Transformador de decodificación: descripción detallada e implementación de código del mecanismo de autoatención y mecanismo de códec

Este artículo analiza exhaustivamente Transformer y sus modelos derivados, analiza en profundidad el mecanismo de autoatención, la estructura del codificador y el decodificador, y enumera su implementación de codificación para profundizar la comprensión, y finalmente enumera varios modelos basados ​​en Transformer, como BERT y GPT. El artículo pretende explicar en profundidad cómo funciona Transformer y demostrar su amplio impacto en el campo de la inteligencia artificial.

El autor, TechLead, tiene más de 10 años de experiencia en arquitectura de servicios de Internet, desarrollo de productos de IA y gestión de equipos. Es un maestro de Fudan de la Universidad de Tongji, miembro del Fudan Robot Intelligence Laboratory, arquitecto senior certificado por Alibaba Cloud, un profesional de gestión de proyectos y un ingreso de IA de mil millones de dólares.

1. El trasfondo del transformador

La aparición de Transformer marca un hito en el campo del procesamiento del lenguaje natural. A continuación, se explicarán de manera integral sus antecedentes desde tres aspectos: los desafíos técnicos, el surgimiento del mecanismo de autoatención y el impacto de Transformer en todo el campo.

1.1 Desafíos técnicos y limitaciones de las soluciones anteriores

RNN y LSTM

Los primeros modelos de secuencia, como RNN y LSTM, aunque funcionaron bien en algunos escenarios, encontraron muchos desafíos en la práctica:

• Eficiencia computacional : Debido a la estructura recursiva de RNN, debe procesar los elementos en la secuencia uno por uno, por lo que el cálculo no puede ser paralelizado.
• Problema de dependencia de larga distancia : RNN tiene dificultades para capturar dependencias de larga distancia en secuencias, y LSTM ha mejorado, pero aún no es perfecto.

Intentos de red neuronal convolucional (CNN) en el procesamiento de secuencias

Las redes neuronales convolucionales (CNN) pueden capturar dependencias locales y, de alguna manera, mejorar la captura de dependencias de largo alcance mediante el uso de convoluciones multicapa. Sin embargo, el tamaño fijo de la ventana de convolución de CNN limita el rango de dependencias que puede capturar y el manejo de las dependencias globales no es lo suficientemente flexible.

1.2 El surgimiento del mecanismo de autoatención

El mecanismo de auto atención aborda los desafíos anteriores:

• Computación en paralelo : al observar todos los elementos en una secuencia simultáneamente, el mecanismo de autoatención permite que el modelo procese la secuencia completa en paralelo.
• Captura de dependencias a larga distancia : el mecanismo de autoatención puede capturar de manera efectiva dependencias a larga distancia en secuencias, sin importar qué tan lejos estén.

La introducción de este mecanismo convierte al modelo Transformer en un avance tecnológico.

1.3 Impacto revolucionario de Transformer

La aparición de Transformer ha tenido un profundo impacto en todo el campo:

• Estableciendo nuevos estándares : Transformer establece nuevos puntos de referencia de rendimiento en múltiples tareas de NLP.
• Promover nuevas investigaciones y aplicaciones : la estructura de Transformer promueve muchas nuevas direcciones de investigación y aplicaciones prácticas, como el nacimiento de modelos avanzados como BERT y GPT.
• Impacto entre campos : además del procesamiento del lenguaje natural, Transformer también ha tenido un impacto en otros campos, como la bioinformática y el procesamiento de imágenes.

---

2. Mecanismo de autoatención

2.1 Concepto y principio de funcionamiento

El mecanismo de autoatención es una técnica que puede capturar la relación entre elementos dentro de una secuencia. Calcula la similitud de cada elemento de la secuencia con otros elementos, lo que permite la captura de dependencias globales.

• Cálculo de peso : asigne diferentes pesos a cada elemento calculando la similitud entre cada elemento en la secuencia.
• Captura de dependencia global : capaz de capturar dependencias a distancias arbitrarias en una secuencia, superando las limitaciones de los modelos anteriores.

Cálculo del peso del elemento

