Salut, habrozhiteli! L'apprentissage par renforcement est le domaine le plus populaire et prometteur de l'intelligence artificielle. L'apprentissage pratique du RL en Python vous aidera à maîtriser non seulement les algorithmes de base, mais également les apprentissages approfondis avancés avec renforcement. Ce livre est destiné aux développeurs de MO et aux passionnés de deep learning qui s'intéressent à l'intelligence artificielle et souhaitent apprendre la méthode d'apprentissage par renforcement. Lisez ce livre et devenez un expert de l'apprentissage renforcé en mettant en œuvre des exemples pratiques au travail ou hors du travail. Des connaissances en algèbre linéaire, en analyse mathématique et en langage de programmation Python vous aideront à comprendre la logique de la présentation.
Extrait. Génération de paroles à l'aide de LSTM RNN
Voyons maintenant comment utiliser LSTM pour générer des paroles de Zayn Malik. Le jeu de données de paroles de chansons de Zane peut être téléchargé à
https://github.com/sudharsan13296/Hands-On-Reinforcement-Learning-With-Python/blob/master/07.%20Deep%20Learning%20Fundamentals/data/ZaynLyrics.txt .
Le travail commence par l'importation des bibliothèques nécessaires:
import tensorflow as tf import numpy as np
Ensuite, le fichier avec les paroles est lu:
with open("Zayn_Lyrics.txt","r") as f: data=f.read() data=data.replace('\n','') data = data.lower()
Assurez-vous que les données ont bien été téléchargées:
data[:50] "now i'm on the edge can't find my way it's inside "
Maintenant, tous les caractères sont stockés dans la variable all_chars:
all_chars=list(set(data))
Le nombre de caractères uniques est stocké dans unique_chars:
unique_chars = len(all_chars)
Et le nombre total de caractères est stocké dans la variable total_chars:
total_chars =len(data)
Nous attribuons d'abord à chaque caractère un index. char_to_ix contiendra le mappage du caractère à l'index, et ix_to_char contiendra le mappage du caractère à l'index:
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 exemple:
char_to_ix['e'] 9 ix_to_char[9] e
Ensuite, la fonction generate_batch est définie, ce qui génère les valeurs d'entrée et cible. Les valeurs cibles sont égales au décalage de la valeur d'entrée fois i.
Par exemple, si input = [12,13,24] avec une valeur de décalage de 1, alors les valeurs cibles seront [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
Nous déterminerons la longueur de la séquence, la vitesse d'apprentissage et le nombre de nœuds, qui est égal au nombre de neurones:
seq_length = 25 learning_rate = 0.1 num_nodes = 300
Construisez le LSTM RNN. TensorFlow fournit la fonction BasicLSTMCell () pour construire des cellules LSTM; vous devez spécifier le nombre d'unités dans la cellule LSTM et le type de fonction d'activation utilisé.
Ainsi, nous créons la cellule LSTM et construisons le réseau RNN avec cette cellule en utilisant la fonction tf.nn.dynamic_rnn (), qui renvoie la sortie et la valeur d'état:
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
Créez maintenant un substitut pour l'entrée X et la cible Y:
X=tf.placeholder(tf.float32,[None,1]) Y=tf.placeholder(tf.float32,[None,1])
Convertissez X et Y en int:
X=tf.cast(X,tf.int32) Y=tf.cast(Y,tf.int32)
Créez également des vues onehot pour X et Y:
X_onehot=tf.one_hot(X,unique_chars) Y_onehot=tf.one_hot(Y,unique_chars)
Obtenez les sorties et les états du RNN en appelant la fonction build_rnn:
outputs,states=build_rnn(X_onehot)
Transposer la sortie:
outputs=tf.transpose(outputs,perm=[1,0,2])
Nous initialisons les poids et les décalages:
W=tf.Variable(tf.random_normal((num_nodes,unique_chars),stddev=0.001)) B=tf.Variable(tf.zeros((1,unique_chars)))
Nous calculons la sortie en multipliant la sortie par le poids et en ajoutant le décalage:
Ys=tf.matmul(outputs[0],W)+B
Nous allons maintenant effectuer une activation softmax et obtenir les probabilités:
prediction = tf.nn.softmax(Ys)
La perte de cross_entropy sera calculée comme suit:
cross_entropy=tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(labels =Y_onehot,logits=Ys))
Notre objectif est de minimiser les pertes, nous allons donc effectuer une rétropropagation pour le réseau et effectuer une descente de gradient:
optimiser = tf.train.GradientDescentOptimizer(learning_rate=learning_rate).minimize(cro ss_entropy)
Ensuite, la fonction auxiliaire prédite sera définie, ce qui donnera les indices du prochain symbole prédit conformément au modèle 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
Ensuite, la taille du paquet batch_size, le nombre de paquets et le nombre d'eras, ainsi que la valeur de décalage pour générer le paquet seront définis:
batch_size=100 total_batch=int(total_chars//batch_size) epochs=1000 shift=0
Enfin, nous créons une session TensorFlow et construisons un modèle:
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
Comme vous pouvez le voir sur les résultats, à l'ère initiale, la sortie se compose de caractères aléatoires, mais comme vous l'apprenez, les résultats s'améliorent:
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!
À propos de l'auteur
Sudharsan Ravichandiran est un spécialiste du traitement et de l'analyse des données, un ardent fan de l'intelligence artificielle et un blogueur vidéo. Il a obtenu un baccalauréat en informatique de l'Université Anne et mène des recherches sur la mise en œuvre pratique de l'apprentissage en profondeur et de l'apprentissage renforcé, y compris le traitement du langage naturel et la vision par ordinateur. Auparavant, il a travaillé en tant que concepteur et développeur Web indépendant, a participé à la création de plusieurs sites primés. Il participe actuellement à des projets open source et répond souvent aux questions sur
Stack Overflow .
À propos des rédacteurs scientifiques
Sujit Pal est directeur de la recherche technique chez Elsevier Labs, la dernière équipe de développement technologique du groupe Reed-Elsevier. Il est engagé dans la recherche dans le domaine de la recherche sémantique, du traitement du langage naturel, de la machine et du deep learning. Chez Elsevier, il a travaillé sur plusieurs projets d'initiative, notamment l'évaluation et l'amélioration de la qualité de la recherche, la classification des images et l'identification des doublons, l'annotation et le développement d'anthologies de textes médicaux et scientifiques. Il a écrit un livre d'apprentissage approfondi avec Antonio Gulli et écrit sur la technologie sur son blog
Salmon Run .
Suriyadeepan Ramamoorthy est un chercheur et ingénieur en intelligence artificielle d'un chercheur et ingénieur en intelligence artificielle à Pondichéry (Inde). Le sujet principal de son travail est la compréhension des langues naturelles et la formation du raisonnement. Il écrit beaucoup sur un blog d'apprentissage en profondeur. Chez SAAMA Technologies, il utilise des méthodes avancées d'apprentissage en profondeur pour analyser des textes biomédicaux. Fervent partisan du logiciel libre, il participe activement à des projets pour son développement dans la communauté FSFTN. Il s'intéresse également aux réseaux collaboratifs, à la visualisation de données et à la programmation créative.
»Plus d'informations sur le livre sont disponibles sur
le site Web de l'éditeur»
Contenu»
Extrait25% de réduction sur les colporteurs -
PythonLors du paiement de la version papier du livre, un livre électronique est envoyé par e-mail.