YOLO26升维：PolyMLP+C2PSA | 多项式通道协同空间聚焦，复杂背景目标检测mAP稳定涨点 | ICML2026

重复模块m (n次迭代):
┌─────────────────────────────────────────────────────────┐
│                                                         │
│  如果 attn=True:                                        │
│    Sequential(                                          │
│        Bottleneck(self.c, self.c),                     │  ←─ 先特征提取
│        PSABlock(self.c, attn_ratio=0.5, num_heads=...) │  ←─ 后注意力增强
│    )                                                    │
│                                                         │
│  否则如果 c3k=True:                                     │
│    C3k(self.c, self.c, 2)                             │  ←─ 同YOLOv11
│                                                         │
│  否则:                                                  │
│    Bottleneck(self.c, self.c)                         │  ←─ 同YOLOv11
│                                                         │
└─────────────────────────────────────────────────────────┘

class BboxLoss(nn.Module):
    """Criterion class for computing training losses for bounding boxes."""

    def __init__(self, reg_max: int = 16):
        """Initialize the BboxLoss module with regularization maximum and DFL settings."""
        super().__init__()
        self.dfl_loss = DFLoss(reg_max) if reg_max > 1 else None

######################################## ICML2026 PolyMLP  by AI Little monster start ########################################

### http://cv2023.blog.csdn.net

def poly_init(x: torch.Tensor, batch: bool = False):
    if batch:
        return
    nn.init.kaiming_normal_(x, nonlinearity="relu")


class LayerNorm2d(nn.LayerNorm):
    def __init__(self, num_channels, affine: bool = True, bias: bool = True):
        super().__init__(num_channels, elementwise_affine=affine, bias=bias)
        self.bias_tf = bias

    def forward(self, x):
        u = x.mean(dim=1, keepdim=True)
        s = ((x * x).mean(dim=1, keepdim=True) - (u * u)).clamp(0)
        x = (x - u) * torch.rsqrt(s + self.eps)
        if self.bias_tf:
            x = x * self.weight.view(1, -1, 1, 1) + self.bias.view(1, -1, 1, 1)
        else:
            x = x * self.weight.view(1, -1, 1, 1)
        return x


class ChannelBatchNorm(nn.Module):
    def __init__(
        self,
        num_channels: int,
        eps: float = 1e-5,
        momentum: float = 0.1,
        affine_hw: bool = True,
        affine_c: bool = True,
        bias: bool = True,
        track_running_stats: bool = True,
    ):
        super().__init__()
        self.num_channels = int(num_channels)
        self.eps = float(eps)
        self.momentum = float(momentum)
        self.affine_hw = bool(affine_hw)
        self.affine_c = bool(affine_c)
        self.bias_tf = bool(bias)
        self.track_running_stats = bool(track_running_stats)

        self.gamma_hw = None
        self.beta_hw = None

        if self.affine_c:
            self.gamma_c = nn.Parameter(torch.ones(self.num_channels))
            self.beta_c = None
        else:
            self.register_parameter("gamma_c", None)
            self.register_parameter("beta_c", None)

        if self.track_running_stats:
            self.register_buffer("running_mean", torch.empty(0))
            self.register_buffer("running_var", torch.empty(0))
            self.register_buffer("num_batches_tracked", torch.tensor(0, dtype=torch.long))
        else:
            self.register_buffer("running_mean", None)
            self.register_buffer("running_var", None)
            self.register_buffer("num_batches_tracked", None)

    def _check_input(self, x):
        if x.dim() != 4:
            raise ValueError(f"Expected (N,C,H,W), got {tuple(x.shape)}")
        if x.size(1) != self.num_channels:
            raise ValueError(f"Expected C={self.num_channels}, got C={x.size(1)}")

    def _maybe_init(self, H, W, device, dtype):
        if self.track_running_stats:
            if (self.running_mean.numel() == 0) or (self.running_mean.shape[-2:] != (H, W)):
                self.running_mean = torch.zeros((1, 1, H, W), device=device, dtype=dtype)
                self.running_var = torch.ones((1, 1, H, W), device=device, dtype=dtype)
                self.num_batches_tracked = torch.tensor(0, device=device, dtype=torch.long)

        if self.affine_hw:
            need = (self.gamma_hw is None) or (tuple(self.gamma_hw.shape[-2:]) != (H, W))
            if need:
                self.gamma_hw = nn.Parameter(torch.ones((1, 1, H, W), device=device, dtype=dtype))
                self.beta_hw = (
                    nn.Parameter(torch.zeros((1, 1, H, W), device=device, dtype=dtype))
                    if self.bias_tf
                    else None
                )

    def forward(self, x):
        self._check_input(x)
        _, C, H, W = x.shape
        self._maybe_init(H, W, x.device, x.dtype)

        if self.training:
            mean = x.mean(dim=(0, 1), keepdim=True)
            ex2 = (x * x).mean(dim=(0, 1), keepdim=True)
            var = (ex2 - mean * mean).clamp(min=0.0)

            if self.track_running_stats:
                with torch.no_grad():
                    self.num_batches_tracked += 1
                    m = self.momentum
                    self.running_mean.mul_(1 - m).add_(m * mean)
                    self.running_var.mul_(1 - m).add_(m * var)
        else:
            if self.track_running_stats and self.running_mean is not None and self.running_mean.numel() != 0:
                mean, var = self.running_mean, self.running_var
            else:
                mean = x.mean(dim=(0, 1), keepdim=True)
                ex2 = (x * x).mean(dim=(0, 1), keepdim=True)
                var = (ex2 - mean * mean).clamp(min=0.0)

        y = (x - mean) * torch.rsqrt(var + self.eps)

        if self.affine_hw:
            y = y * self.gamma_hw
            if self.bias_tf and (self.beta_hw is not None):
                y = y + self.beta_hw

        if self.affine_c:
            y = y * self.gamma_c.view(1, C, 1, 1)
            if self.bias_tf and (self.beta_c is not None):
                y = y + self.beta_c.view(1, C, 1, 1)

        return y


