En el mundo del aprendizaje profundo, los modelos Transformer han revolucionado la inteligencia artificial al lograr un rendimiento excepcional en tareas de procesamiento de lenguaje natural y posteriormente a otras como la visi贸n por computadora. Veremos la implementaci贸n de un modelo Transformer basada en el influyente paper 鈥淎ttention is All You Need鈥, que dio origen posteriormente a ChatGPT. Adem谩s, es interesante explicar c贸mo adaptar este modelo para abordar aplicaciones m谩s avanzadas, como el procesamiento de lenguaje natural.

Implementaci贸n de la atenci贸n escalonada de producto escalado (scaled dot-product attention)

Iniciamos nuestra implementaci贸n con la piedra angular del , la capa de atenci贸n de producto escalado. Esta capa permite al modelo calcular interacciones entre elementos en una secuencia. En nuestro c贸digo, la clase `ScaledDotProductAtt` realiza esta tarea y se basa en multiplicaciones escalares de matrices. A continuaci贸n, proporcionamos explicaciones detalladas de los par谩metros y las operaciones:

– `query`, `key`, `value`: Representan las consultas, claves y valores utilizados en el c谩lculo de la atenci贸n. Ser谩n las entradas a nuestro modelo.

– `dropout`: Es un par谩metro que controla la regularizaci贸n al aplicar eliminaci贸n evitando el sobre entrenamiento (overfitting).

La atenci贸n de producto escalado calcula puntuaciones de atenci贸n mediante el producto escalar de `query` y `key`, escalado por la ra铆z cuadrada de la dimensi贸n de las claves (`key`). Luego, aplicamos la funci贸n para obtener los pesos de atenci贸n. Si se proporciona una m谩scara, se aplica para evitar que ciertos elementos se consideren en la atenci贸n.

# Scaled Dot-Product Attention
class ScaledDotProductAtt(nn.Module):
    def __init__(self, dropout=0.1):
        super(ScaledDotProductAtt, self).__init__()
        self.dropout = nn.Dropout(dropout)

    def forward(self, query, key, value, mask=None):
        attScores = torch.matmul(query, key.transpose(-2, -1)) / np.sqrt(key.size(-1))
        if mask is not None:
            attScores = attScores.masked_fill(mask == 0, -1e10)

        attention = torch.softmax(attScores, dim=-1)
        attention = self.dropout(attention)
        return torch.matmul(attention, value), attention

础迟别苍肠颈贸苍 multicabeza

El siguiente paso en nuestra implementaci贸n es la atenci贸n multicabeza. Esta capa permite al modelo enfocarse en diferentes aspectos de la entrada de manera simult谩nea. La clase `MultiHeadAttention` se encarga de esto, donde:

– `d_model`, `nhead`, `dropout`: Estos par谩metros controlan las dimensiones del modelo y la cantidad de cabezas de atenci贸n, as铆 como la regularizaci贸n.

– `d_k`, `d_v`: Representan las dimensiones de las claves y los valores en cada cabeza de atenci贸n.

– `linear_q`, `linear_k`, `linear_v`: Son capas lineales que proyectan las consultas, claves y valores en espacios de dimensiones adecuadas.

– `scaledDotProductAttention`: Es una instancia de la capa de atenci贸n de producto escalado que utilizamos.

– `linearLayer`: Otra capa lineal para transformar las salidas de las cabezas de atenci贸n.

– `dropout`: Controla la regularizaci贸n.

Esta capa divide la entrada en m煤ltiples cabezas, cada una de las cuales se procesa individualmente. Luego, las salidas se concatenan y se transforman para obtener la salida final.

# Multi-Head Attention
class MultiHeadAttention(nn.Module):
    def __init__(self, d_model, nhead, dropout=0.1):
        super(MultiHeadAttention, self).__init()
        self.d_model = d_model
        self.nhead = nhead
        self.d_k = d_model // nhead
        self.d_v = d_model // nhead

        self.linear_q = nn.Linear(d_model, d_model)
        self.linear_k = nn.Linear(d_model, d_model)
        self.linear_v = nn.Linear(d_model, d_model)

        self.scaledDotProductAttention = ScaledDotProductAtt(dropout)
        self.linearLayer = nn.Linear(d_model, d_model)
        self.dropout = nn.Dropout(dropout)

Codificaci贸n posicional

