From cc7be56f3ba6c041eadd44f31a06dc6fdd336302 Mon Sep 17 00:00:00 2001 From: attilabalint Date: Thu, 20 Jun 2024 21:22:40 +0200 Subject: [PATCH] updated forecast client notebook --- notebooks/03. ForecastClient.ipynb | 24406 ++++++++++++++++++++++++++- 1 file changed, 24312 insertions(+), 94 deletions(-) diff --git a/notebooks/03. ForecastClient.ipynb b/notebooks/03. ForecastClient.ipynb index 4407312..2ef3dc1 100644 --- a/notebooks/03. ForecastClient.ipynb +++ b/notebooks/03. ForecastClient.ipynb @@ -2,24 +2,47 @@ "cells": [ { "cell_type": "code", - "execution_count": null, - "metadata": {}, + "execution_count": 1, + "metadata": { + "ExecuteTime": { + "end_time": "2024-06-20T12:13:26.397469Z", + "start_time": "2024-06-20T12:13:22.828054Z" + } + }, "outputs": [], "source": [ - "import pandas as pd" + "import warnings\n", + "\n", + "warnings.filterwarnings(\"ignore\")\n", + "\n", + "import numpy as np\n", + "import pandas as pd\n", + "import matplotlib.pyplot as plt" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "# Load Data" + "# Accessing the Electricity Demand Dataset" ] }, { - "cell_type": "code", - "execution_count": null, + "cell_type": "markdown", "metadata": {}, + "source": [ + "This notebook assumes that you have downloaded the [electricity-demand](https://huggingface.co/datasets/EDS-lab/electricity-demand/tree/main/data) dataset from HuggingFace. To execute this notebook create a folder `data/electricity-demand/` and download the 3 files into it." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "ExecuteTime": { + "end_time": "2024-06-20T12:13:26.783025Z", + "start_time": "2024-06-20T12:13:26.401893Z" + } + }, "outputs": [], "source": [ "from enfobench.datasets import ElectricityDemandDataset\n", @@ -29,66 +52,205 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 3, + "metadata": { + "ExecuteTime": { + "end_time": "2024-06-20T12:13:26.858410Z", + "start_time": "2024-06-20T12:13:26.786827Z" + }, + "collapsed": false, + "jupyter": { + "outputs_hidden": false + } + }, "outputs": [], "source": [ - "unique_ids = ds.metadata_subset.list_unique_ids()" - ], - "metadata": { - "collapsed": false - } + "unique_ids = ds.metadata_subset.list_unique_ids()\n", + "unique_id = unique_ids[0]" + ] }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, + "execution_count": 4, + "metadata": { + "ExecuteTime": { + "end_time": "2024-06-20T12:13:31.647854Z", + "start_time": "2024-06-20T12:13:26.860841Z" + }, + "collapsed": false, + "jupyter": { + "outputs_hidden": false + } + }, "outputs": [], "source": [ - "len(unique_ids)" + "target, weather, metadata = ds.get_data_by_unique_id(unique_id)" ] }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], + "execution_count": 5, + "metadata": { + "ExecuteTime": { + "end_time": "2024-06-20T12:13:31.680836Z", + "start_time": "2024-06-20T12:13:31.654637Z" + }, + "collapsed": false, + "jupyter": { + "outputs_hidden": false + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "DatetimeIndex: 25029 entries, 2012-09-24 12:00:00 to 2014-02-28 00:00:00\n", + "Data columns (total 1 columns):\n", + " # Column Non-Null Count Dtype \n", + "--- ------ -------------- ----- \n", + " 0 y 25028 non-null float64\n", + "dtypes: float64(1)\n", + "memory usage: 391.1 KB\n" + ] + } + ], "source": [ - "unique_id = unique_ids[0]\n", - "unique_id" + "target.info()" ] }, { "cell_type": "code", - "execution_count": null, - "outputs": [], - "source": [ - "target, past_covariates, metadata = ds.get_data_by_unique_id(unique_id)" - ], + "execution_count": 6, "metadata": { - "collapsed": false - } + "ExecuteTime": { + "end_time": "2024-06-20T12:13:31.705221Z", + "start_time": "2024-06-20T12:13:31.684762Z" + }, + "collapsed": false, + "jupyter": { + "outputs_hidden": false + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "DatetimeIndex: 12853 entries, 2012-09-17 12:00:00 to 2014-03-07 00:00:00\n", + "Data columns (total 32 columns):\n", + " # Column Non-Null Count Dtype \n", + "--- ------ -------------- ----- \n", + " 0 temperature_2m 12853 non-null float32\n", + " 1 relative_humidity_2m 12853 non-null float32\n", + " 2 dew_point_2m 12853 non-null float32\n", + " 3 apparent_temperature 12853 non-null float32\n", + " 4 precipitation 12853 non-null float32\n", + " 5 rain 12853 non-null float32\n", + " 6 snowfall 12853 non-null float32\n", + " 7 snow_depth 12853 non-null float32\n", + " 8 weather_code 12853 non-null float32\n", + " 9 pressure_msl 12853 non-null float32\n", + " 10 surface_pressure 12853 non-null float32\n", + " 11 cloud_cover 12853 non-null float32\n", + " 12 cloud_cover_low 12853 non-null float32\n", + " 13 cloud_cover_mid 12853 non-null float32\n", + " 14 cloud_cover_high 12853 non-null float32\n", + " 15 et0_fao_evapotranspiration 12853 non-null float32\n", + " 16 vapour_pressure_deficit 12853 non-null float32\n", + " 17 wind_speed_10m 12853 non-null float32\n", + " 18 wind_direction_10m 12853 non-null float32\n", + " 19 wind_gusts_10m 12853 non-null float32\n", + " 20 soil_temperature_0_to_7cm 12853 non-null float32\n", + " 21 soil_temperature_7_to_28cm 12853 non-null float32\n", + " 22 soil_moisture_0_to_7cm 12853 non-null float32\n", + " 23 soil_moisture_7_to_28cm 12853 non-null float32\n", + " 24 is_day 12853 non-null float32\n", + " 25 sunshine_duration 12853 non-null float32\n", + " 26 shortwave_radiation 12853 non-null float32\n", + " 27 direct_radiation 12853 non-null float32\n", + " 28 diffuse_radiation 12853 non-null float32\n", + " 29 direct_normal_irradiance 12853 non-null float32\n", + " 30 global_tilted_irradiance 12853 non-null float32\n", + " 31 terrestrial_radiation 12853 non-null float32\n", + "dtypes: float32(32)\n", + "memory usage: 1.7 MB\n" + ] + } + ], + "source": [ + "weather.info()" + ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 7, + "metadata": { + "ExecuteTime": { + "end_time": "2024-06-20T12:13:31.714195Z", + "start_time": "2024-06-20T12:13:31.707526Z" + } + }, "outputs": [], "source": [ - "target.info()" - ], - "metadata": { - "collapsed": false - } + "from enfobench.datasets.utils import create_perfect_forecasts_from_covariates" + ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 8, + "metadata": { + "ExecuteTime": { + "end_time": "2024-06-20T12:13:33.850977Z", + "start_time": "2024-06-20T12:13:31.717998Z" + } + }, "outputs": [], "source": [ - "past_covariates.info()" - ], + "perfect_weather_forecasts = create_perfect_forecasts_from_covariates(\n", + " weather[['temperature_2m', 'relative_humidity_2m', 'wind_speed_10m', 'wind_direction_10m', 'cloud_cover']],\n", + " start=pd.Timestamp(\"2013-01-01T00:00:00\"),\n", + " horizon=pd.Timedelta(\"4 days\"),\n", + " step=pd.Timedelta(\"24 hour\"),\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 9, "metadata": { - "collapsed": false - } + "ExecuteTime": { + "end_time": "2024-06-20T12:13:33.870918Z", + "start_time": "2024-06-20T12:13:33.854999Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "RangeIndex: 41419 entries, 0 to 41418\n", + "Data columns (total 7 columns):\n", + " # Column Non-Null Count Dtype \n", + "--- ------ -------------- ----- \n", + " 0 cutoff_date 41419 non-null datetime64[ns]\n", + " 1 timestamp 41419 non-null datetime64[us]\n", + " 2 temperature_2m 41419 non-null float32 \n", + " 3 relative_humidity_2m 41419 non-null float32 \n", + " 4 wind_speed_10m 41419 non-null float32 \n", + " 5 wind_direction_10m 41419 non-null float32 \n", + " 6 cloud_cover 41419 non-null float32 \n", + "dtypes: datetime64[ns](1), datetime64[us](1), float32(5)\n", + "memory usage: 1.4 MB\n" + ] + } + ], + "source": [ + "perfect_weather_forecasts.info()" + ] }, { "cell_type": "markdown", @@ -99,15 +261,21 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, + "execution_count": 10, + "metadata": { + "ExecuteTime": { + "end_time": "2024-06-20T12:13:33.896748Z", + "start_time": "2024-06-20T12:13:33.874753Z" + } + }, "outputs": [], "source": [ "from enfobench import Dataset\n", "\n", "dataset = Dataset(\n", " target=target,\n", - " past_covariates=past_covariates,\n", + " past_covariates=weather,\n", + " future_covariates=perfect_weather_forecasts,\n", " metadata=metadata,\n", ")" ] @@ -121,8 +289,13 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, + "execution_count": 37, + "metadata": { + "ExecuteTime": { + "end_time": "2024-06-20T12:13:35.400315Z", + "start_time": "2024-06-20T12:13:33.900506Z" + } + }, "outputs": [], "source": [ "from enfobench.evaluation import ForecastClient\n", @@ -132,67 +305,23945 @@ }, { "cell_type": "code", - "execution_count": null, - "outputs": [], + "execution_count": 38, + "metadata": { + "ExecuteTime": { + "end_time": "2024-06-20T12:13:35.439724Z", + "start_time": "2024-06-20T12:13:35.403780Z" + }, + "collapsed": false, + "jupyter": { + "outputs_hidden": false + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "ModelInfo(name='Darts.NaiveMean', authors=[{'name': 'Attila Balint', 'email': 'attila.balint@kuleuven.be'}], type='point', params={})" + ] + }, + "execution_count": 38, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "client.info()" - ], - "metadata": { - "collapsed": false - } + ] }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], + "execution_count": 39, + "metadata": { + "ExecuteTime": { + "end_time": "2024-06-20T12:13:39.790623Z", + "start_time": "2024-06-20T12:13:35.443577Z" + } + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 29/29 [00:02<00:00, 12.98it/s]\n" + ] + } + ], "source": [ "from enfobench.evaluation import cross_validate\n", "\n", "crossval_df = cross_validate(\n", " client,\n", " dataset,\n", - " start_date=pd.Timestamp(\"2023-01-01T00:00:00\"),\n", - " end_date=pd.Timestamp(\"2023-02-01T00:00:00\"),\n", + " start_date=pd.Timestamp(\"2013-06-01T10:00:00\"),\n", + " end_date=pd.Timestamp(\"2013-07-01T00:00:00\"),\n", " horizon=pd.Timedelta(\"38 hours\"),\n", " step=pd.Timedelta(\"1 day\"),\n", + " level=90,\n", ")" ] }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], + "execution_count": 40, + "metadata": { + "ExecuteTime": { + "end_time": "2024-06-20T12:13:39.832924Z", + "start_time": "2024-06-20T12:13:39.806289Z" + } + }, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
cutoff_datetimestampyhaty
02013-06-01 10:00:002013-06-01 10:30:000.2028680.389
12013-06-01 10:00:002013-06-01 11:00:000.2028680.094
22013-06-01 10:00:002013-06-01 11:30:000.2028680.170
32013-06-01 10:00:002013-06-01 12:00:000.2028680.081
42013-06-01 10:00:002013-06-01 12:30:000.2028680.318
\n", + "
" + ], + "text/plain": [ + " cutoff_date timestamp yhat y\n", + "0 2013-06-01 10:00:00 2013-06-01 10:30:00 0.202868 0.389\n", + "1 2013-06-01 10:00:00 2013-06-01 11:00:00 0.202868 0.094\n", + "2 2013-06-01 10:00:00 2013-06-01 11:30:00 0.202868 0.170\n", + "3 2013-06-01 10:00:00 2013-06-01 12:00:00 0.202868 0.081\n", + "4 2013-06-01 10:00:00 2013-06-01 12:30:00 0.202868 0.318" + ] + }, + "execution_count": 40, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ - "crossval_df" + "crossval_df.head()" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 41, + "metadata": { + "ExecuteTime": { + "end_time": "2024-06-20T12:13:39.849880Z", + "start_time": "2024-06-20T12:13:39.835755Z" + }, + "collapsed": false, + "jupyter": { + "outputs_hidden": false + } + }, "outputs": [], "source": [ - "cutoff_date_to_plot = crossval_df.cutoff_date.unique()[0]\n", - "crossval_df.loc[crossval_df.cutoff_date == cutoff_date_to_plot].set_index(\"timestamp\").drop(\n", - " columns=[\"cutoff_date\"]\n", - ").plot()" + "import matplotlib.animation as animation\n", + "\n", + "plt.rcParams[\"animation.html\"] = \"jshtml\"" + ] + }, + { + "cell_type": "code", + "execution_count": 42, + "metadata": { + "ExecuteTime": { + "end_time": "2024-06-20T12:13:51.339674Z", + "start_time": "2024-06-20T12:13:39.853659Z" + } + }, + "outputs": [ + { + "data": { + "text/html": [ + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "
\n", + " \n", + "
\n", + " \n", + "
\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
\n", + "
\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
\n", + "
\n", + "
\n", + "\n", + "\n", + "\n" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 42, + "metadata": {}, + "output_type": "execute_result" + } ], + "source": [ + "plt.ioff()\n", + "fig, ax = plt.subplots(figsize=(12, 5))\n", + "\n", + "cutoff_dates = crossval_df.cutoff_date.unique()\n", + "\n", + "\n", + "def animate_forecast(t):\n", + " plt.cla()\n", + "\n", + " cutoff_date = cutoff_dates[t]\n", + " history = dataset.get_history(cutoff_date)\n", + " forecast = (\n", + " crossval_df.loc[crossval_df.cutoff_date == cutoff_date].set_index(\"timestamp\").drop(columns=[\"cutoff_date\"])\n", + " )\n", + "\n", + " ax.plot(history.index, history.y)\n", + " ax.plot(forecast.index, forecast.yhat)\n", + " ax.set_xlim(cutoff_dates[0] - pd.Timedelta('7D'), crossval_df.timestamp.max())\n", + " ax.set_ylabel(\"Energy (kWh)\")\n", + " ax.set_title(f\"Predicted energy consumption at {cutoff_date}\", fontsize=\"large\", loc=\"left\")\n", + "\n", + "\n", + "ani = animation.FuncAnimation(fig, animate_forecast, frames=len(cutoff_dates))\n", + "ani" + ] + }, + { + "cell_type": "code", + "execution_count": 43, "metadata": { - "collapsed": false - } + "ExecuteTime": { + "end_time": "2024-06-20T12:13:51.351012Z", + "start_time": "2024-06-20T12:13:51.344111Z" + } + }, + "outputs": [], + "source": [ + "plt.ion()\n", + "plt.close()" + ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "# Evaluate metrics" + "# Metrics" ] }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, + "execution_count": 44, + "metadata": { + "ExecuteTime": { + "end_time": "2024-06-20T12:13:51.365870Z", + "start_time": "2024-06-20T12:13:51.356365Z" + } + }, "outputs": [], "source": [ "from enfobench.evaluation import evaluate_metrics\n", @@ -201,50 +24252,217 @@ }, { "cell_type": "code", - "execution_count": null, - "outputs": [], - "source": [ - "evaluate_metrics(\n", - " crossval_df,\n", - " metrics={\"MAE\": mean_absolute_error, \"MBE\": mean_bias_error},\n", - ")" - ], + "execution_count": 45, "metadata": { - "collapsed": false - } + "ExecuteTime": { + "end_time": "2024-06-20T12:13:51.389558Z", + "start_time": "2024-06-20T12:13:51.370421Z" + }, + "collapsed": false, + "jupyter": { + "outputs_hidden": false + } + }, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
MAEMBEweight
00.1220820.0224031.0
\n", + "
" + ], + "text/plain": [ + " MAE MBE weight\n", + "0 0.122082 0.022403 1.0" + ] + }, + "execution_count": 45, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "overall_metrics = evaluate_metrics(crossval_df, metrics={\"MAE\": mean_absolute_error, \"MBE\": mean_bias_error})\n", + "overall_metrics" + ] }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], + "execution_count": 46, + "metadata": { + "ExecuteTime": { + "end_time": "2024-06-20T12:13:51.560505Z", + "start_time": "2024-06-20T12:13:51.392953Z" + } + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 29/29 [00:00<00:00, 297.25it/s]\n" + ] + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
cutoff_dateMAEMBEweight
02013-06-01 10:00:000.1069760.0397371.0
12013-06-02 10:00:000.1117810.0487341.0
22013-06-03 10:00:000.1297920.0259331.0
32013-06-04 10:00:000.1320670.0219461.0
42013-06-05 10:00:000.1251430.0047691.0
\n", + "
" + ], + "text/plain": [ + " cutoff_date MAE MBE weight\n", + "0 2013-06-01 10:00:00 0.106976 0.039737 1.0\n", + "1 2013-06-02 10:00:00 0.111781 0.048734 1.0\n", + "2 2013-06-03 10:00:00 0.129792 0.025933 1.0\n", + "3 2013-06-04 10:00:00 0.132067 0.021946 1.0\n", + "4 2013-06-05 10:00:00 0.125143 0.004769 1.0" + ] + }, + "execution_count": 46, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ - "metrics = evaluate_metrics(\n", + "metrics_per_cutoff = evaluate_metrics(\n", " crossval_df,\n", " metrics={\"MAE\": mean_absolute_error, \"MBE\": mean_bias_error},\n", " groupby=\"cutoff_date\",\n", - ")" + ")\n", + "metrics_per_cutoff.head()" ] }, { "cell_type": "code", - "execution_count": null, - "outputs": [], - "source": [ - "metrics" - ], + "execution_count": 47, "metadata": { - "collapsed": false - } + "ExecuteTime": { + "end_time": "2024-06-20T12:13:52.185650Z", + "start_time": "2024-06-20T12:13:51.563801Z" + }, + "collapsed": false, + "jupyter": { + "outputs_hidden": false + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = plt.subplots(figsize=(12, 5))\n", + "metrics_per_cutoff.set_index(\"cutoff_date\")[[\"MAE\", \"MBE\"]].plot(ax=ax)\n", + "ax.set_xlabel(\"Cutoff date\")\n", + "ax.set_ylabel(\"Energy (kWh)\")\n", + "ax.set_title(\"Prediction metrics per cutoff point\", fontsize=\"large\", loc=\"left\")\n", + "plt.show()" + ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], - "source": [ - "metrics[[\"MAE\", \"MBE\"]].plot()" - ] + "source": [] }, { "cell_type": "code", @@ -270,7 +24488,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.10.9" + "version": "3.11.5" } }, "nbformat": 4,