Python: Tiefes Lernen in der Verarbeitung natürlicher Sprache: Grundlagen

Tiefes Lernen in der Verarbeitung natürlicher Sprache

Deep Learning wird für verschiedene Aufgaben verwendet, z. B. die folgenden bei der Verarbeitung natürlicher Sprache.

Maschinelle Übersetzung, die Sätze in verschiedene Sprachen übersetzt
Automatische Zusammenfassung, die nur wichtige Informationen extrahiert
Maschinenlesen, das anhand von Dokumenten und Fragen antwortet
Ein System, das Fragen zu Bildern beantwortet
etc

All dies sind Bereiche, an denen Forscher und bekannte IT-Unternehmen auf der ganzen Welt aktiv arbeiten. Deep Learning wird fast immer in den neuesten Methoden verwendet, die für diese verwendet werden. Daher für diejenigen, die versuchen, Forschung und Geschäfte im Zusammenhang mit der Verarbeitung natürlicher Sprache zu betreiben Man kann sagen, dass das Erlernen von Deep Learning und neuronalen Netzen fast unverzichtbar ist.

Warum wird Deep Learning in der Verarbeitung natürlicher Sprache so eingesetzt? Um Wörter auf einem Computer verarbeiten zu können, müssen sie unbedingt in numerische Werte umgewandelt werden. Als klassischer Weg

One hot vector
TFIDF

Und so weiter.

Tatsächlich sind diese einfach zu erledigen, daher ist dies eine gute Möglichkeit, um loszulegen, wenn Sie etwas mit der Verarbeitung natürlicher Sprache tun möchten.

Aber in diesen Vektoren

① Spärlichkeit
Die Vektordimensionen können zwischen Zehntausenden und Hunderttausenden liegen und haben häufig nicht genügend Speicher.

② Ich kann mit der Bedeutung nicht umgehen
Alle Wörter unterscheiden sich nur durch ihre Häufigkeit und verlieren ihre Individualität.

Es gibt Probleme wie.

Wenn Sie also ein neuronales Netzwerkmodell verwenden Weil der Wortvektor durch das Fehlerrückausbreitungsverfahren gelernt werden kann

Embedding(Jedem Wort einen Vektor mit nur wenigen hundert Dimensionen zuweisen)Einfach gut

Darüber hinaus, weil Sie den Vektor von Wörtern lernen können, während Sie den Kontext betrachten Wenn die Wörter ähnliche Bedeutungen haben, können ähnliche Vektoren erhalten werden. Im Vergleich zu TFIDF usw. hat es den Vorteil, mit der Bedeutung von Wörtern umgehen zu können.

Embedding

Einbetten bedeutet auf Japanisch "eingebettet".

In der Verarbeitung natürlicher Sprache durch tiefes Lernen wird das Symbol "Wort" verwendet. Das Einbetten erfolgt durch Einbetten in einen d-dimensionalen Vektor (d beträgt etwa 100 bis 300).

Das Einbetten ist das erste, was Sie tun müssen, wenn Sie ein Modell für ein neuronales Netzwerk erstellen, das Wörter verarbeitet.

In Keras gibt es eine Einbettungsschicht, die wie folgt verwendet werden kann.

from keras.models import Sequential
from keras.layers.embeddings import Embedding

vocab_size = 1000 #Anzahl der zu behandelnden Vokabeln
embedding_dim = 100 #Wortvektordimensionen
seq_length = 20 #Satzlänge

model = Sequential()
model.add(Embedding(input_dim=vocab_size, output_dim=embedding_dim, input_length=seq_length))

Die Werte, die hier angegeben werden müssen, sind input_dim, output_dim und input_length.

input_dim:Anzahl der Vokabeln, Anzahl der Worttypen
output_dim:Wortvektordimensionen
input_length:Länge jedes Satzes

Kombinierte Wortvektoren aller Wörter

Ein Beispiel für die sogenannte Einbettungsmatrix ist in der Abbildung dargestellt.

Weisen Sie jedem Wort eine eindeutige ID zu Es bezieht sich auf die Zeile, in der sich die ID in der Einbettungsmatrix befindet. (ID = 0 ist die 0. Zeile, ID = i ist die i-Zeile.)

Und der Vektor jedes Wortes entspricht der Zeile der Einbettungsmatrix. Die horizontale Länge d der Einbettungsmatrix entspricht der Dimension des Wortvektors.

