diff --git a/1-first-project/T_DataNormaization.ipynb b/1-first-project/T_DataNormaization.ipynb deleted file mode 100644 index ce6390d..0000000 --- a/1-first-project/T_DataNormaization.ipynb +++ /dev/null @@ -1,611 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": 1, - "id": "5d6412cd", - "metadata": {}, - "outputs": [], - "source": [ - "import pandas as pd\n", - "import numpy as np\n", - "import os\n", - "import pickle\n" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "id": "fa43325a", - "metadata": {}, - "outputs": [], - "source": [ - "delim = ';'\n", - "\n", - "user_count = 100\n", - "\n", - "base_path = '/opt/iui-datarelease1-sose2021/'\n", - "\n", - "Xpickle_file = './X.pickle'\n", - "\n", - "ypickle_file = './y.pickle'" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "id": "1ea7c2f1", - "metadata": {}, - "outputs": [], - "source": [ - "def load_pickles():\n", - " _p = open(Xpickle_file, 'rb')\n", - " X = pickle.load(_p)\n", - " _p.close()\n", - " \n", - " _p = open(ypickle_file, 'rb')\n", - " y = pickle.load(_p)\n", - " _p.close()\n", - " \n", - " return (np.asarray(X, dtype=pd.DataFrame), np.asarray(y, dtype=str))" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "id": "91f4642c", - "metadata": {}, - "outputs": [], - "source": [ - "def load_data():\n", - " if os.path.isfile(Xpickle_file) and os.path.isfile(ypickle_file):\n", - " return load_pickles()\n", - " data = []\n", - " label = []\n", - " for user in range(0, user_count):\n", - " user_path = base_path + str(user) + '/split_letters_csv/'\n", - " for file in os.listdir(user_path):\n", - " file_name = user_path + file\n", - " letter = ''.join(filter(lambda x: x.isalpha(), file))[0]\n", - " data.append(pd.read_csv(file_name, delim))\n", - " label.append(letter)\n", - " return (np.asarray(data, dtype=pd.DataFrame), np.asarray(label, dtype=str))" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "id": "a8629dc5", - "metadata": {}, - "outputs": [], - "source": [ - "X, y = load_data()" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "id": "18cd698f", - "metadata": {}, - "outputs": [], - "source": [ - "def save_pickle():\n", - "# _p = open(np.asarray(data, dtype=pd.DataFrame), 'wb')\n", - " _p = open(Xpickle_file, 'wb')\n", - " pickle.dump(X, _p)\n", - " _p.close()\n", - "\n", - "# _p = open(np.asarray(label, dtype=str), 'wb')\n", - " _p = open(ypickle_file, 'wb')\n", - " pickle.dump(y, _p)\n", - " _p.close()" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "id": "0f505920", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "(13102, 13102)" - ] - }, - "execution_count": 6, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "len(X), len(y)" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "id": "4bd9f443", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "count 13102.000000\n", - "mean 208.304457\n", - "std 206.732342\n", - "min 42.000000\n", - "50% 185.000000\n", - "90% 270.000000\n", - "91% 276.000000\n", - "92% 286.000000\n", - "93% 299.000000\n", - "94% 312.000000\n", - "95% 333.000000\n", - "96% 355.000000\n", - "97% 388.000000\n", - "98% 456.980000\n", - "99% 701.940000\n", - "max 11073.000000\n", - "dtype: float64" - ] - }, - "execution_count": 7, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "import matplotlib.pyplot as plt\n", - "\n", - "X_len = np.asarray(list(map(len, X)))\n", - "l = []\n", - "sq_xlen = pd.Series(X_len)\n", - "ptiles = [x*0.01 for x in range(100)]\n", - "for i in ptiles:\n", - " l.append(sq_xlen.quantile(i))\n", - "plt.plot(l, ptiles)\n", - "sq_xlen.describe(percentiles=[x*0.01 for x in range(90,100)])" - ] - }, - { - "cell_type": "code", - "execution_count": 49, - "id": "c535003d", - "metadata": {}, - "outputs": [], - "source": [ - "def fill(x, threshold):\n", - " fill = threshold - len(x)\n", - " xx = x\n", - " for i in range(fill):\n", - " xx = xx.append(pd.Series(0,index=x.columns,dtype='float64'), ignore_index=True)\n", - " return xx" - ] - }, - { - "cell_type": "code", - "execution_count": 56, - "id": "4ceefb7e", - "metadata": {}, - "outputs": [], - "source": [ - "threshold_p = 0.98\n", - "threshold = int(sq_xlen.quantile(threshold_p))\n", - "len_mask = np.where(X_len <= threshold)\n", - "\n", - "X_filter = X[len_mask]\n", - "y_filter = y[len_mask]" - ] - }, - { - "cell_type": "code", - "execution_count": 57, - "id": "47e7c7a4", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "CPU times: user 41min 37s, sys: 1.15 s, total: 41min 38s\n", - "Wall time: 41min 59s\n" - ] - } - ], - "source": [ - "%%time\n", - "X_filter = list(map(fill, X_filter, [threshold for i in range(len(X_filter))]))" - ] - }, - { - "cell_type": "markdown", - "id": "d6dbd88b", - "metadata": {}, - "source": [ - "Q: Is there a way to make this quicker?\n", - "\n", - "```python\n", - "X_filter = list(map(fill, X_filter, [threshold for i in range(len(X_filter))]))\n", - "```\n", - "\n", - "CPU times: user 41min 37s, sys: 1.15 s, total: 41min 38s\n", - "Wall time: 41min 59s" - ] - }, - { - "cell_type": "code", - "execution_count": 51, - "id": "5d240071", - "metadata": {}, - "outputs": [], - "source": [ - "def plot_data(data):\n", - " fig, axs = plt.subplots(4, 3, figsize=(3*3, 3*4))\n", - " t = data['Millis']\n", - " axs[0][0].plot(t, data['Acc1 X'])\n", - " axs[0][1].plot(t, data['Acc1 Y'])\n", - " axs[0][2].plot(t, data['Acc1 Z'])\n", - " axs[1][0].plot(t, data['Acc2 X'])\n", - " axs[1][1].plot(t, data['Acc2 Y'])\n", - " axs[1][2].plot(t, data['Acc2 Z'])\n", - " axs[2][0].plot(t, data['Gyro X'])\n", - " axs[2][1].plot(t, data['Gyro Y'])\n", - " axs[2][2].plot(t, data['Gyro Z'])\n", - " axs[3][0].plot(t, data['Mag X'])\n", - " axs[3][1].plot(t, data['Mag Y'])\n", - " axs[3][2].plot(t, data['Mag Z'])\n", - "\n", - " for a in axs:\n", - " for b in a:\n", - " b.plot(t, data['Force'])\n" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "id": "91db361c", - "metadata": {}, - "outputs": [], - "source": [ - "Xfiltered_pickle_file = './X_filter.pickle'\n", - "yfiltered_pickle_file = \"./y_filter.pickle\"" - ] - }, - { - "cell_type": "code", - "execution_count": 63, - "id": "c2238568", - "metadata": {}, - "outputs": [], - "source": [ - "def save_filtered():\n", - " _p = open(Xfiltered_pickle_file, 'wb')\n", - " pickle.dump(X_filter, _p)\n", - " _p.close()\n", - "\n", - " _p = open(yfiltered_pickle_file, 'wb')\n", - " pickle.dump(y_filter, _p)\n", - " _p.close()" - ] - }, - { - "cell_type": "code", - "execution_count": 64, - "id": "a234a063", - "metadata": {}, - "outputs": [], - "source": [ - "save_filtered()" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "id": "a0ae2e62", - "metadata": {}, - "outputs": [], - "source": [ - "def load_filtered_pickles():\n", - " _p = open(Xfiltered_pickle_file, 'rb')\n", - " X = pickle.load(_p)\n", - " _p.close()\n", - " \n", - " _p = open(yfiltered_pickle_file, 'rb')\n", - " y = pickle.load(_p)\n", - " _p.close()\n", - " \n", - " return (np.asarray(X, dtype=pd.DataFrame), np.asarray(y, dtype=str))" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "id": "c030d181", - "metadata": {}, - "outputs": [], - "source": [ - "XX_filtered, yy_filtered = load_filtered_pickles()" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "id": "338bddeb", - "metadata": {}, - "outputs": [], - "source": [ - "# FIRST CELL: set these variables to limit GPU usage.\n", - "import os\n", - "os.environ['TF_FORCE_GPU_ALLOW_GROWTH'] = 'true' # this is required\n", - "os.environ['CUDA_VISIBLE_DEVICES'] = '2' # set to '0' for GPU0, '1' for GPU1 or '2' for GPU2. Check \"gpustat\" in a terminal." - ] - }, - { - "cell_type": "code", - "execution_count": 57, - "id": "57ce2aa7", - "metadata": {}, - "outputs": [], - "source": [ - "from sklearn.model_selection import train_test_split\n", - "from sklearn.preprocessing import LabelEncoder\n", - "\n", - "le = LabelEncoder()\n", - "yyt_filtered = le.fit_transform(yy_filtered)\n", - "XX_filtered = np.asarray(XX_filtered).astype('float64')\n", - "XXX_filtered = np.delete(np.delete(XX_filtered, 0, 2), 13,2)" - ] - }, - { - "cell_type": "code", - "execution_count": 59, - "id": "deecd898", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "(10271, 456, 13)\n", - "(2568, 456, 13)\n", - "(10271,)\n", - "(2568,)\n" - ] - } - ], - "source": [ - "X_train, X_test, y_train, y_test = train_test_split(XXX_filtered, yyt_filtered, test_size=0.2, random_state=177013)\n", - "\n", - "print(X_train.shape)\n", - "print(X_test.shape)\n", - "print(y_train.shape)\n", - "print(y_test.shape)" - ] - }, - { - "cell_type": "code", - "execution_count": 77, - "id": "8fd1a79c", - "metadata": {}, - "outputs": [], - "source": [ - "import tensorflow as tf\n", - "from tensorflow.keras.models import Sequential\n", - "from tensorflow.keras.layers import Dense, Dropout, Activation, Flatten, Conv1D, MaxPooling1D\n", - "\n", - "model = Sequential()\n", - "\n", - "# model.add(Conv1D(32, 3, input_shape = X_train.shape[1:]))\n", - "# model.add(Activation('relu'))\n", - "# model.add(MaxPooling1D(pool_size=3))\n", - "\n", - "# model.add(Conv1D(32, 3))\n", - "# model.add(Activation('relu'))\n", - "# model.add(MaxPooling1D(pool_size=3))\n", - "\n", - "model.add(Flatten())\n", - "model.add(Dense(456, activation='relu', input_shape=(456,13)))\n", - "\n", - "model.add(Dense(104))\n", - "\n", - "model.add(Dense(26))\n", - "model.add(Activation('sigmoid'))\n", - "\n", - "model.compile(\n", - " optimizer=tf.keras.optimizers.Adam(0.001),\n", - " loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True),\n", - " metrics=[tf.keras.metrics.SparseCategoricalAccuracy()],\n", - ")" - ] - }, - { - "cell_type": "code", - "execution_count": 78, - "id": "0562e920", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "array(['K', 'T', 'U', ..., 'F', 'H', 'G'], dtype='" - ] - }, - "execution_count": 80, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "model.fit(X_train, y_train, \n", - " epochs=10,\n", - " batch_size=32,\n", - " verbose=1\n", - " )" - ] - }, - { - "cell_type": "code", - "execution_count": 81, - "id": "8c1f64b6", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Evaluate on test data\n", - "81/81 [==============================] - 0s 1ms/step - loss: 11.4346 - sparse_categorical_accuracy: 0.0312\n", - "test loss, test acc: [11.434555053710938, 0.031152648851275444]\n", - "Generate predictions for 3 samples\n", - "predictions shape: (3, 26)\n" - ] - }, - { - "data": { - "text/plain": [ - "(array(['K', 'T', 'U'], dtype='" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "fig, axs = plt.subplots(13,2,figsize=(20, 60), sharey=True)\n", "\n", @@ -120,6 +107,8 @@ " except:\n", " continue\n", " f = ex_letter['Force']\n", + " f_short = shorten(f)\n", + " \n", " idx = (f > 100) | (f == 0)\n", " f=f[idx]\n", " t=ex_letter['Millis']-ex_letter['Millis'][0]\n", @@ -132,7 +121,7 @@ { "cell_type": "code", "execution_count": 6, - "id": "c64567f3", + "id": "d62de263", "metadata": {}, "outputs": [ { @@ -193,7 +182,7 @@ { "cell_type": "code", "execution_count": 7, - "id": "805bd8b3", + "id": "12151db8", "metadata": {}, "outputs": [ { @@ -254,7 +243,7 @@ { "cell_type": "code", "execution_count": 8, - "id": "8c57c805", + "id": "812b1b32", "metadata": {}, "outputs": [ { @@ -315,7 +304,7 @@ { "cell_type": "code", "execution_count": 9, - "id": "7135ee25", + "id": "8eddc349", "metadata": {}, "outputs": [], "source": [ diff --git a/1-first-project/tdt/NeuralNetwork.ipynb b/1-first-project/tdt/NeuralNetwork.ipynb new file mode 100644 index 0000000..eb977da --- /dev/null +++ b/1-first-project/tdt/NeuralNetwork.ipynb @@ -0,0 +1,587 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "72824b57", + "metadata": {}, + "outputs": [], + "source": [ + "import pandas as pd\n", + "import numpy as np\n", + "import os\n", + "import pickle\n" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "39347ed0", + "metadata": {}, + "outputs": [], + "source": [ + "delim = ';'\n", + "\n", + "base_path = '/opt/iui-datarelease1-sose2021/'\n", + "\n", + "Xpickle_file = './X.pickle'\n", + "\n", + "ypickle_file = './y.pickle'" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "b2701ff7", + "metadata": {}, + "outputs": [], + "source": [ + "def shorten(npList):\n", + " temp = npList['Force']\n", + " thresh = 100\n", + " leeway = 5\n", + " \n", + " temps_over_T = np.where(temp > thresh)[0]\n", + " return npList[max(temps_over_T[0]-leeway,0):temps_over_T[-1]+leeway]" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "8734cc9c", + "metadata": {}, + "outputs": [], + "source": [ + "def load_pickles():\n", + " _p = open(Xpickle_file, 'rb')\n", + " X = pickle.load(_p)\n", + " _p.close()\n", + " \n", + " _p = open(ypickle_file, 'rb')\n", + " y = pickle.load(_p)\n", + " _p.close()\n", + " \n", + " return (np.asarray(X, dtype=pd.DataFrame), np.asarray(y, dtype=str))" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "36140ad8", + "metadata": {}, + "outputs": [], + "source": [ + "def load_data():\n", + " if os.path.isfile(Xpickle_file) and os.path.isfile(ypickle_file):\n", + " return load_pickles()\n", + " data = []\n", + " label = []\n", + " for user in range(0, user_count):\n", + " user_path = base_path + str(user) + '/split_letters_csv/'\n", + " for file in os.listdir(user_path):\n", + " file_name = user_path + file\n", + " letter = ''.join(filter(lambda x: x.isalpha(), file))[0]\n", + " data.append(pd.read_csv(file_name, delim))\n", + " label.append(letter)\n", + " return (np.asarray(data, dtype=pd.DataFrame), np.asarray(label, dtype=str), np.asarray(file_name))" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "7cfdcb24", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "CPU times: user 2.85 s, sys: 180 ms, total: 3.03 s\n", + "Wall time: 3.03 s\n" + ] + }, + { + "data": { + "text/plain": [ + "dtype('O')" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "%%time\n", + "X, y = load_data()\n", + "\n", + "X.dtype" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "86e11944", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "CPU times: user 3.12 s, sys: 13.7 ms, total: 3.13 s\n", + "Wall time: 3.13 s\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + ":1: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray\n" + ] + } + ], + "source": [ + "%%time\n", + "XX = np.array(list(map(shorten, X)))\n" + ] + }, + { + "cell_type": "markdown", + "id": "61730420", + "metadata": {}, + "source": [ + "**How to fix this error**:\n", + "```python\n", + ":1: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray\n", + "```\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "70463f61", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "count 13102.000000\n", + "mean 61.169058\n", + "std 30.698514\n", + "min 10.000000\n", + "50% 57.000000\n", + "95% 102.000000\n", + "96% 107.000000\n", + "97% 113.000000\n", + "98% 127.000000\n", + "99% 156.000000\n", + "max 1522.000000\n", + "dtype: float64" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "\n", + "X_len = np.asarray(list(map(len, XX)))\n", + "l = []\n", + "sq_xlen = pd.Series(X_len)\n", + "ptiles = [x*0.01 for x in range(100)]\n", + "for i in ptiles:\n", + " l.append(sq_xlen.quantile(i))\n", + "plt.plot(l, ptiles)\n", + "sq_xlen.describe(percentiles=[x*0.01 for x in range(95,100)])" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "5f8f9a54", + "metadata": {}, + "outputs": [], + "source": [ + "def plot_data(data):\n", + " fig, axs = plt.subplots(4, 3, figsize=(3*3, 3*4))\n", + " t = data['Millis']\n", + " axs[0][0].plot(t, data['Acc1 X'])\n", + " axs[0][1].plot(t, data['Acc1 Y'])\n", + " axs[0][2].plot(t, data['Acc1 Z'])\n", + " axs[1][0].plot(t, data['Acc2 X'])\n", + " axs[1][1].plot(t, data['Acc2 Y'])\n", + " axs[1][2].plot(t, data['Acc2 Z'])\n", + " axs[2][0].plot(t, data['Gyro X'])\n", + " axs[2][1].plot(t, data['Gyro Y'])\n", + " axs[2][2].plot(t, data['Gyro Z'])\n", + " axs[3][0].plot(t, data['Mag X'])\n", + " axs[3][1].plot(t, data['Mag Y'])\n", + " axs[3][2].plot(t, data['Mag Z'])\n", + "\n", + " for a in axs:\n", + " for b in a:\n", + " b.plot(t, data['Force'])\n" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "43ab9479", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "((12974,), (72, 15))" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "threshold_p = 0.99\n", + "threshold = int(sq_xlen.quantile(threshold_p))\n", + "len_mask = np.where(X_len <= threshold)\n", + "\n", + "X_filter = XX[len_mask]\n", + "y_filter = y[len_mask]\n", + "\n", + "X_filter.shape, X_filter[0].shape" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "79d289f8", + "metadata": {}, + "outputs": [], + "source": [ + "from tensorflow.keras.preprocessing.sequence import pad_sequences\n", + "a = [x.drop(labels='Millis', axis=1) for x in X_filter]" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "3116fea9", + "metadata": {}, + "outputs": [], + "source": [ + "X_filter = pad_sequences(X_filter, dtype=float, padding='post')" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "b21f19f1", + "metadata": {}, + "outputs": [], + "source": [ + "def plot_data(data):\n", + " fig, axs = plt.subplots(5, 3, figsize=(3*3, 3*5))\n", + " axs[0][0].plot(data[0])\n", + " axs[0][1].plot(data[1])\n", + " axs[0][2].plot(data[2])\n", + " axs[1][0].plot(data[3])\n", + " axs[1][1].plot(data[4])\n", + " axs[1][2].plot(data[5])\n", + " axs[2][0].plot(data[6])\n", + " axs[2][1].plot(data[7])\n", + " axs[2][2].plot(data[8])\n", + " axs[3][0].plot(data[9])\n", + " axs[3][1].plot(data[10])\n", + " axs[3][2].plot(data[11])\n", + " axs[4][0].plot(data[12])\n", + " axs[4][1].plot(data[13])\n", + "\n", + "# for a in axs:\n", + "# for b in a:\n", + "# b.plot(t, data['Force'])\n" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "e4eeb3fb", + "metadata": {}, + "outputs": [], + "source": [ + "from sklearn.model_selection import train_test_split\n", + "from sklearn.preprocessing import LabelEncoder, LabelBinarizer\n", + "import tensorflow as tf\n", + "\n", + "lb = LabelBinarizer()\n", + "\n", + "yt_filter = lb.fit_transform(y_filter)" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "208ba84f", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(10379, 156, 15)\n", + "(2595, 156, 15)\n", + "(10379, 26)\n", + "(2595, 26)\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "X_train, X_test, y_train, y_test = train_test_split(X_filter, yt_filter, test_size=0.2, random_state=177013)\n", + "\n", + "print(X_train.shape)\n", + "print(X_test.shape)\n", + "print(y_train.shape)\n", + "print(y_test.shape)\n", + "\n", + "plot_data(X_filter[0].T)" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "1e62d471", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Model: \"sequential\"\n", + "_________________________________________________________________\n", + "Layer (type) Output Shape Param # \n", + "=================================================================\n", + "flatten (Flatten) (None, 2340) 0 \n", + "_________________________________________________________________\n", + "batch_normalization (BatchNo (None, 2340) 9360 \n", + "_________________________________________________________________\n", + "dense (Dense) (None, 1560) 3651960 \n", + "_________________________________________________________________\n", + "dense_1 (Dense) (None, 750) 1170750 \n", + "_________________________________________________________________\n", + "dense_2 (Dense) (None, 300) 225300 \n", + "_________________________________________________________________\n", + "dense_3 (Dense) (None, 156) 46956 \n", + "_________________________________________________________________\n", + "dense_4 (Dense) (None, 26) 4082 \n", + "=================================================================\n", + "Total params: 5,108,408\n", + "Trainable params: 5,103,728\n", + "Non-trainable params: 4,680\n", + "_________________________________________________________________\n" + ] + } + ], + "source": [ + "import tensorflow as tf\n", + "from tensorflow.keras.models import Sequential\n", + "from tensorflow.keras.layers import Dense, Flatten, BatchNormalization\n", + "\n", + "model = Sequential()\n", + "\n", + "model.add(Flatten(input_shape=X_filter[0].shape))\n", + "\n", + "model.add(BatchNormalization())\n", + "\n", + "model.add(Dense(1560, activation='relu'))\n", + "\n", + "model.add(Dense(750, activation='relu'))\n", + "\n", + "model.add(Dense(300, activation='relu'))\n", + "\n", + "model.add(Dense(156, activation='relu'))\n", + "\n", + "model.add(Dense(26, activation='softmax'))\n", + "\n", + "model.compile(\n", + " optimizer=tf.keras.optimizers.Adam(0.001),\n", + " loss=\"categorical_crossentropy\", \n", + " metrics=[\"acc\"],\n", + ")\n", + "\n", + "model.summary()" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "b96c3949", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 1/20\n", + "163/163 [==============================] - 2s 5ms/step - loss: 2.8784 - acc: 0.1653\n", + "Epoch 2/20\n", + "163/163 [==============================] - 1s 5ms/step - loss: 1.7234 - acc: 0.4614\n", + "Epoch 3/20\n", + "163/163 [==============================] - 1s 5ms/step - loss: 1.2611 - acc: 0.6031\n", + "Epoch 4/20\n", + "163/163 [==============================] - 1s 5ms/step - loss: 1.0061 - acc: 0.6808\n", + "Epoch 5/20\n", + "163/163 [==============================] - 1s 5ms/step - loss: 0.8373 - acc: 0.7270\n", + "Epoch 6/20\n", + "163/163 [==============================] - 1s 5ms/step - loss: 0.6859 - acc: 0.7840\n", + "Epoch 7/20\n", + "163/163 [==============================] - 1s 5ms/step - loss: 0.5785 - acc: 0.8184\n", + "Epoch 8/20\n", + "163/163 [==============================] - 1s 5ms/step - loss: 0.4920 - acc: 0.8397\n", + "Epoch 9/20\n", + "163/163 [==============================] - 1s 5ms/step - loss: 0.4323 - acc: 0.8656\n", + "Epoch 10/20\n", + "163/163 [==============================] - 1s 5ms/step - loss: 0.3502 - acc: 0.8835\n", + "Epoch 11/20\n", + "163/163 [==============================] - 1s 5ms/step - loss: 0.3350 - acc: 0.8944\n", + "Epoch 12/20\n", + "163/163 [==============================] - 1s 5ms/step - loss: 0.3153 - acc: 0.8988\n", + "Epoch 13/20\n", + "163/163 [==============================] - 1s 5ms/step - loss: 0.2819 - acc: 0.9111\n", + "Epoch 14/20\n", + "163/163 [==============================] - 1s 5ms/step - loss: 0.2570 - acc: 0.9226\n", + "Epoch 15/20\n", + "163/163 [==============================] - 1s 5ms/step - loss: 0.2015 - acc: 0.9391\n", + "Epoch 16/20\n", + "163/163 [==============================] - 1s 5ms/step - loss: 0.2004 - acc: 0.9356\n", + "Epoch 17/20\n", + "163/163 [==============================] - 1s 5ms/step - loss: 0.2012 - acc: 0.9384\n", + "Epoch 18/20\n", + "163/163 [==============================] - 1s 5ms/step - loss: 0.1925 - acc: 0.9395\n", + "Epoch 19/20\n", + "163/163 [==============================] - 1s 5ms/step - loss: 0.1806 - acc: 0.9462\n", + "Epoch 20/20\n", + "163/163 [==============================] - 1s 5ms/step - loss: 0.1956 - acc: 0.9411\n" + ] + }, + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 17, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "model.fit(X_train, y_train, \n", + " epochs=20,\n", + " batch_size=64,\n", + " shuffle=True,\n", + " verbose=1\n", + " )" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "dd31d2de", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Evaluate on test data\n", + "82/82 [==============================] - 0s 3ms/step - loss: 1.4249 - acc: 0.7299\n", + "test loss, test acc: [1.424863576889038, 0.7298651337623596]\n", + "Generate predictions for 3 samples\n", + "predictions shape: (3, 26)\n" + ] + }, + { + "data": { + "text/plain": [ + "(array(['N', 'U', 'I'], dtype='" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "\n", + "X_len = np.asarray(list(map(len, X)))\n", + "l = []\n", + "sq_xlen = pd.Series(X_len)\n", + "ptiles = [x*0.01 for x in range(100)]\n", + "for i in ptiles:\n", + " l.append(sq_xlen.quantile(i))\n", + "plt.plot(l, ptiles)\n", + "sq_xlen.describe(percentiles=[x*0.01 for x in range(90,100)])" + ] + }, + { + "cell_type": "code", + "execution_count": 49, + "id": "f687916d", + "metadata": {}, + "outputs": [], + "source": [ + "def fill(x, threshold):\n", + " fill = threshold - len(x)\n", + " xx = x\n", + " for i in range(fill):\n", + " xx = xx.append(pd.Series(0,index=x.columns,dtype='float64'), ignore_index=True)\n", + " return xx" + ] + }, + { + "cell_type": "code", + "execution_count": 56, + "id": "fd5700dc", + "metadata": {}, + "outputs": [], + "source": [ + "threshold_p = 0.98\n", + "threshold = int(sq_xlen.quantile(threshold_p))\n", + "len_mask = np.where(X_len <= threshold)\n", + "\n", + "X_filter = X[len_mask]\n", + "y_filter = y[len_mask]" + ] + }, + { + "cell_type": "code", + "execution_count": 57, + "id": "84081ad4", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "CPU times: user 41min 37s, sys: 1.15 s, total: 41min 38s\n", + "Wall time: 41min 59s\n" + ] + } + ], + "source": [ + "%%time\n", + "X_filter = list(map(fill, X_filter, [threshold for i in range(len(X_filter))]))" + ] + }, + { + "cell_type": "code", + "execution_count": 51, + "id": "d757bb26", + "metadata": {}, + "outputs": [], + "source": [ + "def plot_data(data):\n", + " fig, axs = plt.subplots(4, 3, figsize=(3*3, 3*4))\n", + " t = data['Millis']\n", + " axs[0][0].plot(t, data['Acc1 X'])\n", + " axs[0][1].plot(t, data['Acc1 Y'])\n", + " axs[0][2].plot(t, data['Acc1 Z'])\n", + " axs[1][0].plot(t, data['Acc2 X'])\n", + " axs[1][1].plot(t, data['Acc2 Y'])\n", + " axs[1][2].plot(t, data['Acc2 Z'])\n", + " axs[2][0].plot(t, data['Gyro X'])\n", + " axs[2][1].plot(t, data['Gyro Y'])\n", + " axs[2][2].plot(t, data['Gyro Z'])\n", + " axs[3][0].plot(t, data['Mag X'])\n", + " axs[3][1].plot(t, data['Mag Y'])\n", + " axs[3][2].plot(t, data['Mag Z'])\n", + "\n", + " for a in axs:\n", + " for b in a:\n", + " b.plot(t, data['Force'])\n" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "14fc3f15", + "metadata": {}, + "outputs": [], + "source": [ + "Xfiltered_pickle_file = './X_filter.pickle'\n", + "yfiltered_pickle_file = \"./y_filter.pickle\"" + ] + }, + { + "cell_type": "code", + "execution_count": 63, + "id": "26261cc2", + "metadata": {}, + "outputs": [], + "source": [ + "def save_filtered():\n", + " _p = open(Xfiltered_pickle_file, 'wb')\n", + " pickle.dump(X_filter, _p)\n", + " _p.close()\n", + "\n", + " _p = open(yfiltered_pickle_file, 'wb')\n", + " pickle.dump(y_filter, _p)\n", + " _p.close()" + ] + }, + { + "cell_type": "code", + "execution_count": 64, + "id": "a24e9dd2", + "metadata": {}, + "outputs": [], + "source": [ + "save_filtered()" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "b4710358", + "metadata": {}, + "outputs": [], + "source": [ + "def load_filtered_pickles():\n", + " _p = open(Xfiltered_pickle_file, 'rb')\n", + " X = pickle.load(_p)\n", + " _p.close()\n", + " \n", + " _p = open(yfiltered_pickle_file, 'rb')\n", + " y = pickle.load(_p)\n", + " _p.close()\n", + " \n", + " return (np.asarray(X, dtype=pd.DataFrame), np.asarray(y, dtype=str))" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "7a9b0d8b", + "metadata": {}, + "outputs": [], + "source": [ + "XX_filtered, yy_filtered = load_filtered_pickles()" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "6d04f333", + "metadata": {}, + "outputs": [], + "source": [ + "# FIRST CELL: set these variables to limit GPU usage.\n", + "import os\n", + "os.environ['TF_FORCE_GPU_ALLOW_GROWTH'] = 'true' # this is required\n", + "os.environ['CUDA_VISIBLE_DEVICES'] = '2' # set to '0' for GPU0, '1' for GPU1 or '2' for GPU2. Check \"gpustat\" in a terminal." + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "096a2e4c", + "metadata": {}, + "outputs": [], + "source": [ + "from sklearn.model_selection import train_test_split\n", + "from sklearn.preprocessing import LabelEncoder, LabelBinarizer\n", + "import tensorflow as tf\n", + "\n", + "lb = LabelBinarizer()\n", + "\n", + "yyt_filtered = lb.fit_transform(yy_filtered)\n", + "XX_filtered = np.asarray(XX_filtered).astype('float64')\n", + "XXX_filtered = np.delete(XX_filtered, 0, 2)" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "ec34736a", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(10271, 456, 14)\n", + "(2568, 456, 14)\n", + "(10271, 26)\n", + "(2568, 26)\n" + ] + } + ], + "source": [ + "X_train, X_test, y_train, y_test = train_test_split(XXX_filtered, yyt_filtered, test_size=0.2, random_state=177013)\n", + "\n", + "print(X_train.shape)\n", + "print(X_test.shape)\n", + "print(y_train.shape)\n", + "print(y_test.shape)" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "id": "c467d4db", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Model: \"sequential_3\"\n", + "_________________________________________________________________\n", + "Layer (type) Output Shape Param # \n", + "=================================================================\n", + "flatten_3 (Flatten) (None, 6384) 0 \n", + "_________________________________________________________________\n", + "dense_6 (Dense) (None, 456) 2911560 \n", + "_________________________________________________________________\n", + "dense_7 (Dense) (None, 26) 11882 \n", + "=================================================================\n", + "Total params: 2,923,442\n", + "Trainable params: 2,923,442\n", + "Non-trainable params: 0\n", + "_________________________________________________________________\n" + ] + } + ], + "source": [ + "from tensorflow.keras.models import Sequential\n", + "from tensorflow.keras.layers import Dense, Dropout, Activation, Flatten, Conv1D, MaxPooling1D\n", + "\n", + "model = Sequential()\n", + "\n", + "# model.add(Conv1D(32, 3, input_shape = X_train.shape[1:]))\n", + "# model.add(Activation('relu'))\n", + "# model.add(MaxPooling1D(pool_size=3))\n", + "\n", + "# model.add(Conv1D(32, 3))\n", + "# model.add(Activation('relu'))\n", + "# model.add(MaxPooling1D(pool_size=3))\n", + "\n", + "model.add(Flatten(input_shape=(456,14)))\n", + "\n", + "model.add(Dense(456, activation='relu'))\n", + "\n", + "model.add(Dense(26, activation='softmax'))\n", + "\n", + "model.compile(\n", + " optimizer=tf.keras.optimizers.Adam(0.001),\n", + " loss=\"categorical_crossentropy\", \n", + " metrics=[\"acc\"],\n", + ")\n", + "\n", + "model.summary()" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "id": "ce568e2b", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "((10271, 456, 14), (10271, 26))" + ] + }, + "execution_count": 27, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "X_train.shape, y_train.shape" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "id": "b607aa96", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 1/10\n", + "161/161 [==============================] - 1s 2ms/step - loss: 8658.2280 - acc: 0.0409\n", + "Epoch 2/10\n", + "161/161 [==============================] - 0s 2ms/step - loss: 26.3454 - acc: 0.0447\n", + "Epoch 3/10\n", + "161/161 [==============================] - 0s 2ms/step - loss: 10.9452 - acc: 0.0422\n", + "Epoch 4/10\n", + "161/161 [==============================] - 0s 2ms/step - loss: 3.9099 - acc: 0.0437\n", + "Epoch 5/10\n", + "161/161 [==============================] - 0s 2ms/step - loss: 3.5461 - acc: 0.0474\n", + "Epoch 6/10\n", + "161/161 [==============================] - 0s 2ms/step - loss: 4.2588 - acc: 0.0423\n", + "Epoch 7/10\n", + "161/161 [==============================] - 0s 2ms/step - loss: 3.3213 - acc: 0.0414\n", + "Epoch 8/10\n", + "161/161 [==============================] - 0s 2ms/step - loss: 3.2681 - acc: 0.0451\n", + "Epoch 9/10\n", + "161/161 [==============================] - 0s 2ms/step - loss: 3.2482 - acc: 0.0422\n", + "Epoch 10/10\n", + "161/161 [==============================] - 0s 2ms/step - loss: 3.2693 - acc: 0.0435\n" + ] + }, + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 28, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "model.fit(X_train, y_train, \n", + " epochs=10,\n", + " batch_size=64,\n", + " shuffle=True,\n", + " verbose=1\n", + " )" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "id": "eed818c0", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Evaluate on test data\n", + "81/81 [==============================] - 0s 2ms/step - loss: 19.9920 - acc: 0.0331\n", + "test loss, test acc: [19.992048263549805, 0.033099688589572906]\n", + "Generate predictions for 3 samples\n", + "predictions shape: (3, 26)\n" + ] + }, + { + "data": { + "text/plain": [ + "(array(['K', 'T', 'U'], dtype='" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "fig, axs = plt.subplots(13,2,figsize=(20, 60), sharey=True)\n", + "for i,j in zip(XXX_filtered, yy_filtered):\n", + " num = ord(j) - 64\n", + " f = i.T[12]\n", + " r = int((num-1)/2)%13\n", + " c = (num-1)%2\n", + " axs[r][c].title.set_text(f'{j}')\n", + " axs[r][c].plot(f)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "a0e1cee4", + "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.8.5" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/1-first-project/X.pickle b/1-first-project/tdt/X.pickle similarity index 100% rename from 1-first-project/X.pickle rename to 1-first-project/tdt/X.pickle diff --git a/1-first-project/X_filter.pickle b/1-first-project/tdt/X_filter.pickle similarity index 100% rename from 1-first-project/X_filter.pickle rename to 1-first-project/tdt/X_filter.pickle diff --git a/1-first-project/y.pickle b/1-first-project/tdt/y.pickle similarity index 100% rename from 1-first-project/y.pickle rename to 1-first-project/tdt/y.pickle diff --git a/1-first-project/y_filter.pickle b/1-first-project/tdt/y_filter.pickle similarity index 100% rename from 1-first-project/y_filter.pickle rename to 1-first-project/tdt/y_filter.pickle diff --git a/1-first-project/ten_force_entries_all_alphs.png b/1-first-project/ten_force_entries_all_alphs.png deleted file mode 100644 index 23ed759..0000000 Binary files a/1-first-project/ten_force_entries_all_alphs.png and /dev/null differ diff --git a/1-first-project/u1_Acc_all_alphs.png b/1-first-project/u1_Acc_all_alphs.png deleted file mode 100644 index b70ef4b..0000000 Binary files a/1-first-project/u1_Acc_all_alphs.png and /dev/null differ diff --git a/1-first-project/u1_Gyro_all_alphs.png b/1-first-project/u1_Gyro_all_alphs.png deleted file mode 100644 index 9ac8cfe..0000000 Binary files a/1-first-project/u1_Gyro_all_alphs.png and /dev/null differ diff --git a/1-first-project/u1_Mag_all_alphs.png b/1-first-project/u1_Mag_all_alphs.png deleted file mode 100644 index 02553d2..0000000 Binary files a/1-first-project/u1_Mag_all_alphs.png and /dev/null differ