wikillm

Paper · 2022-12-16 · cs.CV

One-Stage Cascade Refinement Networks for Infrared Small Target Detection

OSCAR detects single-frame infrared small targets with a one-stage, anchor-free head on two feature levels (P2 and P3). A pseudo-box label assignment gives tiny targets positive points. The coarse head modulates the fine head's scores and supplies boxes it refines. A normalized-contrast branch scores localisation quality. Author-reported mNoCoAP 85.2 on SIRST-V2 (FCOS 73.1).

Object detectionAnchor-free detectionLabel assignmentProposal refinementinfraredsmall-object-detectionlabel-assignmentcascade-refinement

arXivPDFCodeMarkdown19 min read

AI-compiled by claude-haiku-5-5 on 2026-11-13, not yet reviewed by a human. Every claim cites its source; check it when a detail matters.

In plain words

Infrared cameras often see a faraway object as only a few pixels: a faint blob with no shape or texture. Object detectors work on grids of feature values, and a coarse grid can have no cell that lands inside such a small box. The detector then never learns that the blob is there, so it misses it.

OSCAR changes two things. First, when it decides which grid cells should detect a target, it uses a slightly enlarged square around the target, so at least some cells always count. Second, it stacks two detection layers in a coarse-to-fine order. The coarse layer makes a rough guess of where the target is, and it tells the fine layer how confident it is, so the fine layer can drop background look-alikes. The fine layer then tightens the box around the coarse guess. A third small branch predicts how well a box is centred on the target, so off-centre boxes lose out when duplicates are removed.

The point of the design is accuracy on small targets without giving up the speed of a one-stage detector.

TL;DR

  • One-stage, anchor-free detector for single-frame infrared small targets, on the P2 and P3 levels of a feature pyramid §IV fig. 6.
  • Pseudo-box label assignment makes targets smaller than the feature stride trainable §IV.A eq. 2.
  • The coarse head's predictions modulate the fine head's scores and seed its box regression §IV.B.
  • Author-reported mNoCoAP 85.2 on SIRST-V2 against 73.1 for FCOS and 80.1 for QueryDet tab. IX.
  • Code is public under Apache-2.0, but several details in the code differ from the paper; see Paper vs code.

Problem

Object detectors assign a training label to a feature cell when the target's box covers that cell. For a target smaller than the stride of the layer, the box may cover no cell at all, so the target is labelled as background and the detector learns to ignore it §I §IV.A fig. 5. Infrared small targets are typically about 2 to 12 pixels across §IV.A.

Small boxes also make box regression and the usual IoU score fragile. A one-pixel shift can change IoU a lot, so the authors argue the ground truth is ambiguous and IoU is a poor measure of localisation here §I §III.B fig. 3. Their evaluation metric (mNoCoAP, below) replaces IoU with a normalized-contrast score.

Segmentation-based methods, which the paper says dominate this task, need high-resolution maps and are computationally expensive. The authors argue detection is the better formulation §I.

Assumptions: single-frame images from SIRST-V2 §III.A. The paper's example resize for deep methods is (1000, 600) §V.C, and the config uses one class at that size oscar_w_noco_head_r18_caffe_fpn_p2_gn-head_1x_sirst_det2noco.py oscar_w_noco_head_r18_caffe_fpn_p2_gn-head_1x_sirst_det2noco.py.

Method

Section, equation, table and figure numbers follow the paper's printed IEEE numbering (Roman for sections and tables, Arabic for equations and figures). Section III is the paper's DeepInfrared/SIRST-V2 section, and its equation (1) defines normalized contrast.

Overview. A backbone with a feature pyramid produces P2 (stride 4) and P3 (stride 8) maps §IV fig. 6. The depth ablation favours ResNet-18 §V.B.6 tab. VII. The P3 map feeds a coarse head that predicts a class score and a box at each point. A top-down weight computed from the coarse features then modulates the P2 class scores (§IV.B.1, eqs. 3 and 4). The P2 head regresses boxes starting from the upsampled coarse boxes (§IV.B.2, eqs. 5 and 6). A third branch on the P2 map predicts a normalized-contrast quality map (§IV.C). Training labels come from the pseudo-box rule (§IV.A, eq. 2) and the NoCo target map comes from the ground-truth boxes (§III.B, eq. 1).

