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,133 @@
+---
+frameworks:
+  - pytorch
+language:
+  - en
+license: apache-2.0
+tags:
+  - OneScience
+  - SA-PINNs
+  - self-adaptive-physics-informed-neural-networks
+  - soft-attention
+  - partial-differential-equations
+  - Laplace
+  - Helmholtz
+  - Burgers
+tasks:
+  - pde-solving
+---
+<p align="center">
+  <strong>
+    <span style="font-size: 30px;">SA-PINNs</span>
+  </strong>
+</p>
+
+# Model Overview
+
+SA-PINNs (Self-Adaptive Physics-Informed Neural Networks) assign learnable positive attention weights to observation points, boundary points, and PDE collocation points, enabling the model to focus automatically on regions that are difficult to fit during training.
+
+This model package provides examples for the one-dimensional Laplace equation, the two-dimensional Helmholtz equation, and the one-dimensional time-dependent Burgers equation.
+
+Paper: Self-Adaptive Physics-Informed Neural Networks using a Soft Attention Mechanism  
+https://arxiv.org/abs/2009.04544
+
+# Model Description
+
+SA-PINNs use min–max saddle-point optimization: network parameters reduce the weighted physics loss through gradient descent, while attention parameters increase the weights assigned to difficult locations through gradient ascent. The attention weights are constructed from normalized `exp(alpha)`, ensuring that they remain positive with a mean close to 1. The Adam stage updates both the network and attention parameters, whereas the L-BFGS stage freezes the attention parameters and refines the network.
+
+# Use Cases
+
+| Use Case | Description |
+| :---: | :--- |
+| One-dimensional Laplace equation | Examine how attention focuses on collocation points with high residuals |
+| Two-dimensional Helmholtz equation | Solve a two-dimensional analytical solution with high-frequency spatial variation |
+| Burgers equation | Train jointly on initial conditions, boundary conditions, and nonlinear PDE residuals |
+| Adaptive-weight research | Compare a standard PINN with pointwise soft-attention weighting |
+
+# 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 small-scale pipeline validation.
+- DCU users must install DTK and a PyTorch environment compatible with the target cluster.
+
+### Download the Model Package
+
+```bash
+modelscope download --model OneScience/SA-PINNs --local_dir ./SA-PINNs
+cd SA-PINNs
+```
+
+### 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
+
+All three examples generate observation points, boundary points, and PDE collocation points from analytical equations and random sampling, with no dependency on external data files. The Burgers example does not include a reference solution and therefore outputs only the predicted field and attention distribution.
+
+### Training
+
+Select an example with `--case`:
+
+```bash
+python scripts/train.py --case laplace
+python scripts/train.py --case helmholtz
+python scripts/train.py --case burgers
+```
+
+Checkpoints and training histories are saved to `weight/` and `result/` by default. Command-line arguments such as `--epochs`, `--lbfgs-iters`, `--n-pde`, and `--device` can override values in `conf/config.yaml`.
+
+### Model Weights
+
+This repository provides weights trained for all three examples in the `weight/` directory.
+
+
+### Inference, Evaluation, and Visualization
+
+After training the selected example, run:
+
+```bash
+python scripts/inference.py --case laplace
+python scripts/inference.py --case helmholtz
+python scripts/inference.py --case burgers
+```
+
+Predictions, error plots, and PDE attention distributions are saved to the `result/` directory. The Laplace and Helmholtz examples report relative L2 errors. Default model and training parameters can 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
+
+- McClenny, L. and Braga-Neto, U. Self-Adaptive Physics-Informed Neural Networks using a Soft Attention Mechanism. arXiv:2009.04544, 2020.
+- This model package is released under the Apache-2.0 license and retains attribution to the original paper.

conf/config.yaml

@@ -0,0 +1,103 @@
+root:
+  common:
+    device: "auto"
+    dtype: "float64"
+    seed: 42
+    weight_dir: "weight"
+    result_dir: "result"
+
+  cases:
+    laplace:
+      model:
+        input_dim: 1
+        n_layers: 4
+        n_neurons: 50
+        activation: "tanh"
+      attention:
+        enabled: true
+        lr: 0.01
+      training:
+        epochs: 10000
+        lr: 0.001
+        lbfgs_iters: 2000
+        log_interval: 1000
+      loss:
+        data: 10.0
+        pde: 1.0
+        boundary: 10.0
+      data:
+        domain: [0.0, 1.0]
+        n_sol: 200
+        n_pde: 1000
+        n_bnd: 2
+        noise_std: 0.0
+        test_res: 200
+      output:
+        checkpoint_name: "sapinn_laplace.pt"
+        predictions_name: "sapinn_laplace.npz"
+        figure_name: "sapinn_laplace.png"
+        history_name: "sapinn_laplace_history.npz"
+
+    helmholtz:
+      model:
+        input_dim: 2
+        n_layers: 4
+        n_neurons: 50
+        activation: "tanh"
+      attention:
+        enabled: true
+        lr: 0.001
+      training:
+        epochs: 10000
+        lr: 0.001
+        lbfgs_iters: 5000
+        log_interval: 1000
+      loss:
+        data: 0.0
+        pde: 1.0
+        boundary: 10.0
+      data:
+        domain_x: [-1.0, 1.0]
+        domain_y: [-1.0, 1.0]
+        n_sol: 200
+        n_pde: 10000
+        n_bnd: 400
+        test_res: 100
+        wave_number: 1.0
+      output:
+        checkpoint_name: "sapinn_helmholtz.pt"
+        predictions_name: "sapinn_helmholtz.npz"
+        figure_name: "sapinn_helmholtz.png"
+        history_name: "sapinn_helmholtz_history.npz"
+
+    burgers:
+      model:
+        input_dim: 2
+        n_layers: 8
+        n_neurons: 20
+        activation: "tanh"
+      attention:
+        enabled: true
+        lr: 0.005
+      training:
+        epochs: 100
+        lr: 0.005
+        lbfgs_iters: 5000
+        log_interval: 10
+      loss:
+        data: 10.0
+        pde: 1.0
+        boundary: 10.0
+      data:
+        domain_x: [-1.0, 1.0]
+        domain_t: [0.0, 1.0]
+        n_sol: 100
+        n_pde: 10000
+        n_bnd: 50
+        test_res: 100
+        viscosity: 0.003183098861837907
+      output:
+        checkpoint_name: "sapinn_burgers.pt"
+        predictions_name: "sapinn_burgers.npz"
+        figure_name: "sapinn_burgers.png"
+        history_name: "sapinn_burgers_history.npz"

