├── README.md ├── .gitignore └── power consumption(CNN_LSTM model).ipynb /README.md: -------------------------------------------------------------------------------- 1 | # time-series-forecasting -------------------------------------------------------------------------------- /.gitignore: -------------------------------------------------------------------------------- 1 | # Byte-compiled / optimized / DLL files 2 | __pycache__/ 3 | *.py[cod] 4 | *$py.class 5 | 6 | # C extensions 7 | *.so 8 | 9 | # Distribution / packaging 10 | .Python 11 | build/ 12 | develop-eggs/ 13 | dist/ 14 | downloads/ 15 | eggs/ 16 | .eggs/ 17 | lib/ 18 | lib64/ 19 | parts/ 20 | sdist/ 21 | var/ 22 | wheels/ 23 | *.egg-info/ 24 | .installed.cfg 25 | *.egg 26 | MANIFEST 27 | 28 | # PyInstaller 29 | # Usually these files are written by a python script from a template 30 | # before PyInstaller builds the exe, so as to inject date/other infos into it. 31 | *.manifest 32 | *.spec 33 | 34 | # Installer logs 35 | pip-log.txt 36 | pip-delete-this-directory.txt 37 | 38 | # Unit test / coverage reports 39 | htmlcov/ 40 | .tox/ 41 | .coverage 42 | .coverage.* 43 | .cache 44 | nosetests.xml 45 | coverage.xml 46 | *.cover 47 | .hypothesis/ 48 | .pytest_cache/ 49 | 50 | # Translations 51 | *.mo 52 | *.pot 53 | 54 | # Django stuff: 55 | *.log 56 | local_settings.py 57 | db.sqlite3 58 | 59 | # Flask stuff: 60 | instance/ 61 | .webassets-cache 62 | 63 | # Scrapy stuff: 64 | .scrapy 65 | 66 | # Sphinx documentation 67 | docs/_build/ 68 | 69 | # PyBuilder 70 | target/ 71 | 72 | # Jupyter Notebook 73 | .ipynb_checkpoints 74 | 75 | # pyenv 76 | .python-version 77 | 78 | # celery beat schedule file 79 | celerybeat-schedule 80 | 81 | # SageMath parsed files 82 | *.sage.py 83 | 84 | # Environments 85 | .env 86 | .venv 87 | env/ 88 | venv/ 89 | ENV/ 90 | env.bak/ 91 | venv.bak/ 92 | 93 | # Spyder project settings 94 | .spyderproject 95 | .spyproject 96 | 97 | # Rope project settings 98 | .ropeproject 99 | 100 | # mkdocs documentation 101 | /site 102 | 103 | # mypy 104 | .mypy_cache/ 105 | -------------------------------------------------------------------------------- /power consumption(CNN_LSTM model).ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "code", 5 | "execution_count": 1, 6 | "metadata": {}, 7 | "outputs": [ 8 | { 9 | "name": "stderr", 10 | "output_type": "stream", 11 | "text": [ 12 | "/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", 13 | " from ._conv import register_converters as _register_converters\n", 14 | "Using TensorFlow backend.\n" 15 | ] 16 | } 17 | ], 18 | "source": [ 19 | "# univariate multi-step encoder-decoder cnn-lstm\n", 20 | "from math import sqrt\n", 21 | "from numpy import split\n", 22 | "from numpy import array\n", 23 | "from pandas import read_csv\n", 24 | "from sklearn.metrics import mean_squared_error\n", 25 | "from matplotlib import pyplot\n", 26 | "from keras.models import Sequential\n", 27 | "from keras.layers import Dense\n", 28 | "from keras.layers import Flatten\n", 29 | "from keras.layers import LSTM\n", 30 | "from keras.layers import RepeatVector\n", 31 | "from keras.layers import TimeDistributed\n", 32 | "from keras.layers.convolutional import Conv1D\n", 33 | "from keras.layers.convolutional import MaxPooling1D\n" 34 | ] 35 | }, 36 | { 37 | "cell_type": "code", 38 | "execution_count": 2, 39 | "metadata": {}, 40 | "outputs": [], 41 | "source": [ 42 | "# load and clean-up data\n", 43 | "from numpy import nan\n", 44 | "from numpy import isnan\n", 45 | "from pandas import read_csv\n", 46 | "from pandas import to_numeric\n", 47 | "\n", 48 | "# fill missing values with a value at the same time one day ago\n", 49 | "def fill_missing(values):\n", 50 | "\tone_day = 60 * 24\n", 51 | "\tfor row in range(values.shape[0]):\n", 52 | "\t\tfor col in range(values.shape[1]):\n", 53 | "\t\t\tif isnan(values[row, col]):\n", 54 | "\t\t\t\tvalues[row, col] = values[row - one_day, col]\n", 55 | "\n", 56 | "# load all data\n", 57 | "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", 58 | "# mark all missing values\n", 59 | "dataset.replace('?', nan, inplace=True)\n", 60 | "# make dataset numeric\n", 61 | "dataset = dataset.astype('float32')\n", 62 | "# fill missing\n", 63 | "fill_missing(dataset.values)\n", 64 | "# add a column for for the remainder of sub metering\n", 65 | "values = dataset.values\n", 66 | "dataset['sub_metering_4'] = (values[:,0] * 1000 / 60) - (values[:,4] + values[:,5] + values[:,6])\n", 67 | "# save updated dataset\n", 68 | "dataset.to_csv('household_power_consumption.csv')" 69 | ] 70 | }, 71 | { 72 | "cell_type": "code", 73 | "execution_count": 3, 74 | "metadata": {}, 75 | "outputs": [ 76 | { 77 | "name": "stdout", 78 | "output_type": "stream", 79 | "text": [ 80 | "(1442, 8)\n", 81 | " Global_active_power Global_reactive_power Voltage \\\n", 82 | "datetime \n", 83 | "2006-12-16 1209.176 34.922 93552.53 \n", 84 | "2006-12-17 3390.460 226.006 345725.32 \n", 85 | "2006-12-18 2203.826 161.792 347373.64 \n", 86 | "2006-12-19 1666.194 150.942 348479.01 \n", 87 | "2006-12-20 2225.748 160.998 348923.61 \n", 88 | "\n", 89 | " Global_intensity Sub_metering_1 Sub_metering_2 Sub_metering_3 \\\n", 90 | "datetime \n", 91 | "2006-12-16 5180.8 0.0 546.0 4926.0 \n", 92 | "2006-12-17 14398.6 2033.0 4187.0 13341.0 \n", 93 | "2006-12-18 9247.2 1063.0 2621.0 14018.0 \n", 94 | "2006-12-19 7094.0 839.0 7602.0 6197.0 \n", 95 | "2006-12-20 9313.0 0.0 2648.0 14063.0 \n", 96 | "\n", 97 | " sub_metering_4 \n", 98 | "datetime \n", 99 | "2006-12-16 14680.933319 \n", 100 | "2006-12-17 36946.666732 \n", 101 | "2006-12-18 19028.433281 \n", 102 | "2006-12-19 13131.900043 \n", 103 | "2006-12-20 20384.800011 \n" 104 | ] 105 | } 106 | ], 107 | "source": [ 108 | "from pandas import read_csv\n", 109 | "# load the new file\n", 110 | "dataset = read_csv('household_power_consumption.csv', header=0, infer_datetime_format=True, parse_dates=['datetime'], index_col=['datetime'])\n", 111 | "# resample data to daily\n", 112 | "daily_groups = dataset.resample('D')\n", 113 | "daily_data = daily_groups.sum()\n", 114 | "# summarize\n", 115 | "print(daily_data.shape)\n", 116 | "print(daily_data.head())\n", 117 | "# save\n", 118 | "daily_data.to_csv('household_power_consumption_days.csv')" 119 | ] 120 | }, 121 | { 122 | "cell_type": "code", 123 | "execution_count": 4, 124 | "metadata": {}, 125 | "outputs": [], 126 | "source": [ 127 | "# split a univariate dataset into train/test sets\n", 128 | "def split_dataset(data):\n", 129 | "\t# split into standard weeks\n", 130 | "\ttrain, test = data[1:-328], data[-328:-6]\n", 131 | "\t# restructure into windows of weekly data\n", 132 | "\ttrain = array(split(train, len(train)/7))\n", 133 | "\ttest = array(split(test, len(test)/7))\n", 134 | "\treturn train, test\n" 135 | ] 136 | }, 137 | { 138 | "cell_type": "code", 139 | "execution_count": 5, 140 | "metadata": {}, 141 | "outputs": [], 142 | "source": [ 143 | "# evaluate one or more weekly forecasts against expected values\n", 144 | "def evaluate_forecasts(actual, predicted):\n", 145 | "\tscores = list()\n", 146 | "\t# calculate an RMSE score for each day\n", 147 | "\tfor i in range(actual.shape[1]):\n", 148 | "\t\t# calculate mse\n", 149 | "\t\tmse = mean_squared_error(actual[:, i], predicted[:, i])\n", 150 | "\t\t# calculate rmse\n", 151 | "\t\trmse = sqrt(mse)\n", 152 | "\t\t# store\n", 153 | "\t\tscores.append(rmse)\n", 154 | "\t# calculate overall RMSE\n", 155 | "\ts = 0\n", 156 | "\tfor row in range(actual.shape[0]):\n", 157 | "\t\tfor col in range(actual.shape[1]):\n", 158 | "\t\t\ts += (actual[row, col] - predicted[row, col])**2\n", 159 | "\tscore = sqrt(s / (actual.shape[0] * actual.shape[1]))\n", 160 | "\treturn score, scores" 161 | ] 162 | }, 163 | { 164 | "cell_type": "code", 165 | "execution_count": 6, 166 | "metadata": {}, 167 | "outputs": [], 168 | "source": [ 169 | "# summarize scores\n", 170 | "def summarize_scores(name, score, scores):\n", 171 | "\ts_scores = ', '.join(['%.1f' % s for s in scores])\n", 172 | "\tprint('%s: [%.3f] %s' % (name, score, s_scores))\n" 173 | ] 174 | }, 175 | { 176 | "cell_type": "code", 177 | "execution_count": 7, 178 | "metadata": {}, 179 | "outputs": [], 180 | "source": [ 181 | "# convert history into inputs and outputs\n", 182 | "def to_supervised(train, n_input, n_out=7):\n", 183 | "\t# flatten data\n", 184 | "\tdata = train.reshape((train.shape[0]*train.shape[1], train.shape[2]))\n", 185 | "\tX, y = list(), list()\n", 186 | "\tin_start = 0\n", 187 | "\t# step over the entire history one time step at a time\n", 188 | "\tfor _ in range(len(data)):\n", 189 | "\t\t# define the end of the input sequence\n", 190 | "\t\tin_end = in_start + n_input\n", 191 | "\t\tout_end = in_end + n_out\n", 192 | "\t\t# ensure we have enough data for this instance\n", 193 | "\t\tif out_end < len(data):\n", 194 | "\t\t\tx_input = data[in_start:in_end, 0]\n", 195 | "\t\t\tx_input = x_input.reshape((len(x_input), 1))\n", 196 | "\t\t\tX.append(x_input)\n", 197 | "\t\t\ty.append(data[in_end:out_end, 0])\n", 198 | "\t\t# move along one time step\n", 199 | "\t\tin_start += 1\n", 200 | "\treturn array(X), array(y)" 201 | ] 202 | }, 203 | { 204 | "cell_type": "code", 205 | "execution_count": 8, 206 | "metadata": {}, 207 | "outputs": [], 208 | "source": [ 209 | "# train the model\n", 210 | "def build_model(train, n_input):\n", 211 | "\t# prepare data\n", 212 | "\ttrain_x, train_y = to_supervised(train, n_input)\n", 213 | "\t# define parameters\n", 214 | "\tverbose, epochs, batch_size = 1, 20, 16\n", 215 | "\tn_timesteps, n_features, n_outputs = train_x.shape[1], train_x.shape[2], train_y.shape[1]\n", 216 | "\t# reshape output into [samples, timesteps, features]\n", 217 | "\ttrain_y = train_y.reshape((train_y.shape[0], train_y.shape[1], 1))\n", 218 | "\t# define model\n", 219 | "\tmodel = Sequential()\n", 220 | "\tmodel.add(Conv1D(filters=64, kernel_size=3, activation='relu', input_shape=(n_timesteps,n_features)))\n", 221 | "\tmodel.add(Conv1D(filters=64, kernel_size=3, activation='relu'))\n", 222 | "\tmodel.add(MaxPooling1D(pool_size=2))\n", 223 | "\tmodel.add(Flatten())\n", 224 | "\tmodel.add(RepeatVector(n_outputs))\n", 225 | "\tmodel.add(LSTM(200, activation='relu', return_sequences=True))\n", 226 | "\tmodel.add(TimeDistributed(Dense(100, activation='relu')))\n", 227 | "\tmodel.add(TimeDistributed(Dense(1)))\n", 228 | "\tmodel.compile(loss='mse', optimizer='adam')\n", 229 | "\t# fit network\n", 230 | "\tmodel.fit(train_x, train_y, epochs=epochs, batch_size=batch_size, verbose=verbose)\n", 231 | "\treturn model" 232 | ] 233 | }, 234 | { 235 | "cell_type": "code", 236 | "execution_count": 9, 237 | "metadata": {}, 238 | "outputs": [], 239 | "source": [ 240 | "# make a forecast\n", 241 | "def forecast(model, history, n_input):\n", 242 | "\t# flatten data\n", 243 | "\tdata = array(history)\n", 244 | "\tdata = data.reshape((data.shape[0]*data.shape[1], data.shape[2]))\n", 245 | "\t# retrieve last observations for input data\n", 246 | "\tinput_x = data[-n_input:, 0]\n", 247 | "\t# reshape into [1, n_input, 1]\n", 248 | "\tinput_x = input_x.reshape((1, len(input_x), 1))\n", 249 | "\t# forecast the next week\n", 250 | "\tyhat = model.predict(input_x, verbose=0)\n", 251 | "\t# we only want the vector forecast\n", 252 | "\tyhat = yhat[0]\n", 253 | "\treturn yhat\n" 254 | ] 255 | }, 256 | { 257 | "cell_type": "code", 258 | "execution_count": 10, 259 | "metadata": {}, 260 | "outputs": [], 261 | "source": [ 262 | "# evaluate a single model\n", 263 | "def evaluate_model(train, test, n_input):\n", 264 | "\t# fit model\n", 265 | "\tmodel = build_model(train, n_input)\n", 266 | "\t# history is a list of weekly data\n", 267 | "\thistory = [x for x in train]\n", 268 | "\t# walk-forward validation over each week\n", 269 | "\tpredictions = list()\n", 270 | "\tfor i in range(len(test)):\n", 271 | "\t\t# predict the week\n", 272 | "\t\tyhat_sequence = forecast(model, history, n_input)\n", 273 | "\t\t# store the predictions\n", 274 | "\t\tpredictions.append(yhat_sequence)\n", 275 | "\t\t# get real observation and add to history for predicting the next week\n", 276 | "\t\thistory.append(test[i, :])\n", 277 | "\t# evaluate predictions days for each week\n", 278 | "\tpredictions = array(predictions)\n", 279 | "\tscore, scores = evaluate_forecasts(test[:, :, 0], predictions)\n", 280 | "\treturn score, scores\n" 281 | ] 282 | }, 283 | { 284 | "cell_type": "code", 285 | "execution_count": 11, 286 | "metadata": {}, 287 | "outputs": [], 288 | "source": [ 289 | "dataset = read_csv('household_power_consumption_days.csv', header=0, infer_datetime_format=True, parse_dates=['datetime'], index_col=['datetime'])\n", 290 | "# split into train and test\n", 291 | "train, test = split_dataset(dataset.values)" 292 | ] 293 | }, 294 | { 295 | "cell_type": "code", 296 | "execution_count": 12, 297 | "metadata": {}, 298 | "outputs": [ 299 | { 300 | "name": "stdout", 301 | "output_type": "stream", 302 | "text": [ 303 | "Epoch 1/20\n", 304 | "1092/1092 [==============================] - 2s 1ms/step - loss: 435270.3608\n", 305 | "Epoch 2/20\n", 306 | "1092/1092 [==============================] - 1s 766us/step - loss: 300231.2393\n", 307 | "Epoch 3/20\n", 308 | "1092/1092 [==============================] - 1s 776us/step - loss: 275300.5275\n", 309 | "Epoch 4/20\n", 310 | "1092/1092 [==============================] - 1s 786us/step - loss: 260993.0590\n", 311 | "Epoch 5/20\n", 312 | "1092/1092 [==============================] - 1s 765us/step - loss: 266096.9929\n", 313 | "Epoch 6/20\n", 314 | "1092/1092 [==============================] - 1s 773us/step - loss: 258835.1892\n", 315 | "Epoch 7/20\n", 316 | "1092/1092 [==============================] - 1s 782us/step - loss: 247371.8784\n", 317 | "Epoch 8/20\n", 318 | "1092/1092 [==============================] - 1s 807us/step - loss: 238335.3384\n", 319 | "Epoch 9/20\n", 320 | "1092/1092 [==============================] - 1s 810us/step - loss: 246909.0011\n", 321 | "Epoch 10/20\n", 322 | "1092/1092 [==============================] - 1s 852us/step - loss: 232966.6564\n", 323 | "Epoch 11/20\n", 324 | "1092/1092 [==============================] - 1s 869us/step - loss: 228553.7986\n", 325 | "Epoch 12/20\n", 326 | "1092/1092 [==============================] - 1s 879us/step - loss: 224944.4207\n", 327 | "Epoch 13/20\n", 328 | "1092/1092 [==============================] - 1s 887us/step - loss: 229067.7553\n", 329 | "Epoch 14/20\n", 330 | "1092/1092 [==============================] - 1s 888us/step - loss: 230817.4316\n", 331 | "Epoch 15/20\n", 332 | "1092/1092 [==============================] - 1s 891us/step - loss: 222055.2802\n", 333 | "Epoch 16/20\n", 334 | "1092/1092 [==============================] - 1s 887us/step - loss: 217461.7111\n", 335 | "Epoch 17/20\n", 336 | "1092/1092 [==============================] - 1s 919us/step - loss: 223978.2030\n", 337 | "Epoch 18/20\n", 338 | "1092/1092 [==============================] - 1s 992us/step - loss: 221872.6065\n", 339 | "Epoch 19/20\n", 340 | "1092/1092 [==============================] - 1s 936us/step - loss: 215614.9021\n", 341 | "Epoch 20/20\n", 342 | "1092/1092 [==============================] - 1s 924us/step - loss: 214293.3783\n" 343 | ] 344 | } 345 | ], 346 | "source": [ 347 | "n_input = 14\n", 348 | "score, scores = evaluate_model(train, test, n_input)" 349 | ] 350 | }, 351 | { 352 | "cell_type": "code", 353 | "execution_count": 13, 354 | "metadata": {}, 355 | "outputs": [ 356 | { 357 | "name": "stdout", 358 | "output_type": "stream", 359 | "text": [ 360 | "lstm: [384.824] 379.5, 393.5, 344.6, 377.0, 371.1, 320.5, 486.3\n" 361 | ] 362 | } 363 | ], 364 | "source": [ 365 | "summarize_scores('lstm', score, scores)\n" 366 | ] 367 | }, 368 | { 369 | "cell_type": "code", 370 | "execution_count": 14, 371 | "metadata": {}, 372 | "outputs": [ 373 | { 374 | "data": { 375 | "image/png": "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\n", 376 | "text/plain": [ 377 | "
" 378 | ] 379 | }, 380 | "metadata": {}, 381 | "output_type": "display_data" 382 | } 383 | ], 384 | "source": [ 385 | "days = ['sun', 'mon', 'tue', 'wed', 'thr', 'fri', 'sat']\n", 386 | "pyplot.plot(days, scores, marker='o', label='lstm')\n", 387 | "pyplot.show()" 388 | ] 389 | }, 390 | { 391 | "cell_type": "code", 392 | "execution_count": null, 393 | "metadata": {}, 394 | "outputs": [], 395 | "source": [] 396 | } 397 | ], 398 | "metadata": { 399 | "kernelspec": { 400 | "display_name": "Python 3", 401 | "language": "python", 402 | "name": "python3" 403 | }, 404 | "language_info": { 405 | "codemirror_mode": { 406 | "name": "ipython", 407 | "version": 3 408 | }, 409 | "file_extension": ".py", 410 | "mimetype": "text/x-python", 411 | "name": "python", 412 | "nbconvert_exporter": "python", 413 | "pygments_lexer": "ipython3", 414 | "version": "3.6.4" 415 | } 416 | }, 417 | "nbformat": 4, 418 | "nbformat_minor": 2 419 | } 420 | --------------------------------------------------------------------------------