physai 0.1.0__py3-none-any.whl

physai/__init__.py

@@ -0,0 +1,6 @@
+from .pinn import PINN
+from .physics import *
+from .losses import *
+from .trainer import *
+from .visualization import *
+from .utils import *

physai/losses.py

@@ -0,0 +1,66 @@
+import torch
+
+# ------------------------------
+# Basic Residual Loss
+# ------------------------------
+def residual_loss(residual):
+    """
+    Compute the mean squared residual loss for PINNs.
+    residual: tensor or tuple of tensors (for systems like Navier-Stokes)
+    """
+    if isinstance(residual, tuple):
+        # Sum of losses for multiple residuals
+        return sum(torch.mean(r**2) for r in residual)
+    else:
+        return torch.mean(residual**2)
+
+# ------------------------------
+# Boundary / Initial Condition Loss
+# ------------------------------
+def bc_loss(pred, target):
+    """
+    Compute MSE loss for boundary or initial conditions.
+    pred: predicted values at BC/IC points
+    target: true values at BC/IC points
+    """
+    return torch.mean((pred - target)**2)
+
+# ------------------------------
+# Combined PINN Loss
+# ------------------------------
+def pinn_loss(model, collocation_points, pde_type, bc_points=None, bc_values=None, **kwargs):
+    """
+    Compute total loss for PINNs: PDE residual + BC loss
+    model: PINN model
+    collocation_points: points where PDE is enforced
+    pde_type: string specifying PDE/ODE type
+    bc_points: tensor for boundary/initial points
+    bc_values: tensor for boundary/initial values
+    kwargs: extra parameters for PDE residual (nu, r, K, gamma, etc.)
+    """
+    from physai.physics import pde_residual
+    
+    # PDE Residual
+    residual = pde_residual(model, collocation_points, pde_type, **kwargs)
+    res_loss = residual_loss(residual)
+    
+    # Boundary / Initial Condition Loss
+    bc_l = torch.tensor(0.0)
+    if bc_points is not None and bc_values is not None:
+        pred_bc = model(bc_points)
+        bc_l = bc_loss(pred_bc, bc_values)
+    
+    # Total loss (sum)
+    total_loss = res_loss + bc_l
+    return total_loss, res_loss, bc_l
+
+# ------------------------------
+# Weighted Loss
+# ------------------------------
+def weighted_pinn_loss(model, collocation_points, pde_type, bc_points=None, bc_values=None, pde_weight=1.0, bc_weight=1.0, **kwargs):
+    """
+    Weighted PINN loss for flexibility
+    """
+    total, res_loss, bc_l = pinn_loss(model, collocation_points, pde_type, bc_points, bc_values, **kwargs)
+    total = pde_weight*res_loss + bc_weight*bc_l
+    return total, res_loss, bc_l

physai/pde_residual.py

