From c3135a161e198fb9f3e73e19206af55ff80bb057 Mon Sep 17 00:00:00 2001
From: Jan <jan.mandel@gmail.com>
Date: Wed, 6 Jul 2022 23:17:15 -0600
Subject: [PATCH] return_sequences=false, still same

---
 rnn_tutorial_jm_output.ipynb | 345 +++++++++++++++++++++++++++++++++++++------
 1 file changed, 297 insertions(+), 48 deletions(-)

diff --git a/rnn_tutorial_jm_output.ipynb b/rnn_tutorial_jm_output.ipynb
index 6568d77..df59b7f 100644
--- a/rnn_tutorial_jm_output.ipynb
+++ b/rnn_tutorial_jm_output.ipynb
@@ -101,7 +101,7 @@
         "import matplotlib.pyplot as plt\n",
         "import tensorflow as tf"
       ],
-      "execution_count": null,
+      "execution_count": 1,
       "outputs": []
     },
     {
@@ -130,7 +130,7 @@
       "metadata": {
         "id": "Qf35beQp1Ewv"
       },
-      "execution_count": null,
+      "execution_count": 2,
       "outputs": []
     },
     {
@@ -147,16 +147,17 @@
         "    model.compile(loss='mean_squared_error', optimizer='adam')\n",
         "    return model"
       ],
-      "execution_count": null,
+      "execution_count": 3,
       "outputs": []
     },
     {
       "cell_type": "code",
       "source": [
-        "def create_RNN_functional(hidden_units, dense_units, input_shape, activation):\n",
+        "def create_RNN_functional(hidden_units, dense_units, input_shape, activation,\n",
+        "                          return_sequences=False):\n",
         "    inputs = tf.keras.Input(shape=input_shape)\n",
         "    x = tf.keras.layers.SimpleRNN(hidden_units, input_shape=input_shape,\n",
-        "                        return_sequences=False,\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",
@@ -166,7 +167,7 @@
       "metadata": {
         "id": "zBQxW0h8pvGb"
       },
-      "execution_count": 46,
+      "execution_count": 4,
       "outputs": []
     },
     {
@@ -186,10 +187,22 @@
         "                        activation=['linear', 'linear'])"
       ],
       "metadata": {
-        "id": "dYLai9HypVRo"
+        "id": "dYLai9HypVRo",
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "outputId": "4b69730d-ccc0-4081-888d-d56254bbc1ad"
       },
-      "execution_count": null,
-      "outputs": []
+      "execution_count": 5,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "using functional api\n"
+          ]
+        }
+      ]
     },
     {
       "cell_type": "markdown",
@@ -208,10 +221,30 @@
         "help(demo_model.get_weights)"
       ],
       "metadata": {
-        "id": "TgDQmxwQpUtw"
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "TgDQmxwQpUtw",
+        "outputId": "cd723670-774f-4ca9-a218-5db711e2badd"
       },
-      "execution_count": null,
-      "outputs": []
+      "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",
@@ -225,7 +258,12 @@
     {
       "cell_type": "code",
       "metadata": {
-        "id": "Rdz2nblaTMV5"
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 598
+        },
+        "id": "Rdz2nblaTMV5",
+        "outputId": "1456977c-479e-4520-b6cf-b3fc55547fc3"
       },
       "source": [
         "print(demo_model.summary())\n",
@@ -233,8 +271,42 @@
         "plot_model(demo_model, to_file='model_plot.png', \n",
         "           show_shapes=True, show_layer_names=True)"
       ],
-      "execution_count": null,
-      "outputs": []
+      "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",
@@ -285,7 +357,11 @@
     {
       "cell_type": "code",
       "metadata": {
-        "id": "f-C4rYMDL1_l"
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "f-C4rYMDL1_l",
+        "outputId": "153b0c55-c283-4af5-d320-2595fb7df7e3"
       },
       "source": [
         "w = demo_model.get_weights()\n",
@@ -300,8 +376,20 @@
         "wy = w[3]\n",
         "by = w[4]"
       ],
-      "execution_count": null,
-      "outputs": []
+      "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",
@@ -311,7 +399,7 @@
       "metadata": {
         "id": "kNzpNlwP4MSs"
       },
-      "execution_count": null,
+      "execution_count": 9,
       "outputs": []
     },
     {
@@ -396,7 +484,11 @@
     {
       "cell_type": "code",
       "metadata": {
-        "id": "kMOhAImzL7Ch"
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "kMOhAImzL7Ch",
+        "outputId": "514a245f-85bd-48aa-b4e5-02c355ca6d01"
       },
       "source": [
         "w = demo_model.get_weights()\n",
@@ -423,8 +515,18 @@
         "print(\"Prediction from network \", y_pred_model)\n",
         "print(\"Prediction from our computation \", o3)"
       ],
-      "execution_count": null,
-      "outputs": []
+      "execution_count": 10,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "h1 =  [[ 1.14749658 -0.20947528]] h2 =  [[ 3.29422907 -1.02074469]] h3 =  [[ 6.16276048 -2.74833013]]\n",
+            "Prediction from network  [[3.5862036]]\n",
+            "Prediction from our computation  [[3.58620384]]\n"
+          ]
+        }
+      ]
     },
     {
       "cell_type": "code",
@@ -442,7 +544,7 @@
         "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",
+        "  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",
@@ -453,17 +555,16 @@
           "base_uri": "https://localhost:8080/"
         },
         "id": "Q2kuhi2KBNY4",