• Consulta, clave, estructura de valor : cada elemento de la secuencia se expresa en tres partes: consulta, clave y valor.
• Medida de similitud : use el producto escalar de Query y Key para calcular la similitud entre los elementos.
• Asignación de peso : convierta la similitud en peso mediante la función Softmax.

Por ejemplo, considere el cálculo del peso de un elemento:

import torch
import torch.nn.functional as F

# Query, Key
query = torch.tensor([1, 0.5])
key = torch.tensor([[1, 0], [0, 1]])

# 相似度计算
similarity = query.matmul(key)

# 权重分配
weights = F.softmax(similarity, dim=-1)
# 输出：tensor([0.7311, 0.2689])

suma ponderada

El mecanismo de autoatención utiliza los pesos calculados para ponderar y sumar Valor para obtener una nueva representación de cada elemento.

value = torch.tensor([[1, 2], [3, 4]])
output = weights.matmul(value)
# 输出：tensor([1.7311, 2.7311])

La diferencia entre la autoatención y la atención tradicional

Las principales diferencias entre el mecanismo de autoatención y la atención tradicional son:

• Autorreferencia : El mecanismo de autoatención es la propia atención de la secuencia a sí misma, en lugar de a las secuencias externas.
• Captura de dependencia global : no está limitada por la ventana local y puede capturar dependencias a cualquier distancia en la secuencia.

Eficiencia computacional

El mecanismo de autoatención es capaz de procesar toda la secuencia en paralelo y no está limitado por la longitud de la secuencia, logrando así una notable eficiencia computacional.

• Ventaja de paralelización : los cálculos de autoatención se pueden realizar simultáneamente, mejorando la velocidad de entrenamiento y razonamiento.

Aplicación en Transformador

En Transformer, el mecanismo de autoatención es un componente clave:

• Atención de múltiples cabezas : a través de la atención de múltiples cabezas, el modelo puede aprender diferentes dependencias al mismo tiempo, lo que mejora la expresividad del modelo.
• Visualización de peso : los pesos de autoatención se pueden usar para explicar cómo funciona el modelo, lo que aumenta la interpretabilidad.

aplicación de dominio cruzado

La influencia del mecanismo de autoatención va mucho más allá del procesamiento del lenguaje natural:

• Procesamiento de Imágenes : Aplicaciones a tareas como segmentación y reconocimiento de imágenes.
• Reconocimiento de voz : ayuda a capturar las dependencias temporales en las señales de voz.

Tendencias y desafíos futuros

A pesar del notable éxito de la autoatención, todavía hay espacio para la investigación:

• Requerimientos computacionales y de almacenamiento : La alta complejidad crea desafíos computacionales y de memoria.
• Interpretabilidad y comprensión teórica : Queda por explorar más a fondo una comprensión profunda del mecanismo de atención.

2.2 Proceso de cálculo

representación de entrada

La entrada al mecanismo de autoatención es una secuencia, que generalmente consta de un conjunto de vectores de palabras u otros elementos. Estos elementos se convertirán en tres partes: consulta, clave y valor, respectivamente.

import torch.nn as nn

embedding_dim = 64
query_layer = nn.Linear(embedding_dim, embedding_dim)
key_layer = nn.Linear(embedding_dim, embedding_dim)
value_layer = nn.Linear(embedding_dim, embedding_dim)

Cálculo de similitud

Mediante el cálculo del producto escalar de Consulta y Clave se obtiene la matriz de similitud entre cada elemento.

import torch

embedding_dim = 64

# 假设一个序列包含三个元素
sequence = torch.rand(3, embedding_dim)

query = query_layer(sequence)
key = key_layer(sequence)
value = value_layer(sequence)

def similarity(query, key):
    return torch.matmul(query, key.transpose(-2, -1)) / (embedding_dim ** 0.5)

distribución del peso

Normalice la matriz de similitud a pesos.

def compute_weights(similarity_matrix):
    return torch.nn.functional.softmax(similarity_matrix, dim=-1)

suma ponderada

Utilice la matriz de peso para ponderar y sumar el Valor para obtener el resultado.

def weighted_sum(weights, value):
    return torch.matmul(weights, value)

autoatención de múltiples cabezas

