Object Detection · Retina

What is Qwen3-VL-4B-Instruct?

Qwen3-VL-4B-Instruct solves the problem of understanding images and video through natural-language instructions by using a four-billion-parameter vision-language model. Learn the architecture of Qwen3-VL-4B-Instruct, the loss functions it was trained with, and how to use it in the Telekinesis Agentic OS.

Imagine asking a warehouse robot to find “the damaged carton beside the blue pallet.” The request contains an object, a visual property, and a relationship. Qwen3-VL-4B-Instruct can use all three because it processes the camera image and the instruction inside one multimodal model. This tutorial follows the exact path from pixels to patches, visual tokens, language-conditioned reasoning, and grounded coordinates.

1. What is Qwen3-VL-4B-Instruct?

Qwen3-VL-4B-Instruct is a dense, four-billion-parameter vision-language model trained to follow instructions about images, text, and video. The easiest way to understand it is to use the same division as the technical report: a vision encoder reads the visual input, an MLP vision–language merger converts visual features into the language model’s representation, and a Qwen3 language model interprets those visual tokens together with the instruction.

Its name identifies the Qwen3 generation, a vision-language (VL) interface, a compact dense 4B parameter tier, and an Instruct checkpoint post-trained for direct conversational requests rather than the separate Thinking edition’s extended reasoning behavior.

For the Telekinesis detection Skill, the practical task is visual grounding. Classification asks whether a pallet exists. Detection asks where all pallets from a known class vocabulary are. Grounding asks which image region corresponds to a phrase such as the pallet behind the forklift. The text determines which visual evidence matters.

Unlike a detector with a dedicated box head, Qwen ultimately expresses its answer through the language model. It can generate words, points, or box coordinates in response to an instruction. That provides semantic flexibility, but it also means the result is generated rather than emitted by a conventional detection head and must be validated accordingly.

1.1 The Complete Path From an Image to an Answer

The paper’s three-module architecture

Image or videoDynamic-resolution visual input
Vision encoderSigLIP-2 turns patches into contextual features
MLP vision–language mergerCompresses 2 × 2 features and matches LLM width
Qwen3 language modelThe text instruction joins the visual tokens here
Generated responseLanguage, points, or grounded boxes

DeepStack is an extra connection between the vision encoder and early LLM layers; it is not a fourth top-level module.

Qwen3-VL is organized around three modules in the technical report: a vision encoder, an MLP vision–language merger, and a Qwen3 language model. The text instruction joins the visual stream at the language model. Adapted as an explanatory diagram fromQwen Team, “Qwen3-VL”.

The paper organizes Qwen3-VL into three top-level modules. Following those three modules gives us a simple mental model before we examine patch sizes, positional encodings, and generation.

First, the vision encoder reads the image. It divides the image into patches and turns them into visual features. Self-attention then gives each patch context from other parts of the scene, so a brown region can be interpreted together with its edges, label, and surrounding pallet rather than as an isolated patch of color.

Second, the MLP vision–language merger prepares those visual features for the language model. It groups nearby patch features to shorten the sequence and projects them to the numerical width expected by Qwen3. The result is a sequence of visual tokens that the language model can accept alongside ordinary text tokens.

Third, the Qwen3 language model receives those visual tokens together with the user’s instruction. It processes both in one multimodal context and generates an answer token by token. If the instruction requests localization, that answer can contain labels and coordinate tokens rather than only prose.

Patchification belongs inside the vision encoder’s path. DeepStack supplies an additional route from intermediate vision features into early language-model layers, and interleaved M-RoPE preserves spatial and temporal position. These mechanisms enrich the three-module flow rather than forming separate top-level networks. The rest of Section 1 now follows the image through that flow in detail.

The 4B model combines useful language understanding with a much smaller serving footprint than the 32B dense or 235B mixture-of-experts variants.

Its published configuration gives a concrete picture of what “4B” contains:

ComponentQwen3-VL-4B-Instruct configurationWhy it matters
Vision encoder24 transformer layers, width 1,024, 16 attention headsBuilds contextual visual features
Image patch16×1616\times16 pixelsSets the initial spatial sampling unit
Spatial merger2×22\times2 patch groupsReduces four visual features to one token
Language decoder36 layers, hidden width 2,560Combines prompt and visual evidence
Language attention32 query heads, 8 key/value headsGrouped-query attention reduces KV-cache cost
Native context262,144 tokensSupports long interleaved text, images, and video
Positional encodingInterleaved M-RoPERepresents text, spatial, and temporal position

