Proyecto_Practico.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Proyecto práctico\n",
    "\n",
    "## Unidad 3 - Aprendizaje supervisado\n",
    "\n",
    "El proyecto práctico consiste en abordar un problema de clasificación de documentos textuales. Tenemos a nuestra disposición un dataset de noticias de prensa en español publicada por el medio \"CNN Chile\".\n",
    "\n",
    "Las noticias están divididas en 7 categorías temáticas: *'pais','deportes','tendencias','tecnologias','cultura','economia','mundo'*\n",
    "\n",
    "El proyecto se divide en dos partes:\n",
    "\n",
    "- Utilizar al menos 3 estrategías para entrenar modelos de clasificación capaces de clasificar las noticias según su categoría temática.\n",
    "\n",
    "- Explorar cuáles son las características que permiten explicar las decisiones de su modelo.\n",
    "\n",
    "## 0. Evaluación\n",
    "\n",
    "El proyecto se realiza de forma individual. Se entrega a más tardar el **lunes 30 de noviembre** en su repositorio GitHub.\n",
    "\n",
    "**Pauta de evaluación:**\n",
    "\n",
    "Competencia 1: Aplicar un protocolo de aprendizaje supervisado para resolver un problema clasificación estandar, utilizando un entorno de programación en Python\n",
    "\n",
    "- < 2 : El protocolo de aprendizaje supervisado utilizado es incompleto y/o presenta errores importantes\n",
    "- 2 a 3.9 : El protocolo de aprendizaje supervisado utilizado es incompleto o presenta un error importante\n",
    "- 4 a 5.5 : El protocolo de aprendizaje es completo, no tiene error, pero las estrategias utilizadas son relativamente simples y el rendimiento de los modelos es perfectible.\n",
    "- 5.6 a 7.0 : El protocolo de aprendizaje es completo, no tiene error y al menos una de las estrategias utilizadas a necesitado un trabajado más avanzado y/o permite obtener un mejor rendimiento.\n",
    "\n",
    "Competencia 2: Explicar el rendimiento de un modelo de clasificación aplicando un protocolo de evaluación Precision/Recall/F-Score\n",
    "\n",
    "- < 2 : El trabajo no presenta explicaciones del rendimiento de los modelos de clasificación\n",
    "- 2 a 3.9 : El trabajo presenta algunas explicaciones pero tienen errores.\n",
    "- 4 a 5.5 : El trabajo presenta explicaciones correctas del rendimiento de los modelos\n",
    "- 5.6 a 7 : El trabajo presenta explicaciones correctas del rendimiento de los modelos y además presenta un método para explicar las decisiones/errores\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# TODO\n",
    "* Explicaciones de los modelos\n",
    "* Implementar matriz de confusion para poder ver de forma más visual los casos buenos y malos\n",
    "* Label encoder\n",
    "* Posibles implementaciones: \n",
    "> * Regresión logística con CountVectorizer y TFid\n",
    "> * Decision Tree vs Random forest\n",
    "> * Word Embedding text vs titles?\n",
    "> * Algún modelo de Deep learning (GPT-2, GPT-3 (IMPOSIBLE), BERT (BETO EN ESPAÑOL))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1. Dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>text</th>\n",
       "      <th>category</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>La Federación de Estudiantes de la Universidad...</td>\n",
       "      <td>pais</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>La Defensoría de la Niñez emitió este domingo ...</td>\n",
       "      <td>pais</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>El monto del bono es de dos tercios de Unidad ...</td>\n",
       "      <td>pais</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>Una nueva polémica tiene esta carrera presiden...</td>\n",
       "      <td>pais</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>Especialistas recomiendan no consumir más de 2...</td>\n",
       "      <td>pais</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>...</th>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>6995</th>\n",
       "      <td>Las compañías ya han revelado muchos detalles ...</td>\n",
       "      <td>tecnologias</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>6996</th>\n",
       "      <td>Se proyecta que tras un virtual empate en 2012...</td>\n",
       "      <td>tecnologias</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>6997</th>\n",
       "      <td>Tablets y smartphones fueron los regalos tecno...</td>\n",
       "      <td>tecnologias</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>6998</th>\n",
       "      <td>Crecí jugando clásicos de naves como Terminal ...</td>\n",
       "      <td>tecnologias</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>6999</th>\n",
       "      <td>Konami Digital Entertainment ha anunciado que ...</td>\n",
       "      <td>tecnologias</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "<p>7000 rows × 2 columns</p>\n",
       "</div>"
      ],
      "text/plain": [
       "                                                   text     category\n",
       "0     La Federación de Estudiantes de la Universidad...         pais\n",
       "1     La Defensoría de la Niñez emitió este domingo ...         pais\n",
       "2     El monto del bono es de dos tercios de Unidad ...         pais\n",
       "3     Una nueva polémica tiene esta carrera presiden...         pais\n",
       "4     Especialistas recomiendan no consumir más de 2...         pais\n",
       "...                                                 ...          ...\n",
       "6995  Las compañías ya han revelado muchos detalles ...  tecnologias\n",
       "6996  Se proyecta que tras un virtual empate en 2012...  tecnologias\n",
       "6997  Tablets y smartphones fueron los regalos tecno...  tecnologias\n",
       "6998  Crecí jugando clásicos de naves como Terminal ...  tecnologias\n",
       "6999  Konami Digital Entertainment ha anunciado que ...  tecnologias\n",
       "\n",
       "[7000 rows x 2 columns]"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import pandas as pd\n",
    "from pandasql import sqldf\n",
    "import spacy\n",
    "from sklearn.model_selection import train_test_split\n",
    "\n",
    "df = pd.read_csv('cnnchile_7000.csv')\n",
    "df = df.drop([\"country\",\"media_outlet\", \"url\",\"date\",\"title\"],1)\n",
    "df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 125,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>category</th>\n",
       "      <th>count(*)</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>tendencias</td>\n",
       "      <td>1000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>tecnologias</td>\n",
       "      <td>1000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>pais</td>\n",
       "      <td>1000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>mundo</td>\n",
       "      <td>1000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>economia</td>\n",
       "      <td>1000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>deportes</td>\n",
       "      <td>1000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>6</th>\n",
       "      <td>cultura</td>\n",
       "      <td>1000</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "      category  count(*)\n",
       "0   tendencias      1000\n",
       "1  tecnologias      1000\n",
       "2         pais      1000\n",
       "3        mundo      1000\n",
       "4     economia      1000\n",
       "5     deportes      1000\n",
       "6      cultura      1000"
      ]
     },
     "execution_count": 125,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "q=\"\"\"SELECT category, count(*) FROM df GROUP BY category ORDER BY count(*) DESC;\"\"\"\n",
    "result=sqldf(q)\n",
    "result"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 126,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(7000, 2)"
      ]
     },
     "execution_count": 126,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 127,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['tendencias',\n",
       " 'tecnologias',\n",
       " 'pais',\n",
       " 'mundo',\n",
       " 'economia',\n",
       " 'deportes',\n",
       " 'cultura']"
      ]
     },
     "execution_count": 127,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "categories = result[\"category\"].astype(\"str\").tolist()\n",
    "categories"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(2100, 2)"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "q=\"\"\"SELECT * FROM df WHERE category = \"tendencias\";\"\"\"\n",
    "df_tend=sqldf(q)\n",
    "\n",
    "df_tend = df_tend.sample(n=300)\n",
    "\n",
    "q=\"\"\"SELECT * FROM df WHERE category = \"tecnologias\";\"\"\"\n",
    "df_tech = sqldf(q)\n",
    "\n",
    "df_tech = df_tech.sample(n=300)\n",
    "\n",
    "\n",
    "q=\"\"\"SELECT * FROM df WHERE category = \"pais\";\"\"\"\n",
    "df_pais=sqldf(q)\n",
    "\n",
    "df_pais = df_pais.sample(n=300)\n",
    "\n",
    "q=\"\"\"SELECT * FROM df WHERE category = \"mundo\";\"\"\"\n",
    "df_mundo=sqldf(q)\n",
    "\n",
    "df_mundo = df_mundo.sample(n=300)\n",
    "\n",
    "q=\"\"\"SELECT * FROM df WHERE category = \"economia\";\"\"\"\n",
    "df_eco=sqldf(q)\n",
    "\n",
    "df_eco = df_eco.sample(n=300)\n",
    "\n",
    "q=\"\"\"SELECT * FROM df WHERE category = \"deportes\";\"\"\"\n",
    "df_dep = sqldf(q)\n",
    "\n",
    "df_dep = df_dep.sample(n=300)\n",
    "\n",
    "q=\"\"\"SELECT * FROM df WHERE category = \"cultura\";\"\"\"\n",
    "df_cult = sqldf(q)\n",
    "\n",
    "df_cult = df_cult.sample(n=300)\n",
    "\n",
    "df_train = pd.concat([df_tend, df_tech, df_pais, df_mundo,df_eco,df_dep,df_cult], ignore_index=True)\n",
    "df_train.shape\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>category</th>\n",
       "      <th>count(*)</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>tendencias</td>\n",
       "      <td>300</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>tecnologias</td>\n",
       "      <td>300</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>pais</td>\n",
       "      <td>300</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>mundo</td>\n",
       "      <td>300</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>economia</td>\n",
       "      <td>300</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>deportes</td>\n",
       "      <td>300</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>6</th>\n",
       "      <td>cultura</td>\n",
       "      <td>300</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "      category  count(*)\n",
       "0   tendencias       300\n",
       "1  tecnologias       300\n",
       "2         pais       300\n",
       "3        mundo       300\n",
       "4     economia       300\n",
       "5     deportes       300\n",
       "6      cultura       300"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "q=\"\"\"SELECT category, count(*) FROM df_train GROUP BY category ORDER BY count(*) DESC;\"\"\"\n",
    "test=sqldf(q)\n",
    "test"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "nlp = spacy.load(\"es_core_news_md\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Determinar parametros (Cross Validation)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train:  4200 \n",
      "Test:  2800\n"
     ]
    }
   ],
   "source": [
    "## Determinar la cantidad de data para TRAIN and TEST\n",
    "\n",
    "total = df.shape[0]\n",
    "train = int(total * 0.6)\n",
    "test = total - train\n",
    "print(\"Train: \", train,\"\\nTest: \",test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\" \\nX = df_train['text'].astype(str)\\nylabels = df_train['category'].astype(str)\\n\\nX_train, X_test, y_train, y_test = train_test_split(X, ylabels, test_size=0.25, random_state=0)\\n\""
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "## PRUEBAS REALES\n",
    "\n",
    "X = df['text'].astype(str)\n",
    "ylabels = df['category'].astype(str)\n",
    "\n",
    "X_train, X_test, y_train, y_test = train_test_split(X, ylabels, test_size=0.25, random_state=0)\n",
    "\n",
    "## PRUEBAS PEQUEÑAS\n",
    "''' \n",
    "X = df_train['text'].astype(str)\n",
    "ylabels = df_train['category'].astype(str)\n",
    "\n",
    "X_train, X_test, y_train, y_test = train_test_split(X, ylabels, test_size=0.25, random_state=0)\n",
    "'''\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train size:  (5250,) \n",
      "Test size:  (1750,)\n"
     ]
    }
   ],
   "source": [
    "print(\"Train size: \",X_train.shape, \"\\nTest size: \", X_test.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Spacy function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.feature_extraction.text import CountVectorizer\n",
    "from pandas import DataFrame"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "def feature_extraction(text):\n",
    "    \n",
    "    mytokens = nlp(text)\n",
    "\n",
    "    #Guardamos las palabras como características si corresponden a ciertas categorias gramaticaless\n",
    "    mytokens = [ word for word in mytokens if word.pos_ in [\"NOUN\", \"ADJ\", \"VERB\"] ]\n",
    "    \n",
    "    #Transformamos las palabras en minusculas\n",
    "    mytokens = [ word.lemma_.lower().strip() for word in mytokens ]\n",
    "\n",
    "    # return preprocessed list of tokens\n",
    "    return mytokens"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "bow_vector = CountVectorizer(tokenizer = feature_extraction, min_df=0., max_df=1.0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Entrenamiento\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.pipeline import Pipeline\n",
    "from sklearn.linear_model import LogisticRegression\n",
    "from sklearn import metrics\n",
    "from sklearn.metrics import classification_report\n",
    "from sklearn.metrics import confusion_matrix\n",
    "from sklearn.feature_extraction.text import TfidfVectorizer\n",
    "from sklearn.naive_bayes import MultinomialNB\n",
    "from sklearn.linear_model import SGDClassifier\n",
    "from sklearn import tree\n",
    "from sklearn.ensemble import RandomForestClassifier\n",
    "from sklearn.neighbors import KNeighborsClassifier"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Regresión logistica y CountVectorizer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 159,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Pipeline(steps=[('vectorizing',\n",
       "                 CountVectorizer(min_df=0.0,\n",
       "                                 tokenizer=<function feature_extraction at 0x7f28b5e91e60>)),\n",
       "                ('learning', LogisticRegression(max_iter=1000))])"
      ]
     },
     "execution_count": 159,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "## ENTRENAMIENTO USANDO PIPELINE\n",
    "\n",
    "model_1 = LogisticRegression(max_iter=1000)\n",
    "pipe = Pipeline([('vectorizing', bow_vector),\n",
    "                 ('learning', model_1)])\n",
    "\n",
    "# model generation\n",
    "#Determina los mejores fit para el df usando el modelo_1 y bow_vector\n",
    "pipe.fit(X_train,y_train)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 160,
   "metadata": {},
   "outputs": [],
   "source": [
    "predicted = pipe.predict(X_test) # Vectoriza los datos de test.\n",
    "#predicted_proba = pipe.predict_proba(X_test) #Vectoriza la probabilidad de ser una de las x posibilidades\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 161,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Logistic Regression Accuracy: 0.736\n"
     ]
    }
   ],
   "source": [
    "# Exactitud del modelo.\n",
    "print(\"Logistic Regression Accuracy:\",metrics.accuracy_score(y_test, predicted))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 162,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "              precision    recall  f1-score   support\n",
      "\n",
      "     cultura       0.84      0.83      0.84       250\n",
      "    deportes       0.81      0.86      0.84       255\n",
      "    economia       0.75      0.80      0.78       273\n",
      "       mundo       0.70      0.68      0.69       238\n",
      "        pais       0.72      0.65      0.68       250\n",
      " tecnologias       0.70      0.67      0.68       252\n",
      "  tendencias       0.61      0.64      0.62       232\n",
      "\n",
      "    accuracy                           0.74      1750\n",
      "   macro avg       0.73      0.73      0.73      1750\n",
      "weighted avg       0.74      0.74      0.74      1750\n",
      "\n"
     ]
    }
   ],
   "source": [
    "print(classification_report(y_test, predicted))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Regresión logistica y TfidfTransformer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "##Usamos los id, en funcion de los poco común se aumentan los pesos de las palabras.\n",
    "\n",
    "tfidf_vector = TfidfVectorizer(tokenizer = feature_extraction, min_df=0., max_df=1.0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 143,
   "metadata": {},
   "outputs": [],
   "source": [
    "model_2 = LogisticRegression()\n",
    "\n",
    "pipe2 = Pipeline([('vectorizing', tfidf_vector),\n",
    "                 ('learning', model_2)])\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 144,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Pipeline(steps=[('vectorizing',\n",
       "                 TfidfVectorizer(min_df=0.0,\n",
       "                                 tokenizer=<function feature_extraction at 0x7f28b5e91e60>)),\n",
       "                ('learning', LogisticRegression())])"
      ]
     },
     "execution_count": 144,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pipe2.fit(X_train,y_train)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 145,
   "metadata": {},
   "outputs": [],
   "source": [
    "predicted = pipe2.predict(X_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 146,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Logistic Regression Accuracy: 0.772\n"
     ]
    }
   ],
   "source": [
    "# Model Accuracy\n",
    "print(\"Logistic Regression Accuracy:\",metrics.accuracy_score(y_test, predicted))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 147,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "              precision    recall  f1-score   support\n",
      "\n",
      "     cultura       0.87      0.90      0.89       250\n",
      "    deportes       0.85      0.87      0.86       255\n",
      "    economia       0.77      0.78      0.78       273\n",
      "       mundo       0.72      0.72      0.72       238\n",
      "        pais       0.78      0.68      0.72       250\n",
      " tecnologias       0.72      0.72      0.72       252\n",
      "  tendencias       0.69      0.72      0.70       232\n",
      "\n",
      "    accuracy                           0.77      1750\n",
      "   macro avg       0.77      0.77      0.77      1750\n",
      "weighted avg       0.77      0.77      0.77      1750\n",
      "\n"
     ]
    }
   ],
   "source": [
    "print(classification_report(y_test, predicted))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### MultinomialNB y TfidfTransformer  (Naive Bayes Classifier)\n",
    "\n",
    "* Para textos no deberia funcionar muy bien"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 148,
   "metadata": {},
   "outputs": [],
   "source": [
    "model_3 = MultinomialNB()\n",
    "\n",
    "pipe3 = Pipeline([('vectorizing', tfidf_vector),\n",
    "                 ('learning', model_3)])\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 149,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Pipeline(steps=[('vectorizing',\n",
       "                 TfidfVectorizer(min_df=0.0,\n",
       "                                 tokenizer=<function feature_extraction at 0x7f28b5e91e60>)),\n",
       "                ('learning', MultinomialNB())])"
      ]
     },
     "execution_count": 149,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pipe3.fit(X_train,y_train)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 150,
   "metadata": {},
   "outputs": [],
   "source": [
    "predicted = pipe3.predict(X_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 151,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Logistic Regression Accuracy: 0.752\n"
     ]
    }
   ],
   "source": [
    "# Model Accuracy\n",
    "print(\"MultiNomialNB Accuracy:\",metrics.accuracy_score(y_test, predicted))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 152,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "              precision    recall  f1-score   support\n",
      "\n",
      "     cultura       0.73      0.94      0.82       250\n",
      "    deportes       0.91      0.85      0.88       255\n",
      "    economia       0.75      0.82      0.78       273\n",
      "       mundo       0.70      0.75      0.73       238\n",
      "        pais       0.81      0.66      0.73       250\n",
      " tecnologias       0.64      0.73      0.69       252\n",
      "  tendencias       0.77      0.48      0.59       232\n",
      "\n",
      "    accuracy                           0.75      1750\n",
      "   macro avg       0.76      0.75      0.74      1750\n",
      "weighted avg       0.76      0.75      0.75      1750\n",
      "\n"
     ]
    }
   ],
   "source": [
    "print(classification_report(y_test, predicted))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### SGDClassifier y TfidfTransformer (Gradient descent)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Stochastic Gradient Descent (SGD) This estimator implements regularized linear models with stochastic gradient descent (SGD) learning: the gradient of the loss is estimated each sample at a time and the model is updated along the way with a decreasing strength schedule (aka learning rate). "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 153,
   "metadata": {},
   "outputs": [],
   "source": [
    "model_4 = SGDClassifier(loss='hinge', \n",
    "              penalty='l2', \n",
    "              alpha=1e-3, \n",
    "              random_state=42,\n",
    "              max_iter=5, \n",
    "              tol=None)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 154,
   "metadata": {},
   "outputs": [],
   "source": [
    "pipe4 = Pipeline([('vectorizing', tfidf_vector),\n",
    "                 ('learning', model_4)])\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 155,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Pipeline(steps=[('vectorizing',\n",
       "                 TfidfVectorizer(min_df=0.0,\n",
       "                                 tokenizer=<function feature_extraction at 0x7f28b5e91e60>)),\n",
       "                ('learning',\n",
       "                 SGDClassifier(alpha=0.001, max_iter=5, random_state=42,\n",
       "                               tol=None))])"
      ]
     },
     "execution_count": 155,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pipe4.fit(X_train,y_train)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 156,
   "metadata": {},
   "outputs": [],
   "source": [
    "predicted = pipe4.predict(X_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 157,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Logistic Regression Accuracy: 0.7611428571428571\n"
     ]
    }
   ],
   "source": [
    "# Model Accuracy\n",
    "print(\"SGDC Accuracy:\",metrics.accuracy_score(y_test, predicted))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 163,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "              precision    recall  f1-score   support\n",
      "\n",
      "     cultura       0.84      0.83      0.84       250\n",
      "    deportes       0.81      0.86      0.84       255\n",
      "    economia       0.75      0.80      0.78       273\n",
      "       mundo       0.70      0.68      0.69       238\n",
      "        pais       0.72      0.65      0.68       250\n",
      " tecnologias       0.70      0.67      0.68       252\n",
      "  tendencias       0.61      0.64      0.62       232\n",
      "\n",
      "    accuracy                           0.74      1750\n",
      "   macro avg       0.73      0.73      0.73      1750\n",
      "weighted avg       0.74      0.74      0.74      1750\n",
      "\n"
     ]
    }
   ],
   "source": [
    "print(classification_report(y_test, predicted))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Decision Tree"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 169,
   "metadata": {},
   "outputs": [],
   "source": [
    "model_5 = tree.DecisionTreeClassifier()\n",
    "\n",
    "pipe5 = Pipeline([('vectorizing', tfidf_vector),\n",
    "                 ('learning', model_5)])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 170,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Pipeline(steps=[('vectorizing',\n",
       "                 TfidfVectorizer(min_df=0.0,\n",
       "                                 tokenizer=<function feature_extraction at 0x7f28b5e91e60>)),\n",
       "                ('learning', DecisionTreeClassifier())])"
      ]
     },
     "execution_count": 170,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pipe5.fit(X_train, y_train)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 171,
   "metadata": {},
   "outputs": [],
   "source": [
    "predicted = pipe5.predict(X_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 172,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "              precision    recall  f1-score   support\n",
      "\n",
      "     cultura       0.69      0.66      0.68       250\n",
      "    deportes       0.74      0.74      0.74       255\n",
      "    economia       0.58      0.54      0.56       273\n",
      "       mundo       0.40      0.45      0.42       238\n",
      "        pais       0.38      0.37      0.37       250\n",
      " tecnologias       0.54      0.54      0.54       252\n",
      "  tendencias       0.44      0.45      0.44       232\n",
      "\n",
      "    accuracy                           0.54      1750\n",
      "   macro avg       0.54      0.54      0.54      1750\n",
      "weighted avg       0.54      0.54      0.54      1750\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# Exactitud del modelo.\n",
    "print(\"Decision Tree Accuracy:\",metrics.accuracy_score(y_test, predicted))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 173,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "              precision    recall  f1-score   support\n",
      "\n",
      "     cultura       0.69      0.66      0.68       250\n",
      "    deportes       0.74      0.74      0.74       255\n",
      "    economia       0.58      0.54      0.56       273\n",
      "       mundo       0.40      0.45      0.42       238\n",
      "        pais       0.38      0.37      0.37       250\n",
      " tecnologias       0.54      0.54      0.54       252\n",
      "  tendencias       0.44      0.45      0.44       232\n",
      "\n",
      "    accuracy                           0.54      1750\n",
      "   macro avg       0.54      0.54      0.54      1750\n",
      "weighted avg       0.54      0.54      0.54      1750\n",
      "\n"
     ]
    }
   ],
   "source": [
    "print(classification_report(y_test, predicted))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Random Forest"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 174,
   "metadata": {},
   "outputs": [],
   "source": [
    "model_6 = RandomForestClassifier(n_estimators=100)\n",
    "\n",
    "pipe6 = Pipeline([('vectorizing', tfidf_vector),\n",
    "                 ('learning', model_6)])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 175,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Pipeline(steps=[('vectorizing',\n",
       "                 TfidfVectorizer(min_df=0.0,\n",
       "                                 tokenizer=<function feature_extraction at 0x7f28b5e91e60>)),\n",
       "                ('learning', RandomForestClassifier())])"
      ]
     },
     "execution_count": 175,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pipe6.fit(X_train, y_train)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 176,
   "metadata": {},
   "outputs": [],
   "source": [
    "predicted = pipe6.predict(X_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 177,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Logistic Regression Accuracy: 0.7177142857142857\n"
     ]
    }
   ],
   "source": [
    "# Exactitud del modelo.\n",
    "print(\"Random Forest Accuracy:\",metrics.accuracy_score(y_test, predicted))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 178,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "              precision    recall  f1-score   support\n",
      "\n",
      "     cultura       0.79      0.91      0.85       250\n",
      "    deportes       0.80      0.86      0.83       255\n",
      "    economia       0.71      0.75      0.73       273\n",
      "       mundo       0.71      0.62      0.66       238\n",
      "        pais       0.63      0.64      0.63       250\n",
      " tecnologias       0.71      0.62      0.67       252\n",
      "  tendencias       0.64      0.60      0.62       232\n",
      "\n",
      "    accuracy                           0.72      1750\n",
      "   macro avg       0.71      0.72      0.71      1750\n",
      "weighted avg       0.71      0.72      0.71      1750\n",
      "\n"
     ]
    }
   ],
   "source": [
    "print(classification_report(y_test, predicted))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### KNN (K-nearest Neighbor)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "vecinos = 18 \n",
    "model_7 = KNeighborsClassifier(vecinos)\n",
    "\n",
    "pipe7 = Pipeline([('vectorizing', tfidf_vector),\n",
    "                 ('learning', model_7)])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Pipeline(steps=[('vectorizing',\n",
       "                 TfidfVectorizer(min_df=0.0,\n",
       "                                 tokenizer=<function feature_extraction at 0x7fb9273db9e0>)),\n",
       "                ('learning', KNeighborsClassifier(n_neighbors=18))])"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pipe7.fit(X_train, y_train)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "predicted = pipe7.predict(X_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "KNN Accuracy: 0.7022857142857143\n"
     ]
    }
   ],
   "source": [
    "# Exactitud del modelo.\n",
    "print(\"KNN Accuracy:\",metrics.accuracy_score(y_test, predicted))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "              precision    recall  f1-score   support\n",
      "\n",
      "     cultura       0.85      0.86      0.85       250\n",
      "    deportes       0.75      0.89      0.81       255\n",
      "    economia       0.81      0.68      0.74       273\n",
      "       mundo       0.76      0.61      0.67       238\n",
      "        pais       0.47      0.81      0.59       250\n",
      " tecnologias       0.75      0.60      0.67       252\n",
      "  tendencias       0.75      0.44      0.56       232\n",
      "\n",
      "    accuracy                           0.70      1750\n",
      "   macro avg       0.73      0.70      0.70      1750\n",
      "weighted avg       0.73      0.70      0.70      1750\n",
      "\n"
     ]
    }
   ],
   "source": [
    "print(classification_report(y_test, predicted))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "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.7.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}