CF-DETR: Coarse-to-Fine Transformer for Real-Time Object Detection

Brent Byunghoon Kang; Byeongyun Park; Donghwa Kang; Hyeongboo Baek; Jinkyu Lee; Woojin Shin

REVIEW 4 major objections 4 minor 27 references

CF-DETR: Coarse-to-Fine Transformer for Real-Time Object Detection

T0 review · 4 major / 4 minor · reviewed 2026-08-07 · deepseek-v4-flash

Challenge this review Re-run · record.json Download PDF Read on arXiv ↗

Pith's one-line read CF-DETR claims that splitting each transformer-based detection task into a guaranteed coarse stage plus an opportunistic fine stage satisfies firm real-time deadlines while keeping accuracy above generic real-time DNN schedulers.

desk verdict A solid co-design of a coarse-to-fine DETR with a fixed-priority scheduler, worth refereeing, but the deadline guarantee rests on unvalidated WCET and batching assumptions that need to be exposed and verified. read the letter →

arxiv 2505.23317 v1 pith:Y3XVGIR7 submitted 2025-05-29 eess.SY cs.CVcs.SY

Woojin Shin , Donghwa Kang , Byeongyun Park , Brent Byunghoon Kang , Jinkyu Lee , Hyeongboo Baek This is my paper · ORCID

classification eess.SYcs.CVcs.SY

keywords CF-DETRDETRreal-timeschedulingcoarse-to-fineinferenceautonomousvehiclesnon-preemptivefixed-priorityobjectdetectionGPUbatching

verification ladder T0 review T1 audit T2 compute T3 formal

The pith

A machine-rendered reading of the paper's core claim, the machinery that carries it, and where it could break.

The reading

CF-DETR claims that the latency–accuracy trade-off of Detection Transformers (DETR) can be converted into a scheduling resource: every DETR task first runs a cheap coarse-patch inference that reliably finds large, safety-critical objects, and only the hard remaining regions are refined at fine patch granularity when GPU time permits. The paper asserts that this coarse-to-fine split, orchestrated by the NPFP** non-preemptive fixed-priority scheduler, satisfies firm real-time deadlines (R1) for the coarse stage while keeping overall and critical-object accuracy (R2) higher than generic real-time DNN schedulers such as DNN-SAM. This matters because autonomous vehicles run several concurrent DETR tasks, one per camera, under tight deadlines, and DETR's attention cost grows with patch count, so a uniformly fine model misses deadlines but a uniformly coarse one misses small objects. The evidence spans accuracy and throughput measurements on a server GPU and a Jetson Orin, and an emergency-braking case study on a 1/10-scale autonomous vehicle in which CF-DETR stopped before collision in all 10 trials while the DINO baseline never did.

What carries the argument

The load-bearing mechanism is the decomposition of each DETR task into a coarse subtask $\tau_i^S$ with a fixed worst-case execution time $C_i^S$ and an optional fine subtask $\tau_i^F$ with patch-count-dependent cost $C_i^F(p_i^F)$, scheduled under NPFP** with coarse subtasks always prioritized over fine subtasks. The guarantee rests on two assumptions that the paper states explicitly: offline-measured WCETs that are safe upper bounds, and the batching property that a batch costs no more than the sum of its members' individual costs ($C_{B_S} \le \sum_{\tau_i \in B_S} C_i^S$). Given those, the offline Lemma 1 test stays valid at run time because permissible coarse batches are contiguous priority-ordered prefixes that finish before the earliest future release (principles P1 and P2), and because any such batch only reduces the higher-priority interference seen by other tasks. Fine subtasks are opportunistically grouped by the DBA dynamic program into batches that reduce padding overhead while meeting each fine deadline and the next coarse release, with the WCET of a padded batch taken from a precomputed table.

What would settle it

Profile coarse-subtask latency on inputs chosen to maximize attention cost—for instance, frames densely packed with many small objects—and compare every measurement against the worst-case execution time the paper tabulates for the coarse subtask (Table II). One measured coarse latency above that table value, or one multi-task coarse batch whose latency exceeds the sum of its members' individual worst-case times, would break the batching property and with it the deadline guarantee for coarse subtasks. A complementary check is to rerun the emergency-braking protocol with fine subtasks forced to execute every period and watch whether the guaranteed coarse response time still holds.

Watch

Extended reading notes

Core claim

