kirchhoff-inspired-neural-networks

Kirchhoff-Inspired Neural Network (KINN) - state-variable-based network architecture built on Kirchhoff's current law for evolving high-order perception. Derives numerically stable state updates from ODEs, enabling explicit decoupling and encoding of higher-order evolutionary components. Keywords: KINN, Kirchhoff, ODE-based neural networks, high-order perception, PDE solving, physics-informed neural networks, state-variable networks.

仓库: hiyenwong/ai_collection
最近来源活动: 2026年7月8日 02:48
检测到的 SKILL.md 语言: 英语
星标: 2
分支: 0

安装方式

默认使用会先检查来源的 Prompt；你也可以切换为直接命令，或下载本地副本。

检查来源文件

决定是否安装前，请先阅读 SKILL.md，以及 SkillsMP 当前展示的配套文件。

返回搜索返回安装

Current balance at node i:
  Σ_j I_ij = C_i · dV_i/dt + I_leak,i

Where:
  I_ij: Current from node j to node i
  C_i: Membrane capacitance (learnable)
  V_i: Membrane potential (state variable)
  I_leak,i: Leak current

dV/dt = f(V, W, x)   # Governed by KCL
V(t+dt) = V(t) + dt · f(V(t), W, x(t))

import torch
import torch.nn as nn

class KINNLayers(nn.Module):
    """Kirchhoff-Inspired Neural Network Layer"""
    
    def __init__(self, n_nodes, dt=0.1):
        super().__init__()
        self.n_nodes = n_nodes
        self.dt = dt
        
        # Learnable parameters
        self.capacitance = nn.Parameter(torch.ones(n_nodes))
        self.conductance = nn.Parameter(torch.randn(n_nodes, n_nodes))
        self.leak = nn.Parameter(torch.zeros(n_nodes))
        
    def forward(self, x, n_steps=10):
        """
        Args:
            x: Input current (batch, n_nodes)
            n_steps: Number of ODE integration steps
            
        Returns:
            Final state (batch, n_nodes)
        """
        v = torch.zeros_like(x)  # Initial state
        
        for _ in range(n_steps):
            # Kirchhoff's current law: C·dV/dt = ΣI_in - I_leak
            current_in = x + v @ self.conductance.T
            dvdt = (current_in - self.leak) / self.capacitance
            v = v + self.dt * dvdt
            
        return v


class KINN(nn.Module):
    """Multi-layer Kirchhoff-Inspired Neural Network"""
    
    def __init__(self, input_dim, hidden_dims, output_dim, dt=0.1, n_steps=10):
        super().__init__()
        layers = []
        prev_dim = input_dim
        for h_dim in hidden_dims:
            layers.append(KINNLayers(h_dim, dt))
            layers.append(nn.ReLU())
            prev_dim = h_dim
        layers.append(KINNLayers(output_dim, dt))
        self.layers = nn.ModuleList(layers)
        self.n_steps = n_steps
        
    def forward(self, x):
        for layer in self.layers:
            if isinstance(layer, KINNLayers):
                x = layer(x, self.n_steps)
            else:
                x = layer(x)
        return x

def solve_pde_with_kinn(spatial_grid, initial_condition, boundary_conditions, n_time_steps):
    """Use KINN to solve partial differential equations"""
    # Encode spatial grid as KINN nodes
    # Set initial condition as node states
    # Apply boundary conditions as external currents
    # Evolve through time using KINN dynamics
    pass