Ass 3 ML.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "f1611613",
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import numpy as np\n",
    "import itertools \n",
    "import warnings\n",
    "from sklearn.model_selection import KFold\n",
    "import sklearn.metrics as metric\n",
    "from sklearn.metrics import accuracy_score\n",
    "from sklearn.metrics import mean_squared_error\n",
    "from sklearn.metrics import confusion_matrix\n",
    "from sklearn.metrics import precision_score\n",
    "from sklearn.metrics import recall_score\n",
    "from sklearn.metrics import classification_report\n",
    "from sklearn.model_selection import train_test_split\n",
    "from scipy.io import arff\n",
    "from sklearn.utils import shuffle\n",
    "from sklearn.linear_model import LogisticRegression"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "fcc887be",
   "metadata": {},
   "outputs": [],
   "source": [
    "data = arff.loadarff('TimeBasedFeatures-Dataset-15s-VPN.arff')\n",
    "df = pd.DataFrame(data[0])\n",
    "df = shuffle(df)\n",
    "df.head()\n",
    "y =df['class1'].replace({b'VPN': 1,b'Non-VPN': 0})\n",
    "X = df.drop([\"class1\"],axis=1)\n",
    "X_A, X_B, y_A, y_B = train_test_split(X,y, test_size=0.7, random_state=3)\n",
    "kfold= KFold(n_splits=10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "0a9602e8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'solver': 'newton-cg', 'penalty': 'none', 'class_weight': {1: 1}, 'C': 0.6000000000000001}\n",
      "{'solver': 'newton-cg', 'penalty': 'none', 'class_weight': {1: 1}, 'C': 0.6000000000000001}\n",
      "{'solver': 'liblinear', 'penalty': 'l1', 'class_weight': {1: 1}, 'C': 0.2}\n",
      "{'solver': 'newton-cg', 'penalty': 'none', 'class_weight': {1: 1}, 'C': 0.6000000000000001}\n",
      "{'solver': 'newton-cg', 'penalty': 'none', 'class_weight': {1: 1}, 'C': 0.6000000000000001}\n",
      "{'solver': 'newton-cg', 'penalty': 'none', 'class_weight': {1: 1}, 'C': 0.6000000000000001}\n",
      "{'solver': 'newton-cg', 'penalty': 'none', 'class_weight': {1: 1}, 'C': 0.6000000000000001}\n",
      "{'solver': 'newton-cg', 'penalty': 'none', 'class_weight': {1: 1}, 'C': 0.6000000000000001}\n",
      "{'solver': 'newton-cg', 'penalty': 'none', 'class_weight': {1: 1}, 'C': 0.6000000000000001}\n",
      "{'solver': 'newton-cg', 'penalty': 'none', 'class_weight': {1: 1}, 'C': 0.6000000000000001}\n"
     ]
    }
   ],
   "source": [
    "clf1 = LogisticRegression()\n",
    "import warnings\n",
    "warnings.filterwarnings('ignore')\n",
    "c=[x*0.1 for x in range(1, 10)]\n",
    "c.append(0.01)\n",
    "params={ 'C':c,'penalty': ['l1', 'l2', 'elasticnet','none'],\n",
    "        'solver':['newton-cg', 'lbfgs', 'liblinear', 'sag', 'saga'],\n",
    "         'class_weight': [{0: 0.01}, {1: 1},'none','balanced']}\n",
    "from sklearn.model_selection import RandomizedSearchCV\n",
    "for train_index, val_index in kfold.split(X_A):\n",
    "        output_val=[]\n",
    "        output_train=[]\n",
    "\n",
    "        X_train, X_val = X_A.iloc[train_index], X_A.iloc[val_index]\n",
    "        y_train, y_val = y_A.iloc[train_index], y_A.iloc[val_index]  \n",
    "\n",
    "        randomclf = RandomizedSearchCV(estimator=clf1, param_distributions=params,\n",
    "                               n_iter=len(params), cv=4, verbose=0, random_state=42,\n",
    "                               n_jobs=1)\n",
    "\n",
    "        search=randomclf.fit(X_train, y_train)\n",
    "        print(search.best_params_)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "9f3cbe84",
   "metadata": {},
   "outputs": [],
   "source": [
    "cf = LogisticRegression(solver= 'newton-cg', penalty = 'none', class_weight= {1: 1}, C= 0.6000000000000001)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "0bfcd2fe",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy of training for all folds:0.6401872147080061%\n",
      "Accuracy of validation for all folds:0.6339124416098304%\n",
      "Precision of training for all folds:0.6256372575744614%\n",
      "Precision of validation for all folds:0.6202628545428063%\n",
      "Recall of training for all folds:0.7619150380070817%\n",
      "Recall of validation for all folds:0.7587940761601126%\n",
      "sensitivity of training for all folds:0.5091197264586225%\n",
      "sensitivity of validation for all folds:0.4998490818066143%\n",
      "specificity of training for all folds:0.7619150380070817%\n",
      "specificity of validation for all folds:0.7587940761601126%\n",
      "F1 Score of training for all folds:0.6870049191682733%\n",
      "F1 Score of validation for all folds:0.6822874278607778%\n"
     ]
    }
   ],
   "source": [
    "X_A, X_B, y_A, y_B = train_test_split(X,y, test_size=0.7, random_state=3)\n",
    "kfold= KFold(n_splits=10)\n",
    "AccuracyValidation = []\n",
    "AccuracyTraining = []\n",
    "precisionValidation = []\n",
    "precisionTraining = []\n",
    "recallValidation = []\n",
    "recallTraining = []\n",
    "f1scoreValidation = []\n",
    "f1scoreTraining = []\n",
    "sensitivityValidation = []\n",
    "sensitivityTraining = []\n",
    "specificityValidation = []\n",
    "specificityTraining = []\n",
    "\n",
    "for train_index, val_index in kfold.split(X_A):\n",
    "        output_val=[]\n",
    "        output_train=[]\n",
    "\n",
    "        X_train, X_val = X_A.iloc[train_index], X_A.iloc[val_index]\n",
    "        y_train, y_val = y_A.iloc[train_index], y_A.iloc[val_index]  \n",
    "        cf.fit(X_train,y_train)\n",
    "        output_train =  cf.predict(X_train)\n",
    "        output_val =  cf.predict(X_val)\n",
    "        \n",
    "        AccuracyTraining.append((accuracy_score(y_train,output_train)))\n",
    "        AccuracyValidation.append((accuracy_score(y_val,output_val)))\n",
    "        precisionTraining.append(precision_score(y_train,output_train))\n",
    "        precisionValidation.append(precision_score(y_val,output_val))\n",
    "        recallTraining.append(recall_score(y_train,output_train))\n",
    "        recallValidation.append(recall_score(y_val,output_val))\n",
    "        cmVal = confusion_matrix(y_val,output_val)\n",
    "        cmTrain= confusion_matrix(y_train,output_train)\n",
    "        sensitivityValidation.append(cmVal[0,0]/(cmVal[0,0]+cmVal[0,1]))\n",
    "        sensitivityTraining.append(cmTrain[0,0]/(cmTrain[0,0]+cmTrain[0,1]))\n",
    "        specificityValidation.append( cmVal[1,1]/(cmVal[1,0]+cmVal[1,1]))\n",
    "        specificityTraining.append( cmTrain[1,1]/(cmTrain[1,0]+cmTrain[1,1]))\n",
    "        f1scoreValidation.append( (2 * precision_score(y_val,output_val) * recall_score(y_val,output_val)) / (precision_score(y_val,output_val) + recall_score(y_val,output_val)))\n",
    "        f1scoreTraining.append( (2 * precision_score(y_train,output_train) * recall_score(y_train,output_train)) / (precision_score(y_train,output_train) + recall_score(y_train,output_train)))\n",
    "\n",
    "print(\"Accuracy of training for all folds:{}%\".format((sum(AccuracyTraining)/10)))\n",
    "print(\"Accuracy of validation for all folds:{}%\".format((sum(AccuracyValidation)/10)))\n",
    "\n",
    "print(\"Precision of training for all folds:{}%\".format((sum(precisionTraining)/10)))\n",
    "print(\"Precision of validation for all folds:{}%\".format((sum(precisionValidation)/10)))\n",
    "\n",
    "print(\"Recall of training for all folds:{}%\".format((sum(recallTraining)/10)))\n",
    "print(\"Recall of validation for all folds:{}%\".format((sum(recallValidation)/10)))\n",
    "\n",
    "print(\"sensitivity of training for all folds:{}%\".format((sum(sensitivityTraining)/10)))\n",
    "print(\"sensitivity of validation for all folds:{}%\".format((sum(sensitivityValidation)/10)))\n",
    "\n",
    "print(\"specificity of training for all folds:{}%\".format((sum(specificityTraining)/10)))\n",
    "print(\"specificity of validation for all folds:{}%\".format((sum(specificityValidation)/10)))\n",
    "\n",
    "print(\"F1 Score of training for all folds:{}%\".format((sum(f1scoreTraining)/10)))\n",
    "print(\"F1 Score of validation for all folds:{}%\".format((sum(f1scoreValidation)/10)))\n",
    "\n",
    "output_test =  cf.predict(X_B)\n",
    "\n",
    "accuracy_test = accuracy_score(y_B,output_test)\n",
    "precison_test = precision_score(y_B,output_test)\n",
    "recall_test = recall_score(y_B,output_test)\n",
    "cmTest = confusion_matrix(y_B,output_test)\n",
    "sensitivityTest = cmTest[0,0]/(cmTest[0,0]+cmTest[0,1])\n",
    "specificityTest = cmTest[1,1]/(cmTest[1,0]+cmTest[1,1])\n",
    "f1_test = ( (2 * precison_test* recall_test) / (precison_test + recall_test))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "7994a340",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>Training f1</th>\n",
       "      <th>Validation f1</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>0.691312</td>\n",
       "      <td>0.664625</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>0.679088</td>\n",
       "      <td>0.690852</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>0.679081</td>\n",
       "      <td>0.670807</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>0.692438</td>\n",
       "      <td>0.670866</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>0.691996</td>\n",
       "      <td>0.697108</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>0.682258</td>\n",
       "      <td>0.660606</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>6</th>\n",
       "      <td>0.688417</td>\n",
       "      <td>0.686709</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>7</th>\n",
       "      <td>0.690102</td>\n",
       "      <td>0.689864</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>8</th>\n",
       "      <td>0.687942</td>\n",
       "      <td>0.681957</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>9</th>\n",
       "      <td>0.687415</td>\n",
       "      <td>0.709480</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   Training f1  Validation f1 \n",
       "0     0.691312        0.664625\n",
       "1     0.679088        0.690852\n",
       "2     0.679081        0.670807\n",
       "3     0.692438        0.670866\n",
       "4     0.691996        0.697108\n",
       "5     0.682258        0.660606\n",
       "6     0.688417        0.686709\n",
       "7     0.690102        0.689864\n",
       "8     0.687942        0.681957\n",
       "9     0.687415        0.709480"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "table_f1 = pd.DataFrame({'Training f1': f1scoreTraining, 'Validation f1 ':  f1scoreValidation})\n",
    "table_f1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "511adfa2",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>Training precision</th>\n",
       "      <th>Validation precision</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>0.626041</td>\n",
       "      <td>0.594521</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>0.625401</td>\n",
       "      <td>0.640351</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>0.625120</td>\n",
       "      <td>0.613636</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>0.624847</td>\n",
       "      <td>0.612069</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>0.623175</td>\n",
       "      <td>0.612299</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>0.630689</td>\n",
       "      <td>0.615819</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>6</th>\n",
       "      <td>0.631612</td>\n",
       "      <td>0.618234</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>7</th>\n",
       "      <td>0.624652</td>\n",
       "      <td>0.621253</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>8</th>\n",
       "      <td>0.626453</td>\n",
       "      <td>0.635328</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>9</th>\n",
       "      <td>0.618381</td>\n",
       "      <td>0.639118</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   Training precision  Validation precision \n",
       "0            0.626041               0.594521\n",
       "1            0.625401               0.640351\n",
       "2            0.625120               0.613636\n",
       "3            0.624847               0.612069\n",
       "4            0.623175               0.612299\n",
       "5            0.630689               0.615819\n",
       "6            0.631612               0.618234\n",
       "7            0.624652               0.621253\n",
       "8            0.626453               0.635328\n",
       "9            0.618381               0.639118"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "table_precision= pd.DataFrame({'Training precision': precisionTraining, 'Validation precision ':  precisionValidation})\n",
    "table_precision"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "f30a75aa",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>Training Recall</th>\n",
       "      <th>Validation Recall</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>0.771776</td>\n",
       "      <td>0.753472</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>0.742857</td>\n",
       "      <td>0.750000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>0.743238</td>\n",
       "      <td>0.739726</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>0.776426</td>\n",
       "      <td>0.742160</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>0.777904</td>\n",
       "      <td>0.809187</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>0.743010</td>\n",
       "      <td>0.712418</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>6</th>\n",
       "      <td>0.756449</td>\n",
       "      <td>0.772242</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>7</th>\n",
       "      <td>0.770873</td>\n",
       "      <td>0.775510</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>8</th>\n",
       "      <td>0.762816</td>\n",
       "      <td>0.735974</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>9</th>\n",
       "      <td>0.773800</td>\n",
       "      <td>0.797251</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   Training Recall  Validation Recall\n",
       "0         0.771776           0.753472\n",
       "1         0.742857           0.750000\n",
       "2         0.743238           0.739726\n",
       "3         0.776426           0.742160\n",
       "4         0.777904           0.809187\n",
       "5         0.743010           0.712418\n",
       "6         0.756449           0.772242\n",
       "7         0.770873           0.775510\n",
       "8         0.762816           0.735974\n",
       "9         0.773800           0.797251"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "table_Recall= pd.DataFrame({'Training Recall': recallTraining, 'Validation Recall':  recallValidation})\n",
    "table_Recall"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "b66cb9ad",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>Training Sensitivity</th>\n",
       "      <th>Validation Sensitivity</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>0.502259</td>\n",
       "      <td>0.461818</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>0.521115</td>\n",
       "      <td>0.546125</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>0.520295</td>\n",
       "      <td>0.498155</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>0.496302</td>\n",
       "      <td>0.510870</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>0.490123</td>\n",
       "      <td>0.482143</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>0.536894</td>\n",
       "      <td>0.470817</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>6</th>\n",
       "      <td>0.521005</td>\n",
       "      <td>0.524823</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>7</th>\n",
       "      <td>0.502457</td>\n",
       "      <td>0.481343</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>8</th>\n",
       "      <td>0.514892</td>\n",
       "      <td>0.505792</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>9</th>\n",
       "      <td>0.485855</td>\n",
       "      <td>0.516605</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   Training Sensitivity  Validation Sensitivity\n",
       "0              0.502259                0.461818\n",
       "1              0.521115                0.546125\n",
       "2              0.520295                0.498155\n",
       "3              0.496302                0.510870\n",
       "4              0.490123                0.482143\n",
       "5              0.536894                0.470817\n",
       "6              0.521005                0.524823\n",
       "7              0.502457                0.481343\n",
       "8              0.514892                0.505792\n",
       "9              0.485855                0.516605"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "table_Sensitivity= pd.DataFrame({'Training Sensitivity': sensitivityTraining, 'Validation Sensitivity':  sensitivityValidation})\n",
    "table_Sensitivity"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "8388791c",
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>Training specificity</th>\n",
       "      <th>Validation specificity</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>0.771776</td>\n",
       "      <td>0.753472</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>0.742857</td>\n",
       "      <td>0.750000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>0.743238</td>\n",
       "      <td>0.739726</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>0.776426</td>\n",
       "      <td>0.742160</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>0.777904</td>\n",
       "      <td>0.809187</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>0.743010</td>\n",
       "      <td>0.712418</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>6</th>\n",
       "      <td>0.756449</td>\n",
       "      <td>0.772242</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>7</th>\n",
       "      <td>0.770873</td>\n",
       "      <td>0.775510</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>8</th>\n",
       "      <td>0.762816</td>\n",
       "      <td>0.735974</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>9</th>\n",
       "      <td>0.773800</td>\n",
       "      <td>0.797251</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   Training specificity  Validation specificity\n",
       "0              0.771776                0.753472\n",
       "1              0.742857                0.750000\n",
       "2              0.743238                0.739726\n",
       "3              0.776426                0.742160\n",
       "4              0.777904                0.809187\n",
       "5              0.743010                0.712418\n",
       "6              0.756449                0.772242\n",
       "7              0.770873                0.775510\n",
       "8              0.762816                0.735974\n",
       "9              0.773800                0.797251"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "table_specificity= pd.DataFrame({'Training specificity': specificityTraining, 'Validation specificity':  specificityValidation})\n",
    "table_specificity"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "688527d7",
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>Training Accuracy</th>\n",
       "      <th>Validation Accuracy</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>0.642180</td>\n",
       "      <td>0.611012</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>0.636058</td>\n",
       "      <td>0.651865</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>0.635861</td>\n",
       "      <td>0.623446</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>0.641785</td>\n",
       "      <td>0.628774</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>0.639810</td>\n",
       "      <td>0.646536</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>0.643167</td>\n",
       "      <td>0.602131</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>6</th>\n",
       "      <td>0.643562</td>\n",
       "      <td>0.648313</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>7</th>\n",
       "      <td>0.641461</td>\n",
       "      <td>0.635231</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>8</th>\n",
       "      <td>0.642843</td>\n",
       "      <td>0.629893</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>9</th>\n",
       "      <td>0.635143</td>\n",
       "      <td>0.661922</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   Training Accuracy  Validation Accuracy \n",
       "0           0.642180              0.611012\n",
       "1           0.636058              0.651865\n",
       "2           0.635861              0.623446\n",
       "3           0.641785              0.628774\n",
       "4           0.639810              0.646536\n",
       "5           0.643167              0.602131\n",
       "6           0.643562              0.648313\n",
       "7           0.641461              0.635231\n",
       "8           0.642843              0.629893\n",
       "9           0.635143              0.661922"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "table_accuracy = pd.DataFrame({'Training Accuracy': AccuracyTraining, 'Validation Accuracy ':  AccuracyValidation})\n",
    "table_accuracy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "31922a5f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.6237148732008225\n",
      "0.6146191209572326\n",
      "0.7545084351367074\n",
      "[[3002 3253]\n",
      " [1688 5188]]\n",
      "0.47993605115907273\n",
      "0.7545084351367074\n",
      "0.6774172488085134\n"
     ]
    }
   ],
   "source": [
    "print(accuracy_test)\n",
    "print(precison_test )\n",
    "print(recall_test)\n",
    "print(cmTest )\n",
    "print(sensitivityTest )\n",
    "print(specificityTest )\n",
    "print(f1_test )\n"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.10.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}