diff --git a/.gitignore b/.gitignore index 1b46987..dd70090 100644 --- a/.gitignore +++ b/.gitignore @@ -1,2 +1,12 @@ .ipynb_checkpoints ___* +neuraxle/** +steps/__pycache__/** +savers/__pycache__/** +__pycache__/** +.idea/** +steps/one_hot_encoder.py +steps/transform_expected_output_only_wrapper.py +venv/** +cache/** +neuraxle_tensorflow/** diff --git a/1_train_and_save_LSTM.ipynb b/1_train_and_save_LSTM.ipynb new file mode 100644 index 0000000..55cf140 --- /dev/null +++ b/1_train_and_save_LSTM.ipynb @@ -0,0 +1,527 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Imports" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import tensorflow as tf\n", + "from neuraxle.api import DeepLearningPipeline\n", + "from neuraxle.base import ExecutionContext, DEFAULT_CACHE_FOLDER\n", + "from neuraxle.hyperparams.space import HyperparameterSamples\n", + "from neuraxle.pipeline import Pipeline\n", + "from neuraxle.steps.numpy import OneHotEncoder\n", + "from neuraxle.steps.output_handlers import OutputTransformerWrapper\n", + "\n", + "from data_reading import load_data\n", + "from neuraxle_tensorflow.tensorflow_v1 import TensorflowV1ModelStep\n", + "from plotting import plot_metric\n", + "from steps.forma_data import FormatData" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Load Data" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Some useful info to get an insight on dataset's shape and normalisation:\n", + "(data_inputs shape, expected_outputs shape, every data input mean, every data input standard deviation)\n", + "(7352, 128, 9) (7352, 1) 0.10206611 0.40216514\n", + "The dataset is therefore properly normalised, as expected, but not yet one-hot encoded.\n" + ] + } + ], + "source": [ + "data_inputs, expected_outputs = load_data()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Create LSTM RNN Tensorflow Graph" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "def create_graph(step: TensorflowV1ModelStep):\n", + " # Function returns a tensorflow LSTM (RNN) artificial neural network from given parameters.\n", + " # Moreover, two LSTM cells are stacked which adds deepness to the neural network.\n", + " # Note, some code of this notebook is inspired from an slightly different\n", + " # RNN architecture used on another dataset, some of the credits goes to\n", + " # \"aymericdamien\" under the MIT license.\n", + " # (NOTE: This step could be greatly optimised by shaping the dataset once\n", + " # input shape: (batch_size, n_steps, n_input)\n", + "\n", + " # Graph input/output\n", + " data_inputs = tf.placeholder(tf.float32, [None, step.hyperparams['n_steps'], step.hyperparams['n_inputs']],\n", + " name='data_inputs')\n", + " expected_outputs = tf.placeholder(tf.float32, [None, step.hyperparams['n_classes']], name='expected_outputs')\n", + "\n", + " # Graph weights\n", + " weights = {\n", + " 'hidden': tf.Variable(\n", + " tf.random_normal([step.hyperparams['n_inputs'], step.hyperparams['n_hidden']])\n", + " ), # Hidden layer weights\n", + " 'out': tf.Variable(\n", + " tf.random_normal([step.hyperparams['n_hidden'], step.hyperparams['n_classes']], mean=1.0)\n", + " )\n", + " }\n", + "\n", + " biases = {\n", + " 'hidden': tf.Variable(\n", + " tf.random_normal([step.hyperparams['n_hidden']])\n", + " ),\n", + " 'out': tf.Variable(\n", + " tf.random_normal([step.hyperparams['n_classes']])\n", + " )\n", + " }\n", + "\n", + " data_inputs = tf.transpose(\n", + " data_inputs,\n", + " [1, 0, 2]) # permute n_steps and batch_size\n", + "\n", + " # Reshape to prepare input to hidden activation\n", + " data_inputs = tf.reshape(data_inputs, [-1, step.hyperparams['n_inputs']])\n", + " # new shape: (n_steps*batch_size, n_input)\n", + "\n", + " # ReLU activation, thanks to Yu Zhao for adding this improvement here:\n", + " _X = tf.nn.relu(\n", + " tf.matmul(data_inputs, weights['hidden']) + biases['hidden']\n", + " )\n", + "\n", + " # Split data because rnn cell needs a list of inputs for the RNN inner loop\n", + " _X = tf.split(_X, step.hyperparams['n_steps'], 0)\n", + " # new shape: n_steps * (batch_size, n_hidden)\n", + "\n", + " # Define two stacked LSTM cells (two recurrent layers deep) with tensorflow\n", + " lstm_cell_1 = tf.contrib.rnn.BasicLSTMCell(step.hyperparams['n_hidden'], forget_bias=1.0, state_is_tuple=True)\n", + " lstm_cell_2 = tf.contrib.rnn.BasicLSTMCell(step.hyperparams['n_hidden'], forget_bias=1.0, state_is_tuple=True)\n", + " lstm_cells = tf.contrib.rnn.MultiRNNCell([lstm_cell_1, lstm_cell_2], state_is_tuple=True)\n", + "\n", + " # Get LSTM cell output\n", + " outputs, states = tf.contrib.rnn.static_rnn(lstm_cells, _X, dtype=tf.float32)\n", + "\n", + " # Get last time step's output feature for a \"many-to-one\" style classifier,\n", + " # as in the image describing RNNs at the top of this page\n", + " lstm_last_output = outputs[-1]\n", + "\n", + " # Linear activation\n", + " return tf.matmul(lstm_last_output, weights['out']) + biases['out']" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Create Optimizer" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "def create_optimizer(step: TensorflowV1ModelStep):\n", + " return tf.train.AdamOptimizer(learning_rate=step.hyperparams['learning_rate'])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Create Loss" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "def create_loss(step: TensorflowV1ModelStep):\n", + " # Loss, optimizer and evaluation\n", + " # L2 loss prevents this overkill neural network to overfit the data\n", + " l2 = step.hyperparams['lambda_loss_amount'] * sum(tf.nn.l2_loss(tf_var) for tf_var in tf.trainable_variables())\n", + "\n", + " # Softmax loss\n", + " return tf.reduce_mean(\n", + " tf.nn.softmax_cross_entropy_with_logits(\n", + " labels=step['expected_outputs'],\n", + " logits=step['output']\n", + " )\n", + " ) + l2" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Create Neuraxle Pipeline " + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "class HumanActivityRecognitionPipeline(Pipeline):\n", + " N_HIDDEN = 32\n", + " N_STEPS = 128\n", + " N_INPUTS = 9\n", + " LAMBDA_LOSS_AMOUNT = 0.0015\n", + " LEARNING_RATE = 0.0025\n", + " N_CLASSES = 6\n", + " BATCH_SIZE = 1500\n", + " EPOCHS = 14\n", + "\n", + " def __init__(self):\n", + " super().__init__([\n", + " OutputTransformerWrapper(OneHotEncoder(nb_columns=self.N_CLASSES, name='one_hot_encoded_label')),\n", + " FormatData(n_classes=self.N_CLASSES),\n", + " TensorflowV1ModelStep(\n", + " create_graph=create_graph,\n", + " create_loss=create_loss,\n", + " create_optimizer=create_optimizer\n", + " ).set_hyperparams(\n", + " HyperparameterSamples({\n", + " 'n_steps': self.N_STEPS, # 128 timesteps per series\n", + " 'n_inputs': self.N_INPUTS, # 9 input parameters per timestep\n", + " 'n_hidden': self.N_HIDDEN, # Hidden layer num of features\n", + " 'n_classes': self.N_CLASSES, # Total classes (should go up, or should go down)\n", + " 'learning_rate': self.LEARNING_RATE,\n", + " 'lambda_loss_amount': self.LAMBDA_LOSS_AMOUNT,\n", + " 'batch_size': self.BATCH_SIZE\n", + " })\n", + " )\n", + " ])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Create scoring metric" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "def accuracy_score_classification(data_inputs, expected_outputs):\n", + " accuracy = np.mean(np.argmax(data_inputs, axis=1) == np.argmax(expected_outputs, axis=1))\n", + " return accuracy" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Create deep learning pipeline" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": { + "scrolled": false + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/alexandre/Documents/LSTM-Human-Activity-Recognition/venv/src/neuraxle/neuraxle/pipeline.py:347: UserWarning: Replacing MiniBatchSequentialPipeline[Joiner].batch_size by MiniBatchSequentialPipeline.batch_size.\n", + " 'Replacing {}[{}].batch_size by {}.batch_size.'.format(self.name, step.name, self.name))\n" + ] + } + ], + "source": [ + "pipeline = DeepLearningPipeline(\n", + " HumanActivityRecognitionPipeline(),\n", + " validation_size=0.15,\n", + " batch_size=HumanActivityRecognitionPipeline.BATCH_SIZE,\n", + " batch_metrics={'accuracy': accuracy_score_classification},\n", + " shuffle_in_each_epoch_at_train=True,\n", + " n_epochs=HumanActivityRecognitionPipeline.EPOCHS,\n", + " epochs_metrics={'accuracy': accuracy_score_classification},\n", + " scoring_function=accuracy_score_classification\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Train" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "WARNING:tensorflow:From /home/alexandre/Documents/LSTM-Human-Activity-Recognition/neuraxle_tensorflow/tensorflow_v1.py:82: The name tf.variable_scope is deprecated. Please use tf.compat.v1.variable_scope instead.\n", + "\n", + "WARNING:tensorflow:From /home/alexandre/Documents/LSTM-Human-Activity-Recognition/neuraxle_tensorflow/tensorflow_v1.py:82: The name tf.AUTO_REUSE is deprecated. Please use tf.compat.v1.AUTO_REUSE instead.\n", + "\n", + "WARNING:tensorflow:From /home/alexandre/Documents/LSTM-Human-Activity-Recognition/neuraxle_tensorflow/tensorflow_v1.py:83: The name tf.Session is deprecated. Please use tf.compat.v1.Session instead.\n", + "\n", + "WARNING:tensorflow:From /home/alexandre/Documents/LSTM-Human-Activity-Recognition/neuraxle_tensorflow/tensorflow_v1.py:83: The name tf.ConfigProto is deprecated. Please use tf.compat.v1.ConfigProto instead.\n", + "\n", + "Device mapping:\n", + "/job:localhost/replica:0/task:0/device:XLA_CPU:0 -> device: XLA_CPU device\n", + "/job:localhost/replica:0/task:0/device:XLA_GPU:0 -> device: XLA_GPU device\n", + "\n", + "WARNING:tensorflow:\n", + "The TensorFlow contrib module will not be included in TensorFlow 2.0.\n", + "For more information, please see:\n", + " * https://github.com/tensorflow/community/blob/master/rfcs/20180907-contrib-sunset.md\n", + " * https://github.com/tensorflow/addons\n", + " * https://github.com/tensorflow/io (for I/O related ops)\n", + "If you depend on functionality not listed there, please file an issue.\n", + "\n", + "WARNING:tensorflow:From :52: BasicLSTMCell.__init__ (from tensorflow.python.ops.rnn_cell_impl) is deprecated and will be removed in a future version.\n", + "Instructions for updating:\n", + "This class is equivalent as tf.keras.layers.LSTMCell, and will be replaced by that in Tensorflow 2.0.\n", + "WARNING:tensorflow:From :54: MultiRNNCell.__init__ (from tensorflow.python.ops.rnn_cell_impl) is deprecated and will be removed in a future version.\n", + "Instructions for updating:\n", + "This class is equivalent as tf.keras.layers.StackedRNNCells, and will be replaced by that in Tensorflow 2.0.\n", + "WARNING:tensorflow:From :57: static_rnn (from tensorflow.python.ops.rnn) is deprecated and will be removed in a future version.\n", + "Instructions for updating:\n", + "Please use `keras.layers.RNN(cell, unroll=True)`, which is equivalent to this API\n", + "WARNING:tensorflow:From /home/alexandre/Documents/LSTM-Human-Activity-Recognition/venv/lib/python3.6/site-packages/tensorflow_core/python/ops/rnn_cell_impl.py:735: Layer.add_variable (from tensorflow.python.keras.engine.base_layer) is deprecated and will be removed in a future version.\n", + "Instructions for updating:\n", + "Please use `layer.add_weight` method instead.\n", + "WARNING:tensorflow:From /home/alexandre/Documents/LSTM-Human-Activity-Recognition/venv/lib/python3.6/site-packages/tensorflow_core/python/ops/rnn_cell_impl.py:739: calling Zeros.__init__ (from tensorflow.python.ops.init_ops) with dtype is deprecated and will be removed in a future version.\n", + "Instructions for updating:\n", + "Call initializer instance with the dtype argument instead of passing it to the constructor\n", + "WARNING:tensorflow:From :10: softmax_cross_entropy_with_logits (from tensorflow.python.ops.nn_ops) is deprecated and will be removed in a future version.\n", + "Instructions for updating:\n", + "\n", + "Future major versions of TensorFlow will allow gradients to flow\n", + "into the labels input on backprop by default.\n", + "\n", + "See `tf.nn.softmax_cross_entropy_with_logits_v2`.\n", + "\n", + "WARNING:tensorflow:From /home/alexandre/Documents/LSTM-Human-Activity-Recognition/neuraxle_tensorflow/tensorflow_v1.py:95: The name tf.global_variables_initializer is deprecated. Please use tf.compat.v1.global_variables_initializer instead.\n", + "\n", + "WARNING:tensorflow:From /home/alexandre/Documents/LSTM-Human-Activity-Recognition/neuraxle_tensorflow/tensorflow_v1.py:206: The name tf.get_variable is deprecated. Please use tf.compat.v1.get_variable instead.\n", + "\n" + ] + } + ], + "source": [ + "pipeline, outputs = pipeline.fit_transform(data_inputs, expected_outputs)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Visualize Accuracy" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "accuracies_train = pipeline.get_epoch_metric_train('accuracy')\n", + "accuracies_validation = pipeline.get_epoch_metric_validation('accuracy')\n", + "\n", + "plot_metric(accuracies_train, accuracies_validation, xlabel='epoch', ylabel='accuracy', title='Model Accuracy')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Visualize Loss" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "loss = pipeline.get_step_by_name('TensorflowV1ModelStep').loss\n", + "plot_metric(loss, xlabel='batch', ylabel='softmax_cross_entropy_with_logits', title='softmax_cross_entropy_with_logits')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Save pipeline" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "WARNING:tensorflow:From /home/alexandre/Documents/LSTM-Human-Activity-Recognition/neuraxle_tensorflow/tensorflow_v1.py:231: The name tf.train.Saver is deprecated. Please use tf.compat.v1.train.Saver instead.\n", + "\n" + ] + }, + { + "ename": "AttributeError", + "evalue": "'DeepLearningPipeline' object has no attribute 'steps_as_tuple'", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mAttributeError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m~/Documents/LSTM-Human-Activity-Recognition/venv/lib/python3.6/site-packages/IPython/core/formatters.py\u001b[0m in \u001b[0;36m__call__\u001b[0;34m(self, obj)\u001b[0m\n\u001b[1;32m 700\u001b[0m \u001b[0mtype_pprinters\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtype_printers\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 701\u001b[0m deferred_pprinters=self.deferred_printers)\n\u001b[0;32m--> 702\u001b[0;31m \u001b[0mprinter\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mpretty\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mobj\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 703\u001b[0m \u001b[0mprinter\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mflush\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 704\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0mstream\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mgetvalue\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m~/Documents/LSTM-Human-Activity-Recognition/venv/lib/python3.6/site-packages/IPython/lib/pretty.py\u001b[0m in \u001b[0;36mpretty\u001b[0;34m(self, obj)\u001b[0m\n\u001b[1;32m 400\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mcls\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0mobject\u001b[0m\u001b[0;31m \u001b[0m\u001b[0;31m\\\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 401\u001b[0m \u001b[0;32mand\u001b[0m \u001b[0mcallable\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mcls\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m__dict__\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mget\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'__repr__'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 402\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0m_repr_pprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mobj\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcycle\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 403\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 404\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0m_default_pprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mobj\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcycle\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m~/Documents/LSTM-Human-Activity-Recognition/venv/lib/python3.6/site-packages/IPython/lib/pretty.py\u001b[0m in \u001b[0;36m_repr_pprint\u001b[0;34m(obj, p, cycle)\u001b[0m\n\u001b[1;32m 695\u001b[0m \u001b[0;34m\"\"\"A pprint that just redirects to the normal repr function.\"\"\"\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 696\u001b[0m \u001b[0;31m# Find newlines and replace them with p.break_()\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 697\u001b[0;31m \u001b[0moutput\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mrepr\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mobj\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 698\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0midx\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0moutput_line\u001b[0m \u001b[0;32min\u001b[0m \u001b[0menumerate\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0moutput\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msplitlines\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 699\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0midx\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m~/Documents/LSTM-Human-Activity-Recognition/venv/src/neuraxle/neuraxle/base.py\u001b[0m in \u001b[0;36m__repr__\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 2817\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0;34m\"(\\n\\t\\t\"\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0mpprint\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mpformat\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msteps_as_tuple\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;31m \u001b[0m\u001b[0;31m\\\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 2818\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0;34m\"\\t\\n)\"\u001b[0m\u001b[0;31m \u001b[0m\u001b[0;31m\\\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 2819\u001b[0;31m \u001b[0;34m+\u001b[0m \u001b[0;34m\"\\n)\"\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 2820\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 2821\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0moutput\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;31mAttributeError\u001b[0m: 'DeepLearningPipeline' object has no attribute 'steps_as_tuple'" + ] + } + ], + "source": [ + "pipeline.save(ExecutionContext(DEFAULT_CACHE_FOLDER))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Serve Rest Api" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "ename": "AttributeError", + "evalue": "module '__main__' has no attribute 'ClassificationRNNTensorFlowModel'", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mAttributeError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[1;32m 1\u001b[0m \u001b[0mpipeline\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mHumanActivityRecognitionPipeline\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 2\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 3\u001b[0;31m \u001b[0mpipeline\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpipeline\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mload\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mExecutionContext\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mDEFAULT_CACHE_FOLDER\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 4\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 5\u001b[0m \u001b[0;31m# pipeline, outputs = pipeline.fit_transform(X_train, y_train) # we could train further more here for instance.\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m~/Documents/LSTM-Human-Activity-Recognition/venv/src/neuraxle/neuraxle/base.py\u001b[0m in \u001b[0;36mload\u001b[0;34m(self, context)\u001b[0m\n\u001b[1;32m 1263\u001b[0m \u001b[0;31m# Each saver unstrips the step a bit more if needed\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 1264\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0msaver\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcan_load\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mloaded_self\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcontext\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1265\u001b[0;31m \u001b[0mloaded_self\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0msaver\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mload_step\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mloaded_self\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcontext\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 1266\u001b[0m \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 1267\u001b[0m warnings.warn(\n", + "\u001b[0;32m~/Documents/LSTM-Human-Activity-Recognition/venv/src/neuraxle/neuraxle/base.py\u001b[0m in \u001b[0;36mload_step\u001b[0;34m(self, step, context)\u001b[0m\n\u001b[1;32m 2047\u001b[0m \u001b[0;31m# Load each sub step with their savers\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 2048\u001b[0m \u001b[0msub_step_to_load\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mIdentity\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mname\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mstep_name\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0msavers\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0msavers\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 2049\u001b[0;31m \u001b[0msub_step\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0msub_step_to_load\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mload\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mcontext\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 2050\u001b[0m \u001b[0mstep\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msteps_as_tuple\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mappend\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mstep_name\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0msub_step\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 2051\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m~/Documents/LSTM-Human-Activity-Recognition/venv/src/neuraxle/neuraxle/base.py\u001b[0m in \u001b[0;36mload\u001b[0;34m(self, context)\u001b[0m\n\u001b[1;32m 1263\u001b[0m \u001b[0;31m# Each saver unstrips the step a bit more if needed\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 1264\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0msaver\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcan_load\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mloaded_self\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcontext\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1265\u001b[0;31m \u001b[0mloaded_self\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0msaver\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mload_step\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mloaded_self\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcontext\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 1266\u001b[0m \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 1267\u001b[0m warnings.warn(\n", + "\u001b[0;32m~/Documents/LSTM-Human-Activity-Recognition/venv/src/neuraxle/neuraxle/base.py\u001b[0m in \u001b[0;36mload_step\u001b[0;34m(self, step, context)\u001b[0m\n\u001b[1;32m 279\u001b[0m \u001b[0;34m:\u001b[0m\u001b[0;32mreturn\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 280\u001b[0m \"\"\"\n\u001b[0;32m--> 281\u001b[0;31m \u001b[0mloaded_step\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mload\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_create_step_path\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mcontext\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mstep\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 282\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 283\u001b[0m \u001b[0;31m# we need to keep the current steps in memory because they have been deleted before saving...\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m~/Documents/LSTM-Human-Activity-Recognition/venv/lib/python3.6/site-packages/joblib/numpy_pickle.py\u001b[0m in \u001b[0;36mload\u001b[0;34m(filename, mmap_mode)\u001b[0m\n\u001b[1;32m 603\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0mload_compatibility\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfobj\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 604\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 605\u001b[0;31m \u001b[0mobj\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0m_unpickle\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfobj\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfilename\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmmap_mode\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 606\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 607\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0mobj\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m~/Documents/LSTM-Human-Activity-Recognition/venv/lib/python3.6/site-packages/joblib/numpy_pickle.py\u001b[0m in \u001b[0;36m_unpickle\u001b[0;34m(fobj, filename, mmap_mode)\u001b[0m\n\u001b[1;32m 527\u001b[0m \u001b[0mobj\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 528\u001b[0m \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 529\u001b[0;31m \u001b[0mobj\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0munpickler\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mload\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 530\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0munpickler\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcompat_mode\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 531\u001b[0m warnings.warn(\"The file '%s' has been generated with a \"\n", + "\u001b[0;32m/usr/lib/python3.6/pickle.py\u001b[0m in \u001b[0;36mload\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 1048\u001b[0m \u001b[0;32mraise\u001b[0m \u001b[0mEOFError\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 1049\u001b[0m \u001b[0;32massert\u001b[0m \u001b[0misinstance\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mkey\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mbytes_types\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1050\u001b[0;31m \u001b[0mdispatch\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mkey\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 1051\u001b[0m \u001b[0;32mexcept\u001b[0m \u001b[0m_Stop\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0mstopinst\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 1052\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0mstopinst\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mvalue\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/lib/python3.6/pickle.py\u001b[0m in \u001b[0;36mload_global\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 1336\u001b[0m \u001b[0mmodule\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mreadline\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m-\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdecode\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"utf-8\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 1337\u001b[0m \u001b[0mname\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mreadline\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m-\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdecode\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"utf-8\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1338\u001b[0;31m \u001b[0mklass\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfind_class\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mmodule\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mname\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 1339\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mappend\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mklass\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 1340\u001b[0m \u001b[0mdispatch\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mGLOBAL\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mload_global\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/lib/python3.6/pickle.py\u001b[0m in \u001b[0;36mfind_class\u001b[0;34m(self, module, name)\u001b[0m\n\u001b[1;32m 1390\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0m_getattribute\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0msys\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmodules\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mmodule\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mname\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 1391\u001b[0m \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1392\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mgetattr\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0msys\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmodules\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mmodule\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mname\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 1393\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 1394\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mload_reduce\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;31mAttributeError\u001b[0m: module '__main__' has no attribute 'ClassificationRNNTensorFlowModel'" + ] + } + ], + "source": [ + "pipeline = HumanActivityRecognitionPipeline()\n", + "\n", + "pipeline = pipeline.load(ExecutionContext(DEFAULT_CACHE_FOLDER))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "app = FlaskRestApiWrapper(\n", + " json_decoder=CustomJSONDecoderFor2DArray(),\n", + " wrapped=pipeline,\n", + " json_encoder=CustomJSONEncoderOfOutputs()\n", + ").get_app()\n", + "\n", + "app.run(debug=False, port=5000)" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Human Activity Recognition", + "language": "python", + "name": "human-activity-recognition" + }, + "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.6.8" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/2_call_rest_api_and_eval.ipynb b/2_call_rest_api_and_eval.ipynb new file mode 100644 index 0000000..290ff1d --- /dev/null +++ b/2_call_rest_api_and_eval.ipynb @@ -0,0 +1,317 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Imports " + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import math\n", + "import os\n", + "import json\n", + "import urllib\n", + "\n", + "import numpy as np\n", + "import tensorflow as tf\n", + "import matplotlib.pyplot as plt\n", + "import matplotlib\n", + "from sklearn import metrics\n", + "from neuraxle.base import ExecutionContext, DEFAULT_CACHE_FOLDER, ExecutionMode, BaseStep, NonFittableMixin\n", + "from neuraxle.api.flask import FlaskRestApiWrapper\n", + "from neuraxle.hyperparams.space import HyperparameterSamples\n", + "from neuraxle.pipeline import MiniBatchSequentialPipeline, Joiner, Pipeline\n", + "from neuraxle.steps.numpy import OneHotEncoder\n", + "from neuraxle.steps.output_handlers import OutputTransformerWrapper\n", + "\n", + "from data_reading import DATASET_PATH, TRAIN, TEST, X_train_signals_paths, X_test_signals_paths, load_X, load_y, \\\n", + " TRAIN_FILE_NAME, TEST_FILE_NAME, LABELS\n", + "from pipeline import HumanActivityRecognitionPipeline, BATCH_SIZE\n", + "from steps.custom_json_decoder_for_2darray import CustomJSONDecoderFor2DArray\n", + "from steps.custom_json_encoder_of_outputs import CustomJSONEncoderOfOutputs\n", + "from savers.tensorflow1_step_saver import TensorflowV1StepSaver # TODO: move in a package neuraxle-tensorflow." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Read Data" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Some useful info to get an insight on dataset's shape and normalisation:\n", + "(X shape, y shape, every X's mean, every X's standard deviation)\n", + "(2947, 128, 9) (2947, 1) 0.09913992 0.39567086\n", + "The dataset is therefore properly normalised, as expected, but not yet one-hot encoded.\n" + ] + } + ], + "source": [ + "DATA_PATH = \"data/\"\n", + "DATASET_PATH = DATA_PATH + \"UCI HAR Dataset/\"\n", + "\n", + "# X_train = load_X(X_train_signals_paths)\n", + "X_test = load_X(X_test_signals_paths)\n", + "\n", + "# y_train_path = os.path.join(DATASET_PATH, TRAIN, TRAIN_FILE_NAME)\n", + "y_test_path = os.path.join(DATASET_PATH, TEST, TEST_FILE_NAME)\n", + "\n", + "# y_train = load_y(y_train_path)\n", + "y_test = load_y(y_test_path)\n", + "\n", + "print(\"Some useful info to get an insight on dataset's shape and normalisation:\")\n", + "print(\"(X shape, y shape, every X's mean, every X's standard deviation)\")\n", + "print(X_test.shape, y_test.shape, np.mean(X_test), np.std(X_test))\n", + "print(\"The dataset is therefore properly normalised, as expected, but not yet one-hot encoded.\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# API Caller " + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "class APICaller(NonFittableMixin, BaseStep):\n", + " def __init__(self, url):\n", + " BaseStep.__init__(self)\n", + " self.url = url\n", + " \n", + " def transform(self, data_inputs):\n", + " data = json.dumps(data_inputs.tolist()).encode('utf8')\n", + " req = urllib.request.Request(\n", + " self.url,\n", + " method=\"GET\",\n", + " headers={'content-type': 'application/json'},\n", + " data=data\n", + " )\n", + " response = urllib.request.urlopen(req)\n", + " test_predictions = json.loads(response.read())\n", + " return np.array(test_predictions['predictions'])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Call Rest Api " + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[[ 2.07112408 0.09142101 0.45754826 4.80191326 8.39756203 -1.65806925]\n", + " [ 1.95728445 -0.02661133 0.57281792 4.96968269 8.64764977 -1.52020741]\n", + " [ 1.99783969 0.04387677 0.59818095 5.06699944 8.73121643 -1.54111767]\n", + " ...\n", + " [ 2.27837229 6.34097433 1.04619193 -1.33004761 -1.27574241 -1.44660664]\n", + " [ 2.44670582 6.67506218 0.52507615 -2.08214211 -0.20692641 -0.51537234]\n", + " [ 3.03775263 5.70212603 0.31813109 -1.95930123 -0.19588709 -0.17824771]]\n" + ] + } + ], + "source": [ + "p = Pipeline([\n", + " APICaller(url=\"http://127.0.0.1:5000/\")\n", + "])\n", + "y_pred = p.transform(X_test)\n", + "print(y_pred)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Plot " + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "findfont: Font family ['Bitstream Vera Sans'] not found. Falling back to DejaVu Sans.\n", + "findfont: Font family ['Bitstream Vera Sans'] not found. Falling back to DejaVu Sans.\n", + "findfont: Font family ['Bitstream Vera Sans'] not found. Falling back to DejaVu Sans.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Precision: 85.16945732166661%\n", + "Recall: 84.49270444519851%\n", + "f1_score: 84.45214093239125%\n", + "\n", + "Confusion Matrix:\n", + "[[401 82 13 0 0 0]\n", + " [ 24 432 14 0 0 1]\n", + " [ 68 40 312 0 0 0]\n", + " [ 4 26 0 356 105 0]\n", + " [ 4 9 0 67 452 0]\n", + " [ 0 0 0 0 0 537]]\n", + "\n", + "Confusion matrix (normalised to % of total test data):\n", + "[[13.607058 2.7824907 0.44112659 0. 0. 0. ]\n", + " [ 0.8143875 14.658976 0.4750594 0. 0. 0.03393281]\n", + " [ 2.3074312 1.3573124 10.587037 0. 0. 0. ]\n", + " [ 0.13573125 0.88225317 0. 12.080082 3.5629456 0. ]\n", + " [ 0.13573125 0.3053953 0. 2.2734985 15.337631 0. ]\n", + " [ 0. 0. 0. 0. 0. 18.22192 ]]\n", + "Note: training and testing data is not equally distributed amongst classes, \n", + "so it is normal that more than a 6th of the data is correctly classifier in the last category.\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# (Inline plots: )\n", + "%matplotlib inline\n", + "\n", + "font = {\n", + " 'family' : 'Bitstream Vera Sans',\n", + " 'weight' : 'bold',\n", + " 'size' : 18\n", + "}\n", + "matplotlib.rc('font', **font)\n", + "\n", + "# Results\n", + "\n", + "predictions = y_pred.argmax(1)\n", + "n_classes = 6\n", + "\n", + "print(\"\")\n", + "print(\"Precision: {}%\".format(100*metrics.precision_score(y_test, predictions, average=\"weighted\")))\n", + "print(\"Recall: {}%\".format(100*metrics.recall_score(y_test, predictions, average=\"weighted\")))\n", + "print(\"f1_score: {}%\".format(100*metrics.f1_score(y_test, predictions, average=\"weighted\")))\n", + "\n", + "print(\"\")\n", + "print(\"Confusion Matrix:\")\n", + "confusion_matrix = metrics.confusion_matrix(y_test, predictions)\n", + "print(confusion_matrix)\n", + "normalised_confusion_matrix = np.array(confusion_matrix, dtype=np.float32)/np.sum(confusion_matrix)*100\n", + "\n", + "print(\"\")\n", + "print(\"Confusion matrix (normalised to % of total test data):\")\n", + "print(normalised_confusion_matrix)\n", + "print(\"Note: training and testing data is not equally distributed amongst classes, \")\n", + "print(\"so it is normal that more than a 6th of the data is correctly classifier in the last category.\")\n", + "\n", + "# Plot Results:\n", + "width = 12\n", + "height = 12\n", + "plt.figure(figsize=(width, height))\n", + "plt.imshow(\n", + " normalised_confusion_matrix,\n", + " interpolation='nearest',\n", + " cmap=plt.cm.rainbow\n", + ")\n", + "plt.title(\"Confusion matrix \\n(normalised to % of total test data)\")\n", + "plt.colorbar()\n", + "tick_marks = np.arange(n_classes)\n", + "plt.xticks(tick_marks, LABELS, rotation=90)\n", + "plt.yticks(tick_marks, LABELS)\n", + "plt.tight_layout()\n", + "plt.ylabel('True label')\n", + "plt.xlabel('Predicted label')\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Pipeline\n", + "(\n", + "\tPipeline(\n", + "\tname=Pipeline,\n", + "\thyperparameters=HyperparameterSamples()\n", + ")(\n", + "\t\t[('APICaller',\n", + " APICaller(\n", + "\tname=APICaller,\n", + "\thyperparameters=HyperparameterSamples()\n", + "))]\t\n", + ")\n", + ")" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "p.teardown()" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "venv", + "language": "python", + "name": "venv" + }, + "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.6.8" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/LSTM.ipynb b/LSTM.ipynb deleted file mode 100644 index 29a57ad..0000000 --- a/LSTM.ipynb +++ /dev/null @@ -1,947 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# LSTMs for Human Activity Recognition\n", - "\n", - "Human Activity Recognition (HAR) using smartphones dataset and an LSTM RNN. Classifying the type of movement amongst six categories:\n", - "- WALKING,\n", - "- WALKING_UPSTAIRS,\n", - "- WALKING_DOWNSTAIRS,\n", - "- SITTING,\n", - "- STANDING,\n", - "- LAYING.\n", - "\n", - "Compared to a classical approach, using a Recurrent Neural Networks (RNN) with Long Short-Term Memory cells (LSTMs) require no or almost no feature engineering. Data can be fed directly into the neural network who acts like a black box, modeling the problem correctly. [Other research](https://archive.ics.uci.edu/ml/machine-learning-databases/00240/UCI%20HAR%20Dataset.names) on the activity recognition dataset can use a big amount of feature engineering, which is rather a signal processing approach combined with classical data science techniques. The approach here is rather very simple in terms of how much was the data preprocessed. \n", - "\n", - "Let's use Google's neat Deep Learning library, TensorFlow, demonstrating the usage of an LSTM, a type of Artificial Neural Network that can process sequential data / time series. \n", - "\n", - "## Video dataset overview\n", - "\n", - "Follow this link to see a video of the 6 activities recorded in the experiment with one of the participants:\n", - "\n", - "

\n", - " \n", - "

[Watch video]
\n", - "

\n", - "\n", - "## Details about the input data\n", - "\n", - "I will be using an LSTM on the data to learn (as a cellphone attached on the waist) to recognise the type of activity that the user is doing. The dataset's description goes like this:\n", - "\n", - "> The sensor signals (accelerometer and gyroscope) were pre-processed by applying noise filters and then sampled in fixed-width sliding windows of 2.56 sec and 50% overlap (128 readings/window). The sensor acceleration signal, which has gravitational and body motion components, was separated using a Butterworth low-pass filter into body acceleration and gravity. The gravitational force is assumed to have only low frequency components, therefore a filter with 0.3 Hz cutoff frequency was used. \n", - "\n", - "That said, I will use the almost raw data: only the gravity effect has been filtered out of the accelerometer as a preprocessing step for another 3D feature as an input to help learning. If you'd ever want to extract the gravity by yourself, you could fork my code on using a [Butterworth Low-Pass Filter (LPF) in Python](https://github.com/guillaume-chevalier/filtering-stft-and-laplace-transform) and edit it to have the right cutoff frequency of 0.3 Hz which is a good frequency for activity recognition from body sensors.\n", - "\n", - "## What is an RNN?\n", - "\n", - "As explained in [this article](http://karpathy.github.io/2015/05/21/rnn-effectiveness/), an RNN takes many input vectors to process them and output other vectors. It can be roughly pictured like in the image below, imagining each rectangle has a vectorial depth and other special hidden quirks in the image below. **In our case, the \"many to one\" architecture is used**: we accept time series of [feature vectors](https://www.quora.com/What-do-samples-features-time-steps-mean-in-LSTM/answer/Guillaume-Chevalier-2) (one vector per [time step](https://www.quora.com/What-do-samples-features-time-steps-mean-in-LSTM/answer/Guillaume-Chevalier-2)) to convert them to a probability vector at the output for classification. Note that a \"one to one\" architecture would be a standard feedforward neural network. \n", - "\n", - "> \n", - "> http://karpathy.github.io/2015/05/21/rnn-effectiveness/\n", - "\n", - "## What is an LSTM?\n", - "\n", - "An LSTM is an improved RNN. It is more complex, but easier to train, avoiding what is called the vanishing gradient problem. I recommend [this article](http://colah.github.io/posts/2015-08-Understanding-LSTMs/) for you to learn more on LSTMs.\n", - "\n", - "\n", - "## Results \n", - "\n", - "Scroll on! Nice visuals awaits. " - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "metadata": { - "collapsed": true - }, - "outputs": [], - "source": [ - "# All Includes\n", - "\n", - "import numpy as np\n", - "import matplotlib\n", - "import matplotlib.pyplot as plt\n", - "import tensorflow as tf # Version 1.0.0 (some previous versions are used in past commits)\n", - "from sklearn import metrics\n", - "\n", - "import os" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [], - "source": [ - "# Useful Constants\n", - "\n", - "# Those are separate normalised input features for the neural network\n", - "INPUT_SIGNAL_TYPES = [\n", - " \"body_acc_x_\",\n", - " \"body_acc_y_\",\n", - " \"body_acc_z_\",\n", - " \"body_gyro_x_\",\n", - " \"body_gyro_y_\",\n", - " \"body_gyro_z_\",\n", - " \"total_acc_x_\",\n", - " \"total_acc_y_\",\n", - " \"total_acc_z_\"\n", - "]\n", - "\n", - "# Output classes to learn how to classify\n", - "LABELS = [\n", - " \"WALKING\", \n", - " \"WALKING_UPSTAIRS\", \n", - " \"WALKING_DOWNSTAIRS\", \n", - " \"SITTING\", \n", - " \"STANDING\", \n", - " \"LAYING\"\n", - "] \n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Let's start by downloading the data: " - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "/home/ubuntu/pynb/LSTM-Human-Activity-Recognition\n", - "data\t LSTM_files LSTM_OLD.ipynb README.md\n", - "LICENSE LSTM.ipynb lstm.py\t screenlog.0\n", - "/home/ubuntu/pynb/LSTM-Human-Activity-Recognition/data\n", - "download_dataset.py source.txt\n", - "\n", - "Downloading...\n", - "--2017-05-24 01:49:53-- https://archive.ics.uci.edu/ml/machine-learning-databases/00240/UCI%20HAR%20Dataset.zip\n", - "Resolving archive.ics.uci.edu (archive.ics.uci.edu)... 128.195.10.249\n", - "Connecting to archive.ics.uci.edu (archive.ics.uci.edu)|128.195.10.249|:443... connected.\n", - "HTTP request sent, awaiting response... 200 OK\n", - "Length: 60999314 (58M) [application/zip]\n", - "Saving to: ‘UCI HAR Dataset.zip’\n", - "\n", - "100%[======================================>] 60,999,314 1.69MB/s in 38s \n", - "\n", - "2017-05-24 01:50:31 (1.55 MB/s) - ‘UCI HAR Dataset.zip’ saved [60999314/60999314]\n", - "\n", - "Downloading done.\n", - "\n", - "Extracting...\n", - "Extracting successfully done to /home/ubuntu/pynb/LSTM-Human-Activity-Recognition/data/UCI HAR Dataset.\n", - "/home/ubuntu/pynb/LSTM-Human-Activity-Recognition/data\n", - "download_dataset.py __MACOSX source.txt UCI HAR Dataset UCI HAR Dataset.zip\n", - "/home/ubuntu/pynb/LSTM-Human-Activity-Recognition\n", - "data\t LSTM_files LSTM_OLD.ipynb README.md\n", - "LICENSE LSTM.ipynb lstm.py\t screenlog.0\n", - "\n", - "Dataset is now located at: data/UCI HAR Dataset/\n" - ] - } - ], - "source": [ - "# Note: Linux bash commands start with a \"!\" inside those \"ipython notebook\" cells\n", - "\n", - "DATA_PATH = \"data/\"\n", - "\n", - "!pwd && ls\n", - "os.chdir(DATA_PATH)\n", - "!pwd && ls\n", - "\n", - "!python download_dataset.py\n", - "\n", - "!pwd && ls\n", - "os.chdir(\"..\")\n", - "!pwd && ls\n", - "\n", - "DATASET_PATH = DATA_PATH + \"UCI HAR Dataset/\"\n", - "print(\"\\n\" + \"Dataset is now located at: \" + DATASET_PATH)\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Preparing dataset:" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": {}, - "outputs": [], - "source": [ - "TRAIN = \"train/\"\n", - "TEST = \"test/\"\n", - "\n", - "\n", - "# Load \"X\" (the neural network's training and testing inputs)\n", - "\n", - "def load_X(X_signals_paths):\n", - " X_signals = []\n", - " \n", - " for signal_type_path in X_signals_paths:\n", - " file = open(signal_type_path, 'r')\n", - " # Read dataset from disk, dealing with text files' syntax\n", - " X_signals.append(\n", - " [np.array(serie, dtype=np.float32) for serie in [\n", - " row.replace(' ', ' ').strip().split(' ') for row in file\n", - " ]]\n", - " )\n", - " file.close()\n", - " \n", - " return np.transpose(np.array(X_signals), (1, 2, 0))\n", - "\n", - "X_train_signals_paths = [\n", - " DATASET_PATH + TRAIN + \"Inertial Signals/\" + signal + \"train.txt\" for signal in INPUT_SIGNAL_TYPES\n", - "]\n", - "X_test_signals_paths = [\n", - " DATASET_PATH + TEST + \"Inertial Signals/\" + signal + \"test.txt\" for signal in INPUT_SIGNAL_TYPES\n", - "]\n", - "\n", - "X_train = load_X(X_train_signals_paths)\n", - "X_test = load_X(X_test_signals_paths)\n", - "\n", - "\n", - "# Load \"y\" (the neural network's training and testing outputs)\n", - "\n", - "def load_y(y_path):\n", - " file = open(y_path, 'r')\n", - " # Read dataset from disk, dealing with text file's syntax\n", - " y_ = np.array(\n", - " [elem for elem in [\n", - " row.replace(' ', ' ').strip().split(' ') for row in file\n", - " ]], \n", - " dtype=np.int32\n", - " )\n", - " file.close()\n", - " \n", - " # Substract 1 to each output class for friendly 0-based indexing \n", - " return y_ - 1\n", - "\n", - "y_train_path = DATASET_PATH + TRAIN + \"y_train.txt\"\n", - "y_test_path = DATASET_PATH + TEST + \"y_test.txt\"\n", - "\n", - "y_train = load_y(y_train_path)\n", - "y_test = load_y(y_test_path)\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Additionnal Parameters:\n", - "\n", - "Here are some core parameter definitions for the training. \n", - "\n", - "For example, the whole neural network's structure could be summarised by enumerating those parameters and the fact that two LSTM are used one on top of another (stacked) output-to-input as hidden layers through time steps. " - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Some useful info to get an insight on dataset's shape and normalisation:\n", - "(X shape, y shape, every X's mean, every X's standard deviation)\n", - "(2947, 128, 9) (2947, 1) 0.0991399 0.395671\n", - "The dataset is therefore properly normalised, as expected, but not yet one-hot encoded.\n" - ] - } - ], - "source": [ - "# Input Data \n", - "\n", - "training_data_count = len(X_train) # 7352 training series (with 50% overlap between each serie)\n", - "test_data_count = len(X_test) # 2947 testing series\n", - "n_steps = len(X_train[0]) # 128 timesteps per series\n", - "n_input = len(X_train[0][0]) # 9 input parameters per timestep\n", - "\n", - "\n", - "# LSTM Neural Network's internal structure\n", - "\n", - "n_hidden = 32 # Hidden layer num of features\n", - "n_classes = 6 # Total classes (should go up, or should go down)\n", - "\n", - "\n", - "# Training \n", - "\n", - "learning_rate = 0.0025\n", - "lambda_loss_amount = 0.0015\n", - "training_iters = training_data_count * 300 # Loop 300 times on the dataset\n", - "batch_size = 1500\n", - "display_iter = 30000 # To show test set accuracy during training\n", - "\n", - "\n", - "# Some debugging info\n", - "\n", - "print(\"Some useful info to get an insight on dataset's shape and normalisation:\")\n", - "print(\"(X shape, y shape, every X's mean, every X's standard deviation)\")\n", - "print(X_test.shape, y_test.shape, np.mean(X_test), np.std(X_test))\n", - "print(\"The dataset is therefore properly normalised, as expected, but not yet one-hot encoded.\")\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Utility functions for training:" - ] - }, - { - "cell_type": "code", - "execution_count": 16, - "metadata": { - "collapsed": true - }, - "outputs": [], - "source": [ - "def LSTM_RNN(_X, _weights, _biases):\n", - " # Function returns a tensorflow LSTM (RNN) artificial neural network from given parameters. \n", - " # Moreover, two LSTM cells are stacked which adds deepness to the neural network. \n", - " # Note, some code of this notebook is inspired from an slightly different \n", - " # RNN architecture used on another dataset, some of the credits goes to \n", - " # \"aymericdamien\" under the MIT license.\n", - "\n", - " # (NOTE: This step could be greatly optimised by shaping the dataset once\n", - " # input shape: (batch_size, n_steps, n_input)\n", - " _X = tf.transpose(_X, [1, 0, 2]) # permute n_steps and batch_size\n", - " # Reshape to prepare input to hidden activation\n", - " _X = tf.reshape(_X, [-1, n_input]) \n", - " # new shape: (n_steps*batch_size, n_input)\n", - " \n", - " # ReLU activation, thanks to Yu Zhao for adding this improvement here:\n", - " _X = tf.nn.relu(tf.matmul(_X, _weights['hidden']) + _biases['hidden'])\n", - " # Split data because rnn cell needs a list of inputs for the RNN inner loop\n", - " _X = tf.split(_X, n_steps, 0) \n", - " # new shape: n_steps * (batch_size, n_hidden)\n", - "\n", - " # Define two stacked LSTM cells (two recurrent layers deep) with tensorflow\n", - " lstm_cell_1 = tf.contrib.rnn.BasicLSTMCell(n_hidden, forget_bias=1.0, state_is_tuple=True)\n", - " lstm_cell_2 = tf.contrib.rnn.BasicLSTMCell(n_hidden, forget_bias=1.0, state_is_tuple=True)\n", - " lstm_cells = tf.contrib.rnn.MultiRNNCell([lstm_cell_1, lstm_cell_2], state_is_tuple=True)\n", - " # Get LSTM cell output\n", - " outputs, states = tf.contrib.rnn.static_rnn(lstm_cells, _X, dtype=tf.float32)\n", - "\n", - " # Get last time step's output feature for a \"many-to-one\" style classifier, \n", - " # as in the image describing RNNs at the top of this page\n", - " lstm_last_output = outputs[-1]\n", - " \n", - " # Linear activation\n", - " return tf.matmul(lstm_last_output, _weights['out']) + _biases['out']\n", - "\n", - "\n", - "def extract_batch_size(_train, step, batch_size):\n", - " # Function to fetch a \"batch_size\" amount of data from \"(X|y)_train\" data. \n", - " \n", - " shape = list(_train.shape)\n", - " shape[0] = batch_size\n", - " batch_s = np.empty(shape)\n", - "\n", - " for i in range(batch_size):\n", - " # Loop index\n", - " index = ((step-1)*batch_size + i) % len(_train)\n", - " batch_s[i] = _train[index] \n", - "\n", - " return batch_s\n", - "\n", - "\n", - "def one_hot(y_, n_classes=n_classes):\n", - " # Function to encode neural one-hot output labels from number indexes \n", - " # e.g.: \n", - " # one_hot(y_=[[5], [0], [3]], n_classes=6):\n", - " # return [[0, 0, 0, 0, 0, 1], [1, 0, 0, 0, 0, 0], [0, 0, 0, 1, 0, 0]]\n", - " \n", - " y_ = y_.reshape(len(y_))\n", - " return np.eye(n_classes)[np.array(y_, dtype=np.int32)] # Returns FLOATS\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Let's get serious and build the neural network:" - ] - }, - { - "cell_type": "code", - "execution_count": 17, - "metadata": {}, - "outputs": [], - "source": [ - "\n", - "# Graph input/output\n", - "x = tf.placeholder(tf.float32, [None, n_steps, n_input])\n", - "y = tf.placeholder(tf.float32, [None, n_classes])\n", - "\n", - "# Graph weights\n", - "weights = {\n", - " 'hidden': tf.Variable(tf.random_normal([n_input, n_hidden])), # Hidden layer weights\n", - " 'out': tf.Variable(tf.random_normal([n_hidden, n_classes], mean=1.0))\n", - "}\n", - "biases = {\n", - " 'hidden': tf.Variable(tf.random_normal([n_hidden])),\n", - " 'out': tf.Variable(tf.random_normal([n_classes]))\n", - "}\n", - "\n", - "pred = LSTM_RNN(x, weights, biases)\n", - "\n", - "# Loss, optimizer and evaluation\n", - "l2 = lambda_loss_amount * sum(\n", - " tf.nn.l2_loss(tf_var) for tf_var in tf.trainable_variables()\n", - ") # L2 loss prevents this overkill neural network to overfit the data\n", - "cost = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(labels=y, logits=pred)) + l2 # Softmax loss\n", - "optimizer = tf.train.AdamOptimizer(learning_rate=learning_rate).minimize(cost) # Adam Optimizer\n", - "\n", - "correct_pred = tf.equal(tf.argmax(pred,1), tf.argmax(y,1))\n", - "accuracy = tf.reduce_mean(tf.cast(correct_pred, tf.float32))\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Hooray, now train the neural network:" - ] - }, - { - "cell_type": "code", - "execution_count": 19, - "metadata": { - "scrolled": true - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "WARNING:tensorflow:From :9: initialize_all_variables (from tensorflow.python.ops.variables) is deprecated and will be removed after 2017-03-02.\n", - "Instructions for updating:\n", - "Use `tf.global_variables_initializer` instead.\n", - "Training iter #1500: Batch Loss = 5.416760, Accuracy = 0.15266665816307068\n", - "PERFORMANCE ON TEST SET: Batch Loss = 4.880829811096191, Accuracy = 0.05632847175002098\n", - "Training iter #30000: Batch Loss = 3.031930, Accuracy = 0.607333242893219\n", - "PERFORMANCE ON TEST SET: Batch Loss = 3.0515167713165283, Accuracy = 0.6067186594009399\n", - "Training iter #60000: Batch Loss = 2.672764, Accuracy = 0.7386666536331177\n", - "PERFORMANCE ON TEST SET: Batch Loss = 2.780435085296631, Accuracy = 0.7027485370635986\n", - "Training iter #90000: Batch Loss = 2.378301, Accuracy = 0.8366667032241821\n", - "PERFORMANCE ON TEST SET: Batch Loss = 2.6019773483276367, Accuracy = 0.7617915868759155\n", - "Training iter #120000: Batch Loss = 2.127290, Accuracy = 0.9066667556762695\n", - "PERFORMANCE ON TEST SET: Batch Loss = 2.3625404834747314, Accuracy = 0.8116728663444519\n", - "Training iter #150000: Batch Loss = 1.929805, Accuracy = 0.9380000233650208\n", - "PERFORMANCE ON TEST SET: Batch Loss = 2.306251049041748, Accuracy = 0.8276212215423584\n", - "Training iter #180000: Batch Loss = 1.971904, Accuracy = 0.9153333902359009\n", - "PERFORMANCE ON TEST SET: Batch Loss = 2.0835530757904053, Accuracy = 0.8771631121635437\n", - "Training iter #210000: Batch Loss = 1.860249, Accuracy = 0.8613333702087402\n", - "PERFORMANCE ON TEST SET: Batch Loss = 1.9994492530822754, Accuracy = 0.8788597583770752\n", - "Training iter #240000: Batch Loss = 1.626292, Accuracy = 0.9380000233650208\n", - "PERFORMANCE ON TEST SET: Batch Loss = 1.879166603088379, Accuracy = 0.8944689035415649\n", - "Training iter #270000: Batch Loss = 1.582758, Accuracy = 0.9386667013168335\n", - "PERFORMANCE ON TEST SET: Batch Loss = 2.0341007709503174, Accuracy = 0.8361043930053711\n", - "Training iter #300000: Batch Loss = 1.620352, Accuracy = 0.9306666851043701\n", - "PERFORMANCE ON TEST SET: Batch Loss = 1.8185184001922607, Accuracy = 0.8639293313026428\n", - "Training iter #330000: Batch Loss = 1.474394, Accuracy = 0.9693333506584167\n", - "PERFORMANCE ON TEST SET: Batch Loss = 1.7638503313064575, Accuracy = 0.8747878670692444\n", - "Training iter #360000: Batch Loss = 1.406998, Accuracy = 0.9420000314712524\n", - "PERFORMANCE ON TEST SET: Batch Loss = 1.5946787595748901, Accuracy = 0.902273416519165\n", - "Training iter #390000: Batch Loss = 1.362515, Accuracy = 0.940000057220459\n", - "PERFORMANCE ON TEST SET: Batch Loss = 1.5285792350769043, Accuracy = 0.9046487212181091\n", - "Training iter #420000: Batch Loss = 1.252860, Accuracy = 0.9566667079925537\n", - "PERFORMANCE ON TEST SET: Batch Loss = 1.4635565280914307, Accuracy = 0.9107565879821777\n", - "Training iter #450000: Batch Loss = 1.190078, Accuracy = 0.9553333520889282\n", - "PERFORMANCE ON TEST SET: Batch Loss = 1.442753553390503, Accuracy = 0.9093992710113525\n", - "Training iter #480000: Batch Loss = 1.159610, Accuracy = 0.9446667432785034\n", - "PERFORMANCE ON TEST SET: Batch Loss = 1.4130011796951294, Accuracy = 0.8971834778785706\n", - "Training iter #510000: Batch Loss = 1.100551, Accuracy = 0.9593333601951599\n", - "PERFORMANCE ON TEST SET: Batch Loss = 1.3075592517852783, Accuracy = 0.9117745757102966\n", - "Training iter #540000: Batch Loss = 1.123470, Accuracy = 0.9240000247955322\n", - "PERFORMANCE ON TEST SET: Batch Loss = 1.2605488300323486, Accuracy = 0.9165251851081848\n", - "Training iter #570000: Batch Loss = 1.103454, Accuracy = 0.909333348274231\n", - "PERFORMANCE ON TEST SET: Batch Loss = 1.2327136993408203, Accuracy = 0.9009160399436951\n", - "Training iter #600000: Batch Loss = 1.083368, Accuracy = 0.8966666460037231\n", - "PERFORMANCE ON TEST SET: Batch Loss = 1.2683708667755127, Accuracy = 0.8890395164489746\n", - "Training iter #630000: Batch Loss = 0.939185, Accuracy = 0.9700000882148743\n", - "PERFORMANCE ON TEST SET: Batch Loss = 1.2147629261016846, Accuracy = 0.8866642713546753\n", - "Training iter #660000: Batch Loss = 0.881242, Accuracy = 0.9806667566299438\n", - "PERFORMANCE ON TEST SET: Batch Loss = 1.1068334579467773, Accuracy = 0.9151678681373596\n", - "Training iter #690000: Batch Loss = 0.831674, Accuracy = 0.9853334426879883\n", - "PERFORMANCE ON TEST SET: Batch Loss = 1.0885852575302124, Accuracy = 0.9121139645576477\n", - "Training iter #720000: Batch Loss = 0.866615, Accuracy = 0.9573334455490112\n", - "PERFORMANCE ON TEST SET: Batch Loss = 1.0513516664505005, Accuracy = 0.9158465266227722\n", - "Training iter #750000: Batch Loss = 0.858979, Accuracy = 0.940000057220459\n", - "PERFORMANCE ON TEST SET: Batch Loss = 1.0598633289337158, Accuracy = 0.9063453674316406\n", - "Training iter #780000: Batch Loss = 0.750040, Accuracy = 0.9593334197998047\n", - "PERFORMANCE ON TEST SET: Batch Loss = 1.010966420173645, Accuracy = 0.9155071973800659\n", - "Training iter #810000: Batch Loss = 0.732136, Accuracy = 0.9620000123977661\n", - "PERFORMANCE ON TEST SET: Batch Loss = 0.9865696430206299, Accuracy = 0.9161858558654785\n", - "Training iter #840000: Batch Loss = 0.758945, Accuracy = 0.9406667351722717\n", - "PERFORMANCE ON TEST SET: Batch Loss = 1.0347753763198853, Accuracy = 0.8958262205123901\n", - "Training iter #870000: Batch Loss = 0.710809, Accuracy = 0.9660000205039978\n", - "PERFORMANCE ON TEST SET: Batch Loss = 0.9786491990089417, Accuracy = 0.893111526966095\n", - "Training iter #900000: Batch Loss = 0.705978, Accuracy = 0.9553333520889282\n", - "PERFORMANCE ON TEST SET: Batch Loss = 0.9204542636871338, Accuracy = 0.9002374410629272\n", - "Training iter #930000: Batch Loss = 0.759181, Accuracy = 0.9066667556762695\n", - "PERFORMANCE ON TEST SET: Batch Loss = 0.9086415767669678, Accuracy = 0.9036307334899902\n", - "Training iter #960000: Batch Loss = 0.705333, Accuracy = 0.9286667108535767\n", - "PERFORMANCE ON TEST SET: Batch Loss = 0.850454568862915, Accuracy = 0.9080419540405273\n", - "Training iter #990000: Batch Loss = 0.599754, Accuracy = 0.9693333506584167\n", - "PERFORMANCE ON TEST SET: Batch Loss = 0.8451057076454163, Accuracy = 0.9114353656768799\n", - "Training iter #1020000: Batch Loss = 0.585689, Accuracy = 0.9700000286102295\n", - "PERFORMANCE ON TEST SET: Batch Loss = 0.8170899152755737, Accuracy = 0.9110959768295288\n", - "Training iter #1050000: Batch Loss = 0.553970, Accuracy = 0.984000027179718\n", - "PERFORMANCE ON TEST SET: Batch Loss = 0.8555561304092407, Accuracy = 0.9114352464675903\n", - "Training iter #1080000: Batch Loss = 0.601349, Accuracy = 0.9693334102630615\n", - "PERFORMANCE ON TEST SET: Batch Loss = 0.8512595891952515, Accuracy = 0.8781810998916626\n", - "Training iter #1110000: Batch Loss = 0.601967, Accuracy = 0.937999963760376\n", - "PERFORMANCE ON TEST SET: Batch Loss = 0.7551606297492981, Accuracy = 0.9087206721305847\n", - "Training iter #1140000: Batch Loss = 0.597223, Accuracy = 0.9353333711624146\n", - "PERFORMANCE ON TEST SET: Batch Loss = 0.7431289553642273, Accuracy = 0.909060001373291\n", - "Training iter #1170000: Batch Loss = 0.523300, Accuracy = 0.9500000476837158\n", - "PERFORMANCE ON TEST SET: Batch Loss = 0.745741605758667, Accuracy = 0.9093992710113525\n", - "Training iter #1200000: Batch Loss = 0.500816, Accuracy = 0.9600000381469727\n", - "PERFORMANCE ON TEST SET: Batch Loss = 0.6978224515914917, Accuracy = 0.9138105511665344\n", - "Training iter #1230000: Batch Loss = 0.495834, Accuracy = 0.9546667337417603\n", - "PERFORMANCE ON TEST SET: Batch Loss = 0.6866210699081421, Accuracy = 0.9178825616836548\n", - "Training iter #1260000: Batch Loss = 0.480467, Accuracy = 0.9813334345817566\n", - "PERFORMANCE ON TEST SET: Batch Loss = 0.6883729100227356, Accuracy = 0.9100779294967651\n", - "Training iter #1290000: Batch Loss = 0.516874, Accuracy = 0.9326666593551636\n", - "PERFORMANCE ON TEST SET: Batch Loss = 0.6925369501113892, Accuracy = 0.9032914042472839\n", - "Training iter #1320000: Batch Loss = 0.570053, Accuracy = 0.9080000519752502\n", - "PERFORMANCE ON TEST SET: Batch Loss = 0.743996798992157, Accuracy = 0.8978621363639832\n", - "Training iter #1350000: Batch Loss = 0.491792, Accuracy = 0.9580000638961792\n", - "PERFORMANCE ON TEST SET: Batch Loss = 0.6543726921081543, Accuracy = 0.8951475024223328\n", - "Training iter #1380000: Batch Loss = 0.423705, Accuracy = 0.9760000705718994\n", - "PERFORMANCE ON TEST SET: Batch Loss = 0.6256207227706909, Accuracy = 0.91788250207901\n", - "Training iter #1410000: Batch Loss = 0.399226, Accuracy = 0.9840000867843628\n", - "PERFORMANCE ON TEST SET: Batch Loss = 0.6232836246490479, Accuracy = 0.9205971360206604\n", - "Training iter #1440000: Batch Loss = 0.415493, Accuracy = 0.972000002861023\n", - "PERFORMANCE ON TEST SET: Batch Loss = 0.6083709001541138, Accuracy = 0.9104173183441162\n", - "Training iter #1470000: Batch Loss = 0.499316, Accuracy = 0.9306666851043701\n", - "PERFORMANCE ON TEST SET: Batch Loss = 0.5882848501205444, Accuracy = 0.9117745757102966\n", - "Training iter #1500000: Batch Loss = 0.478666, Accuracy = 0.9346666932106018\n", - "PERFORMANCE ON TEST SET: Batch Loss = 0.5803182125091553, Accuracy = 0.91652512550354\n", - "Training iter #1530000: Batch Loss = 0.366041, Accuracy = 0.968666672706604\n", - "PERFORMANCE ON TEST SET: Batch Loss = 0.5783829689025879, Accuracy = 0.9114352464675903\n", - "Training iter #1560000: Batch Loss = 0.377644, Accuracy = 0.9506667256355286\n", - "PERFORMANCE ON TEST SET: Batch Loss = 0.5899279117584229, Accuracy = 0.9070240259170532\n", - "Training iter #1590000: Batch Loss = 0.485060, Accuracy = 0.9133333563804626\n", - "PERFORMANCE ON TEST SET: Batch Loss = 0.7430599927902222, Accuracy = 0.8649473190307617\n", - "Training iter #1620000: Batch Loss = 0.386228, Accuracy = 0.9633333683013916\n", - "PERFORMANCE ON TEST SET: Batch Loss = 0.5264637470245361, Accuracy = 0.9070240259170532\n", - "Training iter #1650000: Batch Loss = 0.416933, Accuracy = 0.9193333983421326\n", - "PERFORMANCE ON TEST SET: Batch Loss = 0.5343363881111145, Accuracy = 0.914489209651947\n", - "Training iter #1680000: Batch Loss = 0.421477, Accuracy = 0.9300000667572021\n", - "PERFORMANCE ON TEST SET: Batch Loss = 0.5374469757080078, Accuracy = 0.9243297576904297\n", - "Training iter #1710000: Batch Loss = 0.403527, Accuracy = 0.9300000071525574\n", - "PERFORMANCE ON TEST SET: Batch Loss = 0.5439008474349976, Accuracy = 0.905666708946228\n", - "Training iter #1740000: Batch Loss = 0.331851, Accuracy = 0.9753334522247314\n", - "PERFORMANCE ON TEST SET: Batch Loss = 0.5405154228210449, Accuracy = 0.9093992710113525\n", - "Training iter #1770000: Batch Loss = 0.337737, Accuracy = 0.9780000448226929\n", - "PERFORMANCE ON TEST SET: Batch Loss = 0.5582258701324463, Accuracy = 0.9026126861572266\n", - "Training iter #1800000: Batch Loss = 0.332086, Accuracy = 0.9600000381469727\n", - "PERFORMANCE ON TEST SET: Batch Loss = 0.5655900835990906, Accuracy = 0.8995587825775146\n", - "Training iter #1830000: Batch Loss = 0.400998, Accuracy = 0.9480000734329224\n", - "PERFORMANCE ON TEST SET: Batch Loss = 0.47865116596221924, Accuracy = 0.9144891500473022\n", - "Training iter #1860000: Batch Loss = 0.364531, Accuracy = 0.9493333697319031\n", - "PERFORMANCE ON TEST SET: Batch Loss = 0.49166250228881836, Accuracy = 0.9158465266227722\n", - "Training iter #1890000: Batch Loss = 0.316529, Accuracy = 0.9593334197998047\n", - "PERFORMANCE ON TEST SET: Batch Loss = 0.5186017751693726, Accuracy = 0.9104173183441162\n", - "Training iter #1920000: Batch Loss = 0.309109, Accuracy = 0.9626667499542236\n", - "PERFORMANCE ON TEST SET: Batch Loss = 0.5222393274307251, Accuracy = 0.9002374410629272\n", - "Training iter #1950000: Batch Loss = 0.427720, Accuracy = 0.9193333387374878\n", - "PERFORMANCE ON TEST SET: Batch Loss = 0.5457150340080261, Accuracy = 0.9070240259170532\n", - "Training iter #1980000: Batch Loss = 0.330174, Accuracy = 0.9526667594909668\n", - "PERFORMANCE ON TEST SET: Batch Loss = 0.5917137861251831, Accuracy = 0.8812350034713745\n", - "Training iter #2010000: Batch Loss = 0.371541, Accuracy = 0.906000018119812\n", - "PERFORMANCE ON TEST SET: Batch Loss = 0.53951495885849, Accuracy = 0.8802171349525452\n", - "Training iter #2040000: Batch Loss = 0.382413, Accuracy = 0.9206666946411133\n", - "PERFORMANCE ON TEST SET: Batch Loss = 0.42567864060401917, Accuracy = 0.9324736595153809\n", - "Training iter #2070000: Batch Loss = 0.342763, Accuracy = 0.9326667189598083\n", - "PERFORMANCE ON TEST SET: Batch Loss = 0.4292983412742615, Accuracy = 0.9273836612701416\n", - "Training iter #2100000: Batch Loss = 0.259442, Accuracy = 0.9873334169387817\n", - "PERFORMANCE ON TEST SET: Batch Loss = 0.44131210446357727, Accuracy = 0.9273836612701416\n", - "Training iter #2130000: Batch Loss = 0.284630, Accuracy = 0.9593333601951599\n", - "PERFORMANCE ON TEST SET: Batch Loss = 0.46982717514038086, Accuracy = 0.9093992710113525\n", - "Training iter #2160000: Batch Loss = 0.299012, Accuracy = 0.9686667323112488\n", - "PERFORMANCE ON TEST SET: Batch Loss = 0.48389002680778503, Accuracy = 0.9138105511665344\n", - "Training iter #2190000: Batch Loss = 0.287106, Accuracy = 0.9700000286102295\n", - "PERFORMANCE ON TEST SET: Batch Loss = 0.4670214056968689, Accuracy = 0.9216151237487793\n", - "Optimization Finished!\n", - "FINAL RESULT: Batch Loss = 0.45611169934272766, Accuracy = 0.9165252447128296\n" - ] - } - ], - "source": [ - "# To keep track of training's performance\n", - "test_losses = []\n", - "test_accuracies = []\n", - "train_losses = []\n", - "train_accuracies = []\n", - "\n", - "# Launch the graph\n", - "sess = tf.InteractiveSession(config=tf.ConfigProto(log_device_placement=True))\n", - "init = tf.global_variables_initializer()\n", - "sess.run(init)\n", - "\n", - "# Perform Training steps with \"batch_size\" amount of example data at each loop\n", - "step = 1\n", - "while step * batch_size <= training_iters:\n", - " batch_xs = extract_batch_size(X_train, step, batch_size)\n", - " batch_ys = one_hot(extract_batch_size(y_train, step, batch_size))\n", - "\n", - " # Fit training using batch data\n", - " _, loss, acc = sess.run(\n", - " [optimizer, cost, accuracy],\n", - " feed_dict={\n", - " x: batch_xs, \n", - " y: batch_ys\n", - " }\n", - " )\n", - " train_losses.append(loss)\n", - " train_accuracies.append(acc)\n", - " \n", - " # Evaluate network only at some steps for faster training: \n", - " if (step*batch_size % display_iter == 0) or (step == 1) or (step * batch_size > training_iters):\n", - " \n", - " # To not spam console, show training accuracy/loss in this \"if\"\n", - " print(\"Training iter #\" + str(step*batch_size) + \\\n", - " \": Batch Loss = \" + \"{:.6f}\".format(loss) + \\\n", - " \", Accuracy = {}\".format(acc))\n", - " \n", - " # Evaluation on the test set (no learning made here - just evaluation for diagnosis)\n", - " loss, acc = sess.run(\n", - " [cost, accuracy], \n", - " feed_dict={\n", - " x: X_test,\n", - " y: one_hot(y_test)\n", - " }\n", - " )\n", - " test_losses.append(loss)\n", - " test_accuracies.append(acc)\n", - " print(\"PERFORMANCE ON TEST SET: \" + \\\n", - " \"Batch Loss = {}\".format(loss) + \\\n", - " \", Accuracy = {}\".format(acc))\n", - "\n", - " step += 1\n", - "\n", - "print(\"Optimization Finished!\")\n", - "\n", - "# Accuracy for test data\n", - "\n", - "one_hot_predictions, accuracy, final_loss = sess.run(\n", - " [pred, accuracy, cost],\n", - " feed_dict={\n", - " x: X_test,\n", - " y: one_hot(y_test)\n", - " }\n", - ")\n", - "\n", - "test_losses.append(final_loss)\n", - "test_accuracies.append(accuracy)\n", - "\n", - "print(\"FINAL RESULT: \" + \\\n", - " \"Batch Loss = {}\".format(final_loss) + \\\n", - " \", Accuracy = {}\".format(accuracy))\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Training is good, but having visual insight is even better:\n", - "\n", - "Okay, let's plot this simply in the notebook for now." - ] - }, - { - "cell_type": "code", - "execution_count": 20, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAv8AAALuCAYAAAA5cXkcAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nbwFNGxMAAAAASUVORK5CYII=\n", - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "# (Inline plots: )\n", - "%matplotlib inline\n", - "\n", - "font = {\n", - " 'family' : 'Bitstream Vera Sans',\n", - " 'weight' : 'bold',\n", - " 'size' : 18\n", - "}\n", - "matplotlib.rc('font', **font)\n", - "\n", - "width = 12\n", - "height = 12\n", - "plt.figure(figsize=(width, height))\n", - "\n", - "indep_train_axis = np.array(range(batch_size, (len(train_losses)+1)*batch_size, batch_size))\n", - "plt.plot(indep_train_axis, np.array(train_losses), \"b--\", label=\"Train losses\")\n", - "plt.plot(indep_train_axis, np.array(train_accuracies), \"g--\", label=\"Train accuracies\")\n", - "\n", - "indep_test_axis = np.append(\n", - " np.array(range(batch_size, len(test_losses)*display_iter, display_iter)[:-1]),\n", - " [training_iters]\n", - ")\n", - "plt.plot(indep_test_axis, np.array(test_losses), \"b-\", label=\"Test losses\")\n", - "plt.plot(indep_test_axis, np.array(test_accuracies), \"g-\", label=\"Test accuracies\")\n", - "\n", - "plt.title(\"Training session's progress over iterations\")\n", - "plt.legend(loc='upper right', shadow=True)\n", - "plt.ylabel('Training Progress (Loss or Accuracy values)')\n", - "plt.xlabel('Training iteration')\n", - "\n", - "plt.show()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## And finally, the multi-class confusion matrix and metrics!" - ] - }, - { - "cell_type": "code", - "execution_count": 21, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Testing Accuracy: 91.65252447128296%\n", - "\n", - "Precision: 91.76286479743305%\n", - "Recall: 91.65252799457076%\n", - "f1_score: 91.6437546304815%\n", - "\n", - "Confusion Matrix:\n", - "[[466 2 26 0 2 0]\n", - " [ 5 441 25 0 0 0]\n", - " [ 1 0 419 0 0 0]\n", - " [ 1 1 0 396 87 6]\n", - " [ 2 1 0 87 442 0]\n", - " [ 0 0 0 0 0 537]]\n", - "\n", - "Confusion matrix (normalised to % of total test data):\n", - "[[ 15.81269073 0.06786563 0.88225317 0. 0.06786563 0. ]\n", - " [ 0.16966406 14.96437073 0.84832031 0. 0. 0. ]\n", - " [ 0.03393281 0. 14.21784878 0. 0. 0. ]\n", - " [ 0.03393281 0.03393281 0. 13.43739319 2.95215464\n", - " 0.20359688]\n", - " [ 0.06786563 0.03393281 0. 2.95215464 14.99830341 0. ]\n", - " [ 0. 0. 0. 0. 0. 18.22192001]]\n", - "Note: training and testing data is not equally distributed amongst classes, \n", - "so it is normal that more than a 6th of the data is correctly classifier in the last category.\n" - ] - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAA0UAAANGCAYAAAAyEyUbAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\ntf8HGEwmAny82PIAAAAASUVORK5CYII=\n", - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "# Results\n", - "\n", - "predictions = one_hot_predictions.argmax(1)\n", - "\n", - "print(\"Testing Accuracy: {}%\".format(100*accuracy))\n", - "\n", - "print(\"\")\n", - "print(\"Precision: {}%\".format(100*metrics.precision_score(y_test, predictions, average=\"weighted\")))\n", - "print(\"Recall: {}%\".format(100*metrics.recall_score(y_test, predictions, average=\"weighted\")))\n", - "print(\"f1_score: {}%\".format(100*metrics.f1_score(y_test, predictions, average=\"weighted\")))\n", - "\n", - "print(\"\")\n", - "print(\"Confusion Matrix:\")\n", - "confusion_matrix = metrics.confusion_matrix(y_test, predictions)\n", - "print(confusion_matrix)\n", - "normalised_confusion_matrix = np.array(confusion_matrix, dtype=np.float32)/np.sum(confusion_matrix)*100\n", - "\n", - "print(\"\")\n", - "print(\"Confusion matrix (normalised to % of total test data):\")\n", - "print(normalised_confusion_matrix)\n", - "print(\"Note: training and testing data is not equally distributed amongst classes, \")\n", - "print(\"so it is normal that more than a 6th of the data is correctly classifier in the last category.\")\n", - "\n", - "# Plot Results: \n", - "width = 12\n", - "height = 12\n", - "plt.figure(figsize=(width, height))\n", - "plt.imshow(\n", - " normalised_confusion_matrix, \n", - " interpolation='nearest', \n", - " cmap=plt.cm.rainbow\n", - ")\n", - "plt.title(\"Confusion matrix \\n(normalised to % of total test data)\")\n", - "plt.colorbar()\n", - "tick_marks = np.arange(n_classes)\n", - "plt.xticks(tick_marks, LABELS, rotation=90)\n", - "plt.yticks(tick_marks, LABELS)\n", - "plt.tight_layout()\n", - "plt.ylabel('True label')\n", - "plt.xlabel('Predicted label')\n", - "plt.show()" - ] - }, - { - "cell_type": "code", - "execution_count": 22, - "metadata": { - "collapsed": true - }, - "outputs": [], - "source": [ - "sess.close()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Conclusion\n", - "\n", - "Outstandingly, **the final accuracy is of 91%**! And it can peak to values such as 93.25%, at some moments of luck during the training, depending on how the neural network's weights got initialized at the start of the training, randomly. \n", - "\n", - "This means that the neural networks is almost always able to correctly identify the movement type! Remember, the phone is attached on the waist and each series to classify has just a 128 sample window of two internal sensors (a.k.a. 2.56 seconds at 50 FPS), so it amazes me how those predictions are extremely accurate given this small window of context and raw data. I've validated and re-validated that there is no important bug, and the community used and tried this code a lot. (Note: be sure to report something in the issue tab if you find bugs, otherwise [Quora](https://www.quora.com/), [StackOverflow](https://stackoverflow.com/questions/tagged/tensorflow?sort=votes&pageSize=50), and other [StackExchange](https://stackexchange.com/sites#science) sites are the places for asking questions.)\n", - "\n", - "I specially did not expect such good results for guessing between the labels \"SITTING\" and \"STANDING\". Those are seemingly almost the same thing from the point of view of a device placed at waist level according to how the dataset was originally gathered. Thought, it is still possible to see a little cluster on the matrix between those classes, which drifts away just a bit from the identity. This is great.\n", - "\n", - "It is also possible to see that there was a slight difficulty in doing the difference between \"WALKING\", \"WALKING_UPSTAIRS\" and \"WALKING_DOWNSTAIRS\". Obviously, those activities are quite similar in terms of movements. \n", - "\n", - "I also tried my code without the gyroscope, using only the 3D accelerometer's 6 features (and not changing the training hyperparameters), and got an accuracy of 87%. In general, gyroscopes consumes more power than accelerometers, so it is preferable to turn them off. \n", - "\n", - "\n", - "## Improvements\n", - "\n", - "In [another open-source repository of mine](https://github.com/guillaume-chevalier/HAR-stacked-residual-bidir-LSTMs), the accuracy is pushed up to nearly 94% using a special deep LSTM architecture which combines the concepts of bidirectional RNNs, residual connections, and stacked cells. This architecture is also tested on another similar activity dataset. It resembles the nice architecture used in \"[Google’s Neural Machine Translation System: Bridging the Gap between Human and Machine Translation](https://arxiv.org/pdf/1609.08144.pdf)\", without an attention mechanism, and with just the encoder part - as a \"many to one\" architecture instead of a \"many to many\" to be adapted to the Human Activity Recognition (HAR) problem. I also worked more on the problem and came up with the [LARNN](https://github.com/guillaume-chevalier/Linear-Attention-Recurrent-Neural-Network), however it's complicated for just a little gain. Thus the current, original activity recognition project is simply better to use for its outstanding simplicity. \n", - "\n", - "If you want to learn more about deep learning, I have also built a list of the learning ressources for deep learning which have revealed to be the most useful to me [here](https://github.com/guillaume-chevalier/Awesome-Deep-Learning-Resources). \n", - "\n", - "\n", - "## References\n", - "\n", - "The [dataset](https://archive.ics.uci.edu/ml/datasets/Human+Activity+Recognition+Using+Smartphones) can be found on the UCI Machine Learning Repository: \n", - "\n", - "> Davide Anguita, Alessandro Ghio, Luca Oneto, Xavier Parra and Jorge L. Reyes-Ortiz. A Public Domain Dataset for Human Activity Recognition Using Smartphones. 21th European Symposium on Artificial Neural Networks, Computational Intelligence and Machine Learning, ESANN 2013. Bruges, Belgium 24-26 April 2013.\n", - "\n", - "The RNN image for \"many-to-one\" is taken from Karpathy's post: \n", - "\n", - "> Andrej Karpathy, The Unreasonable Effectiveness of Recurrent Neural Networks, 2015, \n", - "> http://karpathy.github.io/2015/05/21/rnn-effectiveness/\n", - "\n", - "## Citation\n", - "\n", - "Copyright (c) 2016 Guillaume Chevalier. To cite my code, you can point to the URL of the GitHub repository, for example: \n", - "\n", - "> Guillaume Chevalier, LSTMs for Human Activity Recognition, 2016, \n", - "> https://github.com/guillaume-chevalier/LSTM-Human-Activity-Recognition\n", - "\n", - "My code is available for free and even for private usage for anyone under the [MIT License](https://github.com/guillaume-chevalier/LSTM-Human-Activity-Recognition/blob/master/LICENSE), however I ask to cite for using the code. \n", - "\n", - "## Extra links\n", - "\n", - "### Connect with me\n", - "\n", - "- [LinkedIn](https://ca.linkedin.com/in/chevalierg)\n", - "- [Twitter](https://twitter.com/guillaume_che)\n", - "- [GitHub](https://github.com/guillaume-chevalier/)\n", - "- [Quora](https://www.quora.com/profile/Guillaume-Chevalier-2)\n", - "- [YouTube](https://www.youtube.com/c/GuillaumeChevalier)\n", - "- [Dev/Consulting](http://www.neuraxio.com/en/)\n", - "\n", - "### Liked this project? Did it help you? Leave a [star](https://github.com/guillaume-chevalier/LSTM-Human-Activity-Recognition/stargazers), [fork](https://github.com/guillaume-chevalier/LSTM-Human-Activity-Recognition/network/members) and share the love!\n", - "\n", - "This activity recognition project has been seen in:\n", - "\n", - "- [Hacker News 1st page](https://news.ycombinator.com/item?id=13049143)\n", - "- [Awesome TensorFlow](https://github.com/jtoy/awesome-tensorflow#tutorials)\n", - "- [TensorFlow World](https://github.com/astorfi/TensorFlow-World#some-useful-tutorials)\n", - "- And more.\n", - "\n", - "---\n" - ] - }, - { - "cell_type": "code", - "execution_count": 23, - "metadata": { - "scrolled": true - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[NbConvertApp] Converting notebook LSTM.ipynb to markdown\n", - "[NbConvertApp] Support files will be in LSTM_files/\n", - "[NbConvertApp] Making directory LSTM_files\n", - "[NbConvertApp] Making directory LSTM_files\n", - "[NbConvertApp] Writing 38654 bytes to LSTM.md\n" - ] - } - ], - "source": [ - "# Let's convert this notebook to a README automatically for the GitHub project's title page:\n", - "!jupyter nbconvert --to markdown LSTM.ipynb\n", - "!mv LSTM.md README.md" - ] - } - ], - "metadata": { - "hide_input": false, - "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.6.6" - } - }, - "nbformat": 4, - "nbformat_minor": 2 -} diff --git a/LSTM_files/LSTM_16_0.png b/LSTM_files/LSTM_16_0.png deleted file mode 100644 index 140f520..0000000 Binary files a/LSTM_files/LSTM_16_0.png and /dev/null differ diff --git a/LSTM_files/LSTM_18_1.png b/LSTM_files/LSTM_18_1.png deleted file mode 100644 index 98676f8..0000000 Binary files a/LSTM_files/LSTM_18_1.png and /dev/null differ diff --git a/README.md b/README.md index c17a4b3..99e4c6a 100644 --- a/README.md +++ b/README.md @@ -1,686 +1,17 @@ +# Full example of LSTM training in TensorFlow, and REST API serving & calling -# LSTMs for Human Activity Recognition +## Instructions: -Human Activity Recognition (HAR) using smartphones dataset and an LSTM RNN. Classifying the type of movement amongst six categories: -- WALKING, -- WALKING_UPSTAIRS, -- WALKING_DOWNSTAIRS, -- SITTING, -- STANDING, -- LAYING. +The first notebook will create a model, save it, then delete the local variable, reload the model completely, and serve its predictions as a REST API on localhost ([http://127.0.0.1:5000/](http://127.0.0.1:5000/)). -Compared to a classical approach, using a Recurrent Neural Networks (RNN) with Long Short-Term Memory cells (LSTMs) require no or almost no feature engineering. Data can be fed directly into the neural network who acts like a black box, modeling the problem correctly. [Other research](https://archive.ics.uci.edu/ml/machine-learning-databases/00240/UCI%20HAR%20Dataset.names) on the activity recognition dataset can use a big amount of feature engineering, which is rather a signal processing approach combined with classical data science techniques. The approach here is rather very simple in terms of how much was the data preprocessed. +1. Read `1_train_and_save_LSTM.ipynb` and execute all the code. Once fully executed, the notebook will have trained and serialized the neural net to a local `./cache;`, folder which is reused at the end of the notebook to launch the REST API. The last two cells of this notebook that loads the model and serve it could as well be executed as a `.py` file instead of as a notebook. +2. Read `2_call_rest_api_and_eval.ipynb` and while the first notebook is running and has reached the end of the code, execute all the code of the second notebook. The code of the second notebook reads the test data on disks, serializes it to JSON, and calls the REST API on the localhost of the machine. Ideally you'd open your ports to the world so as to use a public IP address, or an URL with a DNS pointing to the machine. +3. If you want more information, dive into the local `.py` files for some more reading on how things works. -Let's use Google's neat Deep Learning library, TensorFlow, demonstrating the usage of an LSTM, a type of Artificial Neural Network that can process sequential data / time series. +Note: you may install all the requirements.txt before starting. -## Video dataset overview +## Future improvements -Follow this link to see a video of the 6 activities recorded in the experiment with one of the participants: +Note that in the `requirements.txt`, an URL to a yet-unreleased version of Neuraxle is used as we needed to apply some changes for the example to fully work with TensorFlow. We will soon release those changes as `neuraxle==0.2.2` on PyPI. This means that soon, it will be possible to update this `requirements.txt` to use an official version hosted on the Python Package Index (PyPI), installable with `pip install neuraxle==0.2.2`. Once released, the entry for Neuraxle in the `requirements.txt` will look like `neuraxle==0.2.2` as it'll finally be an officially released version. -

- -

[Watch video]
-

- -## Details about the input data - -I will be using an LSTM on the data to learn (as a cellphone attached on the waist) to recognise the type of activity that the user is doing. The dataset's description goes like this: - -> The sensor signals (accelerometer and gyroscope) were pre-processed by applying noise filters and then sampled in fixed-width sliding windows of 2.56 sec and 50% overlap (128 readings/window). The sensor acceleration signal, which has gravitational and body motion components, was separated using a Butterworth low-pass filter into body acceleration and gravity. The gravitational force is assumed to have only low frequency components, therefore a filter with 0.3 Hz cutoff frequency was used. - -That said, I will use the almost raw data: only the gravity effect has been filtered out of the accelerometer as a preprocessing step for another 3D feature as an input to help learning. If you'd ever want to extract the gravity by yourself, you could fork my code on using a [Butterworth Low-Pass Filter (LPF) in Python](https://github.com/guillaume-chevalier/filtering-stft-and-laplace-transform) and edit it to have the right cutoff frequency of 0.3 Hz which is a good frequency for activity recognition from body sensors. - -## What is an RNN? - -As explained in [this article](http://karpathy.github.io/2015/05/21/rnn-effectiveness/), an RNN takes many input vectors to process them and output other vectors. It can be roughly pictured like in the image below, imagining each rectangle has a vectorial depth and other special hidden quirks in the image below. **In our case, the "many to one" architecture is used**: we accept time series of [feature vectors](https://www.quora.com/What-do-samples-features-time-steps-mean-in-LSTM/answer/Guillaume-Chevalier-2) (one vector per [time step](https://www.quora.com/What-do-samples-features-time-steps-mean-in-LSTM/answer/Guillaume-Chevalier-2)) to convert them to a probability vector at the output for classification. Note that a "one to one" architecture would be a standard feedforward neural network. - -> -> http://karpathy.github.io/2015/05/21/rnn-effectiveness/ - -## What is an LSTM? - -An LSTM is an improved RNN. It is more complex, but easier to train, avoiding what is called the vanishing gradient problem. I recommend [this article](http://colah.github.io/posts/2015-08-Understanding-LSTMs/) for you to learn more on LSTMs. - - -## Results - -Scroll on! Nice visuals awaits. - - -```python -# All Includes - -import numpy as np -import matplotlib -import matplotlib.pyplot as plt -import tensorflow as tf # Version 1.0.0 (some previous versions are used in past commits) -from sklearn import metrics - -import os -``` - - -```python -# Useful Constants - -# Those are separate normalised input features for the neural network -INPUT_SIGNAL_TYPES = [ - "body_acc_x_", - "body_acc_y_", - "body_acc_z_", - "body_gyro_x_", - "body_gyro_y_", - "body_gyro_z_", - "total_acc_x_", - "total_acc_y_", - "total_acc_z_" -] - -# Output classes to learn how to classify -LABELS = [ - "WALKING", - "WALKING_UPSTAIRS", - "WALKING_DOWNSTAIRS", - "SITTING", - "STANDING", - "LAYING" -] - -``` - -## Let's start by downloading the data: - - -```python -# Note: Linux bash commands start with a "!" inside those "ipython notebook" cells - -DATA_PATH = "data/" - -!pwd && ls -os.chdir(DATA_PATH) -!pwd && ls - -!python download_dataset.py - -!pwd && ls -os.chdir("..") -!pwd && ls - -DATASET_PATH = DATA_PATH + "UCI HAR Dataset/" -print("\n" + "Dataset is now located at: " + DATASET_PATH) - -``` - - /home/ubuntu/pynb/LSTM-Human-Activity-Recognition - data LSTM_files LSTM_OLD.ipynb README.md - LICENSE LSTM.ipynb lstm.py screenlog.0 - /home/ubuntu/pynb/LSTM-Human-Activity-Recognition/data - download_dataset.py source.txt - - Downloading... - --2017-05-24 01:49:53-- https://archive.ics.uci.edu/ml/machine-learning-databases/00240/UCI%20HAR%20Dataset.zip - Resolving archive.ics.uci.edu (archive.ics.uci.edu)... 128.195.10.249 - Connecting to archive.ics.uci.edu (archive.ics.uci.edu)|128.195.10.249|:443... connected. - HTTP request sent, awaiting response... 200 OK - Length: 60999314 (58M) [application/zip] - Saving to: ‘UCI HAR Dataset.zip’ - - 100%[======================================>] 60,999,314 1.69MB/s in 38s - - 2017-05-24 01:50:31 (1.55 MB/s) - ‘UCI HAR Dataset.zip’ saved [60999314/60999314] - - Downloading done. - - Extracting... - Extracting successfully done to /home/ubuntu/pynb/LSTM-Human-Activity-Recognition/data/UCI HAR Dataset. - /home/ubuntu/pynb/LSTM-Human-Activity-Recognition/data - download_dataset.py __MACOSX source.txt UCI HAR Dataset UCI HAR Dataset.zip - /home/ubuntu/pynb/LSTM-Human-Activity-Recognition - data LSTM_files LSTM_OLD.ipynb README.md - LICENSE LSTM.ipynb lstm.py screenlog.0 - - Dataset is now located at: data/UCI HAR Dataset/ - - -## Preparing dataset: - - -```python -TRAIN = "train/" -TEST = "test/" - - -# Load "X" (the neural network's training and testing inputs) - -def load_X(X_signals_paths): - X_signals = [] - - for signal_type_path in X_signals_paths: - file = open(signal_type_path, 'r') - # Read dataset from disk, dealing with text files' syntax - X_signals.append( - [np.array(serie, dtype=np.float32) for serie in [ - row.replace(' ', ' ').strip().split(' ') for row in file - ]] - ) - file.close() - - return np.transpose(np.array(X_signals), (1, 2, 0)) - -X_train_signals_paths = [ - DATASET_PATH + TRAIN + "Inertial Signals/" + signal + "train.txt" for signal in INPUT_SIGNAL_TYPES -] -X_test_signals_paths = [ - DATASET_PATH + TEST + "Inertial Signals/" + signal + "test.txt" for signal in INPUT_SIGNAL_TYPES -] - -X_train = load_X(X_train_signals_paths) -X_test = load_X(X_test_signals_paths) - - -# Load "y" (the neural network's training and testing outputs) - -def load_y(y_path): - file = open(y_path, 'r') - # Read dataset from disk, dealing with text file's syntax - y_ = np.array( - [elem for elem in [ - row.replace(' ', ' ').strip().split(' ') for row in file - ]], - dtype=np.int32 - ) - file.close() - - # Substract 1 to each output class for friendly 0-based indexing - return y_ - 1 - -y_train_path = DATASET_PATH + TRAIN + "y_train.txt" -y_test_path = DATASET_PATH + TEST + "y_test.txt" - -y_train = load_y(y_train_path) -y_test = load_y(y_test_path) - -``` - -## Additionnal Parameters: - -Here are some core parameter definitions for the training. - -For example, the whole neural network's structure could be summarised by enumerating those parameters and the fact that two LSTM are used one on top of another (stacked) output-to-input as hidden layers through time steps. - - -```python -# Input Data - -training_data_count = len(X_train) # 7352 training series (with 50% overlap between each serie) -test_data_count = len(X_test) # 2947 testing series -n_steps = len(X_train[0]) # 128 timesteps per series -n_input = len(X_train[0][0]) # 9 input parameters per timestep - - -# LSTM Neural Network's internal structure - -n_hidden = 32 # Hidden layer num of features -n_classes = 6 # Total classes (should go up, or should go down) - - -# Training - -learning_rate = 0.0025 -lambda_loss_amount = 0.0015 -training_iters = training_data_count * 300 # Loop 300 times on the dataset -batch_size = 1500 -display_iter = 30000 # To show test set accuracy during training - - -# Some debugging info - -print("Some useful info to get an insight on dataset's shape and normalisation:") -print("(X shape, y shape, every X's mean, every X's standard deviation)") -print(X_test.shape, y_test.shape, np.mean(X_test), np.std(X_test)) -print("The dataset is therefore properly normalised, as expected, but not yet one-hot encoded.") - -``` - - Some useful info to get an insight on dataset's shape and normalisation: - (X shape, y shape, every X's mean, every X's standard deviation) - (2947, 128, 9) (2947, 1) 0.0991399 0.395671 - The dataset is therefore properly normalised, as expected, but not yet one-hot encoded. - - -## Utility functions for training: - - -```python -def LSTM_RNN(_X, _weights, _biases): - # Function returns a tensorflow LSTM (RNN) artificial neural network from given parameters. - # Moreover, two LSTM cells are stacked which adds deepness to the neural network. - # Note, some code of this notebook is inspired from an slightly different - # RNN architecture used on another dataset, some of the credits goes to - # "aymericdamien" under the MIT license. - - # (NOTE: This step could be greatly optimised by shaping the dataset once - # input shape: (batch_size, n_steps, n_input) - _X = tf.transpose(_X, [1, 0, 2]) # permute n_steps and batch_size - # Reshape to prepare input to hidden activation - _X = tf.reshape(_X, [-1, n_input]) - # new shape: (n_steps*batch_size, n_input) - - # ReLU activation, thanks to Yu Zhao for adding this improvement here: - _X = tf.nn.relu(tf.matmul(_X, _weights['hidden']) + _biases['hidden']) - # Split data because rnn cell needs a list of inputs for the RNN inner loop - _X = tf.split(_X, n_steps, 0) - # new shape: n_steps * (batch_size, n_hidden) - - # Define two stacked LSTM cells (two recurrent layers deep) with tensorflow - lstm_cell_1 = tf.contrib.rnn.BasicLSTMCell(n_hidden, forget_bias=1.0, state_is_tuple=True) - lstm_cell_2 = tf.contrib.rnn.BasicLSTMCell(n_hidden, forget_bias=1.0, state_is_tuple=True) - lstm_cells = tf.contrib.rnn.MultiRNNCell([lstm_cell_1, lstm_cell_2], state_is_tuple=True) - # Get LSTM cell output - outputs, states = tf.contrib.rnn.static_rnn(lstm_cells, _X, dtype=tf.float32) - - # Get last time step's output feature for a "many-to-one" style classifier, - # as in the image describing RNNs at the top of this page - lstm_last_output = outputs[-1] - - # Linear activation - return tf.matmul(lstm_last_output, _weights['out']) + _biases['out'] - - -def extract_batch_size(_train, step, batch_size): - # Function to fetch a "batch_size" amount of data from "(X|y)_train" data. - - shape = list(_train.shape) - shape[0] = batch_size - batch_s = np.empty(shape) - - for i in range(batch_size): - # Loop index - index = ((step-1)*batch_size + i) % len(_train) - batch_s[i] = _train[index] - - return batch_s - - -def one_hot(y_, n_classes=n_classes): - # Function to encode neural one-hot output labels from number indexes - # e.g.: - # one_hot(y_=[[5], [0], [3]], n_classes=6): - # return [[0, 0, 0, 0, 0, 1], [1, 0, 0, 0, 0, 0], [0, 0, 0, 1, 0, 0]] - - y_ = y_.reshape(len(y_)) - return np.eye(n_classes)[np.array(y_, dtype=np.int32)] # Returns FLOATS - -``` - -## Let's get serious and build the neural network: - - -```python - -# Graph input/output -x = tf.placeholder(tf.float32, [None, n_steps, n_input]) -y = tf.placeholder(tf.float32, [None, n_classes]) - -# Graph weights -weights = { - 'hidden': tf.Variable(tf.random_normal([n_input, n_hidden])), # Hidden layer weights - 'out': tf.Variable(tf.random_normal([n_hidden, n_classes], mean=1.0)) -} -biases = { - 'hidden': tf.Variable(tf.random_normal([n_hidden])), - 'out': tf.Variable(tf.random_normal([n_classes])) -} - -pred = LSTM_RNN(x, weights, biases) - -# Loss, optimizer and evaluation -l2 = lambda_loss_amount * sum( - tf.nn.l2_loss(tf_var) for tf_var in tf.trainable_variables() -) # L2 loss prevents this overkill neural network to overfit the data -cost = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(labels=y, logits=pred)) + l2 # Softmax loss -optimizer = tf.train.AdamOptimizer(learning_rate=learning_rate).minimize(cost) # Adam Optimizer - -correct_pred = tf.equal(tf.argmax(pred,1), tf.argmax(y,1)) -accuracy = tf.reduce_mean(tf.cast(correct_pred, tf.float32)) - -``` - -## Hooray, now train the neural network: - - -```python -# To keep track of training's performance -test_losses = [] -test_accuracies = [] -train_losses = [] -train_accuracies = [] - -# Launch the graph -sess = tf.InteractiveSession(config=tf.ConfigProto(log_device_placement=True)) -init = tf.global_variables_initializer() -sess.run(init) - -# Perform Training steps with "batch_size" amount of example data at each loop -step = 1 -while step * batch_size <= training_iters: - batch_xs = extract_batch_size(X_train, step, batch_size) - batch_ys = one_hot(extract_batch_size(y_train, step, batch_size)) - - # Fit training using batch data - _, loss, acc = sess.run( - [optimizer, cost, accuracy], - feed_dict={ - x: batch_xs, - y: batch_ys - } - ) - train_losses.append(loss) - train_accuracies.append(acc) - - # Evaluate network only at some steps for faster training: - if (step*batch_size % display_iter == 0) or (step == 1) or (step * batch_size > training_iters): - - # To not spam console, show training accuracy/loss in this "if" - print("Training iter #" + str(step*batch_size) + \ - ": Batch Loss = " + "{:.6f}".format(loss) + \ - ", Accuracy = {}".format(acc)) - - # Evaluation on the test set (no learning made here - just evaluation for diagnosis) - loss, acc = sess.run( - [cost, accuracy], - feed_dict={ - x: X_test, - y: one_hot(y_test) - } - ) - test_losses.append(loss) - test_accuracies.append(acc) - print("PERFORMANCE ON TEST SET: " + \ - "Batch Loss = {}".format(loss) + \ - ", Accuracy = {}".format(acc)) - - step += 1 - -print("Optimization Finished!") - -# Accuracy for test data - -one_hot_predictions, accuracy, final_loss = sess.run( - [pred, accuracy, cost], - feed_dict={ - x: X_test, - y: one_hot(y_test) - } -) - -test_losses.append(final_loss) -test_accuracies.append(accuracy) - -print("FINAL RESULT: " + \ - "Batch Loss = {}".format(final_loss) + \ - ", Accuracy = {}".format(accuracy)) - -``` - - WARNING:tensorflow:From :9: initialize_all_variables (from tensorflow.python.ops.variables) is deprecated and will be removed after 2017-03-02. - Instructions for updating: - Use `tf.global_variables_initializer` instead. - Training iter #1500: Batch Loss = 5.416760, Accuracy = 0.15266665816307068 - PERFORMANCE ON TEST SET: Batch Loss = 4.880829811096191, Accuracy = 0.05632847175002098 - Training iter #30000: Batch Loss = 3.031930, Accuracy = 0.607333242893219 - PERFORMANCE ON TEST SET: Batch Loss = 3.0515167713165283, Accuracy = 0.6067186594009399 - Training iter #60000: Batch Loss = 2.672764, Accuracy = 0.7386666536331177 - PERFORMANCE ON TEST SET: Batch Loss = 2.780435085296631, Accuracy = 0.7027485370635986 - Training iter #90000: Batch Loss = 2.378301, Accuracy = 0.8366667032241821 - PERFORMANCE ON TEST SET: Batch Loss = 2.6019773483276367, Accuracy = 0.7617915868759155 - Training iter #120000: Batch Loss = 2.127290, Accuracy = 0.9066667556762695 - PERFORMANCE ON TEST SET: Batch Loss = 2.3625404834747314, Accuracy = 0.8116728663444519 - Training iter #150000: Batch Loss = 1.929805, Accuracy = 0.9380000233650208 - PERFORMANCE ON TEST SET: Batch Loss = 2.306251049041748, Accuracy = 0.8276212215423584 - Training iter #180000: Batch Loss = 1.971904, Accuracy = 0.9153333902359009 - PERFORMANCE ON TEST SET: Batch Loss = 2.0835530757904053, Accuracy = 0.8771631121635437 - Training iter #210000: Batch Loss = 1.860249, Accuracy = 0.8613333702087402 - PERFORMANCE ON TEST SET: Batch Loss = 1.9994492530822754, Accuracy = 0.8788597583770752 - Training iter #240000: Batch Loss = 1.626292, Accuracy = 0.9380000233650208 - PERFORMANCE ON TEST SET: Batch Loss = 1.879166603088379, Accuracy = 0.8944689035415649 - Training iter #270000: Batch Loss = 1.582758, Accuracy = 0.9386667013168335 - PERFORMANCE ON TEST SET: Batch Loss = 2.0341007709503174, Accuracy = 0.8361043930053711 - Training iter #300000: Batch Loss = 1.620352, Accuracy = 0.9306666851043701 - PERFORMANCE ON TEST SET: Batch Loss = 1.8185184001922607, Accuracy = 0.8639293313026428 - Training iter #330000: Batch Loss = 1.474394, Accuracy = 0.9693333506584167 - PERFORMANCE ON TEST SET: Batch Loss = 1.7638503313064575, Accuracy = 0.8747878670692444 - Training iter #360000: Batch Loss = 1.406998, Accuracy = 0.9420000314712524 - PERFORMANCE ON TEST SET: Batch Loss = 1.5946787595748901, Accuracy = 0.902273416519165 - Training iter #390000: Batch Loss = 1.362515, Accuracy = 0.940000057220459 - PERFORMANCE ON TEST SET: Batch Loss = 1.5285792350769043, Accuracy = 0.9046487212181091 - Training iter #420000: Batch Loss = 1.252860, Accuracy = 0.9566667079925537 - PERFORMANCE ON TEST SET: Batch Loss = 1.4635565280914307, Accuracy = 0.9107565879821777 - Training iter #450000: Batch Loss = 1.190078, Accuracy = 0.9553333520889282 - ... - PERFORMANCE ON TEST SET: Batch Loss = 0.42567864060401917, Accuracy = 0.9324736595153809 - Training iter #2070000: Batch Loss = 0.342763, Accuracy = 0.9326667189598083 - PERFORMANCE ON TEST SET: Batch Loss = 0.4292983412742615, Accuracy = 0.9273836612701416 - Training iter #2100000: Batch Loss = 0.259442, Accuracy = 0.9873334169387817 - PERFORMANCE ON TEST SET: Batch Loss = 0.44131210446357727, Accuracy = 0.9273836612701416 - Training iter #2130000: Batch Loss = 0.284630, Accuracy = 0.9593333601951599 - PERFORMANCE ON TEST SET: Batch Loss = 0.46982717514038086, Accuracy = 0.9093992710113525 - Training iter #2160000: Batch Loss = 0.299012, Accuracy = 0.9686667323112488 - PERFORMANCE ON TEST SET: Batch Loss = 0.48389002680778503, Accuracy = 0.9138105511665344 - Training iter #2190000: Batch Loss = 0.287106, Accuracy = 0.9700000286102295 - PERFORMANCE ON TEST SET: Batch Loss = 0.4670214056968689, Accuracy = 0.9216151237487793 - Optimization Finished! - FINAL RESULT: Batch Loss = 0.45611169934272766, Accuracy = 0.9165252447128296 - - -## Training is good, but having visual insight is even better: - -Okay, let's plot this simply in the notebook for now. - - -```python -# (Inline plots: ) -%matplotlib inline - -font = { - 'family' : 'Bitstream Vera Sans', - 'weight' : 'bold', - 'size' : 18 -} -matplotlib.rc('font', **font) - -width = 12 -height = 12 -plt.figure(figsize=(width, height)) - -indep_train_axis = np.array(range(batch_size, (len(train_losses)+1)*batch_size, batch_size)) -plt.plot(indep_train_axis, np.array(train_losses), "b--", label="Train losses") -plt.plot(indep_train_axis, np.array(train_accuracies), "g--", label="Train accuracies") - -indep_test_axis = np.append( - np.array(range(batch_size, len(test_losses)*display_iter, display_iter)[:-1]), - [training_iters] -) -plt.plot(indep_test_axis, np.array(test_losses), "b-", label="Test losses") -plt.plot(indep_test_axis, np.array(test_accuracies), "g-", label="Test accuracies") - -plt.title("Training session's progress over iterations") -plt.legend(loc='upper right', shadow=True) -plt.ylabel('Training Progress (Loss or Accuracy values)') -plt.xlabel('Training iteration') - -plt.show() -``` - - -![LSTM Training Testing Comparison Curve](LSTM_files/LSTM_16_0.png) - - -## And finally, the multi-class confusion matrix and metrics! - - -```python -# Results - -predictions = one_hot_predictions.argmax(1) - -print("Testing Accuracy: {}%".format(100*accuracy)) - -print("") -print("Precision: {}%".format(100*metrics.precision_score(y_test, predictions, average="weighted"))) -print("Recall: {}%".format(100*metrics.recall_score(y_test, predictions, average="weighted"))) -print("f1_score: {}%".format(100*metrics.f1_score(y_test, predictions, average="weighted"))) - -print("") -print("Confusion Matrix:") -confusion_matrix = metrics.confusion_matrix(y_test, predictions) -print(confusion_matrix) -normalised_confusion_matrix = np.array(confusion_matrix, dtype=np.float32)/np.sum(confusion_matrix)*100 - -print("") -print("Confusion matrix (normalised to % of total test data):") -print(normalised_confusion_matrix) -print("Note: training and testing data is not equally distributed amongst classes, ") -print("so it is normal that more than a 6th of the data is correctly classifier in the last category.") - -# Plot Results: -width = 12 -height = 12 -plt.figure(figsize=(width, height)) -plt.imshow( - normalised_confusion_matrix, - interpolation='nearest', - cmap=plt.cm.rainbow -) -plt.title("Confusion matrix \n(normalised to % of total test data)") -plt.colorbar() -tick_marks = np.arange(n_classes) -plt.xticks(tick_marks, LABELS, rotation=90) -plt.yticks(tick_marks, LABELS) -plt.tight_layout() -plt.ylabel('True label') -plt.xlabel('Predicted label') -plt.show() -``` - - Testing Accuracy: 91.65252447128296% - - Precision: 91.76286479743305% - Recall: 91.65252799457076% - f1_score: 91.6437546304815% - - Confusion Matrix: - [[466 2 26 0 2 0] - [ 5 441 25 0 0 0] - [ 1 0 419 0 0 0] - [ 1 1 0 396 87 6] - [ 2 1 0 87 442 0] - [ 0 0 0 0 0 537]] - - Confusion matrix (normalised to % of total test data): - [[ 15.81269073 0.06786563 0.88225317 0. 0.06786563 0. ] - [ 0.16966406 14.96437073 0.84832031 0. 0. 0. ] - [ 0.03393281 0. 14.21784878 0. 0. 0. ] - [ 0.03393281 0.03393281 0. 13.43739319 2.95215464 - 0.20359688] - [ 0.06786563 0.03393281 0. 2.95215464 14.99830341 0. ] - [ 0. 0. 0. 0. 0. 18.22192001]] - Note: training and testing data is not equally distributed amongst classes, - so it is normal that more than a 6th of the data is correctly classifier in the last category. - - - -![Confusion Matrix](LSTM_files/LSTM_18_1.png) - - - -```python -sess.close() -``` - -## Conclusion - -Outstandingly, **the final accuracy is of 91%**! And it can peak to values such as 93.25%, at some moments of luck during the training, depending on how the neural network's weights got initialized at the start of the training, randomly. - -This means that the neural networks is almost always able to correctly identify the movement type! Remember, the phone is attached on the waist and each series to classify has just a 128 sample window of two internal sensors (a.k.a. 2.56 seconds at 50 FPS), so it amazes me how those predictions are extremely accurate given this small window of context and raw data. I've validated and re-validated that there is no important bug, and the community used and tried this code a lot. (Note: be sure to report something in the issue tab if you find bugs, otherwise [Quora](https://www.quora.com/), [StackOverflow](https://stackoverflow.com/questions/tagged/tensorflow?sort=votes&pageSize=50), and other [StackExchange](https://stackexchange.com/sites#science) sites are the places for asking questions.) - -I specially did not expect such good results for guessing between the labels "SITTING" and "STANDING". Those are seemingly almost the same thing from the point of view of a device placed at waist level according to how the dataset was originally gathered. Thought, it is still possible to see a little cluster on the matrix between those classes, which drifts away just a bit from the identity. This is great. - -It is also possible to see that there was a slight difficulty in doing the difference between "WALKING", "WALKING_UPSTAIRS" and "WALKING_DOWNSTAIRS". Obviously, those activities are quite similar in terms of movements. - -I also tried my code without the gyroscope, using only the 3D accelerometer's 6 features (and not changing the training hyperparameters), and got an accuracy of 87%. In general, gyroscopes consumes more power than accelerometers, so it is preferable to turn them off. - - -## Improvements - -In [another open-source repository of mine](https://github.com/guillaume-chevalier/HAR-stacked-residual-bidir-LSTMs), the accuracy is pushed up to nearly 94% using a special deep LSTM architecture which combines the concepts of bidirectional RNNs, residual connections, and stacked cells. This architecture is also tested on another similar activity dataset. It resembles the nice architecture used in "[Google’s Neural Machine Translation System: Bridging the Gap between Human and Machine Translation](https://arxiv.org/pdf/1609.08144.pdf)", without an attention mechanism, and with just the encoder part - as a "many to one" architecture instead of a "many to many" to be adapted to the Human Activity Recognition (HAR) problem. I also worked more on the problem and came up with the [LARNN](https://github.com/guillaume-chevalier/Linear-Attention-Recurrent-Neural-Network), however it's complicated for just a little gain. Thus the current, original activity recognition project is simply better to use for its outstanding simplicity. - -If you want to learn more about deep learning, I have also built a list of the learning ressources for deep learning which have revealed to be the most useful to me [here](https://github.com/guillaume-chevalier/Awesome-Deep-Learning-Resources). - -I also have made even more improvements as seen just below with the few lines of code for easier usage and for reaching an even better score. Note this this is still an ongoing project, [subscribe here](https://www.neuraxio.com/en/time-series-solution) to learn more. - -### Even better and easily usable in the cloud - -So I'm planning to release an easily-usable cloud solution that can be used as follow to classify or forecast your time series, and this isn't limited to Human Activity Recognition data: - -[![](https://www.neuraxio.com/images/neuraxio-ts-solution.png)](https://www.neuraxio.com/en/time-series-solution) - -Visit [the Neuraxio's Time Series Solution](https://www.neuraxio.com/en/time-series-solution) product page for more information. - -## References - -The [dataset](https://archive.ics.uci.edu/ml/datasets/Human+Activity+Recognition+Using+Smartphones) can be found on the UCI Machine Learning Repository: - -> Davide Anguita, Alessandro Ghio, Luca Oneto, Xavier Parra and Jorge L. Reyes-Ortiz. A Public Domain Dataset for Human Activity Recognition Using Smartphones. 21th European Symposium on Artificial Neural Networks, Computational Intelligence and Machine Learning, ESANN 2013. Bruges, Belgium 24-26 April 2013. - -The RNN image for "many-to-one" is taken from Karpathy's post: - -> Andrej Karpathy, The Unreasonable Effectiveness of Recurrent Neural Networks, 2015, -> http://karpathy.github.io/2015/05/21/rnn-effectiveness/ - -## Citation - -Copyright (c) 2016 Guillaume Chevalier. To cite my code, you can point to the URL of the GitHub repository, for example: - -> Guillaume Chevalier, LSTMs for Human Activity Recognition, 2016, -> https://github.com/guillaume-chevalier/LSTM-Human-Activity-Recognition - -My code is available for free and even for private usage for anyone under the [MIT License](https://github.com/guillaume-chevalier/LSTM-Human-Activity-Recognition/blob/master/LICENSE), however I ask to cite for using the code. - -## Extra links - -### Connect with me - -- [LinkedIn](https://ca.linkedin.com/in/chevalierg) -- [Twitter](https://twitter.com/guillaume_che) -- [GitHub](https://github.com/guillaume-chevalier/) -- [Quora](https://www.quora.com/profile/Guillaume-Chevalier-2) -- [YouTube](https://www.youtube.com/c/GuillaumeChevalier) -- [Machine Learning Consulting](https://www.neuraxio.com/en/) - -### Liked this project? Did it help you? Leave a [star](https://github.com/guillaume-chevalier/LSTM-Human-Activity-Recognition/stargazers), [fork](https://github.com/guillaume-chevalier/LSTM-Human-Activity-Recognition/network/members) and share the love! - -This activity recognition project has been seen in: - -- [Hacker News 1st page](https://news.ycombinator.com/item?id=13049143) -- [Awesome TensorFlow](https://github.com/jtoy/awesome-tensorflow#tutorials) -- [TensorFlow World](https://github.com/astorfi/TensorFlow-World#some-useful-tutorials) -- And more. - ---- - - - -```python -# Let's convert this notebook to a README automatically for the GitHub project's title page: -!jupyter nbconvert --to markdown LSTM.ipynb -!mv LSTM.md README.md -``` - - [NbConvertApp] Converting notebook LSTM.ipynb to markdown - [NbConvertApp] Support files will be in LSTM_files/ - [NbConvertApp] Making directory LSTM_files - [NbConvertApp] Making directory LSTM_files - [NbConvertApp] Writing 38654 bytes to LSTM.md +You may keep up to date by cloning a new version of the project later. Visit the current [LSTM REST API serving demo project's page](https://github.com/Neuraxio/LSTM-Human-Activity-Recognition) to get updates as they are coded. diff --git a/data_reading.py b/data_reading.py new file mode 100644 index 0000000..042e863 --- /dev/null +++ b/data_reading.py @@ -0,0 +1,94 @@ +import os + +import numpy as np + +INPUT_SIGNAL_TYPES = [ + "body_acc_x_", + "body_acc_y_", + "body_acc_z_", + "body_gyro_x_", + "body_gyro_y_", + "body_gyro_z_", + "total_acc_x_", + "total_acc_y_", + "total_acc_z_" +] + +LABELS = [ + "WALKING", + "WALKING_UPSTAIRS", + "WALKING_DOWNSTAIRS", + "SITTING", + "STANDING", + "LAYING" +] + +DATA_PATH = "data/" +DATASET_PATH = DATA_PATH + "UCI HAR Dataset/" + +TRAIN = "train/" +TEST = "test/" + +X_train_signals_paths = [ + DATASET_PATH + TRAIN + "Inertial Signals/" + signal + "train.txt" for signal in INPUT_SIGNAL_TYPES +] + +X_test_signals_paths = [ + DATASET_PATH + TEST + "Inertial Signals/" + signal + "test.txt" for signal in INPUT_SIGNAL_TYPES +] + +TEST_FILE_NAME = "y_test.txt" +TRAIN_FILE_NAME = "y_train.txt" + + +def load_X(X_signals_paths): + X_signals = [] + + for signal_type_path in X_signals_paths: + file = open(signal_type_path, 'r') + # Read dataset from disk, dealing with text files' syntax + X_signals.append( + [np.array(serie, dtype=np.float32) for serie in [ + row.replace(' ', ' ').strip().split(' ') for row in file + ]] + ) + file.close() + + return np.transpose(np.array(X_signals), (1, 2, 0)) + + +def load_y(y_path): + file = open(y_path, 'r') + # Read dataset from disk, dealing with text file's syntax + y_ = np.array( + [elem for elem in [ + row.replace(' ', ' ').strip().split(' ') for row in file + ]], + dtype=np.int32 + ) + file.close() + + # Substract 1 to each output class for friendly 0-based indexing + return y_ - 1 + + +def load_data(): + # Load "X" (the neural network's training and testing inputs) + + X_train = load_X(X_train_signals_paths) + # X_test = load_X(X_test_signals_paths) + + # Load "y" (the neural network's training and testing outputs) + + y_train_path = os.path.join(DATASET_PATH, TRAIN, TRAIN_FILE_NAME) + # y_test_path = os.path.join(DATASET_PATH, TEST, TEST_FILE_NAME) + + y_train = load_y(y_train_path) + # y_test = load_y(y_test_path) + + print("Some useful info to get an insight on dataset's shape and normalisation:") + print("(data_inputs shape, expected_outputs shape, every data input mean, every data input standard deviation)") + print(X_train.shape, y_train.shape, np.mean(X_train), np.std(X_train)) + print("The dataset is therefore properly normalised, as expected, but not yet one-hot encoded.") + + return X_train, y_train diff --git a/model.py b/model.py new file mode 100644 index 0000000..af7847b --- /dev/null +++ b/model.py @@ -0,0 +1,149 @@ +import numpy as np +from neuraxle.base import BaseStep, ExecutionContext +from neuraxle.data_container import DataContainer +from neuraxle.hyperparams.space import HyperparameterSamples +import tensorflow as tf + +from neuraxle_tensorflow.tensorflow_v1 import TensorflowV1ModelStep + +N_HIDDEN = 32 +N_STEPS = 128 +N_INPUTS = 9 +LAMBDA_LOSS_AMOUNT = 0.0015 +LEARNING_RATE = 0.0025 +N_CLASSES = 6 +BATCH_SIZE = 1500 + + +def create_graph(step: TensorflowV1ModelStep): + # Function returns a tensorflow LSTM (RNN) artificial neural network from given parameters. + # Moreover, two LSTM cells are stacked which adds deepness to the neural network. + # Note, some code of this notebook is inspired from an slightly different + # RNN architecture used on another dataset, some of the credits goes to + # "aymericdamien" under the MIT license. + # (NOTE: This step could be greatly optimised by shaping the dataset once + # input shape: (batch_size, n_steps, n_input) + + # Graph input/output + data_inputs = tf.placeholder(tf.float32, [None, step.hyperparams['n_steps'], step.hyperparams['n_inputs']], + name='data_inputs') + expected_outputs = tf.placeholder(tf.float32, [None, step.hyperparams['n_classes']], name='expected_outputs') + + # Graph weights + weights = { + 'hidden': tf.Variable( + tf.random_normal([step.hyperparams['n_inputs'], step.hyperparams['n_hidden']]) + ), # Hidden layer weights + 'out': tf.Variable( + tf.random_normal([step.hyperparams['n_hidden'], step.hyperparams['n_classes']], mean=1.0) + ) + } + + biases = { + 'hidden': tf.Variable( + tf.random_normal([step.hyperparams['n_hidden']]) + ), + 'out': tf.Variable( + tf.random_normal([step.hyperparams['n_classes']]) + ) + } + + data_inputs = tf.transpose( + data_inputs, + [1, 0, 2]) # permute n_steps and batch_size + + # Reshape to prepare input to hidden activation + data_inputs = tf.reshape(data_inputs, [-1, step.hyperparams['n_inputs']]) + # new shape: (n_steps*batch_size, n_input) + + # ReLU activation, thanks to Yu Zhao for adding this improvement here: + _X = tf.nn.relu( + tf.matmul(data_inputs, weights['hidden']) + biases['hidden'] + ) + + # Split data because rnn cell needs a list of inputs for the RNN inner loop + _X = tf.split(_X, step.hyperparams['n_steps'], 0) + # new shape: n_steps * (batch_size, n_hidden) + + # Define two stacked LSTM cells (two recurrent layers deep) with tensorflow + lstm_cell_1 = tf.contrib.rnn.BasicLSTMCell(step.hyperparams['n_hidden'], forget_bias=1.0, state_is_tuple=True) + lstm_cell_2 = tf.contrib.rnn.BasicLSTMCell(step.hyperparams['n_hidden'], forget_bias=1.0, state_is_tuple=True) + lstm_cells = tf.contrib.rnn.MultiRNNCell([lstm_cell_1, lstm_cell_2], state_is_tuple=True) + + # Get LSTM cell output + outputs, states = tf.contrib.rnn.static_rnn(lstm_cells, _X, dtype=tf.float32) + + # Get last time step's output feature for a "many-to-one" style classifier, + # as in the image describing RNNs at the top of this page + lstm_last_output = outputs[-1] + + # Linear activation + return tf.matmul(lstm_last_output, weights['out']) + biases['out'] + + +def create_optimizer(step: TensorflowV1ModelStep): + return tf.train.AdamOptimizer(learning_rate=step.hyperparams['learning_rate']) + + +def create_loss(step: TensorflowV1ModelStep): + # Loss, optimizer and evaluation + # L2 loss prevents this overkill neural network to overfit the data + l2 = step.hyperparams['lambda_loss_amount'] * sum(tf.nn.l2_loss(tf_var) for tf_var in tf.trainable_variables()) + + # Softmax loss + return tf.reduce_mean( + tf.nn.softmax_cross_entropy_with_logits( + labels=step['expected_outputs'], + logits=step['output'] + ) + ) + l2 + + +class ClassificationRNNTensorFlowModel(TensorflowV1ModelStep): + def setup(self) -> BaseStep: + TensorflowV1ModelStep.setup(self) + + self.losses = [] + self.accuracies = [] + + return self + + def _will_process(self, data_container: DataContainer, context: ExecutionContext) -> ('BaseStep', DataContainer): + if not isinstance(data_container.data_inputs, np.ndarray): + data_container.data_inputs = np.array(data_container.data_inputs) + + if data_container.expected_outputs is not None: + if not isinstance(data_container.expected_outputs, np.ndarray): + data_container.expected_outputs = np.array(data_container.expected_outputs) + + if data_container.expected_outputs.shape != (len(data_container.data_inputs), self.hyperparams['n_classes']): + data_container.expected_outputs = np.reshape(data_container.expected_outputs, (len(data_container.data_inputs), self.hyperparams['n_classes'])) + + return data_container, context + + def _did_fit_transform(self, data_container: DataContainer, context: ExecutionContext) -> DataContainer: + accuracy = np.mean(np.argmax(data_container.data_inputs, axis=1) == np.argmax(data_container.expected_outputs, axis=1)) + + self.accuracies.append(accuracy) + self.losses.append(self.loss) + + print("Batch Loss = " + "{:.6f}".format(self.losses[-1]) + ", Accuracy = {}".format(self.accuracies[-1])) + + return data_container + + +model_step = ClassificationRNNTensorFlowModel( + create_graph=create_graph, + create_loss=create_loss, + create_optimizer=create_optimizer +).set_hyperparams( + HyperparameterSamples({ + 'n_steps': N_STEPS, # 128 timesteps per series + 'n_inputs': N_INPUTS, # 9 input parameters per timestep + 'n_hidden': N_HIDDEN, # Hidden layer num of features + 'n_classes': N_CLASSES, # Total classes (should go up, or should go down) + 'learning_rate': LEARNING_RATE, + 'lambda_loss_amount': LAMBDA_LOSS_AMOUNT, + 'batch_size': BATCH_SIZE + }) +) diff --git a/pipeline.py b/pipeline.py new file mode 100644 index 0000000..a8c00f7 --- /dev/null +++ b/pipeline.py @@ -0,0 +1,17 @@ +from neuraxle.pipeline import MiniBatchSequentialPipeline, Joiner +from neuraxle.steps.numpy import OneHotEncoder +from neuraxle.steps.output_handlers import OutputTransformerWrapper + +from steps.lstm_rnn_tensorflow_model_wrapper import ClassificationRNNTensorFlowModel, N_CLASSES, BATCH_SIZE + + +# TODO: wrap by a validation split wrapper as issue #174 +# ValidationSplitWrapper(HumanActivityRecognitionPipeline) + +class HumanActivityRecognitionPipeline(MiniBatchSequentialPipeline): + def __init__(self): + MiniBatchSequentialPipeline.__init__(self, [ + OutputTransformerWrapper(OneHotEncoder(nb_columns=N_CLASSES, name='one_hot_encoded_label')), + ClassificationRNNTensorFlowModel(), + Joiner(batch_size=BATCH_SIZE) + ]) diff --git a/plotting.py b/plotting.py new file mode 100644 index 0000000..96280d5 --- /dev/null +++ b/plotting.py @@ -0,0 +1,17 @@ +from matplotlib import pyplot as plt + + +def plot_metric(metric_train, metric_validation=None, xlabel='x', ylabel='y', title='Metric'): + plt.plot(range(len(metric_train)), metric_train) + + legend = ['training'] + if metric_validation is not None: + plt.plot(range(len(metric_validation)), metric_validation) + legend.append('validation') + + plt.xlabel(xlabel) + plt.xlabel(ylabel) + plt.title(title) + + plt.legend(legend, loc='upper left') + plt.show() diff --git a/requirements.txt b/requirements.txt new file mode 100644 index 0000000..3e11ae1 --- /dev/null +++ b/requirements.txt @@ -0,0 +1,4 @@ +tensorflow==1.15 +tensorflow-gpu==1.15 +conv==0.2 +-e git://github.com/alexbrillant/Neuraxle.git@bb9bba79dbbf93c9b60c6c5036e9d6bf6021e5c5#egg=neuraxle diff --git a/steps/__init__.py b/steps/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/steps/custom_json_decoder_for_2darray.py b/steps/custom_json_decoder_for_2darray.py new file mode 100644 index 0000000..0d60898 --- /dev/null +++ b/steps/custom_json_decoder_for_2darray.py @@ -0,0 +1,16 @@ +import numpy as np + +from neuraxle.api.flask import JSONDataBodyDecoder + + +class CustomJSONDecoderFor2DArray(JSONDataBodyDecoder): + """This is a custom JSON decoder class that precedes the pipeline's transformation.""" + + def decode(self, data_inputs): + """ + Transform a JSON list object into an np.array object. + + :param data_inputs: json object + :return: np array for data inputs + """ + return np.array(data_inputs) diff --git a/steps/custom_json_encoder_of_outputs.py b/steps/custom_json_encoder_of_outputs.py new file mode 100644 index 0000000..b3120ce --- /dev/null +++ b/steps/custom_json_encoder_of_outputs.py @@ -0,0 +1,16 @@ +from neuraxle.api.flask import JSONDataResponseEncoder + + +class CustomJSONEncoderOfOutputs(JSONDataResponseEncoder): + """This is a custom JSON response encoder class for converting the pipeline's transformation outputs.""" + + def encode(self, data_inputs) -> dict: + """ + Convert predictions to a dict for creating a JSON Response object. + + :param data_inputs: + :return: + """ + return { + 'predictions': list(data_inputs) + } diff --git a/steps/forma_data.py b/steps/forma_data.py new file mode 100644 index 0000000..1107045 --- /dev/null +++ b/steps/forma_data.py @@ -0,0 +1,26 @@ +import numpy as np +from neuraxle.base import BaseStep, NonFittableMixin +from neuraxle.steps.output_handlers import InputAndOutputTransformerMixin + + +class FormatData(NonFittableMixin, InputAndOutputTransformerMixin, BaseStep): + def __init__(self, n_classes): + NonFittableMixin.__init__(self) + InputAndOutputTransformerMixin.__init__(self) + BaseStep.__init__(self) + self.n_classes = n_classes + + def transform(self, data_inputs): + data_inputs, expected_outputs = data_inputs + + if not isinstance(data_inputs, np.ndarray): + data_inputs = np.array(data_inputs) + + if expected_outputs is not None: + if not isinstance(expected_outputs, np.ndarray): + expected_outputs = np.array(expected_outputs) + + if expected_outputs.shape != (len(data_inputs), self.n_classes): + expected_outputs = np.reshape(expected_outputs, (len(data_inputs), self.n_classes)) + + return data_inputs, expected_outputs diff --git a/train_and_save.py b/train_and_save.py new file mode 100644 index 0000000..91e22a1 --- /dev/null +++ b/train_and_save.py @@ -0,0 +1,165 @@ +import numpy as np +import tensorflow as tf +from neuraxle.api import DeepLearningPipeline +from neuraxle.base import ExecutionContext, DEFAULT_CACHE_FOLDER +from neuraxle.hyperparams.space import HyperparameterSamples +from neuraxle.pipeline import Pipeline +from neuraxle.steps.numpy import OneHotEncoder +from neuraxle.steps.output_handlers import OutputTransformerWrapper + +from data_reading import load_data +from neuraxle_tensorflow.tensorflow_v1 import TensorflowV1ModelStep +from plotting import plot_metric +from steps.forma_data import FormatData + + +def create_graph(step: TensorflowV1ModelStep): + # Function returns a tensorflow LSTM (RNN) artificial neural network from given parameters. + # Moreover, two LSTM cells are stacked which adds deepness to the neural network. + # Note, some code of this notebook is inspired from an slightly different + # RNN architecture used on another dataset, some of the credits goes to + # "aymericdamien" under the MIT license. + # (NOTE: This step could be greatly optimised by shaping the dataset once + # input shape: (batch_size, n_steps, n_input) + + # Graph input/output + data_inputs = tf.placeholder(tf.float32, [None, step.hyperparams['n_steps'], step.hyperparams['n_inputs']], + name='data_inputs') + expected_outputs = tf.placeholder(tf.float32, [None, step.hyperparams['n_classes']], name='expected_outputs') + + # Graph weights + weights = { + 'hidden': tf.Variable( + tf.random_normal([step.hyperparams['n_inputs'], step.hyperparams['n_hidden']]) + ), # Hidden layer weights + 'out': tf.Variable( + tf.random_normal([step.hyperparams['n_hidden'], step.hyperparams['n_classes']], mean=1.0) + ) + } + + biases = { + 'hidden': tf.Variable( + tf.random_normal([step.hyperparams['n_hidden']]) + ), + 'out': tf.Variable( + tf.random_normal([step.hyperparams['n_classes']]) + ) + } + + data_inputs = tf.transpose( + data_inputs, + [1, 0, 2]) # permute n_steps and batch_size + + # Reshape to prepare input to hidden activation + data_inputs = tf.reshape(data_inputs, [-1, step.hyperparams['n_inputs']]) + # new shape: (n_steps*batch_size, n_input) + + # ReLU activation, thanks to Yu Zhao for adding this improvement here: + _X = tf.nn.relu( + tf.matmul(data_inputs, weights['hidden']) + biases['hidden'] + ) + + # Split data because rnn cell needs a list of inputs for the RNN inner loop + _X = tf.split(_X, step.hyperparams['n_steps'], 0) + # new shape: n_steps * (batch_size, n_hidden) + + # Define two stacked LSTM cells (two recurrent layers deep) with tensorflow + lstm_cell_1 = tf.contrib.rnn.BasicLSTMCell(step.hyperparams['n_hidden'], forget_bias=1.0, state_is_tuple=True) + lstm_cell_2 = tf.contrib.rnn.BasicLSTMCell(step.hyperparams['n_hidden'], forget_bias=1.0, state_is_tuple=True) + lstm_cells = tf.contrib.rnn.MultiRNNCell([lstm_cell_1, lstm_cell_2], state_is_tuple=True) + + # Get LSTM cell output + outputs, states = tf.contrib.rnn.static_rnn(lstm_cells, _X, dtype=tf.float32) + + # Get last time step's output feature for a "many-to-one" style classifier, + # as in the image describing RNNs at the top of this page + lstm_last_output = outputs[-1] + + # Linear activation + return tf.matmul(lstm_last_output, weights['out']) + biases['out'] + + +def create_optimizer(step: TensorflowV1ModelStep): + return tf.train.AdamOptimizer(learning_rate=step.hyperparams['learning_rate']) + + +def create_loss(step: TensorflowV1ModelStep): + # Loss, optimizer and evaluation + # L2 loss prevents this overkill neural network to overfit the data + l2 = step.hyperparams['lambda_loss_amount'] * sum(tf.nn.l2_loss(tf_var) for tf_var in tf.trainable_variables()) + + # Softmax loss + return tf.reduce_mean( + tf.nn.softmax_cross_entropy_with_logits( + labels=step['expected_outputs'], + logits=step['output'] + ) + ) + l2 + + +class HumanActivityRecognitionPipeline(Pipeline): + N_HIDDEN = 32 + N_STEPS = 128 + N_INPUTS = 9 + LAMBDA_LOSS_AMOUNT = 0.0015 + LEARNING_RATE = 0.0025 + N_CLASSES = 6 + BATCH_SIZE = 1500 + EPOCHS = 14 + + def __init__(self): + super().__init__([ + OutputTransformerWrapper(OneHotEncoder(nb_columns=self.N_CLASSES, name='one_hot_encoded_label')), + FormatData(n_classes=self.N_CLASSES), + TensorflowV1ModelStep( + create_graph=create_graph, + create_loss=create_loss, + create_optimizer=create_optimizer + ).set_hyperparams( + HyperparameterSamples({ + 'n_steps': self.N_STEPS, # 128 timesteps per series + 'n_inputs': self.N_INPUTS, # 9 input parameters per timestep + 'n_hidden': self.N_HIDDEN, # Hidden layer num of features + 'n_classes': self.N_CLASSES, # Total classes (should go up, or should go down) + 'learning_rate': self.LEARNING_RATE, + 'lambda_loss_amount': self.LAMBDA_LOSS_AMOUNT, + 'batch_size': self.BATCH_SIZE + }) + ) + ]) + + +def accuracy_score_classification(data_inputs, expected_outputs): + accuracy = np.mean(np.argmax(data_inputs, axis=1) == np.argmax(expected_outputs, axis=1)) + return accuracy + + +def main(): + pipeline = DeepLearningPipeline( + HumanActivityRecognitionPipeline(), + validation_size=0.15, + batch_size=HumanActivityRecognitionPipeline.BATCH_SIZE, + batch_metrics={'accuracy': accuracy_score_classification}, + shuffle_in_each_epoch_at_train=True, + n_epochs=HumanActivityRecognitionPipeline.EPOCHS, + epochs_metrics={'accuracy': accuracy_score_classification}, + scoring_function=accuracy_score_classification + ) + + data_inputs, expected_outputs = load_data() + pipeline, outputs = pipeline.fit_transform(data_inputs, expected_outputs) + + accuracies_train = pipeline.get_epoch_metric_train('accuracy') + accuracies_validation = pipeline.get_epoch_metric_validation('accuracy') + + plot_metric(accuracies_train, accuracies_validation, xlabel='epoch', ylabel='accuracy', title='Model Accuracy') + + loss = pipeline.get_step_by_name('TensorflowV1ModelStep').loss + plot_metric(loss, xlabel='batch', ylabel='softmax_cross_entropy_with_logits', title='softmax_cross_entropy_with_logits') + + pipeline.save(ExecutionContext(DEFAULT_CACHE_FOLDER)) + pipeline.teardown() + + +if __name__ == '__main__': + main()