@@ -0,0 +1,128 @@
+import torch
+
+# ------------------------------
+# Utility: derivatives
+# ------------------------------
+def derivative(y, x, order=1):
+    for _ in range(order):
+        y = torch.autograd.grad(y, x, grad_outputs=torch.ones_like(y), create_graph=True)[0]
+    return y
+
+# ------------------------------
+# Unified PDE/ODE Residual
+# ------------------------------
+def pde_residual(model, inputs, pde_type, **kwargs):
+    """
+    Compute residual for various ODEs/PDEs automatically.
+    
+    model: torch.nn model
+    inputs: tensor of shape [N, D] where D = 1,2,3 (x, y, z / x, t / x, y, t)
+    pde_type: str, e.g. "heat", "wave", "burgers", "kdv", "laplace", "poisson", "schrodinger",
+                      "navier_stokes_2d", "logistic", "sho", "damped_ho",
+                      "markov", "planck", "newton_cooling", "photoelectric"
+    kwargs: extra parameters (nu, c, alpha, beta, V, f, r, K, gamma, etc.)
+    """
+    
+    # Enable gradients
+    inputs = inputs.clone().detach().requires_grad_(True)
+    u_val = model(inputs)
+    
+    # ------------------ 1D ODEs ------------------
+    if pde_type == "logistic":
+        r = kwargs.get("r", 1.0)
+        K = kwargs.get("K", 1.0)
+        return derivative(u_val, inputs[:,0:1]) - r*u_val*(1 - u_val/K)
+    
+    if pde_type == "sho":
+        return derivative(u_val, inputs[:,0:1], 2) + u_val
+    
+    if pde_type == "damped_ho":
+        gamma = kwargs.get("gamma", 0.1)
+        return derivative(u_val, inputs[:,0:1], 2) + gamma*derivative(u_val, inputs[:,0:1]) + u_val
+
+    if pde_type == "newton_cooling":
+        T_env = kwargs.get("T_env", 25.0)
+        k = kwargs.get("k", 0.1)
+        return derivative(u_val, inputs[:,0:1]) + k*(u_val - T_env)
+    
+    # ------------------ 1D PDEs ------------------
+    if pde_type == "heat":
+        x = inputs[:,0:1]; t = inputs[:,1:2]
+        return derivative(u_val, t) - derivative(u_val, x, 2)
+    
+    if pde_type == "wave":
+        x = inputs[:,0:1]; t = inputs[:,1:2]
+        c = kwargs.get("c", 1.0)
+        return derivative(u_val, t, 2) - c**2 * derivative(u_val, x, 2)
+    
+    if pde_type == "burgers":
+        x = inputs[:,0:1]; t = inputs[:,1:2]; nu = kwargs.get("nu", 0.01)
+        return derivative(u_val, t) + u_val*derivative(u_val, x) - nu*derivative(u_val, x, 2)
+    
+    if pde_type == "kdv":
+        x = inputs[:,0:1]; t = inputs[:,1:2]
+        alpha = kwargs.get("alpha", 6.0)
+        beta  = kwargs.get("beta", 1.0)
+        return derivative(u_val, t) + alpha*u_val*derivative(u_val, x) + beta*derivative(u_val, x, 3)
+    
+    if pde_type == "convection_diffusion":
+        x = inputs[:,0:1]; t = inputs[:,1:2]
+        c = kwargs.get("c", 1.0); D = kwargs.get("D", 0.01)
+        return derivative(u_val, t) + c*derivative(u_val, x) - D*derivative(u_val, x, 2)
+    
+    if pde_type == "markov":
+        x = inputs[:,0:1]; t = inputs[:,1:2]
+        D = kwargs.get("D", 0.1)
+        return derivative(u_val, t) - D*derivative(u_val, x, 2)
+
+    if pde_type == "planck":
+        freq = inputs[:,0:1]; T = inputs[:,1:2]
+        exact = kwargs.get("exact_planck")
+        if exact is None:
+            raise ValueError("Provide exact_planck(freq, T) function for Planck residual")
+        return u_val - exact(freq, T)
+
+    if pde_type == "photoelectric":
+        freq = inputs[:,0:1]; work_func = kwargs.get("work_func", 1.0)
+        return u_val - torch.maximum(torch.zeros_like(freq), freq - work_func)
+    
+    # ------------------ 2D PDEs ------------------
+    if pde_type == "laplace":
+        x, y = inputs[:,0:1], inputs[:,1:2]
+        return derivative(u_val, x, 2) + derivative(u_val, y, 2)
+    
+    if pde_type == "poisson":
+        x, y = inputs[:,0:1], inputs[:,1:2]
+        f = kwargs.get("f", lambda x,y: torch.zeros_like(x))
+        return derivative(u_val, x, 2) + derivative(u_val, y, 2) - f(x, y)
+    
+    if pde_type == "schrodinger":
+        x, t = inputs[:,0:1], inputs[:,1:2]
+        hbar = kwargs.get("hbar", 1.0); m = kwargs.get("m", 1.0)
+        V = kwargs.get("V", None)
+        V_val = V(inputs) if V is not None else torch.zeros_like(u_val)
+        return 1j*hbar*derivative(u_val, t) + (hbar**2/(2*m))*derivative(u_val, x, 2) - V_val*u_val
+    
+    if pde_type == "navier_stokes_2d":
+        x, y, t = inputs[:,0:1], inputs[:,1:2], inputs[:,2:3]
+        model_u = kwargs.get("model_u")
+        model_v = kwargs.get("model_v")
+        model_p = kwargs.get("model_p")
+        nu = kwargs.get("nu", 0.01)
+        U = model_u(inputs); V = model_v(inputs); P = model_p(inputs)
+        res_u = derivative(U, t) + U*derivative(U, x) + V*derivative(U, y) + derivative(P, x) - nu*(derivative(U, x,2)+derivative(U, y,2))
+        res_v = derivative(V, t) + U*derivative(V, x) + V*derivative(V, y) + derivative(P, y) - nu*(derivative(V, x,2)+derivative(V, y,2))
+        res_cont = derivative(U, x) + derivative(V, y)
+        return res_u, res_v, res_cont
+    
+    # ------------------ 3D PDEs ------------------
+    if pde_type == "laplace_3d":
+        x, y, z = inputs[:,0:1], inputs[:,1:2], inputs[:,2:3]
+        return derivative(u_val, x, 2) + derivative(u_val, y, 2) + derivative(u_val, z, 2)
+    
+    if pde_type == "poisson_3d":
+        x, y, z = inputs[:,0:1], inputs[:,1:2], inputs[:,2:3]
+        f = kwargs.get("f", lambda x,y,z: torch.zeros_like(x))
+        return derivative(u_val, x, 2) + derivative(u_val, y, 2) + derivative(u_val, z, 2) - f(x,y,z)
+    
+    raise ValueError(f"PDE/ODE type '{pde_type}' not implemented")

