RNN/RNN TimeSeries using Milk Production Dataset.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import tensorflow as tf\n",
    "%matplotlib inline\n",
    "import pandas as pd"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "milk = pd.read_csv('milk.csv', index_col = 'Month')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>Monthly milk production (pounds per cow)</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Month</th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>1962-01</th>\n",
       "      <td>589</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1962-02</th>\n",
       "      <td>561</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1962-03</th>\n",
       "      <td>640</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "         Monthly milk production (pounds per cow)\n",
       "Month                                            \n",
       "1962-01                                       589\n",
       "1962-02                                       561\n",
       "1962-03                                       640"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "milk.head(3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Make the index a time series\n",
    "\n",
    "milk.index = pd.to_datetime(milk.index)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.axes._subplots.AxesSubplot at 0x18811d9cbe0>"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Plot out the time series\n",
    "milk.plot()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### lest attempt to predict a year worth of data or (12 steps into future)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'pandas.core.frame.DataFrame'>\n",
      "DatetimeIndex: 168 entries, 1962-01-01 to 1975-12-01\n",
      "Data columns (total 1 columns):\n",
      "Monthly milk production (pounds per cow)    168 non-null int64\n",
      "dtypes: int64(1)\n",
      "memory usage: 2.6 KB\n"
     ]
    }
   ],
   "source": [
    "milk.info()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "#train test split\n",
    "train_set = milk.head(156)\n",
    "test_set = milk.tail(12)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\codehax41\\Anaconda3\\lib\\site-packages\\sklearn\\preprocessing\\data.py:334: DataConversionWarning: Data with input dtype int64 were all converted to float64 by MinMaxScaler.\n",
      "  return self.partial_fit(X, y)\n"
     ]
    }
   ],
   "source": [
    "#Scale the data\n",
    "from sklearn.preprocessing import MinMaxScaler\n",
    "scaler = MinMaxScaler()\n",
    "train_scaled = scaler.fit_transform(train_set)\n",
    "test_scaled = scaler.transform(test_set)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "#batch function to feed data as batch\n",
    "\n",
    "def next_batch(training_data, batch_size, steps):\n",
    "    '''\n",
    "    INPUT : Data,Batch Size, Time Step Per Batch\n",
    "    O/P : A tuple of y time series result. y[:,:-1] and y[:,1:]\n",
    "    '''\n",
    "    #use random to set a random starting point index for the batch\n",
    "    #remember that each epochs need have the same no. of step in it\n",
    "    #this means you should limit the starting point to len(data) - steps\n",
    "    rand_start = np.random.randint(0, len(training_data)-steps)\n",
    "    \n",
    "    #now that you have a starting index you'll need to index the data form\n",
    "    #the random start + steps + 1. Then reshape data to be (1, steps+1)\n",
    "    y_batch = np.array(training_data[rand_start:rand_start+steps+1]).reshape(1,steps+1)\n",
    "    \n",
    "    #Return the batch, You'll have two batches to return y[:,:-1] and y[:,1:]\n",
    "    #and need to reshape these into tensor for rnn to reshape(-1,steps,1)\n",
    "    return y_batch[:,:-1].reshape(-1, steps, 1), y_batch[:,1:].reshape(-1,steps,1)\n",
    "    \n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "#setting up rnn\n",
    "\n",
    "#constants\n",
    "num_inputs = 1\n",
    "num_time_steps = 12\n",
    "num_neurons = 100\n",
    "num_outputs = 1\n",
    "learning_rate = 0.03\n",
    "num_training_iteration = 4000\n",
    "batch_size = 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "x=tf.placeholder(tf.float32,[None, num_time_steps,num_inputs]) #None cause will be return by batch\n",
    "y=tf.placeholder(tf.float32,[None, num_time_steps,num_outputs])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "WARNING: The TensorFlow contrib module will not be included in TensorFlow 2.0.\n",
      "For more information, please see:\n",
      "  * https://github.com/tensorflow/community/blob/master/rfcs/20180907-contrib-sunset.md\n",
      "  * https://github.com/tensorflow/addons\n",
      "If you depend on functionality not listed there, please file an issue.\n",
      "\n",
      "WARNING:tensorflow:From <ipython-input-19-9fdf811c1faa>:2: BasicLSTMCell.__init__ (from tensorflow.python.ops.rnn_cell_impl) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "This class is equivalent as tf.keras.layers.LSTMCell, and will be replaced by that in Tensorflow 2.0.\n"
     ]
    }
   ],
   "source": [
    "#RNN cell layer\n",
    "cell = tf.contrib.rnn.BasicLSTMCell(num_units = num_neurons, activation = tf.nn.relu)\n",
    "cell = tf.contrib.rnn.OutputProjectionWrapper(cell, output_size = num_outputs)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:From <ipython-input-20-3216d10fab3b>:2: dynamic_rnn (from tensorflow.python.ops.rnn) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Please use `keras.layers.RNN(cell)`, which is equivalent to this API\n",
      "WARNING:tensorflow:From C:\\Users\\codehax41\\Anaconda3\\lib\\site-packages\\tensorflow\\python\\ops\\tensor_array_ops.py:162: colocate_with (from tensorflow.python.framework.ops) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Colocations handled automatically by placer.\n"
     ]
    }
   ],
   "source": [
    "#perform fully dynamic unrolling of inputs\n",
    "output, states = tf.nn.dynamic_rnn(cell,x,dtype=tf.float32)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "#MSE\n",
    "loss = tf.reduce_mean(tf.square(output-y))\n",
    "optimizer = tf.train.AdamOptimizer(learning_rate=learning_rate)\n",
    "train = optimizer.minimize(loss)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "init = tf.global_variables_initializer()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "saver = tf.train.Saver()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 \tMSE 0.09843712\n",
      "100 \tMSE 0.008603186\n",
      "200 \tMSE 0.011951129\n",
      "300 \tMSE 0.009419616\n",
      "400 \tMSE 0.013218825\n",
      "500 \tMSE 0.011464673\n",
      "600 \tMSE 0.008821918\n",
      "700 \tMSE 0.00877382\n",
      "800 \tMSE 0.004279263\n",
      "900 \tMSE 0.008207901\n",
      "1000 \tMSE 0.012195564\n",
      "1100 \tMSE 0.012998414\n",
      "1200 \tMSE 0.0107958885\n",
      "1300 \tMSE 0.0052644047\n",
      "1400 \tMSE 0.007664107\n",
      "1500 \tMSE 0.006034525\n",
      "1600 \tMSE 0.006828278\n",
      "1700 \tMSE 0.0062664333\n",
      "1800 \tMSE 0.0074845334\n",
      "1900 \tMSE 0.0057384945\n",
      "2000 \tMSE 0.00528102\n",
      "2100 \tMSE 0.0019694127\n",
      "2200 \tMSE 0.0053930427\n",
      "2300 \tMSE 0.0040364238\n",
      "2400 \tMSE 0.007173255\n",
      "2500 \tMSE 0.0036990754\n",
      "2600 \tMSE 0.0031382106\n",
      "2700 \tMSE 0.012483518\n",
      "2800 \tMSE 0.0036344007\n",
      "2900 \tMSE 0.0060086134\n",
      "3000 \tMSE 0.0022149796\n",
      "3100 \tMSE 0.0023916594\n",
      "3200 \tMSE 0.0036901908\n",
      "3300 \tMSE 0.00095281686\n",
      "3400 \tMSE 0.005521387\n",
      "3500 \tMSE 0.004324317\n",
      "3600 \tMSE 0.0066011674\n",
      "3700 \tMSE 0.005542493\n",
      "3800 \tMSE 0.0024677922\n",
      "3900 \tMSE 0.004117129\n"
     ]
    }
   ],
   "source": [
    "#sess\n",
    "#with tf.Session(config = tf.COnfigProto(gpu_options = gpu_options)) as sess:\n",
    "with tf.Session() as sess:\n",
    "    sess.run(init)\n",
    "    for iteration in range(num_training_iteration):\n",
    "        x_batch, y_batch = next_batch(train_scaled, batch_size, num_time_steps)\n",
    "        sess.run(train, feed_dict = {x:x_batch, y:y_batch})\n",
    "        \n",
    "        if iteration % 100 == 0:\n",
    "            mse = loss.eval(feed_dict={x:x_batch, y:y_batch})\n",
    "            print(iteration, '\\tMSE', mse)\n",
    "    saver.save(sess,'./milk_saved_model')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>Monthly milk production (pounds per cow)</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Month</th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>1975-01-01</th>\n",
       "      <td>834</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1975-02-01</th>\n",
       "      <td>782</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1975-03-01</th>\n",
       "      <td>892</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1975-04-01</th>\n",
       "      <td>903</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1975-05-01</th>\n",
       "      <td>966</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1975-06-01</th>\n",
       "      <td>937</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1975-07-01</th>\n",
       "      <td>896</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1975-08-01</th>\n",
       "      <td>858</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1975-09-01</th>\n",
       "      <td>817</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1975-10-01</th>\n",
       "      <td>827</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1975-11-01</th>\n",
       "      <td>797</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1975-12-01</th>\n",
       "      <td>843</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "            Monthly milk production (pounds per cow)\n",
       "Month                                               \n",
       "1975-01-01                                       834\n",
       "1975-02-01                                       782\n",
       "1975-03-01                                       892\n",
       "1975-04-01                                       903\n",
       "1975-05-01                                       966\n",
       "1975-06-01                                       937\n",
       "1975-07-01                                       896\n",
       "1975-08-01                                       858\n",
       "1975-09-01                                       817\n",
       "1975-10-01                                       827\n",
       "1975-11-01                                       797\n",
       "1975-12-01                                       843"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Predicting the future\n",
    "test_set"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:From C:\\Users\\codehax41\\Anaconda3\\lib\\site-packages\\tensorflow\\python\\training\\saver.py:1266: checkpoint_exists (from tensorflow.python.training.checkpoint_management) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Use standard file APIs to check for files with this prefix.\n",
      "INFO:tensorflow:Restoring parameters from ./milk_saved_model\n"
     ]
    }
   ],
   "source": [
    "#Generative Session\n",
    "with tf.Session() as sess:\n",
    "    saver.restore(sess, './milk_saved_model')\n",
    "    \n",
    "    train_seed = list(train_scaled[-12:])\n",
    "    for iteration in range(12): #because i want 12 month\n",
    "        x_batch = np.array(train_seed[-num_time_steps:]).reshape(1,num_time_steps,1)\n",
    "        y_pred = sess.run(output, feed_dict={x:x_batch})\n",
    "        train_seed.append(y_pred[0,-1,0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[array([0.66105769]),\n",
       " array([0.54086538]),\n",
       " array([0.80769231]),\n",
       " array([0.83894231]),\n",
       " array([1.]),\n",
       " array([0.94711538]),\n",
       " array([0.85336538]),\n",
       " array([0.75480769]),\n",
       " array([0.62980769]),\n",
       " array([0.62259615]),\n",
       " array([0.52884615]),\n",
       " array([0.625]),\n",
       " 0.65464246,\n",
       " 0.5699618,\n",
       " 0.8158032,\n",
       " 0.8387791,\n",
       " 1.0172995,\n",
       " 1.026545,\n",
       " 0.9626452,\n",
       " 0.871362,\n",
       " 0.77569115,\n",
       " 0.69135976,\n",
       " 0.6059851,\n",
       " 0.5786027]"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#show result of prediction\n",
    "train_seed"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- grab the portion of the result that are generated value and apply inverse_transform on them to turn them back into milk production value units. Also reshape the result to be 12,1 so we can easily add them to the test set df.\n",
    "\n",
    "- inverse cause as the result above the tail 12 are still not scaled"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [],
   "source": [
    "results = scaler.inverse_transform(np.array(train_seed[12:]).reshape(12,1))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- create a new column on the test set called generated and set it equal to the generated result."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\codehax41\\Anaconda3\\lib\\site-packages\\ipykernel_launcher.py:1: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame.\n",
      "Try using .loc[row_indexer,col_indexer] = value instead\n",
      "\n",
      "See the caveats in the documentation: http://pandas.pydata.org/pandas-docs/stable/indexing.html#indexing-view-versus-copy\n",
      "  \"\"\"Entry point for launching an IPython kernel.\n"
     ]
    }
   ],
   "source": [
    "test_set['Generated'] = results"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>Monthly milk production (pounds per cow)</th>\n",
       "      <th>Generated</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Month</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>1975-01-01</th>\n",
       "      <td>834</td>\n",
       "      <td>825.331238</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1975-02-01</th>\n",
       "      <td>782</td>\n",
       "      <td>790.104065</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1975-03-01</th>\n",
       "      <td>892</td>\n",
       "      <td>892.374146</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1975-04-01</th>\n",
       "      <td>903</td>\n",
       "      <td>901.932129</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1975-05-01</th>\n",
       "      <td>966</td>\n",
       "      <td>976.196655</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1975-06-01</th>\n",
       "      <td>937</td>\n",
       "      <td>980.042725</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1975-07-01</th>\n",
       "      <td>896</td>\n",
       "      <td>953.460449</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1975-08-01</th>\n",
       "      <td>858</td>\n",
       "      <td>915.486572</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1975-09-01</th>\n",
       "      <td>817</td>\n",
       "      <td>875.687561</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1975-10-01</th>\n",
       "      <td>827</td>\n",
       "      <td>840.605652</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1975-11-01</th>\n",
       "      <td>797</td>\n",
       "      <td>805.089783</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1975-12-01</th>\n",
       "      <td>843</td>\n",
       "      <td>793.698669</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "            Monthly milk production (pounds per cow)   Generated\n",
       "Month                                                           \n",
       "1975-01-01                                       834  825.331238\n",
       "1975-02-01                                       782  790.104065\n",
       "1975-03-01                                       892  892.374146\n",
       "1975-04-01                                       903  901.932129\n",
       "1975-05-01                                       966  976.196655\n",
       "1975-06-01                                       937  980.042725\n",
       "1975-07-01                                       896  953.460449\n",
       "1975-08-01                                       858  915.486572\n",
       "1975-09-01                                       817  875.687561\n",
       "1975-10-01                                       827  840.605652\n",
       "1975-11-01                                       797  805.089783\n",
       "1975-12-01                                       843  793.698669"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "test_set"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.axes._subplots.AxesSubplot at 0x188185ca908>"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "#plot \n",
    "test_set.plot()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Try another cells and Play with different hyperparameters"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}