The paper's central claim is that a DETR detector does not have to choose once between speed and accuracy. The same model runs a coarse-patch inference first (strategy A1) that quickly detects large, critical objects; frames whose remaining detections look ambiguous are flagged hard, proposed hard regions are re-partitioned into finer patches and refined selectively (A2); and both stages are batched across concurrent tasks, with image-level batching for coarse inference and patch-level batching for fine regions (A3). The NPFP** scheduler (A4) partitions each periodic task $\tau_i$ into a safety-critical coarse subtask $\tau_i^S$, whose worst-case response time is guaranteed offline by non-preemptive fixed-priority response-time analysis (Lemma 1), and an optional fine subtask $\tau_i^F(p_i^F)$ that runs only when no coarse work is active and only if it finishes before the earliest future coarse release. The paper proves that two design principles for coarse batches—restricting batches to contiguous priority-ordered prefixes and requiring a batch to finish before the next release, exploiting the property $C_{B_S} \le \sum_{\tau_i \in B_S} C_i^S$—preserve the offline schedulability guarantee (Lemma 2), while fine batches are chosen by an $O(N^2)$ dynamic-programming partition that minimizes padding cost subject to the same timing constraints. On this basis the paper reports critical mAP near the model's unconstrained maximum, overall mAP above DNN-SAM baselines, and collision-free emergency braking on a scaled autonomous vehicle.

Load-bearing premise

The guarantee collapses if the offline-measured worst-case execution times of the coarse subtasks are not true worst cases for every input frame, or if batched GPU execution ever takes longer than the sum of the individual subtasks' worst-case times, since the Lemma 1 schedulability test and the safety of coarse batching both assume those bounds.

Editorial extensions

If this is right

Multiple concurrent DETR tasks (one per camera) can be scheduled on a single shared GPU with firm deadlines, because the coarse stage of every task is guaranteed by an offline fixed-priority test regardless of how many fine subtasks are spawned.
Critical-object accuracy stays near the model's unconstrained maximum even when fine inference is skipped on easy frames, since large safety-critical objects are already detected during the coarse stage (observation O2).
Batching can be used aggressively without voiding deadlines: coarse batches formed as contiguous priority-ordered groups that finish before the next release preserve schedulability, and patch-level batching of fine regions cuts latency by roughly 20–40% versus image-level batching.
The method transfers to Transformer detectors beyond DINO, because it relies on the common patch-and-attention architecture rather than on any one model's specifics.
In the paper's emergency-braking case study, CF-DETR under NPFP[C][F] stopped the 1/10-scale vehicle before collision in all 10 trials at stopping distances of 0.47–1.01 m, while the DINO baseline collided in all 10 trials.

Reading between the lines

Editorial extensions of the paper, not claims the author makes directly.

The same coarse-first decomposition could apply to other latency-sensitive Transformer workloads with firm budgets, such as video analytics, robot perception, or LLM serving with per-request time limits, wherever a cheap pass can flag which inputs deserve a costly refinement.
The hardness classifier (average confidence of intermediate-confidence queries after thresholding) is a proxy that depends on the input distribution; a stress test with adversarial frames engineered to produce many mid-confidence false queries would probe whether the fine stage fires exactly where it is needed.
The paper deliberately avoids runtime schedulability re-checks to keep overhead low, so a natural extension is an adaptive variant that re-runs the Lemma 1 test online when measured coarse latencies drift, accepting the overhead the paper argues can be omitted.
Patch-level batching across cameras could in principle be extended to fuse views of the same physical object, refining a shared region once and reusing tokens across tasks—an accuracy and latency win the paper does not explore.

Share X Bluesky LinkedIn Reddit HN

Editorial analysis

A structured set of objections, weighed in public.

Desk editor's note, referee report, and a circularity audit.

Desk Editor's Note

read the letter

Colleague,

Here is my take on CF-DETR. The real contribution is combining two existing ideas: coarse-to-fine inference for transformers (CF-ViT) and batched real-time scheduling for DNNs (Batch-MOT). The new part is applying coarse-to-fine to DETR object detection with criticality-aware refinement, wrapped in an NPFP-style scheduler with a runtime batch safety check. That integration is not in prior work, and it is a legitimate next step for this line of research.

What the paper does well: the system design is pragmatic. The observation that large critical objects are detectable with coarse patches and only hard regions need finer splits is clean and empirically supported. Prioritizing coarse subtasks over fine subtasks is a sensible way to guarantee critical detections while using spare capacity for accuracy. The evaluation on server, embedded, and a 1/10 scale AV is a compelling proof of concept: all ten emergency-braking trials stopped, while DINO collided every time. I credit that as real evidence.

