| apply_mlp |
Ran ran on a synthesized input |
brown-ivl/ConDor/ConDor/auto_encoder/tfn_atlasnet.py code served (permissive licence) · get_code("a43929f6265ac2c2") 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 2, dtype family float, shape (2, 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 tensorflow as tf
import numpy as np
from tensorflow.keras.layers import Dense, BatchNormalization, Activation, Dropout
# Set seed for reproducibility
tf.random.set_seed(0)
np.random.seed(0)
# Create a small input tensor (batch_size=2, features=4)
x = tf.constant(np.random.randn(2, 4).astype(np.float32))
# Create MLP structure: list of dicts with 'layer' and 'bn_layer' keys
mlp = [
{
'layer': Dense(3, activation=None), # Output dim=3
'bn_layer': BatchNormalization()
},
{
'layer': Dense(5, activation=None), # Output dim=5
'bn_layer': BatchNormalization()
}
]
# Build the layers by calling them once to initialize weights
# This is necessary for Keras layers to be properly initialized
temp = x
for block in mlp:
temp = block['layer'](temp)
temp = block['bn_layer'](temp)
ARGS = {
'x': x,
'mlp': mlp
}
- 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 2, dtype family float, shape (2, 5) — shape (2, 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
|
| eqvar_heads_fuzion |
Ran ran on a synthesized input |
brown-ivl/ConDor/ConDor/network_utils/convolution.py code served (permissive licence) · get_code("95ec15b1571be826") 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 tensorflow as tf
import numpy as np
# Analyze the function:
# - Takes X as input
# - Iterates over X (so X is iterable)
# - For each x in X, iterates over x (so x is iterable)
# - For each l in x, accesses x[l] (so x is dict-like)
# - Concatenates lists of tensors using Concatenate() layer
# - Returns a dict of concatenated tensors
# Build sample data: X should be a list of dicts
# Each dict maps string keys to tensors
# The function will group tensors by key and concatenate them
# Create sample tensors (small, CPU only)
tensor1_key_a = tf.constant([[1.0, 2.0, 3.0, 4.0]], dtype=tf.float32) # shape (1, 4)
tensor1_key_b = tf.constant([[5.0, 6.0, 7.0, 8.0]], dtype=tf.float32) # shape (1, 4)
tensor2_key_a = tf.constant([[9.0, 10.0, 11.0, 12.0]], dtype=tf.float32) # shape (1, 4)
tensor2_key_b = tf.constant([[13.0, 14.0, 15.0, 16.0]], dtype=tf.float32) # shape (1, 4)
# Create list of dicts
dict1 = {
'a': tensor1_key_a,
'b': tensor1_key_b
}
dict2 = {
'a': tensor2_key_a,
'b': tensor2_key_b
}
X = [dict1, dict2]
ARGS = {
'X': X
}
- 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 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
|
| grid_sampler |
Ran ran on a synthesized input |
brown-ivl/ConDor/ConDor/network_utils/pooling.py code served (permissive licence) · get_code("183d074ff7b98277") 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 tensorflow as tf
import numpy as np
# Set seed for reproducibility
tf.random.set_seed(0)
# Create small test tensors
batch_size = 2
num_points = 4
num_points_target = 2
# Create x: shape (batch_size, num_points, 3) - 3D coordinates
# Using small values so they round to distinct grid cells
x = tf.constant([
[[1.1, 2.2, 3.3], [1.5, 2.5, 3.5], [5.1, 5.2, 5.3], [5.5, 5.6, 5.7]],
[[10.1, 10.2, 10.3], [10.5, 10.6, 10.7], [15.1, 15.2, 15.3], [15.5, 15.6, 15.7]]
], dtype=tf.float32)
cell_size = 1.0
ARGS = {
"x": x,
"cell_size": cell_size,
"num_points_target": num_points_target
}
- 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 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
|
| grid_sampler_ |
Ran ran on a synthesized input |
brown-ivl/ConDor/ConDor/network_utils/pooling.py code served (permissive licence) · get_code("87f376a5a795f16c") 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 tensorflow as tf
import numpy as np
# Set seed for reproducibility
tf.random.set_seed(0)
np.random.seed(0)
# Create small test tensors
batch_size = 2
num_points = 4
spatial_dims = 3
# x: (batch_size, num_points, spatial_dims) - 3D point coordinates
x = tf.constant(np.random.uniform(0, 10, (batch_size, num_points, spatial_dims)), dtype=tf.float32)
# cell_size: scalar controlling grid resolution
cell_size = 2.0
# num_points_target: target number of points to sample
num_points_target = 2
ARGS = {
"x": x,
"cell_size": cell_size,
"num_points_target": num_points_target
}
- 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 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
|
| mask |
Ran ran on a synthesized input |
brown-ivl/ConDor/ConDor/network_utils/convolution.py code served (permissive licence) · get_code("8b561ee6fdb8f3fd") 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 tensorflow as tf
import numpy as np
# Create a small mask tensor (batch=2, spatial dims)
mask_value = tf.constant([[1.0, 0.0, 1.0],
[0.0, 1.0, 1.0]], dtype=tf.float32)
# Create a dict with integer keys mapping to tensors
# The function multiplies mask_ (expanded to [..., 1, 1]) with x[l]
# So x[l] should be a tensor with at least 2 extra dimensions for the expand_dims to work
x_dict = {
0: tf.constant(np.random.randn(2, 3, 4, 5), dtype=tf.float32),
1: tf.constant(np.random.randn(2, 3, 6, 7), dtype=tf.float32),
}
ARGS = {
'x': x_dict,
'mask': mask_value
}
- 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 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
|
| norml2 |
Ran ran on a synthesized input |
brown-ivl/ConDor/ConDor/network_utils/activations.py code served (permissive licence) · get_code("83c97d74407b4755") 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 1, dtype family float, shape (2,) as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import tensorflow as tf
import numpy as np
# Create a small test tensor
x = tf.constant([[1.0, 2.0, 3.0, 4.0],
[5.0, 6.0, 7.0, 8.0]], dtype=tf.float32)
ARGS = {
"x": x,
"axis": -1,
"keepdims": False,
"eps": 1e-07
}
- 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 1, dtype family float, shape (2,) — shape (2,) as a later run recorded it
- dtype family
- int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
- Environment
- image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
|
| patches_radius |
Ran ran on a synthesized input |
brown-ivl/ConDor/ConDor/network_utils/group_points.py code served (permissive licence) · get_code("c01f0222f247ed28") 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 float, shape (2, 1, 1) 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 sq_norm tensor with shape (batch_size, num_points, 1)
# batch_size = 2, num_points = 4
batch_size = 2
num_points = 4
sq_norm = tf.constant(np.random.rand(batch_size, num_points, 1), dtype=tf.float32)
# Test with different radius types
radius_float = 0.5
ARGS = {
"radius": radius_float,
"sq_norm": sq_norm,
}
- 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 float, shape (2, 1, 1) — shape (2, 1, 1) 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
|
| set_mlp |
Ran ran on a synthesized input |
brown-ivl/ConDor/ConDor/auto_encoder/tfn_atlasnet.py code served (permissive licence) · get_code("f1475b36486b7bbe") How it ranRan in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned list, ndim 1, dtype family float; no output shape is stated. The image it ran in was not recorded. If your copy returns the same type and ndim on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import tensorflow as tf
from tensorflow.keras.layers import Dense, BatchNormalization, Activation, Dropout
# Define arguments for set_mlp function
units = [64, 32, 16] # List of unit sizes for each layer
momentum = 0.99 # Momentum value for BatchNormalization
ARGS = {
'units': units,
'momentum': momentum
}
- 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 list, ndim 1, dtype family float — a list output has no array shape of its own; none is stated
- dtype family
- int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
- Environment
- image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
|
| set_sphere_weights |
Ran ran on a synthesized input |
brown-ivl/ConDor/ConDor/auto_encoder/tfn_atlasnet.py code served (permissive licence) · get_code("34d3cd3a8304196e") 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 tensorflow as tf
from tensorflow.keras.layers import Dense, BatchNormalization, Activation, Dropout
def set_sphere_weights(units, types):
weights = dict()
for l in types:
if int(l) == 0:
weights[l] = Dense(units=units)
else:
weights[l] = Dense(units=units, use_bias=False)
return weights
ARGS = {
"units": 16,
"types": [0, 1, 2]
}
- 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 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
|
| sq_dist_mat |
Ran ran on a synthesized input |
brown-ivl/ConDor/ConDor/evaluators/train_pointnet_cls2.py code served (permissive licence) · get_code("bc0a1952c0374318") 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 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 tensorflow as tf
import numpy as np
# Set seed for reproducibility
tf.random.set_seed(0)
np.random.seed(0)
# Create small tensors with distinct dimensions
# x: shape (batch=2, num_points=3, dim=4)
# y: shape (batch=2, num_points=5, dim=4)
x = tf.constant(np.random.randn(2, 3, 4).astype(np.float32))
y = tf.constant(np.random.randn(2, 5, 4).astype(np.float32))
ARGS = {
"x": x,
"y": y,
}
- 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 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
|
| squash |
Ran ran on a synthesized input |
brown-ivl/ConDor/ConDor/network_utils/activations.py code served (permissive licence) · get_code("6ee731af0229a9ba") 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 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 tensorflow as tf
import numpy as np
# Create a small tensor for testing
# Shape: (batch_size=2, feature_dim=4, reduce_dim=3)
# The function reduces over axis=-2, so we need at least 2 dimensions
# Making it (2, 3, 4) so axis=-2 reduces over dimension of size 3
x = tf.constant(np.random.randn(2, 3, 4).astype(np.float32))
b = 1.0
eps = 1e-07
bias = tf.constant(np.array([0.1, 0.2, 0.3]).astype(np.float32), shape=(1, 3, 1))
ARGS = {
"x": x,
"b": b,
"eps": eps,
"bias": bias,
}
- 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 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
|
| std |
Ran ran on a synthesized input |
brown-ivl/ConDor/ConDor/evaluators/train_pointnet_cls2.py code served (permissive licence) · get_code("95a1e02c41de556a") 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 tensorflow as tf
import numpy as np
# Create a small test tensor with distinct dimensions
# Using shape (2, 4) - batch size 2, feature dimension 4
x = tf.constant([[1.0, 2.0, 3.0, 4.0],
[5.0, 6.0, 7.0, 8.0]], dtype=tf.float32)
ARGS = {
'x': x,
'axis_mean': 0,
'axis_norm': 1
}
- 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 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
|
| tf_heaviside |
Ran ran on a synthesized input |
brown-ivl/ConDor/ConDor/network_utils/sh_conv.py code served (permissive licence) · get_code("492443ff0f1a5a31") 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 2, 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 tensorflow as tf
import numpy as np
def tf_heaviside(X):
return tf.maximum(0.0, tf.sign(X))
# Create a small TensorFlow tensor with both positive and negative values
# to test the heaviside function behavior
X = tf.constant([[-2.0, -1.0, 0.5, 3.0],
[-0.5, 1.5, -3.0, 2.0]], dtype=tf.float32)
ARGS = {
"X": X
}
- 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 2, dtype family float — no output shape is stated: observe_signature.py recorded SymbolicTensor ndim 2, which disagrees with the fixture run
- 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
|
| tf_segment_indicator_ |
Ran ran on a synthesized input |
brown-ivl/ConDor/ConDor/network_utils/sh_conv.py code served (permissive licence) · get_code("b7f5b304241048ea") 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 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 tensorflow as tf
import numpy as np
def tf_heaviside(X):
return tf.maximum(0.0, tf.sign(X))
def tf_segment_indicator_(X, a, b):
return tf_heaviside(X - a) - tf_heaviside(X - b)
# Create small test tensors
X = tf.constant([[-2.0, -1.0, 0.5, 2.0],
[-1.5, 0.0, 1.5, 3.0]], dtype=tf.float32)
a = tf.constant(-1.0, dtype=tf.float32)
b = tf.constant(1.5, dtype=tf.float32)
ARGS = {
"X": X,
"a": a,
"b": b
}
- 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 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
|
| tf_segment_indictor |
Ran ran on a synthesized input |
brown-ivl/ConDor/ConDor/network_utils/sh_conv.py code served (permissive licence) · get_code("645fc9c3ed7714e6") 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 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 tensorflow as tf
import numpy as np
# Create small test tensors
X = tf.constant([[-2.0, -1.0, 0.0, 1.0], [2.0, 3.0, 4.0, 5.0]], dtype=tf.float32)
r = tf.constant(1.5, dtype=tf.float32)
sigma = tf.constant(0.5, dtype=tf.float32)
ARGS = {
"X": X,
"r": r,
"sigma": sigma
}
- 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 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
|
| tf_unique_with_inverse |
Ran ran on a synthesized input |
brown-ivl/ConDor/ConDor/network_utils/group_points.py code served (permissive licence) · get_code("cb175242ae058123") 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 tensorflow as tf
# The function takes a single parameter x, which should be a 1D tensor
# The function calls tf.unique on x, which requires a tensor
# Create a small 1D tensor with some duplicate values
x = tf.constant([1, 2, 2, 3, 1, 4], dtype=tf.int32)
ARGS = {
"x": x
}
- 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 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
|
| tf_unique_with_inverse |
Ran ran on a synthesized input |
brown-ivl/ConDor/ConDor/network_utils/pooling.py code served (permissive licence) · get_code("30fc09c6037ff867") 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 tensorflow as tf
# Create a small 1D tensor with some repeated values
x = tf.constant([1, 2, 3, 2, 1, 4], dtype=tf.int32)
ARGS = {
"x": x
}
- 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 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
|
| var |
Ran ran on a synthesized input |
brown-ivl/ConDor/ConDor/evaluators/train_pointnet_cls2.py code served (permissive licence) · get_code("9fb46aab78071109") 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 tensorflow as tf
import numpy as np
# Create a small test tensor
# Shape: (2, 4) - batch size 2, feature dimension 4
x = tf.constant([
[1.0, 2.0, 3.0, 4.0],
[5.0, 6.0, 7.0, 8.0]
], dtype=tf.float32)
ARGS = {
"x": x,
"axis_mean": 0,
"axis_norm": 1
}
- 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 tuple — a tuple output has no array shape of its own; none is stated
- Environment
- image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
|
| compute_patches_grid |
Not yet run unverified (harvested, no recorded run) |
brown-ivl/ConDor/ConDor/network_utils/group_points.py code served (permissive licence) · get_code("83e06b900f5f086d") How it ran |