| arrayCast |
Ran ran on a synthesized input |
ibm/max-human-pose-estimator/core/tf_pose/slidingwindow/ArrayUtils.py code served (permissive licence) · get_code("20375b6e697cb883") How it ranRan in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned ndarray, ndim 2, dtype family float, shape (2, 4) as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import numpy as np
import torch
import math
import mmap
import tempfile
import psutil
torch.manual_seed(0)
# Create a source numpy array with a specific shape and dtype
source_array = np.array([[1.5, 2.3, 3.1, 4.7],
[5.2, 6.9, 7.1, 8.4]], dtype=np.float64)
# Define the target dtype for casting
target_dtype = np.float32
ARGS = {
"source": source_array,
"dtype": target_dtype
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- numpy, psutil, torch — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type ndarray, ndim 2, dtype family float, shape (2, 4) — shape (2, 4) as a later run recorded it
- dtype family
- int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
- Environment
- image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
|
| arrayFactory |
Ran ran on a synthesized input |
ibm/max-human-pose-estimator/core/tf_pose/slidingwindow/ArrayUtils.py code served (permissive licence) · get_code("967290f028bec7f8") 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 (4, 5, 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 math
import mmap
import tempfile
import numpy as np
import psutil
def _requiredSize(shape, dtype):
"""
Determines the number of bytes required to store a NumPy array with
the specified shape and datatype.
"""
return math.floor(np.prod(np.asarray(shape, dtype=np.uint64)) * np.dtype(dtype).itemsize)
class TempfileBackedArray(np.ndarray):
"""
A NumPy ndarray that uses a memory-mapped temp file as its backing
"""
def __new__(subtype, shape, dtype=float, buffer=None, offset=0, strides=None, order=None, info=None):
numBytes = _requiredSize(shape, dtype)
tempFile = tempfile.TemporaryFile()
tempFile.truncate(numBytes)
buf = mmap.mmap(tempFile.fileno(), numBytes, access=mmap.ACCESS_WRITE)
obj = super(TempfileBackedArray, subtype).__new__(subtype, shape, dtype, buf, 0, None, order)
obj._file = tempFile
return obj
def __array_finalize__(self, obj):
if obj is None:
return
self._file = getattr(obj, '_file', None)
def arrayFactory(shape, dtype=float):
"""
Creates a new ndarray of the specified shape and datatype, storing
it in memory if there is sufficient available space or else using
a memory-mapped temporary file to provide the underlying buffer.
"""
requiredBytes = _requiredSize(shape, dtype)
vmem = psutil.virtual_memory()
if vmem.available > requiredBytes:
return np.ndarray(shape=shape, dtype=dtype)
else:
return TempfileBackedArray(shape=shape, dtype=dtype)
ARGS = {
"shape": (4, 5, 6),
"dtype": np.float32
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- numpy, psutil — 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 (4, 5, 6) — shape (4, 5, 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
|
| batchWindows |
Ran ran on a synthesized input |
ibm/max-human-pose-estimator/core/tf_pose/slidingwindow/Batching.py code served (permissive licence) · get_code("92fd1e2b70b24c05") How it ranRan in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned list, ndim 3, dtype family 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 numpy as np
# Create sample windows data
# windows should be a list or array-like structure that can be converted to numpy array
windows = [
np.array([1, 2, 3, 4]),
np.array([5, 6, 7, 8]),
np.array([9, 10, 11, 12]),
np.array([13, 14, 15, 16]),
np.array([17, 18, 19, 20]),
np.array([21, 22, 23, 24]),
]
# batchSize should be an integer that divides evenly into len(windows)
batchSize = 2
ARGS = {
"windows": windows,
"batchSize": batchSize,
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- numpy — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type list, ndim 3, 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
|
| compute_gt_teacher |
Ran ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT) |
DavHoffmann/LearningToTrainWithSyntheticHumans/tf_pose/train_with_adversarial_teacher.py pointer only (licence: NOASSERTION) · get_code("f4d54c84f9d6d11f") How it ranThe body of this sample is withheld: GitHub could not classify the licence of this paper's repository, DavHoffmann/LearningToTrainWithSyntheticHumans (NOASSERTION). The setup block that called it is withheld with it, because it is written against that body. source_path and origin say where the code lives, to read under the repository's own terms. A run is recorded. |
| cropRect |
Ran ran on a synthesized input |
ibm/max-human-pose-estimator/core/tf_pose/slidingwindow/RectangleUtils.py code served (permissive licence) · get_code("eb150ddc7184f446") How it ranRan in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned tuple, ndim 1, dtype family int; no output shape is stated. The image it ran in was not recorded. If your copy returns the same type and ndim on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import torch
torch.manual_seed(0)
# rect is a tuple of (x, y, w, h)
rect = (10, 20, 100, 50)
# cropTop, cropBottom, cropLeft, cropRight are pixel values
cropTop = 5
cropBottom = 3
cropLeft = 2
cropRight = 4
ARGS = {
"rect": rect,
"cropTop": cropTop,
"cropBottom": cropBottom,
"cropLeft": cropLeft,
"cropRight": cropRight,
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- torch — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type tuple, ndim 1, dtype family int — a tuple output has no array shape of its own; none is stated
- dtype family
- int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
- Environment
- image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
|
| cropRectEqually |
Ran ran on a synthesized input |
ibm/max-human-pose-estimator/core/tf_pose/slidingwindow/RectangleUtils.py code served (permissive licence) · get_code("630ac0a9f50488c4") How it ranRan in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned tuple, ndim 1, dtype family int; no output shape is stated. The image it ran in was not recorded. If your copy returns the same type and ndim on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import torch
# Define the arguments for cropRectEqually
rect = (10, 20, 100, 80) # (x, y, w, h) - a rectangle at (10,20) with width 100 and height 80
cropping = 5 # crop 5 pixels from all sides
ARGS = {
"rect": rect,
"cropping": cropping
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- torch — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type tuple, ndim 1, dtype family int — a tuple output has no array shape of its own; none is stated
- dtype family
- int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
- Environment
- image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
|
| generate |
Ran ran on a synthesized input |
ibm/max-human-pose-estimator/core/tf_pose/slidingwindow/SlidingWindow.py code served (permissive licence) · get_code("cdb1c9715688f9a1") How it ranRan in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned list, ndim 1, dtype family float; no output shape is stated. The image it ran in was not recorded. If your copy returns the same type and ndim on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import torch
import numpy as np
import math
torch.manual_seed(0)
class DimOrder(object):
"""
Represents the order of the dimensions in a dataset's shape.
"""
ChannelHeightWidth = ['c', 'h', 'w']
HeightWidthChannel = ['h', 'w', 'c']
class SlidingWindow(object):
"""
Represents a single window into a larger dataset.
"""
def __init__(self, x, y, w, h, dimOrder, transform=None):
"""
Creates a new window with the specified dimensions and transform
"""
self.x = x
self.y = y
self.w = w
self.h = h
self.dimOrder = dimOrder
self.transform = transform
def apply(self, matrix):
"""
Slices the supplied matrix and applies any transform bound to this window
"""
view = matrix[self.indices()]
return self.transform(view) if self.transform is not None else view
def getRect(self):
"""
Returns the window bounds as a tuple of (x,y,w,h)
"""
return (self.x, self.y, self.w, self.h)
def setRect(self, rect):
"""
Sets the window bounds from a tuple of (x,y,w,h)
"""
self.x, self.y, self.w, self.h = rect
def indices(self, includeChannel=True):
"""
Retrieves the indices for this window as a tuple of slices
"""
if self.dimOrder == DimOrder.HeightWidthChannel:
return (slice(self.y, self.y + self.h), slice(self.x, self.x + self.w))
elif self.dimOrder == DimOrder.ChannelHeightWidth:
if includeChannel is True:
return (slice(None, None), slice(self.y, self.y + self.h), slice(self.x, self.x + self.w))
else:
return (slice(self.y, self.y + self.h), slice(self.x, self.x + self.w))
else:
raise ValueError('Unsupported order of dimensions: ' + str(self.dimOrder))
def __str__(self):
return '(' + str(self.x) + ',' + str(self.y) + ',' + str(self.w) + ',' + str(self.h) + ')'
def __repr__(self):
return self.__str__()
def generateForSize(width, height, dimOrder, maxWindowSizeW, maxWindowSizeH, overlapPercent, transforms=[]):
"""
Generates a set of sliding windows for a dataset with the specified dimensions and order.
"""
windowSizeX = min(maxWindowSizeW, width)
windowSizeY = min(maxWindowSizeH, height)
windowOverlapX = int(math.floor(windowSizeX * overlapPercent))
windowOverlapY = int(math.floor(windowSizeY * overlapPercent))
stepSizeX = windowSizeX - windowOverlapX
stepSizeY = windowSizeY - windowOverlapY
lastX = width - windowSizeX
lastY = height - windowSizeY
xOffsets = list(range(0, lastX + 1, stepSizeX))
yOffsets = list(range(0, lastY + 1, stepSizeY))
if len(xOffsets) == 0 or xOffsets[-1] != lastX:
xOffsets.append(lastX)
if len(yOffsets) == 0 or yOffsets[-1] != lastY:
yOffsets.append(lastY)
windows = []
for xOffset in xOffsets:
for yOffset in yOffsets:
for transform in [None] + transforms:
windows.append(SlidingWindow(x=xOffset, y=yOffset, w=windowSizeX, h=windowSizeY, dimOrder=dimOrder, transform=transform))
return windows
def generate(data, dimOrder, maxWindowSizeW, maxWindowSizeH, overlapPercent, transforms=[]):
"""
Generates a set of sliding windows for the specified dataset.
"""
width = data.shape[dimOrder.index('w')]
height = data.shape[dimOrder.index('h')]
return generateForSize(width, height, dimOrder, maxWindowSizeW, maxWindowSizeH, overlapPercent, transforms)
# Create a simple transform function
def simple_transform(x):
return x * 2
# Create test data with ChannelHeightWidth ordering (c, h, w)
# Shape: (channels=3, height=8, width=16)
data = torch.randn(3, 8, 16)
ARGS = {
'data': data,
'dimOrder': DimOrder.ChannelHeightWidth,
'maxWindowSizeW': 4,
'maxWindowSizeH': 4,
'overlapPercent': 0.25,
'transforms': [simple_transform]
}
- 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 float — a list output has no array shape of its own; none is stated
- dtype family
- int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
- Environment
- image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
|
| generateForSize |
Ran ran on a synthesized input |
ibm/max-human-pose-estimator/core/tf_pose/slidingwindow/SlidingWindow.py code served (permissive licence) · get_code("93c5229a4050e760") How it ranRan in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned list, ndim 1, dtype family float; no output shape is stated. The image it ran in was not recorded. If your copy returns the same type and ndim on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import math
class DimOrder(object):
"""
Represents the order of the dimensions in a dataset's shape.
"""
ChannelHeightWidth = ['c', 'h', 'w']
HeightWidthChannel = ['h', 'w', 'c']
class SlidingWindow(object):
"""
Represents a single window into a larger dataset.
"""
def __init__(self, x, y, w, h, dimOrder, transform=None):
"""
Creates a new window with the specified dimensions and transform
"""
self.x = x
self.y = y
self.w = w
self.h = h
self.dimOrder = dimOrder
self.transform = transform
def apply(self, matrix):
"""
Slices the supplied matrix and applies any transform bound to this window
"""
view = matrix[self.indices()]
return self.transform(view) if self.transform is not None else view
def getRect(self):
"""
Returns the window bounds as a tuple of (x,y,w,h)
"""
return (self.x, self.y, self.w, self.h)
def setRect(self, rect):
"""
Sets the window bounds from a tuple of (x,y,w,h)
"""
self.x, self.y, self.w, self.h = rect
def indices(self, includeChannel=True):
"""
Retrieves the indices for this window as a tuple of slices
"""
if self.dimOrder == DimOrder.HeightWidthChannel:
return (slice(self.y, self.y + self.h), slice(self.x, self.x + self.w))
elif self.dimOrder == DimOrder.ChannelHeightWidth:
if includeChannel is True:
return (slice(None, None), slice(self.y, self.y + self.h), slice(self.x, self.x + self.w))
else:
return (slice(self.y, self.y + self.h), slice(self.x, self.x + self.w))
else:
raise ValueError('Unsupported order of dimensions: ' + str(self.dimOrder))
def __str__(self):
return '(' + str(self.x) + ',' + str(self.y) + ',' + str(self.w) + ',' + str(self.h) + ')'
def __repr__(self):
return self.__str__()
def generateForSize(width, height, dimOrder, maxWindowSizeW, maxWindowSizeH, overlapPercent, transforms=[]):
"""
Generates a set of sliding windows for a dataset with the specified dimensions and order.
"""
windowSizeX = min(maxWindowSizeW, width)
windowSizeY = min(maxWindowSizeH, height)
windowOverlapX = int(math.floor(windowSizeX * overlapPercent))
windowOverlapY = int(math.floor(windowSizeY * overlapPercent))
stepSizeX = windowSizeX - windowOverlapX
stepSizeY = windowSizeY - windowOverlapY
lastX = width - windowSizeX
lastY = height - windowSizeY
xOffsets = list(range(0, lastX + 1, stepSizeX))
yOffsets = list(range(0, lastY + 1, stepSizeY))
if len(xOffsets) == 0 or xOffsets[-1] != lastX:
xOffsets.append(lastX)
if len(yOffsets) == 0 or yOffsets[-1] != lastY:
yOffsets.append(lastY)
windows = []
for xOffset in xOffsets:
for yOffset in yOffsets:
for transform in [None] + transforms:
windows.append(SlidingWindow(x=xOffset, y=yOffset, w=windowSizeX, h=windowSizeY, dimOrder=dimOrder, transform=transform))
return windows
def simple_transform(x):
return x * 2
ARGS = {
'width': 64,
'height': 48,
'dimOrder': DimOrder.ChannelHeightWidth,
'maxWindowSizeW': 32,
'maxWindowSizeH': 24,
'overlapPercent': 0.25,
'transforms': [simple_transform]
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- none outside the standard library — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type list, ndim 1, dtype family float — a list output has no array shape of its own; none is stated
- dtype family
- int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
- Environment
- image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
|
| get_sample_images |
Ran ran on a synthesized input |
ibm/max-human-pose-estimator/core/tf_pose/common.py code served (permissive licence) · get_code("1cb22812d63a8d83") 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 4, 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 cv2
import numpy as np
import tempfile
import os
# Create a temporary directory and a simple test image
temp_dir = tempfile.mkdtemp()
image_path = os.path.join(temp_dir, 'Pilots.jpg')
# Create a minimal valid JPEG image (100x100 RGB)
dummy_image = np.random.randint(0, 256, (100, 100, 3), dtype=np.uint8)
cv2.imwrite(image_path, dummy_image)
# Mock the './images/Pilots.jpg' path by monkey-patching cv2.imread
original_imread = cv2.imread
def mock_imread(path, flags=cv2.IMREAD_COLOR):
if 'Pilots.jpg' in path:
return original_imread(image_path, flags)
return original_imread(path, flags)
cv2.imread = mock_imread
ARGS = {
'w': 640,
'h': 480
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- cv2, numpy — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type list, ndim 4, 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
|
| layer |
Ran ran; our contract draft was wrong, not the code |
ibm/max-human-pose-estimator/core/tf_pose/tensblur/smoother.py code served (permissive licence) · get_code("1fb38eb9d6522fb0") 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 function. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import torch
import torch.nn as nn
torch.manual_seed(0)
class MockLayer(nn.Module):
def __init__(self):
super().__init__()
self.terminals = []
self.layers = {}
self._name_counter = {}
def get_unique_name(self, name):
if name not in self._name_counter:
self._name_counter[name] = 0
else:
self._name_counter[name] += 1
return f"{name}_{self._name_counter[name]}"
def feed(self, output):
self.terminals = [output]
def mock_op(self, layer_input, *args, **kwargs):
"""A simple mock operation that returns the input or processes it"""
if isinstance(layer_input, list):
return torch.cat(layer_input, dim=1)
else:
return layer_input * 2.0
mock_instance = MockLayer()
mock_instance.terminals = [torch.randn(2, 4)]
ARGS = {
'op': mock_op
}
- 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 function — a function output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a function 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
|
| model_wh |
Ran ran on a synthesized input |
ibm/max-human-pose-estimator/core/tf_pose/networks.py code served (permissive licence) · get_code("f8b79dbb86b46205") How it ranRan in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned tuple, ndim 1, dtype family int; no output shape is stated. The image it ran in was not recorded. If your copy returns the same type and ndim on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import torch
import numpy as np
torch.manual_seed(0)
# The function model_wh takes a resolution_str parameter
# It parses a string in format "WIDTHxHEIGHT" and validates that both are multiples of 16
# Then returns a tuple of (width, height) as integers
# Valid resolution string with dimensions that are multiples of 16
resolution_str = "320x240"
ARGS = {
"resolution_str": resolution_str
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- numpy, torch — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type tuple, ndim 1, dtype family int — a tuple output has no array shape of its own; none is stated
- dtype family
- int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
- Environment
- image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
|
| normalize |
Ran ran, violated the contract we drafted |
Xingyu-Romantic/RMPose_PAF/testing/test_pose.py pointer only (licence: NONE) · get_code("9d8d1b763badb5e7") How it ranThe body of this sample is withheld: GitHub detected no licence in this paper's repository, Xingyu-Romantic/RMPose_PAF 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. |
| padRect |
Ran ran on a synthesized input |
ibm/max-human-pose-estimator/core/tf_pose/slidingwindow/RectangleUtils.py code served (permissive licence) · get_code("d8dbe9ff57d30fbc") How it ranRan in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned tuple, ndim 1, dtype family int; no output shape is stated. The image it ran in was not recorded. If your copy returns the same type and ndim on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import torch
import numpy as np
# Analyze the function:
# - rect: tuple of (x, y, w, h) - rectangle coordinates and dimensions
# - padTop, padBottom, padLeft, padRight: integers for padding amounts
# - bounds: tuple with at least 2 elements (bounds[0] and bounds[1])
# - clipExcess: boolean flag
# The function modifies a rectangle by padding it and clipping/adjusting to bounds
# bounds appears to be (height, width) based on the logic:
# overflowY = max(0, y + h - bounds[0]) # compared against bounds[0]
# overflowX = max(0, x + w - bounds[1]) # compared against bounds[1]
ARGS = {
"rect": (10, 20, 50, 60), # (x, y, w, h) - a rectangle at position (10,20) with width 50, height 60
"padTop": 5,
"padBottom": 5,
"padLeft": 3,
"padRight": 3,
"bounds": (100, 100), # (max_height, max_width) - the bounding area
"clipExcess": True
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- numpy, torch — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type tuple, ndim 1, dtype family int — a tuple output has no array shape of its own; none is stated
- dtype family
- int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
- Environment
- image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
|
| padRightDownCorner |
Ran ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT) |
Xingyu-Romantic/RMPose_PAF/testing/test_pose.py pointer only (licence: NONE) · get_code("1273c2cd8619f6cb") How it ranThe body of this sample is withheld: GitHub detected no licence in this paper's repository, Xingyu-Romantic/RMPose_PAF 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. |
| plot_result |
Ran ran on a synthesized input |
MSeeker1340/Vision2018-Pose/src/plot.py code served (permissive licence) · get_code("822b0c684ba9eba6") 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 (224, 224, 3) as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import numpy as np
# Create a sample 3D array with shape (height, width, channels)
# The function will extract channel f and resize it to (224, 224)
y = np.random.rand(128, 128, 5).astype(np.float32)
# f is the channel index to extract
f = 2
ARGS = {
"y": y,
"f": f,
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- numpy, skimage — 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 (224, 224, 3) — shape (224, 224, 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
|
| read_imgfile |
Ran ran on a synthesized input |
ibm/max-human-pose-estimator/core/tf_pose/common.py code served (permissive licence) · get_code("1440a7103327c0de") How it ranRan in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned ndarray, ndim 3, dtype family int, shape (6, 8, 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 tempfile
import cv2
import numpy as np
# Create a temporary image file for testing
with tempfile.NamedTemporaryFile(suffix='.jpg', delete=False) as tmp:
# Create a small test image (3x4 RGB)
test_image = np.random.randint(0, 256, (3, 4, 3), dtype=np.uint8)
cv2.imwrite(tmp.name, test_image)
temp_path = tmp.name
ARGS = {
'path': temp_path,
'width': 8,
'height': 6
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- cv2, numpy — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type ndarray, ndim 3, dtype family int, shape (6, 8, 3) — shape (6, 8, 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
|
| round_int |
Ran ran, honoured the contract we drafted |
DavHoffmann/LearningToTrainWithSyntheticHumans/tf_pose/eval_MPI.py pointer only (licence: NOASSERTION) · get_code("244255938544c7a6") How it ranThe body of this sample is withheld: GitHub could not classify the licence of this paper's repository, DavHoffmann/LearningToTrainWithSyntheticHumans (NOASSERTION). The setup block that called it is withheld with it, because it is written against that body. source_path and origin say where the code lives, to read under the repository's own terms. A run is recorded. |
| zerosFactory |
Ran ran on a synthesized input |
ibm/max-human-pose-estimator/core/tf_pose/slidingwindow/ArrayUtils.py code served (permissive licence) · get_code("e25580edeb9875ea") 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 (4, 5, 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 math
import mmap
import tempfile
import numpy as np
import psutil
def _requiredSize(shape, dtype):
"""
Determines the number of bytes required to store a NumPy array with
the specified shape and datatype.
"""
return math.floor(np.prod(np.asarray(shape, dtype=np.uint64)) * np.dtype(dtype).itemsize)
class TempfileBackedArray(np.ndarray):
"""
A NumPy ndarray that uses a memory-mapped temp file as its backing
"""
def __new__(subtype, shape, dtype=float, buffer=None, offset=0, strides=None, order=None, info=None):
numBytes = _requiredSize(shape, dtype)
tempFile = tempfile.TemporaryFile()
tempFile.truncate(numBytes)
buf = mmap.mmap(tempFile.fileno(), numBytes, access=mmap.ACCESS_WRITE)
obj = super(TempfileBackedArray, subtype).__new__(subtype, shape, dtype, buf, 0, None, order)
obj._file = tempFile
return obj
def __array_finalize__(self, obj):
if obj is None:
return
self._file = getattr(obj, '_file', None)
def arrayFactory(shape, dtype=float):
"""
Creates a new ndarray of the specified shape and datatype, storing
it in memory if there is sufficient available space or else using
a memory-mapped temporary file to provide the underlying buffer.
"""
requiredBytes = _requiredSize(shape, dtype)
vmem = psutil.virtual_memory()
if vmem.available > requiredBytes:
return np.ndarray(shape=shape, dtype=dtype)
else:
return TempfileBackedArray(shape=shape, dtype=dtype)
def zerosFactory(shape, dtype=float):
"""
Creates a new NumPy array using `arrayFactory()` and fills it with zeros.
"""
arr = arrayFactory(shape=shape, dtype=dtype)
arr.fill(0)
return arr
ARGS = {
"shape": (4, 5, 6),
"dtype": np.float32
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- numpy, psutil — 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 (4, 5, 6) — shape (4, 5, 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
|
| generateDistanceMatrix |
Not yet run unverified (harvested, no recorded run) |
ibm/max-human-pose-estimator/core/tf_pose/slidingwindow/WindowDistance.py code served (permissive licence) · get_code("1fc7d25ab7ceeb40") How it ran |
| get_part_cid |
Not yet run unverified (harvested, no recorded run) |
ibm/max-human-pose-estimator/core/tf_pose/pafprocess/pafprocess.py code served (permissive licence) · get_code("0ad190b8ea7cf881") How it ran |
| get_score |
Not yet run unverified (harvested, no recorded run) |
ibm/max-human-pose-estimator/core/tf_pose/pafprocess/pafprocess.py code served (permissive licence) · get_code("418d24f644276625") How it ran |
| mergeWindows |
Not yet run unverified (harvested, no recorded run) |
ibm/max-human-pose-estimator/core/tf_pose/slidingwindow/Merging.py code served (permissive licence) · get_code("33f87ef10f320887") How it ran |
| process_paf |
Not yet run unverified (harvested, no recorded run) |
ibm/max-human-pose-estimator/core/tf_pose/pafprocess/pafprocess.py code served (permissive licence) · get_code("dd2c2980939419d2") How it ran |