Repository: mathLab/PINA (language: python)

Issue:
Forward methods Solvers
**Describe the bug**
I noticed that PINN and Supervised solvers have the following forward pass:

```
def forward(self, x):
    """
    Forward pass implementation for the PINN
    solver.

    :param torch.Tensor x: Input tensor. 
    :return: PINN solution.
    :rtype: torch.Tensor
    """
    # extract labels
    x = x.extract(self.problem.input_variables)
    # perform forward pass
    output = self.neural_net(x).as_subclass(LabelTensor)
    # set the labels
    output.labels = self.problem.output_variables
    return output
```
This forward is problematic, in the sense that `model`s are `torch.nn.Module`, which expect a `torch.Tensor`. Of course a `LabelTensor` is ok, but what if there are internal operations in the `model` which discharge the label? This could result in unwanted behaviour. A possible solution is to overwrite the `Network` class forward, to account also for this problem.

Forward methods Solvers
**Describe the bug**
I noticed that PINN and Supervised solvers have the following forward pass:

```
def forward(self, x):
    """
    Forward pass implementation for the PINN
    solver.

    :param torch.Tensor x: Input tensor. 
    :return: PINN solution.
    :rtype: torch.Tensor
    """
    # extract labels
    x = x.extract(self.problem.input_variables)
    # perform forward pass
    output = self.neural_net(x).as_subclass(LabelTensor)
    # set the labels
    output.labels = self.problem.output_variables
    return output
```
This forward is problematic, in the sense that `model`s are `torch.nn.Module`, which expect a `torch.Tensor`. Of course a `LabelTensor` is ok, but what if there are internal operations in the `model` which discharge the label? This could result in unwanted behaviour. A possible solution is to overwrite the `Network` class forward, to account also for this problem.



Discussion / hints:

Fix patch:
diff --git a/docs/source/_rst/tutorials/tutorial5/tutorial.rst b/docs/source/_rst/tutorials/tutorial5/tutorial.rst
index 4a7c4ebd..e58e9b23 100644
--- a/docs/source/_rst/tutorials/tutorial5/tutorial.rst
+++ b/docs/source/_rst/tutorials/tutorial5/tutorial.rst
@@ -44,8 +44,8 @@ taken from the authors original reference.
     data = io.loadmat("Data_Darcy.mat")
     
     # extract data (we use only 100 data for train)
-    k_train = torch.tensor(data['k_train'], dtype=torch.float).unsqueeze(-1)[:100, ...]
-    u_train = torch.tensor(data['u_train'], dtype=torch.float).unsqueeze(-1)[:100, ...]
+    k_train = torch.tensor(data['k_train'], dtype=torch.float).unsqueeze(-1)
+    u_train = torch.tensor(data['u_train'], dtype=torch.float).unsqueeze(-1)
     k_test = torch.tensor(data['k_test'], dtype=torch.float).unsqueeze(-1)
     u_test= torch.tensor(data['u_test'], dtype=torch.float).unsqueeze(-1)
     x = torch.tensor(data['x'], dtype=torch.float)[0]
@@ -77,7 +77,7 @@ inheriting from ``AbstractProblem``.
         input_variables = ['u_0']
         output_variables = ['u']
         conditions = {'data' : Condition(input_points=LabelTensor(k_train, input_variables), 
-                                         output_points=LabelTensor(u_train, input_variables))}
+                                         output_points=LabelTensor(u_train, output_variables))}
     
     # make problem
     problem = NeuralOperatorSolver()
@@ -99,7 +99,7 @@ training using supervised learning.
     solver = SupervisedSolver(problem=problem, model=model)
     
     # make the trainer and train
-    trainer = Trainer(solver=solver, max_epochs=100, accelerator='cpu', enable_model_summary=False) # we train on CPU and avoid model summary at beginning of training (optional)
+    trainer = Trainer(solver=solver, max_epochs=10, accelerator='cpu', enable_model_summary=False, batch_size=10) # we train on CPU and avoid model summary at beginning of training (optional)
     trainer.train()
 
 
@@ -112,15 +112,18 @@ training using supervised learning.
     HPU available: False, using: 0 HPUs
 
 
