Introduction to Physics-Informed Machine Learning

with Modulus
1
 Agenda
• What is Modulus?

• Modulus Architecture, Training

• Physics informed neural networks in Modulus

• Data informed neural networks in Modulus

• Modulus other features and advancements

2
 Saturating Performance in Traditional HPC
Simulations are getting larger and more complex

Traditional solution methods are:

• Computationally Expensive
• Plagued by Domain Discretization Techniques
• Not suitable for Data-assimilation or Inverse problems

3
 NVIDIA Modulus

NVIDIA Modulus is a neural network framework that blends

the power of physics in form of governing partial differential
equations (PDEs) with data to build high-fidelity,
parameterized surrogate models with near-real-time latency. It
offers:
• AI Toolkit
• Offers building blocks for developing physics-ML surrogate
models
• Scalable Performance Wind Farm Super Resolution FPGA Heatsink Design
Optimization
• Solves larger problems faster by scaling from single GPU to
multi-node implementation
• Near-Real-Time Inference
• Provides parameterized system representation that solves for
multiple scenarios in near real time, trains once offline to infer
in real time repeatedly
• Easy Adoptability
• Includes APIs for domain experts to work at a higher level of
abstraction. Extensible to new applications with reference
applications serving as starting points
Extreme Weather Industrial Digital Twin
Prediction

4
 What is Modulus?
Modulus is a PDE solver

• Like traditional solvers such as Finite Element, Finite Difference, Finite Volume, and Spectral solvers, Modulus can solve PDEs

A comparison between Modulus and commercial solver results for a bracket deflection example. Linear elasticity equations are solved here.

5
 What is Modulus?
Modulus is a tool for efficient design optimization for multi-physics problems

• With Modulus, professionals in Manufacturing and Product Development can explore different configurations and scenarios of a model,
in near-real-time by changing its parameters, allowing them to gain deeper insights about the system or product, and to perform efficient
design optimization of their products.

Efficient design space exploration of the heatsink of a Field-Programmable Gate Array (FPGA) using Modulus.

6
 What is Modulus?
Modulus is a solver for inverse problems

• Many applications in science and engineering involve inferring unknown system characteristics given measured data from sensors or
imaging.
• By combining data and physics, Modulus can effectively solve inverse problems.

(Modulus) (Modulus) (Modulus) (Modulus)

A comparison between Modulus and OpenFOAM results for the flow velocity, pressure and passive scalar concentration fields. Modulus has inferred the velocity and
pressure fields using scattered data from passive scalar concentration.
7
 What is Modulus?
Modulus is a tool for developing digital twins

• A digital twin is a virtual representation (a true-to-reality simulation of physics) of a real-world physical asset or system, which is
continuously updated via stream of data.
• Digital twin predicts the future state of the real-world system under varying conditions.

Virtual representation

Future state realizations

8
 What is Modulus?
Modulus is a tool for developing data-driven solutions to engineering problems

• Modulus contains a variety of APIs for developing data-driven machine learning solutions to challenging engineering systems, including:
• Data-driven modeling of physical systems
• Super resolution of low-fidelity results computed by traditional solvers

Super-resolution of flow in a wind farm using Modulus

9
 What is Modulus?
Putting it all together

• Modulus is a PDE solver (category I)

• Modulus is a tool for efficient design optimization & design space exploration (category I)
• Modulus is a solver for inverse problems (category II)
• Modulus is a tool for developing digital twins (category II)
• Modulus is a tool for developing AI solutions to engineering problems (category III)
These are all done by developing deep neural network models in Modulus that are physics-informed and/or data-informed.

Category I Category II Category III

10
Modulus Architecture

11
 Modulus Training

• Modulus allows for complex problems to be described through

sets of constraints (training objectives)
• Multiple nodes/models can be combined in constraints for
learning different data-driven or physics-driven loss functions
• Exporting results of the trained model to visualization software
is then effortless with Modulus

12
 Physics Informed Neural Networks (PINNs) in Modulus
A problem with NNs and the promise of PINNs

Data Only Data + Physics Physics only

2 2
𝛿 𝑢( ) 𝛿 𝑢( )
2
𝑥 =1 2
𝑥 =1 𝑢 ( 0 )=𝑢 ( 1 )= 0
𝛿𝑥 𝛿𝑥

