1 nn.Introducción a la incrustación

1.1 nn.Función de incrustación

nn.Embedding es un módulo de uso común en PyTorch, su función principal es convertir la secuencia entera de entrada en una representación vectorial densa. En las tareas de procesamiento del lenguaje natural (PNL), cada palabra se puede representar como un vector para facilitar el siguiente paso de cálculo y procesamiento.

1.2 nn.Descripción de la función de incrustación

nn.Embedding consiste en vectorizar la entrada y se define de la siguiente manera:

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)

Descripción de parámetros:

num_embeddings : el número de palabras en el diccionario

embedding_dim : dimensión de incrustación

padding_idx (relleno especificado por índice): si se proporciona, si se encuentra el índice en padding_idx, su posición se completará con 0 (0 es el valor predeterminado; de hecho, se puede completar cualquier valor).

Nota: Los valores de las incrustaciones se seleccionan aleatoriamente de la distribución normal N (0,1).

1.3 nn.Incrustar conversión de vectores de palabras

En PyTorch, nn.Embedding se utiliza para implementar el mapeo de palabras y vectores de palabras. nn.Embedding tiene un peso (.weight) con forma (num_words, embedding_dim). Por ejemplo, hay un total de 100 palabras, cada palabra está representada por un vector de 16 dimensiones y el peso correspondiente es una matriz de 100 × 16.

La forma de entrada de Incrustación es N × W, N es el tamaño del lote, W es la longitud de la secuencia y la forma de salida es N × W × embedding_dim.

La entrada incrustada debe ser un LongTensor, y un FloatTensor debe convertirse en un LongTensor mediante el método tensor.long ().

Los pesos de Incrustación se pueden entrenar, ya sea mediante inicialización aleatoria o mediante inicialización de vectores de palabras previamente entrenados.

2 nn.Incorporar combate real

2.1 Cómo la incrustación procesa el texto

En la tarea de PNL, el texto debe procesarse primero y el texto debe codificarse y convertirse para formar una expresión vectorial. El proceso de incrustación de texto de procesamiento es el siguiente:

(1) Ingrese un fragmento de texto. Las palabras chinas se segmentarán primero (como la segmentación de palabras jieba) y las palabras en inglés se extraerán en función de los espacios.

(2) Primero convierta las palabras al formato de diccionario. Dado que en inglés se utilizan espacios para separar palabras, la estructura del índice del diccionario se puede establecer directamente. Similar a: word2id = {'i': 1, 'me gusta': 2, 'tú': 3, 'quiero': 4, 'una': 5, 'manzana': 6} . Si es chino, primero realice la operación de segmentación de palabras.

(3) Luego use las oraciones como una lista para crear una estructura de índice para cada oración, enumere [[sentencia1], [sentencia2]] . Tomando como ejemplo el índice del diccionario anterior, lo que finalmente se establece es [[1, 2, 3], [1, 4, 5, 6]] . Oraciones de diferentes longitudes como esta.

(4) La operación de relleno es la siguiente. Dado que todas las estructuras tensoriales tienen la misma longitud, debe realizar una operación de relleno en la oración anterior y luego usar nn.Embedding para inicializar la palabra. La estructura después del relleno puede ser así.

[[1, 2, 3, 0], [1, 4, 5, 6]] . donde 0 se utiliza como relleno. (Nota: dado que debe haber un problema de llenado en la tarea NMT, debe haber un tercer parámetro durante la incrustación, de modo que el valor bajo algunos índices sea 0, lo que representa un llenado sin sentido)

2.2 Ejemplos de uso de integración

Por ejemplo, hay dos oraciones:

quiero un avion
quiero viajar a pekin

Convierta dos oraciones en mapeo de identificación:

{Yo: 1, quiero: 2, viaje: 3, avión: 4, a: 5, viaje: 6, Beijing: 7}

Las dos oraciones convertidas en representaciones de identificación son las siguientes:

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)

Los resultados de ejecución se muestran a continuación:

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)

Aviso:

El ID de la oración no puede ser mayor que el índice de la palabra más grande (en el ejemplo anterior, no puede ser mayor que 10)
La entrada de incrustación debe estar alineada dimensionalmente, si la longitud no es suficiente, es necesario rellenar con anticipación.

2.3 Capacidad de aprendizaje de nn.Incrustación

Los parámetros en nn.Embedding no son estáticos, también participarán en el descenso del gradiente. Es decir, la actualización de los parámetros del modelo también actualizará los parámetros de nn.Embedding, o los parámetros de nn.Embedding en sí también son parte de los parámetros del modelo.

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)

Después de 1000 épocas de entrenamiento, vea los nuevos resultados de codificación, que se muestran a continuación:

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>)

Los parámetros de peso y los resultados de codificación han cambiado mucho, por lo que nn.Embedding se puede utilizar como parte del modelo para el entrenamiento conjunto durante el proceso de construcción del modelo.

Aprendizaje profundo: explicación detallada de pytorch nn.Embedding