Now the soft spots, and they are not tiny. The stress-test note is on target. The R1 guarantee rests on the WCETs in Table II being safe upper bounds, but they are the max of 1000 measurements with no safety margin, and the paper explicitly punts: it says it "operate[s] under the assumption that a reliable upper bound on WCET can be established through intensive measurements complemented by appropriate safety margins." For a firm real-time claim, that assumption is load-bearing. The batching property C_BS <= sum C_i^S is asserted and never checked against the batch latency measurements in Fig. 6; if it fails on the real GPU, Lemma 2 and the deadline guarantee collapse. This is the difference between a guaranteed deadline and a likely deadline. The paper either needs stronger WCET evidence (with margins or a statistical argument) or a softer, probabilistic framing of the timing guarantee.

A reproducibility issue: no code or artifacts are released, and the thresholds (confidence cutoffs, critical-size threshold) appear tuned on the same KITTI split used for evaluation. That is a mild self-reference bias, but addressable. The comparison is also limited to DNN-SAM and DINO, and the proofs, especially Lemma 2, are terse. None of these are fatal by themselves; together they mean the paper is not yet as strong as its claims.

Who will get value from this: researchers working on real-time scheduling for DNNs, particularly transformer-based perception. It deserves a serious referee, but the final version should require a reproducibility appendix and an honest treatment of the WCET/batching assumptions.

Recommendation: engage with it. Send it to peer review with the expectation of heavy revision. The core idea is good; the evidence is promising; the timing guarantee needs more rigor.

Best, [Your name]

Referee Report

4 major / 4 minor

Summary. The paper proposes CF-DETR, an integrated system that combines a coarse-to-fine DETR detector (strategies A1–A3) with a non-preemptive fixed-priority scheduling framework (NPFP**, strategy A4) for multiple concurrent DETR tasks on autonomous vehicles. The coarse subtask is treated as safety-critical and guaranteed by a fixed-priority schedulability test, while fine subtasks run opportunistically, individually or batched, to improve accuracy. The authors validate the approach on KITTI with DINO on a server GPU and a Jetson Orin, and report an emergency-braking demonstration on a 1/10-scale vehicle with a Jetson TX2, claiming that CF-DETR meets firm deadlines (R1) while achieving higher critical and overall mAP than DNN-SAM baselines (R2).

Significance. If the scheduling and accuracy claims hold, the paper makes a useful contribution by co-designing a Transformer-specific coarse-to-fine mechanism with a real-time scheduling framework, rather than treating DNNs as black boxes. The explicit treatment of critical-object detection, the use of measured WCETs, and the physical AV demonstration are strengths, and the paper gives a fairly complete algorithmic description of the NPFP** family. However, the main load-bearing ingredients—the WCET upper bounds, the batch-execution inequality, and the proof of Lemma 2—are not yet rigorously validated, and the accuracy evaluation rests on a single dataset with thresholds calibrated on that same data. The central idea is defensible, but several points need to be strengthened before the claims can be accepted.

major comments (4)

[Sec. IV-A, Table II] The schedulability analysis in Lemma 1 and Lemma 2 treats C_i^S and C_BS as safe upper bounds on execution time, but Table II reports only the maximum of 1,000 measurements with no safety margin, tail analysis, or coverage argument. The text in Sec. IV-A says that predictable WCETs require intensive measurements 'complemented by appropriate safety margins,' yet no such margin is applied in the table. Since Eq. (4) and Eq. (5) are valid only if these values are true upper bounds, the R1 guarantee is not yet established. Please provide a formal margin/tail analysis or validate the worst case on adversarial inputs.
[Sec. IV-A/C, Fig. 6] The batching property C_BS ≤ Σ C_i^S is asserted 'as a property of batch execution' and is used in the proof of Lemma 2, but it is never verified against the measured batch latencies in Fig. 6. The figure shows latency distributions for batch sizes 1–6, yet the paper does not check whether the measured batch latency is actually no larger than the sum of the individual WCETs of the batched jobs. On a shared GPU, batching with padding, input-dependent attention, DVFS, or thermal throttling can violate this inequality. Please add a direct comparison of measured C_BS with Σ C_i^S over the measured distributions, and discuss the conditions under which the property holds.
[Sec. IV-C, Lemma 2] Lemma 2 is load-bearing for the entire hard-real-time claim, but its proof is too terse. The proof does not formally map the four scenario types in Fig. 5 to a complete analysis for every job of every task, and it relies on the unproven batching property. In particular, the assertion that tasks in BS finish before their deadlines 'by P2' needs to be shown explicitly, since Eq. (5) bounds completion before the earliest future release time, which is not by itself a deadline bound. Please provide a step-by-step proof for each scenario type, or give a counterexample that clarifies the exact conditions required.
[Sec. V-A, Fig. 7] The accuracy evaluation is potentially self-referential: the critical-object size threshold (>16384 pixels), the high-confidence cutoff (>0.8), and the average-confidence threshold for hard/easy frames are all derived from the same KITTI dataset used to report the mAP numbers in Fig. 7. This calibration-on-evaluation risk means the reported accuracy gains may reflect dataset-specific tuning rather than a general property. Please either calibrate thresholds on a separate split or dataset, report a sensitivity analysis over threshold values, or validate on an additional AV benchmark.

