diff --git "a/Python/index.html" "b/Python/index.html"
--- "a/Python/index.html"
+++ "b/Python/index.html"
@@ -5,6 +5,8 @@
     <meta charset="UTF-8">
     <meta name="viewport" content="width=device-width, initial-scale=1.0">
     <title>Python for Data Science & AI | Complete Masterclass</title>
+    <meta name="description"
+        content="Comprehensive Python for Data Science & AI curriculum. Python Fundamentals, NumPy, Pandas, Matplotlib, Scikit-learn, PyTorch, TensorFlow, Production Python, and Performance Optimization.">
     <link rel="stylesheet" href="../shared/css/design-system.css">
     <link rel="stylesheet" href="../shared/css/components.css">
     <style>
@@ -26,6 +28,7 @@
             background: linear-gradient(135deg, #0a0f1e 0%, #1a1f3a 100%);
             color: #e0e6ed;
             line-height: 1.6;
+            min-height: 100vh;
         }
 
         .container {
@@ -53,6 +56,24 @@
         .subtitle {
             font-size: 1.2rem;
             color: #8892a6;
+            max-width: 700px;
+            margin: 0 auto;
+        }
+
+        .back-home {
+            display: inline-flex;
+            align-items: center;
+            gap: 0.5rem;
+            color: #8892a6;
+            text-decoration: none;
+            font-size: 0.9rem;
+            margin-bottom: 1.5rem;
+            transition: color 0.3s;
+        }
+
+        .back-home:hover {
+            color: var(--python-yellow);
+            text-decoration: none;
         }
 
         /* Dashboard */
@@ -60,6 +81,10 @@
             display: none;
         }
 
+        .dashboard.active {
+            display: block;
+        }
+
         .modules-grid {
             display: grid;
             grid-template-columns: repeat(auto-fit, minmax(320px, 1fr));
@@ -106,7 +131,7 @@
         }
 
         .card h3 {
-            font-size: 1.5rem;
+            font-size: 1.4rem;
             color: var(--python-yellow);
             margin-bottom: 0.5rem;
         }
@@ -151,19 +176,20 @@
         }
 
         .btn-back {
-            background: var(--python-blue);
-            color: white;
+            background: linear-gradient(135deg, var(--python-blue), var(--python-yellow));
+            color: #fff;
             border: none;
             padding: 0.75rem 1.5rem;
             border-radius: 8px;
             cursor: pointer;
             font-size: 1rem;
+            font-weight: 600;
             margin-bottom: 2rem;
             transition: all 0.3s;
         }
 
         .btn-back:hover {
-            background: #2a5d8a;
+            opacity: 0.9;
             transform: translateX(-4px);
         }
 
@@ -214,7 +240,7 @@
 
         .section {
             background: rgba(255, 255, 255, 0.03);
-            border: 1px solid rgba(255, 255, 255, 0.1);
+            border: 1px solid rgba(255, 255, 255, 0.08);
             border-radius: 12px;
             padding: 2rem;
             margin-bottom: 2rem;
@@ -246,7 +272,7 @@
         td {
             padding: 1rem;
             text-align: left;
-            border-bottom: 1px solid rgba(255, 255, 255, 0.1);
+            border-bottom: 1px solid rgba(255, 255, 255, 0.08);
         }
 
         th {
@@ -256,7 +282,7 @@
         }
 
         tr:hover {
-            background: rgba(255, 255, 255, 0.05);
+            background: rgba(255, 255, 255, 0.03);
         }
 
         /* Code Blocks */
@@ -269,36 +295,43 @@
             overflow-x: auto;
             font-family: 'Fira Code', 'Consolas', monospace;
             line-height: 1.6;
+            white-space: pre-wrap;
+            font-size: 0.9rem;
+            color: #ccc;
         }
 