En aplicaciones prácticas, la atención de múltiples cabezas generalmente se usa para capturar información de múltiples facetas en secuencias.

class MultiHeadAttention(nn.Module):
    def __init__(self, embedding_dim, num_heads):
        super(MultiHeadAttention, self).__init__()
        self.num_heads = num_heads
        self.head_dim = embedding_dim // num_heads
        
        self.query_layer = nn.Linear(embedding_dim, embedding_dim)
        self.key_layer = nn.Linear(embedding_dim, embedding_dim)
        self.value_layer = nn.Linear(embedding_dim, embedding_dim)
        self.fc_out = nn.Linear(embedding_dim, embedding_dim)

    def forward(self, query, key, value):
        N = query.shape[0]
        query_len, key_len, value_len = query.shape[1], key.shape[1], value.shape[1]

        # 拆分多个头
        queries = self.query_layer(query).view(N, query_len, self.num_heads, self.head_dim)
        keys = self.key_layer(key).view(N, key_len, self.num_heads, self.head_dim)
        values = self.value_layer(value).view(N, value_len, self.num_heads, self.head_dim)

        # 相似度计算
        similarity_matrix = torch.einsum("nqhd,nkhd->nhqk", [queries, keys]) / (self.head_dim ** 0.5)

        # 权重分配
        weights = torch.nn.functional.softmax(similarity_matrix, dim=-1)

        # 加权求和
        attention = torch.einsum("nhql,nlhd->nqhd", [weights, values])

        # 串联多个头的输出
        attention = attention.permute(0, 2, 1, 3).contiguous().view(N, query_len, embedding_dim)

        # 通过线性层整合输出
        output = self.fc_out(attention)

        return output

---

3. La estructura del Transformador

3.1 Codificador (Codificador)

El codificador es uno de los componentes centrales del Transformador y su tarea principal es comprender y procesar los datos de entrada. El codificador construye una poderosa herramienta de mapeo de secuencia a secuencia al combinar el mecanismo de autoatención, la red neuronal de avance, la capa de normalización y la conexión residual. El mecanismo de autoatención permite que el modelo capture relaciones complejas dentro de la secuencia, y la red de avance proporciona capacidades de computación no lineal. Las capas de normalización y las conexiones residuales ayudan a estabilizar el proceso de entrenamiento.
A continuación se muestran los componentes individuales del codificador y sus descripciones detalladas.

3.1.1 Capa de autoatención

La primera parte del codificador es la capa de autoatención. Como se mencionó anteriormente, la autoatención permite que el modelo preste atención a todas las posiciones en la secuencia de entrada y codifique cada posición en función de esta información.

class SelfAttentionLayer(nn.Module):
    def __init__(self, embedding_dim, num_heads):
        super(SelfAttentionLayer, self).__init__()
        self.multi_head_attention = MultiHeadAttention(embedding_dim, num_heads)
    
    def forward(self, x):
        return self.multi_head_attention(x, x, x)

3.1.2 Red neuronal feedforward

Después de la capa de autoatención, el codificador incluye una red neuronal de avance (FFNN). Esta red consta de dos capas lineales y una función de activación.

class FeedForwardLayer(nn.Module):
    def __init__(self, embedding_dim, ff_dim):
        super(FeedForwardLayer, self).__init__()
        self.fc1 = nn.Linear(embedding_dim, ff_dim)
        self.fc2 = nn.Linear(ff_dim, embedding_dim)
        self.relu = nn.ReLU()
    
    def forward(self, x):
        return self.fc2(self.relu(self.fc1(x)))

3.1.3 Capa de normalización

Con el fin de estabilizar el entrenamiento y acelerar la convergencia, cada capa de autoatención y feed-forward es seguida por una capa de normalización (Layer Normalization).

layer_norm = nn.LayerNorm(embedding_dim)

3.1.4 Conexión residual

El Transformador también utiliza conexiones residuales para que la salida de cada capa se agregue a la entrada. Esto ayuda a prevenir gradientes que se desvanecen y explotan.

output = layer_norm(self_attention(x) + x)
output = layer_norm(feed_forward(output) + output)

3.1.5 Estructura completa del codificador

El codificador final se forma apilando N capas de este tipo.

