SYNTOLOGY HomeExplorerAtlasCodeMethodologyAboutDevelopersFeedPricing
Paper · 1606.00915 · IEEE Transactions on Pattern Analysis and Machine Intelligence · 2016

DeepLab: Semantic Image Segmentation with Deep Convolutional Nets, Atrous Convolution, and Fully Connected CRFs

Alan Yuille, Liang-Chieh Chen, Kevin Murphy, Iasonas Kokkinos, George Papandreou

arXiv · PDF · Open in the Atlas

Code that ran

43 of 63 samples (functions and classes) lifted from this paper's linked repositories executed on a synthesized input in Syntology's jail (12 of them constructed an object rather than computing a result; 2 honoured the contract we drafted, 0 violated it and 32 have no contract verdict; 9 failures of our instrument; 20 no recorded run), measured 2026-11-22; repository links from the Papers with Code archive attributed under CC BY-SA, no affiliation; bodies inline only under a permissive licence as GitHub detects it. Not a reproduction of the paper's results.

"Ran" means the function executed on a synthesized input and returned a value. It is not a reproduction of the paper's results. This record, dated, as JSON: /api/ran/1606.00915.json · badge: /api/ran/1606.00915.svg

Each repository's role is a label: a classifier's output recorded on the link, or, where no role is recorded, what the Papers with Code archive marked. The line under it names its basis. Neither says who wrote the code.

RepositoryRoleRan
eceo-epfl/scaleprotoseg community (classifier label)
classifier basis not recorded on the link
12 ran · 0 no recorded run
Media-Smart/vedaseg community
not in the paper's declared repositories
7 ran · 4 no recorded run
zllrunning/deeplab-pytorch-crf community
not in the paper's declared repositories
5 ran · 0 no recorded run
halbielee/EPS community
Papers with Code archive
4 ran · 0 no recorded run
Lxrd-AJ/Advanced_ML community
Papers with Code archive
3 ran · 0 no recorded run
cgsaxner/UB_Segmentation community (classifier label)
classifier basis not recorded on the link
2 ran · 3 no recorded run
aldo-aguilar/nu-style community (classifier label)
classifier basis not recorded on the link
2 ran · 2 no recorded run
warmspringwinds/pytorch-segmentation-detection community
not in the paper's declared repositories
2 ran · 0 no recorded run
yaq007/Autofocus-Layer community
not in the paper's declared repositories
2 ran · 0 no recorded run
DeepMotionAIResearch/DenseASPP community
Papers with Code archive
1 ran · 4 no recorded run
ShichengChen/WaveUNet community
Papers with Code archive
1 ran · 0 no recorded run
switchablenorms/SwitchNorm_Segmentation community
not in the paper's declared repositories
1 ran · 0 no recorded run
wangleihitcs/DeepLab-V1-PyTorch community
not in the paper's declared repositories
1 ran · 0 no recorded run
leimao/DeepLab-V3 community
Papers with Code archive
0 ran · 5 no recorded run
OIdiotLin/DeepLab-pytorch community
Papers with Code archive
0 ran · 1 no recorded run
Daeijavad/Deeplab-CRF community
not in the paper's declared repositories
0 ran · 1 no recorded run
FunctionStatusWhere it lives
ASPP Ran
ran on a synthesized input · constructed an object; no result was computed
warmspringwinds/pytorch-segmentation-detection/pytorch_segmentation_detection/models/deeplab.py
code served (permissive licence) · get_code("53f17388b003b9b6")
How it ran

Ran 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, ASPP: 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 numpy as np
import torch.nn as nn

torch.manual_seed(0)

def conv3x3(in_channels, out_channels, stride=1, dilation=1):
    """3x3 convolution with padding"""
    kernel_size = np.asarray((3, 3))
    upsampled_kernel_size = (kernel_size - 1) * (dilation - 1) + kernel_size
    full_padding = (upsampled_kernel_size - 1) // 2
    full_padding, kernel_size = (tuple(full_padding), tuple(kernel_size))
    return nn.Conv2d(in_channels, out_channels, kernel_size=kernel_size, stride=stride, padding=full_padding, dilation=dilation, bias=False)

class ASPP(nn.Module):

    def __init__(self, in_channels, out_channels_per_branch=256, branch_dilations=(6, 12, 18)):
        super(ASPP, self).__init__()
        self.relu = nn.ReLU(inplace=True)
        self.conv_1x1 = nn.Conv2d(in_channels=in_channels, out_channels=out_channels_per_branch, kernel_size=1, bias=False)
        self.conv_1x1_bn = torch.nn.BatchNorm2d(num_features=out_channels_per_branch)
        self.conv_3x3_first = conv3x3(in_channels, out_channels_per_branch, dilation=branch_dilations[0])
        self.conv_3x3_first_bn = torch.nn.BatchNorm2d(num_features=out_channels_per_branch)
        self.conv_3x3_second = conv3x3(in_channels, out_channels_per_branch, dilation=branch_dilations[1])
        self.conv_3x3_second_bn = torch.nn.BatchNorm2d(num_features=out_channels_per_branch)
        self.conv_3x3_third = conv3x3(in_channels, out_channels_per_branch, dilation=branch_dilations[2])
        self.conv_3x3_third_bn = torch.nn.BatchNorm2d(num_features=out_channels_per_branch)
        self.conv_1x1_pool = nn.Conv2d(in_channels=in_channels, out_channels=out_channels_per_branch, kernel_size=1, bias=False)
        self.conv_1x1_pool_bn = torch.nn.BatchNorm2d(num_features=out_channels_per_branch)
        self.conv_1x1_final = nn.Conv2d(in_channels=out_channels_per_branch * 5, out_channels=out_channels_per_branch, kernel_size=1, bias=False)
        self.conv_1x1_final_bn = torch.nn.BatchNorm2d(num_features=out_channels_per_branch)

    def forward(self, x):
        input_spatial_dim = x.size()[2:]
        conv_1x1_branch = self.relu(self.conv_1x1_bn(self.conv_1x1(x)))
        conv_3x3_first_branch = self.relu(self.conv_3x3_first_bn(self.conv_3x3_first(x)))
        conv_3x3_second_branch = self.relu(self.conv_3x3_second_bn(self.conv_3x3_second(x)))
        conv_3x3_third_branch = self.relu(self.conv_3x3_third_bn(self.conv_3x3_third(x)))
        global_pool_branch = self.relu(self.conv_1x1_pool_bn(self.conv_1x1_pool(nn.functional.adaptive_avg_pool2d(x, 1))))
        global_pool_branch = nn.functional.upsample_bilinear(input=global_pool_branch, size=input_spatial_dim)
        features_concatenated = torch.cat([conv_1x1_branch, conv_3x3_first_branch, conv_3x3_second_branch, conv_3x3_third_branch, global_pool_branch], dim=1)
        features_fused = self.relu(self.conv_1x1_final_bn(self.conv_1x1_final(features_concatenated)))
        return features_fused

ARGS = {
    'in_channels': 64,
    'out_channels_per_branch': 256,
    'branch_dilations': (6, 12, 18)
}
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 ASPP — 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 ASPP 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
ASPPConv Ran
ran on a synthesized input · constructed an object; no result was computed
Media-Smart/vedaseg/vedaseg/models/encoders/enhance_modules/aspp.py
code served (permissive licence) · get_code("308ccdb3fbb740d8")
How it ran

Ran 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, ASPPConv: 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 arguments for ASPPConv
in_channels = 4
out_channels = 8
dilation = 2
norm_layer = nn.BatchNorm2d
act_layer = nn.ReLU

ARGS = {
    'in_channels': in_channels,
    'out_channels': out_channels,
    'dilation': dilation,
    'norm_layer': norm_layer,
    'act_layer': act_layer,
}
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 ASPPConv — 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 ASPPConv 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
ASPPPooling Ran
ran on a synthesized input · constructed an object; no result was computed
Media-Smart/vedaseg/vedaseg/models/encoders/enhance_modules/aspp.py
code served (permissive licence) · get_code("1ded95feb039492a")
How it ran

