Aprenda Como Empilhar Blocos de Transformador | Construindo Componentes de Transformers

Deslize para mostrar o 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)

Ao processar texto com um Transformer, geralmente são utilizados vários blocos de codificador ou decodificador empilhados uns sobre os outros. No código acima, é mostrado como criar uma pilha de blocos de codificador usando PyTorch. Cada EncoderBlock contém autoatenção multi-cabeça, uma rede feed-forward e normalização de camada. A classe StackedEncoder constrói uma sequência desses blocos, passando a saída de um bloco como entrada para o próximo. Esse empilhamento permite que o modelo aprenda representações cada vez mais complexas do texto em cada camada. Para tarefas de PLN, como classificação de texto ou tradução, empilhar blocos ajuda a capturar relações e contextos mais profundos nos dados. A entrada inicial – texto convertido em embeddings – percorre cada bloco de codificador, com cada bloco refinando a representação com base tanto na entrada quanto no contexto aprendido nas camadas anteriores.

Arquiteturas Transformer podem ser agrupadas em três tipos principais, cada uma adequada para diferentes tarefas de PLN:

Modelos Apenas Codificador

Estrutura: Compostos por uma pilha de blocos de codificador.
Casos de Uso Típicos: Ideais para compreensão ou análise de texto. Aplicações comuns incluem classificação de texto, análise de sentimento e reconhecimento de entidades nomeadas. Um exemplo conhecido desse tipo é o BERT.

Modelos Apenas Decodificador

Estrutura: Compostos por uma pilha de blocos de decodificador.
Casos de Uso Típicos: Projetados para geração de texto, como em modelagem de linguagem e tarefas de autocompletar código. O GPT é um exemplo proeminente de modelo apenas decodificador.

Modelos Codificador-Decodificador

Estrutura: Combinam blocos de codificador que processam a entrada e blocos de decodificador que geram a saída, com informações fluindo do codificador para o decodificador.
Casos de Uso Típicos: Utilizados para tarefas de sequência para sequência, onde tanto a entrada quanto a saída são sequências. Aplicações incluem tradução automática, sumarização e resposta a perguntas. T5 e o Transformer original são exemplos de arquiteturas codificador-decodificador.

Em resumo, a escolha da arquitetura determina os tipos de problemas de PLN que podem ser resolvidos: modelos apenas codificador para análise, apenas decodificador para geração e codificador-decodificador para tarefas que exigem mapear uma sequência em outra.

Tudo estava claro?

Obrigado pelo seu feedback!

Seção 2. Capítulo 6

Pergunte à IA

Pergunte o que quiser ou experimente uma das perguntas sugeridas para iniciar nosso bate-papo

Seção 2. Capítulo 6