PhysicsInformedNN Discretizer for PDESystems

PhysicsInformedNN(chain, strategy; init_params = nothing, phi = nothing,
                  param_estim = false, additional_loss = nothing,
                  adaptive_loss = nothing, logger = nothing, log_options = LogOptions(),
                  iteration = nothing, kwargs...)

A discretize algorithm for the ModelingToolkit PDESystem interface, which transforms a PDESystem into an OptimizationProblem using the Physics-Informed Neural Networks (PINN) methodology.

Positional Arguments

• chain: a vector of Lux/Flux chains with a d-dimensional input and a 1-dimensional output corresponding to each of the dependent variables. Note that this specification respects the order of the dependent variables as specified in the PDESystem. Flux chains will be converted to Lux internally using adapt(FromFluxAdaptor(), chain).
• strategy: determines which training strategy will be used. See the Training Strategy documentation for more details.

Keyword Arguments

• init_params: the initial parameters of the neural networks. If init_params is not given, then the neural network default parameters are used. Note that for Lux, the default will convert to Float64.
• phi: a trial solution, specified as phi(x,p) where x is the coordinates vector for the dependent variable and p are the weights of the phi function (generally the weights of the neural network defining phi). By default, this is generated from the chain. This should only be used to more directly impose functional information in the training problem, for example imposing the boundary condition by the test function formulation.
• adaptive_loss: the choice for the adaptive loss function. See the adaptive loss page for more details. Defaults to no adaptivity.
• additional_loss: a function additional_loss(phi, θ, p_) where phi are the neural network trial solutions, θ are the weights of the neural network(s), and p_ are the hyperparameters of the OptimizationProblem. If param_estim = true, then θ additionally contains the parameters of the differential equation appended to the end of the vector.
• param_estim: whether the parameters of the differential equation should be included in the values sent to the additional_loss function. Defaults to false.
• logger: ?? needs docs
• log_options: ?? why is this separate from the logger?
• iteration: used to control the iteration counter???
• kwargs: Extra keyword arguments which are splatted to the OptimizationProblem on solve.

An encoding of the test function phi that is used for calculating the PDE value at domain points x

Fields:

• f: A representation of the chain function.
• st: The state of the Lux.AbstractLuxLayer. It should be updated on each call.

prob = discretize(pde_system::PDESystem, discretization::PhysicsInformedNN)

Transforms a symbolic description of a ModelingToolkit-defined PDESystem and generates an OptimizationProblem for Optimization.jl whose solution is the solution to the PDE.

prob = symbolic_discretize(pde_system::PDESystem, discretization::AbstractPINN)

symbolic_discretize is the lower level interface to discretize for inspecting internals. It transforms a symbolic description of a ModelingToolkit-defined PDESystem into a PINNRepresentation which holds the pieces required to build an OptimizationProblem for Optimization.jl or a Likelihood Function used for HMC based Posterior Sampling Algorithms AdvancedHMC.jl which is later optimized upon to give Solution or the Solution Distribution of the PDE.

For more information, see discretize and PINNRepresentation.

PINNRepresentation`

An internal representation of a physics-informed neural network (PINN). This is the struct used internally and returned for introspection by symbolic_discretize.

Fields

• eqs: The equations of the PDE

• bcs: The boundary condition equations

• domains: The domains for each of the independent variables

• eq_params: ???

• defaults: ???

• default_p: ???

• param_estim: Whether parameters are to be appended to the additional_loss

• additional_loss: The additional_loss function as provided by the user

• adaloss: The adaptive loss function

• depvars: The dependent variables of the system

• indvars: The independent variables of the system

• dict_indvars: A dictionary form of the independent variables. Define the structure ???

• dict_depvars: A dictionary form of the dependent variables. Define the structure ???

• dict_depvar_input: ???

• logger: The logger as provided by the user

• multioutput: Whether there are multiple outputs, i.e. a system of PDEs

• iteration: The iteration counter used inside the cost function

• init_params: The initial parameters as provided by the user. If the PDE is a system of PDEs, this will be an array of arrays. If Lux.jl is used, then this is an array of ComponentArrays.

• flat_init_params: The initial parameters as a flattened array. This is the array that is used in the construction of the OptimizationProblem. If a Lux.jl neural network is used, then this flattened form is a ComponentArray. If the equation is a system of equations, then flat_init_params.depvar.x are the parameters for the neural network corresponding to the dependent variable x, and i.e. if depvar[i] == :x then for phi[i]. If param_estim = true, then flat_init_params.p are the parameters and flat_init_params.depvar.x are the neural network parameters, so flat_init_params.depvar.x would be the parameters of the neural network for the dependent variable x if it's a system.

• phi: The representation of the test function of the PDE solution

• derivative: The function used for computing the derivative

• strategy: The training strategy as provided by the user

• pde_indvars: ???

• bc_indvars: ???

• pde_integration_vars: ???

• bc_integration_vars: ???

• integral: ???

• symbolic_pde_loss_functions: The PDE loss functions as represented in Julia AST

• symbolic_bc_loss_functions: The boundary condition loss functions as represented in Julia AST

• loss_functions: The PINNLossFunctions, i.e. the generated loss functions

PINNLossFunctions`

The generated functions from the PINNRepresentation

Fields

• bc_loss_functions: The boundary condition loss functions

• pde_loss_functions: The PDE loss functions

• full_loss_function: The full loss function, combining the PDE and boundary condition loss functions. This is the loss function that is used by the optimizer.

• additional_loss_function: The wrapped additional_loss, as pieced together for the optimizer.

• datafree_pde_loss_functions: The pre-data version of the PDE loss function

• datafree_bc_loss_functions: The pre-data version of the BC loss function