Struct CTCLoss 

pub struct CTCLoss { /* private fields */ }

Computes the Connectionist Temporal Classification (CTC) loss.

Calculates the loss between a continuous (unsegmented) time series and a target sequence. CTC sums over the probability of all possible alignments of the input to the target, producing a loss value that is differentiable with respect to each input node.

The input to this loss is expected to be log-probabilities (e.g., via log_softmax), not raw logits.

References

• Connectionist Temporal Classification: Labelling Unsegmented Sequence Data with Recurrent Neural Networks

Example

use burn::tensor::{Tensor, Int};
use burn::tensor::activation::log_softmax;
use burn::nn::loss::{CTCLossConfig, CTCLoss};

let device = Default::default();

// Initialize CTC Loss with default configuration
let ctc_loss = CTCLossConfig::new().init();

// Initialize CTC Loss with custom configuration
let ctc_loss = CTCLossConfig::new()
    .with_blank(1)
    .with_zero_infinity(true)
    .init();

// Prepare inputs (Logits shape: [Time, Batch, Class])
// In your actual code, the logits would be the output of your model
let logits = Tensor::<3>::ones([10, 2, 5], &device);
let log_probs = log_softmax(logits, 2);

// Targets shape: [Batch, Max_Target_Len]
// Note: Targets should not contain the blank index (1).
let targets = Tensor::<2, Int>::from_data([[0, 2], [3, 4]], &device);

// Lengths shape: [Batch]
let input_lengths = Tensor::<1, Int>::from_data([10, 8], &device);
let target_lengths = Tensor::<1, Int>::from_data([2, 2], &device);

// Compute loss
let loss = ctc_loss.forward(log_probs, targets, input_lengths, target_lengths);

Implementations

impl CTCLoss

pub fn forward( &self, log_probs: Tensor<3>, targets: Tensor<2, Int>, input_lengths: Tensor<1, Int>, target_lengths: Tensor<1, Int>, ) -> Tensor<1>

Computes the CTC loss for the input log-probabilities and targets with no reduction applied.

Arguments

• log_probs: The log-probabilities of the outputs (e.g., from log_softmax).
• targets: A 2D tensor containing the target class indices. These indices should not include the blank index used in CTC loss. The targets are padded to the length of the longest sequence.
• input_lengths: A 1D tensor containing the actual length of the input sequence for each batch. This allows retrieving the actual sequence of log-probabilities from log_probs if the batch contains sequences of varying lengths.
• target_lengths: A 1D tensor containing the actual length of the target sequence for each target sequence in targets.

Returns

• A 1D tensor of shape [batch_size] containing the loss for each sample.

Shapes

• log_probs: [time_steps, batch_size, num_classes] where num_classes includes blank.
• targets: [batch_size, max_target_length]
• input_lengths: [batch_size]
• target_lengths: [batch_size]

Panics

• If the batch dimension of targets, input_lengths or target_lengths differs from log_probs.
• If blank is greater than or equal to num_classes.

pub fn forward_with_reduction( &self, log_probs: Tensor<3>, targets: Tensor<2, Int>, input_lengths: Tensor<1, Int>, target_lengths: Tensor<1, Int>, reduction: Reduction, ) -> Tensor<1>

Computes the CTC loss for the input log-probabilities and targets with reduction.

Arguments

• log_probs: The log-probabilities of the outputs (e.g., from log_softmax).
• targets: A 2D tensor containing the target class indices. These indices should not include the blank index used in CTC loss. The targets are padded to the length of the longest sequence.
• input_lengths: A 1D tensor containing the actual length of the input sequence for each batch. This allows retrieving the actual sequence of log-probabilities from log_probs if the batch contains sequences of varying lengths.
• target_lengths: A 1D tensor containing the actual length of the target sequence for each target sequence in targets.
• reduction: The reduction strategy to apply to the loss tensor containing the CTC loss values for each sample (e.g., mean, sum). For the mean reduction strategy, the output losses will be divided by the target lengths and then the mean over the batch is taken. This follows PyTorch’s behavior.

Returns

• A 1D tensor of shape [1] containing the reduced loss value.

Shapes

• log_probs: [time_steps, batch_size, num_classes] where num_classes includes blank.
• targets: [batch_size, max_target_length]
• input_lengths: [batch_size]
• target_lengths: [batch_size]

Panics

• If reduction is not one of Reduction::Auto, Reduction::Mean, and Reduction::Sum.
• If blank index is greater than or equal to num_classes.
• If the batch dimension of log_probs, targets, input_lengths, and target_lengths do not match.

Trait Implementations

impl Clone for CTCLoss

fn clone(&self) -> CTCLoss

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for CTCLoss

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

Formats the value using the given formatter.

impl Display for CTCLoss

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

Formats the value using the given formatter.

impl Module for CTCLoss

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) -> CTCLoss

where M: ModuleMapper,

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

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

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

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

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) -> CTCLoss

Fold parameter reparameterizations into their effective values and remove them.

fn valid(&self) -> CTCLoss

Returns a validation snapshot without autodiff or active training flags.

fn train(self) -> CTCLoss

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 CTCLoss

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 CTCLoss

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.