added gradient diagnostic

Author: hexqnt

src/app.rs

@@ -43,7 +43,8 @@ use crate::fit::{
     default_spline_initial_knot_y, sample_curve,
 };
 use crate::fit::{
-    IncrementalFitRunner, IncrementalFitStep, IncrementalSplineFitRunner, IncrementalSplineFitStep,
+    GradientIterationDiagnostics, IncrementalFitRunner, IncrementalFitStep,
+    IncrementalSplineFitRunner, IncrementalSplineFitStep,
 };
 
 use self::diagnostics::{IterationDiagnostics, diagnostics_plot_y_axis_width};

src/app/diagnostics.rs

@@ -14,6 +14,8 @@ pub(super) struct IterationDiagnostics {
     pub(super) soft_l1_points: Vec<[f64; 2]>,
     pub(super) r2_abs_points: Vec<[f64; 2]>,
     pub(super) max_abs_error_points: Vec<[f64; 2]>,
+    pub(super) gradient_log_l2_norm_points: Vec<[f64; 2]>,
+    pub(super) gradient_cosine_points: Vec<[f64; 2]>,
     pub(super) parameter_names: Vec<String>,
     pub(super) parameter_series: Vec<Vec<[f64; 2]>>,
 }
@@ -42,13 +44,14 @@ impl IterationDiagnostics {
             loss_metric,
             metric_quantization,
         );
