scirs2_series/advanced_training_modules/

neural_ode.rs

//! Neural Ordinary Differential Equations for continuous-time modeling
//!
//! This module implements Neural ODEs which model continuous-time dynamics
//! using neural networks to define the derivative function in an ODE.

use scirs2_core::ndarray::{Array1, Array2};
use scirs2_core::numeric::{Float, FromPrimitive};
use std::fmt::Debug;

use crate::error::Result;

/// Neural Ordinary Differential Equation (NODE) implementation
#[derive(Debug)]
pub struct NeuralODE<F: Float + Debug + scirs2_core::ndarray::ScalarOperand> {
    /// Network parameters
    parameters: Array2<F>,
    /// Integration time steps
    time_steps: Array1<F>,
    /// ODE solver configuration
    solver_config: ODESolverConfig<F>,
    /// Network dimensions
    input_dim: usize,
    hidden_dim: usize,
}

/// Configuration for ODE solver
#[derive(Debug, Clone)]
pub struct ODESolverConfig<F: Float + Debug> {
    /// Integration method
    method: IntegrationMethod,
    /// Step size
    #[allow(dead_code)]
    step_size: F,
    /// Tolerance for adaptive methods
    #[allow(dead_code)]
    tolerance: F,
}

/// Integration methods for ODE solving
#[derive(Debug, Clone)]
pub enum IntegrationMethod {
    /// Forward Euler method
    Euler,
    /// Fourth-order Runge-Kutta
    RungeKutta4,
    /// Adaptive Runge-Kutta-Fehlberg
    RKF45,
}

impl<F: Float + Debug + Clone + FromPrimitive + scirs2_core::ndarray::ScalarOperand> NeuralODE<F> {
    /// Create new Neural ODE
    pub fn new(
        input_dim: usize,
        hidden_dim: usize,
        time_steps: Array1<F>,
        solver_config: ODESolverConfig<F>,
    ) -> Self {
        // Initialize network parameters
        let total_params = input_dim * hidden_dim + hidden_dim * input_dim + 2 * hidden_dim;
        let scale = F::from(2.0).unwrap() / F::from(input_dim).unwrap();
        let std_dev = scale.sqrt();

        let mut parameters = Array2::zeros((1, total_params));
        for i in 0..total_params {
            let val = ((i * 23) % 1000) as f64 / 1000.0 - 0.5;
            parameters[[0, i]] = F::from(val).unwrap() * std_dev;
        }

        Self {
            parameters,
            time_steps,
            solver_config,
            input_dim,
            hidden_dim,
        }
    }

    /// Forward pass through Neural ODE
    pub fn forward(&self, initial_state: &Array1<F>) -> Result<Array2<F>> {
        let num_times = self.time_steps.len();
        let mut trajectory = Array2::zeros((num_times, self.input_dim));

        // Set initial condition
        for i in 0..self.input_dim {
            trajectory[[0, i]] = initial_state[i];
        }

        // Integrate ODE
        for t in 1..num_times {
            let dt = self.time_steps[t] - self.time_steps[t - 1];
            let current_state = trajectory.row(t - 1).to_owned();

            let next_state = match self.solver_config.method {
                IntegrationMethod::Euler => self.euler_step(&current_state, dt)?,
                IntegrationMethod::RungeKutta4 => self.rk4_step(&current_state, dt)?,
                IntegrationMethod::RKF45 => self.rkf45_step(&current_state, dt)?,
            };

            for i in 0..self.input_dim {
                trajectory[[t, i]] = next_state[i];
            }
        }

        Ok(trajectory)
    }

    /// Neural network defining the ODE dynamics
    fn neural_network(&self, state: &Array1<F>) -> Result<Array1<F>> {
        let (w1, b1, w2, b2) = self.extract_ode_weights();

        // First layer
        let mut hidden = Array1::zeros(self.hidden_dim);
        for i in 0..self.hidden_dim {
            let mut sum = b1[i];
            for j in 0..self.input_dim {
                sum = sum + w1[[i, j]] * state[j];
            }
            hidden[i] = self.tanh(sum);
        }

        // Second layer
        let mut output = Array1::zeros(self.input_dim);
        for i in 0..self.input_dim {
            let mut sum = b2[i];
            for j in 0..self.hidden_dim {
                sum = sum + w2[[i, j]] * hidden[j];
            }
            output[i] = sum;
        }

        Ok(output)
    }

