From 88d51e43b2bfdf764384142f892a88929d877692 Mon Sep 17 00:00:00 2001
From: Jan <jan.mandel@gmail.com>
Date: Thu, 7 Jul 2022 00:00:10 -0600
Subject: [PATCH] cryptic graph execution error

---
 rnn_tutorial_jm_output.ipynb | 1981 ++++++++++++++++++++----------------------
 1 file changed, 932 insertions(+), 1049 deletions(-)
 rewrite rnn_tutorial_jm_output.ipynb (80%)

diff --git a/rnn_tutorial_jm_output.ipynb b/rnn_tutorial_jm_output.ipynb
dissimilarity index 80%
index 833a8c9..957f102 100644
--- a/rnn_tutorial_jm_output.ipynb
+++ b/rnn_tutorial_jm_output.ipynb
@@ -1,1049 +1,932 @@
-{
-  "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": [
-              "<IPython.core.display.Image object>"
-            ],
-            "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",
-        "R<sup>m</sup>\n",
-        "* Weights for input units: \n",
-        "w<sub>x</sub>\n",
-        "∈\n",
-        " R<sup>m</sup>\n",
-        "* Weights for hidden units: \n",
-        "w<sub>h</sub>\n",
-        "∈\n",
-        "R<sup>m x m</sup>\n",
-        "* Bias for hidden units: \n",
-        "b<sub>h</sub>\n",
-        "∈\n",
-        "R\n",
-        "<sup>m</sup>\n",
-        "*Weight for the dense layer: \n",
-        "w<sub>y</sub>\n",
-        "∈\n",
-        "R\n",
-        "<sup>m</sup>\n",
-        "*Bias for the dense layer: \n",
-        "b<sub>y</sub>\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",
-        "<img src=\"https://machinelearningmastery.com/wp-content/uploads/2021/09/rnnCode1.png\">"
-      ]
-    },
-    {
-      "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",
-        "h<sub>0</sub>\n",
-        " is initialized to the zero vector. The output \n",
-        "o<sub>3</sub>\n",
-        " is computed from \n",
-        "h<sub>3</sub>\n",
-        " and \n",
-        "w<sub>3</sub>\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": [
-        "<img src=\"https://machinelearningmastery.com/wp-content/uploads/2021/09/rnnCode2.png\">"
-      ]
-    },
-    {
-      "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": [
-              "<keras.callbacks.History at 0x7f53e8856a90>"
-            ]
-          },
-          "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": [
-              "<Figure size 1200x480 with 1 Axes>"
-            ],
-            "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": 18,
+      "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": 19,
+      "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": 20,
+      "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",
+        "    if stateful:\n",
+        "         inputs = tf.keras.Input(batch_shape=batch_shape)\n",
+        "    else:\n",
+        "         inputs = tf.keras.Input(shape=input_shape)\n",
+        "    #inputs = tf.keras.Input(shape=input_shape)\n",
+        "    x = tf.keras.layers.SimpleRNN(hidden_units,\n",
+        "                        return_sequences=return_sequences,\n",
+        "                        stateful=stateful,\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": 33,
+      "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": "10369aad-12d7-4a76-bb7f-a77bb7418a3f"
+      },
+      "execution_count": 22,
+      "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": "0e5a264f-3e1f-4e7c-83b7-683af91accae"
+      },
+      "execution_count": 23,
+      "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": "602e15fa-2bc6-4453-bb12-503ed600a5cf"
+      },
+      "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": 24,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Model: \"model_2\"\n",
+            "_________________________________________________________________\n",
+            " Layer (type)                Output Shape              Param #   \n",
+            "=================================================================\n",
+            " input_5 (InputLayer)        [(None, 3, 1)]            0         \n",
+            "                                                                 \n",
+            " simple_rnn_2 (SimpleRNN)    (None, 2)                 8         \n",
+            "                                                                 \n",
+            " dense_2 (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": [
+              "<IPython.core.display.Image object>"
+            ],
+            "image/png": "iVBORw0KGgoAAAANSUhEUgAAAcMAAAEnCAYAAADVUyhKAAAABmJLR0QA/wD/AP+gvaeTAAAgAElEQVR4nO3deVxU57kH8N8AA7Mww6JsQVEWl+CWGE0VpcYmsUbqgoDiksR44weMBjFqFLdSRONW5YrSXBOv+dTko4BYVFySGoppWvWm1/VCXUJEUUJYRAZZlOW5f6RMHdlmY87Aeb6fz/zhmfe85z3vgzzMmXPeR0JEBMYYY0y80m2EHgFjjDEmNE6GjDHGRI+TIWOMMdHjZMgYY0z07J7dcO7cOezYsUOIsTDGGGOdLj09vcW2Fp8MCwsLcfjwYYsMiJnm/PnzOH/+vNDD6FLu3bvHP98ixvEXt/biL3n20Yq0tDTMnDkT/MSF9YuIiADQ+l85rHX88y1uHH9xayf+/GgFY4wxxsmQMcaY6HEyZIwxJnqcDBljjIkeJ0PGGGOiJ0gyPHnyJJycnHD8+HEhDm82iYmJkEgkLV6DBw8WemgG6S7xYIwxYwmSDPm2ZuvC8WCMiZ0gyTAkJASVlZWYPHmyEIfXUVtbi6CgIKP3P3DgAIhI5/V///d/Zhxh5+tO8WCMMWOI/jvDffv2oaSkROhhsH/heDDGhGDxZPjtt9/Cx8cHEokEu3fvBgCkpKRAqVRCoVDg6NGjeOONN6BWq9GrVy8cPHhQu++uXbsgk8ng7u6O6OhoeHl5QSaTISgoCBcuXNC2i4mJgb29PTw9PbXbFi1aBKVSCYlEgrKyMgBAbGwsli1bhvz8fEgkEgQEBFhoFqxHV4jH6dOnoVarsXHjRktMCWNMjOgZqamp1MpmsyosLCQAlJycrN22Zs0aAkBff/01VVZWUklJCQUHB5NSqaQnT55o20VFRZFSqaS8vDyqq6uj3NxcGjlyJKlUKrp796623Zw5c8jDw0PnuNu2bSMAVFpaqt0WFhZG/v7+Rp3Hhg0bqFevXuTs7ExSqZT69u1LU6dOpf/5n/8xqj9DhYeHU3h4uMn9WHs8srKySKVSUUJCgsnnaomfb2a9OP7i1k7806zuMmlQUBDUajXc3NwQGRmJ6upq3L17V6eNnZ0dnn/+eTg4OCAwMBApKSmoqqrC/v37LTrWt99+G8eOHUNhYSEePXqEgwcP4u7duxg3bhxyc3MtOpbOYg3xCAkJgUajwbp168zSH2OMPcvqkuHT7O3tAQD19fXtthsxYgQUCgWuX79uiWFp9e7dGy+++CIcHR1hb2+PUaNGYf/+/aitrcWePXssOhZLsPZ4MMaYsaw6GRrCwcEBpaWlQg8DQ4YMga2tLW7evCn0UARlLfFgjDF9dItkWF9fj4cPH6JXr15CDwVNTU1oamqCg4OD0EMRjDXFgzHG9NEtkmFOTg6ICKNGjdJus7Oz6/Bynql+/etft9j23XffgYgwevToTj22NRMqHowxZqwumQybmppQUVGBhoYGXL16FbGxsfDx8cG8efO0bQICAvDgwQNkZmaivr4epaWluHPnTou+XF1dUVRUhIKCAlRVVRn0C/v+/fs4dOgQHj58iPr6epw7dw7vvvsufHx8sHDhQnOcapfQ2fE4deoUP1rBGOtUFk+Gu3fvxsiRIwEAK1euxNSpU5GSkoKdO3cCAIYOHYoffvgBn3zyCZYtWwYAmDhxIm7duqXto66uDkOGDIFcLkdwcDD69++Pv/zlLzqXJt977z2MHz8es2bNwoABA7BhwwbI5XIAwOjRo1FYWAgAWLhwIdzd3REYGIhJkybhwYMHep/LxIkTsXbtWvTq1QsKhQIzZszAmDFjcP78efTo0cO0ibKQ7hQPxhgzloRId2HKtLQ0zJw502rXq4yOjkZ6ejrKy8uFHorgIiIiAADp6emCjaGrxcPaf75Z5+L4i1s78U/vkpdJGxsbhR4CewrHgzHW1XXJZNhZrl+/3mpJpmdfkZGRQg+VMcaYGXWpZLh69Wrs378flZWV8PX1xeHDh83a/8CBA1tUoGjtdejQIbMet6vq7HhYi+joaJ0/hubOnduizZkzZxAXF4eMjAz4+flp27755pst2k6YMAEqlQq2trYYNGgQLl68aInTMNqWLVswcOBAyOVyKJVKDBw4EOvWrYNGozGp36amJuzcubPVKiXHjh3Dli1bWlx1yMzM1IlFz549TRqDPjj+Iom/AWu3MStjrrVJxcSYn++oqChydXWlU6dO0Y0bN6iurk7n/fXr19PkyZNJo9Fot/n7+1OPHj0IAGVlZbXo89SpUzR16lTjTsLCQkJCaPv27VRSUkJVVVWUlpZGUqmUXn/9daP7vHnzJo0ZM4YA0LBhw1ptk5SUROPGjaOKigrttqamJrp37x598803NGnSJOrRo4dBx+X4G04k8be+tUkZs0ZyuRwTJ05E//79de6S3bx5Mw4dOoS0tDSoVCqdfXbt2gUbGxtERUWhsrLS0kM2G3t7eyxatAhubm5wdHREREQEpk2bhj//+c/48ccfDe7vypUrWLVqFRYuXIgXXnihzXZLlizBsGHDMGnSJDQ0NAAAJBIJvL29ERwcjH79+hl9Tobi+Hf/+HMyZMxI33//PdatW4ff/e53kMlkLd4PCgpCbGws7t+/j+XLlwswQvM4cuRIi/Pz9vYGADx69Mjg/oYNG4aMjAzMmTOnw5Wa4uPjcfnyZSQlJRl8nM7G8e9e8edkyJiRdu3aBSLClClT2myTmJiI/v3749NPP8WZM2fa7Y+IsGPHDm0FEBcXF0ybNk1nwXN9a00CP9/lu379evj4+EAul2Po0KFITU017aT/5datW3B2dkafPn3M0l9bXFxcMG7cOCQlJVnd4xAc/+4Vf06GjBnpxIkTGDBgABQKRZtt5HI5PvvsM9jY2GDBggWorq5us218fDzi4uKwZs0alJSU4JtvvkFhYSGCg4Px008/Afh58YKlS5eitrYWKpUKqampyM/Ph5+fHxYsWKCzgtKqVauwdetW7Ny5Ez/++CMmT56M2bNn4x//+IdR51tfX4/79+9j9+7dOHPmDJKTk7WVTDrTiy++iPv37+PKlSudfixDcPy7V/w5GTJmhOrqaty+fRv+/v4dth09ejSWLl2KgoICrFq1qtU2tbW12LFjB6ZPn465c+fCyckJQ4YMwccff4yysjLs3bu3xT7t1Zqsq6tDSkoKQkNDERYWBmdnZ6xduxZSqdToOpO9e/dGr169EB8fj61bt2LmzJlG9WOo5u+Grl27ZpHj6YPj3/3ib9fWGxKJpFMPzMyHY2V5JSUlIKJ2PxU8LTExEVlZWdizZ0+rv0Ryc3Px6NEjjBgxQmf7yJEjYW9vjwsXLrTb/7O1Jm/cuIGamhoMHjxY20Yul8PT09PoOpOFhYV4+PAhLl26hLi4OOzduxfZ2dlwd3c3qj99Nc9x86cja8Dx737xbzMZmuvaMus8zeuHLl26VOCRdB3nzp0zy5fxdXV1AKB3qS6ZTIb9+/dj7NixmD9/PrZs2aLz/sOHDwEAjo6OLfZ1dnZGVVWVQeNrvhy3du1arF27Vuc9Ly8vg/pqJpVK4ebmhgkTJsDX1xf9+/fHpk2bOv3mhuY1bJvn3Bpw/Ltf/NtMhjNmzOjUAzPTNa9JyrEyjDn+8zb/BzVkKbrRo0fjgw8+wPbt27Fhwwb4+Pho33N2dgaAVn/pGVMb0s3NDcDPfzDFxsYatK8+AgICYGtri9zcXLP3/awnT54A+PecWwOOf/eLP39nyJgR3N3dIZFIDH5+bMOGDRg4cCAuXbqks33w4MFwdHRscXPDhQsX8OTJE7z00ksGHad3796QyWS4fPmyQfs9q7y8HLNnz26x/datW2hsbETv3r1N6l8fzXPs4eHR6cfSF8e/+8WfkyFjRlAoFPDz88O9e/cM2q/5cpmtrW2L7cuWLcORI0fw+eefQ6PR4Nq1a1i4cCG8vLwQFRVl8HHeeecdHDx4ECkpKdBoNGhsbMS9e/e0D0pHRkbCw8Oj3eXAlEolvvrqK2RnZ0Oj0aC+vh6XLl3C22+/DaVSiQ8++EDbVp/+jNE8x0OGDDFrv6bg+HfD+BuwXA2zMrwcm+GMXY7L29u7xfaYmBiSSqVUU1Oj3XbkyBHy9/cnANSzZ09avHhxq32uWLGixXJcTU1NtG3bNurXrx9JpVJycXGh0NBQunHjhrbNnj17SKFQEADq168f5efn0969e0mtVhMA6tOnD928eZOIiB4/fkwrV64kHx8fsrOzIzc3NwoLC6Pc3FwiIgoNDSUAtH79+nbPf8qUKeTr60uOjo7k4OBA/v7+FBkZSdeuXdNpp29/586dozFjxpCXlxcBIADk6elJQUFBdPbs2RbtQ0JCyNvbm5qamnS2L1myxGLLsXH8u3380zgZdmGcDA1nzl+Gt27dIjs7Ozpw4IC5hmdRjY2NFBwcTPv27bPK/oiIysrKSCaT0fbt21u8J3Qy5Ph3bn9EFo0/r03KmD5qa2vx5Zdf4tatW9ov9AMCApCQkICEhASjlqUSUmNjIzIzM1FVVWWWkmTm7q9ZfHw8XnjhBcTExAD4eZWWoqIifPvtt/j+++/NdpyOcPwt218zS8bf5GR4/vx5PP/887CxsYFEIoGHhwcSExPNMTazebasiqenZ6tlWBhry4MHD7QLNc+fP1+7PS4uDhEREYiMjOxSizHn5OQgIyMDp06d0vtZOUv2BwA7duzA5cuXcfLkSUilUgDA0aNHtQs1nzhxwizH0QfH37L9AQLE34CPke369a9/TQB0ym1YG39/f3JychJ6GGbDl0kN11lfA3z55Ze0cuVKs/crVpmZmbRp0yZqaGgwa78c/65BgPh3z8uktbW1rRaMZOZnibnuCvGcMGECNm/eLPQwuo2pU6ciLi6uxV2X1orjb15CxL9bJsN9+/ahpKRE6GGIgiXmmuPJGOtsnZYM9S01smvXLshkMri7uyM6OhpeXl6QyWQICgrSWY8vJiYG9vb28PT01G5btGgRlEolJBIJysrKAACxsbFYtmwZ8vPzIZFIEBAQYNT4//rXvyIwMBBOTk6QyWQYMmQIvvzySwDAu+++q/3+0d/fX/sA7TvvvAOFQgEnJyccO3YMQPtlVLZu3QqFQgGVSoWSkhIsW7YM3t7euHHjhlFj1gfpUSbGlLm2VDxPnz4NtVqNjRs3dtpcMcZExIBrqu1q7TvDNWvWEAD6+uuvqbKykkpKSig4OJiUSiU9efJE2y4qKoqUSiXl5eVRXV0d5ebm0siRI0mlUtHdu3e17ebMmUMeHh46x922bRsBoNLSUu22sLAw8vf3bzFGQ74zTE9Pp/j4eHrw4AGVl5fTqFGjdG7jDQsLI1tbW7p//77OfrNnz6Zjx45p/718+XJycHCgw4cPU0VFBa1evZpsbGzou+++05mjJUuWUHJyMk2fPp3++c9/6jVGY74zXL9+Pdnb29OBAwfo4cOHdPXqVRo+fDj17NmTiouLte1MmWtLxDMrK4tUKhUlJCQYdP786JC4cfzFTfDvDNsrNdLMzs5O+2klMDAQKSkpqKqqMrrciKnCw8Px29/+Fi4uLnB1dcWUKVNQXl6O0tJSAMDChQvR2NioMz6NRoPvvvsOkyZNAmBYGZXNmzdj8eLFyMjIwMCBAzvlnIwpE2Oszo5nSEgINBoN1q1bZ5b+GGPiZvHvDJ8tNdKWESNGQKFQGF1uxNyab+1tXpj3V7/6Ffr374///u//1lZgPnToECIjI7Vf+nZGGRVTmFomxhTWFk/GGHuaVd9A4+DgoP0kZmknTpzAK6+8Ajc3Nzg4OODDDz/UeV8ikSA6Oho//PADvv76awDAH//4R/zHf/yHts3TZVSav2OUSCS4c+cOampqLHcy/2LuMjGGEjKejDHWHqtNhvX19UaVLjHWN998o60PePfuXYSGhsLT0xMXLlxAZWVli/pjADBv3jzIZDJ8+umnuHHjBtRqNfr06aN9/+kyKkSk8zp37pxFzutp5i4TYwhLx5MxxgzRZj1DoeXk5ICIMGrUKO02Ozu7Di+vGut///d/oVQqAQDXrl1DfX093nvvPfj5+QFovZq8i4sLZs6ciUOHDkGlUmHBggU675urjIq5GFImxtxzbel4MsaYIazmk2FTUxMqKirQ0NCAq1evIjY2Fj4+Ppg3b562TUBAAB48eIDMzEzU19ejtLQUd+7cadGXq6srioqKUFBQgKqqqnZ/4dbX1+Onn35CTk6ONhk2F908c+YM6urqcOvWrTa/T1u4cCEeP36MrKwsTJ48Wec9fcqoWJIhZWJMnevOjuepU6f40QrGmPkYcOtpq86fP0+DBg0iGxsbbSmOjRs3GlRqJCoqiqRSKXl7e5OdnR2p1WqaNm0a5efn6xyrvLycxo8fTzKZjHx9fen999+nFStWEAAKCAjQ3rZ/8eJF6tOnD8nlcho7diz94Q9/0JZVae915MgR7bFWrlxJrq6u5OzsTBEREbR7924CQP7+/jqPBxARvfjiixQXF9fq/LRXRmXLli0kl8sJAPXu3dvg1e+NebRCnzIxRMbPdXFxcafHs7i4mE6ePEkqlYoSExMNOn++tV7cOP7iZvUlnKKiosjV1dWixzSnSZMm0Q8//GDx41rr2qTWHE/+ZShuHH9xE/w5Q300P7LQFTx92fXq1auQyWTw9fUVcETWpyvFkzHGrPYGGmu2cuVKLFy4EESEd955BwcOHBB6SIwxxkwg+CfD1atXY//+/aisrISvry8OHz4s9JA6pFAoMHDgQLz22muIj49HYGCg0EOyGl0xnowxJngy3LRpEx4/fgwiwu3btxEeHi70kDqUmJiIxsZG3L17t8UdpGLXFePJGGOCJ0PGGGNMaJwMGWOMiR4nQ8YYY6LHyZAxxpjotfloRVpamiXHwYxw7949ABwrQzQvkM5zJk4cf3Frr0CChOhfxfj+JS0tDTNnzuz0QTHGGGNCeCbtAUB6i2TIGLOc5j8++b8hY4JK5+8MGWOMiR4nQ8YYY6LHyZAxxpjocTJkjDEmepwMGWOMiR4nQ8YYY6LHyZAxxpjocTJkjDEmepwMGWOMiR4nQ8YYY6LHyZAxxpjocTJkjDEmepwMGWOMiR4nQ8YYY6LHyZAxxpjocTJkjDEmepwMGWOMiR4nQ8YYY6LHyZAxxpjocTJkjDEmepwMGWOMiR4nQ8YYY6LHyZAxxpjocTJkjDEmepwMGWOMiR4nQ8YYY6LHyZAxxpjocTJkjDEmepwMGWOMiR4nQ8YYY6LHyZAxxpjocTJkjDEmepwMGWOMiZ6d0ANgTCzu3buHt99+G42NjdptFRUVUKlUeOWVV3TaDhgwAP/1X/9l4REyJl6cDBmzkF69euHOnTvIz89v8d7Zs2d1/v3LX/7SUsNijIEvkzJmUW+99RakUmmH7SIjIy0wGsZYM06GjFnQnDlz0NDQ0G6bQYMGITAw0EIjYowBnAwZsyh/f38MHToUEomk1felUinefvttC4+KMcbJkDELe+utt2Bra9vqew0NDYiIiLDwiBhjnAwZs7BZs2ahqampxXYbGxuMGjUKffv2tfygGBM5ToaMWZiXlxfGjBkDGxvd/342NjZ46623BBoVY+LGyZAxAbz55pstthERpk+fLsBoGGOcDBkTQHh4uM73hra2tnjttdfg7u4u4KgYEy9OhowJwMXFBa+//ro2IRIR5s6dK/CoGBMvToaMCWTu3LnaG2mkUimmTZsm8IgYEy9OhowJZMqUKXBwcAAATJ48GY6OjgKPiDHx4mTImECUSqX20yBfImVMWBIiIpM6aGMlDcYYY8wSwsPDkZ6ebkoX6WapWhEbG4vRo0eboyvWxcycOZPjb6CdO3cCAJYuXYrGxkakpqZi9uzZAo+KGevpeDLLa55/U5klGY4ePRozZswwR1esi5k5cybH30DNf8E2z1loaChkMpmQQ2ImeDaezLJM/ESoxd8ZMiYwToSMCY+TIWOMMdHjZMgYY0z0OBkyxhgTPU6GjDHGRM+qkuHJkyfh5OSE48ePW+yY27dvh7u7OyQSCT7++GOLHVcoCQkJCAwMhFqthoODAwICAvDhhx/i0aNHgo5LiNgzxlgzq0qGJj7/b5Tly5fj73//u8WPK5Ts7GwsXrwYBQUFKCsrw6ZNm5CUlCR4dXUhYs8YY83M8pyhuYSEhKCyslLoYXRrjo6OiIqK0lZLmDFjBjIyMpCWlobCwkL07t1bkHFZU+xra2vx6quviuqPJMbEzqqSIet8WVlZLbb17NkTAFBTU2Pp4Vilffv2oaSkROhhMMYsyOKXSc+ePYuXX34ZCoUCarUaQ4YMgUajwbfffgsfHx9IJBLs3r0bAJCUlASlUgkbGxu89NJL8PDwgFQqhVKpxPDhwxEcHIzevXtDJpPB2dkZH374ofY4u3btgkwmg7u7O6Kjo+Hl5QWZTIagoCBcuHChw3E2NjZi/fr18PHxgVwux9ChQ5GammrQuW7duhUKhQIqlQolJSVYtmwZvL29sWTJEiiVSigUChw9ehRvvPEG1Go1evXqhYMHD2r3T0lJ0audqe7fvw+5XA5fX1+z9WmI1mKv77nrG+eYmBjY29vD09NTu23RokVQKpWQSCQoKysD8PPSgsuWLUN+fj4kEgkCAgIAAKdPn4ZarcbGjRstMSWMMUsjEwGg1NRUvdo+evSI1Go1bdmyhWpra6m4uJimT59OpaWlRERUWFhIACg5OVm7z29/+1sCQBcuXKDq6moqKyujiRMnEgA6ceIElZaWUnV1NcXExBAAunz5snbfqKgoUiqVlJeXR3V1dZSbm0sjR44klUpFd+/e1ba7desWAaA//OEP2m3Lly8nBwcHOnz4MFVUVNDq1avJxsaGvvvuO4PmZ82aNQSAlixZQsnJyTR9+nT65z//qd3+9ddfU2VlJZWUlFBwcDAplUp68uRJi/07ames6upqUqlUFBMTY9T+hsS/Pa3FXt9z1zfOc+bMIQ8PD53jbtu2jQBofwaJiMLCwsjf31+nXVZWFqlUKkpISDD5XMPDwyk8PNzkfph14HgKy0zzn2bRT4YFBQXQaDQYNGgQZDIZPDw8kJGRob1M157AwEAoFAr06NEDs2bNAgD4+PigZ8+eUCgU2hI4169f19nPzs4Ozz//PBwcHBAYGIiUlBRUVVVh//79bR6rrq4OKSkpCA0NRVhYGJydnbF27VpIpdJ292vP5s2bsXjxYmRkZGDgwIHa7UFBQVCr1XBzc0NkZCSqq6tx9+7dFvvr285QmzZtgpeXFxITE03uq7Poc+7GxNkQISEh0Gg0WLdunVn6Y4xZF4smQz8/P7i7u2Pu3LmIj49HQUGBUf3Y29sDABoaGrTbpFIpAKC+vr7dfUeMGAGFQtEiaT7txo0bqKmpweDBg7Xb5HI5PD09293PVM3n1dE56NuuI0eOHEFaWhq+/PJLqFQqk/qyFH3PXZ84M8ZYM4smQ7lcjuzsbIwdOxYbN26En58fIiMjUVtba8lhwMHBAaWlpW2+X11dDQBYu3YtJBKJ9nXnzp1uc5PJoUOHsHnzZuTk5KBv375CD6dTdBRnxhhrZvEbaAYNGoTjx4+jqKgIK1euRGpqKrZv326x49fX1+Phw4fo1atXm23c3NwA/Fwni4h0XufOnbPUUDtNcnIyPv/8c2RnZ+O5554TejidQp84M8ZYM4smw6KiIuTl5QH4OeF89NFHGD58uHabJeTk5ICIMGrUqDbbNN+hevnyZYuNyxKICCtXrsS1a9eQmZkJR0dHoYfUaVqLs52dncmXlhlj3ZPFk2F0dDSuX7+OJ0+e4NKlS7hz5067iclUTU1NqKioQENDA65evYrY2Fj4+Phg3rx5be4jk8nwzjvv4ODBg0hJSYFGo0FjYyPu3buHH3/8sdPG2tny8vKwdetWfPLJJ5BKpTqXgCUSiUU/oZubPnEOCAjAgwcPkJmZifr6epSWluLOnTst+nJ1dUVRUREKCgpQVVWF+vp6nDp1ih+tYKw7M/V+VBhwa31BQQEFBQWRi4sL2dra0nPPPUdr1qyhhoYGSk5OJk9PTwJACoWCpkyZQklJSaRQKAgA9e3bl/7617/S5s2bycnJiQCQh4cHffHFF3To0CHy8PAgAOTi4kIHDx4kop9vuZdKpeTt7U12dnakVqtp2rRplJ+frx3T73//e+2+SqWSpk+fTkREjx8/ppUrV5KPjw/Z2dmRm5sbhYWFUW5urt5zs2XLFpLL5QSAevfuTQcOHCAioj179mjPq1+/fpSfn0979+4ltVpNAKhPnz508+ZNvdvp69q1awSgzde2bdv07quZIfFvS2uxN+Tc9YkzEVF5eTmNHz+eZDIZ+fr60vvvv08rVqwgABQQEKB9DOPixYvUp08fksvlNHbsWCouLqaTJ0+SSqWixMREk86ViG/F7244nsIy16MVEiLTFoWUSCRITU3FjBkzTOmmU0RHRyM9PR3l5eVCD6Xbsob4d7U4N68Dm56eLvBImDlwPIVlpvlPt6qFujtDY2Oj0ENgFsBxZoyZotsnQ3O7fv16i+/aWntFRkaKcjys8505cwZxcXHIyMiAn5+fNsZvvvlmi7YTJkyASqWCra0tBg0ahIsXLwowYv1t2bIFAwcOhFwuh1KpxMCBA7Fu3TpoNBqT+m1qasLOnTsRFBTU4r1jx45hy5Ytgv1B1Z3jqU/JOKHnX8vUC60w03Jc5hYXF0f29vba7xvT09OFHlK3JHT8u2KcTfmOY/369TR58mTSaDTabf7+/tSjRw8CQFlZWS32OXXqFE2dOtXo8VpSSEgIbd++nUpKSqiqqorS0tJIKpXS66+/bnSfN2/epDFjxhAAGjZsWKttkpKSaNy4cVRRUWFw/xzPto0bN4727NlD5eXlpNFoKDU1laRSKU2cOFGnnVDz/xTLLsdmSZs2bcLjx49BRLh9+zbCw8OFHhLrBGKK8+bNm3Ho0CGkpaW1WDFo165dsLGxQVRUlNWUwjKGvb09Fi1aBDc3Nzg6OiIiIgLTpk3Dn//8Z8nNoHcAACAASURBVKPu5L5y5QpWrVqFhQsX4oUXXmiz3ZIlSzBs2DBMmjRJZ2WrziSGeDaXjHN1dYVKpcKMGTMQGhqK06dPo7CwUNtOiPl/VrdNhox1J99//z3WrVuH3/3ud5DJZC3eDwoKQmxsLO7fv4/ly5cLMELzOHLkSIvz8/b2BgCdS2v6GjZsGDIyMjBnzhw4ODi02zY+Ph6XL19GUlKSwccxlFjimZWVpa2d2qytknGWnP/WcDJkrAvYtWsXiAhTpkxps01iYiL69++PTz/9FGfOnGm3PyLCjh07tIubu7i4YNq0aTpruRpSQswcJc/acuvWLTg7O6NPnz5m6a8tLi4uGDduHJKSkkCm3WTfITHHs62ScZac/9ZwMmSsCzhx4gQGDBgAhULRZhu5XI7PPvsMNjY2WLBggXaN3dbEx8cjLi4Oa9asQUlJCb755hsUFhYiODgYP/30EwDgvffew9KlS1FbWwuVSoXU1FTk5+fDz88PCxYs0FnNZ9WqVdi6dSt27tyJH3/8EZMnT8bs2bPxj3/8w6jzra+vx/3797F7926cOXMGycnJ2kXaO9OLL76I+/fv48qVK516HLHFs1lNTQ2ys7OxYMGCVuNpqflvDSdDxqxcdXU1bt++DX9//w7bjh49GkuXLkVBQQFWrVrVapva2lrs2LED06dPx9y5c+Hk5IQhQ4bg448/RllZGfbu3dtin/bKaHVGybPevXujV69eiI+Px9atWzFz5kyj+jFUv379AADXrl3rtGOIMZ7NOioZZ4n5b4udOTrpDotXM+Nx/A1z7949gxYQLykpARG1+yniaYmJicjKysKePXtaTSK5ubl49OgRRowYobN95MiRsLe3x4ULF9rt/9kyWp1R8qywsBAPHz7EpUuXEBcXh7179yI7Oxvu7u5G9aev5jlu/jTVGcQYT+DfJeO++uqrNkvGWWL+22KWZJiUlCTYl55MeBx/wxly12tdXR0AdHgDSDOZTIb9+/dj7NixmD9/PrZs2aLz/sOHDwGg1YXanZ2dUVVVpffYAN2SZ2vXrtV5z8vLy6C+mkmlUri5uWHChAnw9fVF//79sWnTpk7/OZPL5QD+PeedQYzxPHToEHbs2IGcnJx2K+VYYv7bYpbLpKmpqS1KHfFLHC+Ov+EvQx//aP4FYchDyaNHj8YHH3yAW7duYcOGDTrvOTs7A0CrvySNKXvV2SXPAgICYGtri9zcXJP76siTJ08A/HvOO4PY4mlIyThLzH9b+DtDxqycu7s7JBKJwc+bbdiwAQMHDsSlS5d0tg8ePBiOjo4tboa4cOECnjx5gpdeesmg45ir5Fl5eTlmz57dYvutW7fQ2NiI3r17m9S/Pprn2MPDo9OOIZZ4EhleMs4S898WToaMWTmFQgE/Pz/cu3fPoP2aL689+5yXTCbDsmXLcOTIEXz++efQaDS4du0aFi5cCC8vL0RFRRl8nI5KnkVGRsLDw6Pd5cOUSiW++uorZGdnQ6PRoL6+HpcuXcLbb78NpVKJDz74QNtWn/6M0TzHQ4YMMWu/TxNLPI0pGWeJ+W8TmQhWuhwbswyOv+GMWT4qJiaGpFIp1dTUaLcdOXKE/P39CQD17NmTFi9e3Oq+K1asaLF8V1NTE23bto369etHUqmUXFxcKDQ0lG7cuKFtY0gZrY5KnoWGhhIAWr9+fbvnOWXKFPL19SVHR0dycHAgf39/ioyMpGvXrum007e/c+fO0ZgxY8jLy0tbqszT05OCgoLo7NmzLdqHhISQt7c3NTU1tdvv0zierTOmZJyl5r8VaZwMmUk4/oYz5j/vrVu3yM7OTlsTs6tpbGyk4OBg2rdvn1X2R0RUVlZGMpmMtm/fbtB+HE/zsOT8t6L7rk3KWHcSEBCAhIQEJCQkGLUsmZAaGxuRmZmJqqoqs1RPMXd/zeLj4/HCCy8gJibGbH22hePZkiXnvzWcDBnrIuLi4hAREYHIyMgutXhzTk4OMjIycOrUKb2frbNkfwCwY8cOXL58GSdPnoRUKjVLnx3heP6bEPP/LKtKhleuXEFkZCR8fX3h4OCAnj17YtiwYS1WKzh58iScnJxw/Phxi41t+/bt2rvAPv74Y732ebY+WfNLJpPB19cX8+fPx+3bt9vdR9+aZt2xFhpraePGjYiJicFHH30k9FD09uqrr+KLL76Ap6enVfZ39OhRPH78GDk5OXBxcTFLn/rieAo7/zpMvdAKM31ndPXqVVIoFLRkyRK6ffs21dbW0o0bN+jDDz+kV199VadtVlYWqdVqOnbsmMnHNcStW7cIAP3hD38waD9/f39ycnIiop+vtf/000/0xz/+kRQKBbm7u1NZWVmr+xhT08zStdDMFX8xMdN3HMxKcDyF1e2+M9y+fTucnZ2RlJSEvn37QiaToX///tiwYUOLBzBDQkJQWVmJyZMnCzRa49nY2MDd3R1vvvkmFi9ejJKSkjZXpDe2pll3qYWmj9ra2larl3e1YzDGhGU1ybC8vByVlZV48OCBznZ7e3uLXg61pICAAABAcXFxq+8bW9Osu9RC08e+fftQUlLS5Y/BGBOW1STDkSNHorq6Gr/61a/wt7/9rc123377LXx8fCCRSLB7924AP6+NqVQqYWNjg5deegkeHh6QSqVQKpUYPnw4goODtasqODs748MPP9T2t2vXLshkMri7uyM6OhpeXl6QyWQICgrqcIFbwLS6X7du3QLwcwHSthhS08wc+3U2oo7rrsXExMDe3l7nO4lFixZBqVRCIpGgrKwMABAbG4tly5YhPz8fEokEAQEBesfTlGMAwOnTp6FWq7Fx48ZOnS/GmIWYeqEVZvrOqKamhkaMGKF9IDMwMJC2bNlC5eXlLdoWFhYSAEpOTtZu++1vf0sA6MKFC1RdXU1lZWU0ceJEAkAnTpyg0tJSqq6uppiYGAJAly9f1u4bFRVFSqWS8vLyqK6ujnJzc2nkyJGkUqno7t272natfWe4fPlycnBwoMOHD1NFRQWtXr2abGxs6LvvvtO2efo7QyKiiooK+uyzz0ihUFBISEir8+Hv70+3b98mIqK///3vZGNjQ3379qVHjx4RUfvfGRqzn7EMjf/69evJ3t6eDhw4QA8fPqSrV6/S8OHDqWfPnlRcXKxtN2fOHPLw8NDZd9u2bQSASktLtdvCwsLI399fp52+8TTlGFlZWaRSqSghIUHvc2/G3zF1LxxPYXW77wzlcjn+/ve/4z//8z8xcOBA5OXlYeXKlXj++edx9uxZvfsJDAyEQqFAjx49MGvWLACAj48PevbsCYVCgblz5wJAi1IkdnZ22k8rgYGBSElJQVVVVbv1uwyp+1VZWam909PFxQXvvPMOVq9ejT/96U8dnpM+Nc3MuV9nMabumrGMiachQkJCoNFosG7dOrP0xxgTltUkQ+Dnsi0xMTH45z//ifPnz2PatGkoKSlBREQEKioqDO6vuU5XQ0ODzjEA6FR1bs2IESOgUCjard9lSN0vJycn7crvK1asABHByclJ72dqEhMTMWDAAOzZswfffvutXvuYsl9nMLXumin0iSdjTLysKhk+7Re/+AX+9Kc/YeHChSgtLcVf/vIXi4/BwcEBpaWlbb7/dN2vp58jvHPnDmpqatrcb926dfD09MTq1atRWFio11iaF+mVSCSYP38+amtrO3W/zmDuumuG6iiejDHxsppkGBYWpvMJrlnzw+PtJZfOUF9f32EtMGPrfqlUKmzevBlVVVV477339B5TezXNOmM/czN33TVD6BNPxph4WU0yfPz4MfLy8lpsv3HjBgBg6NChFh1PTk4OiAijRo1qs40pdb/eeust/OIXv0BWVhbS0tL03q+tmmadtZ85GVJ3zc7OrsNL2YZoLZ7mPgZjrOuymmQIAKGhoUhLS8PDhw9RWVmJo0ePYtWqVZg6dWqnJ8OmpiZUVFSgoaEBV69eRWxsLHx8fDBv3rw299Gn7ldbJBIJdu3aBYlEgpiYGL2/E22rplln7WdOhtRdCwgIwIMHD5CZmYn6+nqUlpbizp07Lfp0dXVFUVERCgoKUFVVpU1u+sTTlGOcOnWKH61grDsx9X5UmOnRiq+++opmzpxJ/v7+5ODgQPb29jRgwACKj4+nuro6bbvk5GTy9PQkAKRQKGjKlCmUlJSkrdPVt29f+utf/0qbN28mJycnAkAeHh70xRdf0KFDh8jDw4MAkIuLCx08eJCIfr4VXyqVkre3N9nZ2ZFaraZp06ZRfn6+9ri///3vtfsqlUqaPn06EbVf9+tvf/sb9e/fX/u4yHPPPUfR0dE65z1v3jwCQM7OzvTRRx8ZXdPMlFpopjA0/vrUXSMiKi8vp/Hjx5NMJiNfX196//33acWKFQSAAgICtI9IXLx4kfr06UNyuZzGjh1LxcXFesXT1GOcPHmSVCoVJSYmGjxnfCt+98LxFJa5Hq2QEBGZkkwlEglSU1MxY8YMU7oRVHR0NNLT01FeXi70ULoca4y/tcczIiICAJCeni7wSJg5cDyFZab5T7eqy6RCamxsFHoIzIw4nowxQ3AyZIwxJnqiT4arV6/G/v37UVlZCV9fXxw+fFjoITETcDwZY8awE3oAQtu0aRM2bdok9DCYmXA8GWPGEP0nQ8YYY4yTIWOMMdHjZMgYY0z0OBkyxhgTPbM8dD9q1CheAFmkDh8+zPE30Pnz5wGg3XVvWdfB8RTW+fPnMWrUKJMfujc5GTY//c8YM1xxcTEuXbqEN954Q+ihMNZlNVfmMYHpyZAxZry0tDTMnDkT/N+QMUHxcmyMMcYYJ0PGGGOix8mQMcaY6HEyZIwxJnqcDBljjIkeJ0PGGGOix8mQMcaY6HEyZIwxJnqcDBljjIkeJ0PGGGOix8mQMcaY6HEyZIwxJnqcDBljjIkeJ0PGGGOix8mQMcaY6HEyZIwxJnqcDBljjIkeJ0PGGGOix8mQMcaY6HEyZIwxJnqcDBljjIkeJ0PGGGOix8mQMcaY6HEyZIwxJnqcDBljjIkeJ0PGGGOix8mQMcaY6HEyZIwxJnqcDBljjIkeJ0PGGGOix8mQMcaY6HEyZIwxJnp2Qg+AMbGor6/Ho0ePdLZVV1cDACoqKnS2SyQSODs7W2xsjIkdJ0PGLOTBgwfw9vZGY2Nji/dcXV11/j1+/HhkZ2dbamiMiR5fJmXMQjw8PPDLX/4SNjbt/7eTSCSYNWuWhUbFGAM4GTJmUW+++WaHbWxtbTF9+nQLjIYx1oyTIWMWFBYWBju7tr+dsLW1xcSJE9GjRw8LjooxxsmQMQtSq9V444032kyIRIS5c+daeFSMMU6GjFnY3LlzW72JBgDs7e3xm9/8xsIjYoxxMmTMwn7zm99AoVC02C6VShEaGgqlUinAqBgTN06GjFmYTCbD9OnTIZVKdbbX19djzpw5Ao2KMXHjZMiYAGbPno36+nqdbWq1Gq+//rpAI2JM3DgZMiaA1157TedBe6lUilmzZsHe3l7AUTEmXpwMGROAnZ0dZs2apb1UWl9fj9mzZws8KsbEi5MhYwKZNWuW9lKph4cHxo4dK/CIGBMvToaMCSQoKAje3t4AgLfeeqvDZdoYY52nSy/Ufe7cORQWFgo9DMaMNnLkSNy/fx89evRAWlqa0MNhzGhBQUHo1auX0MMwmoSISOhBGCsiIgKHDx8WehiMMSZ6qampmDFjhtDDMFZ6l78uEx4eDiLil5leqampACD4OLraC/j5l4Ex+6anpws+/q7+MmX++WWe+e/qunwyZKyrCw8PF3oIjIkeJ0PGGGOix8mQMcaY6HEyZIwxJnqcDBljjIkeJ0PGGGOiJ/pk+O6770KlUkEikeDy5ctCD8coCQkJCAwMhFqthoODAwICAvDhhx/i0aNHgo3p5MmTcHJywvHjxwUbA2OM6Uv0yfDTTz/FJ598IvQwTJKdnY3FixejoKAAZWVl2LRpE5KSkhARESHYmLrLs0eMMXEQfTLsDhwdHREVFQVXV1eoVCrMmDEDoaGhOH36tGDL1YWEhKCyshKTJ08W5PhPq62tRVBQkNDDYIxZsS69Nqm5SCQSoYdgkqysrBbbevbsCQCoqamx9HCszr59+1BSUiL0MBhjVkx0nwyJCNu2bcOAAQPg4OAAJycnrFixokW7xsZGrF+/Hj4+PpDL5Rg6dKh2qbKUlBQolUooFAocPXoUb7zxBtRqNXr16oWDBw/q9HP27Fm8/PLLUCgUUKvVGDJkCDQaTYfHMNX9+/chl8vh6+trlv4M8e2338LHxwcSiQS7d+8GoP+c7dq1CzKZDO7u7oiOjoaXlxdkMhmCgoJw4cIFbbuYmBjY29vD09NTu23RokVQKpWQSCQoKysDAMTGxmLZsmXIz8+HRCJBQEAAAOD06dNQq9XYuHGjJaaEMWbtqAsLDw+n8PBwg/ZZs2YNSSQS+v3vf08VFRVUU1NDe/bsIQB06dIlbbvly5eTg4MDHT58mCoqKmj16tVkY2ND3333nbYfAPT1119TZWUllZSUUHBwMCmVSnry5AkRET169IjUajVt2bKFamtrqbi4mKZPn06lpaV6HcNY1dXVpFKpKCYmxuB9U1NTyRw/FoWFhQSAkpOTtdv0mTMioqioKFIqlZSXl0d1dXWUm5tLI0eOJJVKRXfv3tW2mzNnDnl4eOgcd9u2bQRAO8dERGFhYeTv76/TLisri1QqFSUkJJh8rkREACg1NdUsfTHD8fwLqxvMf5qoPhnW1tZi586deO211/DBBx/A2dkZcrkcrq6uOu3q6uqQkpKC0NBQhIWFwdnZGWvXroVUKsX+/ft12gYFBUGtVsPNzQ2RkZGorq7G3bt3AQAFBQXQaDQYNGgQZDIZPDw8kJGRgZ49exp0DENt2rQJXl5eSExMNKmfztLenDWzs7PD888/DwcHBwQGBiIlJQVVVVUmz02zkJAQaDQarFu3ziz9Mca6NlElw++//x41NTV49dVX221348YN1NTUYPDgwdptcrkcnp6euH79epv72dvbA4C2ermfnx/c3d0xd+5cxMfHo6CgwORjdOTIkSNIS0vDl19+CZVKZXQ/lvLsnLVlxIgRUCgUJs0NY4y1RVTJ8N69ewAANze3dttVV1cDANauXQuJRKJ93blzx6AbUuRyObKzszF27Fhs3LgRfn5+iIyMRG1trdmO8bRDhw5h8+bNyMnJQd++fY3qw5o5ODigtLRU6GEwxrohUSVDmUwGAHj8+HG77ZqT5c6dO1vU7Tp37pxBxxw0aBCOHz+OoqIirFy5Eqmpqdi+fbtZjwEAycnJ+Pzzz5GdnY3nnnvO4P2tXX19PR4+fNilK2kzxqyXqJLh4MGDYWNjg7Nnz7bbrnfv3pDJZCavSFNUVIS8vDwAPyfYjz76CMOHD0deXp7ZjkFEWLlyJa5du4bMzEw4Ojqa1J+1ysnJARFh1KhR2m12dnYdXl5ljDF9iCoZurm5ISwsDIcPH8a+ffug0Whw9epV7N27V6edTCbDO++8g4MHDyIlJQUajQaNjY24d+8efvzxR72PV1RUhOjoaFy/fh1PnjzBpUuXcOfOHYwaNcpsx8jLy8PWrVvxySefQCqV6lxylUgk2L59u959WZOmpiZUVFSgoaEBV69eRWxsLHx8fDBv3jxtm4CAADx48ACZmZmor69HaWkp7ty506IvV1dXFBUVoaCgAFVVVaivr8epU6f40QrG2L8JdR+rORjzaEVVVRW9++671KNHD3J0dKSxY8fS+vXrCQD16tWLrly5QkREjx8/ppUrV5KPjw/Z2dmRm5sbhYWFUW5uLu3Zs4cUCgUBoH79+lF+fj7t3buX1Go1AaA+ffrQzZs3qaCggIKCgsjFxYVsbW3pueeeozVr1lBDQ0OHx9DXtWvXCECbr23bthk0P+Z4tCI5OZk8PT0JACkUCpoyZYrec0b086MVUqmUvL29yc7OjtRqNU2bNo3y8/N1jlNeXk7jx48nmUxGvr6+9P7779OKFSsIAAUEBGgfw7h48SL16dOH5HI5jR07loqLi+nkyZOkUqkoMTHRpHNthq5/a3mXxvMvrG4w/2kSoq67iGTz2pvp6ekCj6T7SEtLw8yZMwVdWzQ6Ohrp6ekoLy8XbAyGkkgkSE1NxYwZM4Qeiijx/AurG8x/uqguk7Kuo7GxUeghMMZEhJOhFbp+/XqL7/5ae0VGRgo9VGYGZ86cQVxcHDIyMuDn56eN75tvvtmi7YQJE6BSqWBra4tBgwbh4sWLAoxYf/qUFzt27Bi2bNki2B9A3Xn+mzU1NWHnzp2tLlgv9PxbDYGv05rEmO8MWfvMtRybseLi4sje3p4AUN++fSk9PV2wsRgCRn5nsn79epo8eTJpNBrtNn9/f+rRowcBoKysrBb7nDp1iqZOnWrSeC1l3LhxtGfPHiovLyeNRkOpqakklUpp4sSJOu2SkpJo3LhxVFFRYdRxeP7bdvPmTRozZgwBoGHDhrXaRqj5tyLiWo6NWb9Nmzbh8ePHICLcvn0b4eHhQg+p02zevBmHDh1CWlpai9WCdu3aBRsbG0RFRaGyslKgEZpO3/JiS5YswbBhwzBp0iQ0NDRYZGximP8rV65g1apVWLhwIV544YU22wkx/9aGkyFjAvj++++xbt06/O53v9MuBvG0oKAgxMbG4v79+1i+fLkAIzSPrKws2Nra6mxrq7xYfHw8Ll++jKSkpE4fl1jmf9iwYcjIyMCcOXPg4ODQbltLzr814mTImAB27doFIsKUKVPabJOYmIj+/fvj008/xZkzZ9rtj4iwY8cO7eLmLi4umDZtms5aroaUHhOivJiLiwvGjRuHpKSkTr+bWczz3xZLzr814mTImABOnDiBAQMGQKFQtNlGLpfjs88+g42NDRYsWKBdz7Y18fHxiIuLw5o1a1BSUoJvvvkGhYWFCA4Oxk8//QQAeO+997B06VLU1tZCpVIhNTUV+fn58PPzw4IFC3RW81m1ahW2bt2KnTt34scff8TkyZMxe/Zs/OMf/zDpvGtqapCdnY0FCxZoF2l/2osvvoj79+/jypUrJh2nI2Kd/45Yav6tESdDxiysuroat2/fhr+/f4dtR48ejaVLl6KgoACrVq1qtU1tbS127NiB6dOnY+7cuXBycsKQIUPw8ccfo6ysrMUKS0D7ZbSELC/Wr18/AMC1a9dMOk57xDz/HbHE/FsrO6EHYKrz589rH75npmuu7MFz2nlKSkpARO1+KnlaYmIisrKysGfPHsycObPF+7m5uXj06BFGjBihs33kyJGwt7fHhQsX2u3/2TJanV1e7KuvvmqzvFjznDR/muoMYp1/fVhi/q0VfzJkzMLq6uoAoMMbGprJZDLs378fEokE8+fPR21trc77Dx8+BIBWF2l3dnZGVVWVQeMTsryYXC4H8O856gxinH99WWL+rVWX/2Q4atQoXo7NjJqXY+M5NYxEItG7bfMvHEMech49ejQ++OADbN++HRs2bICPj4/2PWdnZwBo9ZeuMWWvni4vFhsba9C+rUlOTsaXX36J7OzsDquqPHnyBMC/56gziG3+DWGJ+bdW/MmQMQtzd3eHRCIx+Pm1DRs2YODAgbh06ZLO9sGDB8PR0bHFzRUXLlzAkydP8NJLLxl0HCHLizXPiYeHh0nHbo9Y5t8Ylph/a8XJkDELUygU8PPz034/q6/my3XPPrcnk8mwbNkyHDlyBJ9//jk0Gg2uXbuGhQsXwsvLC1FRUQYfp6PyYpGRkfDw8Gh3OTJjyos1z8mQIUMMGrMhxDL/xrDE/Fstoda+MQdejs38hF6OrauCgctRxcTEkFQqpZqaGu22I0eOkL+/PwGgnj170uLFi1vdd8WKFS2WA2tqaqJt27ZRv379SCqVkouLC4WGhtKNGze0bQwpo9VRebHQ0FACQOvXr2/zHI0pLxYSEkLe3t7U1NSk91wS8fy35dy5czRmzBjy8vLSzrunpycFBQXR2bNnW7S31PxbobQu/VuPk6H5cTI0jqG/DG7dukV2dnZ04MCBThxV52lsbKTg4GDat2+f2fosKysjmUxG27dvN3hfnn/TWXL+rRCvTcqYEAICApCQkICEhASdCg5dQWNjIzIzM1FVVWXWyinx8fF44YUXEBMTY7Y+28Lz35Il598acTJ8yrMlXJpf9vb2cHd3xyuvvIJt27ahoqJC6KGybiAuLg4RERGIjIzsUotB5+TkICMjA6dOndL7Wb2O7NixA5cvX8bJkychlUrN0mdHeP7/TYj5tzacDJ8SFhaGH374Af7+/nBycgIRoampCSUlJUhLS4Ovry9WrlyJQYMGdfqySEwcNm7ciJiYGHz00UdCD0Vvr776Kr744gt4enqapb+jR4/i8ePHyMnJgYuLi1n61BfPv7Dzb004GXZAIpHA2dkZr7zyCvbv34+0tDT89NNPCAkJ6VJ/TXYltbW1rRYh7WrH0NeECROwefNmoYchmKlTpyIuLq7FXZqWwvMv7PxbC06GBgoPD8e8efNQUlKCjz/+WOjhdEv79u1DSUlJlz8GY6zr4GRohHnz5gEATp06pd3WXskVQ0q3nD17Fi+//DIUCgXUajWGDBkCjUbT4TGERHqUr4mJiYG9vb3OpZ1FixZBqVRCIpGgrKwMABAbG4tly5YhPz8fEokEAQEB2LVrF2QyGdzd3REdHQ0vLy/IZDIEBQXprPtoyjEA4PTp01Cr1di4cWOnzhdjzAoJfT+rKTrr0Qp/f39ycnJq832NRkMAqHfv3tpty5cvJwcHBzp8+DBVVFTQ6tWrycbGhr777jsiIlqzZg0BoK+//poqKyuppKSEgoODSalU0pMnT4iI6NGjR6RWq2nLli1UW1tLxcXFNH36dCotLdXrGOZgzKMV69evJ3t7ezpw4AA9fPiQrl69SsOHD6eePXtScXGxtt2cOXPIw8NDZ99t27YRAO05EhGFhYWRJUhIoQAAA+lJREFUv7+/TruoqChSKpWUl5dHdXV1lJubSyNHjiSVSkV37941yzGysrJIpVJRQkKCQedP1C1uLe/SeP6F1Q3mnx+tMIZKpYJEItGuRWhIyZX2SrcUFBRAo9Fg0KBBkMlk8PDwQEZGBnr27CloWZf2GFO+xlh2dnbaT5+BgYFISUlBVVWV2c4/JCQEGo0G69atM0t/jLGug5OhEaqrq0FEUKvVAIwvufJs6RY/Pz+4u7tj7ty5iI+PR0FBgbatkGVd2mNq+RpTjBgxAgqFQtDzZ4x1D5wMjXDz5k0AwMCBAwGYr+SKXC5HdnY2xo4di40bN8LPzw+RkZGora0VtKxLe8xdvsZQDg4OKC0t7dRjMMa6P06GRjh9+jQA4I033gCgW3KFiHRe586dM6jvQYMG4fjx4ygqKsLKlSuRmpqK7du3m/UY5mTu8jWGqK+v7/RjMMbEgZOhgYqLi7Fz50706tUL8+fPB2C+kitFRUXIy8sD8HOC/eijjzB8+HDk5eUJWtalPYaUr7Gzs9NeEjaHnJwcEBFGjRrVacdgjIkDJ8M2EBEePXqEpqYmEBFKS0uRmpqKMWPGwNbWFpmZmdrvDPUpuaKPoqIiREdH4/r163jy5AkuXbqEO3fuYNSoUWY7hrkZUr4mICAADx48QGZmJurr61FaWoo7d+606NPV1RVFRUUoKChAVVWVNrk1NTWhoqICDQ0NuHr1KmJjY+Hj46N91MXUY5w6dYofrWBMrIS5i9U8zP1oxbFjx2jo0KGkUCjI3t6ebGxsCABJJBJydnaml19+mRISEqi8vLzFvu2VXNG3dEtBQQEFBQWRi4sL2dra0nPPPUdr1qyhhoaGDo9hLsY8WqFP+RoiovLycho/fjzJZDLy9fWl999/n1asWEEAKCAgQPuIxMWLF6lPnz4kl8tp7NixVFxcTFFRUSSVSsnb25vs7OxIrVbTtGnTKD8/32zHOHnyJKlUKkpMTDR43tD1by3v0nj+hdUN5j9NQkQkWCY2UUREBAAgPT1d4JF0H2lpaZg5cyas7cciOjoa6enpKC8vF3oorZJIJEhNTcWMGTOEHooo8fwLqxvMfzpfJmVdRmNjo9BDYIx1U5wMGWOMiR4nQ2b1Vq9ejf3796OyshK+vr44fPiw0ENijHUzdkIPgLGObNq0CZs2bRJ6GIyxbow/GTLGGBM9ToaMMcZEj5MhY4wx0eNkyBhjTPQ4GTLGGBO9Lr8CDd9mzxhjwuvqK9B06WR47tw5FBYWCj0MxhgTvaCgoK5cTq1rJ0PGGGPMDHhtUsYYY4yTIWOMMdHjZMgYY0z07ABwMUDGGGNidv7/Afi50LuWlJrIAAAAAElFTkSuQmCC\n"
+          },
+          "metadata": {},
+          "execution_count": 24
+        }
+      ]
+    },
+    {
+      "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",
+        "R<sup>m</sup>\n",
+        "* Weights for input units: \n",
+        "w<sub>x</sub>\n",
+        "∈\n",
+        " R<sup>m</sup>\n",
+        "* Weights for hidden units: \n",
+        "w<sub>h</sub>\n",
+        "∈\n",
+        "R<sup>m x m</sup>\n",
+        "* Bias for hidden units: \n",
+        "b<sub>h</sub>\n",
+        "∈\n",
+        "R\n",
+        "<sup>m</sup>\n",
+        "*Weight for the dense layer: \n",
+        "w<sub>y</sub>\n",
+        "∈\n",
+        "R\n",
+        "<sup>m</sup>\n",
+        "*Bias for the dense layer: \n",
+        "b<sub>y</sub>\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": "99e50027-1295-4f2e-8bbc-90790397728d"
+      },
+      "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": 25,
+      "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": 26,
+      "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",
+        "<img src=\"https://machinelearningmastery.com/wp-content/uploads/2021/09/rnnCode1.png\">"
+      ]
+    },
+    {
+      "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",
+        "h<sub>0</sub>\n",
+        " is initialized to the zero vector. The output \n",
+        "o<sub>3</sub>\n",
+        " is computed from \n",
+        "h<sub>3</sub>\n",
+        " and \n",
+        "w<sub>3</sub>\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": "3c518453-dec4-48b8-8785-02435d4700d0"
+      },
+      "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": 27,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "h1 =  [[ 0.51664114 -0.68749332]] h2 =  [[ 1.86312974 -1.14933595]] h3 =  [[ 3.30697657 -0.75672767]]\n",
+            "Prediction from network  [[0.8985116]]\n",
+            "Prediction from our computation  [[0.89851162]]\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": "406fae03-b596-4f8a-f072-fe20dc50e710"
+      },
+      "execution_count": 28,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Prediction from network  [[[0.139544  ]\n",
+            "  [0.09143725]\n",
+            "  [0.18287447]]]\n",
+            "Prediction from our computation  [0.13954399 0.09143724 0.18287446]\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "# stateful\n",
+        "demo_model = create_RNN_functional(hidden_units=2, dense_units=1, \n",
+        "                        activation=['linear', 'linear'],return_sequences=True,\n",
+        "                        stateful=True,batch_shape=(2,3,1))\n",
+        "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)\n",
+        "\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/",
+          "height": 1000
+        },
+        "id": "SLYRVhFGHa4r",
+        "outputId": "6b98a38d-cd2c-4834-ae11-b90807d8cadf"
+      },
+      "execution_count": 35,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Model: \"model_5\"\n",
+            "_________________________________________________________________\n",
+            " Layer (type)                Output Shape              Param #   \n",
+            "=================================================================\n",
+            " input_9 (InputLayer)        [(2, 3, 1)]               0         \n",
+            "                                                                 \n",
+            " simple_rnn_6 (SimpleRNN)    (2, 3, 2)                 8         \n",
+            "                                                                 \n",
+            " dense_5 (Dense)             (2, 3, 1)                 3         \n",
+            "                                                                 \n",
+            "=================================================================\n",
+            "Total params: 11\n",
+            "Trainable params: 11\n",
+            "Non-trainable params: 0\n",
+            "_________________________________________________________________\n",
+            "None\n"
+          ]
+        },
+        {
+          "output_type": "error",
+          "ename": "InvalidArgumentError",
+          "evalue": "ignored",
+          "traceback": [
+            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
+            "\u001b[0;31mInvalidArgumentError\u001b[0m                      Traceback (most recent call last)",
+            "\u001b[0;32m<ipython-input-35-3072faee2c9b>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;31m# Reshape the input to the required sample_size x time_steps x features\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     14\u001b[0m \u001b[0mx_input\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mreshape\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m3\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m1\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---> 15\u001b[0;31m \u001b[0my_pred_model\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mdemo_model\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mpredict\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx_input\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     16\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     17\u001b[0m \u001b[0mh\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mzeros\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m2\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/keras/utils/traceback_utils.py\u001b[0m in \u001b[0;36merror_handler\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m     65\u001b[0m     \u001b[0;32mexcept\u001b[0m \u001b[0mException\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m:\u001b[0m  \u001b[0;31m# pylint: disable=broad-except\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     66\u001b[0m       \u001b[0mfiltered_tb\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0m_process_traceback_frames\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0me\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m__traceback__\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 67\u001b[0;31m       \u001b[0;32mraise\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mwith_traceback\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfiltered_tb\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mfrom\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     68\u001b[0m     \u001b[0;32mfinally\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     69\u001b[0m       \u001b[0;32mdel\u001b[0m \u001b[0mfiltered_tb\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/tensorflow/python/eager/execute.py\u001b[0m in \u001b[0;36mquick_execute\u001b[0;34m(op_name, num_outputs, inputs, attrs, ctx, name)\u001b[0m\n\u001b[1;32m     53\u001b[0m     \u001b[0mctx\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mensure_initialized\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     54\u001b[0m     tensors = pywrap_tfe.TFE_Py_Execute(ctx._handle, device_name, op_name,\n\u001b[0;32m---> 55\u001b[0;31m                                         inputs, attrs, num_outputs)\n\u001b[0m\u001b[1;32m     56\u001b[0m   \u001b[0;32mexcept\u001b[0m \u001b[0mcore\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_NotOkStatusException\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     57\u001b[0m     \u001b[0;32mif\u001b[0m \u001b[0mname\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;31mInvalidArgumentError\u001b[0m: Graph execution error:\n\nDetected at node 'model_5/simple_rnn_6/TensorArrayUnstack/TensorListFromTensor' defined at (most recent call last):\n    File \"/usr/lib/python3.7/runpy.py\", line 193, in _run_module_as_main\n      \"__main__\", mod_spec)\n    File \"/usr/lib/python3.7/runpy.py\", line 85, in _run_code\n      exec(code, run_globals)\n    File \"/usr/local/lib/python3.7/dist-packages/ipykernel_launcher.py\", line 16, in <module>\n      app.launch_new_instance()\n    File \"/usr/local/lib/python3.7/dist-packages/traitlets/config/application.py\", line 846, in launch_instance\n      app.start()\n    File \"/usr/local/lib/python3.7/dist-packages/ipykernel/kernelapp.py\", line 499, in start\n      self.io_loop.start()\n    File \"/usr/local/lib/python3.7/dist-packages/tornado/platform/asyncio.py\", line 132, in start\n      self.asyncio_loop.run_forever()\n    File \"/usr/lib/python3.7/asyncio/base_events.py\", line 541, in run_forever\n      self._run_once()\n    File \"/usr/lib/python3.7/asyncio/base_events.py\", line 1786, in _run_once\n      handle._run()\n    File \"/usr/lib/python3.7/asyncio/events.py\", line 88, in _run\n      self._context.run(self._callback, *self._args)\n    File \"/usr/local/lib/python3.7/dist-packages/tornado/platform/asyncio.py\", line 122, in _handle_events\n      handler_func(fileobj, events)\n    File \"/usr/local/lib/python3.7/dist-packages/tornado/stack_context.py\", line 300, in null_wrapper\n      return fn(*args, **kwargs)\n    File \"/usr/local/lib/python3.7/dist-packages/zmq/eventloop/zmqstream.py\", line 577, in _handle_events\n      self._handle_recv()\n    File \"/usr/local/lib/python3.7/dist-packages/zmq/eventloop/zmqstream.py\", line 606, in _handle_recv\n      self._run_callback(callback, msg)\n    File \"/usr/local/lib/python3.7/dist-packages/zmq/eventloop/zmqstream.py\", line 556, in _run_callback\n      callback(*args, **kwargs)\n    File \"/usr/local/lib/python3.7/dist-packages/tornado/stack_context.py\", line 300, in null_wrapper\n      return fn(*args, **kwargs)\n    File \"/usr/local/lib/python3.7/dist-packages/ipykernel/kernelbase.py\", line 283, in dispatcher\n      return self.dispatch_shell(stream, msg)\n    File \"/usr/local/lib/python3.7/dist-packages/ipykernel/kernelbase.py\", line 233, in dispatch_shell\n      handler(stream, idents, msg)\n    File \"/usr/local/lib/python3.7/dist-packages/ipykernel/kernelbase.py\", line 399, in execute_request\n      user_expressions, allow_stdin)\n    File \"/usr/local/lib/python3.7/dist-packages/ipykernel/ipkernel.py\", line 208, in do_execute\n      res = shell.run_cell(code, store_history=store_history, silent=silent)\n    File \"/usr/local/lib/python3.7/dist-packages/ipykernel/zmqshell.py\", line 537, in run_cell\n      return super(ZMQInteractiveShell, self).run_cell(*args, **kwargs)\n    File \"/usr/local/lib/python3.7/dist-packages/IPython/core/interactiveshell.py\", line 2718, in run_cell\n      interactivity=interactivity, compiler=compiler, result=result)\n    File \"/usr/local/lib/python3.7/dist-packages/IPython/core/interactiveshell.py\", line 2822, in run_ast_nodes\n      if self.run_code(code, result):\n    File \"/usr/local/lib/python3.7/dist-packages/IPython/core/interactiveshell.py\", line 2882, in run_code\n      exec(code_obj, self.user_global_ns, self.user_ns)\n    File \"<ipython-input-35-3072faee2c9b>\", line 15, in <module>\n      y_pred_model = demo_model.predict(x_input)\n    File \"/usr/local/lib/python3.7/dist-packages/keras/utils/traceback_utils.py\", line 64, in error_handler\n      return fn(*args, **kwargs)\n    File \"/usr/local/lib/python3.7/dist-packages/keras/engine/training.py\", line 1982, in predict\n      tmp_batch_outputs = self.predict_function(iterator)\n    File \"/usr/local/lib/python3.7/dist-packages/keras/engine/training.py\", line 1801, in predict_function\n      return step_function(self, iterator)\n    File \"/usr/local/lib/python3.7/dist-packages/keras/engine/training.py\", line 1790, in step_function\n      outputs = model.distribute_strategy.run(run_step, args=(data,))\n    File \"/usr/local/lib/python3.7/dist-packages/keras/engine/training.py\", line 1783, in run_step\n      outputs = model.predict_step(data)\n    File \"/usr/local/lib/python3.7/dist-packages/keras/engine/training.py\", line 1751, in predict_step\n      return self(x, training=False)\n    File \"/usr/local/lib/python3.7/dist-packages/keras/utils/traceback_utils.py\", line 64, in error_handler\n      return fn(*args, **kwargs)\n    File \"/usr/local/lib/python3.7/dist-packages/keras/engine/base_layer.py\", line 1096, in __call__\n      outputs = call_fn(inputs, *args, **kwargs)\n    File \"/usr/local/lib/python3.7/dist-packages/keras/utils/traceback_utils.py\", line 92, in error_handler\n      return fn(*args, **kwargs)\n    File \"/usr/local/lib/python3.7/dist-packages/keras/engine/functional.py\", line 452, in call\n      inputs, training=training, mask=mask)\n    File \"/usr/local/lib/python3.7/dist-packages/keras/engine/functional.py\", line 589, in _run_internal_graph\n      outputs = node.layer(*args, **kwargs)\n    File \"/usr/local/lib/python3.7/dist-packages/keras/layers/recurrent.py\", line 679, in __call__\n      return super(RNN, self).__call__(inputs, **kwargs)\n    File \"/usr/local/lib/python3.7/dist-packages/keras/utils/traceback_utils.py\", line 64, in error_handler\n      return fn(*args, **kwargs)\n    File \"/usr/local/lib/python3.7/dist-packages/keras/engine/base_layer.py\", line 1096, in __call__\n      outputs = call_fn(inputs, *args, **kwargs)\n    File \"/usr/local/lib/python3.7/dist-packages/keras/utils/traceback_utils.py\", line 92, in error_handler\n      return fn(*args, **kwargs)\n    File \"/usr/local/lib/python3.7/dist-packages/keras/layers/recurrent.py\", line 1614, in call\n      inputs, mask=mask, training=training, initial_state=initial_state)\n    File \"/usr/local/lib/python3.7/dist-packages/keras/layers/recurrent.py\", line 826, in call\n      zero_output_for_mask=self.zero_output_for_mask)\n    File \"/usr/local/lib/python3.7/dist-packages/keras/backend.py\", line 4589, in rnn\n      for ta, input_ in zip(input_ta, flatted_inputs))\n    File \"/usr/local/lib/python3.7/dist-packages/keras/backend.py\", line 4589, in <genexpr>\n      for ta, input_ in zip(input_ta, flatted_inputs))\nNode: 'model_5/simple_rnn_6/TensorArrayUnstack/TensorListFromTensor'\nSpecified a list with shape [2,1] from a tensor with shape [1,1]\n\t [[{{node model_5/simple_rnn_6/TensorArrayUnstack/TensorListFromTensor}}]] [Op:__inference_predict_function_2332]"
+          ]
+        }
+      ]
+    },
+    {
+      "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": null,
+      "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"
+      },
+      "source": [
+        "data.shape"
+      ],
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "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": [
+        "<img src=\"https://machinelearningmastery.com/wp-content/uploads/2021/09/rnnCode2.png\">"
+      ]
+    },
+    {
+      "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": null,
+      "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"
+      },
+      "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": null,
+      "outputs": []
+    },
+    {
+      "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"
+      },
+      "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": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "Xz2JRTGKMzo2"
+      },
+      "source": [
+        "## Step 4: Create RNN Model And Train"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "id": "SyAE6XLnMGDO"
+      },
+      "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": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "tluiPIaxM9FH"
+      },
+      "source": [
+        "## Step 5: Compute And Print The Root Mean Square Error"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "id": "LnWdCmqJMK-k"
+      },
+      "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": null,
+      "outputs": []
+    },
+    {
+      "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"
+      },
+      "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": null,
+      "outputs": []
+    }
+  ]
+}
\ No newline at end of file
-- 
2.11.4.GIT