diff --git a/nbs/common.base_model.ipynb b/nbs/common.base_model.ipynb
index fd32e85d1..8ea7143c2 100644
--- a/nbs/common.base_model.ipynb
+++ b/nbs/common.base_model.ipynb
@@ -127,7 +127,11 @@
" **trainer_kwargs,\n",
" ):\n",
" super().__init__()\n",
- " self.save_hyperparameters() # Allows instantiation from a checkpoint from class\n",
+ " with warnings.catch_warnings(record=False):\n",
+ " warnings.filterwarnings('ignore')\n",
+ " # the following line issues a warning about the loss attribute being saved\n",
+ " # but we do want to save it\n",
+ " self.save_hyperparameters() # Allows instantiation from a checkpoint from class\n",
" self.random_seed = random_seed\n",
" pl.seed_everything(self.random_seed, workers=True)\n",
"\n",
@@ -240,8 +244,10 @@
" )\n",
"\n",
" if self.val_check_steps > self.max_steps:\n",
- " warnings.warn('val_check_steps is greater than max_steps, \\\n",
- " setting val_check_steps to max_steps')\n",
+ " warnings.warn(\n",
+ " 'val_check_steps is greater than max_steps, '\n",
+ " 'setting val_check_steps to max_steps.'\n",
+ " )\n",
" val_check_interval = min(self.val_check_steps, self.max_steps)\n",
" self.trainer_kwargs['val_check_interval'] = int(val_check_interval)\n",
" self.trainer_kwargs['check_val_every_n_epoch'] = None\n",
@@ -355,9 +361,15 @@
" def on_validation_epoch_end(self):\n",
" if self.val_size == 0:\n",
" return\n",
- " avg_loss = torch.stack(self.validation_step_outputs).mean()\n",
- " self.log(\"ptl/val_loss\", avg_loss, sync_dist=True)\n",
- " self.valid_trajectories.append((self.global_step, float(avg_loss)))\n",
+ " losses = torch.stack(self.validation_step_outputs)\n",
+ " avg_loss = losses.mean().item()\n",
+ " self.log(\n",
+ " \"ptl/val_loss\",\n",
+ " avg_loss,\n",
+ " batch_size=losses.size(0),\n",
+ " sync_dist=True,\n",
+ " )\n",
+ " self.valid_trajectories.append((self.global_step, avg_loss))\n",
" self.validation_step_outputs.clear() # free memory (compute `avg_loss` per epoch)\n",
"\n",
" def save(self, path):\n",
diff --git a/nbs/common.base_multivariate.ipynb b/nbs/common.base_multivariate.ipynb
index e7cc67e02..959c047b2 100644
--- a/nbs/common.base_multivariate.ipynb
+++ b/nbs/common.base_multivariate.ipynb
@@ -384,8 +384,14 @@
" print('output', torch.isnan(output).sum())\n",
" raise Exception('Loss is NaN, training stopped.')\n",
"\n",
- " self.log('train_loss', loss, prog_bar=True, on_epoch=True)\n",
- " self.train_trajectories.append((self.global_step, float(loss)))\n",
+ " self.log(\n",
+ " 'train_loss',\n",
+ " loss.item(),\n",
+ " batch_size=outsample_y.size(0),\n",
+ " prog_bar=True,\n",
+ " on_epoch=True,\n",
+ " )\n",
+ " self.train_trajectories.append((self.global_step, loss.item()))\n",
" return loss\n",
"\n",
" def validation_step(self, batch, batch_idx):\n",
@@ -428,7 +434,13 @@
" if torch.isnan(valid_loss):\n",
" raise Exception('Loss is NaN, training stopped.')\n",
"\n",
- " self.log('valid_loss', valid_loss, prog_bar=True, on_epoch=True)\n",
+ " self.log(\n",
+ " 'valid_loss',\n",
+ " valid_loss.item(),\n",
+ " batch_size=outsample_y.size(0),\n",
+ " prog_bar=True,\n",
+ " on_epoch=True,\n",
+ " )\n",
" self.validation_step_outputs.append(valid_loss)\n",
" return valid_loss\n",
"\n",
diff --git a/nbs/common.base_recurrent.ipynb b/nbs/common.base_recurrent.ipynb
index 3d78187a2..835242309 100644
--- a/nbs/common.base_recurrent.ipynb
+++ b/nbs/common.base_recurrent.ipynb
@@ -358,8 +358,14 @@
" print('output', torch.isnan(output).sum())\n",
" raise Exception('Loss is NaN, training stopped.')\n",
"\n",
- " self.log('train_loss', loss, batch_size=self.batch_size, prog_bar=True, on_epoch=True)\n",
- " self.train_trajectories.append((self.global_step, float(loss)))\n",
+ " self.log(\n",
+ " 'train_loss',\n",
+ " loss.item(),\n",
+ " batch_size=outsample_y.size(0),\n",
+ " prog_bar=True,\n",
+ " on_epoch=True,\n",
+ " )\n",
+ " self.train_trajectories.append((self.global_step, loss.item()))\n",
" return loss\n",
"\n",
" def validation_step(self, batch, batch_idx):\n",
@@ -425,7 +431,13 @@
" if torch.isnan(valid_loss):\n",
" raise Exception('Loss is NaN, training stopped.')\n",
"\n",
- " self.log('valid_loss', valid_loss, batch_size=self.batch_size, prog_bar=True, on_epoch=True)\n",
+ " self.log(\n",
+ " 'valid_loss',\n",
+ " valid_loss.item(),\n",
+ " batch_size=outsample_y.size(0),\n",
+ " prog_bar=True,\n",
+ " on_epoch=True,\n",
+ " )\n",
" self.validation_step_outputs.append(valid_loss)\n",
" return valid_loss\n",
"\n",
diff --git a/nbs/common.base_windows.ipynb b/nbs/common.base_windows.ipynb
index ba4fcb3ce..f4b1da83b 100644
--- a/nbs/common.base_windows.ipynb
+++ b/nbs/common.base_windows.ipynb
@@ -441,8 +441,14 @@
" print('output', torch.isnan(output).sum())\n",
" raise Exception('Loss is NaN, training stopped.')\n",
"\n",
- " self.log('train_loss', loss, prog_bar=True, on_epoch=True)\n",
- " self.train_trajectories.append((self.global_step, float(loss)))\n",
+ " self.log(\n",
+ " 'train_loss',\n",
+ " loss.item(),\n",
+ " batch_size=outsample_y.size(0),\n",
+ " prog_bar=True,\n",
+ " on_epoch=True,\n",
+ " )\n",
+ " self.train_trajectories.append((self.global_step, loss.item()))\n",
" return loss\n",
"\n",
" def _compute_valid_loss(self, outsample_y, output, outsample_mask, temporal_cols, y_idx):\n",
@@ -513,14 +519,20 @@
" batch_sizes.append(len(output_batch))\n",
" \n",
" valid_loss = torch.stack(valid_losses)\n",
- " batch_sizes = torch.tensor(batch_sizes).to(valid_loss.device)\n",
- " valid_loss = torch.sum(valid_loss * batch_sizes) \\\n",
- " / torch.sum(batch_sizes)\n",
+ " batch_sizes = torch.tensor(batch_sizes, device=valid_loss.device)\n",
+ " batch_size = torch.sum(batch_sizes)\n",
+ " valid_loss = torch.sum(valid_loss * batch_sizes) / batch_size\n",
"\n",
" if torch.isnan(valid_loss):\n",
" raise Exception('Loss is NaN, training stopped.')\n",
"\n",
- " self.log('valid_loss', valid_loss, prog_bar=True, on_epoch=True)\n",
+ " self.log(\n",
+ " 'valid_loss',\n",
+ " valid_loss.item(),\n",
+ " batch_size=batch_size,\n",
+ " prog_bar=True,\n",
+ " on_epoch=True,\n",
+ " )\n",
" self.validation_step_outputs.append(valid_loss)\n",
" return valid_loss\n",
"\n",
diff --git a/nbs/core.ipynb b/nbs/core.ipynb
index 2c2b15c50..14165c3a9 100644
--- a/nbs/core.ipynb
+++ b/nbs/core.ipynb
@@ -68,6 +68,7 @@
"import fsspec\n",
"import numpy as np\n",
"import pandas as pd\n",
+ "import pytorch_lightning as pl\n",
"import torch\n",
"import utilsforecast.processing as ufp\n",
"from coreforecast.grouped_array import GroupedArray\n",
@@ -102,6 +103,10 @@
"outputs": [],
"source": [
"#| exporti\n",
+ "# this disables warnings about the number of workers in the dataloaders\n",
+ "# which the user can't control\n",
+ "pl.disable_possible_user_warnings()\n",
+ "\n",
"def _insample_times(\n",
" times: np.ndarray,\n",
" uids: Series,\n",
diff --git a/nbs/models.bitcn.ipynb b/nbs/models.bitcn.ipynb
index 539f6c80d..d08bec764 100644
--- a/nbs/models.bitcn.ipynb
+++ b/nbs/models.bitcn.ipynb
@@ -13,16 +13,7 @@
"cell_type": "code",
"execution_count": null,
"metadata": {},
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "The autoreload extension is already loaded. To reload it, use:\n",
- " %reload_ext autoreload\n"
- ]
- }
- ],
+ "outputs": [],
"source": [
"#| hide\n",
"%load_ext autoreload\n",
@@ -362,131 +353,7 @@
"cell_type": "code",
"execution_count": null,
"metadata": {},
- "outputs": [
- {
- "name": "stderr",
- "output_type": "stream",
- "text": [
- "c:\\Users\\ospra\\miniconda3\\envs\\neuralforecast\\lib\\site-packages\\statsforecast\\utils.py:237: FutureWarning: 'M' is deprecated and will be removed in a future version, please use 'ME' instead.\n",
- " \"ds\": pd.date_range(start=\"1949-01-01\", periods=len(AirPassengers), freq=\"M\"),\n"
- ]
- },
- {
- "data": {
- "text/markdown": [
- "---\n",
- "\n",
- "[source](https://github.com/Nixtla/neuralforecast/blob/main/neuralforecast/models/bitcn.py#L79){target=\"_blank\" style=\"float:right; font-size:smaller\"}\n",
- "\n",
- "### BiTCN\n",
- "\n",
- "> BiTCN (h:int, input_size:int, hidden_size:int=16, dropout:float=0.1,\n",
- "> futr_exog_list=None, hist_exog_list=None, stat_exog_list=None,\n",
- "> exclude_insample_y=False, loss=MAE(), valid_loss=None,\n",
- "> max_steps:int=1000, learning_rate:float=0.001,\n",
- "> num_lr_decays:int=-1, early_stop_patience_steps:int=-1,\n",
- "> val_check_steps:int=100, batch_size:int=32,\n",
- "> valid_batch_size:Optional[int]=None, windows_batch_size=1024,\n",
- "> inference_windows_batch_size=-1, start_padding_enabled=False,\n",
- "> step_size:int=1, scaler_type:str='identity', random_seed:int=1,\n",
- "> num_workers_loader:int=0, drop_last_loader:bool=False,\n",
- "> optimizer=None, optimizer_kwargs=None, **trainer_kwargs)\n",
- "\n",
- "BiTCN\n",
- "\n",
- "Bidirectional Temporal Convolutional Network (BiTCN) is a forecasting architecture based on two temporal convolutional networks (TCNs). The first network ('forward') encodes future covariates of the time series, whereas the second network ('backward') encodes past observations and covariates. This is a univariate model.\n",
- "\n",
- "**Parameters:**
\n",
- "`h`: int, forecast horizon.
\n",
- "`input_size`: int, considered autorregresive inputs (lags), y=[1,2,3,4] input_size=2 -> lags=[1,2].
\n",
- "`hidden_size`: int=16, units for the TCN's hidden state size.
\n",
- "`dropout`: float=0.1, dropout rate used for the dropout layers throughout the architecture.
\n",
- "`futr_exog_list`: str list, future exogenous columns.
\n",
- "`hist_exog_list`: str list, historic exogenous columns.
\n",
- "`stat_exog_list`: str list, static exogenous columns.
\n",
- "`exclude_insample_y`: bool=False, the model skips the autoregressive features y[t-input_size:t] if True.
\n",
- "`loss`: PyTorch module, instantiated train loss class from [losses collection](https://nixtla.github.io/neuralforecast/losses.pytorch.html).
\n",
- "`valid_loss`: PyTorch module=`loss`, instantiated valid loss class from [losses collection](https://nixtla.github.io/neuralforecast/losses.pytorch.html).
\n",
- "`max_steps`: int=1000, maximum number of training steps.
\n",
- "`learning_rate`: float=1e-3, Learning rate between (0, 1).
\n",
- "`num_lr_decays`: int=-1, Number of learning rate decays, evenly distributed across max_steps.
\n",
- "`early_stop_patience_steps`: int=-1, Number of validation iterations before early stopping.
\n",
- "`val_check_steps`: int=100, Number of training steps between every validation loss check.
\n",
- "`batch_size`: int=32, number of different series in each batch.
\n",
- "`valid_batch_size`: int=None, number of different series in each validation and test batch, if None uses batch_size.
\n",
- "`windows_batch_size`: int=1024, number of windows to sample in each training batch, default uses all.
\n",
- "`inference_windows_batch_size`: int=-1, number of windows to sample in each inference batch, -1 uses all.
\n",
- "`start_padding_enabled`: bool=False, if True, the model will pad the time series with zeros at the beginning, by input size.
\n",
- "`step_size`: int=1, step size between each window of temporal data.
\n",
- "`scaler_type`: str='identity', type of scaler for temporal inputs normalization see [temporal scalers](https://nixtla.github.io/neuralforecast/common.scalers.html).
\n",
- "`random_seed`: int=1, random_seed for pytorch initializer and numpy generators.
\n",
- "`num_workers_loader`: int=os.cpu_count(), workers to be used by `TimeSeriesDataLoader`.
\n",
- "`drop_last_loader`: bool=False, if True `TimeSeriesDataLoader` drops last non-full batch.
\n",
- "`alias`: str, optional, Custom name of the model.
\n",
- "`optimizer`: Subclass of 'torch.optim.Optimizer', optional, user specified optimizer instead of the default choice (Adam).
\n",
- "`optimizer_kwargs`: dict, optional, list of parameters used by the user specified `optimizer`.
\n",
- "`**trainer_kwargs`: int, keyword trainer arguments inherited from [PyTorch Lighning's trainer](https://pytorch-lightning.readthedocs.io/en/stable/api/pytorch_lightning.trainer.trainer.Trainer.html?highlight=trainer).
"
- ],
- "text/plain": [
- "---\n",
- "\n",
- "[source](https://github.com/Nixtla/neuralforecast/blob/main/neuralforecast/models/bitcn.py#L79){target=\"_blank\" style=\"float:right; font-size:smaller\"}\n",
- "\n",
- "### BiTCN\n",
- "\n",
- "> BiTCN (h:int, input_size:int, hidden_size:int=16, dropout:float=0.1,\n",
- "> futr_exog_list=None, hist_exog_list=None, stat_exog_list=None,\n",
- "> exclude_insample_y=False, loss=MAE(), valid_loss=None,\n",
- "> max_steps:int=1000, learning_rate:float=0.001,\n",
- "> num_lr_decays:int=-1, early_stop_patience_steps:int=-1,\n",
- "> val_check_steps:int=100, batch_size:int=32,\n",
- "> valid_batch_size:Optional[int]=None, windows_batch_size=1024,\n",
- "> inference_windows_batch_size=-1, start_padding_enabled=False,\n",
- "> step_size:int=1, scaler_type:str='identity', random_seed:int=1,\n",
- "> num_workers_loader:int=0, drop_last_loader:bool=False,\n",
- "> optimizer=None, optimizer_kwargs=None, **trainer_kwargs)\n",
- "\n",
- "BiTCN\n",
- "\n",
- "Bidirectional Temporal Convolutional Network (BiTCN) is a forecasting architecture based on two temporal convolutional networks (TCNs). The first network ('forward') encodes future covariates of the time series, whereas the second network ('backward') encodes past observations and covariates. This is a univariate model.\n",
- "\n",
- "**Parameters:**
\n",
- "`h`: int, forecast horizon.
\n",
- "`input_size`: int, considered autorregresive inputs (lags), y=[1,2,3,4] input_size=2 -> lags=[1,2].
\n",
- "`hidden_size`: int=16, units for the TCN's hidden state size.
\n",
- "`dropout`: float=0.1, dropout rate used for the dropout layers throughout the architecture.
\n",
- "`futr_exog_list`: str list, future exogenous columns.
\n",
- "`hist_exog_list`: str list, historic exogenous columns.
\n",
- "`stat_exog_list`: str list, static exogenous columns.
\n",
- "`exclude_insample_y`: bool=False, the model skips the autoregressive features y[t-input_size:t] if True.
\n",
- "`loss`: PyTorch module, instantiated train loss class from [losses collection](https://nixtla.github.io/neuralforecast/losses.pytorch.html).
\n",
- "`valid_loss`: PyTorch module=`loss`, instantiated valid loss class from [losses collection](https://nixtla.github.io/neuralforecast/losses.pytorch.html).
\n",
- "`max_steps`: int=1000, maximum number of training steps.
\n",
- "`learning_rate`: float=1e-3, Learning rate between (0, 1).
\n",
- "`num_lr_decays`: int=-1, Number of learning rate decays, evenly distributed across max_steps.
\n",
- "`early_stop_patience_steps`: int=-1, Number of validation iterations before early stopping.
\n",
- "`val_check_steps`: int=100, Number of training steps between every validation loss check.
\n",
- "`batch_size`: int=32, number of different series in each batch.
\n",
- "`valid_batch_size`: int=None, number of different series in each validation and test batch, if None uses batch_size.
\n",
- "`windows_batch_size`: int=1024, number of windows to sample in each training batch, default uses all.
\n",
- "`inference_windows_batch_size`: int=-1, number of windows to sample in each inference batch, -1 uses all.
\n",
- "`start_padding_enabled`: bool=False, if True, the model will pad the time series with zeros at the beginning, by input size.
\n",
- "`step_size`: int=1, step size between each window of temporal data.
\n",
- "`scaler_type`: str='identity', type of scaler for temporal inputs normalization see [temporal scalers](https://nixtla.github.io/neuralforecast/common.scalers.html).
\n",
- "`random_seed`: int=1, random_seed for pytorch initializer and numpy generators.
\n",
- "`num_workers_loader`: int=os.cpu_count(), workers to be used by `TimeSeriesDataLoader`.
\n",
- "`drop_last_loader`: bool=False, if True `TimeSeriesDataLoader` drops last non-full batch.
\n",
- "`alias`: str, optional, Custom name of the model.
\n",
- "`optimizer`: Subclass of 'torch.optim.Optimizer', optional, user specified optimizer instead of the default choice (Adam).
\n",
- "`optimizer_kwargs`: dict, optional, list of parameters used by the user specified `optimizer`.
\n",
- "`**trainer_kwargs`: int, keyword trainer arguments inherited from [PyTorch Lighning's trainer](https://pytorch-lightning.readthedocs.io/en/stable/api/pytorch_lightning.trainer.trainer.Trainer.html?highlight=trainer).
"
- ]
- },
- "execution_count": null,
- "metadata": {},
- "output_type": "execute_result"
- }
- ],
+ "outputs": [],
"source": [
"show_doc(BiTCN)"
]
@@ -495,71 +362,7 @@
"cell_type": "code",
"execution_count": null,
"metadata": {},
- "outputs": [
- {
- "data": {
- "text/markdown": [
- "---\n",
- "\n",
- "### BiTCN.fit\n",
- "\n",
- "> BiTCN.fit (dataset, val_size=0, test_size=0, random_seed=None)\n",
- "\n",
- "Fit.\n",
- "\n",
- "The `fit` method, optimizes the neural network's weights using the\n",
- "initialization parameters (`learning_rate`, `windows_batch_size`, ...)\n",
- "and the `loss` function as defined during the initialization.\n",
- "Within `fit` we use a PyTorch Lightning `Trainer` that\n",
- "inherits the initialization's `self.trainer_kwargs`, to customize\n",
- "its inputs, see [PL's trainer arguments](https://pytorch-lightning.readthedocs.io/en/stable/api/pytorch_lightning.trainer.trainer.Trainer.html?highlight=trainer).\n",
- "\n",
- "The method is designed to be compatible with SKLearn-like classes\n",
- "and in particular to be compatible with the StatsForecast library.\n",
- "\n",
- "By default the `model` is not saving training checkpoints to protect\n",
- "disk memory, to get them change `enable_checkpointing=True` in `__init__`.\n",
- "\n",
- "**Parameters:**
\n",
- "`dataset`: NeuralForecast's `TimeSeriesDataset`, see [documentation](https://nixtla.github.io/neuralforecast/tsdataset.html).
\n",
- "`val_size`: int, validation size for temporal cross-validation.
\n",
- "`random_seed`: int=None, random_seed for pytorch initializer and numpy generators, overwrites model.__init__'s.
\n",
- "`test_size`: int, test size for temporal cross-validation.
"
- ],
- "text/plain": [
- "---\n",
- "\n",
- "### BiTCN.fit\n",
- "\n",
- "> BiTCN.fit (dataset, val_size=0, test_size=0, random_seed=None)\n",
- "\n",
- "Fit.\n",
- "\n",
- "The `fit` method, optimizes the neural network's weights using the\n",
- "initialization parameters (`learning_rate`, `windows_batch_size`, ...)\n",
- "and the `loss` function as defined during the initialization.\n",
- "Within `fit` we use a PyTorch Lightning `Trainer` that\n",
- "inherits the initialization's `self.trainer_kwargs`, to customize\n",
- "its inputs, see [PL's trainer arguments](https://pytorch-lightning.readthedocs.io/en/stable/api/pytorch_lightning.trainer.trainer.Trainer.html?highlight=trainer).\n",
- "\n",
- "The method is designed to be compatible with SKLearn-like classes\n",
- "and in particular to be compatible with the StatsForecast library.\n",
- "\n",
- "By default the `model` is not saving training checkpoints to protect\n",
- "disk memory, to get them change `enable_checkpointing=True` in `__init__`.\n",
- "\n",
- "**Parameters:**
\n",
- "`dataset`: NeuralForecast's `TimeSeriesDataset`, see [documentation](https://nixtla.github.io/neuralforecast/tsdataset.html).
\n",
- "`val_size`: int, validation size for temporal cross-validation.
\n",
- "`random_seed`: int=None, random_seed for pytorch initializer and numpy generators, overwrites model.__init__'s.
\n",
- "`test_size`: int, test size for temporal cross-validation.
"
- ]
- },
- "execution_count": null,
- "metadata": {},
- "output_type": "execute_result"
- }
- ],
+ "outputs": [],
"source": [
"show_doc(BiTCN.fit, name='BiTCN.fit')"
]
@@ -568,53 +371,7 @@
"cell_type": "code",
"execution_count": null,
"metadata": {},
- "outputs": [
- {
- "data": {
- "text/markdown": [
- "---\n",
- "\n",
- "### BiTCN.predict\n",
- "\n",
- "> BiTCN.predict (dataset, test_size=None, step_size=1, random_seed=None,\n",
- "> **data_module_kwargs)\n",
- "\n",
- "Predict.\n",
- "\n",
- "Neural network prediction with PL's `Trainer` execution of `predict_step`.\n",
- "\n",
- "**Parameters:**
\n",
- "`dataset`: NeuralForecast's `TimeSeriesDataset`, see [documentation](https://nixtla.github.io/neuralforecast/tsdataset.html).
\n",
- "`test_size`: int=None, test size for temporal cross-validation.
\n",
- "`step_size`: int=1, Step size between each window.
\n",
- "`random_seed`: int=None, random_seed for pytorch initializer and numpy generators, overwrites model.__init__'s.
\n",
- "`**data_module_kwargs`: PL's TimeSeriesDataModule args, see [documentation](https://pytorch-lightning.readthedocs.io/en/1.6.1/extensions/datamodules.html#using-a-datamodule)."
- ],
- "text/plain": [
- "---\n",
- "\n",
- "### BiTCN.predict\n",
- "\n",
- "> BiTCN.predict (dataset, test_size=None, step_size=1, random_seed=None,\n",
- "> **data_module_kwargs)\n",
- "\n",
- "Predict.\n",
- "\n",
- "Neural network prediction with PL's `Trainer` execution of `predict_step`.\n",
- "\n",
- "**Parameters:**
\n",
- "`dataset`: NeuralForecast's `TimeSeriesDataset`, see [documentation](https://nixtla.github.io/neuralforecast/tsdataset.html).
\n",
- "`test_size`: int=None, test size for temporal cross-validation.
\n",
- "`step_size`: int=1, Step size between each window.
\n",
- "`random_seed`: int=None, random_seed for pytorch initializer and numpy generators, overwrites model.__init__'s.
\n",
- "`**data_module_kwargs`: PL's TimeSeriesDataModule args, see [documentation](https://pytorch-lightning.readthedocs.io/en/1.6.1/extensions/datamodules.html#using-a-datamodule)."
- ]
- },
- "execution_count": null,
- "metadata": {},
- "output_type": "execute_result"
- }
- ],
+ "outputs": [],
"source": [
"show_doc(BiTCN.predict, name='BiTCN.predict')"
]
@@ -630,225 +387,7 @@
"cell_type": "code",
"execution_count": null,
"metadata": {},
- "outputs": [
- {
- "name": "stderr",
- "output_type": "stream",
- "text": [
- "c:\\Users\\ospra\\miniconda3\\envs\\neuralforecast\\lib\\site-packages\\pytorch_lightning\\utilities\\parsing.py:199: Attribute 'loss' is an instance of `nn.Module` and is already saved during checkpointing. It is recommended to ignore them using `self.save_hyperparameters(ignore=['loss'])`.\n",
- "Seed set to 1\n",
- "GPU available: True (cuda), used: True\n",
- "TPU available: False, using: 0 TPU cores\n",
- "IPU available: False, using: 0 IPUs\n",
- "HPU available: False, using: 0 HPUs\n",
- "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0]\n",
- "\n",
- " | Name | Type | Params\n",
- "------------------------------------------------\n",
- "0 | padder_train | ConstantPad1d | 0 \n",
- "1 | loss | MAE | 0 \n",
- "2 | scaler | TemporalNorm | 0 \n",
- "3 | lin_hist | Linear | 32 \n",
- "4 | drop_hist | Dropout | 0 \n",
- "5 | net_bwd | Sequential | 5.4 K \n",
- "6 | drop_temporal | Dropout | 0 \n",
- "7 | temporal_lin1 | Linear | 400 \n",
- "8 | temporal_lin2 | Linear | 204 \n",
- "9 | output_lin | Linear | 17 \n",
- "------------------------------------------------\n",
- "6.0 K Trainable params\n",
- "0 Non-trainable params\n",
- "6.0 K Total params\n",
- "0.024 Total estimated model params size (MB)\n"
- ]
- },
- {
- "data": {
- "application/vnd.jupyter.widget-view+json": {
- "model_id": "ba6bbbee08ea4f9d8b59147465dac139",
- "version_major": 2,
- "version_minor": 0
- },
- "text/plain": [
- "Sanity Checking: | | 0/? [00:00, ?it/s]"
- ]
- },
- "metadata": {},
- "output_type": "display_data"
- },
- {
- "name": "stderr",
- "output_type": "stream",
- "text": [
- "c:\\Users\\ospra\\miniconda3\\envs\\neuralforecast\\lib\\site-packages\\pytorch_lightning\\trainer\\connectors\\data_connector.py:441: The 'val_dataloader' does not have many workers which may be a bottleneck. Consider increasing the value of the `num_workers` argument` to `num_workers=19` in the `DataLoader` to improve performance.\n",
- "c:\\Users\\ospra\\miniconda3\\envs\\neuralforecast\\lib\\site-packages\\pytorch_lightning\\trainer\\connectors\\data_connector.py:441: The 'train_dataloader' does not have many workers which may be a bottleneck. Consider increasing the value of the `num_workers` argument` to `num_workers=19` in the `DataLoader` to improve performance.\n",
- "c:\\Users\\ospra\\miniconda3\\envs\\neuralforecast\\lib\\site-packages\\pytorch_lightning\\loops\\fit_loop.py:298: The number of training batches (1) is smaller than the logging interval Trainer(log_every_n_steps=50). Set a lower value for log_every_n_steps if you want to see logs for the training epoch.\n"
- ]
- },
- {
- "data": {
- "application/vnd.jupyter.widget-view+json": {
- "model_id": "530227d844044eac885f2c5dfb295e37",
- "version_major": 2,
- "version_minor": 0
- },
- "text/plain": [
- "Training: | | 0/? [00:00, ?it/s]"
- ]
- },
- "metadata": {},
- "output_type": "display_data"
- },
- {
- "data": {
- "application/vnd.jupyter.widget-view+json": {
- "model_id": "7b257595c48c4192b89795985166db1e",
- "version_major": 2,
- "version_minor": 0
- },
- "text/plain": [
- "Validation: | | 0/? [00:00, ?it/s]"
- ]
- },
- "metadata": {},
- "output_type": "display_data"
- },
- {
- "data": {
- "application/vnd.jupyter.widget-view+json": {
- "model_id": "361f62afcd254d228d633ed3556f4b8a",
- "version_major": 2,
- "version_minor": 0
- },
- "text/plain": [
- "Validation: | | 0/? [00:00, ?it/s]"
- ]
- },
- "metadata": {},
- "output_type": "display_data"
- },
- {
- "data": {
- "application/vnd.jupyter.widget-view+json": {
- "model_id": "6b240ed6c52c459c919be50b86949ec8",
- "version_major": 2,
- "version_minor": 0
- },
- "text/plain": [
- "Validation: | | 0/? [00:00, ?it/s]"
- ]
- },
- "metadata": {},
- "output_type": "display_data"
- },
- {
- "data": {
- "application/vnd.jupyter.widget-view+json": {
- "model_id": "2ef55261df704604aec3240e21e27b3a",
- "version_major": 2,
- "version_minor": 0
- },
- "text/plain": [
- "Validation: | | 0/? [00:00, ?it/s]"
- ]
- },
- "metadata": {},
- "output_type": "display_data"
- },
- {
- "data": {
- "application/vnd.jupyter.widget-view+json": {
- "model_id": "19d8692f3ce34303a5293948b5b51ca5",
- "version_major": 2,
- "version_minor": 0
- },
- "text/plain": [
- "Validation: | | 0/? [00:00, ?it/s]"
- ]
- },
- "metadata": {},
- "output_type": "display_data"
- },
- {
- "name": "stderr",
- "output_type": "stream",
- "text": [
- "`Trainer.fit` stopped: `max_steps=500` reached.\n",
- "GPU available: True (cuda), used: True\n",
- "TPU available: False, using: 0 TPU cores\n",
- "IPU available: False, using: 0 IPUs\n",
- "HPU available: False, using: 0 HPUs\n",
- "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0]\n",
- "c:\\Users\\ospra\\miniconda3\\envs\\neuralforecast\\lib\\site-packages\\pytorch_lightning\\trainer\\connectors\\data_connector.py:441: The 'predict_dataloader' does not have many workers which may be a bottleneck. Consider increasing the value of the `num_workers` argument` to `num_workers=19` in the `DataLoader` to improve performance.\n"
- ]
- },
- {
- "data": {
- "application/vnd.jupyter.widget-view+json": {
- "model_id": "cc3f1b4cd5394805b498155000510b22",
- "version_major": 2,
- "version_minor": 0
- },
- "text/plain": [
- "Predicting: | | 0/? [00:00, ?it/s]"
- ]
- },
- "metadata": {},
- "output_type": "display_data"
- },
- {
- "name": "stderr",
- "output_type": "stream",
- "text": [
- "C:\\Users\\ospra\\AppData\\Local\\Temp\\ipykernel_24996\\2950578132.py:16: SettingWithCopyWarning: \n",
- "A value is trying to be set on a copy of a slice from a DataFrame.\n",
- "Try using .loc[row_indexer,col_indexer] = value instead\n",
- "\n",
- "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
- " Y_test_df['BiTCN'] = y_hat\n",
- "GPU available: True (cuda), used: True\n",
- "TPU available: False, using: 0 TPU cores\n",
- "IPU available: False, using: 0 IPUs\n",
- "HPU available: False, using: 0 HPUs\n",
- "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0]\n",
- "c:\\Users\\ospra\\miniconda3\\envs\\neuralforecast\\lib\\site-packages\\pytorch_lightning\\trainer\\connectors\\data_connector.py:441: The 'predict_dataloader' does not have many workers which may be a bottleneck. Consider increasing the value of the `num_workers` argument` to `num_workers=19` in the `DataLoader` to improve performance.\n"
- ]
- },
- {
- "data": {
- "application/vnd.jupyter.widget-view+json": {
- "model_id": "4d3fda82020549bbabdfbd93e0318823",
- "version_major": 2,
- "version_minor": 0
- },
- "text/plain": [
- "Predicting: | | 0/? [00:00, ?it/s]"
- ]
- },
- "metadata": {},
- "output_type": "display_data"
- },
- {
- "data": {
- "text/plain": [
- ""
- ]
- },
- "execution_count": null,
- "metadata": {},
- "output_type": "execute_result"
- },
- {
- "data": {
- "image/png": "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",
- "text/plain": [
- "