Do-it-yourself-Chatgpt: Das Prinzip und die Datenvorverarbeitung des GRU-Moduls im seq2seq-Übersetzungsmodell

chatgpt ist eine typische NLP-Anwendung. Das heißt, es konzentriert sich hauptsächlich auf die Sprachverarbeitung und -ausgabe. Daher muss sein Modelldesign auf dem frühen Algorithmusdesign des Deep Learning in der Sprachübersetzung basieren. Um chatgpt zu verstehen, müssen wir daher verstehen, wie Deep-Learning-Algorithmen mit dem Problem der Übersetzung natürlicher Sprache umgehen. Genau wie beim Erlernen der Analysis müssen wir Addition und Multiplikation im Voraus beherrschen.

Durch die Sprachübersetzung wird im Wesentlichen eine Eingabesequenz in eine andere Eingabesequenz umgewandelt. Beispielsweise geben wir in Google Translate oder Baidu Translate eine Sequenzfolge ein: Wie geht es Ihnen, und bei der Übersetzung ins Chinesische wird eine weitere Symbolfolge ausgegeben: Hallo. Daher handelt es sich in der Terminologie um Sequenz für Sequenz, also seq2seq. Wenn zwei Sprachen dieselbe „Bedeutung“ ausdrücken, sind ihre symbolischen Ausdrücke intuitiv unterschiedlich. Offensichtlich sehen die entsprechenden Symbole in Englisch und Chinesisch völlig unterschiedlich aus, aber die „Bedeutung“, die sich in den Symbolen verbirgt, ist dieselbe. Solange Sie es beherrschen Wenn Sie dann die beiden Symbolzeichenfolgen „Wie geht es Ihnen“ und „Hallo“ sehen, können Sie erkennen, dass die „Essenz“ der beiden Symbolzeichenfolgen dieselbe ist. Der Zweck des Algorithmus besteht darin, wie man die „Essenz“ erkennt „der ersten Symbolzeichenfolge wird extrahiert, und dann wird diese „Essenz“ verwendet, um die zweite Symbolzeichenfolge gemäß den Kombinationsregeln der Sprache der zweiten Symbolzeichenfolge zu generieren.

Daher besteht der erste Schritt des Netzwerks darin, sein „Wesen“ anhand der ersten Symbolzeichenfolge zu identifizieren. Offensichtlich kann dieses „Wesen“ nicht mit strukturierten Daten beschrieben werden, daher verwenden wir, wie zuvor beschrieben, Vektoren, um es zu beschreiben. Daher besteht die erste Funktion des Netzwerks darin, die Eingabesymbolsequenz zu identifizieren und dann eine Sequenz auszugeben, die das „Wesen“ darstellt " dieser Sequenz. "Vector, dieser Teil wird auch Encoder genannt. Sein grundlegender Prozess ist wie folgt:

In der obigen Abbildung ist GRU eine Netzwerkkomponente. Um es ganz klar auszudrücken: Es handelt sich um eine spezifische Funktion, die eine oder zwei Eingaben empfangen kann Vektoren und geben Sie dann einen Vektor aus. SOS ist ein spezielles Symbol, das dem Netzwerk mitteilt, wo die Eingabesequenz beginnt. h1 stellt das Verständnis dar, das das Netzwerk erzeugt, wenn es das Wort „wie“ liest, h2 stellt das Verständnis dar, das das Netzwerk erzeugt, wenn es die beiden Symbole „wie sind“ liest, und das letzte h3 stellt das Verständnis dar, das das Netzwerk nach dem Lesen erzeugt Wie geht es dir? Das h3 wird hier verwendet, um die „Bedeutung“ zu simulieren, die Menschen erhalten, nachdem sie die Zeichenfolge „Wie geht es dir?“ gelesen haben.

Wenn das Netzwerk die Bedeutung der Aussage „Wie geht es dir“ „versteht“, also den Vektor h3 erhält, kann es diese „Bedeutung“ verwenden, um eine Zeichenfolgendarstellung der „Bedeutung“ in einer anderen Sprache zu generieren. Dieser Teil von Das Netzwerk heißt Decoder und seine Struktur ist wie folgt:

Der grundlegende Prozess besteht darin, dass der Decoder den vom Encoder ausgegebenen endgültigen Vektor, h3, und einen Vektor, der das Startsymbol darstellt, in die GRU-Einheit eingibt und dann den entsprechenden Vektor generiert zu „Sie“. Der nächste Schritt besteht darin, h3 umzuwandeln. Der Vektor, der „Sie“ entspricht, wird in die GRU-Einheit eingegeben und der Vektor, der „gut“ entspricht, wird erhalten, und so weiter.