configuration.json

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

model/sa_pinn.py

@@ -0,0 +1,267 @@
+from __future__ import annotations
+
+import math
+from collections.abc import Mapping, Sequence
+
+import torch
+import torch.nn as nn
+
+
+class FCN(nn.Module):
+    """Fully connected network used by each SA-PINN case."""
+
+    def __init__(
+        self,
+        layer_sizes: Sequence[int],
+        activation: str = "tanh",
+        dtype: torch.dtype = torch.float64,
+    ) -> None:
+        super().__init__()
+        if len(layer_sizes) < 2:
+            raise ValueError("layer_sizes must include input and output widths")
+        if activation not in {"tanh", "sin", "sine", "relu", "gelu"}:
+            raise ValueError(f"unsupported activation: {activation}")
+        self.activation = "sin" if activation == "sine" else activation
+        stddev = math.sqrt(50.0 / layer_sizes[1])
+        self.linears = nn.ModuleList(
+            nn.Linear(layer_sizes[index], layer_sizes[index + 1], dtype=dtype)
+            for index in range(len(layer_sizes) - 1)
+        )
+        for linear in self.linears:
+            nn.init.trunc_normal_(
+                linear.weight,
+                mean=0.0,
+                std=stddev,
+                a=-2.0 * stddev,
+                b=2.0 * stddev,
+            )
+            nn.init.zeros_(linear.bias)
+
+    def _activate(self, values: torch.Tensor) -> torch.Tensor:
+        if self.activation == "gelu":
+            return torch.nn.functional.gelu(values)
+        return getattr(torch, self.activation)(values)
+
+    def forward(self, inputs: torch.Tensor) -> torch.Tensor:
+        hidden = inputs
+        for linear in self.linears[:-1]:
+            hidden = self._activate(linear(hidden))
+        return self.linears[-1](hidden)
+
+
+class AttentionWeights(nn.Module):
+    """Positive, normalized, per-point self-adaptive loss weights."""
+
+    def __init__(
+        self,
+        n_points: int,
+        dtype: torch.dtype = torch.float64,
+        initial_value: float = 0.0,
+    ) -> None:
+        super().__init__()
+        if n_points <= 0:
+            raise ValueError("attention requires a positive point count")
+        self.alpha = nn.Parameter(
+            torch.full((n_points, 1), initial_value, dtype=dtype)
+        )
+
+    def forward(self) -> torch.Tensor:
+        shifted = self.alpha - self.alpha.detach().max()
+        weights = torch.exp(shifted)
+        weights = weights / (weights.mean() + torch.finfo(weights.dtype).eps)
+        return torch.clamp(weights, min=1.0e-2, max=100.0)
+
+
+class SAPINN(nn.Module):
+    """Self-adaptive PINN with separate attention weights for each loss group."""
+
+    def __init__(
+        self,
+        input_dim: int,
+        n_layers: int,
+        n_neurons: int,
+        activation: str,
+        n_pde: int,
+        n_data: int,
+        n_boundary: int,
+        attention_enabled: bool = True,
+        dtype: torch.dtype = torch.float64,
+    ) -> None:
+        super().__init__()
+        if min(input_dim, n_layers, n_neurons) <= 0:
+            raise ValueError("model dimensions must be positive")
+        self.net = FCN(
+            [input_dim, *([n_neurons] * n_layers), 1],
+            activation=activation,
+            dtype=dtype,
+        )
+        self.att_pde = (
+            AttentionWeights(n_pde, dtype=dtype) if attention_enabled and n_pde else None
+        )
+        self.att_data = (
+            AttentionWeights(n_data, dtype=dtype) if attention_enabled and n_data else None
+        )
+        self.att_boundary = (
+            AttentionWeights(n_boundary, dtype=dtype)
+            if attention_enabled and n_boundary
+            else None
+        )
+
+    def forward(self, inputs: torch.Tensor) -> torch.Tensor:
+        return self.net(inputs)
+
+    def network_parameters(self):
+        return self.net.parameters()
+
+    def attention_parameters(self):
+        for attention in (self.att_pde, self.att_data, self.att_boundary):
+            if attention is not None:
+                yield from attention.parameters()
+
+    def set_attention_trainable(self, trainable: bool) -> None:
+        for parameter in self.attention_parameters():
+            parameter.requires_grad_(trainable)
+
+
+def build_model(
+    model_config: Mapping,
+    point_counts: Mapping[str, int],
+    attention_enabled: bool,
+    dtype: torch.dtype,
+) -> SAPINN:
+    return SAPINN(
+        input_dim=int(model_config["input_dim"]),
+        n_layers=int(model_config["n_layers"]),
+        n_neurons=int(model_config["n_neurons"]),
+        activation=str(model_config["activation"]),
+        n_pde=int(point_counts["pde"]),
+        n_data=int(point_counts["data"]),
+        n_boundary=int(point_counts["boundary"]),
+        attention_enabled=attention_enabled,
+        dtype=dtype,
+    )
+
+
+class Equation:
+    def residual(
+        self, model: SAPINN, coordinates: torch.Tensor
+    ) -> torch.Tensor:
+        raise NotImplementedError
+
+
+class Laplace1D(Equation):
+    def __init__(self, diffusion: float = 1.0) -> None:
+        self.diffusion = diffusion
+
+    def residual(self, model: SAPINN, coordinates: torch.Tensor) -> torch.Tensor:
+        inputs = coordinates.detach().requires_grad_(True)
+        prediction = model(inputs)
+        first = torch.autograd.grad(
+            prediction, inputs, torch.ones_like(prediction), create_graph=True
+        )[0]
+        second = torch.autograd.grad(
+            first, inputs, torch.ones_like(first), create_graph=True
+        )[0]
+        source = torch.pi**2 * torch.sin(torch.pi * inputs)
+        return self.diffusion * second + source
+
+
+class Helmholtz2D(Equation):
+    def __init__(self, wave_number: float = 1.0) -> None:
+        self.wave_number = wave_number
+
+    def residual(self, model: SAPINN, coordinates: torch.Tensor) -> torch.Tensor:
+        inputs = coordinates.detach().requires_grad_(True)
+        prediction = model(inputs)
+        gradient = torch.autograd.grad(
+            prediction, inputs, torch.ones_like(prediction), create_graph=True
+        )[0]
+        prediction_xx = torch.autograd.grad(
+            gradient[:, 0:1],
+            inputs,
+            torch.ones_like(gradient[:, 0:1]),
+            create_graph=True,
+        )[0][:, 0:1]
+        prediction_yy = torch.autograd.grad(
+            gradient[:, 1:2],
+            inputs,
+            torch.ones_like(gradient[:, 1:2]),
+            create_graph=True,
+        )[0][:, 1:2]
+        exact = torch.sin(torch.pi * inputs[:, 0:1]) * torch.sin(
+            4.0 * torch.pi * inputs[:, 1:2]
+        )
+        forcing = (
+            -torch.pi**2 - (4.0 * torch.pi) ** 2 + self.wave_number**2
+        ) * exact
+        return (
+            prediction_xx
+            + prediction_yy
+            + self.wave_number**2 * prediction
+            - forcing
+        )
+
+
+class Burgers2D(Equation):
+    def __init__(self, viscosity: float = 0.01 / math.pi) -> None:
+        self.viscosity = viscosity
+
+    def residual(self, model: SAPINN, coordinates: torch.Tensor) -> torch.Tensor:
+        inputs = coordinates.detach().requires_grad_(True)
+        prediction = model(inputs)
+        gradient = torch.autograd.grad(
+            prediction, inputs, torch.ones_like(prediction), create_graph=True
+        )[0]
+        prediction_x = gradient[:, 0:1]
+        prediction_t = gradient[:, 1:2]
+        prediction_xx = torch.autograd.grad(
+            prediction_x,
+            inputs,
+            torch.ones_like(prediction_x),
+            create_graph=True,
+        )[0][:, 0:1]
+        return (
+            prediction_t
+            + prediction * prediction_x
+            - self.viscosity * prediction_xx
+        )
+
+
+def weighted_mean_square(
+    residual: torch.Tensor, attention: AttentionWeights | None
+) -> torch.Tensor:
+    if attention is None:
+        return torch.mean(residual.square())
+    weights = attention()
+    if weights.shape != residual.shape:
+        raise ValueError(
+            f"attention shape {tuple(weights.shape)} does not match residual {tuple(residual.shape)}"
+        )
+    return torch.mean(weights * residual.square())
+
+
+def loss_components(
+    model: SAPINN,
+    equation: Equation,
+    tensors: Mapping[str, torch.Tensor],
+) -> dict[str, torch.Tensor]:
+    pde_residual = equation.residual(model, tensors["x_pde"])
+    boundary_residual = model(tensors["x_boundary"]) - tensors["u_boundary"]
+    if tensors.get("x_data") is not None:
+        data_residual = model(tensors["x_data"]) - tensors["u_data"]
+        data_loss = weighted_mean_square(data_residual, model.att_data)
+    else:
+        data_loss = torch.zeros((), dtype=pde_residual.dtype, device=pde_residual.device)
+    return {
+        "data": data_loss,
+        "boundary": weighted_mean_square(boundary_residual, model.att_boundary),
+        "pde": weighted_mean_square(pde_residual, model.att_pde),
+    }
+
+
+def weighted_loss(components: Mapping[str, torch.Tensor], weights: Mapping) -> torch.Tensor:
+    return (
+        float(weights["data"]) * components["data"]
+        + float(weights["boundary"]) * components["boundary"]
+        + float(weights["pde"]) * components["pde"]
+    )

