Optimize TF-IDF SVC Hyperopt.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# import sys\n",
    "# !{sys.executable} -m pip install imbalanced-learn --user\n",
    "# !{sys.executable} -m pip install hyperopt --user"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[nltk_data] Downloading package punkt to /home/newsgac/nltk_data...\n",
      "[nltk_data]   Package punkt is already up-to-date!\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import numpy\n",
    "from time import time\n",
    "from sklearn.model_selection import GridSearchCV\n",
    "from hyperopt import tpe, fmin, hp, STATUS_OK, Trials\n",
    "from sklearn.metrics import accuracy_score, log_loss\n",
    "from sklearn.model_selection import train_test_split\n",
    "from copy import deepcopy\n",
    "\n",
    "from newsgac import config\n",
    "from newsgac.genres import genre_codes\n",
    "from newsgac.learners import learners, LearnerSVC, LearnerNB, LearnerXGB, LearnerGB, LearnerMLP, LearnerRF, LearnerLGBM\n",
    "from newsgac.pipelines.get_sk_pipeline import get_sk_pipeline\n",
    "from newsgac.pipelines.utils import report\n",
    "from sklearn import svm\n",
    "\n",
    "\n",
    "from newsgac import database\n",
    "from newsgac.data_sources import DataSource\n",
    "from newsgac.pipelines import Pipeline\n",
    "\n",
    "# from imblearn.under_sampling import RandomUnderSampler\n",
    "# from imblearn.over_sampling import RandomOverSampler, SMOTE, ADASYN\n",
    "# from imblearn.combine import SMOTEENN, SMOTETomek\n",
    "import numpy as np\n",
    "import nltk\n",
    "nltk.download('punkt')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[u'N2BGS Training',\n",
       " u'N2BGS Testing',\n",
       " u'Linked NRC (2930)',\n",
       " u'BOW + 5 features (N2BGS train)',\n",
       " u'BOW + 5 features (N2BGS test)',\n",
       " u'nrc-1950-1994-a.txt',\n",
       " u'nrc-1950-1994-b.txt',\n",
       " u'nrc-1950-1994-c.txt',\n",
       " u'nrc-1950-1994-d.txt',\n",
       " u'nrc-1950-1994-e.txt',\n",
       " u'telegraaf-1950-1994-a.txt',\n",
       " u'telegraaf-1950-1994-b.txt',\n",
       " u'telegraaf-1950-1994-c.txt',\n",
       " u'telegraaf-1950-1994-d.txt',\n",
       " u'telegraaf-1950-1994-e.txt',\n",
       " u'volkskrant-1950-1995-a.txt',\n",
       " u'volkskrant-1950-1995-b.txt',\n",
       " u'volkskrant-1950-1995-c.txt',\n",
       " u'volkskrant-1950-1995-d.txt',\n",
       " u'volkskrant-1950-1995-e.txt',\n",
       " u'nrc-1965.txt',\n",
       " u'nrc-1985.txt',\n",
       " u'BOW + 9 features (N2BGS train)',\n",
       " u'BOW + 9 features (N2BGS test)',\n",
       " u'Linked NRC (2930/9 features)',\n",
       " u'BOW Train unique (9 features)',\n",
       " u'BOW Test unique (9 features)',\n",
       " u'Linked NRC (unique/9 features)',\n",
       " u'BOW Train unique (N3BGS/9 features)',\n",
       " u'N3BGS FROG Test',\n",
       " u'N3BGS FROG Train',\n",
       " u'BOW Test unique (N3BGS/9 features)',\n",
       " u'BOW Test unique (N3BGS/9 features/collapsed)',\n",
       " u'Linked NRC (2930 articles)',\n",
       " u'Combined N3BGS/Linked NRC (3884)',\n",
       " u'2019 N3BGS Test',\n",
       " u'2019 N3BGS Train',\n",
       " u'AAOB',\n",
       " u'20190228 unbalanced train size=3443',\n",
       " u'20190228 unbalanced test size=3443']"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[d.display_title for d in DataSource.objects.all()]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[u'dummy frog',\n",
       " u'dummy bow',\n",
       " u'RF FROG',\n",
       " u'SVC FROG',\n",
       " u'XGB FROG',\n",
       " u'NB FROG',\n",
       " u'MLP FROG',\n",
       " u'RF BOW',\n",
       " u'SVC BOW',\n",
       " u'XGB BOW',\n",
       " u'NB BOW',\n",
       " u'MLP BOW',\n",
       " u'SVC LIN BOW',\n",
       " u'Erik MLP BOW (with stop-words)',\n",
       " u'Erik MLP BOW (5 features) ',\n",
       " u'Erik MLP BOW (9 features) ',\n",
       " u'Erik SVC BOW (9 features)',\n",
       " u'Erik RF BOW (9 features)',\n",
       " u'Erik XGB BOW (9 features)',\n",
       " u'Erik NB BOW (9 features)',\n",
       " u'Erik MLP unique 9 features',\n",
       " u'Erik NB unique (9 features)',\n",
       " u'Erik XGB unique (9 features)',\n",
       " u'Erik SVC unique (9 features)',\n",
       " u'Erik RF unique (9 features)',\n",
       " u'N3BGS MLP unique 9 features',\n",
       " u'N3BGS NB unique 9 features ',\n",
       " u'N3BGS SVC unique 9 features ',\n",
       " u'N3BGS RF unique 9 features',\n",
       " u'N3BGS XGB unique 9 features ',\n",
       " u'dummy n3bgs bow',\n",
       " u'dummy n3bgs frog',\n",
       " u'RF FROG N3BGS',\n",
       " u'SVC FROG N3BGS',\n",
       " u'XGB FROG N3BGS',\n",
       " u'Erik NB N3BGS Collapsed',\n",
       " u'Erik MLP N3BGS Collapsed',\n",
       " u'Erik MLP Linked NRC (2930 articles)',\n",
       " u'Erik RF Linked NRC (2930 articles) ',\n",
       " u'Erik NB Linked NRC (2930 articles) ',\n",
       " u'Erik SVC Linked NRC (2930 articles) ',\n",
       " u'Erik XGB Linked NRC (2930 articles) ',\n",
       " u'SVC BOW Combined',\n",
       " u'NB FROG N3BGS',\n",
       " u'MLP FROG N3BGS',\n",
       " u'RF BOW NBGS',\n",
       " u'SVC BOW N3BGS',\n",
       " u'XGB BOW N3BGS',\n",
       " u'NB BOW N3BGS',\n",
       " u'MLP BOW N3BGS',\n",
       " u'KIM N3BGS FROG and TF-IDF',\n",
       " u'KIM N3BGS MLP Combi features',\n",
       " u'KIM N3BGS RF COMBI',\n",
       " u'KIM N3BGS SVM COMBI (copy)',\n",
       " u'KIM N3BGS XGB COMBI',\n",
       " u'20190228 SVM',\n",
       " u'20190228 SVC no stop words',\n",
       " u'20190228 SVC no stop words, lowercased',\n",
       " u'dummy combi for opt',\n",
       " u'dummy combi for opt ugs',\n",
       " u'new dummy ugs opt',\n",
       " u'new dummy bgs opt',\n",
       " u'dummy opt frog bgs',\n",
       " u'dummy bow opt bgs',\n",
       " u'dummy frog ugs opt',\n",
       " u'dummy bow opt ugs']"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[d.display_title for d in Pipeline.objects.all()]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "DataSource: 20190228 unbalanced train size=3443\n",
      "NLP Tool: TF-IDF\n",
      "Classifier: Light GBM\n",
      "Task status: Status.SUCCESS\n"
     ]
    }
   ],
   "source": [
    "p = Pipeline.objects.all()[65]\n",
    "print 'DataSource: ' + p.data_source.display_title\n",
    "print 'NLP Tool: ' + p.nlp_tool.name\n",
    "print 'Classifier: ' + p.learner.name\n",
    "print 'Task status: ' + str(p.task.status)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3099"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(p.data_source.articles)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Testing data source: 20190228 unbalanced test size=3443\n"
     ]
    }
   ],
   "source": [
    "test_data_source = DataSource.objects.all()[39]\n",
    "print 'Testing data source: ' + test_data_source.display_title"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[('CleanOCR', <newsgac.nlp_tools.transformers.CleanOCR at 0x7f0755a34950>),\n",
       " ('StopWordRemoval',\n",
       "  <newsgac.nlp_tools.transformers.StopWordRemoval at 0x7f0755a34990>),\n",
       " ('FeatureExtraction', FeatureUnion(n_jobs=None,\n",
       "         transformer_list=[('TFIDF', Pipeline(memory=None,\n",
       "       steps=[('RemoveQuotes', <newsgac.nlp_tools.transformers.RemoveQuotes object at 0x7f0755a34890>), ('TF-IDF', TfidfVectorizer(analyzer=u'word', binary=False, decode_error=u'strict',\n",
       "          dtype=<type 'numpy.float64'>, encoding=u'utf-8', input=u'content',\n",
       "          lowercase=True, max_df=1.0, max_featu...        token_pattern=u'(?u)\\\\b\\\\w\\\\w+\\\\b', tokenizer=None, use_idf=True,\n",
       "          vocabulary=None))]))],\n",
       "         transformer_weights=None)),\n",
       " ('RobustScaler',\n",
       "  RobustScaler(copy=True, quantile_range=(25.0, 75.0), with_centering=False,\n",
       "         with_scaling=True))]"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "skp = p.get_sk_pipeline()\n",
    "skp_opt = deepcopy(skp)\n",
    "skp_opt.steps.pop()\n",
    "skp_opt.steps"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "texts = numpy.array([article.raw_text for article in p.data_source.articles])\n",
    "labels = numpy.array([article.label for article in p.data_source.articles])\n",
    "\n",
    "X = skp_opt.fit_transform(texts)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "# get the test dataset for optimization accuracy\n",
    "texts_test = numpy.array([article.raw_text for article in test_data_source.articles])\n",
    "labels_test = numpy.array([article.label for article in test_data_source.articles])\n",
    "\n",
    "X_test = skp_opt.transform(texts_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "X_train = X\n",
    "y_train = labels\n",
    "y_test = labels_test"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(344,)"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y_test.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "kernel_list = ['linear', 'rbf', 'poly', 'sigmoid']\n",
    "# kernel_list = ['linear']\n",
    "class_weights = [None, 'balanced']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "def optimize(evals, trials, optimizer=tpe.suggest):\n",
    "    space = {\n",
    "        'kernel': hp.choice('kernel', kernel_list),\n",
    "        'class_weight': hp.choice('class_weight', class_weights),\n",
    "        'C': hp.uniform('C', 0, 20),\n",
    "        'gamma': hp.uniform('gamma',0.001,10)\n",
    "    }\n",
    "    best = fmin(score, space, algo=optimizer, max_evals=evals, trials=trials)\n",
    "    pbar.close()\n",
    "    return best"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "train_acc_list = []\n",
    "train_loss_list = []\n",
    "test_acc_list = []\n",
    "test_loss_list = []\n",
    "\n",
    "def score(params):\n",
    "    c = params['C']\n",
    "    gamma = params['gamma']\n",
    "    kernel = params['kernel']\n",
    "    class_weight = params['class_weight']\n",
    "    \n",
    "    model = svm.SVC(kernel=kernel,\n",
    "            C=c,\n",
    "            random_state=42,\n",
    "            decision_function_shape='ovr',\n",
    "            # class_weight=self.class_weight,\n",
    "            class_weight=class_weight,\n",
    "            probability=True,\n",
    "            gamma=gamma)\n",
    "    \n",
    "    model.fit(X_train, y_train)\n",
    "    labels_prediction = model.predict(X_test)\n",
    "    labels_probs = model.predict_proba(X_test)\n",
    "    train_acc = accuracy_score(y_train, model.predict(X_train))\n",
    "    train_loss = log_loss(y_train, model.predict_proba(X_train))\n",
    "    test_acc = accuracy_score(y_test, labels_prediction)\n",
    "    test_loss = log_loss(y_test, labels_probs)\n",
    "    \n",
    "    train_acc_list.append(train_acc)\n",
    "    train_loss_list.append(train_loss)\n",
    "    test_acc_list.append(test_acc)\n",
    "    test_loss_list.append(test_loss)\n",
    "    \n",
    "    print('Parameters with this training accuracy {} and loss {} :'.format(train_acc, train_loss))\n",
    "    print('Parameters with this testing accuracy {} and loss {} :'.format(test_acc, test_loss))\n",
    "    print(params)\n",
    "    pbar.update()\n",
    "#     return {'loss': test_loss, 'status': STATUS_OK}\n",
    "    return {'loss': -test_acc, 'status': STATUS_OK}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Hyperopt:   0%|          | 0/10 [00:00<?, ?it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "  0%|          | 0/10 [00:00<?, ?it/s, best loss: ?]\u001b[A\n",
      "\u001b[AParameters with this training accuracy 0.891900613101 and loss 1.30600111834 :\n",
      "\n",
      "  0%|          | 0/10 [02:42<?, ?it/s, best loss: ?]\u001b[A\n",
      "\u001b[AParameters with this testing accuracy 0.44476744186 and loss 1.65899169479 :\n",
      "\n",
      "  0%|          | 0/10 [02:42<?, ?it/s, best loss: ?]\u001b[A\n",
      "\u001b[A{'kernel': 'poly', 'C': 4.973009636125858, 'gamma': 0.4360592553431118, 'class_weight': 'balanced'}\n",
      "\n",
      "  0%|          | 0/10 [02:42<?, ?it/s, best loss: ?]\u001b[A"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Hyperopt:  10%|█         | 1/10 [02:42<24:23, 162.61s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      " 10%|█         | 1/10 [02:42<24:23, 162.60s/it, best loss: -0.44476744186]\u001b[A\n",
      "\u001b[AParameters with this training accuracy 0.996450467893 and loss 1.17658104266 :\n",
      "\n",
      " 10%|█         | 1/10 [05:37<24:23, 162.60s/it, best loss: -0.44476744186]\u001b[A\n",
      "\u001b[AParameters with this testing accuracy 0.433139534884 and loss 1.6213094774 :\n",
      "\n",
      " 10%|█         | 1/10 [05:37<24:23, 162.60s/it, best loss: -0.44476744186]\u001b[A\n",
      "\u001b[A{'kernel': 'poly', 'C': 13.633813144074633, 'gamma': 5.184094496055288, 'class_weight': 'balanced'}\n",
      "\n",
      " 10%|█         | 1/10 [05:37<24:23, 162.60s/it, best loss: -0.44476744186]\u001b[A"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Hyperopt:  20%|██        | 2/10 [05:37<22:10, 166.35s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      " 20%|██        | 2/10 [05:37<22:10, 166.34s/it, best loss: -0.44476744186]\u001b[A\n",
      "\u001b[AParameters with this training accuracy 0.996450467893 and loss 1.17095712472 :\n",
      "\n",
      " 20%|██        | 2/10 [08:27<22:10, 166.34s/it, best loss: -0.44476744186]\u001b[A\n",
      "\u001b[AParameters with this testing accuracy 0.433139534884 and loss 1.62109117743 :\n",
      "\n",
      " 20%|██        | 2/10 [08:27<22:10, 166.34s/it, best loss: -0.44476744186]\u001b[A\n",
      "\u001b[A{'kernel': 'poly', 'C': 12.502759049206931, 'gamma': 5.0334881569026235, 'class_weight': None}\n",
      "\n",
      " 20%|██        | 2/10 [08:27<22:10, 166.34s/it, best loss: -0.44476744186]\u001b[A"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Hyperopt:  30%|███       | 3/10 [08:27<19:31, 167.31s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      " 30%|███       | 3/10 [08:27<19:31, 167.30s/it, best loss: -0.44476744186]\u001b[A\n",
      "\u001b[AParameters with this training accuracy 0.207163601162 and loss 1.90881349613 :\n",
      "\n",
      " 30%|███       | 3/10 [11:00<19:31, 167.30s/it, best loss: -0.44476744186]\u001b[A\n",
      "\u001b[AParameters with this testing accuracy 0.162790697674 and loss 1.89115660412 :\n",
      "\n",
      " 30%|███       | 3/10 [11:00<19:31, 167.30s/it, best loss: -0.44476744186]\u001b[A\n",
      "\u001b[A{'kernel': 'sigmoid', 'C': 4.026079386816798, 'gamma': 0.9536605487206085, 'class_weight': 'balanced'}\n",
      "\n",
      " 30%|███       | 3/10 [11:00<19:31, 167.30s/it, best loss: -0.44476744186]\u001b[A"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Hyperopt:  40%|████      | 4/10 [11:00<16:18, 163.01s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      " 40%|████      | 4/10 [11:00<16:18, 163.00s/it, best loss: -0.44476744186]\u001b[A\n",
      "\u001b[AParameters with this training accuracy 0.995159728945 and loss 0.210083491074 :\n",
      "\n",
      " 40%|████      | 4/10 [13:20<16:18, 163.00s/it, best loss: -0.44476744186]\u001b[A\n",
      "\u001b[AParameters with this testing accuracy 0.642441860465 and loss 1.0777950372 :\n",
      "\n",
      " 40%|████      | 4/10 [13:20<16:18, 163.00s/it, best loss: -0.44476744186]\u001b[A\n",
      "\u001b[A{'kernel': 'linear', 'C': 15.278357185528439, 'gamma': 7.867216386889451, 'class_weight': 'balanced'}\n",
      "\n",
      " 40%|████      | 4/10 [13:20<16:18, 163.00s/it, best loss: -0.44476744186]\u001b[A"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Hyperopt:  50%|█████     | 5/10 [13:20<13:01, 156.29s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      " 50%|█████     | 5/10 [13:20<13:01, 156.29s/it, best loss: -0.642441860465]\u001b[A\n",
      "\u001b[AParameters with this training accuracy 0.181348822201 and loss 1.81020026274 :\n",
      "\n",
      " 50%|█████     | 5/10 [15:31<13:01, 156.29s/it, best loss: -0.642441860465]\u001b[A\n",
      "\u001b[AParameters with this testing accuracy 0.142441860465 and loss 1.81115959942 :\n",
      "\n",
      " 50%|█████     | 5/10 [15:31<13:01, 156.29s/it, best loss: -0.642441860465]\u001b[A\n",
      "\u001b[A{'kernel': 'sigmoid', 'C': 13.234833593340658, 'gamma': 9.26373368648936, 'class_weight': 'balanced'}\n",
      "\n",
      " 50%|█████     | 5/10 [15:31<13:01, 156.29s/it, best loss: -0.642441860465]\u001b[A"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Hyperopt:  60%|██████    | 6/10 [15:31<09:54, 148.62s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      " 60%|██████    | 6/10 [15:31<09:54, 148.62s/it, best loss: -0.642441860465]\u001b[A\n",
      "\u001b[AParameters with this training accuracy 0.996450467893 and loss 1.17459730045 :\n",
      "\n",
      " 60%|██████    | 6/10 [18:16<09:54, 148.62s/it, best loss: -0.642441860465]\u001b[A\n",
      "\u001b[AParameters with this testing accuracy 0.433139534884 and loss 1.62209092202 :\n",
      "\n",
      " 60%|██████    | 6/10 [18:16<09:54, 148.62s/it, best loss: -0.642441860465]\u001b[A\n",
      "\u001b[A{'kernel': 'poly', 'C': 19.387495262844645, 'gamma': 3.6859397030146135, 'class_weight': 'balanced'}\n",
      "\n",
      " 60%|██████    | 6/10 [18:16<09:54, 148.62s/it, best loss: -0.642441860465]\u001b[A"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Hyperopt:  70%|███████   | 7/10 [18:16<07:40, 153.49s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      " 70%|███████   | 7/10 [18:16<07:40, 153.49s/it, best loss: -0.642441860465]\u001b[A\n",
      "\u001b[AParameters with this training accuracy 0.169409486931 and loss 1.8734869389 :\n",
      "\n",
      " 70%|███████   | 7/10 [20:34<07:40, 153.49s/it, best loss: -0.642441860465]\u001b[A\n",
      "\u001b[AParameters with this testing accuracy 0.110465116279 and loss 1.85043818765 :\n",
      "\n",
      " 70%|███████   | 7/10 [20:34<07:40, 153.49s/it, best loss: -0.642441860465]\u001b[A\n",
      "\u001b[A{'kernel': 'sigmoid', 'C': 13.19777110134927, 'gamma': 3.1159292903418603, 'class_weight': 'balanced'}\n",
      "\n",
      " 70%|███████   | 7/10 [20:34<07:40, 153.49s/it, best loss: -0.642441860465]\u001b[A"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Hyperopt:  80%|████████  | 8/10 [20:34<04:57, 148.78s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      " 80%|████████  | 8/10 [20:34<04:57, 148.78s/it, best loss: -0.642441860465]\u001b[A\n",
      "\u001b[AParameters with this training accuracy 0.995805098419 and loss 0.196942378424 :\n",
      "\n",
      " 80%|████████  | 8/10 [22:53<04:57, 148.78s/it, best loss: -0.642441860465]\u001b[A\n",
      "\u001b[AParameters with this testing accuracy 0.651162790698 and loss 1.08150507356 :\n",
      "\n",
      " 80%|████████  | 8/10 [22:53<04:57, 148.78s/it, best loss: -0.642441860465]\u001b[A\n",
      "\u001b[A{'kernel': 'linear', 'C': 5.370547091941049, 'gamma': 8.405408815461676, 'class_weight': None}\n",
      "\n",
      " 80%|████████  | 8/10 [22:53<04:57, 148.78s/it, best loss: -0.642441860465]\u001b[A"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Hyperopt:  90%|█████████ | 9/10 [22:53<02:26, 146.04s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      " 90%|█████████ | 9/10 [22:53<02:26, 146.04s/it, best loss: -0.651162790698]\u001b[A\n",
      "\u001b[AParameters with this training accuracy 0.996450467893 and loss 2.60743022168 :\n",
      "\n",
      " 90%|█████████ | 9/10 [26:43<02:26, 146.04s/it, best loss: -0.651162790698]\u001b[A\n",
      "\u001b[AParameters with this testing accuracy 0.46511627907 and loss 1.93744329905 :\n",
      "\n",
      " 90%|█████████ | 9/10 [26:43<02:26, 146.04s/it, best loss: -0.651162790698]\u001b[A\n",
      "\u001b[A{'kernel': 'rbf', 'C': 18.48509597604255, 'gamma': 8.835841039859861, 'class_weight': 'balanced'}\n",
      "\n",
      " 90%|█████████ | 9/10 [26:43<02:26, 146.04s/it, best loss: -0.651162790698]\u001b[A"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Hyperopt: 100%|██████████| 10/10 [26:43<00:00, 171.04s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "100%|██████████| 10/10 [26:43<00:00, 171.04s/it, best loss: -0.651162790698]\u001b[A------------------------------------\n",
      "('The best hyperparameters are: ', '\\n')\n",
      "{'kernel': 0, 'C': 5.370547091941049, 'gamma': 8.405408815461676, 'class_weight': 0}\n",
      "Time elapsed to optimize 10 executions: 1603.24613714\n",
      "\n",
      " Best score:\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Parameters with this training accuracy 0.995805098419 and loss 0.197679786532 :\n",
      "Parameters with this testing accuracy 0.651162790698 and loss 1.08168052103 :\n",
      "{'kernel': 'linear', 'C': 5.370547091941049, 'gamma': 8.405408815461676, 'class_weight': None}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "{'loss': -0.6511627906976745, 'status': 'ok'}"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import time\n",
    "from tqdm import tqdm\n",
    "import numpy as np\n",
    "\n",
    "trials = Trials()\n",
    "cores = 48\n",
    "start = time.time()\n",
    "evaluations = 10\n",
    "pbar = tqdm(total=evaluations, desc=\"Hyperopt\")\n",
    "best_param = optimize(evals=evaluations,\n",
    "                      optimizer=tpe.suggest,\n",
    "                      trials=trials)\n",
    "print(\"------------------------------------\")\n",
    "print(\"The best hyperparameters are: \", \"\\n\")\n",
    "print(best_param)\n",
    "end = time.time()\n",
    "print('Time elapsed to optimize {0} executions: {1}'.format(evaluations, end - start))\n",
    "best_param['kernel'] = kernel_list[best_param['kernel']]\n",
    "best_param['class_weight'] = class_weights[best_param['class_weight']]\n",
    "print('\\n Best score:')\n",
    "score(best_param)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "# get the best params and train the model\n",
    "SVC_opt = svm.SVC(kernel=best_param['kernel'],\n",
    "            C=best_param['C'],\n",
    "            random_state=42,\n",
    "            decision_function_shape='ovr',\n",
    "            # class_weight=self.class_weight,\n",
    "            class_weight=best_param['class_weight'],\n",
    "            probability=True,\n",
    "            gamma=best_param['gamma'])\n",
    "\n",
    "\n",
    "fitted_model = SVC_opt.fit(X=X_train,y=y_train)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[13.10294832,  4.97329091,  6.0124811 , ...,  9.03743599,\n",
       "         1.91422364,  0.81735311],\n",
       "       [15.2383287 ,  1.88872993,  3.94637936, ...,  0.8466485 ,\n",
       "        -0.1922721 , 10.03442645],\n",
       "       [ 9.03301844, 11.14478948, 10.08136427, ...,  6.00466299,\n",
       "         4.92385279,  3.9106869 ],\n",
       "       ...,\n",
       "       [13.10258485,  4.99179658,  3.98069725, ...,  3.99068329,\n",
       "         9.02847324,  1.89607295],\n",
       "       [15.21807966,  0.82993604,  3.87408754, ...,  2.89571694,\n",
       "        10.05052388, -0.25438888],\n",
       "       [14.19644259,  9.02163649,  9.01059615, ...,  2.93304507,\n",
       "        -0.17412783,  4.94400294]])"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y_score = fitted_model.decision_function(X_test)\n",
    "y_score"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.6511627906976745"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "test_acc = accuracy_score(y_test, fitted_model.predict(X_test))\n",
    "test_acc"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "from matplotlib import pyplot as plt \n",
    "%matplotlib inline \n",
    "x_list =range(len(train_acc_list))\n",
    "\n",
    "plt.plot(x_list, train_acc_list, label='Training accuracy')\n",
    "plt.plot(x_list, test_acc_list, label='Testing accuracy')\n",
    "plt.legend()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot(x_list, train_loss_list, label='Training loss')\n",
    "plt.plot(x_list, test_loss_list, label='Testing loss')\n",
    "plt.legend()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 2",
   "language": "python",
   "name": "python2"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.15"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}