This class represents masks in the form of polygons. Polygons is a list of three levels. The first level of the list corresponds to objects,

This class represents masks in the form of bitmaps. Args: masks (ndarray): ndarray of masks in shape (N, H, W), where N is th

3D boxes of instances in LIDAR coordinates. Coordinates in LiDAR: .. code-block:: none up z x front (yaw=0.5

3D boxes of instances in Depth coordinates. Coordinates in Depth: .. code-block:: none up z y front (yaw=0.5*pi)

ResNet backbone. Args: depth (int): Depth of resnet, from {18, 34, 50, 101, 152}. stem_channels (int | None): Number of stem chan

r"""Feature Pyramid Network. This is an implementation of paper `Feature Pyramid Networks for Object Detection <https://arxiv.org/abs/1612.03

Assign a corresponding gt bbox or background to each bbox. Each proposals will be assigned with `-1`, or a semi-positive integer indicating t

Stores assignments between predicted and truth boxes. Attributes: num_gts (int): the number of truth boxes considered when computing this

Compose multiple transforms sequentially. Args: transforms (Sequence[dict | callable]): Sequence of transform object or confi

Points of instances in LIDAR coordinates. Args: tensor (torch.Tensor | np.ndarray | list): a N x points_dim matrix. points_dim (i

BottleBlock for TridentResNet. Args: trident_dilations (tuple[int, int, int]): Dilations of different trident branch.

3D boxes of instances in CAM coordinates. Coordinates in camera: .. code-block:: none z front (yaw=0.5*pi) /

ResLayer to build ResNet style backbone for RPF in detectoRS. The difference between this module and base class is that we pass ``rfp_inplane

Epoch-based Runner. This runner train models epoch by epoch.

ResLayer to build ResNet style backbone. Args: block (nn.Module): block used to build ResLayer. inplanes (int): inplanes of block

Points of instances in DEPTH coordinates. Args: tensor (torch.Tensor | np.ndarray | list): a N x points_dim matrix. points_dim (i

Implements feed-forward networks (FFNs) with residual connection. Args: embed_dims (int): The feature dimension. Same as `Mul

Point set abstraction module with multi-scale grouping used in Pointnets. Args: num_point (int): Number of points. radii (lis

Implements one decoder layer in DETR transformer. Args: embed_dims (int): The feature dimension. Same as `TransformerEncoderL

Implements one encoder layer in DETR transformer. Args: embed_dims (int): The feature dimension. Same as `FFN`. num_heads (int):

A wrapper of concatenated dataset. Same as :obj:`torch.utils.data.dataset.ConcatDataset`, but concat the group flag for image aspect ratio.

r"""KITTI Dataset. This class serves as the API for experiments on the `KITTI Dataset <http://www.cvlibs.net/datasets/kitti/eval_object.php?o

Load Points From File. Load sunrgbd and scannet points from file. Args: load_dim (int): The dimension of the loaded points.

Absolute pos embedding, learned.

r"""SUNRGBD Dataset. This class serves as the API for experiments on the SUNRGBD Dataset. See the `download page <http://rgbd.cs.princeton.e

r"""ScanNet Dataset. This class serves as the API for experiments on the ScanNet Dataset. Please refer to the `github repo <https://github.c

Simplified version of original basic residual block. This is used in `SCNet <https://arxiv.org/abs/2012.10150>`_. - Norm layer is now optiona

Extract RoI features from all level feature maps levels. This is the implementation of `A novel Region of Interest Extraction Layer for Insta

HourglassNet backbone. Stacked Hourglass Networks for Human Pose Estimation. More details can be found in the `paper <https://arxiv.org/a

Load an image from file. Required keys are "img_prefix" and "img_info" (a dict that must contain the key "filename"). Added or updated keys a

r"""Lyft Dataset. This class serves as the API for experiments on the Lyft Dataset. Please refer to `<https://www.kaggle.com/c/3d-object

A warpper for torch.nn.MultiheadAttention. This module implements MultiheadAttention with residual connection, and positional encoding used i

Wrap the function to be tested for torch.onnx.export tracking.

Assign a corresponding gt bbox or background to each bbox. Each proposals will be assigned with an integer indicating the ground truth index

Points of instances in CAM coordinates. Args: tensor (torch.Tensor | np.ndarray | list): a N x points_dim matrix. points_dim (int

Assign pixels at the center region of a bbox as positive. Each proposals will be assigned with `-1`, `0`, or a positive integer indicating th

Load points from multiple sweeps. This is usually used for nuScenes dataset to utilize previous sweeps. Args: sweeps_num (int): Numb

PartA2 RoI head. Args: num_classes (int): The number of classes to prediction. seg_in_channels (int): Input channels of segmentat

Random sampler. Args: num (int): Number of samples pos_fraction (float): Fraction of positive samples neg_pos_up (int, op

Bbox sampling result. Example: >>> # xdoctest: +IGNORE_WANT >>> from mmdet.core.bbox.samplers.sampling_result import * # NOQA

Implements the DETR transformer. Following the official DETR implementation, this module copy-paste from torch.nn.Transformer with modificati

Implements the decoder in DETR transformer. Args: num_layers (int): The number of `TransformerDecoderLayer`. embed_dims (int): Sa

Vote module. Generate votes from seed point features. Args: in_channels (int): Number of channels of seed point features. vo

Voxel generator in numpy implementation. Args: voxel_size (list[float]): Size of a single voxel point_cloud_range (list[float]):

Simplest RoI head, with only two fc layers for classification and regression respectively.

Filter background points near the bounding box. Args: bbox_enlarge_range (tuple[float], float): Bbox enlarge range.

Base class for 3D Boxes. Note: The box is bottom centered, i.e. the relative position of origin in the box is (0.5, 0.5, 0).

Base class for Points. Args: tensor (torch.Tensor | np.ndarray | list): a N x points_dim matrix. points_dim (int): Number of the

Calculate Chamfer Distance of two sets. Args: mode (str): Criterion mode to calculate distance. The valid modes are smooth_l1

r"""Channel Mapper to reduce/increase channels of backbone features. This is used to reduce/increase channels of backbone features. Args:

A wrapper of repeated dataset with repeat factor. Suitable for training on class imbalanced datasets like LVIS. Following the sampling strate

Custom dataset for detection. The annotation format is shown as follows. The `ann` field is optional for testing. .. code-block:: none

Feature Adaption Module. Feature Adaption Module is implemented based on DCN v1. It uses anchor shape prediction rather than feature map to

Computes one-to-one matching between predictions and ground truth. This class computes an assignment between the targets and the predictions

r"""Online Hard Example Mining Sampler described in `Training Region-based Object Detectors with Online Hard Example Mining <https://arxiv.org

Assign a corresponding gt bbox or background to each point. Each proposals will be assigned with `0`, or a positive integer indicating the gr

RegNet backbone. More details can be found in `paper <https://arxiv.org/abs/2003.13678>`_ . Args: arch (dict): The parameter of RegN

A wrapper of repeated dataset. The length of repeated dataset will be `times` larger than the original dataset. This is useful when the data

r"""ResNetV1d variant described in `Bag of Tricks <https://arxiv.org/pdf/1812.01187.pdf>`_. Compared with default ResNet(ResNetV1b), ResNetV1

Position encoding with sine and cosine functions. See `End-to-End Object Detection with Transformers <https://arxiv.org/pdf/2005.12872>`_ for

Sparse basic block for PartA^2. Sparse basic block implemented with submanifold sparse convolution. Args: inplanes (int): inplanes o

Implements the encoder in DETR transformer. Args: num_layers (int): The number of `TransformerEncoderLayer`. embed_dims (int): Sa

The stem layer, stage 1 and stage 2 in Trident ResNet are identical to ResNet, while in stage 3, Trident BottleBlock is utilized to replace the

Standard anchor generator for 2D anchor-based detectors. Args: strides (list[int] | list[tuple[int, int]]): Strides of anchors

Bidirectional Corner Pooling Module (TopLeft, BottomRight, etc.) Args: in_channels (int): Input channels of module. out_channels

Head of CornerNet: Detecting Objects as Paired Keypoints. Code is modified from the `official github repo <https://github.com/princeton-vl/Co

Detection block in YOLO neck. Let out_channels = n, the DetectionBlock contains: Six ConvLayers, 1 Conv2D Layer and 1 YoloLayer. The firs

Hourglass Module for HourglassNet backbone. Generate module recursively and use BasicBlock as the base unit. Args: depth (int): Dept

Indoor point sample. Sampling data to a certain number. Args: name (str): Name of the dataset. num_points (int): Number of p

IoU Piece-wise Sampling. Sampling negtive proposals according to a list of IoU thresholds. The negtive proposals are divided into several pie

KITTI predictions to Waymo converter. This class serves as the converter to change predictions from KITTI to Waymo format. Args:

r"""Allows the model to jointly attend to information from different representation subspaces. See reference: Attention Is All You Need ..

Point feature propagation module used in PointNets. Propagate the features from one set to another. Args: mlp_channels (list[int]):

A pseudo sampler that does not do sampling actually.

Res2Net backbone. Args: scales (int): Scales used in Res2Net. Default: 4 base_width (int): Basic width of each scale. Default: 26

ResNeSt backbone. Args: groups (int): Number of groups of Bottleneck. Default: 1 base_width (int): Base width of Bottleneck. Defa

ResNeXt backbone. Args: depth (int): Depth of resnet, from {18, 34, 50, 101, 152}. in_channels (int): Number of input image chann