SYNTOLOGY HomeExplorerAtlasCodeMethodologyAboutDevelopersFeedPricing
Paper · 2212.07289 · 2022

ConQueR: Query Contrast Voxel-DETR for 3D Object Detection

arXiv · PDF · Open in the Atlas

Code that ran

7 of 8 samples (functions and classes) lifted from this paper's linked repositories executed on a synthesized input in Syntology's jail (0 of them constructed an object rather than computing a result; 0 honoured the contract we drafted, 0 violated it and 4 have no contract verdict; 3 failures of our instrument; 1 no recorded run), measured 2026-11-22; repository links from the Papers with Code archive attributed under CC BY-SA, no affiliation; bodies inline only under a permissive licence as GitHub detects it. Not a reproduction of the paper's results.

"Ran" means the function executed on a synthesized input and returned a value. It is not a reproduction of the paper's results. This record, dated, as JSON: /api/ran/2212.07289.json · badge: /api/ran/2212.07289.svg

Each repository's role is a label: a classifier's output recorded on the link, or, where no role is recorded, what the Papers with Code archive marked. The line under it names its basis. Neither says who wrote the code.

RepositoryRoleRan
poodarchu/ConQueR canonical (classifier label)
classifier basis not recorded on the link
7 ran · 1 no recorded run
FunctionStatusWhere it lives
clip_grad_norm Ran
ran on a synthesized input
poodarchu/ConQueR/efg/engine/hooks.py
code served (permissive licence) · get_code("434052a707c12e64")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned Tensor, ndim 0, dtype family float, shape () as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch
import torch.nn as nn

torch.manual_seed(0)

# Create a simple model with parameters
model = nn.Sequential(
    nn.Linear(4, 3),
    nn.ReLU(),
    nn.Linear(3, 2)
)

# Create some dummy data and do a forward pass to populate gradients
x = torch.randn(2, 4)
y = torch.randn(2, 2)
output = model(x)
loss = nn.MSELoss()(output, y)
loss.backward()

# Prepare params - get all parameters from the model
params = list(model.parameters())

# kwargs for clip_grad_norm_ can include:
# - max_norm (float): max norm of gradients
# - norm_type (float): type of norm (default 2.0)
# - error_if_nonfinite (bool): whether to error if norm is non-finite
kwargs = {
    'max_norm': 1.0,
    'norm_type': 2.0,
    'error_if_nonfinite': False
}

