EVAL_PIPELINE_TOK1_TUNED.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 114,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import nltk\n",
    "from nltk.tokenize import word_tokenize\n",
    "from nltk.corpus import stopwords\n",
    "from nltk.stem import SnowballStemmer, PorterStemmer, WordNetLemmatizer\n",
    "import matplotlib.pyplot as plt\n",
    "from wordcloud import WordCloud\n",
    "from math import log, sqrt\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "import re\n",
    "from scipy.sparse import csr_matrix\n",
    "from sklearn.linear_model import LogisticRegression\n",
    "from sklearn.svm import SVC\n",
    "from sklearn.naive_bayes import MultinomialNB\n",
    "from sklearn.ensemble import RandomForestClassifier\n",
    "from sklearn.neighbors import KNeighborsClassifier\n",
    "\n",
    "from sklearn.metrics import accuracy_score,confusion_matrix,recall_score,precision_score, f1_score\n",
    "from sklearn.model_selection import cross_val_score\n",
    "\n",
    "from sklearn.feature_extraction.text import CountVectorizer\n",
    "from sklearn.feature_extraction.text import TfidfTransformer, TfidfVectorizer\n",
    "from sklearn.model_selection import GridSearchCV, KFold\n",
    "\n",
    "from imblearn.over_sampling import SMOTE, ADASYN, RandomOverSampler\n",
    "from imblearn.pipeline import make_pipeline\n",
    "from sklearn.model_selection import train_test_split\n",
    "\n",
    "from sklearn.pipeline import Pipeline\n",
    "%matplotlib inline  \n",
    "from imblearn.over_sampling import SMOTE, ADASYN, RandomOverSampler\n",
    "from sklearn.metrics import fbeta_score, make_scorer\n",
    "import xgboost\n",
    "from xgboost import XGBClassifier"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 115,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "data1 = pd.read_csv(\"spam.csv\",encoding='latin-1')\n",
    "\n",
    "\n",
    "#spajanje zadnja cetri stupca kako bi ostavili poruke u potpunosti spojenima\n",
    "data1 = data1.rename(columns={\"Unnamed: 2\":\"two\", \"Unnamed: 3\":\"tri\",\"Unnamed: 4\":\"cetr\"})\n",
    "a =  data1[data1[\"two\"].notnull()][\"v2\"].map(str) + data1[data1[\"two\"].notnull()][\"two\"].map(str)\n",
    "data1.loc[data1[\"two\"].notnull(),\"v2\"] = a\n",
    "a =  data1[data1[\"tri\"].notnull()][\"v2\"].map(str) + data1[data1[\"tri\"].notnull()][\"tri\"].map(str)\n",
    "data1.loc[data1[\"tri\"].notnull(),\"v2\"] = a\n",
    "a =  data1[data1[\"cetr\"].notnull()][\"v2\"].map(str) + data1[data1[\"cetr\"].notnull()][\"cetr\"].map(str)\n",
    "data1.loc[data1[\"cetr\"].notnull(),\"v2\"] = a\n",
    "data1 = data1[[\"v1\",\"v2\"]]\n",
    "#data1.to_csv(\"proba.csv\")\n",
    "\n",
    "\n",
    "\n",
    "data1 = data1.rename(columns={\"v1\":\"category_class\", \"v2\":\"sms\"})\n",
    "codes = {'ham':0, 'spam':1}\n",
    "data1[\"class\"] = data1[\"category_class\"].map(codes)\n",
    "maxLen = max(data1['sms'].apply(len).tolist())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 116,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "       upper_letters      length  numeric_chars  non_alpha_num\n",
      "class                                                         \n",
      "0           4.173472   71.627979       0.305285      17.500518\n",
      "1          15.483266  139.148594      15.812584      29.132530\n"
     ]
    }
   ],
   "source": [
    "# **NOVO - dodani featuri u dataframe i imas statistike prosjecne za svaki\n",
    "from nltk.corpus import words\n",
    "swords = set(words.words())\n",
    "def countUpperLetters(message):\n",
    "    return sum(1 for c in message if c.isupper())\n",
    "def countDigits(message):\n",
    "    return sum(c.isdigit() for c in message)\n",
    "def countNonAlphaNumerical(message):\n",
    "    return sum(not c.isalnum() for c in message)\n",
    "\n",
    "data1[\"upper_letters\"] = data1[\"sms\"].apply(countUpperLetters)\n",
    "data1['length'] = data1['sms'].apply(len)\n",
    "data1[\"numeric_chars\"] = data1[\"sms\"].apply(countDigits)\n",
    "data1[\"non_alpha_num\"] = data1[\"sms\"].apply(countNonAlphaNumerical)\n",
    "print(data1.groupby(\"class\").mean())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 117,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def process_message(message, lower_case = True, stem = True, stop_words = True):\n",
    "    if lower_case:\n",
    "        message = message.lower()\n",
    "    words = word_tokenize(message)\n",
    "    words = [w for w in words if len(w) > 2]\n",
    "    if stop_words:\n",
    "        sw = stopwords.words('english')\n",
    "        words = [word for word in words if word not in sw]\n",
    "    if stem:\n",
    "        stemmer = SnowballStemmer('english')\n",
    "        words = [stemmer.stem(word) for word in words]   \n",
    "    return \" \".join(words)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 118,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "data1['sms'] = data1['sms'].apply(process_message)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 119,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "train,test = train_test_split(data1,test_size=0.25,random_state=28)\n",
    "features_train = train[\"sms\"]\n",
    "features_test = test[\"sms\"]\n",
    "labels_train = train[\"class\"]\n",
    "labels_test = test[\"class\"]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 120,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def dodajFeatureVratiArray(current_array,pandas_column):\n",
    "    return np.hstack((current_array,pandas_column.values.reshape(-1,1)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 121,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def outSystem(count_vect = CountVectorizer()):\n",
    "    count_vect.fit(train['sms'])\n",
    "    count_vectorizer_train = count_vect.transform(train['sms']).todense()\n",
    "    count_vectorizer_test = count_vect.transform(test['sms']).todense()\n",
    "        \n",
    "    train_X = dodajFeatureVratiArray(count_vectorizer_train,train[\"numeric_chars\"])\n",
    "    train_X = dodajFeatureVratiArray(train_X,train[\"length\"])\n",
    "    train_X = dodajFeatureVratiArray(train_X,train[\"non_alpha_num\"])\n",
    "    train_X = dodajFeatureVratiArray(train_X,train[\"upper_letters\"])\n",
    "    \n",
    "    test_X = dodajFeatureVratiArray(count_vectorizer_test,test[\"numeric_chars\"])\n",
    "    test_X = dodajFeatureVratiArray(test_X,test[\"length\"])\n",
    "    test_X = dodajFeatureVratiArray(test_X,test[\"non_alpha_num\"])\n",
    "    test_X = dodajFeatureVratiArray(test_X,test[\"upper_letters\"])\n",
    "    \n",
    "    return(csr_matrix(train_X), csr_matrix(test_X))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 122,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "train_data, test_data = outSystem()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 132,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "ftwo_scorer = make_scorer(fbeta_score, beta=0.5)\n",
    "\n",
    "def crosValBestModel(clf, d_train, d_test, parameters):\n",
    "    grid_search = GridSearchCV(clf, parameters, cv = 10, scoring=ftwo_scorer, n_jobs=2, verbose=10)\n",
    "    grid_search.fit(d_train, labels_train)                \n",
    "    best = grid_search.best_estimator_\n",
    "    preds = best.predict(d_test)\n",
    "   \n",
    "    print(\"Best: %f using %s\" % (grid_search.best_score_, grid_search.best_params_))\n",
    "    means = grid_search.cv_results_['mean_test_score']\n",
    "    stds = grid_search.cv_results_['std_test_score']\n",
    "    params = grid_search.cv_results_['params']\n",
    "    for mean, stdev, param in zip(means, stds, params):\n",
    "        print(\"%f (%f) with: %r\" % (mean, stdev, param))\n",
    "    \n",
    "    print(\"Accuracy :\",accuracy_score(labels_test,preds))\n",
    "    print(\"Recall :\",recall_score(labels_test,preds))\n",
    "    print(\"Presicion :\",precision_score(labels_test,preds))\n",
    "    print(\"F0.5 score :\",fbeta_score(labels_test,preds, beta=0.5))\n",
    "    print(\"CONFUSION MATRIX\",confusion_matrix(labels_test,preds))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 140,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "============================================================\n",
      "___________ MNB______________________\n",
      "Accuracy : 0.976310122039\n",
      "Recall : 0.945355191257\n",
      "Presicion : 0.882653061224\n",
      "F0.5 score : 0.894519131334\n",
      "CONFUSION MATRIX [[1187   23]\n",
      " [  10  173]]\n",
      "============================================================\n",
      "============================================================\n",
      "___________ Logistic______________________\n",
      "Accuracy : 0.991385498923\n",
      "Recall : 0.956284153005\n",
      "Presicion : 0.977653631285\n",
      "F0.5 score : 0.973303670745\n",
      "CONFUSION MATRIX [[1206    4]\n",
      " [   8  175]]\n",
      "============================================================\n",
      "============================================================\n",
      "___________ SVC______________________\n",
      "Accuracy : 0.989231873654\n",
      "Recall : 0.96174863388\n",
      "Presicion : 0.95652173913\n",
      "F0.5 score : 0.957562568009\n",
      "CONFUSION MATRIX [[1202    8]\n",
      " [   7  176]]\n",
      "============================================================\n",
      "============================================================\n",
      "___________ KNN______________________\n",
      "Accuracy : 0.982770997846\n",
      "Recall : 0.907103825137\n",
      "Presicion : 0.959537572254\n",
      "F0.5 score : 0.948571428571\n",
      "CONFUSION MATRIX [[1203    7]\n",
      " [  17  166]]\n",
      "============================================================\n",
      "============================================================\n",
      "___________ RandomForrest______________________\n",
      "Accuracy : 0.992103374013\n",
      "Recall : 0.939890710383\n",
      "Presicion : 1.0\n",
      "F0.5 score : 0.987370838117\n",
      "CONFUSION MATRIX [[1210    0]\n",
      " [  11  172]]\n",
      "============================================================\n"
     ]
    }
   ],
   "source": [
    "clfs = [('MNB',MultinomialNB()), \n",
    "        ('Logistic',LogisticRegression()), \n",
    "        ('SVC',SVC(kernel='linear')), \n",
    "        ('KNN',KNeighborsClassifier()),\n",
    "        ('RandomForrest',RandomForestClassifier(n_estimators=250, max_depth=300,random_state=7))]\n",
    "        #('RandomForrest',RandomForestClassifier(random_state=7))]\n",
    "for name, clf in clfs:\n",
    "    clf.fit(train_data, labels_train)\n",
    "    preds = clf.predict(test_data)\n",
    "    \n",
    "    print('============================================================')\n",
    "    print('___________ '+name+'______________________')\n",
    "    print(\"Accuracy :\",accuracy_score(labels_test,preds))\n",
    "    print(\"Recall :\",recall_score(labels_test,preds))\n",
    "    print(\"Presicion :\",precision_score(labels_test,preds))\n",
    "    print(\"F0.5 score :\",fbeta_score(labels_test,preds, beta=0.5))\n",
    "    print(\"CONFUSION MATRIX\",confusion_matrix(labels_test,preds))\n",
    "    print('============================================================')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "clf = XGBClassifier()\n",
    "\n",
    "parameters = {\n",
    "    'learning_rate': [0.01,0.01,0.1,1,10],\n",
    "    'max_depth' : [1,3,5,7],\n",
    "    'n_estimators' : [100,300,500,700]\n",
    "    'reg_lambda' : [0.01,0.01,0.1,1,10]\n",
    "}\n",
    "\n",
    "crosValBestModel(clf, train_data, test_data, parameters)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 134,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Fitting 10 folds for each of 10 candidates, totalling 100 fits\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "[Parallel(n_jobs=2)]: Done   1 tasks      | elapsed:    1.3s\n",
      "[Parallel(n_jobs=2)]: Done   4 tasks      | elapsed:    2.3s\n",
      "[Parallel(n_jobs=2)]: Done   9 tasks      | elapsed:    2.4s\n",
      "[Parallel(n_jobs=2)]: Done  14 tasks      | elapsed:    2.5s\n",
      "[Parallel(n_jobs=2)]: Batch computation too fast (0.1880s.) Setting batch_size=2.\n",
      "[Parallel(n_jobs=2)]: Done  21 tasks      | elapsed:    2.7s\n",
      "[Parallel(n_jobs=2)]: Batch computation too fast (0.1556s.) Setting batch_size=4.\n",
      "[Parallel(n_jobs=2)]: Done  41 tasks      | elapsed:    3.3s\n",
      "[Parallel(n_jobs=2)]: Done  77 tasks      | elapsed:    4.2s\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Best: 0.967815 using {'C': 7.8000000000000007}\n",
      "0.962743 (0.009514) with: {'C': 0.10000000000000001}\n",
      "0.967029 (0.010286) with: {'C': 1.2000000000000002}\n",
      "0.967499 (0.009512) with: {'C': 2.3000000000000003}\n",
      "0.967499 (0.009512) with: {'C': 3.4000000000000004}\n",
      "0.966034 (0.012301) with: {'C': 4.5}\n",
      "0.966938 (0.011584) with: {'C': 5.5999999999999996}\n",
      "0.967396 (0.010702) with: {'C': 6.7000000000000002}\n",
      "0.967815 (0.011128) with: {'C': 7.8000000000000007}\n",
      "0.967815 (0.011128) with: {'C': 8.9000000000000004}\n",
      "0.967815 (0.011128) with: {'C': 10.0}\n",
      "Accuracy : 0.991385498923\n",
      "Recall : 0.956284153005\n",
      "Presicion : 0.977653631285\n",
      "F0.5 score : 0.973303670745\n",
      "CONFUSION MATRIX [[1206    4]\n",
      " [   8  175]]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "[Parallel(n_jobs=2)]: Done 100 out of 100 | elapsed:    4.8s finished\n"
     ]
    }
   ],
   "source": [
    "clf = LogisticRegression()\n",
    "parameters = {\n",
    "    'C': np.linspace(0.1, 10, num=10)\n",
    "}\n",
    "crosValBestModel(clf, train_data, test_data, parameters)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 135,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Fitting 10 folds for each of 10 candidates, totalling 100 fits\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "[Parallel(n_jobs=2)]: Done   1 tasks      | elapsed:    2.9s\n",
      "[Parallel(n_jobs=2)]: Done   4 tasks      | elapsed:    6.1s\n",
      "[Parallel(n_jobs=2)]: Done   9 tasks      | elapsed:   10.2s\n",
      "[Parallel(n_jobs=2)]: Done  14 tasks      | elapsed:   15.3s\n",
      "[Parallel(n_jobs=2)]: Done  21 tasks      | elapsed:   22.0s\n",
      "[Parallel(n_jobs=2)]: Done  28 tasks      | elapsed:   29.7s\n",
      "[Parallel(n_jobs=2)]: Done  37 tasks      | elapsed:   40.3s\n",
      "[Parallel(n_jobs=2)]: Done  46 tasks      | elapsed:   52.1s\n",
      "[Parallel(n_jobs=2)]: Done  57 tasks      | elapsed:  1.1min\n",
      "[Parallel(n_jobs=2)]: Done  68 tasks      | elapsed:  1.3min\n",
      "[Parallel(n_jobs=2)]: Done  81 tasks      | elapsed:  1.6min\n",
      "[Parallel(n_jobs=2)]: Done  94 tasks      | elapsed:  1.8min\n",
      "[Parallel(n_jobs=2)]: Done 100 out of 100 | elapsed:  1.9min finished\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Best: 0.970287 using {'C': 0.10000000000000001}\n",
      "0.970287 (0.009607) with: {'C': 0.10000000000000001}\n",
      "0.963512 (0.016889) with: {'C': 1.2000000000000002}\n",
      "0.963512 (0.016889) with: {'C': 2.3000000000000003}\n",
      "0.963512 (0.016889) with: {'C': 3.4000000000000004}\n",
      "0.963512 (0.016889) with: {'C': 4.5}\n",
      "0.963512 (0.016889) with: {'C': 5.5999999999999996}\n",
      "0.963512 (0.016889) with: {'C': 6.7000000000000002}\n",
      "0.963512 (0.016889) with: {'C': 7.8000000000000007}\n",
      "0.963512 (0.016889) with: {'C': 8.9000000000000004}\n",
      "0.963512 (0.016889) with: {'C': 10.0}\n",
      "Accuracy : 0.989231873654\n",
      "Recall : 0.945355191257\n",
      "Presicion : 0.97191011236\n",
      "F0.5 score : 0.966480446927\n",
      "CONFUSION MATRIX [[1205    5]\n",
      " [  10  173]]\n"
     ]
    }
   ],
   "source": [
    "clf = SVC(kernel='linear')\n",
    "parameters = {\n",
    "    'C': np.linspace(0.1, 10, num=10)\n",
    "}\n",
    "crosValBestModel(clf, train_data, test_data, parameters)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 136,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Fitting 10 folds for each of 4 candidates, totalling 40 fits\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "[Parallel(n_jobs=2)]: Done   1 tasks      | elapsed:    1.8s\n",
      "[Parallel(n_jobs=2)]: Done   4 tasks      | elapsed:    3.6s\n",
      "[Parallel(n_jobs=2)]: Done   9 tasks      | elapsed:    5.0s\n",
      "[Parallel(n_jobs=2)]: Done  14 tasks      | elapsed:    7.0s\n",
      "[Parallel(n_jobs=2)]: Done  21 tasks      | elapsed:    9.3s\n",
      "[Parallel(n_jobs=2)]: Done  28 tasks      | elapsed:   12.2s\n",
      "[Parallel(n_jobs=2)]: Done  37 tasks      | elapsed:   15.4s\n",
      "[Parallel(n_jobs=2)]: Done  40 out of  40 | elapsed:   16.7s finished\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Best: 0.948069 using {'n_neighbors': 4}\n",
      "0.941859 (0.013919) with: {'n_neighbors': 2}\n",
      "0.934774 (0.021533) with: {'n_neighbors': 3}\n",
      "0.948069 (0.014542) with: {'n_neighbors': 4}\n",
      "0.930989 (0.017998) with: {'n_neighbors': 5}\n",
      "Accuracy : 0.984924623116\n",
      "Recall : 0.896174863388\n",
      "Presicion : 0.987951807229\n",
      "F0.5 score : 0.968122786305\n",
      "CONFUSION MATRIX [[1208    2]\n",
      " [  19  164]]\n"
     ]
    }
   ],
   "source": [
    "clf = KNeighborsClassifier()\n",
    "parameters = {\n",
    "    'n_neighbors': [2,3,4,5]\n",
    "}\n",
    "\n",
    "crosValBestModel(clf, train_data, test_data, parameters)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 137,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Fitting 10 folds for each of 18 candidates, totalling 180 fits\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "[Parallel(n_jobs=2)]: Done   1 tasks      | elapsed:    7.0s\n",
      "[Parallel(n_jobs=2)]: Done   4 tasks      | elapsed:   13.6s\n",
      "[Parallel(n_jobs=2)]: Done   9 tasks      | elapsed:   28.7s\n",
      "[Parallel(n_jobs=2)]: Done  14 tasks      | elapsed:   43.5s\n",
      "[Parallel(n_jobs=2)]: Done  21 tasks      | elapsed:  1.2min\n",
      "[Parallel(n_jobs=2)]: Done  28 tasks      | elapsed:  1.6min\n",
      "[Parallel(n_jobs=2)]: Done  37 tasks      | elapsed:  2.1min\n",
      "[Parallel(n_jobs=2)]: Done  46 tasks      | elapsed:  2.6min\n",
      "[Parallel(n_jobs=2)]: Done  57 tasks      | elapsed:  3.4min\n",
      "[Parallel(n_jobs=2)]: Done  68 tasks      | elapsed:  4.0min\n",
      "[Parallel(n_jobs=2)]: Done  81 tasks      | elapsed:  4.8min\n",
      "[Parallel(n_jobs=2)]: Done  94 tasks      | elapsed:  5.6min\n",
      "[Parallel(n_jobs=2)]: Done 109 tasks      | elapsed:  6.4min\n",
      "[Parallel(n_jobs=2)]: Done 124 tasks      | elapsed:  7.4min\n",
      "[Parallel(n_jobs=2)]: Done 141 tasks      | elapsed:  8.4min\n",
      "[Parallel(n_jobs=2)]: Done 158 tasks      | elapsed:  9.4min\n",
      "[Parallel(n_jobs=2)]: Done 177 tasks      | elapsed: 10.6min\n",
      "[Parallel(n_jobs=2)]: Done 180 out of 180 | elapsed: 10.8min finished\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Best: 0.975898 using {'max_depth': 250, 'max_features': 'auto', 'n_estimators': 200}\n",
      "0.973972 (0.009096) with: {'max_depth': 200, 'max_features': 'auto', 'n_estimators': 200}\n",
      "0.974258 (0.010737) with: {'max_depth': 200, 'max_features': 'auto', 'n_estimators': 250}\n",
      "0.973219 (0.011252) with: {'max_depth': 200, 'max_features': 'auto', 'n_estimators': 300}\n",
      "0.974764 (0.009692) with: {'max_depth': 200, 'max_features': 'sqrt', 'n_estimators': 200}\n",
      "0.973807 (0.011339) with: {'max_depth': 200, 'max_features': 'sqrt', 'n_estimators': 250}\n",
      "0.973171 (0.010651) with: {'max_depth': 200, 'max_features': 'sqrt', 'n_estimators': 300}\n",
      "0.975898 (0.008246) with: {'max_depth': 250, 'max_features': 'auto', 'n_estimators': 200}\n",
      "0.974377 (0.009896) with: {'max_depth': 250, 'max_features': 'auto', 'n_estimators': 250}\n",
      "0.975782 (0.010656) with: {'max_depth': 250, 'max_features': 'auto', 'n_estimators': 300}\n",
      "0.973812 (0.011562) with: {'max_depth': 250, 'max_features': 'sqrt', 'n_estimators': 200}\n",
      "0.974821 (0.009603) with: {'max_depth': 250, 'max_features': 'sqrt', 'n_estimators': 250}\n",
      "0.974308 (0.010685) with: {'max_depth': 250, 'max_features': 'sqrt', 'n_estimators': 300}\n",
      "0.975182 (0.010110) with: {'max_depth': 300, 'max_features': 'auto', 'n_estimators': 200}\n",
      "0.973428 (0.011126) with: {'max_depth': 300, 'max_features': 'auto', 'n_estimators': 250}\n",
      "0.974239 (0.011718) with: {'max_depth': 300, 'max_features': 'auto', 'n_estimators': 300}\n",
      "0.975392 (0.010251) with: {'max_depth': 300, 'max_features': 'sqrt', 'n_estimators': 200}\n",
      "0.975616 (0.010405) with: {'max_depth': 300, 'max_features': 'sqrt', 'n_estimators': 250}\n",
      "0.974223 (0.011771) with: {'max_depth': 300, 'max_features': 'sqrt', 'n_estimators': 300}\n",
      "Accuracy : 0.991385498923\n",
      "Recall : 0.934426229508\n",
      "Presicion : 1.0\n",
      "F0.5 score : 0.98615916955\n",
      "CONFUSION MATRIX [[1210    0]\n",
      " [  12  171]]\n"
     ]
    }
   ],
   "source": [
    "clf = RandomForestClassifier(random_state=7)\n",
    "\n",
    "#max_depth': 250, 'max_features': 'auto', 'n_estimators': 200\n",
    "\n",
    "parameters = {\n",
    "    'n_estimators': [200, 250, 300],\n",
    "    'max_depth': [200, 250, 300],\n",
    "    'max_features': ['auto', 'sqrt']\n",
    "}\n",
    "\n",
    "#n_estimators = [200, 250, 300]\n",
    "#max_depth =  [200, 250, 300]\n",
    "#max_features = ['auto', 'sqrt']\n",
    "#parameters = dict(n_estimators=n_estimators,max_depth=max_depth, max_features = max_features )\n",
    "\n",
    "crosValBestModel(clf,train_data, test_data, parameters)"
   ]
  }
 ],
 "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.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}