result/sapinn_burgers_history.npz

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

result/sapinn_helmholtz_history.npz

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

result/sapinn_laplace_history.npz

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

scripts/common.py

@@ -0,0 +1,54 @@
+from __future__ import annotations
+
+import random
+from collections.abc import Mapping
+from pathlib import Path
+
+import numpy as np
+import torch
+import yaml
+
+
+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, project_root: 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:
+    random.seed(seed)
+    np.random.seed(seed)
+    torch.manual_seed(seed)
+    if torch.cuda.is_available():
+        torch.cuda.manual_seed_all(seed)
+
+
+def checkpoint_state(checkpoint: Mapping) -> tuple[Mapping[str, torch.Tensor], dict]:
+    if "model_state" in checkpoint:
+        return checkpoint["model_state"], dict(checkpoint)
+    if checkpoint and all(torch.is_tensor(value) for value in checkpoint.values()):
+        return checkpoint, {}
+    raise ValueError("checkpoint contains no valid SA-PINN model state")

scripts/inference.py

@@ -0,0 +1,241 @@
+from __future__ import annotations
+
+import argparse
+import os
+import sys
+from collections.abc import Mapping
+from pathlib import Path
+
+import matplotlib
+
+matplotlib.use("Agg")
+import matplotlib.pyplot as plt
+import numpy as np
+import torch
+
+
+PROJECT_ROOT = Path(__file__).resolve().parents[1]
+sys.path.insert(0, str(PROJECT_ROOT))
+sys.path.insert(0, str(Path(__file__).resolve().parent))
+
+from common import (  # noqa: E402
+    checkpoint_state,
+    load_config,
+    project_path,
+    resolve_device,
+    resolve_dtype,
+)
+from model.sa_pinn import build_model  # noqa: E402
+from problems import CASES, generate_data, point_counts, relative_l2, to_tensors  # noqa: E402
+
+
+DEFAULT_CONFIG = PROJECT_ROOT / "conf" / "config.yaml"
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(description="Run SA-PINNs inference and visualization")
+    parser.add_argument(
+        "--config",
+        type=Path,
+        default=Path(os.environ.get("SAPINN_CONFIG", DEFAULT_CONFIG)),
+        help="YAML configuration file",
+    )
+    parser.add_argument("--case", choices=CASES, default="laplace")
+    parser.add_argument("--device", help="Override common.device")
+    parser.add_argument("--checkpoint", type=Path, help="Checkpoint path")
+    parser.add_argument("--weight-dir", type=Path, help="Override weight directory")
+    parser.add_argument("--result-dir", type=Path, help="Override result directory")
+    parser.add_argument("--test-res", type=int, help="Override test resolution per axis")
+    return parser.parse_args()
+
+
+def save_figure(
+    case: str,
+    data: Mapping,
+    prediction: np.ndarray,
+    attention: np.ndarray | None,
+    output_path: Path,
+    error: float | None,
+) -> None:
+    if case == "laplace":
+        exact = data["u_exact"].reshape(-1)
+        predicted = prediction.reshape(-1)
+        x_axis = data["x_test"].reshape(-1)
+        figure, axes = plt.subplots(1, 3, figsize=(15, 4))
+        axes[0].plot(x_axis, exact, "k-", label="Exact")
+        axes[0].plot(x_axis, predicted, "r--", label="SA-PINN")
+        axes[0].set_xlabel("x")
+        axes[0].set_ylabel("u")
+        axes[0].legend()
+        axes[1].semilogy(
+            x_axis, np.maximum(np.abs(predicted - exact), 1.0e-16), "r-"
+        )
+        axes[1].set_xlabel("x")
+        axes[1].set_ylabel("Absolute error")
+        if attention is not None:
+            order = np.argsort(data["x_pde"].reshape(-1))
+            axes[2].plot(
+                data["x_pde"].reshape(-1)[order],
+                attention.reshape(-1)[order],
+                "b-",
+            )
+            axes[2].set_xlabel("x")
+            axes[2].set_ylabel("Attention weight")
+        else:
+            axes[2].text(0.5, 0.5, "Attention disabled", ha="center", va="center")
+            axes[2].set_axis_off()
+    elif case == "helmholtz":
+        shape = data["test_shape"]
+        exact = data["u_exact"].reshape(shape)
+        predicted = prediction.reshape(shape)
+        figure, axes = plt.subplots(1, 3, figsize=(15, 4))
+        for axis, title, field in zip(
+            axes,
+            ("Exact", "SA-PINN", "Absolute error"),
+            (exact, predicted, np.abs(predicted - exact)),
+            strict=True,
+        ):
+            image = axis.imshow(field, extent=(-1, 1, -1, 1), origin="lower", cmap="jet")
+            axis.set_title(title)
+            axis.set_xlabel("x")
+            axis.set_ylabel("y")
+            figure.colorbar(image, ax=axis)
+    else:
+        shape = data["test_shape"]
+        predicted = prediction.reshape(shape)
+        figure, axes = plt.subplots(1, 2, figsize=(12, 4))
+        image = axes[0].imshow(
+            predicted,
+            extent=(-1, 1, 0, 1),
+            origin="lower",
+            aspect="auto",
+            cmap="jet",
+        )
+        axes[0].set_title("SA-PINN Burgers prediction")
+        axes[0].set_xlabel("x")
+        axes[0].set_ylabel("t")
+        figure.colorbar(image, ax=axes[0])
+        if attention is not None:
+            scatter = axes[1].scatter(
+                data["x_pde"][:, 0],
+                data["x_pde"][:, 1],
+                c=attention.reshape(-1),
+                s=8,
+                cmap="viridis",
+            )
+            axes[1].set_title("PDE attention weights")
+            axes[1].set_xlabel("x")
+            axes[1].set_ylabel("t")
+            figure.colorbar(scatter, ax=axes[1])
+        else:
+            axes[1].text(0.5, 0.5, "Attention disabled", ha="center", va="center")
+            axes[1].set_axis_off()
+    figure.suptitle(f"{case} | L2={'N/A' if error is None else f'{error:.3e}'}")
+    figure.tight_layout()
+    figure.savefig(output_path, dpi=150)
+    plt.close(figure)
+
+
+def main() -> None:
+    args = parse_args()
+    config_path = args.config.expanduser().resolve()
+    config = load_config(config_path)
+    common = config["common"]
+    case_config = config["cases"][args.case]
+    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"], PROJECT_ROOT)
+    result_dir = project_path(args.result_dir or common["result_dir"], PROJECT_ROOT)
+    checkpoint_path = (
+        project_path(args.checkpoint, PROJECT_ROOT)
+        if args.checkpoint
+        else weight_dir / case_config["output"]["checkpoint_name"]
+    )
+    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, Mapping):
+        raise ValueError(f"invalid SA-PINN checkpoint: {checkpoint_path}")
+    state, metadata = checkpoint_state(checkpoint)
+    checkpoint_case = metadata.get("case", args.case)
+    if checkpoint_case != args.case:
+        raise ValueError(
+            f"checkpoint case is {checkpoint_case}, but --case requested {args.case}"
+        )
+    model_config = metadata.get("model_config", case_config["model"])
+    data_config = dict(metadata.get("data_config", case_config["data"]))
+    if args.test_res is not None:
+        data_config["test_res"] = args.test_res
+    seed = int(metadata.get("seed", common["seed"]))
+    stored_counts = metadata.get("point_counts")
+    if stored_counts is None:
+        stored_counts = {
+            "pde": int(state["att_pde.alpha"].shape[0])
+            if "att_pde.alpha" in state
+            else int(data_config["n_pde"]),
+            "data": int(state["att_data.alpha"].shape[0])
+            if "att_data.alpha" in state
+            else int(data_config["n_sol"]),
+            "boundary": int(state["att_boundary.alpha"].shape[0])
+            if "att_boundary.alpha" in state
+            else int(data_config["n_bnd"]),
+        }
+        data_config.update(
+            {
+                "n_pde": stored_counts["pde"],
+                "n_sol": stored_counts["data"],
+                "n_bnd": stored_counts["boundary"],
+            }
+        )
+    data = generate_data(args.case, data_config, seed)
+    counts = stored_counts or point_counts(data)
+    attention_enabled = bool(
+        metadata.get(
+            "attention_enabled", any(key.startswith("att_") for key in state)
+        )
+    )
+    model = build_model(model_config, counts, attention_enabled, dtype).to(
+        device=device, dtype=dtype
+    )
+    model.load_state_dict(state, strict=True)
+    model.eval()
+    tensors = to_tensors(data, device, dtype)
+    with torch.no_grad():
+        prediction = model(tensors["x_test"]).cpu().numpy()
+    error = relative_l2(prediction, data["u_exact"])
+    attention = (
+        model.att_pde().detach().cpu().numpy() if model.att_pde is not None else None
+    )
+
+    result_dir.mkdir(parents=True, exist_ok=True)
+    predictions_path = result_dir / case_config["output"]["predictions_name"]
+    figure_path = result_dir / case_config["output"]["figure_name"]
+    np.savez_compressed(
+        predictions_path,
+        coordinates=data["x_test"],
+        prediction=prediction,
+        exact=np.array([]) if data["u_exact"] is None else data["u_exact"],
+        relative_l2=np.nan if error is None else error,
+        pde_attention=np.array([]) if attention is None else attention,
+    )
+    save_figure(args.case, data, prediction, attention, figure_path, error)
+
+    print(f"Config: {config_path}")
+    print(f"Case: {args.case}")
+    print(f"Checkpoint: {checkpoint_path}")
+    print(f"Device: {device}")
+    print(f"Relative L2={'N/A' if error is None else f'{error:.6e}'}")
+    if attention is not None:
+        print(
+            f"PDE attention: mean={attention.mean():.6f}, "
+            f"std={attention.std():.6f}, min={attention.min():.6f}, "
+            f"max={attention.max():.6f}"
+        )
+    print(f"Predictions: {predictions_path}")
+    print(f"Plot: {figure_path}")
+
+
+if __name__ == "__main__":
+    main()

