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
+*.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
+data/XPINN_2D_PoissonEqn.mat filter=lfs diff=lfs merge=lfs -text

README.md

@@ -0,0 +1,128 @@
+---
+frameworks:
+  - pytorch
+language:
+  - en
+license: apache-2.0
+tags:
+  - OneScience
+  - XPINNs
+  - physics-informed-neural-networks
+  - domain-decomposition
+  - partial-differential-equations
+  - Poisson
+tasks:
+  - pde-solving
+---
+<p align="center">
+  <strong>
+    <span style="font-size: 30px;">XPINNs</span>
+  </strong>
+</p>
+
+# Model Overview
+
+XPINNs (Extended Physics-Informed Neural Networks) decompose a complex computational domain into multiple subdomains and assign an independent neural network to each. In addition to enforcing PDE residuals and external boundary conditions, training constrains solution continuity and residual consistency across subdomain interfaces.
+
+This model package reproduces the two-dimensional Poisson benchmark from the XPINNs paper. An irregular X-shaped domain is decomposed into three subdomains governed by:
+
+```text
+u_xx + u_yy = exp(x) + exp(y)
+```
+
+Paper: Extended Physics-Informed Neural Networks (XPINNs): A Generalized Space-Time Domain Decomposition Based Deep Learning Framework for Nonlinear Partial Differential Equations  
+https://doi.org/10.4208/cicp.OA-2020-0164
+
+# Model Description
+
+XPINNs assign a separate neural network to each of the three subdomains, using `tanh`, `sin`, and `cos` activation functions by default. The model solves the equation on the irregular domain by jointly optimizing boundary loss, PDE residual loss, interface-value loss, and interface-residual loss.
+
+# Use Cases
+
+| Use Case | Description |
+| :---: | :--- |
+| PDE solving on complex domains | Solve a two-dimensional Poisson equation on an irregular X-shaped domain |
+| Domain-decomposition research | Configure independent network architectures and activation functions for different subdomains |
+| Interface-constraint research | Compare losses for interface solution continuity and residual consistency |
+| Pipeline validation | Validate training and inference using the bundled data and a small-scale configuration |
+
+# 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, but training with the full sample set 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/XPINNs --local_dir ./XPINNs
+cd XPINNs
+```
+
+### 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 model package includes the two-dimensional Poisson data file `data/XPINN_2D_PoissonEqn.mat`, which contains interior, boundary, and interface points for the three subdomains together with the exact solution. The number of training samples of each type can be adjusted in `conf/config.yaml`.
+
+### Training
+
+```bash
+python scripts/train.py
+```
+
+The default weights are saved to `weight/xpinn_poisson_2d.pt`.
+
+### Model Weights
+
+This repository provides weights trained on the two-dimensional Poisson dataset in the `weight/` directory.
+
+### Inference, Evaluation, and Visualization
+
+After training, run:
+
+```bash
+python scripts/inference.py
+```
+
+The script reports the overall relative L2 error and saves plots of the exact solution, prediction, and absolute error to `result/xpinn_poisson_2d.png`. Model, data, loss, 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
+
+- Jagtap, A. D., Kharazmi, E., and Karniadakis, G. E. Extended Physics-Informed Neural Networks (XPINNs): A Generalized Space-Time Domain Decomposition Based Deep Learning Framework for Nonlinear Partial Differential Equations. Communications in Computational Physics, 28(5), 2002-2041, 2020.
+- 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,45 @@
+root:
+  common:
+    device: "auto"
+    dtype: "float64"
+    seed: 1234
+    weight_dir: "weight"
+    result_dir: "result"
+
+  data:
+    mat_file: "data/XPINN_2D_PoissonEqn.mat"
+    samples:
+      residual_1: 5000
+      residual_2: 1800
+      residual_3: 1200
+      boundary: 200
+      interface_1: 100
+      interface_2: 100
+
+  model:
+    name: "XPINNPoisson2D"
+    subnetworks:
+      domain1:
+        layers: [2, 30, 30, 1]
+        activation: "tanh"
+      domain2:
+        layers: [2, 20, 20, 20, 20, 1]
+        activation: "sin"
+      domain3:
+        layers: [2, 25, 25, 25, 1]
+        activation: "cos"
+
+  loss:
+    boundary: 20.0
+    pde: 1.0
+    interface_residual: 1.0
+    interface_value: 20.0
+
+  training:
+    steps: 501
+    lr: 0.0008
+    log_interval: 20
+    checkpoint_name: "xpinn_poisson_2d.pt"
+
+  inference:
+    figure_name: "xpinn_poisson_2d.png"

configuration.json

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

data/XPINN_2D_PoissonEqn.mat

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

download.sh

@@ -0,0 +1,4 @@
+#!/bin/bash
+# Download files larger than 1MB, excluding .sh .py .md .yaml .yml
+# Total large files: 1
+modelscope download --model OneScience/XPINNs data/XPINN_2D_PoissonEqn.mat --local_dir ./

model/xpinn.py

@@ -0,0 +1,131 @@
+from __future__ import annotations
+
+from collections.abc import Mapping, Sequence
+
+import torch
+import torch.nn as nn
+
+
+class SubNet(nn.Module):
+    """Independent neural network assigned to one XPINN subdomain."""
+
+    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 layers[0] != 2 or layers[-1] != 1:
+            raise ValueError("XPINN subnetworks must have two inputs and one output")
+        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 original implementation.
+        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, coordinates: torch.Tensor) -> torch.Tensor:
+        hidden = coordinates
+        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)
+
+
+class XPINNPoisson2D(nn.Module):
+    """Three-subdomain XPINN for the two-dimensional Poisson benchmark."""
+
+    def __init__(
+        self, config: Mapping, dtype: torch.dtype = torch.float64
+    ) -> None:
+        super().__init__()
+        try:
+            subnetworks = config["subnetworks"]
+            domain1 = subnetworks["domain1"]
+            domain2 = subnetworks["domain2"]
+            domain3 = subnetworks["domain3"]
+        except (KeyError, TypeError) as error:
+            raise ValueError("model config must define three subnetworks") from error
+
+        self.n1 = SubNet(domain1["layers"], domain1["activation"], dtype=dtype)
+        self.n2 = SubNet(domain2["layers"], domain2["activation"], dtype=dtype)
+        self.n3 = SubNet(domain3["layers"], domain3["activation"], dtype=dtype)
+
+    @staticmethod
+    def _gradient(output: torch.Tensor, inputs: torch.Tensor) -> torch.Tensor:
+        return torch.autograd.grad(
+            output,
+            inputs,
+            torch.ones_like(output),
+            create_graph=True,
+        )[0]
+
+    @staticmethod
+    def _source(x: torch.Tensor, y: torch.Tensor) -> torch.Tensor:
+        return torch.exp(x) + torch.exp(y)
+
+    def _residual(
+        self, network: nn.Module, x: torch.Tensor, y: torch.Tensor
+    ) -> tuple[torch.Tensor, torch.Tensor]:
+        prediction = network(torch.cat((x, y), dim=1))
+        prediction_x = self._gradient(prediction, x)
+        prediction_y = self._gradient(prediction, y)
+        prediction_xx = self._gradient(prediction_x, x)
+        prediction_yy = self._gradient(prediction_y, y)
+        residual = prediction_xx + prediction_yy - self._source(x, y)
+        return prediction, residual
+
+    def training_outputs(self, batch: Mapping[str, torch.Tensor]) -> dict[str, torch.Tensor]:
+        boundary_prediction = self.n1(torch.cat((batch["xb"], batch["yb"]), dim=1))
+
+        _, residual1 = self._residual(self.n1, batch["x1"], batch["y1"])
+        _, residual2 = self._residual(self.n2, batch["x2"], batch["y2"])
+        _, residual3 = self._residual(self.n3, batch["x3"], batch["y3"])
+
+        interface1_domain1, interface1_residual1 = self._residual(
+            self.n1, batch["xi1"], batch["yi1"]
+        )
+        interface1_domain2, interface1_residual2 = self._residual(
+            self.n2, batch["xi1"], batch["yi1"]
+        )
+        interface2_domain1, interface2_residual1 = self._residual(
+            self.n1, batch["xi2"], batch["yi2"]
+        )
+        interface2_domain3, interface2_residual3 = self._residual(
+            self.n3, batch["xi2"], batch["yi2"]
+        )
+
+        interface1_average = 0.5 * (interface1_domain1 + interface1_domain2)
+        interface2_average = 0.5 * (interface2_domain1 + interface2_domain3)
+        return {
+            "boundary_prediction": boundary_prediction,
+            "residual1": residual1,
+            "residual2": residual2,
+            "residual3": residual3,
+            "interface1_residual": interface1_residual1 - interface1_residual2,
+            "interface2_residual": interface2_residual1 - interface2_residual3,
+            "interface1_average": interface1_average,
+            "interface2_average": interface2_average,
+            "interface1_domain1": interface1_domain1,
+            "interface1_domain2": interface1_domain2,
+            "interface2_domain1": interface2_domain1,
+            "interface2_domain3": interface2_domain3,
+        }
+
+    def predict(
+        self, domain1: torch.Tensor, domain2: torch.Tensor, domain3: torch.Tensor
+    ) -> tuple[torch.Tensor, torch.Tensor, torch.Tensor]:
+        return self.n1(domain1), self.n2(domain2), self.n3(domain3)

scripts/data_utils.py

@@ -0,0 +1,212 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from pathlib import Path
+
+import numpy as np
+import scipy.io
+import torch
+
+
+REQUIRED_FIELDS = {
+    "x_f1",
+    "y_f1",
+    "x_f2",
+    "y_f2",
+    "x_f3",
+    "y_f3",
+    "xi1",
+    "yi1",
+    "xi2",
+    "yi2",
+    "xb",
+    "yb",
+    "ub",
+    "u_exact",
+    "u_exact1",
+    "u_exact2",
+    "u_exact3",
+}
+
+
+def load_mat_data(path: Path) -> dict:
+    if not path.is_file():
+        raise FileNotFoundError(f"XPINN MATLAB data not found: {path}")
+    data = scipy.io.loadmat(path)
+    missing = REQUIRED_FIELDS.difference(data)
+    if missing:
+        raise ValueError(f"MATLAB data is missing fields: {sorted(missing)}")
+    return data
+
+
+def column(data: Mapping, key: str) -> np.ndarray:
+    return np.asarray(data[key], dtype=np.float64).reshape(-1, 1)
+
+
+def sample_indices(
+    generator: np.random.Generator, total_size: int, sample_size: int, name: str
+) -> np.ndarray:
+    if sample_size <= 0:
+        raise ValueError(f"{name} sample size must be positive")
+    if sample_size > total_size:
+        raise ValueError(
+            f"{name} sample size {sample_size} exceeds available points {total_size}"
+        )
+    return generator.choice(total_size, sample_size, replace=False)
+
+
+def tensor(
+    values: np.ndarray,
+    device: torch.device,
+    dtype: torch.dtype,
+    requires_grad: bool = False,
+) -> torch.Tensor:
+    return torch.as_tensor(values, dtype=dtype, device=device).clone().requires_grad_(
+        requires_grad
+    )
+
+
+def paired_sample(
+    data: Mapping,
+    x_key: str,
+    y_key: str,
+    sample_size: int,
+    generator: np.random.Generator,
+    device: torch.device,
+    dtype: torch.dtype,
+    name: str,
+) -> tuple[torch.Tensor, torch.Tensor]:
+    x = column(data, x_key)
+    y = column(data, y_key)
+    if x.shape != y.shape:
+        raise ValueError(f"coordinate shape mismatch for {name}: {x.shape} and {y.shape}")
+    indices = sample_indices(generator, x.shape[0], sample_size, name)
+    return (
+        tensor(x[indices], device, dtype, requires_grad=True),
+        tensor(y[indices], device, dtype, requires_grad=True),
+    )
+
+
+def build_training_batch(
+    data: Mapping,
+    sample_counts: Mapping[str, int],
+    seed: int,
+    device: torch.device,
+    dtype: torch.dtype,
+) -> dict[str, torch.Tensor]:
+    generator = np.random.default_rng(seed)
+    x1, y1 = paired_sample(
+        data,
+        "x_f1",
+        "y_f1",
+        int(sample_counts["residual_1"]),
+        generator,
+        device,
+        dtype,
+        "residual_1",
+    )
+    x2, y2 = paired_sample(
+        data,
+        "x_f2",
+        "y_f2",
+        int(sample_counts["residual_2"]),
+        generator,
+        device,
+        dtype,
+        "residual_2",
+    )
+    x3, y3 = paired_sample(
+        data,
+        "x_f3",
+        "y_f3",
+        int(sample_counts["residual_3"]),
+        generator,
+        device,
+        dtype,
+        "residual_3",
+    )
+    xi1, yi1 = paired_sample(
+        data,
+        "xi1",
+        "yi1",
+        int(sample_counts["interface_1"]),
+        generator,
+        device,
+        dtype,
+        "interface_1",
+    )
+    xi2, yi2 = paired_sample(
+        data,
+        "xi2",
+        "yi2",
+        int(sample_counts["interface_2"]),
+        generator,
+        device,
+        dtype,
+        "interface_2",
+    )
+
+    boundary_x = column(data, "xb")
+    boundary_y = column(data, "yb")
+    boundary_values = column(data, "ub")
+    if boundary_x.shape != boundary_y.shape or boundary_x.shape != boundary_values.shape:
+        raise ValueError("boundary coordinate and value shapes do not match")
+    boundary_indices = sample_indices(
+        generator,
+        boundary_x.shape[0],
+        int(sample_counts["boundary"]),
+        "boundary",
+    )
+    return {
+        "xb": tensor(boundary_x[boundary_indices], device, dtype),
+        "yb": tensor(boundary_y[boundary_indices], device, dtype),
+        "ub": tensor(boundary_values[boundary_indices], device, dtype),
+        "x1": x1,
+        "y1": y1,
+        "x2": x2,
+        "y2": y2,
+        "x3": x3,
+        "y3": y3,
+        "xi1": xi1,
+        "yi1": yi1,
+        "xi2": xi2,
+        "yi2": yi2,
+    }
+
+
+def build_evaluation_points(
+    data: Mapping, device: torch.device, dtype: torch.dtype
+) -> dict[str, torch.Tensor]:
+    points = {}
+    for domain in (1, 2, 3):
+        x = column(data, f"x_f{domain}")
+        y = column(data, f"y_f{domain}")
+        if x.shape != y.shape:
+            raise ValueError(f"evaluation coordinate mismatch in domain {domain}")
+        points[f"xy{domain}"] = tensor(np.hstack((x, y)), device, dtype)
+    return points
+
+
+def exact_subdomain_values(
+    data: Mapping, device: torch.device, dtype: torch.dtype
+) -> tuple[torch.Tensor, torch.Tensor, torch.Tensor]:
+    return tuple(
+        tensor(column(data, f"u_exact{domain}"), device, dtype)
+        for domain in (1, 2, 3)
+    )
+
+
+def combined_coordinates(data: Mapping) -> tuple[np.ndarray, np.ndarray]:
+    x = np.concatenate([column(data, f"x_f{domain}").reshape(-1) for domain in (1, 2, 3)])
+    y = np.concatenate([column(data, f"y_f{domain}").reshape(-1) for domain in (1, 2, 3)])
+    return x, y
+
+
+def combined_exact_solution(data: Mapping) -> np.ndarray:
+    exact = column(data, "u_exact").reshape(-1)
+    expected_size = sum(column(data, f"x_f{domain}").size for domain in (1, 2, 3))
+    if exact.size != expected_size:
+        raise ValueError(
+            f"combined exact solution has {exact.size} values, expected {expected_size}"
+        )
+    return exact

scripts/inference.py

@@ -0,0 +1,188 @@
+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 matplotlib.tri as tri
+import numpy as np
+import torch
+import yaml
+from matplotlib.patches import Polygon
+
+
+PROJECT_ROOT = Path(__file__).resolve().parents[1]
+sys.path.insert(0, str(PROJECT_ROOT))
+sys.path.insert(0, str(Path(__file__).resolve().parent))
+
+from data_utils import (  # noqa: E402
+    build_evaluation_points,
+    combined_coordinates,
+    combined_exact_solution,
+    load_mat_data,
+)
+from model.xpinn import XPINNPoisson2D  # noqa: E402
+
+
+DEFAULT_CONFIG = PROJECT_ROOT / "conf" / "config.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) -> 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,
+    fallback_model_config: dict,
+    device: torch.device,
+    dtype: torch.dtype,
+) -> XPINNPoisson2D:
+    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 XPINN checkpoint: {checkpoint_path}")
+    if "model_state" in checkpoint:
+        state = checkpoint["model_state"]
+        model_config = checkpoint.get("model_config", fallback_model_config)
+    elif checkpoint and all(torch.is_tensor(value) for value in checkpoint.values()):
+        state = checkpoint
+        model_config = fallback_model_config
+    else:
+        raise ValueError(f"checkpoint contains no model state: {checkpoint_path}")
+    model = XPINNPoisson2D(model_config, dtype=dtype).to(device=device, dtype=dtype)
+    model.load_state_dict(state, strict=True)
+    model.eval()
+    return model
+
+
+def predict(
+    model: XPINNPoisson2D, evaluation_points: dict[str, torch.Tensor]
+) -> np.ndarray:
+    with torch.no_grad():
+        predictions = model.predict(
+            evaluation_points["xy1"],
+            evaluation_points["xy2"],
+            evaluation_points["xy3"],
+        )
+    return torch.cat(predictions).cpu().numpy().reshape(-1)
+
+
+def mask_polygon(data: Mapping) -> np.ndarray:
+    boundary_x = np.asarray(data["xb"]).reshape(-1)
+    boundary_y = np.asarray(data["yb"]).reshape(-1)
+    return np.vstack(
+        (
+            np.column_stack((boundary_x, boundary_y)),
+            np.array(
+                [
+                    [1.8, boundary_y[-1]],
+                    [1.8, -1.7],
+                    [-1.6, -1.7],
+                    [-1.6, 1.55],
+                    [1.8, 1.55],
+                    [1.8, boundary_y[-1]],
+                ]
+            ),
+            np.array([[boundary_x[-1], boundary_y[-1]]]),
+        )
+    )
+
+
+def save_figure(
+    data: Mapping,
+    exact: np.ndarray,
+    prediction: np.ndarray,
+    output_path: Path,
+) -> None:
+    x, y = combined_coordinates(data)
+    if exact.size != x.size or prediction.size != x.size:
+        raise ValueError("plot coordinates, exact values, and predictions must have equal size")
+    triangulation = tri.Triangulation(x, y)
+    polygon = mask_polygon(data)
+    fields = (
+        ("Exact", exact),
+        ("XPINN", prediction),
+        ("Absolute error", np.abs(exact - prediction)),
+    )
+    figure, axes = plt.subplots(1, 3, figsize=(18, 5))
+    for axis, (title, field) in zip(axes, fields, strict=True):
+        contour = axis.tricontourf(triangulation, field, 100, cmap="jet")
+        axis.add_patch(
+            Polygon(polygon, closed=True, facecolor="white", edgecolor="white")
+        )
+        axis.plot(data["xi1"].reshape(-1), data["yi1"].reshape(-1), "w-", linewidth=0.5)
+        axis.plot(data["xi2"].reshape(-1), data["yi2"].reshape(-1), "w-", linewidth=0.5)
+        axis.set_title(title)
+        axis.set_xlabel("x")
+        axis.set_ylabel("y")
+        axis.set_aspect("equal")
+        figure.colorbar(contour, ax=axis)
+    figure.tight_layout()
+    figure.savefig(output_path, dpi=150)
+    plt.close(figure)
+
+
+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"]))
+    data_path = project_path(config["data"]["mat_file"])
+    weight_dir = project_path(common["weight_dir"])
+    result_dir = project_path(common["result_dir"])
+    checkpoint_path = weight_dir / config["training"]["checkpoint_name"]
+    output_path = result_dir / config["inference"]["figure_name"]
+    result_dir.mkdir(parents=True, exist_ok=True)
+
+    print(f"Config: {config_path}")
+    print(f"Data: {data_path}")
+    print(f"Checkpoint: {checkpoint_path}")
+    print(f"Device: {device}")
+    data = load_mat_data(data_path)
+    model = load_model(checkpoint_path, config["model"], device, dtype)
+    evaluation_points = build_evaluation_points(data, device, dtype)
+    prediction = predict(model, evaluation_points)
+    exact = combined_exact_solution(data)
+    relative_l2 = float(
+        np.linalg.norm(exact - prediction) / np.linalg.norm(exact)
+    )
+    save_figure(data, exact, prediction, output_path)
+    print(f"Relative L2={relative_l2:.6e}")
+    print(f"Plot: {output_path}")
+
+
+if __name__ == "__main__":
+    main()

scripts/train.py

@@ -0,0 +1,208 @@
+from __future__ import annotations
+
+import random
+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))
+sys.path.insert(0, str(Path(__file__).resolve().parent))
+
+from data_utils import (  # noqa: E402
+    build_evaluation_points,
+    build_training_batch,
+    exact_subdomain_values,
+    load_mat_data,
+)
+from model.xpinn import XPINNPoisson2D  # noqa: E402
+
+
+DEFAULT_CONFIG = PROJECT_ROOT / "conf" / "config.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) -> 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 compute_loss(
+    outputs: dict[str, torch.Tensor],
+    batch: dict[str, torch.Tensor],
+    weights: dict,
+) -> tuple[torch.Tensor, dict[str, float]]:
+    boundary_loss = torch.mean(
+        (batch["ub"] - outputs["boundary_prediction"]).square()
+    )
+    pde_loss = sum(
+        torch.mean(outputs[f"residual{domain}"].square()) for domain in (1, 2, 3)
+    )
+    interface_residual_loss = torch.mean(
+        outputs["interface1_residual"].square()
+    ) + torch.mean(outputs["interface2_residual"].square())
+    interface_value_loss = (
+        torch.mean(
+            (outputs["interface1_domain1"] - outputs["interface1_average"]).square()
+        )
+        + torch.mean(
+            (outputs["interface1_domain2"] - outputs["interface1_average"]).square()
+        )
+        + torch.mean(
+            (outputs["interface2_domain1"] - outputs["interface2_average"]).square()
+        )
+        + torch.mean(
+            (outputs["interface2_domain3"] - outputs["interface2_average"]).square()
+        )
+    )
+    total = (
+        float(weights["boundary"]) * boundary_loss
+        + float(weights["pde"]) * pde_loss
+        + float(weights["interface_residual"]) * interface_residual_loss
+        + float(weights["interface_value"]) * interface_value_loss
+    )
+    return total, {
+        "boundary": boundary_loss.item(),
+        "pde": pde_loss.item(),
+        "interface_residual": interface_residual_loss.item(),
+        "interface_value": interface_value_loss.item(),
+    }
+
+
+def clear_coordinate_grads(batch: dict[str, torch.Tensor]) -> None:
+    for value in batch.values():
+        if value.requires_grad and value.grad is not None:
+            value.grad = None
+
+
+def evaluate(
+    model: XPINNPoisson2D,
+    points: dict[str, torch.Tensor],
+    references: tuple[torch.Tensor, torch.Tensor, torch.Tensor],
+) -> tuple[float, float, float, float]:
+    with torch.no_grad():
+        predictions = model.predict(points["xy1"], points["xy2"], points["xy3"])
+        errors = tuple(
+            (
+                torch.linalg.vector_norm(prediction - reference)
+                / torch.linalg.vector_norm(reference)
+            ).item()
+            for prediction, reference in zip(predictions, references, strict=True)
+        )
+        combined_prediction = torch.cat(predictions)
+        combined_reference = torch.cat(references)
+        combined_error = (
+            torch.linalg.vector_norm(combined_prediction - combined_reference)
+            / torch.linalg.vector_norm(combined_reference)
+        ).item()
+    return errors[0], errors[1], errors[2], combined_error
+
+
+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"]))
+    seed = int(common["seed"])
+    data_path = project_path(config["data"]["mat_file"])
+    weight_dir = project_path(common["weight_dir"])
+    checkpoint_path = weight_dir / config["training"]["checkpoint_name"]
+    steps = int(config["training"]["steps"])
+    if steps <= 0:
+        raise ValueError("training steps must be positive")
+    counts = {key: int(value) for key, value in config["data"]["samples"].items()}
+    seed_everything(seed)
+
+    print(f"Config: {config_path}")
+    print(f"Data: {data_path}")
+    print(f"Device: {device}")
+    print(f"Samples: {counts}")
+    data = load_mat_data(data_path)
+    batch = build_training_batch(data, counts, seed, device, dtype)
+    evaluation_points = build_evaluation_points(data, device, dtype)
+    references = exact_subdomain_values(data, device, dtype)
+
+    model = XPINNPoisson2D(config["model"], dtype=dtype).to(
+        device=device, dtype=dtype
+    )
+    optimizer = torch.optim.Adam(
+        model.parameters(), lr=float(config["training"]["lr"])
+    )
+    log_interval = int(config["training"]["log_interval"])
+    started = time.time()
+    for step in range(1, steps + 1):
+        clear_coordinate_grads(batch)
+        outputs = model.training_outputs(batch)
+        loss, parts = compute_loss(outputs, batch, config["loss"])
+        if not torch.isfinite(loss):
+            raise FloatingPointError(f"XPINN loss became non-finite at step {step}")
+        optimizer.zero_grad(set_to_none=True)
+        loss.backward()
+        optimizer.step()
+
+        if step == 1 or step % log_interval == 0 or step == steps:
+            error1, error2, error3, combined_error = evaluate(
+                model, evaluation_points, references
+            )
+            print(
+                f"step={step:4d} loss={loss.item():.3e} "
+                f"boundary={parts['boundary']:.3e} pde={parts['pde']:.3e} "
+                f"interface_r={parts['interface_residual']:.3e} "
+                f"interface_u={parts['interface_value']:.3e} "
+                f"l2=({error1:.3e}, {error2:.3e}, {error3:.3e}) "
+                f"combined={combined_error:.3e}"
+            )
+
+    weight_dir.mkdir(parents=True, exist_ok=True)
+    checkpoint = {
+        "case": "poisson2d",
+        "architecture": "xpinn_poisson2d",
+        "model_state": model.state_dict(),
+        "model_config": config["model"],
+        "sample_counts": counts,
+        "step": steps,
+    }
+    torch.save(checkpoint, checkpoint_path)
+    print(f"Training finished in {time.time() - started:.1f}s")
+    print(f"Saved checkpoint: {checkpoint_path}")
+
+
+if __name__ == "__main__":
+    main()

weight/xpinn_poisson_2d.pt

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