[WIP] Feature abnormality detection

docs/discussion/spike_classification/Classifier Model Comparison with Keras Optimizers and Losses.ipynb

@@ -0,0 +1,182 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### This notebook seeks the best combination of Keras model optimizer and loss used in the fit function.\n",
+    "__Accuracy is the goal__"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import numpy as np\n",
+    "import matplotlib.pyplot as plt\n",
+    "import tensorflow as tf\n",
+    "from tqdm import tqdm\n",
+    "\n",
+    "datapath = \"./train_data_00.npz\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "with np.load(datapath) as file:\n",
+    "    labels = file['label']\n",
+    "    spikes = file['spike']\n",
+    "\n",
+    "from sklearn.utils import shuffle\n",
+    "labels, spikes = shuffle(labels, spikes)\n",
+    "\n",
+    "sample_percentage = 0.4\n",
+    "cut = int(sample_percentage*len(labels))\n",
+    "labels = labels[:cut]\n",
+    "spikes = spikes[:cut]\n",
+    "\n",
+    "split = int(len(labels) * 0.8)\n",
+    "train_labels = labels[:split]\n",
+    "train_spikes = spikes[:split]\n",
+    "test_labels = labels[split:]\n",
+    "test_spikes = spikes[split:]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "spike_length = np.shape(train_spikes)[1]\n",
+    "hidden_layer_size = spike_length\n",
+    "\n",
+    "layers = [\n",
+    "    tf.keras.layers.Dense(spike_length),\n",
+    "    tf.keras.layers.Dense(hidden_layer_size),\n",
+    "    tf.keras.layers.Dense(len(np.unique(labels)))\n",
+    "]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "optimizers = np.array([\n",
+    "    \"Adadelta\",\n",
+    "    \"Adagrad\",\n",
+    "    \"Adam\",\n",
+    "    \"Adamax\",\n",
+    "    \"Ftrl\",\n",
+    "    \"Nadam\",\n",
+    "    \"RMSprop\",\n",
+    "    \"SGD\"\n",
+    "])\n",
+    "\n",
+    "losses = np.array([\n",
+    "    \"BinaryCrossentropy\",\n",
+    "    \"BinaryFocalCrossentropy\",\n",
+    "    # \"CategoricalCrossentropy\",\n",
+    "    \"CategoricalHinge\",\n",
+    "    # \"CosineSimilarity\",\n",
+    "    \"Hinge\",\n",
+    "    \"Huber\",\n",
+    "    \"KLDivergence\",\n",
+    "    \"LogCosh\",\n",
+    "    \"MeanAbsoluteError\",\n",
+    "    \"MeanAbsolutePercentageError\",\n",
+    "    \"MeanSquaredError\",\n",
+    "    \"MeanSquaredLogarithmicError\",\n",
+    "    \"Poisson\",\n",
+    "    \"SparseCategoricalCrossentropy\",\n",
+    "    \"SquaredHinge\"\n",
+    "])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "8it [21:53, 164.22s/it]\n"
+     ]
+    }
+   ],
+   "source": [
+    "accuracies = np.ndarray((len(optimizers), len(losses)))\n",
+    "for i, optimizer in tqdm(enumerate(optimizers)):\n",
+    "    for j, loss in enumerate(losses):\n",
+    "        model = tf.keras.Sequential(layers)\n",
+    "        model.compile(\n",
+    "            optimizer=optimizer,\n",
+    "            loss=loss,\n",
+    "            metrics=[\"accuracy\"]\n",
+    "        )\n",
+    "        callback = tf.keras.callbacks.EarlyStopping(monitor=\"accuracy\", patience=1)\n",
+    "        model.fit(train_spikes, train_labels, epochs=6, callbacks=callback, verbose=0)\n",
+    "        model_loss, model_acc = model.evaluate(test_spikes, test_labels, verbose=0)\n",
+    "        accuracies[i][j] = model_acc"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Most accurate combination =  Adam + BinaryCrossentropy\n",
+      "with accuracy =  0.8470870852470398\n"
+     ]
+    }
+   ],
+   "source": [
+    "best_idx = np.argmax(accuracies)\n",
+    "best_opt_idx = int(best_idx / len(losses))\n",
+    "best_loss_idx = best_idx % len(losses)\n",
+    "print(\"Most accurate combination = \", optimizers[best_opt_idx], \"+\", losses[best_loss_idx])\n",
+    "print(\"with accuracy = \", accuracies[best_opt_idx][best_loss_idx])"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3.10.4 ('venv': venv)",
+   "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.4"
+  },
+  "orig_nbformat": 4,
+  "vscode": {
+   "interpreter": {
+    "hash": "814c8425decae4f86b0a2793668b5d1e72243fbb280f353401e2c57732588a25"
+   }
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}

