SYNTOLOGY HomeExplorerAtlasCodeMethodologyAboutDevelopersFeedPricing
Paper · 2004.10934 · arXiv.org · 2020

YOLOv4: Optimal Speed and Accuracy of Object Detection

arXiv · PDF · Open in the Atlas

Code that ran

142 of 184 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; 11 honoured the contract we drafted, 0 violated it and 106 have no contract verdict; 25 failures of our instrument; 42 no recorded run), measured 2026-11-21; 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/2004.10934.json · badge: /api/ran/2004.10934.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
JisuHann/MEME-Tracking community (classifier label)
classifier basis: plan_row
15 ran · 0 no recorded run
GuoQuanhao/YOLOv4-Paddle community (classifier label)
classifier basis not recorded on the link
13 ran · 1 no recorded run
bubbliiiing/yolov4-pytorch community (classifier label)
classifier basis not recorded on the link
12 ran · 0 no recorded run
nemonameless/PaddleDetection_YOLOX community (classifier label)
classifier basis not recorded on the link
10 ran · 3 no recorded run
OwlTing/AI_basketball_games_video_editor community (classifier label)
classifier basis not recorded on the link
10 ran · 1 no recorded run
jason-hu7/PyTorch-YOLOv4 community (classifier label)
classifier basis not recorded on the link
10 ran · 0 no recorded run
Gavino7/YOLOv3set community (classifier label)
classifier basis not recorded on the link
7 ran · 1 no recorded run
WinstonLy/Electricity-Inspection-Based-Ascend310 community (classifier label)
classifier basis not recorded on the link
6 ran · 0 no recorded run
Dodant/ANPR-with-Yolov4 community (classifier label)
classifier basis: plan_row
5 ran · 2 no recorded run
ruyueshuo/DeepStream_YOLOv4 community (classifier label)
classifier basis not recorded on the link
5 ran · 1 no recorded run
zhanghuiyao/yolov5_mindspore community (classifier label)
classifier basis not recorded on the link
5 ran · 0 no recorded run
rechardchen123/YOLOv4_traffic_sign_detection community (classifier label)
classifier basis not recorded on the link
4 ran · 1 no recorded run
michhar/azureml-keras-yolov3-custom community (classifier label)
classifier basis not recorded on the link
4 ran · 1 no recorded run
youchangxin/YOLOv4_tensorflow2 community (classifier label)
classifier basis not recorded on the link
4 ran · 0 no recorded run
sushmaakoju/yolo community (classifier label)
classifier basis not recorded on the link
4 ran · 0 no recorded run
Lornatang/YOLOv4-PyTorch community (classifier label)
classifier basis not recorded on the link
3 ran · 5 no recorded run
UtkarshKharche29/Automatic-Number-Plate-Recognition community (classifier label)
classifier basis not recorded on the link
3 ran · 2 no recorded run
hunglc007/tensorflow-yolov4-tflite community (classifier label)
classifier basis not recorded on the link
3 ran · 2 no recorded run
VCasecnikovs/Yet-Another-YOLOv4-Pytorch community (classifier label)
classifier basis not recorded on the link
3 ran · 1 no recorded run
HeegonJin/yolov1 reimplementation (classifier label)
classifier basis: classifier_2025
3 ran · 0 no recorded run
2023-MindSpore-1/ms-code-51 community (classifier label)
classifier basis not recorded on the link
3 ran · 0 no recorded run
Lebhoryi/keras-YOLOv3-model-set community (classifier label)
classifier basis not recorded on the link
2 ran · 4 no recorded run
hhk7734/tensorflow-yolov4 community (classifier label)
classifier basis not recorded on the link
2 ran · 3 no recorded run
samson6460/tf2_YOLO reimplementation (classifier label)
classifier basis: classifier_2025
2 ran · 1 no recorded run
MEME-Phoenix/Autonomous-Driving-Cart-MEME community (classifier label)
classifier basis not recorded on the link
1 ran · 2 no recorded run
FunctionStatusWhere it lives
DWConv Ran
ran; our contract draft was wrong, not the code
Lornatang/YOLOv4-PyTorch/yolov4_pytorch/model/module/conv.py
code served (permissive licence) · get_code("483be17bd193bd73")
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 Conv. 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 math

torch.manual_seed(0)

def autopad(k, p=None):
    if p is None:
        p = k // 2 if isinstance(k, int) else [x // 2 for x in k]
    return p

class Conv(nn.Module):

    def __init__(self, c1, c2, k=1, s=1, p=None, g=1, act=True):
        super(Conv, self).__init__()
        self.conv = nn.Conv2d(c1, c2, k, s, autopad(k, p), groups=g, bias=False)
        self.bn = nn.BatchNorm2d(c2)
        self.act = nn.LeakyReLU(0.1, inplace=True) if act else nn.Identity()

    def forward(self, x):
        return self.act(self.bn(self.conv(x)))

    def fuseforward(self, x):
        return self.act(self.conv(x))

def DWConv(c1, c2, k=1, s=1, act=True):
    return Conv(c1, c2, k, s, g=math.gcd(c1, c2), act=act)

ARGS = {
    'c1': 4,
    'c2': 8,
    'k': 3,
    's': 1,
    'act': True
}
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 Conv — a Conv output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a Conv 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
DelayedCosineAnnealingLR Ran
ran on a synthesized input
VCasecnikovs/Yet-Another-YOLOv4-Pytorch/sched_del.py
code served (permissive licence) · get_code("95a1c1b3c5daba88")
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 DelayerScheduler. 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
from torch.optim import SGD
from torch.optim.lr_scheduler import CosineAnnealingLR

torch.manual_seed(0)

# Create a minimal model
model = nn.Linear(4, 3)

# Create an optimizer
optimizer = SGD(model.parameters(), lr=0.1)

# Define the arguments for DelayedCosineAnnealingLR
ARGS = {
    "optimizer": optimizer,
    "delay_epochs": 5,
    "cosine_annealing_epochs": 10
}
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 DelayerScheduler — a DelayerScheduler output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a DelayerScheduler 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
GiB Ran
ran on a synthesized input
OwlTing/AI_basketball_games_video_editor/pytorch_YOLOv4/demo_trt.py
code served (permissive licence) · get_code("9b7ca59c50ad0b33")
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

def GiB(val):
    return val * 1 << 30

# The function takes a single parameter 'val' which is multiplied by 2^30
# This is a simple utility function that converts a value to gigabytes (in bytes)
# val can be any numeric type (int, float, etc.)

