Transformers con codificador

Modelos Transformer con PyTorch

James Chapman

Curriculum Manager, DataCamp

El transformer original

La arquitectura de transformers mostrada en el artículo académico «Attention Is All You Need».

El transformer original

Arquitectura original del transformer

Transformers solo codificador

Arquitectura de transformer solo codificador

Cuerpo del transformer: pila de codificadores con N capas de codificador

Capa de codificador

Autoatención multi-cabeza

(Sub)capas feed-forward

Normalizaciones de capa, dropouts

Cabeza del transformer

Transformers solo codificador

Arquitectura de transformer solo codificador

Cuerpo del transformer: pila de codificadores con N capas de codificador

Capa de codificador

Autoatención multi-cabeza

(Sub)capas feed-forward

Normalizaciones de capa, dropouts

Cabeza del transformer: procesa entradas codificadas para producir la predicción

Tarea supervisada: clasificación, regresión

Sublayer feed-forward en capas de codificador

Sublayer feed-forward tras la atención

class FeedForwardSubLayer(nn.Module):
    def __init__(self, d_model, d_ff):
        super().__init__()
        self.fc1 = nn.Linear(d_model, d_ff)
        self.fc2 = nn.Linear(d_ff, d_model)
        self.relu = nn.ReLU()


    def forward(self, x):
        return self.fc2(self.relu(self.fc1(x)))

2 x totalmente conectada + activación ReLU

d_ff: dimensión intermedia entre capas lineales
forward(): procesa salidas de atención para captar patrones no lineales complejos

Capa de codificador

class EncoderLayer(nn.Module):
    def __init__(self, d_model, num_heads, d_ff, dropout):
        super().__init__()
        self.self_attn = MultiHeadAttention(d_model, num_heads)
        self.ff_sublayer = FeedForwardSubLayer(d_model, d_ff)

        self.norm1 = nn.LayerNorm(d_model)
        self.norm2 = nn.LayerNorm(d_model)
        self.dropout = nn.Dropout(dropout)


    def forward(self, x, src_mask):
        attn_output = self.self_attn(x, x, x, src_mask)
        x = self.norm1(x + self.dropout(attn_output))
        ff_output = self.ff_sublayer(x)
        x = self.norm2(x + self.dropout(ff_output))
        return x

Capa de codificador

Autoatención multi-cabeza
Sublayer feed-forward
Normalizaciones de capa y dropouts

forward():

mask evita procesar tokens de padding

Enmascarar el proceso de atención

Relleno de secuencias

Máscara de padding en autoatención

Cuerpo del transformer codificador

class TransformerEncoder(nn.Module):
    def __init__(self, vocab_size, d_model, num_layers, num_heads, d_ff, dropout, max_seq_length):
        super().__init__()

        self.embedding = InputEmbeddings(vocab_size, d_model)

        self.positional_encoding = PositionalEncoding(d_model, max_seq_length)

        self.layers = nn.ModuleList(
          [EncoderLayer(d_model, num_heads, d_ff, dropout) for _ in range(num_layers)]
        )


    def forward(self, x, src_mask):
        x = self.embedding(x)
        x = self.positional_encoding(x)
        for layer in self.layers:
            x = layer(x, src_mask)
        return x

Cabeza del transformer codificador

class ClassifierHead(nn.Module):
    def __init__(self, d_model, num_classes):
        super().__init__()
        self.fc = nn.Linear(d_model, num_classes)

    def forward(self, x):
        logits = self.fc(x)
        return F.log_softmax(logits, dim=-1)

class RegressionHead(nn.Module):
    def __init__(self, d_model, output_dim):
        super().__init__()
        self.fc = nn.Linear(d_model, output_dim)

    def forward(self, x):
        return self.fc(x)

Cabeza de clasificación

Tareas: clasificación de texto, análisis de sentimiento, NER, QA extractiva, etc.
fc: capa lineal totalmente conectada
- Transforma los estados ocultos del codificador en probabilidades de num_classes

Cabeza de regresión

Tareas: estimar legibilidad del texto, complejidad del lenguaje, etc.
- output_dim es 1 al predecir un único valor numérico

¡Vamos a practicar!

Modelos Transformer con PyTorch