+.. parsed-literal::
+
+    Epoch 9: : 100it [00:00, 383.36it/s, v_num=36, mean_loss=0.108]
 
 .. parsed-literal::
 
-    Training: 0it [00:00, ?it/s]
+    `Trainer.fit` stopped: `max_epochs=10` reached.
 
 
 .. parsed-literal::
 
-    `Trainer.fit` stopped: `max_epochs=100` reached.
+    Epoch 9: : 100it [00:00, 380.57it/s, v_num=36, mean_loss=0.108]
 
 
 The final loss is pretty high… We can calculate the error by importing
@@ -143,8 +146,8 @@ The final loss is pretty high… We can calculate the error by importing
 
 .. parsed-literal::
 
-    Final error training 56.24%
-    Final error testing 55.95%
+    Final error training 56.04%
+    Final error testing 56.01%
 
 
 Solving the problem with a Fuorier Neural Operator (FNO)
@@ -170,7 +173,7 @@ operator this approach is better suited, as we shall see.
     solver = SupervisedSolver(problem=problem, model=model)
     
     # make the trainer and train
-    trainer = Trainer(solver=solver, max_epochs=100, accelerator='cpu', enable_model_summary=False) # we train on CPU and avoid model summary at beginning of training (optional)
+    trainer = Trainer(solver=solver, max_epochs=10, accelerator='cpu', enable_model_summary=False, batch_size=10) # we train on CPU and avoid model summary at beginning of training (optional)
     trainer.train()
 
 
@@ -183,15 +186,18 @@ operator this approach is better suited, as we shall see.
     HPU available: False, using: 0 HPUs
 
 
+.. parsed-literal::
+
+    Epoch 9: : 100it [00:04, 22.13it/s, v_num=37, mean_loss=0.000952]
 
 .. parsed-literal::
 
-    Training: 0it [00:00, ?it/s]
+    `Trainer.fit` stopped: `max_epochs=10` reached.
 
 
 .. parsed-literal::
 
-    `Trainer.fit` stopped: `max_epochs=100` reached.
+    Epoch 9: : 100it [00:04, 22.07it/s, v_num=37, mean_loss=0.000952]
 
 
 We can clearly see that the final loss is lower. Let’s see in testing..
@@ -210,8 +216,8 @@ training, when many data samples are used.
 
 .. parsed-literal::
 
-    Final error training 10.86%
-    Final error testing 12.77%
+    Final error training 4.45%
+    Final error testing 4.91%
 
 
 As we can see the loss is way lower!
diff --git a/docs/source/_rst/tutorials/tutorial5/tutorial_files/tutorial_6_0.png b/docs/source/_rst/tutorials/tutorial5/tutorial_files/tutorial_6_0.png
index f62bd0d6..fec83e2c 100644
Binary files a/docs/source/_rst/tutorials/tutorial5/tutorial_files/tutorial_6_0.png and b/docs/source/_rst/tutorials/tutorial5/tutorial_files/tutorial_6_0.png differ
diff --git a/pina/model/network.py b/pina/model/network.py
index f27d5b2c..0f848976 100644
--- a/pina/model/network.py
+++ b/pina/model/network.py
@@ -1,11 +1,12 @@
 import torch
 import torch.nn as nn
 from ..utils import check_consistency
+from ..label_tensor import LabelTensor
 
 
 class Network(torch.nn.Module):
 
-    def __init__(self, model, extra_features=None):
+    def __init__(self, model, input_variables, output_variables, extra_features=None):
         """
         Network class with standard forward method
         and possibility to pass extra features. This
@@ -14,6 +15,10 @@ class is used internally in PINA to convert
     
         :param model: The torch model to convert in a PINA model.
         :type model: torch.nn.Module
+        :param list(str) input_variables: The input variables of the :class:`AbstractProblem`, whose type depends on the
+            type of domain (spatial, temporal, and parameter).
+        :param list(str) output_variables: The output variables of the :class:`AbstractProblem`, whose type depends on the
+            problem setting.
         :param extra_features: List of torch models to augment the input, defaults to None.
         :type extra_features: list(torch.nn.Module)
         """