    /// Extract ODE network weights
    fn extract_ode_weights(&self) -> (Array2<F>, Array1<F>, Array2<F>, Array1<F>) {
        let param_vec = self.parameters.row(0);
        let mut idx = 0;

        // First layer weights
        let mut w1 = Array2::zeros((self.hidden_dim, self.input_dim));
        for i in 0..self.hidden_dim {
            for j in 0..self.input_dim {
                w1[[i, j]] = param_vec[idx];
                idx += 1;
            }
        }

        // First layer bias
        let mut b1 = Array1::zeros(self.hidden_dim);
        for i in 0..self.hidden_dim {
            b1[i] = param_vec[idx];
            idx += 1;
        }

        // Second layer weights
        let mut w2 = Array2::zeros((self.input_dim, self.hidden_dim));
        for i in 0..self.input_dim {
            for j in 0..self.hidden_dim {
                w2[[i, j]] = param_vec[idx];
                idx += 1;
            }
        }

        // Second layer bias
        let mut b2 = Array1::zeros(self.input_dim);
        for i in 0..self.input_dim {
            b2[i] = param_vec[idx];
            idx += 1;
        }

        (w1, b1, w2, b2)
    }

    /// Euler integration step
    fn euler_step(&self, state: &Array1<F>, dt: F) -> Result<Array1<F>> {
        let derivative = self.neural_network(state)?;
        let mut next_state = Array1::zeros(self.input_dim);

        for i in 0..self.input_dim {
            next_state[i] = state[i] + dt * derivative[i];
        }

        Ok(next_state)
    }

    /// Fourth-order Runge-Kutta integration step
    fn rk4_step(&self, state: &Array1<F>, dt: F) -> Result<Array1<F>> {
        let k1 = self.neural_network(state)?;

        let mut temp_state = Array1::zeros(self.input_dim);
        for i in 0..self.input_dim {
            temp_state[i] = state[i] + dt * k1[i] / F::from(2.0).unwrap();
        }
        let k2 = self.neural_network(&temp_state)?;

        for i in 0..self.input_dim {
            temp_state[i] = state[i] + dt * k2[i] / F::from(2.0).unwrap();
        }
        let k3 = self.neural_network(&temp_state)?;

        for i in 0..self.input_dim {
            temp_state[i] = state[i] + dt * k3[i];
        }
        let k4 = self.neural_network(&temp_state)?;

        let mut next_state = Array1::zeros(self.input_dim);
        for i in 0..self.input_dim {
            next_state[i] = state[i]
                + dt * (k1[i]
                    + F::from(2.0).unwrap() * k2[i]
                    + F::from(2.0).unwrap() * k3[i]
                    + k4[i])
                    / F::from(6.0).unwrap();
        }

        Ok(next_state)
    }

    /// Runge-Kutta-Fehlberg integration step (simplified)
    fn rkf45_step(&self, state: &Array1<F>, dt: F) -> Result<Array1<F>> {
        // Simplified RKF45 - uses RK4 for now
        self.rk4_step(state, dt)
    }

    /// Hyperbolic tangent activation
    fn tanh(&self, x: F) -> F {
        x.tanh()
    }
}

impl<F: Float + Debug> ODESolverConfig<F> {
    /// Create new ODE solver configuration
    pub fn new(method: IntegrationMethod, step_size: F, tolerance: F) -> Self {
        Self {
            method,
            step_size,
            tolerance,
        }
    }

    /// Create default Euler configuration
    pub fn euler(step_size: F) -> Self {
        Self::new(IntegrationMethod::Euler, step_size, F::from(1e-6).unwrap())
    }

    /// Create default RK4 configuration
    pub fn runge_kutta4(step_size: F) -> Self {
        Self::new(
            IntegrationMethod::RungeKutta4,
            step_size,
            F::from(1e-6).unwrap(),
        )
    }

    /// Create default RKF45 configuration
    pub fn rkf45(step_size: F, tolerance: F) -> Self {
        Self::new(IntegrationMethod::RKF45, step_size, tolerance)
    }
}