Apprendre Comment Empiler des Blocs de Transformeur | Construction des Composants de Transformer

Glissez pour afficher le menu


              123456789101112131415161718192021222324252627282930313233343536373839404142434445
            
import torch
import torch.nn as nn

class EncoderBlock(nn.Module):
    def __init__(self, embed_dim, num_heads, ff_dim):
        super().__init__()
        self.attn = nn.MultiheadAttention(embed_dim, num_heads, batch_first=True)
        self.norm1 = nn.LayerNorm(embed_dim)
        self.ff = nn.Sequential(
            nn.Linear(embed_dim, ff_dim),
            nn.ReLU(),
            nn.Linear(ff_dim, embed_dim)
        )
        self.norm2 = nn.LayerNorm(embed_dim)
        
    def forward(self, x):
        attn_output, _ = self.attn(x, x, x)
        x = self.norm1(x + attn_output)
        ff_output = self.ff(x)
        x = self.norm2(x + ff_output)
        return x

class StackedEncoder(nn.Module):
    def __init__(self, num_layers, embed_dim, num_heads, ff_dim):
        super().__init__()
        self.layers = nn.ModuleList([
            EncoderBlock(embed_dim, num_heads, ff_dim) for _ in range(num_layers)
        ])
        
    def forward(self, x):
        for layer in self.layers:
            x = layer(x)
        return x

# Example usage: stack 4 encoder blocks for input text embeddings
embed_dim = 64
num_heads = 4
ff_dim = 256
num_layers = 4

stacked_encoder = StackedEncoder(num_layers, embed_dim, num_heads, ff_dim)
input_tensor = torch.rand(2, 10, embed_dim)  # batch_size=2, seq_len=10

output = stacked_encoder(input_tensor)
print("Stacked encoder output shape:", output.shape)

Lors du traitement du texte avec un Transformer, il est courant d'utiliser plusieurs blocs d'encodeur ou de décodeur empilés les uns sur les autres. Dans le code ci-dessus, vous voyez comment créer une pile de blocs d'encodeur avec PyTorch. Chaque EncoderBlock contient une auto-attention multi-tête, un réseau feed-forward et une normalisation de couche. La classe StackedEncoder construit une séquence de ces blocs, transmettant la sortie d'un bloc comme entrée au suivant. Cet empilement permet au modèle d'apprendre des représentations de plus en plus complexes du texte à chaque couche. Pour les tâches de TALN, telles que la classification de texte ou la traduction, l'empilement des blocs aide à capturer des relations et du contexte plus profonds dans les données. L'entrée initiale – le texte converti en embeddings – traverse chaque bloc d'encodeur, chaque bloc affinant la représentation en fonction à la fois de l'entrée et du contexte appris dans les couches précédentes.

Les architectures Transformer peuvent être regroupées en trois grands types, chacun adapté à différentes tâches de TALN :

Modèles encodeur uniquement

Structure : Composés d'une pile de blocs d'encodeur.
Cas d'utilisation typiques : Ces modèles sont idéaux pour la compréhension ou l'analyse de texte. Les applications courantes incluent la classification de texte, l'analyse de sentiment et la reconnaissance d'entités nommées. Un exemple bien connu de ce type est BERT.

Modèles décodeur uniquement

Structure : Composés d'une pile de blocs de décodeur.
Cas d'utilisation typiques : Ces modèles sont conçus pour la génération de texte, comme dans la modélisation du langage et la complétion de code. GPT est un exemple emblématique de modèle décodeur uniquement.

Modèles encodeur-décodeur

Structure : Combinent des blocs d'encodeur qui traitent l'entrée et des blocs de décodeur qui génèrent la sortie, avec un flux d'information de l'encodeur vers le décodeur.
Cas d'utilisation typiques : Utilisés pour les tâches de séquence à séquence où l'entrée et la sortie sont toutes deux des séquences. Les applications incluent la traduction automatique, la synthèse et la réponse à des questions. T5 et le Transformer original sont des exemples d'architectures encodeur-décodeur.

En résumé, le choix de l'architecture détermine les types de problèmes de TALN que vous pouvez résoudre : modèles encodeur uniquement pour l'analyse, modèles décodeur uniquement pour la génération, et modèles encodeur-décodeur pour les tâches nécessitant la correspondance d'une séquence à une autre.

Tout était clair ?

Merci pour vos commentaires !

Section 2. Chapitre 6

Demandez à l'IA

Posez n'importe quelle question ou essayez l'une des questions suggérées pour commencer notre discussion

Section 2. Chapitre 6