| abs_cap |
Ran ran on a synthesized input |
knc6/cdvae/cdvae/common/data_utils.py code served (permissive licence) · get_code("6a946510479f2069") 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)
# The function abs_cap takes two parameters:
# - val (float): a numeric value to cap
# - max_abs_val (float): the maximum absolute value (defaults to 1)
# Looking at the function body:
# - It uses max() and min() built-in functions
# - It compares val against max_abs_val
# - It returns either val or sign(val) * max_abs_val
# The function works with float values
ARGS = {
"val": 1.5,
"max_abs_val": 1.0
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- numpy, torch — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type 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
|
| build_mlp |
Ran ran; our contract draft was wrong, not the code |
gabeguo/cdvae_xrd/cdvae/pl_modules/model.py code served (permissive licence) · get_code("7a500e0992fceda5") How it ranRan in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1) and returned Sequential. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import torch
import torch.nn as nn
torch.manual_seed(0)
ARGS = {
"in_dim": 4,
"hidden_dim": 8,
"fc_num_layers": 3,
"out_dim": 2,
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1
- Imports
- torch — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type Sequential — a Sequential output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a Sequential output the recorded ndim 1 and dtype family float describe that coercion, not the output, and are not stated
- Environment
- image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
|
| censored_min_mae |
Ran ran on a synthesized input |
symmetryadvantage/wyckofftransformer/src/wyckoff_transformer/censored.py code served (permissive licence) · get_code("32b725dbd955ba54") 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
import math
from torch import nn
torch.manual_seed(0)
# Create small tensors for the function
batch_size = 2
dim_size = 4
prediction = torch.randn(batch_size, dim_size)
target = torch.randn(batch_size, dim_size)
# Create a CensoredMinLoss criterion with predict_scale=True
criterion = nn.Module() # This will be replaced with actual CensoredMinLoss below
class SimpleCensoredMinLoss(nn.Module):
"""Stand-in CensoredMinLoss for testing censored_min_mae"""
def __init__(self):
super().__init__()
self.reduction = 'mean'
self.noise = 0.01
self.min_scale = 0.001
self.predict_scale = True
self.register_parameter('global_log_scale', None)
@property
def n_outputs(self):
return 2 if self.predict_scale else 1
def split(self, prediction):
if self.predict_scale:
if prediction.dim() < 2 or prediction.size(-1) != 2:
raise ValueError(f'CensoredMinLoss with predict_scale=True needs a model with outputs=2; got shape {tuple(prediction.shape)}')
return (prediction[..., 0], prediction[..., 1])
location = prediction.squeeze(-1) if prediction.dim() > 1 else prediction
return (location, self.global_log_scale.expand_as(location))
def forward(self, prediction, target):
from torch.special import log_ndtr
location, log_scale = self.split(prediction)
DEFAULT_MIN_SCALE = 0.001
DEFAULT_NOISE = 0.01
sigma = torch.as_tensor(self.noise, dtype=target.dtype, device=target.device)
if torch.any(sigma <= 0):
raise ValueError('noise must be positive')
log_scale = log_scale.clamp(min=math.log(self.min_scale))
scale = log_scale.exp()
t = (target - location) / sigma
a = sigma / scale
nll = log_scale + a * t - 0.5 * a * a - log_ndtr(t - a)
if self.reduction == 'mean':
return nll.mean()
if self.reduction == 'sum':
return nll.sum()
return nll
criterion = SimpleCensoredMinLoss()
# Prepare prediction with 2 outputs (location and log_scale)
prediction = torch.randn(batch_size, 2)
target = torch.randn(batch_size)
ARGS = {
"prediction": prediction,
"target": target,
"criterion": criterion
}
- 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
|
| censored_min_nll |
Ran ran on a synthesized input |
symmetryadvantage/wyckofftransformer/src/wyckoff_transformer/censored.py code served (permissive licence) · get_code("31604f9db40cac45") 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
import math
torch.manual_seed(0)
# Create small tensors with distinct shapes
observed = torch.randn(2, 4)
location = torch.randn(2, 4)
log_scale = torch.randn(2, 4)
noise = 0.01
min_scale = 0.001
ARGS = {
"observed": observed,
"location": location,
"log_scale": log_scale,
"noise": noise,
"min_scale": min_scale,
}
- 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
|
| chemical_system_conditioning_dim |
Ran ran on a synthesized input |
symmetryadvantage/wyckofftransformer/src/wyckoff_transformer/chemical_system.py code served (permissive licence) · get_code("52d4978b57a845eb") How it ranRan in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned int, ndim 0, dtype family int, shape () as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import torch
torch.manual_seed(0)
# The function takes a single parameter: n_elements (int)
# It simply returns n_elements, so we need to provide a valid integer
ARGS = {
"n_elements": 5
}
- 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 int, ndim 0, dtype family int, shape () — shape () as a later run recorded it
- dtype family
- int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
- Environment
- image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
|
| chemical_system_vector |
Ran ran on a synthesized input |
symmetryadvantage/wyckofftransformer/src/wyckoff_transformer/chemical_system.py code served (permissive licence) · get_code("f1aa000edc093144") 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 (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
torch.manual_seed(0)
ARGS = {
"element_tokens": torch.tensor([0, 1, 2], dtype=torch.int64),
"n_elements": 5,
"device": None,
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- torch — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type Tensor, ndim 1, dtype family float, shape (5,) — shape (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
|
| chemical_system_vectors |
Ran ran on a synthesized input |
symmetryadvantage/wyckofftransformer/src/wyckoff_transformer/chemical_system.py code served (permissive licence) · get_code("f5091d700a375822") 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
from torch import Tensor
torch.manual_seed(0)
# element_tokens: Sequence[Sequence[int] | Tensor]
# This should be a sequence of sequences/tensors, each representing element tokens for a chemical system
element_tokens = [
[0, 1, 2], # First system with 3 elements
[1, 3], # Second system with 2 elements
]
# n_elements: int
# Size of the element vocabulary
n_elements = 4
# device: Optional[torch.device]
device = None
ARGS = {
"element_tokens": element_tokens,
"n_elements": n_elements,
"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 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
|
| composition_conditioning_dim |
Ran ran on a synthesized input |
symmetryadvantage/wyckofftransformer/src/wyckoff_transformer/composition.py code served (permissive licence) · get_code("c4974f8a6be0acfa") How it ranRan in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned int, ndim 0, dtype family int, shape () as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import torch
import torch.nn as nn
torch.manual_seed(0)
ARGS = {
"n_elements": 5,
"condition_on_cell_size": 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 int, ndim 0, dtype family int, shape () — shape () as a later run recorded it
- dtype family
- int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
- Environment
- image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
|
| composition_vector |
Ran ran on a synthesized input |
symmetryadvantage/wyckofftransformer/src/wyckoff_transformer/composition.py code served (permissive licence) · get_code("3afdb8687fc3cf98") 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 (11,) 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
from typing import Sequence
torch.manual_seed(0)
# Define ARGS dict with all parameters for composition_vector
ARGS = {
"element_tokens": torch.tensor([0, 2, 4], dtype=torch.int64),
"counts": torch.tensor([2.0, 3.0, 1.0], dtype=torch.float32),
"n_elements": 10,
"device": None,
"condition_on_cell_size": 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 1, dtype family float, shape (11,) — shape (11,) 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
|
| composition_vectors |
Ran ran on a synthesized input |
symmetryadvantage/wyckofftransformer/src/wyckoff_transformer/composition.py code served (permissive licence) · get_code("5a3de7c294a992b4") 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, 7) 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
from typing import Sequence
torch.manual_seed(0)
# For composition_vectors, we need:
# - element_tokens: Sequence[Sequence[int] | Tensor]
# - counts: Sequence[Sequence[float] | Tensor]
# - n_elements: int
# - device: Optional[torch.device]
# - condition_on_cell_size: bool
# Create two compositions with different numbers of elements
element_tokens_1 = [0, 2, 3] # 3 elements
counts_1 = [2.0, 1.0, 3.0] # 3 counts
element_tokens_2 = [1, 4] # 2 elements
counts_2 = [1.5, 2.5] # 2 counts
# Wrap them in sequences
element_tokens = [element_tokens_1, element_tokens_2]
counts = [counts_1, counts_2]
# Vocabulary size (must be > max token index, which is 4)
n_elements = 6
# Device (CPU only)
device = torch.device('cpu')
# Conditioning flag
condition_on_cell_size = True
ARGS = {
'element_tokens': element_tokens,
'counts': counts,
'n_elements': n_elements,
'device': device,
'condition_on_cell_size': condition_on_cell_size,
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- torch — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type Tensor, ndim 2, dtype family float, shape (2, 7) — shape (2, 7) 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
|
| expected_min_bias |
Ran ran on a synthesized input |
symmetryadvantage/wyckofftransformer/src/wyckoff_transformer/censored.py code served (permissive licence) · get_code("8818ca4313431c50") 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)
# Construct arguments for expected_min_bias function
scale = torch.tensor([1.5, 2.0, 0.5, 3.0], dtype=torch.float32)
n = torch.tensor([5.0, 10.0, 2.0, 8.0], dtype=torch.float32)
ARGS = {
"scale": scale,
"n": n,
}
- 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
|
| fib |
Ran ran, honoured the contract we drafted |
sparks-baird/mp-time-split/src/mp_time_split/core.py code served (permissive licence) · get_code("23b0f488ae6bc68e") How it ranRan in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned int, ndim 0, dtype family int, shape () as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import torch
torch.manual_seed(0)
# The fib function takes a single parameter n which should be a positive integer
# Reading the function body:
# - n is used in range(n - 1), so it needs to be an int > 0
# - The function returns the n-th Fibonacci number
ARGS = {
"n": 5
}
- 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 int, ndim 0, dtype family int, shape () — shape () as a later run recorded it
- dtype family
- int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
- Environment
- image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
|
| gene_representations |
Ran ran on a synthesized input |
symmetryadvantage/wyckofftransformer/src/wyckoff_transformer/gene_likelihood.py code served (permissive licence) · get_code("70341785f156077f") 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.
from collections import Counter
from math import lgamma
import numpy as np
# Construct a valid record dict for gene_representations
record = {
'elements': ['Si', 'O', 'Al'], # 3 elements
'sites_enumeration_augmented': [
(1, 2, 3), # First enumeration variant
(1, 2, 4), # Second enumeration variant
],
'site_symmetries_augmented': [
['Wyckoff_2a', 'Wyckoff_4b', 'Wyckoff_8c'], # Symmetries for first variant
['Wyckoff_2a', 'Wyckoff_4b', 'Wyckoff_8c'], # Symmetries for second variant
],
'site_symmetries': ['Wyckoff_2a', 'Wyckoff_4b', 'Wyckoff_8c'],
'sites_enumeration': (1, 2, 3),
}
ARGS = {
'record': record,
}
- 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 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
|
| generation |
Ran ran; our contract draft was wrong, not the code |
txie-93/cdvae/scripts/evaluate.py code served (permissive licence) · get_code("2c52dde33acf320d") How it ranRan in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1) 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)
# Create a minimal model that satisfies the function's requirements
class MinimalModel(nn.Module):
def __init__(self):
super().__init__()
self.hparams = type('obj', (object,), {'hidden_dim': 4})()
self.device = torch.device('cpu')
def langevin_dynamics(self, z, ld_kwargs):
batch_size = z.shape[0]
num_atoms_val = 3
num_atom_types = 5
samples = {
'frac_coords': torch.randn(batch_size, num_atoms_val, 3),
'num_atoms': torch.full((batch_size,), num_atoms_val, dtype=torch.long),
'atom_types': torch.randint(0, num_atom_types, (batch_size, num_atoms_val)),
'lengths': torch.randn(batch_size, 3),
'angles': torch.randn(batch_size, 3),
}
if ld_kwargs.save_traj:
traj_steps = 6
samples['all_frac_coords'] = torch.randn(traj_steps, batch_size, num_atoms_val, 3)
samples['all_atom_types'] = torch.randint(0, num_atom_types, (traj_steps, batch_size, num_atoms_val))
return samples
# Create a minimal ld_kwargs object
class LDKwargs:
def __init__(self, save_traj=True):
self.save_traj = save_traj
model = MinimalModel()
ld_kwargs = LDKwargs(save_traj=True)
num_batches_to_sample = 2
num_samples_per_z = 2
batch_size = 2
down_sample_traj_step = 1
ARGS = {
'model': model,
'ld_kwargs': ld_kwargs,
'num_batches_to_sample': num_batches_to_sample,
'num_samples_per_z': num_samples_per_z,
'batch_size': batch_size,
'down_sample_traj_step': down_sample_traj_step,
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1
- 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
|
| get_data_home |
Ran ran on a synthesized input |
sparks-baird/mp-time-split/src/mp_time_split/core.py code served (permissive licence) · get_code("d48fe570d3e210ff") 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 os
from os import environ, path
import tempfile
# Create a temporary directory to use as data_home
temp_dir = tempfile.mkdtemp()
# Test case 1: with explicit data_home argument
ARGS = {
"data_home": temp_dir
}
- 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
|
| get_env |
Ran ran; our contract draft was wrong, not the code |
knc6/cdvae/cdvae/common/utils.py code served (permissive licence) · get_code("00e20379657c554c") 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 os
from typing import Optional
# Test case 1: env_name exists and has a value
os.environ['TEST_VAR'] = 'test_value'
# Test case 2: env_name does not exist but default is provided
# (no setup needed, will use default)
# Test case 3: env_name exists but is empty, with default provided
os.environ['EMPTY_VAR'] = ''
ARGS = {
'env_name': 'TEST_VAR',
'default': None
}
- 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
|
| group_multiplicity_db |
Ran ran on a synthesized input |
symmetryadvantage/wyckofftransformer/src/wyckoff_transformer/csp.py code served (permissive licence) · get_code("03f72260a9ea750c") How it ranRan in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned dict. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import torch
import numpy as np
torch.manual_seed(0)
# The function iterates over multiplicity_db.items() and unpacks each key as (sg_key, ss_token, enum_token)
# and each value as multiplicity. The sg_key is used as a dictionary key in the grouped dict.
# ss_token, enum_token, and multiplicity are collected in a list.
# Create a small multiplicity_db with the expected structure
multiplicity_db = {
("sg_key_1", "ss_token_1", 0): 2,
("sg_key_1", "ss_token_2", 1): 4,
("sg_key_2", "ss_token_3", 2): 3,
("sg_key_2", "ss_token_4", 3): 5,
("sg_key_3", "ss_token_5", 0): 1,
}
ARGS = {
"multiplicity_db": multiplicity_db
}
- 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 dict — a dict output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a dict output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not stated
- Environment
- image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
|
| log_orderings |
Ran ran on a synthesized input |
symmetryadvantage/wyckofftransformer/src/wyckoff_transformer/gene_likelihood.py code served (permissive licence) · get_code("a9dc0dc92f699021") 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.
from collections import Counter
from math import lgamma
from typing import Sequence, Tuple
torch_imported = False
try:
import torch
torch_imported = True
except ImportError:
pass
# Build valid arguments for log_orderings
# The function expects sites: Sequence[tuple]
# It counts occurrences of each tuple and uses lgamma to compute log orderings
# Create a multiset of sites (tuples representing element, site symmetry, enumeration)
# Example: each tuple is (element_id, symmetry_id, enumeration_id)
sites_example = [
(1, 'A', 0),
(1, 'A', 0), # duplicate
(2, 'B', 1),
(1, 'A', 0), # another duplicate
(2, 'B', 1), # duplicate
]
ARGS = {
'sites': sites_example
}
- 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
|
| optimization |
Ran ran; our contract draft was wrong, not the code |
trachote/dp-cdvae/evaluate.py code served (permissive licence) · get_code("6bfe2286fd2a1f92") How it ranRan in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1) and returned dict. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import torch
import torch.nn as nn
from torch.optim import Adam
torch.manual_seed(0)
# Build a minimal model that satisfies the function's usage
class MinimalVAE(nn.Module):
def __init__(self):
super().__init__()
self.device = torch.device('cpu')
self.hparams = type('obj', (object,), {'hidden_dim': 4})()
# Encoder that returns (mu, logvar, z)
self.encoder = nn.Linear(10, 12) # outputs 12 values (4 for mu, 4 for logvar, 4 for z)
# fc_property: list of functions that take z and return scalar predictions
self.fc_property = [
nn.Linear(4, 1), # property predictor for prop_idx=0
nn.Linear(4, 1), # property predictor for prop_idx=1
]
def encode(self, batch):
# Returns (mu, logvar, z)
out = self.encoder(batch)
mu = out[:, :4]
logvar = out[:, 4:8]
z = out[:, 8:12]
return mu, logvar, z
def langevin_dynamics(self, z, ld_kwargs):
# Returns a dict with the required keys
batch_size = z.shape[0]
return {
'frac_coords': torch.randn(batch_size, 3, 3),
'atom_types': torch.randint(0, 10, (batch_size, 5)),
'num_atoms': torch.randint(1, 6, (batch_size,)),
'lengths': torch.randn(batch_size, 3),
'angles': torch.randn(batch_size, 3),
}
# Create model instance
model = MinimalVAE()
# Create a minimal data loader (list of batches)
data_loader = [torch.randn(2, 10) for _ in range(2)]
# Create ld_kwargs (can be empty dict or contain parameters for langevin_dynamics)
ld_kwargs = {}
# Define ARGS dict with all parameters
ARGS = {
'model': model,
'prop_idx': 0,
'ld_kwargs': ld_kwargs,
'data_loader': data_loader,
'num_starting_points': 2,
'num_gradient_steps': 10,
'lr': 0.001,
'num_saved_crys': 3,
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1
- Imports
- torch, tqdm — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type dict — a dict output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a dict output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not stated
- Environment
- image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
|
| read_config |
Ran ran on a synthesized input |
symmetryadvantage/wyckofftransformer/src/wyckoff_transformer/paths.py code served (permissive licence) · get_code("278184a2cd6bed62") How it ranRan in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned dict. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import os
from pathlib import Path
import tempfile
# Create a temporary config file for testing
temp_dir = tempfile.TemporaryDirectory()
temp_config_path = Path(temp_dir.name) / "paths.env"
# Write a valid config file
config_content = """# This is a comment
STORE_ROOT=/home/user/store
DATABASE_URL=postgresql://localhost/mydb
API_KEY=secret123
# Another comment
CACHE_DIR=/tmp/cache
"""
temp_config_path.write_text(config_content)
ARGS = {
"path": temp_config_path
}
- 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 dict — a dict output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a dict output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not stated
- Environment
- image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
|
| replace_hydride_formula |
Ran ran; our contract draft was wrong, not the code |
ixsluo/cond-cdvae/scripts/evaluate.py code served (permissive licence) · get_code("ca13c46956b131eb") How it ranRan in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1) 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 random
# Set seed for reproducibility
random.seed(0)
# The function takes a single parameter: string
# It iterates through each character in the string
# If the character is 'M', it replaces it with a random choice from the M tuple
# Otherwise, it keeps the character as is
# Create test strings with various patterns
test_string_1 = "MH2" # Simple hydride formula with one M
test_string_2 = "M2MO3" # Multiple M's
test_string_3 = "H2O" # No M's
test_string_4 = "MMMCl" # Multiple consecutive M's
ARGS = {
"string": "MH2"
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1
- 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
|
| repo_root |
Ran ran on a synthesized input |
symmetryadvantage/wyckofftransformer/src/wyckoff_transformer/paths.py code served (permissive licence) · get_code("d04319a29ef33c57") 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.
from pathlib import Path
import tempfile
import os
# Create a temporary directory structure to simulate a repo
temp_dir = tempfile.mkdtemp()
nested_dir = Path(temp_dir) / "subdir" / "nested"
nested_dir.mkdir(parents=True, exist_ok=True)
# Create a pyproject.toml marker file at the repo root
repo_marker_path = Path(temp_dir) / "pyproject.toml"
repo_marker_path.write_text("[project]\nname = 'test'\n")
# Test with a nested path that should find the repo root
test_start_path = nested_dir
ARGS = {
"start": test_start_path
}
- 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 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
|
| sample_range |
Ran ran; our contract draft was wrong, not the code |
ixsluo/cond-cdvae/scripts/evaluate.py code served (permissive licence) · get_code("51f77bb8655afae1") How it ranRan in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1) 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 random
import re
# Set seed for reproducibility
random.seed(42)
# The function takes a single parameter: string
# It finds patterns like "m-n" in the string and replaces them with random integers between m and n
ARGS = {
'string': 'The answer is 1-10 and the range 5-15 should work fine'
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1
- 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
|
| service_ops_vectors |
Ran ran on a synthesized input |
symmetryadvantage/wyckofftransformer/src/wyckoff_transformer/preprocess_wychoffs.py code served (permissive licence) · get_code("eb8846d66ef5069d") How it ranRan in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned dict. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import numpy as np
ARGS = {
'width': 8
}
- 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 dict — a dict output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a dict output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not stated
- Environment
- image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
|
| start_log_prior |
Ran ran on a synthesized input |
symmetryadvantage/wyckofftransformer/src/wyckoff_transformer/gene_likelihood.py code served (permissive licence) · get_code("4c607b6dfe2abca6") 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 Series. 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 logging
import numpy as np
import pandas as pd
from pathlib import Path
from unittest.mock import MagicMock
logging.basicConfig(level=logging.WARNING)
class MockTokenizer:
"""Stand-in tokenizer supporting both categorial and one_hot lookup."""
def __init__(self, start_type='categorial'):
self.start_type = start_type
if start_type == 'categorial':
self.token_map = {'P1': 0, 'P21': 1, 'C2': 2}
else: # one_hot
self.np_dict = {
'P1': np.array([1.0, 0.0, 0.0]),
'P21': np.array([0.0, 1.0, 0.0]),
'C2': np.array([0.0, 0.0, 1.0])
}
def __getitem__(self, key):
if self.start_type == 'categorial':
return self.token_map.get(key, -1)
else:
return self.np_dict.get(key, np.array([-1.0, -1.0, -1.0]))
class MockTrainer:
"""Stand-in trainer with required attributes and methods."""
def __init__(self, start_type='categorial'):
self.start_type = start_type
self.run_path = Path('/tmp/mock_run')
self.start_name = 'space_group'
self.start_token_distribution = None
self.tokenisers = {
self.start_name: MockTokenizer(start_type=start_type)
}
def get_start_token_distribution_path(self, run_path):
return run_path / 'start_token_distribution.pkl'
def load_start_token_distribution_file(self, path):
if self.start_type == 'categorial':
return {
'counts': np.array([100, 50, 25]),
'start_type': 'categorial',
'vectors': None
}
else: # one_hot
return {
'counts': np.array([100, 50, 25]),
'start_type': 'one_hot',
'vectors': [
np.array([1.0, 0.0, 0.0]),
np.array([0.0, 1.0, 0.0]),
np.array([0.0, 0.0, 1.0])
]
}
def make_args_categorial():
trainer = MockTrainer(start_type='categorial')
trainer.start_token_distribution = trainer.load_start_token_distribution_file(None)
records = pd.DataFrame({
'space_group': ['P1', 'P21', 'C2', 'P1']
})
return {
'trainer': trainer,
'records': records
}
def make_args_one_hot():
trainer = MockTrainer(start_type='one_hot')
trainer.start_token_distribution = trainer.load_start_token_distribution_file(None)
records = pd.DataFrame({
'space_group': ['P1', 'P21', 'C2', 'P1']
})
return {
'trainer': trainer,
'records': records
}
ARGS = make_args_categorial()
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- numpy, pandas — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type Series — a Series output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a Series 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
|
| start_to_db_key |
Ran ran on a synthesized input |
symmetryadvantage/wyckofftransformer/src/wyckoff_transformer/csp.py code served (permissive licence) · get_code("dc734da5f9a66136") 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)
# Test case 1: scalar tensor (1D with single element)
start_scalar = torch.tensor([5.0])
# Test case 2: 1D tensor with multiple elements
start_1d = torch.tensor([1.0, 2.0, 3.0, 4.0])
# Test case 3: 2D tensor (batch of vectors)
start_2d = torch.tensor([[1.0, 2.0, 3.0, 4.0],
[5.0, 6.0, 7.0, 8.0]])
# Test case 4: higher dimensional tensor
start_3d = torch.randn(2, 3, 4)
# Using a simple scalar tensor as the primary test case
ARGS = {
"start": start_scalar
}
- 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
|
| warmup_stable_decay |
Ran ran on a synthesized input |
symmetryadvantage/wyckofftransformer/src/wyckoff_transformer/schedules.py code served (permissive licence) · get_code("a0fd18cdf3bb9181") 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 LambdaLR. 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 torch.optim as optim
torch.manual_seed(0)
# Create a minimal model
model = nn.Linear(4, 3)
# Create an optimizer
optimizer = optim.SGD(model.parameters(), lr=0.1)
# Define all arguments for warmup_stable_decay
ARGS = {
'optimizer': optimizer,
'total_steps': 1000,
'warmup_fraction': 0.02,
'decay_fraction': 0.1,
'final_lr_fraction': 0.0,
'decay_shape': 'linear'
}
- 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 LambdaLR — a LambdaLR output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a LambdaLR 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
|
| build_clean_relaxation_condition |
Not yet run unverified (harvested, no recorded run) |
symmetryadvantage/wyckofftransformer/src/wyckoff_transformer/gene_energy.py code served (permissive licence) · get_code("f2619508491644d0") How it ran |
| build_combinatorics |
Not yet run unverified (harvested, no recorded run) |
symmetryadvantage/wyckofftransformer/src/wyckoff_transformer/csp.py code served (permissive licence) · get_code("d8cfa8a7bd164a1f") How it ran |
| build_tokenised_prediction_tensors |
Not yet run unverified (harvested, no recorded run) |
symmetryadvantage/wyckofftransformer/src/wyckoff_transformer/prediction.py code served (permissive licence) · get_code("2efd8e80003f0994") How it ran |
| data_store |
Not yet run unverified (harvested, no recorded run) |
symmetryadvantage/wyckofftransformer/src/wyckoff_transformer/paths.py code served (permissive licence) · get_code("6205bcf4c0b21416") How it ran |
| filter_supported_tokens |
Not yet run unverified (harvested, no recorded run) |
symmetryadvantage/wyckofftransformer/src/wyckoff_transformer/prediction.py code served (permissive licence) · get_code("7682a09675335624") How it ran |
| get_file_paths |
Not yet run unverified (harvested, no recorded run) |
ixsluo/cond-cdvae/scripts/compute_metrics.py code served (permissive licence) · get_code("9a6539ae57f02d7a") How it ran |
| mp_time_split |
Not yet run unverified (harvested, no recorded run) |
sparks-baird/mp-time-split/src/mp_time_split/utils/split.py code served (permissive licence) · get_code("3bc0f40b2f7fd1cc") How it ran |
| optimization |
Not yet run unverified (harvested, no recorded run) |
txie-93/cdvae/scripts/evaluate.py code served (permissive licence) · get_code("7d1d1bcb15f1fefe") How it ran |
| tokeniser_key |
Not yet run unverified (harvested, no recorded run) |
symmetryadvantage/wyckofftransformer/src/wyckoff_transformer/prediction.py code served (permissive licence) · get_code("e28290d6a95905bf") How it ran |