| JPEGSaveWithTargetSize |
Ran ran on a synthesized input |
emiliendupont/coinpp/baseline_image.py code served (permissive licence) · get_code("6b592b46e1f31ef3") 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 io
import math
from PIL import Image
import numpy as np
# Create a small test image
img_array = np.random.randint(0, 256, (100, 100, 3), dtype=np.uint8)
test_image = Image.fromarray(img_array, mode='RGB')
# Define target size in bytes (relatively small to ensure we find a valid quality factor)
target_bytes = 5000
ARGS = {
'im': test_image,
'target_in_bytes': target_bytes
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- PIL, numpy — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type 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
|
| SaveWithTargetSize |
Ran ran on a synthesized input |
emiliendupont/coinpp/baseline_image.py code served (permissive licence) · get_code("22b8c13052b20fc5") 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 io
import math
import os
from PIL import Image
import numpy as np
# Create a small test image
img_array = np.random.randint(0, 256, (64, 64, 3), dtype=np.uint8)
test_image = Image.fromarray(img_array, mode='RGB')
# Define arguments for SaveWithTargetSize
ARGS = {
'img': test_image,
'target_in_bytes': 5000,
'format': 'jpeg'
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- PIL, numpy — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type 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
|
| alphanumeric_sort |
Ran ran on a synthesized input |
emiliendupont/coinpp/plots.py code served (permissive licence) · get_code("c8b42087913378fb") 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 re
def alphanumeric_sort(iterable):
"""Sort iterable in alphanumeric order humans would expect. Taken from
https://stackoverflow.com/questions/2669059/how-to-sort-alpha-numeric-set-in-python"""
convert = lambda text: int(text) if text.isdigit() else text
alphanum_key = lambda key: [convert(c) for c in re.split('([0-9]+)', key)]
return sorted(iterable, key=alphanum_key)
ARGS = {
"iterable": ["file10.txt", "file2.txt", "file1.txt", "image100.png", "image20.png"]
}
- 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, 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
|
| batch_mse_fn |
Ran ran on a synthesized input |
emiliendupont/coinpp/coinpp/losses.py code served (permissive licence) · get_code("44b28292053a912b") 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 (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)
# Create two small batches of signals
# batch_size=2, signal dimensions=4x3
batch_size = 2
signal_shape = (4, 3)
x1 = torch.randn(batch_size, *signal_shape)
x2 = torch.randn(batch_size, *signal_shape)
ARGS = {
"x1": x1,
"x2": x2,
}
- 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 (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
|
| compute_frequency_distribution |
Ran ran on a synthesized input |
emiliendupont/coinpp/entropy_coding.py code served (permissive licence) · get_code("6cb9a57cb491bc9c") 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)
# Create quantized modulation values as integers
# For num_bits=2, we have 2^2 = 4 possible values (0, 1, 2, 3)
# Create a small tensor with some quantized values
quantized_mods = torch.tensor([0, 1, 1, 2, 0, 3, 1, 2], dtype=torch.long)
num_bits = 2
min_count = 1
ARGS = {
"quantized_mods": quantized_mods,
"num_bits": num_bits,
"min_count": min_count,
}
- 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
|
| cross_entropy |
Ran ran on a synthesized input |
emiliendupont/coinpp/entropy_coding.py code served (permissive licence) · get_code("9000986359fde15d") 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. 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 two probability distributions as tensors
# They should sum to 1 (or close to it) since they represent probability distributions
# The function computes: -(test_distribution * log2(train_distribution)).sum()
# train_distribution: represents q, the model's learned distribution
train_distribution = torch.tensor([0.4, 0.3, 0.2, 0.1])
# test_distribution: represents p, the true distribution over test data
test_distribution = torch.tensor([0.25, 0.25, 0.25, 0.25])
ARGS = {
"train_distribution": train_distribution,
"test_distribution": test_distribution,
}
- 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
|
| data2features |
Ran ran on a synthesized input |
emiliendupont/coinpp/coinpp/conversion.py code served (permissive licence) · get_code("db324387c391694e") 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, 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)
# Test case 1: batched=True, shape (batch_size, channels, height, width)
data_batched = torch.randn(2, 3, 4, 5)
# Test case 2: batched=False, shape (channels, height, width)
data_unbatched = torch.randn(3, 4, 5)
# We'll use the batched case as the primary test
ARGS = {
"data": data_batched,
"batched": 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 Tensor, ndim 4, dtype family float, shape (2, 4, 5, 3) — shape (2, 4, 5, 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
|
| dataset_name_to_dims |
Ran ran on a synthesized input |
emiliendupont/coinpp/helpers.py code served (permissive licence) · get_code("0190edd70759cb76") 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
torch.manual_seed(0)
# The function takes a dataset_name string and returns appropriate dimensions
# based on the dataset. We need to test with one of the valid dataset names.
ARGS = {
'dataset_name': 'mnist'
}
- 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 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
|
| features2data |
Ran ran on a synthesized input |
emiliendupont/coinpp/coinpp/conversion.py code served (permissive licence) · get_code("824765764e99b850") 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 (3, 5, 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 test tensors with distinct dimensions
# For batched=False: features shape should be (..., feature_dim)
# moveaxis will move last axis to position 0
features_unbatched = torch.randn(5, 4, 3) # shape (5, 4, 3), last dim is 3
# For batched=True: features shape should be (..., batch_dim, feature_dim)
# moveaxis will move last axis to position 1
features_batched = torch.randn(5, 2, 4) # shape (5, 2, 4), last dim is 4
ARGS = {
"features": features_unbatched,
"batched": 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 3, dtype family float, shape (3, 5, 4) — shape (3, 5, 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
|
| fold3d |
Ran ran on a synthesized input |
emiliendupont/coinpp/coinpp/patching.py code served (permissive licence) · get_code("a4e6c3bd50a898d1") How it ranRan in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned Tensor, ndim 5, dtype family float, shape (1, 3, 4, 5, 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)
# Define parameters for fold3d function
output_size = (4, 5, 6) # (depth, height, width)
kernel_size = (2, 2, 2)
stride = (1, 1, 1)
# Calculate number of patches
depth, height, width = output_size
kd, kh, kw = kernel_size
sd, sh, sw = stride
# Number of patches in each dimension
num_patches_d = (depth - kd) // sd + 1
num_patches_h = (height - kh) // sh + 1
num_patches_w = (width - kw) // sw + 1
num_patches = num_patches_d * num_patches_h * num_patches_w
# Number of channels
channels = 3
# patches shape: (1, channels * kernel_size[0] * kernel_size[1] * kernel_size[2], num_patches)
patches_channels_dim = channels * math.prod(kernel_size)
patches = torch.randn(1, patches_channels_dim, num_patches)
ARGS = {
"patches": patches,
"output_size": output_size,
"kernel_size": kernel_size,
"stride": stride,
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- torch — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type Tensor, ndim 5, dtype family float, shape (1, 3, 4, 5, 6) — shape (1, 3, 4, 5, 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_bpd |
Ran ran on a synthesized input |
emiliendupont/coinpp/entropy_coding.py code served (permissive licence) · get_code("bfd3f89ca260b468") 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. 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)
# Analyze the function: it takes three numeric parameters and performs simple arithmetic
# bits_per_modulation: float - bits per single modulation
# num_modulations: int - count of modulations
# num_dims: int - number of data dimensions
ARGS = {
"bits_per_modulation": 8.5,
"num_modulations": 16,
"num_dims": 256
}
- 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 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
|
| get_dataset_root |
Ran ran on a synthesized input |
emiliendupont/coinpp/helpers.py code served (permissive licence) · get_code("385818650785ae80") 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 PosixPath. 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 yaml
from pathlib import Path
import tempfile
import os
# Create a temporary directory and dataset_paths.yaml file
temp_dir = tempfile.mkdtemp()
data_dir = os.path.join(temp_dir, 'data')
os.makedirs(data_dir, exist_ok=True)
# Create a dataset_paths.yaml file
dataset_paths_content = {
'mnist': '/data/mnist',
'cifar10': '/data/cifar10',
'imagenet': '/data/imagenet'
}
yaml_file_path = os.path.join(data_dir, 'dataset_paths.yaml')
with open(yaml_file_path, 'w') as f:
yaml.dump(dataset_paths_content, f)
# Change working directory to temp_dir so the relative path works
original_cwd = os.getcwd()
os.chdir(temp_dir)
ARGS = {
'dataset_name': 'mnist'
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- yaml — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type PosixPath — a PosixPath output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a PosixPath output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not stated
- Environment
- image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
|
| get_jpeg2000_enc_cmd |
Ran ran on a synthesized input |
emiliendupont/coinpp/baseline_image.py code served (permissive licence) · get_code("812750e68988747d") 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.
import torch
import tempfile
import os
torch.manual_seed(0)
# Create temporary file paths for testing
temp_dir = tempfile.gettempdir()
in_filepath = os.path.join(temp_dir, "input.tif")
out_filepath = os.path.join(temp_dir, "output.jp2")
# The function takes three string parameters:
# in_filepath: path to input file
# quant: quantization rate (appears to be numeric, used in -r flag)
# out_filepath: path to output file
ARGS = {
"in_filepath": in_filepath,
"quant": 0.5,
"out_filepath": out_filepath
}
- 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 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
|
| get_padding |
Ran ran on a synthesized input |
emiliendupont/coinpp/coinpp/patching.py code served (permissive licence) · get_code("51be69bc13ec8685") 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
# Test case 1: 1D spatial shape with 1D patch shape
spatial_shape_1d = (16,)
patch_shape_1d = (4,)
# Test case 2: 2D spatial shape with 2D patch shape
spatial_shape_2d = (24, 32)
patch_shape_2d = (8, 8)
# Test case 3: 3D spatial shape with 3D patch shape
spatial_shape_3d = (12, 16, 20)
patch_shape_3d = (4, 4, 5)
ARGS = {
"spatial_shape": spatial_shape_2d,
"patch_shape": patch_shape_2d
}
- 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
|
| magnify |
Ran ran on a synthesized input |
emiliendupont/coinpp/plots.py code served (permissive licence) · get_code("5f2aef075af00ba9") 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, 3, 8, 10) 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 test image tensor
# Using shape (batch_size, channels, height, width) = (2, 3, 4, 5)
img = torch.randn(2, 3, 4, 5)
# Create arguments dict
ARGS = {
"img": img,
"factor": 2
}
- 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, 3, 8, 10) — shape (2, 3, 8, 10) 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
|
| mse2psnr |
Ran ran on a synthesized input |
emiliendupont/coinpp/coinpp/losses.py code served (permissive licence) · get_code("7031734847dce447") 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 (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 an mse parameter which can be a torch.Tensor or float
# It calls torch.log10() on it, so it needs to support that operation
# Let's create a small tensor representing MSE values
mse_tensor = torch.tensor([0.001, 0.01])
ARGS = {
"mse": mse_tensor
}
- 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 (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
|
| psnr |
Ran ran on a synthesized input |
emiliendupont/coinpp/baseline_audio.py code served (permissive licence) · get_code("7f1bdc1f7fc1bb23") How it ranRan in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned float32, ndim 0, dtype family float, shape () as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import numpy as np
# Create two numpy arrays with different values to avoid MSE == 0
# Using distinct shapes to make dimensions unambiguous
a = np.random.randn(2, 4).astype(np.float32)
b = np.random.randn(2, 4).astype(np.float32)
# Ensure they're not identical (which would cause MSE == 0 and raise ValueError)
b = b + 0.1
ARGS = {
"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 — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type float32, ndim 0, dtype family float, shape () — shape () as a later run recorded it
- dtype family
- int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
- Environment
- image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
|
| psnr_fn |
Ran ran on a synthesized input |
emiliendupont/coinpp/coinpp/losses.py code served (permissive licence) · get_code("304779b8c8321aab") 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 two small tensors with values in [0, 1]
x1 = torch.rand(2, 4)
x2 = torch.rand(2, 4)
ARGS = {
"x1": x1,
"x2": x2,
}
- 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
|
| shape2coordinates |
Ran ran on a synthesized input |
emiliendupont/coinpp/coinpp/conversion.py code served (permissive licence) · get_code("dc3678dbea06996e") 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 (4, 3, 5, 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 = {
"spatial_shape": torch.Size([4, 3, 5]),
"batch_size": 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 4, dtype family float, shape (4, 3, 5, 3) — shape (4, 3, 5, 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
|
| unfold3d |
Ran ran on a synthesized input |
emiliendupont/coinpp/coinpp/patching.py code served (permissive licence) · get_code("4431d05b8caa2cbd") 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, 24, 60) 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 5D tensor with shape (B, C, D, H, W)
# Using distinct sizes: B=2, C=3, D=4, H=5, W=6
tensor = torch.randn(2, 3, 4, 5, 6)
ARGS = {
"tensor": tensor,
"kernel_size": 2,
"padding": 0,
"stride": 1,
"dilation": 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 3, dtype family float, shape (2, 24, 60) — shape (2, 24, 60) 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
|