Tensor-driven accelerated framework for hp-variational pinns

Link to Documentation 📚

A robust tensor-based deep learning framework for solving partial differential equations using hp-Variational Physics-Informed Neural Networks (hp-VPINNs). The framework is based on the methodology presented in the FastVPINNs Paper.

This library is a highly optimised version of the the initial implementation of hp-VPINNs by Kharazmi et al.. Refer the hp-VPINNs Paper.

Thivin Anandh, Divij Ghose, Sashikumaar Ganesan

STARS Lab, Department of Computational and Data Sciences, Indian Institute of Science, Bangalore, India

The build of the code is currently tested on Python versions (3.8, 3.9, 3.10, 3.11), on OS Ubuntu 20.04 and Ubuntu 22.04, MacOS-latest and Windows-latest (refer compatibility build Compatability check).

You can install the package using pip as follows:

pip install fastvpinns

On ubuntu systems with libGL issues caused due to matplotlib or gmsh, please run the following command to install the required dependencies:

sudo apt-get install -y libglu1-mesa 

For more information on the installation process, please refer to our documentation here.

If you use this code in your research, please consider citing the following paper:

@misc{anandh2024fastvpinns,
      title={FastVPINNs: Tensor-Driven Acceleration
             of VPINNs for Complex Geometries}, 
      author={Thivin Anandh, Divij Ghose, Himanshu Jain
               and Sashikumaar Ganesan},
      year={2024},
      eprint={2404.12063},
      archivePrefix={arXiv},
      primaryClass={cs.LG}
}

For detailed usage, please refer to our documentation here.

The package provides a simple API to train and solve PDE using VPINNs. The following code snippet demonstrates how to train a hp-VPINN model for the 2D Poisson equation for a structured grid. We could observe that we can solve a PDE using fastvpinns using 15 lines of code.

#load the geometry 
domain = Geometry_2D("quadrilateral", "internal", 100, 100, "./")
cells, boundary_points = domain.generate_quad_mesh_internal(x_limits=[0, 1],y_limits=[0, 1],n_cells_x=4, n_cells_y=4, num_boundary_points=400)

# load the FEspace
fespace = Fespace2D(domain.mesh,cells,boundary_points,domain.mesh_type,fe_order=5,fe_type="jacobi",quad_order=5,quad_type="legendre", fe_transformation_type="bilinear",bound_function_dict=bound_function_dict,bound_condition_dict=bound_condition_dict,
forcing_function=rhs,output_path=i_output_path,generate_mesh_plot=True)

# Instantiate Data handler 
datahandler = DataHandler2D(fespace, domain, dtype=tf.float32)

# Instantiate the model with the loss function for the model 
model = DenseModel(layer_dims=[2, 30, 30, 30, 1],learning_rate_dict=0.01,params_dict=params_dict,
        loss_function=pde_loss_poisson,  ## Loss function of poisson2D
        input_tensors_list=[in_tensor, dir_in, dir_out],
        orig_factor_matrices=[datahandler.shape_val_mat_list,datahandler.grad_x_mat_list, datahandler.grad_y_mat_list],
        force_function_list=datahandler.forcing_function_list, tensor_dtype=tf.float32,
        use_attention=i_use_attention, ## Archived (not in use)
        activation=i_activation,
        hessian=False)

# Train the model
for epoch in range(1000):
    model.train_step()

Note : Supporting functions which define the actual solution and boundary conditions have to be passed to the main code.

This code is currently maintained by the authors as mentioned in the section above. We welcome contributions from the community. Please refer to the documentation for guidelines on contributing to the project.

This project is licensed under the MIT License - see the LICENSE file for details.