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