Step 1: pseudo-box label assignment §IV.A eq. 2. For a layer with stride s, a ground-truth box is kept as is when its area exceeds p squared. Otherwise it is replaced by a p-by-p box with the same centre. The paper requires p to be at least s. With p equal to s, each target gets at least one positive point; a larger p gives more positives and more low-quality boxes §IV.A. The paper's ablation chooses p = 1.5 s §V.B.1 tab. II.

Step 2: coarse soft proposal §IV.B. The coarse head is a one-stage head on the high-level map. It gives a class score and a box at each point. The paper treats these boxes as learnable anchors for the fine head §IV.B.2.

Step 3: top-down score modulation §IV.B.1 [eqs. 3, 4]. The coarse features are upsampled to the fine grid and passed through two 3-by-3 convolutions with a ReLU in between, then a sigmoid. The output is a weight in (0, 1) per point and class. The paper multiplies this weight into the fine features before the fine classification convolution and applies a sigmoid. The paper's convolution widths are C/4 and C, where C is the feature channel count §IV.B.1. The code does something different (see Paper vs code).

Step 4: top-down cascaded regression §IV.B.2 [eqs. 5, 6]. The coarse box is upsampled to the fine grid and used as the reference box. The fine head regresses four offsets from the concatenation of the upsampled coarse features and the fine features. Each offset is measured from the reference edge and divided by the fine stride s (eq. 5). At inference the offsets are multiplied back by s and added to the reference box. The paper names the upsampling operation "Up" but does not say which interpolation it uses.

Step 5: normalized contrast branch §IV.C eq. 7. The fine head has one more convolutional output, a per-point quality map trained against the NoCo target from §III.B. Its loss is a quality focal loss, which the paper names but does not write out §IV.C. The paper says this suppresses low-quality boxes created by the enlarged pseudo boxes, and the ablation supports this §V.B.5 tab. VI.

Normalized-contrast target §III.B eq. 1. For each ground-truth box the paper defines a region R that extends the box by a multiple of its own height and width on each side. Inside R, the local contrast is the pixel value minus the region minimum. The contrast is multiplied by a Gaussian centred on the box, and the product is rescaled to [0, 1]. Pixels outside R are set to 0.

Loss §IV.C eq. 7. The loss sums four terms and a weighted fifth:

  • coarse focal classification, divided by the number of coarse positives;
  • coarse box loss on coarse positives (the paper calls it an IoU loss);
  • fine focal classification, divided by the number of fine positives;
  • fine box loss on fine positives (the paper calls it an IoU loss);
  • lambda times the normalized-contrast quality loss.

Inference §IV.C. The predicted normalized-contrast map is combined with the two class scores to give each detection a final score. The paper says the NoCo map lowers the score of boxes far from the target centre. It does not give the formula or the non-maximum-suppression threshold.

Pseudocode
# All-scale pseudo-box assignment for one layer  [§IV.A] [eq. 2]
# boxes: (N, 4) ground truth as x0, y0, x1, y1 in input pixels
# p: pseudo-box side, p >= stride of the layer (paper: p = 1.5 s)
def pseudo_boxes(boxes, p):
    # Box centres, kept unchanged by the replacement  [eq. 2]
    centres = (boxes[:, :2] + boxes[:, 2:]) / 2
    # Box area h * w  [eq. 2]
    areas = (boxes[:, 2] - boxes[:, 0]) * (boxes[:, 3] - boxes[:, 1])
    # Boxes whose area is not above p^2 get replaced  [eq. 2]
    replace = areas <= p * p
    # p-by-p square around each centre  [eq. 2]
    squares = concat(centres - p / 2, centres + p / 2, axis=1)
    return where(replace[:, None], squares, boxes)
Pseudocode
# Normalized-contrast target for one ground-truth box  [§III.B] [eq. 1]
# image: (H, W) grey values; box: x0, y0, x1, y1 in pixels
def noco_target(image, box):
    # Region R: the box grown by its own height and width on each side  [§III.B]
    region = grow_box(box, extend_h=box_h, extend_w=box_w)
    # Local contrast: region values minus the region minimum  [§III.B]
    contrast = image[region] - min(image[region])
    # Gaussian weight that prefers the centre; sigma is not stated  [eq. 1]
    weight = gaussian(distance_to_centre(region), sigma=sigma)
    # Multiply, then rescale the product to [0, 1]  [eq. 1]
    product = contrast * weight
    noco = (product - min(product)) / (max(product) - min(product))
    # Pixels outside region R are 0  [§III.B]
    return place(noco, region, background=0)
