Python: Deep Learning in der Verarbeitung natürlicher Sprache: Implementierung eines Antwortsatzauswahlsystems

Antworttextauswahlsystem

Für den Fragetext werden einige Kandidaten für den Antworttext angegeben Es ist ein System, das automatisch die richtige Antwort aus ihnen auswählt.

Der verwendete Datensatz ist

Allen AI's Lehrbuch Frage beantworten.

Ich habe train.json und val.json unter "./nlp_data/" vorbereitet.

Verwenden Sie train.json als Trainingsdaten und val.json als Bewertungsdaten.

Im Allgemeinen erfordert die Aufgabe der Verarbeitung natürlicher Sprache die Vorverarbeitung von Daten.

Verwenden Sie die Trennung als Vorprozess.

Trennung ist die Aufteilung eines Satzes in Wörter.

Auch im Fall von Englisch ist es notwendig, separat zu schreiben, Zeichen und ID-Wörter zu normalisieren.

Und wenn Sie Deep Learning in der Verarbeitung natürlicher Sprache verwenden, müssen alle Satzlängen der Eingabe gleich sein.

Dies liegt daran, dass ansonsten keine Matrixoperationen ausgeführt werden können.

Das Vereinheitlichen der Länge dieses Eingabesatzes wird als Auffüllen bezeichnet.

Kurze Sätze sollten mit 0 hinzugefügt werden, und zu lange Sätze sollten entfernt werden.

Datenvorverarbeitung

Normalisierung / Division

In Bezug auf die englische Normalisierung werden wir uns diesmal nur mit dem grundlegendsten Prozess der Vereinheitlichung in Groß- oder Kleinbuchstaben befassen.

Wenn der englische Satz als Zeichenkette angegeben wird

s = "I am Darwin."
s = s.lower()
print(s)
# => "i am darwin."

Als nächstes kommt die Aufteilung. Eines der Werkzeuge für die englische Teilung

Es gibt etwas namens nltk.

In nltk können Sie zusätzlich zum separaten Schreiben auch Stichwörter, Wortstämme usw. verwenden. Dieses Mal werde ich der Einfachheit halber nur die Unterteilung verwenden.

from nltk.tokenize import word_tokenize
t = "he isn't darwin."
t = word_tokenize(t)
print(t)
# => ['he', 'is', "n't", 'darwin', '.']

Auf diese Weise kann nicht in is und n't unterteilt werden, und der Punkt kann auch als ein Wort getrennt werden.

Klicken Sie hier für Anwendungsbeispiele

import json
from nltk.tokenize import word_tokenize
import nltk
nltk.download('punkt')

with open("./nlp_data/train.json") as f:
    train = json.load(f)

#train ist eine Liste, und jedes Element speichert Fragen, Antwortkandidaten und Antworten als wörterbuchartige Daten.
# train[0] = {'answerChoices': {'a': 'solid Earth.',
#  'b': 'Earths oceans.',
#  'c': 'Earths atmosphere.',
#  'd': 'all of the above'},
# 'correctAnswer': 'd',
# 'question': 'Earth science is the study of'}

target = train[0]["question"]

#Vereinheitlicht in Kleinbuchstaben
target = target.lower()

#Teilen
target = word_tokenize(target)

print(target)

Wort-ID

Weil das Wort selbst nicht als Eingabe an das neuronale Netz weitergegeben werden kann Muss in eine ID konvertiert werden.

Was ist hier ein Ausweis?

Entspricht einer Zeile in der Einbettungsmatrix.

Wenn Sie allen Wörtern, die in den Daten enthalten sind, eine ID geben In vielen Fällen wird die Gesamtzahl der Vokabeln enorm.

Geben Sie daher nur Wörtern eine ID, deren Häufigkeit über einem bestimmten Wert liegt. Konvertiert die Daten in eine Spalte mit IDs.

Auch Wörterbuchtyp.get(['key'])Entspricht Key by
Sie können den Wert von Value erhalten.

dict_ = {'key1': 'earth','key2': 'science', 'key3':'is','key4': 'the', 'key5':'study', 'key6':'of'}

