| 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 ranRan 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 ranRan 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 ranRan 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 ranRan 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 ranRan 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 ranRan 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 ranRan 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 ranRan 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 ranRan 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 ranRan 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 ranRan 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 ranRan 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 ranRan 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 ranRan 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 ranRan 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 ranRan 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 ranRan 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 ranRan 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 ranRan 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 ranRan 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 ranRan 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 ranRan 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 ranRan 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 ranRan 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 ranRan 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 ranRan 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 ranRan 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 ranRan 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 ranRan 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 ranRan 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 ranRan 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 ranRan 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 ranRan 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 ranRan 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 ranRan 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 ranThe 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 ranRan 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 ranRan 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 ranRan 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 ranRan 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 ranRan 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 ranRan 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 ranRan 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 ranRan 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 ranRan 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 ranRan 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 |
| 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 |
| 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 |
| 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 |
| 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 |
| 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 |
| 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 |