SYNTOLOGY HomeExplorerAtlasCodeMethodologyAboutDevelopersFeedPricing
Paper · 2004.01888 · 2020

FairMOT: On the Fairness of Detection and Re-Identification in Multiple Object Tracking

arXiv · PDF · Open in the Atlas

Code that ran

46 of 53 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; 2 honoured the contract we drafted, 0 violated it and 31 have no contract verdict; 13 failures of our instrument; 7 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.01888.json · badge: /api/ran/2004.01888.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
nolanzzz/MTMCT community (classifier label)
classifier basis not recorded on the link
12 ran · 1 no recorded run
harsh2912/people-tracking community (classifier label)
classifier basis not recorded on the link
11 ran · 0 no recorded run
15534081591/FairMOT community (classifier label)
classifier basis not recorded on the link
6 ran · 0 no recorded run
dingwoai/FairMOT-BDD100K community (classifier label)
classifier basis not recorded on the link
4 ran · 0 no recorded run
FlorentijnD/FairMOT community (classifier label)
classifier basis not recorded on the link
3 ran · 5 no recorded run
cds-mipt/cds-tracking community (classifier label)
classifier basis not recorded on the link
3 ran · 1 no recorded run
lilin19890401/FairMOT community (classifier label)
classifier basis not recorded on the link
3 ran · 0 no recorded run
zengwbz/Face-Tracking-usingFairMOT community (classifier label)
classifier basis not recorded on the link
2 ran · 0 no recorded run
ydhcg-bobo/stcmot extension (classifier label)
classifier basis: classifier_2025
1 ran · 0 no recorded run
nemonameless/fairmot community (classifier label)
classifier basis not recorded on the link
1 ran · 0 no recorded run
FunctionStatusWhere it lives
collate_fn Ran
ran on a synthesized input
dingwoai/FairMOT-BDD100K/src/lib/datasets/dataset/bdd100k.py
code served (permissive licence) · get_code("7ca75b6abf5efc06")
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 numpy as np

torch.manual_seed(0)

# The function expects batch to be an iterable of tuples: (img, label, path, size)
# where:
# - img is a torch tensor
# - label is a numpy array with shape (num_boxes, 6)
# - path is a string
# - size is some size value

batch = [
    (
        torch.randn(3, 4, 4),  # img: 3 channels, 4x4
        np.random.randn(2, 6).astype(np.float32),  # label: 2 boxes, 6 values each
        "path/to/image1.jpg",  # path
        (4, 4)  # size
    ),
    (
        torch.randn(3, 4, 4),  # img: 3 channels, 4x4
        np.random.randn(3, 6).astype(np.float32),  # label: 3 boxes, 6 values each
        "path/to/image2.jpg",  # path
        (4, 4)  # size
    )
]

ARGS = {
    "batch": batch
}
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 — 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
compute_bin_loss Ran
ran; our contract draft was wrong, not the code
FlorentijnD/FairMOT/src/lib/models/losses.py
code served (permissive licence) · get_code("65d7a40d70c53ed9")
How it ran

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

import torch
import torch.nn as nn
import torch.nn.functional as F

torch.manual_seed(0)

# Analyze the function:
# - output: passed to F.cross_entropy, so should be (batch_size, num_classes) logits
# - target: passed to F.cross_entropy, so should be (batch_size,) with class indices
# - mask: has .expand_as(output) called on it, then .float() is called
#   mask should be broadcastable to output shape

batch_size = 2
num_classes = 4

# output: logits tensor (batch_size, num_classes)
output = torch.randn(batch_size, num_classes)

# target: class indices (batch_size,) with values in [0, num_classes)
target = torch.tensor([0, 2], dtype=torch.long)

# mask: should be broadcastable to output shape
# Can be a single value or smaller tensor that expands
mask = torch.ones(batch_size, 1)

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

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

import torch
import torch.nn.functional as F

torch.manual_seed(0)

# Create small tensors for output and target
# batch_size=2, feature_dim=4
output = torch.randn(2, 4)
target = torch.randn(2, 4)

ARGS = {
    'output': output,
    'target': target,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type Tensor, ndim 0, dtype family float, shape () — shape () as a later run recorded it
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
compute_rot_loss Ran
ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT)
FlorentijnD/FairMOT/src/lib/models/losses.py
code served (permissive licence) · get_code("8accefa95d8419ec")
How it ran

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

import torch
import torch.nn.functional as F

torch.manual_seed(0)

# Create output tensor: shape (batch_size, 8) since output.view(-1, 8) is called
output = torch.randn(2, 8)

# Create target_bin tensor: shape (batch_size, 2) since target_bin.view(-1, 2) is called
# Values should be 0 or 1 for cross_entropy classification
target_bin = torch.tensor([[1, 0], [0, 1]], dtype=torch.long)

# Create target_res tensor: shape (batch_size, 2) since target_res.view(-1, 2) is called
# These are angle values that will have sin/cos applied
target_res = torch.randn(2, 2)

# Create mask tensor: shape (batch_size, 1) since mask.view(-1, 1) is called
# Mask should be binary or float values
mask = torch.tensor([[1], [1]], dtype=torch.float32)