class Encoder(nn.Module):
    def __init__(self, num_layers, embedding_dim, num_heads, ff_dim):
        super(Encoder, self).__init__()
        self.layers = nn.ModuleList([
            nn.Sequential(
                SelfAttentionLayer(embedding_dim, num_heads),
                nn.LayerNorm(embedding_dim),
                FeedForwardLayer(embedding_dim, ff_dim),
                nn.LayerNorm(embedding_dim)
            )
            for _ in range(num_layers)
        ])

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

3.2 Decodificador (Decodificador)

El decodificador es responsable de generar la secuencia objetivo en base a la salida del codificador y las secuencias de salida parciales generadas previamente. El decodificador adopta una estructura similar al codificador, pero agrega una capa de autoatención enmascarada y una capa de atención de codificador-decodificador para generar la secuencia de destino. La máscara asegura que el decodificador genera una salida en cada posición utilizando solo las posiciones anteriores. La capa de atención codificador-decodificador permite que el decodificador use la salida del codificador. Con esta estructura, el decodificador puede generar secuencias de destino que se ajusten al contexto ya la información de la secuencia de origen, lo que proporciona una solución poderosa para muchas tareas complejas de generación de secuencias.
A continuación se muestran los componentes principales del decodificador y cómo funcionan.

3.2.1 Capa de autoatención

La primera parte del decodificador es una capa de autoatención enmascarada. Esta capa es similar a la capa de autoatención en el codificador, pero agrega una máscara para evitar que las posiciones presten atención a las posiciones posteriores.

def mask_future_positions(size):
    mask = (torch.triu(torch.ones(size, size)) == 1).transpose(0, 1)
    return mask.float().masked_fill(mask == 0, float('-inf')).masked_fill(mask == 1, float(0.0))

mask = mask_future_positions(sequence_length)

3.2.2 Capa de atención codificador-decodificador

El decodificador también incluye una capa de atención codificador-decodificador que permite que el decodificador preste atención a la salida del codificador.

class EncoderDecoderAttention(nn.Module):
    def __init__(self, embedding_dim, num_heads):
        super(EncoderDecoderAttention, self).__init__()
        self.multi_head_attention = MultiHeadAttention(embedding_dim, num_heads)
    
    def forward(self, queries, keys, values):
        return self.multi_head_attention(queries, keys, values)

3.2.3 Red neuronal feedforward

El decodificador también tiene una red neuronal de avance con la misma estructura que la red neuronal de avance en el codificador.

3.2.4 Capa de normalización y conexión residual

Estos componentes también son los mismos que en el codificador y se usan después de cada subcapa.

3.2.5 La estructura completa del decodificador

El decodificador consta de una capa de autoatención, una capa de atención de codificador-decodificador, una red neuronal de avance, una capa de normalización y una conexión residual, que generalmente incluye N capas de este tipo.

class Decoder(nn.Module):
    def __init__(self, num_layers, embedding_dim, num_heads, ff_dim):
        super(Decoder, self).__init__()
        self.layers = nn.ModuleList([
            nn.Sequential(
                SelfAttentionLayer(embedding_dim, num_heads, mask=mask),
                nn.LayerNorm(embedding_dim),
                EncoderDecoderAttention(embedding_dim, num_heads),
                nn.LayerNorm(embedding_dim),
                FeedForwardLayer(embedding_dim, ff_dim),
                nn.LayerNorm(embedding_dim)
            )
            for _ in range(num_layers)
        ])

    def forward(self, x, encoder_output):
        for layer in self.layers:
            x = layer(x, encoder_output)
        return x

---

4. Varios modelos basados ​​en Transformador

Siguen surgiendo modelos basados ​​en transformadores, que brindan herramientas poderosas para una variedad de NLP y otras tareas de procesamiento de secuencias. Desde la generación de texto hasta la comprensión del contexto, estos modelos tienen diferentes ventajas y características, y juntos promueven el rápido desarrollo del campo del procesamiento del lenguaje natural. Lo que estos modelos tienen en común es que todos adoptan el concepto central del Transformer original y realizan varias innovaciones y mejoras sobre esta base. En el futuro, se puede esperar que sigan surgiendo más modelos basados ​​en transformadores, ampliando aún más su alcance e influencia de aplicación.

