Enum LossType 

pub enum LossType {
    Squared,
    Logistic,
    Huber {
        delta: f64,
    },
    Softmax {
        n_classes: usize,
    },
    Expectile {
        tau: f64,
    },
    Quantile {
        tau: f64,
    },
}

Tag identifying a loss function for serialization and reconstruction.

When saving a model, the loss type is captured so the correct loss function can be reconstructed on load. Built-in losses implement Loss::loss_type to return Some(LossType::...) automatically.

Custom losses return None from loss_type() and must be handled manually during serialization.

Variants

Squared

Squared error loss (regression).

Logistic

Logistic (binary cross-entropy) loss.

Huber

Huber loss with the given delta threshold.

Fields

delta: f64

Threshold at which loss transitions from quadratic to linear.

Softmax

Softmax (multi-class cross-entropy) loss.

Fields

n_classes: usize

Number of classes.

Expectile

Expectile loss with asymmetry parameter.

Fields

tau: f64

Asymmetry parameter tau in (0, 1).

Quantile

Quantile (pinball) loss with target quantile.

Fields

tau: f64

Target quantile tau in (0, 1).

Implementations

impl LossType

pub fn into_loss(self) -> Box<dyn Loss>

Reconstruct the loss function from its serialized tag.

Trait Implementations

impl Clone for LossType

fn clone(&self) -> LossType

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for LossType

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for LossType

fn deserialize<__D>( __deserializer: __D, ) -> Result<LossType, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for LossType

fn eq(&self, other: &LossType) -> 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 LossType

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for LossType