added Chebyshev and MSLE metrics

Author: hexqnt

src/app/formula.rs

@@ -568,6 +568,13 @@ fn latex_to_plain_text(text: &str) -> String {
                     output.push_str("\\frac");
                 }
                 "quad" => output.push(' '),
+                "begin" | "end" => {
+                    // Окружения нужны только для LaTeX-верстки и не должны
+                    // попадать в человекочитаемый plain-text.
+                    if matches!(chars.next(), Some('{')) {
+                        let _ = read_braced_group(&mut chars);
+                    }
+                }
                 "text" => {
                     if matches!(chars.next(), Some('{')) {
                         let content = read_braced_group(&mut chars);

src/app/i18n.rs

@@ -156,9 +156,11 @@ pub(super) fn optimization_loss_metric_label(
     metric: OptimizationLossMetric,
 ) -> &'static str {
     match metric {
-        OptimizationLossMetric::Mse => "MSE",
-        OptimizationLossMetric::Mae => "MAE",
+        OptimizationLossMetric::Mse => "MSE (L2)",
+        OptimizationLossMetric::Mae => "MAE (L1)",
         OptimizationLossMetric::SoftL1 => "soft_l1",
+        OptimizationLossMetric::Chebyshev => "Chebyshev",
+        OptimizationLossMetric::Msle => "MSLE",
     }
 }
 

src/app/result_export.rs

@@ -429,9 +429,11 @@ fn optimizer_method_id(method: OptimizerMethod) -> &'static str {
 
 fn objective_metric_name(metric: OptimizationLossMetric) -> &'static str {
     match metric {
-        OptimizationLossMetric::Mse => "Mean Squared Error",
-        OptimizationLossMetric::Mae => "Mean Absolute Error",
+        OptimizationLossMetric::Mse => "Mean Squared Error (L2)",
+        OptimizationLossMetric::Mae => "Mean Absolute Error (L1)",
         OptimizationLossMetric::SoftL1 => "Soft L1",
+        OptimizationLossMetric::Chebyshev => "Chebyshev Distance (Linf)",
+        OptimizationLossMetric::Msle => "Mean Squared Logarithmic Error",
     }
 }
 

src/app/tests/init_optimizer.rs