Pseudocode
# OSCAR forward for one image  [§IV.B] [eqs. 3-6]
# fine: P2 features (C, H/4, W/4); coarse: P3 features (C, H/8, W/8)
def oscar_forward(fine, coarse):
    # Coarse soft proposal: class logits and boxes at each P3 point  [§IV.B]
    coarse_logits, coarse_boxes, coarse_feat = coarse_head(coarse)
    # Upsample coarse features to the fine grid  [§IV.B.1]
    up_coarse = upsample(coarse_feat, size=fine.shape)
    # Top-down weight, two convolutions with ReLU, then sigmoid  [eq. 3]
    weight = sigmoid(conv_2(relu(conv_1(up_coarse))))  # (C, H/4, W/4)
    # Fine class scores, with the weight applied to the features  [eq. 4]
    fine_scores = sigmoid(conv_cls(weight * fine))
    # Coarse boxes upsampled to the fine grid, used as references  [§IV.B.2]
    refs = upsample(coarse_boxes, size=fine.shape)
    # Four offsets from the fused features, scaled by the fine stride  [eq. 6]
    offsets = conv_reg(concat(up_coarse, fine))
    # Invert eq. 5: offsets are measured from the reference, over s  [eq. 5]
    fine_boxes = refs + offsets * s_fine
    # Normalized-contrast quality map on the fine grid  [§IV.C]
    noco = conv_noco(fine)
    return coarse_logits, coarse_boxes, fine_scores, fine_boxes, noco
Pseudocode
# Training loss  [§IV.C] [eq. 7]
# pos_c, pos_f: indices of positive points on the coarse and fine grids
def oscar_loss(out, tgt, lam):
    # Coarse focal classification over all points, per coarse positive  [eq. 7]
    loss = focal(out.coarse_scores, tgt.coarse_labels) / n_pos_coarse
    # Coarse box loss on coarse positives only  [eq. 7]
    loss = loss + box_loss(out.coarse_boxes[pos_c], tgt.coarse_boxes[pos_c])
    # Fine focal classification over all points, per fine positive  [eq. 7]
    loss = loss + focal(out.fine_scores, tgt.fine_labels) / n_pos_fine
    # Fine box loss on fine positives only  [eq. 7]
    loss = loss + box_loss(out.fine_boxes[pos_f], tgt.fine_boxes[pos_f])
    # Normalized-contrast quality loss, weighted by lambda  [eq. 7]
    loss = loss + lam * quality_focal(out.noco, tgt.noco_map)
    return loss
Pseudocode
# Inference: score points and suppress duplicates  [§IV.C]
# The paper says NoCo is combined with both class scores; the formula is not
# stated. The product below is the code's choice (see Paper vs code).
def rank_detections(coarse_scores, fine_scores, noco, boxes):
    # Coarse scores are upsampled to the fine grid before the product  [code]
    coarse_up = upsample(coarse_scores, size=fine_scores.shape)
    # Final score: fine class score, coarse class score and NoCo  [code]
    score = fine_scores * coarse_up * noco
    # Non-maximum suppression; the threshold is not stated in the paper  [code]
    return nms(boxes, score, iou_threshold=0.5)

Hyperparameters

Values marked "code" come from the official config and are not stated in the paper. Paper values are cited to the paper.