-        .code-block .comment {
-            color: #6e7681;
-        }
-
-        .code-block .keyword {
+        /* Syntax Highlighting */
+        .keyword {
             color: #ff7b72;
-            font-weight: bold;
         }
 
-        .code-block .string {
+        .string {
             color: #a5d6ff;
         }
 
-        .code-block .function {
+        .comment {
+            color: #8b949e;
+        }
+
+        .function {
             color: #d2a8ff;
         }
 
-        .code-block .number {
+        .number {
             color: #79c0ff;
         }
 
-        .code-block .class {
+        .class {
             color: #ffa657;
         }
 
+        .preprocessor {
+            color: #7ee787;
+        }
+
         /* Info Boxes */
         .info-box {
-            background: linear-gradient(135deg, rgba(55, 118, 171, 0.1), rgba(255, 212, 59, 0.1));
+            background: linear-gradient(135deg, rgba(55, 118, 171, 0.08), rgba(255, 212, 59, 0.08));
             border-left: 4px solid var(--python-blue);
             border-radius: 8px;
             padding: 1.5rem;
@@ -319,13 +352,17 @@
 
         /* Interview Box */
         .interview-box {
-            background: linear-gradient(135deg, rgba(255, 107, 53, 0.1), rgba(163, 113, 247, 0.1));
-            border-left: 4px solid #ff6b35;
+            background: linear-gradient(135deg, rgba(55, 118, 171, 0.08), rgba(255, 212, 59, 0.05));
+            border-left: 4px solid var(--python-yellow);
             border-radius: 8px;
             padding: 1.5rem;
             margin: 1.5rem 0;
         }
 
+        .interview-box strong {
+            color: var(--python-yellow);
+        }
+
         /* Callouts */
         .callout {
             border-radius: 8px;
@@ -335,2582 +372,89 @@
         }
 
         .callout.tip {
-            background: rgba(46, 204, 113, 0.1);
+            background: rgba(46, 204, 113, 0.08);
             border-color: #2ecc71;
         }
 
         .callout.warning {
-            background: rgba(255, 193, 7, 0.1);
+            background: rgba(255, 193, 7, 0.08);
             border-color: #ffc107;
         }
 
+        .callout.insight {
+            background: rgba(55, 118, 171, 0.08);
+            border-color: var(--python-blue);
+        }
+
         .callout-title {
             font-weight: 700;
             margin-bottom: 0.5rem;
         }
 
-        /* Utility */
-        .dashboard.active {
-            display: block;
+        /* Comparison */
+        .comparison {
+            display: grid;
+            grid-template-columns: 1fr 1fr;
+            gap: 1.5rem;
+            margin: 1.5rem 0;
         }
 
-        .hidden {
-            display: none;
+        .comparison-bad {
+            background: rgba(255, 60, 60, 0.08);
+            border: 1px solid rgba(255, 60, 60, 0.25);
+            border-radius: 8px;
+            padding: 1.5rem;
+        }
+
+        .comparison-good {
+            background: rgba(0, 255, 136, 0.08);
+            border: 1px solid rgba(0, 255, 136, 0.25);
+            border-radius: 8px;
+            padding: 1.5rem;
         }
 
         strong {
             color: var(--python-yellow);
         }
+
+        .hidden {
+            display: none;
+        }
+
+        @media (max-width: 768px) {
+            header h1 {
+                font-size: 2rem;
+            }
+
+            .comparison {
+                grid-template-columns: 1fr;
+            }
+
+            .modules-grid {
+                grid-template-columns: 1fr;
+            }
+
+            .container {
+                padding: 1rem;
+            }
+        }
     </style>
 </head>
 
 <body>
     <div class="container">
-        <!-- Dashboard -->
         <div class="dashboard active" id="dashboard">
+            <a href="../index.html" class="back-home">← Back to Main Dashboard</a>
             <header>
-                <h1>🐍 Python for Data Science & AI Masterclass</h1>
-                <p class="subtitle">From Fundamentals to Production — NumPy · Pandas · PyTorch · TensorFlow ·
-                    Scikit-learn</p>
+                <h1>🐍 Python for Data Science & AI</h1>
+                <p class="subtitle">From Fundamentals to Production — NumPy · Pandas · Scikit-learn · PyTorch ·
+                    TensorFlow · Performance Optimization</p>
             </header>
-
             <div class="modules-grid" id="modulesGrid"></div>
         </div>
-
-        <!-- Module Container -->
         <div id="modulesContainer"></div>
     </div>
-
-    <script>
-        const modules = [
-            {
-                id: "python-fundamentals",
-                title: "Python Fundamentals for DS",
-                icon: "🐍",
-                category: "Foundations",
-                description: "Data structures, comprehensions, file I/O, virtual environments"
-            },
-            {
-                id: "numpy",
-                title: "NumPy & Scientific Computing",
-                icon: "🔢",
-                category: "Scientific",
-                description: "ndarrays, broadcasting, vectorization, linear algebra"
-            },
-            {
-                id: "pandas",
-                title: "Pandas & Data Manipulation",
-                icon: "🐼",
-                category: "Data Wrangling",
-                description: "DataFrames, groupby, pivot, time series, merging"
-            },
-            {
-                id: "visualization",
-                title: "Data Visualization",
-                icon: "📊",
-                category: "Visualization",
-                description: "Matplotlib, Seaborn, Plotly — from basics to publication-ready"
-            },
-            {
-                id: "advanced-python",
-                title: "Advanced Python",
-                icon: "🎯",
-                category: "Advanced",
-                description: "OOP, decorators, async, multiprocessing, type hints"
-            },
-            {
-                id: "sklearn",
-                title: "Python for ML (Scikit-learn)",
-                icon: "🤖",
-                category: "Machine Learning",
-                description: "Pipelines, transformers, cross-validation, hyperparameter tuning"
-            },
-            {
-                id: "pytorch",
-                title: "Deep Learning with PyTorch",
-                icon: "🔥",
-                category: "Deep Learning",
-                description: "Tensors, autograd, nn.Module, training loops, transfer learning"
-            },
-            {
-                id: "tensorflow",
-                title: "TensorFlow & Keras",
-                icon: "🧠",
-                category: "Deep Learning",
-                description: "Sequential/Functional API, callbacks, TensorBoard, deployment"
-            },
-            {
-                id: "production",
-                title: "Production Python",
-                icon: "📦",
-                category: "Engineering",
-                description: "Testing, packaging, logging, FastAPI for model serving"
-            },
-            {
-                id: "optimization",
-                title: "Performance & Optimization",
-                icon: "⚡",
-                category: "Optimization",
-                description: "Profiling, Numba, Cython, memory optimization, Dask"
-            }
-        ];
-
-        const MODULE_CONTENT = {
-            "python-fundamentals": {
-                concepts: `
-                    <div class="section">
-                        <h2>Python Data Structures for DS</h2>
-                        
-                        <table>
-                            <tr>
-                                <th>Type</th>
-                                <th>Mutable</th>
-                                <th>Ordered</th>
-                                <th>Use Case</th>
-                            </tr>
-                            <tr>
-                                <td><strong>list</strong></td>
-                                <td>✓</td>
-                                <td>✓</td>
-                                <td>Sequential data, time series</td>
-                            </tr>
-                            <tr>
-                                <td><strong>tuple</strong></td>
-                                <td>✗</td>
-                                <td>✓</td>
-                                <td>Fixed records, DataFrame rows</td>
-                            </tr>
-                            <tr>
-                                <td><strong>dict</strong></td>
-                                <td>✓</td>
-                                <td>✓ (Python 3.7+)</td>
-                                <td>Lookup tables, JSON data</td>
-                            </tr>
-                            <tr>
-                                <td><strong>set</strong></td>
-                                <td>✓</td>
-                                <td>✗</td>
-                                <td>Unique values, filtering duplicates</td>
-                            </tr>
-                        </table>
-
-                        <h3>List Comprehensions</h3>
-                        <div class="info-box">
-                            <div class="box-title">⚡ Faster Than Loops</div>
-                            <div class="box-content">
-                                List comprehensions are <strong>30-40% faster</strong> than traditional for loops for building lists.
-                            </div>
-                        </div>
-
-                        <h3>Lambda Functions</h3>
-                        <p>Anonymous functions perfect for <code>map()</code>, <code>filter()</code>, and sorting:</p>
-
-                        <h3>File I/O Best Practices</h3>
-                        <div class="callout tip">
-                            <div class="callout-title">✓ Context Managers</div>
-                            Always use <code>with open()</code> to automatically close files and handle exceptions.
-                        </div>
-
-                        <h3>Virtual Environments</h3>
-                        <table>
-                            <tr>
-                                <th>Tool</th>
-                                <th>Best For</th>
-                                <th>Command</th>
-                            </tr>
-                            <tr>
-                                <td>venv</td>
-                                <td>Simple Python projects</td>
-                                <td>python -m venv env</td>
-                            </tr>
-                            <tr>
-                                <td>conda</td>
-                                <td>DS/ML (complex dependencies)</td>
-                                <td>conda create -n myenv python=3.10</td>
-                            </tr>
-                            <tr>
-                                <td>poetry</td>
-                                <td>Modern dependency management</td>
-                                <td>poetry init</td>
-                            </tr>
-                        </table>
-                    </div>
-                `,
-                code: `
-                    <div class="section">
-                        <h2>💻 Essential Code Examples</h2>
-
-                        <h3>List Comprehensions for Data Cleaning</h3>
-                        <div class="code-block">
-<span class="comment"># Clean and transform survey responses</span>
-responses = [<span class="string">" yes "</span>, <span class="string">"NO"</span>, <span class="string">"  Yes"</span>, <span class="string">"no "</span>]
-clean = [r.strip().lower() <span class="keyword">for</span> r <span class="keyword">in</span> responses]
-<span class="comment"># ['yes', 'no', 'yes', 'no']</span>
-
-<span class="comment"># Filter outliers from dataset</span>
-data = [<span class="number">12</span>, <span class="number">45</span>, <span class="number">67</span>, <span class="number">200</span>, <span class="number">89</span>, <span class="number">34</span>]
-q75 = <span class="number">67</span>  <span class="comment"># 75th percentile</span>
-filtered = [x <span class="keyword">for</span> x <span class="keyword">in</span> data <span class="keyword">if</span> x &lt;= q75]
-                        </div>
-
-                        <h3>Dictionary Techniques</h3>
-                        <div class="code-block">
-<span class="comment"># Count occurrences (alternative to Counter)</span>
-labels = [<span class="string">'cat'</span>, <span class="string">'dog'</span>, <span class="string">'cat'</span>, <span class="string">'bird'</span>, <span class="string">'cat'</span>]
-counts = {}
-<span class="keyword">for</span> label <span class="keyword">in</span> labels:
-    counts[label] = counts.get(label, <span class="number">0</span>) + <span class="number">1</span>
-
-<span class="comment"># Dict comprehension for feature scaling</span>
-features = {<span class="string">'age'</span>: <span class="number">25</span>, <span class="string">'income'</span>: <span class="number">50000</span>, <span class="string">'score'</span>: <span class="number">85</span>}
-normalized = {k: v/<span class="number">100</span> <span class="keyword">for</span> k, v <span class="keyword">in</span> features.items()}
-                        </div>
-
-                        <h3>File I/O with Context Managers</h3>
-                        <div class="code-block">
-<span class="comment"># Reading CSV manually</span>
-<span class="keyword">with</span> <span class="function">open</span>(<span class="string">'data.csv'</span>, <span class="string">'r'</span>) <span class="keyword">as</span> f:
-    headers = f.readline().strip().split(<span class="string">','</span>)
-    rows = [line.strip().split(<span class="string">','</span>) <span class="keyword">for</span> line <span class="keyword">in</span> f]
-
-<span class="comment"># Processing large files line-by-line (memory efficient)</span>
-<span class="keyword">def</span> <span class="function">process_large_log</span>(filepath):
-    <span class="keyword">with</span> <span class="function">open</span>(filepath) <span class="keyword">as</span> f:
-        <span class="keyword">for</span> line <span class="keyword">in</span> f:  <span class="comment"># Reads one line at a time</span>
-            <span class="keyword">if</span> <span class="string">'ERROR'</span> <span class="keyword">in</span> line:
-                <span class="function">print</span>(line.strip())
-                        </div>
-
-                        <h3>Lambda + Map/Filter for Data Pipelines</h3>
-                        <div class="code-block">
-<span class="comment"># Apply multiple transformations</span>
-salaries = [<span class="number">45000</span>, <span class="number">67000</span>, <span class="number">89000</span>, <span class="number">123000</span>]
-
-<span class="comment"># Filter and transform in one pipeline</span>
-<span class="keyword">from</span> functools <span class="keyword">import</span> reduce
-
-above_60k = <span class="function">filter</span>(<span class="keyword">lambda</span> x: x &gt; <span class="number">60000</span>, salaries)
-with_bonus = <span class="function">map</span>(<span class="keyword">lambda</span> x: x * <span class="number">1.1</span>, above_60k)
-result = <span class="function">list</span>(with_bonus)
-                        </div>
-                    </div>
-                `,
-                interview: `
-                    <div class="section">
-                        <h2>🎯 Interview Questions</h2>
-
-                        <div class="interview-box">
-                            <strong>Q1: What's the difference between a list and a tuple? When would you use each in DS workflows?</strong>
-                            <p><strong>Answer:</strong> Lists are mutable (can modify), tuples are immutable. Use <strong>tuples</strong> for fixed-size records (e.g., (latitude, longitude) pairs, DataFrame rows), and <strong>lists</strong> for sequences that change (time series, dynamic feature lists).</p>
-                        </div>
-
-                        <div class="interview-box">
-                            <strong>Q2: How does Python's GIL affect data science workflows?</strong>
-                            <p><strong>Answer:</strong> The Global Interpreter Lock prevents true multi-threading for CPU-bound tasks. For DS: Use <strong>multiprocessing</strong> for parallel data processing, or libraries like NumPy/Pandas that release the GIL for computations.</p>
-                        </div>
-
-                        <div class="interview-box">
-                            <strong>Q3: Explain list comprehensions vs generator expressions. When to use each?</strong>
-                            <p><strong>Answer:</strong> List comp <code>[x**2 for x in range(n)]</code> creates the whole list in memory. Generator <code>(x**2 for x in range(n))</code> yields one value at a time. Use generators for <strong>large datasets</strong> to save memory.</p>
-                        </div>
-
-                        <div class="interview-box">
-                            <strong>Q4: How would you handle a 10GB CSV file that doesn't fit in memory?</strong>
-                            <p><strong>Answer:</strong> Read line-by-line using <code>with open()</code>, or use <code>pd.read_csv(chunksize=10000)</code> to process in batches, or use Dask for distributed computing.</p>
-                        </div>
-
-                        <div class="interview-box">
-                            <strong>Q5: What's the time complexity of dict lookup vs list search?</strong>
-                            <p><strong>Answer:</strong> Dict: O(1) average case using hash tables. List: O(n) requires linear scan. Critical for large-scale feature lookups.</p>
-                        </div>
-
-                        <div class="interview-box">
-                            <strong>Q6: Explain the difference between shallow and deep copy.</strong>
-                            <p><strong>Answer:</strong> Shallow copy (<code>list.copy()</code>) copies references. Deep copy (<code>copy.deepcopy()</code>) recursively copies all nested objects. Important when working with nested data structures in pipelines.</p>
-                        </div>
-
-                        <div class="interview-box">
-                            <strong>Q7: How does <code>*args</code> and <code>**kwargs</code> help in building flexible ML pipelines?</strong>
-                            <p><strong>Answer:</strong> They allow variable arguments. <code>*args</code> for positional (e.g., multiple datasets), <code>**kwargs</code> for named parameters (e.g., hyperparameters). Essential for wrapper functions and decorators.</p>
-                        </div>
-
-                        <div class="interview-box">
-                            <strong>Q8: What's the advantage of using <code>with open()</code> over manual file closing?</strong>
-                            <p><strong>Answer:</strong> Context managers guarantee file closure even if exceptions occur, preventing resource leaks in long-running data pipelines.</p>
-                        </div>
-
-                        <div class="interview-box">
-                            <strong>Q9: How would you remove duplicates from a list while preserving order?</strong>
-                            <p><strong>Code:</strong> <code>list(dict.fromkeys(my_list))</code> or <code>[x for i, x in enumerate(my_list) if x not in my_list[:i]]</code></p>
-                        </div>
-
-                        <div class="interview-box">
-                            <strong>Q10: Why use virtual environments in production ML systems?</strong>
-                            <p><strong>Answer:</strong> Isolate dependencies per project, avoid version conflicts (scikit-learn 0.24 vs 1.2), ensure reproducibility across dev/staging/prod, and enable easy rollbacks.</p>
-                        </div>
-                    </div>
-                `
-            },
-
-            "numpy": {
-                concepts: `
-                    <div class="section">
-                        <h2>NumPy ndarray Fundamentals</h2>
-
-                        <h3>Why NumPy?</h3>
-                        <table>
-                            <tr>
-                                <th>Feature</th>
-                                <th>Python List</th>
-                                <th>NumPy Array</th>
-                            </tr>
-                            <tr>
-                                <td>Speed</td>
-                                <td>1x</td>
-                                <td>10-100x faster</td>
-                            </tr>
-                            <tr>
-                                <td>Memory</td>
-                                <td>~28 bytes/element</td>
-                                <td>~8 bytes/element (dtype=int64)</td>
-                            </tr>
-                            <tr>
-                                <td>Vectorization</td>
-                                <td>Manual loops</td>
-                                <td>Built-in (C-optimized)</td>
-                            </tr>
-                        </table>
-
-                        <h3>Broadcasting</h3>
-                        <div class="info-box">
-                            <div class="box-title">🎯 Key Concept</div>
-                            <div class="box-content">
-                                Broadcasting allows operations on arrays of different shapes <strong>without explicit loops or copying</strong>. Rules: trailing dimensions must match or be 1.
-                            </div>
-                        </div>
-
-                        <h3>Vectorization vs Loops</h3>
-                        <div class="callout tip">
-                            <div class="callout-title">⚡ Performance</div>
-                            <code>arr * 2</code> is 50-100x faster than <code>[x * 2 for x in arr]</code> because NumPy uses SIMD instructions.
-                        </div>
-
-                        <h3>Linear Algebra Operations</h3>
-                        <p><strong>Essential for ML:</strong></p>
-                        <ul>
-                            <li><code>np.dot(A, B)</code> - Matrix multiplication (predictions)</li>
-                            <li><code>np.linalg.inv(A)</code> - Inverse (normal equation)</li>
-                            <li><code>np.linalg.eig(A)</code> - Eigenvalues (PCA)</li>
-                            <li><code>np.linalg.svd(A)</code> - SVD (recommender systems)</li>
-                        </ul>
-                    </div>
-                `,
-                code: `
-                    <div class="section">
-                        <h2>💻 NumPy in Action</h2>
-
-                        <h3>Array Creation & Indexing</h3>
-                        <div class="code-block">
-<span class="keyword">import</span> numpy <span class="keyword">as</span> np
-
-<span class="comment"># Create from list</span>
-arr = np.array([[<span class="number">1</span>, <span class="number">2</span>, <span class="number">3</span>], [<span class="number">4</span>, <span class="number">5</span>, <span class="number">6</span>]])
-
-<span class="comment"># Special arrays</span>
-zeros = np.zeros((<span class="number">3</span>, <span class="number">4</span>))
-ones = np.ones((<span class="number">2</span>, <span class="number">3</span>))
-identity = np.eye(<span class="number">5</span>)
-random = np.random.randn(<span class="number">100</span>, <span class="number">10</span>)  <span class="comment"># 100 samples, 10 features</span>
-
-<span class="comment"># Boolean indexing (filtering)</span>
-data = np.array([<span class="number">1</span>, <span class="number">5</span>, <span class="number">-3</span>, <span class="number">8</span>, <span class="number">-2</span>])
-positives = data[data &gt; <span class="number">0</span>]  <span class="comment"># [1, 5, 8]</span>
-                        </div>
-
-                        <h3>Broadcasting Example</h3>
-                        <div class="code-block">
-<span class="comment"># Normalize each feature (mean=0, std=1)</span>
-X = np.random.randn(<span class="number">1000</span>, <span class="number">5</span>)  <span class="comment"># 1000 samples, 5 features</span>
-
-mean = X.mean(axis=<span class="number">0</span>)  <span class="comment"># shape (5,)</span>
-std = X.std(axis=<span class="number">0</span>)    <span class="comment"># shape (5,)</span>
-
-X_normalized = (X - mean) / std  <span class="comment"># Broadcasting!</span>
-<span class="comment"># (1000, 5) - (5,) broadcasts to (1000, 5) - (1,5) automatically</span>
-                        </div>
-
-                        <h3>Vectorized Operations</h3>
-                        <div class="code-block">
-<span class="comment"># Inefficient (Python loop)</span>
-result = []
-<span class="keyword">for</span> x <span class="keyword">in</span> data:
-    result.append(x ** <span class="number">2</span>)
-
-<span class="comment"># Efficient (vectorized)</span>
-result = data ** <span class="number">2</span>  <span class="comment"># 100x faster</span>
-
-<span class="comment"># Apply sigmoid activation</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))
-
-predictions = sigmoid(X @ weights)  <span class="comment"># Matrix mult + vectorized sigmoid</span>
-                        </div>
-
-                        <h3>Linear Algebra for ML</h3>
-                        <div class="code-block">
-<span class="comment"># Solve linear regression (Normal Equation)</span>
-X = np.random.randn(<span class="number">100</span>, <span class="number">3</span>)  <span class="comment"># 100 samples, 3 features</span>
-y = np.random.randn(<span class="number">100</span>)
-
-<span class="comment"># θ = (X^T X)^(-1) X^T y</span>
-theta = np.linalg.inv(X.T @ X) @ X.T @ y
-
-<span class="comment"># Eigendecomposition for PCA</span>
-cov_matrix = np.cov(X.T)
-eigenvalues, eigenvectors = np.linalg.eig(cov_matrix)
-                        </div>
-
-                        <h3>Random Sampling</h3>
-                        <div class="code-block">
-<span class="comment"># Train/test split indices</span>
-n = <span class="number">1000</span>
-indices = np.random.permutation(n)
-train_idx = indices[:<span class="number">800</span>]
-test_idx = indices[<span class="number">800</span>:]
-
-<span class="comment"># Stratified sampling</span>
-classes, counts = np.unique(y, return_counts=<span class="keyword">True</span>)
-                        </div>
-                    </div>
-                `,
-                interview: `
-                    <div class="section">
-                        <h2>🎯 NumPy Interview Questions</h2>
-
-                        <div class="interview-box">
-                            <strong>Q1: Why is NumPy faster than Python lists?</strong>
-                            <p><strong>Answer:</strong> (1) Fixed-type arrays (no type checking), (2) Contiguous memory layout, (3) Vectorized operations in C, (4) SIMD instructions, (5) No Python interpreter overhead for loops.</p>
-                        </div>
-
-                        <div class="interview-box">
-                            <strong>Q2: Explain broadcasting with an example.</strong>
-                            <p><strong>Example:</strong> <code>arr.shape=(3,4)</code> + <code>vec.shape=(4,)</code> → broadcasts vec to (1,4) then (3,4). Adds vec to each row. Critical for efficient feature normalization.</p>
-                        </div>
-
-                        <div class="interview-box">
-                            <strong>Q3: What's the difference between <code>np.dot()</code> and <code>*</code>?</strong>
-                            <p><code>*</code> is element-wise multiplication. <code>np.dot()</code> is matrix multiplication (or <code>@</code> operator). For (m,n) × (n,k) → (m,k) result.</p>
-                        </div>
-
-                        <div class="interview-box">
-                            <strong>Q4: How to handle memory errors with large arrays?</strong>
-                            <p><strong>Solutions:</strong> (1) Use memory-mapped arrays <code>np.memmap</code>, (2) Process in chunks, (3) Use Dask for out-of-core computation, (4) Choose smaller dtypes (float32 vs float64).</p>
-                        </div>
-
-                        <div class="interview-box">
-                            <strong>Q5: What's the difference between <code>copy()</code> and view?</strong>
-                            <p><strong>View:</strong> <code>arr[1:3]</code> shares memory. <strong>Copy:</strong> <code>arr[1:3].copy()</code> creates new array. Views save memory but can cause bugs if modified.</p>
-                        </div>
-
-                        <div class="interview-box">
-                            <strong>Q6: How to normalize a dataset efficiently?</strong>
-                            <p><code>(X - X.mean(axis=0)) / X.std(axis=0)</code> using broadcasting. For large data, use <code>np.nanmean()</code> to handle missing values.</p>
-                        </div>
-
-                        <div class="interview-box">
-                            <strong>Q7: Explain eigendecomposition's role in PCA.</strong>
-                            <p>PCA finds principal components via <code>np.linalg.eig(cov_matrix)</code>. Eigenvectors = directions of max variance. Eigenvalues = variance magnitude. Sort by eigenvalue desc.</p>
-                        </div>
-
-                        <div class="interview-box">
-                            <strong>Q8: What's the shape of <code>np.dot(A, B)</code> if A is (5,3) and B is (3,7)?</strong>
-                            <p><strong>(5, 7)</strong>. Inner dims (3) must match. Outer dims define result.</p>
-                        </div>
-
-                        <div class="interview-box">
-                            <strong>Q9: How to create a train/test split without sklearn?</strong>
-                            <p><code>indices = np.random.permutation(len(X))</code> then slice: <code>X_train = X[indices[:800]]</code></p>
-                        </div>
-
-                        <div class="interview-box">
-                            <strong>Q10: What's the advantage of <code>axis=0</code> vs <code>axis=1</code>?</strong>
-                            <p><code>axis=0</code> = operate down rows (column-wise). <code>axis=1</code> = across columns (row-wise). For (100,5): <code>mean(axis=0)</code> → (5,) means per-feature.</p>
-                        </div>
-                    </div>
-                `
-            },
-
-            "pandas": {
-                concepts: `
-                    <div class="section">
-                        <h2>Pandas Core Concepts</h2>
-
-                        <h3>DataFrames vs Series</h3>
-                        <table>
-                            <tr>
-                                <th>Structure</th>
-                                <th>Dimensions</th>
-                                <th>Use Case</th>
-                            </tr>
-                            <tr>
-                                <td>Series</td>
-                                <td>1D (column)</td>
-                                <td>Single feature, time series</td>
-                            </tr>
-                            <tr>
-                                <td>DataFrame</td>
-                                <td>2D (table)</td>
-                                <td>Tabular data, datasets</td>
-                            </tr>
-                        </table>
-
-                        <h3>Indexing Methods</h3>
-                        <ul>
-                            <li><code>.loc[]</code> - Label-based (by row/col names)</li>
-                            <li><code>.iloc[]</code> - Position-based (by integer index)</li>
-                            <li><code>.at[]</code> - Fast scalar access (label)</li>
-                            <li><code>.iat[]</code> - Fast scalar access (position)</li>
-                        </ul>
-
-                        <h3>GroupBy-Split-Apply-Combine</h3>
-                        <div class="info-box">
-                            <div class="box-title">🔀 Powerful Pattern</div>
-                            <div class="box-content">
-                                <code>df.groupby('category').agg({'price': 'mean', 'quantity': 'sum'})</code><br>
-                                Split data by groups → Apply aggregation → Combine results
-                            </div>
-                        </div>
-
-                        <h3>Merge vs Join vs Concat</h3>
-                        <table>
-                            <tr>
-                                <th>Method</th>
-                                <th>SQL Equivalent</th>
-                                <th>Use Case</th>
-                            </tr>
-                            <tr>
-                                <td>merge()</td>
-                                <td>JOIN</td>
-                                <td>Combine DataFrames on keys</td>
-                            </tr>
-                            <tr>
-                                <td>join()</td>
-                                <td>JOIN on index</td>
-                                <td>Merge by index</td>
-                            </tr>
-                            <tr>
-                                <td>concat()</td>
-                                <td>UNION</td>
-                                <td>Stack DataFrames (rows/cols)</td>
-                            </tr>
-                        </table>
-                    </div>
-                `,
-                code: `
-                    <div class="section">
-                        <h2>💻 Pandas Data Manipulation</h2>
-
-                        <h3>Loading & Basic Exploration</h3>
-                        <div class="code-block">
-<span class="keyword">import</span> pandas <span class="keyword">as</span> pd
-
-<span class="comment"># Load data</span>
-df = pd.read_csv(<span class="string">'data.csv'</span>, parse_dates=[<span class="string">'date'</span>])
-
-<span class="comment"># Quick inspection</span>
-df.head()
-df.info()
-df.describe()
-df.isnull().sum()  <span class="comment"># Missing values</span>
-
-<span class="comment"># Select columns</span>
-df[[<span class="string">'age'</span>, <span class="string">'income'</span>]]
-df.filter(like=<span class="string">'price'</span>)  <span class="comment"># All cols with 'price'</span>
-                        </div>
-
-                        <h3>Filtering & Boolean Indexing</h3>
-                        <div class="code-block">
-<span class="comment"># Filter rows</span>
-high_income = df[df[<span class="string">'income'</span>] &gt; <span class="number">100000</span>]
-
-<span class="comment"># Multiple conditions</span>
-young_rich = df[(df[<span class="string">'age'</span>] &lt; <span class="number">30</span>) & (df[<span class="string">'income'</span>] &gt; <span class="number">80000</span>)]
-
-<span class="comment"># isin for categorical</span>
-cities = df[df[<span class="string">'city'</span>].isin([<span class="string">'NYC'</span>, <span class="string">'SF'</span>, <span class="string">'LA'</span>])]
-                        </div>
-
-                        <h3>GroupBy & Aggregation</h3>
-                        <div class="code-block">
-<span class="comment"># Average salary by department</span>
-df.groupby(<span class="string">'department'</span>)[<span class="string">'salary'</span>].mean()
-
-<span class="comment"># Multiple aggregations</span>
-df.groupby(<span class="string">'category'</span>).agg({
-    <span class="string">'price'</span>: [<span class="string">'mean'</span>, <span class="string">'min'</span>, <span class="string">'max'</span>],
-    <span class="string">'quantity'</span>: <span class="string">'sum'</span>
-})
-
-<span class="comment"># Custom aggregation</span>
-df.groupby(<span class="string">'region'</span>).apply(<span class="keyword">lambda</span> x: x[<span class="string">'sales'</span>].max() - x[<span class="string">'sales'</span>].min())
-                        </div>
-
-                        <h3>Pivot Tables</h3>
-                        <div class="code-block">
-<span class="comment"># Create pivot table (sales by product x region)</span>
-pivot = pd.pivot_table(
-    df,
-    values=<span class="string">'sales'</span>,
-    index=<span class="string">'product'</span>,
-    columns=<span class="string">'region'</span>,
-    aggfunc=<span class="string">'sum'</span>,
-    fill_value=<span class="number">0</span>
-)
-                        </div>
-
-                        <h3>Handling Missing Data</h3>
-                        <div class="code-block">
-<span class="comment"># Drop rows with any NaN</span>
-df.dropna()
-
-<span class="comment"># Fill with mean (per column)</span>
-df.fillna(df.mean())
-
-<span class="comment"># Forward fill (time series)</span>
-df.fillna(method=<span class="string">'ffill'</span>)
-
-<span class="comment"># Interpolate</span>
-df.interpolate(method=<span class="string">'linear'</span>)
-                        </div>
-
-                        <h3>Time Series Operations</h3>
-                        <div class="code-block">
-<span class="comment"># Set datetime index</span>
-df[<span class="string">'date'</span>] = pd.to_datetime(df[<span class="string">'date'</span>])
-df.set_index(<span class="string">'date'</span>, inplace=<span class="keyword">True</span>)
-
-<span class="comment"># Resample to monthly</span>
-monthly = df.resample(<span class="string">'M'</span>).sum()
-
-<span class="comment"># Rolling window (moving average)</span>
-df[<span class="string">'ma_7'</span>] = df[<span class="string">'sales'</span>].rolling(window=<span class="number">7</span>).mean()
-                        </div>
-                    </div>
-                `,
-                interview: `
-                    <div class="section">
-                        <h2>🎯 Pandas Interview Questions</h2>
-
-                        <div class="interview-box">
-                            <strong>Q1: What's the difference between <code>.loc</code> and <code>.iloc</code>?</strong>
-                            <p><code>.loc</code> uses labels (row/col names). <code>.iloc</code> uses integer positions (0-indexed). Example: <code>df.loc['row1', 'col_name']</code> vs <code>df.iloc[0, 2]</code></p>
-                        </div>
-
-                        <div class="interview-box">
-                            <strong>Q2: How to handle a dataset with 30% missing values?</strong>
-                            <p><strong>Options:</strong> (1) Drop if random missing, (2) Impute with mean/median/mode, (3) Use model-based imputation (KNN, iterative), (4) Forward-fill for time series, (5) Create "missing" indicator feature.</p>
-                        </div>
-
-                        <div class="interview-box">
-                            <strong>Q3: Explain <code>apply()</code> vs <code>transform()</code> vs <code>agg()</code>.</strong>
-                            <p><code>apply()</code>: Any function, can change shape. <code>transform()</code>: Returns same shape (broadcasting). <code>agg()</code>: Multiple aggregations simultaneously.</p>
-                        </div>
-
-                        <div class="interview-box">
-                            <strong>Q4: How to merge two DataFrames with different join types?</strong>
-                            <p><code>pd.merge(df1, df2, on='key', how='inner|left|right|outer')</code>. Inner = intersection, Outer = union, Left/Right = preserve one side.</p>
-                        </div>
-
-                        <div class="interview-box">
-                            <strong>Q5: What's the performance difference between <code>iterrows()</code> and vectorization?</strong>
-                            <p><code>iterrows()</code> is 100-500x slower. Always vectorize: <code>df['new_col'] = df['a'] + df['b']</code> instead of looping.</p>
-                        </div>
-
-                        <div class="interview-box">
-                            <strong>Q6: How to create a pivot table from transaction data?</strong>
-                            <p><code>pd.pivot_table(df, values='amount', index='product', columns='month', aggfunc='sum')</code></p>
-                        </div>
-
-                        <div class="interview-box">
-                            <strong>Q7: Explain GroupBy split-apply-combine.</strong>
-                            <p>Split data into groups by key → Apply function to each group → Combine results into new DataFrame. Example: <code>df.groupby('category')['price'].mean()</code></p>
-                        </div>
-
-                        <div class="interview-box">
-                            <strong>Q8: How to detect outliers using Pandas?</strong>
-                            <p>IQR method: <code>Q1 = df['col'].quantile(0.25)</code>, <code>Q3 = df['col'].quantile(0.75)</code>, <code>IQR = Q3 - Q1</code>, outliers if <code>< Q1 - 1.5*IQR</code> or <code>> Q3 + 1.5*IQR</code></p>
-                        </div>
-
-                        <div class="interview-box">
-                            <strong>Q9: What's the advantage of <code>reset_index()</code>?</strong>
-                            <p>Converts index back to regular column. Useful after groupby or when index becomes multi-level. Use <code>drop=True</code> to discard old index.</p>
-                        </div>
-
-                        <div class="interview-box">
-                            <strong>Q10: How to optimize memory usage for large DataFrames?</strong>
-                            <p>(1) Use categorical dtype for repeated strings, (2) Downcast numerics (int64 → int32), (3) Read in chunks, (4) Use <code>usecols</code> to load only needed columns.</p>
-                        </div>
-                    </div>
-                `
-            },
-
-            "visualization": {
-                concepts: `
-                    <div class="section">
-                        <h2>Data Visualization Principles</h2>
-
-                        <h3>Choosing the Right Chart</h3>
-                        <table>
-                            <tr>
-                                <th>Goal</th>
-                                <th>Chart Type</th>
-                                <th>Library</th>
-                            </tr>
-                            <tr>
-                                <td>Distribution</td>
-                                <td>Histogram, KDE, Box plot</td>
-                                <td>Seaborn</td>
-                            </tr>
-                            <tr>
-                                <td>Relationship</td>
-                                <td>Scatter, Reg plot</td>
-                                <td>Matplotlib/Seaborn</td>
-                            </tr>
-                            <tr>
-                                <td>Time Series</td>
-                                <td>Line plot</td>
-                                <td>Matplotlib</td>
-                            </tr>
-                            <tr>
-                                <td>Categorical</td>
-                                <td>Bar, Count plot</td>
-                                <td>Seaborn</td>
-                            </tr>
-                            <tr>
-                                <td>Interactive</td>
-                                <td>Scatter, Line, 3D</td>
-                                <td>Plotly</td>
-                            </tr>
-                        </table>
-
-                        <h3>Matplotlib Architecture</h3>
-                        <div class="info-box">
-                            <div class="box-title">📊 Fig & Axes</div>
-                            <div class="box-content">
-                                <strong>Figure:</strong> Entire canvas<br>
-                                <strong>Axes:</strong> Individual plot (can have multiple in one figure)<br>
-                                <code>fig, ax = plt.subplots(2, 2)</code> creates 2x2 grid
-                            </div>
-                        </div>
-
-                        <h3>Seaborn Advantages</h3>
-                        <ul>
-                            <li>Built on Matplotlib (high-level API)</li>
-                            <li>Beautiful default styles</li>
-                            <li>Statistical plots (regplot, violinplot)</li>
-                            <li>Works seamlessly with Pandas DataFrames</li>
-                        </ul>
-
-                        <h3>Plotly for Interactivity</h3>
-                        <p>Hover tooltips, zoom, pan, export to HTML. Perfect for dashboards and presentations.</p>
-                    </div>
-                `,
-                code: `
-                    <div class="section">
-                        <h2>💻 Plotting Code Examples</h2>
-
-                        <h3>Matplotlib Basics</h3>
-                        <div class="code-block">
-<span class="keyword">import</span> matplotlib.pyplot <span class="keyword">as</span> plt
-
-<span class="comment"># Simple line plot</span>
-plt.plot(x, y, label=<span class="string">'Actual'</span>, color=<span class="string">'blue'</span>, linewidth=<span class="number">2</span>)
-plt.xlabel(<span class="string">'Time'</span>)
-plt.ylabel(<span class="string">'Value'</span>)
-plt.title(<span class="string">'Time Series'</span>)
-plt.legend()
-plt.grid(<span class="keyword">True</span>, alpha=<span class="number">0.3</span>)
-plt.show()
-
-<span class="comment"># Subplots (2x2 grid)</span>
-fig, axes = plt.subplots(<span class="number">2</span>, <span class="number">2</span>, figsize=(<span class="number">12</span>, <span class="number">10</span>))
-axes[<span class="number">0</span>, <span class="number">0</span>].plot(data1)
-axes[<span class="number">0</span>, <span class="number">1</span>].scatter(x, y)
-axes[<span class="number">1</span>, <span class="number">0</span>].hist(values, bins=<span class="number">30</span>)
-                        </div>
-
-                        <h3>Seaborn Statistical Plots</h3>
-                        <div class="code-block">
-<span class="keyword">import</span> seaborn <span class="keyword">as</span> sns
-
-<span class="comment"># Distribution plot</span>
-sns.histplot(df[<span class="string">'price'</span>], kde=<span class="keyword">True</span>, bins=<span class="number">50</span>)
-
-<span class="comment"># Relationship with regression</span>
-sns.regplot(x=<span class="string">'area'</span>, y=<span class="string">'price'</span>, data=df)
-
-<span class="comment"># Categorical count</span>
-sns.countplot(x=<span class="string">'category'</span>, data=df, palette=<span class="string">'viridis'</span>)
-
-<span class="comment"># Correlation heatmap</span>
-corr = df.corr()
-sns.heatmap(corr, annot=<span class="keyword">True</span>, cmap=<span class="string">'coolwarm'</span>, center=<span class="number">0</span>)
-
-<span class="comment"># Pairplot (all features)</span>
-sns.pairplot(df, hue=<span class="string">'species'</span>)
-                        </div>
-
-                        <h3>Plotly Interactive Plots</h3>
-                        <div class="code-block">
-<span class="keyword">import</span> plotly.express <span class="keyword">as</span> px
-
-<span class="comment"># Interactive scatter</span>
-fig = px.scatter(
-    df, x=<span class="string">'gdp'</span>, y=<span class="string">'life_exp'</span>, 
-    size=<span class="string">'pop'</span>, color=<span class="string">'continent'</span>,
-    hover_name=<span class="string">'country'</span>, 
-    title=<span class="string">'GDP vs Life Expectancy'</span>
-)
-fig.show()
-
-<span class="comment"># 3D scatter</span>
-fig = px.scatter_3d(df, x=<span class="string">'x'</span>, y=<span class="string">'y'</span>, z=<span class="string">'z'</span>, color=<span class="string">'cluster'</span>)
-                        </div>
-
-                        <h3>Customization</h3>
-                        <div class="code-block">
-<span class="comment"># Set Seaborn style</span>
-sns.set_style(<span class="string">'whitegrid'</span>)
-sns.set_palette(<span class="string">'husl'</span>)
-
-<span class="comment"># Matplotlib rc params</span>
-plt.rcParams[<span class="string">'figure.figsize'</span>] = (<span class="number">12</span>, <span class="number">6</span>)
-plt.rcParams[<span class="string">'font.size'</span>] = <span class="number">12</span>
-                        </div>
-                    </div>
-                `,
-                interview: `
-                    <div class="section">
-                        <h2>🎯 Visualization Interview Questions</h2>
-
-                        <div class="interview-box">
-                            <strong>Q1: When to use histogram vs KDE plot?</strong>
-                            <p><strong>Histogram:</strong> Raw counts in bins. <strong>KDE:</strong> Smooth probability density estimate. Use KDE for continuous distributions, histogram for discrete/count data.</p>
-                        </div>
-
-                        <div class="interview-box">
-                            <strong>Q2: Explain Figure vs Axes in Matplotlib.</strong>
-                            <p><strong>Figure:</strong> Container (canvas). <strong>Axes:</strong> Individual plot. One figure can have multiple axes (subplots). <code>fig, ax = plt.subplots()</code></p>
-                        </div>
-
-                        <div class="interview-box">
-                            <strong>Q3: How to visualize correlation between features?</strong>
-                            <p><strong>Heatmap:</strong> <code>sns.heatmap(df.corr(), annot=True)</code>. <strong>Pairplot:</strong> <code>sns.pairplot(df)</code> shows all pairwise relationships.</p>
-                        </div>
-
-                        <div class="interview-box">
-                            <strong>Q4: What's the advantage of Plotly over Matplotlib?</strong>
-                            <p><strong>Plotly:</strong> Interactive (zoom, pan, hover tooltips), exports to HTML, better for dashboards. <strong>Matplotlib:</strong> More control, publication-ready static plots.</p>
-                        </div>
-
-                        <div class="interview-box">
-                            <strong>Q5: How to create a subplot grid (2 rows, 3 cols)?</strong>
-                            <p><code>fig, axes = plt.subplots(2, 3, figsize=(15, 8))</code>. Access: <code>axes[row, col].plot(data)</code></p>
-                        </div>
-
-                        <div class="interview-box">
-                            <strong>Q6: Which plot to show feature importance?</strong>
-                            <p><strong>Horizontal bar chart:</strong> <code>plt.barh(features, importances)</code> sorted by importance. Clear for comparing many features.</p>
-                        </div>
-
-                        <div class="interview-box">
-                            <strong>Q7: How to customize Seaborn style?</strong>
-                            <p><code>sns.set_style('whitegrid')</code>, <code>sns.set_palette('husl')</code>, <code>sns.set_context('talk')</code> for presentations</p>
-                        </div>
-
-                        <div class="interview-box">
-                            <strong>Q8: What's the best way to visualize model predictions vs actual?</strong>
-                            <p>Scatter plot: <code>plt.scatter(y_true, y_pred)</code> with diagonal line <code>plt.plot([min, max], [min, max], 'r--')</code>. Points close to line = good predictions.</p>
-                        </div>
-
-                        <div class="interview-box">
-                            <strong>Q9: How to save a plot in high resolution?</strong>
-                            <p><code>plt.savefig('plot.png', dpi=300, bbox_inches='tight')</code>. Use dpi=300 for publications.</p>
-                        </div>
-
-                        <div class="interview-box">
-                            <strong>Q10: Which plot for time series with confidence intervals?</strong>
-                            <p><code>plt.plot(dates, mean)</code> + <code>plt.fill_between(dates, lower, upper, alpha=0.3)</code> for shaded confidence bands.</p>
-                        </div>
-                    </div>
-                `
-            },
-
-            "advanced-python": {
-                concepts: `
-                    <div class="section">
-                        <h2>Object-Oriented Programming (OOP)</h2>
-
-                        <h3>Classes for ML Models</h3>
-                        <div class="info-box">
-                            <div class="box-title">🏗️ Encapsulation</div>
-                            <div class="box-content">
-                                Group related data (features, weights) and methods (fit, predict) into reusable class structures. Scikit-learn uses OOP for all estimators.
-                            </div>
-                        </div>
-
-                        <h3>Key OOP Concepts</h3>
-                        <table>
-                            <tr>
-                                <th>Concept</th>
-                                <th>Purpose</th>
-                                <th>Example</th>
-                            </tr>
-                            <tr>
-                                <td>Inheritance</td>
-                                <td>Reuse code</td>
-                                <td>LinearModel → Ridge, Lasso</td>
-                            </tr>
-                            <tr>
-                                <td>Polymorphism</td>
-                                <td>Same interface, different implementation</td>
-                                <td>fit() for all models</td>
-                            </tr>
-                            <tr>
-                                <td>Encapsulation</td>
-                                <td>Hide internal state</td>
-                                <td>Private attributes _weights</td>
-                            </tr>
-                        </table>
-
-                        <h3>Magic Methods</h3>
-                        <ul>
-                            <li><code>__init__</code> - Constructor</li>
-                            <li><code>__repr__</code> - String representation</li>
-                            <li><code>__call__</code> - Make instance callable</li>
-                            <li><code>__len__</code> - len() support</li>
-                            <li><code>__getitem__</code> - Indexing support</li>
-                        </ul>
-
-                        <h2>Async & Concurrency</h2>
-
-                        <h3>Threading vs Multiprocessing vs Async</h3>
-                        <table>
-                            <tr>
-                                <th>Method</th>
-                                <th>Best For</th>
-                                <th>Limitation</th>
-                            </tr>
-                            <tr>
-                                <td>Threading</td>
-                                <td>I/O-bound (API calls, file reads)</td>
-                                <td>GIL blocks CPU parallelism</td>
-                            </tr>
-                            <tr>
-                                <td>Multiprocessing</td>
-                                <td>CPU-bound (model training)</td>
-                                <td>Memory overhead (process copy)</td>
-                            </tr>
-                            <tr>
-                                <td>Asyncio</td>
-                                <td>Many concurrent I/O tasks</td>
-                                <td>Single-threaded</td>
-                            </tr>
-                        </table>
-
-                        <div class="callout warning">
-                            <div class="callout-title">⚠️ GIL Impact</div>
-                            Python's Global Interpreter Lock means threading won't speed up CPU-heavy tasks like model training. Use multiprocessing instead.
-                        </div>
-
-                        <h3>Decorators</h3>
-                        <p>Modify function behavior without changing code. Common uses:</p>
-                        <ul>
-                            <li><strong>@lru_cache</strong> - Memoization for expensive functions</li>
-                            <li><strong>@property</strong> - Getter/setter methods</li>
-                            <li><strong>@staticmethod</strong> - No self parameter</li>
-                            <li><strong>@timing</strong> - Performance monitoring</li>
-                        </ul>
-
-                        <h3>Context Managers</h3>
-                        <p>Manage resources (files, locks, DB connections) with <code>with</code> statement. Guarantees cleanup even if exceptions occur.</p>
-                    </div>
-                `,
-                code: `
-                    <div class="section">
-                        <h2>💻 Advanced Python Examples</h2>
-
-                        <h3>OOP: Custom ML Model Class</h3>
-                        <div class="code-block">
-<span class="keyword">class</span> <span class="class">SimpleLinearRegression</span>:
-    <span class="keyword">def</span> <span class="function">__init__</span>(<span class="keyword">self</span>, learning_rate=<span class="number">0.01</span>):
-        <span class="keyword">self</span>.lr = learning_rate
-        <span class="keyword">self</span>._weights = <span class="keyword">None</span>
-        <span class="keyword">self</span>._bias = <span class="keyword">None</span>
-    
-    <span class="keyword">def</span> <span class="function">fit</span>(<span class="keyword">self</span>, X, y, epochs=<span class="number">100</span>):
-        n_samples, n_features = X.shape
-        <span class="keyword">self</span>._weights = np.zeros(n_features)
-        <span class="keyword">self</span>._bias = <span class="number">0</span>
-        
-        <span class="keyword">for</span> _ <span class="keyword">in</span> <span class="function">range</span>(epochs):
-            y_pred = <span class="keyword">self</span>.predict(X)
-            dw = (<span class="number">1</span>/n_samples) * X.T @ (y_pred - y)
-            db = (<span class="number">1</span>/n_samples) * np.<span class="function">sum</span>(y_pred - y)
-            
-            <span class="keyword">self</span>._weights -= <span class="keyword">self</span>.lr * dw
-            <span class="keyword">self</span>._bias -= <span class="keyword">self</span>.lr * db
-    
-    <span class="keyword">def</span> <span class="function">predict</span>(<span class="keyword">self</span>, X):
-        <span class="keyword">return</span> X @ <span class="keyword">self</span>._weights + <span class="keyword">self</span>._bias
-    
-    <span class="keyword">def</span> <span class="function">__repr__</span>(<span class="keyword">self</span>):
-        <span class="keyword">return</span> <span class="string">f"SimpleLinearRegression(lr={self.lr})"</span>
-
-<span class="comment"># Usage</span>
-model = SimpleLinearRegression(learning_rate=<span class="number">0.001</span>)
-model.fit(X_train, y_train)
-predictions = model.predict(X_test)
-                        </div>
-
-                        <h3>Inheritance Example</h3>
-                        <div class="code-block">
-<span class="keyword">class</span> <span class="class">BaseModel</span>:
-    <span class="keyword">def</span> <span class="function">__init__</span>(<span class="keyword">self</span>):
-        <span class="keyword">self</span>.is_fitted = <span class="keyword">False</span>
-    
-    <span class="keyword">def</span> <span class="function">check_fitted</span>(<span class="keyword">self</span>):
-        <span class="keyword">if</span> <span class="keyword">not</span> <span class="keyword">self</span>.is_fitted:
-            <span class="keyword">raise</span> <span class="function">ValueError</span>(<span class="string">"Model not fitted yet!"</span>)
-
-<span class="keyword">class</span> <span class="class">LogisticModel</span>(BaseModel):
-    <span class="keyword">def</span> <span class="function">fit</span>(<span class="keyword">self</span>, X, y):
-        <span class="comment"># Training logic</span>
-        <span class="keyword">self</span>.is_fitted = <span class="keyword">True</span>
-    
-    <span class="keyword">def</span> <span class="function">predict</span>(<span class="keyword">self</span>, X):
-        <span class="keyword">self</span>.check_fitted()  <span class="comment"># Inherited method</span>
-        <span class="keyword">return</span> predictions
-                        </div>
-
-                        <h3>Decorators</h3>
-                        <div class="code-block">
-<span class="keyword">from</span> functools <span class="keyword">import</span> lru_cache
-<span class="keyword">import</span> time
-
-<span class="comment"># Timing decorator</span>
-<span class="keyword">def</span> <span class="function">timing_decorator</span>(func):
-    <span class="keyword">def</span> <span class="function">wrapper</span>(*args, **kwargs):
-        start = time.time()
-        result = func(*args, **kwargs)
-        end = time.time()
-        <span class="function">print</span>(<span class="string">f"{func.__name__} took {end-start:.4f}s"</span>)
-        <span class="keyword">return</span> result
-    <span class="keyword">return</span> wrapper
-
-<span class="comment"># Memoization for expensive computations</span>
-<span class="function">@lru_cache</span>(maxsize=<span class="number">128</span>)
-<span class="keyword">def</span> <span class="function">fibonacci</span>(n):
-    <span class="keyword">if</span> n &lt; <span class="number">2</span>:
-        <span class="keyword">return</span> n
-    <span class="keyword">return</span> fibonacci(n<span class="number">-1</span>) + fibonacci(n<span class="number">-2</span>)
-
-<span class="function">@timing_decorator</span>
-<span class="keyword">def</span> <span class="function">train_model</span>(X, y):
-    <span class="comment"># Training code</span>
-    <span class="keyword">pass</span>
-                        </div>
-
-                        <h3>Generators for Memory Efficiency</h3>
-                        <div class="code-block">
-<span class="comment"># Generator for batch processing</span>
-<span class="keyword">def</span> <span class="function">batch_generator</span>(X, y, batch_size=<span class="number">32</span>):
-    n_samples = <span class="function">len</span>(X)
-    <span class="keyword">for</span> i <span class="keyword">in</span> <span class="function">range</span>(<span class="number">0</span>, n_samples, batch_size):
-        <span class="keyword">yield</span> X[i:i+batch_size], y[i:i+batch_size]
-
-<span class="comment"># Use in training loop</span>
-<span class="keyword">for</span> X_batch, y_batch <span class="keyword">in</span> batch_generator(X_train, y_train):
-    <span class="comment"># Train on batch</span>
-    <span class="keyword">pass</span>
-                        </div>
-
-                        <h3>Multiprocessing for Parallel Training</h3>
-                        <div class="code-block">
-<span class="keyword">from</span> multiprocessing <span class="keyword">import</span> Pool
-
-<span class="keyword">def</span> <span class="function">train_fold</span>(args):
-    X_train, y_train, X_val, y_val = args
-    model.fit(X_train, y_train)
-    <span class="keyword">return</span> model.score(X_val, y_val)
-
-<span class="comment"># Parallel cross-validation</span>
-<span class="keyword">with</span> Pool(<span class="number">4</span>) <span class="keyword">as</span> pool:
-    scores = pool.<span class="function">map</span>(train_fold, fold_data)
-                        </div>
-
-                        <h3>Asyncio for Concurrent API Calls</h3>
-                        <div class="code-block">
-<span class="keyword">import</span> asyncio
-<span class="keyword">import</span> aiohttp
-
-<span class="keyword">async</span> <span class="keyword">def</span> <span class="function">fetch_data</span>(session, url):
-    <span class="keyword">async</span> <span class="keyword">with</span> session.get(url) <span class="keyword">as</span> response:
-        <span class="keyword">return</span> <span class="keyword">await</span> response.json()
-
-<span class="keyword">async</span> <span class="keyword">def</span> <span class="function">main</span>():
-    urls = [<span class="string">f"https://api.example.com/data/{i}"</span> <span class="keyword">for</span> i <span class="keyword">in</span> <span class="function">range</span>(<span class="number">100</span>)]
-    
-    <span class="keyword">async</span> <span class="keyword">with</span> aiohttp.ClientSession() <span class="keyword">as</span> session:
-        tasks = [fetch_data(session, url) <span class="keyword">for</span> url <span class="keyword">in</span> urls]
-        results = <span class="keyword">await</span> asyncio.gather(*tasks)
-    
-    <span class="keyword">return</span> results
-
-<span class="comment"># Run</span>
-data = asyncio.run(main())
-                        </div>
-
-                        <h3>Context Manager for Model Serving</h3>
-                        <div class="code-block">
-<span class="keyword">class</span> <span class="class">ModelLoader</span>:
-    <span class="keyword">def</span> <span class="function">__init__</span>(<span class="keyword">self</span>, model_path):
-        <span class="keyword">self</span>.model_path = model_path
-        <span class="keyword">self</span>.model = <span class="keyword">None</span>
-    
-    <span class="keyword">def</span> <span class="function">__enter__</span>(<span class="keyword">self</span>):
-        <span class="keyword">self</span>.model = load_model(<span class="keyword">self</span>.model_path)
-        <span class="function">print</span>(<span class="string">"Model loaded"</span>)
-        <span class="keyword">return</span> <span class="keyword">self</span>.model
-    
-    <span class="keyword">def</span> <span class="function">__exit__</span>(<span class="keyword">self</span>, exc_type, exc_val, exc_tb):
-        <span class="keyword">del</span> <span class="keyword">self</span>.model
-        <span class="function">print</span>(<span class="string">"Model unloaded"</span>)
-
-<span class="comment"># Usage</span>
-<span class="keyword">with</span> ModelLoader(<span class="string">'model.pkl'</span>) <span class="keyword">as</span> model:
-    predictions = model.predict(X_test)
-                        </div>
-                    </div>
-                `,
-                interview: `
-                    <div class="section">
-                        <h2>🎯 Advanced Python Interview Questions</h2>
-
-                        <div class="interview-box">
-                            <strong>Q1: Explain the difference between <code>__init__</code> and <code>__new__</code>.</strong>
-                            <p><code>__new__</code> creates the instance (returns object), <code>__init__</code> initializes it (returns None). Use <code>__new__</code> for singletons or immutable types.</p>
-                        </div>
-
-                        <div class="interview-box">
-                            <strong>Q2: When to use multiprocessing vs threading in ML?</strong>
-                            <p><strong>Multiprocessing:</strong> CPU-bound (model training, hyperparameter tuning). <strong>Threading:</strong> I/O-bound (loading data, API calls). GIL blocks threading for CPU tasks.</p>
-                        </div>
-
-                        <div class="interview-box">
-                            <strong>Q3: What's a decorator and why use it?</strong>
-                            <p>Function that wraps another function to modify behavior. Uses: timing, logging, caching (<code>@lru_cache</code>), authentication. Example: <code>@timing_decorator</code> to measure execution time.</p>
-                        </div>
-
-                        <div class="interview-box">
-                            <strong>Q4: How do generators save memory?</strong>
-                            <p>Yield values one at a time instead of storing the entire list. Critical for large datasets: <code>(x**2 for x in range(10**9))</code> vs <code>[x**2 for x in range(10**9)]</code>.</p>
-                        </div>
-
-                        <div class="interview-box">
-                            <strong>Q5: Explain inheritance vs composition.</strong>
-                            <p><strong>Inheritance:</strong> "is-a" (Ridge is-a LinearModel). <strong>Composition:</strong> "has-a" (Pipeline has-a scaler). Prefer composition for flexibility.</p>
-                        </div>
-
-                        <div class="interview-box">
-                            <strong>Q6: What's the purpose of <code>super()</code>?</strong>
-                            <p>Call parent class methods. Example: <code>super().__init__()</code> in child <code>__init__</code>. Ensures proper initialization in inheritance chains.</p>
-                        </div>
-
-                        <div class="interview-box">
-                            <strong>Q7: How does asyncio differ from threading?</strong>
-                            <p><strong>Asyncio:</strong> Cooperative multitasking (async/await), single-threaded. <strong>Threading:</strong> Preemptive, multiple threads. Asyncio better for thousands of concurrent I/O tasks.</p>
-                        </div>
-
-                        <div class="interview-box">
-                            <strong>Q8: What are magic methods? Give 3 examples.</strong>
-                            <p><code>__len__</code> (len()), <code>__getitem__</code> (indexing), <code>__call__</code> (make callable). Example: <code>dataset[0]</code> calls <code>__getitem__</code>.</p>
-                        </div>
-
-                        <div class="interview-box">
-                            <strong>Q9: Why use context managers for file I/O?</strong>
-                            <p>Guarantee resource cleanup (file close) even if exceptions occur. <code>with open()</code> is safer than manual <code>file.close()</code>.</p>
-                        </div>
-
-                        <div class="interview-box">
-                            <strong>Q10: How to make a class iterable?</strong>
-                            <p>Implement <code>__iter__</code> and <code>__next__</code>. Or use <code>yield</code> in <code>__iter__</code>. Example: Custom dataset class for batch iteration.</p>
-                        </div>
-                    </div>
-                `
-            },
-
-            "sklearn": {
-                concepts: `
-                    <div class="section">
-                        <h2>Scikit-learn Architecture</h2>
-
-                        <h3>Estimators, Transformers, Predictors</h3>
-                        <table>
-                            <tr>
-                                <th>Type</th>
-                                <th>Methods</th>
-                                <th>Example</th>
-                            </tr>
-                            <tr>
-                                <td>Estimator</td>
-                                <td>fit()</td>
-                                <td>All models</td>
-                            </tr>
-                            <tr>
-                                <td>Transformer</td>
-                                <td>fit(), transform()</td>
-                                <td>StandardScaler, PCA</td>
-                            </tr>
-                            <tr>
-                                <td>Predictor</td>
-                                <td>fit(), predict()</td>
-                                <td>Classifiers, Regressors</td>
-                            </tr>
-                        </table>
-
-                        <h3>Pipelines</h3>
-                        <div class="info-box">
-                            <div class="box-title">🔗 Chain Transformations</div>
-                            <div class="box-content">
-                                Pipelines chain preprocessing + model into single object. Prevents data leakage by fitting transforms only on training data.
-                            </div>
-                        </div>
-
-                        <h3>Cross-Validation Strategies</h3>
-                        <ul>
-                            <li><strong>KFold</strong> - Standard k-fold (e.g., 5-fold)</li>
-                            <li><strong>StratifiedKFold</strong> - Preserves class distribution</li>
-                            <li><strong>TimeSeriesSplit</strong> - For temporal data</li>
-                            <li><strong>GroupKFold</strong> - Groups stay together</li>
-                        </ul>
-
-                        <h3>Hyperparameter Tuning</h3>
-                        <table>
-                            <tr>
-                                <th>Method</th>
-                                <th>Strategy</th>
-                                <th>When to Use</th>
-                            </tr>
-                            <tr>
-                                <td>GridSearchCV</td>
-                                <td>Exhaustive search</td>
-                                <td>Small param space</td>
-                            </tr>
-                            <tr>
-                                <td>RandomizedSearchCV</td>
-                                <td>Random sampling</td>
-                                <td>Large param space</td>
-                            </tr>
-                            <tr>
-                                <td>HalvingGridSearchCV</td>
-                                <td>Successive halving</td>
-                                <td>Fast elimination of bad params</td>
-                            </tr>
-                        </table>
-                    </div>
-                `,
-                code: `
-                    <div class="section">
-                        <h2>💻 Scikit-learn in Production</h2>
-
-                        <h3>Building a Pipeline</h3>
-                        <div class="code-block">
-<span class="keyword">from</span> sklearn.pipeline <span class="keyword">import</span> Pipeline
-<span class="keyword">from</span> sklearn.preprocessing <span class="keyword">import</span> StandardScaler
-<span class="keyword">from</span> sklearn.decomposition <span class="keyword">import</span> PCA
-<span class="keyword">from</span> sklearn.linear_model <span class="keyword">import</span> LogisticRegression
-
-<span class="comment"># Create pipeline</span>
-pipeline = Pipeline([
-    (<span class="string">'scaler'</span>, StandardScaler()),
-    (<span class="string">'pca'</span>, PCA(n_components=<span class="number">10</span>)),
-    (<span class="string">'classifier'</span>, LogisticRegression())
-])
-
-<span class="comment"># Fit entire pipeline</span>
-pipeline.fit(X_train, y_train)
-
-<span class="comment"># Predict (auto-applies all transforms)</span>
-predictions = pipeline.predict(X_test)
-                        </div>
-
-                        <h3>Custom Transformer</h3>
-                        <div class="code-block">
-<span class="keyword">from</span> sklearn.base <span class="keyword">import</span> BaseEstimator, TransformerMixin
-
-<span class="keyword">class</span> <span class="class">OutlierRemover</span>(BaseEstimator, TransformerMixin):
-    <span class="keyword">def</span> <span class="function">__init__</span>(<span class="keyword">self</span>, factor=<span class="number">1.5</span>):
-        <span class="keyword">self</span>.factor = factor
-    
-    <span class="keyword">def</span> <span class="function">fit</span>(<span class="keyword">self</span>, X, y=<span class="keyword">None</span>):
-        <span class="keyword">self</span>.q1 = np.percentile(X, <span class="number">25</span>, axis=<span class="number">0</span>)
-        <span class="keyword">self</span>.q3 = np.percentile(X, <span class="number">75</span>, axis=<span class="number">0</span>)
-        <span class="keyword">self</span>.iqr = <span class="keyword">self</span>.q3 - <span class="keyword">self</span>.q1
-        <span class="keyword">return</span> <span class="keyword">self</span>
-    
-    <span class="keyword">def</span> <span class="function">transform</span>(<span class="keyword">self</span>, X):
-        lower = <span class="keyword">self</span>.q1 - <span class="keyword">self</span>.factor * <span class="keyword">self</span>.iqr
-        upper = <span class="keyword">self</span>.q3 + <span class="keyword">self</span>.factor * <span class="keyword">self</span>.iqr
-        mask = np.all((X &gt;= lower) & (X &lt;= upper), axis=<span class="number">1</span>)
-        <span class="keyword">return</span> X[mask]
-                        </div>
-
-                        <h3>GridSearchCV</h3>
-                        <div class="code-block">
-<span class="keyword">from</span> sklearn.model_selection <span class="keyword">import</span> GridSearchCV
-
-<span class="comment"># Define param grid</span>
-param_grid = {
-    <span class="string">'pca__n_components'</span>: [<span class="number">5</span>, <span class="number">10</span>, <span class="number">20</span>],
-    <span class="string">'classifier__C'</span>: [<span class="number">0.1</span>, <span class="number">1</span>, <span class="number">10</span>],
-    <span class="string">'classifier__penalty'</span>: [<span class="string">'l1'</span>, <span class="string">'l2'</span>]
-}
-
-<span class="comment"># Grid search</span>
-grid = GridSearchCV(
-    pipeline,
-    param_grid,
-    cv=<span class="number">5</span>,
-    scoring=<span class="string">'accuracy'</span>,
-    n_jobs=<span class="number">-1</span>
-)
-
-grid.fit(X_train, y_train)
-<span class="function">print</span>(<span class="string">f"Best params: {grid.best_params_}"</span>)
-<span class="function">print</span>(<span class="string">f"Best score: {grid.best_score_:.3f}"</span>)
-                        </div>
-
-                        <h3>Cross-Validation</h3>
-                        <div class="code-block">
-<span class="keyword">from</span> sklearn.model_selection <span class="keyword">import</span> cross_val_score, StratifiedKFold
-
-<span class="comment"># Stratified k-fold for imbalanced data</span>
-cv = StratifiedKFold(n_splits=<span class="number">5</span>, shuffle=<span class="keyword">True</span>, random_state=<span class="number">42</span>)
-
-<span class="comment"># Cross-validate</span>
-scores = cross_val_score(
-    pipeline,
-    X_train,
-    y_train,
-    cv=cv,
-    scoring=<span class="string">'f1_weighted'</span>
-)
-
-<span class="function">print</span>(<span class="string">f"CV Scores: {scores}"</span>)
-<span class="function">print</span>(<span class="string">f"Mean: {scores.mean():.3f} ± {scores.std():.3f}"</span>)
-                        </div>
-
-                        <h3>Feature Selection</h3>
-                        <div class="code-block">
-<span class="keyword">from</span> sklearn.feature_selection <span class="keyword">import</span> SelectKBest, f_classif, RFE
-<span class="keyword">from</span> sklearn.ensemble <span class="keyword">import</span> RandomForestClassifier
-
-<span class="comment"># Univariate selection</span>
-selector = SelectKBest(f_classif, k=<span class="number">10</span>)
-X_selected = selector.fit_transform(X_train, y_train)
-
-<span class="comment"># Recursive Feature Elimination</span>
-rfe = RFE(RandomForestClassifier(), n_features_to_select=<span class="number">10</span>)
-rfe.fit(X_train, y_train)
-selected_features = X_train.columns[rfe.support_]
-                        </div>
-                    </div>
-                `,
-                interview: `
-                    <div class="section">
-                        <h2>🎯 Scikit-learn Interview Questions</h2>
-
-                        <div class="interview-box">
-                            <strong>Q1: What's the difference between <code>fit_transform()</code> and <code>fit()</code> then <code>transform()</code>?</strong>
-                            <p>Functionally identical, but <code>fit_transform()</code> is often optimized (e.g., PCA computes components + projects in one pass). Always use <code>fit_transform()</code> on training data.</p>
-                        </div>
-
-                        <div class="interview-box">
-                            <strong>Q2: Why use pipelines in production?</strong>
-                            <p>(1) Prevent data leakage (scaler only fits on train), (2) Single object for deployment, (3) Hyperparameter tuning across entire workflow, (4) Reproducibility.</p>
-                        </div>
-
-                        <div class="interview-box">
-                            <strong>Q3: When to use GridSearchCV vs RandomizedSearchCV?</strong>
-                            <p><strong>Grid:</strong> Small param space (3 params × 3 values = 27 combos). <strong>Randomized:</strong> Large space (10 params = millions of combos), samples N random combinations.</p>
-                        </div>
-
-                        <div class="interview-box">
-                            <strong>Q4: How to handle class imbalance in cross-validation?</strong>
-                            <p>Use <code>StratifiedKFold</code> to preserve class distribution in each fold. For extreme imbalance, use <code>StratifiedShuffleSplit</code> or SMOTE oversampling.</p>
-                        </div>
-
-                        <div class="interview-box">
-                            <strong>Q5: Explain the difference between <code>StandardScaler</code> and <code>MinMaxScaler</code>.</strong>
-                            <p><strong>StandardScaler:</strong> (x - mean) / std → mean=0, std=1. <strong>MinMaxScaler:</strong> (x - min) / (max - min) → range [0, 1]. Use Standard for normal distributions, MinMax for bounded features.</p>
-                        </div>
-
-                        <div class="interview-box">
-                            <strong>Q6: How to create a custom transformer?</strong>
-                            <p>Inherit from <code>BaseEstimator</code> and <code>TransformerMixin</code>. Implement <code>fit()</code> and <code>transform()</code>. <code>TransformerMixin</code> provides <code>fit_transform()</code> for free.</p>
-                        </div>
-
-                        <div class="interview-box">
-                            <strong>Q7: What's the purpose of <code>n_jobs=-1</code>?</strong>
-                            <p>Use all CPU cores for parallel processing. Critical for GridSearchCV, RandomForest, cross-validation to speed up training.</p>
-                        </div>
-
-                        <div class="interview-box">
-                            <strong>Q8: How does <code>TimeSeriesSplit</code> differ from <code>KFold</code>?</strong>
-                            <p><code>TimeSeriesSplit</code> ensures train comes before test chronologically (no future data in training). <code>KFold</code> randomly splits, causing data leakage for time series.</p>
-                        </div>
-
-                        <div class="interview-box">
-                            <strong>Q9: What's the role of <code>random_state</code>?</strong>
-                            <p>Ensures reproducibility by seeding the random number generator. Critical for debugging and comparing models. Set to fixed value (e.g., 42) for experiments.</p>
-                        </div>
-
-                        <div class="interview-box">
-                            <strong>Q10: How to save and load a trained pipeline?</strong>
-                            <p>Use <code>joblib.dump(pipeline, 'model.pkl')</code> to save, <code>joblib.load('model.pkl')</code> to load. Joblib is more efficient than pickle for large NumPy arrays.</p>
-                        </div>
-                    </div>
-                `
-            },
-
-            "pytorch": {
-                concepts: `
-                    <div class="section">
-                        <h2>PyTorch Fundamentals</h2>
-
-                        <h3>Tensors vs NumPy Arrays</h3>
-                        <table>
-                            <tr>
-                                <th>Feature</th>
-                                <th>NumPy</th>
-                                <th>PyTorch Tensor</th>
-                            </tr>
-                            <tr>
-                                <td>GPU Support</td>
-                                <td>✗</td>
-                                <td>✓ (.cuda())</td>
-                            </tr>
-                            <tr>
-                                <td>Autograd</td>
-                                <td>✗</td>
-                                <td>✓ (requires_grad=True)</td>
-                            </tr>
-                            <tr>
-                                <td>Speed (CPU)</td>
-                                <td>Similar</td>
-                                <td>Similar</td>
-                            </tr>
-                        </table>
-
-                        <h3>Autograd: Automatic Differentiation</h3>
-                        <div class="info-box">
-                            <div class="box-title">∂ Computational Graph</div>
-                            <div class="box-content">
-                                PyTorch builds a dynamic computational graph. <code>loss.backward()</code> computes gradients via backpropagation. Critical for training neural networks.
-                            </div>
-                        </div>
-
-                        <h3>nn.Module Architecture</h3>
-                        <p>All models inherit from <code>nn.Module</code>. Must implement:</p>
-                        <ul>
-                            <li><code>__init__</code> - Define layers</li>
-                            <li><code>forward()</code> - Define forward pass</li>
-                        </ul>
-
-                        <h2>Transformers & NLP</h2>
-
-                        <h3>Hugging Face Integration</h3>
-                        <div class="info-box">
-                            <div class="box-title">🤗 Transformers Library</div>
-                            <div class="box-content">
-                                Pre-trained models (BERT, GPT, T5) with 3 lines of code. <code>AutoModel.from_pretrained('bert-base')</code>
-                            </div>
-                        </div>
-
-                        <h3>Attention Mechanism</h3>
-                        <p><strong>Self-Attention:</strong> Query, Key, Value matrices. Attention(Q, K, V) = softmax(QK^T / √d_k) V</p>
-
-                        <h3>Common Architectures</h3>
-                        <table>
-                            <tr>
-                                <th>Model</th>
-                                <th>Type</th>
-                                <th>Use Case</th>
-                            </tr>
-                            <tr>
-                                <td>BERT</td>
-                                <td>Encoder-only</td>
-                                <td>Classification, NER</td>
-                            </tr>
-                            <tr>
-                                <td>GPT</td>
-                                <td>Decoder-only</td>
-                                <td>Text generation</td>
-                            </tr>
-                            <tr>
-                                <td>T5</td>
-                                <td>Encoder-Decoder</td>
-                                <td>Translation, summarization</td>
-                            </tr>
-                        </table>
-                    </div>
-                `,
-                code: `
-                    <div class="section">
-                        <h2>💻 PyTorch Deep Learning</h2>
-
-                        <h3>Basic Training Loop</h3>
-                        <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"># Define model</span>
-<span class="keyword">class</span> <span class="class">SimpleNN</span>(nn.Module):
-    <span class="keyword">def</span> <span class="function">__init__</span>(<span class="keyword">self</span>, input_size, hidden_size, output_size):
-        <span class="function">super</span>().__init__()
-        <span class="keyword">self</span>.fc1 = nn.Linear(input_size, hidden_size)
-        <span class="keyword">self</span>.relu = nn.ReLU()
-        <span class="keyword">self</span>.fc2 = nn.Linear(hidden_size, output_size)
-    
-    <span class="keyword">def</span> <span class="function">forward</span>(<span class="keyword">self</span>, x):
-        x = <span class="keyword">self</span>.fc1(x)
-        x = <span class="keyword">self</span>.relu(x)
-        x = <span class="keyword">self</span>.fc2(x)
-        <span class="keyword">return</span> x
-
-<span class="comment"># Initialize</span>
-model = SimpleNN(<span class="number">10</span>, <span class="number">64</span>, <span class="number">1</span>)
-criterion = nn.MSELoss()
-optimizer = optim.Adam(model.parameters(), lr=<span class="number">0.001</span>)
-
-<span class="comment"># Training loop</span>
-<span class="keyword">for</span> epoch <span class="keyword">in</span> <span class="function">range</span>(<span class="number">100</span>):
-    <span class="comment"># Forward pass</span>
-    outputs = model(X_train)
-    loss = criterion(outputs, y_train)
-    
-    <span class="comment"># Backward pass</span>
-    optimizer.zero_grad()
-    loss.backward()
-    optimizer.step()
-    
-    <span class="keyword">if</span> epoch % <span class="number">10</span> == <span class="number">0</span>:
-        <span class="function">print</span>(<span class="string">f'Epoch {epoch}, Loss: {loss.item():.4f}'</span>)
-                        </div>
-
-                        <h3>CNN for Image Classification</h3>
-                        <div class="code-block">
-<span class="keyword">class</span> <span class="class">CNN</span>(nn.Module):
-    <span class="keyword">def</span> <span class="function">__init__</span>(<span class="keyword">self</span>):
-        <span class="function">super</span>().__init__()
-        <span class="keyword">self</span>.conv1 = nn.Conv2d(<span class="number">3</span>, <span class="number">32</span>, kernel_size=<span class="number">3</span>)
-        <span class="keyword">self</span>.pool = nn.MaxPool2d(<span class="number">2</span>, <span class="number">2</span>)
-        <span class="keyword">self</span>.conv2 = nn.Conv2d(<span class="number">32</span>, <span class="number">64</span>, kernel_size=<span class="number">3</span>)
-        <span class="keyword">self</span>.fc1 = nn.Linear(<span class="number">64</span> * <span class="number">6</span> * <span class="number">6</span>, <span class="number">128</span>)
-        <span class="keyword">self</span>.fc2 = nn.Linear(<span class="number">128</span>, <span class="number">10</span>)
-    
-    <span class="keyword">def</span> <span class="function">forward</span>(<span class="keyword">self</span>, x):
-        x = <span class="keyword">self</span>.pool(F.relu(<span class="keyword">self</span>.conv1(x)))
-        x = <span class="keyword">self</span>.pool(F.relu(<span class="keyword">self</span>.conv2(x)))
-        x = x.view(-<span class="number">1</span>, <span class="number">64</span> * <span class="number">6</span> * <span class="number">6</span>)
-        x = F.relu(<span class="keyword">self</span>.fc1(x))
-        x = <span class="keyword">self</span>.fc2(x)
-        <span class="keyword">return</span> x
-                        </div>
-
-                        <h3>Transfer Learning (ResNet)</h3>
-                        <div class="code-block">
-<span class="keyword">from</span> torchvision <span class="keyword">import</span> models
-
-<span class="comment"># Load pre-trained ResNet</span>
-model = models.resnet50(pretrained=<span class="keyword">True</span>)
-
-<span class="comment"># Freeze all layers</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</span>
-num_features = model.fc.in_features
-model.fc = nn.Linear(num_features, <span class="number">10</span>)  <span class="comment"># 10 classes</span>
-
-<span class="comment"># Only train final layer</span>
-optimizer = optim.Adam(model.fc.parameters(), lr=<span class="number">0.001</span>)
-                        </div>
-
-                        <h3>Transformers with Hugging Face</h3>
-                        <div class="code-block">
-<span class="keyword">from</span> transformers <span class="keyword">import</span> AutoTokenizer, AutoModelForSequenceClassification
-
-<span class="comment"># Load BERT for classification</span>
-tokenizer = AutoTokenizer.from_pretrained(<span class="string">'bert-base-uncased'</span>)
-model = AutoModelForSequenceClassification.from_pretrained(
-    <span class="string">'bert-base-uncased'</span>,
-    num_labels=<span class="number">2</span>
-)
-
-<span class="comment"># Tokenize text</span>
-text = <span class="string">"This movie is amazing!"</span>
-inputs = tokenizer(text, return_tensors=<span class="string">'pt'</span>, padding=<span class="keyword">True</span>, truncation=<span class="keyword">True</span>)
-
-<span class="comment"># Forward pass</span>
-outputs = model(**inputs)
-logits = outputs.logits
-predictions = torch.argmax(logits, dim=<span class="number">-1</span>)
-                        </div>
-
-                        <h3>Fine-tuning BERT</h3>
-                        <div class="code-block">
-<span class="keyword">from</span> transformers <span class="keyword">import</span> Trainer, TrainingArguments
-
-<span class="comment"># Training arguments</span>
-training_args = TrainingArguments(
-    output_dir=<span class="string">'./results'</span>,
-    num_train_epochs=<span class="number">3</span>,
-    per_device_train_batch_size=<span class="number">16</span>,
-    learning_rate=<span class="number">2e-5</span>,
-    logging_steps=<span class="number">100</span>
-)
-
-<span class="comment"># Trainer</span>
-trainer = Trainer(
-    model=model,
-    args=training_args,
-    train_dataset=train_dataset,
-    eval_dataset=eval_dataset
-)
-
-<span class="comment"># Train</span>
-trainer.train()
-                        </div>
-
-                        <h3>Custom Dataset</h3>
-                        <div class="code-block">
-<span class="keyword">from</span> torch.utils.data <span class="keyword">import</span> Dataset, DataLoader
-
-<span class="keyword">class</span> <span class="class">CustomDataset</span>(Dataset):
-    <span class="keyword">def</span> <span class="function">__init__</span>(<span class="keyword">self</span>, X, y):
-        <span class="keyword">self</span>.X = torch.FloatTensor(X)
-        <span class="keyword">self</span>.y = torch.FloatTensor(y)
-    
-    <span class="keyword">def</span> <span class="function">__len__</span>(<span class="keyword">self</span>):
-        <span class="keyword">return</span> <span class="function">len</span>(<span class="keyword">self</span>.X)
-    
-    <span class="keyword">def</span> <span class="function">__getitem__</span>(<span class="keyword">self</span>, idx):
-        <span class="keyword">return</span> <span class="keyword">self</span>.X[idx], <span class="keyword">self</span>.y[idx]
-
-<span class="comment"># DataLoader</span>
-dataset = CustomDataset(X_train, y_train)
-loader = DataLoader(dataset, batch_size=<span class="number">32</span>, shuffle=<span class="keyword">True</span>)
-                        </div>
-                    </div>
-                `,
-                interview: `
-                    <div class="section">
-                        <h2>🎯 PyTorch & Transformers Interview Questions</h2>
-
-                        <div class="interview-box">
-                            <strong>Q1: What's the purpose of <code>optimizer.zero_grad()</code>?</strong>
-                            <p>Clear gradients from previous iteration. PyTorch accumulates gradients by default. Without <code>zero_grad()</code>, gradients would sum across batches, causing incorrect updates.</p>
-                        </div>
-
-                        <div class="interview-box">
-                            <strong>Q2: Explain <code>requires_grad=True</code>.</strong>
-                            <p>Tells PyTorch to track operations on this tensor for autograd. Essential for trainable parameters. <code>loss.backward()</code> computes gradients only for tensors with <code>requires_grad=True</code>.</p>
-                        </div>
-
-                        <div class="interview-box">
-                            <strong>Q3: What's the difference between <code>model.eval()</code> and <code>model.train()</code>?</strong>
-                            <p><code>model.eval()</code>: Disables dropout, uses batch norm running stats (inference mode). <code>model.train()</code>: Enables dropout, updates batch norm stats (training mode).</p>
-                        </div>
-
-                        <div class="interview-box">
-                            <strong>Q4: How does transfer learning work in PyTorch?</strong>
-                            <p>Load pre-trained model → Freeze layers (<code>requires_grad=False</code>) → Replace final layer → Train only new layer. Leverages learned features from large datasets (ImageNet).</p>
-                        </div>
-
-                        <div class="interview-box">
-                            <strong>Q5: What's the purpose of <code>torch.no_grad()</code>?</strong>
-                            <p>Disable gradient tracking during inference. Saves memory and speeds up computation. Use for validation/testing: <code>with torch.no_grad(): outputs = model(X_test)</code></p>
-                        </div>
-
-                        <div class="interview-box">
-                            <strong>Q6: Explain BERT's masked language modeling.</strong>
-                            <p>Randomly mask 15% of tokens, train model to predict them using bidirectional context. Example: "The [MASK] is blue" → predict "sky". Enables BERT to learn contextualized representations.</p>
-                        </div>
-
-                        <div class="interview-box">
-                            <strong>Q7: What's the difference between <code>nn.Linear</code> and <code>nn.Conv2d</code>?</strong>
-                            <p><code>nn.Linear</code>: Fully-connected layer (all-to-all). <code>nn.Conv2d</code>: Convolutional layer (local connectivity, weight sharing). Convs for spatial data (images), Linear for flattened features.</p>
-                        </div>
-
-                        <div class="interview-box">
-                            <strong>Q8: How to move a model to GPU?</strong>
-                            <p><code>model = model.cuda()</code> or <code>model.to('cuda')</code>. Tensors must also be on GPU: <code>X = X.cuda()</code>. Check: <code>torch.cuda.is_available()</code></p>
-                        </div>
-
-                        <div class="interview-box">
-                            <strong>Q9: What's the role of attention in transformers?</strong>
-                            <p>Allows model to focus on relevant parts of input. Self-attention computes weighted sum of all tokens based on query-key similarity. Replaces RNN's sequential processing with parallel attention.</p>
-                        </div>
-
-                        <div class="interview-box">
-                            <strong>Q10: How to implement early stopping in PyTorch?</strong>
-                            <p>Track validation loss. If no improvement for N epochs, stop training and restore best weights. <code>if val_loss < best_loss: best_loss = val_loss; patience_counter = 0</code></p>
-                        </div>
-                    </div>
-                `
-            },
-
-            "tensorflow": {
-                concepts: `
-                    <div class="section">
-                        <h2>TensorFlow & Keras</h2>
-
-                        <h3>Sequential vs Functional API</h3>
-                        <table>
-                            <tr>
-                                <th>API</th>
-                                <th>Use Case</th>
-                                <th>Complexity</th>
-                            </tr>
-                            <tr>
-                                <td>Sequential</td>
-                                <td>Linear stack of layers</td>
-                                <td>Simple</td>
-                            </tr>
-                            <tr>
-                                <td>Functional</td>
-                                <td>Multi-input, multi-output, skip connections</td>
-                                <td>Complex</td>
-                            </tr>
-                        </table>
-
-                        <h3>Key Components</h3>
-                        <ul>
-                            <li><strong>Layers:</strong> Dense, Conv2D, LSTM, Dropout</li>
-                            <li><strong>Optimizers:</strong> Adam, SGD, RMSprop</li>
-                            <li><strong>Loss Functions:</strong> MSE, CrossEntropy, Hinge</li>
-                            <li><strong>Metrics:</strong> Accuracy, Precision, Recall, AUC</li>
-                        </ul>
-
-                        <h3>Callbacks</h3>
-                        <div class="info-box">
-                            <div class="box-title">🔔 Training Hooks</div>
-                            <div class="box-content">
-                                <strong>EarlyStopping:</strong> Stop when validation plateaus<br>
-                                <strong>ModelCheckpoint:</strong> Save best weights<br>
-                                <strong>TensorBoard:</strong> Visualize training<br>
-                                <strong>ReduceLROnPlateau:</strong> Decrease LR when stuck
-                            </div>
-                        </div>
-
-                        <h3>TensorFlow Lite</h3>
-                        <p>Convert trained models to lightweight format for mobile/edge deployment. Reduced model size + optimized for inference.</p>
-                    </div>
-                `,
-                code: `
-                    <div class="section">
-                        <h2>💻 TensorFlow Code Examples</h2>
-
-                        <h3>Sequential API (Simple)</h3>
-                        <div class="code-block">
-<span class="keyword">from</span> tensorflow <span class="keyword">import</span> keras
-<span class="keyword">from</span> keras <span class="keyword">import</span> layers
-
-<span class="comment"># Build model</span>
-model = keras.Sequential([
-    layers.Dense(<span class="number">128</span>, activation=<span class="string">'relu'</span>, input_shape=(<span class="number">10</span>,)),
-    layers.Dropout(<span class="number">0.3</span>),
-    layers.Dense(<span class="number">64</span>, activation=<span class="string">'relu'</span>),
-    layers.Dense(<span class="number">1</span>, activation=<span class="string">'sigmoid'</span>)
-])
-
-<span class="comment"># Compile</span>
-model.compile(
-    optimizer=<span class="string">'adam'</span>,
-    loss=<span class="string">'binary_crossentropy'</span>,
-    metrics=[<span class="string">'accuracy'</span>]
-)
-
-<span class="comment"># Train</span>
-history = model.fit(
-    X_train, y_train,
-    epochs=<span class="number">50</span>,
-    batch_size=<span class="number">32</span>,
-    validation_split=<span class="number">0.2</span>
-)
-                        </div>
-
-                        <h3>Functional API (Complex)</h3>
-                        <div class="code-block">
-<span class="keyword">from</span> keras <span class="keyword">import</span> Input, Model
-
-<span class="comment"># Multi-input model</span>
-input1 = Input(shape=(<span class="number">10</span>,), name=<span class="string">'features'</span>)
-input2 = Input(shape=(<span class="number">5</span>,), name=<span class="string">'metadata'</span>)
-
-<span class="comment"># Branch 1</span>
-x1 = layers.Dense(<span class="number">64</span>, activation=<span class="string">'relu'</span>)(input1)
-x1 = layers.Dropout(<span class="number">0.3</span>)(x1)
-
-<span class="comment"># Branch 2</span>
-x2 = layers.Dense(<span class="number">32</span>, activation=<span class="string">'relu'</span>)(input2)
-
-<span class="comment"># Merge</span>
-merged = layers.concatenate([x1, x2])
-output = layers.Dense(<span class="number">1</span>, activation=<span class="string">'sigmoid'</span>)(merged)
-
-<span class="comment"># Build model</span>
-model = Model(inputs=[input1, input2], outputs=output)
-model.compile(optimizer=<span class="string">'adam'</span>, loss=<span class="string">'binary_crossentropy'</span>)
-                        </div>
-
-                        <h3>Callbacks</h3>
-                        <div class="code-block">
-<span class="keyword">from</span> keras.callbacks <span class="keyword">import</span> EarlyStopping, ModelCheckpoint, TensorBoard
-
-<span class="comment"># Early stopping</span>
-early_stop = EarlyStopping(
-    monitor=<span class="string">'val_loss'</span>,
-    patience=<span class="number">10</span>,
-    restore_best_weights=<span class="keyword">True</span>
-)
-
-<span class="comment"># Save best model</span>
-checkpoint = ModelCheckpoint(
-    <span class="string">'best_model.h5'</span>,
-    monitor=<span class="string">'val_accuracy'</span>,
-    save_best_only=<span class="keyword">True</span>
-)
-
-<span class="comment"># TensorBoard</span>
-tensorboard = TensorBoard(log_dir=<span class="string">'./logs'</span>)
-
-<span class="comment"># Train with callbacks</span>
-model.fit(
-    X_train, y_train,
-    validation_data=(X_val, y_val),
-    epochs=<span class="number">100</span>,
-    callbacks=[early_stop, checkpoint, tensorboard]
-)
-                        </div>
-
-                        <h3>Custom Training Loop</h3>
-                        <div class="code-block">
-<span class="keyword">import</span> tensorflow <span class="keyword">as</span> tf
-
-<span class="comment"># Define loss and optimizer</span>
-loss_fn = keras.losses.BinaryCrossentropy()
-optimizer = keras.optimizers.Adam()
-
-<span class="comment"># Training step</span>
-<span class="function">@tf.function</span>
-<span class="keyword">def</span> <span class="function">train_step</span>(X, y):
-    <span class="keyword">with</span> tf.GradientTape() <span class="keyword">as</span> tape:
-        predictions = model(X, training=<span class="keyword">True</span>)
-        loss = loss_fn(y, predictions)
-    
-    <span class="comment"># Compute gradients</span>
-    gradients = tape.gradient(loss, model.trainable_variables)
-    
-    <span class="comment"># Update weights</span>
-    optimizer.apply_gradients(<span class="function">zip</span>(gradients, model.trainable_variables))
-    
-    <span class="keyword">return</span> loss
-
-<span class="comment"># Training loop</span>
-<span class="keyword">for</span> epoch <span class="keyword">in</span> <span class="function">range</span>(<span class="number">50</span>):
-    <span class="keyword">for</span> X_batch, y_batch <span class="keyword">in</span> train_dataset:
-        loss = train_step(X_batch, y_batch)
-                        </div>
-
-                        <h3>TensorFlow Lite Conversion</h3>
-                        <div class="code-block">
-<span class="comment"># Convert to TFLite</span>
-converter = tf.lite.TFLiteConverter.from_keras_model(model)
-converter.optimizations = [tf.lite.Optimize.DEFAULT]
-tflite_model = converter.convert()
-
-<span class="comment"># Save</span>
-<span class="keyword">with</span> <span class="function">open</span>(<span class="string">'model.tflite'</span>, <span class="string">'wb'</span>) <span class="keyword">as</span> f:
-    f.write(tflite_model)
-                        </div>
-                    </div>
-                `,
-                interview: `
-                    <div class="section">
-                        <h2>🎯 TensorFlow Interview Questions</h2>
-
-                        <div class="interview-box">
-                            <strong>Q1: When to use Sequential vs Functional API?</strong>
-                            <p><strong>Sequential:</strong> Simple linear models (input → layers → output). <strong>Functional:</strong> Multiple inputs/outputs, skip connections (ResNet), shared layers, complex architectures.</p>
-                        </div>
-
-                        <div class="interview-box">
-                            <strong>Q2: What's the purpose of <code>model.compile()</code>?</strong>
-                            <p>Configure training process: optimizer (how to update weights), loss function (what to minimize), metrics (what to track). Must call before <code>fit()</code>.</p>
-                        </div>
-
-                        <div class="interview-box">
-                            <strong>Q3: Explain <code>validation_split=0.2</code> vs <code>validation_data</code>.</strong>
-                            <p><code>validation_split</code>: Auto-split last 20% of training data. <code>validation_data=(X_val, y_val)</code>: Use explicit validation set. Latter gives more control.</p>
-                        </div>
-
-                        <div class="interview-box">
-                            <strong>Q4: How does EarlyStopping prevent overfitting?</strong>
-                            <p>Monitors validation metric (e.g., val_loss). If no improvement for <code>patience</code> epochs, stops training and restores best weights. Prevents training too long on training data.</p>
-                        </div>
-
-                        <div class="interview-box">
-                            <strong>Q5: What's the advantage of TensorBoard?</strong>
-                            <p>Visualize training curves (loss, accuracy), model graph, histograms of weights/gradients, embeddings. Launch: <code>tensorboard --logdir=./logs</code></p>
-                        </div>
-
-                        <div class="interview-box">
-                            <strong>Q6: How to freeze layers in transfer learning?</strong>
-                            <p><code>for layer in base_model.layers: layer.trainable = False</code>. Then add custom layers on top and train only those.</p>
-                        </div>
-
-                        <div class="interview-box">
-                            <strong>Q7: What's the purpose of <code>@tf.function</code>?</strong>
-                            <p>Converts Python function to TensorFlow graph for faster execution. Auto-optimizes and enables GPU acceleration. Use for training steps and inference.</p>
-                        </div>
-
-                        <div class="interview-box">
-                            <strong>Q8: How to save and load a Keras model?</strong>
-                            <p><code>model.save('model.h5')</code> to save entire model (architecture + weights). <code>keras.models.load_model('model.h5')</code> to load.</p>
-                        </div>
-
-                        <div class="interview-box">
-                            <strong>Q9: What's TensorFlow Lite used for?</strong>
-                            <p>Deploy models on mobile (Android/iOS) and edge devices. Converts model to smaller, optimized format. Supports quantization for further size reduction.</p>
-                        </div>
-
-                        <div class="interview-box">
-                            <strong>Q10: How does <code>Dropout</code> work?</strong>
-                            <p>Randomly sets fraction of inputs to 0 during training. Forces network to learn redundant representations, preventing overfitting. Disabled during inference (<code>model.predict()</code>).</p>
-                        </div>
-                    </div>
-                `
-            },
-
-            "production": {
-                concepts: `
-                    <div class="section">
-                        <h2>Production Python Best Practices</h2>
-
-                        <h3>Testing Frameworks</h3>
-                        <table>
-                            <tr>
-                                <th>Framework</th>
-                                <th>Style</th>
-                                <th>Best For</th>
-                            </tr>
-                            <tr>
-                                <td>unittest</td>
-                                <td>Class-based, built-in</td>
-                                <td>Traditional OOP projects</td>
-                            </tr>
-                            <tr>
-                                <td>pytest</td>
-                                <td>Function-based, fixtures</td>
-                                <td>Modern Python, ML pipelines</td>
-                            </tr>
-                        </table>
-
-                        <h3>Packaging</h3>
-                        <div class="info-box">
-                            <div class="box-title">📦 Distribution</div>
-                            <div class="box-content">
-                                <strong>setup.py (legacy):</strong> Classic packaging<br>
-                                <strong>pyproject.toml (modern):</strong> PEP 517/518 standard<br>
-                                <strong>poetry:</strong> Modern dependency management + packaging
-                            </div>
-                        </div>
-
-                        <h3>Logging Levels</h3>
-                        <ul>
-                            <li><strong>DEBUG:</strong> Detailed diagnostic info</li>
-                            <li><strong>INFO:</strong> General informational messages</li>
-                            <li><strong>WARNING:</strong> Something unexpected</li>
-                            <li><strong>ERROR:</strong> Serious problem occurred</li>
-                            <li><strong>CRITICAL:</strong> Program may crash</li>
-                        </ul>
-
-                        <h3>FastAPI for Model Serving</h3>
-                        <p>Modern async framework for ML APIs. Auto-generates OpenAPI docs, supports type hints, ~3x faster than Flask.</p>
-
-                        <h3>Error Handling</h3>
-                        <div class="callout tip">
-                            <div class="callout-title">✓ Best Practice</div>
-                            Catch specific exceptions, log errors, provide meaningful messages. Never use bare <code>except:</code> — it catches SystemExit and KeyboardInterrupt.
-                        </div>
-                    </div>
-                `,
-                code: `
-                    <div class="section">
-                        <h2>💻 Production Code Examples</h2>
-
-                        <h3>Pytest Testing</h3>
-                        <div class="code-block">
-<span class="comment"># test_model.py</span>
-<span class="keyword">import</span> pytest
-<span class="keyword">import</span> numpy <span class="keyword">as</span> np
-
-<span class="comment"># Fixture (reusable test data)</span>
-<span class="function">@pytest.fixture</span>
-<span class="keyword">def</span> <span class="function">sample_data</span>():
-    X = np.random.randn(<span class="number">100</span>, <span class="number">10</span>)
-    y = np.random.randint(<span class="number">0</span>, <span class="number">2</span>, <span class="number">100</span>)
-    <span class="keyword">return</span> X, y
-
-<span class="comment"># Test function</span>
-<span class="keyword">def</span> <span class="function">test_model_training</span>(sample_data):
-    X, y = sample_data
-    model = MyModel()
-    model.fit(X, y)
-    
-    <span class="keyword">assert</span> model.is_fitted == <span class="keyword">True</span>
-    <span class="keyword">assert</span> model.score(X, y) &gt; <span class="number">0.5</span>
-
-<span class="comment"># Parametrized test</span>
-<span class="function">@pytest.mark.parametrize</span>(<span class="string">"lr,expected"</span>, [
-    (<span class="number">0.001</span>, <span class="number">0.8</span>),
-    (<span class="number">0.01</span>, <span class="number">0.85</span>),
-    (<span class="number">0.1</span>, <span class="number">0.75</span>)
-])
-<span class="keyword">def</span> <span class="function">test_learning_rates</span>(lr, expected, sample_data):
-    X, y = sample_data
-    model = MyModel(learning_rate=lr)
-    model.fit(X, y)
-    <span class="keyword">assert</span> model.score(X, y) &gt; expected
-                        </div>
-
-                        <h3>Logging Configuration</h3>
-                        <div class="code-block">
-<span class="keyword">import</span> logging
-
-<span class="comment"># Configure logger</span>
-logging.basicConfig(
-    level=logging.INFO,
-    format=<span class="string">'%(asctime)s - %(name)s - %(levelname)s - %(message)s'</span>,
-    handlers=[
-        logging.FileHandler(<span class="string">'model_training.log'</span>),
-        logging.StreamHandler()
-    ]
-)
-
-logger = logging.getLogger(__name__)
-
-<span class="comment"># Use in code</span>
-<span class="keyword">def</span> <span class="function">train_model</span>(X, y):
-    logger.info(<span class="string">f"Training on {len(X)} samples"</span>)
-    <span class="keyword">try</span>:
-        model.fit(X, y)
-        logger.info(<span class="string">"Training completed successfully"</span>)
-    <span class="keyword">except</span> <span class="function">ValueError</span> <span class="keyword">as</span> e:
-        logger.error(<span class="string">f"Training failed: {e}"</span>)
-        <span class="keyword">raise</span>
-                        </div>
-
-                        <h3>FastAPI Model Serving</h3>
-                        <div class="code-block">
-<span class="keyword">from</span> fastapi <span class="keyword">import</span> FastAPI, HTTPException
-<span class="keyword">from</span> pydantic <span class="keyword">import</span> BaseModel
-<span class="keyword">import</span> joblib
-
-app = FastAPI()
-
-<span class="comment"># Load model at startup</span>
-model = joblib.load(<span class="string">'model.pkl'</span>)
-
-<span class="comment"># Request schema</span>
-<span class="keyword">class</span> <span class="class">PredictionRequest</span>(BaseModel):
-    features: <span class="function">list</span>[<span class="function">float</span>]
-
-<span class="comment"># Response schema</span>
-<span class="keyword">class</span> <span class="class">PredictionResponse</span>(BaseModel):
-    prediction: <span class="function">float</span>
-    probability: <span class="function">float</span>
-
-<span class="function">@app.post</span>(<span class="string">"/predict"</span>, response_model=PredictionResponse)
-<span class="keyword">async</span> <span class="keyword">def</span> <span class="function">predict</span>(request: PredictionRequest):
-    <span class="keyword">try</span>:
-        X = np.array(request.features).reshape(<span class="number">1</span>, -<span class="number">1</span>)
-        prediction = model.predict(X)[<span class="number">0</span>]
-        probability = model.predict_proba(X)[<span class="number">0</span>].max()
-        
-        <span class="keyword">return</span> PredictionResponse(
-            prediction=<span class="function">float</span>(prediction),
-            probability=<span class="function">float</span>(probability)
-        )
-    <span class="keyword">except</span> <span class="function">Exception</span> <span class="keyword">as</span> e:
-        <span class="keyword">raise</span> HTTPException(status_code=<span class="number">500</span>, detail=<span class="function">str</span>(e))
-
-<span class="comment"># Run: uvicorn main:app --reload</span>
-                        </div>
-
-                        <h3>Packaging with pyproject.toml</h3>
-                        <div class="code-block">
-<span class="comment"># pyproject.toml</span>
-[build-system]
-requires = [<span class="string">"setuptools>=45"</span>, <span class="string">"wheel"</span>]
-build-backend = <span class="string">"setuptools.build_meta"</span>
-
-[project]
-name = <span class="string">"my-ml-package"</span>
-version = <span class="string">"0.1.0"</span>
-dependencies = [
-    <span class="string">"numpy>=1.20"</span>,
-    <span class="string">"scikit-learn>=1.0"</span>,
-    <span class="string">"pandas>=1.3"</span>
-]
-
-[project.optional-dependencies]
-dev = [<span class="string">"pytest"</span>, <span class="string">"black"</span>, <span class="string">"flake8"</span>]
-                        </div>
-
-                        <h3>Exception Handling</h3>
-                        <div class="code-block">
-<span class="comment"># Custom exception</span>
-<span class="keyword">class</span> <span class="class">ModelNotFittedError</span>(<span class="function">Exception</span>):
-    <span class="keyword">pass</span>
-
-<span class="keyword">class</span> <span class="class">MyModel</span>:
-    <span class="keyword">def</span> <span class="function">predict</span>(<span class="keyword">self</span>, X):
-        <span class="keyword">if</span> <span class="keyword">not</span> <span class="keyword">self</span>.is_fitted:
-            <span class="keyword">raise</span> ModelNotFittedError(
-                <span class="string">"Model must be fitted before calling predict()"</span>
-            )
-        
-        <span class="keyword">try</span>:
-            predictions = <span class="keyword">self</span>._predict_internal(X)
-        <span class="keyword">except</span> <span class="function">ValueError</span> <span class="keyword">as</span> e:
-            logger.error(<span class="string">f"Invalid input shape: {e}"</span>)
-            <span class="keyword">raise</span>
-        <span class="keyword">except</span> <span class="function">Exception</span> <span class="keyword">as</span> e:
-            logger.critical(<span class="string">f"Unexpected error: {e}"</span>)
-            <span class="keyword">raise</span>
-        
-        <span class="keyword">return</span> predictions
-                        </div>
-                    </div>
-                `,
-                interview: `
-                    <div class="section">
-                        <h2>🎯 Production Python Interview Questions</h2>
-
-                        <div class="interview-box">
-                            <strong>Q1: What's the advantage of pytest over unittest?</strong>
-                            <p>Pytest: simpler syntax (no classes), powerful fixtures, parametrization, better assertions. Unittest: OOP style, built-in, more verbose. Pytest is preferred for modern Python.</p>
-                        </div>
-
-                        <div class="interview-box">
-                            <strong>Q2: How to test a machine learning model?</strong>
-                            <p>(1) Test data shape/type validation, (2) Test fit/predict logic, (3) Test reproducibility (fixed random seed), (4) Test edge cases (empty data, single sample), (5) Integration tests with real data.</p>
-                        </div>
-
-                        <div class="interview-box">
-                            <strong>Q3: Why use logging instead of print()?</strong>
-                            <p>Logging: levels (DEBUG, INFO, ERROR), can write to files, timestamps, configurable formatting, can be disabled in production. Print: fixed output, no control, pollutes stdout.</p>
-                        </div>
-
-                        <div class="interview-box">
-                            <strong>Q4: How does FastAPI compare to Flask?</strong>
-                            <p><strong>FastAPI:</strong> Async, auto docs (Swagger), type hints, faster. <strong>Flask:</strong> Synchronous, mature ecosystem, simpler. FastAPI better for ML APIs with high throughput.</p>
-                        </div>
-
-                        <div class="interview-box">
-                            <strong>Q5: What's the purpose of fixtures in pytest?</strong>
-                            <p>Reusable test setup code. Example: load dataset once, use in multiple tests. Scope: function (default), class, module, session. Reduces code duplication.</p>
-                        </div>
-
-                        <div class="interview-box">
-                            <strong>Q6: How to package a Python project for distribution?</strong>
-                            <p>Use <code>pyproject.toml</code> (modern) or <code>setup.py</code> (legacy). Build: <code>python -m build</code>. Upload to PyPI: <code>twine upload dist/*</code>. Install: <code>pip install my-package</code></p>
-                        </div>
-
-                        <div class="interview-box">
-                            <strong>Q7: What's type hinting and why use it?</strong>
-                            <p>Specify expected types: <code>def predict(X: np.ndarray) -> np.ndarray:</code>. Benefits: IDE autocomplete, early error detection (mypy), self-documentation, FastAPI uses them for validation.</p>
-                        </div>
-
-                        <div class="interview-box">
-                            <strong>Q8: How to handle secrets/credentials in production?</strong>
-                            <p>Never hardcode. Use: environment variables (<code>os.getenv('API_KEY')</code>), config files (gitignored), secret management services (AWS Secrets Manager, HashiCorp Vault).</p>
-                        </div>
-
-                        <div class="interview-box">
-                            <strong>Q9: What's the purpose of <code>__name__ == '__main__'</code>?</strong>
-                            <p>Distinguish between running as script vs importing as module. Code under <code>if __name__ == '__main__':</code> only runs when executed directly, not when imported.</p>
-                        </div>
-
-                        <div class="interview-box">
-                            <strong>Q10: How to version control ML models?</strong>
-                            <p>Use DVC (Data Version Control) or MLflow. Track model files, datasets, params. Git for code, DVC for large binaries. Enables reproducibility and rollback.</p>
-                        </div>
-                    </div>
-                `
-            },
-
-            "optimization": {
-                concepts: `
-                    <div class="section">
-                        <h2>Performance Optimization</h2>
-
-                        <h3>Profiling Tools</h3>
-                        <table>
-                            <tr>
-                                <th>Tool</th>
-                                <th>Type</th>
-                                <th>Use Case</th>
-                            </tr>
-                            <tr>
-                                <td>cProfile</td>
-                                <td>Function-level</td>
-                                <td>Find slow functions</td>
-                            </tr>
-                            <tr>
-                                <td>line_profiler</td>
-                                <td>Line-by-line</td>
-                                <td>Optimize specific function</td>
-                            </tr>
-                            <tr>
-                                <td>memory_profiler</td>
-                                <td>Memory usage</td>
-                                <td>Find memory leaks</td>
-                            </tr>
-                        </table>
-
-                        <h3>Numba: JIT Compilation</h3>
-                        <div class="info-box">
-                            <div class="box-title">⚡ 100x Speedup</div>
-                            <div class="box-content">
-                                Numba compiles Python to machine code (LLVM). Add <code>@jit</code> decorator to functions with loops/NumPy. No code changes needed!
-                            </div>
-                        </div>
-
-                        <h3>Vectorization Priority</h3>
-                        <ol>
-                            <li><strong>NumPy/Pandas vectorization</strong> — First choice</li>
-                            <li><strong>Numba JIT</strong> — If loops unavoidable</li>
-                            <li><strong>Cython</strong> — If maximum performance needed</li>
-                            <li><strong>Multiprocessing</strong> — For embarrassingly parallel tasks</li>
-                        </ol>
-
-                        <h3>Memory Optimization</h3>
-                        <ul>
-                            <li><strong>Generators:</strong> Yield instead of building lists</li>
-                            <li><strong>__slots__:</strong> Reduce memory for classes</li>
-                            <li><strong>dtype optimization:</strong> float32 vs float64</li>
-                            <li><strong>del:</strong> Explicitly free large objects</li>
-                        </ul>
-
-                        <h3>Dask for Big Data</h3>
-                        <p>Parallel computing for datasets larger than RAM. Pandas-like API but processes in chunks. Scales to clusters.</p>
-
-                        <div class="callout warning">
-                            <div class="callout-title">⚠️ Premature Optimization</div>
-                            Profile first! Don't optimize without measuring. 80% of runtime is often in 20% of code.
-                        </div>
-                    </div>
-                `,
-                code: `
-                    <div class="section">
-                        <h2>💻 Optimization Code Examples</h2>
-
-                        <h3>Profiling with cProfile</h3>
-                        <div class="code-block">
-<span class="keyword">import</span> cProfile
-<span class="keyword">import</span> pstats
-
-<span class="comment"># Profile a function</span>
-<span class="keyword">def</span> <span class="function">slow_function</span>():
-    result = []
-    <span class="keyword">for</span> i <span class="keyword">in</span> <span class="function">range</span>(<span class="number">1000000</span>):
-        result.append(i ** <span class="number">2</span>)
-    <span class="keyword">return</span> result
-
-<span class="comment"># Profile</span>
-profiler = cProfile.Profile()
-profiler.enable()
-slow_function()
-profiler.disable()
-
-<span class="comment"># Print stats</span>
-stats = pstats.Stats(profiler)
-stats.sort_stats(<span class="string">'cumtime'</span>)
-stats.print_stats(<span class="number">10</span>)  <span class="comment"># Top 10 slowest</span>
-                        </div>
-
-                        <h3>Numba JIT Compilation</h3>
-                        <div class="code-block">
-<span class="keyword">from</span> numba <span class="keyword">import</span> jit
-<span class="keyword">import</span> numpy <span class="keyword">as</span> np
-
-<span class="comment"># Slow Python loop</span>
-<span class="keyword">def</span> <span class="function">python_sum</span>(arr):
-    total = <span class="number">0</span>
-    <span class="keyword">for</span> x <span class="keyword">in</span> arr:
-        total += x ** <span class="number">2</span>
-    <span class="keyword">return</span> total
-
-<span class="comment"># Fast Numba version (100x faster!)</span>
-<span class="function">@jit</span>(nopython=<span class="keyword">True</span>)
-<span class="keyword">def</span> <span class="function">numba_sum</span>(arr):
-    total = <span class="number">0</span>
-    <span class="keyword">for</span> x <span class="keyword">in</span> arr:
-        total += x ** <span class="number">2</span>
-    <span class="keyword">return</span> total
-
-arr = np.random.randn(<span class="number">1000000</span>)
-<span class="comment"># First call compiles, subsequent calls are fast</span>
-result = numba_sum(arr)
-                        </div>
-
-                        <h3>Vectorization vs Loops</h3>
-                        <div class="code-block">
-<span class="keyword">import</span> numpy <span class="keyword">as</span> np
-<span class="keyword">import</span> time
-
-<span class="comment"># Slow: Python loop</span>
-<span class="keyword">def</span> <span class="function">loop_version</span>(arr):
-    result = []
-    <span class="keyword">for</span> x <span class="keyword">in</span> arr:
-        result.append(x ** <span class="number">2</span> + <span class="number">2</span> * x)
-    <span class="keyword">return</span> result
-
-<span class="comment"># Fast: Vectorized</span>
-<span class="keyword">def</span> <span class="function">vectorized_version</span>(arr):
-    <span class="keyword">return</span> arr ** <span class="number">2</span> + <span class="number">2</span> * arr
-
-arr = np.random.randn(<span class="number">1000000</span>)
-
-<span class="comment"># Benchmark</span>
-start = time.time()
-loop_version(arr)
-<span class="function">print</span>(<span class="string">f"Loop: {time.time() - start:.4f}s"</span>)
-
-start = time.time()
-vectorized_version(arr)
-<span class="function">print</span>(<span class="string">f"Vectorized: {time.time() - start:.4f}s"</span>)
-                        </div>
-
-                        <h3>Memory Optimization with __slots__</h3>
-                        <div class="code-block">
-<span class="comment"># Regular class (uses dict)</span>
-<span class="keyword">class</span> <span class="class">RegularPoint</span>:
-    <span class="keyword">def</span> <span class="function">__init__</span>(<span class="keyword">self</span>, x, y):
-        <span class="keyword">self</span>.x = x
-        <span class="keyword">self</span>.y = y
-
-<span class="comment"># Optimized class (50% less memory)</span>
-<span class="keyword">class</span> <span class="class">SlottedPoint</span>:
-    __slots__ = [<span class="string">'x'</span>, <span class="string">'y'</span>]
-    
-    <span class="keyword">def</span> <span class="function">__init__</span>(<span class="keyword">self</span>, x, y):
-        <span class="keyword">self</span>.x = x
-        <span class="keyword">self</span>.y = y
-
-<span class="comment"># For millions of instances, slots save significant memory</span>
-points = [SlottedPoint(i, i*<span class="number">2</span>) <span class="keyword">for</span> i <span class="keyword">in</span> <span class="function">range</span>(<span class="number">1000000</span>)]
-                        </div>
-
-                        <h3>Dask for Large Datasets</h3>
-                        <div class="code-block">
-<span class="keyword">import</span> dask.dataframe <span class="keyword">as</span> dd
-
-<span class="comment"># Load large CSV (lazy evaluation)</span>
-df = dd.read_csv(<span class="string">'large_file.csv'</span>)
-
-<span class="comment"># Operations are lazy (not executed yet)</span>
-result = df[df[<span class="string">'value'</span>] &gt; <span class="number">100</span>].groupby(<span class="string">'category'</span>)[<span class="string">'price'</span>].mean()
-
-<span class="comment"># Compute triggers execution (parallel)</span>
-final_result = result.compute()
-
-<span class="comment"># Works with datasets bigger than RAM!</span>
-                        </div>
-
-                        <h3>Multiprocessing for Parallel Tasks</h3>
-                        <div class="code-block">
-<span class="keyword">from</span> multiprocessing <span class="keyword">import</span> Pool
-<span class="keyword">import</span> numpy <span class="keyword">as</span> np
-
-<span class="keyword">def</span> <span class="function">expensive_computation</span>(data):
-    <span class="keyword">return</span> np.mean(data ** <span class="number">2</span>)
-
-<span class="comment"># Split data into chunks</span>
-data = [np.random.randn(<span class="number">1000000</span>) <span class="keyword">for</span> _ <span class="keyword">in</span> <span class="function">range</span>(<span class="number">8</span>)]
-
-<span class="comment"># Parallel processing (uses all CPU cores)</span>
-<span class="keyword">with</span> Pool() <span class="keyword">as</span> pool:
-    results = pool.<span class="function">map</span>(expensive_computation, data)
-
-<span class="function">print</span>(<span class="string">f"Results: {results}"</span>)
-                        </div>
-
-                        <h3>Generator for Memory Efficiency</h3>
-                        <div class="code-block">
-<span class="comment"># Bad: Loads entire file into memory</span>
-<span class="keyword">def</span> <span class="function">read_all_lines</span>(filepath):
-    <span class="keyword">with</span> <span class="function">open</span>(filepath) <span class="keyword">as</span> f:
-        <span class="keyword">return</span> [line.strip() <span class="keyword">for</span> line <span class="keyword">in</span> f]
-
-<span class="comment"># Good: Yields one line at a time</span>
-<span class="keyword">def</span> <span class="function">read_lines_generator</span>(filepath):
-    <span class="keyword">with</span> <span class="function">open</span>(filepath) <span class="keyword">as</span> f:
-        <span class="keyword">for</span> line <span class="keyword">in</span> f:
-            <span class="keyword">yield</span> line.strip()
-
-<span class="comment"># Process 10GB file without loading all</span>
-<span class="keyword">for</span> line <span class="keyword">in</span> read_lines_generator(<span class="string">'huge_file.txt'</span>):
-    process(line)
-                        </div>
-                    </div>
-                `,
-                interview: `
-                    <div class="section">
-                        <h2>🎯 Optimization Interview Questions</h2>
-
-                        <div class="interview-box">
-                            <strong>Q1: What's the first step in optimization?</strong>
-                            <p><strong>Profile first!</strong> Use cProfile to find bottlenecks. Don't optimize without measuring. Often 80% of time is in 20% of code. Focus optimization there.</p>
-                        </div>
-
-                        <div class="interview-box">
-                            <strong>Q2: How does Numba achieve speedup?</strong>
-                            <p>JIT (Just-In-Time) compiles Python to machine code using LLVM. Works best with NumPy arrays and numerical loops. <code>@jit(nopython=True)</code> ensures pure compilation (no Python overhead).</p>
-                        </div>
-
-                        <div class="interview-box">
-                            <strong>Q3: When to use multiprocessing vs threading?</strong>
-                            <p><strong>Multiprocessing:</strong> CPU-bound (bypasses GIL). <strong>Threading:</strong> I/O-bound (file reads, API calls). For ML: multiprocessing for training, threading for data loading.</p>
-                        </div>
-
-                        <div class="interview-box">
-                            <strong>Q4: How do generators save memory?</strong>
-                            <p>Yield values one at a time instead of building entire list. For iterating over 1 billion records: generator uses constant memory, list uses GB of RAM.</p>
-                        </div>
-
-                        <div class="interview-box">
-                            <strong>Q5: What's __slots__ and when to use it?</strong>
-                            <p>Defines fixed attributes, removes <code>__dict__</code>. Saves ~50% memory per instance. Use for dataclasses with millions of instances (points, records).</p>
-                        </div>
-
-                        <div class="interview-box">
-                            <strong>Q6: How does Dask handle data larger than RAM?</strong>
-                            <p>Lazy evaluation + task scheduling. Breaks data into chunks, processes in parallel, keeps only necessary chunks in memory. Spills to disk if needed.</p>
-                        </div>
-
-                        <div class="interview-box">
-                            <strong>Q7: Explain the difference between cProfile and line_profiler.</strong>
-                            <p><strong>cProfile:</strong> Function-level, built-in, overhead low. <strong>line_profiler:</strong> Line-by-line, external, overhead higher. Use cProfile first, line_profiler to dig deeper.</p>
-                        </div>
-
-                        <div class="interview-box">
-                            <strong>Q8: What's the advantage of float32 vs float64?</strong>
-                            <p><strong>float32:</strong> 4 bytes, 50% less memory, faster on GPU. <strong>float64:</strong> 8 bytes, more precision. For deep learning, float32 is usually sufficient and 2x faster.</p>
-                        </div>
-
-                        <div class="interview-box">
-                            <strong>Q9: How to optimize Pandas operations?</strong>
-                            <p>(1) Vectorize (no <code>iterrows()</code>), (2) Use categorical dtype for strings, (3) Downcast numeric types, (4) Use <code>eval()</code> for complex expressions, (5) Process in chunks if too large.</p>
-                        </div>
-
-                        <div class="interview-box">
-                            <strong>Q10: What's Cython and when to use it?</strong>
-                            <p>Python with C types. Compile to C extension. 10-100x faster than Python. Use when Numba insufficient and need maximum performance (custom algorithms, hot loops).</p>
-                        </div>
-                    </div>
-                `
-            }
-        };
-
-        // Render dashboard cards
-        function renderDashboard() {
-            const grid = document.getElementById('modulesGrid');
-            grid.innerHTML = modules.map(module => `
-                <div class="card" onclick="showModule('${module.id}')">
-                    <div class="card-icon">${module.icon}</div>
-                    <h3>${module.title}</h3>
-                    <p>${module.description}</p>
-                    <span class="category-label">${module.category}</span>
-                </div>
-            `).join('');
-        }
-
-        // Show specific module
-        function showModule(moduleId) {
-            const module = modules.find(m => m.id === moduleId);
-            const content = MODULE_CONTENT[moduleId];
-
-            document.getElementById('dashboard').classList.remove('active');
-
-            const moduleHTML = `
-                <div class="module active" id="module-${moduleId}">
-                    <button class="btn-back" onclick="backToDashboard()">← Back to Dashboard</button>
-                    <header>
-                        <h1>${module.icon} ${module.title}</h1>
-                        <p class="subtitle">${module.description}</p>
-                    </header>
-                    
-                    <div class="tabs">
-                        <button class="tab-btn active" onclick="switchTab('${moduleId}', 'concepts', event)">📖 Key Concepts</button>
-                        <button class="tab-btn" onclick="switchTab('${moduleId}', 'code', event)">💻 Code Examples</button>
-                        <button class="tab-btn" onclick="switchTab('${moduleId}', 'interview', event)">🎯 Interview Questions</button>
-                    </div>
-                    
-                    <div id="${moduleId}-concepts" class="tab active">${content.concepts}</div>
-                    <div id="${moduleId}-code" class="tab">${content.code}</div>
-                    <div id="${moduleId}-interview" class="tab">${content.interview}</div>
-                </div>
-            `;
-
-            document.getElementById('modulesContainer').innerHTML = moduleHTML;
-        }
-
-        // Switch tabs
-        function switchTab(moduleId, tabName, e) {
-            const moduleEl = document.getElementById(`module-${moduleId}`);
-
-            // Update tab buttons
-            moduleEl.querySelectorAll('.tab-btn').forEach(btn => btn.classList.remove('active'));
-            if (e && e.target) {
-                e.target.classList.add('active');
-            } else {
-                // Fallback: find the button by tab name
-                const tabNames = ['concepts', 'code', 'interview'];
-                const idx = tabNames.indexOf(tabName);
-                if (idx !== -1) moduleEl.querySelectorAll('.tab-btn')[idx]?.classList.add('active');
-            }
-
-            // Update tab content
-            moduleEl.querySelectorAll('.tab').forEach(tab => tab.classList.remove('active'));
-            document.getElementById(`${moduleId}-${tabName}`).classList.add('active');
-        }
-
-        // Back to dashboard
-        function backToDashboard() {
-            document.querySelectorAll('.module').forEach(m => m.remove());
-            document.getElementById('dashboard').classList.add('active');
-        }
-
-        // Initialize
-        renderDashboard();
-    </script>
+    <script src="app.js"></script>
 </body>
 
 </html>
\ No newline at end of file