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

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

A mapping from symbols to consecutive integers

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

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

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

Computes the sum/avg duration of some event in seconds

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

Decoder layer block. In the original paper each operation (multi-head attention, encoder attention or FFN) is postprocessed with: `dropout ->

VGG + Transformer encoder

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

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.

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

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

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

Scores the target for a given source sentence.

Computes the average occurrence of some event per second

Encoder layer block. In the original paper each operation (multi-head attention or FFN) is postprocessed with: `dropout -> add residual -> la

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/master/examples/roberta

Truncate a sequence by returning the first truncation_length tokens

Loader for TorchNet IndexedDataset

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

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

NoOp simply passes the input as the output.

Sparse Multi-Headed Attention. "Generating Long Sequences with Sparse Transformers". Implements fixed factorized self attention, where l=stri

A :class:`~fairseq.data.FairseqDataset` wrapper that appends/prepends/strips EOS. Note that the transformation is applied in :func:`collater`.

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

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

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

Decoder layer block. In the original paper each operation (multi-head attention, encoder attention or FFN) is postprocessed with: `dropout ->

Transformer encoder consisting of *args.encoder_layers* layers. Each layer is a :class:`TransformerEncoderLayer`. Args: args (ar

r"""Implements Adam algorithm. This implementation is modified from torch.optim.Adam based on: `Fixed Weight Decay Regularization in Adam`

Soft masking function for adaptive size. It masks out the last K values of an input. The masking value goes from 1 to 0 gradually, so K can be

Function to calculate Average Lagging from STACL: Simultaneous Translation with Implicit Anticipation and Controllable Latency using Pref

Function to calculate Average Proportion from Can neural machine translation do simultaneous translation? (https://arxiv.org/abs/1606.020

Sets up a backtranslation dataset which takes a tgt batch, generates a src using a tgt-src backtranslation function (*backtranslation_fn*),

Bucket and pad item lengths to the nearest bucket size. This can be used to reduce the number of unique batch shapes, which is important on T

Create a Dataset for CoVoST (https://github.com/facebookresearch/covost). Args: root (str): root path to the dataset and generated manife

Represents a node in a trie managing unordered constraints.

Conv + Transformer encoder

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

A wrapper around TokenBlockDataset for BART dataset. Args: dataset (TokenBlockDataset): dataset to wrap sizes (List[int]): s

Function to calculate Differentiable Average Lagging from Monotonic Infinite Lookback Attention for Simultaneous Machine Translation (htt

Selects every nth element, where n is the index

Multi-headed attention with Gating and Downsampling