ARGS = {
    'output': output,
    'target_bin': target_bin,
    'target_res': target_res,
    'mask': mask
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type Tensor, ndim 0, dtype family float, shape () — shape () as a later run recorded it
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
draw_bbox Ran
ran on a synthesized input
nolanzzz/MTMCT/util.py
code served (permissive licence) · get_code("5f61628f4d5e3b95")
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, 100, 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 (100x100 RGB image)
img = np.ones((100, 100, 3), dtype=np.uint8) * 255

# Define bounding box coordinates [x1, y1, x2, y2]
box = [10, 15, 50, 60]

# Class name
cls_name = "person"

# Identity (optional, used for color indexing)
identity = 2

# Offset tuple (dx, dy)
offset = (0, 0)

ARGS = {
    "img": img,
    "box": box,
    "cls_name": cls_name,
    "identity": identity,
    "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 (100, 100, 3) — shape (100, 100, 3) as a later run recorded it
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
draw_bboxes Ran
ran on a synthesized input
nolanzzz/MTMCT/util.py
code served (permissive licence) · get_code("4656cb39277d4392")
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 simple test image (480x640 RGB)
img = np.ones((480, 640, 3), dtype=np.uint8) * 255

# Create bounding boxes as a list/array of [x1, y1, x2, y2]
bbox = [
    [50, 50, 150, 200],
    [200, 100, 350, 250],
]

# Create identities array with tracking IDs
identities = np.array([1, 5])

# Define offset
offset = (10, 20)

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
draw_ignore_regions Ran
ran on a synthesized input
cds-mipt/cds-tracking/src/gen_labels_detrac.py
code served (permissive licence) · get_code("cafc915688ec9b1e")
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 (4, 6, 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

# Create a small test image (H×W×C format, BGR or RGB)
# Using shape (4, 6, 3) for a small image with 3 channels
img = np.ones((4, 6, 3), dtype=np.uint8) * 255

# Create a list of boxes in format [left, top, width, height]
# Box 1: left=1, top=1, width=2, height=2
# Box 2: left=3, top=2, width=2, height=1
boxes = [
    [1, 1, 2, 2],
    [3, 2, 2, 1]
]

ARGS = {
    'img': img,
    'boxes': boxes
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type ndarray, ndim 3, dtype family int, shape (4, 6, 3) — shape (4, 6, 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
float3 Ran
ran on a synthesized input
harsh2912/people-tracking/src/lib/tracking_utils/utils.py
code served (permissive licence) · get_code("71977bd2dff971d7")
How it ran

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

import torch

def float3(x):
    return float(format(x, '.3f'))

torch.manual_seed(0)

# x can be any numeric type that format() accepts
x = 3.14159265359

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

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

import torch
import numpy as np

torch.manual_seed(0)

# Create a sample dets_dict
# The dict has keys (e.g., frame IDs or class names) and values are lists of detections
# Each detection is [x1, y1, x2, y2, score, cls_id]
dets_dict = {
    'frame_0': [
        [10.0, 20.0, 50.0, 80.0, 0.95, 1.0],  # x1, y1, x2, y2, score, cls_id
        [100.0, 150.0, 200.0, 250.0, 0.87, 2.0]
    ],
    'frame_1': [
        [30.0, 40.0, 90.0, 120.0, 0.92, 1.0]
    ]
}

# Image dimensions
w = 640
h = 480

ARGS = {
    'dets_dict': dets_dict,
    'w': w,
    'h': h
}
Setup block drafted by
a language model, Claude Sonnet 4.5, prompt python_fixture_v1
Imports
numpy, torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type list, ndim 2, dtype family float — a list output has no array shape of its own; none is stated
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
get_camera_perspective Ran
ran on a synthesized input
cds-mipt/cds-tracking/src/aux_functions.py
code served (permissive licence) · get_code("4cdcf1e0374a3a59")
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 3, 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 cv2
import numpy as np

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

# Define source points - 4 points that form a quadrilateral
# These should be in the format [[x1, y1], [x2, y2], [x3, y3], [x4, y4]]
src_points = [
    [0, 120],
    [640, 120],
    [0, 480],
    [640, 480]
]

ARGS = {
    "img": img,
    "src_points": src_points
}
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, ndim 3, 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_color Ran
ran, honoured the contract we drafted
harsh2912/people-tracking/src/lib/tracking_utils/visualization.py
code served (permissive licence) · get_code("0d2550860de1d622")
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 = {
    "idx": 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 tuple, ndim 1, dtype family int — a tuple output has no array shape of its own; none is stated
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
get_eval_result Ran
ran on a synthesized input
15534081591/FairMOT/sdk_eval.py
code served (permissive licence) · get_code("c7ba403a1a392132")
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. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import os
import numpy as np
import tempfile

# Create temporary directory and files for testing
temp_dir = tempfile.mkdtemp()
result_dir = tempfile.mkdtemp()

# Create a sample image path
img_path = os.path.join(temp_dir, "sample_image.jpg")
with open(img_path, 'w') as f:
    f.write("dummy image")

# Create the binary result files that the function expects
filename = "sample_image"
id_feature_file = os.path.join(result_dir, filename + '_0.bin')
dets_file = os.path.join(result_dir, filename + '_1.bin')

# Write binary files with expected shapes
id_feature_data = np.random.rand(500, 128).astype(np.float32)
id_feature_data.tofile(id_feature_file)

dets_data = np.random.rand(1, 500, 6).astype(np.float32)
dets_data.tofile(dets_file)

ARGS = {
    'img_path': img_path,
    'result_path': result_dir
}
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 — a list 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_feature_pickle_folder Ran
ran on a synthesized input
nolanzzz/MTMCT/clustering/multi_cam_clustering.py
code served (permissive licence) · get_code("d06a6708707d888d")
How it ran

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

import os

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

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

import os
import tempfile

# Analyze the function to determine what parameters are needed
# get_feature_pickle_path requires:
# - work_dirs: a string representing a directory path
# - frame_no_cam: appears to be an integer (used in .format())
# - cam_id: appears to be an integer or string (used in .format())
# - config_basename: a string (used in os.path.join())
# - dataset_type: a string (used in os.path.join())

# The function uses os.path.join() and os.makedirs(), so work_dirs should be
# a valid path string. We'll use a temporary directory.

temp_dir = tempfile.gettempdir()

ARGS = {
    'work_dirs': temp_dir,
    'frame_no_cam': 42,
    'cam_id': 1,
    'config_basename': 'test_config',
    'dataset_type': 'train'
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
none outside the standard library — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type str — a str output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a str output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not stated
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
get_frame_nos_track_results Ran
ran on a synthesized input
nolanzzz/MTMCT/clustering/multi_cam_clustering.py
code served (permissive licence) · get_code("0b062374daf8eacb")
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 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 pandas as pd

def get_frame_nos_track_results(track_results):
    frame_numbers = track_results.groupby('frame_no_cam', as_index=False).mean()
    frame_numbers = frame_numbers['frame_no_cam'].tolist()
    frame_numbers = list(map(int, frame_numbers))
    return frame_numbers

# Create a sample DataFrame that mimics track_results
# The function groups by 'frame_no_cam' and takes the mean, then extracts frame_no_cam values
track_results = pd.DataFrame({
    'frame_no_cam': [1, 1, 2, 2, 3],
    'x': [10.5, 11.2, 20.3, 21.1, 30.0],
    'y': [5.1, 5.9, 15.2, 16.1, 25.0]
})

ARGS = {
    'track_results': track_results
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
pandas — 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 int — 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
heappop Ran
ran on a synthesized input
nolanzzz/MTMCT/clustering/heapq.py
code served (permissive licence) · get_code("861194d214853027")
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)

# The heappop function expects a heap (list-like object that supports indexing,
# pop(), and comparisons of elements). The elements need to support < comparison.
# We'll create a simple list of integers that forms a valid min-heap.

# A valid min-heap with integers
heap = [1, 3, 5, 7, 9, 11, 13]

ARGS = {
    "heap": heap
}
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
heappushpop Ran
ran on a synthesized input
nolanzzz/MTMCT/clustering/heapq.py
code served (permissive licence) · get_code("2dd32a0f4e7523b1")
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)

# The heappushpop function operates on a heap (a list) and an item to push/pop.
# It compares items using the < operator, so we need comparable items.
# The heap is modified in-place, and items are compared directly.

# We'll use a simple list of integers as the heap, and an integer as the item.
heap = [1, 3, 5, 7, 9]
item = 4

ARGS = {
    "heap": heap,
    "item": item,
}
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
heapreplace Ran
ran on a synthesized input
nolanzzz/MTMCT/clustering/heapq.py
code served (permissive licence) · get_code("81179724eab889ba")
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 heapq

# Create a valid min-heap as a list
# The function expects a heap where heap[0] is the smallest element
# We'll create a small heap with comparable items (integers or floats work well)
heap = [1, 3, 5, 7, 9]

# Create a new item to insert
item = 4

# The function heapreplace(heap, item) pops the smallest value (heap[0])
# and adds the new item, maintaining the heap property
ARGS = {
    "heap": heap,
    "item": item
}
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
letterbox Ran
ran; our contract draft was wrong, not the code
dingwoai/FairMOT-BDD100K/src/lib/datasets/dataset/bdd100k.py
code served (permissive licence) · get_code("90caac012650cd20")
How it ran

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

import cv2
import numpy as np

# Create a small test image (height=480, width=640, channels=3)
img = np.random.randint(0, 255, size=(480, 640, 3), dtype=np.uint8)

ARGS = {
    "img": img,
    "height": 608,
    "width": 1088,
    "color": (127.5, 127.5, 127.5)
}
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
load_classes Ran
ran on a synthesized input
harsh2912/people-tracking/src/lib/tracking_utils/utils.py
code served (permissive licence) · get_code("351075718e449c42")
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 labels
temp_file = tempfile.NamedTemporaryFile(mode='w', delete=False, suffix='.txt')
temp_file.write("cat\ndog\nbird\nfish\n")
temp_file.close()

ARGS = {
    "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
load_func Ran
ran; our contract draft was wrong, not the code
lilin19890401/FairMOT/src/gen_labels_crowd.py
code served (permissive licence) · get_code("82e6ffbe008d3cfa")
How it ran

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

import os
import json
import tempfile

# Create a temporary file with JSON records
temp_dir = tempfile.mkdtemp()
temp_file = os.path.join(temp_dir, 'test_records.jsonl')

# Write some test records to the file
records_to_write = [
    {'id': 1, 'text': 'hello'},
    {'id': 2, 'text': 'world'},
    {'id': 3, 'text': 'test'}
]

with open(temp_file, 'w') as f:
    for record in records_to_write:
        f.write(json.dumps(record) + '\n')

# Define ARGS with the file path
ARGS = {
    'fpath': temp_file
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
none outside the standard library — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type list, ndim 1, dtype family float — a list output has no array shape of its own; none is stated
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
map_clusters_track_indices_to_tracks Ran
ran on a synthesized input
nolanzzz/MTMCT/clustering/clustering_utils.py
code served (permissive licence) · get_code("c672ace389f767d9")
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. 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 sample tracks - these will be strings representing track data
track_1 = "Track_1_data"
track_2 = "Track_2_data"
track_3 = "Track_3_data"
track_4 = "Track_4_data"

all_tracks = [track_1, track_2, track_3, track_4]

# Define clusters containing track indices
clusters = [
    [0, 2],      # First cluster references tracks 0 and 2
    [1, 3],      # Second cluster references tracks 1 and 3
    [0, 1, 3]    # Third cluster references tracks 0, 1, and 3
]

ARGS = {
    "clusters": clusters,
    "all_tracks": all_tracks
}
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 list — a list 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
map_idx_to_tracks Ran
ran on a synthesized input
nolanzzz/MTMCT/clustering/clustering_utils.py
code served (permissive licence) · get_code("297139b9ee516b1d")
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 3, dtype family float; no output shape is stated. The image it ran in was not recorded. If your copy returns the same type and ndim on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch
import numpy as np

torch.manual_seed(0)

# Create sample tracks - these could be tensors, dicts, or any objects
track_1 = torch.randn(2, 4)
track_2 = torch.randn(2, 4)
track_3 = torch.randn(2, 4)

all_tracks = [track_1, track_2, track_3]

# Create indices to retrieve specific tracks
track_indices = [0, 2, 1]

ARGS = {
    "track_indices": track_indices,
    "all_tracks": all_tracks,
}
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 list, ndim 3, 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
merge Ran
ran; our contract draft was wrong, not the code
15534081591/FairMOT/src/config.py
code served (permissive licence) · get_code("b9e24c3e3e0e88a7")
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) 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 argparse

torch.manual_seed(0)

# Create a mock args object with some attributes
args = argparse.Namespace(
    learning_rate=0.001,
    batch_size=32,
    epochs=10,
    model_name="test_model",
    debug=True,
    seed=42
)

# Create a base configuration dictionary
cfg = {
    "default_lr": 0.0001,
    "default_batch": 16,
    "dataset": "cifar10"
}

ARGS = {
    "args": args,
    "cfg": cfg
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1
Imports
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
merge_outputs Ran
ran; our contract draft was wrong, not the code
nemonameless/fairmot/src/detect.py
code served (permissive licence) · get_code("41ded276da5308cd")
How it ran

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

import numpy as np

class OptConfig:
    def __init__(self, num_classes):
        self.num_classes = num_classes

# Create opt with 3 classes
opt = OptConfig(num_classes=3)

# Create detections - a list of dicts where each dict maps class_id to detection array
# Each detection array has shape (num_detections, 5) where last column is confidence score
detections = []

# First detection dict
detection1 = {}
for class_id in range(1, opt.num_classes + 1):
    # Create some detections with bboxes (x, y, w, h, score)
    num_dets = 5
    detection1[class_id] = np.array([
        [10.0, 20.0, 30.0, 40.0, 0.9],
        [15.0, 25.0, 35.0, 45.0, 0.8],
        [12.0, 22.0, 32.0, 42.0, 0.7],
        [11.0, 21.0, 31.0, 41.0, 0.6],
        [13.0, 23.0, 33.0, 43.0, 0.5],
    ], dtype=np.float32)

# Second detection dict
detection2 = {}
for class_id in range(1, opt.num_classes + 1):
    num_dets = 4
    detection2[class_id] = np.array([
        [50.0, 60.0, 70.0, 80.0, 0.95],
        [55.0, 65.0, 75.0, 85.0, 0.85],
        [52.0, 62.0, 72.0, 82.0, 0.75],
        [51.0, 61.0, 71.0, 81.0, 0.65],
    ], dtype=np.float32)

detections = [detection1, detection2]

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

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

import numpy as np

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

# Create sample detections
# Each detection is a dict with class_id -> array of shape (num_detections, 5)
# where the 5 columns are [x1, y1, x2, y2, score]

detection1 = {
    1: np.array([
        [10.0, 20.0, 30.0, 40.0, 0.95],
        [50.0, 60.0, 70.0, 80.0, 0.85],
        [100.0, 110.0, 120.0, 130.0, 0.75]
    ], dtype=np.float32)
}

detection2 = {
    1: np.array([
        [15.0, 25.0, 35.0, 45.0, 0.90],
        [55.0, 65.0, 75.0, 85.0, 0.80]
    ], dtype=np.float32)
}

detections = [detection1, detection2]

ARGS = {
    "detections": detections
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type dict — a dict output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a dict output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not stated
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
parse_cli_to_yaml Ran
ran; our contract draft was wrong, not the code
15534081591/FairMOT/src/config.py
code served (permissive licence) · get_code("96d37c643b26e9d8")
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 Namespace. 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 argparse
import ast

def parse_cli_to_yaml(parser, cfg, helper=None, choices=None, cfg_path='default_config.yaml'):
    """
    Parse command line arguments to the configuration according to the default yaml.

    Args:
        parser: Parent parser.
        cfg: Base configuration.
        helper: Helper description.
        cfg_path: Path to the default yaml config.
    """
    parser = argparse.ArgumentParser(description='[REPLACE THIS at config.py]', parents=[parser])
    helper = {} if helper is None else helper
    choices = {} if choices is None else choices
    for item in cfg:
        if not isinstance(cfg[item], list) and (not isinstance(cfg[item], dict)):
            help_description = helper[item] if item in helper else 'Please reference to {}'.format(cfg_path)
            choice = choices[item] if item in choices else None
            if isinstance(cfg[item], bool):
                parser.add_argument('--' + item, type=ast.literal_eval, default=cfg[item], choices=choice, help=help_description)
            else:
                parser.add_argument('--' + item, type=type(cfg[item]), default=cfg[item], choices=choice, help=help_description)
    args = parser.parse_args()
    return args


# Setup code to construct valid arguments
import sys

# Create a parent parser
parent_parser = argparse.ArgumentParser(add_help=False)

# Create a base configuration dictionary with various types
cfg = {
    'learning_rate': 0.001,
    'batch_size': 32,
    'epochs': 100,
    'use_cuda': False,
    'model_name': 'resnet50',
    'dropout': 0.5,
}

# Create helper descriptions for some parameters
helper = {
    'learning_rate': 'Learning rate for optimizer',
    'batch_size': 'Batch size for training',
    'epochs': 'Number of training epochs',
    'use_cuda': 'Whether to use CUDA',
    'model_name': 'Name of the model to use',
}

# Create choices for some parameters
choices = {
    'model_name': ['resnet50', 'vgg16', 'efficientnet'],
}

# Set up sys.argv to simulate command line arguments
sys.argv = ['script.py']

ARGS = {
    'parser': parent_parser,
    'cfg': cfg,
    'helper': helper,
    'choices': choices,
    'cfg_path': 'default_config.yaml'
}
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 Namespace — a Namespace output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a Namespace 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
parse_cli_to_yaml Ran
ran; our contract draft was wrong, not the code
15534081591/FairMOT/modelarts/util/config.py
code served (permissive licence) · get_code("738456e1b7388e7e")
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 Namespace. 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 argparse
import ast

# Create minimal parent parser
parent_parser = argparse.ArgumentParser(add_help=False)

# Create base configuration dict with various types
cfg = {
    'learning_rate': 0.001,
    'batch_size': 32,
    'epochs': 10,
    'use_cuda': False,
    'model_name': 'resnet50',
    'dropout': 0.5,
    'debug': True,
    'nested_list': [1, 2, 3],  # This will be skipped since it's a list
    'nested_dict': {'a': 1},   # This will be skipped since it's a dict
}

# Create helper descriptions
helper = {
    'learning_rate': 'Learning rate for optimizer',
    'batch_size': 'Batch size for training',
    'epochs': 'Number of training epochs',
    'use_cuda': 'Whether to use CUDA',
    'model_name': 'Name of the model architecture',
    'dropout': 'Dropout rate',
    'debug': 'Enable debug mode',
}

# Create choices for specific parameters
choices = {
    'model_name': ['resnet50', 'vgg16', 'mobilenet'],
}

# Set config path
cfg_path = 'default_config.yaml'

ARGS = {
    'parser': parent_parser,
    'cfg': cfg,
    'helper': helper,
    'choices': choices,
    'cfg_path': cfg_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 Namespace — a Namespace output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a Namespace 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
parse_data_cfg Ran
ran on a synthesized input
harsh2912/people-tracking/src/lib/tracking_utils/parse_config.py
code served (permissive licence) · get_code("5f1e6bf7cfe64409")
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 data configuration file
temp_dir = tempfile.mkdtemp()
config_path = os.path.join(temp_dir, "data.cfg")

# Write a sample configuration file
config_content = """# Data configuration file
gpus=0,1
num_workers=4
train_path=/path/to/train
val_path=/path/to/val
classes=10
batch_size=32
# This is a comment
image_size=416
"""

with open(config_path, 'w') as f:
    f.write(config_content)

ARGS = {
    'path': config_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 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
parse_model_cfg Ran
ran on a synthesized input
harsh2912/people-tracking/src/lib/tracking_utils/parse_config.py
code served (permissive licence) · get_code("fd8f3444be894f66")
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 YOLO configuration file
temp_config = """# YOLO v3 configuration file
[net]
batch=64
subdivisions=16
width=416
height=416
channels=3

# Convolutional layer
[convolutional]
batch_normalize=1
filters=32
size=3
stride=1
pad=1
activation=relu

[convolutional]
filters=64
size=3
stride=2
pad=1
activation=relu

[maxpool]
size=2
stride=2

[route]
layers=-1,-3
"""

# Write the config to a temporary file
with tempfile.NamedTemporaryFile(mode='w', suffix='.cfg', delete=False) as f:
    f.write(temp_config)
    config_path = f.name

try:
    ARGS = {
        'path': config_path
    }
finally:
    # Clean up will happen after execution
    pass
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
parse_yaml Ran
ran on a synthesized input
15534081591/FairMOT/src/config.py
code served (permissive licence) · get_code("96a9939953d5992d")
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 tempfile
import os
import yaml

# Create a temporary YAML file with valid config structure
temp_dir = tempfile.mkdtemp()
yaml_path = os.path.join(temp_dir, "config.yaml")

# Write a valid YAML file with 3 documents: config, helper, and choices
yaml_content = """
model: resnet50
learning_rate: 0.001
batch_size: 32
---
model: "Model architecture to use"
learning_rate: "Learning rate for optimization"
batch_size: "Batch size for training"
---
model: [resnet50, resnet101, vgg16]
learning_rate: [0.0001, 0.001, 0.01]
batch_size: [16, 32, 64]
"""

with open(yaml_path, 'w') as f:
    f.write(yaml_content)

ARGS = {
    "yaml_path": yaml_path
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
yaml — 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
parse_yaml Ran
ran on a synthesized input
15534081591/FairMOT/modelarts/util/config.py
code served (permissive licence) · get_code("e88a5b49e162d3f1")
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 yaml
import tempfile
import os

# Create a temporary YAML file with valid content
yaml_content = """
model: resnet50
learning_rate: 0.001
batch_size: 32
---
model: Model architecture
learning_rate: Learning rate for training
batch_size: Number of samples per batch
---
model: [resnet50, vgg16, inception]
learning_rate: [0.0001, 0.001, 0.01]
batch_size: [16, 32, 64]
"""

# Write the YAML content to a temporary file
with tempfile.NamedTemporaryFile(mode='w', suffix='.yaml', delete=False) as f:
    f.write(yaml_content)
    yaml_path = f.name

try:
    ARGS = {
        'yaml_path': yaml_path
    }
finally:
    # Clean up will happen after the function executes
    pass
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
yaml — 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
put_text Ran
ran on a synthesized input
cds-mipt/cds-tracking/src/aux_functions.py
code served (permissive licence) · get_code("aaa08776c6849af2")
How it ran

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

import cv2
import numpy as np

# Create a small test frame (BGR image format for cv2)
frame = np.zeros((480, 640, 3), dtype=np.uint8)

# Define arguments for put_text function
ARGS = {
    "frame": frame,
    "text": "Test Text",
    "text_offset_y": 25
}
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
random_affine Ran
ran; our contract draft was wrong, not the code
dingwoai/FairMOT-BDD100K/src/lib/datasets/dataset/bdd100k.py
code served (permissive licence) · get_code("df92561bc5f7e909")
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 math
import random
import cv2
import numpy as np

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

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

# Create targets array with shape (2, 6)
# Each row: [class_id, conf, x1, y1, x2, y2]
targets = np.array([
    [0, 0.9, 10.0, 20.0, 50.0, 60.0],
    [1, 0.8, 55.0, 25.0, 75.0, 70.0]
], dtype=np.float32)

# Define function parameters
degrees = (-10, 10)
translate = (0.1, 0.1)
scale = (0.9, 1.1)
shear = (-2, 2)
borderValue = (127.5, 127.5, 127.5)

ARGS = {
    'img': img,
    'targets': targets,
    'degrees': degrees,
    'translate': translate,
    'scale': scale,
    'shear': shear,
    'borderValue': borderValue
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
cv2, numpy, torchvision — 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
read_gt_txts Ran
ran on a synthesized input
dingwoai/FairMOT-BDD100K/src/track_bdd.py
code served (permissive licence) · get_code("56a63fa6e0a2dc6a")
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. 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 tempfile
import os

# Create a temporary ground truth text file
temp_dir = tempfile.mkdtemp()
gt_file = os.path.join(temp_dir, "gt.txt")

# Write sample ground truth data
# Format: frame_id track_id x_center y_center width height confidence class_id
sample_data = """1 5 0.1 0.2 0.15 0.25 1 0
2 5 0.12 0.22 0.15 0.25 1 0
3 7 0.5 0.5 0.2 0.3 1 0
4 7 0.52 0.52 0.2 0.3 1 0"""

with open(gt_file, 'w') as f:
    f.write(sample_data)

ARGS = {
    "gt_path": gt_file
}
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 — a list 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
read_mot_results Ran
ran; our contract draft was wrong, not the code
zengwbz/Face-Tracking-usingFairMOT/src/lib/tracking_utils/io.py
pointer only (licence: MIT); the stored copy get_code serves, from weijiawu/BOVText-Benchmark, is pointer only (licence: CC-BY-4.0) · get_code("9a73f2c41ea25d0b")
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 weijiawu/BOVText-Benchmark, and CC-BY-4.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.

read_mot_results Ran
ran on a synthesized input
harsh2912/people-tracking/src/lib/tracking_utils/io.py
code served (permissive licence) · get_code("9eb3b334fd02b5d3")
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 os
import tempfile

# Create a temporary MOT-format results file
temp_dir = tempfile.mkdtemp()
temp_file = os.path.join(temp_dir, "MOT17-02-gt.txt")

# Write sample MOT format data
# Format: FrameID, TargetID, X, Y, W, H, Mark, Label, Visibility
mot_data = """1,1,10.5,20.3,50.0,100.0,1,1,0.95
1,2,200.0,150.0,45.0,95.0,1,1,0.88
2,1,12.0,21.5,50.5,100.5,1,1,0.96
2,3,300.0,200.0,40.0,90.0,1,2,0.75
3,1,15.0,25.0,51.0,101.0,1,1,0.98
"""

with open(temp_file, 'w') as f:
    f.write(mot_data)

ARGS = {
    "filename": temp_file,
    "is_gt": True,
    "is_ignore": False
}
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
read_results Ran
ran; our contract draft was wrong, not the code
harsh2912/people-tracking/src/lib/tracking_utils/io.py
code served (permissive licence) · get_code("1958a4fce355d7a6")
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 os
import tempfile

# Create a temporary MOT format file for testing
temp_file = tempfile.NamedTemporaryFile(mode='w', delete=False, suffix='.txt')
temp_filename = temp_file.name

# Write sample MOT format data
# Format: <frame>, <id>, <x>, <y>, <w>, <h>, <conf>, <class_id>, <visibility>
# For ground truth (is_gt=True), we need MOT16/MOT17 format with proper labels
sample_data = """1,1,10.5,20.3,50.2,100.1,1,1,0.9
2,1,11.0,21.0,50.0,100.0,0.95,1,0.95
3,2,30.0,40.0,60.0,120.0,0.8,1,0.8
"""

temp_file.write(sample_data)
temp_file.close()

# Create another file for ignore testing
temp_ignore_file = tempfile.NamedTemporaryFile(mode='w', delete=False, suffix='.txt')
temp_ignore_filename = temp_ignore_file.name

ignore_data = """1,1,10.5,20.3,50.2,100.1,1,2,0.5
2,1,11.0,21.0,50.0,100.0,0.95,7,0.3
"""

temp_ignore_file.write(ignore_data)
temp_ignore_file.close()

# Define arguments for read_results function
ARGS = {
    'filename': temp_filename,
    'data_type': 'mot',
    'is_gt': False,
    'is_ignore': False,
}
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
read_results Ran
ran; our contract draft was wrong, not the code
zengwbz/Face-Tracking-usingFairMOT/src/lib/tracking_utils/io.py
code served (permissive licence) · get_code("06869f0ca6ac6c89")
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 os
import tempfile

# Create a temporary MOT format results file
temp_file = tempfile.NamedTemporaryFile(mode='w', delete=False, suffix='.txt')
temp_filename = temp_file.name

# Write sample MOT format data
# Format: <frame>, <id>, <x>, <y>, <w>, <h>, <conf>, <class_label>, <visibility>
temp_file.write("1,1,10.0,20.0,50.0,80.0,0.95,1,0.8\n")
temp_file.write("1,2,100.0,150.0,40.0,70.0,0.85,1,0.9\n")
temp_file.write("2,1,11.0,21.0,50.0,80.0,0.93,1,0.8\n")
temp_file.close()

ARGS = {
    'filename': temp_filename,
    'data_type': 'mot',
    'is_gt': False,
    'is_ignore': False
}
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
resize_image Ran
ran on a synthesized input
harsh2912/people-tracking/src/lib/tracking_utils/visualization.py
code served (permissive licence) · get_code("15af20c349fec967")
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 (800, 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 (4x3 pixels, 3 channels for BGR)
# Using a small image that's below max_size to test both branches
image_small = np.random.randint(0, 256, (4, 3, 3), dtype=np.uint8)

# Create a larger image that will trigger resizing
image_large = np.random.randint(0, 256, (1000, 800, 3), dtype=np.uint8)

ARGS = {
    "image": image_large,
    "max_size": 800,
}
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 (800, 640, 3) — shape (800, 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
select_device Ran
ran on a synthesized input
lilin19890401/FairMOT/src/gen_wts.py
code served (permissive licence) · get_code("722ec979c0e8eafd")
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 device. The image it ran in was not recorded. The code mentions cuda, and the harness aliases cuda to the CPU for every sample; whether this run needed that is not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch
import os

torch.manual_seed(0)

# The function select_device takes two parameters:
# - device: a string specifying device ('' for default, 'cpu', or CUDA device spec)
# - batch_size: optional int for batch size validation

# Since this is CPU-only sandbox, we'll use 'cpu' to avoid CUDA assertions
ARGS = {
    'device': 'cpu',
    'batch_size': None
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type device — a device output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a device 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
softmax Ran
ran on a synthesized input
nolanzzz/MTMCT/util.py
code served (permissive licence) · get_code("66744e8b3c8d06d3")
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
import torch

np.random.seed(0)

x = np.random.randn(2, 4)

ARGS = {
    'x': x
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy, torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type ndarray, ndim 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
tlwhs_to_tlbrs Ran
ran on a synthesized input
harsh2912/people-tracking/src/lib/tracking_utils/visualization.py
code served (permissive licence) · get_code("d1b59d059858d28c")
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

# The function tlwhs_to_tlbrs takes bounding boxes in (top-left-width-height) format
# and converts them to (top-left-bottom-right) format.
# It expects an ndarray where each row is [x, y, width, height]

# Create a small sample of bounding boxes in TLWH format
# Shape: (2, 4) where each row is [top, left, width, height]
tlwhs = np.array([
    [10.0, 20.0, 30.0, 40.0],
    [50.0, 60.0, 70.0, 80.0]
], dtype=np.float32)

ARGS = {
    "tlwhs": tlwhs
}
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
unzip_objs Ran
ran on a synthesized input
harsh2912/people-tracking/src/lib/tracking_utils/io.py
code served (permissive licence) · get_code("261a9c5fae0c1b9f")
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

# The function unzip_objs expects a list/iterable of tuples
# Each tuple should contain (tlwh, id, score)
# where tlwh is a 4-element array-like (top, left, width, height)
# id is an identifier
# score is a confidence score

# Create sample objects as tuples
obj1 = ([10, 20, 100, 150], 1, 0.95)
obj2 = ([50, 60, 200, 250], 2, 0.87)
obj3 = ([15, 25, 110, 160], 3, 0.92)

objs = [obj1, obj2, obj3]

ARGS = {
    "objs": objs
}
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
valid_heap_node Ran
ran on a synthesized input
nolanzzz/MTMCT/clustering/clustering_utils.py
code served (permissive licence) · get_code("a5e9dcaf8c7d4a82")
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
import numpy as np

torch.manual_seed(0)

# Analyzing the function:
# - heap_node: indexed with [1], so it's a sequence/tuple
# - heap_node[1] (pair_data): supports 'in' operator, so it's a container (likely a set, list, or tuple)
# - old_clusters: iterable of items that are checked against pair_data using 'in'
# The function checks if any old_cluster appears in pair_data

# Create valid test data:
# heap_node should be a tuple/list with at least 2 elements
# heap_node[1] should be the pair_data (a set, list, or tuple of cluster identifiers)
# old_clusters should be a list of cluster identifiers

# Using simple integer cluster identifiers
pair_data = {0, 1, 2}  # set of cluster ids in this heap node
heap_node = ("some_priority", pair_data)  # tuple where index 1 is pair_data

old_clusters = [3, 4, 5]  # clusters not in pair_data, so valid_heap_node returns True

ARGS = {
    "heap_node": heap_node,
    "old_clusters": old_clusters,
}
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 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
xyxy2xywh Ran
ran on a synthesized input
harsh2912/people-tracking/src/lib/tracking_utils/utils.py
code served (permissive licence) · get_code("a43bd5ac31eb7191")
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
import numpy as np

torch.manual_seed(0)

# The function xyxy2xywh takes a single parameter 'x'
# It expects x to be either a torch tensor or numpy array with shape (batch_size, 4)
# where each row contains [x1, y1, x2, y2] coordinates

# Create a torch tensor input (xyxy format: x1, y1, x2, y2)
x_torch = torch.tensor([
    [10.0, 20.0, 50.0, 80.0],
    [5.0, 15.0, 45.0, 75.0]
], dtype=torch.float32)

ARGS = {
    'x': x_torch
}
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 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
DataParallel Not yet run
unverified (harvested, no recorded run)
FlorentijnD/FairMOT/src/lib/models/data_parallel.py
code served (permissive licence) · get_code("ddb5a5004c8da97a")
How it ran

no invocation recorded.

convert_cv2_img_to_pil_img Not yet run
unverified (harvested, no recorded run)
nolanzzz/MTMCT/feature_extractors/abd_net_extractor.py
code served (permissive licence) · get_code("35609759dcd23c82")
How it ran

no invocation recorded.

data_parallel Not yet run
unverified (harvested, no recorded run)
FlorentijnD/FairMOT/src/lib/models/data_parallel.py
code served (permissive licence) · get_code("61bf3906cbd2ee87")
How it ran

no invocation recorded.

gen_labels Not yet run
unverified (harvested, no recorded run)
cds-mipt/cds-tracking/src/gen_labels_detrac.py
code served (permissive licence) · get_code("3093599680093220")
How it ran

no invocation recorded.

get_dataset Not yet run
unverified (harvested, no recorded run)
FlorentijnD/FairMOT/src/lib/datasets/dataset_factory.py
code served (permissive licence) · get_code("541ce6c4361d61d6")
How it ran

no invocation recorded.

load_model Not yet run
unverified (harvested, no recorded run)
FlorentijnD/FairMOT/src/lib/models/model.py
code served (permissive licence) · get_code("42af9659af852ebd")
How it ran

no invocation recorded.

mot_decode Not yet run
unverified (harvested, no recorded run)
FlorentijnD/FairMOT/src/lib/models/decode.py
code served (permissive licence) · get_code("9cfc15fd1dbd64f3")
How it ran

no invocation recorded.

Also present in other papers' code

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

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

FunctionAlso present inEarliest-datedOthers named
merge 28 other papers
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
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
data_parallel 9 other papers
8 dated earlier, 1 the same month
1505.05424 (2015-05)
Weight Uncertainty in Neural Networks
1603.00831 (2016-03)
MOT16: A Benchmark for Multi-Object Tracking
1808.01244 (2018-08)
CornerNet: Detecting Objects as Paired Keypoints
and 6 more not named here
compute_bin_loss 6 other papers
4 dated earlier, 1 the same month, 1 later
1603.00831 (2016-03)
MOT16: A Benchmark for Multi-Object Tracking
1904.07850 (2019-04)
Objects as Points
2001.03343 (2020-01)
RTM3D: Real-time Monocular 3D Detection from Object Keypoints for Autonomous Driving
and 3 more not named here
compute_res_loss 6 other papers
4 dated earlier, 1 the same month, 1 later
1603.00831 (2016-03)
MOT16: A Benchmark for Multi-Object Tracking
1904.07850 (2019-04)
Objects as Points
2001.03343 (2020-01)
RTM3D: Real-time Monocular 3D Detection from Object Keypoints for Autonomous Driving
and 3 more not named here
compute_rot_loss 6 other papers
4 dated earlier, 1 the same month, 1 later
1603.00831 (2016-03)
MOT16: A Benchmark for Multi-Object Tracking
1904.07850 (2019-04)
Objects as Points
2001.03343 (2020-01)
RTM3D: Real-time Monocular 3D Detection from Object Keypoints for Autonomous Driving
and 3 more not named here
DataParallel 5 other papers
4 dated earlier, 1 the same month
1603.00831 (2016-03)
MOT16: A Benchmark for Multi-Object Tracking
1904.07850 (2019-04)
Objects as Points
2001.04608 (2020-01)
Actions as Moving Points
and 2 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.10934 (2020-04)
YOLOv4: Optimal Speed and Accuracy of Object Detection
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.10934 (2020-04)
YOLOv4: Optimal Speed and Accuracy of Object Detection
2010.12138 (2020-10)
Rethinking the competition between detection and ReID in Multi-Object Tracking
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.10934 (2020-04)
YOLOv4: Optimal Speed and Accuracy of Object Detection
2010.12138 (2020-10)
Rethinking the competition between detection and ReID in Multi-Object Tracking
and 1 more not named here
collate_fn 2 other papers
1 dated earlier, 1 later
1909.12605 (2019-09)
Towards Real-Time Multi-Object Tracking
2010.12138 (2020-10)
Rethinking the competition between detection and ReID in Multi-Object Tracking
letterbox 2 other papers
1 dated earlier, 1 later
1909.12605 (2019-09)
Towards Real-Time Multi-Object Tracking
2010.12138 (2020-10)
Rethinking the competition between detection and ReID in Multi-Object Tracking
load_model 2 other papers
2 dated earlier
1603.00831 (2016-03)
MOT16: A Benchmark for Multi-Object Tracking
1904.07850 (2019-04)
Objects as Points
parse_data_cfg 2 other papers
1 dated earlier, 1 later
1909.12605 (2019-09)
Towards Real-Time Multi-Object Tracking
2010.12138 (2020-10)
Rethinking the competition between detection and ReID in Multi-Object Tracking
random_affine 2 other papers
1 dated earlier, 1 later
1909.12605 (2019-09)
Towards Real-Time Multi-Object Tracking
2010.12138 (2020-10)
Rethinking the competition between detection and ReID in Multi-Object Tracking
xyxy2xywh 2 other papers
1 dated earlier, 1 later
1908.06354 (2019-08)
A Fast and Accurate One-Stage Approach to Visual Grounding
2008.01059 (2020-08)
Improving One-stage Visual Grounding by Recursive Sub-query Construction
draw_bbox 1 other paper
1 dated earlier
1904.07850 (2019-04)
Objects as Points
get_color 1 other paper
1 later
2403.11186 (2024-03)
NetTrack: Tracking Highly Dynamic Objects with a Net
load_func 1 other paper
1 later
2403.04700 (2024-03)
Delving into the Trajectory Long-tail Distribution for Muti-object Tracking

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

Multi-object tracking (MOT) is an important problem in computer vision which has a wide range of applications. Formulating MOT as multi-task learning of object detection and re-ID in a single network is appealing since it allows joint optimization of the two tasks and enjoys high computation efficiency. However, we find that the two tasks tend to compete with each other which need to be carefully addressed. In particular, previous works usually treat re-ID as a secondary task whose accuracy is heavily affected by the primary detection task. As a result, the network is biased to the primary detection task which is not fair to the re-ID task. To solve the problem, we present a simple yet effective approach termed as FairMOT based on the anchor-free object detection architecture CenterNet. Note that it is not a naive combination of CenterNet and re-ID. Instead, we present a bunch of detailed designs which are critical to achieve good tracking results by thorough empirical studies. The resulting approach achieves high accuracy for both detection and tracking. The approach outperforms the state-of-the-art methods by a large margin on several public datasets. The source code and pre-trained models are released at https://github.com/ifzhang/FairMOT.

For agents

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

get_harvested_code_for_paper("2004.01888")
get_code_for_paper("2004.01888")
have("2004.01888")

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

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

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

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

Connect an agent — have() is free.