| ActionScalarTheory |
Ran ran on a synthesized input |
vislearn/trade/trade/datasets.py code served (permissive licence) · get_code("da01152e23f9257f") How it ranRan in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned Tensor, ndim 1, dtype family float, shape (2,) as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import torch
torch.manual_seed(0)
# mus: Initial states - should be a batch of 2D lattice field configurations
# Shape: (batch_size, channels, height, width)
# The function uses: .device, .pow(2), .pow(4), torch.roll with dims 2 and 3
mus = torch.randn(2, 1, 4, 4)
# kappas: Hopping parameters - can be float or tensor
# The function converts float to tensor of length len(mus)
# Shape should be compatible with len(mus) = 2
kappas = 0.5
# lambdas: Quadric couplings - can be float or tensor
# The function converts float to tensor of length len(mus)
# Shape should be compatible with len(mus) = 2
lambdas = 0.3
ARGS = {
"mus": mus,
"kappas": kappas,
"lambdas": lambdas,
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- torch — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type Tensor, ndim 1, dtype family float, shape (2,) — shape (2,) as a later run recorded it
- dtype family
- int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
- Environment
- image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
|
| broadcasted_where |
Ran ran on a synthesized input |
lollcat/fab-jax/fabjax/utils/jax_util.py code served (permissive licence) · get_code("31d10b58f9eba56f") 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 ArrayImpl, ndim 3, dtype family float, shape (2, 4, 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 jax.numpy as jnp
import chex
# Create valid test arrays for the broadcasted_where function
# The function requires:
# - valid_samples: a boolean array (can have fewer dimensions than a1, a2)
# - a1, a2: arrays with equal shapes
# Create a1 and a2 with shape (2, 4, 3) - batch=2, dim1=4, dim2=3
a1 = jnp.ones((2, 4, 3), dtype=jnp.float32)
a2 = jnp.zeros((2, 4, 3), dtype=jnp.float32)
# Create valid_samples with shape (2,) - fewer dimensions than a1/a2
# The function will expand_dims to broadcast properly
valid_samples = jnp.array([True, False], dtype=jnp.bool_)
ARGS = {
"valid_samples": valid_samples,
"a1": a1,
"a2": a2,
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- chex, jax — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type ArrayImpl, ndim 3, dtype family float, shape (2, 4, 3) — shape (2, 4, 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
|
| call_model_batched |
Ran ran on a synthesized input |
aimat-lab/coarse-graining-al/main/utils/call_model_batched.py code served (permissive licence) · get_code("39b9d6445fc9d49f") 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 (6, 3) as a later run recorded it. The image it ran in was not recorded. The code mentions cuda, and the harness aliases cuda to the CPU for every sample; whether this run needed that is not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import torch
import torch.nn as nn
torch.manual_seed(0)
# Create a simple model that accepts input_tensor and optional cond_tensor
class SimpleModel(nn.Module):
def __init__(self):
super().__init__()
self.linear = nn.Linear(4, 3)
def forward(self, x, cond=None):
# Model can accept conditional tensor as tuple or tensor
return self.linear(x)
# Create model instance
model = SimpleModel()
# Create input tensor: shape (6, 4) - 6 samples, 4 features
input_tensor = torch.randn(6, 4)
# Create conditional tensor: shape (6, 5) - 6 samples, 5 features
cond_tensor = torch.randn(6, 5)
ARGS = {
'model': model,
'input_tensor': input_tensor,
'cond_tensor': cond_tensor,
'pass_cond_tensor_as_tuple': True,
'device': 'cpu',
'batch_size': 2,
'move_back_to_cpu': True,
'do_detach': True,
'droplast': False,
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- torch — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type Tensor, ndim 2, dtype family float, shape (6, 3) — shape (6, 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
|
| circular_mean |
Ran ran on a synthesized input |
vislearn/trade/trade/coordinate_transform.py code served (permissive licence) · get_code("ac688680eef129e1") 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 (1, 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)
# alpha is used with .sin(), .cos(), .mean(dim=0), and .view(1, -1)
# It should be a tensor with at least 2 dimensions (batch, features)
# batch size: 2, feature dimension: 4
alpha = torch.randn(2, 4)
ARGS = {
"alpha": alpha
}
- 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 (1, 4) — shape (1, 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
|
| consistency_check_KL |
Ran ran on a synthesized input |
vislearn/trade/trade/losses.py code served (permissive licence) · get_code("b8eaabf1c9db7b92") 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 torch.nn as nn
torch.manual_seed(0)
# Create small log probability tensors (batch_size=2, num_classes=4)
log_probs_beta = torch.randn(2, 4)
log_probs_beta_0 = torch.randn(2, 4)
# Create scalar beta values
beta = torch.tensor(0.5)
beta_0 = torch.tensor(1.0)
# Create a correction function that takes beta and beta_0 and returns a scalar tensor
def correction(b, b0):
return torch.tensor(0.1)
ARGS = {
"log_probs_beta": log_probs_beta,
"log_probs_beta_0": log_probs_beta_0,
"correction": correction,
"beta": beta,
"beta_0": beta_0,
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- torch — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type Tensor, ndim 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
|
| constructor_subnet_2Dconv_plain |
Ran ran on a synthesized input |
vislearn/trade/trade/models.py code served (permissive licence) · get_code("226d82cc38425813") 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 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 = {
'c_in': 3,
'c_out': 5,
'c_hidden': 16,
'activation_type': '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 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
|
| constructor_subnet_fc_configured |
Ran ran on a synthesized input |
vislearn/trade/trade/models.py code served (permissive licence) · get_code("a16486276f5c5f09") How it ranRan in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned partial. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import torch
import torch.nn as nn
from functools import partial
torch.manual_seed(0)
# Define ARGS dict with all parameters for constructor_subnet_fc_configured
ARGS = {
'd_hidden': 16,
'activation_type': '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 partial — a partial output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a partial output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not stated
- Environment
- image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
|
| constructor_subnet_fc_plain |
Ran ran on a synthesized input |
vislearn/trade/trade/models.py code served (permissive licence) · get_code("cadccdbc4e5b12fb") 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 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 = {
'c_in': 10,
'c_out': 5,
'c_hidden': 8,
'activation_type': '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 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
|
| dActionScalarTheory_dkappa |
Ran ran on a synthesized input |
vislearn/trade/trade/datasets.py code served (permissive licence) · get_code("3e92b55934524c65") How it ranRan in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned Tensor, ndim 1, dtype family float, shape (2,) as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import torch
torch.manual_seed(0)
# Analyze the function:
# - mus: used with torch.roll and torch operations on dims 2 and 3, then summed over dims [1, 2, 3]
# This suggests mus is a 4D tensor (batch, dim1, dim2, dim3)
# - parameter_list: optional, type List[torch.Tensor | float], not used in function body
# - device: optional, type str, not used in function body
# Create a small 4D tensor: (batch=2, dim1=3, dim2=4, dim3=5)
mus = torch.randn(2, 3, 4, 5)
# parameter_list can be None or a list of tensors/floats
parameter_list = None
# device can be None or a string
device = None
ARGS = {
"mus": mus,
"parameter_list": parameter_list,
"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 1, dtype family float, shape (2,) — shape (2,) as a later run recorded it
- dtype family
- int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
- Environment
- image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
|
| generate_grid |
Ran ran on a synthesized input |
aimat-lab/coarse-graining-al/main/active_learning/active_learning_managers.py code served (permissive licence) · get_code("2327b3b50e622283") 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 (8, 3) as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import torch
torch.manual_seed(0)
# uniform_ranges: list of tuples or Tensor of shape (D,2)
# Each tuple is (min, max) for that dimension
# Let's use a list of tuples for 3 dimensions
uniform_ranges = [
(0.0, 1.0),
(-1.0, 1.0),
(10.0, 20.0),
]
# num_points_per_dim: int - number of equidistant points per dimension
num_points_per_dim = 2
ARGS = {
"uniform_ranges": uniform_ranges,
"num_points_per_dim": num_points_per_dim,
}
- 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 (8, 3) — shape (8, 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_leading_axis_tree |
Ran ran on a synthesized input |
lollcat/fab-jax/fabjax/utils/jax_util.py code served (permissive licence) · get_code("06e166b4bd44c5ce") How it ranRan in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned tuple, ndim 1, dtype family int; no output shape is stated. The image it ran in was not recorded. If your copy returns the same type and ndim on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import jax
import jax.numpy as jnp
import chex
# Create a simple tree structure with JAX arrays
# The function expects a pytree (nested structure of arrays)
# and will check that all arrays have the same leading shape
# Create arrays with distinct dimensions to test the function
array1 = jnp.ones((2, 4, 3)) # shape (2, 4, 3)
array2 = jnp.ones((2, 5, 6)) # shape (2, 5, 6)
# Create a pytree (dict of arrays) with consistent leading axis
tree = {
'a': array1,
'b': array2,
}
ARGS = {
'tree': tree,
'n_dims': 1,
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- chex, jax — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type tuple, ndim 1, dtype family int — a tuple output has no array shape of its own; none is stated
- dtype family
- int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
- Environment
- image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
|
| is_json_serializable |
Ran ran on a synthesized input |
vislearn/trade/trade/trainables.py code served (permissive licence) · get_code("9bc73838eb0f1444") 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 bool, 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 json
def is_json_serializable(value):
"""Check if a value is JSON serializable."""
try:
json.dumps(value)
return True
except (TypeError, OverflowError):
return False
# Test with a JSON-serializable value
ARGS = {
"value": {"key": "value", "number": 42, "list": [1, 2, 3], "nested": {"inner": 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 bool, 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
|
| log_p_scalar_theory |
Ran ran on a synthesized input |
vislearn/trade/trade/datasets.py code served (permissive licence) · get_code("44b1de121fc4f5c1") How it ranRan in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned Tensor, ndim 1, dtype family float, shape (2,) as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import torch
torch.manual_seed(0)
# Create a small batch of scalar field configurations
# Shape: [batch_size, spatial_dim1, spatial_dim2, spatial_dim3]
# Using batch_size=2, spatial dimensions=4x4x4 for a small 2D lattice
x = torch.randn(2, 1, 4, 4)
# Beta tensor (inverse temperature) - one value per batch element
beta_tensor = torch.tensor([0.5, 1.0])
# Lambda tensor (quadric coupling) - one value per batch element
lambdas = torch.tensor([0.1, 0.2])
# Device
device = torch.device('cpu')
ARGS = {
'x': x,
'beta_tensor': beta_tensor,
'lambdas': lambdas,
'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 1, dtype family float, shape (2,) — shape (2,) as a later run recorded it
- dtype family
- int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
- Environment
- image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
|
| plot_double_well_2d |
Ran ran on a synthesized input |
vislearn/trade/trade/plots.py code served (permissive licence) · get_code("f222aa8da4211121") How it ranRan in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned tuple. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import torch
import torch.nn as nn
import numpy as np
torch.manual_seed(0)
# Create a small energy function that takes samples and returns energies
class EnergyFunction(nn.Module):
def __init__(self):
super().__init__()
self.linear = nn.Linear(2, 1)
def forward(self, x):
# Return energy values as a 1D tensor
return self.linear(x).squeeze(-1)
# Create sample data: batch_size=2, dimensions=2 for 2D double well
samples = torch.randn(2, 2)
# Create target energy function
target_energy = EnergyFunction()
# Create reference/test data (optional, can be None)
reference_data = torch.randn(2, 2)
# Create a simple system object (may not be used but included for completeness)
system = None
ARGS = {
"samples": samples,
"system": system,
"target_energy": target_energy,
"reference_data": reference_data
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- matplotlib, numpy, 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
|
| plot_nd_histogram |
Ran ran on a synthesized input |
vislearn/trade/trade/plots.py code served (permissive licence) · get_code("21e05c489f7ca319") How it ranRan in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned tuple. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import torch
import numpy as np
import matplotlib.pyplot as plt
import torch.nn as nn
torch.manual_seed(0)
# Create a simple energy function that takes samples and returns energies
class SimpleEnergyFunction(nn.Module):
def __init__(self):
super().__init__()
self.linear = nn.Linear(4, 1)
def forward(self, x):
# Returns energy values for each sample
return self.linear(x).squeeze(-1)
# Create sample data: batch_size=2, dimensions=4
samples = torch.randn(2, 4)
# Create reference/test data: batch_size=2, dimensions=4
reference_data = torch.randn(2, 4)
# Create a simple system object (not directly used in plot_nd_histogram, but kept for completeness)
class SimpleSystem:
pass
system = SimpleSystem()
# Create energy function
target_energy = SimpleEnergyFunction()
ARGS = {
"samples": samples,
"system": system,
"target_energy": target_energy,
"reference_data": reference_data
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- matplotlib, numpy, 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
|
| read_config |
Ran ran on a synthesized input |
vislearn/trade/trade/config.py code served (permissive licence) · get_code("4b3e1d756ced6adf") 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 yaml
import tempfile
import os
# Create a temporary YAML file with valid content
temp_dir = tempfile.mkdtemp()
yaml_file_path = os.path.join(temp_dir, 'config.yaml')
config_data = {
'model': 'bert',
'learning_rate': 0.001,
'batch_size': 32,
'epochs': 10,
'layers': [64, 128, 256]
}
with open(yaml_file_path, 'w') as f:
yaml.dump(config_data, f)
ARGS = {
'file_path': yaml_file_path
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- torch, yaml — 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
|
| remove_non_serializable |
Ran ran on a synthesized input |
vislearn/trade/trade/trainables.py code served (permissive licence) · get_code("05e36a7f85d97e27") 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
import json
# Test data with both serializable and non-serializable values
test_dict = {
"name": "test",
"count": 42,
"ratio": 3.14,
"active": True,
"items": [1, 2, 3],
"nested": {
"key1": "value1",
"key2": 100,
"tensor": torch.tensor([1, 2, 3]), # non-serializable
"numpy_array": np.array([1, 2, 3]), # non-serializable
},
"tensor_list": [torch.tensor([1.0, 2.0]), "valid_string", 5],
"callable": lambda x: x, # non-serializable
"none_value": None,
}
test_list = [
"string_value",
42,
3.14,
{"nested_key": "nested_value"},
torch.tensor([1, 2, 3]), # non-serializable
np.array([4, 5, 6]), # non-serializable
[1, 2, {"inner": "dict"}],
]
ARGS = {
"obj": test_dict
}
- 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
|
| reverse_kl_loss |
Ran ran on a synthesized input |
lollcat/fab-jax/fabjax/train/fab_without_buffer.py code served (permissive licence) · get_code("e2da966a3225548a") 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 ArrayImpl, 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 jax
import jax.numpy as jnp
import jax.random as jrandom
import chex
# Define sample_and_log_prob_apply function
# Takes params and shape, returns (samples, log_probs)
def q_sample_and_log_prob_apply(params, shape):
batch_size = shape[0]
# Simple Gaussian sampler
key = jrandom.PRNGKey(0)
samples = jrandom.normal(key, (batch_size, 4))
log_probs = jnp.sum(-0.5 * samples**2, axis=1)
return samples, log_probs
# Define log_q_fn_apply function
# Takes params and samples, returns log_probs
def log_q_fn_apply(params, samples):
# Simple log probability function
return jnp.sum(-0.5 * samples**2, axis=1)
# Define log_p_fn function
# Takes samples, returns log_probs
def log_p_fn(samples):
# Simple target log probability (e.g., standard normal)
return jnp.sum(-0.5 * samples**2, axis=1)
# Create simple params tree (dict of arrays)
params = {
'w': jnp.array([[0.1, 0.2, 0.3, 0.4],
[0.5, 0.6, 0.7, 0.8]]),
'b': jnp.array([0.01, 0.02])
}
ARGS = {
'params': params,
'q_sample_and_log_prob_apply': q_sample_and_log_prob_apply,
'log_q_fn_apply': log_q_fn_apply,
'log_p_fn': log_p_fn,
'batch_size': 2,
'path_gradient': True
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- chex, jax — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type ArrayImpl, 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
|
| sample_without_replacement |
Ran ran on a synthesized input |
lollcat/fab-jax/fabjax/buffer/prioritised_buffer.py code served (permissive licence) · get_code("147034b3e56c8828") 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 ArrayImpl, ndim 2, dtype family int, 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 jax
import jax.random
import jax.lax
import chex
import numpy as np
# Set random seed for reproducibility
np.random.seed(0)
key = jax.random.PRNGKey(0)
# Create small tensors
logits = jax.numpy.array([
[1.0, 2.0, 3.0, 0.5],
[0.1, 0.2, 0.3, 0.4]
], dtype=jax.numpy.float32)
n = 2
ARGS = {
"key": key,
"logits": logits,
"n": n
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- chex, jax, numpy — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type ArrayImpl, ndim 2, dtype family int, 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
|
| select_diverse_points |
Ran ran on a synthesized input |
aimat-lab/coarse-graining-al/main/active_learning/active_learning_managers.py code served (permissive licence) · get_code("a7e6a591642b921e") 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 (3, 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 tensor with shape (batch=5, dim=4)
tensor = torch.randn(5, 4)
# N should be less than the number of points in tensor
N = 3
ARGS = {
"tensor": tensor,
"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 2, dtype family float, shape (3, 4) — shape (3, 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
|
| shift_angles |
Ran ran on a synthesized input |
vislearn/trade/trade/coordinate_transform.py code served (permissive licence) · get_code("c12e51ebb2df519b") 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 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 numpy as np
# Create test arguments for shift_angles function
alpha = np.array([0.5, 1.5, -2.0, 3.14]) # Example angles
shift = np.array([0.1, 0.2, 0.3, 0.4]) # Example shifts
ARGS = {
"alpha": alpha,
"shift": shift
}
- 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 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
|
| build_resnet |
Not yet run unverified (harvested, no recorded run) |
vislearn/trade/trade/flow.py code served (permissive licence) · get_code("cfb7a6f3f78317c8") How it ran |
| build_subnet |
Not yet run unverified (harvested, no recorded run) |
vislearn/trade/trade/flow.py code served (permissive licence) · get_code("19a851e76c47a32b") How it ran |
| compute_KL |
Not yet run unverified (harvested, no recorded run) |
vislearn/trade/trade/losses.py code served (permissive licence) · get_code("a4982e7e1d9e5669") How it ran |
| ct_shift_angle |
Not yet run unverified (harvested, no recorded run) |
vislearn/trade/trade/coordinate_transform.py code served (permissive licence) · get_code("8b55b599f66645b6") How it ran |
| fab_loss_smc_samples |
Not yet run unverified (harvested, no recorded run) |
lollcat/fab-jax/fabjax/train/fab_without_buffer.py code served (permissive licence) · get_code("5e4df7287719cf48") How it ran |
| get_correction_function |
Not yet run unverified (harvested, no recorded run) |
vislearn/trade/trade/losses.py code served (permissive licence) · get_code("01444979755c6722") How it ran |