wip

Author: acharneski

src/benchmarks/evaluation.rs

@@ -1083,4 +1083,4 @@ pub fn new_initial_point(
         *xi += (random_delta * 2.0 - 1.0) * noise; // Random perturbation
     }
     Ok(x)
-}
+}

src/benchmarks/unified_tests.rs

@@ -1390,9 +1390,6 @@ pub fn generate_test_report(results: &[ProblemTestResults]) -> String {
 mod tests {
     use super::*;
     use crate::benchmarks::analytic_functions::*;
-    use crate::benchmarks::ml_problems::*;
-    use crate::benchmarks::mnist::*;
-    use crate::benchmarks::mnist_onednn::*;
     use rand::{rngs::StdRng, SeedableRng};
 
     #[test]
@@ -1669,163 +1666,6 @@ mod tests {
         );
     }
     #[test]
-    fn test_ml_problems_unified() {
-        let mut rng = StdRng::seed_from_u64(42);
-        // Generate small synthetic datasets for testing
-        let (x_data, y_data) = generate_linear_regression_data(20, 3, &mut rng);
-        let (svm_x, svm_y) = generate_svm_data(20, 3, &mut rng);
-        let problems: Vec<Box<dyn OptimizationProblem>> = vec![
-            Box::new(LinearRegression::new(x_data.clone(), y_data.clone(), 0.01).unwrap()),
-            Box::new(
-                LogisticRegression::new(
-                    x_data.clone(),
-                    y_data
-                        .iter()
-                        .map(|&y| if y > 0.0 { 1.0 } else { 0.0 })
-                        .collect(),
-                    0.01,
-                )
-                .unwrap(),
-            ),
-            Box::new(SupportVectorMachine::new(svm_x, svm_y, 1.0).unwrap()),
-            Box::new(NeuralNetworkTraining::mlp_classification(vec![3, 5, 2], &mut rng).unwrap()),
-        ];
-        let config = ProblemTestConfig {
-            gradient_tolerance: 1e-3, // More lenient for ML problems
-            test_points_count: 2,     // Fewer test points for speed
-            derivative_validation: DerivativeValidationConfig {
-                numerical_gradient_tolerance: 1e-3,
-                test_directions_count: 2,
-                enable_second_order_tests: false,
-                enable_robustness_tests: true, // Enable but with lenient settings
-                ..Default::default()
-            },
-            ..Default::default()
-        };
-        let results = test_multiple_problems(problems, Some(config));
-        let report = generate_test_report(&results);
-        println!("{}", report);
-        // ML problems should have reasonable success rate
-        let valid_count = results.iter().filter(|r| r.is_valid()).count();
-        let success_rate = valid_count as f32 / results.len() as f32;
-        assert!(
-            success_rate >= 0.5,
-            "At least 50% of ML problems should pass unified tests. Success rate: {:.1}%",
-            success_rate * 100.0
-        );
-    }
-    #[test]
-    fn test_mnist_problems_unified() {
-        let mut rng = StdRng::seed_from_u64(42);
-        // Create small MNIST-like problems for testing
-        let x_data = vec![vec![0.5; 784]; 10]; // 10 samples, 784 features
-        let mut y_data = vec![vec![0.0; 10]; 10]; // 10 samples, 10 classes
-        for (i, label) in y_data.iter_mut().enumerate() {
-            label[i % 10] = 1.0; // One-hot encoding
-        }
-        let problems: Vec<Box<dyn OptimizationProblem>> = vec![
-            Box::new(
-                MnistNeuralNetwork::new(
-                    x_data.clone(),
-                    y_data.clone(),
-                    &[20],
-                    Some(5),
-                    &mut rng,
-                    None,
-                )
-                .unwrap(),
-            ),
-            #[cfg(feature = "onednn")]
-            Box::new(
-                MnistOneDnnNeuralNetwork::new(x_data, y_data, &[20], Some(5), &mut rng, None)
-                    .unwrap(),
-            ),
-        ];
-        let config = ProblemTestConfig {
-            gradient_tolerance: 1e-2,    // Very lenient for neural networks
-            test_points_count: 1,        // Single test point for speed
-            finite_check_tolerance: 1e8, // Allow larger values
-            derivative_validation: DerivativeValidationConfig {
-                numerical_gradient_tolerance: 1e-2,
-                test_directions_count: 1,
-                enable_second_order_tests: false,
-                enable_directional_tests: false,
-                enable_robustness_tests: false,
-                ..Default::default()
-            },
-            ..Default::default()
-        };
-        let results = test_multiple_problems(problems, Some(config));
-        let report = generate_test_report(&results);
-        println!("{}", report);
-        // Neural networks are complex, allow some failures
-        let valid_count = results.iter().filter(|r| r.is_valid()).count();
-        let success_rate = valid_count as f32 / results.len() as f32;
-        // At least basic functionality should work
-        assert!(
-            success_rate >= 0.3,
-            "At least 30% of neural network problems should pass basic tests. Success rate: {:.1}%",
-            success_rate * 100.0
-        );
-    }
-    #[test]
-    fn test_mixed_problem_types() {
-        let mut rng = StdRng::seed_from_u64(42);
-        // Mix of analytic and ML problems
-        let (x_data, y_data) = generate_linear_regression_data(15, 2, &mut rng);
-        let problems: Vec<Box<dyn OptimizationProblem>> = vec![
-            // Analytic functions
-            Box::new(SphereFunction::new(3)),
-            Box::new(RosenbrockFunction::new(3)),
-            Box::new(BealeFunction::new()),
-            // ML problems
-            Box::new(LinearRegression::new(x_data.clone(), y_data.clone(), 0.01).unwrap()),
-            Box::new(
-                LogisticRegression::new(
-                    x_data,
-                    y_data
-                        .iter()
-                        .map(|&y| if y > 0.0 { 1.0 } else { 0.0 })
-                        .collect(),
-                    0.01,
-                )
-                .unwrap(),
-            ),
-        ];
-        let results = test_multiple_problems(problems, None);
-        let report = generate_test_report(&results);
-        println!("{}", report);
-        // Check that different problem types are handled consistently
-        let analytic_results: Vec<_> = results
-            .iter()
-            .filter(|r| {
-                r.problem_name.contains("Sphere")
-                    || r.problem_name.contains("Rosenbrock")
-                    || r.problem_name.contains("Beale")
-            })
-            .collect();
-        let ml_results: Vec<_> = results
-            .iter()
-            .filter(|r| r.problem_name.contains("Regression"))
-            .collect();
-        // Analytic functions should have high success rate
-        let analytic_success = analytic_results.iter().filter(|r| r.is_valid()).count() as f32
-            / analytic_results.len() as f32;
-        assert!(
-            analytic_success >= 0.9,
-            "Analytic functions should have >90% success rate: {:.1}%",
-            analytic_success * 100.0
-        );
-        // ML problems should have reasonable success rate
-        let ml_success =
-            ml_results.iter().filter(|r| r.is_valid()).count() as f32 / ml_results.len() as f32;
-        assert!(
-            ml_success >= 0.5,
-            "ML problems should have >50% success rate: {:.1}%",
-            ml_success * 100.0
-        );
-    }
-    #[test]
     fn test_gradient_consistency_across_problems() {
         let rng = StdRng::seed_from_u64(42);
         let problems: Vec<Box<dyn OptimizationProblem>> = vec![
@@ -1880,65 +1720,6 @@ mod tests {
             );
         }
     }
-    #[test]
-    fn test_problem_cloning_behavior() {
-        let mut rng = StdRng::seed_from_u64(42);
-        let (x_data, y_data) = generate_linear_regression_data(10, 2, &mut rng);
-        let problems: Vec<Box<dyn OptimizationProblem>> = vec![
-            Box::new(SphereFunction::new(3)),
-            Box::new(LinearRegression::new(x_data, y_data, 0.01).unwrap()),
-        ];
-        for problem in &problems {
-            let cloned = problem.clone_problem();
-            // Basic properties should match
-            assert_eq!(problem.name(), cloned.name());
-            assert_eq!(problem.dimension(), cloned.dimension());
-            assert_eq!(problem.optimal_value(), cloned.optimal_value());
-            // Function evaluations should match
-            let test_point = problem.initial_point();
-            let orig_value = problem.evaluate_f64(&test_point).unwrap();
-            let clone_value = cloned.evaluate_f64(&test_point).unwrap();
-            assert!(
-                (orig_value - clone_value).abs() < 1e-12,
-                "Cloned problem gives different result: {} vs {} for {}",
-                orig_value,
-                clone_value,
-                problem.name()
-            );
-        }
-    }
-    #[test]
-    fn test_dimension_consistency() {
-        let mut rng = StdRng::seed_from_u64(42);
-        let problems: Vec<Box<dyn OptimizationProblem>> = vec![
-            Box::new(SphereFunction::new(5)),
-            Box::new(RosenbrockFunction::new(4)),
-            Box::new(NeuralNetworkTraining::mlp_classification(vec![3, 4, 2], &mut rng).unwrap()),
-        ];
-        for problem in &problems {
-            let dimension = problem.dimension();
-            let initial_point = problem.initial_point();
-            assert_eq!(
-                initial_point.len(),
-                dimension,
-                "Problem {} has dimension mismatch: dimension()={}, initial_point.len()={}",
-                problem.name(),
-                dimension,
-                initial_point.len()
-            );
-            // Test gradient dimension consistency
-            if let Ok(gradient) = problem.gradient_f64(&initial_point) {
-                assert_eq!(
-                    gradient.len(),
-                    dimension,
-                    "Problem {} gradient dimension mismatch: expected {}, got {}",
-                    problem.name(),
-                    dimension,
-                    gradient.len()
-                );
-            }
-        }
-    }
 
     #[test]
     fn test_custom_config() {

src/line_search/bisection.rs

@@ -159,7 +159,8 @@ impl<'a> ProblemEvaluator for LuminalEvaluator<'a> {
             .set_tensor(self.params.id, 0, Tensor::new(new_params));
         self.cx.execute();
         self.num_f_evals += 1;
-        let loss_val = self.loss
+        let loss_val = self
+            .loss
             .data()
             .as_any()
             .downcast_ref::<Vec<f32>>()
@@ -874,4 +875,4 @@ mod tests {
         assert_eq!(line_search.config.max_iterations, 20);
     }
     */
-}
+}

src/line_search/line_search.rs

@@ -253,4 +253,4 @@ mod tests {
         assert_eq!(deserialized.step_size, result.step_size);
         assert_eq!(deserialized.num_f_evals, 3);
     }
-}
+}