-        "outputId": "f809ca56-e91d-4248-b787-18628ea16312"
+        "outputId": "67455e3d-b4b3-4265-d48c-ee8757738e2d"
       },
-      "execution_count": 48,
+      "execution_count": 11,
       "outputs": [
         {
           "output_type": "stream",
           "name": "stdout",
           "text": [
-            "WARNING:tensorflow:5 out of the last 19 calls to <function Model.make_predict_function.<locals>.predict_function at 0x7f05f6a333b0> triggered tf.function retracing. Tracing is expensive and the excessive number of tracings could be due to (1) creating @tf.function repeatedly in a loop, (2) passing tensors with different shapes, (3) passing Python objects instead of tensors. For (1), please define your @tf.function outside of the loop. For (2), @tf.function has experimental_relax_shapes=True option that relaxes argument shapes that can avoid unnecessary retracing. For (3), please refer to https://www.tensorflow.org/guide/function#controlling_retracing and https://www.tensorflow.org/api_docs/python/tf/function for  more details.\n",
-            "Prediction from network  [[5.916549]]\n",
-            "Prediction from our computation  5.916548629906362\n"
+            "Prediction from network  [[-1.0523229]]\n",
+            "Prediction from our computation  -1.0523225195909676\n"
           ]
         }
       ]
@@ -516,7 +617,7 @@
         "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,