@@ -228,7 +228,7 @@ fn fit_export_spline_record_includes_expected_payload() {
     assert_eq!(value["optimizer"]["loss_metric"]["id"], "mae");
     assert_eq!(
         value["optimizer"]["loss_metric"]["name"],
-        "Mean Absolute Error"
+        "Mean Absolute Error (L1)"
     );
     assert!(
         value["optimizer"]

src/app/ui/diagnostics_panel.rs

@@ -141,9 +141,12 @@ fn ui_loss_diagnostics(
                         );
                         if app.fit_loss_metric != OptimizationLossMetric::Mse {
                             plot_ui.line(
-                                Line::new("MSE", PlotPoints::from_iter(mse_points.iter().copied()))
-                                    .id(egui::Id::new(DIAGNOSTICS_SERIES_ID_MSE))
-                                    .width(1.5_f32),
+                                Line::new(
+                                    "MSE (L2)",
+                                    PlotPoints::from_iter(mse_points.iter().copied()),
+                                )
+                                .id(egui::Id::new(DIAGNOSTICS_SERIES_ID_MSE))
+                                .width(1.5_f32),
                             );
                         }
                         plot_ui.line(
@@ -153,9 +156,12 @@ fn ui_loss_diagnostics(
                         );
                         if app.fit_loss_metric != OptimizationLossMetric::Mae {
                             plot_ui.line(
-                                Line::new("MAE", PlotPoints::from_iter(mae_points.iter().copied()))
-                                    .id(egui::Id::new(DIAGNOSTICS_SERIES_ID_MAE))
-                                    .width(1.5_f32),
+                                Line::new(
+                                    "MAE (L1)",
+                                    PlotPoints::from_iter(mae_points.iter().copied()),
+                                )
+                                .id(egui::Id::new(DIAGNOSTICS_SERIES_ID_MAE))
+                                .width(1.5_f32),
                             );
                         }
                         if app.fit_loss_metric != OptimizationLossMetric::SoftL1 {

src/app/ui/status_panel.rs

@@ -13,8 +13,8 @@ pub(super) fn ui_optimization_metric(app: &mut CurveFitApp, ui: &mut egui::Ui) {
             metric_response,
             tr(
                 language,
-                "Optimization metric\n- This metric is minimized during fitting\n- Diagnostics shows it as loss(metric)\n- MSE: smooth gradients, MAE: more robust to outliers, soft_l1: compromise",
-                "Метрика оптимизации\n- Эта метрика минимизируется во время фитинга\n- В диагностике она отображается как loss(metric)\n- MSE: более гладкие градиенты, MAE: устойчивее к выбросам, soft_l1: компромисс",
+                "Optimization metric\n- This metric is minimized during fitting\n- Diagnostics shows it as loss(metric)\n- MSE (L2): smooth gradients\n- MAE (L1): more robust to outliers\n- soft_l1: compromise\n- Chebyshev: minimizes max absolute residual\n- MSLE: emphasizes relative/log-scaled deviations",
+                "Метрика оптимизации\n- Эта метрика минимизируется во время фитинга\n- В диагностике она отображается как loss(metric)\n- MSE (L2): более гладкие градиенты\n- MAE (L1): устойчивее к выбросам\n- soft_l1: компромисс\n- Chebyshev: минимизирует максимальный модуль остатка\n- MSLE: акцент на относительных/логарифмических отклонениях",
             ),
         );
     });

src/fit/metrics.rs

@@ -7,18 +7,49 @@ pub enum OptimizationLossMetric {
     Mse,
     Mae,
     SoftL1,
+    Chebyshev,
+    Msle,
 }
 
 impl OptimizationLossMetric {
     /// Полный список вариантов для UI и переборов.
-    pub const ALL: [Self; 3] = [Self::Mse, Self::Mae, Self::SoftL1];
+    pub const ALL: [Self; 5] = [
+        Self::Mse,
+        Self::Mae,
+        Self::SoftL1,
+        Self::Chebyshev,
+        Self::Msle,
+    ];
 
     /// Короткое имя метрики для подписи в легенде.
     pub fn id(self) -> &'static str {
         match self {
             Self::Mse => "mse",
             Self::Mae => "mae",
             Self::SoftL1 => "soft_l1",
+            Self::Chebyshev => "chebyshev",
+            Self::Msle => "msle",
+        }
+    }
+
+    #[inline]
+    pub(super) fn simd_fast_path_supported(self) -> bool {
+        matches!(self, Self::Mse | Self::Mae | Self::SoftL1)
+    }
+
+    #[inline]
+    pub(super) fn requires_numerical_hessian(self) -> bool {
+        matches!(self, Self::Mae | Self::Chebyshev)
+    }
+
+    #[inline]
+    fn signum_or_zero(value: f64) -> f64 {
+        if value > 0.0 {
+            1.0
+        } else if value < 0.0 {
+            -1.0
+        } else {
+            0.0
         }
     }
 
@@ -27,32 +58,52 @@ impl OptimizationLossMetric {
             Self::Mse => residual * residual,
             Self::Mae => residual.abs(),
             Self::SoftL1 => 2.0 * ((1.0 + residual * residual).sqrt() - 1.0),
+            Self::Chebyshev => residual.abs(),
+            Self::Msle => {
+                let log_term = (1.0 + residual.abs()).ln();
+                log_term * log_term
+            }
         }
     }
 
     pub(super) fn residual_derivative(self, residual: f64) -> f64 {
         match self {
             Self::Mse => 2.0 * residual,
-            Self::Mae => {
-                if residual > 0.0 {
-                    1.0
-                } else if residual < 0.0 {
-                    -1.0
-                } else {
-                    0.0
-                }
-            }
+            Self::Mae | Self::Chebyshev => Self::signum_or_zero(residual),
             Self::SoftL1 => 2.0 * residual / (1.0 + residual * residual).sqrt(),
+            Self::Msle => {
+                let abs_residual = residual.abs();
+                let log_term = (1.0 + abs_residual).ln();
+                Self::signum_or_zero(residual) * (2.0 * log_term / (1.0 + abs_residual))
+            }
         }
     }
 
     pub(super) fn residual_second_derivative(self, residual: f64) -> f64 {
         match self {
             Self::Mse => 2.0,
-            Self::Mae => 0.0,
+            Self::Mae | Self::Chebyshev => 0.0,
             Self::SoftL1 => 2.0 / (1.0 + residual * residual).powf(1.5),
+            Self::Msle => {
+                let abs_residual = residual.abs();
+                let one_plus_abs = 1.0 + abs_residual;
+                let log_term = one_plus_abs.ln();
+                2.0 * (1.0 - log_term) / (one_plus_abs * one_plus_abs)
+            }
         }
     }
+
+    pub(super) fn value_from_prediction(self, prediction: f64, target: f64) -> f64 {
+        self.value_from_residual(prediction - target)
+    }
+
+    pub(super) fn prediction_derivative(self, prediction: f64, target: f64) -> f64 {
+        self.residual_derivative(prediction - target)
+    }
+
+    pub(super) fn prediction_second_derivative(self, prediction: f64, target: f64) -> f64 {
+        self.residual_second_derivative(prediction - target)
+    }
 }
 
 /// Значение по умолчанию для числа знаков после запятой в режиме квантизации метрик.