minor comments (4)

[Sec. II-B, Fig. 2] The x-axis label in Fig. 2(b), 'Object size # of patches,' mixes two different quantities; please separate the object-size axis from the patch-count legend to make the figure readable.
[Sec. IV-A, Algorithm 1] The notation NPFP** with '*' replaced by C, [C], F, and [F] is difficult to parse. A small table mapping each policy name (NPFP C, NPFP C[F], NPFP[C]F, NPFP[C][F]) to its corresponding branches in Algorithm 1 and to whether batching is used would greatly improve clarity.
[Sec. V-C, Case study] The claim that CF-DETR maintains overall accuracy comparable to DINO in the TX2 emergency-braking case study is not supported by any accuracy measurement on TX2; the cited Fig. 7 reports accuracy on the A10 and Orin platforms. Please either add TX2 accuracy numbers or qualify the claim.
[Sec. IV-A, Table II] The paper repeatedly invokes 'dedicated GPU utilization per DNN type' to justify WCET predictability, but the target system description does not specify how GPU contention from non-perception workloads or from the scheduler's own GPU operations is excluded; please make the scope explicit.

Circularity Check

0 steps flagged · score 2.0 of 10

No significant circularity: R1 rests on external standard response-time analysis with in-paper measured WCETs and explicit assumptions; R2 is an empirical held-out benchmark. Only minor non-load-bearing self-citations and KITTI-calibrated thresholds are noted; unvalidated WCET and batch-property assumptions are correctness risks, not circular steps.

full rationale

Walking CF-DETR's derivation chain, no load-bearing step reduces to its own inputs. The R1 deadline guarantee rests on Lemma 1, which is standard external response-time analysis (refs [19]-[22], including the critical-instant theorem) applied to WCETs measured in-paper (Table II, max of 1000 measurements per component) and stated task periods; the inputs do not include the guaranteed outcome, and the proof is a fixed-point iteration on external theory. Lemma 2 (batched coarse execution preserves schedulability) is proven in-paper from explicitly stated assumptions: P1 (contiguous highest-priority batches), P2 (runtime check, Eq. 5), and the batching property 'we assume CBS <= sum of C_i^S'. If those assumptions hold, the proof is sound; whether they hold empirically is a correctness/soundness risk (no safety margin is added to the measured WCETs despite the text claiming 'appropriate safety margins', and the batching property is never checked against the Fig. 6 batch-latency data), not a circular reduction. Lemma 3 is a self-contained O(N^2) DP argument. The R2 accuracy claims come from empirical evaluation on a held-out KITTI half, with CF-DETR and DNN-SAM baselines all using the same DINO detector; the mAP numbers are not computed from any fitted parameter. Minor self-citations exist (RT-MOT, DNN-SAM, Batch-MOT) as baselines and methodology references, but none is load-bearing: the WCET analysis is executed in-paper, and the batching design is followed by an explicit in-paper assumption and proof. The hardness thresholds (c > 0.8; average 0.05) and the critical-object cutoff (> 16384 pixels) are calibrated on the same KITTI benchmark family used for evaluation, which mildly self-referentially defines 'critical mAP'; since that metric is still a genuine measurement that the DNN-SAM baselines score lower on, this is calibration bias, not a by-construction equivalence. Net: no self-definitional, fitted-input-called-prediction, or uniqueness-imported circularity; score 2 reflects only the non-load-bearing self-citations and threshold-calibration self-reference.

Assumptions & free parameters 5 free parameters · 6 assumptions · 0 invented entities

