def __init__(
        self,
        img_size: int = 1024,
        *,
        patch_size: int = 16,
        in_chans: int = 3,
        embed_dim: int = 768,
        depth: int = 12,
        num_heads: int = 12,
        mlp_ratio: float = 4.0,
        out_chans: int = 256,
        qkv_bias: bool = True,
        norm_layer: type[Module] = nn.LayerNorm,
        act_layer: type[Module] = nn.GELU,
        use_abs_pos: bool = True,
        use_rel_pos: bool = False,
        rel_pos_zero_init: bool = True,
        window_size: int = 0,
        global_attn_indexes: tuple[int, ...] = (),
    ) -> None:
        """Construct Image Encoder ViT.

        Args:
        img_size: Input image size.
        patch_size: Patch size.
        in_chans: Number of input image channels.
        embed_dim: Patch embedding dimension.
        depth: Depth of ViT.
        num_heads: Number of attention heads in each ViT block.
        mlp_ratio: Ratio of mlp hidden dim to embedding dim.
        out_chans: Number of output channels.
        qkv_bias: If True, add a learnable bias to query, key, value.
        norm_layer: Normalization layer.
        act_layer: Activation layer.
        use_abs_pos: If True, use absolute positional embeddings.
        use_rel_pos: If True, add relative positional embeddings to the attention map.
        rel_pos_zero_init: If True, zero initialize relative positional parameters.
        window_size: Window size for window attention blocks.
        global_attn_indexes: Indexes for blocks using global attention.

        """
        super().__init__()
        self.img_size = img_size

        self.patch_embed = PatchEmbed(
            kernel_size=(patch_size, patch_size),
            stride=(patch_size, patch_size),
            in_chans=in_chans,
            embed_dim=embed_dim,
        )

        self.pos_embed: Optional[nn.Parameter] = None
        if use_abs_pos:
            # Initialize absolute positional embedding with pretrain image size.
            self.pos_embed = nn.Parameter(zeros(1, img_size // patch_size, img_size // patch_size, embed_dim))

        self.blocks = nn.ModuleList()
        for i in range(depth):
            block = Block(
                dim=embed_dim,
                num_heads=num_heads,
                mlp_ratio=mlp_ratio,
                qkv_bias=qkv_bias,
                norm_layer=norm_layer,
                act_layer=act_layer,
                use_rel_pos=use_rel_pos,
                rel_pos_zero_init=rel_pos_zero_init,
                window_size=window_size if i not in global_attn_indexes else 0,
                input_size=(img_size // patch_size, img_size // patch_size),
            )
            self.blocks.append(block)

        self.neck = nn.Sequential(
            nn.Conv2d(embed_dim, out_chans, kernel_size=1, bias=False),
            LayerNorm2d(out_chans),
            nn.Conv2d(out_chans, out_chans, kernel_size=3, padding=1, bias=False),
            LayerNorm2d(out_chans),
        )
Construct Image Encoder ViT.

        Args:
        img_size: Input image size.
        patch_size: Patch size.
        in_chans: Number of input image channels.
        embed_dim: Patch embedding dimension.
        depth: Depth of ViT.
        num_heads: Number of attention heads in each ViT block.
        mlp_ratio: Ratio of mlp hidden dim to embedding dim.
        out_chans: Number of output channels.
        qkv_bias: If True, add a learnable bias to query, key, value.
        norm_layer: Normalization layer.
        act_layer: Activation layer.
        use_abs_pos: If True, use absolute positional embeddings.
        use_rel_pos: If True, add relative positional embeddings to the attention map.
        rel_pos_zero_init: If True, zero initialize relative positional parameters.
        window_size: Window size for window attention blocks.
        global_attn_indexes: Indexes for blocks using global attention.

        
kornia/contrib/models/sam/architecture/image_encoder.py