NameValueWhereNotes
Feature levelsfine P2 (stride 4), coarse P3 (stride 8)fig. 6 oscar_w_noco_head_r18_caffe_fpn_p2_gn-head_1x_sirst_det2noco.pyCoarse head on P3, fine head on P2
FPN channels C256tab. VII oscar_w_noco_head_r18_caffe_fpn_p2_gn-head_1x_sirst_det2noco.pyHead width is C/2 = 128 in code (line 149)
Stacked convs per branch4 (code)oscar_w_noco_head_r18_caffe_fpn_p2_gn-head_1x_sirst_det2noco.pyPaper gives one convolution for the regression output §IV.B.2
Pseudo-box scale, fine layerp = 1.5 s, i.e. 6 px on P2§V.B.1 tab. II oscar_w_noco_head.pyCode applies it to the fine head only
Pseudo-box scale, coarse layerp = s, i.e. 8 px on P3oscar_w_noco_head.pyNot stated in paper
Top-down weight convsconv_1 kernel C/4 x C x 3 x 3, conv_2 kernel C x C/4 x 3 x 3, ReLU between§IV.B.1Code uses one 3x3 conv (see Paper vs code)
NoCo lambda10^3§V.B.7 tab. VIII oscar_w_noco_head_r18_caffe_fpn_p2_gn-head_1x_sirst_det2noco.pyText in §IV.C says lambda = 1 (see Pitfalls)
Quality focal loss beta2.0oscar_w_noco_head_r18_caffe_fpn_p2_gn-head_1x_sirst_det2noco.pyPaper names the loss but gives no beta
Focal loss gamma / alpha / weight3.0 / 0.25 / 2.0 (both heads)oscar_w_noco_head_r18_caffe_fpn_p2_gn-head_1x_sirst_det2noco.pyPaper gives no gamma, alpha or weight
Box lossDIoU, weight 1.0 (both heads)oscar_w_noco_head_r18_caffe_fpn_p2_gn-head_1x_sirst_det2noco.pyPaper says "IOU loss" §IV.C
BackboneResNet-18 config, basic blocks (2, 2, 2, 2)tab. VII oscar_w_noco_head_r18_caffe_fpn_p2_gn-head_1x_sirst_det2noco.py oscar_w_noco_head_r18_caffe_fpn_p2_gn-head_1x_sirst_det2noco.pyPretrained weights: see Pitfalls
Input sizeresize to 1000 x 600, keep aspect ratio; random horizontal flip (training)§V.C oscar_w_noco_head_r18_caffe_fpn_p2_gn-head_1x_sirst_det2noco.pyPaper gives (1000, 600) as the example size
Paddingsize divisor 32oscar_w_noco_head_r18_caffe_fpn_p2_gn-head_1x_sirst_det2noco.py
Normalisationmean 111.89, std 27.62, same for all three channelsoscar_w_noco_head_r18_caffe_fpn_p2_gn-head_1x_sirst_det2noco.pyInput is converted to RGB in the pipeline (to_rgb=True)
Schedule12 epochs ("1x")§V.A oscar_w_noco_head_r18_caffe_fpn_p2_gn-head_1x_sirst_det2noco.py
Batch4 images per GPU; training set repeated 3 times per epochoscar_w_noco_head_r18_caffe_fpn_p2_gn-head_1x_sirst_det2noco.pyTotal batch size not stated in paper
OptimizerAdamW, lr 0.002, betas (0.9, 0.999), weight decay 0.05oscar_w_noco_head_r18_caffe_fpn_p2_gn-head_1x_sirst_det2noco.pyPaper gives no optimizer
LR schedulepoly, power 1.0, minimum 0; linear warm-up over 1000 iterations from ratio 1e-6oscar_w_noco_head_r18_caffe_fpn_p2_gn-head_1x_sirst_det2noco.py
Precisionfp16 with dynamic loss scalingoscar_w_noco_head_r18_caffe_fpn_p2_gn-head_1x_sirst_det2noco.py
Normalized-contrast Gaussiansigma 1, centred, on a grid spanning -1.5 to 1.5 box unitstransforms.pyPaper gives no sigma; code value only
NoCo region extensionbox height and width on each side (gamma = 1)transforms.pyPaper: gamma in (0, 1], value not stated §III.B
Test score threshold / pre-NMS top-k / NMS IoU / max detections0.05 / 1000 / 0.5 / 100oscar_w_noco_head_r18_caffe_fpn_p2_gn-head_1x_sirst_det2noco.pyNot stated in paper
mNoCoAP thresholds0.1 to 0.9, step 0.1, averaged§III.BPaper's evaluation metric

Baseline settings (model-driven methods)

These are the settings the paper used for the classical comparisons, tuned on the trainval split §V.A tab. I. They are not needed to implement OSCAR.

MethodSettings
FKRWK = 5, p = 6, beta = 200, window 11 x 11
LCMcell 3 x 3, threshold factor k = 3
MPCMN = 1, 3, ..., 9, threshold factor k = 13
WLDML = 4, m = 2, n = 2, threshold factor k = 10
IPIpatch 50 x 50, stride 20, lambda = L / min(m, n)^(1/2), L = 2.5, epsilon = 1e-7
NIPPSpatch 50 x 50, stride 20, lambda = L / sqrt(min(m, n)), L = 1.2, energy ratio r = 0.005
RIPTpatch 50 x 50, stride 10, lambda = L / sqrt(min(I, J, P)), L = 0.001, h = 10, epsilon = 0.01, epsilon = 1e-7, k = 10
SMSLpatch 30 x 30, lambda = 2 x L / sqrt(min(m, n)), L = 5.0, k = 1