These are architectural limits, not robot-performance guarantees; long contexts increase latency and can retain stale observations.

1.2 The Vision Encoder Turns Image Patches Into Visual Features

The first module begins with preprocessing. The image processor decodes and normalizes the RGB image, then resizes it within an allowed pixel budget while preserving its aspect ratio. Qwen3-VL calls this dynamic resolution: a wide conveyor image can remain wide instead of being squeezed into one fixed square.

A transformer cannot consume a two-dimensional pixel array directly. The image is therefore divided into small square regions called patches. Each patch is converted into a vector—a list of learned numerical features—and that vector becomes a visual token. A token is simply one item in the sequence processed by a transformer.

Dynamic resolution means computational cost follows image area. For a processed image of height HH and width WW, a simplified patch count is

Npatch=H16W16.N_{patch}=\frac{H}{16}\frac{W}{16}.

Here, NpatchN_{patch} is the number of patch positions, while HH and WW are the processed image height and width in pixels. The divisor 16 is Qwen3-VL’s patch size along each axis.

Each 16×1616\times16 region is projected into a vector:

xi=Wpvec⁡(Pi)+bp.\mathbf{x}_{i}=\mathbf{W}_{p}\operatorname{vec}(\mathbf{P}_{i})+\mathbf{b}_{p}.

Pi\mathbf{P}_{i} contains patch ii; vec⁡\operatorname{vec} flattens it, Wp\mathbf{W}_{p} is the learned projection, bp\mathbf{b}_{p} its bias, and xi\mathbf{x}_{i} the resulting embedding. It represents a local region and position—not yet an object such as “carton.”

At this point, the vectors still describe local patches rather than complete objects. The rest of the vision encoder supplies context. Qwen3-VL uses a SigLIP-2-based Vision Transformer; for the 2B and 4B models, the report specifies SigLIP2-Large rather than the larger visual backbone used by bigger family members.

Inside every vision block, self-attention lets one patch gather information from other patches:

Attention⁡(Q,K,V)=softmax⁡ ⁣(QKTd)V.\operatorname{Attention}(Q,K,V)= \operatorname{softmax}\!\left(\frac{QK^{\mathsf T}}{\sqrt d}\right)V.

Here, QQ, KK, and VV are the query, key, and value matrices derived from patch features; dd is the key dimension used to scale the dot products; and softmax converts the query–key scores into normalized attention weights.

A brown patch alone could be cardboard, timber, or floor. Self-attention lets it gather evidence from nearby edges, printed labels, and the wider scene. Across 24 transformer layers, isolated patch vectors become contextual visual features. This completes the main job of the first module.

Patch size and image resolution therefore form the first engineering trade-off. More pixels preserve small details, but they also create more patches. No language model can recover a defect that occupies too few input pixels.

1.3 The MLP Merger Makes the Visual Sequence Smaller

The vision encoder and Qwen3 language model do not use the same feature width, and sending every patch feature to the language model would be expensive. The paper’s second module—the MLP vision–language merger—solves both problems. MLP means multilayer perceptron: a small learned network that transforms each group of input features into a new vector. Here, it groups each neighbouring 2×22\times2 set of visual features, compresses that group into one token, and projects the result into the language model’s 2,560-dimensional hidden space.

The approximate token count after spatial merging is

Nvisual≈H32W32.N_{visual}\approx\frac{H}{32}\frac{W}{32}.

Here, NvisualN_{visual} is the number of merged visual tokens. HH and WW again denote processed image dimensions, while 32 is the effective spatial step produced by a 16-pixel patch followed by a 2×22\times2 merger.

A 1024×10241024\times1024 image therefore produces roughly 1,024 merged positions; a 512×512512\times512 image produces about 256. Resolution is also a token-budget setting.

The merger performs two jobs. It compresses the sequence so the language decoder has less work, and it projects visual features from width 1,024 into the decoder’s width 2,560. Unlike the fixed 256-query adapter in the original Qwen-VL model, the Qwen3-VL token count changes with image resolution.

Compression can weaken very small boundaries. Test the smallest object, narrowest gap, and finest printed text required by the task.