Ran 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, ASPPPooling: 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 norm_layer - a simple BatchNorm2d
norm_layer = nn.BatchNorm2d

# Define act_layer - a simple ReLU
act_layer = nn.ReLU

# Arguments for ASPPPooling.__init__
ARGS = {
    'in_channels': 64,
    'out_channels': 32,
    'norm_layer': norm_layer,
    'act_layer': act_layer,
    'mode': 'bilinear',
    'align_corners': True
}
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 ASPPPooling — 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 ASPPPooling 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
ASPP_c Ran
ran on a synthesized input
yaq007/Autofocus-Layer/models.py
code served (permissive licence) · get_code("6dc0febe733fd5b9")
How it ran

Ran 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 5, dtype family float; no output shape is stated. The image it ran in was not recorded. If your copy returns the same type and ndim on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch
import torch.nn as nn

INIT_ARGS = {
    'dilation_list': [1, 2, 3, 4],
    'channels': [3, 8, 12, 16, 20, 24, 28, 32, 36, 40],
    'kernel_size': 3,
    'num_branches': 4
}

# The model processes 3D data through multiple conv layers with specific padding requirements
# After conv1 (kernel=3): spatial dims reduce by 2 on each side
# After conv2 (kernel=3): spatial dims reduce by 2 more on each side
# After layer3 (BasicBlock with dilation=2, kernel=3): reduces by 8 on each side (4 per conv)
# After layer4: reduces by 8 more
# After layer5: reduces by 8 more
# Total reduction before ASPP: 2+2+8+8+8 = 28 on each side, so 56 total per spatial dim
# To get a reasonable output, input spatial dims should be at least 60

x = torch.randn(2, 3, 64, 64, 64)

ARGS = {
    'x': x
}
Setup block drafted by
a language model, class construct-then-call prompt, model not recorded
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type Tensor, ndim 5, 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)
ASPP_module Ran
ran on a synthesized input · constructed an object; no result was computed
ShichengChen/WaveUNet/pytorch-pyrmaid/networks/deeplab_xception.py
code served (permissive licence) · get_code("88e7802a88d1a1f9")
How it ran

Ran 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, ASPP_module: 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 = {
    "inplanes": 64,
    "planes": 128,
    "rate": 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 ASPP_module — 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 ASPP_module 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
BasicBlock Ran
ran on a synthesized input
yaq007/Autofocus-Layer/models.py
code served (permissive licence) · get_code("44f2f26a9ed8d32f")
How it ran

Ran 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 5, dtype family float, shape (2, 4, 16, 16, 16) as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch
import torch.nn as nn

class BasicBlock(nn.Module):

    def __init__(self, inplanes1, outplanes1, outplanes2, kernel=3, downsample=None):
        super(BasicBlock, self).__init__()
        self.conv1 = nn.Conv3d(inplanes1, outplanes1, kernel_size=kernel, dilation=2)
        self.bn1 = nn.BatchNorm3d(outplanes1)
        self.conv2 = nn.Conv3d(outplanes1, outplanes2, kernel_size=kernel, dilation=2)
        self.bn2 = nn.BatchNorm3d(outplanes2)
        self.relu = nn.ReLU(inplace=True)
        if inplanes1 == outplanes2:
            self.downsample = downsample
        else:
            self.downsample = nn.Sequential(nn.Conv3d(inplanes1, outplanes2, kernel_size=1), nn.BatchNorm3d(outplanes2))
        for m in self.modules():
            if isinstance(m, nn.Conv3d):
                m.weight.data.normal_(0, 0.01)
            elif isinstance(m, nn.BatchNorm3d):
                m.weight.data.fill_(1)
                m.bias.data.zero_()

    def forward(self, x):
        residual = x[:, :, 4:-4, 4:-4, 4:-4]
        x = self.conv1(x)
        x = self.bn1(x)
        x = self.relu(x)
        x = self.conv2(x)
        x = self.bn2(x)
        if self.downsample is not None:
            residual = self.downsample(residual)
        x += residual
        x = self.relu(x)
        return x


INIT_ARGS = {
    'inplanes1': 3,
    'outplanes1': 4,
    'outplanes2': 4,
    'kernel': 3,
    'downsample': None,
}

ARGS = {
    'x': torch.randn(2, 3, 24, 24, 24),
}

if __name__ == '__main__':
    block = BasicBlock(**INIT_ARGS)
    output = block(**ARGS)
    print(f"Output shape: {output.shape}")
Setup block drafted by
a language model, class construct-then-call prompt, model not recorded
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type Tensor, ndim 5, dtype family float, shape (2, 4, 16, 16, 16) — shape (2, 4, 16, 16, 16) as a later run recorded it
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: torch and numpy seeded to 0 by the harness immediately before the class was constructed from INIT_ARGS (fixture_check.py)
DeepLabV2 Ran
ran on a synthesized input
zllrunning/deeplab-pytorch-crf/libs/models/deeplabv2.py
code served (permissive licence) · get_code("5d9bd49de1275265")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, class construct-then-call prompt, model not recorded) and returned Tensor, ndim 4, dtype family float; no output shape is stated. The image it ran in was not recorded. If your copy returns the same type and ndim on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch
import numpy as np
from collections import OrderedDict

INIT_ARGS = {
    'n_classes': 4,
    'n_blocks': [1, 1, 1, 1],
    'pyramids': [1, 2, 3]
}

# Create input tensor: batch_size=2, channels=3, height=8, width=6
input_tensor = torch.randn(2, 3, 8, 6)

ARGS = {
    'x': input_tensor
}
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 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)
FRN Ran
ran on a synthesized input · constructed an object; no result was computed
Media-Smart/vedaseg/vedaseg/models/encoders/enhance_modules/aspp.py
code served (permissive licence) · get_code("116bb1dc1ccdde04")
How it ran

Ran 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, FRN: 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
from torch.nn.parameter import Parameter

torch.manual_seed(0)

class FRN(nn.Module):

    def __init__(self, num_features, eps=1e-06):
        super(FRN, self).__init__()
        self.num_features = num_features
        self.gamma = Parameter(torch.Tensor(1, num_features, 1, 1), requires_grad=True)
        self.beta = Parameter(torch.Tensor(1, num_features, 1, 1), requires_grad=True)
        self.register_buffer('eps', torch.Tensor([eps]))
        self.reset_parameters()

    def reset_parameters(self):
        nn.init.ones_(self.gamma)
        nn.init.zeros_(self.beta)

    def forward(self, x):
        nu2 = torch.mean(x.pow(2), dim=[2, 3], keepdim=True)
        x = x * torch.rsqrt(nu2 + self.eps.abs())
        x = self.gamma * x + self.beta
        return x

    def extra_repr(self):
        return '{num_features}, eps={eps}'.format(**self.__dict__)


# Create test input tensor: batch_size=2, num_features=4, height=3, width=5
test_input = torch.randn(2, 4, 3, 5)

ARGS = {
    'num_features': 4,
    'eps': 1e-06
}
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 FRN — 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 FRN 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
Net Ran
ran on a synthesized input
halbielee/EPS/network/resnet38d.py
pointer only (licence: NONE) · get_code("09eb18c5d7d60dfc")
How it ran

The body of this sample is withheld: GitHub detected no licence in this paper's repository, halbielee/EPS when it was checked. The setup block that called it is withheld with it, because it is written against that body. source_path and origin say where the code lives, to read under the repository's own terms. A run is recorded.

Normalize Ran
ran on a synthesized input
halbielee/EPS/network/resnet38d.py
pointer only (licence: NONE) · get_code("bb0ad51ace15dbe4")
How it ran

