wikillm

Paper · 2023-04-18 · cs.CV

Dynamic Coarse-to-Fine Learning for Oriented Tiny Object Detection

DCFL assigns labels to oriented tiny objects in one-stage detectors: a learned dynamic prior per feature point, cross-FPN candidates ranked by Gaussian generalized Jensen-Shannon divergence, then a prediction-aware re-rank and a two-Gaussian mixture filter. Author-reported DOTA-v2.0 mAP 57.66 with ResNet-101 (ReDet backbone) at 40 epochs; 51.57 with ResNet-50 at 12 epochs.

Oriented object detectionLabel assignmentDeformable convolutionGaussian mixture modeloriented-object-detectiontiny-objectsaerial-imageslabel-assignment

arXivPDFCodeMarkdown14 min read

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

In plain words

Aerial photos contain many tiny objects, such as cars, ships and storage tanks, and they are often drawn as tilted rectangles. A detector has to decide which of its many candidate boxes count as "this object". For tiny, oddly shaped objects, the usual rules pick the wrong candidates, or too few of them, so the detector learns poorly from them.

The paper's fix changes three things together. The candidate positions move and are learned, instead of sitting on a fixed grid. The first pass picks candidates loosely, from neighbouring spots and nearby image scales, by comparing how much each candidate's Gaussian shape overlaps the object's. A second pass then keeps only the candidates that already look good to the detector and fit the object's main body.

The method adds no separate branch to the detector. The authors report that it beats other one-stage oriented detectors on several aerial benchmarks. Those numbers come from their own runs and are not independently checked.

TL;DR

  • Oriented tiny objects break two assumptions of standard label assignment: the prior boxes are fixed, and the objects get too few positive samples §1 fig. 2.
  • DCFL makes three things dynamic: the prior position §3.1, the label assignment §3.2, §3.3 and the object representation (a two-Gaussian mixture) §3.3.
  • Coarse candidates come from a generalized Jensen-Shannon divergence between Gaussians §3.2 eq. 10. The result is refined by predicted quality and a mixture-of-Gaussians filter §3.3 eq. 13, eq. 14.
  • Author-reported: 51.57 mAP on DOTA-v2.0 with ResNet-50 at 12 epochs; 57.66 with a ReDet ResNet-101 at 40 epochs tab. 1.
  • Official code (Apache-2.0) exists, but several paper settings differ from it, and the headline 57.66 setup has no matching config in the repo. See Paper vs code.

Problem

Standard label assignment uses a fixed prior (an anchor or a point) and a fixed rule, such as maximum IoU, to decide positives §1. For oriented tiny objects the authors identify two failures:

  • Mismatch. The prior position, the feature sampled at that position, and the instance are not aligned. Most priors sit away from the object's body §1.
  • Imbalance. Objects whose angle or scale differs from the predefined anchors receive far fewer positive samples. The authors measured this on RetinaNet on DOTA-v2.0 §1 fig. 2 fig. 6 §5.

The method assumes an anchor-free or dense one-stage detector with an FPN. It targets DOTA-style oriented boxes parameterised by centre, size and angle §3.

Method

Notation: a prior is a feature point with a square box (w, h, θ) §3.1. Each ground-truth (gt) box is also modelled as a 2-D Gaussian with covariance \boldsymbol{\Sigma}_g eq. 9.

Overview §3. A detector maps priors P to detections D through a head. Static assigners pick positives with a fixed matching function (eq. 2), and dynamic assigners also use predictions (eq. 3). DCFL changes the prior into a learned one, \tilde P = \mathrm{DNN}_p(P), and uses a coarse-to-fine matching §3:

\tilde{G} = \mathcal{M}_d\big(\mathcal{M}_s(\tilde{P}, GT), \tilde{GT}\big) \qquad [\text{eq. 6}]

Here \mathcal{M}_s is the coarse prior matching and \mathcal{M}_d the finer posterior matching, and \tilde{GT} is the Dynamic Gaussian Mixture Model representation of each object. The loss has the same positive/negative split as the baseline, computed on the dynamic quantities §3 eq. 7:

