SYNTOLOGY HomeExplorerAtlasCodeMethodologyAboutDevelopersFeedPricing
Paper · 2106.06575 · ICML · 2021

Auto-NBA: Efficient and Effective Search Over the Joint Space of Networks, Bitwidths, and Accelerators

David Cox, Yang Zhang, Yongan Zhang, Yingyan Lin, Yonggan Fu

arXiv · PDF · Open in the Atlas

Code that ran

18 of 26 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; 1 honoured the contract we drafted, 0 violated it and 0 have no contract verdict; 17 failures of our instrument; 8 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/2106.06575.json · badge: /api/ran/2106.06575.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
RICE-EIC/Auto-NBA marked official in Papers with Code
Papers with Code archive
16 ran · 8 no recorded run
copy not recorded community
not in the paper's declared repositories
2 ran · 0 no recorded run
FunctionStatusWhere it lives
allocate_layers Ran
ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT)
RICE-EIC/Auto-NBA/model_search.py
code served (permissive licence) · get_code("dde6796a9649b047")
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 torch
import numpy as np

torch.manual_seed(0)

# Analyze the function to understand what it needs:
# - net_struct: list of structures, each with at least index [2] (a numeric value for channel count)
# - quant_info: list of quantization bits (integers)
# - dw: list of booleans indicating depthwise convolution
# - platform_specs: dict (not actually used in the function body)
# - cifar: boolean flag

# Create net_struct: list of layer structures
# Each layer needs at least index [2] which represents channel count
# Format appears to be: [in_channels, out_channels, kernel_size, ...]
net_struct = [
    [3, 16, 10],      # layer 0: small kernel (< 16 for CIFAR)
    [16, 32, 20],     # layer 1: large kernel (>= 16 for CIFAR)
    [32, 64, 8],      # layer 2: small kernel
    [64, 128, 28],    # layer 3: large kernel
]

# Create quant_info: quantization bits for each layer
quant_info = [4, 8, 4, 8]

# Create dw: depthwise convolution flags for each layer
dw = [False, True, False, True]

# Create platform_specs: not used in function body but required as parameter
platform_specs = {
    'memory': 1024,
    'compute': 2048,
}

# Create CIFAR flag
cifar = True

ARGS = {
    'net_struct': net_struct,
    'quant_info': quant_info,
    'dw': dw,
    'platform_specs': platform_specs,
    'cifar': cifar,
}
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 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
combined_latency Ran
ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT)
RICE-EIC/Auto-NBA/model_search.py
code served (permissive licence) · get_code("2745222d0ad20aeb")
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 math

# Analyze the function signatures and their usage:
# - comp_mode: integer (0, 1, or 2)
# - input_params: list/array with indices 0-7 accessed
# - net_struct: list/array with indices 0-3 accessed
# - quant: optional integer parameter (default 16)

# From the code analysis:
# input_params needs at least 8 elements (indices 0-7 used)
# net_struct needs at least 4 elements (indices 0-3 used)

# Let's trace through combined_latency to understand the constraints:
# - input_params[0], [1], [2], [3], [4], [5], [6], [7] are all used
# - net_struct[0], [1], [2], [3] are all used
# - All values should be positive numbers to avoid division by zero
# - quant is typically a power of 2 for quantization

# Constructing valid arguments:
ARGS = {
    "comp_mode": 0,
    "input_params": [
        8.0,      # [0] - outer_loop_tr divisor, also used in comp calculation
        6.0,      # [1] - outer_loop_tc divisor
        16.0,     # [2] - outer_loop_tm divisor, channel/feature multiplier
        4.0,      # [3] - outer_loop_tn divisor, batch multiplier
        4.0,      # [4] - tri/clear_buffer divisor
        3.0,      # [5] - tci computation
        2.0,      # [6] - comp_mode 0,1 and write divisor
        2.0,      # [7] - comp_mode 1 divisor, read_ofmap divisor
    ],
    "net_struct": [
        64.0,     # [0] - outer_loop_tn multiplier (N dimension)
        32.0,     # [1] - outer_loop_tm multiplier (M dimension)
        24.0,     # [2] - outer_loop_tc and outer_loop_tr multiplier (C, H dimension)
        3.0,      # [3] - kernel size (used in comp and read calculations)
    ],
    "quant": 16,
}
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 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
comp_engine_lat Ran
ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT)
RICE-EIC/Auto-NBA/model_search.py
code served (permissive licence) · get_code("d6f30bbd3dc5ba42")
How it ran

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

