1 nn. Einführung in die Einbettung

1.1 nn.Einbettungsfunktion

nn.Embedding ist ein häufig verwendetes Modul in PyTorch. Seine Hauptfunktion besteht darin, die eingegebene Ganzzahlsequenz in eine dichte Vektordarstellung umzuwandeln. Bei NLP-Aufgaben (Natural Language Processing) kann jedes Wort als Vektor dargestellt werden, um den nächsten Schritt der Berechnung und Verarbeitung zu erleichtern.

1.2 nn.Einbettungsfunktionsbeschreibung

nn.Embedding dient der Vektorisierung der Eingabe und ist wie folgt definiert:

torch.nn.Embedding(num_embeddings, 
                   embedding_dim, 
                   padding_idx=None, 
                   max_norm=None, 
                   norm_type=2.0, 
                   scale_grad_by_freq=False, 
                   sparse=False, 
                   _weight=None, 
                   _freeze=False, 
                   device=None, 
                   dtype=None)

Parameterbeschreibung:

num_embeddings : die Anzahl der Wörter im Wörterbuch

embedding_dim : Dimension der Einbettung

padding_idx (indexspezifisches padding): Wenn angegeben, wird der Index in padding_idx mit 0 gefüllt (0 ist der Standardwert, tatsächlich kann jeder Wert gefüllt werden).

Hinweis: Die Werte in Einbettungen werden zufällig aus der Normalverteilung N(0,1) ausgewählt.

1.3 nn.Einbettung von Wortvektorkonvertierungen

In PyTorch wird nn.Embedding verwendet, um die Zuordnung von Wörtern und Wortvektoren zu implementieren. nn.Embedding hat ein Gewicht (.weight) mit Form (num_words, embedding_dim). Beispielsweise gibt es insgesamt 100 Wörter, jedes Wort wird durch einen 16-dimensionalen Vektor dargestellt und das entsprechende Gewicht ist eine 100 × 16-Matrix.

Die Eingabeform von Embedding ist N×W, N ist die Stapelgröße, W ist die Länge der Sequenz und die Ausgabeform ist N×W×embedding_dim.

Die eingebettete Eingabe muss ein LongTensor sein, und ein FloatTensor muss über die Methode tensor.long() in einen LongTensor konvertiert werden.

Die Gewichte der Einbettung können trainiert werden, entweder durch zufällige Initialisierung oder durch Initialisierung vorab trainierter Wortvektoren.

2 nn.Einbettung des tatsächlichen Kampfes

2.1 Wie beim Einbetten Text verarbeitet wird

In der NLP-Aufgabe muss der Text zuerst verarbeitet werden, und der Text muss codiert und konvertiert werden, um einen Vektorausdruck zu bilden. Der Prozess der Einbettung von Verarbeitungstext ist wie folgt:

(1) Geben Sie einen Text ein. Chinesische Wörter werden zuerst segmentiert (z. B. Jieba-Wortsegmentierung), und englische Wörter werden basierend auf Leerzeichen extrahiert.

(2) Konvertieren Sie die Wörter zunächst in die Wörterbuchform. Da im Englischen Leerzeichen zum Trennen von Wörtern verwendet werden, kann die Wörterbuchindexstruktur direkt erstellt werden. Ähnlich wie: word2id = {'i' : 1, 'like' : 2, 'you' : 3, 'want' : 4, 'an' : 5, 'apple' : 6} . Wenn es sich um Chinesisch handelt, führen Sie zunächst die Wortsegmentierungsoperation durch.

(3) Verwenden Sie dann die Sätze als Liste, um für jeden Satz eine Indexstruktur zu erstellen, Liste [ [ Satz1 ] , [ Satz2 ] ] . Am Beispiel des Index des obigen Wörterbuchs wird schließlich [[1, 2, 3], [1, 4, 5, 6]] ermittelt . Sätze unterschiedlicher Länge wie dieser

(4) Als nächstes folgt der Füllvorgang. Da die Tensorstrukturen alle gleich lang sind, müssen Sie eine Auffülloperation für den obigen Satz durchführen und dann nn.Embedding verwenden, um das Wort zu initialisieren. Die Struktur nach dem Polstern könnte so aussehen

[ [ 1 , 2 , 3, 0 ] , [ 1 , 4 , 5 , 6 ] ] . wobei 0 als Polsterung verwendet wird. (Hinweis: Da in der NMT-Aufgabe ein Füllproblem vorliegen muss, muss beim Einbetten ein dritter Parameter vorhanden sein, sodass der Wert unter einigen Indizes 0 ist, was eine bedeutungslose Füllung darstellt.)

2.2 Anwendungsbeispiele zum Einbetten

Es gibt zum Beispiel zwei Sätze:

Ich möchte ein Flugzeug
Ich möchte nach Peking reisen

Konvertieren Sie zwei Sätze in eine ID-Zuordnung:

{I: 1, wollen: 2, ein: 3, Flugzeug: 4, bis: 5, Reisen: 6, Peking: 7}

Die beiden in ID-Darstellungen umgewandelten Sätze lauten wie folgt:

1,2,3,4
1,2,5,6,5,7

import torch
from torch import nn

# 创建最大词个数为10，每个词用维度为4表示
embedding = nn.Embedding(10, 4)

# 将第一个句子填充0，与第二个句子长度对齐
in_vector = torch.LongTensor([[1, 2, 3, 4, 0, 0], [1, 2, 5, 6, 5, 7]])
out_emb = embedding(in_vector)
print(in_vector.shape)
print((out_emb.shape))
print(out_emb)
print(embedding.weight)

