Enum RobustLoss 

pub enum RobustLoss {
    Mse,
    Huber {
        delta: f64,
    },
    Trimmed {
        alpha: f64,
    },
}

A loss function for fitting an expression’s constants to data.

Variants

Mse

Mean-squared error (no robustness). Every residual gets full quadratic weight.

Huber

Huber loss: quadratic for |r| ≤ delta, linear beyond. delta is the quadratic-to-linear transition; smaller delta is more aggressive at down-weighting outliers.

Fields

delta: f64

Transition point between the quadratic and linear regimes.

Trimmed

Trimmed MSE: discard the largest alpha fraction of squared residuals before averaging. alpha ∈ [0, 1); e.g. alpha = 0.1 ignores the worst 10% of points.

Fields

alpha: f64

Fraction of largest-residual points to trim.

Implementations

impl RobustLoss

pub fn cost(self, residuals: &[f64]) -> f64

The scalar loss (mean over points) for a residual vector r = prediction − target.

pub fn irls_weight(self, r: f64, residuals: &[f64]) -> f64

The IRLS multiplicative weight w_i applied to residual row i (and the matching Jacobian row) so that a weighted least-squares step descends the robust objective. residuals is the full current residual vector (needed by the trimmed loss to find its quantile threshold).

Trait Implementations

impl Clone for RobustLoss

fn clone(&self) -> RobustLoss

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Copy for RobustLoss

impl Debug for RobustLoss

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for RobustLoss

fn default() -> RobustLoss

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for RobustLoss

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for RobustLoss

fn eq(&self, other: &RobustLoss) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for RobustLoss

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for RobustLoss