SYNTOLOGY HomeExplorerAtlasCodeMethodologyAboutDevelopersFeedPricing
Paper · 2307.00347 · 2023

Spatial-Temporal Graph Enhanced DETR Towards Multi-Frame 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/2307.00347.json · badge: /api/ran/2307.00347.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
eaphan/stemd canonical (classifier label)
classifier basis: census
7 ran · 1 no recorded run
FunctionStatusWhere it lives
convert_basic_c2_names Ran
ran; our contract draft was wrong, not the code
eaphan/stemd/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
eaphan/stemd/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
dn_post_process Ran
ran on a synthesized input
eaphan/stemd/playground/detection.3d/waymo/stemd/STEMD.waymo.resnet18.cdn.epoch12.16f/cdn.py
code served (permissive licence) · get_code("1ee3f1b1247be911")
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 5, 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 torch.nn as nn

torch.manual_seed(0)

# Create small tensors for outputs_class and outputs_coord
# Shape: (num_decoder_layers, batch_size, num_queries, num_classes)
# We use distinct sizes: batch=2, num_queries=5, num_classes=4
batch_size = 2
num_queries = 5
num_classes = 4
num_decoder_layers = 3

outputs_class = torch.randn(num_decoder_layers, batch_size, num_queries, num_classes)
outputs_coord = torch.randn(num_decoder_layers, batch_size, num_queries, 4)

# Create dn_meta with pad_size indicating denoising queries
# pad_size=2 means first 2 queries are denoising queries
dn_meta = {
    'pad_size': 2
}

# aux_loss flag
aux_loss = True

# Helper function to set auxiliary losses
def _set_aux_loss(output_class, output_coord):
    """
    Helper function that takes class and coord outputs and returns aux_outputs list.
    Called when aux_loss is True.
    """
    return [
        {'pred_logits': output_class[i], 'pred_boxes': output_coord[i]}
        for i in range(len(output_class))
    ]

ARGS = {
    'outputs_class': outputs_class,
    'outputs_coord': outputs_coord,
    'dn_meta': dn_meta,
    'aux_loss': aux_loss,
    '_set_aux_loss': _set_aux_loss
}
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 5, 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
eaphan/stemd/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
eaphan/stemd/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
eaphan/stemd/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
prepare_for_cdn Ran
ran on a synthesized input
eaphan/stemd/playground/detection.3d/waymo/stemd/STEMD.waymo.resnet18.cdn.epoch12.16f/cdn.py
code served (permissive licence) · get_code("5e5d396ef5fa54c2")
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. The image it ran in was not recorded. The code mentions cuda, and the harness aliases cuda to the CPU for every sample; whether this run needed that is 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
import torch.nn.functional as F
from torch import nn

torch.manual_seed(0)

# Create mock targets
targets = [
    {
        'labels': torch.tensor([0, 1], dtype=torch.long),
        'gt_boxes': torch.tensor([
            [0.5, 0.5, 0.5, 0.3, 0.3, 0.3, 0.0],
            [0.3, 0.3, 0.3, 0.2, 0.2, 0.2, 0.0]
        ], dtype=torch.float32)
    },
    {
        'labels': torch.tensor([2, 0], dtype=torch.long),
        'gt_boxes': torch.tensor([
            [0.7, 0.7, 0.7, 0.2, 0.2, 0.2, 0.0],
            [0.4, 0.4, 0.4, 0.25, 0.25, 0.25, 0.0]
        ], dtype=torch.float32)
    }
]

# Simple label encoder function
def label_enc(labels):
    return labels

# Create dn_args tuple
dn_args = (
    targets,           # targets
    2,                 # dn_number
    0.3,               # label_noise_ratio
    0.5                # box_noise_scale
)

ARGS = {
    'dn_args': dn_args,
    'training': True,
    'num_queries': 5,
    'num_classes': 4,
    'hidden_dim': 8,
    'label_enc': label_enc
}
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 — a tuple output has no array shape of its own; none is 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
align_and_update_state_dicts Not yet run
unverified (harvested, no recorded run)
eaphan/stemd/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, 6 are also present in other papers whose code we hold (6 with at least one paper dated earlier, 2 the same month, 2 later) and 2 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
32 dated earlier, 1 the same month, 10 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 42 more not named here
convert_c2_detectron_names 29 other papers
26 dated earlier, 1 the same month, 1 later, 1 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
3 dated earlier
2112.12970 (2021-12)
SGTR: End-to-end Scene Graph Generation with Transformer
2212.07289 (2022-12)
ConQueR: Query Contrast Voxel-DETR for 3D Object Detection
2306.05888 (2023-06)
TrajectoryFormer: 3D Object Tracking Transformer with Predictive Trajectory Hypotheses
get_kw_to_default_map 3 other papers
3 dated earlier
1912.05163 (2019-12)
TANet: Robust 3D Object Detection from Point Clouds with Triple Attention
2212.07289 (2022-12)
ConQueR: Query Contrast Voxel-DETR for 3D Object Detection
2306.05888 (2023-06)
TrajectoryFormer: 3D Object Tracking Transformer with Predictive Trajectory Hypotheses
get_pos_to_kw_map 3 other papers
3 dated earlier
1912.05163 (2019-12)
TANet: Robust 3D Object Detection from Point Clouds with Triple Attention
2212.07289 (2022-12)
ConQueR: Query Contrast Voxel-DETR for 3D Object Detection
2306.05888 (2023-06)
TrajectoryFormer: 3D Object Tracking Transformer with Predictive Trajectory Hypotheses
get_printer 3 other papers
3 dated earlier
2006.04182 (2020-06)
Predictive Coding Approximates Backprop Along Arbitrary Computation Graphs
2212.07289 (2022-12)
ConQueR: Query Contrast Voxel-DETR for 3D Object Detection
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

The Detection Transformer (DETR) has revolutionized the design of CNN-based object detection systems, showcasing impressive performance. However, its potential in the domain of multi-frame 3D object detection remains largely unexplored. In this paper, we present STEMD, a novel end-to-end framework that enhances the DETR-like paradigm for multi-frame 3D object detection by addressing three key aspects specifically tailored for this task. First, to model the inter-object spatial interaction and complex temporal dependencies, we introduce the spatial-temporal graph attention network, which represents queries as nodes in a graph and enables effective modeling of object interactions within a social context. To solve the problem of missing hard cases in the proposed output of the encoder in the current frame, we incorporate the output of the previous frame to initialize the query input of the decoder. Finally, it poses a challenge for the network to distinguish between the positive query and other highly similar queries that are not the best match. And similar queries are insufficiently suppressed and turn into redundant prediction boxes. To address this issue, our proposed IoU regularization term encourages similar queries to be distinct during the refinement. Through extensive experiments, we demonstrate the effectiveness of our approach in handling challenging scenarios, while incurring only a minor additional computational overhead. The code is publicly available at https://github.com/Eaphan/STEMD.

For agents

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

get_harvested_code_for_paper("2307.00347")
get_code_for_paper("2307.00347")
have("2307.00347")

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

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

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

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

Connect an agent — have() is free.