The central claim depends on several manually chosen thresholds and measured WCET tables that are not publicly released. The scheduling theory additionally assumes batching never increases total work and that WCET can be bounded by measurement. These are reasonable engineering assumptions but limit how strongly the guaranteed timing results can be trusted.

free parameters (5)

Coarse patch count pS = 795 patches
Chosen from latency-accuracy measurements (Fig. 2); determines coarse subtask latency and accuracy.
High-confidence cutoff = 0.8
Used to exclude already-detected critical objects before hardness calculation (Sec. III-B A1).
Average confidence threshold for hard/easy frames = 0.05
Set based on query-confidence distribution separation in Fig. 4(b); frames with lower average are 'easy'.
Fine patch workload levels S, M, L = e.g., 3000, 4800 patches (from Fig. 4(c))
Discretized fine patch counts used for task workload and batching; chosen from KITTI region-proposal analysis.
Critical object size threshold = 16384 pixels
Defines the 'critical' accuracy metric in evaluation; objects larger than this are considered safety-critical.

assumptions (6)

domain assumption Batched execution no slower than sum of individual executions (CBS <= sum C_i^S).
Assumed in Sec. IV-A as 'a property of batch execution'; not proven for the specific GPU and model.
domain assumption Intensive measurement with safety margins yields reliable WCET upper bounds.
Sec. IV-A states this assumption explicitly; no formal proof of input-independent worst case.
domain assumption Di = Ti for all tasks and tasks are strictly periodic.
Task model in Sec. IV-A; simplifies schedulability but is a design choice.
ad hoc to paper Coarse subtasks always have higher priority than fine subtasks.
Core principle of NPFP**; this is a design decision, not proven optimal for accuracy or safety.
ad hoc to paper KITTI object area >16384 pixels correctly captures safety-critical objects.
Used to define critical accuracy; no external justification.
domain assumption No GPU resource contention between DNN and other system tasks.
Sec. IV-A mentions dedicated GPU utilization per DNN type to avoid resource contention.

how reviews work

0 comments

Cite this review

Pith. "Pith review of CF-DETR: Coarse-to-Fine Transformer for Real-Time Object Detection." pith.science (2026). https://pith.science/paper/Y3XVGIR7

@misc{pith2026250523317,
  author       = {Pith},
  title        = {Pith review of: CF-DETR: Coarse-to-Fine Transformer for Real-Time Object Detection},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/Y3XVGIR7}},
  note         = {Machine review of arXiv:2505.23317}
}

read the original abstract

Detection Transformers (DETR) are increasingly adopted in autonomous vehicle (AV) perception systems due to their superior accuracy over convolutional networks. However, concurrently executing multiple DETR tasks presents significant challenges in meeting firm real-time deadlines (R1) and high accuracy requirements (R2), particularly for safety-critical objects, while navigating the inherent latency-accuracy trade-off under resource constraints. Existing real-time DNN scheduling approaches often treat models generically, failing to leverage Transformer-specific properties for efficient resource allocation. To address these challenges, we propose CF-DETR, an integrated system featuring a novel coarse-to-fine Transformer architecture and a dedicated real-time scheduling framework NPFP**. CF-DETR employs three key strategies (A1: coarse-to-fine inference, A2: selective fine inference, A3: multi-level batch inference) that exploit Transformer properties to dynamically adjust patch granularity and attention scope based on object criticality, aiming to satisfy R2. The NPFP** scheduling framework (A4) orchestrates these adaptive mechanisms A1-A3. It partitions each DETR task into a safety-critical coarse subtask for guaranteed critical object detection within its deadline (ensuring R1), and an optional fine subtask for enhanced overall accuracy (R2), while managing individual and batched execution. Our extensive evaluations on server, GPU-enabled embedded platforms, and actual AV platforms demonstrate that CF-DETR, under an NPFP** policy, successfully meets strict timing guarantees for critical operations and achieves significantly higher overall and critical object detection accuracy compared to existing baselines across diverse AV workloads.

Figures

Figures reproduced from arXiv: 2505.23317 by the authors.

**Figure 3.** System overview of CF-DETR: Periodic frames from multiple tasks arrive and queue. The scheduler then forms initial processing batches (❶). Inputs undergo coarse batch inference using a low-res grid—yielding initial detected boxes through concurrent DETR inferences in a single batch (❷). Frames are classified by confidence as easy (high-confidence) or hard (ambiguous) (❸); this determines if fine subtasks are needed.… view at source ↗