Hier müssen wir Deep Learning verwenden. Eine NLP-Algorithmus-Verarbeitungseinheit, die häufig vor dem Aufkommen großer Sprachmodelle verwendet wurde, heißt GRU. Sie empfängt zwei Eingabevektoren: Hidden_State, Input und Hidden_State. Das zuvor erwähnte Netzwerk liest eine Reihe von The Nach der Zeichenfolge werden Erkenntnisse oder Erkenntnisse gewonnen. Die Eingabe ist der Vektor, der dem aktuellen Eingabewort entspricht. Die grundlegende Arbeit der GRU besteht darin, „das Alte aufzubrechen und das Neue zu etablieren“. Das sogenannte „Shattering“ bezieht sich auf die Zerstörung und Löschung einiger der ursprünglichen „veralteten“ Informationen. Die sogenannten „Originalinformationen“ sind der darin eingegebene Vektor „hidden_state“, der einige Daten in diesem Vektor löscht. Der Prozess ist wie folgt:
Zuerst enthält es zwei Matrizen mit den Namen W_hidden_state und W_input. Lassen Sie sie Produktoperationen mit den Vektoren „hidden_state“ bzw. „input“ ausführen. Fügen Sie dann nach der Operation die beiden Ergebnisvektoren hinzu, um den Ergebnisvektor zu erhalten, und verwenden Sie schließlich die Sigmod-Funktion. Für diesen Ergebnisvektor ist der Berechnungsprozess wie folgt:

Unter diesen sind W_hidden_state und W_input die Parameter, die das Netzwerk für das Training verwendet. Sie bestimmen, welche Daten im Hidden_state-Vektor gelöscht und welche beibehalten werden müssen. Beachten Sie, dass die Sigmoidberechnung jede Komponente des Eingabevektors abbildet [0,1], wobei die Werte Komponenten nahe 0 den zu löschenden Daten entsprechen.

Verwenden Sie dann zuerst eine Matrix W_h, um den Eingabevektor „hidden_state“ zu multiplizieren, um einen Ergebnisvektor zu erhalten. Verwenden Sie dann diesen Ergebnisvektor, um eine elementweise Multiplikation mit dem obigen Gate_reset-Vektor durchzuführen, um den „schäbigen“ Vektor zu erhalten, und verwenden Sie dazu eine andere Matrix W_i Gleiches gilt für die Eingabe des Eingabevektors. Nach der Multiplikation werden die beiden erhaltenen Vektoren summiert und anschließend eine Tanh-Operation durchgeführt. Der Prozess ist wie folgt:

$R=dasTor\_\_\_\_{\_}_{rese}\Theta (W_{}\ast H_{versteckterStatus\_\_\_\_\_})+W_{}\ast v_{Eingang\_\_})$

Beachten Sie, dass die Theta-Operation hier die Multiplikation der entsprechenden Komponenten der beiden Vektoren darstellt, das heißt:

Da die Komponenten im Gate_rese-Vektor Werte zwischen [0,1] haben, werden die Komponenten mit Werten nahe 0 ausgeführt Die obige Operation. Das Ziehen der entsprechenden Komponente in die Nähe von 0 entspricht der Durchführung einer „Lösch“-Operation.

Werfen wir einen Blick darauf, wie man „etwas Neues gründet“. Erstens enthält die GRU-Einheit zwei spezifische Matrizen, nämlich W_input_update und W_hidden_update. Diese beiden Matrizen werden jeweils mit den entsprechenden Vektoren multipliziert und die resultierenden Vektoren summiert. Schließlich wird auf dieser Basis die Sigmoidoperation ausgeführt. Die Schritte sind wie folgt:

Führen Sie dann die Theta-Operation für die Vektoren „Gate_update“ und „hidden_state“ durch:

$u=Tor\_\_{\_}_{Updat}\Theta h_{versteckterStatus\_\_\_\_\_\_}$

Nachdem die folgenden Operationen an r und u ausgeführt wurden, wird das Ergebnis schließlich als endgültige Ausgabe verwendet:

W_output entspricht hier der Ausgabe, die das Netzwerk nach der Identifizierung des aktuellen Eingabeworts erhält, und h_hiddenstate entspricht dem vom Netzwerk erhaltenen „Wissen“. nach der Identifizierung der Zeichenfolge, die aus allen aktuellen Wörtern besteht. .

