SYNTOLOGY HomeExplorerAtlasCodeMethodologyAboutDevelopersFeedPricing
Paper · 1804.02767 · arXiv.org · 2018

YOLOv3: An Incremental Improvement

arXiv · PDF · Open in the Atlas

Code that ran

94 of 124 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; 9 honoured the contract we drafted, 2 violated it and 67 have no contract verdict; 16 failures of our instrument; 30 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/1804.02767.json · badge: /api/ran/1804.02767.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
GunjanChourasia/custom_detector_yolov3 community (classifier label)
classifier basis not recorded on the link
13 ran · 7 no recorded run
yuedongli1/yolov3_mindspore community (classifier label)
classifier basis not recorded on the link
11 ran · 3 no recorded run
Lornatang/PyTorch-yolov3 community (classifier label)
classifier basis not recorded on the link
8 ran · 4 no recorded run
copy not recorded community
not in the paper's declared repositories
8 ran · 2 no recorded run
euske/derpyolo community (classifier label)
classifier basis not recorded on the link
8 ran · 1 no recorded run
zhanghuiyao/yolov3_mindspore community (classifier label)
classifier basis not recorded on the link
8 ran · 0 no recorded run
DevBruce/YOLOv3-TF2 community (classifier label)
classifier basis not recorded on the link
7 ran · 0 no recorded run
qqwweee/keras-yolo3 community (classifier label)
classifier basis not recorded on the link
6 ran · 0 no recorded run
zzh8829/yolov3-tf2 community (classifier label)
classifier basis not recorded on the link
5 ran · 4 no recorded run
YunYang1994/tensorflow-yolov3 community (classifier label)
classifier basis not recorded on the link
3 ran · 3 no recorded run
mvxxx/mimuw-hats community (classifier label)
classifier basis not recorded on the link
3 ran · 2 no recorded run
eavise-kul/lightnet community (classifier label)
classifier basis not recorded on the link
3 ran · 0 no recorded run
Zzh-tju/ultralytics-YOLOv3-Cluster-NMS extension (classifier label)
classifier basis: classifier_2025
2 ran · 1 no recorded run
Jintao-Huang/Darknet53_PyTorch community (classifier label)
classifier basis not recorded on the link
2 ran · 0 no recorded run
liulianjushi/yolo_v3_tf2.0 community (classifier label)
classifier basis not recorded on the link
2 ran · 0 no recorded run
thinhhoang95/helipad-yolo reimplementation (classifier label)
classifier basis: classifier_2025
1 ran · 0 no recorded run
Vijayabhaskar96/Object-Detection-Algorithms reimplementation (classifier label)
classifier basis: classifier_2025
1 ran · 0 no recorded run
calmisential/YOLOv3_TensorFlow2 community (classifier label)
classifier basis not recorded on the link
1 ran · 0 no recorded run
Raychou0830/Carplate reimplementation (classifier label)
classifier basis: classifier_2025
1 ran · 0 no recorded run
albertsokol/yolov3-tf2 reimplementation (classifier label)
classifier basis: classifier_2025
1 ran · 0 no recorded run
saimj7/Social-Distancing-Detection-in-Real-Time community (classifier label)
classifier basis not recorded on the link
0 ran · 1 no recorded run
zeegeeko/YOLOv3 reimplementation (classifier label)
classifier basis: classifier_2025
0 ran · 1 no recorded run
Jiachenyin1/Yolov3-U-attention-permuting extension (classifier label)
classifier basis: classifier_2025
0 ran · 1 no recorded run
FunctionStatusWhere it lives
DarknetBlock Ran
ran on a synthesized input
zzh8829/yolov3-tf2/yolov3_tf2/models.py
code served (permissive licence) · get_code("794b3117107512ef")
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 KerasTensor. 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 tensorflow as tf
import numpy as np

# Create a small input tensor for testing
# DarknetBlock expects a tensor input and will apply Conv2D operations
# Using batch_size=2, height=4, width=4, channels=3 (small dimensions)
input_tensor = tf.keras.Input(shape=(4, 4, 3))

# Define the arguments for DarknetBlock
ARGS = {
    'x': input_tensor,
    'filters': 32,
    'blocks': 2
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy, tensorflow — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type KerasTensor — a KerasTensor 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
DarknetConv Ran
ran on a synthesized input
zzh8829/yolov3-tf2/yolov3_tf2/models.py
code served (permissive licence) · get_code("6e9f112d5b789a72")
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 EagerTensor, ndim 4, dtype family float, shape (2, 4, 3, 16) 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 tensorflow as tf
from tensorflow.keras.layers import Add, Concatenate, Conv2D, Input, Lambda, LeakyReLU, MaxPool2D, UpSampling2D, ZeroPadding2D, BatchNormalization
from tensorflow.keras.regularizers import l2

# Create a small input tensor
# Shape: (batch_size=2, height=4, width=3, channels=1)
input_tensor = tf.random.normal((2, 4, 3, 1))

ARGS = {
    'x': input_tensor,
    'filters': 16,
    'size': 3,
    'strides': 1,
    'batch_norm': True
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
tensorflow — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type EagerTensor, ndim 4, dtype family float, shape (2, 4, 3, 16) — shape (2, 4, 3, 16) 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
IOU Ran
ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT)
this paper's copy was not recorded; identical code first harvested from caihaocong/Yolov3_AlexeyAB_Version
pointer only; the stored copy get_code serves, from caihaocong/Yolov3_AlexeyAB_Version, is pointer only (licence: NOASSERTION) · get_code("ff92ad8f00e93bbc")
How it ran

The body of this sample is withheld: this paper's copy of the code was not recorded (its link names no repository or source path), so no licence was read for it. The setup block that called it is withheld with it, because it is written against that body. source_path and origin say where the code lives, to read under the repository's own terms. A run is recorded.

IOU_dist Ran
ran on a synthesized input
GunjanChourasia/custom_detector_yolov3/kmeans.py
code served (permissive licence) · get_code("7a50e764fb28b748")
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 (2,) 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

# Create small numpy arrays for testing
# points: shape (2, 2) - 2 points with width and height
points = np.array([
    [4.0, 3.0],
    [6.0, 2.0]
], dtype=np.float32)

# centroids: shape (2, 2) - 2 centroids with width and height
centroids = np.array([
    [5.0, 2.0],
    [4.0, 3.0]
], dtype=np.float32)

ARGS = {
    "points": points,
    "centroids": centroids
}
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 float, shape (2,) — shape (2,) 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
argmax Ran
ran on a synthesized input
euske/derpyolo/objutils.py
code served (permissive licence) · get_code("73c23db542d9513e")
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 numpy as np

torch.manual_seed(0)

# The function argmax takes:
# - a: an iterable of items
# - key: a callable that extracts a comparable value from each item

# Create a simple list of items
items = [
    {"value": 3.5, "name": "first"},
    {"value": 7.2, "name": "second"},
    {"value": 5.1, "name": "third"},
]

# Define a key function that extracts the "value" field
def key_func(x):
    return x["value"]

ARGS = {
    "a": items,
    "key": key_func,
}
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 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
autopad Ran
ran, honoured the contract we drafted
yuedongli1/yolov3_mindspore/network/common.py
pointer only (licence: MIT); the stored copy get_code serves, from yang-0201/YOLOv6_pro, is pointer only (licence: GPL-3.0) · get_code("988a3c854b1b13d0")
How it ran

The body of this sample is withheld: this paper's link allows the body inline (MIT), but get_code serves the stored copy, first harvested from yang-0201/YOLOv6_pro, and GPL-3.0, as GitHub detects it on that repository, is not in the permissive set Syntology serves inline. The setup block that called it is withheld with it, because it is written against that body. source_path and origin say where the code lives, to read under the repository's own terms. A run is recorded.

avg_IOU Ran
ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT)
this paper's copy was not recorded; identical code first harvested from caihaocong/Yolov3_AlexeyAB_Version
pointer only; the stored copy get_code serves, from caihaocong/Yolov3_AlexeyAB_Version, is pointer only (licence: NOASSERTION) · get_code("1a3fa3dda9a8b100")
How it ran

