modules.py

from collections import OrderedDict
import numpy as np
import torch.nn as nn
import torch
try:
    from timm.layers import to_2tuple, trunc_normal_, DropPath
except ImportError:
    from timm.models.layers import to_2tuple, trunc_normal_, DropPath
from torchvision.ops.deform_conv import *
from torchvision.ops.ps_roi_pool import *
import torch.nn.functional as F
# from .nonlocal_block import NONLocalBlock2D
#from carafe import CARAFEPack
from torch.nn.modules.utils import _pair
# from .nattencuda import NEWNeighborhoodAttention
# from .nattencuda import NeighborhoodAttention
from einops import rearrange, repeat
from einops.layers.torch import Rearrange
#from depthwise_conv2d_implicit_gemm import DepthWiseConv2dImplicitGEMM
#from .involution_cuda import involution
from natten import NeighborhoodAttention2D



class OverlapPatchEmbed(nn.Module):
    def __init__(self, patchsize, img_size, in_channels,embed_dim,stride,model='no nat'):#8,32,128
        super().__init__()
        self.model=model
        patch_size = _pair(patchsize)
        self.patch_embeddings = nn.Conv2d(in_channels=in_channels,
                                       out_channels=embed_dim,
                                       kernel_size=patchsize,
                                       stride=stride,
                             padding = (patch_size[0] // 2, patch_size[1] // 2)
        )
        
    def forward(self, x):
        x = self.patch_embeddings(x)
        if self.model=='nat':
            x=x.permute(0, 2, 3, 1)
        else:
            x = x.flatten(2).transpose(1, 2)#+self.position_embeddings
        return x

class Mlp(nn.Module):
    def __init__(self, in_channel, mlp_channel,out_channel):
        super(Mlp, self).__init__()
        self.fc1 = nn.Linear(in_channel, mlp_channel)
        self.fc2 = nn.Linear(mlp_channel, out_channel)
        self.act_fn = nn.GELU()#nn.Hardswish(inplace=True)
        self.dropout = nn.Dropout(0.1)

    def forward(self, x):
        x = self.fc1(x)
        x = self.act_fn(x)
        x = self.dropout(x)
        x = self.fc2(x)
        x = self.dropout(x)
        return x




class NoskipViTEncoder(nn.Module):
    def __init__(self, patchsize, img_size, in_channels,stride,kernel_size,head):
        super(NoskipViTEncoder, self).__init__()
        self.img_size=img_size
        self.patchembedding_l=OverlapPatchEmbed(patchsize, img_size, in_channels,in_channels,stride)
        self.patchembedding_s = OverlapPatchEmbed(patchsize, img_size, in_channels,in_channels,stride)
        self.norm_l1=nn.LayerNorm(in_channels)
        self.norm_s1 = nn.LayerNorm(in_channels)
        self.cross=NEWNeighborhoodAttention(in_channels,kernel_size,head,attn_drop=0.1,proj_drop=0.1)
        self.norm = nn.LayerNorm(in_channels)
        self.mlp = Mlp(in_channels, 2*in_channels,in_channels)

    def forward(self, xq, xkv):
        #xq_embedding = xq.permute(0, 2, 3, 1)
        #xkv_embedding=xkv.permute(0, 2, 3, 1)
        xq_embedding ,xkv_embedding=self.patchembedding_s(xq),self.patchembedding_l(xkv)
        xq, xkv = self.norm_s1(xq_embedding), self.norm_l1(xkv_embedding)
        att = self.cross(xq, xkv) + xkv_embedding
        x = self.mlp(self.norm(att)) + att
        x = x.permute(0, 3, 1, 2).contiguous()

        return x
class M3Skip(nn.Module):
    def __init__(self, in_channels=[12,24,48]):
        super(M3Skip, self).__init__()
        self.convl=nn.Sequential(
            nn.Conv2d(in_channels[0],in_channels[1],3,2,1),
        )
        self.convm=nn.Sequential(
            nn.Conv2d(in_channels[1],in_channels[1],3,1,1),
        )

        self.convs=nn.Sequential(
            nn.Upsample(scale_factor=2, mode='bilinear', align_corners=True),
            nn.Conv2d(in_channels[2], in_channels[1], 3, 1, 1),
            )
        self.fuse_conv=nn.Sequential(nn.Conv2d(3*in_channels[1],in_channels[1],3,1,1),
                                     nn.BatchNorm2d(in_channels[1]),
                                     nn.GELU()
                                     )
    def forward(self, xl,xm, xs):
        xl=self.convl(xl)
        xm=self.convm(xm)
        xs=self.convs(xs)
        x=torch.cat([xl,xm,xs],dim=1)
        x=self.fuse_conv(x)
        return x

class M2Skip(nn.Module):
    def __init__(self, in_channels=[12,24],model_type='bottom'):#大,小
        super(M2Skip, self).__init__()
        self.model_type=model_type
        if self.model_type=='bottom':
            self.convl=nn.Sequential(
                nn.Conv2d(in_channels[0],in_channels[1],3,2,1),
            )
            self.convs=nn.Sequential(
                nn.Conv2d(in_channels[1], in_channels[1], 3,1,1),
                )
            self.fuse_conv = nn.Sequential(nn.Conv2d(2 * in_channels[1], in_channels[1], 3,1,1),
                                           nn.BatchNorm2d(in_channels[1]),
                                           nn.GELU()
                                           )
        else:
            self.convl=nn.Sequential(
                nn.Conv2d(in_channels[0],in_channels[0],3,1,1),
            )
            self.convs=nn.Sequential(
                nn.Upsample(scale_factor=2, mode='bilinear', align_corners=True),
                nn.Conv2d(in_channels[1], in_channels[0], 3, 1, 1),
                )
            self.fuse_conv = nn.Sequential(nn.Conv2d(2*in_channels[0], in_channels[0], 3,1,1),
                                           nn.BatchNorm2d(in_channels[0]),
                                           nn.GELU()
                                           )

    def forward(self, xl, xs):
        xl=self.convl(xl)
        xs=self.convs(xs)
        x=torch.cat([xl,xs],dim=1)
        x=self.fuse_conv(x)

        return x

    

class PatchEmbed(nn.Module):

    def __init__(self, patch_size=7,img_size=224,in_chans=3, out_channel=768):
        super().__init__()
        img_size = to_2tuple(img_size)
        patch_size = to_2tuple(patch_size)
        self.num_patches = (img_size[0] // patch_size[0]) * (img_size[1] // patch_size[1])
        #embed_dim=patch_size[0]*patch_size[1]*in_chans

        self.proj = nn.Conv2d(in_chans, out_channel, kernel_size=patch_size, stride=patch_size,
                              )
        self.norm = nn.LayerNorm(out_channel)
        self.position_embeddings = nn.Parameter(torch.zeros(1, self.num_patches, out_channel))
        self.proj_linear=nn.Linear(out_channel,out_channel)
        self.dropout = nn.Dropout(0.1)


    def forward(self, x):
        x = self.proj(x)
        x = x.flatten(2).transpose(-1, -2)+self.position_embeddings
        #x=self.proj_linear(x)
        #x = self.dropout(self.norm(x))
        x=self.norm(x)
        return x



class Attention(nn.Module):
    def __init__(self, dim, num_heads=8, qkv_bias=True, qk_scale=None, attn_drop=0., proj_drop=0., sr_ratio=1):
        super().__init__()
        assert dim % num_heads == 0, f"dim {dim} should be divided by num_heads {num_heads}."

        self.dim = dim
        self.num_heads = num_heads
        head_dim = dim // num_heads
        self.scale = qk_scale or head_dim ** -0.5

        self.q = nn.Linear(dim, dim, bias=qkv_bias)
        self.kv = nn.Linear(dim, dim * 2, bias=qkv_bias)
        self.attn_drop = nn.Dropout(attn_drop)
        self.proj = nn.Linear(dim, dim)
        self.proj_drop = nn.Dropout(proj_drop)

        self.sr_ratio = sr_ratio
        if sr_ratio > 1:
            self.sr = nn.Conv2d(dim, dim, kernel_size=sr_ratio, stride=sr_ratio)
            self.norm = nn.LayerNorm(dim)

        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_()

    def forward(self, x, H, W):
        B, N, C = x.shape
        q = self.q(x).reshape(B, N, self.num_heads, C // self.num_heads).permute(0, 2, 1, 3)

        if self.sr_ratio > 1:
            x_ = x.permute(0, 2, 1).reshape(B, C, H, W)
            x_ = self.sr(x_).reshape(B, C, -1).permute(0, 2, 1)
            x_ = self.norm(x_)
            kv = self.kv(x_).reshape(B, -1, 2, self.num_heads, C // self.num_heads).permute(2, 0, 3, 1, 4)
        else:
            kv = self.kv(x).reshape(B, -1, 2, self.num_heads, C // self.num_heads).permute(2, 0, 3, 1, 4)
        k, v = kv[0], kv[1]

        attn = (q @ k.transpose(-2, -1)) * self.scale
        attn = attn.softmax(dim=-1)
        attn = self.attn_drop(attn)

        x = (attn @ v).transpose(1, 2).reshape(B, N, C)
        x = self.proj(x)
        x = self.proj_drop(x)

        return x

class GlobalAttention(nn.Module):
    def __init__(self, dim, num_heads=8, qkv_bias=True, qk_scale=None, attn_drop=0., proj_drop=0.):
        super().__init__()
        assert dim % num_heads == 0, f"dim {dim} should be divided by num_heads {num_heads}."

        self.dim = dim
        self.num_heads = num_heads
        self.head_dim = dim // num_heads
        self.scale = qk_scale or self.head_dim ** -0.5
        #self.q = nn.Linear(dim,  2, bias=qkv_bias)
        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.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_()

    def forward(self, x):
        B, N, C = x.shape
        qkv = self.qkv(x).reshape(B, -1, 3, self.num_heads, self.head_dim).permute(2, 0, 3, 1, 4)
        q,k, v = qkv[0], qkv[1], qkv[2]

        attn = (q @ k.transpose(-2, -1)) * self.scale
        attn = attn.softmax(dim=-1)
        attn = self.attn_drop(attn)

        x = (attn @ v).transpose(1, 2).reshape(B, N, C)
        x = self.proj(x)
        x = self.proj_drop(x)
        return x


class PoolingAttention(nn.Module):
    def __init__(self, dim, num_heads=2, qkv_bias=False, qk_scale=None, attn_drop=0., proj_drop=0.,
                 pool_ratios=[1, 2, 3, 6]):
        super().__init__()
        assert dim % num_heads == 0, f"dim {dim} should be divided by num_heads {num_heads}."

        self.dim = dim
        self.num_heads = num_heads
        head_dim = dim // num_heads
        self.scale = qk_scale or head_dim ** -0.5

        self.q = nn.Linear(dim, dim, bias=qkv_bias)
        self.kv = nn.Linear(dim, dim * 2, bias=qkv_bias)

        self.attn_drop = nn.Dropout(attn_drop)
        self.proj = nn.Linear(dim, dim)
        self.proj_drop = nn.Dropout(proj_drop)

        self.pool_ratios = pool_ratios

        self.norm = nn.LayerNorm(dim)

    def forward(self, x, H, W, d_convs=None):#93312
        B, N, C = x.shape

        q = self.q(x).reshape(B, N, self.num_heads, C // self.num_heads).permute(0, 2, 1, 3)
        pools = []
        x_ = x.permute(0, 2, 1).reshape(B, C, H, W)
        for (pool_ratio, l) in zip(self.pool_ratios, d_convs):
            pool = F.adaptive_avg_pool2d(x_, (round(H / pool_ratio), round(W / pool_ratio)))
            pool = pool + l(pool)  # fix backward bug in higher torch versions when training
            pools.append(pool.view(B, C, -1))

        pools = torch.cat(pools, dim=2)
        pools = self.norm(pools.permute(0, 2, 1))

        kv = self.kv(pools).reshape(B, -1, 2, self.num_heads, C // self.num_heads).permute(2, 0, 3, 1, 4)
        k, v = kv[0], kv[1]

        attn = (q @ k.transpose(-2, -1)) * self.scale
        attn = attn.softmax(dim=-1)
        x = (attn @ v)
        x = x.transpose(1, 2).contiguous().reshape(B, N, C)

        x = self.proj(x)

        return x
class GFT(nn.Module):
    def __init__(self, patchsize, img_size, in_channels,expand_ratios,out_channel,stride,num_heads):
        super(GFT, self).__init__()
        self.patchembedding=OverlapPatchEmbed(patchsize, img_size, in_channels,in_channels,stride)
        self.norm1=nn.LayerNorm(in_channels)
        self.attention=GlobalAttention(in_channels,num_heads)
        self.norm2 = nn.LayerNorm(in_channels)
        self.mlp = Mlp(in_channels, expand_ratios*in_channels,in_channels)
        self.conv=nn.Sequential(nn.Conv2d(in_channels,out_channel,1),
                                )

    def forward(self, x):
        B,C,H,W = x.shape
        x_embedding=self.patchembedding(x)
        att = self.attention(self.norm1(x_embedding)) + x_embedding
        x = self.mlp(self.norm2(att)) + att
        x = x.reshape(B, H, W, -1).permute(0, 3, 1, 2).contiguous()
        x=self.conv(x)
        return x


class BottleneckGFT(nn.Module):
    def __init__(
        self,
        in_channels,
        out_channel,
        bottleneck_channels=128,
        expand_ratios=2,
        num_heads=4,
        attention="global",
        pool_ratios=(1, 2, 3, 6),
    ):
        super().__init__()
        if bottleneck_channels % num_heads != 0:
            raise ValueError(
                f"bottleneck_channels {bottleneck_channels} must be divisible by num_heads {num_heads}"
            )
        if attention not in ("global", "linear", "pooled", "identity"):
            raise ValueError(f"Unsupported bottleneck GFT attention: {attention}")

        self.attention_type = attention
        self.reduce = nn.Sequential(
            nn.Conv2d(in_channels, bottleneck_channels, kernel_size=1, bias=False),
            nn.BatchNorm2d(bottleneck_channels),
            nn.GELU(),
        )
        self.patch = nn.Conv2d(
            bottleneck_channels,
            bottleneck_channels,
            kernel_size=3,
            stride=1,
            padding=1,
            groups=bottleneck_channels,
            bias=False,
        )
        self.norm1 = nn.LayerNorm(bottleneck_channels)
        if attention == "global":
            self.attention = GlobalAttention(bottleneck_channels, num_heads)
        elif attention == "linear":
            self.attention = LinearAttention(bottleneck_channels, num_heads)
        elif attention == "pooled":
            self.attention = PoolingAttention(bottleneck_channels, num_heads, pool_ratios=pool_ratios)
            self.d_conv = nn.ModuleList(
                [
                    nn.Conv2d(
                        bottleneck_channels,
                        bottleneck_channels,
                        kernel_size=3,
                        stride=1,
                        padding=1,
                        groups=bottleneck_channels,
                    )
                    for _ in pool_ratios
                ]
            )
        else:
            self.attention = nn.Identity()
        self.norm2 = nn.LayerNorm(bottleneck_channels)
        self.mlp = Mlp(
            bottleneck_channels,
            expand_ratios * bottleneck_channels,
            bottleneck_channels,
        )
        self.proj = nn.Sequential(
            nn.Conv2d(bottleneck_channels, out_channel, kernel_size=1, bias=False),
            nn.BatchNorm2d(out_channel),
            nn.GELU(),
        )

    def forward(self, x):
        x = self.reduce(x)
        x = self.patch(x) + x
        B, C, H, W = x.shape
        x = x.flatten(2).transpose(1, 2)

        if self.attention_type == "pooled":
            attn = self.attention(self.norm1(x), H, W, self.d_conv)
        else:
            attn = self.attention(self.norm1(x))
        x = attn + x
        x = self.mlp(self.norm2(x)) + x
        x = x.reshape(B, H, W, C).permute(0, 3, 1, 2).contiguous()
        
        return self.proj(x)
class PoolTransformer(nn.Module):
    def __init__(self, patchsize, img_size, in_channels,out_channel,stride,num_heads,pool_ratios=[1, 2, 3, 6]):
        super(PoolTransformer, self).__init__()
        self.patchembedding=OverlapPatchEmbed(patchsize, img_size, in_channels,out_channel,stride)
        self.norm1=nn.LayerNorm(out_channel)
        self.attention=PoolingAttention(out_channel,num_heads,pool_ratios=pool_ratios)
        self.norm2 = nn.LayerNorm(out_channel)
        self.mlp = Mlp(out_channel, 2*out_channel,out_channel)
        self.norm3=nn.LayerNorm(out_channel)
        self.d_conv = nn.ModuleList(
            [nn.Conv2d(out_channel, out_channel,3,1,1, groups=out_channel) for tempin in pool_ratios])
        self.stride=stride
        self.hw=img_size//stride
        self.drop_path = DropPath(0.1)
    def forward(self, x):
        B,_,H,W=x.shape
        x_embedding=self.patchembedding(x)

        att = self.drop_path(self.attention(self.norm1(x_embedding),self.hw,self.hw,self.d_conv)) + x_embedding
        x = self.drop_path(self.mlp(self.norm2(att))) + att
        x=self.norm3(x)
        x = x.reshape(B, self.hw, self.hw, -1).permute(0, 3, 1, 2).contiguous()
        if self.stride>1:
            x=F.interpolate(x, size=(H,W), mode='bilinear', align_corners=False)
        return x

class NAT_Global_Transformer(nn.Module):
    def __init__(self, patchsize, img_size, in_channels,out_channel,stride,kernel_size=[3,5],num_heads=8,pool_ratios=[1, 2, 3, 6],sr_ratio=1):
        super(NAT_Global_Transformer, self).__init__()
        self.stride=stride
        self.patch_hw=img_size//stride#img_size//patchsize##
        self.patchembedding1=  OverlapPatchEmbed(3, img_size, in_channels,out_channel,1)
        self.patchembedding3 = OverlapPatchEmbed(3, img_size, in_channels, out_channel, 1)
        self.patchembedding2 = OverlapPatchEmbed(patchsize, img_size, in_channels, out_channel,stride)
        self.norm1=nn.LayerNorm(out_channel)
        self.att0=NeighborhoodAttention(out_channel,kernel_size[0],num_heads)
        self.att1 = NeighborhoodAttention(out_channel, kernel_size[1], num_heads)
        self.hatt1 = NEWNeighborhoodAttention(out_channel, kernel_size[0], num_heads)
        self.hatt2 = NEWNeighborhoodAttention(out_channel, kernel_size[1], num_heads)
        self.att2 = Attention(out_channel,num_heads,sr_ratio=sr_ratio)
        self.norm2 = nn.LayerNorm(out_channel)
        self.norm1_0 = nn.LayerNorm(out_channel)
        self.norm1_1 = nn.LayerNorm(out_channel)
        self.norm3 = nn.LayerNorm(out_channel)
        self.mlp = Mlp(out_channel, 2*out_channel,out_channel)
        self.proj = nn.Linear(out_channel, out_channel*patchsize*patchsize)
        self.up_conv =nn.Sequential(  nn.BatchNorm2d(in_channels),
            nn.ReLU(inplace=True),
            nn.Conv2d(in_channels, out_channel,kernel_size=3, padding=1),
            nn.Upsample(scale_factor=stride,mode='bilinear'))
        self.fuse=nn.Conv2d(2*out_channel,out_channel,1)
        self.drop_path = DropPath(0.1)


        self.d_conv = nn.ModuleList(
            [nn.Conv2d(out_channel, out_channel,3,1,1, groups=out_channel) for tempin in pool_ratios])

    def forward(self,xq,xkv ):
        # B,C,H,W = xkv.shape
        #
        # x_embedding2=self.patchembedding2(xq)
        # att2=self.drop_path(self.att2(self.norm2(x_embedding2),self.patch_hw,self.patch_hw))+ x_embedding2
        #
        # att2 = att2.reshape(B, self.patch_hw, self.patch_hw, -1).permute(0, 3, 1, 2).contiguous()
        # if self.stride>1:
        #     att2=self.up_conv(att2)

        x_embedding1 = self.patchembedding1(xq)
        x_embedding3 = self.patchembedding3(xkv)
        xq=self.norm1(x_embedding1)
        xkv = self.norm1_0(x_embedding1)

        #att=self.fuse(torch.cat([att1,att2],dim=1)).permute(0, 2, 3, 1)
        att1 = self.drop_path(self.hatt1(xq,xkv))
        #att2 = self.drop_path(self.hatt2(xq, xkv))
        att=att1+x_embedding3


        #att1=att1.permute(0, 3, 1, 2)


        #att2=self.proj(att2).reshape(B, H, W, -1)
        #att=(att1+att2).permute(0, 2, 3, 1)
        x = self.drop_path(self.mlp(self.norm3(att))) + att
        x = x.permute(0, 3, 1, 2).contiguous()
        return x


class SkipAttention(nn.Module):
    def __init__(self, patchsize, img_size, in_channels,out_channel,stride,sr_ratio):
        super(SkipAttention, self).__init__()
        self.patchembedding=OverlapPatchEmbed(patchsize, img_size, in_channels,out_channel,stride)
        self.norm1=nn.LayerNorm(out_channel)
        self.attention=Attention(out_channel,8,sr_ratio=sr_ratio)
        self.norm2 = nn.LayerNorm(out_channel)
        self.mlp = Mlp(out_channel, 2*out_channel,out_channel)
        self.norm3=nn.LayerNorm(out_channel)
    def forward(self, x):
        B=x.shape[0]
        x_embedding,H,W=self.patchembedding(x)
        att = self.attention(self.norm1(x_embedding),H,W) + x_embedding
        x = self.mlp(self.norm2(att)) + att
        x=self.norm3(x)
        x = x.reshape(B, H, W, -1).permute(0, 3, 1, 2).contiguous()
        return x

class PyramidPool(nn.Module):
    def __init__(self,filters=[16,32, 64, 128, 256]):
        super().__init__()
        self.pool1 = nn.AdaptiveAvgPool2d(128)
        self.pool2 = nn.AdaptiveAvgPool2d(64)
        self.pool3 = nn.AdaptiveAvgPool2d(32)
        self.pool4 = nn.AdaptiveAvgPool2d(16)
        # self.fuse1 = nn.Sequential(nn.Conv2d(filters[0]+filters[1],filters[0]+filters[1], 3,1,1),
        #                            #nn.BatchNorm2d(filters[0]+filters[1]),
        #                            #nn.ReLU(inplace=True)
        #                            )
        #
        # self.fuse2 = nn.Sequential(nn.Conv2d(filters[0]+filters[1]+filters[2],filters[0]+filters[1]+filters[2], 3,1,1),
        #                            #nn.BatchNorm2d(filters[0]+filters[1]+filters[2]),
        #                            #nn.ReLU(inplace=True)
        #                            )
        #
        # self.fuse3 = nn.Sequential(nn.Conv2d(sum(filters)-filters[4],sum(filters)-filters[4], 3,1,1),
        #                            #nn.BatchNorm2d(sum(filters)-filters[4]),
        #                            #nn.ReLU(inplace=True)
        #                            )
        #
        # self.fuse4 = nn.Sequential(nn.Conv2d(sum(filters),sum(filters), 3,1,1),
        #                            #nn.BatchNorm2d(sum(filters)),
        #                            #nn.ReLU(inplace=True)
        #                            )

    def forward(self, x1,x2,x3,x4,x5):


        # x1 = self.pool1(x1)
        # fuse1 = self.fuse1(torch.cat([x1,x2], dim=1))
        # x2 = self.pool2(fuse1)
        # fuse2 = self.fuse2(torch.cat([x2,x3], dim=1))
        # x3 = self.pool3(fuse2)
        # fuse3 = self.fuse3(torch.cat([x3,x4], dim=1))
        # x4 = self.pool4(fuse3)
        # fuse4 = self.fuse4(torch.cat([x4, x5], dim=1))
        # return fuse4


        B, C, H, W = x5.shape
        x=torch.cat([nn.functional.adaptive_avg_pool2d(i, (H, W)) for i in [x1,x2,x3,x4] ], dim=1)
        #x = torch.cat([nn.functional.adaptive_max_pool2d(i, (H, W)) for i in [x1, x2, x3, x4]], dim=1)
        return torch.cat([x,x5],dim=1)





class NeighborhoodTransformer(nn.Module):
    def __init__(self, patchsize, img_size, in_channels,out_channel,stride,kernel_size=[3,5],num_heads=8):
        super(NeighborhoodTransformer, self).__init__()
        self.patchembedding=  OverlapPatchEmbed(patchsize, img_size, in_channels,out_channel,stride,'nat')
        self.norm1=nn.LayerNorm(out_channel)
        self.att1 = NeighborhoodAttention2D(dim=out_channel,num_heads=num_heads,kernel_size=3)

        # self.att1 = NeighborhoodAttention2D(embed_dim=out_channel,num_heads=num_heads,kernel_size=3)
        # self.att2 = NeighborhoodAttention2D(dim=out_channel,num_heads=num_heads,kernel_size=7,)
        self.norm2 = nn.LayerNorm(out_channel)
        self.mlp = Mlp(out_channel, 2*out_channel,out_channel)

    def forward(self, x):
        x_embedding= self.patchembedding(x)
        x= self.norm1(x_embedding)
        att = self.att1(x)+x_embedding#+self.att2(x)
        x = self.mlp(self.norm2(att)) + att
        x = x.permute(0, 3, 1, 2).contiguous()

        return x



class ReparamConv(nn.Module):

    def __init__(self, in_channels,expand_channels,out_channels, large_kernel_size,kernel_size,stride=1, groups=1,deploy=False, se_kind="sse"):
        super(ReparamConv, self).__init__()
        self.large_kernel_size=large_kernel_size
        self.kernel_size=kernel_size
        self.in_channels=in_channels
        self.expand_channels=expand_channels
        self.stride=stride
        self.deploy = deploy
        if se_kind == "se":
            self.se = SE(expand_channels)
        elif se_kind == "sse":
            self.se = SSE(expand_channels)
        else:
            raise ValueError(f"Unsupported se_kind: {se_kind}")

        self.expand_conv =nn.Sequential(nn.Conv2d(in_channels, expand_channels, kernel_size=1, stride=1),
                                        nn.BatchNorm2d(expand_channels),
                                        nn.Hardswish(inplace=True))


        if self.deploy:
            self.fuse_conv = nn.Conv2d(in_channels=expand_channels, out_channels=expand_channels,
                                        kernel_size=large_kernel_size, stride=stride,
                                        padding=large_kernel_size//2,  groups=expand_channels, bias=True,
                                        )
        else:
            self.large_conv = nn.Sequential(OrderedDict(
                [('conv',nn.Conv2d(in_channels=expand_channels, out_channels=expand_channels,
                                         kernel_size=large_kernel_size, stride=stride,
                                         padding=large_kernel_size//2,  groups=expand_channels,bias=False)),
                 ('bn', nn.BatchNorm2d(expand_channels))
                 ]))
            self.square_conv = nn.Sequential(OrderedDict([
                ('conv',nn.Conv2d(in_channels=expand_channels, out_channels=expand_channels,
                                         kernel_size=kernel_size, stride=stride,
                                         padding=kernel_size//2,  groups=expand_channels,bias=False)),
                ('bn', nn.BatchNorm2d(expand_channels))
            ]))
            self.ver_conv = nn.Sequential(OrderedDict([
                 ('conv',nn.Conv2d(in_channels=expand_channels, out_channels=expand_channels,
                                      kernel_size=(kernel_size, 1),stride=stride,
                                      padding=[kernel_size // 2,0],  groups=expand_channels, bias=False,)),
                ('bn', nn.BatchNorm2d(expand_channels))
            ]))

            self.hor_conv = nn.Sequential(OrderedDict([
                 ('conv',nn.Conv2d(in_channels=expand_channels, out_channels=expand_channels,
                                      kernel_size=(1, kernel_size),stride=stride,
                                      padding=[0,kernel_size // 2 ],  groups=expand_channels, bias=False,)),
                ('bn', nn.BatchNorm2d(expand_channels))
            ]))

        self.active = nn.GELU()

        self.pointwise_conv = nn.Sequential(
            nn.Conv2d(expand_channels, out_channels, kernel_size=1, stride=1, padding=0),
            #nn.BatchNorm2d(out_channels)
        )

        self.shortcut = nn.Sequential(
            nn.Conv2d(in_channels, out_channels, kernel_size=1, stride=1, padding=0),
           #nn.BatchNorm2d(out_channels),
        )

    def forward(self, x):
        x1 = self.expand_conv(x)
        if self.deploy:
            out = self.fuse_conv(x1)
        else:

            out = self.large_conv(x1)
            out += self.square_conv(x1)
            out += self.ver_conv(x1)
            out += self.hor_conv(x1)

        x1 = self.se(self.active(out))
        x1 = self.pointwise_conv(x1)
        out = x1 + self.shortcut(x)
        return out

    def fuse_bn(self,conv, bn, mobel='no avg'):
        if mobel == 'avg':
            kernel = conv
        else:
            kernel = conv.weight
        gamma = bn.weight
        std = (bn.running_var + bn.eps).sqrt()
        t = (gamma / std).reshape(-1, 1, 1, 1)
        return kernel * t, bn.bias - bn.running_mean * gamma / std

    def axial_to_square_kernel(self, square_kernel, asym_kernel):
        asym_h = asym_kernel.size(2)
        asym_w = asym_kernel.size(3)
        square_h = square_kernel.size(2)
        square_w = square_kernel.size(3)
        square_kernel[:, :, square_h // 2 - asym_h // 2: square_h // 2 - asym_h // 2 + asym_h,
        square_w // 2 - asym_w // 2: square_w // 2 - asym_w // 2 + asym_w] += asym_kernel
        return square_kernel


    def get_equivalent_kernel_bias(self):
        large_k, large_b = self.fuse_bn(self.large_conv.conv, self.large_conv.bn)
        square_k, square_b = self.fuse_bn(self.square_conv.conv, self.square_conv.bn)
        hor_k, hor_b = self.fuse_bn(self.hor_conv.conv, self.hor_conv.bn)
        ver_k, ver_b = self.fuse_bn(self.ver_conv.conv, self.ver_conv.bn)
        square_k=self.axial_to_square_kernel(square_k, hor_k)
        square_k=self.axial_to_square_kernel(square_k, ver_k)



        #singel_k, singel_b = self.fuse_bn(self.singel_conv.conv, self.singel_conv.bn)

        #avg_weight = get_avg_weight(self.in_channels, self.kernel_size,self.expand_channels).cuda()
        #avg_k,avg_b=fuse_bn(avg_weight, self.avg_cov.bn,mobel='avg')


        large_b =large_b+square_b+hor_b+ver_b
        # #   add to the central part
        large_k += nn.functional.pad(square_k, [(self.large_kernel_size - self.kernel_size) // 2] * 4)
        # # large_k += nn.functional.pad(avg_k, [(self.large_kernel_size - self.kernel_size) // 2] * 4)
        return large_k, large_b

    def switch_to_deploy(self):
        deploy_k, deploy_b = self.get_equivalent_kernel_bias()
        self.deploy = True
        self.fuse_conv = nn.Conv2d(in_channels=self.expand_channels, out_channels=self.expand_channels,
                                    kernel_size=self.large_kernel_size, stride=self.stride,
                                    padding=self.large_kernel_size//2, dilation=1,
                                    groups=self.expand_channels, bias=True,
                                    )
        self.fuse_conv.weight.data = deploy_k
        self.fuse_conv.bias.data = deploy_b
        self.__delattr__('square_conv')
        #self.__delattr__('avg_cov')
        self.__delattr__('hor_conv')
        self.__delattr__('ver_conv')



class MobileBlock(nn.Module):
    '''expand + depthwise + pointwise'''
    def __init__(self, in_channels, expand_channels, out_channels,large_kernel_size,kernel_size,):
        super(MobileBlock, self).__init__()
        self.se = SE(expand_channels)

        self.expand_conv =nn.Sequential(nn.Conv2d(in_channels, expand_channels, kernel_size=1, stride=1, bias=False),
                                        nn.BatchNorm2d(expand_channels),
                                        nn.Hardswish(inplace=True))

        self.depthwise_conv_l  = nn.Sequential(
            nn.Conv2d(expand_channels, expand_channels,kernel_size=5, stride=1,padding=2,dilation=1, groups=expand_channels, bias=False),
            #DepthWiseConv2dImplicitGEMM(expand_channels,13,False),
            nn.BatchNorm2d(expand_channels),
           # nn.Hardswish(inplace=True)
        )
        self.depthwise_conv_r  = nn.Sequential(
            #nn.Conv2d(expand_channels, expand_channels,kernel_size=3, stride=1,padding=2,dilation=2, groups=expand_channels, bias=False),
            nn.Conv2d(expand_channels, expand_channels, kernel_size=3, stride=1, padding=1, dilation=1,
                      groups=expand_channels, bias=False),
            nn.BatchNorm2d(expand_channels),
         #   nn.Hardswish(inplace=True)
        )
        self.reparamconv=ReparamConv(expand_channels,5,3,1,1)
        self.active=nn.Hardswish(inplace=True)



        self.pointwise_conv = nn.Sequential(
            nn.Conv2d(expand_channels, out_channels, kernel_size=1, stride=1, padding=0),
            nn.BatchNorm2d(out_channels))

        self.shortcut = nn.Sequential(
            nn.Conv2d(in_channels, out_channels, kernel_size=1, stride=1, padding=0, bias=False),
            #nn.BatchNorm2d(out_channels),
        )

    def forward(self, x):
        x1 = self.expand_conv(x)
        #x_reparam=self.reparamconv(x1)

        x_l = self.depthwise_conv_l(x1)
        x_r = self.depthwise_conv_r(x1)



        x1 = self.se(self.active(x_l+x_r))
        x1 = self.pointwise_conv(x1)
        out = x1 + self.shortcut(x)
        return out
class SegMLP(nn.Module):
    """
    Linear Embedding
    """
    def __init__(self, input_dim=2048, embed_dim=768):
        super().__init__()
        self.proj = nn.Linear(input_dim, embed_dim)

    def forward(self, x):
        x = x.flatten(2).transpose(1, 2)
        x = self.proj(x)
        return x

class SegHead(nn.Module):
    def __init__(self,in_channels=[16,32,64,128]):
        super(SegHead, self).__init__()
        self.linear1 = SegMLP(input_dim=in_channels[0], embed_dim=in_channels[3])
        self.linear2 = SegMLP(input_dim=in_channels[1], embed_dim=in_channels[3])
        self.linear3 = SegMLP(input_dim=in_channels[2], embed_dim=in_channels[3])
        self.linear4 = SegMLP(input_dim=in_channels[3], embed_dim=in_channels[3])

        self.fuse =nn.Sequential(nn.Conv2d(4*in_channels[3],in_channels[0],1),
                                 nn.BatchNorm2d(in_channels[0])
                                  )
        self.dropout=nn.Dropout(0.1)
        self.linear_pred = nn.Conv2d(in_channels[0], 2, kernel_size=1)

    def forward(self, x1,x2,x3,x4):
        n, _, _, _ = x1.shape
        x1=self.linear1(x1).permute(0,2,1).reshape(n, -1, x1.shape[2], x1.shape[3])
        x2 = self.linear2(x2).permute(0, 2, 1).reshape(n, -1, x2.shape[2], x2.shape[3])
        x3 = self.linear3(x3).permute(0, 2, 1).reshape(n, -1, x3.shape[2], x3.shape[3])
        x4 = self.linear4(x4).permute(0, 2, 1).reshape(n, -1, x4.shape[2], x4.shape[3])

        x2 = F.interpolate(x2, size=x1.size()[2:], mode='bilinear', align_corners=False)
        x3 = F.interpolate(x3, size=x1.size()[2:], mode='bilinear', align_corners=False)
        x4 = F.interpolate(x4, size=x1.size()[2:], mode='bilinear', align_corners=False)
        x=torch.cat([x1,x2,x3,x4], dim=1)
        x  = self.fuse(x)
        x = self.dropout(x)
        x = self.linear_pred(x)
        return x

class SoftPool(nn.Module):
    def __init__(self, kernel_size, stride, padding=0):
        super(SoftPool,self).__init__()
        self.kernel_size = kernel_size
        self.stride = stride
        self.padding = padding

    def forward(self, x):
        x = self.soft_pool2d(x, kernel_size=self.kernel_size, stride=self.stride)
        return x

    def soft_pool2d(self, x, kernel_size=2, stride=None, force_inplace=False):
        kernel_size = _pair(kernel_size)
        if stride is None:
            stride = kernel_size
        else:
            stride = _pair(stride)
        _, c, h, w = x.size()
        e_x = torch.sum(torch.exp(x),dim=1,keepdim=True)
        return F.avg_pool2d(x.mul(e_x), kernel_size, stride=stride).mul_(sum(kernel_size)).div_(F.avg_pool2d(e_x, kernel_size, stride=stride).mul_(sum(kernel_size)))


class ResidualConv(nn.Module):
    def __init__(self, input_dim, output_dim, stride, padding):
        super(ResidualConv, self).__init__()

        self.conv_block = nn.Sequential(
            nn.BatchNorm2d(input_dim),
            nn.ReLU(),
            nn.Conv2d(
                input_dim, output_dim, kernel_size=3, stride=stride, padding=padding
            ),#图像大小减半
            nn.BatchNorm2d(output_dim),
            nn.ReLU(),
            nn.Conv2d(output_dim, output_dim, kernel_size=3, padding=2,dilation=2),
        )
        self.conv_skip = nn.Sequential(
            nn.Conv2d(input_dim, output_dim, kernel_size=3, stride=stride, padding=1),#图像大小减半，保证跳跃连接大小一致
            nn.BatchNorm2d(output_dim),
        )
        self.mult_scal = SPBlock(output_dim, output_dim)
        self.pam=PAM_Module(output_dim)
        self.cam=CAM_Module(output_dim)
        self.eca=ECA(output_dim,3)

    def forward(self, x):
        x1=self.conv_block(x)
        x2=self.mult_scal(x1)
        #x2=self.mult_scal(x)
        #x3=self.pam(x1)
        #x3=self.cam(x2)
        x3=self.conv_skip(x)
        #x4=self.eca(x1+x2)
        return x2+x3

class DepthwiseConvolution(nn.Module):
    def __init__(self, in_ch, out_ch, kernel_size=3, stride=1, padding=1):
        super().__init__()
        self.depthwise_conv = nn.Conv2d(in_channels=in_ch, out_channels=in_ch,
            kernel_size=kernel_size,stride=stride,padding=padding,groups=in_ch)

        self.pointwise_conv = nn.Conv2d(in_channels=in_ch,out_channels=out_ch,
            kernel_size=1,stride=1,padding=0,groups=1)

    def forward(self, x):
        out = self.depthwise_conv(x)
        out = self.pointwise_conv(out)
        return out

class DeformConv_V2(nn.Module):
    def __init__(self, in_channels, out_channels, kernel_size=3, stride=1, padding=1,dilation=1):
        super(DeformConv_V2, self).__init__()
        self.offset_conv = nn.Conv2d(in_channels,2 * kernel_size * kernel_size,
                                     kernel_size=kernel_size,stride=stride,
                                     padding=padding,dilation=dilation
                                     )

        nn.init.constant_(self.offset_conv.weight, 0.)
        nn.init.constant_(self.offset_conv.bias, 0.)

        self.modulator_conv = nn.Conv2d(in_channels,1 * kernel_size * kernel_size,
                                        kernel_size=kernel_size,stride=stride,
                                        padding=padding,dilation=dilation
                                        )

        nn.init.constant_(self.modulator_conv.weight, 0.)
        nn.init.constant_(self.modulator_conv.bias, 0.)

        self.decov2d=DeformConv2d(in_channels,out_channels,
                                  kernel_size=kernel_size,stride=stride,
                                  padding=padding,dilation=dilation)


    def forward(self, x):

        offset = self.offset_conv(x)
        modulator = torch.sigmoid(self.modulator_conv(x))
        x=self.decov2d(x,offset,modulator)
        return x

class DeformRoIpoolV2(nn.Module):
    def __init__(self, in_channels, out_channels, kernel_size=3, stride=1, padding=1):
        super(DeformRoIpoolV2, self).__init__()
        self.offset_conv = nn.Conv2d(in_channels,2 * kernel_size * kernel_size,
                                     kernel_size=kernel_size,
                                     stride=stride,padding=padding,
                                     )

        nn.init.constant_(self.offset_conv.weight, 0.)
        nn.init.constant_(self.offset_conv.bias, 0.)

        self.modulator_conv = nn.Conv2d(in_channels,1 * kernel_size * kernel_size,
                                        kernel_size=kernel_size,
                                        stride=stride,padding=padding,
                                        )

        nn.init.constant_(self.modulator_conv.weight, 0.)
        nn.init.constant_(self.modulator_conv.bias, 0.)


        self.decov2d=DeformConv2d(in_channels,out_channels,
                                  kernel_size=kernel_size,
                                  stride=stride,padding=padding)
    def forward(self, x):

        offset = self.offset_conv(x)
        modulator = torch.sigmoid(self.modulator_conv(x))
        x=self.decov2d(x,offset,modulator)

        return x

class DeformConv(nn.Module):
    def __init__(self, input_dim, output_dim, stride=1, padding=[1,1],dilation=[1,1]):
        super(DeformConv, self).__init__()

        self.double_conv_l = nn.Sequential(
            nn.Conv2d(input_dim, output_dim, kernel_size=3,stride=stride,padding=padding[0],dilation=dilation[0]),
            nn.BatchNorm2d(output_dim),
            nn.LeakyReLU(inplace=True),
            DeformConv_V2(output_dim, output_dim, kernel_size=3, stride=stride, padding=padding[0],dilation=dilation[0]),

        )
        self.double_conv_r = nn.Sequential(
            nn.Conv2d(input_dim, output_dim, kernel_size=3,stride=stride,padding=padding[1],dilation=dilation[1]),
            nn.BatchNorm2d(output_dim),
            nn.LeakyReLU(inplace=True),
            DeformConv_V2(output_dim, output_dim, kernel_size=3, stride=stride, padding=padding[1],dilation=dilation[1]),

        )
        self.combine_cov=nn.Sequential(
            nn.Conv2d(2*output_dim,output_dim,1),
            nn.BatchNorm2d(output_dim),
            nn.LeakyReLU(inplace=True)
        )

        self.conv_skip = nn.Sequential(
            nn.Conv2d(input_dim, output_dim, kernel_size=1),#图像大小减半，保证跳跃连接大小一致
            nn.BatchNorm2d(output_dim)
        )

    def forward(self, x):
        x1= self.double_conv_l(x)
        x2=self.double_conv_r(x)
        x3=self.combine_cov(torch.cat([x1, x2], dim=1))
        x4=self.conv_skip(x)

        return x3+x4

class Down(nn.Module):
    def __init__(self):
        super().__init__()
        self.maxpool_conv =nn.MaxPool2d(2)


    def forward(self, x):
        return self.maxpool_conv(x)


class ECA(nn.Module):

    def __init__(self, channel, k_size=3):
        super(ECA, self).__init__()
        self.avg_pool = nn.AdaptiveAvgPool2d(1)
        self.conv = nn.Conv1d(1, 1, kernel_size=k_size, padding=(k_size - 1) // 2, bias=False)
        self.sigmoid = nn.Sigmoid()

    def forward(self, x):
        # feature descriptor on the global spatial information
        y = self.avg_pool(x)#b,c,1,1

        # Two different branches of ECA module///b,c,1->b,1,c->b,c,1->b,c,1,1
        y = self.conv(y.squeeze(-1).transpose(-1, -2)).transpose(-1, -2).unsqueeze(-1)

        # Multi-scale information fusion
        y = self.sigmoid(y)

        return x * y.expand_as(x)

class PAM_Module(nn.Module):
    """ Position attention module"""
    #Ref from SAGAN
    def __init__(self, in_dim):
        super(PAM_Module, self).__init__()
        self.chanel_in = in_dim

        self.query_conv = nn.Conv2d(in_channels=in_dim, out_channels=in_dim//8, kernel_size=1)
        self.key_conv = nn.Conv2d(in_channels=in_dim, out_channels=in_dim//8, kernel_size=1)
        self.value_conv = nn.Conv2d(in_channels=in_dim, out_channels=in_dim, kernel_size=1)
        self.gamma = nn.Parameter(torch.zeros(1))

        self.softmax = nn.Softmax(dim=-1)
    def forward(self, x):
        """
            inputs :
                x : input feature maps( B X C X H X W)
            returns :
                out : attention value + input feature
                attention: B X (HxW) X (HxW)
        """
        m_batchsize, C, height, width = x.size()
        proj_query = self.query_conv(x).view(m_batchsize, -1, width*height).permute(0, 2, 1)
        proj_key = self.key_conv(x).view(m_batchsize, -1, width*height)
        energy = torch.bmm(proj_query, proj_key)#乘法
        attention = self.softmax(energy)
        proj_value = self.value_conv(x).view(m_batchsize, -1, width*height)

        out = torch.bmm(proj_value, attention.permute(0, 2, 1))
        out = out.view(m_batchsize, C, height, width)

        out = self.gamma*out + x
        return out


class CAM_Module(nn.Module):
    """ Channel attention module"""
    def __init__(self, in_dim):
        super(CAM_Module, self).__init__()
        self.chanel_in = in_dim


        self.gamma = nn.Parameter(torch.zeros(1))
        self.softmax  = nn.Softmax(dim=-1)
    def forward(self,x):
        """
            inputs :
                x : input feature maps( B X C X H X W)
            returns :
                out : attention value + input feature
                attention: B X C X C
        """
        m_batchsize, C, height, width = x.size()
        proj_query = x.view(m_batchsize, C, -1)
        proj_key = x.view(m_batchsize, C, -1).permute(0, 2, 1)
        energy = torch.bmm(proj_query, proj_key)
        energy_new = torch.max(energy, -1, keepdim=True)[0].expand_as(energy)-energy
        attention = self.softmax(energy_new)
        proj_value = x.view(m_batchsize, C, -1)

        out = torch.bmm(attention, proj_value)
        out = out.view(m_batchsize, C, height, width)

        out = self.gamma*out + x
        return out



class SE(nn.Module):
    def __init__(self,input_channels,reduction=4):
        super(SE,self).__init__()
        self.avgpool = nn.AdaptiveAvgPool2d(1)
        self.fc1 = nn.Conv2d(input_channels, input_channels//reduction, 1)
        self.fc2 = nn.Conv2d(input_channels//reduction, input_channels, 1)
        self.activation = nn.ReLU(inplace=True)
        self.scale_activation = nn.Hardsigmoid(inplace=True)
        self._init_weights()

    def forward(self, input):
        x=self.avgpool(input)
        x=self.fc1(x)
        x=self.activation(x)
        x=self.fc2(x)
        x=self.scale_activation(x)
        return x*input

    def _init_weights(self):
        for m in self.modules():
            if isinstance(m, nn.Conv2d):
                nn.init.kaiming_normal_(m.weight)
            elif isinstance(m, nn.BatchNorm2d):
                m.weight.data.fill_(1)
                m.bias.data.zero_()


class SPBlock(nn.Module):#Strip Pooling
    def __init__(self, inplanes, outplanes, norm_layer=None):
        super(SPBlock, self).__init__()
        midplanes = outplanes
        self.conv1 = nn.Conv2d(inplanes, midplanes, kernel_size=(3, 1), padding=(1, 0), bias=False)

        self.bn1 = nn.BatchNorm2d(midplanes)
        self.conv2 = nn.Conv2d(inplanes, midplanes, kernel_size=(1, 3), padding=(0, 1), bias=False)
        self.bn2 = nn.BatchNorm2d(midplanes)
        self.conv3 = nn.Conv2d(midplanes, outplanes, kernel_size=1, bias=True)
        self.pool1 = nn.AdaptiveAvgPool2d((None, 1))
        self.pool2 = nn.AdaptiveAvgPool2d((1, None))
        self.relu = nn.ReLU(inplace=False)

    def forward(self, x):
        _, _, h, w = x.size()
        x1 = self.pool1(x)
        x1 = self.conv1(x1)
        x1 = self.bn1(x1)
        x1 = x1.expand(-1, -1, h, w)
        #x1 = F.interpolate(x1, (h, w))

        x2 = self.pool2(x)
        x2 = self.conv2(x2)
        x2 = self.bn2(x2)
        x2 = x2.expand(-1, -1, h, w)
        #x2 = F.interpolate(x2, (h, w))

        x3 = self.relu(x1 + x2)
        x3 = self.conv3(x3).sigmoid()
        return x*x3


class StripPooling(nn.Module):
    """
    Reference:
    """
    def __init__(self, in_channels, pool_size, norm_layer, up_kwargs):
        super(StripPooling, self).__init__()
        self.pool1 = nn.AdaptiveAvgPool2d(pool_size[0])
        self.pool2 = nn.AdaptiveAvgPool2d(pool_size[1])
        self.pool3 = nn.AdaptiveAvgPool2d((1, None))
        self.pool4 = nn.AdaptiveAvgPool2d((None, 1))

        inter_channels = int(in_channels/4)
        self.conv1_1 = nn.Sequential(nn.Conv2d(in_channels, inter_channels, 1, bias=False),
                                nn.BatchNorm2d(inter_channels),
                                nn.ReLU(True))
        self.conv1_2 = nn.Sequential(nn.Conv2d(in_channels, inter_channels, 1, bias=False),
                                norm_layer(inter_channels),
                                nn.ReLU(True))
        self.conv2_0 = nn.Sequential(nn.Conv2d(inter_channels, inter_channels, 3, 1, 1, bias=False),
                                     nn.BatchNorm2d(inter_channels))
        self.conv2_1 = nn.Sequential(nn.Conv2d(inter_channels, inter_channels, 3, 1, 1, bias=False),
                                     nn.BatchNorm2d(inter_channels))
        self.conv2_2 = nn.Sequential(nn.Conv2d(inter_channels, inter_channels, 3, 1, 1, bias=False),
                                nn.BatchNorm2d(inter_channels))
        self.conv2_3 = nn.Sequential(nn.Conv2d(inter_channels, inter_channels, (1, 3), 1, (0, 1), bias=False),
                                nn.BatchNorm2d(inter_channels))
        self.conv2_4 = nn.Sequential(nn.Conv2d(inter_channels, inter_channels, (3, 1), 1, (1, 0), bias=False),
                                nn.BatchNorm2d(inter_channels))
        self.conv2_5 = nn.Sequential(nn.Conv2d(inter_channels, inter_channels, 3, 1, 1, bias=False),
                                nn.BatchNorm2d(inter_channels),
                                nn.ReLU(True))
        self.conv2_6 = nn.Sequential(nn.Conv2d(inter_channels, inter_channels, 3, 1, 1, bias=False),
                                nn.BatchNorm2d(inter_channels),
                                nn.ReLU(True))
        self.conv3 = nn.Sequential(nn.Conv2d(inter_channels*2, in_channels, 1, bias=False),
                                nn.BatchNorm2d(inter_channels))
        # bilinear interpolate options
        self._up_kwargs = up_kwargs

    def forward(self, x):
        _, _, h, w = x.size()
        x1 = self.conv1_1(x)
        x2 = self.conv1_2(x)
        x2_1 = self.conv2_0(x1)
        x2_2 = F.interpolate(self.conv2_1(self.pool1(x1)), (h, w), **self._up_kwargs)
        x2_3 = F.interpolate(self.conv2_2(self.pool2(x1)), (h, w), **self._up_kwargs)
        x2_4 = F.interpolate(self.conv2_3(self.pool3(x2)), (h, w), **self._up_kwargs)
        x2_5 = F.interpolate(self.conv2_4(self.pool4(x2)), (h, w), **self._up_kwargs)
        x1 = self.conv2_5(F.relu_(x2_1 + x2_2 + x2_3))
        x2 = self.conv2_6(F.relu_(x2_5 + x2_4))
        out = self.conv3(torch.cat([x1, x2], dim=1))
        return F.relu_(x + out)

class connectionfuse(nn.Module):
    def __init__(self, in_channels, out_channels):
        super(connectionfuse, self).__init__()
        self.conv = nn.Sequential(
                                nn.Conv2d(in_channels, out_channels, 1),
                                nn.BatchNorm2d(out_channels),
                                nn.Hardswish(True),
                                )

    def forward(self, x1,x2):
        x=torch.cat([x1,x2],dim=1)
        x= self.conv(x)
        return x

class My_ASPP(nn.Module):
    def __init__(self, in_dims, out_dims, rate=[1, 6, 12, 18]):
        super(My_ASPP, self).__init__()

        self.aspp_block1 = nn.Sequential(
            nn.Conv2d(in_dims, out_dims, 3, stride=1, padding=rate[0], dilation=rate[0]),
            nn.ReLU(inplace=True),
            nn.BatchNorm2d(out_dims),
        )
        self.aspp_block2 = nn.Sequential(
            nn.Conv2d(in_dims, out_dims, 3, stride=1, padding=rate[1], dilation=rate[1]),
            nn.ReLU(inplace=True),
            nn.BatchNorm2d(out_dims),
        )
        self.aspp_block3 = nn.Sequential(
            nn.Conv2d(in_dims, out_dims, 3, stride=1, padding=rate[2], dilation=rate[2]),
            nn.ReLU(inplace=True),
            nn.BatchNorm2d(out_dims),
        )
        self.aspp_block4 = nn.Sequential(
            nn.Conv2d(in_dims, out_dims, 3, stride=1, padding=rate[3], dilation=rate[3]),
            nn.ReLU(inplace=True),
            nn.BatchNorm2d(out_dims),
        )

        self.global_avg_pool = nn.Sequential(nn.AdaptiveAvgPool2d((1, 1)),#输出1*1的特征图
                                             nn.Conv2d(in_dims, out_dims, 1, stride=1),#1*1的卷积
                                             nn.BatchNorm2d(out_dims),
                                             nn.ReLU(inplace=True))
        self.output = nn.Sequential(nn.Conv2d((len(rate)+1) * out_dims, out_dims, 1),
                                    nn.BatchNorm2d(out_dims),
                                    nn.ReLU(inplace=True)
                                    )
        self._init_weights()

    def forward(self, x):
        x1 = self.aspp_block1(x)
        x2 = self.aspp_block2(x)
        x3 = self.aspp_block3(x)
        x4 = self.aspp_block4(x)
        x5 = self.global_avg_pool(x)
        x5 = F.interpolate(x5, size=x4.size()[2:], mode='bilinear', align_corners=True)  # 自适应全局池化需要上采样
        out = torch.cat([x1, x2, x3,x4,x5], dim=1)
        return self.output(out)

    def _init_weights(self):
        for m in self.modules():
            if isinstance(m, nn.Conv2d):
                nn.init.kaiming_normal_(m.weight)
            elif isinstance(m, nn.BatchNorm2d):
                m.weight.data.fill_(1)
                m.bias.data.zero_()



class Up(nn.Module):
    def __init__(self, input_decoder, output_dim):
        super(Up, self).__init__()
        self.conv_decoder = nn.Sequential(
            nn.ConvTranspose2d(input_decoder, output_dim, kernel_size=2, stride=2, padding=0),
            nn.BatchNorm2d(output_dim),
            nn.ReLU(),
        )
    def forward(self, x):
        x= self.conv_decoder(x)
        return x

class Carafe_Up(nn.Module):
    def __init__(self, input_decoder, output_dim,compressed_channels=64,scale_factor=2):
        super(Carafe_Up, self).__init__()
        self.carafe_up = nn.Sequential(nn.BatchNorm2d(input_decoder),
                                       nn.ReLU(inplace=True),

                                       CARAFEPack(input_decoder,scale_factor=scale_factor,compressed_channels=compressed_channels),
                                       nn.Conv2d(input_decoder, output_dim, 1),
                                       )
    def forward(self, x):
        x= self.carafe_up(x)
        return x



class MyAttentionBlock(nn.Module):
    def __init__(self, input_encoder, input_decoder, output_dim):
        super(MyAttentionBlock, self).__init__()

        # self.conv_encoder = nn.Sequential(
        #     nn.Conv2d(input_encoder, output_dim, 3, padding=1),
        #     nn.BatchNorm2d(output_dim),
        #     nn.ReLU()
        # )

        self.conv_decoder = nn.Sequential(
            nn.ConvTranspose2d(input_decoder, output_dim, kernel_size=2, stride=2, padding=0),
            nn.BatchNorm2d(output_dim),
            nn.ReLU(),
        )

        #self.nonlocal_attention=NONLocalBlock2D(output_dim)

        # self.conv_attn = nn.Sequential(
        #     nn.Conv2d(output_dim, 1, 1),
        #     nn.BatchNorm2d(output_dim),
        #     nn.ReLU(),
        # )

    def forward(self, x1, x2):
        x =x1 + self.conv_decoder(x2)
        out=self.nonlocal_attention(x)
        return out


class PPM(nn.Module):#PSP-Net
    def __init__(self, in_dim, reduction_dim, bins):
        super(PPM, self).__init__()
        self.features = []
        for bin in bins:
            self.features.append(nn.Sequential(
                nn.AdaptiveAvgPool2d(bin),
                nn.Conv2d(in_dim, reduction_dim, kernel_size=1, bias=False),
                nn.BatchNorm2d(reduction_dim),
                nn.ReLU(inplace=True)
            ))
        self.features = nn.ModuleList(self.features)

    def forward(self, x):
        x_size = x.size()
        out = [x]
        for f in self.features:
            out.append(F.interpolate(f(x), x_size[2:], mode='bilinear', align_corners=True))
        return torch.cat(out, 1)

class CSE(nn.Module):
	def __init__(self, c, r=16):
		super().__init__()
		hidden = max(c // r, 8)
		self.net = nn.Sequential(
			nn.AdaptiveAvgPool2d(1),
			nn.Conv2d(c, hidden, 1),
			nn.ReLU(inplace=True),
			nn.Conv2d(hidden, c, 1),
			nn.Sigmoid()
		)
	def forward(self, x):
		return x * self.net(x)
	
class SSE(nn.Module):
	def __init__(self, c):
		super().__init__()
		self.net = nn.Sequential(nn.Conv2d(c, 1, 1), nn.Sigmoid())
	def forward(self, x):
		return x * self.net(x)
	
class ScSE(nn.Module):
	def __init__(self, c, r=16, mode="max"):
		super().__init__()
		self.cse = CSE(c, r)
		self.sse = SSE(c)
		self.mode = mode

	def forward(self, x):
		a = self.cse(x)
		b = self.sse(x)
		if self.mode == "max":
			return torch.max(a, b)
		return a + b

class CBAM(nn.Module):
    def __init__(self, channel, reduction=16, spatial_kernel=7):
        super(CBAM, self).__init__()
        hidden = max(channel // reduction, 8)
        self.mlp = nn.Sequential(
            nn.Conv2d(channel, hidden, 1, bias=False),
            nn.ReLU(inplace=True),
            nn.Conv2d(hidden, channel, 1, bias=False),
        )
        self.channel_sigmoid = nn.Sigmoid()
        self.spatial = nn.Sequential(
            nn.Conv2d(2, 1, kernel_size=spatial_kernel, padding=spatial_kernel // 2, bias=False),
            nn.Sigmoid()
        )

    def forward(self, x):
        avg = torch.mean(x, dim=(2, 3), keepdim=True)
        mx, _ = torch.max(x, dim=2, keepdim=True)
        mx, _ = torch.max(mx, dim=3, keepdim=True)
        ch = self.channel_sigmoid(self.mlp(avg) + self.mlp(mx))
        x = x * ch
        avg_sp = torch.mean(x, dim=1, keepdim=True)
        max_sp, _ = torch.max(x, dim=1, keepdim=True)
        sp = self.spatial(torch.cat([avg_sp, max_sp], dim=1))
        return x * sp


class PSUp(nn.Module):
    """
    PixelShuffle upsample x2:
      1x1 conv -> PixelShuffle(2) -> 3x3 conv (refine)
    Input:  (B, c_in, H, W)
    Output: (B, c_out, 2H, 2W)
    """
    def __init__(self, c_in, c_out, r=2):
        super().__init__()
        assert r == 2, "This block is written for r=2; extend if needed."
        self.proj = nn.Conv2d(c_in, c_out * (r * r), kernel_size=1, padding=0, bias=True)
        self.ps = nn.PixelShuffle(r)
        self.refine = nn.Conv2d(c_out, c_out, kernel_size=3, padding=1, bias=True)

    def forward(self, x):
        x = self.proj(x)
        x = self.ps(x)
        x = self.refine(x)
        return x


class AdaptiveSkipFusion(nn.Module):
    """
    Adaptive Skip Fusion with Pyramid Pooling
    Sử dụng SE/CBAM có sẵn để giảm complexity
    """
    def __init__(self, in_channels=[16, 32, 64, 128, 256], out_channel=256, attention_type='se', target_index=-1):
        super(AdaptiveSkipFusion, self).__init__()
        self.target_index = target_index  # Index of feature to use as target size (0=first, -1=last, 1=second, etc.)
        
        # 1x1 convolutions to align channels
        self.channel_align = nn.ModuleList([
            nn.Conv2d(in_ch, out_channel, 1, bias=False) 
            for in_ch in in_channels
        ])
        
        # Learnable fusion weights (one for each scale)
        self.fusion_weights = nn.Parameter(torch.ones(len(in_channels)))
        
        # Sử dụng SE hoặc CBAM có sẵn
        if attention_type == 'se':
            self.attention = SE(out_channel * len(in_channels), 16)
        elif attention_type == 'cbam':
            self.attention = CBAM(out_channel * len(in_channels))
        else:
            self.attention = None
        
        # Final fusion convolution
        self.fuse_conv = nn.Sequential(
            nn.Conv2d(out_channel * len(in_channels), out_channel, 3, 1, 1),
            nn.BatchNorm2d(out_channel),
            nn.GELU()
        )
        
        # Initialize weights
        self._init_weights()
    
    def _init_weights(self):
        """Initialize weights for convolutions"""
        for m in self.modules():
            if isinstance(m, nn.Conv2d):
                nn.init.kaiming_normal_(m.weight, mode='fan_out', nonlinearity='relu')
                if m.bias is not None:
                    nn.init.constant_(m.bias, 0)
            elif isinstance(m, nn.BatchNorm2d):
                nn.init.constant_(m.weight, 1)
                nn.init.constant_(m.bias, 0)
        
    def forward(self, *features):
        """
        Args:
            features: tuple of feature maps from different scales
                     (x1, x2, x3, x4, x5) - smallest to largest
        Returns:
            fused feature map
        """
        # Use specified feature index to determine target size
        B, C, H, W = features[self.target_index].shape
        
        # Align all features to same channel dimension and spatial size
        aligned_features = []
        for i, feat in enumerate(features):
            feat_aligned = self.channel_align[i](feat)
            feat_resized = F.interpolate(feat_aligned, size=(H, W), 
                                        mode='bilinear', align_corners=True)
            aligned_features.append(feat_resized)
        
        # Apply learnable fusion weights
        fusion_weights = F.softmax(self.fusion_weights, dim=0)
        weighted_features = [feat * w for feat, w in zip(aligned_features, fusion_weights)]
        
        # Concatenate all features
        concat_features = torch.cat(weighted_features, dim=1)
        
        # Apply attention (SE or CBAM)
        if self.attention is not None:
            concat_features = self.attention(concat_features)
        
        # Final fusion
        output = self.fuse_conv(concat_features)
        
        return output
class LinearAttention(nn.Module):
    """
    Linear Attention with O(N) complexity instead of O(N^2)
    Efficient alternative to standard self-attention for global context
    """
    def __init__(self, dim, num_heads=8, qkv_bias=True, attn_drop=0., proj_drop=0.):
        super().__init__()
        assert dim % num_heads == 0, f"dim {dim} should be divided by num_heads {num_heads}."
        
        self.dim = dim
        self.num_heads = num_heads
        self.head_dim = dim // num_heads
        
        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.apply(self._init_weights)
    
    def _init_weights(self, m):
        if isinstance(m, nn.Linear):
            trunc_normal_(m.weight, std=.02)
            if 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)
    
    def forward(self, x):
        """
        Args:
            x: (B, N, C) tensor
        Returns:
            out: (B, N, C) tensor
        """
        B, N, C = x.shape
        qkv = self.qkv(x).reshape(B, N, 3, self.num_heads, self.head_dim).permute(2, 0, 3, 1, 4)
        q, k, v = qkv[0], qkv[1], qkv[2]  # (B, num_heads, N, head_dim)
        
        # Linear attention: softmax over feature dimension instead of spatial
        q = F.elu(q) + 1  # (B, num_heads, N, head_dim)
        k = F.elu(k) + 1  # (B, num_heads, N, head_dim)
        
        # Efficient computation: O(N) instead of O(N^2)
        # Compute K^T V first: (B, num_heads, head_dim, head_dim)
        k_cumsum = k.sum(dim=2, keepdim=True)  # Normalization
        context = k.transpose(-2, -1) @ v  # (B, num_heads, head_dim, head_dim)
        
        # Then Q @ (K^T V): (B, num_heads, N, head_dim)
        out = q @ context  # (B, num_heads, N, head_dim)
        
        # Normalize
        normalizer = q @ k_cumsum.transpose(-2, -1)  # (B, num_heads, N, 1)
        out = out / (normalizer + 1e-6)
        
        out = self.attn_drop(out)
        out = out.transpose(1, 2).reshape(B, N, C)
        out = self.proj(out)
        out = self.proj_drop(out)
        
        return out


class LinearAttentionModule(nn.Module):
    """
    LinearAttention-based module as GFT alternative
    Can be used as a drop-in replacement for GFT
    """
    def __init__(self, patchsize, img_size, in_channels, expand_ratios, out_channel, stride, num_heads):
        super(LinearAttentionModule, self).__init__()
        self.patchembedding = OverlapPatchEmbed(patchsize, img_size, in_channels, in_channels, stride)
        self.norm1 = nn.LayerNorm(in_channels)
        self.attention = LinearAttention(in_channels, num_heads)
        self.norm2 = nn.LayerNorm(in_channels)
        self.mlp = Mlp(in_channels, expand_ratios * in_channels, in_channels)
        self.conv = nn.Sequential(nn.Conv2d(in_channels, out_channel, 1))
    
    def forward(self, x):
        B, C, H, W = x.shape
        x_embedding = self.patchembedding(x)
        att = self.attention(self.norm1(x_embedding)) + x_embedding
        x = self.mlp(self.norm2(att)) + att
        x = x.reshape(B, H, W, -1).permute(0, 3, 1, 2).contiguous()
        x = self.conv(x)
        return x


class AxialAttention(nn.Module):
    """
    Axial Attention: Separates attention into height and width axes
    Reduces complexity from O(H²W²) to O(HW(H+W))
    Good for global context with skip connections
    """
    def __init__(self, dim, num_heads=8, qkv_bias=True, attn_drop=0., proj_drop=0., axis='height'):
        super().__init__()
        assert dim % num_heads == 0, f"dim {dim} should be divided by num_heads {num_heads}."
        assert axis in ['height', 'width'], "axis must be 'height' or 'width'"
        
        self.dim = dim
        self.num_heads = num_heads
        self.head_dim = dim // num_heads
        self.scale = self.head_dim ** -0.5
        self.axis = axis
        
        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.apply(self._init_weights)
    
    def _init_weights(self, m):
        if isinstance(m, nn.Linear):
            trunc_normal_(m.weight, std=.02)
            if 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)
    
    def forward(self, x, H, W):
        """
        Args:
            x: (B, N, C) tensor where N = H * W
            H: height
            W: width
        Returns:
            out: (B, N, C) tensor
        """
        B, N, C = x.shape
        
        # Reshape to (B, H, W, C)
        x_2d = x.reshape(B, H, W, C)
        
        if self.axis == 'height':
            # Apply attention along height for each column
            # (B, H, W, C) -> (B*W, H, C)
            x_axis = x_2d.permute(0, 2, 1, 3).reshape(B * W, H, C)
        else:  # width
            # Apply attention along width for each row
            # (B, H, W, C) -> (B*H, W, C)
            x_axis = x_2d.permute(0, 1, 2, 3).reshape(B * H, W, C)
        
        # Standard attention on the selected axis
        BN, L, C = x_axis.shape
        qkv = self.qkv(x_axis).reshape(BN, L, 3, self.num_heads, self.head_dim).permute(2, 0, 3, 1, 4)
        q, k, v = qkv[0], qkv[1], qkv[2]
        
        attn = (q @ k.transpose(-2, -1)) * self.scale
        attn = attn.softmax(dim=-1)
        attn = self.attn_drop(attn)
        
        out_axis = (attn @ v).transpose(1, 2).reshape(BN, L, C)
        out_axis = self.proj(out_axis)
        out_axis = self.proj_drop(out_axis)
        
        # Reshape back
        if self.axis == 'height':
            # (B*W, H, C) -> (B, H, W, C) -> (B, N, C)
            out = out_axis.reshape(B, W, H, C).permute(0, 2, 1, 3).reshape(B, N, C)
        else:  # width
            # (B*H, W, C) -> (B, H, W, C) -> (B, N, C)
            out = out_axis.reshape(B, H, W, C).reshape(B, N, C)
        
        return out


class DualAxialAttention(nn.Module):
    """
    Dual Axial Attention: Combines height and width axis attention
    """
    def __init__(self, dim, num_heads=8, qkv_bias=True, attn_drop=0., proj_drop=0.):
        super().__init__()
        self.height_attn = AxialAttention(dim, num_heads, qkv_bias, attn_drop, proj_drop, axis='height')
        self.width_attn = AxialAttention(dim, num_heads, qkv_bias, attn_drop, proj_drop, axis='width')
    
    def forward(self, x, H, W):
        """
        Args:
            x: (B, N, C) tensor where N = H * W
            H: height
            W: width
        Returns:
            out: (B, N, C) tensor
        """
        # Apply height attention then width attention
        x = self.height_attn(x, H, W) + x
        x = self.width_attn(x, H, W) + x
        return x


class AxialAttentionModule(nn.Module):
    """
    AxialAttention-based module as GFT alternative
    Can be used as a drop-in replacement for GFT
    Better for global context + skip connections
    """
    def __init__(self, patchsize, img_size, in_channels, expand_ratios, out_channel, stride, num_heads):
        super(AxialAttentionModule, self).__init__()
        self.patchembedding = OverlapPatchEmbed(patchsize, img_size, in_channels, in_channels, stride)
        self.norm1 = nn.LayerNorm(in_channels)
        self.attention = DualAxialAttention(in_channels, num_heads)
        self.norm2 = nn.LayerNorm(in_channels)
        self.mlp = Mlp(in_channels, expand_ratios * in_channels, in_channels)
        self.conv = nn.Sequential(nn.Conv2d(in_channels, out_channel, 1))
        self.img_size = img_size
    
    def forward(self, x):
        B, C, H, W = x.shape
        x_embedding = self.patchembedding(x)  # (B, N, C)
        att = self.attention(self.norm1(x_embedding), H, W) + x_embedding
        x = self.mlp(self.norm2(att)) + att
        x = x.reshape(B, H, W, -1).permute(0, 3, 1, 2).contiguous()
        x = self.conv(x)
        return x


# Alias for Multi_Branch_Module
Multi_Branch_Module = ReparamConv