Results

Author-reported, on SIRST-V2 (1024 single-frame images, mostly 1280 x 1024) §III.A. The paper does not state the train and test split sizes or the hardware used for FPS. The paper's own metric is mNoCoAP, not COCO AP, so the numbers are not comparable with other papers.

Main comparison tab. IX. The table row is labelled AP but its caption says mNoCoAP. Deep baselines were trained with the authors' toolkit using default settings §V.A.

MethodmNoCoAPFPSSource
OSCAR (this paper)85.234.6tab. IX
QueryDet80.111.90tab. IX
RFLA78.84.21tab. IX
Faster R-CNN73.44.25tab. IX
FCOS73.128.57tab. IX
ALCNet66.42.62tab. IX
ISTDU65.119.23tab. IX
ACMNet61.429.41tab. IX
IPI (best model-driven)37.70.05tab. IX
MPCM32.21.11tab. IX
RIPT29.20.11tab. IX
FKRW27.80.52tab. IX
LCM20.77.93tab. IX
SMSL20.60.37tab. IX
WLDM11.20.12tab. IX

OSCAR's values at centroid-precision thresholds 0.1 to 0.9 are 93.8, 93.4, 93.3, 90.4, 88.8, 86.2, 82.3, 76.9 and 60.2 tab. IX §III.B. They fall as the threshold rises.

Pseudo-box size tab. II. AP for no pseudo box, p = s, p = 1.5 s and p = 2 s: 71.9, 75.6, 77.6 and 71.2 §V.B.1.

Pseudo-box sizeAPAP10AP30AP50AP70AP90
None (ground-truth box)71.988.986.877.766.232.9
p = s75.689.286.380.374.937.7
p = 1.5 s77.693.692.683.773.935.5
p = 2 s71.290.783.277.267.527.0

Top-down modules tab. V:

TDSMTDCRAPAP10AP30AP50AP70AP90
nono75.689.286.380.374.937.7
yesno78.588.986.784.271.954.0
noyes78.293.189.484.778.436.2
yesyes79.294.889.386.374.443.2

Normalized-contrast variants tab. VI:

VariantAPAP10AP30AP50AP70AP90
None79.294.889.386.374.443.2
NoCo (this paper)79.990.889.284.677.349.1
Centerness (dagger)79.792.990.181.975.550.9
NoCo (dagger)80.391.789.585.977.447.9

The dagger marks variants that differ at inference: "NoCo (dagger)" multiplies the NoCo map with the interpolated coarse classification scores as the final score, and "Centerness (dagger)" replaces the NoCo map with centerness §V.B.5.

Backbone and prediction level tab. VII (mNoCoAP / GFLOPS):

Refining layerResNet-18ResNet-34ResNet-50ResNet-101
P4 (C = 256, s = 16)74.38 / 14.8572.66 / 24.5471.36 / 28.3770.82 / 47.80
P3 (C = 256, s = 8)82.77 / 25.5582.04 / 35.2380.60 / 39.0680.24 / 58.54
P2 (C = 256, s = 4)85.02 / 68.3282.98 / 78.0082.33 / 81.8482.12 / 101.31
P2 (C = 128, s = 4)83.52 / 25.3682.15 / 35.0480.95 / 38.1280.75 / 57.59

Lambda tab. VIII:

lambdaAPAP10AP30AP50AP70AP90
10^280.292.488.585.578.349.9
10^380.693.491.681.977.351.6
10^478.594.588.685.777.343.9
10^577.292.989.182.174.042.6

SimpleGrid probe tab. III fig. 8: the down-sampling schedules are in tab. III. With oracle localisation, the classification-only SimpleGrid scores higher on coarser grids, while the full baseline scores lower as the grid coarsens. The paper uses this to argue that regression, not classification, needs high resolution §V.B.2. The figure is described in words here; its values are not tabulated in the text.

Paper vs code

Code: official repository https://github.com/YimianDai/open-deepinfrared at commit 3398042a1273005492a343596b064ebd4fe511b4, Apache-2.0 (raw/code/2212_08472/LICENSE). Its author is an author of this paper. Model and loss code is in deepir/models/dense_heads/oscar/oscar_w_noco_head.py; the ASPB and NoCo target code is in deepir/datasets/pipelines/transforms.py. The split files named in the config (splits/trainval_full.txt, splits/test_full.txt) are not in the repository, and the dataset is not included.

