Reference for ultralytics/models/sam/modules/tiny_encoder.py

def __init__(
    self,
    a: int,
    b: int,
    ks: int = 1,
    stride: int = 1,
    pad: int = 0,
    dilation: int = 1,
    groups: int = 1,
    bn_weight_init: float = 1,
):
    """
    Initialize a sequential container with 2D convolution followed by batch normalization.

    Args:
        a (int): Number of input channels.
        b (int): Number of output channels.
        ks (int, optional): Kernel size for the convolution.
        stride (int, optional): Stride for the convolution.
        pad (int, optional): Padding for the convolution.
        dilation (int, optional): Dilation factor for the convolution.
        groups (int, optional): Number of groups for the convolution.
        bn_weight_init (float, optional): Initial value for batch normalization weight.
    """
    super().__init__()
    self.add_module("c", torch.nn.Conv2d(a, b, ks, stride, pad, dilation, groups, bias=False))
    bn = torch.nn.BatchNorm2d(b)
    torch.nn.init.constant_(bn.weight, bn_weight_init)
    torch.nn.init.constant_(bn.bias, 0)
    self.add_module("bn", bn)

def __init__(self, in_chans: int, embed_dim: int, resolution: int, activation):
    """
    Initialize patch embedding with convolutional layers for image-to-patch conversion and projection.

    Args:
        in_chans (int): Number of input channels.
        embed_dim (int): Dimension of the embedding.
        resolution (int): Input image resolution.
        activation (nn.Module): Activation function to use between convolutions.
    """
    super().__init__()
    img_size: Tuple[int, int] = to_2tuple(resolution)
    self.patches_resolution = (img_size[0] // 4, img_size[1] // 4)
    self.num_patches = self.patches_resolution[0] * self.patches_resolution[1]
    self.in_chans = in_chans
    self.embed_dim = embed_dim
    n = embed_dim
    self.seq = nn.Sequential(
        Conv2d_BN(in_chans, n // 2, 3, 2, 1),
        activation(),
        Conv2d_BN(n // 2, n, 3, 2, 1),
    )

def __init__(self, in_chans: int, out_chans: int, expand_ratio: float, activation, drop_path: float):
    """
    Initialize the MBConv layer with specified input/output channels, expansion ratio, and activation.

    Args:
        in_chans (int): Number of input channels.
        out_chans (int): Number of output channels.
        expand_ratio (float): Channel expansion ratio for the hidden layer.
        activation (nn.Module): Activation function to use.
        drop_path (float): Drop path rate for stochastic depth.
    """
    super().__init__()
    self.in_chans = in_chans
    self.hidden_chans = int(in_chans * expand_ratio)
    self.out_chans = out_chans

    self.conv1 = Conv2d_BN(in_chans, self.hidden_chans, ks=1)
    self.act1 = activation()

    self.conv2 = Conv2d_BN(self.hidden_chans, self.hidden_chans, ks=3, stride=1, pad=1, groups=self.hidden_chans)
    self.act2 = activation()

    self.conv3 = Conv2d_BN(self.hidden_chans, out_chans, ks=1, bn_weight_init=0.0)
    self.act3 = activation()

    # NOTE: `DropPath` is needed only for training.
    # self.drop_path = DropPath(drop_path) if drop_path > 0. else nn.Identity()
    self.drop_path = nn.Identity()

def __init__(self, input_resolution: Tuple[int, int], dim: int, out_dim: int, activation):
    """
    Initialize the PatchMerging module for merging and projecting neighboring patches in feature maps.

    Args:
        input_resolution (Tuple[int, int]): The input resolution (height, width) of the feature map.
        dim (int): The input dimension of the feature map.
        out_dim (int): The output dimension after merging and projection.
        activation (nn.Module): The activation function used between convolutions.
    """
    super().__init__()

    self.input_resolution = input_resolution
    self.dim = dim
    self.out_dim = out_dim
    self.act = activation()
    self.conv1 = Conv2d_BN(dim, out_dim, 1, 1, 0)
    stride_c = 1 if out_dim in {320, 448, 576} else 2
    self.conv2 = Conv2d_BN(out_dim, out_dim, 3, stride_c, 1, groups=out_dim)
    self.conv3 = Conv2d_BN(out_dim, out_dim, 1, 1, 0)

def __init__(
    self,
    dim: int,
    input_resolution: Tuple[int, int],
    depth: int,
    activation,
    drop_path: Union[float, List[float]] = 0.0,
    downsample: Optional[nn.Module] = None,
    use_checkpoint: bool = False,
    out_dim: Optional[int] = None,
    conv_expand_ratio: float = 4.0,
):
    """
    Initialize the ConvLayer with the given dimensions and settings.

    This layer consists of multiple MobileNetV3-style inverted bottleneck convolutions (MBConv) and
    optionally applies downsampling to the output.

    Args:
        dim (int): The dimensionality of the input and output.
        input_resolution (Tuple[int, int]): The resolution of the input image.
        depth (int): The number of MBConv layers in the block.
        activation (nn.Module): Activation function applied after each convolution.
        drop_path (float | List[float], optional): Drop path rate. Single float or a list of floats for each MBConv.
        downsample (Optional[nn.Module], optional): Function for downsampling the output. None to skip downsampling.
        use_checkpoint (bool, optional): Whether to use gradient checkpointing to save memory.
        out_dim (Optional[int], optional): The dimensionality of the output. None means it will be the same as `dim`.
        conv_expand_ratio (float, optional): Expansion ratio for the MBConv layers.
    """
    super().__init__()
    self.dim = dim
    self.input_resolution = input_resolution
    self.depth = depth
    self.use_checkpoint = use_checkpoint

    # Build blocks
    self.blocks = nn.ModuleList(
        [
            MBConv(
                dim,
                dim,
                conv_expand_ratio,
                activation,
                drop_path[i] if isinstance(drop_path, list) else drop_path,
            )
            for i in range(depth)
        ]
    )

    # Patch merging layer
    self.downsample = (
        None
        if downsample is None
        else downsample(input_resolution, dim=dim, out_dim=out_dim, activation=activation)
    )

def __init__(
    self,
    in_features: int,
    hidden_features: Optional[int] = None,
    out_features: Optional[int] = None,
    activation=nn.GELU,
    drop: float = 0.0,
):
    """
    Initialize a multi-layer perceptron with configurable input, hidden, and output dimensions.

    Args:
        in_features (int): Number of input features.
        hidden_features (Optional[int], optional): Number of hidden features.
        out_features (Optional[int], optional): Number of output features.
        activation (nn.Module): Activation function applied after the first fully-connected layer.
        drop (float, optional): Dropout probability.
    """
    super().__init__()
    out_features = out_features or in_features
    hidden_features = hidden_features or in_features
    self.norm = nn.LayerNorm(in_features)
    self.fc1 = nn.Linear(in_features, hidden_features)
    self.fc2 = nn.Linear(hidden_features, out_features)
    self.act = activation()
    self.drop = nn.Dropout(drop)

def __init__(
    self,
    dim: int,
    key_dim: int,
    num_heads: int = 8,
    attn_ratio: float = 4,
    resolution: Tuple[int, int] = (14, 14),
):
    """
    Initialize the Attention module for multi-head attention with spatial awareness.

    This module implements a multi-head attention mechanism with support for spatial awareness, applying
    attention biases based on spatial resolution. It includes trainable attention biases for each unique
    offset between spatial positions in the resolution grid.

    Args:
        dim (int): The dimensionality of the input and output.
        key_dim (int): The dimensionality of the keys and queries.
        num_heads (int, optional): Number of attention heads.
        attn_ratio (float, optional): Attention ratio, affecting the dimensions of the value vectors.
        resolution (Tuple[int, int], optional): Spatial resolution of the input feature map.
    """
    super().__init__()

    assert isinstance(resolution, tuple) and len(resolution) == 2, "'resolution' argument not tuple of length 2"
    self.num_heads = num_heads
    self.scale = key_dim**-0.5
    self.key_dim = key_dim
    self.nh_kd = nh_kd = key_dim * num_heads
    self.d = int(attn_ratio * key_dim)
    self.dh = int(attn_ratio * key_dim) * num_heads
    self.attn_ratio = attn_ratio
    h = self.dh + nh_kd * 2

    self.norm = nn.LayerNorm(dim)
    self.qkv = nn.Linear(dim, h)
    self.proj = nn.Linear(self.dh, dim)

    points = list(itertools.product(range(resolution[0]), range(resolution[1])))
    N = len(points)
    attention_offsets = {}
    idxs = []
    for p1 in points:
        for p2 in points:
            offset = (abs(p1[0] - p2[0]), abs(p1[1] - p2[1]))
            if offset not in attention_offsets:
                attention_offsets[offset] = len(attention_offsets)
            idxs.append(attention_offsets[offset])
    self.attention_biases = torch.nn.Parameter(torch.zeros(num_heads, len(attention_offsets)))
    self.register_buffer("attention_bias_idxs", torch.LongTensor(idxs).view(N, N), persistent=False)

def __init__(
    self,
    dim: int,
    input_resolution: Tuple[int, int],
    num_heads: int,
    window_size: int = 7,
    mlp_ratio: float = 4.0,
    drop: float = 0.0,
    drop_path: float = 0.0,
    local_conv_size: int = 3,
    activation=nn.GELU,
):
    """
    Initialize a TinyViT block with self-attention and local convolution.

    This block is a key component of the TinyViT architecture, combining self-attention mechanisms with
    local convolutions to process input features efficiently.

    Args:
        dim (int): Dimensionality of the input and output features.
        input_resolution (Tuple[int, int]): Spatial resolution of the input feature map (height, width).
        num_heads (int): Number of attention heads.
        window_size (int, optional): Size of the attention window. Must be greater than 0.
        mlp_ratio (float, optional): Ratio of MLP hidden dimension to embedding dimension.
        drop (float, optional): Dropout rate.
        drop_path (float, optional): Stochastic depth rate.
        local_conv_size (int, optional): Kernel size of the local convolution.
        activation (nn.Module): Activation function for MLP.
    """
    super().__init__()
    self.dim = dim
    self.input_resolution = input_resolution
    self.num_heads = num_heads
    assert window_size > 0, "window_size must be greater than 0"
    self.window_size = window_size
    self.mlp_ratio = mlp_ratio

    # NOTE: `DropPath` is needed only for training.
    # self.drop_path = DropPath(drop_path) if drop_path > 0. else nn.Identity()
    self.drop_path = nn.Identity()

    assert dim % num_heads == 0, "dim must be divisible by num_heads"
    head_dim = dim // num_heads

    window_resolution = (window_size, window_size)
    self.attn = Attention(dim, head_dim, num_heads, attn_ratio=1, resolution=window_resolution)

    mlp_hidden_dim = int(dim * mlp_ratio)
    mlp_activation = activation
    self.mlp = MLP(in_features=dim, hidden_features=mlp_hidden_dim, activation=mlp_activation, drop=drop)

    pad = local_conv_size // 2
    self.local_conv = Conv2d_BN(dim, dim, ks=local_conv_size, stride=1, pad=pad, groups=dim)

def __init__(
    self,
    dim: int,
    input_resolution: Tuple[int, int],
    depth: int,
    num_heads: int,
    window_size: int,
    mlp_ratio: float = 4.0,
    drop: float = 0.0,
    drop_path: Union[float, List[float]] = 0.0,
    downsample: Optional[nn.Module] = None,
    use_checkpoint: bool = False,
    local_conv_size: int = 3,
    activation=nn.GELU,
    out_dim: Optional[int] = None,
):
    """
    Initialize a BasicLayer in the TinyViT architecture.

    This layer consists of multiple TinyViT blocks and an optional downsampling operation. It is designed to
    process feature maps at a specific resolution and dimensionality within the TinyViT model.

    Args:
        dim (int): Dimensionality of the input and output features.
        input_resolution (Tuple[int, int]): Spatial resolution of the input feature map (height, width).
        depth (int): Number of TinyViT blocks in this layer.
        num_heads (int): Number of attention heads in each TinyViT block.
        window_size (int): Size of the local window for attention computation.
        mlp_ratio (float, optional): Ratio of MLP hidden dimension to embedding dimension.
        drop (float, optional): Dropout rate.
        drop_path (float | List[float], optional): Stochastic depth rate. Can be a float or a list of floats for each block.
        downsample (nn.Module | None, optional): Downsampling layer at the end of the layer. None to skip downsampling.
        use_checkpoint (bool, optional): Whether to use gradient checkpointing to save memory.
        local_conv_size (int, optional): Kernel size for the local convolution in each TinyViT block.
        activation (nn.Module): Activation function used in the MLP.
        out_dim (int | None, optional): Output dimension after downsampling. None means it will be the same as `dim`.
    """
    super().__init__()
    self.dim = dim
    self.input_resolution = input_resolution
    self.depth = depth
    self.use_checkpoint = use_checkpoint

    # Build blocks
    self.blocks = nn.ModuleList(
        [
            TinyViTBlock(
                dim=dim,
                input_resolution=input_resolution,
                num_heads=num_heads,
                window_size=window_size,
                mlp_ratio=mlp_ratio,
                drop=drop,
                drop_path=drop_path[i] if isinstance(drop_path, list) else drop_path,
                local_conv_size=local_conv_size,
                activation=activation,
            )
            for i in range(depth)
        ]
    )

    # Patch merging layer
    self.downsample = (
        None
        if downsample is None
        else downsample(input_resolution, dim=dim, out_dim=out_dim, activation=activation)
    )

def __init__(
    self,
    img_size: int = 224,
    in_chans: int = 3,
    num_classes: int = 1000,
    embed_dims: Tuple[int, int, int, int] = (96, 192, 384, 768),
    depths: Tuple[int, int, int, int] = (2, 2, 6, 2),
    num_heads: Tuple[int, int, int, int] = (3, 6, 12, 24),
    window_sizes: Tuple[int, int, int, int] = (7, 7, 14, 7),
    mlp_ratio: float = 4.0,
    drop_rate: float = 0.0,
    drop_path_rate: float = 0.1,
    use_checkpoint: bool = False,
    mbconv_expand_ratio: float = 4.0,
    local_conv_size: int = 3,
    layer_lr_decay: float = 1.0,
):
    """
    Initialize the TinyViT model.

    This constructor sets up the TinyViT architecture, including patch embedding, multiple layers of
    attention and convolution blocks, and a classification head.

    Args:
        img_size (int, optional): Size of the input image.
        in_chans (int, optional): Number of input channels.
        num_classes (int, optional): Number of classes for classification.
        embed_dims (Tuple[int, int, int, int], optional): Embedding dimensions for each stage.
        depths (Tuple[int, int, int, int], optional): Number of blocks in each stage.
        num_heads (Tuple[int, int, int, int], optional): Number of attention heads in each stage.
        window_sizes (Tuple[int, int, int, int], optional): Window sizes for each stage.
        mlp_ratio (float, optional): Ratio of MLP hidden dim to embedding dim.
        drop_rate (float, optional): Dropout rate.
        drop_path_rate (float, optional): Stochastic depth rate.
        use_checkpoint (bool, optional): Whether to use checkpointing to save memory.
        mbconv_expand_ratio (float, optional): Expansion ratio for MBConv layer.
        local_conv_size (int, optional): Kernel size for local convolutions.
        layer_lr_decay (float, optional): Layer-wise learning rate decay factor.
    """
    super().__init__()
    self.img_size = img_size
    self.num_classes = num_classes
    self.depths = depths
    self.num_layers = len(depths)
    self.mlp_ratio = mlp_ratio

    activation = nn.GELU

    self.patch_embed = PatchEmbed(
        in_chans=in_chans, embed_dim=embed_dims[0], resolution=img_size, activation=activation
    )

    patches_resolution = self.patch_embed.patches_resolution
    self.patches_resolution = patches_resolution

    # Stochastic depth
    dpr = [x.item() for x in torch.linspace(0, drop_path_rate, sum(depths))]  # stochastic depth decay rule

    # Build layers
    self.layers = nn.ModuleList()
    for i_layer in range(self.num_layers):
        kwargs = dict(
            dim=embed_dims[i_layer],
            input_resolution=(
                patches_resolution[0] // (2 ** (i_layer - 1 if i_layer == 3 else i_layer)),
                patches_resolution[1] // (2 ** (i_layer - 1 if i_layer == 3 else i_layer)),
            ),
            #   input_resolution=(patches_resolution[0] // (2 ** i_layer),
            #                     patches_resolution[1] // (2 ** i_layer)),
            depth=depths[i_layer],
            drop_path=dpr[sum(depths[:i_layer]) : sum(depths[: i_layer + 1])],
            downsample=PatchMerging if (i_layer < self.num_layers - 1) else None,
            use_checkpoint=use_checkpoint,
            out_dim=embed_dims[min(i_layer + 1, len(embed_dims) - 1)],
            activation=activation,
        )
        if i_layer == 0:
            layer = ConvLayer(conv_expand_ratio=mbconv_expand_ratio, **kwargs)
        else:
            layer = BasicLayer(
                num_heads=num_heads[i_layer],
                window_size=window_sizes[i_layer],
                mlp_ratio=self.mlp_ratio,
                drop=drop_rate,
                local_conv_size=local_conv_size,
                **kwargs,
            )
        self.layers.append(layer)

    # Classifier head
    self.norm_head = nn.LayerNorm(embed_dims[-1])
    self.head = nn.Linear(embed_dims[-1], num_classes) if num_classes > 0 else torch.nn.Identity()

    # Init weights
    self.apply(self._init_weights)
    self.set_layer_lr_decay(layer_lr_decay)
    self.neck = nn.Sequential(
        nn.Conv2d(
            embed_dims[-1],
            256,
            kernel_size=1,
            bias=False,
        ),
        LayerNorm2d(256),
        nn.Conv2d(
            256,
            256,
            kernel_size=3,
            padding=1,
            bias=False,
        ),
        LayerNorm2d(256),
    )