A wrapper around :class:`torch.nn.Conv2d` to support empty inputs and more features.

This structure stores a list of boxes as a Nx4 torch.Tensor. It supports some common methods about boxes (`area`, `clip`, `nonempty`, etc

This class represents a list of instances in an image. It stores the attributes of instances (e.g., boxes, masks, labels, scores) as "fields"

A simple structure that contains basic shape specification about a tensor. It is often used as the auxiliary inputs/outputs of models, to

This structure stores a list of rotated boxes as a Nx5 torch.Tensor. It supports some common methods about boxes (`area`, `clip`, `nonemp

Visualizer that draws data about detection/segmentation on images. It contains methods like `draw_{text,box,circle,line,binary_mask,polygon}

This class stores the segmentation masks for all objects in one image, in the form of bitmaps. Attributes: tensor: bool Tensor o

Region of interest feature map pooler that supports pooling from one or more feature maps.

Map a function over the elements in a dataset.

Produce mask GT from DensePose predictions This sampler simply converts DensePose predictions to BitMasks that a contain a bool tensor of

Sampler implementation that converts predictions to GT using registered samplers for different fields of `Instances`.

Resize the image to a target size.

The box-to-box transform defined in R-CNN. The transformation is parameterized by 4 deltas: (dx, dy, dw, dh). The transformation scales the b

Same as :class:`Checkpointer`, but is able to: 1. handle models in detectron & detectron2 model zoo, and apply conversions for legacy models.

A customized version of `detectron2.data.DatasetMapper`

Predictor output that contains segmentation and inner coordinates predictions for predefined body parts: * coarse segmentation, a tensor

Predictor output that contains embedding and coarse segmentation data: * embedding: float tensor of size [N, D, H, W], contains estimated em

Structure that holds a list of images (of possibly varying sizes) as a single tensor. This works by padding the images to the same size.

Stores keypoint **annotation** data. GT Instances have a `gt_keypoints` property containing the x,y location and visibility flag of each keyp

This class assigns to each predicted "element" (e.g., a box) a ground-truth element. Each predicted element will have exactly zero or one mat

Base visualizer for matrix data

A class that supports simple attribute setter/getter. It is intended for storing metadata of a dataset and make it accessible globally.

In training, we only care about the "infinite stream" of training data. So this sampler produces an infinite stream of indices and all wo

Multi-head Attention block with relative position embeddings.

Extracts data for CompoundVisualizer

Wrapper class to combine multiple :class:`DatasetEvaluator` instances. This class dispatches every evaluation call to all of its :class:

Wrap a list to a torch Dataset. It produces elements of the list as data.

DensePose results for chart-based methods represented by labels and quantized inner coordinates (U, V) of individual charts. Each chart is a

Samples DensePose data from DensePose predictions. Samples for each class are drawn using confidence value estimates.

Two linear layers for predicting Fast R-CNN outputs: 1. proposal-to-detection box regression deltas 2. classification scores

Attribute: polygons (list[ndarray]): list[ndarray]: polygons for this mask. Each ndarray has format [x, y, x, y, ...]

Multilayer perceptron.

Image to Patch Embedding Args: patch_size (int): Patch token size. Default: 4. in_chans (int): Number of input image channels. Def

This class stores the segmentation masks for all objects in one image, in the form of polygons. Attributes: polygons: list[list[ndar

Represent masks by N smaller masks defined in some ROIs. Once ROI boxes are given, full-image bitmask can be obtained by "pasting" the mask o

The box-to-box transform defined in Rotated R-CNN. The transformation is parameterized by 5 deltas: (dx, dy, dw, dh, da). The transformation

Similar to nn.ParameterList, but for buffers

Representing a list of detectron2.structures.Boxes from minibatch, each box is represented by a 5d vector (batch index + 4 coordinates), or a

A wrapper around the traced model in Caffe2's protobuf format. The exported graph has different inputs/outputs from the original Pytorch

The same as `fvcore.common.config.CfgNode`, but different in: 1. Use unsafe yaml loading by default. Note that this may lead to arbit

A callable which takes a dataset dict in Detectron2 Dataset format, and map it into a format used by the model. This is the default call

DensePose results for chart-based methods represented by labels and inner coordinates (U, V) of individual charts. Each chart is a 2D manifol

We add confidence values to DensePoseChartResult Thus the results are represented by two tensors: - labels (tensor [H, W] of long): conta

Dense pose relative annotations that can be applied to any bounding box: x - normalized X coordinates [0, 255] of annotated points

The user-facing class that provides metric storage functionalities. In the future we may add support for storing / logging other types of da

This module implements :paper:`FPN`. It creates pyramid features built on top of some input feature maps.

Attention processor used typically in processing the SD3-like self-attention projections.

Produce indices for inference across all workers. Inference needs to run on the __exact__ set of samples, therefore when the total number

Tensor representation of a list of Instances object for a batch of images. When dealing with a batch of images with Caffe2 ops, a list of bb

A LRScheduler which uses fvcore :class:`ParamScheduler` to multiply the learning rate of each param in the optimizer. Every step, the lea

Mask or segmentation loss as cross-entropy for raw unnormalized scores given ground truth labels. Ground truth labels are either defined by c

In PyTorch<=1.5, ``nn.SyncBatchNorm`` has incorrect gradient when the batch size on each worker is different. (e.g., when scale augmentat

Wrap an object to make it more picklable, note that it uses heavy weight serialization libraries that are slower than pickle. It's best t

Similar to TrainingSampler, but a sample may appear more times than others based on its "repeat factor". This is suitable for training on cla

This method returns a copy of this image, rotated the given number of degrees counter clockwise around its center.

Implementation of a single process tensor storage which stores data in a file

Implementation of a single process tensor storage which stores data in RAM

A model may take rich input/output format (e.g. dict or custom classes), but `torch.jit.trace` requires tuple of tensors as input/output.

Used to store data about detected objects in video frame, in order to transfer color to objects in the future frames. Attributes:

Unify different panoptic annotation/prediction formats

Selector that accepts all entries

AnyNet stage (sequence of blocks w/ the same output shape).

Batch data that have similar aspect ratio together. In this implementation, images whose aspect ratio < (or >) 1 will be batched together

r""" Processor for implementing scaled dot-product attention (enabled by default if you're using PyTorch 2.0).

Input that can be used with :meth:`Augmentation.__call__`. This is a standard implementation for the majority of use cases. This class pr

Apply a sequence of augmentations. It has ``__call__`` method to apply the augmentations. Note that :meth:`get_transform` method is imp

A basic Swin Transformer layer for one stage. Args: dim (int): Number of feature channels depth (int): Depths of this stage.

The standard ResNet stem (layers before the first residual block), with a conv, relu and max_pool.

Basic transformation: [3x3 conv, BN, Relu] x2.

Args: packed_annotations: object that contains packed annotations j_valid (:obj: `torch.Tensor`): uint8 tensor of size M containi

Transformer blocks with support of window attention and residual propagation blocks

Bottleneck transformation: 1x1, 3x3 [+SE], 1x1.

The linear box-to-box transform defined in FCOS. The transformation is parameterized by the distance from the center of (square) src box to 4

Enum of different ways to represent a box.

Modified version of COCOeval for evaluating AP with a custom maxDets (by default for COCO, maxDets is 100)

Accumulates annotations by batches that correspond to objects detected on individual images. Can pack them together into single tensors.

Combines data loaders using the provided sampling ratios

Print **common** metrics to the terminal, including iteration time, ETA, memory, all losses, and the learning rate. It also applies smoot

Accumulates annotations by batches that correspond to objects detected on individual images. Can pack them together into single tensors.

Implement domain-specific BatchNorm by cycling. When a BatchNorm layer is used for multiple input domains or input features, it might ne