Each item below is a difference between the paper and the code at this commit.

  1. Pseudo-box scale per layer. The paper uses p = 1.5 s §V.B.1. The code applies the 1.5 factor to the fine head only, giving 6 px on P2 oscar_w_noco_head.py. The coarse head uses p = s = 8 px on P3 oscar_w_noco_head.py.

  2. Coarse regression targets use the pseudo box. The coarse head's regression targets are distances to the pseudo box, not to the ground-truth box, and the function returns those targets oscar_w_noco_head.py oscar_w_noco_head.py. The fine head's targets use the ground-truth box oscar_w_noco_head.py. Eq. 5 is written against the ground-truth box for both.

  3. Top-down modulation is simpler and runs both ways. The paper describes only the top-down direction (eqs. 3 and 4). The code uses one 3-by-3 convolution to produce the coarse weight, with no C/4 bottleneck and no ReLU oscar_w_noco_head.py oscar_w_noco_head.py. The weight multiplies the fine logits after the convolution, not the features before it oscar_w_noco_head.py. The code also computes the reverse weight from the fine features and multiplies the coarse logits by it oscar_w_noco_head.py oscar_w_noco_head.py oscar_w_noco_head.py. The paper describes only the top-down direction (eqs. 3 and 4).

  4. Regression parameterisation. The coarse box is exp-parameterised oscar_w_noco_head.py. The fine head's regression tower has four stacked convolutions, not one oscar_w_noco_head.py oscar_w_noco_head.py.

  5. Box loss type and normalisation. The code uses DIoU, not the plain IoU loss the paper names oscar_w_noco_head_r18_caffe_fpn_p2_gn-head_1x_sirst_det2noco.py. It averages the box loss over positives oscar_w_noco_head.py oscar_w_noco_head.py. Eq. 7 has no averaging for the box term.

  6. Quality loss weight and normalisation. The code uses a quality focal loss with weight 1000 and averages over every map pixel (default reduction) oscar_w_noco_head_r18_caffe_fpn_p2_gn-head_1x_sirst_det2noco.py noco_focal_loss.py oscar_w_noco_head.py. The paper's text says lambda = 1 §IV.C. Its ablation uses 10^3 §V.B.7.

  7. Score combination at inference. The code's score is the refine class score times the sigmoid of the upsampled coarse scores times the sigmoid of the NoCo map oscar_w_noco_head.py. The multiplication by class scores is done in mmdet's base post-processing, which is outside this repository and was not checked here. The paper gives no formula.

  8. NoCo target generation. The code normalises the contrast by the target-cell maximum plus 0.01 before applying the Gaussian, then min-max normalises the product transforms.py. Eq. 1 normalises the product directly and gives no constant. The code's region extension is one box height and width (gamma = 1) transforms.py. Its Gaussian is fixed (sigma = 1) on a grid spanning -1.5 to 1.5 box units transforms.py.

  9. Centroid used in evaluation. mNoCoAP scores each detection at the centre of its predicted box, not at a peak of the NoCo map transform.py mean_nocoap.py. The paper's wording ("the predicted NoCo value") is consistent with this, but it does not say the centre is used.

  10. Backbone checkpoint. The config's depth is 18 and the R18 checkpoint name is computed oscar_w_noco_head_r18_caffe_fpn_p2_gn-head_1x_sirst_det2noco.py. But the backbone's init block names open-mmlab://detectron/resnet50_caffe oscar_w_noco_head_r18_caffe_fpn_p2_gn-head_1x_sirst_det2noco.py. Which weights load was not verified (no training run).

  11. Layer-wise decay. A paramwise_cfg with stage-wise decay and a constructor override are in the optimizer dict, but the constructor line is commented out oscar_w_noco_head_r18_caffe_fpn_p2_gn-head_1x_sirst_det2noco.py. Whether those keys have any effect was not verified.

