Welcome to Bringing Transformers to Life: Training & Inference! Great work in getting to this point. Over the past two courses, you've journeyed from traditional sequence models to mastering the intricate components of the Transformer architecture. In our first course, you explored RNNs, LSTMs, and discovered how attention mechanisms revolutionized sequence modeling. In our second course, you meticulously deconstructed every piece of the Transformer, from multi-head attention and positional encodings to complete encoder and decoder layers.

Now, we enter an exciting new phase where theory meets practice. This course transforms your architectural knowledge into working, trainable models that can tackle real-world tasks. As we begin this first lesson of our third course, we'll take the crucial step of assembling all those carefully crafted components into a unified, fully functional Transformer model. By the end of this lesson, you'll have built a complete implementation that bridges the gap between isolated components and production-ready architectures.

Let's begin constructing our complete Transformer model by establishing its foundational structure. Notice how we bring together all the components we've built separately:

This initialization reveals the Transformer's modular design philosophy. We maintain separate embeddings for source and target vocabularies because they often represent different languages or domains; imagine translating from English (with its 170,000+ words) to Chinese (with its character-based system). The d_model parameter acts as the universal dimensionality that ensures all components speak the same mathematical language. By setting max_seq_len to 5000, we pre-compute positional encodings for sequences up to this length, striking a balance between memory efficiency and practical flexibility for most real-world applications.

Now, we integrate the encoder and decoder stacks, along with the crucial output projection layer:

The beauty of our modular approach shines here: the TransformerEncoder and TransformerDecoder classes we painstakingly built in previous lessons now slot in seamlessly. The output projection layer deserves special attention — it's essentially asking, "Given everything the decoder has learned about the sequence, what's the probability of each word in my target vocabulary being next?" This linear transformation from d_model dimensions to tgt_vocab_size dimensions creates the logits that, after softmax, become our predicted token probabilities.

Any Machine Learning model needs robust initialization and utility functions to handle real-world data complexities:

Here:

• Xavier uniform initialization ensures our model starts training from a stable point — without it, random initialization could lead to vanishing or exploding gradients that make training impossible.
• The create_padding_mask function is crucial for handling variable-length sequences: in a batch containing "Hello world" and "Hi," the shorter sequence gets padded, and this mask ensures the model ignores those meaningless pad tokens. It returns a boolean tensor of shape (batch_size, 1, 1, seq_len), which is broadcastable to attention score tensors of shape (batch_size, num_heads, query_len, key_len).
• The create_causal_mask generates a lower triangular matrix that enforces the decoder's autoregressive property, preventing it from "cheating" by looking at future tokens during training. It returns a boolean tensor of shape (1, 1, size, size), where size is the target length. In practice, the decoder self-attention mask is formed by combining the target padding mask (batch_size, 1, 1, size) with the causal mask (1, 1, size, size) via logical AND, yielding a mask of shape .

The forward pass reveals how all components collaborate to transform input sequences into output predictions:

This elegantly simple forward pass conceals sophisticated interactions. Source tokens undergo a three-stage transformation: embedding lookup converts integers to vectors, positional encoding adds sequence order information, and the encoder stack builds rich contextual representations. The decoder follows a parallel path but with a crucial difference: it receives the encoder's output as additional context through cross-attention mechanisms. The final projection transforms the decoder's abstract representations back into concrete vocabulary predictions, completing the sequence-to-sequence pipeline.

Let's validate our implementation through systematic testing that demonstrates the model's capabilities. We'll begin by setting up the model configuration and verifying its basic structure:

This configuration uses deliberately modest dimensions to enable quick verification while maintaining architectural authenticity. The different vocabulary sizes (1000 vs. 1200) demonstrate the model's flexibility, essential for tasks like translating between languages with vastly different vocabulary sizes:

Now, let's execute the forward pass and verify that our model produces the expected outputs with proper gradient flow:

The gradient flow verification is particularly crucial — it confirms that gradients propagate seamlessly from the output projection layer all the way back to the source embeddings. This end-to-end gradient flow ensures every parameter can learn during training:

With over 1.3 million parameters, our model has substantial capacity while remaining computationally manageable for educational exploration.

You've successfully assembled a complete, production-ready Transformer model that elegantly integrates every component from our architectural journey. This achievement represents more than technical implementation: you now possess a deep understanding of how token embeddings, positional encodings, attention mechanisms, and projection layers collaborate to enable powerful sequence-to-sequence transformations. Your model stands ready to tackle any task, from machine translation to text summarization, from dialogue generation to code completion.

The practice exercises ahead will solidify your understanding through hands-on experimentation with this complete architecture. As we progress through this course, we'll explore how to prepare datasets, implement efficient training loops, and deploy these models for real-world inference, transforming your theoretical mastery into practical expertise that can solve meaningful problems.