**Figure 4.** Validation of CF-DETR’s adaptive inference strategies A1–A3 using the DINO model on Jetson Orin with the KITTI dataset: (a) sample coarse inference output; (b) hardness identification by query confidence analysis; (c) selective fine inference efficiency, showing patch count versus object coverage; and (d) multi-level batch inference latency advantages for fine-stage processing. image. These ROIs are proposed based o… view at source ↗

Figures from the paper (3 more)

**Figure 5.** Figure 5: Four types of coarse subtask batching scenarios ( [PITH_FULL_IMAGE:figures/full_fig_p008_5.png]

**Figure 7.** Figure 7: Critical and overall mAP (%): CF-DETR (under NPFP∗∗ variants) vs. DNN-SAM, on (a) server and (b) Jetson Orin across various task sets. • NPFP[C][F] where both coarse and fine subtasks are batched. We compare these against two DNN-SAM scheduling algorithms, an existing…

**Figure 8.** Figure 8: Per-task FPS: CF-DETR (under NPFP∗∗ variants) vs. DNN-SAM on Jetson Orin for four-task sets (490,640,840,980). reduce critical accuracy. Regarding overall accuracy, DNNSAM algorithms show a significant performance drop due to a lack of batch support and potentially re…

Discussion (0). Continue with ORCID to comment.

Reference graph

Works this paper leans on

27 extracted references · 19 canonical work pages

[1]

Detrs beat yolos on real-time object detection,

Y . Zhao, W. Lv, S. Xu, J. Wei, G. Wang, Q. Dang, Y . Liu, and J. Chen, “Detrs beat yolos on real-time object detection,” in Proceedings of the IEEE/CVF conference on computer vision and pattern recognition, 2024, pp. 16 965–16 974

work page 2024
[2]

Deformable detr: Deformable transformers for end-to-end object detection,

X. Zhu, W. Su, L. Lu, B. Li, X. Wang, and J. Dai, “Deformable detr: Deformable transformers for end-to-end object detection,”arXiv preprint arXiv:2010.04159, 2020

arXiv 2010
[3]

End-to-end object detection with transformers,

N. Carion, F. Massa, G. Synnaeve, N. Usunier, A. Kirillov, and S. Zagoruyko, “End-to-end object detection with transformers,” in European conference on computer vision . Springer, 2020, pp. 213– 229

2020
[4]

A-vit: Adaptive tokens for efficient vision transformer,

H. Yin, A. Vahdat, J. M. Alvarez, A. Mallya, J. Kautz, and P. Molchanov, “A-vit: Adaptive tokens for efficient vision transformer,” in Proceedings of the IEEE/CVF conference on computer vision and pattern recognition, 2022, pp. 10 809–10 818

work page 2022
[5]

Token merging: Your vit but faster,

D. Bolya, C.-Y . Fu, X. Dai, P. Zhang, C. Feichtenhofer, and J. Hoffman, “Token merging: Your vit but faster,” arXiv preprint arXiv:2210.09461, 2022

arXiv 2022
[6]

RT-MOT: Confidence-aware real-time scheduling framework for multi-object tracking tasks,

D. Kang, S. Lee, H. S. Chwa, S.-H. Bae, C. M. Kang, J. Lee, and H. Baek, “RT-MOT: Confidence-aware real-time scheduling framework for multi-object tracking tasks,” in IEEE Real-Time Systems Symposium (RTSS), 2022, pp. 318–330

work page 2022
[7]

DNN-SAM: Split-and-merge dnn execution for real-time object detection,

W. Kang, S. Chung, J. Y . Kim, Y . Lee, K. Lee, J. Lee, K. G. Shin, and H. S. Chwa, “DNN-SAM: Split-and-merge dnn execution for real-time object detection,” in IEEE Real-Time and Embedded Technology and Applications Symposium (RTAS) , 2022, pp. 160–172

work page 2022
[8]

Real-time scheduling for multi-object tracking tasks in regions with different criticalities,

D. Kang, J. Lee, and H. Baek, “Real-time scheduling for multi-object tracking tasks in regions with different criticalities,” Journal of Systems Architecture, p. 103349, 2025

work page 2025

Show all 27 references

[9]

Self-cueing real-time attention scheduling in criticality-aware visual machine perception,

S. Liu, X. Fu, M. Wigness, P. David, S. Yao, L. Sha, and T. Abdelzaher, “Self-cueing real-time attention scheduling in criticality-aware visual machine perception,” in IEEE Real Time Technology and Applications Symposium (RTAS), 2022, pp. 173–186

2022
[10]

Sˆ3DNN: Supervised streaming and scheduling for GPU-accelerated real-time DNN workloads,

H. Zhou, S. Bateni, and C. Liu, “Sˆ3DNN: Supervised streaming and scheduling for GPU-accelerated real-time DNN workloads,” in IEEE Real-Time and Embedded Technology and Applications Symposium (RTAS), 2018, pp. 190–201

2018
[11]

Pipelined data-parallel CPU/GPU scheduling for multi-DNN real-time inference,

Y . Xiang and H. Kim, “Pipelined data-parallel CPU/GPU scheduling for multi-DNN real-time inference,” in IEEE Real-Time Systems Symposium (RTSS), 2019, pp. 392–405

2019
[12]

R-TOD: Real- time object detector with minimized end-to-end delay for autonomous driving,

W. Jang, H. Jeong, K. Kang, N. Dutt, and J.-C. Kim, “R-TOD: Real- time object detector with minimized end-to-end delay for autonomous driving,” in IEEE Real-Time Systems Symposium (RTSS) , 2022, pp. 1– 14

2022
[13]

Cf-vit: A general coarse-to-fine method for vision transformer,

M. Chen, M. Lin, K. Li, Y . Shen, Y . Wu, F. Chao, and R. Ji, “Cf-vit: A general coarse-to-fine method for vision transformer,” in Proceedings of the AAAI conference on artificial intelligence , vol. 37, no. 6, 2023, pp. 7042–7052

2023
[14]

You only look once: Unified, real-time object detection,

J. Redmon, S. Divvala, R. Girshick, and A. Farhadi, “You only look once: Unified, real-time object detection,” in Proceedings of the IEEE conference on computer vision and pattern recognition , 2016, pp. 779– 788

2016
[15]

Dino: Detr with improved denoising anchor boxes for end-to- end object detection,

H. Zhang, F. Li, S. Liu, L. Zhang, H. Su, J. Zhu, L. M. Ni, and H.-Y . Shum, “Dino: Detr with improved denoising anchor boxes for end-to- end object detection,” arXiv preprint arXiv:2203.03605 , 2022

2022 arXiv
[16]

Are we ready for autonomous driv- ing? the kitti vision benchmark suite,

A. Geiger, P. Lenz, and R. Urtasun, “Are we ready for autonomous driv- ing? the kitti vision benchmark suite,” in Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR), 2012