\mathcal{L} = \sum_{i=1}^{\tilde N_{pos}} \mathcal{L}_{pos}(\tilde D_i, \tilde G_i) + \sum_{j=1}^{\tilde N_{neg}} \mathcal{L}_{neg}(\tilde D_j, y_j) \qquad [\text{eq. 7}]

The paper does not state the loss weights or the exact form of \mathcal{L}_{pos} and \mathcal{L}_{neg}. The implementation section names focal loss for classification and IoU loss for regression §4.2.

Step 1: dynamic prior §3.1. The Prior Capturing Block (PCB) is a dilated convolution followed by a deformable convolution (DCN). The regression branch's learned offsets guide the classification branch's sampling §3.1 fig. 3. Each prior starts at its feature point's location \mathbf{s}. At each iteration the prior moves by the mean of its n sampling offsets, scaled by the feature stride st and divided by 2n §3.1 eq. 8:

\tilde{\mathbf{s}} = \mathbf{s} + st \sum_{i=1}^{n} \frac{\Delta \mathbf{o}_i}{2n} \qquad [\text{eq. 8}]

The paper does not give n. The code uses 9 sampling points r_dcfl_head.py.

Each prior is then a 2-D Gaussian whose mean is \tilde{\mathbf{s}}. Its covariance follows from the square box (w, h) and θ §3.1 eq. 9:

\boldsymbol{\Sigma}_p = R(\theta)\, \mathrm{diag}\!\left(\tfrac{w^2}{4}, \tfrac{h^2}{4}\right) R(\theta)^{\top}, \quad R(\theta) = \begin{bmatrix}\cos\theta & -\sin\theta\\ \sin\theta & \cos\theta\end{bmatrix} \qquad [\text{eq. 9}]

Step 2: coarse prior matching §3.2. For each gt, the method ranks all priors by a similarity between the prior's Gaussian and the gt's Gaussian. The similarity is the Generalized Jensen-Shannon Divergence (GJSD) with weight \alpha = 0.5 §3.2 eq. 10:

\mathrm{GJSD}(\mathcal{N}_p, \mathcal{N}_g) = (1-\alpha)\,\mathrm{KL}(\mathcal{N}_\alpha, \mathcal{N}_p) + \alpha\,\mathrm{KL}(\mathcal{N}_\alpha, \mathcal{N}_g) \qquad [\text{eq. 10}]

The interpolated Gaussian \mathcal{N}_\alpha is given by §3.2 eq. 11 and eq. 12:

\boldsymbol{\Sigma}_\alpha = \big((1-\alpha)\boldsymbol{\Sigma}_p^{-1} + \alpha\boldsymbol{\Sigma}_g^{-1}\big)^{-1} \qquad [\text{eq. 11}]

\boldsymbol{\mu}_\alpha = \boldsymbol{\Sigma}_\alpha\big((1-\alpha)\boldsymbol{\Sigma}_p^{-1}\boldsymbol{\mu}_p + \alpha\boldsymbol{\Sigma}_g^{-1}\boldsymbol{\mu}_g\big) \qquad [\text{eq. 12}]

The top K priors per gt become the Coarse Positive Samples (CPS). Their candidates are Cross-FPN: they can come from adjacent FPN levels and nearby locations §3.2. All other priors are negative §3.2. The paper also describes the single-level and all-level alternatives and reports them as weaker §4.4 tab. 7(b).

Step 3: finer posterior matching §3.3. Within the CPS, the method keeps the Q candidates with the highest "possibility of becoming a true prediction", PT §3.3 eq. 13. These are the Medium Positive Samples (MPS):

PT_i = \tfrac{1}{2}\,\mathrm{Cls}(D_i) + \tfrac{1}{2}\,\mathrm{IoU}(D_i, gt_i) \qquad [\text{eq. 13}]

Here Cls is the predicted class confidence and IoU is the rotated IoU between the predicted box and its gt §3.3.

The gt is then represented by a Dynamic Gaussian Mixture Model with two components that share the gt covariance \boldsymbol{\Sigma}_g. One mean is the gt's geometric centre. The other is the semantic centre, the mean location of the MPS §3.3 eq. 14:

\mathit{DGMM}_i(s\,|\,x,y) = \sum_{m=1}^{2} w_{i,m}\sqrt{2\pi|\boldsymbol{\Sigma}_{i,m}|}\; \mathcal{N}_{i,m}(\boldsymbol{\mu}_{i,m}, \boldsymbol{\Sigma}_{i,m}) \qquad [\text{eq. 14}]

The weights sum to 1 §3.3. The paper sets w_{i,1} = 0.7 §4.4. A candidate is set to negative when its DGMM score is below e^{-g}, where g is a tunable threshold §3.3.

Overall procedure. The steps above combine as follows. This is a paraphrase of the paper's description with code-level details noted, not the official code.

Pseudocode
# Dynamic coarse-to-fine assignment for one image  [§3] [eq. 6]
# Inputs:  centres (N, 2) feature-point locations, strides (N,)
#          offsets (N, 9, 2) sampling offsets from the regression branch
#          gts (G, 5) as (cx, cy, w, h, angle)
#          scores (N, A) classification logits, boxes (N, 5) predicted
# Output:  assigned (N,) gt index per prior, or -1 for negative

def dcfl_assign(centres, strides, offsets, gts, scores, boxes,
                top_k, top_q, g):
    # Dynamic prior: shift each centre by the mean of its sampling
    # offsets, scaled by the stride and halved  [§3.1] [eq. 8]
    priors = centres + strides * mean(offsets, over_points) / 2  # (N, 2)

    # Coarse set: per gt, the top_k priors by GJSD similarity
    # with alpha = 0.5; similarity is 1 / (1 + GJSD)  [§3.2] [eq. 10]
    similarity = 1 / (1 + gjsd(priors, gts, alpha=0.5))  # (G, N)
    coarse = top_indices(similarity, top_k, over_priors)  # (G, K)

    # Medium set: per gt, the top_q coarse candidates by
    # PT = 1/2 class confidence + 1/2 IoU with the gt  [§3.3] [eq. 13]
    pt = (0.5 * max_class_prob(scores, coarse)
          + 0.5 * iou(boxes, coarse, gts))  # (G, K)
    medium = top_indices(pt, top_q, over_candidates)  # (G, Q)

    # Semantic centre: mean location of each gt's medium set  [§3.3]
    semantic = mean(priors[medium], over_candidates)  # (G, 2)

    # Two-Gaussian mixture with the gt covariance; weights 0.7 and 0.3
    # (the second follows from summing to 1)  [§3.3] [eq. 14]
    sigma = gt_covariance(gts)  # (G, 2, 2)
    dgmm = (0.7 * gauss(priors, gts[:, :2], sigma)
            + 0.3 * gauss(priors, semantic, sigma))  # (N, G)

    # Keep a medium candidate only if its mixture score reaches exp(-g)
    # (the code tests the gt it was assigned to)  [§3.3]
    assigned = full(N, -1)
    for each gt and candidate in medium with dgmm >= exp(-g):
        assigned[candidate] = gt
    return assigned


def gauss(points, mean, cov):
    # Unnormalised 2-D Gaussian with peak value 1.
    # [code: mmrotate/core/bbox/assigners/coarse2fine_assigner.py#L199-L204]
    diff = points - mean
    return exp(-0.5 * quadratic_form(diff, inverse(cov)))

Notes on the pseudocode. It omits the shape of the head, the rotated IoU definition and the loss. Pitfalls below list where the code departs from the paper.

Hyperparameters

Paper values are stated in §4.2 and §4.4 unless noted. Config values are from the official repository at code_commit.

