daehn 2.0.0__py3-none-any.whl

daehn/__init__.py

@@ -0,0 +1,28 @@
+"""Differential hard-constrained learning through OHAGI and PURIN."""
+
+import sys as _sys
+from importlib import import_module as _module
+from .api.root import *  # noqa: F403 - compatibility facade mirrors upstream exports
+from .api.root import __all__ as __all__, __version__ as __version__
+
+# Current public benchmark paths point directly to their implementations.
+# No legacy implementation tree or import hook is installed.
+for _name, _target in {
+    "dae": "daehn.api.differential",
+    "dae.model": "daehn.api.differential.reconstruction",
+    "dae.conditions": "daehn.api.differential.conditions",
+    "dae.discretization": "daehn.api.differential.discretization",
+    "opt": "daehn.api.projection",
+    "opt.layers": "daehn.api.projection",
+    "opt.layers.projection": "daehn.api.projection",
+    "train": "ohagi.training",
+    "train.projected_neural": "daehn.api.root",
+    "train.steps": "ohagi.training.steps",
+    "nn": "daehn.api.network",
+    "problems": "daehn.api.problem",
+    "losses": "ohagi.losses",
+    "runtime": "ohagi.execution.runtime",
+    "tree": "ohagi._utils.tree",
+}.items():
+    _sys.modules[__name__ + "." + _name] = _module(_target)
+del _name, _target

daehn/api/__init__.py

@@ -0,0 +1,49 @@
+"""Problem-specific DAEHN adapters to OHAGI and PURIN."""
+
+from importlib import import_module
+
+__all__ = [
+    "nn",
+    "opt",
+    "problems",
+    "dae",
+    "train",
+    "losses",
+    "runtime",
+    "tree",
+    "Problem",
+    "SymbolicProblem",
+    "FunctionalProblem",
+    "MatrixProblem",
+    "ParametricLP",
+    "ParametricQP",
+    "ProjectionConfig",
+    "LinearSolverConfig",
+    "ImplicitGradientConfig",
+    "DAEHardNet",
+    "ProjectedNeuralModel",
+    "MLPBackbone",
+    "FlaxMLPBackbone",
+    "Adam",
+    "AdamState",
+    "BuildReport",
+    "PredictionOutput",
+    "ProjectedMetrics",
+    "CompiledProjectedGraphs",
+    "ProjectionLayerOutput",
+    "ImplicitProjectionLayer",
+    "make_implicit_projection_layer",
+    "apply_updates",
+    "configure_compilation_cache",
+    "save_predictor",
+    "load_predictor",
+]
+
+
+def __getattr__(name):
+    if name not in __all__ and name != "__version__":
+        raise AttributeError(name)
+    root = import_module("daehn.api.root")
+    if name in root.__all__ or name == "__version__":
+        return getattr(root, name)
+    raise AttributeError(name)

daehn/api/configuration.py

@@ -0,0 +1,20 @@
+"""DAEHN defaults for the common PURIN solver configuration."""
+
+from dataclasses import dataclass, field
+from purin.solvers.config import ImplicitGradientConfig as ImplicitGradientConfig
+from purin.solvers.config import LinearSolverConfig as _Linear
+from purin.solvers.config import ProjectionConfig as _Projection
+
+
+@dataclass(frozen=True)
+class LinearSolverConfig(_Linear):
+    """DAE frontend defaults for PURIN's linear-system solver configuration."""
+
+    max_iterations: int = 50
+
+
+@dataclass(frozen=True)
+class ProjectionConfig(_Projection):
+    """DAE frontend defaults for projection tolerance, iteration and gradient policy."""
+
+    linear_solver: _Linear = field(default_factory=LinearSolverConfig)

daehn/api/data.py

