| ClassHead |
Ran ran on a synthesized input |
Oppenheimerdinger/T1/models/T1.py code served (permissive licence) · get_code("5cbf305b5e20f778") How it ranRan in Syntology's sandbox on this synthesized input (drafted by a language model, class construct-then-call prompt, model not recorded) and returned Tensor, ndim 2, dtype family float, shape (2, 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
import torch.nn as nn
class Swish(nn.Module):
def forward(self, x):
return x * torch.sigmoid(x)
class ClassHead(nn.Module):
def __init__(self, cfg, T_out: int):
super().__init__()
input_features_to_linear = cfg.enc_in * cfg.n_heads
proj_dim = cfg.projection_head_dim
self.projection = nn.Linear(input_features_to_linear, proj_dim)
self.activation = Swish()
self.norm = nn.LayerNorm(proj_dim)
self.dropout = nn.Dropout(cfg.drop_head)
self.linear = nn.Linear(proj_dim, cfg.num_class)
self.final_pool_type = getattr(cfg, 'final_pool_type', 'gap').lower()
if self.final_pool_type == 'gap':
self.final_pool = lambda x: x.mean(dim=1)
elif self.final_pool_type == 'maxpool':
self.final_pool = lambda x: torch.max(x, dim=1).values
else:
raise ValueError(f"Unsupported final pooling type: {self.final_pool_type}. Choose 'gap' or 'maxpool'.")
def forward(self, x):
B, M, H, T = x.shape
x = x.reshape(B, M * H, T)
x = self.projection(x.transpose(1, 2))
x = self.activation(x)
x = self.final_pool(x)
x = self.norm(x)
x = self.dropout(x)
x = self.linear(x)
return x
class Config:
def __init__(self):
self.enc_in = 4
self.n_heads = 3
self.projection_head_dim = 8
self.drop_head = 0.1
self.num_class = 5
self.final_pool_type = 'gap'
cfg = Config()
INIT_ARGS = {
'cfg': cfg,
'T_out': 16
}
ARGS = {
'x': torch.randn(2, 3, 4, 16)
}
if __name__ == '__main__':
model = ClassHead(**INIT_ARGS)
output = model(**ARGS)
print(f"Output shape: {output.shape}")
print(f"Output: {output}")
- Setup block drafted by
- a language model, class construct-then-call prompt, model not recorded
- 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, 5) — shape (2, 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: torch and numpy seeded to 0 by the harness immediately before the class was constructed from INIT_ARGS (fixture_check.py)
|
| DepthwiseMix |
Ran ran on a synthesized input |
Oppenheimerdinger/T1/models/T1.py code served (permissive licence) · get_code("a7ba430d1c90ac52") How it ranRan in Syntology's sandbox on this synthesized input (drafted by a language model, class construct-then-call prompt, model not recorded) and returned Tensor, ndim 3, dtype family float; no output shape is stated. The image it ran in was not recorded. If your copy returns the same type and ndim on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import torch
import torch.nn as nn
# INIT_ARGS: parameters for DepthwiseMix.__init__
INIT_ARGS = {
'Cin': 6,
'Cout': 6,
'kL': 5,
'kS': 3,
'bias': True
}
# ARGS: parameters for DepthwiseMix.forward
# Input shape: (batch, Cin, sequence_length)
ARGS = {
'x': torch.randn(2, 6, 8)
}
- Setup block drafted by
- a language model, class construct-then-call prompt, model not recorded
- 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 float — no output shape is stated: observe_signature.py observed this class with its constructor sizes canonicalised where it could, which the node does not record, so its shape is not stated as this setup block's
- 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: torch and numpy seeded to 0 by the harness immediately before the class was constructed from INIT_ARGS (fixture_check.py)
|
| DownSample |
Ran ran on a synthesized input |
Oppenheimerdinger/T1/models/T1.py code served (permissive licence) · get_code("f94921018ed8273d") How it ranRan in Syntology's sandbox on this synthesized input (drafted by a language model, class construct-then-call prompt, model not recorded) 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
def ceil_div(a: int, b: int) -> int:
"""Ceiling division: returns ⌈a/b⌉"""
return (a + b - 1) // b
class DownSample(nn.Module):
def __init__(self, k: int, s: int, C: int):
super().__init__()
self.k, self.s = (k, s)
self.dw = nn.Conv1d(C, C, k, s, groups=C)
def forward(self, x, *args):
B, M, C, T = x.shape
out_len = ceil_div(T, self.s)
total_len_needed = (out_len - 1) * self.s + self.k
pad = max(0, total_len_needed - T)
if pad:
x = torch.cat([x[..., -1:].repeat(1, 1, 1, pad), x], -1)
x = self.dw(x.reshape(B * M, C, -1))
return (x.reshape(B, M, C, x.size(-1)),) + args
INIT_ARGS = {
'k': 3,
's': 2,
'C': 4,
}
ARGS = {
'x': torch.randn(2, 3, 4, 8),
}
if __name__ == '__main__':
model = DownSample(**INIT_ARGS)
output = model(**ARGS)
print("Output shape:", output[0].shape)
print("Output type:", type(output))
- Setup block drafted by
- a language model, class construct-then-call prompt, model not recorded
- 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: torch and numpy seeded to 0 by the harness immediately before the class was constructed from INIT_ARGS (fixture_check.py)
|
| DropPath |
Ran ran on a synthesized input |
Oppenheimerdinger/T1/models/T1.py code served (permissive licence) · get_code("96592475595fbed1") How it ranRan in Syntology's sandbox on this synthesized input (drafted by a language model, class construct-then-call prompt, model not recorded) and returned Tensor, ndim 4, dtype family float, shape (2, 4, 3, 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
import torch.nn as nn
class DropPath(nn.Module):
def __init__(self, drop_prob: float):
super().__init__()
self.drop_prob = drop_prob
def forward(self, x):
if not self.training or self.drop_prob == 0.0:
return x
keep_prob = 1 - self.drop_prob
random_tensor = keep_prob + torch.rand(x.shape[0], 1, 1, 1, device=x.device, dtype=x.dtype)
random_tensor.floor_()
return x.div(keep_prob) * random_tensor
INIT_ARGS = {
'drop_prob': 0.2
}
ARGS = {
'x': torch.randn(2, 4, 3, 5)
}
if __name__ == '__main__':
model = DropPath(**INIT_ARGS)
model.train()
output = model(**ARGS)
print(f"Input shape: {ARGS['x'].shape}")
print(f"Output shape: {output.shape}")
print(f"Output:\n{output}")
- Setup block drafted by
- a language model, class construct-then-call prompt, model not recorded
- 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, 5) — shape (2, 4, 3, 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: torch and numpy seeded to 0 by the harness immediately before the class was constructed from INIT_ARGS (fixture_check.py)
|
| FeedForward |
Ran ran on a synthesized input |
Oppenheimerdinger/T1/models/T1.py code served (permissive licence) · get_code("07ced2912044bc6c") How it ranRan in Syntology's sandbox on this synthesized input (drafted by a language model, class construct-then-call prompt, model not recorded) and returned Tensor, ndim 4, 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
class Config:
def __init__(self):
self.ffn_ratio = 2.0
self.drop_ffn = 0.1
cfg = Config()
H = 8
INIT_ARGS = {
'cfg': cfg,
'H': H
}
B = 2
M = 3
T = 5
x = torch.randn(B, M, H, T)
ARGS = {
'x': x
}
- Setup block drafted by
- a language model, class construct-then-call prompt, model not recorded
- 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 — no output shape is stated: observe_signature.py observed this class with its constructor sizes canonicalised where it could, which the node does not record, so its shape is not stated as this setup block's
- 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: torch and numpy seeded to 0 by the harness immediately before the class was constructed from INIT_ARGS (fixture_check.py)
|
| ForecastHead |
Ran ran on a synthesized input |
Oppenheimerdinger/T1/models/T1.py code served (permissive licence) · get_code("9f7cbb589c1b7f85") How it ranRan in Syntology's sandbox on this synthesized input (drafted by a language model, class construct-then-call prompt, model not recorded) and returned Tensor, ndim 3, dtype family float; no output shape is stated. The image it ran in was not recorded. If your copy returns the same type and ndim on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import torch
import torch.nn as nn
class Config:
def __init__(self):
self.n_heads = 8
self.projection_head_dim = 16
self.pred_len = 12
self.drop_head = 0.1
cfg = Config()
T_out = 5
INIT_ARGS = {
'cfg': cfg,
'T_out': T_out,
}
ARGS = {
'x': torch.randn(2, 3, 8, 5),
}
- Setup block drafted by
- a language model, class construct-then-call prompt, model not recorded
- 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 float — no output shape is stated: observe_signature.py observed this class with its constructor sizes canonicalised where it could, which the node does not record, so its shape is not stated as this setup block's
- 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: torch and numpy seeded to 0 by the harness immediately before the class was constructed from INIT_ARGS (fixture_check.py)
|
| FrontPadding |
Ran ran on a synthesized input |
Oppenheimerdinger/T1/models/T1.py code served (permissive licence) · get_code("e1d41609713d2902") How it ranRan in Syntology's sandbox on this synthesized input (drafted by a language model, class construct-then-call prompt, model not recorded) and returned Tensor, ndim 3, dtype family float, shape (2, 3, 18) 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
def ceil_div(a: int, b: int) -> int:
"""Ceiling division: returns ⌈a/b⌉"""
return (a + b - 1) // b
class FrontPadding(nn.Module):
def __init__(self, patch_size: int, stride: int):
super().__init__()
self.k, self.s = (patch_size, stride)
def forward(self, x):
T = x.size(-1)
out_len = ceil_div(T, self.s)
total_len_needed = (out_len - 1) * self.s + self.k
pad = max(0, total_len_needed - T)
if pad == 0:
return x
return torch.cat([x[..., -1:].repeat(*(1,) * (x.dim() - 1), pad), x], dim=-1)
INIT_ARGS = {
'patch_size': 4,
'stride': 2,
}
ARGS = {
'x': torch.randn(2, 3, 16),
}
if __name__ == '__main__':
model = FrontPadding(**INIT_ARGS)
output = model(**ARGS)
print(f"Input shape: {ARGS['x'].shape}")
print(f"Output shape: {output.shape}")
print(f"Output:\n{output}")
- Setup block drafted by
- a language model, class construct-then-call prompt, model not recorded
- 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 float, shape (2, 3, 18) — shape (2, 3, 18) 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: torch and numpy seeded to 0 by the harness immediately before the class was constructed from INIT_ARGS (fixture_check.py)
|
| PixelShuffle1D |
Ran ran on a synthesized input |
Oppenheimerdinger/T1/models/T1.py code served (permissive licence) · get_code("19f9640048c6b72c") How it ranRan in Syntology's sandbox on this synthesized input (drafted by a language model, class construct-then-call prompt, model not recorded) and returned Tensor, ndim 3, dtype family float, shape (2, 2, 6) 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
class PixelShuffle1D(nn.Module):
def __init__(self, r: int):
super().__init__()
self.r = r
def forward(self, x):
B, C, L = x.shape
assert C % self.r == 0
out = x.reshape(B, C // self.r, self.r, L).permute(0, 1, 3, 2)
return out.reshape(B, C // self.r, L * self.r)
INIT_ARGS = {
'r': 2
}
ARGS = {
'x': torch.randn(2, 4, 3)
}
if __name__ == '__main__':
module = PixelShuffle1D(**INIT_ARGS)
output = module(**ARGS)
print(f"Input shape: {ARGS['x'].shape}")
print(f"Output shape: {output.shape}")
- Setup block drafted by
- a language model, class construct-then-call prompt, model not recorded
- 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 float, shape (2, 2, 6) — shape (2, 2, 6) 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: torch and numpy seeded to 0 by the harness immediately before the class was constructed from INIT_ARGS (fixture_check.py)
|
| ReconHead |
Ran ran on a synthesized input |
Oppenheimerdinger/T1/models/T1.py code served (permissive licence) · get_code("d73ba875476c7a57") How it ranRan in Syntology's sandbox on this synthesized input (drafted by a language model, class construct-then-call prompt, model not recorded) and returned Tensor, ndim 3, dtype family float, shape (2, 3, 12) 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
# Define a minimal config object
class Config:
def __init__(self):
self.seq_len = 8
self.pred_len = 4
self.task_name = 'forecast'
self.n_heads = 4
self.bottle_neck_n_heads = 0
self.head_params_shared = True
self.drop_head = 0.1
INIT_ARGS = {
'cfg': Config(),
'T_out': 3
}
# For forward pass: B=2, M=3, H=4, T=3
# x shape should be (B, M, H, T) = (2, 3, 4, 3)
ARGS = {
'x': torch.randn(2, 3, 4, 3)
}
# Construct and call
if __name__ == '__main__':
# Import the classes (they would be defined above in actual use)
def ceil_div(a: int, b: int) -> int:
return (a + b - 1) // b
class PixelShuffle1D(nn.Module):
def __init__(self, r: int):
super().__init__()
self.r = r
def forward(self, x):
B, C, L = x.shape
assert C % self.r == 0
out = x.reshape(B, C // self.r, self.r, L).permute(0, 1, 3, 2)
return out.reshape(B, C // self.r, L * self.r)
class ReconHead(nn.Module):
def __init__(self, cfg, T_out: int):
super().__init__()
self.pred_len = cfg.seq_len + cfg.pred_len if cfg.task_name.endswith('forecast') else cfg.pred_len
bottle_neck_n_heads = getattr(cfg, 'bottle_neck_n_heads', 0)
if bottle_neck_n_heads > 0 and cfg.task_name == 'anomaly_detection':
self.use_bottleneck = True
self.bottleneck_dim = bottle_neck_n_heads
self.proj_down = nn.Conv1d(cfg.n_heads, self.bottleneck_dim, 1)
self.proj_up = nn.Conv1d(self.bottleneck_dim, cfg.n_heads, 1)
else:
self.use_bottleneck = False
self.up = ceil_div(self.pred_len, T_out)
self.adjusted_channels = (cfg.n_heads + self.up - 1) // self.up * self.up
self.channel_adjust = nn.Conv1d(cfg.n_heads, self.adjusted_channels, 1)
self.ps = PixelShuffle1D(self.up)
self.ps_output_len = T_out * self.up
outC = self.adjusted_channels // self.up
self.proj = nn.Linear(outC, 1) if cfg.head_params_shared else nn.Conv1d(self.pred_len, self.pred_len, kernel_size=outC, groups=self.pred_len)
self.dp = nn.Dropout(cfg.drop_head)
def forward(self, x):
B, M, H, T = x.shape
if self.use_bottleneck:
x = x.reshape(B * M, H, T)
x = self.proj_down(x)
x = self.proj_up(x)
x = x.reshape(B, M, H, T)
x = x.reshape(B * M, H, T)
x = self.channel_adjust(x)
y = self.ps(x.reshape(B, M * self.adjusted_channels, T)).reshape(B * M, self.adjusted_channels // self.up, self.ps_output_len)
if self.ps_output_len > self.pred_len:
crop_start = (self.ps_output_len - self.pred_len) // 2
y = y[..., crop_start:crop_start + self.pred_len]
y = y.transpose(1, 2)
return self.dp(self.proj(y)).reshape(B, M, self.pred_len)
model = ReconHead(**INIT_ARGS)
output = model(**ARGS)
print(f"Output shape: {output.shape}")
print(f"Expected shape: (2, 3, 12)")
- Setup block drafted by
- a language model, class construct-then-call prompt, model not recorded
- 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 float, shape (2, 3, 12) — shape (2, 3, 12) 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: torch and numpy seeded to 0 by the harness immediately before the class was constructed from INIT_ARGS (fixture_check.py)
|
| SACAReparameterization |
Ran ran on a synthesized input |
Oppenheimerdinger/T1/models/T1.py code served (permissive licence) · get_code("41c00d62d64041ca") How it ranRan in Syntology's sandbox on this synthesized input (drafted by a language model, class construct-then-call prompt, model not recorded) and returned Tensor, ndim 4, 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
INIT_ARGS = {
'enc_in': 5,
'n_heads': 3,
'mode': 1,
'hidden_dim': 8,
'drop_rate': 0.1,
'param_type': 'sig'
}
ARGS = {
'stats': torch.randn(2, 1, 5),
'param_type': 'sig'
}
- Setup block drafted by
- a language model, class construct-then-call prompt, model not recorded
- 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 — no output shape is stated: observe_signature.py observed this class with its constructor sizes canonicalised where it could, which the node does not record, so its shape is not stated as this setup block's
- 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: torch and numpy seeded to 0 by the harness immediately before the class was constructed from INIT_ARGS (fixture_check.py)
|
| _get_saca_output_dim |
Ran ran, honoured the contract we drafted |
Oppenheimerdinger/T1/models/T1.py code served (permissive licence) · get_code("56e1096dafc14aa2") How it ranRan in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1) 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)
# Construct arguments for _get_saca_output_dim
# The function takes: mode (int), enc_in (int), n_heads (int)
# and returns an int based on the mode
ARGS = {
"mode": 2,
"enc_in": 8,
"n_heads": 4,
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1
- 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
|
| _reshape_saca_param |
Ran ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT) |
Oppenheimerdinger/T1/models/T1.py code served (permissive licence) · get_code("d4aeff43548b65fc") How it ranRan in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1) and returned Tensor, ndim 4, dtype family float, shape (2, 4, 3, 1) 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)
# Test case 1: mode 0 with param
param_mode0 = torch.randn(2, 4)
mode_0 = 0
enc_in_0 = 4
n_heads_0 = 2
# Test case 2: mode 1 - reshape to [B, H, enc_in, 1]
param_mode1 = torch.randn(2, 12) # B=2, enc_in=3, n_heads=4, so 3*4=12
mode_1 = 1
enc_in_1 = 3
n_heads_1 = 4
# Test case 3: mode 2 - reshape to [B, 1, enc_in, 1]
param_mode2 = torch.randn(2, 3) # B=2, enc_in=3
mode_2 = 2
enc_in_2 = 3
n_heads_2 = 4
# Test case 4: mode 3 - reshape to [B, H, 1, 1]
param_mode3 = torch.randn(2, 4) # B=2, n_heads=4
mode_3 = 3
enc_in_3 = 3
n_heads_3 = 4
# Test case 5: mode 4 - reshape to [B, 1, 1, 1]
param_mode4 = torch.randn(2, 1) # B=2
mode_4 = 4
enc_in_4 = 3
n_heads_4 = 4
ARGS = {
"param": param_mode1,
"mode": mode_1,
"enc_in": enc_in_1,
"n_heads": n_heads_1
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1
- 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, 1) — shape (2, 4, 3, 1) 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
|
| ceil_div |
Ran ran, honoured the contract we drafted |
Oppenheimerdinger/T1/models/T1.py code served (permissive licence) · get_code("3f6428b8556da60f") 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
torch.manual_seed(0)
# ceil_div takes two integers and performs ceiling division
# We need to provide valid int arguments for both parameters
ARGS = {
"a": 10,
"b": 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 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
|
| compute_out_len |
Ran ran, honoured the contract we drafted |
Oppenheimerdinger/T1/models/T1.py code served (permissive licence) · get_code("e6816109da80f6af") How it ranRan in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1) 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
torch.manual_seed(0)
# The function compute_out_len takes three integer parameters: L, k, s
# L: input length
# k: kernel size
# s: stride
# The function computes ceiling division of L by s
ARGS = {
"L": 10,
"k": 3,
"s": 2
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1
- 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
|
| pick |
Ran ran; our contract draft was wrong, not the code |
Oppenheimerdinger/T1/models/T1.py code served (permissive licence) · get_code("5b15c79d1a0c3712") How it ranRan in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1) 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 numpy as np
torch.manual_seed(0)
# The function pick takes:
# - val: can be a list, tuple, or a scalar value
# - idx: an integer index
# It returns an int by either indexing into val (if it's a list/tuple) or converting val directly to int
# Test case 1: val is a list
val_list = [10, 20, 30, 40]
idx_value = 2
ARGS = {
"val": val_list,
"idx": idx_value
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1
- Imports
- numpy, 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
|
| Attention |
Not yet run unverified (harvested, no recorded run) |
Oppenheimerdinger/T1/models/T1.py code served (permissive licence) · get_code("a32c89a2966be2db") How it ran |
| Model |
Not yet run unverified (harvested, no recorded run) |
Oppenheimerdinger/T1/models/T1.py code served (permissive licence) · get_code("a2db8dfdfe40f459") How it ran |
| SACAModule |
Not yet run unverified (harvested, no recorded run) |
Oppenheimerdinger/T1/models/T1.py code served (permissive licence) · get_code("9a9342f7a853fe6c") How it ran |
| T1Block |
Not yet run unverified (harvested, no recorded run) |
Oppenheimerdinger/T1/models/T1.py code served (permissive licence) · get_code("213029c14c5f7221") How it ran |
| T1Stage |
Not yet run unverified (harvested, no recorded run) |
Oppenheimerdinger/T1/models/T1.py code served (permissive licence) · get_code("71e3f87d20e2922e") How it ran |