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,131 @@
+---
+frameworks:
+  - pytorch
+language:
+  - en
+license: apache-2.0
+tags:
+  - OneScience
+  - BPINNs
+  - Bayesian-physics-informed-neural-networks
+  - partial-differential-equations
+  - Laplace
+tasks:
+  - pde-solving
+---
+<p align="center">
+  <strong>
+    <span style="font-size: 30px;">BPINNs</span>
+  </strong>
+</p>
+
+# Model Overview
+
+BPINNs (Bayesian Physics-Informed Neural Networks) incorporate physical-equation constraints into Bayesian neural networks to jointly estimate equation solutions and predictive uncertainty from noisy data. This model package provides an example for solving a one-dimensional Laplace equation:
+
+```text
+u_xx + pi^2 sin(pi x) = 0,  x in [0, 1]
+u(x) = sin(pi x)
+```
+
+Paper: B-PINNs: Bayesian physics-informed neural networks for forward and inverse PDE problems with noisy data  
+https://doi.org/10.1016/j.jcp.2020.109913
+
+# Model Description
+
+BPINNs are trained jointly on observational data, boundary conditions, and PDE residuals. By default, the model is optimized with Adam and then refined with L-BFGS. During inference, predictive means and standard deviations can be computed from multiple parameter states stored in a checkpoint. The default training workflow produces only one optimized state; full Bayesian uncertainty quantification requires posterior parameter states obtained through Hamiltonian Monte Carlo (HMC), variational inference, or ensemble sampling.
+
+# Use Cases
+
+| Use Case | Description |
+| :---: | :--- |
+| One-dimensional Laplace equation | Train the solution jointly from observation points, boundary points, and collocation points |
+| PDE modeling with noisy data | Fit noisy observations subject to physical constraints |
+| Optimizer comparison | Compare the effects of Adam and L-BFGS on PINN convergence |
+| Posterior prediction | Compute predictive means and standard deviations from multiple parameter states |
+
+# 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 can accelerate full training; a CPU is sufficient for 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/BPINNs --local_dir ./BPINNs
+cd BPINNs
+```
+
+### 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
+
+This example automatically generates interior observation points, boundary points, PDE collocation points, and a test grid from the analytical solution; no external data files are required. The number of observation and collocation points, noise level, and computational domain can be configured in `conf/config.yaml`.
+
+### Training
+
+```bash
+python scripts/train.py
+```
+
+By default, training produces the base weights at `weight/bpinn_laplace1d.pt` and saves the training history to `result/training_history.npz`.
+
+### Model Weights
+
+This repository provides weights trained on the one-dimensional Laplace equation in the `weight/` directory.
+
+### L-BFGS Refinement
+
+```bash
+python scripts/refine.py
+```
+
+By default, refinement produces `weight/bpinn_laplace1d_refined.pt`.
+
+### Inference, Evaluation, and Visualization
+
+```bash
+python scripts/inference.py
+```
+
+Inference loads the refined weights when available and otherwise falls back to the base weights. Predictions and visualizations are saved to `result/`. Model, training, 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
+
+- Yang, L., Meng, X., and Karniadakis, G. E. B-PINNs: Bayesian physics-informed neural networks for forward and inverse PDE problems with noisy data. Journal of Computational Physics, 425, 109913, 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,42 @@
+root:
+  common:
+    device: "auto"
+    dtype: "float64"
+    seed: 1234
+    weight_dir: "weight"
+    result_dir: "result"
+
+  model:
+    name: "BPINN"
+    input_dim: 1
+    n_layers: 4
+    n_neurons: 50
+    n_out_sol: 1
+    n_out_par: 0
+    activation: "tanh"
+
+  training:
+    epochs: 10000
+    lr: 0.001
+    lbfgs_iters: 2000
+    refinement_lr: 1.0
+    log_interval: 500
+    checkpoint_name: "bpinn_laplace1d.pt"
+    refined_checkpoint_name: "bpinn_laplace1d_refined.pt"
+
+  loss:
+    data: 10.0
+    pde: 1.0
+    boundary: 10.0
+
+  data:
+    domain: [0.0, 1.0]
+    n_sol: 200
+    n_pde: 1000
+    noise_std: 0.0
+    test_res: 200
+
+  inference:
+    predictions_name: "bpinn_laplace1d.npz"
+    figure_name: "bpinn_laplace1d.png"
+    history_name: "training_history.npz"

configuration.json

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

model/bpinn.py

@@ -0,0 +1,197 @@
+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 the BPINN solution model."""
+
+    def __init__(
+        self,
+        layer_sizes: Sequence[int],
+        activation: str = "tanh",
+        dtype: torch.dtype = torch.float64,
+        stddev: float | None = None,
+    ) -> 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}")
+        if stddev is None:
+            stddev = math.sqrt(50.0 / layer_sizes[1])
+        if stddev <= 0:
+            raise ValueError("stddev must be positive")
+
+        self.activation = "sin" if activation == "sine" else activation
+        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 PhysNet(nn.Module):
+    """Physics-informed network with solution and optional parameter outputs."""
+
+    def __init__(
+        self,
+        input_dim: int = 1,
+        n_layers: int = 4,
+        n_neurons: int = 50,
+        n_out_sol: int = 1,
+        n_out_par: int = 0,
+        activation: str = "tanh",
+        dtype: torch.dtype = torch.float64,
+    ) -> None:
+        super().__init__()
+        if min(input_dim, n_layers, n_neurons, n_out_sol) <= 0 or n_out_par < 0:
+            raise ValueError("network dimensions must be positive")
+        self.n_out_sol = n_out_sol
+        self.n_out_par = n_out_par
+        output_dim = n_out_sol + n_out_par
+        self.fcn = FCN(
+            [input_dim, *([n_neurons] * n_layers), output_dim],
+            activation=activation,
+            dtype=dtype,
+        )
+
+    def forward(self, inputs: torch.Tensor) -> tuple[torch.Tensor, torch.Tensor | None]:
+        outputs = self.fcn(inputs)
+        solution = outputs[..., : self.n_out_sol]
+        parameters = outputs[..., self.n_out_sol :] if self.n_out_par else None
+        return solution, parameters
+
+    def predict_u(self, inputs: torch.Tensor) -> torch.Tensor:
+        return self.forward(inputs)[0]
+
+
+class BPINN(nn.Module):
+    """Physics-informed neural network used by the BPINNs workflow."""
+
+    def __init__(
+        self,
+        input_dim: int = 1,
+        n_layers: int = 4,
+        n_neurons: int = 50,
+        n_out_sol: int = 1,
+        n_out_par: int = 0,
+        activation: str = "tanh",
+        dtype: torch.dtype = torch.float64,
+    ) -> None:
+        super().__init__()
+        self.net = PhysNet(
+            input_dim=input_dim,
+            n_layers=n_layers,
+            n_neurons=n_neurons,
+            n_out_sol=n_out_sol,
+            n_out_par=n_out_par,
+            activation=activation,
+            dtype=dtype,
+        )
+
+    def forward(self, inputs: torch.Tensor) -> tuple[torch.Tensor, torch.Tensor | None]:
+        return self.net(inputs)
+
+    def predict_u(self, inputs: torch.Tensor) -> torch.Tensor:
+        return self.net.predict_u(inputs)
+
+
+def build_model(config: Mapping, dtype: torch.dtype = torch.float64) -> BPINN:
+    return BPINN(
+        input_dim=int(config["input_dim"]),
+        n_layers=int(config["n_layers"]),
+        n_neurons=int(config["n_neurons"]),
+        n_out_sol=int(config["n_out_sol"]),
+        n_out_par=int(config["n_out_par"]),
+        activation=str(config["activation"]),
+        dtype=dtype,
+    )
+
+
+def laplace1d_loss_components(
+    model: BPINN,
+    x_solution: torch.Tensor,
+    u_solution: torch.Tensor,
+    x_boundary: torch.Tensor,
+    u_boundary: torch.Tensor,
+    x_pde: torch.Tensor,
+) -> dict[str, torch.Tensor]:
+    solution_prediction = model.predict_u(x_solution)
+    boundary_prediction = model.predict_u(x_boundary)
+
+    pde_points = x_pde.detach().requires_grad_(True)
+    pde_prediction = model.predict_u(pde_points)
+    first_derivative = torch.autograd.grad(
+        pde_prediction,
+        pde_points,
+        torch.ones_like(pde_prediction),
+        create_graph=True,
+    )[0]
+    second_derivative = torch.autograd.grad(
+        first_derivative,
+        pde_points,
+        torch.ones_like(first_derivative),
+        create_graph=True,
+    )[0]
+    source = torch.pi**2 * torch.sin(torch.pi * pde_points)
+    residual = second_derivative + source
+    return {
+        "data": torch.mean((solution_prediction - u_solution).square()),
+        "boundary": torch.mean((boundary_prediction - u_boundary).square()),
+        "pde": torch.mean(residual.square()),
+    }
+
+
+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"]
+    )
+
+
+def posterior_predict(
+    model: BPINN,
+    states: Sequence[Mapping[str, torch.Tensor]],
+    inputs: torch.Tensor,
+) -> tuple[torch.Tensor, torch.Tensor, torch.Tensor]:
+    """Compute predictive mean and standard deviation from parameter-state samples."""
+    if not states:
+        raise ValueError("posterior prediction requires at least one parameter state")
+    original_state = {
+        key: value.detach().clone() for key, value in model.state_dict().items()
+    }
+    predictions = []
+    try:
+        for state in states:
+            model.load_state_dict(state, strict=True)
+            with torch.no_grad():
+                predictions.append(model.predict_u(inputs))
+    finally:
+        model.load_state_dict(original_state, strict=True)
+    samples = torch.stack(predictions)
+    return samples.mean(dim=0), samples.std(dim=0, unbiased=False), samples

result/training_history.npz

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

scripts/common.py

@@ -0,0 +1,114 @@
+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 exact_solution(values: np.ndarray | torch.Tensor) -> np.ndarray | torch.Tensor:
+    if torch.is_tensor(values):
+        return torch.sin(torch.pi * values)
+    return np.sin(np.pi * values)
+
+
+def build_laplace_data(
+    config: Mapping,
+    seed: int,
+    device: torch.device,
+    dtype: torch.dtype,
+) -> dict[str, torch.Tensor]:
+    domain = config["domain"]
+    if len(domain) != 2 or float(domain[0]) >= float(domain[1]):
+        raise ValueError("data.domain must contain increasing lower and upper bounds")
+    lower, upper = float(domain[0]), float(domain[1])
+    n_solution = int(config["n_sol"])
+    n_pde = int(config["n_pde"])
+    test_resolution = int(config["test_res"])
+    if min(n_solution, n_pde, test_resolution) <= 0:
+        raise ValueError("n_sol, n_pde, and test_res must be positive")
+    noise_std = float(config["noise_std"])
+    if noise_std < 0:
+        raise ValueError("noise_std must be non-negative")
+
+    generator = np.random.default_rng(seed)
+    x_solution = generator.uniform(lower, upper, (n_solution, 1))
+    u_solution = exact_solution(x_solution)
+    if noise_std:
+        u_solution = u_solution + noise_std * generator.standard_normal(u_solution.shape)
+    x_pde = generator.uniform(lower, upper, (n_pde, 1))
+    x_boundary = np.array([[lower], [upper]])
+    u_boundary = exact_solution(x_boundary)
+    x_test = np.linspace(lower, upper, test_resolution)[:, None]
+    u_test = exact_solution(x_test)
+
+    return {
+        "x_solution": torch.as_tensor(x_solution, dtype=dtype, device=device),
+        "u_solution": torch.as_tensor(u_solution, dtype=dtype, device=device),
+        "x_pde": torch.as_tensor(x_pde, dtype=dtype, device=device),
+        "x_boundary": torch.as_tensor(x_boundary, dtype=dtype, device=device),
+        "u_boundary": torch.as_tensor(u_boundary, dtype=dtype, device=device),
+        "x_test": torch.as_tensor(x_test, dtype=dtype, device=device),
+        "u_test": torch.as_tensor(u_test, dtype=dtype, device=device),
+    }
+
+
+def relative_l2(prediction: np.ndarray | torch.Tensor, reference: np.ndarray | torch.Tensor) -> float:
+    if torch.is_tensor(prediction):
+        prediction = prediction.detach().cpu().numpy()
+    if torch.is_tensor(reference):
+        reference = reference.detach().cpu().numpy()
+    prediction_array = np.asarray(prediction).reshape(-1)
+    reference_array = np.asarray(reference).reshape(-1)
+    return float(
+        np.linalg.norm(prediction_array - reference_array)
+        / (np.linalg.norm(reference_array) + 1.0e-12)
+    )
+
+
+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 BPINN model state")

scripts/inference.py

@@ -0,0 +1,126 @@
+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
+
+
+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
+    build_laplace_data,
+    checkpoint_state,
+    load_config,
+    project_path,
+    relative_l2,
+    resolve_device,
+    resolve_dtype,
+)
+from model.bpinn import build_model, posterior_predict  # noqa: E402
+
+
+DEFAULT_CONFIG = PROJECT_ROOT / "conf" / "config.yaml"
+
+
+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"], PROJECT_ROOT)
+    result_dir = project_path(common["result_dir"], PROJECT_ROOT)
+    refined_path = weight_dir / config["training"]["refined_checkpoint_name"]
+    base_path = weight_dir / config["training"]["checkpoint_name"]
+    checkpoint_path = refined_path if refined_path.is_file() else base_path
+    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 BPINN checkpoint: {checkpoint_path}")
+    state, metadata = checkpoint_state(checkpoint)
+    model_config = metadata.get("model_config", config["model"])
+    data_config = dict(metadata.get("data_config", config["data"]))
+    seed = int(metadata.get("seed", common["seed"]))
+    data = build_laplace_data(data_config, seed, device, dtype)
+    model = build_model(model_config, dtype=dtype).to(device=device, dtype=dtype)
+    model.load_state_dict(state, strict=True)
+    model.eval()
+
+    posterior_states = metadata.get("posterior_states") or [state]
+    mean, standard_deviation, samples = posterior_predict(
+        model, posterior_states, data["x_test"]
+    )
+    mean_numpy = mean.cpu().numpy()
+    std_numpy = standard_deviation.cpu().numpy()
+    exact_numpy = data["u_test"].cpu().numpy()
+    x_numpy = data["x_test"].cpu().numpy()
+    error = relative_l2(mean_numpy, exact_numpy)
+    rmse = float(np.sqrt(np.mean((mean_numpy - exact_numpy) ** 2)))
+    max_error = float(np.max(np.abs(mean_numpy - exact_numpy)))
+
+    result_dir.mkdir(parents=True, exist_ok=True)
+    predictions_path = result_dir / config["inference"]["predictions_name"]
+    figure_path = result_dir / config["inference"]["figure_name"]
+    np.savez_compressed(
+        predictions_path,
+        x=x_numpy,
+        exact=exact_numpy,
+        mean=mean_numpy,
+        std=std_numpy,
+        samples=samples.cpu().numpy(),
+        relative_l2=error,
+        rmse=rmse,
+        max_abs_error=max_error,
+    )
+
+    x_axis = x_numpy.reshape(-1)
+    exact_axis = exact_numpy.reshape(-1)
+    mean_axis = mean_numpy.reshape(-1)
+    std_axis = std_numpy.reshape(-1)
+    absolute_error = np.abs(mean_axis - exact_axis)
+    figure, axes = plt.subplots(1, 2, figsize=(12, 4))
+    axes[0].plot(x_axis, exact_axis, "k-", linewidth=1.5, label="Exact")
+    axes[0].plot(x_axis, mean_axis, "r--", linewidth=1.5, label="BPINN")
+    if np.any(std_axis > 0):
+        axes[0].fill_between(
+            x_axis,
+            mean_axis - 2.0 * std_axis,
+            mean_axis + 2.0 * std_axis,
+            color="red",
+            alpha=0.2,
+            label="2 std",
+        )
+    axes[0].set_xlabel("x")
+    axes[0].set_ylabel("u")
+    axes[0].legend()
+    axes[1].semilogy(x_axis, np.maximum(absolute_error, 1.0e-16), "b-")
+    axes[1].set_xlabel("x")
+    axes[1].set_ylabel("Absolute error")
+    figure.tight_layout()
+    figure.savefig(figure_path, dpi=150)
+    plt.close(figure)
+
+    print(f"Config: {config_path}")
+    print(f"Checkpoint: {checkpoint_path}")
+    print(f"Device: {device}")
+    print(f"Posterior states: {len(posterior_states)}")
+    print(f"Relative L2={error:.6e}, RMSE={rmse:.6e}, MaxAbs={max_error:.6e}")
+    print(f"Predictions: {predictions_path}")
+    print(f"Plot: {figure_path}")
+
+
+if __name__ == "__main__":
+    main()

scripts/refine.py

@@ -0,0 +1,115 @@
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+
+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
+    build_laplace_data,
+    checkpoint_state,
+    load_config,
+    project_path,
+    relative_l2,
+    resolve_device,
+    resolve_dtype,
+    seed_everything,
+)
+from model.bpinn import (  # noqa: E402
+    build_model,
+    laplace1d_loss_components,
+    weighted_loss,
+)
+
+
+DEFAULT_CONFIG = PROJECT_ROOT / "conf" / "config.yaml"
+
+
+def main() -> None:
+    config_path = DEFAULT_CONFIG.resolve()
+    config = load_config(config_path)
+    common = config["common"]
+    training = config["training"]
+    lbfgs_iters = int(training["lbfgs_iters"])
+    refinement_lr = float(training["refinement_lr"])
+    if lbfgs_iters <= 0 or refinement_lr <= 0:
+        raise ValueError("lbfgs-iters and lr must be positive")
+    device = resolve_device(str(common["device"]))
+    dtype = resolve_dtype(str(common["dtype"]))
+    weight_dir = project_path(common["weight_dir"], PROJECT_ROOT)
+    input_path = weight_dir / training["checkpoint_name"]
+    output_path = weight_dir / training["refined_checkpoint_name"]
+    if not input_path.is_file():
+        raise FileNotFoundError(f"checkpoint not found: {input_path}")
+    checkpoint = torch.load(input_path, map_location="cpu", weights_only=True)
+    state, metadata = checkpoint_state(checkpoint)
+    model_config = metadata.get("model_config", config["model"])
+    data_config = metadata.get("data_config", config["data"])
+    loss_weights = metadata.get("loss_weights", config["loss"])
+    seed = int(metadata.get("seed", common["seed"]))
+    seed_everything(seed)
+    data = build_laplace_data(data_config, seed, device, dtype)
+    model = build_model(model_config, dtype=dtype).to(device=device, dtype=dtype)
+    model.load_state_dict(state, strict=True)
+
+    def loss_value() -> torch.Tensor:
+        components = laplace1d_loss_components(
+            model,
+            data["x_solution"],
+            data["u_solution"],
+            data["x_boundary"],
+            data["u_boundary"],
+            data["x_pde"],
+        )
+        return weighted_loss(components, loss_weights)
+
+    lbfgs = torch.optim.LBFGS(
+        model.parameters(),
+        lr=refinement_lr,
+        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)
+        loss = loss_value()
+        if not torch.isfinite(loss):
+            raise FloatingPointError("BPINN refinement loss became non-finite")
+        loss.backward()
+        return loss
+
+    print(f"Input checkpoint: {input_path}")
+    print(f"Device: {device}")
+    lbfgs.step(closure)
+    with torch.no_grad():
+        prediction = model.predict_u(data["x_test"])
+    error = relative_l2(prediction, data["u_test"])
+    refined = dict(metadata)
+    refined.update(
+        {
+            "case": "laplace1d",
+            "architecture": "bpinn",
+            "model_state": model.state_dict(),
+            "model_config": model_config,
+            "data_config": data_config,
+            "loss_weights": loss_weights,
+            "seed": seed,
+            "refinement_iters": lbfgs_iters,
+            "final_l2": error,
+        }
+    )
+    output_path.parent.mkdir(parents=True, exist_ok=True)
+    torch.save(refined, output_path)
+    print(f"Relative L2 after refinement={error:.6e}")
+    print(f"Saved checkpoint: {output_path}")
+
+
+if __name__ == "__main__":
+    main()

scripts/train.py

@@ -0,0 +1,185 @@
+from __future__ import annotations
+
+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
+    build_laplace_data,
+    load_config,
+    project_path,
+    relative_l2,
+    resolve_device,
+    resolve_dtype,
+    seed_everything,
+)
+from model.bpinn import (  # noqa: E402
+    build_model,
+    laplace1d_loss_components,
+    weighted_loss,
+)
+
+
+DEFAULT_CONFIG = PROJECT_ROOT / "conf" / "config.yaml"
+
+
+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"])
+    epochs = int(config["training"]["epochs"])
+    lbfgs_iters = int(config["training"]["lbfgs_iters"])
+    learning_rate = float(config["training"]["lr"])
+    if min(epochs, lbfgs_iters) < 0 or epochs + lbfgs_iters == 0:
+        raise ValueError("at least one non-negative optimizer iteration count must be positive")
+    if learning_rate <= 0:
+        raise ValueError("learning rate must be positive")
+
+    data_config = dict(config["data"])
+    weight_dir = project_path(common["weight_dir"], PROJECT_ROOT)
+    result_dir = project_path(common["result_dir"], PROJECT_ROOT)
+    checkpoint_path = weight_dir / config["training"]["checkpoint_name"]
+    history_path = result_dir / config["inference"]["history_name"]
+    seed_everything(seed)
+
+    print(f"Config: {config_path}")
+    print(f"Device: {device}")
+    print(f"Data config: {data_config}")
+    data = build_laplace_data(data_config, seed, device, dtype)
+
+    with torch.enable_grad():
+        test_points = data["x_test"].detach().requires_grad_(True)
+        exact = torch.sin(torch.pi * test_points)
+        first = torch.autograd.grad(
+            exact, test_points, torch.ones_like(exact), create_graph=True
+        )[0]
+        second = torch.autograd.grad(
+            first, test_points, torch.ones_like(first), create_graph=True
+        )[0]
+        max_residual = torch.max(
+            torch.abs(second + torch.pi**2 * torch.sin(torch.pi * test_points))
+        ).item()
+    if max_residual > 1.0e-8:
+        raise RuntimeError(f"Laplace autograd validation failed: {max_residual:.3e}")
+    print(f"PDE autograd validation: {max_residual:.3e}")
+
+    model = build_model(config["model"], dtype=dtype).to(device=device, dtype=dtype)
+    parameter_count = sum(parameter.numel() for parameter in model.parameters())
+    print(f"Parameters: {parameter_count:,}")
+
+    def loss_value() -> tuple[torch.Tensor, dict[str, torch.Tensor]]:
+        components = laplace1d_loss_components(
+            model,
+            data["x_solution"],
+            data["u_solution"],
+            data["x_boundary"],
+            data["u_boundary"],
+            data["x_pde"],
+        )
+        return weighted_loss(components, config["loss"]), components
+
+    def evaluate() -> float:
+        with torch.no_grad():
+            prediction = model.predict_u(data["x_test"])
+        return relative_l2(prediction, data["u_test"])
+
+    optimizer = torch.optim.Adam(model.parameters(), lr=learning_rate)
+    loss_history = []
+    l2_history = []
+    log_interval = int(config["training"]["log_interval"])
+    best_l2 = evaluate()
+    started = time.time()
+    print(
+        f"Adam epochs={epochs} lr={learning_rate:g}, "
+        f"L-BFGS iterations={lbfgs_iters}"
+    )
+    for epoch in range(1, epochs + 1):
+        loss, components = loss_value()
+        if not torch.isfinite(loss):
+            raise FloatingPointError(f"BPINN loss became non-finite at epoch {epoch}")
+        optimizer.zero_grad(set_to_none=True)
+        loss.backward()
+        optimizer.step()
+        loss_history.append(loss.item())
+
+        if epoch == 1 or epoch % log_interval == 0 or epoch == epochs:
+            error = evaluate()
+            l2_history.append((epoch, error))
+            best_l2 = min(best_l2, error)
+            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:.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, _ = loss_value()
+            if not torch.isfinite(closure_loss):
+                raise FloatingPointError("BPINN L-BFGS loss became non-finite")
+            closure_loss.backward()
+            return closure_loss
+
+        lbfgs.step(closure)
+        error = evaluate()
+        l2_history.append((epochs + lbfgs_iters, error))
+        best_l2 = min(best_l2, error)
+        print(f"L-BFGS relative L2={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": "laplace1d",
+        "architecture": "bpinn",
+        "model_state": model.state_dict(),
+        "model_config": config["model"],
+        "data_config": data_config,
+        "loss_weights": config["loss"],
+        "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(loss_history, dtype=np.float64),
+        l2_steps=l2_array[:, 0],
+        l2_values=l2_array[:, 1],
+        final_l2=final_l2,
+        best_l2=best_l2,
+        elapsed_seconds=elapsed,
+        parameter_count=parameter_count,
+    )
+    print(f"Final relative L2={final_l2:.6e}, elapsed={elapsed:.1f}s")
+    print(f"Saved checkpoint: {checkpoint_path}")
+    print(f"Saved history: {history_path}")
+
+
+if __name__ == "__main__":
+    main()

weight/bpinn_laplace1d.pt

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