| compute_loss_pip |
Ran ran on a synthesized input |
jhb86253817/PIPNet/lib/functions_gssl.py code served (permissive licence) · get_code("0ecee63670b4125b") How it ranRan in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned tuple, ndim 1, dtype family float; no output shape is stated. The image it ran in was not recorded. If your copy returns the same type and ndim on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import torch
import torch.nn as nn
torch.manual_seed(0)
# Define small criterion objects that work like loss functions
class DummyClassificationLoss(nn.Module):
def forward(self, output, target):
return torch.mean((output - target) ** 2)
class DummyRegressionLoss(nn.Module):
def forward(self, output, target):
return torch.mean((output - target) ** 2)
# Set up dimensions
batch_size = 2
num_channels = 4
height = 3
width = 5
num_nb = 2 # number of neighbors
spatial_size = height * width
# Create output tensors for maps (batch, channel, height, width)
outputs_map1 = torch.randn(batch_size, num_channels, height, width)
outputs_map2 = torch.randn(batch_size, num_channels, height, width)
outputs_map3 = torch.randn(batch_size, num_channels, height, width)
# Create label tensors for maps
labels_map1 = torch.randn(batch_size, num_channels, height, width)
labels_map2 = torch.randn(batch_size, num_channels, height, width)
labels_map3 = torch.randn(batch_size, num_channels, height, width)
# Create mask tensors for maps
masks_map1 = torch.randint(0, 2, (batch_size, num_channels, height, width)).float()
masks_map2 = torch.randint(0, 2, (batch_size, num_channels, height, width)).float()
masks_map3 = torch.randint(0, 2, (batch_size, num_channels, height, width)).float()
# Create local output tensors (batch, channel, spatial_size)
outputs_local_x = torch.randn(batch_size, num_channels, spatial_size)
outputs_local_y = torch.randn(batch_size, num_channels, spatial_size)
# Create local label tensors
labels_local_x = torch.randn(batch_size, num_channels, spatial_size)
labels_local_y = torch.randn(batch_size, num_channels, spatial_size)
# Create local mask tensors
masks_local_x = torch.randint(0, 2, (batch_size, num_channels, spatial_size)).float()
masks_local_y = torch.randint(0, 2, (batch_size, num_channels, spatial_size)).float()
# Create neighbor output tensors (batch, num_nb, channel, spatial_size)
outputs_nb_x = torch.randn(batch_size, num_nb, num_channels, spatial_size)
outputs_nb_y = torch.randn(batch_size, num_nb, num_channels, spatial_size)
# Create neighbor label tensors
labels_nb_x = torch.randn(batch_size, num_nb, num_channels, spatial_size)
labels_nb_y = torch.randn(batch_size, num_nb, num_channels, spatial_size)
# Create neighbor mask tensors
masks_nb_x = torch.randint(0, 2, (batch_size, num_nb, num_channels, spatial_size)).float()
masks_nb_y = torch.randint(0, 2, (batch_size, num_nb, num_channels, spatial_size)).float()
# Create criterion functions
criterion_cls = DummyClassificationLoss()
criterion_reg = DummyRegressionLoss()
ARGS = {
'outputs_map1': outputs_map1,
'outputs_map2': outputs_map2,
'outputs_map3': outputs_map3,
'outputs_local_x': outputs_local_x,
'outputs_local_y': outputs_local_y,
'outputs_nb_x': outputs_nb_x,
'outputs_nb_y': outputs_nb_y,
'labels_map1': labels_map1,
'labels_map2': labels_map2,
'labels_map3': labels_map3,
'labels_local_x': labels_local_x,
'labels_local_y': labels_local_y,
'labels_nb_x': labels_nb_x,
'labels_nb_y': labels_nb_y,
'masks_map1': masks_map1,
'masks_map2': masks_map2,
'masks_map3': masks_map3,
'masks_local_x': masks_local_x,
'masks_local_y': masks_local_y,
'masks_nb_x': masks_nb_x,
'masks_nb_y': masks_nb_y,
'criterion_cls': criterion_cls,
'criterion_reg': criterion_reg,
'num_nb': num_nb,
}
- 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 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
|
| conv_1x1_bn |
Ran ran; our contract draft was wrong, not the code |
jhb86253817/PIPNet/lib/mobilenetv3.py code served (permissive licence) · get_code("4e90491a30c2dc28") 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 Sequential. 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)
# Define the custom activation modules needed by conv_1x1_bn
class h_sigmoid(nn.Module):
def __init__(self, inplace=True):
super(h_sigmoid, self).__init__()
self.relu = nn.ReLU6(inplace=inplace)
def forward(self, x):
return self.relu(x + 3) / 6
class h_swish(nn.Module):
def __init__(self, inplace=True):
super(h_swish, self).__init__()
self.sigmoid = h_sigmoid(inplace=inplace)
def forward(self, x):
return x * self.sigmoid(x)
def conv_1x1_bn(inp, oup):
return nn.Sequential(
nn.Conv2d(inp, oup, 1, 1, 0, bias=False),
nn.BatchNorm2d(oup),
h_swish()
)
# Create arguments for conv_1x1_bn
# inp: number of input channels (distinct from oup)
# oup: number of output channels
inp_channels = 4
oup_channels = 3
ARGS = {
'inp': inp_channels,
'oup': oup_channels
}
- 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 Sequential — a Sequential output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a Sequential output the recorded ndim 1 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
|
| conv_3x3_bn |
Ran ran; our contract draft was wrong, not the code |
jhb86253817/PIPNet/lib/mobilenetv3.py code served (permissive licence) · get_code("5221887077e3fb54") 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 Sequential. 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)
ARGS = {
'inp': 3,
'oup': 16,
'stride': 1
}
- 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 Sequential — a Sequential output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a Sequential output the recorded ndim 1 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
|
| fr_and_auc |
Ran ran on a synthesized input |
deftruth/torchlm/torchlm/metrics/metrics.py code served (permissive licence) · get_code("7a33e0cbdc0a9b10") How it ranRan in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned tuple, ndim 1, dtype family float; no output shape is stated. The image it ran in was not recorded. If your copy returns the same type and ndim on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import numpy as np
# fr_and_auc takes nmes (list of floats) and optional thres and step parameters
# The function counts how many nmes values are <= each threshold in xs
# and computes a failure rate and AUC
ARGS = {
"nmes": [0.05, 0.08, 0.12, 0.15, 0.02, 0.11],
"thres": 0.1,
"step": 0.0001,
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- numpy, scipy — 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
|
| get_label |
Ran ran on a synthesized input |
jhb86253817/PIPNet/lib/functions.py code served (permissive licence) · get_code("c6f9712584e0d9f8") How it ranRan in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned list. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import os
import tempfile
import numpy as np
# Create a temporary directory structure with test label files
temp_dir = tempfile.mkdtemp()
data_dir = os.path.join(temp_dir, 'data', 'test_dataset')
os.makedirs(data_dir, exist_ok=True)
# Create a label file with image names and targets
label_file_path = os.path.join(data_dir, 'labels.txt')
with open(label_file_path, 'w') as f:
f.write('image1.jpg 0.1 0.2 0.3\n')
f.write('image2.jpg 0.4 0.5 0.6\n')
f.write('image3.jpg 0.7 0.8 0.9\n')
# Change to the temp directory so relative paths work
original_dir = os.getcwd()
os.chdir(temp_dir)
ARGS = {
'data_name': 'test_dataset',
'label_file': 'labels.txt',
'task_type': None
}
- 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 — a list output has no array shape of its own; none is stated
- Environment
- image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
|
| get_meanface |
Ran ran on a synthesized input |
jhb86253817/PIPNet/lib/functions.py code served (permissive licence) · get_code("d4eeabbb4d3bfbcb") How it ranRan in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned tuple. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import numpy as np
import tempfile
import os
# Create a temporary meanface file
temp_dir = tempfile.mkdtemp()
meanface_file = os.path.join(temp_dir, "meanface.txt")
# Create sample meanface data with 5 points in 2D (x, y coordinates)
# 5 points means 10 floats total
meanface_data = "0.0 0.0 1.0 0.0 2.0 0.0 3.0 1.0 1.5 2.0"
with open(meanface_file, 'w') as f:
f.write(meanface_data)
ARGS = {
"meanface_file": meanface_file,
"num_nb": 2
}
- 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
|
| nme |
Ran ran on a synthesized input |
deftruth/torchlm/torchlm/metrics/metrics.py code served (permissive licence) · get_code("791cd5847cdd6ff5") 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 float32, 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
# Create small sample data for landmarks
# Using distinct dimensions: 5 landmarks with 2 coordinates each
n_landmarks = 5
# Predicted landmarks: (5, 2)
lms_pred = np.array([
[10.0, 20.0],
[15.5, 25.3],
[12.1, 22.8],
[18.2, 28.1],
[11.9, 21.5]
], dtype=np.float32)
# Ground truth landmarks: (5, 2)
lms_gt = np.array([
[10.2, 20.1],
[15.3, 25.0],
[12.0, 22.9],
[18.0, 28.2],
[12.1, 21.4]
], dtype=np.float32)
# Normalize value (distance between eyeballs, typically around 100 pixels)
norm = 100.0
ARGS = {
"lms_pred": lms_pred,
"lms_gt": lms_gt,
"norm": norm
}
- 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 float32, 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
|
| process_300w |
Ran ran on a synthesized input |
jhb86253817/PIPNet/lib/preprocess.py code served (permissive licence) · get_code("22d83c9db600623b") How it ranRan in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned tuple. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import os
import cv2
import numpy as np
import tempfile
# Create a temporary directory structure with test data
temp_dir = tempfile.mkdtemp()
test_folder = os.path.join(temp_dir, "test_folder")
os.makedirs(test_folder, exist_ok=True)
# Create a test image (100x100 BGR image)
test_image = np.random.randint(0, 255, (100, 100, 3), dtype=np.uint8)
image_path = os.path.join(test_folder, "test_image.jpg")
cv2.imwrite(image_path, test_image)
# Create a test label file with landmark annotations
# Format: header lines, then landmark coordinates, then footer
label_content = """version: 1
npoints: 5
{
10 20
30 40
50 60
70 80
90 90
}
"""
label_path = os.path.join(test_folder, "test_label.txt")
with open(label_path, 'w') as f:
f.write(label_content)
ARGS = {
"root_folder": temp_dir,
"folder_name": "test_folder",
"image_name": "test_image.jpg",
"label_name": "test_label.txt",
"target_size": 64
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- cv2, numpy — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type tuple — a tuple output has no array shape of its own; none is stated
- Environment
- image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
|
| process_300w |
Ran ran on a synthesized input |
jhb86253817/PIPNet/lib/preprocess_gssl.py code served (permissive licence) · get_code("5a75fb8671b68880") How it ranRan in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned tuple. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import os
import tempfile
import cv2
import numpy as np
# Create temporary directory structure with test files
temp_dir = tempfile.mkdtemp()
folder_name = "test_folder"
folder_path = os.path.join(temp_dir, folder_name)
os.makedirs(folder_path, exist_ok=True)
# Create a test image (100x120 BGR)
image_array = np.random.randint(0, 255, (120, 100, 3), dtype=np.uint8)
image_name = "test_image.jpg"
image_path = os.path.join(folder_path, image_name)
cv2.imwrite(image_path, image_array)
# Create a test label file with landmark annotations
# Format: first 3 lines are headers, then landmark coordinates, then some footer
label_name = "test_image.pts"
label_path = os.path.join(folder_path, label_name)
with open(label_path, 'w') as f:
f.write("version: 1\n")
f.write("n_points: 68\n")
f.write("{\n")
# Write 68 landmark points (x y coordinates)
for i in range(68):
x = 20 + (i % 10) * 5
y = 30 + (i // 10) * 5
f.write(f"{x} {y}\n")
f.write("}\n")
ARGS = {
"root_folder": temp_dir,
"folder_name": folder_name,
"image_name": image_name,
"label_name": label_name,
"target_size": 64
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- cv2, numpy — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type tuple — a tuple output has no array shape of its own; none is stated
- Environment
- image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
|
| process_celeba |
Ran ran on a synthesized input |
jhb86253817/PIPNet/lib/preprocess_gssl.py code served (permissive licence) · get_code("657f44be85c2cb01") 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 (128, 128, 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 os
import cv2
import numpy as np
import tempfile
# Create a temporary directory structure that mimics CelebA
temp_dir = tempfile.mkdtemp()
celeba_dir = os.path.join(temp_dir, 'CELEBA', 'img_celeba')
os.makedirs(celeba_dir, exist_ok=True)
# Create a small dummy image file
image_name = 'test_image.jpg'
dummy_image = np.random.randint(0, 256, (256, 256, 3), dtype=np.uint8)
image_path = os.path.join(celeba_dir, image_name)
cv2.imwrite(image_path, dummy_image)
# Define the bounding box coordinates (xmin, ymin, xmax, ymax)
bbox = (50, 60, 150, 180)
# Define target size for resizing
target_size = 128
ARGS = {
'root_folder': temp_dir,
'image_name': image_name,
'bbox': bbox,
'target_size': target_size
}
- 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 (128, 128, 3) — shape (128, 128, 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
|
| process_cofw |
Ran ran on a synthesized input |
jhb86253817/PIPNet/lib/preprocess.py code served (permissive licence) · get_code("ac5ae0ae9d4b74aa") How it ranRan in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned tuple. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import os
import cv2
import numpy as np
# Create a small valid image
image = np.random.randint(0, 256, size=(100, 120, 3), dtype=np.uint8)
# Create bounding box as (xmin, ymin, width, height)
bbox = (10, 15, 50, 60)
# Create annotation: 29 x-coordinates followed by 29 y-coordinates
anno_x = np.random.uniform(10, 60, size=29)
anno_y = np.random.uniform(15, 75, size=29)
anno = np.concatenate([anno_x, anno_y])
# Target size for resizing
target_size = 64
ARGS = {
"image": image,
"bbox": bbox,
"anno": anno,
"target_size": target_size,
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- cv2, numpy — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type tuple — a tuple output has no array shape of its own; none is stated
- Environment
- image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
|
| process_wflw |
Ran ran on a synthesized input |
jhb86253817/PIPNet/lib/preprocess_gssl.py code served (permissive licence) · get_code("149fe226ec8dbea0") How it ranRan in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned tuple. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import os
import cv2
import numpy as np
from unittest.mock import Mock, patch
# Create a minimal mock image as a numpy array
# The function reads an image, so we need to mock cv2.imread
mock_image = np.random.randint(0, 255, (480, 640, 3), dtype=np.uint8)
# Create annotation data: 196 landmark coordinates + 4 bbox values + 6 attributes + 1 image name
# 196 landmarks (98 points * 2 for x,y)
lms_coords = [float(i % 640) for i in range(196)] # 98 x,y pairs within image bounds
# 4 bbox values: xmin, ymin, xmax, ymax
bbox_values = [100.0, 120.0, 500.0, 450.0]
# 6 attribute values (0 or 1)
attrs = ['1', '0', '1', '0', '1', '0']
# Image name
image_name = 'test_image.jpg'
# Combine all into annotation list
anno = lms_coords + bbox_values + attrs + [image_name]
# Mock cv2.imread to return our mock image
def mock_imread(path):
return mock_image
# Target size for resizing
target_size = 224
ARGS = {
'anno': anno,
'target_size': target_size
}
# Patch cv2.imread for the function execution
import sys
cv2.imread = mock_imread
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- cv2, numpy — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type tuple — a tuple output has no array shape of its own; none is stated
- Environment
- image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
|
| random_blur |
Ran ran on a synthesized input |
jhb86253817/PIPNet/lib/data_utils.py code served (permissive licence) · get_code("4e4f39068434b6e0") 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 Image. 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.
from PIL import Image, ImageFilter
import random
# Create a small PIL Image object
# The function calls .filter() method on the image
image = Image.new('RGB', (32, 32), color='red')
ARGS = {
'image': image
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- PIL — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type Image — a Image output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a Image output the recorded ndim 3 and dtype family int 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
|
| random_occlusion |
Ran ran on a synthesized input |
jhb86253817/PIPNet/lib/data_utils.py code served (permissive licence) · get_code("47e71b4e99e8b661") 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 Image. 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.
from PIL import Image
import numpy as np
import random
random.seed(42)
# Create a small test image (RGB format)
image_array = np.random.randint(0, 256, size=(100, 80, 3), dtype=np.uint8)
image = Image.fromarray(image_array, 'RGB')
ARGS = {
'image': image
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- PIL, numpy — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type Image — a Image output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a Image output the recorded ndim 3 and dtype family int 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
|
| random_translate |
Ran ran on a synthesized input |
jhb86253817/PIPNet/lib/data_utils.py code served (permissive licence) · get_code("555d941276e9070f") How it ranRan in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned tuple. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import torch
import numpy as np
from PIL import Image
import random
# Set seed for reproducibility
random.seed(0)
torch.manual_seed(0)
# Create a small PIL Image (RGB mode, 100x100 pixels)
image = Image.new('RGB', (100, 100), color=(255, 0, 0))
# Create a target array representing normalized coordinates
# Shape: (4,) - representing 2 points with (x, y) normalized coordinates
target = np.array([0.3, 0.4, 0.7, 0.8], dtype=np.float32)
ARGS = {
'image': image,
'target': target
}
- 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 tuple — a tuple output has no array shape of its own; none is stated
- Environment
- image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
|
| compute_loss_pip |
Not yet run unverified (harvested, no recorded run) |
jhb86253817/PIPNet/lib/functions.py code served (permissive licence) · get_code("180321558d57e253") How it ran |
| process_wflw |
Not yet run unverified (harvested, no recorded run) |
jhb86253817/PIPNet/lib/preprocess.py code served (permissive licence) · get_code("260fe0df73217f72") How it ran |