scripts/problems.py

@@ -0,0 +1,167 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+
+import numpy as np
+import torch
+
+from model.sa_pinn import Burgers2D, Equation, Helmholtz2D, Laplace1D
+
+
+CASES = ("laplace", "helmholtz", "burgers")
+
+
+def exact_solution(case: str, coordinates: np.ndarray) -> np.ndarray | None:
+    if case == "laplace":
+        return np.sin(np.pi * coordinates[:, 0:1])
+    if case == "helmholtz":
+        return np.sin(np.pi * coordinates[:, 0:1]) * np.sin(
+            4.0 * np.pi * coordinates[:, 1:2]
+        )
+    if case == "burgers":
+        return None
+    raise ValueError(f"unsupported case: {case}")
+
+
+def build_equation(case: str, data_config: Mapping) -> Equation:
+    if case == "laplace":
+        return Laplace1D()
+    if case == "helmholtz":
+        return Helmholtz2D(float(data_config["wave_number"]))
+    if case == "burgers":
+        return Burgers2D(float(data_config["viscosity"]))
+    raise ValueError(f"unsupported case: {case}")
+
+
+def generate_data(case: str, config: Mapping, seed: int) -> dict[str, np.ndarray | None]:
+    generator = np.random.default_rng(seed)
+    n_pde = int(config["n_pde"])
+    n_solution = int(config["n_sol"])
+    n_boundary = int(config["n_bnd"])
+    test_resolution = int(config["test_res"])
+    if min(n_pde, n_solution, n_boundary, test_resolution) <= 0:
+        raise ValueError("all data counts must be positive")
+
+    if case == "laplace":
+        lower, upper = map(float, config["domain"])
+        x_pde = generator.uniform(lower, upper, (n_pde, 1))
+        x_boundary = np.array([[lower], [upper]], dtype=np.float64)
+        u_boundary = exact_solution(case, x_boundary)
+        x_data = np.linspace(lower, upper, n_solution)[:, None]
+        u_data = exact_solution(case, x_data)
+        noise_std = float(config.get("noise_std", 0.0))
+        if noise_std:
+            u_data = u_data + noise_std * generator.standard_normal(u_data.shape)
+        x_test = np.linspace(lower, upper, test_resolution)[:, None]
+        test_shape = (test_resolution,)
+    elif case == "helmholtz":
+        x_lower, x_upper = map(float, config["domain_x"])
+        y_lower, y_upper = map(float, config["domain_y"])
+        x_pde = np.column_stack(
+            (
+                generator.uniform(x_lower, x_upper, n_pde),
+                generator.uniform(y_lower, y_upper, n_pde),
+            )
+        )
+        if n_boundary < 4 or n_boundary % 4:
+            raise ValueError("Helmholtz n_bnd must be divisible by 4 and at least 4")
+        per_edge = n_boundary // 4
+        x_axis = np.linspace(x_lower, x_upper, per_edge)
+        y_axis = np.linspace(y_lower, y_upper, per_edge)
+        x_boundary = np.vstack(
+            (
+                np.column_stack((x_axis, np.full(per_edge, y_lower))),
+                np.column_stack((x_axis, np.full(per_edge, y_upper))),
+                np.column_stack((np.full(per_edge, x_lower), y_axis)),
+                np.column_stack((np.full(per_edge, x_upper), y_axis)),
+            )
+        )
+        u_boundary = exact_solution(case, x_boundary)
+        x_data = np.column_stack(
+            (
+                generator.uniform(x_lower, x_upper, n_solution),
+                generator.uniform(y_lower, y_upper, n_solution),
+            )
+        )
+        u_data = exact_solution(case, x_data)
+        grid_x = np.linspace(x_lower, x_upper, test_resolution)
+        grid_y = np.linspace(y_lower, y_upper, test_resolution)
+        mesh_x, mesh_y = np.meshgrid(grid_x, grid_y, indexing="xy")
+        x_test = np.column_stack((mesh_x.ravel(), mesh_y.ravel()))
+        test_shape = mesh_x.shape
+    elif case == "burgers":
+        x_lower, x_upper = map(float, config["domain_x"])
+        t_lower, t_upper = map(float, config["domain_t"])
+        x_pde = np.column_stack(
+            (
+                generator.uniform(x_lower, x_upper, n_pde),
+                generator.uniform(t_lower, t_upper, n_pde),
+            )
+        )
+        if n_boundary < 2:
+            raise ValueError("Burgers n_bnd must be at least 2")
+        left_count = n_boundary // 2
+        right_count = n_boundary - left_count
+        left_time = generator.uniform(t_lower, t_upper, left_count)
+        right_time = generator.uniform(t_lower, t_upper, right_count)
+        x_boundary = np.vstack(
+            (
+                np.column_stack((np.full(left_count, x_lower), left_time)),
+                np.column_stack((np.full(right_count, x_upper), right_time)),
+            )
+        )
+        u_boundary = np.zeros((n_boundary, 1))
+        initial_x = generator.uniform(x_lower, x_upper, n_solution)
+        x_data = np.column_stack((initial_x, np.full(n_solution, t_lower)))
+        u_data = -np.sin(np.pi * initial_x)[:, None]
+        grid_x = np.linspace(x_lower, x_upper, test_resolution)
+        grid_t = np.linspace(t_lower, t_upper, test_resolution)
+        mesh_x, mesh_t = np.meshgrid(grid_x, grid_t, indexing="xy")
+        x_test = np.column_stack((mesh_x.ravel(), mesh_t.ravel()))
+        test_shape = mesh_x.shape
+    else:
+        raise ValueError(f"unsupported case: {case}")
+
+    return {
+        "x_pde": np.asarray(x_pde, dtype=np.float64),
+        "x_boundary": np.asarray(x_boundary, dtype=np.float64),
+        "u_boundary": np.asarray(u_boundary, dtype=np.float64),
+        "x_data": np.asarray(x_data, dtype=np.float64),
+        "u_data": np.asarray(u_data, dtype=np.float64),
+        "x_test": np.asarray(x_test, dtype=np.float64),
+        "u_exact": exact_solution(case, np.asarray(x_test, dtype=np.float64)),
+        "test_shape": test_shape,
+    }
+
+
+def to_tensors(
+    data: Mapping[str, np.ndarray | None],
+    device: torch.device,
+    dtype: torch.dtype,
+) -> dict[str, torch.Tensor | None]:
+    return {
+        key: (
+            torch.as_tensor(value, dtype=dtype, device=device)
+            if isinstance(value, np.ndarray)
+            else None
+        )
+        for key, value in data.items()
+        if key != "test_shape"
+    }
+
+
+def point_counts(data: Mapping[str, np.ndarray | None]) -> dict[str, int]:
+    return {
+        "pde": int(data["x_pde"].shape[0]),
+        "boundary": int(data["x_boundary"].shape[0]),
+        "data": int(data["x_data"].shape[0]) if data.get("x_data") is not None else 0,
+    }
+
+
+def relative_l2(prediction: np.ndarray, reference: np.ndarray | None) -> float | None:
+    if reference is None:
+        return None
+    return float(
+        np.linalg.norm(prediction.reshape(-1) - reference.reshape(-1))
+        / (np.linalg.norm(reference.reshape(-1)) + 1.0e-12)
+    )

