Assignment_2_part2.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "0adfdc9c",
   "metadata": {},
   "outputs": [],
   "source": [
    "# importing all the library \n",
    "# all are not used but i have still kept to avoid errors\n",
    "import pandas as pd\n",
    "import math\n",
    "import numpy as np\n",
    "from sklearn import metrics\n",
    "from sklearn.metrics import confusion_matrix,accuracy_score,classification_report\n",
    "from sklearn.model_selection import train_test_split,cross_val_score,KFold,StratifiedKFold\n",
    "from sklearn.tree import DecisionTreeClassifier,plot_tree,export_graphviz\n",
    "from sklearn.ensemble import RandomForestClassifier\n",
    "from sklearn import neighbors, metrics,datasets,svm,linear_model, tree, ensemble\n",
    "from sklearn.metrics import precision_score, recall_score, f1_score, accuracy_score\n",
    "from sklearn.datasets import make_classification,load_iris,load_digits\n",
    "from sklearn.metrics import roc_curve, roc_auc_score,plot_confusion_matrix\n",
    "from sklearn.model_selection import cross_val_score,ParameterGrid,GridSearchCV,train_test_split\n",
    "from sklearn.svm import SVC\n",
    "from sklearn import linear_model\n",
    "from sklearn.decomposition import TruncatedSVD\n",
    "from sklearn.feature_extraction.text import TfidfTransformer, TfidfVectorizer,HashingVectorizer, CountVectorizer\n",
    "from sklearn.metrics import ConfusionMatrixDisplay\n",
    "from sklearn.pipeline import Pipeline, make_pipeline\n",
    "from sklearn.linear_model import LogisticRegression,Perceptron\n",
    "from sklearn.naive_bayes import GaussianNB\n",
    "from sklearn.model_selection import RandomizedSearchCV,train_test_split\n",
    "from sklearn.preprocessing import LabelEncoder,OneHotEncoder,Normalizer,StandardScaler\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "from scipy.stats.mstats import gmean\n",
    "from numpy import mean,std\n",
    "from matplotlib.colors import ListedColormap\n",
    "from imblearn.over_sampling import SMOTE \n",
    "from tensorflow import keras\n",
    "import tensorflow.keras as keras\n",
    "from tensorflow.keras.datasets import mnist\n",
    "from tensorflow.keras.models import Sequential\n",
    "from tensorflow.keras.layers import Dense, Dropout, Flatten ,Conv2D, MaxPooling2D\n",
    "from tensorflow.keras import backend as K\n",
    "import tensorflow as tf\n",
    "from tensorflow.keras import layers\n",
    "import tensorflow_datasets as tfds\n",
    "\n",
    "from keras import layers\n",
    "from keras.backend import clear_session\n",
    "from keras.preprocessing.text import Tokenizer\n",
    "from keras.models import Sequential,Model\n",
    "from keras import layers\n",
    "from keras.wrappers.scikit_learn import KerasClassifier\n",
    "from keras_preprocessing.sequence import pad_sequences\n",
    "import keras\n",
    "from keras.layers import Dense, Activation, concatenate, Embedding, Input\n",
    "\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "8c273fd6",
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "plt.style.use('ggplot')\n",
    "\n",
    "def plot_history(history):\n",
    "    acc = history.history['accuracy']\n",
    "    val_acc = history.history['val_accuracy']\n",
    "    loss = history.history['loss']\n",
    "    val_loss = history.history['val_loss']\n",
    "    x = range(1, len(acc) + 1)\n",
    "\n",
    "    plt.figure(figsize=(12, 5))\n",
    "    plt.subplot(1, 2, 1)\n",
    "    plt.plot(x, acc, 'b', label='Training acc')\n",
    "    plt.plot(x, val_acc, 'r', label='Validation acc')\n",
    "    plt.title('Training and validation accuracy')\n",
    "    plt.legend()\n",
    "    plt.subplot(1, 2, 2)\n",
    "    plt.plot(x, loss, 'b', label='Training loss')\n",
    "    plt.plot(x, val_loss, 'r', label='Validation loss')\n",
    "    plt.title('Training and validation loss')\n",
    "    plt.legend()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "2a5eb386",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Train set \n",
    "train_data=fetch_20newsgroups(subset='train')\n",
    "train_feat=train_data.data\n",
    "train_label=train_data.target"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "fc2a00cf",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Test set \n",
    "test_data=fetch_20newsgroups(subset='test')\n",
    "test_fech=test_data.data\n",
    "test_label=test_data.target"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "9efb6bc2",
   "metadata": {},
   "outputs": [],
   "source": [
    "news20_classes=train_data.target_names\n",
    "num_class=len(news20_classes)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "b1a0d285",
   "metadata": {},
   "outputs": [],
   "source": [
    "#using keras.utils.to_categorical \n",
    "y_train_catego = keras.utils.to_categorical(train_label, num_class)\n",
    "test_y= keras.utils.to_categorical(test_label, num_class)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "d77ff286",
   "metadata": {},
   "outputs": [],
   "source": [
    "# splitting the data at 20 % and 80%\n",
    "X_train,X_val,y_train,y_val=train_test_split(train_feat,y_train_catego,test_size=0.2,random_state=42,stratify=y_train_catego)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "701cf25a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train data shape (9051, 5000)\n",
      "Validation data shape (2263, 5000)\n"
     ]
    }
   ],
   "source": [
    "#setting the parrameter for tokenizing\n",
    "num_words=5000\n",
    "tokenizer=Tokenizer(num_words=num_words)\n",
    "tokenizer.fit_on_texts(X_train)\n",
    "X_train=tokenizer.texts_to_matrix(X_train,mode='tfidf')\n",
    "X_val=tokenizer.texts_to_matrix(X_val,mode='tfidf')\n",
    "X_test=tokenizer.texts_to_matrix(test_fech,mode='tfidf')\n",
    "# printing the train & validation data set using .shape\n",
    "print('Train data shape',X_train.shape)\n",
    "print('Validation data shape',X_val.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "d5af971f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "119286\n",
      "Model: \"sequential_2\"\n",
      "_________________________________________________________________\n",
      " Layer (type)                Output Shape              Param #   \n",
      "=================================================================\n",
      " embedding_1 (Embedding)     (None, 50, 300)           35785800  \n",
      "                                                                 \n",
      " flatten_1 (Flatten)         (None, 15000)             0         \n",
      "                                                                 \n",
      " dense_5 (Dense)             (None, 100)               1500100   \n",
      "                                                                 \n",
      " dense_6 (Dense)             (None, 10)                1010      \n",
      "                                                                 \n",
      " dense_7 (Dense)             (None, 1)                 11        \n",
      "                                                                 \n",
      "=================================================================\n",
      "Total params: 37,286,921\n",
      "Trainable params: 37,286,921\n",
      "Non-trainable params: 0\n",
      "_________________________________________________________________\n"
     ]
    }
   ],
   "source": [
    "embedding_dim = 300\n",
    "maxlen=50\n",
    "vocab_size = len(tokenizer.word_index) + 1\n",
    "print(vocab_size)\n",
    "\n",
    "model = Sequential()\n",
    "model.add(layers.Embedding(input_dim=vocab_size,output_dim=embedding_dim, input_length=maxlen))\n",
    "model.add(layers.Flatten())\n",
    "model.add(layers.Dense(100, activation='relu'))\n",
    "model.add(layers.Dense(10, activation='relu'))\n",
    "model.add(layers.Dense(1, activation='sigmoid'))\n",
    "model.compile(optimizer='adam',\n",
    "              loss='binary_crossentropy',\n",
    "              metrics=['accuracy'])\n",
    "model.summary()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "608d1830",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(2263, 20)"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y_val.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "95198fff",
   "metadata": {},
   "outputs": [],
   "source": [
    "def Model_mlp(vectorize_format,num_class,mlp_structure,dropout_rate,vocab_size,embedding_dim,maxlen):\n",
    "    model=keras.Sequential()\n",
    "    if vectorize_format=='sequence':\n",
    "        model.add(layers.Embedding(input_dim=vocab_size,output_dim=embedding_dim, input_length=maxlen,trainable=True))\n",
    "        model.add(layers.GlobalMaxPooling1D())\n",
    "    else:\n",
    "        model.add(keras.Input(shape=(num_words,)))\n",
    "        \n",
    "    for n_units in mlp_structure:\n",
    "        model.add(layers.Dense(n_units,activation='relu'))\n",
    "        model.add(layers.Dropout(dropout_rate))\n",
    "        \n",
    "    model.add(layers.Dense(num_class,activation='softmax'))\n",
    "    \n",
    "    model.compile(optimizer='adam',\n",
    "              loss='categorical_crossentropy',\n",
    "              metrics=['accuracy'])\n",
    "    return model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "87767525",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "119286\n",
      "Model: \"sequential_3\"\n",
      "_________________________________________________________________\n",
      " Layer (type)                Output Shape              Param #   \n",
      "=================================================================\n",
      " dense_8 (Dense)             (None, 256)               1280256   \n",
      "                                                                 \n",
      " dropout_2 (Dropout)         (None, 256)               0         \n",
      "                                                                 \n",
      " dense_9 (Dense)             (None, 128)               32896     \n",
      "                                                                 \n",
      " dropout_3 (Dropout)         (None, 128)               0         \n",
      "                                                                 \n",
      " dense_10 (Dense)            (None, 20)                2580      \n",
      "                                                                 \n",
      "=================================================================\n",
      "Total params: 1,315,732\n",
      "Trainable params: 1,315,732\n",
      "Non-trainable params: 0\n",
      "_________________________________________________________________\n"
     ]
    }
   ],
   "source": [
    "embedding_dim = 600\n",
    "maxlen=100\n",
    "vocab_size = len(tokenizer.word_index) + 1\n",
    "print(vocab_size)\n",
    "mlp_structure=[256,128]\n",
    "baseline = Model_mlp(vectorize_format='tfidf',num_class=num_class,mlp_structure=mlp_structure,\n",
    "                           dropout_rate=0.2,vocab_size=None,embedding_dim=None, maxlen=None)\n",
    "baseline.summary()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "aad77249",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1/5\n",
      "906/906 [==============================] - 6s 7ms/step - loss: 1.1283 - accuracy: 0.7020 - val_loss: 0.6461 - val_accuracy: 0.8299\n",
      "Epoch 2/5\n",
      "906/906 [==============================] - 6s 6ms/step - loss: 0.3174 - accuracy: 0.9288 - val_loss: 0.6995 - val_accuracy: 0.8303\n",
      "Epoch 3/5\n",
      "906/906 [==============================] - 6s 7ms/step - loss: 0.1920 - accuracy: 0.9603 - val_loss: 0.6841 - val_accuracy: 0.8418\n",
      "Epoch 4/5\n",
      "906/906 [==============================] - 7s 7ms/step - loss: 0.0889 - accuracy: 0.9786 - val_loss: 0.7530 - val_accuracy: 0.8537\n",
      "Epoch 5/5\n",
      "906/906 [==============================] - 6s 7ms/step - loss: 0.1498 - accuracy: 0.9745 - val_loss: 0.9346 - val_accuracy: 0.8418\n"
     ]
    }
   ],
   "source": [
    "history=baseline.fit(X_train, y_train, batch_size=10, epochs=5, validation_data=(X_val,y_val))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "cce42e1a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Training Accuracy: 0.9956\n",
      "Validation Accuracy:  0.8418\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x360 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# printing the plots \n",
    "loss, accuracy = baseline.evaluate(X_train, y_train, verbose=False)\n",
    "print(\"Training Accuracy: {:.4f}\".format(accuracy))\n",
    "loss, accuracy = baseline.evaluate(X_val, y_val, verbose=False)\n",
    "print(\"Validation Accuracy:  {:.4f}\".format(accuracy))\n",
    "plot_history(history)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b0473a8f",
   "metadata": {},
   "source": [
    "# Model Tunining "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "id": "96d11204",
   "metadata": {},
   "outputs": [],
   "source": [
    "# setting parameters \n",
    "batch_size = [64]\n",
    "epochs = [5]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "id": "7eade3b4",
   "metadata": {},
   "outputs": [],
   "source": [
    "param_grid = dict(batch_size=batch_size, epochs=epochs)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "id": "0c7dd721",
   "metadata": {},
   "outputs": [],
   "source": [
    "from scikeras.wrappers import KerasClassifier"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "id": "43b5d830",
   "metadata": {},
   "outputs": [],
   "source": [
    "model = KerasClassifier(build_fn=baseline,\n",
    "                            epochs=epochs, batch_size=10,\n",
    "                            verbose=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "id": "98e376ae",
   "metadata": {},
   "outputs": [],
   "source": [
    "grid = GridSearchCV(estimator=model, param_grid=param_grid,\n",
    "                              cv=10, verbose=1,scoring='accuracy')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "id": "baa27cb5",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Assets written to: C:\\Users\\DHRUVJ~1\\AppData\\Local\\Temp\\tmpy2t3r2fi\\assets\n",
      "Fitting 10 folds for each of 1 candidates, totalling 10 fits\n",
      "INFO:tensorflow:Assets written to: C:\\Users\\DHRUVJ~1\\AppData\\Local\\Temp\\tmpa4d0y2z6\\assets\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\Dhruv Jain\\anaconda3\\lib\\site-packages\\scikeras\\wrappers.py:301: UserWarning: ``build_fn`` will be renamed to ``model`` in a future release, at which point use of ``build_fn`` will raise an Error instead.\n",
      "  warnings.warn(\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Assets written to: C:\\Users\\DHRUVJ~1\\AppData\\Local\\Temp\\tmpzp9o5mx7\\assets\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\Dhruv Jain\\anaconda3\\lib\\site-packages\\scikeras\\wrappers.py:301: UserWarning: ``build_fn`` will be renamed to ``model`` in a future release, at which point use of ``build_fn`` will raise an Error instead.\n",
      "  warnings.warn(\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Assets written to: C:\\Users\\DHRUVJ~1\\AppData\\Local\\Temp\\tmp0qe_slnp\\assets\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\Dhruv Jain\\anaconda3\\lib\\site-packages\\scikeras\\wrappers.py:301: UserWarning: ``build_fn`` will be renamed to ``model`` in a future release, at which point use of ``build_fn`` will raise an Error instead.\n",
      "  warnings.warn(\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Assets written to: C:\\Users\\DHRUVJ~1\\AppData\\Local\\Temp\\tmprt2v5y5k\\assets\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\Dhruv Jain\\anaconda3\\lib\\site-packages\\scikeras\\wrappers.py:301: UserWarning: ``build_fn`` will be renamed to ``model`` in a future release, at which point use of ``build_fn`` will raise an Error instead.\n",
      "  warnings.warn(\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Assets written to: C:\\Users\\DHRUVJ~1\\AppData\\Local\\Temp\\tmp77rfzvf0\\assets\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\Dhruv Jain\\anaconda3\\lib\\site-packages\\scikeras\\wrappers.py:301: UserWarning: ``build_fn`` will be renamed to ``model`` in a future release, at which point use of ``build_fn`` will raise an Error instead.\n",
      "  warnings.warn(\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Assets written to: C:\\Users\\DHRUVJ~1\\AppData\\Local\\Temp\\tmp18_dm2ih\\assets\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\Dhruv Jain\\anaconda3\\lib\\site-packages\\scikeras\\wrappers.py:301: UserWarning: ``build_fn`` will be renamed to ``model`` in a future release, at which point use of ``build_fn`` will raise an Error instead.\n",
      "  warnings.warn(\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Assets written to: C:\\Users\\DHRUVJ~1\\AppData\\Local\\Temp\\tmppe8s0psq\\assets\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\Dhruv Jain\\anaconda3\\lib\\site-packages\\scikeras\\wrappers.py:301: UserWarning: ``build_fn`` will be renamed to ``model`` in a future release, at which point use of ``build_fn`` will raise an Error instead.\n",
      "  warnings.warn(\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Assets written to: C:\\Users\\DHRUVJ~1\\AppData\\Local\\Temp\\tmpovn37s1t\\assets\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\Dhruv Jain\\anaconda3\\lib\\site-packages\\scikeras\\wrappers.py:301: UserWarning: ``build_fn`` will be renamed to ``model`` in a future release, at which point use of ``build_fn`` will raise an Error instead.\n",
      "  warnings.warn(\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Assets written to: C:\\Users\\DHRUVJ~1\\AppData\\Local\\Temp\\tmps5gkar30\\assets\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\Dhruv Jain\\anaconda3\\lib\\site-packages\\scikeras\\wrappers.py:301: UserWarning: ``build_fn`` will be renamed to ``model`` in a future release, at which point use of ``build_fn`` will raise an Error instead.\n",
      "  warnings.warn(\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Assets written to: C:\\Users\\DHRUVJ~1\\AppData\\Local\\Temp\\tmpj7atyj34\\assets\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\Dhruv Jain\\anaconda3\\lib\\site-packages\\scikeras\\wrappers.py:301: UserWarning: ``build_fn`` will be renamed to ``model`` in a future release, at which point use of ``build_fn`` will raise an Error instead.\n",
      "  warnings.warn(\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Assets written to: C:\\Users\\DHRUVJ~1\\AppData\\Local\\Temp\\tmpe593w5tt\\assets\n",
      "INFO:tensorflow:Assets written to: C:\\Users\\DHRUVJ~1\\AppData\\Local\\Temp\\tmpyzpvj6mk\\assets\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\Dhruv Jain\\anaconda3\\lib\\site-packages\\scikeras\\wrappers.py:301: UserWarning: ``build_fn`` will be renamed to ``model`` in a future release, at which point use of ``build_fn`` will raise an Error instead.\n",
      "  warnings.warn(\n"
     ]
    }
   ],
   "source": [
    "# using 10 fits to get better acuuracy at end \n",
    "grid_result = grid.fit(X_train, y_train)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "id": "550eb356",
   "metadata": {},
   "outputs": [],
   "source": [
    "val_acc = grid_result.score(X_val, y_val)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "id": "29788717",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.8572691117984975\n"
     ]
    }
   ],
   "source": [
    "# printing the vali accuracy\n",
    "print(val_acc)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "id": "e983cb93",
   "metadata": {},
   "outputs": [],
   "source": [
    "train_acc=grid.score(X_train,y_train)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "id": "e7c920bf",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.9981217545022649\n"
     ]
    }
   ],
   "source": [
    "print(train_acc)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "id": "75682ff5",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.9783458344004975"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "grid_result.best_score_"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "id": "9d737816",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'batch_size': 10, 'epochs': 5}"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "grid_result.best_params_"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "id": "9b5bb377",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "236/236 [==============================] - 1s 2ms/step\n"
     ]
    }
   ],
   "source": [
    "testy=baseline.predict(X_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "id": "216c251d",
   "metadata": {},
   "outputs": [],
   "source": [
    "yhat_probs = baseline.predict(X_test, verbose=0)\n",
    "# predict crisp classes for test set\n",
    "yhat_classes = np.argmax(baseline.predict(X_test, verbose=0),axis=-1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "id": "29c08382",
   "metadata": {},
   "outputs": [],
   "source": [
    "yhat_probs = yhat_probs[:, 0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "id": "8321b64a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "numpy.ndarray"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(yhat_classes)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "id": "978b7ce0",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 4, 18,  0, ...,  9, 12, 15], dtype=int64)"
      ]
     },
     "execution_count": 81,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(yhat_probs).shape\n",
    "yhat_classes.shape\n",
    "test_y_1.shape\n",
    "test_y_1\n",
    "yhat_classes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "id": "0546cf2e",
   "metadata": {},
   "outputs": [],
   "source": [
    "test_y_1 = test_y[:, 0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "id": "8cac6885",
   "metadata": {},
   "outputs": [],
   "source": [
    "yhat_onehot=keras.utils.to_categorical(yhat_classes, num_class)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "id": "9695d85a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(7532, 20)"
      ]
     },
     "execution_count": 68,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "yhat_onehot.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "id": "8b4da70d",
   "metadata": {},
   "outputs": [],
   "source": [
    "yhat_onehot=yhat_onehot[:,0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "id": "33764a0a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy: 0.978359\n",
      "Precision: 0.976743\n",
      "Recall: 0.978359\n",
      "F1 score: 0.977015\n"
     ]
    }
   ],
   "source": [
    "accuracy = accuracy_score(test_y_1, yhat_onehot)\n",
    "print('Accuracy: %f' % accuracy)\n",
    "# precision tp / (tp + fp)\n",
    "precision = precision_score(test_y_1, yhat_onehot,average='weighted')\n",
    "print('Precision: %f' % precision)\n",
    "# recall: tp / (tp + fn)\n",
    "recall = recall_score(test_y_1, yhat_onehot,average='weighted')\n",
    "print('Recall: %f' % recall)\n",
    "# f1: 2 tp / (2 tp + fp + fn)\n",
    "f1 = f1_score(test_y_1, yhat_onehot,average='weighted')\n",
    "print('F1 score: %f' % f1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "id": "edda1d83",
   "metadata": {},
   "outputs": [],
   "source": [
    "yhat_probs = grid_result.predict(X_test)\n",
    "# predict crisp classes for test set\n",
    "yhat_classes = np.argmax(grid_result.predict(X_test),axis=-1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "id": "9d8ff391",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "numpy.ndarray"
      ]
     },
     "execution_count": 73,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "yhat_probs = yhat_probs[:, 0]\n",
    "type(yhat_classes)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "id": "bbaa4932",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(7532,)"
      ]
     },
     "execution_count": 74,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "yhat_classes.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "id": "564427c4",
   "metadata": {},
   "outputs": [],
   "source": [
    "yhat_onehot=keras.utils.to_categorical(yhat_classes, num_class)\n",
    "yhat_onehot=yhat_onehot[:,0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "id": "1fbf4b66",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(7532,)"
      ]
     },
     "execution_count": 77,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "yhat_onehot.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "id": "ba9cfdc0",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy: 0.975969\n",
      "Precision: 0.977256\n",
      "Recall: 0.975969\n",
      "F1 score: 0.976533\n"
     ]
    }
   ],
   "source": [
    "accuracy = accuracy_score(test_y_1, yhat_onehot)\n",
    "print('Accuracy: %f' % accuracy)\n",
    "# precision tp / (tp + fp)\n",
    "precision = precision_score(test_y_1, yhat_onehot,average='weighted')\n",
    "print('Precision: %f' % precision)\n",
    "# recall: tp / (tp + fn)\n",
    "recall = recall_score(test_y_1, yhat_onehot,average='weighted')\n",
    "print('Recall: %f' % recall)\n",
    "# f1: 2 tp / (2 tp + fp + fn)\n",
    "f1 = f1_score(test_y_1, yhat_onehot,average='weighted')\n",
    "print('F1 score: %f' % f1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c055ee0a",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "005b33d2",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "627fdce2",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "821f2940",
   "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.9.13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}