∑ ( )
2 2
𝐿𝑑𝑎𝑡𝑎 =
2
(𝑢𝑛𝑒𝑡 ( 𝑥 𝑖 ) −𝑢 𝑡𝑟𝑢𝑒 ( 𝑥𝑖 ) ) 𝛿 𝑢𝑛𝑒𝑡
𝑥 𝑖 ∈𝑑𝑎𝑡𝑎
𝐿𝑝h𝑦𝑠𝑖𝑐𝑠= ∑ 𝛿𝑥
2 ( 𝑥 𝑖 ) − 𝑓 ( 𝑥𝑖 ) 𝐿 𝑝h𝑦𝑠𝑖𝑐𝑠 = 𝐿 𝑟𝑒𝑠𝑖𝑑𝑢𝑎𝑙 + 𝐿 𝐵𝐶
𝑥 𝑗 ∈𝑑𝑜𝑚𝑎𝑖𝑛

𝐿 𝑡𝑜𝑡𝑎𝑙 = 𝐿 𝑑𝑎𝑡𝑎 + 𝐿 𝑡𝑜𝑡𝑎𝑙 = 𝐿𝑝h𝑦𝑠𝑖𝑐𝑠

13
 PINNs Theory: Neural Network Solver
Problem description

• Goal: Train a neural network to satisfy the boundary conditions and differential equations by constructing an appropriate loss function
• Consider an example problem:

• We construct a neural network which has a single value input and single value output .
• We assume the neural network is infinitely differentiable - Use activation functions that are infinitely differentiable

14
 PINNs Theory: Neural Network Solver
Loss formulation

• Construct the loss function. We can compute the second order derivatives using Automatic differentiation

• Where are a batch of points in the interior . Total loss becomes

• Minimize the loss using optimizers like Adam

15
 PINNs Theory: Neural Network Solver
Results

• For , the true solution is . After sufficient training we have,

Comparison of the solution predicted by Neural Network with the

analytical solution

16
Modulus: Anatomy of a project
Overview

Modulus works by:

• Writing models which include at least one
adaptable function (a NN)
• Writing objective functions as a combination of
these models
• Describing the geometry/dataset where the
models should be evaluated
• Minimizing the objective functions by using the
provided data, by sampling the geometry, or both
• Running the models to obtain the desired effect

17
Modulus: Anatomy of a project
Load Hydra

defaults :
- modulus_default
- scheduler: tf_exponential_lr
- optimizer: adam
- loss: sum
- _self_

scheduler:
decay_rate: 0.95
decay_steps: 200

save_filetypes : "vtk,npz"

training:
rec_results_freq : 1000
rec_constraint_freq: 1000
max_steps : 5000

18
Modulus: Anatomy of a project
Create geometry, domain and nodes

@modulus.main(config_path="conf",
config_name="config")
def run(cfg: ModulusConfig) -> None:

# make geometry
x = Symbol("x")
geo = Line1D(0, 1)

# make list of nodes to unroll graph on

eq = CustomPDE(f=1.0)
u_net = FullyConnectedArch(
input_keys=[Key("x")],
output_keys=[Key("u")],
nr_layers=3,
layer_size=32
)

nodes = (eq.make_nodes() +
[u_net.make_node(name="u_network")])

# make domain
domain = Domain()

19
Modulus: Anatomy of a project
Add constraints

# add constraints to solver

# bcs
bc = PointwiseBoundaryConstraint(
nodes=nodes,
geometry=geo,
outvar={"u": 0},
batch_size=2,
)
domain.add_constraint(bc, "bc")

# interior
interior = PointwiseInteriorConstraint(
nodes=nodes,
geometry=geo,
outvar={"custom_pde": 0},
batch_size=100,
bounds={x: (0, 1)},
)
domain.add_constraint(interior, "interior")

20
 Modulus: Anatomy of a project
Create utils to visualize the results and run the solver

# add inferencer
x_np = np.linspace(0, 1.0, 100).reshape(-1,1)
inference = PointwiseInferencer(
nodes=nodes,
invar={"x": x_np},
output_names=["u"],
)
domain.add_inferencer(inference, "inf_data")

# make solver
slv = Solver(cfg, domain)

# start solver
slv.solve()

if __name__ == "__main__":
run()

python <script_name>.py
mpirun –np <#GPU> <script_name>.py

