CNNGPT

CNN-Based Language Model

Install

$ pip3 install -U cnngpt

Examples

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)

Detailed Explanation of Each Step

Initialization Parameters

• vocab_size: The size of the vocabulary (number of unique tokens).
• embedding_dim: The dimension of the embeddings.
• num_layers: The number of convolutional layers.
• kernel_size: The size of the convolutional kernels.
• hidden_dim: The dimension of the hidden representations (should match embedding_dim for residual connections).
• max_seq_len: The maximum sequence length the model can handle.

Embedding and Positional Encoding

• Embeddings: Convert token IDs to dense vectors.
• Positional Encoding: Adds a learnable positional embedding to each token embedding.

Convolutional Blocks

• Causal Convolution: Uses padding on the left to ensure that the convolution at time t does not depend on future time steps.
• Dilation: Expands the receptive field exponentially, allowing the model to capture long-term dependencies.
• GLU Activation: Introduces a gating mechanism that can control the flow of information.
  • The output of the convolution is split into two halves along the channel dimension.
  • One half is passed through a sigmoid function to act as a gate for the other half.
• Layer Normalization: Normalizes the outputs to improve training stability.
• Residual Connections: Adds the input to the output to facilitate training deeper networks.

Output Layer

• Projection: Maps the final hidden states to the vocabulary space to produce logits for each token.

Handling Tensor Sizes

Throughout the network, we carefully manage tensor shapes to maintain consistency:

• After embedding and positional encoding: [batch_size, seq_len, embedding_dim]
• Before convolution: Transposed to [batch_size, embedding_dim, seq_len]
• After convolution and GLU: [batch_size, hidden_dim, seq_len]
• After layer normalization and residual connection: Same shape as input to convolution for residual addition.
• Before output layer: Transposed back to [batch_size, seq_len, embedding_dim]
• Output logits: [batch_size, seq_len, vocab_size]

Important Notes

• Causality: By appropriately padding and slicing the convolution outputs, we ensure that the model does not use future information when predicting the current time step.
• Residual Connections: The embedding_dim and hidden_dim must be equal to correctly add the residual connection.
• Layer Normalization: Applied over the feature dimension; we transpose the tensor to [batch_size, seq_len, hidden_dim] before applying LayerNorm.
• GLU Activation Function: The gating mechanism enhances the model's capacity to model complex patterns.
• Flexibility: The model can handle sequences shorter than max_seq_len; positional encodings are sliced accordingly.

Conclusion

We have successfully translated the detailed algorithm into a PyTorch implementation, carefully following each step and ensuring that the code aligns with the design principles outlined earlier. This CNN-based language model leverages causal and dilated convolutions, gated activations, residual connections, and layer normalization to effectively model textual data for generation tasks.

By understanding each component and its role in the model, we can appreciate how this architecture captures both local and global dependencies in language, offering a powerful alternative to traditional models in natural language processing.