The body of this sample is withheld: GitHub detected no licence in this paper's repository, halbielee/EPS when it was checked. The setup block that called it is withheld with it, because it is written against that body. source_path and origin say where the code lives, to read under the repository's own terms. A run is recorded.

Registry Ran
ran on a synthesized input · constructed an object; no result was computed
Media-Smart/vedaseg/vedaseg/models/encoders/enhance_modules/aspp.py
code served (permissive licence) · get_code("d18cf36c9276960f")
How it ran

Ran 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, Registry: 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 inspect
from functools import partial

# Define a minimal test module class
class SimpleModule(torch.nn.Module):
    def __init__(self):
        super().__init__()
        self.linear = torch.nn.Linear(4, 2)
    
    def forward(self, x):
        return self.linear(x)

# Define another test module class
class AnotherModule(torch.nn.Module):
    def __init__(self):
        super().__init__()
        self.conv = torch.nn.Conv1d(4, 8, 3)
    
    def forward(self, x):
        return self.conv(x)

# Construct ARGS
ARGS = {
    'name': 'test_registry'
}
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 Registry — 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 Registry 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
halbielee/EPS/network/resnet38d.py
pointer only (licence: NONE) · get_code("c844437a798458b7")
How it ran

The body of this sample is withheld: GitHub detected no licence in this paper's repository, halbielee/EPS when it was checked. The setup block that called it is withheld with it, because it is written against that body. source_path and origin say where the code lives, to read under the repository's own terms. A run is recorded.

ResBlock_bot Ran
ran on a synthesized input
halbielee/EPS/network/resnet38d.py
pointer only (licence: NONE) · get_code("282223ddd3ff3f7c")
How it ran

The body of this sample is withheld: GitHub detected no licence in this paper's repository, halbielee/EPS when it was checked. The setup block that called it is withheld with it, because it is written against that body. source_path and origin say where the code lives, to read under the repository's own terms. A run is recorded.

ResnetDilated Ran
ran on a synthesized input · constructed an object; no result was computed
switchablenorms/SwitchNorm_Segmentation/models/models.py
pointer only (licence: NONE) · get_code("d8bef07c9adf425e")
How it ran

The body of this sample is withheld: GitHub detected no licence in this paper's repository, switchablenorms/SwitchNorm_Segmentation when it was checked. The setup block that called it is withheld with it, because it is written against that body. source_path and origin say where the code lives, to read under the repository's own terms. A run is recorded.

TLU Ran
ran on a synthesized input · constructed an object; no result was computed
Media-Smart/vedaseg/vedaseg/models/encoders/enhance_modules/aspp.py
code served (permissive licence) · get_code("82583067173f244a")
How it ran

Ran 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, TLU: 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)

# TLU takes one parameter: num_features (int)
num_features = 4

ARGS = {
    'num_features': num_features
}
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 TLU — 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 TLU 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
UNet Ran
ran on a synthesized input · constructed an object; no result was computed
Lxrd-AJ/Advanced_ML/Implementation/unet_model.py
pointer only (licence: NONE) · get_code("eb36d73a1d6a9211")
How it ran

The body of this sample is withheld: GitHub detected no licence in this paper's repository, Lxrd-AJ/Advanced_ML when it was checked. The setup block that called it is withheld with it, because it is written against that body. source_path and origin say where the code lives, to read under the repository's own terms. A run is recorded.

UNetConv2D Ran
ran on a synthesized input · constructed an object; no result was computed
Lxrd-AJ/Advanced_ML/Implementation/unet_model.py
pointer only (licence: NONE) · get_code("964a4d471b87d037")
How it ran

The body of this sample is withheld: GitHub detected no licence in this paper's repository, Lxrd-AJ/Advanced_ML when it was checked. The setup block that called it is withheld with it, because it is written against that body. source_path and origin say where the code lives, to read under the repository's own terms. A run is recorded.

UNetUpConv2D Ran
ran on a synthesized input
Lxrd-AJ/Advanced_ML/Implementation/unet_model.py
pointer only (licence: NONE) · get_code("311989e0cef13762")
How it ran

The body of this sample is withheld: GitHub detected no licence in this paper's repository, Lxrd-AJ/Advanced_ML when it was checked. The setup block that called it is withheld with it, because it is written against that body. source_path and origin say where the code lives, to read under the repository's own terms. A run is recorded.

VGG16_LargeFOV Ran
ran on a synthesized input · constructed an object; no result was computed
wangleihitcs/DeepLab-V1-PyTorch/nets/vgg.py
pointer only (licence: NONE) · get_code("85fce95aedb122ac")
How it ran

The body of this sample is withheld: GitHub detected no licence in this paper's repository, wangleihitcs/DeepLab-V1-PyTorch when it was checked. The setup block that called it is withheld with it, because it is written against that body. source_path and origin say where the code lives, to read under the repository's own terms. A run is recorded.

_ASPPModule Ran
ran on a synthesized input
zllrunning/deeplab-pytorch-crf/libs/models/deeplabv2.py
code served (permissive licence) · get_code("3d1880c02d075eba")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, class construct-then-call prompt, model not recorded) and returned Tensor, ndim 4, dtype family float, shape (2, 4, 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
import torch.nn as nn

INIT_ARGS = {
    'in_channels': 3,
    'out_channels': 4,
    'pyramids': [1, 2, 4]
}

ARGS = {
    'x': torch.randn(2, 3, 8, 6)
}

if __name__ == '__main__':
    model = nn.Module()
    
    class _ASPPModule(nn.Module):
        """Atrous Spatial Pyramid Pooling"""

        def __init__(self, in_channels, out_channels, pyramids):
            super(_ASPPModule, self).__init__()
            self.stages = nn.Module()
            for i, (dilation, padding) in enumerate(zip(pyramids, pyramids)):
                self.stages.add_module('c{}'.format(i), nn.Conv2d(in_channels=in_channels, out_channels=out_channels, kernel_size=3, stride=1, padding=padding, dilation=dilation, bias=True))
            for m in self.stages.children():
                nn.init.normal_(m.weight, mean=0, std=0.01)
                nn.init.constant_(m.bias, 0)

        def forward(self, x):
            h = 0
            for stage in self.stages.children():
                h += stage(x)
            return h
    
    model = _ASPPModule(**INIT_ARGS)
    output = model(**ARGS)
    print(f"Output shape: {output.shape}")
    print(f"Output: {output}")
Setup block drafted by
a language model, class construct-then-call prompt, model not recorded
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type Tensor, ndim 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: torch and numpy seeded to 0 by the harness immediately before the class was constructed from INIT_ARGS (fixture_check.py)
_Bottleneck Ran
ran on a synthesized input
zllrunning/deeplab-pytorch-crf/libs/models/deeplabv2.py
code served (permissive licence) · get_code("84e049f7b9fa13b7")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, class construct-then-call prompt, model not recorded) and returned Tensor, ndim 4, dtype family float, shape (2, 4, 16, 16) as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch
import torch.nn as nn
import torch.nn.functional as F

class _ConvBatchNormReLU(nn.Sequential):

    def __init__(self, in_channels, out_channels, kernel_size, stride, padding, dilation, relu=True):
        super(_ConvBatchNormReLU, self).__init__()
        self.add_module('conv', nn.Conv2d(in_channels=in_channels, out_channels=out_channels, kernel_size=kernel_size, stride=stride, padding=padding, dilation=dilation, bias=False))
        self.add_module('bn', nn.BatchNorm2d(num_features=out_channels, eps=1e-05, momentum=0.999, affine=True))
        if relu:
            self.add_module('relu', nn.ReLU())

    def forward(self, x):
        return super(_ConvBatchNormReLU, self).forward(x)