21
Accessing the supplemental material
DLI Interface and JupyterLab

• Navigate to the course website and begin the

course
• At the bottom of the presentation, you will find a
Start button which you can use to launch the
interactive environment
• The environment may take a few minutes to get
started. Once started click the Launch button

• You can now use this environment to run the

examples provided on GPU
• Feel free to make any modifications to the
examples and see how the training performs

22
 Solving Parameterized Problems
Problem definition

• Consider the parameterized version of the same problem as before. Suppose we want to determine how the solution changes as we move
the position on the boundary condition
• Parameterize the position by variable and the problem now becomes:

• This time, we construct a neural network which has and as input and single value output .
• The losses become

23
 Solving Parameterized Problems
Results

• For , for different values of we have different solutions

Solution to the parametric problem

24
 Solving Inverse Problems
Problem definition

• For inverse problems, we start with a set of observations and then calculate the causal factors that produced them
• For example, suppose we are given the solution at 100 random points between 0 and 1 and we want to determine the that is causing it
• Train two networks and to approximate and

25
 Solving Inverse Problems
Results

• For the solution for is

Comparison of 𝑢_𝑛𝑒𝑡 (𝑥) and train points from 𝑢_𝑡𝑟𝑢𝑒 Comparison of the true solution for and the inverted out

26
 Solution to 1D diffusion
Problem description

• Composite bar with material of conductivity for and for . Points A and C are maintained at temperatures of and respectively
• Equations: Diffusion equation in

When
When

• Flux and field continuity at interface ( 𝑥=1)

27
Solution to 1D diffusion
Code snippets – Custom symbolic PDE

Create a child class from Modulus’ PDE

class

Add the __init__() function to

define any PDE specific arguments

Symbolic input variables using sympy’s

Symbol

Dependent variables defined using

sympy’s Function

Any additional terms that potentially

need to be parameterized can also be
specified as dependent variables

Symbolic PDE. Derivatives are

computed using sympy’s functions
𝑇 𝑡 =∇ ⋅ ( 𝐷 ∇ 𝑇 ) +𝑄
28
Solution to 1D diffusion
Code snippets
Loading hydra configs

Sample the boundary of

geometry

Equation and neural

network nodes

Criteria for sub-sampling

Sample the interior of

geometry

Domain and Constraints

29
Solution to 1D diffusion
Code snippets

Validators to compare with

experimental/analytical
/solver data

Tensorboard visualization of loss curves

Monitor the quantities of

interest during the runtime

Solver
Results generated from numpy output

30
 Parameterized Solution to 1D diffusion
Problem description and code snippets

• Composite bar with material of conductivity for and for .

• Solve the problem for multiple values of in the range in a single training
• Same boundary and interface conditions as before

Symbolically parameterize the

variables of choice
(geometric/physical) and setup
the architecture

Specify the appropriate

parameterization to the
constraints
Validation error for

Fairly simple changes to go from single forward simulation to parameterized simulation

31
 Solution to ODEs – Coupled Spring Mass System
Problem description

• Three masses connected by four springs

• System’s equations (ordinary differential equations):

• For given values masses, spring constants and boundary conditions

32
 Solution to ODEs – Coupled Spring Mass System
Code snippets

Nodes for a simple

transient problem using
continuous time approach

Under continuous time

approach, time can be
modeled as any other
parametrized variable

Validation error for each mass

Simple transient problem using continuous time approach. Advanced approaches like moving-time- 33
window etc. also available for more complex problems.
 Inverse Problem – Coupled Spring Mass System
Problem description

• For the same system, assume we know the analytical solution which is given by:

• With the above data and the values for same as before, use the neural network to find the values of and

34
Inverse Problem – Coupled Spring Mass System
Code snippets

Assimilate the data

using
PointwiseConstraint

Monitors to infer the

Analytical data
inverted quantities

Additional network
to invert out the
unknowns

Results 35
 Data-driven analysis – Surrogate Model for Darcy Flow
Problem description

• Use Fourier Neural Operator (FNO) and its variants to develop a surrogate model that learns a mapping between a permeability field and
pressure field, , for a distribution of permeability fields .
• The Darcy PDE is a second order, elliptical PDE with the following form:

• Where is the flow pressure, is the permeability field and is the forcing function.
• The Darcy flow can parameterize a variety of systems including flow through porous media, elastic materials and heat conduction.
• Here, we will define the domain as a 2D unit square with the boundary condition , .
• Both the permeability and flow fields are discretized into a 2D matrix .