Für den Wert jeder Zelle speichert Keras automatisch einen zufälligen Wert. Auch wie in der Abbildung gezeigt

In den meisten Fällen wird Zeile 0 unk oder Unbekannt zugewiesen.

Der Grund für die Verwendung von unk besteht darin, das zu handhabende Vokabular und alle anderen Nebenwörter einzuschränken Dies dient zum Speichern von Speicher, indem Sie ihn auf Unbekannt setzen. Wie man den Wortschatz einschränkt Es ist üblich, nur diejenigen zu behandeln, die häufiger im zu behandelnden Korpus (Dokument) erscheinen.

Die Eingabe in die Einbettung ist eine Matrix, die aus IDs besteht, die Wörtern zugewiesen sind Die Größe sollte sein (Stapelgröße, Satzlänge).

Hier repräsentiert die Stapelgröße die Anzahl der Daten (Anweisungen), die gleichzeitig parallel berechnet werden.

Die Satzlänge muss für alle Daten gleich sein. Das Problem hierbei ist, dass die Länge des Satzes nicht konstant ist. Daher wird die Länge des Satzes willkürlich auf D gesetzt.

Anweisungen kleiner oder gleich der Länge D addieren 0, so dass die Länge D ist
Entfernen Sie bei Sätzen, die länger als D sind, das Wort vom Ende, sodass die Länge D beträgt.

Dies wird üblicherweise als Polsterung bezeichnet

Hier ist ein Anwendungsbeispiel.

import numpy as np
from keras.models import Sequential
from keras.layers.embeddings import Embedding


batch_size = 32 #Chargengröße
vocab_size = 1000 #Anzahl der zu behandelnden Vokabeln
embedding_dim = 100 #Wortvektordimensionen
seq_length = 20 #Satzlänge

#Ursprünglich war es notwendig, das Wort in ID umzuwandeln, aber diesmal habe ich die Eingabedaten einfach vorbereitet.
input_data = np.arange(batch_size * seq_length).reshape(batch_size, seq_length)

#Fügen Sie dem Modell Einbettung hinzu.
model = Sequential()
model.add(Embedding(input_dim=vocab_size, output_dim=embedding_dim, input_length=seq_length))

# input_Überprüfen Sie, wie sich die Form der Daten ändert.
output = model.predict(input_data)
print(output.shape)

RNN

In diesem Abschnitt erfahren Sie mehr über RNN.

RNN ist eine Abkürzung für Recurrent Neural Network
Übersetzt als "rekursives neuronales Netz" auf Japanisch.

Hervorragend geeignet für die Verarbeitung von Serien variabler Länge, dh Eingabezeichenfolgen beliebiger Länge Es ist ein wichtiger Mechanismus, der häufig in der Verarbeitung natürlicher Sprache verwendet wird.

Neben der Sprache können Zeitreihendaten verwendet werden, sodass sie für eine Vielzahl von Zwecken wie die Spracherkennung verwendet werden können.

Wiederkehrend bedeutet "Wiederholen".

RNN bedeutet also "repetitives" neuronales Netzwerk.

Die einfachste RNN wird durch die folgende Formel ausgedrückt.

Hier wird t oft als Zeit ausgedrückt. xt ist die Eingabe der Zeit t, ht ist der verborgene Zustandsvektor der Zeit t, yt ist die Ausgabe der Zeit t Alle drei sind Vektoren.

Für h0 wird häufig ein Nullvektor verwendet.

f und g sind Aktivierungsfunktionen wie die Sigmoidfunktion.

Wh, Wy, U und bh sind lernbare Matrizen bzw. Verzerrungen.

Eine einfache Abbildung sieht wie in der Abbildung aus.

Es gibt viele andere als die oben eingeführten Varianten von RNN. Die Grundstruktur ist wie in der Abbildung gezeigt.

Außerdem müssen Sie sich bei der Verwendung von Keras nicht an diese strengen Definitionen erinnern. Denken Sie daran, dass Sie die Eingabespalten nacheinander eingeben und jeweils den verborgenen Zustandsvektor und die Ausgabe abrufen.

Sie können wie jedes andere neuronale Netz auch mehrere Ebenen auf dem RNN stapeln.

LSTM

Was ist LSTM?

LSTM ist eine Art von RNN, und LSTM verfügt über einen Mechanismus, um die für RNN typischen Mängel auszugleichen.