print(dict_['key1'])

print(dict_.get('key1'))

Klicken Sie hier für Anwendungsbeispiele

import json
from nltk.tokenize import word_tokenize
import nltk
nltk.download('punkt')

with open("./nlp_data/train.json", "r") as f:
    train = json.load(f)
    
def preprocess(s):
    s = s.lower()
    s = word_tokenize(s)
    return s

sentences = []
for t in train:
    q = t['question']
    q = preprocess(q)
    sentences.append(q)
    for i, a in t['answerChoices'].items():
        a = preprocess(a)
        sentences.append(a)

vocab = {}
for s in sentences:
    for w in s:
        # vocab.get()Berechnen Sie die Häufigkeit für jedes Wort mit
        vocab[w] = vocab.get(w, 0) + 1

        
word2id = {}
word2id['<unk>'] = 0
for w, v in vocab.items():
    if not w in word2id and v >= 2:
        # len()Geben Sie dem Wort einen Ausweis mit
        word2id[w] = len(word2id)

target = preprocess(train[0]["question"])

target = [word2id.get(w, 0) for w in target]

print(target)

Padding

Bei der Durchführung von Deep Learning ist es nicht möglich, Matrixoperationen durchzuführen, wie dies bei Daten mit unterschiedlichen Längen der Fall ist, z. B. bei Sätzen.

Fügen Sie am Ende zwangsweise 0 für die Dummy-ID hinzu oder löschen Sie so viele Wörter wie nötig am Ende des Satzes

Sie müssen die Eingabedaten auffüllen (und abschneiden).

Keras hat eine praktische Funktion dafür, also werde ich sie dieses Mal verwenden.

import numpy as np
from keras.preprocessing.sequence import pad_sequences


s = [[1,2], [3,4,5], [6,7,8], [9,10,11,12,13,14]]
s = pad_sequences(s, maxlen=5, dtype=np.int32, padding='post', truncating='post', value=0)
print(s)
# => array([[ 1,  2,  0,  0,  0],
#       [ 3,  4,  5,  0,  0],
#       [ 6,  7,  8,  0,  0],
#       [ 9, 10, 11, 12, 13]], dtype=int32)

Nach dem Auffüllen und Abschneiden auf diese Weise wird es als numpy-Array zurückgegeben.

Die Erklärung des Arguments lautet wie folgt.

maxlen:Länge vereinheitlichen
dtype:
padding: 'pre''post'を指定し、前と後ろのどちらにpaddingするを決める
truncating: 'pre''post'を指定し、前と後ろのどちらをtruncatingする決める
value:

Geben Sie an, ob die Vorder- oder Rückseite aufgefüllt werden soll, geben Sie an, ob die Vorder- oder Rückseite abgeschnitten werden soll, und klicken Sie hier, um ein Beispiel für die Verwendung des zum Auffüllen verwendeten Werts anzuzeigen.

import numpy as np
from keras.preprocessing.sequence import pad_sequences


#Verwenden Sie dies für das Argument.
maxlen = 10
dtype = np.int32
padding = 'post'
truncating = 'post'
value = 0

#Daten
s = [[1,2,3,4,5,6], [7,8,9,10,11,12,13,14,15,16,17,18], [19,20,21,22,23]]

# padding,Bitte abschneiden.
s = pad_sequences(s,maxlen=10,dtype=np.int32,padding=padding,truncating=truncating,value=value)


print(s)

Attention-based QA-LSTM

Gesamtbild

Von nun an werden wir endlich das Auswahlsystem für Antwortsätze implementieren.

Für das Lernmodell

Attention-based QA-Wir werden eine verbesserte Version von LSTM verwenden, die leicht zu verstehen ist.

Das Gesamtbild des Modells ist ein Diagramm.

① Geben Sie zuerst Frage und Antwort separat in BiLSTM ein.

② Weiter Aufmerksamkeit von Frage zu Antwort Sie können Antwortinformationen unter Berücksichtigung der Frage erhalten.

