reduce default warnings (#974)

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",

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",

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",

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",

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",