| classification_loss |
Ran ran on a synthesized input |
faroukmokhtar/particleflow/mlpf/model/losses.py code served (permissive licence) · get_code("e64cf35ab8bff4bb") 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 torch.nn.functional as F
torch.manual_seed(0)
# Construct the y dictionary with cls_id tensor
# cls_id should be a 1D tensor of class labels (batch_size,)
# Using batch size 2, with class IDs ranging from 0 to 3
y = {
'cls_id': torch.tensor([0, 1, 2, 0], dtype=torch.long) # batch_size=4
}
# Construct the ypred dictionary with required tensors
# ypred['cls_binary'] should be logits for binary classification (batch_size, 2)
# ypred['cls_id_onehot'] should be logits for multi-class (batch_size, num_classes)
num_classes = 4
batch_size = 4
ypred = {
'cls_binary': torch.randn(batch_size, 2), # binary classification logits
'cls_id_onehot': torch.randn(batch_size, num_classes) # multi-class logits
}
ARGS = {
'y': y,
'ypred': ypred
}
- 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
|
| customize_pipeline_test |
Ran ran on a synthesized input |
faroukmokhtar/particleflow/mlpf/customizations.py code served (permissive licence) · get_code("2b270dba64c8bbb1") 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)
# Build a minimal config dict that satisfies the function's requirements
config = {
'batching': {
'bucket_by_sequence_length': True,
},
'datasets': ['cms_pf_ttbar'],
'train_test_datasets': {
'physical': {
'datasets': ['cms_pf_ttbar'],
'batch_per_gpu': 4,
}
},
'validation_dataset': 'cms_pf_ttbar',
'validation_batch_size': 2,
'evaluation_datasets': {
'cms_pf_ttbar': {
'batch_size': 2,
'num_events': -1,
}
},
'parameters': {
'num_graph_layers_id': 5,
'num_graph_layers_cls': 3,
},
}
ARGS = {
'config': config,
}
- 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
|
| dataset_input_type_id |
Ran ran on a synthesized input |
faroukmokhtar/particleflow/mlpf/conf.py code served (permissive licence) · get_code("c01f983334e0f6b8") 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
# Construct arguments for dataset_input_type_id
# The function takes a dataset_name string parameter and returns an int
ARGS = {
'dataset_name': 'test_hits_dataset'
}
- 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
|
| dataset_source_id |
Ran ran on a synthesized input |
faroukmokhtar/particleflow/mlpf/conf.py code served (permissive licence) · get_code("d8a81f0febeff149") 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.
# Setup code for dataset_source_id function
from enum import Enum
class Dataset(Enum):
CMS = 'cms'
CLIC = 'clic'
CLD = 'cld'
CLIC_HITS = 'clic_hits'
CLD_HITS = 'cld_hits'
SOURCE_IDS = {'unknown': 0, Dataset.CMS.value: 1, Dataset.CLIC.value: 2, Dataset.CLD.value: 3}
def dataset_source_id(dataset_name: str) -> int:
for source_name, source_id in SOURCE_IDS.items():
if source_name != 'unknown' and dataset_name.startswith(f'{source_name}_'):
return source_id
return SOURCE_IDS['unknown']
# Test arguments
ARGS = {
'dataset_name': 'cms_data'
}
- 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 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
|
| deltaphi |
Ran ran on a synthesized input |
faroukmokhtar/particleflow/mlpf/jet_utils.py code served (permissive licence) · get_code("72d34ad7b15b8a79") 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
import numba
@numba.njit
def deltaphi(phi1, phi2):
diff = phi1 - phi2
return np.arctan2(np.sin(diff), np.cos(diff))
# The function takes two angle arguments (phi1 and phi2) and computes the difference
# wrapped to [-pi, pi] using arctan2. Both should be numpy arrays or scalars.
# Create small test arrays representing angles in radians
phi1_val = np.array([0.5, 1.0, 1.5, 2.0], dtype=np.float64)
phi2_val = np.array([0.2, 0.8, 1.2, 1.8], dtype=np.float64)
ARGS = {
"phi1": phi1_val,
"phi2": phi2_val,
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- numba, 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
|
| deltar |
Ran ran on a synthesized input |
faroukmokhtar/particleflow/mlpf/jet_utils.py code served (permissive licence) · get_code("48d587451f46aabd") 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 (2,) as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import numpy as np
import numba
@numba.njit
def deltaphi(phi1, phi2):
diff = phi1 - phi2
return np.arctan2(np.sin(diff), np.cos(diff))
@numba.njit
def deltar(eta1, phi1, eta2, phi2):
deta = eta1 - eta2
dphi = deltaphi(phi1, phi2)
return np.sqrt(deta ** 2 + dphi ** 2)
# Create small numpy arrays for the parameters
eta1 = np.array([1.5, 2.3], dtype=np.float64)
phi1 = np.array([0.5, 1.2], dtype=np.float64)
eta2 = np.array([1.0, 2.0], dtype=np.float64)
phi2 = np.array([0.3, 1.0], dtype=np.float64)
ARGS = {
"eta1": eta1,
"phi1": phi1,
"eta2": eta2,
"phi2": phi2
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- numba, 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 (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
|
| get_regions |
Ran ran on a synthesized input |
faroukmokhtar/particleflow/mlpf/model/heptv2.py code served (permissive licence) · get_code("9c993588b9c2e6fc") How it ranRan in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned Tensor, ndim 3, dtype family float, shape (2, 2, 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
from einops import rearrange
torch.manual_seed(0)
ARGS = {
"num_regions": 8,
"num_or_hashes": 2,
"num_heads": 3,
"num_and_hashes": 2,
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- einops, torch — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type Tensor, ndim 3, dtype family float, shape (2, 2, 3) — shape (2, 2, 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
|
| invert_permutation |
Ran ran on a synthesized input |
faroukmokhtar/particleflow/mlpf/model/heptv2.py code served (permissive licence) · get_code("ded74e6af3ddb339") 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 int, 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 os
torch.manual_seed(0)
# Create a small permutation tensor
# A permutation is a rearrangement of indices
# Shape: (2, 4) - batch size 2, dimension 4
perm = torch.tensor([[1, 3, 0, 2], [2, 0, 3, 1]], dtype=torch.long)
ARGS = {
'perm': perm,
}
- 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 int, 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
|
| lsh_mapping |
Ran ran on a synthesized input |
faroukmokhtar/particleflow/mlpf/model/hept.py code served (permissive licence) · get_code("a99434c75350faa3") 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
torch.manual_seed(0)
class SimpleHasher(nn.Module):
"""A minimal LSH hasher that maps input tensors to hash values."""
def __init__(self, input_dim, output_dim):
super().__init__()
self.projection = nn.Linear(input_dim, output_dim)
def forward(self, x):
# Apply projection and return hash-like values
return self.projection(x)
# Create the e2lsh model
input_dim = 4
output_dim = 3
e2lsh = SimpleHasher(input_dim, output_dim)
# Create queries and keys tensors
# queries: shape (2, 4) - batch of 2, dimension 4
# keys: shape (2, 4) - batch of 2, dimension 4
queries = torch.randn(2, 4)
keys = torch.randn(2, 4)
ARGS = {
"e2lsh": e2lsh,
"queries": queries,
"keys": keys,
}
- 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 — 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
|
| match_jets |
Ran ran on a synthesized input |
faroukmokhtar/particleflow/mlpf/jet_utils.py code served (permissive licence) · get_code("45ca4d36fd5a0792") 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 numpy as np
class Jet:
def __init__(self, eta, phi):
self.eta = eta
self.phi = phi
# Create two events with jets
# Event 1: 3 jets in first collection, 2 jets in second collection
jets1_event1 = Jet(
eta=np.array([0.5, 1.2, -0.8]),
phi=np.array([0.1, 1.5, 2.3])
)
jets2_event1 = Jet(
eta=np.array([0.55, 2.0]),
phi=np.array([0.12, 1.6])
)
# Event 2: 2 jets in first collection, 3 jets in second collection
jets1_event2 = Jet(
eta=np.array([1.0, -1.5]),
phi=np.array([0.5, 2.8])
)
jets2_event2 = Jet(
eta=np.array([1.05, -1.48, 0.2]),
phi=np.array([0.51, 2.79, 1.2])
)
jets1 = [jets1_event1, jets1_event2]
jets2 = [jets2_event1, jets2_event2]
deltaR_cut = 0.5
ARGS = {
"jets1": jets1,
"jets2": jets2,
"deltaR_cut": deltaR_cut,
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- numba, 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
|
| pairwise_l2_dist |
Ran ran on a synthesized input |
faroukmokhtar/particleflow/mlpf/model/gnnlsh.py code served (permissive licence) · get_code("c22d7ce353754a1e") 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, 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)
# Create two small tensors for pairwise L2 distance computation
# A: shape (2, 4) - 2 points in 4D space
# B: shape (3, 4) - 3 points in 4D space
A = torch.randn(2, 4, dtype=torch.float32)
B = torch.randn(3, 4, dtype=torch.float32)
ARGS = {
"A": A,
"B": B,
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- 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, 3) — shape (2, 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
|
| point_wise_feed_forward_network |
Ran ran on a synthesized input |
faroukmokhtar/particleflow/mlpf/model/gnnlsh.py code served (permissive licence) · get_code("a3aa89db788edd6f") 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
from torch import nn
torch.manual_seed(0)
ARGS = {
"d_in": 4,
"d_hidden": 8,
"d_out": 3,
"num_layers": 2,
"activation": "ELU",
"dropout": 0.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 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
|
| regression_loss |
Ran ran on a synthesized input |
faroukmokhtar/particleflow/mlpf/model/losses.py code served (permissive licence) · get_code("5c5bebafe8dccc63") 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 torch.nn.functional as F
torch.manual_seed(0)
# Construct y dictionary with required keys
# y['cls_id']: classification ID (0 means not a particle)
# y[feature]: target values for each regression feature
batch_size = 2
y = {
'cls_id': torch.tensor([1, 0, 1, 1]), # Mix of particles (1) and non-particles (0)
'pt': torch.randn(4),
'eta': torch.randn(4),
'sin_phi': torch.randn(4),
'cos_phi': torch.randn(4),
'energy': torch.randn(4),
}
# Construct ypred dictionary with predictions for each feature
ypred = {
'pt': torch.randn(4),
'eta': torch.randn(4),
'sin_phi': torch.randn(4),
'cos_phi': torch.randn(4),
'energy': torch.randn(4),
}
# input_pt: base transverse momentum for scaling
input_pt = torch.tensor([50.0, 75.0, 100.0, 120.0])
# regression_weights: weight multiplier for each feature
regression_weights = {
'pt': 1.0,
'eta': 0.5,
'sin_phi': 0.3,
'cos_phi': 0.3,
'energy': 1.0,
}
ARGS = {
'y': y,
'ypred': ypred,
'input_pt': input_pt,
'regression_weights': regression_weights,
}
- 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
|
| sliced_wasserstein_loss |
Ran ran on a synthesized input |
faroukmokhtar/particleflow/mlpf/model/losses.py code served (permissive licence) · get_code("cfb51c77ac54ffd0") 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)
# Construct tiny tensors for y_pred and y_true
# Shape: (batch_size, feature_dim)
# Using batch_size=2, feature_dim=4
batch_size = 2
feature_dim = 4
y_true = torch.randn(batch_size, feature_dim)
y_pred = torch.randn(batch_size, feature_dim)
num_projections = 200
ARGS = {
"y_pred": y_pred,
"y_true": y_true,
"num_projections": num_projections,
}
- 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
|
| split_indices_to_bins_batch |
Ran ran on a synthesized input |
faroukmokhtar/particleflow/mlpf/model/gnnlsh.py code served (permissive licence) · get_code("b146c0426554f03c") How it ranRan in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned Tensor, ndim 3, dtype family int, shape (2, 16, 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)
batch_size = 2
n_points = 8
num_or_hashes = 4
bin_size = 2
# Create tensor 'a' with shape (batch_size, n_points, num_or_hashes)
a = torch.randn(batch_size, n_points, num_or_hashes)
# Create mask 'msk' with shape (batch_size, n_points)
# Should have some True and False values
msk = torch.randint(0, 2, (batch_size, n_points)).to(torch.bool)
ARGS = {
'a': a,
'bin_size': bin_size,
'msk': msk,
'stable_sort': False
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- torch — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type Tensor, ndim 3, dtype family int, shape (2, 16, 2) — shape (2, 16, 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
|
| trunc_normal_ |
Ran ran on a synthesized input |
faroukmokhtar/particleflow/mlpf/model/hept.py code served (permissive licence) · get_code("e932b7d3ef0f378b") 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; no output shape is stated. It ran in syntology-harvest-sandbox:v5-deps (sha256:6a292aa1aed1) at 2026-09-26T22:17:14Z. 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 math
import torch
torch.manual_seed(0)
# Create a small tensor to be filled with truncated normal values
tensor = torch.empty(2, 4)
# Define arguments for trunc_normal_
ARGS = {
"tensor": tensor,
"mean": 0.0,
"std": 1.0,
"a": -2.0,
"b": 2.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 2, dtype family float — no output shape is stated: no later run recorded an output shape for this sample (observed_output and metamorphic_properties carry none; shape_contract and output_contract record ndim only)
- 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 syntology-harvest-sandbox:v5-deps (sha256:6a292aa1aed1); 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
|
| uniform |
Ran ran; our contract draft was wrong, not the code |
faroukmokhtar/particleflow/mlpf/model/hept.py code served (permissive licence) · get_code("1d809fe0159efa28") 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)
ARGS = {
'a': 0.0,
'b': 10.0,
'shape': (2, 4),
'device': 'cpu'
}
- 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
|
| quantile_partition |
Not yet run unverified (harvested, no recorded run) |
faroukmokhtar/particleflow/mlpf/model/heptv2.py code served (permissive licence) · get_code("574204301da463f9") How it ran |