| angle_error_vec |
Ran ran, honoured the contract we drafted |
jinlinyi/SparsePlanes/sparsePlane/sparseplane/evaluation/mp3d_evaluation.py code served (permissive licence) · get_code("3c23388604dafa28") How it ranRan in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned ndarray, ndim 1, dtype family float, shape (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
torch_seed = 0
# angle_error_vec computes angular error between pairs of vectors
# It expects v1 and v2 to be 2D arrays with shape (batch_size, vector_dim)
# The function sums element-wise products along axis=1, so vectors should be normalized or unit vectors
batch_size = 2
vector_dim = 4
# Create two sets of random vectors
# For meaningful angle computation, vectors should ideally be unit vectors or normalized
v1 = np.random.randn(batch_size, vector_dim).astype(np.float32)
v1 = v1 / np.linalg.norm(v1, axis=1, keepdims=True) # normalize
v2 = np.random.randn(batch_size, vector_dim).astype(np.float32)
v2 = v2 / np.linalg.norm(v2, axis=1, keepdims=True) # normalize
ARGS = {
"v1": v1,
"v2": v2,
}
- 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 (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
|
| conv2d |
Ran ran; our contract draft was wrong, not the code |
jinlinyi/SparsePlanes/sparsePlane/sparseplane/modeling/camera_net/camera_head.py code served (permissive licence) · get_code("6584ae4f2836a5ff") 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 = {
"in_channels": 3,
"out_channels": 16,
"kernel_size": 3,
"stride": 1,
"padding": None,
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- torch — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type 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
|
| deconv2d |
Ran ran; our contract draft was wrong, not the code |
jinlinyi/SparsePlanes/sparsePlane/sparseplane/modeling/camera_net/camera_head.py code served (permissive licence) · get_code("8772d6bd1907c0d8") 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
from torch import nn
torch.manual_seed(0)
ARGS = {
'scale_factor': 2,
'mode': 'nearest',
'in_channels': 256,
'out_channels': 128,
'kernel_size': 3,
'stride': 1,
'padding': 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
|
| face2vert |
Ran ran; our contract draft was wrong, not the code |
jinlinyi/SparsePlanes/data_preparation/convert_mp3d_ply.py code served (permissive licence) · get_code("b58cfd2354528e6e") How it ranRan in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned ndarray, ndim 1, dtype family float, shape (4,) as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import numpy as np
# Analyze function usage:
# - face_id: used as scalar assignment target, appears to be an integer or array index
# - face: used with .max() method, indexed with [:, i] for i in range(3)
# so face must be a 2D array with shape (N, 3) where N is number of faces
# Create small test data
face_id = 1 # scalar face identifier
face = np.array([[0, 1, 2],
[1, 2, 3]], dtype=np.int32) # 2 faces, 3 vertices each, max vertex id is 3
ARGS = {
"face_id": face_id,
"face": face
}
- 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
|
| fitPlane |
Ran ran, honoured the contract we drafted |
jinlinyi/SparsePlanes/data_preparation/fit_plane_ply.py code served (permissive licence) · get_code("af8d8bdd59e32da6") How it ranRan in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned ndarray, ndim 1, dtype family float, shape (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
# fitPlane expects a numpy array (points) as input
# The function checks if points.shape[0] == points.shape[1] (square matrix case)
# or uses lstsq for non-square case
# It performs matrix operations: np.linalg.solve or np.linalg.lstsq
# with np.ones(points.shape[0]) as the right-hand side
# Create a non-square points array (overdetermined system)
# Using shape (5, 3) so it will go to the lstsq branch
points = np.array([
[1.0, 2.0, 3.0],
[4.0, 5.0, 6.0],
[7.0, 8.0, 9.0],
[10.0, 11.0, 12.0],
[13.0, 14.0, 15.0]
], dtype=np.float64)
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 (3,) — shape (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
|
| fix_JSON |
Ran ran; our contract draft was wrong, not the code |
jinlinyi/SparsePlanes/data_preparation/fit_plane_ply.py code served (permissive licence) · get_code("ef49b8c62716105b") How it ranRan in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned dict. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import json
# The function fix_JSON takes a json_message parameter (a string)
# and attempts to parse it as JSON, with a fallback that removes backslashes
# Test case 1: Valid JSON string
valid_json_str = '{"key": "value", "number": 42}'
# Test case 2: JSON with escaped backslashes that need fixing
invalid_json_str = '{"path": "C:\\\\Users\\\\test"}'
# We'll use the valid JSON as the main test case
ARGS = {
"json_message": valid_json_str
}
- 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
|
| get_K_inv_dot_xy_1 |
Ran ran, honoured the contract we drafted |
jinlinyi/SparsePlanes/data_preparation/render_plane.py code served (permissive licence) · get_code("87f16c9e7b3ad9d2") How it ranRan in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned ndarray, ndim 3, dtype family float, shape (3, 480, 640) 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 = {
'h': 480,
'w': 640,
}
- 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, 480, 640) — shape (3, 480, 640) 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_depth_err |
Ran ran; our contract draft was wrong, not the code |
jinlinyi/SparsePlanes/sparsePlane/sparseplane/evaluation/mp3d_evaluation.py code served (permissive licence) · get_code("559d8fc02b1cddcc") How it ranRan in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned Tensor, ndim 0, dtype family float, shape () as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import torch
torch.manual_seed(0)
# Create small tensors for pred_depth and gt_depth
# Shape: (2, 4) - batch size 2, 4 depth values
pred_depth = torch.randn(2, 4)
gt_depth = torch.rand(2, 4) * 0.1 # Values between 0 and 0.1 to have some > 0.0001
# device parameter - None by default
device = None
ARGS = {
"pred_depth": pred_depth,
"gt_depth": gt_depth,
"device": device,
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- torch — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type Tensor, ndim 0, dtype family float, shape () — shape () as a later run recorded it
- dtype family
- int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
- Environment
- image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
|
| get_hfov |
Ran ran, violated the contract we drafted |
jinlinyi/SparsePlanes/data_preparation/utils.py code served (permissive licence) · get_code("8f50175e76de5c7b") 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
# The function expects:
# - intrinsics: a numpy array that can be reshaped to have at least 1 element (accessed via [0])
# - width: an integer (default 1280)
# Create a small intrinsics array representing camera focal length
# Typically this would be a 3x3 or 2x2 intrinsic matrix, but the function only needs the first element
intrinsics = np.array([[500.0, 0.0, 320.0],
[0.0, 500.0, 240.0],
[0.0, 0.0, 1.0]], dtype=np.float32)
ARGS = {
"intrinsics": intrinsics,
"width": 1280
}
- 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
|
| l1LossMask |
Ran ran; our contract draft was wrong, not the code |
jinlinyi/SparsePlanes/sparsePlane/sparseplane/evaluation/mp3d_evaluation.py code served (permissive licence) · get_code("45d9c8eeef02238c") How it ranRan in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned Tensor, ndim 0, dtype family float, shape () as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import torch
torch.manual_seed(0)
# Create small tensors for the function
# pred: predicted values
# gt: ground truth values
# mask: binary mask to select which elements to include in loss
pred = torch.randn(2, 4)
gt = torch.randn(2, 4)
mask = torch.randint(0, 2, (2, 4), dtype=torch.float32)
ARGS = {
"pred": pred,
"gt": gt,
"mask": mask
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- torch — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type Tensor, ndim 0, dtype family float, shape () — shape () as a later run recorded it
- dtype family
- int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
- Environment
- image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
|
| mergePlanesNew |
Ran ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT) |
jinlinyi/SparsePlanes/data_preparation/fit_plane_ply.py code served (permissive licence) · get_code("485d6c3c648a4454") How it ranRan in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned dict. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import numpy as np
# Create a small set of 3D points (N points in 3D space)
points = np.array([
[0.0, 0.0, 0.0],
[1.0, 0.0, 1.0],
[0.0, 1.0, 1.0],
[1.0, 1.0, 2.0],
[2.0, 0.0, 2.0],
[2.0, 1.0, 3.0],
], dtype=np.float64)
# Create plane coefficients (ax + by + cz = 1, so plane is [a, b, c])
planes = [
np.array([0.5, 0.3, 0.2], dtype=np.float64),
np.array([0.1, 0.4, 0.3], dtype=np.float64),
]
# Point indices for each plane (which points belong to which plane)
planePointIndices = [
np.array([0, 1, 2], dtype=np.int64),
np.array([3, 4, 5], dtype=np.int64),
]
# Segments (using sets of segment IDs)
planeSegments = [
{0, 1},
{2, 3},
]
# Segment neighbors (mapping segment ID to neighboring segment IDs)
segmentNeighbors = {
0: [2],
1: [3],
2: [0],
3: [1],
}
# Number of planes range (min, max)
numPlanes = (1, 5)
# Optional parameters with default values
planeDiffThreshold = 0.05
planeAngleThreshold = 30
inlierThreshold = 0.9
planeAreaThreshold = 10
orthogonalThreshold = np.cos(np.deg2rad(60))
parallelThreshold = np.cos(np.deg2rad(30))
debug = False
ARGS = {
'points': points,
'planes': planes,
'planePointIndices': planePointIndices,
'planeSegments': planeSegments,
'segmentNeighbors': segmentNeighbors,
'numPlanes': numPlanes,
'planeDiffThreshold': planeDiffThreshold,
'planeAngleThreshold': planeAngleThreshold,
'inlierThreshold': inlierThreshold,
'planeAreaThreshold': planeAreaThreshold,
'orthogonalThreshold': orthogonalThreshold,
'parallelThreshold': parallelThreshold,
'debug': debug,
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- numpy — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type dict — a dict output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a dict output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not stated
- Environment
- image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
|
| mp3d2habitat |
Ran ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT) |
jinlinyi/SparsePlanes/data_preparation/render_plane.py code served (permissive licence) · get_code("a6798588f1400f85") 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, 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
# The function mp3d2habitat takes a 'planes' parameter
# Looking at the function body:
# - planes is converted to np.array and transposed
# - It's multiplied by a rotation matrix (3x3)
# - The result is transposed back
# This means planes should be a 2D array-like with shape (N, 3)
# where N is the number of planes and 3 are the coordinates
# Create a small sample planes array with shape (2, 3)
# representing 2 planes with 3 coordinates each
planes = np.array([
[1.0, 2.0, 3.0],
[4.0, 5.0, 6.0]
])
ARGS = {
"planes": planes
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- numpy — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type ndarray, ndim 2, dtype family float, shape (2, 3) — shape (2, 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
|
| pad_masks |
Ran ran; our contract draft was wrong, not the code |
jinlinyi/SparsePlanes/sparsePlane/sparseplane/layers/mask_ops.py code served (permissive licence) · get_code("19a63e894fd02add") 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
torch.manual_seed(0)
# Create a small batch of masks with shape (B, M, M)
# B=2 (batch size), M=4 (mask dimension)
masks = torch.randint(0, 2, (2, 4, 4), dtype=torch.float32)
# Padding amount
padding = 1
ARGS = {
"masks": masks,
"padding": padding,
}
- 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 — 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
|
| paste_mask_in_image_old |
Ran ran; our contract draft was wrong, not the code |
jinlinyi/SparsePlanes/sparsePlane/sparseplane/layers/mask_ops.py code served (permissive licence) · get_code("3f6042fe5727b417") How it ranRan in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned Tensor, ndim 2, dtype family int, shape (100, 150) as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import torch
import numpy as np
torch.manual_seed(0)
# Create a small mask tensor (Hmask, Wmask) with values in [0, 1]
mask = torch.rand(8, 6, dtype=torch.float32)
# Create a box tensor (4,) with x0, y0, x1, y1 coordinates
box = torch.tensor([10, 20, 25, 35], dtype=torch.float32)
# Image dimensions
img_h = 100
img_w = 150
# Threshold for binarization
threshold = 0.5
ARGS = {
"mask": mask,
"box": box,
"img_h": img_h,
"img_w": img_w,
"threshold": threshold,
}
- 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 Tensor, ndim 2, dtype family int, shape (100, 150) — shape (100, 150) 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
|
| paste_masks_in_image |
Ran ran; our contract draft was wrong, not the code |
jinlinyi/SparsePlanes/sparsePlane/sparseplane/layers/mask_ops.py code served (permissive licence) · get_code("8254e47b641929b1") How it ranRan in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned Tensor, ndim 3, dtype family float, shape (2, 24, 32) as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import torch
import numpy as np
torch.manual_seed(0)
# Small mask predictions: (N, Hmask, Wmask)
# N=2 instances, 4x4 mask resolution
masks = torch.rand(2, 4, 4)
# Bounding boxes: (N, 4) in format [x0, y0, x1, y1]
# Boxes within image bounds (0-32 for width, 0-24 for height)
boxes = torch.tensor([
[5.0, 3.0, 15.0, 18.0],
[10.0, 5.0, 20.0, 19.0]
], dtype=torch.float32)
# Image shape: (height, width)
image_shape = (24, 32)
# Threshold for binary mask conversion
threshold = 0.5
# NMS flag
nms = False
ARGS = {
"masks": masks,
"boxes": boxes,
"image_shape": image_shape,
"threshold": threshold,
"nms": nms
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- numpy, torch — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type Tensor, ndim 3, dtype family float, shape (2, 24, 32) — shape (2, 24, 32) 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
|
| remove_small_plane |
Ran ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT) |
jinlinyi/SparsePlanes/data_preparation/render_plane.py code served (permissive licence) · get_code("dd689ce211ee4516") 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 int, shape (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 cv2
import numpy as np
# Create a small plane instance ID array
# The function expects a 2D array where different values represent different plane instances
plane_instance_id = np.array([
[0, 0, 1, 1, 2, 2],
[0, 0, 1, 1, 2, 2],
[0, 0, 1, 1, 2, 2],
[0, 0, 3, 3, 2, 2],
[0, 0, 3, 3, 2, 2],
], dtype=np.int32)
ARGS = {
'plane_instance_id': plane_instance_id,
'bkgd': 0,
}
- 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 2, dtype family int, shape (5, 6) — shape (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
|
| sem_seg_postprocess |
Ran ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT) |
jinlinyi/SparsePlanes/sparsePlane/sparseplane/modeling/postprocessing.py code served (permissive licence) · get_code("7d1dddea95f2a435") How it ranRan in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned Tensor, ndim 3, dtype family float, shape (4, 24, 32) as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import torch
import torch.nn.functional as F
torch.manual_seed(0)
# Create a semantic segmentation prediction logits tensor
# Shape: (C, H, W) where C is number of classes, H and W are prediction dimensions
num_classes = 4
pred_height = 16
pred_width = 20
result = torch.randn(num_classes, pred_height, pred_width)
# Image size that the segmentor took as input (height, width)
# This should be smaller than or equal to pred_height and pred_width
img_size = (12, 15)
# Desired output resolution
output_height = 24
output_width = 32
ARGS = {
"result": result,
"img_size": img_size,
"output_height": output_height,
"output_width": output_width,
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- torch — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type Tensor, ndim 3, dtype family float, shape (4, 24, 32) — shape (4, 24, 32) 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
|
| print_scene_recur |
Not yet run unverified (harvested, no recorded run) |
jinlinyi/SparsePlanes/data_preparation/utils.py code served (permissive licence) · get_code("8117d4e34b80b3ab") How it ran |