r"""Convert tensor to image. Args: image_tensor (torch.tensor or list of torch.tensor): If tensor then (NxCxHxW) or (NxTxCxHx

r"""Sum all elements recursively in a nested list. Args: x (nested list of int): Input list of elements. Returns:

r"""Produce output given segmentation and other conditioning inputs. random style will be used if neither z nor style_img is provided.

r"""check if current process is the master

r"""Apply any ops from op_dict to data types. Args: data (dict): Dict containing data_type as key, with each value

r"""Get number of channels for the input image. Args: data_cfg (obj): Data configuration structure. Returns: num_channels (in

r"""Get the image save path. Args: subdir (str): Sub-directory under the main directory for saving the outputs.

r""" Record time before computing loss.

r"""Get the number of filters at current layer. Args: num_downsamples (int) : How many downsamples at current layer. Retu

r"""Get number of channels for the input label map. Args: data_cfg (obj): Data configuration structure. video (bool): Whether we

r"""Get rank of the thread.

r"""Compute the fid score. Args: fid_path (str): Location for the numpy file to store or to load the statistics. data

r"""Load mean and covariance from saved npy file if exists. Otherwise, compute the mean and covariance. Args: act_path (str or None):

r"""Decode content and style code to an image. Args: content (Tensor): Content code. style (Tensor): Style code.

r"""Encode an image to content and style code. Args: images (Tensor): Input images. Returns: (tuple):

r"""Performs a single optimization step. Args: closure (callable, optional): A closure that reevaluates the model

r"""Squared norm.

r"""Write values to meters.

r"""Get world size. How many GPUs are available in this job.

r"""Resamples an image using the provided flow. Args: image (NxCxHxW tensor) : Image to resample. flow (Nx2xHxW tensor) : Optical

r"""Convert flow tensor to color image. Args: tensor (tensor) of If tensor then (NxCxHxW) or (NxTxCxHxW) or (CxHxW). imty

r"""Move all tensors inside data to gpu. Args: data (dict, list, or tensor): Input data.

r"""Pad, upsample, filter, and downsample a batch of 2D images. Performs the following sequence of operations for each channel: 1. Upsample

r"""Initialize weights in the network. Args: init_type (str): The name of the initialization scheme. gain (float): The parameter

r"""Record the value

r"""Compute GAN loss and feature matching loss. Args: net_D_output (dict): Output of the discriminator. dis_update (b

r"""Visualize the input label when saving to image. Args: label (tensor): Input label tensor.

r"""Flush all meters using the current iteration.

r"""Get attribute with default choice. If attribute does not exist, set it using the default value. Args: cfg (obj) : Config options.

r"""Perform data augmentation on images only. Args: data (dict): Keys are from data types. Values can be numpy.ndarray

r"""Reshape input x to the desired weight shape. Args: x (tensor or list of tensors): Input features. weight_shape (l

r"""Return output values. Note that when the gan mode is relativistic. It will do the difference before returning. Args: n

r"""Return the total loss to be backpropagated. Args: gen_forward (bool): If ``True``, backpropagates the generator loss,

r"""Applies differentiable augmentation. Args: data (dict): Input data. keys (list of str): Keys to the data values that we want t

r"""Concat previous and current frames and only keep the latest $(n_frames). If concatenated frames are longer than $(n_frames), drop the oldest o

r"""Crop the image using the given coordinates and resize to target size. Args: img (tensor or list of tensors): Input image. coo

r""" gather to all ranks

r"""Return an activation normalization layer. Args: num_features (int): Number of feature channels. norm_type (str):

r"""Split concatenated labels into their parts. Args: labels (torch.Tensor): Labels obtained through concatenation. label_lengths

r"""Convert all images to tensor. Args: data (dict): Dict containing data_type as key, with each value as a list

r"""Download a file from google drive. Args: URL: GDrive file ID. destination: Path to save the file. Returns:

r"""Draw all the edges in the edge list on the canvas. Args: canvas (HxWxK numpy array): Canvas to draw. keypoints (Px2 numpy arr

r"""Obtain the foreground mask for pose sequences, which only includes the human. This is done by looking at the body part map from DensePose.

r"""Get num channels of all labels to be concated. Returns: label_lengths (OrderedDict): Dict mapping image data_type to num

r"""Load network weights, optimizer parameters, scheduler parameters from a checkpoint. Args: cfg (obj): Global configura

r""" Set a model to require gradient or not. Args: model (nn.Module): Neural network model. require (bool): Whether the network r

r"""Reset the renderer. Args: is_flipped_input (bool): Is the input sequence left-right flipped?

r"""Get frames from this sequence during inference. Args: index (int): Index of inference sequence.

r"""Set random seeds for everything. Args: seed (int): Random seed. by_rank (bool):

r"""Convert segmentation mask tensor to color image. Args: segmap (tensor) of If tensor then (NxCxHxW) or (NxTxCxHxW) or (CxHxW).

r"""Move all tensors inside data to device. Args: data (dict, list, or tensor): Input data. device (str): 'cpu' or 'cuda'.

r"""Assign training loss terms. Args: name (str): Loss name criterion (obj): Loss object. weight (float):

r"""Generate images by combining their content and style codes. Args: content (tensor): Content code tensor. style (t

r"""Generate images by combining their content and style codes. Args: content (tensor): Content code tensor. style (t

r"""Set colors given a list of x and y coordinates for the edge. Args: im (HxWxC numpy array): Canvas to draw. x (1D numpy array)

r"""Remove some labels (e.g. face regions) in the pose map if necessary. Args: pose_map (3D, 4D or 5D tensor): Input pose map. po

r"""Discriminator forward. Args: data (dict): Input data. net_G_output (dict): Generator output. past_fra

r"""Generate a sequence of frames given a sequence of data. Args: data (dict): Training data at the current iteration.

r"""Get the checkpoint path. If it does not exist yet, download it from the url. Args: checkpoint_path (str): Checkpoint path.

r"""Return the networks, the optimizers, and the schedulers. We will first set the random seed to a fixed value so that each GPU copy will be

r"""Return a nonlinearity layer. Args: nonlinearity_type (str): Type of nonlinear activation function. ``'none'``

Return the trainer object. Args: cfg (Config): Loaded config object. net_G (obj): Generator network object. net_D (obj):

r"""One residual block layer in the main branch. Args: x (4D tensor) : Current feature map. encoded_label (list of tens

r"""Pick the image among images according to idx. Args: images (B x N x C x H x W tensor or list of tensors) : N images. idx (B t

r"""Do any postprocessing of the data / output here. Args: data (dict): Training data at the current iteration. net_G

r"""Randomly shift the input tensor. Args: x (4D tensor): The input batch of images. offset (int): The maximum offset ratio that

r"""Compute visualization images and save them to the disk. Args: path (str): Location of the file. data (dict): Data

r"""Set the length of sequence you want as output from dataloader. Args: sequence_length (int): Length of output sequences.