@@ -0,0 +1,83 @@
+"""Deterministic array datasets for DAE training, conditions, and examples."""
+
+from __future__ import annotations
+from dataclasses import dataclass
+from pathlib import Path
+import numpy as np
+
+
+@dataclass(frozen=True)
+class DAEData:
+    """Observation arrays and optional derivative/condition supervision for a DAE.
+
+    Attributes:
+        coordinates: Coordinate observations with a leading sample dimension.
+        parameters: Physical parameter observations aligned with coordinates.
+        states: Observed differential and algebraic state values.
+        derivatives: Optional derivative targets in the compiled derivative order.
+        initial_coordinates: Optional points for initial-condition supervision.
+        initial_targets: Optional state targets at those initial points.
+        boundary_coordinates: Optional points for boundary-condition supervision.
+        boundary_targets: Optional state targets at those boundary points.
+        initial_mask: Optional mask selecting initial-condition observations.
+        boundary_mask: Optional mask selecting boundary-condition observations.
+
+    Notes:
+        ``save`` and ``load`` preserve optional fields through the NPZ dataset
+        format. These datasets are separate from model inference artifacts.
+    """
+
+    coordinates: np.ndarray
+    parameters: np.ndarray
+    states: np.ndarray
+    derivatives: np.ndarray | None = None
+    initial_coordinates: np.ndarray | None = None
+    initial_targets: np.ndarray | None = None
+    boundary_coordinates: np.ndarray | None = None
+    boundary_targets: np.ndarray | None = None
+    initial_mask: np.ndarray | None = None
+    boundary_mask: np.ndarray | None = None
+
+    def save(self, path):
+        """Save observation arrays to NPZ, encoding absent optional fields as empty arrays."""
+        path = Path(path)
+        path.parent.mkdir(parents=True, exist_ok=True)
+
+        def value(x):
+            return np.asarray([]) if x is None else np.asarray(x)
+
+        np.savez(
+            path,
+            coordinates=self.coordinates,
+            parameters=self.parameters,
+            states=self.states,
+            derivatives=value(self.derivatives),
+            initial_coordinates=value(self.initial_coordinates),
+            initial_targets=value(self.initial_targets),
+            boundary_coordinates=value(self.boundary_coordinates),
+            boundary_targets=value(self.boundary_targets),
+            initial_mask=value(self.initial_mask),
+            boundary_mask=value(self.boundary_mask),
+        )
+
+    @classmethod
+    def load(cls, path):
+        """Restore NPZ observations and decode empty optional fields as None."""
+        data = np.load(path)
+
+        def optional(name):
+            value = data[name]
+            return None if value.size == 0 else value
+
+        return cls(
+            data["coordinates"],
+            data["parameters"],
+            data["states"],
+            optional("derivatives"),
+            optional("initial_coordinates"),
+            optional("initial_targets"),
+            optional("boundary_coordinates"),
+            optional("boundary_targets"),
+            optional("initial_mask"),
+            optional("boundary_mask"),
+        )

daehn/api/differential/__init__.py

@@ -0,0 +1,71 @@
+"""Continuous DAE formulation and discretization frontend for DAEHN."""
+
+from daehn.api.differential.symbols import Coordinate
+from daehn.api.differential.symbols import DifferentialState
+from daehn.api.differential.symbols import AlgebraicState
+from daehn.api.differential.symbols import Parameter
+from daehn.api.differential.derivatives import DerivativeSpec
+from daehn.api.differential.derivatives import derivative_closure
+from daehn.api.differential.equations import EquationBlock
+from daehn.api.differential.system import DAESystem
+from daehn.api.differential.scaling import ScalingConfig
+from daehn.api.differential.compiler import compile_dae
+from daehn.api.differential.compiler import CompiledDAE
+from daehn.api.differential.compiler import PreparedDAEProjection
+from daehn.api.differential.reconstruction import FullModelDerivativePlan
+from daehn.api.differential.reconstruction import ProjectedDAEModel
+from daehn.api.differential.reconstruction import extract_network_derivatives
+from daehn.api.data import DAEData
+from daehn.api.fit import DAETrainer
+from daehn.api.fit import DAETrainingConfig
+from daehn.api.fit import DAETrainingResult
+from daehn.api.logging import DAETrainingLogger
+from daehn.api.objectives import physical_residual_blocks
+from daehn.api.objectives import physical_violation_metrics
+from daehn.api.objectives import dae_metrics
+from daehn.api.differential.discretization import TaylorNeighborhood
+from daehn.api.differential.discretization import ForwardDifference
+from daehn.api.differential.discretization import CentralDifference
+from daehn.api.differential.conditions import Condition
+from daehn.api.differential.conditions import InitialCondition
+from daehn.api.differential.conditions import BoundaryCondition
+from daehn.api.differential.conditions import sample_condition_coordinates
+from daehn.api.differential.conditions import condition_mse
+from daehn.api.differential.conditions import hard_initial_transform
+from daehn.api.differential.conditions import homogeneous_box_transform
+
+__all__ = [
+    "Coordinate",
+    "DifferentialState",
+    "AlgebraicState",
+    "Parameter",
+    "DerivativeSpec",
+    "derivative_closure",
+    "EquationBlock",
+    "DAESystem",
+    "ScalingConfig",
+    "compile_dae",
+    "CompiledDAE",
+    "PreparedDAEProjection",
+    "FullModelDerivativePlan",
+    "ProjectedDAEModel",
+    "extract_network_derivatives",
+    "DAEData",
+    "DAETrainer",
+    "DAETrainingConfig",
+    "DAETrainingResult",
+    "DAETrainingLogger",
+    "physical_residual_blocks",
+    "physical_violation_metrics",
+    "dae_metrics",
+    "TaylorNeighborhood",
+    "ForwardDifference",
+    "CentralDifference",
+    "Condition",
+    "InitialCondition",
+    "BoundaryCondition",
+    "sample_condition_coordinates",
+    "condition_mse",
+    "hard_initial_transform",
+    "homogeneous_box_transform",
+]