def make_norm(norm_type, num_channels, bias=False):
    if norm_type == "bn":
        return ChannelBatchNorm(num_channels, bias=bias)
    if norm_type == "ln":
        return LayerNorm2d(num_channels, bias=bias)
    raise ValueError(f"Unsupported norm_type: {norm_type}")


class DropPath(nn.Module):
    def __init__(self, drop_prob: float = 0.0):
        super().__init__()
        self.drop_prob = float(drop_prob)

    def forward(self, x):
        if self.drop_prob == 0.0 or not self.training:
            return x
        keep_prob = 1 - self.drop_prob
        shape = (x.shape[0],) + (1,) * (x.ndim - 1)
        random_tensor = torch.rand(shape, dtype=x.dtype, device=x.device)
        random_tensor = torch.floor(random_tensor + keep_prob)
        return x / keep_prob * random_tensor


class PolyMLP(nn.Module):
    def __init__(
        self,
        in_features, hidden_features=None, out_features=None,
        norm: str = "ln",
        drop_path: float = 0.0,
        bias: bool = False,
    ):
        super().__init__()
        out_features = out_features or in_features
        hidden_features = hidden_features or in_features

        self.C = out_features
        self.C_inner = hidden_features
        if self.C_inner % 2 != 0:
            raise ValueError(f"C * expansion must be even, got {self.C_inner}")

        self.proj_in = nn.Conv2d(in_features, self.C_inner, kernel_size=1, padding=0, bias=bias)
        self.proj_out = nn.Conv2d(self.C_inner // 2, self.C, kernel_size=1, padding=0, bias=bias)
        self.out = nn.Sequential(
            make_norm(norm, self.C_inner // 2, bias=False),
            self.proj_out,
            DropPath(drop_path),
        )

        poly_init(self.proj_in.weight)
        poly_init(self.proj_out.weight)

    def forward(self, x):
        high, low = self.proj_in(x).split(self.C_inner // 2, 1)
        return self.out(high * low)


######################################## ICML2026 PolyMLP  by AI Little monster end ########################################

from ultralytics.nn.block.PolyMLP  import C2PSA_PolyMLP

    base_modules = frozenset(
        {
            Classify,
            Conv,
            ConvTranspose,
            GhostConv,
            Bottleneck,
            GhostBottleneck,
            SPP,
            SPPF,
            C2fPSA,
            C2PSA,
            DWConv,
            Focus,
            BottleneckCSP,
            C1,
            C2,
            C2f,
            C3k2,
            RepNCSPELAN4,
            ELAN1,
            ADown,
            AConv,
            SPPELAN,
            C2fAttn,
            C3,
            C3TR,
            C3Ghost,
            torch.nn.ConvTranspose2d,
            DWConvTranspose2d,
            C3x,
            RepC3,
            PSA,
            SCDown,
            C2fCIB,
            A2C2f,
            C2PSA_PolyMLP,
        }
    )
    repeat_modules = frozenset(  # modules with 'repeat' arguments
        {
            BottleneckCSP,
            C1,
            C2,
            C2f,
            C3k2,
            C2fAttn,
            C3,
            C3TR,
            C3Ghost,
            C3x,
            RepC3,
            C2fPSA,
            C2fCIB,
            C2PSA,
            A2C2f,
            C2PSA_PolyMLP
        }
    )

# Ultralytics 🚀 AGPL-3.0 License - https://ultralytics.com/license

# Ultralytics YOLO26 object detection model with P3/8 - P5/32 outputs
# Model docs: https://docs.ultralytics.com/models/yolo26
# Task docs: https://docs.ultralytics.com/tasks/detect

# Parameters
nc: 80 # number of classes
end2end: True # whether to use end-to-end mode
reg_max: 1 # DFL bins
scales: # model compound scaling constants, i.e. 'model=yolo26n.yaml' will call yolo26.yaml with scale 'n'
  # [depth, width, max_channels]
  n: [0.50, 0.25, 1024] # summary: 260 layers, 2,572,280 parameters, 2,572,280 gradients, 6.1 GFLOPs
  s: [0.50, 0.50, 1024] # summary: 260 layers, 10,009,784 parameters, 10,009,784 gradients, 22.8 GFLOPs
  m: [0.50, 1.00, 512] # summary: 280 layers, 21,896,248 parameters, 21,896,248 gradients, 75.4 GFLOPs
  l: [1.00, 1.00, 512] # summary: 392 layers, 26,299,704 parameters, 26,299,704 gradients, 93.8 GFLOPs
  x: [1.00, 1.50, 512] # summary: 392 layers, 58,993,368 parameters, 58,993,368 gradients, 209.5 GFLOPs

# YOLO26n backbone
backbone:
  # [from, repeats, module, args]
  - [-1, 1, Conv, [64, 3, 2]] # 0-P1/2
  - [-1, 1, Conv, [128, 3, 2]] # 1-P2/4
  - [-1, 2, C3k2, [256, False, 0.25]]
  - [-1, 1, Conv, [256, 3, 2]] # 3-P3/8
  - [-1, 2, C3k2, [512, False, 0.25]]
  - [-1, 1, Conv, [512, 3, 2]] # 5-P4/16
  - [-1, 2, C3k2, [512, True]]
  - [-1, 1, Conv, [1024, 3, 2]] # 7-P5/32
  - [-1, 2, C3k2, [1024, True]]
  - [-1, 1, SPPF, [1024, 5, 3, True]] # 9
  - [-1, 2, C2PSA_PolyMLP, [1024]] # 10

# YOLO26n head
head:
  - [-1, 1, nn.Upsample, [None, 2, "nearest"]]
  - [[-1, 6], 1, Concat, [1]] # cat backbone P4
  - [-1, 2, C3k2, [512, True]] # 13

  - [-1, 1, nn.Upsample, [None, 2, "nearest"]]
  - [[-1, 4], 1, Concat, [1]] # cat backbone P3
  - [-1, 2, C3k2, [256, True]] # 16 (P3/8-small)

  - [-1, 1, Conv, [256, 3, 2]]
  - [[-1, 13], 1, Concat, [1]] # cat head P4
  - [-1, 2, C3k2, [512, True]] # 19 (P4/16-medium)

  - [-1, 1, Conv, [512, 3, 2]]
  - [[-1, 10], 1, Concat, [1]] # cat head P5
  - [-1, 1, C3k2, [1024, True, 0.5, True]] # 22 (P5/32-large)

  - [[16, 19, 22], 1, Detect, [nc]] # Detect(P3, P4, P5)