Exp5-Prediction-Batch 1-48 hour.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Using TensorFlow backend.\n"
     ]
    }
   ],
   "source": [
    "from pandas import DataFrame\n",
    "from pandas import Series\n",
    "from pandas import concat\n",
    "from pandas import read_csv\n",
    "from pandas import datetime\n",
    "from sklearn.metrics import mean_squared_error\n",
    "from sklearn.preprocessing import MinMaxScaler\n",
    "from keras.models import Sequential\n",
    "from keras.layers import Dense\n",
    "from keras.layers import LSTM\n",
    "from math import sqrt\n",
    "from matplotlib import pyplot\n",
    "import numpy as np\n",
    "import pandas as pd"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Hardcode all variables\n",
    "batch_size_exp = 1\n",
    "epoch_exp = 7\n",
    "neurons_exp = 10\n",
    "predict_values_exp = 48\n",
    "lag_exp=24"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# frame a sequence as a supervised learning problem\n",
    "def timeseries_to_supervised(data, lag=1):\n",
    "    df = DataFrame(data)\n",
    "    columns = [df.shift(i) for i in range(1, lag+1)]\n",
    "    columns.append(df)\n",
    "    df = concat(columns, axis=1)\n",
    "    df.fillna(0, inplace=True)\n",
    "    return df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# create a differenced series\n",
    "def difference(dataset, interval=1):\n",
    "    diff = list()\n",
    "    for i in range(interval, len(dataset)):\n",
    "        value = dataset[i] - dataset[i - interval]\n",
    "        diff.append(value)\n",
    "    return Series(diff)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "# invert differenced value\n",
    "def inverse_difference(history, yhat, interval=1):\n",
    "    return yhat + history[-interval]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "# scale train and test data to [-1, 1]\n",
    "def scale(train, test):\n",
    "    # fit scaler\n",
    "    scaler = MinMaxScaler(feature_range=(-1, 1))\n",
    "    scaler = scaler.fit(train)\n",
    "    # transform train\n",
    "    train = train.reshape(train.shape[0], train.shape[1])\n",
    "    train_scaled = scaler.transform(train)\n",
    "    # transform test\n",
    "    test = test.reshape(test.shape[0], test.shape[1])\n",
    "    test_scaled = scaler.transform(test)\n",
    "    return scaler, train_scaled, test_scaled"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "# inverse scaling for a forecasted value\n",
    "def invert_scale(scaler, X, value):\n",
    "    new_row = [x for x in X] + [value]\n",
    "    array = np.array(new_row)\n",
    "    array = array.reshape(1, len(array))\n",
    "    inverted = scaler.inverse_transform(array)\n",
    "    return inverted[0, -1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "# fit an LSTM network to training data\n",
    "def fit_lstm(train, batch_size, nb_epoch, neurons):\n",
    "    X, y = train[:, 0:-1], train[:, -1]\n",
    "    X = X.reshape(X.shape[0], 1, X.shape[1])\n",
    "    model = Sequential()\n",
    "    model.add(LSTM(neurons, batch_input_shape=(batch_size, X.shape[1], X.shape[2]), stateful=True))\n",
    "    model.add(Dense(1))\n",
    "    model.compile(loss='mean_squared_error', optimizer='adam')\n",
    "    for i in range(nb_epoch):\n",
    "        model.fit(X, y, epochs=1, batch_size=batch_size, verbose=1, shuffle=False)\n",
    "        model.reset_states()\n",
    "    return model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "# make a one-step forecast\n",
    "def forecast_lstm(model, batch_size, X):\n",
    "    X = X.reshape(1, 1, len(X))\n",
    "    #print(X)\n",
    "    yhat = model.predict(X, batch_size=1)\n",
    "    return yhat[0,0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "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>Air temperature | ('C)</th>\n",
       "      <th>Pressure | (atm)</th>\n",
       "      <th>Wind speed | (m/s)</th>\n",
       "      <th>Wind direction | (deg)</th>\n",
       "      <th>Power generated by system | (kW)</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>DateTime</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>2007-01-01 00:00:00</th>\n",
       "      <td>10.926</td>\n",
       "      <td>0.979103</td>\n",
       "      <td>9.014</td>\n",
       "      <td>229</td>\n",
       "      <td>33688.1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2007-01-01 01:00:00</th>\n",
       "      <td>9.919</td>\n",
       "      <td>0.979566</td>\n",
       "      <td>9.428</td>\n",
       "      <td>232</td>\n",
       "      <td>37261.9</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2007-01-01 02:00:00</th>\n",
       "      <td>8.567</td>\n",
       "      <td>0.979937</td>\n",
       "      <td>8.700</td>\n",
       "      <td>236</td>\n",
       "      <td>30502.9</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2007-01-01 03:00:00</th>\n",
       "      <td>7.877</td>\n",
       "      <td>0.980053</td>\n",
       "      <td>8.481</td>\n",
       "      <td>247</td>\n",
       "      <td>28419.2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2007-01-01 04:00:00</th>\n",
       "      <td>7.259</td>\n",
       "      <td>0.979867</td>\n",
       "      <td>8.383</td>\n",
       "      <td>256</td>\n",
       "      <td>27370.3</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                     Air temperature | ('C)  Pressure | (atm)  \\\n",
       "DateTime                                                        \n",
       "2007-01-01 00:00:00                  10.926          0.979103   \n",
       "2007-01-01 01:00:00                   9.919          0.979566   \n",
       "2007-01-01 02:00:00                   8.567          0.979937   \n",
       "2007-01-01 03:00:00                   7.877          0.980053   \n",
       "2007-01-01 04:00:00                   7.259          0.979867   \n",
       "\n",
       "                     Wind speed | (m/s)  Wind direction | (deg)  \\\n",
       "DateTime                                                          \n",
       "2007-01-01 00:00:00               9.014                     229   \n",
       "2007-01-01 01:00:00               9.428                     232   \n",
       "2007-01-01 02:00:00               8.700                     236   \n",
       "2007-01-01 03:00:00               8.481                     247   \n",
       "2007-01-01 04:00:00               8.383                     256   \n",
       "\n",
       "                     Power generated by system | (kW)  \n",
       "DateTime                                               \n",
       "2007-01-01 00:00:00                           33688.1  \n",
       "2007-01-01 01:00:00                           37261.9  \n",
       "2007-01-01 02:00:00                           30502.9  \n",
       "2007-01-01 03:00:00                           28419.2  \n",
       "2007-01-01 04:00:00                           27370.3  "
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "''' Loading data '''\n",
    "import pandas as pd\n",
    "series = pd.read_excel('AL_WIND_07_12.xlsx',index_col=\"DateTime\")\n",
    "series.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "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>Power generated by system | (kW)</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>DateTime</th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>2007-01-01 00:00:00</th>\n",
       "      <td>33688.1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2007-01-01 01:00:00</th>\n",
       "      <td>37261.9</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2007-01-01 02:00:00</th>\n",
       "      <td>30502.9</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2007-01-01 03:00:00</th>\n",
       "      <td>28419.2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2007-01-01 04:00:00</th>\n",
       "      <td>27370.3</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                     Power generated by system | (kW)\n",
       "DateTime                                             \n",
       "2007-01-01 00:00:00                           33688.1\n",
       "2007-01-01 01:00:00                           37261.9\n",
       "2007-01-01 02:00:00                           30502.9\n",
       "2007-01-01 03:00:00                           28419.2\n",
       "2007-01-01 04:00:00                           27370.3"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'''Drop all the features as we will not be having any in production'''\n",
    "del series['Air temperature | (\\'C)']\n",
    "del series['Pressure | (atm)']\n",
    "del series['Wind speed | (m/s)']\n",
    "del series['Wind direction | (deg)']\n",
    "series.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "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>Power generated by system | (kW)</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>DateTime</th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>2012-12-31 09:00:00</th>\n",
       "      <td>6110.57</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2012-12-31 10:00:00</th>\n",
       "      <td>6251.34</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2012-12-31 11:00:00</th>\n",
       "      <td>6899.17</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2012-12-31 12:00:00</th>\n",
       "      <td>4514.49</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2012-12-31 13:00:00</th>\n",
       "      <td>1561.25</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                     Power generated by system | (kW)\n",
       "DateTime                                             \n",
       "2012-12-31 09:00:00                           6110.57\n",
       "2012-12-31 10:00:00                           6251.34\n",
       "2012-12-31 11:00:00                           6899.17\n",
       "2012-12-31 12:00:00                           4514.49\n",
       "2012-12-31 13:00:00                           1561.25"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "for i in range(0,10):\n",
    "  series = series[:-1]\n",
    "series.tail()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "# transform data to be stationary\n",
    "raw_values = series.values\n",
    "diff_values = difference(raw_values, 1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "# transform data to be supervised learning\n",
    "supervised = timeseries_to_supervised(diff_values, lag_exp)\n",
    "supervised_values = supervised.values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "# split data into train and test-sets\n",
    "train, test = supervised_values[0:-predict_values_exp], supervised_values[-predict_values_exp:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\ProgramData\\Anaconda3\\envs\\tensorflow\\lib\\site-packages\\sklearn\\utils\\validation.py:475: DataConversionWarning: Data with input dtype object was converted to float64 by MinMaxScaler.\n",
      "  warnings.warn(msg, DataConversionWarning)\n"
     ]
    }
   ],
   "source": [
    "# transform the scale of the data\n",
    "scaler, train_scaled, test_scaled = scale(train, test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1/1\n",
      "52501/52501 [==============================] - 228s 4ms/step - loss: 0.0140\n",
      "Epoch 1/1\n",
      "52501/52501 [==============================] - 142s 3ms/step - loss: 0.0137\n",
      "Epoch 1/1\n",
      "52501/52501 [==============================] - 134s 3ms/step - loss: 0.0135\n",
      "Epoch 1/1\n",
      "52501/52501 [==============================] - 137s 3ms/step - loss: 0.0134\n",
      "Epoch 1/1\n",
      "52501/52501 [==============================] - 134s 3ms/step - loss: 0.0133\n",
      "Epoch 1/1\n",
      "52501/52501 [==============================] - 143s 3ms/step - loss: 0.0133\n",
      "Epoch 1/1\n",
      "52501/52501 [==============================] - 137s 3ms/step - loss: 0.0134\n"
     ]
    }
   ],
   "source": [
    "# fit the model\n",
    "lstm_model = fit_lstm(train_scaled, batch_size_exp, epoch_exp, neurons_exp)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hour=1, Predicted=9421.722809, Expected=5331.850000\n",
      "Hour=2, Predicted=4806.210966, Expected=1479.590000\n",
      "Hour=3, Predicted=2070.099177, Expected=0.000000\n",
      "Hour=4, Predicted=-46.776504, Expected=1699.950000\n",
      "Hour=5, Predicted=1074.315105, Expected=4932.380000\n",
      "Hour=6, Predicted=4625.198128, Expected=10551.200000\n",
      "Hour=7, Predicted=10996.867013, Expected=11277.200000\n",
      "Hour=8, Predicted=12359.007254, Expected=20258.100000\n",
      "Hour=9, Predicted=22264.559030, Expected=27235.300000\n",
      "Hour=10, Predicted=29424.535662, Expected=29297.100000\n",
      "Hour=11, Predicted=31127.749137, Expected=50140.200000\n",
      "Hour=12, Predicted=51736.317224, Expected=28258.100000\n",
      "Hour=13, Predicted=30321.284079, Expected=0.000000\n",
      "Hour=14, Predicted=2346.145982, Expected=3868.210000\n",
      "Hour=15, Predicted=5300.908689, Expected=0.000000\n",
      "Hour=16, Predicted=286.586642, Expected=0.000000\n",
      "Hour=17, Predicted=77.146869, Expected=0.000000\n",
      "Hour=18, Predicted=-92.542711, Expected=4135.800000\n",
      "Hour=19, Predicted=5018.378275, Expected=13607.200000\n",
      "Hour=20, Predicted=15083.940305, Expected=24571.700000\n",
      "Hour=21, Predicted=26585.303545, Expected=32106.600000\n",
      "Hour=22, Predicted=34018.240718, Expected=36286.000000\n",
      "Hour=23, Predicted=37667.709315, Expected=32040.800000\n",
      "Hour=24, Predicted=31471.159456, Expected=27413.500000\n",
      "Hour=25, Predicted=26883.988265, Expected=20005.800000\n",
      "Hour=26, Predicted=19956.509731, Expected=19870.600000\n",
      "Hour=27, Predicted=20139.902157, Expected=23296.700000\n",
      "Hour=28, Predicted=23546.834185, Expected=36275.400000\n",
      "Hour=29, Predicted=36455.517978, Expected=41119.700000\n",
      "Hour=30, Predicted=41424.521953, Expected=45831.200000\n",
      "Hour=31, Predicted=46475.274773, Expected=38451.600000\n",
      "Hour=32, Predicted=39531.522848, Expected=38107.700000\n",
      "Hour=33, Predicted=39608.185755, Expected=36325.100000\n",
      "Hour=34, Predicted=38052.330832, Expected=37641.300000\n",
      "Hour=35, Predicted=39487.520767, Expected=36876.500000\n",
      "Hour=36, Predicted=38894.270974, Expected=35723.600000\n",
      "Hour=37, Predicted=38020.314445, Expected=28221.500000\n",
      "Hour=38, Predicted=30646.330148, Expected=22650.000000\n",
      "Hour=39, Predicted=24733.723845, Expected=14845.100000\n",
      "Hour=40, Predicted=16159.484650, Expected=11449.700000\n",
      "Hour=41, Predicted=12062.510171, Expected=11637.200000\n",
      "Hour=42, Predicted=11829.242036, Expected=6465.350000\n",
      "Hour=43, Predicted=6656.844624, Expected=5802.110000\n",
      "Hour=44, Predicted=6173.842896, Expected=6110.570000\n",
      "Hour=45, Predicted=6698.738391, Expected=6251.340000\n",
      "Hour=46, Predicted=6902.957804, Expected=6899.170000\n",
      "Hour=47, Predicted=7507.726201, Expected=4514.490000\n",
      "Hour=48, Predicted=5026.153767, Expected=1561.250000\n"
     ]
    }
   ],
   "source": [
    "# walk-forward validation on the test data\n",
    "predictions = list()\n",
    "expectations = list()\n",
    "test_pred = list()\n",
    "for i in range(len(test_scaled)):\n",
    "    # make one-step forecast\n",
    "    X, y = test_scaled[i, 0:-1], test_scaled[i, -1]\n",
    "    yhat = forecast_lstm(lstm_model, 1, X)#batch_size_exp to 1\n",
    "    '''# Start Debug prints\n",
    "    print(\"X: %\", X)\n",
    "    print(\"yhat: %\", yhat)\n",
    "    # End Debug prints'''\n",
    "    # Replacing value in test scaled with the predicted value.\n",
    "    test_pred = [yhat] + test_pred \n",
    "    if len(test_pred) > lag_exp+1:\n",
    "        test_pred = test_pred[:-1]\n",
    "    if i+1<len(test_scaled):\n",
    "        if i+1 > lag_exp+1:\n",
    "            test_scaled[i+1] = test_pred\n",
    "        else:\n",
    "            test_scaled[i+1] = np.concatenate((test_pred, test_scaled[i+1, i+1:]),axis=0)\n",
    "\n",
    "    # invert scaling\n",
    "    yhat = invert_scale(scaler, X, yhat)\n",
    "    # invert differencing\n",
    "    yhat = inverse_difference(raw_values, yhat, len(test_scaled)+1-i)\n",
    "    # store forecast\n",
    "    expected = raw_values[len(train) + i + 1]\n",
    "    if expected != 0:\n",
    "        predictions.append(yhat)\n",
    "        expectations.append(expected)\n",
    "    print('Hour=%d, Predicted=%f, Expected=%f' % (i+1, yhat, expected))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Mean Absolute Percent Error:  40.69007886200861\n"
     ]
    }
   ],
   "source": [
    "expectations = np.array(expectations)\n",
    "predictions = np.array(predictions)\n",
    "print(\"Mean Absolute Percent Error: \", (np.mean(np.abs((expectations - predictions) / expectations))*100))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# line plot of observed vs predicted\n",
    "pyplot.plot(raw_values[-predict_values_exp:], label=\"True\")\n",
    "pyplot.plot(predictions, label=\"Predicted\")\n",
    "pyplot.legend(loc='upper right')\n",
    "pyplot.xlabel(\"Number of hours\")\n",
    "pyplot.ylabel(\"Power generated by system (kW)\")\n",
    "pyplot.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.5.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}