SYNTOLOGY HomeExplorerAtlasCodeMethodologyAboutDevelopersFeedPricing
Paper · 1806.09055 · 2018

DARTS: Differentiable Architecture Search

Yiming Yang, Karen Simonyan, Hanxiao Liu

arXiv · PDF · Open in the Atlas

Code that ran

74 of 156 samples (functions and classes) lifted from this paper's linked repositories executed on a synthesized input in Syntology's jail (30 of them constructed an object rather than computing a result; 10 honoured the contract we drafted, 1 violated it and 46 have no contract verdict; 17 failures of our instrument; 82 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/1806.09055.json · badge: /api/ran/1806.09055.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
quark0/darts canonical (classifier label)
classifier basis not recorded on the link
0 ran · 2 no recorded run
yochaiz/darts-UNIQ community
not in the paper's declared repositories
11 ran · 17 no recorded run
anonNo2/MulTeacher-KD community
Papers with Code archive
11 ran · 5 no recorded run
guoyongcs/NATv2 community
not in the paper's declared repositories
8 ran · 7 no recorded run
nikita270a/BayesianDARTS community
not in the paper's declared repositories
7 ran · 2 no recorded run
ky941122/darts-experiment community
not in the paper's declared repositories
7 ran · 2 no recorded run
sinamoradian/SNIP-NAS-2 community
not in the paper's declared repositories
5 ran · 3 no recorded run
ahundt/sharpDARTS community
Papers with Code archive
4 ran · 3 no recorded run
KnightZhang625/DARTS_NAS_TextClassification community (classifier label)
classifier basis not recorded on the link
3 ran · 4 no recorded run
eml-eda/plinio community
Papers with Code archive
3 ran · 1 no recorded run
leopard-ai/betty community
not in the paper's declared repositories
3 ran · 1 no recorded run
grtzsohalf/pt.darts community (classifier label)
classifier basis not recorded on the link
3 ran · 0 no recorded run
sjoshi804/hierarchical-darts-neural-architecture-search community
not in the paper's declared repositories
2 ran · 0 no recorded run
DoctorLiQ/AutoML community (classifier label)
classifier basis not recorded on the link
2 ran · 0 no recorded run
brian-moser/dartsrenet community
Papers with Code archive
1 ran · 1 no recorded run
adammenges/DARTS-PyTorch community
Papers with Code archive
1 ran · 1 no recorded run
abcp4/MyDarts community (classifier label)
classifier basis not recorded on the link
1 ran · 1 no recorded run
aragakiyuiii/Gumbel-darts-master community
Papers with Code archive
1 ran · 1 no recorded run
khanrc/pt.darts community (classifier label)
classifier basis not recorded on the link
1 ran · 0 no recorded run
lorylei/DARTS-et community
not in the paper's declared repositories
0 ran · 5 no recorded run
scz233/darts community
not in the paper's declared repositories
0 ran · 3 no recorded run
IsmaelCesar/darts community
Papers with Code archive
0 ran · 3 no recorded run
AlvinIsonomia/darts.pytorch1.3_MultiGPU community
Papers with Code archive
0 ran · 3 no recorded run
tianbaochou/CNAS community
not in the paper's declared repositories
0 ran · 3 no recorded run
siddikui/Fast-DARTS community
not in the paper's declared repositories
0 ran · 3 no recorded run
FunctionStatusWhere it lives
ActQuant Ran
ran on a synthesized input · constructed an object; no result was computed
yochaiz/darts-UNIQ/cnn/MixedLayer.py
code served (permissive licence) · get_code("7bf58545f542c1c6")
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, ActQuant: 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)

# The ActQuant class requires:
# - bitwidth: int
# - clamp_val: a tensor (used in act_clamp and forward, with .item() called on it)
# - The forward method expects input tensor and uses self.clamp_val

ARGS = {
    'bitwidth': 8,
}

# Create an instance to set clamp_val as a buffer/parameter
model = nn.Module()
model.clamp_val = torch.tensor(1.0)

# After instantiation, we need to set clamp_val on the ActQuant instance
# So we'll create the instance and configure it:
act_quant_layer = nn.Module.__new__(nn.Module)
act_quant_layer.__class__ = type('ActQuant', (nn.Module,), {
    'layer_id': __import__('itertools').count(),
    '__init__': lambda self, bitwidth: None,
})

# Actually, let's properly instantiate it:
class TestActQuant(nn.Module):
    layer_id = __import__('itertools').count()
    
    def __init__(self, bitwidth):
        super(TestActQuant, self).__init__()
        self.quant = True
        self.bitwidth = bitwidth
        self.qunatize_during_training = False
        self.noise_during_training = False
        self.layer_num = next(self.layer_id)
        self.quant_error = []
        self.momentum = 0.9
        self.max_factor_of_act_step = 8
        self.clamp_val = torch.tensor(2.0)
    
    def act_clamp(self, x, clamp_val):
        assert clamp_val >= 0
        x = torch.nn.functional.relu(x) - torch.nn.functional.relu(x - clamp_val)
        return x
    
    def forward(self, input):
        assert isinstance(self.bitwidth, int)
        if self.quant and (not self.training or (self.training and self.qunatize_during_training)):
            x = self.act_clamp(input, self.clamp_val)
            print('Activation layer {}  has clamp value {}'.format(self.layer_num, self.clamp_val.item()))
        else:
            x = self.act_clamp(input, self.clamp_val)
        return x

instance = TestActQuant(bitwidth=8)
instance.eval()

