Module elpis.trainer.data_collator

Classes

class DataCollatorCTCWithPadding (processor: transformers.models.auto.processing_auto.AutoProcessor, padding: Union[bool, str] = 'longest', pad_to_multiple_of: Optional[int] = None, pad_to_multiple_of_labels: Optional[int] = None)

Data collator that will dynamically pad the inputs received.

Args

processor (:class:~transformers.AutoProcessor) The processor used for proccessing the data. padding (:obj:bool, :obj:str or :class:~transformers.tokenization_utils_base.PaddingStrategy, optional, defaults to :obj:True): Select a strategy to pad the returned sequences (according to the model's padding side and padding index) among: * :obj:True or :obj:'longest': Pad to the longest sequence in the batch (or no padding if only a single sequence if provided). * :obj:'max_length': Pad to a maximum length specified with the argument :obj:max_length or to the maximum acceptable input length for the model if that argument is not provided. * :obj:False or :obj:'do_not_pad' (default): No padding (i.e., can output a batch with sequences of different lengths). max_length (:obj:int, optional): Maximum length of the input_values of the returned list and optionally padding length (see above). max_length_labels (:obj:int, optional): Maximum length of the labels returned list and optionally padding length (see above). pad_to_multiple_of (:obj:int, optional): If set will pad the sequence to a multiple of the provided value. This is especially useful to enable the use of Tensor Cores on NVIDIA hardware with compute capability >= 7.5 (Volta).

Expand source code

@dataclass
class DataCollatorCTCWithPadding:
    """
    Data collator that will dynamically pad the inputs received.
    Args:
        processor (:class:`~transformers.AutoProcessor`)
            The processor used for proccessing the data.
        padding (:obj:`bool`, :obj:`str` or :class:`~transformers.tokenization_utils_base.PaddingStrategy`, `optional`, defaults to :obj:`True`):
            Select a strategy to pad the returned sequences (according to the model's padding side and padding index)
            among:
            * :obj:`True` or :obj:`'longest'`: Pad to the longest sequence in the batch (or no padding if only a single
              sequence if provided).
            * :obj:`'max_length'`: Pad to a maximum length specified with the argument :obj:`max_length` or to the
              maximum acceptable input length for the model if that argument is not provided.
            * :obj:`False` or :obj:`'do_not_pad'` (default): No padding (i.e., can output a batch with sequences of
              different lengths).
        max_length (:obj:`int`, `optional`):
            Maximum length of the ``input_values`` of the returned list and optionally padding length (see above).
        max_length_labels (:obj:`int`, `optional`):
            Maximum length of the ``labels`` returned list and optionally padding length (see above).
        pad_to_multiple_of (:obj:`int`, `optional`):
            If set will pad the sequence to a multiple of the provided value.
            This is especially useful to enable the use of Tensor Cores on NVIDIA hardware with compute capability >=
            7.5 (Volta).
    """

    processor: AutoProcessor
    padding: Union[bool, str] = "longest"
    pad_to_multiple_of: Optional[int] = None
    pad_to_multiple_of_labels: Optional[int] = None

    def __call__(
        self, features: List[Dict[str, Union[List[int], torch.Tensor]]]
    ) -> Dict[str, torch.Tensor]:
        # split inputs and labels since they have to be of different lengths and need
        # different padding methods
        input_features = [
            {"input_values": feature["input_values"]} for feature in features
        ]
        label_features = [{"input_ids": feature["labels"]} for feature in features]

        batch = self.processor.pad(  # type: ignore
            input_features,
            padding=self.padding,
            pad_to_multiple_of=self.pad_to_multiple_of,
            return_tensors="pt",
        )

        labels_batch = self.processor.pad(  # type: ignore
            labels=label_features,
            padding=self.padding,
            pad_to_multiple_of=self.pad_to_multiple_of_labels,
            return_tensors="pt",
        )

        # replace padding with -100 to ignore loss correctly
        labels = labels_batch["input_ids"].masked_fill(
            labels_batch.attention_mask.ne(1), -100
        )

        batch["labels"] = labels
        if "attention_mask" in batch:
            batch["attention_mask"] = batch["attention_mask"].to(torch.long)

        return batch

Class variables

var pad_to_multiple_of : Optional[int]

var pad_to_multiple_of_labels : Optional[int]

var padding : Union[bool, str]

var processor : transformers.models.auto.processing_auto.AutoProcessor

class DataCollatorSpeechSeq2SeqWithPadding (processor: transformers.models.auto.processing_auto.AutoProcessor, decoder_start_token_id: int, forward_attention_mask: bool)

Data collator that will dynamically pad the inputs received.

Args

processor ([WhisperProcessor]) The processor used for processing the data. decoder_start_token_id (int) The begin-of-sentence of the decoder. forward_attention_mask (bool) Whether to return attention_mask.

Expand source code

@dataclass
class DataCollatorSpeechSeq2SeqWithPadding:
    """
    Data collator that will dynamically pad the inputs received.
    Args:
        processor ([`WhisperProcessor`])
            The processor used for processing the data.
        decoder_start_token_id (`int`)
            The begin-of-sentence of the decoder.
        forward_attention_mask (`bool`)
            Whether to return attention_mask.
    """

    processor: AutoProcessor
    decoder_start_token_id: int
    forward_attention_mask: bool

    def __call__(
        self, features: List[Dict[str, Union[List[int], torch.Tensor]]]
    ) -> Dict[str, torch.Tensor]:
        # split inputs and labels since they have to be of different lengths and need
        # different padding methods
        model_input_name = self.processor.model_input_names[0]  # type: ignore
        input_features = [
            {model_input_name: feature[model_input_name]} for feature in features
        ]
        label_features = [{"input_ids": feature["labels"]} for feature in features]

        batch = self.processor.feature_extractor.pad(  # type: ignore
            input_features, return_tensors="pt"
        )

        if self.forward_attention_mask:
            batch["attention_mask"] = torch.LongTensor(
                [feature["attention_mask"] for feature in features]
            )

        labels_batch = self.processor.tokenizer.pad(label_features, return_tensors="pt")  # type: ignore

        # replace padding with -100 to ignore loss correctly
        labels = labels_batch["input_ids"].masked_fill(
            labels_batch.attention_mask.ne(1), -100
        )

        # if bos token is appended in previous tokenization step,
        # cut bos token here as it's append later anyways
        if (labels[:, 0] == self.decoder_start_token_id).all().cpu().item():
            labels = labels[:, 1:]

        batch["labels"] = labels

        return batch

Class variables

var decoder_start_token_id : int

var forward_attention_mask : bool

var processor : transformers.models.auto.processing_auto.AutoProcessor