+      "execution_count": 12,
       "outputs": []
     },
     {
@@ -531,13 +632,28 @@
     {
       "cell_type": "code",
       "metadata": {
-        "id": "h5AmHug8JViT"
+        "id": "h5AmHug8JViT",
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "outputId": "cd94b6d4-d289-4e71-d8a4-6a97f3cf6eda"
       },
       "source": [
         "data.shape"
       ],
-      "execution_count": null,
-      "outputs": []
+      "execution_count": 13,
+      "outputs": [
+        {
+          "output_type": "execute_result",
+          "data": {
+            "text/plain": [
+              "(2820,)"
+            ]
+          },
+          "metadata": {},
+          "execution_count": 13
+        }
+      ]
     },
     {
       "cell_type": "markdown",
@@ -593,7 +709,7 @@
         "    X = np.reshape(X, (rows_x, time_steps, 1))    \n",
         "    return X, Y"
       ],
-      "execution_count": null,
+      "execution_count": 14,
       "outputs": []
     },
     {
@@ -608,7 +724,11 @@
     {
       "cell_type": "code",
       "metadata": {
-        "id": "V38oXJ32QiFK"
+        "id": "V38oXJ32QiFK",
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "outputId": "a91d1a52-bee8-4dab-cb23-b6308ea31af5"
       },
       "source": [
         "dat = np.linspace(0.,70.,8).reshape(-1,1)\n",
@@ -620,8 +740,29 @@
         "print('X=',X)\n",
         "print('Y=',Y)\n"
       ],
-      "execution_count": null,
-      "outputs": []
+      "execution_count": 15,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "dat shape= (8, 1)\n",
+            "X shape= (3, 2, 1)\n",
+            "Y shape= (3, 1)\n",
+            "X= [[[ 0.]\n",
+            "  [10.]]\n",
+            "\n",
+            " [[20.]\n",
+            "  [30.]]\n",
+            "\n",
+            " [[40.]\n",
+            "  [50.]]]\n",
+            "Y= [[20.]\n",
+            " [40.]\n",
+            " [60.]]\n"
+          ]
+        }
+      ]
     },
     {
       "cell_type": "markdown",
@@ -635,7 +776,11 @@
     {
       "cell_type": "code",
       "metadata": {
-        "id": "YBnBPDxiQsjL"
+        "id": "YBnBPDxiQsjL",
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "outputId": "d0568f82-fae9-432b-9d28-6cad4e473477"
       },
       "source": [
         "time_steps = 24\n",
@@ -646,8 +791,19 @@
         "print(\"testX shape=\",testX.shape)\n",
         "print(\"testY shape=\",testY.shape)"
       ],
-      "execution_count": null,
-      "outputs": []
+      "execution_count": 16,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "trainX shape= (93, 24, 1)\n",
+            "trainY shape= (93,)\n",
+            "testX shape= (23, 24, 1)\n",
+            "testY shape= (23,)\n"
+          ]
+        }
+      ]
     },
     {
       "cell_type": "markdown",
@@ -661,15 +817,77 @@
     {
       "cell_type": "code",
       "metadata": {
-        "id": "SyAE6XLnMGDO"
+        "id": "SyAE6XLnMGDO",
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "outputId": "027157b4-b956-446b-92aa-fc3d6952a7cb"
       },
       "source": [
         "model = create_RNN(hidden_units=3, dense_units=1, input_shape=(time_steps,1), \n",
         "                   activation=['tanh', 'tanh'])\n",
         "model.fit(trainX, trainY, epochs=20, batch_size=1, verbose=2)"
       ],
-      "execution_count": null,
-      "outputs": []
+      "execution_count": 17,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "using functional api\n",
+            "Epoch 1/20\n",
+            "93/93 - 2s - loss: 0.0811 - 2s/epoch - 22ms/step\n",
+            "Epoch 2/20\n",
+            "93/93 - 1s - loss: 0.0298 - 625ms/epoch - 7ms/step\n",
+            "Epoch 3/20\n",
+            "93/93 - 1s - loss: 0.0186 - 528ms/epoch - 6ms/step\n",
+            "Epoch 4/20\n",
+            "93/93 - 1s - loss: 0.0125 - 593ms/epoch - 6ms/step\n",
+            "Epoch 5/20\n",
+            "93/93 - 1s - loss: 0.0097 - 544ms/epoch - 6ms/step\n",
+            "Epoch 6/20\n",
+            "93/93 - 1s - loss: 0.0094 - 518ms/epoch - 6ms/step\n",
+            "Epoch 7/20\n",
+            "93/93 - 1s - loss: 0.0081 - 615ms/epoch - 7ms/step\n",
+            "Epoch 8/20\n",
+            "93/93 - 1s - loss: 0.0081 - 526ms/epoch - 6ms/step\n",
+            "Epoch 9/20\n",
+            "93/93 - 1s - loss: 0.0082 - 577ms/epoch - 6ms/step\n",
+            "Epoch 10/20\n",
+            "93/93 - 1s - loss: 0.0069 - 586ms/epoch - 6ms/step\n",
+            "Epoch 11/20\n",
+            "93/93 - 1s - loss: 0.0067 - 572ms/epoch - 6ms/step\n",
+            "Epoch 12/20\n",
+            "93/93 - 0s - loss: 0.0070 - 465ms/epoch - 5ms/step\n",
+            "Epoch 13/20\n",
+            "93/93 - 0s - loss: 0.0060 - 485ms/epoch - 5ms/step\n",
+            "Epoch 14/20\n",
+            "93/93 - 1s - loss: 0.0061 - 520ms/epoch - 6ms/step\n",
+            "Epoch 15/20\n",
+            "93/93 - 1s - loss: 0.0058 - 535ms/epoch - 6ms/step\n",
+            "Epoch 16/20\n",
+            "93/93 - 1s - loss: 0.0056 - 605ms/epoch - 7ms/step\n",
+            "Epoch 17/20\n",
+            "93/93 - 1s - loss: 0.0058 - 541ms/epoch - 6ms/step\n",
+            "Epoch 18/20\n",
+            "93/93 - 1s - loss: 0.0054 - 785ms/epoch - 8ms/step\n",
+            "Epoch 19/20\n",
+            "93/93 - 1s - loss: 0.0054 - 648ms/epoch - 7ms/step\n",
+            "Epoch 20/20\n",
+            "93/93 - 1s - loss: 0.0050 - 672ms/epoch - 7ms/step\n"
+          ]
+        },
+        {
+          "output_type": "execute_result",
+          "data": {
+            "text/plain": [
+              "<keras.callbacks.History at 0x7fe86dce13d0>"
+            ]
+          },
+          "metadata": {},
+          "execution_count": 17
+        }
+      ]
     },
     {
       "cell_type": "markdown",
@@ -683,7 +901,11 @@
     {
       "cell_type": "code",
       "metadata": {
-        "id": "LnWdCmqJMK-k"
+        "id": "LnWdCmqJMK-k",
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "outputId": "633a377d-c51e-4903-a11e-d0f86375471f"
       },
       "source": [
         "def print_error(trainY, testY, train_predict, test_predict):    \n",
@@ -700,8 +922,17 @@
         "# Mean square error\n",
         "print_error(trainY, testY, train_predict, test_predict)"
       ],
-      "execution_count": null,
-      "outputs": []
+      "execution_count": 18,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Train RMSE: 0.069 RMSE\n",
+            "Test RMSE: 0.134 RMSE\n"
+          ]
+        }
+      ]
     },
     {
       "cell_type": "markdown",
@@ -724,7 +955,12 @@
     {
       "cell_type": "code",
       "metadata": {
-        "id": "fQPjWHWvMMGL"
+        "id": "fQPjWHWvMMGL",
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 444
+        },
+        "outputId": "7edb1c9b-0c7a-44cc-bc5d-74f29f946930"
       },
       "source": [
         "# Plot the result\n",
@@ -742,8 +978,21 @@
         "    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": []
+      "execution_count": 19,
+      "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
-- 
2.11.4.GIT