diff --git a/examples/bim.ipynb b/examples/bim.ipynb new file mode 100644 index 0000000000..349ecc5b21 --- /dev/null +++ b/examples/bim.ipynb @@ -0,0 +1,888 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "d8c28fed", + "metadata": {}, + "outputs": [], + "source": [ + "from itertools import islice\n", + "%matplotlib inline\n", + "from matplotlib import pyplot as plt\n", + "import matplotlib.dates as mdates" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "7d50dcd2", + "metadata": {}, + "outputs": [], + "source": [ + "from gluonts.dataset.repository.datasets import get_dataset\n", + "from gluonts.dataset.common import ListDataset\n", + "from gluonts.evaluation import make_evaluation_predictions, Evaluator\n", + "from gluonts.torch.model.bim.estimator import BimEstimator\n" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "a1d82599", + "metadata": {}, + "outputs": [], + "source": [ + "dataset = get_dataset(\"traffic\")" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "a1fb2fc6", + "metadata": {}, + "outputs": [], + "source": [ + "estimator = BimEstimator(\n", + " prediction_length=dataset.metadata.prediction_length,\n", + " context_length=dataset.metadata.prediction_length*3,\n", + " \n", + " scaling=\"std\",\n", + " \n", + " batch_size=32,\n", + " num_batches_per_epoch=100,\n", + " trainer_kwargs=dict(accelerator=\"cpu\", max_epochs=20)\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "f5237407", + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "GPU available: True (mps), used: False\n", + "TPU available: False, using: 0 TPU cores\n", + "HPU available: False, using: 0 HPUs\n", + "/opt/homebrew/lib/python3.11/site-packages/lightning/pytorch/trainer/setup.py:177: GPU available but not used. You can set it by doing `Trainer(accelerator='gpu')`.\n", + "/opt/homebrew/lib/python3.11/site-packages/lightning/pytorch/trainer/connectors/logger_connector/logger_connector.py:75: Starting from v1.9.0, `tensorboardX` has been removed as a dependency of the `lightning.pytorch` package, due to potential conflicts with other packages in the ML ecosystem. For this reason, `logger=True` will use `CSVLogger` as the default logger, unless the `tensorboard` or `tensorboardX` packages are found. Please `pip install lightning[extra]` or one of them to enable TensorBoard support by default\n", + "\n", + " | Name | Type | Params | Mode \n", + "-------------------------------------------\n", + "0 | model | BimModel | 72.3 K | train\n", + "-------------------------------------------\n", + "72.3 K Trainable params\n", + "0 Non-trainable params\n", + "72.3 K Total params\n", + "0.289 Total estimated model params size (MB)\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "7c3fa05161d847889c905c5f7a9b16fd", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Sanity Checking: | …" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/kashif/Github/gluon-ts/src/gluonts/dataset/common.py:263: FutureWarning: 'H' is deprecated and will be removed in a future version, please use 'h' instead.\n", + " return pd.Period(val, freq)\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "063dbbde27974a80a73221feb88903a7", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Training: | …" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "fd6389b8852d42b59933ea7ab22bf7d8", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | …" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Epoch 0, global step 100: 'val_loss' reached -2.66824 (best -2.66824), saving model to '/Users/kashif/Github/gluon-ts/examples/lightning_logs/version_220/checkpoints/epoch=0-step=100.ckpt' as top 1\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "c1e5ed5645a7442db463a80a0cbe3af9", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | …" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Epoch 1, global step 200: 'val_loss' reached -2.77567 (best -2.77567), saving model to '/Users/kashif/Github/gluon-ts/examples/lightning_logs/version_220/checkpoints/epoch=1-step=200.ckpt' as top 1\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "b70d5ca154114c93a21e9e8e664c5401", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | …" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Epoch 2, global step 300: 'val_loss' reached -2.82832 (best -2.82832), saving model to '/Users/kashif/Github/gluon-ts/examples/lightning_logs/version_220/checkpoints/epoch=2-step=300.ckpt' as top 1\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "08a0629107854e4c9c34c5d5ecfffd4e", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | …" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Epoch 3, global step 400: 'val_loss' reached -2.83858 (best -2.83858), saving model to '/Users/kashif/Github/gluon-ts/examples/lightning_logs/version_220/checkpoints/epoch=3-step=400.ckpt' as top 1\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "bd8ec836b80d48119652710c658cc7f1", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | …" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Epoch 4, global step 500: 'val_loss' reached -2.85746 (best -2.85746), saving model to '/Users/kashif/Github/gluon-ts/examples/lightning_logs/version_220/checkpoints/epoch=4-step=500.ckpt' as top 1\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "0f6ebb3ab9864326bfc41a6660657e5f", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | …" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Epoch 5, global step 600: 'val_loss' reached -2.87144 (best -2.87144), saving model to '/Users/kashif/Github/gluon-ts/examples/lightning_logs/version_220/checkpoints/epoch=5-step=600.ckpt' as top 1\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "71e9e9889d80458584f39f14e3ccba42", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | …" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Epoch 6, global step 700: 'val_loss' reached -2.91088 (best -2.91088), saving model to '/Users/kashif/Github/gluon-ts/examples/lightning_logs/version_220/checkpoints/epoch=6-step=700.ckpt' as top 1\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "e5be1e89176d4b5d864f68d8c0ab588b", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | …" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Epoch 7, global step 800: 'val_loss' reached -2.91406 (best -2.91406), saving model to '/Users/kashif/Github/gluon-ts/examples/lightning_logs/version_220/checkpoints/epoch=7-step=800.ckpt' as top 1\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "cb4407d3d2cf4b4fa8e6ff55a0ff96d5", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | …" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Epoch 8, global step 900: 'val_loss' reached -2.92444 (best -2.92444), saving model to '/Users/kashif/Github/gluon-ts/examples/lightning_logs/version_220/checkpoints/epoch=8-step=900.ckpt' as top 1\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "f0894850aba54c9f83dd44b61b4b8256", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | …" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Epoch 9, global step 1000: 'val_loss' reached -2.94968 (best -2.94968), saving model to '/Users/kashif/Github/gluon-ts/examples/lightning_logs/version_220/checkpoints/epoch=9-step=1000.ckpt' as top 1\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "8d21ba36dee84578b20f89e68ab31198", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | …" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Epoch 10, global step 1100: 'val_loss' was not in top 1\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "45a82df0db4b480cad21be5aad8c2220", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | …" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Epoch 11, global step 1200: 'val_loss' was not in top 1\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "a232de6104154d148bb1380c4625e614", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | …" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Epoch 12, global step 1300: 'val_loss' was not in top 1\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "33b7e8812c774328b44b7c2073c32144", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | …" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Epoch 13, global step 1400: 'val_loss' was not in top 1\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "ee1edebbb7e043d7ad0e15948959514b", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | …" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Epoch 14, global step 1500: 'val_loss' was not in top 1\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "ecd524ab0ca04f0a98531a2c0251624f", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | …" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Epoch 15, global step 1600: 'val_loss' reached -2.97275 (best -2.97275), saving model to '/Users/kashif/Github/gluon-ts/examples/lightning_logs/version_220/checkpoints/epoch=15-step=1600.ckpt' as top 1\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "9bba4da9059c4bea839d4900381e87d1", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | …" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Epoch 16, global step 1700: 'val_loss' reached -2.98381 (best -2.98381), saving model to '/Users/kashif/Github/gluon-ts/examples/lightning_logs/version_220/checkpoints/epoch=16-step=1700.ckpt' as top 1\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "1d501d993bb348f69c964cc21f1829e5", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | …" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Epoch 17, global step 1800: 'val_loss' was not in top 1\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "564a171747194f6889377c519ae91269", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | …" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Epoch 18, global step 1900: 'val_loss' reached -2.99498 (best -2.99498), saving model to '/Users/kashif/Github/gluon-ts/examples/lightning_logs/version_220/checkpoints/epoch=18-step=1900.ckpt' as top 1\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "35d03bf8f9384de7b74bc5d0f380613b", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | …" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Epoch 19, global step 2000: 'val_loss' was not in top 1\n", + "`Trainer.fit` stopped: `max_epochs=20` reached.\n", + "/opt/homebrew/lib/python3.11/site-packages/lightning/fabric/utilities/cloud_io.py:57: You are using `torch.load` with `weights_only=False` (the current default value), which uses the default pickle module implicitly. It is possible to construct malicious pickle data which will execute arbitrary code during unpickling (See https://github.com/pytorch/pytorch/blob/main/SECURITY.md#untrusted-models for more details). In a future release, the default value for `weights_only` will be flipped to `True`. This limits the functions that could be executed during unpickling. Arbitrary objects will no longer be allowed to be loaded via this mode unless they are explicitly allowlisted by the user via `torch.serialization.add_safe_globals`. We recommend you start setting `weights_only=True` for any use case where you don't have full control of the loaded file. Please open an issue on GitHub for any issues related to this experimental feature.\n" + ] + } + ], + "source": [ + "predictor = estimator.train(training_data=dataset.train, cache_data=True, shuffle_buffer_length=1024,\n", + " validation_data=dataset.test)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "1a3b3153", + "metadata": {}, + "outputs": [], + "source": [ + "forecast_it, ts_it = make_evaluation_predictions(\n", + " dataset=dataset.test,\n", + " predictor=predictor,\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "e91150c4", + "metadata": {}, + "outputs": [], + "source": [ + "forecasts = list(forecast_it)" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "9e07512e", + "metadata": {}, + "outputs": [], + "source": [ + "tss = list(ts_it)" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "b5b0c01e", + "metadata": {}, + "outputs": [], + "source": [ + "evaluator = Evaluator()" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "39de0d08", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Running evaluation: 6034it [00:00, 15347.96it/s]\n", + "/Users/kashif/Github/gluon-ts/src/gluonts/evaluation/_base.py:426: RuntimeWarning: divide by zero encountered in scalar divide\n", + " metrics[\"ND\"] = cast(float, metrics[\"abs_error\"]) / cast(\n", + "/Users/kashif/Github/gluon-ts/src/gluonts/evaluation/_base.py:426: RuntimeWarning: divide by zero encountered in scalar divide\n", + " metrics[\"ND\"] = cast(float, metrics[\"abs_error\"]) / cast(\n", + "/Users/kashif/Github/gluon-ts/src/gluonts/evaluation/_base.py:426: RuntimeWarning: divide by zero encountered in scalar divide\n", + " metrics[\"ND\"] = cast(float, metrics[\"abs_error\"]) / cast(\n", + "/Users/kashif/Github/gluon-ts/src/gluonts/evaluation/_base.py:426: RuntimeWarning: divide by zero encountered in scalar divide\n", + " metrics[\"ND\"] = cast(float, metrics[\"abs_error\"]) / cast(\n", + "/opt/homebrew/lib/python3.11/site-packages/pandas/core/dtypes/astype.py:133: UserWarning: Warning: converting a masked element to nan.\n", + " return arr.astype(dtype, copy=True)\n" + ] + } + ], + "source": [ + "agg_metrics, ts_metrics = evaluator(iter(tss), iter(forecasts))" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "b1ed76e9-eee8-4c78-9027-a7a0834afe2d", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'MSE': np.float64(0.0011298803665301842),\n", + " 'abs_error': np.float64(2170.0790347605944),\n", + " 'abs_target_sum': np.float64(8672.5710073933),\n", + " 'abs_target_mean': np.float64(0.0598868288545002),\n", + " 'seasonal_error': np.float64(0.015220711169889631),\n", + " 'MASE': np.float64(0.9896811474773825),\n", + " 'MAPE': np.float64(0.38089177533154706),\n", + " 'sMAPE': np.float64(0.26805173954995887),\n", + " 'MSIS': np.float64(10.749864545359605),\n", + " 'num_masked_target_values': np.float64(0.0),\n", + " 'QuantileLoss[0.1]': np.float64(976.4684847870581),\n", + " 'Coverage[0.1]': np.float64(0.0713318970279527),\n", + " 'QuantileLoss[0.2]': np.float64(1499.848177894979),\n", + " 'Coverage[0.2]': np.float64(0.16033449342614076),\n", + " 'QuantileLoss[0.3]': np.float64(1846.2374114756412),\n", + " 'Coverage[0.3]': np.float64(0.2534733731079439),\n", + " 'QuantileLoss[0.4]': np.float64(2065.859245616509),\n", + " 'Coverage[0.4]': np.float64(0.34730968953706776),\n", + " 'QuantileLoss[0.5]': np.float64(2170.0790345663263),\n", + " 'Coverage[0.5]': np.float64(0.4515108827753839),\n", + " 'QuantileLoss[0.6]': np.float64(2182.4352470805607),\n", + " 'Coverage[0.6]': np.float64(0.5754612749972379),\n", + " 'QuantileLoss[0.7]': np.float64(2106.5751750650234),\n", + " 'Coverage[0.7]': np.float64(0.7017663794055905),\n", + " 'QuantileLoss[0.8]': np.float64(1906.9515658452292),\n", + " 'Coverage[0.8]': np.float64(0.8113675284498951),\n", + " 'QuantileLoss[0.9]': np.float64(1489.2563424226114),\n", + " 'Coverage[0.9]': np.float64(0.9015025963981881),\n", + " 'RMSE': np.float64(0.033613693140299),\n", + " 'NRMSE': np.float64(0.5612869103816823),\n", + " 'ND': np.float64(0.25022326515523696),\n", + " 'wQuantileLoss[0.1]': np.float64(0.11259273449068634),\n", + " 'wQuantileLoss[0.2]': np.float64(0.17294158521347014),\n", + " 'wQuantileLoss[0.3]': np.float64(0.21288236324634735),\n", + " 'wQuantileLoss[0.4]': np.float64(0.23820609181007335),\n", + " 'wQuantileLoss[0.5]': np.float64(0.25022326513283666),\n", + " 'wQuantileLoss[0.6]': np.float64(0.25164801132444475),\n", + " 'wQuantileLoss[0.7]': np.float64(0.2429008852471988),\n", + " 'wQuantileLoss[0.8]': np.float64(0.21988307322241207),\n", + " 'wQuantileLoss[0.9]': np.float64(0.17172028238835194),\n", + " 'mean_absolute_QuantileLoss': np.float64(1804.8567427504377),\n", + " 'mean_wQuantileLoss': np.float64(0.2081109213417579),\n", + " 'MAE_Coverage': np.float64(0.4015025963981881),\n", + " 'OWA': nan}" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "agg_metrics" + ] + }, + { + "cell_type": "code", + "execution_count": 112, + "id": "d55c38d2", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'MSE': 0.0012157388789809426,\n", + " 'abs_error': 2127.716419382952,\n", + " 'abs_target_sum': 8672.5710073933,\n", + " 'abs_target_mean': 0.0598868288545002,\n", + " 'seasonal_error': 0.015220711169889631,\n", + " 'MASE': 0.9701767568477553,\n", + " 'MAPE': 0.33072504744208253,\n", + " 'sMAPE': 0.251086545969627,\n", + " 'MSIS': 13.999280725979883,\n", + " 'QuantileLoss[0.1]': 960.0377484792289,\n", + " 'Coverage[0.1]': 0.0900660148049939,\n", + " 'QuantileLoss[0.2]': 1515.4287390368036,\n", + " 'Coverage[0.2]': 0.16795105513202963,\n", + " 'QuantileLoss[0.3]': 1847.8790533013753,\n", + " 'Coverage[0.3]': 0.23866837918462047,\n", + " 'QuantileLoss[0.4]': 2037.9262423127334,\n", + " 'Coverage[0.4]': 0.3186802563252679,\n", + " 'QuantileLoss[0.5]': 2127.7164221946655,\n", + " 'Coverage[0.5]': 0.42130703789636503,\n", + " 'QuantileLoss[0.6]': 2152.2924958084946,\n", + " 'Coverage[0.6]': 0.5579217765992708,\n", + " 'QuantileLoss[0.7]': 2125.670852061852,\n", + " 'Coverage[0.7]': 0.6996740691636284,\n", + " 'QuantileLoss[0.8]': 2016.824655845428,\n", + " 'Coverage[0.8]': 0.8053253784112252,\n", + " 'QuantileLoss[0.9]': 1733.3085551973445,\n", + " 'Coverage[0.9]': 0.8823541597613523,\n", + " 'RMSE': 0.03486744726791657,\n", + " 'NRMSE': 0.5822223005434098,\n", + " 'ND': 0.24533859885022447,\n", + " 'wQuantileLoss[0.1]': 0.11069817101074227,\n", + " 'wQuantileLoss[0.2]': 0.17473811834401956,\n", + " 'wQuantileLoss[0.3]': 0.21307165449854173,\n", + " 'wQuantileLoss[0.4]': 0.2349852472323855,\n", + " 'wQuantileLoss[0.5]': 0.24533859917443207,\n", + " 'wQuantileLoss[0.6]': 0.2481723694131396,\n", + " 'wQuantileLoss[0.7]': 0.24510273254029677,\n", + " 'wQuantileLoss[0.8]': 0.2325521064198956,\n", + " 'wQuantileLoss[0.9]': 0.19986098167656538,\n", + " 'mean_absolute_QuantileLoss': 1835.2316404708808,\n", + " 'mean_wQuantileLoss': 0.21161333114555758,\n", + " 'MAE_Coverage': 0.386275457592163,\n", + " 'OWA': nan}" + ] + }, + "execution_count": 112, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "agg_metrics" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "aed3c26e", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure(figsize=(20, 15))\n", + "date_formater = mdates.DateFormatter('%b, %d')\n", + "plt.rcParams.update({'font.size': 15})\n", + "\n", + "for idx, (forecast, ts) in islice(enumerate(zip(forecasts, tss)), 12):\n", + " ax = plt.subplot(3, 4, idx+1)\n", + "\n", + " plt.plot(ts[-4 * dataset.metadata.prediction_length:].to_timestamp(), label=\"target\", )\n", + " forecast.plot( color='g', show_label=True)\n", + " plt.xticks(rotation=60)\n", + " ax.xaxis.set_major_formatter(date_formater)\n", + " ax.set_title(forecast.item_id)\n", + "\n", + "plt.gcf().tight_layout()\n", + "plt.legend()\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "e28df5ce", + "metadata": {}, + "outputs": [], + "source": [ + "def plot_ts(index):\n", + " plt.plot(tss[index][-4 * dataset.metadata.prediction_length:].to_timestamp(), label=\"target\")\n", + " forecasts[index].plot(show_label=True, color='g')\n", + " plt.legend()\n", + " plt.gcf().autofmt_xdate()\n", + " plt.savefig(\"d-linear.png\")\n", + " plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "id": "d6533c71-797e-4b67-960d-bbbf8d590c9b", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plot_ts(9)" + ] + }, + { + "cell_type": "code", + "execution_count": 125, + "id": "795b44a8", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plot_ts(9)" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "4e8bdcd1", + "metadata": {}, + "outputs": [], + "source": [ + "def plot_ts(index):\n", + " plt.plot(tss[index][-4 * dataset.metadata.prediction_length:].to_timestamp(), label=\"target\")\n", + " forecasts[index].plot(show_label=True, color='g')\n", + " plt.legend()\n", + " plt.gcf().autofmt_xdate()\n", + " plt.savefig(\"d-linear.png\")\n", + " plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "54c8b916-62fb-443d-afa2-73710f5c7db2", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "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.11.9" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/src/gluonts/torch/model/bim/__init__.py b/src/gluonts/torch/model/bim/__init__.py new file mode 100644 index 0000000000..9d504ec372 --- /dev/null +++ b/src/gluonts/torch/model/bim/__init__.py @@ -0,0 +1,18 @@ +# Copyright 2018 Amazon.com, Inc. or its affiliates. All Rights Reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"). +# You may not use this file except in compliance with the License. +# A copy of the License is located at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# or in the "license" file accompanying this file. This file is distributed +# on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either +# express or implied. See the License for the specific language governing +# permissions and limitations under the License. + +from .module import BimModel +from .lightning_module import BimLightningModule +from .estimator import BimEstimator + +__all__ = ["BimModel", "BimLightningModule", "BimEstimator"] diff --git a/src/gluonts/torch/model/bim/estimator.py b/src/gluonts/torch/model/bim/estimator.py new file mode 100644 index 0000000000..d1f64006e5 --- /dev/null +++ b/src/gluonts/torch/model/bim/estimator.py @@ -0,0 +1,244 @@ +# Copyright 2018 Amazon.com, Inc. or its affiliates. All Rights Reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"). +# You may not use this file except in compliance with the License. +# A copy of the License is located at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# or in the "license" file accompanying this file. This file is distributed +# on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either +# express or implied. See the License for the specific language governing +# permissions and limitations under the License. + +from typing import Optional, Iterable, Dict, Any + +import torch +import lightning.pytorch as pl + +from gluonts.core.component import validated +from gluonts.dataset.common import Dataset +from gluonts.dataset.field_names import FieldName +from gluonts.dataset.loader import as_stacked_batches +from gluonts.itertools import Cyclic +from gluonts.transform import ( + Transformation, + AddObservedValuesIndicator, + InstanceSampler, + InstanceSplitter, + ValidationSplitSampler, + TestSplitSampler, + ExpectedNumInstanceSampler, + SelectFields, +) +from gluonts.torch.model.estimator import PyTorchLightningEstimator +from gluonts.torch.model.predictor import PyTorchPredictor +from gluonts.torch.distributions import Output, StudentTOutput + +from .lightning_module import BimLightningModule + +PREDICTION_INPUT_NAMES = ["past_target", "past_observed_values"] + +TRAINING_INPUT_NAMES = PREDICTION_INPUT_NAMES + [ + "future_target", + "future_observed_values", +] + + +class BimEstimator(PyTorchLightningEstimator): + """ + An estimator training the Bim model extended for probabilistic + forecasting. + + This class is uses the model defined in ``BimModel``, + and wraps it into a ``BimLightningModule`` for training + purposes: training is performed using PyTorch Lightning's ``pl.Trainer`` + class. + + Parameters + ---------- + prediction_length + Length of the prediction horizon. + context_length + Number of time steps prior to prediction time that the model + takes as inputs (default: ``10 * prediction_length``). + hidden_dimension + Size of representation. + lr + Learning rate (default: ``1e-3``). + weight_decay + Weight decay regularization parameter (default: ``1e-8``). + distr_output + Distribution to use to evaluate observations and sample predictions + (default: StudentTOutput()). + kernel_size + batch_size + The size of the batches to be used for training (default: 32). + num_batches_per_epoch + Number of batches to be processed in each training epoch + (default: 50). + trainer_kwargs + Additional arguments to provide to ``pl.Trainer`` for construction. + train_sampler + Controls the sampling of windows during training. + validation_sampler + Controls the sampling of windows during validation. + """ + + @validated() + def __init__( + self, + prediction_length: int, + context_length: Optional[int] = None, + hidden_dimension: int = 4, + mem_num: int = 100, + ep_mem_num: int = 100, + ep_topk: int = 5, + gamma: float = 1.0, + lr: float = 1e-3, + weight_decay: float = 1e-8, + scaling: Optional[str] = "std", + distr_output: Output = StudentTOutput(), + batch_size: int = 32, + num_batches_per_epoch: int = 50, + trainer_kwargs: Optional[Dict[str, Any]] = None, + train_sampler: Optional[InstanceSampler] = None, + validation_sampler: Optional[InstanceSampler] = None, + ) -> None: + default_trainer_kwargs = { + "max_epochs": 100, + "gradient_clip_val": 10.0, + } + if trainer_kwargs is not None: + default_trainer_kwargs.update(trainer_kwargs) + super().__init__(trainer_kwargs=default_trainer_kwargs) + + self.prediction_length = prediction_length + self.context_length = context_length or 10 * prediction_length + # TODO find way to enforce same defaults to network and estimator + # somehow + self.hidden_dimension = hidden_dimension + self.lr = lr + self.weight_decay = weight_decay + self.distr_output = distr_output + self.scaling = scaling + self.mem_num = mem_num + self.ep_mem_num = ep_mem_num + self.ep_topk = ep_topk + self.gamma = gamma + self.batch_size = batch_size + self.num_batches_per_epoch = num_batches_per_epoch + + self.train_sampler = train_sampler or ExpectedNumInstanceSampler( + num_instances=1.0, min_future=prediction_length + ) + self.validation_sampler = validation_sampler or ValidationSplitSampler( + min_future=prediction_length + ) + + def create_transformation(self) -> Transformation: + return SelectFields( + [ + FieldName.ITEM_ID, + FieldName.INFO, + FieldName.START, + FieldName.TARGET, + ], + allow_missing=True, + ) + AddObservedValuesIndicator( + target_field=FieldName.TARGET, + output_field=FieldName.OBSERVED_VALUES, + ) + + def create_lightning_module(self) -> pl.LightningModule: + return BimLightningModule( + lr=self.lr, + weight_decay=self.weight_decay, + model_kwargs={ + "prediction_length": self.prediction_length, + "context_length": self.context_length, + "hidden_dimension": self.hidden_dimension, + "distr_output": self.distr_output, + "mem_num": self.mem_num, + "ep_mem_num": self.ep_mem_num, + "ep_topk": self.ep_topk, + "gamma": self.gamma, + "scaling": self.scaling, + }, + ) + + def _create_instance_splitter(self, module: BimLightningModule, mode: str): + assert mode in ["training", "validation", "test"] + + instance_sampler = { + "training": self.train_sampler, + "validation": self.validation_sampler, + "test": TestSplitSampler(), + }[mode] + + return InstanceSplitter( + target_field=FieldName.TARGET, + is_pad_field=FieldName.IS_PAD, + start_field=FieldName.START, + forecast_start_field=FieldName.FORECAST_START, + instance_sampler=instance_sampler, + past_length=self.context_length, + future_length=self.prediction_length, + time_series_fields=[ + FieldName.OBSERVED_VALUES, + ], + dummy_value=self.distr_output.value_in_support, + ) + + def create_training_data_loader( + self, + data: Dataset, + module: BimLightningModule, + shuffle_buffer_length: Optional[int] = None, + **kwargs, + ) -> Iterable: + data = Cyclic(data).stream() + instances = self._create_instance_splitter(module, "training").apply( + data, is_train=True + ) + return as_stacked_batches( + instances, + batch_size=self.batch_size, + shuffle_buffer_length=shuffle_buffer_length, + field_names=TRAINING_INPUT_NAMES, + output_type=torch.tensor, + num_batches_per_epoch=self.num_batches_per_epoch, + ) + + def create_validation_data_loader( + self, + data: Dataset, + module: BimLightningModule, + **kwargs, + ) -> Iterable: + instances = self._create_instance_splitter(module, "validation").apply( + data, is_train=True + ) + return as_stacked_batches( + instances, + batch_size=self.batch_size, + field_names=TRAINING_INPUT_NAMES, + output_type=torch.tensor, + ) + + def create_predictor( + self, + transformation: Transformation, + module, + ) -> PyTorchPredictor: + prediction_splitter = self._create_instance_splitter(module, "test") + + return PyTorchPredictor( + input_transform=transformation + prediction_splitter, + input_names=PREDICTION_INPUT_NAMES, + prediction_net=module, + forecast_generator=self.distr_output.forecast_generator, + batch_size=self.batch_size, + prediction_length=self.prediction_length, + device="auto", + ) diff --git a/src/gluonts/torch/model/bim/lightning_module.py b/src/gluonts/torch/model/bim/lightning_module.py new file mode 100644 index 0000000000..4860ad8c0e --- /dev/null +++ b/src/gluonts/torch/model/bim/lightning_module.py @@ -0,0 +1,104 @@ +# Copyright 2018 Amazon.com, Inc. or its affiliates. All Rights Reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"). +# You may not use this file except in compliance with the License. +# A copy of the License is located at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# or in the "license" file accompanying this file. This file is distributed +# on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either +# express or implied. See the License for the specific language governing +# permissions and limitations under the License. + +import lightning.pytorch as pl +import torch + +from gluonts.core.component import validated +from gluonts.itertools import select + +from .module import BimModel + + +class BimLightningModule(pl.LightningModule): + """ + A ``pl.LightningModule`` class that can be used to train a ``BimModel`` + with PyTorch Lightning. + + This is a thin layer around a (wrapped) ``BimModel`` object, + that exposes the methods to evaluate training and validation loss. + + Parameters + ---------- + model_kwargs + Keyword arguments to construct the ``BimModel`` to be trained. + loss + Loss function to be used for training. + lr + Learning rate. + weight_decay + Weight decay regularization parameter. + """ + + @validated() + def __init__( + self, + model_kwargs: dict, + lr: float = 1e-3, + weight_decay: float = 1e-8, + ): + super().__init__() + self.save_hyperparameters() + self.model = BimModel(**model_kwargs) + self.lr = lr + self.weight_decay = weight_decay + self.inputs = self.model.describe_inputs() + + def forward(self, *args, **kwargs): + return self.model.forward(*args, **kwargs) + + def training_step(self, batch, batch_idx: int): # type: ignore + """ + Execute training step. + """ + train_loss, h = self.model.loss( + **select(self.inputs, batch), + future_target=batch["future_target"], + future_observed_values=batch["future_observed_values"], + ) + self.log( + "train_loss", + train_loss.mean(), + on_epoch=True, + on_step=False, + prog_bar=True, + ) + + # update episodic memory + self.model.update_episodic_memory(h, train_loss) + + return train_loss.mean() + + def validation_step(self, batch, batch_idx: int): # type: ignore + """ + Execute validation step. + """ + val_loss = self.model.loss( + **select(self.inputs, batch), + future_target=batch["future_target"], + future_observed_values=batch["future_observed_values"], + ).mean() + self.log( + "val_loss", val_loss, on_epoch=True, on_step=False, prog_bar=True + ) + return val_loss + + def configure_optimizers(self): + """ + Returns the optimizer to use. + """ + return torch.optim.Adam( + self.model.parameters(), + lr=self.lr, + weight_decay=self.weight_decay, + ) diff --git a/src/gluonts/torch/model/bim/module.py b/src/gluonts/torch/model/bim/module.py new file mode 100644 index 0000000000..c16cfb2ab1 --- /dev/null +++ b/src/gluonts/torch/model/bim/module.py @@ -0,0 +1,279 @@ +# Copyright 2018 Amazon.com, Inc. or its affiliates. All Rights Reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"). +# You may not use this file except in compliance with the License. +# A copy of the License is located at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# or in the "license" file accompanying this file. This file is distributed +# on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either +# express or implied. See the License for the specific language governing +# permissions and limitations under the License. + +from typing import Tuple + +import torch +from torch import nn + +from gluonts.core.component import validated +from gluonts.model import Input, InputSpec +from gluonts.torch.distributions import StudentTOutput +from gluonts.torch.scaler import StdScaler, MeanScaler, NOPScaler +from gluonts.torch.model.simple_feedforward import make_linear_layer +from gluonts.torch.util import weighted_average + + +class BimModel(nn.Module): + """ + Module implementing Bim model extended for probabilistic + forecasting. + + Parameters + ---------- + prediction_length + Number of time points to predict. + context_length + Number of time steps prior to prediction time that the model. + hidden_dimension + Size of last hidden layers in the feed-forward network. + distr_output + Distribution to use to evaluate observations and sample predictions. + """ + + @validated() + def __init__( + self, + prediction_length: int, + context_length: int, + hidden_dimension: int, + mem_num: int, + ep_mem_num: int, + ep_topk: int, + gamma: float = 1.0, + distr_output=StudentTOutput(), + scaling: str = "mean", + ) -> None: + super().__init__() + + assert prediction_length > 0 + assert context_length > 0 + + self.prediction_length = prediction_length + self.context_length = context_length + self.hidden_dimension = hidden_dimension + self.mem_dim = hidden_dimension * prediction_length + self.mem_num = mem_num + self.ep_mem_num = ep_mem_num + self.gamma = gamma + self.ep_topk = ep_topk + self.point = 0 + self.first = 1 + self.substitution = 1 + self.num_hard_example = 2 + + self.distr_output = distr_output + if scaling == "mean": + self.scaler = MeanScaler(keepdim=True) + elif scaling == "std": + self.scaler = StdScaler(keepdim=True) + else: + self.scaler = NOPScaler(keepdim=True) + + # concat loc and scale to the context window + self.linear_backbone = make_linear_layer( + context_length + 2, self.mem_dim + ) + self.end_conv = nn.Conv1d( + self.mem_dim * 3, self.mem_dim, kernel_size=1 + ) + + # memory + self.memory = self.construct_memory() + self.ep_frequency = self.construct_episodic_memory() + + # emission head + self.args_proj = self.distr_output.get_args_proj(hidden_dimension) + + def construct_memory(self): + memory_dict = nn.ParameterDict() + memory_dict["Memory"] = nn.Parameter( + torch.randn(self.mem_num, self.mem_dim), requires_grad=True + ) + memory_dict["Wq"] = nn.Parameter( + torch.randn(self.mem_dim, self.mem_dim), requires_grad=True + ) + for param in memory_dict.values(): + nn.init.xavier_normal_(param) + return memory_dict + + def construct_episodic_memory(self): + self.register_buffer( + "episodic_memory", torch.zeros(self.mem_num, self.mem_dim) + ) + ep_frequency = dict(zip(range(self.ep_mem_num), [1] * self.ep_mem_num)) + return ep_frequency + + def describe_inputs(self, batch_size=1) -> InputSpec: + return InputSpec( + { + "past_target": Input( + shape=(batch_size, self.context_length), dtype=torch.float + ), + "past_observed_values": Input( + shape=(batch_size, self.context_length), dtype=torch.float + ), + }, + torch.zeros, + ) + + def combine_features(self, h, h_memory, h_ep): + h_m_sum = torch.cat((h_memory * 1, h), dim=-1) + h_all = torch.cat((h_m_sum, h_ep * self.gamma), dim=-1) + y = self.end_conv(h_all.unsqueeze(-1)).squeeze(-1) + return y + + def forward( + self, + past_target: torch.Tensor, + past_observed_values: torch.Tensor, + ) -> Tuple[Tuple[torch.Tensor, ...], torch.Tensor, torch.Tensor]: + # scale the input + past_target_scaled, loc, scale = self.scaler( + past_target, past_observed_values + ) + loc_scale = torch.cat( + [loc.sign() * loc.abs().log1p(), scale.log()], dim=-1 + ) + h = self.linear_backbone( + torch.cat([past_target_scaled, loc_scale], dim=-1) + ) + h_memory, _, _, _ = self.query_memory(h) + h_ep = self.query_episodic_memory(h) + y = self.combine_features(h, h_memory, h_ep) + + distr_args = self.args_proj( + y.reshape(-1, self.prediction_length, self.hidden_dimension) + ) + + if self.training: + return (distr_args, loc, scale, h) + else: + return (distr_args, loc, scale) + + def query_episodic_memory(self, h_t: torch.Tensor): + query = h_t + top_k = self.ep_topk + matched_idx, k_score = self.get_nearest_key( + query, key_dict=self.episodic_memory, k=top_k + ) + k_score = torch.softmax(k_score, dim=-1).unsqueeze(-1) + mem = self.episodic_memory[matched_idx].detach() + value = torch.sum( + mem * k_score, dim=1 + ) # Changed from dim=2 to dim=1 due to reduced dimensionality + + frequency = torch.bincount(matched_idx.reshape(-1)).tolist() + if self.first and torch.sum(self.episodic_memory) == 0: + self.first = 0 + pass + else: + for f in range(len(frequency)): + self.ep_frequency[f] += frequency[f] + if self.point == 0: + self.ep_frequency = dict( + sorted(self.ep_frequency.items(), key=lambda x: x[1]) + ) # slow + self.id = list(self.ep_frequency.keys()) + return value + + # We also need to implement the get_nearest_key method: + def get_nearest_key(self, query, key_dict, k=3, sim="cosine"): + if sim == "cosine": + sim_func = nn.CosineSimilarity(dim=-1, eps=1e-6) + else: + raise NotImplementedError + with torch.no_grad(): + key_dict = key_dict.unsqueeze(0) # (1, K, d) + similarity = sim_func(key_dict, query.unsqueeze(1)) # (B, K) + topk = torch.topk(similarity, k) + k_score = topk.values + k_index = topk.indices + + return k_index, k_score + + def query_memory(self, h_t: torch.Tensor): + query = torch.matmul(h_t, self.memory["Wq"]) # (B, d) + att_score = torch.softmax( + torch.matmul( + query, self.memory["Memory"].t() / (self.mem_dim**0.5) + ), + dim=-1, + ) # alpha: (B, M) + value = torch.matmul(att_score, self.memory["Memory"]) # (B, d) + _, matched_idx = torch.topk(att_score, k=2, dim=-1) + pos = self.memory["Memory"][matched_idx[:, 0]] # B, d + neg = self.memory["Memory"][matched_idx[:, 1]] # B, d + return value, query, pos, neg + + def loss( + self, + past_target: torch.Tensor, + past_observed_values: torch.Tensor, + future_target: torch.Tensor, + future_observed_values: torch.Tensor, + ) -> torch.Tensor: + if self.training: + distr_args, loc, scale, h = self( + past_target=past_target, + past_observed_values=past_observed_values, + ) + loss = self.distr_output.loss( + target=future_target, + distr_args=distr_args, + loc=loc, + scale=scale, + ) + + return weighted_average( + loss, weights=future_observed_values, dim=-1 + ), h + else: + distr_args, loc, scale = self( + past_target=past_target, + past_observed_values=past_observed_values, + ) + loss = self.distr_output.loss( + target=future_target, + distr_args=distr_args, + loc=loc, + scale=scale, + ) + + return weighted_average( + loss, weights=future_observed_values, dim=-1 + ) + + def update_episodic_memory(self, h, nll): + # update the episodic memory with the most challenging targets + _, index = torch.topk(nll, k=self.num_hard_example, largest=True) + hard_examples = h[index] + + # Update episodic memory + for i, hard_example in enumerate(hard_examples): + memory_index = self.id[self.point] + self.episodic_memory[memory_index, :] = hard_example.data + self.ep_frequency[memory_index] = 0 + self.point += 1 + self.point %= self.num_hard_example * self.substitution + + # Break if we've updated all available memory slots + if i >= self.ep_mem_num - 1: + break + + # If self.point has wrapped around, update self.id + if self.point == 0: + self.ep_frequency = dict( + sorted(self.ep_frequency.items(), key=lambda x: x[1]) + ) + self.id = list(self.ep_frequency.keys())