Python_whatsyourfood.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "_cell_guid": "b1076dfc-b9ad-4769-8c92-a6c4dae69d19",
    "_uuid": "8f2839f25d086af736a60e9eeb907d3b93b6e0e5"
   },
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import json\n",
    "import collections as cl\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "from nltk.stem import WordNetLemmatizer\n",
    "from nltk.corpus import stopwords\n",
    "from string import punctuation\n",
    "from sklearn.linear_model import LinearRegression\n",
    "from sklearn.linear_model import LogisticRegression\n",
    "from sklearn.feature_extraction.text import CountVectorizer\n",
    "from sklearn.feature_extraction.text import TfidfVectorizer\n",
    "from sklearn.ensemble import RandomForestClassifier as RFC\n",
    "from sklearn.neural_network import MLPClassifier\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.svm import SVC\n",
    "from sklearn import naive_bayes\n",
    "from sklearn.metrics import accuracy_score\n",
    "from sklearn.metrics import classification_report\n",
    "from gensim.utils import simple_preprocess\n",
    "from gensim.models import Doc2Vec\n",
    "from gensim.models.doc2vec import TaggedDocument\n",
    "import xgboost\n",
    "import warnings"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "_cell_guid": "79c7e3d0-c299-4dcb-8224-4455121ee9b0",
    "_uuid": "d629ff2d2480ee46fbb7e2d37f6b5fab8052498a",
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "df = pd.read_json('../input/train.json')\n",
    "df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "_uuid": "e16a7299e45aaa4ae44ed29c59c6d5285426b185"
   },
   "outputs": [],
   "source": [
    "missing_values=pd.isnull(df)\n",
    "print(\"MISSING VALUES IN ID: \",missing_values.id.unique())\n",
    "print(\"MISSING VALUES IN CUISINE:\",missing_values.cuisine.unique())\n",
    "print(\"MISSING VALUES IN INGREDIENTS: \",missing_values.ingredients.unique())\n",
    "print(\"------------------------------------------------------------\")\n",
    "print(\"DATE TYPE OF ID:\",df.id.dtype)\n",
    "print(\"DATE TYPE OF Cuisine:\",df.cuisine.dtype)\n",
    "print(\"DATE TYPE OF Ingredients:\",df.ingredients.dtype)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "_uuid": "2e1124b375cf85413d795f574143278662686370",
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "cnt = cl.Counter()\n",
    "for i in df['ingredients']:\n",
    "    for j in i:\n",
    "        cnt[j] +=1\n",
    "list_keyval =  sorted(cnt.items(), key=lambda pair: pair[1], reverse=True)\n",
    "top_10_ingredients = list_keyval[:10]\n",
    "keys = []\n",
    "values = []\n",
    "for i in top_10_ingredients:\n",
    "    keys.append(i[0])\n",
    "    values.append(i[1])\n",
    "print(top_10_ingredients)\n",
    "explode = (0.1, 0, 0, 0,0, 0, 0,0, 0, 0)  # explode 1st slice\n",
    "fig, ax = plt.subplots(figsize=(8, 8), subplot_kw=dict(aspect=\"equal\"))\n",
    "plt.pie(values,explode = explode, labels=keys,\n",
    "        autopct='%1.1f%%', shadow=True, startangle=140)\n",
    "# add a circle at the center\n",
    "my_circle=plt.Circle( (0,0), 0.7, color='white')\n",
    "p=plt.gcf()\n",
    "p.gca().add_artist(my_circle)\n",
    "ax.set_title(\"Plot for Top 10 ingredients used\")\n",
    "plt.show()\n",
    "print('Top 5 Cuisines')\n",
    "count_cu = cl.Counter()\n",
    "for i in df['cuisine']:\n",
    "    count_cu[i]+=1\n",
    "len(count_cu)\n",
    "list_cui =  sorted(count_cu.items(), key=lambda pair: pair[1], reverse=True)\n",
    "list_cui = list_cui[:5]\n",
    "keys_cui = []\n",
    "values_cui = []\n",
    "for i in list_cui:\n",
    "    keys_cui.append(i[0])\n",
    "    values_cui.append(i[1])\n",
    "print(keys_cui)\n",
    "print(values_cui)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "_uuid": "a67c2a73dc48666f3f0f8d7bfc042bb7b7fe327a",
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "df['cuisine'].value_counts().plot(kind='bar')\n",
    "\n",
    "plt.xlabel(\"CUISINES\")\n",
    "plt.ylabel(\"FREQUENCY OF CUISINES\")\n",
    "plt.show()\n",
    "df['cuisine'].value_counts()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "_uuid": "23f5b428a2b513eb86c197cfc9ffb3b211453e96"
   },
   "outputs": [],
   "source": [
    "def strip_punctuation(s):\n",
    "    return ''.join(c for c in s if c not in punctuation)\n",
    "stop_words = set(stopwords.words('english'))\n",
    "lemmatizer = WordNetLemmatizer()\n",
    "df.cuisine.str.lower()\n",
    "def process(x):\n",
    "    k = []\n",
    "    l1 = []\n",
    "    for ele in x:\n",
    "        k.append(ele.split(\" \"))\n",
    "    for elem in k:\n",
    "        c = []\n",
    "        for i in elem:\n",
    "            c.append(lemmatizer.lemmatize(i))\n",
    "        l1.append(\" \".join(c))\n",
    "    return l1\n",
    "\n",
    "l = []\n",
    "for i in range(0,len(df.ingredients)):\n",
    "    filtered_ingredients = [w for w in df.ingredients[i] if not w in stop_words]\n",
    "    filtered_ingredients = [strip_punctuation(w) for w in filtered_ingredients]\n",
    "    filtered_ingredients = [w.lower() for w in filtered_ingredients if not w.isdigit()]\n",
    "    si = process(filtered_ingredients)\n",
    "    corpus = {'id': int(df.id[i]), 'cuisine': df.cuisine[i], 'ingredients': df.ingredients[i], 'stemmedingredients': si}\n",
    "    l.append(corpus)\n",
    "with open('cleaned_train.json', mode='w') as json_file:\n",
    "    json.dump(l, json_file)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "_uuid": "666c61d31a6e0efb4118f2249316ac3893754c76",
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "df_clean = pd.read_json('cleaned_train.json')\n",
    "df_clean"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "_uuid": "3803189b4856334e296537d62280f7a8945c88f5"
   },
   "outputs": [],
   "source": [
    "cuisine = pd.unique(df_clean.cuisine)\n",
    "cuisine_ingredients = []\n",
    "freq = []\n",
    "temp = []\n",
    "for cs in cuisine:\n",
    "    ingredient = []\n",
    "    for c in range(len(df_clean.cuisine)):\n",
    "        if df_clean.cuisine[c]==cs:\n",
    "            ingredient.extend(df_clean.stemmedingredients[c])\n",
    "    cuisine_ingredients.append(ingredient)\n",
    "    freq.append(len(set(ingredient)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "_uuid": "f536755f0c4c14f9401a5d18f34cdef05ae43437"
   },
   "outputs": [],
   "source": [
    "warnings.filterwarnings('ignore')\n",
    "plt.figure(figsize = (12, 8))\n",
    "g = sns.barplot(cuisine, freq, palette = [\"blue\"], alpha = 0.7)\n",
    "g.set_xticklabels(cuisine, rotation = 90, fontsize = 10, fontname = 'DejaVu Sans')\n",
    "g.set(xlabel = 'Cuisines', ylabel = 'Number of different Ingredients')\n",
    "g.set_title('Number of distinct Ingredients used in different Cuisines',fontname = 'fantasy', fontsize = 'xx-large', color = 'midnightblue', fontweight = 'bold')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "_uuid": "fe55a8de0472587e831e2e1c0c89f513a374002c"
   },
   "outputs": [],
   "source": [
    "cuisine_recipes = df_clean.cuisine.value_counts()    \n",
    "freq_list = []\n",
    "i=0;\n",
    "for ti in cuisine_ingredients:\n",
    "    ti_df = pd.Series(ti)\n",
    "    f = ti_df.value_counts()\n",
    "    freq_list.append(f.divide(cuisine_recipes[cuisine[i]]))\n",
    "    i+=1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "_uuid": "189baf40ea54934ced216fc6f50fd0e7feb66367"
   },
   "outputs": [],
   "source": [
    "i=0\n",
    "g1 = []\n",
    "g2 = []\n",
    "for fl in freq_list:\n",
    "    print(\"\\nCuisine: \", cuisine[i].upper(),'\\n')\n",
    "    g1.append(list(fl[0:5]))\n",
    "    g2.append(list(fl.index[0:5]))\n",
    "    for j in range(5):\n",
    "        print(j+1,'.', fl.index[j].upper())\n",
    "    i+=1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "_uuid": "27a56a6d7557476283a3ec6213d94e15aa178477",
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "warnings.filterwarnings('ignore')\n",
    "sns.set(rc={'axes.facecolor':'white', 'figure.facecolor':'white'})\n",
    "plt.figure(figsize = (20, 20))\n",
    "axes = plt.subplot(5, 4, 20)\n",
    "for j in range(20):\n",
    "    plt.subplot(5, 4, j+1)\n",
    "    g=sns.barplot([100*x for x in g1[j]], g2[j], color = \"yellowgreen\", alpha = 0.3)\n",
    "    g.set(yticklabels = [])\n",
    "    for i in range(5):\n",
    "        g.text(5, i+0.1, s = g2[j][i], fontname = 'fantasy', color = \"midnightblue\", fontstyle = 'oblique', fontsize = 'x-large')\n",
    "    g.set_title(cuisine[j].upper(), fontsize = 15, fontname = 'fantasy', fontweight = \"bold\")\n",
    "plt.suptitle(\"MOST USED INGREDIENTS\", fontname = 'fantasy', fontsize = 'xx-large', color = 'mediumvioletred', fontweight = 'bold')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "_uuid": "734c5460ee87a5c00211eef37af5eee428577dc9"
   },
   "outputs": [],
   "source": [
    "t = pd.DataFrame(pd.concat(freq_list))\n",
    "usage = t.groupby(t.index).sum()\n",
    "for i in range(len(freq_list)):\n",
    "    for j in range(len(freq_list[i])):\n",
    "        if freq_list[i][j] >=0.1:\n",
    "            d = float(usage.loc[freq_list[i].index[j]])\n",
    "            freq_list[i][j] = freq_list[i][j]/d\n",
    "        else:\n",
    "            freq_list[i][j] = 0\n",
    "for i in range(len(freq_list)):\n",
    "    freq_list[i] = 100*(freq_list[i].sort_values(ascending = False))\n",
    "freq_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "_uuid": "992d6616ebc69b960036f524157903585ff2d8bd"
   },
   "outputs": [],
   "source": [
    "i=0\n",
    "g1 = []\n",
    "g2 = []\n",
    "for fl in freq_list:\n",
    "    print(\"\\nCuisine: \", cuisine[i].upper(),'\\n')\n",
    "    g1.append(list(fl[0:5]))\n",
    "    g2.append(list(fl.index[0:5]))\n",
    "    for j in range(5):\n",
    "        print(j+1,'.', fl.index[j].upper())\n",
    "    i+=1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "_uuid": "3f41013fe1e73d2732607f01dda001bc6c8c4967",
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "warnings.filterwarnings('ignore')\n",
    "sns.set(rc={'axes.facecolor':'white', 'figure.facecolor':'white'})\n",
    "plt.figure(figsize = (20, 20))\n",
    "axes = plt.subplot(5, 4, 20)\n",
    "for j in range(20):\n",
    "    plt.subplot(5, 4, j+1)\n",
    "    g=sns.barplot(g1[j], g2[j], color = \"mediumvioletred\", alpha = 0.3)\n",
    "    g.set(yticklabels = [])\n",
    "    for i in range(5):\n",
    "        g.text(5, i+0.1, s = g2[j][i], fontname = 'fantasy', color = \"midnightblue\", fontstyle = 'oblique', fontsize = 'x-large')\n",
    "    g.set_title(cuisine[j].upper(), fontsize = 15, fontname = 'fantasy', fontweight = \"bold\")\n",
    "plt.suptitle(\"MOST CUISINE-SPECIFIC INGREDIENTS\", fontname = 'fantasy', fontsize = 'xx-large', color = 'mediumvioletred', fontweight = 'bold')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "_uuid": "e954177fba74948c3f456cebee11ad5b73c642bf"
   },
   "outputs": [],
   "source": [
    "unique_ingredients=[]\n",
    "for i in range(0,len(df_clean['stemmedingredients'])):\n",
    "    unique_ingredients.extend(df_clean['stemmedingredients'][i])\n",
    "    unique_ingredients=list(set(unique_ingredients))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "_uuid": "c872702f53b2aee5bde960037e8067a6a8001948"
   },
   "source": [
    "**Data Transformation using TfidfVectorizer**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "_uuid": "ac7add7ce73ed0d5c44dfbde471f434eb7dbe2e4"
   },
   "outputs": [],
   "source": [
    "docs = []\n",
    "for ingredients in df_clean.stemmedingredients:\n",
    "    str1 = \"\"\n",
    "    for ingredient in ingredients:\n",
    "        str1 = str1 + ingredient + \" \"\n",
    "    docs.append(str1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "_uuid": "082be56e82174cacb22a0987cc25503d745894b6"
   },
   "outputs": [],
   "source": [
    "vectorizer = TfidfVectorizer()\n",
    "X_transformed = vectorizer.fit_transform(docs)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "_uuid": "de45c504050cef016c94572e38703a4861a9c146"
   },
   "outputs": [],
   "source": [
    "X_train, X_test, y_train, y_test = train_test_split(X_transformed, df.cuisine, test_size = 0.30)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "_uuid": "94263815cd45fe5e56f62424eca540a4a8368025"
   },
   "outputs": [],
   "source": [
    "from sklearn.svm import SVC  \n",
    "svclassifier = SVC(kernel='linear')  \n",
    "svclassifier.fit(X_train, y_train)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "_uuid": "1e3306d2a9e12e7f0078db8b651b86d311828039"
   },
   "outputs": [],
   "source": [
    "y_pred = svclassifier.predict(X_test)  \n",
    "print(\"SVM ACCURACY:\",accuracy_score(y_test, y_pred))\n",
    "print(classification_report(y_test,y_pred))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "_uuid": "fa6a19b357553e51a0a7c9bb65cbfb759841bd4f"
   },
   "outputs": [],
   "source": [
    "def model_train(classifier, train_vector, label, train_valid, is_neural_net=False):\n",
    "    # fit the training dataset on the classifier\n",
    "    classifier.fit(train_vector, label)\n",
    "    \n",
    "    # predict the labels on validation dataset\n",
    "    predictions = classifier.predict(train_valid)\n",
    "    \n",
    "    if is_neural_net:\n",
    "        predictions = predictions.argmax(axis=-1)\n",
    "    \n",
    "    return accuracy_score(predictions, y_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "_uuid": "1a3f9ddba4920a823330bd700e830a542973b7d0"
   },
   "outputs": [],
   "source": [
    "accuracy = model_train(naive_bayes.MultinomialNB(fit_prior = False), X_train, y_train, X_test)\n",
    "print(\"Naive Baye's Accuracy \", accuracy)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "_uuid": "b62c4fd17051991d50cd0e56147935ae4ddb5570"
   },
   "outputs": [],
   "source": [
    "forest=RFC(n_estimators=500, max_features = 10)\n",
    "forest.fit(X_train,y_train)\n",
    "output=forest.predict(X_test)\n",
    "print(\"RANDOM FORESTS ACCURACY:\",accuracy_score(y_test, output))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "_uuid": "a38d3136317da23ef9648b27f473d782e14ece0e"
   },
   "outputs": [],
   "source": [
    "warnings.filterwarnings('ignore')\n",
    "accuracy = model_train(xgboost.XGBClassifier(), X_train.tocsc(), y_train, X_test.tocsc())\n",
    "print (\"XG Boost Accuracy: \", accuracy)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "_uuid": "0bb8001e27c1a4b7bd97d6afafb9d6a7cdee6e62"
   },
   "source": [
    "**Data Transformation using CountVectorizer**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "_uuid": "9de2efddebc127cd5938b012cb5712514b03d144"
   },
   "outputs": [],
   "source": [
    "vect = CountVectorizer(max_features = 1000)\n",
    "train_ingr = df_clean['stemmedingredients']\n",
    "docs = [' '.join(x) for x in train_ingr]\n",
    "X_transformed = vect.fit_transform(docs)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "_uuid": "d23eb7ec915344397a55c9010232d9c4d00dc34b"
   },
   "outputs": [],
   "source": [
    "X_train, X_test, y_train, y_test = train_test_split(X_transformed, df.cuisine, test_size = 0.30)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "_uuid": "adb51c425faaed6ceebcb0c40e3d3ab8fd29e573"
   },
   "outputs": [],
   "source": [
    "forest = RFC(n_estimators = 500)\n",
    "forest = forest.fit(X_train, y_train)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "_uuid": "10187817c77e6256350d1415adbcc58007763d90"
   },
   "outputs": [],
   "source": [
    "y_pred = forest.predict(X_test)\n",
    "print(\"Random Forest Accuracy using CountVectorizer-\",100 * accuracy_score(y_test, y_pred),\"%\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "_uuid": "a2d67ebc20452d01999a9ba64ebaad074e99841c"
   },
   "outputs": [],
   "source": [
    "clf = MLPClassifier(solver='lbfgs', alpha=1e-5,hidden_layer_sizes=(15,), random_state=1)\n",
    "clf.fit(X_train, y_train)\n",
    "y_pred = clf.predict(X_test)\n",
    "print(\"Neural Net accuracy using CountVectorizer:\",100 * accuracy_score(y_test, y_pred),'%')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "_uuid": "1c417fcfcbe5cccf0895956ba370c41354c1303b",
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "print(classification_report(y_test,y_pred))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "_uuid": "e777689ba7d7d523d4e1bbad9ebc19b81e56c7d1"
   },
   "outputs": [],
   "source": [
    "svclassifier = SVC(kernel='linear')  \n",
    "svclassifier.fit(X_train, y_train)\n",
    "y_pred = svclassifier.predict(X_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "_uuid": "0666643b2a9813574e944fe24518fcc57ef5eb26"
   },
   "outputs": [],
   "source": [
    "print(\"Accuracy using SVM: \",accuracy_score(y_test, y_pred))\n",
    "print(classification_report(y_test,y_pred))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "_uuid": "e5316232f0fd34748e55062113c6cc933534aeee"
   },
   "source": [
    "**Data Transformation using Doc2Vec**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "_uuid": "4b707669521fc9ad63715e004e97492e292faf6a",
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "recipes = []\n",
    "for recipe in df_clean.stemmedingredients:\n",
    "    s = \"\"\n",
    "    for r_ingredient in recipe:\n",
    "        s = s+' '+r_ingredient\n",
    "    recipes.append(s)\n",
    "recipes = pd.Series(recipes)\n",
    "recipes = recipes.rename(\"ingredients\")\n",
    "data = pd.DataFrame(df_clean.cuisine)\n",
    "data = data.join(recipes)\n",
    "data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "_uuid": "2008568369fd63a0f8f0167910f276a4176820be"
   },
   "outputs": [],
   "source": [
    "def tag_docs(docs):\n",
    "    tagged = docs.apply(lambda r: TaggedDocument(words=simple_preprocess(r['ingredients']), tags=[r.cuisine]), axis=1)\n",
    "    return tagged"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "_uuid": "c6ba88f30174665b8af321a2ac12c42fec1e3437"
   },
   "outputs": [],
   "source": [
    "def train_doc2vec_model(tagged_docs):\n",
    "    sents = tagged_docs.values\n",
    "    doc2vec_model = Doc2Vec(sents, vector_size=650, window=1, epochs=20, dm=1, worker = 4)\n",
    "    return doc2vec_model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "_uuid": "a85e6b141ceca1d2840ff46ecb305bb940f1bced"
   },
   "outputs": [],
   "source": [
    "def vec_for_learning(doc2vec_model, tagged_docs):\n",
    "    sents = tagged_docs.values\n",
    "    targets, regressors = zip(*[(doc.tags[0], doc2vec_model.infer_vector(doc.words, steps=200)) for doc in sents])\n",
    "    return targets, regressors"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "_uuid": "5c1c13e013a69f822b98f8aafcf3ab8c42e6acb2"
   },
   "outputs": [],
   "source": [
    "train_data, test_data = train_test_split(data, test_size = 0.3)\n",
    "train_tagged = tag_docs(train_data)\n",
    "test_tagged = tag_docs(test_data)    \n",
    "model = train_doc2vec_model(train_tagged)\n",
    "y_train, X_train = vec_for_learning(model, train_tagged)\n",
    "y_test, X_test = vec_for_learning(model, test_tagged)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "_uuid": "34759fd9d2adcb0296f8f2fc82e7cf2df390d4e9"
   },
   "outputs": [],
   "source": [
    "logreg = LogisticRegression(solver = 'newton-cg', multi_class = 'multinomial')\n",
    "logreg.fit(X_train, y_train)\n",
    "y_pred = logreg.predict(X_test)\n",
    "print(\"Accuracy for Logistic Regression: \", accuracy_score(y_test, y_pred) * 100, \"%\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "_uuid": "f146d5afb7995c565c49b72f442001137b54deb8"
   },
   "outputs": [],
   "source": [
    "print(\"Logistic Regression\")\n",
    "print(classification_report(y_test,y_pred)) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "_uuid": "44c1ee89b1cd408ccab45596a4720c62e2e95d27"
   },
   "outputs": [],
   "source": [
    "svm = SVC(kernel = 'linear')\n",
    "svm.fit(X_train, y_train)\n",
    "y_pred = svm.predict(X_test)\n",
    "print(\"Accuracy for SVM: \", accuracy_score(y_test, y_pred) * 100, \"%\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "_uuid": "918a9cd51faa8a8668412819677193835e77d233"
   },
   "outputs": [],
   "source": [
    "print(\"Support Vector Machine\")\n",
    "print(classification_report(y_test,y_pred)) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "_uuid": "3f346a5a62bc12248477ac777290cca04c046cc8"
   },
   "outputs": [],
   "source": [
    "forest = RFC(n_estimators = 1000, max_features = 'log2', criterion = 'gini')\n",
    "forest.fit(X_train,y_train)\n",
    "y_pred = forest.predict(X_test)\n",
    "print(\"Accuracy for Random Forest: \", accuracy_score(y_test, y_pred) * 100, \"%\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "_uuid": "b3e52ae2404ff73752bbe22943070a445b81baf2"
   },
   "outputs": [],
   "source": [
    "print(\"Random Forest Classifier\")\n",
    "print(classification_report(y_test,y_pred)) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "_uuid": "ea92b26322b4df6abe62011a7861b387b0fedc18"
   },
   "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.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}