Upload folder using huggingface_hub

.gitattributes

@@ -1,35 +1,50 @@
 *.7z filter=lfs diff=lfs merge=lfs -text
 *.arrow filter=lfs diff=lfs merge=lfs -text
 *.bin filter=lfs diff=lfs merge=lfs -text
+*.bin.* filter=lfs diff=lfs merge=lfs -text
 *.bz2 filter=lfs diff=lfs merge=lfs -text
-*.ckpt filter=lfs diff=lfs merge=lfs -text
 *.ftz filter=lfs diff=lfs merge=lfs -text
 *.gz filter=lfs diff=lfs merge=lfs -text
 *.h5 filter=lfs diff=lfs merge=lfs -text
 *.joblib filter=lfs diff=lfs merge=lfs -text
 *.lfs.* filter=lfs diff=lfs merge=lfs -text
-*.mlmodel filter=lfs diff=lfs merge=lfs -text
 *.model filter=lfs diff=lfs merge=lfs -text
 *.msgpack filter=lfs diff=lfs merge=lfs -text
-*.npy filter=lfs diff=lfs merge=lfs -text
-*.npz filter=lfs diff=lfs merge=lfs -text
 *.onnx filter=lfs diff=lfs merge=lfs -text
 *.ot filter=lfs diff=lfs merge=lfs -text
 *.parquet filter=lfs diff=lfs merge=lfs -text
 *.pb filter=lfs diff=lfs merge=lfs -text
-*.pickle filter=lfs diff=lfs merge=lfs -text
-*.pkl filter=lfs diff=lfs merge=lfs -text
-*.pt filter=lfs diff=lfs merge=lfs -text
+ 
 *.pth filter=lfs diff=lfs merge=lfs -text
 *.rar filter=lfs diff=lfs merge=lfs -text
-*.safetensors filter=lfs diff=lfs merge=lfs -text
 saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.tar.* filter=lfs diff=lfs merge=lfs -text
-*.tar filter=lfs diff=lfs merge=lfs -text
 *.tflite filter=lfs diff=lfs merge=lfs -text
 *.tgz filter=lfs diff=lfs merge=lfs -text
-*.wasm filter=lfs diff=lfs merge=lfs -text
 *.xz filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
