Upload folder using huggingface_hub

.gitattributes

@@ -1,35 +1,49 @@
 *.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
+*.npz 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
+
+*.pt filter=lfs diff=lfs merge=lfs -text

README.md

@@ -0,0 +1,125 @@
+---
+frameworks:
+  - pytorch
+language:
+  - en
+license: apache-2.0
+tags:
+  - OneScience
+  - hp-VPINN
+  - variational-physics-informed-neural-networks
+  - partial-differential-equations
+  - Poisson
+tasks:
+  - pde-solving
+---
+<p align="center">
+  <strong>
+    <span style="font-size: 30px;">hp-VPINN</span>
+  </strong>
+</p>
+
+# Model Overview
+
+hp-VPINN (Variational Physics-Informed Neural Network with h- and p-Refinement) trains a neural network using the variational weak form of a partial differential equation. Test functions impose integral constraints on the equation residual, while domain decomposition (h-refinement) and higher-order polynomial test functions (p-refinement) improve the representation and solution of complex fields.
+
+This model package provides one- and two-dimensional Poisson equation examples.
+
+Paper: hp-VPINNs: Variational physics-informed neural networks with domain decomposition  
+https://doi.org/10.1016/j.cma.2020.113547
+
+# Model Description
+
+hp-VPINN constructs its variational loss with Gauss–Lobatto–Jacobi quadrature and represents the equation solution with a fully connected network. The one-dimensional example supports piecewise integration domains, while the two-dimensional example supports non-square subdomain grids. The number of subdomains and the order of the test functions can be adjusted independently to study the effects of h- and p-refinement on solution quality.
+
+# Use Cases
+
+| Use Case | Description |
+| :---: | :--- |
+| One-dimensional Poisson equation | Constrain the weak-form residual using piecewise integration domains and higher-order test functions |
+| Two-dimensional Poisson equation | Perform tensor-product quadrature on a two-dimensional domain-decomposition grid |
+| h-refinement research | Vary the number of subdomains to compare spatial decomposition strategies |
+| p-refinement research | Vary the test-function order to compare weak-form constraint capacity |
+
+# 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
+hf download --model OneScience-Sugon/VPINNs --local-dir ./VPINNs
+cd VPINNs
+```
+
+### 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
+
+Both the one- and two-dimensional Poisson examples construct source terms, boundary values, and evaluation data from analytical solutions, with no dependency on external data files. The numbers of subdomains, test functions, and quadrature points can be configured in `conf/config.yaml`.
+
+### Training
+
+The training example is controlled by `common.case` in `conf/config.yaml`, which supports `1d`, `2d`, and `all`:
+
+```bash
+python scripts/train.py
+```
+
+Training weights are saved to the `weight/` directory by default.
+
+### Model Weights
+
+This repository provides weights trained on the one- and two-dimensional Poisson datasets in the `weight/` directory.
+
+### Inference, Evaluation, and Visualization
+
+The model package provides one-dimensional Poisson weights for validation. Run:
+
+```bash
+python scripts/inference.py
+```
+
+For the two-dimensional example, first train the corresponding weights, then set `common.case` to `2d` or `all` before running inference. The script reports the relative L2 error and saves result plots to `result/`. Model, training, and inference 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
+
+- Kharazmi, E., Zhang, Z., and Karniadakis, G. E. hp-VPINNs: Variational physics-informed neural networks with domain decomposition. Computer Methods in Applied Mechanics and Engineering, 374, 113547, 2021.
+- This model package is released under the Apache-2.0 license and retains attribution to the original paper.

conf/config.yaml

@@ -0,0 +1,31 @@
+root:
+  common:
+    case: "1d"
+    device: "auto"
+    dtype: "float64"
+    seed: 1234
+    weight_dir: "weight"
+    result_dir: "result"
+
+  poisson1d:
+    n_element: 8
+    n_test: 40
+    n_quad: 60
+    epochs: 10000
+    lbfgs_iters: 1000
+    lr: 0.001
+    log_every: 2000
+    layers: [1, 20, 20, 20, 1]
+
+  poisson2d:
+    n_el_x: 4
+    n_el_y: 4
+    n_test: 8
+    n_quad: 12
+    n_bound: 80
+    boundary_weight: 50.0
+    epochs: 10000
+    lbfgs_iters: 1000
+    lr: 0.001
+    log_every: 2000
+    layers: [2, 30, 30, 30, 30, 1]

configuration.json

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

model/vpinn.py

@@ -0,0 +1,203 @@
+from __future__ import annotations
+
+from collections.abc import Mapping, Sequence
+from pathlib import Path
+
+import numpy as np
+import torch
+import torch.nn as nn
+from scipy.special import gamma, jacobi, roots_jacobi
+
+
+def jacobi_poly(
+    degree: int, alpha: float, beta: float, points: np.ndarray | float
+) -> np.ndarray:
+    return jacobi(degree, alpha, beta)(np.asarray(points, dtype=float))
+
+
+def gauss_lobatto_jacobi_weights(
+    order: int, alpha: float = 0.0, beta: float = 0.0
+) -> tuple[np.ndarray, np.ndarray]:
+    """Return Gauss-Lobatto-Jacobi nodes and weights, including both endpoints."""
+    if order < 3:
+        raise ValueError("Gauss-Lobatto-Jacobi quadrature order must be at least 3")
+
+    interior = roots_jacobi(order - 2, alpha + 1, beta + 1)[0]
+    polynomial = jacobi_poly(order - 1, alpha, beta, interior)
+    if alpha == 0 and beta == 0:
+        weights = 2.0 / ((order - 1) * order * np.square(polynomial))
+        left_weight = 2.0 / (
+            (order - 1)
+            * order
+            * np.square(jacobi_poly(order - 1, 0, 0, -1.0))
+        )
+        right_weight = 2.0 / (
+            (order - 1)
+            * order
+            * np.square(jacobi_poly(order - 1, 0, 0, 1.0))
+        )
+    else:
+        denominator = (
+            (order - 1)
+            * gamma(order)
+            * gamma(alpha + beta + order + 1)
+            * np.square(polynomial)
+        )
+        numerator = (
+            2.0 ** (alpha + beta + 1)
+            * gamma(alpha + order)
+            * gamma(beta + order)
+        )
+        weights = numerator / denominator
+        left_weight = (
+            (beta + 1)
+            * numerator
+            / (
+                (order - 1)
+                * gamma(order)
+                * gamma(alpha + beta + order + 1)
+                * np.square(jacobi_poly(order - 1, alpha, beta, -1.0))
+            )
+        )
+        right_weight = (
+            (alpha + 1)
+            * numerator
+            / (
+                (order - 1)
+                * gamma(order)
+                * gamma(alpha + beta + order + 1)
+                * np.square(jacobi_poly(order - 1, alpha, beta, 1.0))
+            )
+        )
+
+    nodes = np.concatenate(([-1.0], interior, [1.0]))
+    all_weights = np.concatenate(([left_weight], weights, [right_weight]))
+    return nodes, all_weights
+
+
+def test_function_jacobi(
+    degree: int, points: np.ndarray, alpha: float = 0.0, beta: float = 0.0
+) -> np.ndarray:
+    """Evaluate phi_n = P_(n+1) - P_(n-1), which vanishes at both endpoints."""
+    if degree < 1:
+        raise ValueError("test function degree must be at least 1")
+    return jacobi_poly(degree + 1, alpha, beta, points) - jacobi_poly(
+        degree - 1, alpha, beta, points
+    )
+
+
+def d_test_function_jacobi(
+    degree: int, points: np.ndarray
+) -> tuple[np.ndarray, np.ndarray]:
+    """Evaluate the first and second derivatives of a Jacobi test function."""
+    if degree < 1:
+        raise ValueError("test function degree must be at least 1")
+    points = np.asarray(points, dtype=float)
+    if degree == 1:
+        first = ((degree + 2) / 2) * jacobi_poly(degree, 1, 1, points)
+        second = ((degree + 2) * (degree + 3) / 4) * jacobi_poly(
+            degree - 1, 2, 2, points
+        )
+    elif degree == 2:
+        first = ((degree + 2) / 2) * jacobi_poly(
+            degree, 1, 1, points
+        ) - (degree / 2) * jacobi_poly(degree - 2, 1, 1, points)
+        second = ((degree + 2) * (degree + 3) / 4) * jacobi_poly(
+            degree - 1, 2, 2, points
+        )
+    else:
+        first = ((degree + 2) / 2) * jacobi_poly(
+            degree, 1, 1, points
+        ) - (degree / 2) * jacobi_poly(degree - 2, 1, 1, points)
+        second = ((degree + 2) * (degree + 3) / 4) * jacobi_poly(
+            degree - 1, 2, 2, points
+        ) - (degree * (degree + 1) / 4) * jacobi_poly(
+            degree - 3, 2, 2, points
+        )
+    return np.asarray(first), np.asarray(second)
+
+
+class VPINN(nn.Module):
+    """Fully connected VPINN backbone with trainable adaptive activations."""
+
+    def __init__(
+        self,
+        layers: Sequence[int],
+        activation: str = "tanh",
+        dtype: torch.dtype = torch.float64,
+    ) -> 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=dtype)
+            for index in range(len(layers) - 1)
+        )
+        # Keep one value per layer for compatibility with the bundled checkpoint.
+        self.a = nn.ParameterList(
+            nn.Parameter(torch.tensor(0.05, dtype=dtype))
+            for _ in range(len(layers) - 1)
+        )
+        for linear in self.linears:
+            nn.init.xavier_normal_(linear.weight)
+            nn.init.zeros_(linear.bias)
+
+    def forward(self, inputs: torch.Tensor) -> torch.Tensor:
+        hidden = inputs
+        activation = getattr(torch, self.activation)
+        for index, linear in enumerate(self.linears[:-1]):
+            hidden = activation(20.0 * self.a[index] * linear(hidden))
+        return self.linears[-1](hidden)
+
+
+def unpack_checkpoint(checkpoint: Mapping) -> tuple[Mapping[str, torch.Tensor], dict]:
+    """Support both legacy raw state dictionaries and metadata checkpoints."""
+    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 does not contain a valid VPINN state dictionary")
+
+
+def infer_layers(state: Mapping[str, torch.Tensor]) -> list[int]:
+    weight_keys = sorted(
+        (key for key in state if key.startswith("linears.") and key.endswith(".weight")),
+        key=lambda key: int(key.split(".")[1]),
+    )
+    if not weight_keys:
+        raise ValueError("checkpoint contains no VPINN linear-layer weights")
+    layers = [int(state[weight_keys[0]].shape[1])]
+    layers.extend(int(state[key].shape[0]) for key in weight_keys)
+    return layers
+
+
+class VPINNWrapper(nn.Module):
+    """Load a VPINN checkpoint and expose it as an inference module."""
+
+    def __init__(
+        self,
+        weight_path: str | Path,
+        device: str | torch.device | None = None,
+        dtype: torch.dtype = torch.float64,
+    ) -> None:
+        super().__init__()
+        resolved_device = torch.device(
+            device or ("cuda" if torch.cuda.is_available() else "cpu")
+        )
+        checkpoint = torch.load(weight_path, map_location="cpu", weights_only=True)
+        if not isinstance(checkpoint, Mapping):
+            raise ValueError(f"invalid VPINN checkpoint: {weight_path}")
+        state, metadata = unpack_checkpoint(checkpoint)
+        layers = metadata.get("layers") or infer_layers(state)
+        self.device = resolved_device
+        self.dtype = dtype
+        self.net = VPINN(layers, dtype=dtype).to(device=resolved_device, dtype=dtype)
+        self.net.load_state_dict(state, strict=True)
+        self.net.eval()
+
+    def forward(self, inputs: torch.Tensor) -> torch.Tensor:
+        return self.net(inputs.to(device=self.device, dtype=self.dtype))

scripts/inference.py

@@ -0,0 +1,186 @@
+from __future__ import annotations
+
+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
+import yaml
+
+
+PROJECT_ROOT = Path(__file__).resolve().parents[1]
+sys.path.insert(0, str(PROJECT_ROOT))
+
+from model.vpinn import VPINN, infer_layers, unpack_checkpoint  # noqa: E402
+
+
+DEFAULT_CONFIG = PROJECT_ROOT / "conf" / "config.yaml"
+CASES = ("1d", "2d")
+
+
+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_model(
+    checkpoint_path: Path, device: torch.device, dtype: torch.dtype
+) -> tuple[VPINN, dict]:
+    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 VPINN checkpoint: {checkpoint_path}")
+    state, metadata = unpack_checkpoint(checkpoint)
+    layers = metadata.get("layers") or infer_layers(state)
+    model = VPINN(layers, dtype=dtype).to(device=device, dtype=dtype)
+    model.load_state_dict(state, strict=True)
+    model.eval()
+    return model, metadata
+
+
+def exact_poisson1d(x: np.ndarray) -> np.ndarray:
+    return 0.1 * np.sin(8.0 * np.pi * x) + np.tanh(80.0 * x)
+
+
+def infer_poisson1d(
+    weight_dir: Path,
+    result_dir: Path,
+    device: torch.device,
+    dtype: torch.dtype,
+) -> float:
+    checkpoint_path = weight_dir / "hpvpinn_poisson1d.pt"
+    model, _ = load_model(checkpoint_path, device, dtype)
+    points = torch.linspace(-1.0, 1.0, 2001, dtype=dtype, device=device).unsqueeze(-1)
+    exact = exact_poisson1d(points.cpu().numpy().reshape(-1))
+    with torch.no_grad():
+        prediction = model(points).cpu().numpy().reshape(-1)
+    absolute_error = np.abs(prediction - exact)
+    relative_l2 = float(np.linalg.norm(prediction - exact) / np.linalg.norm(exact))
+
+    figure, axes = plt.subplots(1, 2, figsize=(12, 4))
+    coordinates = points.cpu().numpy().reshape(-1)
+    axes[0].plot(coordinates, exact, "k-", linewidth=1.5, label="Exact")
+    axes[0].plot(coordinates, prediction, "r--", linewidth=1.0, label="hp-VPINN")
+    axes[0].set_xlabel("x")
+    axes[0].set_ylabel("u")
+    axes[0].legend()
+    axes[1].semilogy(coordinates, np.maximum(absolute_error, 1.0e-16), "r-")
+    axes[1].set_xlabel("x")
+    axes[1].set_ylabel("Absolute error")
+    figure.tight_layout()
+    output_path = result_dir / "hpvpinn_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 exact_poisson2d(x: np.ndarray, y: np.ndarray) -> np.ndarray:
+    return (0.1 * np.sin(2.0 * np.pi * x) + np.tanh(10.0 * x)) * np.sin(
+        2.0 * np.pi * y
+    )
+
+
+def infer_poisson2d(
+    weight_dir: Path,
+    result_dir: Path,
+    device: torch.device,
+    dtype: torch.dtype,
+) -> float:
+    checkpoint_path = weight_dir / "hpvpinn_poisson2d.pt"
+    model, _ = load_model(checkpoint_path, device, dtype)
+    axis = np.linspace(-1.0, 1.0, 100)
+    mesh_x, mesh_y = np.meshgrid(axis, axis, indexing="ij")
+    points = torch.as_tensor(
+        np.column_stack((mesh_x.ravel(), mesh_y.ravel())), dtype=dtype, device=device
+    )
+    with torch.no_grad():
+        prediction = model(points).cpu().numpy().reshape(mesh_x.shape)
+    exact = exact_poisson2d(mesh_x, mesh_y)
+    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", "hp-VPINN", "Absolute error"),
+        (exact, prediction, absolute_error),
+        strict=True,
+    ):
+        image = plot_axis.imshow(
+            field.T,
+            extent=(-1, 1, -1, 1),
+            origin="lower",
+            aspect="auto",
+            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 / "hpvpinn_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 main() -> None:
+    config_path = DEFAULT_CONFIG.resolve()
+    config = load_config(config_path)
+    common = config["common"]
+    device = resolve_device(str(common["device"]))
+    dtype = resolve_dtype(str(common["dtype"]))
+    weight_dir = project_path(common["weight_dir"])
+    result_dir = project_path(common["result_dir"])
+    result_dir.mkdir(parents=True, exist_ok=True)
+
+    print(f"Config: {config_path}")
+    print(f"Device: {device}")
+    selected_case = str(common["case"]).lower()
+    if selected_case not in (*CASES, "all"):
+        raise ValueError("common.case must be one of: 1d, 2d, all")
+    selected_cases = CASES if selected_case == "all" else (selected_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)
+
+
+if __name__ == "__main__":
+    main()

scripts/train.py

@@ -0,0 +1,509 @@
+from __future__ import annotations
+
+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.vpinn import (  # noqa: E402
+    VPINN,
+    d_test_function_jacobi,
+    gauss_lobatto_jacobi_weights,
+    test_function_jacobi,
+)
+
+
+DEFAULT_CONFIG = PROJECT_ROOT / "conf" / "config.yaml"
+CASES = ("1d", "2d")
+OMEGA_1D = 8.0 * np.pi
+STEEPNESS_1D = 80.0
+
+
+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 positive(value: int, name: str) -> int:
+    if value <= 0:
+        raise ValueError(f"{name} must be positive")
+    return value
+
+
+def save_checkpoint(weight_dir: Path, filename: str, payload: dict) -> Path:
+    weight_dir.mkdir(parents=True, exist_ok=True)
+    output_path = weight_dir / filename
+    torch.save(payload, output_path)
+    print(f"Saved checkpoint: {output_path}")
+    return output_path
+
+
+def exact_poisson1d(x: np.ndarray) -> np.ndarray:
+    return 0.1 * np.sin(OMEGA_1D * x) + np.tanh(STEEPNESS_1D * x)
+
+
+def source_poisson1d(x: np.ndarray) -> np.ndarray:
+    oscillatory = -0.1 * OMEGA_1D**2 * np.sin(OMEGA_1D * x)
+    transition = (
+        -2.0
+        * STEEPNESS_1D**2
+        * np.tanh(STEEPNESS_1D * x)
+        / np.cosh(STEEPNESS_1D * x) ** 2
+    )
+    return -(oscillatory + transition)
+
+
+def build_rhs_1d(
+    element_grid: np.ndarray,
+    quadrature_points: np.ndarray,
+    quadrature_weights: np.ndarray,
+    n_test: int,
+) -> np.ndarray:
+    test_values = np.stack(
+        [
+            test_function_jacobi(index + 1, quadrature_points)
+            for index in range(n_test)
+        ]
+    )
+    rhs = np.empty((element_grid.size - 1, n_test), dtype=float)
+    for element in range(element_grid.size - 1):
+        left, right = element_grid[element : element + 2]
+        jacobian = (right - left) / 2.0
+        physical_points = left + jacobian * (quadrature_points + 1.0)
+        weighted_source = quadrature_weights * source_poisson1d(physical_points)
+        rhs[element] = jacobian * (test_values @ weighted_source)
+    return rhs
+
+
+def train_poisson1d(
+    config: dict,
+    device: torch.device,
+    dtype: torch.dtype,
+    weight_dir: Path,
+) -> None:
+    n_element = positive(int(config["n_element"]), "n_element")
+    n_test = positive(int(config["n_test"]), "n_test")
+    n_quad = positive(int(config["n_quad"]), "n_quad")
+    epochs = int(config["epochs"])
+    lbfgs_iters = int(config["lbfgs_iters"])
+    if epochs < 0 or lbfgs_iters < 0:
+        raise ValueError("epochs and lbfgs_iters must be non-negative")
+    layers = [int(value) for value in config["layers"]]
+    if layers[0] != 1 or layers[-1] != 1:
+        raise ValueError("1D Poisson layers must start and end with width 1")
+
+    element_grid = np.linspace(-1.0, 1.0, n_element + 1)
+    quadrature_points, quadrature_weights = gauss_lobatto_jacobi_weights(n_quad)
+    rhs = build_rhs_1d(element_grid, quadrature_points, quadrature_weights, n_test)
+    test_derivatives = np.stack(
+        [
+            d_test_function_jacobi(index + 1, quadrature_points)[0]
+            for index in range(n_test)
+        ]
+    )
+
+    model = VPINN(layers, dtype=dtype).to(device=device, dtype=dtype)
+    quadrature_tensor = torch.as_tensor(quadrature_points, dtype=dtype, device=device)
+    weight_tensor = torch.as_tensor(quadrature_weights, dtype=dtype, device=device)
+    derivative_tensor = torch.as_tensor(test_derivatives, dtype=dtype, device=device)
+    rhs_tensor = torch.as_tensor(rhs, dtype=dtype, device=device)
+    boundary = torch.tensor([[-1.0], [1.0]], dtype=dtype, device=device)
+    boundary_values = torch.as_tensor(
+        exact_poisson1d(np.array([-1.0, 1.0]))[:, None], dtype=dtype, device=device
+    )
+    test_points = torch.linspace(-1.0, 1.0, 2001, dtype=dtype, device=device).unsqueeze(-1)
+    exact_values = torch.as_tensor(
+        exact_poisson1d(test_points.cpu().numpy().reshape(-1))[:, None],
+        dtype=dtype,
+        device=device,
+    )
+
+    def variational_loss() -> torch.Tensor:
+        loss = torch.zeros((), dtype=dtype, device=device)
+        for element in range(n_element):
+            left, right = element_grid[element : element + 2]
+            jacobian = (right - left) / 2.0
+            physical_points = (
+                left + jacobian * (quadrature_tensor + 1.0)
+            ).unsqueeze(-1)
+            physical_points.requires_grad_(True)
+            prediction = model(physical_points)
+            prediction_x = torch.autograd.grad(
+                prediction,
+                physical_points,
+                torch.ones_like(prediction),
+                create_graph=True,
+            )[0]
+            weak_prediction = derivative_tensor @ (
+                weight_tensor * prediction_x.reshape(-1)
+            )
+            loss = loss + torch.mean((weak_prediction - rhs_tensor[element]).square())
+        boundary_loss = torch.mean((model(boundary) - boundary_values).square())
+        return loss + boundary_loss
+
+    def relative_l2() -> float:
+        with torch.no_grad():
+            return (
+                torch.linalg.vector_norm(model(test_points) - exact_values)
+                / torch.linalg.vector_norm(exact_values)
+            ).item()
+
+    optimizer = torch.optim.Adam(model.parameters(), lr=float(config["lr"]))
+    log_every = int(config["log_every"])
+    started = time.time()
+    print(
+        f"[1D] device={device} elements={n_element} n_test={n_test} "
+        f"n_quad={n_quad} epochs={epochs} lbfgs_iters={lbfgs_iters}"
+    )
+    for step in range(1, epochs + 1):
+        loss = variational_loss()
+        ensure_finite(loss, "1D Poisson", step)
+        optimizer.zero_grad(set_to_none=True)
+        loss.backward()
+        optimizer.step()
+        if step == 1 or step % log_every == 0 or step == epochs:
+            print(
+                f"[1D] step={step:5d} loss={loss.item():.3e} "
+                f"relative_l2={relative_l2():.3e}"
+            )
+
+    if lbfgs_iters > 0:
+        lbfgs = torch.optim.LBFGS(
+            model.parameters(),
+            lr=1.0,
+            max_iter=lbfgs_iters,
+            max_eval=max(1, 2 * lbfgs_iters),
+            history_size=50,
+            line_search_fn="strong_wolfe",
+        )
+
+        def closure() -> torch.Tensor:
+            lbfgs.zero_grad(set_to_none=True)
+            closure_loss = variational_loss()
+            ensure_finite(closure_loss, "1D Poisson L-BFGS", 0)
+            closure_loss.backward()
+            return closure_loss
+
+        lbfgs.step(closure)
+
+    error = relative_l2()
+    print(f"[1D] finished in {time.time() - started:.1f}s, relative L2={error:.6e}")
+    save_checkpoint(
+        weight_dir,
+        "hpvpinn_poisson1d.pt",
+        {
+            "case": "1d",
+            "architecture": "vpinn",
+            "model_state": model.state_dict(),
+            "layers": layers,
+            "n_element": n_element,
+            "n_test": n_test,
+            "n_quad": n_quad,
+        },
+    )
+
+
+def exact_poisson2d(x: np.ndarray, y: np.ndarray) -> np.ndarray:
+    return (0.1 * np.sin(2.0 * np.pi * x) + np.tanh(10.0 * x)) * np.sin(
+        2.0 * np.pi * y
+    )
+
+
+def source_poisson2d(x: np.ndarray, y: np.ndarray) -> np.ndarray:
+    x_component = (
+        -0.4 * np.pi**2 * np.sin(2.0 * np.pi * x)
+        - 200.0 * np.tanh(10.0 * x) / np.cosh(10.0 * x) ** 2
+    ) * np.sin(2.0 * np.pi * y)
+    y_component = (
+        0.1 * np.sin(2.0 * np.pi * x) + np.tanh(10.0 * x)
+    ) * (-4.0 * np.pi**2 * np.sin(2.0 * np.pi * y))
+    return x_component + y_component
+
+
+def build_rhs_2d(
+    grid_x: np.ndarray,
+    grid_y: np.ndarray,
+    quadrature_points: np.ndarray,
+    quadrature_weights: np.ndarray,
+    n_test: int,
+) -> np.ndarray:
+    test_values = np.stack(
+        [
+            test_function_jacobi(index + 1, quadrature_points)
+            for index in range(n_test)
+        ]
+    )
+    n_elements_x = grid_x.size - 1
+    n_elements_y = grid_y.size - 1
+    rhs = np.empty((n_elements_x, n_elements_y, n_test, n_test), dtype=float)
+    for element_x in range(n_elements_x):
+        left_x, right_x = grid_x[element_x : element_x + 2]
+        jacobian_x = (right_x - left_x) / 2.0
+        physical_x = left_x + jacobian_x * (quadrature_points + 1.0)
+        for element_y in range(n_elements_y):
+            left_y, right_y = grid_y[element_y : element_y + 2]
+            jacobian_y = (right_y - left_y) / 2.0
+            physical_y = left_y + jacobian_y * (quadrature_points + 1.0)
+            mesh_x, mesh_y = np.meshgrid(physical_x, physical_y, indexing="ij")
+            weighted_source = (
+                quadrature_weights[:, None]
+                * source_poisson2d(mesh_x, mesh_y)
+                * quadrature_weights[None, :]
+            )
+            rhs[element_x, element_y] = (
+                jacobian_x
+                * jacobian_y
+                * (test_values @ weighted_source @ test_values.T)
+            )
+    return rhs
+
+
+def sample_boundary_2d(n_bound: int) -> tuple[np.ndarray, np.ndarray]:
+    points = []
+    values = []
+    random_x = 2.0 * np.random.rand(n_bound, 1) - 1.0
+    for boundary_y in (1.0, -1.0):
+        y = np.full_like(random_x, boundary_y)
+        points.append(np.hstack((random_x, y)))
+        values.append(exact_poisson2d(random_x, y))
+    random_y = 2.0 * np.random.rand(n_bound, 1) - 1.0
+    for boundary_x in (1.0, -1.0):
+        x = np.full_like(random_y, boundary_x)
+        points.append(np.hstack((x, random_y)))
+        values.append(exact_poisson2d(x, random_y))
+    return np.vstack(points), np.vstack(values)
+
+
+def train_poisson2d(
+    config: dict,
+    device: torch.device,
+    dtype: torch.dtype,
+    weight_dir: Path,
+) -> None:
+    n_el_x = positive(int(config["n_el_x"]), "n_el_x")
+    n_el_y = positive(int(config["n_el_y"]), "n_el_y")
+    n_test = positive(int(config["n_test"]), "n_test")
+    n_quad = positive(int(config["n_quad"]), "n_quad")
+    n_bound = positive(int(config["n_bound"]), "n_bound")
+    epochs = int(config["epochs"])
+    lbfgs_iters = int(config["lbfgs_iters"])
+    if epochs < 0 or lbfgs_iters < 0:
+        raise ValueError("epochs and lbfgs_iters must be non-negative")
+    layers = [int(value) for value in config["layers"]]
+    if layers[0] != 2 or layers[-1] != 1:
+        raise ValueError("2D Poisson layers must start with width 2 and end with width 1")
+
+    grid_x = np.linspace(-1.0, 1.0, n_el_x + 1)
+    grid_y = np.linspace(-1.0, 1.0, n_el_y + 1)
+    quadrature_points, quadrature_weights = gauss_lobatto_jacobi_weights(n_quad)
+    rhs = build_rhs_2d(
+        grid_x, grid_y, quadrature_points, quadrature_weights, n_test
+    )
+    test_values = np.stack(
+        [
+            test_function_jacobi(index + 1, quadrature_points)
+            for index in range(n_test)
+        ]
+    )
+    test_derivatives = np.stack(
+        [
+            d_test_function_jacobi(index + 1, quadrature_points)[0]
+            for index in range(n_test)
+        ]
+    )
+    boundary_points, boundary_values = sample_boundary_2d(n_bound)
+
+    model = VPINN(layers, dtype=dtype).to(device=device, dtype=dtype)
+    quadrature_tensor = torch.as_tensor(quadrature_points, dtype=dtype, device=device)
+    weight_tensor = torch.as_tensor(quadrature_weights, dtype=dtype, device=device)
+    test_tensor = torch.as_tensor(test_values, dtype=dtype, device=device)
+    derivative_tensor = torch.as_tensor(test_derivatives, dtype=dtype, device=device)
+    rhs_tensor = torch.as_tensor(rhs, dtype=dtype, device=device)
+    boundary_tensor = torch.as_tensor(boundary_points, dtype=dtype, device=device)
+    boundary_value_tensor = torch.as_tensor(boundary_values, dtype=dtype, device=device)
+
+    evaluation_axis = torch.linspace(-1.0, 1.0, 100, dtype=dtype, device=device)
+    evaluation_x, evaluation_y = torch.meshgrid(
+        evaluation_axis, evaluation_axis, indexing="ij"
+    )
+    evaluation_points = torch.stack(
+        (evaluation_x.reshape(-1), evaluation_y.reshape(-1)), dim=-1
+    )
+    exact_values = torch.as_tensor(
+        exact_poisson2d(
+            evaluation_points[:, 0].cpu().numpy(),
+            evaluation_points[:, 1].cpu().numpy(),
+        )[:, None],
+        dtype=dtype,
+        device=device,
+    )
+
+    def variational_loss() -> torch.Tensor:
+        loss = torch.zeros((), dtype=dtype, device=device)
+        for element_x in range(n_el_x):
+            left_x, right_x = grid_x[element_x : element_x + 2]
+            jacobian_x = (right_x - left_x) / 2.0
+            physical_x = left_x + jacobian_x * (quadrature_tensor + 1.0)
+            for element_y in range(n_el_y):
+                left_y, right_y = grid_y[element_y : element_y + 2]
+                jacobian_y = (right_y - left_y) / 2.0
+                physical_y = left_y + jacobian_y * (quadrature_tensor + 1.0)
+                mesh_x, mesh_y = torch.meshgrid(physical_x, physical_y, indexing="ij")
+                coordinates = torch.stack(
+                    (mesh_x.reshape(-1), mesh_y.reshape(-1)), dim=-1
+                )
+                coordinates.requires_grad_(True)
+                prediction = model(coordinates)
+                prediction_gradient = torch.autograd.grad(
+                    prediction,
+                    coordinates,
+                    torch.ones_like(prediction),
+                    create_graph=True,
+                )[0]
+                prediction_x = prediction_gradient[:, 0].reshape(n_quad, n_quad)
+                prediction_y = prediction_gradient[:, 1].reshape(n_quad, n_quad)
+                weighted_x = (
+                    weight_tensor[:, None] * prediction_x * weight_tensor[None, :]
+                )
+                weighted_y = (
+                    weight_tensor[:, None] * prediction_y * weight_tensor[None, :]
+                )
+                weak_prediction = -jacobian_y * (
+                    derivative_tensor @ weighted_x @ test_tensor.T
+                ) - jacobian_x * (test_tensor @ weighted_y @ derivative_tensor.T)
+                loss = loss + torch.mean(
+                    (weak_prediction - rhs_tensor[element_x, element_y]).square()
+                )
+        boundary_loss = torch.mean(
+            (model(boundary_tensor) - boundary_value_tensor).square()
+        )
+        return loss + float(config["boundary_weight"]) * boundary_loss
+
+    def relative_l2() -> float:
+        with torch.no_grad():
+            return (
+                torch.linalg.vector_norm(model(evaluation_points) - exact_values)
+                / torch.linalg.vector_norm(exact_values)
+            ).item()
+
+    optimizer = torch.optim.Adam(model.parameters(), lr=float(config["lr"]))
+    log_every = int(config["log_every"])
+    started = time.time()
+    print(
+        f"[2D] device={device} elements={n_el_x}x{n_el_y} n_test={n_test} "
+        f"n_quad={n_quad} epochs={epochs} lbfgs_iters={lbfgs_iters}"
+    )
+    for step in range(1, epochs + 1):
+        loss = variational_loss()
+        ensure_finite(loss, "2D Poisson", step)
+        optimizer.zero_grad(set_to_none=True)
+        loss.backward()
+        optimizer.step()
+        if step == 1 or step % log_every == 0 or step == epochs:
+            print(
+                f"[2D] step={step:5d} loss={loss.item():.3e} "
+                f"relative_l2={relative_l2():.3e}"
+            )
+
+    if lbfgs_iters > 0:
+        lbfgs = torch.optim.LBFGS(
+            model.parameters(),
+            lr=1.0,
+            max_iter=lbfgs_iters,
+            max_eval=max(1, 2 * lbfgs_iters),
+            history_size=50,
+            line_search_fn="strong_wolfe",
+        )
+
+        def closure() -> torch.Tensor:
+            lbfgs.zero_grad(set_to_none=True)
+            closure_loss = variational_loss()
+            ensure_finite(closure_loss, "2D Poisson L-BFGS", 0)
+            closure_loss.backward()
+            return closure_loss
+
+        lbfgs.step(closure)
+
+    error = relative_l2()
+    print(f"[2D] finished in {time.time() - started:.1f}s, relative L2={error:.6e}")
+    save_checkpoint(
+        weight_dir,
+        "hpvpinn_poisson2d.pt",
+        {
+            "case": "2d",
+            "architecture": "vpinn",
+            "model_state": model.state_dict(),
+            "layers": layers,
+            "n_el_x": n_el_x,
+            "n_el_y": n_el_y,
+            "n_test": n_test,
+            "n_quad": n_quad,
+        },
+    )
+
+
+def main() -> None:
+    config_path = DEFAULT_CONFIG.resolve()
+    config = load_config(config_path)
+    common = config["common"]
+    device = resolve_device(str(common["device"]))
+    dtype = resolve_dtype(str(common["dtype"]))
+    weight_dir = project_path(common["weight_dir"])
+    seed_everything(int(common["seed"]))
+
+    print(f"Config: {config_path}")
+    selected_case = str(common["case"]).lower()
+    if selected_case not in (*CASES, "all"):
+        raise ValueError("common.case must be one of: 1d, 2d, all")
+    selected_cases = CASES if selected_case == "all" else (selected_case,)
+    if "1d" in selected_cases:
+        train_poisson1d(config["poisson1d"], device, dtype, weight_dir)
+    if "2d" in selected_cases:
+        train_poisson2d(config["poisson2d"], device, dtype, weight_dir)
+
+
+if __name__ == "__main__":
+    main()

weight/hpvpinn_poisson1d.pt

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