diff --git a/docs/source/_rst/tutorials/tutorial5/tutorial.rst b/docs/source/_rst/tutorials/tutorial5/tutorial.rst index 4a7c4eb..e58e9b2 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 f62bd0d..fec83e2 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/solvers/pinn.py b/pina/solvers/pinn.py index 828b36d..746cae7 100644 --- a/pina/solvers/pinn.py +++ b/pina/solvers/pinn.py @@ -83,11 +83,11 @@ class PINN(SolverInterface): :return: PINN solution. :rtype: torch.Tensor """ - # extract labels - x = x.extract(self.problem.input_variables) - # perform forward pass + # extract torch.Tensor from corresponding label + x = x.extract(self.problem.input_variables).as_subclass(torch.Tensor) + # perform forward pass (using torch.Tensor) + converting to LabelTensor output = self.neural_net(x).as_subclass(LabelTensor) - # set the labels + # set the labels for LabelTensor output.labels = self.problem.output_variables return output diff --git a/pina/solvers/supervised.py b/pina/solvers/supervised.py index 2b33405..fb3df56 100644 --- a/pina/solvers/supervised.py +++ b/pina/solvers/supervised.py @@ -72,11 +72,11 @@ class SupervisedSolver(SolverInterface): :return: Solver solution. :rtype: torch.Tensor """ - # extract labels - x = x.extract(self.problem.input_variables) - # perform forward pass + # extract torch.Tensor from corresponding label + x = x.extract(self.problem.input_variables).as_subclass(torch.Tensor) + # perform forward pass (using torch.Tensor) + converting to LabelTensor output = self.neural_net(x).as_subclass(LabelTensor) - # set the labels + # set the labels for LabelTensor output.labels = self.problem.output_variables return output @@ -99,6 +99,44 @@ class SupervisedSolver(SolverInterface): :rtype: LabelTensor """ + 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.') + + # 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] + + 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 + + + def training_step_(self, batch, batch_idx): + """Solver training step. + + :param batch: The batch element in the dataloader. + :type batch: tuple + :param batch_idx: The batch index. + :type batch_idx: int + :return: The sum of the loss functions. + :rtype: LabelTensor + """ + for condition_name, samples in batch.items(): if condition_name not in self.problem.conditions: diff --git a/tutorials/tutorial5/tutorial.ipynb b/tutorials/tutorial5/tutorial.ipynb index e5c79f8..9c4dbeb 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": [ "
" ] @@ -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 82509d8..5dd9406 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 @@ import matplotlib.pyplot as plt # 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 @@ y = torch.tensor(data['y'], dtype=torch.float)[0] # Let's visualize some data -# In[18]: +# In[13]: plt.subplot(1, 2, 1) @@ -63,14 +63,14 @@ plt.show() # 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 @@ problem = NeuralOperatorSolver() # # 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 @@ model = FeedForward(input_dimensions=1, output_dimensions=1) 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 @@ print(f'Final error testing {err:.2f}%') # # 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 @@ model = FNO(lifting_net=lifting_net, 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