The body of this sample is withheld: this paper's copy of the code was not recorded (its link names no repository or source path), so no licence was read for it. The setup block that called it is withheld with it, because it is written against that body. source_path and origin say where the code lives, to read under the repository's own terms. A run is recorded.

bbox_area Ran
ran on a synthesized input
GunjanChourasia/custom_detector_yolov3/data_aug/bbox_util.py
code served (permissive licence) · get_code("2e3a1b43bdfce447")
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 (2,) 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

# Create a small numpy array with bounding boxes in format [x1, y1, x2, y2]
# Shape: N x 4 where N is number of bounding boxes
bbox = np.array([
    [0.0, 0.0, 10.0, 5.0],  # bbox 1: width=10, height=5, area=50
    [1.0, 2.0, 6.0, 8.0],   # bbox 2: width=5, height=6, area=30
], dtype=np.float32)

ARGS = {
    "bbox": bbox
}
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 float, shape (2,) — shape (2,) 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
bbox_giou Ran
ran on a synthesized input
DevBruce/YOLOv3-TF2/libs/utils/calc_ious.py
code served (permissive licence) · get_code("fe9bc9c30086c04f")
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 EagerTensor, ndim 1, dtype family float, shape (2,) 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 tensorflow as tf

# The function takes two bounding box tensors
# Each box is represented as [center_x, center_y, width, height]
# We'll create two small batches of bounding boxes

# Create boxes1: shape (2, 4) - 2 boxes with 4 coordinates each
boxes1 = tf.constant([
    [5.0, 5.0, 4.0, 6.0],  # center at (5,5), width=4, height=6
    [10.0, 10.0, 2.0, 3.0]  # center at (10,10), width=2, height=3
], dtype=tf.float32)

# Create boxes2: shape (2, 4) - 2 boxes with 4 coordinates each
boxes2 = tf.constant([
    [5.5, 5.5, 3.0, 5.0],   # center at (5.5,5.5), width=3, height=5
    [9.0, 11.0, 4.0, 2.0]   # center at (9,11), width=4, height=2
], dtype=tf.float32)

