Rust Machine Learning Best Practices¶

// rust/01-linear-regression.rs

/*
Linear regression implementation and best practices
*/

use std::collections::HashMap;
use serde::{Deserialize, Serialize};

/// Linear regression model.
pub struct LinearRegression {
    weights: Vec<f64>,
    bias: f64,
    learning_rate: f64,
    epochs: usize,
    regularization: f64,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct TrainingData {
    pub features: Vec<Vec<f64>>,
    pub targets: Vec<f64>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ModelMetrics {
    pub mse: f64,
    pub rmse: f64,
    pub mae: f64,
    pub r2: f64,
}

impl LinearRegression {
    pub fn new(feature_count: usize, learning_rate: f64, epochs: usize, regularization: f64) -> Self {
        Self {
            weights: vec![0.0; feature_count],
            bias: 0.0,
            learning_rate,
            epochs,
            regularization,
        }
    }

    /// Train the linear regression model.
    pub fn train(&mut self, data: &TrainingData) -> Result<ModelMetrics, String> {
        if data.features.is_empty() || data.features.len() != data.targets.len() {
            return Err("Invalid training data".to_string());
        }

        let feature_count = data.features[0].len();
        if feature_count != self.weights.len() {
            return Err("Feature count mismatch".to_string());
        }

        // Gradient descent training
        for epoch in 0..self.epochs {
            let (weight_gradients, bias_gradient) = self.compute_gradients(data);

            // Update weights and bias
            for (weight, gradient) in self.weights.iter_mut().zip(weight_gradients.iter()) {
                *weight -= self.learning_rate * gradient;
            }
            self.bias -= self.learning_rate * bias_gradient;

            // Apply L2 regularization
            for weight in &mut self.weights {
                *weight *= (1.0 - self.learning_rate * self.regularization);
            }

            if epoch % 100 == 0 {
                let mse = self.compute_mse(data);
                println!("Epoch {}: MSE = {:.6}", epoch, mse);
            }
        }

        Ok(self.compute_metrics(data))
    }

    /// Compute gradients for gradient descent.
    fn compute_gradients(&self, data: &TrainingData) -> (Vec<f64>, f64) {
        let mut weight_gradients = vec![0.0; self.weights.len()];
        let mut bias_gradient = 0.0;
        let n = data.features.len() as f64;

        for (features, target) in data.features.iter().zip(data.targets.iter()) {
            let prediction = self.predict_single(features);
            let error = prediction - target;

            // Compute gradients
            for (i, feature) in features.iter().enumerate() {
                weight_gradients[i] += error * feature;
            }
            bias_gradient += error;
        }

        // Average gradients
        for gradient in &mut weight_gradients {
            *gradient /= n;
        }
        bias_gradient /= n;

        (weight_gradients, bias_gradient)
    }

    /// Predict a single sample.
    fn predict_single(&self, features: &[f64]) -> f64 {
        let mut prediction = self.bias;
        for (weight, feature) in self.weights.iter().zip(features.iter()) {
            prediction += weight * feature;
        }
        prediction
    }

    /// Make predictions on new data.
    pub fn predict(&self, features: &[Vec<f64>]) -> Vec<f64> {
        features.iter().map(|f| self.predict_single(f)).collect()
    }

    /// Compute mean squared error.
    fn compute_mse(&self, data: &TrainingData) -> f64 {
        let mut mse = 0.0;
        for (features, target) in data.features.iter().zip(data.targets.iter()) {
            let prediction = self.predict_single(features);
            let error = prediction - target;
            mse += error * error;
        }
        mse / data.features.len() as f64
    }

    /// Compute comprehensive metrics.
    fn compute_metrics(&self, data: &TrainingData) -> ModelMetrics {
        let mut mse = 0.0;
        let mut mae = 0.0;
        let mut target_sum = 0.0;
        let mut target_sum_sq = 0.0;

        for (features, target) in data.features.iter().zip(data.targets.iter()) {
            let prediction = self.predict_single(features);
            let error = prediction - target;

            mse += error * error;
            mae += error.abs();
            target_sum += target;
            target_sum_sq += target * target;
        }

        let n = data.features.len() as f64;
        mse /= n;
        mae /= n;

        let target_mean = target_sum / n;
        let target_var = (target_sum_sq / n) - (target_mean * target_mean);
        let r2 = 1.0 - (mse / target_var);

        ModelMetrics {
            mse,
            rmse: mse.sqrt(),
            mae,
            r2,
        }
    }

    /// Get model parameters.
    pub fn get_parameters(&self) -> (Vec<f64>, f64) {
        (self.weights.clone(), self.bias)
    }

    /// Set model parameters.
    pub fn set_parameters(&mut self, weights: Vec<f64>, bias: f64) -> Result<(), String> {
        if weights.len() != self.weights.len() {
            return Err("Weight count mismatch".to_string());
        }
        self.weights = weights;
        self.bias = bias;
        Ok(())
    }
}

/// Data preprocessing utilities.
pub struct DataPreprocessor {
    feature_scalers: Vec<FeatureScaler>,
    target_scaler: Option<FeatureScaler>,
}

#[derive(Debug, Clone)]
pub struct FeatureScaler {
    pub mean: f64,
    pub std: f64,
    pub min: f64,
    pub max: f64,
}

impl DataPreprocessor {
    pub fn new() -> Self {
        Self {
            feature_scalers: Vec::new(),
            target_scaler: None,
        }
    }

    /// Fit scalers to training data.
    pub fn fit(&mut self, data: &TrainingData, scale_target: bool) {
        let feature_count = data.features[0].len();
        self.feature_scalers.clear();

        // Fit feature scalers
        for i in 0..feature_count {
            let values: Vec<f64> = data.features.iter().map(|f| f[i]).collect();
            let scaler = self.compute_scaler(&values);
            self.feature_scalers.push(scaler);
        }

        // Fit target scaler if requested
        if scale_target {
            let target_scaler = self.compute_scaler(&data.targets);
            self.target_scaler = Some(target_scaler);
        }
    }

    /// Transform features using fitted scalers.
    pub fn transform_features(&self, features: &[Vec<f64>]) -> Vec<Vec<f64>> {
        features.iter().map(|f| self.transform_single_feature(f)).collect()
    }

    /// Transform targets using fitted scaler.
    pub fn transform_targets(&self, targets: &[f64]) -> Vec<f64> {
        if let Some(scaler) = &self.target_scaler {
            targets.iter().map(|t| (t - scaler.mean) / scaler.std).collect()
        } else {
            targets.to_vec()
        }
    }

    /// Inverse transform targets.
    pub fn inverse_transform_targets(&self, targets: &[f64]) -> Vec<f64> {
        if let Some(scaler) = &self.target_scaler {
            targets.iter().map(|t| t * scaler.std + scaler.mean).collect()
        } else {
            targets.to_vec()
        }
    }

    /// Transform a single feature vector.
    fn transform_single_feature(&self, features: &[f64]) -> Vec<f64> {
        features.iter().enumerate().map(|(i, &value)| {
            let scaler = &self.feature_scalers[i];
            (value - scaler.mean) / scaler.std
        }).collect()
    }

    /// Compute scaler statistics.
    fn compute_scaler(&self, values: &[f64]) -> FeatureScaler {
        let mean = values.iter().sum::<f64>() / values.len() as f64;
        let variance = values.iter().map(|v| (v - mean).powi(2)).sum::<f64>() / values.len() as f64;
        let std = variance.sqrt();
        let min = values.iter().cloned().fold(f64::INFINITY, f64::min);
        let max = values.iter().cloned().fold(f64::NEG_INFINITY, f64::max);

        FeatureScaler { mean, std, min, max }
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_linear_regression() {
        let mut model = LinearRegression::new(2, 0.01, 1000, 0.001);

        let data = TrainingData {
            features: vec![
                vec![1.0, 2.0],
                vec![2.0, 3.0],
                vec![3.0, 4.0],
                vec![4.0, 5.0],
            ],
            targets: vec![3.0, 5.0, 7.0, 9.0],
        };

        let metrics = model.train(&data).unwrap();
        assert!(metrics.mse < 1.0);
        assert!(metrics.r2 > 0.9);
    }

    #[test]
    fn test_data_preprocessor() {
        let mut preprocessor = DataPreprocessor::new();

        let data = TrainingData {
            features: vec![
                vec![1.0, 10.0],
                vec![2.0, 20.0],
                vec![3.0, 30.0],
            ],
            targets: vec![100.0, 200.0, 300.0],
        };

        preprocessor.fit(&data, true);

        let transformed_features = preprocessor.transform_features(&data.features);
        assert_eq!(transformed_features.len(), 3);
    }
}

// rust/02-neural-network.rs

/*
Neural network implementation and best practices
*/

use std::collections::HashMap;
use serde::{Deserialize, Serialize};

/// Neural network layer.
pub struct Layer {
    weights: Vec<Vec<f64>>,
    biases: Vec<f64>,
    activation: ActivationFunction,
}

#[derive(Debug, Clone)]
pub enum ActivationFunction {
    ReLU,
    Sigmoid,
    Tanh,
    Linear,
}

impl Layer {
    pub fn new(input_size: usize, output_size: usize, activation: ActivationFunction) -> Self {
        // Initialize weights with Xavier initialization
        let mut weights = Vec::new();
        for _ in 0..output_size {
            let mut row = Vec::new();
            for _ in 0..input_size {
                let weight = fastrand::f64() * 2.0 - 1.0; // Random between -1 and 1
                row.push(weight * (6.0 / (input_size + output_size) as f64).sqrt());
            }
            weights.push(row);
        }

        // Initialize biases to zero
        let biases = vec![0.0; output_size];

        Self {
            weights,
            biases,
            activation,
        }
    }

    /// Forward pass through the layer.
    pub fn forward(&self, inputs: &[f64]) -> Vec<f64> {
        let mut outputs = Vec::new();

        for (i, bias) in self.biases.iter().enumerate() {
            let mut sum = *bias;
            for (j, input) in inputs.iter().enumerate() {
                sum += self.weights[i][j] * input;
            }
            outputs.push(self.activate(sum));
        }

        outputs
    }

    /// Backward pass through the layer.
    pub fn backward(&mut self, inputs: &[f64], gradients: &[f64], learning_rate: f64) -> Vec<f64> {
        let mut input_gradients = vec![0.0; inputs.len()];

        for (i, gradient) in gradients.iter().enumerate() {
            // Update bias
            self.biases[i] -= learning_rate * gradient;

            // Update weights and compute input gradients
            for (j, input) in inputs.iter().enumerate() {
                self.weights[i][j] -= learning_rate * gradient * input;
                input_gradients[j] += gradient * self.weights[i][j];
            }
        }

        input_gradients
    }

    /// Apply activation function.
    fn activate(&self, x: f64) -> f64 {
        match self.activation {
            ActivationFunction::ReLU => x.max(0.0),
            ActivationFunction::Sigmoid => 1.0 / (1.0 + (-x).exp()),
            ActivationFunction::Tanh => x.tanh(),
            ActivationFunction::Linear => x,
        }
    }

    /// Compute activation derivative.
    fn activate_derivative(&self, x: f64) -> f64 {
        match self.activation {
            ActivationFunction::ReLU => if x > 0.0 { 1.0 } else { 0.0 },
            ActivationFunction::Sigmoid => {
                let sigmoid = 1.0 / (1.0 + (-x).exp());
                sigmoid * (1.0 - sigmoid)
            }
            ActivationFunction::Tanh => {
                let tanh = x.tanh();
                1.0 - tanh * tanh
            }
            ActivationFunction::Linear => 1.0,
        }
    }
}

/// Multi-layer neural network.
pub struct NeuralNetwork {
    layers: Vec<Layer>,
    learning_rate: f64,
    epochs: usize,
}

impl NeuralNetwork {
    pub fn new(layer_sizes: Vec<usize>, learning_rate: f64, epochs: usize) -> Self {
        let mut layers = Vec::new();

        for i in 0..layer_sizes.len() - 1 {
            let activation = if i == layer_sizes.len() - 2 {
                ActivationFunction::Linear // Output layer
            } else {
                ActivationFunction::ReLU // Hidden layers
            };

            let layer = Layer::new(layer_sizes[i], layer_sizes[i + 1], activation);
            layers.push(layer);
        }

        Self {
            layers,
            learning_rate,
            epochs,
        }
    }

    /// Train the neural network.
    pub fn train(&mut self, data: &TrainingData) -> Result<ModelMetrics, String> {
        if data.features.is_empty() || data.features.len() != data.targets.len() {
            return Err("Invalid training data".to_string());
        }

        for epoch in 0..self.epochs {
            let mut total_loss = 0.0;

            for (features, target) in data.features.iter().zip(data.targets.iter()) {
                // Forward pass
                let mut activations = vec![features.clone()];
                for layer in &self.layers {
                    let output = layer.forward(activations.last().unwrap());
                    activations.push(output);
                }

                // Compute loss
                let prediction = activations.last().unwrap()[0];
                let error = prediction - target;
                total_loss += error * error;

                // Backward pass
                let mut gradients = vec![error];
                for (i, layer) in self.layers.iter_mut().enumerate().rev() {
                    let layer_input = &activations[i];
                    gradients = layer.backward(layer_input, &gradients, self.learning_rate);
                }
            }

            let avg_loss = total_loss / data.features.len() as f64;
            if epoch % 100 == 0 {
                println!("Epoch {}: Loss = {:.6}", epoch, avg_loss);
            }
        }

        Ok(self.compute_metrics(data))
    }

    /// Make predictions.
    pub fn predict(&self, features: &[Vec<f64>]) -> Vec<f64> {
        features.iter().map(|f| self.predict_single(f)).collect()
    }

    /// Predict a single sample.
    fn predict_single(&self, features: &[f64]) -> f64 {
        let mut activations = features.to_vec();

        for layer in &self.layers {
            activations = layer.forward(&activations);
        }

        activations[0]
    }

    /// Compute model metrics.
    fn compute_metrics(&self, data: &TrainingData) -> ModelMetrics {
        let mut mse = 0.0;
        let mut mae = 0.0;
        let mut target_sum = 0.0;
        let mut target_sum_sq = 0.0;

        for (features, target) in data.features.iter().zip(data.targets.iter()) {
            let prediction = self.predict_single(features);
            let error = prediction - target;

            mse += error * error;
            mae += error.abs();
            target_sum += target;
            target_sum_sq += target * target;
        }

        let n = data.features.len() as f64;
        mse /= n;
        mae /= n;

        let target_mean = target_sum / n;
        let target_var = (target_sum_sq / n) - (target_mean * target_mean);
        let r2 = 1.0 - (mse / target_var);

        ModelMetrics {
            mse,
            rmse: mse.sqrt(),
            mae,
            r2,
        }
    }
}

/// Model persistence utilities.
pub struct ModelPersistence {
    model_path: String,
}

impl ModelPersistence {
    pub fn new(model_path: String) -> Self {
        Self { model_path }
    }

    /// Save model to file.
    pub fn save_model(&self, model: &NeuralNetwork) -> Result<(), String> {
        let serialized = serde_json::to_string_pretty(model)
            .map_err(|e| format!("Failed to serialize model: {}", e))?;

        std::fs::write(&self.model_path, serialized)
            .map_err(|e| format!("Failed to write model file: {}", e))?;

        Ok(())
    }

    /// Load model from file.
    pub fn load_model(&self) -> Result<NeuralNetwork, String> {
        let content = std::fs::read_to_string(&self.model_path)
            .map_err(|e| format!("Failed to read model file: {}", e))?;

        let model: NeuralNetwork = serde_json::from_str(&content)
            .map_err(|e| format!("Failed to deserialize model: {}", e))?;

        Ok(model)
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_neural_network() {
        let mut model = NeuralNetwork::new(vec![2, 4, 1], 0.01, 1000);

        let data = TrainingData {
            features: vec![
                vec![0.0, 0.0],
                vec![0.0, 1.0],
                vec![1.0, 0.0],
                vec![1.0, 1.0],
            ],
            targets: vec![0.0, 1.0, 1.0, 0.0],
        };

        let metrics = model.train(&data).unwrap();
        assert!(metrics.mse < 1.0);
    }

    #[test]
    fn test_layer_forward() {
        let layer = Layer::new(2, 3, ActivationFunction::ReLU);
        let inputs = vec![1.0, 2.0];
        let outputs = layer.forward(&inputs);
        assert_eq!(outputs.len(), 3);
    }
}

// rust/03-model-evaluation.rs

/*
Model evaluation patterns and best practices
*/

use std::collections::HashMap;
use serde::{Deserialize, Serialize};

/// Model evaluator for comprehensive evaluation.
pub struct ModelEvaluator {
    metrics: HashMap<String, f64>,
    predictions: Vec<f64>,
    targets: Vec<f64>,
}

impl ModelEvaluator {
    pub fn new() -> Self {
        Self {
            metrics: HashMap::new(),
            predictions: Vec::new(),
            targets: Vec::new(),
        }
    }

    /// Evaluate model performance.
    pub fn evaluate(&mut self, predictions: Vec<f64>, targets: Vec<f64>) -> Result<(), String> {
        if predictions.len() != targets.len() {
            return Err("Predictions and targets length mismatch".to_string());
        }

        self.predictions = predictions;
        self.targets = targets;

        self.compute_regression_metrics();
        self.compute_classification_metrics();
        self.compute_advanced_metrics();

        Ok(())
    }

    /// Compute regression metrics.
    fn compute_regression_metrics(&mut self) {
        let n = self.predictions.len() as f64;

        // Mean Squared Error
        let mse: f64 = self.predictions.iter()
            .zip(self.targets.iter())
            .map(|(p, t)| (p - t).powi(2))
            .sum::<f64>() / n;

        // Root Mean Squared Error
        let rmse = mse.sqrt();

        // Mean Absolute Error
        let mae: f64 = self.predictions.iter()
            .zip(self.targets.iter())
            .map(|(p, t)| (p - t).abs())
            .sum::<f64>() / n;

        // R-squared
        let target_mean: f64 = self.targets.iter().sum::<f64>() / n;
        let target_variance: f64 = self.targets.iter()
            .map(|t| (t - target_mean).powi(2))
            .sum::<f64>() / n;
        let r2 = 1.0 - (mse / target_variance);

        self.metrics.insert("mse".to_string(), mse);
        self.metrics.insert("rmse".to_string(), rmse);
        self.metrics.insert("mae".to_string(), mae);
        self.metrics.insert("r2".to_string(), r2);
    }

    /// Compute classification metrics.
    fn compute_classification_metrics(&mut self) {
        let n = self.predictions.len() as f64;

        // Convert to binary predictions (threshold = 0.5)
        let binary_predictions: Vec<bool> = self.predictions.iter()
            .map(|p| *p > 0.5)
            .collect();
        let binary_targets: Vec<bool> = self.targets.iter()
            .map(|t| *t > 0.5)
            .collect();

        // Confusion matrix
        let mut tp = 0; // True Positives
        let mut tn = 0; // True Negatives
        let mut fp = 0; // False Positives
        let mut fn = 0; // False Negatives

        for (pred, target) in binary_predictions.iter().zip(binary_targets.iter()) {
            match (*pred, *target) {
                (true, true) => tp += 1,
                (true, false) => fp += 1,
                (false, true) => fn += 1,
                (false, false) => tn += 1,
            }
        }

        // Accuracy
        let accuracy = (tp + tn) as f64 / n;

        // Precision
        let precision = if tp + fp > 0 { tp as f64 / (tp + fp) as f64 } else { 0.0 };

        // Recall
        let recall = if tp + fn > 0 { tp as f64 / (tp + fn) as f64 } else { 0.0 };

        // F1 Score
        let f1 = if precision + recall > 0.0 {
            2.0 * (precision * recall) / (precision + recall)
        } else {
            0.0
        };

        self.metrics.insert("accuracy".to_string(), accuracy);
        self.metrics.insert("precision".to_string(), precision);
        self.metrics.insert("recall".to_string(), recall);
        self.metrics.insert("f1_score".to_string(), f1);
    }

    /// Compute advanced metrics.
    fn compute_advanced_metrics(&mut self) {
        let n = self.predictions.len() as f64;

        // Mean Absolute Percentage Error
        let mape: f64 = self.predictions.iter()
            .zip(self.targets.iter())
            .map(|(p, t)| if *t != 0.0 { ((p - t).abs() / t.abs()) * 100.0 } else { 0.0 })
            .sum::<f64>() / n;

        // Symmetric Mean Absolute Percentage Error
        let smape: f64 = self.predictions.iter()
            .zip(self.targets.iter())
            .map(|(p, t)| {
                let denominator = (p.abs() + t.abs()) / 2.0;
                if denominator != 0.0 { ((p - t).abs() / denominator) * 100.0 } else { 0.0 }
            })
            .sum::<f64>() / n;

        // Mean Bias Error
        let mbe: f64 = self.predictions.iter()
            .zip(self.targets.iter())
            .map(|(p, t)| p - t)
            .sum::<f64>() / n;

        self.metrics.insert("mape".to_string(), mape);
        self.metrics.insert("smape".to_string(), smape);
        self.metrics.insert("mbe".to_string(), mbe);
    }

    /// Get all metrics.
    pub fn get_metrics(&self) -> &HashMap<String, f64> {
        &self.metrics
    }

    /// Get a specific metric.
    pub fn get_metric(&self, name: &str) -> Option<f64> {
        self.metrics.get(name).copied()
    }

    /// Generate evaluation report.
    pub fn generate_report(&self) -> String {
        let mut report = String::new();
        report.push_str("# Model Evaluation Report\n\n");

        report.push_str("## Regression Metrics\n");
        if let Some(mse) = self.metrics.get("mse") {
            report.push_str(&format!("- MSE: {:.6}\n", mse));
        }
        if let Some(rmse) = self.metrics.get("rmse") {
            report.push_str(&format!("- RMSE: {:.6}\n", rmse));
        }
        if let Some(mae) = self.metrics.get("mae") {
            report.push_str(&format!("- MAE: {:.6}\n", mae));
        }
        if let Some(r2) = self.metrics.get("r2") {
            report.push_str(&format!("- R²: {:.6}\n", r2));
        }

        report.push_str("\n## Classification Metrics\n");
        if let Some(accuracy) = self.metrics.get("accuracy") {
            report.push_str(&format!("- Accuracy: {:.6}\n", accuracy));
        }
        if let Some(precision) = self.metrics.get("precision") {
            report.push_str(&format!("- Precision: {:.6}\n", precision));
        }
        if let Some(recall) = self.metrics.get("recall") {
            report.push_str(&format!("- Recall: {:.6}\n", recall));
        }
        if let Some(f1) = self.metrics.get("f1_score") {
            report.push_str(&format!("- F1 Score: {:.6}\n", f1));
        }

        report.push_str("\n## Advanced Metrics\n");
        if let Some(mape) = self.metrics.get("mape") {
            report.push_str(&format!("- MAPE: {:.6}%\n", mape));
        }
        if let Some(smape) = self.metrics.get("smape") {
            report.push_str(&format!("- SMAPE: {:.6}%\n", smape));
        }
        if let Some(mbe) = self.metrics.get("mbe") {
            report.push_str(&format!("- MBE: {:.6}\n", mbe));
        }

        report
    }
}

/// Cross-validation evaluator.
pub struct CrossValidator {
    k_folds: usize,
    random_seed: Option<u64>,
}

impl CrossValidator {
    pub fn new(k_folds: usize) -> Self {
        Self {
            k_folds,
            random_seed: None,
        }
    }

    /// Set random seed for reproducibility.
    pub fn set_random_seed(&mut self, seed: u64) {
        self.random_seed = Some(seed);
    }

    /// Perform k-fold cross-validation.
    pub fn cross_validate<F, T>(&self, data: &TrainingData, train_fn: F) -> Result<Vec<ModelMetrics>, String>
    where
        F: Fn(&TrainingData) -> Result<T, String>,
        T: std::fmt::Debug,
    {
        if data.features.len() < self.k_folds {
            return Err("Not enough data for k-fold cross-validation".to_string());
        }

        let mut results = Vec::new();
        let fold_size = data.features.len() / self.k_folds;

        for fold in 0..self.k_folds {
            let (train_data, test_data) = self.split_data(data, fold, fold_size);

            // Train model on training data
            let _model = train_fn(&train_data)?;

            // Evaluate on test data (simplified for this example)
            let metrics = ModelMetrics {
                mse: 0.1,
                rmse: 0.1.sqrt(),
                mae: 0.1,
                r2: 0.9,
            };

            results.push(metrics);
        }

        Ok(results)
    }

    /// Split data into train and test sets.
    fn split_data(&self, data: &TrainingData, fold: usize, fold_size: usize) -> (TrainingData, TrainingData) {
        let start = fold * fold_size;
        let end = start + fold_size;

        let mut train_features = Vec::new();
        let mut train_targets = Vec::new();
        let mut test_features = Vec::new();
        let mut test_targets = Vec::new();

        for (i, (features, target)) in data.features.iter().zip(data.targets.iter()).enumerate() {
            if i >= start && i < end {
                test_features.push(features.clone());
                test_targets.push(*target);
            } else {
                train_features.push(features.clone());
                train_targets.push(*target);
            }
        }

        (
            TrainingData {
                features: train_features,
                targets: train_targets,
            },
            TrainingData {
                features: test_features,
                targets: test_targets,
            },
        )
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_model_evaluator() {
        let mut evaluator = ModelEvaluator::new();

        let predictions = vec![1.0, 2.0, 3.0, 4.0];
        let targets = vec![1.1, 2.1, 2.9, 4.1];

        evaluator.evaluate(predictions, targets).unwrap();

        let mse = evaluator.get_metric("mse");
        assert!(mse.is_some());
        assert!(mse.unwrap() < 1.0);
    }

    #[test]
    fn test_cross_validator() {
        let validator = CrossValidator::new(3);

        let data = TrainingData {
            features: vec![
                vec![1.0, 2.0],
                vec![2.0, 3.0],
                vec![3.0, 4.0],
                vec![4.0, 5.0],
                vec![5.0, 6.0],
                vec![6.0, 7.0],
            ],
            targets: vec![3.0, 5.0, 7.0, 9.0, 11.0, 13.0],
        };

        let results = validator.cross_validate(&data, |_| Ok("dummy")).unwrap();
        assert_eq!(results.len(), 3);
    }
}