SYNTOLOGY HomeExplorerAtlasCodeMethodologyAboutDevelopersFeedPricing
Paper · 2104.09804 · CVPR · 2021

SE-SSD: Self-Ensembling Single-Stage Object Detector From Point Cloud

Chi-Wing Fu, Li Jiang, Weiliang Tang, Wu Zheng

arXiv · PDF · Open in the Atlas

Code that ran

5 of 5 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 0 have no contract verdict; 5 failures of our instrument; 0 no recorded run), measured 2026-11-21; 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/2104.09804.json · badge: /api/ran/2104.09804.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
Vegeta2020/SE-SSD canonical (classifier label)
classifier basis: census
5 ran · 0 no recorded run
FunctionStatusWhere it lives
create_target_np Ran
ran; our contract draft was wrong, not the code
Vegeta2020/SE-SSD/det3d/core/anchor/target_ops.py
code served (permissive licence) · get_code("8e8dc64823b20f95")
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 numpy as np
import numpy.random as npr

def similarity_fn(anchors, gt_boxes):
    """Compute IoU-like similarity between anchors and gt_boxes."""
    # Simple mock similarity: returns matrix of shape (num_anchors, num_gt_boxes)
    num_anchors = anchors.shape[0]
    num_gt = gt_boxes.shape[0]
    # Create a mock similarity matrix with values between 0 and 1
    similarity = np.random.rand(num_anchors, num_gt).astype(np.float32)
    return similarity

def box_encoding_fn(gt_boxes, anchors):
    """Encode gt_boxes relative to anchors."""
    # Returns box encodings of shape (num_anchors, box_code_size)
    num_anchors = anchors.shape[0]
    box_code_size = 7
    encodings = np.random.randn(num_anchors, box_code_size).astype(np.float32)
    return encodings

def prune_anchor_fn(anchors):
    """Return indices of valid anchors."""
    # Mock: keep all but potentially filter some
    num_anchors = anchors.shape[0]
    # Keep 80% of anchors as valid
    num_valid = max(1, int(0.8 * num_anchors))
    valid_inds = np.sort(np.random.choice(num_anchors, size=num_valid, replace=False))
    return valid_inds

# Create small test data
num_anchors = 10
num_gt_boxes = 3
box_ndim = 4

all_anchors = np.random.randn(num_anchors, box_ndim).astype(np.float32)
gt_boxes = np.random.randn(num_gt_boxes, box_ndim).astype(np.float32)
gt_classes = np.array([1, 2, 1], dtype=np.int32)

