data/Models/Transformer/mdvit.py

'''
UNet architecture: Factorized attention Transformer encoder, CNN decoder
Encoder is from MPViT
'''

import math
from pyexpat import features
import torch
from torch import nn, einsum
from einops import rearrange
import sys
from typing import Tuple
from functools import partial
import numpy as np
from timm.models.layers import DropPath, trunc_normal_

sys.path.append('/ubc/ece/home/ra/grads/siyi/Research/skin_lesion_segmentation/MDViT/')

from Models.Transformer.mpvit import FactorAtt_ConvRelPosEnc, ConvRelPosEnc, ConvPosEnc, Mlp, Conv2d_BN
from Models.Decoders import UnetDecodingBlockTransformer, MLPDecoder, DeepLabV3Decoder, MLPDecoderFM, UnetDecodingBlockTransformer_M


class Conv2d_BN_M(nn.Module):
    """Convolution with BN module.
    M means using domain-specific norm"""
    def __init__(
        self,
        in_ch,
        out_ch,
        kernel_size=1,
        stride=1,
        pad=0,
        dilation=1,
        groups=1,
        bn_weight_init=1,
        norm_layer=nn.BatchNorm2d,
        act_layer=None,
        num_domains=1,
    ):
        super().__init__()

        self.conv = torch.nn.Conv2d(in_ch,
                                    out_ch,
                                    kernel_size,
                                    stride,
                                    pad,
                                    dilation,
                                    groups,
                                    bias=False)
        self.bns = nn.ModuleList([norm_layer(out_ch) for _ in range(num_domains)])
        for bn in self.bns:
            torch.nn.init.constant_(bn.weight, bn_weight_init)
            torch.nn.init.constant_(bn.bias, 0)
        for m in self.modules():
            if isinstance(m, nn.Conv2d):
                # Note that there is no bias due to BN
                fan_out = m.kernel_size[0] * m.kernel_size[1] * m.out_channels
                m.weight.data.normal_(mean=0.0, std=np.sqrt(2.0 / fan_out))

        self.act_layer = act_layer() if act_layer is not None else nn.Identity(
        )

    def forward(self, x, d='0'):
        """foward function"""
        d = int(d)
        x = self.conv(x)
        x = self.bns[d](x)
        x = self.act_layer(x)

        return x



class DWConv2d_BN(nn.Module):
    """Depthwise Separable Convolution with BN module.
    Modify on MPViT DWConv2d_BN, this is for input output are different channel dim"""
    def __init__(
        self,
        in_ch,
        out_ch,
        kernel_size=1,
        stride=1,
        norm_layer=nn.BatchNorm2d,
        act_layer=nn.Hardswish,
        bn_weight_init=1,
    ):
        super().__init__()

        # dw
        self.dwconv = nn.Conv2d(
            in_ch,
            in_ch,
            kernel_size,
            stride,
            (kernel_size - 1) // 2,
            groups=in_ch,
            bias=False,
        )
        # pw-linear
        self.pwconv = nn.Conv2d(in_ch, out_ch, 1, 1, 0, bias=False)
        self.bn = norm_layer(out_ch)
        self.act = act_layer() if act_layer is not None else nn.Identity()

        for m in self.modules():
            if isinstance(m, nn.Conv2d):
                n = m.kernel_size[0] * m.kernel_size[1] * m.out_channels
                m.weight.data.normal_(0, math.sqrt(2.0 / n))
                if m.bias is not None:
                    m.bias.data.zero_()
            elif isinstance(m, nn.BatchNorm2d):
                m.weight.data.fill_(bn_weight_init)
                m.bias.data.zero_()

    def forward(self, x):
        """
        foward function
        """
        x = self.dwconv(x)
        x = self.pwconv(x)
        x = self.bn(x)
        x = self.act(x)

        return x



class DWConv2d_BN_M(nn.Module):
    """Depthwise Separable Convolution with BN module.
    Modify on MPViT DWConv2d_BN, this is for input output are different channel dim
    M means using domain-specific norm"""
    def __init__(
        self,
        in_ch,
        out_ch,
        kernel_size=1,
        stride=1,
        norm_layer=nn.BatchNorm2d,
        act_layer=nn.Hardswish,
        bn_weight_init=1,
        num_domains = 1,
    ):
        super().__init__()

        # dw
        self.dwconv = nn.Conv2d(
            in_ch,
            in_ch,
            kernel_size,
            stride,
            (kernel_size - 1) // 2,
            groups=in_ch,
            bias=False,
        )
        # pw-linear
        self.pwconv = nn.Conv2d(in_ch, out_ch, 1, 1, 0, bias=False)
        self.bns = nn.ModuleList([norm_layer(out_ch) for _ in range(num_domains)])
        self.act = act_layer() if act_layer is not None else nn.Identity()

        for m in self.modules():
            if isinstance(m, nn.Conv2d):
                n = m.kernel_size[0] * m.kernel_size[1] * m.out_channels
                m.weight.data.normal_(0, math.sqrt(2.0 / n))
                if m.bias is not None:
                    m.bias.data.zero_()
            elif isinstance(m, nn.BatchNorm2d):
                m.weight.data.fill_(bn_weight_init)
                m.bias.data.zero_()

    def forward(self, x, d=None):
        """
        foward function
        """
        d = int(d)
        x = self.dwconv(x)
        x = self.pwconv(x)
        x = self.bns[d](x)
        x = self.act(x)

        return x



