diff --git "a/notebooks/03_vectorization_v2.ipynb" "b/notebooks/03_vectorization_v2.ipynb"
new file mode 100644--- /dev/null
+++ "b/notebooks/03_vectorization_v2.ipynb"
@@ -0,0 +1,795 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "2866db9c",
+   "metadata": {},
+   "source": [
+    "# 🔢 Notebook 03 — Vectorización\n",
+    "\n",
+    "Convertimos el texto limpio a números que el modelo puede procesar.\n",
+    "Comparamos **TF-IDF** vs **Bag of Words** y analizamos qué features\n",
+    "captura cada uno.\n",
+    "\n",
+    "El modelo no ve palabras, ve números. Cómo transformemos el texto\n",
+    "define directamente qué puede aprender el modelo.\n",
+    "Un mal vectorizador hace imposible un buen modelo.\n",
+    "\n",
+    "### ¿Por qué TF-IDF sobre BoW en este dataset?\n",
+    "- BoW cuenta apariciones brutas: 'the' pesa igual que 'thug'\n",
+    "- TF-IDF penaliza palabras frecuentes en todos los docs y premia\n",
+    "  las que discriminan entre clases\n",
+    "- Con mediana de 9 tokens por comentario, cada palabra cuenta"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "532b2fc0",
+   "metadata": {},
+   "source": [
+    "## 0. Imports y configuración"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "4259b4ec",
+   "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 numpy as np\n",
+    "import pandas as pd\n",
+    "import matplotlib.pyplot as plt\n",
+    "import seaborn as sns\n",
+    "import mlflow\n",
+    "from pathlib import Path\n",
+    "from sklearn.feature_extraction.text import TfidfVectorizer, CountVectorizer\n",
+    "from sklearn.model_selection import train_test_split\n",
+    "from scipy.sparse import issparse\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": 2,
+   "id": "c8f1081b",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "TF-IDF config: {'max_features': 5000, 'ngram_range': [1, 2], 'sublinear_tf': True, 'min_df': 3}\n",
+      "BoW config    : {'max_features': 5000, 'ngram_range': [1, 1], 'min_df': 3}\n",
+      "random_state  : 42 | test_size: 0.2\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Carga de configuracion\n",
+    "CONFIG_FEAT = PROJECT_ROOT / 'configs' / 'features.yaml'\n",
+    "CONFIG_PIPE = PROJECT_ROOT / 'configs' / 'pipeline.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",
+    "\n",
+    "vec_cfg    = feat_cfg['vectorization']\n",
+    "tfidf_cfg  = vec_cfg['tfidf']\n",
+    "bow_cfg    = vec_cfg['bow']\n",
+    "TARGET_BIN = pipe_cfg['data']['target_binary']\n",
+    "SUBLABELS  = pipe_cfg['data']['target_multilabel']\n",
+    "RAND_STATE = pipe_cfg['pipeline']['random_state']\n",
+    "TEST_SIZE  = pipe_cfg['pipeline']['test_size']\n",
+    "\n",
+    "print('TF-IDF config:', tfidf_cfg)\n",
+    "print('BoW config    :', bow_cfg)\n",
+    "print(f'random_state  : {RAND_STATE} | test_size: {TEST_SIZE}')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "a2337121",
+   "metadata": {},
+   "source": [
+    "## 1. Carga del texto preprocesado\n",
+    "\n",
+    "Usamos el CSV generado por el notebook de preprocesamiento.\n",
+    "**Nunca** vectorizamos texto crudo."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "6b689f0e",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Dataset: (1000, 9)\n",
+      "Nulos en clean_text: 0\n",
+      "Vacios en clean_text: 0\n",
+      "\n",
+      "Distribucion target:\n",
+      "IsToxic\n",
+      "False    538\n",
+      "True     462\n",
+      "Name: count, dtype: int64\n",
+      "\n",
+      "Muestra texto limpio:\n",
+      "  'call anarchist defend cop shoot unarmed civilian highly disappointed beginning r'\n",
+      "  'mother tell I thing god bless woman'\n",
+      "  'love saem thing go peggy stupid ya kill ya self quick stlpd could ever wakeup'\n",
+      "  'next time line car start make burnout smoke riot gas non lethal eficient double '\n"
+     ]
+    }
+   ],
+   "source": [
+    "PROCESSED_PATH = PROJECT_ROOT / 'data' / 'processed' / 'v2' / 'comments_preprocessed.csv'\n",
+    "\n",
+    "df = pd.read_csv(PROCESSED_PATH)\n",
+    "print(f'Dataset: {df.shape}')\n",
+    "print(f'Nulos en clean_text: {df[\"clean_text\"].isnull().sum()}')\n",
+    "print(f'Vacios en clean_text: {(df[\"clean_text\"] == \"\").sum()}')\n",
+    "\n",
+    "# Rellenar vacios con placeholder para no romper el vectorizador\n",
+    "df['clean_text'] = df['clean_text'].fillna('').astype(str)\n",
+    "\n",
+    "print(f'\\nDistribucion target:')\n",
+    "print(df[TARGET_BIN].value_counts())\n",
+    "print()\n",
+    "print('Muestra texto limpio:')\n",
+    "for t in df['clean_text'].sample(4, random_state=42):\n",
+    "    print(f'  {repr(t[:80])}')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "362b8d33",
+   "metadata": {},
+   "source": [
+    "## 2. Train / Test split\n",
+    "\n",
+    "El split se hace **antes** de vectorizar para evitar data leakage.\n",
+    "\n",
+    "> ⚠️ **Data leakage**: si vectorizas todo el dataset y luego splitteas,\n",
+    "> el vectorizador ha 'visto' el test set durante el fit. El vocabulario\n",
+    "> y los IDF scores estarán contaminados con datos de test.\n",
+    "> Resultado: métricas optimistas que no se replican en producción.\n",
+    "\n",
+    "**Regla:** fit del vectorizador **solo** sobre X_train. Transform sobre ambos."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "05cdcb44",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Train : 800 muestras\n",
+      "Test  : 200 muestras\n",
+      "\n",
+      "Distribucion train:\n",
+      "IsToxic\n",
+      "False    430\n",
+      "True     370\n",
+      "Name: count, dtype: int64\n",
+      "\n",
+      "Distribucion test:\n",
+      "IsToxic\n",
+      "False    108\n",
+      "True      92\n",
+      "Name: count, dtype: int64\n"
+     ]
+    }
+   ],
+   "source": [
+    "X = df['clean_text']\n",
+    "y_bin = df[TARGET_BIN]\n",
+    "y_multi = df[SUBLABELS]\n",
+    "\n",
+    "X_train, X_test, y_train, y_test = train_test_split(\n",
+    "    X, y_bin,\n",
+    "    test_size=TEST_SIZE,\n",
+    "    random_state=RAND_STATE,\n",
+    "    stratify=y_bin          # misma proporcion toxic/no-toxic en train y test\n",
+    ")\n",
+    "\n",
+    "print(f'Train : {len(X_train)} muestras')\n",
+    "print(f'Test  : {len(X_test)} muestras')\n",
+    "print()\n",
+    "print('Distribucion train:')\n",
+    "print(y_train.value_counts())\n",
+    "print()\n",
+    "print('Distribucion test:')\n",
+    "print(y_test.value_counts())"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "73ece795",
+   "metadata": {},
+   "source": [
+    "## 3. TF-IDF — Term Frequency Inverse Document Frequency\n",
+    "\n",
+    "### ¿Cómo funciona?\n",
+    "Para cada palabra en cada documento calcula:\n",
+    "```\n",
+    "TF-IDF(palabra, doc) = TF(palabra, doc) × IDF(palabra)\n",
+    "\n",
+    "TF  = frecuencia de la palabra en este documento\n",
+    "IDF = log(total docs / docs que contienen la palabra)\n",
+    "```\n",
+    "**Resultado:** palabras raras pero relevantes tienen peso alto.\n",
+    "Palabras que aparecen en todos los docs (como 'said') tienen peso bajo.\n",
+    "\n",
+    "### Por qué `sublinear_tf=True`\n",
+    "Sin esto, un comentario que dice 'kill' 10 veces pesa 10x más que uno que lo dice 1 vez.\n",
+    "Con `sublinear_tf`: `TF = 1 + log(count)` → escala logarítmica más razonable.\n",
+    "\n",
+    "### Por qué `ngram_range=(1,2)`\n",
+    "Con solo unigramas: 'black' tiene el mismo peso en tóxico y no tóxico.\n",
+    "Con bigramas: 'black thug', 'black criminal' aparecen casi solo en tóxicos."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "81014774",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Vocabulario TF-IDF : 1,093 features\n",
+      "Shape X_train      : (800, 1093)\n",
+      "Shape X_test       : (200, 1093)\n",
+      "Tipo de matriz     : csr_matrix (sparse)\n",
+      "\n",
+      "Valores no-cero    : 10,153 de 874,400\n",
+      "Esparsidad         : 98.8%\n",
+      "\n",
+      "Ejemplo 5 features del vocabulario:\n",
+      "  \"wonder\" -> columna 1063\n",
+      "  \"police\" -> columna 706\n",
+      "  \"expect\" -> columna 300\n",
+      "  \"happen\" -> columna 410\n",
+      "  \"abuse\" -> columna 2\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Fit SOLO sobre train — nunca sobre todo el dataset\n",
+    "tfidf = 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",
+    "X_train_tfidf = tfidf.fit_transform(X_train)   # fit + transform sobre train\n",
+    "X_test_tfidf  = tfidf.transform(X_test)        # solo transform sobre test\n",
+    "\n",
+    "print(f'Vocabulario TF-IDF : {len(tfidf.vocabulary_):,} features')\n",
+    "print(f'Shape X_train      : {X_train_tfidf.shape}')\n",
+    "print(f'Shape X_test       : {X_test_tfidf.shape}')\n",
+    "print(f'Tipo de matriz     : {type(X_train_tfidf).__name__} (sparse)')\n",
+    "print()\n",
+    "\n",
+    "# Esparsidad: que % de valores son 0\n",
+    "total = X_train_tfidf.shape[0] * X_train_tfidf.shape[1]\n",
+    "nonzero = X_train_tfidf.nnz\n",
+    "sparsity = (1 - nonzero / total) * 100\n",
+    "print(f'Valores no-cero    : {nonzero:,} de {total:,}')\n",
+    "print(f'Esparsidad         : {sparsity:.1f}%')\n",
+    "print()\n",
+    "print('Ejemplo 5 features del vocabulario:')\n",
+    "vocab_sample = list(tfidf.vocabulary_.items())[:5]\n",
+    "for word, idx in vocab_sample:\n",
+    "    print(f'  \"{word}\" -> columna {idx}')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "38c270c8",
+   "metadata": {},
+   "source": [
+    "## 4. Análisis de features: ¿qué captura TF-IDF?\n",
+    "\n",
+    "Identificamos las palabras y bigramas con mayor peso promedio\n",
+    "en comentarios tóxicos vs no tóxicos.\n",
+    "Esto nos dice si el vectorizador está capturando las señales correctas."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "34846505",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "TOP 20 features mas discriminantes para TOXICO:\n",
+      " feature    toxic  nontoxic     diff\n",
+      "     run 0.042957  0.004755 0.038203\n",
+      "    fuck 0.032995  0.002363 0.030632\n",
+      "   idiot 0.022649  0.000594 0.022055\n",
+      "    shit 0.021515  0.001077 0.020437\n",
+      "     ass 0.017153  0.000678 0.016475\n",
+      "   shoot 0.029243  0.013207 0.016035\n",
+      "   bitch 0.015237  0.000542 0.014695\n",
+      "  stupid 0.016636  0.002170 0.014466\n",
+      "    thug 0.014222  0.001859 0.012363\n",
+      "    dumb 0.011687  0.000672 0.011015\n",
+      " fucking 0.012425  0.002065 0.010360\n",
+      "    cunt 0.010253  0.000000 0.010253\n",
+      "     get 0.036118  0.026375 0.009744\n",
+      "   white 0.024439  0.015152 0.009287\n",
+      "   black 0.033807  0.025079 0.008728\n",
+      "  racist 0.019295  0.010823 0.008472\n",
+      "    kill 0.016284  0.008030 0.008254\n",
+      "     cnn 0.014236  0.006024 0.008213\n",
+      "bullshit 0.008146  0.000000 0.008146\n",
+      "     job 0.012771  0.005113 0.007658\n",
+      "\n",
+      "TOP 20 features mas discriminantes para NO TOXICO:\n",
+      " feature    toxic  nontoxic      diff\n",
+      "   peggy 0.001108  0.017077 -0.015968\n",
+      "   thank 0.004179  0.020127 -0.015948\n",
+      "  stefan 0.001979  0.015083 -0.013104\n",
+      "   truth 0.002759  0.015289 -0.012530\n",
+      "     say 0.012454  0.024430 -0.011975\n",
+      "   woman 0.002136  0.013687 -0.011551\n",
+      "    good 0.009802  0.019800 -0.009998\n",
+      "    move 0.002136  0.010709 -0.008573\n",
+      "     rap 0.002117  0.010444 -0.008327\n",
+      "     put 0.002022  0.009808 -0.007786\n",
+      "    tell 0.003167  0.010742 -0.007575\n",
+      "    much 0.004500  0.012051 -0.007551\n",
+      "  pretty 0.000245  0.007739 -0.007494\n",
+      "   great 0.003828  0.010680 -0.006852\n",
+      "    well 0.007115  0.013898 -0.006783\n",
+      "ferguson 0.005518  0.011941 -0.006422\n",
+      " hubbard 0.000744  0.006986 -0.006241\n",
+      "     wow 0.002357  0.008521 -0.006164\n",
+      "    love 0.006039  0.012199 -0.006160\n",
+      "   cigar 0.000313  0.006412 -0.006099\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Media de TF-IDF por feature para cada clase\n",
+    "# Usamos el indice del train set para separar por clase\n",
+    "y_train_arr = y_train.values\n",
+    "mask_toxic    = y_train_arr == True\n",
+    "mask_nontoxic = y_train_arr == False\n",
+    "\n",
+    "# Media de cada feature en comentarios toxicos vs no toxicos\n",
+    "mean_toxic    = np.asarray(X_train_tfidf[mask_toxic].mean(axis=0)).flatten()\n",
+    "mean_nontoxic = np.asarray(X_train_tfidf[mask_nontoxic].mean(axis=0)).flatten()\n",
+    "\n",
+    "feature_names = tfidf.get_feature_names_out()\n",
+    "\n",
+    "feat_df = pd.DataFrame({\n",
+    "    'feature'   : feature_names,\n",
+    "    'toxic'     : mean_toxic,\n",
+    "    'nontoxic'  : mean_nontoxic,\n",
+    "    'diff'      : mean_toxic - mean_nontoxic\n",
+    "})\n",
+    "\n",
+    "print('TOP 20 features mas discriminantes para TOXICO:')\n",
+    "print(feat_df.nlargest(20, 'diff')[['feature','toxic','nontoxic','diff']].to_string(index=False))\n",
+    "print()\n",
+    "print('TOP 20 features mas discriminantes para NO TOXICO:')\n",
+    "print(feat_df.nsmallest(20, 'diff')[['feature','toxic','nontoxic','diff']].to_string(index=False))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "6b9527f5",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1500x700 with 2 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Guardado en reports/08_tfidf_top_features.png\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Visualizacion: top features por clase\n",
+    "fig, axes = plt.subplots(1, 2, figsize=(15, 7))\n",
+    "\n",
+    "# Top toxic\n",
+    "top_toxic = feat_df.nlargest(20, 'diff')\n",
+    "axes[0].barh(top_toxic['feature'], top_toxic['diff'], color='#E8593C', edgecolor='white')\n",
+    "axes[0].set_title('Top 20 — mas peso en TOXICOS', fontweight='bold', color='#993C1D')\n",
+    "axes[0].set_xlabel('Diferencia de peso TF-IDF (toxico - no toxico)')\n",
+    "axes[0].invert_yaxis()\n",
+    "\n",
+    "# Top non-toxic\n",
+    "top_nontoxic = feat_df.nsmallest(20, 'diff')\n",
+    "axes[1].barh(top_nontoxic['feature'], top_nontoxic['diff'].abs(), color='#5DCAA5', edgecolor='white')\n",
+    "axes[1].set_title('Top 20 — mas peso en NO TOXICOS', fontweight='bold', color='#0F6E56')\n",
+    "axes[1].set_xlabel('Diferencia de peso TF-IDF (no toxico - toxico)')\n",
+    "axes[1].invert_yaxis()\n",
+    "\n",
+    "plt.tight_layout()\n",
+    "plt.savefig(PROJECT_ROOT / 'reports' / 'v2' / '08_tfidf_top_features.png', dpi=150, bbox_inches='tight')\n",
+    "plt.show()\n",
+    "print('Guardado en reports/08_tfidf_top_features.png')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "ae71378f",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Unigramas en vocabulario : 902\n",
+      "Bigramas en vocabulario  : 191\n",
+      "\n",
+      "TOP 15 bigramas toxicos:\n",
+      "        feature     diff\n",
+      "      get shoot 0.005373\n",
+      "     piece shit 0.005267\n",
+      "        get hit 0.003931\n",
+      "shoot apprehend 0.003739\n",
+      "        get way 0.003618\n",
+      "  rubber bullet 0.003527\n",
+      "law enforcement 0.003492\n",
+      "        go back 0.003289\n",
+      "       dumb ass 0.003264\n",
+      "      joe rogan 0.003253\n",
+      "       get kill 0.003235\n",
+      "        get job 0.003189\n",
+      "   black people 0.002936\n",
+      "  block traffic 0.002768\n",
+      "      kid would 0.002732\n",
+      "\n",
+      "TOP 15 bigramas no toxicos:\n",
+      "         feature      diff\n",
+      "        mr brown -0.003869\n",
+      "    thank stefan -0.003827\n",
+      "      police car -0.003715\n",
+      "african american -0.003510\n",
+      "      people say -0.003140\n",
+      "  police officer -0.003081\n",
+      " black community -0.002905\n",
+      "   peggy hubbard -0.002870\n",
+      "     pretty much -0.002829\n",
+      "       rap lyric -0.002804\n",
+      " stefan molyneux -0.002705\n",
+      "       god bless -0.002689\n",
+      "      tell truth -0.002538\n",
+      "     black woman -0.002325\n",
+      "    deadly force -0.002221\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Analisis de bigramas: los mas discriminantes\n",
+    "bigrams_df = feat_df[feat_df['feature'].str.contains(' ')]  # bigramas tienen espacio\n",
+    "unigrams_df = feat_df[~feat_df['feature'].str.contains(' ')]\n",
+    "\n",
+    "print(f'Unigramas en vocabulario : {len(unigrams_df):,}')\n",
+    "print(f'Bigramas en vocabulario  : {len(bigrams_df):,}')\n",
+    "print()\n",
+    "print('TOP 15 bigramas toxicos:')\n",
+    "print(bigrams_df.nlargest(15, 'diff')[['feature','diff']].to_string(index=False))\n",
+    "print()\n",
+    "print('TOP 15 bigramas no toxicos:')\n",
+    "print(bigrams_df.nsmallest(15, 'diff')[['feature','diff']].to_string(index=False))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "836165d0",
+   "metadata": {},
+   "source": [
+    "## 5. Bag of Words — comparación\n",
+    "\n",
+    "BoW simplemente cuenta cuántas veces aparece cada palabra.\n",
+    "Lo entrenamos con los mismos parámetros para comparar con TF-IDF.\n",
+    "\n",
+    "**Diferencia clave:**\n",
+    "- BoW: comentario largo con 'stupid' 3 veces → peso 3\n",
+    "- TF-IDF: mismo comentario → peso log(3)×IDF('stupid')\n",
+    "- TF-IDF penaliza 'stupid' si aparece en muchos docs, BoW no."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "id": "2553beea",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Vocabulario BoW : 902 features\n",
+      "Shape X_train   : (800, 902)\n",
+      "Shape X_test    : (200, 902)\n"
+     ]
+    }
+   ],
+   "source": [
+    "bow = CountVectorizer(\n",
+    "    max_features = bow_cfg['max_features'],\n",
+    "    ngram_range  = tuple(bow_cfg['ngram_range']),\n",
+    "    min_df       = bow_cfg['min_df'],\n",
+    "    analyzer     = 'word',\n",
+    "    strip_accents= 'unicode',\n",
+    ")\n",
+    "\n",
+    "X_train_bow = bow.fit_transform(X_train)\n",
+    "X_test_bow  = bow.transform(X_test)\n",
+    "\n",
+    "print(f'Vocabulario BoW : {len(bow.vocabulary_):,} features')\n",
+    "print(f'Shape X_train   : {X_train_bow.shape}')\n",
+    "print(f'Shape X_test    : {X_test_bow.shape}')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "b2b33628",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "                                TF-IDF          BoW\n",
+      "----------------------------------------------------\n",
+      "  Vocabulario                    1,093          902\n",
+      "  Shape train              (800, 1093)   (800, 902)\n",
+      "  Esparsidad                     98.8%        98.7%\n",
+      "  Valores no-cero               10,153        9,236\n",
+      "\n",
+      "DECISION: TF-IDF es preferido en este dataset porque:\n",
+      "  - Penaliza palabras frecuentes en todos los docs\n",
+      "  - Premia palabras raras pero discriminantes (thug, bullcrap)\n",
+      "  - sublinear_tf evita que repeticion infle el peso\n",
+      "  - Con 9 tokens medios por doc, cada peso importa\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Comparativa de esparsidad y vocabulario\n",
+    "tfidf_sparse = (1 - X_train_tfidf.nnz / (X_train_tfidf.shape[0]*X_train_tfidf.shape[1])) * 100\n",
+    "bow_sparse   = (1 - X_train_bow.nnz / (X_train_bow.shape[0]*X_train_bow.shape[1])) * 100\n",
+    "\n",
+    "print(f\"{'':25} {'TF-IDF':>12} {'BoW':>12}\")\n",
+    "print('-' * 52)\n",
+    "print(f\"  {'Vocabulario':23} {len(tfidf.vocabulary_):>12,} {len(bow.vocabulary_):>12,}\")\n",
+    "print(f\"  {'Shape train':23} {str(X_train_tfidf.shape):>12} {str(X_train_bow.shape):>12}\")\n",
+    "print(f\"  {'Esparsidad':23} {tfidf_sparse:>11.1f}% {bow_sparse:>11.1f}%\")\n",
+    "print(f\"  {'Valores no-cero':23} {X_train_tfidf.nnz:>12,} {X_train_bow.nnz:>12,}\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "ee98bd10",
+   "metadata": {},
+   "source": [
+    "## 6. Registro en MLflow\n",
+    "\n",
+    "Registramos la configuración del vectorizador y las métricas de vocabulario.\n",
+    "En el siguiente notebook (baseline) compararemos si TF-IDF o BoW da mejor F1."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "589f6b72",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "MLflow run registrado\n",
+      "  Run ID     : f549c95a6e4c4a8dbbc9d5ae3d35c977\n",
+      "  Experimento: 03_vectorization\n"
+     ]
+    }
+   ],
+   "source": [
+    "MLFLOW_DIR = PROJECT_ROOT / 'mlruns'\n",
+    "mlflow.set_tracking_uri(f'file://{MLFLOW_DIR}')\n",
+    "mlflow.set_experiment('Youtube_project_data')\n",
+    "\n",
+    "with mlflow.start_run(run_name='tfidf_vs_bow'):\n",
+    "\n",
+    "    # Params del vectorizador\n",
+    "    mlflow.log_param('tfidf_max_features', tfidf_cfg['max_features'])\n",
+    "    mlflow.log_param('tfidf_ngram_range',  str(tuple(tfidf_cfg['ngram_range'])))\n",
+    "    mlflow.log_param('tfidf_sublinear_tf', tfidf_cfg['sublinear_tf'])\n",
+    "    mlflow.log_param('tfidf_min_df',       tfidf_cfg['min_df'])\n",
+    "    mlflow.log_param('bow_max_features',   bow_cfg['max_features'])\n",
+    "    mlflow.log_param('bow_ngram_range',    str(tuple(bow_cfg['ngram_range'])))\n",
+    "    mlflow.log_param('train_size',         len(X_train))\n",
+    "    mlflow.log_param('test_size',          len(X_test))\n",
+    "    mlflow.log_param('random_state',       RAND_STATE)\n",
+    "\n",
+    "    # Metrics\n",
+    "    mlflow.log_metric('tfidf_vocab_size',   len(tfidf.vocabulary_))\n",
+    "    mlflow.log_metric('tfidf_sparsity_pct', round(tfidf_sparse, 2))\n",
+    "    mlflow.log_metric('bow_vocab_size',     len(bow.vocabulary_))\n",
+    "    mlflow.log_metric('bow_sparsity_pct',   round(bow_sparse, 2))\n",
+    "    mlflow.log_metric('n_bigrams_tfidf',    len(bigrams_df))\n",
+    "    mlflow.log_metric('n_unigrams_tfidf',   len(unigrams_df))\n",
+    "\n",
+    "    # Artefactos\n",
+    "    mlflow.log_artifact(str(PROJECT_ROOT / 'reports' / 'v2' / '08_tfidf_top_features.png'))\n",
+    "    mlflow.log_artifact(str(CONFIG_FEAT))\n",
+    "\n",
+    "    print(f'MLflow run registrado')\n",
+    "    print(f'  Run ID     : {mlflow.active_run().info.run_id}')\n",
+    "    print(f'  Experimento: Youtube_project_data')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "2ecfcd98",
+   "metadata": {},
+   "source": [
+    "## 7. Conclusiones y decisiones"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "99cd4860",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "CONCLUSIONES — VECTORIZACION\n",
+      "=======================================================\n",
+      "Configuracion elegida:\n",
+      "  Metodo   : TF-IDF\n",
+      "  n-gramas : (1, 2) — unigramas + bigramas\n",
+      "  max_feat : 5,000\n",
+      "  min_df   : 3 — filtra palabras en <3 docs\n",
+      "  sublinear: True — escala logaritmica\n",
+      "\n",
+      "Resultado:\n",
+      "  Vocabulario  : 1,093 features\n",
+      "  Shape train  : (800, 1093)\n",
+      "  Shape test   : (200, 1093)\n",
+      "  Esparsidad   : 98.8%\n",
+      "\n",
+      "Por que TF-IDF > BoW en este dataset:\n",
+      "  - 'black' aparece en ambas clases -> BoW no discrimina\n",
+      "  - TF-IDF baja el peso de palabras ubicuas\n",
+      "  - Bigramas capturan 'black thug', 'kill cop' como una unidad\n",
+      "  - Con 9 tokens medios por doc, el IDF marca diferencias claras\n",
+      "\n",
+      "Objetos disponibles para el siguiente notebook:\n",
+      "  X_train_tfidf -> matriz sparse train\n",
+      "  X_test_tfidf  -> matriz sparse test\n",
+      "  y_train       -> labels train\n",
+      "  y_test        -> labels test\n",
+      "  tfidf         -> vectorizador entrenado\n",
+      "\n",
+      "Siguiente: 04_baseline.ipynb\n",
+      "  Logistic Regression + StratifiedKFold + MLflow\n",
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(f\"\"\"\n",
+    "CONCLUSIONES — VECTORIZACION\n",
+    "{'='*55}\n",
+    "Configuracion elegida:\n",
+    "  Metodo   : TF-IDF\n",
+    "  n-gramas : (1, 2) — unigramas + bigramas\n",
+    "  max_feat : {tfidf_cfg['max_features']:,}\n",
+    "  min_df   : {tfidf_cfg['min_df']} — filtra palabras en <{tfidf_cfg['min_df']} docs\n",
+    "  sublinear: True — escala logaritmica\n",
+    "\n",
+    "Resultado:\n",
+    "  Vocabulario  : {len(tfidf.vocabulary_):,} features\n",
+    "  Shape train  : {X_train_tfidf.shape}\n",
+    "  Shape test   : {X_test_tfidf.shape}\n",
+    "  Esparsidad   : {tfidf_sparse:.1f}%\n",
+    "\n",
+    "Por que TF-IDF > BoW en este dataset:\n",
+    "  - 'black' aparece en ambas clases -> BoW no discrimina\n",
+    "  - TF-IDF baja el peso de palabras ubicuas\n",
+    "  - Bigramas capturan 'black thug', 'kill cop' como una unidad\n",
+    "  - Con 9 tokens medios por doc, el IDF marca diferencias claras\n",
+    "\n",
+    "Objetos disponibles para el siguiente notebook:\n",
+    "  X_train_tfidf -> matriz sparse train\n",
+    "  X_test_tfidf  -> matriz sparse test\n",
+    "  y_train       -> labels train\n",
+    "  y_test        -> labels test\n",
+    "  tfidf         -> vectorizador entrenado\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": 5
+}