docs/discussion/spike_classification/Classifier_demo.ipynb

@@ -0,0 +1,170 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "True"
+      ]
+     },
+     "execution_count": 1,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "datapath: str = \"./train_data_00.npz\"\n",
+    "import os\n",
+    "os.path.exists(datapath)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import numpy as np\n",
+    "from sklearn.utils import shuffle\n",
+    "\n",
+    "with np.load(datapath) as file:\n",
+    "    labels, spikes = shuffle(file['label'], file['spike'])\n",
+    "    sample_percentage = 1\n",
+    "    cut = int(sample_percentage*len(labels))\n",
+    "    labels = labels[:cut]\n",
+    "    spikes = spikes[:cut]\n",
+    "\n",
+    "length = len(spikes[0])\n",
+    "split = int(len(labels) * 0.8)\n",
+    "train_labels = labels[:split]\n",
+    "train_spikes = spikes[:split]\n",
+    "test_labels = labels[split:]\n",
+    "test_spikes = spikes[split:]\n",
+    "del labels\n",
+    "del spikes"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from miv.signal.classification.neuronal_spike_classification import NeuronalSpikeClassifier\n",
+    "classifier = NeuronalSpikeClassifier()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "classifier.create_default_tf_keras_model(length)\n",
+    "classifier.default_compile_model()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 19,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 1/5\n",
+      "5075/5075 [==============================] - 7s 1ms/step - loss: 1.2742 - accuracy: 0.7948\n",
+      "Epoch 2/5\n",
+      "5075/5075 [==============================] - 7s 1ms/step - loss: 0.5682 - accuracy: 0.8112\n",
+      "Epoch 3/5\n",
+      "5075/5075 [==============================] - 7s 1ms/step - loss: 0.5358 - accuracy: 0.8144\n",
+      "Epoch 4/5\n",
+      "5075/5075 [==============================] - 7s 1ms/step - loss: 0.5386 - accuracy: 0.8144\n",
+      "Epoch 5/5\n",
+      "5075/5075 [==============================] - 7s 1ms/step - loss: 0.5200 - accuracy: 0.8151\n"
+     ]
+    }
+   ],
+   "source": [
+    "classifier.default_train_model(train_spikes, train_labels)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 20,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "1269/1269 [==============================] - 1s 1ms/step\n"
+     ]
+    }
+   ],
+   "source": [
+    "predictions = classifier.predict_categories_sigmoid(test_spikes)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 21,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "array([[10144,  3851],\n",
+       "       [ 2565, 24036]], dtype=int64)"
+      ]
+     },
+     "execution_count": 21,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "classifier.get_confusion_matrix(test_spikes, test_labels)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3.10.4 ('venv': venv)",
+   "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.4"
+  },
+  "orig_nbformat": 4,
+  "vscode": {
+   "interpreter": {
+    "hash": "814c8425decae4f86b0a2793668b5d1e72243fbb280f353401e2c57732588a25"
+   }
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}

miv/core/spikestamps.py

@@ -82,3 +82,12 @@ def get_last_spikestamp(self):
     def get_first_spikestamp(self):
         """Return timestamps of the first spike in this spikestamps"""
         return min([data[0] for data in self.data if len(data) > 0])
+
+    def get_view(self, tstart: float, tend: float):
+        """Truncate array and only includes spikestamps between tstart and tend."""
+        return Spikestamps(
+            [
+                np.array(sorted(list(filter(lambda x: tstart <= x <= tend, arr))))
+                for arr in self.data
+            ]
+        )

miv/signal/classification/__init__.py

@@ -0,0 +1,3 @@
+from miv.signal.classification.abnormality_detection import *
+from miv.signal.classification.neuronal_spike_classification import *
+from miv.signal.classification.protocol import *