A conv block that bundles conv/norm/activation layers. This block simplifies the usage of convolution layers, which are commonly used with a

A registry to map strings to classes. Registered object could be built from registry. Example: >>> MODELS = Registry('models')

Depthwise separable convolution module. See https://arxiv.org/pdf/1704.04861.pdf for details. This module can replace a ConvModule with the

Normlize image by given mean and std.

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

Feature fusion block.

Drop paths (Stochastic Depth) per sample (when applied in main path of residual blocks). Args: drop_prob (float): Drop rate for path

Feature fusion block.

A general file client to access files in different backends. The client loads a file or text in a specified backend from its path and returns

InvertedResidual block for MobileNetV2. Args: in_channels (int): The input channels of the InvertedResidual block. out_channels (

ModuleList in openmmlab. Args: modules (iterable, optional): an iterable of modules to add. init_cfg (dict, optional): Initializa

Image to Patch Embedding

Interpolation module.

Class that manages loss scaling in mixed precision training which supports both dynamic or static mode. The implementation refers to http

Pooling Pyramid Module used in PSPNet. Args: pool_scales (tuple[int]): Pooling scales used in Pooling Pyramid Module.

A progress bar which can print the progress.

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

Resize sample to given size (width, height).

A learnable scale parameter. This layer scales the input by a learnable factor. It multiplies a learnable scale parameter of shape (1,) with

Sequential module in openmmlab. Args: init_cfg (dict, optional): Initialization config dict.

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

Context Guided Block for CGNet. This class consists of four components: local feature extractor, surrounding feature extractor, joint feature

A container for any type of objects. Typically tensors will be stacked in the collate function and sliced along some dimension in the scatter

Downsampling module for CGNet.

Prepare sample for usage as network input.

Residual convolution module.

Residual convolution module.

Make a ANN used SelfAttentionBlock. Args: low_in_channels (int): Input channels of lower level feature, which is the key feat

A flexible Timer class. :Example: >>> import time >>> import annotator.uniformer.mmcv as mmcv >>> with mmcv.Timer(): >>> # s

Adaptive Context Module used in APCNet. Args: pool_scale (int): Pooling scale used in Adaptive Context Module to extract regi

Asymmetric Fusion Non-local Block(AFNB) Args: low_in_channels (int): Input channels of lower level feature, which is the key

Asymmetric Pyramid Non-local Block (APNB) Args: in_channels (int): Input channels of key/query feature, which is the key feat

Atrous Spatial Pyramid Pooling (ASPP) Module. Args: dilations (tuple[int]): Dilation rate of each layer. in_channels (int): Input

Attention layer for Encoder block. Args: dim (int): Dimension for the input vector. num_heads (int): Number of parallel attention

Basic convolutional block for UNet. This module consists of several plain convolutional layers. Args: in_channels (int): Number of i

Implements encoder block with residual connection. Args: dim (int): The feature dimension. num_heads (int): Number of parallel at

Channel Attention Module (CAM)

A facility for config and config files. It supports common file formats as configs: python/json/yaml. The interface is the same as a dict obj

ContextBlock module in GCNet. See 'GCNet: Non-local Networks Meet Squeeze-Excitation Networks and Beyond' (https://arxiv.org/abs/1904.11492)

Criss-Cross Attention Module. .. note:: Before v1.3.13, we use a CUDA op. Since v1.3.13, we switch to a pure PyTorch and equivale

Dynamic Convolutional Module used in DMNet. Args: filter_size (int): The filter size of generated convolution kernel used in

Using Euclidean distances of points for FPS.

Atrous Spatial Pyramid Pooling (ASPP) Module with depthwise separable conv.

Disentangled Non-Local Blocks. Args: temperature (float): Temperature to adjust attention. Default: 0.05

Expectation Maximization Attention Module used in EMANet. Args: channels (int): Channels of the whole module. num_bases (int): Nu

Encoding Module used in EncNet. Args: in_channels (int): Input channels. num_codes (int): Number of code words. conv_cfg

Encoding Layer: a learnable residual encoder. Input is of shape (batch_size, channels, height, width). Output is of shape (batch_size, num_c

Using feature distances for FPS.

Feature fusion module. Args: higher_in_channels (int): Number of input channels of the higher-resolution branch. lowe

Global Context Extractor for CGNet. This class is employed to refine the joint feature of both local feature and surrounding context. Ar

Global feature extractor module. Args: in_channels (int): Number of input channels of the GFE module. Default: 64 blo

High-Resolution Module for HRNet. In this module, every branch has 4 BasicBlocks/Bottlenecks. Fusion/Exchange is in this module.

Learning to downsample module. Args: in_channels (int): Number of input channels. dw_channels (tuple[int]): Number of output chan

A simple pipeline to load image.

The DataParallel module that supports DataContainer. MMDataParallel has two main differences with PyTorch DataParallel: - It supports a cust

The DDP module that supports DataContainer. MMDDP has two main differences with PyTorch DDP: - It supports a custom type :class:`DataContain

Network for monocular depth estimation.

Network for monocular depth estimation.

MLP layer for Encoder block. Args: in_features(int): Input dimension for the first fully connected layer. hidden_feat

2D Non-local module. Args: in_channels (int): Same as `NonLocalND`. sub_sample (bool): Whether to apply max pooling after pairwis

Make a OCR used SelfAttentionBlock.

Position Attention Module (PAM) Args: in_channels (int): Input channels of key/query feature. channels (int): Output channels of

Pyramid Pooling Module that only concat the features of each layer. Args: pool_scales (tuple[int]): Pooling scales used in Pooling Pyrami

Image to Patch Embedding. Args: img_size (int | tuple): Input image size. default: 224. patch_size (int): Width and h

Hook priority levels. +--------------+------------+ | Level | Value | +==============+============+ | HIGHEST | 0

Radix Softmax module in ``SplitAttentionConv2d``. Args: radix (int): Radix of input. groups (int): Groups of input.

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

Squeeze-and-Excitation Module. Args: channels (int): The input (and output) channels of the SE layer. ratio (int): Squeeze ratio

Aggregate the context features according to the initial predicted probability distribution. Employ the soft-weighted method to aggregate the

Split-Attention Conv2d in ResNeSt. Args: in_channels (int): Same as nn.Conv2d. out_channels (int): Same as nn.Conv2d. ker