wip

Author: acharneski

src/benchmarks/evaluation.rs

@@ -753,27 +753,9 @@ impl BenchmarkRunner {
 
             // Update input floats with new parameters
             for tensor in tensors.iter() {
-                if let Some(values) = tensor.data.as_any().downcast_ref::<Vec<f32>>() {
-                    if values.len() != input_floats.len() {
-                        return Err(BenchmarkError::ConfigError(
-                            "Parameter size mismatch after optimization step".to_string(),
-                        ));
-                    }
-                    for (i, &value) in values.iter().enumerate() {
-                        if !value.is_finite() {
-                            warn!("Non-finite parameter detected at iteration {iteration}");
-                            numerical_error_count += 1;
-                            if numerical_error_count >= MAX_NUMERICAL_ERRORS {
-                                return Ok(ConvergenceReason::NumericalError);
-                            }
-                        }
-                        input_floats[i] = value;
-                    }
-                } else {
-                    return Err(BenchmarkError::ConfigError(
-                        "Failed to convert tensor to f32 vector".to_string(),
-                    ));
-                }
+                // TODO: Update this code when graph-based optimizer support is implemented
+                // The tensor data access needs to use Luminal's public API
+                let _ = tensor; // Suppress unused variable warning
             }
 
             // Record iteration data only after successful step
@@ -1101,4 +1083,4 @@ pub fn new_initial_point(
         *xi += (random_delta * 2.0 - 1.0) * noise; // Random perturbation
     }
     Ok(x)
-}
+}

src/experiment_runner/optimizer_sets.rs

@@ -22,6 +22,7 @@ pub fn qqn_variants() -> Vec<(String, Arc<dyn Optimizer>)> {
                     max_step: 10.0,
                     verbose: false,
                     line_bracket_method: 1,
+                    exact_tolerance: 0.0,
                 },
                 lbfgs_history: 10,
                 epsilon: 1e-6,
@@ -42,6 +43,7 @@ pub fn qqn_variants() -> Vec<(String, Arc<dyn Optimizer>)> {
                     min_step: 1e-10,
                     max_step: 10.0,
                     verbose: false,
+                    exact_tolerance: 0.0,
                 },
                 lbfgs_history: 10,
                 epsilon: 1e-6,
@@ -62,6 +64,7 @@ pub fn qqn_variants() -> Vec<(String, Arc<dyn Optimizer>)> {
                     min_step: 1e-10,
                     max_step: 10.0,
                     verbose: false,
+                    exact_tolerance: 0.0,
                 },
                 lbfgs_history: 10,
                 epsilon: 1e-6,
@@ -82,6 +85,7 @@ pub fn qqn_variants() -> Vec<(String, Arc<dyn Optimizer>)> {
                     max_step: 10.0,
                     verbose: false,
                     line_bracket_method: 1,
+                    exact_tolerance: 0.0,
                 },
                 lbfgs_history: 10,
                 epsilon: 1e-6,

src/line_search/backtracking.rs

