argus.py: factor padding_mode through DPT blocks; add depth crop_border kwarg; batched correspond. README: align with shipped 3M cofiber detection head, drop FCOS framing, fix file sizes/param counts, add real IN1k val comparison, document qkv-bias choice. eval JSON: strip personal paths.

README.md

@@ -26,7 +26,7 @@ metrics:
 
 # Argus
 
-Argus is a multi-task perception system built on a single compact vision backbone. From one forward pass through the encoder, the model produces classification labels, semantic segmentation masks, metric depth maps, object detections with bounding boxes, and dense keypoint correspondences, thereby collapsing five domain-specific pipelines into a unified package of roughly 116 million parameters. The system is named after Argus Panoptes, the many-eyed giant of Greek mythology who was tasked by Hera with watching over everything at once.
+Argus is a multi-task perception system built on a single compact vision backbone. From one forward pass through the encoder, the model produces classification labels, semantic segmentation masks, metric depth maps, object detections with bounding boxes, and dense keypoint correspondences, collapsing five domain-specific pipelines into a unified package of roughly 103 million parameters (85.6M frozen backbone + 17.4M trained heads + buffers). The system is named after Argus Panoptes, the many-eyed giant of Greek mythology who was tasked by Hera with watching over everything at once.
 
 The underlying backbone is [EUPE-ViT-B](https://huggingface.co/facebook/EUPE-ViT-B) (86M parameters), which was introduced in *Efficient Universal Perception Encoder* (Zhu et al., Meta FAIR, [arXiv:2603.22387](https://arxiv.org/abs/2603.22387), March 2026). That paper demonstrates that a small vision encoder can be distilled from a collection of larger specialist teachers, yielding features that transfer well to image understanding, dense prediction, and vision–language tasks simultaneously. Argus takes the released EUPE-ViT-B backbone, leaves its weights frozen, and attaches five lightweight task heads that were trained or constructed independently for this project.
 
@@ -38,14 +38,14 @@ Image → EUPE-ViT-B (frozen, 86M parameters) → shared features
   ├── Classification   — trained linear softmax, 1000 ImageNet classes
   ├── Segmentation     — linear head, 150 ADE20K classes
   ├── Depth            — DPT multi-scale decoder, metric depth in meters (NYU Depth V2)
-  ├── Detection        — FCOS head with simple feature pyramid, 80 COCO classes
+  ├── Detection        — cofiber pyramid + CLIP-text-aligned cosine head, 80 COCO classes
   └── Correspondence   — training-free dense feature matching
 ```
 
 - **Classification** — trained linear softmax, a single `Linear(768, 1000)` layer with bias applied to the L2-normalized CLS token. 85.53% top-1 and 97.69% top-5 on ImageNet-1k val.
 - **Segmentation** — BatchNorm layer followed by a single 1×1 convolution, trained with the backbone held frozen throughout.
 - **Depth** — DPT (Dense Prediction Transformer) decoder hooking into four intermediate ViT layers (blocks 2, 5, 8, 11), fusing their features at four spatial scales via residual conv fusion, producing metric depth in meters via a 256-bin weighted sum over the 0.001 to 10 meter range. Improves RMSE by 8% over a linear probe on the same backbone (0.480 vs 0.520 on NYUv2 test), with abs_rel improving by 28%. Attempts to extend the depth head to outdoor scenes via mixed indoor/outdoor training with scale-and-shift invariant loss degraded indoor accuracy without producing a model that worked reliably across both domains; outdoor depth remains a known limitation.
-- **Detection** — FCOS-style anchor-free detector on a ViTDet-style simple feature pyramid that synthesizes five spatial scales (strides 8 through 128) from the backbone's stride-16 patch features, with shared four-layer convolutional towers for classification and box regression across all pyramid levels. Runs at 640-pixel input with letterbox padding; returns per-image lists of bounding boxes with class labels, confidence scores, and COCO class names.
+- **Detection** — anchor-free detector built on a parameter-free cofiber decomposition of the backbone's stride-16 spatial features (iterated downsample-then-subtract residuals at four scales, concatenated with a 64-dim sinusoidal positional embedding to give an 832-channel input). A 1x1 stem reduces to a 160-channel hidden representation; shared 9-layer cls/reg towers (5 ConvGN blocks plus 4 depthwise-residual blocks) feed three predictions per pyramid level: a CLIP-text-aligned cosine classifier with 80 frozen COCO text embeddings (`text_embed`), a learned `logit_scale` and per-class `cls_bias`, an LTRB box regressor with per-level learned scale, and a centerness branch. Runs at 768-pixel input with letterbox padding; returns per-image lists of bounding boxes with class labels, confidence scores, and COCO class names. ~3M trainable parameters.
 - **Correspondence** — no trained parameters. Source and target features are extracted from two images, upsampled to pixel resolution, and matched by cosine similarity at each source keypoint.
 
 ## Benchmarks
@@ -63,29 +63,26 @@ All four of the paper's reported benchmarks were reproduced as part of building
 
 The classification evaluation used the full 1.28-million-image ImageNet-1k training set as the kNN reference and the 50,000-image validation set as the query. The segmentation and depth heads were trained using the same linear-probe configurations described in the EUPE repository. Correspondence was evaluated on the SPair-71k test split at 512-pixel resolution across all 12,234 test pairs, for a total of 88,328 keypoints, with no failures during the run.
 
-The classification head reaches 85.53% top-1 and 97.69% top-5 on ImageNet-1k val. The kNN protocol used during the paper reproduction phase served as the baseline; the trained linear head superseded it and is the only classification method shipped in the current checkpoint.
-
-| Classification method | Top-1    | Top-5    |
-|-----------------------|----------|----------|
-| kNN (k=10, retired)   | 84.07 %  | 93.99 %  |
-| Linear softmax        | 85.53 %  | 97.69 %  |
+The shipped classification head is a trained linear softmax that reaches 85.53% top-1 and 97.69% top-5 on ImageNet-1k val. The kNN protocol shown in the EUPE-reproduction table above was the development baseline and is no longer exposed at the API level.
 
 ### Detection
 
-The EUPE paper evaluates its backbone exclusively through minimal decoders — linear probes, kNN, and training-free matching — so that downstream performance can be attributed to the learned features rather than to the capacity of the head. The paper's three evaluation domains are image understanding, dense prediction, and vision–language modeling; detection is not among them. The same frozen-backbone protocol applies: the FCOS detection head is trained on COCO 2017 train (117,266 images) at 640-pixel input while the backbone weights remain fixed.
+The EUPE paper evaluates its backbone exclusively through minimal decoders, linear probes, kNN, and training-free matching, so that downstream performance can be attributed to the learned features rather than to the capacity of the head. The paper's three evaluation domains are image understanding, dense prediction, and vision-language modeling; detection is not among them. The same frozen-backbone protocol applies: the detection head is trained on COCO 2017 train (117,266 images) at 768-pixel input while the backbone weights remain fixed.
 
 Evaluation on COCO val2017 (5,000 images) with the standard pycocotools protocol:
 
-| Metric | Value |
-|--------|-------|
-| mAP@[0.5:0.95] | **41.0** |
-| mAP@0.50 | 64.8 |
-| mAP@0.75 | 43.2 |
-| mAP (small objects) | 21.4 |
-| mAP (medium objects) | 44.9 |
-| mAP (large objects) | 62.1 |
+| Metric | Hard NMS | Soft NMS |
+|--------|---------:|---------:|
+| mAP@[0.5:0.95]      | **42.64** | **42.71** |
+| mAP@0.50            | 65.70     | 65.67     |
+| mAP@0.75            | 45.10     | 45.29     |
+| mAP (small objects) | 22.3      | 22.3      |
+| mAP (medium)        | 48.3      | 48.4      |
+| mAP (large)         | 62.9      | 63.1      |
+
+The full lineage of the cofiber-based detection head, including the analytical closed-form, evolved-circuit, dim-sweep, and person-specialist variants and the recipe ablations that took the same architecture from 24.6 to 42.64 mAP, lives in [phanerozoic/cofiber-detection](https://huggingface.co/phanerozoic/cofiber-detection).
 
-FCOS with a fully-trained ResNet-50-FPN backbone — all backbone weights learned end-to-end on COCO — achieves 39.1 mAP on the same benchmark. The frozen EUPE-ViT-B backbone reaches 41.0 mAP while sharing its features across all five task heads. The backbone was never exposed to detection data; these are the same features that produce the classification, segmentation, depth, and correspondence results above.
+Cross-domain transfer behavior on a 20-domain Roboflow 100 VL subset is recorded in `rf100vl_zero_shot_cross_domain_eval.json`: class-agnostic AR@100 averages 0.289 across the 20 domains, with the per-domain breakdown stored in the same file.
 
 ### Depth Decoder Comparison (Development Reference)
 
@@ -120,15 +117,15 @@ The Cityscapes probe reaches 63.76% mIoU, with road at 96.4%, car at 87.9%, sky
 
 ## Comparison with Standard Baselines
 
-As a sanity check, Argus was compared against several well-known models on the same 200-image COCO subset. The classification comparison uses a keyword cross-reference between each model's top-k ImageNet predictions and the COCO ground-truth detection labels on those images, which provides a consistent yardstick across differently-trained models despite the label-space mismatch. **These hit rates measure agreement with COCO detection labels via keyword matching on the 200-image subset; they are not raw ImageNet accuracy.** For reference, all three classifiers exceed 80% top-1 on the full ImageNet validation set.
+**Classification** on ImageNet-1k val (top-1 / top-5):
 
-**Classification** (hit rate against COCO detection labels, 200 images):
+| Model              | Parameters | Top-1   | Top-5   |
+|--------------------|------------|---------|---------|
+| Argus (EUPE-ViT-B) | 86 M       | 85.53%  | 97.69%  |
+| ConvNeXt-Base      | 89 M       | 83.85%  | 96.74%  |
+| ResNet50           | 26 M       | 80.86%  | 95.43%  |
 
-| Model              | Parameters | Top-1 hit | Top-5 hit | Latency | Peak VRAM |
-|--------------------|------------|-----------|-----------|---------|-----------|
-| Argus (EUPE-ViT-B) | 86 M       | 38.5%     | 61.0%     | 13.1 ms | 0.34 GB   |
-| ConvNeXt-Base      | 89 M       | 25.5%     | 48.5%     | 10.4 ms | 0.35 GB   |
-| ResNet50           | 26 M       | 23.0%     | 46.0%     | 8.4 ms  | 0.12 GB   |
+ConvNeXt-Base and ResNet50 numbers are from the [torchvision pretrained-model accuracy table](https://docs.pytorch.org/vision/main/models.html) (`ConvNeXt_Base_Weights.IMAGENET1K_V1`, `ResNet50_Weights.IMAGENET1K_V2`). Argus is evaluated on the same 50,000-image ImageNet-1k validation set with center-crop preprocessing.
 
 **Segmentation**:
 
@@ -154,12 +151,12 @@ The models chosen for this comparison were selected to match the quality tier of
 
 | Pipeline | Parameters | Latency per image | Tasks |
 |----------|-----------|-------------------|-------|
-| Argus unified | 116 M | 56 ms | 5 (classify, segment, depth, detect, correspond) |
+| Argus unified | 103 M | 56 ms | 5 (classify, segment, depth, detect, correspond) |
 | Four separate models | 260 M | 68 ms | 4 (classify, segment, depth, detect) |
 
-The per-model breakdown for the separate pipeline is ConvNeXt-Base at 6 ms, SegFormer-B3 at 19 ms, Depth-Anything-V2-Base at 31 ms, and YOLO26l at 12 ms, summing to 68 ms when the tasks are run sequentially on the same image. Argus completes five tasks — the same four plus keypoint correspondence, which the separate pipeline does not attempt — in 56 ms from a single model load. The total parameter count for the separate pipeline is 260M across four independent weight sets, while Argus carries 116M in a single file.
+The per-model breakdown for the separate pipeline is ConvNeXt-Base at 6 ms, SegFormer-B3 at 19 ms, Depth-Anything-V2-Base at 31 ms, and YOLO26l at 12 ms, summing to 68 ms when the tasks are run sequentially on the same image. Argus completes five tasks, the same four plus keypoint correspondence which the separate pipeline does not attempt, in 56 ms from a single model load. The total parameter count for the separate pipeline is 260M across four independent weight sets, while Argus carries 103M in a single file.
 
-The throughput advantage comes from the shared backbone. Each of the four separate models pays the cost of encoding the image through its own network before producing task-specific output. Argus encodes the image once through EUPE-ViT-B and then routes the resulting features to five lightweight heads, each of which adds only a few milliseconds on top of the shared representation. The backbone forward pass is the dominant cost in both pipelines, and running it once rather than four times is where the 1.2x throughput improvement and 2.2x parameter reduction originate. The practical consequence for deployment is that Argus requires a single model download (447 MB), a single checkpoint load into VRAM (0.53 GB), and a single Python import, where the equivalent separate-model pipeline requires four downloads totaling over a gigabyte, four loads consuming over a gigabyte of VRAM if held concurrently, and four separate dependency trees to manage.
+The throughput advantage comes from the shared backbone. Each of the four separate models pays the cost of encoding the image through its own network before producing task-specific output. Argus encodes the image once through EUPE-ViT-B and then routes the resulting features to five lightweight heads, each of which adds only a few milliseconds on top of the shared representation. The backbone forward pass is the dominant cost in both pipelines, and running it once rather than four times is where the 1.2x throughput improvement and 2.2x parameter reduction originate. The practical consequence for deployment is that Argus requires a single model download (334 MB), a single checkpoint load into VRAM (0.53 GB), and a single Python import, where the equivalent separate-model pipeline requires four downloads totaling over a gigabyte, four loads consuming over a gigabyte of VRAM if held concurrently, and four separate dependency trees to manage.
 
 ## Usage
 
@@ -176,7 +173,7 @@ top5   = model.classify(image, top_k=5)                  # trained linear softma
 seg    = model.segment(image)                            # returns [H, W] class indices
 depth  = model.depth(image)                              # returns [H, W] metric depth in meters
 
-# Detection runs at 640px with letterbox padding:
+# Detection runs at 768px with letterbox padding:
 dets   = model.detect(image, score_thresh=0.3)
 # returns list of {"box": [x1,y1,x2,y2], "score": float, "label": int, "class_name": str}
 
@@ -230,7 +227,7 @@ paths = model.export_onnx("/path/to/out_dir", backbone_resolution=224, verify=Tr
 # paths["verification"] — max abs diff per component
 ```
 
-Classification (kNN over class prototypes) and correspondence run as post-processing on top of the backbone output and need no separate graph.
+Correspondence has no learned parameters and runs as cosine-max on the backbone's spatial output, so it needs no separate graph.
 
 For reduced VRAM on memory-constrained hardware, INT8 weight-only quantization is available via torchao. This quantizes the Linear weight matrices to INT8 while keeping activations in BF16, avoiding the outlier-channel problems that break naive INT8 quantization of ViT models:
 
@@ -263,12 +260,11 @@ The backbone is frozen for every task. Only the task heads are trained, and the
 | EUPE-ViT-B backbone       | LVD-1689M (approximately 1.7 billion web images)         | Meta FAIR (used here frozen)                                |
 | Segmentation head         | ADE20K (20,210 training images, 2,000 validation images) | This repository, 40,000 iterations of linear-probe training |
 | Depth head                | NYU Depth V2 (24,231 training images)                    | This repository, 38,400 iterations of linear-probe training |
-| Class prototypes (kNN)    | ImageNet-1k (1.28 million training images)               | This repository, mean CLS feature per class                 |
 | Linear softmax classifier | ImageNet-1k (1.28 million training images)               | This repository, SGD over cached frozen features            |
-| Detection head            | COCO 2017 (117,266 training images, 80 classes)          | This repository, FCOS with simple FPN, 8 epochs at 640px   |
+| Detection head            | COCO 2017 (117,266 training images, 80 classes)          | This repository, cofiber pyramid + CLIP-text-aligned cosine classifier, frozen text embeddings |
 | Correspondence            | None (training-free)                                     | —                                                           |
 
-The trainable heads sum to approximately 30.5M parameters (seg 117K + depth DPT 13.45M + linear classifier 769K + detection 16.14M). The unified `model.safetensors` is 443 MB.
+The trainable heads sum to approximately 17.4M parameters (seg 117K + depth DPT 13.45M + linear classifier 769K + detection 3.04M). The unified `model.safetensors` is 412 MB.
 
 ### Precision variants
 
@@ -276,22 +272,24 @@ Two safetensors files with the same weights at different on-disk precision. Infe
 
 | File | Size | Load |
 |---|---|---|
-| `model.safetensors` | 334 MB | `AutoModel.from_pretrained("phanerozoic/argus", trust_remote_code=True)` |
-| `model.bf16_backbone.safetensors` | 170 MB | `AutoModel.from_pretrained("phanerozoic/argus", trust_remote_code=True, variant="bf16_backbone")` |
+| `model.safetensors` | 412 MB | `AutoModel.from_pretrained("phanerozoic/argus", trust_remote_code=True)` |
+| `model.bf16_backbone.safetensors` | 241 MB | `AutoModel.from_pretrained("phanerozoic/argus", trust_remote_code=True, variant="bf16_backbone")` |
 
 Both files load into the same FP32 model in memory; PyTorch automatically upcasts the bfloat16 stored weights at construction time. The smaller variant saves download bandwidth and disk space but does not reduce inference VRAM.
 
 ### Architecture details
 
-**Segmentation head** is `BatchNorm2d(768) → Conv2d(768, 150, 1×1)` — 116,886 parameters, 1.4 MB on disk. Trained at 512×512 with cross-entropy loss, AdamW (lr 1e-3, weight decay 1e-3), WarmupOneCycleLR with 1500-step warmup, batch size 16.
+**Backbone** is the 86M-parameter EUPE-ViT-B with a deliberate simplification: `qkv_bias` is set to `False` and `mask_k_bias` is set to `False`. The upstream EUPE-ViT-B release shipped a `qkv.bias_mask` buffer that is identically zero across all attention blocks, which makes the effective qkv bias zero everywhere through `masked_bias = bias * 0 = 0`. Argus drops the bias parameter entirely so the computation is bit-equivalent in fp32. The bf16 output drift this introduces is sub-ULP and is absorbed by every head except the DPT depth decoder, where it surfaces as roughly 2 cm of noise against a 0.39 m RMSE (well below the depth head's own metric floor). The Argus-Lite (ViT-S) variant uses the same `qkv_bias=False` setting; the Argus-Edge (ViT-T) variant restores `qkv_bias=True` and `mask_k_bias=True` because the upstream EUPE-ViT-T release ships a non-trivial bias and bias-mask, neither of which can be folded away.
+
+**Segmentation head** is `BatchNorm2d(768) → Conv2d(768, 150, 1×1)`, 116,886 parameters, 1.4 MB on disk. Trained at 512×512 with cross-entropy loss, AdamW (lr 1e-3, weight decay 1e-3), WarmupOneCycleLR with 1500-step warmup, batch size 16.
 
 **Depth head** is a DPT multi-scale decoder that hooks into backbone blocks [2, 5, 8, 11] via PyTorch forward hooks, capturing intermediate representations without modifying the backbone. A reassemble stage projects each block's output from 768 to 256 channels via LayerNorm + Linear, reshapes to spatial grids, and rescales to four target strides (4, 8, 16, 32) via bilinear interpolation. A bottom-up fusion path combines these four scales through residual conv blocks with skip connections, progressively doubling spatial resolution from stride 32 to stride 2. A final conv head produces 256 depth-bin logits, outputting metric depth in meters via a bin-weighted sum. 13,450,000 parameters, ~51 MB on disk. Trained at 416×416 with SILog loss, AdamW (lr 1e-4, weight decay 1e-3), cosine schedule with 3% warmup, batch size 16, 38,400 iterations.
 
-**Class prototypes (kNN path)** are produced by running the frozen backbone over the full ImageNet-1k training set at 224×224 resolution, computing the mean L2-normalized CLS feature per class, and saving the resulting 1000×768 matrix. No training, just feature extraction. At inference, the kNN path normalizes the query CLS token and computes cosine similarity against the prototype matrix.
+**Linear softmax classifier** is a single `Linear(768, 1000)` layer with bias, 769,000 parameters, about 3 MB on disk. Trained as a two-pass job: first the frozen backbone is run over the ImageNet-1k training set to cache a per-image CLS feature tensor (1,281,167 × 768, stored once at ~3.9 GB), then the linear layer is trained on the cached features alone. The training pass uses SGD with momentum 0.9, weight decay 0, batch size 4096, cosine schedule, 100 epochs, no augmentation, and the best checkpoint by validation top-1 is restored at the end. A small learning-rate sweep over `{0.5, 1.0, 3.0, 10.0, 30.0}` selects the best configuration; the L2-normalized CLS features and zero-initialized weights demand an unusually large learning rate to grow the weight scale to the point where softmax distributions become sharp. The best run used lr = 30.0 and produced 85.53% top-1 / 97.69% top-5 on ImageNet-1k val.
 
-**Linear softmax classifier** is a single `Linear(768, 1000)` layer with bias — 769,000 parameters, about 3 MB on disk. Trained as a two-pass job: first the frozen backbone is run over the ImageNet-1k training set to cache a per-image CLS feature tensor (1,281,167 × 768, stored once at ~3.9 GB), then the linear layer is trained on the cached features alone. The training pass uses SGD with momentum 0.9, weight decay 0, batch size 4096, cosine schedule, 100 epochs, no augmentation, and the best checkpoint by validation top-1 is restored at the end. A small learning-rate sweep over `{0.5, 1.0, 3.0, 10.0, 30.0}` selects the best configuration; the L2-normalized CLS features and zero-initialized weights demand an unusually large learning rate to grow the weight scale to the point where softmax distributions become sharp. The best run used lr = 30.0 and produced 85.53% top-1 / 97.69% top-5 on ImageNet-1k val, beating the kNN protocol on both metrics.
+**Detection head** is an anchor-free per-pixel detector built on a parameter-free cofiber decomposition of the backbone's stride-16 spatial features. The cofiber decomposition iterates an avg-pool then bilinear-upsample-and-subtract residual at four scales (a Rocq/HoTT machine-checked exact decomposition in a semi-additive category, see `phanerozoic/cofiber-detection/CofiberDecomposition.v`), giving frequency-separated bands at strides 16, 32, 64, and 128 with no learned parameters and no FPN. Each band is concatenated with a 64-dim sinusoidal positional embedding (832-channel input per scale), passed through a per-scale GroupNorm and a shared 1x1 stem to 160 hidden channels; top-down lateral fusion combines coarser bands into finer ones, and a single stride-2 transposed convolution synthesizes the stride-8 P3 level from the stride-16 band. Each of the five resulting pyramid levels (strides 8, 16, 32, 64, 128) goes through split classification and regression towers, each tower being five standard 3x3 conv blocks (Conv3x3 + GroupNorm + activation) followed by four depthwise-residual blocks. The classifier projects the 160-dim tower output to a 768-dim space via `cls_project` and scores via cosine similarity against a frozen 80x768 `text_embed` matrix of COCO class names encoded with a CLIP ViT-L/14 8-prompt average; a learned `logit_scale` and per-class `cls_bias` sharpen the scores. The regressor predicts LTRB distances exponentiated with a per-level learned scale, and a centerness branch gates final scores. 2,975,067 parameters, 11.4 MB on disk.
 
-**Detection head** is an FCOS-style anchor-free detector on a ViTDet-style simple feature pyramid. The FPN takes the backbone's stride-16 spatial features and synthesizes five levels: P3 (stride 8, via transposed convolution), P4 (stride 16, identity with channel reduction), P5 (stride 32), P6 (stride 64), and P7 (stride 128), each with 256 channels and GroupNorm normalization. Two shared four-layer convolutional towers (classification and regression) with GroupNorm and GELU process each level, followed by three prediction heads: 80 classification channels, 4 box regression channels (left/top/right/bottom distances, exponentiated with learned per-level scale), and 1 centerness channel. 16,138,074 parameters total, 61.6 MB on disk. Trained at 640×640 with letterbox padding, focal loss (alpha 0.25, gamma 2.0) for classification, GIoU loss for boxes, BCE for centerness, AdamW (lr 1e-3, weight decay 1e-4), cosine schedule with 3% warmup, batch size 64, 8 epochs.
+Trained on COCO 2017 at 768x768 with letterbox padding for 16 epochs at batch 64, AdamW (lr 1e-3, weight decay 1e-4) cosine schedule with 3% warmup, ATSS target assignment, horizontal-flip augmentation, EMA decay 0.9998, and a `cls_project` initialized with the principal components of the text embedding (first 80 columns from the SVD of `text_embed`, remaining 80 columns a random orthogonal complement). After the main run, a 3-epoch partial fine-tune updates only `cls_project`, `cls_bias`, and `logit_scale` at lr 1e-4 with the towers and the cofiber path frozen, picking up +0.15 mAP. The 24.6 to 42.64 mAP path was entirely recipe and resolution: hidden width actually went down (192 to 160), and the cofiber decomposition itself never changed.
 
 **Correspondence** has no learned parameters. At inference time, dense patch features are extracted from both images, upsampled to 512×512 pixel resolution, and matched by cosine similarity per source keypoint.
 
@@ -301,9 +299,8 @@ Both files load into the same FP32 model in memory; PyTorch automatically upcast
 |------------------------------|---------------------------|-------------|
 | Segmentation (ADE20K)        | 40,000                    | ~5 hours    |
 | Depth (NYU Depth V2)         | 38,400                    | ~3 hours    |
-| Class prototypes (IN1k)      | 1.28M images, single pass | ~45 minutes |
-| Linear classifier (IN1k)     | 100 epochs × 313 steps    | ~25 seconds (on cached features, extraction amortized with the kNN prototype pass) |
-| Detection (COCO 2017)        | 8 epochs × 1,832 batches  | ~6 hours at batch 64, 640px, FP32, frozen backbone                                 |
+| Linear classifier (IN1k)     | 100 epochs × 313 steps    | ~25 seconds on cached features held on GPU; ~45 minutes for the one-shot feature extraction pass over the full 1.28M training set if the cache is not already on disk |
+| Detection (COCO 2017)        | 8 epochs × 1,832 batches  | ~6 hours at batch 64, 768px, FP32, frozen backbone                                 |
 | DPT depth decoder (NYUv2)    | 38,400 iterations         | ~5.3 hours at batch 16, 416px, SILog loss, frozen backbone |
 | Correspondence (SPair)       | training-free             | —           |
 
@@ -311,11 +308,11 @@ Training was done on a single 48 GB workstation GPU. Peak VRAM was approximately
 
 ### Why minimal heads
 
-The segmentation and classification heads follow the EUPE paper's evaluation principle: a minimal decoder isolates the backbone's contribution from the head's capacity. A Mask2Former-style segmentation head would produce higher mIoU, but those numbers would reflect the decoder as much as the features. The depth and detection heads are heavier. The DPT decoder fuses features from four intermediate ViT layers at multiple spatial scales; the FCOS head synthesizes a five-level feature pyramid from the backbone's stride-16 output. Depth requires multi-scale fusion to capture spatial gradients across a scene, and detection requires a feature pyramid to resolve objects that range from a dozen pixels to the full image. In both cases the backbone remains frozen and only the head is trained.
+The segmentation and classification heads follow the EUPE paper's evaluation principle: a minimal decoder isolates the backbone's contribution from the head's capacity. A Mask2Former-style segmentation head would produce higher mIoU, but those numbers would reflect the decoder as much as the features. The depth and detection heads are heavier. The DPT decoder fuses features from four intermediate ViT layers at multiple spatial scales; the cofiber detection head builds a five-level pyramid (strides 8 through 128) from the backbone's stride-16 output via a parameter-free decomposition rather than a learned FPN. Depth requires multi-scale fusion to capture spatial gradients across a scene, and detection requires a feature pyramid to resolve objects that range from a dozen pixels to the full image. In both cases the backbone remains frozen and only the head is trained.
 
 ## Notes
 
-The segmentation head was trained on ADE20K's 150-class indoor-and-urban label space. The depth head was trained on NYU Depth v2 and is indoor-biased; outdoor metric depth should be treated as approximate. The detection head was trained on COCO 2017's 80-class label space at 640-pixel input; small-object detection (mAP 21.4) is the expected weakness because the stride-8 P3 level can only resolve objects roughly 12 pixels and larger at that resolution. Classification uses a trained linear softmax classifier that produces calibrated probabilities and reaches 85.53% top-1 on ImageNet-1k val.
+The segmentation head was trained on ADE20K's 150-class indoor-and-urban label space. The depth head was trained on NYU Depth v2 and is indoor-biased; outdoor metric depth should be treated as approximate. The detection head was trained on COCO 2017's 80-class label space at 768-pixel input; small-object detection is the expected weakness because the stride-8 P3 level can only resolve objects roughly 14 pixels and larger at that resolution. Classification uses a trained linear softmax classifier that produces calibrated probabilities and reaches 85.53% top-1 on ImageNet-1k val.
 
 ## License
 

argus.py

@@ -1427,11 +1427,19 @@ N_PREFIX_TOKENS = 5  # 1 CLS + 4 register/storage tokens
 
 
 class _ResidualConvUnit(nn.Module):
-    def __init__(self, dim: int):
+    """Two 3x3 conv + BatchNorm blocks with a residual connection. Padding
+    mode is configurable: the Argus-B DPT depth head trains with reflect
+    padding to avoid edge artifacts; Argus-Lite ships weights that were
+    trained with zero padding (the PyTorch default), and switching pad
+    modes at inference would create a small distribution shift in the
+    edge regions. Variants pass `padding_mode` to keep their inference
+    aligned with their training."""
+
+    def __init__(self, dim: int, padding_mode: str = "reflect"):
         super().__init__()
-        self.conv1 = nn.Conv2d(dim, dim, 3, padding=1, padding_mode="reflect", bias=False)
+        self.conv1 = nn.Conv2d(dim, dim, 3, padding=1, padding_mode=padding_mode, bias=False)
         self.bn1 = nn.BatchNorm2d(dim)
-        self.conv2 = nn.Conv2d(dim, dim, 3, padding=1, padding_mode="reflect", bias=False)
+        self.conv2 = nn.Conv2d(dim, dim, 3, padding=1, padding_mode=padding_mode, bias=False)
         self.bn2 = nn.BatchNorm2d(dim)
         self.act = nn.GELU()
 
@@ -1440,10 +1448,10 @@ class _ResidualConvUnit(nn.Module):
 
 
 class _FeatureFusionBlock(nn.Module):
-    def __init__(self, dim: int, has_skip: bool = True):
+    def __init__(self, dim: int, has_skip: bool = True, padding_mode: str = "reflect"):
         super().__init__()
-        self.rcu1 = _ResidualConvUnit(dim)
-        self.rcu2 = _ResidualConvUnit(dim)
+        self.rcu1 = _ResidualConvUnit(dim, padding_mode=padding_mode)
+        self.rcu2 = _ResidualConvUnit(dim, padding_mode=padding_mode)
         self.skip_proj = nn.Conv2d(dim, dim, 1) if has_skip else None
 
     def forward(self, x: Tensor, skip: Optional[Tensor] = None) -> Tensor:
@@ -1757,7 +1765,18 @@ class Argus(PreTrainedModel):
         return [seg_maps[i] for i in range(len(images))]
 
     @torch.inference_mode()
-    def depth(self, image_or_images, resolution: int = 416, return_confidence: bool = False):
+    def depth(self, image_or_images, resolution: int = 416, return_confidence: bool = False,
+              crop_border: bool = False):
+        """Run the DPT depth decoder. Returns metric depth in meters at the
+        input resolution.
+
+        ``crop_border=True`` strips a small border (``max(4, H/13)`` pixels per
+        side) from the raw decoder output before bilinear-upsampling to the
+        input resolution. Useful when this model is loaded with a backbone
+        whose DPT decoder was trained with zero padding (the unshipped
+        dev-fork behaviour), which leaves a systematic edge artifact. The
+        canonical checkpoint uses reflect padding inside every DPT conv and
+        does not need this crop, so the option defaults to ``False``."""
         single, images = _normalize_image_input(image_or_images)
         transform = make_eupe_transform(resolution)
         batch = torch.stack([transform(img) for img in images]).to(self.device)
@@ -1790,6 +1809,11 @@ class Argus(PreTrainedModel):
             depth_b = self.depth_head(inter_list, H, W)
             std_b = None
 
+        if crop_border:
+            crop = max(4, depth_b.shape[2] // 13)
+            depth_b = depth_b[:, :, crop:-crop, crop:-crop]
+            if std_b is not None:
+                std_b = std_b[:, :, crop:-crop, crop:-crop]
         depth_b = F.interpolate(depth_b, size=(resolution, resolution), mode="bilinear", align_corners=False)
         if std_b is not None:
             std_b = F.interpolate(std_b, size=(resolution, resolution), mode="bilinear", align_corners=False)
@@ -1809,34 +1833,62 @@ class Argus(PreTrainedModel):
     @torch.inference_mode()
     def correspond(
         self,
-        src_image: Image.Image,
-        tgt_image: Image.Image,
+        src_image,
+        tgt_image,
         resolution: int = 512,
     ):
         """Dense patch correspondence between two images.
 
-        Returns a dict with keys `matches` (numpy array of length grid*grid mapping
-        each source patch to its argmax target patch), `scores` (cosine similarity
-        at the match), and `grid` (the patch-grid side length).
+        Single-pair form: pass two `PIL.Image` instances. Returns a dict with
+        keys `matches` (numpy array of length grid*grid mapping each source
+        patch to its argmax target patch), `scores` (cosine similarity at the
+        match), and `grid` (the patch-grid side length).
+
+        Batched form: pass two equally-sized lists/iterables of images. Returns
+        a list of per-pair dicts in the same shape that a single call would
+        produce. Both lists are forwarded through the backbone in two
+        contiguous batches, so cross-pair throughput on GPU is much higher
+        than calling `correspond` in a loop.
         """
+        single = isinstance(src_image, Image.Image) and isinstance(tgt_image, Image.Image)
+        if single:
+            srcs = [src_image]
+            tgts = [tgt_image]
+        else:
+            srcs = list(src_image)
+            tgts = list(tgt_image)
+            if len(srcs) != len(tgts):
+                raise ValueError(
+                    f"src_image and tgt_image must have the same length; "
+                    f"got {len(srcs)} and {len(tgts)}")
+            if not srcs:
+                raise ValueError("empty image list")
+            for i, (a, b) in enumerate(zip(srcs, tgts)):
+                if not isinstance(a, Image.Image) or not isinstance(b, Image.Image):
+                    raise TypeError(f"pair {i} must contain two PIL.Image instances")
+
         transform = make_eupe_transform(resolution)
-        src_t = transform(src_image).unsqueeze(0).to(self.device)
-        tgt_t = transform(tgt_image).unsqueeze(0).to(self.device)
+        src_batch = torch.stack([transform(img) for img in srcs]).to(self.device)
+        tgt_batch = torch.stack([transform(img) for img in tgts]).to(self.device)
 
         with torch.autocast(self.device.type, dtype=torch.bfloat16, enabled=self.device.type == "cuda"):
-            oa = self.backbone.forward_features(src_t)
-            ob = self.backbone.forward_features(tgt_t)
-        pa = F.normalize(oa['x_norm_patchtokens'].float().squeeze(0), dim=-1)
-        pb = F.normalize(ob['x_norm_patchtokens'].float().squeeze(0), dim=-1)
-        sim = pa @ pb.t()
-        m = sim.argmax(dim=-1)
-        s = sim.max(dim=-1).values
-        grid = int(np.sqrt(pa.shape[0]))
-        return {
-            "matches": m.cpu().numpy(),
-            "scores": s.cpu().numpy(),
-            "grid": grid,
-        }
+            oa = self.backbone.forward_features(src_batch)
+            ob = self.backbone.forward_features(tgt_batch)
+        pa_batch = F.normalize(oa['x_norm_patchtokens'].float(), dim=-1)
+        pb_batch = F.normalize(ob['x_norm_patchtokens'].float(), dim=-1)
+
+        results = []
+        for pa, pb in zip(pa_batch, pb_batch):
+            sim = pa @ pb.t()
+            m = sim.argmax(dim=-1)
+            s = sim.max(dim=-1).values
+            grid = int(np.sqrt(pa.shape[0]))
+            results.append({
+                "matches": m.cpu().numpy(),
+                "scores": s.cpu().numpy(),
+                "grid": grid,
+            })
+        return results[0] if single else results
 
     @torch.inference_mode()
     def detect(

rf100vl_zero_shot_cross_domain_eval.json

@@ -1,14 +1,15 @@
 {
   "picker": {
-    "path": "/mnt/d/detection-heads/heads/cofiber_threshold/split_tower_5scale_160h_5std_4dw_ema_l14_16ep_768_cls_calib/checkpoint_final.pth",
+    "head": "argus_text_aligned_detection_head",
+    "config": "split_tower_5scale_160h_5std_4dw_ema_l14_16ep_768_cls_calib",
     "n_params": 2975067,
     "text_embed_dim": 768
   },
   "fcos": {
-    "path": "/mnt/d/_tmp/argus_fcos_head.pth",
+    "head": "argus_fcos_detection_head",
     "n_params": 16138074
   },
-  "cache_dir": "/home/zootest/datasets/rf100vl_val_cache_768",
+  "cache_dir": "rf100vl_val_cache_768",
   "resolution": 768,
   "score_thresh": 0.05,
   "max_per_image": 100,