S+P_Week_3_Exercise_Question.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "accelerator": "GPU",
    "colab": {
      "name": "S+P Week 3 Exercise Question.ipynb",
      "provenance": [],
      "collapsed_sections": [],
      "toc_visible": true
    },
    "kernelspec": {
      "display_name": "Python 3",
      "name": "python3"
    }
  },
  "cells": [
    {
      "cell_type": "code",
      "metadata": {
        "id": "zX4Kg8DUTKWO",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "#@title Licensed under the Apache License, Version 2.0 (the \"License\");\n",
        "# you may not use this file except in compliance with the License.\n",
        "# You may obtain a copy of the License at\n",
        "#\n",
        "# https://www.apache.org/licenses/LICENSE-2.0\n",
        "#\n",
        "# Unless required by applicable law or agreed to in writing, software\n",
        "# distributed under the License is distributed on an \"AS IS\" BASIS,\n",
        "# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n",
        "# See the License for the specific language governing permissions and\n",
        "# limitations under the License."
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "D1J15Vh_1Jih",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 51
        },
        "outputId": "3b274c31-4cfe-4890-ae80-f5876bde5bc4"
      },
      "source": [
        "!pip install tf-nightly-2.0-preview\n"
      ],
      "execution_count": 2,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "\u001b[31mERROR: Could not find a version that satisfies the requirement tf-nightly-2.0-preview (from versions: none)\u001b[0m\n",
            "\u001b[31mERROR: No matching distribution found for tf-nightly-2.0-preview\u001b[0m\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "BOjujz601HcS",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "53beecba-18a6-4f84-b6d5-14609ca633a8"
      },
      "source": [
        "import tensorflow as tf\n",
        "import numpy as np\n",
        "import matplotlib.pyplot as plt\n",
        "print(tf.__version__)"
      ],
      "execution_count": 3,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "2.2.0-rc3\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "Zswl7jRtGzkk",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 279
        },
        "outputId": "f2209331-328c-49ff-e96e-638993dc23b7"
      },
      "source": [
        "def plot_series(time, series, format=\"-\", start=0, end=None):\n",
        "    plt.plot(time[start:end], series[start:end], format)\n",
        "    plt.xlabel(\"Time\")\n",
        "    plt.ylabel(\"Value\")\n",
        "    plt.grid(False)\n",
        "\n",
        "def trend(time, slope=0):\n",
        "    return slope * time\n",
        "\n",
        "def seasonal_pattern(season_time):\n",
        "    \"\"\"Just an arbitrary pattern, you can change it if you wish\"\"\"\n",
        "    return np.where(season_time < 0.1,\n",
        "                    np.cos(season_time * 6 * np.pi),\n",
        "                    2 / np.exp(9 * season_time))\n",
        "\n",
        "def seasonality(time, period, amplitude=1, phase=0):\n",
        "    \"\"\"Repeats the same pattern at each period\"\"\"\n",
        "    season_time = ((time + phase) % period) / period\n",
        "    return amplitude * seasonal_pattern(season_time)\n",
        "\n",
        "def noise(time, noise_level=1, seed=None):\n",
        "    rnd = np.random.RandomState(seed)\n",
        "    return rnd.randn(len(time)) * noise_level\n",
        "\n",
        "time = np.arange(10 * 365 + 1, dtype=\"float32\")\n",
        "baseline = 10\n",
        "series = trend(time, 0.1)  \n",
        "baseline = 10\n",
        "amplitude = 40\n",
        "slope = 0.005\n",
        "noise_level = 3\n",
        "\n",
        "# Create the series\n",
        "series = baseline + trend(time, slope) + seasonality(time, period=365, amplitude=amplitude)\n",
        "# Update with noise\n",
        "series += noise(time, noise_level, seed=51)\n",
        "\n",
        "split_time = 3000\n",
        "time_train = time[:split_time]\n",
        "x_train = series[:split_time]\n",
        "time_valid = time[split_time:]\n",
        "x_valid = series[split_time:]\n",
        "\n",
        "window_size = 20\n",
        "batch_size = 32\n",
        "shuffle_buffer_size = 1000\n",
        "\n",
        "plot_series(time, series)"
      ],
      "execution_count": 10,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "4sTTIOCbyShY",
        "colab": {}
      },
      "source": [
        "def windowed_dataset(series, window_size, batch_size, shuffle_buffer):\n",
        "  dataset = tf.data.Dataset.from_tensor_slices(series)\n",
        "  dataset = dataset.window(window_size + 1, shift=1, drop_remainder=True)\n",
        "  dataset = dataset.flat_map(lambda window: window.batch(window_size + 1))\n",
        "  dataset = dataset.shuffle(shuffle_buffer).map(lambda window: (window[:-1], window[-1]))\n",
        "  dataset = dataset.batch(batch_size).prefetch(1)\n",
        "  return dataset"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "A1Hl39rklkLm",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 130
        },
        "outputId": "bb02382e-fda4-42fb-e899-4f3d47c6022f"
      },
      "source": [
        "tf.keras.backend.clear_session()\n",
        "tf.random.set_seed(51)\n",
        "np.random.seed(51)\n",
        "\n",
        "tf.keras.backend.clear_session()\n",
        "dataset = windowed_dataset(x_train, window_size, batch_size, shuffle_buffer_size)\n",
        "\n",
        "model = tf.keras.models.Sequential([\n",
        "  tf.keras.layers.Lambda(# YOUR CODE HERE),\n",
        "  # YOUR CODE HERE\n",
        "  tf.keras.layers.Lambda(# YOUR CODE HERE)\n",
        "])\n",
        "\n",
        "lr_schedule = tf.keras.callbacks.LearningRateScheduler(\n",
        "    lambda epoch: 1e-8 * 10**(epoch / 20))\n",
        "optimizer = tf.keras.optimizers.SGD(lr=1e-8, momentum=0.9)\n",
        "model.compile(loss=tf.keras.losses.Huber(),\n",
        "              optimizer=optimizer,\n",
        "              metrics=[\"mae\"])\n",
        "history = model.fit(dataset, epochs=100, callbacks=[lr_schedule])"
      ],
      "execution_count": 12,
      "outputs": [
        {
          "output_type": "error",
          "ename": "SyntaxError",
          "evalue": "ignored",
          "traceback": [
            "\u001b[0;36m  File \u001b[0;32m\"<ipython-input-12-4a9377c60022>\"\u001b[0;36m, line \u001b[0;32m12\u001b[0m\n\u001b[0;31m    ])\u001b[0m\n\u001b[0m    ^\u001b[0m\n\u001b[0;31mSyntaxError\u001b[0m\u001b[0;31m:\u001b[0m invalid syntax\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "AkBsrsXMzoWR",
        "colab": {}
      },
      "source": [
        "plt.semilogx(history.history[\"lr\"], history.history[\"loss\"])\n",
        "plt.axis([1e-8, 1e-4, 0, 30])\n",
        "\n",
        "# FROM THIS PICK A LEARNING RATE"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "4uh-97bpLZCA",
        "colab": {}
      },
      "source": [
        "tf.keras.backend.clear_session()\n",
        "tf.random.set_seed(51)\n",
        "np.random.seed(51)\n",
        "\n",
        "tf.keras.backend.clear_session()\n",
        "dataset = windowed_dataset(x_train, window_size, batch_size, shuffle_buffer_size)\n",
        "\n",
        "model = tf.keras.models.Sequential([\n",
        "  tf.keras.layers.Lambda(# YOUR CODE HERE),\n",
        "  # YOUR CODE HERE\n",
        "  tf.keras.layers.Lambda(# YOUR CODE HERE)\n",
        "])\n",
        "\n",
        "model.compile(loss=\"mse\", optimizer=tf.keras.optimizers.SGD(lr=# PUT YOUR LEARNING RATE HERE#, momentum=0.9),metrics=[\"mae\"])\n",
        "history = model.fit(dataset,epochs=500,verbose=1)\n",
        "                                                            \n",
        "# FIND A MODEL AND A LR THAT TRAINS TO AN MAE < 3                                                          "
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "icGDaND7z0ne",
        "colab": {}
      },
      "source": [
        "forecast = []\n",
        "results = []\n",
        "for time in range(len(series) - window_size):\n",
        "  forecast.append(model.predict(series[time:time + window_size][np.newaxis]))\n",
        "\n",
        "forecast = forecast[split_time-window_size:]\n",
        "results = np.array(forecast)[:, 0, 0]\n",
        "\n",
        "\n",
        "plt.figure(figsize=(10, 6))\n",
        "\n",
        "plot_series(time_valid, x_valid)\n",
        "plot_series(time_valid, results)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "KfPeqI7rz4LD",
        "outputId": "5cbee203-d2e8-455e-f603-204d9df993dc",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 164
        }
      },
      "source": [
        "tf.keras.metrics.mean_absolute_error(x_valid, results).numpy()\n",
        "\n",
        "# YOUR RESULT HERE SHOULD BE LESS THAN 4"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "error",
          "ename": "NameError",
          "evalue": "ignored",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-1-c78dd922c50f>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mtf\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mkeras\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmetrics\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmean_absolute_error\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx_valid\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mresults\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mnumpy\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
            "\u001b[0;31mNameError\u001b[0m: name 'tf' is not defined"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "JUsdZB_tzDLe",
        "colab": {}
      },
      "source": [
        "import matplotlib.image  as mpimg\n",
        "import matplotlib.pyplot as plt\n",
        "\n",
        "#-----------------------------------------------------------\n",
        "# Retrieve a list of list results on training and test data\n",
        "# sets for each training epoch\n",
        "#-----------------------------------------------------------\n",
        "mae=history.history['mae']\n",
        "loss=history.history['loss']\n",
        "\n",
        "epochs=range(len(loss)) # Get number of epochs\n",
        "\n",
        "#------------------------------------------------\n",
        "# Plot MAE and Loss\n",
        "#------------------------------------------------\n",
        "plt.plot(epochs, mae, 'r')\n",
        "plt.plot(epochs, loss, 'b')\n",
        "plt.title('MAE and Loss')\n",
        "plt.xlabel(\"Epochs\")\n",
        "plt.ylabel(\"Accuracy\")\n",
        "plt.legend([\"MAE\", \"Loss\"])\n",
        "\n",
        "plt.figure()\n",
        "\n",
        "epochs_zoom = epochs[200:]\n",
        "mae_zoom = mae[200:]\n",
        "loss_zoom = loss[200:]\n",
        "\n",
        "#------------------------------------------------\n",
        "# Plot Zoomed MAE and Loss\n",
        "#------------------------------------------------\n",
        "plt.plot(epochs_zoom, mae_zoom, 'r')\n",
        "plt.plot(epochs_zoom, loss_zoom, 'b')\n",
        "plt.title('MAE and Loss')\n",
        "plt.xlabel(\"Epochs\")\n",
        "plt.ylabel(\"Accuracy\")\n",
        "plt.legend([\"MAE\", \"Loss\"])\n",
        "\n",
        "plt.figure()"
      ],
      "execution_count": 0,
      "outputs": []
    }
  ]
}