Hola habrozhiteli! El aprendizaje por refuerzo es el área más popular y prometedora de la inteligencia artificial. El aprendizaje práctico de RL en Python te ayudará a dominar no solo los algoritmos básicos, sino también los avanzados de aprendizaje profundo con refuerzo. Este libro está destinado a desarrolladores de MO y entusiastas del aprendizaje profundo que estén interesados en la inteligencia artificial y quieran aprender el método de aprendizaje por refuerzo. Lea este libro y conviértase en un experto en aprendizaje reforzado mediante la implementación de ejemplos prácticos dentro o fuera del trabajo. El conocimiento del álgebra lineal, el análisis matemático y el lenguaje de programación Python lo ayudarán a comprender la lógica de la presentación.
Extracto Generando letras usando LSTM RNN
Ahora veamos cómo usar LSTM para generar letras de Zayn Malik. El conjunto de datos de letras de canciones de Zane se puede descargar en
https://github.com/sudharsan13296/Hands-On-Reinforcement-Learning-With-Python/blob/master/07.%20Deep%20Learning%20Fundamentals/data/ZaynLyrics.txt .
El trabajo comienza importando las bibliotecas necesarias:
import tensorflow as tf import numpy as np
Luego se lee el archivo con la letra:
with open("Zayn_Lyrics.txt","r") as f: data=f.read() data=data.replace('\n','') data = data.lower()
Asegúrese de que los datos se hayan cargado correctamente:
data[:50] "now i'm on the edge can't find my way it's inside "
Ahora todos los caracteres se almacenan en la variable all_chars:
all_chars=list(set(data))
El número de caracteres únicos se almacena en unique_chars:
unique_chars = len(all_chars)
Y el número total de caracteres se almacena en la variable total_chars:
total_chars =len(data)
Primero asignamos a cada personaje un índice. char_to_ix contendrá la asignación del carácter al índice, e ix_to_char contendrá la asignación del carácter al índice:
char_to_ix = { ch:i for i,ch in enumerate(all_chars) } ix_to_char = { i:ch for i,ch in enumerate(all_chars) }
Un ejemplo:
char_to_ix['e'] 9 ix_to_char[9] e
Luego se define la función generate_batch, que genera los valores de entrada y de destino. Los valores objetivo son iguales al desplazamiento del valor de entrada multiplicado por i.
Por ejemplo, si input = [12,13,24] con un valor de desplazamiento de 1, los valores objetivo serán [13,24]:
def generate_batch(seq_length,i): inputs = [char_to_ix[ch] for ch in data[i:i+seq_length]] targets = [char_to_ix[ch] for ch in data[i+1:i+seq_length+1]] inputs=np.array(inputs).reshape(seq_length,1) targets=np.array(targets).reshape(seq_length,1) return inputs,targets
Determinaremos la longitud de la secuencia, la velocidad del entrenamiento y el número de nodos, que es igual al número de neuronas.
seq_length = 25 learning_rate = 0.1 num_nodes = 300
Construye el LSTM RNN. TensorFlow proporciona la función BasicLSTMCell () para construir celdas LSTM; debe especificar el número de unidades en la celda LSTM y el tipo de función de activación utilizada.
Entonces, creamos la celda LSTM y construimos la red RNN con esta celda usando la función tf.nn.dynamic_rnn (), que devuelve la salida y el valor de estado:
def build_rnn(x): cell= tf.contrib.rnn.BasicLSTMCell(num_units=num_nodes, activation=tf.nn.relu) outputs, states = tf.nn.dynamic_rnn(cell, x, dtype=tf.float32) return outputs,states
Ahora cree un sustituto para la entrada X y el objetivo Y:
X=tf.placeholder(tf.float32,[None,1]) Y=tf.placeholder(tf.float32,[None,1])
Convierte X e Y a int:
X=tf.cast(X,tf.int32) Y=tf.cast(Y,tf.int32)
También cree vistas onehot para X e Y:
X_onehot=tf.one_hot(X,unique_chars) Y_onehot=tf.one_hot(Y,unique_chars)
Obtenga las salidas y estados del RNN llamando a la función build_rnn:
outputs,states=build_rnn(X_onehot)
Transponer la salida:
outputs=tf.transpose(outputs,perm=[1,0,2])
Inicializamos los pesos y las compensaciones:
W=tf.Variable(tf.random_normal((num_nodes,unique_chars),stddev=0.001)) B=tf.Variable(tf.zeros((1,unique_chars)))
Calculamos la salida multiplicando la salida por el peso y agregando el desplazamiento:
Ys=tf.matmul(outputs[0],W)+B
Ahora realizaremos la activación de softmax y obtendremos las probabilidades:
prediction = tf.nn.softmax(Ys)
La pérdida de cross_entropy se calculará de la siguiente manera:
cross_entropy=tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(labels =Y_onehot,logits=Ys))
Nuestro objetivo es minimizar la pérdida, por lo que realizaremos la propagación hacia atrás para la red y realizaremos el descenso de gradiente:
optimiser = tf.train.GradientDescentOptimizer(learning_rate=learning_rate).minimize(cro ss_entropy)
Luego se definirá la función auxiliar predicción, que dará los índices del próximo símbolo predicho de acuerdo con el modelo RNN:
def predict(seed,i): x=np.zeros((1,1)) x[0][0]= seed indices=[] for t in range(i): p=sess.run(prediction,{X:x}) index = np.random.choice(range(unique_chars), p=p.ravel()) x[0][0]=index indices.append(index) return indices
Luego, se establecerá el tamaño del paquete del tamaño del lote, el número de paquetes y el número de eras, así como el valor de desplazamiento para generar el paquete:
batch_size=100 total_batch=int(total_chars//batch_size) epochs=1000 shift=0
Finalmente, creamos una sesión TensorFlow y construimos un modelo:
init=tf.global_variables_initializer() with tf.Session() as sess: sess.run(init) for epoch in range(epoch): print("Epoch {}:".format(epoch)) if shift + batch_size+1 >= len(data): shift =0
Como puede ver en los resultados, en la era inicial, la salida consta de caracteres aleatorios, pero a medida que aprende, los resultados mejoran:
Epoch 0: Iteration 0: wsadrpud,kpswkypeqawnlfyweudkgt,khdi nmgof' u vnvlmbis . snsblp,podwjqehb,e;g- 'fyqjsyeg,byjgyotsrdf;;u,ha;ik'sfc;dvtauofd.,q.;npsw'wjy-quw'quspfqw- . . . Epoch 113: Iteration 0: i wanna see you, yes, and she said yes!
Sobre el autor
Sudharsan Ravichandiran es especialista en procesamiento y análisis de datos, fanático de la inteligencia artificial y video blogger. Obtuvo una licenciatura en informática de la Universidad de Anne y se dedica a la investigación sobre la implementación práctica del aprendizaje profundo y el aprendizaje reforzado, incluido el procesamiento del lenguaje natural y la visión por computadora. Anteriormente trabajó como diseñador y desarrollador web independiente, participó en la creación de varios sitios galardonados. Actualmente participa en proyectos de código abierto y a menudo responde preguntas sobre
Stack Overflow .
Sobre editores de ciencias
Sujit Pal es Director de Investigación Técnica en Elsevier Labs, el último equipo de desarrollo tecnológico del Grupo Reed-Elsevier. Se dedica a la investigación en el campo de la búsqueda semántica, el procesamiento del lenguaje natural, la máquina y el aprendizaje profundo. En Elsevier, trabajó en varios proyectos de iniciativa, incluida la evaluación y mejora de la calidad de búsqueda, la clasificación de imágenes y la identificación duplicada, anotando y desarrollando antologías de textos médicos y científicos. Escribió un libro de aprendizaje profundo con Antonio Gulli y escribe sobre tecnología en su blog
Salmon Run .
Suriyadeepan Ramamoorthy es un investigador e ingeniero de inteligencia artificial del investigador e ingeniero de IA en Pondicherry (India). El tema principal de su trabajo es comprender los lenguajes naturales y formar razonamientos. Escribe extensamente en un blog de aprendizaje profundo. En SAAMA Technologies, utiliza métodos avanzados de aprendizaje profundo para analizar textos biomédicos. Siendo un ferviente defensor del software libre, participa activamente en proyectos para su desarrollo en la comunidad FSFTN. También está interesado en redes colaborativas, visualización de datos y programación creativa.
»Se puede encontrar más información sobre el libro en
el sitio web del editor»
Contenidos»
ExtractoCupón de 25% de descuento para vendedores ambulantes -
PythonTras el pago de la versión en papel del libro, se envía un libro electrónico por correo electrónico.