| BatchMLP |
Ran ran on a synthesized input |
bdsaglam/torch-scae/torch_scae/nn_ext.py code served (permissive licence) · get_code("d6debf9640bd00f2") 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 = {
'n_mlps': 3,
'sizes': [4, 8, 6, 2],
'activation': nn.ReLU,
'activate_final': False,
'bias_final': 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
|
| BestStack |
Ran ran on a synthesized input |
KohavTal/SCAE_Project/torch_scae/nn_ext.py code served (permissive licence) · get_code("3a64054158d703c5") 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, 32, 64],
"kernel_sizes": [3, 3, 3],
"strides": [1, 2, 1],
"activation": nn.ReLU,
"activate_final": True,
"dropout": 0.1
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- torch — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type Sequential — a Sequential output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a Sequential output the recorded ndim 1 and dtype family float describe that coercion, not the output, and are not stated
- Environment
- image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
|
| Conv2dStack |
Ran ran on a synthesized input |
KohavTal/SCAE_Project/torch_scae/nn_ext.py code served (permissive licence) · get_code("1f7981add3e51350") How it ranRan in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned Sequential. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import torch
import torch.nn as nn
torch.manual_seed(0)
# Define arguments for Conv2dStack
ARGS = {
'in_channels': 3,
'out_channels': [16, 32, 64],
'kernel_sizes': [3, 3, 3],
'strides': [1, 2, 1],
'activation': nn.ReLU,
'activate_final': 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
|
| MLP |
Ran ran on a synthesized input |
KohavTal/SCAE_Project/torch_scae/nn_ext.py code served (permissive licence) · get_code("018f862a3ae6ed96") 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 = {
'sizes': [4, 8, 16, 3],
'activation': nn.ReLU,
'activate_final': True,
'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
|
| affine_grid |
Ran ran on a synthesized input |
bdsaglam/torch-scae/torch_scae/part_decoder.py code served (permissive licence) · get_code("7972654ad56da3c4") 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, 5, 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 torch
torch.manual_seed(0)
# The function takes:
# - matrix: a tensor of shape (batch, 6) representing affine transformation parameters
# - size: a tuple/list where size[-2:] gives (height, width)
# Create a small batch of affine transformation matrices
# Shape: (batch_size=2, 6 parameters)
matrix = torch.randn(2, 6)
# Create a size tuple - can be any shape as long as last 2 elements are height and width
# Using (1, 3, 4, 5) to be distinct: 1 channel, 3 batch(?), 4 height, 5 width
size = (1, 3, 4, 5)
ARGS = {
"matrix": matrix,
"size": size,
}
- 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, 5, 2) — shape (2, 4, 5, 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
|
| capsule_l2_loss |
Ran ran on a synthesized input |
KohavTal/SCAE_Project/torch_scae/object_decoder.py code served (permissive licence) · get_code("dbc3e25948c02028") How it ranRan in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned tuple, ndim 1, dtype family float; no output shape is stated. The image it ran in was not recorded. If your copy returns the same type and ndim on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import torch
torch.manual_seed(0)
# Create a small tensor for caps_presence
# Shape: (batch_size=2, num_caps=4)
# Values should be in a reasonable range for capsule activations (e.g., 0-1)
caps_presence = torch.rand(2, 4)
# Number of classes
n_classes = 2
# Optional within_example_constant (set to None to use default calculation)
within_example_constant = None
ARGS = {
"caps_presence": caps_presence,
"n_classes": n_classes,
"within_example_constant": within_example_constant,
}
- 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
|
| combined_shape |
Ran ran; our contract draft was wrong, not the code |
KohavTal/SCAE_Project/torch_scae/general_utils.py pointer only (licence: Apache-2.0); the stored copy get_code serves, from yinglunxu/reward_poisoning_attack_drl, is pointer only (licence: NONE) · get_code("57542f87e248db45") How it ranThe body of this sample is withheld: this paper's link allows the body inline (Apache-2.0), but get_code serves the stored copy, first harvested from yinglunxu/reward_poisoning_attack_drl, 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. A run is recorded. |
| conv_output_shape |
Ran ran on a synthesized input |
KohavTal/SCAE_Project/torch_scae/nn_utils.py code served (permissive licence) · get_code("46a280d5631eb673") 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 int; 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 numpy as np
from typing import Tuple
torch.manual_seed(0)
# The function conv_output_shape takes:
# - input_shape: Tuple[int, int, int] - a 3-tuple representing (channels, height, width)
# - out_channels: int - number of output channels
# - kernel_size: int - size of the convolutional kernel
# - stride: int - stride of the convolution (default=1)
# - padding: int - padding applied to input (default=0)
# Construct valid arguments
input_shape = (3, 32, 32) # 3 input channels, 32x32 spatial dimensions
out_channels = 16
kernel_size = 3
stride = 1
padding = 0
ARGS = {
"input_shape": input_shape,
"out_channels": out_channels,
"kernel_size": kernel_size,
"stride": stride,
"padding": padding,
}
- 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, ndim 1, dtype family int — a tuple output has no array shape of its own; none is stated
- dtype family
- int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
- Environment
- image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
|
| conv_output_size |
Ran ran on a synthesized input |
KohavTal/SCAE_Project/torch_scae/nn_utils.py code served (permissive licence) · get_code("6c8cdd002826e750") 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 numpy as np
torch.manual_seed(0)
ARGS = {
"in_size": 32,
"kernel_size": 5,
"stride": 1,
"padding": 0
}
- 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 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
|
| cross_entropy_safe |
Ran ran on a synthesized input |
KohavTal/SCAE_Project/torch_scae/math_ops.py code served (permissive licence) · get_code("f65130ec27f57098") How it ranRan in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned Tensor, ndim 0, dtype family float, shape () as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import torch
torch.manual_seed(0)
# Create small tensors for the function parameters
# true_probs: probability distribution (should sum to 1 along dim)
# probs: predicted probabilities (should sum to 1 along dim)
batch_size = 2
num_classes = 4
# Create true_probs as a valid probability distribution
true_probs = torch.tensor([
[0.1, 0.2, 0.3, 0.4],
[0.25, 0.25, 0.25, 0.25]
], dtype=torch.float32)
# Create probs as predicted probabilities
probs = torch.tensor([
[0.15, 0.25, 0.35, 0.25],
[0.2, 0.3, 0.25, 0.25]
], dtype=torch.float32)
ARGS = {
"true_probs": true_probs,
"probs": probs,
"dim": -1
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- torch — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type 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
|
| geometric_transform |
Ran ran on a synthesized input |
KohavTal/SCAE_Project/torch_scae/cv_ops.py code served (permissive licence) · get_code("eaacf4c75671e1c5") 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, 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 math
torch.manual_seed(0)
# Create a small pose tensor with shape [..., 6]
# Using batch size 2, so shape is (2, 6)
pose_tensor = torch.randn(2, 6)
ARGS = {
"pose_tensor": pose_tensor,
"similarity": False,
"nonlinear": True,
"as_matrix": 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 Tensor, ndim 2, dtype family float, shape (2, 6) — shape (2, 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
|
| geometric_transform |
Ran ran on a synthesized input |
bdsaglam/torch-scae/torch_scae/cv_ops.py code served (permissive licence) · get_code("aee48248137bef44") 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, 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 math
torch.manual_seed(0)
# Create a pose tensor with shape [..., 6]
# Using batch size 2, so shape is [2, 6]
pose_tensor = torch.randn(2, 6)
ARGS = {
"pose_tensor": pose_tensor,
"similarity": False,
"nonlinear": True,
"as_matrix": 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 Tensor, ndim 2, dtype family float, shape (2, 6) — shape (2, 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
|
| get_latest_file_iteration |
Ran ran on a synthesized input |
KohavTal/SCAE_Project/torch_scae/general_utils.py code served (permissive licence) · get_code("7b5f49577ae87818") 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 pathlib
import tempfile
import os
# Create a temporary directory with test files
temp_dir = tempfile.mkdtemp()
# Create some test files with numbers in their names
test_files = [
"model_iteration_5.pt",
"model_iteration_12.pt",
"model_iteration_8.pt",
"checkpoint_3.pth",
]
for filename in test_files:
filepath = os.path.join(temp_dir, filename)
with open(filepath, 'w') as f:
f.write("dummy content")
ARGS = {
'folder': temp_dir,
'pattern': '*'
}
- 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
|
| hex_to_rgb |
Ran ran on a synthesized input |
akosiorek/stacked_capsule_autoencoders/capsules/plot.py code served (permissive licence) · get_code("4c1d49543510213d") How it ranRan in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned tuple, ndim 1, dtype family float; no output shape is stated. The image it ran in was not recorded. If your copy returns the same type and ndim on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import torch
import numpy as np
def hex_to_rgb(value):
value = value.lstrip('#')
lv = len(value)
return tuple((int(value[i:i + lv // 3], 16) / 255.0 for i in range(0, lv, lv // 3)))
# The function takes a hex color string and converts it to RGB
# It expects a string starting with '#' followed by hex digits
# Common formats: '#RGB' (3 chars), '#RRGGBB' (6 chars), '#RRGGBBAA' (8 chars)
ARGS = {
'value': '#FF5733'
}
- 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, 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
|
| invert_affine |
Ran ran on a synthesized input |
bdsaglam/torch-scae/torch_scae/part_decoder.py code served (permissive licence) · get_code("00f1c79b7fde1b74") 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, 2, 3) as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import torch
torch.manual_seed(0)
# Construct a batch of (..., 2, 3) affine matrices
# Shape: (batch_size, 2, 3) where:
# - First 2 rows, 2 cols: linear transformation (2x2)
# - First 2 rows, last col: translation (2x1)
matrix = torch.tensor([
[[1.0, 0.5, 2.0],
[0.3, 1.2, 3.0]],
[[0.8, 0.2, 1.5],
[0.1, 0.9, 2.5]]
], dtype=torch.float32)
ARGS = {
"matrix": matrix
}
- 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, 2, 3) — shape (2, 2, 3) as a later run recorded it
- dtype family
- int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
- Environment
- image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
|
| load_data_from_mat |
Ran ran on a synthesized input |
YuZiHanorz/stacked_capsule_autoencoders/load_affnist.py code served (permissive licence) · get_code("dba87d282c88c543") 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 scipy.io as sio
import tempfile
import os
import numpy as np
# Create a temporary .mat file with test data
temp_dir = tempfile.mkdtemp()
mat_path = os.path.join(temp_dir, "test_data.mat")
# Create a simple structure to save
test_struct = {}
test_struct['simple_array'] = np.array([1, 2, 3, 4])
test_struct['nested_value'] = 42
# Save as .mat file
sio.savemat(mat_path, test_struct)
ARGS = {
'path': mat_path
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- numpy, scipy — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type 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
|
| log_safe |
Ran ran on a synthesized input |
KohavTal/SCAE_Project/torch_scae/math_ops.py code served (permissive licence) · get_code("dcc02359a095982c") 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 tensor with positive values to test log_safe
# Using a 2x4 tensor with values > eps to test the main path
tensor = torch.tensor([[0.5, 1.0, 2.0, 0.1],
[0.01, 100.0, 0.0001, 0.5]], dtype=torch.float32)
eps = 1e-16
ARGS = {
"tensor": tensor,
"eps": eps
}
- 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
|
| measure_shape |
Ran ran on a synthesized input |
KohavTal/SCAE_Project/torch_scae/nn_utils.py code served (permissive licence) · get_code("835457d36160df6b") 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 Size. 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)
class SimpleNetwork(nn.Module):
def __init__(self):
super().__init__()
self.linear1 = nn.Linear(4, 8)
self.linear2 = nn.Linear(8, 3)
def forward(self, x):
x = self.linear1(x)
x = self.linear2(x)
return x
network = SimpleNetwork()
input_shape = (4,)
input_dtype = torch.float32
ARGS = {
"network": network,
"input_shape": input_shape,
"input_dtype": input_dtype,
}
- 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 Size — a Size output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a Size output the recorded ndim 1 and dtype family int describe that coercion, not the output, and are not stated
- Environment
- image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
|
| memoize_arg_transform |
Ran ran on a synthesized input |
akosiorek/stacked_capsule_autoencoders/capsules/models/model.py code served (permissive licence) · get_code("8c55f32be627e0ca") How it ranRan in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned tuple, ndim 1, dtype family float; no output shape is stated. The image it ran in was not recorded. If your copy returns the same type and ndim on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import torch
import numpy as np
torch.manual_seed(0)
# The function memoize_arg_transform takes args and kwargs as parameters
# It transforms unhashable types to their string representation
# args should be a tuple/list of arguments
# kwargs should be a dictionary
# Create test arguments with mixed hashable and unhashable types
test_args = (
42, # hashable int
"hello", # hashable string
torch.tensor([1, 2, 3, 4]), # unhashable tensor
[1, 2, 3], # unhashable list
{"key": "value"}, # unhashable dict
np.array([1, 2, 3]), # unhashable numpy array
)
test_kwargs = {
"hashable_int": 100,
"hashable_str": "world",
"unhashable_tensor": torch.tensor([[1, 2], [3, 4]]),
"unhashable_list": [10, 20, 30],
"unhashable_dict": {"nested": "dict"},
}
ARGS = {
"args": test_args,
"kwargs": test_kwargs,
}
- 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, 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
|
| normalize |
Ran ran on a synthesized input |
KohavTal/SCAE_Project/torch_scae/math_ops.py code served (permissive licence) · get_code("557120b6207db13a") 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 tensor with shape (2, 4)
# The function normalizes along a specified dimension
tensor = torch.randn(2, 4)
# The dim parameter specifies which dimension to sum over
dim = 1
ARGS = {
"tensor": tensor,
"dim": dim,
}
- 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
|
| prepare_model_params |
Ran ran on a synthesized input |
KohavTal/SCAE_Project/torch_scae/factory.py code served (permissive licence) · get_code("114ca279f4f910b1") 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.nn as nn
torch.manual_seed(0)
ARGS = {
'image_shape': (3, 32, 32),
'n_classes': 10,
'n_part_caps': 16,
'n_obj_caps': 8,
'pcae_cnn_encoder_params': None,
'pcae_encoder_params': None,
'pcae_template_generator_params': None,
'pcae_decoder_params': None,
'ocae_encoder_set_transformer_params': None,
'ocae_decoder_capsule_params': None,
'scae_params': None,
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- torch — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type 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
|
| prod |
Ran ran, violated the contract we drafted |
KohavTal/SCAE_Project/torch_scae/general_utils.py code served (permissive licence) · get_code("6d5acfb0087d1ee7") 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 operator
from functools import reduce
def prod(iterable):
return reduce(operator.mul, iterable, 1)
# Test cases: prod works with iterables of numbers
# The function multiplies all elements together using reduce
ARGS = {
'iterable': [2, 3, 4, 5]
}
- 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 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
|
| qkv_attention |
Ran ran on a synthesized input |
KohavTal/SCAE_Project/torch_scae/set_transformer.py code served (permissive licence) · get_code("11fd17f376687a4c") 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, 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 numpy as np
torch.manual_seed(0)
# Define dimensions
batch_size = 2
num_queries = 3
num_keys = 4
d_k = 5
d_v = 6
# Create queries: [B, N, d_k]
queries = torch.randn(batch_size, num_queries, d_k)
# Create keys: [B, M, d_k]
keys = torch.randn(batch_size, num_keys, d_k)
# Create values: [B, M, d_v]
values = torch.randn(batch_size, num_keys, d_v)
# Create presence: [B, M] (optional, can be None)
presence = torch.rand(batch_size, num_keys)
ARGS = {
"queries": queries,
"keys": keys,
"values": values,
"presence": presence,
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- numpy, torch — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type Tensor, ndim 3, dtype family float, shape (2, 3, 6) — shape (2, 3, 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
|
| relu1 |
Ran ran on a synthesized input |
akosiorek/stacked_capsule_autoencoders/capsules/math_ops.py code served (permissive licence) · get_code("7ac5d15a4e829dd7") 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 relu1(x):
return tf.nn.relu6(x * 6.0) / 6.0
# Create a small TensorFlow tensor
x_value = tf.constant([[1.5, -2.0, 0.5, 3.0],
[0.2, -1.5, 2.5, -0.8]], dtype=tf.float32)
ARGS = {
'x': x_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 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
|
| toNum |
Ran ran on a synthesized input |
YuZiHanorz/stacked_capsule_autoencoders/handle_csv.py code served (permissive licence) · get_code("a0c52efb1af7f6d5") How it ranRan in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned tuple, ndim 1, dtype family float; no output shape is stated. The image it ran in was not recorded. If your copy returns the same type and ndim on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import torch
import numpy as np
# The function toNum takes a single parameter: str
# It processes a string to extract a numeric part and a unit part
# The function expects a string input
ARGS = {
'str': '42.5 kg'
}
- 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, 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
|
| gaussian_blobs |
Not yet run unverified (harvested, no recorded run) |
akosiorek/stacked_capsule_autoencoders/capsules/plot.py code served (permissive licence) · get_code("c94d19b7ab25522a") How it ran |
| gaussian_blobs_const_scale |
Not yet run unverified (harvested, no recorded run) |
akosiorek/stacked_capsule_autoencoders/capsules/plot.py code served (permissive licence) · get_code("8e494526a6edfb93") How it ran |
| safe_ce |
Not yet run unverified (harvested, no recorded run) |
akosiorek/stacked_capsule_autoencoders/capsules/math_ops.py code served (permissive licence) · get_code("094969771f521bf6") How it ran |
| safe_log |
Not yet run unverified (harvested, no recorded run) |
akosiorek/stacked_capsule_autoencoders/capsules/math_ops.py code served (permissive licence) · get_code("d06435ecd510267e") How it ran |