Mit den oben genannten Grundkenntnissen implementieren wir ein zweisprachiges Übersetzungssystem, das auf Deep Learning basiert. Wir aktualisieren das System Schritt für Schritt. Zuerst verwenden wir das einfachste seq2seq-Modell, um den Effekt zu sehen. Dann fügen wir den Aufmerksamkeitsmechanismus hinzu, um den Verbesserungseffekt zu sehen. Schließlich verwenden wir das Transformatormodell und vergleichen es mit dem vorherigen Modell. Wie stark ist die Verbesserung?

Zuerst bereiten wir die Daten für das Training vor. Bevor wir die folgende Codereihe ausführen können, müssen wir Version 0.6 von Torchtext installieren. Die entsprechenden Befehle lauten wie folgt:

pip install torchtext==0.6 

Das Pytorch-Framework stellt Korpus in drei Sprachen zur Übersetzung bereit, darunter Deutsch, Englisch und Französisch. Jeder Satz in jeder Sprache hat eine Eins-zu-eins-Entsprechung. Beispielsweise enthält Englisch den Satz „Hallo“, dann Deutsch und Französisch Eins-zu-eins-Korrespondenz. Enthält denselben Satz, sodass Sie das Netzwerk für Eins-zu-eins-Übersetzungstrainings verwenden können. Der Code zum Laden des Trainingskorpus lautet wie folgt:

import torch
import torch.nn as nn
import torch.optim as optim
from torchtext.lagecy.dataset import Multi30k
from torchtext.legacy.data import Field, BucketIterator
import spacy
import random
import math
import time

Im obigen Code müssen wir den Torchtex-Teil ausführlich erläutern. Beim Entwurf von NLP-Deep-Learning-Modellen ist die Datenvorverarbeitung eine mühsame, aber notwendige und sorgfältige Aufgabe. Sobald die Vorverarbeitung nicht gut durchgeführt wird und ein Problem mit der Dateneingabe in das Modell auftritt, wird das Modell mit falschen Daten trainiert falsche Ergebnisse. Im vorherigen Kapitel haben wir gesehen, dass das Deep-Learning-Netzwerk nur Vektoren empfangen kann. Da es sich bei den Daten um Sprachtext handelt, müssen wir Textsymbole im Voraus in Vektoren umwandeln, bevor wir sie zur Erkennung oder zum Training in das Netzwerk eingeben. Die Hauptaufgabe des Darin liegt das Torchtext-Framework. Wir sehen auch, dass der obige Code veraltet ist, das heißt, die oben aufgerufene Bibliothek ist alter Code, aber wir können ihn hier weiterhin verwenden.

Das Konvertieren von Text in Vektoren erfordert mehrere Schritte. Der erste Schritt ist die Wortsegmentierung, d einfach. , aber die Segmentierung chinesischer Wörter ist sehr schwierig, da die Grundeinheit eines chinesischen Satzes ein Wort ist und es keine Leerzeichen zwischen den Wörtern gibt. Daher ist es ein komplizierteres Problem, zu unterscheiden, welche Wörter zu bedeutungsvollen Wörtern kombiniert werden können Beispiel: Der chinesische Satz „Ich liebe den Platz des Himmlischen Friedens in Peking“, die korrekten Partizipien lauten „Ich“, „Liebe“, „Beijing“, „Tiananmen“. Da sich das Thema unseres späteren Modells mit westlichen Sprachen befasst, ignorieren wir die chinesischen Partizipien zur Zeit. Tatsächlich ist die Segmentierung englischer Wörter nicht so einfach wie die Verwendung von Leerzeichen. Wenn Sie beispielsweise „Guten Morgen!“ nur auf Leerzeichen zur Segmentierung des Wortes verlassen, wird es in „Guten“ und „Morgen!“ unterteilt, aber das Das Ausrufezeichen ist nicht Teil des Wortes, daher muss die korrekte Wortsegmentierung in „Gut“, „Morgen“ und „!“ unterteilt werden. Glücklicherweise gibt es eine vorgefertigte Codebibliothek, die wir zwischen ihnen aufrufen können Wortsegmentierung ist keine Schwierigkeit.

Der zweite Schritt besteht darin, Wörter in Zahlen umzuwandeln. Dieser Schritt wird auch build_vocab genannt. Sein Ziel ist es, ein Wort mit einer Zahl abzugleichen. Zum Beispiel „Guten Morgen!“ Nach der Ausführung dieses Schritts erhalten Sie ein Kartenobjekt ähnlich dem Folgendes:

{
    
    
"good"-> 0,
"morning"->1,
}

Der dritte Schritt besteht darin, einen Satz zu füllen, da der in das Netzwerk eingegebene Satz normalerweise die vorgegebene Länge erfüllen muss. Wenn die Satzlänge nicht ausreicht, muss er mit einer bestimmten Zeichenfolge oder Bezeichnung gefüllt werden. Angenommen, der Die vorab festgelegte Satzlänge beträgt 4. Dann wird „Guten Morgen“ am Ende mit zwei Zeichenfolgen wie „<pad>“ gefüllt, sodass nach der Wortsegmentierung Folgendes entsteht: „gut“, „Morgen“, „ <pad>“, " <pad> "

Der vierte Schritt besteht darin, die Start- und Endflags des Satzes festzulegen, da wir bei der Eingabe in das Netzwerk dem Netzwerk mitteilen müssen, wo sich der Satzanfang und das Satzende befindet. Daher müssen wir „<“ verwenden „sos>“ zeigt den Anfang des Satzes an, „<eos“ > „ zeigt das Ende an, sodass „Guten Morgen“ zu „ <sos> „ „gut“, „Morgen“, „ <pad> „, „ <pad> wird "" <eos> " nach der Segmentierung. Natürlich werden diese Füllzeichen auch im zweiten Schritt der Zeichenfolge eine entsprechende Nummer geben.

Die obige Arbeit ist die Rolle der Field-Klasse im obigen Code. Schauen wir uns konkrete Beispiele an. Angenommen, wir haben eine test.json-Datei mit Trainingsdaten in einem lokalen Verzeichnis mit folgendem Inhalt:

{
    
    
    "name": "Jocko",
    "quote": "You must own everything in your world. There is no one else to blame.",
    "score": 1
}
{
    
    
    "name": "Bruce",
    "quote": "Do not pray for an easy life, pray for the strength to endure a diffcult one.",
    "score": 1
}
{
    
    
    "name": "Random Potato",
    "quote": "Stand tall, and rice like a potato!",
    "score": 0
}

Dann verwenden wir den folgenden Code, um die obigen Daten zu lesen:

from torchtext.data import TabularDataset
#分词先使用简单的按照空格分割
tokenizer = lambda x: x.split()
quote = Field(init_token='<sos>',eos_token='<eos>',sequential=True, use_vocab=True, tokenize=tokenizer, lower=True)
#因为 score 只有数字因此不需要进行文字到数字的转换步骤
score = Field(sequential=False, use_vocab=False)
#设定哪些字段需要读取
fields = {
    
    'quote':('q', quote), 'score':('s', score)}
#加载数据文件，由于是测试，我们把训练数据和测试数据都指向同一个文件
train_data, test_data = TabularDataset.splits(path='/content/', train='test.json',
                                             test='test.json',format='json',
                                              fields=fields)
print(train_data[0].__dict__.keys())
print(train_data[0].__dict__.values())

print(train_data[1].__dict__.keys())
print(train_data[1].__dict__.values())

print(train_data[2].__dict__.keys())
print(train_data[2].__dict__.values())

'''
建立单词与编号的关联, max_size 表示编号最大值，min_freq 表示出现过指定次数的单词才能赋予编号
'''
quote.build_vocab(train_data, max_size=10000, min_freq=1)
train_iterator, test_iterator = BucketIterator.splits((train_data, test_data), 
                                                      batch_size = 2,
                                                      )
'''
在上面设置的 batch_size = 2，也就是一个集合有两个句子，但是因为数据有 3 个句子，
因此数据就分成两个集合，其中一个集合包含一个句子，另一个集合包含2 个句子，
因此下面代码打印结果中，其中有一个的向量只包含 1 个元素，另一个包含 2 个元素
'''
for batch in train_iterator:
  print(f"batch.q: {
      
      batch.q}")
  print(f"batch.s:{
      
      batch.s}")

Nachdem der Code zugelassen wurde, lauten die Ausgabeergebnisse wie folgt:

dict_keys(['q', 's'])
dict_values([['you', 'must', 'own', 'everything', 'in', 'your', 'world.', 'there', 'is', 'no', 'one', 'else', 'to', 'blame.'], 1])
dict_keys(['q', 's'])
dict_values([['do', 'not', 'pray', 'for', 'an', 'easy', 'life,', 'pray', 'for', 'the', 'strength', 'to', 'endure', 'a', 'diffcult', 'one.'], 1])
dict_keys(['q', 's'])
dict_values([['stand', 'tall,', 'and', 'rice', 'like', 'a', 'potato!'], 0])
batch.q: tensor([[ 2],
        [12],
        [23],
        [ 6],
        [ 5],
        [ 8],
        [13],
        [19],
        [ 6],
        [ 5],
        [32],
        [30],
        [ 7],
        [15],
        [ 4],
        [11],
        [25],
        [ 3]])
