| argmax_pose_predict |
Ran ran on a synthesized input |
PJunhyuk/exercise-pose-analyzer/nnet/predict.py code served (permissive licence) · get_code("9a884fa07ac146ca") 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 (3, 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
# Construct the scoremap (heatmap)
# Shape: (height, width, num_joints)
# The function uses np.argmax over the first two dimensions for each joint
scmap = np.random.rand(8, 10, 3).astype(np.float32)
# Construct the offset matrix
# Shape: (height, width, num_joints, 2)
# The function indexes it as offmat[maxloc][joint_idx] where maxloc is (row, col)
offmat = np.random.rand(8, 10, 3, 2).astype(np.float32)
# Stride parameter - used to scale pixel coordinates
stride = 4
ARGS = {
'scmap': scmap,
'offmat': offmat,
'stride': stride
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- numpy — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type ndarray, ndim 2, dtype family float, shape (3, 3) — shape (3, 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
|
| background_subtraction |
Ran ran on a synthesized input |
PJunhyuk/people-counting-pose/preprocessing.py code served (permissive licence) · get_code("d8f25bdf4f1fe7f2") 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 4, dtype family int, shape (2, 4, 3, 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 torch
import numpy as np
import cv2
torch.manual_seed(0)
# The function takes a video parameter and returns it after applying background subtraction
# The function uses cv2 but doesn't actually call any cv2 methods on the video object
# So we need to provide a video-like object that can be processed
# Create a simple numpy array representing a video (frames, height, width, channels)
video = np.random.randint(0, 255, size=(2, 4, 3, 3), dtype=np.uint8)
ARGS = {
"video": video
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- cv2, numpy, torch — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type ndarray, ndim 4, dtype family int, shape (2, 4, 3, 3) — shape (2, 4, 3, 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
|
| cfg_from_file |
Ran ran on a synthesized input |
ZJX9999/art_track/config.py code served (permissive licence) · get_code("c932aaaecd32b91b") 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 EasyDict. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import tempfile
import os
import yaml
from easydict import EasyDict as edict
# Create a temporary YAML config file
temp_dir = tempfile.mkdtemp()
config_file = os.path.join(temp_dir, 'test_config.yaml')
# Write a minimal YAML config
config_content = {
'stride': 16.0,
'global_scale': 2.0,
'locref_loss_weight': 0.5,
'pairwise_loss_weight': 0.8,
'dataset': {
'batch_size': 4,
'shuffle': True
}
}
with open(config_file, 'w') as f:
yaml.dump(config_content, f)
ARGS = {
'filename': config_file
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- easydict, yaml — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type EasyDict — a EasyDict output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a EasyDict 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
|
| check_config |
Ran ran on a synthesized input |
ZJX9999/art_track/config.py code served (permissive licence) · get_code("029aa31571a2026f") 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 EasyDict. 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 yaml
import tempfile
from easydict import EasyDict as edict
# Create a temporary YAML config file
temp_dir = tempfile.mkdtemp()
config_file = os.path.join(temp_dir, 'pose_cfg.yaml')
yaml_content = """
context:
mode: 1
device_target: GPU
stride: 8.0
weigh_only_present_joints: false
mean_pixel: [123.68, 116.779, 103.939]
global_scale: 1.0
location_refinement: false
locref_stdev: 7.2801
locref_loss_weight: 1.0
locref_huber_loss: true
intermediate_supervision: false
intermediate_supervision_layer: 12
intermediate_supervision_input: 1024
mirror: false
crop: false
crop_pad: 0
scoremap_dir: out/test
dataset:
path: ''
type: ''
parallel: 1
batch_size: 1
shuffle: false
mirror: false
padding: false
use_gt_segm: false
sparse_graph: []
pairwise_stats_collect: false
pairwise_stats_fn: pairwise_stats.mat
pairwise_predict: false
pairwise_huber_loss: true
pairwise_loss_weight: 1.0
tensorflow_pairwise_order: true
"""
with open(config_file, 'w') as f:
f.write(yaml_content)
class MockArgs:
def __init__(self, is_model_arts=False):
self.is_model_arts = is_model_arts
# Set up environment variable for POSE_PARAM_PATH
os.environ['POSE_PARAM_PATH'] = temp_dir
ARGS = {
'c': config_file,
'args': MockArgs(is_model_arts=False)
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- easydict, yaml — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type EasyDict — a EasyDict output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a EasyDict 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
|
| check_config |
Ran ran on a synthesized input |
ZJX9999/art_track/src/config.py code served (permissive licence) · get_code("f33df8791f30904a") 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 EasyDict. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import torch
import yaml
from easydict import EasyDict as edict
import tempfile
import os
# Create a minimal valid YAML config file
yaml_content = """
context:
mode: 1
device_target: GPU
stride: 8.0
weigh_only_present_joints: false
mean_pixel: [123.68, 116.779, 103.939]
global_scale: 1.0
location_refinement: false
locref_stdev: 7.2801
locref_loss_weight: 1.0
locref_huber_loss: true
intermediate_supervision: false
intermediate_supervision_layer: 12
intermediate_supervision_input: 1024
mirror: false
crop: false
crop_pad: 0
scoremap_dir: 'out/eval'
dataset:
path: ''
type: ''
parallel: 1
batch_size: 1
shuffle: false
mirror: false
padding: false
use_gt_segm: false
sparse_graph: []
pairwise_stats_collect: false
pairwise_stats_fn: 'pairwise_stats.mat'
pairwise_predict: false
pairwise_huber_loss: true
pairwise_loss_weight: 1.0
tensorflow_pairwise_order: true
"""
# Write YAML to a temporary file
temp_fd, temp_yaml_path = tempfile.mkstemp(suffix='.yaml')
os.write(temp_fd, yaml_content.encode('utf-8'))
os.close(temp_fd)
try:
# Test case 1: None argument (uses default return)
cfg_none = None
# Test case 2: Valid edict config
cfg_valid = edict({
'context': edict({'mode': 1, 'device_target': 'GPU'}),
'stride': 8.0,
'weigh_only_present_joints': False,
'mean_pixel': [123.68, 116.779, 103.939],
'global_scale': 1.0,
'location_refinement': False,
'locref_stdev': 7.2801,
'locref_loss_weight': 1.0,
'locref_huber_loss': True,
'intermediate_supervision': False,
'intermediate_supervision_layer': 12,
'intermediate_supervision_input': 1024,
'mirror': False,
'crop': False,
'crop_pad': 0,
'scoremap_dir': 'out/eval',
'dataset': edict({'path': '', 'type': '', 'parallel': 1, 'batch_size': 1, 'shuffle': False, 'mirror': False, 'padding': False}),
'use_gt_segm': False,
'sparse_graph': [],
'pairwise_stats_collect': False,
'pairwise_stats_fn': 'pairwise_stats.mat',
'pairwise_predict': False,
'pairwise_huber_loss': True,
'pairwise_loss_weight': 1.0,
'tensorflow_pairwise_order': True,
})
ARGS = {
'c': cfg_valid
}
finally:
if os.path.exists(temp_yaml_path):
os.unlink(temp_yaml_path)
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- easydict, torch, yaml — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type EasyDict — a EasyDict output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a EasyDict 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
|
| compose_option |
Ran ran on a synthesized input |
ZJX9999/art_track/src/args_util.py code served (permissive licence) · get_code("697796d387da2d86") 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 re
from typing import List
def to_number_or_str(value: str):
if value is None:
return None
try:
if re.match('^([-+])?\\d+$', value) is not None:
return int(value)
return float(value)
except ValueError:
return value
def compose_option(option: List[str]):
result = dict()
for o in option:
kv = o.split('=', 1)
key = kv[0]
value = kv[1] if len(kv) == 2 else None
keys = key.split('.')
cursor = result
for k in keys[:-1]:
last_cursor = cursor
cursor = cursor.get(k, None)
if cursor is None:
cursor = dict()
last_cursor[k] = cursor
cursor[keys[-1]] = to_number_or_str(value)
return result
# Setup code to construct valid arguments
option_list = [
"model.name=resnet50",
"model.layers=50",
"learning_rate=0.001",
"batch_size=32",
"optimizer.type=adam",
"optimizer.beta1=0.9",
"debug=true",
"epochs=100",
"nested.deep.value=42",
"flag"
]
ARGS = {
"option": option_list
}
- 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
|
| convert_bbox_to_z |
Ran ran; our contract draft was wrong, not the code |
PJunhyuk/exercise-pose-analyzer/sort.py code served (permissive licence) · get_code("38fac8a2c4b91f17") 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 (4, 1) as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import numpy as np
# The function takes a bbox in the form [x1, y1, x2, y2]
# which represents top-left and bottom-right corners of a bounding box
# Create a valid bounding box
# x1=10, y1=20, x2=50, y2=80
bbox = np.array([10, 20, 50, 80])
ARGS = {
"bbox": bbox
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- numpy — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type ndarray, ndim 2, dtype family float, shape (4, 1) — shape (4, 1) as a later run recorded it
- dtype family
- int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
- Environment
- image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
|
| convert_x_to_bbox |
Ran ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT) |
PJunhyuk/exercise-pose-analyzer/sort.py code served (permissive licence) · get_code("90e53239ac6a25c6") 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 (1, 5) as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import numpy as np
# The function takes:
# - x: an array-like in centre form [x, y, s, r] where x,y is center, s is scale, r is aspect ratio
# - score: optional score value (None or a number)
# Create a valid bounding box in centre form [x, y, s, r]
x = np.array([100.0, 150.0, 500.0, 0.5])
# Create a score value
score = 0.95
ARGS = {
"x": x,
"score": score,
}
- 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 (1, 5) — shape (1, 5) as a later run recorded it
- dtype family
- int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
- Environment
- image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
|
| data_to_input |
Ran ran on a synthesized input |
PJunhyuk/exercise-pose-analyzer/dataset/pose_dataset.py code served (permissive licence) · get_code("144eafc7b562df1f") 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 float, shape (1, 3, 4) as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import numpy as np
# The function takes a single parameter 'data' which it expands along axis 0
# and converts to float. We need to provide a numpy array or array-like object.
# Create a small sample numpy array
sample_data = np.array([[1, 2, 3, 4],
[5, 6, 7, 8],
[9, 10, 11, 12]])
ARGS = {
"data": sample_data
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- numpy — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type ndarray, ndim 3, dtype family float, shape (1, 3, 4) — shape (1, 3, 4) as a later run recorded it
- dtype family
- int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
- Environment
- image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
|
| data_to_input |
Ran ran on a synthesized input |
ZJX9999/art_track/src/dataset/pose.py code served (permissive licence) · get_code("d75be5d78f652ee8") 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 float, shape (3, 5, 4) as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import numpy as np
# Create sample data with shape (H, W, C) - height=5, width=4, channels=3
data = np.random.randn(5, 4, 3).astype(np.float32)
ARGS = {
"data": data
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- numpy — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type ndarray, ndim 3, dtype family float, shape (3, 5, 4) — shape (3, 5, 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
|
| ellipse_set |
Ran ran on a synthesized input |
PJunhyuk/exercise-pose-analyzer/exercise_analyzer.py code served (permissive licence) · get_code("39e4dc3dab3df99a") 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 torch
import numpy as np
torch.manual_seed(0)
# The function accesses person_conf_multi[people_i][point_i][0] and [1]
# This suggests a 3D structure: person_conf_multi is indexed by people_i,
# then by point_i, then by coordinate index (0 or 1 for x, y)
# We'll create a list of lists of coordinate pairs
person_conf_multi = [
# Person 0: multiple points with (x, y) coordinates
[
[10.0, 20.0],
[15.0, 25.0],
[30.0, 40.0],
],
# Person 1: multiple points with (x, y) coordinates
[
[50.0, 60.0],
[70.0, 80.0],
[100.0, 120.0],
]
]
people_i = 0
point_i = 1
ARGS = {
"person_conf_multi": person_conf_multi,
"people_i": people_i,
"point_i": point_i,
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- numpy, torch — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type tuple, ndim 1, dtype family float — a tuple output has no array shape of its own; none is stated
- dtype family
- int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
- Environment
- image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
|
| enclosing_rect |
Ran ran on a synthesized input |
ZJX9999/art_track/postprocess.py code served (permissive licence) · get_code("0743a5c972f71080") 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 1, dtype family float, shape (4,) as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import numpy as np
# Create a small set of 2D points
# The function accesses points[:, 0] and points[:, 1], so we need a 2D array
# with shape (N, 2) where N is the number of points
points = np.array([
[1.0, 2.0],
[5.0, 3.0],
[3.0, 7.0],
[2.0, 1.5]
], dtype=np.float32)
ARGS = {
"points": points
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- numpy — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type ndarray, ndim 1, dtype family float, shape (4,) — shape (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
|
| extend_crop |
Ran ran on a synthesized input |
PJunhyuk/exercise-pose-analyzer/dataset/pose_dataset.py code served (permissive licence) · get_code("1b3db5b8d828e015") 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 torch
import numpy as np
torch.manual_seed(0)
# Analyzing the function:
# - crop: appears to be a list/array with 4 elements (crop[0], crop[1], crop[2], crop[3])
# - crop_pad: a scalar value for padding
# - image_size: has indexing [2], [1] so it's a sequence with at least 3 elements
# image_size[2] is width dimension, image_size[1] is height dimension
crop = [10, 20, 50, 60] # [y_min, x_min, y_max, x_max] style coordinates
crop_pad = 5
image_size = [1, 100, 80] # [batch/channels, height, width]
ARGS = {
"crop": crop,
"crop_pad": crop_pad,
"image_size": image_size
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- numpy, torch — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type 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
|
| extend_crop |
Ran ran on a synthesized input |
ZJX9999/art_track/src/dataset/pose.py code served (permissive licence) · get_code("f242e354254a2599") 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 torch
torch.manual_seed(0)
# Analyze the function:
# - crop: list/array with 4 elements (indices 0,1,2,3) that get modified
# - crop_pad: numeric value for padding amount
# - image_size: tuple/list with at least 2 elements (indices [1] and [2])
# The function modifies crop in-place and returns it
# image_size is indexed as [1] and [2], suggesting it's (batch, height, width, ...) format
crop = [10, 20, 30, 40]
crop_pad = 5
image_size = (2, 100, 80) # (batch, height, width) - distinct sizes to probe later
ARGS = {
"crop": crop,
"crop_pad": crop_pad,
"image_size": image_size
}
- 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 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
|
| extract_cnn_output |
Ran ran on a synthesized input |
PJunhyuk/exercise-pose-analyzer/nnet/predict.py code served (permissive licence) · get_code("ffbb6926b99ca572") 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
class Config:
def __init__(self):
self.location_refinement = True
self.pairwise_predict = True
self.locref_stdev = 0.5
self.num_joints = 5
# Create outputs_np dictionary with proper shapes
# scmap: (batch, height, width, num_joints) -> (2, 4, 3, 5)
# locref: (batch, height, width, num_joints*2) -> (2, 4, 3, 10)
# pairwise_pred: (batch, height, width, num_pairs*2) -> (2, 4, 3, 16)
outputs_np = {
'part_prob': np.random.randn(2, 4, 3, 5).astype(np.float32),
'locref': np.random.randn(2, 4, 3, 10).astype(np.float32),
'pairwise_pred': np.random.randn(2, 4, 3, 16).astype(np.float32),
}
cfg = Config()
# Create pairwise_stats dictionary
# For each pair, store mean and std for x and y offsets
pairwise_stats = {
(0, 1): {'mean': [0.1, 0.2], 'std': [0.5, 0.6]},
(1, 2): {'mean': [0.15, 0.25], 'std': [0.55, 0.65]},
(2, 3): {'mean': [0.12, 0.22], 'std': [0.52, 0.62]},
(3, 4): {'mean': [0.18, 0.28], 'std': [0.58, 0.68]},
}
ARGS = {
'outputs_np': outputs_np,
'cfg': cfg,
'pairwise_stats': pairwise_stats,
}
- 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
|
| iou |
Ran ran, violated the contract we drafted |
PJunhyuk/exercise-pose-analyzer/sort.py code served (permissive licence) · get_code("22b6104aae1c81b4") 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 numpy as np
from numba import jit
@jit
def iou(bb_test, bb_gt):
"""
Computes IUO between two bboxes in the form [x1,y1,x2,y2]
"""
xx1 = np.maximum(bb_test[0], bb_gt[0])
yy1 = np.maximum(bb_test[1], bb_gt[1])
xx2 = np.minimum(bb_test[2], bb_gt[2])
yy2 = np.minimum(bb_test[3], bb_gt[3])
w = np.maximum(0.0, xx2 - xx1)
h = np.maximum(0.0, yy2 - yy1)
wh = w * h
o = wh / ((bb_test[2] - bb_test[0]) * (bb_test[3] - bb_test[1]) + (bb_gt[2] - bb_gt[0]) * (bb_gt[3] - bb_gt[1]) - wh)
return o
# Create test bounding boxes in format [x1, y1, x2, y2]
# bb_test: bounding box 1
bb_test = np.array([10.0, 20.0, 50.0, 80.0], dtype=np.float64)
# bb_gt: ground truth bounding box
bb_gt = np.array([30.0, 40.0, 60.0, 100.0], dtype=np.float64)
ARGS = {
"bb_test": bb_test,
"bb_gt": bb_gt,
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- numba, numpy — 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
|
| load_config |
Ran ran on a synthesized input |
ZJX9999/art_track/config.py code served (permissive licence) · get_code("b95c23cc4a08da33") 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 EasyDict. 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 yaml
import tempfile
from easydict import EasyDict as edict
# Create a temporary YAML config file
temp_dir = tempfile.mkdtemp()
config_file = os.path.join(temp_dir, 'pose_cfg.yaml')
# Write a minimal valid YAML config
config_content = """
context:
mode: 1
device_target: 'GPU'
stride: 8.0
weigh_only_present_joints: false
mean_pixel: [123.68, 116.779, 103.939]
global_scale: 1.0
location_refinement: false
locref_stdev: 7.2801
locref_loss_weight: 1.0
locref_huber_loss: true
intermediate_supervision: false
intermediate_supervision_layer: 12
intermediate_supervision_input: 1024
mirror: false
crop: false
crop_pad: 0
scoremap_dir: 'out/test'
dataset:
path: ''
type: ''
parallel: 1
batch_size: 1
shuffle: false
mirror: false
padding: false
use_gt_segm: false
sparse_graph: []
pairwise_stats_collect: false
pairwise_stats_fn: 'pairwise_stats.mat'
pairwise_predict: false
pairwise_huber_loss: true
pairwise_loss_weight: 1.0
tensorflow_pairwise_order: true
"""
with open(config_file, 'w', encoding='utf-8') as f:
f.write(config_content)
ARGS = {
'filename': config_file
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- easydict, yaml — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type EasyDict — a EasyDict output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a EasyDict 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
|
| load_config |
Ran ran on a synthesized input |
ZJX9999/art_track/src/config.py code served (permissive licence) · get_code("0cfdaa614725eafc") 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 EasyDict. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import torch
import yaml
import tempfile
import os
from easydict import EasyDict as edict
# Create a temporary YAML config file
yaml_content = """
context:
mode: 2
device_target: 'CPU'
stride: 16.0
weigh_only_present_joints: true
mean_pixel: [120.0, 115.0, 100.0]
global_scale: 2.0
location_refinement: true
locref_stdev: 5.0
locref_loss_weight: 0.5
locref_huber_loss: false
intermediate_supervision: true
intermediate_supervision_layer: 10
intermediate_supervision_input: 512
mirror: true
crop: true
crop_pad: 5
scoremap_dir: 'out/custom_eval'
dataset:
path: '/path/to/dataset'
type: 'custom'
parallel: 4
batch_size: 32
shuffle: true
mirror: true
padding: true
use_gt_segm: true
sparse_graph: [1, 2, 3]
pairwise_stats_collect: true
pairwise_stats_fn: 'custom_stats.mat'
pairwise_predict: true
pairwise_huber_loss: false
pairwise_loss_weight: 0.8
tensorflow_pairwise_order: false
"""
# Write to a temporary file
temp_fd, temp_path = tempfile.mkstemp(suffix='.yaml', text=True)
try:
os.write(temp_fd, yaml_content.encode('utf-8'))
finally:
os.close(temp_fd)
# Define ARGS
ARGS = {
'filename': temp_path
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- easydict, torch, yaml — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type EasyDict — a EasyDict output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a EasyDict 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
|
| logit_transform |
Ran ran, violated the contract we drafted |
yangyucheng000/ArtTrack/src/multiperson/predict.py pointer only (licence: NONE) · get_code("9dcc40b6372ecabe") How it ranThe body of this sample is withheld: GitHub detected no licence in this paper's repository, yangyucheng000/ArtTrack when it was checked. The setup block that called it is withheld with it, because it is written against that body. source_path and origin say where the code lives, to read under the repository's own terms. A run is recorded. |
| mirror_joints_map |
Ran ran on a synthesized input |
PJunhyuk/exercise-pose-analyzer/dataset/pose_dataset.py code served (permissive licence) · get_code("455454050a783c85") 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 1, dtype family int, shape (6,) as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import numpy as np
# Construct arguments for mirror_joints_map
# The function takes:
# - all_joints: list of tuples representing symmetric joint pairs
# - num_joints: total number of joints
all_joints = [(0, 1), (2, 3), (4, 5)]
num_joints = 6
ARGS = {
"all_joints": all_joints,
"num_joints": num_joints,
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- numpy — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type ndarray, ndim 1, dtype family int, shape (6,) — shape (6,) 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
|
| mirror_joints_map |
Ran ran on a synthesized input |
ZJX9999/art_track/src/dataset/pose.py code served (permissive licence) · get_code("87eb7cbd676eabd1") 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 1, dtype family int, shape (6,) 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
ARGS = {
"all_joints": [
(0, 1),
(2, 3),
(4, 5)
],
"num_joints": 6
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- numpy — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type ndarray, ndim 1, dtype family int, shape (6,) — shape (6,) 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
|
| rect_size |
Ran ran on a synthesized input |
ZJX9999/art_track/postprocess.py code served (permissive licence) · get_code("759f51295b39a331") 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 1, dtype family int, shape (2,) as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import numpy as np
def rect_size(rect):
"""
get rectangle size
"""
return np.array([rect[2] - rect[0], rect[3] - rect[1]])
# rect is expected to be a sequence-like object with at least 4 elements
# where indices 0,2 represent x-coordinates and indices 1,3 represent y-coordinates
# The function computes width (rect[2] - rect[0]) and height (rect[3] - rect[1])
ARGS = {
"rect": [10, 20, 50, 80]
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- numpy — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type ndarray, ndim 1, dtype family int, shape (2,) — shape (2,) as a later run recorded it
- dtype family
- int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
- Environment
- image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
|
| resize_video |
Ran ran on a synthesized input |
PJunhyuk/people-counting-pose/preprocessing.py code served (permissive licence) · get_code("2bf343ed82c721e8") 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 MockVideo. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import torch
from PIL import Image
import numpy as np
# Create a minimal stand-in class that mimics video object behavior
class MockVideo:
def __init__(self, width=640, height=480):
self.size = (width, height)
def resize(self, width):
# Calculate new height maintaining aspect ratio
aspect_ratio = self.size[1] / self.size[0]
new_height = int(width * aspect_ratio)
self.size = (width, new_height)
return self
# Create a mock video object
video = MockVideo(width=640, height=480)
ARGS = {
'video': video,
'video_width': 320
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- PIL, numpy, torch — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type MockVideo — a MockVideo output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a MockVideo 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
|
| to_number_or_str |
Ran ran on a synthesized input |
ZJX9999/art_track/src/args_util.py code served (permissive licence) · get_code("2c01b911ff424073") 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 re
def to_number_or_str(value: str):
if value is None:
return None
try:
if re.match('^([-+])?\\d+$', value) is not None:
return int(value)
return float(value)
except ValueError:
return value
# Test with various string inputs
ARGS = {
"value": "42"
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- none outside the standard library — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type int, ndim 0, dtype family int, shape () — shape () as a later run recorded it
- dtype family
- int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
- Environment
- image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
|
| get_person_conf_single |
Not yet run unverified (harvested, no recorded run) |
yangyucheng000/ArtTrack/src/multiperson/predict.py pointer only (licence: NONE) · get_code("ce65f08dd190b533") How it ranThe body of this sample is withheld: GitHub detected no licence in this paper's repository, yangyucheng000/ArtTrack when it was checked. The setup block that called it is withheld with it, because it is written against that body. source_path and origin say where the code lives, to read under the repository's own terms. No invocation recorded. |
| huber_loss |
Not yet run unverified (harvested, no recorded run) |
PJunhyuk/exercise-pose-analyzer/nnet/losses.py code served (permissive licence) · get_code("582847866fc1e8a4") How it ran |
| read_video |
Not yet run unverified (harvested, no recorded run) |
PJunhyuk/people-counting-pose/video_pose_ed.py code served (permissive licence) · get_code("4bf0c64eeb36b4bf") How it ran |
| read_video |
Not yet run unverified (harvested, no recorded run) |
janbertelngo/count-people/preprocessing.py code served (permissive licence) · get_code("e9345e7cb5d067a5") How it ran |
| video2posevideo |
Not yet run unverified (harvested, no recorded run) |
PJunhyuk/people-counting-pose/video_pose_ed.py code served (permissive licence) · get_code("fe21ecf97eafb3e6") How it ran |