Gather-and-Expansion Layer. Args: in_channels (int): Number of input channels. out_channels (int): Number of output channels.

Image to Patch Embedding

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

Vision Transformer

Attention Refinement Module (ARM) to refine the features of each stage. Args: in_channels (int): The number of input channels. ou

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

Downsampling module for CGNet.

Track a series of values and provide access to smoothed values over a window or the global series average.

Bilateral Guided Aggregation Layer to fuse the complementary information from both Detail Branch and Semantic Branch. Args: out_chann

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

Context Embedding Block for large receptive filed in Semantic Branch. Args: in_channels (int): Number of input channels. Defa

Context Path to provide sufficient receptive field. Args: backbone_cfg:(dict): Config of backbone of Context Path. co

Detail Branch with wide channels and shallow layers to capture low-level details and generate high-resolution feature representation. Args:

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

An implementation of Efficient Multi-head Attention of Segformer. This module is modified from MultiheadAttention which is a module from mmcv

Feature Fusion Module to fuse low level output feature of Spatial Path and high level output feature of Context Path. Args: in_channe

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

An implementation of MixFFN of Segformer. The differences between MixFFN & FFN: 1. Use 1X1 Conv to replace Linear layer. 2. Intro

Image to Patch Embedding

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

Semantic Branch which is lightweight with narrow channels and deep layers to obtain　high-level semantic context. Args: semantic_chann

Shifted Window Multihead Self-Attention Module. Args: embed_dims (int): Number of input channels. num_heads (int): Number of atte

Spatial Path to preserve the spatial size of the original input image and encode affluent spatial information. Args: in_channels(int)

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

Stem Block at the beginning of Semantic Branch. Args: in_channels (int): Number of input channels. Default: 3. out_ch

Args: embed_dims (int): The feature dimension. num_heads (int): Parallel attention heads. feedforward_channels (int): The

Implements one stage in Swin Transformer. Args: embed_dims (int): The feature dimension. num_heads (int): Parallel attention head

Implements one encoder layer in Segformer. Args: embed_dims (int): The feature dimension. num_heads (int): Parallel attention hea

Implements one encoder layer in Vision Transformer. Args: embed_dims (int): The feature dimension. num_heads (int): Parallel atte

Window based multi-head self-attention (W-MSA) module with relative position bias. Args: embed_dims (int): Number of input channels.

Basic block for ResNet.

BiSeNetV1 backbone. This backbone is the implementation of `BiSeNet: Bilateral Segmentation Network for Real-time Semantic Segmentation <

BiSeNetV2: Bilateral Network with Guided Aggregation for Real-time Semantic Segmentation. This backbone is the implementation of `BiSeNet

Bottleneck block for ResNeSt. Args: inplane (int): Input planes of this block. planes (int): Middle planes of this block.

Bottleneck block for ResNeXt. If style is "pytorch", the stride-two layer is the 3x3 conv layer, if it is "caffe", the stride-two layer is th

Bottleneck block for ResNet. If style is "pytorch", the stride-two layer is the 3x3 conv layer, if it is "caffe", the stride-two layer is the

CGNet backbone. This backbone is the implementation of `A Light-weight Context Guided Network for Semantic Segmentation <https://arxiv.org/ab

Deconvolution upsample module in decoder for UNet (2X upsample). This module uses deconvolution to upsample feature map in the decoder of UNe

Fast-SCNN Backbone. This backbone is the implementation of `Fast-SCNN: Fast Semantic Segmentation Network <https://arxiv.org/abs/1902.04502>`

Apply Gaussian Blur to the PIL image.

HRNet backbone. This backbone is the implementation of `High-Resolution Representations for Labeling Pixels and Regions <https://arxiv.org/ab

Interpolation upsample module in decoder for UNet. This module uses interpolation to upsample feature map in the decoder of UNet. It consists

Almost copy-paste from https://github.com/facebookresearch/barlowtwins/blob/main/main.py

The backbone of Segformer. This backbone is the implementation of `SegFormer: Simple and Efficient Design for Semantic Segmentation with

MobileNetV2 backbone. This backbone is the implementation of `MobileNetV2: Inverted Residuals and Linear Bottlenecks <https://arxiv.org/a

MobileNetV3 backbone. This backbone is the improved implementation of `Searching for MobileNetV3 <https://ieeexplore.ieee.org/document/900883

Perform forward pass separately on each resolution input. The inputs corresponding to a single resolution are clubbed and single forward

Class to compute and apply PCA.

ResNeSt backbone. This backbone is the implementation of `ResNeSt: Split-Attention Networks <https://arxiv.org/abs/2004.08955>`_. Args:

ResNeXt backbone. This backbone is the implementation of `Aggregated Residual Transformations for Deep Neural Networks <https://arxiv.org

ResNet backbone. This backbone is the improved implementation of `Deep Residual Learning for Image Recognition <https://arxiv.org/abs/1512.03

ResNetV1c variant described in [1]_. Compared with default ResNet(ResNetV1b), ResNetV1c replaces the 7x7 conv in the input stem with three 3x

ResNetV1d variant described in [1]_. Compared with default ResNet(ResNetV1b), ResNetV1d replaces the 7x7 conv in the input stem with three 3x

Based on timm and DeiT code bases https://github.com/rwightman/pytorch-image-models/tree/master/timm https://github.com/facebookresearch/

Vision Transformer. This backbone is the implementation of `An Image is Worth 16x16 Words: Transformers for Image Recognition at Scale <h

Apply Solarization to the PIL image.

Swin Transformer backbone. This backbone is the implementation of `Swin Transformer: Hierarchical Vision Transformer using Shifted Window

UNet backbone. This backbone is the implementation of `U-Net: Convolutional Networks for Biomedical Image Segmentation <https://arxiv.org/abs