train_both_svdb_mitdb.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "collapsed": true,
    "ExecuteTime": {
     "end_time": "2023-06-15T23:55:55.632375135Z",
     "start_time": "2023-06-15T23:55:55.576395813Z"
    }
   },
   "outputs": [],
   "source": [
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.metrics import confusion_matrix, classification_report\n",
    "from tensorflow.keras.utils import to_categorical\n",
    "from tensorflow.keras.models import load_model, Sequential\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "import model_training_utils as mtu"
   ]
  },
  {
   "cell_type": "markdown",
   "source": [
    "# svDB prep"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "outputs": [],
   "source": [
    "svdb_data = pd.read_csv(\"data_sliced_tda/svDB.csv\")\n",
    "svdb_data = svdb_data[['betti_H1', 'ann']]\n",
    "\n",
    "# Fix the lame type, string -> list\n",
    "svdb_data['betti_H1'] = svdb_data['betti_H1'].apply(lambda x: mtu.fix_betti_string_svdb(x))\n",
    "# Turn the list into a np.array of floats\n",
    "svdb_data['betti_H1'] = svdb_data['betti_H1'].apply(lambda x: (np.array([float(num) for num in x])))"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2023-06-15T23:17:16.082634171Z",
     "start_time": "2023-06-15T23:16:49.110293375Z"
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "# mitDB prep"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "outputs": [],
   "source": [
    "mitdb_data = pd.read_csv(\"data_sliced_tda/mitDB.csv\")\n",
    "\n",
    "mitdb_data['betti_H1'] = mitdb_data['betti'].apply(lambda x: np.array(mtu.fix_betti_string_mitdb(x)[1]))\n",
    "mitdb_data = mitdb_data[['betti_H1', 'ann']]"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2023-06-15T23:33:25.291880973Z",
     "start_time": "2023-06-15T23:32:58.069315781Z"
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "# Random research"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "outputs": [
    {
     "data": {
      "text/plain": "ann\n0    82877\n1    26347\nName: count, dtype: int64"
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mitdb_data['ann'].value_counts()"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2023-06-16T00:20:51.921544076Z",
     "start_time": "2023-06-16T00:20:51.878809084Z"
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "# Merging data and doing rest of the prep"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "outputs": [],
   "source": [
    "concatenated_data = pd.concat([svdb_data, mitdb_data])\n",
    "concatenated_data = concatenated_data.reset_index(drop=True)"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2023-06-15T23:36:16.485402466Z",
     "start_time": "2023-06-15T23:36:16.442421430Z"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "outputs": [],
   "source": [
    "X, y = concatenated_data['betti_H1'], concatenated_data['ann']\n",
    "\n",
    "# Split to train and test data\n",
    "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, stratify=y, random_state=420)\n",
    "\n",
    "# Encode the classes\n",
    "y_train = to_categorical(np.array(y_train.to_list()))\n",
    "\n",
    "# ????? Make a 3dim train data I guess\n",
    "X_train = np.array(X_train.to_list())\n",
    "X_train = X_train.reshape(X_train.shape[0], X_train.shape[1], 1)"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2023-06-15T23:48:31.913811995Z",
     "start_time": "2023-06-15T23:48:31.545234478Z"
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "# Model training"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "model = load_model('models_raw/4conv_1dens32.hdf5')\n",
    "history = model.fit(X_train, y_train, batch_size=128, epochs=10, validation_split=0.2, verbose=1)\n",
    "model.save(\"models_trained/both_svdb_mitdb_trained.hdf5\")"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "# Model testing and evaluating"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "model = load_model(\"models_trained/both_svdb_mitdb_trained.hdf5\")"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "outputs": [],
   "source": [
    "# Encode the test classes\n",
    "y_test = to_categorical(np.array(y_test.to_list()))\n",
    "\n",
    "# ????? Make a 3dim train data I guess\n",
    "X_test = np.array(X_test.to_list())\n",
    "X_test = X_test.reshape(X_test.shape[0], X_test.shape[1], 1)"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2023-06-15T23:48:40.478404981Z",
     "start_time": "2023-06-15T23:48:40.423911772Z"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1833/1833 [==============================] - 7s 3ms/step - loss: 0.3433 - accuracy: 0.8592\n",
      "Test Loss: 0.34327471256256104\n",
      "Test Accuracy: 0.8591911792755127\n"
     ]
    }
   ],
   "source": [
    "loss, accuracy = model.evaluate(X_test, y_test)\n",
    "print(\"Test Loss:\", loss)\n",
    "print(\"Test Accuracy:\", accuracy)"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2023-06-15T23:49:02.575525983Z",
     "start_time": "2023-06-15T23:48:55.838135566Z"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1833/1833 [==============================] - 6s 3ms/step\n"
     ]
    },
    {
     "data": {
      "text/plain": "array([[47920,  1040],\n       [ 7219,  2475]])"
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y_true = np.argmax(y_test, axis=1)\n",
    "y_pred = np.argmax(model.predict(X_test), axis=1)\n",
    "\n",
    "confusion_matrix(y_true, y_pred)"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2023-06-15T23:54:41.732589221Z",
     "start_time": "2023-06-15T23:54:31.430328765Z"
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "**Accuracy** is a measure of how well the model predicts the correct class labels for the given data. It is defined as the ratio of the number of correct predictions to the total number of predictions. It provides an overall view of the model's performance.\n",
    "\n",
    "**Test loss**, also known as validation loss or evaluation loss, is a measure of how well the model is performing on unseen or test data. It quantifies the difference between the predicted outputs of the model and the true labels in the test set.\n",
    "\n",
    "The **precision** represents the proportion of correctly predicted positive instances out of all instances predicted as positive. It measures the model's ability to avoid false positives.\n",
    "\n",
    "The **recall**, also known as sensitivity or true positive rate, represents the proportion of correctly predicted positive instances out of all actual positive instances. It measures the model's ability to identify all positive instances.\n",
    "\n",
    "The **F1-score** is the harmonic mean of precision and recall, providing a single metric that balances both measures. It is a useful metric when you want to consider both precision and recall simultaneously."
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "              precision    recall  f1-score   support\n",
      "\n",
      "           0       0.87      0.98      0.92     48960\n",
      "           1       0.70      0.26      0.37      9694\n",
      "\n",
      "    accuracy                           0.86     58654\n",
      "   macro avg       0.79      0.62      0.65     58654\n",
      "weighted avg       0.84      0.86      0.83     58654\n",
      "\n"
     ]
    }
   ],
   "source": [
    "print(classification_report(y_true, y_pred))"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2023-06-15T23:56:00.375832987Z",
     "start_time": "2023-06-15T23:56:00.301217727Z"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [],
   "metadata": {
    "collapsed": false
   }
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}