ARGS = {
    'params': params,
    **kwargs
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type Tensor, ndim 0, dtype family float, shape () — shape () as a later run recorded it
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
convert_basic_c2_names Ran
ran; our contract draft was wrong, not the code
poodarchu/ConQueR/efg/utils/d2_model_loading.py
code served (permissive licence) · get_code("e8526a516b4f9206")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned list, ndim 1, dtype family float; no output shape is stated. The image it ran in was not recorded. If your copy returns the same type and ndim on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import copy
import re

# Analyze the function: it takes a list of strings (original_keys) and applies
# various string transformations to them. It doesn't use any complex objects,
# just list operations and string manipulations.

ARGS = {
    'original_keys': [
        'pred_b',
        'pred_w',
        'conv_b',
        'conv_w',
        'bn_s',
        'bn_bias',
        'bn_rm',
        'bn_riv',
        'bn_gamma',
        'bn_beta',
        'gn_s',
        'gn_bias',
        'res_conv1_norm_weight',
        'conv1_weight',
        'layer_branch1_weight',
        'layer_branch2a_bias',
        'layer_branch2b_weight',
        'layer_branch2c_bias',
        'body_conv_fcn_weight',
        'AnnIndex_lowres',
        'Index_UV_lowres',
        'U_lowres',
        'V_lowres',
    ]
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
none outside the standard library — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type list, ndim 1, dtype family float — a list output has no array shape of its own; none is stated
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
convert_c2_detectron_names Ran
ran; our contract draft was wrong, not the code
poodarchu/ConQueR/efg/utils/d2_model_loading.py
code served (permissive licence) · get_code("d65a6f9947376276")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned tuple, ndim 1, dtype family float; no output shape is stated. The image it ran in was not recorded. If your copy returns the same type and ndim on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch
import copy

torch.manual_seed(0)

# The function convert_c2_detectron_names takes a weights dict as input
# where keys are strings and values are tensors (based on the docstring)
# We need to construct a realistic weights dictionary with C2 Detectron naming conventions

weights = {
    'pred_w': torch.randn(4, 3),
    'pred_b': torch.randn(4),
    'res_conv1_norm_s': torch.randn(4),
    'res_conv1_norm_bias': torch.randn(4),
    'conv1_w': torch.randn(3, 4),
    'conv1_b': torch.randn(3),
    'res2_0_branch1_w': torch.randn(4, 3),
    'res2_0_branch2a_w': torch.randn(3, 4),
    'res2_0_branch2b_w': torch.randn(4, 4),
    'res2_0_branch2c_w': torch.randn(4, 3),
    'res2_0_branch1_bn_s': torch.randn(4),
    'res2_0_branch1_bn_bias': torch.randn(4),
    'fpn_inner_res2_0_sum_lateral_w': torch.randn(4, 3),
    'fpn_res2_0_sum_w': torch.randn(3, 4),
    'fpn_inner_res3_1_sum_lateral_w': torch.randn(4, 3),
    'fpn_res3_1_sum_w': torch.randn(3, 4),
    'conv_rpn_w': torch.randn(4, 3),
    'rpn_cls_logits_w': torch.randn(3, 4),
    'rpn_bbox_pred_w': torch.randn(4, 3),
    'fc6_w': torch.randn(4, 3),
    'fc7_w': torch.randn(3, 4),
    'head_conv_w': torch.randn(4, 3),
    'mask_fcn_logits_w': torch.randn(2, 4),
}

ARGS = {
    'weights': weights,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type tuple, ndim 1, dtype family float — a tuple output has no array shape of its own; none is stated
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
get_kw_to_default_map Ran
ran on a synthesized input
poodarchu/ConQueR/efg/modeling/utils.py
code served (permissive licence) · get_code("0f46d9d680073a35")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned dict. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import inspect

def get_kw_to_default_map(func):
    kw_to_default = {}
    fsig = inspect.signature(func)
    for name, info in fsig.parameters.items():
        if info.kind is info.POSITIONAL_OR_KEYWORD:
            if info.default is not info.empty:
                kw_to_default[name] = info.default
    return kw_to_default


def sample_function(a, b=10, c=20, d="default"):
    """Sample function with some default parameters"""
    return a + b + c


ARGS = {
    "func": sample_function
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
none outside the standard library — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type dict — a dict output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a dict output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not stated
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
get_pos_to_kw_map Ran
ran on a synthesized input
poodarchu/ConQueR/efg/modeling/utils.py
code served (permissive licence) · get_code("a1e7892e17d509f0")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned dict. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import inspect

def get_pos_to_kw_map(func):
    pos_to_kw = {}
    fsig = inspect.signature(func)
    pos = 0
    for name, info in fsig.parameters.items():
        if info.kind is info.POSITIONAL_OR_KEYWORD:
            pos_to_kw[pos] = name
        pos += 1
    return pos_to_kw

# Create a simple test function with various parameter kinds
def sample_func(a, b, c=10, *args, d=20, **kwargs):
    pass

ARGS = {
    'func': sample_func
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
none outside the standard library — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type dict — a dict output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a dict output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not stated
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
get_printer Ran
ran; our contract draft was wrong, not the code
poodarchu/ConQueR/efg/modeling/utils.py
code served (permissive licence) · get_code("f1dcdd191e058d41")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned function. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch

torch.manual_seed(0)

# The function get_printer takes a message string and returns a printer function
# that will be used as a hook to print gradient information about tensors.
# The msg parameter is simply a string label.

ARGS = {
    "msg": "Gradient info:"
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type function — a function output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a function output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not stated
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
limit_period Ran
ran on a synthesized input
poodarchu/ConQueR/datasets/utils/waymo_eval.py
code served (permissive licence) · get_code("5f4e8136399d27e8")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned ndarray, ndim 1, dtype family float, shape (5,) as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import numpy as np
import torch

torch.manual_seed(0)

# Analyzing the function:
# - val: np.ndarray - the function performs floor division, subtraction, clipping operations on it
# - offset: float - default 0.5, used in arithmetic operations
# - period: float - default np.pi, used in arithmetic operations
# The function works with numpy arrays and returns a numpy array (despite docstring saying torch.Tensor)

# Create a small numpy array with various values to test the periodic limiting
val = np.array([0.5, 1.2, 2.8, -0.3, 3.5])

offset = 0.5
period = np.pi

ARGS = {
    'val': val,
    'offset': offset,
    'period': period
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy, torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type ndarray, ndim 1, dtype family float, shape (5,) — shape (5,) as a later run recorded it
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
align_and_update_state_dicts Not yet run
unverified (harvested, no recorded run)
poodarchu/ConQueR/efg/utils/d2_model_loading.py
code served (permissive licence) · get_code("4552d09aa9f10a7e")
How it ran

no invocation recorded.

Also present in other papers' code

Of 8 samples lifted from this paper's linked repositories, 8 carry a function identity and 0 do not. Of the 8 distinct functions with an identity, 7 are also present in other papers whose code we hold (6 with at least one paper dated earlier, 2 the same month, 7 later) and 1 are only here among the 52,977 papers whose code Syntology holds (as of 2026-09-26).

Only here means: among the 52,977 papers whose code Syntology holds (51,887 with lifted samples, 1,090 through their assemblies only), as of 2026-09-26, no other paper's lifted samples or current assembly bricks contain an identical function body after normalisation.

FunctionAlso present inEarliest-datedOthers named
convert_basic_c2_names 45 other papers
21 dated earlier, 1 the same month, 20 later, 3 same year, order not determinable
1703.06870 (2017-03)
Mask R-CNN
1804.08864 (2018-04)
Learning to See the Invisible: End-to-End Trainable Amodal Instance Segmentation
1901.08164 (2019-01)
Decoupled Greedy Learning of CNNs
and 42 more not named here
convert_c2_detectron_names 29 other papers
19 dated earlier, 1 the same month, 7 later, 2 same year, order not determinable
1703.06870 (2017-03)
Mask R-CNN
1804.08864 (2018-04)
Learning to See the Invisible: End-to-End Trainable Amodal Instance Segmentation
1901.08164 (2019-01)
Decoupled Greedy Learning of CNNs
and 26 more not named here
align_and_update_state_dicts 3 other papers
1 dated earlier, 2 later
2112.12970 (2021-12)
SGTR: End-to-end Scene Graph Generation with Transformer
2306.05888 (2023-06)
TrajectoryFormer: 3D Object Tracking Transformer with Predictive Trajectory Hypotheses
2307.00347 (2023-07)
Spatial-Temporal Graph Enhanced DETR Towards Multi-Frame 3D Object Detection
get_kw_to_default_map 3 other papers
1 dated earlier, 2 later
1912.05163 (2019-12)
TANet: Robust 3D Object Detection from Point Clouds with Triple Attention
2306.05888 (2023-06)
TrajectoryFormer: 3D Object Tracking Transformer with Predictive Trajectory Hypotheses
2307.00347 (2023-07)
Spatial-Temporal Graph Enhanced DETR Towards Multi-Frame 3D Object Detection
get_pos_to_kw_map 3 other papers
1 dated earlier, 2 later
1912.05163 (2019-12)
TANet: Robust 3D Object Detection from Point Clouds with Triple Attention
2306.05888 (2023-06)
TrajectoryFormer: 3D Object Tracking Transformer with Predictive Trajectory Hypotheses
2307.00347 (2023-07)
Spatial-Temporal Graph Enhanced DETR Towards Multi-Frame 3D Object Detection
get_printer 3 other papers
1 dated earlier, 2 later
2006.04182 (2020-06)
Predictive Coding Approximates Backprop Along Arbitrary Computation Graphs
2306.05888 (2023-06)
TrajectoryFormer: 3D Object Tracking Transformer with Predictive Trajectory Hypotheses
2307.00347 (2023-07)
Spatial-Temporal Graph Enhanced DETR Towards Multi-Frame 3D Object Detection
clip_grad_norm 1 other paper
1 later
2306.05888 (2023-06)
TrajectoryFormer: 3D Object Tracking Transformer with Predictive Trajectory Hypotheses

Presence, not direction: an identical function body in two papers' repositories does not say who wrote it, which came from which, or that either paper's method rests on it. Matching is exact after normalisation, so a renamed or edited function is not matched. Dates are when papers appeared, not when code was written. Only .py files the harvester lifted are covered; notebooks are not read. A new-style arXiv id YYMM.NNNN dates a paper to the month 20YY-MM; otherwise Paper.year dates it to the year; otherwise it is undated. Dates are when the paper appeared, not when the code was written. Read 2026-11-22.

Repositories linked to this paper

Some links come from the archived Papers with Code dataset (CC BY-SA 4.0): attribution and licence.

Abstract

Although DETR-based 3D detectors can simplify the detection pipeline and achieve direct sparse predictions, their performance still lags behind dense detectors with post-processing for 3D object detection from point clouds. DETRs usually adopt a larger number of queries than GTs (e.g., 300 queries v.s. 40 objects in Waymo) in a scene, which inevitably incur many false positives during inference. In this paper, we propose a simple yet effective sparse 3D detector, named Query Contrast Voxel-DETR (ConQueR), to eliminate the challenging false positives, and achieve more accurate and sparser predictions. We observe that most false positives are highly overlapping in local regions, caused by the lack of explicit supervision to discriminate locally similar queries. We thus propose a Query Contrast mechanism to explicitly enhance queries towards their best-matched GTs over all unmatched query predictions. This is achieved by the construction of positive and negative GT-query pairs for each GT, and a contrastive loss to enhance positive GT-query pairs against negative ones based on feature similarities. ConQueR closes the gap of sparse and dense 3D detectors, and reduces up to ~60% false positives. Our single-frame ConQueR achieves new state-of-the-art (sota) 71.6 mAPH/L2 on the challenging Waymo Open Dataset validation set, outperforming previous sota methods (e.g., PV-RCNN++) by over 2.0 mAPH/L2.

For agents

The same record, over MCP at https://syntology.ai/mcp:

get_harvested_code_for_paper("2212.07289")
get_code_for_paper("2212.07289")
have("2212.07289")

The run record, dated, one paper per request, free:

curl https://syntology.ai/api/ran/2212.07289.json

A badge for a README (the split and the date, never a ratio):

[![Syntology run record](https://syntology.ai/api/ran/2212.07289.svg)](https://syntology.ai/paper/2212.07289)

Connect an agent — have() is free.