Convenient helper nn.Module to create a stack of linear layers.

Implements chunked memmap. - Designed to use with a dataset loader (no slicing support). - It handles saving/loading the meta data automatica

CameraTrajectory is a pattern of camera poses

Upsample, finite-impulse-response filtering, downsample.

A helper class that wraps around the typical nn.Conv1D to help initialize it.

A dictionary that contains the hyper-parameters of Network_Graves.

A helper class that wraps around the typical nn.Linear to help initialize it.

r""" .. math:: \min_x || y - X * x ||^2

A dictionary that contains the hyper-parameters of NetworkGraves.

The Alex Graves' model in https://arxiv.org/abs/1308.0850 The network includes (see Fig 12 in the paper): - attn_rnn - gaussian sli

A wrapper around torch.optim.Optimizer to adjust learning rate with a warm-up period.

The batch preparer works as follows: - First adds datasets before iterator starts. - When creating the iterator (beginning of a epoch):

The class assembles batches by grouping data of similar length. It returns indices of the data in the dataset within a batch. Here is an

A helper class that wraps around the typical nn.ConvTranspose1D to help initialize it.

r""" The class assembles batches by grouping data of similar lengths. It returns indices of the data in the dataset within a batch -- in o

Attention with mixture of gaussian windows. Ref: https://arxiv.org/abs/1308.0850 page 26

Convenient helper nn.Module to create a stack of RNNCells. Note that nn.LSTMCell is preferred over nn.LSTM when for loop needs to be cal

Helper class to log information. The class implements a universal logger that can push information to - local shell - tensorboard To

r""" The layer implements style modulated 1D convolution. :math:`y = mod(s,k) * x`, where :math:`*` is the convolusion,

r""" The layer implements modulated subspace layer. .. math:: & y = W * (x + V * s + x0 + x1) + b + b0, \text{ where} \\ &\q

Variational RNN The inputs to the network are: - past outputs xs = [x0, x1, ..., x_{T-1}] - content sequence cs = [c1, ..., cN]

r""" The layer implements a typical linear layer but allows the input x to be shifted by dx. .. math:: & y = W * (x + dx) + b + b

This is just a simple transformer with a learned token whose output token is used to infer t and surface normal.

The class assembles batches by sorting the sequence length of samples. It returns indices of the data in the dataset within a batch.

Convenient helper nn.Module to create a stack of conv1D layers.

Compute the average and standard deviation of a dictionary of values.

The layer implements a matrix A and its transpose A^T.

The base model. It is a convenient class the collects necessary information (e.g., normalization statistics, codemap, etc) with the mode

r""" The base training procedure, including handling command line arguments through a yaml file, distributed data parallel, training loop, etc

A dictionary that contains the hyper-parameters of a Network.

Dataset content: https://github.com/apple/ml-hypersim We will load the data to the following convention: For world coordinate: x-axis to

The class implements a simple reader for an index file like scp files. Given an index file (e.g., scp file, with or without the unique id),

r"""Dataset as a concatenation of multiple MeshDatasets. Arguments: datasets (sequence): List of datasets to be concatenated

Nested dropout layer proposed by Rippel et al. [2014]. Compared to typical dropout, which independently masks variables, the nested drop

Custom encoder for saving numpy data types into a json file. Json only supports saving native python types like int, list, dict, etc. Therefo

A dictionary that contains the hyper-parameters of :py:class:`TacotronContentEncoder`.

r""" This class implements the spherical Gaussian distribution (i.e., the von Mises-Fisher distribution in 3D). Let :math:`w` in :math:`\math

Convenient helper nn.Module to create a stack of filtered conv1D layers.

Convenient helper nn.Module to create a stack of modulated subspace layers.

- a few conv1D layers - Bidirectional LSTM

In the test, we will use linear regression to test BaseTrainProcess.