-        self.append(0, metrics, params);
+        self.append(0, metrics, None, params);
     }
 
     pub(super) fn append(
         &mut self,
         iteration: u64,
         metrics: IterationMetricSnapshot,
+        gradient_diagnostics: Option<GradientIterationDiagnostics>,
         params: &CurveParams,
     ) {
         let family = params.family();
@@ -61,7 +64,7 @@ impl IterationDiagnostics {
         }
 
         let iteration = iteration as f64;
-        self.upsert_metrics(iteration, metrics);
+        self.upsert_metrics(iteration, metrics, gradient_diagnostics);
         params.with_values(|values| {
             for (series, value) in self.parameter_series.iter_mut().zip(values.iter().copied()) {
                 upsert_iteration_point(series, iteration, value);
@@ -73,6 +76,7 @@ impl IterationDiagnostics {
         &mut self,
         iteration: u64,
         metrics: IterationMetricSnapshot,
+        gradient_diagnostics: Option<GradientIterationDiagnostics>,
         knot_y: &[f64],
     ) {
         let parameter_count = knot_y.len();
@@ -81,13 +85,18 @@ impl IterationDiagnostics {
         }
 
         let iteration = iteration as f64;
-        self.upsert_metrics(iteration, metrics);
+        self.upsert_metrics(iteration, metrics, gradient_diagnostics);
         for (series, value) in self.parameter_series.iter_mut().zip(knot_y.iter().copied()) {
             upsert_iteration_point(series, iteration, value);
         }
     }
 
-    fn upsert_metrics(&mut self, iteration: f64, metrics: IterationMetricSnapshot) {
+    fn upsert_metrics(
+        &mut self,
+        iteration: f64,
+        metrics: IterationMetricSnapshot,
+        gradient_diagnostics: Option<GradientIterationDiagnostics>,
+    ) {
         upsert_iteration_point(&mut self.loss_points, iteration, metrics.loss);
         upsert_iteration_point(&mut self.mse_points, iteration, metrics.mse);
         upsert_iteration_point(&mut self.rmse_points, iteration, metrics.rmse);
@@ -99,6 +108,25 @@ impl IterationDiagnostics {
             iteration,
             metrics.max_abs_error,
         );
+        if let Some(gradient_diagnostics) = gradient_diagnostics
+            && gradient_diagnostics.gradient_l2_norm.is_finite()
+            && gradient_diagnostics.gradient_l2_norm > 0.0
+        {
+            upsert_iteration_point(
+                &mut self.gradient_log_l2_norm_points,
+                iteration,
+                gradient_diagnostics.gradient_l2_norm.log10(),
+            );
+            if let Some(gradient_cosine) = gradient_diagnostics.gradient_cosine
+                && gradient_cosine.is_finite()
+            {
+                upsert_iteration_point(
+                    &mut self.gradient_cosine_points,
+                    iteration,
+                    gradient_cosine,
+                );
+            }
+        }
     }
 
     fn reset_for_family(&mut self, family: CurveFamily) {
@@ -136,6 +164,8 @@ impl IterationDiagnostics {
         self.soft_l1_points.clear();
         self.r2_abs_points.clear();
         self.max_abs_error_points.clear();
+        self.gradient_log_l2_norm_points.clear();
+        self.gradient_cosine_points.clear();
     }
 }
 

src/app/fit_worker.rs

@@ -74,7 +74,12 @@ impl CurveFitApp {
         replay_frames: &mut Vec<ReplayFrame>,
     ) {
         for entry in trace {
-            diagnostics.append(entry.iteration, entry.metrics, &entry.params);
+            diagnostics.append(
+                entry.iteration,
+                entry.metrics,
+                entry.gradient_diagnostics,
+                &entry.params,
+            );
             Self::upsert_buffered_parametric_replay_frame(
                 replay_frames,
                 entry.iteration,
@@ -89,7 +94,12 @@ impl CurveFitApp {
         replay_frames: &mut Vec<ReplayFrame>,
     ) {
         for entry in trace {
-            diagnostics.append_spline(entry.iteration, entry.metrics, &entry.knot_y);
+            diagnostics.append_spline(
+                entry.iteration,
+                entry.metrics,
+                entry.gradient_diagnostics,
+                &entry.knot_y,
+            );
             Self::upsert_buffered_spline_replay_frame(
                 replay_frames,
                 entry.iteration,
@@ -218,7 +228,7 @@ impl CurveFitApp {
             // Финальные метрики пересчитываем по тем точкам и параметрам, которые видит пользователь.
             let (metrics, snapshot_metrics, snapshot_residuals) =
                 self.parametric_metrics_and_residuals(points, &result.params);
-            diagnostics.append(result.iterations, metrics, &result.params);
+            diagnostics.append(result.iterations, metrics, None, &result.params);
             result_metrics = Some(snapshot_metrics);
             residual_plot_points = snapshot_residuals;
         }
@@ -257,7 +267,7 @@ impl CurveFitApp {
         Self::apply_spline_trace_to_buffers(trace, &mut diagnostics, &mut replay_frames);
         let knot_y = result.knots.iter().map(|knot| knot[1]).collect::<Vec<_>>();
         let spline_plot_curve = Self::plot_points_from_pairs(result.curve.iter().copied());
-        diagnostics.append_spline(result.iterations, metrics, &knot_y);
+        diagnostics.append_spline(result.iterations, metrics, None, &knot_y);
         Self::upsert_buffered_spline_replay_frame(
             &mut replay_frames,
             result.iterations,
@@ -466,6 +476,7 @@ impl CurveFitApp {
                     iteration,
                     mse: _,
                     metrics,
+                    gradient_diagnostics,
                     params,
                 }) => {
                     let params = if let Some(normalization) = normalization {
@@ -498,6 +509,7 @@ impl CurveFitApp {
                     iteration_trace.push(ParametricIterationTraceEntry {
                         iteration,
                         metrics,
+                        gradient_diagnostics,
                         params,
                     });
                 }
@@ -546,12 +558,14 @@ impl CurveFitApp {
                     iteration,
                     mse: _,
                     metrics,
+                    gradient_diagnostics,
                     knot_y,
                     curve,
                 }) => {
                     iteration_trace.push(SplineIterationTraceEntry {
                         iteration,
                         metrics,
+                        gradient_diagnostics,
                         knot_y,
                         curve,
                     });
@@ -620,6 +634,7 @@ impl CurveFitApp {
                         iteration,
                         mse: _,
                         metrics,
+                        gradient_diagnostics,
                         params,
                     }) => {
                         let params = if let Some(normalization) = normalization {
@@ -643,6 +658,7 @@ impl CurveFitApp {
                         iteration_trace.push(ParametricIterationTraceEntry {
                             iteration,
                             metrics,
+                            gradient_diagnostics,
                             params,
                         });
                     }
@@ -735,12 +751,14 @@ impl CurveFitApp {
                         iteration,
                         mse: _,
                         metrics,
+                        gradient_diagnostics,
                         knot_y,
                         curve,
                     }) => {
                         iteration_trace.push(SplineIterationTraceEntry {
                             iteration,
                             metrics,
+                            gradient_diagnostics,
                             knot_y,
                             curve,
                         });

src/app/panel_state.rs

@@ -5,6 +5,7 @@
 pub(super) enum DiagnosticsTab {
     #[default]
     Loss,
+    Gradient,
     Residuals,
 }
 

src/app/state.rs

@@ -190,6 +190,7 @@ pub(super) enum WasmFitJob {
 pub(super) struct ParametricIterationTraceEntry {
     pub(super) iteration: u64,
     pub(super) metrics: IterationMetricSnapshot,
+    pub(super) gradient_diagnostics: Option<GradientIterationDiagnostics>,
     pub(super) params: CurveParams,
 }
 
@@ -198,6 +199,7 @@ pub(super) struct ParametricIterationTraceEntry {
 pub(super) struct SplineIterationTraceEntry {
     pub(super) iteration: u64,
     pub(super) metrics: IterationMetricSnapshot,
+    pub(super) gradient_diagnostics: Option<GradientIterationDiagnostics>,
     pub(super) knot_y: Vec<f64>,
     pub(super) curve: Vec<[f64; 2]>,
 }

src/app/tests.rs

@@ -24,8 +24,8 @@ use super::{
 };
 use crate::domain::{CurveFamily, CurveParams, FitResult, OptimizerConfig, Point, Points};
 use crate::fit::{
-    DEFAULT_METRIC_QUANTIZATION_DECIMAL_PLACES, IterationMetricSnapshot, MetricQuantization,
-    OptimizationLossMetric, SplineResult,
+    DEFAULT_METRIC_QUANTIZATION_DECIMAL_PLACES, GradientIterationDiagnostics,
+    IterationMetricSnapshot, MetricQuantization, OptimizationLossMetric, SplineResult,
 };
 
 // Все import-ы специально поднимаются в этот модуль,

src/app/tests/fit_lifecycle.rs

@@ -245,11 +245,13 @@ fn finished_message_applies_buffered_parametric_trace_in_single_poll() {
         super::ParametricIterationTraceEntry {
             iteration: 1,
             metrics: metrics_snapshot(2.0, 2.0, 1.4, 1.2, 1.1, 0.1, 2.0),
+            gradient_diagnostics: None,
             params: CurveParams::Linear { a: 0.4, b: 0.8 },
         },
         super::ParametricIterationTraceEntry {
             iteration: 2,
             metrics: metrics_snapshot(0.5, 0.5, 0.7, 0.6, 0.55, 0.7, 0.9),
+            gradient_diagnostics: None,
             params: CurveParams::Linear { a: 1.2, b: 0.5 },
         },
     ];

src/app/tests/replay_diagnostics.rs

@@ -43,11 +43,13 @@ fn diagnostics_append_replaces_duplicate_iteration() {
     diagnostics.append(
         2,
         metrics_snapshot(5.0, 5.0, 5.0_f64.sqrt(), 2.0, 1.75, -1.5, 3.0),
+        None,
         &CurveParams::Linear { a: 1.0, b: 0.0 },
     );
     diagnostics.append(
         2,
         metrics_snapshot(3.0, 3.0, 3.0_f64.sqrt(), 1.5, 1.1, -2.0, 2.0),
+        None,
         &CurveParams::Linear { a: -1.5, b: 0.5 },
     );
 
@@ -65,6 +67,25 @@ fn diagnostics_append_replaces_duplicate_iteration() {
     assert_eq!(diagnostics.parameter_series[1][1], [2.0, 0.5]);
 }
 
+#[test]
+fn diagnostics_append_tracks_gradient_norm_and_direction() {
+    let mut diagnostics = IterationDiagnostics::default();
+    let params = CurveParams::Linear { a: 1.0, b: 0.0 };
+
+    diagnostics.append(
+        3,
+        metrics_snapshot(1.0, 1.0, 1.0, 1.0, 1.0, 0.0, 1.0),
+        Some(GradientIterationDiagnostics {
+            gradient_l2_norm: 1e-3,
+            gradient_cosine: Some(-0.25),
+        }),
+        &params,
+    );
+
+    assert_eq!(diagnostics.gradient_log_l2_norm_points, vec![[3.0, -3.0]]);
+    assert_eq!(diagnostics.gradient_cosine_points, vec![[3.0, -0.25]]);
+}
+
 #[test]
 fn diagnostics_append_resets_when_family_changes() {
     let points = line_points();
@@ -78,6 +99,7 @@ fn diagnostics_append_resets_when_family_changes() {
     diagnostics.append(
         4,
         metrics_snapshot(1.0, 1.0, 1.0, 1.0, 0.8, 0.2, 1.0),
+        None,
         &CurveParams::Quadratic {
             a: 1.0,
             b: -2.0,
@@ -103,11 +125,13 @@ fn diagnostics_append_spline_tracks_knot_parameters() {
     diagnostics.append_spline(
         1,
         metrics_snapshot(2.5, 2.5, 2.5_f64.sqrt(), 1.2, 1.6, -0.25, 2.0),
+        None,
         &[0.5, -1.0],
     );
     diagnostics.append_spline(
         2,
         metrics_snapshot(1.5, 1.5, 1.5_f64.sqrt(), 0.9, 1.0, 0.25, 1.4),
+        None,
         &[0.75, -0.25],
     );