From 60bf1d6d9952968fcc20f02ac743c532a722669f Mon Sep 17 00:00:00 2001 From: Jan Date: Wed, 6 Jul 2022 23:31:13 -0600 Subject: [PATCH] starting stateful, not turned on yet --- rnn_tutorial_jm.ipynb | 40 +- rnn_tutorial_jm_output.ipynb | 2049 +++++++++++++++++++++--------------------- 2 files changed, 1086 insertions(+), 1003 deletions(-) rewrite rnn_tutorial_jm_output.ipynb (64%) diff --git a/rnn_tutorial_jm.ipynb b/rnn_tutorial_jm.ipynb index 30b87a6..dfb578b 100644 --- a/rnn_tutorial_jm.ipynb +++ b/rnn_tutorial_jm.ipynb @@ -153,10 +153,16 @@ { "cell_type": "code", "source": [ - "def create_RNN_functional(hidden_units, dense_units, input_shape, activation,\n", - " return_sequences=False):\n", + "def create_RNN_functional(hidden_units, dense_units, input_shape=None, activation=None,\n", + " return_sequences=False,stateful=False,batch_shape=None):\n", " inputs = tf.keras.Input(shape=input_shape)\n", - " x = tf.keras.layers.SimpleRNN(hidden_units, input_shape=input_shape,\n", + " if stateful:\n", + " x = tf.keras.layers.SimpleRNN(hidden_units, batch_shape=batch_shape,\n", + " return_sequences=return_sequences,\n", + " stateful=true,\n", + " activation=activation[0])(inputs)\n", + " else:\n", + " x = tf.keras.layers.SimpleRNN(hidden_units, input_shape=input_shape,\n", " return_sequences=return_sequences,\n", " activation=activation[0])(inputs)\n", " outputs = tf.keras.layers.Dense(dense_units, activation=activation[1])(x)\n", @@ -456,6 +462,34 @@ "outputs": [] }, { + "cell_type": "code", + "source": [ + "# stateful\n", + "demo_model = create_RNN_functional(hidden_units=2, dense_units=1, input_shape=(3,1), \n", + " activation=['linear', 'linear'],return_sequences=True)\n", + "w = demo_model.get_weights()\n", + "\n", + "x = np.array([1, 2, 3])\n", + "# Reshape the input to the required sample_size x time_steps x features \n", + "x_input = np.reshape(x,(1, 3, 1))\n", + "y_pred_model = demo_model.predict(x_input)\n", + "\n", + "h = np.zeros(2)\n", + "o = np.empty(3)\n", + "for i in range(3):\n", + " h = np.dot(x[i], w[0]) + np.dot(h, w[1]) + w[2]\n", + " o[i]=np.dot(h, w[3]) + w[4]\n", + "\n", + "print(\"Prediction from network \", y_pred_model)\n", + "print(\"Prediction from our computation \", o)" + ], + "metadata": { + "id": "SLYRVhFGHa4r" + }, + "execution_count": null, + "outputs": [] + }, + { "cell_type": "markdown", "metadata": { "id": "JopR12ZaVAyS" diff --git a/rnn_tutorial_jm_output.ipynb b/rnn_tutorial_jm_output.ipynb dissimilarity index 64% index 2e80e70..833a8c9 100644 --- a/rnn_tutorial_jm_output.ipynb +++ b/rnn_tutorial_jm_output.ipynb @@ -1,1000 +1,1049 @@ -{ - "nbformat": 4, - "nbformat_minor": 0, - "metadata": { - "colab": { - "name": "rnn_tutorial_jm.ipynb", - "provenance": [], - "collapsed_sections": [] - }, - "kernelspec": { - "name": "python3", - "display_name": "Python 3" - }, - "language_info": { - "name": "python" - } - }, - "cells": [ - { - "cell_type": "markdown", - "metadata": { - "id": "hEhvqXQBNN6r" - }, - "source": [ - "# Understanding Simple Recurrent Neural Networks In Keras\n", - "From https://machinelearningmastery.com/understanding-simple-recurrent-neural-networks-in-keras/ \n", - "With changes by Jan Mandel\n", - "2021-12-26: small changes for clarity\n", - "2022-06-16: added same by functional interface" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "pINycjukQijP" - }, - "source": [ - "This tutorial is designed for anyone looking for an understanding of how recurrent neural networks (RNN) work and how to use them via the Keras deep learning library. While all the methods required for solving problems and building applications are provided by the Keras library, it is also important to gain an insight on how everything works. In this article, the computations taking place in the RNN model are shown step by step. Next, a complete end to end system for time series prediction is developed.\n", - "\n", - "After completing this tutorial, you will know:\n", - "\n", - "* The structure of RNN\n", - "* How RNN computes the output when given an input\n", - "* How to prepare data for a SimpleRNN in Keras\n", - "* How to train a SimpleRNN model\n", - "\n", - "Let’s get started." - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "3D7sqhF-QtJ4" - }, - "source": [ - "## Tutorial Overview\n", - "\n", - "This tutorial is divided into two parts; they are:\n", - "\n", - "1. The structure of the RNN\n", - " 1. Different weights and biases associated with different layers of the RNN.\n", - " 2. How computations are performed to compute the output when given an input.\n", - "2. A complete application for time series prediction." - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "jU0opwkmQ9wm" - }, - "source": [ - "## Prerequisites\n", - "\n", - "It is assumed that you have a basic understanding of RNNs before you start implementing them. An [Introduction To Recurrent Neural Networks And The Math That Powers Them](https://machinelearningmastery.com/an-introduction-to-recurrent-neural-networks-and-the-math-that-powers-them) gives you a quick overview of RNNs.\n", - "\n", - "Let’s now get right down to the implementation part." - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "-UcYCr1FMaE7" - }, - "source": [ - "## Import section" - ] - }, - { - "cell_type": "code", - "metadata": { - "id": "FimVgAB4LsI9" - }, - "source": [ - "from pandas import read_csv\n", - "import numpy as np\n", - "from keras.models import Sequential\n", - "from keras.layers import Dense, SimpleRNN\n", - "from sklearn.preprocessing import MinMaxScaler\n", - "from sklearn.metrics import mean_squared_error\n", - "import math\n", - "import matplotlib.pyplot as plt\n", - "import tensorflow as tf" - ], - "execution_count": 1, - "outputs": [] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "O-okDDv9Md4Z" - }, - "source": [ - "## Keras SimpleRNN" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "W-WQZp0qRta0" - }, - "source": [ - "The function below returns a model that includes a SimpleRNN layer and a Dense layer for learning sequential data. The input_shape specifies the parameter (time_steps x features). We’ll simplify everything and use univariate data, i.e., one feature only; the time_steps are discussed below." - ] - }, - { - "cell_type": "code", - "source": [ - "api_type = 2 # 1 = sequential, 2 = functional" - ], - "metadata": { - "id": "Qf35beQp1Ewv" - }, - "execution_count": 2, - "outputs": [] - }, - { - "cell_type": "code", - "metadata": { - "id": "Aoh0LWQ7Ltdk" - }, - "source": [ - "def create_RNN_sequential(hidden_units, dense_units, input_shape, activation):\n", - " model = Sequential()\n", - " model.add(SimpleRNN(hidden_units, input_shape=input_shape, \n", - " activation=activation[0]))\n", - " model.add(Dense(units=dense_units, activation=activation[1]))\n", - " model.compile(loss='mean_squared_error', optimizer='adam')\n", - " return model" - ], - "execution_count": 3, - "outputs": [] - }, - { - "cell_type": "code", - "source": [ - "def create_RNN_functional(hidden_units, dense_units, input_shape, activation,\n", - " return_sequences=False):\n", - " inputs = tf.keras.Input(shape=input_shape)\n", - " x = tf.keras.layers.SimpleRNN(hidden_units, input_shape=input_shape,\n", - " return_sequences=return_sequences,\n", - " activation=activation[0])(inputs)\n", - " outputs = tf.keras.layers.Dense(dense_units, activation=activation[1])(x)\n", - " model = tf.keras.Model(inputs=inputs, outputs=outputs)\n", - " model.compile(loss='mean_squared_error', optimizer='adam')\n", - " return model" - ], - "metadata": { - "id": "zBQxW0h8pvGb" - }, - "execution_count": 4, - "outputs": [] - }, - { - "cell_type": "code", - "source": [ - "def create_RNN(hidden_units, dense_units, input_shape, activation):\n", - " if api_type==1:\n", - " print('using sequential api')\n", - " return create_RNN_sequential(hidden_units, dense_units, input_shape, activation)\n", - " if api_type==2:\n", - " print('using functional api')\n", - " return create_RNN_functional(hidden_units, dense_units, input_shape, activation)\n", - " print('api_type must be 1 or 2, got ',api_type)\n", - " raise(ValueError)\n", - "\n", - "demo_model = create_RNN(hidden_units=2, dense_units=1, input_shape=(3,1), \n", - " activation=['linear', 'linear'])" - ], - "metadata": { - "id": "dYLai9HypVRo", - "colab": { - "base_uri": "https://localhost:8080/" - }, - "outputId": "4b69730d-ccc0-4081-888d-d56254bbc1ad" - }, - "execution_count": 5, - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - "using functional api\n" - ] - } - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "_CZtOyDPSuMy" - }, - "source": [ - "The object demo_model is returned with 2 hidden units created via a the SimpleRNN layer and 1 dense unit created via the Dense layer. The input_shape is set at 3×1 and a linear activation function is used in both layers for simplicity. Just to recall the linear activation function f(x)=x makes no change in the input." - ] - }, - { - "cell_type": "code", - "source": [ - "print(dir(demo_model))\n", - "# help(demo_model)\n", - "help(demo_model.get_weights)" - ], - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "TgDQmxwQpUtw", - "outputId": "cd723670-774f-4ca9-a218-5db711e2badd" - }, - "execution_count": 6, - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - "['_SCALAR_UPRANKING_ON', '_TF_MODULE_IGNORED_PROPERTIES', '__call__', '__class__', '__copy__', '__deepcopy__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getstate__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__setstate__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', '_activity_regularizer', '_add_trackable', '_add_trackable_child', '_add_variable_with_custom_getter', '_assert_compile_was_called', '_assert_weights_created', '_auto_track_sub_layers', '_autocast', '_autographed_call', '_base_model_initialized', '_build_input_shape', '_call_accepts_kwargs', '_call_arg_was_passed', '_call_fn_arg_defaults', '_call_fn_arg_positions', '_call_fn_args', '_call_full_argspec', '_callable_losses', '_cast_single_input', '_check_call_args', '_checkpoint_dependencies', '_clear_losses', '_cluster_coordinator', '_compile_was_called', '_compiled_trainable_state', '_compute_dtype', '_compute_dtype_object', '_compute_output_and_mask_jointly', '_compute_tensor_usage_count', '_configure_steps_per_execution', '_conform_to_reference_input', '_dedup_weights', '_default_training_arg', '_deferred_dependencies', '_delete_tracking', '_deserialization_dependencies', '_deserialize_from_proto', '_distribution_strategy', '_dtype', '_dtype_policy', '_dynamic', '_eager_losses', '_enable_dict_to_input_mapping', '_expects_mask_arg', '_expects_training_arg', '_feed_input_names', '_feed_input_shapes', '_feed_inputs', '_flatten', '_flatten_layers', '_flatten_modules', '_flatten_to_reference_inputs', '_functional_construction_call', '_gather_children_attribute', '_gather_saveables_for_checkpoint', '_get_call_arg_value', '_get_callback_model', '_get_cell_name', '_get_compile_args', '_get_existing_metric', '_get_input_masks', '_get_legacy_saved_model_children', '_get_node_attribute_at_index', '_get_optimizer', '_get_save_spec', '_get_trainable_state', '_graph_network_add_loss', '_graph_network_add_metric', '_handle_activity_regularization', '_handle_deferred_dependencies', '_handle_deferred_layer_dependencies', '_handle_weight_regularization', '_in_multi_worker_mode', '_inbound_nodes', '_inbound_nodes_value', '_infer_output_signature', '_init_batch_counters', '_init_call_fn_args', '_init_graph_network', '_init_set_name', '_initial_weights', '_input_coordinates', '_input_layers', '_input_spec', '_insert_layers', '_instrument_layer_creation', '_instrumented_keras_api', '_instrumented_keras_layer_class', '_instrumented_keras_model_class', '_is_compiled', '_is_graph_network', '_is_layer', '_is_model_for_instrumentation', '_jit_compile', '_keras_api_names', '_keras_api_names_v1', '_keras_tensor_symbolic_call', '_layer_call_argspecs', '_layer_checkpoint_dependencies', '_list_extra_dependencies_for_serialization', '_list_functions_for_serialization', '_lookup_dependency', '_losses', '_map_resources', '_maybe_build', '_maybe_cast_inputs', '_maybe_create_attribute', '_maybe_initialize_trackable', '_maybe_load_initial_epoch_from_ckpt', '_metrics', '_metrics_lock', '_must_restore_from_config', '_name', '_name_based_attribute_restore', '_name_based_restores', '_name_scope', '_nested_inputs', '_nested_outputs', '_network_nodes', '_no_dependency', '_nodes_by_depth', '_non_trainable_weights', '_obj_reference_counts', '_obj_reference_counts_dict', '_object_identifier', '_outbound_nodes', '_outbound_nodes_value', '_outer_name_scope', '_output_coordinates', '_output_layers', '_output_mask_cache', '_output_shape_cache', '_output_tensor_cache', '_predict_counter', '_preload_simple_restoration', '_preserve_input_structure_in_config', '_reset_compile_cache', '_restore_from_checkpoint_position', '_run_eagerly', '_run_internal_graph', '_saved_model_arg_spec', '_saved_model_inputs_spec', '_self_name_based_restores', '_self_saveable_object_factories', '_self_setattr_tracking', '_self_tracked_trackables', '_self_unconditional_checkpoint_dependencies', '_self_unconditional_deferred_dependencies', '_self_unconditional_dependency_names', '_self_update_uid', '_serialize_to_proto', '_set_call_arg_value', '_set_connectivity_metadata', '_set_dtype_policy', '_set_inputs', '_set_mask_keras_history_checked', '_set_mask_metadata', '_set_output_names', '_set_save_spec', '_set_trainable_state', '_set_training_mode', '_setattr_tracking', '_should_cast_single_input', '_should_compute_mask', '_should_eval', '_single_restoration_from_checkpoint_position', '_split_out_first_arg', '_stateful', '_steps_per_execution', '_supports_masking', '_symbolic_call', '_tensor_usage_count', '_test_counter', '_tf_api_names', '_tf_api_names_v1', '_thread_local', '_track_trackable', '_trackable_children', '_trackable_saved_model_saver', '_trackable_saver', '_tracking_metadata', '_train_counter', '_trainable', '_trainable_weights', '_training_state', '_unconditional_checkpoint_dependencies', '_unconditional_dependency_names', '_undeduplicated_weights', '_update_uid', '_updated_config', '_updates', '_use_input_spec_as_call_signature', '_validate_compile', '_validate_graph_inputs_and_outputs', '_validate_target_and_loss', 'activity_regularizer', 'add_loss', 'add_metric', 'add_update', 'add_variable', 'add_weight', 'apply', 'build', 'built', 'call', 'compile', 'compiled_loss', 'compiled_metrics', 'compute_dtype', 'compute_loss', 'compute_mask', 'compute_metrics', 'compute_output_shape', 'compute_output_signature', 'count_params', 'distribute_strategy', 'dtype', 'dtype_policy', 'dynamic', 'evaluate', 'evaluate_generator', 'finalize_state', 'fit', 'fit_generator', 'from_config', 'get_config', 'get_input_at', 'get_input_mask_at', 'get_input_shape_at', 'get_layer', 'get_losses_for', 'get_output_at', 'get_output_mask_at', 'get_output_shape_at', 'get_updates_for', 'get_weights', 'history', 'inbound_nodes', 'input', 'input_mask', 'input_names', 'input_shape', 'input_spec', 'inputs', 'layers', 'load_weights', 'loss', 'losses', 'make_predict_function', 'make_test_function', 'make_train_function', 'metrics', 'metrics_names', 'name', 'name_scope', 'non_trainable_variables', 'non_trainable_weights', 'optimizer', 'outbound_nodes', 'output', 'output_mask', 'output_names', 'output_shape', 'outputs', 'predict', 'predict_function', 'predict_generator', 'predict_on_batch', 'predict_step', 'reset_metrics', 'reset_states', 'run_eagerly', 'save', 'save_spec', 'save_weights', 'set_weights', 'state_updates', 'stateful', 'stop_training', 'submodules', 'summary', 'supports_masking', 'test_function', 'test_on_batch', 'test_step', 'to_json', 'to_yaml', 'train_function', 'train_on_batch', 'train_step', 'train_tf_function', 'trainable', 'trainable_variables', 'trainable_weights', 'updates', 'variable_dtype', 'variables', 'weights', 'with_name_scope']\n", - "Help on method get_weights in module keras.engine.training:\n", - "\n", - "get_weights() method of keras.engine.functional.Functional instance\n", - " Retrieves the weights of the model.\n", - " \n", - " Returns:\n", - " A flat list of Numpy arrays.\n", - "\n" - ] - } - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "BI0vVCjQTBPF" - }, - "source": [ - "Look at the model following https://machinelearningmastery.com/visualize-deep-learning-neural-network-model-keras/ :" - ] - }, - { - "cell_type": "code", - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 598 - }, - "id": "Rdz2nblaTMV5", - "outputId": "1456977c-479e-4520-b6cf-b3fc55547fc3" - }, - "source": [ - "print(demo_model.summary())\n", - "from keras.utils.vis_utils import plot_model\n", - "plot_model(demo_model, to_file='model_plot.png', \n", - " show_shapes=True, show_layer_names=True)" - ], - "execution_count": 7, - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - "Model: \"model\"\n", - "_________________________________________________________________\n", - " Layer (type) Output Shape Param # \n", - "=================================================================\n", - " input_1 (InputLayer) [(None, 3, 1)] 0 \n", - " \n", - " simple_rnn (SimpleRNN) (None, 2) 8 \n", - " \n", - " dense (Dense) (None, 1) 3 \n", - " \n", - "=================================================================\n", - "Total params: 11\n", - "Trainable params: 11\n", - "Non-trainable params: 0\n", - "_________________________________________________________________\n", - "None\n" - ] - }, - { - "output_type": "execute_result", - "data": { - "text/plain": [ - "" - ], - "image/png": "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\n" - }, - "metadata": {}, - "execution_count": 7 - } - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "6KMS82uNTZz4" - }, - "source": [ - "If we have m\n", - " hidden units (\n", - "m\n", - "=\n", - "2\n", - " in the above case), then:\n", - "* Input: \n", - "x\n", - "∈\n", - "R\n", - "* Hidden unit: \n", - "h\n", - "∈\n", - "Rm\n", - "* Weights for input units: \n", - "wx\n", - "∈\n", - " Rm\n", - "* Weights for hidden units: \n", - "wh\n", - "∈\n", - "Rm x m\n", - "* Bias for hidden units: \n", - "bh\n", - "∈\n", - "R\n", - "m\n", - "*Weight for the dense layer: \n", - "wy\n", - "∈\n", - "R\n", - "m\n", - "*Bias for the dense layer: \n", - "by\n", - "∈\n", - "R\n", - "\n", - "Let’s look at the above weights. The weights are generated randomly so they will be different every time. The important thing is to learn what the structure of each object being used looks like and how it interacts with others to produce the final output. The get_weights() method of the model object returns a list of arrays, which consists of the weights and the bias of each layer, in the order of the layers. The first layer's input takes two entries, the (external) input values and the values of the hidden variables from the previous step." - ] - }, - { - "cell_type": "code", - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "f-C4rYMDL1_l", - "outputId": "153b0c55-c283-4af5-d320-2595fb7df7e3" - }, - "source": [ - "w = demo_model.get_weights()\n", - "#print(len(w),' weight arrays:',w)\n", - "wname=('wx','wh','bh','wy','by','wz','bz')\n", - "for i in range(len(w)):\n", - " print(i,':',wname[i],'shape=',w[i].shape)\n", - "\n", - "wx = w[0]\n", - "wh = w[1]\n", - "bh = w[2]\n", - "wy = w[3]\n", - "by = w[4]" - ], - "execution_count": 8, - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - "0 : wx shape= (1, 2)\n", - "1 : wh shape= (2, 2)\n", - "2 : bh shape= (2,)\n", - "3 : wy shape= (2, 1)\n", - "4 : by shape= (1,)\n" - ] - } - ] - }, - { - "cell_type": "code", - "source": [ - "# help(SimpleRNN)" - ], - "metadata": { - "id": "kNzpNlwP4MSs" - }, - "execution_count": 9, - "outputs": [] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "oks2sHZlUQZB" - }, - "source": [ - "Now let’s do a simple experiment to see how the layers from a SimpleRNN and Dense layer produce an output. Keep this figure in view.\n", - "" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "eGi9cUkgUkTe" - }, - "source": [ - "We’ll input x for three time steps and let the network generate an output. The values of the hidden units at time steps 1, 2 and 3 will be computed. \n", - "h0\n", - " is initialized to the zero vector. The output \n", - "o3\n", - " is computed from \n", - "h3\n", - " and \n", - "w3\n", - ". An activation function is linear, f(x)=x, so the update of $h(k)$ and the output $o(k)$ are given by" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "QSD8ABJXxS7K" - }, - "source": [ - "\\begin{align*}\n", - "h\\left( 0\\right) = &\\left[\n", - "\\begin{array}\n", - "[c]{c}%\n", - "0\\\\\n", - "0\n", - "\\end{array}\n", - "\\right] \\\\\n", - "h\\left( k+1\\right) =&x\\left( k\\right) \\left[\n", - "\\begin{array}\n", - "[c]{c}%\n", - "w_{x,0}\\\\\n", - "w_{x,1}%\n", - "\\end{array}\n", - "\\right] +\\left[ h_{0}(k),h_{1}(k)\\right] \\left[\n", - "\\begin{array}\n", - "[c]{cc}%\n", - "w_{h,00} & w_{h,01}\\\\\n", - "w_{h,10} & w_{h,11}%\n", - "\\end{array}\n", - "\\right] +\\left[\n", - "\\begin{array}\n", - "[c]{c}%\n", - "b_{h,0}\\\\\n", - "b_{h,1}%\n", - "\\end{array}\n", - "\\right] \\\\\n", - "o(k+1)=& \\left[ h_{0}(k+1),h_{1}(k+1)\\right] \\left[\n", - "\\begin{array}\n", - "[c]{c}%\n", - "w_{y,0}\\\\\n", - "w_{y,1}%\n", - "\\end{array}\n", - "\\right] \n", - "\\end{align*}\n" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "MAvXBZodx8RP" - }, - "source": [ - "We compute this for $k=1,2,3$ and compare with the output of the model:" - ] - }, - { - "cell_type": "code", - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "kMOhAImzL7Ch", - "outputId": "514a245f-85bd-48aa-b4e5-02c355ca6d01" - }, - "source": [ - "w = demo_model.get_weights()\n", - "wx = w[0]\n", - "wh = w[1]\n", - "bh = w[2]\n", - "wy = w[3]\n", - "by = w[4]\n", - "x = np.array([1, 2, 3])\n", - "# Reshape the input to the required sample_size x time_steps x features \n", - "x_input = np.reshape(x,(1, 3, 1))\n", - "y_pred_model = demo_model.predict(x_input)\n", - "\n", - "\n", - "m = 2\n", - "h0 = np.zeros(m)\n", - "h1 = np.dot(x[0], wx) + np.dot(h0,wh) + bh\n", - "h2 = np.dot(x[1], wx) + np.dot(h1,wh) + bh\n", - "h3 = np.dot(x[2], wx) + np.dot(h2,wh) + bh\n", - "o3 = np.dot(h3, wy) + by\n", - "\n", - "print('h1 = ', h1,'h2 = ', h2,'h3 = ', h3)\n", - "\n", - "print(\"Prediction from network \", y_pred_model)\n", - "print(\"Prediction from our computation \", o3)" - ], - "execution_count": 10, - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - "h1 = [[ 1.14749658 -0.20947528]] h2 = [[ 3.29422907 -1.02074469]] h3 = [[ 6.16276048 -2.74833013]]\n", - "Prediction from network [[3.5862036]]\n", - "Prediction from our computation [[3.58620384]]\n" - ] - } - ] - }, - { - "cell_type": "code", - "source": [ - "# the same using arrays\n", - "demo_model = create_RNN_functional(hidden_units=2, dense_units=1, input_shape=(3,1), \n", - " activation=['linear', 'linear'],return_sequences=True)\n", - "w = demo_model.get_weights()\n", - "\n", - "x = np.array([1, 2, 3])\n", - "# Reshape the input to the required sample_size x time_steps x features \n", - "x_input = np.reshape(x,(1, 3, 1))\n", - "y_pred_model = demo_model.predict(x_input)\n", - "\n", - "h = np.zeros(2)\n", - "o = np.empty(3)\n", - "for i in range(3):\n", - " h = np.dot(x[i], w[0]) + np.dot(h, w[1]) + w[2]\n", - " o[i]=np.dot(h, w[3]) + w[4]\n", - "\n", - "print(\"Prediction from network \", y_pred_model)\n", - "print(\"Prediction from our computation \", o)" - ], - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "Q2kuhi2KBNY4", - "outputId": "7ac8798e-3497-44e2-d644-911ca058389f" - }, - "execution_count": 20, - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - "Prediction from network [[[0.3814198]\n", - " [0.7680409]\n", - " [0.7637329]]]\n", - "Prediction from our computation [0.38141983 0.76804086 0.76373292]\n" - ] - } - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "JopR12ZaVAyS" - }, - "source": [ - "The predictions came out the same! This confirms that we know what the network is doing." - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "dHGF-tofMpJP" - }, - "source": [ - "## Step 1, 2: Reading Data and Splitting Into Train And Test" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "5x748YZuY-yL" - }, - "source": [ - "The following function reads the train and test data from a given URL and splits it into a given percentage of train and test data. It returns single dimensional arrays for train and test data after scaling the data between 0 and 1 using MinMaxScaler from scikit-learn." - ] - }, - { - "cell_type": "code", - "metadata": { - "id": "JyrxUuiuL8gv" - }, - "source": [ - "# Parameter split_percent defines the ratio of training examples\n", - "def get_train_test(data, split_percent=0.8):\n", - " scaler = MinMaxScaler(feature_range=(0, 1))\n", - " data = scaler.fit_transform(data).flatten()\n", - " n = len(data)\n", - " # Point for splitting data into train and test\n", - " split = int(n*split_percent)\n", - " train_data = data[range(split)]\n", - " test_data = data[split:]\n", - " return train_data, test_data, data\n", - "\n", - "sunspots_url = 'https://raw.githubusercontent.com/jbrownlee/Datasets/master/monthly-sunspots.csv'\n", - "df = read_csv(sunspots_url, usecols=[1], engine='python')\n", - "train_data, test_data, data = get_train_test(np.array(df.values.astype('float32')))" - ], - "execution_count": 12, - "outputs": [] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "iCsHwJOcZMJ7" - }, - "source": [ - "Let's print the data shape so that we know what we got." - ] - }, - { - "cell_type": "code", - "metadata": { - "id": "h5AmHug8JViT", - "colab": { - "base_uri": "https://localhost:8080/" - }, - "outputId": "cd94b6d4-d289-4e71-d8a4-6a97f3cf6eda" - }, - "source": [ - "data.shape" - ], - "execution_count": 13, - "outputs": [ - { - "output_type": "execute_result", - "data": { - "text/plain": [ - "(2820,)" - ] - }, - "metadata": {}, - "execution_count": 13 - } - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "QHoBV8CSMt44" - }, - "source": [ - "## Step 3: Reshaping Data For Keras" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "B1CW_mu8Zbwb" - }, - "source": [ - "The next step is to prepare the data for Keras model training. The input array should be shaped as: **(total_samples, x time_steps, x features)**.\n", - "There are many ways of preparing time series data for training. We’ll create input rows with non-overlapping time steps. An example is shown in the figure below. Here time_steps denotes the number of previous time steps to use for predicting the next value of the time series data. We have for time_steps = 2, features = 1, and the first 6 terms are split total_samples=3 samples: 0, 10 predict the next term 20, then 20, 30 predict the next term 40, etc." - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "OeEc_dmqZmtx" - }, - "source": [ - "" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "iLqm8291Pd5X" - }, - "source": [ - "The following function get_XY() takes a one dimensional array as input and converts it to the required input X and target Y arrays." - ] - }, - { - "cell_type": "code", - "metadata": { - "id": "IxJEj52BL__o" - }, - "source": [ - "# Prepare the input X and target Y\n", - "def get_XY(dat, time_steps):\n", - " # Indices of target array\n", - " Y_ind = np.arange(time_steps, len(dat), time_steps)\n", - " Y = dat[Y_ind]\n", - " # Prepare X\n", - " rows_x = len(Y)\n", - " X = dat[range(time_steps*rows_x)]\n", - " X = np.reshape(X, (rows_x, time_steps, 1)) \n", - " return X, Y" - ], - "execution_count": 14, - "outputs": [] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "RFhadJjzQO7p" - }, - "source": [ - "For illustration, on the simple example above it returns the expected result: " - ] - }, - { - "cell_type": "code", - "metadata": { - "id": "V38oXJ32QiFK", - "colab": { - "base_uri": "https://localhost:8080/" - }, - "outputId": "a91d1a52-bee8-4dab-cb23-b6308ea31af5" - }, - "source": [ - "dat = np.linspace(0.,70.,8).reshape(-1,1)\n", - "print(\"dat shape=\",dat.shape)\n", - "X, Y = get_XY(dat, 2)\n", - "print(\"X shape=\",X.shape)\n", - "print(\"Y shape=\",Y.shape)\n", - "#print('dat=',dat)\n", - "print('X=',X)\n", - "print('Y=',Y)\n" - ], - "execution_count": 15, - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - "dat shape= (8, 1)\n", - "X shape= (3, 2, 1)\n", - "Y shape= (3, 1)\n", - "X= [[[ 0.]\n", - " [10.]]\n", - "\n", - " [[20.]\n", - " [30.]]\n", - "\n", - " [[40.]\n", - " [50.]]]\n", - "Y= [[20.]\n", - " [40.]\n", - " [60.]]\n" - ] - } - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "4V4IE7TvQpDW" - }, - "source": [ - "Now use it for the sunspot data. We’ll use 12 time_steps for the sunspots dataset as the sunspots generally have a cycle of 12 months. You can experiment with other values of time_steps." - ] - }, - { - "cell_type": "code", - "metadata": { - "id": "YBnBPDxiQsjL", - "colab": { - "base_uri": "https://localhost:8080/" - }, - "outputId": "d0568f82-fae9-432b-9d28-6cad4e473477" - }, - "source": [ - "time_steps = 24\n", - "trainX, trainY = get_XY(train_data, time_steps)\n", - "testX, testY = get_XY(test_data, time_steps)\n", - "print(\"trainX shape=\",trainX.shape)\n", - "print(\"trainY shape=\",trainY.shape)\n", - "print(\"testX shape=\",testX.shape)\n", - "print(\"testY shape=\",testY.shape)" - ], - "execution_count": 16, - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - "trainX shape= (93, 24, 1)\n", - "trainY shape= (93,)\n", - "testX shape= (23, 24, 1)\n", - "testY shape= (23,)\n" - ] - } - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "Xz2JRTGKMzo2" - }, - "source": [ - "## Step 4: Create RNN Model And Train" - ] - }, - { - "cell_type": "code", - "metadata": { - "id": "SyAE6XLnMGDO", - "colab": { - "base_uri": "https://localhost:8080/" - }, - "outputId": "027157b4-b956-446b-92aa-fc3d6952a7cb" - }, - "source": [ - "model = create_RNN(hidden_units=3, dense_units=1, input_shape=(time_steps,1), \n", - " activation=['tanh', 'tanh'])\n", - "model.fit(trainX, trainY, epochs=20, batch_size=1, verbose=2)" - ], - "execution_count": 17, - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - "using functional api\n", - "Epoch 1/20\n", - "93/93 - 2s - loss: 0.0811 - 2s/epoch - 22ms/step\n", - "Epoch 2/20\n", - "93/93 - 1s - loss: 0.0298 - 625ms/epoch - 7ms/step\n", - "Epoch 3/20\n", - "93/93 - 1s - loss: 0.0186 - 528ms/epoch - 6ms/step\n", - "Epoch 4/20\n", - "93/93 - 1s - loss: 0.0125 - 593ms/epoch - 6ms/step\n", - "Epoch 5/20\n", - "93/93 - 1s - loss: 0.0097 - 544ms/epoch - 6ms/step\n", - "Epoch 6/20\n", - "93/93 - 1s - loss: 0.0094 - 518ms/epoch - 6ms/step\n", - "Epoch 7/20\n", - "93/93 - 1s - loss: 0.0081 - 615ms/epoch - 7ms/step\n", - "Epoch 8/20\n", - "93/93 - 1s - loss: 0.0081 - 526ms/epoch - 6ms/step\n", - "Epoch 9/20\n", - "93/93 - 1s - loss: 0.0082 - 577ms/epoch - 6ms/step\n", - "Epoch 10/20\n", - "93/93 - 1s - loss: 0.0069 - 586ms/epoch - 6ms/step\n", - "Epoch 11/20\n", - "93/93 - 1s - loss: 0.0067 - 572ms/epoch - 6ms/step\n", - "Epoch 12/20\n", - "93/93 - 0s - loss: 0.0070 - 465ms/epoch - 5ms/step\n", - "Epoch 13/20\n", - "93/93 - 0s - loss: 0.0060 - 485ms/epoch - 5ms/step\n", - "Epoch 14/20\n", - "93/93 - 1s - loss: 0.0061 - 520ms/epoch - 6ms/step\n", - "Epoch 15/20\n", - "93/93 - 1s - loss: 0.0058 - 535ms/epoch - 6ms/step\n", - "Epoch 16/20\n", - "93/93 - 1s - loss: 0.0056 - 605ms/epoch - 7ms/step\n", - "Epoch 17/20\n", - "93/93 - 1s - loss: 0.0058 - 541ms/epoch - 6ms/step\n", - "Epoch 18/20\n", - "93/93 - 1s - loss: 0.0054 - 785ms/epoch - 8ms/step\n", - "Epoch 19/20\n", - "93/93 - 1s - loss: 0.0054 - 648ms/epoch - 7ms/step\n", - "Epoch 20/20\n", - "93/93 - 1s - loss: 0.0050 - 672ms/epoch - 7ms/step\n" - ] - }, - { - "output_type": "execute_result", - "data": { - "text/plain": [ - "" - ] - }, - "metadata": {}, - "execution_count": 17 - } - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "tluiPIaxM9FH" - }, - "source": [ - "## Step 5: Compute And Print The Root Mean Square Error" - ] - }, - { - "cell_type": "code", - "metadata": { - "id": "LnWdCmqJMK-k", - "colab": { - "base_uri": "https://localhost:8080/" - }, - "outputId": "633a377d-c51e-4903-a11e-d0f86375471f" - }, - "source": [ - "def print_error(trainY, testY, train_predict, test_predict): \n", - " # Error of predictions\n", - " train_rmse = math.sqrt(mean_squared_error(trainY, train_predict))\n", - " test_rmse = math.sqrt(mean_squared_error(testY, test_predict))\n", - " # Print RMSE\n", - " print('Train RMSE: %.3f RMSE' % (train_rmse))\n", - " print('Test RMSE: %.3f RMSE' % (test_rmse)) \n", - "\n", - "# make predictions\n", - "train_predict = model.predict(trainX)\n", - "test_predict = model.predict(testX)\n", - "# Mean square error\n", - "print_error(trainY, testY, train_predict, test_predict)" - ], - "execution_count": 18, - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - "Train RMSE: 0.069 RMSE\n", - "Test RMSE: 0.134 RMSE\n" - ] - } - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "eed7244NNHs9" - }, - "source": [ - "" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "nDwJvflyNGz3" - }, - "source": [ - "## Step 6: View The result" - ] - }, - { - "cell_type": "code", - "metadata": { - "id": "fQPjWHWvMMGL", - "colab": { - "base_uri": "https://localhost:8080/", - "height": 444 - }, - "outputId": "7edb1c9b-0c7a-44cc-bc5d-74f29f946930" - }, - "source": [ - "# Plot the result\n", - "def plot_result(trainY, testY, train_predict, test_predict):\n", - " actual = np.append(trainY, testY)\n", - " predictions = np.append(train_predict, test_predict)\n", - " rows = len(actual)\n", - " plt.figure(figsize=(15, 6), dpi=80)\n", - " plt.plot(range(rows), actual)\n", - " plt.plot(range(rows), predictions)\n", - " plt.axvline(x=len(trainY), color='r')\n", - " plt.legend(['Actual', 'Predictions'])\n", - " plt.xlabel('Observation number after given time steps')\n", - " plt.ylabel('Sunspots scaled')\n", - " plt.title('Actual and Predicted Values. The Red Line Separates The Training And Test Examples')\n", - "plot_result(trainY, testY, train_predict, test_predict)" - ], - "execution_count": 19, - "outputs": [ - { - "output_type": "display_data", - "data": { - "text/plain": [ - "
" - ], - "image/png": "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\n" - }, - "metadata": { - "needs_background": "light" - } - } - ] - } - ] -} \ No newline at end of file +{ + "nbformat": 4, + "nbformat_minor": 0, + "metadata": { + "colab": { + "name": "rnn_tutorial_jm.ipynb", + "provenance": [], + "collapsed_sections": [] + }, + "kernelspec": { + "name": "python3", + "display_name": "Python 3" + }, + "language_info": { + "name": "python" + } + }, + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "id": "hEhvqXQBNN6r" + }, + "source": [ + "# Understanding Simple Recurrent Neural Networks In Keras\n", + "From https://machinelearningmastery.com/understanding-simple-recurrent-neural-networks-in-keras/ \n", + "With changes by Jan Mandel\n", + "2021-12-26: small changes for clarity\n", + "2022-06-16: added same by functional interface" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "pINycjukQijP" + }, + "source": [ + "This tutorial is designed for anyone looking for an understanding of how recurrent neural networks (RNN) work and how to use them via the Keras deep learning library. While all the methods required for solving problems and building applications are provided by the Keras library, it is also important to gain an insight on how everything works. In this article, the computations taking place in the RNN model are shown step by step. Next, a complete end to end system for time series prediction is developed.\n", + "\n", + "After completing this tutorial, you will know:\n", + "\n", + "* The structure of RNN\n", + "* How RNN computes the output when given an input\n", + "* How to prepare data for a SimpleRNN in Keras\n", + "* How to train a SimpleRNN model\n", + "\n", + "Let’s get started." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "3D7sqhF-QtJ4" + }, + "source": [ + "## Tutorial Overview\n", + "\n", + "This tutorial is divided into two parts; they are:\n", + "\n", + "1. The structure of the RNN\n", + " 1. Different weights and biases associated with different layers of the RNN.\n", + " 2. How computations are performed to compute the output when given an input.\n", + "2. A complete application for time series prediction." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "jU0opwkmQ9wm" + }, + "source": [ + "## Prerequisites\n", + "\n", + "It is assumed that you have a basic understanding of RNNs before you start implementing them. An [Introduction To Recurrent Neural Networks And The Math That Powers Them](https://machinelearningmastery.com/an-introduction-to-recurrent-neural-networks-and-the-math-that-powers-them) gives you a quick overview of RNNs.\n", + "\n", + "Let’s now get right down to the implementation part." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "-UcYCr1FMaE7" + }, + "source": [ + "## Import section" + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "FimVgAB4LsI9" + }, + "source": [ + "from pandas import read_csv\n", + "import numpy as np\n", + "from keras.models import Sequential\n", + "from keras.layers import Dense, SimpleRNN\n", + "from sklearn.preprocessing import MinMaxScaler\n", + "from sklearn.metrics import mean_squared_error\n", + "import math\n", + "import matplotlib.pyplot as plt\n", + "import tensorflow as tf" + ], + "execution_count": 1, + "outputs": [] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "O-okDDv9Md4Z" + }, + "source": [ + "## Keras SimpleRNN" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "W-WQZp0qRta0" + }, + "source": [ + "The function below returns a model that includes a SimpleRNN layer and a Dense layer for learning sequential data. The input_shape specifies the parameter (time_steps x features). We’ll simplify everything and use univariate data, i.e., one feature only; the time_steps are discussed below." + ] + }, + { + "cell_type": "code", + "source": [ + "api_type = 2 # 1 = sequential, 2 = functional" + ], + "metadata": { + "id": "Qf35beQp1Ewv" + }, + "execution_count": 2, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "id": "Aoh0LWQ7Ltdk" + }, + "source": [ + "def create_RNN_sequential(hidden_units, dense_units, input_shape, activation):\n", + " model = Sequential()\n", + " model.add(SimpleRNN(hidden_units, input_shape=input_shape, \n", + " activation=activation[0]))\n", + " model.add(Dense(units=dense_units, activation=activation[1]))\n", + " model.compile(loss='mean_squared_error', optimizer='adam')\n", + " return model" + ], + "execution_count": 3, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "def create_RNN_functional(hidden_units, dense_units, input_shape=None, activation=None,\n", + " return_sequences=False,stateful=False,batch_shape=None):\n", + " inputs = tf.keras.Input(shape=input_shape)\n", + " if stateful:\n", + " x = tf.keras.layers.SimpleRNN(hidden_units, batch_shape=batch_shape,\n", + " return_sequences=return_sequences,\n", + " stateful=true,\n", + " activation=activation[0])(inputs)\n", + " else:\n", + " x = tf.keras.layers.SimpleRNN(hidden_units, input_shape=input_shape,\n", + " return_sequences=return_sequences,\n", + " activation=activation[0])(inputs)\n", + " outputs = tf.keras.layers.Dense(dense_units, activation=activation[1])(x)\n", + " model = tf.keras.Model(inputs=inputs, outputs=outputs)\n", + " model.compile(loss='mean_squared_error', optimizer='adam')\n", + " return model" + ], + "metadata": { + "id": "zBQxW0h8pvGb" + }, + "execution_count": 4, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "def create_RNN(hidden_units, dense_units, input_shape, activation):\n", + " if api_type==1:\n", + " print('using sequential api')\n", + " return create_RNN_sequential(hidden_units, dense_units, input_shape, activation)\n", + " if api_type==2:\n", + " print('using functional api')\n", + " return create_RNN_functional(hidden_units, dense_units, input_shape, activation)\n", + " print('api_type must be 1 or 2, got ',api_type)\n", + " raise(ValueError)\n", + "\n", + "demo_model = create_RNN(hidden_units=2, dense_units=1, input_shape=(3,1), \n", + " activation=['linear', 'linear'])" + ], + "metadata": { + "id": "dYLai9HypVRo", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "48aa6528-3189-45d0-f808-17bba44233a0" + }, + "execution_count": 5, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "using functional api\n" + ] + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "_CZtOyDPSuMy" + }, + "source": [ + "The object demo_model is returned with 2 hidden units created via a the SimpleRNN layer and 1 dense unit created via the Dense layer. The input_shape is set at 3×1 and a linear activation function is used in both layers for simplicity. Just to recall the linear activation function f(x)=x makes no change in the input." + ] + }, + { + "cell_type": "code", + "source": [ + "print(dir(demo_model))\n", + "# help(demo_model)\n", + "help(demo_model.get_weights)" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "TgDQmxwQpUtw", + "outputId": "b8666c9a-8d1d-45b7-d166-f1ae8071232f" + }, + "execution_count": 6, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "['_SCALAR_UPRANKING_ON', '_TF_MODULE_IGNORED_PROPERTIES', '__call__', '__class__', '__copy__', '__deepcopy__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getstate__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__setstate__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', '_activity_regularizer', '_add_trackable', '_add_trackable_child', '_add_variable_with_custom_getter', '_assert_compile_was_called', '_assert_weights_created', '_auto_track_sub_layers', '_autocast', '_autographed_call', '_base_model_initialized', '_build_input_shape', '_call_accepts_kwargs', '_call_arg_was_passed', '_call_fn_arg_defaults', '_call_fn_arg_positions', '_call_fn_args', '_call_full_argspec', '_callable_losses', '_cast_single_input', '_check_call_args', '_checkpoint_dependencies', '_clear_losses', '_cluster_coordinator', '_compile_was_called', '_compiled_trainable_state', '_compute_dtype', '_compute_dtype_object', '_compute_output_and_mask_jointly', '_compute_tensor_usage_count', '_configure_steps_per_execution', '_conform_to_reference_input', '_dedup_weights', '_default_training_arg', '_deferred_dependencies', '_delete_tracking', '_deserialization_dependencies', '_deserialize_from_proto', '_distribution_strategy', '_dtype', '_dtype_policy', '_dynamic', '_eager_losses', '_enable_dict_to_input_mapping', '_expects_mask_arg', '_expects_training_arg', '_feed_input_names', '_feed_input_shapes', '_feed_inputs', '_flatten', '_flatten_layers', '_flatten_modules', '_flatten_to_reference_inputs', '_functional_construction_call', '_gather_children_attribute', '_gather_saveables_for_checkpoint', '_get_call_arg_value', '_get_callback_model', '_get_cell_name', '_get_compile_args', '_get_existing_metric', '_get_input_masks', '_get_legacy_saved_model_children', '_get_node_attribute_at_index', '_get_optimizer', '_get_save_spec', '_get_trainable_state', '_graph_network_add_loss', '_graph_network_add_metric', '_handle_activity_regularization', '_handle_deferred_dependencies', '_handle_deferred_layer_dependencies', '_handle_weight_regularization', '_in_multi_worker_mode', '_inbound_nodes', '_inbound_nodes_value', '_infer_output_signature', '_init_batch_counters', '_init_call_fn_args', '_init_graph_network', '_init_set_name', '_initial_weights', '_input_coordinates', '_input_layers', '_input_spec', '_insert_layers', '_instrument_layer_creation', '_instrumented_keras_api', '_instrumented_keras_layer_class', '_instrumented_keras_model_class', '_is_compiled', '_is_graph_network', '_is_layer', '_is_model_for_instrumentation', '_jit_compile', '_keras_api_names', '_keras_api_names_v1', '_keras_tensor_symbolic_call', '_layer_call_argspecs', '_layer_checkpoint_dependencies', '_list_extra_dependencies_for_serialization', '_list_functions_for_serialization', '_lookup_dependency', '_losses', '_map_resources', '_maybe_build', '_maybe_cast_inputs', '_maybe_create_attribute', '_maybe_initialize_trackable', '_maybe_load_initial_epoch_from_ckpt', '_metrics', '_metrics_lock', '_must_restore_from_config', '_name', '_name_based_attribute_restore', '_name_based_restores', '_name_scope', '_nested_inputs', '_nested_outputs', '_network_nodes', '_no_dependency', '_nodes_by_depth', '_non_trainable_weights', '_obj_reference_counts', '_obj_reference_counts_dict', '_object_identifier', '_outbound_nodes', '_outbound_nodes_value', '_outer_name_scope', '_output_coordinates', '_output_layers', '_output_mask_cache', '_output_shape_cache', '_output_tensor_cache', '_predict_counter', '_preload_simple_restoration', '_preserve_input_structure_in_config', '_reset_compile_cache', '_restore_from_checkpoint_position', '_run_eagerly', '_run_internal_graph', '_saved_model_arg_spec', '_saved_model_inputs_spec', '_self_name_based_restores', '_self_saveable_object_factories', '_self_setattr_tracking', '_self_tracked_trackables', '_self_unconditional_checkpoint_dependencies', '_self_unconditional_deferred_dependencies', '_self_unconditional_dependency_names', '_self_update_uid', '_serialize_to_proto', '_set_call_arg_value', '_set_connectivity_metadata', '_set_dtype_policy', '_set_inputs', '_set_mask_keras_history_checked', '_set_mask_metadata', '_set_output_names', '_set_save_spec', '_set_trainable_state', '_set_training_mode', '_setattr_tracking', '_should_cast_single_input', '_should_compute_mask', '_should_eval', '_single_restoration_from_checkpoint_position', '_split_out_first_arg', '_stateful', '_steps_per_execution', '_supports_masking', '_symbolic_call', '_tensor_usage_count', '_test_counter', '_tf_api_names', '_tf_api_names_v1', '_thread_local', '_track_trackable', '_trackable_children', '_trackable_saved_model_saver', '_trackable_saver', '_tracking_metadata', '_train_counter', '_trainable', '_trainable_weights', '_training_state', '_unconditional_checkpoint_dependencies', '_unconditional_dependency_names', '_undeduplicated_weights', '_update_uid', '_updated_config', '_updates', '_use_input_spec_as_call_signature', '_validate_compile', '_validate_graph_inputs_and_outputs', '_validate_target_and_loss', 'activity_regularizer', 'add_loss', 'add_metric', 'add_update', 'add_variable', 'add_weight', 'apply', 'build', 'built', 'call', 'compile', 'compiled_loss', 'compiled_metrics', 'compute_dtype', 'compute_loss', 'compute_mask', 'compute_metrics', 'compute_output_shape', 'compute_output_signature', 'count_params', 'distribute_strategy', 'dtype', 'dtype_policy', 'dynamic', 'evaluate', 'evaluate_generator', 'finalize_state', 'fit', 'fit_generator', 'from_config', 'get_config', 'get_input_at', 'get_input_mask_at', 'get_input_shape_at', 'get_layer', 'get_losses_for', 'get_output_at', 'get_output_mask_at', 'get_output_shape_at', 'get_updates_for', 'get_weights', 'history', 'inbound_nodes', 'input', 'input_mask', 'input_names', 'input_shape', 'input_spec', 'inputs', 'layers', 'load_weights', 'loss', 'losses', 'make_predict_function', 'make_test_function', 'make_train_function', 'metrics', 'metrics_names', 'name', 'name_scope', 'non_trainable_variables', 'non_trainable_weights', 'optimizer', 'outbound_nodes', 'output', 'output_mask', 'output_names', 'output_shape', 'outputs', 'predict', 'predict_function', 'predict_generator', 'predict_on_batch', 'predict_step', 'reset_metrics', 'reset_states', 'run_eagerly', 'save', 'save_spec', 'save_weights', 'set_weights', 'state_updates', 'stateful', 'stop_training', 'submodules', 'summary', 'supports_masking', 'test_function', 'test_on_batch', 'test_step', 'to_json', 'to_yaml', 'train_function', 'train_on_batch', 'train_step', 'train_tf_function', 'trainable', 'trainable_variables', 'trainable_weights', 'updates', 'variable_dtype', 'variables', 'weights', 'with_name_scope']\n", + "Help on method get_weights in module keras.engine.training:\n", + "\n", + "get_weights() method of keras.engine.functional.Functional instance\n", + " Retrieves the weights of the model.\n", + " \n", + " Returns:\n", + " A flat list of Numpy arrays.\n", + "\n" + ] + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "BI0vVCjQTBPF" + }, + "source": [ + "Look at the model following https://machinelearningmastery.com/visualize-deep-learning-neural-network-model-keras/ :" + ] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 598 + }, + "id": "Rdz2nblaTMV5", + "outputId": "9afa6abe-c1e0-47cd-9c93-0b5ad1943e1e" + }, + "source": [ + "print(demo_model.summary())\n", + "from keras.utils.vis_utils import plot_model\n", + "plot_model(demo_model, to_file='model_plot.png', \n", + " show_shapes=True, show_layer_names=True)" + ], + "execution_count": 7, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Model: \"model\"\n", + "_________________________________________________________________\n", + " Layer (type) Output Shape Param # \n", + "=================================================================\n", + " input_1 (InputLayer) [(None, 3, 1)] 0 \n", + " \n", + " simple_rnn (SimpleRNN) (None, 2) 8 \n", + " \n", + " dense (Dense) (None, 1) 3 \n", + " \n", + "=================================================================\n", + "Total params: 11\n", + "Trainable params: 11\n", + "Non-trainable params: 0\n", + "_________________________________________________________________\n", + "None\n" + ] + }, + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "" + ], + "image/png": "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\n" + }, + "metadata": {}, + "execution_count": 7 + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "6KMS82uNTZz4" + }, + "source": [ + "If we have m\n", + " hidden units (\n", + "m\n", + "=\n", + "2\n", + " in the above case), then:\n", + "* Input: \n", + "x\n", + "∈\n", + "R\n", + "* Hidden unit: \n", + "h\n", + "∈\n", + "Rm\n", + "* Weights for input units: \n", + "wx\n", + "∈\n", + " Rm\n", + "* Weights for hidden units: \n", + "wh\n", + "∈\n", + "Rm x m\n", + "* Bias for hidden units: \n", + "bh\n", + "∈\n", + "R\n", + "m\n", + "*Weight for the dense layer: \n", + "wy\n", + "∈\n", + "R\n", + "m\n", + "*Bias for the dense layer: \n", + "by\n", + "∈\n", + "R\n", + "\n", + "Let’s look at the above weights. The weights are generated randomly so they will be different every time. The important thing is to learn what the structure of each object being used looks like and how it interacts with others to produce the final output. The get_weights() method of the model object returns a list of arrays, which consists of the weights and the bias of each layer, in the order of the layers. The first layer's input takes two entries, the (external) input values and the values of the hidden variables from the previous step." + ] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "f-C4rYMDL1_l", + "outputId": "f6d67620-1382-4ec7-9562-917469c4a5df" + }, + "source": [ + "w = demo_model.get_weights()\n", + "#print(len(w),' weight arrays:',w)\n", + "wname=('wx','wh','bh','wy','by','wz','bz')\n", + "for i in range(len(w)):\n", + " print(i,':',wname[i],'shape=',w[i].shape)\n", + "\n", + "wx = w[0]\n", + "wh = w[1]\n", + "bh = w[2]\n", + "wy = w[3]\n", + "by = w[4]" + ], + "execution_count": 8, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "0 : wx shape= (1, 2)\n", + "1 : wh shape= (2, 2)\n", + "2 : bh shape= (2,)\n", + "3 : wy shape= (2, 1)\n", + "4 : by shape= (1,)\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "# help(SimpleRNN)" + ], + "metadata": { + "id": "kNzpNlwP4MSs" + }, + "execution_count": 9, + "outputs": [] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "oks2sHZlUQZB" + }, + "source": [ + "Now let’s do a simple experiment to see how the layers from a SimpleRNN and Dense layer produce an output. Keep this figure in view.\n", + "" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "eGi9cUkgUkTe" + }, + "source": [ + "We’ll input x for three time steps and let the network generate an output. The values of the hidden units at time steps 1, 2 and 3 will be computed. \n", + "h0\n", + " is initialized to the zero vector. The output \n", + "o3\n", + " is computed from \n", + "h3\n", + " and \n", + "w3\n", + ". An activation function is linear, f(x)=x, so the update of $h(k)$ and the output $o(k)$ are given by" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "QSD8ABJXxS7K" + }, + "source": [ + "\\begin{align*}\n", + "h\\left( 0\\right) = &\\left[\n", + "\\begin{array}\n", + "[c]{c}%\n", + "0\\\\\n", + "0\n", + "\\end{array}\n", + "\\right] \\\\\n", + "h\\left( k+1\\right) =&x\\left( k\\right) \\left[\n", + "\\begin{array}\n", + "[c]{c}%\n", + "w_{x,0}\\\\\n", + "w_{x,1}%\n", + "\\end{array}\n", + "\\right] +\\left[ h_{0}(k),h_{1}(k)\\right] \\left[\n", + "\\begin{array}\n", + "[c]{cc}%\n", + "w_{h,00} & w_{h,01}\\\\\n", + "w_{h,10} & w_{h,11}%\n", + "\\end{array}\n", + "\\right] +\\left[\n", + "\\begin{array}\n", + "[c]{c}%\n", + "b_{h,0}\\\\\n", + "b_{h,1}%\n", + "\\end{array}\n", + "\\right] \\\\\n", + "o(k+1)=& \\left[ h_{0}(k+1),h_{1}(k+1)\\right] \\left[\n", + "\\begin{array}\n", + "[c]{c}%\n", + "w_{y,0}\\\\\n", + "w_{y,1}%\n", + "\\end{array}\n", + "\\right] \n", + "\\end{align*}\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "MAvXBZodx8RP" + }, + "source": [ + "We compute this for $k=1,2,3$ and compare with the output of the model:" + ] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "kMOhAImzL7Ch", + "outputId": "c726a247-33ef-469b-867a-a861d12d4c94" + }, + "source": [ + "w = demo_model.get_weights()\n", + "wx = w[0]\n", + "wh = w[1]\n", + "bh = w[2]\n", + "wy = w[3]\n", + "by = w[4]\n", + "x = np.array([1, 2, 3])\n", + "# Reshape the input to the required sample_size x time_steps x features \n", + "x_input = np.reshape(x,(1, 3, 1))\n", + "y_pred_model = demo_model.predict(x_input)\n", + "\n", + "\n", + "m = 2\n", + "h0 = np.zeros(m)\n", + "h1 = np.dot(x[0], wx) + np.dot(h0,wh) + bh\n", + "h2 = np.dot(x[1], wx) + np.dot(h1,wh) + bh\n", + "h3 = np.dot(x[2], wx) + np.dot(h2,wh) + bh\n", + "o3 = np.dot(h3, wy) + by\n", + "\n", + "print('h1 = ', h1,'h2 = ', h2,'h3 = ', h3)\n", + "\n", + "print(\"Prediction from network \", y_pred_model)\n", + "print(\"Prediction from our computation \", o3)" + ], + "execution_count": 10, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "h1 = [[-1.06725907 0.72348773]] h2 = [[-0.85886271 1.63453803]] h3 = [[-1.46430677 1.54551815]]\n", + "Prediction from network [[0.42967746]]\n", + "Prediction from our computation [[0.42967746]]\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "# the same using arrays\n", + "demo_model = create_RNN_functional(hidden_units=2, dense_units=1, input_shape=(3,1), \n", + " activation=['linear', 'linear'],return_sequences=True)\n", + "w = demo_model.get_weights()\n", + "\n", + "x = np.array([1, 2, 3])\n", + "# Reshape the input to the required sample_size x time_steps x features \n", + "x_input = np.reshape(x,(1, 3, 1))\n", + "y_pred_model = demo_model.predict(x_input)\n", + "\n", + "h = np.zeros(2)\n", + "o = np.empty(3)\n", + "for i in range(3):\n", + " h = np.dot(x[i], w[0]) + np.dot(h, w[1]) + w[2]\n", + " o[i]=np.dot(h, w[3]) + w[4]\n", + "\n", + "print(\"Prediction from network \", y_pred_model)\n", + "print(\"Prediction from our computation \", o)" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "Q2kuhi2KBNY4", + "outputId": "7d5d5917-8bea-4221-f9ef-2a85f2d96776" + }, + "execution_count": 11, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Prediction from network [[[1.0083389 ]\n", + " [0.89703053]\n", + " [1.7940611 ]]]\n", + "Prediction from our computation [1.00833888 0.89703049 1.794061 ]\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "# stateful\n", + "demo_model = create_RNN_functional(hidden_units=2, dense_units=1, input_shape=(3,1), \n", + " activation=['linear', 'linear'],return_sequences=True)\n", + "w = demo_model.get_weights()\n", + "\n", + "x = np.array([1, 2, 3])\n", + "# Reshape the input to the required sample_size x time_steps x features \n", + "x_input = np.reshape(x,(1, 3, 1))\n", + "y_pred_model = demo_model.predict(x_input)\n", + "\n", + "h = np.zeros(2)\n", + "o = np.empty(3)\n", + "for i in range(3):\n", + " h = np.dot(x[i], w[0]) + np.dot(h, w[1]) + w[2]\n", + " o[i]=np.dot(h, w[3]) + w[4]\n", + "\n", + "print(\"Prediction from network \", y_pred_model)\n", + "print(\"Prediction from our computation \", o)" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "SLYRVhFGHa4r", + "outputId": "ffcae068-f129-496e-f9c1-2b5d8ee59e5a" + }, + "execution_count": 12, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Prediction from network [[[0.02811029]\n", + " [0.50526243]\n", + " [1.0105247 ]]]\n", + "Prediction from our computation [0.02811029 0.5052624 1.01052474]\n" + ] + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "JopR12ZaVAyS" + }, + "source": [ + "The predictions came out the same! This confirms that we know what the network is doing." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "dHGF-tofMpJP" + }, + "source": [ + "## Step 1, 2: Reading Data and Splitting Into Train And Test" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "5x748YZuY-yL" + }, + "source": [ + "The following function reads the train and test data from a given URL and splits it into a given percentage of train and test data. It returns single dimensional arrays for train and test data after scaling the data between 0 and 1 using MinMaxScaler from scikit-learn." + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "JyrxUuiuL8gv" + }, + "source": [ + "# Parameter split_percent defines the ratio of training examples\n", + "def get_train_test(data, split_percent=0.8):\n", + " scaler = MinMaxScaler(feature_range=(0, 1))\n", + " data = scaler.fit_transform(data).flatten()\n", + " n = len(data)\n", + " # Point for splitting data into train and test\n", + " split = int(n*split_percent)\n", + " train_data = data[range(split)]\n", + " test_data = data[split:]\n", + " return train_data, test_data, data\n", + "\n", + "sunspots_url = 'https://raw.githubusercontent.com/jbrownlee/Datasets/master/monthly-sunspots.csv'\n", + "df = read_csv(sunspots_url, usecols=[1], engine='python')\n", + "train_data, test_data, data = get_train_test(np.array(df.values.astype('float32')))" + ], + "execution_count": 13, + "outputs": [] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "iCsHwJOcZMJ7" + }, + "source": [ + "Let's print the data shape so that we know what we got." + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "h5AmHug8JViT", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "6a29edd5-9583-4443-86b9-edbdff8050c8" + }, + "source": [ + "data.shape" + ], + "execution_count": 14, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "(2820,)" + ] + }, + "metadata": {}, + "execution_count": 14 + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "QHoBV8CSMt44" + }, + "source": [ + "## Step 3: Reshaping Data For Keras" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "B1CW_mu8Zbwb" + }, + "source": [ + "The next step is to prepare the data for Keras model training. The input array should be shaped as: **(total_samples, x time_steps, x features)**.\n", + "There are many ways of preparing time series data for training. We’ll create input rows with non-overlapping time steps. An example is shown in the figure below. Here time_steps denotes the number of previous time steps to use for predicting the next value of the time series data. We have for time_steps = 2, features = 1, and the first 6 terms are split total_samples=3 samples: 0, 10 predict the next term 20, then 20, 30 predict the next term 40, etc." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "OeEc_dmqZmtx" + }, + "source": [ + "" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "iLqm8291Pd5X" + }, + "source": [ + "The following function get_XY() takes a one dimensional array as input and converts it to the required input X and target Y arrays." + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "IxJEj52BL__o" + }, + "source": [ + "# Prepare the input X and target Y\n", + "def get_XY(dat, time_steps):\n", + " # Indices of target array\n", + " Y_ind = np.arange(time_steps, len(dat), time_steps)\n", + " Y = dat[Y_ind]\n", + " # Prepare X\n", + " rows_x = len(Y)\n", + " X = dat[range(time_steps*rows_x)]\n", + " X = np.reshape(X, (rows_x, time_steps, 1)) \n", + " return X, Y" + ], + "execution_count": 15, + "outputs": [] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "RFhadJjzQO7p" + }, + "source": [ + "For illustration, on the simple example above it returns the expected result: " + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "V38oXJ32QiFK", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "78928106-fde1-494d-b317-7acb619e1bb5" + }, + "source": [ + "dat = np.linspace(0.,70.,8).reshape(-1,1)\n", + "print(\"dat shape=\",dat.shape)\n", + "X, Y = get_XY(dat, 2)\n", + "print(\"X shape=\",X.shape)\n", + "print(\"Y shape=\",Y.shape)\n", + "#print('dat=',dat)\n", + "print('X=',X)\n", + "print('Y=',Y)\n" + ], + "execution_count": 16, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "dat shape= (8, 1)\n", + "X shape= (3, 2, 1)\n", + "Y shape= (3, 1)\n", + "X= [[[ 0.]\n", + " [10.]]\n", + "\n", + " [[20.]\n", + " [30.]]\n", + "\n", + " [[40.]\n", + " [50.]]]\n", + "Y= [[20.]\n", + " [40.]\n", + " [60.]]\n" + ] + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "4V4IE7TvQpDW" + }, + "source": [ + "Now use it for the sunspot data. We’ll use 12 time_steps for the sunspots dataset as the sunspots generally have a cycle of 12 months. You can experiment with other values of time_steps." + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "YBnBPDxiQsjL", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "adb1b3e9-ce11-42b7-855b-66db73c58a51" + }, + "source": [ + "time_steps = 24\n", + "trainX, trainY = get_XY(train_data, time_steps)\n", + "testX, testY = get_XY(test_data, time_steps)\n", + "print(\"trainX shape=\",trainX.shape)\n", + "print(\"trainY shape=\",trainY.shape)\n", + "print(\"testX shape=\",testX.shape)\n", + "print(\"testY shape=\",testY.shape)" + ], + "execution_count": 17, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "trainX shape= (93, 24, 1)\n", + "trainY shape= (93,)\n", + "testX shape= (23, 24, 1)\n", + "testY shape= (23,)\n" + ] + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "Xz2JRTGKMzo2" + }, + "source": [ + "## Step 4: Create RNN Model And Train" + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "SyAE6XLnMGDO", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "28868a27-1106-405e-e7ca-cc7573bd8286" + }, + "source": [ + "model = create_RNN(hidden_units=3, dense_units=1, input_shape=(time_steps,1), \n", + " activation=['tanh', 'tanh'])\n", + "model.fit(trainX, trainY, epochs=20, batch_size=1, verbose=2)" + ], + "execution_count": 18, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "using functional api\n", + "Epoch 1/20\n", + "93/93 - 2s - loss: 0.0133 - 2s/epoch - 22ms/step\n", + "Epoch 2/20\n", + "93/93 - 0s - loss: 0.0103 - 497ms/epoch - 5ms/step\n", + "Epoch 3/20\n", + "93/93 - 1s - loss: 0.0090 - 550ms/epoch - 6ms/step\n", + "Epoch 4/20\n", + "93/93 - 0s - loss: 0.0079 - 479ms/epoch - 5ms/step\n", + "Epoch 5/20\n", + "93/93 - 1s - loss: 0.0071 - 526ms/epoch - 6ms/step\n", + "Epoch 6/20\n", + "93/93 - 1s - loss: 0.0069 - 620ms/epoch - 7ms/step\n", + "Epoch 7/20\n", + "93/93 - 1s - loss: 0.0065 - 521ms/epoch - 6ms/step\n", + "Epoch 8/20\n", + "93/93 - 1s - loss: 0.0061 - 591ms/epoch - 6ms/step\n", + "Epoch 9/20\n", + "93/93 - 1s - loss: 0.0060 - 550ms/epoch - 6ms/step\n", + "Epoch 10/20\n", + "93/93 - 1s - loss: 0.0058 - 591ms/epoch - 6ms/step\n", + "Epoch 11/20\n", + "93/93 - 1s - loss: 0.0058 - 532ms/epoch - 6ms/step\n", + "Epoch 12/20\n", + "93/93 - 1s - loss: 0.0055 - 593ms/epoch - 6ms/step\n", + "Epoch 13/20\n", + "93/93 - 1s - loss: 0.0053 - 618ms/epoch - 7ms/step\n", + "Epoch 14/20\n", + "93/93 - 1s - loss: 0.0052 - 616ms/epoch - 7ms/step\n", + "Epoch 15/20\n", + "93/93 - 1s - loss: 0.0051 - 587ms/epoch - 6ms/step\n", + "Epoch 16/20\n", + "93/93 - 1s - loss: 0.0051 - 571ms/epoch - 6ms/step\n", + "Epoch 17/20\n", + "93/93 - 1s - loss: 0.0050 - 598ms/epoch - 6ms/step\n", + "Epoch 18/20\n", + "93/93 - 1s - loss: 0.0050 - 559ms/epoch - 6ms/step\n", + "Epoch 19/20\n", + "93/93 - 1s - loss: 0.0049 - 655ms/epoch - 7ms/step\n", + "Epoch 20/20\n", + "93/93 - 1s - loss: 0.0049 - 519ms/epoch - 6ms/step\n" + ] + }, + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "" + ] + }, + "metadata": {}, + "execution_count": 18 + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "tluiPIaxM9FH" + }, + "source": [ + "## Step 5: Compute And Print The Root Mean Square Error" + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "LnWdCmqJMK-k", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "61fa0c32-96e7-4af5-cc84-2853c8bccee9" + }, + "source": [ + "def print_error(trainY, testY, train_predict, test_predict): \n", + " # Error of predictions\n", + " train_rmse = math.sqrt(mean_squared_error(trainY, train_predict))\n", + " test_rmse = math.sqrt(mean_squared_error(testY, test_predict))\n", + " # Print RMSE\n", + " print('Train RMSE: %.3f RMSE' % (train_rmse))\n", + " print('Test RMSE: %.3f RMSE' % (test_rmse)) \n", + "\n", + "# make predictions\n", + "train_predict = model.predict(trainX)\n", + "test_predict = model.predict(testX)\n", + "# Mean square error\n", + "print_error(trainY, testY, train_predict, test_predict)" + ], + "execution_count": 19, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Train RMSE: 0.069 RMSE\n", + "Test RMSE: 0.102 RMSE\n" + ] + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "eed7244NNHs9" + }, + "source": [ + "" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "nDwJvflyNGz3" + }, + "source": [ + "## Step 6: View The result" + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "fQPjWHWvMMGL", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 420 + }, + "outputId": "ad07c596-5267-4cba-cca7-e44f8649cff7" + }, + "source": [ + "# Plot the result\n", + "def plot_result(trainY, testY, train_predict, test_predict):\n", + " actual = np.append(trainY, testY)\n", + " predictions = np.append(train_predict, test_predict)\n", + " rows = len(actual)\n", + " plt.figure(figsize=(15, 6), dpi=80)\n", + " plt.plot(range(rows), actual)\n", + " plt.plot(range(rows), predictions)\n", + " plt.axvline(x=len(trainY), color='r')\n", + " plt.legend(['Actual', 'Predictions'])\n", + " plt.xlabel('Observation number after given time steps')\n", + " plt.ylabel('Sunspots scaled')\n", + " plt.title('Actual and Predicted Values. The Red Line Separates The Training And Test Examples')\n", + "plot_result(trainY, testY, train_predict, test_predict)" + ], + "execution_count": 20, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": { + "needs_background": "light" + } + } + ] + } + ] +} \ No newline at end of file -- 2.11.4.GIT