| compute_cross_entropy_loss |
Ran ran; our contract draft was wrong, not the code |
explanare/ravel/src/utils/metric_utils.py code served (permissive licence) · get_code("39d29ba2dce082a9") 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)
# Small tensors: batch_size=2, seq_len=5, vocab_size=4
batch_size = 2
seq_len = 5
vocab_size = 4
next_n_tokens = 1
# Create logits tensor: shape (batch_size, seq_len, vocab_size)
logits = torch.randn(batch_size, seq_len, vocab_size)
# Create labels tensor: shape (batch_size, seq_len)
# Use values in range [0, vocab_size) and include pad_token_id
labels = torch.randint(0, vocab_size, (batch_size, seq_len))
# Set pad_token_id
pad_token_id = 0
ARGS = {
"logits": logits,
"labels": labels,
"pad_token_id": pad_token_id,
"next_n_tokens": next_n_tokens
}
- 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
|
| compute_disentangle_score |
Ran ran; our contract draft was wrong, not the code |
explanare/ravel/src/utils/metric_utils.py code served (permissive licence) · get_code("618cb3bd9cfb4a14") How it ranRan in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned dict. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import numpy as np
# Construct log_data dictionary
# The function accesses log_data[t]['metrics']['base_labels']['accuracy']
# and log_data[t]['metrics']['labels']['accuracy']
log_data = {
'task_1': {
'metrics': {
'base_labels': {'accuracy': 0.85},
'labels': {'accuracy': 0.90}
}
},
'task_2': {
'metrics': {
'base_labels': {'accuracy': 0.80},
'labels': {'accuracy': 0.88}
}
},
'task_3': {
'metrics': {
'base_labels': {'accuracy': 0.92},
'labels': {'accuracy': 0.95}
}
},
'task_4': {
'metrics': {
'base_labels': {'accuracy': 0.78},
'labels': {'accuracy': 0.82}
}
}
}
# Construct attribute_to_iso_tasks dictionary
# Maps attributes to lists of task names
attribute_to_iso_tasks = {
'color': ['task_1', 'task_2'],
'shape': ['task_3', 'task_4']
}
# Construct attribute_to_cause_tasks dictionary
# Maps attributes to lists of task names
attribute_to_cause_tasks = {
'rotation': ['task_1', 'task_3'],
'scale': ['task_2', 'task_4']
}
ARGS = {
'log_data': log_data,
'attribute_to_iso_tasks': attribute_to_iso_tasks,
'attribute_to_cause_tasks': attribute_to_cause_tasks
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- numpy — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type dict — a dict output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a dict output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not stated
- Environment
- image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
|
| compute_metrics |
Ran ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT) |
explanare/ravel/src/utils/metric_utils.py code served (permissive licence) · get_code("5500053238475cfe") 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 eval_preds: list of tensors with shape (batch_size, seq_len, vocab_size)
# Using 3D tensors (logits before argmax)
eval_preds = [
torch.randn(2, 5, 10), # batch=2, seq_len=5, vocab_size=10
torch.randn(2, 5, 10),
]
# Construct eval_labels: list of tensors with shape (batch_size, seq_len)
# Values should be token ids (0-9) or pad_token_id (which is 0) or negative (ignored)
eval_labels = [
torch.tensor([[1, 2, 3, 4, 5], [2, 3, 4, 5, 6]]), # batch=2, seq_len=5
torch.tensor([[0, 1, 2, 3, 4], [5, 6, 7, 8, 0]]), # batch=2, seq_len=5
]
pad_token_id = 0
ARGS = {
'eval_preds': eval_preds,
'eval_labels': eval_labels,
'pad_token_id': pad_token_id,
'last_n_tokens': 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 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
|
| compute_principal_component |
Ran ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT) |
explanare/ravel/src/methods/pca.py code served (permissive licence) · get_code("ebcb0699723a970c") How it ranRan in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned dict. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import numpy as np
from sklearn.decomposition import PCA
# Set random seed for reproducibility
np.random.seed(0)
# Create small feature matrix: 2 samples, 4 features
features = np.random.randn(2, 4).astype(np.float32)
# Set n_components to be less than min(n_samples, n_features)
n_components = 2
ARGS = {
'features': features,
'n_components': n_components
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- numpy, sklearn — 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
|
| generate_batched |
Ran ran; our contract draft was wrong, not the code |
explanare/ravel/src/utils/generation_utils.py code served (permissive licence) · get_code("e7618272c2024815") 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 torch
import torch.nn as nn
torch.manual_seed(0)
class MockTokenizer:
def __init__(self):
self.pad_token_id = 0
def __call__(self, text, return_tensors=None, padding=None, max_length=None, truncation=None):
# Simulate tokenization
if isinstance(text, str):
token_ids = [1, 2, 3]
else:
token_ids = [[1, 2, 3] for _ in text]
if max_length:
token_ids = [ids[:max_length] + [self.pad_token_id] * max(0, max_length - len(ids))
for ids in token_ids] if isinstance(token_ids[0], list) else token_ids[:max_length] + [self.pad_token_id] * max(0, max_length - len(token_ids))
if isinstance(token_ids[0], list):
input_ids = torch.tensor(token_ids, dtype=torch.long)
attention_mask = torch.tensor([[1 if x != self.pad_token_id else 0 for x in ids] for ids in token_ids], dtype=torch.long)
else:
input_ids = torch.tensor([token_ids], dtype=torch.long)
attention_mask = torch.tensor([[1 if x != self.pad_token_id else 0 for x in token_ids]], dtype=torch.long)
if return_tensors == 'pt':
return {
'input_ids': input_ids,
'attention_mask': attention_mask
}
return {'input_ids': input_ids}
def batch_decode(self, token_ids, skip_special_tokens=False):
# Mock decode: return a string for each sequence
batch_size = token_ids.shape[0]
return [f"generated text {i}" for i in range(batch_size)]
class MockGenerativeModel(nn.Module):
def __init__(self):
super().__init__()
self.linear = nn.Linear(4, 4)
self.device_type = 'cpu'
@property
def device(self):
return torch.device('cpu')
def generate(self, input_ids, attention_mask=None, max_new_tokens=None,
do_sample=False, num_return_sequences=1, return_dict_in_generate=False,
pad_token_id=None, **kwargs):
# Generate mock output token ids
batch_size = input_ids.shape[0]
seq_len = input_ids.shape[1] + (max_new_tokens if max_new_tokens else 5)
output_ids = torch.randint(1, 100, (batch_size * num_return_sequences, seq_len), dtype=torch.long)
return output_ids
tokenizer = MockTokenizer()
model = MockGenerativeModel()
all_prompts = [
"What is machine learning?",
"Explain neural networks.",
]
ARGS = {
'pretrained_model': model,
'tokenizer': tokenizer,
'all_prompts': all_prompts,
'max_length': 64,
'prompt_max_length': 32,
'max_new_tokens': 32,
'sample_n': 2,
'batch_size': 2,
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- 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 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_score |
Ran ran; our contract draft was wrong, not the code |
explanare/ravel/src/methods/linear_adversarial_probe.py code served (permissive licence) · get_code("4637704289ff6a8a") 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 numpy as np
import sklearn
from sklearn.linear_model import SGDClassifier
from sklearn.metrics import log_loss
# Set random seed for reproducibility
np.random.seed(0)
# Create small synthetic datasets
# X_train: (samples=5, features=4)
X_train = np.random.randn(5, 4).astype(np.float32)
y_train = np.array([0, 1, 0, 1, 0])
# X_dev: (samples=3, features=4)
X_dev = np.random.randn(3, 4).astype(np.float32)
y_dev = np.array([0, 1, 0])
# P: positive semi-definite matrix (4x4) for projection
# Create a symmetric positive definite matrix
A = np.random.randn(4, 4).astype(np.float32)
P = A @ A.T + np.eye(4)
# rank: smaller than feature dimension
rank = 2
ARGS = {
'X_train': X_train,
'y_train': y_train,
'X_dev': X_dev,
'y_dev': y_dev,
'P': P,
'rank': rank
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- numpy, sklearn — 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
|
| init_sgd_classifier |
Ran ran; our contract draft was wrong, not the code |
explanare/ravel/src/methods/linear_adversarial_probe.py code served (permissive licence) · get_code("9a0c2776f5ac2bc0") 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 SGDClassifier. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
from sklearn.linear_model import SGDClassifier
def init_sgd_classifier(params=None):
if params is None:
params = {'loss': 'log_loss', 'tol': 0.0001, 'iters_no_change': 15, 'alpha': 0.0001, 'max_iter': 25000}
return SGDClassifier(loss=params['loss'], fit_intercept=True, max_iter=params['max_iter'], tol=params['tol'], n_iter_no_change=params['iters_no_change'], n_jobs=32, alpha=params['alpha'])
ARGS = {
'params': {
'loss': 'log_loss',
'tol': 0.0001,
'iters_no_change': 15,
'alpha': 0.0001,
'max_iter': 25000
}
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- sklearn — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type SGDClassifier — a SGDClassifier output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a SGDClassifier 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
|
| kept_first_n_label_token |
Ran ran; our contract draft was wrong, not the code |
explanare/ravel/src/utils/dataset_utils.py code served (permissive licence) · get_code("f648fddc170ec6d8") 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)
x = {
'labels': torch.tensor([[1, 2, 3, 4, 5], [6, 7, 8, 9, 10]]),
'inv_labels': torch.tensor([[10, 20, 30, 40, 50], [60, 70, 80, 90, 100]]),
}
ARGS = {
'x': x,
'first_n': 2,
'padding_offset': 3,
}
- 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
|
| kept_first_n_label_token_multitask |
Ran ran; our contract draft was wrong, not the code |
explanare/ravel/src/utils/dataset_utils.py code served (permissive licence) · get_code("f404f9aad2c1b27e") 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 the arguments for kept_first_n_label_token_multitask
x = {
'labels': torch.tensor([1, 2, 3, 4, 5, 6, 7, 8]),
'inv_labels': torch.tensor([10, 20, 30, 40, 50, 60, 70, 80]),
'split': 'train',
'base_labels': None,
}
cause_tasks = ['train', 'val']
first_n = 4
padding_offset = 3
ARGS = {
'x': x,
'cause_tasks': cause_tasks,
'first_n': first_n,
'padding_offset': padding_offset,
}
- 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
|
| preproc_tokenize |
Ran ran; our contract draft was wrong, not the code |
explanare/ravel/src/utils/dataset_utils.py code served (permissive licence) · get_code("39872fcdf40c8524") 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 copy
import torch
from transformers import AutoTokenizer
torch.manual_seed(0)
class MockTokenizer:
def __init__(self):
self.padding_side = 'left'
self.pad_token_id = 0
def __call__(self, text, padding=None, max_length=None, return_tensors=None, truncation=None):
if isinstance(text, list):
batch_size = len(text)
else:
batch_size = 1
# Return a dict with input_ids and attention_mask
return {
'input_ids': torch.randint(1, 100, (batch_size, max_length or 10)),
'attention_mask': torch.ones(batch_size, max_length or 10, dtype=torch.long)
}
tokenizer = MockTokenizer()
tokenizer.padding_side = 'left'
examples = {
'input': ['hello world', 'foo bar'],
'label': ['world hello', 'bar foo'],
'extra_input_field': ['extra text one', 'extra text two'],
'extra_label_field': ['label extra one', 'label extra two']
}
max_input_length = 10
max_output_length = 8
input_feature = 'input'
label_feature = 'label'
extra_input_to_tokenize = ['extra_input_field']
extra_label_to_tokenize = ['extra_label_field']
ARGS = {
'tokenizer': tokenizer,
'max_input_length': max_input_length,
'max_output_length': max_output_length,
'examples': examples,
'input_feature': input_feature,
'label_feature': label_feature,
'extra_input_to_tokenize': extra_input_to_tokenize,
'extra_label_to_tokenize': extra_label_to_tokenize
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- torch, transformers — 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_invalid_token_id |
Ran ran; our contract draft was wrong, not the code |
explanare/ravel/src/utils/intervention_utils.py code served (permissive licence) · get_code("fe8f9421a66f408f") 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
torch.manual_seed(0)
# Create a small tensor with some -100 values (invalid token ids)
token_ids = torch.tensor([
[1, -100, 3, 4],
[5, 6, -100, 8]
], dtype=torch.long)
pad_id = 2
ARGS = {
"token_ids": token_ids,
"pad_id": pad_id
}
- 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
|
| select_features_with_classifier |
Ran ran; our contract draft was wrong, not the code |
explanare/ravel/src/methods/select_features.py code served (permissive licence) · get_code("be76384e0b33672a") 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 as nn
import numpy as np
from sklearn.svm import LinearSVC
from sklearn.feature_selection import SelectFromModel
torch.manual_seed(0)
# Create a simple featurizer that transforms inputs to a feature space
class SimpleFeaturizer(nn.Module):
def __init__(self, input_dim, output_dim):
super().__init__()
self.linear = nn.Linear(input_dim, output_dim)
def forward(self, x):
return self.linear(x)
# Build minimal valid arguments
featurizer = SimpleFeaturizer(input_dim=3, output_dim=8)
# Create small batch of inputs: shape (2, 3) - batch of 2, 3 features
inputs = torch.randn(2, 3)
# Create labels for binary classification: shape (2,)
labels = np.array([0, 1])
# coeff will use default if not provided, but we can also pass None explicitly
coeff = None
ARGS = {
"featurizer": featurizer,
"inputs": inputs,
"labels": labels,
"coeff": coeff
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- numpy, sklearn, 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
|
| gen_context_test_split |
Not yet run unverified (harvested, no recorded run) |
explanare/ravel/src/utils/generate_ravel_instance.py code served (permissive licence) · get_code("8240c646692f8698") How it ran |
| gen_entity_test_split |
Not yet run unverified (harvested, no recorded run) |
explanare/ravel/src/utils/generate_ravel_instance.py code served (permissive licence) · get_code("58779741197dded2") How it ran |
| gen_train_split |
Not yet run unverified (harvested, no recorded run) |
explanare/ravel/src/utils/generate_ravel_instance.py code served (permissive licence) · get_code("8289a1e4195d682d") How it ran |
| symmetric |
Not yet run unverified (harvested, no recorded run) |
explanare/ravel/src/methods/linear_adversarial_probe.py pointer only (licence: MIT); the stored copy get_code serves, from shauli-ravfogel/rlace-icml, is pointer only (licence: NONE) · get_code("5eb6f7201a4d2f1c") How it ranThe body of this sample is withheld: this paper's link allows the body inline (MIT), but get_code serves the stored copy, first harvested from shauli-ravfogel/rlace-icml, and GitHub detected no licence in that repository when it was checked. The setup block that called it is withheld with it, because it is written against that body. source_path and origin say where the code lives, to read under the repository's own terms. No invocation recorded. |
| train_intervention_step |
Not yet run unverified (harvested, no recorded run) |
explanare/ravel/src/utils/intervention_utils.py code served (permissive licence) · get_code("01750c9c0ff161d4") How it ran |