pinnforge 0.1.0__py3-none-any.whl

pinnforge/__init__.py

@@ -0,0 +1,57 @@
+"""
+PINNForge - Physics-Informed Neural Networks made easy
+"""
+
+from pinnforge.core.pinn import PINN, PINNTrainer, FourierFeatureMapping
+from pinnforge.physics.pdes import BurgersEquation, HeatEquation, WaveEquation, PDE, create_pde
+from pinnforge.utils.data import generate_simulation_data, add_noise
+from pinnforge.utils.logging import ExperimentLogger
+
+# Auto-solver
+from pinnforge.auto import AutoPINN, solve_pde
+
+# Symbolic
+try:
+    from pinnforge.symbolic import SymbolicPDE, SymbolicPINNTrainer
+except ImportError:
+    SymbolicPDE = None
+
+# Benchmarks
+try:
+    from pinnforge.benchmarks import compute_relative_l2_error, compute_metrics, BenchmarkRunner
+except ImportError:
+    compute_relative_l2_error = None
+
+__version__ = "0.1.0"
+
+__all__ = [
+    # One-line API
+    "solve_pde",
+    "AutoPINN",
+    
+    # Core
+    "PINN",
+    "PINNTrainer",
+    "FourierFeatureMapping",
+    
+    # Physics
+    "BurgersEquation",
+    "HeatEquation",
+    "WaveEquation",
+    "PDE",
+    "create_pde",
+    
+    # Utils
+    "generate_simulation_data",
+    "add_noise",
+    "ExperimentLogger",
+    
+    # Symbolic
+    "SymbolicPDE",
+    "SymbolicPINNTrainer",
+    
+    # Benchmarks
+    "compute_relative_l2_error",
+    "compute_metrics",
+    "BenchmarkRunner",
+]

pinnforge/auto/__init__.py

@@ -0,0 +1,4 @@
+from pinnforge.auto.solver import AutoPINN, solve_pde
+from pinnforge.auto.config import AutoConfig
+
+__all__ = ["AutoPINN", "solve_pde", "AutoConfig"]

pinnforge/auto/config.py

@@ -0,0 +1,93 @@
+"""
+Auto-configuration heuristics for PINNs.
+Based on PDE characteristics, auto-selects hyperparameters.
+"""
+import numpy as np
+from dataclasses import dataclass, field
+from typing import Tuple, List, Optional
+
+
+@dataclass
+class AutoConfig:
+    """
+    Auto-selected configuration for a PINN solve.
+    """
+    # Network
+    layers: List[int] = field(default_factory=lambda: [2, 64, 64, 64, 1])
+    activation: str = "tanh"
+    
+    # Fourier features
+    use_fourier: bool = False
+    fourier_scale: float = 8.0
+    
+    # Training
+    n_collocation: int = 10000
+    n_boundary: int = 200
+    n_initial: int = 200
+    epochs: int = 5000
+    learning_rate: float = 1e-3
+    batch_size: int = 1000
+    
+    # Loss
+    use_adaptive_weights: bool = False
+    weight_bc: float = 1.0
+    weight_ic: float = 1.0
+    
+    # Precision
+    precision: str = "float32"
+    
+    @classmethod
+    def for_pde(cls, pde_name: str, nu: Optional[float] = None, 
+                domain: Optional[List[Tuple]] = None) -> "AutoConfig":
+        """
+        Auto-select config based on PDE type and parameters.
+        
+        Heuristics based on PINNacle findings and common failure modes:
+        - Stiff problems (low nu) need more collocation + larger Fourier scale
+        - High-frequency problems need wider networks
+        - Long time domains need more collocation points
+        """
+        config = cls()
+        
+        if pde_name.lower() == "burgers":
+            if nu is not None and nu < 0.02:
+                # Stiff Burgers: needs more points, larger Fourier scale
+                config.layers = [2, 128, 128, 128, 1]
+                config.fourier_scale = 15.0
+                config.n_collocation = 20000
+                config.epochs = 10000
+                config.learning_rate = 5e-4
+            else:
+                config.layers = [2, 64, 64, 64, 1]
+                config.fourier_scale = 10.0
+                
+        elif pde_name.lower() == "heat":
+            config.layers = [2, 64, 64, 64, 1]
+            config.fourier_scale = 8.0
+            config.epochs = 3000
+            
+        elif pde_name.lower() == "wave":
+            # Wave equations are high-frequency sensitive
+            config.layers = [2, 96, 96, 96, 1]
+            config.fourier_scale = 20.0
+            config.epochs = 8000
+            config.precision = "float64"  # Waves need precision
+            
+        elif pde_name.lower() == "navier-stokes":
+            # NS is the hardest: needs big network + precision
+            config.layers = [3, 128, 128, 128, 128, 2]  # (x,y,t) -> (u,v)
+            config.fourier_scale = 12.0
+            config.n_collocation = 50000
+            config.epochs = 20000
+            config.learning_rate = 1e-4
+            config.precision = "float64"
+            
+        # Domain-based adjustments
+        if domain:
+            # Longer time domains need more collocation
+            t_range = domain[1] if len(domain) > 1 else (0, 1)
+            t_span = t_range[1] - t_range[0]
+            if t_span > 2:
+                config.n_collocation = int(config.n_collocation * t_span / 1.0)
+                
+        return config

