Upload 4 files

model/DCCS.py

@@ -0,0 +1,158 @@
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from thop import profile
+from model.auxiliary import VSSM
+import torch
+from model.LaSEA import *
+import torch
+import time
+from thop import profile
+class ChannelAttention(nn.Module):
+    def __init__(self, in_planes, ratio=16):
+        super(ChannelAttention, self).__init__()
+        self.avg_pool = nn.AdaptiveAvgPool2d(1)
+        self.max_pool = nn.AdaptiveMaxPool2d(1)
+        self.fc1 = nn.Conv2d(in_planes, in_planes // 16, 1, bias=False)
+        self.relu1 = nn.ReLU()
+        self.fc2 = nn.Conv2d(in_planes // 16, in_planes, 1, bias=False)
+        self.sigmoid = nn.Sigmoid()
+
+    def forward(self, x):
+        avg_out = self.fc2(self.relu1(self.fc1(self.avg_pool(x))))
+        max_out = self.fc2(self.relu1(self.fc1(self.max_pool(x))))
+        out = avg_out + max_out
+        return self.sigmoid(out)
+
+
+class SpatialAttention(nn.Module):
+    def __init__(self, kernel_size=7):
+        super(SpatialAttention, self).__init__()
+        assert kernel_size in (3, 7), 'kernel size must be 3 or 7'
+        padding = 3 if kernel_size == 7 else 1
+        self.conv1 = nn.Conv2d(2, 1, kernel_size, padding=padding, bias=False)
+        self.sigmoid = nn.Sigmoid()
+
+    def forward(self, x):
+        avg_out = torch.mean(x, dim=1, keepdim=True)
+        max_out, _ = torch.max(x, dim=1, keepdim=True)
+        x = torch.cat([avg_out, max_out], dim=1)
+        x = self.conv1(x)
+        return self.sigmoid(x)
+
+
+class ResNet(nn.Module):
+    def __init__(self, in_channels, out_channels, stride=1):
+        super(ResNet, self).__init__()
+        self.conv1 = nn.Conv2d(in_channels, out_channels, kernel_size=3, stride=stride, padding=1)
+        self.bn1 = nn.BatchNorm2d(out_channels)
+        self.relu = nn.ReLU(inplace=True)
+        self.conv2 = nn.Conv2d(out_channels, out_channels, kernel_size=3, padding=1)
+        self.bn2 = nn.BatchNorm2d(out_channels)
+        if stride != 1 or out_channels != in_channels:
+            self.shortcut = nn.Sequential(
+                nn.Conv2d(in_channels, out_channels, kernel_size=1, stride=stride),
+                nn.BatchNorm2d(out_channels))
+        else:
+            self.shortcut = None
+
+        self.ca = ChannelAttention(out_channels)
+        self.sa = SpatialAttention()
+
+    def forward(self, x):
+        residual = x
+        if self.shortcut is not None:
+            residual = self.shortcut(x)
+        out = self.conv1(x)
+        out = self.bn1(out)
+        out = self.relu(out)
+
+        out = self.conv2(out)
+        out = self.bn2(out)
+        out = self.ca(out) * out
+        out = self.sa(out) * out
+        out += residual
+        out = self.relu(out)
+        return out
+
+
+class DCCS(nn.Module):
+    def __init__(self, input_channels, block=ResNet):
+        super().__init__()
+        param_channels = [16, 32, 64, 128, 256]
+        param_blocks = [2, 2, 2, 2]
+        self.pool = nn.MaxPool2d(2, 2)
+        self.up = nn.Upsample(scale_factor=2, mode='bilinear', align_corners=True)
+        self.up_4 = nn.Upsample(scale_factor=4, mode='bilinear', align_corners=True)
+        self.up_8 = nn.Upsample(scale_factor=8, mode='bilinear', align_corners=True)
+        self.up_16 = nn.Upsample(scale_factor=4, mode='bilinear', align_corners=True)
+        self.conv_init = nn.Conv2d(input_channels, param_channels[0], 1, 1)
+        self.encoder_0 = self._make_layer(param_channels[0], param_channels[0], block)
+        self.encoder_1 = self._make_layer(param_channels[0], param_channels[1], block, param_blocks[0])
+        self.encoder_2 = self._make_layer(param_channels[1], param_channels[2], block, param_blocks[1])
+        self.encoder_3 = self._make_layer(param_channels[2], param_channels[3], block, param_blocks[2])
+
+        self.middle_layer = self._make_layer(param_channels[3], param_channels[4], block, param_blocks[3])
+
+        self.decoder_3 = self._make_layer(param_channels[3] + param_channels[4], param_channels[3], block,
+                                          param_blocks[2])
+        self.decoder_2 = self._make_layer(param_channels[2] + param_channels[3], param_channels[2], block,
+                                          param_blocks[1])
+        self.decoder_1 = self._make_layer(param_channels[1] + param_channels[2], param_channels[1], block,
+                                          param_blocks[0])
+        self.decoder_0 = self._make_layer(param_channels[0] + param_channels[1], param_channels[0], block)
+
+        self.output_0 = nn.Conv2d(param_channels[0], 1, 1)
+        self.output_1 = nn.Conv2d(param_channels[1], 1, 1)
+        self.output_2 = nn.Conv2d(param_channels[2], 1, 1)
+        self.output_3 = nn.Conv2d(param_channels[3], 1, 1)
+        self.final = nn.Conv2d(4, 1, 3, 1, 1)
+        self.VSSM = VSSM()
+        self.post_fuse3 = nn.Conv2d(param_channels[3] * 2, param_channels[3], kernel_size=1)
+        self.post_fuse2 = nn.Conv2d(param_channels[2] * 2, param_channels[2], kernel_size=1)
+        self.post_fuse1 = nn.Conv2d(param_channels[1] * 2, param_channels[1], kernel_size=1)
+        self.post_fuse0 = nn.Conv2d(param_channels[0] * 2, param_channels[0], kernel_size=1)
+        self.GLFA = GLFA(in_channels=256)
+    def _make_layer(self, in_channels, out_channels, block, block_num=1):
+        layer = []
+        layer.append(block(in_channels, out_channels))
+        for _ in range(block_num - 1):
+            layer.append(block(out_channels, out_channels))
+        return nn.Sequential(*layer)
+    def forward(self, x, warm_flag):
+        outputs = self.VSSM(x)
+        x_e0f = outputs[0].permute(0, 3, 1, 2).contiguous()
+        x_e1f = outputs[1].permute(0, 3, 1, 2).contiguous()
+        x_e2f = outputs[2].permute(0, 3, 1, 2).contiguous()
+        x_e3f = outputs[3].permute(0, 3, 1, 2).contiguous()
+        x_e0z = self.encoder_0(self.conv_init(x))
+        x_e0 = torch.cat([x_e0z, x_e0f], dim=1)
+        x_e0z = self.post_fuse0(x_e0)
+        x_e1z = self.encoder_1(self.pool(x_e0z))
+        x_e1_fused = torch.cat([x_e1z, x_e1f], dim=1)
+        x_e1z = self.post_fuse1(x_e1_fused)
+        x_e2z = self.encoder_2(self.pool(x_e1z))
+        x_e2_fused = torch.cat([x_e2z, x_e2f], dim=1)
+        x_e2z = self.post_fuse2(x_e2_fused)
+        x_e3z = self.encoder_3(self.pool(x_e2z))
+        x_e3_fused = torch.cat([x_e3z, x_e3f], dim=1)
+        x_e3z = self.post_fuse3(x_e3_fused)
+        x_m = self.middle_layer(self.pool(x_e3z))
+        x_m = self.GLFA(x_m)
+        x_d3 = self.decoder_3(torch.cat([x_e3z, self.up(x_m)], 1))
+        x_d2 = self.decoder_2(torch.cat([x_e2z, self.up(x_d3)], 1))
+        x_d1 = self.decoder_1(torch.cat([x_e1z, self.up(x_d2)], 1))
+        x_d0 = self.decoder_0(torch.cat([x_e0z, self.up(x_d1)], 1))
+
+        if warm_flag:
+            mask0 = self.output_0(x_d0)
+            mask1 = self.output_1(x_d1)
+            mask2 = self.output_2(x_d2)
+            mask3 = self.output_3(x_d3)
+            output = self.final(torch.cat([mask0, self.up(mask1), self.up_4(mask2), self.up_8(mask3)], dim=1))
+            return [mask0, mask1, mask2, mask3], output
+
+        else:
+            output = self.output_0(x_d0)
+            return [], output
+

model/LaSEA.py

@@ -0,0 +1,243 @@
+import torch
+import torch.nn as nn
+from typing import Optional, Callable, Union, Tuple, Any
+import torch
+from torch import nn, Tensor
+import numpy as np
+from typing import Optional
+import math
+from torch import nn
+
+def makeDivisible(v: float, divisor: int, min_value: Optional[int] = None) -> int:
+    if min_value is None:
+        min_value = divisor
+    new_v = max(min_value, int(v + divisor / 2) // divisor * divisor)
+    if new_v < 0.9 * v:
+        new_v += divisor
+    return new_v
+def callMethod(self, ElementName):
+    return getattr(self, ElementName)
+def setMethod(self, ElementName, ElementValue):
+    return setattr(self, ElementName, ElementValue)
+def shuffleTensor(Feature: Tensor, Mode: int=1) -> Tensor:
+    if isinstance(Feature, Tensor):
+        Feature = [Feature]
+    Indexs = None
+    Output = []
+    for f in Feature:
+        B, C, H, W = f.shape
+        if Mode == 1:
+            f = f.flatten(2)
+            if Indexs is None:
+                Indexs = torch.randperm(f.shape[-1], device=f.device)
+            f = f[:, :, Indexs.to(f.device)]
+            f = f.reshape(B, C, H, W)
+        else:
+            if Indexs is None:
+                Indexs = [torch.randperm(H, device=f.device),
+                          torch.randperm(W, device=f.device)]
+            f = f[:, :, Indexs[0].to(f.device)]
+            f = f[:, :, :, Indexs[1].to(f.device)]
+        Output.append(f)
+    return Output
+class AdaptiveAvgPool2d(nn.AdaptiveAvgPool2d):
+    def __init__(self, output_size: int or tuple=1):
+        super(AdaptiveAvgPool2d, self).__init__(output_size=output_size)
+
+    def profileModule(self, Input: Tensor):
+        Output = self.forward(Input)
+        return Output, 0.0, 0.0
+
+class AdaptiveMaxPool2d(nn.AdaptiveMaxPool2d):
+    def __init__(self, output_size: int or tuple=1):
+        super(AdaptiveMaxPool2d, self).__init__(output_size=output_size)
+
+    def profileModule(self, Input: Tensor):
+        Output = self.forward(Input)
+        return Output, 0.0, 0.0
+class BaseConv2d(nn.Module):
+    def __init__(
+            self,
+            in_channels: int,
+            out_channels: int,
+            kernel_size: int,
+            stride: Optional[int] = 1,
+            padding: Optional[int] = None,
+            groups: Optional[int] = 1,
+            bias: Optional[bool] = None,
+            BNorm: bool = False,
+            ActLayer: Optional[Callable[..., nn.Module]] = None,
+            dilation: int = 1,
+            Momentum: Optional[float] = 0.1,
+            **kwargs: Any
+    ) -> None:
+        super(BaseConv2d, self).__init__()
+        if padding is None:
+            padding = int((kernel_size - 1) // 2 * dilation)
+
+        if bias is None:
+            bias = not BNorm
+
+        self.in_channels = in_channels
+        self.out_channels = out_channels
+        self.kernel_size = kernel_size
+        self.stride = stride
+        self.padding = padding
+        self.groups = groups
+        self.bias = bias
+
+        self.Conv = nn.Conv2d(in_channels, out_channels,
+                              kernel_size, stride, padding, dilation, groups, bias, **kwargs)
+
+        self.Bn = nn.BatchNorm2d(out_channels, eps=0.001, momentum=Momentum) if BNorm else nn.Identity()
+
+        if ActLayer is not None:
+            if isinstance(list(ActLayer().named_modules())[0][1], nn.Sigmoid):
+                self.Act = ActLayer()
+            else:
+                self.Act = ActLayer(inplace=True)
+        else:
+            self.Act = ActLayer
+
+        self.apply(initWeight)
+
+    def forward(self, x: Tensor) -> Tensor:
+        x = self.Conv(x)
+        x = self.Bn(x)
+        if self.Act is not None:
+            x = self.Act(x)
+        return x
+
+NormLayerTuple = (
+    nn.BatchNorm1d,
+    nn.BatchNorm2d,
+    nn.SyncBatchNorm,
+    nn.LayerNorm,
+    nn.InstanceNorm1d,
+    nn.InstanceNorm2d,
+    nn.GroupNorm,
+    nn.BatchNorm3d,
+)
+def initWeight(Module):
+    if Module is None:
+        return
+    elif isinstance(Module, (nn.Conv2d, nn.Conv3d, nn.ConvTranspose2d)):
+        nn.init.kaiming_uniform_(Module.weight, a=math.sqrt(5))
+        if Module.bias is not None:
+            fan_in, _ = nn.init._calculate_fan_in_and_fan_out(Module.weight)
+            if fan_in != 0:
+                bound = 1 / math.sqrt(fan_in)
+                nn.init.uniform_(Module.bias, -bound, bound)
+    elif isinstance(Module, NormLayerTuple):
+        if Module.weight is not None:
+            nn.init.ones_(Module.weight)
+        if Module.bias is not None:
+            nn.init.zeros_(Module.bias)
+    elif isinstance(Module, nn.Linear):
+        nn.init.kaiming_uniform_(Module.weight, a=math.sqrt(5))
+        if Module.bias is not None:
+            fan_in, _ = nn.init._calculate_fan_in_and_fan_out(Module.weight)
+            bound = 1 / math.sqrt(fan_in) if fan_in > 0 else 0
+            nn.init.uniform_(Module.bias, -bound, bound)
+    elif isinstance(Module, (nn.Sequential, nn.ModuleList)):
+        for m in Module:
+            initWeight(m)
+    elif list(Module.children()):
+        for m in Module.children():
+            initWeight(m)
+class Attention(nn.Module):
+    def __init__(
+            self,
+            InChannels: int,
+            HidChannels: int = None,
+            SqueezeFactor: int = 4,
+            PoolRes: list = [1, 2, 3],
+            Act: Callable[..., nn.Module] = nn.ReLU,
+            ScaleAct: Callable[..., nn.Module] = nn.Sigmoid,
+            MoCOrder: bool = True,
+            **kwargs: Any,
+    ) -> None:
+        super().__init__()
+        if HidChannels is None:
+            HidChannels = max(makeDivisible(InChannels // SqueezeFactor, 8), 32)
+
+        AllPoolRes = PoolRes + [1] if 1 not in PoolRes else PoolRes
+        for k in AllPoolRes:
+            Pooling = AdaptiveAvgPool2d(k)
+            setMethod(self, 'Pool%d' % k, Pooling)
+
+        self.SELayer = nn.Sequential(
+            BaseConv2d(InChannels, HidChannels, 1, ActLayer=Act),
+            BaseConv2d(HidChannels, InChannels, 1, ActLayer=ScaleAct),
+        )
+
+        self.PoolRes = PoolRes
+        self.MoCOrder = MoCOrder
+
+    def RandomSample(self, x: Tensor) -> Tensor:
+        if self.training:
+            PoolKeep = np.random.choice(self.PoolRes)
+            x1 = shuffleTensor(x)[0] if self.MoCOrder else x
+            AttnMap: Tensor = callMethod(self, 'Pool%d' % PoolKeep)(x1)
+            if AttnMap.shape[-1] > 1:
+                AttnMap = AttnMap.flatten(2)
+                AttnMap = AttnMap[:, :, torch.randperm(AttnMap.shape[-1])[0]]
+                AttnMap = AttnMap[:, :, None, None]  # squeeze twice
+        else:
+            AttnMap: Tensor = callMethod(self, 'Pool%d' % 1)(x)
+
+        return AttnMap
+
+    def forward(self, x: Tensor) -> Tensor:
+        AttnMap = self.RandomSample(x)
+        return x * self.SELayer(AttnMap)
+
+def channel_shuffle(x, groups):
+    batchsize, num_channels, height, width = x.data.size()
+    channels_per_group = num_channels // groups
+    x = x.view(batchsize, groups, channels_per_group, height, width)
+    x = torch.transpose(x, 1, 2).contiguous()
+    x = x.view(batchsize, -1, height, width)
+    return x
+class GLFA(nn.Module):
+    def __init__(self, in_channels):
+        super(GLFA, self).__init__()
+        self.in_channels = in_channels
+        self.out_channels = in_channels
+        self.conv_1 = nn.Sequential(
+            nn.Conv2d(in_channels, in_channels, padding=1, kernel_size=3, dilation=1),
+            nn.BatchNorm2d(in_channels),
+            nn.ReLU(inplace=True)
+        )
+        self.conv_2 = nn.Sequential(
+            nn.Conv2d(in_channels, in_channels, padding=2, kernel_size=3, dilation=2),
+            nn.BatchNorm2d(in_channels),
+            nn.ReLU(inplace=True)
+        )
+        self.conv_3 = nn.Sequential(
+            nn.Conv2d(in_channels, in_channels, padding=3, kernel_size=3, dilation=3),
+            nn.BatchNorm2d(in_channels),
+            nn.ReLU(inplace=True)
+        )
+        self.conv_4 = nn.Sequential(
+            nn.Conv2d(in_channels, in_channels, padding=4, kernel_size=3, dilation=4),
+            nn.BatchNorm2d(in_channels),
+            nn.ReLU(inplace=True)
+        )
+        self.fuse = nn.Sequential(
+            nn.Conv2d(in_channels * 4, in_channels, kernel_size=1, padding=0),
+            nn.BatchNorm2d(in_channels),
+            nn.ReLU(inplace=True)
+        )
+        self.mca = Attention(InChannels=in_channels, HidChannels=16)
+    def forward(self, x):
+        d = x
+        c1 = self.conv_1(x)
+        c2 = self.conv_2(x)
+        c3 = self.conv_3(x)
+        c4 = self.conv_4(x)
+        cat = torch.cat([c1, c2, c3, c4], dim=1)
+        cat = channel_shuffle(cat, groups=4)
+        M= self.fuse(cat)  #
+        O = self.mca(M)
+        return O + d

model/auxiliary.py

@@ -0,0 +1,701 @@
+import time
+import math
+from functools import partial
+from typing import Optional, Callable
+from torch import Tensor
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+import torch.utils.checkpoint as checkpoint
+from einops import rearrange, repeat
+from timm.models.layers import DropPath, to_2tuple, trunc_normal_
+
+try:
+    from mamba_ssm.ops.selective_scan_interface import selective_scan_fn, selective_scan_ref
+except:
+    pass
+try:
+    from selective_scan import selective_scan_fn as selective_scan_fn_v1
+    from selective_scan import selective_scan_ref as selective_scan_ref_v1
+except:
+    pass
+
+DropPath.__repr__ = lambda self: f"timm.DropPath({self.drop_prob})"
+
+def flops_selective_scan_ref(B=1, L=256, D=768, N=16, with_D=True, with_Z=False, with_Group=True, with_complex=False):
+    """
+    u: r(B D L)
+    delta: r(B D L)
+    A: r(D N)
+    B: r(B N L)
+    C: r(B N L)
+    D: r(D)
+    z: r(B D L)
+    delta_bias: r(D), fp32
+
+    ignores:
+        [.float(), +, .softplus, .shape, new_zeros, repeat, stack, to(dtype), silu]
+    """
+    import numpy as np
+
+    # fvcore.nn.jit_handles
+    def get_flops_einsum(input_shapes, equation):
+        np_arrs = [np.zeros(s) for s in input_shapes]
+        optim = np.einsum_path(equation, *np_arrs, optimize="optimal")[1]
+        for line in optim.split("\n"):
+            if "optimized flop" in line.lower():
+                # divided by 2 because we count MAC (multiply-add counted as one flop)
+                flop = float(np.floor(float(line.split(":")[-1]) / 2))
+                return flop
+
+    assert not with_complex
+
+    flops = 0  # below code flops = 0
+    if False:
+        ...
+        """
+        dtype_in = u.dtype
+        u = u.float()
+        delta = delta.float()
+        if delta_bias is not None:
+            delta = delta + delta_bias[..., None].float()
+        if delta_softplus:
+            delta = F.softplus(delta)
+        batch, dim, dstate = u.shape[0], A.shape[0], A.shape[1]
+        is_variable_B = B.dim() >= 3
+        is_variable_C = C.dim() >= 3
+        if A.is_complex():
+            if is_variable_B:
+                B = torch.view_as_complex(rearrange(B.float(), "... (L two) -> ... L two", two=2))
+            if is_variable_C:
+                C = torch.view_as_complex(rearrange(C.float(), "... (L two) -> ... L two", two=2))
+        else:
+            B = B.float()
+            C = C.float()
+        x = A.new_zeros((batch, dim, dstate))
+        ys = []
+        """
+
+    flops += get_flops_einsum([[B, D, L], [D, N]], "bdl,dn->bdln")
+    if with_Group:
+        flops += get_flops_einsum([[B, D, L], [B, N, L], [B, D, L]], "bdl,bnl,bdl->bdln")
+    else:
+        flops += get_flops_einsum([[B, D, L], [B, D, N, L], [B, D, L]], "bdl,bdnl,bdl->bdln")
+    if False:
+        ...
+        """
+        deltaA = torch.exp(torch.einsum('bdl,dn->bdln', delta, A))
+        if not is_variable_B:
+            deltaB_u = torch.einsum('bdl,dn,bdl->bdln', delta, B, u)
+        else:
+            if B.dim() == 3:
+                deltaB_u = torch.einsum('bdl,bnl,bdl->bdln', delta, B, u)
+            else:
+                B = repeat(B, "B G N L -> B (G H) N L", H=dim // B.shape[1])
+                deltaB_u = torch.einsum('bdl,bdnl,bdl->bdln', delta, B, u)
+        if is_variable_C and C.dim() == 4:
+            C = repeat(C, "B G N L -> B (G H) N L", H=dim // C.shape[1])
+        last_state = None
+        """
+
+    in_for_flops = B * D * N
+    if with_Group:
+        in_for_flops += get_flops_einsum([[B, D, N], [B, D, N]], "bdn,bdn->bd")
+    else:
+        in_for_flops += get_flops_einsum([[B, D, N], [B, N]], "bdn,bn->bd")
+    flops += L * in_for_flops
+    if False:
+        ...
+        """
+        for i in range(u.shape[2]):
+            x = deltaA[:, :, i] * x + deltaB_u[:, :, i]
+            if not is_variable_C:
+                y = torch.einsum('bdn,dn->bd', x, C)
+            else:
+                if C.dim() == 3:
+                    y = torch.einsum('bdn,bn->bd', x, C[:, :, i])
+                else:
+                    y = torch.einsum('bdn,bdn->bd', x, C[:, :, :, i])
+            if i == u.shape[2] - 1:
+                last_state = x
+            if y.is_complex():
+                y = y.real * 2
+            ys.append(y)
+        y = torch.stack(ys, dim=2) # (batch dim L)
+        """
+
+    if with_D:
+        flops += B * D * L
+    if with_Z:
+        flops += B * D * L
+    if False:
+        ...
+    return flops
+class PatchEmbed2D(nn.Module):
+    def __init__(self, patch_size=4, in_chans=3, embed_dim=96, norm_layer=None, **kwargs):
+        super().__init__()
+        if isinstance(patch_size, int):
+            patch_size = (patch_size, patch_size)
+        self.proj = nn.Conv2d(in_chans, embed_dim, kernel_size=patch_size, stride=patch_size)
+        if norm_layer is not None:
+            self.norm = norm_layer(embed_dim)
+        else:
+            self.norm = None
+
+    def forward(self, x):
+        x = self.proj(x).permute(0, 2, 3, 1)
+        if self.norm is not None:
+            x = self.norm(x)
+        return x
+class PatchMerging2D(nn.Module):
+    def __init__(self, dim, norm_layer=nn.LayerNorm):
+        super().__init__()
+        self.dim = dim
+        self.reduction = nn.Linear(4 * dim, 2 * dim, bias=False)
+        self.norm = norm_layer(4 * dim)
+    def forward(self, x):  # x: [B, H, W, C]
+        B, H, W, C = x.shape
+        SHAPE_FIX = [-1, -1]
+        if (W % 2 != 0) or (H % 2 != 0):
+            print(f"Warning: x.shape {x.shape} is not even.", flush=True)
+            SHAPE_FIX[0] = H // 2
+            SHAPE_FIX[1] = W // 2
+        x0 = x[:, 0::2, 0::2, :]
+        x1 = x[:, 1::2, 0::2, :]
+        x2 = x[:, 0::2, 1::2, :]
+        x3 = x[:, 1::2, 1::2, :]
+        if SHAPE_FIX[0] > 0:
+            x0 = x0[:, :SHAPE_FIX[0], :SHAPE_FIX[1], :]
+            x1 = x1[:, :SHAPE_FIX[0], :SHAPE_FIX[1], :]
+            x2 = x2[:, :SHAPE_FIX[0], :SHAPE_FIX[1], :]
+            x3 = x3[:, :SHAPE_FIX[0], :SHAPE_FIX[1], :]
+        x = torch.cat([x0, x1, x2, x3], dim=-1)
+        x = self.norm(x)
+        x = self.reduction(x)
+        return x
+class PatchExpand2D(nn.Module):
+    def __init__(self, dim, dim_scale=2, norm_layer=nn.LayerNorm):
+        super().__init__()
+        self.dim = dim * 2
+        self.dim_scale = dim_scale
+        self.expand = nn.Linear(self.dim, dim_scale * self.dim, bias=False)
+        self.norm = norm_layer(self.dim // dim_scale)
+    def forward(self, x):
+        B, H, W, C = x.shape
+        x = self.expand(x)
+
+        x = rearrange(x, 'b h w (p1 p2 c)-> b (h p1) (w p2) c', p1=self.dim_scale, p2=self.dim_scale,
+                      c=C // self.dim_scale)
+        x = self.norm(x)
+        return x
+class Final_PatchExpand2D(nn.Module):
+    def __init__(self, dim, dim_scale=4, norm_layer=nn.LayerNorm):
+        super().__init__()
+        self.dim = dim
+        self.dim_scale = dim_scale
+        self.expand = nn.Linear(self.dim, dim_scale * self.dim, bias=False)
+        self.norm = norm_layer(self.dim // dim_scale)
+
+    def forward(self, x):
+        B, H, W, C = x.shape
+        x = self.expand(x)
+
+        x = rearrange(x, 'b h w (p1 p2 c)-> b (h p1) (w p2) c', p1=self.dim_scale, p2=self.dim_scale,
+                      c=C // self.dim_scale)
+        x = self.norm(x)
+
+        return x
+class SS2D(nn.Module):
+    def __init__(
+            self,
+            d_model,
+            d_state=16,
+            d_conv=3,
+            expand=2,
+            dt_rank="auto",
+            dt_min=0.001,
+            dt_max=0.1,
+            dt_init="random",
+            dt_scale=1.0,
+            dt_init_floor=1e-4,
+            dropout=0.,
+            conv_bias=True,
+            bias=False,
+            device=None,
+            dtype=None,
+            **kwargs,
+    ):
+        factory_kwargs = {"device": device, "dtype": dtype}
+        super().__init__()
+        self.d_model = d_model
+        self.d_state = d_state
+        self.d_conv = d_conv
+        self.expand = expand
+        self.d_inner = int(self.expand * self.d_model)
+        self.dt_rank = math.ceil(self.d_model / 16) if dt_rank == "auto" else dt_rank
+
+        self.in_proj = nn.Linear(self.d_model, self.d_inner * 2, bias=bias, **factory_kwargs)
+        self.conv2d = nn.Conv2d(
+            in_channels=self.d_inner,
+            out_channels=self.d_inner,
+            groups=self.d_inner,
+            bias=conv_bias,
+            kernel_size=d_conv,
+            padding=(d_conv - 1) // 2,
+            **factory_kwargs,
+        )
+        self.act = nn.SiLU()
+
+        self.x_proj = (
+            nn.Linear(self.d_inner, (self.dt_rank + self.d_state * 2), bias=False, **factory_kwargs),
+            nn.Linear(self.d_inner, (self.dt_rank + self.d_state * 2), bias=False, **factory_kwargs),
+            nn.Linear(self.d_inner, (self.dt_rank + self.d_state * 2), bias=False, **factory_kwargs),
+            nn.Linear(self.d_inner, (self.dt_rank + self.d_state * 2), bias=False, **factory_kwargs),
+        )
+        self.x_proj_weight = nn.Parameter(torch.stack([t.weight for t in self.x_proj], dim=0))  # (K=4, N, inner)
+        del self.x_proj
+
+        self.dt_projs = (
+            self.dt_init(self.dt_rank, self.d_inner, dt_scale, dt_init, dt_min, dt_max, dt_init_floor,
+                         **factory_kwargs),
+            self.dt_init(self.dt_rank, self.d_inner, dt_scale, dt_init, dt_min, dt_max, dt_init_floor,
+                         **factory_kwargs),
+            self.dt_init(self.dt_rank, self.d_inner, dt_scale, dt_init, dt_min, dt_max, dt_init_floor,
+                         **factory_kwargs),
+            self.dt_init(self.dt_rank, self.d_inner, dt_scale, dt_init, dt_min, dt_max, dt_init_floor,
+                         **factory_kwargs),
+        )
+        self.dt_projs_weight = nn.Parameter(torch.stack([t.weight for t in self.dt_projs], dim=0))  # (K=4, inner, rank)
+        self.dt_projs_bias = nn.Parameter(torch.stack([t.bias for t in self.dt_projs], dim=0))  # (K=4, inner)
+        del self.dt_projs
+
+        self.A_logs = self.A_log_init(self.d_state, self.d_inner, copies=4, merge=True)  # (K=4, D, N)
+        self.Ds = self.D_init(self.d_inner, copies=4, merge=True)  # (K=4, D, N)
+
+        # self.selective_scan = selective_scan_fn
+        self.forward_core = self.forward_corev0
+
+        self.out_norm = nn.LayerNorm(self.d_inner)
+        self.out_proj = nn.Linear(self.d_inner, self.d_model, bias=bias, **factory_kwargs)
+        self.dropout = nn.Dropout(dropout) if dropout > 0. else None
+        self.ChannelAttentionModule = ChannelAttentionModule(in_channels=self.d_inner)
+    @staticmethod
+    def dt_init(dt_rank, d_inner, dt_scale=1.0, dt_init="random", dt_min=0.001, dt_max=0.1, dt_init_floor=1e-4,
+                **factory_kwargs):
+        dt_proj = nn.Linear(dt_rank, d_inner, bias=True, **factory_kwargs)
+        dt_init_std = dt_rank ** -0.5 * dt_scale
+        if dt_init == "constant":
+            nn.init.constant_(dt_proj.weight, dt_init_std)
+        elif dt_init == "random":
+            nn.init.uniform_(dt_proj.weight, -dt_init_std, dt_init_std)
+        else:
+            raise NotImplementedError
+        dt = torch.exp(
+            torch.rand(d_inner, **factory_kwargs) * (math.log(dt_max) - math.log(dt_min))
+            + math.log(dt_min)
+        ).clamp(min=dt_init_floor)
+        inv_dt = dt + torch.log(-torch.expm1(-dt))
+        with torch.no_grad():
+            dt_proj.bias.copy_(inv_dt)
+        dt_proj.bias._no_reinit = True
+
+        return dt_proj
+
+    @staticmethod
+    def A_log_init(d_state, d_inner, copies=1, device=None, merge=True):
+        # S4D real initialization
+        A = repeat(
+            torch.arange(1, d_state + 1, dtype=torch.float32, device=device),
+            "n -> d n",
+            d=d_inner,
+        ).contiguous()
+        A_log = torch.log(A)  # Keep A_log in fp32
+        if copies > 1:
+            A_log = repeat(A_log, "d n -> r d n", r=copies)
+            if merge:
+                A_log = A_log.flatten(0, 1)
+        A_log = nn.Parameter(A_log)
+        A_log._no_weight_decay = True
+        return A_log
+
+    @staticmethod
+    def D_init(d_inner, copies=1, device=None, merge=True):
+        # D "skip" parameter
+        D = torch.ones(d_inner, device=device)
+        if copies > 1:
+            D = repeat(D, "n1 -> r n1", r=copies)
+            if merge:
+                D = D.flatten(0, 1)
+        D = nn.Parameter(D)  # Keep in fp32
+        D._no_weight_decay = True
+        return D
+
+    def forward_corev0(self, x: torch.Tensor):
+        self.selective_scan = selective_scan_fn
+
+        B, C, H, W = x.shape
+        L = H * W
+        K = 4
+
+        x_hwwh = torch.stack([x.view(B, -1, L), torch.transpose(x, dim0=2, dim1=3).contiguous().view(B, -1, L)],
+                             dim=1).view(B, 2, -1, L)
+        xs = torch.cat([x_hwwh, torch.flip(x_hwwh, dims=[-1])], dim=1)  # (b, k, d, l)
+
+        x_dbl = torch.einsum("b k d l, k c d -> b k c l", xs.view(B, K, -1, L), self.x_proj_weight)
+        # x_dbl = x_dbl + self.x_proj_bias.view(1, K, -1, 1)
+        dts, Bs, Cs = torch.split(x_dbl, [self.dt_rank, self.d_state, self.d_state], dim=2)
+        dts = torch.einsum("b k r l, k d r -> b k d l", dts.view(B, K, -1, L), self.dt_projs_weight)
+        # dts = dts + self.dt_projs_bias.view(1, K, -1, 1)
+
+        xs = xs.float().view(B, -1, L)  # (b, k * d, l)
+        dts = dts.contiguous().float().view(B, -1, L)  # (b, k * d, l)
+        Bs = Bs.float().view(B, K, -1, L)  # (b, k, d_state, l)
+        Cs = Cs.float().view(B, K, -1, L)  # (b, k, d_state, l)
+        Ds = self.Ds.float().view(-1)  # (k * d)
+        As = -torch.exp(self.A_logs.float()).view(-1, self.d_state)  # (k * d, d_state)
+        dt_projs_bias = self.dt_projs_bias.float().view(-1)  # (k * d)
+
+        out_y = self.selective_scan(
+            xs, dts,
+            As, Bs, Cs, Ds, z=None,
+            delta_bias=dt_projs_bias,
+            delta_softplus=True,
+            return_last_state=False,
+        ).view(B, K, -1, L)
+        assert out_y.dtype == torch.float
+
+        inv_y = torch.flip(out_y[:, 2:4], dims=[-1]).view(B, 2, -1, L)
+        wh_y = torch.transpose(out_y[:, 1].view(B, -1, W, H), dim0=2, dim1=3).contiguous().view(B, -1, L)
+        invwh_y = torch.transpose(inv_y[:, 1].view(B, -1, W, H), dim0=2, dim1=3).contiguous().view(B, -1, L)
+
+        return out_y[:, 0], inv_y[:, 0], wh_y, invwh_y
+    def forward_corev1(self, x: torch.Tensor):
+        self.selective_scan = selective_scan_fn_v1
+
+        B, C, H, W = x.shape
+        L = H * W
+        K = 4
+        x_hwwh = torch.stack([x.view(B, -1, L), torch.transpose(x, dim0=2, dim1=3).contiguous().view(B, -1, L)],
+                             dim=1).view(B, 2, -1, L)
+        xs = torch.cat([x_hwwh, torch.flip(x_hwwh, dims=[-1])], dim=1)
+
+        x_dbl = torch.einsum("b k d l, k c d -> b k c l", xs.view(B, K, -1, L), self.x_proj_weight)
+        dts, Bs, Cs = torch.split(x_dbl, [self.dt_rank, self.d_state, self.d_state], dim=2)
+        dts = torch.einsum("b k r l, k d r -> b k d l", dts.view(B, K, -1, L), self.dt_projs_weight)
+        xs = xs.float().view(B, -1, L)
+        dts = dts.contiguous().float().view(B, -1, L)
+        Bs = Bs.float().view(B, K, -1, L)
+        Cs = Cs.float().view(B, K, -1, L)
+        Ds = self.Ds.float().view(-1)
+        As = -torch.exp(self.A_logs.float()).view(-1, self.d_state)
+        dt_projs_bias = self.dt_projs_bias.float().view(-1)
+
+        out_y = self.selective_scan(
+            xs, dts,
+            As, Bs, Cs, Ds,
+            delta_bias=dt_projs_bias,
+            delta_softplus=True,
+        ).view(B, K, -1, L)
+        assert out_y.dtype == torch.float
+
+        inv_y = torch.flip(out_y[:, 2:4], dims=[-1]).view(B, 2, -1, L)
+        wh_y = torch.transpose(out_y[:, 1].view(B, -1, W, H), dim0=2, dim1=3).contiguous().view(B, -1, L)
+        invwh_y = torch.transpose(inv_y[:, 1].view(B, -1, W, H), dim0=2, dim1=3).contiguous().view(B, -1, L)
+
+        return out_y[:, 0], inv_y[:, 0], wh_y, invwh_y
+    def forward(self, a: torch.Tensor, **kwargs):
+        B, H, W, C = a.shape
+
+        xz = self.in_proj(a)
+        x, z = xz.chunk(2, dim=-1)
+        z = z.permute(0, 3, 1, 2)
+        z = self.ChannelAttentionModule(z) * z
+        z = z.permute(0, 2, 3, 1).contiguous()
+        x = x.permute(0, 3, 1, 2).contiguous()
+        x = self.act(self.conv2d(x))
+        y1, y2, y3, y4 = self.forward_core(x)
+        assert y1.dtype == torch.float32
+        y = y1 + y2 + y3 + y4
+        y = torch.transpose(y, dim0=1, dim1=2).contiguous().view(B, H, W, -1)
+        y = self.out_norm(y)
+        y = y * torch.nn.functional.silu(z)
+        out = self.out_proj(y)
+        if self.dropout is not None:
+            out = self.dropout(out)
+        return out+a
+def channel_shuffle(x: Tensor, groups: int) -> Tensor:
+    batch_size, height, width, num_channels = x.size()
+    channels_per_group = num_channels // groups
+    x = x.view(batch_size, height, width, groups, channels_per_group)
+    x = torch.transpose(x, 3, 4).contiguous()
+    x = x.view(batch_size, height, width, -1)
+    return x
+
+class ChannelAttentionModule(nn.Module):
+    def __init__(self, in_channels, reduction=4):
+        super(ChannelAttentionModule, self).__init__()
+        self.avg_pool = nn.AdaptiveAvgPool2d(1)
+        self.max_pool = nn.AdaptiveMaxPool2d(1)
+        self.fc = nn.Sequential(
+            nn.Conv2d(in_channels, in_channels // reduction, 1, bias=False),
+            nn.ReLU(inplace=True),
+            nn.Conv2d(in_channels // reduction, in_channels, 1, bias=False)
+        )
+        self.sigmoid = nn.Sigmoid()
+
+    def forward(self, x):
+        avg_out = self.fc(self.avg_pool(x))
+        max_out = self.fc(self.max_pool(x))
+        out = avg_out + max_out
+        return self.sigmoid(out)
+
+class SS_Conv_SSM(nn.Module):
+    def __init__(
+            self,
+            hidden_dim: int = 0,
+            drop_path: float = 0,
+            norm_layer: Callable[..., torch.nn.Module] = partial(nn.LayerNorm, eps=1e-6),
+            attn_drop_rate: float = 0,
+            d_state: int = 16,
+            **kwargs,
+    ):
+        super().__init__()
+        self.ln_1 = norm_layer(hidden_dim // 2)
+        self.self_attention = SS2D(d_model=hidden_dim // 2, dropout=attn_drop_rate, d_state=d_state, **kwargs)
+        self.drop_path = DropPath(drop_path)
+
+        self.conv33conv33conv11 = nn.Sequential(
+            nn.BatchNorm2d(hidden_dim // 2),
+            nn.Conv2d(in_channels=hidden_dim // 2, out_channels=hidden_dim // 2, kernel_size=3, stride=1, padding=1),
+            nn.BatchNorm2d(hidden_dim // 2),
+            nn.ReLU(),
+            nn.Conv2d(in_channels=hidden_dim // 2, out_channels=hidden_dim // 2, kernel_size=3, stride=1, padding=1),
+            nn.BatchNorm2d(hidden_dim // 2),
+            nn.ReLU(),
+            nn.Conv2d(in_channels=hidden_dim // 2, out_channels=hidden_dim // 2, kernel_size=1, stride=1),
+            nn.ReLU()
+        )
+        self.ChannelAttentionModule = ChannelAttentionModule(in_channels=hidden_dim // 2)
+    def forward(self, input: torch.Tensor):
+        input_left, input_right = input.chunk(2, dim=-1)
+        input_right = self.ln_1(input_right)
+        input_left = self.ln_1(input_left)
+        x = self.drop_path(self.self_attention(input_right))
+        b0 = input_left.permute(0, 3, 1, 2).contiguous()
+        b1 = self.conv33conv33conv11(b0)
+        b2 = self.ChannelAttentionModule(b0)
+        b1= b1.permute(0, 2, 3, 1).contiguous()
+        b2 = b2.permute(0, 2, 3, 1).contiguous()
+        input_left = b1 * b2
+        output1 = torch.cat((input_left, x), dim=-1)
+        output = channel_shuffle(output1, groups=2)
+        return output + input
+class VSSLayer(nn.Module):
+    """ A basic Swin Transformer layer for one stage.
+    Args:
+        dim (int): Number of input channels.
+        depth (int): Number of blocks.
+        drop (float, optional): Dropout rate. Default: 0.0
+        attn_drop (float, optional): Attention dropout rate. Default: 0.0
+        drop_path (float | tuple[float], optional): Stochastic depth rate. Default: 0.0
+        norm_layer (nn.Module, optional): Normalization layer. Default: nn.LayerNorm
+        downsample (nn.Module | None, optional): Downsample layer at the end of the layer. Default: None
+        use_checkpoint (bool): Whether to use checkpointing to save memory. Default: False.
+    """
+
+    def __init__(
+            self,
+            dim,
+            depth,
+            attn_drop=0.,
+            drop_path=0.,
+            norm_layer=nn.LayerNorm,
+            downsample=None,
+            use_checkpoint=False,
+            d_state=16,
+            **kwargs,
+    ):
+        super().__init__()
+        self.dim = dim
+        self.use_checkpoint = use_checkpoint
+
+        self.blocks = nn.ModuleList([
+            SS_Conv_SSM(
+                hidden_dim=dim,
+                drop_path=drop_path[i] if isinstance(drop_path, list) else drop_path,
+                norm_layer=norm_layer,
+                attn_drop_rate=attn_drop,
+                d_state=d_state,
+            )
+            for i in range(depth)])
+
+        if True:  # is this really applied? Yes, but been overriden later in VSSM!
+            def _init_weights(module: nn.Module):
+                for name, p in module.named_parameters():
+                    if name in ["out_proj.weight-881-1KESHIHUA QUANZHONG"]:
+                        p = p.clone().detach_()  # fake init, just to keep the seed ....
+                        nn.init.kaiming_uniform_(p, a=math.sqrt(5))
+
+            self.apply(_init_weights)
+
+        if downsample is not None:
+            self.downsample = downsample(dim=dim, norm_layer=norm_layer)
+        else:
+            self.downsample = None
+
+    def forward(self, x):
+        for blk in self.blocks:
+            if self.use_checkpoint:
+                x = checkpoint.checkpoint(blk, x)
+            else:
+                x = blk(x)
+
+        if self.downsample is not None:
+            x = self.downsample(x)
+
+        return x
+class VSSLayer_up(nn.Module):
+    """ A basic Swin Transformer layer for one stage.
+    Args:
+        dim (int): Number of input channels.
+        depth (int): Number of blocks.
+        drop (float, optional): Dropout rate. Default: 0.0
+        attn_drop (float, optional): Attention dropout rate. Default: 0.0
+        drop_path (float | tuple[float], optional): Stochastic depth rate. Default: 0.0
+        norm_layer (nn.Module, optional): Normalization layer. Default: nn.LayerNorm
+        downsample (nn.Module | None, optional): Downsample layer at the end of the layer. Default: None
+        use_checkpoint (bool): Whether to use checkpointing to save memory. Default: False.
+    """
+
+    def __init__(
+            self,
+            dim,
+            depth,
+            attn_drop=0.,
+            drop_path=0.,
+            norm_layer=nn.LayerNorm,
+            upsample=None,
+            use_checkpoint=False,
+            d_state=16,
+            **kwargs,
+    ):
+        super().__init__()
+        self.dim = dim
+        self.use_checkpoint = use_checkpoint
+
+        self.blocks = nn.ModuleList([
+            SS_Conv_SSM(
+                hidden_dim=dim,
+                drop_path=drop_path[i] if isinstance(drop_path, list) else drop_path,
+                norm_layer=norm_layer,
+                attn_drop_rate=attn_drop,
+                d_state=d_state,
+            )
+            for i in range(depth)])
+
+        if True:
+            def _init_weights(module: nn.Module):
+                for name, p in module.named_parameters():
+                    if name in ["out_proj.weight-881-1KESHIHUA QUANZHONG"]:
+                        p = p.clone().detach_()
+                        nn.init.kaiming_uniform_(p, a=math.sqrt(5))
+
+            self.apply(_init_weights)
+
+        if upsample is not None:
+            self.upsample = upsample(dim=dim, norm_layer=norm_layer)
+        else:
+            self.upsample = None
+
+    def forward(self, x):
+        if self.upsample is not None:
+            x = self.upsample(x)
+        for blk in self.blocks:
+            if self.use_checkpoint:
+                x = checkpoint.checkpoint(blk, x)
+            else:
+                x = blk(x)
+        return x
+class VSSM(nn.Module):
+    def __init__(self, patch_size=1, in_chans=3, num_classes=1, depths=[2, 2, 2, 2],
+                 dims=[16, 32, 64, 128], d_state=16, drop_rate=0.,
+                 attn_drop_rate=0., drop_path_rate=0.1,
+                 norm_layer=nn.LayerNorm, patch_norm=True,
+                 use_checkpoint=False, **kwargs):
+        super().__init__()
+        self.num_classes = num_classes
+        self.num_layers = len(depths)
+        self.embed_dim = dims[0]
+        self.num_features = dims[-1]
+        self.dims = dims
+        self.layer_outputs = []
+        self.patch_embed = PatchEmbed2D(patch_size=patch_size, in_chans=in_chans, embed_dim=self.embed_dim,
+                                        norm_layer=norm_layer if patch_norm else None)
+        self.ape = False
+        if self.ape:
+            self.patches_resolution = self.patch_embed.patches_resolution
+            self.absolute_pos_embed = nn.Parameter(torch.zeros(1, *self.patches_resolution, self.embed_dim))
+            trunc_normal_(self.absolute_pos_embed, std=.02)
+        self.pos_drop = nn.Dropout(p=drop_rate)
+
+        dpr = [x.item() for x in torch.linspace(0, drop_path_rate, sum(depths))]
+        self.layers = nn.ModuleList()
+        for i_layer in range(self.num_layers):
+            layer = VSSLayer(
+                dim=dims[i_layer],
+                depth=depths[i_layer],
+                d_state=math.ceil(dims[0] / 6) if d_state is None else d_state,
+                drop=drop_rate,
+                attn_drop=attn_drop_rate,
+                drop_path=dpr[sum(depths[:i_layer]):sum(depths[:i_layer + 1])],
+                norm_layer=norm_layer,
+                downsample=PatchMerging2D if (i_layer < self.num_layers - 1) else None,
+                use_checkpoint=use_checkpoint,
+            )
+            self.layers.append(layer)
+        self.avgpool = nn.AdaptiveAvgPool2d(1)
+        self.head = nn.Linear(self.num_features, num_classes) if num_classes > 0 else nn.Identity()
+
+        self.apply(self._init_weights)
+        for m in self.modules():
+            if isinstance(m, nn.Conv2d):
+                nn.init.kaiming_normal_(m.weight, mode='fan_out', nonlinearity='relu')
+
+    def _init_weights(self, m: nn.Module):
+        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)
+
+    @torch.jit.ignore
+    def no_weight_decay(self):
+        return {'absolute_pos_embed'}
+
+    @torch.jit.ignore
+    def no_weight_decay_keywords(self):
+        return {'relative_position_bias_table'}
+
+    def forward_backbone(self, x):
+        self.layer_outputs = []
+        x = self.patch_embed(x)
+        self.layer_outputs.append(x)
+
+        if self.ape:
+            x = x + self.absolute_pos_embed
+        x = self.pos_drop(x)
+
+        for layer in self.layers:
+            x = layer(x)
+            self.layer_outputs.append(x)
+        return self.layer_outputs
+
+    def forward(self, x, i=None):
+        outputs = self.forward_backbone(x)
+        if i is not None:
+            x = outputs[i]
+            x = x.permute(0, 3, 1, 2).contiguous()
+            return x
+        return outputs

model/loss.py

@@ -0,0 +1,123 @@
+import torch.nn as nn
+import numpy as np
+import torch
+import torch.nn.functional as F
+from skimage import measure
+
+
+def SoftIoULoss(pred, target):
+    pred = torch.sigmoid(pred)
+
+    smooth = 1
+
+    intersection = pred * target
+    intersection_sum = torch.sum(intersection, dim=(1, 2, 3))
+    pred_sum = torch.sum(pred, dim=(1, 2, 3))
+    target_sum = torch.sum(target, dim=(1, 2, 3))
+
+    loss = (intersection_sum + smooth) / \
+           (pred_sum + target_sum - intersection_sum + smooth)
+
+    loss = 1 - loss.mean()
+
+    return loss
+
+
+def Dice(pred, target, warm_epoch=1, epoch=1, layer=0):
+    pred = torch.sigmoid(pred)
+
+    smooth = 1
+
+    intersection = pred * target
+    intersection_sum = torch.sum(intersection, dim=(1, 2, 3))
+    pred_sum = torch.sum(pred, dim=(1, 2, 3))
+    target_sum = torch.sum(target, dim=(1, 2, 3))
+
+    loss = (2 * intersection_sum + smooth) / \
+           (pred_sum + target_sum + intersection_sum + smooth)
+
+    loss = 1 - loss.mean()
+
+    return loss
+
+
+class SLSIoULoss(nn.Module):
+    def __init__(self):
+        super(SLSIoULoss, self).__init__()
+
+    def forward(self, pred_log, target, warm_epoch, epoch, with_shape=True):
+        pred = torch.sigmoid(pred_log)
+        smooth = 0.0
+
+        intersection = pred * target
+
+        intersection_sum = torch.sum(intersection, dim=(1, 2, 3))
+        pred_sum = torch.sum(pred, dim=(1, 2, 3))
+        target_sum = torch.sum(target, dim=(1, 2, 3))
+
+        dis = torch.pow((pred_sum - target_sum) / 2, 2)
+
+        alpha = (torch.min(pred_sum, target_sum) + dis + smooth) / (torch.max(pred_sum, target_sum) + dis + smooth)
+
+        loss = (intersection_sum + smooth) / \
+               (pred_sum + target_sum - intersection_sum + smooth)
+        lloss = LLoss(pred, target)
+
+        if epoch > warm_epoch:
+            siou_loss = alpha * loss
+            if with_shape:
+                loss = 1 - siou_loss.mean() + lloss
+            else:
+                loss = 1 - siou_loss.mean()
+        else:
+            loss = 1 - loss.mean()
+        return loss
+
+
+def LLoss(pred, target):
+    loss = torch.tensor(0.0, requires_grad=True).to(pred)
+
+    patch_size = pred.shape[0]
+    h = pred.shape[2]
+    w = pred.shape[3]
+    x_index = torch.arange(0, w, 1).view(1, 1, w).repeat((1, h, 1)).to(pred) / w
+    y_index = torch.arange(0, h, 1).view(1, h, 1).repeat((1, 1, w)).to(pred) / h
+    smooth = 1e-8
+    for i in range(patch_size):
+        pred_centerx = (x_index * pred[i]).mean()
+        pred_centery = (y_index * pred[i]).mean()
+
+        target_centerx = (x_index * target[i]).mean()
+        target_centery = (y_index * target[i]).mean()
+
+        angle_loss = (4 / (torch.pi ** 2)) * (torch.square(torch.arctan((pred_centery) / (pred_centerx + smooth))
+                                                           - torch.arctan(
+            (target_centery) / (target_centerx + smooth))))
+
+        pred_length = torch.sqrt(pred_centerx * pred_centerx + pred_centery * pred_centery + smooth)
+        target_length = torch.sqrt(target_centerx * target_centerx + target_centery * target_centery + smooth)
+
+        length_loss = (torch.min(pred_length, target_length)) / (torch.max(pred_length, target_length) + smooth)
+
+        loss = loss + (1 - length_loss + angle_loss) / patch_size
+
+    return loss
+
+
+class AverageMeter(object):
+    """Computes and stores the average and current value"""
+
+    def __init__(self):
+        self.reset()
+
+    def reset(self):
+        self.val = 0
+        self.avg = 0
+        self.sum = 0
+        self.count = 0
+
+    def update(self, val, n=1):
+        self.val = val
+        self.sum += val * n
+        self.count += n
+        self.avg = self.sum / self.count