SYNTOLOGY HomeExplorerAtlasCodeMethodologyAboutDevelopersFeedPricing
Paper · 1909.13404 · 2019

Towards modular and programmable architecture search

arXiv · PDF · Open in the Atlas

Code that ran

11 of 16 samples (functions and classes) lifted from this paper's linked repositories executed on a synthesized input in Syntology's jail (0 of them constructed an object rather than computing a result; 0 honoured the contract we drafted, 0 violated it and 10 have no contract verdict; 1 failure of our instrument; 5 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/1909.13404.json · badge: /api/ran/1909.13404.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
negrinho/deep_architect canonical (classifier label)
classifier basis: classifier_2025
1 ran · 2 no recorded run
negrinho/deep_architect_legacy community (classifier label)
classifier basis not recorded on the link
10 ran · 3 no recorded run
FunctionStatusWhere it lives
Optional_fn Ran
ran on a synthesized input
negrinho/deep_architect_legacy/darch/modules.py
code served (permissive licence) · get_code("a23397aa96508c9e")
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 Or. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch
import torch.nn as nn

torch.manual_seed(0)

class Scope:
    """Stand-in scope object that manages namespaces."""
    def __init__(self):
        self.names = {}
    
    def get_valid_name(self, prefix):
        if prefix not in self.names:
            self.names[prefix] = 0
        else:
            self.names[prefix] += 1
        return f"{prefix}_{self.names[prefix]}"
    
    def register_namespace(self, name):
        pass

class BasicModule(object):
    """Basic search and compilation functionality for basic modules."""

    def __init__(self):
        self.order = []
        self.domains = []
        self.chosen = []
        self.in_d = None
        self.scope = None
        self.namespace_id = None

    def initialize(self, in_d, scope):
        if self.in_d != None or self.scope != None:
            raise AssertionError
        if len(in_d) < 1:
            raise ValueError
        self.in_d = in_d
        self.scope = scope
        prefix = self.__class__.__name__
        name = scope.get_valid_name(prefix)
        self.namespace_id = name
        scope.register_namespace(name)
        propagate(self)

    def get_outdim(self):
        raise NotImplementedError

    def is_specified(self):
        return self.scope != None and self.in_d != None and (len(self.chosen) == len(self.order))

    def get_choices(self):
        assert not self.is_specified()
        i = len(self.chosen)
        return (self.order[i], self.domains[i])

    def choose(self, choice_i):
        assert not self.is_specified()
        if len(self.domains[len(self.chosen)]) <= choice_i:
            raise ValueError
        self.chosen.append(choice_i)
        propagate(self)

    def repr_program(self):
        name = self.__class__.__name__
        return (name,) + tuple(self.domains)

    def repr_model(self):
        name = self.__class__.__name__
        vals = [dm[i] for i, dm in zip(self.chosen, self.domains)]
        r = (name,) + tuple(vals)
        return (r,)

    def compile(self, in_x, train_feed, eval_feed):
        raise NotImplementedError

class Empty(BasicModule):
    """Empty Module that passes input to output without transformation."""

    def get_outdim(self):
        return self.in_d

    def compile(self, in_x, train_feed, eval_feed):
        return in_x

def propagate(b):
    """Propagates choices in a module."""
    while not b.is_specified() and len(b.get_choices()[1]) == 1:
        b.choose(0)

class Or:
    def __init__(self, bs):
        if len(bs) == 0:
            raise ValueError
        self.order = ['or_branch']
        self.domains = [range(len(bs))]
        self.bs = bs
        self.in_d = None
        self.chosen = []
        self.scope = None

    def initialize(self, in_d, scope):
        self.in_d = in_d
        self.scope = scope
        propagate(self)

    def get_outdim(self):
        i = self.chosen[0]
        return self.bs[i].get_outdim()

    def is_specified(self):
        if len(self.chosen) == 1:
            i = self.chosen[0]
            return self.bs[i].is_specified()
        else:
            return False

    def get_choices(self):
        if len(self.chosen) == 0:
            return (self.order[0], self.domains[0])
        else:
            i = self.chosen[0]
            return self.bs[i].get_choices()

    def choose(self, choice_i):
        if len(self.chosen) == 0:
            self.chosen.append(choice_i)
            self.bs[choice_i].initialize(self.in_d, self.scope)
        else:
            b_i = self.chosen[0]
            self.bs[b_i].choose(choice_i)

    def repr_program(self):
        name = self.__class__.__name__
        args = [b.repr_program() for b in self.bs]
        return (name,) + tuple(args)

    def repr_model(self):
        vals = self.bs[self.chosen[0]].repr_model()
        return vals

    def compile(self, in_x, train_feed, eval_feed):
        out_y = self.bs[self.chosen[0]].compile(in_x, train_feed, eval_feed)
        return out_y

def Optional_fn(b):
    return Or([Empty(), b])

# Create a small BasicModule subclass for testing
class SimpleModule(BasicModule):
    def __init__(self):
        super().__init__()
        self.order = []
        self.domains = []
    
    def get_outdim(self):
        return self.in_d
    
    def compile(self, in_x, train_feed, eval_feed):
        return in_x

# Construct arguments
module = SimpleModule()

ARGS = {
    'b': module
}
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 Or — a Or output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a Or output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not stated
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
compute_padded_dims Ran
ran on a synthesized input
negrinho/deep_architect_legacy/darch/modules.py
code served (permissive licence) · get_code("d77c894b8db356ad")
How it ran

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

import numpy as np

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

# Construct valid arguments for compute_percentiles
scores = [0.1, 0.3, 0.5, 0.7, 0.9, 1.0, 0.2, 0.8]
thresholds = [0.0, 0.25, 0.5, 0.75, 1.0]

ARGS = {
    "scores": scores,
    "thresholds": thresholds
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type 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
constant_initializer Ran
ran on a synthesized input
negrinho/deep_architect_legacy/darch/initializers.py
code served (permissive licence) · get_code("23308e943e627336")
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 function. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import tensorflow as tf
import numpy as np

def constant_initializer(val):
    initer = tf.constant_initializer(val)

    def init_fn(shape):
        init_vals = initer(shape)
        return init_vals
    return init_fn

# Create a simple scalar value to pass as the constant
val = 0.5

ARGS = {
    "val": val
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy, tensorflow — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type function — a function output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a function 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
gaussian_initializer Ran
ran on a synthesized input
negrinho/deep_architect_legacy/darch/initializers.py
code served (permissive licence) · get_code("06396da2b2c2b8ad")
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 function. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import tensorflow as tf

ARGS = {
    "mean": 0.0,
    "stddev": 1.0,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
tensorflow — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type function — a function output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a function 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
load_mnist Ran
ran on a synthesized input
negrinho/deep_architect_legacy/darch/datasets.py
code served (permissive licence) · get_code("a670d1a23a9c9041")
How it ran

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

import os
import tempfile
import numpy as np

# Create a temporary directory for data_dir
temp_dir = tempfile.mkdtemp()

# Mock the tensorflow MNIST data structure
class MockMNISTDataset:
    def __init__(self):
        self.images = np.random.rand(10, 784).astype(np.float32)
        self.labels = np.eye(10)[:10]  # one-hot encoded

class MockMNISTData:
    def __init__(self):
        self.train = MockMNISTDataset()
        self.validation = MockMNISTDataset()
        self.test = MockMNISTDataset()

# Monkey-patch tensorflow.examples.tutorials.mnist.input_data
import sys
from unittest.mock import MagicMock

# Create mock tensorflow module structure
mock_tf = MagicMock()
mock_examples = MagicMock()
mock_tutorials = MagicMock()
mock_mnist_module = MagicMock()
mock_input_data = MagicMock()

def mock_read_data_sets(data_dir, one_hot=True, reshape=False):
    return MockMNISTData()

mock_input_data.read_data_sets = mock_read_data_sets
mock_mnist_module.input_data = mock_input_data
mock_tutorials.mnist = mock_mnist_module
mock_examples.tutorials = mock_tutorials
mock_tf.examples = mock_examples

sys.modules['tensorflow'] = mock_tf
sys.modules['tensorflow.examples'] = mock_examples
sys.modules['tensorflow.examples.tutorials'] = mock_tutorials
sys.modules['tensorflow.examples.tutorials.mnist'] = mock_mnist_module
sys.modules['tensorflow.examples.tutorials.mnist.input_data'] = mock_input_data

ARGS = {
    'data_dir': temp_dir,
    'flatten': False,
    'one_hot': True,
    'normalize_range': False
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy, tensorflow — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type tuple — a tuple output has no array shape of its own; none is stated
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
onehot_to_idx Ran
ran on a synthesized input
negrinho/deep_architect_legacy/darch/datasets.py
code served (permissive licence) · get_code("863b33d3c3b063c5")
How it ran

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

import numpy as np

# Create a one-hot encoded array
# Shape: (batch_size=2, num_classes=4)
# Each row has exactly one position with value > 0.0
y_onehot = np.array([
    [1.0, 0.0, 0.0, 0.0],
    [0.0, 0.0, 1.0, 0.0]
], dtype=np.float32)

ARGS = {
    "y_onehot": y_onehot
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type ndarray, ndim 1, dtype family int, shape (2,) — shape (2,) 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
propagate_seq Ran
ran on a synthesized input
negrinho/deep_architect_legacy/darch/modules.py
code served (permissive licence) · get_code("31baee2de886be6b")
How it ran

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

import torch
import torch.nn as nn

torch.manual_seed(0)

class MockModule(nn.Module):
    """Mock module that has is_specified(), scope, get_outdim(), and initialize() methods."""
    
    def __init__(self, specified=False, scope_val="scope_default", outdim=4):
        super().__init__()
        self._specified = specified
        self.scope = scope_val
        self._outdim = outdim
    
    def is_specified(self):
        return self._specified
    
    def get_outdim(self):
        return self._outdim
    
    def initialize(self, input_dim, scope):
        # Mock initialization that marks this module as specified
        self._specified = True
        self.scope = scope


# Create a sequence of modules
# Module 0: specified=True, will trigger initialization of Module 1
# Module 1: specified=False initially, will become specified after initialize()
# Module 2: specified=False, may or may not be initialized depending on chain
module_0 = MockModule(specified=True, scope_val="scope_0", outdim=5)
module_1 = MockModule(specified=False, scope_val="scope_1", outdim=6)
module_2 = MockModule(specified=False, scope_val="scope_2", outdim=7)

bs = [module_0, module_1, module_2]

ARGS = {
    "bs": bs,
    "i": 0
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type 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
running_max_stats Ran
ran on a synthesized input
negrinho/deep_architect_legacy/plots.py
code served (permissive licence) · get_code("d3779a34252371e5")
How it ran

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

import numpy as np

# Create a small sample scores array
# Shape: (batch_size=2, sequence_length=4)
# This will be used with np.maximum.accumulate along axis=1
scores = np.array([
    [1.0, 3.0, 2.0, 5.0],
    [2.0, 1.0, 4.0, 3.0]
], dtype=np.float32)

ARGS = {
    "scores": scores
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type tuple — a tuple output has no array shape of its own; none is stated
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
sorted_values_by_key Ran
ran; our contract draft was wrong, not the code
negrinho/deep_architect/deep_architect/core.py
code served (permissive licence) · get_code("0fcde3f7818db7b9")
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 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

torch.manual_seed(0)

# The function sorted_values_by_key takes a dict 'd' and returns values sorted by keys
# It accesses d[k] for each key k in sorted(d)
# So we need a dict with sortable keys and any values

ARGS = {
    "d": {
        "apple": 42,
        "banana": 3.14,
        "cherry": [1, 2, 3],
        "date": torch.tensor([1.0, 2.0, 3.0, 4.0])
    }
}
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 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
xavier_initializer_affine Ran
ran on a synthesized input
negrinho/deep_architect_legacy/darch/initializers.py
code served (permissive licence) · get_code("817a654081d21835")
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 function. 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 numpy as np
import tensorflow as tf

def xavier_initializer_affine(gain=1.0):
    def init_fn(shape):
        n, m = shape
        sc = gain * (np.sqrt(6.0) / np.sqrt(m + n))
        init_vals = tf.random_uniform([n, m], -sc, sc)
        return init_vals
    return init_fn

ARGS = {
    "gain": 1.0
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy, tensorflow — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type function — a function output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a function 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
deepconv_ss0 Not yet run
unverified (harvested, no recorded run)
negrinho/deep_architect_legacy/search_spaces.py
code served (permissive licence) · get_code("3dd086420646eb90")
How it ran

no invocation recorded.

determine_module_eval_seq Not yet run
unverified (harvested, no recorded run)
negrinho/deep_architect/deep_architect/core.py
code served (permissive licence) · get_code("9c8caae33be86506")
How it ran

no invocation recorded.

extract_unique_modules Not yet run
unverified (harvested, no recorded run)
negrinho/deep_architect/deep_architect/core.py
code served (permissive licence) · get_code("4c8342e71f166f2b")
How it ran

no invocation recorded.

resnet_ss0 Not yet run
unverified (harvested, no recorded run)
negrinho/deep_architect_legacy/search_spaces.py
code served (permissive licence) · get_code("dc596d8ae84aa4d6")
How it ran

no invocation recorded.

tfref_convnet_ss0 Not yet run
unverified (harvested, no recorded run)
negrinho/deep_architect_legacy/search_spaces.py
code served (permissive licence) · get_code("c16000cc3ab471b6")
How it ran

no invocation recorded.

Also present in other papers' code

Of 16 samples lifted from this paper's linked repositories, 16 carry a function identity and 0 do not. Of the 16 distinct functions with an identity, 0 are also present in other papers whose code we hold (0 with at least one paper dated earlier, 0 the same month, 0 later) and 16 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.

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

Repositories linked to this paper

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

Abstract

Neural architecture search methods are able to find high performance deep learning architectures with minimal effort from an expert. However, current systems focus on specific use-cases (e.g. convolutional image classifiers and recurrent language models), making them unsuitable for general use-cases that an expert might wish to write. Hyperparameter optimization systems are general-purpose but lack the constructs needed for easy application to architecture search. In this work, we propose a formal language for encoding search spaces over general computational graphs. The language constructs allow us to write modular, composable, and reusable search space encodings and to reason about search space design. We use our language to encode search spaces from the architecture search literature. The language allows us to decouple the implementations of the search space and the search algorithm, allowing us to expose search spaces to search algorithms through a consistent interface. Our experiments show the ease with which we can experiment with different combinations of search spaces and search algorithms without having to implement each combination from scratch. We release an implementation of our language with this paper.

For agents

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

get_harvested_code_for_paper("1909.13404")
get_code_for_paper("1909.13404")
have("1909.13404")

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

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

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

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

Connect an agent — have() is free.