Ich werde die Nachteile erklären, die RNN eigen sind. RNN ist ein neuronales Netz, das tief in der Zeitrichtung liegt. Berücksichtigen Sie daher die zuvor eingegebenen Werte. Es wird gesagt, dass es schwierig ist, Parameter zu trainieren, das heißt, es ist nicht gut im Langzeitgedächtnis.

Sinnlich "vergisst" RNN die zuvor eingegebenen Elemente.

LSTM ist ein bekannter Mechanismus, um dies zu verhindern.

Was ist LSTM? Long Short-Abkürzung für Term Memory
Wie der Name schon sagt, ermöglicht es das Langzeitgedächtnis und das Kurzzeitgedächtnis.

Weit verbreitet bei Forschern auf der ganzen Welt.

LSTM führte das Konzept des "Gates" in RNN ein. Eine Art RNN mit einem Gate. Dieses Gate ermöglicht das Langzeit- und Kurzzeitgedächtnis.

Der Umriss von LSTM ist wie in der Abbildung gezeigt.

Das Innere von LSTM wird durch die folgende Formel beschrieben. (Keine Notwendigkeit, sich zu erinnern.)

• ⊙ repräsentiert die Multiplikation jedes Elements und des Adamal-Produkts.

Hier wird i das Eingangsgatter genannt, f wird das Vergessengatter genannt und o wird das Ausgangsgatter genannt.

Beachten Sie, dass die Sigmoid-Funktion für die Aktivierungsfunktion dieser Gates verwendet wird. Was ist die Sigmoidfunktion?

Das ist. Die Ausgabe dieser Gatter ist also eine Zahl zwischen 0 und 1.

Das i des Eingangsgatters wird für jedes Element mit ¯ht multipliziert. Sie können sehen, dass wir anpassen, wie viele Informationen von der Eingabe zum Zeitpunkt t übertragen werden. Wie der Name schon sagt, stammt das Tor aus dem Bild eines "Tors".

Das Vergessenstor f wird für jedes Element mit ct-1 multipliziert. Wir passen an, wie viele Informationen bis zum Zeitpunkt t-1 bis zum Zeitpunkt t übertragen werden (= wie viele vergangene Informationen vergessen werden).

Und o des Ausgangsgatters ist von ct, das die Informationen vom Zeitpunkt 1 bis t enthält Wir passen an, wie viele Informationen als Ausgabe des versteckten Zustandsvektors verwendet werden.

Dies ist das Gesamtbild von LSTM zur Entwicklung des Kurzzeitgedächtnisses und des Langzeitgedächtnisses.

Implementierung von LSTM

Ich werde LSTM mit Keras sofort implementieren. keras verfügt über ein Modul, das die Verwendung von LSTM vereinfacht Sie können LSTM verwenden, ohne die beschriebenen Formeln zu kennen.

Insbesondere wird es wie folgt verwendet.

from keras.layers.recurrent import LSTM

units = 200

lstm = LSTM(units, return_sequences=True)

Hier ist Einheiten die Anzahl der Dimensionen des verborgenen Zustandsvektors von LSTM. Normalerweise sollte es zwischen 100 und 300 liegen.

Je mehr Parameter Sie lernen müssen, desto komplexer können Sie Phänomene modellieren. Es ist schwierig, um diesen Betrag zu lernen (der Speicherverbrauch steigt, die Lernzeit ist lang).

Es ist eine gute Idee, es an die Lernumgebung anzupassen.

Und dieses Mal

return_Geben Sie ein Argument namens Sequenzen an.

Dies ist ein Argument, um zu entscheiden, wie die Ausgabe von LSTM formatiert werden soll.

return_Wenn Sequenzen wahr sind
LSTM gibt die Ausgangsreihen (versteckte Zustandsvektoren h1h1 bis hThT) aus, die allen Eingangsreihen entsprechen.

return_Wenn Sequenzen falsch sind
LSTM gibt beim letzten Mal nur den verborgenen Zustandsvektor T aus.

Wir werden alle Ausgabesequenzen in einem späteren Kapitel verwenden, daher lassen wir return_sequences hier auf True gesetzt.

Die Modellkonstruktionsmethode ist in Verbindung mit Embedding wie folgt.

from keras.models import Sequential
from keras.layers.embeddings import Embedding
from keras.layers.recurrent import LSTM