@@ -21,7 +26,12 @@ class is used internally in PINA to convert
 
         # check model consistency
         check_consistency(model, nn.Module)
+        check_consistency(input_variables, str)
+        check_consistency(output_variables, str)
+
         self._model = model
+        self._input_variables = input_variables
+        self._output_variables = output_variables
 
         # check consistency and assign extra fatures
         if extra_features is None:
@@ -46,14 +56,55 @@ def forward(self, x):
         :param torch.Tensor x: Input of the network.
         :return torch.Tensor: Output of the network.
         """
+        # extract torch.Tensor from corresponding label
+        # in case `input_variables = []` all points are used
+        if self._input_variables:
+            x = x.extract(self._input_variables)
+
         # extract features and append
         for feature in self._extra_features:
             x = x.append(feature(x))
-        # perform forward pass
-        return self._model(x)
+
+        # convert LabelTensor to torch.Tensor
+        x = x.as_subclass(torch.Tensor)
+
+        # perform forward pass (using torch.Tensor) + converting to LabelTensor
+        output = self._model(x).as_subclass(LabelTensor)
+
+        # set the labels for LabelTensor
+        output.labels = self._output_variables
+
+        return output
+
+    def forward_map(self, x):
+        """
+        Forward method for Network class when the input is
+        a tuple. This class implements the standard forward method,
+        and it adds the possibility to pass extra features.
+        All the PINA models ``forward`` s are overriden
+        by this class, to enable :class:`pina.label_tensor.LabelTensor` labels
+        extraction.
+
+        :param list (torch.Tensor) | tuple(torch.Tensor) x: Input of the network.
+        :return torch.Tensor: Output of the network.
+
+        .. note::
+            This function does not extract the input variables, all the variables
+            are used for both tensors. Output variables are correctly applied.
+        """
+        # convert LabelTensor s to torch.Tensor s
+        x = list(map(lambda x: x.as_subclass(torch.Tensor), x))
+
+        # perform forward pass (using torch.Tensor) + converting to LabelTensor
+        output = self._model(x).as_subclass(LabelTensor)
+
+        # set the labels for LabelTensor
+        output.labels = self._output_variables
+
+        return output
 
     @property
-    def model(self):
+    def torchmodel(self):
         return self._model
 
     @property
diff --git a/pina/solvers/garom.py b/pina/solvers/garom.py
index 972f1565..4e41af8c 100644
--- a/pina/solvers/garom.py
+++ b/pina/solvers/garom.py
@@ -32,7 +32,6 @@ def __init__(
         problem,
         generator,
         discriminator,
-        extra_features=None,
         loss=None,
         optimizer_generator=torch.optim.Adam,
         optimizer_generator_kwargs={'lr': 0.001},
@@ -58,13 +57,6 @@ def __init__(
             for the generator.
         :param torch.nn.Module discriminator: The neural network model to use
             for the discriminator.
-        :param torch.nn.Module extra_features: The additional input
-            features to use as augmented input. It should either be a
-            list of torch.nn.Module, or a dictionary. If a list it is 
-            passed the extra features are passed to both network. If a 
-            dictionary is passed, the keys must be ``generator`` and
-            ``discriminator`` and the values a list of torch.nn.Module
-            extra features for each.
         :param torch.nn.Module loss: The loss function used as minimizer,
             default ``None``. If ``loss`` is ``None`` the defualt
             ``PowerLoss(p=1)`` is used, as in the original paper.
@@ -97,15 +89,9 @@ def __init__(
             parameters), and ``output_points``.
         """
 
