dim20: 3.9 mAP from 22K params. 768->20->80 bottleneck, SVD-initialized from pruned prototypes.

heads/__init__.py

@@ -26,6 +26,7 @@ from .optimal_transport.head import OptimalTransport
 from .tropical.head import TropicalDetection
 from .compression.head import CompressionDetection
 from .curvature.head import CurvatureDetection
+from .cofiber_threshold.dim20_20k.head import CofiberThresholdDim20
 
 REGISTRY = {
     "baseline_fcos": BaselineFCOS,
@@ -54,6 +55,7 @@ REGISTRY = {
     "compression": CompressionDetection,
     "curvature": CurvatureDetection,
     "cofiber_threshold_box32": CofiberThresholdV2,
+    "cofiber_threshold_dim20": CofiberThresholdDim20,
 }
 
 ALL_NAMES = list(REGISTRY.keys())

heads/cofiber_threshold/dim10_13k/head.py

@@ -0,0 +1,66 @@
+"""Cofiber Threshold Dim10: 768->10->80 classification. 13,426 params."""
+
+import math
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+
+def cofiber_decompose(f, n_scales):
+    cofibers = []
+    residual = f
+    for _ in range(n_scales - 1):
+        omega = F.avg_pool2d(residual, 2)
+        sigma_omega = F.interpolate(omega, size=residual.shape[2:], mode="bilinear", align_corners=False)
+        cofibers.append(residual - sigma_omega)
+        residual = omega
+    cofibers.append(residual)
+    return cofibers
+
+
+class CofiberThresholdDim10(nn.Module):
+    name = "cofiber_threshold_dim10"
+    needs_intermediates = False
+
+    def __init__(self, feat_dim=768, bottleneck_dim=10, num_classes=80, n_scales=3, reg_hidden=16):
+        super().__init__()
+        self.n_scales = n_scales
+        self.scale_norms = nn.ModuleList([nn.LayerNorm(feat_dim) for _ in range(n_scales)])
+        self.project = nn.Linear(feat_dim, bottleneck_dim, bias=False)
+        self.cls_weight = nn.Parameter(torch.randn(num_classes, bottleneck_dim) * 0.01)
+        self.cls_bias = nn.Parameter(torch.zeros(num_classes))
+        self.reg_hidden = nn.Linear(bottleneck_dim, reg_hidden)
+        self.reg_act = nn.GELU()
+        self.reg_out = nn.Linear(reg_hidden, 4)
+        self.ctr_weight = nn.Parameter(torch.randn(1, bottleneck_dim) * 0.01)
+        self.ctr_bias = nn.Parameter(torch.zeros(1))
+        self.scale_params = nn.Parameter(torch.ones(n_scales))
+
+    def forward(self, spatial, inter=None):
+        cofibers = cofiber_decompose(spatial, self.n_scales)
+        cls_l, reg_l, ctr_l = [], [], []
+        for i, cof in enumerate(cofibers):
+            B, C, H, W = cof.shape
+            f = self.scale_norms[i](cof.permute(0, 2, 3, 1).reshape(-1, C))
+            z = self.project(f)
+            cls = (z @ self.cls_weight.T + self.cls_bias).reshape(B, H, W, -1).permute(0, 3, 1, 2)
+            reg_raw = (self.reg_out(self.reg_act(self.reg_hidden(z))) * self.scale_params[i]).clamp(-10, 10)
+            reg = torch.exp(reg_raw).reshape(B, H, W, 4).permute(0, 3, 1, 2)
+            ctr = (z @ self.ctr_weight.T + self.ctr_bias).reshape(B, H, W, 1).permute(0, 3, 1, 2)
+            cls_l.append(cls); reg_l.append(reg); ctr_l.append(ctr)
+        return cls_l, reg_l, ctr_l
+
+    def loss(self, preds, locs, boxes_b, labels_b):
+        from losses.fcos import fcos_loss
+        return fcos_loss(*preds, locs, boxes_b, labels_b)
+
+    def decode(self, preds, locs, **kw):
+        from utils.decode import decode_fcos
+        return decode_fcos(*preds, locs, **kw)
+
+    def get_locs(self, spatial):
+        from utils.decode import make_locations
+        dummy = cofiber_decompose(spatial[:1], self.n_scales)
+        sizes = [(c.shape[2], c.shape[3]) for c in dummy]
+        strides = [16 * (2 ** i) for i in range(self.n_scales)]
+        return make_locations(sizes, strides, spatial.device)

heads/cofiber_threshold/dim10_13k/svd_init.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:bfc10537d889491f549b872928d240d9756d18c30ae595d8e3a8b94f5b9c45ff
+size 35821

heads/cofiber_threshold/dim15_17k/head.py

@@ -0,0 +1,66 @@
+"""Cofiber Threshold Dim15: 768->15->80 classification. 17,751 params."""
+
+import math
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+
+def cofiber_decompose(f, n_scales):
+    cofibers = []
+    residual = f
+    for _ in range(n_scales - 1):
+        omega = F.avg_pool2d(residual, 2)
+        sigma_omega = F.interpolate(omega, size=residual.shape[2:], mode="bilinear", align_corners=False)
+        cofibers.append(residual - sigma_omega)
+        residual = omega
+    cofibers.append(residual)
+    return cofibers
+
+
+class CofiberThresholdDim15(nn.Module):
+    name = "cofiber_threshold_dim15"
+    needs_intermediates = False
+
+    def __init__(self, feat_dim=768, bottleneck_dim=15, num_classes=80, n_scales=3, reg_hidden=16):
+        super().__init__()
+        self.n_scales = n_scales
+        self.scale_norms = nn.ModuleList([nn.LayerNorm(feat_dim) for _ in range(n_scales)])
+        self.project = nn.Linear(feat_dim, bottleneck_dim, bias=False)
+        self.cls_weight = nn.Parameter(torch.randn(num_classes, bottleneck_dim) * 0.01)
+        self.cls_bias = nn.Parameter(torch.zeros(num_classes))
+        self.reg_hidden = nn.Linear(bottleneck_dim, reg_hidden)
+        self.reg_act = nn.GELU()
+        self.reg_out = nn.Linear(reg_hidden, 4)
+        self.ctr_weight = nn.Parameter(torch.randn(1, bottleneck_dim) * 0.01)
+        self.ctr_bias = nn.Parameter(torch.zeros(1))
+        self.scale_params = nn.Parameter(torch.ones(n_scales))
+
+    def forward(self, spatial, inter=None):
+        cofibers = cofiber_decompose(spatial, self.n_scales)
+        cls_l, reg_l, ctr_l = [], [], []
+        for i, cof in enumerate(cofibers):
+            B, C, H, W = cof.shape
+            f = self.scale_norms[i](cof.permute(0, 2, 3, 1).reshape(-1, C))
+            z = self.project(f)
+            cls = (z @ self.cls_weight.T + self.cls_bias).reshape(B, H, W, -1).permute(0, 3, 1, 2)
+            reg_raw = (self.reg_out(self.reg_act(self.reg_hidden(z))) * self.scale_params[i]).clamp(-10, 10)
+            reg = torch.exp(reg_raw).reshape(B, H, W, 4).permute(0, 3, 1, 2)
+            ctr = (z @ self.ctr_weight.T + self.ctr_bias).reshape(B, H, W, 1).permute(0, 3, 1, 2)
+            cls_l.append(cls); reg_l.append(reg); ctr_l.append(ctr)
+        return cls_l, reg_l, ctr_l
+
+    def loss(self, preds, locs, boxes_b, labels_b):
+        from losses.fcos import fcos_loss
+        return fcos_loss(*preds, locs, boxes_b, labels_b)
+
+    def decode(self, preds, locs, **kw):
+        from utils.decode import decode_fcos
+        return decode_fcos(*preds, locs, **kw)
+
+    def get_locs(self, spatial):
+        from utils.decode import make_locations
+        dummy = cofiber_decompose(spatial[:1], self.n_scales)
+        sizes = [(c.shape[2], c.shape[3]) for c in dummy]
+        strides = [16 * (2 ** i) for i in range(self.n_scales)]
+        return make_locations(sizes, strides, spatial.device)

heads/cofiber_threshold/dim15_17k/svd_init.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:1843641c84fb1a44e8b9e2e308b22e38ebc42f63e105464511946f8aa826ce1d
+size 52781

heads/cofiber_threshold/dim20_20k/checkpoint.pth

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:acd116819d27c1b4c8cfeece6195d6d22abe31b3382394c2af44ec509b7bf7ef
+oid sha256:4da888b1bf8d9713177831259be1dceb5cdc79e21f13ed4621927ed3bd786101
 size 94325

heads/cofiber_threshold/dim20_20k/cofiber_threshold_dim20_coco_8ep_22k.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:8a5f897f169c0ee7370f74a58766f4b717d32835c8278ad2e09d9d024801b9bc
+size 94513

heads/cofiber_threshold/dim20_20k/cofiber_threshold_dim20_coco_8ep_22k_coco_summary.json

@@ -0,0 +1,13 @@
+{
+  "head": "cofiber_threshold_dim20",
+  "params": 22076,
+  "checkpoint": "heads/cofiber_threshold/dim20_20k/cofiber_threshold_dim20_coco_8ep_22k.pth",
+  "n_images": 5000,
+  "n_detections": 499821,
+  "mAP_0.5_0.95": 0.03944936745927407,
+  "mAP_0.50": 0.1479595923539579,
+  "mAP_0.75": 0.009029135490091572,
+  "mAP_small": 0.015860738490560772,
+  "mAP_medium": 0.039767698217524725,
+  "mAP_large": 0.058431098084337586
+}

heads/cofiber_threshold/dim20_20k/head.py

@@ -64,3 +64,18 @@ class CofiberThresholdDim20(nn.Module):
             reg_l.append(reg)
             ctr_l.append(ctr)
         return cls_l, reg_l, ctr_l
+
+    def loss(self, preds, locs, boxes_b, labels_b):
+        from losses.fcos import fcos_loss
+        return fcos_loss(*preds, locs, boxes_b, labels_b)
+
+    def decode(self, preds, locs, **kw):
+        from utils.decode import decode_fcos
+        return decode_fcos(*preds, locs, **kw)
+
+    def get_locs(self, spatial):
+        from utils.decode import make_locations
+        dummy = cofiber_decompose(spatial[:1], self.n_scales)
+        sizes = [(c.shape[2], c.shape[3]) for c in dummy]
+        strides = [16 * (2 ** i) for i in range(self.n_scales)]
+        return make_locations(sizes, strides, spatial.device)

heads/cofiber_threshold/dim20_22k/svd_init.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6ec7e85396c35b2e0678220d2471286a7df583d4635b2553717fd107dd80a4b5
+size 69741

heads/cofiber_threshold/dim30_30k/head.py

@@ -0,0 +1,66 @@
+"""Cofiber Threshold Dim30: 768->30->80 classification. 30,726 params."""
+
+import math
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+
+def cofiber_decompose(f, n_scales):
+    cofibers = []
+    residual = f
+    for _ in range(n_scales - 1):
+        omega = F.avg_pool2d(residual, 2)
+        sigma_omega = F.interpolate(omega, size=residual.shape[2:], mode="bilinear", align_corners=False)
+        cofibers.append(residual - sigma_omega)
+        residual = omega
+    cofibers.append(residual)
+    return cofibers
+
+
+class CofiberThresholdDim30(nn.Module):
+    name = "cofiber_threshold_dim30"
+    needs_intermediates = False
+
+    def __init__(self, feat_dim=768, bottleneck_dim=30, num_classes=80, n_scales=3, reg_hidden=16):
+        super().__init__()
+        self.n_scales = n_scales
+        self.scale_norms = nn.ModuleList([nn.LayerNorm(feat_dim) for _ in range(n_scales)])
+        self.project = nn.Linear(feat_dim, bottleneck_dim, bias=False)
+        self.cls_weight = nn.Parameter(torch.randn(num_classes, bottleneck_dim) * 0.01)
+        self.cls_bias = nn.Parameter(torch.zeros(num_classes))
+        self.reg_hidden = nn.Linear(bottleneck_dim, reg_hidden)
+        self.reg_act = nn.GELU()
+        self.reg_out = nn.Linear(reg_hidden, 4)
+        self.ctr_weight = nn.Parameter(torch.randn(1, bottleneck_dim) * 0.01)
+        self.ctr_bias = nn.Parameter(torch.zeros(1))
+        self.scale_params = nn.Parameter(torch.ones(n_scales))
+
+    def forward(self, spatial, inter=None):
+        cofibers = cofiber_decompose(spatial, self.n_scales)
+        cls_l, reg_l, ctr_l = [], [], []
+        for i, cof in enumerate(cofibers):
+            B, C, H, W = cof.shape
+            f = self.scale_norms[i](cof.permute(0, 2, 3, 1).reshape(-1, C))
+            z = self.project(f)
+            cls = (z @ self.cls_weight.T + self.cls_bias).reshape(B, H, W, -1).permute(0, 3, 1, 2)
+            reg_raw = (self.reg_out(self.reg_act(self.reg_hidden(z))) * self.scale_params[i]).clamp(-10, 10)
+            reg = torch.exp(reg_raw).reshape(B, H, W, 4).permute(0, 3, 1, 2)
+            ctr = (z @ self.ctr_weight.T + self.ctr_bias).reshape(B, H, W, 1).permute(0, 3, 1, 2)
+            cls_l.append(cls); reg_l.append(reg); ctr_l.append(ctr)
+        return cls_l, reg_l, ctr_l
+
+    def loss(self, preds, locs, boxes_b, labels_b):
+        from losses.fcos import fcos_loss
+        return fcos_loss(*preds, locs, boxes_b, labels_b)
+
+    def decode(self, preds, locs, **kw):
+        from utils.decode import decode_fcos
+        return decode_fcos(*preds, locs, **kw)
+
+    def get_locs(self, spatial):
+        from utils.decode import make_locations
+        dummy = cofiber_decompose(spatial[:1], self.n_scales)
+        sizes = [(c.shape[2], c.shape[3]) for c in dummy]
+        strides = [16 * (2 ** i) for i in range(self.n_scales)]
+        return make_locations(sizes, strides, spatial.device)

heads/cofiber_threshold/dim30_30k/svd_init.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:2de5b79f34fac5fd500ab3180733435ebc27bb3836b3c62f129ba6022812867a
+size 103661

heads/cofiber_threshold/dim5_9k/head.py

@@ -0,0 +1,66 @@
+"""Cofiber Threshold Dim5: 768->5->80 classification. 9,101 params."""
+
+import math
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+
+def cofiber_decompose(f, n_scales):
+    cofibers = []
+    residual = f
+    for _ in range(n_scales - 1):
+        omega = F.avg_pool2d(residual, 2)
+        sigma_omega = F.interpolate(omega, size=residual.shape[2:], mode="bilinear", align_corners=False)
+        cofibers.append(residual - sigma_omega)
+        residual = omega
+    cofibers.append(residual)
+    return cofibers
+
+
+class CofiberThresholdDim5(nn.Module):
+    name = "cofiber_threshold_dim5"
+    needs_intermediates = False
+
+    def __init__(self, feat_dim=768, bottleneck_dim=5, num_classes=80, n_scales=3, reg_hidden=16):
+        super().__init__()
+        self.n_scales = n_scales
+        self.scale_norms = nn.ModuleList([nn.LayerNorm(feat_dim) for _ in range(n_scales)])
+        self.project = nn.Linear(feat_dim, bottleneck_dim, bias=False)
+        self.cls_weight = nn.Parameter(torch.randn(num_classes, bottleneck_dim) * 0.01)
+        self.cls_bias = nn.Parameter(torch.zeros(num_classes))
+        self.reg_hidden = nn.Linear(bottleneck_dim, reg_hidden)
+        self.reg_act = nn.GELU()
+        self.reg_out = nn.Linear(reg_hidden, 4)
+        self.ctr_weight = nn.Parameter(torch.randn(1, bottleneck_dim) * 0.01)
+        self.ctr_bias = nn.Parameter(torch.zeros(1))
+        self.scale_params = nn.Parameter(torch.ones(n_scales))
+
+    def forward(self, spatial, inter=None):
+        cofibers = cofiber_decompose(spatial, self.n_scales)
+        cls_l, reg_l, ctr_l = [], [], []
+        for i, cof in enumerate(cofibers):
+            B, C, H, W = cof.shape
+            f = self.scale_norms[i](cof.permute(0, 2, 3, 1).reshape(-1, C))
+            z = self.project(f)
+            cls = (z @ self.cls_weight.T + self.cls_bias).reshape(B, H, W, -1).permute(0, 3, 1, 2)
+            reg_raw = (self.reg_out(self.reg_act(self.reg_hidden(z))) * self.scale_params[i]).clamp(-10, 10)
+            reg = torch.exp(reg_raw).reshape(B, H, W, 4).permute(0, 3, 1, 2)
+            ctr = (z @ self.ctr_weight.T + self.ctr_bias).reshape(B, H, W, 1).permute(0, 3, 1, 2)
+            cls_l.append(cls); reg_l.append(reg); ctr_l.append(ctr)
+        return cls_l, reg_l, ctr_l
+
+    def loss(self, preds, locs, boxes_b, labels_b):
+        from losses.fcos import fcos_loss
+        return fcos_loss(*preds, locs, boxes_b, labels_b)
+
+    def decode(self, preds, locs, **kw):
+        from utils.decode import decode_fcos
+        return decode_fcos(*preds, locs, **kw)
+
+    def get_locs(self, spatial):
+        from utils.decode import make_locations
+        dummy = cofiber_decompose(spatial[:1], self.n_scales)
+        sizes = [(c.shape[2], c.shape[3]) for c in dummy]
+        strides = [16 * (2 ** i) for i in range(self.n_scales)]
+        return make_locations(sizes, strides, spatial.device)

heads/cofiber_threshold/dim5_9k/svd_init.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b54e557b30c91fed9365db41c9920f1a9cd69cbb047313e26e882058bffc57dc
+size 18861