physai/physics.py

@@ -0,0 +1,76 @@
+import torch
+
+def derivative(y, x, order=1):
+    for _ in range(order):
+        y = torch.autograd.grad(y, x, grad_outputs=torch.ones_like(y), create_graph=True)[0]
+    return y
+
+# 1D ODEs
+def dy_dx_equals_y(x, model):
+    x.requires_grad_(True)
+    y = model(x)
+    return derivative(y, x) - y
+
+def dy_dx_equals_func(x, model, func):
+    x.requires_grad_(True)
+    y = model(x)
+    return derivative(y, x) - func(x)
+
+def second_order_ode(x, model):
+    x.requires_grad_(True)
+    y = model(x)
+    return derivative(y, x, 2) + y
+
+def damped_harmonic_oscillator(x, model, gamma=0.1):
+    x.requires_grad_(True)
+    y = model(x)
+    return derivative(y, x, 2) + gamma*derivative(y, x) + y
+
+def logistic_growth(x, model, r=1.0, K=1.0):
+    x.requires_grad_(True)
+    y = model(x)
+    return derivative(y, x) - r*y*(1 - y/K)
+
+# 1D PDEs
+def heat_equation(u, x, t, model):
+    x.requires_grad_(True)
+    t.requires_grad_(True)
+    u_val = model(torch.cat([x, t], dim=1))
+    return derivative(u_val, t) - derivative(u_val, x, 2)
+
+def wave_equation(u, x, t, model, c=1.0):
+    x.requires_grad_(True)
+    t.requires_grad_(True)
+    u_val = model(torch.cat([x, t], dim=1))
+    return derivative(u_val, t, 2) - c**2 * derivative(u_val, x, 2)
+
+def burgers_equation(u, x, t, model, nu=0.01):
+    x.requires_grad_(True)
+    t.requires_grad_(True)
+    u_val = model(torch.cat([x, t], dim=1))
+    return derivative(u_val, t) + u_val*derivative(u_val, x) - nu*derivative(u_val, x, 2)
+
+def kdv_equation(u, x, t, model, alpha=6.0, beta=1.0):
+    x.requires_grad_(True)
+    t.requires_grad_(True)
+    u_val = model(torch.cat([x, t], dim=1))
+    return derivative(u_val, t) + alpha*u_val*derivative(u_val, x) + beta*derivative(u_val, x, 3)
+
+def convection_diffusion(u, x, t, model, c=1.0, D=0.01):
+    x.requires_grad_(True)
+    t.requires_grad_(True)
+    u_val = model(torch.cat([x, t], dim=1))
+    return derivative(u_val, t) + c*derivative(u_val, x) - D*derivative(u_val, x, 2)
+
+# 2D PDEs
+def laplace_equation(u, x, y, model):
+    x.requires_grad_(True)
+    y.requires_grad_(True)
+    u_val = model(torch.cat([x, y], dim=1))
+    return derivative(u_val, x, 2) + derivative(u_val, y, 2)
+
+def poisson_equation(u, x, y, f, model):
+    x.requires_grad_(True)
+    y.requires_grad_(True)
+    u_val = model(torch.cat([x, y], dim=1))
+    return derivative(u_val, x, 2) + derivative(u_val, y, 2) - f(x, y)

