update files

ml_complete-all-topics/app.js

@@ -1,3 +1,97 @@
+// ========== VISUALIZATION VERIFICATION SYSTEM ==========
+const vizLog = {
+  success: [],
+  failed: [],
+  warnings: []
+};
+
+function logViz(module, name, status, error = null) {
+  const log = {
+    module: module,
+    name: name,
+    status: status,
+    timestamp: new Date().toLocaleTimeString(),
+    error: error
+  };
+  
+  if (status === 'success') {
+    vizLog.success.push(log);
+    console.log(`✓ ${module} - ${name}`);
+  } else if (status === 'failed') {
+    vizLog.failed.push(log);
+    console.error(`✗ ${module} - ${name}: ${error}`);
+  } else {
+    vizLog.warnings.push(log);
+    console.warn(`⚠ ${module} - ${name}: ${error}`);
+  }
+}
+
+function createVerifiedVisualization(canvasId, chartConfig, moduleName, vizName) {
+  try {
+    const canvas = document.getElementById(canvasId);
+    if (!canvas) {
+      logViz(moduleName, vizName, 'failed', 'Canvas not found');
+      showFallback(canvasId, 'error');
+      return null;
+    }
+    
+    const ctx = canvas.getContext('2d');
+    if (!ctx) {
+      logViz(moduleName, vizName, 'failed', 'Cannot get context');
+      showFallback(canvasId, 'error');
+      return null;
+    }
+    
+    if (typeof Chart === 'undefined') {
+      logViz(moduleName, vizName, 'failed', 'Chart.js not loaded');
+      showFallback(canvasId, 'error');
+      return null;
+    }
+    
+    const chart = new Chart(ctx, chartConfig);
+    logViz(moduleName, vizName, 'success');
+    return chart;
+    
+  } catch (error) {
+    logViz(moduleName, vizName, 'failed', error.message);
+    showFallback(canvasId, 'error');
+    return null;
+  }
+}
+
+function showFallback(elementId, type) {
+  const element = document.getElementById(elementId);
+  if (!element) return;
+  
+  const container = element.parentElement;
+  if (!container) return;
+  
+  if (type === 'error') {
+    container.innerHTML = '<div style="padding: 40px; text-align: center; color: #ff8c6a; background: rgba(255, 140, 106, 0.1); border-radius: 8px; border: 2px solid #ff8c6a;">⚠️ Visualization temporarily unavailable<br><small style="color: #a9b4c2; margin-top: 8px; display: block;">Data is still accessible via diagnostic tools</small></div>';
+  }
+}
+
+// Show report on load
+window.addEventListener('load', () => {
+  setTimeout(() => {
+    console.log('\n=== VISUALIZATION VERIFICATION REPORT ===');
+    console.log(`✓ Success: ${vizLog.success.length}`);
+    console.log(`✗ Failed: ${vizLog.failed.length}`);
+    console.log(`⚠ Warnings: ${vizLog.warnings.length}`);
+    
+    if (vizLog.failed.length > 0) {
+      console.error('Failed visualizations:', vizLog.failed);
+    }
+    
+    if (vizLog.success.length > 0) {
+      console.log('\nSuccessful visualizations:');
+      vizLog.success.forEach(v => console.log(`  ✓ ${v.module} - ${v.name}`));
+    }
+    
+    console.log('\n=========================================');
+  }, 2000);
+});
+
 // Data
 const data = {
   linearRegression: [
@@ -134,8 +228,18 @@ function initSections() {
         if (section.id === 'hyperparameter-tuning') initHyperparameterTuning();
         if (section.id === 'naive-bayes') initNaiveBayes();
         if (section.id === 'kmeans') initKMeans();
+        if (section.id === 'decision-tree-regression') initDecisionTreeRegression();
         if (section.id === 'decision-trees') initDecisionTrees();
+        if (section.id === 'gradient-boosting') initGradientBoosting();
+        if (section.id === 'xgboost') initXGBoost();
+        if (section.id === 'bagging') initBagging();
+        if (section.id === 'boosting-adaboost') initBoostingAdaBoost();
+        if (section.id === 'random-forest') initRandomForest();
         if (section.id === 'ensemble-methods') initEnsembleMethods();
+        if (section.id === 'diagnostics') {
+          // Wait for all visualizations to initialize
+          setTimeout(showDiagnostics, 500);
+        }
         if (section.id === 'rl-intro') { /* No viz for intro */ }
         if (section.id === 'q-learning') { /* Add Q-learning viz if needed */ }
         if (section.id === 'policy-gradient') { /* Add policy gradient viz if needed */ }
@@ -182,7 +286,7 @@ function initTOCLinks() {
       });
       ticking = true;
     }
-  });
+  }, 'Gradient Descent', 'Loss Curve');
 }
 
 function updateActiveLink() {
@@ -263,7 +367,12 @@ function drawLinearRegression() {
   });
   mse /= data.linearRegression.length;
   
-  lrChart = safeCreateChart(ctx, {
+  // Destroy existing chart
+  if (lrChart) {
+    lrChart.destroy();
+  }
+  
+  lrChart = createVerifiedVisualization('lr-canvas', {
     type: 'scatter',
     data: {
       datasets: [
@@ -313,7 +422,7 @@ function drawLinearRegression() {
         }
       }
     }
-  }, 'Linear Regression Chart');
+  }, 'Linear Regression', 'Scatter + Line');
 }
 
 // Gradient Descent Visualization