2012
[17]

[Online]

NVIDIA Orin Developer Kit. [Online]. Available: https://www.nvidia. com/ko-kr/autonomous-machines/embedded-systems/jetson-orin/
[18]

Batch-MOT: Batch-enabled real-time scheduling for multi-object tracking tasks,

D. Kang, S. Lee, C.-H. Hong, J. Lee, and H. Baek, “Batch-MOT: Batch-enabled real-time scheduling for multi-object tracking tasks,” in Proceedings of ACM & IEEE International Conference on Embedded Software (EMSOFT), 2024, pp. 1–12

2024
[19]

Effective analysis for engineer- ing real-time fixed priority schedulers,

A. Burns, K. Tindell, and A. Wellings, “Effective analysis for engineer- ing real-time fixed priority schedulers,” IEEE Transactions on Software Engineering (TSE), vol. 21, no. 5, pp. 475–480, 1995

1995
[20]

Feasibility analysis under fixed priority scheduling with fixed preemption points,

G. Yao, G. Buttazzo, and M. Bertogna, “Feasibility analysis under fixed priority scheduling with fixed preemption points,” in IEEE International Conference on Embedded and Real-Time Computing Systems and Ap- plications (RTCSA), 2010, pp. 71–80

2010
[21]

Non-preemptive and limited preemptive scheduling,

J.-J. Chen and G. von der Bruggen, “Non-preemptive and limited preemptive scheduling,” Lecture Note in TU Dortmund , 2017. [Online]. Available: https://ls12-www.cs.tu-dortmund.de/daes/media/documents/ teaching/courses/rts/non-preemptive-scheduling.pdf

2017
[22]

Preemptive and non-preemptive real-time uniprocessor scheduling,

L. George, N. Rivierre, and M. Spuri, “Preemptive and non-preemptive real-time uniprocessor scheduling,” Inria, Tech. Rep., 1996

1996
[23]

Deep residual learning for image recognition,

K. He, X. Zhang, S. Ren, and J. Sun, “Deep residual learning for image recognition,” in Proceedings of the IEEE conference on computer vision and pattern recognition , 2016, pp. 770–778