batch.s:tensor([1])
batch.q: tensor([[ 2,  2],
        [29, 35],
        [31, 21],
        [ 9, 26],
        [28, 16],
        [20, 17],
        [ 4, 36],
        [27, 34],
        [ 3, 33],
        [ 1, 18],
        [ 1, 22],
        [ 1, 24],
        [ 1, 14],
        [ 1,  7],
        [ 1, 10],
        [ 1,  3]])
batch.s:tensor([0, 1])

Beachten Sie, dass wir in der obigen Ausgabe beim Segmentieren des Satzes nur Leerzeichen verwenden, sodass das Ausrufezeichen mit dem Wort Potato kombiniert wird. Jetzt verbessern wir die Wortsegmentierungsmethode. Führen Sie zunächst die folgenden zwei Befehle aus, um den Wortsegmentierungsalgorithmus herunterzuladen:

#下载英语分词算法
!python -m spacy download en_core_web_sm
#下载德语分词算法
!python -m spacy download de_core_news_sm

Laden Sie dann den entsprechenden Wortsegmentierungsalgorithmus:

spacy_de = spacy.load('de_core_news_sm')
spacy_en = spacy.load('en_core_web_sm')

Ersetzen Sie dann die ursprüngliche Art der Verwendung von Leerzeichen für die Wortsegmentierung:

#分词先使用简单的按照空格分割
#tokenizer = lambda x: x.split()
#使用新加载的分词算法
import spacy
def tokenizer(text):
  return [tok.text for tok in spacy_en.tokenizer(text)]

Führen Sie dann den vorherigen Code erneut aus und Sie werden feststellen, dass das Ausrufezeichen und die Kartoffel getrennt sind:

dict_keys(['q', 's'])
dict_values([['stand', 'tall', ',', 'and', 'rice', 'like', 'a', 'potato', '!'], 0])

Wir haben zuvor gesagt, dass Wörter numerischen Zahlen entsprechen. Wir können den folgenden Code verwenden, um die entsprechende Sorgfalt anzuzeigen:

#单词转换为编号
print(f'the number for word:"You" is {
      
      quote.vocab.stoi["You"]}')
#查看!对应编号
print(f'the number for word:"!" is {
      
      quote.vocab.stoi["!"]}')
#查看起始标志的编号
print(f'the number for word:"<sos>" is {
      
      quote.vocab.stoi["<sos>"]}')
#查看结束标志的编号
print(f'the number for word:"<eos>" is {
      
      quote.vocab.stoi["<eos>"]}')

#查看编号转换为单词
print(f'the word for number:5 is {
      
      quote.vocab.itos[5]}')
print(f'the word for number:6 is {
      
      quote.vocab.itos[6]}')
print(f'the word for number:2 is {
      
      quote.vocab.itos[2]}')
print(f'the word for number:10 is {
      
      quote.vocab.itos[10]}')

Die nach der Ausführung des obigen Codes erhaltenen Ergebnisse lauten wie folgt:

the number for word:"You" is 0
the number for word:"!" is 11
the number for word:"<sos>" is 2
the number for word:"<eos>" is 3
the word for number:5 is ,
the word for number:6 is a
the word for number:2 is <sos>
the word for number:10 is to

Wie aus der Ausgabe ersichtlich ist, haben die entsprechenden Satzzeichen wie „!“, „,“ nach der Wortsegmentierung entsprechende Nummern. Werfen wir abschließend einen Blick auf den Trainingsdatensatz Multi30k, der drei Sprachen enthält: Englisch, Deutsch und Französisch. Jede Sprache hat einen Eins-zu-eins-Satz, das heißt, wenn es einen Satz auf Englisch gibt, dann gibt es einen ein entsprechender Satz in Deutsch und Französisch. Übersetzung: Dieser Datensatz kann zum Trainieren des Übersetzungssystems verwendet werden, das wir später durchführen werden.

Zuerst richten wir die Wortsegmentierungsmethoden für Englisch und Deutsch ein und richten die entsprechenden Feldobjekte ein. Der Code lautet wie folgt:

def tokenizer_eng(text):
  return [tok.text for tok in spacy_en.tokenizer(text)]