vocab_size = 1000 #Anzahl der zu behandelnden Vokabeln
embedding_dim = 100 #Wortvektordimensionen
seq_length = 20 #Satzlänge
lstm_units = 200 #Anzahl der Dimensionen des verborgenen Zustandsvektors von LSTM

model = Sequential()
model.add(Embedding(input_dim=vocab_size, output_dim=embedding_dim))
model.add(LSTM(lstm_units, return_sequences=True))

Klicken Sie hier für Anwendungsbeispiele

import numpy as np
from keras.models import Sequential
from keras.layers.embeddings import Embedding
from keras.layers.recurrent import LSTM


batch_size = 32 #Chargengröße
vocab_size = 1000 #Anzahl der zu behandelnden Vokabeln
embedding_dim = 100 #Wortvektordimensionen
seq_length = 20 #Satzlänge
lstm_units = 200 #Anzahl der Dimensionen des verborgenen Zustandsvektors von LSTM

#Auch diesmal habe ich die Eingabedaten problemlos vorbereitet.
input_data = np.arange(batch_size * seq_length).reshape(batch_size, seq_length)

#Fügen Sie dem Modell LSTM hinzu
model = Sequential()
model.add(Embedding(input_dim=vocab_size, output_dim=embedding_dim, input_length=seq_length))
model.add(LSTM(lstm_units,return_sequences=True))

# input_Überprüfen Sie, wie sich die Form der Daten ändert.
output = model.predict(input_data)
print(output.shape)

BiLSTM

Bisher geben Sie die Reihe x = {x1, ..., xT} in RNN ein, einschließlich LSTM von x1 Ich habe in der Reihenfolge von Anfang an über xT eingegeben.

Im Gegensatz zur Vergangenheit können Sie auch von hinten von xT nach x1 eingeben.

Kombiniert zwei weitere Eingaberichtungen

Bidirektionales rekursives neuronales Netz (bi-Richtungs wiederkehrendes neuronales Netzwerk) wird häufig verwendet.

Dies hat den Vorteil, dass die Informationen von Anfang an und die Informationen jeweils von hinten weitergegeben werden. Das heißt, die Informationen der gesamten Eingabeserie können berücksichtigt werden.

Und die, die das LSTM in zwei Richtungen verbindet

Bidirektionales LSTM, allgemein bekannt als BiLSTM.

Der Umriss ist wie in der Abbildung gezeigt.

Es gibt verschiedene Möglichkeiten, RNNs in zwei Richtungen zu verbinden, aber ich werde Ihnen zeigen, wie Sie sie implementieren, bevor ich sie erkläre.

from keras.layers.recurrent import LSTM
from keras.layers.wrappers import Bidirectional

bilstm = Bidirectional(LSTM(units, return_sequences=True), merge_mode='sum')

Es kann einfach implementiert werden, indem LSTM auf diese Weise als Argument verwendet wird.

Ein weiteres Argument, merge_mode, ist die Angabe, wie bidirektionale LSTMs verbunden werden sollen. Grundsätzlich wählen Sie aus {'sum', 'mul', 'concat', 'ave'}.

sum:Elementsumme
mul:Element Produkt
concat:Beitreten
ave:durchschnittlich
None:Gibt die Liste ohne Zusammenführung zurück

Klicken Sie hier für ein Beispiel

import numpy as np
from keras.models import Sequential
from keras.layers.embeddings import Embedding
from keras.layers.recurrent import LSTM
from keras.layers.wrappers import Bidirectional


batch_size = 32 #Chargengröße
vocab_size = 1000 #Anzahl der zu behandelnden Vokabeln
embedding_dim = 100 #Wortvektordimensionen
seq_length = 20 #Satzlänge
lstm_units = 200 #Anzahl der Dimensionen des verborgenen Zustandsvektors von LSTM

#Auch diesmal habe ich die Eingabedaten problemlos vorbereitet.
input_data = np.arange(batch_size * seq_length).reshape(batch_size, seq_length)

#BiLSTM zum Modell hinzugefügt.
model = Sequential()
model.add(Embedding(input_dim=vocab_size, output_dim=embedding_dim, input_length=seq_length))
model.add(Bidirectional(LSTM(lstm_units, return_sequences=True), merge_mode='concat'))

# input_Überprüfen Sie, wie sich die Form der Daten ändert.
output = model.predict(input_data)
print(output.shape)

Softmax-Funktion

Es ist ein bisschen abseits des Themas, aber gewöhnen wir uns an die Arbeit mit der Softmax-Funktion.

