Grid_SearchCV.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "   radius_mean  texture_mean  perimeter_mean  smoothness_mean  area_mean  \\\n",
      "0     2.327415     -2.569512        1.486073         0.159885  -0.435486   \n",
      "1     2.980117     -1.146063       -0.663482        -0.220002   0.243566   \n",
      "2     2.988588     -0.332936       -0.294597         0.230955  -0.013079   \n",
      "3    -1.135178      0.474079        0.131484         0.323124  -0.221959   \n",
      "4     2.968990     -1.890360       -0.142690        -0.293323   0.052689   \n",
      "\n",
      "   concavity_mean  compactness_mean  texture_se   area_se  \\\n",
      "0        0.034616          0.002777    0.003918  0.020190   \n",
      "1       -0.035380          0.003260    0.016865  0.009204   \n",
      "2        0.018910          0.016429    0.015743 -0.001196   \n",
      "3        0.221830         -0.004916    0.056660  0.014218   \n",
      "4        0.051094          0.004643   -0.026062 -0.010812   \n",
      "\n",
      "   fractal_dimension_mean  \n",
      "0                0.000661  \n",
      "1                0.005190  \n",
      "2               -0.002060  \n",
      "3                0.004241  \n",
      "4                0.001895  \n"
     ]
    }
   ],
   "source": [
    "import pandas as pd\n",
    "from sklearn.preprocessing import OneHotEncoder\n",
    "from sklearn.compose import ColumnTransformer\n",
    "from sklearn.pipeline import Pipeline\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.metrics import accuracy_score, classification_report\n",
    "from sklearn.metrics import confusion_matrix\n",
    "from imblearn.over_sampling import SMOTE\n",
    "from sklearn.model_selection import GridSearchCV\n",
    "\n",
    "\n",
    "from sklearn.linear_model import LogisticRegression\n",
    "from sklearn.tree import DecisionTreeClassifier\n",
    "from sklearn.ensemble import RandomForestClassifier\n",
    "\n",
    "df = pd.read_csv('data.csv')\n",
    "list = ['Unnamed: 32','id']\n",
    "df.drop(list,axis = 1, inplace = True)\n",
    "\n",
    "#Encoding categorical data values\n",
    "from sklearn.preprocessing import LabelEncoder\n",
    "labelencoder = LabelEncoder()\n",
    "df['diagnosis'] = labelencoder.fit_transform(df['diagnosis'])\n",
    "\n",
    "from sklearn.preprocessing import StandardScaler\n",
    "ss = StandardScaler()\n",
    "df['radius_mean'] = ss.fit_transform(df['radius_mean'].values.reshape(-1,1))\n",
    "df['texture_mean'] = ss.fit_transform(df['texture_mean'].values.reshape(-1,1))\n",
    "df['perimeter_mean'] = ss.fit_transform(df['perimeter_mean'].values.reshape(-1,1))\n",
    "df['area_mean'] = ss.fit_transform(df['area_mean'].values.reshape(-1,1))\n",
    "df['perimeter_se'] = ss.fit_transform(df['perimeter_se'].values.reshape(-1,1))\n",
    "df['area_se'] = ss.fit_transform(df['area_se'].values.reshape(-1,1))\n",
    "df['radius_worst'] = ss.fit_transform(df['radius_worst'].values.reshape(-1,1))\n",
    "df['texture_worst'] = ss.fit_transform(df['texture_worst'].values.reshape(-1,1))\n",
    "df['perimeter_worst'] = ss.fit_transform(df['perimeter_worst'].values.reshape(-1,1))\n",
    "df['area_worst'] = ss.fit_transform(df['area_worst'].values.reshape(-1,1))\n",
    "\n",
    "df_1 = pd.DataFrame(df['diagnosis'])\n",
    "df.drop(['diagnosis'], axis =1, inplace = True)\n",
    "df_2 = pd.DataFrame(df[['radius_mean', 'texture_mean', 'perimeter_mean', \n",
    "                        'smoothness_mean', 'area_mean', 'concavity_mean', 'compactness_mean', \n",
    "                        'texture_se', 'area_se', 'fractal_dimension_mean']])\n",
    "\n",
    "\n",
    "from sklearn.decomposition import PCA\n",
    "pca = PCA()\n",
    "df_pca = pd.DataFrame(pca.fit_transform(df_2), columns=df_2.columns)\n",
    "print(df_pca.head())\n",
    "\n",
    "\n",
    "X = df_pca.values\n",
    "Y = df_1['diagnosis'].values\n",
    "\n",
    "from sklearn.model_selection import train_test_split\n",
    "X_train, X_test, Y_train, Y_test = train_test_split(X, Y, test_size = 0.20, \n",
    "                                                    stratify = Y)\n",
    "\n",
    "\n",
    "sm = SMOTE(random_state=42, kind = 'borderline1')\n",
    "\n",
    "X_resampled, Y_resampled = sm.fit_resample(X_train, Y_train)\n",
    "\n",
    "# Logistic Regression\n",
    "lr_model = Pipeline([(\"model\", LogisticRegression(class_weight=\"balanced\", solver=\"liblinear\", random_state=42))])\n",
    "\n",
    "# Decision Tree\n",
    "dt_model = Pipeline([(\"model\", DecisionTreeClassifier(class_weight=\"balanced\"))])\n",
    "\n",
    "# Random Forest\n",
    "rf_model = Pipeline([(\"model\", RandomForestClassifier(class_weight=\"balanced\", n_estimators=100, n_jobs=-1))])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Logistic Regression"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "GridSearchCV(cv=5, error_score='raise-deprecating',\n",
       "       estimator=Pipeline(memory=None,\n",
       "     steps=[('model', LogisticRegression(C=1.0, class_weight='balanced', dual=False,\n",
       "          fit_intercept=True, intercept_scaling=1, max_iter=100,\n",
       "          multi_class='warn', n_jobs=None, penalty='l2', random_state=42,\n",
       "          solver='liblinear', tol=0.0001, verbose=0, warm_start=False))]),\n",
       "       fit_params=None, iid='warn', n_jobs=-1,\n",
       "       param_grid={'model__C': [1, 1.3, 1.5]}, pre_dispatch='2*n_jobs',\n",
       "       refit=True, return_train_score='warn', scoring='f1', verbose=0)"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "gs = GridSearchCV(lr_model, {\"model__C\": [1, 1.3, 1.5]}, n_jobs=-1, cv=5, scoring=\"f1\")\n",
    "gs.fit(X_resampled, Y_resampled)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'model__C': 1.3}\n",
      "0.8827214864109764\n"
     ]
    }
   ],
   "source": [
    "print(gs.best_params_)\n",
    "print(gs.best_score_)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Pipeline(memory=None,\n",
       "     steps=[('model', LogisticRegression(C=1.3, class_weight='balanced', dual=False,\n",
       "          fit_intercept=True, intercept_scaling=1, max_iter=100,\n",
       "          multi_class='warn', n_jobs=None, penalty='l2', random_state=42,\n",
       "          solver='liblinear', tol=0.0001, verbose=0, warm_start=False))])"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "lr_model.set_params(**gs.best_params_)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'memory': None,\n",
       " 'steps': [('model',\n",
       "   LogisticRegression(C=1.3, class_weight='balanced', dual=False,\n",
       "             fit_intercept=True, intercept_scaling=1, max_iter=100,\n",
       "             multi_class='warn', n_jobs=None, penalty='l2', random_state=42,\n",
       "             solver='liblinear', tol=0.0001, verbose=0, warm_start=False))],\n",
       " 'model': LogisticRegression(C=1.3, class_weight='balanced', dual=False,\n",
       "           fit_intercept=True, intercept_scaling=1, max_iter=100,\n",
       "           multi_class='warn', n_jobs=None, penalty='l2', random_state=42,\n",
       "           solver='liblinear', tol=0.0001, verbose=0, warm_start=False),\n",
       " 'model__C': 1.3,\n",
       " 'model__class_weight': 'balanced',\n",
       " 'model__dual': False,\n",
       " 'model__fit_intercept': True,\n",
       " 'model__intercept_scaling': 1,\n",
       " 'model__max_iter': 100,\n",
       " 'model__multi_class': 'warn',\n",
       " 'model__n_jobs': None,\n",
       " 'model__penalty': 'l2',\n",
       " 'model__random_state': 42,\n",
       " 'model__solver': 'liblinear',\n",
       " 'model__tol': 0.0001,\n",
       " 'model__verbose': 0,\n",
       " 'model__warm_start': False}"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "lr_model.get_params(\"model\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.9122807017543859"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "lr_model.fit(X_resampled, Y_resampled)\n",
    "y_pred = lr_model.predict(X_test)\n",
    "accuracy_score(Y_test, y_pred)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "              precision    recall  f1-score   support\n",
      "\n",
      "           0       0.94      0.92      0.93        72\n",
      "           1       0.86      0.90      0.88        42\n",
      "\n",
      "   micro avg       0.91      0.91      0.91       114\n",
      "   macro avg       0.90      0.91      0.91       114\n",
      "weighted avg       0.91      0.91      0.91       114\n",
      "\n"
     ]
    }
   ],
   "source": [
    "print(classification_report(Y_test, y_pred))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[66  6]\n",
      " [ 4 38]]\n"
     ]
    }
   ],
   "source": [
    "print(confusion_matrix(Y_test, y_pred))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.9122807017543859"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "lr_model.score(X_test, Y_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.9052631578947369"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "lr_model.score(X_resampled, Y_resampled)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Decision Tree"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "GridSearchCV(cv=5, error_score='raise-deprecating',\n",
       "       estimator=Pipeline(memory=None,\n",
       "     steps=[('model', DecisionTreeClassifier(class_weight='balanced', criterion='gini',\n",
       "            max_depth=None, max_features=None, max_leaf_nodes=None,\n",
       "            min_impurity_decrease=0.0, min_impurity_split=None,\n",
       "            min_samples_leaf=1, min_samples_split=2,\n",
       "            min_weight_fraction_leaf=0.0, presort=False, random_state=None,\n",
       "            splitter='best'))]),\n",
       "       fit_params=None, iid='warn', n_jobs=-1,\n",
       "       param_grid={'model__max_depth': [3, 5, 7], 'model__min_samples_split': [2, 5]},\n",
       "       pre_dispatch='2*n_jobs', refit=True, return_train_score='warn',\n",
       "       scoring='f1', verbose=0)"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "gs = GridSearchCV(dt_model, {\"model__max_depth\": [3, 5, 7], \n",
    "                             \"model__min_samples_split\": [2, 5]}, \n",
    "                  n_jobs=-1, cv=5, scoring=\"f1\")\n",
    "\n",
    "gs.fit(X_resampled, Y_resampled)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'model__max_depth': 7, 'model__min_samples_split': 2}\n",
      "0.9233468286099866\n"
     ]
    }
   ],
   "source": [
    "print(gs.best_params_)\n",
    "print(gs.best_score_)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Pipeline(memory=None,\n",
       "     steps=[('model', DecisionTreeClassifier(class_weight='balanced', criterion='gini', max_depth=7,\n",
       "            max_features=None, max_leaf_nodes=None,\n",
       "            min_impurity_decrease=0.0, min_impurity_split=None,\n",
       "            min_samples_leaf=1, min_samples_split=2,\n",
       "            min_weight_fraction_leaf=0.0, presort=False, random_state=None,\n",
       "            splitter='best'))])"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dt_model.set_params(**gs.best_params_)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'memory': None,\n",
       " 'steps': [('model',\n",
       "   DecisionTreeClassifier(class_weight='balanced', criterion='gini', max_depth=7,\n",
       "               max_features=None, max_leaf_nodes=None,\n",
       "               min_impurity_decrease=0.0, min_impurity_split=None,\n",
       "               min_samples_leaf=1, min_samples_split=2,\n",
       "               min_weight_fraction_leaf=0.0, presort=False, random_state=None,\n",
       "               splitter='best'))],\n",
       " 'model': DecisionTreeClassifier(class_weight='balanced', criterion='gini', max_depth=7,\n",
       "             max_features=None, max_leaf_nodes=None,\n",
       "             min_impurity_decrease=0.0, min_impurity_split=None,\n",
       "             min_samples_leaf=1, min_samples_split=2,\n",
       "             min_weight_fraction_leaf=0.0, presort=False, random_state=None,\n",
       "             splitter='best'),\n",
       " 'model__class_weight': 'balanced',\n",
       " 'model__criterion': 'gini',\n",
       " 'model__max_depth': 7,\n",
       " 'model__max_features': None,\n",
       " 'model__max_leaf_nodes': None,\n",
       " 'model__min_impurity_decrease': 0.0,\n",
       " 'model__min_impurity_split': None,\n",
       " 'model__min_samples_leaf': 1,\n",
       " 'model__min_samples_split': 2,\n",
       " 'model__min_weight_fraction_leaf': 0.0,\n",
       " 'model__presort': False,\n",
       " 'model__random_state': None,\n",
       " 'model__splitter': 'best'}"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dt_model.get_params(\"model\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.9298245614035088"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dt_model.fit(X_resampled, Y_resampled)\n",
    "y_pred = dt_model.predict(X_test)\n",
    "\n",
    "accuracy_score(Y_test, y_pred)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "              precision    recall  f1-score   support\n",
      "\n",
      "           0       0.94      0.94      0.94        72\n",
      "           1       0.90      0.90      0.90        42\n",
      "\n",
      "   micro avg       0.93      0.93      0.93       114\n",
      "   macro avg       0.92      0.92      0.92       114\n",
      "weighted avg       0.93      0.93      0.93       114\n",
      "\n"
     ]
    }
   ],
   "source": [
    "print(classification_report(Y_test, y_pred))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[68  4]\n",
      " [ 4 38]]\n"
     ]
    }
   ],
   "source": [
    "print(confusion_matrix(Y_test, y_pred))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.9298245614035088"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dt_model.score(X_test, Y_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.9982456140350877"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dt_model.score(X_resampled, Y_resampled)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Random Forest"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "GridSearchCV(cv=5, error_score='raise-deprecating',\n",
       "       estimator=Pipeline(memory=None,\n",
       "     steps=[('model', RandomForestClassifier(bootstrap=True, class_weight='balanced',\n",
       "            criterion='gini', max_depth=None, max_features='auto',\n",
       "            max_leaf_nodes=None, min_impurity_decrease=0.0,\n",
       "            min_impurity_split=None, min_samples_leaf=1,\n",
       "            min_samples_split=2, min_weight_fraction_leaf=0.0,\n",
       "            n_estimators=100, n_jobs=-1, oob_score=False,\n",
       "            random_state=None, verbose=0, warm_start=False))]),\n",
       "       fit_params=None, iid='warn', n_jobs=-1,\n",
       "       param_grid={'model__max_depth': [10, 15], 'model__min_samples_split': [5, 10]},\n",
       "       pre_dispatch='2*n_jobs', refit=True, return_train_score='warn',\n",
       "       scoring='f1', verbose=0)"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "gs = GridSearchCV(rf_model, {\"model__max_depth\": [10, 15], \n",
    "                             \"model__min_samples_split\": [5, 10]}, \n",
    "                  n_jobs=-1, cv=5, scoring=\"f1\")\n",
    "\n",
    "gs.fit(X_resampled, Y_resampled)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'model__max_depth': 10, 'model__min_samples_split': 5}\n",
      "0.9474974092500822\n"
     ]
    }
   ],
   "source": [
    "print(gs.best_params_)\n",
    "print(gs.best_score_)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Pipeline(memory=None,\n",
       "     steps=[('model', RandomForestClassifier(bootstrap=True, class_weight='balanced',\n",
       "            criterion='gini', max_depth=10, max_features='auto',\n",
       "            max_leaf_nodes=None, min_impurity_decrease=0.0,\n",
       "            min_impurity_split=None, min_samples_leaf=1,\n",
       "            min_samples_split=5, min_weight_fraction_leaf=0.0,\n",
       "            n_estimators=100, n_jobs=-1, oob_score=False,\n",
       "            random_state=None, verbose=0, warm_start=False))])"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "rf_model.set_params(**gs.best_params_)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'memory': None,\n",
       " 'steps': [('model',\n",
       "   RandomForestClassifier(bootstrap=True, class_weight='balanced',\n",
       "               criterion='gini', max_depth=10, max_features='auto',\n",
       "               max_leaf_nodes=None, min_impurity_decrease=0.0,\n",
       "               min_impurity_split=None, min_samples_leaf=1,\n",
       "               min_samples_split=5, min_weight_fraction_leaf=0.0,\n",
       "               n_estimators=100, n_jobs=-1, oob_score=False,\n",
       "               random_state=None, verbose=0, warm_start=False))],\n",
       " 'model': RandomForestClassifier(bootstrap=True, class_weight='balanced',\n",
       "             criterion='gini', max_depth=10, max_features='auto',\n",
       "             max_leaf_nodes=None, min_impurity_decrease=0.0,\n",
       "             min_impurity_split=None, min_samples_leaf=1,\n",
       "             min_samples_split=5, min_weight_fraction_leaf=0.0,\n",
       "             n_estimators=100, n_jobs=-1, oob_score=False,\n",
       "             random_state=None, verbose=0, warm_start=False),\n",
       " 'model__bootstrap': True,\n",
       " 'model__class_weight': 'balanced',\n",
       " 'model__criterion': 'gini',\n",
       " 'model__max_depth': 10,\n",
       " 'model__max_features': 'auto',\n",
       " 'model__max_leaf_nodes': None,\n",
       " 'model__min_impurity_decrease': 0.0,\n",
       " 'model__min_impurity_split': None,\n",
       " 'model__min_samples_leaf': 1,\n",
       " 'model__min_samples_split': 5,\n",
       " 'model__min_weight_fraction_leaf': 0.0,\n",
       " 'model__n_estimators': 100,\n",
       " 'model__n_jobs': -1,\n",
       " 'model__oob_score': False,\n",
       " 'model__random_state': None,\n",
       " 'model__verbose': 0,\n",
       " 'model__warm_start': False}"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "rf_model.get_params(\"model\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.956140350877193"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "rf_model.fit(X_resampled, Y_resampled)\n",
    "y_pred = rf_model.predict(X_test)\n",
    "accuracy_score(Y_test, y_pred)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "              precision    recall  f1-score   support\n",
      "\n",
      "           0       0.99      0.94      0.96        72\n",
      "           1       0.91      0.98      0.94        42\n",
      "\n",
      "   micro avg       0.96      0.96      0.96       114\n",
      "   macro avg       0.95      0.96      0.95       114\n",
      "weighted avg       0.96      0.96      0.96       114\n",
      "\n"
     ]
    }
   ],
   "source": [
    "print(classification_report(Y_test, y_pred))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[68  4]\n",
      " [ 1 41]]\n"
     ]
    }
   ],
   "source": [
    "print(confusion_matrix(Y_test, y_pred))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.956140350877193"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "rf_model.score(X_test, Y_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.9982456140350877"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "rf_model.score(X_resampled, Y_resampled)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}