Simulation By Deep Neural Operator (DeepONets)

Explore deep learning theory through neural networks, weights and biases, activation functions like ReLU and sigmoid, and loss-based training using gradient descent and backpropagation to optimize predictions.

Explore the basics of PyTorch tensors, from scalars and vectors to matrices and higher-order tensors, and learn to create, reshape, index, and perform core operations with torch.

Connect tensors with NumPy arrays using PyTorch and NumPy, converting between torch tensors and NumPy arrays, including CPU and GPU (CUDA) handling.

Learn backpropagation theory for deep neural networks, performing forward and backward passes to minimize squared loss by adjusting weights through the chain rule and gradient updates.

Implement backpropagation in PyTorch by performing a forward pass with x, y, and a learnable weight w, computing the loss from y hat and y, then backward.

Learn how to numerically solve the heat equation, a partial differential equation, by discretizing space and time, using forward, backward, and central difference schemes, including a three-point second-derivative stencil.

Set up a heat equation solver in a Jupyter notebook by discretizing a rod, applying boundary and initial conditions, and visualizing temperature evolution with NumPy and Matplotlib.

Apply an explicit finite-difference scheme to the diffusion equation for u, updating the solution step by step from the initial condition using dt, dx, and k with predicted future values.

Plot the 1D heat equation solution over time to observe diffusion as time steps advance, with careful boundary handling and future neural network solutions.

Develop a deep neural operator for numerical integration by generating diverse training data from random Gaussian curves, computing their integrals, and forming input-output training pairs.

Reshape data into DeepONets format by feeding the whole input sequence u to the branch and a target location x to the trunk, producing s.

Transform raw data into tensors, set 32-batch patches, split into training and test sets, and build PyTorch data loaders to produce patch-based batches for model training.

Build a deep onet in PyTorch by constructing branch and trunk networks, configuring inputs for the full sequence and a location, and applying Einstein multiplication to combine outputs.

Train the network by defining a mean squared error loss and optimizing with Adam at a chosen learning rate. Run 2000 epochs, monitor training loss, and update via backpropagation.

Explore how a deep neural operator (DeepONets) evaluates results by comparing neural network integration against an analytical cosine-based solution, using loss convergence and plotting to validate accuracy.

Solve the 1D heat equation with forward-time central-space finite differences, generate training data using Gaussian seeds, and train a deep operator network (DeepONets) to learn temperature evolution.

Preprocess data for DeepONets by combining x and y into a single input, reshaping a 15 by 50 grid into 750 samples, and converting to numpy arrays for training.

Generate patch-based data sets, split into train and test with a 0.8 ratio, convert to torch tensors, and load with a shuffled data loader for training and evaluation.

Build a deep operator model in PyTorch by defining a class with a branch and trunk network, processing initial conditions and (x,t) inputs to produce the DeepONet output.

Train a DeepONets model by defining mean squared error loss, selecting Adam with a learning rate, and running a patch-based training loop with backpropagation across epochs.

Evaluate the neural operator (deepONet) by tracking training losses, plotting mean square error, and comparing new data with finite difference method results to assess convergence and accuracy.

generate data for the 1d heat equation using a deep operator network with the deep xd library, then preprocess inputs and solve with finite difference method, comparing DeepONets to PyTorch.

Preprocess data for deep nets by reshaping inputs, forming the a-x-t combination, and interpreting rows as data points. Create train/test split and convert to numpy arrays, pairing X and Y.

Build a DeepONets model with a branch encoding the initial condition curve and a trunk for location, using ReLU and normal initialization; then define, compile, and run to see results.

Compile the model with the Adam optimizer at a 0.001 learning rate and train while recording loss history. Post-process the results and compare with the finite difference method and PyTorch.

Evaluate and compare the deep neural operator (deepONets) for the 1d heat equation, tracing loss history and train-test differences, and assess unseen data performance against a finite difference model.

Create and subset Navier–Stokes data to train a deep neural operator (deeponets) that simulates 2D velocity fields over time on 64x64 grids with 65 time steps.

Preprocess data for a DeepONets deep neural operator by selecting a small training set, creating spatiotemporal x, y, time coordinates, and preparing initial conditions and train–test inputs.

Build a simple DeepONets model with a branch and trunk, expand input dimensions for X, Y, and t, apply ReLU activation with normal initialization, and prepare to train.

Compile the model, configure the Adam optimizer with a 0.001 learning rate, and train the DeepONets-based simulation, tracking history across 1000 iterations and using a test split to predict trends.

Evaluate deep neural operator training by analyzing loss history, training versus test performance, and one-step predictions from initial conditions, highlighting data requirements and model complexity.