data-mining-part-b-nn-keras.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import warnings"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "warnings.filterwarnings(\"ignore\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Using TensorFlow backend.\n"
     ]
    }
   ],
   "source": [
    "import pandas\n",
    "from sklearn.model_selection import train_test_split\n",
    "from keras import Sequential\n",
    "from keras.layers import Embedding, Dense, Dropout, GlobalMaxPool1D, Flatten\n",
    "from keras.callbacks import EarlyStopping\n",
    "from sklearn.metrics import accuracy_score, confusion_matrix, classification_report\n",
    "import tensorflow\n",
    "import numpy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "o = pandas.read_csv('small-preprocessed_onion_data-500-rows.csv')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "X = o.iloc[:, :-1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "Y = o.iloc[:, -1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "x_fit, x_test, y_fit, y_test = train_test_split(X, Y, test_size=0.25, random_state=42)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "x_train, x_val, y_train, y_val = train_test_split(x_fit, y_fit, test_size=0.20, random_state=42)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "x_train = tensorflow.keras.utils.normalize(x_train, axis=1).to_numpy()\n",
    "x_val = tensorflow.keras.utils.normalize(x_val, axis=1).to_numpy()\n",
    "x_test = tensorflow.keras.utils.normalize(x_test, axis=1).to_numpy()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "y_train = y_train.to_numpy()\n",
    "y_val = y_val.to_numpy()\n",
    "y_test = y_test.to_numpy()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:From C:\\Users\\andreas\\anaconda3\\lib\\site-packages\\tensorflow\\python\\ops\\resource_variable_ops.py:435: colocate_with (from tensorflow.python.framework.ops) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Colocations handled automatically by placer.\n"
     ]
    }
   ],
   "source": [
    "model = Sequential()\n",
    "\n",
    "model.add(Dense(128, activation=tensorflow.nn.relu))\n",
    "model.add(Dense(128, activation=tensorflow.nn.relu))\n",
    "model.add(Dense(2, activation=tensorflow.nn.softmax))\n",
    "model.compile(optimizer='adam', loss='sparse_categorical_crossentropy', metrics=['accuracy'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "es = EarlyStopping(monitor='val_loss', mode='min', verbose=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train on 300 samples, validate on 75 samples\n",
      "Epoch 1/10\n",
      "300/300 [==============================] - 0s 675us/step - loss: 0.6813 - accuracy: 0.6067 - val_loss: 0.6529 - val_accuracy: 0.6400\n",
      "Epoch 2/10\n",
      "300/300 [==============================] - 0s 299us/step - loss: 0.6010 - accuracy: 0.6067 - val_loss: 0.6087 - val_accuracy: 0.6400\n",
      "Epoch 3/10\n",
      "300/300 [==============================] - 0s 286us/step - loss: 0.3998 - accuracy: 0.8767 - val_loss: 0.4909 - val_accuracy: 0.8267\n",
      "Epoch 4/10\n",
      "300/300 [==============================] - 0s 278us/step - loss: 0.1221 - accuracy: 0.9933 - val_loss: 0.3647 - val_accuracy: 0.8533\n",
      "Epoch 5/10\n",
      "300/300 [==============================] - 0s 278us/step - loss: 0.0185 - accuracy: 1.0000 - val_loss: 0.3446 - val_accuracy: 0.8667\n",
      "Epoch 6/10\n",
      "300/300 [==============================] - 0s 301us/step - loss: 0.0050 - accuracy: 1.0000 - val_loss: 0.3411 - val_accuracy: 0.8800\n",
      "Epoch 7/10\n",
      "300/300 [==============================] - 0s 296us/step - loss: 0.0025 - accuracy: 1.0000 - val_loss: 0.3449 - val_accuracy: 0.8533\n",
      "Epoch 00007: early stopping\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<keras.callbacks.callbacks.History at 0x214f1fe4dc8>"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "model.fit(x_train, y_train, epochs=10, batch_size=16, verbose=1, validation_data=(x_val, y_val), callbacks=[es])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "y_pred = model.predict(x_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model: \"sequential_1\"\n",
      "_________________________________________________________________\n",
      "Layer (type)                 Output Shape              Param #   \n",
      "=================================================================\n",
      "dense_1 (Dense)              (None, 128)               337280    \n",
      "_________________________________________________________________\n",
      "dense_2 (Dense)              (None, 128)               16512     \n",
      "_________________________________________________________________\n",
      "dense_3 (Dense)              (None, 2)                 258       \n",
      "=================================================================\n",
      "Total params: 354,050\n",
      "Trainable params: 354,050\n",
      "Non-trainable params: 0\n",
      "_________________________________________________________________\n"
     ]
    }
   ],
   "source": [
    "model.summary()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "final_evaluation = []\n",
    "y_hat = []\n",
    "y_real = []\n",
    "evaluation = []"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "y_test_hat = [y_test, numpy.zeros(y_test.shape[0], dtype=numpy.int16)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "for i in range(len(y_test)):\n",
    "    if y_test_hat[0][i] == 0:\n",
    "        y_test_hat[1][i] = 1\n",
    "    else:\n",
    "        y_test_hat[1][i] = 0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "y_test_hat = numpy.transpose(y_test_hat)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "y_test_hat = y_test_hat[:,[0, 1]] = y_test_hat[:,[1, 0]]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "for i in range(len(y_test)):\n",
    "    final_evaluation.append(y_test_hat[i][0] - y_pred[i][0])\n",
    "    y_real.append(y_test_hat[i][0])\n",
    "    y_hat.append(y_pred[i][0])\n",
    "    if numpy.mean(numpy.abs(y_test_hat[i] - y_pred[i])) > 0.5:\n",
    "        evaluation.append(False)\n",
    "    else:\n",
    "        evaluation.append(True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "y_pred_df = pandas.DataFrame(list(zip(final_evaluation, evaluation, y_real,\n",
    "                                       y_hat)), columns=['loss_dif',\n",
    "                                                         'evaluation',\n",
    "                                                         'y_real',\n",
    "                                                         'y_hat'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "errors = y_pred_df.loc[y_pred_df['evaluation'] == False]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "              precision    recall  f1-score   support\n",
      "\n",
      "         0.0       0.67      0.83      0.74        42\n",
      "         1.0       0.90      0.80      0.85        83\n",
      "\n",
      "    accuracy                           0.81       125\n",
      "   macro avg       0.79      0.81      0.80       125\n",
      "weighted avg       0.83      0.81      0.81       125\n",
      "\n"
     ]
    }
   ],
   "source": [
    "print(classification_report(\n",
    "    y_pred_df.y_real.astype(numpy.float16).to_numpy(),\n",
    "    numpy.where(y_pred_df.y_hat.astype(numpy.float16).to_numpy() > 0.5, 1, 0)\n",
    "))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "y_pred = model.predict(X)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "final_evaluation = []\n",
    "y_pred_hat = []\n",
    "y_real = []\n",
    "evaluation = []"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "y_hat = [Y.to_numpy(), numpy.zeros(Y.to_numpy().shape[0], dtype=numpy.int16)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "for i in range(Y.to_numpy().shape[0]):\n",
    "    if y_hat[0][i] == 0:\n",
    "        y_hat[1][i] = 1\n",
    "    else:\n",
    "        y_hat[1][i] = 0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "y_hat = numpy.transpose(y_hat)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "y_hat = y_hat[:,[0, 1]] = y_hat[:,[1, 0]]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "for i in range(Y.to_numpy().shape[0]):\n",
    "    final_evaluation.append(y_hat[i][0] - y_pred[i][0])\n",
    "    y_real.append(y_hat[i][0])\n",
    "    y_pred_hat.append(y_pred[i][0])\n",
    "    if numpy.mean(numpy.abs(y_hat[i] - y_pred[i])) > 0.5:\n",
    "        evaluation.append(False)\n",
    "    else:\n",
    "        evaluation.append(True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [],
   "source": [
    "y_pred_df = pandas.DataFrame(list(zip(final_evaluation, evaluation, y_real,\n",
    "                                       y_pred_hat)), columns=['loss_dif',\n",
    "                                                         'evaluation',\n",
    "                                                         'y_real',\n",
    "                                                         'y_hat'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [],
   "source": [
    "errors = y_pred_df.loc[y_pred_df['evaluation'] == False]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "              precision    recall  f1-score   support\n",
      "\n",
      "         0.0       0.88      0.94      0.91       187\n",
      "         1.0       0.96      0.92      0.94       313\n",
      "\n",
      "    accuracy                           0.93       500\n",
      "   macro avg       0.92      0.93      0.93       500\n",
      "weighted avg       0.93      0.93      0.93       500\n",
      "\n"
     ]
    }
   ],
   "source": [
    "print(classification_report(\n",
    "    y_pred_df.y_real.astype(numpy.float16).to_numpy(),\n",
    "    numpy.where(y_pred_df.y_hat.astype(numpy.float16).to_numpy() > 0.5, 1, 0)\n",
    "))"
   ]
  },
  {
   "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.7.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}