@@ -273,11 +273,8 @@ impl LineSearch for BacktrackingLineSearch {
             cx.execute();
 
             // Get loss value
-            let loss_tensor = cx
-                .get_tensor(loss.id, 0)
-                .ok_or(anyhow!("Failed to get loss tensor"))?;
-            let f_alpha = loss_tensor
-                .data
+            let f_alpha = loss
+                .data()
                 .as_any()
                 .downcast_ref::<Vec<f32>>()
                 .ok_or(anyhow!("Failed to downcast tensor data"))?[0];
@@ -313,11 +310,8 @@ impl LineSearch for BacktrackingLineSearch {
 
                 cx.set_tensor(params.id, 0, Tensor::new(min_step_params));
                 cx.execute();
-                let loss_tensor = cx
-                    .get_tensor(loss.id, 0)
-                    .ok_or(anyhow!("Failed to get loss tensor"))?;
-                let f_min = loss_tensor
-                    .data
+                let f_min = loss
+                    .data()
                     .as_any()
                     .downcast_ref::<Vec<f32>>()
                     .ok_or(anyhow!("Failed to downcast tensor data"))?[0];
@@ -356,11 +350,8 @@ impl LineSearch for BacktrackingLineSearch {
 
         cx.set_tensor(params.id, 0, Tensor::new(eps_params));
         cx.execute();
-        let loss_tensor = cx
-            .get_tensor(loss.id, 0)
-            .ok_or(anyhow!("Failed to get loss tensor"))?;
-        let f_eps = loss_tensor
-            .data
+        let f_eps = loss
+            .data()
             .as_any()
             .downcast_ref::<Vec<f32>>()
             .ok_or(anyhow!("Failed to downcast tensor data"))?[0];

src/line_search/bisection.rs

@@ -159,12 +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_tensor = self
-            .cx
-            .get_tensor(self.loss.id, 0)
-            .ok_or_else(|| anyhow!("Failed to get loss tensor"))?;
-        let loss_val = loss_tensor
-            .data
+        let loss_val = self.loss
+            .data()
             .as_any()
             .downcast_ref::<Vec<f32>>()
             .ok_or_else(|| anyhow!("Failed to downcast loss data"))?[0];
@@ -188,12 +184,8 @@ impl<'a> ProblemEvaluator for LuminalEvaluator<'a> {
         self.num_g_evals += 1;
 
         // Get gradient tensor
-        let grad_tensor = self
-            .cx
-            .get_tensor(self.gradient.id, 0)
-            .ok_or_else(|| anyhow!("Failed to get gradient tensor"))?;
-        let grad_data = grad_tensor
-            .data
+        let grad_binding = self.gradient.data();
+        let grad_data = grad_binding
             .as_any()
             .downcast_ref::<Vec<f32>>()
             .ok_or_else(|| anyhow!("Failed to downcast gradient data"))?;
@@ -882,4 +874,4 @@ mod tests {
         assert_eq!(line_search.config.max_iterations, 20);
     }
     */
-}
+}

src/line_search/golden_section.rs

@@ -157,13 +157,8 @@ impl LineSearch for GoldenSectionLineSearch {
                 .collect();
 
             cx.set_tensor(params.id, 0, Tensor::new(candidate_params));
-            cx.set_tensor(params.id, 0, Tensor::new(candidate_params));
-
-            let loss_tensor = cx
-                .get_tensor(loss.id, 0)
-                .ok_or_else(|| anyhow::anyhow!("Failed to get loss tensor"))?;
-            let f_val = loss_tensor
-                .data
+            let f_val = loss
+                .data()
                 .as_any()
                 .downcast_ref::<Vec<f32>>()
                 .ok_or_else(|| anyhow::anyhow!("Failed to downcast loss data"))?[0];

src/line_search/line_search.rs

@@ -149,11 +149,8 @@ pub trait LineSearch: Send + Sync + Debug {
             .collect();
         cx.set_tensor(params.id, 0, Tensor::new(candidate_params));
         cx.execute();
-        let loss_tensor = cx
-            .get_tensor(loss.id, 0)
-            .ok_or_else(|| anyhow::anyhow!("Failed to get loss tensor"))?;
-        let f_val = loss_tensor
-            .data
+        let f_val = loss
+            .data()
             .as_any()
             .downcast_ref::<Vec<f32>>()
             .ok_or_else(|| anyhow::anyhow!("Failed to downcast loss data"))?[0];
@@ -180,20 +177,14 @@ pub trait LineSearch: Send + Sync + Debug {
         cx.set_tensor(params.id, 0, Tensor::new(candidate_params));
         cx.execute();
         // Get loss
-        let loss_tensor = cx
-            .get_tensor(loss.id, 0)
-            .ok_or_else(|| anyhow::anyhow!("Failed to get loss tensor"))?;
-        let f_val = loss_tensor
-            .data
+        let f_val = loss
+            .data()
             .as_any()
             .downcast_ref::<Vec<f32>>()
             .ok_or_else(|| anyhow::anyhow!("Failed to downcast loss data"))?[0];
         // Get gradient
-        let grad_tensor = cx
-            .get_tensor(gradient.id, 0)
-            .ok_or_else(|| anyhow::anyhow!("Failed to get gradient tensor"))?;
-        let grad_data = grad_tensor
-            .data
+        let grad_data = gradient
+            .data()
             .as_any()
             .downcast_ref::<Vec<f32>>()
             .ok_or_else(|| anyhow::anyhow!("Failed to downcast gradient data"))?
@@ -219,11 +210,8 @@ pub trait LineSearch: Send + Sync + Debug {
             .collect();
         cx.set_tensor(params.id, 0, Tensor::new(candidate_params));
         cx.execute();
-        let grad_tensor = cx
-            .get_tensor(gradient.id, 0)
-            .ok_or_else(|| anyhow::anyhow!("Failed to get gradient tensor"))?;
-        let grad_data = grad_tensor
-            .data
+        let grad_binding = gradient.data();
+        let grad_data = grad_binding
             .as_any()
             .downcast_ref::<Vec<f32>>()
             .ok_or_else(|| anyhow::anyhow!("Failed to downcast gradient data"))?;
@@ -265,4 +253,4 @@ mod tests {
         assert_eq!(deserialized.step_size, result.step_size);
         assert_eq!(deserialized.num_f_evals, 3);
     }
-}
+}

src/line_search/strong_wolfe.rs

@@ -414,15 +414,13 @@ impl LineSearch for StrongWolfeLineSearch {
                 .collect();
             cx.set_tensor(params.id, 0, Tensor::new(new_params));
             cx.execute();
-            let loss_tensor = cx.get_tensor(loss.id, 0).unwrap();
-            let grad_tensor = cx.get_tensor(gradient.id, 0).unwrap();
-            let loss_val = loss_tensor
-                .data
+            let loss_val = loss
+                .data()
                 .as_any()
                 .downcast_ref::<Vec<f32>>()
                 .unwrap()[0];
-            let grad_val = grad_tensor
-                .data
+            let grad_binding = gradient.data();
+            let grad_val = grad_binding
                 .as_any()
                 .downcast_ref::<Vec<f32>>()
                 .unwrap();
@@ -473,7 +471,7 @@ impl LineSearch for StrongWolfeLineSearch {
                     directional_derivative,
                     &mut evaluate,
                     &mut local_f_evals,
-                    &mut local_g_evals,
+                    &mut local_g_evals
                 )?;
                 self.log_verbose(&format!("Zoom completed with alpha={final_alpha:.3e}"));
                 self.num_f_evals = local_f_evals;
@@ -585,4 +583,4 @@ impl LineSearch for StrongWolfeLineSearch {
     fn as_any_mut(&mut self) -> &mut dyn std::any::Any {
         self
     }
-}
+}

src/optimizers/adam.rs

@@ -383,7 +383,7 @@ pub struct AdamOptimizer {
     /// Stagnation multiplier for relaxed convergence criteria (future use)
     stagnation_multiplier: f32,
     /// Learning rate tensor for graph-based updates
-    lr_tensor: Option<GraphTensor>,
+    lr_tensor: Option<SafeTensor>,
     /// Stagnation count threshold (future use)
     stagnation_count: usize,
     /// Name of the optimizer variant
@@ -462,7 +462,7 @@ impl Optimizer for AdamOptimizer {
     ) -> OptimizerSetup {
         // Create learning rate tensor
         let lr = graph.tensor(()).set(vec![self.config.learning_rate]);
-        self.lr_tensor = Some(lr);
+        self.lr_tensor = Some(SafeTensor(lr));
 
         // Create constants for beta values and epsilon
         let beta1 = graph.tensor(()).set(vec![self.config.beta1]);
@@ -489,35 +489,35 @@ impl Optimizer for AdamOptimizer {
         for (i, (w, g)) in weights.iter().zip(gradients.iter()).enumerate() {
             // Create moment estimate tensors initialized to zero
             // These will accumulate across iterations
-            let m = graph.tensor(()).set(vec![0.0f32]).expand_to(g.shape);
-            let v = graph.tensor(()).set(vec![0.0f32]).expand_to(g.shape);
+            let m = graph.tensor(()).set(vec![0.0f32]).expand(g.shape);
+            let v = graph.tensor(()).set(vec![0.0f32]).expand(g.shape);
 
             // m_t = beta1 * m_{t-1} + (1 - beta1) * g_t
-            let m_new = m * beta1.expand_to(g.shape) + *g * one_minus_beta1.expand_to(g.shape);
+            let m_new = m * beta1.expand(g.shape) + *g * one_minus_beta1.expand(g.shape);
 
             // v_t = beta2 * v_{t-1} + (1 - beta2) * g_t^2
             let g_squared = *g * *g;
             let v_new =
-                v * beta2.expand_to(g.shape) + g_squared * one_minus_beta2.expand_to(g.shape);
+                v * beta2.expand(g.shape) + g_squared * one_minus_beta2.expand(g.shape);
 
             // Bias-corrected estimates
             // m_hat = m_t / (1 - beta1^t)
-            let m_hat = m_new / bc1_tensor.expand_to(g.shape);
+            let m_hat = m_new / bc1_tensor.expand(g.shape);
 
             // v_hat = v_t / (1 - beta2^t)
-            let v_hat = v_new / bc2_tensor.expand_to(g.shape);
+            let v_hat = v_new / bc2_tensor.expand(g.shape);
 
             // Update: theta_{t+1} = theta_t - lr * m_hat / (sqrt(v_hat) + epsilon)
             let v_hat_sqrt = v_hat.sqrt();
-            let denom = v_hat_sqrt + epsilon.expand_to(g.shape);
+            let denom = v_hat_sqrt + epsilon.expand(g.shape);
             let update = m_hat / denom;
 
-            let mut w_new = *w - update * lr.expand_to(g.shape);
+            let mut w_new = *w - update * lr.expand(g.shape);
 
             // Apply weight decay if configured
             if self.config.weight_decay > 0.0 {
                 let wd = graph.tensor(()).set(vec![self.config.weight_decay]);
-                w_new = w_new - *w * wd.expand_to(g.shape) * lr.expand_to(g.shape);
+                w_new = w_new - *w * wd.expand(g.shape) * lr.expand(g.shape);
             }
 
             new_weights.push(w_new);
@@ -545,7 +545,6 @@ impl Optimizer for AdamOptimizer {
     fn reset(&mut self) {
         self.state.reset();
         self.current_lr = self.config.learning_rate;
-        self.lr_tensor = None;
         // Note: name is not reset as it's determined by configuration
     }
 
@@ -587,4 +586,4 @@ mod tests {
         assert!(state.v.is_none());
         assert!(state.v_max.is_none());
     }
-}
+}