pinnforge/auto/solver.py

@@ -0,0 +1,335 @@
+"""
+AutoPINN: One-function PDE solver.
+"""
+import torch
+import numpy as np
+from typing import Optional, List, Tuple, Dict, Any
+import warnings
+
+from pinnforge.core.pinn import PINN, PINNTrainer
+from pinnforge.physics.pdes import create_pde, PDE
+from pinnforge.utils.data import (
+    create_collocation_points,
+    create_boundary_points,
+    create_initial_points,
+)
+from pinnforge.auto.config import AutoConfig
+
+
+class AutoPINN:
+    """
+    Automatic PINN solver.
+    
+    One call to solve() does everything:
+    1. Selects hyperparameters based on PDE characteristics
+    2. Generates collocation/boundary/initial points
+    3. Builds network with Fourier features
+    4. Trains with adaptive loss weighting
+    5. Validates against numerical solver
+    6. Generates report with plots and metrics
+    
+    Example:
+        >>> solver = AutoPINN("burgers", nu=0.01)
+        >>> result = solver.solve()
+        >>> print(f"Relative L2 error: {result['metrics']['relative_l2_error']:.2e}")
+    """
+    
+    def __init__(
+        self,
+        pde_name: str,
+        nu: Optional[float] = None,
+        domain: Optional[List[Tuple[float, float]]] = None,
+        config: Optional[AutoConfig] = None,
+        device: str = "cpu",
+        verbose: bool = True,
+    ):
+        """
+        Args:
+            pde_name: Name of PDE ('burgers', 'heat', 'wave', 'navier-stokes')
+            nu: Viscosity parameter (for Burgers)
+            domain: Domain specification [(x_min, x_max), (t_min, t_max)]
+            config: Override auto-config (optional)
+            device: 'cpu' or 'cuda'
+            verbose: Print progress
+        """
+        self.pde_name = pde_name
+        self.nu = nu
+        self.domain = domain or [(0, 1), (0, 1)]
+        self.device = device
+        self.verbose = verbose
+        
+        # Auto-select config if not provided
+        if config is None:
+            self.config = AutoConfig.for_pde(pde_name, nu=nu, domain=domain)
+        else:
+            self.config = config
+        
+        # Create PDE
+        pde_kwargs = {}
+        if nu is not None:
+            pde_kwargs["nu"] = nu
+        self.pde = create_pde(pde_name, **pde_kwargs)
+        
+        # Placeholders
+        self.model = None
+        self.trainer = None
+        self.result = None
+    
+    @classmethod
+    def from_symbolic(
+        cls,
+        equation,
+        independent_vars: List,
+        dependent_var,
+        domain: Optional[List[Tuple[float, float]]] = None,
+        device: str = "cpu",
+        **kwargs,
+    ) -> "AutoPINN":
+        """
+        Create AutoPINN from a SymPy equation.
+        
+        Example:
+            >>> import sympy as sp
+            >>> x, t, u = sp.symbols('x t u')
+            >>> pde = sp.diff(u,t) + u*sp.diff(u,x) - 0.01*sp.diff(u,x,2)
+            >>> solver = AutoPINN.from_symbolic(pde, [x,t], u)
+        """
+        from pinnforge.symbolic.pde import SymbolicPDE
+        
+        symbolic_pde = SymbolicPDE(equation, dependent_var, independent_vars)
+        
+        # Determine "name" for config selection
+        n_vars = len(independent_vars)
+        if n_vars == 2:
+            name = "symbolic_2d"
+        elif n_vars == 3:
+            name = "symbolic_3d"
+        else:
+            name = "symbolic"
+        
+        # Create instance with symbolic PDE
+        instance = cls.__new__(cls)
+        instance.pde_name = name
+        instance.nu = None
+        instance.domain = domain or [(0, 1)] * n_vars
+        instance.device = device
+        instance.verbose = kwargs.get("verbose", True)
+        instance.pde = symbolic_pde
+        instance.config = AutoConfig.for_pde(name, domain=domain)
+        
+        if "config" in kwargs:
+            instance.config = kwargs["config"]
+        
+        instance.model = None
+        instance.trainer = None
+        instance.result = None
+        
+        return instance
+    
+    def solve(self, validate: bool = True) -> Dict[str, Any]:
+        """
+        Solve the PDE. This is the main entry point.
+        
+        Returns:
+            Dictionary with:
+            - model: Trained PINN
+            - trainer: PINNTrainer
+            - history: Training history
+            - metrics: Validation metrics (if validate=True)
+            - solution: Callable for predictions
+        """
+        if self.verbose:
+            print(f"[AutoPINN] Solving {self.pde_name} PDE")
+            print(f"  Config: {self.config.layers}, Fourier scale={self.config.fourier_scale}")
+            print(f"  Epochs: {self.config.epochs}, LR: {self.config.learning_rate}")
+        
+        # 1. Build model
+        self.model = PINN(
+            layers=self.config.layers,
+            activation=self.config.activation,
+            use_fourier_features=self.config.use_fourier,
+            fourier_scale=self.config.fourier_scale,
+            use_adaptive_activation=False,
+            device=self.device,
+        )
+        
+        # 2. Generate data
+        x_pde, t_pde = create_collocation_points(
+            x_range=self.domain[0],
+            t_range=self.domain[1] if len(self.domain) > 1 else (0, 1),
+            n_points=self.config.n_collocation,
+            device=self.device,
+        )
+        x_bc, t_bc = create_boundary_points(
+            x_range=self.domain[0],
+            t_range=self.domain[1] if len(self.domain) > 1 else (0, 1),
+            n_points=self.config.n_boundary,
+            device=self.device,
+        )
+        bc_values = self.pde.boundary_condition(x_bc, t_bc)
+        x_ic, t_ic = create_initial_points(
+            x_range=self.domain[0],
+            n_points=self.config.n_initial,
+            device=self.device,
+        )
+        ic_values = self.pde.initial_condition(x_ic)
+        
+        # 3. Train
+        self.trainer = PINNTrainer(
+            model=self.model,
+            pde_fn=self.pde.residual,
+            learning_rate=self.config.learning_rate,
+            use_adaptive_weights=self.config.use_adaptive_weights,
+            device=self.device,
+        )
+        
+        history = self.trainer.train(
+            x_pde=x_pde, t_pde=t_pde,
+            x_bc=x_bc, t_bc=t_bc, bc_values=bc_values,
+            x_ic=x_ic, t_ic=t_ic, ic_values=ic_values,
+            epochs=self.config.epochs,
+            batch_size=self.config.batch_size,
+            weights={"pde": 1.0, "bc": self.config.weight_bc, "ic": self.config.weight_ic},
+            verbose=self.verbose,
+        )
+        
+        # 4. Validate (optional)
+        metrics = {}
+        if validate and hasattr(self.pde, 'analytical_solution'):
+            metrics = self._validate()
+        
+        # 5. Build result
+        self.result = {
+            "model": self.model,
+            "trainer": self.trainer,
+            "history": history,
+            "metrics": metrics,
+            "config": self.config,
+            "predict": lambda x, t: self.trainer.predict(
+                torch.tensor(x, dtype=torch.float32, device=self.device).reshape(-1, 1),
+                torch.tensor(t, dtype=torch.float32, device=self.device).reshape(-1, 1),
+            ),
+        }
+        
+        if self.verbose:
+            print(f"[AutoPINN] Complete.")
+            if metrics:
+                print(f"  Relative L2 error: {metrics.get('relative_l2_error', 'N/A'):.4e}")
+        
+        return self.result
+    
+    def _validate(self) -> Dict[str, float]:
+        """Validate against analytical solution."""
+        from pinnforge.benchmarks.metrics import compute_metrics
+        
+        # Dense test grid
+        n_test = 5000
+        x_test = torch.linspace(
+            self.domain[0][0], self.domain[0][1], int(np.sqrt(n_test)),
+            device=self.device
+        ).reshape(-1, 1)
+        t_test = torch.linspace(
+            self.domain[1][0], self.domain[1][1], int(np.sqrt(n_test)),
+            device=self.device
+        ).reshape(-1, 1)
+        
+        X, T = torch.meshgrid(x_test.squeeze(), t_test.squeeze(), indexing='ij')
+        X_flat = X.reshape(-1, 1)
+        T_flat = T.reshape(-1, 1)
+        
+        with torch.no_grad():
+            u_pred = self.trainer.predict(X_flat, T_flat)
+        
+        try:
+            u_true = self.pde.analytical_solution(X_flat, T_flat)
+            return compute_metrics(u_pred, u_true)
+        except (NotImplementedError, AttributeError):
+        # No analytical solution available, skip validation
+            return {}
+
+    def report(self, save_path: Optional[str] = None):
+        """
+        Generate a visual report of the solution.
+        
+        Args:
+            save_path: Path to save the report image. If None, displays.
+        """
+        if self.result is None:
+            raise RuntimeError("Must call solve() before report()")
+        
+        import matplotlib.pyplot as plt
+        
+        # Create dense grid
+        n = 100
+        x = torch.linspace(self.domain[0][0], self.domain[0][1], n, device=self.device)
+        t = torch.linspace(
+            self.domain[1][0] if len(self.domain) > 1 else 0,
+            self.domain[1][1] if len(self.domain) > 1 else 1,
+            n, device=self.device
+        )
+        X, T = torch.meshgrid(x, t, indexing='ij')
+        X_flat = X.reshape(-1, 1)
+        T_flat = T.reshape(-1, 1)
+        
+        with torch.no_grad():
+            u_pred = self.trainer.predict(X_flat, T_flat).reshape(n, n)
+        
+        fig, axes = plt.subplots(1, 3, figsize=(15, 4))
+        
+        # Predicted solution
+        im1 = axes[0].contourf(X.cpu().numpy(), T.cpu().numpy(), u_pred.cpu().numpy(), levels=50, cmap='viridis')
+        axes[0].set_xlabel('x'); axes[0].set_ylabel('t')
+        axes[0].set_title('PINN Solution')
+        plt.colorbar(im1, ax=axes[0])
+        
+        # Training loss
+        if 'loss_total' in self.result['history']:
+            axes[1].semilogy(self.result['history']['loss_total'])
+            axes[1].set_xlabel('Epoch'); axes[1].set_ylabel('Loss')
+            axes[1].set_title('Training Convergence')
+            axes[1].grid(True, alpha=0.3)
+        
+        # Error (if analytical available)
+        if 'relative_l2_error' in self.result['metrics']:
+            u_true = self.pde.analytical_solution(X_flat, T_flat).reshape(n, n)
+            error = torch.abs(u_pred - u_true)
+            im3 = axes[2].contourf(X.cpu().numpy(), T.cpu().numpy(), error.cpu().numpy(), levels=50, cmap='hot')
+            axes[2].set_xlabel('x'); axes[2].set_ylabel('t')
+            axes[2].set_title(f'Error (max: {error.max():.2e})')
+            plt.colorbar(im3, ax=axes[2])
+        
+        plt.tight_layout()
+        if save_path:
+            plt.savefig(save_path, dpi=150)
+            print(f"[AutoPINN] Report saved to {save_path}")
+        else:
+            plt.show()
+
+
+def solve_pde(
+    pde_name: str,
+    nu: Optional[float] = None,
+    domain: Optional[List[Tuple[float, float]]] = None,
+    epochs: Optional[int] = None,
+    device: str = "cpu",
+    verbose: bool = True,
+) -> Dict[str, Any]:
+    """
+    One-line PDE solver.
+    
+    Example:
+        >>> result = solve_pde("burgers", nu=0.01, epochs=5000)
+        >>> print(result['metrics']['relative_l2_error'])
+    """
+    solver = AutoPINN(
+        pde_name=pde_name,
+        nu=nu,
+        domain=domain,
+        device=device,
+        verbose=verbose,
+    )
+    
+    if epochs is not None:
+        solver.config.epochs = epochs
+    
+    return solver.solve()

