| attention |
Ran ran on a synthesized input |
rodem-hep/pc-jedi/src/models/transformers.py code served (permissive licence) · get_code("37f26eb1c05ac461") 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, 4, 5) as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import torch
import math
torch.manual_seed(0)
# Batch size: 2, heads: 3, sequence length: 4, feature dim: 5
batch_size = 2
num_heads = 3
seq_length = 4
feature_dim = 5
# Create query, key, value tensors with shape (batch, heads, seq_length, feature_dim)
query = torch.randn(batch_size, num_heads, seq_length, feature_dim)
key = torch.randn(batch_size, num_heads, seq_length, feature_dim)
value = torch.randn(batch_size, num_heads, seq_length, feature_dim)
# Dimension of key features (used for scaling)
dim_key = feature_dim
# Attention mask: shape (batch, seq_length, seq_length) - boolean tensor
# True means attend, False means mask out
attn_mask = torch.ones(batch_size, seq_length, seq_length, dtype=torch.bool)
# Attention bias: shape (batch, seq_length, seq_length, heads)
# Extra weights to add to attention scores
attn_bias = torch.randn(batch_size, seq_length, seq_length, num_heads)
# Dropout probability
drp = 0.1
# Training mode
training = True
ARGS = {
'query': query,
'key': key,
'value': value,
'dim_key': dim_key,
'attn_mask': attn_mask,
'attn_bias': attn_bias,
'drp': drp,
'training': training,
}
- 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, 4, 5) — shape (2, 3, 4, 5) as a later run recorded it
- dtype family
- int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
- Environment
- image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
|
| cosine_beta_shedule |
Ran ran on a synthesized input |
rodem-hep/pc-jedi/src/models/diffusion.py code served (permissive licence) · get_code("1504ad575ab6e48d") 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
import math
torch.manual_seed(0)
# The function expects:
# - diff_time: T.Tensor (used in arithmetic operations)
# - max_sr: float (default 1)
# - min_sr: float (default 0.01)
# Create a small tensor for diff_time
# The function uses it in: diffusion_angles = start_angle + diff_time * (end_angle - start_angle)
# So it should be a tensor of reasonable shape
diff_time = torch.linspace(0, 1, 4)
ARGS = {
"diff_time": diff_time,
"max_sr": 0.9,
"min_sr": 0.02
}
- 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
|
| cosine_diffusion_shedule |
Ran ran on a synthesized input |
rodem-hep/pc-jedi/src/models/diffusion.py code served (permissive licence) · get_code("2995fa6ac54da40c") 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 3, 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 math
torch.manual_seed(0)
# Create a small tensor with diffusion times between 0 and 1
# Shape: (2, 4) - batch of 2, with 4 time values
diff_time = torch.linspace(0, 1, 8).reshape(2, 4)
# Use default values for max_sr and min_sr
max_sr = 1.0
min_sr = 0.01
ARGS = {
"diff_time": diff_time,
"max_sr": max_sr,
"min_sr": min_sr,
}
- 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 3, 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
|
| cosine_encoding |
Ran ran; our contract draft was wrong, not the code |
rodem-hep/pc-jedi/src/models/modules.py code served (permissive licence) · get_code("6a728d7d4c676cdb") 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, 32) 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 input tensor
# The function expects the final dimension to be 1, or it will unsqueeze it
# Let's create a 2D tensor with shape (2, 1) - batch of 2 values
x = torch.tensor([[0.3], [0.7]], dtype=torch.float32)
# Parameters for the function
outp_dim = 32
min_value = 0.0
max_value = 1.0
frequency_scaling = 'exponential'
ARGS = {
'x': x,
'outp_dim': outp_dim,
'min_value': min_value,
'max_value': max_value,
'frequency_scaling': frequency_scaling
}
- 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, 32) — shape (2, 32) 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
|
| ddim_predict |
Ran ran on a synthesized input |
rodem-hep/pc-jedi/src/models/diffusion.py code served (permissive licence) · get_code("2b57a32088530b36") 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 as T
T.manual_seed(0)
# Create small test tensors with distinct dimensions
batch_size = 2
feature_dim = 4
# noisy_data: the input noisy tensor
noisy_data = T.randn(batch_size, feature_dim)
# pred_noises: predicted noise from model
pred_noises = T.randn(batch_size, feature_dim)
# signal_rates: scaling factor for signal component
signal_rates = T.ones(batch_size, 1) * 0.7
# noise_rates: scaling factor for noise component
noise_rates = T.ones(batch_size, 1) * 0.3
ARGS = {
'noisy_data': noisy_data,
'pred_noises': pred_noises,
'signal_rates': signal_rates,
'noise_rates': noise_rates,
}
- 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
|
| get_act |
Ran ran on a synthesized input |
rodem-hep/pc-jedi/src/models/modules.py code served (permissive licence) · get_code("4e36f432e6fda919") 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 ReLU. 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)
# The function get_act takes a single parameter: name (str)
# It returns an nn.Module activation function based on the name
# Valid names are: 'relu', 'lrlu', 'silu', 'swish', 'selu', 'softmax', 'gelu', 'tanh', 'sigmoid'
ARGS = {
'name': 'relu'
}
- 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 ReLU — a ReLU output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a ReLU 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_loss_fn |
Ran ran on a synthesized input |
rodem-hep/pc-jedi/src/torch_utils.py code served (permissive licence) · get_code("03b2ee87958648c6") 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 MSELoss. 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)
# The function get_loss_fn takes a 'name' parameter and optional kwargs
# Looking at the function body, it:
# - Checks the name against specific strings ('none', 'huber', 'mse', 'mae')
# - Returns None or an nn.Module loss function
# - The kwargs are passed to the loss constructors but the function doesn't use them directly
# We'll test with a valid loss name that exercises the main path
ARGS = {
'name': 'mse',
}
- 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 MSELoss — a MSELoss output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a MSELoss 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_nrm |
Ran ran on a synthesized input |
rodem-hep/pc-jedi/src/models/modules.py code served (permissive licence) · get_code("e8e415ee3dbd27cb") 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 BatchNorm1d. 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 = {
'name': 'batch',
'outp_dim': 64,
}
- 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 BatchNorm1d — a BatchNorm1d output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a BatchNorm1d 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
|
| locals_to_mass_and_pt |
Ran ran on a synthesized input |
rodem-hep/pc-jedi/src/physics.py code served (permissive licence) · get_code("40c1c42984bb85ec") 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, 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 as T
T.manual_seed(0)
# csts should be a tensor of shape (batch, num_constituents, 3)
# where the last dimension contains [del_eta, del_phi, log_pt]
# Using batch_size=2, num_constituents=4
csts = T.randn(2, 4, 3)
# mask should be a BoolTensor of shape (batch, num_constituents)
# to select which constituents are valid
mask = T.tensor([
[True, True, True, False],
[True, True, False, False]
])
ARGS = {
"csts": csts,
"mask": mask
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- torch — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type Tensor, ndim 2, dtype family float, shape (2, 2) — shape (2, 2) as a later run recorded it
- dtype family
- int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
- Environment
- image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
|
| log_squash |
Ran ran on a synthesized input |
rodem-hep/pc-jedi/src/numpy_utils.py code served (permissive licence) · get_code("7ba8326426ab16c1") How it ranRan in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned ndarray, ndim 2, dtype family float, shape (2, 4) as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import numpy as np
# Create a simple numpy array with mixed positive and negative values
# This will test the sign preservation and log squashing behavior
data = np.array([
[-10.5, 2.3, -0.1, 100.0],
[0.0, -50.2, 3.14, -0.001]
], dtype=np.float32)
ARGS = {
"data": data
}
- 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 (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
|
| merge_masks |
Ran ran on a synthesized input |
rodem-hep/pc-jedi/src/models/transformers.py code served (permissive licence) · get_code("13ad605957a293d0") 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, 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 as T
T.manual_seed(0)
device = T.device('cpu')
# q_mask: Union[T.BoolTensor, None] - boolean mask for queries
q_mask = T.tensor([[True, True, False], [True, True, True]], dtype=T.bool, device=device)
# kv_mask: Union[T.BoolTensor, None] - boolean mask for key/values
kv_mask = T.tensor([[True, False], [True, True]], dtype=T.bool, device=device)
# attn_mask: Union[T.BoolTensor, None] - attention mask
attn_mask = T.tensor([[[True, True], [True, False], [False, False]],
[[True, True], [True, True], [True, False]]], dtype=T.bool, device=device)
# q_shape: T.Size - shape of query tensor (batch=2, seq_len=3, hidden=4)
q_shape = T.Size([2, 3, 4])
# k_shape: T.Size - shape of key tensor (batch=2, seq_len=2, hidden=4)
k_shape = T.Size([2, 2, 4])
ARGS = {
'q_mask': q_mask,
'kv_mask': kv_mask,
'attn_mask': attn_mask,
'q_shape': q_shape,
'k_shape': k_shape,
'device': device
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- torch — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type Tensor, ndim 3, dtype family float, shape (2, 3, 2) — shape (2, 3, 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
|
| numpy_locals_to_mass_and_pt |
Ran ran on a synthesized input |
rodem-hep/pc-jedi/src/physics.py code served (permissive licence) · get_code("9ab34bf4ce285384") How it ranRan in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned ndarray, ndim 2, dtype family float, shape (2, 2) as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import numpy as np
# Create small sample data for constituents
# Shape: (batch_size, num_constituents, num_features)
# Features are: del_eta, del_phi, log_pt (or pt)
batch_size = 2
num_constituents = 4
num_features = 3
csts = np.random.randn(batch_size, num_constituents, num_features).astype(np.float32)
# Make pt values reasonable (del_eta and del_phi should be small, pt should be positive when logged)
csts[..., 2] = np.random.uniform(0, 3, (batch_size, num_constituents))
# Create mask to select valid constituents
# Shape: (batch_size, num_constituents)
mask = np.ones((batch_size, num_constituents), dtype=np.float32)
mask[0, 3] = 0 # mask out one constituent in first batch
ARGS = {
"csts": csts,
"mask": mask,
"pt_logged": True,
}
- 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 (2, 2) — shape (2, 2) as a later run recorded it
- dtype family
- int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
- Environment
- image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
|
| reload_original_config |
Ran ran on a synthesized input |
rodem-hep/pc-jedi/src/hydra_utils.py code served (permissive licence) · get_code("d690d626ae8c473f") 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 DictConfig. 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
from pathlib import Path
from omegaconf import DictConfig, OmegaConf
import torch
torch.manual_seed(0)
# Create a temporary directory to act as the working directory
tmpdir = tempfile.mkdtemp()
original_cwd = os.getcwd()
os.chdir(tmpdir)
# Create a minimal full_config.yaml file
config_yaml_path = Path(tmpdir) / 'full_config.yaml'
config_yaml_content = """
ckpt_path: null
loggers:
wandb:
resume: false
"""
config_yaml_path.write_text(config_yaml_content)
# Create checkpoints directory with dummy checkpoint files
checkpoints_dir = Path(tmpdir) / 'checkpoints'
checkpoints_dir.mkdir(exist_ok=True)
# Create last and best checkpoint files with different modification times
last_ckpt = checkpoints_dir / 'last_v0.ckpt'
best_ckpt = checkpoints_dir / 'best_v0.ckpt'
last_ckpt.write_text('dummy checkpoint content')
best_ckpt.write_text('dummy checkpoint content')
# Ensure last is more recent
import time
time.sleep(0.01)
last_ckpt.touch()
# Create the input config
input_cfg = OmegaConf.create({
'ckpt_path': None,
'loggers': {
'wandb': {
'resume': False
}
}
})
ARGS = {
'cfg': input_cfg,
'get_best': False
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- omegaconf, pytorch_lightning, torch — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type DictConfig — a DictConfig output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a DictConfig 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
|
| to_np |
Ran ran on a synthesized input |
rodem-hep/pc-jedi/src/torch_utils.py code served (permissive licence) · get_code("1042ba4270cff87d") How it ranRan in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned ndarray, ndim 2, dtype family float, shape (2, 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 as T
import numpy as np
T.manual_seed(0)
# Test case 1: A single tensor
tensor_input = T.randn(2, 4)
# Test case 2: A tuple of tensors
tuple_input = (T.randn(2, 4), T.randn(3, 5))
# Test case 3: A list of tensors
list_input = [T.randn(2, 4), T.randn(3, 5)]
# Test case 4: A tensor with bfloat16 dtype
bfloat16_tensor = T.randn(2, 4).to(dtype=T.bfloat16)
# Test case 5: A tensor with gradient
tensor_with_grad = T.randn(2, 4, requires_grad=True)
ARGS = {
"inpt": tensor_input
}
- 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 ndarray, 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
|
| undo_log_squash |
Ran ran on a synthesized input |
rodem-hep/pc-jedi/src/numpy_utils.py code served (permissive licence) · get_code("fb41e7055a7e1e1e") How it ranRan in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned ndarray, ndim 2, dtype family float, shape (2, 4) as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import numpy as np
# Create test data for undo_log_squash
# The function takes an np.ndarray and applies the inverse of a log squash operation
# It uses np.sign, np.exp, and np.abs which work element-wise on arrays
# Create a small test array with mixed positive and negative values
data = np.array([
[0.5, -0.3, 1.2, -0.8],
[0.1, -2.0, 0.0, 1.5]
], dtype=np.float32)
ARGS = {
"data": data
}
- 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 (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
|
| instantiate_collection |
Not yet run unverified (harvested, no recorded run) |
rodem-hep/pc-jedi/src/hydra_utils.py code served (permissive licence) · get_code("814934ff90988982") How it ran |
| plot_multi_hists |
Not yet run unverified (harvested, no recorded run) |
rodem-hep/pc-jedi/src/plotting.py code served (permissive licence) · get_code("6466f297d91408a6") How it ran |