Struct SmoothL1Loss 

pub struct SmoothL1Loss {
    pub beta: f32,
}

Computes the Smooth L1 Loss between predictions and targets.

This loss function uses L2 loss for small errors (below beta) and L1 loss for large errors (above beta), providing robustness to outliers while maintaining smooth gradients near |x - y| = 0.

Mathematical Definition

For predictions x and targets y, the element-wise loss is:

• L_i = 0.5 * (x_i - y_i)² / beta , if |x_i - y_i| < beta
• L_i = |x_i - y_i| - 0.5 * beta , otherwise

Notes

Smooth L1 loss is closely related to HuberLoss since it is equivalent to HuberLoss scaled by 1/beta: SmoothL1(x, y, beta) = Huber(x, y, beta) / beta

This leads to the following differences:

• As beta approaches 0, Smooth L1 loss converges to L1Loss, while HuberLoss converges to 0. When beta = 0, Smooth L1 loss is equivalent to L1 loss. Thus, the beta parameter in Burn must be positive. L1Loss should be used for beta = 0.
• As beta approaches positive infinity, Smooth L1 loss converges to a constant 0 loss, while HuberLoss converges to L2Loss.

Example

use burn_nn::loss::{SmoothL1LossConfig, Reduction};
use burn::tensor::Tensor;

// Create Smooth L1 loss with the default beta=1.0
let smooth_l1 = SmoothL1LossConfig::new().init();

let predictions: Tensor<2> = /* model output */;
let targets: Tensor<2> = /* ground truth */;

// Compute element-wise loss without reduction
let element_wise = smooth_l1.forward(predictions.clone(), targets.clone());

// Compute loss with mean reduction
let loss = smooth_l1.forward_with_reduction(predictions.clone(), targets.clone(), Reduction::Mean);

// Per-image loss: reduce over C, H, W → [batch, 1, 1, 1]
let loss_per_image = smooth_l1.forward_reduce_dims(predictions, targets, &[1, 2, 3]);

Fields

beta: f32

Specifies the threshold at which to change between L1 and L2 loss. The value must be positive. Default: 1.0

Implementations

impl SmoothL1Loss

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

Computes the element-wise smooth L1 loss without reduction.

Arguments

• predictions - The model’s predicted values.
• targets - The ground truth target values.

Returns

A tensor of the same shape as the inputs, containing the smooth L1 loss for each element.

Shapes

• predictions: [...dims] - Any shape
• targets: [...dims] - Must match predictions shape
• output: [...dims] - Same shape as inputs

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

Computes the smooth L1 loss with reduction.

Arguments

• predictions - The model’s predicted values.
• targets - The ground truth target values.
• reduction - Specifies how to reduce the element-wise losses:
  • Reduction::Mean or Reduction::Auto: Returns the mean of all element-wise losses.
  • Reduction::Sum: Returns the sum of all element-wise losses.

Returns

A scalar tensor containing the reduced loss value.

Shapes

• predictions: [...dims] - Any shape
• targets: [...dims] - Must match predictions shape
• output: [1] - Scalar loss value

pub fn forward_reduce_dims<const D: usize>( &self, predictions: Tensor<D>, targets: Tensor<D>, dims: &[impl AsIndex], ) -> Tensor<D>

Computes the smooth L1 loss with reduction over specified dimensions.

Calculates element-wise smooth L1 loss, then takes the mean over the specified dimensions. Useful for per-sample or per-channel losses.

Dimensions can be provided in any order.

Arguments

• predictions - The model’s predicted values.
• targets - The ground truth target values.
• dims - Dimensions to reduce over. Negative dimensions are supported and count from the end.

Returns

A tensor with the specified dimensions reduced to size 1.

Example

// Consider image tensor with shape [batch, C, H, W]
let smooth_l1 = SmoothL1LossConfig::new().init();

// Per-image loss: reduce over C, H, W → [batch, 1, 1, 1]
let loss_per_image = smooth_l1.forward_reduce_dims(predictions, targets, &[1, 2, 3]);

