""" Multi-Layer Perceptron with Custom Initialization """ import torch import torch.nn as nn # --- Added activation registry with custom sine (supports autograd) --- class SinActFunc(torch.autograd.Function): @staticmethod def forward(ctx, x): ctx.save_for_backward(x) return x.sin() @staticmethod def backward(ctx, grad_out): (x,) = ctx.saved_tensors return grad_out * x.cos() class Sine(nn.Module): def forward(self, x): return SinActFunc.apply(x) ACTIVATION_REGISTRY = { 'relu': lambda: nn.ReLU(), 'tanh': lambda: nn.Tanh(), 'sin': lambda: Sine(), } def get_activation(name: str): key = name.lower() if key not in ACTIVATION_REGISTRY: raise ValueError(f"Unknown activation '{name}'. Available: {list(ACTIVATION_REGISTRY.keys())}") return ACTIVATION_REGISTRY[key]() def act_prime(mod, a): """ Unified activation derivative for manual Jacobian. a: pre-activation tensor. """ if isinstance(mod, nn.ReLU): return (a > 0).to(a.dtype) if isinstance(mod, nn.LeakyReLU): ns = getattr(mod, "negative_slope", 0.01) return torch.where(a > 0, torch.ones_like(a), torch.full_like(a, ns)) if isinstance(mod, nn.Tanh): ta = torch.tanh(a) return 1.0 - ta * ta if isinstance(mod, nn.Sigmoid): s = torch.sigmoid(a) return s * (1.0 - s) if isinstance(mod, nn.Softplus): beta = getattr(mod, "beta", 1.0) return torch.sigmoid(beta * a) if isinstance(mod, nn.SiLU): # Swish s = torch.sigmoid(a) return s * (1.0 + a * (1.0 - s)) if isinstance(mod, nn.ELU): alpha = getattr(mod, "alpha", 1.0) return torch.where(a > 0, torch.ones_like(a), alpha * torch.exp(a)) if isinstance(mod, nn.Identity): return torch.ones_like(a) if isinstance(mod, Sine): return torch.cos(a) raise NotImplementedError(f"Jacobian for activation {mod.__class__.__name__} not implemented.") class MLPWithCustomInit(nn.Module): def __init__(self, input_dim, hidden_dims, output_dim, activation=nn.ReLU, init_type='kaiming', activation_per_layer=None, dim_in_linear=[0, 0], dim_out_linear=0, hidden_dim_linear=[]): super().__init__() layers = [] # Store linear branch parameters self.dim_in_linear = dim_in_linear self.dim_out_linear = dim_out_linear self.hidden_dim_linear = hidden_dim_linear # Validate dim_in_linear format if not isinstance(dim_in_linear, (list, tuple)) or len(dim_in_linear) != 2: raise ValueError(f"dim_in_linear must be a list/tuple of length 2 [start_idx, end_idx], got {dim_in_linear}") start_idx, end_idx = dim_in_linear linear_input_size = end_idx - start_idx # Create linear/MLP branch if specified if linear_input_size > 0 and dim_out_linear > 0: if start_idx < 0 or end_idx > input_dim or start_idx >= end_idx: raise ValueError(f"Invalid dim_in_linear {dim_in_linear}: must satisfy 0 <= start < end <= {input_dim}") if dim_out_linear > output_dim: raise ValueError(f"dim_out_linear ({dim_out_linear}) cannot be larger than output_dim ({output_dim})") # Create branch network (linear or MLP) if len(hidden_dim_linear) == 0: # Simple linear branch self.linear_branch = nn.Linear(linear_input_size, dim_out_linear) branch_type = 'linear_branch' else: # MLP branch branch_layers = [] branch_dims = [linear_input_size] + hidden_dim_linear + [dim_out_linear] for i, (in_dim, out_dim) in enumerate(zip(branch_dims[:-1], branch_dims[1:])): branch_layers.append(nn.Linear(in_dim, out_dim)) # Add activation for all layers except the last one if i < len(branch_dims) - 2: branch_layers.append(activation()) self.linear_branch = nn.Sequential(*branch_layers) branch_type = 'mlp_branch' # MLP output dimension is total minus branch output mlp_output_dim = output_dim - dim_out_linear total_output_dim = output_dim else: self.linear_branch = None mlp_output_dim = output_dim total_output_dim = output_dim linear_input_size = 0 branch_type = None dims = [input_dim] + hidden_dims # Record layer information for debugging/analysis self.layer_info = { 'input_dim': input_dim, 'hidden_dims': hidden_dims, 'output_dim': output_dim, 'mlp_output_dim': mlp_output_dim, 'total_output_dim': total_output_dim, 'dim_in_linear': dim_in_linear, 'linear_input_size': linear_input_size, 'dim_out_linear': dim_out_linear, 'hidden_dim_linear': hidden_dim_linear, 'branch_type': branch_type, 'total_layers': len(hidden_dims) + 1, 'layer_details': [] } # Add branch info if exists if self.linear_branch is not None: if branch_type == 'linear_branch': # Simple linear branch self.layer_info['layer_details'].append({ 'layer_idx': -1, # Special index for branch 'type': 'linear_branch', 'input_dim': linear_input_size, 'input_slice': f"[{start_idx}:{end_idx}]", 'output_dim': dim_out_linear, 'activation': 'None', 'parameters': linear_input_size * dim_out_linear + dim_out_linear }) else: # MLP branch - record each layer branch_dims = [linear_input_size] + hidden_dim_linear + [dim_out_linear] total_branch_params = 0 for i, (in_dim, out_dim) in enumerate(zip(branch_dims[:-1], branch_dims[1:])): layer_params = in_dim * out_dim + out_dim total_branch_params += layer_params if i < len(branch_dims) - 2: # Hidden layer in branch self.layer_info['layer_details'].append({ 'layer_idx': f"b{i}", # Branch layer index 'type': 'branch_hidden', 'input_dim': in_dim, 'output_dim': out_dim, 'input_slice': f"[{start_idx}:{end_idx}]" if i == 0 else None, 'activation': activation().__class__.__name__, 'parameters': layer_params }) else: # Output layer in branch self.layer_info['layer_details'].append({ 'layer_idx': f"b{i}", 'type': 'branch_output', 'input_dim': in_dim, 'output_dim': out_dim, 'input_slice': f"[{start_idx}:{end_idx}]" if i == 0 and len(branch_dims) == 2 else None, 'activation': 'None', 'parameters': layer_params }) # Handle activation per layer if activation_per_layer is None: activation_fns = [activation() for _ in hidden_dims] else: if len(activation_per_layer) != len(hidden_dims): raise ValueError(f"Number of activations ({len(activation_per_layer)}) must match number of hidden layers ({len(hidden_dims)})") activation_fns = [get_activation(a) for a in activation_per_layer] for i, (in_dim, out_dim) in enumerate(zip(dims[:-1], dims[1:])): layer_linear = nn.Linear(in_dim, out_dim) activation_fn = activation_fns[i] layers.append(layer_linear) layers.append(activation_fn) # Record layer details self.layer_info['layer_details'].append({ 'layer_idx': i, 'type': 'hidden', 'input_dim': in_dim, 'output_dim': out_dim, 'activation': activation_fn.__class__.__name__, 'parameters': in_dim * out_dim + out_dim }) # Output layer - use mlp_output_dim instead of output_dim output_layer = nn.Linear(dims[-1], mlp_output_dim) layers.append(output_layer) # Record output layer details self.layer_info['layer_details'].append({ 'layer_idx': len(hidden_dims), 'type': 'output', 'input_dim': dims[-1], 'output_dim': mlp_output_dim, 'activation': 'None', 'parameters': dims[-1] * mlp_output_dim + mlp_output_dim }) # Calculate total parameters self.layer_info['total_parameters'] = sum(detail['parameters'] for detail in self.layer_info['layer_details']) self.net = nn.Sequential(*layers) self.activation = activation self.init_type = init_type self.apply(self._init_weights) def _init_weights(self, module): if isinstance(module, nn.Linear): if self.init_type == 'xavier': if isinstance(self.activation(), (nn.Tanh, nn.ReLU)): gain = nn.init.calculate_gain('tanh' if isinstance(self.activation(), nn.Tanh) else 'relu') nn.init.xavier_uniform_(module.weight, gain=gain) else: nn.init.xavier_uniform_(module.weight) elif self.init_type == 'kaiming': nn.init.kaiming_uniform_(module.weight, nonlinearity='relu') elif self.init_type == 'orthogonal': nn.init.orthogonal_(module.weight, gain=1.0) elif self.init_type == 'small_normal': nn.init.normal_(module.weight, mean=0.0, std=0.01) if module.bias is not None: nn.init.zeros_(module.bias) def _apply_network(self, x): """Apply the complete network with linear branch if present""" if self.linear_branch is not None: # Extract slice from input for linear branch start_idx, end_idx = self.dim_in_linear x1 = x[..., start_idx:end_idx] # Apply linear branch linear_out = self.linear_branch(x1) # Apply MLP to full input mlp_out = self.net(x) # Concatenate outputs: [linear_out; mlp_out] return torch.cat([linear_out, mlp_out], dim=-1) else: # No linear branch, just apply MLP return self.net(x) def forward(self, t=None, x=None, u=None): """ Forward pass - handle both (t, x) and single argument calls, plus external input u IMPORTANT: This must maintain compatibility with: 1. Hybrid models: encoder([], x_flat) and decoder([], z_flat) 2. Vector fields in torchdiffeq: vector_field(t, z) or vector_field(t, z, u) 3. Autoregressive models: ag_function(None, ag_input) 4. NEW: External input conditioning: vector_field(t, z, u) """ if x is None and u is None: # Single argument call: forward(input) # This handles autoregressive case: ag_function(ag_input) return self._apply_network(t) # t is actually the input elif u is None: # Two argument call: forward(t, x) # This handles hybrid case: encoder([], x_flat) where t=[] and x=x_flat # And vector field case: vector_field(t, z) where we use z return self._apply_network(x) else: # Three argument call: forward(t, x, u) - NEW for external conditioning # Concatenate x and u for input to network if isinstance(u, (int, float)): # Scalar u, expand to match batch size u_expanded = torch.full((x.shape[0], 1), u, device=x.device, dtype=x.dtype) else: u_expanded = u xu_input = torch.cat([x, u_expanded], dim=-1) return self._apply_network(xu_input) def forward_Jac(self, t=None, x=None, u=None): """ Manual forward + Jacobian for the MLP with branch support. Returns: y: [B, total_out_dim] where total_out_dim = dim_out_linear + mlp_output_dim J: [B, total_out_dim, in_dim_eff], where in_dim_eff is the actual input fed to the network The Jacobian accounts for the branch structure: output = [branch(x1); MLP(x)] """ # --- 1) Parse inputs to match your forward conventions --- if x is None and u is None: inp = t elif u is None: inp = x else: if isinstance(u, (int, float)): u = torch.full((x.shape[0], 1), u, device=x.device, dtype=x.dtype) inp = torch.cat([x, u], dim=-1) B, Din = inp.shape if self.linear_branch is not None: # Extract slice from input for branch start_idx, end_idx = self.dim_in_linear x1 = inp[..., start_idx:end_idx] # Apply branch network if len(self.hidden_dim_linear) == 0: # Simple linear branch: y_branch = A @ x1 + b branch_out = self.linear_branch(x1) # [B, dim_out_linear] # Construct Jacobian for linear branch W_branch = self.linear_branch.weight # [dim_out_linear, linear_input_size] J_branch = torch.zeros(B, self.dim_out_linear, Din, device=inp.device, dtype=inp.dtype) J_branch[:, :, start_idx:end_idx] = W_branch.unsqueeze(0).expand(B, -1, -1) else: # MLP branch - need to compute Jacobian through the branch network y_branch = x1 J_branch = None is_first_branch = True a_cache_branch = None # Propagate through branch layers for i, module in enumerate(self.linear_branch): if isinstance(module, nn.Linear): W = module.weight # [out, in] b = module.bias # [out] a = y_branch @ W.t() + b # pre-activation Wb = W.unsqueeze(0).expand(B, -1, -1) # [B, out, in] if is_first_branch: J_branch = Wb # [B, out, linear_input_size] is_first_branch = False else: J_branch = torch.bmm(Wb, J_branch) # [B, out, linear_input_size] y_branch = a a_cache_branch = a else: # Activation function in branch ap = act_prime(module, a_cache_branch) # [B, dim] y_branch = module(y_branch) J_branch = ap.unsqueeze(-1) * J_branch branch_out = y_branch # Expand J_branch to full input dimensions J_branch_full = torch.zeros(B, self.dim_out_linear, Din, device=inp.device, dtype=inp.dtype) J_branch_full[:, :, start_idx:end_idx] = J_branch J_branch = J_branch_full # MLP branch: apply full network to full input y_mlp = inp J_mlp = None is_first = True a_cache = None # Propagate through MLP layers for module in self.net: if isinstance(module, nn.Linear): W = module.weight # [out, in] b = module.bias # [out] a = y_mlp @ W.t() + b # pre-activation Wb = W.unsqueeze(0).expand(B, -1, -1) # [B, out, in] if is_first: J_mlp = Wb # [B, out, Din] is_first = False else: J_mlp = torch.bmm(Wb, J_mlp) # [B, out, Din] y_mlp = a a_cache = a else: # Activation function ap = act_prime(module, a_cache) # [B, dim] y_mlp = module(y_mlp) if J_mlp is None: I = torch.eye(Din, device=y_mlp.device, dtype=y_mlp.dtype) J_mlp = I.unsqueeze(0).expand(B, Din, Din).clone() is_first = False J_mlp = ap.unsqueeze(-1) * J_mlp # Combine outputs and Jacobians y = torch.cat([branch_out, y_mlp], dim=-1) # [B, total_out_dim] J = torch.cat([J_branch, J_mlp], dim=1) # [B, total_out_dim, Din] else: # No linear branch, use original implementation y = inp J = None is_first = True a_cache = None for module in self.net: if isinstance(module, nn.Linear): W = module.weight b = module.bias a = y @ W.t() + b Wb = W.unsqueeze(0).expand(B, -1, -1) if is_first: J = Wb is_first = False else: J = torch.bmm(Wb, J) y = a a_cache = a else: ap = act_prime(module, a_cache) y = module(y) if J is None: I = torch.eye(Din, device=y.device, dtype=y.dtype) J = I.unsqueeze(0).expand(B, Din, Din).clone() is_first = False J = ap.unsqueeze(-1) * J return y, J def __call__(self, *args): """ Allow flexible calling - CRITICAL for compatibility This ensures all calling patterns work correctly """ if len(args) == 1: # Single argument: autoregressive case return self._apply_network(args[0]) elif len(args) == 2: # Two arguments: hybrid/ODE case - use second argument (actual data) return self._apply_network(args[1]) elif len(args) == 3: # Three arguments: external input case - concatenate second and third x, u = args[1], args[2] if isinstance(u, (int, float)): u_expanded = torch.full((x.shape[0], 1), u, device=x.device, dtype=x.dtype) else: u_expanded = u xu_input = torch.cat([x, u_expanded], dim=-1) return self._apply_network(xu_input) else: raise ValueError(f"Expected 1, 2, or 3 arguments, got {len(args)}") def get_layer_info(self): """Return detailed layer information""" return self.layer_info def print_architecture(self, name="MLP"): """Print a summary of the network architecture""" print(f"\n{name} Architecture:") print(f" Input dimension: {self.layer_info['input_dim']}") if self.linear_branch is not None: start_idx, end_idx = self.dim_in_linear if self.layer_info['branch_type'] == 'linear_branch': print(f" Linear branch: input[{start_idx}:{end_idx}] ({self.layer_info['linear_input_size']}) -> {self.layer_info['dim_out_linear']}") else: print(f" MLP branch: input[{start_idx}:{end_idx}] ({self.layer_info['linear_input_size']}) -> {self.layer_info['hidden_dim_linear']} -> {self.layer_info['dim_out_linear']}") print(f" Total layers: {self.layer_info['total_layers']}") print(f" MLP output dimension: {self.layer_info['mlp_output_dim']}") print(f" Total output dimension: {self.layer_info['total_output_dim']}") print(f" Total parameters: {self.layer_info['total_parameters']}") print(" Layer details:") for detail in self.layer_info['layer_details']: if 'branch' in detail['type']: layer_type = detail['type'].replace('_', ' ').title() slice_info = f" {detail['input_slice']}" if detail.get('input_slice') else "" print(f" {layer_type} {detail['layer_idx']}: " f"{detail['input_dim']}{slice_info} -> {detail['output_dim']}, " f"activation: {detail['activation']}, " f"params: {detail['parameters']}") else: print(f" Layer {detail['layer_idx']} ({detail['type']}): " f"{detail['input_dim']} -> {detail['output_dim']}, " f"activation: {detail['activation']}, " f"params: {detail['parameters']}") # --- Example usage (adapt constructor to your class) --- if __name__ == "__main__": import time def _batch_jacobian_autograd(model, x, *, mode="x"): """ Compute Jacobian batch-wise using torch.autograd.functional.jacobian Returns: J_auto [B, out_dim, in_dim] mode: - "x": calls model.forward(inp) where inp=x - "tx": calls model.forward(t=None, x=inp) """ x = x.detach() B, Din = x.shape if mode == "x": def f_single(x_single): # x_single: [Din] y_single = model.forward(x_single.unsqueeze(0)).squeeze(0) # [Dout] return y_single elif mode == "tx": def f_single(x_single): y_single = model.forward(None, x_single.unsqueeze(0)).squeeze(0) return y_single else: raise NotImplementedError J_list = [] for b in range(B): xb = x[b].clone().requires_grad_(True) Jb = torch.autograd.functional.jacobian( f_single, xb, create_graph=False, vectorize=True ) # [Dout, Din] J_list.append(Jb) return torch.stack(J_list, dim=0) # [B, Dout, Din] @torch.no_grad() def check_manual_jacobian(model, x, *, atol=1e-6, rtol=1e-5, mode="x", verbose=True): """ Compare manual Jacobian (forward_Jac) vs. autograd Jacobian. Args: model: your MLP instance (with .forward and .forward_Jac) x: [B, in_dim] input atol, rtol: tolerances for allclose mode: see _batch_jacobian_autograd; default assumes forward(x) Prints max abs diff and raises AssertionError if mismatch. """ start_manual = time.time() y_man, J_man = model.forward_Jac(x) if mode == "x" else model.forward_Jac(None, x) end_manual = time.time() print(f"Manual Jacobian time: {end_manual - start_manual:.4f} seconds") J_auto = _batch_jacobian_autograd(model, x, mode=mode) start_auto = time.time() J_auto = _batch_jacobian_autograd(model, x, mode=mode) end_auto = time.time() print(f"Autograd Jacobian time: {end_auto - start_auto:.4f} seconds") # print(J_man) # print(J_auto) if J_auto.shape != J_man.shape: raise RuntimeError(f"Shape mismatch: auto {J_auto.shape} vs manual {J_man.shape}") max_abs = (J_auto - J_man).abs().max().item() ok = torch.allclose(J_auto, J_man, atol=atol, rtol=rtol) if verbose: print(f"[Jacobian check] shape={tuple(J_man.shape)}, max|Δ|={max_abs:.3e}, " f"allclose(atol={atol}, rtol={rtol})={ok}") assert ok, f"Jacobian mismatch: max|Δ|={max_abs:.3e} exceeds tolerances." torch.manual_seed(0) # Test with MLP branch using slice [1, 4] - total output dim is 7 (3 from branch + 4 from MLP) model = MLPWithCustomInit(6, [64] * 3, 7, dim_in_linear=[1, 4], dim_out_linear=3, hidden_dim_linear=[8, 6]).to('cuda') x = torch.randn(512, 6).to('cuda') _ = model(x) # warmup print(f"Input shape: {x.shape}") print(f"Output shape: {model(x).shape}") model.print_architecture("MLP with MLP Branch (slice [1:4])") check_manual_jacobian(model, x, mode="x") # Test with linear branch (empty hidden_dim_linear) model_linear = MLPWithCustomInit(6, [64] * 3, 7, dim_in_linear=[1, 4], dim_out_linear=3, hidden_dim_linear=[]).to('cuda') model_linear.print_architecture("MLP with Linear Branch") check_manual_jacobian(model_linear, x, mode="x") # Test without branch (original behavior) model_orig = MLPWithCustomInit(6, [64] * 3, 4).to('cuda') _ = model_orig(x) print(f"Original output shape: {model_orig(x).shape}") check_manual_jacobian(model_orig, x, mode="x") # Test with legacy int format (should work as [0, 2]) model_legacy = MLPWithCustomInit(6, [64] * 3, 7, dim_in_linear=[0, 2], dim_out_linear=3).to('cuda') print(f"Legacy format dim_in_linear=2 -> {model_legacy.dim_in_linear}") model_legacy.print_architecture("MLP with Linear Branch (legacy format)") # Test without linear branch (original behavior) model_orig = MLPWithCustomInit(6, [64] * 3, 4).to('cuda') _ = model_orig(x) print(f"Original output shape: {model_orig(x).shape}") check_manual_jacobian(model_orig, x, mode="x")