| AEHelper |
Ran ran on a synthesized input |
microsoft/dcvc/DCVC-family/DCVC-FM/src/models/video_model.py code served (permissive licence) · get_code("f82bf9fe9efb4ab4") 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 NoneType. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import torch
import numpy as np
class AEHelper:
def __init__(self):
super().__init__()
self.entropy_coder = None
self.cdf_group_index = None
self._offset = None
self._quantized_cdf = None
self._cdf_length = None
def set_cdf_info(self, quantized_cdf, cdf_length, offset):
self._quantized_cdf = quantized_cdf.cpu().numpy()
self._cdf_length = cdf_length.reshape(-1).int().cpu().numpy()
self._offset = offset.reshape(-1).int().cpu().numpy()
def get_cdf_info(self):
return (self._quantized_cdf, self._cdf_length, self._offset)
INIT_ARGS = {}
ARGS = {
'quantized_cdf': torch.randint(0, 256, (4, 3), dtype=torch.uint8),
'cdf_length': torch.tensor([5, 6, 7, 8], dtype=torch.int32),
'offset': torch.tensor([0, 1, 2, 3], dtype=torch.int32),
}
METHOD = 'set_cdf_info'
if __name__ == '__main__':
obj = AEHelper(**INIT_ARGS)
result = getattr(obj, METHOD)(**ARGS)
cdf_info = obj.get_cdf_info()
print("CDF info retrieved successfully")
print(f"Quantized CDF shape: {cdf_info[0].shape}")
print(f"CDF length shape: {cdf_info[1].shape}")
print(f"Offset shape: {cdf_info[2].shape}")
- Setup block drafted by
- a language model, class construct-then-call prompt, model not recorded
- Imports
- numpy, torch — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type NoneType — a NoneType output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a NoneType 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: torch and numpy seeded to 0 by the harness immediately before the class was constructed from INIT_ARGS (fixture_check.py)
|
| BitEstimator |
Ran ran on a synthesized input · constructed an object; no result was computed |
microsoft/dcvc/DCVC-family/DCVC-FM/src/models/video_model.py code served (permissive licence) · get_code("379a90fedf952408") 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, BitEstimator: 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
from torch import nn
import numpy as np
torch.manual_seed(0)
ARGS = {
"qp_num": 3,
"channel": 4,
}
- 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 BitEstimator — 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 BitEstimator 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
|
| Bitparm |
Ran ran on a synthesized input · constructed an object; no result was computed |
microsoft/dcvc/DCVC-family/DCVC-FM/src/models/video_model.py code served (permissive licence) · get_code("c4a3ec7db0af2724") 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, Bitparm: 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
from torch import nn
torch.manual_seed(0)
# Create a Bitparm module instance with small dimensions
bitparm_module = nn.Sequential() # Stand-in, though we're testing Bitparm itself
# Define arguments for Bitparm.__init__
qp_num = 3 # Number of QP values (distinct from other dims)
channel = 4 # Number of channels
final = False # Test non-final case
# Create test inputs for forward pass
x = torch.randn(2, 4, 8, 8) # batch=2, channels=4, height=8, width=8
index = torch.tensor([0, 1], dtype=torch.long) # Index tensor for selecting QP parameters
ARGS = {
"qp_num": qp_num,
"channel": channel,
"final": final,
}
- 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 Bitparm — 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 Bitparm 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
|
| ContextualDecoder |
Ran ran on a synthesized input · constructed an object; no result was computed |
microsoft/dcvc/DCVC-family/DCVC-FM/src/models/video_model.py code served (permissive licence) · get_code("fca5b37ad0d391c2") 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, ContextualDecoder: 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)
# Build the ContextualDecoder module
decoder = nn.Module()
# Create minimal dummy tensors for the forward pass
# x shape: (batch, g_ch_16x, height, width) = (2, 128, 4, 4)
# After up1: (2, 96, 8, 8)
# After up2: (2, 96, 16, 16)
# context3: (2, 96, 16, 16) - concatenated with feature
# After res1: (2, 192, 16, 16)
# After up3: (2, 64, 32, 32)
# quant_step: scalar or (1,)
# context2: (2, 128, 32, 32) - concatenated with feature * quant_step
# After res2: (2, 128, 32, 32)
# After up4: (2, 32, 64, 64)
x = torch.randn(2, 128, 4, 4)
context2 = torch.randn(2, 128, 32, 32)
context3 = torch.randn(2, 96, 16, 16)
quant_step = torch.tensor(0.5)
ARGS = {
"inplace": False,
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- torch — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type ContextualDecoder — 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 ContextualDecoder 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
|
| ContextualEncoder |
Ran ran on a synthesized input |
microsoft/dcvc/DCVC-family/DCVC-FM/src/models/video_model.py code served (permissive licence) · get_code("310fe7d061e997cf") 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
from torch import nn
# Copy the classes from the problem
class ConvFFN3(nn.Module):
def __init__(self, in_ch, inplace=False):
super().__init__()
expansion_factor = 2
internal_ch = in_ch * expansion_factor
self.conv = nn.Conv2d(in_ch, internal_ch * 2, 1)
self.conv_out = nn.Conv2d(internal_ch, in_ch, 1)
self.relu1 = nn.LeakyReLU(negative_slope=0.1, inplace=inplace)
self.relu2 = nn.LeakyReLU(negative_slope=0.01, inplace=inplace)
def forward(self, x):
identity = x
x1, x2 = self.conv(x).chunk(2, 1)
out = self.relu1(x1) + self.relu2(x2)
return identity + self.conv_out(out)
class DepthConv(nn.Module):
def __init__(self, in_ch, out_ch, slope=0.01, inplace=False):
super().__init__()
self.conv1 = nn.Sequential(nn.Conv2d(in_ch, in_ch, 1), nn.LeakyReLU(negative_slope=slope, inplace=inplace))
self.depth_conv = nn.Conv2d(in_ch, in_ch, 3, padding=1, groups=in_ch)
self.conv2 = nn.Conv2d(in_ch, out_ch, 1)
self.adaptor = None
if in_ch != out_ch:
self.adaptor = nn.Conv2d(in_ch, out_ch, 1)
def forward(self, x):
identity = x
if self.adaptor is not None:
identity = self.adaptor(identity)
out = self.conv1(x)
out = self.depth_conv(out)
out = self.conv2(out)
return out + identity
class DepthConvBlock4(nn.Module):
def __init__(self, in_ch, out_ch, slope_depth_conv=0.01, inplace=False):
super().__init__()
self.block = nn.Sequential(DepthConv(in_ch, out_ch, slope=slope_depth_conv, inplace=inplace), ConvFFN3(out_ch, inplace=inplace))
def forward(self, x):
return self.block(x)
g_ch_16x = 128
g_ch_1x = 48
g_ch_2x = 64
g_ch_4x = 96
g_ch_8x = 96
class ContextualEncoder(nn.Module):
def __init__(self, inplace=False):
super().__init__()
self.conv1 = nn.Conv2d(g_ch_1x + 3, g_ch_2x, 3, stride=2, padding=1)
self.res1 = DepthConvBlock4(g_ch_2x * 2, g_ch_2x * 2, inplace=inplace)
self.conv2 = nn.Conv2d(g_ch_2x * 2, g_ch_4x, 3, stride=2, padding=1)
self.res2 = DepthConvBlock4(g_ch_4x * 2, g_ch_4x * 2, inplace=inplace)
self.conv3 = nn.Conv2d(g_ch_4x * 2, g_ch_8x, 3, stride=2, padding=1)
self.conv4 = nn.Conv2d(g_ch_8x, g_ch_16x, 3, stride=2, padding=1)
def forward(self, x, context1, context2, context3, quant_step):
feature = self.conv1(torch.cat([x, context1], dim=1))
feature = self.res1(torch.cat([feature, context2], dim=1))
feature = feature * quant_step
feature = self.conv2(feature)
feature = self.res2(torch.cat([feature, context3], dim=1))
feature = self.conv3(feature)
feature = self.conv4(feature)
return feature
INIT_ARGS = {
'inplace': False,
}
ARGS = {
'x': torch.randn(2, 3, 32, 32),
'context1': torch.randn(2, g_ch_1x, 32, 32),
'context2': torch.randn(2, g_ch_2x, 16, 16),
'context3': torch.randn(2, g_ch_4x, 8, 8),
'quant_step': torch.tensor(1.0),
}
- 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)
|
| ConvFFN |
Ran ran on a synthesized input · constructed an object; no result was computed |
microsoft/dcvc/DCVC-family/DCVC-FM/src/models/video_model.py code served (permissive licence) · get_code("419be1df805c2172") 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, ConvFFN: 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 = {
'in_ch': 16,
'slope': 0.1,
'inplace': False,
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- torch — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type ConvFFN — 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 ConvFFN 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
|
| ConvFFN3 |
Ran ran on a synthesized input · constructed an object; no result was computed |
microsoft/dcvc/DCVC-family/DCVC-FM/src/models/video_model.py code served (permissive licence) · get_code("03692913271d3292") 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, ConvFFN3: 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 ConvFFN3(nn.Module):
def __init__(self, in_ch, inplace=False):
super().__init__()
expansion_factor = 2
internal_ch = in_ch * expansion_factor
self.conv = nn.Conv2d(in_ch, internal_ch * 2, 1)
self.conv_out = nn.Conv2d(internal_ch, in_ch, 1)
self.relu1 = nn.LeakyReLU(negative_slope=0.1, inplace=inplace)
self.relu2 = nn.LeakyReLU(negative_slope=0.01, inplace=inplace)
def forward(self, x):
identity = x
x1, x2 = self.conv(x).chunk(2, 1)
out = self.relu1(x1) + self.relu2(x2)
return identity + self.conv_out(out)
ARGS = {
"in_ch": 4,
"inplace": False,
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- torch — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type ConvFFN3 — 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 ConvFFN3 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
|
| DepthConv |
Ran ran on a synthesized input |
microsoft/dcvc/DCVC-family/DCVC-FM/src/models/video_model.py code served (permissive licence) · get_code("a6721c08436a1879") 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
from torch import nn
class DepthConv(nn.Module):
def __init__(self, in_ch, out_ch, slope=0.01, inplace=False):
super().__init__()
self.conv1 = nn.Sequential(nn.Conv2d(in_ch, in_ch, 1), nn.LeakyReLU(negative_slope=slope, inplace=inplace))
self.depth_conv = nn.Conv2d(in_ch, in_ch, 3, padding=1, groups=in_ch)
self.conv2 = nn.Conv2d(in_ch, out_ch, 1)
self.adaptor = None
if in_ch != out_ch:
self.adaptor = nn.Conv2d(in_ch, out_ch, 1)
def forward(self, x):
identity = x
if self.adaptor is not None:
identity = self.adaptor(identity)
out = self.conv1(x)
out = self.depth_conv(out)
out = self.conv2(out)
return out + identity
INIT_ARGS = {
'in_ch': 4,
'out_ch': 6,
'slope': 0.01,
'inplace': False
}
ARGS = {
'x': torch.randn(2, 4, 3, 5)
}
if __name__ == '__main__':
model = DepthConv(**INIT_ARGS)
output = model(**ARGS)
print(f"Output shape: {output.shape}")
print(f"Expected shape: (2, 6, 3, 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 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)
|
| DepthConvBlock |
Ran ran on a synthesized input · constructed an object; no result was computed |
microsoft/dcvc/DCVC-family/DCVC-FM/src/models/video_model.py code served (permissive licence) · get_code("b14677bd2a05b95f") 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, DepthConvBlock: 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 = {
"in_ch": 4,
"out_ch": 8,
"slope_depth_conv": 0.01,
"slope_ffn": 0.1,
"inplace": False,
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- torch — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type DepthConvBlock — 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 DepthConvBlock 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
|
| DepthConvBlock4 |
Ran ran on a synthesized input · constructed an object; no result was computed |
microsoft/dcvc/DCVC-family/DCVC-FM/src/models/video_model.py code served (permissive licence) · get_code("5fcc0a5945f66527") 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, DepthConvBlock4: 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 small test input tensor
# Shape: (batch_size=2, channels=4, height=8, width=8)
test_input = torch.randn(2, 4, 8, 8)
# Define ARGS dict with all parameters for DepthConvBlock4.__init__
ARGS = {
'in_ch': 4,
'out_ch': 3,
'slope_depth_conv': 0.01,
'inplace': False
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- torch — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type DepthConvBlock4 — 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 DepthConvBlock4 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
|
| FeatureExtractor |
Ran ran on a synthesized input · constructed an object; no result was computed |
microsoft/dcvc/DCVC-family/DCVC-FM/src/models/video_model.py code served (permissive licence) · get_code("4d085f78c5a59bdc") 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, FeatureExtractor: 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)
# Define the constants used in FeatureExtractor
g_ch_1x = 48
g_ch_2x = 64
g_ch_4x = 96
# Define ResBlock class
class ResBlock(nn.Module):
def __init__(self, channel, slope=0.01, end_with_relu=False, bottleneck=False, inplace=False):
super().__init__()
in_channel = channel // 2 if bottleneck else channel
self.first_layer = nn.LeakyReLU(negative_slope=slope, inplace=False)
self.conv1 = nn.Conv2d(channel, in_channel, 3, padding=1)
self.relu = nn.LeakyReLU(negative_slope=slope, inplace=inplace)
self.conv2 = nn.Conv2d(in_channel, channel, 3, padding=1)
self.last_layer = self.relu if end_with_relu else nn.Identity()
def forward(self, x):
identity = x
out = self.first_layer(x)
out = self.conv1(out)
out = self.relu(out)
out = self.conv2(out)
out = self.last_layer(out)
return identity + out
# Define FeatureExtractor class
class FeatureExtractor(nn.Module):
def __init__(self, inplace=False):
super().__init__()
self.conv1 = nn.Conv2d(g_ch_1x, g_ch_1x, 3, stride=1, padding=1)
self.res_block1 = ResBlock(g_ch_1x, inplace=inplace)
self.conv2 = nn.Conv2d(g_ch_1x, g_ch_2x, 3, stride=2, padding=1)
self.res_block2 = ResBlock(g_ch_2x, inplace=inplace)
self.conv3 = nn.Conv2d(g_ch_2x, g_ch_4x, 3, stride=2, padding=1)
self.res_block3 = ResBlock(g_ch_4x, inplace=inplace)
def forward(self, feature):
layer1 = self.conv1(feature)
layer1 = self.res_block1(layer1)
layer2 = self.conv2(layer1)
layer2 = self.res_block2(layer2)
layer3 = self.conv3(layer2)
layer3 = self.res_block3(layer3)
return (layer1, layer2, layer3)
# Create arguments for FeatureExtractor
ARGS = {
'inplace': False
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- torch — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type FeatureExtractor — 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 FeatureExtractor 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
|
| GaussianEncoder |
Ran ran on a synthesized input · constructed an object; no result was computed |
microsoft/dcvc/DCVC-family/DCVC-FM/src/models/video_model.py code served (permissive licence) · get_code("659877e766994421") 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, GaussianEncoder: 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 math
import numpy as np
torch.manual_seed(0)
ARGS = {
'distribution': 'laplace'
}
- 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 GaussianEncoder — 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 GaussianEncoder 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
|
| MEBasic |
Ran ran on a synthesized input · constructed an object; no result was computed |
microsoft/dcvc/DCVC-family/DCVC-FM/src/models/video_model.py code served (permissive licence) · get_code("fe224c85d7424b84") 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, MEBasic: 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)
# MEBasic.__init__ takes complexity_level as a parameter
# MEBasic.forward expects input x to be a 4D tensor (batch, channels, height, width)
# The forward method accesses x[:, -2:, :, :] in bypass mode
# and applies convolutions that expect 8 input channels
# Create a small input tensor: batch_size=2, channels=8, height=4, width=3
input_tensor = torch.randn(2, 8, 4, 3)
ARGS = {
"complexity_level": 0
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- torch — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type MEBasic — 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 MEBasic 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
|
| MultiScaleContextFusion |
Ran ran on a synthesized input · constructed an object; no result was computed |
microsoft/dcvc/DCVC-family/DCVC-FM/src/models/video_model.py code served (permissive licence) · get_code("320925690ef29c06") 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, MultiScaleContextFusion: 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
from torch import nn
torch.manual_seed(0)
# Define the constants and classes needed
g_ch_1x = 48
g_ch_2x = 64
g_ch_4x = 96
def subpel_conv3x3(in_ch, out_ch, r=1):
"""3x3 sub-pixel convolution for up-sampling."""
return nn.Sequential(nn.Conv2d(in_ch, out_ch * r ** 2, kernel_size=3, padding=1), nn.PixelShuffle(r))
class ResBlock(nn.Module):
def __init__(self, channel, slope=0.01, end_with_relu=False, bottleneck=False, inplace=False):
super().__init__()
in_channel = channel // 2 if bottleneck else channel
self.first_layer = nn.LeakyReLU(negative_slope=slope, inplace=False)
self.conv1 = nn.Conv2d(channel, in_channel, 3, padding=1)
self.relu = nn.LeakyReLU(negative_slope=slope, inplace=inplace)
self.conv2 = nn.Conv2d(in_channel, channel, 3, padding=1)
self.last_layer = self.relu if end_with_relu else nn.Identity()
def forward(self, x):
identity = x
out = self.first_layer(x)
out = self.conv1(out)
out = self.relu(out)
out = self.conv2(out)
out = self.last_layer(out)
return identity + out
# Create test inputs
# The forward method expects context1, context2, context3 with specific channel dimensions
batch_size = 2
height = 4
width = 3
context1 = torch.randn(batch_size, g_ch_1x, height * 4, width * 4)
context2 = torch.randn(batch_size, g_ch_2x, height * 2, width * 2)
context3 = torch.randn(batch_size, g_ch_4x, height, width)
ARGS = {
'inplace': False
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- torch — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type MultiScaleContextFusion — 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 MultiScaleContextFusion 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
|
| MvDec |
Ran ran on a synthesized input |
microsoft/dcvc/DCVC-family/DCVC-FM/src/models/video_model.py code served (permissive licence) · get_code("ddc18f98237531b4") 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
# Define the helper functions and classes needed
def conv3x3(in_ch, out_ch, stride=1):
"""3x3 convolution with padding."""
return nn.Conv2d(in_ch, out_ch, kernel_size=3, stride=stride, padding=1)
def subpel_conv1x1(in_ch, out_ch, r=1):
"""1x1 sub-pixel convolution for up-sampling."""
return nn.Sequential(nn.Conv2d(in_ch, out_ch * r ** 2, kernel_size=1, padding=0), nn.PixelShuffle(r))
class ConvFFN3(nn.Module):
def __init__(self, in_ch, inplace=False):
super().__init__()
expansion_factor = 2
internal_ch = in_ch * expansion_factor
self.conv = nn.Conv2d(in_ch, internal_ch * 2, 1)
self.conv_out = nn.Conv2d(internal_ch, in_ch, 1)
self.relu1 = nn.LeakyReLU(negative_slope=0.1, inplace=inplace)
self.relu2 = nn.LeakyReLU(negative_slope=0.01, inplace=inplace)
def forward(self, x):
identity = x
x1, x2 = self.conv(x).chunk(2, 1)
out = self.relu1(x1) + self.relu2(x2)
return identity + self.conv_out(out)
class DepthConv(nn.Module):
def __init__(self, in_ch, out_ch, slope=0.01, inplace=False):
super().__init__()
self.conv1 = nn.Sequential(nn.Conv2d(in_ch, in_ch, 1), nn.LeakyReLU(negative_slope=slope, inplace=inplace))
self.depth_conv = nn.Conv2d(in_ch, in_ch, 3, padding=1, groups=in_ch)
self.conv2 = nn.Conv2d(in_ch, out_ch, 1)
self.adaptor = None
if in_ch != out_ch:
self.adaptor = nn.Conv2d(in_ch, out_ch, 1)
def forward(self, x):
identity = x
if self.adaptor is not None:
identity = self.adaptor(identity)
out = self.conv1(x)
out = self.depth_conv(out)
out = self.conv2(out)
return out + identity
class DepthConvBlock4(nn.Module):
def __init__(self, in_ch, out_ch, slope_depth_conv=0.01, inplace=False):
super().__init__()
self.block = nn.Sequential(DepthConv(in_ch, out_ch, slope=slope_depth_conv, inplace=inplace), ConvFFN3(out_ch, inplace=inplace))
def forward(self, x):
return self.block(x)
class ResidualBlockUpsample(nn.Module):
def __init__(self, in_ch, out_ch, upsample=2, inplace=False):
super().__init__()
self.subpel_conv = subpel_conv1x1(in_ch, out_ch, upsample)
self.leaky_relu = nn.LeakyReLU(inplace=inplace)
self.conv = conv3x3(out_ch, out_ch)
self.leaky_relu2 = nn.LeakyReLU(negative_slope=0.1, inplace=inplace)
self.upsample = subpel_conv1x1(in_ch, out_ch, upsample)
def forward(self, x):
identity = x
out = self.subpel_conv(x)
out = self.leaky_relu(out)
out = self.conv(out)
out = self.leaky_relu2(out)
identity = self.upsample(x)
out = out + identity
return out
class MvDec(nn.Module):
def __init__(self, output_channel, channel, inplace=False):
super().__init__()
self.dec_1 = nn.Sequential(DepthConvBlock4(channel, channel, inplace=inplace), ResidualBlockUpsample(channel, channel, 2, inplace=inplace), DepthConvBlock4(channel, channel, inplace=inplace), ResidualBlockUpsample(channel, channel, 2, inplace=inplace), DepthConvBlock4(channel, channel, inplace=inplace))
self.dec_2 = ResidualBlockUpsample(channel, channel, 2, inplace=inplace)
self.dec_3 = nn.Sequential(DepthConvBlock4(channel, channel, inplace=inplace), subpel_conv1x1(channel, output_channel, 2))
def forward(self, x, quant_step):
feature = self.dec_1(x)
out = self.dec_2(feature)
out = out * quant_step
mv = self.dec_3(out)
return (mv, feature)
INIT_ARGS = {
'output_channel': 3,
'channel': 4,
'inplace': False,
}
ARGS = {
'x': torch.randn(2, 4, 8, 8),
'quant_step': torch.tensor(0.5),
}
if __name__ == '__main__':
model = MvDec(**INIT_ARGS)
output = model(**ARGS)
print("Output shapes:", output[0].shape, output[1].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 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)
|
| MvEnc |
Ran ran on a synthesized input |
microsoft/dcvc/DCVC-family/DCVC-FM/src/models/video_model.py code served (permissive licence) · get_code("0272de7b35cc7549") 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
from torch import nn
# Helper functions and classes from the provided code
def conv1x1(in_ch, out_ch, stride=1):
"""1x1 convolution."""
return nn.Conv2d(in_ch, out_ch, kernel_size=1, stride=stride)
def conv3x3(in_ch, out_ch, stride=1):
"""3x3 convolution with padding."""
return nn.Conv2d(in_ch, out_ch, kernel_size=3, stride=stride, padding=1)
class ConvFFN3(nn.Module):
def __init__(self, in_ch, inplace=False):
super().__init__()
expansion_factor = 2
internal_ch = in_ch * expansion_factor
self.conv = nn.Conv2d(in_ch, internal_ch * 2, 1)
self.conv_out = nn.Conv2d(internal_ch, in_ch, 1)
self.relu1 = nn.LeakyReLU(negative_slope=0.1, inplace=inplace)
self.relu2 = nn.LeakyReLU(negative_slope=0.01, inplace=inplace)
def forward(self, x):
identity = x
x1, x2 = self.conv(x).chunk(2, 1)
out = self.relu1(x1) + self.relu2(x2)
return identity + self.conv_out(out)
class DepthConv(nn.Module):
def __init__(self, in_ch, out_ch, slope=0.01, inplace=False):
super().__init__()
self.conv1 = nn.Sequential(nn.Conv2d(in_ch, in_ch, 1), nn.LeakyReLU(negative_slope=slope, inplace=inplace))
self.depth_conv = nn.Conv2d(in_ch, in_ch, 3, padding=1, groups=in_ch)
self.conv2 = nn.Conv2d(in_ch, out_ch, 1)
self.adaptor = None
if in_ch != out_ch:
self.adaptor = nn.Conv2d(in_ch, out_ch, 1)
def forward(self, x):
identity = x
if self.adaptor is not None:
identity = self.adaptor(identity)
out = self.conv1(x)
out = self.depth_conv(out)
out = self.conv2(out)
return out + identity
class DepthConvBlock4(nn.Module):
def __init__(self, in_ch, out_ch, slope_depth_conv=0.01, inplace=False):
super().__init__()
self.block = nn.Sequential(DepthConv(in_ch, out_ch, slope=slope_depth_conv, inplace=inplace), ConvFFN3(out_ch, inplace=inplace))
def forward(self, x):
return self.block(x)
class ResidualBlockWithStride(nn.Module):
def __init__(self, in_ch, out_ch, stride=2, inplace=False):
super().__init__()
self.conv1 = conv3x3(in_ch, out_ch, stride=stride)
self.leaky_relu = nn.LeakyReLU(inplace=inplace)
self.conv2 = conv3x3(out_ch, out_ch)
self.leaky_relu2 = nn.LeakyReLU(negative_slope=0.1, inplace=inplace)
if stride != 1:
self.downsample = conv1x1(in_ch, out_ch, stride=stride)
else:
self.downsample = None
def forward(self, x):
identity = x
out = self.conv1(x)
out = self.leaky_relu(out)
out = self.conv2(out)
out = self.leaky_relu2(out)
if self.downsample is not None:
identity = self.downsample(x)
out = out + identity
return out
class MvEnc(nn.Module):
def __init__(self, input_channel, channel, inplace=False):
super().__init__()
self.enc_1 = nn.Sequential(ResidualBlockWithStride(input_channel, channel, stride=2, inplace=inplace), DepthConvBlock4(channel, channel, inplace=inplace))
self.enc_2 = ResidualBlockWithStride(channel, channel, stride=2, inplace=inplace)
self.adaptor_0 = DepthConvBlock4(channel, channel, inplace=inplace)
self.adaptor_1 = DepthConvBlock4(channel * 2, channel, inplace=inplace)
self.enc_3 = nn.Sequential(ResidualBlockWithStride(channel, channel, stride=2, inplace=inplace), DepthConvBlock4(channel, channel, inplace=inplace), nn.Conv2d(channel, channel, 3, stride=2, padding=1))
def forward(self, x, context, quant_step):
out = self.enc_1(x)
out = out * quant_step
out = self.enc_2(out)
if context is None:
out = self.adaptor_0(out)
else:
out = self.adaptor_1(torch.cat((out, context), dim=1))
return self.enc_3(out)
INIT_ARGS = {
'input_channel': 3,
'channel': 4,
'inplace': False,
}
ARGS = {
'x': torch.randn(2, 3, 64, 64),
'context': None,
'quant_step': torch.tensor(0.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 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)
|
| OffsetDiversity |
Ran ran on a synthesized input · constructed an object; no result was computed |
microsoft/dcvc/DCVC-family/DCVC-FM/src/models/video_model.py code served (permissive licence) · get_code("d2f0192d643ab535") 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, OffsetDiversity: 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
from torch import nn
import torch.nn.functional as F
torch.manual_seed(0)
# Create minimal tensors for testing
B, C_in, H, W = 2, 48, 8, 8
C_aux = 48 + 3 + 2 # g_ch_1x + 3 + 2
offset_num = 2
group_num = 16
# x: input feature map (B, C_in, H, W)
x = torch.randn(B, C_in, H, W)
# aux_feature: auxiliary feature (B, aux_feature_num, H, W)
aux_feature = torch.randn(B, C_aux, H, W)
# flow: optical flow (B, 2, H, W)
flow = torch.randn(B, 2, H, W)
ARGS = {
"in_channel": 48,
"aux_feature_num": 48 + 3 + 2,
"offset_num": 2,
"group_num": 16,
"max_residue_magnitude": 40,
"inplace": False,
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- torch — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type OffsetDiversity — 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 OffsetDiversity 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
|
| ReconGeneration |
Ran ran on a synthesized input · constructed an object; no result was computed |
microsoft/dcvc/DCVC-family/DCVC-FM/src/models/video_model.py code served (permissive licence) · get_code("3d55656b67d7cbf4") 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, ReconGeneration: 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
from torch import nn
torch.manual_seed(0)
# The ReconGeneration class expects:
# - ctx: context tensor with ctx_channel (default g_ch_1x=48) channels
# - res: residual tensor with res_channel (default 32) channels
# Both tensors should have spatial dimensions that work through the UNet2 architecture
# (which uses max_pool and upsampling by factor of 2)
# Create sample tensors: batch=2, spatial dims=8x8 (divisible by 2 for pooling)
batch_size = 2
ctx_channel = 48
res_channel = 32
height = 8
width = 8
ctx_tensor = torch.randn(batch_size, ctx_channel, height, width)
res_tensor = torch.randn(batch_size, res_channel, height, width)
ARGS = {
"ctx_channel": ctx_channel,
"res_channel": res_channel,
"inplace": False,
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- torch — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type ReconGeneration — 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 ReconGeneration 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
|
| ResBlock |
Ran ran on a synthesized input · constructed an object; no result was computed |
microsoft/dcvc/DCVC-family/DCVC-FM/src/models/video_model.py code served (permissive licence) · get_code("75b276630f3fe107") 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, ResBlock: 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 = {
'channel': 16,
'slope': 0.01,
'end_with_relu': False,
'bottleneck': False,
'inplace': False,
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- torch — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type ResBlock — 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 ResBlock 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
|
| ResidualBlockUpsample |
Ran ran on a synthesized input · constructed an object; no result was computed |
microsoft/dcvc/DCVC-family/DCVC-FM/src/models/video_model.py code served (permissive licence) · get_code("c0ac2daecdabac0b") 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, ResidualBlockUpsample: 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)
# Define the helper functions needed
def conv3x3(in_ch, out_ch, stride=1):
"""3x3 convolution with padding."""
return nn.Conv2d(in_ch, out_ch, kernel_size=3, stride=stride, padding=1)
def subpel_conv1x1(in_ch, out_ch, r=1):
"""1x1 sub-pixel convolution for up-sampling."""
return nn.Sequential(nn.Conv2d(in_ch, out_ch * r ** 2, kernel_size=1, padding=0), nn.PixelShuffle(r))
class ResidualBlockUpsample(nn.Module):
"""Residual block with sub-pixel upsampling on the last convolution.
Args:
in_ch (int): number of input channels
out_ch (int): number of output channels
upsample (int): upsampling factor (default: 2)
"""
def __init__(self, in_ch, out_ch, upsample=2, inplace=False):
super().__init__()
self.subpel_conv = subpel_conv1x1(in_ch, out_ch, upsample)
self.leaky_relu = nn.LeakyReLU(inplace=inplace)
self.conv = conv3x3(out_ch, out_ch)
self.leaky_relu2 = nn.LeakyReLU(negative_slope=0.1, inplace=inplace)
self.upsample = subpel_conv1x1(in_ch, out_ch, upsample)
def forward(self, x):
identity = x
out = self.subpel_conv(x)
out = self.leaky_relu(out)
out = self.conv(out)
out = self.leaky_relu2(out)
identity = self.upsample(x)
out = out + identity
return out
# Create arguments for ResidualBlockUpsample
ARGS = {
"in_ch": 3,
"out_ch": 4,
"upsample": 2,
"inplace": False,
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- torch — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type ResidualBlockUpsample — 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 ResidualBlockUpsample 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
|
| ResidualBlockWithStride |
Ran ran on a synthesized input · constructed an object; no result was computed |
microsoft/dcvc/DCVC-family/DCVC-FM/src/models/video_model.py code served (permissive licence) · get_code("0b4d24dfa9389a82") 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, ResidualBlockWithStride: 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)
def conv1x1(in_ch, out_ch, stride=1):
"""1x1 convolution."""
return nn.Conv2d(in_ch, out_ch, kernel_size=1, stride=stride)
def conv3x3(in_ch, out_ch, stride=1):
"""3x3 convolution with padding."""
return nn.Conv2d(in_ch, out_ch, kernel_size=3, stride=stride, padding=1)
class ResidualBlockWithStride(nn.Module):
"""Residual block with a stride on the first convolution.
Args:
in_ch (int): number of input channels
out_ch (int): number of output channels
stride (int): stride value (default: 2)
"""
def __init__(self, in_ch, out_ch, stride=2, inplace=False):
super().__init__()
self.conv1 = conv3x3(in_ch, out_ch, stride=stride)
self.leaky_relu = nn.LeakyReLU(inplace=inplace)
self.conv2 = conv3x3(out_ch, out_ch)
self.leaky_relu2 = nn.LeakyReLU(negative_slope=0.1, inplace=inplace)
if stride != 1:
self.downsample = conv1x1(in_ch, out_ch, stride=stride)
else:
self.downsample = None
def forward(self, x):
identity = x
out = self.conv1(x)
out = self.leaky_relu(out)
out = self.conv2(out)
out = self.leaky_relu2(out)
if self.downsample is not None:
identity = self.downsample(x)
out = out + identity
return out
ARGS = {
'in_ch': 3,
'out_ch': 4,
'stride': 2,
'inplace': False
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- torch — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type ResidualBlockWithStride — 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 ResidualBlockWithStride 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
|
| UNet2 |
Ran ran on a synthesized input · constructed an object; no result was computed |
microsoft/dcvc/DCVC-family/DCVC-FM/src/models/video_model.py code served (permissive licence) · get_code("a12a5eee4649c19e") 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, UNet2: 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)
# UNet2.__init__ takes: in_ch=64, out_ch=64, inplace=False
# UNet2.forward takes: x (a tensor)
# The forward method expects x to be a 4D tensor (batch, channels, height, width)
# in_ch=64 means input has 64 channels
# out_ch=64 means output has 64 channels
# Create a small input tensor: batch_size=2, in_ch=64, height=4, width=3
x = torch.randn(2, 64, 4, 3)
ARGS = {
'in_ch': 64,
'out_ch': 64,
'inplace': False,
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- torch — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type UNet2 — 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 UNet2 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
|
| bilineardownsacling |
Ran ran; our contract draft was wrong, not the code |
microsoft/dcvc/DCVC-family/DCVC-FM/src/models/video_model.py code served (permissive licence) · get_code("4ee1913b1f8ce86e") 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, 4, 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
import torch.nn.functional as F
torch.manual_seed(0)
# Create a small input tensor with shape (batch, channels, height, width)
# Using distinct sizes: batch=2, channels=4, height=8, width=6
inputfeature = torch.randn(2, 4, 8, 6)
ARGS = {
'inputfeature': inputfeature
}
- 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, 4, 3) — shape (2, 4, 4, 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
|
| bilinearupsacling |
Ran ran; our contract draft was wrong, not the code |
microsoft/dcvc/DCVC-family/DCVC-FM/src/models/video_model.py code served (permissive licence) · get_code("2c8c63d56261cb76") 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, 6, 10) 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 a small input tensor with shape (batch, channels, height, width)
# Using distinct sizes: batch=2, channels=4, height=3, width=5
inputfeature = torch.randn(2, 4, 3, 5)
ARGS = {
"inputfeature": inputfeature
}
- 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, 6, 10) — shape (2, 4, 6, 10) 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
|
| block_mc_func |
Ran ran; our contract draft was wrong, not the code |
microsoft/dcvc/DCVC-family/DCVC-FM/src/models/video_model.py code served (permissive licence) · get_code("da82b58aa9f6478c") 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, 8, 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
torch.manual_seed(0)
# Create small tensors for testing
batch_size = 2
channels = 4
height = 8
width = 6
# im: image tensor (B, C, H, W)
im = torch.randn(batch_size, channels, height, width, dtype=torch.float32)
# flow: optical flow tensor (B, 2, H, W)
# 2 channels for horizontal and vertical flow
flow = torch.randn(batch_size, 2, height, width, dtype=torch.float32)
ARGS = {
"im": im,
"flow": flow,
}
- 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, 8, 6) — shape (2, 4, 8, 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: none by the harness; any seed is in the setup block
|
| conv1x1 |
Ran ran; our contract draft was wrong, not the code |
microsoft/dcvc/DCVC-family/DCVC-FM/src/models/video_model.py code served (permissive licence) · get_code("ff496db6b866af12") 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 Conv2d. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import torch
from torch import nn
torch.manual_seed(0)
ARGS = {
"in_ch": 3,
"out_ch": 64,
"stride": 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 Conv2d — a Conv2d output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a Conv2d 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
|
| conv3x3 |
Ran ran; our contract draft was wrong, not the code |
microsoft/dcvc/DCVC-family/DCVC-FM/src/models/video_model.py code served (permissive licence) · get_code("194462a957fb0991") 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 Conv2d. 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 = {
"in_ch": 3,
"out_ch": 64,
"stride": 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 Conv2d — a Conv2d output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a Conv2d 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
|
| flow_warp |
Ran ran; our contract draft was wrong, not the code |
microsoft/dcvc/DCVC-family/DCVC-FM/src/models/video_model.py code served (permissive licence) · get_code("ca37ddb87705e620") 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, 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)
# Create small tensors for testing
# im: image tensor with shape (B, C, H, W)
# flow: optical flow tensor with shape (B, 2, H, W)
im = torch.randn(2, 4, 3, 5, dtype=torch.float32)
flow = torch.randn(2, 2, 3, 5, dtype=torch.float32)
ARGS = {
'im': im,
'flow': flow
}
- 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, 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: none by the harness; any seed is in the setup block
|
| get_downsampled_shape |
Ran ran, honoured the contract we drafted |
microsoft/dcvc/DCVC-family/DCVC-FM/src/models/video_model.py code served (permissive licence) · get_code("0c429d93ea07cde7") 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 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
torch.manual_seed(0)
# Analyzing the function:
# - height: int, used in arithmetic operations
# - width: int, used in arithmetic operations
# - p: int, used as divisor/multiplier in arithmetic operations
# The function performs downsampling calculations based on height, width, and a patch size p
ARGS = {
"height": 64,
"width": 48,
"p": 8
}
- 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 1, dtype family int — 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
|
| get_padding_size |
Ran ran, honoured the contract we drafted |
microsoft/dcvc/DCVC-family/DCVC-FM/src/models/video_model.py code served (permissive licence) · get_code("058564027e22df3c") 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 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 numpy as np
torch.manual_seed(0)
ARGS = {
"height": 100,
"width": 150,
"p": 64
}
- 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 tuple, ndim 1, dtype family int — 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
|
| subpel_conv1x1 |
Ran ran; our contract draft was wrong, not the code |
microsoft/dcvc/DCVC-family/DCVC-FM/src/models/video_model.py code served (permissive licence) · get_code("05d9e671c5f84bdb") How it ranRan in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned Sequential. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import torch
from torch import nn
torch.manual_seed(0)
ARGS = {
'in_ch': 3,
'out_ch': 64,
'r': 2
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- torch — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type Sequential — a Sequential output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a Sequential output the recorded ndim 1 and dtype family float describe that coercion, not the output, and are not stated
- Environment
- image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
|
| subpel_conv3x3 |
Ran ran; our contract draft was wrong, not the code |
microsoft/dcvc/DCVC-family/DCVC-FM/src/models/video_model.py code served (permissive licence) · get_code("c441c9f39e918e8a") How it ranRan in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned Sequential. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import torch
from torch import nn
torch.manual_seed(0)
ARGS = {
"in_ch": 3,
"out_ch": 16,
"r": 2
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- torch — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type Sequential — a Sequential output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a Sequential output the recorded ndim 1 and dtype family float describe that coercion, not the output, and are not stated
- Environment
- image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
|
| torch_warp |
Ran ran; our contract draft was wrong, not the code |
microsoft/dcvc/DCVC-family/DCVC-FM/src/models/video_model.py code served (permissive licence) · get_code("4ed6bbdfa756e1be") 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, 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)
# Create small tensors for the function
# feature: used in grid_sample as input, needs shape (B, C, H, W)
# flow: used to get size and access device, needs shape (B, 2, H, W) for optical flow
batch_size = 2
channels = 4
height = 3
width = 5
# feature tensor: (batch, channels, height, width)
feature = torch.randn(batch_size, channels, height, width, dtype=torch.float32)
# flow tensor: (batch, 2, height, width) - 2 channels for x and y flow
flow = torch.randn(batch_size, 2, height, width, dtype=torch.float32)
ARGS = {
'feature': feature,
'flow': flow
}
- 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, 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: none by the harness; any seed is in the setup block
|
| write_ip |
Ran ran, honoured the contract we drafted |
microsoft/dcvc/DCVC-family/DCVC-FM/src/models/video_model.py code served (permissive licence) · get_code("c8819fe99eeef17c") 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 enum
import struct
import io
class NalType(enum.IntEnum):
NAL_SPS = 0
NAL_I = 1
NAL_P = 2
NAL_Ps = 3
def write_bytes(fd, values, fmt='>{:d}s'):
if len(values) == 0:
return 0
fd.write(struct.pack(fmt.format(len(values)), values))
return len(values)
def write_uchars(fd, values, fmt='>{:d}B'):
fd.write(struct.pack(fmt.format(len(values)), *values))
return len(values)
def write_uint_adaptive(f, a):
if a <= 32767:
a0 = a & 255
a1 = a >> 8
write_uchars(f, (a1, a0))
return 2
assert a < 1 << 30
a0 = a & 255
a1 = a >> 8 & 255
a2 = a >> 16 & 255
a3 = a >> 24 & 255
a3 = a3 | 1 << 7
write_uchars(f, (a3, a2, a1, a0))
return 4
def write_ip(f, is_i_frame, sps_id, bit_stream):
written = 0
flag = (int(NalType.NAL_I if is_i_frame else NalType.NAL_P) << 4) + sps_id
written += write_uchars(f, (flag,))
written += write_uint_adaptive(f, len(bit_stream))
written += write_bytes(f, bit_stream)
return written
# Setup arguments for write_ip
f = io.BytesIO()
is_i_frame = True
sps_id = 2
bit_stream = b'\x00\x01\x02\x03\x04\x05'
ARGS = {
'f': f,
'is_i_frame': is_i_frame,
'sps_id': sps_id,
'bit_stream': bit_stream
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- none outside the standard library — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type int, ndim 0, dtype family int, shape () — shape () as a later run recorded it
- dtype family
- int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
- Environment
- image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
|
| write_uchars |
Ran ran; our contract draft was wrong, not the code |
microsoft/dcvc/DCVC-family/DCVC-FM/src/models/video_model.py code served (permissive licence) · get_code("cde57c4548df7988") 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 io
import struct
# Create a file-like object to write to
fd = io.BytesIO()
# Create valid unsigned char values (0-255 range)
values = [42, 100, 200, 15, 7]
# Format string for packing (default format)
fmt = '>{:d}B'
ARGS = {
'fd': fd,
'values': values,
'fmt': fmt
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- none outside the standard library — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type int, ndim 0, dtype family int, shape () — shape () as a later run recorded it
- dtype family
- int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
- Environment
- image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
|
| write_uint_adaptive |
Ran ran, honoured the contract we drafted |
microsoft/dcvc/DCVC-family/DCVC-FM/src/models/video_model.py code served (permissive licence) · get_code("1ec4dcdc3950ddfe") 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 struct
import io
def write_uchars(fd, values, fmt='>{:d}B'):
fd.write(struct.pack(fmt.format(len(values)), *values))
return len(values)
def write_uint_adaptive(f, a):
if a <= 32767:
a0 = a & 255
a1 = a >> 8
write_uchars(f, (a1, a0))
return 2
assert a < 1 << 30
a0 = a & 255
a1 = a >> 8 & 255
a2 = a >> 16 & 255
a3 = a >> 24 & 255
a3 = a3 | 1 << 7
write_uchars(f, (a3, a2, a1, a0))
return 4
# Create a file-like object for writing
f = io.BytesIO()
# Test with a small value (fits in 2 bytes)
a = 1000
ARGS = {
'f': f,
'a': a
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- none outside the standard library — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type int, ndim 0, dtype family int, shape () — shape () as a later run recorded it
- dtype family
- int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
- Environment
- image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
|
| CompressionModel |
Not yet run unverified (harvested, no recorded run) |
microsoft/dcvc/DCVC-family/DCVC-FM/src/models/video_model.py code served (permissive licence) · get_code("b04500057b53dc0d") How it ran |
| DMC |
Not yet run unverified (harvested, no recorded run) |
microsoft/dcvc/DCVC-family/DCVC-FM/src/models/video_model.py code served (permissive licence) · get_code("d0541ab1ef1f01d7") How it ran |
| EntropyCoder |
Not yet run unverified (harvested, no recorded run) |
microsoft/dcvc/DCVC-family/DCVC-FM/src/models/video_model.py code served (permissive licence) · get_code("8b1f88062c054aad") How it ran |
| ME_Spynet |
Not yet run unverified (harvested, no recorded run) |
microsoft/dcvc/DCVC-family/DCVC-FM/src/models/video_model.py code served (permissive licence) · get_code("8a52237f88c790c0") How it ran |
| NalType |
Not yet run unverified (harvested, no recorded run) |
microsoft/dcvc/DCVC-family/DCVC-FM/src/models/video_model.py code served (permissive licence) · get_code("b50de84040ba0329") How it ran |
| add_grid_cache |
Not yet run unverified (harvested, no recorded run) |
microsoft/dcvc/DCVC-family/DCVC-FM/src/models/video_model.py code served (permissive licence) · get_code("a3cc1c3e7b0b88aa") How it ran |
| write_bytes |
Not yet run unverified (harvested, no recorded run) |
microsoft/dcvc/DCVC-family/DCVC-FM/src/models/video_model.py code served (permissive licence) · get_code("395e86482196ce43") How it ran |