diff --git "a/DeepLearning/index.html" "b/DeepLearning/index.html"
--- "a/DeepLearning/index.html"
+++ "b/DeepLearning/index.html"
@@ -10,6 +10,12 @@
     <link rel="stylesheet" href="../shared/css/design-system.css">
     <link rel="stylesheet" href="../shared/css/components.css">
 
+    <!-- MathJax 3.x -->
+    <script>
+        MathJax = { tex: { inlineMath: [['$', '$'], ['\\(', '\\)']] } };
+    </script>
+    <script id="MathJax-script" async src="https://cdn.jsdelivr.net/npm/mathjax@3/es5/tex-mml-chtml.js"></script>
+
     <style>
         * {
             margin: 0;
@@ -279,6 +285,66 @@
             color: var(--cyan);
         }
 
+        .code-block {
+            background: #0d1117;
+            border: 1px solid #30363d;
+            border-radius: 8px;
+            padding: 20px;
+            margin: 20px 0;
+            overflow-x: auto;
+            font-family: 'Fira Code', 'Consolas', monospace;
+            font-size: 0.88em;
+            line-height: 1.7;
+            white-space: pre-wrap;
+            color: #e6edf3;
+        }
+
+        .code-block .comment {
+            color: #8b949e;
+        }
+
+        .code-block .keyword {
+            color: #ff7b72;
+        }
+
+        .code-block .string {
+            color: #a5d6ff;
+        }
+
+        .code-block .function {
+            color: #d2a8ff;
+        }
+
+        .code-block .number {
+            color: #79c0ff;
+        }
+
+        .code-block .class-name {
+            color: #ffa657;
+        }
+
+        .code-block .builtin {
+            color: #79c0ff;
+        }
+
+        .code-title {
+            display: block;
+            background: #161b22;
+            color: #8b949e;
+            padding: 8px 16px;
+            border-radius: 8px 8px 0 0;
+            border: 1px solid #30363d;
+            border-bottom: none;
+            font-size: 0.85em;
+            font-family: 'Fira Code', monospace;
+            margin-top: 20px;
+        }
+
+        .code-title+.code-block {
+            margin-top: 0;
+            border-radius: 0 0 8px 8px;
+        }
+
         .callout {
             border-left: 4px solid;
             padding: 15px;
@@ -789,33 +855,56 @@
         const MODULE_CONTENT = {
             "nn-basics": {
                 overview: `
-                    <h3>What are Neural Networks?</h3>
-                    <p>Neural Networks are computational models inspired by the human brain's structure. They consist of interconnected nodes (neurons) organized in layers that process information through weighted connections.</p>
-                    
-                    <h3>Why Use Neural Networks?</h3>
-                    <ul>
-                        <li><strong>Universal Approximation:</strong> Can theoretically approximate any continuous function</li>
-                        <li><strong>Feature Learning:</strong> Automatically discover representations from raw data</li>
-                        <li><strong>Adaptability:</strong> Learn from examples without explicit programming</li>
-                        <li><strong>Parallel Processing:</strong> Highly parallelizable for modern hardware</li>
-                    </ul>
-                    
-                    <div class="callout tip">
-                        <div class="callout-title">✅ Advantages</div>
-                        • Non-linear problem solving<br>
-                        • Robust to noisy data<br>
-                        • Works with incomplete information<br>
-                        • Continuous learning capability
-                    </div>
-                    
-                    <div class="callout warning">
-                        <div class="callout-title">⚠️ Disadvantages</div>
-                        • Requires large amounts of training data<br>
-                        • Computationally expensive<br>
-                        • "Black box" - difficult to interpret<br>
-                        • Prone to overfitting without regularization
+                <p>A neural network is a computing system <strong>inspired by biological brains</strong> — but it's not a brain simulation. It's a mathematical function that learns patterns from data by adjusting millions of numbers called <strong>weights</strong>.</p>
+
+                <div class="callout insight">
+                    <div class="callout-title">🧠 The Core Intuition</div>
+                    Think of a neural network like a factory assembly line. Raw materials (data) enter one end. At each station (layer), workers (neurons) examine the material, make a small decision, and pass the result forward. By the end, the factory produces a finished product (prediction). During training, a quality inspector (loss function) checks the output and sends feedback backward through the line so each worker can improve.
+                </div>
+
+                <h3>How Does a Single Neuron Work?</h3>
+                <p>A neuron does three things:</p>
+                <div class="list-item">
+                    <div class="list-num">1</div>
+                    <div><strong>Weighted Sum:</strong> Multiply each input by a weight and add them up: $$z = w_1 x_1 + w_2 x_2 + ... + w_n x_n + b$$</div>
+                </div>
+                <div class="list-item">
+                    <div class="list-num">2</div>
+                    <div><strong>Bias:</strong> Add a bias term $b$ — this shifts the decision boundary (like the y-intercept in y = mx + b)</div>
+                </div>
+                <div class="list-item">
+                    <div class="list-num">3</div>
+                    <div><strong>Activation:</strong> Pass the result through a non-linear function: $$a = \\sigma(z)$$</div>
+                </div>
+
+                <h3>The Training Process</h3>
+                <p>Training a neural network follows a simple loop repeated thousands of times:</p>
+                <div class="info-box">
+                    <div class="box-title">🔄 The Training Loop</div>
+                    <div class="box-content">
+                        <strong>1. Forward Pass:</strong> Feed data through the network, get a prediction<br>
+                        <strong>2. Compute Loss:</strong> Measure how wrong the prediction is (e.g., MSE, Cross-Entropy)<br>
+                        <strong>3. Backward Pass:</strong> Calculate how each weight contributed to the error (gradients via chain rule)<br>
+                        <strong>4. Update Weights:</strong> Nudge each weight slightly to reduce the error: $$w_{new} = w_{old} - \\eta \\cdot \\frac{\\partial L}{\\partial w}$$
+                        <strong>5. Repeat</strong> until the loss is small enough
                     </div>
-                `,
+                </div>
+
+                <h3>Types of Layers</h3>
+                <table style="width:100%; border-collapse: collapse; margin: 15px 0;">
+                    <tr style="border-bottom: 2px solid var(--cyan);">
+                        <th style="padding: 10px; text-align: left; color: var(--cyan);">Layer Type</th>
+                        <th style="padding: 10px; text-align: left; color: var(--cyan);">Purpose</th>
+                        <th style="padding: 10px; text-align: left; color: var(--cyan);">Example</th>
+                    </tr>
+                    <tr style="border-bottom: 1px solid rgba(255,255,255,0.1);"><td style="padding: 8px;">Dense/Linear</td><td>Every neuron connects to every input</td><td>nn.Linear(784, 128)</td></tr>
+                    <tr style="border-bottom: 1px solid rgba(255,255,255,0.1);"><td style="padding: 8px;">Convolutional</td><td>Detect spatial patterns (edges, textures)</td><td>nn.Conv2d(3, 32, 3)</td></tr>
+                    <tr style="border-bottom: 1px solid rgba(255,255,255,0.1);"><td style="padding: 8px;">Recurrent (LSTM/GRU)</td><td>Process sequences (text, time series)</td><td>nn.LSTM(128, 256)</td></tr>
+                    <tr style="border-bottom: 1px solid rgba(255,255,255,0.1);"><td style="padding: 8px;">Attention</td><td>Focus on relevant parts of input</td><td>nn.MultiheadAttention()</td></tr>
+                    <tr style="border-bottom: 1px solid rgba(255,255,255,0.1);"><td style="padding: 8px;">Dropout</td><td>Regularization (randomly zero neurons)</td><td>nn.Dropout(0.5)</td></tr>
+                    <tr><td style="padding: 8px;">BatchNorm</td><td>Stabilize and speed up training</td><td>nn.BatchNorm1d(128)</td></tr>
+                </table>
+`,
                 concepts: `
                     <h3>Core Components</h3>
                     <div class="list-item">
@@ -915,144 +1004,193 @@
                         Example: Layer 784 → 128<br>
                         Params = 784 × 128 + 128 = 100,480
                     </div>
+                `,
+                code: `
+                    <h3>Build a Neuron from Scratch (NumPy)</h3>
+                    <p>Let's implement the fundamental unit of a neural network — a single neuron — using only NumPy. This helps you understand what happens <strong>under the hood</strong> before using frameworks like PyTorch.</p>
+                    <span class="code-title">📄 neuron_numpy.py</span><div class="code-block"><span class="keyword">import</span> numpy <span class="keyword">as</span> np
+
+<span class="comment"># --- A Single Neuron from Scratch ---</span>
+<span class="keyword">def</span> <span class="function">sigmoid</span>(z):
+    <span class="string">"""Activation function: squashes output to (0, 1)"""</span>
+    <span class="keyword">return</span> <span class="number">1</span> / (<span class="number">1</span> + np.exp(-z))
+
+<span class="comment"># Input features (e.g., hours studied, hours slept)</span>
+X = np.array([<span class="number">6.0</span>, <span class="number">8.0</span>])
+
+<span class="comment"># Learnable parameters</span>
+weights = np.array([<span class="number">0.5</span>, <span class="number">-0.3</span>])
+bias = <span class="number">0.1</span>
+
+<span class="comment"># Forward pass: z = w·x + b</span>
+z = np.dot(weights, X) + bias   <span class="comment"># 0.5*6 + (-0.3)*8 + 0.1 = 0.7</span>
+output = sigmoid(z)              <span class="comment"># σ(0.7) ≈ 0.668</span>
+
+<span class="keyword">print</span>(f<span class="string">"Linear output z = {z:.3f}"</span>)
+<span class="keyword">print</span>(f<span class="string">"Activated output a = {output:.3f}"</span>)</div>
+                    <h3>The Same Neuron in PyTorch</h3>
+                    <p>PyTorch wraps this into <code>nn.Linear</code>. One line replaces all the manual math above — but the computation is identical.</p>
+                    <span class="code-title">📄 neuron_pytorch.py</span><div class="code-block"><span class="keyword">import</span> torch
+<span class="keyword">import</span> torch.nn <span class="keyword">as</span> nn
+
+<span class="comment"># A single neuron: 2 inputs → 1 output</span>
+neuron = nn.Linear(in_features=<span class="number">2</span>, out_features=<span class="number">1</span>)
+
+<span class="comment"># Input tensor</span>
+X = torch.tensor([[<span class="number">6.0</span>, <span class="number">8.0</span>]])
+
+<span class="comment"># Forward pass</span>
+z = neuron(X)                    <span class="comment"># Linear: z = Wx + b</span>
+a = torch.sigmoid(z)             <span class="comment"># Activation</span>
+<span class="keyword">print</span>(f<span class="string">"Output: {a.item():.4f}"</span>)
+
+<span class="comment"># Check learnable parameters</span>
+<span class="keyword">print</span>(f<span class="string">"Weights: {neuron.weight.data}"</span>)
+<span class="keyword">print</span>(f<span class="string">"Bias: {neuron.bias.data}"</span>)
+<span class="keyword">print</span>(f<span class="string">"Total params: {sum(p.numel() for p in neuron.parameters())}"</span>)  <span class="comment"># 3</span></div>
+                    <h3>Build a Simple Neural Network</h3>
+                    <span class="code-title">📄 simple_network.py</span><div class="code-block"><span class="keyword">import</span> torch.nn <span class="keyword">as</span> nn
+
+<span class="comment"># 3-layer network: 784 → 128 → 64 → 10</span>
+model = nn.Sequential(
+    nn.Linear(<span class="number">784</span>, <span class="number">128</span>),   <span class="comment"># Hidden layer 1</span>
+    nn.ReLU(),
+    nn.Linear(<span class="number">128</span>, <span class="number">64</span>),    <span class="comment"># Hidden layer 2</span>
+    nn.ReLU(),
+    nn.Linear(<span class="number">64</span>, <span class="number">10</span>),     <span class="comment"># Output layer (10 classes)</span>
+)
+
+<span class="comment"># Count parameters</span>
+total = <span class="builtin">sum</span>(p.numel() <span class="keyword">for</span> p <span class="keyword">in</span> model.parameters())
+<span class="keyword">print</span>(f<span class="string">"Total parameters: {total:,}"</span>)  <span class="comment"># 109,386</span>
+
+<span class="comment"># Forward pass with random MNIST-like input</span>
+X = torch.randn(<span class="number">1</span>, <span class="number">784</span>)
+output = model(X)
+<span class="keyword">print</span>(f<span class="string">"Output shape: {output.shape}"</span>)  <span class="comment"># [1, 10]</span></div>
                 `
             },
             "activation": {
                 overview: `
-                    <h3>What are Activation Functions?</h3>
-                    <p>Activation functions introduce non-linearity into neural networks, enabling them to learn complex patterns. Without activation functions, a neural network would be just a linear regression model regardless of depth.</p>
-                    
-                    <h3>Why Do We Need Them?</h3>
-                    <ul>
-                        <li><strong>Non-linearity:</strong> Real-world problems are rarely linear</li>
-                        <li><strong>Complex Pattern Learning:</strong> Enable learning of intricate decision boundaries</li>
-                        <li><strong>Gradient Flow:</strong> Control how gradients propagate during backpropagation</li>
-                        <li><strong>Range Normalization:</strong> Keep activations in manageable ranges</li>
-                    </ul>
-                    
-                    <h3>Common Activation Functions Comparison</h3>
-                    <table>
-                        <tr>
-                            <th>Function</th>
-                            <th>Range</th>
-                            <th>Best Use</th>
-                            <th>Issue</th>
-                        </tr>
-                        <tr>
-                            <td>ReLU</td>
-                            <td>[0, ∞)</td>
-                            <td>Hidden layers (default)</td>
-                            <td>Dying ReLU problem</td>
-                        </tr>
-                        <tr>
-                            <td>Sigmoid</td>
-                            <td>(0, 1)</td>
-                            <td>Binary classification output</td>
-                            <td>Vanishing gradients</td>
-                        </tr>
-                        <tr>
-                            <td>Tanh</td>
-                            <td>(-1, 1)</td>
-                            <td>RNNs, zero-centered</td>
-                            <td>Vanishing gradients</td>
-                        </tr>
-                        <tr>
-                            <td>Leaky ReLU</td>
-                            <td>(-∞, ∞)</td>
-                            <td>Fixes dying ReLU</td>
-                            <td>Extra hyperparameter</td>
-                        </tr>
-                        <tr>
-                            <td>Softmax</td>
-                            <td>(0, 1) sum=1</td>
-                            <td>Multi-class output</td>
-                            <td>Computationally expensive</td>
-                        </tr>
-                        <tr>
-                            <td>GELU</td>
-                            <td>(-0.17, ∞)</td>
-                            <td>Transformers (BERT, GPT)</td>
-                            <td>Computationally expensive</td>
-                        </tr>
-                        <tr>
-                            <td>Swish</td>
-                            <td>(-0.28, ∞)</td>
-                            <td>Deep networks (40+ layers)</td>
-                            <td>Slightly slower than ReLU</td>
-                        </tr>
-                    </table>
-                `,
-                concepts: `
-                    <h3>Key Properties</h3>
-                    <div class="list-item">
-                        <div class="list-num">01</div>
-                        <div><strong>Differentiability:</strong> Must have derivatives for backpropagation to work</div>
-                    </div>
-                    <div class="list-item">
-                        <div class="list-num">02</div>
-                        <div><strong>Monotonicity:</strong> Preferably monotonic for easier optimization</div>
-                    </div>
-                    <div class="list-item">
-                        <div class="list-num">03</div>
-                        <div><strong>Zero-Centered:</strong> Helps with faster convergence (Tanh)</div>
-                    </div>
-                    <div class="list-item">
-                        <div class="list-num">04</div>
-                        <div><strong>Computational Efficiency:</strong> Should be fast to compute (ReLU wins)</div>
-                    </div>
-                    
-                    <div class="callout tip">
-                        <div class="callout-title">💡 Best Practices</div>
-                        • Use <strong>ReLU</strong> for hidden layers by default<br>
-                        • Use <strong>Sigmoid</strong> for binary classification output<br>
-                        • Use <strong>Softmax</strong> for multi-class classification<br>
-                        • Try <strong>Leaky ReLU</strong> or <strong>ELU</strong> if ReLU neurons are dying<br>
-                        • Avoid Sigmoid/Tanh in deep networks (gradient vanishing)
-                    </div>
+                <p>Activation functions are the <strong>secret sauce</strong> that gives neural networks their power. Without them, a neural network — no matter how many layers — would just be a fancy linear regression. They introduce <strong>non-linearity</strong>, which is what allows networks to learn complex patterns like recognizing faces, understanding language, or playing games.</p>
 
-                    <div class="callout warning">
-                        <div class="callout-title">⚠️ Dead Neurons (Dying ReLU Problem)</div>
-                        When a neuron's input is always negative, ReLU outputs 0 and its gradient is 0.<br>
-                        The neuron <strong>never updates</strong> — it's permanently "dead".<br><br>
-                        <strong>Solutions:</strong><br>
-                        • Use <strong>Leaky ReLU</strong> (small slope for negative values)<br>
-                        • Use <strong>ELU</strong> (exponential for negative values)<br>
-                        • Careful weight initialization (He Initialization)
-                    </div>
+                <div class="callout insight">
+                    <div class="callout-title">🧠 The Big Idea</div>
+                    Imagine trying to separate red and blue dots on a page using only straight lines. Without activation functions, that's all a neural network can do — draw straight lines. With activation functions, the network can bend, curve, and twist those lines into any shape needed to perfectly separate the dots.
+                </div>
 
-                    <h3>GELU (Gaussian Error Linear Unit)</h3>
-                    <p>Used in <strong>Transformers, BERT, and GPT</strong>. GELU multiplies the input by the probability that it's positive under a Gaussian distribution.</p>
-                    <div class="formula">
-                        GELU(x) = x × Φ(x) ≈ 0.5x(1 + tanh(√(2/π)(x + 0.044715x³)))
-                    </div>
+                <h3>Why Do We Need Activation Functions?</h3>
+                <p>Consider stacking two linear layers:</p>
+                <div class="formula">
+                    Layer 1: $$z_1 = W_1 x + b_1$$
+                    Layer 2: $$z_2 = W_2 z_1 + b_2 = W_2(W_1 x + b_1) + b_2 = (W_2 W_1)x + (W_2 b_1 + b_2)$$
+                </div>
+                <p>The result is still just <strong>one linear transformation</strong>! Adding 100 more layers changes nothing — it collapses into a single matrix multiplication. Activation functions break this linearity.</p>
 
-                    <h3>Swish (Self-Gated Activation)</h3>
-                    <p>Developed by Google researchers. Consistently matches or outperforms ReLU on deep networks.</p>
-                    <div class="formula">
-                        Swish(x) = x × σ(βx)  where σ = Sigmoid, β = learnable parameter
-                    </div>
-                    <div class="callout tip">
-                        <div class="callout-title">💡 Why Swish is Better</div>
-                        • <strong>Smooth:</strong> Doesn't abruptly change direction like ReLU at x=0<br>
-                        • <strong>Non-monotonous:</strong> Small negative values preserved (not zeroed like ReLU)<br>
-                        • <strong>Unbounded above, bounded below:</strong> Best of both worlds<br>
-                        • Best for networks with depth > 40 layers
+                <div class="info-box">
+                    <div class="box-title">Learning Objectives</div>
+                    <div class="box-content">
+                        ✓ Understand <strong>why</strong> non-linearity is essential for deep learning<br>
+                        ✓ Master 7 activation functions: Sigmoid, Tanh, ReLU, Leaky ReLU, ELU, Softmax, GELU<br>
+                        ✓ Know the <strong>vanishing gradient problem</strong> and which activations solve it<br>
+                        ✓ Learn when to use which activation (hidden layers vs. output layers)<br>
+                        ✓ Implement all activations in PyTorch
                     </div>
+                </div>
 
-                    <h3>How to Choose Activation Functions</h3>
-                    <table>
-                        <tr><th>Layer / Task</th><th>Recommended</th></tr>
-                        <tr><td>Hidden layers (default)</td><td>ReLU</td></tr>
-                        <tr><td>Regression output</td><td>Linear (no activation)</td></tr>
-                        <tr><td>Binary classification output</td><td>Sigmoid</td></tr>
-                        <tr><td>Multi-class classification</td><td>Softmax</td></tr>
-                        <tr><td>Multi-label classification</td><td>Sigmoid</td></tr>
-                        <tr><td>CNN hidden layers</td><td>ReLU</td></tr>
-                        <tr><td>RNN hidden layers</td><td>Tanh / Sigmoid</td></tr>
-                        <tr><td>Transformers</td><td>GELU</td></tr>
-                        <tr><td>Deep networks (40+ layers)</td><td>Swish</td></tr>
-                    </table>
-                `,
+                <h3>Quick Comparison Table</h3>
+                <table style="width:100%; border-collapse: collapse; margin: 15px 0;">
+                    <tr style="border-bottom: 2px solid var(--cyan);">
+                        <th style="padding: 10px; text-align: left; color: var(--cyan);">Function</th>
+                        <th style="padding: 10px; text-align: left; color: var(--cyan);">Range</th>
+                        <th style="padding: 10px; text-align: left; color: var(--cyan);">Best For</th>
+                        <th style="padding: 10px; text-align: left; color: var(--cyan);">Issue</th>
+                    </tr>
+                    <tr style="border-bottom: 1px solid rgba(255,255,255,0.1);">
+                        <td style="padding: 8px;">Sigmoid</td><td>(0, 1)</td><td>Binary output</td><td>Vanishing gradient</td>
+                    </tr>
+                    <tr style="border-bottom: 1px solid rgba(255,255,255,0.1);">
+                        <td style="padding: 8px;">Tanh</td><td>(-1, 1)</td><td>Hidden layers (older models)</td><td>Vanishing gradient</td>
+                    </tr>
+                    <tr style="border-bottom: 1px solid rgba(255,255,255,0.1);">
+                        <td style="padding: 8px;">ReLU</td><td>[0, ∞)</td><td>Default for hidden layers</td><td>Dying neurons</td>
+                    </tr>
+                    <tr style="border-bottom: 1px solid rgba(255,255,255,0.1);">
+                        <td style="padding: 8px;">Leaky ReLU</td><td>(-∞, ∞)</td><td>When ReLU neurons die</td><td>Extra hyperparameter</td>
+                    </tr>
+                    <tr style="border-bottom: 1px solid rgba(255,255,255,0.1);">
+                        <td style="padding: 8px;">GELU</td><td>≈(-0.17, ∞)</td><td>Transformers (BERT, GPT)</td><td>Slightly slower</td>
+                    </tr>
+                    <tr>
+                        <td style="padding: 8px;">Softmax</td><td>(0, 1) sums to 1</td><td>Multi-class output</td><td>Only for output layer</td>
+                    </tr>
+                </table>
+`,
+                concepts: `
+                <h3>1. Sigmoid — The Classic Gate</h3>
+                <p>Sigmoid squashes any input into the range (0, 1). Think of it as a <strong>confidence score</strong> — how sure is the network that something is true?</p>
+                <div class="formula" style="text-align:center;">$$\\sigma(z) = \\frac{1}{1 + e^{-z}}$$</div>
+                <div class="callout tip">
+                    <div class="callout-title">📌 When to Use</div>
+                    <strong>Only</strong> for the output layer of binary classification (yes/no, spam/not-spam). <strong>Never</strong> use in hidden layers — it causes the vanishing gradient problem.
+                </div>
+                <p><strong>Why it vanishes:</strong> The maximum derivative of sigmoid is just 0.25 (at z=0). When you multiply gradients across 10 layers: 0.25¹⁰ ≈ 0.00000095. The gradient essentially disappears, and the network stops learning.</p>
+
+                <h3>2. Tanh — Centered Sigmoid</h3>
+                <p>Tanh is sigmoid's improvement — it outputs values between (-1, 1), which means it's <strong>zero-centered</strong>. This helps with optimization because gradients don't all push in the same direction.</p>
+                <div class="formula" style="text-align:center;">$$\\tanh(z) = \\frac{e^z - e^{-z}}{e^z + e^{-z}} = 2\\sigma(2z) - 1$$</div>
+                <p>Fun fact: Tanh is just a rescaled sigmoid! It's better for hidden layers than sigmoid, but still vanishes for large |z|.</p>
+
+                <h3>3. ReLU — The Game Changer</h3>
+                <p>ReLU (Rectified Linear Unit) is beautifully simple: output the input if positive, else output zero. This simplicity made deep learning practical.</p>
+                <div class="formula" style="text-align:center;">$$\\text{ReLU}(z) = \\max(0, z)$$</div>
+                <div class="callout insight">
+                    <div class="callout-title">🎯 Why ReLU Changed Everything</div>
+                    <strong>1. No vanishing gradient:</strong> Gradient is exactly 1 for positive inputs — constant, never shrinking.<br>
+                    <strong>2. Sparse activation:</strong> ~50% of neurons output 0. This sparsity makes networks efficient.<br>
+                    <strong>3. Computationally cheap:</strong> Just a comparison — no exponentials like sigmoid/tanh.<br>
+                    <strong>4. Biologically plausible:</strong> Real neurons either fire or don't (all-or-nothing).
+                </div>
+                <p><strong>The Dying ReLU Problem:</strong> If a neuron's input is always negative (e.g., after a bad weight update), its gradient is permanently 0. That neuron is "dead" — it will never activate again. Solution → Leaky ReLU.</p>
+
+                <h3>4. Leaky ReLU & Parametric ReLU</h3>
+                <p>Instead of outputting 0 for negative inputs, Leaky ReLU allows a small slope (typically α=0.01):</p>
+                <div class="formula" style="text-align:center;">$$\\text{LeakyReLU}(z) = \\begin{cases} z & z > 0 \\\\ \\alpha z & z \\leq 0 \\end{cases}$$</div>
+                <p><strong>Parametric ReLU (PReLU)</strong> makes α a <em>learnable parameter</em> — the network decides the optimal slope for negative values.</p>
+
+                <h3>5. GELU — The Transformer's Choice</h3>
+                <p>GELU (Gaussian Error Linear Unit) is used in GPT, BERT, and almost all modern transformers. Unlike ReLU's hard cutoff at 0, GELU provides a <strong>smooth curve</strong>:</p>
+                <div class="formula" style="text-align:center;">$$\\text{GELU}(z) = z \\cdot \\Phi(z) \\approx 0.5z\\left(1 + \\tanh\\left[\\sqrt{\\frac{2}{\\pi}}(z + 0.044715z^3)\\right]\\right)$$</div>
+                <p>Where Φ(z) is the cumulative distribution function of the standard normal. It "softly gates" the input based on how likely it is to be positive statistically.</p>
+
+                <h3>6. Swish / SiLU</h3>
+                <p>Discovered by Google through automated search. It's simply x times sigmoid(x):</p>
+                <div class="formula" style="text-align:center;">$$\\text{Swish}(z) = z \\cdot \\sigma(z) = \\frac{z}{1 + e^{-z}}$$</div>
+                <p>Swish is smooth, non-monotonic, and consistently outperforms ReLU in deep networks (>40 layers). Used in EfficientNet.</p>
+
+                <h3>7. Softmax — Probability Distribution</h3>
+                <p>Softmax converts a vector of raw scores (logits) into a <strong>probability distribution</strong>. All outputs sum to 1.</p>
+                <div class="formula" style="text-align:center;">$$\\text{Softmax}(z_i) = \\frac{e^{z_i}}{\\sum_{j=1}^{K} e^{z_j}}$$</div>
+                <p><strong>Example:</strong> Logits [2.0, 1.0, 0.1] → Softmax [0.659, 0.242, 0.099]. The network is 65.9% confident in class 0.</p>
+
+                <div class="callout warning">
+                    <div class="callout-title">⚠️ Common Mistakes</div>
+                    1. Using Softmax in hidden layers (it's for the final output layer only)<br>
+                    2. Using Sigmoid for multi-class (use Softmax instead)<br>
+                    3. Applying Softmax manually before CrossEntropyLoss in PyTorch (it already includes softmax!)
+                </div>
+
+                <h3>Decision Guide: Which Activation to Use?</h3>
+                <div class="info-box">
+                    <div class="box-title">🎯 The Simple Rules</div>
+                    <div class="box-content">
+                        <strong>Hidden layers:</strong> Start with ReLU. If you see dying neurons, try Leaky ReLU. For Transformers, use GELU.<br><br>
+                        <strong>Output layer — Binary classification:</strong> Sigmoid (one neuron, output = probability)<br>
+                        <strong>Output layer — Multi-class:</strong> Softmax (K neurons, outputs = probabilities summing to 1)<br>
+                        <strong>Output layer — Regression:</strong> No activation (or Linear) — let the output be any real number
+                    </div>
+                </div>
+`,
                 applications: `
                     <div class="info-box">
                         <div class="box-title">🧠 Neural Network Design</div>
@@ -1083,76 +1221,153 @@
                 `,
                 math: `
                     <h3>Derivatives: The Backprop Fuel</h3>
-                    <p>Activation functions must be differentiable for backpropagation to work. Let's look at the derivatives on paper:</p>
-                    
-                    <div class="list-item">
-                        <div class="list-num">01</div>
-                        <div><strong>Sigmoid:</strong> σ(z) = 1 / (1 + e⁻ᶻ)<br>
-                        <strong>Derivative:</strong> σ'(z) = σ(z)(1 - σ(z))<br>
-                        <span class="formula-caption">Max gradient is 0.25 (at z=0). This is why deep networks vanish!</span></div>
-                    </div>
+                    <p>Activation functions must be differentiable for backpropagation to work. Here are the key formulas rendered with proper math notation:</p>
 
-                    <div class="list-item">
-                        <div class="list-num">02</div>
-                        <div><strong>Tanh:</strong> tanh(z) = (eᶻ - e⁻ᶻ) / (eᶻ + e⁻ᶻ)<br>
-                        <strong>Derivative:</strong> tanh'(z) = 1 - tanh²(z)<br>
-                        <span class="formula-caption">Max gradient is 1.0 (at z=0). Better than Sigmoid, but still vanishes.</span></div>
-                    </div>
-
-                    <div class="list-item">
-                        <div class="list-num">03</div>
-                        <div><strong>ReLU:</strong> max(0, z)<br>
-                        <strong>Derivative:</strong> 1 if z > 0, else 0<br>
-                        <span class="formula-caption">Gradient is 1.0 for all positive z. No vanishing! But 0 for negative (Dying ReLU).</span></div>
+                    <div class="formula" style="text-align:center;">
+                        <strong>Sigmoid:</strong> $$\\sigma(z) = \\frac{1}{1 + e^{-z}}, \\quad \\sigma'(z) = \\sigma(z)(1 - \\sigma(z))$$
+                        <strong>Tanh:</strong> $$\\tanh(z) = \\frac{e^z - e^{-z}}{e^z + e^{-z}}, \\quad \\tanh'(z) = 1 - \\tanh^2(z)$$
+                        <strong>ReLU:</strong> $$\\text{ReLU}(z) = \\max(0, z), \\quad \\text{ReLU}'(z) = \\begin{cases} 1 & z > 0 \\ 0 & z \\leq 0 \\end{cases}$$
+                        <strong>Leaky ReLU:</strong> $$\\text{LeakyReLU}(z) = \\begin{cases} z & z > 0 \\ \\alpha z & z \\leq 0 \\end{cases}, \\quad \\alpha = 0.01$$
+                        <strong>Softmax:</strong> $$\\text{Softmax}(z_i) = \\frac{e^{z_i}}{\\sum_{j=1}^{K} e^{z_j}}$$
                     </div>
 
                     <div class="callout insight">
-                        <div class="callout-title">📝 Paper & Pain: The Chain Effect</div>
-                        Each layer multiplies the gradient by σ'(z). <br>
-                        For 10 Sigmoid layers: Total gradient ≈ (0.25)¹⁰ ≈ <strong>0.00000095</strong><br>
-                        This is the mathematical proof of the Vanishing Gradient Problem!
-                    </div>
+                        <div class="callout-title">📝 The Vanishing Gradient Problem (Proof)</div>
+                        Each layer multiplies the gradient by $\\sigma'(z)$. For Sigmoid, $\\max(\\sigma') = 0.25$.<br>
+                        For 10 Sigmoid layers: $$\\text{Total gradient} \\approx (0.25)^{10} \\approx 0.00000095$$
+                        This is why <strong>ReLU</strong> ($\\text{gradient} = 1$) solved deep learning!
+                    </div>
+
+                    <h3>Python: Activation Functions</h3>
+                    <span class="code-title">📄 activations.py</span><div class="code-block"><span class="keyword">import</span> torch
+<span class="keyword">import</span> torch.nn.functional <span class="keyword">as</span> F
+
+x = torch.linspace(-<span class="number">5</span>, <span class="number">5</span>, <span class="number">100</span>)
+
+<span class="comment"># All common activations</span>
+relu    = F.relu(x)
+sigmoid = torch.sigmoid(x)
+tanh    = torch.tanh(x)
+leaky   = F.leaky_relu(x, negative_slope=<span class="number">0.01</span>)
+gelu    = F.gelu(x)
+swish   = x * torch.sigmoid(x)   <span class="comment"># Swish = x * σ(x)</span>
+
+<span class="comment"># Softmax (on logits)</span>
+logits = torch.tensor([<span class="number">2.0</span>, <span class="number">1.0</span>, <span class="number">0.1</span>])
+probs = F.softmax(logits, dim=<span class="number">0</span>)
+<span class="keyword">print</span>(f<span class="string">"Softmax: {probs}"</span>)  <span class="comment"># [0.659, 0.242, 0.099] → sums to 1</span>
+
+<span class="comment"># Custom activation in a model</span>
+model = torch.nn.Sequential(
+    torch.nn.Linear(<span class="number">784</span>, <span class="number">256</span>),
+    torch.nn.GELU(),            <span class="comment"># Used in Transformers</span>
+    torch.nn.Linear(<span class="number">256</span>, <span class="number">10</span>),
+)</div>
+                `,
+                code: `
+                    <h3>All Activation Functions in Python</h3>
+                    <p>Let's implement every activation function from scratch using NumPy, then see the PyTorch equivalents.</p>
+                    <span class="code-title">📄 activations_numpy.py</span><div class="code-block"><span class="keyword">import</span> numpy <span class="keyword">as</span> np
+
+<span class="comment"># --- Activation Functions from Scratch ---</span>
+
+<span class="keyword">def</span> <span class="function">sigmoid</span>(z):
+    <span class="string">"""Squashes input to (0, 1). Used for binary output."""</span>
+    <span class="keyword">return</span> <span class="number">1</span> / (<span class="number">1</span> + np.exp(-z))
+
+<span class="keyword">def</span> <span class="function">sigmoid_derivative</span>(z):
+    s = sigmoid(z)
+    <span class="keyword">return</span> s * (<span class="number">1</span> - s)  <span class="comment"># Max = 0.25 at z=0</span>
+
+<span class="keyword">def</span> <span class="function">tanh_fn</span>(z):
+    <span class="string">"""Squashes input to (-1, 1). Zero-centered."""</span>
+    <span class="keyword">return</span> np.tanh(z)
+
+<span class="keyword">def</span> <span class="function">relu</span>(z):
+    <span class="string">"""Max(0, z). Default for hidden layers."""</span>
+    <span class="keyword">return</span> np.maximum(<span class="number">0</span>, z)
+
+<span class="keyword">def</span> <span class="function">leaky_relu</span>(z, alpha=<span class="number">0.01</span>):
+    <span class="string">"""Small gradient when z < 0. Fixes dying ReLU."""</span>
+    <span class="keyword">return</span> np.where(z > <span class="number">0</span>, z, alpha * z)
+
+<span class="keyword">def</span> <span class="function">gelu</span>(z):
+    <span class="string">"""Used in BERT/GPT. Smooth approximation."""</span>
+    <span class="keyword">return</span> <span class="number">0.5</span> * z * (<span class="number">1</span> + np.tanh(np.sqrt(<span class="number">2</span>/np.pi) * (z + <span class="number">0.044715</span> * z**<span class="number">3</span>)))
+
+<span class="keyword">def</span> <span class="function">swish</span>(z):
+    <span class="string">"""z * sigmoid(z). Self-gated. Used in EfficientNet."""</span>
+    <span class="keyword">return</span> z * sigmoid(z)
+
+<span class="keyword">def</span> <span class="function">softmax</span>(z):
+    <span class="string">"""Converts logits to probabilities summing to 1."""</span>
+    exp_z = np.exp(z - np.max(z))  <span class="comment"># Numerical stability</span>
+    <span class="keyword">return</span> exp_z / exp_z.sum()
+
+<span class="comment"># --- Demo ---</span>
+z = np.linspace(-<span class="number">5</span>, <span class="number">5</span>, <span class="number">100</span>)
+<span class="keyword">print</span>(<span class="string">"Sigmoid(0) ="</span>, sigmoid(<span class="number">0</span>))          <span class="comment"># 0.5</span>
+<span class="keyword">print</span>(<span class="string">"ReLU(-3) ="</span>, relu(-<span class="number">3</span>))              <span class="comment"># 0</span>
+<span class="keyword">print</span>(<span class="string">"Leaky ReLU(-3) ="</span>, leaky_relu(-<span class="number">3</span>))  <span class="comment"># -0.03</span>
+<span class="keyword">print</span>(<span class="string">"Softmax([2,1,0.1]) ="</span>, softmax(np.array([<span class="number">2</span>, <span class="number">1</span>, <span class="number">0.1</span>])))
+</div>
+
+                    <h3>PyTorch Equivalents</h3>
+                    <span class="code-title">📄 activations_pytorch.py</span><div class="code-block"><span class="keyword">import</span> torch
+<span class="keyword">import</span> torch.nn <span class="keyword">as</span> nn
+<span class="keyword">import</span> torch.nn.functional <span class="keyword">as</span> F
+
+x = torch.randn(<span class="number">5</span>)
+
+<span class="comment"># Functional API</span>
+<span class="keyword">print</span>(<span class="string">"Sigmoid:"</span>, torch.sigmoid(x))
+<span class="keyword">print</span>(<span class="string">"ReLU:"</span>, F.relu(x))
+<span class="keyword">print</span>(<span class="string">"GELU:"</span>, F.gelu(x))
+<span class="keyword">print</span>(<span class="string">"Softmax:"</span>, F.softmax(x, dim=<span class="number">0</span>))
+
+<span class="comment"># In a model (Module API)</span>
+model = nn.Sequential(
+    nn.Linear(<span class="number">784</span>, <span class="number">256</span>),
+    nn.ReLU(),          <span class="comment"># Default for hidden layers</span>
+    nn.Linear(<span class="number">256</span>, <span class="number">128</span>),
+    nn.GELU(),          <span class="comment"># Used in Transformers</span>
+    nn.Linear(<span class="number">128</span>, <span class="number">10</span>),  <span class="comment"># No activation — CrossEntropyLoss includes Softmax</span>
+)
+</div>
                 `
             },
             "conv-layer": {
                 overview: `
-                    <h3>What are Convolutional Layers?</h3>
-                    <p>Convolutional layers are the fundamental building blocks of CNNs. They apply learnable filters (kernels) across input data to detect local patterns like edges, textures, and shapes.</p>
-                    
-                    <h3>Why Use Convolutions Instead of Fully Connected Layers?</h3>
-                    <ul>
-                        <li><strong>Parameter Efficiency:</strong> Share weights across spatial locations (fewer parameters)</li>
-                        <li><strong>Translation Invariance:</strong> Detect features regardless of position</li>
-                        <li><strong>Local Connectivity:</strong> Each neuron sees
+                <p>Convolution is the <strong>fundamental operation</strong> that makes CNNs work. Instead of connecting every input pixel to every neuron (which would be billions of parameters for an image), a small filter (kernel) <strong>slides across the image</strong>, detecting local patterns like edges, corners, and textures.</p>
 
- only a small region (receptive field)</li>
-                        <li><strong>Hierarchical Learning:</strong> Build complex features from simple ones</li>
-                    </ul>
-                    
-                    <div class="callout insight">
-                        <div class="callout-title">🔍 Example: Parameter Comparison</div>
-                        For a 224×224 RGB image:<br>
-                        • <strong>Fully Connected:</strong> 224 × 224 × 3 × 1000 = 150M parameters (for 1000 neurons)<br>
-                        • <strong>Convolutional (3×3):</strong> 3 × 3 × 3 × 64 = 1,728 parameters (for 64 filters)<br>
-                        <strong>Result:</strong> 87,000x fewer parameters! 🚀
-                    </div>
-                    
-                    <div class="callout tip">
-                        <div class="callout-title">✅ Advantages</div>
-                        • Drastically reduced parameters<br>
-                        • Spatial hierarchy (edges → textures → parts → objects)<br>
-                        • GPU-friendly (highly parallelizable)<br>
-                        • Built-in translation equivariance
-                    </div>
-                    
-                    <div class="callout warning">
-                        <div class="callout-title">⚠️ Disadvantages</div>
-                        • Not rotation invariant (require data augmentation)<br>
-                        • Fixed receptive field size<br>
-                        • Memory intensive during training<br>
-                        • Require careful hyperparameter tuning (kernel size, stride, padding)
+                <div class="callout insight">
+                    <div class="callout-title">🔍 The Flashlight Analogy</div>
+                    Imagine examining a large painting with a small flashlight in a dark room. You can only see a small patch at a time (the receptive field). As you move the flashlight across the painting (the sliding window), you notice patterns — edges, curves, colors. A convolutional layer does exactly this, but with <strong>many flashlights simultaneously</strong>, each looking for a different pattern.
+                </div>
+
+                <h3>Key Concepts</h3>
+                <div class="list-item"><div class="list-num">1</div><div><strong>Kernel/Filter:</strong> A small matrix (typically 3×3 or 5×5) of learnable weights. Each filter detects one type of pattern.</div></div>
+                <div class="list-item"><div class="list-num">2</div><div><strong>Stride:</strong> How many pixels the filter moves at each step. Stride=1 means move 1 pixel, stride=2 means skip every other position (halves output size).</div></div>
+                <div class="list-item"><div class="list-num">3</div><div><strong>Padding:</strong> Adding zeros around the border so the output has the same spatial size as the input. 'same' padding with 3×3 kernel means pad=1.</div></div>
+                <div class="list-item"><div class="list-num">4</div><div><strong>Feature Map:</strong> The output of applying one filter to the entire input. 32 filters = 32 feature maps = 32 channels in the output.</div></div>
+
+                <h3>Output Size Formula</h3>
+                <div class="formula" style="text-align:center;">
+                    $$W_{out} = \\left\\lfloor \\frac{W_{in} + 2p - k}{s} \\right\\rfloor + 1$$
+                    Where: $W_{in}$ = input size, $p$ = padding, $k$ = kernel size, $s$ = stride
+                </div>
+                <p><strong>Example:</strong> Input 32×32, kernel 3×3, stride 1, padding 1: Output = (32 + 2 - 3)/1 + 1 = <strong>32×32</strong> (same size!)</p>
+
+                <h3>Parameter Efficiency: Why CNNs Beat Dense Layers</h3>
+                <div class="info-box">
+                    <div class="box-title">📊 Parameter Comparison (32×32 RGB Image → 64 outputs)</div>
+                    <div class="box-content">
+                        <strong>Dense Layer:</strong> 32 × 32 × 3 × 64 = <span style="color:#ff6b35">196,608 parameters</span><br>
+                        <strong>Conv Layer (3×3):</strong> 3 × 3 × 3 × 64 + 64 = <span style="color:#00ff88">1,792 parameters</span><br>
+                        <strong>Savings: 110x fewer parameters!</strong> This is thanks to weight sharing and local connectivity.
                     </div>
-                `,
+                </div>
+`,
                 concepts: `
                     <h3>Key Hyperparameters</h3>
                     <div class="list-item">
@@ -1223,6 +1438,48 @@
                             Blurring, sharpening, and edge detection in Photoshop/GIMP are all done with 2D convolutions using fixed kernels.
                         </div>
                     </div>
+                `,
+                code: `
+                    <h3>Convolution Math</h3>
+                    <div class="formula" style="text-align:center;">
+                        <strong>Output Size:</strong> $$W_{out} = \\left\\lfloor \\frac{W_{in} + 2p - k}{s} \\right\\rfloor + 1$$
+                        Where $p$ = padding, $k$ = kernel size, $s$ = stride.
+                    </div>
+                    <h3>Complete CNN Classifier (CIFAR-10)</h3>
+<span class="code-title">📄 cnn_cifar10.py</span><div class="code-block"><span class="keyword">import</span> torch
+<span class="keyword">import</span> torch.nn <span class="keyword">as</span> nn
+<span class="keyword">import</span> torchvision
+<span class="keyword">import</span> torchvision.transforms <span class="keyword">as</span> T
+
+<span class="comment"># --- Data Loading ---</span>
+transform = T.Compose([T.ToTensor(), T.Normalize((<span class="number">0.5</span>,<span class="number">0.5</span>,<span class="number">0.5</span>), (<span class="number">0.5</span>,<span class="number">0.5</span>,<span class="number">0.5</span>))])
+trainset = torchvision.datasets.CIFAR10(root=<span class="string">"./data"</span>, train=<span class="keyword">True</span>, download=<span class="keyword">True</span>, transform=transform)
+trainloader = torch.utils.data.DataLoader(trainset, batch_size=<span class="number">64</span>, shuffle=<span class="keyword">True</span>)
+
+<span class="comment"># --- CNN Model ---</span>
+<span class="keyword">class</span> <span class="class-name">CNN</span>(nn.Module):
+    <span class="keyword">def</span> <span class="function">__init__</span>(self):
+        <span class="builtin">super</span>().__init__()
+        self.features = nn.Sequential(
+            nn.Conv2d(<span class="number">3</span>, <span class="number">32</span>, <span class="number">3</span>, padding=<span class="number">1</span>),   <span class="comment"># 32x32 → 32x32</span>
+            nn.BatchNorm2d(<span class="number">32</span>), nn.ReLU(),
+            nn.MaxPool2d(<span class="number">2</span>),                    <span class="comment"># → 16x16</span>
+            nn.Conv2d(<span class="number">32</span>, <span class="number">64</span>, <span class="number">3</span>, padding=<span class="number">1</span>),  <span class="comment"># → 16x16</span>
+            nn.BatchNorm2d(<span class="number">64</span>), nn.ReLU(),
+            nn.MaxPool2d(<span class="number">2</span>),                    <span class="comment"># → 8x8</span>
+            nn.Conv2d(<span class="number">64</span>, <span class="number">128</span>, <span class="number">3</span>, padding=<span class="number">1</span>), <span class="comment"># → 8x8</span>
+            nn.BatchNorm2d(<span class="number">128</span>), nn.ReLU(),
+            nn.AdaptiveAvgPool2d(<span class="number">1</span>),             <span class="comment"># → 1x1</span>
+        )
+        self.classifier = nn.Linear(<span class="number">128</span>, <span class="number">10</span>)
+    
+    <span class="keyword">def</span> <span class="function">forward</span>(self, x):
+        x = self.features(x)
+        x = x.view(x.size(<span class="number">0</span>), -<span class="number">1</span>)
+        <span class="keyword">return</span> self.classifier(x)
+
+model = CNN()
+<span class="keyword">print</span>(f<span class="string">"Parameters: {sum(p.numel() for p in model.parameters()):,}"</span>)</div>
                 `
             },
             "yolo": {
@@ -1367,88 +1624,38 @@
             },
             "transformers": {
                 overview: `
-                    <h3>📜 "Attention Is All You Need" (Vaswani et al., 2017)</h3>
-                    <div class="callout insight">
-                        <div class="callout-title">📄 Paper Reference</div>
-                        <strong>Authors:</strong> Ashish Vaswani, Noam Shazeer, Niki Parmar, Jakob Uszkoreit, Llion Jones, Aidan N. Gomez, Łukasz Kaiser, Illia Polosukhin<br>
-                        <strong>Published:</strong> NeurIPS 2017 | <strong>Citations:</strong> 100,000+<br>
-                        <strong>Link:</strong> <a href="https://arxiv.org/abs/1706.03762" target="_blank" style="color: var(--cyan);">arxiv.org/abs/1706.03762</a>
-                    </div>
-                    
-                    <h3>What are Transformers?</h3>
-                    <p>Transformers are neural architectures based <strong>entirely on attention mechanisms</strong>, completely eliminating recurrence and convolutions. This groundbreaking paper introduced the architecture that now powers GPT-4, Claude, BERT, and virtually all modern AI.</p>
-                    
-                    <h3>The Problem with RNNs/LSTMs</h3>
-                    <ul>
-                        <li><strong>Sequential Processing:</strong> RNNs must process tokens one-by-one, preventing parallelization</li>
-                        <li><strong>Memory Bottleneck:</strong> Hidden state must compress entire history into fixed-size vector</li>
-                        <li><strong>Long-Range Dependencies:</strong> Gradients vanish/explode over long sequences</li>
-                        <li><strong>Slow Training:</strong> Cannot leverage GPU parallelism effectively</li>
-                    </ul>
-                    
-                    <h3>The Transformer Solution</h3>
-                    <ul>
-                        <li><strong>Parallelization:</strong> Process entire sequence at once (O(1) sequential operations)</li>
-                        <li><strong>Direct Connections:</strong> Any position can attend to any other position directly</li>
-                        <li><strong>No Vanishing Gradients:</strong> Attention + residual connections maintain gradient flow</li>
-                        <li><strong>Massive Scalability:</strong> Performance scales with compute and data</li>
-                    </ul>
-                    
-                    <div class="callout tip">
-                        <div class="callout-title">✅ Paper's Key Results</div>
-                        • <strong>WMT 2014 English-to-German:</strong> 28.4 BLEU (new SOTA, +2 over previous best)<br>
-                        • <strong>WMT 2014 English-to-French:</strong> 41.8 BLEU (single model SOTA)<br>
-                        • <strong>Training Time:</strong> 3.5 days on 8 GPUs (fraction of previous models)<br>
-                        • <strong>English Constituency Parsing:</strong> Generalizes beyond translation
-                    </div>
-                    
-                    <div class="callout warning">
-                        <div class="callout-title">⚠️ Limitations Acknowledged in Paper</div>
-                        • <strong>Quadratic Complexity:</strong> O(n²) memory for sequence length n<br>
-                        • <strong>No Positional Bias:</strong> Must explicitly inject position information<br>
-                        • <strong>Data Hungry:</strong> Requires large datasets to train from scratch
+                <p>The Transformer architecture, introduced in the 2017 paper <strong>"Attention Is All You Need"</strong>, is the foundation of modern AI. GPT, BERT, LLaMA, DALL-E, Stable Diffusion — they all use Transformers. The key innovation: <strong>self-attention</strong>, which lets every token in a sequence directly attend to every other token.</p>
+
+                <div class="callout insight">
+                    <div class="callout-title">🎭 The Conference Room Analogy</div>
+                    Imagine a meeting where everyone can hear everyone else simultaneously (unlike RNNs where information passes person-to-person in a chain). Each person (token) decides who to pay attention to based on relevance. The CEO might focus on the CFO for budget discussions but the CTO for technical decisions. This dynamic, context-dependent attention is what Transformers do.
+                </div>
+
+                <h3>Transformer Architecture</h3>
+                <div class="list-item"><div class="list-num">1</div><div><strong>Input Embedding + Positional Encoding:</strong> Convert tokens to vectors and add position information (since attention has no inherent sense of order)</div></div>
+                <div class="list-item"><div class="list-num">2</div><div><strong>Multi-Head Self-Attention:</strong> Each head learns a different type of relationship. Head 1 might learn syntactic dependencies, Head 2 might learn semantic similarity.</div></div>
+                <div class="list-item"><div class="list-num">3</div><div><strong>Feed-Forward Network:</strong> A two-layer MLP applied independently to each position. This is where most of the model's "knowledge" is stored.</div></div>
+                <div class="list-item"><div class="list-num">4</div><div><strong>Layer Normalization + Residual Connections:</strong> Applied around each sub-layer to stabilize training.</div></div>
+
+                <h3>Self-Attention: The Heart of Transformers</h3>
+                <div class="formula" style="text-align:center;">
+                    $$\\text{Attention}(Q, K, V) = \\text{softmax}\\left(\\frac{QK^T}{\\sqrt{d_k}}\\right)V$$
+                </div>
+                <p><strong>Q (Query):</strong> "What am I looking for?"<br>
+                <strong>K (Key):</strong> "What do I contain?"<br>
+                <strong>V (Value):</strong> "What information do I provide?"</p>
+                <p>The $\\sqrt{d_k}$ scaling prevents the dot products from becoming too large (which would make softmax saturate and kill gradients).</p>
+
+                <h3>Why Transformers Beat RNNs</h3>
+                <div class="info-box">
+                    <div class="box-title">Speed & Power Comparison</div>
+                    <div class="box-content">
+                        <strong>Parallelization:</strong> RNNs process tokens sequentially (slow). Transformers process all tokens at once (fast). GPT-3 training would take 355 years with RNNs.<br>
+                        <strong>Long-range dependencies:</strong> RNNs lose information over long sequences. Transformers can attend to any position directly.<br>
+                        <strong>Scalability:</strong> Transformers scale to billions of parameters with predictable improvements (scaling laws).
                     </div>
-                    
-                    <h3>Transformer Variants (Evolution)</h3>
-                    <table>
-                        <tr>
-                            <th>Model</th>
-                            <th>Type</th>
-                            <th>Architecture</th>
-                            <th>Best For</th>
-                        </tr>
-                        <tr>
-                            <td>Original Transformer</td>
-                            <td>Encoder-Decoder</td>
-                            <td>Full (6+6 layers)</td>
-                            <td>Machine Translation</td>
-                        </tr>
-                        <tr>
-                            <td>BERT (2018)</td>
-                            <td>Encoder-only</td>
-                            <td>Bidirectional</td>
-                            <td>Understanding (NLU)</td>
-                        </tr>
-                        <tr>
-                            <td>GPT (2018-2023)</td>
-                            <td>Decoder-only</td>
-                            <td>Autoregressive</td>
-                            <td>Generation (NLG)</td>
-                        </tr>
-                        <tr>
-                            <td>T5 (2019)</td>
-                            <td>Encoder-Decoder</td>
-                            <td>Text-to-Text</td>
-                            <td>All NLP tasks</td>
-                        </tr>
-                        <tr>
-                            <td>ViT (2020)</td>
-                            <td>Encoder-only</td>
-                            <td>Image patches</td>
-                            <td>Computer Vision</td>
-                        </tr>
-                    </table>
-                `,
+                </div>
+`,
                 concepts: `
                     <h3>🏗️ Complete Architecture Overview</h3>
                     <p>The Transformer follows an <strong>Encoder-Decoder</strong> structure, but each component uses only attention mechanisms.</p>
@@ -1880,6 +2087,47 @@ output, attn_weights = mha(x, x, x)  <span style="color: #6c7086;"># Self-attent
                         Copy the code above and run it in a Jupyter notebook or Google Colab.<br>
                         Experiment with different d_model, n_heads, and seq_len values!
                     </div>
+                `,
+                code: `
+                    <h3>Self-Attention (Scaled Dot-Product)</h3>
+                    <div class="formula" style="text-align:center;">
+                        $$\\text{Attention}(Q, K, V) = \\text{softmax}\\left(\\frac{QK^T}{\\sqrt{d_k}}\\right)V$$
+                        Where $Q = XW^Q$, $K = XW^K$, $V = XW^V$
+                    </div>
+                    <div class="formula" style="text-align:center;">
+                        <strong>Multi-Head:</strong> $$\\text{MultiHead}(Q,K,V) = \\text{Concat}(head_1, ..., head_h)W^O$$
+                        <strong>Positional Encoding:</strong> $$PE_{(pos, 2i)} = \\sin(pos / 10000^{2i/d}), \\quad PE_{(pos, 2i+1)} = \\cos(pos / 10000^{2i/d})$$
+                    </div>
+<span class="code-title">📄 transformer_from_scratch.py</span><div class="code-block"><span class="keyword">import</span> torch
+<span class="keyword">import</span> torch.nn <span class="keyword">as</span> nn
+<span class="keyword">import</span> math
+
+<span class="keyword">class</span> <span class="class-name">SelfAttention</span>(nn.Module):
+    <span class="keyword">def</span> <span class="function">__init__</span>(self, d_model, n_heads):
+        <span class="builtin">super</span>().__init__()
+        self.d_k = d_model // n_heads
+        self.n_heads = n_heads
+        self.W_q = nn.Linear(d_model, d_model)
+        self.W_k = nn.Linear(d_model, d_model)
+        self.W_v = nn.Linear(d_model, d_model)
+        self.W_o = nn.Linear(d_model, d_model)
+    
+    <span class="keyword">def</span> <span class="function">forward</span>(self, x):
+        B, T, C = x.shape
+        Q = self.W_q(x).view(B, T, self.n_heads, self.d_k).transpose(<span class="number">1</span>,<span class="number">2</span>)
+        K = self.W_k(x).view(B, T, self.n_heads, self.d_k).transpose(<span class="number">1</span>,<span class="number">2</span>)
+        V = self.W_v(x).view(B, T, self.n_heads, self.d_k).transpose(<span class="number">1</span>,<span class="number">2</span>)
+        
+        <span class="comment"># Scaled Dot-Product Attention</span>
+        scores = (Q @ K.transpose(-<span class="number">2</span>,-<span class="number">1</span>)) / math.sqrt(self.d_k)
+        attn = torch.softmax(scores, dim=-<span class="number">1</span>)
+        out = (attn @ V).transpose(<span class="number">1</span>,<span class="number">2</span>).reshape(B, T, C)
+        <span class="keyword">return</span> self.W_o(out)
+
+<span class="comment"># Test</span>
+attn = SelfAttention(d_model=<span class="number">512</span>, n_heads=<span class="number">8</span>)
+x = torch.randn(<span class="number">2</span>, <span class="number">10</span>, <span class="number">512</span>)  <span class="comment"># (batch, seq_len, d_model)</span>
+<span class="keyword">print</span>(attn(x).shape)  <span class="comment"># (2, 10, 512)</span></div>
                 `
             },
             "perceptron": {
@@ -2138,26 +2386,27 @@ output, attn_weights = mha(x, x, x)  <span style="color: #6c7086;"># Self-attent
             },
             "loss": {
                 overview: `
-                    <h3>Loss Functions Guide</h3>
-                    <table>
-                        <tr>
-                            <th>Task</th>
-                            <th>Loss Function</th>
-                        </tr>
-                        <tr>
-                            <td>Binary Classification</td>
-                            <td>Binary Cross-Entropy</td>
-                        </tr>
-                        <tr>
-                            <td>Multi-class</td>
-                            <td>Categorical Cross-Entropy</td>
-                        </tr>
-                        <tr>
-                            <td>Regression</td>
-                            <td>MSE or MAE</td>
-                        </tr>
-                    </table>
-                `,
+                <p>The loss function is the <strong>judge</strong> of your neural network. It measures how wrong the network's predictions are compared to the true answers. The entire goal of training is to <strong>minimize this number</strong>.</p>
+
+                <div class="callout insight">
+                    <div class="callout-title">🎯 Why Loss Functions Matter</div>
+                    The choice of loss function determines <em>what</em> the network optimizes for. Use the wrong loss and you'll get a network that's great at the wrong thing. For example, using MSE for classification gives equal penalty to being "slightly wrong" and "completely wrong" — which isn't what you want.
+                </div>
+
+                <h3>Matching Loss to Task</h3>
+                <table style="width:100%; border-collapse: collapse; margin: 15px 0;">
+                    <tr style="border-bottom: 2px solid var(--cyan);">
+                        <th style="padding: 10px; text-align: left; color: var(--cyan);">Task</th>
+                        <th style="padding: 10px; text-align: left; color: var(--cyan);">Loss Function</th>
+                        <th style="padding: 10px; text-align: left; color: var(--cyan);">Output Activation</th>
+                        <th style="padding: 10px; text-align: left; color: var(--cyan);">PyTorch</th>
+                    </tr>
+                    <tr style="border-bottom: 1px solid rgba(255,255,255,0.1);"><td style="padding: 8px;">Regression</td><td>MSE / MAE / Huber</td><td>None (Linear)</td><td>nn.MSELoss()</td></tr>
+                    <tr style="border-bottom: 1px solid rgba(255,255,255,0.1);"><td style="padding: 8px;">Binary Classification</td><td>Binary Cross-Entropy</td><td>Sigmoid</td><td>nn.BCEWithLogitsLoss()</td></tr>
+                    <tr style="border-bottom: 1px solid rgba(255,255,255,0.1);"><td style="padding: 8px;">Multi-class</td><td>Categorical Cross-Entropy</td><td>Softmax (built-in)</td><td>nn.CrossEntropyLoss()</td></tr>
+                    <tr><td style="padding: 8px;">Object Detection</td><td>Focal Loss + IoU Loss</td><td>Varies</td><td>Custom</td></tr>
+                </table>
+`,
                 concepts: `
                     <h3>Common Loss Functions</h3>
                     <div class="list-item">
@@ -2271,47 +2520,109 @@ output, attn_weights = mha(x, x, x)  <span style="color: #6c7086;"># Self-attent
                         <div class="list-num">💡</div>
                         <div>This is beautiful: the gradient depends <strong>only on the error</strong> (ŷ-y), not on how saturated the neuron is. This enables much faster training.</div>
                     </div>
+                `,
+                code: `
+                    <h3>Loss Functions (MathJax)</h3>
+                    <div class="formula" style="text-align:center;">
+                        <strong>MSE (Regression):</strong> $$L = \\frac{1}{n}\\sum_{i=1}^{n}(y_i - \\hat{y}_i)^2$$
+                        <strong>Binary Cross-Entropy:</strong> $$L = -\\frac{1}{n}\\sum[y\\log(\\hat{y}) + (1-y)\\log(1-\\hat{y})]$$
+                        <strong>Categorical Cross-Entropy:</strong> $$L = -\\sum_{c=1}^{C} y_c \\log(\\hat{y}_c)$$
+                    </div>
+<span class="code-title">📄 loss_functions.py</span><div class="code-block"><span class="keyword">import</span> torch
+<span class="keyword">import</span> torch.nn <span class="keyword">as</span> nn
+
+<span class="comment"># --- MSE Loss (Regression) ---</span>
+mse = nn.MSELoss()
+pred = torch.tensor([<span class="number">2.5</span>, <span class="number">0.0</span>, <span class="number">2.1</span>])
+target = torch.tensor([<span class="number">3.0</span>, <span class="number">-0.5</span>, <span class="number">2.0</span>])
+<span class="keyword">print</span>(f<span class="string">"MSE: {mse(pred, target).item():.4f}"</span>)
+
+<span class="comment"># --- Binary Cross-Entropy (Binary Classification) ---</span>
+bce = nn.BCEWithLogitsLoss()  <span class="comment"># includes sigmoid</span>
+logits = torch.tensor([<span class="number">1.5</span>, <span class="number">-0.5</span>, <span class="number">2.0</span>])
+labels = torch.tensor([<span class="number">1.0</span>, <span class="number">0.0</span>, <span class="number">1.0</span>])
+<span class="keyword">print</span>(f<span class="string">"BCE: {bce(logits, labels).item():.4f}"</span>)
+
+<span class="comment"># --- Cross-Entropy (Multi-class) ---</span>
+ce = nn.CrossEntropyLoss()  <span class="comment"># includes softmax internally</span>
+logits = torch.tensor([[<span class="number">2.0</span>, <span class="number">1.0</span>, <span class="number">0.1</span>]])
+target = torch.tensor([<span class="number">0</span>])  <span class="comment"># class index</span>
+<span class="keyword">print</span>(f<span class="string">"CE: {ce(logits, target).item():.4f}"</span>)</div>
                 `
             },
             "optimizers": {
                 overview: `
-                    <h3>Optimizer Selection Guide</h3>
-                    <table>
-                        <tr>
-                            <th>Optimizer</th>
-                            <th>When to Use</th>
-                        </tr>
-                        <tr>
-                            <td>Adam/AdamW</td>
-                            <td><strong>Default choice</strong> - works 90% of time</td>
-                        </tr>
-                        <tr>
-                            <td>SGD + Momentum</td>
-                            <td>CNNs (better final accuracy with patience)</td>
-                        </tr>
-                        <tr>
-                            <td>RMSprop</td>
-                            <td>RNNs</td>
-                        </tr>
-                    </table>
-                    
-                    <div class="formula">
-                        Adam: m_t = β₁·m + (1-β₁)·∇L<br>
-                        v_t = β₂·v + (1-β₂)·(∇L)²<br>
-                        w = w - α·m_t/√(v_t)
+                <p>Optimizers are the <strong>algorithms that actually update the weights</strong> during training. Think of training as hiking down a foggy mountain — you can't see the bottom (global minimum), but you can feel the slope beneath your feet (gradient). The optimizer decides <strong>how big a step to take</strong> and <strong>in which direction</strong>.</p>
+
+                <div class="callout insight">
+                    <div class="callout-title">🏔️ The Mountain Analogy</div>
+                    <strong>SGD</strong> = Walking downhill with fixed-size steps. Simple but slow.<br>
+                    <strong>Momentum</strong> = Rolling a ball downhill — it builds up speed on consistent slopes.<br>
+                    <strong>Adam</strong> = A smart hiker with GPS who adapts step size per-dimension and remembers past terrain.
+                </div>
+
+                <h3>The Optimization Problem</h3>
+                <p>Training finds weights that <strong>minimize the loss function</strong>. The loss surface is a high-dimensional landscape with valleys (good), plateaus (stuck), and saddle points (tricky). Different optimizers navigate this landscape differently.</p>
+                <div class="formula" style="text-align:center;">
+                    $$\\theta^* = \\arg\\min_{\\theta} L(\\theta; X, y)$$
+                </div>
+
+                <h3>Learning Rate: The Most Important Hyperparameter</h3>
+                <div class="info-box">
+                    <div class="box-title">⚡ Learning Rate Effects</div>
+                    <div class="box-content">
+                        <strong>Too high (0.1):</strong> Overshoots the minimum, loss oscillates wildly or diverges to infinity<br>
+                        <strong>Too low (0.00001):</strong> Converges extremely slowly, might get stuck in local minima<br>
+                        <strong>Just right (0.001):</strong> Smooth convergence to a good minimum<br><br>
+                        <strong>Rule of thumb:</strong> Start with lr=0.001 for Adam, lr=0.01 for SGD. Use learning rate schedulers (cosine annealing, step decay) to reduce lr during training.
                     </div>
-                `,
+                </div>
+`,
                 concepts: `
-                    <h3>Optimizer Evolution</h3>
-                    <div class="list-item">
-                        <div class="list-num">01</div>
-                        <div><strong>SGD:</strong> Simple but requires careful learning rate tuning</div>
-                    </div>
-                    <div class="list-item">
-                        <div class="list-num">02</div>
-                        <div><strong>Adam:</strong> Adaptive rates + momentum = works out-of-box</div>
-                    </div>
-                `,
+                <h3>1. SGD (Stochastic Gradient Descent)</h3>
+                <p>The simplest optimizer. Compute the gradient on a mini-batch and take a step proportional to the learning rate:</p>
+                <div class="formula" style="text-align:center;">$$\\theta_{t+1} = \\theta_t - \\eta \\nabla L(\\theta_t)$$</div>
+                <p><strong>Problem:</strong> SGD oscillates in ravines (narrow valleys) and is slow on plateaus. It treats all parameters equally regardless of how frequently they update.</p>
+
+                <h3>2. SGD with Momentum</h3>
+                <p>Adds a "velocity" term that remembers past gradients. Like a ball rolling downhill — it accelerates when the gradient consistently points the same direction:</p>
+                <div class="formula" style="text-align:center;">
+                    $$v_t = \\gamma v_{t-1} + \\eta \\nabla L(\\theta_t)$$
+                    $$\\theta_{t+1} = \\theta_t - v_t$$
+                </div>
+                <p>Where $\\gamma$ is the momentum coefficient (typically 0.9). This dampens oscillations and speeds convergence 2-10x.</p>
+
+                <h3>3. RMSprop</h3>
+                <p>Adapts the learning rate <strong>per parameter</strong>. Parameters with large gradients get smaller updates, and vice versa:</p>
+                <div class="formula" style="text-align:center;">
+                    $$s_t = \\beta s_{t-1} + (1-\\beta)g_t^2$$
+                    $$\\theta_{t+1} = \\theta_t - \\frac{\\eta}{\\sqrt{s_t + \\epsilon}} g_t$$
+                </div>
+                <p>Invented by Geoff Hinton in a Coursera lecture slide (never formally published!).</p>
+
+                <h3>4. Adam (Adaptive Moment Estimation) ⭐</h3>
+                <p><strong>The default optimizer for most deep learning.</strong> It combines the best of Momentum (first moment) and RMSprop (second moment):</p>
+                <div class="formula" style="text-align:center;">
+                    $$m_t = \\beta_1 m_{t-1} + (1-\\beta_1)g_t \\quad \\text{(1st moment: mean of gradients)}$$
+                    $$v_t = \\beta_2 v_{t-1} + (1-\\beta_2)g_t^2 \\quad \\text{(2nd moment: variance of gradients)}$$
+                    $$\\hat{m}_t = \\frac{m_t}{1-\\beta_1^t}, \\quad \\hat{v}_t = \\frac{v_t}{1-\\beta_2^t} \\quad \\text{(bias correction)}$$
+                    $$\\theta_{t+1} = \\theta_t - \\frac{\\eta \\hat{m}_t}{\\sqrt{\\hat{v}_t} + \\epsilon}$$
+                </div>
+                <p>Default hyperparameters: $\\beta_1=0.9$, $\\beta_2=0.999$, $\\epsilon=10^{-8}$, $\\eta=0.001$.</p>
+
+                <h3>5. AdamW (Adam with Decoupled Weight Decay)</h3>
+                <p>Standard Adam applies weight decay <em>inside</em> the adaptive learning rate, which doesn't regularize properly. AdamW <strong>decouples</strong> weight decay from the gradient update:</p>
+                <div class="formula" style="text-align:center;">$$\\theta_{t+1} = (1 - \\lambda)\\theta_t - \\frac{\\eta \\hat{m}_t}{\\sqrt{\\hat{v}_t} + \\epsilon}$$</div>
+                <p><strong>Used by:</strong> GPT, BERT, LLaMA, and virtually all modern large models.</p>
+
+                <div class="callout tip">
+                    <div class="callout-title">🎯 Which Optimizer Should You Use?</div>
+                    <strong>Default:</strong> Adam or AdamW with lr=0.001<br>
+                    <strong>Computer Vision:</strong> SGD with Momentum (lr=0.01, momentum=0.9) often generalizes better<br>
+                    <strong>Large Language Models:</strong> AdamW with cosine lr schedule and warmup<br>
+                    <strong>Fine-tuning pretrained:</strong> AdamW with very low lr (2e-5 to 5e-5)
+                </div>
+`,
                 applications: `
                     <div class="info-box">
                         <div class="box-title">🚀 Training Acceleration</div>
@@ -2447,45 +2758,123 @@ output, attn_weights = mha(x, x, x)  <span style="color: #6c7086;"># Self-attent
                         m₀ = 0, v₀ = 0 initialization biases early estimates toward zero.<br>
                         Dividing by (1 - βᵗ) compensates for this, especially in early training steps.
                     </div>
-                `
+                `,
+                code: `
+                    <h3>Implementing Optimizers in PyTorch</h3>
+                    <p>PyTorch provides all common optimizers in <code>torch.optim</code>. Here's a complete example showing how to use them and how to implement SGD from scratch.</p>
+                    <span class="code-title">📄 optimizers_comparison.py</span><div class="code-block"><span class="keyword">import</span> torch
+<span class="keyword">import</span> torch.nn <span class="keyword">as</span> nn
+<span class="keyword">import</span> torch.optim <span class="keyword">as</span> optim
+
+<span class="comment"># --- Simple model for demonstration ---</span>
+model = nn.Sequential(
+    nn.Linear(<span class="number">784</span>, <span class="number">256</span>),
+    nn.ReLU(),
+    nn.Linear(<span class="number">256</span>, <span class="number">10</span>),
+)
+
+<span class="comment"># ====== 1. SGD ======</span>
+optimizer = optim.SGD(model.parameters(), lr=<span class="number">0.01</span>)
+
+<span class="comment"># ====== 2. SGD with Momentum ======</span>
+optimizer = optim.SGD(model.parameters(), lr=<span class="number">0.01</span>, momentum=<span class="number">0.9</span>)
+
+<span class="comment"># ====== 3. Adam (Most Common) ======</span>
+optimizer = optim.Adam(model.parameters(), lr=<span class="number">0.001</span>)
+
+<span class="comment"># ====== 4. AdamW (For Transformers/LLMs) ======</span>
+optimizer = optim.AdamW(model.parameters(), lr=<span class="number">0.001</span>, weight_decay=<span class="number">0.01</span>)
+
+<span class="comment"># ====== Training Loop ======</span>
+criterion = nn.CrossEntropyLoss()
+
+<span class="keyword">for</span> epoch <span class="keyword">in</span> range(<span class="number">10</span>):
+    <span class="keyword">for</span> X_batch, y_batch <span class="keyword">in</span> train_loader:
+        <span class="comment"># 1. Forward pass</span>
+        predictions = model(X_batch)
+        loss = criterion(predictions, y_batch)
+
+        <span class="comment"># 2. Backward pass</span>
+        optimizer.zero_grad()     <span class="comment"># Clear old gradients</span>
+        loss.backward()           <span class="comment"># Compute gradients</span>
+
+        <span class="comment"># 3. Update weights</span>
+        optimizer.step()          <span class="comment"># Apply optimizer rule</span>
+
+    <span class="keyword">print</span>(f<span class="string">"Epoch {epoch+1}, Loss: {loss.item():.4f}"</span>)
+</div>
+
+                    <h3>SGD from Scratch</h3>
+                    <p>Understanding what happens inside <code>optimizer.step()</code>:</p>
+                    <span class="code-title">📄 sgd_from_scratch.py</span><div class="code-block"><span class="keyword">import</span> numpy <span class="keyword">as</span> np
+
+<span class="keyword">class</span> <span class="function">SGD</span>:
+    <span class="string">"""Stochastic Gradient Descent with Momentum."""</span>
+    <span class="keyword">def</span> <span class="function">__init__</span>(self, params, lr=<span class="number">0.01</span>, momentum=<span class="number">0.9</span>):
+        self.params = params
+        self.lr = lr
+        self.momentum = momentum
+        self.velocities = [np.zeros_like(p) <span class="keyword">for</span> p <span class="keyword">in</span> params]
+
+    <span class="keyword">def</span> <span class="function">step</span>(self, gradients):
+        <span class="keyword">for</span> i, (param, grad) <span class="keyword">in</span> enumerate(zip(self.params, gradients)):
+            <span class="comment"># v = momentum * v_prev + lr * gradient</span>
+            self.velocities[i] = self.momentum * self.velocities[i] + self.lr * grad
+            <span class="comment"># param = param - velocity</span>
+            param -= self.velocities[i]
+
+<span class="comment"># Usage</span>
+W = np.random.randn(<span class="number">3</span>, <span class="number">3</span>) * <span class="number">0.01</span>
+b = np.zeros(<span class="number">3</span>)
+optimizer = SGD([W, b], lr=<span class="number">0.01</span>, momentum=<span class="number">0.9</span>)
+
+<span class="comment"># After computing gradients dW, db:</span>
+<span class="comment"># optimizer.step([dW, db])</span>
+</div>
+
+                    <h3>Learning Rate Schedulers</h3>
+                    <span class="code-title">📄 lr_schedulers.py</span><div class="code-block"><span class="keyword">from</span> torch.optim.lr_scheduler <span class="keyword">import</span> StepLR, CosineAnnealingLR
+
+optimizer = optim.Adam(model.parameters(), lr=<span class="number">0.001</span>)
+
+<span class="comment"># Reduce LR by 0.1 every 30 epochs</span>
+scheduler = StepLR(optimizer, step_size=<span class="number">30</span>, gamma=<span class="number">0.1</span>)
+
+<span class="comment"># Cosine annealing (smooth decay, used in modern training)</span>
+scheduler = CosineAnnealingLR(optimizer, T_max=<span class="number">100</span>, eta_min=<span class="number">1e-6</span>)
+
+<span class="keyword">for</span> epoch <span class="keyword">in</span> range(<span class="number">100</span>):
+    train_one_epoch()
+    scheduler.step()  <span class="comment"># Update learning rate</span>
+    <span class="keyword">print</span>(f<span class="string">"LR: {scheduler.get_last_lr()[0]:.6f}"</span>)
+</div>
+`
             },
             "backprop": {
                 overview: `
-                    <h3>Forward & Backpropagation</h3>
-                    <p>The neural network training loop consists of two passes: <strong>forward propagation</strong> (compute predictions) and <strong>backpropagation</strong> (compute gradients for updates).</p>
-                    
-                    <h3>Forward Propagation</h3>
-                    <p>The process of moving inputs through the network to produce an output:</p>
-                    <div class="formula">
-                        Input → Weighted Sum → Activation → Output
-                    </div>
-                    <p>This happens: for every batch, in every epoch, before computing loss.</p>
+                <p>Backpropagation is the algorithm that makes neural networks <strong>learn</strong>. It computes how much each weight in the network contributed to the error, then adjusts each weight accordingly. It's conceptually simple: <strong>the chain rule of calculus applied systematically from output to input</strong>.</p>
 
-                    <h3>Training Pipeline</h3>
-                    <table>
-                        <tr><th>Component</th><th>Role</th></tr>
-                        <tr><td>Forward Propagation</td><td>Computes predictions</td></tr>
-                        <tr><td>Loss Function</td><td>Computes error</td></tr>
-                        <tr><td>Backpropagation</td><td>Computes gradients</td></tr>
-                        <tr><td>Gradient Descent</td><td>Updates weights</td></tr>
-                    </table>
+                <div class="callout insight">
+                    <div class="callout-title">💡 The Factory Analogy</div>
+                    Imagine a factory with 5 stations producing widgets. A quality inspector at the end finds defects. Backpropagation is like tracing the defect backward through each station to find which worker caused the problem and by how much. Each worker (weight) then adjusts their technique proportionally to their contribution to the defect.
+                </div>
 
-                    <div class="callout warning">
-                        <div class="callout-title">⚠️ Key Distinction</div>
-                        Backpropagation does <strong>NOT</strong> update weights — it only computes gradients.<br>
-                        <strong>Gradient Descent</strong> (or any optimizer) does the actual weight update!
-                    </div>
+                <h3>The Algorithm in 4 Steps</h3>
+                <div class="list-item"><div class="list-num">1</div><div><strong>Forward Pass:</strong> Compute outputs layer by layer: $z^l = W^l a^{l-1} + b^l$, then $a^l = \\sigma(z^l)$</div></div>
+                <div class="list-item"><div class="list-num">2</div><div><strong>Compute Loss:</strong> Compare prediction to truth: $L = \\text{CrossEntropy}(\\hat{y}, y)$</div></div>
+                <div class="list-item"><div class="list-num">3</div><div><strong>Backward Pass:</strong> Compute $\\frac{\\partial L}{\\partial W^l}$ for every layer using the chain rule</div></div>
+                <div class="list-item"><div class="list-num">4</div><div><strong>Update:</strong> $W^l \\leftarrow W^l - \\eta \\frac{\\partial L}{\\partial W^l}$</div></div>
 
-                    <h3>Training Terminologies</h3>
-                    <table>
-                        <tr><th>Term</th><th>Meaning</th><th>Example (1000 samples, batch=100)</th></tr>
-                        <tr><td>Batch</td><td>Subset of data</td><td>100 samples</td></tr>
-                        <tr><td>Batch Size</td><td>Samples per batch</td><td>100</td></tr>
-                        <tr><td>Steps per Epoch</td><td>Total / Batch Size</td><td>1000/100 = 10</td></tr>
-                        <tr><td>Iteration</td><td>One batch update</td><td>1 step</td></tr>
-                        <tr><td>Epoch</td><td>One full pass of dataset</td><td>10 iterations</td></tr>
-                    </table>
-                `,
+                <h3>Computational Graphs</h3>
+                <p>Modern frameworks (PyTorch, TensorFlow) build a <strong>computational graph</strong> during the forward pass. Each operation becomes a node. During backprop, they traverse this graph in reverse, applying the chain rule at each node. This is called <strong>automatic differentiation (autograd)</strong>.</p>
+
+                <div class="info-box">
+                    <div class="box-title">🔑 Key Insight</div>
+                    <div class="box-content">
+                        Backprop's time complexity is <strong>O(W)</strong> — proportional to the number of weights. This is the same as a forward pass! Computing all gradients is no more expensive than computing the prediction itself.
+                    </div>
+                </div>
+`,
                 concepts: `
                     <div class="formula">
                         Chain Rule:<br>
@@ -2563,54 +2952,107 @@ output, attn_weights = mha(x, x, x)  <span style="color: #6c7086;"># Self-attent
                         &nbsp;&nbsp;&nbsp;δ = ∂L/∂z = -0.12 * 0.1056 = -0.01267<br>
                         &nbsp;&nbsp;&nbsp;<strong>∂L/∂w = δ * x</strong> | <strong>∂L/∂b = δ</strong>
                     </div>
-                `
+                `,
+                code: `
+                    <h3>Backpropagation from Scratch</h3>
+                    <p>A complete 2-layer neural network trained with backpropagation using only NumPy. This is the best way to truly understand how gradients flow.</p>
+                    <span class="code-title">📄 backprop_numpy.py</span><div class="code-block"><span class="keyword">import</span> numpy <span class="keyword">as</span> np
+
+np.random.seed(<span class="number">42</span>)
+
+<span class="comment"># --- Data: XOR problem ---</span>
+X = np.array([[<span class="number">0</span>,<span class="number">0</span>], [<span class="number">0</span>,<span class="number">1</span>], [<span class="number">1</span>,<span class="number">0</span>], [<span class="number">1</span>,<span class="number">1</span>]])
+y = np.array([[<span class="number">0</span>], [<span class="number">1</span>], [<span class="number">1</span>], [<span class="number">0</span>]])
+
+<span class="comment"># --- Initialize weights ---</span>
+W1 = np.random.randn(<span class="number">2</span>, <span class="number">4</span>) * <span class="number">0.5</span>   <span class="comment"># Input(2) -> Hidden(4)</span>
+b1 = np.zeros((<span class="number">1</span>, <span class="number">4</span>))
+W2 = np.random.randn(<span class="number">4</span>, <span class="number">1</span>) * <span class="number">0.5</span>   <span class="comment"># Hidden(4) -> Output(1)</span>
+b2 = np.zeros((<span class="number">1</span>, <span class="number">1</span>))
+lr = <span class="number">0.5</span>
+
+<span class="keyword">def</span> <span class="function">sigmoid</span>(z):
+    <span class="keyword">return</span> <span class="number">1</span> / (<span class="number">1</span> + np.exp(-z))
+
+<span class="keyword">for</span> epoch <span class="keyword">in</span> range(<span class="number">10000</span>):
+    <span class="comment"># ====== FORWARD PASS ======</span>
+    z1 = X @ W1 + b1           <span class="comment"># (4, 4)</span>
+    a1 = sigmoid(z1)            <span class="comment"># Hidden activation</span>
+    z2 = a1 @ W2 + b2           <span class="comment"># (4, 1)</span>
+    a2 = sigmoid(z2)            <span class="comment"># Output prediction</span>
+
+    <span class="comment"># ====== COMPUTE LOSS (MSE) ======</span>
+    loss = np.mean((y - a2) ** <span class="number">2</span>)
+
+    <span class="comment"># ====== BACKWARD PASS (Chain Rule) ======</span>
+    <span class="comment"># dL/da2 = -2(y - a2) / n</span>
+    dL_da2 = -<span class="number">2</span> * (y - a2) / len(y)
+    <span class="comment"># da2/dz2 = sigmoid'(z2) = a2(1 - a2)</span>
+    dz2 = dL_da2 * a2 * (<span class="number">1</span> - a2)
+
+    <span class="comment"># Gradients for W2, b2</span>
+    dW2 = a1.T @ dz2            <span class="comment"># (4, 1)</span>
+    db2 = dz2.sum(axis=<span class="number">0</span>, keepdims=<span class="keyword">True</span>)
+
+    <span class="comment"># Propagate to hidden layer</span>
+    dz1 = (dz2 @ W2.T) * a1 * (<span class="number">1</span> - a1)
+    dW1 = X.T @ dz1             <span class="comment"># (2, 4)</span>
+    db1 = dz1.sum(axis=<span class="number">0</span>, keepdims=<span class="keyword">True</span>)
+
+    <span class="comment"># ====== UPDATE WEIGHTS ======</span>
+    W2 -= lr * dW2
+    b2 -= lr * db2
+    W1 -= lr * dW1
+    b1 -= lr * db1
+
+    <span class="keyword">if</span> epoch % <span class="number">2000</span> == <span class="number">0</span>:
+        <span class="keyword">print</span>(f<span class="string">"Epoch {epoch}: Loss = {loss:.6f}"</span>)
+
+<span class="comment"># Final predictions</span>
+<span class="keyword">print</span>(<span class="string">"Predictions:"</span>, a2.round(<span class="number">2</span>).flatten())
+<span class="comment"># Expected: [0, 1, 1, 0] for XOR</span>
+</div>
+
+                    <h3>PyTorch Autograd (Automatic Backprop)</h3>
+                    <span class="code-title">📄 backprop_pytorch.py</span><div class="code-block"><span class="keyword">import</span> torch
+<span class="keyword">import</span> torch.nn <span class="keyword">as</span> nn
+
+<span class="comment"># PyTorch handles backprop automatically via autograd!</span>
+x = torch.tensor([<span class="number">2.0</span>], requires_grad=<span class="keyword">True</span>)
+y = x**<span class="number">2</span> + <span class="number">3</span>*x + <span class="number">1</span>   <span class="comment"># f(x) = x^2 + 3x + 1</span>
+y.backward()            <span class="comment"># Compute df/dx automatically</span>
+<span class="keyword">print</span>(x.grad)           <span class="comment"># 7.0  (derivative: 2x + 3, at x=2: 7)</span>
+</div>
+`
             },
             "regularization": {
                 overview: `
-                    <h3>Regularization Techniques</h3>
-                    <table>
-                        <tr>
-                            <th>Method</th>
-                            <th>How It Works</th>
-                            <th>When to Use</th>
-                        </tr>
-                        <tr>
-                            <td>L2 (Ridge)</td>
-                            <td>Adds λΣw² to loss</td>
-                            <td>Keeps all features, reduces magnitude</td>
-                        </tr>
-                        <tr>
-                            <td>L1 (Lasso)</td>
-                            <td>Adds λΣ|w| to loss</td>
-                            <td>Feature selection (zeros out weights)</td>
-                        </tr>
-                        <tr>
-                            <td>Dropout</td>
-                            <td>Randomly drops neurons (p=0.5 typical)</td>
-                            <td><strong>Most effective for deep networks</strong></td>
-                        </tr>
-                        <tr>
-                            <td>Early Stopping</td>
-                            <td>Stop when validation loss increases</td>
-                            <td>Prevents overfitting during training</td>
-                        </tr>
-                        <tr>
-                            <td>Data Augmentation</td>
-                            <td>Artificially expand dataset</td>
-                            <td>Computer vision (rotations, flips, crops)</td>
-                        </tr>
-                    </table>
+                <p>Regularization prevents a neural network from <strong>memorizing the training data</strong> instead of learning general patterns. Without it, the network performs brilliantly on training data but fails on new data — this is <strong>overfitting</strong>.</p>
 
-                    <h3>Weight Initialization</h3>
-                    <p>Proper initialization prevents vanishing/exploding gradients from the very first step.</p>
-                    <table>
-                        <tr><th>Method</th><th>Formula</th><th>Best For</th></tr>
-                        <tr><td>Zero Init</td><td>All w = 0</td><td>❌ Never use! Breaks symmetry</td></tr>
-                        <tr><td>Random</td><td>w ~ N(0, 0.01)</td><td>⚠️ Vanishes in deep nets</td></tr>
-                        <tr><td><strong>Xavier (Glorot)</strong></td><td>w ~ N(0, √(2/(n_in + n_out)))</td><td>✅ Sigmoid, Tanh</td></tr>
-                        <tr><td><strong>He (Kaiming)</strong></td><td>w ~ N(0, √(2/n_in))</td><td>✅ ReLU (default)</td></tr>
-                    </table>
-                `,
+                <div class="callout insight">
+                    <div class="callout-title">📚 The Exam Analogy</div>
+                    Imagine a student who memorizes all answers in a textbook word-for-word but doesn't understand the concepts. They'll ace the exact same questions but fail on any new ones. Regularization forces the network to "understand" rather than "memorize."
+                </div>
+
+                <h3>Signs of Overfitting</h3>
+                <div class="info-box">
+                    <div class="box-title">🚨 Red Flags</div>
+                    <div class="box-content">
+                        ✗ Training accuracy: 99%, Validation accuracy: 65% (huge gap)<br>
+                        ✗ Training loss keeps decreasing but validation loss starts increasing<br>
+                        ✗ Model works perfectly on seen data but fails on new examples<br>
+                        ✗ Small dataset with a very large model (too many parameters for too little data)
+                    </div>
+                </div>
+
+                <h3>Regularization Techniques</h3>
+                <div class="list-item"><div class="list-num">1</div><div><strong>L2 Regularization (Weight Decay):</strong> Adds $\\lambda \\sum w^2$ to the loss. Penalizes large weights, encouraging smaller, more distributed weights.</div></div>
+                <div class="list-item"><div class="list-num">2</div><div><strong>L1 Regularization:</strong> Adds $\\lambda \\sum |w|$ to the loss. Encourages sparsity — some weights become exactly zero.</div></div>
+                <div class="list-item"><div class="list-num">3</div><div><strong>Dropout:</strong> During training, randomly sets neurons to 0 with probability $p$. Forces the network to be redundant — no single neuron can be relied upon.</div></div>
+                <div class="list-item"><div class="list-num">4</div><div><strong>Data Augmentation:</strong> Artificially increase training data by applying random transformations (flips, rotations, crops). The best regularizer is <em>more data</em>.</div></div>
+                <div class="list-item"><div class="list-num">5</div><div><strong>Early Stopping:</strong> Monitor validation loss during training. Stop when it starts increasing even though training loss continues to decrease.</div></div>
+                <div class="list-item"><div class="list-num">6</div><div><strong>Batch Normalization:</strong> While not designed as regularization, BN has a regularizing effect because mini-batch statistics add noise.</div></div>
+`,
                 applications: `
                     <div class="info-box">
                         <div class="box-title">🎯 Best Practices</div>
@@ -2735,21 +3177,110 @@ output, attn_weights = mha(x, x, x)  <span style="color: #6c7086;"># Self-attent
                         <strong>Xavier:</strong> Calibrates variance based on layer width → stable gradients for Sigmoid/Tanh.<br>
                         <strong>He:</strong> Accounts for ReLU zeroing out negative half → default for modern networks.
                     </div>
-                `
+                `,
+                code: `
+                    <h3>Regularization Techniques in PyTorch</h3>
+                    <p>Complete examples of the most important regularization methods.</p>
+                    <span class="code-title">📄 regularization_pytorch.py</span><div class="code-block"><span class="keyword">import</span> torch
+<span class="keyword">import</span> torch.nn <span class="keyword">as</span> nn
+<span class="keyword">import</span> torchvision.transforms <span class="keyword">as</span> T
+
+<span class="comment"># ====== 1. Dropout ======</span>
+<span class="keyword">class</span> <span class="function">ModelWithDropout</span>(nn.Module):
+    <span class="keyword">def</span> <span class="function">__init__</span>(self):
+        super().__init__()
+        self.net = nn.Sequential(
+            nn.Linear(<span class="number">784</span>, <span class="number">256</span>),
+            nn.ReLU(),
+            nn.Dropout(p=<span class="number">0.5</span>),  <span class="comment"># 50% of neurons randomly zeroed</span>
+            nn.Linear(<span class="number">256</span>, <span class="number">128</span>),
+            nn.ReLU(),
+            nn.Dropout(p=<span class="number">0.3</span>),  <span class="comment"># 30% dropout</span>
+            nn.Linear(<span class="number">128</span>, <span class="number">10</span>),
+        )
+
+    <span class="keyword">def</span> <span class="function">forward</span>(self, x):
+        <span class="keyword">return</span> self.net(x)
+
+model = ModelWithDropout()
+model.train()   <span class="comment"># Dropout active</span>
+model.eval()    <span class="comment"># Dropout disabled (IMPORTANT for inference!)</span>
+
+<span class="comment"># ====== 2. L2 Regularization (Weight Decay) ======</span>
+optimizer = torch.optim.Adam(
+    model.parameters(),
+    lr=<span class="number">0.001</span>,
+    weight_decay=<span class="number">0.01</span>,  <span class="comment"># L2 penalty lambda</span>
+)
+
+<span class="comment"># ====== 3. Data Augmentation ======</span>
+train_transforms = T.Compose([
+    T.RandomHorizontalFlip(p=<span class="number">0.5</span>),
+    T.RandomRotation(degrees=<span class="number">15</span>),
+    T.RandomResizedCrop(size=<span class="number">224</span>, scale=(<span class="number">0.8</span>, <span class="number">1.0</span>)),
+    T.ColorJitter(brightness=<span class="number">0.2</span>, contrast=<span class="number">0.2</span>),
+    T.ToTensor(),
+    T.Normalize(mean=[<span class="number">0.485</span>, <span class="number">0.456</span>, <span class="number">0.406</span>],
+                std=[<span class="number">0.229</span>, <span class="number">0.224</span>, <span class="number">0.225</span>]),
+])
+
+<span class="comment"># ====== 4. Early Stopping ======</span>
+best_val_loss = float(<span class="string">'inf'</span>)
+patience = <span class="number">5</span>
+counter = <span class="number">0</span>
+
+<span class="keyword">for</span> epoch <span class="keyword">in</span> range(<span class="number">100</span>):
+    train_loss = train_one_epoch()
+    val_loss = validate()
+
+    <span class="keyword">if</span> val_loss < best_val_loss:
+        best_val_loss = val_loss
+        counter = <span class="number">0</span>
+        torch.save(model.state_dict(), <span class="string">'best_model.pt'</span>)
+    <span class="keyword">else</span>:
+        counter += <span class="number">1</span>
+        <span class="keyword">if</span> counter >= patience:
+            <span class="keyword">print</span>(f<span class="string">"Early stopping at epoch {epoch}"</span>)
+            <span class="keyword">break</span>
+</div>
+`
             },
             "batch-norm": {
                 overview: `
-                    <h3>Batch Normalization</h3>
-                    <p>Normalizes layer inputs to have mean=0 and variance=1, stabilizing and accelerating training.</p>
-                    
-                    <div class="callout tip">
-                        <div class="callout-title">✅ Benefits</div>
-                        • <strong>Faster Training:</strong> Allows higher learning rates<br>
-                        • <strong>Reduces Vanishing Gradients:</strong> Better gradient flow<br>
-                        • <strong>Regularization Effect:</strong> Adds slight noise<br>
-                        • <strong>Less Sensitive to Init:</strong> Reduces initialization impact
+                <p>Batch Normalization (BatchNorm) was one of the most impactful innovations in deep learning. It <strong>normalizes the inputs to each layer</strong>, which stabilizes and dramatically accelerates training. Before BatchNorm, training deep networks was extremely difficult.</p>
+
+                <div class="callout insight">
+                    <div class="callout-title">🎯 The Core Problem BatchNorm Solves</div>
+                    As data flows through layers, the distribution of activations keeps shifting — this is called <strong>Internal Covariate Shift</strong>. Each layer has to constantly adapt to new input distributions, slowing down training. BatchNorm fixes this by normalizing each layer's input to have mean=0 and variance=1.
+                </div>
+
+                <h3>How It Works (Step by Step)</h3>
+                <div class="formula" style="text-align:center;">
+                    Given a mini-batch $B = \\{x_1, ..., x_m\\}$:<br><br>
+                    <strong>Step 1 — Mean:</strong> $$\\mu_B = \\frac{1}{m}\\sum_{i=1}^{m} x_i$$
+                    <strong>Step 2 — Variance:</strong> $$\\sigma_B^2 = \\frac{1}{m}\\sum_{i=1}^{m} (x_i - \\mu_B)^2$$
+                    <strong>Step 3 — Normalize:</strong> $$\\hat{x}_i = \\frac{x_i - \\mu_B}{\\sqrt{\\sigma_B^2 + \\epsilon}}$$
+                    <strong>Step 4 — Scale and Shift:</strong> $$y_i = \\gamma \\hat{x}_i + \\beta$$
+                </div>
+                <p>$\\gamma$ and $\\beta$ are <strong>learnable parameters</strong>. They allow the network to undo the normalization if that's optimal — giving the network the flexibility to decide the best distribution for each layer.</p>
+
+                <div class="info-box">
+                    <div class="box-title">Benefits of BatchNorm</div>
+                    <div class="box-content">
+                        ✓ <strong>Train 5-10x faster</strong> — allows much higher learning rates<br>
+                        ✓ <strong>Reduces sensitivity</strong> to weight initialization<br>
+                        ✓ <strong>Acts as regularization</strong> — mini-batch noise has a dropout-like effect<br>
+                        ✓ <strong>Enables deeper networks</strong> — reduces vanishing/exploding gradients
                     </div>
-                `,
+                </div>
+
+                <div class="callout warning">
+                    <div class="callout-title">⚠️ BatchNorm Gotchas</div>
+                    <strong>1. Train vs. Eval:</strong> During training, BN uses mini-batch statistics. During inference, it uses running averages computed during training. Always call <code>model.eval()</code> before inference!<br>
+                    <strong>2. Small batch sizes:</strong> BN performs poorly with batch_size &lt; 16 because statistics are noisy. Use LayerNorm instead (as in Transformers).<br>
+                    <strong>3. Placement:</strong> Usually placed <em>after</em> the linear/conv layer and <em>before</em> the activation: Linear → BN → ReLU.
+                </div>
+`,
                 math: `
                     <h3>The 4 Steps of Batch Normalization</h3>
                     <p>Calculated per mini-batch B = {x₁, ..., xₘ}:</p>
@@ -2996,7 +3527,57 @@ output, attn_weights = mha(x, x, x)  <span style="color: #6c7086;"># Self-attent
                         2. <strong>Params:</strong> 64 * (3 * 3 * 3 + 1) = 64 * 28 = <strong>1,792 parameters</strong><br>
                         3. <strong>FLOPs:</strong> 224 * 224 * 1792 ≈ <strong>90 Million operations</strong> per image!
                     </div>
-                `
+                `,
+                code: `
+                    <h3>Building a CNN from Scratch in PyTorch</h3>
+                    <p>A complete CNN for classifying CIFAR-10 images (32×32 RGB) into 10 categories.</p>
+                    <span class="code-title">📄 cnn_cifar10.py</span><div class="code-block"><span class="keyword">import</span> torch
+<span class="keyword">import</span> torch.nn <span class="keyword">as</span> nn
+<span class="keyword">import</span> torch.nn.functional <span class="keyword">as</span> F
+
+<span class="keyword">class</span> <span class="function">SimpleCNN</span>(nn.Module):
+    <span class="string">"""
+    Architecture:
+    Input (3, 32, 32)
+    -> Conv(3->32, 3x3) -> BN -> ReLU -> MaxPool(2x2) -> (32, 16, 16)
+    -> Conv(32->64, 3x3) -> BN -> ReLU -> MaxPool(2x2) -> (64, 8, 8)
+    -> Conv(64->128, 3x3) -> BN -> ReLU -> MaxPool(2x2) -> (128, 4, 4)
+    -> Flatten -> FC(2048, 256) -> Dropout -> FC(256, 10)
+    """</span>
+    <span class="keyword">def</span> <span class="function">__init__</span>(self):
+        super().__init__()
+        <span class="comment"># Convolutional layers</span>
+        self.conv1 = nn.Conv2d(<span class="number">3</span>, <span class="number">32</span>, kernel_size=<span class="number">3</span>, padding=<span class="number">1</span>)
+        self.bn1 = nn.BatchNorm2d(<span class="number">32</span>)
+        self.conv2 = nn.Conv2d(<span class="number">32</span>, <span class="number">64</span>, kernel_size=<span class="number">3</span>, padding=<span class="number">1</span>)
+        self.bn2 = nn.BatchNorm2d(<span class="number">64</span>)
+        self.conv3 = nn.Conv2d(<span class="number">64</span>, <span class="number">128</span>, kernel_size=<span class="number">3</span>, padding=<span class="number">1</span>)
+        self.bn3 = nn.BatchNorm2d(<span class="number">128</span>)
+        self.pool = nn.MaxPool2d(<span class="number">2</span>, <span class="number">2</span>)  <span class="comment"># Halves spatial dimensions</span>
+
+        <span class="comment"># Fully connected layers</span>
+        self.fc1 = nn.Linear(<span class="number">128</span> * <span class="number">4</span> * <span class="number">4</span>, <span class="number">256</span>)
+        self.dropout = nn.Dropout(<span class="number">0.5</span>)
+        self.fc2 = nn.Linear(<span class="number">256</span>, <span class="number">10</span>)
+
+    <span class="keyword">def</span> <span class="function">forward</span>(self, x):
+        x = self.pool(F.relu(self.bn1(self.conv1(x))))  <span class="comment"># (B, 32, 16, 16)</span>
+        x = self.pool(F.relu(self.bn2(self.conv2(x))))  <span class="comment"># (B, 64, 8, 8)</span>
+        x = self.pool(F.relu(self.bn3(self.conv3(x))))  <span class="comment"># (B, 128, 4, 4)</span>
+        x = x.view(x.size(<span class="number">0</span>), -<span class="number">1</span>)                      <span class="comment"># Flatten</span>
+        x = self.dropout(F.relu(self.fc1(x)))
+        x = self.fc2(x)
+        <span class="keyword">return</span> x
+
+<span class="comment"># --- Training Setup ---</span>
+model = SimpleCNN()
+<span class="keyword">print</span>(f<span class="string">"Total parameters: {sum(p.numel() for p in model.parameters()):,}"</span>)
+<span class="comment"># Total parameters: ~600K (tiny by today's standards)</span>
+
+criterion = nn.CrossEntropyLoss()
+optimizer = torch.optim.Adam(model.parameters(), lr=<span class="number">0.001</span>)
+</div>
+`
             },
             "viz-filters": {
                 overview: `
@@ -3340,29 +3921,40 @@ output, attn_weights = mha(x, x, x)  <span style="color: #6c7086;"># Self-attent
             },
             "resnet": {
                 overview: `
-                    <h3>ResNet (2015) - Residual Connections</h3>
-                    <p><strong>Problem:</strong> Very deep networks (>20 layers) had degradation - training accuracy got worse!</p>
-                    
-                    <h3>Solution: Skip Connections</h3>
-                    <div class="formula">
-                        Instead of learning H(x), learn residual F(x) = H(x) - x<br>
-                        Output: y = F(x) + x  (shortcut connection)
-                    </div>
-                    
-                    <h3>Why Skip Connections Work</h3>
-                    <ul>
-                        <li><strong>Gradient Flow:</strong> Gradients flow directly through shortcuts</li>
-                        <li><strong>Identity Mapping:</strong> Easy to learn identity (just set F(x)=0)</li>
-                        <li><strong>Feature Reuse:</strong> Earlier features directly available to later layers</li>
-                    </ul>
-                    
-                    <div class="callout tip">
-                        <div class="callout-title">🏆 Impact</div>
-                        • Enabled training of 152-layer networks (even 1000+ layers)<br>
-                        • Won ImageNet 2015<br>
-                        • Skip connections now used everywhere (U-Net, Transformers, etc.)
-                    </div>
-                `,
+                <p>ResNet (Residual Networks) solved the <strong>degradation problem</strong> — deeper networks were performing WORSE than shallower ones, not because of overfitting, but because gradients couldn't flow through many layers. The solution? <strong>Skip connections</strong> that let gradients bypass layers entirely.</p>
+
+                <div class="callout insight">
+                    <div class="callout-title">🏗️ The Highway Analogy</div>
+                    Imagine a highway with an exit ramp. If the road ahead is blocked (gradient vanishes), you can take the exit ramp and bypass the blockage. Skip connections are these exit ramps — they guarantee that information (and gradients) can always flow through the network, even if some layers become useless.
+                </div>
+
+                <h3>The Residual Block</h3>
+                <p>Instead of learning the full mapping $H(x)$, the block learns the <strong>residual</strong> $F(x) = H(x) - x$. The output is:</p>
+                <div class="formula" style="text-align:center;">
+                    $$y = F(x, \\{W_i\\}) + x$$
+                </div>
+                <p><strong>Why this works:</strong> If the optimal mapping is close to identity (common in deep networks), it's much easier for the network to learn $F(x) \\approx 0$ than to learn $H(x) \\approx x$. Pushing weights toward zero is easy; learning a complex identity mapping is hard.</p>
+
+                <h3>ResNet Variants</h3>
+                <table style="width:100%; border-collapse: collapse; margin: 15px 0;">
+                    <tr style="border-bottom: 2px solid var(--cyan);">
+                        <th style="padding: 10px; color: var(--cyan);">Model</th>
+                        <th style="padding: 10px; color: var(--cyan);">Layers</th>
+                        <th style="padding: 10px; color: var(--cyan);">Parameters</th>
+                        <th style="padding: 10px; color: var(--cyan);">Top-1 Accuracy</th>
+                    </tr>
+                    <tr style="border-bottom: 1px solid rgba(255,255,255,0.1);"><td style="padding: 8px;">ResNet-18</td><td>18</td><td>11.7M</td><td>69.8%</td></tr>
+                    <tr style="border-bottom: 1px solid rgba(255,255,255,0.1);"><td style="padding: 8px;">ResNet-34</td><td>34</td><td>21.8M</td><td>73.3%</td></tr>
+                    <tr style="border-bottom: 1px solid rgba(255,255,255,0.1);"><td style="padding: 8px;">ResNet-50</td><td>50</td><td>25.6M</td><td>76.1%</td></tr>
+                    <tr style="border-bottom: 1px solid rgba(255,255,255,0.1);"><td style="padding: 8px;">ResNet-101</td><td>101</td><td>44.5M</td><td>77.4%</td></tr>
+                    <tr><td style="padding: 8px;">ResNet-152</td><td>152</td><td>60.2M</td><td>78.3%</td></tr>
+                </table>
+
+                <div class="callout tip">
+                    <div class="callout-title">💡 Impact</div>
+                    ResNet won the 2015 ImageNet competition with 152 layers and 3.6% top-5 error — the first time a neural network surpassed human performance (5.1%). ResNet concepts are now used in virtually every modern architecture.
+                </div>
+`,
                 concepts: `
                     <h3>Identity & Projection Shortcuts</h3>
                     <div class="list-item">
@@ -3391,6 +3983,19 @@ output, attn_weights = mha(x, x, x)  <span style="color: #6c7086;"># Self-attent
                         <div class="box-title">🏗️ Modern Vision Backbones</div>
                         <div class="box-content">ResNet is the default starting point for nearly all computer vision tasks today (Mask R-CNN, YOLO, etc.).</div>
                     </div>
+                `,
+                code: `
+                    <h3>Skip Connection Math</h3>
+                    <div class="formula" style="text-align:center;">
+                        $$\\mathcal{H}(x) = \\mathcal{F}(x) + x$$
+                        The network learns the <strong>residual</strong> $\\mathcal{F}(x) = \\mathcal{H}(x) - x$ instead of the full mapping.
+                    </div>
+<span class="code-title">📄 resnet_pytorch.py</span><div class="code-block"><span class="keyword">import</span> torchvision.models <span class="keyword">as</span> models
+
+<span class="comment"># Load pretrained ResNet-50</span>
+model = models.resnet50(weights=<span class="string">"IMAGENET1K_V2"</span>)
+<span class="keyword">print</span>(f<span class="string">"Parameters: {sum(p.numel() for p in model.parameters()):,}"</span>)
+<span class="comment"># Output: 25,557,032 parameters</span></div>
                 `
             },
             "inception": {
@@ -3501,40 +4106,30 @@ output, attn_weights = mha(x, x, x)  <span style="color: #6c7086;"># Self-attent
             },
             "transfer-learning": {
                 overview: `
-                    <h3>Transfer Learning - Don't Train from Scratch!</h3>
-                    <p>Use pre-trained models (ImageNet) as feature extractors for your custom task.</p>
-                    
-                    <h3>Two Strategies</h3>
-                    <table>
-                        <tr>
-                            <th>Approach</th>
-                            <th>When to Use</th>
-                            <th>How</th>
-                        </tr>
-                        <tr>
-                            <td>Feature Extraction</td>
-                            <td><strong>Small dataset</strong> (<10K images)</td>
-                            <td>Freeze all layers, train only final FC layer</td>
-                        </tr>
-                        <tr>
-                            <td>Fine-tuning</td>
-                            <td><strong>Medium dataset</strong> (10K-100K)</td>
-                            <td>Freeze early layers, train last few + FC</td>
-                        </tr>
-                        <tr>
-                            <td>Full Training</td>
-                            <td><strong>Large dataset</strong> (>1M images)</td>
-                            <td>Use pre-trained as initialization, train all</td>
-                        </tr>
-                    </table>
-                    
-                    <div class="callout tip">
-                        <div class="callout-title">💡 Best Practices</div>
-                        • Use pre-trained models when dataset < 100K images<br>
-                        • Start with low learning rate (1e-4) for fine-tuning<br>
-                        • Popular backbones: ResNet50, EfficientNet, ViT
-                    </div>
-                `,
+                <p>Transfer learning is the most <strong>practical technique</strong> in modern deep learning. Instead of training from scratch (which requires millions of images and weeks of GPU time), you <strong>reuse a model already trained on a large dataset</strong> (like ImageNet's 14M images) and fine-tune it for your specific task.</p>
+
+                <div class="callout insight">
+                    <div class="callout-title">🎓 The Education Analogy</div>
+                    Transfer learning is like a medical student who already learned anatomy, chemistry, and biology (pretrained knowledge). Instead of re-learning everything from scratch for cardiology (your task), they just need specialized training on heart-related topics. The foundational knowledge <strong>transfers</strong>.
+                </div>
+
+                <h3>Two Strategies</h3>
+                <div class="list-item"><div class="list-num">1</div><div><strong>Feature Extraction (Freeze backbone)</strong><br>Freeze all pretrained layers. Only train a new classification head. Best when you have <strong>little data</strong> (&lt;1000 images) or your task is similar to ImageNet.</div></div>
+                <div class="list-item"><div class="list-num">2</div><div><strong>Fine-tuning (Unfreeze some layers)</strong><br>Unfreeze the last few layers and train with a very small learning rate (1e-4 to 1e-5). Best when you have <strong>moderate data</strong> (1000-50000 images) or your task is somewhat different.</div></div>
+
+                <h3>When to Use Which Strategy</h3>
+                <table style="width:100%; border-collapse: collapse; margin: 15px 0;">
+                    <tr style="border-bottom: 2px solid var(--cyan);">
+                        <th style="padding: 10px; color: var(--cyan);">Data Size</th>
+                        <th style="padding: 10px; color: var(--cyan);">Similar to ImageNet?</th>
+                        <th style="padding: 10px; color: var(--cyan);">Strategy</th>
+                    </tr>
+                    <tr style="border-bottom: 1px solid rgba(255,255,255,0.1);"><td style="padding: 8px;">Small (&lt;1K)</td><td>Yes</td><td>Feature extraction</td></tr>
+                    <tr style="border-bottom: 1px solid rgba(255,255,255,0.1);"><td style="padding: 8px;">Small (&lt;1K)</td><td>No</td><td>Feature extraction + heavy augmentation</td></tr>
+                    <tr style="border-bottom: 1px solid rgba(255,255,255,0.1);"><td style="padding: 8px;">Medium (1K-50K)</td><td>Yes</td><td>Fine-tune last few layers</td></tr>
+                    <tr><td style="padding: 8px;">Large (&gt;50K)</td><td>No</td><td>Fine-tune entire network (low lr)</td></tr>
+                </table>
+`,
                 concepts: `
                     <h3>Why Transfer Learning Works</h3>
                     <div class="list-item">
@@ -3611,6 +4206,29 @@ output, attn_weights = mha(x, x, x)  <span style="color: #6c7086;"># Self-attent
                             Land use classification, deforestation detection, urban planning using models pre-trained on aerial imagery.
                         </div>
                     </div>
+                `,
+                code: `<span class="code-title">📄 transfer_learning.py</span><div class="code-block"><span class="keyword">import</span> torch
+<span class="keyword">import</span> torchvision.models <span class="keyword">as</span> models
+<span class="keyword">import</span> torch.nn <span class="keyword">as</span> nn
+
+<span class="comment"># --- Load pretrained ResNet-18 ---</span>
+model = models.resnet18(weights=<span class="string">"IMAGENET1K_V1"</span>)
+
+<span class="comment"># --- Strategy 1: Feature Extraction (freeze all) ---</span>
+<span class="keyword">for</span> param <span class="keyword">in</span> model.parameters():
+    param.requires_grad = <span class="keyword">False</span>
+
+<span class="comment"># Replace final layer for 5 classes</span>
+model.fc = nn.Linear(model.fc.in_features, <span class="number">5</span>)
+
+<span class="comment"># Only train the new layer</span>
+optimizer = torch.optim.Adam(model.fc.parameters(), lr=<span class="number">0.001</span>)
+
+<span class="comment"># --- Strategy 2: Fine-tuning (unfreeze some layers) ---</span>
+<span class="keyword">for</span> param <span class="keyword">in</span> model.layer4.parameters():
+    param.requires_grad = <span class="keyword">True</span>  <span class="comment"># unfreeze last residual block</span>
+
+<span class="keyword">print</span>(f<span class="string">"Trainable: {sum(p.numel() for p in model.parameters() if p.requires_grad):,}"</span>)</div>
                 `
             },
             "localization": {
@@ -4174,29 +4792,40 @@ output, attn_weights = mha(x, x, x)  <span style="color: #6c7086;"># Self-attent
             },
             "gans": {
                 overview: `
-                    <h3>GANs (Generative Adversarial Networks)</h3>
-                    <p>Two networks compete: Generator creates fake data, Discriminator tries to detect fakes.</p>
-                    
-                    <h3>The GAN Game</h3>
-                    <div class="formula">
-                        Generator: Creates fake images from random noise<br>
-                        Goal: Fool discriminator<br>
-                        <br>
-                        Discriminator: Classifies real vs fake<br>
-                        Goal: Correctly identify fakes<br>
-                        <br>
-                        Minimax Loss:<br>
-                        min_G max_D E[log D(x)] + E[log(1 - D(G(z)))]
-                    </div>
-                    
-                    <div class="callout warning">
-                        <div class="callout-title">⚠️ Training Challenges</div>
-                        • Mode collapse (Generator produces limited variety)<br>
-                        • Training instability (careful tuning needed)<br>
-                        • Convergence issues<br>
-                        • Solutions: Wasserstein GAN, Spectral Normalization, StyleGAN improvements
-                    </div>
-                `,
+                <p>Generative Adversarial Networks (GANs) are a framework for training generative models using an <strong>adversarial game</strong> between two neural networks: a <strong>Generator</strong> (forger) and a <strong>Discriminator</strong> (detective).</p>
+
+                <div class="callout insight">
+                    <div class="callout-title">🎨 The Art Forger Analogy</div>
+                    The Generator is an art forger trying to create fake paintings that look real. The Discriminator is an art detective trying to spot fakes. As the detective gets better at spotting fakes, the forger improves to fool the detective. Eventually, the forger creates paintings so good that even the detective can't tell them apart from real ones.
+                </div>
+
+                <h3>The Min-Max Game</h3>
+                <div class="formula" style="text-align:center;">
+                    $$\\min_G \\max_D \\; V(D,G) = \\mathbb{E}_{x \\sim p_{data}}[\\log D(x)] + \\mathbb{E}_{z \\sim p_z}[\\log(1 - D(G(z)))]$$
+                </div>
+                <p><strong>D(x)</strong> = probability that $x$ is real. <strong>G(z)</strong> = fake image generated from noise $z$.</p>
+
+                <h3>GAN Variants</h3>
+                <table style="width:100%; border-collapse: collapse; margin: 15px 0;">
+                    <tr style="border-bottom: 2px solid var(--cyan);">
+                        <th style="padding: 10px; color: var(--cyan);">Variant</th>
+                        <th style="padding: 10px; color: var(--cyan);">Innovation</th>
+                        <th style="padding: 10px; color: var(--cyan);">Use Case</th>
+                    </tr>
+                    <tr style="border-bottom: 1px solid rgba(255,255,255,0.1);"><td style="padding: 8px;">DCGAN</td><td>Convolutional architecture</td><td>Image generation</td></tr>
+                    <tr style="border-bottom: 1px solid rgba(255,255,255,0.1);"><td style="padding: 8px;">WGAN</td><td>Wasserstein distance (stable training)</td><td>Any generation task</td></tr>
+                    <tr style="border-bottom: 1px solid rgba(255,255,255,0.1);"><td style="padding: 8px;">Pix2Pix</td><td>Paired image-to-image translation</td><td>Sketch → Photo</td></tr>
+                    <tr style="border-bottom: 1px solid rgba(255,255,255,0.1);"><td style="padding: 8px;">CycleGAN</td><td>Unpaired image translation</td><td>Horse → Zebra</td></tr>
+                    <tr><td style="padding: 8px;">StyleGAN</td><td>Style-based generation (faces)</td><td>High-res face synthesis</td></tr>
+                </table>
+
+                <div class="callout warning">
+                    <div class="callout-title">⚠️ GAN Training Challenges</div>
+                    <strong>Mode Collapse:</strong> Generator produces only one type of output. Solution: use WGAN or add diversity penalties.<br>
+                    <strong>Training Instability:</strong> G and D can oscillate without converging. Solution: use spectral normalization, gradient penalty.<br>
+                    <strong>Evaluation:</strong> Hard to objectively measure quality. Metrics like FID (Fréchet Inception Distance) help but aren't perfect.
+                </div>
+`,
                 applications: `
                     <div class="info-box">
                         <div class="box-title">🎨 Image Generation</div>
@@ -4232,6 +4861,44 @@ output, attn_weights = mha(x, x, x)  <span style="color: #6c7086;"># Self-attent
                         <div class="list-num">💡</div>
                         <div><strong>Heuristic Fix:</strong> Instead of minimizing log(1-D(G(z))), we maximize <strong>log D(G(z))</strong>. This provides much stronger gradients early on!</div>
                     </div>
+                `,
+                code: `
+                    <h3>GAN Objective (Min-Max Game)</h3>
+                    <div class="formula" style="text-align:center;">
+                        $$\\min_G \\max_D \\; V(D,G) = \\mathbb{E}_{x \\sim p_{data}}[\\log D(x)] + \\mathbb{E}_{z \\sim p_z}[\\log(1 - D(G(z)))]$$
+                    </div>
+                    <p><strong>Generator</strong> tries to minimize — create fakes so good that $D(G(z)) \\to 1$. <strong>Discriminator</strong> tries to maximize — correctly classify real vs fake.</p>
+<span class="code-title">📄 dcgan.py</span><div class="code-block"><span class="keyword">import</span> torch.nn <span class="keyword">as</span> nn
+
+<span class="keyword">class</span> <span class="class-name">Generator</span>(nn.Module):
+    <span class="keyword">def</span> <span class="function">__init__</span>(self, latent_dim=<span class="number">100</span>):
+        <span class="builtin">super</span>().__init__()
+        self.net = nn.Sequential(
+            nn.ConvTranspose2d(latent_dim, <span class="number">512</span>, <span class="number">4</span>, <span class="number">1</span>, <span class="number">0</span>),
+            nn.BatchNorm2d(<span class="number">512</span>), nn.ReLU(),
+            nn.ConvTranspose2d(<span class="number">512</span>, <span class="number">256</span>, <span class="number">4</span>, <span class="number">2</span>, <span class="number">1</span>),
+            nn.BatchNorm2d(<span class="number">256</span>), nn.ReLU(),
+            nn.ConvTranspose2d(<span class="number">256</span>, <span class="number">128</span>, <span class="number">4</span>, <span class="number">2</span>, <span class="number">1</span>),
+            nn.BatchNorm2d(<span class="number">128</span>), nn.ReLU(),
+            nn.ConvTranspose2d(<span class="number">128</span>, <span class="number">3</span>, <span class="number">4</span>, <span class="number">2</span>, <span class="number">1</span>),
+            nn.Tanh(),  <span class="comment"># Output: [-1, 1]</span>
+        )
+    <span class="keyword">def</span> <span class="function">forward</span>(self, z):
+        <span class="keyword">return</span> self.net(z.view(-<span class="number">1</span>, <span class="number">100</span>, <span class="number">1</span>, <span class="number">1</span>))
+
+<span class="keyword">class</span> <span class="class-name">Discriminator</span>(nn.Module):
+    <span class="keyword">def</span> <span class="function">__init__</span>(self):
+        <span class="builtin">super</span>().__init__()
+        self.net = nn.Sequential(
+            nn.Conv2d(<span class="number">3</span>, <span class="number">64</span>, <span class="number">4</span>, <span class="number">2</span>, <span class="number">1</span>),
+            nn.LeakyReLU(<span class="number">0.2</span>),
+            nn.Conv2d(<span class="number">64</span>, <span class="number">128</span>, <span class="number">4</span>, <span class="number">2</span>, <span class="number">1</span>),
+            nn.BatchNorm2d(<span class="number">128</span>), nn.LeakyReLU(<span class="number">0.2</span>),
+            nn.Conv2d(<span class="number">128</span>, <span class="number">1</span>, <span class="number">4</span>, <span class="number">1</span>, <span class="number">0</span>),
+            nn.Sigmoid(),
+        )
+    <span class="keyword">def</span> <span class="function">forward</span>(self, x):
+        <span class="keyword">return</span> self.net(x).view(-<span class="number">1</span>)</div>
                 `
             },
             "diffusion": {
@@ -4318,19 +4985,35 @@ output, attn_weights = mha(x, x, x)  <span style="color: #6c7086;"># Self-attent
             },
             "rnn": {
                 overview: `
-                    <h3>The Problem of Long-Term Dependencies</h3>
-                    <p>Imagine trying to predict the last word in the text: "I grew up in France... [200 words] ... I speak fluent <strong>French</strong>."</p>
-                    <p>Standard RNNs fail here. As the gap grows, the gradient from "French" has to travel back 200 steps to "France".</p>
-                    
-                    <div class="callout warning">
-                        <div class="callout-title">⚠️ The Vanishing Gradient Failure</div>
-                        If the weight W < 1, the gradient shrinks exponentially: 0.9²⁰⁰ ≈ 0.0000000007.<br>
-                        The network literally "forgets" the context.
-                    </div>
-                    
-                    <h3>The LSTM Solution: "The Conveyor Belt"</h3>
-                    <p>The core idea of LSTM is the <strong>Cell State (C)</strong>. It runs straight down the entire chain, with only minor linear interactions. It's like a conveyor belt—information can flow along it unchanged.</p>
-                `,
+                <p>Recurrent Neural Networks (RNNs) are designed for <strong>sequential data</strong> — text, time series, audio, video frames. Unlike feedforward networks that process inputs independently, RNNs have a <strong>memory</strong> (hidden state) that carries information from previous time steps.</p>
+
+                <div class="callout insight">
+                    <div class="callout-title">📖 The Reading Analogy</div>
+                    When you read a sentence, you don't forget the beginning when you reach the end. Your brain maintains context. RNNs do the same — they process one word (token) at a time while maintaining a hidden state that summarizes everything seen so far.
+                </div>
+
+                <h3>Vanilla RNN vs. LSTM vs. GRU</h3>
+                <table style="width:100%; border-collapse: collapse; margin: 15px 0;">
+                    <tr style="border-bottom: 2px solid var(--cyan);">
+                        <th style="padding: 10px; color: var(--cyan);">Feature</th>
+                        <th style="padding: 10px; color: var(--cyan);">Vanilla RNN</th>
+                        <th style="padding: 10px; color: var(--cyan);">LSTM</th>
+                        <th style="padding: 10px; color: var(--cyan);">GRU</th>
+                    </tr>
+                    <tr style="border-bottom: 1px solid rgba(255,255,255,0.1);"><td style="padding: 8px;">Memory</td><td>Short (5-10 steps)</td><td>Long (100+ steps)</td><td>Long</td></tr>
+                    <tr style="border-bottom: 1px solid rgba(255,255,255,0.1);"><td style="padding: 8px;">Gates</td><td>None</td><td>3 (forget, input, output)</td><td>2 (reset, update)</td></tr>
+                    <tr style="border-bottom: 1px solid rgba(255,255,255,0.1);"><td style="padding: 8px;">Parameters</td><td>Fewest</td><td>Most (4x hidden_dim²)</td><td>Middle (3x hidden_dim²)</td></tr>
+                    <tr><td style="padding: 8px;">Use Today?</td><td>❌ Rarely</td><td>✅ Still useful</td><td>✅ Often preferred</td></tr>
+                </table>
+
+                <h3>The Vanishing Gradient Problem in RNNs</h3>
+                <p>Vanilla RNNs multiply the gradient by the same weight matrix at each time step. After many steps, the gradient either <strong>vanishes</strong> (matrix eigenvalues &lt; 1) or <strong>explodes</strong> (eigenvalues &gt; 1). LSTMs solve this with a special <strong>cell state</strong> highway that allows gradients to flow unchanged over many steps.</p>
+
+                <div class="callout tip">
+                    <div class="callout-title">🔮 Historical Note</div>
+                    RNNs dominated NLP from 2013-2017. The Transformer architecture (2017) has now largely replaced them because Transformers can process all tokens in parallel, while RNNs must process sequentially. However, RNNs are still used for real-time streaming data and edge devices.
+                </div>
+`,
                 concepts: `
                     <h3>Step-by-Step LSTM Walkthrough</h3>
                     <p>LSTMs control the cell state via "Gates".</p>
@@ -4372,12 +5055,12 @@ output, attn_weights = mha(x, x, x)  <span style="color: #6c7086;"># Self-attent
                     <h3>Paper & Pain: Why LSTMs Don't Vanish</h3>
                     <p>Let's look at the gradient flow in the Cell State equation:</p>
                     <div class="formula">
-                        C_t = f_t \cdot C_{t-1} + i_t \cdot \tilde{C}_t
+                        C_t = f_t \\cdot C_{t-1} + i_t \\cdot \\tilde{C}_t
                     </div>
                     
                     <p>During backpropagation (BPTT), the derivative of C_t with respect to C_{t-1} is:</p>
                     <div class="formula" style="color: #00ff88;">
-                        \frac{\partial C_t}{\partial C_{t-1}} = f_t + \dots
+                        \\frac{\\partial C_t}{\\partial C_{t-1}} = f_t + \\dots
                     </div>
                     
                     <div class="callout tip">
@@ -4417,56 +5100,64 @@ output, attn_weights = mha(x, x, x)  <span style="color: #6c7086;"># Self-attent
                             Generating melody and chords where context (key signature, tempo) must be maintained for minutes.
                         </div>
                     </div>
+                `,
+                code: `
+                    <h3>LSTM Cell Equations</h3>
+                    <div class="formula" style="text-align:center;">
+                        <strong>Forget Gate:</strong> $$f_t = \\sigma(W_f \\cdot [h_{t-1}, x_t] + b_f)$$
+                        <strong>Input Gate:</strong> $$i_t = \\sigma(W_i \\cdot [h_{t-1}, x_t] + b_i)$$
+                        <strong>Cell Update:</strong> $$\\tilde{C}_t = \\tanh(W_C \\cdot [h_{t-1}, x_t] + b_C)$$
+                        $$C_t = f_t \\odot C_{t-1} + i_t \\odot \\tilde{C}_t$$
+                        <strong>Output Gate:</strong> $$o_t = \\sigma(W_o \\cdot [h_{t-1}, x_t] + b_o)$$
+                        $$h_t = o_t \\odot \\tanh(C_t)$$
+                    </div>
+<span class="code-title">📄 lstm_sentiment.py</span><div class="code-block"><span class="keyword">import</span> torch
+<span class="keyword">import</span> torch.nn <span class="keyword">as</span> nn
+
+<span class="keyword">class</span> <span class="class-name">SentimentLSTM</span>(nn.Module):
+    <span class="keyword">def</span> <span class="function">__init__</span>(self, vocab_size, embed_dim, hidden_dim):
+        <span class="builtin">super</span>().__init__()
+        self.embedding = nn.Embedding(vocab_size, embed_dim)
+        self.lstm = nn.LSTM(embed_dim, hidden_dim, batch_first=<span class="keyword">True</span>, bidirectional=<span class="keyword">True</span>)
+        self.fc = nn.Linear(hidden_dim * <span class="number">2</span>, <span class="number">1</span>)  <span class="comment"># *2 for bidirectional</span>
+    
+    <span class="keyword">def</span> <span class="function">forward</span>(self, x):
+        embeds = self.embedding(x)                <span class="comment"># (batch, seq_len, embed_dim)</span>
+        lstm_out, (h_n, c_n) = self.lstm(embeds)  <span class="comment"># h_n: final hidden states</span>
+        hidden = torch.cat((h_n[-<span class="number">2</span>], h_n[-<span class="number">1</span>]), dim=<span class="number">1</span>)
+        <span class="keyword">return</span> torch.sigmoid(self.fc(hidden))
+
+model = SentimentLSTM(vocab_size=<span class="number">10000</span>, embed_dim=<span class="number">128</span>, hidden_dim=<span class="number">256</span>)
+x = torch.randint(<span class="number">0</span>, <span class="number">10000</span>, (<span class="number">4</span>, <span class="number">50</span>))  <span class="comment"># batch=4, seq_len=50</span>
+<span class="keyword">print</span>(model(x).shape)  <span class="comment"># (4, 1)</span></div>
                 `
             },
             "bert": {
                 overview: `
-                    <h3>BERT: Bidirectional Encoder Representations from Transformers</h3>
-                    <p><strong>Paper:</strong> "BERT: Pre-training of Deep Bidirectional Transformers for Language Understanding" (Devlin et al., 2018)</p>
-                    <p><strong>arXiv:</strong> <a href="https://arxiv.org/abs/1810.04805" target="_blank">1810.04805</a></p>
-                    
-                    <div class="callout insight">
-                        <div class="callout-title">🎯 Key Innovation</div>
-                        BERT revolutionized NLP by introducing <strong>bidirectional pre-training</strong>. Unlike previous models (GPT, ELMo) that processed text left-to-right or combined shallow bidirectional representations, BERT deeply integrates left AND right context in all layers simultaneously.
-                    </div>
-                    
-                    <h3>Why BERT Matters</h3>
-                    <ul>
-                        <li><strong>Transfer Learning for NLP:</strong> Pre-train once on massive unlabeled data, fine-tune on many tasks</li>
-                        <li><strong>State-of-the-Art Results:</strong> Set new records on 11 NLP tasks including SQuAD, GLUE, and SWAG</li>
-                        <li><strong>Efficiency:</strong> Fine-tuning requires minimal task-specific architecture changes</li>
-                        <li><strong>Accessibility:</strong> Google released pre-trained models publicly</li>
-                    </ul>
-                    
-                    <h3>Pre-training Corpus</h3>
-                    <div class="info-box">
-                        <div class="box-title">📚 Training Data</div>
-                        <div class="box-content">
-                            <strong>BooksCorpus:</strong> 800M words from 11,038 unpublished books<br>
-                            <strong>English Wikipedia:</strong> 2,500M words (text passages only, no lists/tables/headers)<br>
-                            <strong>Total:</strong> ~3.3 billion words
-                        </div>
-                    </div>
-                    
-                    <h3>Pre-training Tasks</h3>
-                    <div class="list-item">
-                        <div class="list-num">01</div>
-                        <div><strong>Masked Language Modeling (MLM):</strong> Randomly mask 15% of tokens and predict them using bidirectional context. Example: "The cat [MASK] on the mat" → predict "sat"</div>
-                    </div>
-                    <div class="list-item">
-                        <div class="list-num">02</div>
-                        <div><strong>Next Sentence Prediction (NSP):</strong> Given sentence pairs (A, B), predict if B actually follows A in the corpus. Helps with tasks like QA and NLI that require understanding sentence relationships.</div>
-                    </div>
-                    
-                    <div class="callout tip">
-                        <div class="callout-title">💡 The BERT Fine-tuning Paradigm</div>
-                        1. <strong>Pre-train</strong> BERT on BooksCorpus + Wikipedia (days/weeks on TPUs)<br>
-                        2. <strong>Download</strong> pre-trained weights from Google<br>
-                        3. <strong>Add</strong> task-specific head (1 layer for classification/QA/NER)<br>
-                        4. <strong>Fine-tune</strong> entire model on your dataset (hours on single GPU)<br>
-                        5. <strong>Achieve SOTA</strong> with as few as 3,600 labeled examples!
-                    </div>
-                `,
+                <p>BERT (Bidirectional Encoder Representations from Transformers) revolutionized NLP in 2018. Unlike GPT which reads left-to-right, BERT reads <strong>both directions simultaneously</strong>, giving it a deeper understanding of context.</p>
+
+                <div class="callout insight">
+                    <div class="callout-title">📝 The Fill-in-the-Blank Analogy</div>
+                    BERT was trained by randomly masking 15% of words and predicting them using the surrounding context (both left and right). It's like a student learning vocabulary by doing fill-in-the-blank exercises: "The cat sat on the [MASK]" → "mat". This bidirectional context is what makes BERT so powerful for understanding language.
+                </div>
+
+                <h3>Two Training Objectives</h3>
+                <div class="list-item"><div class="list-num">1</div><div><strong>Masked Language Modeling (MLM):</strong> Randomly mask 15% of tokens and predict them. This forces the model to understand context from both sides.</div></div>
+                <div class="list-item"><div class="list-num">2</div><div><strong>Next Sentence Prediction (NSP):</strong> Given two sentences, predict if sentence B follows sentence A. This teaches the model inter-sentence relationships. (Note: Later papers showed NSP isn't crucial.)</div></div>
+
+                <h3>BERT vs GPT</h3>
+                <table style="width:100%; border-collapse: collapse; margin: 15px 0;">
+                    <tr style="border-bottom: 2px solid var(--cyan);">
+                        <th style="padding: 10px; color: var(--cyan);">Feature</th>
+                        <th style="padding: 10px; color: var(--cyan);">BERT</th>
+                        <th style="padding: 10px; color: var(--cyan);">GPT</th>
+                    </tr>
+                    <tr style="border-bottom: 1px solid rgba(255,255,255,0.1);"><td style="padding: 8px;">Direction</td><td>Bidirectional</td><td>Left-to-right (autoregressive)</td></tr>
+                    <tr style="border-bottom: 1px solid rgba(255,255,255,0.1);"><td style="padding: 8px;">Best for</td><td>Understanding (classification, QA, NER)</td><td>Generation (text, code, chat)</td></tr>
+                    <tr style="border-bottom: 1px solid rgba(255,255,255,0.1);"><td style="padding: 8px;">Architecture</td><td>Transformer Encoder</td><td>Transformer Decoder</td></tr>
+                    <tr><td style="padding: 8px;">Parameters</td><td>110M (base) / 340M (large)</td><td>175B (GPT-3) / 1.7T (GPT-4)</td></tr>
+                </table>
+`,
                 concepts: `
                     <h3>BERT Architecture</h3>
                     <p>BERT uses a multi-layer bidirectional Transformer encoder based on Vaswani et al. (2017).</p>
@@ -4768,56 +5459,64 @@ output, attn_weights = mha(x, x, x)  <span style="color: #6c7086;"># Self-attent
                         )<br>
                         print(answer)  # "a bidirectional Transformer for NLP"
                     </div>
+                `,
+                code: `
+                    <h3>BERT Training Objectives</h3>
+                    <div class="formula" style="text-align:center;">
+                        <strong>MLM:</strong> $$L_{MLM} = -\\sum_{i \\in M} \\log P(x_i | x_{\\backslash M})$$
+                        <strong>NSP:</strong> $$L_{NSP} = -[y\\log(p) + (1-y)\\log(1-p)]$$
+                    </div>
+<span class="code-title">📄 bert_huggingface.py</span><div class="code-block"><span class="keyword">from</span> transformers <span class="keyword">import</span> BertTokenizer, BertModel, pipeline
+
+<span class="comment"># --- Quick sentiment analysis ---</span>
+classifier = pipeline(<span class="string">"sentiment-analysis"</span>)
+result = classifier(<span class="string">"Deep learning is fascinating!"</span>)
+<span class="keyword">print</span>(result)  <span class="comment"># [{'label': 'POSITIVE', 'score': 0.9998}]</span>
+
+<span class="comment"># --- BERT Embeddings for custom tasks ---</span>
+tokenizer = BertTokenizer.from_pretrained(<span class="string">"bert-base-uncased"</span>)
+model = BertModel.from_pretrained(<span class="string">"bert-base-uncased"</span>)
+
+text = <span class="string">"Neural networks learn features automatically"</span>
+inputs = tokenizer(text, return_tensors=<span class="string">"pt"</span>)
+outputs = model(**inputs)
+
+<span class="comment"># CLS token embedding (sentence representation)</span>
+cls_embedding = outputs.last_hidden_state[:, <span class="number">0</span>, :]
+<span class="keyword">print</span>(f<span class="string">"Shape: {cls_embedding.shape}"</span>)  <span class="comment"># (1, 768)</span></div>
                 `
             },
             "gpt": {
                 overview: `
-                    <h3>GPT (Generative Pre-trained Transformer)</h3>
-                    <p>Decoder-only Transformer trained to predict next token (autoregressive language modeling).</p>
-                    
-                    <h3>GPT Evolution</h3>
-                    <table>
-                        <tr>
-                            <th>Model</th>
-                            <th>Params</th>
-                            <th>Training Data</th>
-                            <th>Capability</th>
-                        </tr>
-                        <tr>
-                            <td>GPT-1</td>
-                            <td>117M</td>
-                            <td>BooksCorpus</td>
-                            <td>Basic text generation</td>
-                        </tr>
-                        <tr>
-                            <td>GPT-2</td>
-                            <td>1.5B</td>
-                            <td>WebText (40GB)</td>
-                            <td>Coherent paragraphs</td>
-                        </tr>
-                        <tr>
-                            <td>GPT-3</td>
-                            <td>175B</td>
-                            <td>570GB text</td>
-                            <td>Few-shot learning</td>
-                        </tr>
-                        <tr>
-                            <td>GPT-4</td>
-                            <td>~1.8T</td>
-                            <td>Multi-modal</td>
-                            <td>Reasoning, coding, images</td>
-                        </tr>
-                    </table>
-                    
-                    <div class="callout insight">
-                        <div class="callout-title">🚀 Emergent Abilities</div>
-                        As models scale, new capabilities emerge:<br>
-                        • In-context learning (learn from prompts)<br>
-                        • Chain-of-thought reasoning<br>
-                        • Code generation<br>
-                        • Multi-step problem solving
-                    </div>
-                `,
+                <p>GPT (Generative Pre-trained Transformer) is the architecture behind ChatGPT, GitHub Copilot, and the AI revolution. It's a <strong>decoder-only Transformer</strong> trained to predict the next token in a sequence — a simple objective that produces remarkably intelligent behavior.</p>
+
+                <div class="callout insight">
+                    <div class="callout-title">🎯 The Core Idea</div>
+                    GPT's entire training objective is <strong>next-token prediction</strong>: given "The cat sat on the", predict "mat". By doing this on trillions of tokens from the internet, the model learns grammar, facts, reasoning, coding, math — all as a byproduct of predicting what comes next. It's arguably the most powerful simple idea in AI.
+                </div>
+
+                <h3>The GPT Family</h3>
+                <table style="width:100%; border-collapse: collapse; margin: 15px 0;">
+                    <tr style="border-bottom: 2px solid var(--cyan);">
+                        <th style="padding: 10px; color: var(--cyan);">Model</th>
+                        <th style="padding: 10px; color: var(--cyan);">Year</th>
+                        <th style="padding: 10px; color: var(--cyan);">Parameters</th>
+                        <th style="padding: 10px; color: var(--cyan);">Key Innovation</th>
+                    </tr>
+                    <tr style="border-bottom: 1px solid rgba(255,255,255,0.1);"><td style="padding: 8px;">GPT-1</td><td>2018</td><td>117M</td><td>Pretrain on unlabeled text, fine-tune</td></tr>
+                    <tr style="border-bottom: 1px solid rgba(255,255,255,0.1);"><td style="padding: 8px;">GPT-2</td><td>2019</td><td>1.5B</td><td>Zero-shot task transfer</td></tr>
+                    <tr style="border-bottom: 1px solid rgba(255,255,255,0.1);"><td style="padding: 8px;">GPT-3</td><td>2020</td><td>175B</td><td>In-context learning, few-shot prompting</td></tr>
+                    <tr style="border-bottom: 1px solid rgba(255,255,255,0.1);"><td style="padding: 8px;">GPT-4</td><td>2023</td><td>~1.7T (MoE)</td><td>Multimodal (text + images), RLHF</td></tr>
+                    <tr><td style="padding: 8px;">GPT-4o</td><td>2024</td><td>Unknown</td><td>Native multimodal (audio, video, text)</td></tr>
+                </table>
+
+                <h3>How GPT Generates Text</h3>
+                <p>GPT uses <strong>autoregressive generation</strong>: it generates one token at a time, each conditioned on all previous tokens. The process:</p>
+                <div class="list-item"><div class="list-num">1</div><div>Feed prompt tokens through the Transformer decoder</div></div>
+                <div class="list-item"><div class="list-num">2</div><div>Get probability distribution over vocabulary (~50K tokens)</div></div>
+                <div class="list-item"><div class="list-num">3</div><div>Sample from the distribution (temperature, top-k, top-p control randomness)</div></div>
+                <div class="list-item"><div class="list-num">4</div><div>Append the new token and repeat from step 1</div></div>
+`,
                 concepts: `
                     <h3>GPT Architecture</h3>
                     <div class="list-item">
@@ -4874,6 +5573,27 @@ output, attn_weights = mha(x, x, x)  <span style="color: #6c7086;"># Self-attent
                             GitHub Copilot, code completion, bug fixing, documentation
                         </div>
                     </div>
+                `,
+                code: `<span class="code-title">📄 gpt_generation.py</span><div class="code-block"><span class="keyword">from</span> transformers <span class="keyword">import</span> GPT2LMHeadModel, GPT2Tokenizer
+
+tokenizer = GPT2Tokenizer.from_pretrained(<span class="string">"gpt2"</span>)
+model = GPT2LMHeadModel.from_pretrained(<span class="string">"gpt2"</span>)
+
+<span class="comment"># Generate text</span>
+prompt = <span class="string">"Deep learning has revolutionized"</span>
+inputs = tokenizer.encode(prompt, return_tensors=<span class="string">"pt"</span>)
+
+outputs = model.generate(
+    inputs, max_length=<span class="number">100</span>,
+    temperature=<span class="number">0.7</span>,        <span class="comment"># creativity control</span>
+    top_k=<span class="number">50</span>,               <span class="comment"># top-k sampling</span>
+    top_p=<span class="number">0.9</span>,              <span class="comment"># nucleus sampling</span>
+    do_sample=<span class="keyword">True</span>,
+    no_repeat_ngram_size=<span class="number">2</span>,
+)
+
+text = tokenizer.decode(outputs[<span class="number">0</span>])
+<span class="keyword">print</span>(text)</div>
                 `
             },
             "vit": {
@@ -5006,8 +5726,8 @@ output, attn_weights = mha(x, x, x)  <span style="color: #6c7086;"># Self-attent
                     
                     <div class="formula">
                         1. Score: $e_{tj} = score(s_{t-1}, h_j)$ (e.g., Dot Product)<br>
-                        2. Weights: $\alpha_{tj} = softmax(e_{tj})$<br>
-                        3. Context: $c_t = \sum \alpha_{tj} h_j$<br>
+                        2. Weights: $\\alpha_{tj} = softmax(e_{tj})$<br>
+                        3. Context: $c_t = \\sum \\alpha_{tj} h_j$<br>
                         4. Output: $s_t = RNN(s_{t-1}, [y_{t-1}, c_t])$
                     </div>
                     
@@ -5089,7 +5809,7 @@ output, attn_weights = mha(x, x, x)  <span style="color: #6c7086;"># Self-attent
                         <div class="list-num">2014</div>
                         <div><strong>GANs</strong> (Goodfellow et al.)<br>
                         <em>"Generative Adversarial Networks"</em><br>
-                        <span class="formula-caption">Insight: Training a generator by fighting a discriminator. The minimax game: $\min_G \max_D V(D, G)$.</span><br>
+                        <span class="formula-caption">Insight: Training a generator by fighting a discriminator. The minimax game: $\\min_G \\max_D V(D, G)$.</span><br>
                         <a href="https://arxiv.org/pdf/1406.2661.pdf" target="_blank" style="color: #a371f7;">📄 Read PDF</a></div>
                     </div>
 
@@ -5121,7 +5841,7 @@ output, attn_weights = mha(x, x, x)  <span style="color: #6c7086;"># Self-attent
                         <div class="list-num">2020</div>
                         <div><strong>DDPM</strong> (Ho et al.)<br>
                         <em>"Denoising Diffusion Probabilistic Models"</em><br>
-                        <span class="formula-caption">Insight: Predicting the noise $\epsilon$ is mathematically equivalent to predicting the score function (gradient of data density).</span><br>
+                        <span class="formula-caption">Insight: Predicting the noise $\\epsilon$ is mathematically equivalent to predicting the score function (gradient of data density).</span><br>
                         <a href="https://arxiv.org/pdf/2006.11239.pdf" target="_blank" style="color: #a371f7;">📄 Read PDF</a></div>
                     </div>
                 `,
@@ -5129,13 +5849,13 @@ output, attn_weights = mha(x, x, x)  <span style="color: #6c7086;"># Self-attent
                     <h3>The Formulas That Changed AI</h3>
                     
                     <p><strong>ResNet Residual:</strong></p>
-                    <div class="formula">y = F(x, \{W_i\}) + x</div>
+                    <div class="formula">y = F(x, \\{W_i\}) + x</div>
                     
                     <p><strong>Scaled Dot-Product Attention:</strong></p>
-                    <div class="formula">Attention(Q, K, V) = softmax(\frac{QK^T}{\sqrt{d_k}})V</div>
+                    <div class="formula">Attention(Q, K, V) = softmax(\\frac{QK^T}{\\sqrt{d_k}})V</div>
                     
                     <p><strong>Diffusion Reverse Process:</strong></p>
-                    <div class="formula">p_\theta(x_{t-1}|x_t) = \mathcal{N}(x_{t-1}; \mu_\theta(x_t, t), \Sigma_\theta(x_t, t))</div>
+                    <div class="formula">p_\\theta(x_{t-1}|x_t) = \\mathcal{N}(x_{t-1}; \\mu_\\theta(x_t, t), \\Sigma_\\theta(x_t, t))</div>
                 `,
                 applications: `
                     <div class="info-box">
@@ -5223,69 +5943,33 @@ output, attn_weights = mha(x, x, x)  <span style="color: #6c7086;"># Self-attent
             },
             "vector-db": {
                 overview: `
-                    <h3>What are Vector Databases?</h3>
-                    <p>Vector databases store data as <strong>high-dimensional numerical vectors</strong> (embeddings) and enable <strong>similarity search</strong> instead of exact-match queries. They are the backbone of modern AI applications like semantic search, recommendation systems, and RAG pipelines.</p>
-                    
-                    <h3>Why Do We Need Them?</h3>
-                    <ul>
-                        <li><strong>Semantic Understanding:</strong> Traditional databases search by keywords; vector DBs search by meaning</li>
-                        <li><strong>AI-Native:</strong> LLMs and neural networks produce embeddings — vector DBs store and query them</li>
-                        <li><strong>Scale:</strong> Billions of vectors with sub-millisecond query times using approximate nearest neighbor (ANN) algorithms</li>
-                        <li><strong>Multi-Modal:</strong> Store text, image, audio, and video embeddings in the same space</li>
-                    </ul>
-                    
-                    <h3>Vector DB Landscape</h3>
-                    <table>
-                        <tr>
-                            <th>Database</th>
-                            <th>Type</th>
-                            <th>Best For</th>
-                            <th>Index</th>
-                        </tr>
-                        <tr>
-                            <td>FAISS</td>
-                            <td>Library</td>
-                            <td>Research, local use</td>
-                            <td>IVF, HNSW, PQ</td>
-                        </tr>
-                        <tr>
-                            <td>Pinecone</td>
-                            <td>Managed SaaS</td>
-                            <td>Production, low-ops</td>
-                            <td>Proprietary</td>
-                        </tr>
-                        <tr>
-                            <td>ChromaDB</td>
-                            <td>Open-Source</td>
-                            <td>Prototyping, local RAG</td>
-                            <td>HNSW</td>
-                        </tr>
-                        <tr>
-                            <td>Weaviate</td>
-                            <td>Open-Source</td>
-                            <td>Hybrid search</td>
-                            <td>HNSW + BM25</td>
-                        </tr>
-                        <tr>
-                            <td>Milvus</td>
-                            <td>Open-Source</td>
-                            <td>Enterprise scale</td>
-                            <td>IVF, DiskANN</td>
-                        </tr>
-                        <tr>
-                            <td>Qdrant</td>
-                            <td>Open-Source</td>
-                            <td>Filtering + search</td>
-                            <td>HNSW</td>
-                        </tr>
-                    </table>
+                <p>Vector databases store and search <strong>high-dimensional embeddings</strong> — the numerical representations that AI models use to understand text, images, and audio. They enable <strong>semantic search</strong>: finding items by meaning, not just keywords.</p>
 
-                    <div class="callout tip">
-                        <div class="callout-title">💡 Key Insight</div>
-                        Traditional DB: "Find all users named John"<br>
-                        Vector DB: "Find all users <strong>similar to</strong> this profile" — completely different paradigm!
-                    </div>
-                `,
+                <div class="callout insight">
+                    <div class="callout-title">📚 Traditional DB vs Vector DB</div>
+                    <strong>Traditional (SQL):</strong> "Find documents with the word 'dog'" → Exact keyword match<br>
+                    <strong>Vector DB:</strong> "Find documents about pets" → Returns articles about dogs, cats, hamsters — because their <em>meaning</em> is similar even if they don't share exact words.
+                </div>
+
+                <h3>How It Works</h3>
+                <div class="list-item"><div class="list-num">1</div><div><strong>Embed:</strong> Convert text/images into vectors using an embedding model (e.g., OpenAI ada-002, sentence-transformers)</div></div>
+                <div class="list-item"><div class="list-num">2</div><div><strong>Index:</strong> Store vectors in a specialized data structure (HNSW, IVF, product quantization) for fast search</div></div>
+                <div class="list-item"><div class="list-num">3</div><div><strong>Query:</strong> Convert query to a vector, find the K nearest neighbors using cosine similarity or L2 distance</div></div>
+
+                <h3>Popular Vector Databases</h3>
+                <table style="width:100%; border-collapse: collapse; margin: 15px 0;">
+                    <tr style="border-bottom: 2px solid var(--cyan);">
+                        <th style="padding: 10px; color: var(--cyan);">Database</th>
+                        <th style="padding: 10px; color: var(--cyan);">Type</th>
+                        <th style="padding: 10px; color: var(--cyan);">Best For</th>
+                    </tr>
+                    <tr style="border-bottom: 1px solid rgba(255,255,255,0.1);"><td style="padding: 8px;">ChromaDB</td><td>In-memory, local</td><td>Prototyping, small datasets</td></tr>
+                    <tr style="border-bottom: 1px solid rgba(255,255,255,0.1);"><td style="padding: 8px;">FAISS (Meta)</td><td>Library</td><td>Billion-scale search, GPU-accelerated</td></tr>
+                    <tr style="border-bottom: 1px solid rgba(255,255,255,0.1);"><td style="padding: 8px;">Pinecone</td><td>Cloud service</td><td>Production SaaS, managed infrastructure</td></tr>
+                    <tr style="border-bottom: 1px solid rgba(255,255,255,0.1);"><td style="padding: 8px;">Weaviate</td><td>Open-source</td><td>Multi-modal search, GraphQL API</td></tr>
+                    <tr><td style="padding: 8px;">Milvus</td><td>Open-source</td><td>Enterprise, distributed scaling</td></tr>
+                </table>
+`,
                 concepts: `
                     <h3>Core Concepts</h3>
                     <div class="list-item">
@@ -5314,7 +5998,7 @@ output, attn_weights = mha(x, x, x)  <span style="color: #6c7086;"># Self-attent
                     </div>
                     
                     <h3>Embedding Pipeline</h3>
-                    <div class="formula">
+                    <div class="formul a">
                         1. Raw Data → Embedding Model → Vector (e.g., [0.12, -0.34, 0.56, ...])<br>
                         2. Store vector + metadata in Vector DB<br>
                         3. Query: Convert query → vector → Find nearest neighbors<br>
@@ -5395,45 +6079,56 @@ output, attn_weights = mha(x, x, x)  <span style="color: #6c7086;"># Self-attent
                             <strong>Google Lens:</strong> Find products by uploading a photo
                         </div>
                     </div>
+                `,
+                code: `
+                    <h3>Similarity Metrics</h3>
+                    <div class="formula" style="text-align:center;">
+                        <strong>Cosine Similarity:</strong> $$\\cos(\\theta) = \\frac{A \\cdot B}{\\|A\\| \\|B\\|}$$
+                        <strong>L2 (Euclidean):</strong> $$d = \\sqrt{\\sum(a_i - b_i)^2}$$
+                    </div>
+<span class="code-title">📄 chromadb_example.py</span><div class="code-block"><span class="keyword">import</span> chromadb
+
+client = chromadb.Client()
+collection = client.create_collection(<span class="string">"dl_docs"</span>)
+
+<span class="comment"># Add documents</span>
+collection.add(
+    documents=[<span class="string">"Neural networks use backpropagation"</span>, <span class="string">"CNNs detect visual patterns"</span>],
+    ids=[<span class="string">"doc1"</span>, <span class="string">"doc2"</span>],
+)
+
+<span class="comment"># Query</span>
+results = collection.query(query_texts=[<span class="string">"How do neural nets learn?"</span>], n_results=<span class="number">1</span>)
+<span class="keyword">print</span>(results[<span class="string">"documents"</span>])  <span class="comment"># [["Neural networks use backpropagation"]]</span></div>
                 `
             },
             "rag": {
                 overview: `
-                    <h3>Retrieval-Augmented Generation (RAG)</h3>
-                    <p>RAG combines the <strong>reasoning power of LLMs</strong> with <strong>external knowledge retrieval</strong> to produce accurate, grounded, and up-to-date responses. It solves the fundamental problem of LLM hallucination by anchoring generation in real data.</p>
-                    
-                    <h3>Why RAG?</h3>
-                    <ul>
-                        <li><strong>Reduces Hallucination:</strong> LLMs generate from training data; RAG retrieves from your actual documents</li>
-                        <li><strong>Always Up-to-Date:</strong> No need to retrain the model when knowledge changes — just update the vector store</li>
-                        <li><strong>Domain-Specific:</strong> Works with proprietary data (internal docs, codebases, policies)</li>
-                        <li><strong>Cost-Effective:</strong> Much cheaper than fine-tuning for knowledge injection</li>
-                        <li><strong>Verifiable:</strong> Retrieved sources can be cited, enabling fact-checking</li>
-                    </ul>
-                    
-                    <div class="callout tip">
-                        <div class="callout-title">💡 RAG vs Fine-Tuning</div>
-                        <strong>Fine-tuning:</strong> Changes the model's behavior/style (teach it HOW to respond)<br>
-                        <strong>RAG:</strong> Changes the model's knowledge (give it WHAT to respond with)<br><br>
-                        Rule of thumb: Use RAG for knowledge, fine-tuning for behavior. Combine both for production systems.
-                    </div>
-                    
-                    <h3>The RAG Pipeline</h3>
-                    <div class="formula">
-                        <strong>Indexing Phase (Offline):</strong><br>
-                        Documents → Chunk → Embed → Store in Vector DB<br><br>
-                        <strong>Query Phase (Online):</strong><br>
-                        User Query → Embed → Retrieve top-k chunks → Context + Query → LLM → Answer
-                    </div>
-                    
-                    <div class="callout warning">
-                        <div class="callout-title">⚠️ RAG Failure Modes</div>
-                        • <strong>Poor chunking:</strong> Chunks too large (diluted) or too small (missing context)<br>
-                        • <strong>Retrieval misses:</strong> Relevant docs not in top-k results<br>
-                        • <strong>Lost in the middle:</strong> LLMs ignore context in the middle of long prompts<br>
-                        • <strong>Outdated embeddings:</strong> Vector store not synced with source documents
-                    </div>
-                `,
+                <p>RAG (Retrieval-Augmented Generation) is the <strong>most practical pattern for building AI applications</strong> today. Instead of relying solely on an LLM's training data (which is frozen at training time), RAG retrieves relevant documents from your own knowledge base and includes them in the prompt.</p>
+
+                <div class="callout insight">
+                    <div class="callout-title">💡 Why RAG Matters</div>
+                    LLMs have two fundamental problems: (1) they hallucinate — confidently generating false information, and (2) their knowledge has a cutoff date. RAG solves both by grounding the LLM's responses in <strong>actual, verifiable documents</strong> from your data.
+                </div>
+
+                <h3>The RAG Pipeline</h3>
+                <div class="list-item"><div class="list-num">1</div><div><strong>Ingestion (Offline):</strong> Load documents → Split into chunks (500-1000 tokens) → Embed each chunk → Store in vector DB</div></div>
+                <div class="list-item"><div class="list-num">2</div><div><strong>Retrieval (Online):</strong> User asks a question → Embed the question → Find K most similar chunks in vector DB</div></div>
+                <div class="list-item"><div class="list-num">3</div><div><strong>Generation:</strong> Stuff retrieved chunks into the prompt as context → LLM generates an answer grounded in the context</div></div>
+
+                <h3>RAG vs. Fine-Tuning</h3>
+                <table style="width:100%; border-collapse: collapse; margin: 15px 0;">
+                    <tr style="border-bottom: 2px solid var(--cyan);">
+                        <th style="padding: 10px; color: var(--cyan);">Aspect</th>
+                        <th style="padding: 10px; color: var(--cyan);">RAG</th>
+                        <th style="padding: 10px; color: var(--cyan);">Fine-Tuning</th>
+                    </tr>
+                    <tr style="border-bottom: 1px solid rgba(255,255,255,0.1);"><td style="padding: 8px;">Knowledge updates</td><td>Instant (add new docs)</td><td>Requires retraining</td></tr>
+                    <tr style="border-bottom: 1px solid rgba(255,255,255,0.1);"><td style="padding: 8px;">Hallucination</td><td>Reduced (grounded in docs)</td><td>Can still hallucinate</td></tr>
+                    <tr style="border-bottom: 1px solid rgba(255,255,255,0.1);"><td style="padding: 8px;">Cost</td><td>Low (no training needed)</td><td>High (GPU compute)</td></tr>
+                    <tr><td style="padding: 8px;">Best for</td><td>QA over docs, support bots</td><td>Teaching new skills/style</td></tr>
+                </table>
+`,
                 concepts: `
                     <h3>RAG Architecture Deep Dive</h3>
                     
@@ -5569,68 +6264,63 @@ output, attn_weights = mha(x, x, x)  <span style="color: #6c7086;"># Self-attent
                         • <strong>Haystack:</strong> Production-ready, NLP-first<br>
                         • <strong>Semantic Kernel:</strong> Microsoft's enterprise RAG framework
                     </div>
+                `,
+                code: `<span class="code-title">📄 rag_langchain.py</span><div class="code-block"><span class="keyword">from</span> langchain.document_loaders <span class="keyword">import</span> PyPDFLoader
+<span class="keyword">from</span> langchain.text_splitter <span class="keyword">import</span> RecursiveCharacterTextSplitter
+<span class="keyword">from</span> langchain.embeddings <span class="keyword">import</span> OpenAIEmbeddings
+<span class="keyword">from</span> langchain.vectorstores <span class="keyword">import</span> Chroma
+<span class="keyword">from</span> langchain.chains <span class="keyword">import</span> RetrievalQA
+<span class="keyword">from</span> langchain.llms <span class="keyword">import</span> OpenAI
+
+<span class="comment"># 1. Load & chunk documents</span>
+loader = PyPDFLoader(<span class="string">"deep_learning_book.pdf"</span>)
+docs = loader.load()
+splitter = RecursiveCharacterTextSplitter(chunk_size=<span class="number">1000</span>, chunk_overlap=<span class="number">200</span>)
+chunks = splitter.split_documents(docs)
+
+<span class="comment"># 2. Create vector store</span>
+embeddings = OpenAIEmbeddings()
+vectordb = Chroma.from_documents(chunks, embeddings, persist_directory=<span class="string">"./chroma_db"</span>)
+
+<span class="comment"># 3. Query with RAG</span>
+qa_chain = RetrievalQA.from_chain_type(
+    llm=OpenAI(temperature=<span class="number">0</span>),
+    retriever=vectordb.as_retriever(search_kwargs={<span class="string">"k"</span>: <span class="number">3</span>}),
+)
+answer = qa_chain.run(<span class="string">"What is backpropagation?"</span>)
+<span class="keyword">print</span>(answer)</div>
                 `
             },
             "advanced-llm": {
                 overview: `
-                    <h3>Fine-Tuning & Quantization for LLMs</h3>
-                    <p>Fine-tuning adapts a pre-trained LLM to a specific task or domain. Quantization reduces model size and inference cost. Together, they enable <strong>deploying powerful AI on limited hardware</strong>.</p>
-                    
-                    <h3>The Fine-Tuning Spectrum</h3>
-                    <table>
-                        <tr>
-                            <th>Method</th>
-                            <th>Parameters Trained</th>
-                            <th>GPU Memory</th>
-                            <th>Best For</th>
-                        </tr>
-                        <tr>
-                            <td>Full Fine-Tuning</td>
-                            <td>100%</td>
-                            <td>Very High</td>
-                            <td>Fundamental behavior change</td>
-                        </tr>
-                        <tr>
-                            <td>LoRA</td>
-                            <td>0.1-1%</td>
-                            <td>Low</td>
-                            <td>Style/domain adaptation</td>
-                        </tr>
-                        <tr>
-                            <td>QLoRA</td>
-                            <td>0.1-1%</td>
-                            <td>Very Low</td>
-                            <td>Consumer GPU fine-tuning</td>
-                        </tr>
-                        <tr>
-                            <td>Prompt Tuning</td>
-                            <td>~0.01%</td>
-                            <td>Minimal</td>
-                            <td>Task-specific adapters</td>
-                        </tr>
-                        <tr>
-                            <td>RLHF / DPO</td>
-                            <td>Varies</td>
-                            <td>High</td>
-                            <td>Alignment & safety</td>
-                        </tr>
-                    </table>
-                    
-                    <div class="callout tip">
-                        <div class="callout-title">💡 When to Fine-Tune vs RAG</div>
-                        <strong>Fine-tune when:</strong> You need to change HOW the model responds (tone, format, reasoning style)<br>
-                        <strong>Use RAG when:</strong> You need to change WHAT the model knows (add new facts/documents)<br>
-                        <strong>Both when:</strong> Production systems needing custom behavior + dynamic knowledge
-                    </div>
-                    
-                    <div class="callout warning">
-                        <div class="callout-title">⚠️ Fine-Tuning Risks</div>
-                        • <strong>Catastrophic forgetting:</strong> Model loses general capabilities<br>
-                        • <strong>Overfitting:</strong> Small datasets → memorization instead of learning<br>
-                        • <strong>Alignment tax:</strong> Safety guardrails can be weakened<br>
-                        • <strong>Data quality:</strong> "Garbage in, garbage out" — bad examples = bad model
-                    </div>
-                `,
+                <p>Fine-tuning a 7B+ parameter model requires enormous GPU memory (28GB+ for fp32). <strong>LoRA (Low-Rank Adaptation)</strong> makes this practical by training only a tiny fraction of parameters — typically <strong>0.1% or less</strong> — while achieving similar performance to full fine-tuning.</p>
+
+                <div class="callout insight">
+                    <div class="callout-title">🎯 The Key Insight</div>
+                    Research showed that pretrained weight matrices have <strong>low intrinsic dimensionality</strong> — meaning changes during fine-tuning can be represented by low-rank matrices. Instead of updating the full d×d weight matrix W, we add a small update BA where B is d×r and A is r×d, with rank r << d.
+                </div>
+
+                <h3>LoRA Math</h3>
+                <div class="formula" style="text-align:center;">
+                    $$W' = W + \\Delta W = W + BA$$
+                    $$B \\in \\mathbb{R}^{d \\times r}, \\; A \\in \\mathbb{R}^{r \\times d}, \\; r \\ll d$$
+                </div>
+                <p><strong>Example:</strong> For a 4096×4096 weight matrix (16.7M params), LoRA with r=16 adds only 2×4096×16 = 131K params — a <strong>128x reduction</strong>.</p>
+
+                <h3>Quantization + LoRA = QLoRA</h3>
+                <p>QLoRA takes this further by keeping the base model in <strong>4-bit quantized</strong> format and training LoRA adapters in fp16. This means fine-tuning a 65B model on a <strong>single 48GB GPU</strong>.</p>
+                <table style="width:100%; border-collapse: collapse; margin: 15px 0;">
+                    <tr style="border-bottom: 2px solid var(--cyan);">
+                        <th style="padding: 10px; color: var(--cyan);">Method</th>
+                        <th style="padding: 10px; color: var(--cyan);">7B Model Memory</th>
+                        <th style="padding: 10px; color: var(--cyan);">Trainable Params</th>
+                    </tr>
+                    <tr style="border-bottom: 1px solid rgba(255,255,255,0.1);"><td style="padding: 8px;">Full Fine-tune (fp32)</td><td>28 GB</td><td>7B (100%)</td></tr>
+                    <tr style="border-bottom: 1px solid rgba(255,255,255,0.1);"><td style="padding: 8px;">Full Fine-tune (fp16)</td><td>14 GB</td><td>7B (100%)</td></tr>
+                    <tr style="border-bottom: 1px solid rgba(255,255,255,0.1);"><td style="padding: 8px;">LoRA (fp16)</td><td>14 GB</td><td>~4M (0.06%)</td></tr>
+                    <tr><td style="padding: 8px;">QLoRA (4-bit)</td><td>~4 GB</td><td>~4M (0.06%)</td></tr>
+                </table>
+`,
                 concepts: `
                     <h3>LoRA (Low-Rank Adaptation)</h3>
                     <p>Instead of updating all parameters, LoRA freezes the original weights and injects small trainable matrices into each layer.</p>
@@ -5777,6 +6467,31 @@ output, attn_weights = mha(x, x, x)  <span style="color: #6c7086;"># Self-attent
                             <strong>TRL:</strong> Transformer Reinforcement Learning (RLHF/DPO)
                         </div>
                     </div>
+                `,
+                code: `
+                    <h3>LoRA Math</h3>
+                    <div class="formula" style="text-align:center;">
+                        $$W' = W + BA, \\quad B \\in \\mathbb{R}^{d \\times r}, \\; A \\in \\mathbb{R}^{r \\times d}, \\; r \\ll d$$
+                        Trainable params: $2 \\times d \\times r$ instead of $d^2$ (e.g., <strong>128x reduction</strong>)
+                    </div>
+<span class="code-title">📄 lora_finetuning.py</span><div class="code-block"><span class="keyword">from</span> peft <span class="keyword">import</span> LoraConfig, get_peft_model
+<span class="keyword">from</span> transformers <span class="keyword">import</span> AutoModelForCausalLM, AutoTokenizer
+
+<span class="comment"># Load base model</span>
+model = AutoModelForCausalLM.from_pretrained(<span class="string">"meta-llama/Llama-2-7b-hf"</span>)
+
+<span class="comment"># Apply LoRA</span>
+lora_config = LoraConfig(
+    r=<span class="number">16</span>,                  <span class="comment"># rank (lower = fewer params)</span>
+    lora_alpha=<span class="number">32</span>,          <span class="comment"># scaling factor</span>
+    target_modules=[<span class="string">"q_proj"</span>, <span class="string">"v_proj"</span>],  <span class="comment"># which layers to adapt</span>
+    lora_dropout=<span class="number">0.05</span>,
+    task_type=<span class="string">"CAUSAL_LM"</span>,
+)
+
+model = get_peft_model(model, lora_config)
+model.print_trainable_parameters()
+<span class="comment"># Output: trainable: 4,194,304 || all: 6,742,609,920 || 0.06%</span></div>
                 `
             }
         };
@@ -5799,6 +6514,7 @@ output, attn_weights = mha(x, x, x)  <span style="color: #6c7086;"># Self-attent
                         <button class="tab-btn" onclick="switchTab(event, '${module.id}-visualization')">📊 Visualization</button>
                         <button class="tab-btn" onclick="switchTab(event, '${module.id}-math')">Math</button>
                         <button class="tab-btn" onclick="switchTab(event, '${module.id}-applications')">Applications</button>
+                        <button class="tab-btn" onclick="switchTab(event, '${module.id}-code')">🐍 Python Code</button>
                         <button class="tab-btn" onclick="switchTab(event, '${module.id}-summary')">Summary</button>
                     </div>
 
@@ -5875,6 +6591,19 @@ output, attn_weights = mha(x, x, x)  <span style="color: #6c7086;"># Self-attent
                         </div>
                     </div>
 
+                    <div id="${module.id}-code" class="tab">
+                        <div class="section">
+                            <h2>🐍 Python Implementation</h2>
+                            ${content.code || `
+                                <p>Production-ready Python code for ${module.title.toLowerCase()} using PyTorch and TensorFlow.</p>
+                                <div class="callout tip">
+                                    <div class="callout-title">💡 Coming Soon</div>
+                                    Python code examples for this module are being prepared.
+                                </div>
+                            `}
+                        </div>
+                    </div>
+
                     <div id="${module.id}-summary" class="tab">
                         <div class="section">
                             <h2>✅ Summary</h2>
@@ -5936,6 +6665,11 @@ output, attn_weights = mha(x, x, x)  <span style="color: #6c7086;"># Self-attent
             if (tab) tab.classList.add('active');
             e.target.classList.add('active');
 
+            // Re-render MathJax in the newly visible tab
+            if (window.MathJax && window.MathJax.typesetPromise) {
+                window.MathJax.typesetPromise([tab]).catch(function (err) { console.log('MathJax typeset:', err); });
+            }
+
             // Trigger visualization when tabs are clicked
             setTimeout(() => {
                 const moduleId = tabId.split('-')[0];
@@ -6879,7 +7613,7 @@ output, attn_weights = mha(x, x, x)  <span style="color: #6c7086;"># Self-attent
 
         function drawPoolingDemo(ctx, canvas) {
             const cellSize = 30;
-            const matrix = [[12, 20, 30, 0], [8, 12, 2, 0], [34, 70, 37, 4], [112, 100, 25, 12]];
+            const input = [[20, 30, 0, 5], [8, 12, 2, 0], [34, 70, 37, 4], [112, 100, 25, 12]];
 
             ctx.fillStyle = '#e4e6eb';
             ctx.font = 'bold 14px Arial';
@@ -6893,7 +7627,7 @@ output, attn_weights = mha(x, x, x)  <span style="color: #6c7086;"># Self-attent
                     ctx.strokeRect(50 + j * cellSize, 50 + i * cellSize, cellSize, cellSize);
                     ctx.fillStyle = '#e4e6eb';
                     ctx.font = '10px Arial';
-                    ctx.fillText(matrix[i][j], 50 + j * cellSize + cellSize / 2, 50 + i * cellSize + cellSize / 2 + 4);
+                    ctx.fillText(input[i][j], 50 + j * cellSize + cellSize / 2, 50 + i * cellSize + cellSize / 2 + 4);
                 }
             }