NameValueWhereNotes
BackboneResNet-50 with FPN (default)§4.2ReDet ResNet-101 (ReR101) for the headline DOTA-v2.0 57.66 and DIOR-R 71.03 tab. 1 tab. 4
Backbone (repo)ResNet-50 and ResNet-101 (DOTA); ReResNet-101 (DIOR-R)dotav2_test_dcfl_r50_1x.py diorr_dcfl_rer101_40e.pyNo DOTA-v2.0 ReR101 config is in the repo
K (coarse top-K per gt)16§3.2 tab. 7(d)DOTA configs topk=16 dotav2_test_dcfl_r50_1x.py; DIOR-R config topk=15 diorr_dcfl_rer101_40e.py
Q (medium set per gt)12§3.3 tab. 7(d)DOTA topq=12 dotav2_test_dcfl_r50_1x.py; DIOR-R topq=13 diorr_dcfl_rer101_40e.py
α (GJSD weight)0.5§3.2Paper: both distributions contribute equally
w₁ (geometric weight)0.7§4.4Code coarse2fine_assigner.py
g (mask threshold)0.8 besttab. 7(e)Code gauss_thr=0.6 in every DCFL config dotav2_test_dcfl_r50_1x.py; g = 0.6 is not in the paper's sweep
Dilation rate3§4.4Code uses dilation_rate - 1 as the sampling offset r_dcfl_head.py; DOTA-v1.0 config uses 4 dotav1_test_dcfl_r50_3x.py
Prior shapeone square prior per location, size not stated§3.1Code: anchor scale 4 × stride, ratio 1.0 dotav2_test_dcfl_r50_1x.py
OptimizerSGD, momentum 0.9, weight decay 1e-4§4.2Matches code
Learning rate0.005§4.2DOTA configs 0.0025 dotav2_test_dcfl_r50_1x.py; DIOR-R config 0.005 diorr_dcfl_rer101_40e.py
Batch size4 on one RTX 3090§4.2DOTA configs samples_per_gpu=2 dotav2_test_dcfl_r50_1x.py; DIOR-R samples_per_gpu=4
LR schedulenot stated in papernot stated1x: linear warm-up 500 iters, steps at 8 and 11, 12 epochs [code: configs/base/schedules/schedule_1x.py#L7-L13]
Epochs12 (DOTA-v1.0, v2.0, VisDrone, COCO); 40 (DOTA-v1.5, DIOR-R)§4.2DCFL† uses 40 epochs tab. 1
Input size1024×1024 crops with overlap 200 (DOTA); 800×800 (DIOR-R); 1333×800 (VisDrone, COCO)§4.2Code img_scale=(1024, 1024) dotav2_test_dcfl_r50_1x.py
Augmentationrandom flipping only§4.2Code: flip ratio 0.25 each for horizontal, vertical and diagonal dotav2_test_dcfl_r50_1x.py
Classification lossfocal loss, γ = 2, α = 0.25§4.2 (γ, α not stated)Code dotav2_test_dcfl_r50_1x.py
Regression lossrotated IoU loss, weight 1.0§4.2Code dotav2_test_dcfl_r50_1x.py
Gradient clippingnot statednot statedCode: max norm 35 [code: configs/base/schedules/schedule_1x.py#L5]
NMS and score thresholdnot statednot statedCode: IoU 0.4, score 0.05 dotav2_test_dcfl_r50_1x.py

Results

Author-reported. Setups are DOTA-v2.0, DOTA-v1.0, DOTA-v1.5, DIOR-R, VisDrone and MS COCO, single-scale training and testing §4.1 §4.2. The baselines in the DOTA-v2.0 table were reproduced by the authors with the same settings §4.2.

SettingMetricBaselineThis paperSource
DOTA-v2.0, ResNet-50, 12 epochsmAPRetinaNet-O 46.68; S2A-Net 49.86DCFL 51.57tab. 1
DOTA-v2.0, ResNet-50, 40 epochsmAPnot in tableDCFL† 55.08tab. 1
DOTA-v2.0, ReR101, 40 epochsmAPOriented R-CNN 53.28 (two-stage, ResNet-50, 12 epochs)DCFL† 57.66 (headline)tab. 1 §4.3
DOTA-v2.0, S2A-Net with DCFLmAPS2A-Net 49.8652.84tab. 1
DOTA-v1.0, 12 epochs (MMRotate)mAPRetinaNet-O 69.79; S2A-Net 73.91DCFL 74.26tab. 2
DOTA-v1.0, 36 epochsmAPGGHL 73.98DCFL 75.35tab. 2
DOTA-v1.5, ResNet-50, 40 epochsmAPRetinaNet-O 59.16DCFL 67.37tab. 3
DOTA-v1.5, ReR101, 40 epochsmAPReDet (ReR50) 66.86DCFL 70.24tab. 3
DIOR-R, ReR101, 40 epochsmAPOriented RepPoints 66.71 (ResNet-50 row)DCFL 71.03tab. 4
DIOR-R tiny classes (vehicle, bridge, windmill)APRetinaNet-O 38.0 / 24.0 / 60.2DCFL 50.9 / 42.1 / 70.9tab. 5
VisDrone, HBBAP₅₀RetinaNet 29.2DCFL 32.1tab. 6
MS COCO, HBBAP₅₀RetinaNet 55.4DCFL 57.3tab. 6
DOTA-v2.0 HBBAP₅₀FCOS 55.4DCFL 57.4tab. 6
Ablation, DOTA-v2.0 val, ResNet-50mAPRetinaNet 51.70DCFL 59.15tab. 7(a)
Inference speed, DOTA-v2.0 val, RTX 3090FPSRetinaNet 20.8; S2A-Net 18.9; R3Det 16.2DCFL 20.9§5
Parameters and GFLOPs at 1024 inputM / GFLOPsRetinaNet 36.5 / 217.3DCFL 36.1 / 157.8tab. 8

Summary of the claims in the text. The paper reports the state of the art for one-stage detectors on DOTA-v1.5, DOTA-v2.0 and DIOR-R under single-scale settings [abstract] §4.3. The authors also say the gain on the tiny classes of DOTA-v1.5 is "about 10 points" §4.3. In the table, the gain for ResNet-50 on the three shown classes ranges from +7.6 to +15.7 tab. 3.

Ablations §4.4, DOTA-v2.0 train split, val split, mAP:

  • Individual parts tab. 7(a): CPS plus MPS 53.41; CPS plus DGMM 57.20; all three 59.15. The authors state that CPS alone cannot be used as positives.
  • Candidate definition tab. 7(b): all-level 50.12; single-level 56.72; Cross-FPN with KLD 57.82, with GWD 58.55, with GJSD 59.15.
  • PCB design tab. 7(c): the text reports DCN adds 0.34 mAP (58.07 to 58.41). The guided variant reaches 59.15.
  • K and Q grid tab. 7(d): best K = 16, Q = 12 (59.15). The other settings in the grid range from 57.0 to 59.1.
  • Threshold g tab. 7(e): g = 0.8 gives 59.15; g = 0.4 gives 58.95; g = 1.0 gives 58.20; g = 1.2 gives 57.91.

Paper vs code

Official code: https://github.com/Chasel-Tsui/mmrotate-dcfl (Apache-2.0, commit d60ca272). The paper links it in the abstract. Code paths below are relative to the repository root at code_commit. The main implementation is mmrotate/models/dense_heads/r_dcfl_head.py (head) and mmrotate/core/bbox/assigners/coarse2fine_assigner.py (assigner). The GJSD metric is in mmrotate/core/bbox/iou_calculators/rotate_metric_calculator.py.

  • Learning rate and batch size. Paper: lr 0.005, batch 4 on one RTX 3090 §4.2. DOTA configs: lr 0.0025, samples_per_gpu=2 [code: configs/dcfl/dotav2_test_dcfl_r50_1x.py#L98] [code: configs/dcfl/dotav2_test_dcfl_r50_1x.py#L103]. The repository README lists batch size 2 for DCFL [README, DCFL rows]. DIOR-R config: lr 0.005 with samples_per_gpu=4 diorr_dcfl_rer101_40e.py diorr_dcfl_rer101_40e.py.
  • Threshold g. Paper: best g = 0.8 tab. 7(e). All DCFL configs: gauss_thr=0.6 dotav2_test_dcfl_r50_1x.py.
  • Dilation. Paper: dilation rate 3 §4.4. The head uses dilation_rate - 1 as the offset of its sampling grid [code: mmrotate/models/dense_heads/r_dcfl_head.py#L193-L196], so the DOTA-v2.0 configs (dilation_rate = 3) sample at ±2 pixels. The DOTA-v1.0 config uses dilation_rate = 4 dotav1_test_dcfl_r50_3x.py.
  • K and Q on DIOR-R. Paper gives one K and Q §3.2 §3.3 tab. 7(d). The DIOR-R config uses topk=15 and topq=13 [code: configs/dcfl/diorr_dcfl_rer101_40e.py#L63-L64]. The paper does not state this per-dataset change.
  • Prior update scale. Eq. 8 uses the feature stride st. The code multiplies each level's offsets by img_shape/256, then doubles it per level r_dcfl_head.py [code: mmrotate/models/dense_heads/r_dcfl_head.py#L560-L563]. At 1024 input, that equals stride/2, which matches Eq. 8 with n = 9. At 800 input (DIOR-R), the factor at the finest level is 3.125 where stride/2 would be 4, so the shift is smaller. This is derived from the code, not measured.
  • Where the dynamic prior is used. Eq. 5 suggests the head consumes the dynamic prior. In the code, the shifted prior is used only for target assignment r_dcfl_head.py. Box decoding in loss_single uses the unshifted anchors [code: mmrotate/models/dense_heads/r_dcfl_head.py#L253], and inference uses static grid priors r_dcfl_head.py.
  • Negative masking. Paper: a sample is set negative if its DGMM score is below e^{-g} "with any gt" §3.3. The code checks only the gt the sample is assigned to [code: mmrotate/core/bbox/assigners/coarse2fine_assigner.py#L206-L209].
  • DGMM normalisation. Eq. 14 multiplies each Gaussian by \sqrt{2\pi|\Sigma|}. For a 2-D Gaussian that leaves a peak of 1/\sqrt{2\pi} \approx 0.40. The code uses unnormalised Gaussians with peak 1 [code: mmrotate/core/bbox/assigners/coarse2fine_assigner.py#L199-L204]. The threshold e^{-g} is applied to the code's values.
  • Quality score. Eq. 13 weights class and IoU by ½ each. The code adds the IoU to the sigmoid of the maximum class logit [code: mmrotate/core/bbox/assigners/coarse2fine_assigner.py#L160-L162]. The ranking is the same, since the two differ by a factor of 2.
  • GJSD. The paper prints only the KL form of Eq. 10. The closed form the code uses is \tfrac12\big[(1-\alpha)\mu_p^\top\Sigma_p^{-1}\mu_p + \alpha\mu_g^\top\Sigma_g^{-1}\mu_g - \mu_\alpha^\top\Sigma_\alpha^{-1}\mu_\alpha + \log(|\Sigma_p|^{1-\alpha}|\Sigma_g|^{\alpha}/|\Sigma_\alpha|)\big] rotate_metric_calculator.py. The paper's source contains this line only commented out. The code converts it to a similarity 1/(1+\mathrm{GJSD}) [code: mmrotate/core/bbox/iou_calculators/rotate_metric_calculator.py#L103-L109].
  • Precision. On CUDA, the GJSD is computed in half precision [code: mmrotate/core/bbox/iou_calculators/rotate_metric_calculator.py#L202-L203].
  • Headline config. The paper's 57.66 uses ReR101 at 40 epochs on DOTA-v2.0 tab. 1. The repository has no DOTA-v2.0 config with that backbone. Its DOTA-v2.0 ResNet-101 config is 1x, and the README reports 52.54 for it. The ReR101 40-epoch config is for DIOR-R only [code: configs/dcfl/diorr_dcfl_rer101_40e.py#L10-L11].
  • DOTA-v1.0 12-epoch result. The 74.26 entry tab. 2 has no matching config. The repository has only a 3x config [code: configs/dcfl/dotav1_test_dcfl_r50_3x.py].
  • Flipping. Paper: "random flipping" §4.2. The DOTA config flips horizontally, vertically and diagonally, with 0.25 probability each [code: configs/dcfl/dotav2_test_dcfl_r50_1x.py#L87-L91].
  • Anchor size. The paper says the prior is square "as in RetinaNet" but gives no size. The code uses scale 4 × stride with one scale per level [code: configs/dcfl/dotav2_test_dcfl_r50_1x.py#L36-L41].
  • Device. The target builder allocates with hard-coded .cuda() [code: mmrotate/models/dense_heads/r_dcfl_head.py#L390-L391]. CPU-only training would fail there.

Pitfalls

  • Headline vs fair comparison. 57.66 combines a stronger backbone (ReR101), 40 epochs and the DCFL† setting tab. 1. The baselines in that table are reproduced by the authors with the 12-epoch DOTA setting §4.2. Compare the ResNet-50 12-epoch rows (51.57 against 46.68 to 49.86), not the headline.
  • Two baselines of 51.70 and 46.68. The ablation baseline (RetinaNet 51.70, tab. 7(a)) is on DOTA-v2.0 val, trained on train. The main-table baseline (46.68, tab. 1) is on the test split. Do not compare the two.
  • Overclaim in the text. The paper says 51.57 "surpasses all one-stage object detectors tested" §4.3. The same table lists S2A-Net with DCFL at 52.84 tab. 1. The paper does not discuss that row.
  • "About 10 points" on tiny classes. §4.3 summarises the gain as about 10 points. Table 3 gives +7.6 to +15.7 for ResNet-50 and +12.8 to +16.6 for ReR101 on the shown classes tab. 3. The shown classes are only three of DOTA-v1.5's classes, and the mAP column is not their average. The paper does not say how the mAP was computed.
  • Shifted prior is an assignment-only signal. Because the head decodes boxes from unshifted anchors, the learned prior changes which predictions are trained as positives, not where the regression starts. An implementation that follows Eq. 5 literally will differ from the code.
  • Scale dependence of the prior update. The shift scales with image height divided by 256, not the stride. Changing input size changes the effective update (see Paper vs code).
  • Ties in top-K. When a prior is in the top-K of two gts, the later gt index overwrites the earlier one [code: mmrotate/core/bbox/assigners/coarse2fine_assigner.py#L133-L136]. The paper is silent on ties.
  • Candidate label. A prior that enters a gt's medium set keeps the label from its GJSD top-K assignment [code: mmrotate/core/bbox/assigners/coarse2fine_assigner.py#L179-L185]. The paper does not say this.
  • Threshold sensitivity. The paper sweeps g from 0.4 to 1.2 and finds a range of 57.9 to 59.2 tab. 7(e). The authors describe the method as robust to K, Q and g §4.4. The code default is g = 0.6, which the paper did not test.
  • Numerics. The GJSD uses determinants of 2×2 covariances, and the width and height are clamped at 1e-7 to 1e7 [code: mmrotate/core/bbox/iou_calculators/rotate_metric_calculator.py#L138]. Half-precision evaluation on CUDA [code: mmrotate/core/bbox/iou_calculators/rotate_metric_calculator.py#L202-L203] makes near-degenerate boxes more prone to overflow or NaN. This is a risk, not a reported failure.
  • Costs the abstract hides. Assignment runs a GJSD over all priors for every gt at every iteration, and the code offloads to CPU above 1024 gts [code: configs/dcfl/dotav2_test_dcfl_r50_1x.py#L64]. The paper reports only inference speed and parameters §5 tab. 8.
  • Not stated. Loss weights, the exact \mathcal{L}_{pos} and \mathcal{L}_{neg}, the LR schedule, NMS settings, anchor size and gradient clipping are not stated in the paper. The values above come from the code.

Lineage

  • Builds on the dense one-stage design of RetinaNet (focal loss, anchors) §2 and on deformable convolution §3.1. It uses a Generalized Jensen-Shannon divergence between Gaussians, cited in the paper as gjsd_2020_entropy §3.2. None of these have cards in this wiki.
  • Compared against, in the paper's tables: RetinaNet-O, R3Det, ATSS-O, S2A-Net, DAL, SASM, Oriented R-CNN, Oriented RepPoints, GGHL, KLD and AOPG tab. 1 tab. 2 tab. 4.
  • Superseded by: not known from wiki content.

Source and license

Adapted from “Dynamic Coarse-to-Fine Learning for Oriented Tiny Object Detection” by Chang Xu, Jian Ding, Jinwang Wang, Wen Yang, Huai Yu, Lei Yu, Gui-Song Xia (arXiv:2304.08876), 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/Chasel-Tsui/mmrotate-dcfl at commit d60ca27234a3 (Apache-2.0). Any quoted code is shown under that license.