| batch_to_dict |
Ran ran; our contract draft was wrong, not the code |
spozdn/pet/src/molecule.py code served (permissive licence) · get_code("55931e9283fdb1b3") 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)
class Batch:
def __init__(self):
self.x = torch.randn(2, 4)
self.central_species = torch.randint(0, 5, (2,))
self.neighbor_species = torch.randint(0, 5, (2, 3))
self.mask = torch.ones(2, 3, dtype=torch.bool)
self.batch = torch.tensor([0, 1])
self.nums = torch.tensor([3, 3])
self.neighbors_index = torch.randint(0, 2, (2, 3)).T
self.neighbors_pos = torch.randn(2, 3, 4)
self.target_id = torch.tensor([10, 20])
self.neighbor_scalar_attributes = torch.randn(2, 3, 2)
self.central_scalar_attributes = torch.randn(2, 2)
self.k_vectors = torch.randn(2, 5, 3)
self.k_mask = torch.ones(2, 5, dtype=torch.bool)
self.positions = torch.randn(2, 3)
self.volume = torch.tensor([100.0, 150.0])
batch = Batch()
ARGS = {
'batch': batch
}
- 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
|
| combine_hypers_shallow |
Ran ran; our contract draft was wrong, not the code |
spozdn/pet/src/hypers.py code served (permissive licence) · get_code("4bc4baf4b5f5ccd8") 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
torch.manual_seed(0)
# Construct test data for combine_hypers_shallow function
provided_hypers = {
'learning_rate': 0.01,
'batch_size': 32
}
default_hypers = {
'learning_rate': 0.001,
'batch_size': 16,
'epochs': 100,
'optimizer': 'adam'
}
duplicated_params = [
('lr', 'learning_rate'),
('batch', 'batch_size')
]
ARGS = {
'provided_hypers': provided_hypers,
'default_hypers': default_hypers,
'duplicated_params': duplicated_params
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- torch — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type dict — a dict output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a dict output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not stated
- Environment
- image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
|
| convert_atomic_throughput |
Ran ran, honoured the contract we drafted |
spozdn/pet/src/analysis.py code served (permissive licence) · get_code("4bec4c57a9f5a050") 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 numpy as np
import math
class MockStructure:
"""Stand-in for atomic structure object with get_positions() method."""
def __init__(self, num_atoms):
self.num_atoms = num_atoms
def get_positions(self):
"""Return positions array with shape (num_atoms, 3)."""
return np.random.rand(self.num_atoms, 3)
# Create train_structures with distinct sizes
train_structures = [
MockStructure(num_atoms=5),
MockStructure(num_atoms=7),
MockStructure(num_atoms=3),
]
# Create atomic_throughput value
atomic_throughput = 100
ARGS = {
"train_structures": train_structures,
"atomic_throughput": atomic_throughput,
}
- 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 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
|
| cutoff_func |
Ran ran; our contract draft was wrong, not the code |
spozdn/pet/src/pet.py code served (permissive licence) · get_code("95ddf4e6c591ac91") 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 numpy as np
torch.manual_seed(0)
# Create a small grid tensor with values in a range that will exercise all branches
# of the cutoff function
grid = torch.linspace(0, 10, 8).reshape(2, 4)
r_cut = 5.0
delta = 2.0
ARGS = {
"grid": grid,
"r_cut": r_cut,
"delta": delta,
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- numpy, torch — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type Tensor, ndim 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_activation |
Ran ran; our contract draft was wrong, not the code |
spozdn/pet/src/pet.py code served (permissive licence) · get_code("e8687ce6441116b2") 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 Mish. 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
from torch import nn
# Create a small stand-in class for hypers that has ACTIVATION attribute
class HyperConfig:
def __init__(self, activation):
self.ACTIVATION = activation
# Test with 'mish' activation
hypers = HyperConfig('mish')
ARGS = {
'hypers': hypers
}
- 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 Mish — a Mish output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a Mish 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_all_k_from_reciprocal |
Ran ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT) |
spozdn/pet/src/long_range.py code served (permissive licence) · get_code("1a94a922640cc3c0") 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 2, 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 numpy as np
import math
# Analyze the function to understand what arguments are needed
# get_all_k_from_reciprocal takes: w_1, w_2, w_3 (reciprocal lattice vectors), k_cut (cutoff)
# Each w_i is used in np.cross and vector operations, so they should be 1D arrays
# k_cut is a scalar used in comparison
# Create small 3D vectors for reciprocal lattice vectors
w_1 = np.array([1.0, 0.0, 0.0])
w_2 = np.array([0.0, 1.0, 0.0])
w_3 = np.array([0.0, 0.0, 1.0])
# Set a reasonable k_cut value
k_cut = 2.5
ARGS = {
"w_1": w_1,
"w_2": w_2,
"w_3": w_3,
"k_cut": k_cut
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- numpy — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type list, ndim 2, 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
|
| get_all_species |
Ran ran, honoured the contract we drafted |
spozdn/pet/src/data_preparation.py code served (permissive licence) · get_code("b20572fb9eed36e9") 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 1, dtype family int, shape (3,) as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import numpy as np
class MockStructure:
"""Mock structure object that has get_atomic_numbers() method."""
def __init__(self, atomic_numbers):
self.atomic_numbers = atomic_numbers
def get_atomic_numbers(self):
return self.atomic_numbers
# Create sample structures with different atomic numbers
structure1 = MockStructure([1, 1, 8]) # H, H, O
structure2 = MockStructure([6, 8, 8]) # C, O, O
structure3 = MockStructure([1, 6]) # H, C
structures = [structure1, structure2, structure3]
ARGS = {
"structures": structures
}
- 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 1, dtype family int, shape (3,) — shape (3,) as a later run recorded it
- dtype family
- int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
- Environment
- image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
|
| get_forces |
Ran ran, honoured the contract we drafted |
spozdn/pet/src/data_preparation.py code served (permissive licence) · get_code("e16a920d4ecca23d") 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 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 numpy as np
torch.manual_seed(0)
# Create a stand-in Structure class that mimics ASE or similar structure object
class Structure:
def __init__(self, arrays_dict):
self.arrays = arrays_dict
# Create two sample structures with forces arrays
structure1 = Structure({
'forces': np.array([[1.0, 2.0, 3.0, 4.0], [5.0, 6.0, 7.0, 8.0]], dtype=np.float32)
})
structure2 = Structure({
'forces': np.array([[0.5, 1.5, 2.5, 3.5], [4.5, 5.5, 6.5, 7.5]], dtype=np.float32)
})
structures = [structure1, structure2]
FORCES_KEY = 'forces'
ARGS = {
'structures': structures,
'FORCES_KEY': FORCES_KEY
}
- 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 list, ndim 3, 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
|
| get_pyg_graphs |
Ran ran; our contract draft was wrong, not the code |
spozdn/pet/src/data_preparation.py code served (permissive licence) · get_code("d7df1a51b8ac9361") 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 numpy as np
import torch
torch.manual_seed(0)
class MockMolecule:
def __init__(self, structure, R_CUT, USE_ADDITIONAL_SCALAR_ATTRIBUTES, USE_LONG_RANGE, K_CUT, MULTI_TARGET, TARGET_INDEX_KEY):
self.structure = structure
self.R_CUT = R_CUT
self.USE_ADDITIONAL_SCALAR_ATTRIBUTES = USE_ADDITIONAL_SCALAR_ATTRIBUTES
self.USE_LONG_RANGE = USE_LONG_RANGE
self.K_CUT = K_CUT
self.MULTI_TARGET = MULTI_TARGET
self.TARGET_INDEX_KEY = TARGET_INDEX_KEY
self._max_num = np.random.randint(5, 15)
self._num_k = np.random.randint(3, 8) if USE_LONG_RANGE else 0
def get_max_num(self):
return self._max_num
def get_num_k(self):
return self._num_k
def get_graph(self, max_num, all_species, max_k_num):
return {"nodes": np.random.rand(max_num, 4), "edges": np.random.rand(max_num, 3)}
# Monkey patch the Molecule class in the function's module
import sys
module = sys.modules[__name__]
module.Molecule = MockMolecule
# Create mock structures
structures = [
{"atoms": ["C", "H", "O"], "positions": np.random.rand(3, 3)},
{"atoms": ["N", "C"], "positions": np.random.rand(2, 3)}
]
# Create all_species list
all_species = ["C", "H", "O", "N"]
# Set parameters
R_CUT = 5.0
USE_ADDITIONAL_SCALAR_ATTRIBUTES = True
USE_LONG_RANGE = True
K_CUT = 3.0
MULTI_TARGET = False
TARGET_INDEX_KEY = "energy"
ARGS = {
"structures": structures,
"all_species": all_species,
"R_CUT": R_CUT,
"USE_ADDITIONAL_SCALAR_ATTRIBUTES": USE_ADDITIONAL_SCALAR_ATTRIBUTES,
"USE_LONG_RANGE": USE_LONG_RANGE,
"K_CUT": K_CUT,
"MULTI_TARGET": MULTI_TARGET,
"TARGET_INDEX_KEY": TARGET_INDEX_KEY
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- numpy, torch, tqdm — 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
|
| get_structural_batch_size |
Ran ran, honoured the contract we drafted |
spozdn/pet/src/analysis.py code served (permissive licence) · get_code("072569b89a08575e") 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 numpy as np
import math
class MockStructure:
"""Mock ASE-like structure object with get_positions() method"""
def __init__(self, num_atoms):
self.num_atoms = num_atoms
def get_positions(self):
"""Return positions array with shape (num_atoms, 3)"""
return np.random.randn(self.num_atoms, 3)
# Create mock structures with different numbers of atoms
structures = [
MockStructure(num_atoms=5),
MockStructure(num_atoms=7),
MockStructure(num_atoms=3),
]
atomic_batch_size = 32
ARGS = {
"structures": structures,
"atomic_batch_size": atomic_batch_size,
}
- 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 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
|
| get_volume |
Ran ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT) |
spozdn/pet/src/long_range.py code served (permissive licence) · get_code("07ab60b0a26fa0b2") 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 float64, ndim 0, 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 numpy as np
# Create three vectors for computing volume of parallelepiped
# Each vector should be a numpy array of shape (3,) for 3D vectors
v_1 = np.array([1.0, 2.0, 3.0])
v_2 = np.array([4.0, 5.0, 6.0])
v_3 = np.array([7.0, 8.0, 10.0])
ARGS = {
"v_1": v_1,
"v_2": v_2,
"v_3": v_3,
}
- 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 float64, ndim 0, dtype family float — no output shape is stated: observe_signature.py recorded float ndim 0, which disagrees with the fixture run
- 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
|
| propagate_duplicated_params |
Ran ran; our contract draft was wrong, not the code |
spozdn/pet/src/hypers.py code served (permissive licence) · get_code("d10705f1d479d240") How it ranRan in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned tuple, ndim 1, dtype family float; no output shape is stated. The image it ran in was not recorded. If your copy returns the same type and ndim on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import torch
torch.manual_seed(0)
# Simple test case 1: first_key provided in provided_hypers
provided_hypers_1 = {'learning_rate': 0.001}
default_hypers_1 = {'batch_size': 32}
first_key_1 = 'learning_rate'
second_key_1 = 'lr'
# Simple test case 2: second_key provided in provided_hypers
provided_hypers_2 = {'lr': 0.002}
default_hypers_2 = {'batch_size': 16}
first_key_2 = 'learning_rate'
second_key_2 = 'lr'
# Simple test case 3: first_key in default_hypers
provided_hypers_3 = {}
default_hypers_3 = {'learning_rate': 0.0005}
first_key_3 = 'learning_rate'
second_key_3 = 'lr'
# Simple test case 4: second_key in default_hypers
provided_hypers_4 = {}
default_hypers_4 = {'lr': 0.0003}
first_key_4 = 'learning_rate'
second_key_4 = 'lr'
# Use the first test case for the ARGS
ARGS = {
'provided_hypers': provided_hypers_1,
'default_hypers': default_hypers_1,
'first_key': first_key_1,
'second_key': second_key_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 tuple, ndim 1, dtype family float — a tuple output has no array shape of its own; none is stated
- dtype family
- int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
- Environment
- image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
|
| q_func_exp |
Ran ran; our contract draft was wrong, not the code |
spozdn/pet/src/sp_frames_calculator.py code served (permissive licence) · get_code("bb7a0d45da617036") How it ranRan in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned Tensor, ndim 2, dtype family float, shape (2, 4) as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import torch
torch.manual_seed(0)
# Create a small grid tensor with values
grid = torch.randn(2, 4)
# Define scalar parameters
w = 0.5
delta = 0.1
add_linear_multiplier = True
ARGS = {
"grid": grid,
"w": w,
"delta": delta,
"add_linear_multiplier": add_linear_multiplier,
}
- 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
|
| smooth_max |
Ran ran; our contract draft was wrong, not the code |
spozdn/pet/src/sp_frames_calculator.py code served (permissive licence) · get_code("ebdd8aa78165df48") 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)
# The function smooth_max takes:
# - values: an iterable of numeric values (used in zip with weights, iterated over)
# - beta: a numeric scalar (used in multiplication with value)
# Create small test values as a list of scalars
values = [torch.tensor(0.5), torch.tensor(1.2), torch.tensor(-0.3)]
# Beta is a scalar multiplier
beta = 2.0
ARGS = {
"values": values,
"beta": beta,
}
- 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
|
| smooth_max_weighted |
Ran ran; our contract draft was wrong, not the code |
spozdn/pet/src/sp_frames_calculator.py code served (permissive licence) · get_code("86484398825c248c") 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)
# The function expects:
# - values: iterable of scalars/tensors that will be multiplied by beta
# - weights: iterable of scalars/tensors that will be multiplied by exp(value * beta)
# - beta: scalar that scales the values
values = [torch.tensor(0.5), torch.tensor(1.2), torch.tensor(-0.3)]
weights = [torch.tensor(0.2), torch.tensor(0.5), torch.tensor(0.3)]
beta = torch.tensor(2.0)
ARGS = {
"values": values,
"weights": weights,
"beta": beta
}
- 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
|
| combine_hypers |
Not yet run unverified (harvested, no recorded run) |
spozdn/pet/src/hypers.py code served (permissive licence) · get_code("2d4f94e828d7243b") How it ran |
| get_upper_bound |
Not yet run unverified (harvested, no recorded run) |
spozdn/pet/src/long_range.py code served (permissive licence) · get_code("4d07a8d02807a64e") How it ran |