import torch
import numpy as np

torch.manual_seed(0)

# Analyzing the function:
# - comp_mode: int (0, 1, or 2)
# - input_params: indexable with indices 0,1,2,3,4,6,7 (list or array)
# - net_struct: indexable with index 3 (list or array)
# All accessed values are used in arithmetic operations

# Create input_params with at least 8 elements (indices 0-7)
# Using distinct values to avoid ambiguity
input_params = [2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0]

# Create net_struct with at least 4 elements (index 3)
net_struct = [1.0, 2.0, 3.0, 4.0]

# Create comp_mode as an int (0, 1, or 2)
comp_mode = 0

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

# The function design_choice_gen takes two boolean parameters: cifar and edd
# Looking at the function body, it only uses these parameters as conditions
# to determine which design spaces to return. It doesn't actually use them
# in any complex way - just as boolean flags for branching logic.

ARGS = {
    'cifar': True,
    'edd': False
}
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 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
dw_combined_latency Ran
ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT)
RICE-EIC/Auto-NBA/model_search.py
code served (permissive licence) · get_code("5d5557669b20df95")
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 math

# Analyze the function signature and requirements
# dw_combined_latency(comp_mode, input_params, net_struct, quant=16)

# From analyzing the function body:
# - comp_mode: integer (0, 1, or 2 based on conditions)
# - input_params: list/tuple with at least 7 elements (indexed 0-6)
#   - input_params[0]: tr (tile row)
#   - input_params[1]: tc (tile col)
#   - input_params[2]: tm (tile channel)
#   - input_params[3]: must be 1 (input channel tiling)
#   - input_params[4]: used in various calculations
#   - input_params[5]: used in read_if calculations
#   - input_params[6]: used in various calculations
# - net_struct: list/tuple with at least 4 elements
#   - net_struct[1]: M (total channels)
#   - net_struct[2]: spatial dimension
#   - net_struct[3]: kernel size (K)
# - quant: integer, defaults to 16

# Create valid test arguments
comp_mode = 0

# input_params: [tr, tc, tm, tci, tro, tci_read, tro_read]
# Need to satisfy: input_params[3] == 1
# All values should be positive integers
input_params = [
    8,    # input_params[0]: tr (tile row)
    8,    # input_params[1]: tc (tile col)
    16,   # input_params[2]: tm (tile channel)
    1,    # input_params[3]: tci (MUST be 1)
    4,    # input_params[4]: tro
    4,    # input_params[5]: tci_read
    4,    # input_params[6]: tro_read
]

# net_struct: [C, M, spatial, K]
# net_struct[3] is kernel size, net_struct[2] is spatial dimension
# net_struct[1] is total channels M
net_struct = [
    32,   # net_struct[0]: C (channels)
    64,   # net_struct[1]: M (output channels)
    32,   # net_struct[2]: spatial dimension (H/W)
    3,    # net_struct[3]: K (kernel size)
]

quant = 16

ARGS = {
    "comp_mode": comp_mode,
    "input_params": input_params,
    "net_struct": net_struct,
    "quant": quant,
}
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 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
dw_comp_engine_lat Ran
ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT)
RICE-EIC/Auto-NBA/model_search.py
code served (permissive licence) · get_code("d4f83a7f576254e7")
How it ran

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

import torch
import numpy as np

torch.manual_seed(0)

# Analyzing the function:
# - comp_mode: integer (0 or 1)
# - input_params: list/tuple with at least 7 elements (indices 0-6 used)
#   - input_params[0], [1], [2], [3], [4], [6] are used in calculations
#   - input_params[3] must equal 1
# - net_struct: list/tuple with at least 4 elements (index 3 used)
#   - net_struct[3] is used in calculations