Pitfalls

  • Which pseudo-box size is the baseline. The text picks p = 1.5 s and says it is used in later experiments §V.B.1. But tables V and VI build on the p = s row (AP 75.6), not the p = 1.5 s row (AP 77.6) tab. II tab. V. The implementer must decide which setting to use; the paper does not say.

  • Lambda. §IV.C says lambda is 1. §V.B.7 and the config use 10^3 oscar_w_noco_head_r18_caffe_fpn_p2_gn-head_1x_sirst_det2noco.py. Eq. 7 has no normalisation, so the value's effect depends on the reduction used.

  • Numbers that do not reconcile. The best NoCo-ablation AP is 80.3 tab. VI, while the ResNet-18 P2 entry of the depth table is 85.02 mNoCoAP tab. VII and the main table reports 85.2 tab. IX. The paper does not say whether the ablation AP and the mNoCoAP are the same metric. The lambda sweep is stated to use ResNet-50 with P2 §V.B.7, but the ResNet-50 P2 entry is 82.33 tab. VII, and the sweep's best row is 80.6 tab. VIII. The caption of tab. VIII repeats the caption of tab. V.

  • FLOPs claim. The text says the P2 head costs "300% more" than P3 §V.B.6. Tab. VII gives 68.32 vs 25.55 GFLOPS for ResNet-18 with C = 256, a ratio of about 2.7 (roughly 167% more). The text elsewhere says "2-3 times".

  • Ambiguous "Up". Feature upsampling mode is not stated. The code uses bilinear for features and nearest-exact for boxes and NoCo maps oscar_w_noco_head.py oscar_w_noco_head.py. Nearest-exact is also used for the NoCo map oscar_w_noco_head.py.

  • Positive assignment rule. The paper does not say how a point is assigned to a box when it lies inside several, or whether "inside" means the pseudo box or the ground-truth box. The code uses the pseudo box for the inside test and the smallest-area box when several contain a point oscar_w_noco_head.py oscar_w_noco_head.py.

  • Ties at the area threshold. The code keeps a box when its area is strictly greater than p squared, which matches eq. 2 oscar_w_noco_head.py.

  • Quality loss parameters. Beta is 2.0 in the config oscar_w_noco_head_r18_caffe_fpn_p2_gn-head_1x_sirst_det2noco.py but the paper gives none. A reimplementation that copies the paper's focal loss form instead will not match the code's quality loss.

  • Metric is the authors'. mNoCoAP replaces IoU with a NoCo threshold averaged over nine levels. Numbers from the paper cannot be compared with COCO AP or with other infrared papers that use IoU.

  • Baseline tuning. Deep baselines (FCOS, Faster R-CNN, RFLA, QueryDet) were run with the authors' toolkit at default settings, and the paper says only that training followed the original papers §V.A. Their gap to OSCAR may reflect that setup.

  • Dataset and split. SIRST-V2's train and test split sizes are not stated in the paper. The config names split files that are not in the repository oscar_w_noco_head_r18_caffe_fpn_p2_gn-head_1x_sirst_det2noco.py.

  • Hidden costs. The paper's top-down weight and cascade add a second head and a NoCo branch, so the code computes two score maps and two box maps per image. The paper reports speed only as FPS on unstated hardware §V.C tab. IX.

  • No variance reported. The paper reports no seeds, repeats or error bars. Differences of about one point between rows (for example the NoCo variants in tab. VI) cannot be judged as real or noise from the paper alone.

Lineage

  • Builds on: the anchor-free one-stage detector the paper uses as its baseline (described as a simplified FCOS without centre-ness) §V.B §IV.A. The paper cites focal loss and a quality focal loss for the classification and quality terms §IV.C. It also builds on feature pyramids for the P2 and P3 levels §I.
  • Compared against: model-driven methods FKRW, LCM, MPCM, WLDM, IPI, NIPPS, RIPT and SMSL; data-driven methods ISTDU, ACMNet, ALCNet, FCOS, Faster R-CNN, QueryDet and RFLA §V.A §V.C tab. IX.
  • Related: Cascade R-CNN and RefineDet, which the paper contrasts with its top-down, one-stage cascade fig. 1 §II.
  • Superseded by: not known from wiki content.

Source and license

Adapted from “One-Stage Cascade Refinement Networks for Infrared Small Target Detection” by Yimian Dai, Xiang Li, Fei Zhou, Yulei Qian, Yaohong Chen, Jian Yang (arXiv:2212.08472), used under CC BY 4.0. Changes: condensed and restructured for implementation, with tables, equations and algorithms taken from the paper and its code, each cited to its source. Not affiliated with or endorsed by the authors. Code citations refer to https://github.com/YimianDai/open-deepinfrared at commit 3398042a1273 (Apache-2.0). Any quoted code is shown under that license.