| Is_horizontal |
Ran ran on a synthesized input |
wyf-ACCEPT/BackToReality/data_generation/ScanNet/segment_tools.py code served (permissive licence) · get_code("af68a34722851d0e") 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)
# The function accesses scene_vertices[seg] to get a subset of vertices,
# then accesses the third column ([:, 2]) to get z-coordinates.
# It calls .sort() on the result and .shape[0] to get the number of elements.
# seg should be an indexable collection that selects rows from scene_vertices.
# Create scene_vertices as a tensor with shape (10, 3) - 10 vertices, 3D coordinates
scene_vertices = torch.randn(10, 3)
# Create seg as a tensor of indices to select from scene_vertices
# This will select 6 vertices from the 10 available
seg = torch.tensor([0, 1, 3, 5, 7, 9])
ARGS = {
"scene_vertices": scene_vertices,
"seg": seg
}
- 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
|
| SigmoidFocalClassificationLoss |
Ran ran on a synthesized input |
xuxw98/backtoreality/detection/GroupFree3D/models/loss_helper.py code served (permissive licence) · get_code("2616a152109ab293") How it ranRan in Syntology's sandbox on this synthesized input (drafted by a language model, class construct-then-call prompt, model not recorded) and returned Tensor, ndim 3, 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
class SigmoidFocalClassificationLoss(nn.Module):
"""
Sigmoid focal cross entropy loss.
"""
def __init__(self, gamma: float=2.0, alpha: float=0.25):
"""
Args:
gamma: Weighting parameter to balance loss for hard and easy examples.
alpha: Weighting parameter to balance loss for positive and negative examples.
"""
super(SigmoidFocalClassificationLoss, self).__init__()
self.alpha = alpha
self.gamma = gamma
@staticmethod
def sigmoid_cross_entropy_with_logits(input: torch.Tensor, target: torch.Tensor):
""" PyTorch Implementation for tf.nn.sigmoid_cross_entropy_with_logits:
max(x, 0) - x * z + log(1 + exp(-abs(x))) in
https://www.tensorflow.org/api_docs/python/tf/nn/sigmoid_cross_entropy_with_logits
Args:
input: (B, #proposals, #classes) float tensor.
Predicted logits for each class
target: (B, #proposals, #classes) float tensor.
One-hot encoded classification targets
Returns:
loss: (B, #proposals, #classes) float tensor.
Sigmoid cross entropy loss without reduction
"""
loss = torch.clamp(input, min=0) - input * target + torch.log1p(torch.exp(-torch.abs(input)))
return loss
def forward(self, input: torch.Tensor, target: torch.Tensor, weights: torch.Tensor):
"""
Args:
input: (B, #proposals, #classes) float tensor.
Predicted logits for each class
target: (B, #proposals, #classes) float tensor.
One-hot encoded classification targets
weights: (B, #proposals) float tensor.
Anchor-wise weights.
Returns:
weighted_loss: (B, #proposals, #classes) float tensor after weighting.
"""
pred_sigmoid = torch.sigmoid(input)
alpha_weight = target * self.alpha + (1 - target) * (1 - self.alpha)
pt = target * (1.0 - pred_sigmoid) + (1.0 - target) * pred_sigmoid
focal_weight = alpha_weight * torch.pow(pt, self.gamma)
bce_loss = self.sigmoid_cross_entropy_with_logits(input, target)
loss = focal_weight * bce_loss
weights = weights.unsqueeze(-1)
assert weights.shape.__len__() == loss.shape.__len__()
return loss * weights
INIT_ARGS = {
'gamma': 2.0,
'alpha': 0.25,
}
ARGS = {
'input': torch.randn(2, 5, 4),
'target': torch.randint(0, 2, (2, 5, 4)).float(),
'weights': torch.ones(2, 5),
}
if __name__ == '__main__':
loss_fn = SigmoidFocalClassificationLoss(**INIT_ARGS)
output = loss_fn(**ARGS)
print(f"Output shape: {output.shape}")
print(f"Output:\n{output}")
- Setup block drafted by
- a language model, class construct-then-call prompt, model not recorded
- 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 — no output shape is stated: observe_signature.py observed this class with its constructor sizes canonicalised where it could, which the node does not record, so its shape is not stated as this setup block's
- 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: torch and numpy seeded to 0 by the harness immediately before the class was constructed from INIT_ARGS (fixture_check.py)
|
| compute_objectness_loss_based_on_query_points |
Ran ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT) |
xuxw98/backtoreality/detection/GroupFree3D/models/loss_helper.py code served (permissive licence) · get_code("642ad5f6031a8aa1") 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. The code mentions cuda, and the harness aliases cuda to the CPU for every sample; whether this run needed that is 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)
# Create small tensors with distinct dimensions
B = 2 # batch size
N = 4 # number of points
K = 3 # number of query points
K2 = 5 # number of ground truth objects
num_classes = 1
# Build end_points dict with all required keys
end_points = {
'seed_inds': torch.randint(0, N, (B, N)),
'center_label': torch.randn(B, K2, 3),
'query_points_sample_inds': torch.randint(0, N, (B, K)),
'point_obj_mask': torch.randint(0, 2, (B, N)).float(),
'point_instance_label': torch.randint(-1, K2, (B, N)),
'proposal_objectness_scores': torch.randn(B, K, num_classes),
}
# Create additional objectness_scores for decoder layers if needed
num_decoder_layers = 0
ARGS = {
'end_points': end_points,
'num_decoder_layers': num_decoder_layers,
}
- 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
|
| compute_points_obj_cls_loss_hard_topk |
Ran ran, honoured the contract we drafted |
xuxw98/backtoreality/detection/GroupFree3D/models/loss_helper.py code served (permissive licence) · get_code("c9e3c6528cd69995") 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
import torch.nn as nn
torch.manual_seed(0)
# Build minimal end_points dict with all required keys
B = 2 # batch size
K = 4 # number of seeds/proposals
K2 = 3 # number of ground truth objects
num_classes = 1
end_points = {
'box_label_mask': torch.ones((B, K2), dtype=torch.float32),
'seed_inds': torch.randint(0, K, (B, K), dtype=torch.long),
'seed_xyz': torch.randn((B, K, 3), dtype=torch.float32),
'seeds_obj_cls_logits': torch.randn((B, K, 1), dtype=torch.float32),
'center_label': torch.randn((B, K2, 3), dtype=torch.float32),
'size_gts': torch.randn((B, K2, 3), dtype=torch.float32),
'point_instance_label': torch.randint(-1, K2, (B, K), dtype=torch.long),
}
topk = 2
ARGS = {
'end_points': end_points,
'topk': topk,
}
- 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
|
| compute_points_obj_cls_loss_hard_topk_weak |
Ran ran, honoured the contract we drafted |
xuxw98/backtoreality/detection/GroupFree3D/models/loss_helper.py code served (permissive licence) · get_code("5d501aaa66769592") 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
import torch.nn as nn
torch.manual_seed(0)
# Build end_points dict with all required keys
B = 2 # batch size
K = 4 # number of seeds
K2 = 3 # number of gt boxes
num_classes = 1
end_points = {
'box_label_mask': torch.ones((B, K2), dtype=torch.float32),
'seed_inds': torch.randint(0, K, (B, K), dtype=torch.long),
'seed_xyz': torch.randn((B, K, 3), dtype=torch.float32),
'seeds_obj_cls_logits': torch.randn((B, K, num_classes), dtype=torch.float32),
'center_label': torch.randn((B, K2, 3), dtype=torch.float32),
}
topk = 2
ARGS = {
'end_points': end_points,
'topk': topk,
}
- 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
|
| find_nearest_object |
Ran ran on a synthesized input |
wyf-ACCEPT/BackToReality/data_generation/ScanNet/scannet_scene_synthesis.py code served (permissive licence) · get_code("cc8c7c54286373af") 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
# Construct the info_dict parameter
# Structure: key -> [[[numerator, denominator], ...], ..., support_flag]
# The function accesses value[0][0][0], value[0][0][1], and value[2]
info_dict = {
'obj_code_1': [
[[8, 4], [2, 1]], # value[0] is list of lists
'some_metadata',
True # value[2] is the support flag
],
'obj_code_2': [
[[10, 5], [3, 2]],
'other_metadata',
False
],
'obj_code_3': [
[[6, 3], [1, 2]],
'more_metadata',
True
],
'obj_code_4': [
[[0, 0], [0, 0]], # Division by zero case - should be skipped
'bad_metadata',
True
]
}
# ls_ratio: a float representing the target width-to-height ratio
ls_ratio = 2.0
# object_name: a string prefix for the output filename
object_name = 'test_object'
# require_support: boolean flag to filter by support
require_support = False
ARGS = {
'ls_ratio': ls_ratio,
'info_dict': info_dict,
'object_name': object_name,
'require_support': require_support
}
- 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 — 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
|
| get_MER |
Ran ran on a synthesized input |
wyf-ACCEPT/BackToReality/data_generation/Matterport3D/modelnet40_tools.py code served (permissive licence) · get_code("5909c81367fe7e2b") 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 cv2
class MockPointCloud:
def __init__(self, points):
self.points = points
# Create a simple point cloud with 5 points in 2D (we only use first 2 coords)
# Points should form a reasonable shape for minAreaRect
points_data = np.array([
[0.0, 0.0, 0.5],
[1.0, 0.0, 0.5],
[1.0, 0.5, 0.5],
[0.0, 0.5, 0.5],
[0.5, 0.25, 0.5]
], dtype=np.float32)
pcd = MockPointCloud(points_data)
ARGS = {
'pcd': pcd
}
- 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
|
| get_MER |
Ran ran on a synthesized input |
wyf-ACCEPT/BackToReality/data_generation/Matterport3D/matterport_scene_synthesis.py code served (permissive licence) · get_code("f66ccab4c6f93ada") 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 cv2
import copy
# Create a small set of 2D points as a numpy array
# Shape should be (N, 2+) where first 2 columns are x, y coordinates
points = np.array([
[0.5, 0.3],
[0.7, 0.2],
[0.8, 0.5],
[0.6, 0.7]
], dtype=np.float32)
ARGS = {
'points': points
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- 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
|
| get_id_to_label |
Ran ran on a synthesized input |
wyf-ACCEPT/BackToReality/data_generation/ScanNet/ins_ply.py code served (permissive licence) · get_code("114d8fa311c666a5") 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 os
import json
import tempfile
# Create a temporary JSON file with the expected structure
temp_file = tempfile.NamedTemporaryFile(mode='w', delete=False, suffix='.json')
temp_filename = temp_file.name
# Write sample data matching the function's expected structure
sample_data = {
'segGroups': [
{
'objectId': 0,
'label': 'chair'
},
{
'objectId': 1,
'label': 'table'
},
{
'objectId': 2,
'label': 'wall'
}
]
}
json.dump(sample_data, temp_file)
temp_file.close()
ARGS = {
'filename': temp_filename
}
- 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_normal |
Ran ran on a synthesized input |
wyf-ACCEPT/BackToReality/data_generation/ScanNet/segment_tools.py code served (permissive licence) · get_code("52dc1aebbd2b533c") How it ranRan in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned ndarray, ndim 2, dtype family float, shape (4, 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
class MockMesh:
def __init__(self):
# Create a simple tetrahedron mesh with 4 vertices and 4 triangular faces
self.vertices = np.array([
[0.0, 0.0, 0.0],
[1.0, 0.0, 0.0],
[0.5, 1.0, 0.0],
[0.5, 0.5, 1.0]
], dtype=np.float64)
# Define 4 triangular faces (indices into vertices)
self.faces = np.array([
[0, 1, 2],
[0, 1, 3],
[1, 2, 3],
[0, 2, 3]
], dtype=np.int32)
self.triangle_normals = None
def compute_vertex_normals(self):
# Compute triangle normals from vertices and faces
triangle_normals = []
for face in self.faces:
v0 = self.vertices[face[0]]
v1 = self.vertices[face[1]]
v2 = self.vertices[face[2]]
# Compute two edge vectors
edge1 = v1 - v0
edge2 = v2 - v0
# Compute normal via cross product
normal = np.cross(edge1, edge2)
norm = np.linalg.norm(normal)
if norm > 0:
normal = normal / norm
triangle_normals.append(normal)
self.triangle_normals = np.array(triangle_normals)
mesh = MockMesh()
ARGS = {
"mesh": mesh
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- numpy — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type ndarray, ndim 2, dtype family float, shape (4, 3) — shape (4, 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
|
| get_solid_MER |
Ran ran on a synthesized input |
wyf-ACCEPT/BackToReality/data_generation/ScanNet/scannet_scene_synthesis.py code served (permissive licence) · get_code("22667864de7fcab8") 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 torch
torch.manual_seed(0)
# The function takes a single parameter 'points'
# Looking at the function body:
# - points[:, 0:2] extracts first 2 columns
# - points is multiplied by 1000 and cast to int
# - points is used with cv2.minAreaRect which expects a 2D array of point coordinates
# - points is used with KMeans.predict which expects a 2D array
# So points should be a 2D numpy array with at least 2 columns
# Create a small sample of points with shape (n_points, at_least_2_columns)
# Using shape (6, 3) to have some distinct dimension from other possible uses
points = np.array([
[0.1, 0.2, 0.5],
[0.15, 0.25, 0.5],
[0.12, 0.22, 0.5],
[0.5, 0.6, 0.5],
[0.55, 0.65, 0.5],
[0.52, 0.62, 0.5]
], 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
- cv2, numpy, sklearn, 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
|
| get_solid_MER |
Ran ran on a synthesized input |
wyf-ACCEPT/BackToReality/data_generation/Matterport3D/matterport_scene_synthesis.py code served (permissive licence) · get_code("d7006f63008a044b") 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 cv2
import copy
from sklearn.cluster import KMeans
# Create a simple set of points for testing
# The function expects points as a numpy array with at least columns 0:2 (x, y coordinates)
# Shape should be (num_points, num_features) where num_features >= 2
points = np.array([
[0.5, 0.5, 0.1, 0.2],
[0.6, 0.4, 0.15, 0.25],
[0.7, 0.6, 0.12, 0.22],
[1.2, 1.3, 0.18, 0.28],
[1.3, 1.4, 0.14, 0.24],
[1.4, 1.2, 0.16, 0.26],
], dtype=np.float32)
ARGS = {
"points": points,
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- cv2, numpy, sklearn — 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
|
| get_support_z |
Ran ran on a synthesized input |
wyf-ACCEPT/BackToReality/data_generation/Matterport3D/modelnet40_tools.py code served (permissive licence) · get_code("d9e542fd2784b3d8") 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
class MockPointCloud:
def __init__(self, points, normals):
self.points = points
self.normals = normals
# Create test data
# 20 points with (x, y, z) coordinates
np.random.seed(0)
points = np.random.randn(20, 3).astype(np.float32)
# Create normals where some have high z-component (> 0.88)
normals = np.random.randn(20, 3).astype(np.float32)
# Normalize normals
normals = normals / np.linalg.norm(normals, axis=1, keepdims=True)
# Ensure some normals have abs(dot(normal, [0,0,1])) > 0.88
# This means the z-component should be > 0.88 or < -0.88
for i in range(10):
normals[i] = np.array([0.0, 0.0, 0.95])
for i in range(10, 15):
normals[i] = np.array([0.0, 0.0, -0.95])
# Create point cloud object
pcd = MockPointCloud(points, normals)
ARGS = {
"pcd": pcd
}
- 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
|
| l1_loss |
Ran ran; our contract draft was wrong, not the code |
xuxw98/backtoreality/detection/GroupFree3D/models/loss_helper.py code served (permissive licence) · get_code("e1e4a142a595bcf2") 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 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 torch
torch.manual_seed(0)
# Create a small error tensor (batch size 2, dimension 4)
error = torch.randn(2, 4)
ARGS = {
"error": error
}
- 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 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
|
| modelnet40_to_id |
Ran ran on a synthesized input |
wyf-ACCEPT/BackToReality/data_generation/ScanNet/scannet_utils.py code served (permissive licence) · get_code("fde3fc16b0a466d2") How it ranRan in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned int, ndim 0, dtype family int, shape () as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import torch
import tempfile
import os
# Create a temporary modelnet40_shape_names.txt file
temp_dir = tempfile.gettempdir()
shape_names_path = os.path.join(temp_dir, 'modelnet40_shape_names.txt')
# Write sample ModelNet40 shape names to the file
shape_names = [
'airplane',
'bathtub',
'bed',
'bench',
'bicycle',
'birdhouse',
'bookshelf',
'bottle',
'bowl',
'bus',
'cabinet',
'camera',
'can',
'cap',
'car',
'chair',
'clipart',
'clock',
'computer',
'cone',
'curtain',
'desk',
'dishwasher',
'display',
'door',
'dresser',
'dumbbell',
'earphone',
'fan',
'file',
'flower_pot',
'fountain',
'glass_box',
'guitar',
'gun',
'gym_shoes',
'hair_brush',
'hat',
'helmet',
'home',
'house'
]
with open(shape_names_path, 'w') as f:
for name in shape_names:
f.write(name + '\n')
# Change to the temp directory so the function can find the file
original_cwd = os.getcwd()
os.chdir(temp_dir)
ARGS = {
'modelname': 'chair'
}
- 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 int, ndim 0, dtype family int, shape () — shape () as a later run recorded it
- dtype family
- int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
- Environment
- image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
|
| nn_distance |
Ran ran; our contract draft was wrong, not the code |
xuxw98/backtoreality/detection/GroupFree3D/models/loss_helper.py code served (permissive licence) · get_code("60f5b7fe1cc54f17") 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)
def huber_loss(x, delta):
"""Stand-in for huber_loss since it's not defined in the function"""
mask = torch.abs(x) <= delta
return torch.where(mask, 0.5 * x ** 2, delta * (torch.abs(x) - 0.5 * delta))
# Create small test tensors
# pc1: (B=2, N=3, C=4)
pc1 = torch.randn(2, 3, 4)
# pc2: (B=2, M=5, C=4)
pc2 = torch.randn(2, 5, 4)
ARGS = {
"pc1": pc1,
"pc2": pc2,
"l1smooth": False,
"delta": 1.0,
"l1": False,
}
- 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
|
| read_aggregation |
Ran ran on a synthesized input |
wyf-ACCEPT/BackToReality/data_generation/ScanNet/ins_ply.py code served (permissive licence) · get_code("99136f050d5a159b") 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 os
import json
import tempfile
# Create a temporary JSON file with valid aggregation data
temp_file = tempfile.NamedTemporaryFile(mode='w', suffix='.json', delete=False)
aggregation_data = {
'segGroups': [
{
'objectId': 0,
'label': 'wall',
'segments': [0, 1, 2]
},
{
'objectId': 1,
'label': 'floor',
'segments': [3, 4]
},
{
'objectId': 2,
'label': 'wall',
'segments': [5]
}
]
}
json.dump(aggregation_data, temp_file)
temp_file.close()
ARGS = {
'filename': temp_file.name
}
- 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 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
|
| read_label_mapping |
Ran ran on a synthesized input |
wyf-ACCEPT/BackToReality/data_generation/ScanNet/scannet_utils.py code served (permissive licence) · get_code("69e7d6553f196430") 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 os
import csv
import tempfile
# Create a temporary directory and files for testing
tmpdir = tempfile.mkdtemp()
# Create modelnet40_shape_names.txt file
modelnet40_path = os.path.join(tmpdir, 'modelnet40_shape_names.txt')
with open(modelnet40_path, 'w') as f:
f.write('airplane\n')
f.write('bathtub\n')
f.write('bed\n')
f.write('bench\n')
f.write('bicycle\n')
# Create a label mapping CSV file
mapping_path = os.path.join(tmpdir, 'label_mapping.tsv')
with open(mapping_path, 'w') as f:
f.write('category\tModelNet40\n')
f.write('syn_airplane\tairplane\n')
f.write('syn_bathtub\tbathtub\n')
f.write('syn_bed\tbed\n')
# Change to the temp directory so the function can find modelnet40_shape_names.txt
original_cwd = os.getcwd()
os.chdir(tmpdir)
# Now define the arguments
ARGS = {
'filename': mapping_path,
'label_from': 'category',
'label_to': 'ModelNet40'
}
- 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
|
| read_segmentation |
Ran ran; our contract draft was wrong, not the code |
wyf-ACCEPT/BackToReality/data_generation/ScanNet/ins_ply.py code served (permissive licence) · get_code("527894e637039fb3") 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 os
import json
import tempfile
# Create a temporary JSON file with valid segmentation data
temp_dir = tempfile.mkdtemp()
temp_filename = os.path.join(temp_dir, "test_segmentation.json")
# Create sample segmentation data
segmentation_data = {
"segIndices": [0, 1, 0, 2, 1, 2, 0, 1]
}
with open(temp_filename, 'w') as f:
json.dump(segmentation_data, f)
ARGS = {
"filename": temp_filename
}
- 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 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
|
| smoothl1_loss |
Ran ran; our contract draft was wrong, not the code |
xuxw98/backtoreality/detection/GroupFree3D/models/loss_helper.py code served (permissive licence) · get_code("a18fa7b4ad55d938") 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 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 torch
torch.manual_seed(0)
# Create a small error tensor (batch size 2, dimension 4)
error = torch.randn(2, 4)
# Define delta parameter
delta = 1.0
# Construct the ARGS dict with all parameters
ARGS = {
"error": error,
"delta": delta,
}
- 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 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
|
| compute_box_and_sem_cls_loss |
Not yet run unverified (harvested, no recorded run) |
xuxw98/backtoreality/detection/GroupFree3D/models/loss_helper.py code served (permissive licence) · get_code("7d9d44a980e24c22") How it ran |
| compute_center_and_sem_cls_loss |
Not yet run unverified (harvested, no recorded run) |
xuxw98/backtoreality/detection/GroupFree3D/models/loss_helper.py code served (permissive licence) · get_code("4a436f36baabf7ee") How it ran |
| compute_objectness_loss_based_on_query_points_weak |
Not yet run unverified (harvested, no recorded run) |
xuxw98/backtoreality/detection/GroupFree3D/models/loss_helper.py code served (permissive licence) · get_code("137a1dae05a132ca") How it ran |
| get_loss_weak |
Not yet run unverified (harvested, no recorded run) |
xuxw98/backtoreality/detection/GroupFree3D/models/loss_helper.py code served (permissive licence) · get_code("a8c59f9640373662") How it ran |
| read_mesh_vertices |
Not yet run unverified (harvested, no recorded run) |
wyf-ACCEPT/BackToReality/data_generation/ScanNet/scannet_utils.py code served (permissive licence) · get_code("f772d38e5bc06661") How it ran |