pinnforge/benchmarks/__init__.py

@@ -0,0 +1,4 @@
+from pinnforge.benchmarks.metrics import compute_relative_l2_error, compute_metrics
+from pinnforge.benchmarks.runner import BenchmarkRunner, run_benchmark
+
+__all__ = ["compute_relative_l2_error", "compute_metrics", "BenchmarkRunner", "run_benchmark"]

pinnforge/benchmarks/metrics.py

@@ -0,0 +1,106 @@
+"""
+Benchmarking metrics for PINN evaluation.
+Pure-PyTorch implementation, no external ML dependencies.
+"""
+import torch
+from typing import Dict, List
+
+
+def compute_relative_l2_error(
+    u_pred: torch.Tensor,
+    u_true: torch.Tensor,
+) -> float:
+    """
+    Compute relative L2 error.
+
+    Args:
+        u_pred: Predicted solution
+        u_true: Ground truth solution
+
+    Returns:
+        Relative L2 error
+    """
+    u_pred = u_pred.flatten()
+    u_true = u_true.flatten()
+
+    numerator = torch.norm(u_pred - u_true, p=2)
+    denominator = torch.norm(u_true, p=2)
+
+    if denominator == 0:
+        return 0.0
+
+    return (numerator / denominator).item()
+
+
+def compute_metrics(
+    u_pred: torch.Tensor,
+    u_true: torch.Tensor,
+) -> Dict[str, float]:
+    """
+    Compute comprehensive set of metrics.
+
+    Returns:
+        Dictionary with: relative_l2_error, mse, rmse, r2_score, max_error, mean_error
+    """
+    u_pred = u_pred.flatten().detach()
+    u_true = u_true.flatten().detach()
+
+    # Mean squared error
+    mse = torch.mean((u_pred - u_true) ** 2).item()
+
+    # Root mean squared error
+    rmse = mse ** 0.5
+
+    # R^2 score: 1 - SS_res / SS_tot
+    ss_res = torch.sum((u_true - u_pred) ** 2)
+    ss_tot = torch.sum((u_true - u_true.mean()) ** 2)
+    if ss_tot.item() == 0:
+        r2 = 0.0
+    else:
+        r2 = (1.0 - ss_res / ss_tot).item()
+
+    return {
+        "relative_l2_error": compute_relative_l2_error(u_pred, u_true),
+        "mse": mse,
+        "rmse": rmse,
+        "r2_score": r2,
+        "max_error": torch.max(torch.abs(u_pred - u_true)).item(),
+        "mean_error": torch.mean(torch.abs(u_pred - u_true)).item(),
+    }
+
+
+def compute_convergence_rate(
+    errors: List[float],
+    iterations: List[int],
+) -> float:
+    """
+    Estimate convergence rate from error history.
+
+    Args:
+        errors: List of errors over iterations
+        iterations: Corresponding iteration numbers
+
+    Returns:
+        Convergence rate (higher is better)
+    """
+    if len(errors) < 2:
+        return 0.0
+
+    import math
+
+    # Fit power law: error = C * iter^(-rate)
+    log_errors = [math.log(e) for e in errors]
+    log_iters = [math.log(i) for i in iterations]
+
+    n = len(log_errors)
+    mean_x = sum(log_iters) / n
+    mean_y = sum(log_errors) / n
+
+    num = sum((log_iters[i] - mean_x) * (log_errors[i] - mean_y) for i in range(n))
+    den = sum((log_iters[i] - mean_x) ** 2 for i in range(n))
+
+    if den == 0:
+        return 0.0
+
+    slope = num / den
+    return -slope