power consumption(CNN_LSTM model).ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Users/fatmakursun/anaconda3/lib/python3.6/site-packages/h5py/__init__.py:36: FutureWarning: Conversion of the second argument of issubdtype from `float` to `np.floating` is deprecated. In future, it will be treated as `np.float64 == np.dtype(float).type`.\n",
      "  from ._conv import register_converters as _register_converters\n",
      "Using TensorFlow backend.\n"
     ]
    }
   ],
   "source": [
    "# univariate multi-step encoder-decoder cnn-lstm\n",
    "from math import sqrt\n",
    "from numpy import split\n",
    "from numpy import array\n",
    "from pandas import read_csv\n",
    "from sklearn.metrics import mean_squared_error\n",
    "from matplotlib import pyplot\n",
    "from keras.models import Sequential\n",
    "from keras.layers import Dense\n",
    "from keras.layers import Flatten\n",
    "from keras.layers import LSTM\n",
    "from keras.layers import RepeatVector\n",
    "from keras.layers import TimeDistributed\n",
    "from keras.layers.convolutional import Conv1D\n",
    "from keras.layers.convolutional import MaxPooling1D\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# load and clean-up data\n",
    "from numpy import nan\n",
    "from numpy import isnan\n",
    "from pandas import read_csv\n",
    "from pandas import to_numeric\n",
    "\n",
    "# fill missing values with a value at the same time one day ago\n",
    "def fill_missing(values):\n",
    "\tone_day = 60 * 24\n",
    "\tfor row in range(values.shape[0]):\n",
    "\t\tfor col in range(values.shape[1]):\n",
    "\t\t\tif isnan(values[row, col]):\n",
    "\t\t\t\tvalues[row, col] = values[row - one_day, col]\n",
    "\n",
    "# load all data\n",
    "dataset = read_csv('household_power_consumption.txt', sep=';', header=0, low_memory=False, infer_datetime_format=True, parse_dates={'datetime':[0,1]}, index_col=['datetime'])\n",
    "# mark all missing values\n",
    "dataset.replace('?', nan, inplace=True)\n",
    "# make dataset numeric\n",
    "dataset = dataset.astype('float32')\n",
    "# fill missing\n",
    "fill_missing(dataset.values)\n",
    "# add a column for for the remainder of sub metering\n",
    "values = dataset.values\n",
    "dataset['sub_metering_4'] = (values[:,0] * 1000 / 60) - (values[:,4] + values[:,5] + values[:,6])\n",
    "# save updated dataset\n",
    "dataset.to_csv('household_power_consumption.csv')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1442, 8)\n",
      "            Global_active_power  Global_reactive_power    Voltage  \\\n",
      "datetime                                                            \n",
      "2006-12-16             1209.176                 34.922   93552.53   \n",
      "2006-12-17             3390.460                226.006  345725.32   \n",
      "2006-12-18             2203.826                161.792  347373.64   \n",
      "2006-12-19             1666.194                150.942  348479.01   \n",
      "2006-12-20             2225.748                160.998  348923.61   \n",
      "\n",
      "            Global_intensity  Sub_metering_1  Sub_metering_2  Sub_metering_3  \\\n",
      "datetime                                                                       \n",
      "2006-12-16            5180.8             0.0           546.0          4926.0   \n",
      "2006-12-17           14398.6          2033.0          4187.0         13341.0   \n",
      "2006-12-18            9247.2          1063.0          2621.0         14018.0   \n",
      "2006-12-19            7094.0           839.0          7602.0          6197.0   \n",
      "2006-12-20            9313.0             0.0          2648.0         14063.0   \n",
      "\n",
      "            sub_metering_4  \n",
      "datetime                    \n",
      "2006-12-16    14680.933319  \n",
      "2006-12-17    36946.666732  \n",
      "2006-12-18    19028.433281  \n",
      "2006-12-19    13131.900043  \n",
      "2006-12-20    20384.800011  \n"
     ]
    }
   ],
   "source": [
    "from pandas import read_csv\n",
    "# load the new file\n",
    "dataset = read_csv('household_power_consumption.csv', header=0, infer_datetime_format=True, parse_dates=['datetime'], index_col=['datetime'])\n",
    "# resample data to daily\n",
    "daily_groups = dataset.resample('D')\n",
    "daily_data = daily_groups.sum()\n",
    "# summarize\n",
    "print(daily_data.shape)\n",
    "print(daily_data.head())\n",
    "# save\n",
    "daily_data.to_csv('household_power_consumption_days.csv')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# split a univariate dataset into train/test sets\n",
    "def split_dataset(data):\n",
    "\t# split into standard weeks\n",
    "\ttrain, test = data[1:-328], data[-328:-6]\n",
    "\t# restructure into windows of weekly data\n",
    "\ttrain = array(split(train, len(train)/7))\n",
    "\ttest = array(split(test, len(test)/7))\n",
    "\treturn train, test\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "# evaluate one or more weekly forecasts against expected values\n",
    "def evaluate_forecasts(actual, predicted):\n",
    "\tscores = list()\n",
    "\t# calculate an RMSE score for each day\n",
    "\tfor i in range(actual.shape[1]):\n",
    "\t\t# calculate mse\n",
    "\t\tmse = mean_squared_error(actual[:, i], predicted[:, i])\n",
    "\t\t# calculate rmse\n",
    "\t\trmse = sqrt(mse)\n",
    "\t\t# store\n",
    "\t\tscores.append(rmse)\n",
    "\t# calculate overall RMSE\n",
    "\ts = 0\n",
    "\tfor row in range(actual.shape[0]):\n",
    "\t\tfor col in range(actual.shape[1]):\n",
    "\t\t\ts += (actual[row, col] - predicted[row, col])**2\n",
    "\tscore = sqrt(s / (actual.shape[0] * actual.shape[1]))\n",
    "\treturn score, scores"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "# summarize scores\n",
    "def summarize_scores(name, score, scores):\n",
    "\ts_scores = ', '.join(['%.1f' % s for s in scores])\n",
    "\tprint('%s: [%.3f] %s' % (name, score, s_scores))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "# convert history into inputs and outputs\n",
    "def to_supervised(train, n_input, n_out=7):\n",
    "\t# flatten data\n",
    "\tdata = train.reshape((train.shape[0]*train.shape[1], train.shape[2]))\n",
    "\tX, y = list(), list()\n",
    "\tin_start = 0\n",
    "\t# step over the entire history one time step at a time\n",
    "\tfor _ in range(len(data)):\n",
    "\t\t# define the end of the input sequence\n",
    "\t\tin_end = in_start + n_input\n",
    "\t\tout_end = in_end + n_out\n",
    "\t\t# ensure we have enough data for this instance\n",
    "\t\tif out_end < len(data):\n",
    "\t\t\tx_input = data[in_start:in_end, 0]\n",
    "\t\t\tx_input = x_input.reshape((len(x_input), 1))\n",
    "\t\t\tX.append(x_input)\n",
    "\t\t\ty.append(data[in_end:out_end, 0])\n",
    "\t\t# move along one time step\n",
    "\t\tin_start += 1\n",
    "\treturn array(X), array(y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "# train the model\n",
    "def build_model(train, n_input):\n",
    "\t# prepare data\n",
    "\ttrain_x, train_y = to_supervised(train, n_input)\n",
    "\t# define parameters\n",
    "\tverbose, epochs, batch_size = 1, 20, 16\n",
    "\tn_timesteps, n_features, n_outputs = train_x.shape[1], train_x.shape[2], train_y.shape[1]\n",
    "\t# reshape output into [samples, timesteps, features]\n",
    "\ttrain_y = train_y.reshape((train_y.shape[0], train_y.shape[1], 1))\n",
    "\t# define model\n",
    "\tmodel = Sequential()\n",
    "\tmodel.add(Conv1D(filters=64, kernel_size=3, activation='relu', input_shape=(n_timesteps,n_features)))\n",
    "\tmodel.add(Conv1D(filters=64, kernel_size=3, activation='relu'))\n",
    "\tmodel.add(MaxPooling1D(pool_size=2))\n",
    "\tmodel.add(Flatten())\n",
    "\tmodel.add(RepeatVector(n_outputs))\n",
    "\tmodel.add(LSTM(200, activation='relu', return_sequences=True))\n",
    "\tmodel.add(TimeDistributed(Dense(100, activation='relu')))\n",
    "\tmodel.add(TimeDistributed(Dense(1)))\n",
    "\tmodel.compile(loss='mse', optimizer='adam')\n",
    "\t# fit network\n",
    "\tmodel.fit(train_x, train_y, epochs=epochs, batch_size=batch_size, verbose=verbose)\n",
    "\treturn model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "# make a forecast\n",
    "def forecast(model, history, n_input):\n",
    "\t# flatten data\n",
    "\tdata = array(history)\n",
    "\tdata = data.reshape((data.shape[0]*data.shape[1], data.shape[2]))\n",
    "\t# retrieve last observations for input data\n",
    "\tinput_x = data[-n_input:, 0]\n",
    "\t# reshape into [1, n_input, 1]\n",
    "\tinput_x = input_x.reshape((1, len(input_x), 1))\n",
    "\t# forecast the next week\n",
    "\tyhat = model.predict(input_x, verbose=0)\n",
    "\t# we only want the vector forecast\n",
    "\tyhat = yhat[0]\n",
    "\treturn yhat\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "# evaluate a single model\n",
    "def evaluate_model(train, test, n_input):\n",
    "\t# fit model\n",
    "\tmodel = build_model(train, n_input)\n",
    "\t# history is a list of weekly data\n",
    "\thistory = [x for x in train]\n",
    "\t# walk-forward validation over each week\n",
    "\tpredictions = list()\n",
    "\tfor i in range(len(test)):\n",
    "\t\t# predict the week\n",
    "\t\tyhat_sequence = forecast(model, history, n_input)\n",
    "\t\t# store the predictions\n",
    "\t\tpredictions.append(yhat_sequence)\n",
    "\t\t# get real observation and add to history for predicting the next week\n",
    "\t\thistory.append(test[i, :])\n",
    "\t# evaluate predictions days for each week\n",
    "\tpredictions = array(predictions)\n",
    "\tscore, scores = evaluate_forecasts(test[:, :, 0], predictions)\n",
    "\treturn score, scores\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "dataset = read_csv('household_power_consumption_days.csv', header=0, infer_datetime_format=True, parse_dates=['datetime'], index_col=['datetime'])\n",
    "# split into train and test\n",
    "train, test = split_dataset(dataset.values)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1/20\n",
      "1092/1092 [==============================] - 2s 1ms/step - loss: 435270.3608\n",
      "Epoch 2/20\n",
      "1092/1092 [==============================] - 1s 766us/step - loss: 300231.2393\n",
      "Epoch 3/20\n",
      "1092/1092 [==============================] - 1s 776us/step - loss: 275300.5275\n",
      "Epoch 4/20\n",
      "1092/1092 [==============================] - 1s 786us/step - loss: 260993.0590\n",
      "Epoch 5/20\n",
      "1092/1092 [==============================] - 1s 765us/step - loss: 266096.9929\n",
      "Epoch 6/20\n",
      "1092/1092 [==============================] - 1s 773us/step - loss: 258835.1892\n",
      "Epoch 7/20\n",
      "1092/1092 [==============================] - 1s 782us/step - loss: 247371.8784\n",
      "Epoch 8/20\n",
      "1092/1092 [==============================] - 1s 807us/step - loss: 238335.3384\n",
      "Epoch 9/20\n",
      "1092/1092 [==============================] - 1s 810us/step - loss: 246909.0011\n",
      "Epoch 10/20\n",
      "1092/1092 [==============================] - 1s 852us/step - loss: 232966.6564\n",
      "Epoch 11/20\n",
      "1092/1092 [==============================] - 1s 869us/step - loss: 228553.7986\n",
      "Epoch 12/20\n",
      "1092/1092 [==============================] - 1s 879us/step - loss: 224944.4207\n",
      "Epoch 13/20\n",
      "1092/1092 [==============================] - 1s 887us/step - loss: 229067.7553\n",
      "Epoch 14/20\n",
      "1092/1092 [==============================] - 1s 888us/step - loss: 230817.4316\n",
      "Epoch 15/20\n",
      "1092/1092 [==============================] - 1s 891us/step - loss: 222055.2802\n",
      "Epoch 16/20\n",
      "1092/1092 [==============================] - 1s 887us/step - loss: 217461.7111\n",
      "Epoch 17/20\n",
      "1092/1092 [==============================] - 1s 919us/step - loss: 223978.2030\n",
      "Epoch 18/20\n",
      "1092/1092 [==============================] - 1s 992us/step - loss: 221872.6065\n",
      "Epoch 19/20\n",
      "1092/1092 [==============================] - 1s 936us/step - loss: 215614.9021\n",
      "Epoch 20/20\n",
      "1092/1092 [==============================] - 1s 924us/step - loss: 214293.3783\n"
     ]
    }
   ],
   "source": [
    "n_input = 14\n",
    "score, scores = evaluate_model(train, test, n_input)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "lstm: [384.824] 379.5, 393.5, 344.6, 377.0, 371.1, 320.5, 486.3\n"
     ]
    }
   ],
   "source": [
    "summarize_scores('lstm', score, scores)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "days = ['sun', 'mon', 'tue', 'wed', 'thr', 'fri', 'sat']\n",
    "pyplot.plot(days, scores, marker='o', label='lstm')\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.6.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}