| batch_loss |
Ran ran on a synthesized input |
ellisdg/3DUnetCNN/unet3d/train/training_utils.py code served (permissive licence) · get_code("e0f6de538e2f1e18") 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. The code mentions cuda, and the harness aliases cuda to the CPU for every sample; whether this run needed that is not recorded. If your copy returns the same type 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 minimal model that takes images and outputs predictions
class SimpleModel(nn.Module):
def __init__(self):
super().__init__()
self.linear = nn.Linear(4, 3)
def forward(self, x):
# x shape: (batch_size, 4)
return self.linear(x)
# Define a minimal inferer that takes images and model
class SimpleInferer:
def __call__(self, images, model):
return model(images)
# Create model
model = SimpleModel()
# Create small tensors (batch=2, feature_dim=4 for images, num_classes=3 for target)
images = torch.randn(2, 4)
target = torch.randint(0, 3, (2,))
# Create loss criterion
criterion = nn.CrossEntropyLoss()
# Create inferer
inferer = SimpleInferer()
ARGS = {
"model": model,
"images": images,
"target": target,
"criterion": criterion,
"n_gpus": 0,
"use_amp": False,
"inferer": inferer,
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- torch — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type tuple — a tuple output has no array shape of its own; none is stated
- Environment
- image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
|
| calculate_origin_offset |
Ran ran on a synthesized input |
ellisdg/3DUnetCNN/unet3d/utils/affine.py code served (permissive licence) · get_code("48624962e9942c9f") 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 1, dtype family float, shape (4,) as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import torch
torch.manual_seed(0)
# The function takes two parameters: new_spacing and old_spacing
# Looking at the function body, it uses torch.divide, torch.subtract operations
# These work on torch tensors, so both parameters should be tensors
# The function performs element-wise operations, so they should have compatible shapes
new_spacing = torch.tensor([2.0, 3.0, 4.0, 5.0])
old_spacing = torch.tensor([1.0, 1.5, 2.0, 2.5])
ARGS = {
"new_spacing": new_spacing,
"old_spacing": old_spacing,
}
- 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 1, dtype family float, shape (4,) — shape (4,) as a later run recorded it
- dtype family
- int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
- Environment
- image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
|
| epoch_training |
Ran ran on a synthesized input |
ellisdg/3DUnetCNN/unet3d/train/training_utils.py code served (permissive licence) · get_code("d5f1b71fdb23285a") 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 float, ndim 0, dtype family float, shape () as a later run recorded it. The image it ran in was not recorded. The code mentions cuda, and the harness aliases cuda to the CPU for every sample; whether this run needed that is not recorded. If your copy returns the same type, 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
import torch.optim as optim
torch.manual_seed(0)
# Create a simple model
class SimpleModel(nn.Module):
def __init__(self):
super().__init__()
self.fc = nn.Linear(4, 2)
def forward(self, x):
return self.fc(x)
# Create a simple criterion
criterion = nn.CrossEntropyLoss()
# Create model and optimizer
model = SimpleModel()
optimizer = optim.SGD(model.parameters(), lr=0.01)
# Create a simple data loader (list of dicts with 'image' and 'label' keys)
train_loader = [
{
'image': torch.randn(2, 4),
'label': torch.randint(0, 2, (2,))
},
{
'image': torch.randn(2, 4),
'label': torch.randint(0, 2, (2,))
}
]
ARGS = {
'train_loader': train_loader,
'model': model,
'criterion': criterion,
'optimizer': optimizer,
'epoch': 0,
'n_gpus': None,
'print_frequency': 1,
'print_gpu_memory': False,
'scaler': None,
'samples_per_epoch': None,
'iteration': 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 float, 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
|
| epoch_validation |
Ran ran on a synthesized input |
ellisdg/3DUnetCNN/unet3d/train/training_utils.py code served (permissive licence) · get_code("c0efd1b82154d3f9") 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 float, ndim 0, dtype family float, shape () as a later run recorded it. The image it ran in was not recorded. The code mentions cuda, and the harness aliases cuda to the CPU for every sample; whether this run needed that is not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import torch
import torch.nn as nn
torch.manual_seed(0)
# Build a minimal model
class SimpleModel(nn.Module):
def __init__(self):
super().__init__()
self.fc = nn.Linear(4, 3)
def forward(self, x):
return self.fc(x)
# Build a minimal criterion
criterion = nn.CrossEntropyLoss()
# Build a minimal val_loader (list of dicts with 'image' and 'label' keys)
val_loader = [
{'image': torch.randn(2, 4), 'label': torch.randint(0, 3, (2,))},
{'image': torch.randn(2, 4), 'label': torch.randint(0, 3, (2,))},
]
# Build model
model = SimpleModel()
# Build inferer (callable that takes images and model, returns output)
class SimpleInferer:
def __call__(self, images, model):
return model(images)
inferer = SimpleInferer()
ARGS = {
'val_loader': val_loader,
'model': model,
'criterion': criterion,
'n_gpus': 0,
'print_freq': 1,
'use_amp': False,
'inferer': inferer,
}
- 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 float, 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
|
| extract_gifti_array |
Ran ran on a synthesized input |
ellisdg/3DUnetCNN/unet3d/utils/cifti.py code served (permissive licence) · get_code("d7f84b2efefc9200") 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 (10, 3) as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import numpy as np
class GiftiArray:
def __init__(self, data, metadata):
self.data = data
self.metadata = metadata
class GiftiObject:
def __init__(self, darrays):
self.darrays = darrays
# Create sample data arrays with metadata
array1_data = np.random.randn(10, 3).astype(np.float32)
array1_metadata = {
'Name': 'CoordinateSystemXformNode',
'GeometricType': 'Anatomical',
'AnatomicalStructurePrimary': 'CortexLeft',
'AnatomicalStructureSecondary': 'Gyrus'
}
array2_data = np.random.randn(8, 4).astype(np.float32)
array2_metadata = {
'Name': 'Surfaces',
'GeometricType': 'Functional',
'AnatomicalStructurePrimary': 'CortexRight',
'AnatomicalStructureSecondary': 'Sulcus'
}
gifti_arrays = [
GiftiArray(array1_data, array1_metadata),
GiftiArray(array2_data, array2_metadata)
]
gifti_object = GiftiObject(gifti_arrays)
ARGS = {
'gifti_object': gifti_object,
'index': 0,
'geometric_type': 'Anatomical',
'primary_anatomical_structure': 'CortexLeft',
'secondary_anatomical_structure': 'Gyrus'
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- numpy — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type ndarray, ndim 2, dtype family float, shape (10, 3) — shape (10, 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
|
| extract_gifti_surface_vertices |
Ran ran on a synthesized input |
ellisdg/3DUnetCNN/unet3d/utils/cifti.py code served (permissive licence) · get_code("ec8a60718108f746") 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 (10, 3) as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import numpy as np
class MockGiftiArray:
def __init__(self, data, name, geometric_type='Anatomical', primary_structure='CortexLeft', secondary_structure=None):
self.data = data
self.metadata = {
'Name': name,
'GeometricType': geometric_type,
'AnatomicalStructurePrimary': primary_structure,
'AnatomicalStructureSecondary': secondary_structure
}
class MockGiftiObject:
def __init__(self, darrays):
self.darrays = darrays
# Create mock GIFTI surface object with vertex data
vertex_data = np.random.randn(10, 3).astype(np.float32)
array0 = MockGiftiArray(
data=vertex_data,
name='CoordinateSystemXYZ',
geometric_type='Anatomical',
primary_structure='CortexLeft',
secondary_structure=None
)
array1 = MockGiftiArray(
data=np.random.randn(10, 3).astype(np.int32),
name='Normal',
geometric_type='Anatomical',
primary_structure='CortexLeft',
secondary_structure=None
)
surface = MockGiftiObject(darrays=[array0, array1])
ARGS = {
'surface': surface,
'index': 0,
'geometric_type': 'Anatomical',
'primary_anatomical_structure': 'CortexLeft',
'secondary_anatomical_structure': None
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- numpy — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type ndarray, ndim 2, dtype family float, shape (10, 3) — shape (10, 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
|
| flip_image |
Ran ran on a synthesized input |
ellisdg/3DUnetCNN/unet3d/utils/augment.py code served (permissive licence) · get_code("e3f4fafafb4fd349") 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 Image. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import torch
torch.manual_seed(0)
class Image:
def __init__(self, data):
self.data = data
def detach(self):
return self.data.detach()
def make_similar(self, data):
return Image(data)
image = Image(torch.randn(2, 3, 4, 5))
axis = [2, 3]
ARGS = {
"image": image,
"axis": axis,
}
- 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 Image — a Image output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a Image output the recorded ndim 4 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
|
| generate_hcp_filenames |
Ran ran on a synthesized input |
ellisdg/3DUnetCNN/unet3d/utils/filenames.py code served (permissive licence) · get_code("e6578b6b8b776391") 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. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import os
import tempfile
import shutil
# Create a temporary directory structure for testing
temp_dir = tempfile.mkdtemp()
# Create some test subject directories and files
subject_ids = ['100307', '100408']
for subject_id in subject_ids:
subject_dir = os.path.join(temp_dir, subject_id)
os.makedirs(subject_dir, exist_ok=True)
# Create dummy feature files
with open(os.path.join(subject_dir, 'features.nii.gz'), 'w') as f:
f.write('dummy feature data')
# Create dummy metric files
with open(os.path.join(subject_dir, 'metrics.nii.gz'), 'w') as f:
f.write('dummy metric data')
# Create dummy surface files (using template format)
for hemi in ['L', 'R']:
surface_file = os.path.join(subject_dir, f'surface_{hemi}_{subject_id}.surf.gii')
with open(surface_file, 'w') as f:
f.write('dummy surface data')
ARGS = {
'directory': temp_dir,
'surface_basename_template': 'surface_{hemi}_{subject_id}.surf.gii',
'target_basenames': 'metrics.nii.gz',
'feature_basenames': 'features.nii.gz',
'subject_ids': subject_ids,
'hemispheres': ['L', 'R']
}
- 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 list — a list 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_feature_filename_and_subject_id |
Ran ran on a synthesized input |
ellisdg/3DUnetCNN/unet3d/predict/utils.py code served (permissive licence) · get_code("6db950092e32b901") 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
class MockDataset:
def __init__(self):
self.feature_index = 0
self.epoch_filenames = [
['data/subject_001/session_01/features.npy', 'subject_001'],
['data/subject_002/session_01/features.npy', 'subject_002'],
['data/subject_001/session_02/features.npy', 'subject_001'],
]
dataset = MockDataset()
idx = 0
ARGS = {
'dataset': dataset,
'idx': idx,
'verbose': False,
}
- 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
|
| get_image |
Ran ran on a synthesized input |
ellisdg/3DUnetCNN/unet3d/utils/image.py code served (permissive licence) · get_code("50a36c3ef53a39bf") 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 Image. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import torch
import numpy as np
from monai.data.meta_tensor import MetaTensor
torch.manual_seed(0)
# Create a small tensor for image data
data = torch.randn(2, 4, 3, 5)
# Create an affine matrix (4x4)
affine = torch.eye(4)
# Optional kwargs
kwargs = {}
ARGS = {
"data": data,
"affine": affine,
"kwargs": kwargs
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- monai, nibabel, numpy, torch — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type Image — a Image 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_spacing_from_affine |
Ran ran on a synthesized input |
ellisdg/3DUnetCNN/unet3d/utils/affine.py code served (permissive licence) · get_code("ac1b3032b0af0eeb") 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 1, dtype family float, shape (3,) as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import torch
torch.manual_seed(0)
# The function expects an affine transformation matrix
# It accesses affine[:3, :3] which is a 3x3 slice
# So we need at least a 3x3 matrix, but we can make it larger (4x4 is common for affine transforms)
affine = torch.tensor([
[1.5, 0.1, 0.2, 10.0],
[0.0, 2.0, 0.1, 20.0],
[0.1, 0.0, 3.5, 30.0],
[0.0, 0.0, 0.0, 1.0]
], dtype=torch.float32)
ARGS = {
"affine": affine
}
- 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 1, dtype family float, shape (3,) — shape (3,) as a later run recorded it
- dtype family
- int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
- Environment
- image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
|
| infer_subject_id |
Ran ran on a synthesized input |
ellisdg/3DUnetCNN/unet3d/predict/utils.py code served (permissive licence) · get_code("7855782a9942e2e4") 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 str. 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.
ARGS = {
"filename": "path/to/subject_001/data/file.txt",
"ref_filename": "path/to/reference/data/file.txt"
}
- 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 str — a str output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a str 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
|
| load_images_from_dataset |
Ran ran on a synthesized input |
ellisdg/3DUnetCNN/unet3d/predict/volumetric.py code served (permissive licence) · get_code("d175ff824428b980") How it ranRan in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned tuple. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import torch
import torch.nn as nn
torch.manual_seed(0)
class MockDataset:
def __init__(self):
pass
def get_feature_image(self, idx, return_unmodified=False):
x_image = torch.randn(2, 4)
if return_unmodified:
ref_image = torch.randn(3, 5)
return x_image, ref_image
else:
return x_image
dataset = MockDataset()
idx = 0
resample_predictions = True
ARGS = {
"dataset": dataset,
"idx": idx,
"resample_predictions": resample_predictions,
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- torch — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type tuple — a tuple output has no array shape of its own; none is stated
- Environment
- image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
|
| load_state_dict |
Ran ran on a synthesized input |
ellisdg/3DUnetCNN/unet3d/models/build.py code served (permissive licence) · get_code("fb1d0885dc8670c6") 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 SimpleModel. 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
import math
torch.manual_seed(0)
# Create a simple model
class SimpleModel(nn.Module):
def __init__(self):
super().__init__()
self.linear1 = nn.Linear(4, 3)
self.linear2 = nn.Linear(3, 2)
def forward(self, x):
x = self.linear1(x)
x = self.linear2(x)
return x
# Create model instance
model = SimpleModel()
# Create a state dict with slightly different shapes for testing shape matching
state_dict = {
'linear1.weight': torch.randn(3, 4), # Different from model's (3, 4)
'linear1.bias': torch.randn(3),
'linear2.weight': torch.randn(2, 3),
'linear2.bias': torch.randn(2),
}
# Setup arguments
ARGS = {
'model': model,
'state_dict': state_dict,
'n_gpus': 1,
'strict': 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 SimpleModel — a SimpleModel output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a SimpleModel 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
|
| load_volumetric_model |
Ran ran on a synthesized input |
ellisdg/3DUnetCNN/unet3d/predict/volumetric.py code served (permissive licence) · get_code("a952576fb1f2c26a") 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 MinimalUNet3D. 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
from unittest.mock import Mock, patch, MagicMock
torch.manual_seed(0)
# Create a minimal mock for build_or_load_model
class MinimalUNet3D(nn.Module):
def __init__(self):
super().__init__()
self.conv1 = nn.Conv3d(1, 8, kernel_size=3)
self.conv2 = nn.Conv3d(8, 16, kernel_size=3)
def forward(self, x):
x = self.conv1(x)
x = self.conv2(x)
return x
def mock_build_or_load_model(model_name, model_filename, n_gpus, strict, **kwargs):
"""Mock implementation of build_or_load_model"""
model = MinimalUNet3D()
return model
# Patch the import before defining ARGS
import sys
from unittest.mock import MagicMock
# Create a mock unet3d module structure
mock_unet3d = MagicMock()
mock_unet3d.models.build.build_or_load_model = mock_build_or_load_model
sys.modules['unet3d'] = mock_unet3d
sys.modules['unet3d.models'] = mock_unet3d.models
sys.modules['unet3d.models.build'] = mock_unet3d.models.build
ARGS = {
'model_name': 'unet3d',
'model_filename': 'model.pt',
'n_gpus': 1,
'strict': True,
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- torch, unet3d — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type MinimalUNet3D — a MinimalUNet3D output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a MinimalUNet3D 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
|
| pytorch_predict_batch_array |
Ran ran on a synthesized input |
ellisdg/3DUnetCNN/unet3d/predict/utils.py code served (permissive licence) · get_code("0a4754cb9d311c12") 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, 3) as a later run recorded it. The image it ran in was not recorded. The code mentions cuda, and the harness aliases cuda to the CPU for every sample; whether this run needed that is not recorded. If your copy returns the same type, 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)
# Create a minimal model that satisfies the function's requirements
class SimpleModel(nn.Module):
def __init__(self):
super().__init__()
self.linear = nn.Linear(4, 3)
def forward(self, x):
return self.linear(x)
# Instantiate the model
model = SimpleModel()
# Create batch of tiny tensors (2 samples, 4 features each)
batch = [
torch.randn(4),
torch.randn(4)
]
# Define arguments for pytorch_predict_batch_array
ARGS = {
'model': model,
'batch': batch,
'n_gpus': 0
}
- 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, 3) — shape (2, 3) as a later run recorded it
- dtype family
- int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
- Environment
- image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
|
| random_flip_dimensions |
Ran ran on a synthesized input |
ellisdg/3DUnetCNN/unet3d/utils/augment.py code served (permissive licence) · get_code("360dfc67628c771e") 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 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 numpy as np
# Set seed for reproducibility
np.random.seed(0)
# The function random_flip_dimensions takes one parameter: n_dimensions
# It iterates through range(n_dimensions) and randomly decides whether to append each dimension index to a list
# So n_dimensions should be an integer representing the number of dimensions
n_dimensions = 5
ARGS = {
"n_dimensions": n_dimensions
}
- 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 list, ndim 1, dtype family int — 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
|
| random_scale_factor |
Ran ran on a synthesized input |
ellisdg/3DUnetCNN/unet3d/utils/augment.py code served (permissive licence) · get_code("c746ac1567201dd2") 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 1, dtype family float, shape (3,) as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import torch
torch.manual_seed(0)
ARGS = {
"n_dim": 3,
"mean": 1.0,
"std": 0.25,
}
- 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 1, dtype family float, shape (3,) — shape (3,) as a later run recorded it
- dtype family
- int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
- Environment
- image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
|
| set_affine_spacing |
Ran ran on a synthesized input |
ellisdg/3DUnetCNN/unet3d/utils/affine.py code served (permissive licence) · get_code("aed17f756b9cc8c3") 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 (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 torch
torch.manual_seed(0)
# Create a 4x4 affine transformation matrix
# The upper-left 3x3 block contains rotation, zoom, and shear (RZS)
# The rightmost column contains translation
affine = torch.tensor([
[1.5, 0.0, 0.0, 10.0],
[0.0, 2.0, 0.0, 20.0],
[0.0, 0.0, 1.5, 30.0],
[0.0, 0.0, 0.0, 1.0]
], dtype=torch.float32)
# Create spacing values (one for each dimension)
spacing = torch.tensor([1.0, 2.0, 1.5], dtype=torch.float32)
ARGS = {
"affine": affine,
"spacing": spacing
}
- 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 (4, 4) — shape (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
|
| wrapped_partial |
Ran ran on a synthesized input |
ellisdg/3DUnetCNN/unet3d/utils/filenames.py code served (permissive licence) · get_code("1e0de6b9c650bc32") 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 partial. 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
from functools import partial, update_wrapper
torch.manual_seed(0)
# Define a simple function to wrap
def add_numbers(a, b, c=0):
"""Simple function that adds numbers."""
return a + b + c
# Define another function for testing
def multiply_and_add(x, y, z=1):
"""Multiply x by y and add z."""
return x * y + z
# Define a tensor-based function
def tensor_operation(tensor, scale=1.0, offset=0.0):
"""Apply scale and offset to a tensor."""
return tensor * scale + offset
# Test with a simple function
test_func = add_numbers
test_args = (5,)
test_kwargs = {"c": 3}
# Test with tensor function
tensor_func = tensor_operation
tensor_arg = torch.randn(2, 4)
tensor_kwargs = {"scale": 2.0, "offset": 1.0}
# Construct the ARGS dictionary
ARGS = {
"func": test_func,
"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
- torch — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type partial — a partial output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a partial 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
|
| extract_gifti_array_names |
Not yet run unverified (harvested, no recorded run) |
ellisdg/3DUnetCNN/unet3d/utils/cifti.py code served (permissive licence) · get_code("a613b779df9b18fb") How it ran |