Interactive visual token budget

Change image resolution and patch merging

—
16 × 16 image patchesvisual tokens

Qwen3-VL uses dynamic resolution: more image area produces more visual tokens and therefore more language-model work.

1.4 The Qwen3 Language Model Combines Vision With the Instruction

Visual tokens + prompt → grounded response

Visual tokensImage evidence in embedding space
Text promptTask and referring expression
Multimodal sequenceImage boundaries and text tokens
36-layer Qwen3 decoderCausal attention with GQA
Autoregressive decodingOne output token at a time
Grounded responseText, references, and coordinates

The prompt conditions which visual evidence matters because generated text states can attend back to the preceding visual tokens.

Qwen3-VL places projected visual tokens inside the Qwen3 context and generates grounded text, points, and boxes autoregressively. Adapted as an explanatory diagram fromQwen Team, “Qwen3-VL”.

The third module is the 36-layer Qwen3 causal language model. The merged visual tokens are placed in its context, and the text instruction joins them there. Conceptually, the decoder receives

[⟨vision⟩,v1,…,vM,⟨/vision⟩,t1,…,tL].[\langle vision\rangle,\mathbf{v}_{1},\ldots,\mathbf{v}_{M}, \langle/vision\rangle,\mathbf{t}_{1},\ldots,\mathbf{t}_{L}].

Here, vi\mathbf{v}_i is visual token ii and MM is the number of visual tokens; tj\mathbf{t}_j is text token jj and LL is the instruction length. The angle-bracket markers identify the visual portion of the multimodal sequence.

The image features do not change when the wording changes, but the language model’s use of them does. The instructions find every carton and find the damaged carton beside the pallet direct attention toward different evidence in the same visual representation. This is the core mechanism behind language-conditioned visual understanding.

The 4B model uses grouped-query attention: 32 query heads share 8 key/value heads. Sharing fewer key/value projections reduces KV-cache memory during long-context generation, which matters when several images, video frames, or a long robot history occupy the context.

1.5 DeepStack Adds Earlier Visual Features to the Language Model

Multi-level vision → DeepStack fusion

ViT feature hierarchyEarly, middle, and deep visual states
Feature tapsViT layers 5, 11, and 17
Dedicated mergersCompress and project each level
Residual injectionAdd vision to LLM layers 1–3
Fused language statesFine and semantic visual evidence

DeepStack gives early LLM layers fresh intermediate visual features without lengthening the token sequence.

Qwen3-VL uses DeepStack to merge three intermediate ViT feature levels and add them to corresponding early layers of the language model. Adapted as an explanatory diagram fromQwen Team, “Qwen3-VL”.

We can now see the limitation of the main three-module path. The merger normally receives the final vision-encoder features. Those features are semantically strong—they are good at representing that a region is a carton—but some fine local detail may be clearer in earlier vision layers.

DeepStack creates extra connections from those intermediate vision layers into the language model. For the 4B configuration, it taps vision layers 5, 11, and 17. Dedicated mergers compress and project each feature level, then add the resulting vectors to the corresponding hidden states of the first three language-model layers.

The vectors are added to existing states rather than appended as new context tokens, so the sequence does not become longer. The main merger supplies the final semantic representation; DeepStack supplements it with earlier visual detail. In a warehouse example, fine features may preserve a torn cardboard edge while deeper features establish that the region is a carton.

1.6 Positional Encoding Preserves Where and When Things Appear

A language model must distinguish token order. A vision-language model must additionally preserve image height, image width, and—for video—time. Qwen3-VL uses interleaved Multimodal Rotary Position Embeddings, or interleaved M-RoPE.

Qwen3-VL interleaves temporal, horizontal, and vertical axes across low- and high-frequency bands. Consequently, similar tokens at different image positions receive different phase information, allowing the decoder to learn above, inside, and left of.

M-RoPE represents image layout, not calibrated geometry. Camera intrinsics, metric depth, and robot-frame transforms still come from the surrounding system.

1.7 Autoregressive Generation Produces Words and Coordinates

Qwen3-VL generates output autoregressively:

P(y∣I,p)=∏k=1TP(yk∣I,p,y1,…,yk−1).P(\mathbf{y}\mid I,p)=\prod_{k=1}^{T} P(y_k\mid I,p,y_1,\ldots,y_{k-1}).