36
 Darcy Flow – Fourier Neural Operators (FNO)
Theory

• FNO can be used to parameterize solutions for a distribution of PDE solutions. The key feature of FNO is the spectral convolutions:
operations that place the integral kernel in Fourier space:​

• is the transformation containing the learnable parameters . This operator is calculated over the entire structured Euclidean domain . Fast
Fourier Transform (FFT) is used to perform the Fourier transforms efficiently and the resulting transformation is a finite size matrix of
learnable weights. ​
• In spectral convolution, the Fourier coefficients are truncated to only the lower modes which allows explicit control over the
dimensionality of the spectral space and linear operator.​
• The FNO model is a composition of a fully-connected “lifting” layer, spectral convolutions with point-wise linear skip connections and a
decoding point-wise fully-connected neural network at the end:​

• Here, is the spectral convolution layer with the point-wise linear transform and activation function . is the point-wise lifting network
that projects the input into a higher dimensional latent space. Q is the point-wise fully-connected decoding network. ​
• Since all fully-connected components of FNO are point-wise operations, the model is invariant to the dimensionality of the input. ​

Source: Li et al., 2010.08895.pdf (arxiv.org)

37
Darcy Flow – Fourier Neural Operators (FNO)
Code Snippets

Lazy data loading (in

addition to eager
loading) available for
large datasets

Instantiate the FNO

model. Network
parameters handled in
configs.
Hydra configs for the Darcy FNO problem
38
Darcy Flow – Fourier Neural Operators (FNO)
Code Snippets

• Note
• The constraint will construct the data loader
automatically.
• Modulus constraints can instantly be scaled to
multi-node/multi-GPU training.
• Optimizations such as torch script/CUDA graphs
will be performed under-the-hood.
Supervised grid constraints
• Batch size is controlled in the Hydra configuration
file.
• These are the two core components of setting up
basic data-driven problem in Modulus.

Grid Validators

39
Darcy Flow – Fourier Neural Operators (FNO)
Results and discussion

FNO accurately learns the solution of this

system.

Modulus supports the visualization of results

through images (matplotlib), Tensorboard,
VTK files and Omniverse for select problems.

For more information, please refer to the

official Modulus user guide example.

40
 Darcy Flow – Adaptive Fourier Neural Operators (AFNO)
Theory

• AFNO combines the Fourier Neural Operator (FNO) with the powerful Vision Transformer (ViT) model for image processing. The ViT
and related variants of transformer models have achieved SOTA performance in image processing tasks. The multi-head self-attention
(MHSA) mechanism of the ViT is key to its impressive performance. ​
• The first step in the architecture involves dividing the input image into a regular grid with equal sized patches of size . The parameter is
referred to as the patch size. For simplicity, we consider a single channel image. Each patch is embedded into a token of size d, the
embedding dimension. The patch embedding operation results in a token tensor of size . The patch size and embedding dimension are
user selected parameters. A smaller patch size allows the model to capture fine scale details better while increasing the computational cost
of training the model. A higher embedding dimension also increases the parameter count of the model. The token tensor is then processed
by multiple layers of the transformer architecture performing spatial and channel mixing. The AFNO architecture implements the
following operations in each layer.​
• The token tensor is first transformed to the Fourier domain with​

• Here, is the index the patch location and DFT denotes a 2D discrete Fourier transform. ​

41
Darcy Flow – Adaptive Fourier Neural Operators (AFNO)
Code Snippets

Lazy loading like FNO

example

Crop the data to make

divisible by patch size
Constraints and Validators same as FNO example.
Without any changes to the core constraint/validator, experiment with different
architectures with ease 42
Darcy Flow – Adaptive Fourier Neural Operators (AFNO)
Results and discussion

AFNO accurately learns the solution of this

system.

For more information, please refer to the

official Modulus user guide example.

AFNO is the key backboard for NVIDIA’s

groundbreaking FourCastNet:

43
 Darcy Flow – Physics Informed Neural Operators (PINO)
Theory

