SYNTOLOGY HomeExplorerAtlasCodeMethodologyAboutDevelopersFeedPricing
Paper · 1612.01465 · 2016

ArtTrack: Articulated Multi-person Tracking in the Wild

arXiv · PDF · Open in the Atlas

Code that ran

24 of 29 samples (functions and classes) lifted from this paper's linked repositories executed on a synthesized input in Syntology's jail (0 of them constructed an object rather than computing a result; 0 honoured the contract we drafted, 2 violated it and 20 have no contract verdict; 2 failures of our instrument; 5 no recorded run), measured 2026-11-22; repository links from the Papers with Code archive attributed under CC BY-SA, no affiliation; bodies inline only under a permissive licence as GitHub detects it. Not a reproduction of the paper's results.

"Ran" means the function executed on a synthesized input and returned a value. It is not a reproduction of the paper's results. This record, dated, as JSON: /api/ran/1612.01465.json · badge: /api/ran/1612.01465.svg

Each repository's role is a label: a classifier's output recorded on the link, or, where no role is recorded, what the Papers with Code archive marked. The line under it names its basis. Neither says who wrote the code.

RepositoryRoleRan
ZJX9999/art_track community (classifier label)
classifier basis not recorded on the link
12 ran · 0 no recorded run
PJunhyuk/exercise-pose-analyzer community (classifier label)
classifier basis not recorded on the link
9 ran · 1 no recorded run
PJunhyuk/people-counting-pose community (classifier label)
classifier basis not recorded on the link
2 ran · 2 no recorded run
yangyucheng000/ArtTrack reimplementation (classifier label)
classifier basis: classifier_2025
1 ran · 1 no recorded run
janbertelngo/count-people community (classifier label)
classifier basis not recorded on the link
0 ran · 1 no recorded run
FunctionStatusWhere it lives
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 ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned ndarray, ndim 2, dtype family float, shape (3, 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 ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned ndarray, ndim 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 ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned 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 ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned 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 ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned 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 ran

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

import 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 ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned ndarray, ndim 2, dtype family float, shape (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 ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned ndarray, ndim 2, dtype family float, shape (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 ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned ndarray, ndim 3, dtype family float, shape (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 ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned ndarray, ndim 3, dtype family float, shape (3, 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 ran

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

import torch
import numpy as np

torch.manual_seed(0)

# The function 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 ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned ndarray, ndim 1, dtype family float, shape (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 ran

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

import 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 ran

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

import 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 ran

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

import numpy as np

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 ran

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

import 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 ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned 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 ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned 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 ran

The 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 ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned ndarray, ndim 1, dtype family 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 ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned ndarray, ndim 1, dtype family 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 ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned ndarray, ndim 1, dtype family 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 ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned 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 ran

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

import 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 ran

The 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

no invocation recorded.

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

no invocation recorded.

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

no invocation recorded.

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

no invocation recorded.

Also present in other papers' code

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

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

FunctionAlso present inEarliest-datedOthers named
convert_bbox_to_z 4 other papers
1 dated earlier, 3 later
1602.00763 (2016-02)
Simple Online and Realtime Tracking
1906.07155 (2019-06)
MMDetection: Open MMLab Detection Toolbox and Benchmark
and 1 more not named here
convert_x_to_bbox 4 other papers
1 dated earlier, 3 later
1602.00763 (2016-02)
Simple Online and Realtime Tracking
1906.07155 (2019-06)
MMDetection: Open MMLab Detection Toolbox and Benchmark
and 1 more not named here
iou 3 other papers
1 dated earlier, 2 later
1602.00763 (2016-02)
Simple Online and Realtime Tracking
1906.07155 (2019-06)
MMDetection: Open MMLab Detection Toolbox and Benchmark

Presence, not direction: an identical function body in two papers' repositories does not say who wrote it, which came from which, or that either paper's method rests on it. Matching is exact after normalisation, so a renamed or edited function is not matched. Dates are when papers appeared, not when code was written. Only .py files the harvester lifted are covered; notebooks are not read. A new-style arXiv id YYMM.NNNN dates a paper to the month 20YY-MM; otherwise Paper.year dates it to the year; otherwise it is undated. Dates are when the paper appeared, not when the code was written. Read 2026-11-22.

Repositories linked to this paper

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

Abstract

In this paper we propose an approach for articulated tracking of multiple people in unconstrained videos. Our starting point is a model that resembles existing architectures for single-frame pose estimation but is substantially faster. We achieve this in two ways: (1) by simplifying and sparsifying the body-part relationship graph and leveraging recent methods for faster inference, and (2) by offloading a substantial share of computation onto a feed-forward convolutional architecture that is able to detect and associate body joints of the same person even in clutter. We use this model to generate proposals for body joint locations and formulate articulated tracking as spatio-temporal grouping of such proposals. This allows to jointly solve the association problem for all people in the scene by propagating evidence from strong detections through time and enforcing constraints that each proposal can be assigned to one person only. We report results on a public MPII Human Pose benchmark and on a new MPII Video Pose dataset of image sequences with multiple people. We demonstrate that our model achieves state-of-the-art results while using only a fraction of time and is able to leverage temporal information to improve state-of-the-art for crowded scenes.

For agents

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

get_harvested_code_for_paper("1612.01465")
get_code_for_paper("1612.01465")
have("1612.01465")

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

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

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

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

Connect an agent — have() is free.