Here, y=(y1,…,yT)\mathbf{y}=(y_1,\ldots,y_T) is the complete generated response of length TT; II is the encoded image, pp is the prompt, kk is the generation step, and PP denotes conditional probability.

Every token depends on the image, prompt, and previous answer tokens. For grounding, Qwen3-VL is trained to produce boxes and points with relative coordinates normalized to [0,1000][0,1000]. A structured response can represent a box as {"bbox_2d": [x_1, y_1, x_2, y_2]}.

For an image with width WW and height HH, the corresponding pixel coordinates are approximately

xpx=xnorm1000W,ypx=ynorm1000H.x_{px}=\frac{x_{norm}}{1000}W, \qquad y_{px}=\frac{y_{norm}}{1000}H.

Here, xnormx_{norm} and ynormy_{norm} are generated coordinates on the normalized 0–1000 scale; xpxx_{px} and ypxy_{px} are pixel coordinates; and WW and HH are the original image width and height.

Coordinates are generated as text tokens learned from grounding supervision; there is no final box-regression head or NMS. The output must therefore be parsed and validated.

A box remains a 2D hypothesis. It contains no verified depth, surface normal, collision state, or grasp pose. Before motion, associate it with synchronized depth or segmentation, transform the resulting geometry through calibrated frames, and apply reachability and collision checks.

1.8 The Loss Function Teaches Qwen to Predict the Next Token

Qwen3-VL is trained as an autoregressive model. During training, it is shown the correct response and asked to predict every next token from the preceding image and text context. If the correct next token is yky_k, the token-level cross-entropy loss is

Lk=−log⁡P(yk∣I,p,y<k).\mathcal{L}_{k}=-\log P(y_k\mid I,p,y_{<k}).

Here, Lk\mathcal{L}_k is the loss at output position kk; II is the encoded visual input; pp is the instruction; y<ky_{<k} denotes all correct response tokens before position kk; and P(yk∣I,p,y<k)P(y_k\mid I,p,y_{<k}) is the probability the model assigned to the correct token.

The model minimizes a weighted aggregate of these token losses. This one objective can teach many behaviours because the target sequence can contain ordinary words, structured markup, point coordinates, or box coordinates. For grounding examples, predicting the wrong coordinate token produces loss just as predicting the wrong noun does. Qwen therefore learns localization through the language-generation objective rather than through a separate box-regression head.

The Qwen3-VL report also changes how losses from examples of different lengths are balanced. A simple per-sample average can give a short caption and a very long multimodal document similar overall influence, even though their token counts differ greatly. The report uses a square-root-normalized per-token loss to balance text-only and multimodal data more carefully. The exact weighting is an optimization choice; the mental model remains next-token prediction across a diverse multimodal mixture.

Post-training adds further objectives. Supervised fine-tuning continues to train on desired responses, teacher distillation transfers behaviour from stronger models, and reinforcement learning rewards outputs that satisfy reasoning and instruction-following criteria. These stages shape the Instruct checkpoint, but they do not add a separate detection head.

1.9 The Training Stages Align Vision and Language

Qwen3-VL begins with a 67-billion-token alignment stage that trains only the merger on captions, visual knowledge, and OCR while freezing both backbones. Full-parameter pre-training then uses about one trillion tokens at 8K context, another trillion at 32K, and 100 billion tokens for 256K-context adaptation.

Its mixture covers captions, interleaved documents, OCR, VQA, 2D/3D grounding, counting, spatial reasoning, STEM, code, GUI agents, and video. Grounding sources include COCO, Objects365, OpenImages, RefCOCO/+/g, and filtered synthetic annotations. Supervised instructions, teacher distillation, and reinforcement learning then produce the Instruct behavior.

Training breadth explains both the model’s strength and its limit. It can connect unfamiliar wording to broad visual concepts, but it may still fail on proprietary parts, unusual camera spectra, rare defects, or workcell views absent from that distribution.

1.10 How Qwen3-VL Differs From a Conventional Detector

QuestionConventional detectorQwen3-VL-4B-Instruct
InputImageImage plus natural-language instruction
VocabularyUsually fixed during trainingConcepts and relationships expressed in text
Visual interfaceDetector feature mapsDynamic visual tokens projected into an LLM
LocalizationDedicated box headGenerated relative coordinate tokens
Duplicate handlingOften NMS or set predictionLearned structured generation
Best fitRepeated known classes at high rateAttributes, relations, OCR, flexible requests
Main riskMissed trained objectsPlausible but unsupported or malformed output

