| ConvBlock |
Ran ran on a synthesized input · constructed an object; no result was computed |
VSainteuf/utae-paps/src/backbones/utae.py code served (permissive licence) · get_code("45da329fac60ca4d") 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 an instance of its own class, ConvBlock: the run constructed the object and did not call it, so no result was computed. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import torch
import torch.nn as nn
torch.manual_seed(0)
ARGS = {
'nkernels': [3, 16, 32],
'pad_value': None,
'norm': 'batch',
'last_relu': True,
'padding_mode': 'reflect',
}
- 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 ConvBlock — the run constructed an instance of its own class and did not call it; no shape is stated — the instrument coerces any output to an array; for a ConvBlock 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
|
| ConvLayer |
Ran ran on a synthesized input · constructed an object; no result was computed |
VSainteuf/utae-paps/src/backbones/utae.py code served (permissive licence) · get_code("e7e11ee365ea4bce") 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 an instance of its own class, ConvLayer: the run constructed the object and did not call it, so no result was computed. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import torch
import torch.nn as nn
torch.manual_seed(0)
ARGS = {
'nkernels': [3, 16, 32],
'norm': 'batch',
'k': 3,
's': 1,
'p': 1,
'n_groups': 4,
'last_relu': True,
'padding_mode': 'reflect'
}
- 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 ConvLayer — the run constructed an instance of its own class and did not call it; no shape is stated — the instrument coerces any output to an array; for a ConvLayer 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
|
| DownConvBlock |
Ran ran on a synthesized input · constructed an object; no result was computed |
VSainteuf/utae-paps/src/backbones/utae.py code served (permissive licence) · get_code("4a4104e4258a152b") 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 an instance of its own class, DownConvBlock: the run constructed the object and did not call it, so no result was computed. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import torch
import torch.nn as nn
torch.manual_seed(0)
ARGS = {
'd_in': 3,
'd_out': 16,
'k': 3,
's': 1,
'p': 1,
'pad_value': None,
'norm': 'batch',
'padding_mode': 'reflect'
}
- 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 DownConvBlock — the run constructed an instance of its own class and did not call it; no shape is stated — the instrument coerces any output to an array; for a DownConvBlock 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
|
| LTAE2d |
Ran ran on a synthesized input · constructed an object; no result was computed |
VSainteuf/utae-paps/src/backbones/utae.py code served (permissive licence) · get_code("0c52a14cf35ab27e") 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 an instance of its own class, LTAE2d: the run constructed the object and did not call it, so no result was computed. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import torch
import torch.nn as nn
import numpy as np
torch.manual_seed(0)
class ScaledDotProductAttention(nn.Module):
def __init__(self, temperature, attn_dropout=0.1):
super().__init__()
self.temperature = temperature
self.dropout = nn.Dropout(attn_dropout)
self.softmax = nn.Softmax(dim=2)
def forward(self, q, k, v, pad_mask=None, return_comp=False):
attn = torch.matmul(q.unsqueeze(1), k.transpose(1, 2))
attn = attn / self.temperature
if pad_mask is not None:
attn = attn.masked_fill(pad_mask.unsqueeze(1), -1000.0)
if return_comp:
comp = attn
attn = self.softmax(attn)
attn = self.dropout(attn)
output = torch.matmul(attn, v)
if return_comp:
return (output, attn, comp)
else:
return (output, attn)
class MultiHeadAttention(nn.Module):
def __init__(self, n_head, d_k, d_in):
super().__init__()
self.n_head = n_head
self.d_k = d_k
self.d_in = d_in
self.Q = nn.Parameter(torch.zeros((n_head, d_k))).requires_grad_(True)
nn.init.normal_(self.Q, mean=0, std=np.sqrt(2.0 / d_k))
self.fc1_k = nn.Linear(d_in, n_head * d_k)
nn.init.normal_(self.fc1_k.weight, mean=0, std=np.sqrt(2.0 / d_k))
self.attention = ScaledDotProductAttention(temperature=np.power(d_k, 0.5))
def forward(self, v, pad_mask=None, return_comp=False):
d_k, d_in, n_head = (self.d_k, self.d_in, self.n_head)
sz_b, seq_len, _ = v.size()
q = torch.stack([self.Q for _ in range(sz_b)], dim=1).view(-1, d_k)
k = self.fc1_k(v).view(sz_b, seq_len, n_head, d_k)
k = k.permute(2, 0, 1, 3).contiguous().view(-1, seq_len, d_k)
if pad_mask is not None:
pad_mask = pad_mask.repeat((n_head, 1))
v = torch.stack(v.split(v.shape[-1] // n_head, dim=-1)).view(n_head * sz_b, seq_len, -1)
if return_comp:
output, attn, comp = self.attention(q, k, v, pad_mask=pad_mask, return_comp=return_comp)
else:
output, attn = self.attention(q, k, v, pad_mask=pad_mask, return_comp=return_comp)
attn = attn.view(n_head, sz_b, 1, seq_len)
attn = attn.squeeze(dim=2)
output = output.view(n_head, sz_b, 1, d_in // n_head)
output = output.squeeze(dim=2)
if return_comp:
return (output, attn, comp)
else:
return (output, attn)
class PositionalEncoder(nn.Module):
def __init__(self, d, T=1000, repeat=None, offset=0):
super(PositionalEncoder, self).__init__()
self.d = d
self.T = T
self.repeat = repeat
self.denom = torch.pow(T, 2 * (torch.arange(offset, offset + d).float() // 2) / d)
self.updated_location = False
def forward(self, batch_positions):
if not self.updated_location:
self.denom = self.denom.to(batch_positions.device)
self.updated_location = True
sinusoid_table = batch_positions[:, :, None] / self.denom[None, None, :]
sinusoid_table[:, :, 0::2] = torch.sin(sinusoid_table[:, :, 0::2])
sinusoid_table[:, :, 1::2] = torch.cos(sinusoid_table[:, :, 1::2])
if self.repeat is not None:
sinusoid_table = torch.cat([sinusoid_table for _ in range(self.repeat)], dim=-1)
return sinusoid_table
ARGS = {
"in_channels": 128,
"n_head": 4,
"d_k": 8,
"mlp": [64, 32],
"dropout": 0.2,
"d_model": 64,
"T": 1000,
"return_att": False,
"positional_encoding": True
}
- 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 LTAE2d — the run constructed an instance of its own class and did not call it; no shape is stated — the instrument coerces any output to an array; for a LTAE2d 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
|
| MultiHeadAttention |
Ran ran on a synthesized input · constructed an object; no result was computed |
VSainteuf/utae-paps/src/backbones/utae.py code served (permissive licence) · get_code("05217b7e7b5d3120") 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 an instance of its own class, MultiHeadAttention: the run constructed the object and did not call it, so no result was computed. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import torch
import torch.nn as nn
import numpy as np
torch.manual_seed(0)
# Parameters for MultiHeadAttention
n_head = 2
d_k = 4
d_in = 8
# Create a small input tensor for testing
# Shape: (batch_size, seq_len, d_in)
# batch_size = 2, seq_len = 3, d_in = 8
v = torch.randn(2, 3, 8)
# Create a pad_mask (optional parameter)
# Shape: (batch_size, seq_len)
pad_mask = torch.zeros(2, 3, dtype=torch.bool)
pad_mask[0, 2] = True # Mask the last position in first batch
ARGS = {
'n_head': n_head,
'd_k': d_k,
'd_in': d_in,
}
- 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 MultiHeadAttention — the run constructed an instance of its own class and did not call it; no shape is stated — the instrument coerces any output to an array; for a MultiHeadAttention 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
|
| PositionalEncoder |
Ran ran on a synthesized input · constructed an object; no result was computed |
VSainteuf/utae-paps/src/backbones/utae.py code served (permissive licence) · get_code("de6db552db8d11c4") 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 an instance of its own class, PositionalEncoder: the run constructed the object and did not call it, so no result was computed. 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 PositionalEncoder(nn.Module):
def __init__(self, d, T=1000, repeat=None, offset=0):
super(PositionalEncoder, self).__init__()
self.d = d
self.T = T
self.repeat = repeat
self.denom = torch.pow(T, 2 * (torch.arange(offset, offset + d).float() // 2) / d)
self.updated_location = False
def forward(self, batch_positions):
if not self.updated_location:
self.denom = self.denom.to(batch_positions.device)
self.updated_location = True
sinusoid_table = batch_positions[:, :, None] / self.denom[None, None, :]
sinusoid_table[:, :, 0::2] = torch.sin(sinusoid_table[:, :, 0::2])
sinusoid_table[:, :, 1::2] = torch.cos(sinusoid_table[:, :, 1::2])
if self.repeat is not None:
sinusoid_table = torch.cat([sinusoid_table for _ in range(self.repeat)], dim=-1)
return sinusoid_table
# Create batch_positions: shape (batch_size=2, sequence_length=3)
batch_positions = torch.tensor([[0.0, 1.0, 2.0], [3.0, 4.0, 5.0]])
ARGS = {
'd': 4,
'T': 1000,
'repeat': None,
'offset': 0
}
# Test instantiation
encoder = PositionalEncoder(**ARGS)
output = encoder(batch_positions)
- 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 PositionalEncoder — the run constructed an instance of its own class and did not call it; no shape is stated — the instrument coerces any output to an array; for a PositionalEncoder 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
|
| ScaledDotProductAttention |
Ran ran on a synthesized input · constructed an object; no result was computed |
VSainteuf/utae-paps/src/backbones/utae.py code served (permissive licence) · get_code("2b213e91591f2da8") 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 an instance of its own class, ScaledDotProductAttention: the run constructed the object and did not call it, so no result was computed. 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 ScaledDotProductAttention(nn.Module):
"""Scaled Dot-Product Attention
Modified from github.com/jadore801120/attention-is-all-you-need-pytorch
"""
def __init__(self, temperature, attn_dropout=0.1):
super().__init__()
self.temperature = temperature
self.dropout = nn.Dropout(attn_dropout)
self.softmax = nn.Softmax(dim=2)
def forward(self, q, k, v, pad_mask=None, return_comp=False):
attn = torch.matmul(q.unsqueeze(1), k.transpose(1, 2))
attn = attn / self.temperature
if pad_mask is not None:
attn = attn.masked_fill(pad_mask.unsqueeze(1), -1000.0)
if return_comp:
comp = attn
attn = self.softmax(attn)
attn = self.dropout(attn)
output = torch.matmul(attn, v)
if return_comp:
return (output, attn, comp)
else:
return (output, attn)
# Construct tiny tensors for testing
batch_size = 2
seq_len_q = 3
seq_len_k = 4
d_model = 5
q = torch.randn(batch_size, seq_len_q, d_model)
k = torch.randn(batch_size, seq_len_k, d_model)
v = torch.randn(batch_size, seq_len_k, d_model)
pad_mask = torch.zeros(batch_size, seq_len_k, dtype=torch.bool)
temperature = 2.0
ARGS = {
"temperature": temperature,
"attn_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 ScaledDotProductAttention — the run constructed an instance of its own class and did not call it; no shape is stated — the instrument coerces any output to an array; for a ScaledDotProductAttention 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
|
| Temporal_Aggregator |
Ran ran on a synthesized input · constructed an object; no result was computed |
VSainteuf/utae-paps/src/backbones/utae.py code served (permissive licence) · get_code("95b9e0afd8ec4312") 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 an instance of its own class, Temporal_Aggregator: the run constructed the object and did not call it, so no result was computed. 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 Temporal_Aggregator(nn.Module):
def __init__(self, mode='mean'):
super(Temporal_Aggregator, self).__init__()
self.mode = mode
def forward(self, x, pad_mask=None, attn_mask=None):
if pad_mask is not None and pad_mask.any():
if self.mode == 'att_group':
n_heads, b, t, h, w = attn_mask.shape
attn = attn_mask.view(n_heads * b, t, h, w)
if x.shape[-2] > w:
attn = nn.Upsample(size=x.shape[-2:], mode='bilinear', align_corners=False)(attn)
else:
attn = nn.AvgPool2d(kernel_size=w // x.shape[-2])(attn)
attn = attn.view(n_heads, b, t, *x.shape[-2:])
attn = attn * (~pad_mask).float()[None, :, :, None, None]
out = torch.stack(x.chunk(n_heads, dim=2))
out = attn[:, :, :, None, :, :] * out
out = out.sum(dim=2)
out = torch.cat([group for group in out], dim=1)
return out
elif self.mode == 'att_mean':
attn = attn_mask.mean(dim=0)
attn = nn.Upsample(size=x.shape[-2:], mode='bilinear', align_corners=False)(attn)
attn = attn * (~pad_mask).float()[:, :, None, None]
out = (x * attn[:, :, None, :, :]).sum(dim=1)
return out
elif self.mode == 'mean':
out = x * (~pad_mask).float()[:, :, None, None, None]
out = out.sum(dim=1) / (~pad_mask).sum(dim=1)[:, None, None, None]
return out
elif self.mode == 'att_group':
n_heads, b, t, h, w = attn_mask.shape
attn = attn_mask.view(n_heads * b, t, h, w)
if x.shape[-2] > w:
attn = nn.Upsample(size=x.shape[-2:], mode='bilinear', align_corners=False)(attn)
else:
attn = nn.AvgPool2d(kernel_size=w // x.shape[-2])(attn)
attn = attn.view(n_heads, b, t, *x.shape[-2:])
out = torch.stack(x.chunk(n_heads, dim=2))
out = attn[:, :, :, None, :, :] * out
out = out.sum(dim=2)
out = torch.cat([group for group in out], dim=1)
return out
elif self.mode == 'att_mean':
attn = attn_mask.mean(dim=0)
attn = nn.Upsample(size=x.shape[-2:], mode='bilinear', align_corners=False)(attn)
out = (x * attn[:, :, None, :, :]).sum(dim=1)
return out
elif self.mode == 'mean':
return x.mean(dim=1)
# Setup for 'mean' mode without pad_mask or attn_mask
aggregator_mean = Temporal_Aggregator(mode='mean')
# x shape: (batch, time, channels, height, width) = (2, 3, 4, 5, 6)
x_mean = torch.randn(2, 3, 4, 5, 6)
# Setup for 'att_mean' mode with attn_mask and pad_mask
aggregator_att_mean = Temporal_Aggregator(mode='att_mean')
# x shape: (batch, time, channels, height, width)
x_att_mean = torch.randn(2, 3, 4, 8, 8)
# attn_mask shape: (n_heads, batch, time, height, width)
attn_mask_att_mean = torch.randn(2, 2, 3, 8, 8)
# pad_mask shape: (batch, time) - boolean mask where True means padded
pad_mask_att_mean = torch.tensor([[False, False, True], [False, True, True]])
# Setup for 'att_group' mode
aggregator_att_group = Temporal_Aggregator(mode='att_group')
n_heads = 2
b = 2
t = 3
c_per_head = 4
h = 8
w = 8
# x should have shape compatible with att_group: (batch, time, n_heads*channels, height, width)
x_att_group = torch.randn(b, t, n_heads * c_per_head, h, w)
# attn_mask shape: (n_heads, batch, time, height, width)
attn_mask_att_group = torch.randn(n_heads, b, t, h, w)
pad_mask_att_group = torch.tensor([[False, False, True], [False, True, True]])
ARGS = {
'mode': 'mean'
}
- 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 Temporal_Aggregator — the run constructed an instance of its own class and did not call it; no shape is stated — the instrument coerces any output to an array; for a Temporal_Aggregator 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
|
| TemporallySharedBlock |
Ran ran on a synthesized input · constructed an object; no result was computed |
VSainteuf/utae-paps/src/backbones/utae.py code served (permissive licence) · get_code("f56238c8ef11a6d5") 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 an instance of its own class, TemporallySharedBlock: the run constructed the object and did not call it, so no result was computed. 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 concrete subclass of TemporallySharedBlock that implements forward()
class ConcreteBlock(nn.Module):
def __init__(self, pad_value=None):
super(ConcreteBlock, self).__init__()
self.pad_value = pad_value
self.out_shape = None
# Simple conv layer for the forward pass
self.conv = nn.Conv2d(in_channels=4, out_channels=3, kernel_size=3, padding=1)
def forward(self, x):
# x shape: (b*t, c, h, w) or (b, c, h, w)
return self.conv(x)
def smart_forward(self, input):
if len(input.shape) == 4:
return self.forward(input)
else:
b, t, c, h, w = input.shape
if self.pad_value is not None:
dummy = torch.zeros(input.shape, device=input.device).float()
self.out_shape = self.forward(dummy.view(b * t, c, h, w)).shape
out = input.view(b * t, c, h, w)
if self.pad_value is not None:
pad_mask = (out == self.pad_value).all(dim=-1).all(dim=-1).all(dim=-1)
if pad_mask.any():
temp = torch.ones(self.out_shape, device=input.device, requires_grad=False) * self.pad_value
temp[~pad_mask] = self.forward(out[~pad_mask])
out = temp
else:
out = self.forward(out)
else:
out = self.forward(out)
_, c, h, w = out.shape
out = out.view(b, t, c, h, w)
return out
# Create the module instance
module = ConcreteBlock(pad_value=None)
ARGS = {
"pad_value": None
}
- 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 TemporallySharedBlock — the run constructed an instance of its own class and did not call it; no shape is stated — the instrument coerces any output to an array; for a TemporallySharedBlock 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
|
| UpConvBlock |
Ran ran on a synthesized input · constructed an object; no result was computed |
VSainteuf/utae-paps/src/backbones/utae.py code served (permissive licence) · get_code("a64d9cde74098274") 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 an instance of its own class, UpConvBlock: the run constructed the object and did not call it, so no result was computed. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import torch
import torch.nn as nn
torch.manual_seed(0)
ARGS = {
'd_in': 64,
'd_out': 32,
'k': 3,
's': 2,
'p': 1,
'norm': 'batch',
'd_skip': 32,
'padding_mode': 'reflect'
}
- 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 UpConvBlock — the run constructed an instance of its own class and did not call it; no shape is stated — the instrument coerces any output to an array; for a UpConvBlock 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
|
| UTAE |
Not yet run unverified (harvested, no recorded run) |
VSainteuf/utae-paps/src/backbones/utae.py code served (permissive licence) · get_code("8abb5042ed8b7f79") How it ran |