SYNTOLOGY HomeExplorerAtlasCodeMethodologyAboutDevelopersFeedPricing
Paper · 2104.00298 · ICML · 2021

EfficientNetV2: Smaller Models and Faster Training

Quoc Le, Mingxing Tan

arXiv · PDF · Open in the Atlas

Code that ran

55 of 79 samples (functions and classes) lifted from this paper's linked repositories executed on a synthesized input in Syntology's jail (14 of them constructed an object rather than computing a result; 12 honoured the contract we drafted, 0 violated it and 30 have no contract verdict; 13 failures of our instrument; 24 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/2104.00298.json · badge: /api/ran/2104.00298.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
google/automl canonical (classifier label)
classifier basis: classifier_2025
1 ran · 0 no recorded run
szq0214/fkd community
Papers with Code archive
7 ran · 1 no recorded run
hwzwx1190522/efficientnetv2 community (classifier label)
classifier basis not recorded on the link
7 ran · 0 no recorded run
Klassikcat/project-NEXTLab-CNN-EfficientNet community
Papers with Code archive
6 ran · 3 no recorded run
abhuse/pytorch-efficientnet community
Papers with Code archive
6 ran · 3 no recorded run
DavidLandup0/deepvision community
Papers with Code archive
4 ran · 6 no recorded run
leondgarse/Keras_efficientnet_v2 community
Papers with Code archive
4 ran · 3 no recorded run
jahongir7174/EfficientNetV2 reimplementation (classifier label)
classifier basis: classifier_2025
4 ran · 1 no recorded run
hankyul2/EfficientNetV2-pytorch reimplementation (classifier label)
classifier basis: classifier_2025
4 ran · 1 no recorded run
danstowell/insect_classifier_GDSC23_insecteffnet community (classifier label)
classifier basis not recorded on the link
4 ran · 1 no recorded run
jahongir7174/EffcientNetV2 community (classifier label)
classifier basis not recorded on the link
3 ran · 0 no recorded run
JohnnyHopp/PaDiM-EfficientNetV2 extension (classifier label)
classifier basis: classifier_2025
2 ran · 0 no recorded run
seermer/TensorFlow2-EfficientNetV2 reimplementation (classifier label)
classifier basis: classifier_2025
2 ran · 0 no recorded run
phykn/film-defect-detection community
Papers with Code archive
1 ran · 0 no recorded run
d-li14/efficientnetv2.pytorch port (classifier label)
classifier basis: classifier_2025
0 ran · 5 no recorded run
FunctionStatusWhere it lives
Attention Ran
ran on a synthesized input
szq0214/fkd/FKD/FKD_ViT/SReT.py
code served (permissive licence) · get_code("e3021018c5f52aca")
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 3, dtype family float; no output shape is stated. The image it ran in was not recorded. If your copy returns the same type and ndim on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch
from torch import nn

class Attention(nn.Module):

    def __init__(self, dim, num_groups1=8, num_groups2=4, num_heads=8, qkv_bias=False, qk_scale=None, attn_drop=0.0, proj_drop=0.0):
        super().__init__()
        self.num_heads = num_heads
        self.num_groups1 = num_groups1
        self.num_groups2 = num_groups2
        head_dim = dim // num_heads
        self.scale = qk_scale or head_dim ** (-0.5)
        self.qkv = nn.Linear(dim, dim * 3, bias=qkv_bias)
        self.attn_drop = nn.Dropout(attn_drop)
        self.proj = nn.Linear(dim, dim)
        self.proj_drop = nn.Dropout(proj_drop)

    def forward(self, x, recursive_index):
        B, N, C = x.shape
        if recursive_index == False:
            num_groups = self.num_groups1
        else:
            num_groups = self.num_groups2
            if num_groups != 1:
                idx = torch.randperm(N)
                x = x[:, idx, :]
                inverse = torch.argsort(idx)
        qkv = self.qkv(x).reshape(B, num_groups, N // num_groups, 3, self.num_heads, C // self.num_heads).permute(3, 0, 1, 4, 2, 5)
        q, k, v = (qkv[0], qkv[1], qkv[2])
        attn = q @ k.transpose(-2, -1) * self.scale
        attn = attn.softmax(dim=-1)
        attn = self.attn_drop(attn)
        x = (attn @ v).transpose(2, 3).reshape(B, num_groups, N // num_groups, C)
        x = x.permute(0, 3, 1, 2).reshape(B, C, N).transpose(1, 2)
        if recursive_index == True and num_groups != 1:
            x = x[:, inverse, :]
        x = self.proj(x)
        x = self.proj_drop(x)
        return x


INIT_ARGS = {
    'dim': 8,
    'num_groups1': 2,
    'num_groups2': 2,
    'num_heads': 2,
    'qkv_bias': False,
    'qk_scale': None,
    'attn_drop': 0.1,
    'proj_drop': 0.1,
}

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

if __name__ == '__main__':
    model = Attention(**INIT_ARGS)
    output = model(**ARGS)
    print(f"Output shape: {output.shape}")
    print(f"Expected shape: {ARGS['x'].shape}")
    assert output.shape == ARGS['x'].shape, f"Shape mismatch: {output.shape} vs {ARGS['x'].shape}"
    print("Test passed!")
Setup block drafted by
a language model, class construct-then-call prompt, model not recorded
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type Tensor, ndim 3, dtype family float — no output shape is stated: observe_signature.py observed this class with its constructor sizes canonicalised where it could, which the node does not record, so its shape is not stated as this setup block's
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: torch and numpy seeded to 0 by the harness immediately before the class was constructed from INIT_ARGS (fixture_check.py)
CLF_MODEL Ran
ran on a synthesized input · constructed an object; no result was computed
phykn/film-defect-detection/module/model.py
pointer only (licence: NONE) · get_code("87eea03ed82a58bb")
How it ran

The body of this sample is withheld: GitHub detected no licence in this paper's repository, phykn/film-defect-detection 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.

Conv Ran
ran on a synthesized input · constructed an object; no result was computed
jahongir7174/EfficientNetV2/nets/nn.py
code served (permissive licence) · get_code("9354545acc375b1b")
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, Conv: 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)

# Activation function to use
activation = nn.ReLU()

# Define ARGS dict with all parameters for Conv.__init__
ARGS = {
    'in_ch': 3,
    'out_ch': 16,
    'activation': activation,
    'k': 3,
    's': 1,
    'g': 1
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type Conv — 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 Conv 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
ConvBNAct Ran
ran on a synthesized input · constructed an object; no result was computed
hankyul2/EfficientNetV2-pytorch/efficientnetv2/efficientnet_v2.py
code served (permissive licence) · get_code("2a8679c295eca86e")
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, ConvBNAct: 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 arguments for ConvBNAct.__init__
in_channel = 3
out_channel = 16
kernel_size = 3
stride = 1
groups = 1
norm_layer = nn.BatchNorm2d
act = nn.ReLU
conv_layer = nn.Conv2d

ARGS = {
    'in_channel': in_channel,
    'out_channel': out_channel,
    'kernel_size': kernel_size,
    'stride': stride,
    'groups': groups,
    'norm_layer': norm_layer,
    'act': act,
    'conv_layer': conv_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 ConvBNAct — 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 ConvBNAct 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
ConvKernalInitializer Ran
ran on a synthesized input
Klassikcat/project-NEXTLab-CNN-EfficientNet/EfficientNet_codestates/model/model.py
pointer only (licence: NONE) · get_code("4727c94370c69e97")
How it ran

The body of this sample is withheld: GitHub detected no licence in this paper's repository, Klassikcat/project-NEXTLab-CNN-EfficientNet 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.

EfficientNet Ran
ran on a synthesized input · constructed an object; no result was computed
jahongir7174/EfficientNetV2/nets/nn.py
code served (permissive licence) · get_code("4f25eeb823c2de8b")
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, EfficientNet: 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 timm.models.layers import DropPath

torch.manual_seed(0)

ARGS = {
    "drop_rate": 0.1,
    "num_class": 10
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
timm, torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type EfficientNet — 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 EfficientNet 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
LearnableCoefficient Ran
ran on a synthesized input · constructed an object; no result was computed
szq0214/fkd/FKD/FKD_ViT/SReT.py
code served (permissive licence) · get_code("70b3286546cf6d44")
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, LearnableCoefficient: the run constructed the object and did not call it, so no result was computed. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch
from torch import nn

torch.manual_seed(0)

class LearnableCoefficient(nn.Module):

    def __init__(self):
        super(LearnableCoefficient, self).__init__()
        self.bias = nn.Parameter(torch.ones(1), requires_grad=True)

    def forward(self, x):
        out = x * self.bias
        return out


# Create a sample input tensor (batch_size=2, features=4)
sample_input = torch.randn(2, 4)

# The __init__ method takes no parameters, so ARGS should be empty
ARGS = {}
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 LearnableCoefficient — 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 LearnableCoefficient 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
MBConv Ran
ran on a synthesized input · constructed an object; no result was computed
hankyul2/EfficientNetV2-pytorch/efficientnetv2/efficientnet_v2.py
code served (permissive licence) · get_code("5c4ec70828e49d68")
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, MBConv: 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 functools import partial

torch.manual_seed(0)

class MBConvConfig:
    """Configuration class for MBConv"""
    def __init__(self, in_ch, out_ch, kernel, stride, expand_ratio, fused=False):
        self.in_ch = in_ch
        self.out_ch = out_ch
        self.kernel = kernel
        self.stride = stride
        self.expand_ratio = expand_ratio
        self.fused = fused
        self.norm_layer = nn.BatchNorm2d
        self.act = partial(nn.SiLU, inplace=True)
    
    def adjust_channels(self, channels, multiplier):
        """Adjust number of channels based on multiplier"""
        return int(channels * multiplier)

config = MBConvConfig(
    in_ch=4,
    out_ch=8,
    kernel=3,
    stride=1,
    expand_ratio=2,
    fused=False
)

ARGS = {
    'c': config,
    'sd_prob': 0.1
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type MBConv — 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 MBConv 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
MBConvBlock Ran
ran; our contract draft was wrong, not the code
Klassikcat/project-NEXTLab-CNN-EfficientNet/EfficientNet_codestates/model/model.py
pointer only (licence: NONE) · get_code("cb2b257652e0c5cc")
How it ran

The body of this sample is withheld: GitHub detected no licence in this paper's repository, Klassikcat/project-NEXTLab-CNN-EfficientNet 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.

MBConvBlockV2 Ran
ran on a synthesized input
abhuse/pytorch-efficientnet/efficientnet_v2.py
code served (permissive licence) · get_code("f9ecf91bbb0df74d")
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 torch.nn as nn

# INIT_ARGS for MBConvBlockV2.__init__
INIT_ARGS = {
    'in_channels': 8,
    'out_channels': 12,
    'kernel_size': 3,
    'stride': 1,
    'expansion_factor': 2,
    'act_fn': 'relu',
    'act_kwargs': None,
    'bn_epsilon': 1e-5,
    'bn_momentum': 0.1,
    'se_size': 4,
    'drop_connect_rate': 0.2,
    'bias': False,
    'tf_style_conv': True,
    'in_spatial_shape': (7, 9)
}

# ARGS for MBConvBlockV2.forward
ARGS = {
    'x': torch.randn(2, 8, 7, 9)
}
Setup block drafted by
a language model, class construct-then-call prompt, model not recorded
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type Tensor, ndim 4, dtype family float — no output shape is stated: observe_signature.py observed this class with its constructor sizes canonicalised where it could, which the node does not record, so its shape is not stated as this setup block's
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: torch and numpy seeded to 0 by the harness immediately before the class was constructed from INIT_ARGS (fixture_check.py)
Non_proj Ran
ran on a synthesized input · constructed an object; no result was computed
szq0214/fkd/FKD/FKD_ViT/SReT.py
code served (permissive licence) · get_code("311f34cd673ace61")
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, Non_proj: the run constructed the object and did not call it, so no result was computed. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch
from torch import nn

torch.manual_seed(0)

ARGS = {
    "dim": 4,
    "num_heads": 2,
    "mlp_ratio": 1.0,
    "qkv_bias": False,
    "qk_scale": None,
    "drop": 0.0,
    "attn_drop": 0.0,
    "drop_path": 0.0,
    "act_layer": nn.GELU,
    "norm_layer": nn.LayerNorm,
}
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 Non_proj — 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 Non_proj 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
Residual Ran
ran on a synthesized input · constructed an object; no result was computed
jahongir7174/EfficientNetV2/nets/nn.py
code served (permissive licence) · get_code("acb059769b4a4327")
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, Residual: the run constructed the object and did not call it, so no result was computed. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch
from timm.models.layers import DropPath

torch.manual_seed(0)

ARGS = {
    "in_ch": 4,
    "out_ch": 8,
    "s": 1,
    "r": 2,
    "dp_rate": 0.1,
    "fused": True,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
timm, torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type Residual — 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 Residual 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
SE Ran
ran on a synthesized input · constructed an object; no result was computed
jahongir7174/EfficientNetV2/nets/nn.py
code served (permissive licence) · get_code("57a73cdb3469e654")
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, SE: 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

torch.manual_seed(0)

# SE module expects:
# - ch: number of channels (int)
# - r: reduction ratio (int)
# 
# The forward method expects x to be a 4D tensor (batch, channels, height, width)

ch = 4
r = 2

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

ARGS = {
    'ch': ch,
    'r': r
}
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 SE — 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 SE 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
SEBlock Ran
ran; our contract draft was wrong, not the code
Klassikcat/project-NEXTLab-CNN-EfficientNet/EfficientNet_codestates/model/model.py
pointer only (licence: NONE) · get_code("020b78c721a6198e")
How it ran

The body of this sample is withheld: GitHub detected no licence in this paper's repository, Klassikcat/project-NEXTLab-CNN-EfficientNet 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.

SEUnit Ran
ran on a synthesized input · constructed an object; no result was computed
hankyul2/EfficientNetV2-pytorch/efficientnetv2/efficientnet_v2.py
code served (permissive licence) · get_code("2a6675c2cebf02ab")
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, SEUnit: 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 functools import partial

torch.manual_seed(0)

ARGS = {
    "in_channel": 16,
    "reduction_ratio": 4,
    "act1": partial(nn.SiLU, inplace=True),
    "act2": nn.Sigmoid,
}
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 SEUnit — 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 SEUnit 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
SamePaddingConv2d Ran
ran on a synthesized input
abhuse/pytorch-efficientnet/efficientnet_v2.py
code served (permissive licence) · get_code("b7194f8c7b7e316c")
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, 12) as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch
import torch.nn as nn
import collections.abc as container_abc
from math import ceil, floor

def _pair(x):
    if isinstance(x, container_abc.Iterable):
        return x
    return (x, x)

class SamePaddingConv2d(nn.Module):

    def __init__(self, in_spatial_shape, in_channels, out_channels, kernel_size, stride, dilation=1, enforce_in_spatial_shape=False, **kwargs):
        super(SamePaddingConv2d, self).__init__()
        self._in_spatial_shape = _pair(in_spatial_shape)
        self.enforce_in_spatial_shape = enforce_in_spatial_shape
        kernel_size = _pair(kernel_size)
        stride = _pair(stride)
        dilation = _pair(dilation)
        in_height, in_width = self._in_spatial_shape
        filter_height, filter_width = kernel_size
        stride_heigth, stride_width = stride
        dilation_height, dilation_width = dilation
        out_height = int(ceil(float(in_height) / float(stride_heigth)))
        out_width = int(ceil(float(in_width) / float(stride_width)))
        pad_along_height = max((out_height - 1) * stride_heigth + filter_height + (filter_height - 1) * (dilation_height - 1) - in_height, 0)
        pad_along_width = max((out_width - 1) * stride_width + filter_width + (filter_width - 1) * (dilation_width - 1) - in_width, 0)
        pad_top = pad_along_height // 2
        pad_bottom = pad_along_height - pad_top
        pad_left = pad_along_width // 2
        pad_right = pad_along_width - pad_left
        paddings = (pad_left, pad_right, pad_top, pad_bottom)
        if any((p > 0 for p in paddings)):
            self.zero_pad = nn.ZeroPad2d(paddings)
        else:
            self.zero_pad = None
        self.conv = nn.Conv2d(in_channels=in_channels, out_channels=out_channels, kernel_size=kernel_size, stride=stride, dilation=dilation, **kwargs)
        self._out_spatial_shape = (out_height, out_width)

    @property
    def out_spatial_shape(self):
        return self._out_spatial_shape

    def check_spatial_shape(self, x):
        if x.size(2) != self._in_spatial_shape[0] or x.size(3) != self._in_spatial_shape[1]:
            raise ValueError('Expected input spatial shape {}, got {} instead'.format(self._in_spatial_shape, x.shape[2:]))

    def forward(self, x):
        if self.enforce_in_spatial_shape:
            self.check_spatial_shape(x)
        if self.zero_pad is not None:
            x = self.zero_pad(x)
        x = self.conv(x)
        return x


INIT_ARGS = {
    'in_spatial_shape': (8, 12),
    'in_channels': 3,
    'out_channels': 4,
    'kernel_size': 3,
    'stride': 1,
    'dilation': 1,
    'enforce_in_spatial_shape': False,
}

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

module = SamePaddingConv2d(**INIT_ARGS)
output = module(**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, 12) — shape (2, 4, 8, 12) as a later run recorded it
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: torch and numpy seeded to 0 by the harness immediately before the class was constructed from INIT_ARGS (fixture_check.py)
StochasticDepth Ran
ran on a synthesized input · constructed an object; no result was computed
hankyul2/EfficientNetV2-pytorch/efficientnetv2/efficientnet_v2.py
code served (permissive licence) · get_code("eacbe6ee4a26a27f")
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, StochasticDepth: the run constructed the object and did not call it, so no result was computed. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch
from torch import nn

torch.manual_seed(0)

# StochasticDepth takes prob and mode as parameters
# prob: float probability of dying (0.0 to 1.0)
# mode: string, either "row" or "all"

ARGS = {
    "prob": 0.2,
    "mode": "row"
}
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 StochasticDepth — 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 StochasticDepth 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
Swish Ran
ran on a synthesized input
Klassikcat/project-NEXTLab-CNN-EfficientNet/EfficientNet_codestates/model/model.py
pointer only (licence: NONE) · get_code("d9cb72304c6ddff3")
How it ran

The body of this sample is withheld: GitHub detected no licence in this paper's repository, Klassikcat/project-NEXTLab-CNN-EfficientNet 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.

Transformer Ran
ran on a synthesized input · constructed an object; no result was computed
szq0214/fkd/FKD/FKD_ViT/SReT.py
code served (permissive licence) · get_code("8ecbf3a8e9175884")
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, Transformer: 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 timm.models.layers import DropPath

torch.manual_seed(0)

ARGS = {
    "base_dim": 2,
    "depth": 2,
    "recursive_num": 1,
    "groups1": 2,
    "groups2": 1,
    "heads": 2,
    "mlp_ratio": 4.0,
    "np_mlp_ratio": 1.0,
    "drop_rate": 0.0,
    "attn_drop_rate": 0.0,
    "drop_path_prob": None,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
einops, timm, torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type Transformer — 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 Transformer 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
Transformer_Block Ran
ran on a synthesized input · constructed an object; no result was computed
szq0214/fkd/FKD/FKD_ViT/SReT.py
code served (permissive licence) · get_code("547d2d46045ba04f")
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, Transformer_Block: the run constructed the object and did not call it, so no result was computed. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch
from torch import nn
from timm.models.layers import DropPath

torch.manual_seed(0)

ARGS = {
    "dim": 4,
    "num_groups1": 2,
    "num_groups2": 1,
    "num_heads": 2,
    "mlp_ratio": 4.0,
    "qkv_bias": False,
    "qk_scale": None,
    "drop": 0.0,
    "attn_drop": 0.0,
    "drop_path": 0.0,
    "act_layer": nn.GELU,
    "norm_layer": nn.LayerNorm,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
timm, torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type Transformer_Block — 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 Transformer_Block 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
__FusedMBConvTF Ran
ran on a synthesized input
DavidLandup0/deepvision/deepvision/models/classification/efficientnet/efficientnetv2.py
code served (permissive licence) · get_code("3c00e00b9c6c998f")
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 EagerTensor, ndim 4, dtype family float, shape (2, 5, 6, 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 tensorflow as tf
from tensorflow.keras import layers

@tf.keras.utils.register_keras_serializable(package='deepvision')
class __FusedMBConvTF(layers.Layer):

    def __init__(self, input_filters: int, output_filters: int, expand_ratio=1, kernel_size=3, strides=1, se_ratio=0.0, bn_momentum=0.9, activation=tf.keras.activations.swish, dropout: float=0.8, **kwargs):
        super().__init__(**kwargs)
        self.input_filters = input_filters
        self.output_filters = output_filters
        self.expand_ratio = expand_ratio
        self.kernel_size = kernel_size
        self.strides = strides
        self.se_ratio = se_ratio
        self.bn_momentum = bn_momentum
        self.activation = activation
        self.dropout = dropout
        self.filters = self.input_filters * self.expand_ratio
        self.filters_se = max(1, int(input_filters * se_ratio))
        self.conv1 = layers.Conv2D(filters=self.filters, kernel_size=kernel_size, strides=strides, padding='same', use_bias=False)
        self.bn1 = layers.BatchNormalization(momentum=self.bn_momentum)
        self.se_conv1 = layers.Conv2D(self.filters_se, 1, padding='same', activation=self.activation)
        self.se_conv2 = layers.Conv2D(self.filters, 1, padding='same', activation='sigmoid')
        self.output_conv = layers.Conv2D(filters=self.output_filters, kernel_size=1 if expand_ratio != 1 else kernel_size, strides=1, padding='same', use_bias=False)
        self.bn_out = layers.BatchNormalization(momentum=self.bn_momentum)

    def call(self, inputs):
        if self.expand_ratio != 1:
            x = self.conv1(inputs)
            x = self.bn1(x)
            x = self.activation(x)
        else:
            x = inputs
        if 0 < self.se_ratio <= 1:
            se = layers.GlobalAveragePooling2D()(x)
            se = layers.Reshape((1, 1, self.filters))(se)
            se = self.se_conv1(se)
            se = self.se_conv2(se)
            x = layers.multiply([x, se])
        x = self.output_conv(x)
        x = self.bn_out(x)
        if self.expand_ratio == 1:
            x = self.activation(x)
        if self.strides == 1 and self.input_filters == self.output_filters:
            if self.dropout:
                x = layers.Dropout(self.dropout)(x)
            x = layers.add([x, inputs])
        return x

    def get_config(self):
        config = {'input_filters': self.input_filters, 'output_filters': self.output_filters, 'expand_ratio': self.expand_ratio, 'kernel_size': self.kernel_size, 'strides': self.strides, 'se_ratio': self.se_ratio, 'bn_momentum': self.bn_momentum, 'activation': self.activation, 'dropout': self.dropout}
        base_config = super().get_config()
        return dict(list(base_config.items()) + list(config.items()))

    @classmethod
    def from_config(cls, config, custom_objects=None):
        activation = config.pop('activation')
        activation = tf.keras.activations.deserialize(activation)
        return cls(activation=activation, **config)


INIT_ARGS = {
    'input_filters': 4,
    'output_filters': 8,
    'expand_ratio': 2,
    'kernel_size': 3,
    'strides': 1,
    'se_ratio': 0.25,
    'bn_momentum': 0.9,
    'activation': tf.keras.activations.swish,
    'dropout': 0.8,
}

ARGS = {
    'inputs': tf.random.normal((2, 5, 6, 4)),
}

layer = __FusedMBConvTF(**INIT_ARGS)
output = layer(**ARGS)
print(f"Output shape: {output.shape}")
Setup block drafted by
a language model, class construct-then-call prompt, model not recorded
Imports
tensorflow — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type EagerTensor, ndim 4, dtype family float, shape (2, 5, 6, 8) — shape (2, 5, 6, 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)
_make_divisible Ran
ran, honoured the contract we drafted
leondgarse/Keras_efficientnet_v2/keras_efficientnet_v2/efficientnet_v2.py
code served (permissive licence) · get_code("29f99c375893c0a7")
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 int, ndim 0, dtype family int, shape () as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch
import numpy as np

# Setup for _make_divisible function
# The function takes:
# - v: a numeric value to make divisible
# - divisor: the divisor to use (default 4)
# - min_value: minimum value threshold (default None)

ARGS = {
    "v": 33,
    "divisor": 4,
    "min_value": None,
}
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 int, ndim 0, dtype family int, shape () — shape () as a later run recorded it
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
_make_divisible Ran
ran, honoured the contract we drafted
DavidLandup0/deepvision/deepvision/models/classification/efficientnet/efficientnetv2.py
code served (permissive licence) · get_code("933cca1f8110f0cc")
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 int, ndim 0, dtype family int, shape () as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch
import numpy as np

# Analyze the function: _make_divisible takes 4 numeric parameters
# filter_num: a number representing filters
# width_coefficient: a scaling coefficient
# depth_divisor: a divisor for depth calculation
# min_depth: minimum depth (can be None)

ARGS = {
    "filter_num": 32,
    "width_coefficient": 1.0,
    "depth_divisor": 8,
    "min_depth": 16
}
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 int, ndim 0, dtype family int, shape () — shape () as a later run recorded it
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
_pair Ran
ran, honoured the contract we drafted
abhuse/pytorch-efficientnet/efficientnet_v2.py
code served (permissive licence) · get_code("9bfd0b1a5faef873")
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) 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 collections.abc as container_abc
import torch

torch.manual_seed(0)

# The function _pair takes a single parameter 'x'
# It checks if x is iterable, and if so returns it as-is
# Otherwise it returns (x, x)

# Test case 1: non-iterable input (int)
x_non_iterable = 5

# Test case 2: iterable input (tuple)
x_iterable = (3, 4)

# We'll use the non-iterable case as the primary test
ARGS = {
    "x": x_non_iterable
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type 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
accuracy Ran
ran on a synthesized input
jahongir7174/EffcientNetV2/utils/util.py
code served (permissive licence) · get_code("279ab9885f76b013")
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 2, dtype family float; no output shape is stated. The image it ran in was not recorded. If your copy returns the same type and ndim on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch

torch.manual_seed(0)

# Create small tensors for the accuracy function
batch_size = 2
num_classes = 4

# output: logits tensor of shape (batch_size, num_classes)
# The function calls output.topk(max_k, 1, True, True)
output = torch.randn(batch_size, num_classes)

# target: ground truth labels of shape (batch_size,)
# The function calls target.size(0) and target.view(1, -1)
target = torch.tensor([0, 2])

# top_k: list of k values to compute top-k accuracy
top_k = [1, 2]

ARGS = {
    "output": output,
    "target": target,
    "top_k": top_k,
}
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 2, 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
arg_to_varname Ran
ran; our contract draft was wrong, not the code
hwzwx1190522/efficientnetv2/efficientnetv2/src/configs/parser.py
pointer only (licence: Apache-2.0); the stored copy get_code serves, from Seongyeol-kim/FedWSQ, is pointer only (licence: NONE) · get_code("177a4abf40724f6e")
How it ran

The body of this sample is withheld: this paper's link allows the body inline (Apache-2.0), but get_code serves the stored copy, first harvested from Seongyeol-kim/FedWSQ, 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.

argv_to_vars Ran
ran; our contract draft was wrong, not the code
hwzwx1190522/efficientnetv2/efficientnetv2/src/configs/parser.py
pointer only (licence: Apache-2.0); the stored copy get_code serves, from Seongyeol-kim/FedWSQ, is pointer only (licence: NONE) · get_code("ffc9d7cced6f71fb")
How it ran

The body of this sample is withheld: this paper's link allows the body inline (Apache-2.0), but get_code serves the stored copy, first harvested from Seongyeol-kim/FedWSQ, 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.

assignment Ran
ran on a synthesized input
hwzwx1190522/efficientnetv2/efficientnetv2/src/models/var_init.py
code served (permissive licence) · get_code("615dd6b5188585cd")
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 0, dtype family float, shape () as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import numpy as np

# Test case 1: scalar array assignment
arr1 = np.array(5.0)
num1 = 10.0

# Test case 2: 1D array assignment with scalar
arr2 = np.array([1.0, 2.0, 3.0, 4.0])
num2 = 7.0

# Test case 3: array assignment with numpy array
arr3 = np.array([1.0, 2.0, 3.0])
num3 = np.array([5.0, 6.0, 7.0])

# Test case 4: 2D array assignment with scalar
arr4 = np.array([[1.0, 2.0], [3.0, 4.0]])
num4 = 9.0

# Use the first test case for the main ARGS
ARGS = {
    "arr": np.array(5.0),
    "num": 10.0
}
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 0, dtype family float, shape () — shape () as a later run recorded it
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
batchnorm_with_activation Ran
ran; our contract draft was wrong, not the code
leondgarse/Keras_efficientnet_v2/keras_efficientnet_v2/efficientnet_v2.py
code served (permissive licence) · get_code("e9ed9f7ced6189ee")
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 KerasTensor. 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 tensorflow as tf
from tensorflow.keras import backend as K
from tensorflow.keras.layers import Input
import numpy as np

# Set up a small input tensor for the function
# The function expects a tensor input and applies batch norm + activation
batch_size = 2
height = 4
width = 3
channels = 5

# Create a small dummy input tensor
input_data = tf.random.normal((batch_size, height, width, channels))

# Create an Input layer to pass to the function
inputs = Input(shape=(height, width, channels))

# Construct ARGS dictionary with all parameters
ARGS = {
    'inputs': inputs,
    'activation': 'swish',
    'use_torch_eps': False,
    'name': 'test_'
}
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 KerasTensor — a KerasTensor output has no array shape of its own; none is stated
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
calcul_acc Ran
ran on a synthesized input
hwzwx1190522/efficientnetv2/efficientnetv2/postprocess.py
code served (permissive licence) · get_code("5af3c724a0f8260c")
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 float, ndim 0, dtype family float, shape () as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch
import numpy as np

torch.manual_seed(0)

# The function calcul_acc takes two parameters: lab (labels) and preds (predictions)
# It iterates through pairs of (label, prediction) and counts matches
# Both should be iterable sequences where elements can be compared with ==

# Create simple label and prediction lists
lab = [0, 1, 1, 0, 1]
preds = [0, 1, 0, 0, 1]

ARGS = {
    "lab": lab,
    "preds": preds
}
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 float, ndim 0, dtype family float, shape () — shape () as a later run recorded it
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
calculate_gain Ran
ran, honoured the contract we drafted
hwzwx1190522/efficientnetv2/efficientnetv2/src/models/var_init.py
code served (permissive licence) · get_code("e460868d0e106ef7")
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 float, ndim 0, dtype family float, shape () as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch
import torch.nn as nn
import math

torch.manual_seed(0)

# Test case 1: linear nonlinearity
ARGS = {
    'nonlinearity': 'relu',
    'param': None
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type float, ndim 0, dtype family float, shape () — shape () as a later run recorded it
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
collate_fn Ran
ran on a synthesized input
danstowell/insect_classifier_GDSC23_insecteffnet/src/custom/data.py
code served (permissive licence) · get_code("428d01f7470ad87b")
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

torch.manual_seed(0)

# Construct a batch of dictionaries with 'wave' and 'labels' keys
batch = [
    {
        'wave': torch.randn(4),
        'labels': torch.randint(0, 2, (3,))
    },
    {
        'wave': torch.randn(4),
        'labels': torch.randint(0, 2, (3,))
    }
]

ARGS = {
    'batch': batch
}
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
compute_pca Ran
ran; our contract draft was wrong, not the code
JohnnyHopp/PaDiM-EfficientNetV2/utils.py
code served (permissive licence) · get_code("4b11257d79964d87")
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) and returned tuple. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch
import numpy as np
from sklearn.decomposition import PCA

torch.manual_seed(0)

class Args:
    def __init__(self, pca=True, npca=False):
        self.pca = pca
        self.npca = npca

args = Args(pca=True, npca=False)

# Create small feature tensors with distinct dimensions
# Each feature is (batch_size=2, feature_dim=4)
features = [
    torch.randn(2, 4),
    torch.randn(2, 4),
]

ARGS = {
    'args': args,
    'features': features,
    'variance_threshold': 0.95
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1
Imports
numpy, sklearn, torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type tuple — a tuple output has no array shape of its own; none is stated
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
conv2d_no_bias Ran
ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT)
leondgarse/Keras_efficientnet_v2/keras_efficientnet_v2/efficientnet_v2.py
code served (permissive licence) · get_code("96248e1c8a073860")
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 4, dtype family float, shape (2, 4, 4, 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 tensorflow as tf
from tensorflow import keras
from tensorflow.keras.layers import Input
import numpy as np

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

# Create a small input tensor: batch_size=2, height=4, width=4, channels=3
input_tensor = Input(shape=(4, 4, 3), batch_size=2)

# Build a functional model to get actual tensor output
dummy_model = keras.Model(inputs=input_tensor, outputs=input_tensor)
actual_input = tf.random.normal((2, 4, 4, 3))

ARGS = {
    'inputs': actual_input,
    'filters': 8,
    'kernel_size': 3,
    'strides': 1,
    'padding': 'SAME',
    'use_torch_padding': False,
    'name': 'test_'
}
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 4, dtype family float, shape (2, 4, 4, 8) — shape (2, 4, 4, 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: none by the harness; any seed is in the setup block
conv_embedding Ran
ran on a synthesized input · constructed an object; no result was computed
szq0214/fkd/FKD/FKD_ViT/SReT.py
code served (permissive licence) · get_code("3b89a9e5b46d66cf")
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, conv_embedding: the run constructed the object and did not call it, so no result was computed. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch
import torch.nn as nn

torch.manual_seed(0)

ARGS = {
    'in_channels': 3,
    'out_channels': 64,
    'patch_size': 16,
    'stride': 2,
    'padding': 1
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type conv_embedding — 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 conv_embedding 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
conv_head_pooling Ran
ran on a synthesized input
szq0214/fkd/FKD/FKD_ViT/SReT.py
code served (permissive licence) · get_code("82db52dd557154d5")
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

# INIT_ARGS for conv_head_pooling.__init__
INIT_ARGS = {
    'in_feature': 8,
    'out_feature': 8,
    'stride': 2,
    'padding_mode': 'zeros'
}

# ARGS for conv_head_pooling.forward
# Input tensor shape: (batch, channels, height, width)
# channels must match in_feature=8
ARGS = {
    'x': torch.randn(2, 8, 16, 12)
}
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)
get_max_amplitude_window_index Ran
ran on a synthesized input
danstowell/insect_classifier_GDSC23_insecteffnet/src/custom/utils.py
code served (permissive licence) · get_code("f905c37ee28fdfb6")
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 int, ndim 0, dtype family int, shape () as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch
import numpy as np
import math

torch.manual_seed(0)

# Create a small waveform tensor
# Shape: (1, 1000) - single channel, 1000 samples
waveform = torch.randn(1, 1000)

# Set samplerate
samplerate = 100

# Create ARGS dict with all parameters
ARGS = {
    "path": "/tmp/dummy_audio.wav",  # dummy path, won't be used since waveform is provided
    "waveform": waveform,
    "samplerate": samplerate,
    "window_length_sec": 2,  # 2 seconds * 100 Hz = 200 samples
    "scan_param": 10,  # scan every 10 samples
    "verbose": True
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy, torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type int, ndim 0, dtype family int, shape () — shape () as a later run recorded it
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
get_min_max Ran
ran on a synthesized input
danstowell/insect_classifier_GDSC23_insecteffnet/src/custom/utils.py
code served (permissive licence) · get_code("19efbee201b88cff")
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 types import SimpleNamespace

torch.manual_seed(0)

class MockConfig(SimpleNamespace):
    def __init__(self):
        super().__init__()
        self.sample_rate = 16000
        self.n_fft = 512
        self.hop_length = 160
        self.n_mels = 64

class MockDataModule:
    def __init__(self, cfg):
        self.cfg = cfg
        self.train = SimpleNamespace(mode='train')
    
    def setup(self):
        pass
    
    def train_dataloader(self):
        batch1 = {'wave': torch.randn(2, 3200)}
        batch2 = {'wave': torch.randn(2, 3200)}
        return [batch1, batch2]

class MockModel(nn.Module):
    def __init__(self, cfg, init_backbone=False):
        super().__init__()
        self.cfg = cfg
        self.linear = nn.Linear(512, 64)
    
    def wav2timefreq(self, wave):
        batch_size = wave.shape[0]
        time_steps = 20
        freq_bins = 64
        spec = torch.randn(batch_size, freq_bins, time_steps)
        return spec

cfg = MockConfig()
dm = MockDataModule
model = MockModel

ARGS = {
    'cfg': cfg,
    'dm': dm,
    'model': model,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
torch, tqdm — 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
kaiming_uniform_ Ran
ran; our contract draft was wrong, not the code
hwzwx1190522/efficientnetv2/efficientnetv2/src/models/var_init.py
code served (permissive licence) · get_code("f3e2d15712198ce4")
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 2, dtype family float, shape (4, 3) as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import numpy as np
import math

# Create a small array with shape (4, 3) to use as input
# This has 4 output feature maps and 3 input feature maps
arr = np.random.randn(4, 3)

ARGS = {
    'arr': arr,
    'a': 0.2,
    'mode': 'fan_in',
    'nonlinearity': 'leaky_relu'
}
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 2, dtype family float, shape (4, 3) — shape (4, 3) as a later run recorded it
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
min_max_norm Ran
ran on a synthesized input
danstowell/insect_classifier_GDSC23_insecteffnet/src/custom/utils.py
code served (permissive licence) · get_code("5c88df91221a8d8c")
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, 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 numpy as np

torch.manual_seed(0)

# Construct a small tensor for x
x = torch.randn(2, 4)

# Define default parameters
min_val = -39.4655
max_val = 53.6203

# Build ARGS dict with all parameters
ARGS = {
    "x": x,
    "min_val": min_val,
    "max_val": max_val,
}
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 Tensor, ndim 2, dtype family float, shape (2, 4) — shape (2, 4) as a later run recorded it
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
parse_model_inputs Ran
ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT)
DavidLandup0/deepvision/deepvision/models/classification/efficientnet/efficientnetv2.py
code served (permissive licence) · get_code("d2941723ae4cc495")
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) and returned KerasTensor. 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 tensorflow as tf
from tensorflow.keras import layers
from tensorflow import keras
import numpy as np

# Test case 1: tensorflow backend with no input_tensor
backend_tf = 'tensorflow'
input_shape_1 = (4, 3)
input_tensor_none = None

# Test case 2: tensorflow backend with keras tensor
input_tensor_keras = layers.Input(shape=(4, 3))

# Test case 3: pytorch backend
backend_pytorch = 'pytorch'
input_tensor_pytorch = tf.constant(np.random.randn(2, 4, 3).astype(np.float32))

# We'll use the first test case for ARGS
ARGS = {
    'backend': 'tensorflow',
    'input_shape': (4, 3),
    'input_tensor': None
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1
Imports
numpy, tensorflow — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type KerasTensor — a KerasTensor output has no array shape of its own; none is stated
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
pca_reduction Ran
ran; our contract draft was wrong, not the code
JohnnyHopp/PaDiM-EfficientNetV2/utils.py
code served (permissive licence) · get_code("56c266222ed70de4")
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) and returned Tensor, ndim 4, dtype family float, shape (2, 2, 3, 5) as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch
import numpy as np

torch.manual_seed(0)

# Create small tensors with distinct dimensions
# features: (batch=2, channels=4, height=3, width=5)
features = torch.randn(2, 4, 3, 5)

# pca_mean: (channels=4,) - mean for each channel
pca_mean = torch.randn(4)

# pca_components: (n_components=2, channels=4) - PCA components matrix
pca_components = torch.randn(2, 4)

# device: CPU or CUDA
device = torch.device("cpu")

ARGS = {
    "features": features,
    "pca_mean": pca_mean,
    "pca_components": pca_components,
    "device": device,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1
Imports
numpy, sklearn, 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, 2, 3, 5) — shape (2, 2, 3, 5) as a later run recorded it
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
rotate Ran
ran on a synthesized input
jahongir7174/EffcientNetV2/utils/util.py
code served (permissive licence) · get_code("8d9311e021af04d6")
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 Image. 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 random
from PIL import Image
import numpy as np

# Create a small test image
image_array = np.random.randint(0, 256, (64, 64, 3), dtype=np.uint8)
test_image = Image.fromarray(image_array, mode='RGB')

# Define magnitude as a float value between 0 and 10
magnitude = 5.5

ARGS = {
    'image': test_image,
    'magnitude': magnitude
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
PIL, numpy — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type Image — a Image output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a Image output the recorded ndim 3 and dtype family int 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
round_filters Ran
ran, honoured the contract we drafted
seermer/TensorFlow2-EfficientNetV2/efficientnetV2.py
code served (permissive licence) · get_code("e60387e9529f63ff")
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) and returned int, ndim 0, dtype family int, shape () as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch
import numpy as np

torch.manual_seed(0)

ARGS = {
    "filters": 32,
    "multiplier": 1.5
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1
Imports
numpy, torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type int, ndim 0, dtype family int, shape () — shape () as a later run recorded it
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
round_filters Ran
ran, honoured the contract we drafted
google/automl/efficientnetv2/effnetv2_model.py
code served (permissive licence) · get_code("5640ec0612debaea")
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) and returned int, ndim 0, dtype family int, shape () as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch
import numpy as np

class MockMConfig:
    def __init__(self, width_coefficient, depth_divisor, min_depth):
        self.width_coefficient = width_coefficient
        self.depth_divisor = depth_divisor
        self.min_depth = min_depth

mconfig = MockMConfig(
    width_coefficient=1.2,
    depth_divisor=8,
    min_depth=16
)

ARGS = {
    "filters": 32,
    "mconfig": mconfig,
    "skip": False
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1
Imports
numpy, torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type int, ndim 0, dtype family int, shape () — shape () as a later run recorded it
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
round_filters Ran
ran, honoured the contract we drafted
Klassikcat/project-NEXTLab-CNN-EfficientNet/EfficientNet_codestates/model/model.py
pointer only (licence: NONE) · get_code("8c25eeaec4c91203")
How it ran

The body of this sample is withheld: GitHub detected no licence in this paper's repository, Klassikcat/project-NEXTLab-CNN-EfficientNet 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.

round_filters Ran
ran, honoured the contract we drafted
abhuse/pytorch-efficientnet/efficientnet_v2.py
code served (permissive licence) · get_code("6c7d046d7dd60b22")
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) and returned int, ndim 0, dtype family int, shape () as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch
import numpy as np

torch.manual_seed(0)

ARGS = {
    "filters": 32,
    "width_coefficient": 1.2,
    "depth_divisor": 8
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1
Imports
numpy, torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type int, ndim 0, dtype family int, shape () — shape () as a later run recorded it
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
round_repeats Ran
ran, honoured the contract we drafted
seermer/TensorFlow2-EfficientNetV2/efficientnetV2.py
code served (permissive licence) · get_code("1a9d7e65e0a9fbc9")
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) and returned int, ndim 0, dtype family int, shape () as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import math

def round_repeats(repeats, multiplier=1.0):
    return int(math.ceil(multiplier * repeats))

ARGS = {
    "repeats": 5,
    "multiplier": 1.5
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1
Imports
none outside the standard library — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type int, ndim 0, dtype family int, shape () — shape () as a later run recorded it
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
round_repeats Ran
ran, honoured the contract we drafted
Klassikcat/project-NEXTLab-CNN-EfficientNet/EfficientNet_codestates/model/model.py
pointer only (licence: NONE) · get_code("f93cb693ac8bb537")
How it ran

The body of this sample is withheld: GitHub detected no licence in this paper's repository, Klassikcat/project-NEXTLab-CNN-EfficientNet 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.

round_repeats Ran
ran, honoured the contract we drafted
abhuse/pytorch-efficientnet/efficientnet_v2.py
code served (permissive licence) · get_code("167f9f74323c7278")
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) and returned int, ndim 0, dtype family int, shape () as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

from math import ceil, floor

def round_repeats(repeats, depth_coefficient):
    """Round number of filters based on depth multiplier."""
    return int(ceil(depth_coefficient * repeats))

ARGS = {
    "repeats": 4,
    "depth_coefficient": 1.2
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1
Imports
none outside the standard library — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type int, ndim 0, dtype family int, shape () — shape () as a later run recorded it
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
same_padding Ran
ran, honoured the contract we drafted
DavidLandup0/deepvision/deepvision/models/classification/efficientnet/efficientnetv2.py
code served (permissive licence) · get_code("ec08335b5c6ecfc3")
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) and returned int, ndim 0, dtype family int, shape () as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch
import torch.nn as nn

torch.manual_seed(0)

ARGS = {
    "kernel_size": 3,
    "stride": 2,
    "dilation": 1,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type int, ndim 0, dtype family int, shape () — shape () as a later run recorded it
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
se_module Ran
ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT)
leondgarse/Keras_efficientnet_v2/keras_efficientnet_v2/efficientnet_v2.py
code served (permissive licence) · get_code("b43c2e4c5402cf83")
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 4, dtype family float, shape (2, 4, 3, 5) as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import tensorflow as tf
from tensorflow import keras
from tensorflow.keras import backend as K
from tensorflow.keras.layers import Input

# Set up a small input tensor
# Batch size 2, height 4, width 3, channels 5
inputs = tf.random.normal((2, 4, 3, 5), dtype=tf.float32)

# Define ARGS dict with all parameters
ARGS = {
    'inputs': inputs,
    'se_ratio': 4,
    'name': 'se_test_'
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
tensorflow — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type EagerTensor, ndim 4, dtype family float, shape (2, 4, 3, 5) — shape (2, 4, 3, 5) as a later run recorded it
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
torch_conv_out_spatial_shape Ran
ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT)
abhuse/pytorch-efficientnet/efficientnet_v2.py
code served (permissive licence) · get_code("97d77e37b5677cd8")
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) and returned tuple, ndim 1, dtype family int; no output shape is stated. The image it ran in was not recorded. If your copy returns the same type and ndim on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch
import collections.abc as container_abc
from math import ceil, floor

def _pair(x):
    if isinstance(x, container_abc.Iterable):
        return x
    return (x, x)

def torch_conv_out_spatial_shape(in_spatial_shape, kernel_size, stride):
    if in_spatial_shape is None:
        return None
    hin, win = _pair(in_spatial_shape)
    kh, kw = _pair(kernel_size)
    sh, sw = _pair(stride)
    hout = int(floor((hin - kh - 1) / sh + 1))
    wout = int(floor((win - kw - 1) / sw + 1))
    return (hout, wout)

torch.manual_seed(0)

ARGS = {
    "in_spatial_shape": (32, 48),
    "kernel_size": 3,
    "stride": 1
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type 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
trim_preceding_hyphens Ran
ran; our contract draft was wrong, not the code
hwzwx1190522/efficientnetv2/efficientnetv2/src/configs/parser.py
pointer only (licence: Apache-2.0); the stored copy get_code serves, from Seongyeol-kim/FedWSQ, is pointer only (licence: NONE) · get_code("a99f170ebd682af5")
How it ran

The body of this sample is withheld: this paper's link allows the body inline (Apache-2.0), but get_code serves the stored copy, first harvested from Seongyeol-kim/FedWSQ, 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.

weight_decay Ran
ran on a synthesized input
jahongir7174/EffcientNetV2/utils/util.py
code served (permissive licence) · get_code("3e49c5fa4dfff12e")
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 torch
import torch.nn as nn

torch.manual_seed(0)

class SimpleModel(nn.Module):
    def __init__(self):
        super().__init__()
        # Create parameters with different shapes to test the logic
        self.linear1 = nn.Linear(4, 3)  # weight: (3, 4), bias: (3,)
        self.linear2 = nn.Linear(3, 2)  # weight: (2, 3), bias: (2,)
        self.norm = nn.BatchNorm1d(2)   # weight: (2,), bias: (2,)
    
    def forward(self, x):
        x = self.linear1(x)
        x = self.linear2(x)
        x = self.norm(x)
        return x

model = SimpleModel()

ARGS = {
    'model': model,
    'decay': 1e-05
}
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 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
DenseKernalInitializer Not yet run
unverified (harvested, no recorded run)
Klassikcat/project-NEXTLab-CNN-EfficientNet/EfficientNet_codestates/model/model.py
pointer only (licence: NONE) · get_code("e19de965ff30b13f")
How it ran

The body of this sample is withheld: GitHub detected no licence in this paper's repository, Klassikcat/project-NEXTLab-CNN-EfficientNet 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.

DropConnect Not yet run
unverified (harvested, no recorded run)
Klassikcat/project-NEXTLab-CNN-EfficientNet/EfficientNet_codestates/model/model.py
pointer only (licence: NONE) · get_code("46312249974aad39")
How it ran

The body of this sample is withheld: GitHub detected no licence in this paper's repository, Klassikcat/project-NEXTLab-CNN-EfficientNet 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.

EffNetV2 Not yet run
unverified (harvested, no recorded run)
d-li14/efficientnetv2.pytorch/effnetv2.py
code served (permissive licence) · get_code("cead257166f9875e")
How it ran

no invocation recorded.

EfficientNet Not yet run
unverified (harvested, no recorded run)
Klassikcat/project-NEXTLab-CNN-EfficientNet/EfficientNet_codestates/model/model.py
pointer only (licence: NONE) · get_code("17727025309b999a")
How it ran

The body of this sample is withheld: GitHub detected no licence in this paper's repository, Klassikcat/project-NEXTLab-CNN-EfficientNet 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.

EfficientNetV2 Not yet run
unverified (harvested, no recorded run)
leondgarse/Keras_efficientnet_v2/keras_efficientnet_v2/efficientnet_v2.py
code served (permissive licence) · get_code("b5e6a1fcfb844a2d")
How it ran

no invocation recorded.

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

Also present in other papers' code

Of 79 samples lifted from this paper's linked repositories, 79 carry a function identity and 0 do not. Of the 79 distinct functions with an identity, 22 are also present in other papers whose code we hold (17 with at least one paper dated earlier, 1 the same month, 11 later) and 57 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
round_repeats
brick of this paper's assembly: helper
30 other papers
12 dated earlier, 2 the same month, 16 later · 3 only as an assembly brick
1808.08127 (2018-08)
Recalibrating Fully Convolutional Networks with Spatial and Channel 'Squeeze &amp; Excitation' Blocks
1905.11946 (2019-05)
EfficientNet: Rethinking Model Scaling for Convolutional Neural Networks
1911.09070 (2019-11)
EfficientDet: Scalable and Efficient Object Detection
and 27 more not named here
arg_to_varname 9 other papers
2 dated earlier, 7 later
1512.03385 (2015-12)
Deep Residual Learning for Image Recognition
1911.13299 (2019-11)
What's Hidden in a Randomly Weighted Neural Network?
2105.15203 (2021-05)
SegFormer: Simple and Efficient Design for Semantic Segmentation with Transformers
and 6 more not named here
trim_preceding_hyphens 9 other papers
2 dated earlier, 7 later
1512.03385 (2015-12)
Deep Residual Learning for Image Recognition
1911.13299 (2019-11)
What's Hidden in a Randomly Weighted Neural Network?
2105.15203 (2021-05)
SegFormer: Simple and Efficient Design for Semantic Segmentation with Transformers
and 6 more not named here
argv_to_vars 8 other papers
2 dated earlier, 6 later
1512.03385 (2015-12)
Deep Residual Learning for Image Recognition
1911.13299 (2019-11)
What's Hidden in a Randomly Weighted Neural Network?
2110.14068 (2021-10)
Drawing Robust Scratch Tickets: Subnetworks with Inborn Robustness Are Found within Randomly Initialized Networks
and 5 more not named here
calcul_acc 4 other papers
4 dated earlier
1512.03385 (2015-12)
Deep Residual Learning for Image Recognition
1807.11164 (2018-07)
ShuffleNet V2: Practical Guidelines for Efficient CNN Architecture Design
1811.12814 (2018-11)
Graph-Based Global Reasoning Networks
and 1 more not named here
calculate_gain 3 other papers
1 dated earlier, 2 later
1804.02767 (2018-04)
YOLOv3: An Incremental Improvement
2105.15203 (2021-05)
SegFormer: Simple and Efficient Design for Semantic Segmentation with Transformers
2107.08430 (2021-07)
YOLOX: Exceeding YOLO Series in 2021
kaiming_uniform_ 2 other papers
1 dated earlier, 1 later
1804.02767 (2018-04)
YOLOv3: An Incremental Improvement
2107.08430 (2021-07)
YOLOX: Exceeding YOLO Series in 2021
round_filters 2 other papers
2 dated earlier
1812.01187 (2018-12)
Bag of Tricks for Image Classification with Convolutional Neural Networks
1911.11907 (2019-11)
GhostNet: More Features from Cheap Operations
round_repeats 2 other papers
2 dated earlier
1812.01187 (2018-12)
Bag of Tricks for Image Classification with Convolutional Neural Networks
1911.11907 (2019-11)
GhostNet: More Features from Cheap Operations
assignment 1 other paper
1 later
2105.15203 (2021-05)
SegFormer: Simple and Efficient Design for Semantic Segmentation with Transformers
batchnorm_with_activation
brick of this paper's assembly: model
1 other paper
1 dated earlier
1911.04252 (2019-11)
Self-training with Noisy Student improves ImageNet classification
conv2d_no_bias
brick of this paper's assembly: helper
1 other paper
1 dated earlier
1911.04252 (2019-11)
Self-training with Noisy Student improves ImageNet classification
conv_head_pooling 1 other paper
1 dated earlier · 1 only as an assembly brick
2103.16302 (2021-03)
Rethinking Spatial Dimensions of Vision Transformers
get_activation
brick of this paper's assembly: helper
1 other paper
1 later
2310.04361 (2023-10)
Exploiting Activation Sparsity with Dense to Dynamic-k Mixture-of-Experts Conversion
parse_model_inputs
brick of this paper's assembly: helper
1 other paper
1 later
2105.15203 (2021-05)
SegFormer: Simple and Efficient Design for Semantic Segmentation with Transformers
reload_model_weights
brick of this paper's assembly: helper
1 other paper
1 dated earlier · 1 only as an assembly brick
1911.04252 (2019-11)
Self-training with Noisy Student improves ImageNet classification
round_filters
brick of this paper's assembly: helper
1 other paper
1 dated earlier · 1 only as an assembly brick
1905.11946 (2019-05)
EfficientNet: Rethinking Model Scaling for Convolutional Neural Networks
round_filters
brick of this paper's assembly: helper
1 other paper
1 later
2310.04361 (2023-10)
Exploiting Activation Sparsity with Dense to Dynamic-k Mixture-of-Experts Conversion
round_filters 1 other paper
1 dated earlier
1911.04252 (2019-11)
Self-training with Noisy Student improves ImageNet classification
round_repeats
brick of this paper's assembly: helper
1 other paper
1 dated earlier
1905.11946 (2019-05)
EfficientNet: Rethinking Model Scaling for Convolutional Neural Networks

Shown: the 20 functions present in the most other papers. 2 more shared functions are not listed here.

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

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

Abstract

This paper introduces EfficientNetV2, a new family of convolutional networks that have faster training speed and better parameter efficiency than previous models. To develop these models, we use a combination of training-aware neural architecture search and scaling, to jointly optimize training speed and parameter efficiency. The models were searched from the search space enriched with new ops such as Fused-MBConv. Our experiments show that EfficientNetV2 models train much faster than state-of-the-art models while being up to 6.8x smaller. Our training can be further sped up by progressively increasing the image size during training, but it often causes a drop in accuracy. To compensate for this accuracy drop, we propose an improved method of progressive learning, which adaptively adjusts regularization (e.g. data augmentation) along with image size. With progressive learning, our EfficientNetV2 significantly outperforms previous models on Im-ageNet and CIFAR/Cars/Flowers datasets. By pretraining on the same ImageNet21k, our Effi-cientNetV2 achieves 87.3% top-1 accuracy on ImageNet ILSVRC2012, outperforming the recent ViT by 2.0% accuracy while training 5x-11x faster using the same computing resources. Code is available at https://github.com/google/ automl/tree/master/efficientnetv2.

For agents

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

get_harvested_code_for_paper("2104.00298")
get_code_for_paper("2104.00298")
have("2104.00298")

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

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

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

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

Connect an agent — have() is free.