CNNGPT

Modelo de linguagem baseado em CNN

Instalar

$ pip3 install -U cnngpt

Exemplos

 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 )

Explicação detalhada de cada etapa

Parâmetros de inicialização

• vocab_size : O tamanho do vocabulário (número de tokens exclusivos).
• embedding_dim : A dimensão dos embeddings.
• num_layers : o número de camadas convolucionais.
• kernel_size : O tamanho dos kernels convolucionais.
• hidden_dim : A dimensão das representações ocultas (deve corresponder embedding_dim para conexões residuais).
• max_seq_len : O comprimento máximo da sequência que o modelo pode manipular.

Incorporação e codificação posicional

• Incorporações : Converta IDs de token em vetores densos.
• Codificação posicional : adiciona uma incorporação posicional que pode ser aprendida a cada incorporação de token.

Blocos Convolucionais

• Convolução Causal : Usa preenchimento à esquerda para garantir que a convolução no tempo t não dependa de etapas de tempo futuras.
• Dilatação : Expande exponencialmente o campo receptivo, permitindo que o modelo capture dependências de longo prazo.
• Ativação GLU : introduz um mecanismo de controle que pode controlar o fluxo de informações.
  • A saída da convolução é dividida em duas metades ao longo da dimensão do canal.
  • Uma metade passa por uma função sigmóide para atuar como porta para a outra metade.
• Normalização de camada : Normaliza as saídas para melhorar a estabilidade do treinamento.
• Conexões residuais : Adiciona a entrada à saída para facilitar o treinamento de redes mais profundas.

Camada de saída

• Projeção : mapeia os estados ocultos finais para o espaço de vocabulário para produzir logits para cada token.

Manipulação de tamanhos de tensor

Em toda a rede, gerenciamos cuidadosamente as formas dos tensores para manter a consistência:

• Após incorporação e codificação posicional: [batch_size, seq_len, embedding_dim]
• Antes da convolução: transposto para [batch_size, embedding_dim, seq_len]
• Após convolução e GLU: [batch_size, hidden_dim, seq_len]
• Após a normalização da camada e conexão residual: Mesma forma da entrada para convolução para adição residual.
• Antes da camada de saída: transposto de volta para [batch_size, seq_len, embedding_dim]
• Logits de saída: [batch_size, seq_len, vocab_size]

Notas importantes

• Causalidade : Ao preencher e fatiar adequadamente as saídas de convolução, garantimos que o modelo não use informações futuras ao prever o intervalo de tempo atual.
• Conexões residuais : embedding_dim e hidden_dim devem ser iguais para adicionar corretamente a conexão residual.
• Normalização de Camada : Aplicada sobre a dimensão do recurso; transpomos o tensor para [batch_size, seq_len, hidden_dim] antes de aplicar LayerNorm .
• Função de ativação GLU : O mecanismo de ativação aumenta a capacidade do modelo de modelar padrões complexos.
• Flexibilidade : O modelo pode lidar com sequências menores que max_seq_len ; codificações posicionais são divididas de acordo.

Conclusão

Traduzimos com sucesso o algoritmo detalhado em uma implementação PyTorch, seguindo cuidadosamente cada etapa e garantindo que o código esteja alinhado com os princípios de design descritos anteriormente. Este modelo de linguagem baseado em CNN aproveita convoluções causais e dilatadas, ativações fechadas, conexões residuais e normalização de camada para modelar efetivamente dados textuais para tarefas de geração.

Ao compreender cada componente e seu papel no modelo, podemos apreciar como esta arquitetura captura dependências locais e globais na linguagem, oferecendo uma alternativa poderosa aos modelos tradicionais no processamento de linguagem natural.