(3) Danach wird der verborgene Zustandsvektor zu jedem Zeitpunkt der Frage gemittelt (mittleres Pooling), um den Vektor q zu erhalten.

④ Nehmen Sie andererseits nach dem Anwenden von Attention from Question den Durchschnitt der verborgenen Zustandsvektoren zu jedem Zeitpunkt der Antwort. Holen Sie sich den Vektor a.

⑤ Schließlich diese beiden Vektoren

mögen

Kombinieren Sie die Vektoren in der obigen Gleichung Die Ausgabe besteht aus zwei Einheiten über ein neuronales Netz mit Vorwärtsausbreitung und die Softmax-Funktion.

Diese Beitrittsmethode basiert auf der bekannten Methode namens InferSent, die von Facebook Research angekündigt wurde.

Die Ausgabeschicht dieses Modells besteht aus zwei Einheiten Wir werden lernen, [1,0] für korrekte Antwortsätze und [0,1] für falsche Antwortsätze vorherzusagen.

BiLSTM für Fragen und Antworten

Bidirectional LSTM(BiLSTM)Was ist
Wenn Sie einen eindeutigen Ausdruck erkennen, können Sie Kontextinformationen sowohl in der linken als auch in der rechten Richtung erfassen, indem Sie von hinten lesen.

Klicken Sie hier für Anwendungsbeispiele

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


vocab_size = 1000 #Anzahl der zu behandelnden Vokabeln
embedding_dim = 100 #Wortvektordimensionen
seq_length1 = 20 #Fragenlänge
seq_length2 = 10 #Antwortlänge
lstm_units = 200 #Anzahl der Dimensionen des verborgenen Zustandsvektors von LSTM

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)
h1 = Dropout(0.2)(bilstm1)
model1 = Model(inputs=input1, outputs=h1)


input2 = Input(shape=(seq_length2,))
embed2 = embedding(input2)
bilstm2 = Bidirectional(LSTM(lstm_units, return_sequences=True), merge_mode='concat')(embed2)
h2 = Dropout(0.2)(bilstm2)
model2 = Model(inputs=input2, outputs=h2)

model1.summary()
model2.summary()

Aufmerksamkeit von Frage zu Antwort

Lassen Sie uns den Inhalt der folgenden Abbildung durchgehen.

Beachten Sie, dass es sich um eine Aufmerksamkeit von Frage zu Antwort handelt.

Hier ist ein Verwendungsbeispiel, das dem vorherigen Abschnitt hinzugefügt wurde.

from keras.layers import Input, Dense, Dropout
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 #Fragenlänge
seq_length2 = 10 #Antwortlänge
lstm_units = 200 #Anzahl der Dimensionen des verborgenen Zustandsvektors von LSTM
hidden_dim = 200 #Anzahl der Dimensionen des endgültigen Ausgabevektors

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)
h1 = Dropout(0.2)(bilstm1)

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

#Berechnen Sie das Produkt für jedes Element
product = dot([h2, h1], axes=2) #Größe:[Stapelgröße, Antwortlänge, Fragenlänge]
a = Activation('softmax')(product)
c = dot([a, h1], axes=[2, 1])
c_h2 = concatenate([c, h2], axis=2)
h = Dense(hidden_dim, activation='tanh')(c_h2)

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

Ausgabeebene, Kompilierung

Implementieren Sie vom mittleren Pooling zur Ausgabeschicht.

Beachten Sie, dass wir endlich die Softmax-Funktion verwenden.

für gemeines Pooling

from keras.layers.pooling import AveragePooling1D

y = AveragePooling1D(pool_size=2, strides=1)(x)

Die Größe von x ist [batch_size, Schritte, Features]

Die Größe von y ist [batch_size, downsampled_steps, features].

Klicken Sie hier für Anwendungsbeispiele

from keras.layers import Input, Dense, Dropout, Lambda, Reshape
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, subtract, multiply
from keras.layers.core import Activation
from keras.layers.pooling import AveragePooling1D
from keras import backend as K
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 #Fragenlänge
seq_length2 = 10 #Antwortlänge
lstm_units = 200 #Anzahl der Dimensionen des verborgenen Zustandsvektors von LSTM
hidden_dim = lstm_units * 2 #Anzahl der Dimensionen des endgültigen Ausgabevektors