# Create valid input_params
# input_params[3] must be 1 (channel tiling constraint)
input_params = [
    2,      # [0]: some dimension
    3,      # [1]: some dimension
    4,      # [2]: some dimension
    1,      # [3]: MUST be 1 (input channel & tiling)
    5,      # [4]: divisor for comp_mode 1
    6,      # [5]: unused but present
    7       # [6]: divisor for comp_mode 0
]

# Create valid net_struct
# net_struct[3] is used in calculation
net_struct = [
    10,     # [0]: unused
    11,     # [1]: unused
    12,     # [2]: unused
    2       # [3]: kernel size or similar dimension
]

# comp_mode can be 0 or 1
comp_mode = 0

ARGS = {
    'comp_mode': comp_mode,
    'input_params': input_params,
    'net_struct': net_struct
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy, torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type float, ndim 0, dtype family float, shape () — shape () as a later run recorded it
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
dw_read_if_lat Ran
ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT)
RICE-EIC/Auto-NBA/model_search.py
code served (permissive licence) · get_code("69a5f7e7f77884eb")
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 math
import torch
import numpy as np

# Analyzing the function:
# - comp_mode: integer (compared to 2)
# - input_params: indexable with indices 0-6 (7 elements needed)
# - net_struct: indexable with index 3 (at least 4 elements)
# - quant: integer, default 16

# The function accesses:
# input_params[0], input_params[1], input_params[2], input_params[4], input_params[5], input_params[6]
# net_struct[3]

ARGS = {
    "comp_mode": 2,
    "input_params": [10, 12, 8, 0, 5, 6, 3],
    "net_struct": [1, 2, 3, 4],
    "quant": 16
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy, torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type 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
dw_read_we_lat Ran
ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT)
RICE-EIC/Auto-NBA/model_search.py
code served (permissive licence) · get_code("11ad6ba24dd52bed")
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 math

def dw_read_we_lat(comp_mode, input_params, net_struct, quant=16):
    if input_params[3] != 1:
        raise Exception('input channel & corresponding tiling needs to be set as one for dw conv')
    if comp_mode == 1:
        return input_params[2] * input_params[3] * net_struct[3] * (quant / 16)
    else:
        return math.ceil(input_params[2] * input_params[3] * net_struct[3] * net_struct[3] / max(min(4, input_params[6]), 2)) * (quant / 16)

# Construct valid arguments
# comp_mode: integer, either 1 or other value
# input_params: list/tuple with at least 7 elements
#   - input_params[2]: some numeric value (used in multiplication)
#   - input_params[3]: must be 1 (checked in condition)
#   - input_params[6]: numeric value (used in min/max operations)
# net_struct: list/tuple with at least 4 elements
#   - net_struct[3]: numeric value (used in multiplication)
# quant: numeric value, default 16

ARGS = {
    'comp_mode': 1,
    'input_params': [10, 20, 8, 1, 5, 6, 3],
    'net_struct': [2, 3, 4, 5],
    'quant': 16
}
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 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
dw_write_ofmap Ran
ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT)
RICE-EIC/Auto-NBA/model_search.py
code served (permissive licence) · get_code("6915888ee6046399")
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 math
import torch
import torch.nn as nn

# Analyze the function:
# - comp_mode: int (1 or other), used in if/else
# - input_params: list/tuple accessed by indices [0], [1], [2], [4], [6]
#   Needs at least 7 elements (indices 0-6)
#   Used in arithmetic operations (multiplication, division)
# - net_struct: not used in function body, can be any object
# - quant: int/float, default 16, used in division

# Create minimal valid arguments
torch.manual_seed(0)

# input_params needs at least 7 numeric elements
# Using distinct sizes: [10, 8, 12, 5, 4, 6, 3]
input_params = [10, 8, 12, 5, 4, 6, 3]

# comp_mode: choose 1 to execute first branch
comp_mode = 1

# net_struct: not used, can be empty dict or minimal object
net_struct = {}