ARGS = {
    'all_anchors': all_anchors,
    'gt_boxes': gt_boxes,
    'similarity_fn': similarity_fn,
    'box_encoding_fn': box_encoding_fn,
    'prune_anchor_fn': prune_anchor_fn,
    'gt_classes': gt_classes,
    'matched_threshold': 0.6,
    'unmatched_threshold': 0.45,
    'bbox_inside_weight': None,
    'positive_fraction': 0.5,
    'rpn_batch_size': 300,
    'norm_by_num_examples': False,
    'box_code_size': 7,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy — 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
create_target_np Ran
ran; our contract draft was wrong, not the code
Vegeta2020/SE-SSD/det3d/core/anchor/target_ops_v2.py
code served (permissive licence) · get_code("d7088d15c0d599a1")
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 numpy as np

def similarity_fn(anchors, gt_boxes):
    """Compute IoU-like similarity between anchors and ground truth boxes."""
    # Simple mock: return random overlap matrix
    num_anchors = anchors.shape[0]
    num_gt = gt_boxes.shape[0]
    overlap = np.random.rand(num_anchors, num_gt).astype(anchors.dtype)
    return overlap

def box_encoding_fn(gt_boxes, anchors):
    """Encode ground truth boxes relative to anchors."""
    # Mock encoding: just return deltas
    deltas = gt_boxes - anchors
    return deltas

def prune_anchor_fn(anchors):
    """Prune anchors (mock implementation)."""
    return anchors

# Create tiny test data
num_anchors = 5
num_gt = 2
box_code_size = 7

all_anchors = np.random.rand(num_anchors, box_code_size).astype(np.float32)
gt_boxes = np.random.rand(num_gt, box_code_size).astype(np.float32)
gt_classes = np.array([1, 2], dtype=np.int32)

ARGS = {
    'all_anchors': all_anchors,
    'gt_boxes': gt_boxes,
    'similarity_fn': similarity_fn,
    'box_encoding_fn': box_encoding_fn,
    'prune_anchor_fn': prune_anchor_fn,
    'gt_classes': gt_classes,
    'matched_threshold': 0.6,
    'unmatched_threshold': 0.45,
    'bbox_inside_weight': None,
    'positive_fraction': None,
    'rpn_batch_size': 300,
    'norm_by_num_examples': False,
    'box_code_size': 7,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy — 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
create_target_np Ran
ran; our contract draft was wrong, not the code
Vegeta2020/SE-SSD/det3d/core/anchor/target_ops_v3.py
code served (permissive licence) · get_code("67b4ddf97c1ab9d4")
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 numpy as np
from scipy.spatial.distance import cdist

# Set random seed for reproducibility
np.random.seed(0)

# Define a similarity function that computes IoU-like overlap
def similarity_fn(anchors, gt_boxes):
    """Compute pairwise similarity between anchors and ground truth boxes."""
    # Simple cosine similarity as a stand-in for IoU computation
    # anchors: (num_anchors, 7), gt_boxes: (num_gt, 7)
    num_anchors = anchors.shape[0]
    num_gt = gt_boxes.shape[0]
    overlap = np.zeros((num_anchors, num_gt), dtype=np.float32)
    
    for i in range(num_anchors):
        for j in range(num_gt):
            # Simple dot product as overlap metric
            overlap[i, j] = np.dot(anchors[i], gt_boxes[j]) / (np.linalg.norm(anchors[i]) * np.linalg.norm(gt_boxes[j]) + 1e-6)
            overlap[i, j] = max(0, overlap[i, j])
    
    return overlap

# Define a box encoding function
def box_encoding_fn(gt_boxes, anchors):
    """Encode ground truth boxes relative to anchors."""
    # Simple difference as encoding
    return gt_boxes - anchors

# Define a prune anchor function
def prune_anchor_fn(all_anchors):
    """Return indices of anchors to keep."""
    # Keep all but the last anchor for testing
    return np.arange(all_anchors.shape[0] - 1)

# Create test data
num_anchors = 5
num_gt = 2
box_code_size = 7

all_anchors = np.random.randn(num_anchors, box_code_size).astype(np.float32)
gt_boxes = np.random.randn(num_gt, box_code_size).astype(np.float32)
gt_classes = np.array([1, 2], dtype=np.int32)

bbox_inside_weight = np.ones((box_code_size,), dtype=np.float32)

ARGS = {
    'all_anchors': all_anchors,
    'gt_boxes': gt_boxes,
    'similarity_fn': similarity_fn,
    'box_encoding_fn': box_encoding_fn,
    'prune_anchor_fn': prune_anchor_fn,
    'gt_classes': gt_classes,
    'matched_threshold': 0.6,
    'unmatched_threshold': 0.45,
    'bbox_inside_weight': bbox_inside_weight,
    'positive_fraction': 0.5,
    'rpn_batch_size': 300,
    'norm_by_num_examples': False,
    'box_code_size': box_code_size,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy, scipy — 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
create_target_np Ran
ran; our contract draft was wrong, not the code
Vegeta2020/SE-SSD/det3d/core/anchor/target_ops_v4.py
code served (permissive licence) · get_code("69bb4d54aa3145dd")
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 numpy as np

def prune_anchor_fn(anchors):
    """Prune anchors - returns indices of anchors to keep"""
    # Keep all but last anchor for testing
    return np.arange(anchors.shape[0] - 1)

def similarity_fn(anchors, gt_boxes):
    """Compute similarity between anchors and gt_boxes"""
    # Simple mock: return random overlap scores
    num_anchors = anchors.shape[0]
    num_gt = gt_boxes.shape[0]
    return np.random.rand(num_anchors, num_gt)

def box_encoding_fn(gt_boxes, anchors):
    """Encode gt_boxes relative to anchors"""
    # Return encoding with same number of rows as anchors, box_code_size=7 columns
    return np.random.rand(anchors.shape[0], 7)

# Create test data
num_anchors = 10
num_gt = 3
box_code_size = 7

all_anchors = np.random.rand(num_anchors, 4).astype(np.float32)
gt_boxes = np.random.rand(num_gt, 4).astype(np.float32)
gt_classes = np.array([1, 2, 1], dtype=np.int32)

ARGS = {
    'all_anchors': all_anchors,
    'gt_boxes': gt_boxes,
    'similarity_fn': similarity_fn,
    'box_encoding_fn': box_encoding_fn,
    'prune_anchor_fn': prune_anchor_fn,
    'gt_classes': gt_classes,
    'matched_threshold': 0.6,
    'unmatched_threshold': 0.45,
    'bbox_inside_weight': None,
    'positive_fraction': None,
    'rpn_batch_size': 300,
    'norm_by_num_examples': False,
    'box_code_size': box_code_size
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy — 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
unmap Ran
ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT)
Vegeta2020/SE-SSD/det3d/core/anchor/target_ops.py
code served (permissive licence) · get_code("2902bedb7c18b1a1")
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 int, 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

# Test case 1: 1D array with subset indices
data_1d = np.array([10, 20, 30], dtype=np.int32)
count_1d = 5
inds_1d = np.array([1, 3, 4], dtype=np.int64)
fill_1d = 0

# Test case 2: 2D array with subset indices
data_2d = np.array([[1, 2], [3, 4], [5, 6]], dtype=np.float32)
count_2d = 4
inds_2d = np.array([0, 2, 3], dtype=np.int64)
fill_2d = 0

# Use case 1 for ARGS
ARGS = {
    "data": data_1d,
    "count": count_1d,
    "inds": inds_1d,
    "fill": fill_1d
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy — 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 int, 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

Also present in other papers' code

Of 5 samples lifted from this paper's linked repositories, 5 carry a function identity and 0 do not. Of the 5 distinct functions with an identity, 2 are also present in other papers whose code we hold (2 with at least one paper dated earlier, 0 the same month, 0 later) and 3 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
unmap 4 other papers
4 dated earlier
1812.05784 (2018-12)
PointPillars: Fast Encoders for Object Detection from Point Clouds
1908.09492 (2019-08)
Class-balanced Grouping and Sampling for Point Cloud 3D Object Detection
1912.04986 (2019-12)
What You See is What You Get: Exploiting Visibility for 3D Object Detection
and 1 more not named here
create_target_np 1 other paper
1 dated earlier
1908.09492 (2019-08)
Class-balanced Grouping and Sampling for Point Cloud 3D Object Detection

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-21.

Repositories linked to this paper

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

Abstract

We present Self-Ensembling Single-Stage object Detector (SE-SSD) for accurate and efficient 3D object detection in outdoor point clouds. Our key focus is on exploiting both soft and hard targets with our formulated constraints to jointly optimize the model, without introducing extra computation in the inference. Specifically, SE-SSD contains a pair of teacher and student SSDs, in which we design an effective IoU-based matching strategy to filter soft targets from the teacher and formulate a consistency loss to align student predictions with them. Also, to maximize the distilled knowledge for ensembling the teacher, we design a new augmentation scheme to produce shape-aware augmented samples to train the student, aiming to encourage it to infer complete object shapes. Lastly, to better exploit hard targets, we design an ODIoU loss to supervise the student with constraints on the predicted box centers and orientations. Our SE-SSD attains top performance compared with all prior published works. Also, it attains top precisions for car detection in the KITTI benchmark (ranked 1 st and 2 nd on the BEV and 3D leaderboards 1 , respectively) with an ultra-high inference speed. The code is available at https://github.com/Vegeta2020/SE-SSD.

For agents

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

get_harvested_code_for_paper("2104.09804")
get_code_for_paper("2104.09804")
have("2104.09804")

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

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

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

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

Connect an agent — have() is free.