class _Bottleneck(nn.Sequential):
    """Bottleneck Unit"""

    def __init__(self, in_channels, mid_channels, out_channels, stride, dilation, downsample):
        super(_Bottleneck, self).__init__()
        self.reduce = _ConvBatchNormReLU(in_channels, mid_channels, 1, stride, 0, 1)
        self.conv3x3 = _ConvBatchNormReLU(mid_channels, mid_channels, 3, 1, dilation, dilation)
        self.increase = _ConvBatchNormReLU(mid_channels, out_channels, 1, 1, 0, 1, relu=False)
        self.downsample = downsample
        if self.downsample:
            self.proj = _ConvBatchNormReLU(in_channels, out_channels, 1, stride, 0, 1, relu=False)

    def forward(self, x):
        h = self.reduce(x)
        h = self.conv3x3(h)
        h = self.increase(h)
        if self.downsample:
            h += self.proj(x)
        else:
            h += x
        return F.relu(h)


INIT_ARGS = {
    'in_channels': 4,
    'mid_channels': 8,
    'out_channels': 4,
    'stride': 1,
    'dilation': 1,
    'downsample': False,
}

ARGS = {
    'x': torch.randn(2, 4, 16, 16),
}
Setup block drafted by
a language model, class construct-then-call prompt, model not recorded
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type Tensor, ndim 4, dtype family float, shape (2, 4, 16, 16) — shape (2, 4, 16, 16) as a later run recorded it
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: torch and numpy seeded to 0 by the harness immediately before the class was constructed from INIT_ARGS (fixture_check.py)
_ConvBatchNormReLU Ran
ran on a synthesized input
zllrunning/deeplab-pytorch-crf/libs/models/deeplabv2.py
code served (permissive licence) · get_code("6cd27134d67d87a8")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, class construct-then-call prompt, model not recorded) and returned Tensor, ndim 4, dtype family float, shape (2, 4, 8, 8) as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch
import torch.nn as nn

class _ConvBatchNormReLU(nn.Sequential):

    def __init__(self, in_channels, out_channels, kernel_size, stride, padding, dilation, relu=True):
        super(_ConvBatchNormReLU, self).__init__()
        self.add_module('conv', nn.Conv2d(in_channels=in_channels, out_channels=out_channels, kernel_size=kernel_size, stride=stride, padding=padding, dilation=dilation, bias=False))
        self.add_module('bn', nn.BatchNorm2d(num_features=out_channels, eps=1e-05, momentum=0.999, affine=True))
        if relu:
            self.add_module('relu', nn.ReLU())

    def forward(self, x):
        return super(_ConvBatchNormReLU, self).forward(x)


INIT_ARGS = {
    'in_channels': 3,
    'out_channels': 4,
    'kernel_size': 3,
    'stride': 1,
    'padding': 1,
    'dilation': 1,
    'relu': True
}

ARGS = {
    'x': torch.randn(2, 3, 8, 8)
}

model = _ConvBatchNormReLU(**INIT_ARGS)
output = model(**ARGS)
Setup block drafted by
a language model, class construct-then-call prompt, model not recorded
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type Tensor, ndim 4, dtype family float, shape (2, 4, 8, 8) — shape (2, 4, 8, 8) as a later run recorded it
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: torch and numpy seeded to 0 by the harness immediately before the class was constructed from INIT_ARGS (fixture_check.py)
_ResBlock Ran
ran on a synthesized input
zllrunning/deeplab-pytorch-crf/libs/models/deeplabv2.py
code served (permissive licence) · get_code("ae539753ae4d52c4")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, class construct-then-call prompt, model not recorded) and returned Tensor, ndim 4, dtype family float, shape (2, 5, 4, 4) as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch
import torch.nn as nn
import torch.nn.functional as F

class _ConvBatchNormReLU(nn.Sequential):
    def __init__(self, in_channels, out_channels, kernel_size, stride, padding, dilation, relu=True):
        super(_ConvBatchNormReLU, self).__init__()
        self.add_module('conv', nn.Conv2d(in_channels=in_channels, out_channels=out_channels, kernel_size=kernel_size, stride=stride, padding=padding, dilation=dilation, bias=False))
        self.add_module('bn', nn.BatchNorm2d(num_features=out_channels, eps=1e-05, momentum=0.999, affine=True))
        if relu:
            self.add_module('relu', nn.ReLU())

    def forward(self, x):
        return super(_ConvBatchNormReLU, self).forward(x)

class _Bottleneck(nn.Sequential):
    """Bottleneck Unit"""

    def __init__(self, in_channels, mid_channels, out_channels, stride, dilation, downsample):
        super(_Bottleneck, self).__init__()
        self.reduce = _ConvBatchNormReLU(in_channels, mid_channels, 1, stride, 0, 1)
        self.conv3x3 = _ConvBatchNormReLU(mid_channels, mid_channels, 3, 1, dilation, dilation)
        self.increase = _ConvBatchNormReLU(mid_channels, out_channels, 1, 1, 0, 1, relu=False)
        self.downsample = downsample
        if self.downsample:
            self.proj = _ConvBatchNormReLU(in_channels, out_channels, 1, stride, 0, 1, relu=False)

    def forward(self, x):
        h = self.reduce(x)
        h = self.conv3x3(h)
        h = self.increase(h)
        if self.downsample:
            h += self.proj(x)
        else:
            h += x
        return F.relu(h)

class _ResBlock(nn.Sequential):
    """Residual Block"""

    def __init__(self, n_layers, in_channels, mid_channels, out_channels, stride, dilation, mg=None):
        super(_ResBlock, self).__init__()
        if mg is None:
            mg = [1 for _ in range(n_layers)]
        else:
            assert n_layers == len(mg), '{} values expected, but got: mg={}'.format(n_layers, mg)
        self.add_module('block1', _Bottleneck(in_channels, mid_channels, out_channels, stride, dilation * mg[0], True))
        for i, g in zip(range(2, n_layers + 1), mg[1:]):
            self.add_module('block' + str(i), _Bottleneck(out_channels, mid_channels, out_channels, 1, dilation * g, False))

    def __call__(self, x):
        return super(_ResBlock, self).forward(x)

INIT_ARGS = {
    'n_layers': 2,
    'in_channels': 4,
    'mid_channels': 3,
    'out_channels': 5,
    'stride': 2,
    'dilation': 1,
    'mg': None
}

ARGS = {
    'x': torch.randn(2, 4, 8, 8)
}

if __name__ == '__main__':
    model = _ResBlock(**INIT_ARGS)
    output = model(**ARGS)
    print(f"Output shape: {output.shape}")
    print(f"Output: {output}")
Setup block drafted by
a language model, class construct-then-call prompt, model not recorded
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type Tensor, ndim 4, dtype family float, shape (2, 5, 4, 4) — shape (2, 5, 4, 4) as a later run recorded it
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: torch and numpy seeded to 0 by the harness immediately before the class was constructed from INIT_ARGS (fixture_check.py)
_Transition Ran
ran on a synthesized input · constructed an object; no result was computed
DeepMotionAIResearch/DenseASPP/models/DenseASPP.py
pointer only (licence: NONE) · get_code("6dc18b4169cafab5")
How it ran

The body of this sample is withheld: GitHub detected no licence in this paper's repository, DeepMotionAIResearch/DenseASPP when it was checked. The setup block that called it is withheld with it, because it is written against that body. source_path and origin say where the code lives, to read under the repository's own terms. A run is recorded.

bilinear_upsampling_weights Ran
ran on a synthesized input
cgsaxner/UB_Segmentation/upsampling.py
code served (permissive licence) · get_code("d241a51429ebbb55")
How it ran

Ran 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 ndarray, ndim 4, dtype family float, shape (4, 4, 3, 3) as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import numpy as np

