Pytorch implementa el modelo transformador

Transformer es una potente arquitectura de red neuronal que se puede utilizar para procesar datos de secuencia, como tareas de procesamiento del lenguaje natural. En PyTorch, los modelos Transformer se pueden implementar fácilmente utilizando la clase torch.nn.Transformer.
El siguiente es un código de muestra de una implementación simple del modelo Transformer, que convierte una secuencia de entrada en una secuencia de salida, que puede usarse para tareas de traducción de secuencia a secuencia: el código de muestra es el siguiente
:

import torch
import torch.nn as nn
import torch.nn.functional as F
import math

class PositionalEncoding(nn.Module):
    def __init__(self, d_model, dropout=0.1, max_len=5000):
        super().__init__()
        self.dropout = nn.Dropout(p=dropout)

        pe = torch.zeros(max_len, d_model)
        position = torch.arange(0, max_len, dtype=torch.float).unsqueeze(1)
        div_term = torch.exp(torch.arange(0, d_model, 2).float() * (-math.log(10000.0) / d_model))
        pe[:, 0::2] = torch.sin(position * div_term)
        pe[:, 1::2] = torch.cos(position * div_term)
        pe = pe.unsqueeze(0).transpose(0, 1)
        self.register_buffer('pe', pe)

    def forward(self, x):
        x = x + self.pe[:x.size(0), :]
        return self.dropout(x)


class TransformerModel(nn.Module):
    def __init__(self, input_vocab_size, output_vocab_size, d_model, nhead, num_layers, dim_feedforward, dropout=0.1):
        super(TransformerModel, self).__init__()

        self.d_model = d_model
        self.nhead = nhead
        self.num_layers = num_layers
        self.dim_feedforward = dim_feedforward

        self.embedding = nn.Embedding(input_vocab_size, d_model)
        self.pos_encoder = PositionalEncoding(d_model, dropout)
        encoder_layer = nn.TransformerEncoderLayer(d_model, nhead, dim_feedforward, dropout)
        self.transformer_encoder = nn.TransformerEncoder(encoder_layer, num_layers)
        self.decoder = nn.Linear(d_model, output_vocab_size)

        self.init_weights()

    def init_weights(self):
        initrange = 0.1
        self.embedding.weight.data.uniform_(-initrange, initrange)
        self.decoder.bias.data.zero_()
        self.decoder.weight.data.uniform_(-initrange, initrange)

    def forward(self, src, src_mask=None):
        src = self.embedding(src) * math.sqrt(self.d_model)
        src = self.pos_encoder(src)
        output = self.transformer_encoder(src, src_mask)
        output = self.decoder(output)
        return output

En el código anterior, definimos una clase de modelo llamada TransformerModel que hereda de nn.Module. El modelo incluye los siguientes componentes:

nn.Embedding: convierte cada token en la secuencia de entrada a su representación vectorial.
PositionalEncoding: codifica la posición de cada marcador en la secuencia como un vector.
nn.TransformerEncoder: transforma la secuencia de entrada codificada en una secuencia de salida.
nn.Linear: Convierte la salida del Transformador a la secuencia de salida final.
Puede modificar los hiperparámetros en la clase TransformerModel según sus propias necesidades, como el tamaño del vocabulario de entrada y salida, la dimensión de incrustación, el número de capa de Transformer, la dimensión de la capa oculta, etc. Al entrenar con este modelo, debe definir una función de pérdida y un optimizador, y utilizar el bucle de entrenamiento estándar de PyTorch para el entrenamiento.

En Transformer, la función de la codificación posicional es incrustar la información de posición en la secuencia de entrada en el espacio vectorial, de modo que el vector correspondiente a cada posición sea único. En esta implementación, la codificación posicional utiliza la fórmula:

$$\text{PE}(pos,\_2i)\_=\sin (pos/10000^{\text{modelo}2i/d})$$

$$\text{PE}(pos,\_2i\_\_+1)=\mathrm{porque}(pos/10000^{\text{modelo}2i/d})$$

donde pos representa la posición en la secuencia de entrada e i representa la dimensión del vector. La matriz de codificación posicional resultante se agrega al vector de incrustación de la secuencia de entrada.