Varia_training_set.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "[nltk_data] Downloading package stopwords to /home/alex/nltk_data...\n",
      "[nltk_data]   Package stopwords is already up-to-date!\n"
     ]
    }
   ],
   "source": [
    "from AC import preproc\n",
    "from AC import get_news\n",
    "import inspect\n",
    "import nltk\n",
    "nltk.download(\"stopwords\")\n",
    "\n",
    "%load_ext autoreload\n",
    "%autoreload 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 2400/2400 [03:28<00:00, 11.50it/s]\n"
     ]
    }
   ],
   "source": [
    "economia = get_news(\"./articoli_economia/\")\n",
    "cultura = get_news(\"./articoli_cultura/\")\n",
    "tech = get_news(\"./articoli_tech/\")\n",
    "politica = get_news(\"./articoli_politica/\")\n",
    "sport = get_news(\"./articoli_sport/\")\n",
    "cronaca = get_news(\"./articoli_cronaca/\")\n",
    "\n",
    "for articolo in economia:\n",
    "    articolo['categoria'] = \"Economia\"\n",
    "for articolo in cultura:\n",
    "    articolo['categoria'] = \"Cultura\"\n",
    "for articolo in tech:\n",
    "    articolo['categoria'] = \"Tech\"\n",
    "for articolo in politica:\n",
    "    articolo['categoria'] = \"Politica\"\n",
    "for articolo in sport:\n",
    "    articolo['categoria'] = \"Sport\"\n",
    "for articolo in cronaca:\n",
    "    articolo['categoria'] = \"Cronaca\"\n",
    "dati_preprocessati =  preproc(tech + politica + cultura + economia + sport + cronaca)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.feature_extraction.text import CountVectorizer\n",
    "from sklearn.decomposition import LatentDirichletAllocation\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.tree import DecisionTreeClassifier\n",
    "from sklearn.dummy import DummyClassifier\n",
    "from sklearn.metrics import accuracy_score\n",
    "from sklearn.pipeline import Pipeline\n",
    "from sklearn import metrics\n",
    "import matplotlib.pyplot as plt\n",
    "import pandas as pd"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/alex/anaconda3/envs/msbd/lib/python3.6/site-packages/sklearn/model_selection/_split.py:2179: FutureWarning: From version 0.21, test_size will always complement train_size unless both are specified.\n",
      "  FutureWarning)\n"
     ]
    }
   ],
   "source": [
    "seed = 0\n",
    "train_documents,test_documents = train_test_split(dati_preprocessati,random_state=seed,train_size=0.5)\n",
    "test_documents, val_documents = train_test_split(test_documents,random_state=seed,train_size=0.5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "docs_texts = [' '.join([word for word in x['testo']] + x['tags'] + x['sottotitolo'] + x['titolo_articolo']) for x in dati_preprocessati]\n",
    "train_texts = [' '.join([word for word in x['testo']] + x['sottotitolo'] + x['titolo_articolo']) for x in train_documents]\n",
    "test_texts = [' '.join([word for word in x['testo']] + x['sottotitolo'] + x['titolo_articolo']) for x in test_documents]\n",
    "val_texts = [' '.join([word for word in x['testo']] + x['sottotitolo'] + x['titolo_articolo']) for x in val_documents]\n",
    "\n",
    "docs_cats = [x[\"categoria\"] for x in dati_preprocessati]\n",
    "train_cats = [x[\"categoria\"] for x in train_documents]\n",
    "test_cats = [x[\"categoria\"] for x in test_documents]\n",
    "val_cats = [x[\"categoria\"] for x in val_documents]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Classificazione con LDA al variare della dimensione del training set"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## LDA-12"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/alex/anaconda3/envs/msbd/lib/python3.6/site-packages/sklearn/model_selection/_split.py:2179: FutureWarning: From version 0.21, test_size will always complement train_size unless both are specified.\n",
      "  FutureWarning)\n",
      "/home/alex/anaconda3/envs/msbd/lib/python3.6/site-packages/sklearn/model_selection/_split.py:2179: FutureWarning: From version 0.21, test_size will always complement train_size unless both are specified.\n",
      "  FutureWarning)\n"
     ]
    },
    {
     "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>accuracy_score</th>\n",
       "      <th>train_size</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>0.518333</td>\n",
       "      <td>0.15</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>0.781667</td>\n",
       "      <td>0.30</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>0.886667</td>\n",
       "      <td>0.60</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>0.991667</td>\n",
       "      <td>1.00</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   accuracy_score  train_size\n",
       "0        0.518333        0.15\n",
       "1        0.781667        0.30\n",
       "2        0.886667        0.60\n",
       "3        0.991667        1.00"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# definizione della Pipeline per LDA-12\n",
    "ldac = Pipeline([\n",
    "    (\"count_mx\",CountVectorizer(max_features=1000000, lowercase=True)),\n",
    "    (\"lda\", LatentDirichletAllocation(max_iter=50, learning_method='online',random_state=0)),\n",
    "    (\"classifier\",DecisionTreeClassifier(random_state=0))\n",
    "])\n",
    "# assegnazione valore dei parametri\n",
    "params = {\n",
    "    'lda__n_components': 12,\n",
    "    'lda__learning_decay': 0.7, \n",
    "    'count_mx__ngram_range': (1, 3), \n",
    "    'count_mx__min_df': 9, \n",
    "    'count_mx__max_df': 0.5, \n",
    "    'classifier__min_samples_leaf': 1, \n",
    "    'classifier__max_depth': 18\n",
    "\n",
    "}\n",
    "ldac.set_params(**params)\n",
    "\n",
    "#al variare della dimensione del training set (0.15, 0.3, 0.6 e 1.0) misuriamo l'accuratezza sull'insieme di validazione\n",
    "conLDA12 = []\n",
    "for i in [0.15,0.3,0.6]:\n",
    "    split,s0 = train_test_split(train_documents,random_state=0, train_size = i)\n",
    "    \n",
    "    tr_texts = [' '.join([word for word in x['testo']] + x['sottotitolo'] + x['titolo_articolo']) for x in split]\n",
    "    tr_cats = [x[\"categoria\"] for x in split]\n",
    "    ldac.fit(tr_texts, tr_cats)\n",
    "    \n",
    "    pred_cats = ldac.predict(test_texts)\n",
    "    conLDA12.append({\"accuracy_score\":metrics.accuracy_score(test_cats, pred_cats),\"train_size\": i})\n",
    "\n",
    "# Training con tutto l'insieme\n",
    "ldac.fit(train_texts, train_cats)\n",
    "pred_cats = ldac.predict(test_texts)\n",
    "conLDA12.append({\"accuracy_score\":metrics.accuracy_score(test_cats, pred_cats),\"train_size\": 1.0})\n",
    "    \n",
    "conLDA12 = pd.DataFrame(conLDA12).sort_values([\"train_size\",\"accuracy_score\"], ascending=[True,False])\n",
    "display(conLDA12)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# stessa cosa per le altre configurazioni"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## LDA-48"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/alex/anaconda3/envs/msbd/lib/python3.6/site-packages/sklearn/model_selection/_split.py:2179: FutureWarning: From version 0.21, test_size will always complement train_size unless both are specified.\n",
      "  FutureWarning)\n",
      "/home/alex/anaconda3/envs/msbd/lib/python3.6/site-packages/sklearn/model_selection/_split.py:2179: FutureWarning: From version 0.21, test_size will always complement train_size unless both are specified.\n",
      "  FutureWarning)\n",
      "/home/alex/anaconda3/envs/msbd/lib/python3.6/site-packages/sklearn/model_selection/_split.py:2179: FutureWarning: From version 0.21, test_size will always complement train_size unless both are specified.\n",
      "  FutureWarning)\n"
     ]
    },
    {
     "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>accuracy_score</th>\n",
       "      <th>train_size</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>0.600000</td>\n",
       "      <td>0.15</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>0.765000</td>\n",
       "      <td>0.30</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>0.910000</td>\n",
       "      <td>0.60</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>0.978333</td>\n",
       "      <td>1.00</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   accuracy_score  train_size\n",
       "0        0.600000        0.15\n",
       "1        0.765000        0.30\n",
       "2        0.910000        0.60\n",
       "3        0.978333        1.00"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "ldac = Pipeline([\n",
    "    (\"count_mx\",CountVectorizer(max_features=1000000, lowercase=True)),\n",
    "    (\"lda\", LatentDirichletAllocation(max_iter=50, learning_method='online',random_state=0)),\n",
    "    (\"classifier\",DecisionTreeClassifier(random_state=0))\n",
    "])\n",
    "params = {\n",
    "     'lda__n_components': 48,\n",
    "    'lda__learning_decay': 0.7, \n",
    "    'count_mx__ngram_range': (1, 3), \n",
    "    'count_mx__min_df': 9, \n",
    "    'count_mx__max_df': 0.5, \n",
    "    'classifier__min_samples_leaf': 1, \n",
    "    'classifier__max_depth': 23\n",
    "\n",
    "}\n",
    "ldac.set_params(**params)\n",
    "\n",
    "conLDA48 = []\n",
    "for i in [0.15,0.3,0.6]:\n",
    "    split = train_test_split(train_documents,random_state=0, train_size = i)\n",
    "    \n",
    "    tr_texts = [' '.join([word for word in x['testo']] + x['sottotitolo'] + x['titolo_articolo']) for x in split[0]]\n",
    "    tr_cats = [x[\"categoria\"] for x in split[0]]\n",
    "    ldac.fit(tr_texts, tr_cats)\n",
    "    \n",
    "    pred_cats = ldac.predict(test_texts)\n",
    "    conLDA48.append({\"accuracy_score\":metrics.accuracy_score(test_cats, pred_cats),\"train_size\": i})\n",
    "\n",
    "# Training con tutto l'insieme\n",
    "ldac.fit(train_texts, train_cats)\n",
    "pred_cats = ldac.predict(test_texts)\n",
    "conLDA48.append({\"accuracy_score\":metrics.accuracy_score(test_cats, pred_cats),\"train_size\": 1.0})\n",
    "    \n",
    "conLDA48 = pd.DataFrame(conLDA48).sort_values([\"train_size\",\"accuracy_score\"], ascending=[True,False])\n",
    "display(conLDA48)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Classificazione senza LDA al variare della dimensione del training set"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/alex/anaconda3/envs/msbd/lib/python3.6/site-packages/sklearn/model_selection/_split.py:2179: FutureWarning: From version 0.21, test_size will always complement train_size unless both are specified.\n",
      "  FutureWarning)\n",
      "/home/alex/anaconda3/envs/msbd/lib/python3.6/site-packages/sklearn/model_selection/_split.py:2179: FutureWarning: From version 0.21, test_size will always complement train_size unless both are specified.\n",
      "  FutureWarning)\n",
      "/home/alex/anaconda3/envs/msbd/lib/python3.6/site-packages/sklearn/model_selection/_split.py:2179: FutureWarning: From version 0.21, test_size will always complement train_size unless both are specified.\n",
      "  FutureWarning)\n"
     ]
    },
    {
     "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>accuracy_score</th>\n",
       "      <th>train_size</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>0.585000</td>\n",
       "      <td>0.15</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>0.756667</td>\n",
       "      <td>0.30</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>0.891667</td>\n",
       "      <td>0.60</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>0.975000</td>\n",
       "      <td>1.00</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   accuracy_score  train_size\n",
       "0        0.585000        0.15\n",
       "1        0.756667        0.30\n",
       "2        0.891667        0.60\n",
       "3        0.975000        1.00"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "tfc = Pipeline([\n",
    "    (\"count_mx\", TfidfVectorizer(max_features=1000000, lowercase=True)),\n",
    "    (\"classifier\",DecisionTreeClassifier(random_state=0))\n",
    "]) \n",
    "params = { \n",
    "    'count_mx__ngram_range': (1, 3), \n",
    "    'count_mx__min_df': 9, \n",
    "    'count_mx__max_df': 0.5, \n",
    "    'classifier__min_samples_leaf': 1, \n",
    "    'classifier__max_depth': 34\n",
    "\n",
    "}\n",
    "tfc.set_params(**params)\n",
    "\n",
    "senzaLDA = []\n",
    "for i in [0.15,0.3,0.6]:\n",
    "    split = train_test_split(train_documents,random_state=0, train_size = i)\n",
    "    \n",
    "    tr_texts = [' '.join([word for word in x['testo']] + x['sottotitolo'] + x['titolo_articolo']) for x in split[0]]\n",
    "    tr_cats = [x[\"categoria\"] for x in split[0]]\n",
    "    tfc.fit(tr_texts, tr_cats)\n",
    "\n",
    "    pred_cats = tfc.predict(test_texts)\n",
    "    senzaLDA.append({\"accuracy_score\":metrics.accuracy_score(test_cats, pred_cats),\"train_size\": i})\n",
    "\n",
    "# Training con tutto l'insieme\n",
    "tfc.fit(train_texts, train_cats)\n",
    "pred_cats = tfc.predict(test_texts)\n",
    "senzaLDA.append({\"accuracy_score\":metrics.accuracy_score(test_cats, pred_cats),\"train_size\": 1.0})\n",
    "\n",
    "senzaLDA = pd.DataFrame(senzaLDA).sort_values([\"train_size\",\"accuracy_score\"], ascending=[True,False])\n",
    "display(senzaLDA)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x7f1142f47198>"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# stampiamo su un grafico i risultati\n",
    "plt.style.use('seaborn-darkgrid')\n",
    "plt.ylim((0,1.1))\n",
    "plt.xlim((0.1,1.05))\n",
    "plt.xticks([0.15,0.3,0.6,1.0],[\"15\",\"30\",\"60\",\"100\"])\n",
    "plt.xlabel(\"% training set\")\n",
    "plt.ylabel(\"accuratezza\")\n",
    "\n",
    "plt.plot( 'train_size', 'accuracy_score', data=conLDA12, marker='', linewidth=2)\n",
    "plt.plot( 'train_size', 'accuracy_score', data=conLDA48, marker='',color='green', linewidth=2)\n",
    "plt.plot( 'train_size', 'accuracy_score', data=senzaLDA, marker='', color='red', linewidth=2)\n",
    "plt.legend(['Con LDA-12', 'Con LDA-48', 'Term Frequency'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "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.6.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}