# quant: numeric value for quantization bits
quant = 16

ARGS = {
    "comp_mode": comp_mode,
    "input_params": input_params,
    "net_struct": net_struct,
    "quant": quant
}
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
generate_params Ran
ran; our contract draft was wrong, not the code
RICE-EIC/Auto-NBA/model_search.py
code served (permissive licence) · get_code("1bab1f2c8a46c6fe")
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. 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.autograd import Variable

torch.manual_seed(0)

# Define the space dictionaries with the required keys
# Each space needs: comp_mode, trbuff, tcbuff, tmbuff, tnbuff, tr, tc, tm, tn
acc1_space = {
    'comp_mode': [1, 2, 3],
    'trbuff': [4, 5],
    'tcbuff': [6, 7, 8],
    'tmbuff': [9],
    'tnbuff': [10, 11],
    'tr': [12, 13, 14],
    'tc': [15],
    'tm': [16, 17],
    'tn': [18, 19, 20, 21]
}

acc2_space = {
    'comp_mode': [1, 2],
    'trbuff': [3, 4, 5],
    'tcbuff': [6],
    'tmbuff': [7, 8],
    'tnbuff': [9, 10, 11],
    'tr': [12],
    'tc': [13, 14],
    'tm': [15, 16, 17],
    'tn': [18]
}

dw_acc1_space = {
    'comp_mode': [1],
    'trbuff': [2, 3],
    'tcbuff': [4, 5, 6],
    'tmbuff': [7, 8, 9],
    'tnbuff': [10],
    'tr': [11, 12],
    'tc': [13, 14, 15],
    'tm': [16],
    'tn': [17, 18]
}

dw_acc2_space = {
    'comp_mode': [1, 2, 3, 4],
    'trbuff': [5],
    'tcbuff': [6, 7],
    'tmbuff': [8, 9, 10],
    'tnbuff': [11, 12],
    'tr': [13],
    'tc': [14, 15],
    'tm': [16, 17, 18],
    'tn': [19]
}

# Define quant_options list
quant_options = ['option1', 'option2']

ARGS = {
    'acc1_space': acc1_space,
    'acc2_space': acc2_space,
    'dw_acc1_space': dw_acc1_space,
    'dw_acc2_space': dw_acc2_space,
    'quant_options': quant_options
}
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 — 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
gumbel_softmax Ran
ran; our contract draft was wrong, not the code
RICE-EIC/Auto-NBA/model_search.py
code served (permissive licence) · get_code("1824fbfcfee2e185")
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; 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.functional as F

torch.manual_seed(0)

# Create a small logits tensor
# Shape: [batch_size=2, n_class=4]
logits = torch.randn(2, 4)

ARGS = {
    "logits": logits,
    "temperature": 1.0,
    "hard": False,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type Tensor, ndim 2, dtype family float — no output shape is stated: observe_signature.py could not observe it (call:AssertionError)
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
gumbel_softmax_sample Ran
ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT)
this paper's copy was not recorded; identical code first harvested from gatech-eic/nasa
pointer only; the stored copy get_code serves, from gatech-eic/nasa, is pointer only (licence: NONE) · get_code("0d41bbe52278fde1")
How it ran

The body of this sample is withheld: this paper's copy of the code was not recorded (its link names no repository or source path), so no licence was read for it. The setup block that called it is withheld with it, because it is written against that body. source_path and origin say where the code lives, to read under the repository's own terms. A run is recorded.

random_sample Ran
ran, honoured the contract we drafted
RICE-EIC/Auto-NBA/model_search.py
code served (permissive licence) · get_code("40eb5ef310a13593")
How it ran

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

import numpy as np

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

# Construct input_dict with required keys and list values
# The function expects keys like 'comp_mode', 'tr', 'tc', 'tm', 'tn' and others
# For keys 'tr', 'tc', 'tm', 'tn', the function samples and checks against a 'buff' key
input_dict = {
    'comp_mode': [1, 2, 3],
    'trbuff': [100],  # buffer for 'tr' comparisons
    'tcbuff': [100],  # buffer for 'tc' comparisons
    'tmbuff': [100],  # buffer for 'tm' comparisons
    'tnbuff': [100],  # buffer for 'tn' comparisons
    'tr': [10, 20, 30],
    'tc': [5, 15, 25],
    'tm': [8, 12, 16],
    'tn': [2, 4, 6],
    'other_param': [42, 100, 200],
}