@@ -429,7 +538,12 @@ function drawGradientDescent(currentStep = -1) {
   const ctx = canvas.getContext('2d');
   const lossData = state.gdIterations.map((iter, i) => ({ x: i + 1, y: iter.loss }));
   
-  gdChart = safeCreateChart(ctx, {
+  // Destroy existing chart
+  if (gdChart) {
+    gdChart.destroy();
+  }
+  
+  gdChart = createVerifiedVisualization('gd-canvas', {
     type: 'line',
     data: {
       datasets: [{
@@ -481,17 +595,57 @@ function safeCreateChart(ctx, config, chartName) {
       console.warn(`Canvas context not found for ${chartName}`);
       return null;
     }
-    return new Chart(ctx, config);
+    const chart = new Chart(ctx, config);
+    console.log(`✓ Chart created: ${chartName}`);
+    return chart;
   } catch (error) {
     console.error(`Chart creation failed for ${chartName}:`, error);
-    // Show fallback message
-    if (ctx && ctx.canvas && ctx.canvas.parentElement) {
-      ctx.canvas.parentElement.innerHTML = `<p style="color: #ff8c6a; text-align: center; padding: 40px;">Visualization temporarily unavailable. Please refresh the page.</p>`;
-    }
     return null;
   }
 }
 
+// Link Verification System
+function verifyAllLinks() {
+  const links = document.querySelectorAll('a[href^="#"]');
+  const broken = [];
+  let working = 0;
+  
+  links.forEach(link => {
+    const targetId = link.getAttribute('href').substring(1);
+    const target = document.getElementById(targetId);
+    
+    if (!target) {
+      broken.push({
+        text: link.textContent,
+        href: link.getAttribute('href')
+      });
+      link.style.color = 'red';
+      link.title = 'Broken link';
+    } else {
+      working++;
+      link.addEventListener('click', (e) => {
+        e.preventDefault();
+        target.scrollIntoView({ behavior: 'smooth' });
+        
+        // Highlight section
+        const originalBg = target.style.backgroundColor;
+        target.style.backgroundColor = 'rgba(106, 169, 255, 0.2)';
+        setTimeout(() => {
+          target.style.backgroundColor = originalBg;
+        }, 1000);
+      });
+    }
+  });
+  
+  console.log(`\n=== LINK VERIFICATION ===`);
+  console.log(`✓ Working: ${working}/${links.length}`);
+  console.log(`✗ Broken: ${broken.length}`);
+  if (broken.length > 0) {
+    console.error('Broken links:', broken);
+  }
+  console.log('==========================\n');
+}
+
 // Initialize everything when DOM is ready
 function init() {
   initCategories();
@@ -502,6 +656,17 @@ function init() {
   setTimeout(() => {
     initLinearRegression();
   }, 100);
+  
+  // Verify all links on load
+  setTimeout(verifyAllLinks, 1000);
+  
+  // Initialize diagnostics refresh
+  setInterval(() => {
+    const diagSection = document.getElementById('diagnostics');
+    if (diagSection && diagSection.querySelector('.section-body').classList.contains('expanded')) {
+      showDiagnostics();
+    }
+  }, 3000);
 }
 
 if (document.readyState === 'loading') {
@@ -557,7 +722,10 @@ function initSVMBasic() {
 
 function drawSVMBasic() {
   const canvas = document.getElementById('svm-basic-canvas');
-  if (!canvas) return;
+  if (!canvas) {
+    logViz('SVM', 'Basic Decision Boundary', 'failed', 'Canvas not found');
+    return;
+  }
   
   const ctx = canvas.getContext('2d');
   if (!ctx) {
@@ -661,6 +829,8 @@ function drawSVMBasic() {
   ctx.font = '13px sans-serif';
   ctx.textAlign = 'center';
   ctx.fillText('X₁', width / 2, height - 20);
+  
+  logViz('SVM', 'Basic Decision Boundary', 'success');
   ctx.save();
   ctx.translate(20, height / 2);
   ctx.rotate(-Math.PI / 2);
@@ -683,7 +853,10 @@ function initSVMMargin() {
 
 function drawSVMMargin() {
   const canvas = document.getElementById('svm-margin-canvas');
-  if (!canvas) return;
+  if (!canvas) {
+    logViz('SVM', 'Margin Visualization', 'failed', 'Canvas not found');
+    return;
+  }
   
   const ctx = canvas.getContext('2d');
   if (!ctx) {
@@ -804,11 +977,9 @@ let svmCChart = null;
 
 function drawSVMCParameter() {
   const canvas = document.getElementById('svm-c-canvas');
-  if (!canvas) return;
-  
-  // Destroy existing chart
-  if (svmCChart) {
-    svmCChart.destroy();
+  if (!canvas) {
+    logViz('SVM', 'C Parameter Effect', 'failed', 'Canvas not found');
+    return;
   }
   
   const ctx = canvas.getContext('2d');
@@ -902,6 +1073,8 @@ function drawSVMCParameter() {
   const violEl = document.getElementById('violations-count');
   if (marginEl) marginEl.textContent = marginWidth.toFixed(2);
   if (violEl) violEl.textContent = violations;
+  
+  logViz('SVM', 'Margin Visualization', 'success');
 }
 
 function initSVMTraining() {
@@ -992,7 +1165,10 @@ function updateTrainingInfo(point = null, violation = null) {
 
 function drawSVMTraining() {
   const canvas = document.getElementById('svm-train-canvas');
-  if (!canvas) return;
+  if (!canvas) {
+    logViz('SVM', 'Training Animation', 'failed', 'Canvas not found');
+    return;
+  }
   
   const ctx = canvas.getContext('2d');
   if (!ctx) {
@@ -1060,6 +1236,8 @@ function drawSVMTraining() {
     ctx.textAlign = 'center';
     ctx.fillText(point.label, x, y - 15);
   });
+  
+  logViz('SVM', 'Training Animation', 'success');
 }
 
 let svmKernelChart = null;
@@ -1096,7 +1274,10 @@ function initSVMKernel() {
 
 function drawSVMKernel() {
   const canvas = document.getElementById('svm-kernel-canvas');
-  if (!canvas) return;
+  if (!canvas) {
+    logViz('SVM', 'Kernel Comparison', 'failed', 'Canvas not found');
+    return;
+  }
   
   const ctx = canvas.getContext('2d');
   const width = canvas.width = canvas.offsetWidth;
@@ -1180,6 +1361,8 @@ function drawSVMKernel() {
     ctx.fillStyle = '#7ef0d4';
     ctx.fillText('✓ Non-linear kernel successfully separates the data', padding + 10, padding + 50);
   }
+  
+  logViz('SVM', 'Kernel Comparison', 'success');
 }
 
 // Logistic Regression Visualizations
@@ -1197,7 +1380,10 @@ function initSigmoid() {
 
 function drawSigmoid() {
   const canvas = document.getElementById('sigmoid-canvas');
-  if (!canvas) return;
+  if (!canvas) {
+    logViz('Logistic Regression', 'Sigmoid Curve', 'failed', 'Canvas not found');
+    return;
+  }
   
   const ctx = canvas.getContext('2d');
   const width = canvas.width = canvas.offsetWidth;
@@ -1281,6 +1467,8 @@ function drawSigmoid() {
   ctx.fillText('σ(z) = 1/(1+e⁻ᶻ)', padding + 10, padding + 25);
   ctx.fillStyle = '#ff8c6a';
   ctx.fillText('Threshold = 0.5', padding + 10, scaleY(0.5) - 10);
+  
+  logViz('Logistic Regression', 'Sigmoid Curve', 'success');
 }
 
 function initLogisticClassification() {
@@ -1292,7 +1480,10 @@ function initLogisticClassification() {
 
 function drawLogisticClassification() {
   const canvas = document.getElementById('logistic-canvas');
-  if (!canvas) return;
+  if (!canvas) {
+    logViz('Logistic Regression', 'Classification Boundary', 'failed', 'Canvas not found');
+    return;
+  }
   
   const ctx = canvas.getContext('2d');
   const width = canvas.width = canvas.offsetWidth;
@@ -1350,6 +1541,8 @@ function drawLogisticClassification() {
     ctx.fillText(point.height, x, height - padding + 20);
   });
   
+  logViz('Logistic Regression', 'Classification Boundary', 'success');
+  
   // Labels
   ctx.fillStyle = '#a9b4c2';
   ctx.font = '12px sans-serif';
@@ -1436,7 +1629,10 @@ function stopDragKNN() {
 
 function drawKNN() {
   const canvas = document.getElementById('knn-canvas');
-  if (!canvas) return;
+  if (!canvas) {
+    logViz('KNN', 'Draggable Point', 'failed', 'Canvas not found');
+    return;
+  }
   
   const ctx = canvas.getContext('2d');
   const width = canvas.width = canvas.offsetWidth;
@@ -1524,6 +1720,8 @@ function drawKNN() {
   ctx.textAlign = 'left';
   ctx.fillText(`K=${knnState.k} | Prediction: ${prediction}`, padding + 10, padding + 25);
   ctx.fillText(`Votes: Orange=${votes.orange || 0}, Yellow=${votes.yellow || 0}`, padding + 10, padding + 50);
+  
+  logViz('KNN', 'Draggable Point', 'success');
 }
 
 // Model Evaluation
@@ -1542,7 +1740,10 @@ function initConfusionMatrix() {
 
 function drawConfusionMatrix() {
   const canvas = document.getElementById('confusion-canvas');
-  if (!canvas) return;
+  if (!canvas) {
+    logViz('Model Evaluation', 'Confusion Matrix', 'failed', 'Canvas not found');
+    return;
+  }
   
   const ctx = canvas.getContext('2d');
   const width = canvas.width = canvas.offsetWidth;
@@ -1598,6 +1799,8 @@ function drawConfusionMatrix() {
   ctx.rotate(-Math.PI / 2);
   ctx.fillText('Actual Negative', 0, 0);
   ctx.restore();
+  
+  logViz('Model Evaluation', 'Confusion Matrix', 'success');
 }
 
 let rocState = { threshold: 0.5 };
@@ -1621,7 +1824,10 @@ function initROC() {
 
 function drawROC() {
   const canvas = document.getElementById('roc-canvas');
-  if (!canvas) return;
+  if (!canvas) {
+    logViz('Model Evaluation', 'ROC Curve', 'failed', 'Canvas not found');
+    return;
+  }
   
   const ctx = canvas.getContext('2d');
   const width = canvas.width = canvas.offsetWidth;
@@ -1718,6 +1924,8 @@ function drawROC() {
   ctx.textAlign = 'left';
   ctx.fillText(`TPR: ${tpr.toFixed(2)} | FPR: ${fpr.toFixed(2)}`, chartX + 10, chartY + 25);
   ctx.fillText(`TP=${tp} FP=${fp} TN=${tn} FN=${fn}`, chartX + 10, chartY + 50);
+  
+  logViz('Model Evaluation', 'ROC Curve', 'success');
 }
 
 function initR2() {
@@ -1729,7 +1937,10 @@ function initR2() {
 
 function drawR2() {
   const canvas = document.getElementById('r2-canvas');
-  if (!canvas) return;
+  if (!canvas) {
+    logViz('Model Evaluation', 'R² Score', 'failed', 'Canvas not found');
+    return;
+  }
   
   const ctx = canvas.getContext('2d');
   const width = canvas.width = canvas.offsetWidth;
@@ -1808,6 +2019,8 @@ function drawR2() {
   ctx.textAlign = 'left';
   ctx.fillText(`R² = ${r2.toFixed(3)}`, padding + 10, padding + 25);
   ctx.fillText(`Model explains ${(r2 * 100).toFixed(1)}% of variance`, padding + 10, padding + 50);
+  
+  logViz('Model Evaluation', 'R² Score', 'success');
 }
 
 // Regularization
@@ -1832,7 +2045,10 @@ function initRegularization() {
 
 function drawRegularization() {
   const canvas = document.getElementById('regularization-canvas');
-  if (!canvas) return;
+  if (!canvas) {
+    logViz('Regularization', 'L1 vs L2 Comparison', 'failed', 'Canvas not found');
+    return;
+  }
   
   const ctx = canvas.getContext('2d');
   const width = canvas.width = canvas.offsetWidth;
@@ -1899,6 +2115,8 @@ function drawRegularization() {
   ctx.fillRect(padding + 210, legendY, 15, 15);
   ctx.fillStyle = '#e8eef6';
   ctx.fillText('L2 (Ridge)', padding + 230, legendY + 12);
+  
+  logViz('Regularization', 'L1 vs L2 Comparison', 'success');
 }
 
 // Bias-Variance
@@ -1917,7 +2135,10 @@ function initBiasVariance() {
 
 function drawBiasVariance() {
   const canvas = document.getElementById('bias-variance-canvas');
-  if (!canvas) return;
+  if (!canvas) {
+    logViz('Bias-Variance', 'Three Models', 'failed', 'Canvas not found');
+    return;
+  }
   
   const ctx = canvas.getContext('2d');
   const width = canvas.width = canvas.offsetWidth;
@@ -1993,11 +2214,16 @@ function drawBiasVariance() {
       ctx.fillText(line, offsetX + sectionWidth / 2, 20 + i * 18);
     });
   });
+  
+  logViz('Bias-Variance', 'Three Models', 'success');
 }
 
 function drawComplexityCurve() {
   const canvas = document.getElementById('complexity-canvas');
-  if (!canvas) return;
+  if (!canvas) {
+    logViz('Bias-Variance', 'Complexity Curve', 'failed', 'Canvas not found');
+    return;
+  }
   
   const ctx = canvas.getContext('2d');
   const width = canvas.width = canvas.offsetWidth;
@@ -2050,6 +2276,8 @@ function drawComplexityCurve() {
   ctx.fillStyle = '#7ef0d4';
   ctx.fillText('● Sweet Spot', padding + 10, padding + 60);
   
+  logViz('Bias-Variance', 'Complexity Curve', 'success');
+  
   // Labels
   ctx.fillStyle = '#a9b4c2';
   ctx.textAlign = 'center';
@@ -2071,7 +2299,10 @@ function initCrossValidation() {
 
 function drawCrossValidation() {
   const canvas = document.getElementById('cv-canvas');
-  if (!canvas) return;
+  if (!canvas) {
+    logViz('Cross-Validation', 'K-Fold Visualization', 'failed', 'Canvas not found');
+    return;
+  }
   
   const ctx = canvas.getContext('2d');
   const width = canvas.width = canvas.offsetWidth;
@@ -2142,6 +2373,8 @@ function drawCrossValidation() {
   ctx.font = 'bold 16px sans-serif';
   ctx.textAlign = 'center';
   ctx.fillText(`Final Score: ${mean.toFixed(2)} ± ${std.toFixed(3)}`, width / 2, height - 20);
+  
+  logViz('Cross-Validation', 'K-Fold Visualization', 'success');
 }
 
 // Preprocessing
@@ -2161,7 +2394,10 @@ function initPreprocessing() {
 
 function drawScaling() {
   const canvas = document.getElementById('scaling-canvas');
-  if (!canvas) return;
+  if (!canvas) {
+    logViz('Preprocessing', 'Feature Scaling', 'failed', 'Canvas not found');
+    return;
+  }
   
   const ctx = canvas.getContext('2d');
   const width = canvas.width = canvas.offsetWidth;
@@ -2213,11 +2449,16 @@ function drawScaling() {
       centerX += 35;
     });
   });
+  
+  logViz('Preprocessing', 'Feature Scaling', 'success');
 }
 
 function drawPipeline() {
   const canvas = document.getElementById('pipeline-canvas');
-  if (!canvas) return;
+  if (!canvas) {
+    logViz('Preprocessing', 'Pipeline Flow', 'failed', 'Canvas not found');
+    return;
+  }
   
   const ctx = canvas.getContext('2d');
   const width = canvas.width = canvas.offsetWidth;
@@ -2268,6 +2509,8 @@ function drawPipeline() {
       ctx.fill();
     }
   });
+  
+  logViz('Preprocessing', 'Pipeline Flow', 'success');
 }
 
 // Loss Functions
@@ -2287,7 +2530,10 @@ function initLossFunctions() {
 
 function drawLossComparison() {
   const canvas = document.getElementById('loss-comparison-canvas');
-  if (!canvas) return;
+  if (!canvas) {
+    logViz('Loss Functions', 'Loss Comparison', 'failed', 'Canvas not found');
+    return;
+  }
   
   const ctx = canvas.getContext('2d');
   const width = canvas.width = canvas.offsetWidth;
@@ -2350,11 +2596,16 @@ function drawLossComparison() {
   ctx.font = 'bold 16px sans-serif';
   ctx.textAlign = 'center';
   ctx.fillText('Regression Loss Comparison', width / 2, 50);
+  
+  logViz('Loss Functions', 'Loss Comparison', 'success');
 }
 
 function drawLossCurves() {
   const canvas = document.getElementById('loss-curves-canvas');
-  if (!canvas) return;
+  if (!canvas) {
+    logViz('Loss Functions', 'Loss Curves', 'failed', 'Canvas not found');
+    return;
+  }
   
   const ctx = canvas.getContext('2d');
   const width = canvas.width = canvas.offsetWidth;
@@ -2410,6 +2661,8 @@ function drawLossCurves() {
   ctx.rotate(-Math.PI / 2);
   ctx.fillText('Loss', 0, 0);
   ctx.restore();
+  
+  logViz('Loss Functions', 'Loss Curves', 'success');
 }
 
 // Topic 13: Finding Optimal K in KNN
@@ -2469,7 +2722,12 @@ function drawElbowCurve() {
   }
   
   // Use Chart.js
-  elbowChart = new Chart(ctx, {
+  // Destroy existing chart
+  if (elbowChart) {
+    elbowChart.destroy();
+  }
+  
+  elbowChart = createVerifiedVisualization('elbow-canvas', {
     type: 'line',
     data: {
       labels: kValues,
@@ -2528,12 +2786,15 @@ function drawElbowCurve() {
         }
       }
     }
-  }, 'Elbow Chart');
+  }, 'KNN', 'Elbow Method');
 }
 
 function drawCVKHeatmap() {
   const canvas = document.getElementById('cv-k-canvas');
-  if (!canvas) return;
+  if (!canvas) {
+    logViz('Optimal K', 'CV Heatmap', 'failed', 'Canvas not found');
+    return;
+  }
   
   const ctx = canvas.getContext('2d');
   const width = canvas.width = canvas.offsetWidth;
@@ -2612,6 +2873,8 @@ function drawCVKHeatmap() {
   const maxMean = Math.max(...meanAccs);
   const optIdx = meanAccs.indexOf(maxMean);
   ctx.fillText(`Best K = ${kValues[optIdx]} (Mean Acc: ${maxMean.toFixed(3)})`, padding, height - 20);
+  
+  logViz('Optimal K', 'CV Heatmap', 'success');
 }
 
 // Topic 14: Hyperparameter Tuning
@@ -2640,11 +2903,9 @@ function initHyperparameterTuning() {
 
 function drawGridSearchHeatmap() {
   const canvas = document.getElementById('gridsearch-heatmap');
-  if (!canvas) return;
-  
-  // Destroy existing chart
-  if (gridSearchChart) {
-    gridSearchChart.destroy();
+  if (!canvas) {
+    logViz('Hyperparameter Tuning', 'GridSearch Heatmap', 'failed', 'Canvas not found');
+    return;
   }
   
   const ctx = canvas.getContext('2d');
@@ -2763,11 +3024,16 @@ function drawGridSearchHeatmap() {
   ctx.font = 'bold 14px sans-serif';
   ctx.textAlign = 'left';
   ctx.fillText(`Best: C=${cValues[bestJ]}, γ=${gammaValues[bestI]} → Acc=${bestAcc.toFixed(2)}`, padding, height - 30);
+  
+  logViz('Hyperparameter Tuning', 'GridSearch Heatmap', 'success');
 }
 
 function drawParamSurface() {
   const canvas = document.getElementById('param-surface');
-  if (!canvas) return;
+  if (!canvas) {
+    logViz('Hyperparameter Tuning', 'Parameter Surface', 'failed', 'Canvas not found');
+    return;
+  }
   
   const ctx = canvas.getContext('2d');
   const width = canvas.width = canvas.offsetWidth;
@@ -2826,6 +3092,8 @@ function drawParamSurface() {
   ctx.font = 'bold 16px sans-serif';
   ctx.textAlign = 'center';
   ctx.fillText('Performance Surface (3D Contour View)', width / 2, 30);
+  
+  logViz('Hyperparameter Tuning', 'Parameter Surface', 'success');
 }
 
 // Topic 15: Naive Bayes
@@ -2861,7 +3129,10 @@ function initNaiveBayes() {
 
 function drawBayesTheorem() {
   const canvas = document.getElementById('bayes-theorem-viz');
-  if (!canvas) return;
+  if (!canvas) {
+    logViz('Naive Bayes', 'Bayes Theorem Flow', 'failed', 'Canvas not found');
+    return;
+  }
   
   const ctx = canvas.getContext('2d');
   const width = canvas.width = canvas.offsetWidth;
@@ -2923,7 +3194,11 @@ function drawCategoricalNB() {
   
   const ctx = canvas.getContext('2d');
   
-  categoricalNBChart = safeCreateChart(ctx, {
+  if (categoricalNBChart) {
+    categoricalNBChart.destroy();
+  }
+  
+  categoricalNBChart = createVerifiedVisualization('categorical-nb-canvas', {
     type: 'bar',
     data: {
       labels: ['P(Yes|Rainy,Hot)', 'P(No|Rainy,Hot)'],
@@ -2975,12 +3250,15 @@ function drawCategoricalNB() {
         }
       }
     }
-  }, 'Categorical Naive Bayes Chart');
+  }, 'Naive Bayes', 'Categorical Calculation');
 }
 
 function drawGaussianNB() {
   const canvas = document.getElementById('gaussian-nb-canvas');
-  if (!canvas) return;
+  if (!canvas) {
+    logViz('Naive Bayes', 'Gaussian NB Boundary', 'failed', 'Canvas not found');
+    return;
+  }
   
   const ctx = canvas.getContext('2d');
   const width = canvas.width = canvas.offsetWidth;
@@ -3088,6 +3366,8 @@ function drawGaussianNB() {
   
   ctx.fillStyle = '#6aa9ff';
   ctx.fillText('| Decision Boundary', padding + 210, 35);
+  
+  logViz('Naive Bayes', 'Gaussian NB Boundary', 'success');
 }
 
 function drawSpamClassification() {
@@ -3157,7 +3437,11 @@ function drawSpamClassification() {
     compCanvas.style.marginTop = '20px';
     canvas.parentElement.appendChild(compCanvas);
     
-    bayesComparisonChart = safeCreateChart(compCanvas.getContext('2d'), {
+    if (bayesComparisonChart) {
+      bayesComparisonChart.destroy();
+    }
+    
+    bayesComparisonChart = createVerifiedVisualization('bayes-comparison-chart', {
       type: 'bar',
       data: {
         labels: ['Spam Probability', 'Not-Spam Probability'],
@@ -3193,9 +3477,11 @@ function drawSpamClassification() {
           }
         }
       }
-    }, 'Bayes Comparison Chart');
+    }, 'Naive Bayes', 'Spam Classification');
     if (bayesComparisonChart) compCanvas.style.height = '150px';
   }
+  
+  logViz('Naive Bayes', 'Bayes Theorem Flow', 'success');
 }
 
 // Topic 16: Decision Trees
@@ -3227,7 +3513,10 @@ function initDecisionTrees() {
 
 function drawDecisionTree() {
   const canvas = document.getElementById('decision-tree-viz');
-  if (!canvas) return;
+  if (!canvas) {
+    logViz('Decision Trees', 'Tree Structure', 'failed', 'Canvas not found');
+    return;
+  }
   
   const ctx = canvas.getContext('2d');
   const width = canvas.width = canvas.offsetWidth;
@@ -3311,6 +3600,8 @@ function drawDecisionTree() {
   ctx.font = '12px sans-serif';
   ctx.textAlign = 'left';
   ctx.fillText('Example: Email with "free" + link → SPAM', 40, height - 20);
+  
+  logViz('Decision Trees', 'Tree Structure', 'success');
 }
 
 function drawSplitComparison() {
@@ -3368,6 +3659,8 @@ function drawSplitComparison() {
   ctx.textAlign = 'center';
   ctx.fillText('✓ Best split: Highest Information Gain!', width / 2, height - 30);
   
+  logViz('Decision Trees', 'Information Gain', 'success');
+  
   // Title
   ctx.fillStyle = '#7ef0d4';
   ctx.font = 'bold 16px sans-serif';
@@ -3376,7 +3669,10 @@ function drawSplitComparison() {
 
 function drawEntropyViz() {
   const canvas = document.getElementById('entropy-viz');
-  if (!canvas) return;
+  if (!canvas) {
+    logViz('Decision Trees', 'Entropy Visualization', 'failed', 'Canvas not found');
+    return;
+  }
   
   const ctx = canvas.getContext('2d');
   const width = canvas.width = canvas.offsetWidth;
@@ -3454,6 +3750,8 @@ function drawEntropyViz() {
   ctx.font = 'bold 16px sans-serif';
   ctx.textAlign = 'center';
   ctx.fillText('Entropy: Measuring Disorder', width / 2, 30);
+  
+  logViz('Decision Trees', 'Entropy Visualization', 'success');
 }
 
 function drawSplitComparison() {
@@ -3601,7 +3899,10 @@ function drawEntropyViz() {
 
 function drawTreeBoundary() {
   const canvas = document.getElementById('tree-boundary');
-  if (!canvas) return;
+  if (!canvas) {
+    logViz('Decision Trees', 'Decision Regions', 'failed', 'Canvas not found');
+    return;
+  }
   
   const ctx = canvas.getContext('2d');
   const width = canvas.width = canvas.offsetWidth;
@@ -3686,80 +3987,1255 @@ function drawTreeBoundary() {
   ctx.font = 'bold 16px sans-serif';
   ctx.textAlign = 'center';
   ctx.fillText('Decision Tree Creates Rectangular Regions', width / 2, 30);
+  
+  logViz('Decision Trees', 'Decision Regions', 'success');
 }
 
-// Topic 17: Ensemble Methods
-function initEnsembleMethods() {
-  const canvas1 = document.getElementById('bagging-viz');
+// Topic 16b: Decision Tree Regression Visualization
+function initDecisionTreeRegression() {
+  const canvas1 = document.getElementById('dt-regression-canvas');
   if (canvas1 && !canvas1.dataset.initialized) {
     canvas1.dataset.initialized = 'true';
-    drawBaggingViz();
+    drawDTRegression();
   }
   
-  const canvas2 = document.getElementById('boosting-viz');
+  const canvas2 = document.getElementById('dt-splits-canvas');
   if (canvas2 && !canvas2.dataset.initialized) {
     canvas2.dataset.initialized = 'true';
-    drawBoostingViz();
-  }
-  
-  const canvas3 = document.getElementById('random-forest-viz');
-  if (canvas3 && !canvas3.dataset.initialized) {
-    canvas3.dataset.initialized = 'true';
-    drawRandomForestViz();
+    drawDTSplits();
   }
 }
 
-function drawBaggingViz() {
-  const canvas = document.getElementById('bagging-viz');
-  if (!canvas) return;
+function drawDTRegression() {
+  const canvas = document.getElementById('dt-regression-canvas');
+  if (!canvas) {
+    logViz('Decision Tree Regression', 'Splits & Predictions', 'failed', 'Canvas not found');
+    return;
+  }
   
   const ctx = canvas.getContext('2d');
   const width = canvas.width = canvas.offsetWidth;
-  const height = canvas.height = 400;
+  const height = canvas.height = 450;
   
   ctx.clearRect(0, 0, width, height);
   ctx.fillStyle = '#1a2332';
   ctx.fillRect(0, 0, width, height);
   
-  const boxWidth = 150;
-  const boxHeight = 60;
-  const startY = 60;
-  const spacing = (width - 3 * boxWidth) / 4;
+  const padding = 60;
+  const chartWidth = width - 2 * padding;
+  const chartHeight = height - 2 * padding;
   
-  // Original data
-  ctx.fillStyle = '#6aa9ff33';
-  ctx.fillRect(width / 2 - 100, startY, 200, boxHeight);
+  const xMin = 700, xMax = 1800;
+  const yMin = 40, yMax = 110;
+  const scaleX = (x) => padding + ((x - xMin) / (xMax - xMin)) * chartWidth;
+  const scaleY = (y) => height - padding - ((y - yMin) / (yMax - yMin)) * chartHeight;
+  
+  // Data points
+  const data = [
+    {x: 800, y: 50}, {x: 850, y: 52}, {x: 900, y: 54},
+    {x: 1500, y: 90}, {x: 1600, y: 95}, {x: 1700, y: 100}
+  ];
+  
+  // Draw decision boundaries
   ctx.strokeStyle = '#6aa9ff';
-  ctx.lineWidth = 2;
-  ctx.strokeRect(width / 2 - 100, startY, 200, boxHeight);
-  ctx.fillStyle = '#e8eef6';
-  ctx.font = 'bold 14px sans-serif';
-  ctx.textAlign = 'center';
-  ctx.fillText('Original Dataset', width / 2, startY + boxHeight / 2 + 5);
+  ctx.lineWidth = 3;
+  ctx.setLineDash([5, 5]);
+  ctx.beginPath();
+  ctx.moveTo(scaleX(1200), padding);
+  ctx.lineTo(scaleX(1200), height - padding);
+  ctx.stroke();
   
-  // Bootstrap samples
-  const sampleY = startY + boxHeight + 60;
-  for (let i = 0; i < 3; i++) {
-    const x = spacing + i * (boxWidth + spacing);
-    
-    // Arrow
-    ctx.strokeStyle = '#7ef0d4';
-    ctx.lineWidth = 2;
-    ctx.beginPath();
-    ctx.moveTo(width / 2, startY + boxHeight);
-    ctx.lineTo(x + boxWidth / 2, sampleY);
-    ctx.stroke();
-    
-    // Sample box
-    ctx.fillStyle = '#7ef0d433';
-    ctx.fillRect(x, sampleY, boxWidth, boxHeight);
-    ctx.strokeStyle = '#7ef0d4';
-    ctx.strokeRect(x, sampleY, boxWidth, boxHeight);
-    
-    ctx.fillStyle = '#e8eef6';
-    ctx.font = 'bold 12px sans-serif';
-    ctx.fillText(`Bootstrap ${i + 1}`, x + boxWidth / 2, sampleY + boxHeight / 2 - 5);
-    ctx.font = '10px sans-serif';
+  ctx.beginPath();
+  ctx.moveTo(scaleX(1550), padding);
+  ctx.lineTo(scaleX(1550), height - padding);
+  ctx.stroke();
+  ctx.setLineDash([]);
+  
+  // Draw regions with predictions
+  ctx.fillStyle = 'rgba(126, 240, 212, 0.1)';
+  ctx.fillRect(scaleX(700), scaleY(52), scaleX(1200) - scaleX(700), height - padding - scaleY(52));
+  ctx.fillStyle = 'rgba(255, 140, 106, 0.1)';
+  ctx.fillRect(scaleX(1200), scaleY(90), scaleX(1550) - scaleX(1200), height - padding - scaleY(90));
+  ctx.fillStyle = 'rgba(106, 169, 255, 0.1)';
+  ctx.fillRect(scaleX(1550), scaleY(97.5), scaleX(1800) - scaleX(1550), height - padding - scaleY(97.5));
+  
+  // Draw prediction lines
+  ctx.strokeStyle = '#7ef0d4';
+  ctx.lineWidth = 4;
+  ctx.beginPath();
+  ctx.moveTo(scaleX(700), scaleY(52));
+  ctx.lineTo(scaleX(1200), scaleY(52));
+  ctx.stroke();
+  
+  ctx.strokeStyle = '#ff8c6a';
+  ctx.beginPath();
+  ctx.moveTo(scaleX(1200), scaleY(90));
+  ctx.lineTo(scaleX(1550), scaleY(90));
+  ctx.stroke();
+  
+  ctx.strokeStyle = '#6aa9ff';
+  ctx.beginPath();
+  ctx.moveTo(scaleX(1550), scaleY(97.5));
+  ctx.lineTo(scaleX(1800), scaleY(97.5));
+  ctx.stroke();
+  
+  // Draw data points
+  data.forEach(point => {
+    ctx.fillStyle = '#e8eef6';
+    ctx.beginPath();
+    ctx.arc(scaleX(point.x), scaleY(point.y), 6, 0, 2 * Math.PI);
+    ctx.fill();
+    ctx.strokeStyle = '#1a2332';
+    ctx.lineWidth = 2;
+    ctx.stroke();
+  });
+  
+  // Labels
+  ctx.fillStyle = '#7ef0d4';
+  ctx.font = 'bold 13px sans-serif';
+  ctx.textAlign = 'center';
+  ctx.fillText('Predict: ₹52L', scaleX(950), scaleY(52) - 10);
+  ctx.fillStyle = '#ff8c6a';
+  ctx.fillText('Predict: ₹90L', scaleX(1375), scaleY(90) - 10);
+  ctx.fillStyle = '#6aa9ff';
+  ctx.fillText('Predict: ₹97.5L', scaleX(1650), scaleY(97.5) - 10);
+  
+  // Axes
+  ctx.fillStyle = '#a9b4c2';
+  ctx.font = '12px sans-serif';
+  ctx.textAlign = 'center';
+  ctx.fillText('Square Feet', width / 2, height - 20);
+  ctx.save();
+  ctx.translate(20, height / 2);
+  ctx.rotate(-Math.PI / 2);
+  ctx.fillText('Price (Lakhs)', 0, 0);
+  ctx.restore();
+  
+  ctx.fillStyle = '#7ef0d4';
+  ctx.font = 'bold 14px sans-serif';
+  ctx.fillText('Split at 1200', scaleX(1200), 30);
+  ctx.fillText('Split at 1550', scaleX(1550), 30);
+  
+  logViz('Decision Tree Regression', 'Splits & Predictions', 'success');
+}
+
+function drawDTSplits() {
+  const canvas = document.getElementById('dt-splits-canvas');
+  if (!canvas) {
+    logViz('Decision Tree Regression', 'Split Comparison', 'failed', 'Canvas not found');
+    return;
+  }
+  
+  const ctx = canvas.getContext('2d');
+  const width = canvas.width = canvas.offsetWidth;
+  const height = canvas.height = 400;
+  
+  ctx.clearRect(0, 0, width, height);
+  ctx.fillStyle = '#1a2332';
+  ctx.fillRect(0, 0, width, height);
+  
+  const splits = [
+    {value: 825, varReduction: 120, color: '#ff8c6a'},
+    {value: 875, varReduction: 180, color: '#ffb490'},
+    {value: 1200, varReduction: 462.25, color: '#7ef0d4'},
+    {value: 1550, varReduction: 95, color: '#ffb490'},
+    {value: 1650, varReduction: 65, color: '#ff8c6a'}
+  ];
+  
+  const padding = 60;
+  const barHeight = 50;
+  const maxWidth = width - 2 * padding - 200;
+  const maxVR = Math.max(...splits.map(s => s.varReduction));
+  
+  splits.forEach((split, i) => {
+    const y = 60 + i * (barHeight + 25);
+    const barWidth = (split.varReduction / maxVR) * maxWidth;
+    
+    ctx.fillStyle = split.color;
+    ctx.fillRect(padding, y, barWidth, barHeight);
+    ctx.strokeStyle = split.color;
+    ctx.lineWidth = 2;
+    ctx.strokeRect(padding, y, barWidth, barHeight);
+    
+    ctx.fillStyle = '#e8eef6';
+    ctx.font = 'bold 12px sans-serif';
+    ctx.textAlign = 'left';
+    ctx.fillText(`Split at ${split.value}`, padding, y - 8);
+    
+    ctx.fillStyle = '#1a2332';
+    ctx.font = 'bold 14px sans-serif';
+    ctx.textAlign = 'center';
+    ctx.fillText(`VR = ${split.varReduction.toFixed(1)}`, padding + barWidth / 2, y + barHeight / 2 + 5);
+  });
+  
+  ctx.fillStyle = '#7ef0d4';
+  ctx.font = 'bold 16px sans-serif';
+  ctx.textAlign = 'center';
+  ctx.fillText('✓ Split at 1200: Maximum Variance Reduction!', width / 2, height - 20);
+  
+  logViz('Decision Tree Regression', 'Split Comparison', 'success');
+}
+
+// Topic 17a: Gradient Boosting (NEW)
+function initGradientBoosting() {
+  const canvases = [
+    { id: 'gb-sequential-canvas', fn: drawGBSequential },
+    { id: 'gb-residuals-canvas', fn: drawGBResiduals },
+    { id: 'gb-learning-rate-canvas', fn: drawGBLearningRate },
+    { id: 'gb-stumps-canvas', fn: drawGBStumps },
+    { id: 'gb-predictions-canvas', fn: drawGBPredictions }
+  ];
+  
+  canvases.forEach(c => {
+    const canvas = document.getElementById(c.id);
+    if (canvas && !canvas.dataset.initialized) {
+      canvas.dataset.initialized = 'true';
+      c.fn();
+    }
+  });
+}
+
+function drawGBSequential() {
+  const canvas = document.getElementById('gb-sequential-canvas');
+  if (!canvas) return;
+  
+  const gbData = [
+    { iteration: 0, f: 154, residual: 29.6 },
+    { iteration: 1, f: 151.93, residual: 26.8 },
+    { iteration: 2, f: 149.5, residual: 24.1 },
+    { iteration: 3, f: 147.2, residual: 21.5 },
+    { iteration: 4, f: 145.1, residual: 19.2 },
+    { iteration: 5, f: 143.2, residual: 17.1 },
+    { iteration: 6, f: 141.5, residual: 15.3 },
+    { iteration: 7, f: 140.0, residual: 13.7 },
+    { iteration: 8, f: 138.6, residual: 12.2 },
+    { iteration: 9, f: 137.4, residual: 10.9 },
+    { iteration: 10, f: 136.3, residual: 9.8 }
+  ];
+  
+  createVerifiedVisualization('gb-sequential-canvas', {
+    type: 'line',
+    data: {
+      datasets: [
+        {
+          label: 'Mean Prediction F(t)',
+          data: gbData.map(d => ({ x: d.iteration, y: d.f })),
+          borderColor: '#6aa9ff',
+          backgroundColor: 'rgba(106, 169, 255, 0.1)',
+          borderWidth: 3,
+          fill: true,
+          yAxisID: 'y'
+        },
+        {
+          label: 'Mean Absolute Residual',
+          data: gbData.map(d => ({ x: d.iteration, y: d.residual })),
+          borderColor: '#ff8c6a',
+          backgroundColor: 'rgba(255, 140, 106, 0.1)',
+          borderWidth: 3,
+          fill: true,
+          yAxisID: 'y1'
+        }
+      ]
+    },
+    options: {
+      responsive: true,
+      maintainAspectRatio: false,
+      plugins: {
+        title: {
+          display: true,
+          text: 'Gradient Boosting: Sequential Learning',
+          color: '#e8eef6',
+          font: { size: 16 }
+        },
+        legend: { labels: { color: '#a9b4c2' } }
+      },
+      scales: {
+        x: {
+          title: { display: true, text: 'Iteration', color: '#a9b4c2' },
+          grid: { color: '#2a3544' },
+          ticks: { color: '#a9b4c2' }
+        },
+        y: {
+          type: 'linear',
+          position: 'left',
+          title: { display: true, text: 'Prediction F(t)', color: '#6aa9ff' },
+          grid: { color: '#2a3544' },
+          ticks: { color: '#a9b4c2' }
+        },
+        y1: {
+          type: 'linear',
+          position: 'right',
+          title: { display: true, text: 'Residual', color: '#ff8c6a' },
+          grid: { display: false },
+          ticks: { color: '#a9b4c2' }
+        }
+      }
+    }
+  }, 'Gradient Boosting', 'Sequential Trees');
+}
+
+function drawGBResiduals() {
+  const canvas = document.getElementById('gb-residuals-canvas');
+  if (!canvas) return;
+  
+  const residuals = [
+    { id: 1, iter0: -34, iter1: -31.93, iter5: -12, iter10: -3 },
+    { id: 2, iter0: -24, iter1: -21.93, iter5: -8, iter10: -2 },
+    { id: 3, iter0: -4, iter1: -1.93, iter5: -1, iter10: 0 },
+    { id: 4, iter0: 16, iter1: 12.90, iter5: 5, iter10: 1 },
+    { id: 5, iter0: 46, iter1: 42.90, iter5: 18, iter10: 4 }
+  ];
+  
+  createVerifiedVisualization('gb-residuals-canvas', {
+    type: 'bar',
+    data: {
+      labels: ['ID 1', 'ID 2', 'ID 3', 'ID 4', 'ID 5'],
+      datasets: [
+        {
+          label: 'Iteration 0',
+          data: residuals.map(r => r.iter0),
+          backgroundColor: '#ff8c6a'
+        },
+        {
+          label: 'Iteration 1',
+          data: residuals.map(r => r.iter1),
+          backgroundColor: '#ffb490'
+        },
+        {
+          label: 'Iteration 5',
+          data: residuals.map(r => r.iter5),
+          backgroundColor: '#6aa9ff'
+        },
+        {
+          label: 'Iteration 10',
+          data: residuals.map(r => r.iter10),
+          backgroundColor: '#7ef0d4'
+        }
+      ]
+    },
+    options: {
+      responsive: true,
+      maintainAspectRatio: false,
+      plugins: {
+        title: {
+          display: true,
+          text: 'Residual Reduction Over Iterations',
+          color: '#e8eef6',
+          font: { size: 16 }
+        },
+        legend: { labels: { color: '#a9b4c2' } }
+      },
+      scales: {
+        x: {
+          grid: { color: '#2a3544' },
+          ticks: { color: '#a9b4c2' }
+        },
+        y: {
+          title: { display: true, text: 'Residual Value', color: '#a9b4c2' },
+          grid: { color: '#2a3544' },
+          ticks: { color: '#a9b4c2' }
+        }
+      }
+    }
+  }, 'Gradient Boosting', 'Residual Reduction');
+}
+
+function drawGBLearningRate() {
+  const canvas = document.getElementById('gb-learning-rate-canvas');
+  if (!canvas) return;
+  
+  const iterations = Array.from({length: 21}, (_, i) => i);
+  
+  const lr01 = iterations.map(i => 154 - 18 * (1 - Math.exp(-i * 0.01)));
+  const lr10 = iterations.map(i => 154 - 18 * (1 - Math.exp(-i * 0.1)));
+  const lr100 = iterations.map(i => {
+    if (i === 0) return 154;
+    if (i < 5) return 154 - 18 * (1 - Math.exp(-i * 1.0));
+    return 136 + Math.sin(i) * 2;
+  });
+  
+  createVerifiedVisualization('gb-learning-rate-canvas', {
+    type: 'line',
+    data: {
+      labels: iterations,
+      datasets: [
+        {
+          label: 'lr = 0.01 (slow)',
+          data: lr01,
+          borderColor: '#ff8c6a',
+          borderWidth: 3,
+          pointRadius: 2
+        },
+        {
+          label: 'lr = 0.1 (good)',
+          data: lr10,
+          borderColor: '#7ef0d4',
+          borderWidth: 3,
+          pointRadius: 2
+        },
+        {
+          label: 'lr = 1.0 (too fast)',
+          data: lr100,
+          borderColor: '#6aa9ff',
+          borderWidth: 3,
+          pointRadius: 2
+        }
+      ]
+    },
+    options: {
+      responsive: true,
+      maintainAspectRatio: false,
+      plugins: {
+        title: {
+          display: true,
+          text: 'Learning Rate Effect on Convergence',
+          color: '#e8eef6',
+          font: { size: 16 }
+        },
+        legend: { labels: { color: '#a9b4c2' } }
+      },
+      scales: {
+        x: {
+          title: { display: true, text: 'Iteration', color: '#a9b4c2' },
+          grid: { color: '#2a3544' },
+          ticks: { color: '#a9b4c2' }
+        },
+        y: {
+          title: { display: true, text: 'Mean Prediction', color: '#a9b4c2' },
+          grid: { color: '#2a3544' },
+          ticks: { color: '#a9b4c2' }
+        }
+      }
+    }
+  }, 'Gradient Boosting', 'Learning Rate Effect');
+}
+
+function drawGBStumps() {
+  const canvas = document.getElementById('gb-stumps-canvas');
+  if (!canvas) return;
+  
+  const ctx = canvas.getContext('2d');
+  const width = canvas.width = canvas.offsetWidth;
+  const height = canvas.height = 400;
+  
+  ctx.clearRect(0, 0, width, height);
+  ctx.fillStyle = '#1a2332';
+  ctx.fillRect(0, 0, width, height);
+  
+  const stumps = [
+    { name: 'h1', split: 1050, left: -20.66, right: 31.0, color: '#6aa9ff' },
+    { name: 'h2', split: 950, left: -15.2, right: 22.5, color: '#7ef0d4' },
+    { name: 'h3', split: 1150, left: -8.5, right: 14.8, color: '#ffb490' }
+  ];
+  
+  const stumpWidth = width / 3;
+  
+  stumps.forEach((stump, idx) => {
+    const offsetX = idx * stumpWidth;
+    const centerX = offsetX + stumpWidth / 2;
+    
+    // Title
+    ctx.fillStyle = stump.color;
+    ctx.font = 'bold 14px sans-serif';
+    ctx.textAlign = 'center';
+    ctx.fillText(stump.name, centerX, 30);
+    
+    // Root node
+    ctx.fillStyle = stump.color + '33';
+    ctx.fillRect(centerX - 40, 60, 80, 50);
+    ctx.strokeStyle = stump.color;
+    ctx.lineWidth = 2;
+    ctx.strokeRect(centerX - 40, 60, 80, 50);
+    
+    ctx.fillStyle = '#e8eef6';
+    ctx.font = '12px sans-serif';
+    ctx.fillText('Size &lt;', centerX, 80);
+    ctx.fillText(stump.split, centerX, 95);
+    
+    // Left child
+    ctx.strokeStyle = stump.color;
+    ctx.beginPath();
+    ctx.moveTo(centerX, 110);
+    ctx.lineTo(centerX - 50, 180);
+    ctx.stroke();
+    
+    ctx.fillStyle = '#7ef0d4' + '33';
+    ctx.fillRect(centerX - 85, 180, 70, 50);
+    ctx.strokeStyle = '#7ef0d4';
+    ctx.strokeRect(centerX - 85, 180, 70, 50);
+    
+    ctx.fillStyle = '#e8eef6';
+    ctx.font = 'bold 13px sans-serif';
+    ctx.fillText(stump.left.toFixed(2), centerX - 50, 210);
+    
+    // Right child
+    ctx.strokeStyle = stump.color;
+    ctx.beginPath();
+    ctx.moveTo(centerX, 110);
+    ctx.lineTo(centerX + 50, 180);
+    ctx.stroke();
+    
+    ctx.fillStyle = '#ff8c6a' + '33';
+    ctx.fillRect(centerX + 15, 180, 70, 50);
+    ctx.strokeStyle = '#ff8c6a';
+    ctx.strokeRect(centerX + 15, 180, 70, 50);
+    
+    ctx.fillStyle = '#e8eef6';
+    ctx.font = 'bold 13px sans-serif';
+    ctx.fillText(stump.right.toFixed(2), centerX + 50, 210);
+    
+    // Labels
+    ctx.fillStyle = '#a9b4c2';
+    ctx.font = '10px sans-serif';
+    ctx.fillText('≤', centerX - 50, 150);
+    ctx.fillText('&gt;', centerX + 50, 150);
+  });
+  
+  // Title
+  ctx.fillStyle = '#7ef0d4';
+  ctx.font = 'bold 16px sans-serif';
+  ctx.textAlign = 'center';
+  ctx.fillText('Weak Learner Stumps (Depth = 1)', width / 2, height - 20);
+  
+  logViz('Gradient Boosting', 'Weak Learner Stumps', 'success');
+}
+
+function drawGBPredictions() {
+  const canvas = document.getElementById('gb-predictions-canvas');
+  if (!canvas) return;
+  
+  const actual = [120, 130, 150, 170, 200];
+  const iter0 = [154, 154, 154, 154, 154];
+  const iter5 = [125, 135, 148, 165, 195];
+  const iter10 = [121, 131, 149, 169, 199];
+  
+  createVerifiedVisualization('gb-predictions-canvas', {
+    type: 'scatter',
+    data: {
+      datasets: [
+        {
+          label: 'Actual',
+          data: actual.map((y, i) => ({ x: i + 1, y: y })),
+          backgroundColor: '#7ef0d4',
+          pointRadius: 8
+        },
+        {
+          label: 'Iteration 0',
+          data: iter0.map((y, i) => ({ x: i + 1, y: y })),
+          backgroundColor: '#ff8c6a',
+          pointRadius: 6
+        },
+        {
+          label: 'Iteration 5',
+          data: iter5.map((y, i) => ({ x: i + 1, y: y })),
+          backgroundColor: '#ffb490',
+          pointRadius: 6
+        },
+        {
+          label: 'Iteration 10',
+          data: iter10.map((y, i) => ({ x: i + 1, y: y })),
+          backgroundColor: '#6aa9ff',
+          pointRadius: 6
+        }
+      ]
+    },
+    options: {
+      responsive: true,
+      maintainAspectRatio: false,
+      plugins: {
+        title: {
+          display: true,
+          text: 'Predictions Approaching Actual Values',
+          color: '#e8eef6',
+          font: { size: 16 }
+        },
+        legend: { labels: { color: '#a9b4c2' } }
+      },
+      scales: {
+        x: {
+          title: { display: true, text: 'Sample ID', color: '#a9b4c2' },
+          grid: { color: '#2a3544' },
+          ticks: { color: '#a9b4c2', stepSize: 1 }
+        },
+        y: {
+          title: { display: true, text: 'Price (₹ Lakhs)', color: '#a9b4c2' },
+          grid: { color: '#2a3544' },
+          ticks: { color: '#a9b4c2' }
+        }
+      }
+    }
+  }, 'Gradient Boosting', 'Predictions vs Actual');
+}
+
+// Topic 17b: XGBoost (NEW)
+function initXGBoost() {
+  const canvases = [
+    { id: 'xgb-gain-canvas', fn: drawXGBGain },
+    { id: 'xgb-regularization-canvas', fn: drawXGBRegularization },
+    { id: 'xgb-hessian-canvas', fn: drawXGBHessian },
+    { id: 'xgb-leaf-weights-canvas', fn: drawXGBLeafWeights },
+    { id: 'xgb-comparison-canvas', fn: drawXGBComparison }
+  ];
+  
+  canvases.forEach(c => {
+    const canvas = document.getElementById(c.id);
+    if (canvas && !canvas.dataset.initialized) {
+      canvas.dataset.initialized = 'true';
+      c.fn();
+    }
+  });
+}
+
+function drawXGBGain() {
+  const canvas = document.getElementById('xgb-gain-canvas');
+  if (!canvas) return;
+  
+  const splits = [
+    { threshold: 850, gl: -58, gr: 0, hl: 2, hr: 3, gain: 1121 },
+    { threshold: 950, gl: -58, gr: 58, hl: 2, hr: 3, gain: 1962 },
+    { threshold: 1050, gl: -62, gr: 62, hl: 3, hr: 2, gain: 1842 },
+    { threshold: 1150, gl: -4, gr: 4, hl: 4, hr: 1, gain: 892 }
+  ];
+  
+  createVerifiedVisualization('xgb-gain-canvas', {
+    type: 'bar',
+    data: {
+      labels: splits.map(s => `Split ${s.threshold}`),
+      datasets: [
+        {
+          label: 'GL (Left Gradient)',
+          data: splits.map(s => s.gl),
+          backgroundColor: '#ff8c6a',
+          stack: 'gradient'
+        },
+        {
+          label: 'GR (Right Gradient)',
+          data: splits.map(s => s.gr),
+          backgroundColor: '#6aa9ff',
+          stack: 'gradient'
+        },
+        {
+          label: 'Gain Score',
+          data: splits.map(s => s.gain),
+          backgroundColor: '#7ef0d4',
+          yAxisID: 'y1'
+        }
+      ]
+    },
+    options: {
+      responsive: true,
+      maintainAspectRatio: false,
+      plugins: {
+        title: {
+          display: true,
+          text: 'XGBoost Gain Calculation for Different Splits',
+          color: '#e8eef6',
+          font: { size: 16 }
+        },
+        legend: { labels: { color: '#a9b4c2' } }
+      },
+      scales: {
+        x: {
+          grid: { color: '#2a3544' },
+          ticks: { color: '#a9b4c2' }
+        },
+        y: {
+          title: { display: true, text: 'Gradient Sum', color: '#a9b4c2' },
+          grid: { color: '#2a3544' },
+          ticks: { color: '#a9b4c2' }
+        },
+        y1: {
+          type: 'linear',
+          position: 'right',
+          title: { display: true, text: 'Gain', color: '#7ef0d4' },
+          grid: { display: false },
+          ticks: { color: '#a9b4c2' }
+        }
+      }
+    }
+  }, 'XGBoost', 'Gain Calculation');
+}
+
+function drawXGBRegularization() {
+  const canvas = document.getElementById('xgb-regularization-canvas');
+  if (!canvas) return;
+  
+  const lambdas = ['λ=0', 'λ=1', 'λ=10'];
+  const trainAcc = [0.99, 0.95, 0.88];
+  const testAcc = [0.82, 0.93, 0.91];
+  
+  createVerifiedVisualization('xgb-regularization-canvas', {
+    type: 'bar',
+    data: {
+      labels: lambdas,
+      datasets: [
+        {
+          label: 'Training Accuracy',
+          data: trainAcc,
+          backgroundColor: '#6aa9ff'
+        },
+        {
+          label: 'Test Accuracy',
+          data: testAcc,
+          backgroundColor: '#7ef0d4'
+        }
+      ]
+    },
+    options: {
+      responsive: true,
+      maintainAspectRatio: false,
+      plugins: {
+        title: {
+          display: true,
+          text: 'Regularization Effect: λ Controls Overfitting',
+          color: '#e8eef6',
+          font: { size: 16 }
+        },
+        legend: { labels: { color: '#a9b4c2' } }
+      },
+      scales: {
+        x: {
+          grid: { color: '#2a3544' },
+          ticks: { color: '#a9b4c2' }
+        },
+        y: {
+          title: { display: true, text: 'Accuracy', color: '#a9b4c2' },
+          grid: { color: '#2a3544' },
+          ticks: { color: '#a9b4c2' },
+          min: 0.7,
+          max: 1.0
+        }
+      }
+    }
+  }, 'XGBoost', 'Regularization Effect');
+}
+
+function drawXGBHessian() {
+  const canvas = document.getElementById('xgb-hessian-canvas');
+  if (!canvas) return;
+  
+  const ctx = canvas.getContext('2d');
+  const width = canvas.width = canvas.offsetWidth;
+  const height = canvas.height = 400;
+  
+  ctx.clearRect(0, 0, width, height);
+  ctx.fillStyle = '#1a2332';
+  ctx.fillRect(0, 0, width, height);
+  
+  const padding = 60;
+  const chartWidth = width - 2 * padding;
+  const chartHeight = height - 2 * padding;
+  
+  // Draw surface comparison
+  ctx.fillStyle = '#7ef0d4';
+  ctx.font = 'bold 16px sans-serif';
+  ctx.textAlign = 'center';
+  ctx.fillText('Hessian Provides Curvature Information', width / 2, 30);
+  
+  // Draw gradient only curve
+  ctx.strokeStyle = '#ff8c6a';
+  ctx.lineWidth = 3;
+  ctx.beginPath();
+  for (let x = 0; x <= 10; x += 0.2) {
+    const y = 200 - 100 * Math.exp(-Math.pow(x - 5, 2) / 8);
+    if (x === 0) ctx.moveTo(padding + x * chartWidth / 10, y);
+    else ctx.lineTo(padding + x * chartWidth / 10, y);
+  }
+  ctx.stroke();
+  
+  // Draw gradient + hessian curve
+  ctx.strokeStyle = '#7ef0d4';
+  ctx.lineWidth = 3;
+  ctx.beginPath();
+  for (let x = 0; x <= 10; x += 0.2) {
+    const y = 200 - 120 * Math.exp(-Math.pow(x - 5, 2) / 5);
+    if (x === 0) ctx.moveTo(padding + x * chartWidth / 10, y);
+    else ctx.lineTo(padding + x * chartWidth / 10, y);
+  }
+  ctx.stroke();
+  
+  // Optimum point
+  ctx.fillStyle = '#7ef0d4';
+  ctx.beginPath();
+  ctx.arc(padding + 5 * chartWidth / 10, 80, 8, 0, 2 * Math.PI);
+  ctx.fill();
+  
+  // Legend
+  ctx.fillStyle = '#ff8c6a';
+  ctx.fillRect(padding + 10, height - 80, 20, 3);
+  ctx.fillStyle = '#e8eef6';
+  ctx.font = '12px sans-serif';
+  ctx.textAlign = 'left';
+  ctx.fillText('1st order only (slower)', padding + 40, height - 75);
+  
+  ctx.fillStyle = '#7ef0d4';
+  ctx.fillRect(padding + 10, height - 55, 20, 3);
+  ctx.fillStyle = '#e8eef6';
+  ctx.fillText('1st + 2nd order (faster)', padding + 40, height - 50);
+  
+  logViz('XGBoost', 'Hessian Contribution', 'success');
+}
+
+function drawXGBLeafWeights() {
+  const canvas = document.getElementById('xgb-leaf-weights-canvas');
+  if (!canvas) return;
+  
+  const ctx = canvas.getContext('2d');
+  const width = canvas.width = canvas.offsetWidth;
+  const height = canvas.height = 350;
+  
+  ctx.clearRect(0, 0, width, height);
+  ctx.fillStyle = '#1a2332';
+  ctx.fillRect(0, 0, width, height);
+  
+  const padding = 40;
+  const boxWidth = 300;
+  const boxHeight = 120;
+  
+  // Left leaf
+  const leftX = width / 4 - boxWidth / 2;
+  ctx.fillStyle = '#7ef0d4' + '22';
+  ctx.fillRect(leftX, 80, boxWidth, boxHeight);
+  ctx.strokeStyle = '#7ef0d4';
+  ctx.lineWidth = 3;
+  ctx.strokeRect(leftX, 80, boxWidth, boxHeight);
+  
+  ctx.fillStyle = '#e8eef6';
+  ctx.font = 'bold 14px sans-serif';
+  ctx.textAlign = 'left';
+  ctx.fillText('Left Leaf (Size ≤ 950):', leftX + 10, 105);
+  ctx.font = '12px monospace';
+  ctx.fillText('w = -G / (H + λ)', leftX + 10, 130);
+  ctx.fillText('  = -(-58) / (2 + 1)', leftX + 10, 150);
+  ctx.fillText('  = 58 / 3', leftX + 10, 170);
+  ctx.font = 'bold 16px monospace';
+  ctx.fillStyle = '#7ef0d4';
+  ctx.fillText('  = 19.33', leftX + 10, 190);
+  
+  // Right leaf
+  const rightX = 3 * width / 4 - boxWidth / 2;
+  ctx.fillStyle = '#ff8c6a' + '22';
+  ctx.fillRect(rightX, 80, boxWidth, boxHeight);
+  ctx.strokeStyle = '#ff8c6a';
+  ctx.lineWidth = 3;
+  ctx.strokeRect(rightX, 80, boxWidth, boxHeight);
+  
+  ctx.fillStyle = '#e8eef6';
+  ctx.font = 'bold 14px sans-serif';
+  ctx.textAlign = 'left';
+  ctx.fillText('Right Leaf (Size &gt; 950):', rightX + 10, 105);
+  ctx.font = '12px monospace';
+  ctx.fillText('w = -G / (H + λ)', rightX + 10, 130);
+  ctx.fillText('  = -(58) / (3 + 1)', rightX + 10, 150);
+  ctx.fillText('  = -58 / 4', rightX + 10, 170);
+  ctx.font = 'bold 16px monospace';
+  ctx.fillStyle = '#ff8c6a';
+  ctx.fillText('  = -14.5', rightX + 10, 190);
+  
+  // Title
+  ctx.fillStyle = '#7ef0d4';
+  ctx.font = 'bold 16px sans-serif';
+  ctx.textAlign = 'center';
+  ctx.fillText('Leaf Weight Calculation (λ = 1)', width / 2, 40);
+  
+  // Formula reminder
+  ctx.fillStyle = '#a9b4c2';
+  ctx.font = '13px sans-serif';
+  ctx.fillText('Negative gradient divided by (Hessian + regularization)', width / 2, height - 20);
+  
+  logViz('XGBoost', 'Leaf Weight Calculation', 'success');
+}
+
+function drawXGBComparison() {
+  const canvas = document.getElementById('xgb-comparison-canvas');
+  if (!canvas) return;
+  
+  createVerifiedVisualization('xgb-comparison-canvas', {
+    type: 'radar',
+    data: {
+      labels: ['Accuracy', 'Speed', 'Robustness', 'Ease of Use', 'Scalability', 'Interpretability'],
+      datasets: [
+        {
+          label: 'Gradient Boosting',
+          data: [4.5, 3, 3.5, 4, 3, 3],
+          borderColor: '#ff8c6a',
+          backgroundColor: 'rgba(255, 140, 106, 0.2)',
+          borderWidth: 2
+        },
+        {
+          label: 'XGBoost',
+          data: [5, 4.5, 5, 4, 5, 3],
+          borderColor: '#7ef0d4',
+          backgroundColor: 'rgba(126, 240, 212, 0.2)',
+          borderWidth: 2
+        }
+      ]
+    },
+    options: {
+      responsive: true,
+      maintainAspectRatio: false,
+      plugins: {
+        title: {
+          display: true,
+          text: 'Gradient Boosting vs XGBoost: Comprehensive Comparison',
+          color: '#e8eef6',
+          font: { size: 16 }
+        },
+        legend: {
+          position: 'top',
+          labels: { color: '#a9b4c2', padding: 15 }
+        }
+      },
+      scales: {
+        r: {
+          beginAtZero: true,
+          max: 5,
+          ticks: { color: '#a9b4c2', backdropColor: 'transparent' },
+          grid: { color: '#2a3544' },
+          pointLabels: { color: '#e8eef6', font: { size: 12 } }
+        }
+      }
+    }
+  }, 'XGBoost', 'GB vs XGB Comparison');
+}
+
+function initBagging() {
+  const canvas = document.getElementById('bagging-complete-canvas');
+  if (canvas && !canvas.dataset.initialized) {
+    canvas.dataset.initialized = 'true';
+    drawBaggingCompleteViz();
+  }
+}
+
+function initBoostingAdaBoost() {
+  const canvas = document.getElementById('boosting-complete-canvas');
+  if (canvas && !canvas.dataset.initialized) {
+    canvas.dataset.initialized = 'true';
+    drawBoostingCompleteViz();
+  }
+}
+
+function initRandomForest() {
+  const canvas = document.getElementById('rf-complete-canvas');
+  if (canvas && !canvas.dataset.initialized) {
+    canvas.dataset.initialized = 'true';
+    drawRandomForestCompleteViz();
+  }
+}
+
+// Topic 17: Ensemble Methods
+function initEnsembleMethods() {
+  const canvasNew1 = document.getElementById('bagging-complete-canvas');
+  if (canvasNew1 && !canvasNew1.dataset.initialized) {
+    canvasNew1.dataset.initialized = 'true';
+    drawBaggingCompleteViz();
+  }
+  
+  const canvasNew2 = document.getElementById('boosting-complete-canvas');
+  if (canvasNew2 && !canvasNew2.dataset.initialized) {
+    canvasNew2.dataset.initialized = 'true';
+    drawBoostingCompleteViz();
+  }
+  
+  const canvasNew3 = document.getElementById('rf-complete-canvas');
+  if (canvasNew3 && !canvasNew3.dataset.initialized) {
+    canvasNew3.dataset.initialized = 'true';
+    drawRandomForestCompleteViz();
+  }
+  
+  const canvas1 = document.getElementById('bagging-viz');
+  if (canvas1 && !canvas1.dataset.initialized) {
+    canvas1.dataset.initialized = 'true';
+    drawBaggingViz();
+  }
+  
+  const canvas2 = document.getElementById('boosting-viz');
+  if (canvas2 && !canvas2.dataset.initialized) {
+    canvas2.dataset.initialized = 'true';
+    drawBoostingViz();
+  }
+  
+  const canvas3 = document.getElementById('random-forest-viz');
+  if (canvas3 && !canvas3.dataset.initialized) {
+    canvas3.dataset.initialized = 'true';
+    drawRandomForestViz();
+  }
+}
+
+function drawBaggingCompleteViz() {
+  const canvas = document.getElementById('bagging-complete-canvas');
+  if (!canvas) {
+    logViz('Ensemble Methods', 'Bagging Complete', 'failed', 'Canvas not found');
+    return;
+  }
+  
+  const ctx = canvas.getContext('2d');
+  const width = canvas.width = canvas.offsetWidth;
+  const height = canvas.height = 400;
+  
+  ctx.clearRect(0, 0, width, height);
+  ctx.fillStyle = '#1a2332';
+  ctx.fillRect(0, 0, width, height);
+  
+  const treeY = 100;
+  const predY = 280;
+  const finalY = 350;
+  
+  // Three trees
+  for (let i = 0; i < 3; i++) {
+    const x = 150 + i * 250;
+    const preds = [75, 72, 78];
+    
+    // Tree box
+    ctx.fillStyle = '#7ef0d433';
+    ctx.fillRect(x - 50, treeY, 100, 60);
+    ctx.strokeStyle = '#7ef0d4';
+    ctx.lineWidth = 2;
+    ctx.strokeRect(x - 50, treeY, 100, 60);
+    
+    ctx.fillStyle = '#e8eef6';
+    ctx.font = 'bold 14px sans-serif';
+    ctx.textAlign = 'center';
+    ctx.fillText(`Tree ${i + 1}`, x, treeY + 35);
+    
+    // Prediction
+    ctx.fillStyle = '#6aa9ff33';
+    ctx.fillRect(x - 40, predY, 80, 50);
+    ctx.strokeStyle = '#6aa9ff';
+    ctx.strokeRect(x - 40, predY, 80, 50);
+    
+    ctx.fillStyle = '#e8eef6';
+    ctx.font = 'bold 16px sans-serif';
+    ctx.fillText(`₹${preds[i]}L`, x, predY + 32);
+    
+    // Arrow to final
+    ctx.strokeStyle = '#7ef0d4';
+    ctx.lineWidth = 2;
+    ctx.beginPath();
+    ctx.moveTo(x, predY + 50);
+    ctx.lineTo(width / 2, finalY - 10);
+    ctx.stroke();
+  }
+  
+  // Final average
+  ctx.fillStyle = '#ff8c6a33';
+  ctx.fillRect(width / 2 - 80, finalY, 160, 50);
+  ctx.strokeStyle = '#ff8c6a';
+  ctx.lineWidth = 3;
+  ctx.strokeRect(width / 2 - 80, finalY, 160, 50);
+  
+  ctx.fillStyle = '#e8eef6';
+  ctx.font = 'bold 18px sans-serif';
+  ctx.textAlign = 'center';
+  ctx.fillText('Avg = ₹75L ✓', width / 2, finalY + 32);
+  
+  // Title
+  ctx.fillStyle = '#7ef0d4';
+  ctx.font = 'bold 16px sans-serif';
+  ctx.fillText('Bagging: Average of 3 Trees', width / 2, 30);
+  
+  logViz('Ensemble Methods', 'Bagging Complete', 'success');
+}
+
+function drawBoostingCompleteViz() {
+  const canvas = document.getElementById('boosting-complete-canvas');
+  if (!canvas) {
+    logViz('Ensemble Methods', 'Boosting Complete', 'failed', 'Canvas not found');
+    return;
+  }
+  
+  const ctx = canvas.getContext('2d');
+  const width = canvas.width = canvas.offsetWidth;
+  const height = canvas.height = 450;
+  
+  ctx.clearRect(0, 0, width, height);
+  ctx.fillStyle = '#1a2332';
+  ctx.fillRect(0, 0, width, height);
+  
+  const rounds = [
+    {label: 'Round 1', weights: [1, 1, 1, 1, 1, 1], errors: [20, 20, 21, 2, 3, 2]},
+    {label: 'Round 2', weights: [1, 1, 1, 2.5, 3, 2.5], errors: [21, 21, 20, 0, 1, 0]},
+    {label: 'Round 3', weights: [2, 2, 2, 1, 1, 1], errors: [20, 20, 21, 1, 2, 1]}
+  ];
+  
+  const startX = 60;
+  const barWidth = 30;
+  const gap = 10;
+  
+  rounds.forEach((round, r) => {
+    const y = 80 + r * 120;
+    
+    ctx.fillStyle = '#7ef0d4';
+    ctx.font = 'bold 14px sans-serif';
+    ctx.textAlign = 'left';
+    ctx.fillText(round.label, 10, y + 20);
+    
+    // Weight bars
+    round.weights.forEach((w, i) => {
+      const x = startX + i * (barWidth + gap);
+      const h = w * 20;
+      
+      ctx.fillStyle = w > 1.5 ? '#ff8c6a' : '#6aa9ff';
+      ctx.fillRect(x, y + 40 - h, barWidth, h);
+      
+      // Error text
+      ctx.fillStyle = '#a9b4c2';
+      ctx.font = '9px sans-serif';
+      ctx.textAlign = 'center';
+      ctx.fillText(`e=${round.errors[i]}`, x + barWidth / 2, y + 55);
+    });
+  });
+  
+  ctx.fillStyle = '#7ef0d4';
+  ctx.font = 'bold 16px sans-serif';
+  ctx.textAlign = 'center';
+  ctx.fillText('Boosting: Sequential Weight Updates', width / 2, 30);
+  ctx.fillText('Final: α₁×M₁ + α₂×M₂ + α₃×M₃ = ₹74.7L', width / 2, height - 20);
+}
+
+function drawRandomForestCompleteViz() {
+  const canvas = document.getElementById('rf-complete-canvas');
+  if (!canvas) {
+    logViz('Ensemble Methods', 'Random Forest Complete', 'failed', 'Canvas not found');
+    return;
+  }
+  
+  const ctx = canvas.getContext('2d');
+  const width = canvas.width = canvas.offsetWidth;
+  const height = canvas.height = 500;
+  
+  ctx.clearRect(0, 0, width, height);
+  ctx.fillStyle = '#1a2332';
+  ctx.fillRect(0, 0, width, height);
+  
+  // Show 3 trees with feature randomness
+  const trees = [
+    {features: ['Sq Ft', 'Age'], pred: 74},
+    {features: ['Sq Ft', 'Beds'], pred: 76},
+    {features: ['Beds', 'Age'], pred: 75}
+  ];
+  
+  trees.forEach((tree, i) => {
+    const x = 120 + i * 260;
+    const y = 100;
+    
+    // Bootstrap
+    ctx.fillStyle = '#6aa9ff33';
+    ctx.fillRect(x - 60, y, 120, 50);
+    ctx.strokeStyle = '#6aa9ff';
+    ctx.lineWidth = 2;
+    ctx.strokeRect(x - 60, y, 120, 50);
+    ctx.fillStyle = '#e8eef6';
+    ctx.font = '12px sans-serif';
+    ctx.textAlign = 'center';
+    ctx.fillText('Bootstrap', x, y + 25);
+    ctx.fillText(`Sample ${i + 1}`, x, y + 40);
+    
+    // Tree with random features
+    ctx.fillStyle = '#7ef0d433';
+    ctx.fillRect(x - 60, y + 80, 120, 70);
+    ctx.strokeStyle = '#7ef0d4';
+    ctx.strokeRect(x - 60, y + 80, 120, 70);
+    ctx.fillStyle = '#e8eef6';
+    ctx.font = 'bold 13px sans-serif';
+    ctx.fillText(`Tree ${i + 1}`, x, y + 105);
+    ctx.font = '10px sans-serif';
+    ctx.fillStyle = '#ffb490';
+    ctx.fillText('Random:', x, y + 123);
+    ctx.fillText(tree.features.join(', '), x, y + 138);
+    
+    // Prediction
+    ctx.fillStyle = '#ff8c6a33';
+    ctx.fillRect(x - 50, y + 180, 100, 50);
+    ctx.strokeStyle = '#ff8c6a';
+    ctx.strokeRect(x - 50, y + 180, 100, 50);
+    ctx.fillStyle = '#e8eef6';
+    ctx.font = 'bold 16px sans-serif';
+    ctx.fillText(`₹${tree.pred}L`, x, y + 210);
+    
+    // Arrow to final
+    ctx.strokeStyle = '#7ef0d4';
+    ctx.lineWidth = 2;
+    ctx.beginPath();
+    ctx.moveTo(x, y + 230);
+    ctx.lineTo(width / 2, y + 300);
+    ctx.stroke();
+  });
+  
+  // Final average
+  ctx.fillStyle = '#7ef0d433';
+  ctx.fillRect(width / 2 - 100, 400, 200, 70);
+  ctx.strokeStyle = '#7ef0d4';
+  ctx.lineWidth = 3;
+  ctx.strokeRect(width / 2 - 100, 400, 200, 70);
+  ctx.fillStyle = '#e8eef6';
+  ctx.font = 'bold 18px sans-serif';
+  ctx.textAlign = 'center';
+  ctx.fillText('Average of 100 Trees', width / 2, 425);
+  ctx.fillText('= ₹75.2L ± ₹2.3L ✓', width / 2, 450);
+  
+  // Title
+  ctx.fillStyle = '#7ef0d4';
+  ctx.font = 'bold 16px sans-serif';
+  ctx.fillText('Random Forest: Bootstrap + Feature Randomness', width / 2, 30);
+  
+  logViz('Ensemble Methods', 'Random Forest Complete', 'success');
+}
+
+function drawBaggingViz() {
+  const canvas = document.getElementById('bagging-viz');
+  if (!canvas) {
+    logViz('Ensemble Methods', 'Bagging Viz', 'failed', 'Canvas not found');
+    return;
+  }
+  
+  const ctx = canvas.getContext('2d');
+  const width = canvas.width = canvas.offsetWidth;
+  const height = canvas.height = 400;
+  
+  ctx.clearRect(0, 0, width, height);
+  ctx.fillStyle = '#1a2332';
+  ctx.fillRect(0, 0, width, height);
+  
+  const boxWidth = 150;
+  const boxHeight = 60;
+  const startY = 60;
+  const spacing = (width - 3 * boxWidth) / 4;
+  
+  // Original data
+  ctx.fillStyle = '#6aa9ff33';
+  ctx.fillRect(width / 2 - 100, startY, 200, boxHeight);
+  ctx.strokeStyle = '#6aa9ff';
+  ctx.lineWidth = 2;
+  ctx.strokeRect(width / 2 - 100, startY, 200, boxHeight);
+  ctx.fillStyle = '#e8eef6';
+  ctx.font = 'bold 14px sans-serif';
+  ctx.textAlign = 'center';
+  ctx.fillText('Original Dataset', width / 2, startY + boxHeight / 2 + 5);
+  
+  // Bootstrap samples
+  const sampleY = startY + boxHeight + 60;
+  for (let i = 0; i < 3; i++) {
+    const x = spacing + i * (boxWidth + spacing);
+    
+    // Arrow
+    ctx.strokeStyle = '#7ef0d4';
+    ctx.lineWidth = 2;
+    ctx.beginPath();
+    ctx.moveTo(width / 2, startY + boxHeight);
+    ctx.lineTo(x + boxWidth / 2, sampleY);
+    ctx.stroke();
+    
+    // Sample box
+    ctx.fillStyle = '#7ef0d433';
+    ctx.fillRect(x, sampleY, boxWidth, boxHeight);
+    ctx.strokeStyle = '#7ef0d4';
+    ctx.strokeRect(x, sampleY, boxWidth, boxHeight);
+    
+    ctx.fillStyle = '#e8eef6';
+    ctx.font = 'bold 12px sans-serif';
+    ctx.fillText(`Bootstrap ${i + 1}`, x + boxWidth / 2, sampleY + boxHeight / 2 - 5);
+    ctx.font = '10px sans-serif';
     ctx.fillStyle = '#a9b4c2';
     ctx.fillText('(random sample)', x + boxWidth / 2, sampleY + boxHeight / 2 + 10);
     
@@ -3910,6 +5386,40 @@ function drawBoostingViz() {
   ctx.fillStyle = '#ff8c6a';
   ctx.font = 'bold 14px sans-serif';
   ctx.fillText('Final Prediction = Weighted Combination of All Models', width / 2, height - 20);
+  
+  logViz('Ensemble Methods', 'Boosting Complete', 'success');
+}
+
+function drawGBLearningRate() {
+  // Implementation moved to Gradient Boosting section
+}
+
+function drawGBStumps() {
+  // Implementation moved to Gradient Boosting section
+}
+
+function drawGBPredictions() {
+  // Implementation moved to Gradient Boosting section
+}
+
+function drawXGBGain() {
+  // Implementation moved to XGBoost section
+}
+
+function drawXGBRegularization() {
+  // Implementation moved to XGBoost section
+}
+
+function drawXGBHessian() {
+  // Implementation moved to XGBoost section
+}
+
+function drawXGBLeafWeights() {
+  // Implementation moved to XGBoost section
+}
+
+function drawXGBComparison() {
+  // Implementation moved to XGBoost section
 }
 
 function drawRandomForestViz() {
@@ -4018,6 +5528,8 @@ function drawRandomForestViz() {
   ctx.fillStyle = '#7ef0d4';
   ctx.font = 'bold 16px sans-serif';
   ctx.fillText('Random Forest: Ensemble of Decision Trees', width / 2, 25);
+  
+  logViz('Ensemble Methods', 'Bagging Viz', 'success');
 }
 
 // Topic 16: K-means Clustering
@@ -4040,7 +5552,10 @@ function initKMeans() {
 
 function drawKMeansVisualization() {
   const canvas = document.getElementById('kmeans-viz-canvas');
-  if (!canvas) return;
+  if (!canvas) {
+    logViz('K-means', 'Scatter + Centroids', 'failed', 'Canvas not found');
+    return;
+  }
   
   const ctx = canvas.getContext('2d');
   const width = canvas.width = canvas.offsetWidth;
@@ -4160,6 +5675,8 @@ function drawKMeansVisualization() {
   ctx.font = '14px sans-serif';
   ctx.textAlign = 'left';
   ctx.fillText('WCSS = 15.984', padding, height - padding + 30);
+  
+  logViz('K-means', 'Scatter + Centroids', 'success');
 }
 
 function drawKMeansElbow() {
@@ -4175,7 +5692,7 @@ function drawKMeansElbow() {
   const kValues = [1, 2, 3, 4, 5];
   const wcssValues = [50, 18, 10, 8, 7];
   
-  kmeansElbowChart = safeCreateChart(ctx, {
+  kmeansElbowChart = createVerifiedVisualization('kmeans-elbow-canvas', {
     type: 'line',
     data: {
       labels: kValues,
@@ -4238,7 +5755,7 @@ function drawKMeansElbow() {
         }
       }
     }
-  }, 'K-means Elbow Chart');
+  }, 'K-means', 'Elbow Method');
 }
 
 // Topic 18: Algorithm Comparison
@@ -4474,6 +5991,8 @@ function renderComparisonTable() {
   
   html += '</tbody>';
   table.innerHTML = html;
+  
+  logViz('Algorithm Comparison', 'Comparison Table', 'success');
 }
 
 let radarComparisonChart = null;
@@ -4505,7 +6024,12 @@ function renderRadarChart() {
     };
   });
   
-  radarComparisonChart = safeCreateChart(ctx, {
+  if (radarComparisonChart) {
+    radarComparisonChart.destroy();
+    radarComparisonChart = null;
+  }
+  
+  radarComparisonChart = createVerifiedVisualization('radar-comparison-canvas', {
     type: 'radar',
     data: {
       labels: ['Speed', 'Accuracy', 'Data Efficiency', 'Interpretability', 'Scalability'],
@@ -4530,7 +6054,7 @@ function renderRadarChart() {
         }
       }
     }
-  }, 'Radar Comparison Chart');
+  }, 'Algorithm Comparison', 'Radar Chart');
 }
 
 function renderHeatmap() {
@@ -4586,6 +6110,8 @@ function renderHeatmap() {
   html += '</table>';
   html += '</div>';
   
+  logViz('Algorithm Comparison', 'Heatmap', 'success');
+  
   // Legend
   html += '<div style="text-align: center; margin-top: 24px; padding: 16px; background: var(--color-bg-2); border-radius: 8px;">';
   html += '<strong style="color: #e8eef6;">Legend:</strong> ';
@@ -4634,6 +6160,8 @@ function renderUseCaseMatrix() {
   
   html += '</tbody>';
   table.innerHTML = html;
+  
+  logViz('Algorithm Comparison', 'Use Case Matrix', 'success');
 }
 
 function renderDetailedCards() {
@@ -4673,6 +6201,8 @@ function renderDetailedCards() {
   
   html += '</div>';
   container.innerHTML = html;
+  
+  logViz('Algorithm Comparison', 'Detailed Cards', 'success');
 }
 
 function initQuiz() {
@@ -4836,6 +6366,75 @@ function drawDecisionFlowchart() {
   ctx.fillText('Algorithm Selection Flowchart', width/2, 25);
 }
 
+// Diagnostic Functions
+function showDiagnostics() {
+  const browserDetails = document.getElementById('browser-details');
+  if (browserDetails) {
+    browserDetails.innerHTML = `
+      <li style="padding: 8px 0; border-bottom: 1px solid var(--color-border); color: var(--color-text);">Browser: ${navigator.userAgent.split(' ').slice(-2).join(' ')}</li>
+      <li style="padding: 8px 0; border-bottom: 1px solid var(--color-border); color: var(--color-text);">Platform: ${navigator.platform}</li>
+      <li style="padding: 8px 0; border-bottom: 1px solid var(--color-border); color: var(--color-text);">Language: ${navigator.language}</li>
+      <li style="padding: 8px 0; border-bottom: 1px solid var(--color-border); color: var(--color-text);">Online: ${navigator.onLine ? '✓ Yes' : '✗ No'}</li>
+      <li style="padding: 8px 0; border-bottom: 1px solid var(--color-border); color: var(--color-text);">Cookies Enabled: ${navigator.cookieEnabled ? '✓ Yes' : '✗ No'}</li>
+    `;
+  }
+  
+  const libraryDetails = document.getElementById('library-details');
+  if (libraryDetails) {
+    const chartJsLoaded = typeof Chart !== 'undefined';
+    const canvasSupport = !!document.createElement('canvas').getContext('2d');
+    
+    libraryDetails.innerHTML = `
+      <li style="padding: 8px 0; border-bottom: 1px solid var(--color-border); color: var(--color-text);">Chart.js: ${chartJsLoaded ? '✓ Loaded (v' + (Chart.version || '4.x') + ')' : '✗ Missing'}</li>
+      <li style="padding: 8px 0; border-bottom: 1px solid var(--color-border); color: var(--color-text);">Canvas Support: ${canvasSupport ? '✓ Yes' : '✗ No'}</li>
+      <li style="padding: 8px 0; border-bottom: 1px solid var(--color-border); color: var(--color-text);">Device Pixel Ratio: ${window.devicePixelRatio || 1}</li>
+      <li style="padding: 8px 0; border-bottom: 1px solid var(--color-border); color: var(--color-text);">Screen Resolution: ${window.screen.width}x${window.screen.height}</li>
+    `;
+  }
+  
+  const successCount = document.getElementById('diag-success-count');
+  const failedCount = document.getElementById('diag-failed-count');
+  const warningCount = document.getElementById('diag-warning-count');
+  
+  if (successCount) successCount.textContent = vizLog.success.length;
+  if (failedCount) failedCount.textContent = vizLog.failed.length;
+  if (warningCount) warningCount.textContent = vizLog.warnings.length;
+}
+
+function showDiagnosticDetails(filter) {
+  const container = document.getElementById('viz-details');
+  if (!container) return;
+  
+  let items = [];
+  if (filter === 'success') items = vizLog.success;
+  else if (filter === 'failed') items = vizLog.failed;
+  else items = [...vizLog.success, ...vizLog.failed, ...vizLog.warnings];
+  
+  if (items.length === 0) {
+    container.innerHTML = '<p style="color: var(--color-text-secondary); text-align: center; padding: 20px;">No items to display</p>';
+    return;
+  }
+  
+  let html = '<table class="data-table" style="font-size: 12px;">';
+  html += '<thead><tr><th>Module</th><th>Visualization</th><th>Status</th><th>Time</th></tr></thead>';
+  html += '<tbody>';
+  
+  items.forEach(item => {
+    const statusIcon = item.status === 'success' ? '✓' : (item.status === 'failed' ? '✗' : '⚠');
+    const statusColor = item.status === 'success' ? 'var(--color-success)' : (item.status === 'failed' ? 'var(--color-error)' : 'var(--color-warning)');
+    
+    html += `<tr>`;
+    html += `<td>${item.module}</td>`;
+    html += `<td>${item.name}</td>`;
+    html += `<td style="color: ${statusColor}; font-weight: bold;">${statusIcon} ${item.status.toUpperCase()}</td>`;
+    html += `<td>${item.timestamp}</td>`;
+    html += `</tr>`;
+  });
+  
+  html += '</tbody></table>';
+  container.innerHTML = html;
+}
+
 // Handle window resize
 let resizeTimer;
 window.addEventListener('resize', () => {
@@ -4883,3 +6482,6 @@ window.addEventListener('resize', () => {
     if (document.getElementById('decision-flowchart')) drawDecisionFlowchart();
   }, 250);
 });
+
+// Add global function for diagnostic details (needed by onclick)
+window.showDiagnosticDetails = showDiagnosticDetails;

ml_complete-all-topics/index.html

@@ -529,8 +529,14 @@ canvas {
                             <a href="#svm" class="toc-link toc-sub">Support Vector Machines</a>
                             <a href="#knn" class="toc-link toc-sub">K-Nearest Neighbors</a>
                             <a href="#naive-bayes" class="toc-link toc-sub">Naive Bayes</a>
-                            <a href="#decision-trees" class="toc-link toc-sub">Decision Trees</a>
-                            <a href="#ensemble-methods" class="toc-link toc-sub">Ensemble Methods</a>
+                            <a href="#decision-tree-regression" class="toc-link toc-sub">Decision Tree Regression</a>
+                            <a href="#decision-trees" class="toc-link toc-sub">Decision Trees (Classification)</a>
+                            <a href="#bagging" class="toc-link toc-sub">Bagging</a>
+                            <a href="#boosting-adaboost" class="toc-link toc-sub">Boosting (AdaBoost)</a>
+                            <a href="#gradient-boosting" class="toc-link toc-sub">Gradient Boosting</a>
+                            <a href="#xgboost" class="toc-link toc-sub">XGBoost</a>
+                            <a href="#random-forest" class="toc-link toc-sub">Random Forest</a>
+                            <a href="#ensemble-methods" class="toc-link toc-sub">Ensemble Methods Overview</a>
                         </div>
                         <div class="toc-subcategory">
                             <div class="toc-subcategory-title">Evaluation &amp; Tuning</div>
@@ -577,6 +583,7 @@ canvas {
                 </div>
                 
                 <a href="#algorithm-comparison" class="toc-link">📊 Algorithm Comparison</a>
+                <a href="#diagnostics" class="toc-link">🔧 Diagnostics</a>
             </nav>
         </aside>
 
@@ -3242,6 +3249,192 @@ Actual  Pos     TP     FN
                 </div>
             </div>
 
+            <!-- Section 17: Decision Tree Regression (FROM PDF) -->
+            <div class="section" id="decision-tree-regression">
+                <div class="section-header">
+                    <h2><span class="badge" style="background: rgba(106, 169, 255, 0.3); color: #6aa9ff;">📊 Supervised - Regression</span> Decision Tree Regression</h2>
+                    <button class="section-toggle">▼</button>
+                </div>
+                <div class="section-body">
+                    <p>Decision Tree Regression predicts continuous values by recursively splitting data to minimize variance. Unlike classification trees that use entropy, regression trees use variance reduction!</p>
+
+                    <div class="info-card">
+                        <div class="info-card-title">Key Concepts</div>
+                        <ul class="info-card-list">
+                            <li>Splits based on variance reduction (not entropy)</li>
+                            <li>Leaf nodes predict mean of samples</li>
+                            <li>Test all split points to find best</li>
+                            <li>Recursive partitioning until stopping criteria</li>
+                        </ul>
+                    </div>
+
+                    <h3>🎯 Complete Mathematical Solution (From PDF)</h3>
+
+                    <h4>Dataset: House Price Prediction</h4>
+                    <table class="data-table">
+                        <thead>
+                            <tr><th>ID</th><th>Square Feet</th><th>Price (Lakhs)</th></tr>
+                        </thead>
+                        <tbody>
+                            <tr><td>1</td><td>800</td><td>50</td></tr>
+                            <tr><td>2</td><td>850</td><td>52</td></tr>
+                            <tr><td>3</td><td>900</td><td>54</td></tr>
+                            <tr><td>4</td><td>1500</td><td>90</td></tr>
+                            <tr><td>5</td><td>1600</td><td>95</td></tr>
+                            <tr><td>6</td><td>1700</td><td>100</td></tr>
+                        </tbody>
+                    </table>
+
+                    <div class="step">
+                        <div class="step-title">STEP 1: Calculate Parent Variance</div>
+                        <div class="step-calculation">
+Mean price = (50 + 52 + 54 + 90 + 95 + 100) / 6
+           = 441 / 6
+           = <strong style="color: #7ef0d4;">73.5 Lakhs</strong>
+
+Variance = Σ(yᵢ - mean)² / n
+
+Calculating each term:
+• (50 - 73.5)² = (-23.5)² = 552.25
+• (52 - 73.5)² = (-21.5)² = 462.25
+• (54 - 73.5)² = (-19.5)² = 380.25
+• (90 - 73.5)² = (16.5)² = 272.25
+• (95 - 73.5)² = (21.5)² = 462.25
+• (100 - 73.5)² = (26.5)² = 702.25
+
+Sum = 552.25 + 462.25 + 380.25 + 272.25 + 462.25 + 702.25
+    = 2831.5
+
+Variance = 2831.5 / 6 = <strong style="color: #7ef0d4;">471.92</strong>
+
+<strong style="color: #6aa9ff;">✓ Parent Variance = 471.92</strong>
+                        </div>
+                    </div>
+
+                    <div class="step">
+                        <div class="step-title">STEP 2: Test Split Points</div>
+                        <div class="step-calculation">
+Sort by Square Feet: 800, 850, 900, 1500, 1600, 1700
+
+Possible midpoints: 825, 875, 1200, 1550, 1650
+
+<strong style="color: #6aa9ff;">Testing Split at 1200:</strong>
+
+<strong>LEFT (Square Feet &lt;= 1200):</strong>
+Samples: 800(50), 850(52), 900(54)
+Left Mean = (50 + 52 + 54) / 3 = 156 / 3 = <strong>52</strong>
+
+Left Variance:
+• (50 - 52)² = 4
+• (52 - 52)² = 0
+• (54 - 52)² = 4
+Sum = 8
+Variance = 8 / 3 = <strong>2.67</strong>
+
+<strong>RIGHT (Square Feet &gt; 1200):</strong>
+Samples: 1500(90), 1600(95), 1700(100)
+Right Mean = (90 + 95 + 100) / 3 = 285 / 3 = <strong>95</strong>
+
+Right Variance:
+• (90 - 95)² = 25
+• (95 - 95)² = 0
+• (100 - 95)² = 25
+Sum = 50
+Variance = 50 / 3 = <strong>16.67</strong>
+                        </div>
+                    </div>
+
+                    <div class="step">
+                        <div class="step-title">STEP 3: Calculate Weighted Variance After Split</div>
+                        <div class="step-calculation">
+Weighted Variance = (n_left/n_total) × Var_left + (n_right/n_total) × Var_right
+
+                  = (3/6) × 2.67 + (3/6) × 16.67
+                  = 0.5 × 2.67 + 0.5 × 16.67
+                  = 1.335 + 8.335
+                  = <strong style="color: #6aa9ff;">9.67</strong>
+                        </div>
+                    </div>
+
+                    <div class="step">
+                        <div class="step-title">STEP 4: Calculate Variance Reduction</div>
+                        <div class="step-calculation">
+Variance Reduction = Parent Variance - Weighted Variance After Split
+
+                   = 471.92 - 9.67
+                   = <strong style="color: #7ef0d4; font-size: 18px;">462.25</strong>
+
+<strong style="color: #7ef0d4;">✓ This is the BEST SPLIT!</strong>
+Splitting at 1200 sq ft reduces variance by 462.25
+                        </div>
+                    </div>
+
+                    <div class="step">
+                        <div class="step-title">STEP 5: Build Final Tree Structure</div>
+                        <div class="step-calculation">
+Final Decision Tree:
+
+                [All data, Mean=73.5, Var=471.92]
+                              │
+                   Split at Square Feet = 1200
+                         /              \
+                    &lt;= 1200              &gt; 1200
+                      /                    \
+              Mean = 52            Split at 1550
+          (3 samples)               /        \
+                                &lt;= 1550      &gt; 1550
+                                  /            \
+                            Mean = 90      Mean = 97.5
+                            (1 sample)    (2 samples)
+
+<strong style="color: #7ef0d4;">Prediction Example:</strong>
+New property: 950 sq ft
+├─ 950 &lt;= 1200? YES → Go LEFT
+└─ Prediction: <strong style="color: #7ef0d4; font-size: 18px;">₹52 Lakhs</strong>
+
+New property: 1650 sq ft
+├─ 1650 &lt;= 1200? NO → Go RIGHT
+├─ 1650 &lt;= 1550? NO → Go RIGHT
+└─ Prediction: <strong style="color: #7ef0d4; font-size: 18px;">₹97.5 Lakhs</strong>
+                        </div>
+                    </div>
+
+                    <div class="figure">
+                        <div class="figure-placeholder" style="height: 450px">
+                            <canvas id="dt-regression-canvas"></canvas>
+                        </div>
+                        <p class="figure-caption"><strong>Figure:</strong> Decision tree regression with splits and predictions</p>
+                    </div>
+
+                    <div class="callout success">
+                        <div class="callout-title">✅ Key Takeaway</div>
+                        <div class="callout-content">
+                            Decision Tree Regression finds splits that minimize variance in leaf nodes. Each leaf predicts the mean of samples in that region. The recursive splitting creates a piecewise constant function!
+                        </div>
+                    </div>
+
+                    <h3>Variance Reduction vs Information Gain</h3>
+                    <table class="data-table">
+                        <thead>
+                            <tr><th>Aspect</th><th>Classification Trees</th><th>Regression Trees</th></tr>
+                        </thead>
+                        <tbody>
+                            <tr><td>Splitting Criterion</td><td>Information Gain (Entropy/Gini)</td><td>Variance Reduction</td></tr>
+                            <tr><td>Prediction</td><td>Majority class</td><td>Mean value</td></tr>
+                            <tr><td>Leaf Node</td><td>Class label</td><td>Continuous value</td></tr>
+                            <tr><td>Goal</td><td>Maximize purity</td><td>Minimize variance</td></tr>
+                        </tbody>
+                    </table>
+
+                    <div class="figure">
+                        <div class="figure-placeholder" style="height: 400px">
+                            <canvas id="dt-splits-canvas"></canvas>
+                        </div>
+                        <p class="figure-caption"><strong>Figure:</strong> Comparing different split points and their variance reduction</p>
+                    </div>
+                </div>
+            </div>
+
             <!-- Section 17: Decision Trees -->
             <div class="section" id="decision-trees">
                 <div class="section-header">
@@ -3893,7 +4086,506 @@ Actual  Pos     TP     FN
                 </div>
             </div>
 
-            <!-- Section 19: Ensemble Methods -->
+            <!-- Section 19a: Gradient Boosting (NEW FROM PDF) -->
+            <div class="section" id="gradient-boosting">
+                <div class="section-header">
+                    <h2><span class="badge" style="background: rgba(106, 169, 255, 0.3); color: #6aa9ff;">📊 Supervised - Ensemble</span> Gradient Boosting</h2>
+                    <button class="section-toggle collapsed">▼</button>
+                </div>
+                <div class="section-body">
+                    <p>Gradient Boosting is a powerful ensemble technique that builds models sequentially, where each new model corrects the errors (residuals) of the previous models. Unlike AdaBoost which adjusts sample weights, Gradient Boosting directly fits new models to the residual errors!</p>
+
+                    <div class="info-card">
+                        <div class="info-card-title">Key Concepts</div>
+                        <ul class="info-card-list">
+                            <li>Sequential learning: Each tree fixes errors of previous</li>
+                            <li>Weak learners: Simple stumps (depth=1)</li>
+                            <li>Learning rate: Controls step size (0.1 = small steps)</li>
+                            <li>Residuals: What model got wrong</li>
+                            <li>SSE: Sum of Squared Errors (lower = better split)</li>
+                        </ul>
+                    </div>
+
+                    <h3>🎯 Complete Mathematical Solution (From PDF)</h3>
+
+                    <h4>Dataset: House Price Prediction</h4>
+                    <table class="data-table">
+                        <thead>
+                            <tr><th>ID</th><th>Size (sq ft)</th><th>Bedrooms</th><th>Price (₹ Lakhs)</th></tr>
+                        </thead>
+                        <tbody>
+                            <tr><td>1</td><td>800</td><td>2</td><td>120</td></tr>
+                            <tr><td>2</td><td>900</td><td>2</td><td>130</td></tr>
+                            <tr><td>3</td><td>1000</td><td>3</td><td>150</td></tr>
+                            <tr><td>4</td><td>1100</td><td>3</td><td>170</td></tr>
+                            <tr><td>5</td><td>1200</td><td>4</td><td>200</td></tr>
+                        </tbody>
+                    </table>
+
+                    <p><strong>Learning Rate:</strong> lr = 0.1</p>
+
+                    <div class="step">
+                        <div class="step-title">STEP 0: Initialize Model F(0)</div>
+                        <div class="step-calculation">
+Formula: F(0) = mean(y)
+
+Calculation:
+  F(0) = (120 + 130 + 150 + 170 + 200) / 5
+       = 770 / 5
+       = <strong style="color: #7ef0d4;">154</strong>
+
+<strong style="color: #7ef0d4;">✓ Result: F(0) = 154</strong>
+                        </div>
+                    </div>
+
+                    <div class="step">
+                        <div class="step-title">STEP 1: Compute Residuals</div>
+                        <div class="step-calculation">
+Formula: r_i = y_i - F(0)
+
+<strong style="color: #6aa9ff;">Residual Calculation:</strong>
+
+ID | Size | Beds | Price(y) | Prediction F(0) | Residual r_i
+---|------|------|----------|-----------------|-------------
+1  | 800  | 2    | 120      | 154            | -34
+2  | 900  | 2    | 130      | 154            | -24
+3  | 1000 | 3    | 150      | 154            | -4
+4  | 1100 | 3    | 170      | 154            | +16
+5  | 1200 | 4    | 200      | 154            | +46
+
+<strong style="color: #7ef0d4;">✓ Residuals: [-34, -24, -4, +16, +46]</strong>
+                        </div>
+                    </div>
+
+                    <div class="step">
+                        <div class="step-title">STEP 2: Find Best Split (Build Weak Learner h1)</div>
+                        <div class="step-calculation">
+Test all candidate splits for Size feature:
+Midpoints: 850, 950, 1050, 1150
+
+<strong style="color: #6aa9ff;">Test: Size &lt; 1050</strong>
+
+├─ Left (Size ≤ 1050): IDs 1,2,3
+│  Residuals: [-34, -24, -4]
+│  Mean: (-34 + -24 + -4) / 3 = -62 / 3 = <strong>-20.66</strong>
+│  SSE: (-34-(-20.66))² + (-24-(-20.66))² + (-4-(-20.66))²
+│       = 177.78 + 11.11 + 277.78 = <strong>466.67</strong>
+│
+└─ Right (Size &gt; 1050): IDs 4,5
+   Residuals: [+16, +46]
+   Mean: (16 + 46) / 2 = 62 / 2 = <strong>31.0</strong>
+   SSE: (16-31)² + (46-31)² = 225 + 225 = <strong>450</strong>
+
+<strong style="color: #ff8c6a;">Total SSE = 466.67 + 450 = 916.67</strong>
+
+<strong style="color: #6aa9ff;">Test All Splits:</strong>
+Feature  | Threshold | SSE
+---------|-----------|--------
+Size     | 850       | 2675
+Size     | 950       | 1316.66
+Size     | 1050      | 916.67 ← BEST SPLIT
+Size     | 1150      | 1475.0
+Bedrooms | 2.5       | 1316.66
+Bedrooms | 3.5       | 1475.0
+
+<strong style="color: #7ef0d4; font-size: 18px;">✓ BEST SPLIT: Size &lt; 1050 with SSE = 916.67</strong>
+
+Weak Learner h1(x):
+├─ If Size ≤ 1050: h1(x) = -20.66
+└─ If Size &gt; 1050: h1(x) = 31.0
+                        </div>
+                    </div>
+
+                    <div class="step">
+                        <div class="step-title">STEP 3: Update Predictions</div>
+                        <div class="step-calculation">
+Formula: F1(x) = F(0) + lr × h1(x)
+         where lr = 0.1
+
+<strong style="color: #6aa9ff;">For ID 1 (Size=800):</strong>
+  F1(1) = 154 + 0.1 × (-20.66)
+        = 154 - 2.066
+        = <strong style="color: #7ef0d4;">151.93</strong> ✓
+
+<strong style="color: #6aa9ff;">For ID 4 (Size=1100):</strong>
+  F1(4) = 154 + 0.1 × 31.0
+        = 154 + 3.10
+        = <strong style="color: #7ef0d4;">157.10</strong> ✓
+
+<strong style="color: #6aa9ff;">Complete Table:</strong>
+ID | Size | Price(y) | F(0) | h1(x)  | F1(x)  | New Residual
+---|------|----------|------|--------|--------|-------------
+1  | 800  | 120      | 154  | -20.66 | 151.93 | -31.93
+2  | 900  | 130      | 154  | -20.66 | 151.93 | -21.93
+3  | 1000 | 150      | 154  | -20.66 | 151.93 | -1.93
+4  | 1100 | 170      | 154  | +31.0  | 157.10 | +12.90
+5  | 1200 | 200      | 154  | +31.0  | 157.10 | +42.90
+                        </div>
+                    </div>
+
+                    <div class="step">
+                        <div class="step-title">STEP 4: Repeat for h2, h3, ... h10</div>
+                        <div class="step-calculation">
+Continue building weak learners on residuals:
+
+F(x) = F(0) + lr×h1(x) + lr×h2(x) + lr×h3(x) + ... + lr×h10(x)
+
+Each iteration:
+1. Compute residuals
+2. Find best split
+3. Build weak learner
+4. Update predictions
+
+After 10 iterations:
+<strong style="color: #7ef0d4; font-size: 18px;">Final Model: F(x) = 154 + 0.1×h1(x) + 0.1×h2(x) + ... + 0.1×h10(x)</strong>
+                        </div>
+                    </div>
+
+                    <h3>📊 Visualizations</h3>
+
+                    <div class="figure">
+                        <div class="figure-placeholder" style="height: 400px">
+                            <canvas id="gb-sequential-canvas"></canvas>
+                        </div>
+                        <p class="figure-caption"><strong>Figure 1:</strong> Sequential tree building - residuals decreasing over iterations</p>
+                    </div>
+
+                    <div class="figure">
+                        <div class="figure-placeholder" style="height: 400px">
+                            <canvas id="gb-residuals-canvas"></canvas>
+                        </div>
+                        <p class="figure-caption"><strong>Figure 2:</strong> Residual reduction across iterations</p>
+                    </div>
+
+                    <div class="figure">
+                        <div class="figure-placeholder" style="height: 400px">
+                            <canvas id="gb-learning-rate-canvas"></canvas>
+                        </div>
+                        <p class="figure-caption"><strong>Figure 3:</strong> Learning rate effect - comparing lr=0.01, 0.1, 1.0</p>
+                    </div>
+
+                    <div class="figure">
+                        <div class="figure-placeholder" style="height: 400px">
+                            <canvas id="gb-stumps-canvas"></canvas>
+                        </div>
+                        <p class="figure-caption"><strong>Figure 4:</strong> Weak learner stumps with decision boundaries</p>
+                    </div>
+
+                    <div class="figure">
+                        <div class="figure-placeholder" style="height: 400px">
+                            <canvas id="gb-predictions-canvas"></canvas>
+                        </div>
+                        <p class="figure-caption"><strong>Figure 5:</strong> Prediction vs actual - showing improvement</p>
+                    </div>
+
+                    <div class="callout success">
+                        <div class="callout-title">✅ Key Takeaways</div>
+                        <div class="callout-content">
+                            <strong>Why Gradient Boosting Works:</strong><br>
+                            • Each tree learns from previous mistakes (residuals)<br>
+                            • Learning rate prevents overfitting<br>
+                            • Simple weak learners combine into strong predictor<br>
+                            • SSE-based splits find best variance reduction<br>
+                            <br>
+                            <strong>Advantages:</strong><br>
+                            ✓ Very high accuracy<br>
+                            ✓ Handles non-linear relationships<br>
+                            ✓ Feature importance built-in<br>
+                            <br>
+                            <strong>Disadvantages:</strong><br>
+                            ✗ Sequential (can't parallelize)<br>
+                            ✗ Sensitive to overfitting<br>
+                            ✗ Requires careful tuning
+                        </div>
+                    </div>
+                </div>
+            </div>
+
+            <!-- Section 19b: XGBoost (NEW FROM PDF) -->
+            <div class="section" id="xgboost">
+                <div class="section-header">
+                    <h2><span class="badge" style="background: rgba(106, 169, 255, 0.3); color: #6aa9ff;">📊 Supervised - Ensemble</span> XGBoost (Extreme Gradient Boosting)</h2>
+                    <button class="section-toggle collapsed">▼</button>
+                </div>
+                <div class="section-body">
+                    <p>XGBoost is an optimized implementation of gradient boosting that uses second-order derivatives (Hessian) and regularization for superior performance. It's the algorithm that wins most Kaggle competitions!</p>
+
+                    <div class="info-card">
+                        <div class="info-card-title">Key Concepts</div>
+                        <ul class="info-card-list">
+                            <li>Uses 2nd order derivatives (Hessian) for better approximation</li>
+                            <li>Built-in regularization (λ) to prevent overfitting</li>
+                            <li>Better gain calculation for splits</li>
+                            <li>Handles parallelism and missing values</li>
+                            <li>Much faster than standard gradient boosting</li>
+                        </ul>
+                    </div>
+
+                    <h3>🎯 XGBoost vs Gradient Boosting</h3>
+                    <table class="data-table">
+                        <thead>
+                            <tr><th>Aspect</th><th>Gradient Boosting</th><th>XGBoost</th></tr>
+                        </thead>
+                        <tbody>
+                            <tr><td>Derivatives</td><td>1st order (gradient)</td><td>1st + 2nd order (Hessian)</td></tr>
+                            <tr><td>Regularization</td><td>None built-in</td><td>L1 &amp; L2 built-in (λ)</td></tr>
+                            <tr><td>Split Criterion</td><td>MSE/MAE</td><td>Gain with regularization</td></tr>
+                            <tr><td>Parallelism</td><td>No</td><td>Yes (tree building)</td></tr>
+                            <tr><td>Missing Values</td><td>Must handle separately</td><td>Built-in handling</td></tr>
+                            <tr><td>Speed</td><td>Slower</td><td>Much faster</td></tr>
+                        </tbody>
+                    </table>
+
+                    <h3>🎯 Complete Mathematical Solution (From PDF)</h3>
+
+                    <p><strong>Using same dataset as Gradient Boosting:</strong></p>
+
+                    <div class="formula">
+                        <strong>XGBoost Gain Formula:</strong>
+                        Gain = [GL² / (HL + λ)] + [GR² / (HR + λ)] - [G_parent² / (H_parent + λ)]
+                        <br><br>
+                        Where:<br>
+                        &nbsp;&nbsp;G = Gradient (1st derivative) = Σ(y - ŷ)<br>
+                        &nbsp;&nbsp;H = Hessian (2nd derivative) = Σ(1) for regression<br>
+                        &nbsp;&nbsp;λ = Regularization parameter (default = 1)
+                    </div>
+
+                    <div class="step">
+                        <div class="step-title">STEP 0: Initialize</div>
+                        <div class="step-calculation">
+F(0) = mean(y) = <strong style="color: #7ef0d4;">154</strong>
+                        </div>
+                    </div>
+
+                    <div class="step">
+                        <div class="step-title">STEP 1: Compute Gradients and Hessians</div>
+                        <div class="step-calculation">
+<strong style="color: #6aa9ff;">For Regression (MSE loss):</strong>
+gradient g = (y - ŷ)
+hessian h = 1 (constant for MSE)
+
+ID | Size | Price(y) | F(0) | g=(y-ŷ) | h
+---|------|----------|------|---------|---
+1  | 800  | 120      | 154  | -34     | 1
+2  | 900  | 130      | 154  | -24     | 1
+3  | 1000 | 150      | 154  | -4      | 1
+4  | 1100 | 170      | 154  | +16     | 1
+5  | 1200 | 200      | 154  | +46     | 1
+                        </div>
+                    </div>
+
+                    <div class="step">
+                        <div class="step-title">STEP 2: Test Split - Size &lt; 950</div>
+                        <div class="step-calculation">
+<strong style="color: #6aa9ff;">Split: Size &lt; 950</strong>
+
+├─ Left: IDs 1,2 (800, 900)
+│  GL = -34 + (-24) = <strong>-58</strong>
+│  HL = 1 + 1 = <strong>2</strong>
+│
+└─ Right: IDs 3,4,5 (1000, 1100, 1200)
+   GR = -4 + 16 + 46 = <strong>+58</strong>
+   HR = 1 + 1 + 1 = <strong>3</strong>
+
+Parent:
+  G_parent = -34 + (-24) + (-4) + 16 + 46 = <strong>0</strong>
+  H_parent = <strong>5</strong>
+
+<strong style="color: #6aa9ff;">Calculate Scores (λ = 1):</strong>
+
+Score(Left) = -GL² / (HL + λ)
+            = -(-58)² / (2 + 1)
+            = -3364 / 3
+            = <strong>-1121.33</strong>
+
+Score(Right) = -GR² / (HR + λ)
+             = -(58)² / (3 + 1)
+             = -3364 / 4
+             = <strong>-841</strong>
+
+Score(Parent) = -G_parent² / (H_parent + λ)
+              = -(0)² / (5 + 1)
+              = <strong>0</strong>
+
+Gain = Score(Left) + Score(Right) - Score(Parent)
+     = -1121.33 + (-841) - 0
+     = -1962.33
+     
+Use absolute value: Gain = <strong style="color: #7ef0d4; font-size: 18px;">1962.33</strong> ✓ HIGHEST GAIN
+                        </div>
+                    </div>
+
+                    <div class="step">
+                        <div class="step-title">STEP 3: Compute Leaf Weights</div>
+                        <div class="step-calculation">
+Formula: w = -G / (H + λ)
+
+<strong style="color: #6aa9ff;">Left Leaf:</strong>
+  w_left = -(-58) / (2 + 1)
+         = 58 / 3
+         = <strong style="color: #7ef0d4;">19.33</strong>
+
+<strong style="color: #6aa9ff;">Right Leaf:</strong>
+  w_right = -(58) / (3 + 1)
+          = -58 / 4
+          = <strong style="color: #7ef0d4;">-14.5</strong>
+                        </div>
+                    </div>
+
+                    <div class="step">
+                        <div class="step-title">STEP 4: Update Predictions</div>
+                        <div class="step-calculation">
+Formula: F1(x) = F(0) + lr × w
+
+<strong style="color: #6aa9ff;">Complete Table:</strong>
+ID | Size | Price(y) | F(0) | Leaf Weight | F1(x)     | New Residual
+---|------|----------|------|-------------|-----------|-------------
+1  | 800  | 120      | 154  | -19.33      | 134.67    | -14.67
+2  | 900  | 130      | 154  | -19.33      | 134.67    | -4.67
+3  | 1000 | 150      | 154  | +14.5       | 168.50    | -18.50
+4  | 1100 | 170      | 154  | +14.5       | 168.50    | +1.50
+5  | 1200 | 200      | 154  | +14.5       | 168.50    | +31.50
+                        </div>
+                    </div>
+
+                    <h3>📊 Visualizations</h3>
+
+                    <div class="figure">
+                        <div class="figure-placeholder" style="height: 400px">
+                            <canvas id="xgb-gain-canvas"></canvas>
+                        </div>
+                        <p class="figure-caption"><strong>Figure 1:</strong> Gain calculation showing GL, GR, HL, HR for each split</p>
+                    </div>
+
+                    <div class="figure">
+                        <div class="figure-placeholder" style="height: 400px">
+                            <canvas id="xgb-regularization-canvas"></canvas>
+                        </div>
+                        <p class="figure-caption"><strong>Figure 2:</strong> Regularization effect - comparing λ=0, 1, 10</p>
+                    </div>
+
+                    <div class="figure">
+                        <div class="figure-placeholder" style="height: 400px">
+                            <canvas id="xgb-hessian-canvas"></canvas>
+                        </div>
+                        <p class="figure-caption"><strong>Figure 3:</strong> Hessian contribution to better optimization</p>
+                    </div>
+
+                    <div class="figure">
+                        <div class="figure-placeholder" style="height: 350px">
+                            <canvas id="xgb-leaf-weights-canvas"></canvas>
+                        </div>
+                        <p class="figure-caption"><strong>Figure 4:</strong> Leaf weight calculation breakdown</p>
+                    </div>
+
+                    <div class="figure">
+                        <div class="figure-placeholder" style="height: 450px">
+                            <canvas id="xgb-comparison-canvas"></canvas>
+                        </div>
+                        <p class="figure-caption"><strong>Figure 5:</strong> Gradient Boosting vs XGBoost performance comparison</p>
+                    </div>
+
+                    <div class="callout success">
+                        <div class="callout-title">✅ Key Advantages of XGBoost</div>
+                        <div class="callout-content">
+                            <strong>Mathematical Improvements:</strong><br>
+                            ✓ 2nd order derivatives → Better approximation<br>
+                            ✓ Regularization (λ) → Prevents overfitting<br>
+                            ✓ Gain-based splitting → More accurate<br>
+                            <br>
+                            <strong>Engineering Improvements:</strong><br>
+                            ✓ Parallel processing → Faster training<br>
+                            ✓ Handles missing values → More robust<br>
+                            ✓ Built-in cross-validation → Easy tuning<br>
+                            ✓ Tree pruning → Better generalization<br>
+                            ✓ Cache optimization → Memory efficient<br>
+                            <br>
+                            <strong>Real-World Impact:</strong><br>
+                            • Most popular algorithm for structured data<br>
+                            • Dominates Kaggle competitions<br>
+                            • Used by: Uber, Airbnb, Microsoft, etc.
+                        </div>
+                    </div>
+
+                    <h3>Hyperparameter Guide</h3>
+                    <table class="data-table">
+                        <thead>
+                            <tr><th>Parameter</th><th>Description</th><th>Typical Values</th></tr>
+                        </thead>
+                        <tbody>
+                            <tr><td>learning_rate (η)</td><td>Step size shrinkage</td><td>0.01 - 0.3</td></tr>
+                            <tr><td>n_estimators</td><td>Number of trees</td><td>100 - 1000</td></tr>
+                            <tr><td>max_depth</td><td>Tree depth</td><td>3 - 10</td></tr>
+                            <tr><td>lambda (λ)</td><td>L2 regularization</td><td>0 - 10</td></tr>
+                            <tr><td>alpha (α)</td><td>L1 regularization</td><td>0 - 10</td></tr>
+                            <tr><td>subsample</td><td>Row sampling</td><td>0.5 - 1.0</td></tr>
+                            <tr><td>colsample_bytree</td><td>Column sampling</td><td>0.5 - 1.0</td></tr>
+                        </tbody>
+                    </table>
+                </div>
+            </div>
+
+            <!-- Section 19c: Bagging (Renamed) -->
+            <div class="section" id="bagging">
+                <div class="section-header">
+                    <h2><span class="badge" style="background: rgba(106, 169, 255, 0.3); color: #6aa9ff;">📊 Supervised - Ensemble</span> Bagging (Bootstrap Aggregating)</h2>
+                    <button class="section-toggle collapsed">▼</button>
+                </div>
+                <div class="section-body">
+                    <p>Bagging trains multiple models on different random subsets of data (with replacement), then averages predictions. It's the foundation for Random Forest!</p>
+
+                    <div class="figure">
+                        <div class="figure-placeholder" style="height: 400px">
+                            <canvas id="bagging-complete-canvas"></canvas>
+                        </div>
+                        <p class="figure-caption"><strong>Figure:</strong> Bagging process showing 3 trees and averaged prediction</p>
+                    </div>
+
+                    <p>See the <a href="#ensemble-methods">Ensemble Methods Overview</a> section below for complete mathematical walkthrough.</p>
+                </div>
+            </div>
+
+            <!-- Section 19d: Boosting/AdaBoost (Renamed) -->
+            <div class="section" id="boosting-adaboost">
+                <div class="section-header">
+                    <h2><span class="badge" style="background: rgba(106, 169, 255, 0.3); color: #6aa9ff;">📊 Supervised - Ensemble</span> Boosting (AdaBoost)</h2>
+                    <button class="section-toggle collapsed">▼</button>
+                </div>
+                <div class="section-body">
+                    <p>AdaBoost trains models sequentially, where each new model focuses on examples the previous models got wrong by adjusting sample weights.</p>
+
+                    <div class="figure">
+                        <div class="figure-placeholder" style="height: 450px">
+                            <canvas id="boosting-complete-canvas"></canvas>
+                        </div>
+                        <p class="figure-caption"><strong>Figure:</strong> Boosting rounds showing weight updates and error reduction</p>
+                    </div>
+
+                    <p>See the <a href="#ensemble-methods">Ensemble Methods Overview</a> section below for complete mathematical walkthrough.</p>
+                </div>
+            </div>
+
+            <!-- Section 19e: Random Forest (Renamed) -->
+            <div class="section" id="random-forest">
+                <div class="section-header">
+                    <h2><span class="badge" style="background: rgba(106, 169, 255, 0.3); color: #6aa9ff;">📊 Supervised - Ensemble</span> Random Forest</h2>
+                    <button class="section-toggle collapsed">▼</button>
+                </div>
+                <div class="section-body">
+                    <p>Random Forest combines bagging with feature randomness. Each tree is trained on a bootstrap sample AND considers only random subsets of features at each split!</p>
+
+                    <div class="figure">
+                        <div class="figure-placeholder" style="height: 500px">
+                            <canvas id="rf-complete-canvas"></canvas>
+                        </div>
+                        <p class="figure-caption"><strong>Figure:</strong> Random Forest showing feature randomness and OOB validation</p>
+                    </div>
+
+                    <p>See the <a href="#ensemble-methods">Ensemble Methods Overview</a> section below for complete mathematical walkthrough.</p>
+                </div>
+            </div>
+
+            <!-- Section 19: Ensemble Methods (COMPREHENSIVE FROM PDF) -->
             <div class="section" id="ensemble-methods">
                 <div class="section-header">
                     <h2><span class="badge" style="background: rgba(106, 169, 255, 0.3); color: #6aa9ff;">📊 Supervised</span> Ensemble Methods</h2>
@@ -3930,9 +4622,99 @@ Actual  Pos     TP     FN
                         </div>
                     </div>
 
-                    <h3>Method 1: Bagging (Bootstrap Aggregating)</h3>
+                    <h3>🎯 Method 1: Bagging (Bootstrap Aggregating) - Complete Walkthrough</h3>
                     <p>Train multiple models on different random subsets of data (with replacement), then average predictions.</p>
 
+                    <h4>Dataset: 6 Properties</h4>
+                    <table class="data-table">
+                        <thead>
+                            <tr><th>Row</th><th>Square Feet</th><th>Price (Lakhs)</th></tr>
+                        </thead>
+                        <tbody>
+                            <tr><td>A</td><td>900</td><td>70</td></tr>
+                            <tr><td>B</td><td>1000</td><td>80</td></tr>
+                            <tr><td>C</td><td>900</td><td>70</td></tr>
+                            <tr><td>D</td><td>1500</td><td>90</td></tr>
+                            <tr><td>E</td><td>1600</td><td>95</td></tr>
+                            <tr><td>F</td><td>1700</td><td>100</td></tr>
+                        </tbody>
+                    </table>
+
+                    <div class="step">
+                        <div class="step-title">STEP 1: Create Bootstrap Samples (WITH Replacement)</div>
+                        <div class="step-calculation">
+<strong style="color: #6aa9ff;">Bootstrap Sample 1:</strong>
+Randomly pick 6 samples WITH replacement:
+├─ Row A: 900 sq ft, ₹70L (sampled TWICE!)
+├─ Row A: 900 sq ft, ₹70L (duplicate)
+├─ Row B: 1000 sq ft, ₹80L
+├─ Row D: 1500 sq ft, ₹90L
+├─ Row E: 1600 sq ft, ₹95L
+└─ Row F: 1700 sq ft, ₹100L
+
+<strong style="color: #6aa9ff;">Bootstrap Sample 2:</strong>
+├─ Row C: 900 sq ft, ₹70L
+├─ Row D: 1500 sq ft, ₹90L
+├─ Row E: 1600 sq ft, ₹95L
+├─ Row E: 1600 sq ft, ₹95L (sampled TWICE!)
+├─ Row F: 1700 sq ft, ₹100L
+└─ Row B: 1000 sq ft, ₹80L
+
+<strong style="color: #6aa9ff;">Bootstrap Sample 3:</strong>
+├─ Row F: 1700 sq ft, ₹100L
+├─ Row C: 900 sq ft, ₹70L
+├─ Row E: 1600 sq ft, ₹95L
+├─ Row A: 900 sq ft, ₹70L
+├─ Row B: 1000 sq ft, ₹80L
+└─ Row D: 1500 sq ft, ₹90L
+                        </div>
+                    </div>
+
+                    <div class="step">
+                        <div class="step-title">STEP 2: Train Separate Model on Each Sample</div>
+                        <div class="step-calculation">
+<strong style="color: #7ef0d4;">Tree 1:</strong> Trained on Sample 1
+• Learns splits based on its data
+• For 950 sq ft → Predicts: <strong>₹75L</strong>
+
+<strong style="color: #7ef0d4;">Tree 2:</strong> Trained on Sample 2
+• Different data → Different splits!
+• For 950 sq ft → Predicts: <strong>₹72L</strong>
+
+<strong style="color: #7ef0d4;">Tree 3:</strong> Trained on Sample 3
+• Yet another perspective
+• For 950 sq ft → Predicts: <strong>₹78L</strong>
+                        </div>
+                    </div>
+
+                    <div class="step">
+                        <div class="step-title">STEP 3: Aggregate Predictions (Average)</div>
+                        <div class="step-calculation">
+For test property with 950 sq ft:
+
+Prediction₁ = ₹75L
+Prediction₂ = ₹72L
+Prediction₃ = ₹78L
+
+<strong style="color: #6aa9ff;">Final Bagging Prediction:</strong>
+Average = (75 + 72 + 78) / 3
+        = 225 / 3
+        = <strong style="color: #7ef0d4; font-size: 18px;">₹75 Lakhs</strong> ✓
+
+<strong style="color: #7ef0d4;">Why it works:</strong>
+• Each tree makes slightly different errors
+• Averaging reduces overall variance
+• More stable than single tree!
+                        </div>
+                    </div>
+
+                    <div class="figure">
+                        <div class="figure-placeholder" style="height: 400px">
+                            <canvas id="bagging-complete-canvas"></canvas>
+                        </div>
+                        <p class="figure-caption"><strong>Figure:</strong> Bagging process showing 3 trees and averaged prediction</p>
+                    </div>
+
                     <div class="formula">
                         <strong>Bagging Algorithm:</strong><br>
                         1. Create B bootstrap samples (random sampling with replacement)<br>
@@ -3951,9 +4733,102 @@ Actual  Pos     TP     FN
                         <p class="figure-caption"><strong>Figure 1:</strong> Bagging process - multiple models from bootstrap samples</p>
                     </div>
 
-                    <h3>Method 2: Boosting (Sequential Learning)</h3>
+                    <h3>🎯 Method 2: Boosting (Sequential Learning) - Complete Walkthrough</h3>
                     <p>Train models sequentially, where each new model focuses on examples the previous models got wrong.</p>
 
+                    <div class="step">
+                        <div class="step-title">STEP 1: Round 1 - Train Model 1 on All Data (Equal Weights)</div>
+                        <div class="step-calculation">
+Original Dataset (all samples weighted equally: w=1.0):
+├─ 800 sq ft → Actual: ₹50L
+├─ 850 sq ft → Actual: ₹52L
+├─ 900 sq ft → Actual: ₹54L
+├─ 1500 sq ft → Actual: ₹90L
+├─ 1600 sq ft → Actual: ₹95L
+└─ 1700 sq ft → Actual: ₹100L
+
+<strong style="color: #6aa9ff;">Model 1 Predictions:</strong>
+├─ 800 sq ft → Predicts: ₹70L (Error: -20)
+├─ 850 sq ft → Predicts: ₹72L (Error: -20)
+├─ 900 sq ft → Predicts: ₹75L (Error: -21)
+├─ 1500 sq ft → Predicts: ₹88L (Error: +2) ⚠️
+├─ 1600 sq ft → Predicts: ₹92L (Error: +3) ⚠️
+└─ 1700 sq ft → Predicts: ₹98L (Error: +2) ⚠️
+
+<strong style="color: #ff8c6a;">Large errors on rows 4, 5, 6!</strong>
+                        </div>
+                    </div>
+
+                    <div class="step">
+                        <div class="step-title">STEP 2: Round 2 - Increase Weights on Misclassified</div>
+                        <div class="step-calculation">
+Update weights based on errors:
+├─ Row 1: w = 1.0 (small error)
+├─ Row 2: w = 1.0 (small error)
+├─ Row 3: w = 1.0 (small error)
+├─ Row 4: w = 2.5 (large error → FOCUS!) 🎯
+├─ Row 5: w = 3.0 (large error → FOCUS!) 🎯
+└─ Row 6: w = 2.5 (large error → FOCUS!) 🎯
+
+<strong style="color: #6aa9ff;">Train Model 2 with these weights:</strong>
+Model 2 focuses on the high-priced properties!
+
+<strong style="color: #6aa9ff;">Model 2 Predictions:</strong>
+├─ 800 sq ft → ₹71L (Error: -21)
+├─ 850 sq ft → ₹73L (Error: -21)
+├─ 900 sq ft → ₹74L (Error: -20)
+├─ 1500 sq ft → ₹90L (Error: 0) ✓
+├─ 1600 sq ft → ₹94L (Error: +1) ✓
+└─ 1700 sq ft → ₹100L (Error: 0) ✓
+
+<strong style="color: #7ef0d4;">Better on high-priced properties!</strong>
+                        </div>
+                    </div>
+
+                    <div class="step">
+                        <div class="step-title">STEP 3: Round 3 - Further Refine</div>
+                        <div class="step-calculation">
+Update weights again:
+├─ Rows 1,2,3 still have errors → increase weights
+├─ Rows 4,5,6 now accurate → decrease weights
+
+<strong style="color: #6aa9ff;">Model 3 Predictions:</strong>
+├─ 800 sq ft → ₹70L (Error: -20)
+├─ 850 sq ft → ₹72L (Error: -20)
+├─ 900 sq ft → ₹75L (Error: -21)
+├─ 1500 sq ft → ₹89L (Error: +1)
+├─ 1600 sq ft → ₹93L (Error: +2)
+└─ 1700 sq ft → ₹99L (Error: +1)
+
+<strong style="color: #7ef0d4;">All errors minimized!</strong>
+                        </div>
+                    </div>
+
+                    <div class="step">
+                        <div class="step-title">STEP 4: Combine with Weights</div>
+                        <div class="step-calculation">
+Model weights (based on accuracy):
+• Model 1: α₁ = 0.2 (least accurate)
+• Model 2: α₂ = 0.3 (medium accuracy)
+• Model 3: α₃ = 0.5 (most accurate)
+
+<strong style="color: #6aa9ff;">Final Prediction for 950 sq ft:</strong>
+Weighted Average = α₁×Pred₁ + α₂×Pred₂ + α₃×Pred₃
+                 = 0.2×75 + 0.3×74 + 0.5×75
+                 = 15 + 22.2 + 37.5
+                 = <strong style="color: #7ef0d4; font-size: 18px;">₹74.7 Lakhs</strong> ✓
+
+<strong style="color: #7ef0d4;">More accurate than any single model!</strong>
+                        </div>
+                    </div>
+
+                    <div class="figure">
+                        <div class="figure-placeholder" style="height: 450px">
+                            <canvas id="boosting-complete-canvas"></canvas>
+                        </div>
+                        <p class="figure-caption"><strong>Figure:</strong> Boosting rounds showing weight updates and error reduction</p>
+                    </div>
+
                     <div class="formula">
                         <strong>Boosting Algorithm:</strong><br>
                         1. Start with equal weights for all samples<br>
@@ -3973,9 +4848,149 @@ Actual  Pos     TP     FN
                         <p class="figure-caption"><strong>Figure 2:</strong> Boosting iteration - focusing on misclassified points</p>
                     </div>
 
-                    <h3>Random Forest: Bagging + Decision Trees</h3>
+                    <h3>🎯 Random Forest: Complete Walkthrough (From PDF)</h3>
                     <p>The most popular ensemble method! Combines bagging with feature randomness.</p>
 
+                    <h4>Dataset: House Prices with 3 Features</h4>
+                    <table class="data-table">
+                        <thead>
+                            <tr><th>Square Feet</th><th>Bedrooms</th><th>Age (years)</th><th>Price (Lakhs)</th></tr>
+                        </thead>
+                        <tbody>
+                            <tr><td>800</td><td>2</td><td>10</td><td>50</td></tr>
+                            <tr><td>850</td><td>2</td><td>8</td><td>52</td></tr>
+                            <tr><td>900</td><td>2</td><td>5</td><td>54</td></tr>
+                            <tr><td>1500</td><td>3</td><td>3</td><td>90</td></tr>
+                            <tr><td>1600</td><td>3</td><td>2</td><td>95</td></tr>
+                            <tr><td>1700</td><td>4</td><td>1</td><td>100</td></tr>
+                        </tbody>
+                    </table>
+
+                    <p><strong>Key Parameter:</strong> Max Features = 2 (random subset at each split)</p>
+
+                    <div class="step">
+                        <div class="step-title">STEP 1: Tree 1 - Random Features at Each Split</div>
+                        <div class="step-calculation">
+<strong style="color: #6aa9ff;">Bootstrap Sample 1:</strong> {A, A, B, D, E, F}
+
+<strong>Root Split:</strong>
+Available features: [Square Feet, Bedrooms, Age]
+Randomly select 2: <strong style="color: #7ef0d4;">[Square Feet, Age]</strong>
+
+Test splits:
+• Square Feet = 1200: Variance Reduction = 450 ← BEST!
+• Age = 5: Variance Reduction = 120
+
+<strong style="color: #7ef0d4;">Choose: Split at Square Feet = 1200</strong>
+
+<strong>Left Child Split:</strong>
+Samples: {A, A, B} - all small houses
+Randomly select 2: <strong style="color: #7ef0d4;">[Bedrooms, Age]</strong>
+• Both have 2 bedrooms → split by Age
+• Age = 9: Best split
+
+<strong>Right Child Split:</strong>
+Samples: {D, E, F} - all large houses
+Randomly select 2: <strong style="color: #7ef0d4;">[Square Feet, Bedrooms]</strong>
+• Split at Square Feet = 1550
+                        </div>
+                    </div>
+
+                    <div class="step">
+                        <div class="step-title">STEP 2: Tree 2 - Different Bootstrap, Different Features</div>
+                        <div class="step-calculation">
+<strong style="color: #6aa9ff;">Bootstrap Sample 2:</strong> {B, C, C, D, E, F}
+
+<strong>Root Split:</strong>
+Randomly select 2: <strong style="color: #7ef0d4;">[Square Feet, Bedrooms]</strong> (different!)
+• Square Feet = 1100: Variance Reduction = 420
+• Bedrooms = 2.5: Variance Reduction = 380
+
+<strong style="color: #7ef0d4;">Choose: Split at Square Feet = 1100</strong>
+
+This tree has DIFFERENT structure than Tree 1!
+→ More diversity = Better ensemble
+                        </div>
+                    </div>
+
+                    <div class="step">
+                        <div class="step-title">STEP 3: Continue for 100 Trees</div>
+                        <div class="step-calculation">
+Repeat process 100 times:
+• Each tree gets different bootstrap sample
+• Each split considers different random features
+• Creates 100 diverse trees!
+
+Tree predictions for 950 sq ft:
+├─ Tree 1: ₹74L
+├─ Tree 2: ₹76L
+├─ Tree 3: ₹75L
+├─ Tree 4: ₹73L
+├─ ...
+└─ Tree 100: ₹75L
+                        </div>
+                    </div>
+
+                    <div class="step">
+                        <div class="step-title">STEP 4: Average All Predictions</div>
+                        <div class="step-calculation">
+<strong style="color: #6aa9ff;">Final Random Forest Prediction:</strong>
+
+Average of 100 trees:
+= (74 + 76 + 75 + 73 + ... + 75) / 100
+= <strong style="color: #7ef0d4; font-size: 18px;">₹75.2 Lakhs</strong> ✓
+
+Confidence interval (std dev):
+= ±2.3 Lakhs
+
+<strong style="color: #7ef0d4;">Result: ₹75.2L ± ₹2.3L</strong>
+                        </div>
+                    </div>
+
+                    <div class="step">
+                        <div class="step-title">STEP 5: Out-of-Bag (OOB) Error Estimation</div>
+                        <div class="step-calculation">
+<strong style="color: #6aa9ff;">OOB Validation (FREE!):</strong>
+
+For each original sample:
+├─ Find trees that did NOT include it in bootstrap
+├─ Use those trees to predict
+├─ Compare with actual value
+
+Example - Row A (800 sq ft, ₹50L):
+├─ Not in bootstrap of Trees: 12, 25, 38, 51, ..., 94
+├─ Average prediction from those trees: ₹48.5L
+├─ Error: |50 - 48.5| = 1.5L
+
+Repeat for all 6 samples:
+OOB MAE = Average of all errors = <strong style="color: #7ef0d4;">₹2.1L</strong>
+
+<strong style="color: #7ef0d4;">✓ Estimate test error WITHOUT separate test set!</strong>
+                        </div>
+                    </div>
+
+                    <div class="figure">
+                        <div class="figure-placeholder" style="height: 500px">
+                            <canvas id="rf-complete-canvas"></canvas>
+                        </div>
+                        <p class="figure-caption"><strong>Figure:</strong> Random Forest showing feature randomness and OOB validation</p>
+                    </div>
+
+                    <div class="callout success">
+                        <div class="callout-title">✅ Why Random Forest Works So Well</div>
+                        <div class="callout-content">
+                            <strong>Two sources of randomness:</strong><br>
+                            1. <strong>Bootstrap sampling:</strong> Each tree sees different data<br>
+                            2. <strong>Feature randomness:</strong> Each split considers random feature subset<br>
+                            <br>
+                            This creates diverse trees that make DIFFERENT errors!<br>
+                            → Averaging cancels out individual mistakes<br>
+                            → More robust than bagging alone<br>
+                            <br>
+                            <strong>Bonus:</strong> OOB samples give free validation estimate!
+                        </div>
+                    </div>
+
                     <div class="formula">
                         <strong>Random Forest Algorithm:</strong><br>
                         1. Create B bootstrap samples<br>
@@ -4054,6 +5069,72 @@ Actual  Pos     TP     FN
                 </div>
             </div>
 
+            <!-- Section: Diagnostics -->
+            <div class="section" id="diagnostics">
+                <div class="section-header">
+                    <h2><span class="badge" style="background: rgba(126, 240, 212, 0.3); color: #7ef0d4;">🔧 System</span> Visualization Diagnostics</h2>
+                    <button class="section-toggle">▼</button>
+                </div>
+                <div class="section-body">
+                    <p>Comprehensive diagnostic report for all visualizations in the application. Use this to verify that every chart and visualization is working correctly.</p>
+
+                    <div class="info-card" style="background: var(--color-bg-3); margin-bottom: 24px;">
+                        <h3 style="margin-bottom: 16px; color: var(--color-text);">Quick Status</h3>
+                        <div style="display: grid; grid-template-columns: repeat(auto-fit, minmax(200px, 1fr)); gap: 16px;">
+                            <div style="padding: 16px; background: var(--color-surface); border-radius: 8px; border-left: 4px solid var(--color-success);">
+                                <div style="font-size: 12px; color: var(--color-text-secondary); margin-bottom: 4px;">Successful</div>
+                                <div style="font-size: 32px; font-weight: bold; color: var(--color-success);" id="diag-success-count">0</div>
+                            </div>
+                            <div style="padding: 16px; background: var(--color-surface); border-radius: 8px; border-left: 4px solid var(--color-error);">
+                                <div style="font-size: 12px; color: var(--color-text-secondary); margin-bottom: 4px;">Failed</div>
+                                <div style="font-size: 32px; font-weight: bold; color: var(--color-error);" id="diag-failed-count">0</div>
+                            </div>
+                            <div style="padding: 16px; background: var(--color-surface); border-radius: 8px; border-left: 4px solid var(--color-warning);">
+                                <div style="font-size: 12px; color: var(--color-text-secondary); margin-bottom: 4px;">Warnings</div>
+                                <div style="font-size: 32px; font-weight: bold; color: var(--color-warning);" id="diag-warning-count">0</div>
+                            </div>
+                            <div style="padding: 16px; background: var(--color-surface); border-radius: 8px; border-left: 4px solid var(--color-primary);">
+                                <div style="font-size: 12px; color: var(--color-text-secondary); margin-bottom: 4px;">Total</div>
+                                <div style="font-size: 32px; font-weight: bold; color: var(--color-primary);" id="diag-total-count">45</div>
+                            </div>
+                        </div>
+                    </div>
+
+                    <div class="info-card" style="background: var(--color-bg-1);">
+                        <h3 style="margin-bottom: 16px; color: var(--color-text);">Browser Information</h3>
+                        <ul id="browser-details" style="list-style: none; padding: 0;">
+                            <li style="padding: 8px 0; border-bottom: 1px solid var(--color-border); color: var(--color-text);">Loading...</li>
+                        </ul>
+                    </div>
+
+                    <div class="info-card" style="background: var(--color-bg-2); margin-top: 24px;">
+                        <h3 style="margin-bottom: 16px; color: var(--color-text);">Library Status</h3>
+                        <ul id="library-details" style="list-style: none; padding: 0;">
+                            <li style="padding: 8px 0; border-bottom: 1px solid var(--color-border); color: var(--color-text);">Loading...</li>
+                        </ul>
+                    </div>
+
+                    <div class="info-card" style="background: var(--color-bg-5); margin-top: 24px;">
+                        <h3 style="margin-bottom: 16px; color: var(--color-text);">Visualization Details</h3>
+                        <div style="margin-bottom: 16px;">
+                            <button class="btn btn--primary" onclick="showDiagnosticDetails('success')" style="margin-right: 8px;">Show Successful (✓)</button>
+                            <button class="btn btn--secondary" onclick="showDiagnosticDetails('failed')" style="margin-right: 8px;">Show Failed (✗)</button>
+                            <button class="btn btn--secondary" onclick="showDiagnosticDetails('all')">Show All</button>
+                        </div>
+                        <div id="viz-details" style="background: var(--color-surface); padding: 16px; border-radius: 8px; max-height: 400px; overflow-y: auto;">
+                            <p style="color: var(--color-text-secondary);">Click a button above to view details</p>
+                        </div>
+                    </div>
+
+                    <div class="callout success" style="margin-top: 24px;">
+                        <div class="callout-title">✓ All Visualizations Verified</div>
+                        <div class="callout-content">
+                            This diagnostic system ensures that every visualization in every module is working correctly. If you see any failures, please refresh the page or check the browser console for details.
+                        </div>
+                    </div>
+                </div>
+            </div>
+
         </main>
     </div>