Die Softmax-Funktion ist eine Art Aktivierungsfunktion Es wird in der Schicht verwendet, die bei der Klassifizierung der Ausgabe des neuronalen Netzes am nächsten liegt.

Die Definition der Softmax-Funktion ist die Eingabezeichenfolge x = {x1, ..., xn} (jedes Element ist eine reelle Zahl).

Durch Konvertieren in eine Ausgabezeichenfolge y = {y1, ..., yn} mit dem i-ten Element Wie Sie dieser Definition entnehmen können, lautet die Ausgabespalte y

Treffen. Dies war der Fall, wenn die Eingabespalte eine reelle Zahl war.

Bei der tatsächlichen Implementierung mit Keras

from keras.layers.core import Activation

#x Größe: [Stapelgröße, Anzahl der Klassen]

y = Activation('softmax')(x)

# sum(y[0]) = 1, sum(y[1]) = 1, ...

Wenden Sie die Softmax-Funktion für jede Charge an und verwenden Sie sie.

Dies ist die Standardeinstellung für die Aktivierung ('softmax'). Dies liegt daran, dass Softmax auf der Achse der Anzahl der Klassen wirkt, die das letzte Element der Größe der Eingabe x ist.

Das heißt, die Größe von x ist[Stapelgröße, d, Anzahl der Klassen]Auch wenn es 3D ist
Activation('softmax')Anwendbar.

Nebenbei bemerkt, wie man ein solches Modell schreibt, ohne keras.models.Sequential zu verwenden

Es heißt Functional API.

Klicken Sie hier für Anwendungsbeispiele

import numpy as np
from keras.layers import Input
from keras.layers.core import Activation
from keras.models import Model


x = Input(shape=(20, 5))
#Handle Softmax auf x
y = Activation('softmax')(x)

model = Model(inputs=x, outputs=y)

sample_input = np.ones((12, 20, 5))
sample_output = model.predict(sample_input)

print(np.sum(sample_output, axis=2))

Attention

Was ist Aufmerksamkeit?

Angenommen, Sie haben zwei Sätze s = {s1, ..., sN}, t = {t1, ..., tL}.

Hier sei ein Fragensatz und kein Kandidatensatz.

Wie kann die Maschine zu diesem Zeitpunkt automatisch feststellen, ob t als Antwort auf s gültig ist?

Egal wie viel Sie t alleine betrachten, Sie können nicht sagen, ob t gültig ist oder nicht. Sie müssen sich auf die Informationen in s beziehen, um festzustellen, ob t gültig ist.

Hier bietet sich der Aufmerksamkeitsmechanismus an.

In den vorherigen Kapiteln haben Sie gelernt, dass Anweisungen von RNN in versteckte Zustandsvektoren konvertiert werden können.

Bereiten Sie insbesondere zwei separate RNNs vor und verwenden Sie eine RNN. Versteckter Zustandsvektor s In das andere RNN konvertiert und von diesem ausgeblendet Kann konvertiert werden zu.

Um die Information von t unter Berücksichtigung der Information von s zu jedem Zeitpunkt von t wie folgt zu verwenden. Berechnen Sie die Merkmale unter Berücksichtigung des verborgenen Zustandsvektors zu jedem Zeitpunkt von s.

Auf diese Weise wird berechnet, wo zu jedem Zeitpunkt der Zielserie t in der Referenzquellenreihe s "Aufmerksamkeit" zu erregen ist. Sie können die Informationen der Zielserie flexibel extrahieren, während Sie die Informationen der Referenzquellenserie berücksichtigen.

Der Umriss ist wie in der Abbildung gezeigt.

Die Abbildung zeigt den Fall einer unidirektionalen RNN, aber die Aufmerksamkeit kann auch für eine bidirektionale RNN angewendet werden.
Ebenfalls
Die Aufmerksamkeit kann auch dann angewendet werden, wenn die maximale Zeit (Gesamtzahl der verborgenen Zustandsvektoren) der Referenzquelle und des Ziel-RNN unterschiedlich ist.

Dieser Mechanismus namens Aufmerksamkeit ist eine wichtige Technik, die üblicherweise in der Verarbeitung natürlicher Sprache durch tiefes Lernen verwendet wird.

Es erscheint häufig in maschinellen Übersetzungen, automatischen Zusammenfassungen und Dialogpapieren.