# However, the function checks for keys like key+'buff' which would be 'trbuff', 'tcbuff', etc.
# We need to restructure to match what the function expects
input_dict = {
    'comp_mode': [1, 2, 3],
    'trbuff': [100],
    'tcbuff': [100],
    'tmbuff': [100],
    'tnbuff': [100],
    'tr': [10, 20, 30],
    'tc': [5, 15, 25],
    'tm': [8, 12, 16],
    'tn': [2, 4, 6],
}

ARGS = {
    'input_dict': input_dict,
    'fix_comp_mode': False,
}
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 int — a list output has no array shape of its own; none is stated
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
read_if_lat Ran
ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT)
RICE-EIC/Auto-NBA/model_search.py
code served (permissive licence) · get_code("2cf026e1cb51cdf0")
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 math

torch = None  # Not needed for this function

# Analyze the function:
# - comp_mode: compared with 2 (integer)
# - input_params: indexed at [0], [1], [3], [4], [5], [7] (list/tuple of at least 8 numeric elements)
# - net_struct: indexed at [3] (list/tuple with at least 4 elements)
# - quant: numeric, default 16

# Construct input_params with 8 elements (indices 0-7 used)
input_params = [
    10,   # [0]: tri comparison value
    20,   # [1]: tci comparison value
    30,   # [2]: unused
    100,  # [3]: multiplier in calculation
    5,    # [4]: added to net_struct[3]
    6,    # [5]: added to net_struct[3]
    40,   # [6]: unused
    3,    # [7]: used in else branch for min()
]

# Construct net_struct with at least 4 elements (index [3] used)
net_struct = [1, 2, 3, 7]  # [3] = 7

# comp_mode: test with 2 (if branch) and other values (else branch)
comp_mode = 2

# quant: default is 16, test with different value
quant = 16

ARGS = {
    "comp_mode": comp_mode,
    "input_params": input_params,
    "net_struct": net_struct,
    "quant": quant,
}
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 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
read_we_lat Ran
ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT)
RICE-EIC/Auto-NBA/model_search.py
code served (permissive licence) · get_code("b678c5ea7942bb72")
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 math

torch.manual_seed(0)

# Analyzing the function:
# - comp_mode: used in comparison (== 2), should be an int
# - input_params: indexed with [2], [3], [6], so should be a list/tuple with at least 7 elements
# - net_struct: indexed with [3] (twice in else branch), so should be a list/tuple with at least 4 elements
# - quant: has default value 16, used in division, should be a number

# The function uses input_params indices: 2, 3, 6
# The function uses net_struct indices: 3
# Let's create reasonable values

comp_mode = 2  # Testing the if branch first

# input_params needs at least 7 elements (indices 0-6)
# Using distinct sizes to make dimensions clear
input_params = [
    10,   # index 0 (unused)
    20,   # index 1 (unused)
    5,    # index 2 (used in both branches)
    3,    # index 3 (used in both branches)
    100,  # index 4 (unused)
    200,  # index 5 (unused)
    2     # index 6 (used in else branch)
]

# net_struct needs at least 4 elements (indices 0-3)
net_struct = [
    7,    # index 0 (unused)
    8,    # index 1 (unused)
    9,    # index 2 (unused)
    4     # index 3 (used twice)
]

quant = 16

ARGS = {
    "comp_mode": comp_mode,
    "input_params": input_params,
    "net_struct": net_struct,
    "quant": quant
}
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
resource_consumption Ran
ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT)
RICE-EIC/Auto-NBA/model_search.py
code served (permissive licence) · get_code("377dd9a088043ca5")
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 math