ARGS = {
    "val": 5
}
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
ap_per_class Ran
ran on a synthesized input
jason-hu7/PyTorch-YOLOv4/src/yolov4/evaluate.py
code served (permissive licence) · get_code("fb11e5a36b487be1")
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 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

np.random.seed(0)

# Create small test data for ap_per_class
# tp: True positives (binary array)
tp = np.array([1, 0, 1, 1, 0, 1], dtype=np.int32)

# conf: Objectness confidence scores (0-1)
conf = np.array([0.9, 0.8, 0.7, 0.6, 0.5, 0.4], dtype=np.float32)

# pred_cls: Predicted class labels
pred_cls = np.array([0, 1, 0, 2, 1, 0], dtype=np.int32)

# target_cls: True class labels
target_cls = np.array([0, 0, 0, 1, 1, 2], dtype=np.int32)

ARGS = {
    'tp': tp,
    'conf': conf,
    'pred_cls': pred_cls,
    'target_cls': target_cls,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy, tqdm — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type tuple, ndim 2, 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
assert_in Ran
ran on a synthesized input
JisuHann/MEME-Tracking/deep_sort_pytorch/utils/asserts.py
code served (permissive licence) · get_code("287f12a551c1c76a")
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 bool, 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

torch.manual_seed(0)

# The function checks if 'file' is in 'files_to_check'
# Both parameters appear to be compared for membership, so they can be strings or other comparable objects

file = "model.pth"
files_to_check = ["model.pth", "config.json", "weights.bin"]

ARGS = {
    "file": file,
    "files_to_check": files_to_check
}
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 bool, 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
assert_in_env Ran
ran on a synthesized input
JisuHann/MEME-Tracking/deep_sort_pytorch/utils/asserts.py
code served (permissive licence) · get_code("3d29e11e107d75b2")
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 bool, 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 os
from os import environ

# Set up some environment variables for the function to check
os.environ['TEST_VAR_1'] = 'value1'
os.environ['TEST_VAR_2'] = 'value2'
os.environ['TEST_VAR_3'] = 'value3'

# Define ARGS with a check_list parameter
ARGS = {
    'check_list': ['TEST_VAR_1', 'TEST_VAR_2', 'TEST_VAR_3']
}
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 bool, 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
auto_pad Ran
ran on a synthesized input
zhanghuiyao/yolov5_mindspore/src/backbone.py
code served (permissive licence) · get_code("c0c6a62986836544")
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 numpy as np

torch.manual_seed(0)

def auto_pad(k, p=None):
    if p is None:
        p = k // 2 if isinstance(k, int) else [x // 2 for x in k]
    return p

# Test case 1: k is an int
k_int = 5

# Test case 2: k is a list/tuple of ints
k_list = [4, 6, 8]

# Test case 3: p is explicitly provided (int)
p_int = 2

# Test case 4: p is explicitly provided (list)
p_list = [1, 2, 3]

ARGS = {
    "k": 5,
    "p": None
}
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 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
autopad Ran
ran, honoured the contract we drafted
GuoQuanhao/YOLOv4-Paddle/models/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.

autopad Ran
ran, honoured the contract we drafted
Yuzi0123/MindSpore_Yolov5/network/common.py
pointer only (licence: MIT); the stored copy get_code serves, from LiuZhu-CV/DEAL, is pointer only (licence: NONE) · get_code("86db6b7ab1646a7c")
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 LiuZhu-CV/DEAL, 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.

avg_iou Ran
ran on a synthesized input
bubbliiiing/yolov4-pytorch/kmeans_for_anchors.py
code served (permissive licence) · get_code("4c6b7d44826bea5a")
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 float32, 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 numpy as np

# Construct arguments for avg_iou function
# The function expects:
# - box: numpy array of shape (N, 2) containing box dimensions
# - cluster: numpy array of shape (M, 2) containing cluster dimensions

# Create small stand-in data
box = np.array([
    [10.0, 20.0],
    [15.0, 25.0]
], dtype=np.float32)

cluster = np.array([
    [12.0, 18.0],
    [8.0, 22.0],
    [14.0, 24.0]
], dtype=np.float32)

ARGS = {
    "box": box,
    "cluster": cluster
}
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 float32, 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
bb_intersection_over_union Ran
ran on a synthesized input
OwlTing/AI_basketball_games_video_editor/tool/utils_basketball.py
code served (permissive licence) · get_code("b53d797b64b0f56f")
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

torch.manual_seed(0)

# boxA and boxB are expected to be sequences/lists with 4 elements
# representing bounding box coordinates [x1, y1, x2, y2]
boxA = [10, 20, 50, 60]
boxB = [30, 40, 70, 80]

ARGS = {
    "boxA": boxA,
    "boxB": boxB
}
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
bbox2points Ran
ran on a synthesized input
ruyueshuo/DeepStream_YOLOv4/darknet.py
code served (permissive licence) · get_code("235651fd2f591868")
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

torch.manual_seed(0)

# The function bbox2points takes a bbox parameter in YOLO format
# YOLO format: (x, y, w, h) where x,y is center and w,h are width/height
# The function unpacks this tuple and performs arithmetic operations

# Create a valid bbox in YOLO format
# Using reasonable values: center at (100, 100), width=50, height=40
bbox = (100.5, 100.5, 50.0, 40.0)

ARGS = {
    "bbox": bbox
}
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 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
bbox_diou Ran
ran on a synthesized input
youchangxin/YOLOv4_tensorflow2/utils/iou.py
code served (permissive licence) · get_code("4f87eb54c22fb5be")
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

# bbox_diou expects:
# - boxes1: array-like with shape (..., 4) where last dim is [x1, y1, x2, y2]
# - boxes2: array-like with shape (..., 4) where last dim is [x1, y1, x2, y2]
# - eps: float (optional, has default)

# Create two sets of bounding boxes
# Each box is [x1, y1, x2, y2] format
boxes1 = np.array([
    [10.0, 10.0, 50.0, 50.0],
    [20.0, 20.0, 80.0, 80.0]
])

boxes2 = np.array([
    [15.0, 15.0, 55.0, 55.0],
    [30.0, 30.0, 90.0, 90.0]
])

ARGS = {
    "boxes1": boxes1,
    "boxes2": boxes2,
    "eps": 1e-07
}
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
youchangxin/YOLOv4_tensorflow2/utils/iou.py
code served (permissive licence) · get_code("74b6a6cd26ba9812")
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
import numpy as np

# Set seed for reproducibility
tf.random.set_seed(0)

# Create small bounding boxes in center-width-height format
# Shape: (2, 4) where each box is [center_x, center_y, width, height]
boxes1 = tf.constant([
    [10.0, 10.0, 4.0, 6.0],
    [20.0, 20.0, 8.0, 10.0]
], dtype=tf.float32)

boxes2 = tf.constant([
    [11.0, 11.0, 4.0, 6.0],
    [21.0, 21.0, 8.0, 10.0]
], dtype=tf.float32)

eps = 1e-07

ARGS = {
    "boxes1": boxes1,
    "boxes2": boxes2,
    "eps": eps
}
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 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
youchangxin/YOLOv4_tensorflow2/utils/iou.py
code served (permissive licence) · get_code("cbe6ee131a66ebda")
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 numpy as np
import tensorflow as tf

# The function expects two arguments: boxes1 and boxes2
# These should be array-like objects representing bounding boxes
# Format: [center_x, center_y, width, height] for each box
# We'll create small numpy arrays with 2 boxes each

boxes1 = np.array([
    [10.0, 10.0, 4.0, 6.0],  # box 1: center at (10,10), width=4, height=6
    [20.0, 20.0, 8.0, 8.0]   # box 2: center at (20,20), width=8, height=8
], dtype=np.float32)

boxes2 = np.array([
    [11.0, 11.0, 5.0, 5.0],  # box 1: center at (11,11), width=5, height=5
    [25.0, 25.0, 6.0, 6.0]   # box 2: center at (25,25), width=6, height=6
], dtype=np.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
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 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
box_area Ran
ran, honoured the contract we drafted
jason-hu7/PyTorch-YOLOv4/src/yolov4/bbox_ops.py
code served (permissive licence) · get_code("2e8f013294f43ab6")
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 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 torch

torch.manual_seed(0)

# Create a tensor of bounding boxes in (x1, y1, x2, y2) format
# Shape: [N, 4] where N=2 boxes
boxes = torch.tensor([
    [10.0, 20.0, 50.0, 80.0],  # box 1: width=40, height=60, area=2400
    [5.0, 15.0, 35.0, 55.0]     # box 2: width=30, height=40, area=1200
], dtype=torch.float32)

ARGS = {
    "boxes": boxes
}
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 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
box_diou Ran
ran on a synthesized input
Gavino7/YOLOv3set/yolo2/loss.py
code served (permissive licence) · get_code("f1144ff6c0ba5dcd")
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 5, dtype family float, shape (2, 3, 4, 2, 1) 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 tensors with shape (batch, feat_w, feat_h, anchor_num, 4)
batch_size = 2
feat_w = 3
feat_h = 4
anchor_num = 2

# Ground truth boxes: xywh format
b_true = tf.constant(
    np.random.rand(batch_size, feat_w, feat_h, anchor_num, 4).astype(np.float32) * 10 + 1,
    dtype=tf.float32
)

# Predicted boxes: xywh format
b_pred = tf.constant(
    np.random.rand(batch_size, feat_w, feat_h, anchor_num, 4).astype(np.float32) * 10 + 1,
    dtype=tf.float32
)

ARGS = {
    "b_true": b_true,
    "b_pred": b_pred,
    "use_ciou": 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 5, dtype family float, shape (2, 3, 4, 2, 1) — shape (2, 3, 4, 2, 1) 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
box_giou Ran
ran on a synthesized input
Gavino7/YOLOv3set/yolo2/loss.py
code served (permissive licence) · get_code("ae7bb59e3e00b67f")
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 5, dtype family float, shape (2, 3, 4, 2, 1) 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

# Set seeds for reproducibility
np.random.seed(0)
tf.random.set_seed(0)

# Create small tensors with shape (batch, feat_w, feat_h, anchor_num, 4)
# Using distinct dimensions: batch=2, feat_w=3, feat_h=4, anchor_num=2, coords=4 (xywh)
batch_size = 2
feat_w = 3
feat_h = 4
anchor_num = 2
coord_dim = 4

# Ground truth boxes: random xywh coordinates
# x, y in range [0, 100], w, h in range [10, 50]
b_true_data = np.random.uniform(0, 100, (batch_size, feat_w, feat_h, anchor_num, 2)).astype(np.float32)
b_true_wh = np.random.uniform(10, 50, (batch_size, feat_w, feat_h, anchor_num, 2)).astype(np.float32)
b_true = np.concatenate([b_true_data, b_true_wh], axis=-1)
b_true = tf.constant(b_true, dtype=tf.float32)

# Predicted boxes: similar distribution but slightly perturbed
b_pred_data = np.random.uniform(0, 100, (batch_size, feat_w, feat_h, anchor_num, 2)).astype(np.float32)
b_pred_wh = np.random.uniform(10, 50, (batch_size, feat_w, feat_h, anchor_num, 2)).astype(np.float32)
b_pred = np.concatenate([b_pred_data, b_pred_wh], axis=-1)
b_pred = tf.constant(b_pred, dtype=tf.float32)

ARGS = {
    "b_true": b_true,
    "b_pred": b_pred,
}
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 5, dtype family float, shape (2, 3, 4, 2, 1) — shape (2, 3, 4, 2, 1) 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
box_iou Ran
ran on a synthesized input
Gavino7/YOLOv3set/yolo3/loss.py
code served (permissive licence) · get_code("a432a967aa4de172")
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 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 tensorflow as tf
import numpy as np

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

# Create small test tensors with shape (i1,...,iN, 4) for b1 and (j, 4) for b2
# Using xywh format (x, y, width, height)

# b1: shape (2, 3, 4) - batch of 2, with 3 boxes each, 4 coordinates (xywh)
b1_data = np.array([
    [[10.0, 20.0, 4.0, 6.0], [30.0, 40.0, 8.0, 10.0], [50.0, 60.0, 5.0, 5.0]],
    [[15.0, 25.0, 6.0, 8.0], [35.0, 45.0, 10.0, 12.0], [55.0, 65.0, 7.0, 7.0]]
], dtype=np.float32)
b1 = tf.constant(b1_data)

# b2: shape (5, 4) - 5 boxes, 4 coordinates (xywh)
b2_data = np.array([
    [10.0, 20.0, 4.0, 6.0],
    [11.0, 21.0, 4.0, 6.0],
    [30.0, 40.0, 8.0, 10.0],
    [100.0, 100.0, 2.0, 2.0],
    [50.0, 60.0, 5.0, 5.0]
], dtype=np.float32)
b2 = tf.constant(b2_data)

ARGS = {
    "b1": b1,
    "b2": b2
}
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 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
box_wh_iou Ran
ran on a synthesized input
jason-hu7/PyTorch-YOLOv4/src/yolov4/bbox_ops.py
code served (permissive licence) · get_code("3cb91fcd1be7e15a")
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 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 torch

torch.manual_seed(0)

# wh1 should be a tensor with shape [2] containing width and height
wh1 = torch.tensor([3.0, 4.0])

# wh2 should be a tensor with shape [2, 2] so that when transposed it becomes [2, 2]
# This allows broadcasting with wh1
wh2 = torch.tensor([[2.0, 5.0], [3.5, 2.5]])

ARGS = {
    "wh1": wh1,
    "wh2": wh2,
}
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 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
build_targets Ran
ran on a synthesized input
Lornatang/YOLOv4-PyTorch/yolov4_pytorch/utils/loss.py
code served (permissive licence) · get_code("d08e9c30a7dd2bb9")
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 torch
import torch.nn as nn

torch.manual_seed(0)

# Build a minimal detector module
class DetectionHead(nn.Module):
    def __init__(self):
        super().__init__()
        self.na = 3  # number of anchors
        self.nl = 2  # number of layers
        # Anchors for each layer
        self.anchors = [
            torch.tensor([[10., 13.], [16., 30.], [33., 23.]], dtype=torch.float32),
            torch.tensor([[30., 61.], [62., 45.], [59., 119.]], dtype=torch.float32),
        ]

class MinimalModel(nn.Module):
    def __init__(self):
        super().__init__()
        self.model = nn.ModuleList([
            nn.Conv2d(3, 64, 3),
            DetectionHead()
        ])
        self.hyper_parameters = {
            'anchor_t': 4.0
        }

# Create model
model = MinimalModel()

# Create predictions for two detection layers
# p[i] shape should be [batch, na*5, height, width] or similar
# The function accesses p[i].shape[[3, 2, 3, 2]] which expects at least 4 dimensions
p = [
    torch.randn(2, 3, 8, 8),   # batch=2, na=3, height=8, width=8
    torch.randn(2, 3, 4, 4),   # batch=2, na=3, height=4, width=4
]

# Create targets tensor
# Shape: [num_targets, 6] where columns are [batch_idx, class, x, y, w, h]
# All coordinates normalized to [0, 1]
targets = torch.tensor([
    [0, 1, 0.3, 0.4, 0.2, 0.15],
    [0, 2, 0.7, 0.6, 0.25, 0.2],
    [1, 0, 0.5, 0.5, 0.1, 0.1],
], dtype=torch.float32)

ARGS = {
    'p': p,
    'targets': targets,
    '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 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
c_array Ran
ran; our contract draft was wrong, not the code
Dodant/ANPR-with-Yolov4/darknet.py
pointer only (licence: MIT); 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 link allows the body inline (MIT), but get_code serves the stored copy, first harvested from caihaocong/Yolov3_AlexeyAB_Version, 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.

cas_iou Ran
ran on a synthesized input
bubbliiiing/yolov4-pytorch/kmeans_for_anchors.py
code served (permissive licence) · get_code("364d90eb3c67abdf")
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 (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

# Analyze the function:
# - box: used with indexing box[0] and box[1], appears to be a 1D array-like with at least 2 elements
# - cluster: used with indexing cluster[:, 0] and cluster[:, 1], appears to be a 2D array with shape (n, 2+)
# The function computes IoU (Intersection over Union) for bounding boxes
# box represents a single box with [width, height]
# cluster represents multiple boxes with shape (num_boxes, 2) where each row is [width, height]

# Create valid arguments
box = np.array([10.0, 8.0])  # Single box with width=10, height=8

cluster = np.array([
    [5.0, 4.0],   # First cluster box
    [12.0, 6.0],  # Second cluster box
    [8.0, 9.0],   # Third cluster box
])

ARGS = {
    "box": box,
    "cluster": cluster
}
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 (3,) — shape (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
change_box_order Ran
ran on a synthesized input
jason-hu7/PyTorch-YOLOv4/src/yolov4/bbox_ops.py
code served (permissive licence) · get_code("d483eb180e196c10")
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 and 4 represents [xmin, ymin, xmax, ymax]
boxes = torch.tensor([
    [10.0, 20.0, 50.0, 80.0],
    [15.0, 25.0, 60.0, 90.0]
])

ARGS = {
    'boxes': boxes,
    'order': 'xyxy2xywh'
}
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
check_batch_shape Ran
ran on a synthesized input
ruyueshuo/DeepStream_YOLOv4/darknet_images.py
code served (permissive licence) · get_code("b4b83dd7260c4010")
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 Size. 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 numpy as np

torch.manual_seed(0)

# Create a list of images with the same shape
# Images are represented as tensors with shape (channels, height, width)
image1 = torch.randn(3, 4, 5)
image2 = torch.randn(3, 4, 5)
images = [image1, image2]

batch_size = 2

ARGS = {
    "images": images,
    "batch_size": batch_size
}
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 Size — a Size output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a Size output the recorded ndim 1 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
check_img_size Ran
ran on a synthesized input
GuoQuanhao/YOLOv4-Paddle/utils/general.py
code served (permissive licence) · get_code("34e57d21351373bb")
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 math

def make_divisible(x, divisor):
    return math.ceil(x / divisor) * divisor

def check_img_size(img_size, s=32):
    new_size = make_divisible(img_size, int(s))
    return new_size

# Setup code
ARGS = {
    "img_size": 640,
    "s": 32
}
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 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
color_map Ran
ran on a synthesized input
OwlTing/AI_basketball_games_video_editor/video_editor.py
code served (permissive licence) · get_code("4df5f69834a3535a")
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

torch.manual_seed(0)

ARGS = {
    "index": 5
}
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 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
compute_ap Ran
ran on a synthesized input
jason-hu7/PyTorch-YOLOv4/src/yolov4/evaluate.py
code served (permissive licence) · get_code("2fa13d4d71fd9934")
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 float64, ndim 0, 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

# Construct valid arguments for compute_ap
recall = [0.1, 0.3, 0.5, 0.7, 0.9]
precision = [0.95, 0.85, 0.75, 0.65, 0.55]

ARGS = {
    "recall": recall,
    "precision": precision,
}
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 float64, ndim 0, dtype family float — no output shape is stated: observe_signature.py recorded float ndim 0, which disagrees with the fixture run
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
compute_color_for_labels Ran
ran, honoured the contract we drafted
JisuHann/MEME-Tracking/deep_sort_pytorch/utils/draw.py
pointer only (licence: MIT); the stored copy get_code serves, from mikel-brostrom/Yolov3_DeepSort_Pytorch, is pointer only (licence: NONE) · get_code("bcfa4cf98c4b792a")
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 mikel-brostrom/Yolov3_DeepSort_Pytorch, 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.

compute_iou Ran
ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT)
HeegonJin/yolov1/yolov1.py
pointer only (licence: NONE) · get_code("8773def2c6ac88dd")
How it ran

The body of this sample is withheld: GitHub detected no licence in this paper's repository, HeegonJin/yolov1 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.

conv2d Ran
ran; our contract draft was wrong, not the code
bubbliiiing/yolov4-pytorch/nets/yolo.py
code served (permissive licence) · get_code("e360ecbff4906503")
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 Sequential. 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
from collections import OrderedDict

torch.manual_seed(0)

ARGS = {
    'filter_in': 3,
    'filter_out': 16,
    'kernel_size': 3,
    'stride': 1
}
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 Sequential — a Sequential output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a Sequential 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
convert Ran
ran on a synthesized input
rechardchen123/YOLOv4_traffic_sign_detection/genfiles.py
code served (permissive licence) · get_code("04bbdadb21f8b94d")
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

torch.manual_seed(0)

# Analyze the function:
# - size: indexed with [0] and [1], so it's a sequence with at least 2 elements
# - box: indexed with [0], [1], [2], [3], so it's a sequence with at least 4 elements
# - Both are used in arithmetic operations, so they should contain numbers

# size represents image dimensions (width, height)
size = (640, 480)

# box represents bounding box coordinates [x_min, x_max, y_min, y_max]
box = (100.0, 200.0, 150.0, 300.0)

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

torch.manual_seed(0)

ARGS = {
    "x": 100,
    "y": 200,
    "w": 50,
    "h": 75
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type tuple, ndim 1, dtype family 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
convert_cat_id_and_reorientate_bbox Ran
ran on a synthesized input
OwlTing/AI_basketball_games_video_editor/pytorch_YOLOv4/evaluate_on_coco.py
code served (permissive licence) · get_code("8feef70f588e82ac")
How it ran

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

import torch
import numpy as np

# Define a sample annotation dictionary with the required fields
single_annotation = {
    'category_id': 5,  # Test with a category in the 0-10 range
    'bbox': [100.0, 200.0, 50.0, 75.0]  # [x, y, w, h] format
}

ARGS = {
    'single_annotation': single_annotation
}
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 dict — a dict output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a dict output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not stated
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
copy_yolo_files Ran
ran on a synthesized input
sushmaakoju/yolo/src/yolohelper.py
code served (permissive licence) · get_code("6933283fbb3262f0")
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 bool, 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 os
import tempfile
import shutil

# Create a temporary directory structure for testing
temp_dir = tempfile.mkdtemp()
dest_dir = tempfile.mkdtemp()

# Create source files in a temporary location
source_dir = tempfile.mkdtemp()
source_files = []
for i in range(3):
    file_path = os.path.join(source_dir, f"file_{i}.txt")
    with open(file_path, 'w') as f:
        f.write(f"test content {i}")
    source_files.append(file_path)

# Ensure destination directory exists
if not os.path.exists(dest_dir):
    os.makedirs(dest_dir)

ARGS = {
    "sourcedir_datafiles": source_files,
    "destination_path": dest_dir,
}
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 bool, 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
correct_pad Ran
ran; our contract draft was wrong, not the code
Gavino7/YOLOv3set/common/backbones/efficientnet.py
code served (permissive licence) · get_code("372c139f6aad1ede")
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 2, 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

# Create a minimal backend class that mimics Keras backend behavior
class MockBackend:
    def __init__(self, data_format='channels_last'):
        self._data_format = data_format
    
    def image_data_format(self):
        return self._data_format
    
    def int_shape(self, inputs):
        # Return the shape of the input tensor
        if isinstance(inputs, torch.Tensor):
            return tuple(inputs.shape)
        return inputs.shape

# Create a mock backend instance
backend = MockBackend(data_format='channels_last')

# Create a small input tensor with shape (batch, height, width, channels)
# Using channels_last format: batch=2, height=4, width=3, channels=5
torch.manual_seed(0)
inputs = torch.randn(2, 4, 3, 5)

# kernel_size can be an integer or tuple
kernel_size = 3

ARGS = {
    'backend': backend,
    'inputs': inputs,
    'kernel_size': kernel_size
}
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 2, 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
cvDrawBoxes Ran
ran on a synthesized input
Dodant/ANPR-with-Yolov4/darknet_video.py
code served (permissive licence) · get_code("0c143d1141be03d4")
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 cv2
import numpy as np

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

# Create detections list with format expected by cvDrawBoxes
# Each detection is a tuple/list: (class_name_bytes, confidence, bbox)
# where bbox = (x_center, y_center, width, height)
detections = [
    (b'person', 0.95, (75, 50, 40, 60)),
    (b'car', 0.87, (100, 30, 50, 35)),
]

ARGS = {
    'detections': detections,
    'img': img,
}
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
cvtColor Ran
ran on a synthesized input
bubbliiiing/yolov4-pytorch/utils/utils.py
code served (permissive licence) · get_code("4cbceadc5b5bb315")
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.

import numpy as np
from PIL import Image

# Create a small test image using PIL
pil_image = Image.new('L', (4, 3))  # Grayscale image (not RGB)

ARGS = {
    'image': pil_image
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
PIL, numpy — 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
darknet53 Ran
ran on a synthesized input
bubbliiiing/yolov4-pytorch/nets/CSPdarknet.py
code served (permissive licence) · get_code("81eb9513d26497e9")
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 CSPDarkNet. 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 math

torch.manual_seed(0)

ARGS = {
    'pretrained': False
}
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 CSPDarkNet — a CSPDarkNet output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a CSPDarkNet 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
data_preprocess Ran
ran on a synthesized input
xiuyu0000/tutorials/resnet/predict.py
code served (permissive licence) · get_code("5dd08b3fc0867021")
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, 224, 224) 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 cv2
import numpy as np
import tempfile
import os

# Create a temporary image file for testing
temp_dir = tempfile.mkdtemp()
img_array = np.random.randint(0, 256, (256, 256, 3), dtype=np.uint8)
img_path = os.path.join(temp_dir, "test_image.jpg")
cv2.imwrite(img_path, img_array)

ARGS = {
    "img_path": img_path
}
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 float, shape (3, 224, 224) — shape (3, 224, 224) 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
detect_shot Ran
ran on a synthesized input
OwlTing/AI_basketball_games_video_editor/tool/utils_basketball.py
code served (permissive licence) · get_code("a5f6e666692809fd")
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 pandas as pd
import numpy as np

# Create sample dataframes for basketball detections
basketball_data = {
    'frame_index': [0, 1, 2, 3, 4],
    'box_x1': [100.0, 110.0, 120.0, 130.0, 140.0],
    'box_y1': [50.0, 60.0, 70.0, 80.0, 90.0],
    'box_x2': [150.0, 160.0, 170.0, 180.0, 190.0],
    'box_y2': [100.0, 110.0, 120.0, 130.0, 140.0],
}
df_obj_log_basketball = pd.DataFrame(basketball_data)

# Create sample dataframes for basketball hoop detections
hoop_data = {
    'frame_index': [0, 1, 2, 3, 4],
    'box_x1': [105.0, 115.0, 125.0, 135.0, 145.0],
    'box_y1': [55.0, 65.0, 75.0, 85.0, 95.0],
    'box_x2': [145.0, 155.0, 165.0, 175.0, 185.0],
    'box_y2': [95.0, 105.0, 115.0, 125.0, 135.0],
    'obj_box_id': [1, 2, 3, 4, 5],
}
df_obj_log_basketball_hoop = pd.DataFrame(hoop_data)

ARGS = {
    'df_obj_log_basketball': df_obj_log_basketball,
    'df_obj_log_basketball_hoop': df_obj_log_basketball_hoop,
    'search_frame_range': 2,
    'search_mode': 'full',
    'scale': 0.5,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy, pandas — 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
detection_loss_4_yolo Ran
ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT)
HeegonJin/yolov1/yolov1.py
pointer only (licence: NONE) · get_code("0c45c50019378016")
How it ran

The body of this sample is withheld: GitHub detected no licence in this paper's repository, HeegonJin/yolov1 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.

down2xlabel Ran
ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT)
samson6460/tf2_YOLO/utils/tools.py
pointer only (licence: NONE) · get_code("1c89045660fcfc14")
How it ran

The body of this sample is withheld: GitHub detected no licence in this paper's repository, samson6460/tf2_YOLO 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.

draw_boxes Ran
ran; our contract draft was wrong, not the code
JisuHann/MEME-Tracking/deep_sort_pytorch/utils/draw.py
code served (permissive licence) · get_code("bb6bb0009b53e1ba")
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 (480, 640, 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 cv2
import numpy as np

# Create a small test image
img = np.zeros((480, 640, 3), dtype=np.uint8)

# Create bounding boxes in format [x1, y1, x2, y2]
# Using 4 boxes with distinct coordinates
bbox = np.array([
    [10, 20, 100, 150],
    [200, 100, 350, 250],
    [400, 50, 550, 180],
    [50, 300, 200, 400]
], dtype=np.float32)

# Create identity labels for each box
identities = np.array([1, 2, 5, 10], dtype=np.int32)

# Define offset
offset = (0, 0)

ARGS = {
    "img": img,
    "bbox": bbox,
    "identities": identities,
    "offset": offset
}
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 (480, 640, 3) — shape (480, 640, 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
dump_value Ran
ran; our contract draft was wrong, not the code
nemonameless/PaddleDetection_YOLOX/ppdet/core/workspace.py
code served (permissive licence) · get_code("891281774f8942bd")
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 torch
import yaml

torch.manual_seed(0)

# The function takes a single parameter 'value' and processes it
# It checks if value has __dict__, or is a dict, tuple, or list
# Then it yaml.dump's it and does string processing
# So we need to test with various types of values

ARGS = {
    'value': {
        'key1': 'test_string',
        'key2': 42,
        'nested': {'inner': [1, 2, 3]},
        'tuple_field': (1, 2, 3),
        'list_field': [4, 5, 6]
    }
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
torch, yaml — 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
exif_size Ran
ran, honoured the contract we drafted
GuoQuanhao/YOLOv4-Paddle/utils/datasets.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.

expand_bbox Ran
ran on a synthesized input
nemonameless/PaddleDetection_YOLOX/ppdet/modeling/bbox_utils.py
code served (permissive licence) · get_code("c434ee22884ca564")
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 (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 numpy as np

# Create a small array of bounding boxes in format [x1, y1, x2, y2]
# Using 2 bboxes as a minimal batch
bboxes = np.array([
    [10.0, 20.0, 50.0, 80.0],
    [100.0, 150.0, 200.0, 250.0]
], dtype=np.float32)

scale = 1.5

ARGS = {
    "bboxes": bboxes,
    "scale": scale
}
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 (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
find_end Ran
ran on a synthesized input
UtkarshKharche29/Automatic-Number-Plate-Recognition/stage2/segment.py
code served (permissive licence) · get_code("91804129cdaf6a22")
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.

# Setup code for find_end function

# The function uses global variables that need to be set up
segmentation_spacing = 0.79
start = 1
end = 2
black = [0.1, 0.2, 0.9, 0.5, 0.3, 0.15, 0.8]  # List of values to search through
black_max = 1.0  # Maximum value in black list
width = len(black)  # Width should be at least as long as the black list

# Define arguments for find_end function
ARGS = {
    "start": 1
}
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 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
find_image_size Ran
ran on a synthesized input
rechardchen123/YOLOv4_traffic_sign_detection/data_transfer/tt100k_to_voc_train.py
code served (permissive licence) · get_code("fce8f344ac3d616d")
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.

from PIL import Image
import tempfile
import os

# Create a temporary RGB image file
with tempfile.TemporaryDirectory() as tmpdir:
    img_path = os.path.join(tmpdir, "test_image.png")
    
    # Create a small RGB image (4x3 pixels)
    img = Image.new('RGB', (4, 3), color=(255, 0, 0))
    img.save(img_path)
    
    # Store the path for ARGS
    temp_img_path = img_path
    
    # Create ARGS with the temporary image path
    ARGS = {
        'filename': temp_img_path
    }

# Note: Since we're in a temporary directory context, we need to recreate the image
# outside the context for the function to use it
import tempfile
import os
from PIL import Image

tmpdir = tempfile.mkdtemp()
img_path = os.path.join(tmpdir, "test_image.png")
img = Image.new('RGB', (4, 3), color=(255, 0, 0))
img.save(img_path)

ARGS = {
    'filename': img_path
}
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 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
find_number Ran
ran on a synthesized input
Dodant/ANPR-with-Yolov4/OCR/ocr.py
code served (permissive licence) · get_code("5c6b536192570557")
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 numpy as np

# Global variable that the function uses
pos_cnt = []

# Create sample contour data
# Each contour is a dict with keys: idx, cx, cy, w, h
contour_list = [
    {
        'idx': 0,
        'cx': 10.0,
        'cy': 20.0,
        'w': 5.0,
        'h': 8.0
    },
    {
        'idx': 1,
        'cx': 12.0,
        'cy': 21.0,
        'w': 5.2,
        'h': 8.1
    },
    {
        'idx': 2,
        'cx': 11.0,
        'cy': 20.5,
        'w': 5.1,
        'h': 7.9
    },
    {
        'idx': 3,
        'cx': 50.0,
        'cy': 60.0,
        'w': 10.0,
        'h': 15.0
    },
    {
        'idx': 4,
        'cx': 100.0,
        'cy': 120.0,
        'w': 3.0,
        'h': 4.0
    }
]

# Initialize pos_cnt with dummy data (numpy array of contours)
pos_cnt = np.array([
    {'idx': 0, 'cx': 10.0, 'cy': 20.0, 'w': 5.0, 'h': 8.0},
    {'idx': 1, 'cx': 12.0, 'cy': 21.0, 'w': 5.2, 'h': 8.1},
    {'idx': 2, 'cx': 11.0, 'cy': 20.5, 'w': 5.1, 'h': 7.9},
    {'idx': 3, 'cx': 50.0, 'cy': 60.0, 'w': 10.0, 'h': 15.0},
    {'idx': 4, 'cx': 100.0, 'cy': 120.0, 'w': 3.0, 'h': 4.0}
])

ARGS = {
    'contour_list': contour_list
}
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 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
fuse_conv_and_bn Ran
ran on a synthesized input
Lornatang/YOLOv4-PyTorch/yolov4_pytorch/model/fuse.py
code served (permissive licence) · get_code("08c9d24c9a0af764")
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
import torch.nn as nn

torch.manual_seed(0)

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

# Create a BatchNorm2d layer with matching output channels
bn = nn.BatchNorm2d(num_features=16)

# Initialize BatchNorm parameters with some values
bn.weight.data.fill_(1.0)
bn.bias.data.fill_(0.0)
bn.running_mean.data.fill_(0.1)
bn.running_var.data.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
gdrive_download Ran
ran on a synthesized input
GuoQuanhao/YOLOv4-Paddle/utils/google_utils.py
code served (permissive licence) · get_code("d60fe5b5099859c9")
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 os
import platform
import time

ARGS = {
    'id': '1n_oKgR81BJtqk75b00eAjdv03qVCQn2f',
    'name': 'test_file.zip'
}
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 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_affine_mat_kernel Ran
ran; our contract draft was wrong, not the code
nemonameless/PaddleDetection_YOLOX/ppdet/modeling/keypoint_utils.py
code served (permissive licence) · get_code("e9ea8d6169dd3c5a")
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
import cv2

# Define ARGS dictionary for get_affine_mat_kernel
ARGS = {
    'h': 256,
    'w': 192,
    's': 256,
    'inv': False,
}
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
get_affine_transform Ran
ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT)
nemonameless/PaddleDetection_YOLOX/ppdet/modeling/keypoint_utils.py
code served (permissive licence) · get_code("2fc1e1b3d4511e08")
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 (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 cv2
import numpy as np

ARGS = {
    'center': np.array([100.0, 100.0], dtype=np.float32),
    'input_size': np.array([200.0, 200.0], dtype=np.float32),
    'rot': 0.0,
    'output_size': np.array([64.0, 64.0], dtype=np.float32),
    'shift': (0.0, 0.0),
    'inv': False
}
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 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
get_anchors Ran
ran on a synthesized input
michhar/azureml-keras-yolov3-custom/project/train_azureml.py
code served (permissive licence) · get_code("ce2b160dd57455ac")
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 tempfile
import os
import numpy as np

# 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
anchor_data = "0.5,0.6,0.7,0.8,0.9,1.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 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_bboxes Ran
ran on a synthesized input
michhar/azureml-keras-yolov3-custom/augmentation.py
code served (permissive licence) · get_code("6e65e80a8be4e9a1")
How it ran

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

import tempfile
import os

# Create a temporary annotation file with sample data
temp_dir = tempfile.mkdtemp()
annot_file = os.path.join(temp_dir, "annotations.txt")

# Write sample annotation data
with open(annot_file, 'w') as f:
    f.write("image1.jpg 10 20 100 120 50 60 150 160\n")
    f.write("image2.jpg 5 15 95 110\n")
    f.write("image3.jpg 30 40 200 220 70 80 170 180 110 120 210 230\n")

ARGS = {
    "annot_file": annot_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 dict — a dict output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a dict output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not stated
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
get_classes Ran
ran on a synthesized input
bubbliiiing/yolov4-pytorch/utils/utils.py
code served (permissive licence) · get_code("25609cd2d07a364b")
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 tempfile
import os

# Create a temporary file with class names
temp_file = tempfile.NamedTemporaryFile(mode='w', delete=False, encoding='utf-8', suffix='.txt')
temp_file.write("class_one\n")
temp_file.write("class_two\n")
temp_file.write("class_three\n")
temp_file.close()

classes_path = temp_file.name

ARGS = {
    "classes_path": classes_path
}
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 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_classes Ran
ran on a synthesized input
michhar/azureml-keras-yolov3-custom/project/train_azureml.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_file_name_and_ext Ran
ran on a synthesized input
sushmaakoju/yolo/src/yolo_plots.py
code served (permissive licence) · get_code("649fd3af2414b853")
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 os

def get_file_name_and_ext(filename):
    file_path, temp_filename = os.path.split(filename)
    file_name, file_ext = os.path.splitext(temp_filename)
    return (file_name, file_ext)

ARGS = {
    "filename": "/path/to/document.txt"
}
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 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_hash Ran
ran, honoured the contract we drafted
GuoQuanhao/YOLOv4-Paddle/utils/datasets.py
pointer only (licence: MIT); the stored copy get_code serves, from serkansulun/video-emotion, is pointer only (licence: NOASSERTION) · get_code("94786637156cb923")
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.

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

Also present in other papers' code

Of 184 samples lifted from this paper's linked repositories, 184 carry a function identity and 0 do not. Of the 182 distinct functions with an identity, 67 are also present in other papers whose code we hold (48 with at least one paper dated earlier, 10 the same month, 43 later) and 115 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
identity 69 other papers
13 dated earlier, 56 later · 5 only as an assembly brick
1706.07296 (2017-06)
A Minimal Developmental Model Can Increase Evolvability in Soft Robots
1802.09419 (2018-02)
Stochastic Hyperparameter Optimization through Hypernetworks
1804.06055 (2018-04)
Co-occurrence Feature Learning from Skeleton Data for Action Recognition and Detection with Hierarchical Aggregation
and 66 more not named here
merge 28 other papers
18 dated earlier, 1 the same month, 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 25 more not named here
autopad 23 other papers
4 dated earlier, 19 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
1804.02767 (2018-04)
YOLOv3: An Incremental Improvement
and 20 more not named here
parse_cli_to_yaml 20 other papers
13 dated earlier, 1 the same month, 6 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
11 dated earlier, 1 the same month, 3 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
autopad 12 other papers
2 dated earlier, 10 later · 2 only as an assembly brick
1512.03385 (2015-12)
Deep Residual Learning for Image Recognition
1611.02644 (2016-11)
Multispectral Deep Neural Networks for Pedestrian Detection
2308.11918 (2023-08)
AMSP-UOD: When Vortex Convolution and Stochastic Perturbation Meet Underwater Object Detection
and 9 more not named here
linear_warmup_lr 8 other papers
5 dated earlier, 3 later
1611.06612 (2016-11)
RefineNet: Multi-Path Refinement Networks for High-Resolution Semantic Segmentation
1811.12814 (2018-11)
Graph-Based Global Reasoning Networks
1907.03222 (2019-07)
IRNet: A General Purpose Deep Residual Regression Framework for Materials Discovery
and 5 more not named here
DWConv 6 other papers
1 dated earlier, 5 later
1703.07402 (2017-03)
Simple Online and Realtime Tracking with a Deep Association Metric
2206.14651 (2022-06)
BoT-SORT: Robust Associations Multi-Pedestrian Tracking
2207.02696 (2022-07)
YOLOv7: Trainable bag-of-freebies sets new state-of-the-art for real-time object detectors
and 3 more not named here
load_classes 6 other papers
2 dated earlier, 4 later
1804.02767 (2018-04)
YOLOv3: An Incremental Improvement
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
and 3 more not named here
unique_config_sections 5 other papers
5 dated earlier
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
4 dated earlier
1609.04836 (2016-09)
On Large-Batch Training for Deep Learning: Generalization Gap and Sharp Minima
1612.08242 (2016-12)
YOLO9000: Better, Faster, Stronger
1804.02767 (2018-04)
YOLOv3: An Incremental Improvement
and 1 more not named here
dump_value 4 other papers
1 dated earlier, 3 later
1912.06218 (2019-12)
YOLACT++: Better Real-time Instance Segmentation
2304.08069 (2023-04)
DETRs Beat YOLOs on Real-time Object Detection
2308.07313 (2023-08)
Group Pose: A Simple Baseline for End-to-End Multi-person Pose Estimation
and 1 more not named here
expand_bbox 4 other papers
2 dated earlier, 2 later
1911.06644 (2019-11)
You Only Watch Once: A Unified CNN Architecture for Real-Time Spatiotemporal Action Localization
1911.07559 (2019-11)
FFA-Net: Feature Fusion Attention Network for Single Image Dehazing
2106.13230 (2021-06)
Video Swin Transformer
and 1 more not named here
make_divisible 4 other papers
1 dated earlier, 1 the same month, 2 later
1804.02767 (2018-04)
YOLOv3: An Incremental Improvement
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
make_layers 4 other papers
2 dated earlier, 2 later
1703.07402 (2017-03)
Simple Online and Realtime Tracking with a Deep Association Metric
1904.07850 (2019-04)
Objects as Points
2110.06864 (2021-10)
ByteTrack: Multi-Object Tracking by Associating Every Detection Box
and 1 more not named here
read_mot_results 4 other papers
1 dated earlier, 1 the same month, 2 later
1909.12605 (2019-09)
Towards Real-Time Multi-Object Tracking
2004.01888 (2020-04)
FairMOT: On the Fairness of Detection and Re-Identification in Multiple Object Tracking
2010.12138 (2020-10)
Rethinking the competition between detection and ReID in Multi-Object Tracking
and 1 more not named here
read_results 4 other papers
1 dated earlier, 1 the same month, 2 later
1909.12605 (2019-09)
Towards Real-Time Multi-Object Tracking
2004.01888 (2020-04)
FairMOT: On the Fairness of Detection and Re-Identification in Multiple Object Tracking
2010.12138 (2020-10)
Rethinking the competition between detection and ReID in Multi-Object Tracking
and 1 more not named here
sample 4 other papers
4 dated earlier
1609.04836 (2016-09)
On Large-Batch Training for Deep Learning: Generalization Gap and Sharp Minima
1612.08242 (2016-12)
YOLO9000: Better, Faster, Stronger
1804.02767 (2018-04)
YOLOv3: An Incremental Improvement
and 1 more not named here
unzip_objs 4 other papers
1 dated earlier, 1 the same month, 2 later
1909.12605 (2019-09)
Towards Real-Time Multi-Object Tracking
2004.01888 (2020-04)
FairMOT: On the Fairness of Detection and Re-Identification in Multiple Object Tracking
2010.12138 (2020-10)
Rethinking the competition between detection and ReID in Multi-Object Tracking
and 1 more not named here
box_area 3 other papers
1 dated earlier, 2 later
1506.01497 (2015-06)
Faster R-CNN: Towards Real-Time Object Detection with Region Proposal Networks
2010.04159 (2020-10)
Deformable DETR: Deformable Transformers for End-to-End Object Detection

Shown: the 20 functions present in the most other papers. 47 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-21.

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

There are a huge number of features which are said to improve Convolutional Neural Network (CNN) accuracy. Practical testing of combinations of such features on large datasets, and theoretical justification of the result, is required. Some features operate on certain models exclusively and for certain problems exclusively, or only for small-scale datasets; while some features, such as batch-normalization and residual-connections, are applicable to the majority of models, tasks, and datasets. We assume that such universal features include Weighted-Residual-Connections (WRC), Cross-Stage-Partial-connections (CSP), Cross mini-Batch Normalization (CmBN), Self-adversarial-training (SAT) and Mish-activation. We use new features: WRC, CSP, CmBN, SAT, Mish activation, Mosaic data augmentation, CmBN, DropBlock regularization, and CIoU loss, and combine some of them to achieve state-of-the-art results: 43.5% AP (65.7% AP50) for the MS COCO dataset at a realtime speed of ~65 FPS on Tesla V100. Source code is at https://github.com/AlexeyAB/darknet

For agents

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

get_harvested_code_for_paper("2004.10934")
get_code_for_paper("2004.10934")
have("2004.10934")

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

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

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

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

Connect an agent — have() is free.