A mapping from symbols to consecutive integers

Break a Dataset of tokens into blocks. Args: dataset (~torch.utils.data.Dataset): dataset to break into blocks sizes (List[int]):

A pair of torch.utils.data.Datasets. Args: src (torch.utils.data.Dataset): source dataset to wrap src_sizes (List[int]): sou

Multi-headed attention. See "Attention Is All You Need" for more details.

Interface to write and read from shared memory. Whereas PlasmaArray writes to plasma on serialization, PlasmaView writes to shared memory on insta

Truncate a sequence by returning the first truncation_length tokens

Exponential Moving Average of Fairseq Models EMA keeps a copy of the exponentially decayed model params. The set of params should include both

Randomly samples from a given dataset at each epoch. Sampling is done with or without replacement, depending on the "replace" parameter.

Zip multiple :class:`~fairseq.data.FairseqDataset` instances together. Shorter datasets are repeated in a round-robin fashion to match the length

Records progress through the set of constraints for each item in the beam using a trie.

This is an implementation of the efficient softmax approximation for graphical processing units (GPU), described in the paper "Efficient soft

Computes the sum/avg duration of some event in seconds

Transformer decoder consisting of *args.decoder_layers* layers. Each layer is a :class:`TransformerDecoderLayer`. Args: args (arg

VGG + Transformer encoder

1D convolution over an input of shape (time x batch x channel) The implementation uses gemm to perform the convolution. This implementation i

A wrapper around an ensemble of models.

A LayerDrop implementation based on :class:`torch.nn.ModuleList`. We refresh the choice of which layers to drop every time we iterate ov

Subclass torch's LayerNorm to handle fp16.

Wrap a DistributedDataParallel module and forward requests for missing attributes to the module wrapped by DDP (the twice-wrapped module).

A single linear layer which does a 1x1 conv

Records progress through the set of linear nonbranching constraints with gaps.

Scores the target for a given source sentence.

contextmanager to read a chunck of a file line by line.

A wrapper that kills the process if no progress is made within a given *timeout*. The timer is reset every time :func:`forward` is called.

A sorted dictionary of :class:`Meters`. Meters are sorted according to a priority that is given when the meter is first added to the dictiona

Wrapper class for calling ngram_repeat_block cuda extension

Piecewise linear function. Can be configured with a string.

A simple PyTorch Hub interface to RoBERTa. Usage: https://github.com/pytorch/fairseq/tree/main/examples/roberta

Computes the average occurrence of some event per second

A :class:`~fairseq.data.FairseqDataset` wrapper that transform bos on collated samples of language pair dataset. Note that the transformation

CIDEr scorer.

Wrapper around an iterable that maintains the iteration count. Args: iterable (iterable): iterable to wrap start (int): starting

build a dictionary with occurence count and then build the Huffman code for it.

an indexed dataset that use mmap and memoryview to access data from disk that was compressed with a HuffmanCoder.

Loader for TorchNet IndexedDataset

This module learns positional embeddings up to a fixed maximum size. Padding ids are ignored by either offsetting based on padding_idx or

An optimized version of nn.Conv1d. At training time, this module uses ConvTBC, which is an optimized version of Conv1d. At inference time, it

Create a Dataset for MuST-C. Each item is a tuple of the form: waveform, sample_rate, source utterance, target utterance, speaker_id, utt

Model parallel Multi-headed attention. This performs the Multi-headed attention over multiple gpus. See "Megatron-LM: https://arxiv.org/pdf/1

Stores multiple instances of FairseqDataset together and in every iteration creates a batch by first sampling a dataset according to a specif

Multi-headed attention. See "Attention Is All You Need" for more details.

NoOp simply passes the input as the output.

Wrapper class for data config YAML

A sharded wrapper around an iterable, padded to length. Args: iterable (iterable): iterable to wrap num_shards (int): number of s