SYNTOLOGY HomeExplorerAtlasCodeMethodologyAboutDevelopersFeedPricing
Paper · 1905.02244 · ICCV · 2019

Searching for MobileNetV3

Quoc Le, Mingxing Tan, Ruoming Pang, Yukun Zhu, Hartwig Adam, Liang-Chieh Chen, Mark Sandler, Bo Chen, Vijay Vasudevan, Andrew Howard, Weijun Wang, Grace Chu, and 1 more

arXiv · PDF · Open in the Atlas

Code that ran

86 of 105 samples (functions and classes) lifted from this paper's linked repositories executed on a synthesized input in Syntology's jail (22 of them constructed an object rather than computing a result; 11 honoured the contract we drafted, 2 violated it and 57 have no contract verdict; 16 failures of our instrument; 19 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/1905.02244.json · badge: /api/ran/1905.02244.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
emilianavt/OpenSeeFace community (classifier label)
classifier basis not recorded on the link
11 ran · 4 no recorded run
Randl/MobileNetV3-pytorch community
Papers with Code archive
9 ran · 2 no recorded run
chris-boson/fashion_mnist community
Papers with Code archive
9 ran · 0 no recorded run
rwightman/genmobilenet-pytorch community (classifier label)
classifier basis not recorded on the link
6 ran · 5 no recorded run
showlo/mobilenetv3 community
not in the paper's declared repositories
6 ran · 0 no recorded run
SpikeKing/mobilenet_v3 community
Papers with Code archive
5 ran · 2 no recorded run
t-hanya/kuzushiji-recognition community (classifier label)
classifier basis not recorded on the link
5 ran · 1 no recorded run
PolinaDruzhinina/modelnet community
Papers with Code archive
5 ran · 0 no recorded run
OniroAI/Instance-segmentation-with-MobileNetV3 community
not in the paper's declared repositories
5 ran · 0 no recorded run
xiaolai-sqlai/mobilenetv3 community (classifier label)
classifier basis not recorded on the link
5 ran · 0 no recorded run
rwightman/efficientnet-jax community
Papers with Code archive
4 ran · 1 no recorded run
wang-zidu/3ddfa-v3 community
not in the paper's declared repositories
4 ran · 0 no recorded run
ckyrkou/EmergencyNet community
Papers with Code archive
3 ran · 1 no recorded run
ujsyehao/mobilenetv3-ssd community
not in the paper's declared repositories
2 ran · 0 no recorded run
ekzhang/fastseg community (classifier label)
classifier basis not recorded on the link
1 ran · 2 no recorded run
pengboxiangshang/mobilenetv3_pytorch community
Papers with Code archive
1 ran · 0 no recorded run
tiagoCuervo/JapaNet community
not in the paper's declared repositories
1 ran · 0 no recorded run
kuan-wang/pytorch-mobilenet-v3 community
Papers with Code archive
1 ran · 0 no recorded run
TheConstant3/MobileNetV3-Keras community
Papers with Code archive
1 ran · 0 no recorded run
d-li14/mobilenetv3.pytorch community
Papers with Code archive
1 ran · 0 no recorded run
atregret/mobilenetv3 community (classifier label)
classifier basis not recorded on the link
1 ran · 0 no recorded run
xiaochus/MobileNetV3 community (classifier label)
classifier basis not recorded on the link
0 ran · 1 no recorded run
FunctionStatusWhere it lives
Bottleneck Ran
ran on a synthesized input · constructed an object; no result was computed
showlo/mobilenetv3/mobileNetV3.py
pointer only (licence: NONE) · get_code("9a228be8d95a8267")
How it ran

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

BottleneckSE Ran
ran on a synthesized input · constructed an object; no result was computed
PolinaDruzhinina/modelnet/models/mobilenetv3.py
pointer only (licence: NONE) · get_code("9e476824ce6c9115")
How it ran

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

ConvBlock Ran
ran on a synthesized input · constructed an object; no result was computed
OniroAI/Instance-segmentation-with-MobileNetV3/modules/keras_models.py
pointer only (licence: GPL-3.0) · get_code("379eb0ad4b8f3ec3")
How it ran

The body of this sample is withheld: GPL-3.0, as GitHub detects it on this paper's repository, OniroAI/Instance-segmentation-with-MobileNetV3, is not in the permissive set Syntology serves inline. 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.

DropBlock2D Ran
ran on a synthesized input
Randl/MobileNetV3-pytorch/MobileNetV3.py
code served (permissive licence) · get_code("eea0d2df8bb7cbe4")
How it ran

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

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

class DropBlock2D(nn.Module):
    """Randomly zeroes 2D spatial blocks of the input tensor.

    As described in the paper
    `DropBlock: A regularization method for convolutional networks`_ ,
    dropping whole blocks of feature map allows to remove semantic
    information as compared to regular dropout.

    Args:
        drop_prob (float): probability of an element to be dropped.
        block_size (int): size of the block to drop

    Shape:
        - Input: `(N, C, H, W)`
        - Output: `(N, C, H, W)`

    .. _DropBlock: A regularization method for convolutional networks:
       https://arxiv.org/abs/1810.12890

    """

    def __init__(self, drop_prob, block_size):
        super(DropBlock2D, self).__init__()
        self.register_buffer('drop_prob', drop_prob * torch.ones(1, dtype=torch.float32))
        self.block_size = block_size

    def forward(self, x):
        assert x.dim() == 4, 'Expected input with 4 dimensions (bsize, channels, height, width)'
        if not self.training or self.drop_prob == 0.0:
            return x
        else:
            gamma = self._compute_gamma(x)
            mask = (torch.rand(x.shape[0], *x.shape[2:]) < gamma).to(x)
            block_mask, keeped = self._compute_block_mask(mask)
            out = x * block_mask[:, None, :, :]
            out = out * (block_mask.numel() / keeped).to(out)
            return out

    def _compute_block_mask(self, mask):
        block_mask = F.max_pool2d(input=mask[:, None, :, :], kernel_size=(self.block_size, self.block_size), stride=(1, 1), padding=self.block_size // 2)
        if self.block_size % 2 == 0:
            block_mask = block_mask[:, :, :-1, :-1]
        keeped = block_mask.numel() - block_mask.sum().to(torch.float32)
        block_mask = 1 - block_mask.squeeze(1)
        return (block_mask, keeped)

    def _compute_gamma(self, x):
        return self.drop_prob.item() / self.block_size ** 2


INIT_ARGS = {
    'drop_prob': 0.1,
    'block_size': 3,
}

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

if __name__ == '__main__':
    model = DropBlock2D(**INIT_ARGS)
    model.train()
    output = model(**ARGS)
    print(f"Input shape: {ARGS['x'].shape}")
    print(f"Output shape: {output.shape}")
    print(f"Output:\n{output}")
Setup block drafted by
a language model, class construct-then-call prompt, model not recorded
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type Tensor, ndim 4, dtype family float, shape (2, 4, 8, 6) — shape (2, 4, 8, 6) as a later run recorded it
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: torch and numpy seeded to 0 by the harness immediately before the class was constructed from INIT_ARGS (fixture_check.py)
DropBlockScheduled Ran
ran on a synthesized input
Randl/MobileNetV3-pytorch/MobileNetV3.py
code served (permissive licence) · get_code("d44d7e19fe65cbc2")
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

class SimpleDropBlock(nn.Module):
    def __init__(self, drop_prob=0.0, block_size=7):
        super(SimpleDropBlock, self).__init__()
        self.drop_prob = nn.Parameter(torch.tensor([drop_prob]), requires_grad=False)
        self.block_size = block_size
    
    def forward(self, x):
        if not self.training or self.drop_prob[0] == 0:
            return x
        
        gamma = self.drop_prob[0] / (self.block_size ** 2)
        mask = torch.bernoulli(torch.ones_like(x) * (1 - gamma))
        
        block_mask = nn.functional.max_pool2d(
            mask,
            kernel_size=self.block_size,
            stride=1,
            padding=self.block_size // 2
        )
        
        block_mask = 1 - block_mask
        normalize_factor = block_mask.numel() / (block_mask.sum() + 1e-7)
        
        return x * block_mask * normalize_factor

dropblock = SimpleDropBlock(drop_prob=0.0, block_size=3)

INIT_ARGS = {
    'dropblock': dropblock,
    'start_value': 0.0,
    'stop_value': 0.5,
    'nr_steps': 10,
    'start_step': 0
}

ARGS = {
    'x': torch.randn(2, 3, 8, 8)
}
Setup block drafted by
a language model, class construct-then-call prompt, model not recorded
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type Tensor, ndim 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)
EfficientHead Ran
ran on a synthesized input · constructed an object; no result was computed
rwightman/efficientnet-jax/jeffnet/linen/blocks_linen.py
code served (permissive licence) · get_code("fae9673025e2a220")
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, EfficientHead: 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 jax
import jax.numpy as jnp
import flax.linen as nn
from functools import partial

# Define minimal stand-in implementations for the conv_layer and linear_layer
def minimal_conv2d(features, kernel_size, stride=None, padding=0, dilation=None, 
                   groups=1, bias=False, dtype=jnp.float32, precision=None, 
                   name=None, kernel_init=None, bias_init=None):
    """Minimal conv2d that returns a Conv module."""
    stride = stride or 1
    dilation = dilation or 1
    if isinstance(padding, str):
        padding = 0
    else:
        padding = padding if isinstance(padding, (tuple, list)) else (padding, padding)
    
    return nn.Conv(
        features=features,
        kernel_size=(kernel_size, kernel_size) if isinstance(kernel_size, int) else kernel_size,
        strides=(stride, stride) if isinstance(stride, int) else stride,
        padding=padding,
        kernel_dilation=(dilation, dilation) if isinstance(dilation, int) else dilation,
        feature_group_count=groups,
        use_bias=bias,
        dtype=dtype,
        precision=precision,
        name=name,
        kernel_init=kernel_init,
        bias_init=bias_init
    )

def minimal_linear(features, bias=True, dtype=jnp.float32, name=None, 
                   kernel_init=None, bias_init=None):
    """Minimal linear layer that returns a Dense module."""
    return nn.Dense(
        features=features,
        use_bias=bias,
        dtype=dtype,
        name=name,
        kernel_init=kernel_init,
        bias_init=bias_init
    )

# Minimal activation function
def minimal_act_fn(x):
    return nn.relu(x)

# Build arguments dictionary
ARGS = {
    'num_features': 128,
    'num_classes': 10,
    'global_pool': 'avg',
    'drop_rate': 0.2,
    'dtype': jnp.float32,
    'conv_layer': minimal_conv2d,
    'norm_layer': None,
    'linear_layer': minimal_linear,
    'act_fn': minimal_act_fn,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
flax, jax — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type EfficientHead — 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 EfficientHead 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
H_sigmoid Ran
ran on a synthesized input · constructed an object; no result was computed
showlo/mobilenetv3/mobileNetV3.py
pointer only (licence: NONE) · get_code("557fa0210dc2d24b")
How it ran

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

H_swish Ran
ran on a synthesized input · constructed an object; no result was computed
showlo/mobilenetv3/mobileNetV3.py
pointer only (licence: NONE) · get_code("0d8cfba511f31324")
How it ran

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

HardSigmoid Ran
ran on a synthesized input
Randl/MobileNetV3-pytorch/MobileNetV3.py
code served (permissive licence) · get_code("fda5ccaf76461ba5")
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 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 torch.nn as nn
import torch.nn.functional as F

def hard_sigmoid(x, inplace=False):
    return F.relu6(x + 3, inplace) / 6

class HardSigmoid(nn.Module):

    def __init__(self, inplace=False):
        super(HardSigmoid, self).__init__()
        self.inplace = inplace

    def forward(self, x):
        return hard_sigmoid(x, inplace=self.inplace)


INIT_ARGS = {
    'inplace': False
}

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

if __name__ == '__main__':
    module = HardSigmoid(**INIT_ARGS)
    output = module(**ARGS)
    print(output)
Setup block drafted by
a language model, class construct-then-call prompt, model not recorded
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type Tensor, ndim 2, dtype family float, shape (2, 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: torch and numpy seeded to 0 by the harness immediately before the class was constructed from INIT_ARGS (fixture_check.py)
HardSwish Ran
ran on a synthesized input
Randl/MobileNetV3-pytorch/MobileNetV3.py
code served (permissive licence) · get_code("0ae7cf2c14285d34")
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 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 torch.nn as nn
import torch.nn.functional as F

def hard_sigmoid(x, inplace=False):
    return F.relu6(x + 3, inplace) / 6

def hard_swish(x, inplace=False):
    return x * hard_sigmoid(x, inplace)

class HardSwish(nn.Module):

    def __init__(self, inplace=False):
        super(HardSwish, self).__init__()
        self.inplace = inplace

    def forward(self, x):
        return hard_swish(x, inplace=self.inplace)


INIT_ARGS = {
    'inplace': False
}

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

if __name__ == '__main__':
    module = HardSwish(**INIT_ARGS)
    output = module(**ARGS)
    print(output)
Setup block drafted by
a language model, class construct-then-call prompt, model not recorded
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type Tensor, ndim 2, dtype family float, shape (2, 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: torch and numpy seeded to 0 by the harness immediately before the class was constructed from INIT_ARGS (fixture_check.py)
Hsigmoid Ran
ran on a synthesized input · constructed an object; no result was computed
chris-boson/fashion_mnist/trainer/models/mobilenetv3.py
pointer only (licence: NONE) · get_code("4a269a6484171c4e")
How it ran

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

Hswish Ran
ran on a synthesized input · constructed an object; no result was computed
chris-boson/fashion_mnist/trainer/models/mobilenetv3.py
pointer only (licence: NONE) · get_code("d276d941f05c6062")
How it ran

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

Identity Ran
ran on a synthesized input · constructed an object; no result was computed
chris-boson/fashion_mnist/trainer/models/mobilenetv3.py
pointer only (licence: NONE) · get_code("9942e2eaf6ad275b")
How it ran

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

InvertedResidual Ran
ran on a synthesized input · constructed an object; no result was computed
wang-zidu/3ddfa-v3/model/mb_v3_networks.py
code served (permissive licence) · get_code("708f8102eea91f9e")
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, InvertedResidual: the run constructed the object and did not call it, so no result was computed. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch
import torch.nn as nn

torch.manual_seed(0)

class h_sigmoid(nn.Module):
    def __init__(self, inplace=True):
        super(h_sigmoid, self).__init__()
        self.relu = nn.ReLU6(inplace=inplace)

    def forward(self, x):
        return self.relu(x + 3) / 6

class h_swish(nn.Module):
    def __init__(self, inplace=True):
        super(h_swish, self).__init__()
        self.sigmoid = h_sigmoid(inplace=inplace)

    def forward(self, x):
        return x * self.sigmoid(x)

def _make_divisible(v, divisor, min_value=None):
    if min_value is None:
        min_value = divisor
    new_v = max(min_value, int(v + divisor / 2) // divisor * divisor)
    if new_v < 0.9 * v:
        new_v += divisor
    return new_v

class SELayer(nn.Module):
    def __init__(self, channel, reduction=4):
        super(SELayer, self).__init__()
        self.avg_pool = nn.AdaptiveAvgPool2d(1)
        self.fc = nn.Sequential(
            nn.Linear(channel, _make_divisible(channel // reduction, 8)),
            nn.ReLU(inplace=True),
            nn.Linear(_make_divisible(channel // reduction, 8), channel),
            h_sigmoid()
        )

    def forward(self, x):
        b, c, _, _ = x.size()
        y = self.avg_pool(x).view(b, c)
        y = self.fc(y).view(b, c, 1, 1)
        return x * y

class InvertedResidual(nn.Module):
    def __init__(self, inp, hidden_dim, oup, kernel_size, stride, use_se, use_hs):
        super(InvertedResidual, self).__init__()
        assert stride in [1, 2]
        self.identity = stride == 1 and inp == oup
        if inp == hidden_dim:
            self.conv = nn.Sequential(
                nn.Conv2d(hidden_dim, hidden_dim, kernel_size, stride, (kernel_size - 1) // 2, groups=hidden_dim, bias=False),
                nn.BatchNorm2d(hidden_dim),
                h_swish() if use_hs else nn.ReLU(inplace=True),
                SELayer(hidden_dim) if use_se else nn.Identity(),
                nn.Conv2d(hidden_dim, oup, 1, 1, 0, bias=False),
                nn.BatchNorm2d(oup)
            )
        else:
            self.conv = nn.Sequential(
                nn.Conv2d(inp, hidden_dim, 1, 1, 0, bias=False),
                nn.BatchNorm2d(hidden_dim),
                h_swish() if use_hs else nn.ReLU(inplace=True),
                nn.Conv2d(hidden_dim, hidden_dim, kernel_size, stride, (kernel_size - 1) // 2, groups=hidden_dim, bias=False),
                nn.BatchNorm2d(hidden_dim),
                SELayer(hidden_dim) if use_se else nn.Identity(),
                h_swish() if use_hs else nn.ReLU(inplace=True),
                nn.Conv2d(hidden_dim, oup, 1, 1, 0, bias=False),
                nn.BatchNorm2d(oup)
            )

    def forward(self, x):
        if self.identity:
            return x + self.conv(x)
        else:
            return self.conv(x)

ARGS = {
    'inp': 16,
    'hidden_dim': 32,
    'oup': 24,
    'kernel_size': 3,
    'stride': 1,
    'use_se': True,
    'use_hs': True
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type InvertedResidual — 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 InvertedResidual 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
LastBlockLarge Ran
ran on a synthesized input
Randl/MobileNetV3-pytorch/MobileNetV3.py
code served (permissive licence) · get_code("3b87793a966b3e95")
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 2, dtype family float, shape (2, 3) as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

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

class HardSwish(nn.Module):

    def __init__(self, inplace=False):
        super(HardSwish, self).__init__()
        self.inplace = inplace

    def forward(self, x):
        return hard_swish(x, inplace=self.inplace)

def hard_sigmoid(x, inplace=False):
    return F.relu6(x + 3, inplace) / 6

def hard_swish(x, inplace=False):
    return x * hard_sigmoid(x, inplace)

class LastBlockLarge(nn.Module):

    def __init__(self, inplanes, num_classes, expplanes1, expplanes2):
        super(LastBlockLarge, self).__init__()
        self.conv1 = nn.Conv2d(inplanes, expplanes1, kernel_size=1, bias=False)
        self.bn1 = nn.BatchNorm2d(expplanes1)
        self.act1 = HardSwish(inplace=True)
        self.avgpool = nn.AdaptiveAvgPool2d(1)
        self.conv2 = nn.Conv2d(expplanes1, expplanes2, kernel_size=1, stride=1)
        self.act2 = HardSwish(inplace=True)
        self.dropout = nn.Dropout(p=0.2, inplace=True)
        self.fc = nn.Linear(expplanes2, num_classes)
        self.expplanes1 = expplanes1
        self.expplanes2 = expplanes2
        self.inplanes = inplanes
        self.num_classes = num_classes

    def forward(self, x):
        out = self.conv1(x)
        out = self.bn1(out)
        out = self.act1(out)
        out = self.avgpool(out)
        out = self.conv2(out)
        out = self.act2(out)
        out = out.view(out.size(0), -1)
        out = self.fc(self.dropout(out))
        return out

INIT_ARGS = {
    'inplanes': 4,
    'num_classes': 3,
    'expplanes1': 8,
    'expplanes2': 6,
}

ARGS = {
    'x': torch.randn(2, 4, 5, 5),
}
Setup block drafted by
a language model, class construct-then-call prompt, model not recorded
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type Tensor, ndim 2, dtype family float, shape (2, 3) — shape (2, 3) as a later run recorded it
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: torch and numpy seeded to 0 by the harness immediately before the class was constructed from INIT_ARGS (fixture_check.py)
LastBlockSmall Ran
ran on a synthesized input
Randl/MobileNetV3-pytorch/MobileNetV3.py
code served (permissive licence) · get_code("ace014323d335247")
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 2, dtype family float, shape (2, 3) as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

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

# Define the helper functions and classes needed
def hard_sigmoid(x, inplace=False):
    return F.relu6(x + 3, inplace) / 6

def hard_swish(x, inplace=False):
    return x * hard_sigmoid(x, inplace)

class HardSigmoid(nn.Module):
    def __init__(self, inplace=False):
        super(HardSigmoid, self).__init__()
        self.inplace = inplace

    def forward(self, x):
        return hard_sigmoid(x, inplace=self.inplace)

class HardSwish(nn.Module):
    def __init__(self, inplace=False):
        super(HardSwish, self).__init__()
        self.inplace = inplace

    def forward(self, x):
        return hard_swish(x, inplace=self.inplace)

class SqEx(nn.Module):
    def __init__(self, n_features, reduction=4):
        super(SqEx, self).__init__()
        if n_features % reduction != 0:
            raise ValueError('n_features must be divisible by reduction (default = 4)')
        self.linear1 = nn.Linear(n_features, n_features // reduction, bias=True)
        self.nonlin1 = nn.ReLU(inplace=True)
        self.linear2 = nn.Linear(n_features // reduction, n_features, bias=True)
        self.nonlin2 = HardSigmoid(inplace=True)

    def forward(self, x):
        y = F.avg_pool2d(x, kernel_size=x.size()[2:4])
        y = y.permute(0, 2, 3, 1)
        y = self.nonlin1(self.linear1(y))
        y = self.nonlin2(self.linear2(y))
        y = y.permute(0, 3, 1, 2)
        y = x * y
        return y

class LastBlockSmall(nn.Module):
    def __init__(self, inplanes, num_classes, expplanes1, expplanes2):
        super(LastBlockSmall, self).__init__()
        self.conv1 = nn.Conv2d(inplanes, expplanes1, kernel_size=1, bias=False)
        self.bn1 = nn.BatchNorm2d(expplanes1)
        self.act1 = HardSwish(inplace=True)
        self.se = SqEx(expplanes1)
        self.avgpool = nn.AdaptiveAvgPool2d(1)
        self.conv2 = nn.Conv2d(expplanes1, expplanes2, kernel_size=1, stride=1, bias=False)
        self.act2 = HardSwish(inplace=True)
        self.dropout = nn.Dropout(p=0.2, inplace=True)
        self.fc = nn.Linear(expplanes2, num_classes)
        self.expplanes1 = expplanes1
        self.expplanes2 = expplanes2
        self.inplanes = inplanes
        self.num_classes = num_classes

    def forward(self, x):
        out = self.conv1(x)
        out = self.bn1(out)
        out = self.act1(out)
        out = self.se(out)
        out = self.avgpool(out)
        out = self.conv2(out)
        out = self.act2(out)
        out = out.view(out.size(0), -1)
        out = self.fc(self.dropout(out))
        return out

INIT_ARGS = {
    'inplanes': 8,
    'num_classes': 3,
    'expplanes1': 12,
    'expplanes2': 16,
}

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

# INIT_ARGS for LinearBottleneck.__init__
INIT_ARGS = {
    'inplanes': 8,
    'outplanes': 12,
    'expplanes': 16,
    'k': 3,
    'stride': 1,
    'drop_prob': 0.1,
    'num_steps': 1000.0,
    'start_step': 0,
    'activation': nn.ReLU,
    'act_params': {'inplace': True},
    'SE': True
}

# ARGS for LinearBottleneck.forward
ARGS = {
    'x': torch.randn(2, 8, 14, 14)
}
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)
LiteRASSP Ran
ran on a synthesized input · constructed an object; no result was computed
OniroAI/Instance-segmentation-with-MobileNetV3/modules/keras_models.py
pointer only (licence: GPL-3.0) · get_code("8725aa67394a59c0")
How it ran

The body of this sample is withheld: GPL-3.0, as GitHub detects it on this paper's repository, OniroAI/Instance-segmentation-with-MobileNetV3, is not in the permissive set Syntology serves inline. 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.

MobileBlock Ran
ran on a synthesized input
SpikeKing/mobilenet_v3/mn3_model.py
pointer only (licence: NONE) · get_code("9e8d7789c4c389a6")
How it ran

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

MobileBottleneck Ran
ran on a synthesized input · constructed an object; no result was computed
chris-boson/fashion_mnist/trainer/models/mobilenetv3.py
pointer only (licence: NONE) · get_code("2d8a3aa3bbd7b78a")
How it ran

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

MobileNetV3 Ran
ran on a synthesized input · constructed an object; no result was computed
showlo/mobilenetv3/mobileNetV3.py
pointer only (licence: NONE) · get_code("7f869bd47b2a9653")
How it ran

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

MobileNetV3 Ran
ran on a synthesized input
wang-zidu/3ddfa-v3/model/mb_v3_networks.py
code served (permissive licence) · get_code("561f7b0eb338927a")
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 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
import torch.nn as nn
import numpy as np
from collections import OrderedDict

# Stand-in modules and helper functions
def h_swish():
    return nn.ReLU6(inplace=True)

def h_sigmoid():
    return nn.Sigmoid()

class SELayer(nn.Module):
    def __init__(self, channel, reduction=4):
        super().__init__()
        self.avg_pool = nn.AdaptiveAvgPool2d(1)
        self.fc = nn.Sequential(
            nn.Linear(channel, channel // reduction),
            nn.ReLU(inplace=True),
            nn.Linear(channel // reduction, channel),
            h_sigmoid()
        )

    def forward(self, x):
        b, c, _, _ = x.size()
        y = self.avg_pool(x).view(b, c)
        y = self.fc(y).view(b, c, 1, 1)
        return x * y

def _make_divisible(v, divisor, min_value=None):
    if min_value is None:
        min_value = divisor
    new_v = max(min_value, int(v + divisor / 2) // divisor * divisor)
    if new_v < 0.9 * v:
        new_v += divisor
    return new_v

# Configuration for MobileNetV3 (small model)
cfgs_small = [
    # k, t, c, use_se, use_hs, s
    [3,  1,  4, 0, 0, 2],
    [3,  4,  4, 1, 0, 2],
    [3,  4,  8, 1, 1, 2],
    [5,  2,  8, 0, 1, 1],
    [5,  2, 12, 0, 1, 1],
]

INIT_ARGS = {
    'cfgs': cfgs_small,
    'mode': 'small',
    'num_classes': 10,
    'width_mult': 1.0
}

# Create input tensor for forward pass
batch_size = 2
channels = 3
height = 8
width = 8
input_tensor = torch.randn(batch_size, channels, height, width)

ARGS = {
    'x': input_tensor
}
Setup block drafted by
a language model, class construct-then-call prompt, model not recorded
Imports
numpy, torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type Tensor, ndim 2, 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)
MobileNetV3 Ran
ran on a synthesized input · constructed an object; no result was computed
PolinaDruzhinina/modelnet/models/mobilenetv3.py
pointer only (licence: NONE) · get_code("dd0eb9bdaecad128")
How it ran

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

MobileNetV3 Ran
ran on a synthesized input · constructed an object; no result was computed
chris-boson/fashion_mnist/trainer/models/mobilenetv3.py
pointer only (licence: NONE) · get_code("f54f64d3a22943e8")
How it ran

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

MobileNetV3 Ran
ran on a synthesized input · constructed an object; no result was computed
pengboxiangshang/mobilenetv3_pytorch/MobileNetV3.py
pointer only (licence: NONE) · get_code("a0eb27e3a8ffc484")
How it ran

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

MobileNetV3 Ran
ran on a synthesized input
tiagoCuervo/JapaNet/model.py
pointer only (licence: NONE) · get_code("ddd66ea3aa2a3a65")
How it ran

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

MobileNetV3 Ran
ran on a synthesized input
kuan-wang/pytorch-mobilenet-v3/mobilenetv3.py
code served (permissive licence) · get_code("6278668ba6ef59f3")
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 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
import torch.nn as nn
import numpy as np

# INIT_ARGS for MobileNetV3.__init__
INIT_ARGS = {
    'n_class': 10,
    'input_size': 32,  # Must be divisible by 32
    'dropout': 0.8,
    'mode': 'small',
    'width_mult': 0.5  # Smaller width multiplier for tiny model
}

# ARGS for forward method
# Input tensor: batch_size=2, channels=3, height=32, width=32
ARGS = {
    'x': torch.randn(2, 3, 32, 32)
}
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 2, 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)
MobileNetV3Small Ran
ran on a synthesized input · constructed an object; no result was computed
TheConstant3/MobileNetV3-Keras/src/mobilenetV3.py
pointer only (licence: NONE) · get_code("0c9f35bd6df82dc7")
How it ran

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

SE Ran
ran on a synthesized input · constructed an object; no result was computed
PolinaDruzhinina/modelnet/models/mobilenetv3.py
pointer only (licence: NONE) · get_code("2d9873a3665e1dd9")
How it ran

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

SELayer Ran
ran on a synthesized input · constructed an object; no result was computed
d-li14/mobilenetv3.pytorch/mobilenetv3.py
code served (permissive licence) · get_code("3a744d625048086e")
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, SELayer: the run constructed the object and did not call it, so no result was computed. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch
import torch.nn as nn

torch.manual_seed(0)

ARGS = {
    "channel": 16,
    "reduction": 4,
}
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 SELayer — 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 SELayer 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
SEModule Ran
ran on a synthesized input · constructed an object; no result was computed
showlo/mobilenetv3/mobileNetV3.py
pointer only (licence: NONE) · get_code("c89b0dcd2fc64746")
How it ran

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

SEModule Ran
ran on a synthesized input · constructed an object; no result was computed
chris-boson/fashion_mnist/trainer/models/mobilenetv3.py
pointer only (licence: NONE) · get_code("be1d6e0d4c7fbed8")
How it ran

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

SeModule Ran
ran on a synthesized input · constructed an object; no result was computed
ujsyehao/mobilenetv3-ssd/pytorch_model/mobilenetv3.py
pointer only (licence: NONE) · get_code("518da7f7fc849e72")
How it ran

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

SqEx Ran
ran on a synthesized input
Randl/MobileNetV3-pytorch/MobileNetV3.py
code served (permissive licence) · get_code("544e406c29c4e4cb")
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, 8, 4, 3) as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

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

class HardSigmoid(nn.Module):

    def __init__(self, inplace=False):
        super(HardSigmoid, self).__init__()
        self.inplace = inplace

    def forward(self, x):
        return hard_sigmoid(x, inplace=self.inplace)

def hard_sigmoid(x, inplace=False):
    return F.relu6(x + 3, inplace) / 6

class SqEx(nn.Module):

    def __init__(self, n_features, reduction=4):
        super(SqEx, self).__init__()
        if n_features % reduction != 0:
            raise ValueError('n_features must be divisible by reduction (default = 4)')
        self.linear1 = nn.Linear(n_features, n_features // reduction, bias=True)
        self.nonlin1 = nn.ReLU(inplace=True)
        self.linear2 = nn.Linear(n_features // reduction, n_features, bias=True)
        self.nonlin2 = HardSigmoid(inplace=True)

    def forward(self, x):
        y = F.avg_pool2d(x, kernel_size=x.size()[2:4])
        y = y.permute(0, 2, 3, 1)
        y = self.nonlin1(self.linear1(y))
        y = self.nonlin2(self.linear2(y))
        y = y.permute(0, 3, 1, 2)
        y = x * y
        return y

INIT_ARGS = {
    'n_features': 8,
    'reduction': 4
}

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

if __name__ == '__main__':
    model = SqEx(**INIT_ARGS)
    output = model(**ARGS)
    print(f"Input shape: {ARGS['x'].shape}")
    print(f"Output shape: {output.shape}")
    print("Success!")
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, 8, 4, 3) — shape (2, 8, 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: torch and numpy seeded to 0 by the harness immediately before the class was constructed from INIT_ARGS (fixture_check.py)
SqueezeBlock Ran
ran on a synthesized input
SpikeKing/mobilenet_v3/mn3_model.py
pointer only (licence: NONE) · get_code("3ba84df153cca41e")
How it ran

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

_ensure_divisible Ran
ran, honoured the contract we drafted
showlo/mobilenetv3/mobileNetV3.py
pointer only (licence: NONE) · get_code("06ed09c8c4a05763")
How it ran

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

_make_divisible Ran
ran, honoured the contract we drafted
SpikeKing/mobilenet_v3/mn3_model.py
pointer only (licence: NONE) · get_code("03eee59192d9c54e")
How it ran

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

accuracy_np Ran
ran, honoured the contract we drafted
rwightman/genmobilenet-pytorch/caffe2_validate.py
code served (permissive licence) · get_code("ce856d9e51a3df05")
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 numpy as np

# Create sample outputs and targets for the accuracy_np function
# The function expects:
# - output: shape (batch_size, num_classes) with prediction scores
# - target: shape (batch_size,) with true class indices

batch_size = 2
num_classes = 4

# Create random output scores (logits or probabilities)
output = np.random.randn(batch_size, num_classes).astype(np.float32)

# Create target class indices (must be valid indices in range [0, num_classes-1])
target = np.array([0, 2], dtype=np.int64)

ARGS = {
    "output": output,
    "target": target,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type tuple, ndim 1, dtype family 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
activation Ran
ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT)
ckyrkou/EmergencyNet/code/model.py
pointer only (licence: NONE) · get_code("d04dc47c293a9646")
How it ran

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

blend Ran
ran on a synthesized input
ekzhang/fastseg/fastseg/image/colorize.py
code served (permissive licence) · get_code("a27dd3605bd35022")
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.

from PIL import Image
import numpy as np

# Create two small RGB images of the same size
# Image.blend requires both images to be the same size and mode
width, height = 4, 3
mode = 'RGB'

# Create a simple input image (red-ish)
input_array = np.ones((height, width, 3), dtype=np.uint8) * 100
input_img = Image.new(mode, (width, height))
input_img.putdata([tuple(input_array[i, j]) for i in range(height) for j in range(width)])

# Create a segmentation image (green-ish)
seg_array = np.ones((height, width, 3), dtype=np.uint8) * 50
seg_img = Image.new(mode, (width, height))
seg_img.putdata([tuple(seg_array[i, j]) for i in range(height) for j in range(width)])

ARGS = {
    'input_img': input_img,
    'seg_img': seg_img,
}
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
build_transform Ran
ran; our contract draft was wrong, not the code
xiaolai-sqlai/mobilenetv3/datasets.py
pointer only (licence: MIT); the stored copy get_code serves, from techmonsterwang/illama, is pointer only (licence: NONE) · get_code("6a0317bfd6be9557")
How it ran

The body of this sample is withheld: MIT, as GitHub detects it on this paper's repository, xiaolai-sqlai/mobilenetv3, is in the permissive set, but a licence decision keeps the body a pointer: the reason for that decision is not recorded with it. 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.

calc_f1_score Ran
ran on a synthesized input
t-hanya/kuzushiji-recognition/kr/evaluation.py
code served (permissive licence) · get_code("ecdc06194e69eea3")
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

torch.manual_seed(0)

# calc_f1_score takes three integer parameters: n_tp, n_fp, n_fn
# It calculates precision, recall, and F1 score from these counts

ARGS = {
    "n_tp": 42,
    "n_fp": 8,
    "n_fn": 5,
}
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
calc_iou_mat Ran
ran on a synthesized input
t-hanya/kuzushiji-recognition/kr/detector/bbox_voting.py
code served (permissive licence) · get_code("2049f6182035adfb")
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 (2, 3) as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import numpy as np

# Create two sets of bounding boxes
# Each bbox is [x1, y1, x2, y2] format
# bboxes1: 2 bboxes
bboxes1 = np.array([
    [0, 0, 10, 10],      # First bbox
    [5, 5, 15, 15]       # Second bbox
], dtype=np.float32)

# bboxes2: 3 bboxes (different size to make the IOU matrix non-square)
bboxes2 = np.array([
    [0, 0, 5, 5],        # First bbox
    [8, 8, 12, 12],      # Second bbox
    [20, 20, 30, 30]     # Third bbox
], dtype=np.float32)

ARGS = {
    'bboxes1': bboxes1,
    'bboxes2': bboxes2
}
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 (2, 3) — shape (2, 3) as a later run recorded it
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
check_bn Ran
ran, violated the contract we drafted
xiaolai-sqlai/mobilenetv3/utils.py
pointer only (licence: MIT); the stored copy get_code serves, from JiancongXiao/Adaptive-Smoothness-Weighted-AT, is pointer only (licence: NONE) · get_code("6e59364a7cf6008f")
How it ran

The body of this sample is withheld: MIT, as GitHub detects it on this paper's repository, xiaolai-sqlai/mobilenetv3, is in the permissive set, but a licence decision keeps the body a pointer: the reason for that decision is not recorded with it. 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.

clamp_to_im Ran
ran on a synthesized input
emilianavt/OpenSeeFace/tracker.py
code served (permissive licence) · get_code("812a03560e02d125")
How it ran

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

import torch

torch.manual_seed(0)

# The function clamp_to_im takes:
# - pt: a point (tuple or list-like with [0] and [1] indexing for x and y)
# - w: width (int)
# - h: height (int)

pt = [2.5, 3.7]
w = 10
h = 8

ARGS = {
    "pt": pt,
    "w": w,
    "h": h,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type tuple, ndim 1, dtype family int — a tuple output has no array shape of its own; none is stated
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
compare_with_ground_truth Ran
ran on a synthesized input
t-hanya/kuzushiji-recognition/kr/evaluation.py
code served (permissive licence) · get_code("fd81c5c2c0790a12")
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. 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.

from typing import List, Tuple
import numpy as np

# Construct valid arguments for compare_with_ground_truth
pred_labels = [
    {'unicode': 'A', 'point': {'x': 15, 'y': 15}},
    {'unicode': 'C', 'point': {'x': 55, 'y': 55}},
    {'unicode': 'D', 'point': {'x': 100, 'y': 100}},
]

gt_labels = [
    {'unicode': 'A', 'bbox': {'x1': 10, 'y1': 10, 'x2': 20, 'y2': 20}},
    {'unicode': 'B', 'bbox': {'x1': 50, 'y1': 50, 'x2': 60, 'y2': 60}},
    {'unicode': 'C', 'bbox': {'x1': 50, 'y1': 50, 'x2': 60, 'y2': 60}},
]

ARGS = {
    'pred_labels': pred_labels,
    'gt_labels': gt_labels,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type tuple — 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 Ran
ran; our contract draft was wrong, not the code
rwightman/efficientnet-jax/jeffnet/linen/blocks_linen.py
code served (permissive licence) · get_code("704704cc698dd1a4")
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 Conv. 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 jax
import jax.numpy as jnp
import flax.linen as nn
import flax.linen.initializers as initializers
from typing import Callable, Tuple, Union, Optional

# Define the helper function that's used in conv2d
def get_like_padding(kernel_size, stride, dilation):
    """Stand-in implementation for get_like_padding"""
    return 1

def to_tuple(v, n: int):
    """Converts input to tuple."""
    if isinstance(v, tuple):
        return v
    elif isinstance(v, (int, float)):
        return (v,) * n
    else:
        return tuple(v)

# Set up default kernel initializer
default_kernel_init = initializers.kaiming_normal()

# Define ARGS dictionary with all parameters for conv2d
ARGS = {
    'features': 16,
    'kernel_size': 3,
    'stride': 1,
    'padding': 'SAME',
    'dilation': 1,
    'groups': 1,
    'bias': False,
    'dtype': jnp.float32,
    'precision': None,
    'name': 'conv_layer',
    'kernel_init': default_kernel_init,
    'bias_init': initializers.zeros,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
flax, jax — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type Conv — a Conv output has no array shape of its own; none 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
conv2d_same Ran
ran; our contract draft was wrong, not the code
rwightman/genmobilenet-pytorch/geffnet/conv2d_layers.py
code served (permissive licence) · get_code("4ec99f9f08732346")
How it ran

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

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

torch.manual_seed(0)

# Create input tensor: (batch=2, channels=3, height=8, width=8)
x = torch.randn(2, 3, 8, 8)

# Create weight tensor for conv2d: (out_channels=4, in_channels=3, kernel_h=3, kernel_w=3)
weight = torch.randn(4, 3, 3, 3)

# Create bias tensor: (out_channels=4,)
bias = torch.randn(4)

# Define parameters
stride = (1, 1)
padding = (0, 0)
dilation = (1, 1)
groups = 1

ARGS = {
    'x': x,
    'weight': weight,
    'bias': bias,
    'stride': stride,
    'padding': padding,
    'dilation': dilation,
    'groups': groups,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type Tensor, ndim 4, dtype family float, shape (2, 4, 8, 8) — shape (2, 4, 8, 8) as a later run recorded it
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
conv_1x1_bn Ran
ran; our contract draft was wrong, not the code
wang-zidu/3ddfa-v3/model/mb_v3_networks.py
code served (permissive licence) · get_code("4e90491a30c2dc28")
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 Sequential. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch
import torch.nn as nn

torch.manual_seed(0)

# Define the custom activation modules needed by conv_1x1_bn
class h_sigmoid(nn.Module):
    def __init__(self, inplace=True):
        super(h_sigmoid, self).__init__()
        self.relu = nn.ReLU6(inplace=inplace)

    def forward(self, x):
        return self.relu(x + 3) / 6

class h_swish(nn.Module):
    def __init__(self, inplace=True):
        super(h_swish, self).__init__()
        self.sigmoid = h_sigmoid(inplace=inplace)

    def forward(self, x):
        return x * self.sigmoid(x)

def conv_1x1_bn(inp, oup):
    return nn.Sequential(
        nn.Conv2d(inp, oup, 1, 1, 0, bias=False),
        nn.BatchNorm2d(oup),
        h_swish()
    )

# Create arguments for conv_1x1_bn
# inp: number of input channels (distinct from oup)
# oup: number of output channels
inp_channels = 4
oup_channels = 3

ARGS = {
    'inp': inp_channels,
    'oup': oup_channels
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type Sequential — a Sequential output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a Sequential output the recorded ndim 1 and dtype family float describe that coercion, not the output, and are not stated
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
conv_1x1_bn Ran
ran; our contract draft was wrong, not the code
chris-boson/fashion_mnist/trainer/models/mobilenetv3.py
pointer only (licence: NONE) · get_code("db82a4013a44fb42")
How it ran

The body of this sample is withheld: GitHub detected no licence in this paper's repository, chris-boson/fashion_mnist 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_3x3_bn Ran
ran; our contract draft was wrong, not the code
wang-zidu/3ddfa-v3/model/mb_v3_networks.py
code served (permissive licence) · get_code("5221887077e3fb54")
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 Sequential. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch
import torch.nn as nn

torch.manual_seed(0)

ARGS = {
    'inp': 3,
    'oup': 16,
    'stride': 1
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type Sequential — a Sequential output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a Sequential output the recorded ndim 1 and dtype family float describe that coercion, not the output, and are not stated
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
conv_bn Ran
ran; our contract draft was wrong, not the code
chris-boson/fashion_mnist/trainer/models/mobilenetv3.py
pointer only (licence: NONE) · get_code("84a4cf301e929085")
How it ran

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

cosine_scheduler Ran
ran, honoured the contract we drafted
xiaolai-sqlai/mobilenetv3/utils.py
pointer only (licence: MIT); the stored copy get_code serves, from boyazeng/understand_bias, is pointer only (licence: NONE) · get_code("b700fb0a3496b255")
How it ran

The body of this sample is withheld: MIT, as GitHub detects it on this paper's repository, xiaolai-sqlai/mobilenetv3, is in the permissive set, but a licence decision keeps the body a pointer: the reason for that decision is not recorded with it. 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.

create_conv2d_pad Ran
ran; our contract draft was wrong, not the code
rwightman/genmobilenet-pytorch/geffnet/conv2d_layers.py
code served (permissive licence) · get_code("d97a5cf595717b21")
How it ran

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

import torch
import torch.nn as nn

torch.manual_seed(0)

def is_exportable():
    return False

def is_scriptable():
    return False

ARGS = {
    'in_chs': 3,
    'out_chs': 16,
    'kernel_size': 3,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type Conv2d — a Conv2d output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a Conv2d output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not stated
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
decode Ran
ran on a synthesized input
emilianavt/OpenSeeFace/retinaface.py
code served (permissive licence) · get_code("24e984c89fc9c4d5")
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 (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 numpy as np

# Set random seed for reproducibility
np.random.seed(0)

# Create small sample data for the decode function
# loc: offsets for bounding boxes (batch_size=2, 4 values per box)
loc = np.random.randn(2, 4).astype(np.float32)

# priors: prior boxes in format [cx, cy, w, h] (batch_size=2, 4 values per box)
priors = np.array([
    [0.5, 0.5, 0.2, 0.3],
    [0.7, 0.6, 0.15, 0.25]
], dtype=np.float32)

# variances: scaling factors for loc adjustments (2 values: one for xy, one for wh)
variances = np.array([0.1, 0.2], dtype=np.float32)

ARGS = {
    'loc': loc,
    'priors': priors,
    'variances': variances
}
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 (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
evaluate_kuzushiji_recognition Ran
ran on a synthesized input
t-hanya/kuzushiji-recognition/kr/evaluation.py
code served (permissive licence) · get_code("4e6344480f924830")
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 numpy as np
from typing import List

# Construct valid arguments for evaluate_kuzushiji_recognition

# Sample prediction labels for 2 images
all_pred_labels = [
    # First image: 2 predicted characters
    [
        {'unicode': 'A', 'point': {'x': 15, 'y': 15}},
        {'unicode': 'C', 'point': {'x': 55, 'y': 55}},
    ],
    # Second image: 1 predicted character
    [
        {'unicode': 'B', 'point': {'x': 25, 'y': 25}},
    ],
]

# Sample ground truth labels for 2 images
all_gt_labels = [
    # First image: 2 ground truth characters
    [
        {'unicode': 'A', 'bbox': {'x1': 10, 'y1': 10, 'x2': 20, 'y2': 20}},
        {'unicode': 'B', 'bbox': {'x1': 50, 'y1': 50, 'x2': 60, 'y2': 60}},
    ],
    # Second image: 2 ground truth characters
    [
        {'unicode': 'B', 'bbox': {'x1': 20, 'y1': 20, 'x2': 30, 'y2': 30}},
        {'unicode': 'D', 'bbox': {'x1': 70, 'y1': 70, 'x2': 80, 'y2': 80}},
    ],
]

ARGS = {
    'all_pred_labels': all_pred_labels,
    'all_gt_labels': all_gt_labels,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type tuple, ndim 1, dtype family 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
fusion_block Ran
ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT)
ckyrkou/EmergencyNet/code/model.py
pointer only (licence: NONE) · get_code("927b92925cff89c3")
How it ran

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

gaussian_radius Ran
ran on a synthesized input
t-hanya/kuzushiji-recognition/kr/detector/centernet/heatmap.py
code served (permissive licence) · get_code("4d72a8990678d08d")
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 float64, ndim 0, dtype family float; no output shape is stated. The image it ran in was not recorded. If your copy returns the same type and ndim on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import numpy as np

ARGS = {
    "bbox_size": (64, 48),
    "min_overlap": 0.7,
}
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 float64, ndim 0, dtype family float — no output shape is stated: observe_signature.py recorded float ndim 0, which disagrees with the fixture run
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
get_bound_method_class Ran
ran on a synthesized input
emilianavt/OpenSeeFace/similaritytransform.py
code served (permissive licence) · get_code("04e390b8fa4ddf5b")
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 type. 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 sys

class SimpleClass:
    def method(self):
        pass

# Create an instance and get a bound method
obj = SimpleClass()
bound_method = obj.method

ARGS = {
    "m": bound_method
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
none outside the standard library — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type type — a type output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a type 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
get_lr Ran
ran, honoured the contract we drafted
atregret/mobilenetv3/src/lr_generator.py
code served (permissive licence) · get_code("bcab367eb4c6388e")
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 1, dtype family float, shape (995,) 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
import numpy as np

# The function get_lr takes only scalar/int arguments, no complex objects needed
ARGS = {
    "global_step": 5,
    "lr_init": 0.0001,
    "lr_end": 0.00001,
    "lr_max": 0.001,
    "warmup_epochs": 2,
    "total_epochs": 10,
    "steps_per_epoch": 100
}
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 1, dtype family float, shape (995,) — shape (995,) 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

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

Also present in other papers' code

Of 105 samples lifted from this paper's linked repositories, 105 carry a function identity and 0 do not. Of the 105 distinct functions with an identity, 23 are also present in other papers whose code we hold (9 with at least one paper dated earlier, 4 the same month, 18 later) and 82 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
cosine_scheduler 26 other papers
26 later
136810051 (2022 (year only))
AMixer: Adaptive Weight Mixing for Self-Attention Free Vision Transformers
136860514 (2022 (year only))
SLIP: Self-supervision meets Language-Image Pre-training
2206.02967 (2022-06)
Masked Unsupervised Self-training for Label-free Image Classification
and 23 more not named here
get_parameter_groups 18 other papers
18 later
136810051 (2022 (year only))
AMixer: Adaptive Weight Mixing for Self-Attention Free Vision Transformers
136860514 (2022 (year only))
SLIP: Self-supervision meets Language-Image Pre-training
2211.05781 (2022-11)
Demystify Transformers &amp; Convolutions in Modern Image Deep Networks
and 15 more not named here
get_num_layer_for_convnext 12 other papers
12 later
2211.05781 (2022-11)
Demystify Transformers &amp; Convolutions in Modern Image Deep Networks
ijcai2023_0111 (2023 (year only))
RaMLP: Vision MLP via Region-aware Mixing
2302.06052 (2023-02)
CEDNet: A Cascade Encoder-Decoder Network for Dense Prediction
and 9 more not named here
make_divisible
brick of this paper's assembly: helper
12 other papers
4 dated earlier, 8 later · 1 only as an assembly brick
1503.03832 (2015-03)
FaceNet: A Unified Embedding for Face Recognition and Clustering
1801.04381 (2018-01)
MobileNetV2: Inverted Residuals and Linear Bottlenecks
1811.08383 (2018-11)
TSM: Temporal Shift Module for Efficient Video Understanding
and 9 more not named here
build_transform 9 other papers
9 later
2105.13677 (2021-05)
ResT: An Efficient Transformer for Visual Recognition
136810051 (2022 (year only))
AMixer: Adaptive Weight Mixing for Self-Attention Free Vision Transformers
2211.05781 (2022-11)
Demystify Transformers &amp; Convolutions in Modern Image Deep Networks
and 6 more not named here
py_cpu_nms 9 other papers
2 dated earlier, 1 the same month, 6 later
1506.01497 (2015-06)
Faster R-CNN: Towards Real-Time Object Detection with Region Proposal Networks
1812.00155 (2018-12)
Learning RoI Transformer for Detecting Oriented Objects in Aerial Images
1905.00641 (2019-05)
RetinaFace: Single-stage Dense Face Localisation in the Wild
and 6 more not named here
check_bn 8 other papers
1 dated earlier, 7 later
1803.05407 (2018-03)
Averaging Weights Leads to Wider Optima and Better Generalization
1910.09777 (2019-10)
Self-Correction for Human Parsing
2210.00557 (2022-10)
Adaptive Smoothness-weighted Adversarial Training for Multiple Perturbations with Its Stability Analysis
and 5 more not named here
conv_1x1_bn
brick of this paper's assembly: helper
4 other papers
2 dated earlier, 2 later
1503.03832 (2015-03)
FaceNet: A Unified Embedding for Face Recognition and Clustering
1812.00332 (2018-12)
ProxylessNAS: Direct Neural Architecture Search on Target Task and Hardware
2001.00705 (2020-01)
Fractional Skipping: Towards Finer-Grained Dynamic CNN Inference
and 1 more not named here
conv_1x1_bn
brick of this paper's assembly: model
4 other papers
1 dated earlier, 3 later
1512.02325 (2015-12)
SSD: Single Shot MultiBox Detector
2003.03771 (2020-03)
Pixel-in-Pixel Net: Towards Efficient Facial Landmark Detection in the Wild
Wang_3D_Face_Reconstruction_with_the_Geometric_Guidance_of_Facial_Part_CVPR_2024_paper (2024 (year only))
3D Face Reconstruction with the Geometric Guidance of Facial Part Segmentation
and 1 more not named here
conv_3x3_bn
brick of this paper's assembly: model
4 other papers
1 dated earlier, 3 later
1512.02325 (2015-12)
SSD: Single Shot MultiBox Detector
2003.03771 (2020-03)
Pixel-in-Pixel Net: Towards Efficient Facial Landmark Detection in the Wild
Wang_3D_Face_Reconstruction_with_the_Geometric_Guidance_of_Facial_Part_CVPR_2024_paper (2024 (year only))
3D Face Reconstruction with the Geometric Guidance of Facial Part Segmentation
and 1 more not named here
conv_bn
brick of this paper's assembly: helper
4 other papers
1 dated earlier, 3 later
1503.03832 (2015-03)
FaceNet: A Unified Embedding for Face Recognition and Clustering
2001.00705 (2020-01)
Fractional Skipping: Towards Finer-Grained Dynamic CNN Inference
2009.09960 (2020-09)
Towards Fast, Accurate and Stable 3D Dense Face Alignment
and 1 more not named here
accuracy_np 2 other papers
2 later
2401.17992 (2024-01)
Multilinear Operator Networks
2404.10518 (2024-04)
MobileNetV4 -- Universal Models for the Mobile Ecosystem
Hsigmoid
brick of this paper's assembly: helper, model
1 other paper
1 later
2403.08161 (2024-03)
LAFS: Landmark-based Facial Self-supervised Learning for Face Recognition
Hswish
brick of this paper's assembly: helper, model
1 other paper
1 later
2403.08161 (2024-03)
LAFS: Landmark-based Facial Self-supervised Learning for Face Recognition
Identity
brick of this paper's assembly: helper, model
1 other paper
1 later
2403.08161 (2024-03)
LAFS: Landmark-based Facial Self-supervised Learning for Face Recognition
MobileBottleneck
brick of this paper's assembly: model
1 other paper
1 later
2403.08161 (2024-03)
LAFS: Landmark-based Facial Self-supervised Learning for Face Recognition
SEModule
brick of this paper's assembly: helper, model
1 other paper
1 later
2403.08161 (2024-03)
LAFS: Landmark-based Facial Self-supervised Learning for Face Recognition
_make_divisible
brick of this paper's assembly: helper
1 other paper
1 dated earlier
1704.04861 (2017-04)
MobileNets: Efficient Convolutional Neural Networks for Mobile Vision Applications
conv2d_same 1 other paper
1 the same month
1905.11946 (2019-05)
EfficientNet: Rethinking Model Scaling for Convolutional Neural Networks
create_conv2d_pad 1 other paper
1 the same month
1905.11946 (2019-05)
EfficientNet: Rethinking Model Scaling for Convolutional Neural Networks

Shown: the 20 functions present in the most other papers. 3 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

More are linked than shown here.

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

Abstract

We present the next generation of MobileNets based on a combination of complementary search techniques as well as a novel architecture design. MobileNetV3 is tuned to mobile phone CPUs through a combination of hardwareaware network architecture search (NAS) complemented by the NetAdapt algorithm and then subsequently improved through novel architecture advances. This paper starts the exploration of how automated search algorithms and network design can work together to harness complementary approaches improving the overall state of the art. Through this process we create two new MobileNet models for release: MobileNetV3-Large and MobileNetV3-Small which are targeted for high and low resource use cases. These models are then adapted and applied to the tasks of object detection and semantic segmentation. For the task of semantic segmentation (or any dense pixel prediction), we propose a new efficient segmentation decoder Lite Reduced Atrous Spatial Pyramid Pooling (LR-ASPP). We achieve new state of the art results for mobile classification, detection and segmentation. MobileNetV3-Large is 3.2% more accurate on ImageNet classification while reducing latency by 20% compared to MobileNetV2. MobileNetV3-Small is 6.6% more accurate compared to a MobileNetV2 model with comparable latency. MobileNetV3-Large detection is over 25% faster at roughly the same accuracy as Mo-bileNetV2 on COCO detection. MobileNetV3-Large LR-ASPP is 34% faster than MobileNetV2 R-ASPP at similar accuracy for Cityscapes segmentation.

For agents

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

get_harvested_code_for_paper("1905.02244")
get_code_for_paper("1905.02244")
have("1905.02244")

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

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

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

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

Connect an agent — have() is free.