• PINO incorporates a PDE loss to the Fourier Neural Operator. This improves interpretability and reduces the amount of data required to
train a surrogate model, since the PDE loss constrains the solution space. ​
• In general, the PDE loss involves computing the PDE operator which in turn involves computing the partial derivatives of the Fourier
Neural Operator ansatz, which is nontrivial. The key set of innovations in the PINO are the various ways to compute the partial
derivatives of the operator ansatz. The PINO framework implements the differentiation in three different ways.​
• Numerical differentiation using a finite difference Method (FDM).​
• Numerical differentiation computed via spectral derivative.​
• Hybrid differentiation based on a combination of first-order “exact” and second-order FDM derivatives.​

44
 Darcy Flow – Physics Informed Neural Operators (PINO)
Code snippets

• Setting up a PINO problem in Modulus requires setting up a custom PDE loss that can compute on grid data. Readers are referred to the
supplemental Jupyter notebooks for the code snippets for the Loss definition.

Load additional gradients for

the loss calculation

Additional nodes
for physics loss

Loss for physics constraint

45
 Darcy Flow – Physics Informed Neural Operators (PINO)
Code snippets and results and discussion

Results. Left: Inputs to the model (Input permeability and its gradients), Right: Model
prediction and its comparison with true solution

Constraints and Validators same as FNO example.

Without any changes to the core constraint/validator, experiment with
different architectures with ease
Benefit of PINO is seen in “small data” regimes where the PDE loss regularizes the model giving better
prediction than FNO when trained with only 100 samples. 46
 Neural Operators in Modulus
Conclusions

• Modulus supports several neural operators (also includes the famous DeepONets) that can easily be used out of the box.
• Modulus uses Hydra configuration for easily adjusting hyperparameters and even changing model architectures with minimal changes to
Python code.
• Data-driven training can quickly be integrated into the Modulus framework.
• For more information on supported models and examples please see the Modulus documentation.

47
 Modulus Features
Constructive Solid Geometry Module – Fully parameterizable with SymPy and allows Boolean ops

• Allows to create complex geometries using a variety of primitives (​torus, cones, ellipse, etc.)
• Supports functions like translate, rotate, scale, repeat, etc.

Example of a parameterized 3 Fin heatsink and solving the

conjugate heat transfer problem.

Boolean (Union, Intersection and, Subtraction) of different Geometry parameterizable using SymPy 48
primitives within Modulus
 Modulus Features
PySDF library: Tessellated Geometry Module, OptiX for sampling and SDF

• Allows to import complex tessellated geometries.​

• Uses ray tracing to compute SDF and its derivatives. Also computes surface normals.​
• Once the geometry is imported, creates a point cloud for training.​

49
 Modulus Features and Advancements
Physics types and solution of differential equations

Physics types:
• Linear Elasticity (plane stress, plane strain and 3D)
• Fluid Mechanics
• Heat Transfer
• Coupled Fluid-Thermal
• Electromagnetics
• Wave propagation
• Examples of 2-eqn. turbulence (on fully developed channel case)
Linear Elasticity
Solution of differential equations:
Electromagnetics
• Ordinary Differential Equations
• Differential (strong) Form
Modulus t=600ms
• Integral (weak) form of the PDEs
Conjugate Heat Transfer

Taylor-Green vortex decay Wave Propagation

50
 Modulus Features and Advancements
Network Architectures

Several neural network architectures:

• Fully connected Network
• Fourier Feature Network
• Sinusoidal Representation Network (SiReN)
• Modified Fourier Network
• Deep Galerkin Method Network
• Modified Highway Network
• Multiplicative Filter Networks
• Operators:
• Fourier Neural Operator (FNO)
• Adaptive Fourier Neural Operator (AFNO)
• Physics Informed Fourier Neural Operator (PINO)
• DeepONet
Comparisons of various networks in Modulus applied to solve the flow over a heatsink

Darcy Flow problem using FNO in Modulus

51
 Modulus Features and Advancements
Other advanced training features

Other Features include:

• Support for new optimizers
• AdaHessian and up to 30+ optimizers (from PyTorch’s
torch_optimizer library)
• New algorithms for loss balancing
• GradNorm, ReLoBRaLo, Soft Adapt, NTK, etc.
• Sobolev (gradient-enhanced) training
• Exact boundary condition imposition Importance
• Global and local learning rate annealing sampling
• Global adaptive activation functions
• Halton sequences for low-discrepancy point cloud creation
• Gradient Accumulation
• Time-stepping schemes for transient problems
• Temporal loss weighting and time marching for the continuous time
approach
• Importance sampling
• Homoscedastic task uncertainty quantification for loss weighting
• Hydra Configs for easy hyper-parameter tuning