En el modelo Transformer, la codificaci贸n posicional se utiliza para que el modelo comprenda la posici贸n de las palabras en la secuencia. La clase `PositionalEncoding` se encarga de esto. Algunos par谩metros y operaciones clave son:

– `d_model`, `dropout`, `max_length`: Controlan la dimensi贸n del modelo, la regularizaci贸n y la longitud m谩xima de la secuencia.

– `pe`: Es una matriz que contiene la codificaci贸n posicional.

– `position`, `div_term`: Variables auxiliares utilizadas en el c谩lculo de la codificaci贸n posicional.

La codificaci贸n posicional se suma a las representaciones de entrada, lo que permite al modelo tener en cuenta la posici贸n de las palabras.

# Positional Encoding
class PositionalEncoding(nn.Module):
    def __init__(self, d_model, dropout=0.1, max_length=100):
        super(PositionalEncoding, self).__init()
        self.dropout = nn.Dropout(dropout)
        pe = torch.zeros(max_length, d_model)
        position = torch.arange(0, max_length, 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)

Capas de feed-forward y normalizaci贸n

Las capas de feed-forward y normalizaci贸n son componentes esenciales en cada capa del modelo:

– `d_model`, `d_mlp`, `dropout`: controlan las dimensiones del modelo, la dimensi贸n de las capas de Feed-Forward y la regularizaci贸n.

– `linear1`, `linear2`: son capas lineales utilizadas en la capa de Feed-Forward.

– `gamma`, `beta`, `epsilon`: par谩metros y constantes utilizadas en la capa de normalizaci贸n.

La capa de Feed-Forward transforma las representaciones intermedias, mientras que la Normalizaci贸n mantiene la estabilidad del entrenamiento.

# Feed-Forward Layer
class FeedForward(nn.Module):
    def __init__(self, d_model, d_mlp=1024, dropout=0.1):
        super(FeedForward, self).__init()
        self.linear1 = nn.Linear(d_model, d_mlp)
        self.dropout = nn.Dropout(dropout)
        self.linear2 = nn.Linear(d_mlp, d_model)

# Normalization Layer
class NormalizationLayer(nn.Module):
    def __init__(self, d_model, epsilon=1e-5):
        super(NormalizationLayer, self).__init()
        self.gamma = nn.Parameter(torch.ones(d_model))
        self.beta = nn.Parameter(torch.zeros(d_model))
        self.epsilon = epsilon

Modelo de lenguaje

Finalmente, ensamblamos todas estas piezas en un modelo de lenguaje completo en la clase `LanguageModel`. Aqu铆 est谩n los detalles:

– `d_model`, `nhead`, `nEncoder`, `d_mlp`, `vocab_size`, `dropout`: Controlan las dimensiones del modelo, la cantidad de cabezas de atenci贸n, el n煤mero de capas del codificador, la dimensi贸n de las capas de Feed-Forward, el tama帽o del vocabulario y la regularizaci贸n.

– `encoderLayer`, `encoderNorm`: Representan una capa del codificador y una capa de normalizaci贸n.

– `posEncoder`, `inputEmbed`, `outputLayer`: Son la codificaci贸n posicional, la capa de embedding de entrada y la capa lineal de salida.

Este modelo toma una secuencia de entrada, aplica la codificaci贸n posicional y utiliza la atenci贸n multi-cabeza y las capas de Feed-Forward para aprender representaciones significativas. Luego, una capa lineal proyecta las representaciones en las probabilidades de las palabras del vocabulario.

# Language Model
class LanguageModel(nn.Module):
    def __init__(self, d_model, nhead, nEncoder, d_mlp, vocab_size, dropout=0.1):
        super(LanguageModel, self).__init__()
        self.d_model = d_model
        encoderLayer = Encoder(d_model, nhead, d_mlp, dropout)
        encoderNorm = NormalizationLayer(d_model)
        self.encoder = nn.TransformerEncoder(encoderLayer, nEncoder, encoderNorm)
        self.posEncoder = PositionalEncoding(d_model, dropout, max_length)
        self.inputEmbed = nn.Embedding(vocab_size, d_model)
        self.outputLayer = nn.Linear(d_model, vocab_size)

Ampliando la funcionalidad: GPT-3, visi贸n y modelos multi-modales