class DWCPatchEmbed(nn.Module):
    """Depthwise Convolutional Patch Embedding layer Image to Patch
    Embedding. The same as the module in MPViT"""
    def __init__(self,
                 in_chans=3,
                 embed_dim=768,
                 patch_size=16,
                 stride=1,
                 conv_norm=nn.BatchNorm2d,
                 act_layer=nn.Hardswish,):
        super().__init__()

        self.patch_conv = DWConv2d_BN(
            in_chans,
            embed_dim,
            kernel_size=patch_size,
            stride=stride,
            norm_layer=conv_norm,
            act_layer=act_layer,
        )

    def forward(self, x):
        """foward function"""
        x = self.patch_conv(x)

        return x



class DWCPatchEmbed_M(nn.Module):
    """Depthwise Convolutional Patch Embedding layer Image to Patch
    Embedding. The same as the module in MPViT
    M means using domain-specific norm"""
    def __init__(self,
                 in_chans=3,
                 embed_dim=768,
                 patch_size=16,
                 stride=1,
                 conv_norm=nn.BatchNorm2d,
                 act_layer=nn.Hardswish,
                 num_domains=1):
        super().__init__()

        self.patch_conv = DWConv2d_BN_M(
            in_chans,
            embed_dim,
            kernel_size=patch_size,
            stride=stride,
            norm_layer=conv_norm,
            act_layer=act_layer,
            num_domains=num_domains,
        )

    def forward(self, x, d=None):
        """foward function"""
        x = self.patch_conv(x, d)

        return x


