| annealed_alpha |
Ran ran, honoured the contract we drafted |
VectorInstitute/odyssey/odyssey/models/concept_bottleneck.py code served (permissive licence) · get_code("652cb2ddc9a741b5") How it ranRan in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned float, ndim 0, dtype family float, shape () as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import math
torch_seed = 0
ARGS = {
"step": 1000,
"anneal_steps": 10000,
"start": 0.1,
"end": 0.9,
"cosine": False,
}
- 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 float, ndim 0, dtype family float, shape () — shape () as a later run recorded it
- dtype family
- int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
- Environment
- image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
|
| best_scorer_per_cell |
Ran ran; our contract draft was wrong, not the code |
VectorInstitute/odyssey/odyssey/inference/model_comparison.py code served (permissive licence) · get_code("9cc15076d0a08f28") 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.
from collections.abc import Sequence
from dataclasses import dataclass
@dataclass(frozen=True)
class ScorerAUROC:
"""One (event, horizon, scorer[, stratum]) AUROC cell."""
event: str
horizon_hours: float
scorer: str
stratum: str
n: int
n_positive: int
auroc: float | None
# Create test data with various AUROC values and strata
rows = [
ScorerAUROC(event="mortality", horizon_hours=24.0, scorer="model_a", stratum="all", n=100, n_positive=30, auroc=0.85),
ScorerAUROC(event="mortality", horizon_hours=24.0, scorer="model_b", stratum="all", n=100, n_positive=30, auroc=0.82),
ScorerAUROC(event="mortality", horizon_hours=24.0, scorer="model_c", stratum="all", n=100, n_positive=30, auroc=None),
ScorerAUROC(event="readmission", horizon_hours=48.0, scorer="model_a", stratum="all", n=150, n_positive=45, auroc=0.78),
ScorerAUROC(event="readmission", horizon_hours=48.0, scorer="model_b", stratum="all", n=150, n_positive=45, auroc=0.81),
ScorerAUROC(event="mortality", horizon_hours=24.0, scorer="model_a", stratum="icu", n=50, n_positive=20, auroc=0.88),
ScorerAUROC(event="mortality", horizon_hours=24.0, scorer="model_b", stratum="icu", n=50, n_positive=20, auroc=0.80),
ScorerAUROC(event="empty_cell", horizon_hours=72.0, scorer="model_a", stratum="all", n=10, n_positive=1, auroc=None),
ScorerAUROC(event="empty_cell", horizon_hours=72.0, scorer="model_b", stratum="all", n=10, n_positive=1, auroc=None),
]
ARGS = {
"rows": rows,
"stratum": "all",
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- none outside the standard library — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type dict — a dict output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a dict output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not stated
- Environment
- image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
|
| censored_hazard_log_likelihood |
Ran ran; our contract draft was wrong, not the code |
VectorInstitute/odyssey/odyssey/models/time_to_event.py code served (permissive licence) · get_code("2407e51f7377ab2c") 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
import torch.nn.functional as F
torch.manual_seed(0)
# Create small tensors for testing
batch_size = 2
num_bins = 4
# hazard_logits: shape (batch_size, num_bins)
hazard_logits = torch.randn(batch_size, num_bins)
# target_bin: shape (batch_size,) with values in range [0, num_bins)
target_bin = torch.tensor([1, 2], dtype=torch.long)
# observed: shape (batch_size,) boolean tensor
observed = torch.tensor([True, False], dtype=torch.bool)
ARGS = {
"hazard_logits": hazard_logits,
"target_bin": target_bin,
"observed": observed,
}
- 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
|
| concept_loss |
Ran ran; our contract draft was wrong, not the code |
VectorInstitute/odyssey/odyssey/models/concept_bottleneck.py code served (permissive licence) · get_code("b040d3186985f9cd") 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.functional as F
torch.manual_seed(0)
# Define small tensors for testing
batch_size = 2
num_concepts = 4
# concept_logits: shape (batch_size, num_concepts) - raw model outputs
concept_logits = torch.randn(batch_size, num_concepts)
# concept_labels: shape (batch_size, num_concepts) - binary labels (0 or 1)
concept_labels = torch.randint(0, 2, (batch_size, num_concepts))
# concept_mask: shape (batch_size, num_concepts) - 1 = observed, 0 = unobserved
concept_mask = torch.randint(0, 2, (batch_size, num_concepts))
# pos_weight: shape (num_concepts,) - positive class weight per concept
pos_weight = torch.tensor([2.0, 3.0, 1.5, 2.5])
ARGS = {
"concept_logits": concept_logits,
"concept_labels": concept_labels,
"concept_mask": concept_mask,
"pos_weight": pos_weight,
}
- 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
|
| gap_to_bin |
Ran ran; our contract draft was wrong, not the code |
VectorInstitute/odyssey/odyssey/models/time_to_event.py code served (permissive licence) · get_code("20e5b21ec781dd3a") 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 int, shape (5,) as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import torch
torch.manual_seed(0)
# gap_to_bin takes:
# 1. gap_hours: torch.Tensor - a tensor of non-negative gap values in hours
# 2. edges: Sequence[float] - a sequence of bin edge boundaries
# Create a small tensor of gap hours (non-negative values)
gap_hours = torch.tensor([0.0, 1.5, 3.0, 5.5, 10.0], dtype=torch.float32)
# Create a sequence of edges (bin boundaries)
edges = [2.0, 4.0, 8.0]
ARGS = {
"gap_hours": gap_hours,
"edges": edges,
}
- 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 int, shape (5,) — shape (5,) as a later run recorded it
- dtype family
- int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
- Environment
- image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
|
| hazard_log_likelihood |
Ran ran; our contract draft was wrong, not the code |
VectorInstitute/odyssey/odyssey/models/time_to_event.py code served (permissive licence) · get_code("fa134ddfdde7b9ed") 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
import torch.nn.functional as F
torch.manual_seed(0)
# Construct arguments for hazard_log_likelihood
# The function expects:
# - hazard_logits: shape (..., num_bins)
# - target_bin: shape (...) long tensor with values < num_bins
batch_size = 2
num_bins = 4
# Create hazard_logits with shape (2, 4)
hazard_logits = torch.randn(batch_size, num_bins)
# Create target_bin with shape (2,) containing valid bin indices
target_bin = torch.tensor([1, 3], dtype=torch.long)
ARGS = {
"hazard_logits": hazard_logits,
"target_bin": target_bin,
}
- 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
|
| intervention_apply_mask |
Ran ran; our contract draft was wrong, not the code |
VectorInstitute/odyssey/odyssey/models/concept_bottleneck.py code served (permissive licence) · get_code("1257aeb0e0ca5e64") How it ranRan in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned Tensor, ndim 2, dtype family float, shape (2, 4) as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import torch
from dataclasses import dataclass
@dataclass(frozen=True)
class BottleneckIntervention:
"""A do()-style edit applied inside the bottleneck's mixing step."""
probs: torch.Tensor | None = None
probs_mask: torch.Tensor | None = None
uncertain_band: float | None = None
zero_known: bool = False
zero_unknown: bool = False
zero_residual: bool = False
def intervention_apply_mask(intervention: BottleneckIntervention, own_probs: torch.Tensor) -> torch.Tensor | None:
"""Where an intervention's ``probs`` actually replace the model's own."""
apply: torch.Tensor | None = None
if intervention.probs_mask is not None:
apply = intervention.probs_mask.expand_as(own_probs)
if intervention.uncertain_band is not None:
band = (own_probs - 0.5).abs() < intervention.uncertain_band
apply = band if apply is None else apply & band
return apply
torch.manual_seed(0)
# Create test tensors
own_probs_tensor = torch.rand(2, 4) # batch=2, num_concepts=4
# Case 1: Both probs_mask and uncertain_band set
probs_mask_tensor = torch.ones(2, 4, dtype=torch.bool)
intervention_1 = BottleneckIntervention(
probs=torch.rand(2, 4),
probs_mask=probs_mask_tensor,
uncertain_band=0.2,
zero_known=False,
zero_unknown=False,
zero_residual=False
)
ARGS = {
"intervention": intervention_1,
"own_probs": own_probs_tensor
}
- 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
|
| middle_layer |
Ran ran, honoured the contract we drafted |
VectorInstitute/odyssey/odyssey/models/injection.py code served (permissive licence) · get_code("37d5d57f4239c77d") How it ranRan in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned int, ndim 0, dtype family int, shape () as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import torch
import torch.nn as nn
torch.manual_seed(0)
class SimpleBackbone(nn.Module):
def __init__(self, num_layers=4):
super().__init__()
self.layers = nn.ModuleList([
nn.Linear(4, 4) for _ in range(num_layers)
])
def forward(self, x):
for layer in self.layers:
x = layer(x)
return x
backbone = SimpleBackbone(num_layers=4)
ARGS = {
'backbone': backbone
}
- 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
|
| pinball_loss |
Ran ran; our contract draft was wrong, not the code |
VectorInstitute/odyssey/odyssey/models/value_head.py code served (permissive licence) · get_code("ab16e79712613f58") 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 small tensors with distinct dimensions
# quantiles: shape (batch=2, num_quantiles=4)
quantiles = torch.randn(2, 4)
# target: shape (batch=2,) - will be unsqueezed to (2, 1) to broadcast against quantiles
target = torch.randn(2)
# levels: sequence of quantile levels (tau values)
levels = [0.25, 0.5, 0.75, 0.9]
ARGS = {
"quantiles": quantiles,
"target": target,
"levels": levels,
}
- 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
|
| select_diverse_cases |
Ran ran, honoured the contract we drafted |
VectorInstitute/odyssey/odyssey/inference/case_study.py code served (permissive licence) · get_code("20f21b3aa186f2d8") How it ranRan in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned list, ndim 1, dtype family 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 torch
import polars as pl
import random
torch.manual_seed(0)
random.seed(0)
# Create a sample events DataFrame with subject_id and other columns
events = pl.DataFrame({
'subject_id': [1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 3, 4, 4, 5, 5, 5, 5, 5, 5],
'event_type': ['A', 'B', 'C', 'A', 'B', 'C', 'D', 'A', 'B', 'C', 'D', 'E', 'A', 'B', 'A', 'B', 'C', 'D', 'E', 'F'],
})
# Create concept_labels dict with tensors
# Each subject has a tensor of concept labels (binary or count)
concept_labels = {
1: torch.tensor([1, 0, 1, 0], dtype=torch.float32), # 2 concepts triggered
2: torch.tensor([1, 1, 1, 0], dtype=torch.float32), # 3 concepts triggered
3: torch.tensor([0, 0, 0, 0], dtype=torch.float32), # 0 concepts triggered
4: torch.tensor([1, 0, 0, 0], dtype=torch.float32), # 1 concept triggered
5: torch.tensor([1, 1, 0, 0], dtype=torch.float32), # 2 concepts triggered
}
ARGS = {
'events': events,
'concept_labels': concept_labels,
'n_cases': 3,
'min_events': 2,
'seed': 42,
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- polars, torch — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type list, ndim 1, dtype family int — 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
|
| stream_injection |
Ran ran; our contract draft was wrong, not the code |
VectorInstitute/odyssey/odyssey/models/injection.py code served (permissive licence) · get_code("04ebfb65c3483398") 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 _GeneratorContextManager. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import torch
import torch.nn as nn
torch.manual_seed(0)
# Create a simple block-structured backbone with a layers attribute
class SimpleBlock(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)
class BlockBackbone(nn.Module):
def __init__(self, num_layers=3, hidden_dim=4):
super().__init__()
self.layers = nn.ModuleList([
SimpleBlock(hidden_dim, hidden_dim) for _ in range(num_layers)
])
def forward(self, x):
for layer in self.layers:
x = layer(x)
return x
# Construct the arguments
backbone = BlockBackbone(num_layers=3, hidden_dim=4)
layer_index = 1
vector = torch.randn(4) # Shape (d,) where d=4
ARGS = {
"backbone": backbone,
"layer_index": layer_index,
"vector": vector,
}
- 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 _GeneratorContextManager — a _GeneratorContextManager output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a _GeneratorContextManager 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
|
| value_features |
Ran ran; our contract draft was wrong, not the code |
VectorInstitute/odyssey/odyssey/models/embeddings.py code served (permissive licence) · get_code("816376e6520ac858") 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 4, dtype family float, shape (2, 4, 3, 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)
# Construct test values tensor with shape (..., 3)
# Using a batch of 2 samples with 4 features each, resulting in (..., 3) compatibility
# The function expects values to potentially contain NaN and work with any shape ending in a dimension
values = torch.tensor([
[[1.0, 2.0, 3.0],
[4.0, 5.0, 6.0],
[7.0, 8.0, 9.0],
[10.0, 11.0, 12.0]],
[[float('nan'), 2.5, 3.5],
[4.5, float('nan'), 6.5],
[7.5, 8.5, float('nan')],
[10.5, 11.5, 12.5]]
], dtype=torch.float32)
ARGS = {
"values": values
}
- 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 4, dtype family float, shape (2, 4, 3, 3) — shape (2, 4, 3, 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
|
| value_quantile_loss |
Ran ran; our contract draft was wrong, not the code |
VectorInstitute/odyssey/odyssey/models/value_head.py code served (permissive licence) · get_code("0a2999efd7fc3d1b") 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
from collections.abc import Sequence
torch.manual_seed(0)
# Construct tensors for the function
# quantiles: shape (..., K) where K is the number of quantile levels
# Let's use shape (2, 3, 4) where batch=2, some intermediate dim=3, quantiles=4
quantiles = torch.randn(2, 3, 4)
# target: shape (...) that broadcasts against quantiles' last dimension
# Should have shape (2, 3) to broadcast with (2, 3, 4)
target = torch.randn(2, 3)
# valid: boolean mask with same shape as target
# Shape (2, 3) to match target
valid = torch.randint(0, 2, (2, 3), dtype=torch.bool)
# levels: sequence of floats representing quantile levels
# Must have length matching the last dimension of quantiles (4 in this case)
levels = [0.25, 0.5, 0.75, 0.95]
ARGS = {
"quantiles": quantiles,
"target": target,
"valid": valid,
"levels": levels,
}
- 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
|
| value_target_valid_mask |
Ran ran; our contract draft was wrong, not the code |
VectorInstitute/odyssey/odyssey/models/value_head.py code served (permissive licence) · get_code("ab2ebe14caf34af0") 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 3, dtype family float; no output shape is stated. The image it ran in was not recorded. If your copy returns the same type and ndim on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import torch
torch.manual_seed(0)
# Create small test tensors
# values: (lanes, T) - standardized values, already shifted
# real_mask: (lanes, T) - boolean mask indicating real tokens
lanes = 2
T = 4
values = torch.randn(lanes, T)
# Set some values to NaN to test the isnan logic
values[0, 2] = float('nan')
real_mask = torch.tensor([
[True, True, False, True],
[True, True, True, False]
], dtype=torch.bool)
ARGS = {
"values": values,
"real_mask": real_mask,
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- torch — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type tuple, ndim 3, 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
|