A detector is usually better when the robot repeatedly tracks the same known categories and latency must be predictable. Qwen3-VL becomes valuable when the instruction contains information that a class ID loses: the open drawer, the warning label reading corrosive, or the tool beneath the red cable.

The two architectures can cooperate. Qwen can interpret the instruction and nominate a target; a detector can track it at frame rate; a segmenter can refine its boundary; and calibrated depth can recover physical geometry.

1.11 How the Qwen-VL Family Evolved

GenerationRepresentative modelsMain architectural changePractical meaning
Qwen-VL7B, 7B-ChatViT-bigG plus a fixed 256-query adapterEstablished unified language, OCR, and grounding
Qwen2-VL2B, 7B, 72BDynamic resolution, 2×2 patch merging, M-RoPEVisual token count follows image detail
Qwen2.5-VL3B, 7B, 32B, 72BImproved temporal modeling, localization, and structured outputsStronger documents, video, and agent use
Qwen3-VL2B–235B-A22BInterleaved M-RoPE, DeepStack, explicit video timestampsMulti-level visual fusion and long multimodal context

The important discontinuity is between original Qwen-VL and the current model. Qwen3-VL-4B-Instruct does not use the original fixed 256-token position-aware adapter. It uses a dynamic SigLIP-2 vision encoder, spatial patch merging, and DeepStack.

1.12 Choosing Among the Qwen3-VL Model Sizes

Every Qwen3-VL size is released in an Instruct edition for direct answers and a Thinking edition for more deliberate reasoning. Dense models activate all parameters for every token. MoE models store many expert parameters but activate only a subset, written after A in the name.

Family memberArchitectureEditionsRelative deployment position
Qwen3-VL-2BDense, 2BInstruct, ThinkingLowest resource demand; edge-oriented experiments
Qwen3-VL-4BDense, 4BInstruct, ThinkingTelekinesis focus: compact semantic grounding
Qwen3-VL-8BDense, 8BInstruct, ThinkingMore capacity with higher memory and latency
Qwen3-VL-32BDense, 32BInstruct, ThinkingHigh-quality dense deployment
Qwen3-VL-30B-A3BMoE, 30B total / 3B activeInstruct, ThinkingLower active compute with MoE serving complexity
Qwen3-VL-235B-A22BMoE, 235B total / 22B activeInstruct, ThinkingFlagship quality; distributed cloud-scale serving

Parameter count alone does not choose the best robotics model. Compare task accuracy, time to first token, total generation latency, memory, image-token budget, and failure behavior on the target hardware. The 4B Instruct edition is attractive when direct structured output and practical serving matter more than extended visible reasoning.

1.13 Engineering Trade-offs for Robotics

  • Resolution versus latency: more pixels create more visual tokens and more LLM work. Set an explicit pixel budget for each camera mode.
  • Semantic flexibility versus repeatability: natural language handles attributes and relationships, but paraphrases can change the result. Test a controlled prompt set.
  • Long context versus fresh state: 256K tokens support rich histories, but moving robots should not reason from stale frames. Timestamp and retire old observations.
  • Generation versus rigid schemas: generated coordinates are flexible, but require JSON parsing, range checks, duplicate handling, and a safe no-result path.
  • 4B efficiency versus difficult reasoning: the compact model is easier to serve; larger or Thinking variants may solve harder tasks but raise latency and memory.
  • Image position versus physical position: normalized 2D coordinates are not metric robot coordinates. Calibration and depth remain mandatory.

The paper’s three-module story now gives us a compact mental model. The vision encoder converts a dynamic image grid into contextual features. The MLP merger compresses and projects those features into visual tokens. The Qwen3 language model combines those tokens with the instruction and generates an answer. DeepStack strengthens the connection between the first and third modules, while interleaved M-RoPE preserves spatial and temporal position. Every implementation detail fits somewhere inside that flow.

2. How to Use Qwen3-VL-4B-Instruct in the Telekinesis Agentic OS

Telekinesis provides Qwen3-VL-4B-Instruct grounding as the Retina Skill detect_objects_using_qwen. The code below loads an image, requests three object names, and prints the typed categories, scores, and boxes returned by the Skill.