# Construct arguments for bilinear_upsampling_weights
ARGS = {
    "factor": 2,
    "num_channels": 3,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type ndarray, ndim 4, dtype family float, shape (4, 4, 3, 3) — shape (4, 4, 3, 3) as a later run recorded it
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
build_act_layer Ran
ran; our contract draft was wrong, not the code
Media-Smart/vedaseg/vedaseg/models/encoders/enhance_modules/aspp.py
code served (permissive licence) · get_code("0f5c1cdac6542626")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned tuple, ndim 1, dtype family float; no output shape is stated. The image it ran in was not recorded. If your copy returns the same type and ndim on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch
import torch.nn as nn
from torch.nn.parameter import Parameter

torch.manual_seed(0)

class TLU(nn.Module):

    def __init__(self, num_features):
        super(TLU, self).__init__()
        self.num_features = num_features
        self.tau = Parameter(torch.Tensor(1, num_features, 1, 1), requires_grad=True)
        self.reset_parameters()

    def reset_parameters(self):
        nn.init.zeros_(self.tau)

    def forward(self, x):
        return torch.max(x, self.tau)

    def extra_repr(self):
        return '{num_features}'.format(**self.__dict__)

act_cfg = {'Relu': ('relu', nn.ReLU), 'Tlu': ('tlu', TLU)}

def build_act_layer(cfg, num_features, postfix='', layer_only=False):
    """ Build activate layer

    Args:
        cfg (dict): cfg should contain:
            type (str): identify activate layer type.
            layer args: args needed to instantiate a activate layer.
            requires_grad (bool): [optional] whether stop gradient updates
        num_features (int): number of channels from input.
        postfix (int, str): appended into act abbreviation to
            create named layer.

    Returns:
        name (str): abbreviation + postfix
        layer (nn.Module): created act layer
    """
    assert isinstance(cfg, dict) and 'type' in cfg
    cfg_ = cfg.copy()
    layer_type = cfg_.pop('type')
    if layer_type not in act_cfg:
        raise KeyError('Unrecognized activate type {}'.format(layer_type))
    else:
        abbr, act_layer = act_cfg[layer_type]
        if act_layer is None:
            raise NotImplementedError
    assert isinstance(postfix, (int, str))
    name = abbr + str(postfix)
    requires_grad = cfg_.pop('requires_grad', True)
    if layer_type != 'Tlu':
        layer = act_layer(**cfg_)
    else:
        layer = act_layer(num_features, **cfg_)
    for param in layer.parameters():
        param.requires_grad = requires_grad
    if layer_only:
        return layer
    else:
        return (name, layer)

ARGS = {
    'cfg': {'type': 'Tlu', 'requires_grad': True},
    'num_features': 4,
    'postfix': '_0',
    'layer_only': 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 tuple, ndim 1, dtype family float — a tuple output has no array shape of its own; none is stated
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
build_norm_layer Ran
ran; our contract draft was wrong, not the code
Media-Smart/vedaseg/vedaseg/models/encoders/enhance_modules/aspp.py
code served (permissive licence) · get_code("fcbdd0b7fa92032b")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned tuple, ndim 1, dtype family float; no output shape is stated. The image it ran in was not recorded. If your copy returns the same type and ndim on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch
import torch.nn as nn
from torch.nn.parameter import Parameter

torch.manual_seed(0)

class FRN(nn.Module):

    def __init__(self, num_features, eps=1e-06):
        super(FRN, self).__init__()
        self.num_features = num_features
        self.gamma = Parameter(torch.Tensor(1, num_features, 1, 1), requires_grad=True)
        self.beta = Parameter(torch.Tensor(1, num_features, 1, 1), requires_grad=True)
        self.register_buffer('eps', torch.Tensor([eps]))
        self.reset_parameters()

    def reset_parameters(self):
        nn.init.ones_(self.gamma)
        nn.init.zeros_(self.beta)

    def forward(self, x):
        nu2 = torch.mean(x.pow(2), dim=[2, 3], keepdim=True)
        x = x * torch.rsqrt(nu2 + self.eps.abs())
        x = self.gamma * x + self.beta
        return x

    def extra_repr(self):
        return '{num_features}, eps={eps}'.format(**self.__dict__)

norm_cfg = {'FRN': ('frn', FRN), 'BN': ('bn', nn.BatchNorm2d), 'SyncBN': ('bn', nn.SyncBatchNorm), 'GN': ('gn', nn.GroupNorm)}

def build_norm_layer(cfg, num_features, postfix='', layer_only=False):
    """ Build normalization layer

    Args:
        cfg (dict): cfg should contain:
            type (str): identify norm layer type.
            layer args: args needed to instantiate a norm layer.
            requires_grad (bool): [optional] whether stop gradient updates
        num_features (int): number of channels from input.
        postfix (int, str): appended into norm abbreviation to
            create named layer.

    Returns:
        name (str): abbreviation + postfix
        layer (nn.Module): created norm layer
    """
    assert isinstance(cfg, dict) and 'type' in cfg
    cfg_ = cfg.copy()
    layer_type = cfg_.pop('type')
    if layer_type not in norm_cfg:
        raise KeyError('Unrecognized norm type {}'.format(layer_type))
    else:
        abbr, norm_layer = norm_cfg[layer_type]
        if norm_layer is None:
            raise NotImplementedError
    assert isinstance(postfix, (int, str))
    name = abbr + str(postfix)
    requires_grad = cfg_.pop('requires_grad', True)
    if layer_type != 'GN':
        layer = norm_layer(num_features, **cfg_)
        if layer_type == 'SyncBN':
            layer._specify_ddp_gpu_num(1)
    else:
        assert 'num_groups' in cfg_
        layer = norm_layer(num_channels=num_features, **cfg_)
    for param in layer.parameters():
        param.requires_grad = requires_grad
    if layer_only:
        return layer
    return (name, layer)

ARGS = {
    'cfg': {'type': 'FRN', 'eps': 1e-6},
    'num_features': 8,
    'postfix': '0',
    'layer_only': 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 tuple, ndim 1, dtype family float — a tuple output has no array shape of its own; none is stated
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
compute_layer_rf_info Ran
ran on a synthesized input
eceo-epfl/scaleprotoseg/receptive_field.py
code served (permissive licence) · get_code("c2f4bd843f1e0e47")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned list, ndim 1, dtype family 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 math

# Analyze the function:
# - layer_filter_size: int (used in math operations)
# - layer_stride: int (used in math operations)
# - layer_padding: str or int (checked against 'SAME' and 'VALID', or used as int)
# - previous_layer_rf_info: tuple/list with 4 elements [n_in, j_in, r_in, start_in]
#   where each element is a number (int or float)

# Create valid arguments for a typical CNN layer computation
# Using a simple case: 3x3 kernel, stride 1, SAME padding, starting from input layer

previous_layer_rf_info = [224, 1, 1, 0.5]  # n_in=224, j_in=1, r_in=1, start_in=0.5

ARGS = {
    "layer_filter_size": 3,
    "layer_stride": 1,
    "layer_padding": "SAME",
    "previous_layer_rf_info": previous_layer_rf_info
}
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 list, ndim 1, dtype family float — a list output has no array shape of its own; none is stated
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
compute_rf_protoL_at_spatial_location Ran
ran on a synthesized input
eceo-epfl/scaleprotoseg/receptive_field.py
code served (permissive licence) · get_code("efb66ddd03d907f4")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned list, ndim 1, dtype family int; no output shape is stated. The image it ran in was not recorded. If your copy returns the same type and ndim on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch
import numpy as np

torch.manual_seed(0)

# Analyze the function:
# - img_height: int (used for comparison and min operation)
# - img_width: int (used for comparison and min operation)
# - height_index: int (used for comparison and arithmetic)
# - width_index: int (used for comparison and arithmetic)
# - protoL_rf_info: tuple/list with 4 elements [n, j, r, start]
#   - n: int (used for assertion comparison)
#   - j: int (used for multiplication)
#   - r: int (used for division and arithmetic)
#   - start: int (used for addition)

ARGS = {
    "img_height": 224,
    "img_width": 224,
    "height_index": 2,
    "width_index": 3,
    "protoL_rf_info": [10, 16, 51, 75]
}
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 list, ndim 1, dtype family int — a list output has no array shape of its own; none is stated
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
compute_rf_prototype Ran
ran on a synthesized input
eceo-epfl/scaleprotoseg/receptive_field.py
code served (permissive licence) · get_code("efea10148e03ffc4")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned list, ndim 1, dtype family int; no output shape is stated. The image it ran in was not recorded. If your copy returns the same type and ndim on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch

torch.manual_seed(0)

# Construct protoL_rf_info tuple
# protoL_rf_info = (n, j, r, start)
# n: number of prototypes in height/width dimension
# j: stride/jump between prototype centers
# r: receptive field size
# start: starting offset
protoL_rf_info = (5, 2, 8, 1)

# Construct prototype_patch_index tuple
# prototype_patch_index = (img_index, height_index, width_index)
prototype_patch_index = (0, 2, 3)

# Image size
img_size = 224

ARGS = {
    "img_size": img_size,
    "prototype_patch_index": prototype_patch_index,
    "protoL_rf_info": protoL_rf_info,
}
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 list, ndim 1, dtype family int — a list output has no array shape of its own; none is stated
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
conv3x3 Ran
ran; our contract draft was wrong, not the code
warmspringwinds/pytorch-segmentation-detection/pytorch_segmentation_detection/models/deeplab.py
code served (permissive licence) · get_code("9e2edfa6c37815a7")
How it ran

Ran 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
import numpy as np

torch.manual_seed(0)

ARGS = {
    "in_channels": 3,
    "out_channels": 64,
    "stride": 1,
    "dilation": 1,
}
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 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
create_logger Ran
ran; our contract draft was wrong, not the code
eceo-epfl/scaleprotoseg/log.py
code served (permissive licence) · get_code("da0f80d54b852951")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned tuple, ndim 1, dtype family float; no output shape is stated. The image it ran in was not recorded. If your copy returns the same type and ndim on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import os
import tempfile

# Create a temporary file for logging
temp_dir = tempfile.gettempdir()
log_filename = os.path.join(temp_dir, "test_logger.log")

# Ensure the file exists and is empty for this test
with open(log_filename, 'w') as f:
    f.write("")

ARGS = {
    "log_filename": log_filename,
    "display": True,
}
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 tuple, ndim 1, dtype family float — a tuple output has no array shape of its own; none is stated
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
find_continuous_high_activation_crop Ran
ran on a synthesized input
eceo-epfl/scaleprotoseg/helpers.py
code served (permissive licence) · get_code("159cfd7b77ad44a5")
How it ran

Ran 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 numpy as np

# Create a small activation map (2D numpy array)
# Using shape (10, 10) to have enough space for the algorithm to expand
activation_map = np.random.rand(10, 10) * 2  # values between 0 and 2

# Create a patch_bbox (start_h, end_h, start_w, end_w)
# Starting with a small region in the middle
patch_bbox = (3, 5, 3, 5)

# Set threshold for high activation
threshold = 0.5

# Set margin to add around the found region
add_margin = 2

# Ensure there are some high activation values in and around the patch
# so the algorithm can find continuous regions
activation_map[3:6, 3:6] = 1.5  # High values in the patch region
activation_map[2, 3:6] = 1.2    # High values above
activation_map[6, 3:6] = 1.2    # High values below
activation_map[3:6, 2] = 1.2    # High values to the left
activation_map[3:6, 6] = 1.2    # High values to the right

ARGS = {
    "activation_map": activation_map,
    "patch_bbox": patch_bbox,
    "threshold": threshold,
    "add_margin": add_margin,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type 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
find_high_activation_crop Ran
ran, honoured the contract we drafted
eceo-epfl/scaleprotoseg/helpers.py
code served (permissive licence) · get_code("a578552e64b8de7e")
How it ran

Ran 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 numpy as np

# Create a sample activation map
# The function expects a 2D numpy array (height x width)
# Let's create one with some high and low activation values
np.random.seed(0)
activation_map = np.random.rand(8, 6) * 100  # Values between 0-100

# Define ARGS dict with all parameters
ARGS = {
    'activation_map': activation_map,
    'percentile': 95
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type 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_input_optimizer Ran
ran; our contract draft was wrong, not the code
aldo-aguilar/nu-style/src/handlers.py
pointer only (licence: MIT); the stored copy get_code serves, from ritesh2212/DeepPhotoStyle_pytorch-master, is pointer only (licence: NONE) · get_code("8f043783be05520d")
How it ran

The body of this sample is withheld: this paper's link allows the body inline (MIT), but get_code serves the stored copy, first harvested from ritesh2212/DeepPhotoStyle_pytorch-master, and GitHub detected no licence in that repository when it was checked. The setup block that called it is withheld with it, because it is written against that body. source_path and origin say where the code lives, to read under the repository's own terms. A run is recorded.

get_lr Ran
ran, honoured the contract we drafted
eceo-epfl/scaleprotoseg/segmentation/em/module_em.py
pointer only (licence: MIT); the stored copy get_code serves, from yjzhang96/UTI-VFI, is pointer only (licence: NONE) · get_code("7337f1f5ff01dcd0")
How it ran

The body of this sample is withheld: this paper's link allows the body inline (MIT), but get_code serves the stored copy, first harvested from yjzhang96/UTI-VFI, and GitHub detected no licence in that repository when it was checked. The setup block that called it is withheld with it, because it is written against that body. source_path and origin say where the code lives, to read under the repository's own terms. A run is recorded.

image_loader Ran
ran on a synthesized input
aldo-aguilar/nu-style/src/dataset.py
code served (permissive licence) · get_code("c70da0d4921fa08b")
How it ran

Ran 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 (1, 3, 64, 64) as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch
from PIL import Image
import io
import torchvision.transforms as transforms

torch.manual_seed(0)

# Create a small test image in memory
img_array = torch.randint(0, 256, (32, 32, 3), dtype=torch.uint8).numpy()
img = Image.fromarray(img_array, mode='RGB')

# Save to bytes buffer
buffer = io.BytesIO()
img.save(buffer, format='PNG')
buffer.seek(0)

# Write to a temporary file-like object that PIL can read
# Since we can't do real file I/O, we'll use a workaround with PIL's ability to open from bytes
import tempfile
import os

temp_file = tempfile.NamedTemporaryFile(delete=False, suffix='.png')
temp_file.write(buffer.getvalue())
temp_file.close()

ARGS = {
    'image_name': temp_file.name,
    'imsize': 64,
    'device': 'cpu'
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
PIL, torch, torchvision — 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 (1, 3, 64, 64) — shape (1, 3, 64, 64) 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
iou_coeff Ran
ran on a synthesized input
cgsaxner/UB_Segmentation/metrics.py
code served (permissive licence) · get_code("dd2ff9a3c0d64a92")
How it ran

Ran 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 EagerTensor, ndim 0, 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 tensorflow as tf
import numpy as np

# Set random seeds for reproducibility
tf.random.set_seed(0)
np.random.seed(0)

# Create small tensors with distinct dimensions
batch_size = 2
height = 4
width = 3
depth = 5

# Create label tensor: [batch_size, height, width, depth]
# Binary values (0 or 1) for segmentation labels
label = tf.constant(
    np.random.randint(0, 2, size=(batch_size, height, width, depth)),
    dtype=tf.float32
)

# Create prediction tensor: [batch_size, height, width, depth]
# Float values between 0 and 1 (e.g., from sigmoid activation)
prediction = tf.constant(
    np.random.uniform(0, 1, size=(batch_size, height, width, depth)),
    dtype=tf.float32
)

ARGS = {
    "label": label,
    "prediction": prediction,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy, tensorflow — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type EagerTensor, ndim 0, dtype family float — no output shape is stated: observe_signature.py recorded SymbolicTensor ndim 0, which disagrees with the fixture run
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
list_of_distances Ran
ran; our contract draft was wrong, not the code
eceo-epfl/scaleprotoseg/helpers.py
code served (permissive licence) · get_code("c9e92d0b7ff929fe")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned Tensor, ndim 2, dtype family float, shape (2, 3) as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch

torch.manual_seed(0)

# X: shape (batch_size, dim) - will be unsqueezed to (batch_size, dim, 1)
X = torch.randn(2, 4)

# Y: shape (num_points, dim) - will be transposed to (dim, num_points) then unsqueezed to (1, dim, num_points)
Y = torch.randn(3, 4)

ARGS = {
    "X": X,
    "Y": Y,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type Tensor, ndim 2, dtype family float, shape (2, 3) — shape (2, 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
preprocess Ran
ran; our contract draft was wrong, not the code
eceo-epfl/scaleprotoseg/preprocess.py
code served (permissive licence) · get_code("2f5c8689a7884f62")
How it ran

Ran 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, 3, 4, 4) as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch

torch.manual_seed(0)

# Create a small tensor with batch size 2, 3 channels, and 4x4 spatial dimensions
x = torch.randn(2, 3, 4, 4)

# Define mean and std for normalization
mean = (0.485, 0.456, 0.406)
std = (0.229, 0.224, 0.225)

ARGS = {
    "x": x,
    "mean": mean,
    "std": std
}
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, 3, 4, 4) — shape (2, 3, 4, 4) as a later run recorded it
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
preprocess_input_function Ran
ran; our contract draft was wrong, not the code
eceo-epfl/scaleprotoseg/preprocess.py
code served (permissive licence) · get_code("d22fdfbc49113693")
How it ran

Ran 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, 3, 4, 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)

# The function preprocess_input_function takes one parameter: x
# Looking at the function body, x is used in preprocess() which:
# - Checks that x.size(1) == 3 (second dimension must be 3, for RGB channels)
# - Creates a tensor of same shape as x
# - Indexes x with [:, i, :, :] for i in range(3)
# This means x must be a 4D tensor with shape (batch, 3, height, width)

# Create a small test tensor: batch_size=2, channels=3, height=4, width=5
x = torch.randn(2, 3, 4, 5)

ARGS = {
    "x": x
}
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, 3, 4, 5) — shape (2, 3, 4, 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
sanitize_config_val_for_json Ran
ran on a synthesized input
eceo-epfl/scaleprotoseg/segmentation/config.py
code served (permissive licence) · get_code("32401bdce2879798")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned dict. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch
import json

torch.manual_seed(0)

ARGS = {
    "val": {
        "model_name": "bert-base",
        "learning_rate": 0.001,
        "epochs": 10,
        "nested_config": {
            "hidden_size": 768,
            "num_layers": 12,
            "dropout": 0.1,
            "activation": "gelu"
        },
        "layer_sizes": [128, 256, 512],
        "mixed_list": [
            1,
            2.5,
            "text",
            {"key": "value"},
            [1, 2, 3]
        ],
        "deeply_nested": {
            "level1": {
                "level2": {
                    "level3": [1, 2, {"final": "value"}]
                }
            }
        },
        "simple_values": [True, False, None, 42, 3.14, "string"]
    }
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type dict — a dict output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a dict output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not stated
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
undo_preprocess Ran
ran; our contract draft was wrong, not the code
eceo-epfl/scaleprotoseg/preprocess.py
code served (permissive licence) · get_code("efb86a8611f14f72")
How it ran

Ran 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, 3, 4, 4) as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch

torch.manual_seed(0)

# Create a small batch of preprocessed images (batch_size=2, channels=3, height=4, width=4)
x = torch.randn(2, 3, 4, 4)

mean = (0.485, 0.456, 0.406)
std = (0.229, 0.224, 0.225)

ARGS = {
    "x": x,
    "mean": mean,
    "std": std
}
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, 3, 4, 4) — shape (2, 3, 4, 4) as a later run recorded it
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
ASPP Not yet run
unverified (harvested, no recorded run)
Media-Smart/vedaseg/vedaseg/models/encoders/enhance_modules/aspp.py
code served (permissive licence) · get_code("8a6aac3339ee8802")
How it ran

no invocation recorded.

ASPPModule Not yet run
unverified (harvested, no recorded run)
OIdiotLin/DeepLab-pytorch/src/networks/deeplabv3.py
pointer only (licence: NONE) · get_code("3edb28451c5d5ab9")
How it ran

The body of this sample is withheld: GitHub detected no licence in this paper's repository, OIdiotLin/DeepLab-pytorch when it was checked. The setup block that called it is withheld with it, because it is written against that body. source_path and origin say where the code lives, to read under the repository's own terms. No invocation recorded.

DeepLab Not yet run
unverified (harvested, no recorded run)
leimao/DeepLab-V3/model.py
code served (permissive licence) · get_code("ac381b8ad8a845a3")
How it ran

no invocation recorded.

DenseASPP Not yet run
unverified (harvested, no recorded run)
DeepMotionAIResearch/DenseASPP/models/DenseASPP.py
pointer only (licence: NONE) · get_code("8a58f32a65726f57")
How it ran

The body of this sample is withheld: GitHub detected no licence in this paper's repository, DeepMotionAIResearch/DenseASPP when it was checked. The setup block that called it is withheld with it, because it is written against that body. source_path and origin say where the code lives, to read under the repository's own terms. No invocation recorded.

MobileNet Not yet run
unverified (harvested, no recorded run)
leimao/DeepLab-V3/model.py
code served (permissive licence) · get_code("9a312354c4aac598")
How it ran

no invocation recorded.

Network Not yet run
unverified (harvested, no recorded run)
Daeijavad/Deeplab-CRF/network_class.py
pointer only (licence: NONE) · get_code("f1deead3b623ea55")
How it ran

The body of this sample is withheld: GitHub detected no licence in this paper's repository, Daeijavad/Deeplab-CRF when it was checked. The setup block that called it is withheld with it, because it is written against that body. source_path and origin say where the code lives, to read under the repository's own terms. No invocation recorded.

Resnet Not yet run
unverified (harvested, no recorded run)
leimao/DeepLab-V3/model.py
code served (permissive licence) · get_code("59f29ececcd49f37")
How it ran

no invocation recorded.

Vgg16 Not yet run
unverified (harvested, no recorded run)
leimao/DeepLab-V3/model.py
code served (permissive licence) · get_code("0682c73df452506f")
How it ran

no invocation recorded.

_DenseAsppBlock Not yet run
unverified (harvested, no recorded run)
DeepMotionAIResearch/DenseASPP/models/DenseASPP.py
pointer only (licence: NONE) · get_code("6a76699fca4b02b5")
How it ran

The body of this sample is withheld: GitHub detected no licence in this paper's repository, DeepMotionAIResearch/DenseASPP when it was checked. The setup block that called it is withheld with it, because it is written against that body. source_path and origin say where the code lives, to read under the repository's own terms. No invocation recorded.

_DenseBlock Not yet run
unverified (harvested, no recorded run)
DeepMotionAIResearch/DenseASPP/models/DenseASPP.py
pointer only (licence: NONE) · get_code("e62f57b4d5854c77")
How it ran

The body of this sample is withheld: GitHub detected no licence in this paper's repository, DeepMotionAIResearch/DenseASPP when it was checked. The setup block that called it is withheld with it, because it is written against that body. source_path and origin say where the code lives, to read under the repository's own terms. No invocation recorded.

_DenseLayer Not yet run
unverified (harvested, no recorded run)
DeepMotionAIResearch/DenseASPP/models/DenseASPP.py
pointer only (licence: NONE) · get_code("a1a737ad0daed701")
How it ran

The body of this sample is withheld: GitHub detected no licence in this paper's repository, DeepMotionAIResearch/DenseASPP when it was checked. The setup block that called it is withheld with it, because it is written against that body. source_path and origin say where the code lives, to read under the repository's own terms. No invocation recorded.

atrous_spatial_pyramid_pooling Not yet run
unverified (harvested, no recorded run)
leimao/DeepLab-V3/model.py
code served (permissive licence) · get_code("c8a45bd65a5b3b97")
How it ran

no invocation recorded.

constant_init Not yet run
unverified (harvested, no recorded run)
Media-Smart/vedaseg/vedaseg/models/encoders/enhance_modules/aspp.py
code served (permissive licence) · get_code("5ceabf20d794e5bd")
How it ran

no invocation recorded.

getData Not yet run
unverified (harvested, no recorded run)
aldo-aguilar/nu-style/CycleGan/src/dataset.py
code served (permissive licence) · get_code("1127bbe82e43e0e6")
How it ran

no invocation recorded.

get_style_model_and_loss Not yet run
unverified (harvested, no recorded run)
aldo-aguilar/nu-style/src/handlers.py
code served (permissive licence) · get_code("8ead0bc727213153")
How it ran

no invocation recorded.

init_weights Not yet run
unverified (harvested, no recorded run)
Media-Smart/vedaseg/vedaseg/models/encoders/enhance_modules/aspp.py
code served (permissive licence) · get_code("20164401c294879a")
How it ran

no invocation recorded.

kaiming_init Not yet run
unverified (harvested, no recorded run)
Media-Smart/vedaseg/vedaseg/models/encoders/enhance_modules/aspp.py
code served (permissive licence) · get_code("17876e40add6c703")
How it ran

no invocation recorded.

Showing the first 60. An agent gets every one from get_harvested_code_for_paper("1606.00915").

Also present in other papers' code

Of 63 samples lifted from this paper's linked repositories, 63 carry a function identity and 0 do not. Of the 63 distinct functions with an identity, 11 are also present in other papers whose code we hold (2 with at least one paper dated earlier, 0 the same month, 11 later) and 52 are only here among the 52,977 papers whose code Syntology holds (as of 2026-09-26).

Only here means: among the 52,977 papers whose code Syntology holds (51,887 with lifted samples, 1,090 through their assemblies only), as of 2026-09-26, no other paper's lifted samples or current assembly bricks contain an identical function body after normalisation.

FunctionAlso present inEarliest-datedOthers named
get_lr 25 other papers
1 dated earlier, 24 later · 2 only as an assembly brick
1605.07148 (2016-05)
Backprop KF: Learning Discriminative Deterministic State Estimators
1904.01355 (2019-04)
FCOS: Fully Convolutional One-Stage Object Detection
1912.02923 (2019-12)
Generating 3D People in Scenes without People
and 22 more not named here
Registry
brick of this paper's assembly: helper
5 other papers
1 dated earlier, 4 later · 1 only as an assembly brick
1505.04597 (2015-05)
U-Net: Convolutional Networks for Biomedical Image Segmentation
2005.12872 (2020-05)
End-to-End Object Detection with Transformers
2012.12877 (2020-12)
Training data-efficient image transformers & distillation through attention
and 2 more not named here
preprocess_input_function 3 other papers
3 later
1906.10651 (2019-06)
Interpretable Image Recognition with Hierarchical Prototypes
2410.20722 (2024-10)
Interpretable Image Classification with Adaptive Prototype-based Vision Transformers
2503.01087 (2025-03)
Rashomon Sets for Prototypical-Part Networks: Editing Interpretable Models in Real-Time
create_logger 2 other papers
2 later
1906.10651 (2019-06)
Interpretable Image Recognition with Hierarchical Prototypes
2410.20722 (2024-10)
Interpretable Image Classification with Adaptive Prototype-based Vision Transformers
find_high_activation_crop 2 other papers
2 later
2208.10431 (2022-08)
ProtoPFormer: Concentrating on Prototypical Parts in Vision Transformers for Interpretable Image Recognition
2410.20722 (2024-10)
Interpretable Image Classification with Adaptive Prototype-based Vision Transformers
list_of_distances 2 other papers
2 later
1906.10651 (2019-06)
Interpretable Image Recognition with Hierarchical Prototypes
2410.20722 (2024-10)
Interpretable Image Classification with Adaptive Prototype-based Vision Transformers
preprocess 2 other papers
2 later
2410.20722 (2024-10)
Interpretable Image Classification with Adaptive Prototype-based Vision Transformers
2605.02167 (2026-05)
Manifold-Aligned Guided Integrated Gradients for Reliable Feature Attribution
undo_preprocess 2 other papers
2 later
2410.20722 (2024-10)
Interpretable Image Classification with Adaptive Prototype-based Vision Transformers
2605.02167 (2026-05)
Manifold-Aligned Guided Integrated Gradients for Reliable Feature Attribution
compute_layer_rf_info 1 other paper
1 later
136720346 (2022 (year only))
Interpretable Image Classification with Differentiable Prototypes Assignment
get_input_optimizer 1 other paper
1 later
1703.07511 (2017-03)
Deep Photo Style Transfer
kaiming_init
brick of this paper's assembly: helper
1 other paper
1 later · 1 only as an assembly brick
2203.02149 (2022-03)
HDNet: High-resolution Dual-domain Learning for Spectral Compressive Imaging

Presence, not direction: an identical function body in two papers' repositories does not say who wrote it, which came from which, or that either paper's method rests on it. Matching is exact after normalisation, so a renamed or edited function is not matched. Dates are when papers appeared, not when code was written. Only .py files the harvester lifted are covered; notebooks are not read. A new-style arXiv id YYMM.NNNN dates a paper to the month 20YY-MM; otherwise Paper.year dates it to the year; otherwise it is undated. Dates are when the paper appeared, not when the code was written. Read 2026-11-22.

Repositories linked to this paper

More are linked than shown here.

Some links come from the archived Papers with Code dataset (CC BY-SA 4.0): attribution and licence.

Abstract

In this work we address the task of semantic image segmentation with Deep Learning and make three main contributions that are experimentally shown to have substantial practical merit. First, we highlight convolution with upsampled filters, or 'atrous convolution', as a powerful tool in dense prediction tasks. Atrous convolution allows us to explicitly control the resolution at which feature responses are computed within Deep Convolutional Neural Networks. It also allows us to effectively enlarge the field of view of filters to incorporate larger context without increasing the number of parameters or the amount of computation. Second, we propose atrous spatial pyramid pooling (ASPP) to robustly segment objects at multiple scales. ASPP probes an incoming convolutional feature layer with filters at multiple sampling rates and effective fields-of-views, thus capturing objects as well as image context at multiple scales. Third, we improve the localization of object boundaries by combining methods from DCNNs and probabilistic graphical models. The commonly deployed combination of max-pooling and downsampling in DCNNs achieves invariance but has a toll on localization accuracy. We overcome this by combining the responses at the final DCNN layer with a fully connected Conditional Random Field (CRF), which is shown both qualitatively and quantitatively to improve localization performance. Our proposed "DeepLab" system sets the new state-of-art at the PASCAL VOC-2012 semantic image segmentation task, reaching 79.7% mIOU in the test set, and advances the results on three other datasets: PASCAL-Context, PASCAL-Person-Part, and Cityscapes. All of our code is made publicly available online.

For agents

The same record, over MCP at https://syntology.ai/mcp:

get_harvested_code_for_paper("1606.00915")
get_code_for_paper("1606.00915")
have("1606.00915")

The run record, dated, one paper per request, free:

curl https://syntology.ai/api/ran/1606.00915.json

A badge for a README (the split and the date, never a ratio):

[![Syntology run record](https://syntology.ai/api/ran/1606.00915.svg)](https://syntology.ai/paper/1606.00915)

Connect an agent — have() is free.