2016
[24]

Microsoft coco: Common objects in context,

T.-Y . Lin, M. Maire, S. Belongie, J. Hays, P. Perona, D. Ramanan, P. Doll ´ar, and C. L. Zitnick, “Microsoft coco: Common objects in context,” in Computer vision–ECCV 2014: 13th European conference, zurich, Switzerland, September 6-12, 2014, proceedings, part v 13 . Springer,...

2014
[25]

The rate monotonic scheduling algorithm: Exact characterization and average case behavior,

J. Lehoczky, L. Sha, and Y . Ding, “The rate monotonic scheduling algorithm: Exact characterization and average case behavior,” in IEEE Real-Time Systems Symposium (RTSS) , 1989, pp. 166–171

1989
[26]

Scheduling algorithms for multiprogram- ming in a hard-real-time environment,

C. L. Liu and J. W. Layland, “Scheduling algorithms for multiprogram- ming in a hard-real-time environment,” Journal of the ACM (JACM) , vol. 20, no. 1, pp. 46–61, 1973

1973
[27]

An image is worth 16x16 words: Transformers for image recognition at scale,

A. Dosovitskiy, L. Beyer, A. Kolesnikov, D. Weissenborn, X. Zhai, T. Unterthiner, M. Dehghani, M. Minderer, G. Heigold, S. Gelly et al., “An image is worth 16x16 words: Transformers for image recognition at scale,” arXiv preprint arXiv:2010.11929 , 2020. 12

2010 arXiv

Pith tools

Reviewed August 7, 2026 · model on record in the stance chip above.

[1] [1]

Detrs beat yolos on real-time object detection,

Y . Zhao, W. Lv, S. Xu, J. Wei, G. Wang, Q. Dang, Y . Liu, and J. Chen, “Detrs beat yolos on real-time object detection,” in Proceedings of the IEEE/CVF conference on computer vision and pattern recognition, 2024, pp. 16 965–16 974

work page 2024

[2] [2]

Deformable detr: Deformable transformers for end-to-end object detection,

X. Zhu, W. Su, L. Lu, B. Li, X. Wang, and J. Dai, “Deformable detr: Deformable transformers for end-to-end object detection,”arXiv preprint arXiv:2010.04159, 2020

arXiv 2010

[3] [3]

End-to-end object detection with transformers,

N. Carion, F. Massa, G. Synnaeve, N. Usunier, A. Kirillov, and S. Zagoruyko, “End-to-end object detection with transformers,” in European conference on computer vision . Springer, 2020, pp. 213– 229

2020

[4] [4]

A-vit: Adaptive tokens for efficient vision transformer,

H. Yin, A. Vahdat, J. M. Alvarez, A. Mallya, J. Kautz, and P. Molchanov, “A-vit: Adaptive tokens for efficient vision transformer,” in Proceedings of the IEEE/CVF conference on computer vision and pattern recognition, 2022, pp. 10 809–10 818

work page 2022

[5] [5]

Token merging: Your vit but faster,

D. Bolya, C.-Y . Fu, X. Dai, P. Zhang, C. Feichtenhofer, and J. Hoffman, “Token merging: Your vit but faster,” arXiv preprint arXiv:2210.09461, 2022

arXiv 2022

[6] [6]

RT-MOT: Confidence-aware real-time scheduling framework for multi-object tracking tasks,

D. Kang, S. Lee, H. S. Chwa, S.-H. Bae, C. M. Kang, J. Lee, and H. Baek, “RT-MOT: Confidence-aware real-time scheduling framework for multi-object tracking tasks,” in IEEE Real-Time Systems Symposium (RTSS), 2022, pp. 318–330

work page 2022

[7] [7]

DNN-SAM: Split-and-merge dnn execution for real-time object detection,

W. Kang, S. Chung, J. Y . Kim, Y . Lee, K. Lee, J. Lee, K. G. Shin, and H. S. Chwa, “DNN-SAM: Split-and-merge dnn execution for real-time object detection,” in IEEE Real-Time and Embedded Technology and Applications Symposium (RTAS) , 2022, pp. 160–172

work page 2022

[8] [8]

Real-time scheduling for multi-object tracking tasks in regions with different criticalities,

D. Kang, J. Lee, and H. Baek, “Real-time scheduling for multi-object tracking tasks in regions with different criticalities,” Journal of Systems Architecture, p. 103349, 2025

work page 2025