def tokenizer_ger(text):
  return [tok.text for tok in spacy_de.tokenizer(text)]

#设置英语和德语的两种预处理方式
english = Field(sequential=True, use_vocab=True, tokenize=tokenizer_eng, lower=True)
german = Field(sequential=True, use_vocab=True, tokenize=tokenizer_ger, lower=True)

Verwenden Sie dann den folgenden Code, um sowohl deutsche als auch englische Korpora aus der Multi30k-Datenbank zu laden:

train_data, validation_data, test_data = Multi30k.splits(exts=('.de', '.en'), 
                                                         fields=(german, english))

#建立英语与德语单词与数字编号的对应
english.build_vocab(train_data, max_size=10000, min_freq=2)
german.build_vocab(train_data, max_size=10000, min_freq=2)

Dann erstellen wir Traverser für die drei Datentypen und drucken die gelesenen Daten aus, um Folgendes zu sehen:

#建立英语与德语单词与数字编号的对应
english.build_vocab(train_data, max_size=10000, min_freq=2)
german.build_vocab(train_data, max_size=10000, min_freq=2)

#建立对应数据集的遍历器
train_iterator, validation_iterator, test_iterator = BucketIterator.splits(
    (train_data, validation_data, test_data),
    batch_size=64
)

for batch in train_iterator:
  print(batch)

Beim Ausführen des obigen Codes kann beim Ausführen von Multi30k.splits ein FileNotFound-Fehler auftreten. Dies liegt daran, dass der interne Link zum Herunterladen des Datensatzes ungültig ist, sodass wir den Datensatz zuerst selbst herunterladen müssen. Der Link zum Herunterladen des Datensatzes lautet wie folgt:
https://github.com/neychev/small_DL_repo/tree/master/datasets/Multi30k
Wir laden Training.tar.gz, validation.tar.gz, mmt_task1_test2016.tar.gz zur lokalen Dekomprimierung herunter und Sie wird es unter dem entsprechenden Pfad sehen. Gehen Sie zu den Dateien train.de, train.en, val.de, val.en, test2016.de, test2016.en und erstellen Sie dann einen neuen Pfad ./data/multi30k im Pfad Dort, wo sich der Code befindet, und alle vorherigen Dateien unter dem neu erstellten Pfad ablegen. Wenn Sie unter Colab testen, müssen wir den Pfad /data/multi30k unter dem aktuellen Pfad erstellen und dann alle vorherigen Dateien hochladen. Die Situation ist wie folgt:

Führen Sie nach Abschluss der Datenvorbereitung den obigen Code aus. Das Ergebnis ist wie folgt:

[torchtext.data.batch.Batch of size 64 from MULTI30K]
	[.src]:[torch.LongTensor of size 23x64]
	[.trg]:[torch.LongTensor of size 31x64]

[torchtext.data.batch.Batch of size 64 from MULTI30K]
	[.src]:[torch.LongTensor of size 24x64]
	[.trg]:[torch.LongTensor of size 22x64]

[torchtext.data.batch.Batch of size 64 from MULTI30K]
	[.src]:[torch.LongTensor of size 27x64]
	[.trg]:[torch.LongTensor of size 28x64]
	
	...

Wir sehen, dass die Ausgabe .src und .trg 64 enthält, was bedeutet, dass ein Satz 64 Sätze enthält. Die vorherige Zahl gibt die Länge jedes Satzes an. Natürlich muss die Länge jedes Satzes in einem Satz unterschiedlich sein. Daher wird der längste Satz als Standard ausgewählt und jeder Satz, der kürzer als die Standardlänge ist, wird mit dem Symbol „<pad>“ aufgefüllt. Mit dem folgenden Code können wir die diesem Zeichen entsprechende Nummer ausdrucken:

print(f"number for word: '<pad>' is : {
      
      english.vocab.stoi['<pad>']}")

Die nach der Ausführung des obigen Codes erhaltenen Ergebnisse lauten wie folgt:

number for word: '<pad>' is : 1

Das heißt, die entsprechende Nummer der zum Füllen der Satzlänge verwendeten Zeichenfolge ist 1.
Das Obige ist die Datenvorbereitung vor der Implementierung des Netzwerkmodells. Im nächsten Abschnitt werden wir uns ansehen, wie das seq2seq-Übersetzungsmodell entworfen wird. Download-Adresse für den gesamten Code und die Daten in diesem Abschnitt:
https://github.com/wycl16514/seq2seq-gru-data-preprocess.git