physai/pinn.py

@@ -0,0 +1,78 @@
+import torch
+import torch.nn as nn
+import torch.optim as optim
+from torch.cuda.amp import autocast
+from torch.amp import grad_scaler as GradScaler
+class PINN(nn.Module):
+    """Physics-Informed Neural Network (PINN) with advanced optimization features."""
+
+    def __init__(self, layers, activation='tanh', device=None):
+        super().__init__()
+        # Set device
+        self.device = device if device else ('cuda' if torch.cuda.is_available() else 'cpu')
+        # Build the neural network
+        self.model = self._build_network(layers, activation).to(self.device)
+        # Store training history
+        self.history = {"loss": []}
+
+    def _build_network(self, layers, activation):
+        """Construct a fully connected network with specified activation and Xavier initialization."""
+        net = []
+        activations = {
+            'tanh': nn.Tanh(),
+            'relu': nn.ReLU(),
+            'gelu': nn.GELU(),
+            'silu': nn.SiLU()
+        }
+        act = activations.get(activation.lower(), nn.Tanh())
+
+        for i in range(len(layers) - 1):
+            linear = nn.Linear(layers[i], layers[i + 1])
+            nn.init.xavier_uniform_(linear.weight)
+            nn.init.zeros_(linear.bias)
+            net.append(linear)
+            if i < len(layers) - 2:
+                net.append(act)
+        return nn.Sequential(*net)
+
+    def forward(self, x):
+        return self.model(x)
+
+    def physics_loss(self, x, physics_fn):
+        """Compute physics-integrated loss."""
+        x = x.to(self.device).requires_grad_(True)
+        y = self.forward(x)
+        residual = physics_fn(x, y)
+        return torch.mean(residual ** 2)
+
+    def train_model(self, x, physics_fn, lr=1e-3, epochs=1000, verbose=True,
+                    clip_grad=None, scheduler=None, use_amp=True):
+        """Train the PINN with advanced options: AMP, gradient clipping, scheduler."""
+        optimizer = optim.Adam(self.parameters(), lr=lr)
+        scaler = GradScaler(enabled=use_amp)
+
+        if scheduler:
+            scheduler = scheduler(optimizer)
+
+        for epoch in range(epochs):
+            optimizer.zero_grad()
+            with autocast(enabled=use_amp):
+                loss = self.physics_loss(x, physics_fn)
+
+            scaler.scale(loss).backward()
+
+            if clip_grad:
+                scaler.unscale_(optimizer)
+                nn.utils.clip_grad_norm_(self.parameters(), clip_grad)
+
+            scaler.step(optimizer)
+            scaler.update()
+
+            if scheduler:
+                scheduler.step()
+
+            self.history["loss"].append(loss.item())
+            if verbose and (epoch % max(epochs // 10, 1) == 0 or epoch == epochs - 1):
+                print(f"Epoch {epoch+1}/{epochs} - Loss: {loss.item():.6f}")
+
+        return self.history

physai/trainer.py

@@ -0,0 +1,68 @@
+import torch
+from torch import optim
+from .losses import pinn_loss
+from .visualization import plot_loss
+
+class Trainer:
+    """
+    Trainer class for Physics-Informed Neural Networks (PINNs)
+    Supports:
+        - Mixed precision training (AMP)
+        - Gradient clipping
+        - Optional learning rate scheduler
+        - Logging & plotting
+        - Flexible handling of ODE/PDE types
+    """
+
+    def __init__(self, model, collocation_points, pde_type, bc_points=None, bc_values=None, device=None):
+        self.model = model
+        self.x = collocation_points
+        self.pde_type = pde_type
+        self.bc_x = bc_points
+        self.bc_y = bc_values
+        self.device = device or ('cuda' if torch.cuda.is_available() else 'cpu')
+
+        self.model.to(self.device)
+        self.history = {"total_loss": [], "res_loss": [], "bc_loss": []}
+        self.scaler = torch.cuda.amp.GradScaler(enabled=self.device.startswith("cuda"))
+
+    def train(self, epochs=1000, lr=1e-3, scheduler_fn=None, clip_grad=None, verbose=True, **kwargs):
+        optimizer = optim.Adam(self.model.parameters(), lr=lr)
+        scheduler = scheduler_fn(optimizer) if scheduler_fn else None
+
+        x = self.x.to(self.device)
+        bc_x = self.bc_x.to(self.device) if self.bc_x is not None else None
+        bc_y = self.bc_y.to(self.device) if self.bc_y is not None else None
+
+        for epoch in range(epochs):
+            optimizer.zero_grad()
+            with torch.cuda.amp.autocast(enabled=self.device.startswith("cuda")):
+                total, res_l, bc_l = pinn_loss(
+                    self.model, x, self.pde_type, bc_points=bc_x, bc_values=bc_y, **kwargs
+                )
+
+            self.scaler.scale(total).backward()
+
+            if clip_grad:
+                self.scaler.unscale_(optimizer)
+                torch.nn.utils.clip_grad_norm_(self.model.parameters(), clip_grad)
+
+            self.scaler.step(optimizer)
+            self.scaler.update()
+
+            if scheduler:
+                scheduler.step()
+
+            self.history["total_loss"].append(total.item())
+            self.history["res_loss"].append(res_l.item())
+            self.history["bc_loss"].append(bc_l.item())
+
+            if verbose and (epoch % max(epochs // 10, 1) == 0 or epoch == epochs - 1):
+                print(f"Epoch {epoch+1}/{epochs} | Total: {total.item():.6e} | "
+                      f"Res: {res_l.item():.6e} | BC: {bc_l.item():.6e}")
+
+        return self.history
+
+    def plot_training_loss(self):
+        """Plot training loss curves"""
+        plot_loss(self.history, title=f"Training Loss for {self.pde_type}")

physai/utils.py

@@ -0,0 +1,4 @@
+import torch
+
+def to_device(tensor, device='cpu'):
+    return tensor.to(device)

physai/visualization.py

@@ -0,0 +1,137 @@
+import torch
+import matplotlib.pyplot as plt
+import matplotlib.animation as animation
+from mpl_toolkits.mplot3d import Axes3D
+
+# ------------------------------
+# 1D plotting for ODEs / PDEs
+# ------------------------------
+def plot_1d_solution(model, x, exact=None, title="1D Solution", device=None):
+    """
+    Plot 1D solution of a model or function.
+    model: torch model or callable
+    x: tensor of shape [N,1]
+    exact: optional exact solution for comparison
+    """
+    device = device or ('cuda' if torch.cuda.is_available() else 'cpu')
+    x = x.to(device)
+    
+    with torch.no_grad():
+        y_pred = model(x).cpu().numpy()
+    
+    plt.figure(figsize=(8,5))
+    plt.plot(x.cpu().numpy(), y_pred, label="Predicted", lw=2)
+    if exact is not None:
+        plt.plot(x.cpu().numpy(), exact.cpu().numpy(), "--", label="Exact", lw=2)
+    plt.xlabel("x")
+    plt.ylabel("y")
+    plt.title(title)
+    plt.legend()
+    plt.grid(True)
+    plt.show()
+
+
+# ------------------------------
+# 2D Surface Plotting
+# ------------------------------
+def plot_2d_surface(model, X, Y, title="2D Surface", device=None):
+    """
+    Plot 2D surface of a model: inputs X,Y tensors of shape [N,1]
+    """
+    device = device or ('cuda' if torch.cuda.is_available() else 'cpu')
+    X = X.to(device)
+    Y = Y.to(device)
+    XY = torch.cat([X, Y], dim=1)
+    
+    with torch.no_grad():
+        Z = model(XY).cpu().numpy()
+    
+    fig = plt.figure(figsize=(8,6))
+    ax = fig.add_subplot(111, projection='3d')
+    ax.plot_trisurf(X.cpu().numpy().ravel(), Y.cpu().numpy().ravel(), Z.ravel(), cmap="viridis")
+    ax.set_xlabel("X")
+    ax.set_ylabel("Y")
+    ax.set_zlabel("U")
+    ax.set_title(title)
+    plt.show()
+
+
+# ------------------------------
+# 2D / 3D Animation over Time
+# ------------------------------
+def animate_2d(model, x, t, title="2D PDE Evolution", interval=100, device=None):
+    """
+    Animate a 2D PDE solution over time
+    x: tensor [N,1] spatial points
+    t: tensor [M,1] time points
+    """
+    device = device or ('cuda' if torch.cuda.is_available() else 'cpu')
+    x = x.to(device)
+    t = t.to(device)
+    
+    fig, ax = plt.subplots()
+    line, = ax.plot([], [], lw=2)
+    
+    ax.set_xlim(float(x.min()), float(x.max()))
+    ax.set_ylim(-1.0, 1.0)  # adjust according to problem
+    ax.set_xlabel("x")
+    ax.set_ylabel("u(x,t)")
+    ax.set_title(title)
+    
+    def init():
+        line.set_data([], [])
+        return line,
+    
+    def update(frame):
+        t_i = t[frame].repeat(x.shape[0],1)
+        xt = torch.cat([x, t_i], dim=1)
+        with torch.no_grad():
+            y = model(xt).cpu().numpy()
+        line.set_data(x.cpu().numpy(), y.ravel())
+        ax.set_title(f"{title} | t={t[frame].item():.2f}")
+        return line,
+    
+    ani = animation.FuncAnimation(fig, update, frames=len(t), init_func=init, blit=True, interval=interval)
+    plt.show()
+    return ani
+
+
+# ------------------------------
+# Loss Plotting
+# ------------------------------
+def plot_loss(history, title="Training Loss"):
+    """
+    Plot training loss curves
+    history: dict with keys 'total_loss', 'res_loss', 'bc_loss'
+    """
+    plt.figure(figsize=(8,5))
+    plt.plot(history["total_loss"], label="Total Loss", lw=2)
+    plt.plot(history["res_loss"], label="Residual Loss", lw=2)
+    plt.plot(history["bc_loss"], label="BC Loss", lw=2)
+    plt.xlabel("Epochs")
+    plt.ylabel("Loss")
+    plt.yscale("log")
+    plt.title(title)
+    plt.legend()
+    plt.grid(True)
+    plt.show()
+
+
+# ------------------------------
+# Optional callback for Trainer
+# ------------------------------
+def visualization_callback(model, x, t=None, kind="1d", interval=100, device=None):
+    """
+    General callback function to visualize PINN during training.
+    kind: "1d", "2d_surface", "2d_animation"
+    x: spatial points
+    t: optional time points
+    """
+    if kind == "1d":
+        plot_1d_solution(model, x, device=device)
+    elif kind == "2d_surface":
+        assert t is not None, "Provide Y grid for 2D surface"
+        plot_2d_surface(model, x, t, device=device)
+    elif kind == "2d_animation":
+        assert t is not None, "Provide time points for animation"
+        animate_2d(model, x, t, interval=interval, device=device)

physai-0.1.0.dist-info/METADATA

@@ -0,0 +1,196 @@
+Metadata-Version: 2.4
+Name: physai
+Version: 0.1.0
+Summary: Physics-Informed Neural Network (PINN) library for solving ODEs/PDEs with visualization and training tools
+Author-email: Mankrit Singh <whataninfinity@gmail.com>
+License: MIT
+Project-URL: GitHub, https://github.com/MS-AGI/PhysAI
+Keywords: PINN,Physics-Informed Neural Network,ODE,PDE,Deep Learning
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: torch>=2.0.0
+Requires-Dist: matplotlib
+Requires-Dist: numpy
+Dynamic: license-file
+
+# PhysAI - Physics-Informed Neural Networks (PINNs)
+
+[![Python Version](https://img.shields.io/badge/python-3.10%2B-blue.svg)](https://www.python.org/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-indigo.svg)](https://opensource.org/licenses/MIT)
+
+---
+
+## **Overview**
+
+**PhysAI** is a Python package for solving **ordinary differential equations (ODEs) and partial differential equations (PDEs)** using **Physics-Informed Neural Networks (PINNs)**. It integrates physics directly into neural network training, allowing the solution of classic physics problems without relying on traditional numerical solvers.
+
+PhysAI supports a wide range of physics problems including:
+
+* **ODEs:** Logistic growth, Newton’s law of cooling, damped/simple harmonic oscillators, Markov processes.
+* **PDEs:** Heat equation, wave equation, Burgers' equation, KdV equation, convection-diffusion.
+* **Quantum Mechanics:** Schrödinger equation.
+* **Electromagnetism & Quantum Phenomena:** Planck’s law, photoelectric effect.
+* **Fluid Dynamics:** 2D incompressible Navier-Stokes.
+* **Static Problems:** Laplace and Poisson equations (2D/3D).
+
+Key features:
+
+* Flexible **PDE/ODE residual computation** for various physics laws.
+* **Mixed-precision training** for faster computation on GPUs.
+* Gradient clipping and learning rate schedulers supported.
+* **Visualization and animations** of solutions using matplotlib.
+* Weighted loss functions combining residual and boundary conditions.
+
+---
+
+## **Installation**
+
+Clone the repository and install dependencies:
+
+```bash
+git clone https://github.com/yourusername/physai.git
+cd physai
+pip install -r requirements.txt
+```
+
+Python >= 3.10 recommended.
+
+---
+
+## **Repository Structure**
+
+```
+physai/
+├── __init__.py
+├── models.py          # PINN neural network class
+├── trainer.py         # trainer cls for PINNs
+├── visualization.py
+├── pde_residual.py    # residuals for ODEs/PDEs
+├── losses.py
+├── utils.py 
+examples/              
+├── example_schrodinger.py
+├── example_newton_cooling.py
+├── example_markov.py
+├── example_photoelectric.py
+├── example_planck.py
+README.md             
+requirements.txt      
+.gitignore             
+```
+
+---
+
+## **Quick Start Example**
+
+```python
+import torch
+from physai.models import PINN
+from physai.pde_residual import pde_residual
+from physai.losses import pinn_loss
+from physai.visualization import plot_1d_solution
+
+# Define a 1D logistic growth ODE
+def logistic(x, y):
+    r, K = 1.0, 1.0
+    return torch.autograd.grad(y, x, grad_outputs=torch.ones_like(y), create_graph=True)[0] - r*y*(1 - y/K)
+
+# Create a PINN model
+model = PINN(layers=[1, 20, 20, 1], activation='tanh')
+
+# Training points
+x_train = torch.linspace(0, 5, 100).reshape(-1,1)
+
+# Train the model
+from physai.trainer import Trainer
+trainer = Trainer(model, collocation_points=x_train, pde_type='logistic')
+history = trainer.train(epochs=500, lr=1e-3)
+
+# Plot solution
+plot_1d_solution(model, x_train, title='Logistic Growth')
+```
+
+---
+
+## **Training a PDE Example: 1D Heat Equation**
+
+```python
+import torch
+from physai.models import PINN
+from physai.trainer import Trainer
+from physai.visualization import animate_2d
+
+# PINN model
+model = PINN(layers=[2, 50, 50, 1], activation='tanh')
+
+# Collocation points
+x = torch.linspace(0, 1, 50).reshape(-1,1)
+t = torch.linspace(0, 2, 50).reshape(-1,1)
+inputs = torch.cartesian_prod(x.squeeze(), t.squeeze())
+inputs = inputs.float()
+
+# Trainer
+trainer = Trainer(model, collocation_points=inputs, pde_type='heat')
+history = trainer.train(epochs=1000, lr=1e-3)
+
+# Animate solution
+animate_2d(model, x, t, title='Heat Equation Evolution')
+```
+
+---
+
+## **Physics Problems Supported**
+
+| Type               | Equations / Laws                                                                           |
+| ------------------ | ------------------------------------------------------------------------------------------ |
+| ODE                | Logistic Growth, Simple/Damped Harmonic Oscillator, Newton's Law of Cooling, Markov Chains |
+| PDE                | Heat Equation, Wave Equation, Burgers', KdV, Convection-Diffusion, Laplace, Poisson        |
+| Quantum            | Schrödinger Equation, Planck's Law                                                         |
+| Quantum/Electromag | Photoelectric Effect                                                                       |
+| Fluid Dynamics     | 2D Incompressible Navier-Stokes                                                            |
+| 3D PDEs            | Laplace 3D, Poisson 3D                                                                     |
+
+---
+
+## **Visualization**
+
+* **1D plots:** `plot_1d_solution(model, x)`
+* **2D surface plots:** `plot_2d_surface(model, X, Y)`
+* **Animation over time:** `animate_2d(model, x, t)`
+* **Training loss plots:** `plot_loss(trainer.history)`
+
+---
+
+## **Advanced Features**
+
+* Mixed precision training for faster GPU computation
+* Gradient clipping
+* Flexible learning rate scheduling
+* Weighted PINN loss for custom PDE/BC importance
+* Supports custom potentials (`V(x,t)`) for Schrödinger equation
+
+---
+
+## **Citation / Usage in Papers**
+
+If you use **PhysAI** in your research, please cite it as:
+
+```
+@misc{PhysAI2025,
+  author = {Mankrit Singh},
+  title = {PhysAI: Physics-Informed Neural Networks in PyTorch},
+  year = {2025},
+  howpublished = {\url{https://github.com/MS-AGI/PhysAI}
+}
+```
+
+---
+
+## **License**
+
+MIT License. See [LICENSE](LICENSE) file.
+
+---
+
+**Solve physics problems with PINNs and visualize them interactively!**

physai-0.1.0.dist-info/RECORD

@@ -0,0 +1,13 @@
+physai/__init__.py,sha256=FrvSe4-UPuJLaQQ4NnysW4XcNE2EE62RhS5dW8qxBr0,147
+physai/losses.py,sha256=A6FUgm1eCczu8qQcHvI1z_WT0XGtRBShssYMUKHl8hc,2351
+physai/pde_residual.py,sha256=AT2WRYMSs0d8eigYKmuJkhGKeJDc7H8erwxdumLpvbo,5596
+physai/physics.py,sha256=kE8Y3NPxuy7H731UB7t6DxghB758kpkmhkrNK2gdOis,2456
+physai/pinn.py,sha256=PpJydZjrnqkXX75HJl-ItYqYQhrRi9XR2w2O8ERSYXc,2863
+physai/trainer.py,sha256=v7nzgevkVTY75Efs8AGWvymWtbb7KaA6FDeAiU1ZpEs,2681
+physai/utils.py,sha256=gbYIH3nofds3u8iRauooTWeHVHi-2URddT7BkAaT0DE,84
+physai/visualization.py,sha256=ccrPTooWPHqKwpVgIwmsphJGkmVvmM4fUmdE5gkXZ7k,4375
+physai-0.1.0.dist-info/licenses/LICENSE,sha256=QEi1eLA1tImN_mOcj5idr2ldBEzXBLSZJ5lKKmmMD2s,1084
+physai-0.1.0.dist-info/METADATA,sha256=Lc0HlkT2mKqQ-L4GqwdZ2G4J-U-5QnNk2cU9ItMjzY4,6347
+physai-0.1.0.dist-info/WHEEL,sha256=DnLRTWE75wApRYVsjgc6wsVswC54sMSJhAEd4xhDpBk,91
+physai-0.1.0.dist-info/top_level.txt,sha256=XasGUSPQXLDNo4l-dunwoQqXio1B878qCFcNao4GFqY,7
+physai-0.1.0.dist-info/RECORD,,

physai-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.4.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

physai-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 MS-AGI
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

physai-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+physai