| center_image |
Ran ran on a synthesized input |
haibao637/D2HC-RMVSNet/mvsnet/dataset.py code served (permissive licence) · get_code("fb6a94f3be766ec1") 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 (2, 3, 4) as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import numpy as np
# The function takes an image as input and normalizes it
# by computing mean and variance across spatial dimensions (0, 1)
# The image should be a numpy array with shape (height, width, channels)
# Create a small test image: 2x3 spatial dimensions with 4 channels
np.random.seed(0)
img = np.random.randint(0, 256, size=(2, 3, 4), dtype=np.uint8)
ARGS = {
"img": img
}
- 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 (2, 3, 4) — shape (2, 3, 4) as a later run recorded it
- dtype family
- int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
- Environment
- image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
|
| conv |
Ran ran on a synthesized input |
yhw-yhw/D2HC-RMVSNet/models/submodule.py code served (permissive licence) · get_code("57f8bde36807b129") 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": 64,
"kernel_size": 3,
"stride": 1,
"dilation": 1,
"bias": True,
}
- 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
|
| convbn |
Ran ran on a synthesized input |
yhw-yhw/D2HC-RMVSNet/models/submodule.py code served (permissive licence) · get_code("ebeb960f39a49a1f") 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': 64,
'kernel_size': 3,
'stride': 1,
'dilation': 1,
'bias': True
}
- 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
|
| convgnrelu |
Ran ran; our contract draft was wrong, not the code |
yhw-yhw/D2HC-RMVSNet/models/submodule.py code served (permissive licence) · get_code("e23d1383c35bf5b7") 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,
"dilation": 1,
"bias": True,
"group_channel": 8,
}
- 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
|
| crop |
Ran ran on a synthesized input |
haibao637/D2HC-RMVSNet/mvsnet/dataset.py code served (permissive licence) · get_code("8542218e64194c0f") 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 math
# Create a small test image (height=100, width=120, channels=3)
image = np.random.rand(100, 120, 3).astype(np.float32)
# Create camera parameters structure
# cams[1] should be indexable and contain camera intrinsics
# cams[1][0] and cams[1][1] should be arrays with at least index [2]
# These represent principal point x and y coordinates
cams = [
None, # cams[0] - not used
[
np.array([500.0, 0.0, 320.0, 0.0]), # cams[1][0] - intrinsic row with cx at index 2
np.array([0.0, 500.0, 240.0, 0.0]) # cams[1][1] - intrinsic row with cy at index 2
]
]
# Set max dimensions - these define the maximum output size
max_h = 96
max_w = 128
ARGS = {
"image": image,
"cams": cams,
"max_h": max_h,
"max_w": max_w
}
- 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
|
| get_knn_3d |
Ran ran on a synthesized input |
haibao637/D2HC-RMVSNet/mvsnet/utils.py code served (permissive licence) · get_code("ed08fe74ba4859e3") 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 EagerTensor, ndim 3, dtype family int, shape (2, 60, 20) as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import numpy as np
import tensorflow as tf
# Small test values for get_knn_3d function
batch_size = 2
depth = 4
height = 3
width = 5
channels = 3
# Create a small xyz tensor with shape (B, D, H, W, 3)
xyz = tf.random.normal((batch_size, depth, height, width, channels), dtype=tf.float32)
# Define shape tuple
shape = (batch_size, depth, height, width, channels)
# Parameters for the function
kernel_size = 5
knn_neighbors = 20
ARGS = {
"xyz": xyz,
"shape": shape,
"kernel_size": kernel_size,
"knn": knn_neighbors
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- numpy, scipy, tensorflow — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type EagerTensor, ndim 3, dtype family int, shape (2, 60, 20) — shape (2, 60, 20) 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_propability_map |
Ran ran on a synthesized input |
yhw-yhw/D2HC-RMVSNet/models/vamvsnet.py code served (permissive licence) · get_code("6b612d536ecaad39") 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, 3, 5) as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import torch
torch.manual_seed(0)
# Analyze the function:
# - prob_volume: tensor with shape (batch_size, depth_num, height, width)
# Used with: .shape, unsqueeze, repeat, torch.gather, torch.mean
# - depth: tensor with shape (batch_size, height, width)
# Used with: .unsqueeze, .repeat, torch.abs
# - depth_values: tensor
# Used with: .repeat, .permute
batch_size = 2
depth_num = 4
height = 3
width = 5
# prob_volume: (batch_size, depth_num, height, width)
prob_volume = torch.rand(batch_size, depth_num, height, width)
# depth: (batch_size, height, width)
depth = torch.rand(batch_size, height, width) * 10
# depth_values: needs to work with repeat(height, width, 1, 1).permute(2, 3, 0, 1)
# This means depth_values should be shape (1, 1, depth_num) or (depth_num,)
# After repeat(height, width, 1, 1) it becomes (height, width, 1, depth_num)
# After permute(2, 3, 0, 1) it becomes (1, depth_num, height, width)
depth_values = torch.linspace(0, 10, depth_num).reshape(1, 1, depth_num)
ARGS = {
"prob_volume": prob_volume,
"depth": depth,
"depth_values": depth_values,
}
- 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 (2, 3, 5) — shape (2, 3, 5) as a later run recorded it
- dtype family
- int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
- Environment
- image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
|
| homo_warping |
Ran ran on a synthesized input |
yhw-yhw/D2HC-RMVSNet/models/module.py code served (permissive licence) · get_code("97a56271be444a38") 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 5, dtype family float, shape (2, 4, 3, 8, 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 torch
import torch.nn as nn
torch.manual_seed(0)
# Define the required tensor arguments
batch_size = 2
channels = 4
height = 8
width = 6
num_depth = 3
# src_fea: feature map from source view [batch, channels, height, width]
src_fea = torch.randn(batch_size, channels, height, width, dtype=torch.float32)
# src_proj: source view projection matrix [batch, 4, 4]
src_proj = torch.randn(batch_size, 4, 4, dtype=torch.float32)
# ref_proj: reference view projection matrix [batch, 4, 4]
ref_proj = torch.randn(batch_size, 4, 4, dtype=torch.float32)
# depth_values: depth samples [batch, num_depth]
depth_values = torch.randn(batch_size, num_depth, dtype=torch.float32)
ARGS = {
'src_fea': src_fea,
'src_proj': src_proj,
'ref_proj': ref_proj,
'depth_values': depth_values,
}
- 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 5, dtype family float, shape (2, 4, 3, 8, 6) — shape (2, 4, 3, 8, 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
|
| homo_warping_depthwise |
Ran ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT) |
yhw-yhw/D2HC-RMVSNet/models/module.py code served (permissive licence) · get_code("31cdec41e4c82500") 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 4, dtype family float, shape (2, 4, 8, 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 torch
import torch.nn.functional as F
torch.manual_seed(0)
# Parameters for homo_warping_depthwise
batch_size = 2
channels = 4
height = 8
width = 6
# src_fea: source feature map [batch, channels, height, width]
src_fea = torch.randn(batch_size, channels, height, width)
# src_proj: source projection matrix [batch, 4, 4]
src_proj = torch.randn(batch_size, 4, 4)
# ref_proj: reference projection matrix [batch, 4, 4]
ref_proj = torch.randn(batch_size, 4, 4)
# depth_value: depth values [batch]
depth_value = torch.randn(batch_size) + 1.0 # avoid near-zero values
ARGS = {
"src_fea": src_fea,
"src_proj": src_proj,
"ref_proj": ref_proj,
"depth_value": depth_value,
}
- 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 4, dtype family float, shape (2, 4, 8, 6) — shape (2, 4, 8, 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
|
| knn |
Ran ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT) |
haibao637/D2HC-RMVSNet/mvsnet/utils.py code served (permissive licence) · get_code("fea0b2409287c761") 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 EagerTensor, ndim 3, dtype family int, shape (2, 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 tensorflow as tf
import numpy as np
# Create a small pairwise distance matrix
# Shape: (batch_size=2, num_points=4, num_points=4)
# Pairwise distances should be non-negative, symmetric
batch_size = 2
num_points = 4
# Create realistic pairwise distance matrices
adj_matrix_data = np.array([
# First batch
[[0.0, 1.2, 2.3, 3.1],
[1.2, 0.0, 1.5, 2.8],
[2.3, 1.5, 0.0, 2.1],
[3.1, 2.8, 2.1, 0.0]],
# Second batch
[[0.0, 0.9, 2.1, 2.9],
[0.9, 0.0, 1.3, 2.5],
[2.1, 1.3, 0.0, 1.8],
[2.9, 2.5, 1.8, 0.0]]
], dtype=np.float32)
adj_matrix = tf.constant(adj_matrix_data)
ARGS = {
"adj_matrix": adj_matrix,
"k": 3
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- numpy, tensorflow — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type EagerTensor, ndim 3, dtype family int, shape (2, 4, 3) — shape (2, 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
|
| layer |
Ran ran on a synthesized input |
haibao637/D2HC-RMVSNet/cnn_wrapper/network.py code served (permissive licence) · get_code("664f1649e11743ea") How it ranRan in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned function. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import tensorflow as tf
class MockNetworkLayer:
"""Mock network class that supports the layer decorator pattern."""
def __init__(self):
self.inputs = None
self.terminals = []
self.layers = {}
self._unique_names = {}
def get_unique_name(self, name):
"""Generate unique layer names."""
if name not in self._unique_names:
self._unique_names[name] = 0
else:
self._unique_names[name] += 1
return f"{name}_{self._unique_names[name]}"
def feed(self, layer_output):
"""Update terminals with new layer output."""
self.terminals = [layer_output]
def mock_op(self, *args, **kwargs):
"""Mock operation that returns a tensor."""
if len(args) > 0 and isinstance(args[0], tf.Tensor):
return args[0]
return tf.constant([[1.0, 2.0], [3.0, 4.0]])
# Create a mock layer decorator function for testing
def layer(op):
"""Decorator for composable network layers."""
def layer_decorated(self, *args, **kwargs):
"""Layer decoration."""
if self.inputs is None or (len(args) > 0 and isinstance(args[0], tf.Tensor)):
layer_output = op(self, *args, **kwargs)
return layer_output
name = kwargs.setdefault('name', self.get_unique_name(op.__name__))
if not self.terminals:
raise RuntimeError('No input variables found for layer %s.' % name)
elif len(self.terminals) == 1:
layer_input = self.terminals[0]
else:
layer_input = list(self.terminals)
layer_output = op(self, layer_input, *args, **kwargs)
self.layers[name] = layer_output
self.feed(layer_output)
return self
return layer_decorated
# Create test instance
mock_network = MockNetworkLayer()
# Create a decorated operation
@layer
def mock_decorated_op(self, *args, **kwargs):
"""A mock decorated operation."""
if len(args) > 0 and isinstance(args[0], tf.Tensor):
return args[0]
return tf.constant([[1.0, 2.0], [3.0, 4.0]])
ARGS = {
'op': mock_op
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- tensorflow — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type function — a function output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a function output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not stated
- Environment
- image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
|
| less_one_percentage |
Ran ran on a synthesized input |
haibao637/D2HC-RMVSNet/mvsnet/loss.py code served (permissive licence) · get_code("21691dc956884a92") 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 EagerTensor, 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 tensorflow as tf
import numpy as np
# Create small test tensors
batch_size = 2
height = 4
width = 3
channels = 1
# y_true: tensor with some zeros and some non-zero values
y_true = tf.constant(
np.array([[[[1.0], [2.0], [3.0]],
[[0.0], [5.0], [6.0]],
[[7.0], [0.0], [9.0]],
[[10.0], [11.0], [0.0]]],
[[[2.0], [3.0], [4.0]],
[[0.0], [6.0], [7.0]],
[[8.0], [0.0], [10.0]],
[[11.0], [12.0], [0.0]]]]),
dtype=tf.float32
)
# y_pred: predicted values
y_pred = tf.constant(
np.array([[[[1.1], [2.2], [3.3]],
[[0.1], [5.1], [6.2]],
[[7.1], [0.2], [9.3]],
[[10.2], [11.1], [0.1]]],
[[[2.1], [3.2], [4.1]],
[[0.2], [6.1], [7.1]],
[[8.1], [0.1], [10.2]],
[[11.1], [12.2], [0.2]]]]),
dtype=tf.float32
)
# interval: scalar value representing the acceptable error interval
interval = tf.constant(2.0, dtype=tf.float32)
ARGS = {
'y_true': y_true,
'y_pred': y_pred,
'interval': interval
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- numpy, tensorflow — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type EagerTensor, 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
|
| less_three_percentage |
Ran ran on a synthesized input |
haibao637/D2HC-RMVSNet/mvsnet/loss.py code served (permissive licence) · get_code("6f4c635649523f09") 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 EagerTensor, 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 tensorflow as tf
import numpy as np
# Create small test tensors
batch_size = 2
height = 4
width = 3
# y_true: tensor with some zeros and some non-zero values
# Shape: (batch_size, height, width, 1) or similar
y_true = tf.constant([
[[[1.0], [2.0], [3.0]],
[[4.0], [0.0], [6.0]],
[[7.0], [8.0], [0.0]],
[[10.0], [11.0], [12.0]]],
[[[0.0], [2.5], [3.5]],
[[4.5], [5.5], [0.0]],
[[7.5], [8.5], [9.5]],
[[0.0], [11.5], [12.5]]]
], dtype=tf.float32)
# y_pred: predictions with same shape as y_true
y_pred = tf.constant([
[[[1.1], [2.2], [3.3]],
[[4.4], [0.0], [6.6]],
[[7.7], [8.8], [0.0]],
[[10.1], [11.1], [12.1]]],
[[[0.0], [2.6], [3.6]],
[[4.6], [5.6], [0.0]],
[[7.6], [8.6], [9.6]],
[[0.0], [11.6], [12.6]]]
], dtype=tf.float32)
# interval: scalar or small tensor representing the interval for normalization
interval = tf.constant(10.0, dtype=tf.float32)
ARGS = {
"y_true": y_true,
"y_pred": y_pred,
"interval": interval
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- numpy, tensorflow — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type EagerTensor, ndim 0, dtype family float, shape () — shape () as a later run recorded it
- dtype family
- int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
- Environment
- image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
|
| load_cam |
Ran ran on a synthesized input |
haibao637/D2HC-RMVSNet/mvsnet/dataset.py code served (permissive licence) · get_code("6830d06d246cc3e7") 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 (2, 4, 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 io
# Create a mock file object with camera data
# The function expects words to be split from file.read()
# We need 29, 30, or 31 words depending on the case
# Format: 1 word (header) + 16 extrinsic + 9 intrinsic + optional depth params
# Total structure: [header, ex[0-15], intr[0-8], depth_params...]
camera_data = """header
1.0 0.0 0.0 0.0
0.0 1.0 0.0 0.0
0.0 0.0 1.0 0.0
0.0 0.0 0.0 1.0
3000.0 0.0 512.0
0.0 3000.0 384.0
0.0 0.0 1.0
100.0 2.0 128 456.0"""
mock_file = io.StringIO(camera_data)
ARGS = {
"file": mock_file,
"interval_scale": 1
}
- 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 (2, 4, 4) — shape (2, 4, 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
|
| make_nograd_func |
Ran ran; our contract draft was wrong, not the code |
yhw-yhw/D2HC-RMVSNet/utils.py code served (permissive licence) · get_code("a76fc7fb6958f97c") How it ranRan in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned function. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import torch
import torch.nn as nn
torch.manual_seed(0)
# Create a simple function that uses torch operations
def sample_func(x, y):
# This function performs some torch operations
result = x + y
return result
# Test that the function works with gradients enabled
test_x = torch.randn(2, 4, requires_grad=True)
test_y = torch.randn(2, 4, requires_grad=True)
ARGS = {
"func": sample_func
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- torch — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type function — a function output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a function output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not stated
- Environment
- image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
|
| make_recursive_func |
Ran ran; our contract draft was wrong, not the code |
yhw-yhw/D2HC-RMVSNet/utils.py code served (permissive licence) · get_code("b62bec09ceeaca79") How it ranRan in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned function. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import torch
import torch.nn as nn
torch.manual_seed(0)
# Define a simple function to be made recursive
def example_func(x):
"""A simple function that doubles its input"""
if isinstance(x, torch.Tensor):
return x * 2
elif isinstance(x, (int, float)):
return x * 2
else:
return x
# The make_recursive_func takes a function as its only parameter
ARGS = {
"func": example_func
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- torch — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type function — a function output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a function output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not stated
- Environment
- image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
|
| mvsnet_loss |
Ran ran on a synthesized input |
yhw-yhw/D2HC-RMVSNet/models/vamvsnet.py code served (permissive licence) · get_code("50fac0e8112069d0") 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.functional as F
torch.manual_seed(0)
# Create small tensors for the function
# depth_est and depth_gt should have the same shape
# mask should be broadcastable to that shape
batch_size = 2
height = 4
width = 3
# depth_est: estimated depth map
depth_est = torch.randn(batch_size, height, width, dtype=torch.float32)
# depth_gt: ground truth depth map
depth_gt = torch.randn(batch_size, height, width, dtype=torch.float32)
# mask: binary mask indicating valid pixels (will be compared to 0.5)
mask = torch.rand(batch_size, height, width, dtype=torch.float32)
ARGS = {
"depth_est": depth_est,
"depth_gt": depth_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
|
| mvsnet_loss_l1norm |
Ran ran on a synthesized input |
yhw-yhw/D2HC-RMVSNet/models/vamvsnet.py code served (permissive licence) · get_code("9c2943933ea1a82e") 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.functional as F
torch.manual_seed(0)
# Create small tensors for depth estimation and ground truth
# depth_est and depth_gt should have the same shape
# mask should be broadcastable to the same shape
batch_size = 2
height = 4
width = 3
depth_est = torch.randn(batch_size, height, width, dtype=torch.float32)
depth_gt = torch.randn(batch_size, height, width, dtype=torch.float32)
mask = torch.rand(batch_size, height, width, dtype=torch.float32)
ARGS = {
"depth_est": depth_est,
"depth_gt": depth_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
|
| non_zero_mean_absolute_diff |
Ran ran on a synthesized input |
haibao637/D2HC-RMVSNet/mvsnet/loss.py code served (permissive licence) · get_code("5c36c6f46f8628bd") 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 EagerTensor, 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 tensorflow as tf
import numpy as np
# Set seed for reproducibility
tf.random.set_seed(0)
np.random.seed(0)
# Create small tensors for the function
batch_size = 2
height = 4
width = 3
channels = 5
# y_true: batch of ground truth values with some zeros
y_true = tf.constant(
np.random.randn(batch_size, height, width, channels).astype(np.float32)
)
# Set some values to zero to test the masking
y_true_np = y_true.numpy()
y_true_np[0, 0, 0, 0] = 0.0
y_true_np[1, 1, 1, 1] = 0.0
y_true = tf.constant(y_true_np)
# y_pred: batch of predictions with same shape
y_pred = tf.constant(
np.random.randn(batch_size, height, width, channels).astype(np.float32)
)
# interval: scaling factors for each batch element
interval = tf.constant([1.0, 2.0], dtype=tf.float32)
ARGS = {
"y_true": y_true,
"y_pred": y_pred,
"interval": interval,
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- numpy, tensorflow — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type EagerTensor, 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
|
| read_camera_parameters |
Ran ran on a synthesized input |
yhw-yhw/D2HC-RMVSNet/fusion.py code served (permissive licence) · get_code("681f7cd39c206d61") 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 camera parameters file with valid format
temp_file = tempfile.NamedTemporaryFile(mode='w', delete=False, suffix='.txt')
filename = temp_file.name
# Write camera parameters in the expected format
# Line 0: some header
# Lines 1-4: 4x4 extrinsics matrix
# Line 5-6: empty/header
# Lines 7-9: 3x3 intrinsics matrix
lines = [
"header",
"1.0 0.0 0.0 0.0",
"0.0 1.0 0.0 0.0",
"0.0 0.0 1.0 0.0",
"0.0 0.0 0.0 1.0",
"intrinsics",
"header2",
"500.0 0.0 320.0",
"0.0 500.0 240.0",
"0.0 0.0 1.0"
]
temp_file.write('\n'.join(lines))
temp_file.close()
ARGS = {
"filename": filename,
"scale": 0.5,
"index": 10.0,
"flag": 0
}
- 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
|
| read_cameras_binary |
Ran ran; our contract draft was wrong, not the code |
haibao637/D2HC-RMVSNet/mvsnet/colmap2mvsnet.py code served (permissive licence) · get_code("0bf4b207ce0d106a") How it ranRan in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1) 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 collections
import struct
import numpy as np
import tempfile
import os
CameraModel = collections.namedtuple('CameraModel', ['model_id', 'model_name', 'num_params'])
Camera = collections.namedtuple('Camera', ['id', 'model', 'width', 'height', 'params'])
CAMERA_MODELS = {CameraModel(model_id=0, model_name='SIMPLE_PINHOLE', num_params=3), CameraModel(model_id=1, model_name='PINHOLE', num_params=4), CameraModel(model_id=2, model_name='SIMPLE_RADIAL', num_params=4), CameraModel(model_id=3, model_name='RADIAL', num_params=5), CameraModel(model_id=4, model_name='OPENCV', num_params=8), CameraModel(model_id=5, model_name='OPENCV_FISHEYE', num_params=8), CameraModel(model_id=6, model_name='FULL_OPENCV', num_params=12), CameraModel(model_id=7, model_name='FOV', num_params=5), CameraModel(model_id=8, model_name='SIMPLE_RADIAL_FISHEYE', num_params=4), CameraModel(model_id=9, model_name='RADIAL_FISHEYE', num_params=5), CameraModel(model_id=10, model_name='THIN_PRISM_FISHEYE', num_params=12)}
CAMERA_MODEL_IDS = dict([(camera_model.model_id, camera_model) for camera_model in CAMERA_MODELS])
# Create a temporary binary file with valid camera data
temp_file = tempfile.NamedTemporaryFile(delete=False, suffix='.bin')
temp_path = temp_file.name
try:
# Write number of cameras (2 cameras)
num_cameras = 2
temp_file.write(struct.pack('<Q', num_cameras))
# Write first camera
camera_id_1 = 1
model_id_1 = 1 # PINHOLE with 4 params
width_1 = 640
height_1 = 480
params_1 = [500.0, 500.0, 320.0, 240.0] # fx, fy, cx, cy
temp_file.write(struct.pack('<iiQQ', camera_id_1, model_id_1, width_1, height_1))
temp_file.write(struct.pack('<' + 'd' * 4, *params_1))
# Write second camera
camera_id_2 = 2
model_id_2 = 2 # SIMPLE_RADIAL with 4 params
width_2 = 800
height_2 = 600
params_2 = [600.0, 400.0, 300.0, 0.1] # fx, fy, cx, cy, k1
temp_file.write(struct.pack('<iiQQ', camera_id_2, model_id_2, width_2, height_2))
temp_file.write(struct.pack('<' + 'd' * 4, *params_2))
temp_file.close()
ARGS = {
'path_to_model_file': temp_path
}
finally:
pass
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1
- 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
|
| read_cameras_text |
Ran ran; our contract draft was wrong, not the code |
haibao637/D2HC-RMVSNet/mvsnet/colmap2mvsnet.py code served (permissive licence) · get_code("8a38e306ff4c5b42") How it ranRan in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1) 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 collections
import numpy as np
import tempfile
import os
Camera = collections.namedtuple('Camera', ['id', 'model', 'width', 'height', 'params'])
# Create a temporary file with valid camera data in the expected format
temp_file = tempfile.NamedTemporaryFile(mode='w', delete=False, suffix='.txt')
temp_path = temp_file.name
# Write sample camera data
# Format: camera_id model width height params...
temp_file.write("# Camera list\n")
temp_file.write("1 SIMPLE_PINHOLE 640 480 320.5 240.5 500.0\n")
temp_file.write("2 PINHOLE 800 600 400.0 300.0 600.0 0.1\n")
temp_file.close()
ARGS = {
'path': temp_path
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1
- 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
|
| read_img |
Ran ran, honoured the contract we drafted |
yhw-yhw/D2HC-RMVSNet/fusion.py code served (permissive licence) · get_code("a1db096963f65ed2") How it ranRan in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned ndarray, ndim 3, dtype family float, shape (4, 3, 3) as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import numpy as np
from PIL import Image
import tempfile
import os
# Create a temporary image file for testing
temp_dir = tempfile.mkdtemp()
temp_filename = os.path.join(temp_dir, "test_image.png")
# Create a small test image (4x3 pixels, RGB)
test_array = np.random.randint(0, 256, (4, 3, 3), dtype=np.uint8)
test_image = Image.fromarray(test_array, mode='RGB')
test_image.save(temp_filename)
ARGS = {
"filename": temp_filename
}
- 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 ndarray, ndim 3, dtype family float, shape (4, 3, 3) — shape (4, 3, 3) as a later run recorded it
- dtype family
- int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
- Environment
- image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
|
| read_mask |
Ran ran on a synthesized input |
yhw-yhw/D2HC-RMVSNet/fusion.py code served (permissive licence) · get_code("5dc8398ed1ff8701") 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, 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
from PIL import Image
import tempfile
import os
# Create a temporary image file for testing
temp_dir = tempfile.mkdtemp()
temp_image_path = os.path.join(temp_dir, "test_image.png")
# Create a simple test image with PIL
test_array = np.array([[100, 150], [200, 50]], dtype=np.uint8)
test_image = Image.fromarray(test_array, mode='L')
test_image.save(temp_image_path)
# Define ARGS dict with the filename parameter
ARGS = {
"filename": temp_image_path
}
- 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 ndarray, ndim 2, dtype family float, shape (2, 2) — shape (2, 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
|
| read_next_bytes |
Ran ran, honoured the contract we drafted |
haibao637/D2HC-RMVSNet/mvsnet/colmap2mvsnet.py code served (permissive licence) · get_code("56858e04e6fdb2ff") How it ranRan in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1) 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 struct
import io
# Create a binary file-like object with test data
# We'll pack some values and then read them back
test_data = struct.pack('<hfi', 42, 3.14, 100)
fid = io.BytesIO(test_data)
ARGS = {
'fid': fid,
'num_bytes': 10, # 2 bytes (h) + 4 bytes (f) + 4 bytes (i) = 10 bytes
'format_char_sequence': 'hfi',
'endian_character': '<'
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1
- 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
|
| reduce_scalar_outputs |
Ran ran on a synthesized input |
yhw-yhw/D2HC-RMVSNet/utils.py code served (permissive licence) · get_code("c84727567da9be2b") 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 torch
import torch.distributed as dist
torch.manual_seed(0)
# The function expects a dict mapping string keys to scalar tensor values
# that can be stacked and reduced across distributed processes
scalar_outputs = {
'loss': torch.tensor(0.5),
'accuracy': torch.tensor(0.95),
'perplexity': torch.tensor(2.3),
}
ARGS = {
'scalar_outputs': scalar_outputs,
}
- 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 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
|
| PQ |
Not yet run unverified (harvested, no recorded run) |
haibao637/D2HC-RMVSNet/mvsnet/homography_warping.py code served (permissive licence) · get_code("c41b40eafbf6e881") How it ran |
| get_homography |
Not yet run unverified (harvested, no recorded run) |
haibao637/D2HC-RMVSNet/mvsnet/homography_warping.py code served (permissive licence) · get_code("dc432dc54a530ceb") How it ran |
| grad_d |
Not yet run unverified (harvested, no recorded run) |
haibao637/D2HC-RMVSNet/mvsnet/homography_warping.py code served (permissive licence) · get_code("39256ffa5e435bee") How it ran |
| homo_warping_depthwise_ori |
Not yet run unverified (harvested, no recorded run) |
yhw-yhw/D2HC-RMVSNet/models/module.py code served (permissive licence) · get_code("8c215efdfa14a940") How it ran |
| pairwise_distance |
Not yet run unverified (harvested, no recorded run) |
haibao637/D2HC-RMVSNet/mvsnet/utils.py pointer only (licence: MIT); the stored copy get_code serves, from af13s/dgcnn-amino, is pointer only (licence: NONE) · get_code("3d90b05b13b0c0b9") How it ranThe body of this sample is withheld: this paper's link allows the body inline (MIT), but get_code serves the stored copy, first harvested from af13s/dgcnn-amino, and GitHub detected no licence in that repository when it was checked. The setup block that called it is withheld with it, because it is written against that body. source_path and origin say where the code lives, to read under the repository's own terms. No invocation recorded. |
| read_gipuma_dmb |
Not yet run unverified (harvested, no recorded run) |
haibao637/D2HC-RMVSNet/mvsnet/depthfusion.py code served (permissive licence) · get_code("f6147a9b9d73ca5e") How it ran |
| scale_camera |
Not yet run unverified (harvested, no recorded run) |
haibao637/D2HC-RMVSNet/mvsnet/preprocess.py code served (permissive licence) · get_code("234f6f5aa22f6f5c") How it ran |