from telekinesis import datatypes, retina

image = datatypes.Image.from_url(
    url="https://assets.telekinesis.ai/examples/v1/images/warehouse_1.jpg"
)

detections, categories = retina.detect_objects_using_qwen(
    image=image,
    objects=["person", "forklift", "pallet"],
)

for detection in detections:
    label = categories[detection.category_id]
    print(label.name, detection.score, detection.bbox)

The visualization shows the structured grounding result rather than free-form model prose. Check that every returned box is supported by visible evidence, especially when the requested object is absent or several similar instances are present.

Qwen3-VL-4B-Instruct object detection output in a warehouse scene

Qwen3-VL-4B-Instruct uses multimodal understanding to localize requested concepts. Treat every box as a hypothesis until downstream geometry validates it.

Try it out

Build with Qwen3-VL-4B-Instruct in Retina

See the complete Skill signature, typed inputs, output schema, and current examples.

Open Qwen docs

Runnable example

Run the Qwen detection example

Open the exact Python script used to detect requested objects with Qwen and Retina.

View Python example

3. Benchmarking

3.1 Results Reported for Qwen3-VL-4B

The Qwen3-VL technical report evaluates a broad multimodal model, so no single score describes it. The tables below extract the 4B results most relevant to robot perception and keep Instruct separate from Thinking. The Telekinesis Skill uses the Instruct edition.

Visual Reasoning and General VQA

Benchmark4B Thinking4B InstructWhat it probes
MMMU70.867.4Multi-discipline image reasoning
MMMU-Pro57.053.2Harder, less shortcut-prone MMMU
MathVista mini79.573.7Visual mathematical reasoning
MathVision60.051.6Diagram and competition-style math
MMBench-EN84.683.9General visual question answering
RealWorldQA73.270.9Questions about real-world imagery
HallusionBench64.157.6Resistance to visually unsupported answers

Thinking usually improves difficult reasoning, but it also generates more tokens and is not the edition used by the Skill.

2D/3D Grounding, Counting, and Spatial Understanding

Benchmark4B Thinking4B InstructMetric / interpretation
RefCOCO average88.289.0Referring-expression grounding accuracy
CountBench89.484.9Counting accuracy
ODinW-1339.448.2Open-vocabulary detection mAP
ARKitScenes46.356.63D grounding mAP@0.15
Hypersim11.912.23D grounding mAP@0.15
SUN RGB-D28.034.73D grounding mAP@0.15
ERQA47.341.3Embodied reasoning
VSI-Bench55.259.3Visual-spatial intelligence
EmbSpatialBench80.779.6Embodied spatial relations
RefSpatialBench45.346.6Spatial referring expressions
RoboSpatialHome63.261.7Home-robot spatial understanding

The mixed pattern matters. Thinking is not universally better: the 4B Instruct checkpoint scores higher on ODinW-13 and all three reported 3D grounding datasets. Benchmark the exact checkpoint and prompting mode used in production.

OCR and Document Understanding

Benchmark4B Thinking4B Instruct
DocVQA test94.295.3
InfoVQA test83.080.3
ChartQA test88.884.6
OCRBench808881
OCRBench v2 English61.863.7
CC-OCR73.876.2

Video Understanding

Benchmark4B Thinking4B Instruct
MVBench69.368.9
Video-MME without subtitles68.969.3
MLVU M-Avg75.775.3
LVBench53.556.2
Charades-STA mIoU59.055.5
VideoMMMU69.456.2

These paper results establish capability, not safe robot behavior or Telekinesis service performance. Build a prompt-by-scene test set and report box success at an IoU tolerance, negative-scene hallucination rate, malformed-output rate, duplicate rate, time to first token, total latency, and final robot-task success.

3.2 Comparison with Other Telekinesis Skills

SkillQueryThreshold controlStrongest reason to choose it
Qwen3-VL-4B-InstructRequested names or conceptsNo exposed tuning thresholdAttributes, relationships, OCR, and semantic flexibility
Grounding DINONames or phrasesBox and text thresholdsDetection-focused open-vocabulary grounding
RF-DETRCOCO class setScore thresholdEnd-to-end fixed-vocabulary set prediction
YOLOXCOCO class setScore and NMS thresholdsEfficient dense detection with explicit suppression control

4. Where to Go Next?

5. References