Trait Implementations

impl Clone for SmoothL1Loss

fn clone(&self) -> SmoothL1Loss

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for SmoothL1Loss

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

Formats the value using the given formatter.

impl Display for SmoothL1Loss

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

Formats the value using the given formatter.

impl Module for SmoothL1Loss

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

where V: ModuleVisitor,

Visit each parameter and module-owned control value with a visitor.

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

where M: ModuleMapper,

Map each parameter and module-owned control value with a mapper.

fn to_device(self, _: &Device) -> SmoothL1Loss

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

fn fork(self, _: &Device) -> SmoothL1Loss

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

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

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

fn materialize(self) -> SmoothL1Loss

Fold parameter reparameterizations into their effective values and remove them.

fn valid(&self) -> SmoothL1Loss

Returns a validation snapshot without autodiff or active training flags.

fn train(self) -> SmoothL1Loss

Enables autodiff and restores configured training state throughout the module.

fn devices(&self) -> Vec<Device>

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

fn set_require_grad(self, require_grad: bool) -> Self

Set whether every floating-point tensor parameter in the module tree requires gradients.

fn set_require_grad_group(self, group: ParamGroup, require_grad: bool) -> Self

Set whether matched floating-point tensor parameters require gradients.

fn no_grad(self) -> Self

Disable gradients for every floating-point tensor parameter in the module tree.

fn freeze(self) -> Self

Freeze the whole module tree.

fn unfreeze(self) -> Self

Unfreeze the whole module tree.

fn freeze_group(self, group: ParamGroup) -> Self

Freeze every module-owned value in the given group, leaving the rest of the module untouched.

fn unfreeze_group(self, group: ParamGroup) -> Self

Unfreeze every module-owned value in the given group, leaving the rest of the module untouched.

fn num_params(&self) -> usize

Get the number of parameters the module has, including all of its sub-modules, without initializing the ones not initialized yet.

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

Quantize the weights of the module.

fn quantize_weights_group( self, quantizer: &mut Quantizer, group: ParamGroup, ) -> Self

Quantize the weights of the given parameter group.

fn apply_reparameterization<R>(self, reparameterizer: R) -> Self

where Self: Sized, R: Reparameterizer,

Attach reparameterizations using the given Reparameterizer.

fn apply_lora(self, lora: Lora) -> Self

where Self: Sized,

Attach LoRA adapters to the module’s 2-D weights, freezing all base tensor parameters.

fn apply_qlora(self, qlora: QLora) -> Self

where Self: Sized,

Apply QLoRA to the module: quantize the (frozen) base tensor parameters and attach trainable LoRA adapters to 2-D weights.

fn into_record(self) -> ModuleRecord

where Self: Sized,

Collect this module’s tensor parameters into a ModuleRecord.

fn into_record_group(self, group: ParamGroup) -> ModuleRecord

where Self: Sized,

Collect the tensor parameters group names into a ModuleRecord.

fn try_load_record(self, record: ModuleRecord) -> Result<Self, RecordError>

where Self: Sized,

Apply a ModuleRecord to this module, returning the loaded module.

fn load_record(self, record: ModuleRecord) -> Self

where Self: Sized,

Apply a ModuleRecord to this module, consuming and returning it.

fn save_file<P>(self, path: P) -> Result<(), RecordError>

where P: AsRef<Path>, Self: Sized,

Save this module’s parameters to a burnpack file on disk.

fn load_file<P>(self, path: P) -> Self

where P: AsRef<Path>, Self: Sized,

Load this module’s parameters from a burnpack file on disk, returning the loaded module.

fn try_load_file<P>(self, path: P) -> Result<Self, RecordError>

where P: AsRef<Path>, Self: Sized,

Fallible variant of load_file.

impl ModuleDisplay for SmoothL1Loss

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

Formats the module with provided display settings.

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.

impl ModuleDisplayDefault for SmoothL1Loss

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.