CNNGPT

Modelo de lenguaje basado en CNN

Instalar

$ pip3 install -U cnngpt

Ejemplos

 import torch
from cnngpt . main import CNNLanguageModel

# Hyperparameters
vocab_size = 5000
embedding_dim = 256
num_layers = 4
kernel_size = 3
hidden_dim = 256
max_seq_len = 100

# Initialize model
model = CNNLanguageModel (
    vocab_size ,
    embedding_dim ,
    num_layers ,
    kernel_size ,
    hidden_dim ,
    max_seq_len ,
)

# Dummy input (batch_size=32, sequence_length=50)
x = torch . randint (
    0 , vocab_size , ( 32 , 50 )
)  # Random integers as token IDs

# Forward pass
logits = model ( x )  # [batch_size, seq_len, vocab_size]

# Output shape
print ( "Logits shape:" , logits . shape )

Explicación detallada de cada paso

Parámetros de inicialización

• vocab_size : el tamaño del vocabulario (número de tokens únicos).
• embedding_dim : la dimensión de las incrustaciones.
• num_layers : el número de capas convolucionales.
• kernel_size : el tamaño de los núcleos convolucionales.
• hidden_dim : La dimensión de las representaciones ocultas (debe coincidir con embedding_dim para conexiones residuales).
• max_seq_len : la longitud máxima de secuencia que el modelo puede manejar.

Incrustación y codificación posicional

• Incrustaciones : convierte ID de tokens en vectores densos.
• Codificación posicional : agrega una incrustación posicional que se puede aprender a cada incrustación de token.

Bloques convolucionales

• Convolución causal : utiliza relleno a la izquierda para garantizar que la convolución en el momento t no dependa de pasos de tiempo futuros.
• Dilatación : expande exponencialmente el campo receptivo, permitiendo que el modelo capture dependencias a largo plazo.
• Activación GLU : introduce un mecanismo de activación que puede controlar el flujo de información.
  • La salida de la convolución se divide en dos mitades a lo largo de la dimensión del canal.
  • Una mitad pasa a través de una función sigmoidea para actuar como puerta para la otra mitad.
• Normalización de capas : normaliza las salidas para mejorar la estabilidad del entrenamiento.
• Conexiones residuales : agrega la entrada a la salida para facilitar el entrenamiento de redes más profundas.

Capa de salida

• Proyección : asigna los estados ocultos finales al espacio de vocabulario para producir logits para cada token.

Manejo de tamaños de tensor

En toda la red, gestionamos cuidadosamente las formas tensoriales para mantener la coherencia:

• Después de la incrustación y la codificación posicional: [batch_size, seq_len, embedding_dim]
• Antes de la convolución: transpuesta a [batch_size, embedding_dim, seq_len]
• Después de la convolución y GLU: [batch_size, hidden_dim, seq_len]
• Después de la normalización de la capa y la conexión residual: la misma forma que la entrada a la convolución para la adición residual.
• Antes de la capa de salida: transpuesta nuevamente a [batch_size, seq_len, embedding_dim]
• Logits de salida: [batch_size, seq_len, vocab_size]

Notas importantes

• Causalidad : al rellenar y dividir adecuadamente las salidas de convolución, nos aseguramos de que el modelo no utilice información futura al predecir el paso de tiempo actual.
• Conexiones residuales : embedding_dim y hidden_dim deben ser iguales para agregar correctamente la conexión residual.
• Normalización de capa : se aplica sobre la dimensión de la característica; Transponemos el tensor a [batch_size, seq_len, hidden_dim] antes de aplicar LayerNorm .
• Función de activación de GLU : el mecanismo de activación mejora la capacidad del modelo para modelar patrones complejos.
• Flexibilidad : el modelo puede manejar secuencias más cortas que max_seq_len ; las codificaciones posicionales se dividen en consecuencia.

Conclusión

Hemos traducido con éxito el algoritmo detallado a una implementación de PyTorch, siguiendo cuidadosamente cada paso y asegurándonos de que el código se alinee con los principios de diseño descritos anteriormente. Este modelo de lenguaje basado en CNN aprovecha convoluciones causales y dilatadas, activaciones cerradas, conexiones residuales y normalización de capas para modelar eficazmente datos textuales para tareas de generación.

Al comprender cada componente y su papel en el modelo, podemos apreciar cómo esta arquitectura captura dependencias locales y globales en el lenguaje, ofreciendo una poderosa alternativa a los modelos tradicionales en el procesamiento del lenguaje natural.