diff --git "a/notebooks/05_ensemble_v2.ipynb" "b/notebooks/05_ensemble_v2.ipynb"
new file mode 100644--- /dev/null
+++ "b/notebooks/05_ensemble_v2.ipynb"
@@ -0,0 +1,1031 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# 🌲 Notebook 05 — Modelos Ensemble + Naive Bayes\n",
+    "## YouTube Hate Speech Detection\n",
+    "\n",
+    "### ¿Qué hace este notebook?\n",
+    "Comparamos 3 modelos bajo las **mismas condiciones** que el baseline:\n",
+    "- **Random Forest** — ensemble de árboles de decisión, votación por mayoría\n",
+    "- **XGBoost** — gradient boosting, árboles entrenados secuencialmente\n",
+    "- **Complement Naive Bayes** — modelo probabilístico, diseñado para texto pequeño\n",
+    "\n",
+    "### ¿Por qué estos modelos?\n",
+    "El baseline (LR) tiene gap train/test de ~11pp. Buscamos si algún modelo\n",
+    "generaliza mejor con solo 800 muestras de entrenamiento.\n",
+    "\n",
+    "### Contexto del baseline\n",
+    "- LR F1 test: ~0.75 | Gap: ~11pp\n",
+    "- Problema raíz: dataset pequeño (1000 muestras, 8 vídeos específicos)\n",
+    "- Los nombres propios ya fueron eliminados del vocabulario\n",
+    "\n",
+    "### ¿Por qué Complement Naive Bayes?\n",
+    "MultinomialNB modela qué palabras son frecuentes en cada clase.\n",
+    "**ComplementNB** modela qué palabras son RARAS en cada clase — más robusto\n",
+    "con datasets pequeños y clases casi balanceadas como el nuestro.\n",
+    "\n",
+    "### Output\n",
+    "- Tabla comparativa de los 4 modelos (LR + RF + XGBoost + CNB)\n",
+    "- Modelo ganador guardado en `models/best_ensemble.joblib`\n",
+    "- Experimento registrado en MLflow: `Youtube_project_experiment`"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 0. Imports y configuración"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "kernel\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(\"kernel\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/under/miniconda3/envs/py310/lib/python3.10/site-packages/tqdm/auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n",
+      "  from .autonotebook import tqdm as notebook_tqdm\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "PROJECT_ROOT: /mnt/c/Users/under/Documents/F5/3_Projects/Project_9_Equipo3/Project_YT\n"
+     ]
+    }
+   ],
+   "source": [
+    "import sys\n",
+    "import yaml\n",
+    "import joblib\n",
+    "import numpy as np\n",
+    "import pandas as pd\n",
+    "import matplotlib.pyplot as plt\n",
+    "import seaborn as sns\n",
+    "import mlflow\n",
+    "import mlflow.sklearn\n",
+    "from pathlib import Path\n",
+    "from sklearn.ensemble import RandomForestClassifier\n",
+    "from sklearn.naive_bayes import ComplementNB\n",
+    "from sklearn.linear_model import LogisticRegression\n",
+    "from sklearn.feature_extraction.text import TfidfVectorizer\n",
+    "from sklearn.pipeline import Pipeline\n",
+    "from sklearn.model_selection import train_test_split, StratifiedKFold, cross_validate\n",
+    "from sklearn.metrics import f1_score, roc_auc_score, classification_report, confusion_matrix\n",
+    "from xgboost import XGBClassifier\n",
+    "import warnings\n",
+    "warnings.filterwarnings('ignore')\n",
+    "\n",
+    "PROJECT_ROOT = Path.cwd().parent\n",
+    "sys.path.insert(0, str(PROJECT_ROOT))\n",
+    "\n",
+    "plt.rcParams['figure.figsize'] = (12, 5)\n",
+    "plt.rcParams['axes.spines.top'] = False\n",
+    "plt.rcParams['axes.spines.right'] = False\n",
+    "\n",
+    "print(f'PROJECT_ROOT: {PROJECT_ROOT}')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "RF config : {'n_estimators': 100, 'max_depth': 10, 'min_samples_split': 10, 'min_samples_leaf': 5, 'max_features': 'sqrt', 'class_weight': 'balanced', 'n_jobs': -1}\n",
+      "XGB config: {'n_estimators': 100, 'max_depth': 3, 'learning_rate': 0.1, 'subsample': 0.8, 'colsample_bytree': 0.8, 'min_child_weight': 5, 'reg_lambda': 1, 'scale_pos_weight': 1}\n"
+     ]
+    }
+   ],
+   "source": [
+    "CONFIG_FEAT = PROJECT_ROOT / 'configs' / 'features.yaml'\n",
+    "CONFIG_PIPE = PROJECT_ROOT / 'configs' / 'pipeline.yaml'\n",
+    "CONFIG_MOD  = PROJECT_ROOT / 'configs' / 'models.yaml'\n",
+    "\n",
+    "with open(CONFIG_FEAT) as f: feat_cfg = yaml.safe_load(f)\n",
+    "with open(CONFIG_PIPE) as f: pipe_cfg = yaml.safe_load(f)\n",
+    "with open(CONFIG_MOD)  as f: mod_cfg  = yaml.safe_load(f)\n",
+    "\n",
+    "tfidf_cfg = feat_cfg['vectorization']['tfidf']\n",
+    "rf_cfg    = mod_cfg['models']['random_forest']\n",
+    "xgb_cfg   = mod_cfg['models']['xgboost']\n",
+    "lr_cfg    = mod_cfg['models']['logistic_regression']\n",
+    "TARGET    = pipe_cfg['data']['target_binary']\n",
+    "RAND      = pipe_cfg['pipeline']['random_state']\n",
+    "TEST_SIZE = pipe_cfg['pipeline']['test_size']\n",
+    "CV_FOLDS  = pipe_cfg['pipeline']['cv_folds']\n",
+    "\n",
+    "print('RF config :', rf_cfg)\n",
+    "print('XGB config:', xgb_cfg)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 1. Carga de datos y split\n",
+    "\n",
+    "Mismo split que en todos los notebooks anteriores.\n",
+    "`random_state` fijo desde YAML garantiza comparación justa entre modelos."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Train: 800 | Test: 200\n",
+      "Baseline referencia — LR F1 test: ~0.75 | Gap: ~11pp\n"
+     ]
+    }
+   ],
+   "source": [
+    "PROCESSED = PROJECT_ROOT / 'data' / 'processed' / 'v2' / 'comments_preprocessed.csv'\n",
+    "\n",
+    "df = pd.read_csv(PROCESSED)\n",
+    "df['clean_text'] = df['clean_text'].fillna('').astype(str)\n",
+    "\n",
+    "X = df['clean_text']\n",
+    "y = df[TARGET]\n",
+    "\n",
+    "X_train, X_test, y_train, y_test = train_test_split(\n",
+    "    X, y, test_size=TEST_SIZE, random_state=RAND, stratify=y\n",
+    ")\n",
+    "\n",
+    "print(f'Train: {len(X_train)} | Test: {len(X_test)}')\n",
+    "print(f'Baseline referencia — LR F1 test: ~0.75 | Gap: ~11pp')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 2. Vectorizador compartido\n",
+    "\n",
+    "Todos los modelos usan el mismo TF-IDF con los mismos parámetros.\n",
+    "Esto garantiza que las diferencias en métricas vienen del clasificador,\n",
+    "no del vectorizador."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "TF-IDF: max_features=5000 | ngram=[1, 2] | min_df=3\n",
+      "CV: 5-fold StratifiedKFold\n"
+     ]
+    }
+   ],
+   "source": [
+    "def make_tfidf():\n",
+    "    \"\"\"Crea TF-IDF con config del YAML. Llamar una vez por modelo.\"\"\"\n",
+    "    return TfidfVectorizer(\n",
+    "        max_features = tfidf_cfg['max_features'],\n",
+    "        ngram_range  = tuple(tfidf_cfg['ngram_range']),\n",
+    "        sublinear_tf = tfidf_cfg['sublinear_tf'],\n",
+    "        min_df       = tfidf_cfg['min_df'],\n",
+    "        analyzer     = 'word',\n",
+    "        strip_accents= 'unicode',\n",
+    "    )\n",
+    "\n",
+    "cv_strategy = StratifiedKFold(n_splits=CV_FOLDS, shuffle=True, random_state=RAND)\n",
+    "scoring = {'f1': 'f1_weighted', 'roc_auc': 'roc_auc',\n",
+    "           'precision': 'precision_weighted', 'recall': 'recall_weighted'}\n",
+    "\n",
+    "print(f'TF-IDF: max_features={tfidf_cfg[\"max_features\"]} | ngram={tfidf_cfg[\"ngram_range\"]} | min_df={tfidf_cfg[\"min_df\"]}')\n",
+    "print(f'CV: {CV_FOLDS}-fold StratifiedKFold')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 3. Complement Naive Bayes\n",
+    "\n",
+    "### ¿Cómo funciona Naive Bayes?\n",
+    "Aplica el teorema de Bayes asumiendo independencia entre features:\n",
+    "```\n",
+    "P(toxico | palabras) ∝ P(toxico) × ∏ P(palabra_i | toxico)\n",
+    "```\n",
+    "El modelo aprende qué probabilidad tiene cada palabra dado cada clase.\n",
+    "\n",
+    "### ¿Por qué Complement?\n",
+    "**MultinomialNB** aprende P(palabra | clase_positiva).\n",
+    "**ComplementNB** aprende P(palabra | **NOT** clase) — más estable con\n",
+    "datasets pequeños porque usa más datos para estimar cada probabilidad.\n",
+    "\n",
+    "### Parámetro alpha\n",
+    "Suavizado de Laplace — evita probabilidad cero para palabras no vistas.\n",
+    "`alpha=1.0` es el valor estándar. Valores menores = más ajuste a los datos."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Ejecutando CV para ComplementNB...\n",
+      "F1 val    : 0.6762 ± 0.0314\n",
+      "F1 train  : 0.8970\n",
+      "Train-Val gap: 22.07 pp ⚠️ Overfitting\n",
+      "ROC-AUC   : 0.7709\n"
+     ]
+    }
+   ],
+   "source": [
+    "# ComplementNB requiere valores no negativos -> TF-IDF es perfecto\n",
+    "pipeline_cnb = Pipeline([\n",
+    "    ('tfidf', make_tfidf()),\n",
+    "    ('clf',   ComplementNB(alpha=1.0))\n",
+    "])\n",
+    "\n",
+    "print('Ejecutando CV para ComplementNB...')\n",
+    "cv_cnb = cross_validate(pipeline_cnb, X_train, y_train,\n",
+    "                         cv=cv_strategy, scoring=scoring,\n",
+    "                         return_train_score=True, n_jobs=-1)\n",
+    "\n",
+    "f1_val = cv_cnb['test_f1'].mean()\n",
+    "f1_train = cv_cnb['train_f1'].mean()\n",
+    "f1_std = cv_cnb['test_f1'].std()\n",
+    "\n",
+    "cv_gap_pp_cnb = abs(f1_train - f1_val) * 100\n",
+    "\n",
+    "roc = cv_cnb['test_roc_auc'].mean()\n",
+    "\n",
+    "flag = '✅ Estable' if cv_gap_pp_cnb < 5 else '⚠️ Overfitting'\n",
+    "\n",
+    "print(f'F1 val    : {f1_val:.4f} ± {f1_std:.4f}')\n",
+    "print(f'F1 train  : {f1_train:.4f}')\n",
+    "print(f'Train-Val gap: {cv_gap_pp_cnb:.2f} pp {flag}')\n",
+    "print(f'ROC-AUC   : {roc:.4f}')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 4. Random Forest\n",
+    "\n",
+    "### ¿Cómo funciona?\n",
+    "Entrena N árboles de decisión, cada uno sobre una muestra aleatoria del dataset\n",
+    "y un subconjunto aleatorio de features. La predicción final es la votación de todos.\n",
+    "\n",
+    "### Anti-overfitting con dataset pequeño\n",
+    "Sin restricciones, RF memoriza los 800 ejemplos de entrenamiento perfectamente.\n",
+    "Los parámetros clave para controlarlo:\n",
+    "- `max_depth=8` → limita la profundidad de cada árbol\n",
+    "- `min_samples_leaf=4` → cada hoja necesita al menos 4 muestras\n",
+    "- `max_features='sqrt'` → cada árbol ve solo √1093 ≈ 33 features\n",
+    "\n",
+    "### RF vs TF-IDF: el problema\n",
+    "RF fue diseñado para features densas. Con 98.8% de esparsidad,\n",
+    "la mayoría de splits son poco informativos. LR y NB son naturalmente\n",
+    "mejores con matrices sparse."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Ejecutando CV para Random Forest...\n",
+      "F1 val    : 0.6942 ± 0.0310\n",
+      "F1 train  : 0.8212\n",
+      "Train-Val gap: 12.70 pp ⚠️ Overfitting\n",
+      "ROC-AUC   : 0.7567\n"
+     ]
+    }
+   ],
+   "source": [
+    "pipeline_rf = Pipeline([\n",
+    "    ('tfidf', make_tfidf()),\n",
+    "    ('clf', RandomForestClassifier(\n",
+    "        n_estimators    = rf_cfg['n_estimators'],\n",
+    "        max_depth       = 8,        # restriccion anti-overfitting\n",
+    "        min_samples_leaf= 4,        # cada hoja necesita 4+ muestras\n",
+    "        max_features    = 'sqrt',   # sqrt(1093) ~ 33 features por arbol\n",
+    "        class_weight    = rf_cfg['class_weight'],\n",
+    "        random_state    = RAND,\n",
+    "        n_jobs          = -1\n",
+    "    ))\n",
+    "])\n",
+    "\n",
+    "print('Ejecutando CV para Random Forest...')\n",
+    "cv_rf = cross_validate(pipeline_rf, X_train, y_train,\n",
+    "                        cv=cv_strategy, scoring=scoring,\n",
+    "                        return_train_score=True, n_jobs=-1)\n",
+    "\n",
+    "f1_val = cv_rf['test_f1'].mean()\n",
+    "f1_train = cv_rf['train_f1'].mean()\n",
+    "f1_std = cv_rf['test_f1'].std()\n",
+    "\n",
+    "cv_gap_pp_rf = abs(f1_train - f1_val) * 100\n",
+    "\n",
+    "roc = cv_rf['test_roc_auc'].mean()\n",
+    "\n",
+    "flag = '✅ Estable' if cv_gap_pp_rf < 5 else '⚠️ Overfitting'\n",
+    "\n",
+    "print(f'F1 val    : {f1_val:.4f} ± {f1_std:.4f}')\n",
+    "print(f'F1 train  : {f1_train:.4f}')\n",
+    "print(f'Train-Val gap: {cv_gap_pp_rf:.2f} pp {flag}')\n",
+    "print(f'ROC-AUC   : {roc:.4f}')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 5. XGBoost\n",
+    "\n",
+    "### ¿Cómo funciona?\n",
+    "Gradient Boosting: entrena árboles **secuencialmente**.\n",
+    "Cada árbol aprende a corregir los errores del anterior.\n",
+    "El resultado es una suma ponderada de árboles débiles.\n",
+    "\n",
+    "### Diferencia clave con RF\n",
+    "- **RF**: árboles en paralelo, independientes, vota la mayoría\n",
+    "- **XGBoost**: árboles en serie, cada uno se enfoca en los errores previos\n",
+    "\n",
+    "### Parámetros anti-overfitting para dataset pequeño\n",
+    "- `max_depth=3` → árboles muy simples (RF usa 8)\n",
+    "- `learning_rate=0.05` → pasos pequeños, más conservador\n",
+    "- `subsample=0.8` → cada árbol ve solo el 80% de los datos\n",
+    "- `colsample_bytree=0.8` → cada árbol ve el 80% de features\n",
+    "- `n_estimators=200` con `eval_metric` → más árboles pero simples"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Ejecutando CV para XGBoost...\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "F1 val    : 0.6331 ± 0.0221\n",
+      "F1 train  : 0.7602\n",
+      "Train-Val gap: 12.72 pp ⚠️ Overfitting\n",
+      "ROC-AUC   : 0.6535\n"
+     ]
+    }
+   ],
+   "source": [
+    "pipeline_xgb = Pipeline([\n",
+    "    ('tfidf', make_tfidf()),\n",
+    "    ('clf', XGBClassifier(\n",
+    "        n_estimators      = 200,\n",
+    "        max_depth         = 3,          # arboles simples\n",
+    "        learning_rate     = 0.05,       # pasos pequenos\n",
+    "        subsample         = 0.8,\n",
+    "        colsample_bytree  = 0.8,\n",
+    "        scale_pos_weight  = y_train.value_counts()[False] / y_train.value_counts()[True],\n",
+    "        random_state      = RAND,\n",
+    "        eval_metric       = 'logloss',\n",
+    "        verbosity         = 0,\n",
+    "        min_child_weight  = 5,\n",
+    "        reg_lambda        = 1,\n",
+    "        use_label_encoder = False,\n",
+    "    ))\n",
+    "])\n",
+    "\n",
+    "print('Ejecutando CV para XGBoost...')\n",
+    "cv_xgb = cross_validate(pipeline_xgb, X_train, y_train,\n",
+    "                         cv=cv_strategy, scoring=scoring,\n",
+    "                         return_train_score=True, n_jobs=-1)\n",
+    "\n",
+    "\n",
+    "f1_val = cv_xgb['test_f1'].mean()\n",
+    "f1_train = cv_xgb['train_f1'].mean()\n",
+    "f1_std = cv_xgb['test_f1'].std()\n",
+    "\n",
+    "cv_gap_pp_xgb  = abs(f1_train - f1_val) * 100\n",
+    "\n",
+    "roc = cv_xgb['test_roc_auc'].mean()\n",
+    "\n",
+    "flag = '✅ Estable' if cv_gap_pp_xgb < 5 else '⚠️ Overfitting'\n",
+    "\n",
+    "print(f'F1 val    : {f1_val:.4f} ± {f1_std:.4f}')\n",
+    "print(f'F1 train  : {f1_train:.4f}')\n",
+    "print(f'Train-Val gap: {cv_gap_pp_xgb:.2f} pp {flag}')\n",
+    "print(f'ROC-AUC   : {roc:.4f}')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 6. Tabla comparativa — los 4 modelos\n",
+    "\n",
+    "Comparamos todos los modelos bajo exactamente las mismas condiciones.\n",
+    "El ganador se entrena en todo X_train y se evalúa en test."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 20,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "LR CV reconstruido\n",
+      "F1 val   : 0.7015\n",
+      "F1 train : 0.8839\n",
+      "Gap      : 18.24 pp\n",
+      "ROC-AUC  : 0.7737\n"
+     ]
+    }
+   ],
+   "source": [
+    "lr_model = joblib.load(\"../models/lr_baseline.joblib\")\n",
+    "\n",
+    "cv_lr = cross_validate(\n",
+    "    lr_model,\n",
+    "    X_train,\n",
+    "    y_train,\n",
+    "    cv=cv_strategy,\n",
+    "    scoring=scoring,\n",
+    "    return_train_score=True,\n",
+    "    n_jobs=-1\n",
+    ")\n",
+    "\n",
+    "LR_f1_val   = cv_lr['test_f1'].mean()\n",
+    "LR_f1_train = cv_lr['train_f1'].mean()\n",
+    "LR_gap      = LR_f1_train - LR_f1_val\n",
+    "LR_roc      = cv_lr['test_roc_auc'].mean()\n",
+    "\n",
+    "print(\"LR CV reconstruido\")\n",
+    "print(f\"F1 val   : {LR_f1_val:.4f}\")\n",
+    "print(f\"F1 train : {LR_f1_train:.4f}\")\n",
+    "print(f\"Gap      : {LR_gap*100:.2f} pp\")\n",
+    "print(f\"ROC-AUC  : {LR_roc:.4f}\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 22,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "COMPARATIVA DE MODELOS — CV (CLEAN)\n",
+      "======================================================================\n",
+      "Modelo                     F1 Val   F1 Train     Gap pp    ROC-AUC      Rúbrica\n",
+      "----------------------------------------------------------------------\n",
+      "Logistic Regression        0.7015     0.8839      18.2     0.7737    ⚠️ 18.2pp\n",
+      "Random Forest              0.6942     0.8212      12.7     0.7567    ⚠️ 12.7pp\n",
+      "Complement NB              0.6762     0.8970      22.1     0.7709    ⚠️ 22.1pp\n",
+      "XGBoost                    0.6331     0.7602      12.7     0.6535    ⚠️ 12.7pp\n",
+      "\n",
+      "GANADOR:\n",
+      "Logistic Regression\n",
+      "F1: 0.7015\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Resultados LR del notebook anterior (copiar valores reales)\n",
+    "# Si re-ejecutas LR aqui, usa estos valores del notebook 04\n",
+    "\n",
+    "results = {\n",
+    "    'Logistic Regression': {\n",
+    "        'f1_val'  : LR_f1_val,\n",
+    "        'f1_train': LR_f1_train,\n",
+    "        'gap'     : LR_f1_train - LR_f1_val,\n",
+    "        'roc_auc' : LR_roc,\n",
+    "    },\n",
+    "    'Complement NB': {\n",
+    "        'f1_val'  : cv_cnb['test_f1'].mean(),\n",
+    "        'f1_train': cv_cnb['train_f1'].mean(),\n",
+    "        'gap'     : cv_cnb['train_f1'].mean() - cv_cnb['test_f1'].mean(),\n",
+    "        'roc_auc' : cv_cnb['test_roc_auc'].mean(),\n",
+    "    },\n",
+    "    'Random Forest': {\n",
+    "        'f1_val'  : cv_rf['test_f1'].mean(),\n",
+    "        'f1_train': cv_rf['train_f1'].mean(),\n",
+    "        'gap'     : cv_rf['train_f1'].mean() - cv_rf['test_f1'].mean(),\n",
+    "        'roc_auc' : cv_rf['test_roc_auc'].mean(),\n",
+    "    },\n",
+    "    'XGBoost': {\n",
+    "        'f1_val'  : cv_xgb['test_f1'].mean(),\n",
+    "        'f1_train': cv_xgb['train_f1'].mean(),\n",
+    "        'gap'     : cv_xgb['train_f1'].mean() - cv_xgb['test_f1'].mean(),\n",
+    "        'roc_auc' : cv_xgb['test_roc_auc'].mean(),\n",
+    "    },\n",
+    "}\n",
+    "\n",
+    "comp_df = pd.DataFrame(results).T\n",
+    "\n",
+    "# convertir a porcentaje SOLO para display\n",
+    "comp_df['gap_pp'] = comp_df['gap'] * 100\n",
+    "\n",
+    "comp_df['rubrica'] = comp_df['gap_pp'].apply(\n",
+    "    lambda x: '✅ OK' if x < 5 else f'⚠️ {x:.1f}pp'\n",
+    ")\n",
+    "\n",
+    "comp_df = comp_df.sort_values('f1_val', ascending=False)\n",
+    "\n",
+    "\n",
+    "print('COMPARATIVA DE MODELOS — CV (CLEAN)')\n",
+    "print('=' * 70)\n",
+    "print(f\"{'Modelo':22} {'F1 Val':>10} {'F1 Train':>10} {'Gap pp':>10} {'ROC-AUC':>10} {'Rúbrica':>12}\")\n",
+    "print('-' * 70)\n",
+    "\n",
+    "for model, row in comp_df.iterrows():\n",
+    "    print(\n",
+    "        f\"{model:22} \"\n",
+    "        f\"{row['f1_val']:>10.4f} \"\n",
+    "        f\"{row['f1_train']:>10.4f} \"\n",
+    "        f\"{row['gap_pp']:>9.1f} \"\n",
+    "        f\"{row['roc_auc']:>10.4f} \"\n",
+    "        f\"{row['rubrica']:>12}\"\n",
+    "    )\n",
+    "\n",
+    "best_model = comp_df['f1_val'].idxmax()\n",
+    "\n",
+    "print('\\nGANADOR:')\n",
+    "print(best_model)\n",
+    "print(f\"F1: {comp_df.loc[best_model, 'f1_val']:.4f}\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 25,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1400x600 with 2 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Guardado en reports/v2/12_ensemble_comparativa.png\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Visualizacion comparativa\n",
+    "fig, axes = plt.subplots(1, 2, figsize=(14, 6))\n",
+    "models_list = list(comp_df.index)\n",
+    "colors = ['#5DCAA5' if g < 5 else '#E8593C' for g in comp_df['gap_pp']]\n",
+    "x = np.arange(len(models_list))\n",
+    "width = 0.35\n",
+    "\n",
+    "# F1 train vs val\n",
+    "axes[0].bar(x - width/2, comp_df['f1_train'], width,\n",
+    "            label='F1 Train', color='#7F77DD', alpha=0.8)\n",
+    "axes[0].bar(x + width/2, comp_df['f1_val'], width,\n",
+    "            label='F1 Val', color=colors, alpha=0.8)\n",
+    "axes[0].axhline(0.75, color='gray', linestyle='--', alpha=0.5, label='Baseline LR ~0.75')\n",
+    "axes[0].set_title('F1 Train vs Validacion', fontweight='bold')\n",
+    "axes[0].set_xticks(x)\n",
+    "axes[0].set_xticklabels([m.replace(' ', '\\n') for m in models_list], fontsize=9)\n",
+    "axes[0].set_ylim(0.5, 1.0)\n",
+    "axes[0].legend()\n",
+    "\n",
+    "# Gap\n",
+    "gap_colors = ['#5DCAA5' if g < 5 else '#E8593C' for g in comp_df['gap_pp']]\n",
+    "axes[1].bar(models_list, comp_df['gap_pp'], color=gap_colors, alpha=0.8, width=0.5)\n",
+    "axes[1].axhline(5, color='red', linestyle='--', linewidth=1.5, label='Límite rúbrica (5pp)')\n",
+    "axes[1].set_title('Gap Train-Val (pp) — menor es mejor')\n",
+    "axes[1].set_ylabel('Diferencia en puntos porcentuales')\n",
+    "axes[1].set_xticks(np.arange(len(models_list)))\n",
+    "axes[1].set_xticklabels([m.replace(' ', '\\n') for m in models_list], fontsize=9)\n",
+    "axes[1].legend()\n",
+    "\n",
+    "plt.tight_layout()\n",
+    "plt.savefig(PROJECT_ROOT / 'reports' / 'v2' / '12_ensemble_comparativa.png',\n",
+    "            dpi=150, bbox_inches='tight')\n",
+    "plt.show()\n",
+    "print('Guardado en reports/v2/12_ensemble_comparativa.png')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 7. Evaluación final del ganador en test\n",
+    "\n",
+    "Entrenamos el mejor modelo en todo X_train y evaluamos en test.\n",
+    "Este número es el que va al informe final."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 26,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Entrenando Logistic Regression en todo X_train...\n",
+      "=======================================================\n",
+      "RESULTADOS FINALES — Logistic Regression\n",
+      "=======================================================\n",
+      "F1 Train  : 0.8623\n",
+      "F1 Test   : 0.7531\n",
+      "Gap       : 10.91 pp  ⚠️\n",
+      "ROC-AUC   : 0.8075\n",
+      "\n",
+      "              precision    recall  f1-score   support\n",
+      "\n",
+      "   No toxico       0.75      0.82      0.78       108\n",
+      "      Toxico       0.77      0.67      0.72        92\n",
+      "\n",
+      "    accuracy                           0.76       200\n",
+      "   macro avg       0.76      0.75      0.75       200\n",
+      "weighted avg       0.76      0.76      0.75       200\n",
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Mapeo de nombres a pipelines\n",
+    "pipelines = {\n",
+    "    'Logistic Regression': Pipeline([\n",
+    "        ('tfidf', make_tfidf()),\n",
+    "        ('clf', LogisticRegression(\n",
+    "            C            = lr_cfg['C'],\n",
+    "            max_iter     = lr_cfg['max_iter'],\n",
+    "            class_weight = lr_cfg['class_weight'],\n",
+    "            solver       = lr_cfg['solver'],\n",
+    "            random_state = RAND,\n",
+    "        ))\n",
+    "    ]),   # ya evaluado en notebook 04\n",
+    "    'Complement NB'      : pipeline_cnb,\n",
+    "    'Random Forest'      : pipeline_rf,\n",
+    "    'XGBoost'            : pipeline_xgb,\n",
+    "}\n",
+    "\n",
+    "best_pipeline = pipelines[best_model]\n",
+    "print(f'Entrenando {best_model} en todo X_train...')\n",
+    "best_pipeline.fit(X_train, y_train)\n",
+    "\n",
+    "y_pred       = best_pipeline.predict(X_test)\n",
+    "y_pred_proba = best_pipeline.predict_proba(X_test)[:, 1]\n",
+    "y_pred_train = best_pipeline.predict(X_train)\n",
+    "\n",
+    "f1_train_final = f1_score(y_train, y_pred_train, average='weighted')\n",
+    "f1_test_final  = f1_score(y_test,  y_pred,       average='weighted')\n",
+    "\n",
+    "gap_final_pp = abs(f1_train_final - f1_test_final) * 100\n",
+    "roc_auc_final = roc_auc_score(y_test, y_pred_proba)\n",
+    "\n",
+    "print('=' * 55)\n",
+    "print(f'RESULTADOS FINALES — {best_model}')\n",
+    "print('=' * 55)\n",
+    "print(f'F1 Train  : {f1_train_final:.4f}')\n",
+    "print(f'F1 Test   : {f1_test_final:.4f}')\n",
+    "print(f'Gap       : {gap_final_pp:.2f} pp  {\"✅\" if gap_final_pp < 5 else \"⚠️\"}')\n",
+    "print(f'ROC-AUC   : {roc_auc_final:.4f}')\n",
+    "print()\n",
+    "print(classification_report(y_test, y_pred, target_names=['No toxico','Toxico']))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 27,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1300x500 with 3 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# Matriz de confusion del ganador\n",
+    "fig, axes = plt.subplots(1, 2, figsize=(13, 5))\n",
+    "\n",
+    "cm = confusion_matrix(y_test, y_pred)\n",
+    "sns.heatmap(cm, annot=True, fmt='d', cmap='Blues', ax=axes[0],\n",
+    "            xticklabels=['No toxico','Toxico'],\n",
+    "            yticklabels=['No toxico','Toxico'],\n",
+    "            linewidths=0.5)\n",
+    "axes[0].set_title(f'Confusión — {best_model}', fontweight='bold')\n",
+    "axes[0].set_ylabel('Real')\n",
+    "axes[0].set_xlabel('Predicho')\n",
+    "\n",
+    "from sklearn.metrics import RocCurveDisplay\n",
+    "RocCurveDisplay.from_predictions(y_test, y_pred_proba, ax=axes[1],\n",
+    "                                  color='#5DCAA5', name=best_model)\n",
+    "axes[1].plot([0,1],[0,1],'--', color='gray', alpha=0.5)\n",
+    "axes[1].set_title('Curva ROC — ganador', fontweight='bold')\n",
+    "\n",
+    "plt.tight_layout()\n",
+    "plt.savefig(PROJECT_ROOT / 'reports' / 'v2' / '13_best_model_test.png',\n",
+    "            dpi=150, bbox_inches='tight')\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 8. Registro en MLflow\n",
+    "\n",
+    "Registramos los 3 modelos en el mismo experimento para\n",
+    "compararlos directamente en el dashboard de MLflow."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 28,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "  ✅ complement_nb registrado\n",
+      "  ✅ random_forest registrado\n",
+      "  ✅ xgboost registrado\n",
+      "\n",
+      "Todos los modelos registrados en MLflow\n",
+      "  Ver: mlflow ui --backend-store-uri file:///mnt/c/Users/under/Documents/F5/3_Projects/Project_9_Equipo3/Project_YT/mlruns\n"
+     ]
+    }
+   ],
+   "source": [
+    "MLFLOW_DIR = PROJECT_ROOT / 'mlruns'\n",
+    "mlflow.set_tracking_uri(f'file://{MLFLOW_DIR}')\n",
+    "mlflow.set_experiment('Youtube_project_experiment')\n",
+    "\n",
+    "model_configs = {\n",
+    "    'complement_nb' : (pipeline_cnb,  cv_cnb,  {'alpha': 1.0}),\n",
+    "    'random_forest' : (pipeline_rf,   cv_rf,   {'max_depth': 8, 'min_samples_leaf': 4}),\n",
+    "    'xgboost'       : (pipeline_xgb,  cv_xgb,  {'max_depth': 3, 'learning_rate': 0.05}),\n",
+    "}\n",
+    "\n",
+    "for run_name, (pipe, cv_res, extra_params) in model_configs.items():\n",
+    "    with mlflow.start_run(run_name=run_name):\n",
+    "\n",
+    "        mlflow.log_param('model', run_name)\n",
+    "        mlflow.log_param('vectorizer', 'tfidf')\n",
+    "        mlflow.log_param('tfidf_features', tfidf_cfg['max_features'])\n",
+    "        mlflow.log_param('ngram_range', str(tuple(tfidf_cfg['ngram_range'])))\n",
+    "        mlflow.log_param('cv_folds', CV_FOLDS)\n",
+    "\n",
+    "        for k, v in extra_params.items():\n",
+    "            mlflow.log_param(k, v)\n",
+    "\n",
+    "        cv_gap_pp = abs(cv_res['train_f1'].mean() - cv_res['test_f1'].mean()) * 100\n",
+    "\n",
+    "        mlflow.log_metric('cv_f1_val', cv_res['test_f1'].mean())\n",
+    "        mlflow.log_metric('cv_f1_train', cv_res['train_f1'].mean())\n",
+    "        mlflow.log_metric('cv_gap_pp', round(cv_gap_pp, 2))\n",
+    "        mlflow.log_metric('cv_roc_auc', cv_res['test_roc_auc'].mean())\n",
+    "        mlflow.log_metric('cv_f1_std', cv_res['test_f1'].std())\n",
+    "\n",
+    "        if run_name.replace('_', ' ').lower() == best_model.lower():\n",
+    "            mlflow.log_metric('test_f1', f1_test_final)\n",
+    "            mlflow.log_metric('test_gap_pp', round(gap_final_pp, 2))\n",
+    "            mlflow.sklearn.log_model(pipe, f'{run_name}_pipeline')\n",
+    "\n",
+    "        print(f'  ✅ {run_name} registrado')\n",
+    "\n",
+    "mlflow.log_artifact(str(PROJECT_ROOT / 'reports' / 'v2' / '12_ensemble_comparativa.png'))\n",
+    "print('\\nTodos los modelos registrados en MLflow')\n",
+    "print(f'  Ver: mlflow ui --backend-store-uri file://{MLFLOW_DIR}')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 9. Guardar modelo ganador\n",
+    "\n",
+    "Guardamos el pipeline completo del ganador.\n",
+    "Este es el modelo que usará la API y la app de Streamlit."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 29,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Modelo guardado: /mnt/c/Users/under/Documents/F5/3_Projects/Project_9_Equipo3/Project_YT/models/best_ensemble.joblib\n",
+      "\n",
+      "Verificacion:\n",
+      "  ✅ [TOXICO 0.72] you are a stupid thug get out\n",
+      "  ✅ [NO TOXICO 0.43] I think the police should be more transparent\n",
+      "  ✅ [TOXICO 0.58] black people are criminal thugs\n",
+      "  ✅ [NO TOXICO 0.27] thank you for sharing this video\n"
+     ]
+    }
+   ],
+   "source": [
+    "MODELS_DIR = PROJECT_ROOT / 'models'\n",
+    "MODELS_DIR.mkdir(exist_ok=True)\n",
+    "\n",
+    "model_path = MODELS_DIR / 'best_ensemble.joblib'\n",
+    "joblib.dump(best_pipeline, model_path)\n",
+    "print(f'Modelo guardado: {model_path}')\n",
+    "\n",
+    "# Verificacion\n",
+    "loaded = joblib.load(model_path)\n",
+    "tests = [\n",
+    "    ('you are a stupid thug get out', True),\n",
+    "    ('I think the police should be more transparent', False),\n",
+    "    ('black people are criminal thugs', True),\n",
+    "    ('thank you for sharing this video', False),\n",
+    "]\n",
+    "print('\\nVerificacion:')\n",
+    "for text, expected in tests:\n",
+    "    pred = loaded.predict([text])[0]\n",
+    "    prob = loaded.predict_proba([text])[0][1]\n",
+    "    ok = '✅' if pred == expected else '❌'\n",
+    "    label = 'TOXICO' if pred else 'NO TOXICO'\n",
+    "    print(f'  {ok} [{label} {prob:.2f}] {text[:55]}')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 10. Conclusiones y decisiones"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 31,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "cnb_f1 = cv_cnb['test_f1'].mean()\n",
+    "cnb_gap = abs(cv_cnb['train_f1'].mean() - cv_cnb['test_f1'].mean()) * 100\n",
+    "\n",
+    "rf_f1 = cv_rf['test_f1'].mean()\n",
+    "rf_gap = abs(cv_rf['train_f1'].mean() - cv_rf['test_f1'].mean()) * 100\n",
+    "\n",
+    "xgb_f1 = cv_xgb['test_f1'].mean()\n",
+    "xgb_gap = abs(cv_xgb['train_f1'].mean() - cv_xgb['test_f1'].mean()) * 100"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 32,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "CONCLUSIONES — ENSEMBLE + NAIVE BAYES\n",
+      "=======================================================\n",
+      "\n",
+      "Modelos evaluados:\n",
+      "  Logistic Regression  F1~0.70 gap~18pp (referencia)\n",
+      "  Complement NB        F1=0.6762 gap=22.07pp\n",
+      "  Random Forest        F1=0.6942 gap=12.70pp\n",
+      "  XGBoost              F1=0.6331 gap=12.72pp\n",
+      "\n",
+      "Ganador CV: Logistic Regression\n",
+      "\n",
+      "  F1 test  : 0.7531\n",
+      "  Gap final: 10.91pp\n",
+      "\n",
+      "Observacion sobre el overfitting:\n",
+      "  Con 800 muestras y vocabulario especifico de 8 videos,\n",
+      "  un gap < 5pp es difícil de alcanzar sin data augmentation.\n",
+      "  El gap es una limitacion conocida del dataset, no del modelo.\n",
+      "\n",
+      "Modelo guardado:\n",
+      "  models/best_ensemble.joblib\n",
+      "\n",
+      "Siguiente:\n",
+      "  -> 06_tuning.ipynb\n",
+      "     Optuna sobre Logistic Regression\n",
+      "     Objetivo: mejorar F1 test y reducir gap\n",
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(f\"\"\"\n",
+    "CONCLUSIONES — ENSEMBLE + NAIVE BAYES\n",
+    "{'='*55}\n",
+    "\n",
+    "Modelos evaluados:\n",
+    "  Logistic Regression  F1~0.70 gap~18pp (referencia)\n",
+    "  Complement NB        F1={cnb_f1:.4f} gap={cnb_gap:.2f}pp\n",
+    "  Random Forest        F1={rf_f1:.4f} gap={rf_gap:.2f}pp\n",
+    "  XGBoost              F1={xgb_f1:.4f} gap={xgb_gap:.2f}pp\n",
+    "\n",
+    "Ganador CV: {best_model}\n",
+    "\n",
+    "  F1 test  : {f1_test_final:.4f}\n",
+    "  Gap final: {gap_final_pp:.2f}pp\n",
+    "\n",
+    "Observacion sobre el overfitting:\n",
+    "  Con 800 muestras y vocabulario especifico de 8 videos,\n",
+    "  un gap < 5pp es difícil de alcanzar sin data augmentation.\n",
+    "  El gap es una limitacion conocida del dataset, no del modelo.\n",
+    "\n",
+    "Modelo guardado:\n",
+    "  models/best_ensemble.joblib\n",
+    "\n",
+    "Siguiente:\n",
+    "  -> 06_tuning.ipynb\n",
+    "     Optuna sobre {best_model}\n",
+    "     Objetivo: mejorar F1 test y reducir gap\n",
+    "\"\"\")"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "py310",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.10.20"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}