def abs_sub(x):
    return K.abs(x[0] - x[1])

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)
h1 = Dropout(0.2)(bilstm1)

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

#Berechnen Sie das Produkt für jedes Element
product = dot([h2, h1], axes=2) #Größe:[Stapelgröße, Antwortlänge, Fragenlänge]
a = Activation('softmax')(product)
c = dot([a, h1], axes=[2, 1])
c_h2 = concatenate([c, h2], axis=2)
h = Dense(hidden_dim, activation='tanh')(c_h2)

#Es ist hier implementiert.
mean_pooled_1 = AveragePooling1D(pool_size=seq_length1, strides=1, padding='valid')(h1)
mean_pooled_2 = AveragePooling1D(pool_size=seq_length2, strides=1, padding='valid')(h)

mean_pooled_1 = Reshape((lstm_units * 2,))(mean_pooled_1)
mean_pooled_2 = Reshape((lstm_units * 2,))(mean_pooled_2)

sub = Lambda(abs_sub)([mean_pooled_1, mean_pooled_2])
mult = multiply([mean_pooled_1, mean_pooled_2])
con = concatenate([mean_pooled_1, mean_pooled_2, sub, mult], axis=-1)
#con = Reshape((lstm_units * 2 * 4,))(con)
output = Dense(2, activation='softmax')(con)

model = Model(inputs=[input1, input2], outputs=output)
model.summary()
model.compile(optimizer="adam", loss="categorical_crossentropy")

Ausbildung

Nach dem Erstellen des Modells lernen wir das Modell.

Nach Abschluss aller Vorverarbeitungen außer Auffüllen und Konvertieren in ID Es wird davon ausgegangen, dass es in ./nlp_data/ vorbereitet ist.

Das Wörterbuch zum Konvertieren von Wörtern in IDs ist in ./nlp_data/word2id.json gespeichert.

Der Dateiname lautet ./nlp_data/preprocessed_train.json Die Auswertungsdaten lauten ./nlp_data/preprocessed_val.json.

Die Daten in preprocessed_train.json sehen beispielsweise so aus.

{'answerChoices': {'a': [1082, 1181, 586, 2952, 0],
  'b': [1471, 2492, 773, 0, 1297],
  'c': [811, 2575, 0, 1181, 2841, 0],
  'd': [2031, 1984, 1099, 0, 3345, 975, 87, 697, 1366]},
 'correctAnswer': 'a',
 'question': [544, 0]}

Klicken Sie hier für Anwendungsbeispiele

import json
import numpy as np
from keras.layers import Input, Dense, Dropout, Reshape
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.layers.pooling import AveragePooling1D
from keras.models import Model
from keras.preprocessing.sequence import pad_sequences

with open("./nlp_data/word2id.json", "r") as f:
    word2id = json.load(f)

batch_size = 500 #Chargengröße
vocab_size = len(word2id) #Anzahl der zu behandelnden Vokabeln
embedding_dim = 100 #Wortvektordimensionen
seq_length1 = 20 #Fragenlänge
seq_length2 = 10 #Antwortlänge
lstm_units = 200 #Anzahl der Dimensionen des verborgenen Zustandsvektors von LSTM
hidden_dim = 200 #Anzahl der Dimensionen des endgültigen Ausgabevektors

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)
h1 = Dropout(0.2)(bilstm1)

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

#Berechnen Sie das Produkt für jedes Element
product = dot([h2, h1], axes=2) #Größe:[Stapelgröße, Antwortlänge, Fragenlänge]
a = Activation('softmax')(product)
c = dot([a, h1], axes=[2, 1])
c_h2 = concatenate([c, h2], axis=2)
h = Dense(hidden_dim, activation='tanh')(c_h2)