-        if isinstance(extra_features, dict):
-            extra_features = [
-                extra_features['generator'], extra_features['discriminator']
-            ]
-
         super().__init__(
             models=[generator, discriminator],
             problem=problem,
-            extra_features=extra_features,
             optimizers=[optimizer_generator, optimizer_discriminator],
             optimizers_kwargs=[
                 optimizer_generator_kwargs, optimizer_discriminator_kwargs
@@ -200,7 +186,7 @@ def _train_generator(self, parameters, snapshots):
 
         # generator loss
         r_loss = self._loss(snapshots, generated_snapshots)
-        d_fake = self.discriminator([generated_snapshots, parameters])
+        d_fake = self.discriminator.forward_map([generated_snapshots, parameters])
         g_loss = self._loss(d_fake, generated_snapshots) + self.regularizer * r_loss
 
         # backward step
@@ -220,8 +206,8 @@ def _train_discriminator(self, parameters, snapshots):
         generated_snapshots = self.generator(parameters)
 
         # Discriminator pass
-        d_real = self.discriminator([snapshots, parameters])
-        d_fake = self.discriminator([generated_snapshots, parameters]) 
+        d_real = self.discriminator.forward_map([snapshots, parameters])
+        d_fake = self.discriminator.forward_map([generated_snapshots, parameters]) 
 
         # evaluate loss
         d_loss_real = self._loss(d_real, snapshots)
diff --git a/pina/solvers/pinn.py b/pina/solvers/pinn.py
index 828b36d7..a1581a4a 100644
--- a/pina/solvers/pinn.py
+++ b/pina/solvers/pinn.py
@@ -83,13 +83,7 @@ def forward(self, x):
         :return: PINN solution.
         :rtype: torch.Tensor
         """
-        # extract labels
-        x = x.extract(self.problem.input_variables)
-        # perform forward pass
-        output = self.neural_net(x).as_subclass(LabelTensor)
-        # set the labels
-        output.labels = self.problem.output_variables
-        return output
+        return self.neural_net(x)
 
     def configure_optimizers(self):
         """
diff --git a/pina/solvers/solver.py b/pina/solvers/solver.py
index 698e0882..c0fade5b 100644
--- a/pina/solvers/solver.py
+++ b/pina/solvers/solver.py
@@ -69,7 +69,7 @@ def __init__(self,
                              f' {len_optimizer_kwargs} dicitionaries')
 
         # extra features handling
-        if extra_features is None:
+        if extra_features is None or (len(extra_features)==0):
             extra_features = [None] * len_model
         else:
             # if we only have a list of extra features
@@ -80,7 +80,7 @@ def __init__(self,
                     raise ValueError(
                         'You passed a list of extrafeatures list with len'
                         f'different of models len. Expected {len_model} '
-                        f'got {len(extra_features)}. If you want to use'
+                        f'got {len(extra_features)}. If you want to use '
                         'the same list of extra features for all models, '
                         'just pass a list of extrafeatures and not a list '
                         'of list of extra features.')
@@ -91,6 +91,8 @@ def __init__(self,
 
         for idx in range(len_model):
             model_ = Network(model=models[idx],
+                             input_variables=problem.input_variables,
+                             output_variables=problem.output_variables,
                              extra_features=extra_features[idx])
             optim_ = optimizers[idx](model_.parameters(),
                                      **optimizers_kwargs[idx])
diff --git a/pina/solvers/supervised.py b/pina/solvers/supervised.py
index 2b33405a..c98146b6 100644
--- a/pina/solvers/supervised.py
+++ b/pina/solvers/supervised.py
@@ -72,13 +72,7 @@ def forward(self, x):
         :return: Solver solution.
         :rtype: torch.Tensor
         """
-        # extract labels
-        x = x.extract(self.problem.input_variables)
-        # perform forward pass
-        output = self.neural_net(x).as_subclass(LabelTensor)
-        # set the labels
-        output.labels = self.problem.output_variables
-        return output
+        return self.neural_net(x)
 
     def configure_optimizers(self):
         """Optimizer configuration for the solver.
@@ -99,21 +93,28 @@ def training_step(self, batch, batch_idx):
         :rtype: LabelTensor
         """
 
-        for condition_name, samples in batch.items():
+        dataloader = self.trainer.train_dataloader
+        condition_idx = batch['condition']
+
+        for condition_id in range(condition_idx.min(), condition_idx.max()+1):
+
+            condition_name = dataloader.condition_names[condition_id]
+            condition = self.problem.conditions[condition_name]
+            pts = batch['pts']
+            out = batch['output']
 
             if condition_name not in self.problem.conditions:
                 raise RuntimeError('Something wrong happened.')
 
-            condition = self.problem.conditions[condition_name]
+            # for data driven mode
+            if not hasattr(condition, 'output_points'):
+                raise NotImplementedError('Supervised solver works only in data-driven mode.')
+            
+            output_pts = out[condition_idx == condition_id]
+            input_pts = pts[condition_idx == condition_id]
 
-            # data loss
-            if hasattr(condition, 'output_points'):
-                input_pts, output_pts = samples
-                loss = self.loss(self.forward(input_pts),
-                                 output_pts) * condition.data_weight
-            else:
-                raise RuntimeError(
-                    'Supervised solver works only in data-driven mode.')
+            loss = self.loss(self.forward(input_pts), output_pts) * condition.data_weight
+            loss = loss.as_subclass(torch.Tensor)
 
         self.log('mean_loss', float(loss), prog_bar=True, logger=True)
         return loss
diff --git a/tutorials/tutorial5/tutorial.ipynb b/tutorials/tutorial5/tutorial.ipynb
index e5c79f82..9c4dbebf 100644
--- a/tutorials/tutorial5/tutorial.ipynb
+++ b/tutorials/tutorial5/tutorial.ipynb
@@ -19,7 +19,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 1,
+   "execution_count": 11,
    "id": "5f2744dc",
    "metadata": {},
    "outputs": [],
@@ -54,7 +54,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 17,
+   "execution_count": 12,
    "id": "2ffb8a4c",
    "metadata": {},
    "outputs": [],
@@ -63,8 +63,8 @@
     "data = io.loadmat(\"Data_Darcy.mat\")\n",
     "\n",
     "# extract data (we use only 100 data for train)\n",
-    "k_train = torch.tensor(data['k_train'], dtype=torch.float).unsqueeze(-1)[:100, ...]\n",
-    "u_train = torch.tensor(data['u_train'], dtype=torch.float).unsqueeze(-1)[:100, ...]\n",
+    "k_train = torch.tensor(data['k_train'], dtype=torch.float).unsqueeze(-1)\n",
+    "u_train = torch.tensor(data['u_train'], dtype=torch.float).unsqueeze(-1)\n",
     "k_test = torch.tensor(data['k_test'], dtype=torch.float).unsqueeze(-1)\n",
     "u_test= torch.tensor(data['u_test'], dtype=torch.float).unsqueeze(-1)\n",
     "x = torch.tensor(data['x'], dtype=torch.float)[0]\n",
@@ -81,13 +81,13 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 18,
+   "execution_count": 13,
    "id": "c8501b6f",
    "metadata": {},
    "outputs": [
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 640x480 with 2 Axes>"
       ]
@@ -116,7 +116,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 19,
+   "execution_count": 14,
    "id": "8b27d283",
    "metadata": {},
    "outputs": [],
@@ -125,7 +125,7 @@
     "    input_variables = ['u_0']\n",
     "    output_variables = ['u']\n",
     "    conditions = {'data' : Condition(input_points=LabelTensor(k_train, input_variables), \n",
-    "                                     output_points=LabelTensor(u_train, input_variables))}\n",
+    "                                     output_points=LabelTensor(u_train, output_variables))}\n",
     "\n",
     "# make problem\n",
     "problem = NeuralOperatorSolver()"
@@ -143,7 +143,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 20,
+   "execution_count": 15,
    "id": "e34f18b0",
    "metadata": {},
    "outputs": [
@@ -158,24 +158,24 @@
      ]
     },
     {
-     "data": {
-      "application/vnd.jupyter.widget-view+json": {
-       "model_id": "40f63403b97248a88e49755e8cb096fc",
-       "version_major": 2,
-       "version_minor": 0
-      },
-      "text/plain": [
-       "Training: 0it [00:00, ?it/s]"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 9: : 100it [00:00, 383.36it/s, v_num=36, mean_loss=0.108]"
+     ]
     },
     {
      "name": "stderr",
      "output_type": "stream",
      "text": [
-      "`Trainer.fit` stopped: `max_epochs=100` reached.\n"
+      "`Trainer.fit` stopped: `max_epochs=10` reached.\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 9: : 100it [00:00, 380.57it/s, v_num=36, mean_loss=0.108]\n"
      ]
     }
    ],
@@ -188,7 +188,7 @@
     "solver = SupervisedSolver(problem=problem, model=model)\n",
     "\n",
     "# make the trainer and train\n",
-    "trainer = Trainer(solver=solver, max_epochs=100, accelerator='cpu', enable_model_summary=False) # we train on CPU and avoid model summary at beginning of training (optional)\n",
+    "trainer = Trainer(solver=solver, max_epochs=10, accelerator='cpu', enable_model_summary=False, batch_size=10) # we train on CPU and avoid model summary at beginning of training (optional)\n",
     "trainer.train()\n"
    ]
   },
@@ -202,7 +202,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 21,
+   "execution_count": 16,
    "id": "0e2a6aa4",
    "metadata": {},
    "outputs": [
@@ -210,8 +210,8 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "Final error training 56.24%\n",
-      "Final error testing 55.95%\n"
+      "Final error training 56.04%\n",
+      "Final error testing 56.01%\n"
      ]
     }
    ],
@@ -241,7 +241,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 22,
+   "execution_count": 17,
    "id": "9af523a5",
    "metadata": {},
    "outputs": [
@@ -256,24 +256,24 @@
      ]
     },
     {
-     "data": {
-      "application/vnd.jupyter.widget-view+json": {
-       "model_id": "5328859a5d9344ddb818622fd058d2a5",
-       "version_major": 2,
-       "version_minor": 0
-      },
-      "text/plain": [
-       "Training: 0it [00:00, ?it/s]"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 9: : 100it [00:04, 22.13it/s, v_num=37, mean_loss=0.000952]"
+     ]
     },
     {
      "name": "stderr",
      "output_type": "stream",
      "text": [
-      "`Trainer.fit` stopped: `max_epochs=100` reached.\n"
+      "`Trainer.fit` stopped: `max_epochs=10` reached.\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 9: : 100it [00:04, 22.07it/s, v_num=37, mean_loss=0.000952]\n"
      ]
     }
    ],
@@ -293,7 +293,7 @@
     "solver = SupervisedSolver(problem=problem, model=model)\n",
     "\n",
     "# make the trainer and train\n",
-    "trainer = Trainer(solver=solver, max_epochs=100, accelerator='cpu', enable_model_summary=False) # we train on CPU and avoid model summary at beginning of training (optional)\n",
+    "trainer = Trainer(solver=solver, max_epochs=10, accelerator='cpu', enable_model_summary=False, batch_size=10) # we train on CPU and avoid model summary at beginning of training (optional)\n",
     "trainer.train()\n"
    ]
   },
@@ -307,7 +307,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 23,
+   "execution_count": 18,
    "id": "58e2db89",
    "metadata": {},
    "outputs": [
@@ -315,8 +315,8 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "Final error training 10.86%\n",
-      "Final error testing 12.77%\n"
+      "Final error training 4.45%\n",
+      "Final error testing 4.91%\n"
      ]
     }
    ],
@@ -366,7 +366,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.9.7"
+   "version": "3.9.16"
   }
  },
  "nbformat": 4,
diff --git a/tutorials/tutorial5/tutorial.py b/tutorials/tutorial5/tutorial.py
index 82509d80..5dd94067 100644
--- a/tutorials/tutorial5/tutorial.py
+++ b/tutorials/tutorial5/tutorial.py
@@ -6,7 +6,7 @@
 # In this tutorial we are going to solve the Darcy flow problem in two dimensions, presented in [*Fourier Neural Operator for
 # Parametric Partial Differential Equation*](https://openreview.net/pdf?id=c8P9NQVtmnO). First of all we import the modules needed for the tutorial. Importing `scipy` is needed for input output operations.
 
-# In[1]:
+# In[11]:
 
 
 # !pip install scipy  # install scipy
@@ -32,15 +32,15 @@
 # Specifically, $u$ is the flow pressure, $k$ is the permeability field and $f$ is the forcing function. The Darcy flow can parameterize a variety of systems including flow through porous media, elastic materials and heat conduction. Here you will define the domain as a 2D unit square Dirichlet boundary conditions. The dataset is taken from the authors original reference.
 # 
 
-# In[17]:
+# In[12]:
 
 
 # download the dataset
 data = io.loadmat("Data_Darcy.mat")
 
 # extract data (we use only 100 data for train)
-k_train = torch.tensor(data['k_train'], dtype=torch.float).unsqueeze(-1)[:100, ...]
-u_train = torch.tensor(data['u_train'], dtype=torch.float).unsqueeze(-1)[:100, ...]
+k_train = torch.tensor(data['k_train'], dtype=torch.float).unsqueeze(-1)
+u_train = torch.tensor(data['u_train'], dtype=torch.float).unsqueeze(-1)
 k_test = torch.tensor(data['k_test'], dtype=torch.float).unsqueeze(-1)
 u_test= torch.tensor(data['u_test'], dtype=torch.float).unsqueeze(-1)
 x = torch.tensor(data['x'], dtype=torch.float)[0]
@@ -49,7 +49,7 @@
 
 # Let's visualize some data
 
-# In[18]:
+# In[13]:
 
 
 plt.subplot(1, 2, 1)
@@ -63,14 +63,14 @@
 
 # We now create the neural operator class. It is a very simple class, inheriting from `AbstractProblem`.
 
-# In[19]:
+# In[14]:
 
 
 class NeuralOperatorSolver(AbstractProblem):
     input_variables = ['u_0']
     output_variables = ['u']
     conditions = {'data' : Condition(input_points=LabelTensor(k_train, input_variables), 
-                                     output_points=LabelTensor(u_train, input_variables))}
+                                     output_points=LabelTensor(u_train, output_variables))}
 
 # make problem
 problem = NeuralOperatorSolver()
@@ -80,7 +80,7 @@ class NeuralOperatorSolver(AbstractProblem):
 # 
 # We will first solve the problem using a Feedforward neural network. We will use the `SupervisedSolver` for solving the problem, since we are training using supervised learning.
 
-# In[20]:
+# In[15]:
 
 
 # make model
@@ -91,13 +91,13 @@ class NeuralOperatorSolver(AbstractProblem):
 solver = SupervisedSolver(problem=problem, model=model)
 
 # make the trainer and train
-trainer = Trainer(solver=solver, max_epochs=100, accelerator='cpu', enable_model_summary=False) # we train on CPU and avoid model summary at beginning of training (optional)
+trainer = Trainer(solver=solver, max_epochs=10, accelerator='cpu', enable_model_summary=False, batch_size=10) # we train on CPU and avoid model summary at beginning of training (optional)
 trainer.train()
 
 
 # The final loss is pretty high... We can calculate the error by importing `LpLoss`.
 
-# In[21]:
+# In[16]:
 
 
 from pina.loss import LpLoss
@@ -117,7 +117,7 @@ class NeuralOperatorSolver(AbstractProblem):
 # 
 # We will now move to solve the problem using a FNO. Since we are learning operator this approach is better suited, as we shall see.
 
-# In[22]:
+# In[17]:
 
 
 # make model
@@ -135,13 +135,13 @@ class NeuralOperatorSolver(AbstractProblem):
 solver = SupervisedSolver(problem=problem, model=model)
 
 # make the trainer and train
-trainer = Trainer(solver=solver, max_epochs=100, accelerator='cpu', enable_model_summary=False) # we train on CPU and avoid model summary at beginning of training (optional)
+trainer = Trainer(solver=solver, max_epochs=10, accelerator='cpu', enable_model_summary=False, batch_size=10) # we train on CPU and avoid model summary at beginning of training (optional)
 trainer.train()
 
 
 # We can clearly see that the final loss is lower. Let's see in testing.. Notice that the number of parameters is way higher than a `FeedForward` network. We suggest to use GPU or TPU for a speed up in training, when many data samples are used.
 
-# In[23]:
+# In[18]:
 
 
 err = float(metric_err(u_train.squeeze(-1), solver.models[0](k_train).squeeze(-1)).mean())*100


Test patch:
diff --git a/tests/test_solvers/test_supervised_solver.py b/tests/test_solvers/test_supervised_solver.py
new file mode 100644
index 00000000..dfe0bd86
--- /dev/null
+++ b/tests/test_solvers/test_supervised_solver.py
@@ -0,0 +1,101 @@
+import torch
+
+from pina.problem import AbstractProblem
+from pina import Condition, LabelTensor
+from pina.solvers import SupervisedSolver
+from pina.trainer import Trainer
+from pina.model import FeedForward
+from pina.loss import LpLoss
+
+
+class NeuralOperatorProblem(AbstractProblem):
+    input_variables = ['u_0', 'u_1']
+    output_variables = ['u']
+    conditions = {'data' : Condition(input_points=LabelTensor(torch.rand(100, 2), input_variables), 
+                                     output_points=LabelTensor(torch.rand(100, 1), output_variables))}
+
+class myFeature(torch.nn.Module):
+    """
+    Feature: sin(x)
+    """
+
+    def __init__(self):
+        super(myFeature, self).__init__()
+
+    def forward(self, x):
+        t = (torch.sin(x.extract(['u_0']) * torch.pi) *
+             torch.sin(x.extract(['u_1']) * torch.pi))
+        return LabelTensor(t, ['sin(x)sin(y)'])
+
+
+# make the problem + extra feats
+problem = NeuralOperatorProblem()
+extra_feats = [myFeature()]
+model = FeedForward(len(problem.input_variables),
+                    len(problem.output_variables))
+model_extra_feats = FeedForward(
+    len(problem.input_variables) + 1,
+    len(problem.output_variables))
+
+
+def test_constructor():
+    SupervisedSolver(problem=problem, model=model, extra_features=None)
+
+
+def test_constructor_extra_feats():
+    SupervisedSolver(problem=problem, model=model_extra_feats, extra_features=extra_feats)
+
+
+def test_train_cpu():
+    solver = SupervisedSolver(problem = problem, model=model, extra_features=None, loss=LpLoss())
+    trainer = Trainer(solver=solver, max_epochs=3, accelerator='cpu', batch_size=20)
+    trainer.train()
+
+
+def test_train_restore():
+    tmpdir = "tests/tmp_restore"
+    solver = SupervisedSolver(problem=problem,
+                model=model,
+                extra_features=None,
+                loss=LpLoss())
+    trainer = Trainer(solver=solver,
+                      max_epochs=5,
+                      accelerator='cpu',
+                      default_root_dir=tmpdir)
+    trainer.train()
+    ntrainer = Trainer(solver=solver, max_epochs=15, accelerator='cpu')
+    t = ntrainer.train(
+        ckpt_path=f'{tmpdir}/lightning_logs/version_0/checkpoints/epoch=4-step=5.ckpt')
+    import shutil
+    shutil.rmtree(tmpdir)
+
+
+def test_train_load():
+    tmpdir = "tests/tmp_load"
+    solver = SupervisedSolver(problem=problem,
+                model=model,
+                extra_features=None,
+                loss=LpLoss())
+    trainer = Trainer(solver=solver,
+                      max_epochs=15,
+                      accelerator='cpu',
+                      default_root_dir=tmpdir)
+    trainer.train()
+    new_solver = SupervisedSolver.load_from_checkpoint(
+        f'{tmpdir}/lightning_logs/version_0/checkpoints/epoch=14-step=15.ckpt',
+        problem = problem, model=model)
+    test_pts = LabelTensor(torch.rand(20, 2), problem.input_variables)
+    assert new_solver.forward(test_pts).shape == (20, 1)
+    assert new_solver.forward(test_pts).shape == solver.forward(test_pts).shape
+    torch.testing.assert_close(
+        new_solver.forward(test_pts),
+        solver.forward(test_pts))
+    import shutil
+    shutil.rmtree(tmpdir)
+
+def test_train_extra_feats_cpu():
+    pinn = SupervisedSolver(problem=problem,
+                model=model_extra_feats,
+                extra_features=extra_feats)
+    trainer = Trainer(solver=pinn, max_epochs=5, accelerator='cpu')
+    trainer.train()
\ No newline at end of file