ARGS = {
    'bitwidth': 8,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type ActQuant — 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 ActQuant 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
BertEmbeddings Ran
ran on a synthesized input
anonNo2/MulTeacher-KD/models/search_cnn.py
pointer only (licence: NONE) · get_code("be6377d03707aa67")
How it ran

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

BinarySoftmax Ran
ran; our contract draft was wrong, not the code
guoyongcs/NATv2/search_model.py
pointer only (licence: NONE) · get_code("29b9493035e8b483")
How it ran

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

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

import torch
import torch.nn as nn
from abc import abstractmethod

torch.manual_seed(0)

class ConcreteBlock(nn.Module):
    """Concrete implementation of Block for testing"""
    
    def __init__(self):
        super().__init__()
        self.conv = nn.Conv2d(3, 16, kernel_size=3)
        self.linear = nn.Linear(16, 8)
        self._output_bitwidth = 8
        self._bops = 1000
        
    def getBops(self, input_bitwidth):
        return self._bops
    
    def getCurrentOutputBitwidth(self):
        return self._output_bitwidth
    
    def choosePathByAlphas(self):
        return None
    
    def numOfOps(self):
        return 2
    
    def getLayers(self):
        return [self.conv, self.linear]
    
    def outputLayer(self):
        return self.linear


# Since Block is abstract and only defines abstract methods,
# we create a concrete implementation to instantiate
block_instance = ConcreteBlock()

ARGS = {
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type Block — the run constructed an instance of its own class and did not call it; no shape is stated — the instrument coerces any output to an array; for a Block output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not stated
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
CalcMac Ran
ran on a synthesized input · constructed an object; no result was computed
yochaiz/darts-UNIQ/cnn/MixedLayer.py
code served (permissive licence) · get_code("e6dfaf43861899ee")
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, CalcMac: 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)

# Construct arguments for CalcMac
ARGS = {
    "kernel_height": 3,
    "kernel_width": 5,
    "groups": 2
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type CalcMac — 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 CalcMac 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
Cell Ran
ran on a synthesized input
brian-moser/dartsrenet/directional_model_cell.py
code served (permissive licence) · get_code("28cee2e19a5ecea9")
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. The code mentions cuda, and the harness aliases cuda to the CPU for every sample; whether this run needed that is 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 namedtuple

# Stand-in for Genotype (minimal recurrent and concat)
Genotype = namedtuple('Genotype', ['recurrent', 'concat'])
recurrent_ops = [('tanh', 0), ('relu', 1)]
genotype = Genotype(recurrent=recurrent_ops, concat=[0, 1])

# INIT_ARGS
INIT_ARGS = {
    'ninp': 4,          # input feature dimension
    'nhid': 8,          # hidden state dimension
    'translation': 'patch_2x2',
    'genotype': genotype
}

# Create input tensor for forward pass
batch_size = 2
seq_len = 6           # Temporal sequence length (must be even for patch_2x2)
height = 4            # Spatial height (must be even for patch_2x2)
width = 4             # Spatial width (must be even for patch_2x2)
channels = INIT_ARGS['ninp']

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

import torch
import torch.nn as nn
from typing import Callable, Optional, Tuple, Type, Dict, Any

torch.manual_seed(0)

Pattern = Type[nn.Module]
PatternSpec = Dict[str, Any]

def cost_spec_zero_fn(_):
    return torch.tensor(0.0)

def cost_spec_fail_fn(x):
    raise KeyError(f'Cannot find cost model for pattern {x}')

Constraint = Optional[Callable[[PatternSpec], bool]]
CostFn = Callable[[PatternSpec], torch.Tensor]

# Create a simple test pattern (a basic nn.Module)
class SimpleLayer(nn.Module):
    def __init__(self):
        super().__init__()
        self.linear = nn.Linear(4, 3)
    
    def forward(self, x):
        return self.linear(x)

ARGS = {
    'shared': True,
    'default_behavior': 'zero'
}
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 CostSpec — 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 CostSpec 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
DNAS Ran
ran on a synthesized input · constructed an object; no result was computed
eml-eda/plinio/plinio/methods/dnas_base/dnas.py
code served (permissive licence) · get_code("3c6112439e086fa6")
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, DNAS: the run constructed the object and did not call it, so no result was computed. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch
import torch.nn as nn
from collections import UserDict
from typing import Dict, Any, Optional, Tuple

torch.manual_seed(0)

# Define a minimal nn.Module for the model parameter
class SimpleModel(nn.Module):
    def __init__(self):
        super().__init__()
        self.linear = nn.Linear(4, 3)
    
    def forward(self, x):
        return self.linear(x)

# Define a minimal CostSpec
class CostSpec(UserDict):
    def __init__(self, shared: bool = True, default_behavior: str = 'zero'):
        super(CostSpec, self).__init__()
        self.shared = shared
        if default_behavior == 'zero':
            self.default = lambda _: torch.tensor(0.0)
        elif default_behavior == 'fail':
            self.default = lambda x: (_ for _ in ()).throw(KeyError(f'Cannot find cost model for pattern {x}'))
        else:
            raise ValueError(f'Unknown default behavior {default_behavior}')
    
    def __setitem__(self, key: Tuple[type, Optional[callable]], cost_fn: callable):
        if key[0] not in self.data:
            self.data[key[0]] = []
        self.data[key[0]].append((key[1], cost_fn))
    
    def __getitem__(self, key: Tuple[type, Dict[str, Any]]):
        best_match = self.default
        best_constr = None
        if key[0] in self.data:
            for constr, cost_fn in self.data[key[0]]:
                if constr is None or constr(key[1]):
                    if best_constr is None:
                        best_match = cost_fn
                        best_constr = constr
                    else:
                        raise KeyError('Found two conflicting cost models! Terminating')
        return best_match

# Create a simple input example
input_example = torch.randn(2, 4)

# Create a CostSpec instance
cost_spec = CostSpec(shared=True, default_behavior='zero')

# Create the model
model = SimpleModel()

# Construct ARGS dictionary for DNAS.__init__
ARGS = {
    'model': model,
    'cost': cost_spec,
    'input_example': input_example,
    'input_shape': None
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type DNAS — 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 DNAS 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
DilConv Ran
ran on a synthesized input · constructed an object; no result was computed
sinamoradian/SNIP-NAS-2/model_search.py
pointer only (licence: NONE) · get_code("972b4aaa77fb3108")
How it ran

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

DilConv Ran
ran on a synthesized input · constructed an object; no result was computed
nikita270a/BayesianDARTS/models/search_cells.py
code served (permissive licence) · get_code("703a958de7b456d1")
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, DilConv: 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 = {
    'C_in': 3,
    'C_out': 16,
    'kernel_size': 3,
    'stride': 1,
    'padding': 1,
    'dilation': 1,
    'affine': 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 DilConv — 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 DilConv 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
DilConv Ran
ran on a synthesized input · constructed an object; no result was computed
ky941122/darts-experiment/models/search_cells.py
code served (permissive licence) · get_code("38122459ccf1a660")
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, DilConv: 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 = {
    'C_in': 3,
    'C_out': 16,
    'kernel_size': 3,
    'stride': 1,
    'padding': 1,
    'dilation': 1,
    'affine': 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 DilConv — 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 DilConv 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
DilConv Ran
ran on a synthesized input
anonNo2/MulTeacher-KD/models/search_cnn.py
pointer only (licence: NONE) · get_code("086d247c91a00516")
How it ran

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

FacConv Ran
ran on a synthesized input · constructed an object; no result was computed
nikita270a/BayesianDARTS/models/search_cells.py
code served (permissive licence) · get_code("7db5b8ab87539ce7")
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, FacConv: 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 = {
    'C_in': 3,
    'C_out': 4,
    'kernel_length': 3,
    'stride': 1,
    'padding': 1,
    'affine': 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 FacConv — 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 FacConv 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
FacConv Ran
ran on a synthesized input · constructed an object; no result was computed
ky941122/darts-experiment/models/search_cells.py
code served (permissive licence) · get_code("23d1d1fcef01bbea")
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, FacConv: 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 = {
    'C_in': 3,
    'C_out': 16,
    'kernel_length': 3,
    'stride': 1,
    'padding': 0,
    'affine': 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 FacConv — 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 FacConv 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
FactorizedReduce Ran
ran on a synthesized input · constructed an object; no result was computed
sinamoradian/SNIP-NAS-2/model_search.py
pointer only (licence: NONE) · get_code("ad3248ef7ba59585")
How it ran

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

FactorizedReduce Ran
ran on a synthesized input · constructed an object; no result was computed
ahundt/sharpDARTS/cnn/model_search.py
code served (permissive licence) · get_code("ee94b24e7ab13cc4")
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, FactorizedReduce: 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)

# FactorizedReduce requires:
# - C_in: number of input channels
# - C_out: number of output channels (must be even)
# - kernel_size: kernel size for convolutions (default 1)
# - stride: stride for convolutions (default 2)
# - padding: padding for convolutions (default 0)
# - affine: whether BatchNorm2d uses affine parameters (default True)

ARGS = {
    "C_in": 4,
    "C_out": 8,
    "kernel_size": 1,
    "stride": 2,
    "padding": 0,
    "affine": 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 FactorizedReduce — 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 FactorizedReduce 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
FactorizedReduce Ran
ran on a synthesized input · constructed an object; no result was computed
nikita270a/BayesianDARTS/models/search_cells.py
code served (permissive licence) · get_code("fefa1d2349401d52")
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, FactorizedReduce: the run constructed the object and did not call it, so no result was computed. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch
import torch.nn as nn

torch.manual_seed(0)

# Define ARGS dict with all parameters for FactorizedReduce.__init__
ARGS = {
    "C_in": 4,
    "C_out": 8,
    "affine": 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 FactorizedReduce — 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 FactorizedReduce 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
FactorizedReduce Ran
ran on a synthesized input · constructed an object; no result was computed
ky941122/darts-experiment/models/search_cells.py
code served (permissive licence) · get_code("40910e7a9c9eb0ee")
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, FactorizedReduce: 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)

# FactorizedReduce.__init__ parameters:
# - C_in: int (number of input channels)
# - C_out: int (number of output channels)
# - affine: bool (whether to use affine in BatchNorm2d)

ARGS = {
    "C_in": 16,
    "C_out": 32,
    "affine": 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 FactorizedReduce — 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 FactorizedReduce 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
GraphConvolution Ran
ran on a synthesized input · constructed an object; no result was computed
guoyongcs/NATv2/search_model.py
pointer only (licence: NONE) · get_code("46d722214869fb2f")
How it ran

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

Initialized_Conv1d Ran
ran on a synthesized input
anonNo2/MulTeacher-KD/models/search_cnn.py
pointer only (licence: NONE) · get_code("f12de2e65d75f997")
How it ran

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

MixedOperation Ran
ran on a synthesized input
sjoshi804/hierarchical-darts-neural-architecture-search/mixed_operation.py
code served (permissive licence) · get_code("95aacf26df6ccb99")
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, 3, 3) as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch
import torch.nn as nn
import torch.nn.functional as F
from torch.nn.modules.batchnorm import BatchNorm2d


def gumbel_softmax(alphas, temp, epsilon=0.0001):
    log_probs = torch.log(torch.max(alphas, torch.ones_like(alphas) * epsilon))
    gumbel = -torch.log(-torch.log(torch.zeros_like(alphas).uniform_()))
    z = (log_probs + gumbel) / temp
    return F.softmax(z, dim=-1)


class MixedOperation(nn.Module):
    def __init__(self, operations, alpha_e):
        super().__init__()
        self.alpha_e = nn.ParameterList(alpha_e)
        self.ops = nn.ModuleList([operations[key] for key in sorted(operations.keys())])
        for i in range(len(self.ops)):
            if 'pool' in str(type(self.ops[i])).lower():
                self.ops[i] = nn.Sequential(self.ops[i], BatchNorm2d(self.ops[i].channels_out, affine=False))

    def forward(self, x, op_num=0, temp=None):
        if temp is not None:
            if len(self.ops) == 1:
                return sum([w * self.ops[0].forward(x, op_num=op_num) for op_num, w in enumerate(gumbel_softmax(self.alpha_e[0], temp))])
            else:
                return sum((w * op(x) for w, op in zip(gumbel_softmax(self.alpha_e[op_num], temp), self.ops)))
        elif len(self.ops) == 1:
            return sum([w * self.ops[0].forward(x, op_num=op_num) for op_num, w in enumerate(F.softmax(self.alpha_e[0], dim=-1))])
        else:
            return sum((w * op(x) for w, op in zip(F.softmax(self.alpha_e[op_num], dim=-1), self.ops)))


class DummyOp(nn.Module):
    def __init__(self, in_channels, out_channels):
        super().__init__()
        self.conv = nn.Conv2d(in_channels, out_channels, kernel_size=1)
    
    def forward(self, x):
        return self.conv(x)


INIT_ARGS = {
    'operations': {
        'op_1': DummyOp(4, 4),
        'op_2': DummyOp(4, 4),
    },
    'alpha_e': [
        nn.Parameter(torch.randn(2)),
        nn.Parameter(torch.randn(2)),
    ]
}

ARGS = {
    'x': torch.randn(2, 4, 3, 3),
    'op_num': 0,
    'temp': None,
}

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

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

PoolBN Ran
ran on a synthesized input · constructed an object; no result was computed
nikita270a/BayesianDARTS/models/search_cells.py
code served (permissive licence) · get_code("4942b404c230cbaa")
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, PoolBN: 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 = {
    'pool_type': 'max',
    'C': 16,
    'kernel_size': 3,
    'stride': 1,
    'padding': 1,
    'affine': 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 PoolBN — 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 PoolBN 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
PoolBN Ran
ran on a synthesized input · constructed an object; no result was computed
ky941122/darts-experiment/models/search_cells.py
code served (permissive licence) · get_code("e593ae035d9d7fae")
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, PoolBN: 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 = {
    'pool_type': 'max',
    'C': 4,
    'kernel_size': 3,
    'stride': 2,
    'padding': 1,
    'affine': 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 PoolBN — 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 PoolBN 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
PoolBN Ran
ran on a synthesized input
anonNo2/MulTeacher-KD/models/search_cnn.py
pointer only (licence: NONE) · get_code("05a10cd094c04cbe")
How it ran

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

RNN Ran
ran on a synthesized input
anonNo2/MulTeacher-KD/models/search_cnn.py
pointer only (licence: NONE) · get_code("7b38fef01289ef2e")
How it ran

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

ReLUConvBN Ran
ran on a synthesized input · constructed an object; no result was computed
sinamoradian/SNIP-NAS-2/model_search.py
pointer only (licence: NONE) · get_code("f142655cc4e284fe")
How it ran

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

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

import torch
import torch.nn as nn

torch.manual_seed(0)

# Define ARGS dict with all parameters for ResizablePool
ARGS = {
    'C_in': 3,
    'C_out': 16,
    'kernel_size': 3,
    'stride': 1,
    'padding': 1,
    'affine': True,
    'pool_type': nn.MaxPool2d
}
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 ResizablePool — 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 ResizablePool 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
Round Ran
ran on a synthesized input · constructed an object; no result was computed
yochaiz/darts-UNIQ/cnn/MixedLayer.py
code served (permissive licence) · get_code("3bb84a37cd76cdaf")
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, Round: 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

torch.manual_seed(0)

# The Round.forward method takes self and x (a tensor)
# The Round.backward method takes self and grad_output
# We need to construct valid arguments to call Round.apply(x)

x = torch.randn(2, 4, requires_grad=True)

ARGS = {
    'x': x
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type Round — 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 Round 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
SelfAttention Ran
ran on a synthesized input
anonNo2/MulTeacher-KD/models/search_cnn.py
pointer only (licence: NONE) · get_code("54e27a823121bcae")
How it ran

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

SepConv Ran
ran on a synthesized input · constructed an object; no result was computed
sinamoradian/SNIP-NAS-2/model_search.py
pointer only (licence: NONE) · get_code("260d8cebac869f29")
How it ran

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

SepConv Ran
ran on a synthesized input · constructed an object; no result was computed
nikita270a/BayesianDARTS/models/search_cells.py
code served (permissive licence) · get_code("11ac01cf8d618695")
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, SepConv: 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)

# SepConv.__init__ parameters:
# - C_in: int (number of input channels)
# - C_out: int (number of output channels)
# - kernel_size: int (kernel size for convolutions)
# - stride: int (stride for first DilConv)
# - padding: int (padding for convolutions)
# - affine: bool (whether to use affine in BatchNorm2d)

ARGS = {
    "C_in": 3,
    "C_out": 16,
    "kernel_size": 3,
    "stride": 1,
    "padding": 1,
    "affine": 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 SepConv — 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 SepConv 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
SepConv Ran
ran on a synthesized input · constructed an object; no result was computed
ky941122/darts-experiment/models/search_cells.py
code served (permissive licence) · get_code("9e7fcbf7500216a1")
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, SepConv: 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 = {
    'C_in': 3,
    'C_out': 16,
    'kernel_size': 3,
    'stride': 1,
    'padding': 1,
    'affine': 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 SepConv — 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 SepConv 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
SepConv Ran
ran on a synthesized input
anonNo2/MulTeacher-KD/models/search_cnn.py
pointer only (licence: NONE) · get_code("527906c425df25cb")
How it ran

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

SharpSepConv Ran
ran on a synthesized input · constructed an object; no result was computed
ahundt/sharpDARTS/cnn/model_search.py
code served (permissive licence) · get_code("cae072e0d23d7b87")
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, SharpSepConv: 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 = {
    'C_in': 3,
    'C_out': 16,
    'kernel_size': 3,
    'stride': 1,
    'padding': 1,
    'dilation': 1,
    'affine': True,
    'C_mid_mult': 1,
    'C_mid': None,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type SharpSepConv — 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 SharpSepConv 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
StdConv Ran
ran on a synthesized input · constructed an object; no result was computed
nikita270a/BayesianDARTS/models/search_cells.py
code served (permissive licence) · get_code("b45294a7653cebea")
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, StdConv: 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 = {
    'C_in': 3,
    'C_out': 16,
    'kernel_size': 3,
    'stride': 1,
    'padding': 1,
    'affine': 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 StdConv — 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 StdConv 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
StdConv Ran
ran on a synthesized input · constructed an object; no result was computed
ky941122/darts-experiment/models/search_cells.py
code served (permissive licence) · get_code("b2b5ab2613ce6249")
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, StdConv: 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 = {
    "C_in": 3,
    "C_out": 16,
    "kernel_size": 3,
    "stride": 2,
    "padding": 1,
    "affine": 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 StdConv — 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 StdConv 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
Zero Ran
ran on a synthesized input · constructed an object; no result was computed
sinamoradian/SNIP-NAS-2/model_search.py
pointer only (licence: NONE) · get_code("0c8c2cf75802acb2")
How it ran

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

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

import torch
import torch.nn as nn

torch.manual_seed(0)

# Create a small input tensor for testing
# Shape: (batch=2, channels=4, height=8, width=8)
x = torch.randn(2, 4, 8, 8)

# Test case 1: stride = 1
stride_1 = 1

# Test case 2: stride = 2 (for testing the slicing operation)
stride_2 = 2

# We'll use stride=1 as the primary test case
ARGS = {
    "stride": 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 Zero — 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 Zero 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
Zero Ran
ran on a synthesized input · constructed an object; no result was computed
ky941122/darts-experiment/models/search_cells.py
code served (permissive licence) · get_code("40adb1723238c54f")
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, Zero: the run constructed the object and did not call it, so no result was computed. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch
import torch.nn as nn

torch.manual_seed(0)

# Create a small input tensor for testing
# Shape: (batch=2, channels=4, height=3, width=3)
x = torch.randn(2, 4, 3, 3)

# Define ARGS with the stride parameter
ARGS = {
    "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 Zero — 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 Zero 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
Zero Ran
ran on a synthesized input
anonNo2/MulTeacher-KD/models/search_cnn.py
pointer only (licence: NONE) · get_code("157a9f2bb5c00947")
How it ran

The body of this sample is withheld: GitHub detected no licence in this paper's repository, anonNo2/MulTeacher-KD 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 Ran
ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT)
DoctorLiQ/AutoML/cnn/utils.py
code served (permissive licence) · get_code("e93d9ddbfeb73ced")
How it ran

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

import torch

torch.manual_seed(0)

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

# output: logits/scores from model, shape (batch_size, num_classes)
output = torch.randn(batch_size, num_classes)

# target: ground truth labels, shape (batch_size,)
target = torch.tensor([0, 2])

# topk: tuple of k values to compute accuracy for
topk = (1, 2)

ARGS = {
    "output": output,
    "target": target,
    "topk": topk
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type list, ndim 1, dtype family float — a list output has no array shape of its own; none is stated
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
act_quant Ran
ran; our contract draft was wrong, not the code
yochaiz/darts-UNIQ/cnn/MixedLayer.py
code served (permissive licence) · get_code("dc2219edf51bea05")
How it ran

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

import torch

torch.manual_seed(0)

# Create a small input tensor (batch_size=2, features=4)
x = torch.randn(2, 4, requires_grad=True)

# Define act_max_value as a scalar
act_max_value = 1.0

# Define bitwidth as an integer
bitwidth = 8

ARGS = {
    'x': x,
    'act_max_value': act_max_value,
    'bitwidth': bitwidth
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type Tensor, ndim 2, dtype family float, shape (2, 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
add_flops_counting_methods Ran
ran; our contract draft was wrong, not the code
yochaiz/darts-UNIQ/cnn/MixedLayer.py
code served (permissive licence) · get_code("6887e3a481bbdf51")
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 SimpleConvNet. The image it ran in was not recorded. The code mentions cuda, and the harness aliases cuda to the CPU for every sample; whether this run needed that is not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch
import torch.nn as nn
from torch.nn import ModuleList, BatchNorm2d, Conv2d

torch.manual_seed(0)

# Create a minimal model with Conv2d layers
class SimpleConvNet(nn.Module):
    def __init__(self):
        super(SimpleConvNet, self).__init__()
        self.conv1 = Conv2d(in_channels=3, out_channels=8, kernel_size=3, groups=1, padding=1)
        self.bn1 = BatchNorm2d(8)
    
    def forward(self, x):
        x = self.conv1(x)
        x = self.bn1(x)
        return x

# Instantiate the model
net = SimpleConvNet()

# Define the ARGS dictionary
ARGS = {
    'net_main_module': net
}
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 SimpleConvNet — a SimpleConvNet output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a SimpleConvNet 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
adjust_lr Ran
ran, honoured the contract we drafted
DoctorLiQ/AutoML/cnn/train_imagenet.py
pointer only (licence: Apache-2.0); the stored copy get_code serves, from chenxin061/pdarts, is pointer only (licence: NOASSERTION) · get_code("e7ef53e9c5847e3e")
How it ran

The body of this sample is withheld: this paper's link allows the body inline (Apache-2.0), but get_code serves the stored copy, first harvested from chenxin061/pdarts, and GitHub could not classify the licence of that repository (NOASSERTION). 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.

arch_to_genotype Ran
ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT)
guoyongcs/NATv2/search_model.py
pointer only (licence: NONE) · get_code("17fa4f1fc1d15167")
How it ran

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

arch_to_matrix Ran
ran, honoured the contract we drafted
guoyongcs/NATv2/search_model.py
pointer only (licence: NONE) · get_code("2b306b50b019502e")
How it ran

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

check_quantization Ran
ran; our contract draft was wrong, not the code
yochaiz/darts-UNIQ/cnn/MixedLayer.py
code served (permissive licence) · get_code("ee8e28f152fee8d8")
How it ran

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

import torch

torch.manual_seed(0)

# The function takes a tensor x, moves it to CPU, gets unique values, sorts them,
# and returns the count of unique values.
# We need to construct a small tensor with some repeated values to test quantization.

x = torch.tensor([[1.0, 2.0, 3.0, 1.0],
                   [2.0, 3.0, 1.0, 2.0]], dtype=torch.float32)

ARGS = {
    "x": x
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type int, ndim 0, dtype family int, shape () — shape () as a later run recorded it
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
collectStats Ran
ran; our contract draft was wrong, not the code
yochaiz/darts-UNIQ/cnn/MixedLayer.py
code served (permissive licence) · get_code("6f070fe81b2b020e")
How it ran

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

import torch
import numpy as np

torch.manual_seed(0)

# Analyze the function:
# - type: used as first element in result list (string or any type)
# - val: passed to lambda functions that call:
#   - .argmin() and .min() - needs a tensor or array-like with these methods
#   - '' (string literal, not used with val)
#   - sum(x) / len(x) - needs to be iterable with sum and len
#   - .argmax() and .max() - needs a tensor or array-like with these methods

# val should be a tensor that supports argmin, min, argmax, max, sum, len
val = torch.tensor([3.2, 1.5, 4.1, 2.8])

type_arg = "Statistics"

ARGS = {
    "type": type_arg,
    "val": val
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy, torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type list — a list 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
compute_average_bops_cost Ran
ran, honoured the contract we drafted
yochaiz/darts-UNIQ/cnn/MixedLayer.py
code served (permissive licence) · get_code("1884427dc95caff7")
How it ran

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

import torch
import torch.nn as nn
from torch.nn import ModuleList, BatchNorm2d, Conv2d

torch.manual_seed(0)

class SimpleNet(nn.Module):
    def __init__(self):
        super().__init__()
        self.conv1 = Conv2d(3, 16, kernel_size=3, padding=1)
        self.bn1 = BatchNorm2d(16)
        self.conv2 = Conv2d(16, 32, kernel_size=3, padding=1)
        
    def forward(self, x):
        x = self.conv1(x)
        x = self.bn1(x)
        x = self.conv2(x)
        return x

# Create a model instance
model = SimpleNet()

# Add the required attributes that compute_average_bops_cost expects
model.__batch_counter__ = 2

# Add __bops__ attribute to each Conv2d module
for module in model.modules():
    if isinstance(module, Conv2d):
        module.__bops__ = 1000

ARGS = {
    'self': model
}
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
compute_average_flops_cost Ran
ran, honoured the contract we drafted
yochaiz/darts-UNIQ/cnn/MixedLayer.py
code served (permissive licence) · get_code("ccb0d5c261dc1bbf")
How it ran

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

import torch
import torch.nn as nn
from torch.nn import ModuleList, BatchNorm2d, Conv2d

torch.manual_seed(0)

# Create a minimal model with Conv2d modules that have __flops__ attribute
class MinimalNet(nn.Module):
    def __init__(self):
        super().__init__()
        self.conv1 = Conv2d(3, 16, kernel_size=3, padding=1)
        self.conv2 = Conv2d(16, 32, kernel_size=3, padding=1)
        self.bn = BatchNorm2d(32)
    
    def forward(self, x):
        return self.bn(self.conv2(self.conv1(x)))

# Create an instance of the model
model = MinimalNet()

# Set the __batch_counter__ attribute (required by the function)
model.__batch_counter__ = 4

# Set __flops__ attribute on each Conv2d module
model.conv1.__flops__ = 1000
model.conv2.__flops__ = 2000

# The function is a method, so we need to bind it to the model instance
# or call it on the model itself. We'll add it as a method.
def compute_average_flops_cost(self):
    """
    A method that will be available after add_flops_counting_methods() is called
    on a desired net object.

    Returns current mean flops consumption per image.

    """
    batches_count = self.__batch_counter__
    flops_sum = 0
    for module in self.modules():
        if isinstance(module, Conv2d):
            flops_sum += module.__flops__
    return flops_sum / batches_count

# Bind the method to the model
model.compute_average_flops_cost = compute_average_flops_cost.__get__(model, MinimalNet)

ARGS = {
    'self': model
}
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
compute_bops_mults_adds Ran
ran, honoured the contract we drafted
yochaiz/darts-UNIQ/cnn/MixedLayer.py
code served (permissive licence) · get_code("741e43d2364cb3e7")
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
import torch.nn as nn
from torch.nn import ModuleList, BatchNorm2d, Conv2d

torch.manual_seed(0)

class ModelWithConv(nn.Module):
    def __init__(self):
        super().__init__()
        self.conv = Conv2d(3, 16, kernel_size=3, padding=1)
        # Add the required attributes that the function accesses
        self.conv.__mults__ = 1000
        self.conv.__adds__ = 2000
        self.conv.__calc_mac_value__ = 3000
    
    def forward(self, x):
        return self.conv(x)

def compute_bops_mults_adds(model_instance, batch_size):
    conv = [m for m in model_instance.modules() if isinstance(m, Conv2d)]
    assert len(conv) == 1
    conv = conv[0]
    return (conv.__mults__, conv.__adds__, conv.__calc_mac_value__, batch_size)

model = ModelWithConv()

ARGS = {
    'self': model,
    'batch_size': 2
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type 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
concat Ran
ran, honoured the contract we drafted
adammenges/DARTS-PyTorch/cnn/arch.py
code served (permissive licence) · get_code("94df8664a92747e5")
How it ran

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

import torch

torch.manual_seed(0)

# The function takes a list of tensors, flattens each one, and concatenates them
# We need to create a list of tensors with different shapes to test the function

tensor1 = torch.randn(2, 3)  # Shape [2, 3]
tensor2 = torch.randn(4, 5)  # Shape [4, 5]
tensor3 = torch.randn(2)     # Shape [2]

xs = [tensor1, tensor2, tensor3]

ARGS = {
    "xs": xs
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type Tensor, ndim 1, dtype family float, shape (28,) — shape (28,) 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
convert_lstm_output Ran
ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT)
guoyongcs/NATv2/search_model.py
pointer only (licence: NONE) · get_code("0a909cc50287bef2")
How it ran

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

cost_spec_zero_fn Ran
ran, honoured the contract we drafted
eml-eda/plinio/plinio/methods/dnas_base/dnas.py
code served (permissive licence) · get_code("fb1b499268a1e793")
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 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)

def cost_spec_zero_fn(_):
    return torch.tensor(0.0)

ARGS = {
    "_": None
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type Tensor, 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
data_transforms Ran
ran; our contract draft was wrong, not the code
khanrc/pt.darts/preproc.py
code served (permissive licence) · get_code("1d6c0c0dff1c1274")
How it ran

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

import torch
import numpy as np
import torchvision.transforms as transforms

torch.manual_seed(0)
np.random.seed(0)

ARGS = {
    'dataset': 'cifar10',
    'cutout_length': 8
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy, torch, torchvision — 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
data_transforms Ran
ran on a synthesized input
abcp4/MyDarts/preproc.py
code served (permissive licence) · get_code("1110ae3cbc865a46")
How it ran

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

import torch
import numpy as np
import torchvision.transforms as transforms

torch.manual_seed(0)
np.random.seed(0)

ARGS = {
    "dataset": "cifar10",
    "cutout_length": 8,
    "resize": 64,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy, torch, torchvision — 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
data_transforms Ran
ran on a synthesized input
grtzsohalf/pt.darts/preproc.py
code served (permissive licence) · get_code("95b3a859cdfee2ba")
How it ran

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

import torch
import numpy as np
import torchvision.transforms as transforms

torch.manual_seed(0)
np.random.seed(0)

ARGS = {
    'dataset': 'cifar10',
    'cutout_length': 8
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy, torch, torchvision — 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
get_logger Ran
ran on a synthesized input
grtzsohalf/pt.darts/utils.py
code served (permissive licence) · get_code("93204f7c934e37f7")
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 Logger. 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 logging
import tempfile
import os

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

ARGS = {
    'file_path': file_path
}
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 Logger — a Logger output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a Logger 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_parser Ran
ran; our contract draft was wrong, not the code
KnightZhang625/DARTS_NAS_TextClassification/config.py
pointer only (licence: MIT); the stored copy get_code serves, from harveyp123/maxk-gnn, is pointer only (licence: NONE) · get_code("bf0bc305c2302fec")
How it ran

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

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

Also present in other papers' code

Of 156 samples lifted from this paper's linked repositories, 156 carry a function identity and 0 do not. Of the 142 distinct functions with an identity, 20 are also present in other papers whose code we hold (8 with at least one paper dated earlier, 0 the same month, 18 later) and 122 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
accuracy
brick of this paper's assembly: helper
71 other papers
7 dated earlier, 64 later · 2 only as an assembly brick
1505.05424 (2015-05)
Weight Uncertainty in Neural Networks
1705.07204 (2017-05)
Ensemble Adversarial Training: Attacks and Defenses
1802.10399 (2018-02)
Compressing Neural Networks using the Variational Information Bottleneck
and 68 more not named here
adjust_lr 8 other papers
8 later
1904.12760 (2019-04)
Progressive Differentiable Architecture Search: Bridging the Depth Gap between Search and Evaluation
1906.07528 (2019-06)
Prune and Replace NAS
1912.00195 (2019-12)
SGAS: Sequential Greedy Architecture Search
and 5 more not named here
count_parameters_in_MB 8 other papers
8 later
1912.00195 (2019-12)
SGAS: Sequential Greedy Architecture Search
2004.14557 (2020-04)
Learning Deformable Image Registration from Optimization: Perspective, Modules, Bilevel Training and Beyond
2006.16537 (2020-06)
Theory-Inspired Path-Regularized Differential Network Architecture Search
and 5 more not named here
accuracy 7 other papers
7 later
2103.15798 (2021-03)
Rethinking Neural Operations for Diverse Tasks
2109.03508 (2021-09)
RepNAS: Searching for Efficient Re-parameterizing Blocks
aaai_26076 (2023 (year only))
PINAT: A Permutation INvariance Augmented Transformer for NAS Predictor
and 4 more not named here
drop_path 6 other papers
6 later
1912.00195 (2019-12)
SGAS: Sequential Greedy Architecture Search
2006.16537 (2020-06)
Theory-Inspired Path-Regularized Differential Network Architecture Search
2007.03154 (2020-07)
Discretization-Aware Architecture Search
and 3 more not named here
GraphConvolution
brick of this paper's assembly: helper
3 other papers
1 dated earlier, 2 later · 2 only as an assembly brick
1609.02907 (2016-09)
Semi-Supervised Classification with Graph Convolutional Networks
2407.16168 (2024-07)
Progressively Modality Freezing for Multi-Modal Entity Alignment
2605.19738 (2026-05)
TERGAD: Structure-Aware Text-Enhanced Representations for Graph Anomaly Detection
broadcast_list 2 other papers
1 dated earlier, 1 later
1805.09501 (2018-05)
AutoAugment: Learning Augmentation Policies from Data
2101.04028 (2021-01)
Unchain the Search Space with Hierarchical Differentiable Architecture Search
drop_path_ 2 other papers
1 dated earlier, 1 later
1805.09501 (2018-05)
AutoAugment: Learning Augmentation Policies from Data
2001.01431 (2020-01)
Deeper Insights into Weight Sharing in Neural Architecture Search
from_str 2 other papers
1 dated earlier, 1 later
1805.09501 (2018-05)
AutoAugment: Learning Augmentation Policies from Data
2001.01431 (2020-01)
Deeper Insights into Weight Sharing in Neural Architecture Search
get_parser 2 other papers
2 later
2001.01431 (2020-01)
Deeper Insights into Weight Sharing in Neural Architecture Search
2312.08656 (2023-12)
MaxK-GNN: Extremely Fast GPU Kernel Design for Accelerating Graph Neural Networks Training
param_size 2 other papers
1 dated earlier, 1 later
1805.09501 (2018-05)
AutoAugment: Learning Augmentation Policies from Data
2312.08656 (2023-12)
MaxK-GNN: Extremely Fast GPU Kernel Design for Accelerating Graph Neural Networks Training
DilConv
brick of this paper's assembly: model
1 other paper
1 later
2004.07802 (2020-04)
Geometry-Aware Gradient Algorithms for Neural Architecture Search
FactorizedReduce
brick of this paper's assembly: model
1 other paper
1 later
2004.07802 (2020-04)
Geometry-Aware Gradient Algorithms for Neural Architecture Search
ReLUConvBN
brick of this paper's assembly: entry, helper, model
1 other paper
1 later
2004.07802 (2020-04)
Geometry-Aware Gradient Algorithms for Neural Architecture Search
Zero
brick of this paper's assembly: helper, model
1 other paper
1 later
2004.07802 (2020-04)
Geometry-Aware Gradient Algorithms for Neural Architecture Search
act_quant
brick of this paper's assembly: helper
1 other paper
1 later
1810.00162 (2018-10)
NICE: Noise Injection and Clamping Estimation for Neural Network Quantization
data_transforms 1 other paper
1 later
2001.01431 (2020-01)
Deeper Insights into Weight Sharing in Neural Architecture Search
get_logger 1 other paper
1 dated earlier
1805.09501 (2018-05)
AutoAugment: Learning Augmentation Policies from Data
parse
brick of this paper's assembly: helper
1 other paper
1 dated earlier
1805.09501 (2018-05)
AutoAugment: Learning Augmentation Policies from Data
parse_gpus 1 other paper
1 later
2209.04766 (2022-09)
Towards Sparsification of Graph Neural Networks

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

This paper addresses the scalability challenge of architecture search by formulating the task in a differentiable manner. Unlike conventional approaches of applying evolution or reinforcement learning over a discrete and non-differentiable search space, our method is based on the continuous relaxation of the architecture representation, allowing efficient search of the architecture using gradient descent. Extensive experiments on CIFAR-10, ImageNet, Penn Treebank and WikiText-2 show that our algorithm excels in discovering high-performance convolutional architectures for image classification and recurrent architectures for language modeling, while being orders of magnitude faster than state-of-the-art non-differentiable techniques. Our implementation has been made publicly available to facilitate further research on efficient architecture search algorithms. Discovering state-of-the-art neural network architectures requires substantial effort of human experts. Recently, there has been a growing interest in developing algorithmic solutions to automate the manual process of architecture design. The automatically searched architectures have achieved highly competitive performance in tasks such as image classification (

For agents

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

get_harvested_code_for_paper("1806.09055")
get_code_for_paper("1806.09055")
have("1806.09055")

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

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

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

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

Connect an agent — have() is free.