# Analyzing the function:
# - comp_mode: integer (0, 1, or 2)
# - input_params: list/tuple of at least 8 numeric values (indexed 0-7)
# - net_struct: list/tuple of at least 4 elements (indexed 0-3)
# - dw: boolean
# - quant: integer (default 16)

# The function accesses:
# input_params[0], [1], [2], [3], [4], [5], [6], [7]
# net_struct[3]

# Create reasonable test data
comp_mode = 0
input_params = [
    64,      # [0] - output height dimension
    64,      # [1] - output width dimension
    128,     # [2] - output channels
    32,      # [3] - input channels
    8,       # [4] - tile height
    8,       # [5] - tile width
    16,      # [6] - parallelism factor
    4,       # [7] - another parallelism/banking factor
]
net_struct = [
    1,       # [0] - unused in this function
    1,       # [1] - unused in this function
    1,       # [2] - unused in this function
    3,       # [3] - kernel size
]
dw = False
quant = 16

ARGS = {
    "comp_mode": comp_mode,
    "input_params": input_params,
    "net_struct": net_struct,
    "dw": dw,
    "quant": quant,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
none outside the standard library — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type tuple, ndim 1, dtype family float — a tuple output has no array shape of its own; none is stated
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
sample_gumbel Ran
ran; our contract draft was wrong, not the code
this paper's copy was not recorded; identical code first harvested from gatech-eic/nasa
pointer only; the stored copy get_code serves, from gatech-eic/nasa, is pointer only (licence: NONE) · get_code("7c913c414af7196f")
How it ran

The body of this sample is withheld: this paper's copy of the code was not recorded (its link names no repository or source path), so no licence was read for it. The setup block that called it is withheld with it, because it is written against that body. source_path and origin say where the code lives, to read under the repository's own terms. A run is recorded.

write_ofmap Ran
ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT)
RICE-EIC/Auto-NBA/model_search.py
code served (permissive licence) · get_code("082bac1336b391d0")
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 math

# Analyze the function:
# - comp_mode: integer (2 or other value) used in if/else
# - input_params: list/tuple with at least 7 elements (indices 0-6 accessed)
#   - input_params[0], [1], [2]: dimensions (multiply/divide operations)
#   - input_params[4]: used in comp_mode==2 branch
#   - input_params[6]: used in else branch
# - net_struct: passed but never used in the function body
# - quant: integer with default 16, used in final multiplication

# Build minimal valid arguments
comp_mode = 2

# input_params needs at least 7 elements
# Using distinct values to make dimensions unambiguous
input_params = [8, 4, 16, 2, 2, 3, 3]
# [0]=8, [1]=4, [2]=16, [4]=2, [6]=3 are the accessed indices

# net_struct is never used, so a simple placeholder
net_struct = None

# quant with a non-default value to test the scaling
quant = 32

ARGS = {
    "comp_mode": comp_mode,
    "input_params": input_params,
    "net_struct": net_struct,
    "quant": quant,
}
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 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
FBNet Not yet run
unverified (harvested, no recorded run)
RICE-EIC/Auto-NBA/model_search.py
code served (permissive licence) · get_code("7809544871a9fe0b")
How it ran

no invocation recorded.

MixedOp Not yet run
unverified (harvested, no recorded run)
RICE-EIC/Auto-NBA/model_search.py
code served (permissive licence) · get_code("7e63cdc000697a3c")
How it ran

no invocation recorded.

capsuled_predictor Not yet run
unverified (harvested, no recorded run)
RICE-EIC/Auto-NBA/model_search.py
code served (permissive licence) · get_code("83866a815206c036")
How it ran

no invocation recorded.

cifar_convert_to_layers Not yet run
unverified (harvested, no recorded run)
RICE-EIC/Auto-NBA/model_search.py
code served (permissive licence) · get_code("9e23744959c78f65")
How it ran

no invocation recorded.

evaluate_latency Not yet run
unverified (harvested, no recorded run)
RICE-EIC/Auto-NBA/model_search.py
code served (permissive licence) · get_code("bdf35073bdcf40de")
How it ran

no invocation recorded.