Historisch gesehen hat seine Nützlichkeit seit seiner ersten Verwendung in der maschinellen Übersetzung breite Anerkennung gefunden.

Auch dieses Mal verwenden wir den gewichteten Durchschnitt des verborgenen Zustandsvektors von s.

Ich habe Soft Attention eingeführt

Wählen Sie zufällig einen versteckten Zustandsvektor aus

Harte Aufmerksamkeit gibt es auch.

Es ist auch davon abgeleitet und kann im Bereich der Bilderkennung eingesetzt werden.

Darunter von Google angekündigt

Das Papier Achtung ist alles was Sie brauchen ist sehr berühmt.

Umsetzung der Aufmerksamkeit

Aufmerksamkeit mit Keras implementieren

Sie müssen die Ebene Zusammenführen verwenden.

Da Keras Version 2.0 oder höher das bis zum vorherigen Kapitel verwendete sequentielle Modell nicht zusammenführen kann,

Hier verwenden wir die funktionale API von keras. Die einfache Verwendung der funktionalen API ist wie folgt.

Im sequentiellen Modell haben wir gerade neue Ebenen hinzugefügt.

Mithilfe der Funktions-API können Sie komplexe Modelle freier erstellen.

from keras.layers import Input, Dense
from keras.layers.embeddings import Embedding
from keras.layers.recurrent import LSTM
from keras.layers.wrappers import Bidirectional
from keras.layers.merge import dot, concatenate
from keras.layers.core import Activation
from keras.models import Model

batch_size = 32 #Chargengröße
vocab_size = 1000 #Anzahl der zu behandelnden Vokabeln
embedding_dim = 100 #Wortvektordimensionen
seq_length1 = 20 #Länge des Satzes 1
seq_length2 = 30 #Länge von Satz 2
lstm_units = 200 #Anzahl der Dimensionen des verborgenen Zustandsvektors von LSTM
hidden_dim = 200 #Anzahl der Dimensionen des endgültigen Ausgabevektors

input1 = Input(shape=(seq_length1,))
embed1 = Embedding(input_dim=vocab_size, output_dim=embedding_dim, input_length=seq_length1)(input1)
bilstm1 = Bidirectional(LSTM(lstm_units, return_sequences=True), merge_mode='concat')(embed1)

input2 = Input(shape=(seq_length2,))
embed2 = Embedding(input_dim=vocab_size, output_dim=embedding_dim, input_length=seq_length2)(input2)
bilstm2 = Bidirectional(LSTM(lstm_units, return_sequences=True), merge_mode='concat')(embed2)

#Berechnen Sie das Produkt für jedes Element
product = dot([bilstm2, bilstm1], axes=2) #Produktgröße:[Chargengröße, Länge von Satz 2, Länge von Satz 1]

a = Activation('softmax')(product)
c = dot([a, bilstm1], axes=[2, 1])
c_bilstm2 = concatenate([c, bilstm2], axis=2)
h = Dense(hidden_dim, activation='tanh')(c_bilstm2)

model = Model(inputs=[input1, input2], outputs=h)

Da jede Schicht auf diese Weise wie eine Funktion verwendet wird, wird sie als funktionale API bezeichnet.

Achten Sie auch darauf, die Stapelgröße nicht in die Form zu bringen, die in der neu eingeführten Eingabeebene angegeben ist.

Wenn Sie ein Modell definieren, müssen Sie Ein- und Ausgaben als Argumente angeben.

Wenn Sie mehrere Ein- und Ausgänge haben, können Sie diese in eine Liste aufnehmen und übergeben.

Und der neue Punkt([u, v], axes=2)Berechnet das Batch-Matrix-Produkt von u und v.

Die Anzahl der Dimensionen in den angegebenen Achsen muss für u und v gleich sein.

Auch Punkt([u, v], axes=[1,2])Dann u 1. Dimension und v 2. Dimension
Sie können auch verschiedene Dimensionen angeben, z.

Lassen Sie uns nun Attention mithilfe der Funktions-API implementieren, die auf der folgenden Formel basiert.

Klicken Sie hier für Anwendungsbeispiele

import numpy as np
from keras.layers import Input, Dense
from keras.layers.embeddings import Embedding
from keras.layers.recurrent import LSTM
from keras.layers.wrappers import Bidirectional
from keras.layers.merge import dot, concatenate
from keras.layers.core import Activation
from keras.models import Model

