fix tutorial poisson
This commit is contained in:
Nicola Demo
Binary file not shown.
|
Before Width: | Height: | Size: 20 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 20 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 18 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 31 KiB |
@@ -1,302 +0,0 @@
|
||||
Tutorial 1: resolution of a Poisson problem
|
||||
===========================================
|
||||
|
||||
The problem definition
|
||||
~~~~~~~~~~~~~~~~~~~~~~
|
||||
|
||||
This tutorial presents how to solve with Physics-Informed Neural
|
||||
Networks a 2-D Poisson problem with Dirichlet boundary conditions.
|
||||
|
||||
The problem is written as: :raw-latex:`\begin{equation}
|
||||
\begin{cases}
|
||||
\Delta u = \sin{(\pi x)} \sin{(\pi y)} \text{ in } D, \\
|
||||
u = 0 \text{ on } \Gamma_1 \cup \Gamma_2 \cup \Gamma_3 \cup \Gamma_4,
|
||||
\end{cases}
|
||||
\end{equation}`
|
||||
where :math:`D` is a square domain :math:`[0,1]^2`, and
|
||||
:math:`\Gamma_i`, with :math:`i=1,...,4`, are the boundaries of the
|
||||
square.
|
||||
|
||||
First of all, some useful imports.
|
||||
|
||||
.. code:: ipython3
|
||||
|
||||
import os
|
||||
import numpy as np
|
||||
import argparse
|
||||
import sys
|
||||
import torch
|
||||
from torch.nn import ReLU, Tanh, Softplus
|
||||
from pina.problem import SpatialProblem
|
||||
from pina.operators import nabla
|
||||
from pina.model import FeedForward
|
||||
from pina.adaptive_functions import AdaptiveSin, AdaptiveCos, AdaptiveTanh
|
||||
from pina import Condition, Span, PINN, LabelTensor, Plotter
|
||||
|
||||
Now, the Poisson problem is written in PINA code as a class. The
|
||||
equations are written as *conditions* that should be satisfied in the
|
||||
corresponding domains. *truth_solution* is the exact solution which will
|
||||
be compared with the predicted one.
|
||||
|
||||
.. code:: ipython3
|
||||
|
||||
class Poisson(SpatialProblem):
|
||||
spatial_variables = ['x', 'y']
|
||||
bounds_x = [0, 1]
|
||||
bounds_y = [0, 1]
|
||||
output_variables = ['u']
|
||||
domain = Span({'x': bounds_x, 'y': bounds_y})
|
||||
|
||||
def laplace_equation(input_, output_):
|
||||
force_term = (torch.sin(input_['x']*torch.pi) *
|
||||
torch.sin(input_['y']*torch.pi))
|
||||
return nabla(output_['u'], input_).flatten() - force_term
|
||||
|
||||
def nil_dirichlet(input_, output_):
|
||||
value = 0.0
|
||||
return output_['u'] - value
|
||||
|
||||
conditions = {
|
||||
'gamma1': Condition(
|
||||
Span({'x': bounds_x, 'y': bounds_y[-1]}), nil_dirichlet),
|
||||
'gamma2': Condition(
|
||||
Span({'x': bounds_x, 'y': bounds_y[0]}), nil_dirichlet),
|
||||
'gamma3': Condition(
|
||||
Span({'x': bounds_x[-1], 'y': bounds_y}), nil_dirichlet),
|
||||
'gamma4': Condition(
|
||||
Span({'x': bounds_x[0], 'y': bounds_y}), nil_dirichlet),
|
||||
'D': Condition(
|
||||
Span({'x': bounds_x, 'y': bounds_y}), laplace_equation),
|
||||
}
|
||||
def poisson_sol(self, x, y):
|
||||
return -(np.sin(x*np.pi)*np.sin(y*np.pi))/(2*np.pi**2)
|
||||
|
||||
truth_solution = poisson_sol
|
||||
|
||||
The problem solution
|
||||
~~~~~~~~~~~~~~~~~~~~
|
||||
|
||||
Then, a feed-forward neural network is defined, through the class
|
||||
*FeedForward*. A 2-D grid is instantiated inside the square domain and
|
||||
on the boundaries. This neural network takes as input the coordinates of
|
||||
the points which compose the grid and gives as output the solution of
|
||||
the Poisson problem. The residual of the equations are evaluated at each
|
||||
point of the grid and the loss minimized by the neural network is the
|
||||
sum of the residuals. In this tutorial, the neural network is composed
|
||||
by two hidden layers of 10 neurons each, and it is trained for 5000
|
||||
epochs with a learning rate of 0.003. These parameters can be modified
|
||||
as desired. The output of the cell below is the final loss of the
|
||||
training phase of the PINN.
|
||||
|
||||
.. code:: ipython3
|
||||
|
||||
poisson_problem = Poisson()
|
||||
|
||||
model = FeedForward(layers=[10, 10],
|
||||
output_variables=poisson_problem.output_variables,
|
||||
input_variables=poisson_problem.input_variables)
|
||||
|
||||
pinn = PINN(poisson_problem, model, lr=0.003, regularizer=1e-8)
|
||||
pinn.span_pts(20, 'grid', locations=['gamma1', 'gamma2', 'gamma3', 'gamma4'])
|
||||
pinn.span_pts(20, 'grid', locations=['D'])
|
||||
pinn.train(5000, 100)
|
||||
|
||||
|
||||
|
||||
|
||||
The loss trend is saved in a dedicated txt file located in
|
||||
*tutorial1_files*.
|
||||
|
||||
.. code:: ipython3
|
||||
|
||||
os.mkdir('tutorial1_files')
|
||||
with open('tutorial1_files/poisson_history.txt', 'w') as file_:
|
||||
for i, losses in enumerate(pinn.history):
|
||||
file_.write('{} {}\n'.format(i, sum(losses)))
|
||||
pinn.save_state('tutorial1_files/pina.poisson')
|
||||
|
||||
Now the *Plotter* class is used to plot the results. The solution
|
||||
predicted by the neural network is plotted on the left, the exact one is
|
||||
represented at the center and on the right the error between the exact
|
||||
and the predicted solutions is showed.
|
||||
|
||||
.. code:: ipython3
|
||||
|
||||
plotter = Plotter()
|
||||
plotter.plot(pinn)
|
||||
|
||||
|
||||
|
||||
.. image:: output_13_0.png
|
||||
|
||||
|
||||
The problem solution with extra-features
|
||||
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
||||
|
||||
Now, the same problem is solved in a different way. A new neural network
|
||||
is now defined, with an additional input variable, named extra-feature,
|
||||
which coincides with the forcing term in the Laplace equation. The set
|
||||
of input variables to the neural network is:
|
||||
|
||||
:raw-latex:`\begin{equation}
|
||||
[\mathbf{x}, \mathbf{y}, \mathbf{k}(\mathbf{x}, \mathbf{y})], \text{ with } \mathbf{k}(\mathbf{x}, \mathbf{y})=\sin{(\pi \mathbf{x})}\sin{(\pi \mathbf{y})},
|
||||
\end{equation}`
|
||||
|
||||
where :math:`\mathbf{x}` and :math:`\mathbf{y}` are the coordinates of
|
||||
the points of the grid and :math:`\mathbf{k}(\mathbf{x}, \mathbf{y})` is
|
||||
the forcing term evaluated at the grid points.
|
||||
|
||||
This forcing term is initialized in the class *myFeature*, the output of
|
||||
the cell below is also in this case the final loss of PINN.
|
||||
|
||||
.. code:: ipython3
|
||||
|
||||
poisson_problem = Poisson()
|
||||
|
||||
class myFeature(torch.nn.Module):
|
||||
"""
|
||||
"""
|
||||
def __init__(self):
|
||||
super(myFeature, self).__init__()
|
||||
|
||||
def forward(self, x):
|
||||
return LabelTensor(torch.sin(x.extract(['x'])*torch.pi) *
|
||||
torch.sin(x.extract(['y'])*torch.pi), 'k')
|
||||
|
||||
feat = [myFeature()]
|
||||
model_feat = FeedForward(layers=[10, 10],
|
||||
output_variables=poisson_problem.output_variables,
|
||||
input_variables=poisson_problem.input_variables,
|
||||
extra_features=feat)
|
||||
|
||||
pinn_feat = PINN(poisson_problem, model_feat, lr=0.003, regularizer=1e-8)
|
||||
pinn_feat.span_pts(20, 'grid', locations=['gamma1', 'gamma2', 'gamma3', 'gamma4'])
|
||||
pinn.feat_span_pts(20, 'grid', locations=['D'])
|
||||
pinn_feat.train(5000, 100)
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
The losses are saved in a txt file as for the basic Poisson case.
|
||||
|
||||
.. code:: ipython3
|
||||
|
||||
with open('tutorial1_files/poisson_history_feat.txt', 'w') as file_:
|
||||
for i, losses in enumerate(pinn_feat.history):
|
||||
file_.write('{} {}\n'.format(i, sum(losses)))
|
||||
pinn_feat.save_state('tutorial1_files/pina.poisson_feat')
|
||||
|
||||
The predicted and exact solutions and the error between them are
|
||||
represented below.
|
||||
|
||||
.. code:: ipython3
|
||||
|
||||
plotter_feat = Plotter()
|
||||
plotter_feat.plot(pinn_feat)
|
||||
|
||||
|
||||
|
||||
.. image:: output_20_0.png
|
||||
|
||||
|
||||
The problem solution with learnable extra-features
|
||||
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
||||
|
||||
Another way to predict the solution is to add a parametric extra-feature.
|
||||
The parameters added in the
|
||||
expression of the extra-feature are learned during the training phase of
|
||||
the neural network. For example, considering two parameters, the
|
||||
parameteric extra-feature is written as:
|
||||
|
||||
:raw-latex:`\begin{equation}
|
||||
\mathbf{k}(\mathbf{x}, \mathbf{y}) = \beta \sin{(\alpha \mathbf{x})} \sin{(\alpha \mathbf{y})}
|
||||
\end{equation}`
|
||||
|
||||
Here, as done for the other cases, the new parametric feature is defined
|
||||
and the neural network is re-initialized and trained.
|
||||
|
||||
.. code:: ipython3
|
||||
|
||||
class LearnableFeature(torch.nn.Module):
|
||||
"""
|
||||
"""
|
||||
def __init__(self):
|
||||
super(myFeature, self).__init__()
|
||||
self.beta = torch.nn.Parameter(torch.Tensor([1.0]))
|
||||
self.alpha = torch.nn.Parameter(torch.Tensor([1.0]))
|
||||
|
||||
def forward(self, x):
|
||||
return LabelTensor(
|
||||
self.beta*torch.sin(self.alpha*x.extract(['x'])*torch.pi)*
|
||||
torch.sin(self.alpha*x.extract(['y'])*torch.pi),
|
||||
'k')
|
||||
|
||||
feat = [LearnableFeature()]
|
||||
model_learn = FeedForward(layers=[10, 10],
|
||||
output_variables=param_poisson_problem.output_variables,
|
||||
input_variables=param_poisson_problem.input_variables,
|
||||
extra_features=feat)
|
||||
|
||||
pinn_learn = PINN(poisson_problem, model_feat, lr=0.003, regularizer=1e-8)
|
||||
pinn_learn.span_pts(20, 'grid', ['D'])
|
||||
pinn_learn.span_pts(20, 'grid', ['gamma1', 'gamma2', 'gamma3', 'gamma4'])
|
||||
pinn_learn.train(5000, 100)
|
||||
|
||||
|
||||
|
||||
|
||||
The losses are saved as for the other two cases trained above.
|
||||
|
||||
.. code:: ipython3
|
||||
|
||||
with open('tutorial1_files/poisson_history_learn_feat.txt', 'w') as file_:
|
||||
for i, losses in enumerate(pinn_learn.history):
|
||||
file_.write('{} {}\n'.format(i, sum(losses)))
|
||||
pinn_learn.save_state('tutorial1_files/pina.poisson_learn_feat')
|
||||
|
||||
Here the plots for the prediction error (below on the right) shows that
|
||||
the prediction coming from the latter version is more accurate than
|
||||
the one of the basic version of PINN.
|
||||
|
||||
.. code:: ipython3
|
||||
|
||||
plotter_learn = Plotter()
|
||||
plotter_learn.plot(pinn_learn)
|
||||
|
||||
|
||||
|
||||
.. image:: output_29_0.png
|
||||
|
||||
|
||||
Now the files containing the loss trends for the three cases are read.
|
||||
The loss histories are compared; we can see that the loss decreases
|
||||
faster in the cases of PINN with extra-feature.
|
||||
|
||||
.. code:: ipython3
|
||||
|
||||
import pandas as pd
|
||||
|
||||
df = pd.read_csv("tutorial1_files/poisson_history.txt", sep=" ", header=None)
|
||||
epochs = df[0]
|
||||
poisson_data = epochs.to_numpy()*100
|
||||
basic = df[1].to_numpy()
|
||||
|
||||
df_feat = pd.read_csv("tutorial1_files/poisson_history_feat.txt", sep=" ", header=None)
|
||||
feat = df_feat[1].to_numpy()
|
||||
|
||||
df_learn = pd.read_csv("tutorial1_files/poisson_history_learn_feat.txt", sep=" ", header=None)
|
||||
learn_feat = df_learn[1].to_numpy()
|
||||
|
||||
import matplotlib.pyplot as plt
|
||||
plt.semilogy(epochs, basic, label='Basic PINN')
|
||||
plt.semilogy(epochs, feat, label='PINN with extra-feature')
|
||||
plt.semilogy(epochs, learn_feat, label='PINN with learnable extra-feature')
|
||||
plt.legend()
|
||||
plt.grid()
|
||||
plt.show()
|
||||
|
||||
|
||||
|
||||
.. image:: output_31_0.png
|
||||
|
||||
Reference in New Issue
Block a user