Was für ein Artikel?

Für diejenigen, die dies oder jenes für Deep-Learning-Modellierung ausprobieren möchten, aber nicht wissen, wie sie es implementieren sollen Verwendung der funktionalen API von keras als Framework, das relativ flexibel und angemessen abstrahiert ist Versuchen Sie, seq2seq, das mit sequentiellen Funktionen schwierig ist, so einfach wie möglich zu implementieren

Inhaltsverzeichnis

Übersicht
Vorverarbeitung
Modellbau & Lernen (Imakoko)
Inferenz
Modellverbesserung (noch nicht vorgenommen)

Motivation für diesen Artikel

Es stellt sich heraus, dass Keras verwendet werden können, um tiefes Lernen zu implementieren. Welche Art von Code sollte ich speziell schreiben? Ich werde die Frage beantworten.

Was Sie beim Modellbau und Lernen tun müssen

Bei Verwendung von Keras ist es zweckmäßig, die Modellklasse zu verwenden. https://keras.io/ja/models/model/

Die Klasse "Modell" ist dafür verantwortlich, Lernmethoden zu definieren, das Lernen auszuführen und auf ein durch Lernen bestimmtes Modell zu schließen.

Um eine "Modell" -Instanz zu erstellen, muss im Voraus ein Berechnungsdiagramm für das Modell des maschinellen Lernens erstellt werden. Hierfür gibt es zwei Optionen: sequentielle API und funktionale API. Die sequentielle API ist sehr einfach und nützlich, wenn die Verarbeitung der vorherigen Schicht zur Verarbeitung der nächsten Schicht wird. Stattdessen wird die Modellflexibilität beeinträchtigt und kann nicht mit zunehmender Komplexität verwendet werden, z. B. Modelle mit mehreren Eingängen und mehreren Ausgängen. Im Vergleich zur sequentiellen API müssen Sie für die funktionale API die Verbindung zwischen Ebenen selbst definieren, aber Sie können sie flexibler schreiben. Dieses Mal erstellen wir ein Modell mit der funktionalen API.

Sobald Sie ein Berechnungsdiagramm erstellt und eine "Modell" -Instanz erstellt haben, ist der Rest einfach Definition der Lernmethode mit der Kompilierungsmethode der Modellinstanz (Optimierungsmethode, Einstellung der Verlustfunktion usw.) Sie können das Lernen mit der Methode "fit" ausführen.

Modellbildung & Lernimplementierung

Definition des Berechnungsdiagramms

Wir werden das in der folgenden Abbildung gezeigte Modell erstellen

Encoder

Mit dem Encoder gibt es zwei Möglichkeiten: Einbetten des Eingangs und Eingeben in das LSTM. Das Implementierungsbeispiel lautet wie folgt

from keras.layers import Input, LSTM, Dense, Embedding
# Define an input sequence and process it.
encoder_inputs = Input(shape=(max_length_inp,),name='encoder_input')
encoder_inputs_embedding = Embedding(input_dim=vocab_inp_size, output_dim=embedding_dim)(encoder_inputs)
encoder = LSTM(units, return_state=True)
encoder_outputs, state_h, state_c = encoder(encoder_inputs_embedding)
# We discard `encoder_outputs` and only keep the states.
encoder_states = [state_h, state_c]

Die Eingabe in das Modell erfolgt immer über die Ebene "Eingabe". Zu diesem Zeitpunkt wird die maximale Länge der Eingabezeichenfolge "max_length_inp" sofort von "Input" eingegeben. Der RNN-basierte Algorithmus verarbeitet die Eingabedatenzeichenfolgen nacheinander und übergibt sie nacheinander an den nächsten Schritt, kann aber auch auf diese Weise abgekürzt werden.

encoder_inputs_embedding = Embedding(input_dim=vocab_inp_size, output_dim=embedding_dim)(encoder_inputs)

Meint "Definieren Sie die Ebene" Einbetten "mit" input_dim = voc_inp_size, output_dim = embedded_dim "." "Fügen Sie ein Berechnungsdiagramm hinzu, sodass das Ergebnis des Ersetzens von" encoder_inputs "für das definierte" Embedding "" encoder_inputs_embedding "ist." Es bedeutet das.

encoder = LSTM(units, return_state=True)
encoder_outputs, state_h, state_c = encoder(encoder_inputs_embedding)

Sie können die Ebene auch definieren und wie in einer separaten Zeile zum Berechnungsdiagramm hinzufügen, wie in.

Decoder

Es gibt drei Dinge, die mit dem Decoder zu tun haben: Einbetten (zum Erzwingen des Lehrers), LSTM und Dicht für den Decodereingang. Das Implementierungsbeispiel lautet wie folgt

from keras.layers import Input, LSTM, Dense, Embedding
# Set up the decoder, using `encoder_states` as initial state.
decoder_inputs = Input(shape=(max_length_targ-1,),name='decoder_input')
decoder_inputs_embedding  = Embedding(input_dim=vocab_tar_size, output_dim=embedding_dim)(decoder_inputs)
# We set up our decoder to return full output sequences,
# and to return internal states as well. We don't use the
# return states in the training model, but we will use them in inference.
decoder_lstm = LSTM(units, return_sequences=True, return_state=True)
decoder_outputs, _, _ = decoder_lstm(decoder_inputs_embedding,
                                     initial_state=encoder_states)
decoder_dense = Dense(vocab_tar_size, activation='softmax')
decoder_outputs = decoder_dense(decoder_outputs)

Was unterscheidet sich vom Encoder

