Hallo habrozhiteli! Reinforcement Learning ist der beliebteste und vielversprechendste Bereich der künstlichen Intelligenz. Praktisches Lernen RL in Python hilft Ihnen dabei, nicht nur die grundlegenden, sondern auch die fortgeschrittenen Deep-Learning-Algorithmen mit Verstärkung zu beherrschen. Dieses Buch richtet sich an MO-Entwickler und Deep-Learning-Enthusiasten, die sich für künstliche Intelligenz interessieren und die Methode des verstärkenden Lernens erlernen möchten. Lesen Sie dieses Buch und werden Sie ein Experte für verstärktes Lernen, indem Sie praktische Beispiele in oder außerhalb der Arbeit implementieren. Kenntnisse der linearen Algebra, der mathematischen Analyse und der Programmiersprache Python helfen Ihnen, die Logik der Präsentation zu verstehen.
Auszug. Erstellen von Texten mit LSTM RNN
Nun wollen wir sehen, wie man LSTM verwendet, um Zayn Malik-Texte zu generieren. Der Songtext-Datensatz von Zane kann unter
https://github.com/sudharsan13296/Hands-On-Reinforcement-Learning-With-Python/blob/master/07.%20Deep%20Learning%20Fundamentals/data/ZaynLyrics.txt heruntergeladen werden .
Die Arbeit beginnt mit dem Import der erforderlichen Bibliotheken:
import tensorflow as tf import numpy as np
Dann wird die Datei mit den Texten gelesen:
with open("Zayn_Lyrics.txt","r") as f: data=f.read() data=data.replace('\n','') data = data.lower()
Stellen Sie sicher, dass die Daten erfolgreich hochgeladen wurden:
data[:50] "now i'm on the edge can't find my way it's inside "
Jetzt werden alle Zeichen in der Variablen all_chars gespeichert:
all_chars=list(set(data))
Die Anzahl der eindeutigen Zeichen wird in unique_chars gespeichert:
unique_chars = len(all_chars)
Die Gesamtzahl der Zeichen wird in der Variablen total_chars gespeichert:
total_chars =len(data)
Zuerst weisen wir jedem Zeichen einen Index zu. char_to_ix enthält die Zuordnung des Zeichens zum Index und ix_to_char enthält die Zuordnung des Zeichens zum 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) }
Ein Beispiel:
char_to_ix['e'] 9 ix_to_char[9] e
Anschließend wird die Funktion generate_batch definiert, die die Eingabe- und Zielwerte generiert. Die Zielwerte sind gleich der Verschiebung der Eingabewerte mal i.
Wenn beispielsweise Eingabe = [12,13,24] mit einem Verschiebungswert von 1 ist, sind die Zielwerte [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
Wir werden die Länge der Sequenz, die Lerngeschwindigkeit und die Anzahl der Knoten bestimmen, die der Anzahl der Neuronen entspricht:
seq_length = 25 learning_rate = 0.1 num_nodes = 300
Erstellen Sie die LSTM-RNN. TensorFlow bietet die Funktion BasicLSTMCell () zum Erstellen von LSTM-Zellen. Sie müssen die Anzahl der Einheiten in der LSTM-Zelle und die Art der verwendeten Aktivierungsfunktion angeben.
Also erstellen wir die LSTM-Zelle und bauen mit dieser Zelle das RNN-Netzwerk mit der Funktion tf.nn.dynamic_rnn () auf, die die Ausgabe und den Statuswert zurückgibt:
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
Erstellen Sie nun einen Ersatz für Eingabe X und Ziel Y:
X=tf.placeholder(tf.float32,[None,1]) Y=tf.placeholder(tf.float32,[None,1])
Konvertieren Sie X und Y in int:
X=tf.cast(X,tf.int32) Y=tf.cast(Y,tf.int32)
Erstellen Sie auch Onehot-Ansichten für X und Y:
X_onehot=tf.one_hot(X,unique_chars) Y_onehot=tf.one_hot(Y,unique_chars)
Rufen Sie die Ausgaben und Zustände vom RNN ab, indem Sie die Funktion build_rnn aufrufen:
outputs,states=build_rnn(X_onehot)
Transponieren Sie die Ausgabe:
outputs=tf.transpose(outputs,perm=[1,0,2])
Wir initialisieren die Gewichte und Offsets:
W=tf.Variable(tf.random_normal((num_nodes,unique_chars),stddev=0.001)) B=tf.Variable(tf.zeros((1,unique_chars)))
Wir berechnen die Ausgabe, indem wir die Ausgabe mit dem Gewicht multiplizieren und den Versatz addieren:
Ys=tf.matmul(outputs[0],W)+B
Jetzt werden wir die Softmax-Aktivierung durchführen und die Wahrscheinlichkeiten ermitteln:
prediction = tf.nn.softmax(Ys)
Der Verlust von cross_entropy wird wie folgt berechnet:
cross_entropy=tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(labels =Y_onehot,logits=Ys))
Unser Ziel ist es, Verluste zu minimieren, damit wir eine Rückausbreitung für das Netzwerk durchführen und einen Gradientenabstieg durchführen können:
optimiser = tf.train.GradientDescentOptimizer(learning_rate=learning_rate).minimize(cro ss_entropy)
Dann wird die Vorhersage der Hilfsfunktion definiert, die die Indizes des nächsten vorhergesagten Symbols gemäß dem RNN-Modell ergibt:
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
Dann werden die Paketgröße batch_size, die Anzahl der Pakete und die Anzahl der Epochen sowie der Verschiebungswert zum Erzeugen des Pakets festgelegt:
batch_size=100 total_batch=int(total_chars//batch_size) epochs=1000 shift=0
Schließlich erstellen wir eine TensorFlow-Sitzung und erstellen ein Modell:
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
Wie Sie den Ergebnissen entnehmen können, besteht die Ausgabe in der Anfangszeit aus zufälligen Zeichen, aber wie Sie lernen, verbessern sich die Ergebnisse:
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!
Über den Autor
Sudharsan Ravichandiran ist Spezialist für Datenverarbeitung und -analyse,
begeisterter Fan künstlicher Intelligenz und Videoblogger. Er erwarb einen Bachelor-Abschluss in Informatik an der Anne University und forscht an der praktischen Umsetzung von Deep Learning und verstärktem Lernen, einschließlich Verarbeitung natürlicher Sprache und Computer Vision. Zuvor war er als freiberuflicher Webdesigner und Entwickler an der Erstellung mehrerer preisgekrönter Websites beteiligt. Derzeit nimmt er an Open Source-Projekten teil und beantwortet häufig Fragen zum
Stapelüberlauf .
Über Wissenschaftsredakteure
Sujit Pal ist technischer Forschungsdirektor bei Elsevier Labs, dem neuesten Technologieentwicklungsteam der Reed-Elsevier Group. Er forscht auf dem Gebiet der semantischen Suche, der Verarbeitung natürlicher Sprache, des maschinellen und tiefen Lernens. Bei Elsevier arbeitete er an mehreren Initiativprojekten, darunter der Bewertung und Verbesserung der Suchqualität, der Klassifizierung von Bildern und der Identifizierung von Duplikaten sowie der Kommentierung und Entwicklung von Anthologien medizinischer und wissenschaftlicher Texte. Er schrieb mit Antonio Gulli ein Deep-Learning-Buch und schreibt über Technologie in seinem
Salmon Run- Blog.
Suriyadeepan Ramamoorthy ist ein Forscher und Ingenieur für künstliche Intelligenz von einem KI-Forscher und Ingenieur in Pondicherry, Indien. Das Hauptthema seiner Arbeit ist das Verstehen natürlicher Sprachen und das Bilden von Argumenten. Er schreibt ausführlich in einem Deep-Learning-Blog. Bei SAAMA Technologies verwendet er fortgeschrittene Deep-Learning-Methoden, um biomedizinische Texte zu analysieren. Als begeisterter Befürworter freier Software beteiligt er sich aktiv an Projekten zu deren Entwicklung in der FSFTN-Community. Er interessiert sich auch für kollaborative Netzwerke, Datenvisualisierung und kreative Programmierung.
»Weitere Informationen zum Buch finden Sie auf
der Website des Herausgebers»
Inhalt»
Auszug25% Rabatt auf Gutschein für Händler -
PythonNach Bezahlung der Papierversion des Buches wird ein elektronisches Buch per E-Mail verschickt.