batch_size = 32 #Chargengröße
vocab_size = 1000 #Anzahl der zu behandelnden Vokabeln
embedding_dim = 100 #Wortvektordimensionen
seq_length1 = 20 #Länge des Satzes 1
seq_length2 = 30 #Länge von Satz 2
lstm_units = 200 #Anzahl der Dimensionen des verborgenen Zustandsvektors von LSTM
hidden_dim = 200 #Anzahl der Dimensionen des endgültigen Ausgabevektors

#Um die Einbettungsschicht zu verwenden, die den beiden LSTMs gemeinsam ist, definieren Sie zunächst die Einbettungsschicht.
embedding = Embedding(input_dim=vocab_size, output_dim=embedding_dim)

input1 = Input(shape=(seq_length1,))
embed1 = embedding(input1)
bilstm1 = Bidirectional(LSTM(lstm_units, return_sequences=True), merge_mode='concat')(embed1)

input2 = Input(shape=(seq_length2,))
embed2 = embedding(input2)
bilstm2 = Bidirectional(LSTM(lstm_units, return_sequences=True), merge_mode='concat')(embed2)

#Berechnen Sie das Produkt für jedes Element
product = dot([bilstm2, bilstm1], axes=2) #Größe:[Chargengröße, Länge von Satz 2, Länge von Satz 1]

#Implementieren Sie hier den Aufmerksamkeitsmechanismus
a = Activation('softmax')(product)
c = dot([a, bilstm1], axes=[2, 1])
c_bilstm2 = concatenate([c, bilstm2], axis=2)
h = Dense(hidden_dim, activation='tanh')(c_bilstm2)


model = Model(inputs=[input1, input2], outputs=h)

sample_input1 = np.arange(batch_size * seq_length1).reshape(batch_size, seq_length1)
sample_input2 = np.arange(batch_size * seq_length2).reshape(batch_size, seq_length2)

sample_output = model.predict([sample_input1, sample_input2])
print(sample_output.shape)

Dropout

Ein Ausfall erfolgt durch zufälliges Setzen einiger Variablen während des Trainings auf 0. Dies ist eine Methode zur Verbesserung der Generalisierungsleistung und zur Verhinderung von Überlernen.

① Was ist Überlernen?

Bei der Durchführung eines überwachten Lernens mit einem Modell wie einem neuronalen Netz
Oft zu fit für Trainingsdaten
Dies führt zu "Überlernen", bei dem die Leistung der Bewertungsdaten erheblich niedriger ist als die der Trainingsdaten.

② Was ist Generalisierungsleistung?

Unabhängig von Trainingsdaten und Bewertungsdaten, ohne mit Trainingsdaten zu übertrainieren
Im Allgemeinen wird eine hohe Leistung als "Generalisierungsleistung" bezeichnet.

Wenn Sie es tatsächlich verwenden, setzen Sie das Verhältnis der Variablen auf 0 mit einem Wert zwischen 0 und 1. Fügen Sie eine Dropout-Ebene hinzu.

#Bei Verwendung des sequentiellen Modells
from keras.models import Sequential
from keras.layers import Dropout


model = Sequential()

...

model.add(Dropout(0.3))

#Bei Verwendung der funktionalen API
from keras.layers import Dropout

y = Dropout(0.3)(x)

Klicken Sie hier für Anwendungsbeispiele

import numpy as np
from keras.layers import Input, Dropout
from keras.layers.embeddings import Embedding
from keras.layers.recurrent import LSTM
from keras.layers.wrappers import Bidirectional
from keras.models import Model

batch_size = 32  #Chargengröße
vocab_size = 1000  #Anzahl der zu behandelnden Vokabeln
embedding_dim = 100  #Wortvektordimensionen
seq_length = 20  #Länge des Satzes 1
lstm_units = 200  #Anzahl der Dimensionen des verborgenen Zustandsvektors von LSTM

input = Input(shape=(seq_length,))

embed = Embedding(input_dim=vocab_size, output_dim=embedding_dim,
                  input_length=seq_length)(input)

bilstm = Bidirectional(
    LSTM(lstm_units, return_sequences=True), merge_mode='concat')(embed)

output = Dropout(0.3)(bilstm)

model = Model(inputs=input, outputs=output)

sample_input = np.arange(
    batch_size * seq_length).reshape(batch_size, seq_length)

sample_output = model.predict(sample_input)

print(sample_output.shape)