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 wrapper around :class:`torch.nn.Conv2d` to support empty inputs and more features.

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}

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

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

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

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

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

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.

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

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

Map a function over the elements in a dataset.

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

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

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

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

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

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

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

A simple trainer for the most common type of task: single-cost single-optimizer single-data-source iterative optimization, optionally usi

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.

We use the "DefaultTrainer" which contains pre-defined default logic for standard training workflow. They may not work for you, especially if

Evaluate AR for object proposals, AP for instance detection/segmentation, AP for keypoint detection outputs using COCO's metrics. See htt

A class that manages prompt templates and keeps all conversation history.

Create a simple end-to-end predictor with the given config that runs on single device for a single input image. Compared to using the mo

Drop paths (Stochastic Depth) per sample (when applied in main path of residual blocks).

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

Write scalars to a json file. It saves scalars as one json per line (instead of a big json) for easy parsing. Examples parsing such a j

This module is used in RetinaNet to generate extra layers, P6 and P7 from C5 feature.

Resize the image to a target size.

This module implements Feature Pyramid Network. It creates pyramid features built on top of some input feature maps.

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

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

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

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

:class:`transformers.LogitsProcessor` that enforces that when specified sequences appear, stop geration. Args: stop_words_ids (:obj:

Convert an old indices-based (also called map-style) dataset to an iterable-style dataset.

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

Compute anchors in the standard ways described in "Faster R-CNN: Towards Real-Time Object Detection with Region Proposal Networks".

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

Evaluate object proposal and instance detection/segmentation outputs using LVIS's metrics and evaluation API.

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

Transformer decoder consisting of *config.num_hidden_layers* layers. Each layer is a [`Phi3DecoderLayer`] Args: config: Phi3Config

Region Proposal Network, introduced by :paper:`Faster R-CNN`.

Implement :paper:`ResNet`.

This module implements Vision Transformer (ViT) backbone in :paper:`vitdet`. "Exploring Plain Vision Transformer Backbones for Object Detecti

Add an initial warmup stage to another scheduler.

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.

Similar to nn.ParameterList, but for buffers

Evaluate Panoptic Quality metrics on COCO using PanopticAPI. It saves panoptic segmentation prediction in `output_dir` It contains a syn

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

Make a detectron2 model traceable with Caffe2 operators. This class creates a traceable version of a detectron2 model which: 1. Rewrite

Evaluate instance segmentation results on cityscapes dataset using cityscapes API. Note: * It does not work in multi-machine distrib

Evaluate semantic segmentation results on cityscapes dataset using cityscapes API. Note: * It does not work in multi-machine distrib

A kxk depthwise convolution + a 1x1 convolution. In :paper:`xception`, norm & activation are applied on the second conv. :paper:`mobilen

Processes an answer similar to Eval AI copied from https://github.com/facebookresearch/mmf/blob/c46b3b3391275b4181567db80943473a8

Same as :class:`fvcore.nn.FlopCountAnalysis`, but supports detectron2 models.

A GeneralizedRCNN with test-time augmentation enabled. Its :meth:`__call__` method has the same interface as :meth:`GeneralizedRCNN.forward`.