Phase_02_Progress.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Phase 2 progress"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Data preprocessing\n",
    "\n",
    "In this part, I change the label into digital number from string and plot a graph via the length of text."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import nltk"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'pandas.core.frame.DataFrame'>\n",
      "RangeIndex: 6335 entries, 0 to 6334\n",
      "Data columns (total 5 columns):\n",
      "Unnamed: 0       6335 non-null int64\n",
      "title            6335 non-null object\n",
      "text             6335 non-null object\n",
      "label            6335 non-null object\n",
      "title_vectors    6335 non-null object\n",
      "dtypes: int64(1), object(4)\n",
      "memory usage: 247.5+ KB\n"
     ]
    }
   ],
   "source": [
    "df = pd.read_csv('data/fake_or_real_news.csv', nrows=10000)\n",
    "df.info()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "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>title</th>\n",
       "      <th>text</th>\n",
       "      <th>label</th>\n",
       "      <th>title_vectors</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>You Can Smell Hillary’s Fear</td>\n",
       "      <td>Daniel Greenfield, a Shillman Journalism Fello...</td>\n",
       "      <td>0</td>\n",
       "      <td>[ 1.1533764e-02  4.2144405e-03  1.9692603e-02 ...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>Watch The Exact Moment Paul Ryan Committed Pol...</td>\n",
       "      <td>Google Pinterest Digg Linkedin Reddit Stumbleu...</td>\n",
       "      <td>0</td>\n",
       "      <td>[ 0.11267698  0.02518966 -0.00212591  0.021095...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>Kerry to go to Paris in gesture of sympathy</td>\n",
       "      <td>U.S. Secretary of State John F. Kerry said Mon...</td>\n",
       "      <td>1</td>\n",
       "      <td>[ 0.04253004  0.04300297  0.01848392  0.048672...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>Bernie supporters on Twitter erupt in anger ag...</td>\n",
       "      <td>— Kaydee King (@KaydeeKing) November 9, 2016 T...</td>\n",
       "      <td>0</td>\n",
       "      <td>[ 0.10801624  0.11583211  0.02874823  0.061732...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>The Battle of New York: Why This Primary Matters</td>\n",
       "      <td>It's primary day in New York and front-runners...</td>\n",
       "      <td>1</td>\n",
       "      <td>[ 1.69016439e-02  7.13498285e-03 -7.81233795e-...</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                                               title  \\\n",
       "0                       You Can Smell Hillary’s Fear   \n",
       "1  Watch The Exact Moment Paul Ryan Committed Pol...   \n",
       "2        Kerry to go to Paris in gesture of sympathy   \n",
       "3  Bernie supporters on Twitter erupt in anger ag...   \n",
       "4   The Battle of New York: Why This Primary Matters   \n",
       "\n",
       "                                                text  label  \\\n",
       "0  Daniel Greenfield, a Shillman Journalism Fello...      0   \n",
       "1  Google Pinterest Digg Linkedin Reddit Stumbleu...      0   \n",
       "2  U.S. Secretary of State John F. Kerry said Mon...      1   \n",
       "3  — Kaydee King (@KaydeeKing) November 9, 2016 T...      0   \n",
       "4  It's primary day in New York and front-runners...      1   \n",
       "\n",
       "                                       title_vectors  \n",
       "0  [ 1.1533764e-02  4.2144405e-03  1.9692603e-02 ...  \n",
       "1  [ 0.11267698  0.02518966 -0.00212591  0.021095...  \n",
       "2  [ 0.04253004  0.04300297  0.01848392  0.048672...  \n",
       "3  [ 0.10801624  0.11583211  0.02874823  0.061732...  \n",
       "4  [ 1.69016439e-02  7.13498285e-03 -7.81233795e-...  "
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df.drop('Unnamed: 0', inplace=True, axis=1)\n",
    "label_trans = lambda i: 0 if i == 'FAKE' else 1\n",
    "df.label = df.label.apply(label_trans)\n",
    "df.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.axes._subplots.AxesSubplot at 0x1a134502b0>"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x1a1325c278>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib\n",
    "%matplotlib inline\n",
    "df['text'].str.len().plot(kind = 'hist', bins = 1000, figsize = (7,5))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Term document\n",
    "\n",
    "The contents in text are vary from each other. To normalize them, I transfer all the words into lowercase words and filter all the punctuations. And then tokenize them into a word list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "from string import punctuation\n",
    "texts = df.text\n",
    "mapping_table = {ord(char): u' ' for char in punctuation}\n",
    "tokenized = [nltk.word_tokenize(review.translate(mapping_table)) for review in texts]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "def clean_text(tokenized_list):\n",
    "    import string\n",
    "    sw = nltk.corpus.stopwords.words('english')\n",
    "    sw.append(\"“\")\n",
    "    sw.append(\"”\")\n",
    "    sw.append(\"’\")\n",
    "    sw.append(\"‘\")\n",
    "    sw.append(\"—\")\n",
    "    new_list = [[token.lower() for token in tlist if token not in string.punctuation and token.lower() not in sw] for tlist in tokenized_list]\n",
    "    return new_list\n",
    "cleaned = clean_text(tokenized)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "from gensim.models import Doc2Vec, Word2Vec\n",
    "from gensim.models.doc2vec import TaggedDocument\n",
    "from nltk.corpus import reuters\n",
    "\n",
    "tokenized_docs = [nltk.word_tokenize(reuters.raw(fileid)) for fileid in reuters.fileids()]\n",
    "tagged_docs = [TaggedDocument(doc, tags=[idx]) for idx, doc in enumerate(cleaned)]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Vector transition\n",
    "\n",
    "I use two ways to transit the words showed up in the word list that I created in last step: Word2Vec and Doc2Vec, and right now I can't tell which one is better."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "word_model = Word2Vec(cleaned, size = 300, window = 5, min_count = 1, alpha = 0.025, iter=10, batch_words = 10000)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "27020435"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "doc_model = Doc2Vec(size=300, window=5, min_count=5, dm = 1, iter=10)\n",
    "doc_model.build_vocab(tagged_docs)\n",
    "doc_model.train(tagged_docs, epochs=10, total_examples=doc_model.corpus_count)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(6335, 300)"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import numpy as np\n",
    "doc_vectors = []\n",
    "for i in range(len(df)):\n",
    "    doc_vectors.append(doc_model.docvecs[i])\n",
    "doc_vectors = np.asarray(doc_vectors)\n",
    "doc_vectors.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Users/lifesaver/miniconda3/lib/python3.6/site-packages/ipykernel_launcher.py:5: DeprecationWarning: Call to deprecated `__getitem__` (Method will be removed in 4.0.0, use self.wv.__getitem__() instead).\n",
      "  \"\"\"\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "(6335, 300)"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "word_vectors = np.zeros((len(df), 300))\n",
    "for i in range(0, len(df)):\n",
    "    word_vectors[i] = 0\n",
    "    for word in cleaned[i]:\n",
    "        word_vectors[i] += word_model[word]\n",
    "    if len(cleaned[i]) != 0:\n",
    "        word_vectors[i] = word_vectors[i] / len(cleaned[i])\n",
    "word_vectors.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Set splitting\n",
    "\n",
    "As learned in first lecture, I split the set into testing set and training set, with 300 features selected, and the test size is set to one third. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "x0 = word_vectors\n",
    "x = doc_vectors\n",
    "y = np.array(df['label']) \n",
    "from sklearn.model_selection import train_test_split\n",
    "seed = 2\n",
    "test_size = 0.33\n",
    "x0_train, x0_test, y0_train, y0_test = train_test_split(x0, y, test_size=test_size, random_state=seed)\n",
    "x_train, x_test, y_train, y_test = train_test_split(x, y, test_size=test_size, random_state=seed)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Logistic regression"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Word2Vec + LR: 0.8976566236250598\n",
      "Doc2Vec  + LR: 0.8574844571975132\n"
     ]
    }
   ],
   "source": [
    "import time\n",
    "from sklearn.linear_model import LogisticRegression\n",
    "LR0_model = LogisticRegression()\n",
    "LR_model = LogisticRegression()\n",
    "LR0_model = LR0_model.fit(x0_train, y0_train)\n",
    "LR_model = LR_model.fit(x_train, y_train)\n",
    "print(\"Word2Vec + LR:\",LR0_model.score(x0_test, y0_test))\n",
    "print(\"Doc2Vec  + LR:\",LR_model.score(x_test, y_test))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Word2Vec + LR\n",
      "             precision    recall  f1-score   support\n",
      "\n",
      "       FAKE       0.90      0.89      0.90      1050\n",
      "       REAL       0.89      0.90      0.90      1041\n",
      "\n",
      "avg / total       0.90      0.90      0.90      2091\n",
      "\n",
      "Doc2Vec + LR\n",
      "             precision    recall  f1-score   support\n",
      "\n",
      "       FAKE       0.83      0.90      0.86      1050\n",
      "       REAL       0.89      0.81      0.85      1041\n",
      "\n",
      "avg / total       0.86      0.86      0.86      2091\n",
      "\n"
     ]
    }
   ],
   "source": [
    "from sklearn.metrics import classification_report\n",
    "target_names = ['FAKE', 'REAL']\n",
    "y0_pred = LR0_model.predict(x0_test)\n",
    "y_pred = LR_model.predict(x_test)\n",
    "print(\"Word2Vec + LR\")\n",
    "print(classification_report(y0_test, y0_pred, target_names=target_names))\n",
    "print(\"Doc2Vec + LR\")\n",
    "print(classification_report(y_test, y_pred, target_names=target_names))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.metrics import * \n",
    "LR0_result = [accuracy_score(y0_test, y0_pred), precision_score(y0_test, y0_pred), recall_score(y0_test, y0_pred),\n",
    "             f1_score(y0_test, y0_pred)]\n",
    "LR_result = [accuracy_score(y_test, y_pred), precision_score(y_test, y_pred), recall_score(y_test, y_pred),\n",
    "             f1_score(y_test, y_pred)]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Random Forest"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Word2Vec + RF: 0.8866571018651362\n",
      "Doc2Vec  + RF: 0.8579626972740315\n"
     ]
    }
   ],
   "source": [
    "from sklearn.ensemble import RandomForestClassifier\n",
    "RF0_model = RandomForestClassifier(n_estimators = 20, max_features=20, random_state=seed)\n",
    "RF_model = RandomForestClassifier(n_estimators = 20, max_features=20, random_state=seed)\n",
    "RF0_model = RF0_model.fit(x0_train, y0_train)\n",
    "RF_model = RF_model.fit(x_train, y_train)\n",
    "print(\"Word2Vec + RF:\",RF0_model.score(x0_test, y0_test))\n",
    "print(\"Doc2Vec  + RF:\",RF_model.score(x_test, y_test))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Word2Vec + RF\n",
      "             precision    recall  f1-score   support\n",
      "\n",
      "       FAKE       0.87      0.91      0.89      1050\n",
      "       REAL       0.91      0.86      0.88      1041\n",
      "\n",
      "avg / total       0.89      0.89      0.89      2091\n",
      "\n",
      "Doc2Vec + RF\n",
      "             precision    recall  f1-score   support\n",
      "\n",
      "       FAKE       0.84      0.89      0.86      1050\n",
      "       REAL       0.88      0.83      0.85      1041\n",
      "\n",
      "avg / total       0.86      0.86      0.86      2091\n",
      "\n"
     ]
    }
   ],
   "source": [
    "y0_pred = RF0_model.predict(x0_test)\n",
    "y_pred = RF_model.predict(x_test)\n",
    "print(\"Word2Vec + RF\")\n",
    "print(classification_report(y0_test, y0_pred, target_names=target_names))\n",
    "print(\"Doc2Vec + RF\")\n",
    "print(classification_report(y_test, y_pred, target_names=target_names))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.metrics import * \n",
    "RF0_result = [accuracy_score(y0_test, y0_pred), precision_score(y0_test, y0_pred), recall_score(y0_test, y0_pred),\n",
    "             f1_score(y0_test, y0_pred)]\n",
    "RF_result = [accuracy_score(y_test, y_pred), precision_score(y_test, y_pred), recall_score(y_test, y_pred),\n",
    "             f1_score(y_test, y_pred)]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## XGboost"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Word2Vec + XG: 0.8871353419416547\n",
      "Doc2Vec  + XG: 0.8813964610234337\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Users/lifesaver/miniconda3/lib/python3.6/site-packages/sklearn/preprocessing/label.py:151: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n",
      "  if diff:\n",
      "/Users/lifesaver/miniconda3/lib/python3.6/site-packages/sklearn/preprocessing/label.py:151: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n",
      "  if diff:\n"
     ]
    }
   ],
   "source": [
    "from xgboost import XGBClassifier\n",
    "XG0_model = XGBClassifier(max_depth=7, learning_rate=0.2, \n",
    "                        n_estimators=20, silent=True, \n",
    "                        objective='binary:logistic', nthread=-1, \n",
    "                        gamma=0, min_child_weight=1, max_delta_step=0, \n",
    "                        subsample=1, colsample_bytree=1, \n",
    "                        colsample_bylevel=1, reg_alpha=0, \n",
    "                        reg_lambda=1, scale_pos_weight=1, \n",
    "                        base_score=0.5, seed=0, missing=None)\n",
    "XG_model = XGBClassifier(max_depth=7, learning_rate=0.2, \n",
    "                        n_estimators=20, silent=True, \n",
    "                        objective='binary:logistic', nthread=-1, \n",
    "                        gamma=0, min_child_weight=1, max_delta_step=0, \n",
    "                        subsample=1, colsample_bytree=1, \n",
    "                        colsample_bylevel=1, reg_alpha=0, \n",
    "                        reg_lambda=1, scale_pos_weight=1, \n",
    "                        base_score=0.5, seed=0, missing=None)\n",
    "XG0_model = XG0_model.fit(x0_train, y0_train)\n",
    "XG_model = XG_model.fit(x_train, y_train)\n",
    "print(\"Word2Vec + XG:\",XG0_model.score(x0_test, y0_test))\n",
    "print(\"Doc2Vec  + XG:\",XG_model.score(x_test, y_test))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Word2Vec + XG\n",
      "             precision    recall  f1-score   support\n",
      "\n",
      "       FAKE       0.88      0.90      0.89      1050\n",
      "       REAL       0.89      0.88      0.89      1041\n",
      "\n",
      "avg / total       0.89      0.89      0.89      2091\n",
      "\n",
      "Doc2Vec + XG\n",
      "             precision    recall  f1-score   support\n",
      "\n",
      "       FAKE       0.87      0.89      0.88      1050\n",
      "       REAL       0.89      0.87      0.88      1041\n",
      "\n",
      "avg / total       0.88      0.88      0.88      2091\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Users/lifesaver/miniconda3/lib/python3.6/site-packages/sklearn/preprocessing/label.py:151: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n",
      "  if diff:\n",
      "/Users/lifesaver/miniconda3/lib/python3.6/site-packages/sklearn/preprocessing/label.py:151: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n",
      "  if diff:\n"
     ]
    }
   ],
   "source": [
    "y0_pred = XG0_model.predict(x0_test)\n",
    "y_pred = XG_model.predict(x_test)\n",
    "print(\"Word2Vec + XG\")\n",
    "print(classification_report(y0_test, y0_pred, target_names=target_names))\n",
    "print(\"Doc2Vec + XG\")\n",
    "print(classification_report(y_test, y_pred, target_names=target_names))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.metrics import * \n",
    "XG0_result = [accuracy_score(y0_test, y0_pred), precision_score(y0_test, y0_pred), recall_score(y0_test, y0_pred),\n",
    "             f1_score(y0_test, y0_pred)]\n",
    "XG_result = [accuracy_score(y_test, y_pred), precision_score(y_test, y_pred), recall_score(y_test, y_pred),\n",
    "             f1_score(y_test, y_pred)]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Results"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x1a581977b8>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "Y1 = np.array(LR0_result[:4])\n",
    "Y2 = np.array(RF0_result[:4])\n",
    "Y3 = np.array(XG0_result[:4])\n",
    "from matplotlib import pyplot as plt\n",
    "plt.figure(figsize=(11,6))\n",
    "n = 4\n",
    "X = np.arange(n)+1\n",
    "plt.xticks([1.3,2.3,3.3,4.3],[r'$Accuracy$', r'$Precision$', r'$Recall$',r'$F1-score$'])\n",
    "plt.bar(X,Y1,width = 0.3,facecolor = 'lightskyblue',edgecolor = 'white',label='LR')\n",
    "plt.bar(X+0.3,Y2,width = 0.3,facecolor = 'yellowgreen',edgecolor = 'white',label='RF')\n",
    "plt.bar(X+0.6, Y3, width = 0.3,facecolor = 'coral',edgecolor = 'white',label='XG')\n",
    "for x,y in zip(X,Y1):\n",
    "    plt.text(x, y, '%.2f' % y, ha='center', va= 'bottom')\n",
    "for x,y in zip(X,Y2):\n",
    "    plt.text(x+0.3, y, '%.2f' % y, ha='center', va= 'bottom')\n",
    "for x,y in zip(X,Y3):\n",
    "    plt.text(x+0.6, y, '%.2f' % y, ha='center', va= 'bottom')\n",
    "plt.ylabel('Percentage')\n",
    "plt.ylim(0,+1)\n",
    "plt.legend()\n",
    "plt.title('Word2Vec Result')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x1a58377cf8>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "Y1 = np.array(LR_result[:4])\n",
    "Y2 = np.array(RF_result[:4])\n",
    "Y3 = np.array(XG_result[:4])\n",
    "from matplotlib import pyplot as plt\n",
    "plt.figure(figsize=(11,6))\n",
    "n = 4\n",
    "X = np.arange(n)+1\n",
    "plt.xticks([1.3,2.3,3.3,4.3],[r'$Accuracy$', r'$Precision$', r'$Recall$',r'$F1-score$'])\n",
    "plt.bar(X,Y1,width = 0.3,facecolor = 'lightskyblue',edgecolor = 'white',label='LR')\n",
    "plt.bar(X+0.3,Y2,width = 0.3,facecolor = 'yellowgreen',edgecolor = 'white',label='RF')\n",
    "plt.bar(X+0.6, Y3, width = 0.3,facecolor = 'coral',edgecolor = 'white',label='XG')\n",
    "for x,y in zip(X,Y1):\n",
    "    plt.text(x, y, '%.2f' % y, ha='center', va= 'bottom')\n",
    "for x,y in zip(X,Y2):\n",
    "    plt.text(x+0.3, y, '%.2f' % y, ha='center', va= 'bottom')\n",
    "for x,y in zip(X,Y3):\n",
    "    plt.text(x+0.6, y, '%.2f' % y, ha='center', va= 'bottom')\n",
    "plt.ylabel('Percentage')\n",
    "plt.ylim(0,+1)\n",
    "plt.legend()\n",
    "plt.title('Doc2Vec Result')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Analysis\n",
    "\n",
    "It seems that the Word2Vec has better score in every field comparing to Doc2Vec method, which make sence because when we choose vectors from word it maybe will cause us a lot of time but the result is more accuracy and more specific. The best model in Word2Vec is very hard to say sense the models perform very close to each other, but I will choose logistic regression rather than other two because of time spend. "
   ]
  }
 ],
 "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.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}