ARGS = {
    "boxes1": boxes1,
    "boxes2": boxes2
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
tensorflow — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type EagerTensor, ndim 1, dtype family float, shape (2,) — shape (2,) 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
bbox_iou Ran
ran on a synthesized input
DevBruce/YOLOv3-TF2/libs/utils/calc_ious.py
code served (permissive licence) · get_code("a28227d670ba6b7e")
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 EagerTensor, ndim 1, dtype family float, shape (2,) 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 tensorflow as tf

# Create small bounding box tensors
# Format: [center_x, center_y, width, height]
# boxes1: shape (2, 4) - 2 boxes with 4 coordinates each
boxes1 = tf.constant([
    [10.0, 10.0, 4.0, 6.0],
    [20.0, 20.0, 8.0, 8.0]
], dtype=tf.float32)

# boxes2: shape (2, 4) - 2 boxes with 4 coordinates each
boxes2 = tf.constant([
    [11.0, 11.0, 4.0, 6.0],
    [22.0, 22.0, 6.0, 6.0]
], dtype=tf.float32)

ARGS = {
    "boxes1": boxes1,
    "boxes2": boxes2
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
tensorflow — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type EagerTensor, ndim 1, dtype family float, shape (2,) — shape (2,) 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
bprj Ran
ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT)
thinhhoang95/helipad-yolo/detect.py
pointer only (licence: GPL-3.0) · get_code("ce470c95b08cd7db")
How it ran

The body of this sample is withheld: GPL-3.0, as GitHub detects it on this paper's repository, thinhhoang95/helipad-yolo, is not in the permissive set Syntology serves inline. The setup block that called it is withheld with it, because it is written against that body. source_path and origin say where the code lives, to read under the repository's own terms. A run is recorded.

broadcast_iou Ran
ran on a synthesized input
zzh8829/yolov3-tf2/yolov3_tf2/utils.py
code served (permissive licence) · get_code("5bac87cf119ddef3")
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 EagerTensor, ndim 2, dtype family float, shape (2, 3) 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 tensorflow as tf
import numpy as np

# Create small bounding box tensors
# Bounding boxes are typically in format [x_min, y_min, x_max, y_max]
# box_1: shape (2, 4) - 2 boxes with 4 coordinates each
box_1 = tf.constant([
    [0.0, 0.0, 2.0, 2.0],
    [1.0, 1.0, 3.0, 3.0]
], dtype=tf.float32)

# box_2: shape (3, 4) - 3 boxes with 4 coordinates each
# Using different batch size to demonstrate broadcasting
box_2 = tf.constant([
    [0.5, 0.5, 1.5, 1.5],
    [1.5, 1.5, 2.5, 2.5],
    [2.0, 2.0, 4.0, 4.0]
], dtype=tf.float32)

ARGS = {
    "box_1": box_1,
    "box_2": box_2
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy, tensorflow — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type EagerTensor, ndim 2, dtype family float, shape (2, 3) — shape (2, 3) 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
c_array Ran
ran; our contract draft was wrong, not the code
this paper's copy was not recorded; identical code first harvested from caihaocong/Yolov3_AlexeyAB_Version
pointer only; the stored copy get_code serves, from caihaocong/Yolov3_AlexeyAB_Version, is pointer only (licence: NOASSERTION) · get_code("78d482d2a7373f3c")
How it ran

The body of this sample is withheld: this paper's copy of the code was not recorded (its link names no repository or source path), so no licence was read for it. The setup block that called it is withheld with it, because it is written against that body. source_path and origin say where the code lives, to read under the repository's own terms. A run is recorded.

calculate_gain Ran
ran, honoured the contract we drafted
zhanghuiyao/yolov3_mindspore/src/initializer.py
code served (permissive licence) · get_code("e460868d0e106ef7")
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 float, 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
import math

torch.manual_seed(0)

# Test case 1: linear nonlinearity
ARGS = {
    'nonlinearity': 'relu',
    'param': None
}
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 float, 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
center_to_corner Ran
ran, violated the contract we drafted
this paper's copy was not recorded; identical code first harvested from DavianYang/yolo.ai
pointer only · get_code("2e0088f9f6c77ccd")
How it ran

The body of this sample is withheld: this paper's copy of the code was not recorded (its link names no repository or source path), so no licence was read for it. The setup block that called it is withheld with it, because it is written against that body. source_path and origin say where the code lives, to read under the repository's own terms. A run is recorded.

check_file Ran
ran on a synthesized input
yuedongli1/yolov3_mindspore/utils/general.py
code served (permissive licence) · get_code("91b4702f6af52c0c")
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 str. 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 tempfile
import os
from pathlib import Path

# Create a temporary directory with test files
temp_dir = tempfile.mkdtemp()
test_file = os.path.join(temp_dir, "test.txt")
with open(test_file, "w") as f:
    f.write("test content")

# Test case 1: valid file path
ARGS = {
    "file": test_file
}
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 str — a str output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a str 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
clip_box Ran
ran on a synthesized input
GunjanChourasia/custom_detector_yolov3/data_aug/bbox_util.py
code served (permissive licence) · get_code("ef2908ceb8d3dbd6")
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 2, dtype family float, shape (3, 4) 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

# Create sample bounding boxes with shape N x 4 (x1, y1, x2, y2)
# Using 3 bounding boxes
bbox = np.array([
    [10.0, 20.0, 100.0, 150.0],
    [50.0, 60.0, 200.0, 250.0],
    [5.0, 5.0, 50.0, 50.0]
], dtype=np.float32)

# Create a clip box defining image boundaries (x1, y1, x2, y2)
clip_box = np.array([0.0, 0.0, 300.0, 300.0], dtype=np.float32)

# Create alpha parameter (threshold for keeping clipped boxes)
alpha = 0.5

ARGS = {
    "bbox": bbox,
    "clip_box": clip_box,
    "alpha": alpha
}
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 2, dtype family float, shape (3, 4) — shape (3, 4) 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
clip_coords Ran
ran on a synthesized input
Lornatang/PyTorch-yolov3/yolov3_pytorch/utils/common.py
code served (permissive licence) · get_code("acdd9e1ef705fe40")
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 2, dtype family float, shape (2, 4) 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

torch.manual_seed(0)

# Create a small tensor of bounding boxes in xyxy format
# Shape: (n, 4) where n=2 boxes, each with [x1, y1, x2, y2]
boxes = torch.tensor([
    [10.0, 20.0, 100.0, 150.0],
    [5.0, 15.0, 200.0, 180.0]
], dtype=torch.float32)

# Image shape as (height, width)
image_shape = (200, 256)

ARGS = {
    "boxes": boxes,
    "image_shape": image_shape
}
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 2, dtype family float, shape (2, 4) — shape (2, 4) 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
clip_coords Ran
ran on a synthesized input
yuedongli1/yolov3_mindspore/utils/metrics.py
code served (permissive licence) · get_code("8749f6c6e44471e8")
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 2, dtype family float, shape (2, 4) 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

torch.manual_seed(0)

# boxes is a tensor that supports indexing and .clip() method
# It should have shape (batch, 4) where 4 represents [x_min, y_min, x_max, y_max]
boxes = torch.tensor([
    [10.0, 20.0, 100.0, 150.0],
    [5.0, 15.0, 200.0, 250.0]
], dtype=torch.float32)

# img_shape is a tuple or list representing (height, width)
img_shape = (300, 400)

ARGS = {
    "boxes": boxes,
    "img_shape": img_shape
}
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 2, dtype family float, shape (2, 4) — shape (2, 4) 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
compare_version Ran
ran on a synthesized input
yuedongli1/yolov3_mindspore/utils/all_finite.py
code served (permissive licence) · get_code("d6ae8e6a9c267f7b")
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 int, ndim 0, dtype family int, 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

# The function compare_version takes two version strings and compares them
# It splits by '.', compares integer components, and returns -1, 0, or 1
# No complex objects needed - just strings

ARGS = {
    'v1': '1.8.1',
    'v2': '1.9.0'
}
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 int, ndim 0, dtype family int, 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
confidence_filter Ran
ran on a synthesized input
GunjanChourasia/custom_detector_yolov3/bbox.py
code served (permissive licence) · get_code("613f27d12519398d")
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 3, dtype family float, shape (2, 3, 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 torch

torch.manual_seed(0)

# The function expects:
# - result: a tensor with shape (batch, num_objects, features) where feature index 4 is confidence
# - confidence: a scalar threshold value

# Create a small result tensor with shape (batch=2, num_objects=3, features=5)
# Feature at index 4 is the confidence score
result = torch.tensor([
    [[0.1, 0.2, 0.3, 0.4, 0.9],
     [0.2, 0.3, 0.4, 0.5, 0.3],
     [0.3, 0.4, 0.5, 0.6, 0.7]],
    [[0.4, 0.5, 0.6, 0.7, 0.2],
     [0.5, 0.6, 0.7, 0.8, 0.95],
     [0.6, 0.7, 0.8, 0.9, 0.5]]
], dtype=torch.float32)

# Confidence threshold
confidence = 0.5

ARGS = {
    "result": result,
    "confidence": confidence
}
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 3, dtype family float, shape (2, 3, 5) — shape (2, 3, 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
conv_batch Ran
ran; our contract draft was wrong, not the code
this paper's copy was not recorded; identical code first harvested from gunooknam/Code_Study_Yolov3
pointer only; the stored copy get_code serves, from gunooknam/Code_Study_Yolov3, is pointer only (licence: NONE) · get_code("94cad4bc0776217e")
How it ran

The body of this sample is withheld: this paper's copy of the code was not recorded (its link names no repository or source path), so no licence was read for it. The setup block that called it is withheld with it, because it is written against that body. source_path and origin say where the code lives, to read under the repository's own terms. A run is recorded.

conv_block Ran
ran on a synthesized input
DevBruce/YOLOv3-TF2/libs/models/layers.py
code served (permissive licence) · get_code("67f851a5d61759bc")
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 EagerTensor, ndim 4, dtype family float, shape (2, 4, 4, 16) 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 tensorflow as tf
import numpy as np

# Create a small input tensor (batch=2, height=4, width=4, channels=3)
input_tensor = tf.constant(np.random.randn(2, 4, 4, 3).astype(np.float32))

# Define the arguments dictionary
ARGS = {
    'x': input_tensor,
    'out_channels': 16,
    'kernel_size': 3,
    'downsample': False,
    'activate': 'leaky',
    'bn': True
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy, tensorflow — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type EagerTensor, ndim 4, dtype family float, shape (2, 4, 4, 16) — shape (2, 4, 4, 16) 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
conv_upsample_block Ran
ran; our contract draft was wrong, not the code
Vijayabhaskar96/Object-Detection-Algorithms/Yolo_V3/YoloV3_model.py
pointer only (licence: NONE) · get_code("6044c07c7c65ad55")
How it ran

The body of this sample is withheld: GitHub detected no licence in this paper's repository, Vijayabhaskar96/Object-Detection-Algorithms when it was checked. The setup block that called it is withheld with it, because it is written against that body. source_path and origin say where the code lives, to read under the repository's own terms. A run is recorded.

convert2cpu Ran
ran on a synthesized input
GunjanChourasia/custom_detector_yolov3/util.py
code served (permissive licence) · get_code("9c414d9463c241cd")
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 2, dtype family float, shape (2, 4) 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

torch.manual_seed(0)

# Create a small CPU tensor to pass to convert2cpu
matrix = torch.randn(2, 4)

ARGS = {
    "matrix": matrix
}
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 2, dtype family float, shape (2, 4) — shape (2, 4) 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
corner_to_center Ran
ran, violated the contract we drafted
this paper's copy was not recorded; identical code first harvested from DavianYang/yolo.ai
pointer only · get_code("ba28b6ff72c46019")
How it ran

The body of this sample is withheld: this paper's copy of the code was not recorded (its link names no repository or source path), so no licence was read for it. The setup block that called it is withheld with it, because it is written against that body. source_path and origin say where the code lives, to read under the repository's own terms. A run is recorded.

count_learnable_parameters Ran
ran on a synthesized input
GunjanChourasia/custom_detector_yolov3/util.py
code served (permissive licence) · get_code("bd2be659aa2aba95")
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 int, ndim 0, dtype family int, 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)

class SimpleModel(nn.Module):
    def __init__(self):
        super().__init__()
        self.linear1 = nn.Linear(4, 3)
        self.linear2 = nn.Linear(3, 2)
    
    def forward(self, x):
        x = self.linear1(x)
        x = self.linear2(x)
        return x

model = SimpleModel()

ARGS = {
    "model": model
}
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 int, ndim 0, dtype family int, 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
count_parameters Ran
ran, honoured the contract we drafted
GunjanChourasia/custom_detector_yolov3/util.py
pointer only (licence: MIT); the stored copy get_code serves, from sleepymalc/miss, is pointer only (licence: NONE) · get_code("df23da82fbd7ff7b")
How it ran

The body of this sample is withheld: this paper's link allows the body inline (MIT), but get_code serves the stored copy, first harvested from sleepymalc/miss, and GitHub detected no licence in that repository when it was checked. The setup block that called it is withheld with it, because it is written against that body. source_path and origin say where the code lives, to read under the repository's own terms. A run is recorded.

createFileHandler Ran
ran on a synthesized input
eavise-kul/lightnet/lightnet/log.py
code served (permissive licence) · get_code("e3f1588842c9401c")
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 FileHandler. 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 logging
import tempfile
import os

class LevelFilter(logging.Filter):

    def __init__(self, levels, *args, **kwargs):
        super().__init__(*args, **kwargs)
        self.levels = levels

    def filter(self, record):
        if self.levels is None or record.levelname in self.levels:
            return True
        else:
            return False

logger = logging.getLogger('lightnet')

def createFileHandler(self, filename, levels=None, filemode='a'):
    """ Create a file to write log messages of certaing levels """
    fh = logging.FileHandler(filename=filename, mode=filemode)
    fh.setLevel(logging.NOTSET)
    fh.addFilter(LevelFilter(levels))
    fh.setFormatter(logging.Formatter('{levelname} [{name}] {message}', style='{'))
    logger.addHandler(fh)
    return fh

# Setup temporary file for logging
temp_dir = tempfile.gettempdir()
temp_log_file = os.path.join(temp_dir, 'test_log.txt')

# Create a dummy self object (this is a method, so we need an instance)
class DummyLogger:
    pass

dummy_self = DummyLogger()

ARGS = {
    'self': dummy_self,
    'filename': temp_log_file,
    'levels': ['INFO', 'WARNING', 'ERROR'],
    'filemode': 'a'
}
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 FileHandler — a FileHandler output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a FileHandler 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
darknet53 Ran
ran; our contract draft was wrong, not the code
this paper's copy was not recorded; identical code first harvested from gunooknam/Code_Study_Yolov3
pointer only; the stored copy get_code serves, from gunooknam/Code_Study_Yolov3, is pointer only (licence: NONE) · get_code("f6caf2197aa6a134")
How it ran

The body of this sample is withheld: this paper's copy of the code was not recorded (its link names no repository or source path), so no licence was read for it. The setup block that called it is withheld with it, because it is written against that body. source_path and origin say where the code lives, to read under the repository's own terms. A run is recorded.

darknet53 Ran
ran on a synthesized input
Jintao-Huang/Darknet53_PyTorch/models/darknet53.py
code served (permissive licence) · get_code("f9299ec3aa73a4dd")
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 Darknet53. 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
import torch.nn as nn

torch.manual_seed(0)

# Mock the load_state_dict_from_url function since we can't download
def load_state_dict_from_url(url, progress=True):
    # Return a dummy state dict that won't actually load
    # (pretrained=False anyway in our test)
    return {}

# Define ARGS with all parameters for darknet53 function
ARGS = {
    'pretrained': False,
    'progress': True,
    'num_classes': 10,
    'norm_layer': nn.BatchNorm2d
}
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 Darknet53 — a Darknet53 output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a Darknet53 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
diomgis Ran
ran on a synthesized input
euske/derpyolo/objutils.py
code served (permissive licence) · get_code("0baeb54a2e10e06c")
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 float, 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 math

def diomgis(y):
    if 0 < y and y < 1:
        return -math.log(1.0 / y - 1.0)
    raise ValueError(y)

ARGS = {
    "y": 0.5
}
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 float, 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
draw_outputs Ran
ran on a synthesized input
zzh8829/yolov3-tf2/yolov3_tf2/utils.py
code served (permissive licence) · get_code("9d9a2b61c5bcbecb")
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 3, dtype family int, shape (100, 150, 3) 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 cv2

# Create a small test image (height=100, width=150, channels=3)
img = np.random.randint(0, 256, (100, 150, 3), dtype=np.uint8)

# Create outputs tuple with batched predictions
# boxes: normalized coordinates [batch_size, num_detections, 4] where each box is [x1, y1, x2, y2]
# objectness: confidence scores [batch_size, num_detections]
# classes: class indices [batch_size, num_detections]
# nums: number of detections per batch [batch_size]

batch_size = 1
num_detections = 3

boxes = np.array([[[0.1, 0.2, 0.4, 0.5],
                    [0.5, 0.3, 0.8, 0.7],
                    [0.2, 0.6, 0.6, 0.9]]])  # shape: (1, 3, 4)

objectness = np.array([[0.95, 0.87, 0.72]])  # shape: (1, 3)

classes = np.array([[0, 1, 0]])  # shape: (1, 3)

nums = np.array([3])  # shape: (1,) - we have 3 detections

outputs = (boxes, objectness, classes, nums)

# Class names for labeling
class_names = ["person", "car", "dog"]

ARGS = {
    "img": img,
    "outputs": outputs,
    "class_names": class_names
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
cv2, numpy — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type ndarray, ndim 3, dtype family int, shape (100, 150, 3) — shape (100, 150, 3) 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
draw_rect Ran
ran on a synthesized input
GunjanChourasia/custom_detector_yolov3/data_aug/bbox_util.py
code served (permissive licence) · get_code("dbdb9af98dfff0c1")
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 3, dtype family int, shape (100, 150, 3) 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 cv2

# Create a small test image (height=100, width=150, channels=3)
# Using BGR format since cv2.rectangle expects that
test_image = np.random.randint(0, 256, size=(100, 150, 3), dtype=np.uint8)

# Create bounding boxes in format x1 y1 x2 y2
# 2 bounding boxes: first from (10,20) to (50,60), second from (70,30) to (120,80)
bounding_boxes = np.array([
    [10, 20, 50, 60],
    [70, 30, 120, 80]
], dtype=np.float32)

# Define color as RGB tuple (B, G, R for cv2)
color = [0, 255, 0]

ARGS = {
    "im": test_image,
    "cords": bounding_boxes,
    "color": color
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
cv2, numpy — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type ndarray, ndim 3, dtype family int, shape (100, 150, 3) — shape (100, 150, 3) 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
exif_size Ran
ran, honoured the contract we drafted
yuedongli1/yolov3_mindspore/utils/dataset.py
pointer only (licence: MIT); the stored copy get_code serves, from serkansulun/video-emotion, is pointer only (licence: NOASSERTION) · get_code("2ae73fdbbb2cb8ba")
How it ran

The body of this sample is withheld: this paper's link allows the body inline (MIT), but get_code serves the stored copy, first harvested from serkansulun/video-emotion, and GitHub could not classify the licence of that repository (NOASSERTION). The setup block that called it is withheld with it, because it is written against that body. source_path and origin say where the code lives, to read under the repository's own terms. A run is recorded.

floatn Ran
ran, honoured the contract we drafted
Zzh-tju/ultralytics-YOLOv3-Cluster-NMS/utils/utils.py
pointer only (licence: GPL-3.0) · get_code("ed702a199df9d0db")
How it ran

The body of this sample is withheld: GPL-3.0, as GitHub detects it on this paper's repository, Zzh-tju/ultralytics-YOLOv3-Cluster-NMS, is not in the permissive set Syntology serves inline. The setup block that called it is withheld with it, because it is written against that body. source_path and origin say where the code lives, to read under the repository's own terms. A run is recorded.

fuse_conv_and_bn Ran
ran on a synthesized input
Lornatang/PyTorch-yolov3/yolov3_pytorch/models/module.py
code served (permissive licence) · get_code("4958de84124bd877")
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 Conv2d. 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
from torch import nn

torch.manual_seed(0)

# Create a Conv2d layer
# in_channels=3, out_channels=4, kernel_size=3, stride=1, padding=1
conv = nn.Conv2d(in_channels=3, out_channels=4, kernel_size=3, stride=1, padding=1, bias=True)

# Initialize conv weights and bias with some values
conv.weight.data.fill_(0.1)
conv.bias.data.fill_(0.05)

# Create a BatchNorm2d layer matching the output channels of conv
bn = nn.BatchNorm2d(num_features=4)

# Initialize BatchNorm parameters
bn.weight.data.fill_(1.0)
bn.bias.data.fill_(0.0)
bn.running_mean.fill_(0.1)
bn.running_var.fill_(0.5)
bn.eps = 1e-5

ARGS = {
    "conv": conv,
    "bn": bn
}
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 Conv2d — a Conv2d output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a Conv2d 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
generate_grid_index Ran
ran on a synthesized input
liulianjushi/yolo_v3_tf2.0/yolo/bounding_box.py
code served (permissive licence) · get_code("7841edd8ae71f548")
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 EagerTensor, ndim 2, dtype family float, shape (16, 2) 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 tensorflow as tf

# The function generate_grid_index takes a single parameter: grid_dim
# It uses tf.range, tf.meshgrid, tf.reshape, and tf.concat
# grid_dim should be an integer representing the dimension of the grid

ARGS = {
    "grid_dim": 4
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
tensorflow — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type EagerTensor, ndim 2, dtype family float, shape (16, 2) — shape (16, 2) 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
get_abs_coord Ran
ran on a synthesized input
GunjanChourasia/custom_detector_yolov3/bbox.py
code served (permissive licence) · get_code("ec014668804d4c46")
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 numpy as np

torch.manual_seed(0)

# The function expects a box parameter which is a sequence-like object
# that supports indexing and item assignment. Based on the function body:
# - box[0], box[1] are center coordinates (x, y)
# - box[2], box[3] are width and height
# - The function modifies box[2] and box[3] in place
# - Returns a tuple of 4 coordinates (x1, y1, x2, y2)

# Create a simple list representing a bounding box
# Format: [center_x, center_y, width, height]
box = [10.0, 20.0, 5.0, 8.0]

ARGS = {
    "box": box
}
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 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_anchors Ran
ran on a synthesized input
YunYang1994/tensorflow-yolov3/core/utils.py
code served (permissive licence) · get_code("eb22d53f46cdff31")
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 3, dtype family float, shape (3, 3, 2) 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 tempfile
import os

# Create a temporary anchors file
temp_dir = tempfile.mkdtemp()
anchors_path = os.path.join(temp_dir, "anchors.txt")

# Write anchor data to the temporary file
# The function expects a CSV string that can be reshaped to (3, 3, 2)
# That's 3 * 3 * 2 = 18 values
anchor_values = "1.2,2.3,3.4,4.5,5.6,6.7,7.8,8.9,9.0,10.1,11.2,12.3,13.4,14.5,15.6,16.7,17.8,18.9"
with open(anchors_path, 'w') as f:
    f.write(anchor_values)

ARGS = {
    "anchors_path": anchors_path
}
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 3, dtype family float, shape (3, 3, 2) — shape (3, 3, 2) 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
get_anchors Ran
ran on a synthesized input
qqwweee/keras-yolo3/train_bottleneck.py
code served (permissive licence) · get_code("d9196437ddef4b60")
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 2, dtype family float, shape (3, 2) 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 tempfile
import os

# Create a temporary file with anchor data
temp_dir = tempfile.mkdtemp()
anchors_path = os.path.join(temp_dir, "anchors.txt")

# Write sample anchor data to the file
# The function expects comma-separated floats that reshape to (-1, 2)
anchor_data = "10.0,20.0,30.0,40.0,50.0,60.0"
with open(anchors_path, 'w') as f:
    f.write(anchor_data)

ARGS = {
    'anchors_path': anchors_path
}
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 2, dtype family float, shape (3, 2) — shape (3, 2) 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
get_classes Ran
ran on a synthesized input
qqwweee/keras-yolo3/train_bottleneck.py
code served (permissive licence) · get_code("688442602fea3347")
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 tempfile
import os

# Create a temporary file with class names
temp_file = tempfile.NamedTemporaryFile(mode='w', delete=False, suffix='.txt')
temp_file.write("class_0\n")
temp_file.write("class_1\n")
temp_file.write("class_2\n")
temp_file.close()

ARGS = {
    "classes_path": temp_file.name
}
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
get_hash Ran
ran on a synthesized input
yuedongli1/yolov3_mindspore/utils/dataset.py
code served (permissive licence) · get_code("a3c4fa7fd984d56b")
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 str. 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 os
import tempfile
import hashlib

# Create temporary files for testing
temp_dir = tempfile.mkdtemp()
test_file_1 = os.path.join(temp_dir, "test1.txt")
test_file_2 = os.path.join(temp_dir, "test2.txt")

# Write some content to the files
with open(test_file_1, 'w') as f:
    f.write("a" * 100)

with open(test_file_2, 'w') as f:
    f.write("b" * 200)

# Define ARGS with paths parameter
ARGS = {
    'paths': [test_file_1, test_file_2]
}
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 str — a str output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a str 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_histogram Ran
ran on a synthesized input
mvxxx/mimuw-hats/model/api/similarity.py
code served (permissive licence) · get_code("f0656af9cfc0e4cc")
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 2, 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 numpy as np

# Create a small test image with shape (height, width, channels)
# Using distinct dimensions: 4x5x3
img = np.random.randint(0, 256, size=(4, 5, 3), dtype=np.uint8)

ARGS = {
    "img": img
}
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 list, ndim 2, 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
get_img_size Ran
ran on a synthesized input
zhanghuiyao/yolov3_mindspore/postprocess.py
code served (permissive licence) · get_code("b13acc0922dade5c")
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 int; 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 numpy as np
from PIL import Image
import io

torch.manual_seed(0)

# Create a small test image in memory
img_array = np.random.randint(0, 256, (100, 150, 3), dtype=np.uint8)
img = Image.fromarray(img_array)

# Save to bytes buffer
buffer = io.BytesIO()
img.save(buffer, format='PNG')
buffer.seek(0)

# Write to a temporary file path (we'll use a string path)
import tempfile
with tempfile.NamedTemporaryFile(suffix='.png', delete=False) as f:
    f.write(buffer.getvalue())
    temp_file_path = f.name

ARGS = {
    'file_name': temp_file_path
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
PIL, numpy, 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 int — 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_length_of_dataset Ran
ran on a synthesized input
calmisential/YOLOv3_TensorFlow2/data_process/make_dataset.py
code served (permissive licence) · get_code("410bf279e17ed843")
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 int, ndim 0, dtype family int, 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)

# The function iterates over the dataset and counts elements
# So we need an iterable object that yields items

class SimpleDataset:
    def __init__(self, size=5):
        self.size = size
    
    def __iter__(self):
        for i in range(self.size):
            yield (torch.randn(2, 4), torch.tensor(i))

dataset = SimpleDataset(size=5)

ARGS = {
    "dataset": dataset
}
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 int, ndim 0, dtype family int, 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
get_logger Ran
ran on a synthesized input
zhanghuiyao/yolov3_mindspore/src/logger.py
code served (permissive licence) · get_code("f938002f1fb9665f")
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 LOGGER. 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 os
import sys
import logging
import tempfile
from datetime import datetime

# Create a temporary directory for logging
temp_dir = tempfile.mkdtemp()

ARGS = {
    'path': temp_dir,
    'rank': 0
}
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 LOGGER — a LOGGER output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a LOGGER 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_random_data Ran
ran; our contract draft was wrong, not the code
qqwweee/keras-yolo3/yolo3/utils.py
code served (permissive licence) · get_code("2d6f15893e2ed21a")
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. 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 PIL import Image
import tempfile
import os

# Create a temporary directory for test images
temp_dir = tempfile.mkdtemp()

# Create a small test image and save it
test_image = Image.new('RGB', (100, 80), color=(73, 109, 137))
image_path = os.path.join(temp_dir, 'test_image.jpg')
test_image.save(image_path)

# Create annotation line with image path and bounding boxes
# Format: image_path box1 box2 ... where each box is x1,y1,x2,y2,class_id
annotation_line = f"{image_path} 10,20,50,60,0 55,25,80,70,1"

ARGS = {
    'annotation_line': annotation_line,
    'input_shape': (224, 224),
    'random': True,
    'max_boxes': 20,
    'jitter': 0.3,
    'hue': 0.1,
    'sat': 1.5,
    'val': 1.5,
    'proc_img': True
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
PIL, matplotlib, numpy — 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
get_test_input Ran
ran on a synthesized input
GunjanChourasia/custom_detector_yolov3/live.py
code served (permissive licence) · get_code("4a14389065cd27db")
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 4, dtype family float, shape (1, 3, 64, 64) as a later run recorded it. 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, 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 numpy as np
import tempfile
import os

torch.manual_seed(0)

# Create a fake image file since cv2.imread is used in the function
# We need to create a temporary PNG file
temp_dir = tempfile.gettempdir()
fake_image_path = os.path.join(temp_dir, 'dog-cycle-car.png')

# Create a simple RGB image and save it
fake_img = np.random.randint(0, 256, (100, 100, 3), dtype=np.uint8)
import cv2
cv2.imwrite(fake_image_path, fake_img)

# Change to temp directory so the function can find the image
original_dir = os.getcwd()
os.chdir(temp_dir)

ARGS = {
    'input_dim': 64
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
cv2, numpy, torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type Tensor, ndim 4, dtype family float, shape (1, 3, 64, 64) — shape (1, 3, 64, 64) 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
get_transform Ran
ran on a synthesized input
DevBruce/YOLOv3-TF2/libs/utils/augs.py
code served (permissive licence) · get_code("5a7d8b60a457be7b")
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 Compose. 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 albumentations as A

np.random.seed(0)

ARGS = {
    'img_height': 480,
    'img_width': 640,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
albumentations, numpy — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type Compose — a Compose output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a Compose output the recorded ndim 1 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_yolo_layers Ran
ran, honoured the contract we drafted
Raychou0830/Carplate/models.py
pointer only (licence: GPL-3.0) · get_code("ec338718ed4c4fe1")
How it ran

The body of this sample is withheld: GPL-3.0, as GitHub detects it on this paper's repository, Raychou0830/Carplate, is not in the permissive set Syntology serves inline. The setup block that called it is withheld with it, because it is written against that body. source_path and origin say where the code lives, to read under the repository's own terms. A run is recorded.

image_preporcess Ran
ran on a synthesized input
YunYang1994/tensorflow-yolov3/core/utils.py
code served (permissive licence) · get_code("b7e9b538a3a6d6c6")
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. 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 cv2
import numpy as np

# Create a small test image (BGR format, as expected by cv2.cvtColor)
# Using shape (480, 640, 3) for a realistic small image
np.random.seed(0)
test_image = np.random.randint(0, 255, size=(480, 640, 3), dtype=np.uint8)

# Create ground truth boxes in format [x1, y1, x2, y2]
# Using 3 boxes with coordinates that fit within the image
gt_boxes = np.array([
    [10.0, 20.0, 100.0, 150.0],
    [200.0, 250.0, 350.0, 400.0],
    [50.0, 100.0, 200.0, 300.0]
], dtype=np.float32)

# Target size (height, width)
target_size = (416, 416)

ARGS = {
    "image": test_image,
    "target_size": target_size,
    "gt_boxes": gt_boxes
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
cv2, numpy — 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
img2label_paths Ran
ran on a synthesized input
yuedongli1/yolov3_mindspore/utils/dataset.py
code served (permissive licence) · get_code("ca5277eb2bdc881d")
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 os

def img2label_paths(img_paths):
    sa, sb = (os.sep + 'images' + os.sep, os.sep + 'labels' + os.sep)
    return ['txt'.join(x.replace(sa, sb, 1).rsplit(x.split('.')[-1], 1)) for x in img_paths]

# Setup: img_paths is a list of file paths with 'images' directory in them
# The function replaces 'images' with 'labels' and changes the file extension to 'txt'

ARGS = {
    'img_paths': [
        os.sep.join(['data', 'images', 'image1.jpg']),
        os.sep.join(['data', 'images', 'image2.png']),
        os.sep.join(['project', 'dataset', 'images', 'photo.jpeg'])
    ]
}
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
inv_sigmoid Ran
ran on a synthesized input
euske/derpyolo/vocutils.py
code served (permissive licence) · get_code("ebad0ef33daaaf54")
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 float, 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 math

def inv_sigmoid(y):
    if 0 < y and y < 1:
        return -math.log(1.0 / y - 1.0)
    raise ValueError(y)

# The function takes a single parameter y which must be a float between 0 and 1 (exclusive)
# We'll use a value like 0.5 which is valid
ARGS = {
    "y": 0.5
}
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 float, 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
kaiming_uniform_ Ran
ran on a synthesized input
zhanghuiyao/yolov3_mindspore/src/initializer.py
code served (permissive licence) · get_code("9a180909c46a9282")
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 2, dtype family float, shape (5, 3) 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 math

# Create a small numpy array with shape (out_features, in_features, ...)
# Using distinct dimensions: 5 output features, 3 input features
arr = np.empty((5, 3))

ARGS = {
    'arr': arr,
    'a': 0.2,
    'mode': 'fan_in',
    'nonlinearity': 'leaky_relu'
}
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 2, dtype family float, shape (5, 3) — shape (5, 3) 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
letterbox Ran
ran on a synthesized input
DevBruce/YOLOv3-TF2/libs/utils/augs.py
code served (permissive licence) · get_code("ffa8fed7bfc2815e")
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. 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 cv2
import numpy as np

# Create a small test image (height=100, width=150, channels=3)
img_arr = np.random.randint(0, 256, size=(100, 150, 3), dtype=np.uint8)

# Define target size (height, width)
target_size = (200, 300)

# Create bounding boxes in format [x_min, y_min, x_max, y_max]
# 2 boxes with distinct values for probing
boxes = np.array([
    [10.0, 20.0, 50.0, 80.0],
    [60.0, 30.0, 140.0, 90.0]
], dtype=np.float32)

ARGS = {
    "img_arr": img_arr,
    "target_size": target_size,
    "boxes": boxes
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
cv2, numpy — 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
letterbox_image Ran
ran; our contract draft was wrong, not the code
qqwweee/keras-yolo3/yolo3/utils.py
code served (permissive licence) · get_code("fe7e8a0ae28d05e2")
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 Image. 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.

from PIL import Image

# Create a small test image
image = Image.new('RGB', (100, 80), color=(200, 100, 50))

# Define target size for letterboxing
size = (128, 128)

ARGS = {
    'image': image,
    'size': size,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
PIL — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type Image — a Image output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a Image output the recorded ndim 3 and dtype family int 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
load_class_names_from_file Ran
ran on a synthesized input
Lornatang/PyTorch-yolov3/yolov3_pytorch/utils/common.py
code served (permissive licence) · get_code("0b7afeadea0cacd7")
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.

from pathlib import Path
import tempfile
import os

# Create a temporary file with class names
temp_dir = tempfile.mkdtemp()
temp_file = os.path.join(temp_dir, "class_names.txt")

with open(temp_file, 'w') as f:
    f.write("class_0\n")
    f.write("class_1\n")
    f.write("class_2\n")

ARGS = {
    "path": temp_file
}
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
load_classes Ran
ran; our contract draft was wrong, not the code
Zzh-tju/ultralytics-YOLOv3-Cluster-NMS/utils/utils.py
pointer only (licence: GPL-3.0) · get_code("fa99a26b6ba8f205")
How it ran

The body of this sample is withheld: GPL-3.0, as GitHub detects it on this paper's repository, Zzh-tju/ultralytics-YOLOv3-Cluster-NMS, is not in the permissive set Syntology serves inline. The setup block that called it is withheld with it, because it is written against that body. source_path and origin say where the code lives, to read under the repository's own terms. A run is recorded.

load_darknet_weights Ran
ran on a synthesized input
Lornatang/PyTorch-yolov3/yolov3_pytorch/models/utils.py
code served (permissive licence) · get_code("123fe9f28114f0d9")
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 MinimalDarknet. 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
import torch.nn as nn
import numpy as np
import tempfile
import os

torch.manual_seed(0)

# Create a minimal Darknet-like model that has the required attributes
class MinimalDarknet(nn.Module):
    def __init__(self):
        super().__init__()
        self.header_info = None
        self.seen = None
        
        # Create module_defines and module_list as the function expects
        self.module_defines = [
            {'type': 'convolutional', 'batch_normalize': True},
            {'type': 'convolutional', 'batch_normalize': False},
        ]
        
        # First module: conv with batch norm
        conv1 = nn.Conv2d(3, 16, kernel_size=3, padding=1)
        bn1 = nn.BatchNorm2d(16)
        module1 = nn.Sequential(conv1, bn1)
        
        # Second module: conv without batch norm
        conv2 = nn.Conv2d(16, 32, kernel_size=3, padding=1)
        module2 = nn.Sequential(conv2)
        
        self.module_list = nn.ModuleList([module1, module2])

# Create a temporary weights file in darknet format
def create_dummy_weights_file():
    # Create temporary file
    fd, weights_path = tempfile.mkstemp(suffix='.weights')
    os.close(fd)
    
    with open(weights_path, 'wb') as f:
        # Write header: [major, minor, revision, seen, _]
        header = np.array([0, 0, 0, 1000, 0], dtype=np.int32)
        header.tofile(f)
        
        # Calculate total weights needed
        model = MinimalDarknet()
        
        # Module 1: conv1 + bn1
        conv1 = model.module_list[0][0]
        bn1 = model.module_list[0][1]
        
        # Module 2: conv2
        conv2 = model.module_list[1][0]
        
        # Collect all weights in darknet order
        weights_list = []
        
        # Module 1 with batch norm: bn.bias, bn.weight, bn.running_mean, bn.running_var, conv.weight
        weights_list.append(bn1.bias.data.numpy())
        weights_list.append(bn1.weight.data.numpy())
        weights_list.append(bn1.running_mean.data.numpy())
        weights_list.append(bn1.running_var.data.numpy())
        weights_list.append(conv1.weight.data.numpy().flatten())
        
        # Module 2 without batch norm: conv.bias, conv.weight
        weights_list.append(conv2.bias.data.numpy())
        weights_list.append(conv2.weight.data.numpy().flatten())
        
        weights = np.concatenate(weights_list)
        weights.astype(np.float32).tofile(f)
    
    return weights_path

# Set up arguments
model = MinimalDarknet()
weights_path = create_dummy_weights_file()

ARGS = {
    'model': model,
    'weights_path': weights_path,
}
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 MinimalDarknet — a MinimalDarknet output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a MinimalDarknet 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

Showing the first 60. An agent gets every one from get_harvested_code_for_paper("1804.02767").

Also present in other papers' code

Of 124 samples lifted from this paper's linked repositories, 124 carry a function identity and 0 do not. Of the 124 distinct functions with an identity, 37 are also present in other papers whose code we hold (17 with at least one paper dated earlier, 2 the same month, 30 later) and 87 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
merge 28 other papers
8 dated earlier, 1 the same month, 19 later
1406.1078 (2014-06)
Learning Phrase Representations using RNN Encoder-Decoder for Statistical Machine Translation
1409.3215 (2014-09)
Sequence to Sequence Learning with Neural Networks
1512.00567 (2015-12)
Rethinking the Inception Architecture for Computer Vision
and 25 more not named here
autopad 23 other papers
2 dated earlier, 21 later · 1 only as an assembly brick
1311.2524 (2013-11)
Rich feature hierarchies for accurate object detection and semantic segmentation
1703.07402 (2017-03)
Simple Online and Realtime Tracking with a Deep Association Metric
1902.03368 (2019-02)
Skin Lesion Analysis Toward Melanoma Detection 2018: A Challenge Hosted by the International Skin Imaging Collaboration (ISIC)
and 20 more not named here
parse_cli_to_yaml 20 other papers
6 dated earlier, 1 the same month, 13 later
1406.1078 (2014-06)
Learning Phrase Representations using RNN Encoder-Decoder for Statistical Machine Translation
1409.3215 (2014-09)
Sequence to Sequence Learning with Neural Networks
1512.00567 (2015-12)
Rethinking the Inception Architecture for Computer Vision
and 17 more not named here
parse_yaml 15 other papers
6 dated earlier, 9 later
1406.1078 (2014-06)
Learning Phrase Representations using RNN Encoder-Decoder for Statistical Machine Translation
1409.3215 (2014-09)
Sequence to Sequence Learning with Neural Networks
1512.00567 (2015-12)
Rethinking the Inception Architecture for Computer Vision
and 12 more not named here
count_parameters 7 other papers
7 later
1904.12257 (2019-04)
Spatio-Temporal Filter Adaptive Network for Video Deblurring
1905.05934 (2019-05)
EigenDamage: Structured Pruning in the Kronecker-Factored Eigenbasis
2006.12250 (2020-06)
Pix2Vox++: Multi-scale Context-aware 3D Object Reconstruction from Single and Multiple Images
and 4 more not named here
load_classes 6 other papers
6 later
1911.08287 (2019-11)
Distance-IoU Loss: Faster and Better Learning for Bounding Box Regression
2004.10934 (2020-04)
YOLOv4: Optimal Speed and Accuracy of Object Detection
2005.03572 (2020-05)
Enhancing Geometric Factors in Model Learning and Inference for Object Detection and Instance Segmentation
and 3 more not named here
unique_config_sections 5 other papers
3 dated earlier, 2 later
1612.08242 (2016-12)
YOLO9000: Better, Faster, Stronger
1703.07402 (2017-03)
Simple Online and Realtime Tracking with a Deep Association Metric
1710.10891 (2017-10)
Open Set Logo Detection and Retrieval
and 2 more not named here
c_array 4 other papers
2 dated earlier, 2 later
1609.04836 (2016-09)
On Large-Batch Training for Deep Learning: Generalization Gap and Sharp Minima
1612.08242 (2016-12)
YOLO9000: Better, Faster, Stronger
1907.10890 (2019-07)
DeFog: Fog Computing Benchmarks
and 1 more not named here
make_divisible 4 other papers
4 later
2004.10934 (2020-04)
YOLOv4: Optimal Speed and Accuracy of Object Detection
2004.11757 (2020-04)
Ultra Fast Structure-aware Deep Lane Detection
2009.02967 (2020-09)
Stochastic-YOLO: Efficient Probabilistic Object Detection under Dataset Shifts
and 1 more not named here
sample 4 other papers
2 dated earlier, 2 later
1609.04836 (2016-09)
On Large-Batch Training for Deep Learning: Generalization Gap and Sharp Minima
1612.08242 (2016-12)
YOLO9000: Better, Faster, Stronger
1907.10890 (2019-07)
DeFog: Fog Computing Benchmarks
and 1 more not named here
IOU 3 other papers
3 dated earlier
1602.02282 (2016-02)
Ladder Variational Autoencoders
1609.04836 (2016-09)
On Large-Batch Training for Deep Learning: Generalization Gap and Sharp Minima
1612.08242 (2016-12)
YOLO9000: Better, Faster, Stronger
avg_IOU 3 other papers
3 dated earlier
1602.02282 (2016-02)
Ladder Variational Autoencoders
1609.04836 (2016-09)
On Large-Batch Training for Deep Learning: Generalization Gap and Sharp Minima
1612.08242 (2016-12)
YOLO9000: Better, Faster, Stronger
calculate_gain 3 other papers
3 later
2104.00298 (2021-04)
EfficientNetV2: Smaller Models and Faster Training
2105.15203 (2021-05)
SegFormer: Simple and Efficient Design for Semantic Segmentation with Transformers
2107.08430 (2021-07)
YOLOX: Exceeding YOLO Series in 2021
exif_size 3 other papers
3 later
2004.10934 (2020-04)
YOLOv4: Optimal Speed and Accuracy of Object Detection
2009.02967 (2020-09)
Stochastic-YOLO: Efficient Probabilistic Object Detection under Dataset Shifts
2602.07063 (2026-02)
Video-based Music Generation
get_yolo_layers 3 other papers
3 later
2004.10934 (2020-04)
YOLOv4: Optimal Speed and Accuracy of Object Detection
2004.11757 (2020-04)
Ultra Fast Structure-aware Deep Lane Detection
2009.02967 (2020-09)
Stochastic-YOLO: Efficient Probabilistic Object Detection under Dataset Shifts
labels_to_class_weights 3 other papers
3 later
1911.08287 (2019-11)
Distance-IoU Loss: Faster and Better Learning for Bounding Box Regression
2005.03572 (2020-05)
Enhancing Geometric Factors in Model Learning and Inference for Object Detection and Instance Segmentation
2009.02967 (2020-09)
Stochastic-YOLO: Efficient Probabilistic Object Detection under Dataset Shifts
letterbox_image 3 other papers
3 later
1905.05055 (2019-05)
Object Detection in 20 Years: A Survey
2003.08813 (2020-03)
Multi-task Collaborative Network for Joint Referring Expression Comprehension and Segmentation
2601.07576 (2026-01)
A Multimodal Dataset of Student Oral Presentations with Sensors and Evaluation Data
network_width 3 other papers
2 dated earlier, 1 later
1609.04836 (2016-09)
On Large-Batch Training for Deep Learning: Generalization Gap and Sharp Minima
1612.08242 (2016-12)
YOLO9000: Better, Faster, Stronger
2004.10934 (2020-04)
YOLOv4: Optimal Speed and Accuracy of Object Detection
rand 3 other papers
3 later
1905.05055 (2019-05)
Object Detection in 20 Years: A Survey
2003.08813 (2020-03)
Multi-task Collaborative Network for Joint Referring Expression Comprehension and Segmentation
2601.07576 (2026-01)
A Multimodal Dataset of Student Oral Presentations with Sensors and Evaluation Data
floatn 2 other papers
2 later
1911.08287 (2019-11)
Distance-IoU Loss: Faster and Better Learning for Bounding Box Regression
2005.03572 (2020-05)
Enhancing Geometric Factors in Model Learning and Inference for Object Detection and Instance Segmentation

Shown: the 20 functions present in the most other papers. 17 more shared functions are not listed here.

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

More are linked than shown here.

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

Abstract

We present some updates to YOLO! We made a bunch of little design changes to make it better. We also trained this new network that's pretty swell. It's a little bigger than last time but more accurate. It's still fast though, don't worry. At 320x320 YOLOv3 runs in 22 ms at 28.2 mAP, as accurate as SSD but three times faster. When we look at the old .5 IOU mAP detection metric YOLOv3 is quite good. It achieves 57.9 mAP@50 in 51 ms on a Titan X, compared to 57.5 mAP@50 in 198 ms by RetinaNet, similar performance but 3.8x faster. As always, all the code is online at https://pjreddie.com/yolo/

For agents

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

get_harvested_code_for_paper("1804.02767")
get_code_for_paper("1804.02767")
have("1804.02767")

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

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

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

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

Connect an agent — have() is free.