mean_pooled_1 = AveragePooling1D(pool_size=seq_length1, strides=1, padding='valid')(h1)
mean_pooled_2 = AveragePooling1D(pool_size=seq_length2, strides=1, padding='valid')(h)
con = concatenate([mean_pooled_1, mean_pooled_2], axis=-1)
con = Reshape((lstm_units * 2 + hidden_dim,))(con)
output = Dense(2, activation='softmax')(con)

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

model.compile(optimizer="adam", loss="categorical_crossentropy")

with open("./nlp_data/preprocessed_train.json", "r") as f:
    train = json.load(f)

questions = []
answers = []
outputs = []
for t in train:
    for i, ans in t["answerChoices"].items():
        if i == t["correctAnswer"]:
            outputs.append([1, 0])
        else:
            outputs.append([0, 1])
        #Bitte geben Sie den folgenden Code ein
        questions.append(t["question"])
        answers.append(ans)

questions = pad_sequences(questions, maxlen=seq_length1, dtype=np.int32, padding='post', truncating='post', value=0)
answers = pad_sequences(answers, maxlen=seq_length2, dtype=np.int32, padding='post', truncating='post', value=0)
outputs = np.array(outputs)

#ich lerne
model.fit([questions[:10*100], answers[:10*100]], outputs[:10*100], batch_size=batch_size)
#Wenn Sie lokal arbeiten, führen Sie den folgenden Code aus.

#　model.save_weights("./nlp_data/model.hdf5")
#　model_json = model.to_json()

#　with open("./nlp_data/model.json", "w") as f:
    #　json.dump(model_json, f)

Klicken Sie hier für Ergebnisse

Prüfung

Testen Sie abschließend anhand der Bewertungsdaten.

Weil es eine binäre Klassifikation ist Genauigkeit ist Genauigkeit Präzision Berechnen Sie die Rückrufrate (Rückruf).

Außerdem habe ich hier 5 Epochen gelernt Wir haben ein trainiertes Modell vorbereitet ("./nlp_data/trained_model.hdf5").

Klicken Sie hier für Anwendungsbeispiele

import json
import numpy as np
from keras.models import model_from_json
from keras.preprocessing.sequence import pad_sequences


with open("./nlp_data/preprocessed_val.json", "r") as f:
    val = json.load(f)
seq_length1 = 20 #Fragenlänge
seq_length2 = 10 #Antwortlänge

questions = []
answers = []
outputs = []
for t in val:
    for i, ans in t["answerChoices"].items():
        if i == t["correctAnswer"]:
            outputs.append([1, 0])
        else:
            outputs.append([0, 1])
        questions.append(t["question"])
        answers.append(ans)

questions = pad_sequences(questions, maxlen=seq_length1, dtype=np.int32, padding='post', truncating='post', value=0)
answers = pad_sequences(answers, maxlen=seq_length2, dtype=np.int32, padding='post', truncating='post', value=0)

with open("./nlp_data/model.json", "r") as f:
    model_json = json.load(f)
model = model_from_json(model_json)
model.load_weights("./nlp_data/trained_model.hdf5")

pred = model.predict([questions, answers])

pred_idx = np.argmax(pred, axis=-1)
true_idx = np.argmax(outputs, axis=-1)

TP = 0
FP = 0
FN = 0
TN = 0

for p, t in zip(pred_idx, true_idx):
    if p == 0 and t == 0:
        TP += 1
    elif p == 0 and t == 1:
        FP += 1
    elif p == 1 and t == 0:
        FN += 1
    else:
        TN += 1

print("Richtige Antwortrate:", (TP+TN)/(TP+FP+FN+TN))
print("Compliance-Rate:", TP/(TP+FP))
print("Erinnern:", TP/(TP+FN))

Klicken Sie hier für Ergebnisse

Aufmerksamkeitsvisualisierung

Aufmerksamkeit ist beim Anwenden von Aufmerksamkeit von Satz s auf Satz t

Wie viel Aufmerksamkeit wird dem j-ten Wort von s dem i-ten Wort von t wie in geschenkt Man kann sagen, dass aij es repräsentiert.