@@ -125,11 +176,6 @@ impl ResidualQuantizer {
             Self::Enabled { scale } => (value * scale).round() / scale,
         }
     }
-
-    #[inline]
-    pub(super) fn residual(self, predicted: f64, observed: f64) -> f64 {
-        self.quantize_value(predicted) - self.quantize_value(observed)
-    }
 }
 
 #[derive(Debug, Clone, Copy, PartialEq)]
@@ -211,6 +257,7 @@ pub(super) struct ScalarMetrics {
     pub(super) rmse: f64,
     pub(super) mae: f64,
     pub(super) soft_l1: f64,
+    pub(super) msle: f64,
     pub(super) r2: f64,
     pub(super) max_abs_error: f64,
 }
@@ -223,6 +270,8 @@ pub(super) fn scalar_loss_value(
         OptimizationLossMetric::Mse => metrics.mse,
         OptimizationLossMetric::Mae => metrics.mae,
         OptimizationLossMetric::SoftL1 => metrics.soft_l1,
+        OptimizationLossMetric::Chebyshev => metrics.max_abs_error,
+        OptimizationLossMetric::Msle => metrics.msle,
     }
 }
 
@@ -246,13 +295,17 @@ where
     let mut sse = 0.0;
     let mut sae = 0.0;
     let mut soft_l1_sum = 0.0;
+    let mut msle_sum = 0.0;
     let mut max_abs_error = 0.0_f64;
     for point in points.as_slice() {
-        let residual = quantizer.residual(evaluate(point.x()), point.y());
+        let predicted = quantizer.quantize_value(evaluate(point.x()));
+        let observed = quantizer.quantize_value(point.y());
+        let residual = predicted - observed;
         let abs_residual = residual.abs();
         sse += residual * residual;
         sae += abs_residual;
         soft_l1_sum += OptimizationLossMetric::SoftL1.value_from_residual(residual);
+        msle_sum += OptimizationLossMetric::Msle.value_from_prediction(predicted, observed);
         max_abs_error = max_abs_error.max(abs_residual);
     }
 
@@ -268,6 +321,7 @@ where
     let rmse = mse.sqrt();
     let mae = sae / sample_count;
     let soft_l1 = soft_l1_sum / sample_count;
+    let msle = msle_sum / sample_count;
     let r2 = if sst <= 1e-15 {
         if sse <= 1e-15 { 1.0 } else { 0.0 }
     } else {
@@ -279,6 +333,7 @@ where
         rmse,
         mae,
         soft_l1,
+        msle,
         r2,
         max_abs_error,
     }
@@ -289,6 +344,7 @@ pub(super) struct EvaluatorMetrics {
     pub(super) rmse: f64,
     pub(super) mae: f64,
     pub(super) soft_l1: f64,
+    pub(super) msle: f64,
     pub(super) r2: f64,
     pub(super) max_abs_error: f64,
     pub(super) residuals: Vec<[f64; 2]>,
@@ -316,6 +372,7 @@ where
         rmse: scalar.rmse,
         mae: scalar.mae,
         soft_l1: scalar.soft_l1,
+        msle: scalar.msle,
         r2: scalar.r2,
         max_abs_error: scalar.max_abs_error,
         residuals,