Una vez que hemos implementado el modelo Transformer b谩sico, podemos considerar c贸mo ampliar su funcionalidad. En un mundo en constante evoluci贸n de la IA, es esencial estar al tanto de las 煤ltimas tendencias. A continuaci贸n, algunas formas de ampliar tu modelo:

  • 1. Incorporar GPT-3 o ChatGPT: Puedes combinar tu implementaci贸n con modelos de lenguaje pre-entrenados como GPT-3 o ChatGPT para dotar a tu modelo de habilidades de generaci贸n de lenguaje natural de vanguardia.
  • 2. Incorporar Visi贸n por Computadora: Para tareas de visi贸n por computadora, agrega una rama de red neuronal convolucional (CNN) a tu modelo para procesar datos de im谩genes. Esto habilita aplicaciones que requieren la comprensi贸n de texto y visi贸n.
  • 3. Explorar Modelos Multi-Modales: Considera explorar modelos multi-modales que pueden manejar datos de texto, im谩genes y otros tipos de entrada en un solo modelo.

Posibles modificaciones para un modelo de lenguaje (LLM)

Un Modelo de Lenguaje (LLM) tiene como objetivo principal predecir la probabilidad de la palabra siguiente en una secuencia de palabras. Para adaptar nuestro modelo actual a un LLM, debemos realizar las siguientes modificaciones:

1. Cambio en la funci贸n de p茅rdida

En lugar de utilizar la funci贸n de p茅rdida de entrop铆a cruzada categ贸rica, que se utiliza en tareas de clasificaci贸n, como la traducci贸n autom谩tica, necesitamos una funci贸n de p茅rdida que sea adecuada para la tarea de predicci贸n de palabras. Com煤nmente, se utiliza la p茅rdida de entrop铆a cruzada de palabras, que mide la discrepancia entre las distribuciones de probabilidad del modelo y las distribuciones reales de palabras.

# P茅rdida para un Modelo de Lenguaje (Cross-Entropy Loss)
criterion = nn.CrossEntropyLoss()

2. Modificaci贸n de los datos de entrada y salida

En un LLM, los datos de entrada y salida se organizan de manera ligeramente diferente. La entrada consiste en una secuencia de palabras hasta un punto de corte, y la salida es la palabra siguiente a predecir.

input_seq = tokens[:-1]  # Secuencia de entrada
target_seq = tokens[1:]   # Secuencia de salida (palabra siguiente)

3. Entrenamiento con datos de texto

El modelo se entrena con datos de texto sin procesar en lugar de datos clasificados. Esto significa que el preprocesamiento de los datos, como la tokenizaci贸n y la construcci贸n del vocabulario, se debe realizar antes del entrenamiento.

4. Evaluaci贸n de la generaci贸n de texto

Una vez que el modelo est谩 entrenado, se puede utilizar para generar texto aut贸nomamente. La generaci贸n de texto implica alimentar una palabra inicial y permitir que el modelo prediga palabras sucesivas de manera aut贸noma.

# Generaci贸n de texto aut贸noma
def generate_text(model, starting_word, max_length):
    current_word = starting_word
    generated_text = [current_word]
    for _ in range(max_length):
        input_seq = [current_word]
        input_seq = torch.tensor(input_seq)
        output = model(input_seq)
        predicted_word = torch.argmax(output, dim=-1)[-1].item()
        generated_text.append(predicted_word)
        current_word = predicted_word
    return generated_text

Estas modificaciones permiten que el modelo funcione como un Modelo de Lenguaje (LLM) que puede generar texto de manera aut贸noma y predecir palabras siguientes en una secuencia. La adaptaci贸n de un modelo Transformer a un LLM es un paso importante para aplicaciones como la generaci贸n de texto creativo, correcci贸n gramatical y completado autom谩tico de texto.

En resumen, construir un modelo Transformer desde cero basado en el paper original es un desaf铆o emocionante que nos brinda una base s贸lida para comprender c贸mo funcionan estos modelos. Adem谩s, ampliar la funcionalidad del modelo nos permite aprovechar todo su potencial en aplicaciones del mundo real.

La IA es una tecnolog铆a, que si bien no es nueva, est谩 generando much铆simo hype y  avanza constantemente, estar al tanto de las 煤ltimas tendencias y modelos, como los modelos multi-modales, es esencial para mantenerse actualizado en este campo en constante evoluci贸n.