Struct burn::nn::loss::HuberLoss

pub struct HuberLoss {
    pub delta: f32,
    pub lin_bias: f32,
}

Calculate the Huber loss between the inputs and the target.

The loss for each element of the residuals r = targets - predictions is given by

L(r) = 0.5 * r^2                  if |r| <= d
L(r) = 0.5 * d^2 + d * (|r| - d)  if |r| >  d

where d is the configured delta. In particular, this is equal to the L2 Loss for residuals with magnitude smaller than delta, but behaves linearly instead of quadratically for large residuals.

This loss function is less sensitive to outliers than the mean squared error loss.

See also: https://en.wikipedia.org/wiki/Huber_loss

Fields

delta: f32

The bound where the Huber loss function changes from quadratic to linear behaviour.

lin_bias: f32

Precomputed value for the linear bias.

Implementations

impl HuberLoss

pub fn forward<const D: usize, B>( &self, predictions: Tensor<B, D>, targets: Tensor<B, D>, reduction: Reduction, ) -> Tensor<B, 1>

where B: Backend,

Compute the loss element-wise for the predictions and targets, then reduce to a single loss value.

Reduction::Auto behaves as Reduction::Mean.

Shapes

• predictions: […dims]
• targets: […dims]
• output: [1]

pub fn forward_no_reduction<const D: usize, B>( &self, predictions: Tensor<B, D>, targets: Tensor<B, D>, ) -> Tensor<B, D>

where B: Backend,

Compute the loss element-wise for the predictions and targets.

Shapes

• predictions: […dims]
• targets: […dims]
• output: […dims]

pub fn forward_residuals<const D: usize, B>( &self, residuals: Tensor<B, D>, ) -> Tensor<B, D>

where B: Backend,

Compute the loss element-wise for the given residuals.

Shapes

• residuals: […dims]
• output: […dims]

Trait Implementations

impl<B> AutodiffModule<B> for HuberLoss

where B: AutodiffBackend,

type InnerModule = HuberLoss

Inner module without auto-differentiation.

fn valid(&self) -> <HuberLoss as AutodiffModule<B>>::InnerModule

Get the same module, but on the inner backend without auto-differentiation.

impl Clone for HuberLoss

fn clone(&self) -> HuberLoss

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for HuberLoss

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

Formats the value using the given formatter.

impl Display for HuberLoss

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

Formats the value using the given formatter.

impl<B> Module<B> for HuberLoss

where B: Backend,

type Record = ConstantRecord

Type to save and load the module.

fn visit<V>(&self, _visitor: &mut V)

where V: ModuleVisitor<B>,

Visit each tensor parameter in the module with a visitor.

fn map<M>(self, _mapper: &mut M) -> HuberLoss

where M: ModuleMapper<B>,

Map each tensor parameter in the module with a mapper.

fn load_record(self, _record: <HuberLoss as Module<B>>::Record) -> HuberLoss

Load the module state from a record.

fn into_record(self) -> <HuberLoss as Module<B>>::Record

Convert the module into a record containing the state.

fn to_device(self, _: &<B as Backend>::Device) -> HuberLoss

Move the module and all of its sub-modules to the given device.

fn fork(self, _: &<B as Backend>::Device) -> HuberLoss

Fork the module and all of its sub-modules to the given device.

fn collect_devices( &self, devices: Vec<<B as Backend>::Device>, ) -> Vec<<B as Backend>::Device>

Return all the devices found in the underneath module tree added to the given vector without duplicates.

fn devices(&self) -> Vec<<B as Backend>::Device>

Return all the devices found in the underneath module tree without duplicates.

fn no_grad(self) -> Self

Each tensor in the module tree will not require grad.

fn num_params(&self) -> usize

Get the number of parameters the module has, including all of its sub-modules.

fn save_file<FR, PB>( self, file_path: PB, recorder: &FR, ) -> Result<(), RecorderError>

where FR: FileRecorder<B>, PB: Into<PathBuf>,

Save the module to a file using the provided file recorder.

fn load_file<FR, PB>( self, file_path: PB, recorder: &FR, device: &<B as Backend>::Device, ) -> Result<Self, RecorderError>

where FR: FileRecorder<B>, PB: Into<PathBuf>,

Load the module from a file using the provided file recorder.

fn quantize_weights<C>(self, quantizer: &mut Quantizer<C>) -> Self

where C: Calibration,

Quantize the weights of the module.

impl ModuleDisplay for HuberLoss

fn custom_settings(&self) -> Option<DisplaySettings>

Custom display settings for the module.

fn custom_content(&self, content: Content) -> Option<Content>

Custom attributes for the module.

fn format(&self, passed_settings: DisplaySettings) -> String

Formats the module with provided display settings.

impl ModuleDisplayDefault for HuberLoss

fn content(&self, content: Content) -> Option<Content>

Attributes of the module used for display purposes.

fn num_params(&self) -> usize

Gets the number of the parameters of the module.