+*.zstandard filter=lfs diff=lfs merge=lfs -text
+*.tfevents* filter=lfs diff=lfs merge=lfs -text
+*.db* filter=lfs diff=lfs merge=lfs -text
+*.ark* filter=lfs diff=lfs merge=lfs -text
+**/*ckpt*data* filter=lfs diff=lfs merge=lfs -text
+**/*ckpt*.meta filter=lfs diff=lfs merge=lfs -text
+**/*ckpt*.index filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.gguf* filter=lfs diff=lfs merge=lfs -text
+*.ggml filter=lfs diff=lfs merge=lfs -text
+*.llamafile* filter=lfs diff=lfs merge=lfs -text
+*.pt2 filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+ 
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text

README.md

@@ -0,0 +1,126 @@
+---
+frameworks:
+  - pytorch
+language:
+  - en
+license: apache-2.0
+tags:
+  - OneScience
+  - gPINNs
+  - physics-informed-neural-networks
+  - partial-differential-equations
+  - Poisson
+  - Burgers
+tasks:
+  - pde-solving
+---
+<p align="center">
+  <strong>
+    <span style="font-size: 30px;">gPINNs</span>
+  </strong>
+</p>
+
+# Model Overview
+
+gPINNs (Gradient-enhanced Physics-Informed Neural Networks) augment the PDE residual constraints of conventional PINNs with constraints on residual gradients with respect to the input coordinates. This additional higher-order derivative information can improve sample efficiency and solution accuracy for selected forward and inverse problems.
+
+This model package provides one-dimensional and two-dimensional Poisson examples, together with a Burgers equation example using residual-based adaptive refinement (RAR).
+
+Paper: Gradient-enhanced physics-informed neural networks for forward and inverse PDE problems  
+https://doi.org/10.1016/j.cma.2022.114823
+
+# Model Description
+
+gPINNs use automatic differentiation to compute both PDE residuals and their coordinate gradients, incorporating both as training constraints. The two-dimensional Poisson example applies a hard-boundary output transformation, while the Burgers example uses RAR to add collocation points progressively in high-residual regions.
+
+# Use Cases
+
+| Use Case | Description |
+| :---: | :--- |
+| One-dimensional Poisson equation | Validate joint training with residual-gradient constraints and boundary loss |
+| Two-dimensional Poisson equation | Solve a homogeneous Dirichlet boundary-value problem using a hard-boundary output transformation |
+| Burgers equation | Combine higher-order automatic differentiation with RAR in high-residual regions |
+| Pipeline validation | Validate training, inference, and plotting with the bundled data and pretrained weights |
+
+# Usage
+
+## 1. OneCode
+
+Use the online OneCode environment for an intelligent, one-click AI for Science (AI4S) programming experience:
+
+[Launch OneCode for one-click AI4S programming](https://web-2069360198568017922-iaaj.ksai.scnet.cn:58043/home)
+
+## 2. Manual Setup
+
+**Hardware Requirements**
+
+- A GPU or DCU is recommended for training.
+- A CPU can be used for inference and small-scale pipeline validation, but full training will be slow.
+- DCU users must install DTK and a PyTorch environment compatible with the target cluster.
+
+### Download the Model Package
+
+```bash
+modelscope download --model OneScience/gPINNs --local_dir ./gPINNs
+cd gPINNs
+```
+
+### Set Up the Runtime Environment
+
+**DCU Environment**
+
+```bash
+# Activate DTK and Conda first
+conda create -n onescience311 python=3.11 -y
+conda activate onescience311
+pip install onescience[cfd-dcu] -i http://mirrors.onescience.ai:3141/pypi/simple/ --trusted-host mirrors.onescience.ai
+```
+
+**GPU Environment**
+
+```bash
+# Activate Conda first
+conda create -n onescience311 python=3.11 -y libstdcxx-ng=12 libgcc-ng=12 gcc_linux-64=12 gxx_linux-64=12
+conda activate onescience311
+pip install onescience[cfd-gpu] -i http://mirrors.onescience.ai:3141/pypi/simple/ --trusted-host mirrors.onescience.ai
+```
+
+### Training Data
+
+The one- and two-dimensional Poisson examples construct training and evaluation data from analytical solutions; the Burgers example uses the bundled reference solution `data/Burgers.npz`. Data and training parameters can be adjusted in `conf/config.yaml`.
+
+### Training
+
+To train all examples:
+
+```bash
+python scripts/train.py --case all
+```
+
+Alternatively, train an individual example with `--case 1d`, `--case 2d`, or `--case burgers`. The `--epochs` and `--nf` options override the defaults for the selected example; `--lbfgs-iters` applies only to the one-dimensional Poisson case, `--rar-rounds` controls the number of RAR rounds for the Burgers case, and `--quick` skips RAR for rapid pipeline validation.
+
+### Model Weights
+
+This model package provides pretrained weights for the one-dimensional Poisson, two-dimensional Poisson, and Burgers equation examples in the `weight/` directory.
+
+### Inference, Evaluation, and Visualization
+
+The model package provides weights for validating all three examples. Run:
+
+```bash
+python scripts/inference.py --case all
+```
+
+The script reports the relative L2 error for each example and saves prediction visualizations under `result/`. Use `--case` to select an individual example. Model, data, and training parameters can all be modified in `conf/config.yaml`.
+
+# Official OneScience Resources
+
+| Platform | OneScience Repository | Skills Repository |
+| --- | --- | --- |
+| Gitee | https://gitee.com/onescience-ai/onescience | https://gitee.com/onescience-ai/oneskills |
+| GitHub | https://github.com/onescience-ai/OneScience | https://github.com/onescience-ai/oneskills |
+
+# Citations and License
+
+- Yu, J., Lu, L., Meng, X., and Karniadakis, G. E. Gradient-enhanced physics-informed neural networks for forward and inverse PDE problems. Computer Methods in Applied Mechanics and Engineering, 393, 114823, 2022.
+- This model package is released under the Apache-2.0 license and retains attribution to the original paper and data sources.

conf/config.yaml

@@ -0,0 +1,39 @@
+root:
+  common:
+    device: "auto"
+    dtype: "float64"
+    seed: 1234
+    weight_dir: "weight"
+    result_dir: "result"
+
+  poisson1d:
+    nf: 30
+    w_g: 0.1
+    epochs: 30000
+    lbfgs_iters: 2000
+    lr: 0.001
+    log_every: 1000
+    layers: [1, 30, 30, 30, 30, 1]
+
+  poisson2d:
+    a: 2.0
+    nf: 400
+    w_g: 0.001
+    epochs: 15000
+    lr: 0.001
+    log_every: 2000
+    layers: [2, 30, 30, 30, 1]
+
+  burgers:
+    data: "data/Burgers.npz"
+    nf: 1500
+    w_g: 0.0001
+    epochs: 20000
+    lr: 0.001
+    log_every: 2000
+    layers: [2, 32, 32, 32, 1]
+    rar_rounds: 5
+    rar_epochs: 5000
+    rar_candidate_points: 100000
+    rar_candidate_batch_size: 10000
+    rar_add_points: 10

configuration.json

@@ -0,0 +1 @@
+{"framework":"Pytorch","task":"other"}

data/Burgers.npz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e9d57a5824cd54b8345ac0c7390dad93ccb1bebec85d4f9d71f5407c99874315
+size 208318

model/gpinn.py

@@ -0,0 +1,220 @@
+from __future__ import annotations
+
+from collections.abc import Sequence
+
+import numpy as np
+import torch
+import torch.autograd as autograd
+import torch.nn as nn
+
+
+class SubNet(nn.Module):
+    """Fully connected network with trainable adaptive activations."""
+
+    def __init__(self, layers: Sequence[int], activation: str = "tanh") -> None:
+        super().__init__()
+        if len(layers) < 2:
+            raise ValueError("layers must contain at least an input and an output size")
+        if activation not in {"tanh", "sin", "cos"}:
+            raise ValueError(f"unsupported activation: {activation}")
+
+        self.activation = activation
+        self.linears = nn.ModuleList(
+            nn.Linear(layers[index], layers[index + 1], dtype=torch.float64)
+            for index in range(len(layers) - 1)
+        )
+        # Keep one value per layer for compatibility with the published checkpoints.
+        self.a = nn.ParameterList(
+            nn.Parameter(torch.tensor(0.05, dtype=torch.float64))
+            for _ in range(len(layers) - 1)
+        )
+
+    def forward(self, inputs: torch.Tensor) -> torch.Tensor:
+        hidden = inputs
+        for index, linear in enumerate(self.linears[:-1]):
+            hidden = 20.0 * self.a[index] * linear(hidden)
+            hidden = getattr(torch, self.activation)(hidden)
+        return self.linears[-1](hidden)
+
+
+class gPINN(nn.Module):
+    """Gradient-enhanced physics-informed neural network backbone."""
+
+    def __init__(self, layers: Sequence[int], activation: str = "tanh") -> None:
+        super().__init__()
+        self.net = SubNet(layers, activation)
+
+    def forward(self, inputs: torch.Tensor) -> torch.Tensor:
+        return self.net(inputs)
+
+
+class gPINNPoisson2D(nn.Module):
+    """2D Poisson model whose output transform enforces zero boundaries."""
+
+    def __init__(self, layers: Sequence[int]) -> None:
+        super().__init__()
+        self.net = gPINN(layers)
+
+    def forward(self, coordinates: torch.Tensor) -> torch.Tensor:
+        x = coordinates[:, 0:1]
+        y = coordinates[:, 1:2]
+        return x * y * (1.0 - x) * (1.0 - y) * self.net(coordinates)
+
+
+def exact_poisson1d(x: np.ndarray) -> np.ndarray:
+    solution = x + np.sin(8.0 * x) / 8.0
+    for frequency in range(1, 5):
+        solution += np.sin(frequency * x) / frequency
+    return solution
+
+
+def gpinn_loss_poisson1d(
+    model: nn.Module,
+    interior: torch.Tensor,
+    boundary: torch.Tensor,
+    boundary_values: torch.Tensor,
+    gradient_weight: float,
+) -> tuple[torch.Tensor, dict[str, float]]:
+    x = interior.detach().requires_grad_(True)
+    prediction = model(x)
+    first = autograd.grad(prediction, x, torch.ones_like(prediction), create_graph=True)[0]
+    second = autograd.grad(first, x, torch.ones_like(first), create_graph=True)[0]
+    third = autograd.grad(second, x, torch.ones_like(second), create_graph=True)[0]
+
+    source = 8.0 * torch.sin(8.0 * x) + sum(
+        frequency * torch.sin(frequency * x) for frequency in range(1, 5)
+    )
+    source_gradient = (
+        torch.cos(x)
+        + 4.0 * torch.cos(2.0 * x)
+        + 9.0 * torch.cos(3.0 * x)
+        + 16.0 * torch.cos(4.0 * x)
+        + 64.0 * torch.cos(8.0 * x)
+    )
+
+    residual = -second - source
+    residual_gradient = -third - source_gradient
+    residual_loss = torch.mean(residual.square())
+    boundary_loss = torch.mean((model(boundary) - boundary_values).square())
+    gradient_loss = torch.mean(residual_gradient.square())
+    loss = residual_loss + boundary_loss + gradient_weight * gradient_loss
+    return loss, {
+        "residual": residual_loss.item(),
+        "boundary": boundary_loss.item(),
+        "gradient": gradient_loss.item(),
+    }
+
+
+def exact_poisson2d(x: np.ndarray, y: np.ndarray, exponent: float) -> np.ndarray:
+    return (16.0 * x * y * (1.0 - x) * (1.0 - y)) ** exponent
+
+
+def _poisson2d_source(coordinates: torch.Tensor, exponent: float) -> torch.Tensor:
+    x = coordinates[:, 0:1]
+    y = coordinates[:, 1:2]
+    exact = (16.0 * x * y * (1.0 - x) * (1.0 - y)) ** exponent
+    exact_gradient = autograd.grad(
+        exact, coordinates, torch.ones_like(exact), create_graph=True
+    )[0]
+    exact_xx = autograd.grad(
+        exact_gradient[:, 0:1],
+        coordinates,
+        torch.ones_like(exact_gradient[:, 0:1]),
+        create_graph=True,
+    )[0][:, 0:1]
+    exact_yy = autograd.grad(
+        exact_gradient[:, 1:2],
+        coordinates,
+        torch.ones_like(exact_gradient[:, 1:2]),
+        create_graph=True,
+    )[0][:, 1:2]
+    return -(exact_xx + exact_yy)
+
+
+def gpinn_loss_poisson2d(
+    model: nn.Module,
+    interior: torch.Tensor,
+    gradient_weight: float,
+    exponent: float,
+) -> tuple[torch.Tensor, dict[str, float]]:
+    coordinates = interior.detach().requires_grad_(True)
+    prediction = model(coordinates)
+    prediction_gradient = autograd.grad(
+        prediction, coordinates, torch.ones_like(prediction), create_graph=True
+    )[0]
+    prediction_xx = autograd.grad(
+        prediction_gradient[:, 0:1],
+        coordinates,
+        torch.ones_like(prediction_gradient[:, 0:1]),
+        create_graph=True,
+    )[0][:, 0:1]
+    prediction_yy = autograd.grad(
+        prediction_gradient[:, 1:2],
+        coordinates,
+        torch.ones_like(prediction_gradient[:, 1:2]),
+        create_graph=True,
+    )[0][:, 1:2]
+
+    residual = prediction_xx + prediction_yy + _poisson2d_source(coordinates, exponent)
+    residual_gradient = autograd.grad(
+        residual, coordinates, torch.ones_like(residual), create_graph=True
+    )[0]
+    residual_loss = torch.mean(residual.square())
+    gradient_loss = torch.mean(residual_gradient[:, 0:1].square()) + torch.mean(
+        residual_gradient[:, 1:2].square()
+    )
+    loss = residual_loss + gradient_weight * gradient_loss
+    return loss, {"residual": residual_loss.item(), "gradient": gradient_loss.item()}
+
+
+def output_transform_burgers(
+    coordinates: torch.Tensor, raw_prediction: torch.Tensor
+) -> torch.Tensor:
+    x = coordinates[:, 0:1]
+    t = coordinates[:, 1:2]
+    return (
+        (1.0 - x) * (1.0 + x) * (1.0 - torch.exp(-t)) * raw_prediction
+        - torch.sin(torch.pi * x)
+    )
+
+
+class gPINNBurgers(nn.Module):
+    """Burgers model with hard initial and boundary constraints."""
+
+    def __init__(self, layers: Sequence[int]) -> None:
+        super().__init__()
+        self.net = gPINN(layers)
+
+    def forward(self, coordinates: torch.Tensor) -> torch.Tensor:
+        return output_transform_burgers(coordinates, self.net(coordinates))
+
+
+def burgers_residual(
+    model: nn.Module, coordinates: torch.Tensor, create_graph: bool = True
+) -> tuple[torch.Tensor, torch.Tensor]:
+    inputs = coordinates.detach().requires_grad_(True)
+    prediction = model(inputs)
+    prediction_gradient = autograd.grad(
+        prediction, inputs, torch.ones_like(prediction), create_graph=True
+    )[0]
+    prediction_x = prediction_gradient[:, 0:1]
+    prediction_t = prediction_gradient[:, 1:2]
+    prediction_xx = autograd.grad(
+        prediction_x,
+        inputs,
+        torch.ones_like(prediction_x),
+        create_graph=create_graph,
+    )[0][:, 0:1]
+    viscosity = 0.01 / torch.pi
+    residual = prediction_t + prediction * prediction_x - viscosity * prediction_xx
+    return residual, inputs
+
+
+def burgers_gpinn_terms(
+    model: nn.Module, coordinates: torch.Tensor
+) -> tuple[torch.Tensor, torch.Tensor, torch.Tensor]:
+    residual, inputs = burgers_residual(model, coordinates, create_graph=True)
+    residual_gradient = autograd.grad(
+        residual, inputs, torch.ones_like(residual), create_graph=True
+    )[0]
+    return residual, residual_gradient[:, 0:1], residual_gradient[:, 1:2]

scripts/inference.py

@@ -0,0 +1,270 @@
+from __future__ import annotations
+
+import argparse
+import os
+import sys
+from pathlib import Path
+
+import matplotlib
+
+matplotlib.use("Agg")
+import matplotlib.pyplot as plt
+import numpy as np
+import torch
+import yaml
+
+
+PROJECT_ROOT = Path(__file__).resolve().parents[1]
+sys.path.insert(0, str(PROJECT_ROOT))
+
+from model.gpinn import (  # noqa: E402
+    exact_poisson1d,
+    exact_poisson2d,
+    gPINN,
+    gPINNBurgers,
+    gPINNPoisson2D,
+)
+
+
+DEFAULT_CONFIG = PROJECT_ROOT / "conf" / "config.yaml"
+CASES = ("1d", "2d", "burgers")
+
+
+def load_config(path: Path) -> dict:
+    with path.open("r", encoding="utf-8") as stream:
+        config = yaml.safe_load(stream)
+    if not isinstance(config, dict) or "root" not in config:
+        raise ValueError(f"config must contain a 'root' mapping: {path}")
+    return config["root"]
+
+
+def project_path(value: str | Path) -> Path:
+    path = Path(value).expanduser()
+    return path if path.is_absolute() else PROJECT_ROOT / path
+
+
+def resolve_device(requested: str) -> torch.device:
+    if requested == "auto":
+        return torch.device("cuda" if torch.cuda.is_available() else "cpu")
+    device = torch.device(requested)
+    if device.type == "cuda" and not torch.cuda.is_available():
+        raise RuntimeError("CUDA/DCU was requested but torch.cuda.is_available() is false")
+    return device
+
+
+def resolve_dtype(name: str) -> torch.dtype:
+    try:
+        return {"float32": torch.float32, "float64": torch.float64}[name]
+    except KeyError as error:
+        raise ValueError(f"unsupported dtype: {name}") from error
+
+
+def load_checkpoint(weight_dir: Path, filename: str) -> dict:
+    checkpoint_path = weight_dir / filename
+    if not checkpoint_path.is_file():
+        raise FileNotFoundError(
+            f"checkpoint not found: {checkpoint_path}. Run scripts/train.py first."
+        )
+    checkpoint = torch.load(checkpoint_path, map_location="cpu", weights_only=True)
+    if not isinstance(checkpoint, dict) or "model_state" not in checkpoint:
+        raise ValueError(f"invalid checkpoint format: {checkpoint_path}")
+    return checkpoint
+
+
+def infer_poisson1d(
+    weight_dir: Path,
+    result_dir: Path,
+    device: torch.device,
+    dtype: torch.dtype,
+) -> float:
+    checkpoint = load_checkpoint(weight_dir, "gpinn_poisson1d.pt")
+    layers = checkpoint.get("layers", [1, 30, 30, 30, 30, 1])
+    model = gPINN(layers).to(device=device, dtype=dtype)
+    model.load_state_dict(checkpoint["model_state"], strict=True)
+    model.eval()
+
+    x = torch.linspace(0.0, np.pi, 1000, dtype=dtype, device=device).unsqueeze(-1)
+    exact = exact_poisson1d(x.cpu().numpy().reshape(-1))
+    with torch.no_grad():
+        prediction = model(x).cpu().numpy().reshape(-1)
+    relative_l2 = float(np.linalg.norm(prediction - exact) / np.linalg.norm(exact))
+
+    figure, axis = plt.subplots(figsize=(8, 4))
+    axis.plot(x.cpu().numpy(), exact, "k-", label="Exact")
+    axis.plot(x.cpu().numpy(), prediction, "r--", label="gPINN")
+    axis.set_xlabel("x")
+    axis.set_ylabel("u")
+    axis.legend()
+    figure.tight_layout()
+    output_path = result_dir / "gpinn_poisson1d.png"
+    figure.savefig(output_path, dpi=150)
+    plt.close(figure)
+    print(f"[1D] relative L2={relative_l2:.6e}, plot={output_path}")
+    return relative_l2
+
+
+def infer_poisson2d(
+    weight_dir: Path,
+    result_dir: Path,
+    device: torch.device,
+    dtype: torch.dtype,
+    default_exponent: float,
+) -> float:
+    checkpoint = load_checkpoint(weight_dir, "gpinn_poisson2d.pt")
+    layers = checkpoint.get("layers", [2, 30, 30, 30, 1])
+    architecture = checkpoint.get("architecture", "gpinn")
+    if architecture == "poisson2d_hard_bc":
+        model = gPINNPoisson2D(layers)
+    elif architecture == "gpinn":
+        # The bundled legacy checkpoint predates the hard boundary transform.
+        model = gPINN(layers)
+    else:
+        raise ValueError(f"unsupported 2D Poisson architecture: {architecture}")
+    model = model.to(device=device, dtype=dtype)
+    model.load_state_dict(checkpoint["model_state"], strict=True)
+    model.eval()
+
+    exponent = float(checkpoint.get("a", default_exponent))
+    axis = np.linspace(0.0, 1.0, 100)
+    grid_x, grid_y = np.meshgrid(axis, axis)
+    coordinates = torch.as_tensor(
+        np.column_stack([grid_x.ravel(), grid_y.ravel()]), dtype=dtype, device=device
+    )
+    with torch.no_grad():
+        prediction = model(coordinates).cpu().numpy().reshape(grid_x.shape)
+    exact = exact_poisson2d(grid_x, grid_y, exponent)
+    absolute_error = np.abs(prediction - exact)
+    relative_l2 = float(
+        np.linalg.norm(prediction.ravel() - exact.ravel()) / np.linalg.norm(exact.ravel())
+    )
+
+    figure, axes = plt.subplots(1, 3, figsize=(15, 4))
+    for plot_axis, title, field in zip(
+        axes,
+        ("Exact", "gPINN", "Absolute error"),
+        (exact, prediction, absolute_error),
+        strict=True,
+    ):
+        image = plot_axis.imshow(field, extent=(0, 1, 0, 1), origin="lower", cmap="jet")
+        plot_axis.set_title(title)
+        plot_axis.set_xlabel("x")
+        plot_axis.set_ylabel("y")
+        figure.colorbar(image, ax=plot_axis)
+    figure.tight_layout()
+    output_path = result_dir / "gpinn_poisson2d.png"
+    figure.savefig(output_path, dpi=150)
+    plt.close(figure)
+    print(f"[2D] relative L2={relative_l2:.6e}, plot={output_path}")
+    return relative_l2
+
+
+def load_burgers_grid(data_path: Path) -> tuple[np.ndarray, np.ndarray, np.ndarray]:
+    if not data_path.is_file():
+        raise FileNotFoundError(f"Burgers data not found: {data_path}")
+    with np.load(data_path) as data:
+        missing = {"t", "x", "usol"}.difference(data.files)
+        if missing:
+            raise ValueError(f"Burgers data is missing arrays: {sorted(missing)}")
+        time_axis = np.asarray(data["t"]).reshape(-1)
+        space_axis = np.asarray(data["x"]).reshape(-1)
+        exact = np.asarray(data["usol"])
+    expected_shape = (space_axis.size, time_axis.size)
+    if exact.shape != expected_shape:
+        raise ValueError(f"usol shape must be {expected_shape}, got {exact.shape}")
+    return time_axis, space_axis, exact
+
+
+def infer_burgers(
+    weight_dir: Path,
+    result_dir: Path,
+    data_path: Path,
+    device: torch.device,
+    dtype: torch.dtype,
+) -> float:
+    checkpoint = load_checkpoint(weight_dir, "gpinn_burgers.pt")
+    layers = checkpoint.get("layers", [2, 32, 32, 32, 1])
+    model = gPINNBurgers(layers).to(device=device, dtype=dtype)
+    model.load_state_dict(checkpoint["model_state"], strict=True)
+    model.eval()
+
+    time_axis, space_axis, exact = load_burgers_grid(data_path)
+    time_grid, space_grid = np.meshgrid(time_axis, space_axis)
+    coordinates = torch.as_tensor(
+        np.column_stack([space_grid.ravel(), time_grid.ravel()]),
+        dtype=dtype,
+        device=device,
+    )
+    with torch.no_grad():
+        prediction = model(coordinates).cpu().numpy().reshape(exact.shape)
+    absolute_error = np.abs(prediction - exact)
+    relative_l2 = float(
+        np.linalg.norm(prediction.ravel() - exact.ravel()) / np.linalg.norm(exact.ravel())
+    )
+
+    figure, axes = plt.subplots(1, 3, figsize=(15, 4))
+    for plot_axis, title, field in zip(
+        axes,
+        ("Exact", "gPINN", "Absolute error"),
+        (exact, prediction, absolute_error),
+        strict=True,
+    ):
+        image = plot_axis.contourf(time_axis, space_axis, field, 100, cmap="jet")
+        plot_axis.set_title(title)
+        plot_axis.set_xlabel("t")
+        plot_axis.set_ylabel("x")
+        figure.colorbar(image, ax=plot_axis)
+    figure.tight_layout()
+    output_path = result_dir / "gpinn_burgers.png"
+    figure.savefig(output_path, dpi=150)
+    plt.close(figure)
+    print(f"[Burgers] relative L2={relative_l2:.6e}, plot={output_path}")
+    return relative_l2
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(description="Run gPINN inference and visualization")
+    parser.add_argument(
+        "--config",
+        type=Path,
+        default=Path(os.environ.get("GPINN_CONFIG", DEFAULT_CONFIG)),
+        help="YAML configuration file",
+    )
+    parser.add_argument("--case", choices=(*CASES, "all"), default="all")
+    parser.add_argument("--device", help="Override common.device, for example cpu or cuda:0")
+    parser.add_argument("--data", type=Path, help="Override Burgers.npz path")
+    parser.add_argument("--weight-dir", type=Path, help="Override checkpoint input directory")
+    parser.add_argument("--result-dir", type=Path, help="Override plot output directory")
+    return parser.parse_args()
+
+
+def main() -> None:
+    args = parse_args()
+    config_path = args.config.expanduser().resolve()
+    config = load_config(config_path)
+    common = config["common"]
+    device = resolve_device(args.device or str(common["device"]))
+    dtype = resolve_dtype(str(common["dtype"]))
+    weight_dir = project_path(args.weight_dir or common["weight_dir"])
+    result_dir = project_path(args.result_dir or common["result_dir"])
+    data_path = project_path(args.data or config["burgers"]["data"])
+    result_dir.mkdir(parents=True, exist_ok=True)
+
+    print(f"Config: {config_path}")
+    print(f"Device: {device}")
+    selected_cases = CASES if args.case == "all" else (args.case,)
+    if "1d" in selected_cases:
+        infer_poisson1d(weight_dir, result_dir, device, dtype)
+    if "2d" in selected_cases:
+        infer_poisson2d(
+            weight_dir,
+            result_dir,
+            device,
+            dtype,
+            float(config["poisson2d"]["a"]),
+        )
+    if "burgers" in selected_cases:
+        infer_burgers(weight_dir, result_dir, data_path, device, dtype)
+
+
+if __name__ == "__main__":
+    main()

scripts/train.py

@@ -0,0 +1,495 @@
+from __future__ import annotations
+
+import argparse
+import os
+import sys
+import time
+from pathlib import Path
+
+import numpy as np
+import torch
+import yaml
+
+
+PROJECT_ROOT = Path(__file__).resolve().parents[1]
+sys.path.insert(0, str(PROJECT_ROOT))
+
+from model.gpinn import (  # noqa: E402
+    burgers_gpinn_terms,
+    burgers_residual,
+    exact_poisson1d,
+    exact_poisson2d,
+    gPINN,
+    gPINNBurgers,
+    gPINNPoisson2D,
+    gpinn_loss_poisson1d,
+    gpinn_loss_poisson2d,
+)
+
+
+DEFAULT_CONFIG = PROJECT_ROOT / "conf" / "config.yaml"
+CASES = ("1d", "2d", "burgers")
+
+
+def load_config(path: Path) -> dict:
+    with path.open("r", encoding="utf-8") as stream:
+        config = yaml.safe_load(stream)
+    if not isinstance(config, dict) or "root" not in config:
+        raise ValueError(f"config must contain a 'root' mapping: {path}")
+    return config["root"]
+
+
+def project_path(value: str | Path) -> Path:
+    path = Path(value).expanduser()
+    return path if path.is_absolute() else PROJECT_ROOT / path
+
+
+def resolve_device(requested: str) -> torch.device:
+    if requested == "auto":
+        return torch.device("cuda" if torch.cuda.is_available() else "cpu")
+    device = torch.device(requested)
+    if device.type == "cuda" and not torch.cuda.is_available():
+        raise RuntimeError("CUDA/DCU was requested but torch.cuda.is_available() is false")
+    return device
+
+
+def resolve_dtype(name: str) -> torch.dtype:
+    try:
+        return {"float32": torch.float32, "float64": torch.float64}[name]
+    except KeyError as error:
+        raise ValueError(f"unsupported dtype: {name}") from error
+
+
+def seed_everything(seed: int) -> None:
+    np.random.seed(seed)
+    torch.manual_seed(seed)
+    if torch.cuda.is_available():
+        torch.cuda.manual_seed_all(seed)
+
+
+def ensure_finite(loss: torch.Tensor, case: str, step: int) -> None:
+    if not torch.isfinite(loss):
+        raise FloatingPointError(f"{case} loss became non-finite at step {step}")
+
+
+def save_checkpoint(weight_dir: Path, filename: str, payload: dict) -> Path:
+    weight_dir.mkdir(parents=True, exist_ok=True)
+    checkpoint_path = weight_dir / filename
+    torch.save(payload, checkpoint_path)
+    print(f"Saved checkpoint: {checkpoint_path}")
+    return checkpoint_path
+
+
+def train_poisson1d(
+    config: dict,
+    device: torch.device,
+    dtype: torch.dtype,
+    weight_dir: Path,
+    epochs_override: int | None,
+    nf_override: int | None,
+    lbfgs_override: int | None,
+) -> None:
+    layers = [int(value) for value in config["layers"]]
+    nf = nf_override if nf_override is not None else int(config["nf"])
+    epochs = epochs_override if epochs_override is not None else int(config["epochs"])
+    lbfgs_iters = (
+        lbfgs_override if lbfgs_override is not None else int(config["lbfgs_iters"])
+    )
+    log_every = int(config["log_every"])
+
+    interior = torch.linspace(0.0, np.pi, nf, dtype=dtype, device=device).unsqueeze(-1)
+    boundary = torch.tensor([[0.0], [np.pi]], dtype=dtype, device=device)
+    boundary_values = boundary.clone()
+    test_x = torch.linspace(0.0, np.pi, 1000, dtype=dtype, device=device).unsqueeze(-1)
+    exact = torch.as_tensor(
+        exact_poisson1d(test_x.detach().cpu().numpy().reshape(-1)),
+        dtype=dtype,
+        device=device,
+    ).unsqueeze(-1)
+
+    model = gPINN(layers).to(device=device, dtype=dtype)
+    optimizer = torch.optim.Adam(model.parameters(), lr=float(config["lr"]))
+    scheduler = torch.optim.lr_scheduler.StepLR(optimizer, step_size=5000, gamma=0.5)
+    started = time.time()
+    print(
+        f"[1D] device={device} nf={nf} epochs={epochs} "
+        f"lbfgs_iters={lbfgs_iters}"
+    )
+
+    for step in range(1, epochs + 1):
+        loss, parts = gpinn_loss_poisson1d(
+            model, interior, boundary, boundary_values, float(config["w_g"])
+        )
+        ensure_finite(loss, "1D Poisson", step)
+        optimizer.zero_grad(set_to_none=True)
+        loss.backward()
+        optimizer.step()
+        scheduler.step()
+        if step == 1 or step % log_every == 0 or step == epochs:
+            with torch.no_grad():
+                relative_l2 = torch.linalg.vector_norm(model(test_x) - exact) / torch.linalg.vector_norm(
+                    exact
+                )
+            print(
+                f"[1D] step={step:5d} loss={loss.item():.3e} "
+                f"residual={parts['residual']:.3e} boundary={parts['boundary']:.3e} "
+                f"gradient={parts['gradient']:.3e} l2={relative_l2.item():.3e}"
+            )
+
+    if lbfgs_iters > 0:
+        lbfgs = torch.optim.LBFGS(
+            model.parameters(),
+            lr=1.0,
+            max_iter=lbfgs_iters,
+            line_search_fn="strong_wolfe",
+        )
+
+        def closure() -> torch.Tensor:
+            lbfgs.zero_grad(set_to_none=True)
+            closure_loss, _ = gpinn_loss_poisson1d(
+                model, interior, boundary, boundary_values, float(config["w_g"])
+            )
+            ensure_finite(closure_loss, "1D Poisson L-BFGS", 0)
+            closure_loss.backward()
+            return closure_loss
+
+        lbfgs.step(closure)
+
+    with torch.no_grad():
+        relative_l2 = torch.linalg.vector_norm(model(test_x) - exact) / torch.linalg.vector_norm(exact)
+    print(f"[1D] finished in {time.time() - started:.1f}s, relative L2={relative_l2.item():.6e}")
+    save_checkpoint(
+        weight_dir,
+        "gpinn_poisson1d.pt",
+        {
+            "case": "1d",
+            "architecture": "gpinn",
+            "model_state": model.state_dict(),
+            "layers": layers,
+            "nf": nf,
+            "w_g": float(config["w_g"]),
+        },
+    )
+
+
+def train_poisson2d(
+    config: dict,
+    device: torch.device,
+    dtype: torch.dtype,
+    weight_dir: Path,
+    epochs_override: int | None,
+    nf_override: int | None,
+) -> None:
+    layers = [int(value) for value in config["layers"]]
+    nf = nf_override if nf_override is not None else int(config["nf"])
+    epochs = epochs_override if epochs_override is not None else int(config["epochs"])
+    exponent = float(config["a"])
+    log_every = int(config["log_every"])
+
+    interior = torch.rand(nf, 2, dtype=dtype, device=device)
+    model = gPINNPoisson2D(layers).to(device=device, dtype=dtype)
+    optimizer = torch.optim.Adam(model.parameters(), lr=float(config["lr"]))
+    scheduler = torch.optim.lr_scheduler.StepLR(optimizer, step_size=5000, gamma=0.5)
+    started = time.time()
+    print(f"[2D] device={device} nf={nf} epochs={epochs} a={exponent:g}")
+
+    for step in range(1, epochs + 1):
+        loss, parts = gpinn_loss_poisson2d(
+            model, interior, float(config["w_g"]), exponent
+        )
+        ensure_finite(loss, "2D Poisson", step)
+        optimizer.zero_grad(set_to_none=True)
+        loss.backward()
+        optimizer.step()
+        scheduler.step()
+        if step == 1 or step % log_every == 0 or step == epochs:
+            print(
+                f"[2D] step={step:5d} loss={loss.item():.3e} "
+                f"residual={parts['residual']:.3e} gradient={parts['gradient']:.3e}"
+            )
+
+    axis = np.linspace(0.0, 1.0, 100)
+    grid_x, grid_y = np.meshgrid(axis, axis)
+    test_coordinates = torch.as_tensor(
+        np.column_stack([grid_x.ravel(), grid_y.ravel()]), dtype=dtype, device=device
+    )
+    with torch.no_grad():
+        prediction = model(test_coordinates).cpu().numpy().reshape(grid_x.shape)
+    exact = exact_poisson2d(grid_x, grid_y, exponent)
+    relative_l2 = np.linalg.norm(prediction.ravel() - exact.ravel()) / np.linalg.norm(
+        exact.ravel()
+    )
+    print(f"[2D] finished in {time.time() - started:.1f}s, relative L2={relative_l2:.6e}")
+    save_checkpoint(
+        weight_dir,
+        "gpinn_poisson2d.pt",
+        {
+            "case": "2d",
+            "architecture": "poisson2d_hard_bc",
+            "model_state": model.state_dict(),
+            "layers": layers,
+            "a": exponent,
+            "nf": nf,
+            "w_g": float(config["w_g"]),
+        },
+    )
+
+
+def load_burgers_reference(
+    data_path: Path, device: torch.device, dtype: torch.dtype
+) -> tuple[torch.Tensor, torch.Tensor]:
+    if not data_path.is_file():
+        raise FileNotFoundError(f"Burgers data not found: {data_path}")
+    with np.load(data_path) as data:
+        missing = {"t", "x", "usol"}.difference(data.files)
+        if missing:
+            raise ValueError(f"Burgers data is missing arrays: {sorted(missing)}")
+        time_axis = np.asarray(data["t"]).reshape(-1)
+        space_axis = np.asarray(data["x"]).reshape(-1)
+        exact = np.asarray(data["usol"])
+    expected_shape = (space_axis.size, time_axis.size)
+    if exact.shape != expected_shape:
+        raise ValueError(f"usol shape must be {expected_shape}, got {exact.shape}")
+    time_grid, space_grid = np.meshgrid(time_axis, space_axis)
+    coordinates = torch.as_tensor(
+        np.column_stack([space_grid.ravel(), time_grid.ravel()]),
+        dtype=dtype,
+        device=device,
+    )
+    values = torch.as_tensor(exact.reshape(-1, 1), dtype=dtype, device=device)
+    return coordinates, values
+
+
+def burgers_boundary_points(
+    device: torch.device, dtype: torch.dtype
+) -> tuple[torch.Tensor, torch.Tensor, torch.Tensor]:
+    boundary = torch.cat(
+        [
+            torch.cat(
+                [
+                    torch.full((100, 1), -1.0, dtype=dtype, device=device),
+                    torch.rand(100, 1, dtype=dtype, device=device),
+                ],
+                dim=1,
+            ),
+            torch.cat(
+                [
+                    torch.full((100, 1), 1.0, dtype=dtype, device=device),
+                    torch.rand(100, 1, dtype=dtype, device=device),
+                ],
+                dim=1,
+            ),
+        ]
+    )
+    initial = torch.cat(
+        [
+            torch.linspace(-1.0, 1.0, 200, dtype=dtype, device=device).unsqueeze(-1),
+            torch.zeros(200, 1, dtype=dtype, device=device),
+        ],
+        dim=1,
+    )
+    initial_values = -torch.sin(torch.pi * initial[:, 0:1])
+    return boundary, initial, initial_values
+
+
+def add_rar_points(
+    model: torch.nn.Module,
+    config: dict,
+    device: torch.device,
+    dtype: torch.dtype,
+) -> torch.Tensor:
+    candidate_count = int(config["rar_candidate_points"])
+    batch_size = int(config["rar_candidate_batch_size"])
+    add_count = int(config["rar_add_points"])
+    if min(candidate_count, batch_size, add_count) <= 0:
+        raise ValueError("RAR point counts must be positive")
+
+    shortlisted_points = []
+    shortlisted_residuals = []
+    was_training = model.training
+    model.eval()
+    for start in range(0, candidate_count, batch_size):
+        current_size = min(batch_size, candidate_count - start)
+        candidates = torch.rand(current_size, 2, dtype=dtype, device=device)
+        candidates[:, 0] = 2.0 * candidates[:, 0] - 1.0
+        residual, inputs = burgers_residual(model, candidates, create_graph=False)
+        count = min(add_count, current_size)
+        values, indices = torch.topk(residual.detach().abs().reshape(-1), count)
+        shortlisted_points.append(inputs.detach()[indices])
+        shortlisted_residuals.append(values)
+    if was_training:
+        model.train()
+
+    residuals = torch.cat(shortlisted_residuals)
+    points = torch.cat(shortlisted_points)
+    final_count = min(add_count, residuals.numel())
+    indices = torch.topk(residuals, final_count).indices
+    return points[indices].detach()
+
+
+def train_burgers(
+    config: dict,
+    device: torch.device,
+    dtype: torch.dtype,
+    weight_dir: Path,
+    data_path: Path,
+    epochs_override: int | None,
+    nf_override: int | None,
+    rar_override: int | None,
+    quick: bool,
+) -> None:
+    layers = [int(value) for value in config["layers"]]
+    nf = nf_override if nf_override is not None else int(config["nf"])
+    epochs = epochs_override if epochs_override is not None else int(config["epochs"])
+    rar_rounds = rar_override if rar_override is not None else int(config["rar_rounds"])
+    if quick:
+        rar_rounds = 0
+    log_every = int(config["log_every"])
+
+    collocation = torch.rand(nf, 2, dtype=dtype, device=device)
+    collocation[:, 0] = 2.0 * collocation[:, 0] - 1.0
+    reference_coordinates, reference_values = load_burgers_reference(data_path, device, dtype)
+    boundary, initial, initial_values = burgers_boundary_points(device, dtype)
+    model = gPINNBurgers(layers).to(device=device, dtype=dtype)
+    optimizer = torch.optim.Adam(model.parameters(), lr=float(config["lr"]))
+    scheduler = torch.optim.lr_scheduler.StepLR(optimizer, step_size=5000, gamma=0.5)
+    anchors: list[torch.Tensor] = []
+
+    def evaluate() -> float:
+        with torch.no_grad():
+            return (
+                torch.linalg.vector_norm(model(reference_coordinates) - reference_values)
+                / torch.linalg.vector_norm(reference_values)
+            ).item()
+
+    def optimization_step(points: torch.Tensor, step: int) -> tuple[torch.Tensor, dict[str, float]]:
+        residual, residual_x, residual_t = burgers_gpinn_terms(model, points)
+        residual_loss = torch.mean(residual.square())
+        boundary_loss = torch.mean(model(boundary).square()) + torch.mean(
+            (model(initial) - initial_values).square()
+        )
+        gradient_loss = torch.mean(residual_x.square()) + torch.mean(residual_t.square())
+        loss = residual_loss + boundary_loss + float(config["w_g"]) * gradient_loss
+        ensure_finite(loss, "Burgers", step)
+        optimizer.zero_grad(set_to_none=True)
+        loss.backward()
+        optimizer.step()
+        scheduler.step()
+        return loss, {
+            "residual": residual_loss.item(),
+            "boundary": boundary_loss.item(),
+            "gradient": gradient_loss.item(),
+        }
+
+    started = time.time()
+    print(f"[Burgers] device={device} nf={nf} epochs={epochs} rar_rounds={rar_rounds}")
+    for step in range(1, epochs + 1):
+        points = torch.cat([collocation, *anchors], dim=0)
+        loss, parts = optimization_step(points, step)
+        if step == 1 or step % log_every == 0 or step == epochs:
+            print(
+                f"[Burgers] step={step:5d} loss={loss.item():.3e} "
+                f"residual={parts['residual']:.3e} boundary={parts['boundary']:.3e} "
+                f"gradient={parts['gradient']:.3e} l2={evaluate():.3e}"
+            )
+
+    rar_epochs = int(config["rar_epochs"])
+    for round_index in range(1, rar_rounds + 1):
+        new_points = add_rar_points(model, config, device, dtype)
+        anchors.append(new_points)
+        points = torch.cat([collocation, *anchors], dim=0)
+        for rar_step in range(1, rar_epochs + 1):
+            optimization_step(points, epochs + (round_index - 1) * rar_epochs + rar_step)
+        print(
+            f"[Burgers] RAR round={round_index}/{rar_rounds} "
+            f"anchors={sum(item.shape[0] for item in anchors)} l2={evaluate():.3e}"
+        )
+
+    relative_l2 = evaluate()
+    print(
+        f"[Burgers] finished in {time.time() - started:.1f}s, "
+        f"relative L2={relative_l2:.6e}"
+    )
+    save_checkpoint(
+        weight_dir,
+        "gpinn_burgers.pt",
+        {
+            "case": "burgers",
+            "architecture": "burgers_hard_bc",
+            "model_state": model.state_dict(),
+            "layers": layers,
+            "nf": nf,
+            "w_g": float(config["w_g"]),
+            "rar_rounds": rar_rounds,
+        },
+    )
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(description="Train gPINN PDE examples")
+    parser.add_argument(
+        "--config",
+        type=Path,
+        default=Path(os.environ.get("GPINN_CONFIG", DEFAULT_CONFIG)),
+        help="YAML configuration file",
+    )
+    parser.add_argument("--case", choices=(*CASES, "all"), default="all")
+    parser.add_argument("--device", help="Override common.device, for example cpu or cuda:0")
+    parser.add_argument("--epochs", type=int, help="Override Adam iterations for selected cases")
+    parser.add_argument("--nf", type=int, help="Override collocation point count")
+    parser.add_argument("--lbfgs-iters", type=int, help="Override 1D Poisson L-BFGS iterations")
+    parser.add_argument("--rar-rounds", type=int, help="Override Burgers RAR rounds")
+    parser.add_argument("--quick", action="store_true", help="Skip Burgers RAR rounds")
+    parser.add_argument("--data", type=Path, help="Override Burgers.npz path")
+    parser.add_argument("--weight-dir", type=Path, help="Override checkpoint output directory")
+    return parser.parse_args()
+
+
+def main() -> None:
+    args = parse_args()
+    config_path = args.config.expanduser().resolve()
+    config = load_config(config_path)
+    common = config["common"]
+    device = resolve_device(args.device or str(common["device"]))
+    dtype = resolve_dtype(str(common["dtype"]))
+    weight_dir = project_path(args.weight_dir or common["weight_dir"])
+    data_path = project_path(args.data or config["burgers"]["data"])
+    seed_everything(int(common["seed"]))
+
+    print(f"Config: {config_path}")
+    selected_cases = CASES if args.case == "all" else (args.case,)
+    if "1d" in selected_cases:
+        train_poisson1d(
+            config["poisson1d"],
+            device,
+            dtype,
+            weight_dir,
+            args.epochs,
+            args.nf,
+            args.lbfgs_iters,
+        )
+    if "2d" in selected_cases:
+        train_poisson2d(
+            config["poisson2d"],
+            device,
+            dtype,
+            weight_dir,
+            args.epochs,
+            args.nf,
+        )
+    if "burgers" in selected_cases:
+        train_burgers(
+            config["burgers"],
+            device,
+            dtype,
+            weight_dir,
+            data_path,
+            args.epochs,
+            args.nf,
+            args.rar_rounds,
+            args.quick,
+        )
+
+
+if __name__ == "__main__":
+    main()

weight/gpinn_burgers.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:aeb01c61bba1d304e8d986605b18b9a99b113dc6cdbfe8abfa1d1d060af73b55
+size 22674

weight/gpinn_poisson1d.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e7d934849cd64c65ed87016db2175aef801e59113563ae21aa3e33b95636e403
+size 28161

weight/gpinn_poisson2d.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6aeb343877399cfa2f48ee4b48965d880009311bb4188471eb739a2bb2fbe8d9
+size 20210