4.1 BERT (Representaciones de codificador bidireccional de transformadores)

BERT es un modelo basado en codificador de Transformer para generar incrustaciones de palabras sensibles al contexto. A diferencia de los métodos tradicionales de incrustación de palabras, BERT puede comprender el significado específico de las palabras en las oraciones.

caracteristica principal

• Entrenamiento bidireccional, capturando información contextual
• Pre-entrenamiento extenso para una variedad de tareas posteriores

4.2 GPT (Transformador preentrenado generativo)

A diferencia de BERT, GPT se enfoca en generar texto usando decodificadores Transformer. GPT está previamente entrenado como modelo de lenguaje y ajustado para varias tareas generativas.

caracteristica principal

• generar texto de izquierda a derecha
• Alta flexibilidad en una variedad de tareas de generación

4.3 Transformer-XL（Transformer-XL: modelos de lenguaje atento más allá de un contexto de longitud fija）

Transformer-XL aborda la limitación de longitud de contexto del modelo Transformer original mediante la introducción de un mecanismo de memoria reutilizable.

caracteristica principal

• depende del contexto más largo
• El mecanismo de memoria mejora la eficiencia

4.4 T5 (Transformador de transferencia de texto a texto)

El modelo T5 trata todas las tareas de PNL como problemas de traducción de texto a texto. Este marco unificado hace que sea muy fácil cambiar entre diferentes tareas.

caracteristica principal

• Versatilidad, adecuado para una variedad de tareas de PNL
• Simplifica la necesidad de arquitecturas específicas de tareas

4.5 XLNet

XLNet es un modelo de preentrenamiento autorregresivo de propósito general que combina las capacidades bidireccionales de BERT y las ventajas autorregresivas de GPT.

caracteristica principal

• Combinando bidireccional y autorregresivo
• Proporciona un método efectivo de pre-entrenamiento

4.6 DistilBERT

DistilBERT es una versión ligera del modelo BERT que conserva la mayor parte de su rendimiento pero con un tamaño de modelo significativamente reducido.

caracteristica principal

• Menos parámetros y cálculos
• Adecuado para escenarios con recursos limitados

4.7 ALBERT（A Lite BERT）

ALBERT es otra optimización de BERT que reduce la cantidad de parámetros mientras mejora la velocidad de entrenamiento y el rendimiento del modelo.

caracteristica principal

• intercambio de parámetros
• entrenamiento más rápido

---

V. Resumen

Desde su introducción, Transformer ha cambiado profundamente el procesamiento del lenguaje natural y muchas otras tareas de procesamiento de secuencias. A través de su exclusivo mecanismo de autoatención, Transformer supera muchas limitaciones de los modelos anteriores, lo que permite una mayor paralelización y una captura de dependencia más flexible.

En este documento, exploramos en detalle los siguientes aspectos de Transformer:

1. Antecedentes de la apariencia : Comprenda cómo nació Transformer a partir de las limitaciones de RNN y CNN, y cómo procesa las secuencias a través del mecanismo de autoatención.
2. Mecanismo de autoatención : Explica en detalle el proceso de cálculo del mecanismo de autoatención y cómo permite que el modelo establezca dependencias entre diferentes posiciones.
3. Estructura de Transformer : obtenga una visión detallada de la estructura del codificador y decodificador de Transformer, y cómo funcionan juntos los diversos componentes.
4. Varios modelos basados ​​en Transformer : Discuta una serie de modelos basados ​​en Transformer, como BERT, GPT, T5, etc., y comprenda sus características y aplicaciones.

Transformer no solo promueve la investigación y las aplicaciones en el campo del procesamiento del lenguaje natural, sino que también demuestra su potencial en otros campos, como la bioinformática, el análisis de imágenes, etc. Muchos modelos modernos de última generación se basan en Transformer y aprovechan su estructura flexible y eficiente para resolver problemas previamente intratables.

En el futuro, podemos esperar que Transformer y sus modelos derivados continúen desempeñando un papel importante en una gama más amplia de campos, innovando y promoviendo continuamente el desarrollo del campo de la inteligencia artificial.

---