scripts/train.py

@@ -0,0 +1,234 @@
+from __future__ import annotations
+
+import argparse
+import os
+import sys
+import time
+from pathlib import Path
+
+import numpy as np
+import torch
+
+
+PROJECT_ROOT = Path(__file__).resolve().parents[1]
+sys.path.insert(0, str(PROJECT_ROOT))
+sys.path.insert(0, str(Path(__file__).resolve().parent))
+
+from common import (  # noqa: E402
+    load_config,
+    project_path,
+    resolve_device,
+    resolve_dtype,
+    seed_everything,
+)
+from model.sa_pinn import build_model, loss_components, weighted_loss  # noqa: E402
+from problems import (  # noqa: E402
+    CASES,
+    build_equation,
+    generate_data,
+    point_counts,
+    relative_l2,
+    to_tensors,
+)
+
+
+DEFAULT_CONFIG = PROJECT_ROOT / "conf" / "config.yaml"
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(description="Train a self-adaptive PINN")
+    parser.add_argument(
+        "--config",
+        type=Path,
+        default=Path(os.environ.get("SAPINN_CONFIG", DEFAULT_CONFIG)),
+        help="YAML configuration file",
+    )
+    parser.add_argument("--case", choices=CASES, default="laplace")
+    parser.add_argument("--device", help="Override common.device, for example cpu or cuda:0")
+    parser.add_argument("--seed", type=int, help="Override common.seed")
+    parser.add_argument("--epochs", type=int, help="Override Adam iterations")
+    parser.add_argument("--lr", type=float, help="Override network learning rate")
+    parser.add_argument("--attention-lr", type=float, help="Override attention learning rate")
+    parser.add_argument("--lbfgs-iters", type=int, help="Override L-BFGS iterations")
+    parser.add_argument("--n-sol", type=int, help="Override data or initial-condition points")
+    parser.add_argument("--n-pde", type=int, help="Override PDE collocation points")
+    parser.add_argument("--n-bnd", type=int, help="Override boundary points")
+    parser.add_argument("--test-res", type=int, help="Override test resolution per axis")
+    parser.add_argument("--weight-dir", type=Path, help="Override checkpoint output directory")
+    parser.add_argument("--result-dir", type=Path, help="Override history 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"]
+    case_config = config["cases"][args.case]
+    device = resolve_device(args.device or str(common["device"]))
+    dtype = resolve_dtype(str(common["dtype"]))
+    seed = args.seed if args.seed is not None else int(common["seed"])
+    epochs = (
+        args.epochs if args.epochs is not None else int(case_config["training"]["epochs"])
+    )
+    lbfgs_iters = (
+        args.lbfgs_iters
+        if args.lbfgs_iters is not None
+        else int(case_config["training"]["lbfgs_iters"])
+    )
+    network_lr = (
+        args.lr if args.lr is not None else float(case_config["training"]["lr"])
+    )
+    attention_lr = (
+        args.attention_lr
+        if args.attention_lr is not None
+        else float(case_config["attention"]["lr"])
+    )
+    if min(epochs, lbfgs_iters) < 0 or epochs + lbfgs_iters == 0:
+        raise ValueError("at least one optimizer iteration count must be positive")
+    if min(network_lr, attention_lr) <= 0:
+        raise ValueError("network and attention learning rates must be positive")
+
+    data_config = dict(case_config["data"])
+    for key, value in (
+        ("n_sol", args.n_sol),
+        ("n_pde", args.n_pde),
+        ("n_bnd", args.n_bnd),
+        ("test_res", args.test_res),
+    ):
+        if value is not None:
+            data_config[key] = value
+    weight_dir = project_path(args.weight_dir or common["weight_dir"], PROJECT_ROOT)
+    result_dir = project_path(args.result_dir or common["result_dir"], PROJECT_ROOT)
+    checkpoint_path = weight_dir / case_config["output"]["checkpoint_name"]
+    history_path = result_dir / case_config["output"]["history_name"]
+    seed_everything(seed)
+
+    data = generate_data(args.case, data_config, seed)
+    counts = point_counts(data)
+    tensors = to_tensors(data, device, dtype)
+    attention_enabled = bool(case_config["attention"]["enabled"])
+    model = build_model(
+        case_config["model"], counts, attention_enabled, dtype
+    ).to(device=device, dtype=dtype)
+    equation = build_equation(args.case, data_config)
+    parameter_count = sum(parameter.numel() for parameter in model.parameters())
+
+    print(f"Config: {config_path}")
+    print(f"Case: {args.case}")
+    print(f"Device: {device}")
+    print(f"Points: {counts}")
+    print(f"Parameters: {parameter_count:,}")
+
+    def loss_value() -> tuple[torch.Tensor, dict[str, torch.Tensor]]:
+        components = loss_components(model, equation, tensors)
+        return weighted_loss(components, case_config["loss"]), components
+
+    def evaluate() -> float | None:
+        with torch.no_grad():
+            prediction = model(tensors["x_test"]).cpu().numpy()
+        return relative_l2(prediction, data["u_exact"])
+
+    network_optimizer = torch.optim.Adam(model.network_parameters(), lr=network_lr)
+    attention_parameters = list(model.attention_parameters())
+    attention_optimizer = (
+        torch.optim.Adam(attention_parameters, lr=attention_lr)
+        if attention_parameters
+        else None
+    )
+    history = []
+    l2_history = []
+    log_interval = int(case_config["training"]["log_interval"])
+    started = time.time()
+    for epoch in range(1, epochs + 1):
+        network_optimizer.zero_grad(set_to_none=True)
+        if attention_optimizer is not None:
+            attention_optimizer.zero_grad(set_to_none=True)
+        loss, components = loss_value()
+        if not torch.isfinite(loss):
+            raise FloatingPointError(f"SA-PINN loss became non-finite at epoch {epoch}")
+        loss.backward()
+        network_optimizer.step()
+        if attention_optimizer is not None:
+            for parameter in attention_parameters:
+                if parameter.grad is not None:
+                    parameter.grad.neg_()
+            attention_optimizer.step()
+        history.append(loss.item())
+
+        if epoch == 1 or epoch % log_interval == 0 or epoch == epochs:
+            error = evaluate()
+            if error is not None:
+                l2_history.append((epoch, error))
+            attention = model.att_pde()
+            error_text = "N/A" if error is None else f"{error:.3e}"
+            print(
+                f"epoch={epoch:6d} loss={loss.item():.3e} "
+                f"data={components['data'].item():.3e} "
+                f"boundary={components['boundary'].item():.3e} "
+                f"pde={components['pde'].item():.3e} l2={error_text} "
+                f"attention_std={attention.std(unbiased=False).item():.3e}"
+            )
+
+    if lbfgs_iters > 0:
+        model.set_attention_trainable(False)
+        lbfgs = torch.optim.LBFGS(
+            model.network_parameters(),
+            lr=0.8,
+            max_iter=lbfgs_iters,
+            max_eval=max(1, 2 * lbfgs_iters),
+            tolerance_grad=1.0e-7,
+            tolerance_change=1.0e-9,
+            history_size=50,
+            line_search_fn="strong_wolfe",
+        )
+
+        def closure() -> torch.Tensor:
+            lbfgs.zero_grad(set_to_none=True)
+            closure_loss, _ = loss_value()
+            if not torch.isfinite(closure_loss):
+                raise FloatingPointError("SA-PINN L-BFGS loss became non-finite")
+            closure_loss.backward()
+            return closure_loss
+
+        lbfgs.step(closure)
+        model.set_attention_trainable(True)
+        error = evaluate()
+        if error is not None:
+            l2_history.append((epochs + lbfgs_iters, error))
+        print(f"L-BFGS L2={'N/A' if error is None else f'{error:.6e}'}")
+
+    final_l2 = evaluate()
+    elapsed = time.time() - started
+    weight_dir.mkdir(parents=True, exist_ok=True)
+    result_dir.mkdir(parents=True, exist_ok=True)
+    checkpoint = {
+        "case": args.case,
+        "architecture": "sa_pinn",
+        "model_state": model.state_dict(),
+        "model_config": case_config["model"],
+        "attention_enabled": attention_enabled,
+        "point_counts": counts,
+        "data_config": data_config,
+        "seed": seed,
+        "epochs": epochs,
+        "lbfgs_iters": lbfgs_iters,
+        "final_l2": final_l2,
+    }
+    torch.save(checkpoint, checkpoint_path)
+    l2_array = np.asarray(l2_history, dtype=np.float64).reshape(-1, 2)
+    np.savez_compressed(
+        history_path,
+        loss=np.asarray(history, dtype=np.float64),
+        l2_steps=l2_array[:, 0] if l2_array.size else np.array([]),
+        l2_values=l2_array[:, 1] if l2_array.size else np.array([]),
+        elapsed_seconds=elapsed,
+        final_l2=np.nan if final_l2 is None else final_l2,
+    )
+    print(f"Final L2={'N/A' if final_l2 is None else f'{final_l2:.6e}'}")
+    print(f"Saved checkpoint: {checkpoint_path}")
+    print(f"Saved history: {history_path}")
+
+
+if __name__ == "__main__":
+    main()

weight/sapinn_burgers.pt

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

weight/sapinn_helmholtz.pt

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

weight/sapinn_laplace.pt

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