{
 "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": 2,
   "id": "61f63fbf",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Kernel\n"
     ]
    }
   ],
   "source": [
    "print(\"Kernel\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "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": 4,
   "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": 5,
   "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 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": 6,
   "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": 7,
   "id": "81014774",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Vocabulario TF-IDF : 1,080 features\n",
      "Shape X_train      : (800, 1080)\n",
      "Shape X_test       : (200, 1080)\n",
      "Tipo de matriz     : csr_matrix (sparse)\n",
      "\n",
      "Valores no-cero    : 10,010 de 864,000\n",
      "Esparsidad         : 98.8%\n",
      "\n",
      "Ejemplo 5 features del vocabulario:\n",
      "  \"wonder\" -> columna 1050\n",
      "  \"police\" -> columna 697\n",
      "  \"expect\" -> columna 298\n",
      "  \"happen\" -> columna 406\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": 8,
   "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.042961  0.004840 0.038121\n",
      "    fuck 0.033135  0.002391 0.030743\n",
      "   idiot 0.022376  0.000594 0.021782\n",
      "    shit 0.021520  0.001077 0.020443\n",
      "     ass 0.017156  0.000687 0.016469\n",
      "   shoot 0.029257  0.013242 0.016014\n",
      "   bitch 0.015259  0.000559 0.014701\n",
      "  stupid 0.016642  0.002210 0.014432\n",
      "    thug 0.014311  0.001864 0.012447\n",
      "    dumb 0.011687  0.000672 0.011015\n",
      " fucking 0.012428  0.002065 0.010363\n",
      "    cunt 0.010253  0.000000 0.010253\n",
      "   white 0.024497  0.015250 0.009247\n",
      "   black 0.033891  0.025289 0.008601\n",
      "  racist 0.019317  0.010835 0.008482\n",
      "     cnn 0.014236  0.006085 0.008151\n",
      "bullshit 0.008150  0.000000 0.008150\n",
      "    kill 0.016292  0.008181 0.008111\n",
      "     get 0.036290  0.028203 0.008088\n",
      "   every 0.010437  0.002884 0.007553\n",
      "\n",
      "TOP 20 features mas discriminantes para NO TOXICO:\n",
      "feature    toxic  nontoxic      diff\n",
      "  thank 0.004184  0.023202 -0.019018\n",
      "  truth 0.002759  0.015370 -0.012611\n",
      "    say 0.012548  0.024861 -0.012313\n",
      "  woman 0.002165  0.014023 -0.011857\n",
      "   good 0.009662  0.020247 -0.010585\n",
      "   move 0.002154  0.010722 -0.008568\n",
      "    rap 0.002121  0.010594 -0.008473\n",
      "    put 0.002038  0.010320 -0.008281\n",
      "   well 0.007127  0.014863 -0.007736\n",
      "   tell 0.003222  0.010832 -0.007610\n",
      "   much 0.004523  0.012103 -0.007580\n",
      " pretty 0.000245  0.007745 -0.007500\n",
      "  great 0.003828  0.011223 -0.007395\n",
      "   love 0.006049  0.013132 -0.007083\n",
      "    wow 0.002357  0.008650 -0.006293\n",
      "  could 0.003965  0.010111 -0.006146\n",
      "   fair 0.000000  0.006140 -0.006140\n",
      "    vid 0.000000  0.005757 -0.005757\n",
      "   side 0.001831  0.007576 -0.005745\n",
      "  force 0.000000  0.005633 -0.005633\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": 9,
   "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": 10,
   "id": "ae71378f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Unigramas en vocabulario : 896\n",
      "Bigramas en vocabulario  : 184\n",
      "\n",
      "TOP 15 bigramas toxicos:\n",
      "        feature     diff\n",
      "      get shoot 0.005374\n",
      "     piece shit 0.005267\n",
      "      guy idiot 0.004208\n",
      "        get hit 0.003931\n",
      "shoot apprehend 0.003739\n",
      "        get way 0.003618\n",
      "  rubber bullet 0.003527\n",
      "law enforcement 0.003480\n",
      "        go back 0.003297\n",
      "       dumb ass 0.003264\n",
      "      joe rogan 0.003253\n",
      "       get kill 0.003235\n",
      "        get job 0.003189\n",
      "   black people 0.002941\n",
      "  block traffic 0.002768\n",
      "\n",
      "TOP 15 bigramas no toxicos:\n",
      "         feature      diff\n",
      "        mr brown -0.003882\n",
      "      police car -0.003806\n",
      "      people say -0.003721\n",
      "african american -0.003534\n",
      "  police officer -0.003099\n",
      " black community -0.003013\n",
      "     pretty much -0.002829\n",
      "       rap lyric -0.002811\n",
      "       god bless -0.002736\n",
      "      tell truth -0.002614\n",
      "     black woman -0.002318\n",
      "     mr molyneux -0.002261\n",
      " majority people -0.002251\n",
      "    deadly force -0.002221\n",
      "    people would -0.002150\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": 11,
   "id": "2553beea",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Vocabulario BoW : 896 features\n",
      "Shape X_train   : (800, 896)\n",
      "Shape X_test    : (200, 896)\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": 12,
   "id": "b2b33628",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "                                TF-IDF          BoW\n",
      "----------------------------------------------------\n",
      "  Vocabulario                    1,080          896\n",
      "  Shape train              (800, 1080)   (800, 896)\n",
      "  Esparsidad                     98.8%        98.7%\n",
      "  Valores no-cero               10,010        9,127\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": 13,
   "id": "589f6b72",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "MLflow run registrado\n",
      "  Run ID     : 03dee0fc689c48f98491cd212cd14756\n",
      "  Experimento: Youtube_project_data\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": 14,
   "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,080 features\n",
      "  Shape train  : (800, 1080)\n",
      "  Shape test   : (200, 1080)\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"
     ]
    }
   ],
   "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
}