Form von Eingang ist 1 weniger.
Setzen Sie die Option return_sequences = True von LSTM, um die LSTM-Ausgabe für jeden Schritt zu erhalten
LSTM empfängt den Speicher encoder_states der verborgenen Schicht von LSTM, die vom Encoder erhalten wurde
Es gibt eine "dichte" Ebene. Da es sich um eine Ausgabeschicht handelt, ist "Aktivierung" "Softmax"

Generierung von Modellinstanzen

Wenn Sie zu diesem Punkt kommen, ist der Rest einfach

from keras.models import Model
# Define the model that will turn
# `encoder_input_data` & `decoder_input_data` into `decoder_target_data`
model = Model([encoder_inputs, decoder_inputs], decoder_outputs)

Überprüfen Sie das generierte Modell

from IPython.display import SVG
SVG(model_to_dot(model).create(prog='dot', format='svg'))

Sie können das Berechnungsdiagramm visualisieren, mit dem das Modell dargestellt wird.

Die Zeichnungspositionsbeziehung jeder Ebene unterscheidet sich von der am Anfang gezeigten Abbildung, aber Sie können sehen, dass sie mit einem Netzwerk identisch ist.

Ebenfalls,

model.summary()

Sie können die Anzahl der Parameter für jede Ebene mit überprüfen.


__________________________________________________________________________________________________
Layer (type)                    Output Shape         Param #     Connected to                     
==================================================================================================
encoder_input (InputLayer)      (None, 18)           0                                            
__________________________________________________________________________________________________
decoder_input (InputLayer)      (None, 17)           0                                            
__________________________________________________________________________________________________
embedding_1 (Embedding)         (None, 18, 256)      1699328     encoder_input[0][0]              
__________________________________________________________________________________________________
embedding_2 (Embedding)         (None, 17, 256)      2247168     decoder_input[0][0]              
__________________________________________________________________________________________________
lstm_1 (LSTM)                   [(None, 1024), (None 5246976     embedding_1[0][0]                
__________________________________________________________________________________________________
lstm_2 (LSTM)                   [(None, 17, 1024), ( 5246976     embedding_2[0][0]                
                                                                 lstm_1[0][1]                     
                                                                 lstm_1[0][2]                     
__________________________________________________________________________________________________
dense_1 (Dense)                 (None, 17, 8778)     8997450     lstm_2[0][0]                     
==================================================================================================
Total params: 23,437,898
Trainable params: 23,437,898
Non-trainable params: 0
__________________________________________________________________________________________________

Es wird empfohlen, es während der eigentlichen Modellierung entsprechend zu visualisieren, da es das Debuggen verbessert.

Lernbedingungen festlegen und Lernen ausführen

Ich möchte Adam verwenden, um die Verlustfunktion als Kreuzentropie zu optimieren. Schauen wir uns die Wortgenauigkeit für jede Epoche an.

Ich möchte das Modell alle 5 Epochen speichern.

Das Implementierungsbeispiel lautet wie folgt

model.compile(optimizer='adam', loss='categorical_crossentropy',
              metrics=['accuracy'])

# define save condition
dir_path = 'saved_models/LSTM/'
save_every = 5
train_schedule = [save_every for i in range(divmod(epochs,save_every)[0])]
if divmod(epochs,save_every)[1] != 0:
    train_schedule += [divmod(epochs,save_every)[1]]
    
#run training
total_epochs = 0
for epoch in train_schedule:
    history = model.fit([encoder_input_tensor, decoder_input_tensor], 
                          np.apply_along_axis(lambda x: np_utils.to_categorical(x,num_classes=vocab_tar_size), 1, decoder_target_tensor),
                          batch_size=batch_size,
                          epochs=epoch,
                          validation_split=0.2)
    total_epochs += epoch
    filename = str(total_epochs) + 'epochs_LSTM.h5'
    model.save(dir_path+filename)

Ich mache verschiedene Dinge, aber die einzigen sind "model.compile" und "model.fit". Ich denke, dass nur diese beiden für das Minimum ausreichen.

Übergeben Sie die Optimierungsmethode, die Verlustfunktion und die Bewertungsmetrik als Optionen an "model.compile". Dann wird es mit model.fit gelernt und ausgeführt. Die wichtigsten Parameter für "model.fit" sind die Eingabedaten und die richtigen Antwortdaten. Die richtigen Antwortdaten lauten "np.apply_along_axis (lambda x: np_utils.to_categorical (x, num_classes = vocal_tar_size), 1, decoder_target_tensor)" Dies liegt daran, dass ich jedes Element von "decoder_target_tensor" in ein One-Hot-codiertes Format konvertieren möchte.

Tipps zum Codieren und Debuggen

Fehler können schnell gefunden werden, indem geeignete Visualisierungen vorgenommen werden, um die Konsistenz der Dimensionen zu überprüfen, oder indem bestimmte Werte entsprechend ersetzt werden. Da jede Ebene wie eine Funktion behandelt werden kann, können Sie die Ausgabe des konkreten Werts erhalten, indem Sie den konkreten Wert ersetzen.

Referenz

Der Vorbehandlungsteil ist wie folgt Neuronale maschinelle Übersetzung mit Aufmerksamkeit https://www.tensorflow.org/tutorials/text/nmt_with_attention

Die Codebasis für den Lern- / Inferenzteil ist wie folgt Sequence to sequence example in Keras (character-level). https://keras.io/examples/lstm_seq2seq/

Die zum Lernen verwendeten Daten sind wie folgt https://github.com/odashi/small_parallel_enja

Das Repository mit dem Code für diesen Artikel https://github.com/nagiton/simple_NMT

[PYTHON] Erstellen Sie ein seq2seq-Modell mit dem Functional API Model Building & Learning von keras