CNNGPT

Modèle de langage basé sur CNN

Installer

$ pip3 install -U cnngpt

Exemples

 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 )

Explication détaillée de chaque étape

Paramètres d'initialisation

• vocab_size : La taille du vocabulaire (nombre de jetons uniques).
• embedding_dim : La dimension des intégrations.
• num_layers : Le nombre de couches convolutives.
• kernel_size : La taille des noyaux convolutifs.
• hidden_dim : La dimension des représentations cachées (doit correspondre à embedding_dim pour les connexions résiduelles).
• max_seq_len : La longueur de séquence maximale que le modèle peut gérer.

Incorporation et codage positionnel

• Embeddings : convertissez les ID de jetons en vecteurs denses.
• Encodage positionnel : ajoute une intégration positionnelle apprenable à chaque intégration de jeton.

Blocs convolutifs

• Convolution causale : utilise un remplissage sur la gauche pour garantir que la convolution au temps t ne dépend pas des pas de temps futurs.
• Dilatation : étend le champ réceptif de manière exponentielle, permettant au modèle de capturer les dépendances à long terme.
• Activation GLU : introduit un mécanisme de contrôle qui peut contrôler le flux d'informations.
  • La sortie de la convolution est divisée en deux moitiés le long de la dimension du canal.
  • Une moitié passe par une fonction sigmoïde pour servir de porte à l’autre moitié.
• Normalisation des couches : normalise les sorties pour améliorer la stabilité de l'entraînement.
• Connexions résiduelles : ajoute l'entrée à la sortie pour faciliter la formation de réseaux plus profonds.

Couche de sortie

• Projection : mappe les états cachés finaux sur l'espace de vocabulaire pour produire des logits pour chaque jeton.

Gestion des tailles de tenseurs

Dans tout le réseau, nous gérons soigneusement les formes tensorielles pour maintenir la cohérence :

• Après intégration et encodage positionnel : [batch_size, seq_len, embedding_dim]
• Avant convolution : transposé en [batch_size, embedding_dim, seq_len]
• Après convolution et GLU : [batch_size, hidden_dim, seq_len]
• Après normalisation de la couche et connexion résiduelle : même forme que l'entrée dans la convolution pour l'ajout résiduel.
• Avant la couche de sortie : retransposé en [batch_size, seq_len, embedding_dim]
• Logits de sortie : [batch_size, seq_len, vocab_size]

Remarques importantes

• Causalité : en complétant et en découpant de manière appropriée les sorties de convolution, nous garantissons que le modèle n'utilise pas d'informations futures lors de la prédiction du pas de temps actuel.
• Connexions résiduelles : embedding_dim et hidden_dim doivent être égaux pour ajouter correctement la connexion résiduelle.
• Normalisation des calques : appliquée sur la dimension de l'entité ; nous transposons le tenseur en [batch_size, seq_len, hidden_dim] avant d'appliquer LayerNorm .
• Fonction d'activation GLU : Le mécanisme de déclenchement améliore la capacité du modèle à modéliser des modèles complexes.
• Flexibilité : Le modèle peut gérer des séquences plus courtes que max_seq_len ; les codages de position sont découpés en conséquence.

Conclusion

Nous avons traduit avec succès l'algorithme détaillé dans une implémentation PyTorch, en suivant attentivement chaque étape et en veillant à ce que le code soit conforme aux principes de conception décrits précédemment. Ce modèle de langage basé sur CNN exploite les convolutions causales et dilatées, les activations fermées, les connexions résiduelles et la normalisation des couches pour modéliser efficacement les données textuelles pour les tâches de génération.

En comprenant chaque composant et son rôle dans le modèle, nous pouvons apprécier comment cette architecture capture les dépendances locales et globales du langage, offrant une alternative puissante aux modèles traditionnels de traitement du langage naturel.