Add files using upload-large-folder tool

source_code/SegMamba/mamba/mamba_ssm/ops/selective_scan_interface.py

@@ -0,0 +1,709 @@
+# Copyright (c) 2023, Tri Dao, Albert Gu.
+
+import torch
+import torch.nn.functional as F
+from torch.cuda.amp import custom_bwd, custom_fwd
+
+from einops import rearrange, repeat
+
+from causal_conv1d import causal_conv1d_fn
+import causal_conv1d_cuda
+import selective_scan_cuda
+
+
+class SelectiveScanFn(torch.autograd.Function):
+
+    @staticmethod
+    def forward(ctx, u, delta, A, B, C, D=None, z=None, delta_bias=None, delta_softplus=False,
+                return_last_state=False):
+        if u.stride(-1) != 1:
+            u = u.contiguous()
+        if delta.stride(-1) != 1:
+            delta = delta.contiguous()
+        if D is not None:
+            D = D.contiguous()
+        if B.stride(-1) != 1:
+            B = B.contiguous()
+        if C.stride(-1) != 1:
+            C = C.contiguous()
+        if z is not None and z.stride(-1) != 1:
+            z = z.contiguous()
+        if B.dim() == 3:
+            B = rearrange(B, "b dstate l -> b 1 dstate l")
+            ctx.squeeze_B = True
+        if C.dim() == 3:
+            C = rearrange(C, "b dstate l -> b 1 dstate l")
+            ctx.squeeze_C = True
+        out, x, *rest = selective_scan_cuda.fwd(u, delta, A, B, C, D, z, delta_bias, delta_softplus)
+        ctx.delta_softplus = delta_softplus
+        ctx.has_z = z is not None
+        last_state = x[:, :, -1, 1::2]  # (batch, dim, dstate)
+        if not ctx.has_z:
+            ctx.save_for_backward(u, delta, A, B, C, D, delta_bias, x)
+            return out if not return_last_state else (out, last_state)
+        else:
+            ctx.save_for_backward(u, delta, A, B, C, D, z, delta_bias, x, out)
+            out_z = rest[0]
+            return out_z if not return_last_state else (out_z, last_state)
+
+    @staticmethod
+    def backward(ctx, dout, *args):
+        if not ctx.has_z:
+            u, delta, A, B, C, D, delta_bias, x = ctx.saved_tensors
+            z = None
+            out = None
+        else:
+            u, delta, A, B, C, D, z, delta_bias, x, out = ctx.saved_tensors
+        if dout.stride(-1) != 1:
+            dout = dout.contiguous()
+        # The kernel supports passing in a pre-allocated dz (e.g., in case we want to fuse the
+        # backward of selective_scan_cuda with the backward of chunk).
+        # Here we just pass in None and dz will be allocated in the C++ code.
+        du, ddelta, dA, dB, dC, dD, ddelta_bias, *rest = selective_scan_cuda.bwd(
+            u, delta, A, B, C, D, z, delta_bias, dout, x, out, None, ctx.delta_softplus,
+            False  # option to recompute out_z, not used here
+        )
+        dz = rest[0] if ctx.has_z else None
+        dB = dB.squeeze(1) if getattr(ctx, "squeeze_B", False) else dB
+        dC = dC.squeeze(1) if getattr(ctx, "squeeze_C", False) else dC
+        return (du, ddelta, dA, dB, dC,
+                dD if D is not None else None,
+                dz,
+                ddelta_bias if delta_bias is not None else None,
+                None,
+                None)
+
+
+def selective_scan_fn(u, delta, A, B, C, D=None, z=None, delta_bias=None, delta_softplus=False,
+                     return_last_state=False):
+    """if return_last_state is True, returns (out, last_state)
+    last_state has shape (batch, dim, dstate). Note that the gradient of the last state is
+    not considered in the backward pass.
+    """
+    return SelectiveScanFn.apply(u, delta, A, B, C, D, z, delta_bias, delta_softplus, return_last_state)
+
+
+def selective_scan_ref(u, delta, A, B, C, D=None, z=None, delta_bias=None, delta_softplus=False,
+                      return_last_state=False):
+    """
+    u: r(B D L)
+    delta: r(B D L)
+    A: c(D N) or r(D N)
+    B: c(D N) or r(B N L) or r(B N 2L) or r(B G N L) or (B G N L)
+    C: c(D N) or r(B N L) or r(B N 2L) or r(B G N L) or (B G N L)
+    D: r(D)
+    z: r(B D L)
+    delta_bias: r(D), fp32
+
+    out: r(B D L)
+    last_state (optional): r(B D dstate) or c(B D dstate)
+    """
+    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 = []
+    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
+    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)
+    out = y if D is None else y + u * rearrange(D, "d -> d 1")
+    if z is not None:
+        out = out * F.silu(z)
+    out = out.to(dtype=dtype_in)
+    return out if not return_last_state else (out, last_state)
+
+
+class MambaInnerFnNoOutProj(torch.autograd.Function):
+
+    @staticmethod
+    @custom_fwd
+    def forward(ctx, xz, conv1d_weight, conv1d_bias, x_proj_weight, delta_proj_weight,
+                A, B=None, C=None, D=None, delta_bias=None, B_proj_bias=None,
+                C_proj_bias=None, delta_softplus=True, checkpoint_lvl=1):
+        """
+             xz: (batch, dim, seqlen)
+        """
+        assert checkpoint_lvl in [0, 1]
+        L = xz.shape[-1]
+        delta_rank = delta_proj_weight.shape[1]
+        d_state = A.shape[-1] * (1 if not A.is_complex() else 2)
+        if torch.is_autocast_enabled():
+            x_proj_weight = x_proj_weight.to(dtype=torch.get_autocast_gpu_dtype())
+            delta_proj_weight = delta_proj_weight.to(dtype=torch.get_autocast_gpu_dtype())
+        if xz.stride(-1) != 1:
+            xz = xz.contiguous()
+        conv1d_weight = rearrange(conv1d_weight, "d 1 w -> d w")
+        x, z = xz.chunk(2, dim=1)
+        conv1d_bias = conv1d_bias.contiguous() if conv1d_bias is not None else None
+        conv1d_out = causal_conv1d_cuda.causal_conv1d_fwd(x, conv1d_weight, conv1d_bias, True)
+        # We're being very careful here about the layout, to avoid extra transposes.
+        # We want delta to have d as the slowest moving dimension
+        # and L as the fastest moving dimension, since those are what the ssm_scan kernel expects.
+        x_dbl = F.linear(rearrange(conv1d_out, 'b d l -> (b l) d'), x_proj_weight)  # (bl d)
+        delta = rearrange(delta_proj_weight @ x_dbl[:, :delta_rank].t(), "d (b l) -> b d l", l = L)
+        ctx.is_variable_B = B is None
+        ctx.is_variable_C = C is None
+        ctx.B_proj_bias_is_None = B_proj_bias is None
+        ctx.C_proj_bias_is_None = C_proj_bias is None
+        if B is None:  # variable B
+            B = x_dbl[:, delta_rank:delta_rank + d_state]  # (bl dstate)
+            if B_proj_bias is not None:
+                B = B + B_proj_bias.to(dtype=B.dtype)
+            if not A.is_complex():
+                # B = rearrange(B, "(b l) dstate -> b dstate l", l=L).contiguous()
+                B = rearrange(B, "(b l) dstate -> b 1 dstate l", l=L).contiguous()
+            else:
+                B = rearrange(B, "(b l) (dstate two) -> b 1 dstate (l two)", l=L, two=2).contiguous()
+        else:
+            if B.stride(-1) != 1:
+                B = B.contiguous()
+        if C is None:  # variable C
+            C = x_dbl[:, -d_state:]  # (bl dstate)
+            if C_proj_bias is not None:
+                C = C + C_proj_bias.to(dtype=C.dtype)
+            if not A.is_complex():
+                # C = rearrange(C, "(b l) dstate -> b dstate l", l=L).contiguous()
+                C = rearrange(C, "(b l) dstate -> b 1 dstate l", l=L).contiguous()
+            else:
+                C = rearrange(C, "(b l) (dstate two) -> b 1 dstate (l two)", l=L, two=2).contiguous()
+        else:
+            if C.stride(-1) != 1:
+                C = C.contiguous()
+        if D is not None:
+            D = D.contiguous()
+        out, scan_intermediates, out_z = selective_scan_cuda.fwd(
+            conv1d_out, delta, A, B, C, D, z, delta_bias, delta_softplus
+        )
+        ctx.delta_softplus = delta_softplus
+        ctx.checkpoint_lvl = checkpoint_lvl
+        if checkpoint_lvl >= 1:  # Will recompute conv1d_out and delta in the backward pass
+            conv1d_out, delta = None, None
+        ctx.save_for_backward(xz, conv1d_weight, conv1d_bias, x_dbl, x_proj_weight,
+                              delta_proj_weight, conv1d_out, delta,
+                              A, B, C, D, delta_bias, scan_intermediates, out)
+        # return rearrange(out_z, "b d l -> b l d")
+        return out_z
+
+    @staticmethod
+    @custom_bwd
+    def backward(ctx, dout):
+        # dout: (batch, seqlen, dim)
+        (xz, conv1d_weight, conv1d_bias, x_dbl, x_proj_weight, delta_proj_weight, 
+         conv1d_out, delta, A, B, C, D, delta_bias, scan_intermediates, out) = ctx.saved_tensors
+        L = xz.shape[-1]
+        delta_rank = delta_proj_weight.shape[1]
+        d_state = A.shape[-1] * (1 if not A.is_complex() else 2)
+        x, z = xz.chunk(2, dim=1)
+        if dout.stride(-1) != 1:
+            dout = dout.contiguous()
+        if ctx.checkpoint_lvl == 1:
+            conv1d_out = causal_conv1d_cuda.causal_conv1d_fwd(x, conv1d_weight, conv1d_bias, True)
+            delta = rearrange(delta_proj_weight @ x_dbl[:, :delta_rank].t(),
+                              "d (b l) -> b d l", l = L)
+        # The kernel supports passing in a pre-allocated dz (e.g., in case we want to fuse the
+        # backward of selective_scan_cuda with the backward of chunk).
+        dxz = torch.empty_like(xz)  # (batch, dim, seqlen)
+        dx, dz = dxz.chunk(2, dim=1)
+        # dout_y = rearrange(dout, "b l d -> b d l") # because no arrange at end of forward, so dout shape is b d l
+        dconv1d_out, ddelta, dA, dB, dC, dD, ddelta_bias, dz, out_z = selective_scan_cuda.bwd(
+            conv1d_out, delta, A, B, C, D, z, delta_bias, dout, scan_intermediates, out, dz,
+            ctx.delta_softplus,
+            True  # option to recompute out_z
+        )
+        dD = dD if D is not None else None
+        dx_dbl = torch.empty_like(x_dbl)
+        dB_proj_bias = None
+        if ctx.is_variable_B:
+            if not A.is_complex():
+                dB = rearrange(dB, "b 1 dstate l -> (b l) dstate").contiguous()
+            else:
+                dB = rearrange(dB, "b 1 dstate (l two) -> (b l) (dstate two)", two=2).contiguous()
+            dB_proj_bias = dB.sum(0) if not ctx.B_proj_bias_is_None else None
+            dx_dbl[:, delta_rank:delta_rank + d_state] = dB  # (bl d)
+            dB = None
+        dC_proj_bias = None
+        if ctx.is_variable_C:
+            if not A.is_complex():
+                dC = rearrange(dC, "b 1 dstate l -> (b l) dstate").contiguous()
+            else:
+                dC = rearrange(dC, "b 1 dstate (l two) -> (b l) (dstate two)", two=2).contiguous()
+            dC_proj_bias = dC.sum(0) if not ctx.C_proj_bias_is_None else None
+            dx_dbl[:, -d_state:] = dC  # (bl d)
+            dC = None
+        ddelta = rearrange(ddelta, "b d l -> d (b l)")
+        ddelta_proj_weight = torch.einsum("dB,Br->dr", ddelta, x_dbl[:, :delta_rank])
+        dx_dbl[:, :delta_rank] = torch.einsum("dB,dr->Br", ddelta, delta_proj_weight)
+        dconv1d_out = rearrange(dconv1d_out, "b d l -> d (b l)")
+        dx_proj_weight = torch.einsum("Br,Bd->rd", dx_dbl, rearrange(conv1d_out, "b d l -> (b l) d"))
+        dconv1d_out = torch.addmm(dconv1d_out, x_proj_weight.t(), dx_dbl.t(), out=dconv1d_out)
+        dconv1d_out = rearrange(dconv1d_out, "d (b l) -> b d l", b=x.shape[0], l=x.shape[-1])
+        # The kernel supports passing in a pre-allocated dx (e.g., in case we want to fuse the
+        # backward of conv1d with the backward of chunk).
+        dx, dconv1d_weight, dconv1d_bias = causal_conv1d_cuda.causal_conv1d_bwd(
+            x, conv1d_weight, conv1d_bias, dconv1d_out, dx, True
+        )
+        dconv1d_bias = dconv1d_bias if conv1d_bias is not None else None
+        dconv1d_weight = rearrange(dconv1d_weight, "d w -> d 1 w")
+        return (dxz, dconv1d_weight, dconv1d_bias, dx_proj_weight, ddelta_proj_weight,
+                dA, dB, dC, dD,
+                ddelta_bias if delta_bias is not None else None,
+                dB_proj_bias, dC_proj_bias, None)
+    
+
+class MambaInnerFn(torch.autograd.Function):
+
+    @staticmethod
+    @custom_fwd
+    def forward(ctx, xz, conv1d_weight, conv1d_bias, x_proj_weight, delta_proj_weight,
+                out_proj_weight, out_proj_bias,
+                A, B=None, C=None, D=None, delta_bias=None, B_proj_bias=None,
+                C_proj_bias=None, delta_softplus=True, checkpoint_lvl=1):
+        """
+             xz: (batch, dim, seqlen)
+        """
+        assert checkpoint_lvl in [0, 1]
+        L = xz.shape[-1]
+        delta_rank = delta_proj_weight.shape[1]
+        d_state = A.shape[-1] * (1 if not A.is_complex() else 2)
+        if torch.is_autocast_enabled():
+            x_proj_weight = x_proj_weight.to(dtype=torch.get_autocast_gpu_dtype())
+            delta_proj_weight = delta_proj_weight.to(dtype=torch.get_autocast_gpu_dtype())
+            out_proj_weight = out_proj_weight.to(dtype=torch.get_autocast_gpu_dtype())
+            out_proj_bias = (out_proj_bias.to(dtype=torch.get_autocast_gpu_dtype())
+                             if out_proj_bias is not None else None)
+        if xz.stride(-1) != 1:
+            xz = xz.contiguous()
+        conv1d_weight = rearrange(conv1d_weight, "d 1 w -> d w")
+        x, z = xz.chunk(2, dim=1)
+        conv1d_bias = conv1d_bias.contiguous() if conv1d_bias is not None else None
+        conv1d_out = causal_conv1d_cuda.causal_conv1d_fwd(x, conv1d_weight, conv1d_bias, True)
+        # We're being very careful here about the layout, to avoid extra transposes.
+        # We want delta to have d as the slowest moving dimension
+        # and L as the fastest moving dimension, since those are what the ssm_scan kernel expects.
+        x_dbl = F.linear(rearrange(conv1d_out, 'b d l -> (b l) d'), x_proj_weight)  # (bl d)
+        delta = rearrange(delta_proj_weight @ x_dbl[:, :delta_rank].t(), "d (b l) -> b d l", l = L)
+        ctx.is_variable_B = B is None
+        ctx.is_variable_C = C is None
+        ctx.B_proj_bias_is_None = B_proj_bias is None
+        ctx.C_proj_bias_is_None = C_proj_bias is None
+        if B is None:  # variable B
+            B = x_dbl[:, delta_rank:delta_rank + d_state]  # (bl dstate)
+            if B_proj_bias is not None:
+                B = B + B_proj_bias.to(dtype=B.dtype)
+            if not A.is_complex():
+                # B = rearrange(B, "(b l) dstate -> b dstate l", l=L).contiguous()
+                B = rearrange(B, "(b l) dstate -> b 1 dstate l", l=L).contiguous()
+            else:
+                B = rearrange(B, "(b l) (dstate two) -> b 1 dstate (l two)", l=L, two=2).contiguous()
+        else:
+            if B.stride(-1) != 1:
+                B = B.contiguous()
+        if C is None:  # variable C
+            C = x_dbl[:, -d_state:]  # (bl dstate)
+            if C_proj_bias is not None:
+                C = C + C_proj_bias.to(dtype=C.dtype)
+            if not A.is_complex():
+                # C = rearrange(C, "(b l) dstate -> b dstate l", l=L).contiguous()
+                C = rearrange(C, "(b l) dstate -> b 1 dstate l", l=L).contiguous()
+            else:
+                C = rearrange(C, "(b l) (dstate two) -> b 1 dstate (l two)", l=L, two=2).contiguous()
+        else:
+            if C.stride(-1) != 1:
+                C = C.contiguous()
+        if D is not None:
+            D = D.contiguous()
+        out, scan_intermediates, out_z = selective_scan_cuda.fwd(
+            conv1d_out, delta, A, B, C, D, z, delta_bias, delta_softplus
+        )
+        ctx.delta_softplus = delta_softplus
+        ctx.out_proj_bias_is_None = out_proj_bias is None
+        ctx.checkpoint_lvl = checkpoint_lvl
+        if checkpoint_lvl >= 1:  # Will recompute conv1d_out and delta in the backward pass
+            conv1d_out, delta = None, None
+        ctx.save_for_backward(xz, conv1d_weight, conv1d_bias, x_dbl, x_proj_weight,
+                              delta_proj_weight, out_proj_weight, conv1d_out, delta,
+                              A, B, C, D, delta_bias, scan_intermediates, out)
+        return F.linear(rearrange(out_z, "b d l -> b l d"), out_proj_weight, out_proj_bias)
+
+    @staticmethod
+    @custom_bwd
+    def backward(ctx, dout):
+        # dout: (batch, seqlen, dim)
+        (xz, conv1d_weight, conv1d_bias, x_dbl, x_proj_weight, delta_proj_weight, out_proj_weight,
+         conv1d_out, delta, A, B, C, D, delta_bias, scan_intermediates, out) = ctx.saved_tensors
+        L = xz.shape[-1]
+        delta_rank = delta_proj_weight.shape[1]
+        d_state = A.shape[-1] * (1 if not A.is_complex() else 2)
+        x, z = xz.chunk(2, dim=1)
+        if dout.stride(-1) != 1:
+            dout = dout.contiguous()
+        if ctx.checkpoint_lvl == 1:
+            conv1d_out = causal_conv1d_cuda.causal_conv1d_fwd(x, conv1d_weight, conv1d_bias, True)
+            delta = rearrange(delta_proj_weight @ x_dbl[:, :delta_rank].t(),
+                              "d (b l) -> b d l", l = L)
+        # The kernel supports passing in a pre-allocated dz (e.g., in case we want to fuse the
+        # backward of selective_scan_cuda with the backward of chunk).
+        dxz = torch.empty_like(xz)  # (batch, dim, seqlen)
+        dx, dz = dxz.chunk(2, dim=1)
+        dout = rearrange(dout, "b l e -> e (b l)")
+        dout_y = rearrange(out_proj_weight.t() @ dout, "d (b l) -> b d l", l=L)
+        dconv1d_out, ddelta, dA, dB, dC, dD, ddelta_bias, dz, out_z = selective_scan_cuda.bwd(
+            conv1d_out, delta, A, B, C, D, z, delta_bias, dout_y, scan_intermediates, out, dz,
+            ctx.delta_softplus,
+            True  # option to recompute out_z
+        )
+        dout_proj_weight = torch.einsum("eB,dB->ed", dout, rearrange(out_z, "b d l -> d (b l)"))
+        dout_proj_bias = dout.sum(dim=(0, 1)) if not ctx.out_proj_bias_is_None else None
+        dD = dD if D is not None else None
+        dx_dbl = torch.empty_like(x_dbl)
+        dB_proj_bias = None
+        if ctx.is_variable_B:
+            if not A.is_complex():
+                dB = rearrange(dB, "b 1 dstate l -> (b l) dstate").contiguous()
+            else:
+                dB = rearrange(dB, "b 1 dstate (l two) -> (b l) (dstate two)", two=2).contiguous()
+            dB_proj_bias = dB.sum(0) if not ctx.B_proj_bias_is_None else None
+            dx_dbl[:, delta_rank:delta_rank + d_state] = dB  # (bl d)
+            dB = None
+        dC_proj_bias = None
+        if ctx.is_variable_C:
+            if not A.is_complex():
+                dC = rearrange(dC, "b 1 dstate l -> (b l) dstate").contiguous()
+            else:
+                dC = rearrange(dC, "b 1 dstate (l two) -> (b l) (dstate two)", two=2).contiguous()
+            dC_proj_bias = dC.sum(0) if not ctx.C_proj_bias_is_None else None
+            dx_dbl[:, -d_state:] = dC  # (bl d)
+            dC = None
+        ddelta = rearrange(ddelta, "b d l -> d (b l)")
+        ddelta_proj_weight = torch.einsum("dB,Br->dr", ddelta, x_dbl[:, :delta_rank])
+        dx_dbl[:, :delta_rank] = torch.einsum("dB,dr->Br", ddelta, delta_proj_weight)
+        dconv1d_out = rearrange(dconv1d_out, "b d l -> d (b l)")
+        dx_proj_weight = torch.einsum("Br,Bd->rd", dx_dbl, rearrange(conv1d_out, "b d l -> (b l) d"))
+        dconv1d_out = torch.addmm(dconv1d_out, x_proj_weight.t(), dx_dbl.t(), out=dconv1d_out)
+        dconv1d_out = rearrange(dconv1d_out, "d (b l) -> b d l", b=x.shape[0], l=x.shape[-1])
+        # The kernel supports passing in a pre-allocated dx (e.g., in case we want to fuse the
+        # backward of conv1d with the backward of chunk).
+        dx, dconv1d_weight, dconv1d_bias = causal_conv1d_cuda.causal_conv1d_bwd(
+            x, conv1d_weight, conv1d_bias, dconv1d_out, dx, True
+        )
+        dconv1d_bias = dconv1d_bias if conv1d_bias is not None else None
+        dconv1d_weight = rearrange(dconv1d_weight, "d w -> d 1 w")
+        return (dxz, dconv1d_weight, dconv1d_bias, dx_proj_weight, ddelta_proj_weight,
+                dout_proj_weight, dout_proj_bias,
+                dA, dB, dC, dD,
+                ddelta_bias if delta_bias is not None else None,
+                dB_proj_bias, dC_proj_bias, None)
+
+
+class BiMambaInnerFn(torch.autograd.Function):
+
+    @staticmethod
+    @custom_fwd
+    def forward(ctx, xz, conv1d_weight, conv1d_bias, x_proj_weight, delta_proj_weight,
+                out_proj_weight, out_proj_bias,
+                A, A_b, B=None, C=None, D=None, delta_bias=None, B_proj_bias=None,
+                C_proj_bias=None, delta_softplus=True, checkpoint_lvl=1):
+        """
+             xz: (batch, dim, seqlen)
+        """
+        assert checkpoint_lvl in [0, 1]
+        L = xz.shape[-1]
+        delta_rank = delta_proj_weight.shape[1]
+        d_state = A.shape[-1] * (1 if not A.is_complex() else 2)
+        if torch.is_autocast_enabled():
+            x_proj_weight = x_proj_weight.to(dtype=torch.get_autocast_gpu_dtype())
+            delta_proj_weight = delta_proj_weight.to(dtype=torch.get_autocast_gpu_dtype())
+            out_proj_weight = out_proj_weight.to(dtype=torch.get_autocast_gpu_dtype())
+            out_proj_bias = (out_proj_bias.to(dtype=torch.get_autocast_gpu_dtype())
+                             if out_proj_bias is not None else None)
+        if xz.stride(-1) != 1:
+            xz = xz.contiguous()
+        conv1d_weight = rearrange(conv1d_weight, "d 1 w -> d w")
+        x, z = xz.chunk(2, dim=1)
+        conv1d_bias = conv1d_bias.contiguous() if conv1d_bias is not None else None
+        conv1d_out = causal_conv1d_cuda.causal_conv1d_fwd(x, conv1d_weight, conv1d_bias, True)
+        # We're being very careful here about the layout, to avoid extra transposes.
+        # We want delta to have d as the slowest moving dimension
+        # and L as the fastest moving dimension, since those are what the ssm_scan kernel expects.
+        x_dbl = F.linear(rearrange(conv1d_out, 'b d l -> (b l) d'), x_proj_weight)  # (bl d)
+        delta = rearrange(delta_proj_weight @ x_dbl[:, :delta_rank].t(), "d (b l) -> b d l", l = L)
+        ctx.is_variable_B = B is None
+        ctx.is_variable_C = C is None
+        ctx.B_proj_bias_is_None = B_proj_bias is None
+        ctx.C_proj_bias_is_None = C_proj_bias is None
+        if B is None:  # variable B
+            B = x_dbl[:, delta_rank:delta_rank + d_state]  # (bl dstate)
+            if B_proj_bias is not None:
+                B = B + B_proj_bias.to(dtype=B.dtype)
+            if not A.is_complex():
+                # B = rearrange(B, "(b l) dstate -> b dstate l", l=L).contiguous()
+                B = rearrange(B, "(b l) dstate -> b 1 dstate l", l=L).contiguous()
+            else:
+                B = rearrange(B, "(b l) (dstate two) -> b 1 dstate (l two)", l=L, two=2).contiguous()
+        else:
+            if B.stride(-1) != 1:
+                B = B.contiguous()
+        if C is None:  # variable C
+            C = x_dbl[:, -d_state:]  # (bl dstate)
+            if C_proj_bias is not None:
+                C = C + C_proj_bias.to(dtype=C.dtype)
+            if not A.is_complex():
+                # C = rearrange(C, "(b l) dstate -> b dstate l", l=L).contiguous()
+                C = rearrange(C, "(b l) dstate -> b 1 dstate l", l=L).contiguous()
+            else:
+                C = rearrange(C, "(b l) (dstate two) -> b 1 dstate (l two)", l=L, two=2).contiguous()
+        else:
+            if C.stride(-1) != 1:
+                C = C.contiguous()
+        if D is not None:
+            D = D.contiguous()
+        out_f, scan_intermediates_f, out_z_f = selective_scan_cuda.fwd(
+            conv1d_out, delta, A, B, C, D, z, delta_bias, delta_softplus
+        )
+        assert not A_b.is_complex(), "A should not be complex!!"
+        out_b, scan_intermediates_b, out_z_b = selective_scan_cuda.fwd(
+            conv1d_out.flip([-1]), delta.flip([-1]), A_b, B.flip([-1]), C.flip([-1]), D, z.flip([-1]), delta_bias, delta_softplus,
+        )
+
+        out_z = out_z_f + out_z_b.flip([-1])
+
+        ctx.delta_softplus = delta_softplus
+        ctx.out_proj_bias_is_None = out_proj_bias is None
+        ctx.checkpoint_lvl = checkpoint_lvl
+        if checkpoint_lvl >= 1:  # Will recompute conv1d_out and delta in the backward pass
+            conv1d_out, delta = None, None
+        ctx.save_for_backward(xz, conv1d_weight, conv1d_bias, x_dbl, x_proj_weight,
+                              delta_proj_weight, out_proj_weight, conv1d_out, delta,
+                              A, A_b, B, C, D, delta_bias, scan_intermediates_f, scan_intermediates_b, out_f, out_b)
+        return F.linear(rearrange(out_z, "b d l -> b l d"), out_proj_weight, out_proj_bias)
+
+    @staticmethod
+    @custom_bwd
+    def backward(ctx, dout):
+        # dout: (batch, seqlen, dim)
+        (xz, conv1d_weight, conv1d_bias, x_dbl, x_proj_weight, delta_proj_weight, out_proj_weight,
+         conv1d_out, delta, A, A_b, B, C, D, delta_bias, scan_intermediates_f, scan_intermediates_b, out_f, out_b) = ctx.saved_tensors
+        L = xz.shape[-1]
+        delta_rank = delta_proj_weight.shape[1]
+        d_state = A.shape[-1] * (1 if not A.is_complex() else 2)
+        x, z = xz.chunk(2, dim=1)
+        if dout.stride(-1) != 1:
+            dout = dout.contiguous()
+        if ctx.checkpoint_lvl == 1:
+            conv1d_out = causal_conv1d_cuda.causal_conv1d_fwd(x, conv1d_weight, conv1d_bias, True)
+            delta = rearrange(delta_proj_weight @ x_dbl[:, :delta_rank].t(),
+                              "d (b l) -> b d l", l = L)
+        # The kernel supports passing in a pre-allocated dz (e.g., in case we want to fuse the
+        # backward of selective_scan_cuda with the backward of chunk).
+        dxz = torch.empty_like(xz)  # (batch, dim, seqlen)
+        dx, dz = dxz.chunk(2, dim=1)
+        dout = rearrange(dout, "b l e -> e (b l)")
+        dout_y = rearrange(out_proj_weight.t() @ dout, "d (b l) -> b d l", l=L)
+        dconv1d_out, ddelta, dA, dB, dC, dD, ddelta_bias, dz, out_z_f = selective_scan_cuda.bwd(
+            conv1d_out, delta, A, B, C, D, z, delta_bias, dout_y, scan_intermediates_f, out_f, dz,
+            ctx.delta_softplus,
+            True  # option to recompute out_z
+        )
+        # flip one
+        dz_b = torch.empty_like(dz)
+        dconv1d_out_f_b, ddelta_f_b, dA_b, dB_f_b, dC_f_b, dD_b, ddelta_bias_b, dz_b, out_z_b = selective_scan_cuda.bwd(
+            conv1d_out.flip([-1]), delta.flip([-1]), A_b, B.flip([-1]), C.flip([-1]), D, z.flip([-1]), delta_bias, dout_y.flip([-1]), scan_intermediates_b, out_b, dz_b,
+            ctx.delta_softplus,
+            True  # option to recompute out_z
+        )
+
+        dconv1d_out = dconv1d_out + dconv1d_out_f_b.flip([-1])
+        ddelta = ddelta + ddelta_f_b.flip([-1])
+        dB = dB + dB_f_b.flip([-1])
+        dC = dC + dC_f_b.flip([-1])
+        dD = dD + dD_b
+        ddelta_bias = ddelta_bias + ddelta_bias_b
+        dz = dz + dz_b.flip([-1])
+        out_z = out_z_f + out_z_b.flip([-1])
+        
+        dout_proj_weight = torch.einsum("eB,dB->ed", dout, rearrange(out_z, "b d l -> d (b l)"))
+        dout_proj_bias = dout.sum(dim=(0, 1)) if not ctx.out_proj_bias_is_None else None
+        dD = dD if D is not None else None
+        dx_dbl = torch.empty_like(x_dbl)
+        dB_proj_bias = None
+        if ctx.is_variable_B:
+            if not A.is_complex():
+                dB = rearrange(dB, "b 1 dstate l -> (b l) dstate").contiguous()
+            else:
+                dB = rearrange(dB, "b 1 dstate (l two) -> (b l) (dstate two)", two=2).contiguous()
+            dB_proj_bias = dB.sum(0) if not ctx.B_proj_bias_is_None else None
+            dx_dbl[:, delta_rank:delta_rank + d_state] = dB  # (bl d)
+            dB = None
+        dC_proj_bias = None
+        if ctx.is_variable_C:
+            if not A.is_complex():
+                dC = rearrange(dC, "b 1 dstate l -> (b l) dstate").contiguous()
+            else:
+                dC = rearrange(dC, "b 1 dstate (l two) -> (b l) (dstate two)", two=2).contiguous()
+            dC_proj_bias = dC.sum(0) if not ctx.C_proj_bias_is_None else None
+            dx_dbl[:, -d_state:] = dC  # (bl d)
+            dC = None
+        ddelta = rearrange(ddelta, "b d l -> d (b l)")
+        ddelta_proj_weight = torch.einsum("dB,Br->dr", ddelta, x_dbl[:, :delta_rank])
+        dx_dbl[:, :delta_rank] = torch.einsum("dB,dr->Br", ddelta, delta_proj_weight)
+        dconv1d_out = rearrange(dconv1d_out, "b d l -> d (b l)")
+        dx_proj_weight = torch.einsum("Br,Bd->rd", dx_dbl, rearrange(conv1d_out, "b d l -> (b l) d"))
+        dconv1d_out = torch.addmm(dconv1d_out, x_proj_weight.t(), dx_dbl.t(), out=dconv1d_out)
+        dconv1d_out = rearrange(dconv1d_out, "d (b l) -> b d l", b=x.shape[0], l=x.shape[-1])
+        # The kernel supports passing in a pre-allocated dx (e.g., in case we want to fuse the
+        # backward of conv1d with the backward of chunk).
+        dx, dconv1d_weight, dconv1d_bias = causal_conv1d_cuda.causal_conv1d_bwd(
+            x, conv1d_weight, conv1d_bias, dconv1d_out, dx, True
+        )
+        dconv1d_bias = dconv1d_bias if conv1d_bias is not None else None
+        dconv1d_weight = rearrange(dconv1d_weight, "d w -> d 1 w")
+        return (dxz, dconv1d_weight, dconv1d_bias, dx_proj_weight, ddelta_proj_weight,
+                dout_proj_weight, dout_proj_bias,
+                dA, dA_b, dB, dC, dD,
+                ddelta_bias if delta_bias is not None else None,
+                dB_proj_bias, dC_proj_bias, None)
+    
+
+def mamba_inner_fn(
+    xz, conv1d_weight, conv1d_bias, x_proj_weight, delta_proj_weight,
+    out_proj_weight, out_proj_bias,
+    A, B=None, C=None, D=None, delta_bias=None, B_proj_bias=None,
+    C_proj_bias=None, delta_softplus=True
+):
+    return MambaInnerFn.apply(xz, conv1d_weight, conv1d_bias, x_proj_weight, delta_proj_weight,
+                              out_proj_weight, out_proj_bias,
+                              A, B, C, D, delta_bias, B_proj_bias, C_proj_bias, delta_softplus)
+
+def bimamba_inner_fn(
+    xz, conv1d_weight, conv1d_bias, x_proj_weight, delta_proj_weight,
+    out_proj_weight, out_proj_bias,
+    A, A_b, B=None, C=None, D=None, delta_bias=None, B_proj_bias=None,
+    C_proj_bias=None, delta_softplus=True
+):
+    return BiMambaInnerFn.apply(xz, conv1d_weight, conv1d_bias, x_proj_weight, delta_proj_weight,
+                              out_proj_weight, out_proj_bias,
+                              A, A_b, B, C, D, delta_bias, B_proj_bias, C_proj_bias, delta_softplus)
+
+
+def mamba_inner_fn_no_out_proj(
+    xz, conv1d_weight, conv1d_bias, x_proj_weight, delta_proj_weight,
+    A, B=None, C=None, D=None, delta_bias=None, B_proj_bias=None,
+    C_proj_bias=None, delta_softplus=True
+):
+    return MambaInnerFnNoOutProj.apply(xz, conv1d_weight, conv1d_bias, x_proj_weight, delta_proj_weight,
+                              A, B, C, D, delta_bias, B_proj_bias, C_proj_bias, delta_softplus)
+
+
+def mamba_inner_ref(
+    xz, conv1d_weight, conv1d_bias, x_proj_weight, delta_proj_weight,
+    out_proj_weight, out_proj_bias,
+    A, B=None, C=None, D=None, delta_bias=None, B_proj_bias=None,
+    C_proj_bias=None, delta_softplus=True
+):
+    L = xz.shape[-1]
+    delta_rank = delta_proj_weight.shape[1]
+    d_state = A.shape[-1] * (1 if not A.is_complex() else 2)
+    x, z = xz.chunk(2, dim=1)
+    x = causal_conv1d_fn(x, rearrange(conv1d_weight, "d 1 w -> d w"), conv1d_bias, "silu")
+    # We're being very careful here about the layout, to avoid extra transposes.
+    # We want delta to have d as the slowest moving dimension
+    # and L as the fastest moving dimension, since those are what the ssm_scan kernel expects.
+    x_dbl = F.linear(rearrange(x, 'b d l -> (b l) d'), x_proj_weight)  # (bl d)
+    delta = delta_proj_weight @ x_dbl[:, :delta_rank].t()
+    delta = rearrange(delta, "d (b l) -> b d l", l=L)
+    if B is None:  # variable B
+        B = x_dbl[:, delta_rank:delta_rank + d_state]  # (bl d)
+        if B_proj_bias is not None:
+            B = B + B_proj_bias.to(dtype=B.dtype)
+        if not A.is_complex():
+            B = rearrange(B, "(b l) dstate -> b dstate l", l=L).contiguous()
+        else:
+            B = rearrange(B, "(b l) (dstate two) -> b dstate (l two)", l=L, two=2).contiguous()
+    if C is None:  # variable B
+        C = x_dbl[:, -d_state:]  # (bl d)
+        if C_proj_bias is not None:
+            C = C + C_proj_bias.to(dtype=C.dtype)
+        if not A.is_complex():
+            C = rearrange(C, "(b l) dstate -> b dstate l", l=L).contiguous()
+        else:
+            C = rearrange(C, "(b l) (dstate two) -> b dstate (l two)", l=L, two=2).contiguous()
+    y = selective_scan_fn(x, delta, A, B, C, D, z=z, delta_bias=delta_bias, delta_softplus=True)
+    return F.linear(rearrange(y, "b d l -> b l d"), out_proj_weight, out_proj_bias)
+
+
+def bimamba_inner_ref(
+    xz, conv1d_weight, conv1d_bias, x_proj_weight, delta_proj_weight,
+    out_proj_weight, out_proj_bias,
+    A, A_b, B=None, C=None, D=None, delta_bias=None, B_proj_bias=None,
+    C_proj_bias=None, delta_softplus=True
+):
+    L = xz.shape[-1]
+    delta_rank = delta_proj_weight.shape[1]
+    d_state = A.shape[-1] * (1 if not A.is_complex() else 2)
+    x, z = xz.chunk(2, dim=1)
+    x = causal_conv1d_fn(x, rearrange(conv1d_weight, "d 1 w -> d w"), conv1d_bias, "silu")
+    # We're being very careful here about the layout, to avoid extra transposes.
+    # We want delta to have d as the slowest moving dimension
+    # and L as the fastest moving dimension, since those are what the ssm_scan kernel expects.
+    x_dbl = F.linear(rearrange(x, 'b d l -> (b l) d'), x_proj_weight)  # (bl d)
+    delta = delta_proj_weight @ x_dbl[:, :delta_rank].t()
+    delta = rearrange(delta, "d (b l) -> b d l", l=L)
+    if B is None:  # variable B
+        B = x_dbl[:, delta_rank:delta_rank + d_state]  # (bl d)
+        if B_proj_bias is not None:
+            B = B + B_proj_bias.to(dtype=B.dtype)
+        if not A.is_complex():
+            B = rearrange(B, "(b l) dstate -> b dstate l", l=L).contiguous()
+        else:
+            B = rearrange(B, "(b l) (dstate two) -> b dstate (l two)", l=L, two=2).contiguous()
+    if C is None:  # variable B
+        C = x_dbl[:, -d_state:]  # (bl d)
+        if C_proj_bias is not None:
+            C = C + C_proj_bias.to(dtype=C.dtype)
+        if not A.is_complex():
+            C = rearrange(C, "(b l) dstate -> b dstate l", l=L).contiguous()
+        else:
+            C = rearrange(C, "(b l) (dstate two) -> b dstate (l two)", l=L, two=2).contiguous()
+    y = selective_scan_fn(x, delta, A, B, C, D, z=z, delta_bias=delta_bias, delta_softplus=True)
+    y_b = selective_scan_fn(x.flip([-1]), delta.flip([-1]), A_b, B.flip([-1]), C.flip([-1]), D, z.flip([-1]), delta_bias, delta_softplus=True)
+    y = y + y_b.flip([-1])
+    return F.linear(rearrange(y, "b d l -> b l d"), out_proj_weight, out_proj_bias)

source_code/SegMamba/monai/handlers/clearml_handlers.py

@@ -0,0 +1,178 @@
+# Copyright (c) MONAI Consortium
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#     http://www.apache.org/licenses/LICENSE-2.0
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any, Mapping, Sequence
+
+from monai.utils import optional_import
+
+from .tensorboard_handlers import TensorBoardImageHandler, TensorBoardStatsHandler
+
+
+class ClearMLHandler:
+    """
+    Base class for the handlers to log everything to ClearML.
+    For more details of ClearML usage, please refer to:
+    https://clear.ml/docs/latest/docs/references/sdk/task
+
+    Usage example is available in the tutorial:
+    https://github.com/Project-MONAI/tutorials/blob/master/3d_segmentation/unet_segmentation_3d_ignite.ipynb.
+
+    """
+
+    def __init__(
+        self,
+        project_name: str | None,
+        task_name: str | None,
+        output_uri: str | bool,
+        tags: Sequence[str] | None,
+        reuse_last_task_id: bool,
+        continue_last_task: bool,
+        auto_connect_frameworks: bool | Mapping[str, bool | str | list],
+        auto_connect_arg_parser: bool | Mapping[str, bool],
+    ) -> None:
+        """
+        Args:
+            project_name: ClearML project name, default to 'MONAI'.
+            task_name: ClearML task name, default to 'monai_experiment'.
+            output_uri: The default location for output models and other artifacts, default to 'True'.
+            tags: Add a list of tags (str) to the created Task, default to 'None'.
+            reuse_last_task_id: Force a new Task (experiment) with a previously used Task ID, default to 'True'.
+            continue_last_task: Continue the execution of a previously executed Task (experiment), default to 'False'.
+            auto_connect_frameworks: Automatically connect frameworks, default to 'True'.
+            auto_connect_arg_parser: Automatically connect an argparse object to the Task, default to 'True'.
+
+        """
+
+        if TYPE_CHECKING:
+            import clearml
+        else:
+            clearml, _ = optional_import("clearml")
+
+        # Always check if the user didn't already add a `task.init`` in before
+        # if so, use that task, otherwise create a new one.
+        if clearml.Task.current_task():
+            self.clearml_task = clearml.Task.current_task()
+        else:
+            self.clearml_task = clearml.Task.init(
+                project_name=project_name,
+                task_name=task_name,
+                output_uri=output_uri,
+                tags=tags,
+                reuse_last_task_id=reuse_last_task_id,
+                continue_last_task=continue_last_task,
+                auto_connect_frameworks=auto_connect_frameworks,
+                auto_connect_arg_parser=auto_connect_arg_parser,
+            )
+
+
+class ClearMLStatsHandler(ClearMLHandler, TensorBoardStatsHandler):
+    """
+
+    Class to write tensorboard stats by inheriting TensorBoardStatsHandler class.
+    Everything from Tensorboard is logged automatically to ClearML.
+
+    Usage example is available in the tutorial:
+    https://github.com/Project-MONAI/tutorials/blob/master/3d_segmentation/unet_segmentation_3d_ignite.ipynb.
+
+    """
+
+    def __init__(
+        self,
+        project_name: str | None = "MONAI",
+        task_name: str | None = "monai_experiment",
+        output_uri: str | bool = True,
+        tags: Sequence[str] | None = None,
+        reuse_last_task_id: bool = True,
+        continue_last_task: bool = False,
+        auto_connect_frameworks: bool | Mapping[str, bool | str | list] = True,
+        auto_connect_arg_parser: bool | Mapping[str, bool] = True,
+        *args: Any,
+        **kwargs: Any,
+    ) -> None:
+        """
+        Args:
+            project_name: ClearML project name, default to 'MONAI'.
+            task_name: ClearML task name, default to 'monai_experiment'.
+            output_uri: The default location for output models and other artifacts, default to 'True'.
+            tags: Add a list of tags (str) to the created Task, default to 'None'.
+            reuse_last_task_id: Force a new Task (experiment) with a previously used Task ID, default to 'True'.
+            continue_last_task: Continue the execution of a previously executed Task (experiment), default to 'False'.
+            auto_connect_frameworks: Automatically connect frameworks, default to 'True'.
+            auto_connect_arg_parser: Automatically connect an argparse object to the Task, default to 'True'.
+
+        """
+
+        ClearMLHandler.__init__(
+            self,
+            project_name=project_name,
+            task_name=task_name,
+            output_uri=output_uri,
+            tags=tags,
+            reuse_last_task_id=reuse_last_task_id,
+            continue_last_task=continue_last_task,
+            auto_connect_frameworks=auto_connect_frameworks,
+            auto_connect_arg_parser=auto_connect_arg_parser,
+        )
+        TensorBoardStatsHandler.__init__(self, *args, **kwargs)
+
+
+class ClearMLImageHandler(ClearMLHandler, TensorBoardImageHandler):
+    """
+
+    This class inherits all functionality from TensorBoardImageHandler class.
+    Everything from Tensorboard is logged automatically to ClearML.
+
+    Usage example is available in the tutorial:
+    https://github.com/Project-MONAI/tutorials/blob/master/3d_segmentation/unet_segmentation_3d_ignite.ipynb.
+
+    """
+
+    def __init__(
+        self,
+        project_name: str | None = "MONAI",
+        task_name: str | None = "monai_experiment",
+        output_uri: str | bool = True,
+        tags: Sequence[str] | None = None,
+        reuse_last_task_id: bool = True,
+        continue_last_task: bool = False,
+        auto_connect_frameworks: bool | Mapping[str, bool | str | list] = True,
+        auto_connect_arg_parser: bool | Mapping[str, bool] = True,
+        *args: Any,
+        **kwargs: Any,
+    ) -> None:
+        """
+        Args:
+            project_name: ClearML project name, default to 'MONAI'.
+            task_name: ClearML task name, default to 'monai_experiment'.
+            output_uri: The default location for output models and other artifacts, default to 'True'.
+            tags: Add a list of tags (str) to the created Task, default to 'None'.
+            reuse_last_task_id: Force a new Task (experiment) with a previously used Task ID, default to 'True'.
+            continue_last_task: Continue the execution of a previously executed Task (experiment), default to 'False'.
+            auto_connect_frameworks: Automatically connect frameworks, default to 'True'.
+            auto_connect_arg_parser: Automatically connect an argparse object to the Task, default to 'True'.
+
+        """
+
+        ClearMLHandler.__init__(
+            self,
+            project_name=project_name,
+            task_name=task_name,
+            output_uri=output_uri,
+            tags=tags,
+            reuse_last_task_id=reuse_last_task_id,
+            continue_last_task=continue_last_task,
+            auto_connect_frameworks=auto_connect_frameworks,
+            auto_connect_arg_parser=auto_connect_arg_parser,
+        )
+
+        TensorBoardImageHandler.__init__(self, *args, **kwargs)

source_code/SegMamba/monai/handlers/metric_logger.py

@@ -0,0 +1,137 @@
+# Copyright (c) MONAI Consortium
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#     http://www.apache.org/licenses/LICENSE-2.0
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from __future__ import annotations
+
+from collections import defaultdict
+from collections.abc import Callable, Mapping, Sequence
+from enum import Enum
+from threading import RLock
+from typing import TYPE_CHECKING, Any
+
+from monai.config import IgniteInfo
+from monai.utils import min_version, optional_import
+from monai.utils.enums import CommonKeys
+
+Events, _ = optional_import("ignite.engine", IgniteInfo.OPT_IMPORT_VERSION, min_version, "Events")
+if TYPE_CHECKING:
+    from ignite.engine import Engine
+else:
+    Engine, _ = optional_import(
+        "ignite.engine", IgniteInfo.OPT_IMPORT_VERSION, min_version, "Engine", as_type="decorator"
+    )
+
+
+def _get_loss_from_output(output: Sequence[Mapping[str, Any]], loss_key: str = CommonKeys.LOSS) -> Any:
+    return output[0][loss_key]
+
+
+class MetricLoggerKeys(Enum):
+    METRICS = "Metrics"
+    LOSS = "Loss"
+
+
+class MetricLogger:
+    """
+    Collect per-iteration metrics and loss value from the attached trainer. This will also collect metric values from
+    a given evaluator object which is expected to perform evaluation at the end of training epochs. This class is
+    useful for collecting loss and metric values in one place for storage with checkpoint savers (`state_dict` and
+    `load_state_dict` methods provided as expected by Pytorch and Ignite) and for graphing during training.
+
+    Example::
+        # construct an evaluator saving mean dice metric values in the key "val_mean_dice"
+        evaluator = SupervisedEvaluator(..., key_val_metric={"val_mean_dice": MeanDice(...)})
+
+        # construct the logger and associate with evaluator to extract metric values from
+        logger = MetricLogger(evaluator=evaluator)
+
+        # construct the trainer with the logger passed in as a handler so that it logs loss values
+        trainer = SupervisedTrainer(..., train_handlers=[logger, ValidationHandler(1, evaluator)])
+
+        # run training, logger.loss will be a list of (iteration, loss) values, logger.metrics a dict with key
+        # "val_mean_dice" storing a list of (iteration, metric) values
+        trainer.run()
+
+    Args:
+        loss_transform: Converts the `output` value from the trainer's state into a loss value
+            `engine.state` and `loss_transform` inherit from the ignite concept:
+            https://pytorch.org/ignite/concepts.html#state, explanation and usage example are in the tutorial:
+            https://github.com/Project-MONAI/tutorials/blob/master/modules/batch_output_transform.ipynb.
+        metric_transform: Converts the metric value coming from the trainer/evaluator's state into a storable value
+        evaluator: Optional evaluator to consume metric results from at the end of its evaluation run
+    """
+
+    def __init__(
+        self,
+        loss_transform: Callable = _get_loss_from_output,
+        metric_transform: Callable = lambda x: x,
+        evaluator: Engine | None = None,
+    ) -> None:
+        self.loss_transform = loss_transform
+        self.metric_transform = metric_transform
+        self.loss: list = []
+        self.metrics: defaultdict = defaultdict(list)
+        self.iteration = 0
+        self.lock = RLock()
+
+        if evaluator is not None:
+            self.attach_evaluator(evaluator)
+
+    def attach(self, engine: Engine) -> None:
+        """
+        Args:
+            engine: Ignite Engine, it can be a trainer, validator or evaluator.
+        """
+        engine.add_event_handler(Events.ITERATION_COMPLETED, self)
+
+    def attach_evaluator(self, evaluator: Engine) -> None:
+        """
+        Attach event  handlers to the given evaluator to log metric values from it.
+
+        Args:
+            evaluator: Ignite Engine implementing network evaluation
+        """
+        evaluator.add_event_handler(Events.COMPLETED, self.log_metrics)
+
+    def __call__(self, engine: Engine) -> None:
+        """
+        Args:
+            engine: Ignite Engine, it can be a trainer, validator or evaluator.
+        """
+        with self.lock:
+            self.iteration = engine.state.iteration
+            lossval = self.loss_transform(engine.state.output)
+
+            self.loss.append((self.iteration, lossval))
+            self.log_metrics(engine)
+
+    def log_metrics(self, engine: Engine) -> None:
+        """
+        Log metrics from the given Engine's state member.
+
+        Args:
+            engine: Ignite Engine to log from
+        """
+        with self.lock:
+            for m, v in engine.state.metrics.items():
+                v = self.metric_transform(v)
+                self.metrics[m].append((self.iteration, v))
+
+    def state_dict(self):
+        return {MetricLoggerKeys.LOSS: self.loss, MetricLoggerKeys.METRICS: self.metrics}
+
+    def load_state_dict(self, state_dict):
+        self.loss[:] = state_dict[MetricLoggerKeys.LOSS]
+        self.metrics.clear()
+        self.metrics.update(state_dict[MetricLoggerKeys.METRICS])
+
+
+metriclogger = MetricLogger

source_code/SegMamba/monai/handlers/metrics_reloaded_handler.py

@@ -0,0 +1,115 @@
+# Copyright (c) MONAI Consortium
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#     http://www.apache.org/licenses/LICENSE-2.0
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from __future__ import annotations
+
+from collections.abc import Callable
+
+from monai.handlers.ignite_metric import IgniteMetricHandler
+from monai.metrics import MetricsReloadedBinary, MetricsReloadedCategorical
+from monai.utils.enums import MetricReduction
+
+
+class MetricsReloadedBinaryHandler(IgniteMetricHandler):
+    """
+    Handler of MetricsReloadedBinary, which wraps the binary pairwise metrics of MetricsReloaded.
+    """
+
+    def __init__(
+        self,
+        metric_name: str,
+        include_background: bool = True,
+        reduction: MetricReduction | str = MetricReduction.MEAN,
+        get_not_nans: bool = False,
+        output_transform: Callable = lambda x: x,
+        save_details: bool = True,
+    ) -> None:
+        """
+
+        Args:
+            metric_name: Name of a binary metric from the MetricsReloaded package.
+            include_background: whether to include computation on the first channel of
+                the predicted output. Defaults to ``True``.
+            reduction: define mode of reduction to the metrics, will only apply reduction on `not-nan` values,
+                available reduction modes: {``"none"``, ``"mean"``, ``"sum"``, ``"mean_batch"``, ``"sum_batch"``,
+                ``"mean_channel"``, ``"sum_channel"``}, default to ``"mean"``. if "none", will not do reduction.
+            get_not_nans: whether to return the `not_nans` count, if True, aggregate() returns (metric, not_nans).
+                Here `not_nans` count the number of not nans for the metric,
+                thus its shape equals to the shape of the metric.
+            output_transform: callable to extract `y_pred` and `y` from `ignite.engine.state.output` then
+                construct `(y_pred, y)` pair, where `y_pred` and `y` can be `batch-first` Tensors or
+                lists of `channel-first` Tensors. the form of `(y_pred, y)` is required by the `update()`.
+                `engine.state` and `output_transform` inherit from the ignite concept:
+                https://pytorch.org/ignite/concepts.html#state, explanation and usage example are in the tutorial:
+                https://github.com/Project-MONAI/tutorials/blob/master/modules/batch_output_transform.ipynb.
+            save_details: whether to save metric computation details per image, for example: TP/TN/FP/FN of every image.
+                default to True, will save to `engine.state.metric_details` dict with the metric name as key.
+
+        See also:
+            :py:meth:`monai.metrics.wrapper`
+        """
+        metric_fn = MetricsReloadedBinary(
+            metric_name=metric_name,
+            include_background=include_background,
+            reduction=reduction,
+            get_not_nans=get_not_nans,
+        )
+        super().__init__(metric_fn=metric_fn, output_transform=output_transform, save_details=save_details)
+
+
+class MetricsReloadedCategoricalHandler(IgniteMetricHandler):
+    """
+    Handler of MetricsReloadedCategorical, which wraps the categorical pairwise metrics of MetricsReloaded.
+    """
+
+    def __init__(
+        self,
+        metric_name: str,
+        include_background: bool = True,
+        reduction: MetricReduction | str = MetricReduction.MEAN,
+        get_not_nans: bool = False,
+        smooth_dr: float = 1e-5,
+        output_transform: Callable = lambda x: x,
+        save_details: bool = True,
+    ) -> None:
+        """
+
+        Args:
+            metric_name: Name of a categorical metric from the MetricsReloaded package.
+            include_background: whether to include computation on the first channel of
+                the predicted output. Defaults to ``True``.
+            reduction: define mode of reduction to the metrics, will only apply reduction on `not-nan` values,
+                available reduction modes: {``"none"``, ``"mean"``, ``"sum"``, ``"mean_batch"``, ``"sum_batch"``,
+                ``"mean_channel"``, ``"sum_channel"``}, default to ``"mean"``. if "none", will not do reduction.
+            get_not_nans: whether to return the `not_nans` count, if True, aggregate() returns (metric, not_nans).
+                Here `not_nans` count the number of not nans for the metric,
+                thus its shape equals to the shape of the metric.
+            smooth_dr: a small constant added to the denominator to avoid nan. OBS: should be greater than zero.
+            output_transform: callable to extract `y_pred` and `y` from `ignite.engine.state.output` then
+                construct `(y_pred, y)` pair, where `y_pred` and `y` can be `batch-first` Tensors or
+                lists of `channel-first` Tensors. the form of `(y_pred, y)` is required by the `update()`.
+                `engine.state` and `output_transform` inherit from the ignite concept:
+                https://pytorch.org/ignite/concepts.html#state, explanation and usage example are in the tutorial:
+                https://github.com/Project-MONAI/tutorials/blob/master/modules/batch_output_transform.ipynb.
+            save_details: whether to save metric computation details per image, for example: TP/TN/FP/FN of every image.
+                default to True, will save to `engine.state.metric_details` dict with the metric name as key.
+
+        See also:
+            :py:meth:`monai.metrics.wrapper`
+        """
+        metric_fn = MetricsReloadedCategorical(
+            metric_name=metric_name,
+            include_background=include_background,
+            reduction=reduction,
+            get_not_nans=get_not_nans,
+            smooth_dr=smooth_dr,
+        )
+        super().__init__(metric_fn=metric_fn, output_transform=output_transform, save_details=save_details)

source_code/SegMamba/monai/handlers/nvtx_handlers.py

@@ -0,0 +1,182 @@
+# Copyright (c) MONAI Consortium
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#     http://www.apache.org/licenses/LICENSE-2.0
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""
+Wrapper around NVIDIA Tools Extension for profiling MONAI ignite workflow
+"""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from monai.config import IgniteInfo
+from monai.utils import ensure_tuple, min_version, optional_import
+
+_nvtx, _ = optional_import("torch._C._nvtx", descriptor="NVTX is not installed. Are you sure you have a CUDA build?")
+if TYPE_CHECKING:
+    from ignite.engine import Engine, Events
+else:
+    Engine, _ = optional_import(
+        "ignite.engine", IgniteInfo.OPT_IMPORT_VERSION, min_version, "Engine", as_type="decorator"
+    )
+    Events, _ = optional_import(
+        "ignite.engine", IgniteInfo.OPT_IMPORT_VERSION, min_version, "Events", as_type="decorator"
+    )
+
+__all__ = ["RangeHandler", "RangePushHandler", "RangePopHandler", "MarkHandler"]
+
+
+class RangeHandler:
+    """
+    Attach a NVTX range to a pair of Ignite events.
+    It pushes an NVTX range at the first event and pops it at the second event.
+    Stores zero-based depth of the range that is started.
+
+    Args:
+        events: a string, pair of Ignite events, pair of Ignite event literals, or pair of Ignite events and literals.
+            If a single string is provided, it should  describe the base name of a pair of default Ignite events
+            with _STARTED and _COMPLETED postfix (like "EPOCH" for Events.EPOCH_STARTED and Events.EPOCH_COMPLETED).
+            The accepted events are: BATCH, ITERATION, EPOCH, and ENGINE.
+            If pair of literals, each should be the literal equivalent of an Ignite event, fo instance:
+            ("EPOCH_STARTED" and "EPOCH_COMPLETED").
+            One can combine events and literals, like (Events.EPOCH_STARTED and "EPOCH_COMPLETED").
+            For the complete list of Events,
+            check https://pytorch.org/ignite/generated/ignite.engine.events.Events.html.
+
+        msg: ASCII message to associate with range.
+            If not provided, the name of first event will be assigned to the NVTX range.
+    """
+
+    def __init__(self, events: str | tuple[str | Events, str | Events], msg: str | None = None) -> None:
+        self.events = self.resolve_events(events)
+        if msg is None:
+            if isinstance(events, str):
+                # assign the prefix of the events
+                msg = events
+            else:
+                # combine events' names
+                msg = "/".join([e.name for e in self.events])
+        self.msg = msg
+        self.depth = None
+
+    def resolve_events(self, events: str | tuple) -> tuple[Events, Events]:
+        """
+        Resolve the input events to create a pair of Ignite events
+        """
+        events = ensure_tuple(events)
+        if len(events) == 1:
+            return self.create_paired_events(events[0])
+        if len(events) == 2:
+            return self.get_event(events[0]), self.get_event(events[1])
+        raise ValueError(f"Exactly two Ignite events should be provided [received {len(events)}].")
+
+    def create_paired_events(self, event: str) -> tuple[Events, Events]:
+        """
+        Create pair of Ignite events from a event prefix name
+        """
+        event = event.upper()
+        event_prefix = {"": "", "ENGINE": "", "EPOCH": "EPOCH_", "ITERATION": "ITERATION_", "BATCH": "GET_BATCH_"}
+        return self.get_event(event_prefix[event] + "STARTED"), self.get_event(event_prefix[event] + "COMPLETED")
+
+    def get_event(self, event: str | Events) -> Events:
+        return Events[event.upper()] if isinstance(event, str) else event
+
+    def attach(self, engine: Engine) -> None:
+        """
+        Attach an NVTX Range to specific Ignite events
+        Args:
+            engine: Ignite Engine, it can be a trainer, validator or evaluator.
+        """
+        engine.add_event_handler(self.events[0], self.range_push)
+        engine.add_event_handler(self.events[1], self.range_pop)
+
+    def range_push(self):
+        self.depth = _nvtx.rangePushA(self.msg)
+
+    def range_pop(self):
+        _nvtx.rangePop()
+
+
+class RangePushHandler:
+    """
+    At a specific event, pushes a range onto a stack of nested range span.
+    Stores zero-based depth of the range that is started.
+
+    Args:
+        msg: ASCII message to associate with range
+    """
+
+    def __init__(self, event: str | Events, msg: str | None = None) -> None:
+        self.event = Events[event.upper()] if isinstance(event, str) else event
+        if msg is None:
+            msg = self.event.name
+        self.msg = msg
+        self.depth = None
+
+    def attach(self, engine: Engine) -> None:
+        """
+        Push an NVTX range at a specific Ignite event
+        Args:
+            engine: Ignite Engine, it can be a trainer, validator or evaluator.
+        """
+        engine.add_event_handler(self.event, self.range_push)
+
+    def range_push(self):
+        self.depth = _nvtx.rangePushA(self.msg)
+
+
+class RangePopHandler:
+    """
+    At a specific event, pop a previously pushed range.
+    Stores zero-based depth of the range that is started.
+
+    Args:
+        msg: ASCII message to associate with range
+    """
+
+    def __init__(self, event: str | Events) -> None:
+        self.event = Events[event.upper()] if isinstance(event, str) else event
+
+    def attach(self, engine: Engine) -> None:
+        """
+        Pop an NVTX range at a specific Ignite event
+        Args:
+            engine: Ignite Engine, it can be a trainer, validator or evaluator.
+        """
+        engine.add_event_handler(self.event, self.range_pop)
+
+    def range_pop(self):
+        _nvtx.rangePop()
+
+
+class MarkHandler:
+    """
+    Mark an instantaneous event that occurred at some point.
+
+    Args:
+        msg: ASCII message to associate with range
+    """
+
+    def __init__(self, event: str | Events, msg: str | None = None) -> None:
+        self.event = Events[event.upper()] if isinstance(event, str) else event
+        if msg is None:
+            msg = self.event.name
+        self.msg = msg
+
+    def attach(self, engine: Engine) -> None:
+        """
+        Add an NVTX mark to a specific Ignite event
+        Args:
+            engine: Ignite Engine, it can be a trainer, validator or evaluator.
+        """
+        engine.add_event_handler(self.event, self.mark)
+
+    def mark(self):
+        _nvtx.markA(self.msg)

source_code/SegMamba/monai/handlers/panoptic_quality.py

@@ -0,0 +1,69 @@
+# Copyright (c) MONAI Consortium
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#     http://www.apache.org/licenses/LICENSE-2.0
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from __future__ import annotations
+
+from collections.abc import Callable
+
+from monai.handlers.ignite_metric import IgniteMetricHandler
+from monai.metrics import PanopticQualityMetric
+from monai.utils import MetricReduction
+
+
+class PanopticQuality(IgniteMetricHandler):
+    """
+    Computes Panoptic quality from full size Tensor and collects average over batch, class-channels, iterations.
+    """
+
+    def __init__(
+        self,
+        num_classes: int,
+        metric_name: str = "pq",
+        reduction: MetricReduction | str = MetricReduction.MEAN_BATCH,
+        match_iou_threshold: float = 0.5,
+        smooth_numerator: float = 1e-6,
+        output_transform: Callable = lambda x: x,
+        save_details: bool = True,
+    ) -> None:
+        """
+
+        Args:
+            num_classes: number of classes. The number should not count the background.
+            metric_name: output metric. The value can be "pq", "sq" or "rq".
+            reduction: define mode of reduction to the metrics, will only apply reduction on `not-nan` values,
+                available reduction modes: {``"none"``, ``"mean"``, ``"sum"``, ``"mean_batch"``, ``"sum_batch"``,
+                ``"mean_channel"``, ``"sum_channel"``}, default to `self.reduction`. if "none", will not do reduction.
+            match_iou_threshold: IOU threshold to determine the pairing between `y_pred` and `y`. Usually,
+                it should >= 0.5, the pairing between instances of `y_pred` and `y` are identical.
+                If set `match_iou_threshold` < 0.5, this function uses Munkres assignment to find the
+                maximal amount of unique pairing.
+            smooth_numerator: a small constant added to the numerator to avoid zero.
+            output_transform: callable to extract `y_pred` and `y` from `ignite.engine.state.output` then
+                construct `(y_pred, y)` pair, where `y_pred` and `y` can be `batch-first` Tensors or
+                lists of `channel-first` Tensors. the form of `(y_pred, y)` is required by the `update()`.
+                `engine.state` and `output_transform` inherit from the ignite concept:
+                https://pytorch.org/ignite/concepts.html#state, explanation and usage example are in the tutorial:
+                https://github.com/Project-MONAI/tutorials/blob/master/modules/batch_output_transform.ipynb.
+            save_details: whether to save metric computation details per image, for example: panoptic quality of
+                every image.
+                default to True, will save to `engine.state.metric_details` dict with the metric name as key.
+
+        See also:
+            :py:meth:`monai.metrics.panoptic_quality.compute_panoptic_quality`
+        """
+        metric_fn = PanopticQualityMetric(
+            num_classes=num_classes,
+            metric_name=metric_name,
+            reduction=reduction,
+            match_iou_threshold=match_iou_threshold,
+            smooth_numerator=smooth_numerator,
+        )
+        super().__init__(metric_fn=metric_fn, output_transform=output_transform, save_details=save_details)

source_code/SegMamba/monai/handlers/postprocessing.py

@@ -0,0 +1,73 @@
+# Copyright (c) MONAI Consortium
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#     http://www.apache.org/licenses/LICENSE-2.0
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from __future__ import annotations
+
+from collections.abc import Callable
+from typing import TYPE_CHECKING
+
+from monai.config import IgniteInfo
+from monai.engines.utils import IterationEvents, engine_apply_transform
+from monai.utils import min_version, optional_import
+
+Events, _ = optional_import("ignite.engine", IgniteInfo.OPT_IMPORT_VERSION, min_version, "Events")
+if TYPE_CHECKING:
+    from ignite.engine import Engine
+else:
+    Engine, _ = optional_import("ignite.engine", IgniteInfo.OPT_IMPORT_VERSION, min_version, "Engine")
+
+
+class PostProcessing:
+    """
+    Ignite handler to execute additional post processing after the post processing in engines.
+    So users can insert other handlers between engine postprocessing and this post processing handler.
+    If using components from `monai.transforms` as the `transform`, recommend to decollate `engine.state.batch`
+    and `engine.state.batch` in the engine(set `decollate=True`) or in the `DecollateBatch` handler first.
+
+    """
+
+    def __init__(self, transform: Callable, event: str = "MODEL_COMPLETED") -> None:
+        """
+        Args:
+            transform: callable function to execute on the `engine.state.batch` and `engine.state.output`.
+                can also be composed transforms.
+            event: expected EVENT to attach the handler, should be "MODEL_COMPLETED" or "ITERATION_COMPLETED".
+                default to "MODEL_COMPLETED".
+
+        """
+        self.transform = transform
+        event = event.upper()
+        if event not in ("MODEL_COMPLETED", "ITERATION_COMPLETED"):
+            raise ValueError("event should be `MODEL_COMPLETED` or `ITERATION_COMPLETED`.")
+        self.event = event
+
+    def attach(self, engine: Engine) -> None:
+        """
+        Args:
+            engine: Ignite Engine, it can be a trainer, validator or evaluator.
+        """
+        if self.event == "MODEL_COMPLETED":
+            engine.add_event_handler(IterationEvents.MODEL_COMPLETED, self)
+        else:
+            engine.add_event_handler(Events.ITERATION_COMPLETED, self)
+
+    def __call__(self, engine: Engine) -> None:
+        """
+        Args:
+            engine: Ignite Engine, it can be a trainer, validator or evaluator.
+        """
+        if not isinstance(engine.state.batch, list) or not isinstance(engine.state.output, list):
+            engine.state.batch, engine.state.output = engine_apply_transform(
+                batch=engine.state.batch, output=engine.state.output, transform=self.transform
+            )
+        else:
+            for i, (b, o) in enumerate(zip(engine.state.batch, engine.state.output)):
+                engine.state.batch[i], engine.state.output[i] = engine_apply_transform(b, o, self.transform)

source_code/SegMamba/monai/handlers/probability_maps.py

@@ -0,0 +1,134 @@
+# Copyright (c) MONAI Consortium
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#     http://www.apache.org/licenses/LICENSE-2.0
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from __future__ import annotations
+
+import logging
+import threading
+from typing import TYPE_CHECKING
+
+import numpy as np
+
+from monai.config import DtypeLike, IgniteInfo
+from monai.data.folder_layout import FolderLayout
+from monai.utils import ProbMapKeys, min_version, optional_import
+from monai.utils.enums import CommonKeys
+
+Events, _ = optional_import("ignite.engine", IgniteInfo.OPT_IMPORT_VERSION, min_version, "Events")
+if TYPE_CHECKING:
+    from ignite.engine import Engine
+else:
+    Engine, _ = optional_import("ignite.engine", IgniteInfo.OPT_IMPORT_VERSION, min_version, "Engine")
+
+
+class ProbMapProducer:
+    """
+    Event handler triggered on completing every iteration to calculate and save the probability map.
+    This handler use metadata from MetaTensor to create the probability map. This can be simply achieved by using
+    `monai.data.SlidingPatchWSIDataset` or `monai.data.MaskedPatchWSIDataset` as the dataset.
+
+    """
+
+    def __init__(
+        self,
+        output_dir: str = "./",
+        output_postfix: str = "",
+        prob_key: str = "pred",
+        dtype: DtypeLike = np.float64,
+        name: str | None = None,
+    ) -> None:
+        """
+        Args:
+            output_dir: output directory to save probability maps.
+            output_postfix: a string appended to all output file names.
+            prob_key: the key associated to the probability output of the model
+            dtype: the data type in which the probability map is stored. Default np.float64.
+            name: identifier of logging.logger to use, defaulting to `engine.logger`.
+
+        """
+        self.folder_layout = FolderLayout(
+            output_dir=output_dir,
+            postfix=output_postfix,
+            extension=".npy",
+            parent=False,
+            makedirs=True,
+            data_root_dir="",
+        )
+
+        self.logger = logging.getLogger(name)
+        self._name = name
+        self.prob_key = prob_key
+        self.dtype = dtype
+        self.prob_map: dict[str, np.ndarray] = {}
+        self.counter: dict[str, int] = {}
+        self.num_done_images: int = 0
+        self.num_images: int = 0
+        self.lock = threading.Lock()
+
+    def attach(self, engine: Engine) -> None:
+        """
+        Args:
+            engine: Ignite Engine, it can be a trainer, validator or evaluator.
+        """
+
+        image_data = engine.data_loader.dataset.image_data  # type: ignore
+        self.num_images = len(image_data)
+
+        # Initialized probability maps for all the images
+        for sample in image_data:
+            name = sample[ProbMapKeys.NAME]
+            self.counter[name] = sample[ProbMapKeys.COUNT]
+            self.prob_map[name] = np.zeros(sample[ProbMapKeys.SIZE], dtype=self.dtype)
+
+        if self._name is None:
+            self.logger = engine.logger
+        if not engine.has_event_handler(self, Events.ITERATION_COMPLETED):
+            engine.add_event_handler(Events.ITERATION_COMPLETED, self)
+        if not engine.has_event_handler(self.finalize, Events.COMPLETED):
+            engine.add_event_handler(Events.COMPLETED, self.finalize)
+
+    def __call__(self, engine: Engine) -> None:
+        """
+        This method assumes self.batch_transform will extract metadata from the input batch.
+
+        Args:
+            engine: Ignite Engine, it can be a trainer, validator or evaluator.
+        """
+        if not isinstance(engine.state.batch, dict) or not isinstance(engine.state.output, dict):
+            raise ValueError("engine.state.batch and engine.state.output must be dictionaries.")
+        names = engine.state.batch[CommonKeys.IMAGE].meta[ProbMapKeys.NAME]
+        locs = engine.state.batch[CommonKeys.IMAGE].meta[ProbMapKeys.LOCATION]
+        probs = engine.state.output[self.prob_key]
+        for name, loc, prob in zip(names, locs, probs):
+            self.prob_map[name][tuple(loc)] = prob
+            with self.lock:
+                self.counter[name] -= 1
+                if self.counter[name] == 0:
+                    self.save_prob_map(name)
+
+    def save_prob_map(self, name: str) -> None:
+        """
+        This method save the probability map for an image, when its inference is finished,
+        and delete that probability map from memory.
+
+        Args:
+            name: the name of image to be saved.
+        """
+        file_path = self.folder_layout.filename(name)
+        np.save(file_path, self.prob_map[name])
+
+        self.num_done_images += 1
+        self.logger.info(f"Inference of '{name}' is done [{self.num_done_images}/{self.num_images}]!")
+        del self.prob_map[name]
+        del self.counter[name]
+
+    def finalize(self, engine: Engine) -> None:
+        self.logger.info(f"Probability map is created for {self.num_done_images}/{self.num_images} images!")

source_code/SegMamba/monai/handlers/regression_metrics.py

@@ -0,0 +1,154 @@
+# Copyright (c) MONAI Consortium
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#     http://www.apache.org/licenses/LICENSE-2.0
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from __future__ import annotations
+
+from collections.abc import Callable
+
+from monai.handlers.ignite_metric import IgniteMetricHandler
+from monai.metrics import MAEMetric, MSEMetric, PSNRMetric, RMSEMetric
+from monai.utils import MetricReduction
+
+
+class MeanSquaredError(IgniteMetricHandler):
+    """
+    Computes Mean Squared Error from full size Tensor and collects average over batch, iterations.
+    """
+
+    def __init__(
+        self,
+        reduction: MetricReduction | str = MetricReduction.MEAN,
+        output_transform: Callable = lambda x: x,
+        save_details: bool = True,
+    ) -> None:
+        """
+
+        Args:
+            reduction: define the mode to reduce metrics, will only execute reduction on `not-nan` values,
+                available reduction modes: {``"none"``, ``"mean"``, ``"sum"``, ``"mean_batch"``, ``"sum_batch"``,
+                ``"mean_channel"``, ``"sum_channel"``}, default to ``"mean"``. if "none", will not do reduction.
+            output_transform: callable to extract `y_pred` and `y` from `ignite.engine.state.output` then
+                construct `(y_pred, y)` pair, where `y_pred` and `y` can be `batch-first` Tensors or
+                lists of `channel-first` Tensors. the form of `(y_pred, y)` is required by the `update()`.
+                `engine.state` and `output_transform` inherit from the ignite concept:
+                https://pytorch.org/ignite/concepts.html#state, explanation and usage example are in the tutorial:
+                https://github.com/Project-MONAI/tutorials/blob/master/modules/batch_output_transform.ipynb.
+            save_details: whether to save metric computation details per image, for example: mean squared error of every image.
+                default to True, will save to `engine.state.metric_details` dict with the metric name as key.
+
+        See also:
+            :py:class:`monai.metrics.MSEMetric`
+        """
+        metric_fn = MSEMetric(reduction=reduction)
+        super().__init__(metric_fn=metric_fn, output_transform=output_transform, save_details=save_details)
+
+
+class MeanAbsoluteError(IgniteMetricHandler):
+    """
+    Computes Mean Absolute Error from full size Tensor and collects average over batch, iterations.
+    """
+
+    def __init__(
+        self,
+        reduction: MetricReduction | str = MetricReduction.MEAN,
+        output_transform: Callable = lambda x: x,
+        save_details: bool = True,
+    ) -> None:
+        """
+
+        Args:
+            reduction: define the mode to reduce metrics, will only execute reduction on `not-nan` values,
+                available reduction modes: {``"none"``, ``"mean"``, ``"sum"``, ``"mean_batch"``, ``"sum_batch"``,
+                ``"mean_channel"``, ``"sum_channel"``}, default to ``"mean"``. if "none", will not do reduction.
+            output_transform: callable to extract `y_pred` and `y` from `ignite.engine.state.output` then
+                construct `(y_pred, y)` pair, where `y_pred` and `y` can be `batch-first` Tensors or
+                lists of `channel-first` Tensors. the form of `(y_pred, y)` is required by the `update()`.
+                `engine.state` and `output_transform` inherit from the ignite concept:
+                https://pytorch.org/ignite/concepts.html#state, explanation and usage example are in the tutorial:
+                https://github.com/Project-MONAI/tutorials/blob/master/modules/batch_output_transform.ipynb.
+            save_details: whether to save metric computation details per image, for example: mean squared error of every image.
+                default to True, will save to `engine.state.metric_details` dict with the metric name as key.
+
+        See also:
+            :py:class:`monai.metrics.MAEMetric`
+        """
+        metric_fn = MAEMetric(reduction=reduction)
+        super().__init__(metric_fn=metric_fn, output_transform=output_transform, save_details=save_details)
+
+
+class RootMeanSquaredError(IgniteMetricHandler):
+    """
+    Computes Root Mean Squared Error from full size Tensor and collects average over batch, iterations.
+    """
+
+    def __init__(
+        self,
+        reduction: MetricReduction | str = MetricReduction.MEAN,
+        output_transform: Callable = lambda x: x,
+        save_details: bool = True,
+    ) -> None:
+        """
+
+        Args:
+            reduction: define the mode to reduce metrics, will only execute reduction on `not-nan` values,
+                available reduction modes: {``"none"``, ``"mean"``, ``"sum"``, ``"mean_batch"``, ``"sum_batch"``,
+                ``"mean_channel"``, ``"sum_channel"``}, default to ``"mean"``. if "none", will not do reduction.
+            output_transform: callable to extract `y_pred` and `y` from `ignite.engine.state.output` then
+                construct `(y_pred, y)` pair, where `y_pred` and `y` can be `batch-first` Tensors or
+                lists of `channel-first` Tensors. the form of `(y_pred, y)` is required by the `update()`.
+                `engine.state` and `output_transform` inherit from the ignite concept:
+                https://pytorch.org/ignite/concepts.html#state, explanation and usage example are in the tutorial:
+                https://github.com/Project-MONAI/tutorials/blob/master/modules/batch_output_transform.ipynb.
+            save_details: whether to save metric computation details per image, for example: mean squared error of every image.
+                default to True, will save to `engine.state.metric_details` dict with the metric name as key.
+
+        See also:
+            :py:class:`monai.metrics.RMSEMetric`
+        """
+        metric_fn = RMSEMetric(reduction=reduction)
+        super().__init__(metric_fn=metric_fn, output_transform=output_transform, save_details=save_details)
+
+
+class PeakSignalToNoiseRatio(IgniteMetricHandler):
+    """
+    Computes Peak Signal to Noise Ratio from full size Tensor and collects average over batch, iterations.
+    """
+
+    def __init__(
+        self,
+        max_val: int | float,
+        reduction: MetricReduction | str = MetricReduction.MEAN,
+        output_transform: Callable = lambda x: x,
+        save_details: bool = True,
+    ) -> None:
+        """
+
+        Args:
+            max_val: The dynamic range of the images/volumes (i.e., the difference between the
+                maximum and the minimum allowed values e.g. 255 for a uint8 image).
+            reduction: define the mode to reduce metrics, will only execute reduction on `not-nan` values,
+                available reduction modes: {``"none"``, ``"mean"``, ``"sum"``, ``"mean_batch"``, ``"sum_batch"``,
+                ``"mean_channel"``, ``"sum_channel"``}, default to ``"mean"``. if "none", will not do reduction.
+            output_transform: callable to extract `y_pred` and `y` from `ignite.engine.state.output` then
+                construct `(y_pred, y)` pair, where `y_pred` and `y` can be `batch-first` Tensors or
+                lists of `channel-first` Tensors. the form of `(y_pred, y)` is required by the `update()`.
+                `engine.state` and `output_transform` inherit from the ignite concept:
+                https://pytorch.org/ignite/concepts.html#state, explanation and usage example are in the tutorial:
+                https://github.com/Project-MONAI/tutorials/blob/master/modules/batch_output_transform.ipynb.
+            save_details: whether to save metric computation details per image, for example: mean squared error of every image.
+                default to True, will save to `engine.state.metric_details` dict with the metric name as key.
+            reduction: {``"none"``, ``"mean"``, ``"sum"``, ``"mean_batch"``, ``"sum_batch"``,
+
+        See also:
+            :py:class:`monai.metrics.PSNRMetric`
+        """
+        metric_fn = PSNRMetric(max_val=max_val, reduction=reduction)
+        super().__init__(metric_fn=metric_fn, output_transform=output_transform, save_details=save_details)

source_code/SegMamba/monai/handlers/roc_auc.py

@@ -0,0 +1,53 @@
+# Copyright (c) MONAI Consortium
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#     http://www.apache.org/licenses/LICENSE-2.0
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from __future__ import annotations
+
+from collections.abc import Callable
+
+from monai.handlers.ignite_metric import IgniteMetricHandler
+from monai.metrics import ROCAUCMetric
+from monai.utils import Average
+
+
+class ROCAUC(IgniteMetricHandler):
+    """
+    Computes Area Under the Receiver Operating Characteristic Curve (ROC AUC).
+    accumulating predictions and the ground-truth during an epoch and applying `compute_roc_auc`.
+
+    Args:
+        average: {``"macro"``, ``"weighted"``, ``"micro"``, ``"none"``}
+            Type of averaging performed if not binary classification. Defaults to ``"macro"``.
+
+            - ``"macro"``: calculate metrics for each label, and find their unweighted mean.
+                This does not take label imbalance into account.
+            - ``"weighted"``: calculate metrics for each label, and find their average,
+                weighted by support (the number of true instances for each label).
+            - ``"micro"``: calculate metrics globally by considering each element of the label
+                indicator matrix as a label.
+            - ``"none"``: the scores for each class are returned.
+
+        output_transform: callable to extract `y_pred` and `y` from `ignite.engine.state.output` then
+            construct `(y_pred, y)` pair, where `y_pred` and `y` can be `batch-first` Tensors or
+            lists of `channel-first` Tensors. the form of `(y_pred, y)` is required by the `update()`.
+            `engine.state` and `output_transform` inherit from the ignite concept:
+            https://pytorch.org/ignite/concepts.html#state, explanation and usage example are in the tutorial:
+            https://github.com/Project-MONAI/tutorials/blob/master/modules/batch_output_transform.ipynb.
+
+    Note:
+        ROCAUC expects y to be comprised of 0's and 1's.
+        y_pred must either be probability estimates or confidence values.
+
+    """
+
+    def __init__(self, average: Average | str = Average.MACRO, output_transform: Callable = lambda x: x) -> None:
+        metric_fn = ROCAUCMetric(average=Average(average))
+        super().__init__(metric_fn=metric_fn, output_transform=output_transform, save_details=False)

source_code/SegMamba/monai/handlers/smartcache_handler.py

@@ -0,0 +1,81 @@
+# Copyright (c) MONAI Consortium
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#     http://www.apache.org/licenses/LICENSE-2.0
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from monai.config import IgniteInfo
+from monai.data import SmartCacheDataset
+from monai.utils import min_version, optional_import
+
+Events, _ = optional_import("ignite.engine", IgniteInfo.OPT_IMPORT_VERSION, min_version, "Events")
+if TYPE_CHECKING:
+    from ignite.engine import Engine
+else:
+    Engine, _ = optional_import("ignite.engine", IgniteInfo.OPT_IMPORT_VERSION, min_version, "Engine")
+
+
+class SmartCacheHandler:
+    """
+    Attach SmartCache logic to the engine in Ignite.
+    Mainly include the `start`, `update_cache`, and `shutdown` functions of SmartCacheDataset.
+
+    """
+
+    def __init__(self, smartcacher: SmartCacheDataset) -> None:
+        """
+        Args:
+            smartcacher: predefined SmartCacheDataset, will attach it to the engine.
+
+        Raises:
+            TypeError: When ``smartcacher`` is not a ``monai.data.SmartCacheDataset``.
+
+        """
+        if not isinstance(smartcacher, SmartCacheDataset):
+            raise TypeError("smartcacher must be a monai.data.SmartCacheDataset.")
+        self.smartcacher = smartcacher
+
+    def attach(self, engine: Engine) -> None:
+        """
+        Args:
+            engine: Ignite Engine, it can be a trainer, validator or evaluator.
+        """
+        engine.add_event_handler(Events.STARTED, self.started)
+        engine.add_event_handler(Events.EPOCH_COMPLETED, self.epoch_completed)
+        engine.add_event_handler(Events.COMPLETED, self.completed)
+
+    def started(self, engine: Engine) -> None:
+        """Callback for train or validation/evaluation started Event.
+        Start the replacement thread of SmartCacheDataset.
+
+        Args:
+            engine: Ignite Engine, it can be a trainer, validator or evaluator.
+        """
+        self.smartcacher.start()
+
+    def epoch_completed(self, engine: Engine) -> None:
+        """Callback for train or validation/evaluation epoch completed Event.
+        Update cache content with replacement data.
+
+        Args:
+            engine: Ignite Engine, it can be a trainer, validator or evaluator.
+        """
+        self.smartcacher.update_cache()
+
+    def completed(self, engine: Engine) -> None:
+        """Callback for train or validation/evaluation completed Event.
+        Stop the replacement thread of SmartCacheDataset.
+
+        Args:
+            engine: Ignite Engine, it can be a trainer, validator or evaluator.
+        """
+        self.smartcacher.shutdown()

source_code/SegMamba/monai/handlers/stats_handler.py

@@ -0,0 +1,293 @@
+# Copyright (c) MONAI Consortium
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#     http://www.apache.org/licenses/LICENSE-2.0
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from __future__ import annotations
+
+import logging
+import warnings
+from collections.abc import Callable, Sequence
+from typing import TYPE_CHECKING, Any
+
+import torch
+
+from monai.apps import get_logger
+from monai.config import IgniteInfo
+from monai.utils import is_scalar, min_version, optional_import
+
+Events, _ = optional_import("ignite.engine", IgniteInfo.OPT_IMPORT_VERSION, min_version, "Events")
+if TYPE_CHECKING:
+    from ignite.engine import Engine
+else:
+    Engine, _ = optional_import(
+        "ignite.engine", IgniteInfo.OPT_IMPORT_VERSION, min_version, "Engine", as_type="decorator"
+    )
+
+DEFAULT_KEY_VAL_FORMAT = "{}: {:.4f} "
+DEFAULT_TAG = "Loss"
+
+
+class StatsHandler:
+    """
+    StatsHandler defines a set of Ignite Event-handlers for all the log printing logics.
+    It can be used for any Ignite Engine(trainer, validator and evaluator).
+    And it can support logging for epoch level and iteration level with pre-defined loggers.
+
+    Note that if ``name`` is None, this class will leverage `engine.logger` as the logger, otherwise,
+    ``logging.getLogger(name)`` is used. In both cases, it's important to make sure that the logging level is at least
+    ``INFO``. To change the level of logging, please call ``import ignite; ignite.utils.setup_logger(name)``
+    (when ``name`` is not None) or ``engine.logger = ignite.utils.setup_logger(engine.logger.name, reset=True)``
+    (when ``name`` is None) before running the engine with this handler attached.
+
+    Default behaviors:
+        - When EPOCH_COMPLETED, logs ``engine.state.metrics`` using ``self.logger``.
+        - When ITERATION_COMPLETED, logs
+          ``self.output_transform(engine.state.output)`` using ``self.logger``.
+
+    Usage example::
+
+        import ignite
+        import monai
+
+        trainer = ignite.engine.Engine(lambda x, y: [0.0])  # an example trainer
+        monai.handlers.StatsHandler(name="train_stats").attach(trainer)
+
+        trainer.run(range(3), max_epochs=4)
+
+    More details of example is available in the tutorial:
+    https://github.com/Project-MONAI/tutorials/blob/master/modules/engines/unet_training_dict.py.
+
+    """
+
+    def __init__(
+        self,
+        iteration_log: bool | Callable[[Engine, int], bool] = True,
+        epoch_log: bool | Callable[[Engine, int], bool] = True,
+        epoch_print_logger: Callable[[Engine], Any] | None = None,
+        iteration_print_logger: Callable[[Engine], Any] | None = None,
+        output_transform: Callable = lambda x: x[0],
+        global_epoch_transform: Callable = lambda x: x,
+        state_attributes: Sequence[str] | None = None,
+        name: str | None = "StatsHandler",
+        tag_name: str = DEFAULT_TAG,
+        key_var_format: str = DEFAULT_KEY_VAL_FORMAT,
+    ) -> None:
+        """
+
+        Args:
+            iteration_log: whether to log data when iteration completed, default to `True`. ``iteration_log`` can
+                be also a function and it will be interpreted as an event filter
+                (see https://pytorch.org/ignite/generated/ignite.engine.events.Events.html for details).
+                Event filter function accepts as input engine and event value (iteration) and should return True/False.
+                Event filtering can be helpful to customize iteration logging frequency.
+            epoch_log: whether to log data when epoch completed, default to `True`. ``epoch_log`` can be
+                also a function and it will be interpreted as an event filter. See ``iteration_log`` argument for more
+                details.
+            epoch_print_logger: customized callable printer for epoch level logging.
+                Must accept parameter "engine", use default printer if None.
+            iteration_print_logger: customized callable printer for iteration level logging.
+                Must accept parameter "engine", use default printer if None.
+            output_transform: a callable that is used to transform the
+                ``ignite.engine.state.output`` into a scalar to print, or a dictionary of {key: scalar}.
+                In the latter case, the output string will be formatted as key: value.
+                By default this value logging happens when every iteration completed.
+                The default behavior is to print loss from output[0] as output is a decollated list
+                and we replicated loss value for every item of the decollated list.
+                `engine.state` and `output_transform` inherit from the ignite concept:
+                https://pytorch.org/ignite/concepts.html#state, explanation and usage example are in the tutorial:
+                https://github.com/Project-MONAI/tutorials/blob/master/modules/batch_output_transform.ipynb.
+            global_epoch_transform: a callable that is used to customize global epoch number.
+                For example, in evaluation, the evaluator engine might want to print synced epoch number
+                with the trainer engine.
+            state_attributes: expected attributes from `engine.state`, if provided, will extract them
+                when epoch completed.
+            name: identifier of `logging.logger` to use, if None, defaulting to ``engine.logger``.
+            tag_name: when iteration output is a scalar, tag_name is used to print
+                tag_name: scalar_value to logger. Defaults to ``'Loss'``.
+            key_var_format: a formatting string to control the output string format of key: value.
+
+        """
+
+        self.iteration_log = iteration_log
+        self.epoch_log = epoch_log
+        self.epoch_print_logger = epoch_print_logger
+        self.iteration_print_logger = iteration_print_logger
+        self.output_transform = output_transform
+        self.global_epoch_transform = global_epoch_transform
+        self.state_attributes = state_attributes
+        self.tag_name = tag_name
+        self.key_var_format = key_var_format
+        self.logger = get_logger(name)  # type: ignore
+        self.name = name
+
+    def attach(self, engine: Engine) -> None:
+        """
+        Register a set of Ignite Event-Handlers to a specified Ignite engine.
+
+        Args:
+            engine: Ignite Engine, it can be a trainer, validator or evaluator.
+
+        """
+        if self.name is None:
+            self.logger = engine.logger
+        if self.logger.getEffectiveLevel() > logging.INFO:
+            suggested = f"\n\nimport ignite\nignite.utils.setup_logger('{self.logger.name}', reset=True)"
+            if self.logger.name != engine.logger.name:
+                suggested += f"\nignite.utils.setup_logger('{engine.logger.name}', reset=True)"
+            suggested += "\n\n"
+            warnings.warn(
+                f"the effective log level of {self.logger.name} is higher than INFO, StatsHandler may not output logs,"
+                f"\nplease use the following code before running the engine to enable it: {suggested}"
+            )
+        if self.iteration_log and not engine.has_event_handler(self.iteration_completed, Events.ITERATION_COMPLETED):
+            event = Events.ITERATION_COMPLETED
+            if callable(self.iteration_log):  # substitute event with new one using filter callable
+                event = event(event_filter=self.iteration_log)
+            engine.add_event_handler(event, self.iteration_completed)
+        if self.epoch_log and not engine.has_event_handler(self.epoch_completed, Events.EPOCH_COMPLETED):
+            event = Events.EPOCH_COMPLETED
+            if callable(self.epoch_log):  # substitute event with new one using filter callable
+                event = event(event_filter=self.epoch_log)
+            engine.add_event_handler(event, self.epoch_completed)
+        if not engine.has_event_handler(self.exception_raised, Events.EXCEPTION_RAISED):
+            engine.add_event_handler(Events.EXCEPTION_RAISED, self.exception_raised)
+
+    def epoch_completed(self, engine: Engine) -> None:
+        """
+        Handler for train or validation/evaluation epoch completed Event.
+        Print epoch level log, default values are from Ignite `engine.state.metrics` dict.
+
+        Args:
+            engine: Ignite Engine, it can be a trainer, validator or evaluator.
+
+        """
+        if self.epoch_print_logger is not None:
+            self.epoch_print_logger(engine)
+        else:
+            self._default_epoch_print(engine)
+
+    def iteration_completed(self, engine: Engine) -> None:
+        """
+        Handler for train or validation/evaluation iteration completed Event.
+        Print iteration level log, default values are from Ignite `engine.state.output`.
+
+        Args:
+            engine: Ignite Engine, it can be a trainer, validator or evaluator.
+
+        """
+        if self.iteration_print_logger is not None:
+            self.iteration_print_logger(engine)
+        else:
+            self._default_iteration_print(engine)
+
+    def exception_raised(self, _engine: Engine, e: Exception) -> None:
+        """
+        Handler for train or validation/evaluation exception raised Event.
+        Print the exception information and traceback. This callback may be skipped because the logic
+        with Ignite can only trigger the first attached handler for `EXCEPTION_RAISED` event.
+
+        Args:
+            _engine: Ignite Engine, unused argument.
+            e: the exception caught in Ignite during engine.run().
+
+        """
+        self.logger.exception(f"Exception: {e}")
+        raise e
+
+    def _default_epoch_print(self, engine: Engine) -> None:
+        """
+        Execute epoch level log operation.
+        Default to print the values from Ignite `engine.state.metrics` dict and
+        print the values of specified attributes of `engine.state`.
+
+        Args:
+            engine: Ignite Engine, it can be a trainer, validator or evaluator.
+
+        """
+        current_epoch = self.global_epoch_transform(engine.state.epoch)
+
+        prints_dict = engine.state.metrics
+        if prints_dict is not None and len(prints_dict) > 0:
+            out_str = f"Epoch[{current_epoch}] Metrics -- "
+            for name in sorted(prints_dict):
+                value = prints_dict[name]
+                out_str += self.key_var_format.format(name, value) if is_scalar(value) else f"{name}: {str(value)}"
+            self.logger.info(out_str)
+
+        if (
+            hasattr(engine.state, "key_metric_name")
+            and hasattr(engine.state, "best_metric")
+            and hasattr(engine.state, "best_metric_epoch")
+            and engine.state.key_metric_name is not None
+        ):
+            out_str = f"Key metric: {engine.state.key_metric_name} "
+            out_str += f"best value: {engine.state.best_metric} "
+            out_str += f"at epoch: {engine.state.best_metric_epoch}"
+            self.logger.info(out_str)
+
+        if self.state_attributes is not None and len(self.state_attributes) > 0:
+            out_str = "State values: "
+            for attr in self.state_attributes:
+                out_str += f"{attr}: {getattr(engine.state, attr, None)} "
+            self.logger.info(out_str)
+
+    def _default_iteration_print(self, engine: Engine) -> None:
+        """
+        Execute iteration log operation based on Ignite `engine.state.output` data.
+        Print the values from `self.output_transform(engine.state.output)`.
+        Since `engine.state.output` is a decollated list and we replicated the loss value for every item
+        of the decollated list, the default behavior is to print the loss from `output[0]`.
+
+        Args:
+            engine: Ignite Engine, it can be a trainer, validator or evaluator.
+
+        """
+        loss = self.output_transform(engine.state.output)
+        if loss is None:
+            return  # no printing if the output is empty
+
+        out_str = ""
+        if isinstance(loss, dict):  # print dictionary items
+            for name in sorted(loss):
+                value = loss[name]
+                if not is_scalar(value):
+                    warnings.warn(
+                        "ignoring non-scalar output in StatsHandler,"
+                        " make sure `output_transform(engine.state.output)` returns"
+                        " a scalar or dictionary of key and scalar pairs to avoid this warning."
+                        " {}:{}".format(name, type(value))
+                    )
+                    continue  # not printing multi dimensional output
+                out_str += self.key_var_format.format(name, value.item() if isinstance(value, torch.Tensor) else value)
+        elif is_scalar(loss):  # not printing multi dimensional output
+            out_str += self.key_var_format.format(
+                self.tag_name, loss.item() if isinstance(loss, torch.Tensor) else loss
+            )
+        else:
+            warnings.warn(
+                "ignoring non-scalar output in StatsHandler,"
+                " make sure `output_transform(engine.state.output)` returns"
+                " a scalar or a dictionary of key and scalar pairs to avoid this warning."
+                " {}".format(type(loss))
+            )
+
+        if not out_str:
+            return  # no value to print
+
+        num_iterations = engine.state.epoch_length
+        current_iteration = engine.state.iteration
+        if num_iterations is not None:
+            current_iteration = (current_iteration - 1) % num_iterations + 1
+        current_epoch = engine.state.epoch
+        num_epochs = engine.state.max_epochs
+
+        base_str = f"Epoch: {current_epoch}/{num_epochs}, Iter: {current_iteration}/{num_iterations} --"
+
+        self.logger.info(" ".join([base_str, out_str]))

source_code/SegMamba/monai/handlers/utils.py

@@ -0,0 +1,219 @@
+# Copyright (c) MONAI Consortium
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#     http://www.apache.org/licenses/LICENSE-2.0
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from __future__ import annotations
+
+import os
+from collections import OrderedDict
+from collections.abc import Callable, Sequence
+from typing import TYPE_CHECKING, Any
+
+import numpy as np
+import torch
+
+from monai.config import IgniteInfo, KeysCollection, PathLike
+from monai.utils import ensure_tuple, look_up_option, min_version, optional_import
+
+idist, _ = optional_import("ignite", IgniteInfo.OPT_IMPORT_VERSION, min_version, "distributed")
+if TYPE_CHECKING:
+    from ignite.engine import Engine
+else:
+    Engine, _ = optional_import("ignite.engine", IgniteInfo.OPT_IMPORT_VERSION, min_version, "Engine")
+
+__all__ = ["stopping_fn_from_metric", "stopping_fn_from_loss", "write_metrics_reports", "from_engine"]
+
+
+def stopping_fn_from_metric(metric_name: str) -> Callable[[Engine], Any]:
+    """
+    Returns a stopping function for ignite.handlers.EarlyStopping using the given metric name.
+    """
+
+    def stopping_fn(engine: Engine) -> Any:
+        return engine.state.metrics[metric_name]
+
+    return stopping_fn
+
+
+def stopping_fn_from_loss() -> Callable[[Engine], Any]:
+    """
+    Returns a stopping function for ignite.handlers.EarlyStopping using the loss value.
+    """
+
+    def stopping_fn(engine: Engine) -> Any:
+        return -engine.state.output  # type:ignore
+
+    return stopping_fn
+
+
+def write_metrics_reports(
+    save_dir: PathLike,
+    images: Sequence[str] | None,
+    metrics: dict[str, torch.Tensor | np.ndarray] | None,
+    metric_details: dict[str, torch.Tensor | np.ndarray] | None,
+    summary_ops: str | Sequence[str] | None,
+    deli: str = ",",
+    output_type: str = "csv",
+    class_labels: list[str] | None = None,
+) -> None:
+    """
+    Utility function to write the metrics into files, contains 3 parts:
+    1. if `metrics` dict is not None, write overall metrics into file, every line is a metric name and value pair.
+    2. if `metric_details` dict is not None,  write raw metric data of every image into file, every line for 1 image.
+    3. if `summary_ops` is not None, compute summary based on operations on `metric_details` and write to file.
+
+    Args:
+        save_dir: directory to save all the metrics reports.
+        images: name or path of every input image corresponding to the metric_details data.
+            if None, will use index number as the filename of every input image.
+        metrics: a dictionary of (metric name, metric value) pairs.
+        metric_details: a dictionary of (metric name, metric raw values) pairs, usually, it comes from metrics
+            computation, for example, the raw value can be the mean_dice of every channel of every input image.
+        summary_ops: expected computation operations to generate the summary report.
+            it can be: None, "*" or list of strings, default to None.
+            None - don't generate summary report for every expected metric_details.
+            "*" - generate summary report for every metric_details with all the supported operations.
+            list of strings - generate summary report for every metric_details with specified operations, they
+            should be within list: ["mean", "median", "max", "min", "<int>percentile", "std", "notnans"].
+            the number in "<int>percentile" should be [0, 100], like: "15percentile". default: "90percentile".
+            for more details, please check: https://numpy.org/doc/stable/reference/generated/numpy.nanpercentile.html.
+            note that: for the overall summary, it computes `nanmean` of all classes for each image first,
+            then compute summary. example of the generated summary report::
+
+                class    mean    median    max    5percentile 95percentile  notnans
+                class0  6.0000   6.0000   7.0000   5.1000      6.9000       2.0000
+                class1  6.0000   6.0000   6.0000   6.0000      6.0000       1.0000
+                mean    6.2500   6.2500   7.0000   5.5750      6.9250       2.0000
+
+        deli: the delimiter character in the saved file, default to "," as the default output type is `csv`.
+            to be consistent with: https://docs.python.org/3/library/csv.html#csv.Dialect.delimiter.
+        output_type: expected output file type, supported types: ["csv"], default to "csv".
+        class_labels: list of class names used to name the classes in the output report, if None,
+            "class0", ..., "classn" are used, default to None.
+
+    """
+    if output_type.lower() != "csv":
+        raise ValueError(f"unsupported output type: {output_type}.")
+
+    if not os.path.exists(save_dir):
+        os.makedirs(save_dir)
+
+    if metrics is not None and len(metrics) > 0:
+        with open(os.path.join(save_dir, "metrics.csv"), "w") as f:
+            for k, v in metrics.items():
+                f.write(f"{k}{deli}{str(v)}\n")
+    if metric_details is not None and len(metric_details) > 0:
+        for k, v in metric_details.items():
+            if isinstance(v, torch.Tensor):
+                v = v.cpu().numpy()
+            if v.ndim == 0:
+                # reshape to [1, 1] if no batch and class dims
+                v = v.reshape((1, 1))
+            elif v.ndim == 1:
+                # reshape to [N, 1] if no class dim
+                v = v.reshape((-1, 1))
+
+            # add the average value of all classes to v
+            if class_labels is None:
+                class_labels = ["class" + str(i) for i in range(v.shape[1])]
+            else:
+                class_labels = [str(i) for i in class_labels]  # ensure to have a list of str
+
+            class_labels += ["mean"]
+            v = np.concatenate([v, np.nanmean(v, axis=1, keepdims=True)], axis=1)
+
+            with open(os.path.join(save_dir, f"{k}_raw.csv"), "w") as f:
+                f.write(f"filename{deli}{deli.join(class_labels)}\n")
+                for i, b in enumerate(v):
+                    f.write(
+                        f"{images[i] if images is not None else str(i)}{deli}"
+                        f"{deli.join([f'{c:.4f}' if isinstance(c, (int, float)) else str(c) for c in b])}\n"
+                    )
+
+            if summary_ops is not None:
+                supported_ops = OrderedDict(
+                    {
+                        "mean": np.nanmean,
+                        "median": np.nanmedian,
+                        "max": np.nanmax,
+                        "min": np.nanmin,
+                        "90percentile": lambda x: np.nanpercentile(x[0], x[1]),
+                        "std": np.nanstd,
+                        "notnans": lambda x: (~np.isnan(x)).sum(),
+                    }
+                )
+                ops = ensure_tuple(summary_ops)
+                if "*" in ops:
+                    ops = tuple(supported_ops.keys())
+
+                def _compute_op(op: str, d: np.ndarray) -> Any:
+                    if not op.endswith("percentile"):
+                        c_op = look_up_option(op, supported_ops)
+                        return c_op(d)
+
+                    threshold = int(op.split("percentile")[0])
+                    return supported_ops["90percentile"]((d, threshold))  # type: ignore
+
+                with open(os.path.join(save_dir, f"{k}_summary.csv"), "w") as f:
+                    f.write(f"class{deli}{deli.join(ops)}\n")
+                    for i, c in enumerate(np.transpose(v)):
+                        f.write(f"{class_labels[i]}{deli}{deli.join([f'{_compute_op(k, c):.4f}' for k in ops])}\n")
+
+
+def from_engine(keys: KeysCollection, first: bool = False) -> Callable:
+    """
+    Utility function to simplify the `batch_transform` or `output_transform` args of ignite components
+    when handling dictionary or list of dictionaries(for example: `engine.state.batch` or `engine.state.output`).
+    Users only need to set the expected keys, then it will return a callable function to extract data from
+    dictionary and construct a tuple respectively.
+
+    If data is a list of dictionaries after decollating, extract expected keys and construct lists respectively,
+    for example, if data is `[{"A": 1, "B": 2}, {"A": 3, "B": 4}]`, from_engine(["A", "B"]): `([1, 3], [2, 4])`.
+
+    It can help avoid a complicated `lambda` function and make the arg of metrics more straight-forward.
+    For example, set the first key as the prediction and the second key as label to get the expected data
+    from `engine.state.output` for a metric::
+
+        from monai.handlers import MeanDice, from_engine
+
+        metric = MeanDice(
+            include_background=False,
+            output_transform=from_engine(["pred", "label"])
+        )
+
+    Args:
+        keys: specified keys to extract data from dictionary or decollated list of dictionaries.
+        first: whether only extract specified keys from the first item if input data is a list of dictionaries,
+            it's used to extract the scalar data which doesn't have batch dim and was replicated into every
+            dictionary when decollating, like `loss`, etc.
+
+
+    """
+    _keys = ensure_tuple(keys)
+
+    def _wrapper(data):
+        if isinstance(data, dict):
+            return tuple(data[k] for k in _keys)
+        if isinstance(data, list) and isinstance(data[0], dict):
+            # if data is a list of dictionaries, extract expected keys and construct lists,
+            # if `first=True`, only extract keys from the first item of the list
+            ret = [data[0][k] if first else [i[k] for i in data] for k in _keys]
+            return tuple(ret) if len(ret) > 1 else ret[0]
+
+    return _wrapper
+
+
+def ignore_data(x: Any) -> None:
+    """
+    Always return `None` for any input data.
+    A typical usage is to avoid logging the engine output of every iteration during evaluation.
+
+    """
+    return None

source_code/SegMamba/monai/handlers/validation_handler.py

@@ -0,0 +1,86 @@
+# Copyright (c) MONAI Consortium
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#     http://www.apache.org/licenses/LICENSE-2.0
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from monai.config import IgniteInfo
+from monai.engines.evaluator import Evaluator
+from monai.utils import min_version, optional_import
+
+Events, _ = optional_import("ignite.engine", IgniteInfo.OPT_IMPORT_VERSION, min_version, "Events")
+if TYPE_CHECKING:
+    from ignite.engine import Engine
+else:
+    Engine, _ = optional_import("ignite.engine", IgniteInfo.OPT_IMPORT_VERSION, min_version, "Engine")
+
+
+class ValidationHandler:
+    """
+    Attach validator to the trainer engine in Ignite.
+    It can support to execute validation every N epochs or every N iterations.
+
+    """
+
+    def __init__(
+        self, interval: int, validator: Evaluator | None = None, epoch_level: bool = True, exec_at_start: bool = False
+    ) -> None:
+        """
+        Args:
+            interval: do validation every N epochs or every N iterations during training.
+            validator: run the validator when trigger validation, suppose to be Evaluator.
+                if None, should call `set_validator()` before training.
+            epoch_level: execute validation every N epochs or N iterations.
+                `True` is epoch level, `False` is iteration level.
+            exec_at_start: whether to execute a validation first when starting the training.
+                default to `False`. It can be useful especially for some transfer-learning cases
+                to validate the initial model before training.
+
+        Raises:
+            TypeError: When ``validator`` is not a ``monai.engines.evaluator.Evaluator``.
+
+        """
+        if validator is not None and not isinstance(validator, Evaluator):
+            raise TypeError(f"validator must be a monai.engines.evaluator.Evaluator but is {type(validator).__name__}.")
+        self.validator = validator
+        self.interval = interval
+        self.epoch_level = epoch_level
+        self.exec_at_start = exec_at_start
+
+    def set_validator(self, validator: Evaluator) -> None:
+        """
+        Set validator if not setting in the __init__().
+        """
+        if not isinstance(validator, Evaluator):
+            raise TypeError(f"validator must be a monai.engines.evaluator.Evaluator but is {type(validator).__name__}.")
+        self.validator = validator
+
+    def attach(self, engine: Engine) -> None:
+        """
+        Args:
+            engine: Ignite Engine, it can be a trainer, validator or evaluator.
+        """
+        if self.epoch_level:
+            engine.add_event_handler(Events.EPOCH_COMPLETED(every=self.interval), self)
+        else:
+            engine.add_event_handler(Events.ITERATION_COMPLETED(every=self.interval), self)
+        if self.exec_at_start:
+            engine.add_event_handler(Events.STARTED, self)
+
+    def __call__(self, engine: Engine) -> None:
+        """
+        Args:
+            engine: Ignite Engine, it can be a trainer, validator or evaluator.
+        """
+        if self.validator is None:
+            raise RuntimeError("please set validator in __init__() or call `set_validator()` before training.")
+        self.validator.run(engine.state.epoch)

source_code/SegMamba/monai/inferers/merger.py

@@ -0,0 +1,381 @@
+# Copyright (c) MONAI Consortium
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#     http://www.apache.org/licenses/LICENSE-2.0
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from __future__ import annotations
+
+import threading
+from abc import ABC, abstractmethod
+from collections.abc import Sequence
+from contextlib import nullcontext
+from typing import TYPE_CHECKING, Any
+
+import numpy as np
+import torch
+
+from monai.utils import ensure_tuple_size, optional_import, require_pkg
+
+if TYPE_CHECKING:
+    import zarr
+else:
+    zarr, _ = optional_import("zarr")
+
+__all__ = ["Merger", "AvgMerger", "ZarrAvgMerger"]
+
+
+class Merger(ABC):
+    """
+    A base class for merging patches.
+    Extend this class to support operations for `PatchInference`.
+    There are two methods that must be implemented in the concrete classes:
+
+        - aggregate: aggregate the values at their corresponding locations
+        - finalize: perform any final process and return the merged output
+
+    Args:
+        merged_shape: the shape of the tensor required to merge the patches.
+        cropped_shape: the shape of the final merged output tensor.
+            If not provided, it will be the same as `merged_shape`.
+        device: the device where Merger tensors should reside.
+    """
+
+    def __init__(
+        self,
+        merged_shape: Sequence[int],
+        cropped_shape: Sequence[int] | None = None,
+        device: torch.device | str | None = None,
+    ) -> None:
+        self.merged_shape = merged_shape
+        self.cropped_shape = self.merged_shape if cropped_shape is None else cropped_shape
+        self.device = device
+        self.is_finalized = False
+
+    @abstractmethod
+    def aggregate(self, values: torch.Tensor, location: Sequence[int]) -> None:
+        """
+        Aggregate values for merging.
+        This method is being called in a loop and should add values to their corresponding location in the merged output results.
+
+        Args:
+            values: a tensor of shape BCHW[D], representing the values of inference output.
+            location: a tuple/list giving the top left location of the patch in the output.
+
+        Raises:
+            NotImplementedError: When the subclass does not override this method.
+
+        """
+        raise NotImplementedError(f"Subclass {self.__class__.__name__} must implement this method.")
+
+    @abstractmethod
+    def finalize(self) -> Any:
+        """
+        Perform final operations for merging patches and return the final merged output.
+
+        Returns:
+            The results of merged patches, which is commonly a torch.Tensor representing the merged result, or
+                a string representing the filepath to the merged results on disk.
+
+        Raises:
+            NotImplementedError: When the subclass does not override this method.
+
+        """
+        raise NotImplementedError(f"Subclass {self.__class__.__name__} must implement this method.")
+
+
+class AvgMerger(Merger):
+    """Merge patches by taking average of the overlapping area
+
+    Args:
+        merged_shape: the shape of the tensor required to merge the patches.
+        cropped_shape: the shape of the final merged output tensor.
+            If not provided, it will be the same as `merged_shape`.
+        device: the device for aggregator tensors and final results.
+        value_dtype: the dtype for value aggregating tensor and the final result.
+        count_dtype: the dtype for sample counting tensor.
+    """
+
+    def __init__(
+        self,
+        merged_shape: Sequence[int],
+        cropped_shape: Sequence[int] | None = None,
+        value_dtype: torch.dtype = torch.float32,
+        count_dtype: torch.dtype = torch.uint8,
+        device: torch.device | str = "cpu",
+    ) -> None:
+        super().__init__(merged_shape=merged_shape, cropped_shape=cropped_shape, device=device)
+        if not self.merged_shape:
+            raise ValueError(f"`merged_shape` must be provided for `AvgMerger`. {self.merged_shape} is give.")
+        self.value_dtype = value_dtype
+        self.count_dtype = count_dtype
+        self.values = torch.zeros(self.merged_shape, dtype=self.value_dtype, device=self.device)
+        self.counts = torch.zeros(self.merged_shape, dtype=self.count_dtype, device=self.device)
+
+    def aggregate(self, values: torch.Tensor, location: Sequence[int]) -> None:
+        """
+        Aggregate values for merging.
+
+        Args:
+            values: a tensor of shape BCHW[D], representing the values of inference output.
+            location: a tuple/list giving the top left location of the patch in the original image.
+
+        Raises:
+            NotImplementedError: When the subclass does not override this method.
+
+        """
+        if self.is_finalized:
+            raise ValueError("`AvgMerger` is already finalized. Please instantiate a new object to aggregate.")
+        patch_size = values.shape[2:]
+        map_slice = tuple(slice(loc, loc + size) for loc, size in zip(location, patch_size))
+        map_slice = ensure_tuple_size(map_slice, values.ndim, pad_val=slice(None), pad_from_start=True)
+        self.values[map_slice] += values
+        self.counts[map_slice] += 1
+
+    def finalize(self) -> torch.Tensor:
+        """
+        Finalize merging by dividing values by counts and return the merged tensor.
+
+        Notes:
+            To avoid creating a new tensor for the final results (to save memory space),
+            after this method is called, `get_values()` method will return the "final" averaged values,
+            and not the accumulating values. Also calling `finalize()` multiple times does not have any effect.
+
+        Returns:
+            torch.tensor: a tensor of merged patches
+        """
+        # guard against multiple call to finalize
+        if not self.is_finalized:
+            # use in-place division to save space
+            self.values.div_(self.counts)
+            # finalize the shape
+            self.values = self.values[tuple(slice(0, end) for end in self.cropped_shape)]
+            # set finalize flag to protect performing in-place division again
+            self.is_finalized = True
+
+        return self.values
+
+    def get_output(self) -> torch.Tensor:
+        """
+        Get the final merged output.
+
+        Returns:
+            torch.Tensor: merged output.
+        """
+        return self.finalize()
+
+    def get_values(self) -> torch.Tensor:
+        """
+        Get the accumulated values during aggregation or final averaged values after it is finalized.
+
+        Returns:
+            torch.tensor: aggregated values.
+
+        Notes:
+            - If called before calling `finalize()`, this method returns the accumulating values.
+            - If called after calling `finalize()`, this method returns the final merged [and averaged] values.
+        """
+        return self.values
+
+    def get_counts(self) -> torch.Tensor:
+        """
+        Get the aggregator tensor for number of samples.
+
+        Returns:
+            torch.Tensor: number of accumulated samples at each location.
+        """
+        return self.counts
+
+
+@require_pkg(pkg_name="zarr")
+class ZarrAvgMerger(Merger):
+    """Merge patches by taking average of the overlapping area and store the results in zarr array.
+
+    Zarr is a format for the storage of chunked, compressed, N-dimensional arrays.
+    Zarr data can be stored in any storage system that can be represented as a key-value store,
+    like POSIX file systems, cloud object storage, zip files, and relational and document databases.
+    See https://zarr.readthedocs.io/en/stable/ for more details.
+    It is particularly useful for storing N-dimensional arrays too large to fit into memory.
+    One specific use case of this class is to merge patches extracted from whole slide images (WSI),
+    where the merged results do not fit into memory and need to be stored on a file system.
+
+    Args:
+        merged_shape: the shape of the tensor required to merge the patches.
+        cropped_shape: the shape of the final merged output tensor.
+            If not provided, it will be the same as `merged_shape`.
+        dtype: the dtype for the final merged result. Default is `float32`.
+        value_dtype: the dtype for value aggregating tensor and the final result. Default is `float32`.
+        count_dtype: the dtype for sample counting tensor. Default is `uint8`.
+        store: the zarr store to save the final results. Default is "merged.zarr".
+        value_store: the zarr store to save the value aggregating tensor. Default is a temporary store.
+        count_store: the zarr store to save the sample counting tensor. Default is a temporary store.
+        compressor: the compressor for final merged zarr array. Default is "default".
+        value_compressor: the compressor for value aggregating zarr array. Default is None.
+        count_compressor: the compressor for sample counting zarr array. Default is None.
+        chunks : int or tuple of ints that defines the chunk shape, or boolean. Default is True.
+            If True, chunk shape will be guessed from `shape` and `dtype`.
+            If False, it will be set to `shape`, i.e., single chunk for the whole array.
+            If an int, the chunk size in each dimension will be given by the value of `chunks`.
+    """
+
+    def __init__(
+        self,
+        merged_shape: Sequence[int],
+        cropped_shape: Sequence[int] | None = None,
+        dtype: np.dtype | str = "float32",
+        value_dtype: np.dtype | str = "float32",
+        count_dtype: np.dtype | str = "uint8",
+        store: zarr.storage.Store | str = "merged.zarr",
+        value_store: zarr.storage.Store | str | None = None,
+        count_store: zarr.storage.Store | str | None = None,
+        compressor: str = "default",
+        value_compressor: str | None = None,
+        count_compressor: str | None = None,
+        chunks: Sequence[int] | bool = True,
+        thread_locking: bool = True,
+    ) -> None:
+        super().__init__(merged_shape=merged_shape, cropped_shape=cropped_shape)
+        if not self.merged_shape:
+            raise ValueError(f"`merged_shape` must be provided for `ZarrAvgMerger`. {self.merged_shape} is give.")
+        self.output_dtype = dtype
+        self.value_dtype = value_dtype
+        self.count_dtype = count_dtype
+        self.store = store
+        self.value_store = zarr.storage.TempStore() if value_store is None else value_store
+        self.count_store = zarr.storage.TempStore() if count_store is None else count_store
+        self.chunks = chunks
+        self.compressor = compressor
+        self.value_compressor = value_compressor
+        self.count_compressor = count_compressor
+        self.output = zarr.empty(
+            shape=self.merged_shape,
+            chunks=self.chunks,
+            dtype=self.output_dtype,
+            compressor=self.compressor,
+            store=self.store,
+            overwrite=True,
+        )
+        self.values = zarr.zeros(
+            shape=self.merged_shape,
+            chunks=self.chunks,
+            dtype=self.value_dtype,
+            compressor=self.value_compressor,
+            store=self.value_store,
+            overwrite=True,
+        )
+        self.counts = zarr.zeros(
+            shape=self.merged_shape,
+            chunks=self.chunks,
+            dtype=self.count_dtype,
+            compressor=self.count_compressor,
+            store=self.count_store,
+            overwrite=True,
+        )
+        self.lock: threading.Lock | nullcontext
+        if thread_locking:
+            # use lock to protect the in-place addition during aggregation
+            self.lock = threading.Lock()
+        else:
+            # use nullcontext to avoid the locking if not needed
+            self.lock = nullcontext()
+
+    def aggregate(self, values: torch.Tensor, location: Sequence[int]) -> None:
+        """
+        Aggregate values for merging.
+
+        Args:
+            values: a tensor of shape BCHW[D], representing the values of inference output.
+            location: a tuple/list giving the top left location of the patch in the original image.
+        """
+        if self.is_finalized:
+            raise ValueError("`ZarrAvgMerger` is already finalized. Please instantiate a new object to aggregate.")
+        patch_size = values.shape[2:]
+        map_slice = tuple(slice(loc, loc + size) for loc, size in zip(location, patch_size))
+        map_slice = ensure_tuple_size(map_slice, values.ndim, pad_val=slice(None), pad_from_start=True)
+        with self.lock:
+            self.values[map_slice] += values.numpy()
+            self.counts[map_slice] += 1
+
+    def finalize(self) -> zarr.Array:
+        """
+        Finalize merging by dividing values by counts and return the merged tensor.
+
+        Notes:
+            To avoid creating a new tensor for the final results (to save memory space),
+            after this method is called, `get_values()` method will return the "final" averaged values,
+            and not the accumulating values. Also calling `finalize()` multiple times does not have any effect.
+
+        Returns:
+            zarr.Array: a zarr array of of merged patches
+        """
+        # guard against multiple calls to finalize
+        if not self.is_finalized:
+            # use chunks for division to fit into memory
+            for chunk in iterate_over_chunks(self.values.chunks, self.values.cdata_shape):
+                self.output[chunk] = self.values[chunk] / self.counts[chunk]
+            # finalize the shape
+            self.output.resize(self.cropped_shape)
+            # set finalize flag to protect performing in-place division again
+            self.is_finalized = True
+
+        return self.output
+
+    def get_output(self) -> zarr.Array:
+        """
+        Get the final merged output.
+
+        Returns:
+            zarr.Array: Merged (averaged) output tensor.
+        """
+        return self.output
+
+    def get_values(self) -> zarr.Array:
+        """
+        Get the accumulated values during aggregation
+
+        Returns:
+            zarr.Array: aggregated values.
+
+        """
+        return self.values
+
+    def get_counts(self) -> zarr.Array:
+        """
+        Get the aggregator tensor for number of samples.
+
+        Returns:
+            zarr.Array: Number of accumulated samples at each location.
+        """
+        return self.counts
+
+
+def iterate_over_chunks(chunks, cdata_shape, slice_tuple=()):
+    """
+    Iterate over chunks of a given shape.
+
+    Args:
+        chunks: the chunk shape
+        cdata_shape: the shape of the data in chunks
+        slice_tuple: the slice tuple to be used for indexing
+
+    Raises:
+        ValueError: When the length of chunks and cdata_shape are not the same.
+
+    Yields:
+        slices of the data
+    """
+    if len(chunks) != len(cdata_shape):
+        raise ValueError("chunks and cdata_shape must have the same length")
+    if len(chunks) == 1:
+        for i in range(cdata_shape[0]):
+            yield slice_tuple + (slice(i * chunks[0], (i + 1) * chunks[0]),)
+    else:
+        for i in range(cdata_shape[0]):
+            yield from iterate_over_chunks(
+                chunks[1:], cdata_shape[1:], slice_tuple + (slice(i * chunks[0], (i + 1) * chunks[0]),)
+            )

source_code/SegMamba/monai/inferers/splitter.py

@@ -0,0 +1,444 @@
+# Copyright (c) MONAI Consortium
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#     http://www.apache.org/licenses/LICENSE-2.0
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from __future__ import annotations
+
+import os
+import warnings
+from abc import ABC, abstractmethod
+from collections.abc import Callable, Iterable, Sequence
+from inspect import _empty, isclass, signature
+from typing import Any
+
+import torch
+
+from monai.data.utils import iter_patch_position
+from monai.data.wsi_reader import BaseWSIReader, WSIReader
+from monai.transforms.utility.array import convert_to_tensor
+from monai.utils.misc import PathLike, ensure_tuple, ensure_tuple_rep
+
+__all__ = ["Splitter", "SlidingWindowSplitter", "WSISlidingWindowSplitter"]
+
+
+class Splitter(ABC):
+    """
+    A base class for splitting the inputs into iterable tuple of patches and locations
+    Extend this class to support operations for `PatchInference`, e.g. SlidingPatchSplitter.
+
+    Args:
+        patch_size: the size of patches to be generated.
+        device: the device where the patches are generated.
+    """
+
+    def __init__(self, patch_size: Sequence[int] | int, device: torch.device | str | None = None) -> None:
+        self.patch_size = patch_size
+        self.device = device
+
+    @abstractmethod
+    def get_input_shape(self, inputs: Any) -> tuple:
+        """
+        Return the input spatial shape.
+
+        Args:
+            inputs: either a tensor of shape BCHW[D], representing a batch of images,
+                or a filename (str) or list of filenames to the image(s).
+
+        Raises:
+            NotImplementedError: When the subclass does not override this method.
+
+        """
+        raise NotImplementedError(f"Subclass {self.__class__.__name__} must implement this method.")
+
+    @abstractmethod
+    def get_padded_shape(self, inputs: Any) -> tuple:
+        """
+        Return the actual spatial shape covered by the output split patches.
+        For instance, if the input image is padded, the actual spatial shape will be enlarged
+        and not the same as input spatial shape.
+
+        Args:
+            inputs: either a tensor of shape BCHW[D], representing a batch of images,
+                or a filename (str) or list of filenames to the image(s).
+
+        Raises:
+            NotImplementedError: When the subclass does not override this method.
+
+        """
+        raise NotImplementedError(f"Subclass {self.__class__.__name__} must implement this method.")
+
+    @abstractmethod
+    def __call__(self, inputs: Any) -> Iterable[tuple[torch.Tensor, Sequence[int]]]:
+        """
+        Split the input image (or batch of images) into patches and return pairs of (patch, location).
+        Where location is the coordinate of top left [front] corner of a patch.
+
+        Args:
+            inputs: either a tensor of shape BCHW[D], representing a batch of images,
+                or a filename (str) or list of filenames to the image(s).
+
+        Raises:
+            NotImplementedError: When the subclass does not override this method.
+
+        """
+        raise NotImplementedError(f"Subclass {self.__class__.__name__} must implement this method.")
+
+
+class SlidingWindowSplitter(Splitter):
+    """
+    Splits the input into patches with sliding window strategy and a possible overlap.
+    It also allows offsetting the starting position and filtering the patches.
+
+    Args:
+        patch_size : the size of the patches to be generated.
+        offset: the amount of offset for the patches with respect to the original input.  Defaults to 0.
+        overlap: the amount of overlap between patches in each dimension. It can be either a float in
+            the range of [0.0, 1.0) that defines relative overlap to the patch size, or it can be a non-negative int
+            that defines number of pixels for overlap. Defaults to 0.0.
+        filter_fn: a callable to filter patches. It should accepts exactly two parameters (patch, location), and
+            return True for a patch to keep. Defaults to no filtering.
+        pad_mode: string define the mode for `torch.nn.functional.pad`. The acceptable values are
+            `"constant"`, `"reflect"`, `"replicate"`, `"circular"` or `None`. Default to `"constant"`.
+            If None, no padding will be applied, so it will drop the patches crossing the border of
+            the image (either when the offset is negative or the image is non-divisible by the patch_size).
+        pad_value: the value for `"constant"` padding. Defaults to 0.
+        device: the device where the patches are generated. Defaults to the device of inputs.
+
+    Note:
+        When a scaler value is provided for `patch_size`, `offset`, or `overlap`,
+            it is broadcasted to all the spatial dimensions.
+    """
+
+    def __init__(
+        self,
+        patch_size: Sequence[int] | int,
+        overlap: Sequence[float] | float | Sequence[int] | int = 0.0,
+        offset: Sequence[int] | int = 0,
+        filter_fn: Callable | None = None,
+        pad_mode: str | None = "constant",
+        pad_value: float | int = 0,
+        device: torch.device | str | None = None,
+    ) -> None:
+        super().__init__(patch_size=patch_size, device=device)
+        self.offset = offset
+        # check if fraction overlaps are within the range of [0, 1)
+        if isinstance(ensure_tuple(overlap)[0], float) and any(ov < 0.0 or ov >= 1.0 for ov in ensure_tuple(overlap)):
+            raise ValueError(
+                f"Relative overlap must be between 0.0 and 1.0 but {overlap} is given. "
+                "If you wish to use number of pixels as overlap, please provide integer numbers."
+            )
+        elif any(ov < 0 for ov in ensure_tuple(overlap)):
+            raise ValueError(f"Number of pixels for overlap cannot be negative. {overlap} is given. ")
+
+        self.overlap = overlap
+        self.filter_fn = self._validate_filter_fn(filter_fn)
+        # padding
+        self.pad_mode = pad_mode
+        self.pad_value = pad_value
+        # check a valid padding mode is provided if there is any negative offset.
+        if not self.pad_mode and any(off < 0 for off in ensure_tuple(offset)):
+            raise ValueError(f"Negative `offset`requires a valid padding mode but `mode` is set to {self.pad_mode}.")
+
+    @staticmethod
+    def _validate_filter_fn(filter_fn):
+        if callable(filter_fn):
+            sig = signature(filter_fn)
+            n_params = len(sig.parameters)
+            num_pos_params = len([v for v in sig.parameters.values() if v.default is _empty])
+            if n_params < 2:
+                raise ValueError(
+                    f"`filter_fn` requires to accept at least two parameters (patch, location)."
+                    f"The provided callable ({filter_fn}) has {n_params} parameters."
+                )
+            elif num_pos_params > 2:
+                raise ValueError(
+                    f"`filter_fn` can have at most two positional parameters (patch, location)."
+                    f"The provided callable ({filter_fn}) has {num_pos_params} positional parameters."
+                )
+        elif filter_fn is not None:
+            raise ValueError(
+                "`filter_fn` should be a callable with two input parameters (patch, location). "
+                f"{type(filter_fn)} is given."
+            )
+        return filter_fn
+
+    def _calculate_pad_size(self, spatial_shape, spatial_ndim, patch_size, offset, overlap):
+        # initialize with zero
+        pad_size = [0] * 2 * spatial_ndim
+        if not self.pad_mode:
+            return pad_size, False
+        # set the starting pad size only if the offset is negative
+        pad_size[1::2] = (-min(off, 0) for off in offset)
+        # set the ending pad size only if it is not divisible by the patch size
+        end_padding = []
+        for sh, off, ps, ov in zip(spatial_shape, offset, patch_size, overlap):
+            if ps == 0:
+                pad_amount = 0
+            else:
+                if isinstance(ov, float):
+                    pad_amount = (off - sh + ps) % round(ps - (ps * ov))
+                else:
+                    pad_amount = (off - sh + ps) % round(ps - ov)
+            end_padding.append(pad_amount)
+
+        pad_size[::2] = end_padding
+        return pad_size, any(pad_size[1::2])
+
+    def _get_valid_shape_parameters(
+        self, spatial_shape: Sequence[int]
+    ) -> tuple[tuple[int, ...], tuple[float, ...] | tuple[int, ...], tuple[int, ...]]:
+        spatial_ndim = len(spatial_shape)
+        # patch_size
+        patch_size = ensure_tuple_rep(self.patch_size, spatial_ndim)
+        # overlap
+        overlap = ensure_tuple_rep(self.overlap, spatial_ndim)
+        overlap = tuple(o if p else type(overlap[0])(0) for o, p in zip(overlap, patch_size))
+        if any(ov > ps for ov, ps in zip(overlap, patch_size)):
+            raise ValueError(f"`overlap` ({overlap}) cannot be larger than patch size ({patch_size}).")
+        # offset
+        offset = ensure_tuple_rep(self.offset, spatial_ndim)
+        for off, ps, sh in zip(offset, patch_size, spatial_shape):
+            if off < -ps:
+                raise ValueError(f"Negative `offset` ({off}) cannot be larger than `patch_size` ({ps}) in magnitude.")
+            if off >= sh:
+                raise ValueError(f"`offset` ({off}) cannot be larger than inputs size ({sh}).")
+        return patch_size, overlap, offset
+
+    def _get_patch(self, inputs: Any, location: tuple[int, ...], patch_size: tuple[int, ...]) -> Any:
+        slices = (slice(None),) * 2 + tuple(slice(loc, loc + ps) for loc, ps in zip(location, patch_size))
+        return inputs[slices]
+
+    def get_input_shape(self, inputs: Any) -> tuple:
+        """
+        Return the input spatial shape.
+
+        Args:
+            inputs: either a tensor of shape BCHW[D], representing a batch of images,
+                or a filename (str) or list of filenames to the image(s).
+
+        Returns:
+            spatial_shape
+        """
+        return tuple(inputs.shape[2:])
+
+    def get_padded_shape(self, inputs: Any) -> tuple:
+        """
+        Return the actual spatial shape covered by the output split patches.
+        For instance, if the input image is padded, the actual spatial shape will be enlarged
+        and not the same as input spatial shape.
+
+        Args:
+            inputs: either a tensor of shape BCHW[D], representing a batch of images,
+                or a filename (str) or list of filenames to the image(s).
+
+        Returns:
+            padded_spatial_shape
+
+        """
+        spatial_shape = self.get_input_shape(inputs)
+        if not self.pad_mode:
+            return spatial_shape
+        spatial_ndim = len(spatial_shape)
+        patch_size, overlap, offset = self._get_valid_shape_parameters(spatial_shape)
+        pad_size, _ = self._calculate_pad_size(spatial_shape, spatial_ndim, patch_size, offset, overlap)
+        padded_spatial_shape = tuple(ss + ps + pe for ss, ps, pe in zip(spatial_shape, pad_size[1::2], pad_size[::2]))
+
+        return padded_spatial_shape
+
+    def __call__(self, inputs: Any) -> Iterable[tuple[torch.Tensor, Sequence[int]]]:
+        """Split the input tensor into patches and return patches and locations.
+
+        Args:
+            inputs: either a torch.Tensor with BCHW[D] dimensions, representing an image or a batch of images
+
+        Yields:
+            tuple[torch.Tensor, Sequence[int]]: yields tuple of patch and location
+        """
+
+        if not isinstance(inputs, torch.Tensor):
+            raise ValueError(f"The input should be a tensor. {type(inputs)} is given.")
+
+        spatial_shape = inputs.shape[2:]
+        spatial_ndim = len(spatial_shape)
+        patch_size, overlap, offset = self._get_valid_shape_parameters(spatial_shape)
+        pad_size, is_start_padded = self._calculate_pad_size(spatial_shape, spatial_ndim, patch_size, offset, overlap)
+
+        # Padding
+        if self.pad_mode and any(pad_size):
+            # pad the inputs
+            inputs = torch.nn.functional.pad(inputs, pad_size[::-1], mode=self.pad_mode, value=self.pad_value)
+            # update spatial shape
+            spatial_shape = inputs.shape[2:]
+            # correct the offset with respect to the padded image
+            if is_start_padded:
+                offset = tuple(off + p for off, p in zip(offset, pad_size[1::2]))
+
+        # Splitting
+        for location in iter_patch_position(spatial_shape, patch_size, offset, overlap, False):
+            patch = self._get_patch(inputs, location, patch_size)
+            patch = convert_to_tensor(patch, device=self.device)
+            # correct the location with respect to original inputs (remove starting pads)
+            if is_start_padded:
+                location = tuple(loc - p for loc, p in zip(location, pad_size[1::2]))
+            # filter patch and yield
+            if self.filter_fn is None or self.filter_fn(patch, location):
+                yield patch, location
+
+
+class WSISlidingWindowSplitter(SlidingWindowSplitter):
+    """
+    Splits the whole slide image input into patches with sliding window strategy and a possible overlap.
+    This extracts patches from file without loading the entire slide into memory.
+    It also allows offsetting the starting position and filtering the patches.
+
+    Args:
+        patch_size : the size of the patches to be generated.
+        offset: the amount of offset for the patches with respect to the original input.  Defaults to 0.
+        overlap: the amount of overlap between patches in each dimension. It can be either a float in
+            the range of [0.0, 1.0) that defines relative overlap to the patch size, or it can be a non-negative int
+            that defines number of pixels for overlap. Defaults to 0.0.
+        filter_fn: a callable to filter patches. It should accepts exactly two parameters (patch, location), and
+            return True for a patch to keep. Defaults to no filtering.
+        pad_mode: define the mode for padding. Either "constant" or None. Default to "constant".
+            Padding is only supported with "OpenSlide" or "cuCIM" backend, and the filling value is 256.
+        device: the device where the patches are generated. Defaults to the device of inputs.
+        reader: the module to be used for loading whole slide imaging. If `reader` is
+
+            - a string, it defines the backend of `monai.data.WSIReader`. Defaults to "OpenSlide".
+            - a class (inherited from `BaseWSIReader`), it is initialized and set as wsi_reader.
+            - an instance of a class inherited from `BaseWSIReader`, it is set as the wsi_reader.
+
+            To obtain an optimized performance please use either "cuCIM" or "OpenSlide" backend.
+        reader_kwargs: the arguments to pass to `WSIReader` or the provided whole slide reader class.
+            For instance, level=2, dtype=torch.float32, etc.
+            Note that if `level` is not provided, `level=0` is assumed.
+
+    Note:
+        When a scaler value is provided for `patch_size`, `offset`, or `overlap`,
+        it is broadcasted to all the spatial dimensions.
+    """
+
+    def __init__(
+        self,
+        patch_size: Sequence[int] | int,
+        overlap: Sequence[float] | float | Sequence[int] | int = 0.0,
+        offset: Sequence[int] | int = 0,
+        filter_fn: Callable | None = None,
+        pad_mode: str | None = "constant",
+        device: torch.device | str | None = None,
+        reader: str | BaseWSIReader | type[BaseWSIReader] | None = "OpenSlide",
+        **reader_kwargs: dict,
+    ) -> None:
+        if pad_mode and pad_mode != "constant":
+            raise ValueError(
+                f"The underlying wsi readers only support for constant padding. pad_mod={pad_mode} is given."
+            )
+
+        super().__init__(
+            patch_size=patch_size, overlap=overlap, offset=offset, filter_fn=filter_fn, device=device, pad_mode=pad_mode
+        )
+        # Set WSI reader
+        self._set_reader(reader, reader_kwargs)
+        if self.reader.backend.lower() not in ["openslide", "cucim"]:
+            warnings.warn(
+                f"WSIReader with {self.reader.backend.lower()} backend is not supported for efficiently loading patches. "
+                "This may cause an significant slow down and a large memory foot print. "
+                "Please use other backends such as 'OpenSlide' or 'cuCIM' instead."
+            )
+
+    def _set_reader(self, reader: str | BaseWSIReader | type[BaseWSIReader] | None, reader_kwargs: dict) -> None:
+        """
+        Set the WSI reader object based on the input reader
+
+        Args:
+            reader: the module to be used for loading whole slide imaging. If `reader` is
+
+                - a string, it defines the backend of `monai.data.WSIReader`. Defaults to cuCIM.
+                - a class (inherited from `BaseWSIReader`), it is initialized and set as wsi_reader.
+                - an instance of a class inherited from `BaseWSIReader`, it is set as the wsi_reader.
+        """
+        self.reader: WSIReader | BaseWSIReader
+        self.reader_kwargs = reader_kwargs
+        if isinstance(reader, str):
+            self.reader = WSIReader(backend=reader, **self.reader_kwargs)
+        elif isclass(reader) and issubclass(reader, BaseWSIReader):
+            self.reader = reader(**self.reader_kwargs)
+        elif isinstance(reader, BaseWSIReader):
+            self.reader = reader
+        else:
+            raise ValueError(f"Unsupported reader type: {reader}.")
+
+    def _get_patch(self, inputs: Any, location: tuple[int, ...], patch_size: tuple[int, ...]) -> Any:
+        patch, _ = self.reader.get_data(wsi=inputs, location=location, size=patch_size)  # type: ignore
+        return patch[None]
+
+    def get_input_shape(self, inputs: Any) -> tuple:
+        """
+        Return the input spatial shape.
+
+        Args:
+            inputs: either a tensor of shape BCHW[D], representing a batch of images,
+                or a filename (str) or list of filenames to the image(s).
+
+        Returns:
+            spatial_shape
+
+        """
+        wsi = self.reader.read(inputs)
+        level = self.reader_kwargs.get("level", 0)
+        return self.reader.get_size(wsi, level)
+
+    def __call__(self, inputs: PathLike | Sequence[PathLike]) -> Iterable[tuple[torch.Tensor, Sequence[int]]]:
+        """Split the input tensor into patches and return patches and locations.
+
+        Args:
+            inputs: the file path to a whole slide image.
+
+        Yields:
+            tuple[torch.Tensor, Sequence[int]]: yields tuple of patch and location
+        """
+        # Handle if the input file paths are batched
+        if not isinstance(inputs, str) and isinstance(inputs, Sequence):
+            if len(inputs) > 1:
+                raise ValueError("Only batch size of one would work for wsi image. Please provide one path at a time.")
+            inputs = inputs[0]
+
+        # Check if the input is a sting or path like
+        if not isinstance(inputs, (str, os.PathLike)):
+            raise ValueError(f"The input should be the path to the whole slide image. {type(inputs)} is given.")
+
+        wsi = self.reader.read(inputs)
+        level = self.reader_kwargs.get("level", 0)
+        downsample_ratio = self.reader.get_downsample_ratio(wsi, level)
+        spatial_shape: tuple = self.reader.get_size(wsi, level)
+        spatial_ndim = len(spatial_shape)
+        if spatial_ndim != 2:
+            raise ValueError(f"WSIReader only support 2D images. {spatial_ndim} spatial dimension is provided.")
+        patch_size, overlap, offset = self._get_valid_shape_parameters(spatial_shape)
+        pad_size, is_start_padded = self._calculate_pad_size(spatial_shape, spatial_ndim, patch_size, offset, overlap)
+
+        # Padding (extend the spatial shape)
+        if any(pad_size):
+            spatial_shape = tuple(ss + ps + pe for ss, ps, pe in zip(spatial_shape, pad_size[1::2], pad_size[::2]))
+            # correct the offset with respect to the padded image
+            if is_start_padded:
+                offset = tuple(off + p for off, p in zip(offset, pad_size[1::2]))
+
+        # Splitting (extracting patches)
+        for location in iter_patch_position(spatial_shape, patch_size, offset, overlap, False):
+            location_ = tuple(round(loc * downsample_ratio) for loc in location)
+            patch = self._get_patch(wsi, location_, patch_size)
+            patch = convert_to_tensor(patch, device=self.device)
+            # correct the location with respect to original inputs (remove starting pads)
+            if is_start_padded:
+                location = tuple(loc - p for loc, p in zip(location, pad_size[1::2]))
+            # filter patch and yield
+            if self.filter_fn is None or self.filter_fn(patch, location):
+                yield patch, location

source_code/SegMamba/monai/inferers/utils.py

@@ -0,0 +1,405 @@
+# Copyright (c) MONAI Consortium
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#     http://www.apache.org/licenses/LICENSE-2.0
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from __future__ import annotations
+
+import itertools
+from collections.abc import Callable, Mapping, Sequence
+from typing import Any, Iterable
+
+import numpy as np
+import torch
+import torch.nn.functional as F
+
+from monai.data.meta_tensor import MetaTensor
+from monai.data.utils import compute_importance_map, dense_patch_slices, get_valid_patch_size
+from monai.utils import (
+    BlendMode,
+    PytorchPadMode,
+    convert_data_type,
+    convert_to_dst_type,
+    ensure_tuple,
+    ensure_tuple_rep,
+    fall_back_tuple,
+    look_up_option,
+    optional_import,
+    pytorch_after,
+)
+
+tqdm, _ = optional_import("tqdm", name="tqdm")
+_nearest_mode = "nearest-exact" if pytorch_after(1, 11) else "nearest"
+
+__all__ = ["sliding_window_inference"]
+
+
+def sliding_window_inference(
+    inputs: torch.Tensor | MetaTensor,
+    roi_size: Sequence[int] | int,
+    sw_batch_size: int,
+    predictor: Callable[..., torch.Tensor | Sequence[torch.Tensor] | dict[Any, torch.Tensor]],
+    overlap: Sequence[float] | float = 0.25,
+    mode: BlendMode | str = BlendMode.CONSTANT,
+    sigma_scale: Sequence[float] | float = 0.125,
+    padding_mode: PytorchPadMode | str = PytorchPadMode.CONSTANT,
+    cval: float = 0.0,
+    sw_device: torch.device | str | None = None,
+    device: torch.device | str | None = None,
+    progress: bool = False,
+    roi_weight_map: torch.Tensor | None = None,
+    process_fn: Callable | None = None,
+    buffer_steps: int | None = None,
+    buffer_dim: int = -1,
+    with_coord: bool = False,
+    *args: Any,
+    **kwargs: Any,
+) -> torch.Tensor | tuple[torch.Tensor, ...] | dict[Any, torch.Tensor]:
+    """
+    Sliding window inference on `inputs` with `predictor`.
+
+    The outputs of `predictor` could be a tensor, a tuple, or a dictionary of tensors.
+    Each output in the tuple or dict value is allowed to have different resolutions with respect to the input.
+    e.g., the input patch spatial size is [128,128,128], the output (a tuple of two patches) patch sizes
+    could be ([128,64,256], [64,32,128]).
+    In this case, the parameter `overlap` and `roi_size` need to be carefully chosen to ensure the output ROI is still
+    an integer. If the predictor's input and output spatial sizes are not equal, we recommend choosing the parameters
+    so that `overlap*roi_size*output_size/input_size` is an integer (for each spatial dimension).
+
+    When roi_size is larger than the inputs' spatial size, the input image are padded during inference.
+    To maintain the same spatial sizes, the output image will be cropped to the original input size.
+
+    Args:
+        inputs: input image to be processed (assuming NCHW[D])
+        roi_size: the spatial window size for inferences.
+            When its components have None or non-positives, the corresponding inputs dimension will be used.
+            if the components of the `roi_size` are non-positive values, the transform will use the
+            corresponding components of img size. For example, `roi_size=(32, -1)` will be adapted
+            to `(32, 64)` if the second spatial dimension size of img is `64`.
+        sw_batch_size: the batch size to run window slices.
+        predictor: given input tensor ``patch_data`` in shape NCHW[D],
+            The outputs of the function call ``predictor(patch_data)`` should be a tensor, a tuple, or a dictionary
+            with Tensor values. Each output in the tuple or dict value should have the same batch_size, i.e. NM'H'W'[D'];
+            where H'W'[D'] represents the output patch's spatial size, M is the number of output channels,
+            N is `sw_batch_size`, e.g., the input shape is (7, 1, 128,128,128),
+            the output could be a tuple of two tensors, with shapes: ((7, 5, 128, 64, 256), (7, 4, 64, 32, 128)).
+            In this case, the parameter `overlap` and `roi_size` need to be carefully chosen
+            to ensure the scaled output ROI sizes are still integers.
+            If the `predictor`'s input and output spatial sizes are different,
+            we recommend choosing the parameters so that ``overlap*roi_size*zoom_scale`` is an integer for each dimension.
+        overlap: Amount of overlap between scans along each spatial dimension, defaults to ``0.25``.
+        mode: {``"constant"``, ``"gaussian"``}
+            How to blend output of overlapping windows. Defaults to ``"constant"``.
+
+            - ``"constant``": gives equal weight to all predictions.
+            - ``"gaussian``": gives less weight to predictions on edges of windows.
+
+        sigma_scale: the standard deviation coefficient of the Gaussian window when `mode` is ``"gaussian"``.
+            Default: 0.125. Actual window sigma is ``sigma_scale`` * ``dim_size``.
+            When sigma_scale is a sequence of floats, the values denote sigma_scale at the corresponding
+            spatial dimensions.
+        padding_mode: {``"constant"``, ``"reflect"``, ``"replicate"``, ``"circular"``}
+            Padding mode for ``inputs``, when ``roi_size`` is larger than inputs. Defaults to ``"constant"``
+            See also: https://pytorch.org/docs/stable/generated/torch.nn.functional.pad.html
+        cval: fill value for 'constant' padding mode. Default: 0
+        sw_device: device for the window data.
+            By default the device (and accordingly the memory) of the `inputs` is used.
+            Normally `sw_device` should be consistent with the device where `predictor` is defined.
+        device: device for the stitched output prediction.
+            By default the device (and accordingly the memory) of the `inputs` is used. If for example
+            set to device=torch.device('cpu') the gpu memory consumption is less and independent of the
+            `inputs` and `roi_size`. Output is on the `device`.
+        progress: whether to print a `tqdm` progress bar.
+        roi_weight_map: pre-computed (non-negative) weight map for each ROI.
+            If not given, and ``mode`` is not `constant`, this map will be computed on the fly.
+        process_fn: process inference output and adjust the importance map per window
+        buffer_steps: the number of sliding window iterations along the ``buffer_dim``
+            to be buffered on ``sw_device`` before writing to ``device``.
+            (Typically, ``sw_device`` is ``cuda`` and ``device`` is ``cpu``.)
+            default is None, no buffering. For the buffer dim, when spatial size is divisible by buffer_steps*roi_size,
+            (i.e. no overlapping among the buffers) non_blocking copy may be automatically enabled for efficiency.
+        buffer_dim: the spatial dimension along which the buffers are created.
+            0 indicates the first spatial dimension. Default is -1, the last spatial dimension.
+        with_coord: whether to pass the window coordinates to ``predictor``. Default is False.
+            If True, the signature of ``predictor`` should be ``predictor(patch_data, patch_coord, ...)``.
+        args: optional args to be passed to ``predictor``.
+        kwargs: optional keyword args to be passed to ``predictor``.
+
+    Note:
+        - input must be channel-first and have a batch dim, supports N-D sliding window.
+
+    """
+    buffered = buffer_steps is not None and buffer_steps > 0
+    num_spatial_dims = len(inputs.shape) - 2
+    if buffered:
+        if buffer_dim < -num_spatial_dims or buffer_dim > num_spatial_dims:
+            raise ValueError(f"buffer_dim must be in [{-num_spatial_dims}, {num_spatial_dims}], got {buffer_dim}.")
+        if buffer_dim < 0:
+            buffer_dim += num_spatial_dims
+    overlap = ensure_tuple_rep(overlap, num_spatial_dims)
+    for o in overlap:
+        if o < 0 or o >= 1:
+            raise ValueError(f"overlap must be >= 0 and < 1, got {overlap}.")
+    compute_dtype = inputs.dtype
+
+    # determine image spatial size and batch size
+    # Note: all input images must have the same image size and batch size
+    batch_size, _, *image_size_ = inputs.shape
+    device = device or inputs.device
+    sw_device = sw_device or inputs.device
+
+    temp_meta = None
+    if isinstance(inputs, MetaTensor):
+        temp_meta = MetaTensor([]).copy_meta_from(inputs, copy_attr=False)
+    inputs = convert_data_type(inputs, torch.Tensor, wrap_sequence=True)[0]
+    roi_size = fall_back_tuple(roi_size, image_size_)
+
+    # in case that image size is smaller than roi size
+    image_size = tuple(max(image_size_[i], roi_size[i]) for i in range(num_spatial_dims))
+    pad_size = []
+    for k in range(len(inputs.shape) - 1, 1, -1):
+        diff = max(roi_size[k - 2] - inputs.shape[k], 0)
+        half = diff // 2
+        pad_size.extend([half, diff - half])
+    if any(pad_size):
+        inputs = F.pad(inputs, pad=pad_size, mode=look_up_option(padding_mode, PytorchPadMode), value=cval)
+
+    # Store all slices
+    scan_interval = _get_scan_interval(image_size, roi_size, num_spatial_dims, overlap)
+    slices = dense_patch_slices(image_size, roi_size, scan_interval, return_slice=not buffered)
+
+    num_win = len(slices)  # number of windows per image
+    total_slices = num_win * batch_size  # total number of windows
+    windows_range: Iterable
+    if not buffered:
+        non_blocking = False
+        windows_range = range(0, total_slices, sw_batch_size)
+    else:
+        slices, n_per_batch, b_slices, windows_range = _create_buffered_slices(
+            slices, batch_size, sw_batch_size, buffer_dim, buffer_steps
+        )
+        non_blocking, _ss = torch.cuda.is_available(), -1
+        for x in b_slices[:n_per_batch]:
+            if x[1] < _ss:  # detect overlapping slices
+                non_blocking = False
+                break
+            _ss = x[2]
+
+    # Create window-level importance map
+    valid_patch_size = get_valid_patch_size(image_size, roi_size)
+    if valid_patch_size == roi_size and (roi_weight_map is not None):
+        importance_map_ = roi_weight_map
+    else:
+        try:
+            valid_p_size = ensure_tuple(valid_patch_size)
+            importance_map_ = compute_importance_map(
+                valid_p_size, mode=mode, sigma_scale=sigma_scale, device=sw_device, dtype=compute_dtype
+            )
+            if len(importance_map_.shape) == num_spatial_dims and not process_fn:
+                importance_map_ = importance_map_[None, None]  # adds batch, channel dimensions
+        except Exception as e:
+            raise RuntimeError(
+                f"patch size {valid_p_size}, mode={mode}, sigma_scale={sigma_scale}, device={device}\n"
+                "Seems to be OOM. Please try smaller patch size or mode='constant' instead of mode='gaussian'."
+            ) from e
+    importance_map_ = convert_data_type(importance_map_, torch.Tensor, device=sw_device, dtype=compute_dtype)[0]
+
+    # stores output and count map
+    output_image_list, count_map_list, sw_device_buffer, b_s, b_i = [], [], [], 0, 0  # type: ignore
+    # for each patch
+    for slice_g in tqdm(windows_range) if progress else windows_range:
+        slice_range = range(slice_g, min(slice_g + sw_batch_size, b_slices[b_s][0] if buffered else total_slices))
+        unravel_slice = [
+            [slice(idx // num_win, idx // num_win + 1), slice(None)] + list(slices[idx % num_win])
+            for idx in slice_range
+        ]
+        if sw_batch_size > 1:
+            win_data = torch.cat([inputs[win_slice] for win_slice in unravel_slice]).to(sw_device)
+        else:
+            win_data = inputs[unravel_slice[0]].to(sw_device)
+        if with_coord:
+            seg_prob_out = predictor(win_data, unravel_slice, *args, **kwargs)  # batched patch
+        else:
+            seg_prob_out = predictor(win_data, *args, **kwargs)  # batched patch
+
+        # convert seg_prob_out to tuple seg_tuple, this does not allocate new memory.
+        dict_keys, seg_tuple = _flatten_struct(seg_prob_out)
+        if process_fn:
+            seg_tuple, w_t = process_fn(seg_tuple, win_data, importance_map_)
+        else:
+            w_t = importance_map_
+        if len(w_t.shape) == num_spatial_dims:
+            w_t = w_t[None, None]
+        w_t = w_t.to(dtype=compute_dtype, device=sw_device)
+        if buffered:
+            c_start, c_end = b_slices[b_s][1:]
+            if not sw_device_buffer:
+                k = seg_tuple[0].shape[1]  # len(seg_tuple) > 1 is currently ignored
+                sp_size = list(image_size)
+                sp_size[buffer_dim] = c_end - c_start
+                sw_device_buffer = [torch.zeros(size=[1, k, *sp_size], dtype=compute_dtype, device=sw_device)]
+            for p, s in zip(seg_tuple[0], unravel_slice):
+                offset = s[buffer_dim + 2].start - c_start
+                s[buffer_dim + 2] = slice(offset, offset + roi_size[buffer_dim])
+                s[0] = slice(0, 1)
+                sw_device_buffer[0][s] += p * w_t
+            b_i += len(unravel_slice)
+            if b_i < b_slices[b_s][0]:
+                continue
+        else:
+            sw_device_buffer = list(seg_tuple)
+
+        for ss in range(len(sw_device_buffer)):
+            b_shape = sw_device_buffer[ss].shape
+            seg_chns, seg_shape = b_shape[1], b_shape[2:]
+            z_scale = None
+            if not buffered and seg_shape != roi_size:
+                z_scale = [out_w_i / float(in_w_i) for out_w_i, in_w_i in zip(seg_shape, roi_size)]
+                w_t = F.interpolate(w_t, seg_shape, mode=_nearest_mode)
+            if len(output_image_list) <= ss:
+                output_shape = [batch_size, seg_chns]
+                output_shape += [int(_i * _z) for _i, _z in zip(image_size, z_scale)] if z_scale else list(image_size)
+                # allocate memory to store the full output and the count for overlapping parts
+                new_tensor: Callable = torch.empty if non_blocking else torch.zeros  # type: ignore
+                output_image_list.append(new_tensor(output_shape, dtype=compute_dtype, device=device))
+                count_map_list.append(torch.zeros([1, 1] + output_shape[2:], dtype=compute_dtype, device=device))
+                w_t_ = w_t.to(device)
+                for __s in slices:
+                    if z_scale is not None:
+                        __s = tuple(slice(int(_si.start * z_s), int(_si.stop * z_s)) for _si, z_s in zip(__s, z_scale))
+                    count_map_list[-1][(slice(None), slice(None), *__s)] += w_t_
+            if buffered:
+                o_slice = [slice(None)] * len(inputs.shape)
+                o_slice[buffer_dim + 2] = slice(c_start, c_end)
+                img_b = b_s // n_per_batch  # image batch index
+                o_slice[0] = slice(img_b, img_b + 1)
+                if non_blocking:
+                    output_image_list[0][o_slice].copy_(sw_device_buffer[0], non_blocking=non_blocking)
+                else:
+                    output_image_list[0][o_slice] += sw_device_buffer[0].to(device=device)
+            else:
+                sw_device_buffer[ss] *= w_t
+                sw_device_buffer[ss] = sw_device_buffer[ss].to(device)
+                _compute_coords(unravel_slice, z_scale, output_image_list[ss], sw_device_buffer[ss])
+        sw_device_buffer = []
+        if buffered:
+            b_s += 1
+
+    if non_blocking:
+        torch.cuda.current_stream().synchronize()
+
+    # account for any overlapping sections
+    for ss in range(len(output_image_list)):
+        output_image_list[ss] /= count_map_list.pop(0)
+
+    # remove padding if image_size smaller than roi_size
+    if any(pad_size):
+        for ss, output_i in enumerate(output_image_list):
+            zoom_scale = [_shape_d / _roi_size_d for _shape_d, _roi_size_d in zip(output_i.shape[2:], roi_size)]
+            final_slicing: list[slice] = []
+            for sp in range(num_spatial_dims):
+                si = num_spatial_dims - sp - 1
+                slice_dim = slice(
+                    int(round(pad_size[sp * 2] * zoom_scale[si])),
+                    int(round((pad_size[sp * 2] + image_size_[si]) * zoom_scale[si])),
+                )
+                final_slicing.insert(0, slice_dim)
+            output_image_list[ss] = output_i[(slice(None), slice(None), *final_slicing)]
+
+    final_output = _pack_struct(output_image_list, dict_keys)
+    if temp_meta is not None:
+        final_output = convert_to_dst_type(final_output, temp_meta, device=device)[0]
+    else:
+        final_output = convert_to_dst_type(final_output, inputs, device=device)[0]
+
+    return final_output  # type: ignore
+
+
+def _create_buffered_slices(slices, batch_size, sw_batch_size, buffer_dim, buffer_steps):
+    """rearrange slices for buffering"""
+    slices_np = np.asarray(slices)
+    slices_np = slices_np[np.argsort(slices_np[:, buffer_dim, 0], kind="mergesort")]
+    slices = [tuple(slice(c[0], c[1]) for c in i) for i in slices_np]
+    slices_np = slices_np[:, buffer_dim]
+
+    _, _, _b_lens = np.unique(slices_np[:, 0], return_counts=True, return_index=True)
+    b_ends = np.cumsum(_b_lens).tolist()  # possible buffer flush boundaries
+    x = [0, *b_ends][:: min(len(b_ends), int(buffer_steps))]
+    if x[-1] < b_ends[-1]:
+        x.append(b_ends[-1])
+    n_per_batch = len(x) - 1
+    windows_range = [
+        range(b * x[-1] + x[i], b * x[-1] + x[i + 1], sw_batch_size)
+        for b in range(batch_size)
+        for i in range(n_per_batch)
+    ]
+    b_slices = []
+    for _s, _r in enumerate(windows_range):
+        s_s = slices_np[windows_range[_s - 1].stop % len(slices) if _s > 0 else 0, 0]
+        s_e = slices_np[(_r.stop - 1) % len(slices), 1]
+        b_slices.append((_r.stop, s_s, s_e))  # buffer index, slice start, slice end
+    windows_range = itertools.chain(*windows_range)  # type: ignore
+    return slices, n_per_batch, b_slices, windows_range
+
+
+def _compute_coords(coords, z_scale, out, patch):
+    """sliding window batch spatial scaling indexing for multi-resolution outputs."""
+    for original_idx, p in zip(coords, patch):
+        idx_zm = list(original_idx)  # 4D for 2D image, 5D for 3D image
+        if z_scale:
+            for axis in range(2, len(idx_zm)):
+                idx_zm[axis] = slice(
+                    int(original_idx[axis].start * z_scale[axis - 2]), int(original_idx[axis].stop * z_scale[axis - 2])
+                )
+        out[idx_zm] += p
+
+
+def _get_scan_interval(
+    image_size: Sequence[int], roi_size: Sequence[int], num_spatial_dims: int, overlap: Sequence[float]
+) -> tuple[int, ...]:
+    """
+    Compute scan interval according to the image size, roi size and overlap.
+    Scan interval will be `int((1 - overlap) * roi_size)`, if interval is 0,
+    use 1 instead to make sure sliding window works.
+
+    """
+    if len(image_size) != num_spatial_dims:
+        raise ValueError(f"len(image_size) {len(image_size)} different from spatial dims {num_spatial_dims}.")
+    if len(roi_size) != num_spatial_dims:
+        raise ValueError(f"len(roi_size) {len(roi_size)} different from spatial dims {num_spatial_dims}.")
+
+    scan_interval = []
+    for i, o in zip(range(num_spatial_dims), overlap):
+        if roi_size[i] == image_size[i]:
+            scan_interval.append(int(roi_size[i]))
+        else:
+            interval = int(roi_size[i] * (1 - o))
+            scan_interval.append(interval if interval > 0 else 1)
+    return tuple(scan_interval)
+
+
+def _flatten_struct(seg_out):
+    dict_keys = None
+    seg_probs: tuple[torch.Tensor, ...]
+    if isinstance(seg_out, torch.Tensor):
+        seg_probs = (seg_out,)
+    elif isinstance(seg_out, Mapping):
+        dict_keys = sorted(seg_out.keys())  # track predictor's output keys
+        seg_probs = tuple(seg_out[k] for k in dict_keys)
+    else:
+        seg_probs = ensure_tuple(seg_out)
+    return dict_keys, seg_probs
+
+
+def _pack_struct(seg_out, dict_keys=None):
+    if dict_keys is not None:
+        return dict(zip(dict_keys, seg_out))
+    if isinstance(seg_out, (list, tuple)) and len(seg_out) == 1:
+        return seg_out[0]
+    return ensure_tuple(seg_out)

source_code/SegMamba/monai/losses/cldice.py

@@ -0,0 +1,184 @@
+# Copyright (c) MONAI Consortium
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#     http://www.apache.org/licenses/LICENSE-2.0
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from __future__ import annotations
+
+import torch
+import torch.nn.functional as F
+from torch.nn.modules.loss import _Loss
+
+
+def soft_erode(img: torch.Tensor) -> torch.Tensor:  # type: ignore
+    """
+    Perform soft erosion on the input image
+
+    Args:
+        img: the shape should be BCH(WD)
+
+    Adapted from:
+        https://github.com/jocpae/clDice/blob/master/cldice_loss/pytorch/soft_skeleton.py#L6
+    """
+    if len(img.shape) == 4:
+        p1 = -(F.max_pool2d(-img, (3, 1), (1, 1), (1, 0)))
+        p2 = -(F.max_pool2d(-img, (1, 3), (1, 1), (0, 1)))
+        return torch.min(p1, p2)
+    elif len(img.shape) == 5:
+        p1 = -(F.max_pool3d(-img, (3, 1, 1), (1, 1, 1), (1, 0, 0)))
+        p2 = -(F.max_pool3d(-img, (1, 3, 1), (1, 1, 1), (0, 1, 0)))
+        p3 = -(F.max_pool3d(-img, (1, 1, 3), (1, 1, 1), (0, 0, 1)))
+        return torch.min(torch.min(p1, p2), p3)
+
+
+def soft_dilate(img: torch.Tensor) -> torch.Tensor:  # type: ignore
+    """
+    Perform soft dilation on the input image
+
+    Args:
+        img: the shape should be BCH(WD)
+
+    Adapted from:
+        https://github.com/jocpae/clDice/blob/master/cldice_loss/pytorch/soft_skeleton.py#L18
+    """
+    if len(img.shape) == 4:
+        return F.max_pool2d(img, (3, 3), (1, 1), (1, 1))
+    elif len(img.shape) == 5:
+        return F.max_pool3d(img, (3, 3, 3), (1, 1, 1), (1, 1, 1))
+
+
+def soft_open(img: torch.Tensor) -> torch.Tensor:
+    """
+    Wrapper function to perform soft opening on the input image
+
+    Args:
+        img: the shape should be BCH(WD)
+
+    Adapted from:
+        https://github.com/jocpae/clDice/blob/master/cldice_loss/pytorch/soft_skeleton.py#L25
+    """
+    eroded_image = soft_erode(img)
+    dilated_image = soft_dilate(eroded_image)
+    return dilated_image
+
+
+def soft_skel(img: torch.Tensor, iter_: int) -> torch.Tensor:
+    """
+    Perform soft skeletonization on the input image
+
+    Adapted from:
+       https://github.com/jocpae/clDice/blob/master/cldice_loss/pytorch/soft_skeleton.py#L29
+
+    Args:
+        img: the shape should be BCH(WD)
+        iter_: number of iterations for skeletonization
+
+    Returns:
+        skeletonized image
+    """
+    img1 = soft_open(img)
+    skel = F.relu(img - img1)
+    for _ in range(iter_):
+        img = soft_erode(img)
+        img1 = soft_open(img)
+        delta = F.relu(img - img1)
+        skel = skel + F.relu(delta - skel * delta)
+    return skel
+
+
+def soft_dice(y_true: torch.Tensor, y_pred: torch.Tensor, smooth: float = 1.0) -> torch.Tensor:
+    """
+    Function to compute soft dice loss
+
+    Adapted from:
+        https://github.com/jocpae/clDice/blob/master/cldice_loss/pytorch/cldice.py#L22
+
+    Args:
+        y_true: the shape should be BCH(WD)
+        y_pred: the shape should be BCH(WD)
+
+    Returns:
+        dice loss
+    """
+    intersection = torch.sum((y_true * y_pred)[:, 1:, ...])
+    coeff = (2.0 * intersection + smooth) / (torch.sum(y_true[:, 1:, ...]) + torch.sum(y_pred[:, 1:, ...]) + smooth)
+    soft_dice: torch.Tensor = 1.0 - coeff
+    return soft_dice
+
+
+class SoftclDiceLoss(_Loss):
+    """
+    Compute the Soft clDice loss defined in:
+
+        Shit et al. (2021) clDice -- A Novel Topology-Preserving Loss Function
+        for Tubular Structure Segmentation. (https://arxiv.org/abs/2003.07311)
+
+    Adapted from:
+        https://github.com/jocpae/clDice/blob/master/cldice_loss/pytorch/cldice.py#L7
+    """
+
+    def __init__(self, iter_: int = 3, smooth: float = 1.0) -> None:
+        """
+        Args:
+            iter_: Number of iterations for skeletonization
+            smooth: Smoothing parameter
+        """
+        super().__init__()
+        self.iter = iter_
+        self.smooth = smooth
+
+    def forward(self, y_true: torch.Tensor, y_pred: torch.Tensor) -> torch.Tensor:
+        skel_pred = soft_skel(y_pred, self.iter)
+        skel_true = soft_skel(y_true, self.iter)
+        tprec = (torch.sum(torch.multiply(skel_pred, y_true)[:, 1:, ...]) + self.smooth) / (
+            torch.sum(skel_pred[:, 1:, ...]) + self.smooth
+        )
+        tsens = (torch.sum(torch.multiply(skel_true, y_pred)[:, 1:, ...]) + self.smooth) / (
+            torch.sum(skel_true[:, 1:, ...]) + self.smooth
+        )
+        cl_dice: torch.Tensor = 1.0 - 2.0 * (tprec * tsens) / (tprec + tsens)
+        return cl_dice
+
+
+class SoftDiceclDiceLoss(_Loss):
+    """
+    Compute the Soft clDice loss defined in:
+
+        Shit et al. (2021) clDice -- A Novel Topology-Preserving Loss Function
+        for Tubular Structure Segmentation. (https://arxiv.org/abs/2003.07311)
+
+    Adapted from:
+        https://github.com/jocpae/clDice/blob/master/cldice_loss/pytorch/cldice.py#L38
+    """
+
+    def __init__(self, iter_: int = 3, alpha: float = 0.5, smooth: float = 1.0) -> None:
+        """
+        Args:
+            iter_: Number of iterations for skeletonization
+            smooth: Smoothing parameter
+            alpha: Weighing factor for cldice
+        """
+        super().__init__()
+        self.iter = iter_
+        self.smooth = smooth
+        self.alpha = alpha
+
+    def forward(self, y_true: torch.Tensor, y_pred: torch.Tensor) -> torch.Tensor:
+        dice = soft_dice(y_true, y_pred, self.smooth)
+        skel_pred = soft_skel(y_pred, self.iter)
+        skel_true = soft_skel(y_true, self.iter)
+        tprec = (torch.sum(torch.multiply(skel_pred, y_true)[:, 1:, ...]) + self.smooth) / (
+            torch.sum(skel_pred[:, 1:, ...]) + self.smooth
+        )
+        tsens = (torch.sum(torch.multiply(skel_true, y_pred)[:, 1:, ...]) + self.smooth) / (
+            torch.sum(skel_true[:, 1:, ...]) + self.smooth
+        )
+        cl_dice = 1.0 - 2.0 * (tprec * tsens) / (tprec + tsens)
+        total_loss: torch.Tensor = (1.0 - self.alpha) * dice + self.alpha * cl_dice
+        return total_loss

source_code/SegMamba/monai/losses/dice.py

@@ -0,0 +1,1068 @@
+# Copyright (c) MONAI Consortium
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#     http://www.apache.org/licenses/LICENSE-2.0
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from __future__ import annotations
+
+import warnings
+from collections.abc import Callable, Sequence
+from typing import Any
+
+import numpy as np
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from torch.nn.modules.loss import _Loss
+
+from monai.losses.focal_loss import FocalLoss
+from monai.losses.spatial_mask import MaskedLoss
+from monai.networks import one_hot
+from monai.utils import DiceCEReduction, LossReduction, Weight, deprecated_arg, look_up_option, pytorch_after
+
+
+class DiceLoss(_Loss):
+    """
+    Compute average Dice loss between two tensors. It can support both multi-classes and multi-labels tasks.
+    The data `input` (BNHW[D] where N is number of classes) is compared with ground truth `target` (BNHW[D]).
+
+    Note that axis N of `input` is expected to be logits or probabilities for each class, if passing logits as input,
+    must set `sigmoid=True` or `softmax=True`, or specifying `other_act`. And the same axis of `target`
+    can be 1 or N (one-hot format).
+
+    The `smooth_nr` and `smooth_dr` parameters are values added to the intersection and union components of
+    the inter-over-union calculation to smooth results respectively, these values should be small.
+
+    The original paper: Milletari, F. et. al. (2016) V-Net: Fully Convolutional Neural Networks forVolumetric
+    Medical Image Segmentation, 3DV, 2016.
+
+    """
+
+    def __init__(
+        self,
+        include_background: bool = True,
+        to_onehot_y: bool = False,
+        sigmoid: bool = False,
+        softmax: bool = False,
+        other_act: Callable | None = None,
+        squared_pred: bool = False,
+        jaccard: bool = False,
+        reduction: LossReduction | str = LossReduction.MEAN,
+        smooth_nr: float = 1e-5,
+        smooth_dr: float = 1e-5,
+        batch: bool = False,
+        weight: Sequence[float] | float | int | torch.Tensor | None = None,
+    ) -> None:
+        """
+        Args:
+            include_background: if False, channel index 0 (background category) is excluded from the calculation.
+                if the non-background segmentations are small compared to the total image size they can get overwhelmed
+                by the signal from the background so excluding it in such cases helps convergence.
+            to_onehot_y: whether to convert the ``target`` into the one-hot format,
+                using the number of classes inferred from `input` (``input.shape[1]``). Defaults to False.
+            sigmoid: if True, apply a sigmoid function to the prediction.
+            softmax: if True, apply a softmax function to the prediction.
+            other_act: callable function to execute other activation layers, Defaults to ``None``. for example:
+                ``other_act = torch.tanh``.
+            squared_pred: use squared versions of targets and predictions in the denominator or not.
+            jaccard: compute Jaccard Index (soft IoU) instead of dice or not.
+            reduction: {``"none"``, ``"mean"``, ``"sum"``}
+                Specifies the reduction to apply to the output. Defaults to ``"mean"``.
+
+                - ``"none"``: no reduction will be applied.
+                - ``"mean"``: the sum of the output will be divided by the number of elements in the output.
+                - ``"sum"``: the output will be summed.
+
+            smooth_nr: a small constant added to the numerator to avoid zero.
+            smooth_dr: a small constant added to the denominator to avoid nan.
+            batch: whether to sum the intersection and union areas over the batch dimension before the dividing.
+                Defaults to False, a Dice loss value is computed independently from each item in the batch
+                before any `reduction`.
+            weight: weights to apply to the voxels of each class. If None no weights are applied.
+                The input can be a single value (same weight for all classes), a sequence of values (the length
+                of the sequence should be the same as the number of classes. If not ``include_background``,
+                the number of classes should not include the background category class 0).
+                The value/values should be no less than 0. Defaults to None.
+
+        Raises:
+            TypeError: When ``other_act`` is not an ``Optional[Callable]``.
+            ValueError: When more than 1 of [``sigmoid=True``, ``softmax=True``, ``other_act is not None``].
+                Incompatible values.
+
+        """
+        super().__init__(reduction=LossReduction(reduction).value)
+        if other_act is not None and not callable(other_act):
+            raise TypeError(f"other_act must be None or callable but is {type(other_act).__name__}.")
+        if int(sigmoid) + int(softmax) + int(other_act is not None) > 1:
+            raise ValueError("Incompatible values: more than 1 of [sigmoid=True, softmax=True, other_act is not None].")
+        self.include_background = include_background
+        self.to_onehot_y = to_onehot_y
+        self.sigmoid = sigmoid
+        self.softmax = softmax
+        self.other_act = other_act
+        self.squared_pred = squared_pred
+        self.jaccard = jaccard
+        self.smooth_nr = float(smooth_nr)
+        self.smooth_dr = float(smooth_dr)
+        self.batch = batch
+        weight = torch.as_tensor(weight) if weight is not None else None
+        self.register_buffer("class_weight", weight)
+        self.class_weight: None | torch.Tensor
+
+    def forward(self, input: torch.Tensor, target: torch.Tensor) -> torch.Tensor:
+        """
+        Args:
+            input: the shape should be BNH[WD], where N is the number of classes.
+            target: the shape should be BNH[WD] or B1H[WD], where N is the number of classes.
+
+        Raises:
+            AssertionError: When input and target (after one hot transform if set)
+                have different shapes.
+            ValueError: When ``self.reduction`` is not one of ["mean", "sum", "none"].
+
+        Example:
+            >>> from monai.losses.dice import *  # NOQA
+            >>> import torch
+            >>> from monai.losses.dice import DiceLoss
+            >>> B, C, H, W = 7, 5, 3, 2
+            >>> input = torch.rand(B, C, H, W)
+            >>> target_idx = torch.randint(low=0, high=C - 1, size=(B, H, W)).long()
+            >>> target = one_hot(target_idx[:, None, ...], num_classes=C)
+            >>> self = DiceLoss(reduction='none')
+            >>> loss = self(input, target)
+            >>> assert np.broadcast_shapes(loss.shape, input.shape) == input.shape
+        """
+        if self.sigmoid:
+            input = torch.sigmoid(input)
+
+        n_pred_ch = input.shape[1]
+        if self.softmax:
+            if n_pred_ch == 1:
+                warnings.warn("single channel prediction, `softmax=True` ignored.")
+            else:
+                input = torch.softmax(input, 1)
+
+        if self.other_act is not None:
+            input = self.other_act(input)
+
+        if self.to_onehot_y:
+            if n_pred_ch == 1:
+                warnings.warn("single channel prediction, `to_onehot_y=True` ignored.")
+            else:
+                target = one_hot(target, num_classes=n_pred_ch)
+
+        if not self.include_background:
+            if n_pred_ch == 1:
+                warnings.warn("single channel prediction, `include_background=False` ignored.")
+            else:
+                # if skipping background, removing first channel
+                target = target[:, 1:]
+                input = input[:, 1:]
+
+        if target.shape != input.shape:
+            raise AssertionError(f"ground truth has different shape ({target.shape}) from input ({input.shape})")
+
+        # reducing only spatial dimensions (not batch nor channels)
+        reduce_axis: list[int] = torch.arange(2, len(input.shape)).tolist()
+        if self.batch:
+            # reducing spatial dimensions and batch
+            reduce_axis = [0] + reduce_axis
+
+        intersection = torch.sum(target * input, dim=reduce_axis)
+
+        if self.squared_pred:
+            ground_o = torch.sum(target**2, dim=reduce_axis)
+            pred_o = torch.sum(input**2, dim=reduce_axis)
+        else:
+            ground_o = torch.sum(target, dim=reduce_axis)
+            pred_o = torch.sum(input, dim=reduce_axis)
+
+        denominator = ground_o + pred_o
+
+        if self.jaccard:
+            denominator = 2.0 * (denominator - intersection)
+
+        f: torch.Tensor = 1.0 - (2.0 * intersection + self.smooth_nr) / (denominator + self.smooth_dr)
+
+        num_of_classes = target.shape[1]
+        if self.class_weight is not None and num_of_classes != 1:
+            # make sure the lengths of weights are equal to the number of classes
+            if self.class_weight.ndim == 0:
+                self.class_weight = torch.as_tensor([self.class_weight] * num_of_classes)
+            else:
+                if self.class_weight.shape[0] != num_of_classes:
+                    raise ValueError(
+                        """the length of the `weight` sequence should be the same as the number of classes.
+                        If `include_background=False`, the weight should not include
+                        the background category class 0."""
+                    )
+            if self.class_weight.min() < 0:
+                raise ValueError("the value/values of the `weight` should be no less than 0.")
+            # apply class_weight to loss
+            f = f * self.class_weight.to(f)
+
+        if self.reduction == LossReduction.MEAN.value:
+            f = torch.mean(f)  # the batch and channel average
+        elif self.reduction == LossReduction.SUM.value:
+            f = torch.sum(f)  # sum over the batch and channel dims
+        elif self.reduction == LossReduction.NONE.value:
+            # If we are not computing voxelwise loss components at least
+            # make sure a none reduction maintains a broadcastable shape
+            broadcast_shape = list(f.shape[0:2]) + [1] * (len(input.shape) - 2)
+            f = f.view(broadcast_shape)
+        else:
+            raise ValueError(f'Unsupported reduction: {self.reduction}, available options are ["mean", "sum", "none"].')
+
+        return f
+
+
+class MaskedDiceLoss(DiceLoss):
+    """
+    Add an additional `masking` process before `DiceLoss`, accept a binary mask ([0, 1]) indicating a region,
+    `input` and `target` will be masked by the region: region with mask `1` will keep the original value,
+    region with `0` mask will be converted to `0`. Then feed `input` and `target` to normal `DiceLoss` computation.
+    This has the effect of ensuring only the masked region contributes to the loss computation and
+    hence gradient calculation.
+
+    """
+
+    def __init__(self, *args: Any, **kwargs: Any) -> None:
+        """
+        Args follow :py:class:`monai.losses.DiceLoss`.
+        """
+        super().__init__(*args, **kwargs)
+        self.spatial_weighted = MaskedLoss(loss=super().forward)
+
+    def forward(self, input: torch.Tensor, target: torch.Tensor, mask: torch.Tensor | None = None) -> torch.Tensor:
+        """
+        Args:
+            input: the shape should be BNH[WD].
+            target: the shape should be BNH[WD].
+            mask: the shape should B1H[WD] or 11H[WD].
+        """
+        return self.spatial_weighted(input=input, target=target, mask=mask)  # type: ignore[no-any-return]
+
+
+class GeneralizedDiceLoss(_Loss):
+    """
+    Compute the generalised Dice loss defined in:
+
+        Sudre, C. et. al. (2017) Generalised Dice overlap as a deep learning
+        loss function for highly unbalanced segmentations. DLMIA 2017.
+
+    Adapted from:
+        https://github.com/NifTK/NiftyNet/blob/v0.6.0/niftynet/layer/loss_segmentation.py#L279
+    """
+
+    def __init__(
+        self,
+        include_background: bool = True,
+        to_onehot_y: bool = False,
+        sigmoid: bool = False,
+        softmax: bool = False,
+        other_act: Callable | None = None,
+        w_type: Weight | str = Weight.SQUARE,
+        reduction: LossReduction | str = LossReduction.MEAN,
+        smooth_nr: float = 1e-5,
+        smooth_dr: float = 1e-5,
+        batch: bool = False,
+    ) -> None:
+        """
+        Args:
+            include_background: If False channel index 0 (background category) is excluded from the calculation.
+            to_onehot_y: whether to convert the ``target`` into the one-hot format,
+                using the number of classes inferred from `input` (``input.shape[1]``). Defaults to False.
+            sigmoid: If True, apply a sigmoid function to the prediction.
+            softmax: If True, apply a softmax function to the prediction.
+            other_act: callable function to execute other activation layers, Defaults to ``None``. for example:
+                ``other_act = torch.tanh``.
+            w_type: {``"square"``, ``"simple"``, ``"uniform"``}
+                Type of function to transform ground truth volume to a weight factor. Defaults to ``"square"``.
+            reduction: {``"none"``, ``"mean"``, ``"sum"``}
+                Specifies the reduction to apply to the output. Defaults to ``"mean"``.
+
+                - ``"none"``: no reduction will be applied.
+                - ``"mean"``: the sum of the output will be divided by the number of elements in the output.
+                - ``"sum"``: the output will be summed.
+            smooth_nr: a small constant added to the numerator to avoid zero.
+            smooth_dr: a small constant added to the denominator to avoid nan.
+            batch: whether to sum the intersection and union areas over the batch dimension before the dividing.
+                Defaults to False, intersection over union is computed from each item in the batch.
+                If True, the class-weighted intersection and union areas are first summed across the batches.
+
+        Raises:
+            TypeError: When ``other_act`` is not an ``Optional[Callable]``.
+            ValueError: When more than 1 of [``sigmoid=True``, ``softmax=True``, ``other_act is not None``].
+                Incompatible values.
+
+        """
+        super().__init__(reduction=LossReduction(reduction).value)
+        if other_act is not None and not callable(other_act):
+            raise TypeError(f"other_act must be None or callable but is {type(other_act).__name__}.")
+        if int(sigmoid) + int(softmax) + int(other_act is not None) > 1:
+            raise ValueError("Incompatible values: more than 1 of [sigmoid=True, softmax=True, other_act is not None].")
+
+        self.include_background = include_background
+        self.to_onehot_y = to_onehot_y
+        self.sigmoid = sigmoid
+        self.softmax = softmax
+        self.other_act = other_act
+
+        self.w_type = look_up_option(w_type, Weight)
+
+        self.smooth_nr = float(smooth_nr)
+        self.smooth_dr = float(smooth_dr)
+        self.batch = batch
+
+    def w_func(self, grnd):
+        if self.w_type == str(Weight.SIMPLE):
+            return torch.reciprocal(grnd)
+        if self.w_type == str(Weight.SQUARE):
+            return torch.reciprocal(grnd * grnd)
+        return torch.ones_like(grnd)
+
+    def forward(self, input: torch.Tensor, target: torch.Tensor) -> torch.Tensor:
+        """
+        Args:
+            input: the shape should be BNH[WD].
+            target: the shape should be BNH[WD].
+
+        Raises:
+            ValueError: When ``self.reduction`` is not one of ["mean", "sum", "none"].
+
+        """
+        if self.sigmoid:
+            input = torch.sigmoid(input)
+        n_pred_ch = input.shape[1]
+        if self.softmax:
+            if n_pred_ch == 1:
+                warnings.warn("single channel prediction, `softmax=True` ignored.")
+            else:
+                input = torch.softmax(input, 1)
+
+        if self.other_act is not None:
+            input = self.other_act(input)
+
+        if self.to_onehot_y:
+            if n_pred_ch == 1:
+                warnings.warn("single channel prediction, `to_onehot_y=True` ignored.")
+            else:
+                target = one_hot(target, num_classes=n_pred_ch)
+
+        if not self.include_background:
+            if n_pred_ch == 1:
+                warnings.warn("single channel prediction, `include_background=False` ignored.")
+            else:
+                # if skipping background, removing first channel
+                target = target[:, 1:]
+                input = input[:, 1:]
+
+        if target.shape != input.shape:
+            raise AssertionError(f"ground truth has differing shape ({target.shape}) from input ({input.shape})")
+
+        # reducing only spatial dimensions (not batch nor channels)
+        reduce_axis: list[int] = torch.arange(2, len(input.shape)).tolist()
+        if self.batch:
+            reduce_axis = [0] + reduce_axis
+        intersection = torch.sum(target * input, reduce_axis)
+
+        ground_o = torch.sum(target, reduce_axis)
+        pred_o = torch.sum(input, reduce_axis)
+
+        denominator = ground_o + pred_o
+
+        w = self.w_func(ground_o.float())
+        infs = torch.isinf(w)
+        if self.batch:
+            w[infs] = 0.0
+            w = w + infs * torch.max(w)
+        else:
+            w[infs] = 0.0
+            max_values = torch.max(w, dim=1)[0].unsqueeze(dim=1)
+            w = w + infs * max_values
+
+        final_reduce_dim = 0 if self.batch else 1
+        numer = 2.0 * (intersection * w).sum(final_reduce_dim, keepdim=True) + self.smooth_nr
+        denom = (denominator * w).sum(final_reduce_dim, keepdim=True) + self.smooth_dr
+        f: torch.Tensor = 1.0 - (numer / denom)
+
+        if self.reduction == LossReduction.MEAN.value:
+            f = torch.mean(f)  # the batch and channel average
+        elif self.reduction == LossReduction.SUM.value:
+            f = torch.sum(f)  # sum over the batch and channel dims
+        elif self.reduction == LossReduction.NONE.value:
+            # If we are not computing voxelwise loss components at least
+            # make sure a none reduction maintains a broadcastable shape
+            broadcast_shape = list(f.shape[0:2]) + [1] * (len(input.shape) - 2)
+            f = f.view(broadcast_shape)
+        else:
+            raise ValueError(f'Unsupported reduction: {self.reduction}, available options are ["mean", "sum", "none"].')
+
+        return f
+
+
+class GeneralizedWassersteinDiceLoss(_Loss):
+    """
+    Compute the generalized Wasserstein Dice Loss defined in:
+
+        Fidon L. et al. (2017) Generalised Wasserstein Dice Score for Imbalanced Multi-class
+        Segmentation using Holistic Convolutional Networks. BrainLes 2017.
+
+    Or its variant (use the option weighting_mode="GDL") defined in the Appendix of:
+
+        Tilborghs, S. et al. (2020) Comparative study of deep learning methods for the automatic
+        segmentation of lung, lesion and lesion type in CT scans of COVID-19 patients.
+        arXiv preprint arXiv:2007.15546
+
+    Adapted from:
+        https://github.com/LucasFidon/GeneralizedWassersteinDiceLoss
+    """
+
+    def __init__(
+        self,
+        dist_matrix: np.ndarray | torch.Tensor,
+        weighting_mode: str = "default",
+        reduction: LossReduction | str = LossReduction.MEAN,
+        smooth_nr: float = 1e-5,
+        smooth_dr: float = 1e-5,
+    ) -> None:
+        """
+        Args:
+            dist_matrix: 2d tensor or 2d numpy array; matrix of distances between the classes.
+            It must have dimension C x C where C is the number of classes.
+            weighting_mode: {``"default"``, ``"GDL"``}
+                Specifies how to weight the class-specific sum of errors.
+                Default to ``"default"``.
+
+                - ``"default"``: (recommended) use the original weighting method as in:
+                    Fidon L. et al. (2017) Generalised Wasserstein Dice Score for Imbalanced Multi-class
+                    Segmentation using Holistic Convolutional Networks. BrainLes 2017.
+                - ``"GDL"``: use a GDL-like weighting method as in the Appendix of:
+                    Tilborghs, S. et al. (2020) Comparative study of deep learning methods for the automatic
+                    segmentation of lung, lesion and lesion type in CT scans of COVID-19 patients.
+                    arXiv preprint arXiv:2007.15546
+            reduction: {``"none"``, ``"mean"``, ``"sum"``}
+                Specifies the reduction to apply to the output. Defaults to ``"mean"``.
+
+                - ``"none"``: no reduction will be applied.
+                - ``"mean"``: the sum of the output will be divided by the number of elements in the output.
+                - ``"sum"``: the output will be summed.
+            smooth_nr: a small constant added to the numerator to avoid zero.
+            smooth_dr: a small constant added to the denominator to avoid nan.
+
+        Raises:
+            ValueError: When ``dist_matrix`` is not a square matrix.
+
+        Example:
+            .. code-block:: python
+
+                import torch
+                import numpy as np
+                from monai.losses import GeneralizedWassersteinDiceLoss
+
+                # Example with 3 classes (including the background: label 0).
+                # The distance between the background class (label 0) and the other classes is the maximum, equal to 1.
+                # The distance between class 1 and class 2 is 0.5.
+                dist_mat = np.array([[0.0, 1.0, 1.0], [1.0, 0.0, 0.5], [1.0, 0.5, 0.0]], dtype=np.float32)
+                wass_loss = GeneralizedWassersteinDiceLoss(dist_matrix=dist_mat)
+
+                pred_score = torch.tensor([[1000, 0, 0], [0, 1000, 0], [0, 0, 1000]], dtype=torch.float32)
+                grnd = torch.tensor([0, 1, 2], dtype=torch.int64)
+                wass_loss(pred_score, grnd)  # 0
+
+        """
+        super().__init__(reduction=LossReduction(reduction).value)
+
+        if dist_matrix.shape[0] != dist_matrix.shape[1]:
+            raise ValueError(f"dist_matrix must be C x C, got {dist_matrix.shape[0]} x {dist_matrix.shape[1]}.")
+
+        if weighting_mode not in ["default", "GDL"]:
+            raise ValueError("weighting_mode must be either 'default' or 'GDL, got %s." % weighting_mode)
+
+        self.m = dist_matrix
+        if isinstance(self.m, np.ndarray):
+            self.m = torch.from_numpy(self.m)
+        if torch.max(self.m) != 1:
+            self.m = self.m / torch.max(self.m)
+        self.alpha_mode = weighting_mode
+        self.num_classes = self.m.size(0)
+        self.smooth_nr = float(smooth_nr)
+        self.smooth_dr = float(smooth_dr)
+
+    def forward(self, input: torch.Tensor, target: torch.Tensor) -> torch.Tensor:
+        """
+        Args:
+            input: the shape should be BNH[WD].
+            target: the shape should be BNH[WD].
+
+        """
+        # Aggregate spatial dimensions
+        flat_input = input.reshape(input.size(0), input.size(1), -1)
+        flat_target = target.reshape(target.size(0), -1).long()
+
+        # Apply the softmax to the input scores map
+        probs = F.softmax(flat_input, dim=1)
+
+        # Compute the Wasserstein distance map
+        wass_dist_map = self.wasserstein_distance_map(probs, flat_target)
+
+        # Compute the values of alpha to use
+        alpha = self._compute_alpha_generalized_true_positives(flat_target)
+
+        # Compute the numerator and denominator of the generalized Wasserstein Dice loss
+        if self.alpha_mode == "GDL":
+            # use GDL-style alpha weights (i.e. normalize by the volume of each class)
+            # contrary to the original definition we also use alpha in the "generalized all error".
+            true_pos = self._compute_generalized_true_positive(alpha, flat_target, wass_dist_map)
+            denom = self._compute_denominator(alpha, flat_target, wass_dist_map)
+        else:  # default: as in the original paper
+            # (i.e. alpha=1 for all foreground classes and 0 for the background).
+            # Compute the generalised number of true positives
+            true_pos = self._compute_generalized_true_positive(alpha, flat_target, wass_dist_map)
+            all_error = torch.sum(wass_dist_map, dim=1)
+            denom = 2 * true_pos + all_error
+
+        # Compute the final loss
+        wass_dice: torch.Tensor = (2.0 * true_pos + self.smooth_nr) / (denom + self.smooth_dr)
+        wass_dice_loss: torch.Tensor = 1.0 - wass_dice
+
+        if self.reduction == LossReduction.MEAN.value:
+            wass_dice_loss = torch.mean(wass_dice_loss)  # the batch and channel average
+        elif self.reduction == LossReduction.SUM.value:
+            wass_dice_loss = torch.sum(wass_dice_loss)  # sum over the batch and channel dims
+        elif self.reduction == LossReduction.NONE.value:
+            # If we are not computing voxelwise loss components at least
+            # make sure a none reduction maintains a broadcastable shape
+            broadcast_shape = input.shape[0:2] + (1,) * (len(input.shape) - 2)
+            wass_dice_loss = wass_dice_loss.view(broadcast_shape)
+        else:
+            raise ValueError(f'Unsupported reduction: {self.reduction}, available options are ["mean", "sum", "none"].')
+
+        return wass_dice_loss
+
+    def wasserstein_distance_map(self, flat_proba: torch.Tensor, flat_target: torch.Tensor) -> torch.Tensor:
+        """
+        Compute the voxel-wise Wasserstein distance between the
+        flattened prediction and the flattened labels (ground_truth) with respect
+        to the distance matrix on the label space M.
+        This corresponds to eq. 6 in:
+
+            Fidon L. et al. (2017) Generalised Wasserstein Dice Score for Imbalanced Multi-class
+            Segmentation using Holistic Convolutional Networks. BrainLes 2017.
+
+        Args:
+            flat_proba: the probabilities of input(predicted) tensor.
+            flat_target: the target tensor.
+        """
+        # Turn the distance matrix to a map of identical matrix
+        m = torch.clone(torch.as_tensor(self.m)).to(flat_proba.device)
+        m_extended = torch.unsqueeze(m, dim=0)
+        m_extended = torch.unsqueeze(m_extended, dim=3)
+        m_extended = m_extended.expand((flat_proba.size(0), m_extended.size(1), m_extended.size(2), flat_proba.size(2)))
+
+        # Expand the feature dimensions of the target
+        flat_target_extended = torch.unsqueeze(flat_target, dim=1)
+        flat_target_extended = flat_target_extended.expand(
+            (flat_target.size(0), m_extended.size(1), flat_target.size(1))
+        )
+        flat_target_extended = torch.unsqueeze(flat_target_extended, dim=1)
+
+        # Extract the vector of class distances for the ground-truth label at each voxel
+        m_extended = torch.gather(m_extended, dim=1, index=flat_target_extended)
+        m_extended = torch.squeeze(m_extended, dim=1)
+
+        # Compute the wasserstein distance map
+        wasserstein_map = m_extended * flat_proba
+
+        # Sum over the classes
+        wasserstein_map = torch.sum(wasserstein_map, dim=1)
+        return wasserstein_map
+
+    def _compute_generalized_true_positive(
+        self, alpha: torch.Tensor, flat_target: torch.Tensor, wasserstein_distance_map: torch.Tensor
+    ) -> torch.Tensor:
+        """
+        Args:
+            alpha: generalised number of true positives of target class.
+            flat_target: the target tensor.
+            wasserstein_distance_map: the map obtained from the above function.
+        """
+        # Extend alpha to a map and select value at each voxel according to flat_target
+        alpha_extended = torch.unsqueeze(alpha, dim=2)
+        alpha_extended = alpha_extended.expand((flat_target.size(0), self.num_classes, flat_target.size(1)))
+        flat_target_extended = torch.unsqueeze(flat_target, dim=1)
+        alpha_extended = torch.gather(alpha_extended, index=flat_target_extended, dim=1)
+
+        return torch.sum(alpha_extended * (1.0 - wasserstein_distance_map), dim=[1, 2])
+
+    def _compute_denominator(
+        self, alpha: torch.Tensor, flat_target: torch.Tensor, wasserstein_distance_map: torch.Tensor
+    ) -> torch.Tensor:
+        """
+        Args:
+            alpha: generalised number of true positives of target class.
+            flat_target: the target tensor.
+            wasserstein_distance_map: the map obtained from the above function.
+        """
+        # Extend alpha to a map and select value at each voxel according to flat_target
+        alpha_extended = torch.unsqueeze(alpha, dim=2)
+        alpha_extended = alpha_extended.expand((flat_target.size(0), self.num_classes, flat_target.size(1)))
+        flat_target_extended = torch.unsqueeze(flat_target, dim=1)
+        alpha_extended = torch.gather(alpha_extended, index=flat_target_extended, dim=1)
+
+        return torch.sum(alpha_extended * (2.0 - wasserstein_distance_map), dim=[1, 2])
+
+    def _compute_alpha_generalized_true_positives(self, flat_target: torch.Tensor) -> torch.Tensor:
+        """
+        Args:
+            flat_target: the target tensor.
+        """
+        alpha: torch.Tensor = torch.ones((flat_target.size(0), self.num_classes)).float().to(flat_target.device)
+        if self.alpha_mode == "GDL":  # GDL style
+            # Define alpha like in the generalized dice loss
+            # i.e. the inverse of the volume of each class.
+            one_hot_f = F.one_hot(flat_target, num_classes=self.num_classes).permute(0, 2, 1).float()
+            volumes = torch.sum(one_hot_f, dim=2)
+            alpha = 1.0 / (volumes + 1.0)
+        else:  # default, i.e. like in the original paper
+            # alpha weights are 0 for the background and 1 the other classes
+            alpha[:, 0] = 0.0
+        return alpha
+
+
+class DiceCELoss(_Loss):
+    """
+    Compute both Dice loss and Cross Entropy Loss, and return the weighted sum of these two losses.
+    The details of Dice loss is shown in ``monai.losses.DiceLoss``.
+    The details of Cross Entropy Loss is shown in ``torch.nn.CrossEntropyLoss`` and ``torch.nn.BCEWithLogitsLoss()``.
+    In this implementation, two deprecated parameters ``size_average`` and ``reduce``, and the parameter ``ignore_index`` are
+    not supported.
+
+    """
+
+    @deprecated_arg(
+        "ce_weight", since="1.2", removed="1.4", new_name="weight", msg_suffix="please use `weight` instead."
+    )
+    def __init__(
+        self,
+        include_background: bool = True,
+        to_onehot_y: bool = False,
+        sigmoid: bool = False,
+        softmax: bool = False,
+        other_act: Callable | None = None,
+        squared_pred: bool = False,
+        jaccard: bool = False,
+        reduction: str = "mean",
+        smooth_nr: float = 1e-5,
+        smooth_dr: float = 1e-5,
+        batch: bool = False,
+        ce_weight: torch.Tensor | None = None,
+        weight: torch.Tensor | None = None,
+        lambda_dice: float = 1.0,
+        lambda_ce: float = 1.0,
+    ) -> None:
+        """
+        Args:
+            ``lambda_ce`` are only used for cross entropy loss.
+            ``reduction`` and ``weight`` is used for both losses and other parameters are only used for dice loss.
+
+            include_background: if False channel index 0 (background category) is excluded from the calculation.
+            to_onehot_y: whether to convert the ``target`` into the one-hot format,
+                using the number of classes inferred from `input` (``input.shape[1]``). Defaults to False.
+            sigmoid: if True, apply a sigmoid function to the prediction, only used by the `DiceLoss`,
+                don't need to specify activation function for `CrossEntropyLoss` and `BCEWithLogitsLoss`.
+            softmax: if True, apply a softmax function to the prediction, only used by the `DiceLoss`,
+                don't need to specify activation function for `CrossEntropyLoss` and `BCEWithLogitsLoss`.
+            other_act: callable function to execute other activation layers, Defaults to ``None``. for example:
+                ``other_act = torch.tanh``. only used by the `DiceLoss`, not for the `CrossEntropyLoss` and `BCEWithLogitsLoss`.
+            squared_pred: use squared versions of targets and predictions in the denominator or not.
+            jaccard: compute Jaccard Index (soft IoU) instead of dice or not.
+            reduction: {``"mean"``, ``"sum"``}
+                Specifies the reduction to apply to the output. Defaults to ``"mean"``. The dice loss should
+                as least reduce the spatial dimensions, which is different from cross entropy loss, thus here
+                the ``none`` option cannot be used.
+
+                - ``"mean"``: the sum of the output will be divided by the number of elements in the output.
+                - ``"sum"``: the output will be summed.
+
+            smooth_nr: a small constant added to the numerator to avoid zero.
+            smooth_dr: a small constant added to the denominator to avoid nan.
+            batch: whether to sum the intersection and union areas over the batch dimension before the dividing.
+                Defaults to False, a Dice loss value is computed independently from each item in the batch
+                before any `reduction`.
+            weight: a rescaling weight given to each class for cross entropy loss for `CrossEntropyLoss`.
+                or a weight of positive examples to be broadcasted with target used as `pos_weight` for `BCEWithLogitsLoss`.
+                See ``torch.nn.CrossEntropyLoss()`` or ``torch.nn.BCEWithLogitsLoss()`` for more information.
+                The weight is also used in `DiceLoss`.
+            lambda_dice: the trade-off weight value for dice loss. The value should be no less than 0.0.
+                Defaults to 1.0.
+            lambda_ce: the trade-off weight value for cross entropy loss. The value should be no less than 0.0.
+                Defaults to 1.0.
+
+        """
+        super().__init__()
+        reduction = look_up_option(reduction, DiceCEReduction).value
+        weight = ce_weight if ce_weight is not None else weight
+        dice_weight: torch.Tensor | None
+        if weight is not None and not include_background:
+            dice_weight = weight[1:]
+        else:
+            dice_weight = weight
+        self.dice = DiceLoss(
+            include_background=include_background,
+            to_onehot_y=to_onehot_y,
+            sigmoid=sigmoid,
+            softmax=softmax,
+            other_act=other_act,
+            squared_pred=squared_pred,
+            jaccard=jaccard,
+            reduction=reduction,
+            smooth_nr=smooth_nr,
+            smooth_dr=smooth_dr,
+            batch=batch,
+            weight=dice_weight,
+        )
+        self.cross_entropy = nn.CrossEntropyLoss(weight=weight, reduction=reduction)
+        self.binary_cross_entropy = nn.BCEWithLogitsLoss(pos_weight=weight, reduction=reduction)
+        if lambda_dice < 0.0:
+            raise ValueError("lambda_dice should be no less than 0.0.")
+        if lambda_ce < 0.0:
+            raise ValueError("lambda_ce should be no less than 0.0.")
+        self.lambda_dice = lambda_dice
+        self.lambda_ce = lambda_ce
+        self.old_pt_ver = not pytorch_after(1, 10)
+
+    def ce(self, input: torch.Tensor, target: torch.Tensor) -> torch.Tensor:
+        """
+        Compute CrossEntropy loss for the input logits and target.
+        Will remove the channel dim according to PyTorch CrossEntropyLoss:
+        https://pytorch.org/docs/stable/generated/torch.nn.CrossEntropyLoss.html?#torch.nn.CrossEntropyLoss.
+
+        """
+        n_pred_ch, n_target_ch = input.shape[1], target.shape[1]
+        if n_pred_ch != n_target_ch and n_target_ch == 1:
+            target = torch.squeeze(target, dim=1)
+            target = target.long()
+        elif self.old_pt_ver:
+            warnings.warn(
+                f"Multichannel targets are not supported in this older Pytorch version {torch.__version__}. "
+                "Using argmax (as a workaround) to convert target to a single channel."
+            )
+            target = torch.argmax(target, dim=1)
+        elif not torch.is_floating_point(target):
+            target = target.to(dtype=input.dtype)
+
+        return self.cross_entropy(input, target)  # type: ignore[no-any-return]
+
+    def bce(self, input: torch.Tensor, target: torch.Tensor) -> torch.Tensor:
+        """
+        Compute Binary CrossEntropy loss for the input logits and target in one single class.
+
+        """
+        if not torch.is_floating_point(target):
+            target = target.to(dtype=input.dtype)
+
+        return self.binary_cross_entropy(input, target)  # type: ignore[no-any-return]
+
+    def forward(self, input: torch.Tensor, target: torch.Tensor) -> torch.Tensor:
+        """
+        Args:
+            input: the shape should be BNH[WD].
+            target: the shape should be BNH[WD] or B1H[WD].
+
+        Raises:
+            ValueError: When number of dimensions for input and target are different.
+            ValueError: When number of channels for target is neither 1 (without one-hot encoding) nor the same as input.
+
+        Returns:
+            torch.Tensor: value of the loss.
+
+        """
+        if input.dim() != target.dim():
+            raise ValueError(
+                "the number of dimensions for input and target should be the same, "
+                f"got shape {input.shape} (nb dims: {len(input.shape)}) and {target.shape} (nb dims: {len(target.shape)}). "
+                "if target is not one-hot encoded, please provide a tensor with shape B1H[WD]."
+            )
+
+        if target.shape[1] != 1 and target.shape[1] != input.shape[1]:
+            raise ValueError(
+                "number of channels for target is neither 1 (without one-hot encoding) nor the same as input, "
+                f"got shape {input.shape} and {target.shape}."
+            )
+
+        dice_loss = self.dice(input, target)
+        ce_loss = self.ce(input, target) if input.shape[1] != 1 else self.bce(input, target)
+        total_loss: torch.Tensor = self.lambda_dice * dice_loss + self.lambda_ce * ce_loss
+
+        return total_loss
+
+
+class DiceFocalLoss(_Loss):
+    """
+    Compute both Dice loss and Focal Loss, and return the weighted sum of these two losses.
+    The details of Dice loss is shown in ``monai.losses.DiceLoss``.
+    The details of Focal Loss is shown in ``monai.losses.FocalLoss``.
+
+    ``gamma`` and ``lambda_focal`` are only used for the focal loss.
+    ``include_background``, ``weight`` and ``reduction`` are used for both losses
+    and other parameters are only used for dice loss.
+
+    """
+
+    @deprecated_arg(
+        "focal_weight", since="1.2", removed="1.4", new_name="weight", msg_suffix="please use `weight` instead."
+    )
+    def __init__(
+        self,
+        include_background: bool = True,
+        to_onehot_y: bool = False,
+        sigmoid: bool = False,
+        softmax: bool = False,
+        other_act: Callable | None = None,
+        squared_pred: bool = False,
+        jaccard: bool = False,
+        reduction: str = "mean",
+        smooth_nr: float = 1e-5,
+        smooth_dr: float = 1e-5,
+        batch: bool = False,
+        gamma: float = 2.0,
+        focal_weight: Sequence[float] | float | int | torch.Tensor | None = None,
+        weight: Sequence[float] | float | int | torch.Tensor | None = None,
+        lambda_dice: float = 1.0,
+        lambda_focal: float = 1.0,
+    ) -> None:
+        """
+        Args:
+            include_background: if False channel index 0 (background category) is excluded from the calculation.
+            to_onehot_y: whether to convert the ``target`` into the one-hot format,
+                using the number of classes inferred from `input` (``input.shape[1]``). Defaults to False.
+            sigmoid: if True, apply a sigmoid function to the prediction, only used by the `DiceLoss`,
+                don't need to specify activation function for `FocalLoss`.
+            softmax: if True, apply a softmax function to the prediction, only used by the `DiceLoss`,
+                don't need to specify activation function for `FocalLoss`.
+            other_act: callable function to execute other activation layers, Defaults to ``None``.
+                for example: `other_act = torch.tanh`. only used by the `DiceLoss`, not for `FocalLoss`.
+            squared_pred: use squared versions of targets and predictions in the denominator or not.
+            jaccard: compute Jaccard Index (soft IoU) instead of dice or not.
+            reduction: {``"none"``, ``"mean"``, ``"sum"``}
+                Specifies the reduction to apply to the output. Defaults to ``"mean"``.
+
+                - ``"none"``: no reduction will be applied.
+                - ``"mean"``: the sum of the output will be divided by the number of elements in the output.
+                - ``"sum"``: the output will be summed.
+
+            smooth_nr: a small constant added to the numerator to avoid zero.
+            smooth_dr: a small constant added to the denominator to avoid nan.
+            batch: whether to sum the intersection and union areas over the batch dimension before the dividing.
+                Defaults to False, a Dice loss value is computed independently from each item in the batch
+                before any `reduction`.
+            gamma: value of the exponent gamma in the definition of the Focal loss.
+            weight: weights to apply to the voxels of each class. If None no weights are applied.
+                The input can be a single value (same weight for all classes), a sequence of values (the length
+                of the sequence should be the same as the number of classes).
+            lambda_dice: the trade-off weight value for dice loss. The value should be no less than 0.0.
+                Defaults to 1.0.
+            lambda_focal: the trade-off weight value for focal loss. The value should be no less than 0.0.
+                Defaults to 1.0.
+
+        """
+        super().__init__()
+        weight = focal_weight if focal_weight is not None else weight
+        self.dice = DiceLoss(
+            include_background=include_background,
+            to_onehot_y=False,
+            sigmoid=sigmoid,
+            softmax=softmax,
+            other_act=other_act,
+            squared_pred=squared_pred,
+            jaccard=jaccard,
+            reduction=reduction,
+            smooth_nr=smooth_nr,
+            smooth_dr=smooth_dr,
+            batch=batch,
+            weight=weight,
+        )
+        self.focal = FocalLoss(
+            include_background=include_background, to_onehot_y=False, gamma=gamma, weight=weight, reduction=reduction
+        )
+        if lambda_dice < 0.0:
+            raise ValueError("lambda_dice should be no less than 0.0.")
+        if lambda_focal < 0.0:
+            raise ValueError("lambda_focal should be no less than 0.0.")
+        self.lambda_dice = lambda_dice
+        self.lambda_focal = lambda_focal
+        self.to_onehot_y = to_onehot_y
+
+    def forward(self, input: torch.Tensor, target: torch.Tensor) -> torch.Tensor:
+        """
+        Args:
+            input: the shape should be BNH[WD]. The input should be the original logits
+                due to the restriction of ``monai.losses.FocalLoss``.
+            target: the shape should be BNH[WD] or B1H[WD].
+
+        Raises:
+            ValueError: When number of dimensions for input and target are different.
+            ValueError: When number of channels for target is neither 1 (without one-hot encoding) nor the same as input.
+
+        Returns:
+            torch.Tensor: value of the loss.
+        """
+        if input.dim() != target.dim():
+            raise ValueError(
+                "the number of dimensions for input and target should be the same, "
+                f"got shape {input.shape} (nb dims: {len(input.shape)}) and {target.shape} (nb dims: {len(target.shape)}). "
+                "if target is not one-hot encoded, please provide a tensor with shape B1H[WD]."
+            )
+
+        if target.shape[1] != 1 and target.shape[1] != input.shape[1]:
+            raise ValueError(
+                "number of channels for target is neither 1 (without one-hot encoding) nor the same as input, "
+                f"got shape {input.shape} and {target.shape}."
+            )
+
+        if self.to_onehot_y:
+            n_pred_ch = input.shape[1]
+            if n_pred_ch == 1:
+                warnings.warn("single channel prediction, `to_onehot_y=True` ignored.")
+            else:
+                target = one_hot(target, num_classes=n_pred_ch)
+        dice_loss = self.dice(input, target)
+        focal_loss = self.focal(input, target)
+        total_loss: torch.Tensor = self.lambda_dice * dice_loss + self.lambda_focal * focal_loss
+        return total_loss
+
+
+class GeneralizedDiceFocalLoss(_Loss):
+    """Compute both Generalized Dice Loss and Focal Loss, and return their weighted average. The details of Generalized Dice Loss
+    and Focal Loss are available at ``monai.losses.GeneralizedDiceLoss`` and ``monai.losses.FocalLoss``.
+
+    Args:
+        include_background (bool, optional): if False channel index 0 (background category) is excluded from the calculation.
+            Defaults to True.
+        to_onehot_y: whether to convert the ``target`` into the one-hot format,
+            using the number of classes inferred from `input` (``input.shape[1]``). Defaults to False.
+        sigmoid (bool, optional): if True, apply a sigmoid function to the prediction. Defaults to False.
+        softmax (bool, optional): if True, apply a softmax function to the prediction. Defaults to False.
+        other_act (Optional[Callable], optional): callable function to execute other activation layers,
+            Defaults to ``None``. for example: `other_act = torch.tanh`.
+            only used by the `GeneralizedDiceLoss`, not for the `FocalLoss`.
+        w_type (Union[Weight, str], optional): {``"square"``, ``"simple"``, ``"uniform"``}. Type of function to transform
+            ground-truth volume to a weight factor. Defaults to ``"square"``.
+        reduction (Union[LossReduction, str], optional): {``"none"``, ``"mean"``, ``"sum"``}. Specified the reduction to
+            apply to the output. Defaults to ``"mean"``.
+            - ``"none"``: no reduction will be applied.
+            - ``"mean"``: the sum of the output will be divided by the number of elements in the output.
+            - ``"sum"``: the output will be summed.
+        smooth_nr (float, optional): a small constant added to the numerator to avoid zero. Defaults to 1e-5.
+        smooth_dr (float, optional): a small constant added to the denominator to avoid nan. Defaults to 1e-5.
+        batch (bool, optional): whether to sum the intersection and union areas over the batch dimension before the dividing.
+            Defaults to False, i.e., the areas are computed for each item in the batch.
+        gamma (float, optional): value of the exponent gamma in the definition of the Focal loss. Defaults to 2.0.
+        weight (Optional[Union[Sequence[float], float, int, torch.Tensor]], optional): weights to apply to
+            the voxels of each class. If None no weights are applied. The input can be a single value
+            (same weight for all classes), a sequence of values (the length of the sequence hould be the same as
+            the number of classes). Defaults to None.
+        lambda_gdl (float, optional): the trade-off weight value for Generalized Dice Loss. The value should be
+            no less than 0.0. Defaults to 1.0.
+        lambda_focal (float, optional): the trade-off weight value for Focal Loss. The value should be no less
+            than 0.0. Defaults to 1.0.
+
+    Raises:
+        ValueError: if either `lambda_gdl` or `lambda_focal` is less than 0.
+    """
+
+    @deprecated_arg(
+        "focal_weight", since="1.2", removed="1.4", new_name="weight", msg_suffix="please use `weight` instead."
+    )
+    def __init__(
+        self,
+        include_background: bool = True,
+        to_onehot_y: bool = False,
+        sigmoid: bool = False,
+        softmax: bool = False,
+        other_act: Callable | None = None,
+        w_type: Weight | str = Weight.SQUARE,
+        reduction: LossReduction | str = LossReduction.MEAN,
+        smooth_nr: float = 1e-5,
+        smooth_dr: float = 1e-5,
+        batch: bool = False,
+        gamma: float = 2.0,
+        focal_weight: Sequence[float] | float | int | torch.Tensor | None = None,
+        weight: Sequence[float] | float | int | torch.Tensor | None = None,
+        lambda_gdl: float = 1.0,
+        lambda_focal: float = 1.0,
+    ) -> None:
+        super().__init__()
+        self.generalized_dice = GeneralizedDiceLoss(
+            include_background=include_background,
+            to_onehot_y=to_onehot_y,
+            sigmoid=sigmoid,
+            softmax=softmax,
+            other_act=other_act,
+            w_type=w_type,
+            reduction=reduction,
+            smooth_nr=smooth_nr,
+            smooth_dr=smooth_dr,
+            batch=batch,
+        )
+        weight = focal_weight if focal_weight is not None else weight
+        self.focal = FocalLoss(
+            include_background=include_background,
+            to_onehot_y=to_onehot_y,
+            gamma=gamma,
+            weight=weight,
+            reduction=reduction,
+        )
+        if lambda_gdl < 0.0:
+            raise ValueError("lambda_gdl should be no less than 0.0.")
+        if lambda_focal < 0.0:
+            raise ValueError("lambda_focal should be no less than 0.0.")
+        self.lambda_gdl = lambda_gdl
+        self.lambda_focal = lambda_focal
+
+    def forward(self, input: torch.Tensor, target: torch.Tensor) -> torch.Tensor:
+        """
+        Args:
+            input (torch.Tensor): the shape should be BNH[WD]. The input should be the original logits
+                due to the restriction of ``monai.losses.FocalLoss``.
+            target (torch.Tensor): the shape should be BNH[WD] or B1H[WD].
+
+        Raises:
+            ValueError: When number of dimensions for input and target are different.
+            ValueError: When number of channels for target is neither 1 (without one-hot encoding) nor the same as input.
+
+        Returns:
+            torch.Tensor: value of the loss.
+        """
+        if input.dim() != target.dim():
+            raise ValueError(
+                "the number of dimensions for input and target should be the same, "
+                f"got shape {input.shape} (nb dims: {len(input.shape)}) and {target.shape} (nb dims: {len(target.shape)}). "
+                "if target is not one-hot encoded, please provide a tensor with shape B1H[WD]."
+            )
+
+        if target.shape[1] != 1 and target.shape[1] != input.shape[1]:
+            raise ValueError(
+                "number of channels for target is neither 1 (without one-hot encoding) nor the same as input, "
+                f"got shape {input.shape} and {target.shape}."
+            )
+
+        gdl_loss = self.generalized_dice(input, target)
+        focal_loss = self.focal(input, target)
+        total_loss: torch.Tensor = self.lambda_gdl * gdl_loss + self.lambda_focal * focal_loss
+        return total_loss
+
+
+Dice = DiceLoss
+dice_ce = DiceCELoss
+dice_focal = DiceFocalLoss
+generalized_dice = GeneralizedDiceLoss
+generalized_dice_focal = GeneralizedDiceFocalLoss
+generalized_wasserstein_dice = GeneralizedWassersteinDiceLoss

source_code/SegMamba/monai/losses/ds_loss.py

@@ -0,0 +1,88 @@
+# Copyright (c) MONAI Consortium
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#     http://www.apache.org/licenses/LICENSE-2.0
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from __future__ import annotations
+
+from typing import Union
+
+import torch
+import torch.nn.functional as F
+from torch.nn.modules.loss import _Loss
+
+from monai.utils import pytorch_after
+
+
+class DeepSupervisionLoss(_Loss):
+    """
+    Wrapper class around the main loss function to accept a list of tensors returned from a deeply
+    supervised networks. The final loss is computed as the sum of weighted losses for each of deep supervision levels.
+    """
+
+    def __init__(self, loss: _Loss, weight_mode: str = "exp", weights: list[float] | None = None) -> None:
+        """
+        Args:
+            loss: main loss instance, e.g DiceLoss().
+            weight_mode: {``"same"``, ``"exp"``, ``"two"``}
+                Specifies the weights calculation for each image level. Defaults to ``"exp"``.
+                - ``"same"``: all weights are equal to 1.
+                - ``"exp"``: exponentially decreasing weights by a power of 2: 0, 0.5, 0.25, 0.125, etc .
+                - ``"two"``: equal smaller weights for lower levels: 1, 0.5, 0.5, 0.5, 0.5, etc
+            weights: a list of weights to apply to each deeply supervised sub-loss, if provided, this will be used
+                regardless of the weight_mode
+        """
+        super().__init__()
+        self.loss = loss
+        self.weight_mode = weight_mode
+        self.weights = weights
+        self.interp_mode = "nearest-exact" if pytorch_after(1, 11) else "nearest"
+
+    def get_weights(self, levels: int = 1) -> list[float]:
+        """
+        Calculates weights for a given number of scale levels
+        """
+        levels = max(1, levels)
+        if self.weights is not None and len(self.weights) >= levels:
+            weights = self.weights[:levels]
+        elif self.weight_mode == "same":
+            weights = [1.0] * levels
+        elif self.weight_mode == "exp":
+            weights = [max(0.5**l, 0.0625) for l in range(levels)]
+        elif self.weight_mode == "two":
+            weights = [1.0 if l == 0 else 0.5 for l in range(levels)]
+        else:
+            weights = [1.0] * levels
+
+        return weights
+
+    def get_loss(self, input: torch.Tensor, target: torch.Tensor) -> torch.Tensor:
+        """
+        Calculates a loss output accounting for differences in shapes,
+        and downsizing targets if necessary (using nearest neighbor interpolation)
+        Generally downsizing occurs for all level, except for the first (level==0)
+        """
+        if input.shape[2:] != target.shape[2:]:
+            target = F.interpolate(target, size=input.shape[2:], mode=self.interp_mode)
+        return self.loss(input, target)  # type: ignore[no-any-return]
+
+    def forward(self, input: Union[None, torch.Tensor, list[torch.Tensor]], target: torch.Tensor) -> torch.Tensor:
+        if isinstance(input, (list, tuple)):
+            weights = self.get_weights(levels=len(input))
+            loss = torch.tensor(0, dtype=torch.float, device=target.device)
+            for l in range(len(input)):
+                loss += weights[l] * self.get_loss(input[l].float(), target)
+            return loss
+        if input is None:
+            raise ValueError("input shouldn't be None.")
+
+        return self.loss(input.float(), target)  # type: ignore[no-any-return]
+
+
+ds_loss = DeepSupervisionLoss

source_code/SegMamba/monai/losses/focal_loss.py

@@ -0,0 +1,255 @@
+# Copyright (c) MONAI Consortium
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#     http://www.apache.org/licenses/LICENSE-2.0
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from __future__ import annotations
+
+import warnings
+from collections.abc import Sequence
+from typing import Optional
+
+import torch
+import torch.nn.functional as F
+from torch.nn.modules.loss import _Loss
+
+from monai.networks import one_hot
+from monai.utils import LossReduction
+
+
+class FocalLoss(_Loss):
+    """
+    FocalLoss is an extension of BCEWithLogitsLoss that down-weights loss from
+    high confidence correct predictions.
+
+    Reimplementation of the Focal Loss described in:
+
+        - ["Focal Loss for Dense Object Detection"](https://arxiv.org/abs/1708.02002), T. Lin et al., ICCV 2017
+        - "AnatomyNet: Deep learning for fast and fully automated whole-volume segmentation of head and neck anatomy",
+          Zhu et al., Medical Physics 2018
+
+    Example:
+        >>> import torch
+        >>> from monai.losses import FocalLoss
+        >>> from torch.nn import BCEWithLogitsLoss
+        >>> shape = B, N, *DIMS = 2, 3, 5, 7, 11
+        >>> input = torch.rand(*shape)
+        >>> target = torch.rand(*shape)
+        >>> # Demonstrate equivalence to BCE when gamma=0
+        >>> fl_g0_criterion = FocalLoss(reduction='none', gamma=0)
+        >>> fl_g0_loss = fl_g0_criterion(input, target)
+        >>> bce_criterion = BCEWithLogitsLoss(reduction='none')
+        >>> bce_loss = bce_criterion(input, target)
+        >>> assert torch.allclose(fl_g0_loss, bce_loss)
+        >>> # Demonstrate "focus" by setting gamma > 0.
+        >>> fl_g2_criterion = FocalLoss(reduction='none', gamma=2)
+        >>> fl_g2_loss = fl_g2_criterion(input, target)
+        >>> # Mark easy and hard cases
+        >>> is_easy = (target > 0.7) & (input > 0.7)
+        >>> is_hard = (target > 0.7) & (input < 0.3)
+        >>> easy_loss_g0 = fl_g0_loss[is_easy].mean()
+        >>> hard_loss_g0 = fl_g0_loss[is_hard].mean()
+        >>> easy_loss_g2 = fl_g2_loss[is_easy].mean()
+        >>> hard_loss_g2 = fl_g2_loss[is_hard].mean()
+        >>> # Gamma > 0 causes the loss function to "focus" on the hard
+        >>> # cases.  IE, easy cases are downweighted, so hard cases
+        >>> # receive a higher proportion of the loss.
+        >>> hard_to_easy_ratio_g2 = hard_loss_g2 / easy_loss_g2
+        >>> hard_to_easy_ratio_g0 = hard_loss_g0 / easy_loss_g0
+        >>> assert hard_to_easy_ratio_g2 > hard_to_easy_ratio_g0
+    """
+
+    def __init__(
+        self,
+        include_background: bool = True,
+        to_onehot_y: bool = False,
+        gamma: float = 2.0,
+        alpha: float | None = None,
+        weight: Sequence[float] | float | int | torch.Tensor | None = None,
+        reduction: LossReduction | str = LossReduction.MEAN,
+        use_softmax: bool = False,
+    ) -> None:
+        """
+        Args:
+            include_background: if False, channel index 0 (background category) is excluded from the loss calculation.
+                If False, `alpha` is invalid when using softmax.
+            to_onehot_y: whether to convert the label `y` into the one-hot format. Defaults to False.
+            gamma: value of the exponent gamma in the definition of the Focal loss. Defaults to 2.
+            alpha: value of the alpha in the definition of the alpha-balanced Focal loss.
+                The value should be in [0, 1]. Defaults to None.
+            weight: weights to apply to the voxels of each class. If None no weights are applied.
+                The input can be a single value (same weight for all classes), a sequence of values (the length
+                of the sequence should be the same as the number of classes. If not ``include_background``,
+                the number of classes should not include the background category class 0).
+                The value/values should be no less than 0. Defaults to None.
+            reduction: {``"none"``, ``"mean"``, ``"sum"``}
+                Specifies the reduction to apply to the output. Defaults to ``"mean"``.
+
+                - ``"none"``: no reduction will be applied.
+                - ``"mean"``: the sum of the output will be divided by the number of elements in the output.
+                - ``"sum"``: the output will be summed.
+
+            use_softmax: whether to use softmax to transform the original logits into probabilities.
+                If True, softmax is used. If False, sigmoid is used. Defaults to False.
+
+        Example:
+            >>> import torch
+            >>> from monai.losses import FocalLoss
+            >>> pred = torch.tensor([[1, 0], [0, 1], [1, 0]], dtype=torch.float32)
+            >>> grnd = torch.tensor([[0], [1], [0]], dtype=torch.int64)
+            >>> fl = FocalLoss(to_onehot_y=True)
+            >>> fl(pred, grnd)
+        """
+        super().__init__(reduction=LossReduction(reduction).value)
+        self.include_background = include_background
+        self.to_onehot_y = to_onehot_y
+        self.gamma = gamma
+        self.alpha = alpha
+        self.weight = weight
+        self.use_softmax = use_softmax
+        weight = torch.as_tensor(weight) if weight is not None else None
+        self.register_buffer("class_weight", weight)
+        self.class_weight: None | torch.Tensor
+
+    def forward(self, input: torch.Tensor, target: torch.Tensor) -> torch.Tensor:
+        """
+        Args:
+            input: the shape should be BNH[WD], where N is the number of classes.
+                The input should be the original logits since it will be transformed by
+                a sigmoid/softmax in the forward function.
+            target: the shape should be BNH[WD] or B1H[WD], where N is the number of classes.
+
+        Raises:
+            ValueError: When input and target (after one hot transform if set)
+                have different shapes.
+            ValueError: When ``self.reduction`` is not one of ["mean", "sum", "none"].
+            ValueError: When ``self.weight`` is a sequence and the length is not equal to the
+                number of classes.
+            ValueError: When ``self.weight`` is/contains a value that is less than 0.
+
+        """
+        n_pred_ch = input.shape[1]
+
+        if self.to_onehot_y:
+            if n_pred_ch == 1:
+                warnings.warn("single channel prediction, `to_onehot_y=True` ignored.")
+            else:
+                target = one_hot(target, num_classes=n_pred_ch)
+
+        if not self.include_background:
+            if n_pred_ch == 1:
+                warnings.warn("single channel prediction, `include_background=False` ignored.")
+            else:
+                # if skipping background, removing first channel
+                target = target[:, 1:]
+                input = input[:, 1:]
+
+        if target.shape != input.shape:
+            raise ValueError(f"ground truth has different shape ({target.shape}) from input ({input.shape})")
+
+        loss: Optional[torch.Tensor] = None
+        input = input.float()
+        target = target.float()
+        if self.use_softmax:
+            if not self.include_background and self.alpha is not None:
+                self.alpha = None
+                warnings.warn("`include_background=False`, `alpha` ignored when using softmax.")
+            loss = softmax_focal_loss(input, target, self.gamma, self.alpha)
+        else:
+            loss = sigmoid_focal_loss(input, target, self.gamma, self.alpha)
+
+        num_of_classes = target.shape[1]
+        if self.class_weight is not None and num_of_classes != 1:
+            # make sure the lengths of weights are equal to the number of classes
+            if self.class_weight.ndim == 0:
+                self.class_weight = torch.as_tensor([self.class_weight] * num_of_classes)
+            else:
+                if self.class_weight.shape[0] != num_of_classes:
+                    raise ValueError(
+                        """the length of the `weight` sequence should be the same as the number of classes.
+                        If `include_background=False`, the weight should not include
+                        the background category class 0."""
+                    )
+            if self.class_weight.min() < 0:
+                raise ValueError("the value/values of the `weight` should be no less than 0.")
+            # apply class_weight to loss
+            self.class_weight = self.class_weight.to(loss)
+            broadcast_dims = [-1] + [1] * len(target.shape[2:])
+            self.class_weight = self.class_weight.view(broadcast_dims)
+            loss = self.class_weight * loss
+
+        if self.reduction == LossReduction.SUM.value:
+            # Previously there was a mean over the last dimension, which did not
+            # return a compatible BCE loss. To maintain backwards compatible
+            # behavior we have a flag that performs this extra step, disable or
+            # parameterize if necessary. (Or justify why the mean should be there)
+            average_spatial_dims = True
+            if average_spatial_dims:
+                loss = loss.mean(dim=list(range(2, len(target.shape))))
+            loss = loss.sum()
+        elif self.reduction == LossReduction.MEAN.value:
+            loss = loss.mean()
+        elif self.reduction == LossReduction.NONE.value:
+            pass
+        else:
+            raise ValueError(f'Unsupported reduction: {self.reduction}, available options are ["mean", "sum", "none"].')
+        return loss
+
+
+def softmax_focal_loss(
+    input: torch.Tensor, target: torch.Tensor, gamma: float = 2.0, alpha: Optional[float] = None
+) -> torch.Tensor:
+    """
+    FL(pt) = -alpha * (1 - pt)**gamma * log(pt)
+
+    where p_i = exp(s_i) / sum_j exp(s_j), t is the target (ground truth) class, and
+    s_j is the unnormalized score for class j.
+    """
+    input_ls = input.log_softmax(1)
+    loss: torch.Tensor = -(1 - input_ls.exp()).pow(gamma) * input_ls * target
+
+    if alpha is not None:
+        # (1-alpha) for the background class and alpha for the other classes
+        alpha_fac = torch.tensor([1 - alpha] + [alpha] * (target.shape[1] - 1)).to(loss)
+        broadcast_dims = [-1] + [1] * len(target.shape[2:])
+        alpha_fac = alpha_fac.view(broadcast_dims)
+        loss = alpha_fac * loss
+
+    return loss
+
+
+def sigmoid_focal_loss(
+    input: torch.Tensor, target: torch.Tensor, gamma: float = 2.0, alpha: Optional[float] = None
+) -> torch.Tensor:
+    """
+    FL(pt) = -alpha * (1 - pt)**gamma * log(pt)
+
+    where p = sigmoid(x), pt = p if label is 1 or 1 - p if label is 0
+    """
+    # computing binary cross entropy with logits
+    # equivalent to F.binary_cross_entropy_with_logits(input, target, reduction='none')
+    # see also https://github.com/pytorch/pytorch/blob/main/aten/src/ATen/native/Loss.cpp#L363
+    loss: torch.Tensor = input - input * target - F.logsigmoid(input)
+
+    # sigmoid(-i) if t==1; sigmoid(i) if t==0 <=>
+    # 1-sigmoid(i) if t==1; sigmoid(i) if t==0 <=>
+    # 1-p if t==1; p if t==0 <=>
+    # pfac, that is, the term (1 - pt)
+    invprobs = F.logsigmoid(-input * (target * 2 - 1))  # reduced chance of overflow
+    # (pfac.log() * gamma).exp() <=>
+    # pfac.log().exp() ^ gamma <=>
+    # pfac ^ gamma
+    loss = (invprobs * gamma).exp() * loss
+
+    if alpha is not None:
+        # alpha if t==1; (1-alpha) if t==0
+        alpha_factor = target * alpha + (1 - target) * (1 - alpha)
+        loss = alpha_factor * loss
+
+    return loss

source_code/SegMamba/monai/losses/hausdorff_loss.py

@@ -0,0 +1,242 @@
+# Copyright (c) MONAI Consortium
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#     http://www.apache.org/licenses/LICENSE-2.0
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# Hausdorff loss implementation based on paper:
+# https://arxiv.org/pdf/1904.10030.pdf
+
+# Repo: https://github.com/PatRyg99/HausdorffLoss
+
+from __future__ import annotations
+
+import warnings
+from typing import Callable
+
+import torch
+from torch.nn.modules.loss import _Loss
+
+from monai.networks import one_hot
+from monai.transforms.utils import distance_transform_edt
+from monai.utils import LossReduction
+
+
+class HausdorffDTLoss(_Loss):
+    """
+    Compute channel-wise binary Hausdorff loss based on distance transform. It can support both multi-classes and
+    multi-labels tasks. The data `input` (BNHW[D] where N is number of classes) is compared with ground truth `target`
+    (BNHW[D]).
+
+    Note that axis N of `input` is expected to be logits or probabilities for each class, if passing logits as input,
+    must set `sigmoid=True` or `softmax=True`, or specifying `other_act`. And the same axis of `target`
+    can be 1 or N (one-hot format).
+
+    The original paper: Karimi, D. et. al. (2019) Reducing the Hausdorff Distance in Medical Image Segmentation with
+    Convolutional Neural Networks, IEEE Transactions on medical imaging, 39(2), 499-513
+    """
+
+    def __init__(
+        self,
+        alpha: float = 2.0,
+        include_background: bool = False,
+        to_onehot_y: bool = False,
+        sigmoid: bool = False,
+        softmax: bool = False,
+        other_act: Callable | None = None,
+        reduction: LossReduction | str = LossReduction.MEAN,
+        batch: bool = False,
+    ) -> None:
+        """
+        Args:
+            include_background: if False, channel index 0 (background category) is excluded from the calculation.
+                if the non-background segmentations are small compared to the total image size they can get overwhelmed
+                by the signal from the background so excluding it in such cases helps convergence.
+            to_onehot_y: whether to convert the ``target`` into the one-hot format,
+                using the number of classes inferred from `input` (``input.shape[1]``). Defaults to False.
+            sigmoid: if True, apply a sigmoid function to the prediction.
+            softmax: if True, apply a softmax function to the prediction.
+            other_act: callable function to execute other activation layers, Defaults to ``None``. for example:
+                ``other_act = torch.tanh``.
+            reduction: {``"none"``, ``"mean"``, ``"sum"``}
+                Specifies the reduction to apply to the output. Defaults to ``"mean"``.
+
+                - ``"none"``: no reduction will be applied.
+                - ``"mean"``: the sum of the output will be divided by the number of elements in the output.
+                - ``"sum"``: the output will be summed.
+            batch: whether to sum the intersection and union areas over the batch dimension before the dividing.
+                Defaults to False, a loss value is computed independently from each item in the batch
+                before any `reduction`.
+
+        Raises:
+            TypeError: When ``other_act`` is not an ``Optional[Callable]``.
+            ValueError: When more than 1 of [``sigmoid=True``, ``softmax=True``, ``other_act is not None``].
+                Incompatible values.
+
+        """
+        super(HausdorffDTLoss, self).__init__(reduction=LossReduction(reduction).value)
+        if other_act is not None and not callable(other_act):
+            raise TypeError(f"other_act must be None or callable but is {type(other_act).__name__}.")
+        if int(sigmoid) + int(softmax) > 1:
+            raise ValueError("Incompatible values: more than 1 of [sigmoid=True, softmax=True, other_act is not None].")
+
+        self.alpha = alpha
+        self.include_background = include_background
+        self.to_onehot_y = to_onehot_y
+        self.sigmoid = sigmoid
+        self.softmax = softmax
+        self.other_act = other_act
+        self.batch = batch
+
+    @torch.no_grad()
+    def distance_field(self, img: torch.Tensor) -> torch.Tensor:
+        """Generate distance transform.
+
+        Args:
+            img (np.ndarray): input mask as NCHWD or NCHW.
+
+        Returns:
+            np.ndarray: Distance field.
+        """
+        field = torch.zeros_like(img)
+
+        for batch_idx in range(len(img)):
+            fg_mask = img[batch_idx] > 0.5
+
+            # For cases where the mask is entirely background or entirely foreground
+            # the distance transform is not well defined for all 1s,
+            # which always would happen on either foreground or background, so skip
+            if fg_mask.any() and not fg_mask.all():
+                fg_dist: torch.Tensor = distance_transform_edt(fg_mask)  # type: ignore
+                bg_mask = ~fg_mask
+                bg_dist: torch.Tensor = distance_transform_edt(bg_mask)  # type: ignore
+
+                field[batch_idx] = fg_dist + bg_dist
+
+        return field
+
+    def forward(self, input: torch.Tensor, target: torch.Tensor) -> torch.Tensor:
+        """
+        Args:
+            input: the shape should be BNHW[D], where N is the number of classes.
+            target: the shape should be BNHW[D] or B1HW[D], where N is the number of classes.
+
+        Raises:
+            ValueError: If the input is not 2D (NCHW) or 3D (NCHWD).
+            AssertionError: When input and target (after one hot transform if set)
+                have different shapes.
+            ValueError: When ``self.reduction`` is not one of ["mean", "sum", "none"].
+
+        Example:
+            >>> import torch
+            >>> from monai.losses.hausdorff_loss import HausdorffDTLoss
+            >>> from monai.networks.utils import one_hot
+            >>> B, C, H, W = 7, 5, 3, 2
+            >>> input = torch.rand(B, C, H, W)
+            >>> target_idx = torch.randint(low=0, high=C - 1, size=(B, H, W)).long()
+            >>> target = one_hot(target_idx[:, None, ...], num_classes=C)
+            >>> self = HausdorffDTLoss(reduction='none')
+            >>> loss = self(input, target)
+            >>> assert np.broadcast_shapes(loss.shape, input.shape) == input.shape
+        """
+        if input.dim() != 4 and input.dim() != 5:
+            raise ValueError("Only 2D (NCHW) and 3D (NCHWD) supported")
+
+        if self.sigmoid:
+            input = torch.sigmoid(input)
+
+        n_pred_ch = input.shape[1]
+        if self.softmax:
+            if n_pred_ch == 1:
+                warnings.warn("single channel prediction, `softmax=True` ignored.")
+            else:
+                input = torch.softmax(input, 1)
+
+        if self.other_act is not None:
+            input = self.other_act(input)
+
+        if self.to_onehot_y:
+            if n_pred_ch == 1:
+                warnings.warn("single channel prediction, `to_onehot_y=True` ignored.")
+            else:
+                target = one_hot(target, num_classes=n_pred_ch)
+
+        if not self.include_background:
+            if n_pred_ch == 1:
+                warnings.warn("single channel prediction, `include_background=False` ignored.")
+            else:
+                # If skipping background, removing first channel
+                target = target[:, 1:]
+                input = input[:, 1:]
+
+        if target.shape != input.shape:
+            raise AssertionError(f"ground truth has different shape ({target.shape}) from input ({input.shape})")
+
+        device = input.device
+        all_f = []
+        for i in range(input.shape[1]):
+            ch_input = input[:, [i]]
+            ch_target = target[:, [i]]
+            pred_dt = self.distance_field(ch_input.detach()).float()
+            target_dt = self.distance_field(ch_target.detach()).float()
+
+            pred_error = (ch_input - ch_target) ** 2
+            distance = pred_dt**self.alpha + target_dt**self.alpha
+
+            running_f = pred_error * distance.to(device)
+            reduce_axis: list[int] = torch.arange(2, len(input.shape)).tolist()
+            if self.batch:
+                # reducing spatial dimensions and batch
+                reduce_axis = [0] + reduce_axis
+            all_f.append(running_f.mean(dim=reduce_axis, keepdim=True))
+        f = torch.cat(all_f, dim=1)
+        if self.reduction == LossReduction.MEAN.value:
+            f = torch.mean(f)  # the batch and channel average
+        elif self.reduction == LossReduction.SUM.value:
+            f = torch.sum(f)  # sum over the batch and channel dims
+        elif self.reduction == LossReduction.NONE.value:
+            # If we are not computing voxelwise loss components at least make sure a none reduction maintains a
+            # broadcastable shape
+            broadcast_shape = list(f.shape[0:2]) + [1] * (len(ch_input.shape) - 2)
+            f = f.view(broadcast_shape)
+        else:
+            raise ValueError(f'Unsupported reduction: {self.reduction}, available options are ["mean", "sum", "none"].')
+
+        return f
+
+
+class LogHausdorffDTLoss(HausdorffDTLoss):
+    """
+    Compute the logarithm of the Hausdorff Distance Transform Loss.
+
+    This class computes the logarithm of the Hausdorff Distance Transform Loss, which is based on the distance transform.
+    The logarithm is computed to potentially stabilize and scale the loss values, especially when the original loss
+    values are very small.
+
+    The formula for the loss is given by:
+        log_loss = log(HausdorffDTLoss + 1)
+
+    Inherits from the HausdorffDTLoss class to utilize its distance transform computation.
+    """
+
+    def forward(self, input: torch.Tensor, target: torch.Tensor) -> torch.Tensor:
+        """
+        Compute the logarithm of the Hausdorff Distance Transform Loss.
+
+        Args:
+            input (torch.Tensor): The shape should be BNHW[D], where N is the number of classes.
+            target (torch.Tensor): The shape should be BNHW[D] or B1HW[D], where N is the number of classes.
+
+        Returns:
+            torch.Tensor: The computed Log Hausdorff Distance Transform Loss for the given input and target.
+
+        Raises:
+            Any exceptions raised by the parent class HausdorffDTLoss.
+        """
+        log_loss: torch.Tensor = torch.log(super().forward(input, target) + 1)
+        return log_loss

source_code/SegMamba/monai/losses/image_dissimilarity.py

@@ -0,0 +1,329 @@
+# Copyright (c) MONAI Consortium
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#     http://www.apache.org/licenses/LICENSE-2.0
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from __future__ import annotations
+
+import torch
+from torch.nn import functional as F
+from torch.nn.modules.loss import _Loss
+
+from monai.networks.layers import gaussian_1d, separable_filtering
+from monai.utils import LossReduction
+from monai.utils.module import look_up_option
+
+
+def make_rectangular_kernel(kernel_size: int) -> torch.Tensor:
+    return torch.ones(kernel_size)
+
+
+def make_triangular_kernel(kernel_size: int) -> torch.Tensor:
+    fsize = (kernel_size + 1) // 2
+    if fsize % 2 == 0:
+        fsize -= 1
+    f = torch.ones((1, 1, fsize), dtype=torch.float).div(fsize)
+    padding = (kernel_size - fsize) // 2 + fsize // 2
+    return F.conv1d(f, f, padding=padding).reshape(-1)
+
+
+def make_gaussian_kernel(kernel_size: int) -> torch.Tensor:
+    sigma = torch.tensor(kernel_size / 3.0)
+    kernel = gaussian_1d(sigma=sigma, truncated=kernel_size // 2, approx="sampled", normalize=False) * (
+        2.5066282 * sigma
+    )
+    return kernel[:kernel_size]
+
+
+kernel_dict = {
+    "rectangular": make_rectangular_kernel,
+    "triangular": make_triangular_kernel,
+    "gaussian": make_gaussian_kernel,
+}
+
+
+class LocalNormalizedCrossCorrelationLoss(_Loss):
+    """
+    Local squared zero-normalized cross-correlation.
+    The loss is based on a moving kernel/window over the y_true/y_pred,
+    within the window the square of zncc is calculated.
+    The kernel can be a rectangular / triangular / gaussian window.
+    The final loss is the averaged loss over all windows.
+
+    Adapted from:
+        https://github.com/voxelmorph/voxelmorph/blob/legacy/src/losses.py
+        DeepReg (https://github.com/DeepRegNet/DeepReg)
+    """
+
+    def __init__(
+        self,
+        spatial_dims: int = 3,
+        kernel_size: int = 3,
+        kernel_type: str = "rectangular",
+        reduction: LossReduction | str = LossReduction.MEAN,
+        smooth_nr: float = 0.0,
+        smooth_dr: float = 1e-5,
+    ) -> None:
+        """
+        Args:
+            spatial_dims: number of spatial dimensions, {``1``, ``2``, ``3``}. Defaults to 3.
+            kernel_size: kernel spatial size, must be odd.
+            kernel_type: {``"rectangular"``, ``"triangular"``, ``"gaussian"``}. Defaults to ``"rectangular"``.
+            reduction: {``"none"``, ``"mean"``, ``"sum"``}
+                Specifies the reduction to apply to the output. Defaults to ``"mean"``.
+
+                - ``"none"``: no reduction will be applied.
+                - ``"mean"``: the sum of the output will be divided by the number of elements in the output.
+                - ``"sum"``: the output will be summed.
+            smooth_nr: a small constant added to the numerator to avoid nan.
+            smooth_dr: a small constant added to the denominator to avoid nan.
+
+        """
+        super().__init__(reduction=LossReduction(reduction).value)
+
+        self.ndim = spatial_dims
+        if self.ndim not in {1, 2, 3}:
+            raise ValueError(f"Unsupported ndim: {self.ndim}-d, only 1-d, 2-d, and 3-d inputs are supported")
+
+        self.kernel_size = kernel_size
+        if self.kernel_size % 2 == 0:
+            raise ValueError(f"kernel_size must be odd, got {self.kernel_size}")
+
+        _kernel = look_up_option(kernel_type, kernel_dict)
+        self.kernel = _kernel(self.kernel_size)
+        self.kernel.require_grads = False
+        self.kernel_vol = self.get_kernel_vol()
+
+        self.smooth_nr = float(smooth_nr)
+        self.smooth_dr = float(smooth_dr)
+
+    def get_kernel_vol(self):
+        vol = self.kernel
+        for _ in range(self.ndim - 1):
+            vol = torch.matmul(vol.unsqueeze(-1), self.kernel.unsqueeze(0))
+        return torch.sum(vol)
+
+    def forward(self, pred: torch.Tensor, target: torch.Tensor) -> torch.Tensor:
+        """
+        Args:
+            pred: the shape should be BNH[WD].
+            target: the shape should be BNH[WD].
+        Raises:
+            ValueError: When ``self.reduction`` is not one of ["mean", "sum", "none"].
+        """
+        if pred.ndim - 2 != self.ndim:
+            raise ValueError(f"expecting pred with {self.ndim} spatial dimensions, got pred of shape {pred.shape}")
+        if target.shape != pred.shape:
+            raise ValueError(f"ground truth has differing shape ({target.shape}) from pred ({pred.shape})")
+
+        t2, p2, tp = target * target, pred * pred, target * pred
+        kernel, kernel_vol = self.kernel.to(pred), self.kernel_vol.to(pred)
+        kernels = [kernel] * self.ndim
+        # sum over kernel
+        t_sum = separable_filtering(target, kernels=kernels)
+        p_sum = separable_filtering(pred, kernels=kernels)
+        t2_sum = separable_filtering(t2, kernels=kernels)
+        p2_sum = separable_filtering(p2, kernels=kernels)
+        tp_sum = separable_filtering(tp, kernels=kernels)
+
+        # average over kernel
+        t_avg = t_sum / kernel_vol
+        p_avg = p_sum / kernel_vol
+
+        # normalized cross correlation between t and p
+        # sum[(t - mean[t]) * (p - mean[p])] / std[t] / std[p]
+        # denoted by num / denom
+        # assume we sum over N values
+        # num = sum[t * p - mean[t] * p - t * mean[p] + mean[t] * mean[p]]
+        #     = sum[t*p] - sum[t] * sum[p] / N * 2 + sum[t] * sum[p] / N
+        #     = sum[t*p] - sum[t] * sum[p] / N
+        #     = sum[t*p] - sum[t] * mean[p] = cross
+        # the following is actually squared ncc
+        cross = tp_sum - p_avg * t_sum
+        t_var = torch.max(
+            t2_sum - t_avg * t_sum, torch.as_tensor(self.smooth_dr, dtype=t2_sum.dtype, device=t2_sum.device)
+        )
+        p_var = torch.max(
+            p2_sum - p_avg * p_sum, torch.as_tensor(self.smooth_dr, dtype=p2_sum.dtype, device=p2_sum.device)
+        )
+        ncc: torch.Tensor = (cross * cross + self.smooth_nr) / (t_var * p_var)
+
+        if self.reduction == LossReduction.SUM.value:
+            return torch.sum(ncc).neg()  # sum over the batch, channel and spatial ndims
+        if self.reduction == LossReduction.NONE.value:
+            return ncc.neg()
+        if self.reduction == LossReduction.MEAN.value:
+            return torch.mean(ncc).neg()  # average over the batch, channel and spatial ndims
+        raise ValueError(f'Unsupported reduction: {self.reduction}, available options are ["mean", "sum", "none"].')
+
+
+class GlobalMutualInformationLoss(_Loss):
+    """
+    Differentiable global mutual information loss via Parzen windowing method.
+
+    Reference:
+        https://dspace.mit.edu/handle/1721.1/123142, Section 3.1, equation 3.1-3.5, Algorithm 1
+    """
+
+    def __init__(
+        self,
+        kernel_type: str = "gaussian",
+        num_bins: int = 23,
+        sigma_ratio: float = 0.5,
+        reduction: LossReduction | str = LossReduction.MEAN,
+        smooth_nr: float = 1e-7,
+        smooth_dr: float = 1e-7,
+    ) -> None:
+        """
+        Args:
+            kernel_type: {``"gaussian"``, ``"b-spline"``}
+                ``"gaussian"``: adapted from DeepReg
+                Reference: https://dspace.mit.edu/handle/1721.1/123142, Section 3.1, equation 3.1-3.5, Algorithm 1.
+                ``"b-spline"``: based on the method of Mattes et al [1,2] and adapted from ITK
+                References:
+                  [1] "Nonrigid multimodality image registration"
+                      D. Mattes, D. R. Haynor, H. Vesselle, T. Lewellen and W. Eubank
+                      Medical Imaging 2001: Image Processing, 2001, pp. 1609-1620.
+                  [2] "PET-CT Image Registration in the Chest Using Free-form Deformations"
+                      D. Mattes, D. R. Haynor, H. Vesselle, T. Lewellen and W. Eubank
+                      IEEE Transactions in Medical Imaging. Vol.22, No.1,
+                      January 2003. pp.120-128.
+
+            num_bins: number of bins for intensity
+            sigma_ratio: a hyper param for gaussian function
+            reduction: {``"none"``, ``"mean"``, ``"sum"``}
+                Specifies the reduction to apply to the output. Defaults to ``"mean"``.
+
+                - ``"none"``: no reduction will be applied.
+                - ``"mean"``: the sum of the output will be divided by the number of elements in the output.
+                - ``"sum"``: the output will be summed.
+            smooth_nr: a small constant added to the numerator to avoid nan.
+            smooth_dr: a small constant added to the denominator to avoid nan.
+        """
+        super().__init__(reduction=LossReduction(reduction).value)
+        if num_bins <= 0:
+            raise ValueError("num_bins must > 0, got {num_bins}")
+        bin_centers = torch.linspace(0.0, 1.0, num_bins)  # (num_bins,)
+        sigma = torch.mean(bin_centers[1:] - bin_centers[:-1]) * sigma_ratio
+        self.kernel_type = look_up_option(kernel_type, ["gaussian", "b-spline"])
+        self.num_bins = num_bins
+        self.kernel_type = kernel_type
+        if self.kernel_type == "gaussian":
+            self.preterm = 1 / (2 * sigma**2)
+            self.bin_centers = bin_centers[None, None, ...]
+        self.smooth_nr = float(smooth_nr)
+        self.smooth_dr = float(smooth_dr)
+
+    def parzen_windowing(
+        self, pred: torch.Tensor, target: torch.Tensor
+    ) -> tuple[torch.Tensor, torch.Tensor, torch.Tensor, torch.Tensor]:
+        if self.kernel_type == "gaussian":
+            pred_weight, pred_probability = self.parzen_windowing_gaussian(pred)
+            target_weight, target_probability = self.parzen_windowing_gaussian(target)
+        elif self.kernel_type == "b-spline":
+            # a third order BSpline kernel is used for the pred image intensity PDF.
+            pred_weight, pred_probability = self.parzen_windowing_b_spline(pred, order=3)
+            # a zero order (box car) BSpline kernel is used for the target image intensity PDF.
+            target_weight, target_probability = self.parzen_windowing_b_spline(target, order=0)
+        else:
+            raise ValueError
+        return pred_weight, pred_probability, target_weight, target_probability
+
+    def parzen_windowing_b_spline(self, img: torch.Tensor, order: int) -> tuple[torch.Tensor, torch.Tensor]:
+        """
+        Parzen windowing with b-spline kernel (adapted from ITK)
+
+        Args:
+            img: the shape should be B[NDHW].
+            order: int.
+        """
+
+        # Compute binsize for the histograms.
+        #
+        # The binsize for the image intensities needs to be adjusted so that
+        # we can avoid dealing with boundary conditions using the cubic
+        # spline as the Parzen window.  We do this by increasing the size
+        # of the bins so that the joint histogram becomes "padded" at the
+        # borders. Because we are changing the binsize,
+        # we also need to shift the minimum by the padded amount in order to
+        # avoid minimum values filling in our padded region.
+        #
+        # Note that there can still be non-zero bin values in the padded region,
+        # it's just that these bins will never be a central bin for the Parzen
+        # window.
+        _max, _min = torch.max(img), torch.min(img)
+        padding = 2
+        bin_size = (_max - _min) / (self.num_bins - 2 * padding)
+        norm_min = torch.div(_min, bin_size) - padding
+
+        # assign bin/window index to each voxel
+        window_term = torch.div(img, bin_size) - norm_min  # B[NDHW]
+        # make sure the extreme values are in valid (non-padded) bins
+        window_term = torch.clamp(window_term, padding, self.num_bins - padding - 1)  # B[NDHW]
+        window_term = window_term.reshape(window_term.shape[0], -1, 1)  # (batch, num_sample, 1)
+        bins = torch.arange(self.num_bins, device=window_term.device).reshape(1, 1, -1)  # (1, 1, num_bins)
+        sample_bin_matrix = torch.abs(bins - window_term)  # (batch, num_sample, num_bins)
+
+        # b-spleen kernel
+        # (4 - 6 * abs ** 2 + 3 * abs ** 3) / 6 when 0 <= abs < 1
+        # (2 - abs) ** 3 / 6 when 1 <= abs < 2
+        weight = torch.zeros_like(sample_bin_matrix, dtype=torch.float)  # (batch, num_sample, num_bins)
+        if order == 0:
+            weight = weight + (sample_bin_matrix < 0.5) + (sample_bin_matrix == 0.5) * 0.5
+        elif order == 3:
+            weight = weight + (4 - 6 * sample_bin_matrix**2 + 3 * sample_bin_matrix**3) * (sample_bin_matrix < 1) / 6
+            weight = weight + (2 - sample_bin_matrix) ** 3 * (sample_bin_matrix >= 1) * (sample_bin_matrix < 2) / 6
+        else:
+            raise ValueError(f"Do not support b-spline {order}-order parzen windowing")
+
+        weight = weight / torch.sum(weight, dim=-1, keepdim=True)  # (batch, num_sample, num_bins)
+        probability = torch.mean(weight, dim=-2, keepdim=True)  # (batch, 1, num_bins)
+        return weight, probability
+
+    def parzen_windowing_gaussian(self, img: torch.Tensor) -> tuple[torch.Tensor, torch.Tensor]:
+        """
+        Parzen windowing with gaussian kernel (adapted from DeepReg implementation)
+        Note: the input is expected to range between 0 and 1
+        Args:
+            img: the shape should be B[NDHW].
+        """
+        img = torch.clamp(img, 0, 1)
+        img = img.reshape(img.shape[0], -1, 1)  # (batch, num_sample, 1)
+        weight = torch.exp(
+            -self.preterm.to(img) * (img - self.bin_centers.to(img)) ** 2
+        )  # (batch, num_sample, num_bin)
+        weight = weight / torch.sum(weight, dim=-1, keepdim=True)  # (batch, num_sample, num_bin)
+        probability = torch.mean(weight, dim=-2, keepdim=True)  # (batch, 1, num_bin)
+        return weight, probability
+
+    def forward(self, pred: torch.Tensor, target: torch.Tensor) -> torch.Tensor:
+        """
+        Args:
+            pred: the shape should be B[NDHW].
+            target: the shape should be same as the pred shape.
+        Raises:
+            ValueError: When ``self.reduction`` is not one of ["mean", "sum", "none"].
+        """
+        if target.shape != pred.shape:
+            raise ValueError(f"ground truth has differing shape ({target.shape}) from pred ({pred.shape})")
+        wa, pa, wb, pb = self.parzen_windowing(pred, target)  # (batch, num_sample, num_bin), (batch, 1, num_bin)
+
+        pab = torch.bmm(wa.permute(0, 2, 1), wb.to(wa)).div(wa.shape[1])  # (batch, num_bins, num_bins)
+        papb = torch.bmm(pa.permute(0, 2, 1), pb.to(pa))  # (batch, num_bins, num_bins)
+        mi = torch.sum(
+            pab * torch.log((pab + self.smooth_nr) / (papb + self.smooth_dr) + self.smooth_dr), dim=(1, 2)
+        )  # (batch)
+
+        if self.reduction == LossReduction.SUM.value:
+            return torch.sum(mi).neg()  # sum over the batch and channel ndims
+        if self.reduction == LossReduction.NONE.value:
+            return mi.neg()
+        if self.reduction == LossReduction.MEAN.value:
+            return torch.mean(mi).neg()  # average over the batch and channel ndims
+        raise ValueError(f'Unsupported reduction: {self.reduction}, available options are ["mean", "sum", "none"].')

source_code/SegMamba/monai/losses/multi_scale.py

@@ -0,0 +1,94 @@
+# Copyright (c) MONAI Consortium
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#     http://www.apache.org/licenses/LICENSE-2.0
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from __future__ import annotations
+
+import torch
+from torch.nn.modules.loss import _Loss
+
+from monai.networks.layers import gaussian_1d, separable_filtering
+from monai.utils import LossReduction
+
+
+def make_gaussian_kernel(sigma: int) -> torch.Tensor:
+    if sigma <= 0:
+        raise ValueError(f"expecting positive sigma, got sigma={sigma}")
+    return gaussian_1d(sigma=torch.tensor(sigma), truncated=3, approx="sampled", normalize=False)
+
+
+def make_cauchy_kernel(sigma: int) -> torch.Tensor:
+    if sigma <= 0:
+        raise ValueError(f"expecting positive sigma, got sigma={sigma}")
+    tail = int(sigma * 5)
+    k = torch.tensor([((x / sigma) ** 2 + 1) for x in range(-tail, tail + 1)])
+    k = torch.reciprocal(k)
+    k = k / torch.sum(k)
+    return k
+
+
+kernel_fn_dict = {"gaussian": make_gaussian_kernel, "cauchy": make_cauchy_kernel}
+
+
+class MultiScaleLoss(_Loss):
+    """
+    This is a wrapper class.
+    It smooths the input and target at different scales before passing them into the wrapped loss function.
+
+    Adapted from:
+        DeepReg (https://github.com/DeepRegNet/DeepReg)
+    """
+
+    def __init__(
+        self,
+        loss: _Loss,
+        scales: list | None = None,
+        kernel: str = "gaussian",
+        reduction: LossReduction | str = LossReduction.MEAN,
+    ) -> None:
+        """
+        Args:
+            loss: loss function to be wrapped
+            scales: list of scalars or None, if None, do not apply any scaling.
+            kernel: gaussian or cauchy.
+        """
+        super().__init__(reduction=LossReduction(reduction).value)
+        if kernel not in kernel_fn_dict:
+            raise ValueError(f"got unsupported kernel type: {kernel}", "only support gaussian and cauchy")
+        self.kernel_fn = kernel_fn_dict[kernel]
+        self.loss = loss
+        self.scales = scales
+
+    def forward(self, y_true: torch.Tensor, y_pred: torch.Tensor) -> torch.Tensor:
+        if self.scales is None:
+            loss: torch.Tensor = self.loss(y_pred, y_true)
+        else:
+            loss_list = []
+            for s in self.scales:
+                if s == 0:
+                    # no smoothing
+                    loss_list.append(self.loss(y_pred, y_true))
+                else:
+                    loss_list.append(
+                        self.loss(
+                            separable_filtering(y_pred, [self.kernel_fn(s).to(y_pred)] * (y_true.ndim - 2)),
+                            separable_filtering(y_true, [self.kernel_fn(s).to(y_pred)] * (y_true.ndim - 2)),
+                        )
+                    )
+            loss = torch.stack(loss_list, dim=0)
+
+        if self.reduction == LossReduction.MEAN.value:
+            loss = torch.mean(loss)  # the batch and channel average
+        elif self.reduction == LossReduction.SUM.value:
+            loss = torch.sum(loss)  # sum over the batch and channel dims
+        elif self.reduction != LossReduction.NONE.value:
+            raise ValueError(f'Unsupported reduction: {self.reduction}, available options are ["mean", "sum", "none"].')
+
+        return loss

source_code/SegMamba/monai/losses/perceptual.py

@@ -0,0 +1,437 @@
+# Copyright (c) MONAI Consortium
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#     http://www.apache.org/licenses/LICENSE-2.0
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from __future__ import annotations
+
+import warnings
+
+import torch
+import torch.nn as nn
+
+from monai.utils import optional_import
+from monai.utils.enums import StrEnum
+
+LPIPS, _ = optional_import("lpips", name="LPIPS")
+torchvision, _ = optional_import("torchvision")
+
+
+class PercetualNetworkType(StrEnum):
+    alex = "alex"
+    vgg = "vgg"
+    squeeze = "squeeze"
+    radimagenet_resnet50 = "radimagenet_resnet50"
+    medicalnet_resnet10_23datasets = "medicalnet_resnet10_23datasets"
+    medicalnet_resnet50_23datasets = "medicalnet_resnet50_23datasets"
+    resnet50 = "resnet50"
+
+
+class PerceptualLoss(nn.Module):
+    """
+    Perceptual loss using features from pretrained deep neural networks trained. The function supports networks
+    pretrained on: ImageNet that use the LPIPS approach from Zhang, et al. "The unreasonable effectiveness of deep
+    features as a perceptual metric." https://arxiv.org/abs/1801.03924 ; RadImagenet from Mei, et al. "RadImageNet: An
+    Open Radiologic Deep Learning Research Dataset for Effective Transfer Learning"
+    https://pubs.rsna.org/doi/full/10.1148/ryai.210315 ; MedicalNet from Chen et al. "Med3D: Transfer Learning for
+    3D Medical Image Analysis" https://arxiv.org/abs/1904.00625 ;
+    and ResNet50 from Torchvision: https://pytorch.org/vision/main/models/generated/torchvision.models.resnet50.html .
+
+    The fake 3D implementation is based on a 2.5D approach where we calculate the 2D perceptual loss on slices from all
+    three axes and average. The full 3D approach uses a 3D network to calculate the perceptual loss.
+    MedicalNet networks are only compatible with 3D inputs and support channel-wise loss.
+
+    Args:
+        spatial_dims: number of spatial dimensions.
+        network_type: {``"alex"``, ``"vgg"``, ``"squeeze"``, ``"radimagenet_resnet50"``,
+        ``"medicalnet_resnet10_23datasets"``, ``"medicalnet_resnet50_23datasets"``, ``"resnet50"``}
+            Specifies the network architecture to use. Defaults to ``"alex"``.
+        is_fake_3d: if True use 2.5D approach for a 3D perceptual loss.
+        fake_3d_ratio: ratio of how many slices per axis are used in the 2.5D approach.
+        cache_dir: path to cache directory to save the pretrained network weights.
+        pretrained: whether to load pretrained weights. This argument only works when using networks from
+            LIPIS or Torchvision. Defaults to ``"True"``.
+        pretrained_path: if `pretrained` is `True`, users can specify a weights file to be loaded
+            via using this argument. This argument only works when ``"network_type"`` is "resnet50".
+            Defaults to `None`.
+        pretrained_state_dict_key: if `pretrained_path` is not `None`, this argument is used to
+            extract the expected state dict. This argument only works when ``"network_type"`` is "resnet50".
+            Defaults to `None`.
+        channel_wise: if True, the loss is returned per channel. Otherwise the loss is averaged over the channels.
+                Defaults to ``False``.
+    """
+
+    def __init__(
+        self,
+        spatial_dims: int,
+        network_type: str = PercetualNetworkType.alex,
+        is_fake_3d: bool = True,
+        fake_3d_ratio: float = 0.5,
+        cache_dir: str | None = None,
+        pretrained: bool = True,
+        pretrained_path: str | None = None,
+        pretrained_state_dict_key: str | None = None,
+        channel_wise: bool = False,
+    ):
+        super().__init__()
+
+        if spatial_dims not in [2, 3]:
+            raise NotImplementedError("Perceptual loss is implemented only in 2D and 3D.")
+
+        if (spatial_dims == 2 or is_fake_3d) and "medicalnet_" in network_type:
+            raise ValueError(
+                "MedicalNet networks are only compatible with ``spatial_dims=3``."
+                "Argument is_fake_3d must be set to False."
+            )
+
+        if channel_wise and "medicalnet_" not in network_type:
+            raise ValueError("Channel-wise loss is only compatible with MedicalNet networks.")
+
+        if network_type.lower() not in list(PercetualNetworkType):
+            raise ValueError(
+                "Unrecognised criterion entered for Adversarial Loss. Must be one in: %s"
+                % ", ".join(PercetualNetworkType)
+            )
+
+        if cache_dir:
+            torch.hub.set_dir(cache_dir)
+            # raise a warning that this may change the default cache dir for all torch.hub calls
+            warnings.warn(
+                f"Setting cache_dir to {cache_dir}, this may change the default cache dir for all torch.hub calls."
+            )
+
+        self.spatial_dims = spatial_dims
+        self.perceptual_function: nn.Module
+        if spatial_dims == 3 and is_fake_3d is False:
+            self.perceptual_function = MedicalNetPerceptualSimilarity(
+                net=network_type, verbose=False, channel_wise=channel_wise
+            )
+        elif "radimagenet_" in network_type:
+            self.perceptual_function = RadImageNetPerceptualSimilarity(net=network_type, verbose=False)
+        elif network_type == "resnet50":
+            self.perceptual_function = TorchvisionModelPerceptualSimilarity(
+                net=network_type,
+                pretrained=pretrained,
+                pretrained_path=pretrained_path,
+                pretrained_state_dict_key=pretrained_state_dict_key,
+            )
+        else:
+            self.perceptual_function = LPIPS(pretrained=pretrained, net=network_type, verbose=False)
+        self.is_fake_3d = is_fake_3d
+        self.fake_3d_ratio = fake_3d_ratio
+        self.channel_wise = channel_wise
+
+    def _calculate_axis_loss(self, input: torch.Tensor, target: torch.Tensor, spatial_axis: int) -> torch.Tensor:
+        """
+        Calculate perceptual loss in one of the axis used in the 2.5D approach. After the slices of one spatial axis
+        is transformed into different instances in the batch, we compute the loss using the 2D approach.
+
+        Args:
+            input: input 5D tensor. BNHWD
+            target: target 5D tensor. BNHWD
+            spatial_axis: spatial axis to obtain the 2D slices.
+        """
+
+        def batchify_axis(x: torch.Tensor, fake_3d_perm: tuple) -> torch.Tensor:
+            """
+            Transform slices from one spatial axis into different instances in the batch.
+            """
+            slices = x.float().permute((0,) + fake_3d_perm).contiguous()
+            slices = slices.view(-1, x.shape[fake_3d_perm[1]], x.shape[fake_3d_perm[2]], x.shape[fake_3d_perm[3]])
+
+            return slices
+
+        preserved_axes = [2, 3, 4]
+        preserved_axes.remove(spatial_axis)
+
+        channel_axis = 1
+        input_slices = batchify_axis(x=input, fake_3d_perm=(spatial_axis, channel_axis) + tuple(preserved_axes))
+        indices = torch.randperm(input_slices.shape[0])[: int(input_slices.shape[0] * self.fake_3d_ratio)].to(
+            input_slices.device
+        )
+        input_slices = torch.index_select(input_slices, dim=0, index=indices)
+        target_slices = batchify_axis(x=target, fake_3d_perm=(spatial_axis, channel_axis) + tuple(preserved_axes))
+        target_slices = torch.index_select(target_slices, dim=0, index=indices)
+
+        axis_loss = torch.mean(self.perceptual_function(input_slices, target_slices))
+
+        return axis_loss
+
+    def forward(self, input: torch.Tensor, target: torch.Tensor) -> torch.Tensor:
+        """
+        Args:
+            input: the shape should be BNHW[D].
+            target: the shape should be BNHW[D].
+        """
+        if target.shape != input.shape:
+            raise ValueError(f"ground truth has differing shape ({target.shape}) from input ({input.shape})")
+
+        if self.spatial_dims == 3 and self.is_fake_3d:
+            # Compute 2.5D approach
+            loss_sagittal = self._calculate_axis_loss(input, target, spatial_axis=2)
+            loss_coronal = self._calculate_axis_loss(input, target, spatial_axis=3)
+            loss_axial = self._calculate_axis_loss(input, target, spatial_axis=4)
+            loss = loss_sagittal + loss_axial + loss_coronal
+        else:
+            # 2D and real 3D cases
+            loss = self.perceptual_function(input, target)
+
+        if self.channel_wise:
+            loss = torch.mean(loss.squeeze(), dim=0)
+        else:
+            loss = torch.mean(loss)
+
+        return loss
+
+
+class MedicalNetPerceptualSimilarity(nn.Module):
+    """
+    Component to perform the perceptual evaluation with the networks pretrained by Chen, et al. "Med3D: Transfer
+    Learning for 3D Medical Image Analysis". This class uses torch Hub to download the networks from
+    "Warvito/MedicalNet-models".
+
+    Args:
+        net: {``"medicalnet_resnet10_23datasets"``, ``"medicalnet_resnet50_23datasets"``}
+            Specifies the network architecture to use. Defaults to ``"medicalnet_resnet10_23datasets"``.
+        verbose: if false, mute messages from torch Hub load function.
+        channel_wise: if True, the loss is returned per channel. Otherwise the loss is averaged over the channels.
+                Defaults to ``False``.
+    """
+
+    def __init__(
+        self, net: str = "medicalnet_resnet10_23datasets", verbose: bool = False, channel_wise: bool = False
+    ) -> None:
+        super().__init__()
+        torch.hub._validate_not_a_forked_repo = lambda a, b, c: True
+        self.model = torch.hub.load("warvito/MedicalNet-models", model=net, verbose=verbose)
+        self.eval()
+
+        self.channel_wise = channel_wise
+
+        for param in self.parameters():
+            param.requires_grad = False
+
+    def forward(self, input: torch.Tensor, target: torch.Tensor) -> torch.Tensor:
+        """
+        Compute perceptual loss using MedicalNet 3D networks. The input and target tensors are inputted in the
+        pre-trained MedicalNet that is used for feature extraction. Then, these extracted features are normalised across
+        the channels. Finally, we compute the difference between the input and target features and calculate the mean
+        value from the spatial dimensions to obtain the perceptual loss.
+
+        Args:
+            input: 3D input tensor with shape BCDHW.
+            target: 3D target tensor with shape BCDHW.
+
+        """
+        input = medicalnet_intensity_normalisation(input)
+        target = medicalnet_intensity_normalisation(target)
+
+        # Get model outputs
+        feats_per_ch = 0
+        for ch_idx in range(input.shape[1]):
+            input_channel = input[:, ch_idx, ...].unsqueeze(1)
+            target_channel = target[:, ch_idx, ...].unsqueeze(1)
+
+            if ch_idx == 0:
+                outs_input = self.model.forward(input_channel)
+                outs_target = self.model.forward(target_channel)
+                feats_per_ch = outs_input.shape[1]
+            else:
+                outs_input = torch.cat([outs_input, self.model.forward(input_channel)], dim=1)
+                outs_target = torch.cat([outs_target, self.model.forward(target_channel)], dim=1)
+
+        # Normalise through the channels
+        feats_input = normalize_tensor(outs_input)
+        feats_target = normalize_tensor(outs_target)
+
+        feats_diff: torch.Tensor = (feats_input - feats_target) ** 2
+        if self.channel_wise:
+            results = torch.zeros(
+                feats_diff.shape[0], input.shape[1], feats_diff.shape[2], feats_diff.shape[3], feats_diff.shape[4]
+            )
+            for i in range(input.shape[1]):
+                l_idx = i * feats_per_ch
+                r_idx = (i + 1) * feats_per_ch
+                results[:, i, ...] = feats_diff[:, l_idx : i + r_idx, ...].sum(dim=1)
+        else:
+            results = feats_diff.sum(dim=1, keepdim=True)
+
+        results = spatial_average_3d(results, keepdim=True)
+
+        return results
+
+
+def spatial_average_3d(x: torch.Tensor, keepdim: bool = True) -> torch.Tensor:
+    return x.mean([2, 3, 4], keepdim=keepdim)
+
+
+def normalize_tensor(x: torch.Tensor, eps: float = 1e-10) -> torch.Tensor:
+    norm_factor = torch.sqrt(torch.sum(x**2, dim=1, keepdim=True))
+    return x / (norm_factor + eps)
+
+
+def medicalnet_intensity_normalisation(volume):
+    """Based on https://github.com/Tencent/MedicalNet/blob/18c8bb6cd564eb1b964bffef1f4c2283f1ae6e7b/datasets/brains18.py#L133"""
+    mean = volume.mean()
+    std = volume.std()
+    return (volume - mean) / std
+
+
+class RadImageNetPerceptualSimilarity(nn.Module):
+    """
+    Component to perform the perceptual evaluation with the networks pretrained on RadImagenet (pretrained by Mei, et
+    al. "RadImageNet: An Open Radiologic Deep Learning Research Dataset for Effective Transfer Learning"). This class
+    uses torch Hub to download the networks from "Warvito/radimagenet-models".
+
+    Args:
+        net: {``"radimagenet_resnet50"``}
+            Specifies the network architecture to use. Defaults to ``"radimagenet_resnet50"``.
+        verbose: if false, mute messages from torch Hub load function.
+    """
+
+    def __init__(self, net: str = "radimagenet_resnet50", verbose: bool = False) -> None:
+        super().__init__()
+        self.model = torch.hub.load("Warvito/radimagenet-models", model=net, verbose=verbose)
+        self.eval()
+
+        for param in self.parameters():
+            param.requires_grad = False
+
+    def forward(self, input: torch.Tensor, target: torch.Tensor) -> torch.Tensor:
+        """
+        We expect that the input is normalised between [0, 1]. Given the preprocessing performed during the training at
+        https://github.com/BMEII-AI/RadImageNet, we make sure that the input and target have 3 channels, reorder it from
+         'RGB' to 'BGR', and then remove the mean components of each input data channel. The outputs are normalised
+        across the channels, and we obtain the mean from the spatial dimensions (similar approach to the lpips package).
+        """
+        # If input has just 1 channel, repeat channel to have 3 channels
+        if input.shape[1] == 1 and target.shape[1] == 1:
+            input = input.repeat(1, 3, 1, 1)
+            target = target.repeat(1, 3, 1, 1)
+
+        # Change order from 'RGB' to 'BGR'
+        input = input[:, [2, 1, 0], ...]
+        target = target[:, [2, 1, 0], ...]
+
+        # Subtract mean used during training
+        input = subtract_mean(input)
+        target = subtract_mean(target)
+
+        # Get model outputs
+        outs_input = self.model.forward(input)
+        outs_target = self.model.forward(target)
+
+        # Normalise through the channels
+        feats_input = normalize_tensor(outs_input)
+        feats_target = normalize_tensor(outs_target)
+
+        results: torch.Tensor = (feats_input - feats_target) ** 2
+        results = spatial_average(results.sum(dim=1, keepdim=True), keepdim=True)
+
+        return results
+
+
+class TorchvisionModelPerceptualSimilarity(nn.Module):
+    """
+    Component to perform the perceptual evaluation with TorchVision models.
+    Currently, only ResNet50 is supported. The network structure is based on:
+    https://pytorch.org/vision/main/models/generated/torchvision.models.resnet50.html
+
+    Args:
+        net: {``"resnet50"``}
+            Specifies the network architecture to use. Defaults to ``"resnet50"``.
+        pretrained: whether to load pretrained weights. Defaults to `True`.
+        pretrained_path: if `pretrained` is `True`, users can specify a weights file to be loaded
+            via using this argument. Defaults to `None`.
+        pretrained_state_dict_key: if `pretrained_path` is not `None`, this argument is used to
+            extract the expected state dict. Defaults to `None`.
+    """
+
+    def __init__(
+        self,
+        net: str = "resnet50",
+        pretrained: bool = True,
+        pretrained_path: str | None = None,
+        pretrained_state_dict_key: str | None = None,
+    ) -> None:
+        super().__init__()
+        supported_networks = ["resnet50"]
+        if net not in supported_networks:
+            raise NotImplementedError(
+                f"'net' {net} is not supported, please select a network from {supported_networks}."
+            )
+
+        if pretrained_path is None:
+            network = torchvision.models.resnet50(
+                weights=torchvision.models.ResNet50_Weights.DEFAULT if pretrained else None
+            )
+        else:
+            network = torchvision.models.resnet50(weights=None)
+            if pretrained is True:
+                state_dict = torch.load(pretrained_path)
+                if pretrained_state_dict_key is not None:
+                    state_dict = state_dict[pretrained_state_dict_key]
+                network.load_state_dict(state_dict)
+        self.final_layer = "layer4.2.relu_2"
+        self.model = torchvision.models.feature_extraction.create_feature_extractor(network, [self.final_layer])
+        self.eval()
+
+        for param in self.parameters():
+            param.requires_grad = False
+
+    def forward(self, input: torch.Tensor, target: torch.Tensor) -> torch.Tensor:
+        """
+        We expect that the input is normalised between [0, 1]. Given the preprocessing performed during the training at
+        https://pytorch.org/vision/main/models/generated/torchvision.models.resnet50.html#torchvision.models.ResNet50_Weights,
+        we make sure that the input and target have 3 channels, and then do Z-Score normalization.
+        The outputs are normalised across the channels, and we obtain the mean from the spatial dimensions (similar
+        approach to the lpips package).
+        """
+        # If input has just 1 channel, repeat channel to have 3 channels
+        if input.shape[1] == 1 and target.shape[1] == 1:
+            input = input.repeat(1, 3, 1, 1)
+            target = target.repeat(1, 3, 1, 1)
+
+        # Input normalization
+        input = torchvision_zscore_norm(input)
+        target = torchvision_zscore_norm(target)
+
+        # Get model outputs
+        outs_input = self.model.forward(input)[self.final_layer]
+        outs_target = self.model.forward(target)[self.final_layer]
+
+        # Normalise through the channels
+        feats_input = normalize_tensor(outs_input)
+        feats_target = normalize_tensor(outs_target)
+
+        results: torch.Tensor = (feats_input - feats_target) ** 2
+        results = spatial_average(results.sum(dim=1, keepdim=True), keepdim=True)
+
+        return results
+
+
+def spatial_average(x: torch.Tensor, keepdim: bool = True) -> torch.Tensor:
+    return x.mean([2, 3], keepdim=keepdim)
+
+
+def torchvision_zscore_norm(x: torch.Tensor) -> torch.Tensor:
+    mean = [0.485, 0.456, 0.406]
+    std = [0.229, 0.224, 0.225]
+    x[:, 0, :, :] = (x[:, 0, :, :] - mean[0]) / std[0]
+    x[:, 1, :, :] = (x[:, 1, :, :] - mean[1]) / std[1]
+    x[:, 2, :, :] = (x[:, 2, :, :] - mean[2]) / std[2]
+    return x
+
+
+def subtract_mean(x: torch.Tensor) -> torch.Tensor:
+    mean = [0.406, 0.456, 0.485]
+    x[:, 0, :, :] -= mean[0]
+    x[:, 1, :, :] -= mean[1]
+    x[:, 2, :, :] -= mean[2]
+    return x

source_code/SegMamba/monai/losses/spatial_mask.py

@@ -0,0 +1,70 @@
+# Copyright (c) MONAI Consortium
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#     http://www.apache.org/licenses/LICENSE-2.0
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from __future__ import annotations
+
+import inspect
+import warnings
+from collections.abc import Callable
+from typing import Any, Optional
+
+import torch
+from torch.nn.modules.loss import _Loss
+
+__all__ = ["MaskedLoss"]
+
+
+class MaskedLoss(_Loss):
+    """
+    This is a wrapper class for the loss functions.  It allows for additional
+    weighting masks to be applied to both input and target.
+
+    See Also:
+        - :py:class:`monai.losses.MaskedDiceLoss`
+    """
+
+    def __init__(
+        self, loss: Callable[[torch.Tensor, torch.Tensor], torch.Tensor] | _Loss, *loss_args: Any, **loss_kwargs: Any
+    ) -> None:
+        """
+        Args:
+            loss: loss function to be wrapped, this could be a loss class or an instance of a loss class.
+            loss_args: arguments to the loss function's constructor if `loss` is a class.
+            loss_kwargs: keyword arguments to the loss function's constructor if `loss` is a class.
+        """
+        super().__init__()
+        self.loss: Callable[[torch.Tensor, torch.Tensor], torch.Tensor] = (
+            loss(*loss_args, **loss_kwargs) if inspect.isclass(loss) else loss
+        )
+        if not callable(self.loss):
+            raise ValueError("The loss function is not callable.")
+
+    def forward(self, input: torch.Tensor, target: torch.Tensor, mask: Optional[torch.Tensor] = None) -> torch.Tensor:
+        """
+        Args:
+            input: the shape should be BNH[WD].
+            target: the shape should be BNH[WD].
+            mask: the shape should be B1H[WD] or 11H[WD].
+        """
+        if mask is None:
+            warnings.warn("No mask value specified for the MaskedLoss.")
+            return self.loss(input, target)
+
+        if input.dim() != mask.dim():
+            warnings.warn(f"Dim of input ({input.shape}) is different from mask ({mask.shape}).")
+        if input.shape[0] != mask.shape[0] and mask.shape[0] != 1:
+            raise ValueError(f"Batch size of mask ({mask.shape}) must be one or equal to input ({input.shape}).")
+        if target.dim() > 1:
+            if mask.shape[1] != 1:
+                raise ValueError(f"Mask ({mask.shape}) must have only one channel.")
+            if input.shape[2:] != mask.shape[2:]:
+                warnings.warn(f"Spatial size of input ({input.shape}) is different from mask ({mask.shape}).")
+        return self.loss(input * mask, target * mask)

source_code/SegMamba/monai/losses/spectral_loss.py

@@ -0,0 +1,88 @@
+# Copyright (c) MONAI Consortium
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#     http://www.apache.org/licenses/LICENSE-2.0
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from __future__ import annotations
+
+import torch
+import torch.nn.functional as F
+from torch.fft import fftn
+from torch.nn.modules.loss import _Loss
+
+from monai.utils import LossReduction
+
+
+class JukeboxLoss(_Loss):
+    """
+    Calculate spectral component based on the magnitude of Fast Fourier Transform (FFT).
+
+    Based on:
+        Dhariwal, et al. 'Jukebox: A generative model for music.' https://arxiv.org/abs/2005.00341
+
+    Args:
+        spatial_dims: number of spatial dimensions.
+        fft_signal_size: signal size in the transformed dimensions. See torch.fft.fftn() for more information.
+        fft_norm: {``"forward"``, ``"backward"``, ``"ortho"``} Specifies the normalization mode in the fft. See
+            torch.fft.fftn() for more information.
+
+        reduction: {``"none"``, ``"mean"``, ``"sum"``}
+            Specifies the reduction to apply to the output. Defaults to ``"mean"``.
+
+            - ``"none"``: no reduction will be applied.
+            - ``"mean"``: the sum of the output will be divided by the number of elements in the output.
+            - ``"sum"``: the output will be summed.
+    """
+
+    def __init__(
+        self,
+        spatial_dims: int,
+        fft_signal_size: tuple[int] | None = None,
+        fft_norm: str = "ortho",
+        reduction: LossReduction | str = LossReduction.MEAN,
+    ) -> None:
+        super().__init__(reduction=LossReduction(reduction).value)
+
+        self.spatial_dims = spatial_dims
+        self.fft_signal_size = fft_signal_size
+        self.fft_dim = tuple(range(1, spatial_dims + 2))
+        self.fft_norm = fft_norm
+
+    def forward(self, input: torch.Tensor, target: torch.Tensor) -> torch.Tensor:
+        input_amplitude = self._get_fft_amplitude(target)
+        target_amplitude = self._get_fft_amplitude(input)
+
+        # Compute distance between amplitude of frequency components
+        # See Section 3.3 from https://arxiv.org/abs/2005.00341
+        loss = F.mse_loss(target_amplitude, input_amplitude, reduction="none")
+
+        if self.reduction == LossReduction.MEAN.value:
+            loss = loss.mean()
+        elif self.reduction == LossReduction.SUM.value:
+            loss = loss.sum()
+        elif self.reduction == LossReduction.NONE.value:
+            pass
+
+        return loss
+
+    def _get_fft_amplitude(self, images: torch.Tensor) -> torch.Tensor:
+        """
+        Calculate the amplitude of the fourier transformations representation of the images
+
+        Args:
+            images: Images that are to undergo fftn
+
+        Returns:
+            fourier transformation amplitude
+        """
+        img_fft = fftn(images, s=self.fft_signal_size, dim=self.fft_dim, norm=self.fft_norm)
+
+        amplitude = torch.sqrt(torch.real(img_fft) ** 2 + torch.imag(img_fft) ** 2)
+
+        return amplitude

source_code/SegMamba/monai/losses/ssim_loss.py

@@ -0,0 +1,134 @@
+# Copyright (c) MONAI Consortium
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#     http://www.apache.org/licenses/LICENSE-2.0
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from __future__ import annotations
+
+from collections.abc import Sequence
+
+import torch
+from torch.nn.modules.loss import _Loss
+
+from monai.metrics.regression import KernelType, SSIMMetric
+from monai.utils import LossReduction, ensure_tuple_rep
+
+
+class SSIMLoss(_Loss):
+    """
+    Compute the loss function based on the Structural Similarity Index Measure (SSIM) Metric.
+
+    For more info, visit
+        https://vicuesoft.com/glossary/term/ssim-ms-ssim/
+
+    SSIM reference paper:
+        Wang, Zhou, et al. "Image quality assessment: from error visibility to structural
+        similarity." IEEE transactions on image processing 13.4 (2004): 600-612.
+    """
+
+    def __init__(
+        self,
+        spatial_dims: int,
+        data_range: float = 1.0,
+        kernel_type: KernelType | str = KernelType.GAUSSIAN,
+        win_size: int | Sequence[int] = 11,
+        kernel_sigma: float | Sequence[float] = 1.5,
+        k1: float = 0.01,
+        k2: float = 0.03,
+        reduction: LossReduction | str = LossReduction.MEAN,
+    ):
+        """
+        Args:
+            spatial_dims: number of spatial dimensions of the input images.
+            data_range: value range of input images. (usually 1.0 or 255)
+            kernel_type: type of kernel, can be "gaussian" or "uniform".
+            win_size: window size of kernel
+            kernel_sigma: standard deviation for Gaussian kernel.
+            k1: stability constant used in the luminance denominator
+            k2: stability constant used in the contrast denominator
+            reduction: {``"none"``, ``"mean"``, ``"sum"``}
+                Specifies the reduction to apply to the output. Defaults to ``"mean"``.
+                - ``"none"``: no reduction will be applied.
+                - ``"mean"``: the sum of the output will be divided by the number of elements in the output.
+                - ``"sum"``: the output will be summed.
+
+        """
+        super().__init__(reduction=LossReduction(reduction).value)
+        self.spatial_dims = spatial_dims
+        self._data_range = data_range
+        self.kernel_type = kernel_type
+
+        if not isinstance(win_size, Sequence):
+            win_size = ensure_tuple_rep(win_size, spatial_dims)
+        self.kernel_size = win_size
+
+        if not isinstance(kernel_sigma, Sequence):
+            kernel_sigma = ensure_tuple_rep(kernel_sigma, spatial_dims)
+        self.kernel_sigma = kernel_sigma
+
+        self.k1 = k1
+        self.k2 = k2
+
+        self.ssim_metric = SSIMMetric(
+            spatial_dims=self.spatial_dims,
+            data_range=self._data_range,
+            kernel_type=self.kernel_type,
+            win_size=self.kernel_size,
+            kernel_sigma=self.kernel_sigma,
+            k1=self.k1,
+            k2=self.k2,
+        )
+
+    @property
+    def data_range(self) -> float:
+        return self._data_range
+
+    @data_range.setter
+    def data_range(self, value: float) -> None:
+        self._data_range = value
+        self.ssim_metric.data_range = value
+
+    def forward(self, input: torch.Tensor, target: torch.Tensor) -> torch.Tensor:
+        """
+        Args:
+            input: batch of predicted images with shape (batch_size, channels, spatial_dim1, spatial_dim2[, spatial_dim3])
+            target: batch of target images with shape (batch_size, channels, spatial_dim1, spatial_dim2[, spatial_dim3])
+
+        Returns:
+            1 minus the ssim index (recall this is meant to be a loss function)
+
+        Example:
+            .. code-block:: python
+
+                import torch
+
+                # 2D data
+                x = torch.ones([1,1,10,10])/2
+                y = torch.ones([1,1,10,10])/2
+                print(1-SSIMLoss(spatial_dims=2)(x,y))
+
+                # pseudo-3D data
+                x = torch.ones([1,5,10,10])/2  # 5 could represent number of slices
+                y = torch.ones([1,5,10,10])/2
+                print(1-SSIMLoss(spatial_dims=2)(x,y))
+
+                # 3D data
+                x = torch.ones([1,1,10,10,10])/2
+                y = torch.ones([1,1,10,10,10])/2
+                print(1-SSIMLoss(spatial_dims=3)(x,y))
+        """
+        ssim_value = self.ssim_metric._compute_tensor(input, target).view(-1, 1)
+        loss: torch.Tensor = 1 - ssim_value
+
+        if self.reduction == LossReduction.MEAN.value:
+            loss = torch.mean(loss)  # the batch average
+        elif self.reduction == LossReduction.SUM.value:
+            loss = torch.sum(loss)  # sum over the batch
+
+        return loss

source_code/SegMamba/monai/losses/sure_loss.py

@@ -0,0 +1,200 @@
+# Copyright (c) MONAI Consortium
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#     http://www.apache.org/licenses/LICENSE-2.0
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from __future__ import annotations
+
+from typing import Callable, Optional
+
+import torch
+import torch.nn as nn
+from torch.nn.modules.loss import _Loss
+
+
+def complex_diff_abs_loss(x: torch.Tensor, y: torch.Tensor) -> torch.Tensor:
+    """
+    First compute the difference in the complex domain,
+    then get the absolute value and take the mse
+
+    Args:
+        x, y - B, 2, H, W real valued tensors representing complex numbers
+                or  B,1,H,W complex valued tensors
+    Returns:
+        l2_loss - scalar
+    """
+    if not x.is_complex():
+        x = torch.view_as_complex(x.permute(0, 2, 3, 1).contiguous())
+    if not y.is_complex():
+        y = torch.view_as_complex(y.permute(0, 2, 3, 1).contiguous())
+
+    diff = torch.abs(x - y)
+    return nn.functional.mse_loss(diff, torch.zeros_like(diff), reduction="mean")
+
+
+def sure_loss_function(
+    operator: Callable,
+    x: torch.Tensor,
+    y_pseudo_gt: torch.Tensor,
+    y_ref: Optional[torch.Tensor] = None,
+    eps: Optional[float] = -1.0,
+    perturb_noise: Optional[torch.Tensor] = None,
+    complex_input: Optional[bool] = False,
+) -> torch.Tensor:
+    """
+    Args:
+        operator (function): The operator function that takes in an input
+        tensor x and returns an output tensor y. We will use this to compute
+        the divergence. More specifically, we will perturb the input x by a
+        small amount and compute the divergence between the perturbed output
+        and the reference output
+
+        x (torch.Tensor): The input tensor of shape (B, C, H, W) to the
+        operator.  For complex input, the shape is (B, 2, H, W) aka C=2 real.
+        For real input, the shape is (B, 1, H, W) real.
+
+        y_pseudo_gt (torch.Tensor): The pseudo ground truth tensor of shape
+        (B, C, H, W) used to compute the L2 loss.  For complex input, the shape is
+        (B, 2, H, W) aka C=2 real.  For real input, the shape is (B, 1, H, W)
+        real.
+
+        y_ref (torch.Tensor, optional): The reference output tensor of shape
+        (B, C, H, W) used to compute the divergence. Defaults to None.  For
+        complex input, the shape is (B, 2, H, W) aka C=2 real.  For real input,
+        the shape is (B, 1, H, W) real.
+
+        eps (float, optional): The perturbation scalar. Set to -1 to set it
+        automatically estimated based on y_pseudo_gtk
+
+        perturb_noise (torch.Tensor, optional): The noise vector of shape (B, C, H, W).
+        Defaults to None.  For complex input, the shape is (B, 2, H, W) aka C=2 real.
+        For real input, the shape is (B, 1, H, W) real.
+
+        complex_input(bool, optional): Whether the input is complex or not.
+        Defaults to False.
+
+    Returns:
+        sure_loss (torch.Tensor): The SURE loss scalar.
+    """
+    # perturb input
+    if perturb_noise is None:
+        perturb_noise = torch.randn_like(x)
+    if eps == -1.0:
+        eps = float(torch.abs(y_pseudo_gt.max())) / 1000
+    # get y_ref if not provided
+    if y_ref is None:
+        y_ref = operator(x)
+
+    # get perturbed output
+    x_perturbed = x + eps * perturb_noise
+    y_perturbed = operator(x_perturbed)
+    # divergence
+    divergence = torch.sum(1.0 / eps * torch.matmul(perturb_noise.permute(0, 1, 3, 2), y_perturbed - y_ref))  # type: ignore
+    # l2 loss between y_ref, y_pseudo_gt
+    if complex_input:
+        l2_loss = complex_diff_abs_loss(y_ref, y_pseudo_gt)
+    else:
+        # real input
+        l2_loss = nn.functional.mse_loss(y_ref, y_pseudo_gt, reduction="mean")
+
+    # sure loss
+    sure_loss = l2_loss * divergence / (x.shape[0] * x.shape[2] * x.shape[3])
+    return sure_loss
+
+
+class SURELoss(_Loss):
+    """
+    Calculate the Stein's Unbiased Risk Estimator (SURE) loss for a given operator.
+
+    This is a differentiable loss function that can be used to train/guide an
+    operator (e.g. neural network), where the pseudo ground truth is available
+    but the reference ground truth is not. For example, in the MRI
+    reconstruction, the pseudo ground truth is the zero-filled reconstruction
+    and the reference ground truth is the fully sampled reconstruction.  Often,
+    the reference ground truth is not available due to the lack of fully sampled
+    data.
+
+    The original SURE loss is proposed in [1]. The SURE loss used for guiding
+    the diffusion model based MRI reconstruction is proposed in [2].
+
+    Reference
+
+    [1] Stein, C.M.: Estimation of the mean of a multivariate normal distribution. Annals of Statistics
+
+    [2] B. Ozturkler et al. SMRD: SURE-based Robust MRI Reconstruction with Diffusion Models.
+    (https://arxiv.org/pdf/2310.01799.pdf)
+    """
+
+    def __init__(self, perturb_noise: Optional[torch.Tensor] = None, eps: Optional[float] = None) -> None:
+        """
+        Args:
+            perturb_noise (torch.Tensor, optional): The noise vector of shape
+            (B, C, H, W). Defaults to None.  For complex input, the shape is (B, 2, H, W) aka C=2 real.
+            For real input, the shape is (B, 1, H, W) real.
+
+            eps (float, optional): The perturbation scalar. Defaults to None.
+        """
+        super().__init__()
+        self.perturb_noise = perturb_noise
+        self.eps = eps
+
+    def forward(
+        self,
+        operator: Callable,
+        x: torch.Tensor,
+        y_pseudo_gt: torch.Tensor,
+        y_ref: Optional[torch.Tensor] = None,
+        complex_input: Optional[bool] = False,
+    ) -> torch.Tensor:
+        """
+        Args:
+            operator (function): The operator function that takes in an input
+            tensor x and returns an output tensor y. We will use this to compute
+            the divergence. More specifically, we will perturb the input x by a
+            small amount and compute the divergence between the perturbed output
+            and the reference output
+
+            x (torch.Tensor): The input tensor of shape (B, C, H, W) to the
+            operator. C=1 or 2: For complex input, the shape is (B, 2, H, W) aka
+            C=2 real.  For real input, the shape is (B, 1, H, W) real.
+
+            y_pseudo_gt (torch.Tensor): The pseudo ground truth tensor of shape
+            (B, C, H, W) used to compute the L2 loss. C=1 or 2: For complex
+            input, the shape is (B, 2, H, W) aka C=2 real.  For real input, the
+            shape is (B, 1, H, W) real.
+
+            y_ref (torch.Tensor, optional): The reference output tensor of the
+            same shape as y_pseudo_gt
+
+        Returns:
+            sure_loss (torch.Tensor): The SURE loss scalar.
+        """
+
+        # check inputs shapes
+        if x.dim() != 4:
+            raise ValueError(f"Input tensor x should be 4D, got {x.dim()}.")
+        if y_pseudo_gt.dim() != 4:
+            raise ValueError(f"Input tensor y_pseudo_gt should be 4D, but got {y_pseudo_gt.dim()}.")
+        if y_ref is not None and y_ref.dim() != 4:
+            raise ValueError(f"Input tensor y_ref should be 4D, but got {y_ref.dim()}.")
+        if x.shape != y_pseudo_gt.shape:
+            raise ValueError(
+                f"Input tensor x and y_pseudo_gt should have the same shape, but got x shape {x.shape}, "
+                f"y_pseudo_gt shape {y_pseudo_gt.shape}."
+            )
+        if y_ref is not None and y_pseudo_gt.shape != y_ref.shape:
+            raise ValueError(
+                f"Input tensor y_pseudo_gt and y_ref should have the same shape, but got y_pseudo_gt shape {y_pseudo_gt.shape}, "
+                f"y_ref shape {y_ref.shape}."
+            )
+
+        # compute loss
+        loss = sure_loss_function(operator, x, y_pseudo_gt, y_ref, self.eps, self.perturb_noise, complex_input)
+
+        return loss

source_code/SegMamba/monai/metrics/confusion_matrix.py

@@ -0,0 +1,322 @@
+# Copyright (c) MONAI Consortium
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#     http://www.apache.org/licenses/LICENSE-2.0
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from __future__ import annotations
+
+import warnings
+from collections.abc import Sequence
+
+import torch
+
+from monai.metrics.utils import do_metric_reduction, ignore_background
+from monai.utils import MetricReduction, ensure_tuple
+
+from .metric import CumulativeIterationMetric
+
+
+class ConfusionMatrixMetric(CumulativeIterationMetric):
+    """
+    Compute confusion matrix related metrics. This function supports to calculate all metrics mentioned in:
+    `Confusion matrix <https://en.wikipedia.org/wiki/Confusion_matrix>`_.
+    It can support both multi-classes and multi-labels classification and segmentation tasks.
+    `y_preds` is expected to have binarized predictions and `y` should be in one-hot format. You can use suitable transforms
+    in ``monai.transforms.post`` first to achieve binarized values.
+    The `include_background` parameter can be set to ``False`` for an instance to exclude
+    the first category (channel index 0) which is by convention assumed to be background. If the non-background
+    segmentations are small compared to the total image size they can get overwhelmed by the signal from the
+    background.
+
+    Example of the typical execution steps of this metric class follows :py:class:`monai.metrics.metric.Cumulative`.
+
+    Args:
+        include_background: whether to include metric computation on the first channel of
+            the predicted output. Defaults to True.
+        metric_name: [``"sensitivity"``, ``"specificity"``, ``"precision"``, ``"negative predictive value"``,
+            ``"miss rate"``, ``"fall out"``, ``"false discovery rate"``, ``"false omission rate"``,
+            ``"prevalence threshold"``, ``"threat score"``, ``"accuracy"``, ``"balanced accuracy"``,
+            ``"f1 score"``, ``"matthews correlation coefficient"``, ``"fowlkes mallows index"``,
+            ``"informedness"``, ``"markedness"``]
+            Some of the metrics have multiple aliases (as shown in the wikipedia page aforementioned),
+            and you can also input those names instead.
+            Except for input only one metric, multiple metrics are also supported via input a sequence of metric names, such as
+            ("sensitivity", "precision", "recall"), if ``compute_sample`` is ``True``, multiple ``f`` and ``not_nans`` will be
+            returned with the same order as input names when calling the class.
+        compute_sample: when reducing, if ``True``, each sample's metric will be computed based on each confusion matrix first.
+            if ``False``, compute reduction on the confusion matrices first, defaults to ``False``.
+        reduction: define mode of reduction to the metrics, will only apply reduction on `not-nan` values,
+            available reduction modes: {``"none"``, ``"mean"``, ``"sum"``, ``"mean_batch"``, ``"sum_batch"``,
+            ``"mean_channel"``, ``"sum_channel"``}, default to ``"mean"``. if "none", will not do reduction.
+        get_not_nans: whether to return the `not_nans` count, if True, aggregate() returns [(metric, not_nans), ...]. If False,
+            aggregate() returns [metric, ...].
+            Here `not_nans` count the number of not nans for True Positive, False Positive, True Negative and False Negative.
+            Its shape depends on the shape of the metric, and it has one more dimension with size 4. For example, if the shape
+            of the metric is [3, 3], `not_nans` has the shape [3, 3, 4].
+
+    """
+
+    def __init__(
+        self,
+        include_background: bool = True,
+        metric_name: Sequence[str] | str = "hit_rate",
+        compute_sample: bool = False,
+        reduction: MetricReduction | str = MetricReduction.MEAN,
+        get_not_nans: bool = False,
+    ) -> None:
+        super().__init__()
+        self.include_background = include_background
+        self.metric_name = ensure_tuple(metric_name)
+        self.compute_sample = compute_sample
+        self.reduction = reduction
+        self.get_not_nans = get_not_nans
+
+    def _compute_tensor(self, y_pred: torch.Tensor, y: torch.Tensor) -> torch.Tensor:  # type: ignore[override]
+        """
+        Args:
+            y_pred: input data to compute. It must be one-hot format and first dim is batch.
+                The values should be binarized.
+            y: ground truth to compute the metric. It must be one-hot format and first dim is batch.
+                The values should be binarized.
+        Raises:
+            ValueError: when `y_pred` has less than two dimensions.
+        """
+        # check dimension
+        dims = y_pred.ndimension()
+        if dims < 2:
+            raise ValueError("y_pred should have at least two dimensions.")
+        if dims == 2 or (dims == 3 and y_pred.shape[-1] == 1):
+            if self.compute_sample:
+                warnings.warn("As for classification task, compute_sample should be False.")
+                self.compute_sample = False
+
+        return get_confusion_matrix(y_pred=y_pred, y=y, include_background=self.include_background)
+
+    def aggregate(
+        self, compute_sample: bool = False, reduction: MetricReduction | str | None = None
+    ) -> list[torch.Tensor | tuple[torch.Tensor, torch.Tensor]]:
+        """
+        Execute reduction for the confusion matrix values.
+
+        Args:
+            compute_sample: when reducing, if ``True``, each sample's metric will be computed based on each confusion matrix first.
+                if ``False``, compute reduction on the confusion matrices first, defaults to ``False``.
+            reduction: define mode of reduction to the metrics, will only apply reduction on `not-nan` values,
+                available reduction modes: {``"none"``, ``"mean"``, ``"sum"``, ``"mean_batch"``, ``"sum_batch"``,
+                ``"mean_channel"``, ``"sum_channel"``}, default to `self.reduction`. if "none", will not do reduction.
+
+        """
+        data = self.get_buffer()
+        if not isinstance(data, torch.Tensor):
+            raise ValueError("the data to aggregate must be PyTorch Tensor.")
+
+        results: list[torch.Tensor | tuple[torch.Tensor, torch.Tensor]] = []
+        for metric_name in self.metric_name:
+            if compute_sample or self.compute_sample:
+                sub_confusion_matrix = compute_confusion_matrix_metric(metric_name, data)
+                f, not_nans = do_metric_reduction(sub_confusion_matrix, reduction or self.reduction)
+            else:
+                f, not_nans = do_metric_reduction(data, reduction or self.reduction)
+                f = compute_confusion_matrix_metric(metric_name, f)
+            if self.get_not_nans:
+                results.append((f, not_nans))
+            else:
+                results.append(f)
+        return results
+
+
+def get_confusion_matrix(y_pred: torch.Tensor, y: torch.Tensor, include_background: bool = True) -> torch.Tensor:
+    """
+    Compute confusion matrix. A tensor with the shape [BC4] will be returned. Where, the third dimension
+    represents the number of true positive, false positive, true negative and false negative values for
+    each channel of each sample within the input batch. Where, B equals to the batch size and C equals to
+    the number of classes that need to be computed.
+
+    Args:
+        y_pred: input data to compute. It must be one-hot format and first dim is batch.
+            The values should be binarized.
+        y: ground truth to compute the metric. It must be one-hot format and first dim is batch.
+            The values should be binarized.
+        include_background: whether to include metric computation on the first channel of
+            the predicted output. Defaults to True.
+
+    Raises:
+        ValueError: when `y_pred` and `y` have different shapes.
+    """
+
+    if not include_background:
+        y_pred, y = ignore_background(y_pred=y_pred, y=y)
+
+    if y.shape != y_pred.shape:
+        raise ValueError(f"y_pred and y should have same shapes, got {y_pred.shape} and {y.shape}.")
+
+    # get confusion matrix related metric
+    batch_size, n_class = y_pred.shape[:2]
+    # convert to [BNS], where S is the number of pixels for one sample.
+    # As for classification tasks, S equals to 1.
+    y_pred = y_pred.reshape(batch_size, n_class, -1)
+    y = y.reshape(batch_size, n_class, -1)
+    tp = (y_pred + y) == 2
+    tn = (y_pred + y) == 0
+
+    tp = tp.sum(dim=[2]).float()
+    tn = tn.sum(dim=[2]).float()
+    p = y.sum(dim=[2]).float()
+    n = y.shape[-1] - p
+
+    fn = p - tp
+    fp = n - tn
+
+    return torch.stack([tp, fp, tn, fn], dim=-1)
+
+
+def compute_confusion_matrix_metric(metric_name: str, confusion_matrix: torch.Tensor) -> torch.Tensor:
+    """
+    This function is used to compute confusion matrix related metric.
+
+    Args:
+        metric_name: [``"sensitivity"``, ``"specificity"``, ``"precision"``, ``"negative predictive value"``,
+            ``"miss rate"``, ``"fall out"``, ``"false discovery rate"``, ``"false omission rate"``,
+            ``"prevalence threshold"``, ``"threat score"``, ``"accuracy"``, ``"balanced accuracy"``,
+            ``"f1 score"``, ``"matthews correlation coefficient"``, ``"fowlkes mallows index"``,
+            ``"informedness"``, ``"markedness"``]
+            Some of the metrics have multiple aliases (as shown in the wikipedia page aforementioned),
+            and you can also input those names instead.
+        confusion_matrix: Please see the doc string of the function ``get_confusion_matrix`` for more details.
+
+    Raises:
+        ValueError: when the size of the last dimension of confusion_matrix is not 4.
+        NotImplementedError: when specify a not implemented metric_name.
+
+    """
+
+    metric = check_confusion_matrix_metric_name(metric_name)
+
+    input_dim = confusion_matrix.ndimension()
+    if input_dim == 1:
+        confusion_matrix = confusion_matrix.unsqueeze(dim=0)
+    if confusion_matrix.shape[-1] != 4:
+        raise ValueError("the size of the last dimension of confusion_matrix should be 4.")
+
+    tp = confusion_matrix[..., 0]
+    fp = confusion_matrix[..., 1]
+    tn = confusion_matrix[..., 2]
+    fn = confusion_matrix[..., 3]
+    p = tp + fn
+    n = fp + tn
+    # calculate metric
+    numerator: torch.Tensor
+    denominator: torch.Tensor | float
+    nan_tensor = torch.tensor(float("nan"), device=confusion_matrix.device)
+    if metric == "tpr":
+        numerator, denominator = tp, p
+    elif metric == "tnr":
+        numerator, denominator = tn, n
+    elif metric == "ppv":
+        numerator, denominator = tp, (tp + fp)
+    elif metric == "npv":
+        numerator, denominator = tn, (tn + fn)
+    elif metric == "fnr":
+        numerator, denominator = fn, p
+    elif metric == "fpr":
+        numerator, denominator = fp, n
+    elif metric == "fdr":
+        numerator, denominator = fp, (fp + tp)
+    elif metric == "for":
+        numerator, denominator = fn, (fn + tn)
+    elif metric == "pt":
+        tpr = torch.where(p > 0, tp / p, nan_tensor)
+        tnr = torch.where(n > 0, tn / n, nan_tensor)
+        numerator = torch.sqrt(tpr * (1.0 - tnr)) + tnr - 1.0
+        denominator = tpr + tnr - 1.0
+    elif metric == "ts":
+        numerator, denominator = tp, (tp + fn + fp)
+    elif metric == "acc":
+        numerator, denominator = (tp + tn), (p + n)
+    elif metric == "ba":
+        tpr = torch.where(p > 0, tp / p, nan_tensor)
+        tnr = torch.where(n > 0, tn / n, nan_tensor)
+        numerator, denominator = (tpr + tnr), 2.0
+    elif metric == "f1":
+        numerator, denominator = tp * 2.0, (tp * 2.0 + fn + fp)
+    elif metric == "mcc":
+        numerator = tp * tn - fp * fn
+        denominator = torch.sqrt((tp + fp) * (tp + fn) * (tn + fp) * (tn + fn))
+    elif metric == "fm":
+        tpr = torch.where(p > 0, tp / p, nan_tensor)
+        ppv = torch.where((tp + fp) > 0, tp / (tp + fp), nan_tensor)
+        numerator = torch.sqrt(ppv * tpr)
+        denominator = 1.0
+    elif metric == "bm":
+        tpr = torch.where(p > 0, tp / p, nan_tensor)
+        tnr = torch.where(n > 0, tn / n, nan_tensor)
+        numerator = tpr + tnr - 1.0
+        denominator = 1.0
+    elif metric == "mk":
+        ppv = torch.where((tp + fp) > 0, tp / (tp + fp), nan_tensor)
+        npv = torch.where((tn + fn) > 0, tn / (tn + fn), nan_tensor)
+        numerator = ppv + npv - 1.0
+        denominator = 1.0
+    else:
+        raise NotImplementedError("the metric is not implemented.")
+
+    if isinstance(denominator, torch.Tensor):
+        return torch.where(denominator != 0, numerator / denominator, nan_tensor)
+    return numerator / denominator
+
+
+def check_confusion_matrix_metric_name(metric_name: str) -> str:
+    """
+    There are many metrics related to confusion matrix, and some of the metrics have
+    more than one names. In addition, some of the names are very long.
+    Therefore, this function is used to check and simplify the name.
+
+    Returns:
+        Simplified metric name.
+
+    Raises:
+        NotImplementedError: when the metric is not implemented.
+    """
+    metric_name = metric_name.replace(" ", "_")
+    metric_name = metric_name.lower()
+    if metric_name in ["sensitivity", "recall", "hit_rate", "true_positive_rate", "tpr"]:
+        return "tpr"
+    if metric_name in ["specificity", "selectivity", "true_negative_rate", "tnr"]:
+        return "tnr"
+    if metric_name in ["precision", "positive_predictive_value", "ppv"]:
+        return "ppv"
+    if metric_name in ["negative_predictive_value", "npv"]:
+        return "npv"
+    if metric_name in ["miss_rate", "false_negative_rate", "fnr"]:
+        return "fnr"
+    if metric_name in ["fall_out", "false_positive_rate", "fpr"]:
+        return "fpr"
+    if metric_name in ["false_discovery_rate", "fdr"]:
+        return "fdr"
+    if metric_name in ["false_omission_rate", "for"]:
+        return "for"
+    if metric_name in ["prevalence_threshold", "pt"]:
+        return "pt"
+    if metric_name in ["threat_score", "critical_success_index", "ts", "csi"]:
+        return "ts"
+    if metric_name in ["accuracy", "acc"]:
+        return "acc"
+    if metric_name in ["balanced_accuracy", "ba"]:
+        return "ba"
+    if metric_name in ["f1_score", "f1"]:
+        return "f1"
+    if metric_name in ["matthews_correlation_coefficient", "mcc"]:
+        return "mcc"
+    if metric_name in ["fowlkes_mallows_index", "fm"]:
+        return "fm"
+    if metric_name in ["informedness", "bookmaker_informedness", "bm", "youden_index", "youden"]:
+        return "bm"
+    if metric_name in ["markedness", "deltap", "mk"]:
+        return "mk"
+    raise NotImplementedError("the metric is not implemented.")

source_code/SegMamba/monai/metrics/cumulative_average.py

@@ -0,0 +1,160 @@
+# Copyright (c) MONAI Consortium
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#     http://www.apache.org/licenses/LICENSE-2.0
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from __future__ import annotations
+
+import warnings
+from typing import Any
+
+import torch
+import torch.distributed as dist
+
+from monai.config import NdarrayOrTensor
+
+
+class CumulativeAverage:
+    """
+    A utility class to keep track of average values. For example during training/validation loop,
+    we need to accumulate the per-batch metrics and calculate the final average value for the whole dataset.
+    When training in multi-gpu environment, with DistributedDataParallel, it will average across the processes.
+
+    Example:
+
+    .. code-block:: python
+
+        from monai.metrics import CumulativeAverage
+
+        run_avg = CumulativeAverage()
+        batch_size = 8
+        for i in range(len(train_set)):
+            ...
+            val = calc_metric(x,y) #some metric value
+            run_avg.append(val, count=batch_size)
+
+        val_avg = run_avg.aggregate() #average value
+
+    """
+
+    def __init__(self) -> None:
+        self.reset()
+
+    def reset(self) -> None:
+        """
+        Reset all  stats
+        """
+        self.val: torch.Tensor = None  # type: ignore
+        self.sum = torch.tensor(0, dtype=torch.float)
+        self.count = torch.tensor(0, dtype=torch.float)
+        self.is_distributed = dist.is_available() and dist.is_initialized()
+
+    def get_current(self, to_numpy: bool = True) -> NdarrayOrTensor:
+        """
+        returns the most recent value (averaged across processes)
+
+        Args:
+            to_numpy: whether to convert to numpy array. Defaults to True
+        """
+        if self.val is None:
+            return 0
+
+        val = self.val.clone()
+        val[~torch.isfinite(val)] = 0
+
+        if self.is_distributed:
+            val = val / dist.get_world_size()
+            dist.all_reduce(val)
+
+        if to_numpy:
+            val = val.cpu().numpy()
+
+        return val
+
+    def aggregate(self, to_numpy: bool = True) -> NdarrayOrTensor:
+        """
+        returns the total average value (averaged across processes)
+
+        Args:
+            to_numpy: whether to convert to numpy array. Defaults to True
+        """
+        if self.val is None:
+            return 0
+
+        sum = self.sum
+        count = self.count
+
+        if self.is_distributed:
+            sum = sum.to(self.val, copy=True)
+            count = count.to(self.val, copy=True)
+            dist.all_reduce(sum)
+            dist.all_reduce(count)
+
+        val = torch.where(count > 0, sum / count, sum)
+
+        if to_numpy:
+            val = val.cpu().numpy()
+        return val
+
+    def append(self, val: Any, count: Any | None = 1) -> None:
+        """
+        Append with a new value, and an optional count. Any data type is supported that is convertable
+            with torch.as_tensor() e.g. number, list, numpy array, or Tensor.
+
+        Args:
+            val: value (e.g. number, list, numpy array or Tensor) to keep track of
+            count: count (e.g. number, list, numpy array or Tensor), to update the contribution count
+
+        For example:
+            # a simple constant tracking
+            avg = CumulativeAverage()
+            avg.append(0.6)
+            avg.append(0.8)
+            print(avg.aggregate()) #prints 0.7
+
+            # an array tracking, e.g. metrics from 3 classes
+            avg= CumulativeAverage()
+            avg.append([0.2, 0.4, 0.4])
+            avg.append([0.4, 0.6, 0.4])
+            print(avg.aggregate()) #prints [0.3, 0.5. 0.4]
+
+            # different contributions / counts
+            avg= CumulativeAverage()
+            avg.append(1, count=4) #avg metric 1 coming from a batch of 4
+            avg.append(2, count=6) #avg metric 2 coming from a batch of 6
+            print(avg.aggregate()) #prints 1.6 == (1*4 +2*6)/(4+6)
+
+            # different contributions / counts
+            avg= CumulativeAverage()
+            avg.append([0.5, 0.5, 0], count=[1, 1, 0]) # last elements count is zero to ignore it
+            avg.append([0.5, 0.5, 0.5], count=[1, 1, 1]) #
+            print(avg.aggregate()) #prints [0.5, 0.5, 0,5] == ([0.5, 0.5, 0] + [0.5, 0.5, 0.5]) / ([1, 1, 0] + [1, 1, 1])
+
+        """
+        self.val = torch.as_tensor(val, dtype=torch.float)
+        if self.val.requires_grad:
+            self.val = self.val.detach().clone()
+
+        count = torch.as_tensor(count, dtype=torch.float, device="cpu")
+        if count.ndim > 0 and count.shape != self.val.shape:
+            raise ValueError(
+                f"Count shape must match val shape, unless count is a single number: {count} val {self.val.cpu()}"
+            )
+
+        val = count * self.val.cpu()
+
+        # account for possible non-finite numbers in val and replace them with 0s
+        nfin = torch.isfinite(val)
+        if not torch.all(nfin):
+            warnings.warn(f"non-finite inputs received: val: {val}, count: {count}")
+            count = torch.where(nfin, count, torch.zeros_like(count))
+            val = torch.where(nfin, val, torch.zeros_like(val))
+
+        self.count = self.count + count
+        self.sum = self.sum + val

source_code/SegMamba/monai/metrics/f_beta_score.py

@@ -0,0 +1,107 @@
+# Copyright (c) MONAI Consortium
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#     http://www.apache.org/licenses/LICENSE-2.0
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from __future__ import annotations
+
+from collections.abc import Sequence
+
+import torch
+
+from monai.metrics.utils import do_metric_reduction, ignore_background
+from monai.utils import MetricReduction
+
+from .metric import CumulativeIterationMetric
+
+
+class FBetaScore(CumulativeIterationMetric):
+
+    def __init__(
+        self,
+        beta: float = 1.0,
+        include_background: bool = True,
+        reduction: MetricReduction | str = MetricReduction.MEAN,
+        get_not_nans: bool = False,
+    ) -> None:
+        super().__init__()
+        self.beta = beta
+        self.include_background = include_background
+        self.reduction = reduction
+        self.get_not_nans = get_not_nans
+
+    def _compute_tensor(self, y_pred: torch.Tensor, y: torch.Tensor) -> torch.Tensor:  # type: ignore[override]
+        if y_pred.ndimension() < 2:
+            raise ValueError("y_pred should have at least two dimensions.")
+
+        return get_f_beta_score(y_pred=y_pred, y=y, include_background=self.include_background)
+
+    def aggregate(
+        self, compute_sample: bool = False, reduction: MetricReduction | str | None = None
+    ) -> Sequence[torch.Tensor | tuple[torch.Tensor, torch.Tensor]]:
+        data = self.get_buffer()
+        if not isinstance(data, torch.Tensor):
+            raise ValueError("the data to aggregate must be PyTorch Tensor.")
+
+        results: list[torch.Tensor | tuple[torch.Tensor, torch.Tensor]] = []
+        f, not_nans = do_metric_reduction(data, reduction or self.reduction)
+        f = compute_f_beta_score(f, self.beta)
+        if self.get_not_nans:
+            results.append((f, not_nans))
+        else:
+            results.append(f)
+
+        return results
+
+
+def get_f_beta_score(y_pred: torch.Tensor, y: torch.Tensor, include_background: bool = True) -> torch.Tensor:
+    if not include_background:
+        y_pred, y = ignore_background(y_pred=y_pred, y=y)
+
+    if y.shape != y_pred.shape:
+        raise ValueError(f"y_pred and y should have same shapes, got {y_pred.shape} and {y.shape}.")
+
+    # get confusion matrix related metric
+    batch_size, n_class = y_pred.shape[:2]
+    # convert to [BNS], where S is the number of pixels for one sample.
+    # As for classification tasks, S equals to 1.
+    y_pred = y_pred.view(batch_size, n_class, -1)
+    y = y.view(batch_size, n_class, -1)
+    tp = (y_pred + y) == 2
+    tn = (y_pred + y) == 0
+
+    tp = tp.sum(dim=[2]).float()
+    tn = tn.sum(dim=[2]).float()
+    p = y.sum(dim=[2]).float()
+    n = y.shape[-1] - p
+
+    fn = p - tp
+    fp = n - tn
+
+    return torch.stack([tp, fp, tn, fn], dim=-1)
+
+
+def compute_f_beta_score(confusion_matrix: torch.Tensor, beta: float) -> torch.Tensor:
+    input_dim = confusion_matrix.ndimension()
+    if input_dim == 1:
+        confusion_matrix = confusion_matrix.unsqueeze(dim=0)
+    if confusion_matrix.shape[-1] != 4:
+        raise ValueError("the size of the last dimension of confusion_matrix should be 4.")
+
+    tp = confusion_matrix[..., 0]
+    fp = confusion_matrix[..., 1]
+    # tn = confusion_matrix[..., 2]
+    fn = confusion_matrix[..., 3]
+
+    nan_tensor = torch.tensor(float("nan"), device=confusion_matrix.device)
+    numerator, denominator = (1.0 + beta**2) * tp, ((1.0 + beta**2) * tp + beta**2 * fn + fp)
+
+    if isinstance(denominator, torch.Tensor):
+        return torch.where(denominator != 0, numerator / denominator, nan_tensor)
+    return numerator / denominator

source_code/SegMamba/monai/metrics/fid.py

@@ -0,0 +1,110 @@
+# Copyright (c) MONAI Consortium
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#     http://www.apache.org/licenses/LICENSE-2.0
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from __future__ import annotations
+
+import numpy as np
+import torch
+
+from monai.metrics.metric import Metric
+from monai.utils import optional_import
+
+scipy, _ = optional_import("scipy")
+
+
+class FIDMetric(Metric):
+    """
+    Frechet Inception Distance (FID). The FID calculates the distance between two distributions of feature vectors.
+    Based on: Heusel M. et al. "Gans trained by a two time-scale update rule converge to a local nash equilibrium."
+    https://arxiv.org/abs/1706.08500. The inputs for this metric should be two groups of feature vectors (with format
+    (number images, number of features)) extracted from a pretrained network.
+
+    Originally, it was proposed to use the activations of the pool_3 layer of an Inception v3 pretrained with Imagenet.
+    However, others networks pretrained on medical datasets can be used as well (for example, RadImageNwt for 2D and
+    MedicalNet for 3D images). If the chosen model output is not a scalar, a global spatia average pooling should be
+    used.
+    """
+
+    def __call__(self, y_pred: torch.Tensor, y: torch.Tensor) -> torch.Tensor:
+        return get_fid_score(y_pred, y)
+
+
+def get_fid_score(y_pred: torch.Tensor, y: torch.Tensor) -> torch.Tensor:
+    """Computes the FID score metric on a batch of feature vectors.
+
+    Args:
+        y_pred: feature vectors extracted from a pretrained network run on generated images.
+        y: feature vectors extracted from a pretrained network run on images from the real data distribution.
+    """
+    y = y.double()
+    y_pred = y_pred.double()
+
+    if y.ndimension() > 2:
+        raise ValueError("Inputs should have (number images, number of features) shape.")
+
+    mu_y_pred = torch.mean(y_pred, dim=0)
+    sigma_y_pred = _cov(y_pred, rowvar=False)
+    mu_y = torch.mean(y, dim=0)
+    sigma_y = _cov(y, rowvar=False)
+
+    return compute_frechet_distance(mu_y_pred, sigma_y_pred, mu_y, sigma_y)
+
+
+def _cov(input_data: torch.Tensor, rowvar: bool = True) -> torch.Tensor:
+    """
+    Estimate a covariance matrix of the variables.
+
+    Args:
+        input_data: A 1-D or 2-D array containing multiple variables and observations. Each row of `m` represents a variable,
+            and each column a single observation of all those variables.
+        rowvar: If rowvar is True (default), then each row represents a variable, with observations in the columns.
+            Otherwise, the relationship is transposed: each column represents a variable, while the rows contain
+            observations.
+    """
+    if input_data.dim() < 2:
+        input_data = input_data.view(1, -1)
+
+    if not rowvar and input_data.size(0) != 1:
+        input_data = input_data.t()
+
+    factor = 1.0 / (input_data.size(1) - 1)
+    input_data = input_data - torch.mean(input_data, dim=1, keepdim=True)
+    return factor * input_data.matmul(input_data.t()).squeeze()
+
+
+def _sqrtm(input_data: torch.Tensor) -> torch.Tensor:
+    """Compute the square root of a matrix."""
+    scipy_res, _ = scipy.linalg.sqrtm(input_data.detach().cpu().numpy().astype(np.float_), disp=False)
+    return torch.from_numpy(scipy_res)
+
+
+def compute_frechet_distance(
+    mu_x: torch.Tensor, sigma_x: torch.Tensor, mu_y: torch.Tensor, sigma_y: torch.Tensor, epsilon: float = 1e-6
+) -> torch.Tensor:
+    """The Frechet distance between multivariate normal distributions."""
+    diff = mu_x - mu_y
+
+    covmean = _sqrtm(sigma_x.mm(sigma_y))
+
+    # Product might be almost singular
+    if not torch.isfinite(covmean).all():
+        print(f"FID calculation produces singular product; adding {epsilon} to diagonal of covariance estimates")
+        offset = torch.eye(sigma_x.size(0), device=mu_x.device, dtype=mu_x.dtype) * epsilon
+        covmean = _sqrtm((sigma_x + offset).mm(sigma_y + offset))
+
+    # Numerical error might give slight imaginary component
+    if torch.is_complex(covmean):
+        if not torch.allclose(torch.diagonal(covmean).imag, torch.tensor(0, dtype=torch.double), atol=1e-3):
+            raise ValueError(f"Imaginary component {torch.max(torch.abs(covmean.imag))} too high.")
+        covmean = covmean.real
+
+    tr_covmean = torch.trace(covmean)
+    return diff.dot(diff) + torch.trace(sigma_x) + torch.trace(sigma_y) - 2 * tr_covmean

source_code/SegMamba/monai/metrics/froc.py

@@ -0,0 +1,175 @@
+# Copyright (c) MONAI Consortium
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#     http://www.apache.org/licenses/LICENSE-2.0
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from __future__ import annotations
+
+from typing import Any, cast
+
+import numpy as np
+import torch
+
+from monai.config import NdarrayOrTensor
+
+
+def compute_fp_tp_probs_nd(
+    probs: NdarrayOrTensor,
+    coords: NdarrayOrTensor,
+    evaluation_mask: NdarrayOrTensor,
+    labels_to_exclude: list | None = None,
+) -> tuple[NdarrayOrTensor, NdarrayOrTensor, int]:
+    """
+    This function is modified from the official evaluation code of
+    `CAMELYON 16 Challenge <https://camelyon16.grand-challenge.org/>`_, and used to distinguish
+    true positive and false positive predictions. A true positive prediction is defined when
+    the detection point is within the annotated ground truth region.
+
+    Args:
+        probs: an array with shape (n,) that represents the probabilities of the detections.
+            Where, n is the number of predicted detections.
+        coords: an array with shape (n, n_dim) that represents the coordinates of the detections.
+            The dimensions must be in the same order as in `evaluation_mask`.
+        evaluation_mask: the ground truth mask for evaluation.
+        labels_to_exclude: labels in this list will not be counted for metric calculation.
+
+    Returns:
+        fp_probs: an array that contains the probabilities of the false positive detections.
+        tp_probs: an array that contains the probabilities of the True positive detections.
+        num_targets: the total number of targets (excluding `labels_to_exclude`) for all images under evaluation.
+
+    """
+    if not (len(probs) == len(coords)):
+        raise ValueError(f"the length of probs {probs.shape}, should be the same as of coords {coords.shape}.")
+    if not (len(coords.shape) > 1 and coords.shape[1] == len(evaluation_mask.shape)):
+        raise ValueError(
+            f"coords {coords.shape} need to represent the same number of dimensions as mask {evaluation_mask.shape}."
+        )
+
+    if isinstance(probs, torch.Tensor):
+        probs = probs.detach().cpu().numpy()
+    if isinstance(coords, torch.Tensor):
+        coords = coords.detach().cpu().numpy()
+    if isinstance(evaluation_mask, torch.Tensor):
+        evaluation_mask = evaluation_mask.detach().cpu().numpy()
+
+    if labels_to_exclude is None:
+        labels_to_exclude = []
+
+    max_label = np.max(evaluation_mask)
+    tp_probs = np.zeros((max_label,), dtype=np.float32)
+
+    hittedlabel = evaluation_mask[tuple(coords.T)]
+    fp_probs = probs[np.where(hittedlabel == 0)]
+    for i in range(1, max_label + 1):
+        if i not in labels_to_exclude and i in hittedlabel:
+            tp_probs[i - 1] = probs[np.where(hittedlabel == i)].max()
+
+    num_targets = max_label - len(labels_to_exclude)
+    return fp_probs, tp_probs, cast(int, num_targets)
+
+
+def compute_fp_tp_probs(
+    probs: NdarrayOrTensor,
+    y_coord: NdarrayOrTensor,
+    x_coord: NdarrayOrTensor,
+    evaluation_mask: NdarrayOrTensor,
+    labels_to_exclude: list | None = None,
+    resolution_level: int = 0,
+) -> tuple[NdarrayOrTensor, NdarrayOrTensor, int]:
+    """
+    This function is modified from the official evaluation code of
+    `CAMELYON 16 Challenge <https://camelyon16.grand-challenge.org/>`_, and used to distinguish
+    true positive and false positive predictions. A true positive prediction is defined when
+    the detection point is within the annotated ground truth region.
+
+    Args:
+        probs: an array with shape (n,) that represents the probabilities of the detections.
+            Where, n is the number of predicted detections.
+        y_coord: an array with shape (n,) that represents the Y-coordinates of the detections.
+        x_coord: an array with shape (n,) that represents the X-coordinates of the detections.
+        evaluation_mask: the ground truth mask for evaluation.
+        labels_to_exclude: labels in this list will not be counted for metric calculation.
+        resolution_level: the level at which the evaluation mask is made.
+
+    Returns:
+        fp_probs: an array that contains the probabilities of the false positive detections.
+        tp_probs: an array that contains the probabilities of the True positive detections.
+        num_targets: the total number of targets (excluding `labels_to_exclude`) for all images under evaluation.
+
+    """
+    if isinstance(y_coord, torch.Tensor):
+        y_coord = y_coord.detach().cpu().numpy()
+    if isinstance(x_coord, torch.Tensor):
+        x_coord = x_coord.detach().cpu().numpy()
+
+    y_coord = (y_coord / pow(2, resolution_level)).astype(int)
+    x_coord = (x_coord / pow(2, resolution_level)).astype(int)
+
+    stacked = np.stack([y_coord, x_coord], axis=1)
+
+    return compute_fp_tp_probs_nd(
+        probs=probs, coords=stacked, evaluation_mask=evaluation_mask, labels_to_exclude=labels_to_exclude
+    )
+
+
+def compute_froc_curve_data(
+    fp_probs: np.ndarray | torch.Tensor, tp_probs: np.ndarray | torch.Tensor, num_targets: int, num_images: int
+) -> tuple[np.ndarray, np.ndarray]:
+    """
+    This function is modified from the official evaluation code of
+    `CAMELYON 16 Challenge <https://camelyon16.grand-challenge.org/>`_, and used to compute
+    the required data for plotting the Free Response Operating Characteristic (FROC) curve.
+
+    Args:
+        fp_probs: an array that contains the probabilities of the false positive detections for all
+            images under evaluation.
+        tp_probs: an array that contains the probabilities of the True positive detections for all
+            images under evaluation.
+        num_targets: the total number of targets (excluding `labels_to_exclude`) for all images under evaluation.
+        num_images: the number of images under evaluation.
+
+    """
+    if not isinstance(fp_probs, type(tp_probs)):
+        raise AssertionError("fp and tp probs should have same type.")
+    if isinstance(fp_probs, torch.Tensor):
+        fp_probs = fp_probs.detach().cpu().numpy()
+    if isinstance(tp_probs, torch.Tensor):
+        tp_probs = tp_probs.detach().cpu().numpy()
+
+    total_fps, total_tps = [], []
+    all_probs = sorted(set(list(fp_probs) + list(tp_probs)))
+    for thresh in all_probs[1:]:
+        total_fps.append((fp_probs >= thresh).sum())
+        total_tps.append((tp_probs >= thresh).sum())
+    total_fps.append(0)
+    total_tps.append(0)
+    fps_per_image = np.asarray(total_fps) / float(num_images)
+    total_sensitivity = np.asarray(total_tps) / float(num_targets)
+    return fps_per_image, total_sensitivity
+
+
+def compute_froc_score(
+    fps_per_image: np.ndarray, total_sensitivity: np.ndarray, eval_thresholds: tuple = (0.25, 0.5, 1, 2, 4, 8)
+) -> Any:
+    """
+    This function is modified from the official evaluation code of
+    `CAMELYON 16 Challenge <https://camelyon16.grand-challenge.org/>`_, and used to compute
+    the challenge's second evaluation metric, which is defined as the average sensitivity at
+    the predefined false positive rates per whole slide image.
+
+    Args:
+        fps_per_image: the average number of false positives per image for different thresholds.
+        total_sensitivity: sensitivities (true positive rates) for different thresholds.
+        eval_thresholds: the false positive rates for calculating the average sensitivity. Defaults
+            to (0.25, 0.5, 1, 2, 4, 8) which is the same as the CAMELYON 16 Challenge.
+
+    """
+    interp_sens = np.interp(eval_thresholds, fps_per_image[::-1], total_sensitivity[::-1])
+    return np.mean(interp_sens)

source_code/SegMamba/monai/metrics/hausdorff_distance.py

@@ -0,0 +1,246 @@
+# Copyright (c) MONAI Consortium
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#     http://www.apache.org/licenses/LICENSE-2.0
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from __future__ import annotations
+
+from collections.abc import Sequence
+from typing import Any
+
+import numpy as np
+import torch
+
+from monai.metrics.utils import (
+    do_metric_reduction,
+    get_edge_surface_distance,
+    get_surface_distance,
+    ignore_background,
+    prepare_spacing,
+)
+from monai.utils import MetricReduction, convert_data_type, deprecated
+
+from .metric import CumulativeIterationMetric
+
+__all__ = ["HausdorffDistanceMetric", "compute_hausdorff_distance", "compute_percent_hausdorff_distance"]
+
+
+class HausdorffDistanceMetric(CumulativeIterationMetric):
+    """
+    Compute Hausdorff Distance between two tensors. It can support both multi-classes and multi-labels tasks.
+    It supports both directed and non-directed Hausdorff distance calculation. In addition, specify the `percentile`
+    parameter can get the percentile of the distance. Input `y_pred` is compared with ground truth `y`.
+    `y_preds` is expected to have binarized predictions and `y` should be in one-hot format.
+    You can use suitable transforms in ``monai.transforms.post`` first to achieve binarized values.
+    `y_preds` and `y` can be a list of channel-first Tensor (CHW[D]) or a batch-first Tensor (BCHW[D]).
+    The implementation refers to `DeepMind's implementation <https://github.com/deepmind/surface-distance>`_.
+
+    Example of the typical execution steps of this metric class follows :py:class:`monai.metrics.metric.Cumulative`.
+
+    Args:
+        include_background: whether to include distance computation on the first channel of
+            the predicted output. Defaults to ``False``.
+        distance_metric: : [``"euclidean"``, ``"chessboard"``, ``"taxicab"``]
+            the metric used to compute surface distance. Defaults to ``"euclidean"``.
+        percentile: an optional float number between 0 and 100. If specified, the corresponding
+            percentile of the Hausdorff Distance rather than the maximum result will be achieved.
+            Defaults to ``None``.
+        directed: whether to calculate directed Hausdorff distance. Defaults to ``False``.
+        reduction: define mode of reduction to the metrics, will only apply reduction on `not-nan` values,
+            available reduction modes: {``"none"``, ``"mean"``, ``"sum"``, ``"mean_batch"``, ``"sum_batch"``,
+            ``"mean_channel"``, ``"sum_channel"``}, default to ``"mean"``. if "none", will not do reduction.
+        get_not_nans: whether to return the `not_nans` count, if True, aggregate() returns (metric, not_nans).
+            Here `not_nans` count the number of not nans for the metric, thus its shape equals to the shape of the metric.
+
+    """
+
+    def __init__(
+        self,
+        include_background: bool = False,
+        distance_metric: str = "euclidean",
+        percentile: float | None = None,
+        directed: bool = False,
+        reduction: MetricReduction | str = MetricReduction.MEAN,
+        get_not_nans: bool = False,
+    ) -> None:
+        super().__init__()
+        self.include_background = include_background
+        self.distance_metric = distance_metric
+        self.percentile = percentile
+        self.directed = directed
+        self.reduction = reduction
+        self.get_not_nans = get_not_nans
+
+    def _compute_tensor(self, y_pred: torch.Tensor, y: torch.Tensor, **kwargs: Any) -> torch.Tensor:  # type: ignore[override]
+        """
+        Args:
+            y_pred: input data to compute, typical segmentation model output.
+                It must be one-hot format and first dim is batch, example shape: [16, 3, 32, 32]. The values
+                should be binarized.
+            y: ground truth to compute the distance. It must be one-hot format and first dim is batch.
+                The values should be binarized.
+            kwargs: additional parameters, e.g. ``spacing`` should be passed to correctly compute the metric.
+                ``spacing``: spacing of pixel (or voxel). This parameter is relevant only
+                if ``distance_metric`` is set to ``"euclidean"``.
+                If a single number, isotropic spacing with that value is used for all images in the batch. If a sequence of numbers,
+                the length of the sequence must be equal to the image dimensions.
+                This spacing will be used for all images in the batch.
+                If a sequence of sequences, the length of the outer sequence must be equal to the batch size.
+                If inner sequence has length 1, isotropic spacing with that value is used for all images in the batch,
+                else the inner sequence length must be equal to the image dimensions. If ``None``, spacing of unity is used
+                for all images in batch. Defaults to ``None``.
+
+        Raises:
+            ValueError: when `y_pred` has less than three dimensions.
+        """
+        dims = y_pred.ndimension()
+        if dims < 3:
+            raise ValueError("y_pred should have at least three dimensions.")
+
+        # compute (BxC) for each channel for each batch
+        return compute_hausdorff_distance(
+            y_pred=y_pred,
+            y=y,
+            include_background=self.include_background,
+            distance_metric=self.distance_metric,
+            percentile=self.percentile,
+            directed=self.directed,
+            spacing=kwargs.get("spacing"),
+        )
+
+    def aggregate(
+        self, reduction: MetricReduction | str | None = None
+    ) -> torch.Tensor | tuple[torch.Tensor, torch.Tensor]:
+        """
+        Execute reduction logic for the output of `compute_hausdorff_distance`.
+
+        Args:
+            reduction: define mode of reduction to the metrics, will only apply reduction on `not-nan` values,
+                available reduction modes: {``"none"``, ``"mean"``, ``"sum"``, ``"mean_batch"``, ``"sum_batch"``,
+                ``"mean_channel"``, ``"sum_channel"``}, default to `self.reduction`. if "none", will not do reduction.
+
+        """
+        data = self.get_buffer()
+        if not isinstance(data, torch.Tensor):
+            raise ValueError("the data to aggregate must be PyTorch Tensor.")
+
+        # do metric reduction
+        f, not_nans = do_metric_reduction(data, reduction or self.reduction)
+        return (f, not_nans) if self.get_not_nans else f
+
+
+def compute_hausdorff_distance(
+    y_pred: np.ndarray | torch.Tensor,
+    y: np.ndarray | torch.Tensor,
+    include_background: bool = False,
+    distance_metric: str = "euclidean",
+    percentile: float | None = None,
+    directed: bool = False,
+    spacing: int | float | np.ndarray | Sequence[int | float | np.ndarray | Sequence[int | float]] | None = None,
+) -> torch.Tensor:
+    """
+    Compute the Hausdorff distance.
+
+    Args:
+        y_pred: input data to compute, typical segmentation model output.
+            It must be one-hot format and first dim is batch, example shape: [16, 3, 32, 32]. The values
+            should be binarized.
+        y: ground truth to compute mean the distance. It must be one-hot format and first dim is batch.
+            The values should be binarized.
+        include_background: whether to include distance computation on the first channel of
+            the predicted output. Defaults to ``False``.
+        distance_metric: : [``"euclidean"``, ``"chessboard"``, ``"taxicab"``]
+            the metric used to compute surface distance. Defaults to ``"euclidean"``.
+        percentile: an optional float number between 0 and 100. If specified, the corresponding
+            percentile of the Hausdorff Distance rather than the maximum result will be achieved.
+            Defaults to ``None``.
+        directed: whether to calculate directed Hausdorff distance. Defaults to ``False``.
+        spacing: spacing of pixel (or voxel). This parameter is relevant only if ``distance_metric`` is set to ``"euclidean"``.
+            If a single number, isotropic spacing with that value is used for all images in the batch. If a sequence of numbers,
+            the length of the sequence must be equal to the image dimensions. This spacing will be used for all images in the batch.
+            If a sequence of sequences, the length of the outer sequence must be equal to the batch size.
+            If inner sequence has length 1, isotropic spacing with that value is used for all images in the batch,
+            else the inner sequence length must be equal to the image dimensions. If ``None``, spacing of unity is used
+            for all images in batch. Defaults to ``None``.
+    """
+
+    if not include_background:
+        y_pred, y = ignore_background(y_pred=y_pred, y=y)
+    y_pred = convert_data_type(y_pred, output_type=torch.Tensor, dtype=torch.float)[0]
+    y = convert_data_type(y, output_type=torch.Tensor, dtype=torch.float)[0]
+
+    if y.shape != y_pred.shape:
+        raise ValueError(f"y_pred and y should have same shapes, got {y_pred.shape} and {y.shape}.")
+
+    batch_size, n_class = y_pred.shape[:2]
+    hd = torch.empty((batch_size, n_class), dtype=torch.float, device=y_pred.device)
+
+    img_dim = y_pred.ndim - 2
+    spacing_list = prepare_spacing(spacing=spacing, batch_size=batch_size, img_dim=img_dim)
+
+    for b, c in np.ndindex(batch_size, n_class):
+        _, distances, _ = get_edge_surface_distance(
+            y_pred[b, c],
+            y[b, c],
+            distance_metric=distance_metric,
+            spacing=spacing_list[b],
+            symmetric=not directed,
+            class_index=c,
+        )
+        percentile_distances = [_compute_percentile_hausdorff_distance(d, percentile) for d in distances]
+        max_distance = torch.max(torch.stack(percentile_distances))
+        hd[b, c] = max_distance
+    return hd
+
+
+def _compute_percentile_hausdorff_distance(
+    surface_distance: torch.Tensor, percentile: float | None = None
+) -> torch.Tensor:
+    """
+    This function is used to compute the Hausdorff distance.
+    """
+
+    # for both pred and gt do not have foreground
+    if surface_distance.shape == (0,):
+        return torch.tensor(np.nan, dtype=torch.float, device=surface_distance.device)
+
+    if not percentile:
+        return surface_distance.max()
+
+    if 0 <= percentile <= 100:
+        return torch.quantile(surface_distance, percentile / 100)
+    raise ValueError(f"percentile should be a value between 0 and 100, get {percentile}.")
+
+
+@deprecated(since="1.3.0", removed="1.5.0")
+def compute_percent_hausdorff_distance(
+    edges_pred: np.ndarray,
+    edges_gt: np.ndarray,
+    distance_metric: str = "euclidean",
+    percentile: float | None = None,
+    spacing: int | float | np.ndarray | Sequence[int | float] | None = None,
+) -> float:
+    """
+    This function is used to compute the directed Hausdorff distance.
+    """
+
+    surface_distance: np.ndarray = get_surface_distance(  # type: ignore
+        edges_pred, edges_gt, distance_metric=distance_metric, spacing=spacing
+    )
+
+    # for both pred and gt do not have foreground
+    if surface_distance.shape == (0,):
+        return np.nan
+
+    if not percentile:
+        return surface_distance.max()  # type: ignore[no-any-return]
+
+    if 0 <= percentile <= 100:
+        return np.percentile(surface_distance, percentile)  # type: ignore[no-any-return]
+    raise ValueError(f"percentile should be a value between 0 and 100, get {percentile}.")

source_code/SegMamba/monai/metrics/loss_metric.py

@@ -0,0 +1,111 @@
+# Copyright (c) MONAI Consortium
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#     http://www.apache.org/licenses/LICENSE-2.0
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from __future__ import annotations
+
+from typing import Any
+
+import torch
+from torch.nn.modules.loss import _Loss
+
+from monai.metrics.utils import do_metric_reduction
+from monai.utils import MetricReduction
+
+from ..config import TensorOrList
+from .metric import CumulativeIterationMetric
+
+
+class LossMetric(CumulativeIterationMetric):
+    """
+    A wrapper to make ``loss_fn`` available as a cumulative metric. That is, the loss values computed from
+    mini-batches can be combined in the ``reduction`` mode across multiple iterations, as a quantitative measurement
+    of a model.
+
+    Example:
+
+    .. code-block:: python
+
+        import torch
+        from monai.losses import DiceLoss
+        from monai.metrics import LossMetric
+
+        dice_loss = DiceLoss(include_background=True)
+        loss_metric = LossMetric(loss_fn=dice_loss)
+
+        # first iteration
+        y_pred = torch.tensor([[[[1.0, 0.0], [0.0, 1.0]]]])  # shape [batch=1, channel=1, 2, 2]
+        y = torch.tensor([[[[1.0, 0.0], [1.0, 1.0]]]])  # shape [batch=1, channel=1, 2, 2]
+        loss_metric(y_pred, y)
+
+        # second iteration
+        y_pred = torch.tensor([[[[1.0, 0.0], [0.0, 0.0]]]])  # shape [batch=1, channel=1, 2, 2]
+        y = torch.tensor([[[[1.0, 0.0], [1.0, 1.0]]]])  # shape [batch=1, channel=1, 2, 2]
+        loss_metric(y_pred, y)
+
+        # aggregate
+        print(loss_metric.aggregate(reduction="none"))  # tensor([[0.2000], [0.5000]]) (shape [batch=2, channel=1])
+
+        # reset
+        loss_metric.reset()
+        print(loss_metric.aggregate())
+
+
+    Args:
+        loss_fn: a callable function that takes ``y_pred`` and optionally ``y`` as input (in the "batch-first" format),
+            returns a "batch-first" tensor of loss values.
+        reduction: define mode of reduction to the metrics, will only apply reduction on `not-nan` values,
+            available reduction modes: {``"none"``, ``"mean"``, ``"sum"``, ``"mean_batch"``, ``"sum_batch"``,
+            ``"mean_channel"``, ``"sum_channel"``}, default to ``"mean"``. if "none", will not do reduction.
+        get_not_nans: whether to return the `not_nans` count, if True, aggregate() returns (metric, not_nans).
+            Here `not_nans` count the number of not nans for the metric, thus its shape equals to the shape of the metric.
+
+    """
+
+    def __init__(
+        self, loss_fn: _Loss, reduction: MetricReduction | str = MetricReduction.MEAN, get_not_nans: bool = False
+    ) -> None:
+        super().__init__()
+        self.loss_fn = loss_fn
+        self.reduction = reduction
+        self.get_not_nans = get_not_nans
+
+    def aggregate(
+        self, reduction: MetricReduction | str | None = None
+    ) -> torch.Tensor | tuple[torch.Tensor, torch.Tensor]:
+        """
+        Returns the aggregated loss value across multiple iterations.
+
+        Args:
+            reduction: define mode of reduction to the metrics, will only apply reduction on `not-nan` values,
+                available reduction modes: {``"none"``, ``"mean"``, ``"sum"``, ``"mean_batch"``, ``"sum_batch"``,
+                ``"mean_channel"``, ``"sum_channel"``}, default to `self.reduction`. if "none", will not do reduction.
+        """
+        data = self.get_buffer()
+        if data is None:
+            return (torch.tensor(0.0), torch.tensor(0.0)) if self.get_not_nans else torch.tensor(0.0)
+        f, not_nans = do_metric_reduction(data, reduction or self.reduction)
+        return (f, not_nans) if self.get_not_nans else f
+
+    def _compute_tensor(self, y_pred: torch.Tensor, y: torch.Tensor | None = None, **kwargs: Any) -> TensorOrList:
+        """
+        Input `y_pred` is compared with ground truth `y`.
+        Both `y_pred` and `y` are expected to be a batch-first Tensor (BC[HWD]).
+
+        Returns:
+             a tensor with shape (BC[HWD]), or a list of tensors, each tensor with shape (C[HWD]).
+        """
+        iter_loss: TensorOrList = self.loss_fn(y_pred) if y is None else self.loss_fn(y_pred, y)
+        if isinstance(iter_loss, torch.Tensor):
+            while iter_loss.dim() < 2:
+                iter_loss = iter_loss[None]
+        # to be compatible with `Cumulative`, iter_loss should at least have a batch dim.
+        # to be compatible with `do_metric_reduction`, iter_loss should at least have a batch and a channel dim.
+        return iter_loss

source_code/SegMamba/monai/metrics/meandice.py

@@ -0,0 +1,281 @@
+# Copyright (c) MONAI Consortium
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#     http://www.apache.org/licenses/LICENSE-2.0
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from __future__ import annotations
+
+import torch
+
+from monai.metrics.utils import do_metric_reduction
+from monai.utils import MetricReduction
+
+from .metric import CumulativeIterationMetric
+
+__all__ = ["DiceMetric", "compute_dice", "DiceHelper"]
+
+
+class DiceMetric(CumulativeIterationMetric):
+    """
+    Compute average Dice score for a set of pairs of prediction-groundtruth segmentations.
+
+    It supports both multi-classes and multi-labels tasks.
+    Input `y_pred` is compared with ground truth `y`.
+    `y_pred` is expected to have binarized predictions and `y` can be single-channel class indices or in the
+    one-hot format. The `include_background` parameter can be set to ``False`` to exclude
+    the first category (channel index 0) which is by convention assumed to be background. If the non-background
+    segmentations are small compared to the total image size they can get overwhelmed by the signal from the
+    background. `y_preds` and `y` can be a list of channel-first Tensor (CHW[D]) or a batch-first Tensor (BCHW[D]),
+    `y` can also be in the format of `B1HW[D]`.
+
+    Example of the typical execution steps of this metric class follows :py:class:`monai.metrics.metric.Cumulative`.
+
+    Args:
+        include_background: whether to include Dice computation on the first channel of
+            the predicted output. Defaults to ``True``.
+        reduction: define mode of reduction to the metrics, will only apply reduction on `not-nan` values,
+            available reduction modes: {``"none"``, ``"mean"``, ``"sum"``, ``"mean_batch"``, ``"sum_batch"``,
+            ``"mean_channel"``, ``"sum_channel"``}, default to ``"mean"``. if "none", will not do reduction.
+        get_not_nans: whether to return the `not_nans` count, if True, aggregate() returns (metric, not_nans).
+            Here `not_nans` count the number of not nans for the metric, thus its shape equals to the shape of the metric.
+        ignore_empty: whether to ignore empty ground truth cases during calculation.
+            If `True`, NaN value will be set for empty ground truth cases.
+            If `False`, 1 will be set if the predictions of empty ground truth cases are also empty.
+        num_classes: number of input channels (always including the background). When this is None,
+            ``y_pred.shape[1]`` will be used. This option is useful when both ``y_pred`` and ``y`` are
+            single-channel class indices and the number of classes is not automatically inferred from data.
+        return_with_label: whether to return the metrics with label, only works when reduction is "mean_batch".
+            If `True`, use "label_{index}" as the key corresponding to C channels; if 'include_background' is True,
+            the index begins at "0", otherwise at "1". It can also take a list of label names.
+            The outcome will then be returned as a dictionary.
+
+    """
+
+    def __init__(
+        self,
+        include_background: bool = True,
+        reduction: MetricReduction | str = MetricReduction.MEAN,
+        get_not_nans: bool = False,
+        ignore_empty: bool = True,
+        num_classes: int | None = None,
+        return_with_label: bool | list[str] = False,
+    ) -> None:
+        super().__init__()
+        self.include_background = include_background
+        self.reduction = reduction
+        self.get_not_nans = get_not_nans
+        self.ignore_empty = ignore_empty
+        self.num_classes = num_classes
+        self.return_with_label = return_with_label
+        self.dice_helper = DiceHelper(
+            include_background=self.include_background,
+            reduction=MetricReduction.NONE,
+            get_not_nans=False,
+            softmax=False,
+            ignore_empty=self.ignore_empty,
+            num_classes=self.num_classes,
+        )
+
+    def _compute_tensor(self, y_pred: torch.Tensor, y: torch.Tensor) -> torch.Tensor:  # type: ignore[override]
+        """
+        Args:
+            y_pred: input data to compute, typical segmentation model output.
+                It must be one-hot format and first dim is batch, example shape: [16, 3, 32, 32]. The values
+                should be binarized.
+            y: ground truth to compute mean Dice metric. `y` can be single-channel class indices or
+                in the one-hot format.
+
+        Raises:
+            ValueError: when `y_pred` has less than three dimensions.
+        """
+        dims = y_pred.ndimension()
+        if dims < 3:
+            raise ValueError(f"y_pred should have at least 3 dimensions (batch, channel, spatial), got {dims}.")
+        # compute dice (BxC) for each channel for each batch
+        return self.dice_helper(y_pred=y_pred, y=y)  # type: ignore
+
+    def aggregate(
+        self, reduction: MetricReduction | str | None = None
+    ) -> torch.Tensor | tuple[torch.Tensor, torch.Tensor]:
+        """
+        Execute reduction and aggregation logic for the output of `compute_dice`.
+
+        Args:
+            reduction: define mode of reduction to the metrics, will only apply reduction on `not-nan` values,
+                available reduction modes: {``"none"``, ``"mean"``, ``"sum"``, ``"mean_batch"``, ``"sum_batch"``,
+                ``"mean_channel"``, ``"sum_channel"``}, default to `self.reduction`. if "none", will not do reduction.
+
+        """
+        data = self.get_buffer()
+        if not isinstance(data, torch.Tensor):
+            raise ValueError(f"the data to aggregate must be PyTorch Tensor, got {type(data)}.")
+
+        # do metric reduction
+        f, not_nans = do_metric_reduction(data, reduction or self.reduction)
+        if self.reduction == MetricReduction.MEAN_BATCH and self.return_with_label:
+            _f = {}
+            if isinstance(self.return_with_label, bool):
+                for i, v in enumerate(f):
+                    _label_key = f"label_{i+1}" if not self.include_background else f"label_{i}"
+                    _f[_label_key] = round(v.item(), 4)
+            else:
+                for key, v in zip(self.return_with_label, f):
+                    _f[key] = round(v.item(), 4)
+            f = _f
+        return (f, not_nans) if self.get_not_nans else f
+
+
+def compute_dice(
+    y_pred: torch.Tensor,
+    y: torch.Tensor,
+    include_background: bool = True,
+    ignore_empty: bool = True,
+    num_classes: int | None = None,
+) -> torch.Tensor:
+    """Computes Dice score metric for a batch of predictions.
+
+    Args:
+        y_pred: input data to compute, typical segmentation model output.
+            `y_pred` can be single-channel class indices or in the one-hot format.
+        y: ground truth to compute mean dice metric. `y` can be single-channel class indices or in the one-hot format.
+        include_background: whether to include Dice computation on the first channel of
+            the predicted output. Defaults to True.
+        ignore_empty: whether to ignore empty ground truth cases during calculation.
+            If `True`, NaN value will be set for empty ground truth cases.
+            If `False`, 1 will be set if the predictions of empty ground truth cases are also empty.
+        num_classes: number of input channels (always including the background). When this is None,
+            ``y_pred.shape[1]`` will be used. This option is useful when both ``y_pred`` and ``y`` are
+            single-channel class indices and the number of classes is not automatically inferred from data.
+
+    Returns:
+        Dice scores per batch and per class, (shape: [batch_size, num_classes]).
+
+    """
+    return DiceHelper(  # type: ignore
+        include_background=include_background,
+        reduction=MetricReduction.NONE,
+        get_not_nans=False,
+        softmax=False,
+        ignore_empty=ignore_empty,
+        num_classes=num_classes,
+    )(y_pred=y_pred, y=y)
+
+
+class DiceHelper:
+    """
+    Compute Dice score between two tensors `y_pred` and `y`.
+    `y_pred` and `y` can be single-channel class indices or in the one-hot format.
+
+    Example:
+
+    .. code-block:: python
+
+        import torch
+        from monai.metrics import DiceHelper
+
+        n_classes, batch_size = 5, 16
+        spatial_shape = (128, 128, 128)
+
+        y_pred = torch.rand(batch_size, n_classes, *spatial_shape).float()  # predictions
+        y = torch.randint(0, n_classes, size=(batch_size, 1, *spatial_shape)).long()  # ground truth
+
+        score, not_nans = DiceHelper(include_background=False, sigmoid=True, softmax=True)(y_pred, y)
+        print(score, not_nans)
+
+    """
+
+    def __init__(
+        self,
+        include_background: bool | None = None,
+        sigmoid: bool = False,
+        softmax: bool | None = None,
+        activate: bool = False,
+        get_not_nans: bool = True,
+        reduction: MetricReduction | str = MetricReduction.MEAN_BATCH,
+        ignore_empty: bool = True,
+        num_classes: int | None = None,
+    ) -> None:
+        """
+
+        Args:
+            include_background: whether to include the score on the first channel
+                (default to the value of `sigmoid`, False).
+            sigmoid: whether ``y_pred`` are/will be sigmoid activated outputs. If True, thresholding at 0.5
+                will be performed to get the discrete prediction. Defaults to False.
+            softmax: whether ``y_pred`` are softmax activated outputs. If True, `argmax` will be performed to
+                get the discrete prediction. Defaults to the value of ``not sigmoid``.
+            activate: whether to apply sigmoid to ``y_pred`` if ``sigmoid`` is True. Defaults to False.
+                This option is only valid when ``sigmoid`` is True.
+            get_not_nans: whether to return the number of not-nan values.
+            reduction: define mode of reduction to the metrics
+            ignore_empty: if `True`, NaN value will be set for empty ground truth cases.
+                If `False`, 1 will be set if the Union of ``y_pred`` and ``y`` is empty.
+            num_classes: number of input channels (always including the background). When this is None,
+                ``y_pred.shape[1]`` will be used. This option is useful when both ``y_pred`` and ``y`` are
+                single-channel class indices and the number of classes is not automatically inferred from data.
+        """
+        self.sigmoid = sigmoid
+        self.reduction = reduction
+        self.get_not_nans = get_not_nans
+        self.include_background = sigmoid if include_background is None else include_background
+        self.softmax = not sigmoid if softmax is None else softmax
+        self.activate = activate
+        self.ignore_empty = ignore_empty
+        self.num_classes = num_classes
+
+    def compute_channel(self, y_pred: torch.Tensor, y: torch.Tensor) -> torch.Tensor:
+        """"""
+        y_o = torch.sum(y)
+        if y_o > 0:
+            return (2.0 * torch.sum(torch.masked_select(y, y_pred))) / (y_o + torch.sum(y_pred))
+        if self.ignore_empty:
+            return torch.tensor(float("nan"), device=y_o.device)
+        denorm = y_o + torch.sum(y_pred)
+        if denorm <= 0:
+            return torch.tensor(1.0, device=y_o.device)
+        return torch.tensor(0.0, device=y_o.device)
+
+    def __call__(self, y_pred: torch.Tensor, y: torch.Tensor) -> torch.Tensor | tuple[torch.Tensor, torch.Tensor]:
+        """
+
+        Args:
+            y_pred: input predictions with shape (batch_size, num_classes or 1, spatial_dims...).
+                the number of channels is inferred from ``y_pred.shape[1]`` when ``num_classes is None``.
+            y: ground truth with shape (batch_size, num_classes or 1, spatial_dims...).
+        """
+        _softmax, _sigmoid = self.softmax, self.sigmoid
+        if self.num_classes is None:
+            n_pred_ch = y_pred.shape[1]  # y_pred is in one-hot format or multi-channel scores
+        else:
+            n_pred_ch = self.num_classes
+            if y_pred.shape[1] == 1 and self.num_classes > 1:  # y_pred is single-channel class indices
+                _softmax = _sigmoid = False
+
+        if _softmax:
+            if n_pred_ch > 1:
+                y_pred = torch.argmax(y_pred, dim=1, keepdim=True)
+
+        elif _sigmoid:
+            if self.activate:
+                y_pred = torch.sigmoid(y_pred)
+            y_pred = y_pred > 0.5
+
+        first_ch = 0 if self.include_background else 1
+        data = []
+        for b in range(y_pred.shape[0]):
+            c_list = []
+            for c in range(first_ch, n_pred_ch) if n_pred_ch > 1 else [1]:
+                x_pred = (y_pred[b, 0] == c) if (y_pred.shape[1] == 1) else y_pred[b, c].bool()
+                x = (y[b, 0] == c) if (y.shape[1] == 1) else y[b, c]
+                c_list.append(self.compute_channel(x_pred, x))
+            data.append(torch.stack(c_list))
+        data = torch.stack(data, dim=0).contiguous()  # type: ignore
+
+        f, not_nans = do_metric_reduction(data, self.reduction)  # type: ignore
+        return (f, not_nans) if self.get_not_nans else f

source_code/SegMamba/monai/metrics/mmd.py

@@ -0,0 +1,91 @@
+# Copyright (c) MONAI Consortium
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#     http://www.apache.org/licenses/LICENSE-2.0
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from __future__ import annotations
+
+from collections.abc import Callable
+
+import torch
+
+from monai.metrics.metric import Metric
+
+
+class MMDMetric(Metric):
+    """
+    Unbiased Maximum Mean Discrepancy (MMD) is a kernel-based method for measuring the similarity between two
+    distributions. It is a non-negative metric where a smaller value indicates a closer match between the two
+    distributions.
+
+    Gretton, A., et al,, 2012.  A kernel two-sample test. The Journal of Machine Learning Research, 13(1), pp.723-773.
+
+    Args:
+        y_mapping: Callable to transform the y tensors before computing the metric. It is usually a Gaussian or Laplace
+            filter, but it can be any function that takes a tensor as input and returns a tensor as output such as a
+            feature extractor or an Identity function., e.g. `y_mapping = lambda x: x.square()`.
+    """
+
+    def __init__(self, y_mapping: Callable | None = None) -> None:
+        super().__init__()
+        self.y_mapping = y_mapping
+
+    def __call__(self, y: torch.Tensor, y_pred: torch.Tensor) -> torch.Tensor:
+        return compute_mmd(y, y_pred, self.y_mapping)
+
+
+def compute_mmd(y: torch.Tensor, y_pred: torch.Tensor, y_mapping: Callable | None) -> torch.Tensor:
+    """
+    Args:
+        y: first sample (e.g., the reference image). Its shape is (B,C,W,H) for 2D data and (B,C,W,H,D) for 3D.
+        y_pred: second sample (e.g., the reconstructed image). It has similar shape as y.
+        y_mapping: Callable to transform the y tensors before computing the metric.
+    """
+    if y_pred.shape[0] == 1 or y.shape[0] == 1:
+        raise ValueError("MMD metric requires at least two samples in y and y_pred.")
+
+    if y_mapping is not None:
+        y = y_mapping(y)
+        y_pred = y_mapping(y_pred)
+
+    if y_pred.shape != y.shape:
+        raise ValueError(
+            "y_pred and y shapes dont match after being processed "
+            f"by their transforms, received y_pred: {y_pred.shape} and y: {y.shape}"
+        )
+
+    for d in range(len(y.shape) - 1, 1, -1):
+        y = y.squeeze(dim=d)
+        y_pred = y_pred.squeeze(dim=d)
+
+    y = y.view(y.shape[0], -1)
+    y_pred = y_pred.view(y_pred.shape[0], -1)
+
+    y_y = torch.mm(y, y.t())
+    y_pred_y_pred = torch.mm(y_pred, y_pred.t())
+    y_pred_y = torch.mm(y_pred, y.t())
+
+    m = y.shape[0]
+    n = y_pred.shape[0]
+
+    # Ref. 1 Eq. 3 (found under Lemma 6)
+    # term 1
+    c1 = 1 / (m * (m - 1))
+    a = torch.sum(y_y - torch.diag(torch.diagonal(y_y)))
+
+    # term 2
+    c2 = 1 / (n * (n - 1))
+    b = torch.sum(y_pred_y_pred - torch.diag(torch.diagonal(y_pred_y_pred)))
+
+    # term 3
+    c3 = 2 / (m * n)
+    c = torch.sum(y_pred_y)
+
+    mmd = c1 * a + c2 * b - c3 * c
+    return mmd

source_code/SegMamba/monai/metrics/panoptic_quality.py

@@ -0,0 +1,296 @@
+# Copyright (c) MONAI Consortium
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#     http://www.apache.org/licenses/LICENSE-2.0
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from __future__ import annotations
+
+from collections.abc import Sequence
+
+import torch
+
+from monai.metrics.metric import CumulativeIterationMetric
+from monai.metrics.utils import do_metric_reduction, remap_instance_id
+from monai.utils import MetricReduction, ensure_tuple, optional_import
+
+linear_sum_assignment, _ = optional_import("scipy.optimize", name="linear_sum_assignment")
+
+__all__ = ["PanopticQualityMetric", "compute_panoptic_quality"]
+
+
+class PanopticQualityMetric(CumulativeIterationMetric):
+    """
+    Compute Panoptic Quality between two instance segmentation masks. If specifying `metric_name` to "SQ" or "RQ",
+    Segmentation Quality (SQ) or Recognition Quality (RQ) will be returned instead.
+
+    Panoptic Quality is a metric used in panoptic segmentation tasks. This task unifies the typically distinct tasks
+    of semantic segmentation (assign a class label to each pixel) and
+    instance segmentation (detect and segment each object instance). Compared with semantic segmentation, panoptic
+    segmentation distinguish different instances that belong to same class.
+    Compared with instance segmentation, panoptic segmentation does not allow overlap and only one semantic label and
+    one instance id can be assigned to each pixel.
+    Please refer to the following paper for more details:
+    https://openaccess.thecvf.com/content_CVPR_2019/papers/Kirillov_Panoptic_Segmentation_CVPR_2019_paper.pdf
+
+    This class also refers to the following implementation:
+    https://github.com/TissueImageAnalytics/CoNIC
+
+    Args:
+        num_classes: number of classes. The number should not count the background.
+        metric_name: output metric. The value can be "pq", "sq" or "rq".
+            Except for input only one metric, multiple metrics are also supported via input a sequence of metric names
+            such as ("pq", "sq", "rq"). If input a sequence, a list of results with the same order
+            as the input names will be returned.
+        reduction: define mode of reduction to the metrics, will only apply reduction on `not-nan` values,
+            available reduction modes: {``"none"``, ``"mean"``, ``"sum"``, ``"mean_batch"``, ``"sum_batch"``,
+            ``"mean_channel"``, ``"sum_channel"``}, default to `self.reduction`. if "none", will not do reduction.
+        match_iou_threshold: IOU threshold to determine the pairing between `y_pred` and `y`. Usually,
+            it should >= 0.5, the pairing between instances of `y_pred` and `y` are identical.
+            If set `match_iou_threshold` < 0.5, this function uses Munkres assignment to find the
+            maximal amount of unique pairing.
+        smooth_numerator: a small constant added to the numerator to avoid zero.
+
+    """
+
+    def __init__(
+        self,
+        num_classes: int,
+        metric_name: Sequence[str] | str = "pq",
+        reduction: MetricReduction | str = MetricReduction.MEAN_BATCH,
+        match_iou_threshold: float = 0.5,
+        smooth_numerator: float = 1e-6,
+    ) -> None:
+        super().__init__()
+        self.num_classes = num_classes
+        self.reduction = reduction
+        self.match_iou_threshold = match_iou_threshold
+        self.smooth_numerator = smooth_numerator
+        self.metric_name = ensure_tuple(metric_name)
+
+    def _compute_tensor(self, y_pred: torch.Tensor, y: torch.Tensor) -> torch.Tensor:  # type: ignore[override]
+        """
+        Args:
+            y_pred: Predictions. It must be in the form of B2HW and have integer type. The first channel and the
+                second channel represent the instance predictions and classification predictions respectively.
+            y: ground truth. It must have the same shape as `y_pred` and have integer type. The first channel and the
+                second channel represent the instance labels and classification labels respectively.
+                Values in the second channel of `y_pred` and `y` should be in the range of 0 to `self.num_classes`,
+                where 0 represents the background.
+
+        Raises:
+            ValueError: when `y_pred` and `y` have different shapes.
+            ValueError: when `y_pred` and `y` have != 2 channels.
+            ValueError: when `y_pred` and `y` have != 4 dimensions.
+
+        """
+        if y_pred.shape != y.shape:
+            raise ValueError(f"y_pred and y should have same shapes, got {y_pred.shape} and {y.shape}.")
+
+        if y_pred.shape[1] != 2:
+            raise ValueError(
+                f"for panoptic quality calculation, only 2 channels input is supported, got {y_pred.shape[1]}."
+            )
+
+        dims = y_pred.ndimension()
+        if dims != 4:
+            raise ValueError(f"y_pred should have 4 dimensions (batch, 2, h, w), got {dims}.")
+
+        batch_size = y_pred.shape[0]
+
+        outputs = torch.zeros([batch_size, self.num_classes, 4], device=y_pred.device)
+
+        for b in range(batch_size):
+            true_instance, pred_instance = y[b, 0], y_pred[b, 0]
+            true_class, pred_class = y[b, 1], y_pred[b, 1]
+            for c in range(self.num_classes):
+                pred_instance_c = (pred_class == c + 1) * pred_instance
+                true_instance_c = (true_class == c + 1) * true_instance
+
+                outputs[b, c] = compute_panoptic_quality(
+                    pred=pred_instance_c,
+                    gt=true_instance_c,
+                    remap=True,
+                    match_iou_threshold=self.match_iou_threshold,
+                    output_confusion_matrix=True,
+                )
+
+        return outputs
+
+    def aggregate(self, reduction: MetricReduction | str | None = None) -> torch.Tensor | list[torch.Tensor]:
+        """
+        Execute reduction logic for the output of `compute_panoptic_quality`.
+
+        Args:
+            reduction: define mode of reduction to the metrics, will only apply reduction on `not-nan` values,
+                available reduction modes: {``"none"``, ``"mean"``, ``"sum"``, ``"mean_batch"``, ``"sum_batch"``,
+                ``"mean_channel"``, ``"sum_channel"``}, default to `self.reduction`. if "none", will not do reduction.
+
+        """
+        data = self.get_buffer()
+        if not isinstance(data, torch.Tensor):
+            raise ValueError("the data to aggregate must be PyTorch Tensor.")
+
+        # do metric reduction
+        f, _ = do_metric_reduction(data, reduction or self.reduction)
+        tp, fp, fn, iou_sum = f[..., 0], f[..., 1], f[..., 2], f[..., 3]
+        results = []
+        for metric_name in self.metric_name:
+            metric_name = _check_panoptic_metric_name(metric_name)
+            if metric_name == "rq":
+                results.append(tp / (tp + 0.5 * fp + 0.5 * fn + self.smooth_numerator))
+            elif metric_name == "sq":
+                results.append(iou_sum / (tp + self.smooth_numerator))
+            else:
+                results.append(iou_sum / (tp + 0.5 * fp + 0.5 * fn + self.smooth_numerator))
+
+        return results[0] if len(results) == 1 else results
+
+
+def compute_panoptic_quality(
+    pred: torch.Tensor,
+    gt: torch.Tensor,
+    metric_name: str = "pq",
+    remap: bool = True,
+    match_iou_threshold: float = 0.5,
+    smooth_numerator: float = 1e-6,
+    output_confusion_matrix: bool = False,
+) -> torch.Tensor:
+    """Computes Panoptic Quality (PQ). If specifying `metric_name` to "SQ" or "RQ",
+    Segmentation Quality (SQ) or Recognition Quality (RQ) will be returned instead.
+
+    In addition, if `output_confusion_matrix` is True, the function will return a tensor with shape 4, which
+    represents the true positive, false positive, false negative and the sum of iou. These four values are used to
+    calculate PQ, and returning them directly enables further calculation over all images.
+
+    Args:
+        pred: input data to compute, it must be in the form of HW and have integer type.
+        gt: ground truth. It must have the same shape as `pred` and have integer type.
+        metric_name: output metric. The value can be "pq", "sq" or "rq".
+        remap: whether to remap `pred` and `gt` to ensure contiguous ordering of instance id.
+        match_iou_threshold: IOU threshold to determine the pairing between `pred` and `gt`. Usually,
+            it should >= 0.5, the pairing between instances of `pred` and `gt` are identical.
+            If set `match_iou_threshold` < 0.5, this function uses Munkres assignment to find the
+            maximal amount of unique pairing.
+        smooth_numerator: a small constant added to the numerator to avoid zero.
+
+    Raises:
+        ValueError: when `pred` and `gt` have different shapes.
+        ValueError: when `match_iou_threshold` <= 0.0 or > 1.0.
+
+    """
+
+    if gt.shape != pred.shape:
+        raise ValueError(f"pred and gt should have same shapes, got {pred.shape} and {gt.shape}.")
+    if match_iou_threshold <= 0.0 or match_iou_threshold > 1.0:
+        raise ValueError(f"'match_iou_threshold' should be within (0, 1], got: {match_iou_threshold}.")
+
+    gt = gt.int()
+    pred = pred.int()
+
+    if remap is True:
+        gt = remap_instance_id(gt)
+        pred = remap_instance_id(pred)
+
+    pairwise_iou, true_id_list, pred_id_list = _get_pairwise_iou(pred, gt, device=pred.device)
+    paired_iou, paired_true, paired_pred = _get_paired_iou(
+        pairwise_iou, match_iou_threshold, device=pairwise_iou.device
+    )
+
+    unpaired_true = [idx for idx in true_id_list[1:] if idx not in paired_true]
+    unpaired_pred = [idx for idx in pred_id_list[1:] if idx not in paired_pred]
+
+    tp, fp, fn = len(paired_true), len(unpaired_pred), len(unpaired_true)
+    iou_sum = paired_iou.sum()
+
+    if output_confusion_matrix:
+        return torch.as_tensor([tp, fp, fn, iou_sum], device=pred.device)
+
+    metric_name = _check_panoptic_metric_name(metric_name)
+    if metric_name == "rq":
+        return torch.as_tensor(tp / (tp + 0.5 * fp + 0.5 * fn + smooth_numerator), device=pred.device)
+    if metric_name == "sq":
+        return torch.as_tensor(iou_sum / (tp + smooth_numerator), device=pred.device)
+    return torch.as_tensor(iou_sum / (tp + 0.5 * fp + 0.5 * fn + smooth_numerator), device=pred.device)
+
+
+def _get_id_list(gt: torch.Tensor) -> list[torch.Tensor]:
+    id_list = list(gt.unique())
+    # ensure id 0 is included
+    if 0 not in id_list:
+        id_list.insert(0, torch.tensor(0).int())
+
+    return id_list
+
+
+def _get_pairwise_iou(
+    pred: torch.Tensor, gt: torch.Tensor, device: str | torch.device = "cpu"
+) -> tuple[torch.Tensor, list[torch.Tensor], list[torch.Tensor]]:
+    pred_id_list = _get_id_list(pred)
+    true_id_list = _get_id_list(gt)
+
+    pairwise_iou = torch.zeros([len(true_id_list) - 1, len(pred_id_list) - 1], dtype=torch.float, device=device)
+    true_masks: list[torch.Tensor] = []
+    pred_masks: list[torch.Tensor] = []
+
+    for t in true_id_list[1:]:
+        t_mask = torch.as_tensor(gt == t, device=device).int()
+        true_masks.append(t_mask)
+
+    for p in pred_id_list[1:]:
+        p_mask = torch.as_tensor(pred == p, device=device).int()
+        pred_masks.append(p_mask)
+
+    for true_id in range(1, len(true_id_list)):
+        t_mask = true_masks[true_id - 1]
+        pred_true_overlap = pred[t_mask > 0]
+        pred_true_overlap_id = list(pred_true_overlap.unique())
+        for pred_id in pred_true_overlap_id:
+            if pred_id == 0:
+                continue
+            p_mask = pred_masks[pred_id - 1]
+            total = (t_mask + p_mask).sum()
+            inter = (t_mask * p_mask).sum()
+            iou = inter / (total - inter)
+            pairwise_iou[true_id - 1, pred_id - 1] = iou
+
+    return pairwise_iou, true_id_list, pred_id_list
+
+
+def _get_paired_iou(
+    pairwise_iou: torch.Tensor, match_iou_threshold: float = 0.5, device: str | torch.device = "cpu"
+) -> tuple[torch.Tensor, torch.Tensor, torch.Tensor]:
+    if match_iou_threshold >= 0.5:
+        pairwise_iou[pairwise_iou <= match_iou_threshold] = 0.0
+        paired_true, paired_pred = torch.nonzero(pairwise_iou)[:, 0], torch.nonzero(pairwise_iou)[:, 1]
+        paired_iou = pairwise_iou[paired_true, paired_pred]
+        paired_true += 1
+        paired_pred += 1
+
+        return paired_iou, paired_true, paired_pred
+
+    pairwise_iou = pairwise_iou.cpu().numpy()
+    paired_true, paired_pred = linear_sum_assignment(-pairwise_iou)
+    paired_iou = pairwise_iou[paired_true, paired_pred]
+    paired_true = torch.as_tensor(list(paired_true[paired_iou > match_iou_threshold] + 1), device=device)
+    paired_pred = torch.as_tensor(list(paired_pred[paired_iou > match_iou_threshold] + 1), device=device)
+    paired_iou = paired_iou[paired_iou > match_iou_threshold]
+
+    return paired_iou, paired_true, paired_pred
+
+
+def _check_panoptic_metric_name(metric_name: str) -> str:
+    metric_name = metric_name.replace(" ", "_")
+    metric_name = metric_name.lower()
+    if metric_name in ["panoptic_quality", "pq"]:
+        return "pq"
+    if metric_name in ["segmentation_quality", "sq"]:
+        return "sq"
+    if metric_name in ["recognition_quality", "rq"]:
+        return "rq"
+    raise ValueError(f"metric name: {metric_name} is wrong, please use 'pq', 'sq' or 'rq'.")

source_code/SegMamba/monai/metrics/regression.py

@@ -0,0 +1,596 @@
+# Copyright (c) MONAI Consortium
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#     http://www.apache.org/licenses/LICENSE-2.0
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from __future__ import annotations
+
+import math
+from abc import abstractmethod
+from collections.abc import Callable, Sequence
+from functools import partial
+from typing import Any
+
+import torch
+import torch.nn.functional as F
+
+from monai.metrics.utils import do_metric_reduction
+from monai.utils import MetricReduction, StrEnum, convert_data_type, ensure_tuple_rep
+from monai.utils.type_conversion import convert_to_dst_type
+
+from .metric import CumulativeIterationMetric
+
+
+class RegressionMetric(CumulativeIterationMetric):
+    """
+    Base class for regression metrics.
+    Input `y_pred` is compared with ground truth `y`.
+    Both `y_pred` and `y` are expected to be real-valued, where `y_pred` is output from a regression model.
+    `y_preds` and `y` can be a list of channel-first Tensor (CHW[D]) or a batch-first Tensor (BCHW[D]).
+
+    Example of the typical execution steps of this metric class follows :py:class:`monai.metrics.metric.Cumulative`.
+
+    Args:
+        reduction: define mode of reduction to the metrics, will only apply reduction on `not-nan` values,
+            available reduction modes: {``"none"``, ``"mean"``, ``"sum"``, ``"mean_batch"``, ``"sum_batch"``,
+            ``"mean_channel"``, ``"sum_channel"``}, default to ``"mean"``. if "none", will not do reduction.
+        get_not_nans: whether to return the `not_nans` count, if True, aggregate() returns (metric, not_nans).
+            Here `not_nans` count the number of not nans for the metric, thus its shape equals to the shape of the metric.
+
+    """
+
+    def __init__(self, reduction: MetricReduction | str = MetricReduction.MEAN, get_not_nans: bool = False) -> None:
+        super().__init__()
+        self.reduction = reduction
+        self.get_not_nans = get_not_nans
+
+    def aggregate(
+        self, reduction: MetricReduction | str | None = None
+    ) -> torch.Tensor | tuple[torch.Tensor, torch.Tensor]:
+        """
+        Args:
+            reduction: define mode of reduction to the metrics, will only apply reduction on `not-nan` values,
+                available reduction modes: {``"none"``, ``"mean"``, ``"sum"``, ``"mean_batch"``, ``"sum_batch"``,
+                ``"mean_channel"``, ``"sum_channel"``}, default to `self.reduction`. if "none", will not do reduction.
+        """
+        data = self.get_buffer()
+        if not isinstance(data, torch.Tensor):
+            raise ValueError("the data to aggregate must be PyTorch Tensor.")
+
+        f, not_nans = do_metric_reduction(data, reduction or self.reduction)
+        return (f, not_nans) if self.get_not_nans else f
+
+    def _check_shape(self, y_pred: torch.Tensor, y: torch.Tensor) -> None:
+        if y_pred.shape != y.shape:
+            raise ValueError(f"y_pred and y shapes dont match, received y_pred: [{y_pred.shape}] and y: [{y.shape}]")
+
+        # also check if there is atleast one non-batch dimension i.e. num_dims >= 2
+        if len(y_pred.shape) < 2:
+            raise ValueError("either channel or spatial dimensions required, found only batch dimension")
+
+    @abstractmethod
+    def _compute_metric(self, y_pred: torch.Tensor, y: torch.Tensor) -> torch.Tensor:
+        raise NotImplementedError(f"Subclass {self.__class__.__name__} must implement this method.")
+
+    def _compute_tensor(self, y_pred: torch.Tensor, y: torch.Tensor) -> torch.Tensor:  # type: ignore[override]
+        if not isinstance(y_pred, torch.Tensor) or not isinstance(y, torch.Tensor):
+            raise ValueError("y_pred and y must be PyTorch Tensor.")
+        self._check_shape(y_pred, y)
+        return self._compute_metric(y_pred, y)
+
+
+class MSEMetric(RegressionMetric):
+    r"""Compute Mean Squared Error between two tensors using function:
+
+    .. math::
+        \operatorname {MSE}\left(Y, \hat{Y}\right) =\frac {1}{n}\sum _{i=1}^{n}\left(y_i-\hat{y_i} \right)^{2}.
+
+    More info: https://en.wikipedia.org/wiki/Mean_squared_error
+
+    Input `y_pred` is compared with ground truth `y`.
+    Both `y_pred` and `y` are expected to be real-valued, where `y_pred` is output from a regression model.
+
+    Example of the typical execution steps of this metric class follows :py:class:`monai.metrics.metric.Cumulative`.
+
+    Args:
+        reduction: define the mode to reduce metrics, will only execute reduction on `not-nan` values,
+            available reduction modes: {``"none"``, ``"mean"``, ``"sum"``, ``"mean_batch"``, ``"sum_batch"``,
+            ``"mean_channel"``, ``"sum_channel"``}, default to ``"mean"``. if "none", will not do reduction.
+        get_not_nans: whether to return the `not_nans` count, if True, aggregate() returns (metric, not_nans).
+
+    """
+
+    def __init__(self, reduction: MetricReduction | str = MetricReduction.MEAN, get_not_nans: bool = False) -> None:
+        super().__init__(reduction=reduction, get_not_nans=get_not_nans)
+        self.sq_func = partial(torch.pow, exponent=2.0)
+
+    def _compute_metric(self, y_pred: torch.Tensor, y: torch.Tensor) -> torch.Tensor:
+        return compute_mean_error_metrics(y_pred, y, func=self.sq_func)
+
+
+class MAEMetric(RegressionMetric):
+    r"""Compute Mean Absolute Error between two tensors using function:
+
+    .. math::
+        \operatorname {MAE}\left(Y, \hat{Y}\right) =\frac {1}{n}\sum _{i=1}^{n}\left|y_i-\hat{y_i}\right|.
+
+    More info: https://en.wikipedia.org/wiki/Mean_absolute_error
+
+    Input `y_pred` is compared with ground truth `y`.
+    Both `y_pred` and `y` are expected to be real-valued, where `y_pred` is output from a regression model.
+
+    Example of the typical execution steps of this metric class follows :py:class:`monai.metrics.metric.Cumulative`.
+
+    Args:
+        reduction: define the mode to reduce metrics, will only execute reduction on `not-nan` values,
+            available reduction modes: {``"none"``, ``"mean"``, ``"sum"``, ``"mean_batch"``, ``"sum_batch"``,
+            ``"mean_channel"``, ``"sum_channel"``}, default to ``"mean"``. if "none", will not do reduction.
+        get_not_nans: whether to return the `not_nans` count, if True, aggregate() returns (metric, not_nans).
+
+    """
+
+    def __init__(self, reduction: MetricReduction | str = MetricReduction.MEAN, get_not_nans: bool = False) -> None:
+        super().__init__(reduction=reduction, get_not_nans=get_not_nans)
+        self.abs_func = torch.abs
+
+    def _compute_metric(self, y_pred: torch.Tensor, y: torch.Tensor) -> torch.Tensor:
+        return compute_mean_error_metrics(y_pred, y, func=self.abs_func)
+
+
+class RMSEMetric(RegressionMetric):
+    r"""Compute Root Mean Squared Error between two tensors using function:
+
+    .. math::
+        \operatorname {RMSE}\left(Y, \hat{Y}\right) ={ \sqrt{ \frac {1}{n}\sum _{i=1}^{n}\left(y_i-\hat{y_i}\right)^2 } } \
+        = \sqrt {\operatorname{MSE}\left(Y, \hat{Y}\right)}.
+
+    More info: https://en.wikipedia.org/wiki/Root-mean-square_deviation
+
+    Input `y_pred` is compared with ground truth `y`.
+    Both `y_pred` and `y` are expected to be real-valued, where `y_pred` is output from a regression model.
+
+    Example of the typical execution steps of this metric class follows :py:class:`monai.metrics.metric.Cumulative`.
+
+    Args:
+        reduction: define the mode to reduce metrics, will only execute reduction on `not-nan` values,
+            available reduction modes: {``"none"``, ``"mean"``, ``"sum"``, ``"mean_batch"``, ``"sum_batch"``,
+            ``"mean_channel"``, ``"sum_channel"``}, default to ``"mean"``. if "none", will not do reduction.
+        get_not_nans: whether to return the `not_nans` count, if True, aggregate() returns (metric, not_nans).
+
+    """
+
+    def __init__(self, reduction: MetricReduction | str = MetricReduction.MEAN, get_not_nans: bool = False) -> None:
+        super().__init__(reduction=reduction, get_not_nans=get_not_nans)
+        self.sq_func = partial(torch.pow, exponent=2.0)
+
+    def _compute_metric(self, y_pred: torch.Tensor, y: torch.Tensor) -> torch.Tensor:
+        mse_out = compute_mean_error_metrics(y_pred, y, func=self.sq_func)
+        return torch.sqrt(mse_out)
+
+
+class PSNRMetric(RegressionMetric):
+    r"""Compute Peak Signal To Noise Ratio between two tensors using function:
+
+    .. math::
+        \operatorname{PSNR}\left(Y, \hat{Y}\right) = 20 \cdot \log_{10} \left({\mathit{MAX}}_Y\right) \
+        -10 \cdot \log_{10}\left(\operatorname{MSE\left(Y, \hat{Y}\right)}\right)
+
+    More info: https://en.wikipedia.org/wiki/Peak_signal-to-noise_ratio
+
+    Help taken from:
+    https://github.com/tensorflow/tensorflow/blob/master/tensorflow/python/ops/image_ops_impl.py line 4139
+
+    Input `y_pred` is compared with ground truth `y`.
+    Both `y_pred` and `y` are expected to be real-valued, where `y_pred` is output from a regression model.
+
+    Example of the typical execution steps of this metric class follows :py:class:`monai.metrics.metric.Cumulative`.
+
+    Args:
+        max_val: The dynamic range of the images/volumes (i.e., the difference between the
+            maximum and the minimum allowed values e.g. 255 for a uint8 image).
+        reduction: define the mode to reduce metrics, will only execute reduction on `not-nan` values,
+            available reduction modes: {``"none"``, ``"mean"``, ``"sum"``, ``"mean_batch"``, ``"sum_batch"``,
+            ``"mean_channel"``, ``"sum_channel"``}, default to ``"mean"``. if "none", will not do reduction.
+        get_not_nans: whether to return the `not_nans` count, if True, aggregate() returns (metric, not_nans).
+
+    """
+
+    def __init__(
+        self, max_val: int | float, reduction: MetricReduction | str = MetricReduction.MEAN, get_not_nans: bool = False
+    ) -> None:
+        super().__init__(reduction=reduction, get_not_nans=get_not_nans)
+        self.max_val = max_val
+        self.sq_func = partial(torch.pow, exponent=2.0)
+
+    def _compute_metric(self, y_pred: torch.Tensor, y: torch.Tensor) -> Any:
+        mse_out = compute_mean_error_metrics(y_pred, y, func=self.sq_func)
+        return 20 * math.log10(self.max_val) - 10 * torch.log10(mse_out)
+
+
+def compute_mean_error_metrics(y_pred: torch.Tensor, y: torch.Tensor, func: Callable) -> torch.Tensor:
+    # reducing in only channel + spatial dimensions (not batch)
+    # reduction of batch handled inside __call__() using do_metric_reduction() in respective calling class
+    flt = partial(torch.flatten, start_dim=1)
+    return torch.mean(flt(func(y - y_pred)), dim=-1, keepdim=True)
+
+
+class KernelType(StrEnum):
+    GAUSSIAN = "gaussian"
+    UNIFORM = "uniform"
+
+
+class SSIMMetric(RegressionMetric):
+    r"""
+    Computes the Structural Similarity Index Measure (SSIM).
+
+    .. math::
+        \operatorname {SSIM}(x,y) =\frac {(2 \mu_x \mu_y + c_1)(2 \sigma_{xy} + c_2)}{((\mu_x^2 + \
+                \mu_y^2 + c_1)(\sigma_x^2 + \sigma_y^2 + c_2)}
+
+    For more info, visit
+        https://vicuesoft.com/glossary/term/ssim-ms-ssim/
+
+    SSIM reference paper:
+        Wang, Zhou, et al. "Image quality assessment: from error visibility to structural
+        similarity." IEEE transactions on image processing 13.4 (2004): 600-612.
+
+    Args:
+        spatial_dims: number of spatial dimensions of the input images.
+        data_range: value range of input images. (usually 1.0 or 255)
+        kernel_type: type of kernel, can be "gaussian" or "uniform".
+        win_size: window size of kernel
+        kernel_sigma: standard deviation for Gaussian kernel.
+        k1: stability constant used in the luminance denominator
+        k2: stability constant used in the contrast denominator
+        reduction: define the mode to reduce metrics, will only execute reduction on `not-nan` values,
+            available reduction modes: {``"none"``, ``"mean"``, ``"sum"``, ``"mean_batch"``, ``"sum_batch"``,
+            ``"mean_channel"``, ``"sum_channel"``}, default to ``"mean"``. if "none", will not do reduction
+        get_not_nans: whether to return the `not_nans` count, if True, aggregate() returns (metric, not_nans)
+    """
+
+    def __init__(
+        self,
+        spatial_dims: int,
+        data_range: float = 1.0,
+        kernel_type: KernelType | str = KernelType.GAUSSIAN,
+        win_size: int | Sequence[int] = 11,
+        kernel_sigma: float | Sequence[float] = 1.5,
+        k1: float = 0.01,
+        k2: float = 0.03,
+        reduction: MetricReduction | str = MetricReduction.MEAN,
+        get_not_nans: bool = False,
+    ) -> None:
+        super().__init__(reduction=reduction, get_not_nans=get_not_nans)
+
+        self.spatial_dims = spatial_dims
+        self.data_range = data_range
+        self.kernel_type = kernel_type
+
+        if not isinstance(win_size, Sequence):
+            win_size = ensure_tuple_rep(win_size, spatial_dims)
+        self.kernel_size = win_size
+
+        if not isinstance(kernel_sigma, Sequence):
+            kernel_sigma = ensure_tuple_rep(kernel_sigma, spatial_dims)
+        self.kernel_sigma = kernel_sigma
+
+        self.k1 = k1
+        self.k2 = k2
+
+    def _compute_metric(self, y_pred: torch.Tensor, y: torch.Tensor) -> torch.Tensor:
+        """
+        Args:
+            y_pred: Predicted image.
+                It must be a 2D or 3D batch-first tensor [B,C,H,W] or [B,C,H,W,D].
+            y: Reference image.
+                It must be a 2D or 3D batch-first tensor [B,C,H,W] or [B,C,H,W,D].
+
+        Raises:
+            ValueError: when `y_pred` is not a 2D or 3D image.
+        """
+        dims = y_pred.ndimension()
+        if self.spatial_dims == 2 and dims != 4:
+            raise ValueError(
+                f"y_pred should have 4 dimensions (batch, channel, height, width) when using {self.spatial_dims} "
+                f"spatial dimensions, got {dims}."
+            )
+
+        if self.spatial_dims == 3 and dims != 5:
+            raise ValueError(
+                f"y_pred should have 5 dimensions (batch, channel, height, width, depth) when using {self.spatial_dims}"
+                f" spatial dimensions, got {dims}."
+            )
+
+        ssim_value_full_image, _ = compute_ssim_and_cs(
+            y_pred=y_pred,
+            y=y,
+            spatial_dims=self.spatial_dims,
+            data_range=self.data_range,
+            kernel_type=self.kernel_type,
+            kernel_size=self.kernel_size,
+            kernel_sigma=self.kernel_sigma,
+            k1=self.k1,
+            k2=self.k2,
+        )
+
+        ssim_per_batch: torch.Tensor = ssim_value_full_image.view(ssim_value_full_image.shape[0], -1).mean(
+            1, keepdim=True
+        )
+
+        return ssim_per_batch
+
+
+def _gaussian_kernel(
+    spatial_dims: int, num_channels: int, kernel_size: Sequence[int], kernel_sigma: Sequence[float]
+) -> torch.Tensor:
+    """Computes 2D or 3D gaussian kernel.
+
+    Args:
+        spatial_dims: number of spatial dimensions of the input images.
+        num_channels: number of channels in the image
+        kernel_size: size of kernel
+        kernel_sigma: standard deviation for Gaussian kernel.
+    """
+
+    def gaussian_1d(kernel_size: int, sigma: float) -> torch.Tensor:
+        """Computes 1D gaussian kernel.
+
+        Args:
+            kernel_size: size of the gaussian kernel
+            sigma: Standard deviation of the gaussian kernel
+        """
+        dist = torch.arange(start=(1 - kernel_size) / 2, end=(1 + kernel_size) / 2, step=1)
+        gauss = torch.exp(-torch.pow(dist / sigma, 2) / 2)
+        return (gauss / gauss.sum()).unsqueeze(dim=0)
+
+    gaussian_kernel_x = gaussian_1d(kernel_size[0], kernel_sigma[0])
+    gaussian_kernel_y = gaussian_1d(kernel_size[1], kernel_sigma[1])
+    kernel = torch.matmul(gaussian_kernel_x.t(), gaussian_kernel_y)  # (kernel_size, 1) * (1, kernel_size)
+
+    kernel_dimensions: tuple[int, ...] = (num_channels, 1, kernel_size[0], kernel_size[1])
+
+    if spatial_dims == 3:
+        gaussian_kernel_z = gaussian_1d(kernel_size[2], kernel_sigma[2])[None,]
+        kernel = torch.mul(
+            kernel.unsqueeze(-1).repeat(1, 1, kernel_size[2]),
+            gaussian_kernel_z.expand(kernel_size[0], kernel_size[1], kernel_size[2]),
+        )
+        kernel_dimensions = (num_channels, 1, kernel_size[0], kernel_size[1], kernel_size[2])
+
+    return kernel.expand(kernel_dimensions)
+
+
+def compute_ssim_and_cs(
+    y_pred: torch.Tensor,
+    y: torch.Tensor,
+    spatial_dims: int,
+    kernel_size: Sequence[int],
+    kernel_sigma: Sequence[float],
+    data_range: float = 1.0,
+    kernel_type: KernelType | str = KernelType.GAUSSIAN,
+    k1: float = 0.01,
+    k2: float = 0.03,
+) -> tuple[torch.Tensor, torch.Tensor]:
+    """
+    Function to compute the Structural Similarity Index Measure (SSIM) and Contrast Sensitivity (CS) for a batch
+    of images.
+
+    Args:
+        y_pred: batch of predicted images with shape (batch_size, channels, spatial_dim1, spatial_dim2[, spatial_dim3])
+        y: batch of target images with shape (batch_size, channels, spatial_dim1, spatial_dim2[, spatial_dim3])
+        kernel_size: the size of the kernel to use for the SSIM computation.
+        kernel_sigma: the standard deviation of the kernel to use for the SSIM computation.
+        spatial_dims: number of spatial dimensions of the images (2, 3)
+        data_range: the data range of the images.
+        kernel_type: the type of kernel to use for the SSIM computation. Can be either "gaussian" or "uniform".
+        k1: the first stability constant.
+        k2: the second stability constant.
+
+    Returns:
+        ssim: the Structural Similarity Index Measure score for the batch of images.
+        cs: the Contrast Sensitivity for the batch of images.
+    """
+    if y.shape != y_pred.shape:
+        raise ValueError(f"y_pred and y should have same shapes, got {y_pred.shape} and {y.shape}.")
+
+    y_pred = convert_data_type(y_pred, output_type=torch.Tensor, dtype=torch.float)[0]
+    y = convert_data_type(y, output_type=torch.Tensor, dtype=torch.float)[0]
+
+    num_channels = y_pred.size(1)
+
+    if kernel_type == KernelType.GAUSSIAN:
+        kernel = _gaussian_kernel(spatial_dims, num_channels, kernel_size, kernel_sigma)
+    elif kernel_type == KernelType.UNIFORM:
+        kernel = torch.ones((num_channels, 1, *kernel_size)) / torch.prod(torch.tensor(kernel_size))
+
+    kernel = convert_to_dst_type(src=kernel, dst=y_pred)[0]
+
+    c1 = (k1 * data_range) ** 2  # stability constant for luminance
+    c2 = (k2 * data_range) ** 2  # stability constant for contrast
+
+    conv_fn = getattr(F, f"conv{spatial_dims}d")
+    mu_x = conv_fn(y_pred, kernel, groups=num_channels)
+    mu_y = conv_fn(y, kernel, groups=num_channels)
+    mu_xx = conv_fn(y_pred * y_pred, kernel, groups=num_channels)
+    mu_yy = conv_fn(y * y, kernel, groups=num_channels)
+    mu_xy = conv_fn(y_pred * y, kernel, groups=num_channels)
+
+    sigma_x = mu_xx - mu_x * mu_x
+    sigma_y = mu_yy - mu_y * mu_y
+    sigma_xy = mu_xy - mu_x * mu_y
+
+    contrast_sensitivity = (2 * sigma_xy + c2) / (sigma_x + sigma_y + c2)
+    ssim_value_full_image = ((2 * mu_x * mu_y + c1) / (mu_x**2 + mu_y**2 + c1)) * contrast_sensitivity
+
+    return ssim_value_full_image, contrast_sensitivity
+
+
+class MultiScaleSSIMMetric(RegressionMetric):
+    """
+    Computes the Multi-Scale Structural Similarity Index Measure (MS-SSIM).
+
+    MS-SSIM reference paper:
+        Wang, Z., Simoncelli, E.P. and Bovik, A.C., 2003, November. "Multiscale structural
+        similarity for image quality assessment." In The Thirty-Seventh Asilomar Conference
+        on Signals, Systems & Computers, 2003 (Vol. 2, pp. 1398-1402). IEEE
+
+    Args:
+        spatial_dims: number of spatial dimensions of the input images.
+        data_range: value range of input images. (usually 1.0 or 255)
+        kernel_type: type of kernel, can be "gaussian" or "uniform".
+        kernel_size: size of kernel
+        kernel_sigma: standard deviation for Gaussian kernel.
+        k1: stability constant used in the luminance denominator
+        k2: stability constant used in the contrast denominator
+        weights: parameters for image similarity and contrast sensitivity at different resolution scores.
+        reduction: define the mode to reduce metrics, will only execute reduction on `not-nan` values,
+            available reduction modes: {``"none"``, ``"mean"``, ``"sum"``, ``"mean_batch"``, ``"sum_batch"``,
+            ``"mean_channel"``, ``"sum_channel"``}, default to ``"mean"``. if "none", will not do reduction
+        get_not_nans: whether to return the `not_nans` count, if True, aggregate() returns (metric, not_nans)
+    """
+
+    def __init__(
+        self,
+        spatial_dims: int,
+        data_range: float = 1.0,
+        kernel_type: KernelType | str = KernelType.GAUSSIAN,
+        kernel_size: int | Sequence[int] = 11,
+        kernel_sigma: float | Sequence[float] = 1.5,
+        k1: float = 0.01,
+        k2: float = 0.03,
+        weights: Sequence[float] = (0.0448, 0.2856, 0.3001, 0.2363, 0.1333),
+        reduction: MetricReduction | str = MetricReduction.MEAN,
+        get_not_nans: bool = False,
+    ) -> None:
+        super().__init__(reduction=reduction, get_not_nans=get_not_nans)
+
+        self.spatial_dims = spatial_dims
+        self.data_range = data_range
+        self.kernel_type = kernel_type
+
+        if not isinstance(kernel_size, Sequence):
+            kernel_size = ensure_tuple_rep(kernel_size, spatial_dims)
+        self.kernel_size = kernel_size
+
+        if not isinstance(kernel_sigma, Sequence):
+            kernel_sigma = ensure_tuple_rep(kernel_sigma, spatial_dims)
+        self.kernel_sigma = kernel_sigma
+
+        self.k1 = k1
+        self.k2 = k2
+        self.weights = weights
+
+    def _compute_metric(self, y_pred: torch.Tensor, y: torch.Tensor) -> torch.Tensor:
+        return compute_ms_ssim(
+            y_pred=y_pred,
+            y=y,
+            spatial_dims=self.spatial_dims,
+            data_range=self.data_range,
+            kernel_type=self.kernel_type,
+            kernel_size=self.kernel_size,
+            kernel_sigma=self.kernel_sigma,
+            k1=self.k1,
+            k2=self.k2,
+            weights=self.weights,
+        )
+
+
+def compute_ms_ssim(
+    y_pred: torch.Tensor,
+    y: torch.Tensor,
+    spatial_dims: int,
+    data_range: float = 1.0,
+    kernel_type: KernelType | str = KernelType.GAUSSIAN,
+    kernel_size: int | Sequence[int] = 11,
+    kernel_sigma: float | Sequence[float] = 1.5,
+    k1: float = 0.01,
+    k2: float = 0.03,
+    weights: Sequence[float] = (0.0448, 0.2856, 0.3001, 0.2363, 0.1333),
+) -> torch.Tensor:
+    """
+    Args:
+        y_pred: Predicted image.
+            It must be a 2D or 3D batch-first tensor [B,C,H,W] or [B,C,H,W,D].
+        y: Reference image.
+            It must be a 2D or 3D batch-first tensor [B,C,H,W] or [B,C,H,W,D].
+        spatial_dims: number of spatial dimensions of the input images.
+        data_range: value range of input images. (usually 1.0 or 255)
+        kernel_type: type of kernel, can be "gaussian" or "uniform".
+        kernel_size: size of kernel
+        kernel_sigma: standard deviation for Gaussian kernel.
+        k1: stability constant used in the luminance denominator
+        k2: stability constant used in the contrast denominator
+        weights: parameters for image similarity and contrast sensitivity at different resolution scores.
+    Raises:
+        ValueError: when `y_pred` is not a 2D or 3D image.
+    """
+    dims = y_pred.ndimension()
+    if spatial_dims == 2 and dims != 4:
+        raise ValueError(
+            f"y_pred should have 4 dimensions (batch, channel, height, width) when using {spatial_dims} "
+            f"spatial dimensions, got {dims}."
+        )
+
+    if spatial_dims == 3 and dims != 5:
+        raise ValueError(
+            f"y_pred should have 4 dimensions (batch, channel, height, width, depth) when using {spatial_dims}"
+            f" spatial dimensions, got {dims}."
+        )
+
+    if not isinstance(kernel_size, Sequence):
+        kernel_size = ensure_tuple_rep(kernel_size, spatial_dims)
+
+    if not isinstance(kernel_sigma, Sequence):
+        kernel_sigma = ensure_tuple_rep(kernel_sigma, spatial_dims)
+    # check if image have enough size for the number of downsamplings and the size of the kernel
+    weights_div = max(1, (len(weights) - 1)) ** 2
+    y_pred_spatial_dims = y_pred.shape[2:]
+    for i in range(len(y_pred_spatial_dims)):
+        if y_pred_spatial_dims[i] // weights_div <= kernel_size[i] - 1:
+            raise ValueError(
+                f"For a given number of `weights` parameters {len(weights)} and kernel size "
+                f"{kernel_size[i]}, the image height must be larger than "
+                f"{(kernel_size[i] - 1) * weights_div}."
+            )
+
+    weights_tensor = torch.tensor(weights, device=y_pred.device, dtype=torch.float)
+
+    avg_pool = getattr(F, f"avg_pool{spatial_dims}d")
+
+    multiscale_list: list[torch.Tensor] = []
+    for _ in range(len(weights_tensor)):
+        ssim, cs = compute_ssim_and_cs(
+            y_pred=y_pred,
+            y=y,
+            spatial_dims=spatial_dims,
+            data_range=data_range,
+            kernel_type=kernel_type,
+            kernel_size=kernel_size,
+            kernel_sigma=kernel_sigma,
+            k1=k1,
+            k2=k2,
+        )
+
+        cs_per_batch = cs.view(cs.shape[0], -1).mean(1)
+
+        multiscale_list.append(torch.relu(cs_per_batch))
+        y_pred = avg_pool(y_pred, kernel_size=2)
+        y = avg_pool(y, kernel_size=2)
+
+    ssim = ssim.view(ssim.shape[0], -1).mean(1)
+    multiscale_list[-1] = torch.relu(ssim)
+    multiscale_list_tensor = torch.stack(multiscale_list)
+
+    ms_ssim_value_full_image = torch.prod(multiscale_list_tensor ** weights_tensor.view(-1, 1), dim=0)
+
+    ms_ssim_per_batch: torch.Tensor = ms_ssim_value_full_image.view(ms_ssim_value_full_image.shape[0], -1).mean(
+        1, keepdim=True
+    )
+
+    return ms_ssim_per_batch

source_code/SegMamba/monai/networks/__init__.py

@@ -0,0 +1,34 @@
+# Copyright (c) MONAI Consortium
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#     http://www.apache.org/licenses/LICENSE-2.0
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from __future__ import annotations
+
+from .utils import (
+    convert_to_onnx,
+    convert_to_torchscript,
+    convert_to_trt,
+    copy_model_state,
+    eval_mode,
+    get_state_dict,
+    icnr_init,
+    look_up_named_module,
+    normal_init,
+    normalize_transform,
+    one_hot,
+    pixelshuffle,
+    predict_segmentation,
+    replace_modules,
+    replace_modules_temp,
+    save_state,
+    set_named_module,
+    to_norm_affine,
+    train_mode,
+)

source_code/sam3/.github/workflows/format.yml

@@ -0,0 +1,18 @@
+name: SAM3/ufmt
+on:
+  pull_request:
+    branches:
+    - main
+jobs:
+  ufmt_check:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Install ruff-api
+        run: pip install ruff-api==0.1.0
+      - name: Check formatting
+        uses: omnilib/ufmt@action-v1
+        with:
+          path: sam3 scripts
+          python-version: "3.12"
+          black-version: "24.2.0"
+          usort-version: "1.0.2"

source_code/sam3/sam3/agent/helpers/boxes.py

@@ -0,0 +1,438 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates. All Rights Reserved
+
+import math
+from enum import IntEnum, unique
+from typing import List, Tuple, Union
+
+import numpy as np
+import torch
+from torch import device
+
+_RawBoxType = Union[List[float], Tuple[float, ...], torch.Tensor, np.ndarray]
+
+
+@unique
+class BoxMode(IntEnum):
+    """
+    Enum of different ways to represent a box.
+    """
+
+    XYXY_ABS = 0
+    """
+    (x0, y0, x1, y1) in absolute floating points coordinates.
+    The coordinates in range [0, width or height].
+    """
+    XYWH_ABS = 1
+    """
+    (x0, y0, w, h) in absolute floating points coordinates.
+    """
+    XYXY_REL = 2
+    """
+    Not yet supported!
+    (x0, y0, x1, y1) in range [0, 1]. They are relative to the size of the image.
+    """
+    XYWH_REL = 3
+    """
+    Not yet supported!
+    (x0, y0, w, h) in range [0, 1]. They are relative to the size of the image.
+    """
+    XYWHA_ABS = 4
+    """
+    (xc, yc, w, h, a) in absolute floating points coordinates.
+    (xc, yc) is the center of the rotated box, and the angle a is in degrees ccw.
+    """
+
+    @staticmethod
+    def convert(
+        box: _RawBoxType, from_mode: "BoxMode", to_mode: "BoxMode"
+    ) -> _RawBoxType:
+        """
+        Args:
+            box: can be a k-tuple, k-list or an Nxk array/tensor, where k = 4 or 5
+            from_mode, to_mode (BoxMode)
+
+        Returns:
+            The converted box of the same type.
+        """
+        if from_mode == to_mode:
+            return box
+
+        original_type = type(box)
+        is_numpy = isinstance(box, np.ndarray)
+        single_box = isinstance(box, (list, tuple))
+        if single_box:
+            assert len(box) == 4 or len(box) == 5, (
+                "BoxMode.convert takes either a k-tuple/list or an Nxk array/tensor,"
+                " where k == 4 or 5"
+            )
+            arr = torch.tensor(box)[None, :]
+        else:
+            # avoid modifying the input box
+            if is_numpy:
+                arr = torch.from_numpy(np.asarray(box)).clone()
+            else:
+                arr = box.clone()
+
+        assert to_mode not in [
+            BoxMode.XYXY_REL,
+            BoxMode.XYWH_REL,
+        ] and from_mode not in [
+            BoxMode.XYXY_REL,
+            BoxMode.XYWH_REL,
+        ], "Relative mode not yet supported!"
+
+        if from_mode == BoxMode.XYWHA_ABS and to_mode == BoxMode.XYXY_ABS:
+            assert (
+                arr.shape[-1] == 5
+            ), "The last dimension of input shape must be 5 for XYWHA format"
+            original_dtype = arr.dtype
+            arr = arr.double()
+
+            w = arr[:, 2]
+            h = arr[:, 3]
+            a = arr[:, 4]
+            c = torch.abs(torch.cos(a * math.pi / 180.0))
+            s = torch.abs(torch.sin(a * math.pi / 180.0))
+            # This basically computes the horizontal bounding rectangle of the rotated box
+            new_w = c * w + s * h
+            new_h = c * h + s * w
+
+            # convert center to top-left corner
+            arr[:, 0] -= new_w / 2.0
+            arr[:, 1] -= new_h / 2.0
+            # bottom-right corner
+            arr[:, 2] = arr[:, 0] + new_w
+            arr[:, 3] = arr[:, 1] + new_h
+
+            arr = arr[:, :4].to(dtype=original_dtype)
+        elif from_mode == BoxMode.XYWH_ABS and to_mode == BoxMode.XYWHA_ABS:
+            original_dtype = arr.dtype
+            arr = arr.double()
+            arr[:, 0] += arr[:, 2] / 2.0
+            arr[:, 1] += arr[:, 3] / 2.0
+            angles = torch.zeros((arr.shape[0], 1), dtype=arr.dtype)
+            arr = torch.cat((arr, angles), axis=1).to(dtype=original_dtype)
+        else:
+            if to_mode == BoxMode.XYXY_ABS and from_mode == BoxMode.XYWH_ABS:
+                arr[:, 2] += arr[:, 0]
+                arr[:, 3] += arr[:, 1]
+            elif from_mode == BoxMode.XYXY_ABS and to_mode == BoxMode.XYWH_ABS:
+                arr[:, 2] -= arr[:, 0]
+                arr[:, 3] -= arr[:, 1]
+            else:
+                raise NotImplementedError(
+                    "Conversion from BoxMode {} to {} is not supported yet".format(
+                        from_mode, to_mode
+                    )
+                )
+
+        if single_box:
+            return original_type(arr.flatten().tolist())
+        if is_numpy:
+            return arr.numpy()
+        else:
+            return arr
+
+
+class Boxes:
+    """
+    This structure stores a list of boxes as a Nx4 torch.Tensor.
+    It supports some common methods about boxes
+    (`area`, `clip`, `nonempty`, etc),
+    and also behaves like a Tensor
+    (support indexing, `to(device)`, `.device`, and iteration over all boxes)
+
+    Attributes:
+        tensor (torch.Tensor): float matrix of Nx4. Each row is (x1, y1, x2, y2).
+    """
+
+    def __init__(self, tensor: torch.Tensor):
+        """
+        Args:
+            tensor (Tensor[float]): a Nx4 matrix.  Each row is (x1, y1, x2, y2).
+        """
+        if not isinstance(tensor, torch.Tensor):
+            tensor = torch.as_tensor(
+                tensor, dtype=torch.float32, device=torch.device("cpu")
+            )
+        else:
+            tensor = tensor.to(torch.float32)
+        if tensor.numel() == 0:
+            # Use reshape, so we don't end up creating a new tensor that does not depend on
+            # the inputs (and consequently confuses jit)
+            tensor = tensor.reshape((-1, 4)).to(dtype=torch.float32)
+        assert tensor.dim() == 2 and tensor.size(-1) == 4, tensor.size()
+
+        self.tensor = tensor
+
+    def clone(self) -> "Boxes":
+        """
+        Clone the Boxes.
+
+        Returns:
+            Boxes
+        """
+        return Boxes(self.tensor.clone())
+
+    def to(self, device: torch.device):
+        # Boxes are assumed float32 and does not support to(dtype)
+        return Boxes(self.tensor.to(device=device))
+
+    def area(self) -> torch.Tensor:
+        """
+        Computes the area of all the boxes.
+
+        Returns:
+            torch.Tensor: a vector with areas of each box.
+        """
+        box = self.tensor
+        area = (box[:, 2] - box[:, 0]) * (box[:, 3] - box[:, 1])
+        return area
+
+    def clip(self, box_size: Tuple[int, int]) -> None:
+        """
+        Clip (in place) the boxes by limiting x coordinates to the range [0, width]
+        and y coordinates to the range [0, height].
+
+        Args:
+            box_size (height, width): The clipping box's size.
+        """
+        assert torch.isfinite(self.tensor).all(), "Box tensor contains infinite or NaN!"
+        h, w = box_size
+        x1 = self.tensor[:, 0].clamp(min=0, max=w)
+        y1 = self.tensor[:, 1].clamp(min=0, max=h)
+        x2 = self.tensor[:, 2].clamp(min=0, max=w)
+        y2 = self.tensor[:, 3].clamp(min=0, max=h)
+        self.tensor = torch.stack((x1, y1, x2, y2), dim=-1)
+
+    def nonempty(self, threshold: float = 0.0) -> torch.Tensor:
+        """
+        Find boxes that are non-empty.
+        A box is considered empty, if either of its side is no larger than threshold.
+
+        Returns:
+            Tensor:
+                a binary vector which represents whether each box is empty
+                (False) or non-empty (True).
+        """
+        box = self.tensor
+        widths = box[:, 2] - box[:, 0]
+        heights = box[:, 3] - box[:, 1]
+        keep = (widths > threshold) & (heights > threshold)
+        return keep
+
+    def __getitem__(self, item) -> "Boxes":
+        """
+        Args:
+            item: int, slice, or a BoolTensor
+
+        Returns:
+            Boxes: Create a new :class:`Boxes` by indexing.
+
+        The following usage are allowed:
+
+        1. `new_boxes = boxes[3]`: return a `Boxes` which contains only one box.
+        2. `new_boxes = boxes[2:10]`: return a slice of boxes.
+        3. `new_boxes = boxes[vector]`, where vector is a torch.BoolTensor
+           with `length = len(boxes)`. Nonzero elements in the vector will be selected.
+
+        Note that the returned Boxes might share storage with this Boxes,
+        subject to Pytorch's indexing semantics.
+        """
+        if isinstance(item, int):
+            return Boxes(self.tensor[item].view(1, -1))
+        b = self.tensor[item]
+        assert (
+            b.dim() == 2
+        ), "Indexing on Boxes with {} failed to return a matrix!".format(item)
+        return Boxes(b)
+
+    def __len__(self) -> int:
+        return self.tensor.shape[0]
+
+    def __repr__(self) -> str:
+        return "Boxes(" + str(self.tensor) + ")"
+
+    def inside_box(
+        self, box_size: Tuple[int, int], boundary_threshold: int = 0
+    ) -> torch.Tensor:
+        """
+        Args:
+            box_size (height, width): Size of the reference box.
+            boundary_threshold (int): Boxes that extend beyond the reference box
+                boundary by more than boundary_threshold are considered "outside".
+
+        Returns:
+            a binary vector, indicating whether each box is inside the reference box.
+        """
+        height, width = box_size
+        inds_inside = (
+            (self.tensor[..., 0] >= -boundary_threshold)
+            & (self.tensor[..., 1] >= -boundary_threshold)
+            & (self.tensor[..., 2] < width + boundary_threshold)
+            & (self.tensor[..., 3] < height + boundary_threshold)
+        )
+        return inds_inside
+
+    def get_centers(self) -> torch.Tensor:
+        """
+        Returns:
+            The box centers in a Nx2 array of (x, y).
+        """
+        return (self.tensor[:, :2] + self.tensor[:, 2:]) / 2
+
+    def scale(self, scale_x: float, scale_y: float) -> None:
+        """
+        Scale the box with horizontal and vertical scaling factors
+        """
+        self.tensor[:, 0::2] *= scale_x
+        self.tensor[:, 1::2] *= scale_y
+
+    @classmethod
+    def cat(cls, boxes_list: List["Boxes"]) -> "Boxes":
+        """
+        Concatenates a list of Boxes into a single Boxes
+
+        Arguments:
+            boxes_list (list[Boxes])
+
+        Returns:
+            Boxes: the concatenated Boxes
+        """
+        assert isinstance(boxes_list, (list, tuple))
+        if len(boxes_list) == 0:
+            return cls(torch.empty(0))
+        assert all([isinstance(box, Boxes) for box in boxes_list])
+
+        # use torch.cat (v.s. layers.cat) so the returned boxes never share storage with input
+        cat_boxes = cls(torch.cat([b.tensor for b in boxes_list], dim=0))
+        return cat_boxes
+
+    @property
+    def device(self) -> device:
+        return self.tensor.device
+
+    # type "Iterator[torch.Tensor]", yield, and iter() not supported by torchscript
+    # https://github.com/pytorch/pytorch/issues/18627
+    @torch.jit.unused
+    def __iter__(self):
+        """
+        Yield a box as a Tensor of shape (4,) at a time.
+        """
+        yield from self.tensor
+
+
+def pairwise_intersection(boxes1: Boxes, boxes2: Boxes) -> torch.Tensor:
+    """
+    Given two lists of boxes of size N and M,
+    compute the intersection area between __all__ N x M pairs of boxes.
+    The box order must be (xmin, ymin, xmax, ymax)
+
+    Args:
+        boxes1,boxes2 (Boxes): two `Boxes`. Contains N & M boxes, respectively.
+
+    Returns:
+        Tensor: intersection, sized [N,M].
+    """
+    boxes1, boxes2 = boxes1.tensor, boxes2.tensor
+    width_height = torch.min(boxes1[:, None, 2:], boxes2[:, 2:]) - torch.max(
+        boxes1[:, None, :2], boxes2[:, :2]
+    )  # [N,M,2]
+
+    width_height.clamp_(min=0)  # [N,M,2]
+    intersection = width_height.prod(dim=2)  # [N,M]
+    return intersection
+
+
+# implementation from https://github.com/kuangliu/torchcv/blob/master/torchcv/utils/box.py
+# with slight modifications
+def pairwise_iou(boxes1: Boxes, boxes2: Boxes) -> torch.Tensor:
+    """
+    Given two lists of boxes of size N and M, compute the IoU
+    (intersection over union) between **all** N x M pairs of boxes.
+    The box order must be (xmin, ymin, xmax, ymax).
+
+    Args:
+        boxes1,boxes2 (Boxes): two `Boxes`. Contains N & M boxes, respectively.
+
+    Returns:
+        Tensor: IoU, sized [N,M].
+    """
+    area1 = boxes1.area()  # [N]
+    area2 = boxes2.area()  # [M]
+    inter = pairwise_intersection(boxes1, boxes2)
+
+    # handle empty boxes
+    iou = torch.where(
+        inter > 0,
+        inter / (area1[:, None] + area2 - inter),
+        torch.zeros(1, dtype=inter.dtype, device=inter.device),
+    )
+    return iou
+
+
+def pairwise_ioa(boxes1: Boxes, boxes2: Boxes) -> torch.Tensor:
+    """
+    Similar to :func:`pariwise_iou` but compute the IoA (intersection over boxes2 area).
+
+    Args:
+        boxes1,boxes2 (Boxes): two `Boxes`. Contains N & M boxes, respectively.
+
+    Returns:
+        Tensor: IoA, sized [N,M].
+    """
+    area2 = boxes2.area()  # [M]
+    inter = pairwise_intersection(boxes1, boxes2)
+
+    # handle empty boxes
+    ioa = torch.where(
+        inter > 0, inter / area2, torch.zeros(1, dtype=inter.dtype, device=inter.device)
+    )
+    return ioa
+
+
+def pairwise_point_box_distance(points: torch.Tensor, boxes: Boxes):
+    """
+    Pairwise distance between N points and M boxes. The distance between a
+    point and a box is represented by the distance from the point to 4 edges
+    of the box. Distances are all positive when the point is inside the box.
+
+    Args:
+        points: Nx2 coordinates. Each row is (x, y)
+        boxes: M boxes
+
+    Returns:
+        Tensor: distances of size (N, M, 4). The 4 values are distances from
+            the point to the left, top, right, bottom of the box.
+    """
+    x, y = points.unsqueeze(dim=2).unbind(dim=1)  # (N, 1)
+    x0, y0, x1, y1 = boxes.tensor.unsqueeze(dim=0).unbind(dim=2)  # (1, M)
+    return torch.stack([x - x0, y - y0, x1 - x, y1 - y], dim=2)
+
+
+def matched_pairwise_iou(boxes1: Boxes, boxes2: Boxes) -> torch.Tensor:
+    """
+    Compute pairwise intersection over union (IOU) of two sets of matched
+    boxes that have the same number of boxes.
+    Similar to :func:`pairwise_iou`, but computes only diagonal elements of the matrix.
+
+    Args:
+        boxes1 (Boxes): bounding boxes, sized [N,4].
+        boxes2 (Boxes): same length as boxes1
+    Returns:
+        Tensor: iou, sized [N].
+    """
+    assert len(boxes1) == len(boxes2), (
+        "boxlists should have the same" "number of entries, got {}, {}".format(
+            len(boxes1), len(boxes2)
+        )
+    )
+    area1 = boxes1.area()  # [N]
+    area2 = boxes2.area()  # [N]
+    box1, box2 = boxes1.tensor, boxes2.tensor
+    lt = torch.max(box1[:, :2], box2[:, :2])  # [N,2]
+    rb = torch.min(box1[:, 2:], box2[:, 2:])  # [N,2]
+    wh = (rb - lt).clamp(min=0)  # [N,2]
+    inter = wh[:, 0] * wh[:, 1]  # [N]
+    iou = inter / (area1 + area2 - inter)  # [N]
+    return iou

source_code/sam3/sam3/agent/helpers/color_map.py

@@ -0,0 +1,150 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates. All Rights Reserved
+
+"""
+An awesome colormap for really neat visualizations.
+Copied from Detectron, and removed gray colors.
+"""
+
+import random
+
+import numpy as np
+
+__all__ = ["colormap", "random_color", "random_colors"]
+
+
+# A list of 25 bright and sharp colors for segmentation masks,
+# generated from the edges of the sRGB color space for maximum intensity.
+_COLORS = (
+    np.array(
+        [
+            # The original 8 sharp colors
+            1.000,
+            1.000,
+            0.000,  # 1. Yellow
+            0.000,
+            1.000,
+            0.000,  # 2. Lime
+            0.000,
+            1.000,
+            1.000,  # 3. Cyan
+            1.000,
+            0.000,
+            1.000,  # 4. Magenta
+            1.000,
+            0.000,
+            0.000,  # 5. Red
+            1.000,
+            0.498,
+            0.000,  # 6. Orange
+            0.498,
+            1.000,
+            0.000,  # 7. Chartreuse
+            0.000,
+            1.000,
+            0.498,  # 8. Spring Green
+            1.000,
+            0.000,
+            0.498,  # 9. Rose
+            0.498,
+            0.000,
+            1.000,  # 10. Violet
+            0.753,
+            1.000,
+            0.000,  # 11. Electric Lime
+            1.000,
+            0.753,
+            0.000,  # 12. Vivid Orange
+            0.000,
+            1.000,
+            0.753,  # 13. Turquoise
+            0.753,
+            0.000,
+            1.000,  # 14. Bright Violet
+            1.000,
+            0.000,
+            0.753,  # 15. Bright Pink
+            1.000,
+            0.251,
+            0.000,  # 16. Fiery Orange
+            0.251,
+            1.000,
+            0.000,  # 17. Bright Chartreuse
+            0.000,
+            1.000,
+            0.251,  # 18. Malachite Green
+            0.251,
+            0.000,
+            1.000,  # 19. Deep Violet
+            1.000,
+            0.000,
+            0.251,  # 20. Hot Pink
+        ]
+    )
+    .astype(np.float32)
+    .reshape(-1, 3)
+)
+
+
+def colormap(rgb=False, maximum=255):
+    """
+    Args:
+        rgb (bool): whether to return RGB colors or BGR colors.
+        maximum (int): either 255 or 1
+
+    Returns:
+        ndarray: a float32 array of Nx3 colors, in range [0, 255] or [0, 1]
+    """
+    assert maximum in [255, 1], maximum
+    c = _COLORS * maximum
+    if not rgb:
+        c = c[:, ::-1]
+    return c
+
+
+def random_color(rgb=False, maximum=255):
+    """
+    Args:
+        rgb (bool): whether to return RGB colors or BGR colors.
+        maximum (int): either 255 or 1
+
+    Returns:
+        ndarray: a vector of 3 numbers
+    """
+    idx = np.random.randint(0, len(_COLORS))
+    ret = _COLORS[idx] * maximum
+    if not rgb:
+        ret = ret[::-1]
+    return ret
+
+
+def random_colors(N, rgb=False, maximum=255):
+    """
+    Args:
+        N (int): number of unique colors needed
+        rgb (bool): whether to return RGB colors or BGR colors.
+        maximum (int): either 255 or 1
+
+    Returns:
+        ndarray: a list of random_color
+    """
+    indices = random.sample(range(len(_COLORS)), N)
+    ret = [_COLORS[i] * maximum for i in indices]
+    if not rgb:
+        ret = [x[::-1] for x in ret]
+    return ret
+
+
+if __name__ == "__main__":
+    import cv2
+
+    size = 100
+    H, W = 10, 10
+    canvas = np.random.rand(H * size, W * size, 3).astype("float32")
+    for h in range(H):
+        for w in range(W):
+            idx = h * W + w
+            if idx >= len(_COLORS):
+                break
+            canvas[h * size : (h + 1) * size, w * size : (w + 1) * size] = _COLORS[idx]
+    cv2.imshow("a", canvas)
+    cv2.waitKey(0)

source_code/sam3/sam3/agent/helpers/keypoints.py

@@ -0,0 +1,244 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates. All Rights Reserved
+
+from typing import Any, List, Tuple, Union
+
+import numpy as np
+import torch
+from torch.nn import functional as F
+
+
+class Keypoints:
+    """
+    Stores keypoint **annotation** data. GT Instances have a `gt_keypoints` property
+    containing the x,y location and visibility flag of each keypoint. This tensor has shape
+    (N, K, 3) where N is the number of instances and K is the number of keypoints per instance.
+
+    The visibility flag follows the COCO format and must be one of three integers:
+
+    * v=0: not labeled (in which case x=y=0)
+    * v=1: labeled but not visible
+    * v=2: labeled and visible
+    """
+
+    def __init__(self, keypoints: Union[torch.Tensor, np.ndarray, List[List[float]]]):
+        """
+        Arguments:
+            keypoints: A Tensor, numpy array, or list of the x, y, and visibility of each keypoint.
+                The shape should be (N, K, 3) where N is the number of
+                instances, and K is the number of keypoints per instance.
+        """
+        device = (
+            keypoints.device
+            if isinstance(keypoints, torch.Tensor)
+            else torch.device("cpu")
+        )
+        keypoints = torch.as_tensor(keypoints, dtype=torch.float32, device=device)
+        assert keypoints.dim() == 3 and keypoints.shape[2] == 3, keypoints.shape
+        self.tensor = keypoints
+
+    def __len__(self) -> int:
+        return self.tensor.size(0)
+
+    def to(self, *args: Any, **kwargs: Any) -> "Keypoints":
+        return type(self)(self.tensor.to(*args, **kwargs))
+
+    @property
+    def device(self) -> torch.device:
+        return self.tensor.device
+
+    def to_heatmap(self, boxes: torch.Tensor, heatmap_size: int) -> torch.Tensor:
+        """
+        Convert keypoint annotations to a heatmap of one-hot labels for training,
+        as described in :paper:`Mask R-CNN`.
+
+        Arguments:
+            boxes: Nx4 tensor, the boxes to draw the keypoints to
+
+        Returns:
+            heatmaps:
+                A tensor of shape (N, K), each element is integer spatial label
+                in the range [0, heatmap_size**2 - 1] for each keypoint in the input.
+            valid:
+                A tensor of shape (N, K) containing whether each keypoint is in the roi or not.
+        """
+        return _keypoints_to_heatmap(self.tensor, boxes, heatmap_size)
+
+    def __getitem__(self, item: Union[int, slice, torch.BoolTensor]) -> "Keypoints":
+        """
+        Create a new `Keypoints` by indexing on this `Keypoints`.
+
+        The following usage are allowed:
+
+        1. `new_kpts = kpts[3]`: return a `Keypoints` which contains only one instance.
+        2. `new_kpts = kpts[2:10]`: return a slice of key points.
+        3. `new_kpts = kpts[vector]`, where vector is a torch.ByteTensor
+           with `length = len(kpts)`. Nonzero elements in the vector will be selected.
+
+        Note that the returned Keypoints might share storage with this Keypoints,
+        subject to Pytorch's indexing semantics.
+        """
+        if isinstance(item, int):
+            return Keypoints([self.tensor[item]])
+        return Keypoints(self.tensor[item])
+
+    def __repr__(self) -> str:
+        s = self.__class__.__name__ + "("
+        s += "num_instances={})".format(len(self.tensor))
+        return s
+
+    @staticmethod
+    def cat(keypoints_list: List["Keypoints"]) -> "Keypoints":
+        """
+        Concatenates a list of Keypoints into a single Keypoints
+
+        Arguments:
+            keypoints_list (list[Keypoints])
+
+        Returns:
+            Keypoints: the concatenated Keypoints
+        """
+        assert isinstance(keypoints_list, (list, tuple))
+        assert len(keypoints_list) > 0
+        assert all(isinstance(keypoints, Keypoints) for keypoints in keypoints_list)
+
+        cat_kpts = type(keypoints_list[0])(
+            torch.cat([kpts.tensor for kpts in keypoints_list], dim=0)
+        )
+        return cat_kpts
+
+
+def _keypoints_to_heatmap(
+    keypoints: torch.Tensor, rois: torch.Tensor, heatmap_size: int
+) -> Tuple[torch.Tensor, torch.Tensor]:
+    """
+    Encode keypoint locations into a target heatmap for use in SoftmaxWithLoss across space.
+
+    Maps keypoints from the half-open interval [x1, x2) on continuous image coordinates to the
+    closed interval [0, heatmap_size - 1] on discrete image coordinates. We use the
+    continuous-discrete conversion from Heckbert 1990 ("What is the coordinate of a pixel?"):
+    d = floor(c) and c = d + 0.5, where d is a discrete coordinate and c is a continuous coordinate.
+
+    Arguments:
+        keypoints: tensor of keypoint locations in of shape (N, K, 3).
+        rois: Nx4 tensor of rois in xyxy format
+        heatmap_size: integer side length of square heatmap.
+
+    Returns:
+        heatmaps: A tensor of shape (N, K) containing an integer spatial label
+            in the range [0, heatmap_size**2 - 1] for each keypoint in the input.
+        valid: A tensor of shape (N, K) containing whether each keypoint is in
+            the roi or not.
+    """
+
+    if rois.numel() == 0:
+        return rois.new().long(), rois.new().long()
+    offset_x = rois[:, 0]
+    offset_y = rois[:, 1]
+    scale_x = heatmap_size / (rois[:, 2] - rois[:, 0])
+    scale_y = heatmap_size / (rois[:, 3] - rois[:, 1])
+
+    offset_x = offset_x[:, None]
+    offset_y = offset_y[:, None]
+    scale_x = scale_x[:, None]
+    scale_y = scale_y[:, None]
+
+    x = keypoints[..., 0]
+    y = keypoints[..., 1]
+
+    x_boundary_inds = x == rois[:, 2][:, None]
+    y_boundary_inds = y == rois[:, 3][:, None]
+
+    x = (x - offset_x) * scale_x
+    x = x.floor().long()
+    y = (y - offset_y) * scale_y
+    y = y.floor().long()
+
+    x[x_boundary_inds] = heatmap_size - 1
+    y[y_boundary_inds] = heatmap_size - 1
+
+    valid_loc = (x >= 0) & (y >= 0) & (x < heatmap_size) & (y < heatmap_size)
+    vis = keypoints[..., 2] > 0
+    valid = (valid_loc & vis).long()
+
+    lin_ind = y * heatmap_size + x
+    heatmaps = lin_ind * valid
+
+    return heatmaps, valid
+
+
+@torch.jit.script_if_tracing
+def heatmaps_to_keypoints(maps: torch.Tensor, rois: torch.Tensor) -> torch.Tensor:
+    """
+    Extract predicted keypoint locations from heatmaps.
+
+    Args:
+        maps (Tensor): (#ROIs, #keypoints, POOL_H, POOL_W). The predicted heatmap of logits for
+            each ROI and each keypoint.
+        rois (Tensor): (#ROIs, 4). The box of each ROI.
+
+    Returns:
+        Tensor of shape (#ROIs, #keypoints, 4) with the last dimension corresponding to
+        (x, y, logit, score) for each keypoint.
+
+    When converting discrete pixel indices in an NxN image to a continuous keypoint coordinate,
+    we maintain consistency with :meth:`Keypoints.to_heatmap` by using the conversion from
+    Heckbert 1990: c = d + 0.5, where d is a discrete coordinate and c is a continuous coordinate.
+    """
+
+    offset_x = rois[:, 0]
+    offset_y = rois[:, 1]
+
+    widths = (rois[:, 2] - rois[:, 0]).clamp(min=1)
+    heights = (rois[:, 3] - rois[:, 1]).clamp(min=1)
+    widths_ceil = widths.ceil()
+    heights_ceil = heights.ceil()
+
+    num_rois, num_keypoints = maps.shape[:2]
+    xy_preds = maps.new_zeros(rois.shape[0], num_keypoints, 4)
+
+    width_corrections = widths / widths_ceil
+    height_corrections = heights / heights_ceil
+
+    keypoints_idx = torch.arange(num_keypoints, device=maps.device)
+
+    for i in range(num_rois):
+        outsize = (int(heights_ceil[i]), int(widths_ceil[i]))
+        roi_map = F.interpolate(
+            maps[[i]], size=outsize, mode="bicubic", align_corners=False
+        )
+
+        # Although semantically equivalent, `reshape` is used instead of `squeeze` due
+        # to limitation during ONNX export of `squeeze` in scripting mode
+        roi_map = roi_map.reshape(roi_map.shape[1:])  # keypoints x H x W
+
+        # softmax over the spatial region
+        max_score, _ = roi_map.view(num_keypoints, -1).max(1)
+        max_score = max_score.view(num_keypoints, 1, 1)
+        tmp_full_resolution = (roi_map - max_score).exp_()
+        tmp_pool_resolution = (maps[i] - max_score).exp_()
+        # Produce scores over the region H x W, but normalize with POOL_H x POOL_W,
+        # so that the scores of objects of different absolute sizes will be more comparable
+        roi_map_scores = tmp_full_resolution / tmp_pool_resolution.sum(
+            (1, 2), keepdim=True
+        )
+
+        w = roi_map.shape[2]
+        pos = roi_map.view(num_keypoints, -1).argmax(1)
+
+        x_int = pos % w
+        y_int = (pos - x_int) // w
+
+        assert (
+            roi_map_scores[keypoints_idx, y_int, x_int]
+            == roi_map_scores.view(num_keypoints, -1).max(1)[0]
+        ).all()
+
+        x = (x_int.float() + 0.5) * width_corrections[i]
+        y = (y_int.float() + 0.5) * height_corrections[i]
+
+        xy_preds[i, :, 0] = x + offset_x[i]
+        xy_preds[i, :, 1] = y + offset_y[i]
+        xy_preds[i, :, 2] = roi_map[keypoints_idx, y_int, x_int]
+        xy_preds[i, :, 3] = roi_map_scores[keypoints_idx, y_int, x_int]
+
+    return xy_preds

source_code/sam3/sam3/agent/helpers/mask_overlap_removal.py

@@ -0,0 +1,128 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates. All Rights Reserved
+
+from typing import Dict, List
+
+import numpy as np
+import torch
+
+try:
+    from pycocotools import mask as mask_utils
+except Exception:
+    mask_utils = None
+
+
+def mask_intersection(
+    masks1: torch.Tensor, masks2: torch.Tensor, block_size: int = 16
+) -> torch.Tensor:
+    assert masks1.shape[1:] == masks2.shape[1:]
+    assert masks1.dtype == torch.bool and masks2.dtype == torch.bool
+    N, M = masks1.shape[0], masks2.shape[0]
+    out = torch.zeros(N, M, device=masks1.device, dtype=torch.long)
+    for i in range(0, N, block_size):
+        for j in range(0, M, block_size):
+            a = masks1[i : i + block_size]
+            b = masks2[j : j + block_size]
+            inter = (a[:, None] & b[None, :]).flatten(-2).sum(-1)
+            out[i : i + block_size, j : j + block_size] = inter
+    return out
+
+
+def mask_iom(masks1: torch.Tensor, masks2: torch.Tensor) -> torch.Tensor:
+    assert masks1.shape[1:] == masks2.shape[1:]
+    assert masks1.dtype == torch.bool and masks2.dtype == torch.bool
+    inter = mask_intersection(masks1, masks2)
+    area1 = masks1.flatten(-2).sum(-1)  # (N,)
+    area2 = masks2.flatten(-2).sum(-1)  # (M,)
+    min_area = torch.min(area1[:, None], area2[None, :]).clamp_min(1)
+    return inter.float() / (min_area.float() + 1e-8)
+
+
+def _decode_single_mask(mask_repr, h: int, w: int) -> np.ndarray:
+    if isinstance(mask_repr, (list, tuple, np.ndarray)):
+        arr = np.array(mask_repr)
+        if arr.ndim != 2:
+            raise ValueError("Mask array must be 2D (H, W).")
+        return (arr > 0).astype(np.uint8)
+
+    if mask_utils is None:
+        raise ImportError(
+            "pycocotools is required to decode RLE mask strings. pip install pycocotools"
+        )
+
+    if not isinstance(mask_repr, (str, bytes)):
+        raise ValueError("Unsupported mask representation type for RLE decode.")
+
+    rle = {
+        "counts": mask_repr if isinstance(mask_repr, (str, bytes)) else str(mask_repr),
+        "size": [h, w],
+    }
+    decoded = mask_utils.decode(rle)
+    if decoded.ndim == 3:
+        decoded = decoded[:, :, 0]
+    return (decoded > 0).astype(np.uint8)
+
+
+def _decode_masks_to_torch_bool(pred_masks: List, h: int, w: int) -> torch.Tensor:
+    bin_masks = [_decode_single_mask(m, h, w) for m in pred_masks]
+    masks_np = np.stack(bin_masks, axis=0).astype(np.uint8)  # (N, H, W)
+    return torch.from_numpy(masks_np > 0)
+
+
+def remove_overlapping_masks(sample: Dict, iom_thresh: float = 0.3) -> Dict:
+    """
+    Greedy keep: sort by score desc; keep a mask if IoM to all kept masks <= threshold.
+    If pred_masks has length 0 or 1, returns sample unchanged (no extra keys).
+    """
+    # Basic presence checks
+    if "pred_masks" not in sample or not isinstance(sample["pred_masks"], list):
+        return sample  # nothing to do / preserve as-is
+
+    pred_masks = sample["pred_masks"]
+    N = len(pred_masks)
+
+    # --- Early exit: 0 or 1 mask -> do NOT modify the JSON at all ---
+    if N <= 1:
+        return sample
+
+    # From here on we have at least 2 masks
+    h = int(sample["orig_img_h"])
+    w = int(sample["orig_img_w"])
+    pred_scores = sample.get("pred_scores", [1.0] * N)  # fallback if scores missing
+    pred_boxes = sample.get("pred_boxes", None)
+
+    assert N == len(pred_scores), "pred_masks and pred_scores must have same length"
+    if pred_boxes is not None:
+        assert N == len(pred_boxes), "pred_masks and pred_boxes must have same length"
+
+    masks_bool = _decode_masks_to_torch_bool(pred_masks, h, w)  # (N, H, W)
+
+    order = sorted(range(N), key=lambda i: float(pred_scores[i]), reverse=True)
+    kept_idx: List[int] = []
+    kept_masks: List[torch.Tensor] = []
+
+    for i in order:
+        cand = masks_bool[i].unsqueeze(0)  # (1, H, W)
+        if len(kept_masks) == 0:
+            kept_idx.append(i)
+            kept_masks.append(masks_bool[i])
+            continue
+
+        kept_stack = torch.stack(kept_masks, dim=0)  # (K, H, W)
+        iom_vals = mask_iom(cand, kept_stack).squeeze(0)  # (K,)
+        if torch.any(iom_vals > iom_thresh):
+            continue  # overlaps too much with a higher-scored kept mask
+        kept_idx.append(i)
+        kept_masks.append(masks_bool[i])
+
+    kept_idx_sorted = sorted(kept_idx)
+
+    # Build filtered JSON (this *does* modify fields; only for N>=2 case)
+    out = dict(sample)
+    out["pred_masks"] = [pred_masks[i] for i in kept_idx_sorted]
+    out["pred_scores"] = [pred_scores[i] for i in kept_idx_sorted]
+    if pred_boxes is not None:
+        out["pred_boxes"] = [pred_boxes[i] for i in kept_idx_sorted]
+    out["kept_indices"] = kept_idx_sorted
+    out["removed_indices"] = [i for i in range(N) if i not in set(kept_idx_sorted)]
+    out["iom_threshold"] = float(iom_thresh)
+    return out

source_code/sam3/sam3/agent/helpers/masks.py

@@ -0,0 +1,560 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates. All Rights Reserved
+
+import copy
+import itertools
+from typing import Any, Iterator, List, Union
+
+import numpy as np
+import pycocotools.mask as mask_util
+import torch
+from torch import device
+
+from .boxes import Boxes
+from .memory import retry_if_cuda_oom
+
+from .roi_align import ROIAlign
+
+
+def polygon_area(x, y):
+    # Using the shoelace formula
+    # https://stackoverflow.com/questions/24467972/calculate-area-of-polygon-given-x-y-coordinates
+    return 0.5 * np.abs(np.dot(x, np.roll(y, 1)) - np.dot(y, np.roll(x, 1)))
+
+
+def polygons_to_bitmask(
+    polygons: List[np.ndarray], height: int, width: int
+) -> np.ndarray:
+    """
+    Args:
+        polygons (list[ndarray]): each array has shape (Nx2,)
+        height, width (int)
+
+    Returns:
+        ndarray: a bool mask of shape (height, width)
+    """
+    if len(polygons) == 0:
+        # COCOAPI does not support empty polygons
+        return np.zeros((height, width)).astype(bool)
+    rles = mask_util.frPyObjects(polygons, height, width)
+    rle = mask_util.merge(rles)
+    return mask_util.decode(rle).astype(bool)
+
+
+def rasterize_polygons_within_box(
+    polygons: List[np.ndarray], box: np.ndarray, mask_size: int
+) -> torch.Tensor:
+    """
+    Rasterize the polygons into a mask image and
+    crop the mask content in the given box.
+    The cropped mask is resized to (mask_size, mask_size).
+
+    This function is used when generating training targets for mask head in Mask R-CNN.
+    Given original ground-truth masks for an image, new ground-truth mask
+    training targets in the size of `mask_size x mask_size`
+    must be provided for each predicted box. This function will be called to
+    produce such targets.
+
+    Args:
+        polygons (list[ndarray[float]]): a list of polygons, which represents an instance.
+        box: 4-element numpy array
+        mask_size (int):
+
+    Returns:
+        Tensor: BoolTensor of shape (mask_size, mask_size)
+    """
+    # 1. Shift the polygons w.r.t the boxes
+    w, h = box[2] - box[0], box[3] - box[1]
+
+    polygons = copy.deepcopy(polygons)
+    for p in polygons:
+        p[0::2] = p[0::2] - box[0]
+        p[1::2] = p[1::2] - box[1]
+
+    # 2. Rescale the polygons to the new box size
+    # max() to avoid division by small number
+    ratio_h = mask_size / max(h, 0.1)
+    ratio_w = mask_size / max(w, 0.1)
+
+    if ratio_h == ratio_w:
+        for p in polygons:
+            p *= ratio_h
+    else:
+        for p in polygons:
+            p[0::2] *= ratio_w
+            p[1::2] *= ratio_h
+
+    # 3. Rasterize the polygons with coco api
+    mask = polygons_to_bitmask(polygons, mask_size, mask_size)
+    mask = torch.from_numpy(mask)
+    return mask
+
+
+class BitMasks:
+    """
+    This class stores the segmentation masks for all objects in one image, in
+    the form of bitmaps.
+
+    Attributes:
+        tensor: bool Tensor of N,H,W, representing N instances in the image.
+    """
+
+    def __init__(self, tensor: Union[torch.Tensor, np.ndarray]):
+        """
+        Args:
+            tensor: bool Tensor of N,H,W, representing N instances in the image.
+        """
+        if isinstance(tensor, torch.Tensor):
+            tensor = tensor.to(torch.bool)
+        else:
+            tensor = torch.as_tensor(
+                tensor, dtype=torch.bool, device=torch.device("cpu")
+            )
+        assert tensor.dim() == 3, tensor.size()
+        self.image_size = tensor.shape[1:]
+        self.tensor = tensor
+
+    @torch.jit.unused
+    def to(self, *args: Any, **kwargs: Any) -> "BitMasks":
+        return BitMasks(self.tensor.to(*args, **kwargs))
+
+    @property
+    def device(self) -> torch.device:
+        return self.tensor.device
+
+    @torch.jit.unused
+    def __getitem__(self, item: Union[int, slice, torch.BoolTensor]) -> "BitMasks":
+        """
+        Returns:
+            BitMasks: Create a new :class:`BitMasks` by indexing.
+
+        The following usage are allowed:
+
+        1. `new_masks = masks[3]`: return a `BitMasks` which contains only one mask.
+        2. `new_masks = masks[2:10]`: return a slice of masks.
+        3. `new_masks = masks[vector]`, where vector is a torch.BoolTensor
+           with `length = len(masks)`. Nonzero elements in the vector will be selected.
+
+        Note that the returned object might share storage with this object,
+        subject to Pytorch's indexing semantics.
+        """
+        if isinstance(item, int):
+            return BitMasks(self.tensor[item].unsqueeze(0))
+        m = self.tensor[item]
+        assert (
+            m.dim() == 3
+        ), "Indexing on BitMasks with {} returns a tensor with shape {}!".format(
+            item, m.shape
+        )
+        return BitMasks(m)
+
+    @torch.jit.unused
+    def __iter__(self) -> torch.Tensor:
+        yield from self.tensor
+
+    @torch.jit.unused
+    def __repr__(self) -> str:
+        s = self.__class__.__name__ + "("
+        s += "num_instances={})".format(len(self.tensor))
+        return s
+
+    def __len__(self) -> int:
+        return self.tensor.shape[0]
+
+    def nonempty(self) -> torch.Tensor:
+        """
+        Find masks that are non-empty.
+
+        Returns:
+            Tensor: a BoolTensor which represents
+                whether each mask is empty (False) or non-empty (True).
+        """
+        return self.tensor.flatten(1).any(dim=1)
+
+    @staticmethod
+    def from_polygon_masks(
+        polygon_masks: Union["PolygonMasks", List[List[np.ndarray]]],
+        height: int,
+        width: int,
+    ) -> "BitMasks":
+        """
+        Args:
+            polygon_masks (list[list[ndarray]] or PolygonMasks)
+            height, width (int)
+        """
+        if isinstance(polygon_masks, PolygonMasks):
+            polygon_masks = polygon_masks.polygons
+        masks = [polygons_to_bitmask(p, height, width) for p in polygon_masks]
+        if len(masks):
+            return BitMasks(torch.stack([torch.from_numpy(x) for x in masks]))
+        else:
+            return BitMasks(torch.empty(0, height, width, dtype=torch.bool))
+
+    @staticmethod
+    def from_roi_masks(roi_masks: "ROIMasks", height: int, width: int) -> "BitMasks":
+        """
+        Args:
+            roi_masks:
+            height, width (int):
+        """
+        return roi_masks.to_bitmasks(height, width)
+
+    def crop_and_resize(self, boxes: torch.Tensor, mask_size: int) -> torch.Tensor:
+        """
+        Crop each bitmask by the given box, and resize results to (mask_size, mask_size).
+        This can be used to prepare training targets for Mask R-CNN.
+        It has less reconstruction error compared to rasterization with polygons.
+        However we observe no difference in accuracy,
+        but BitMasks requires more memory to store all the masks.
+
+        Args:
+            boxes (Tensor): Nx4 tensor storing the boxes for each mask
+            mask_size (int): the size of the rasterized mask.
+
+        Returns:
+            Tensor:
+                A bool tensor of shape (N, mask_size, mask_size), where
+                N is the number of predicted boxes for this image.
+        """
+        assert len(boxes) == len(self), "{} != {}".format(len(boxes), len(self))
+        device = self.tensor.device
+
+        batch_inds = torch.arange(len(boxes), device=device).to(dtype=boxes.dtype)[
+            :, None
+        ]
+        rois = torch.cat([batch_inds, boxes], dim=1)  # Nx5
+
+        bit_masks = self.tensor.to(dtype=torch.float32)
+        rois = rois.to(device=device)
+        output = (
+            ROIAlign((mask_size, mask_size), 1.0, 0, aligned=True)
+            .forward(bit_masks[:, None, :, :], rois)
+            .squeeze(1)
+        )
+        output = output >= 0.5
+        return output
+
+    def get_bounding_boxes(self) -> Boxes:
+        """
+        Returns:
+            Boxes: tight bounding boxes around bitmasks.
+            If a mask is empty, it's bounding box will be all zero.
+        """
+        boxes = torch.zeros(self.tensor.shape[0], 4, dtype=torch.float32)
+        x_any = torch.any(self.tensor, dim=1)
+        y_any = torch.any(self.tensor, dim=2)
+        for idx in range(self.tensor.shape[0]):
+            x = torch.where(x_any[idx, :])[0]
+            y = torch.where(y_any[idx, :])[0]
+            if len(x) > 0 and len(y) > 0:
+                boxes[idx, :] = torch.as_tensor(
+                    [x[0], y[0], x[-1] + 1, y[-1] + 1], dtype=torch.float32
+                )
+        return Boxes(boxes)
+
+    @staticmethod
+    def cat(bitmasks_list: List["BitMasks"]) -> "BitMasks":
+        """
+        Concatenates a list of BitMasks into a single BitMasks
+
+        Arguments:
+            bitmasks_list (list[BitMasks])
+
+        Returns:
+            BitMasks: the concatenated BitMasks
+        """
+        assert isinstance(bitmasks_list, (list, tuple))
+        assert len(bitmasks_list) > 0
+        assert all(isinstance(bitmask, BitMasks) for bitmask in bitmasks_list)
+
+        cat_bitmasks = type(bitmasks_list[0])(
+            torch.cat([bm.tensor for bm in bitmasks_list], dim=0)
+        )
+        return cat_bitmasks
+
+
+class PolygonMasks:
+    """
+    This class stores the segmentation masks for all objects in one image, in the form of polygons.
+
+    Attributes:
+        polygons: list[list[ndarray]]. Each ndarray is a float64 vector representing a polygon.
+    """
+
+    def __init__(self, polygons: List[List[Union[torch.Tensor, np.ndarray]]]):
+        """
+        Arguments:
+            polygons (list[list[np.ndarray]]): The first
+                level of the list correspond to individual instances,
+                the second level to all the polygons that compose the
+                instance, and the third level to the polygon coordinates.
+                The third level array should have the format of
+                [x0, y0, x1, y1, ..., xn, yn] (n >= 3).
+        """
+        if not isinstance(polygons, list):
+            raise ValueError(
+                "Cannot create PolygonMasks: Expect a list of list of polygons per image. "
+                "Got '{}' instead.".format(type(polygons))
+            )
+
+        def _make_array(t: Union[torch.Tensor, np.ndarray]) -> np.ndarray:
+            # Use float64 for higher precision, because why not?
+            # Always put polygons on CPU (self.to is a no-op) since they
+            # are supposed to be small tensors.
+            # May need to change this assumption if GPU placement becomes useful
+            if isinstance(t, torch.Tensor):
+                t = t.cpu().numpy()
+            return np.asarray(t).astype("float64")
+
+        def process_polygons(
+            polygons_per_instance: List[Union[torch.Tensor, np.ndarray]],
+        ) -> List[np.ndarray]:
+            if not isinstance(polygons_per_instance, list):
+                raise ValueError(
+                    "Cannot create polygons: Expect a list of polygons per instance. "
+                    "Got '{}' instead.".format(type(polygons_per_instance))
+                )
+            # transform each polygon to a numpy array
+            polygons_per_instance = [_make_array(p) for p in polygons_per_instance]
+            for polygon in polygons_per_instance:
+                if len(polygon) % 2 != 0 or len(polygon) < 6:
+                    raise ValueError(
+                        f"Cannot create a polygon from {len(polygon)} coordinates."
+                    )
+            return polygons_per_instance
+
+        self.polygons: List[List[np.ndarray]] = [
+            process_polygons(polygons_per_instance)
+            for polygons_per_instance in polygons
+        ]
+
+    def to(self, *args: Any, **kwargs: Any) -> "PolygonMasks":
+        return self
+
+    @property
+    def device(self) -> torch.device:
+        return torch.device("cpu")
+
+    def get_bounding_boxes(self) -> Boxes:
+        """
+        Returns:
+            Boxes: tight bounding boxes around polygon masks.
+        """
+        boxes = torch.zeros(len(self.polygons), 4, dtype=torch.float32)
+        for idx, polygons_per_instance in enumerate(self.polygons):
+            minxy = torch.as_tensor([float("inf"), float("inf")], dtype=torch.float32)
+            maxxy = torch.zeros(2, dtype=torch.float32)
+            for polygon in polygons_per_instance:
+                coords = torch.from_numpy(polygon).view(-1, 2).to(dtype=torch.float32)
+                minxy = torch.min(minxy, torch.min(coords, dim=0).values)
+                maxxy = torch.max(maxxy, torch.max(coords, dim=0).values)
+            boxes[idx, :2] = minxy
+            boxes[idx, 2:] = maxxy
+        return Boxes(boxes)
+
+    def nonempty(self) -> torch.Tensor:
+        """
+        Find masks that are non-empty.
+
+        Returns:
+            Tensor:
+                a BoolTensor which represents whether each mask is empty (False) or not (True).
+        """
+        keep = [1 if len(polygon) > 0 else 0 for polygon in self.polygons]
+        return torch.from_numpy(np.asarray(keep, dtype=bool))
+
+    def __getitem__(
+        self, item: Union[int, slice, List[int], torch.BoolTensor]
+    ) -> "PolygonMasks":
+        """
+        Support indexing over the instances and return a `PolygonMasks` object.
+        `item` can be:
+
+        1. An integer. It will return an object with only one instance.
+        2. A slice. It will return an object with the selected instances.
+        3. A list[int]. It will return an object with the selected instances,
+           correpsonding to the indices in the list.
+        4. A vector mask of type BoolTensor, whose length is num_instances.
+           It will return an object with the instances whose mask is nonzero.
+        """
+        if isinstance(item, int):
+            selected_polygons = [self.polygons[item]]
+        elif isinstance(item, slice):
+            selected_polygons = self.polygons[item]
+        elif isinstance(item, list):
+            selected_polygons = [self.polygons[i] for i in item]
+        elif isinstance(item, torch.Tensor):
+            # Polygons is a list, so we have to move the indices back to CPU.
+            if item.dtype == torch.bool:
+                assert item.dim() == 1, item.shape
+                item = item.nonzero().squeeze(1).cpu().numpy().tolist()
+            elif item.dtype in [torch.int32, torch.int64]:
+                item = item.cpu().numpy().tolist()
+            else:
+                raise ValueError(
+                    "Unsupported tensor dtype={} for indexing!".format(item.dtype)
+                )
+            selected_polygons = [self.polygons[i] for i in item]
+        return PolygonMasks(selected_polygons)
+
+    def __iter__(self) -> Iterator[List[np.ndarray]]:
+        """
+        Yields:
+            list[ndarray]: the polygons for one instance.
+            Each Tensor is a float64 vector representing a polygon.
+        """
+        return iter(self.polygons)
+
+    def __repr__(self) -> str:
+        s = self.__class__.__name__ + "("
+        s += "num_instances={})".format(len(self.polygons))
+        return s
+
+    def __len__(self) -> int:
+        return len(self.polygons)
+
+    def crop_and_resize(self, boxes: torch.Tensor, mask_size: int) -> torch.Tensor:
+        """
+        Crop each mask by the given box, and resize results to (mask_size, mask_size).
+        This can be used to prepare training targets for Mask R-CNN.
+
+        Args:
+            boxes (Tensor): Nx4 tensor storing the boxes for each mask
+            mask_size (int): the size of the rasterized mask.
+
+        Returns:
+            Tensor: A bool tensor of shape (N, mask_size, mask_size), where
+            N is the number of predicted boxes for this image.
+        """
+        assert len(boxes) == len(self), "{} != {}".format(len(boxes), len(self))
+
+        device = boxes.device
+        # Put boxes on the CPU, as the polygon representation is not efficient GPU-wise
+        # (several small tensors for representing a single instance mask)
+        boxes = boxes.to(torch.device("cpu"))
+
+        results = [
+            rasterize_polygons_within_box(poly, box.numpy(), mask_size)
+            for poly, box in zip(self.polygons, boxes)
+        ]
+        """
+        poly: list[list[float]], the polygons for one instance
+        box: a tensor of shape (4,)
+        """
+        if len(results) == 0:
+            return torch.empty(0, mask_size, mask_size, dtype=torch.bool, device=device)
+        return torch.stack(results, dim=0).to(device=device)
+
+    def area(self):
+        """
+        Computes area of the mask.
+        Only works with Polygons, using the shoelace formula:
+        https://stackoverflow.com/questions/24467972/calculate-area-of-polygon-given-x-y-coordinates
+
+        Returns:
+            Tensor: a vector, area for each instance
+        """
+
+        area = []
+        for polygons_per_instance in self.polygons:
+            area_per_instance = 0
+            for p in polygons_per_instance:
+                area_per_instance += polygon_area(p[0::2], p[1::2])
+            area.append(area_per_instance)
+
+        return torch.tensor(area)
+
+    @staticmethod
+    def cat(polymasks_list: List["PolygonMasks"]) -> "PolygonMasks":
+        """
+        Concatenates a list of PolygonMasks into a single PolygonMasks
+
+        Arguments:
+            polymasks_list (list[PolygonMasks])
+
+        Returns:
+            PolygonMasks: the concatenated PolygonMasks
+        """
+        assert isinstance(polymasks_list, (list, tuple))
+        assert len(polymasks_list) > 0
+        assert all(isinstance(polymask, PolygonMasks) for polymask in polymasks_list)
+
+        cat_polymasks = type(polymasks_list[0])(
+            list(itertools.chain.from_iterable(pm.polygons for pm in polymasks_list))
+        )
+        return cat_polymasks
+
+
+class ROIMasks:
+    """
+    Represent masks by N smaller masks defined in some ROIs. Once ROI boxes are given,
+    full-image bitmask can be obtained by "pasting" the mask on the region defined
+    by the corresponding ROI box.
+    """
+
+    def __init__(self, tensor: torch.Tensor):
+        """
+        Args:
+            tensor: (N, M, M) mask tensor that defines the mask within each ROI.
+        """
+        if tensor.dim() != 3:
+            raise ValueError("ROIMasks must take a masks of 3 dimension.")
+        self.tensor = tensor
+
+    def to(self, device: torch.device) -> "ROIMasks":
+        return ROIMasks(self.tensor.to(device))
+
+    @property
+    def device(self) -> device:
+        return self.tensor.device
+
+    def __len__(self):
+        return self.tensor.shape[0]
+
+    def __getitem__(self, item) -> "ROIMasks":
+        """
+        Returns:
+            ROIMasks: Create a new :class:`ROIMasks` by indexing.
+
+        The following usage are allowed:
+
+        1. `new_masks = masks[2:10]`: return a slice of masks.
+        2. `new_masks = masks[vector]`, where vector is a torch.BoolTensor
+           with `length = len(masks)`. Nonzero elements in the vector will be selected.
+
+        Note that the returned object might share storage with this object,
+        subject to Pytorch's indexing semantics.
+        """
+        t = self.tensor[item]
+        if t.dim() != 3:
+            raise ValueError(
+                f"Indexing on ROIMasks with {item} returns a tensor with shape {t.shape}!"
+            )
+        return ROIMasks(t)
+
+    @torch.jit.unused
+    def __repr__(self) -> str:
+        s = self.__class__.__name__ + "("
+        s += "num_instances={})".format(len(self.tensor))
+        return s
+
+    @torch.jit.unused
+    def to_bitmasks(self, boxes: torch.Tensor, height, width, threshold=0.5):
+        """
+        Args: see documentation of :func:`paste_masks_in_image`.
+        """
+        from detectron2.layers.mask_ops import (
+            _paste_masks_tensor_shape,
+            paste_masks_in_image,
+        )
+
+        if torch.jit.is_tracing():
+            if isinstance(height, torch.Tensor):
+                paste_func = _paste_masks_tensor_shape
+            else:
+                paste_func = paste_masks_in_image
+        else:
+            paste_func = retry_if_cuda_oom(paste_masks_in_image)
+        bitmasks = paste_func(
+            self.tensor, boxes.tensor, (height, width), threshold=threshold
+        )
+        return BitMasks(bitmasks)

source_code/sam3/sam3/agent/helpers/rle.py

@@ -0,0 +1,122 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates. All Rights Reserved
+
+"""Some utilities for RLE encoding that doesn't require downloading the masks to the cpu"""
+
+import numpy as np
+import torch
+from pycocotools import mask as mask_util
+
+
+@torch.no_grad()
+def rle_encode(orig_mask, return_areas=False):
+    """Encodes a collection of masks in RLE format
+
+    This function emulates the behavior of the COCO API's encode function, but
+    is executed partially on the GPU for faster execution.
+
+    Args:
+        mask (torch.Tensor): A mask of shape (N, H, W) with dtype=torch.bool
+        return_areas (bool): If True, add the areas of the masks as a part of
+            the RLE output dict under the "area" key. Default is False.
+
+    Returns:
+        str: The RLE encoded masks
+    """
+    assert orig_mask.ndim == 3, "Mask must be of shape (N, H, W)"
+    assert orig_mask.dtype == torch.bool, "Mask must have dtype=torch.bool"
+
+    if orig_mask.numel() == 0:
+        return []
+
+    # First, transpose the spatial dimensions.
+    # This is necessary because the COCO API uses Fortran order
+    mask = orig_mask.transpose(1, 2)
+
+    # Flatten the mask
+    flat_mask = mask.reshape(mask.shape[0], -1)
+    if return_areas:
+        mask_areas = flat_mask.sum(-1).tolist()
+    # Find the indices where the mask changes
+    differences = torch.ones(
+        mask.shape[0], flat_mask.shape[1] + 1, device=mask.device, dtype=torch.bool
+    )
+    differences[:, 1:-1] = flat_mask[:, :-1] != flat_mask[:, 1:]
+    differences[:, 0] = flat_mask[:, 0]
+    _, change_indices = torch.where(differences)
+
+    try:
+        boundaries = torch.cumsum(differences.sum(-1), 0).cpu()
+    except RuntimeError as _:
+        boundaries = torch.cumsum(differences.cpu().sum(-1), 0)
+
+    change_indices_clone = change_indices.clone()
+    # First pass computes the RLEs on GPU, in a flatten format
+    for i in range(mask.shape[0]):
+        # Get the change indices for this batch item
+        beg = 0 if i == 0 else boundaries[i - 1].item()
+        end = boundaries[i].item()
+        change_indices[beg + 1 : end] -= change_indices_clone[beg : end - 1]
+
+    # Now we can split the RLES of each batch item, and convert them to strings
+    # No more gpu at this point
+    change_indices = change_indices.tolist()
+
+    batch_rles = []
+    # Process each mask in the batch separately
+    for i in range(mask.shape[0]):
+        beg = 0 if i == 0 else boundaries[i - 1].item()
+        end = boundaries[i].item()
+        run_lengths = change_indices[beg:end]
+
+        uncompressed_rle = {"counts": run_lengths, "size": list(orig_mask.shape[1:])}
+        h, w = uncompressed_rle["size"]
+        rle = mask_util.frPyObjects(uncompressed_rle, h, w)
+        rle["counts"] = rle["counts"].decode("utf-8")
+        if return_areas:
+            rle["area"] = mask_areas[i]
+        batch_rles.append(rle)
+
+    return batch_rles
+
+
+def robust_rle_encode(masks):
+    """Encodes a collection of masks in RLE format. Uses the gpu version fist, falls back to the cpu version if it fails"""
+
+    assert masks.ndim == 3, "Mask must be of shape (N, H, W)"
+    assert masks.dtype == torch.bool, "Mask must have dtype=torch.bool"
+
+    try:
+        return rle_encode(masks)
+    except RuntimeError as _:
+        masks = masks.cpu().numpy()
+        rles = [
+            mask_util.encode(
+                np.array(mask[:, :, np.newaxis], dtype=np.uint8, order="F")
+            )[0]
+            for mask in masks
+        ]
+        for rle in rles:
+            rle["counts"] = rle["counts"].decode("utf-8")
+        return rles
+
+
+def ann_to_rle(segm, im_info):
+    """Convert annotation which can be polygons, uncompressed RLE to RLE.
+    Args:
+        ann (dict) : annotation object
+    Returns:
+        ann (rle)
+    """
+    h, w = im_info["height"], im_info["width"]
+    if isinstance(segm, list):
+        # polygon -- a single object might consist of multiple parts
+        # we merge all parts into one mask rle code
+        rles = mask_util.frPyObjects(segm, h, w)
+        rle = mask_util.merge(rles)
+    elif isinstance(segm["counts"], list):
+        # uncompressed RLE
+        rle = mask_util.frPyObjects(segm, h, w)
+    else:
+        # rle
+        rle = segm
+    return rle

source_code/sam3/sam3/agent/helpers/roi_align.py

@@ -0,0 +1,75 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates. All Rights Reserved
+
+from torch import nn
+from torchvision.ops import roi_align
+
+
+# NOTE: torchvision's RoIAlign has a different default aligned=False
+class ROIAlign(nn.Module):
+    def __init__(self, output_size, spatial_scale, sampling_ratio, aligned=True):
+        """
+        Args:
+            output_size (tuple): h, w
+            spatial_scale (float): scale the input boxes by this number
+            sampling_ratio (int): number of inputs samples to take for each output
+                sample. 0 to take samples densely.
+            aligned (bool): if False, use the legacy implementation in
+                Detectron. If True, align the results more perfectly.
+
+        Note:
+            The meaning of aligned=True:
+
+            Given a continuous coordinate c, its two neighboring pixel indices (in our
+            pixel model) are computed by floor(c - 0.5) and ceil(c - 0.5). For example,
+            c=1.3 has pixel neighbors with discrete indices [0] and [1] (which are sampled
+            from the underlying signal at continuous coordinates 0.5 and 1.5). But the original
+            roi_align (aligned=False) does not subtract the 0.5 when computing neighboring
+            pixel indices and therefore it uses pixels with a slightly incorrect alignment
+            (relative to our pixel model) when performing bilinear interpolation.
+
+            With `aligned=True`,
+            we first appropriately scale the ROI and then shift it by -0.5
+            prior to calling roi_align. This produces the correct neighbors; see
+            detectron2/tests/test_roi_align.py for verification.
+
+            The difference does not make a difference to the model's performance if
+            ROIAlign is used together with conv layers.
+        """
+        super().__init__()
+        self.output_size = output_size
+        self.spatial_scale = spatial_scale
+        self.sampling_ratio = sampling_ratio
+        self.aligned = aligned
+
+        from torchvision import __version__
+
+        version = tuple(int(x) for x in __version__.split(".")[:2])
+        # https://github.com/pytorch/vision/pull/2438
+        assert version >= (0, 7), "Require torchvision >= 0.7"
+
+    def forward(self, input, rois):
+        """
+        Args:
+            input: NCHW images
+            rois: Bx5 boxes. First column is the index into N. The other 4 columns are xyxy.
+        """
+        assert rois.dim() == 2 and rois.size(1) == 5
+        if input.is_quantized:
+            input = input.dequantize()
+        return roi_align(
+            input,
+            rois.to(dtype=input.dtype),
+            self.output_size,
+            self.spatial_scale,
+            self.sampling_ratio,
+            self.aligned,
+        )
+
+    def __repr__(self):
+        tmpstr = self.__class__.__name__ + "("
+        tmpstr += "output_size=" + str(self.output_size)
+        tmpstr += ", spatial_scale=" + str(self.spatial_scale)
+        tmpstr += ", sampling_ratio=" + str(self.sampling_ratio)
+        tmpstr += ", aligned=" + str(self.aligned)
+        tmpstr += ")"
+        return tmpstr