Die Matrix A, die dieses aij als (i, j) -Komponente hat, wird als Aufmerksamkeitsmatrix bezeichnet. Sie können die Beziehung zwischen den Wörtern s und t anhand der Aufmerksamkeitsmatrix visualisieren.

Fragenwörter (horizontale Achse) und Antwortwörter (vertikale Achse), die eng miteinander verbunden sind, werden in Weiß angezeigt.

Klicken Sie hier für Anwendungsbeispiele

import matplotlib.pyplot as plt
import json
import numpy as np
from keras.layers import Input, Dense, Dropout, Reshape
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.layers.pooling import AveragePooling1D
from keras.models import Model
from keras.preprocessing.sequence import pad_sequences
from keras.models import model_from_json
import mpl_toolkits.axes_grid1

batch_size = 32  #Chargengröße
embedding_dim = 100  #Wortvektordimensionen
seq_length1 = 20  #Fragenlänge
seq_length2 = 10  #Antwortlänge
lstm_units = 200  #Anzahl der Dimensionen des verborgenen Zustandsvektors von LSTM
hidden_dim = 200  #Anzahl der Dimensionen des endgültigen Ausgabevektors

with open("./nlp_data/preprocessed_val.json", "r") as f:
    val = json.load(f)

questions = []
answers = []
outputs = []
for t in val:
    for i, ans in t["answerChoices"].items():
        if i == t["correctAnswer"]:
            outputs.append([1, 0])
        else:
            outputs.append([0, 1])
        questions.append(t["question"])
        answers.append(ans)

questions = pad_sequences(questions, maxlen=seq_length1,
                          dtype=np.int32, padding='post', truncating='post', value=0)
answers = pad_sequences(answers, maxlen=seq_length2,
                        dtype=np.int32, padding='post', truncating='post', value=0)

with open("./nlp_data/word2id.json", "r") as f:
    word2id = json.load(f)

vocab_size = len(word2id)  #Anzahl der zu behandelnden Vokabeln
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)
h1 = Dropout(0.2)(bilstm1)

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


#Berechnen Sie das Produkt für jedes Element
product = dot([h2, h1], axes=2)  #Größe:[Stapelgröße, Antwortlänge, Fragenlänge]
a = Activation('softmax')(product)

c = dot([a, h1], axes=[2, 1])
c_h2 = concatenate([c, h2], axis=2)
h = Dense(hidden_dim, activation='tanh')(c_h2)

mean_pooled_1 = AveragePooling1D(
    pool_size=seq_length1, strides=1, padding='valid')(h1)
mean_pooled_2 = AveragePooling1D(
    pool_size=seq_length2, strides=1, padding='valid')(h)
con = concatenate([mean_pooled_1, mean_pooled_2], axis=-1)
con = Reshape((lstm_units * 2 + hidden_dim,))(con)
output = Dense(2, activation='softmax')(con)

#Bitte antworten Sie hier
prob_model = Model(inputs=[input1, input2], outputs=[a, output])

prob_model.load_weights("./nlp_data/trained_model.hdf5")

question = np.array([[2945, 1752, 2993, 1099, 122, 2717, 0,
                      0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]])
answer = np.array([[2841, 830, 2433, 0, 0, 0, 0, 0, 0, 0]])

att, pred = prob_model.predict([question, answer])

id2word = {v: k for k, v in word2id.items()}

q_words = [id2word[w] for w in question[0]]
a_words = [id2word[w] for w in answer[0]]

f = plt.figure(figsize=(8, 8.5))
ax = f.add_subplot(1, 1, 1)

# add image
i = ax.imshow(att[0], interpolation='nearest', cmap='gray')

# add labels
ax.set_yticks(range(att.shape[1]))
ax.set_yticklabels(a_words)

ax.set_xticks(range(att.shape[2]))
ax.set_xticklabels(q_words, rotation=45)

ax.set_xlabel('Question')
ax.set_ylabel('Answer')

# add colorbar
divider = mpl_toolkits.axes_grid1.make_axes_locatable(ax)
cax = divider.append_axes('right', '5%', pad='3%')
plt.colorbar(i, cax=cax)
plt.show()

Klicken Sie hier für Ergebnisse