Die Laufergebnisse werden wie folgt angezeigt:

torch.Size([2, 6])
torch.Size([2, 6, 4])
tensor([[[-0.6642, -0.6263,  1.2333, -0.6055],
         [ 0.9950, -0.2912,  1.0008,  0.1202],
         [ 1.2501,  0.1923,  0.5791, -1.4586],
         [-0.6935,  2.1906,  1.0595,  0.2089],
         [ 0.7359, -0.1194, -0.2195,  0.9161],
         [ 0.7359, -0.1194, -0.2195,  0.9161]],

        [[-0.6642, -0.6263,  1.2333, -0.6055],
         [ 0.9950, -0.2912,  1.0008,  0.1202],
         [-0.3216,  1.2407,  0.2542,  0.8630],
         [ 0.6886, -0.6119,  1.5270,  0.1228],
         [-0.3216,  1.2407,  0.2542,  0.8630],
         [ 0.0048,  1.8500,  1.4381,  0.3675]]], grad_fn=<EmbeddingBackward0>)
Parameter containing:
tensor([[ 0.7359, -0.1194, -0.2195,  0.9161],
        [-0.6642, -0.6263,  1.2333, -0.6055],
        [ 0.9950, -0.2912,  1.0008,  0.1202],
        [ 1.2501,  0.1923,  0.5791, -1.4586],
        [-0.6935,  2.1906,  1.0595,  0.2089],
        [-0.3216,  1.2407,  0.2542,  0.8630],
        [ 0.6886, -0.6119,  1.5270,  0.1228],
        [ 0.0048,  1.8500,  1.4381,  0.3675],
        [ 0.3810, -0.7594, -0.1821,  0.5859],
        [-1.4029,  1.2243,  0.0374, -1.0549]], requires_grad=True)

Beachten:

Die ID im Satz darf nicht größer als der Index des größten Worts sein (im obigen Beispiel darf sie nicht größer als 10 sein).
Die Einbettungseingabe muss maßlich ausgerichtet sein. Wenn die Länge nicht ausreicht, muss vorab eine Polsterung vorgenommen werden.

2.3 Erlernbarkeit von nn.Embedding

Die Parameter in nn.Embedding sind nicht statisch, sie nehmen auch am Gradientenabstieg teil. Das heißt, durch die Aktualisierung der Modellparameter werden auch die Parameter von nn.Embedding aktualisiert, oder die Parameter von nn.Embedding selbst sind ebenfalls Teil der Modellparameter.

import torch
from torch import nn

# 创建最大词个数为10，每个词用维度为4表示
embedding = nn.Embedding(10, 4)

# 将第一个句子填充0，与第二个句子长度对齐
in_vector = torch.LongTensor([[1, 2, 3, 4, 0, 0], [1, 2, 5, 6, 5, 7]])

optimizer = torch.optim.SGD(embedding.parameters(), lr=0.01)
criteria = nn.MSELoss()

for i in range(1000):
    outputs = embedding(torch.LongTensor([1, 2, 3, 4]))
    loss = criteria(outputs, torch.ones(4, 4))
    loss.backward()
    optimizer.step()
    optimizer.zero_grad()

print(embedding.weight)
new_output = embedding(in_vector)
print(new_output)

Sehen Sie sich nach 1000 Trainingsepochen die neuen Codierungsergebnisse an, die wie folgt angezeigt werden:

Parameter containing:
tensor([[-0.2475, -1.3436, -0.0449,  0.2093],
        [ 0.4831,  0.5887,  1.2278,  1.1106],
        [ 1.1809,  0.7451,  0.2049,  1.3053],
        [ 0.7369,  1.1276,  1.0066,  0.4399],
        [ 1.3064,  0.3979,  0.8753,  0.9410],
        [-0.6222,  0.2574,  1.1211,  0.1801],
        [-0.5072,  0.2564,  0.5500,  0.3136],
        [-1.7473,  0.0504, -0.0633, -0.3138],
        [-2.4507, -0.6092,  0.0348, -0.4384],
        [ 0.9458, -0.2867, -0.0285,  1.1842]], requires_grad=True)
tensor([[[ 0.4831,  0.5887,  1.2278,  1.1106],
         [ 1.1809,  0.7451,  0.2049,  1.3053],
         [ 0.7369,  1.1276,  1.0066,  0.4399],
         [ 1.3064,  0.3979,  0.8753,  0.9410],
         [-0.2475, -1.3436, -0.0449,  0.2093],
         [-0.2475, -1.3436, -0.0449,  0.2093]],

        [[ 0.4831,  0.5887,  1.2278,  1.1106],
         [ 1.1809,  0.7451,  0.2049,  1.3053],
         [-0.6222,  0.2574,  1.1211,  0.1801],
         [-0.5072,  0.2564,  0.5500,  0.3136],
         [-0.6222,  0.2574,  1.1211,  0.1801],
         [-1.7473,  0.0504, -0.0633, -0.3138]]], grad_fn=<EmbeddingBackward0>)

Die Gewichtsparameter und Codierungsergebnisse haben sich stark verändert, sodass nn.Embedding als Teil des Modells für gemeinsames Training während des Modellerstellungsprozesses verwendet werden kann.

Deep Learning: Detaillierte Erklärung von Pytorch nn.Embedding