search_for_best_latency Not yet run
unverified (harvested, no recorded run)
RICE-EIC/Auto-NBA/model_search.py
code served (permissive licence) · get_code("bd71a08555ee6e6c")
How it ran

no invocation recorded.

sys_consumption Not yet run
unverified (harvested, no recorded run)
RICE-EIC/Auto-NBA/model_search.py
code served (permissive licence) · get_code("cf3df44ac78c9623")
How it ran

no invocation recorded.

sys_latency Not yet run
unverified (harvested, no recorded run)
RICE-EIC/Auto-NBA/model_search.py
code served (permissive licence) · get_code("f871981fcbaf0534")
How it ran

no invocation recorded.

Also present in other papers' code

Of 26 samples lifted from this paper's linked repositories, 26 carry a function identity and 0 do not. Of the 26 distinct functions with an identity, 3 are also present in other papers whose code we hold (2 with at least one paper dated earlier, 1 the same month, 3 later) and 23 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
sample_gumbel
brick of this paper's assembly: sampler
7 other papers
2 dated earlier, 1 the same month, 3 later, 1 same year, order not determinable
1912.10917 (2019-12)
FasterSeg: Searching for Faster Real-time Semantic Segmentation
2008.11062 (2020-08)
GAN Slimming: All-in-One GAN Compression by A Unified Optimization Framework
Fu_SACoD_Sensor_Algorithm_Co-Design_Towards_Efficient_CNN-Powered_Intelligent_PhlatCam_ICCV_2021_paper (2021 (year only))
SACoD: Sensor Algorithm Co-Design Towards Efficient CNN-powered Intelligent PhlatCam
and 4 more not named here
gumbel_softmax_sample
brick of this paper's assembly: helper
5 other papers
2 dated earlier, 2 later, 1 same year, order not determinable
1912.10917 (2019-12)
FasterSeg: Searching for Faster Real-time Semantic Segmentation
2008.11062 (2020-08)
GAN Slimming: All-in-One GAN Compression by A Unified Optimization Framework
Fu_SACoD_Sensor_Algorithm_Co-Design_Towards_Efficient_CNN-Powered_Intelligent_PhlatCam_ICCV_2021_paper (2021 (year only))
SACoD: Sensor Algorithm Co-Design Towards Efficient CNN-powered Intelligent PhlatCam
and 2 more not named here
gumbel_softmax
brick of this paper's assembly: sampler
1 other paper
1 later
2210.13361 (2022-10)
NASA: Neural Architecture Search and Acceleration for Hardware Inspired Hybrid 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

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

Abstract

While maximizing deep neural networks' (DNNs') acceleration efficiency requires a joint search/design of three different yet highly coupled aspects, including the networks, bitwidths, and accelerators, the challenges associated with such a joint search have not yet been fully understood and addressed. The key challenges include (1) the dilemma of whether to explode the memory consumption due to the huge joint space or achieve sub-optimal designs, (2) the discrete nature of the accelerator design space that is coupled yet different from that of the networks and bitwidths, and (3) the chicken and egg problem associated with network-accelerator co-search, i.e., co-search requires operation-wise hardware cost, which is lacking during search as the optimal accelerator depending on the whole network is still unknown during search. To tackle these daunting challenges towards optimal and fast development of DNN accelerators, we propose a framework dubbed Auto-NBA to enable jointly searching for the Networks, Bitwidths, and Accelerators, by efficiently localizing the optimal design within the huge joint design space for each target dataset and acceleration specification. Our Auto-NBA integrates a heterogeneous sampling strategy to achieve unbiased search with constant memory consumption, and a novel joint-search pipeline equipped with a generic differentiable accelerator search engine. Extensive experiments and ablation studies validate that both Auto-NBA generated networks and accelerators consistently outperform state-of-the-art designs (including co-search/exploration techniques, hardwareaware NAS methods, and DNN accelerators), in terms of search time, task accuracy, and

For agents

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

get_harvested_code_for_paper("2106.06575")
get_code_for_paper("2106.06575")
have("2106.06575")

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

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

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

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

Connect an agent — have() is free.