Handling larger batch sizes

using Multi-GPU and/or
Gradient Aggregation

52
 Modulus Features and Advancements
Other advanced training features

• APIs to automatically generate point clouds from Boolean compositions of geometry primitives or import point cloud for
complex geometry (e.g., STL files)
• Parameterized system representation that solves several configurations concurrently for analytical geometry
using Modulus CSG module
• Transfer learning for efficient surrogate-based parameterization of STL and constructive solid geometries

STL geometry and Transfer Learning Geometry parameterization using Modulus’ CSG module

53
 Omniverse Extension for Modulus

• NVIDIA Omniverse™ is an easily extensible platform for 3D

design collaboration and scalable multi-GPU, real-time, true-to-
reality simulation. Omniverse revolutionizes the way we create
and develop as individuals and work together as teams, bringing
more creative possibilities and efficiency to 3D creators,
developers and enterprises. ​

• Omniverse extension for Modulus enables real-time virtual-

world simulation and full-design fidelity visualization. The built-
in pipeline can be used for common visualizations such as
streamlines and iso-surfaces for the outputs of the Modulus
model. Another key feature is being able to visualize and analyze
the high-fidelity simulation output in near real time as the design
parameters are varied.​

• For more information, please refer Modulus Extension Docs

54
 Modulus Resources

• Download Now: https://developer.nvidia.com/modulus-downloads​

• Webpage: https://developer.nvidia.com/modulus​
• Documentation: https://sw-docs-dgx-station.nvidia.com/deeplearning/modulus/index.html​
• Developer Forum: https://forums.developer.nvidia.com/c/physics-simulation​
• Demos:​
• Accelerating Extreme Weather Prediction with FourCastNet​
• Siemens Energy HRSG Digital Twin Simulation Using NVIDIA Modulus and Omniverse​
• Accelerating Scientific & Engineering Simulation Workflows with AI​
• Flow Physics Quantification in an Aneurysm Using NVIDIA Modulus​
• Blogs: ​
• AI and Machine Learning in Physics​
• Using NVIDIA Modulus and Omniverse Wind Farm Digital Twin for Siemens Gamesa (using NVIDIA Modulus and Omniverse)​
• Siemens Energy Taps NVIDIA to Develop Industrial Digital Twin of Power Plant in Omniverse and Modulus​
• Using Hybrid Physics-Informed Neural Networks for Digital Twins in Prognosis and Health Management​
• Using Physics-Informed Deep Learning for Transport in Porous Media​

55
 Modulus Resources

• Papers:​
• NVIDIA SimNet™: An AI-Accelerated Multi-Physics Simulation Framework​
• Physics-Informed Machine Learning and Uncertainty Quantification for Mechanics of Heterogeneous Materials​
• Physics Informed RNN-DCT Networks for Time-Dependent Partial Differential Equations

• ​Talks:​
• A Novel Framework for Physics based Machine Learning in Science & Engineering Domains​
• Accelerate HPC Simulations at Scale with Physics-informed Neural Networks and NVIDIA GPUs on AWS​
• Toward Developing High Reynolds Number, Compressible, Reacting Flows in Modulus​
• Physics-informed Neural Networks for Wave Propagation Using NVIDIA Modulus​
• Uncertainty Quantification for Transport in Porous Media Using Parameterized Physics Informed Neural Networks​
• Using Physics-Informed Neural Networks and Modulus to Accelerate Product Development​
• Physics-Informed Neural Networks for Mechanics of Heterogenous Media​
• Hybrid Physics-Informed Neural Networks for Digital Twin in Prognosis and Health Management​
• Physics-Informed Neural Network for Flow and Transport in Porous Media​
• AI-Accelerated Computational Science and Engineering Using Physics-Based Neural Networks​
• Cumulative Damage Models, Hybrid-Physics-Informed Neural Networks, and Digital TwinsWWCumulative
Damage Models, Hybrid-Physics-Informed Neural Networks, and Digital Twins​
• NVIDIA Modulus - Accelerating Scientific & Engineering Simulation workflows with AI​

• Podcast:​
• AI Physics Simulation Toolkit SimNet & PINNs​

56
57