class FactorAtt_ConvRelPosEnc_Sup(nn.Module):
    """Factorized attention with convolutional relative position encoding class.
    Modified for domain attention. Follow Selective kernel. Add domain label 
    r: ratio, max(4,n//r) is the hidden size for the fc layer in domain attention
    """
    def __init__(
        self,
        seq_length,
        dim,
        num_heads=8,
        qkv_bias=False,
        qk_scale=None,
        attn_drop=0.0,
        proj_drop=0.0,
        shared_crpe=None,
        r=2,
        num_domains=4,
    ):
        super().__init__()
        self.num_heads = num_heads
        head_dim = dim // num_heads
        self.scale = qk_scale or head_dim**-0.5
        hidden_dim = max(dim//r,4)

        self.qkv = nn.Linear(dim, dim * 3, bias=qkv_bias)
        self.attn_drop = nn.Dropout(attn_drop)
        self.proj = nn.Linear(dim, dim)
        self.proj_drop = nn.Dropout(proj_drop)

        self.domain_layer = nn.Sequential(
            nn.Linear(num_domains, hidden_dim),
            nn.ReLU(inplace=True),
            nn.Linear(hidden_dim,self.num_heads*head_dim),
        )

        # Shared convolutional relative position encoding.
        self.crpe = shared_crpe

    def forward(self, x, size, domain_label):
        """foward function
        domain_label is one_hot vector
        """
        B, N, C = x.shape

        # Generate Q, K, V.
        qkv = (self.qkv(x).reshape(B, N, 3, self.num_heads,
                                   C // self.num_heads).permute(2, 0, 3, 1, 4)).contiguous()
        q, k, v = qkv[0], qkv[1], qkv[2]

        # Factorized attention.  Different from COAT
        k_softmax = k.softmax(dim=2)
        k_softmax_T_dot_v = einsum("b h n k, b h n v -> b h k v", k_softmax, v)
        factor_att = einsum("b h n k, b h k v -> b h n v", q,
                            k_softmax_T_dot_v)
        crpe = self.crpe(q, v, size=size)
        factor_att = self.scale * factor_att + crpe  

        # TODO for domain attention 
        domain_att = self.domain_layer(domain_label).unsqueeze(2)  # (B,H*K,1)
        domain_att = rearrange(domain_att, 'b (h k) c -> b h c k', h=self.num_heads).contiguous()  # (b,h,1,k)
        domain_att = torch.softmax(domain_att, dim=1)   # (b,h,1,k)
        x = domain_att*factor_att   # (B,H,N,dim)

        # Reshape.
        x = x.transpose(1, 2).contiguous().reshape(B, N, C)

        # Output projection.
        x = self.proj(x)
        x = self.proj_drop(x)

        return x


class SerialBlock_adapt(nn.Module):
    """ Serial block class.
        Note: In this implementation, each serial block only contains a conv-attention and a FFN (MLP) module. 
        input: x (B,N,C), (H,W)  output: out (B,N,C)"""
    def __init__(self, seq_length, dim, num_heads, mlp_ratio=4., qkv_bias=False, qk_scale=None, drop=0., attn_drop=0.,
                 drop_path=0., act_layer=nn.GELU, norm_layer=nn.LayerNorm, shared_cpe=None, shared_crpe=None, 
                 adapt_method=None, num_domains=4):
        super().__init__()

        # Conv-Attention.
        self.cpe = shared_cpe
        self.norm1 = norm_layer(dim)
        self.adapt_method = adapt_method

        if self.adapt_method == 'Sup':
            self.factoratt_crpe = FactorAtt_ConvRelPosEnc_Sup(
                seq_length, dim, num_heads=num_heads, qkv_bias=qkv_bias, qk_scale=qk_scale, 
                attn_drop=attn_drop, proj_drop=drop, shared_crpe=shared_crpe, num_domains=num_domains,
            ) 
        else:
            self.factoratt_crpe = FactorAtt_ConvRelPosEnc(
                dim, num_heads=num_heads, qkv_bias=qkv_bias, qk_scale=qk_scale, attn_drop=attn_drop, proj_drop=drop, shared_crpe=shared_crpe)

        self.drop_path = DropPath(drop_path) if drop_path > 0. else nn.Identity()

        # MLP.
        self.norm2 = norm_layer(dim)
        mlp_hidden_dim = int(dim * mlp_ratio)
        self.mlp = Mlp(in_features=dim, hidden_features=mlp_hidden_dim, act_layer=act_layer, drop=drop)

    def forward(self, x, size: Tuple[int, int], domain_label=None):
        # Conv-Attention.
        x = self.cpe(x, size)
        cur = self.norm1(x)
        if self.adapt_method != None and domain_label != None :
            cur = self.factoratt_crpe(cur, size, domain_label)
        else:
            cur = self.factoratt_crpe(cur, size)
        x = x + self.drop_path(cur) 

        # MLP. 
        cur = self.norm2(x)
        cur = self.mlp(cur)
        x = x + self.drop_path(cur)

        return x


class SerialBlock_adapt_M(nn.Module):
    """ Serial block class.
        Note: In this implementation, each serial block only contains a conv-attention and a FFN (MLP) module. 
        input: x (B,N,C), (H,W)  output: out (B,N,C)
        M means using domain-specific norm"""
    def __init__(self, seq_length, dim, num_heads, mlp_ratio=4., qkv_bias=False, qk_scale=None, drop=0., attn_drop=0.,
                 drop_path=0., act_layer=nn.GELU, norm_layer=nn.LayerNorm, shared_cpe=None, shared_crpe=None, 
                 adapt_method=None, num_domains=4):
        super().__init__()

        # Conv-Attention.
        self.cpe = shared_cpe
        # self.norm1 = norm_layer(dim)
        self.norm1s = nn.ModuleList([norm_layer(dim) for _ in range(num_domains)])
        self.adapt_method = adapt_method

        if self.adapt_method == 'Sup':
            self.factoratt_crpe = FactorAtt_ConvRelPosEnc_Sup(
                seq_length, dim, num_heads=num_heads, qkv_bias=qkv_bias, qk_scale=qk_scale, 
                attn_drop=attn_drop, proj_drop=drop, shared_crpe=shared_crpe, num_domains=num_domains,
            ) 
        else:
            self.factoratt_crpe = FactorAtt_ConvRelPosEnc(
                dim, num_heads=num_heads, qkv_bias=qkv_bias, qk_scale=qk_scale, attn_drop=attn_drop, proj_drop=drop, shared_crpe=shared_crpe)

        self.drop_path = DropPath(drop_path) if drop_path > 0. else nn.Identity()

        # MLP.
        self.norm2s = nn.ModuleList([norm_layer(dim) for _ in range(num_domains)])
        mlp_hidden_dim = int(dim * mlp_ratio)
        self.mlp = Mlp(in_features=dim, hidden_features=mlp_hidden_dim, act_layer=act_layer, drop=drop)

    def forward(self, x, size: Tuple[int, int], domain_label=None, d=None):
        # Conv-Attention.
        d = int(d)
        x = self.cpe(x, size)
        cur = self.norm1s[d](x)
        if self.adapt_method != None and domain_label != None :
            cur = self.factoratt_crpe(cur, size, domain_label)
        else:
            cur = self.factoratt_crpe(cur, size)
        x = x + self.drop_path(cur) 

        # MLP. 
        cur = self.norm2s[d](x)
        cur = self.mlp(cur)
        x = x + self.drop_path(cur)

        return x


class MHSA_stage_adapt(nn.Module):
    '''
    Multi-head self attention
    (B, N, C) --> (B, N, C)
    Combine several Serial blocks for a stage
    '''
    def __init__(self, seq_length, dim, num_layers, num_heads, mlp_ratio, qkv_bias=True, qk_scale=None, 
        drop_rate=0., attn_drop_rate=0., drop_path_rate=0., num_domains=4,
        norm_layer=nn.LayerNorm, adapt_method=None, crpe_window={3:2, 5:3, 7:3}):
        super(MHSA_stage_adapt, self).__init__()

        self.cpe = ConvPosEnc(dim, k=3)
        self.crpe = ConvRelPosEnc(Ch=dim//num_heads, h=num_heads, window=crpe_window)

        self.mhca_blks = nn.ModuleList(
            [SerialBlock_adapt(
                seq_length, dim, num_heads, mlp_ratio, qkv_bias, qk_scale, 
                drop_rate, attn_drop_rate, drop_path_rate,
                nn.GELU, norm_layer, self.cpe, self.crpe, adapt_method,num_domains,
            ) for _ in range(num_layers)]
        )

    def forward(self, input, H, W, domain_label=None):
        for blk in self.mhca_blks:
            input = blk(input, size=(H,W)) if domain_label==None else blk(input, (H,W), domain_label)
        return input


class MHSA_stage_adapt_M(nn.Module):
    '''
    Multi-head self attention
    (B, N, C) --> (B, N, C)
    Combine several Serial blocks for a stage
    M means using domain-specific norms
    '''
    def __init__(self, seq_length, dim, num_layers, num_heads, mlp_ratio, qkv_bias=True, qk_scale=None, 
        drop_rate=0., attn_drop_rate=0., drop_path_rate=0., num_domains=4,
        norm_layer=nn.LayerNorm, adapt_method=None, crpe_window={3:2, 5:3, 7:3}):
        super(MHSA_stage_adapt_M, self).__init__()

        self.cpe = ConvPosEnc(dim, k=3)
        self.crpe = ConvRelPosEnc(Ch=dim//num_heads, h=num_heads, window=crpe_window)

        self.mhca_blks = nn.ModuleList(
            [SerialBlock_adapt_M(
                seq_length, dim, num_heads, mlp_ratio, qkv_bias, qk_scale, 
                drop_rate, attn_drop_rate, drop_path_rate,
                nn.GELU, norm_layer, self.cpe, self.crpe, adapt_method,num_domains,
            ) for _ in range(num_layers)]
        )

    def forward(self, input, H, W, domain_label=None, d=None):
        for blk in self.mhca_blks:
            input = blk(input, size=(H,W),d=d) if domain_label==None else blk(input, (H,W), domain_label,d=d)
        return input



# 4 features into decoder
class MDViT(nn.Module):
    '''
    several decoders to do knowledge distillation
    A Conv Position encoding + Factorized attention Transformer
    use transformer encoder and decoder
    feature_dim is the 4th stage output dimension
    do_detach: ture means detach the feature from the last encoder, then pass into projection head
    Input: an image
    Output: a list contains features from each stage
    '''
    def __init__(
        self,
        img_size=512,
        in_chans=3,
        num_stages=4,
        num_layers=[2, 2, 2, 2],
        embed_dims=[64, 128, 320, 512],
        mlp_ratios=[8, 8, 4, 4],
        num_heads=[8, 8, 8, 8],
        qkv_bias=True,
        qk_scale=None,
        drop_rate=0.,
        attn_drop_rate=0.,
        drop_path_rate=0.0,
        norm_layer=partial(nn.LayerNorm, eps=1e-6),
        conv_norm=nn.BatchNorm2d,
        adapt_method=None,
        num_domains=4,
        decoder_name = 'MLPFM',
        **kwargs,
    ):
        super(MDViT, self).__init__()
        self.num_stages = num_stages
        self.decoder_name = decoder_name

        self.stem = nn.Sequential(
            Conv2d_BN(
                in_chans,
                embed_dims[0] // 2,
                kernel_size=3,
                stride=2,
                pad=1,
                act_layer=nn.Hardswish,
            ),
            Conv2d_BN(
                embed_dims[0] // 2,
                embed_dims[0],
                kernel_size=3,
                stride=2,
                pad=1,
                act_layer=nn.Hardswish,
            ),
        )

        # Patch embeddings.
        self.patch_embed_stages = nn.ModuleList([
            DWCPatchEmbed(
                in_chans=embed_dims[idx] if idx==0 else embed_dims[idx-1],
                embed_dim=embed_dims[idx],
                patch_size=3,
                stride=1 if idx==0 else 2, 
                conv_norm=conv_norm,
            ) for idx in range(self.num_stages)
        ])

        # Multi-Head Convolutional Self-Attention (MHCA)
        self.mhsa_stages = nn.ModuleList([
           MHSA_stage_adapt(
                (img_size//2**(idx+2))**2,
                embed_dims[idx],
                num_layers=num_layers[idx],
                num_heads=num_heads[idx], 
                mlp_ratio=mlp_ratios[idx], 
                qkv_bias=qkv_bias, qk_scale=qk_scale, 
                drop_rate=drop_rate, attn_drop_rate=attn_drop_rate, drop_path_rate=drop_path_rate, 
                norm_layer=norm_layer,
                adapt_method=adapt_method,
                num_domains=num_domains
            ) for idx in range(self.num_stages)
        ])


        # bridge 
        self.bridge = nn.Sequential(
            nn.Conv2d(embed_dims[3],embed_dims[3],kernel_size=3,stride=1, padding=1),
            conv_norm(embed_dims[3]),
            nn.ReLU(inplace=True),
            nn.Conv2d(embed_dims[3],embed_dims[3]*2,kernel_size=3,stride=1, padding=1),
            conv_norm(embed_dims[3]*2),
            nn.ReLU(inplace=True)
        )


        # decoder
        self.mhsa_list = []
        for idx in range(self.num_stages):
            self.mhsa_list.append(
                MHSA_stage_adapt(
                (img_size//2**(idx+2))**2,
                embed_dims[idx],
                num_layers=num_layers[idx],
                num_heads=num_heads[idx], 
                mlp_ratio=mlp_ratios[idx], 
                qkv_bias=qkv_bias, qk_scale=qk_scale, 
                drop_rate=drop_rate, attn_drop_rate=attn_drop_rate, drop_path_rate=drop_path_rate, 
                norm_layer=norm_layer,
                adapt_method=adapt_method,
                num_domains=num_domains
                )            
            )

        self.decoder1 = UnetDecodingBlockTransformer(embed_dims[3]*2,embed_dims[3],self.mhsa_list[3],conv_norm=conv_norm)  # 768,384
        self.decoder2 = UnetDecodingBlockTransformer(embed_dims[3],embed_dims[2],self.mhsa_list[2],conv_norm=conv_norm)  # 384,192
        self.decoder3 = UnetDecodingBlockTransformer(embed_dims[2],embed_dims[1],self.mhsa_list[1],conv_norm=conv_norm)   # 192,96
        self.decoder4 = UnetDecodingBlockTransformer(embed_dims[1],embed_dims[0],self.mhsa_list[0],conv_norm=conv_norm)    # 96,48
        self.finalconv = nn.Sequential(
            nn.Conv2d(embed_dims[0], 1, kernel_size=1)
        )    

        # TODO auxiliary decoding branches
        # MLPFM decoder   MLP and fuse the feature from the main branch
        if self.decoder_name == 'MLPFM':
            self.debranch1 = MLPDecoderFM(embed_dims, 1, 512)
            self.debranch2 = MLPDecoderFM(embed_dims, 1, 512)
            self.debranch3 = MLPDecoderFM(embed_dims, 1, 512)
            self.debranch4 = MLPDecoderFM(embed_dims, 1, 512)
        
        elif self.decoder_name == 'MLP':
            self.debranch1 = MLPDecoder(embed_dims, 1, 512)
            self.debranch2 = MLPDecoder(embed_dims, 1, 512)
            self.debranch3 = MLPDecoder(embed_dims, 1, 512)
            self.debranch4 = MLPDecoder(embed_dims, 1, 512)          
        
        # DeepLabV3 decoder
        elif self.decoder_name == 'DeepLabV3':
            self.debranch1 = DeepLabV3Decoder(512,1)
            self.debranch2 = DeepLabV3Decoder(512,1)
            self.debranch3 = DeepLabV3Decoder(512,1)
            self.debranch4 = DeepLabV3Decoder(512,1)   

        elif self.decoder_name == 'Transformer':
            debranchs = []
            for i in range(num_domains):
                mhsa_list = []
                for idx in range(self.num_stages):
                    mhsa_list.append(
                        MHSA_stage_adapt(
                        (img_size//2**(idx+2))**2,
                        embed_dims[idx],
                        num_layers=num_layers[idx],
                        num_heads=num_heads[idx], 
                        mlp_ratio=mlp_ratios[idx], 
                        qkv_bias=qkv_bias, qk_scale=qk_scale, 
                        drop_rate=drop_rate, attn_drop_rate=attn_drop_rate, drop_path_rate=drop_path_rate, 
                        norm_layer=norm_layer,
                        adapt_method=False,
                        num_domains=num_domains
                        )            
                    )
                debranchs.append(
                    nn.ModuleList([
                        UnetDecodingBlockTransformer(embed_dims[3]*2,embed_dims[3],mhsa_list[3],conv_norm=conv_norm),
                        UnetDecodingBlockTransformer(embed_dims[3],embed_dims[2],mhsa_list[2],conv_norm=conv_norm),
                        UnetDecodingBlockTransformer(embed_dims[2],embed_dims[1],mhsa_list[1],conv_norm=conv_norm),
                        UnetDecodingBlockTransformer(embed_dims[1],embed_dims[0],mhsa_list[0],conv_norm=conv_norm),
                        nn.Sequential(nn.Conv2d(embed_dims[0], 1, kernel_size=1))    
                    ])
                )
                self.debranchs = nn.ModuleList(debranchs)


        self.apply(self._init_weights)


    def _init_weights(self, m):
        if isinstance(m, nn.Linear):
            trunc_normal_(m.weight, std=.02)
            if isinstance(m, nn.Linear) and m.bias is not None:
                nn.init.constant_(m.bias, 0)
        elif isinstance(m, nn.LayerNorm):
            nn.init.constant_(m.bias, 0)
            nn.init.constant_(m.weight, 1.0)
        elif isinstance(m, nn.Conv2d):
            fan_out = m.kernel_size[0] * m.kernel_size[1] * m.out_channels
            fan_out //= m.groups
            m.weight.data.normal_(0, math.sqrt(2.0 / fan_out))
            if m.bias is not None:
                m.bias.data.zero_()
        elif isinstance(m, nn.BatchNorm2d):
            m.weight.data.fill_(1)
            m.bias.data.zero_()


    def forward(self, x, domain_label=None, d=None, out_feat=False, out_seg=True):
        # out_feat=True output mid features
        # out_seg=True  output segmentation prediction
        # x (B,in_chans,H,W)
        img_size = x.size()[2:]
        x = self.stem(x)  # (B,embed_dim[0],H/4,W/4)
        encoder_outs = []
        for idx in range(self.num_stages):
            x = self.patch_embed_stages[idx](x)  # (B, embed_dim[idx],H/(4*2^idx),W/(4*2^idx))
            B,C,H,W = x.shape
            x = rearrange(x, 'b c h w -> b (h w) c')
            x = self.mhsa_stages[idx](x, H, W) if domain_label==None else self.mhsa_stages[idx](x, H, W,domain_label)
            x = rearrange(x, 'b (h w) c -> b c h w', w=W, h=H).contiguous()
            encoder_outs.append(x)
        
        if out_seg == False:
            x = nn.functional.adaptive_avg_pool2d(encoder_outs[3],1).reshape(B, -1)
            return {'seg': None, 'feat': x}

        # bridge
        out = self.bridge(encoder_outs[3])
        bridge_out = out

        # decoding
        out = self.decoder1(out, encoder_outs[3]) if domain_label==None else self.decoder1(out, encoder_outs[3],domain_label) # (384,16,16)
        out = self.decoder2(out, encoder_outs[2]) if domain_label==None else self.decoder2(out, encoder_outs[2],domain_label) # (192,32,32)
        out = self.decoder3(out, encoder_outs[1]) if domain_label==None else self.decoder3(out, encoder_outs[1],domain_label) # (96,64,64)
        out = self.decoder4(out, encoder_outs[0]) if domain_label==None else self.decoder4(out, encoder_outs[0],domain_label) # (48,128,128)
        decoder_outs = []
        decoder_outs.append(out)
        
        # upsample
        out = nn.functional.interpolate(out,size = img_size,mode = 'bilinear', align_corners=False) # (48,512,512)
        out = self.finalconv(out)  # (1,512,512)     

        if self.decoder_name == 'MLPFM':
            encoder_outs = encoder_outs+decoder_outs

        if self.decoder_name == 'Transformer':
            int_d = int(d)
            debranch = self.debranchs[int_d]
            aux_out = debranch[0](bridge_out, encoder_outs[3])
            aux_out = debranch[1](aux_out, encoder_outs[2])
            aux_out = debranch[2](aux_out, encoder_outs[1])
            aux_out = debranch[3](aux_out, encoder_outs[0])
            aux_out = nn.functional.interpolate(aux_out,size = img_size,mode = 'bilinear', align_corners=False)
            aux_out = debranch[4](aux_out)
        else:
            if d == '0':
                aux_out = self.debranch1(encoder_outs, img_size=img_size)
            elif d == '1':
                aux_out = self.debranch2(encoder_outs, img_size=img_size)
            elif d == '2':
                aux_out = self.debranch3(encoder_outs, img_size=img_size)
            elif d == '3':
                aux_out = self.debranch4(encoder_outs, img_size=img_size)
            else:
                aux_out = None
        
        if out_feat:
            x = nn.functional.adaptive_avg_pool2d(encoder_outs[3],1).reshape(B, -1)
            return {'seg': [out, aux_out], 'feat': x}
        else:
            return [out, aux_out]



# use different norms for different domains
class MDViT_DSN(nn.Module):
    '''
    several decoders to do knowledge distillation
    A Conv Position encoding + Factorized attention Transformer
    use transformer encoder and decoder
    feature_dim is the 4th stage output dimension
    do_detach: ture means detach the feature from the last encoder, then pass into projection head
    Input: an image
    Output: a list contains features from each stage
    '''
    def __init__(
        self,
        img_size=512,
        in_chans=3,
        num_stages=4,
        num_layers=[2, 2, 2, 2],
        embed_dims=[64, 128, 320, 512],
        mlp_ratios=[8, 8, 4, 4],
        num_heads=[8, 8, 8, 8],
        qkv_bias=True,
        qk_scale=None,
        drop_rate=0.,
        attn_drop_rate=0.,
        drop_path_rate=0.0,
        norm_layer=partial(nn.LayerNorm, eps=1e-6),
        conv_norm=nn.BatchNorm2d,
        adapt_method=None,
        num_domains=4,
        decoder_name = 'MLP',
        **kwargs,
    ):
        super(MDViT_DSN, self).__init__()
        self.num_stages = num_stages
        self.decoder_name = decoder_name


        self.stem_1 = Conv2d_BN_M(
                in_chans,
                embed_dims[0] // 2,
                kernel_size=3,
                stride=2,
                pad=1,
                act_layer=nn.Hardswish,
                num_domains=num_domains
            )
        self.stem_2 =  Conv2d_BN_M(
                embed_dims[0] // 2,
                embed_dims[0],
                kernel_size=3,
                stride=2,
                pad=1,
                act_layer=nn.Hardswish,
                num_domains=num_domains
            )

        # Patch embeddings.
        self.patch_embed_stages = nn.ModuleList([
            DWCPatchEmbed_M(
                in_chans=embed_dims[idx] if idx==0 else embed_dims[idx-1],
                embed_dim=embed_dims[idx],
                patch_size=3,
                stride=1 if idx==0 else 2, 
                conv_norm=conv_norm,
                num_domains=num_domains
            ) for idx in range(self.num_stages)
        ])

        # Multi-Head Convolutional Self-Attention (MHCA)
        self.mhsa_stages = nn.ModuleList([
           MHSA_stage_adapt_M(
                (img_size//2**(idx+2))**2,
                embed_dims[idx],
                num_layers=num_layers[idx],
                num_heads=num_heads[idx], 
                mlp_ratio=mlp_ratios[idx], 
                qkv_bias=qkv_bias, qk_scale=qk_scale, 
                drop_rate=drop_rate, attn_drop_rate=attn_drop_rate, drop_path_rate=drop_path_rate, 
                norm_layer=norm_layer,
                adapt_method=adapt_method,
                num_domains=num_domains
            ) for idx in range(self.num_stages)
        ])

        # bridge 
        self.bridge_conv1 = nn.Conv2d(embed_dims[3],embed_dims[3],kernel_size=3,stride=1, padding=1)
        self.bridge_norms1 = nn.ModuleList([conv_norm(embed_dims[3]) for _ in range(num_domains)])
        self.bridge_act1 = nn.ReLU(inplace=True)
        self.bridge_conv2 = nn.Conv2d(embed_dims[3],embed_dims[3]*2,kernel_size=3,stride=1, padding=1)
        self.bridge_norms2 = nn.ModuleList([conv_norm(embed_dims[3]*2) for _ in range(num_domains)])
        self.bridge_act2 = nn.ReLU(inplace=True)

        # decoder
        self.mhsa_list = []
        for idx in range(self.num_stages):
            self.mhsa_list.append(
                MHSA_stage_adapt_M(
                (img_size//2**(idx+2))**2,
                embed_dims[idx],
                num_layers=num_layers[idx],
                num_heads=num_heads[idx], 
                mlp_ratio=mlp_ratios[idx], 
                qkv_bias=qkv_bias, qk_scale=qk_scale, 
                drop_rate=drop_rate, attn_drop_rate=attn_drop_rate, drop_path_rate=drop_path_rate, 
                norm_layer=norm_layer,
                adapt_method=adapt_method,
                num_domains=num_domains
                )            
            )

        self.decoder1 = UnetDecodingBlockTransformer_M(embed_dims[3]*2,embed_dims[3],self.mhsa_list[3],conv_norm=conv_norm,num_domains=num_domains)  # 768,384
        self.decoder2 = UnetDecodingBlockTransformer_M(embed_dims[3],embed_dims[2],self.mhsa_list[2],conv_norm=conv_norm,num_domains=num_domains)  # 384,192
        self.decoder3 = UnetDecodingBlockTransformer_M(embed_dims[2],embed_dims[1],self.mhsa_list[1],conv_norm=conv_norm,num_domains=num_domains)   # 192,96
        self.decoder4 = UnetDecodingBlockTransformer_M(embed_dims[1],embed_dims[0],self.mhsa_list[0],conv_norm=conv_norm,num_domains=num_domains)    # 96,48
        self.finalconv = nn.Sequential(
            nn.Conv2d(embed_dims[0], 1, kernel_size=1)
        )    

        # TODO auxiliary decoding branches
        # MLP decoder
        if self.decoder_name == 'MLP':
            self.debranch1 = MLPDecoder(embed_dims, 1, 512)
            self.debranch2 = MLPDecoder(embed_dims, 1, 512)
            self.debranch3 = MLPDecoder(embed_dims, 1, 512)
            self.debranch4 = MLPDecoder(embed_dims, 1, 512)
        
        # DeepLabV3 decoder
        elif self.decoder_name == 'DeepLabV3':
            self.debranch1 = DeepLabV3Decoder(512,1)
            self.debranch2 = DeepLabV3Decoder(512,1)
            self.debranch3 = DeepLabV3Decoder(512,1)
            self.debranch4 = DeepLabV3Decoder(512,1)   
        # 
        # MS Decoder   resunet
        elif self.decoder_name == 'MLPFM':
            self.debranch1 = MLPDecoderFM(embed_dims, 1, 512)
            self.debranch2 = MLPDecoderFM(embed_dims, 1, 512)
            self.debranch3 = MLPDecoderFM(embed_dims, 1, 512)
            self.debranch4 = MLPDecoderFM(embed_dims, 1, 512)

        self.apply(self._init_weights)


    def _init_weights(self, m):
        if isinstance(m, nn.Linear):
            trunc_normal_(m.weight, std=.02)
            if isinstance(m, nn.Linear) and m.bias is not None:
                nn.init.constant_(m.bias, 0)
        elif isinstance(m, nn.LayerNorm):
            nn.init.constant_(m.bias, 0)
            nn.init.constant_(m.weight, 1.0)
        elif isinstance(m, nn.Conv2d):
            fan_out = m.kernel_size[0] * m.kernel_size[1] * m.out_channels
            fan_out //= m.groups
            m.weight.data.normal_(0, math.sqrt(2.0 / fan_out))
            if m.bias is not None:
                m.bias.data.zero_()
        elif isinstance(m, nn.BatchNorm2d):
            m.weight.data.fill_(1)
            m.bias.data.zero_()


    def forward(self, x, domain_label=None, d=None, out_feat=False, out_seg=True):
        # out_feat if output mid features
        # out_seg  if output segmentation prediction
        # x (B,in_chans,H,W)
        img_size = x.size()[2:]
        # x = self.stem(x)  # (B,embed_dim[0],H/4,W/4)
        x = self.stem_1(x,d=d)
        x = self.stem_2(x,d=d)
        encoder_outs = []
        for idx in range(self.num_stages):
            x = self.patch_embed_stages[idx](x,d)  # (B, embed_dim[idx],H/(4*2^idx),W/(4*2^idx))
            B,C,H,W = x.shape
            x = rearrange(x, 'b c h w -> b (h w) c')
            x = self.mhsa_stages[idx](x, H, W,d=d) if domain_label==None else self.mhsa_stages[idx](x, H, W,domain_label,d)
            x = rearrange(x, 'b (h w) c -> b c h w', w=W, h=H).contiguous()
            encoder_outs.append(x)
        
        if out_seg == False:
            x = nn.functional.adaptive_avg_pool2d(encoder_outs[3],1).reshape(B, -1)
            return {'seg': None, 'feat': x}

        # bridge
        d_int = int(d)
        out = self.bridge_conv1(encoder_outs[3])
        out = self.bridge_norms1[d_int](out)
        out = self.bridge_act1(out)
        out = self.bridge_conv2(out)
        out = self.bridge_norms2[d_int](out)
        out = self.bridge_act2(out)
        

        # decoding
        out = self.decoder1(out, encoder_outs[3],d=d) if domain_label==None else self.decoder1(out, encoder_outs[3],d,domain_label) # (384,16,16)
        out = self.decoder2(out, encoder_outs[2],d=d) if domain_label==None else self.decoder2(out, encoder_outs[2],d,domain_label) # (192,32,32)
        out = self.decoder3(out, encoder_outs[1],d=d) if domain_label==None else self.decoder3(out, encoder_outs[1],d,domain_label) # (96,64,64)
        out = self.decoder4(out, encoder_outs[0],d=d) if domain_label==None else self.decoder4(out, encoder_outs[0],d,domain_label) # (48,128,128)
        decoder_outs = []
        decoder_outs.append(out)
        
        # upsample
        out = nn.functional.interpolate(out,size = img_size,mode = 'bilinear', align_corners=False) # (48,512,512)
        out = self.finalconv(out)  # (1,512,512)     

        # auxiliary branches decoding
        
        if self.decoder_name == 'MLPFM':
            encoder_outs = encoder_outs+decoder_outs

        if d == '0':
            aux_out = self.debranch1(encoder_outs, img_size=img_size)
        elif d == '1':
            aux_out = self.debranch2(encoder_outs, img_size=img_size)
        elif d == '2':
            aux_out = self.debranch3(encoder_outs, img_size=img_size)
        elif d == '3':
            aux_out = self.debranch4(encoder_outs, img_size=img_size)
        else:
            aux_out = None

        
        if out_feat:
            x = nn.functional.adaptive_avg_pool2d(encoder_outs[3],1).reshape(B, -1)
            return {'seg': [out, aux_out], 'feat': x}
        else:
            return [out, aux_out]


if __name__ == '__main__':
    x = torch.randn(5,3,256,256)
    domain_label = torch.randint(0,4,(5,))
    domain_label = torch.nn.functional.one_hot(domain_label, 4).float()
    
    # MDViT
    # model = MDViT(adapt_method='Sup', num_domains=4, decoder_name='MLPFM')
    # MDViT^D
    # model = MDViT(adapt_method='Sup', num_domains=4, decoder_name='DeepLabV3')
    # MDViT^T
    # model = MDViT(adapt_method='Sup', num_domains=4, decoder_name='Transformer')
    # BASE+MKD
    # model = MDViT(adapt_method=None, num_domains=4, decoder_name='MLPFM')
    # MDViT+DSN
    model = MDViT_DSN(adapt_method='Sup', num_domains=4, decoder_name='MLPFM')

    
    y = model(x, domain_label, d='1',out_feat=True) # d='2', out_feat=True
    # segmentation map
    print(y['seg'][0].shape)
    # auxiliary branch map
    print(y['seg'][1].shape)
    # feature map
    print(y['feat'].shape)

    param = sum(p.numel() for p in model.parameters() if p.requires_grad)
    print(f"number of parameter: {param/1e6} M")
    
    count = 0
    for name, params in model.named_parameters():
        if 'debranch' not in name:
            count += params.numel()
    print(f'number of params not in debranches: {count/1e6} M')