SYNTOLOGY HomeExplorerAtlasCodeMethodologyAboutDevelopersFeedPricing
Paper · 1805.09501 · 2018

AutoAugment: Learning Augmentation Policies from Data

arXiv · PDF · Open in the Atlas

Code that ran

25 of 43 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, 2 violated it and 15 have no contract verdict; 7 failures of our instrument; 18 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/1805.09501.json · badge: /api/ran/1805.09501.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
2han9x1a0release/RLCC community (classifier label)
classifier basis not recorded on the link
9 ran · 12 no recorded run
YaCpotato/deepaugmentFix community (classifier label)
classifier basis not recorded on the link
5 ran · 0 no recorded run
abcp4/DAPytorch community (classifier label)
classifier basis not recorded on the link
3 ran · 4 no recorded run
TillBeemelmanns/auto-augment-tf2-operations community (classifier label)
classifier basis not recorded on the link
3 ran · 0 no recorded run
4uiiurz1/pytorch-auto-augment reimplementation (classifier label)
classifier basis: classifier_2025
2 ran · 1 no recorded run
barisozmen/deepaugment reimplementation (classifier label)
classifier basis: classifier_2025
2 ran · 0 no recorded run
junkwhinger/fastautoaugment_jsh reimplementation (classifier label)
classifier basis: classifier_2025
1 ran · 1 no recorded run
FunctionStatusWhere it lives
build_optimizer Ran
ran on a synthesized input
2han9x1a0release/RLCC/openunreid/core/solvers/optim.py
code served (permissive licence) · get_code("d7b9dce3fe1c3682")
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 Adam. 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 simple model with named children
class SimpleModel(nn.Module):
    def __init__(self):
        super().__init__()
        self.backbone = nn.Linear(4, 8)
        self.classifier = nn.Linear(8, 3)
    
    def forward(self, x):
        x = self.backbone(x)
        x = self.classifier(x)
        return x

model = SimpleModel()

ARGS = {
    'models': model,
    'optim': 'adam',
    'lr': 0.00035,
    'weight_decay': 0.0005,
    'momentum': 0.9,
    'sgd_dampening': 0,
    'sgd_nesterov': False,
    'rmsprop_alpha': 0.99,
    'adam_beta1': 0.9,
    'adam_beta2': 0.999,
    'staged_lr': False,
    'new_layers': '',
    'base_lr_mult': 0.1,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type Adam — a Adam output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a Adam 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_jaccard_distance Ran
ran on a synthesized input
2han9x1a0release/RLCC/openunreid/core/utils/compute_dist.py
code served (permissive licence) · get_code("90ac063c815a1d9d")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned ndarray, ndim 2, dtype family float; 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 numpy as np

torch.manual_seed(0)

# Create small feature tensor (N=2, feature_dim=4)
features = torch.randn(2, 4, dtype=torch.float32)

# Define stub functions for faiss operations that will be called
# Since we're CPU-only, we need to mock these or use search_option >= 3
def search_raw_array_pytorch(res, x, y, k):
    # Mock: return distances and indices
    N = x.size(0)
    indices = torch.arange(N).unsqueeze(0).repeat(N, 1)
    distances = torch.zeros(N, N)
    return distances, indices

def search_index_pytorch(index, x, k):
    # Mock: return distances and indices
    N = x.size(0)
    indices = torch.arange(N).unsqueeze(0).repeat(N, 1)
    distances = torch.zeros(N, N)
    return distances, indices

def index_init_gpu(ngpus, dim):
    # Mock index
    class MockIndex:
        def add(self, x):
            pass
        def search(self, x, k):
            N = x.shape[0]
            return np.zeros((N, k)), np.arange(N).reshape(N, 1).repeat(k, axis=1)
    return MockIndex()

def index_init_cpu(dim):
    # Mock CPU index
    class MockIndex:
        def add(self, x):
            pass
        def search(self, x, k):
            N = x.shape[0]
            return np.zeros((N, k)), np.arange(N).reshape(N, 1).repeat(k, axis=1)
    return MockIndex()

# Inject mock functions into the module namespace so compute_jaccard_distance can find them
import sys
current_module = sys.modules[__name__]
setattr(current_module, 'search_raw_array_pytorch', search_raw_array_pytorch)
setattr(current_module, 'search_index_pytorch', search_index_pytorch)
setattr(current_module, 'index_init_gpu', index_init_gpu)
setattr(current_module, 'index_init_cpu', index_init_cpu)

ARGS = {
    'features': features,
    'k1': 1,
    'k2': 1,
    'search_option': 3,
    'fp16': False,
    'verbose': False
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
faiss, numpy, torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type ndarray, ndim 2, dtype family float — no output shape is stated: observe_signature.py could not observe it (fixture:KeyError)
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
conv_norm_lrelu Ran
ran on a synthesized input
2han9x1a0release/RLCC/openunreid/models/backbones/discriminator.py
code served (permissive licence) · get_code("82f35d7c062474b2")
How it ran

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

import torch
import torch.nn as nn
import functools

torch.manual_seed(0)

ARGS = {
    'in_dim': 3,
    'out_dim': 64,
    'kernel_size': 3,
    'stride': 1,
    'padding': 1,
    'norm': functools.partial(nn.InstanceNorm2d, affine=False),
    'relu': functools.partial(nn.LeakyReLU, negative_slope=0.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 Sequential — a Sequential output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a Sequential output the recorded ndim 1 and dtype family float describe that coercion, not the output, and are not stated
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
create_classifier Ran
ran on a synthesized input
TillBeemelmanns/auto-augment-tf2-operations/utils/classification_example.py
code served (permissive licence) · get_code("250ec7daec9a09f3")
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 Functional. 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 = {
    "input_shape": (32, 32, 3),
    "num_classes": 10
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
keras, tensorflow — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type Functional — a Functional output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a Functional 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
denormalize Ran
ran on a synthesized input
YaCpotato/deepaugmentFix/deepaugment/augmenter.py
code served (permissive licence) · get_code("92ae1c2343aa2f75")
How it ran

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

import torch
import numpy as np

torch.manual_seed(0)

# The function denormalize takes X and multiplies it by 255, then copies it
# X should be a numpy array or similar object with __mul__ and copy methods
# Creating a small normalized array (values between 0 and 1)
X = np.random.rand(2, 4).astype(np.float32)

ARGS = {
    "X": X
}
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 ndarray, ndim 2, dtype family float, shape (2, 4) — shape (2, 4) as a later run recorded it
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
eval_cuhk03 Ran
ran on a synthesized input
2han9x1a0release/RLCC/openunreid/core/metrics/rank.py
code served (permissive licence) · get_code("1e9f2436aa92ae9c")
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

np.random.seed(0)

# Create small synthetic data for person re-identification evaluation
num_queries = 2
num_gallery = 3
max_rank = 2

# Distance matrix: (num_queries, num_gallery)
# Smaller values = more similar
distmat = np.random.rand(num_queries, num_gallery).astype(np.float32)

# Query person IDs
q_pids = np.array([0, 1], dtype=np.int32)

# Gallery person IDs - ensure at least one match for each query
g_pids = np.array([0, 1, 0], dtype=np.int32)

# Query camera IDs
q_camids = np.array([0, 1], dtype=np.int32)

# Gallery camera IDs - make sure some are different from query cameras
# so that the remove logic (same pid AND same camid) filters correctly
g_camids = np.array([1, 0, 0], dtype=np.int32)

ARGS = {
    "distmat": distmat,
    "q_pids": q_pids,
    "g_pids": g_pids,
    "q_camids": q_camids,
    "g_camids": g_camids,
    "max_rank": max_rank,
}
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
eval_market1501 Ran
ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT)
2han9x1a0release/RLCC/openunreid/core/metrics/rank.py
code served (permissive licence) · get_code("a355d3e47a6679b6")
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

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

# Create test data for eval_market1501
# num_q = 2 queries, num_g = 3 gallery images
num_q = 2
num_g = 3

# Distance matrix: similarity/distance scores between queries and gallery
# Shape: (num_q, num_g)
distmat = np.array([
    [0.1, 0.5, 0.9],
    [0.2, 0.8, 0.3]
], dtype=np.float32)

# Query person IDs: which person identity each query belongs to
q_pids = np.array([0, 1], dtype=np.int32)

# Gallery person IDs: which person identity each gallery image belongs to
g_pids = np.array([0, 1, 0], dtype=np.int32)

# Query camera IDs: which camera captured each query
q_camids = np.array([0, 1], dtype=np.int32)

# Gallery camera IDs: which camera captured each gallery image
g_camids = np.array([0, 1, 2], dtype=np.int32)

# Maximum rank for CMC calculation
max_rank = 2

ARGS = {
    'distmat': distmat,
    'q_pids': q_pids,
    'g_pids': g_pids,
    'q_camids': q_camids,
    'g_camids': g_camids,
    'max_rank': max_rank
}
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
evaluate_py Ran
ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT)
2han9x1a0release/RLCC/openunreid/core/metrics/rank.py
code served (permissive licence) · get_code("99f281b515b56572")
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

np.random.seed(0)

# Create a small distance matrix (4 queries x 5 gallery items)
# Distance matrix should be 2D array of floats
num_queries = 4
num_gallery = 5
distmat = np.random.rand(num_queries, num_gallery).astype(np.float32)

# Query person IDs (one per query image)
q_pids = np.array([0, 1, 0, 1], dtype=np.int32)

# Gallery person IDs (one per gallery image)
g_pids = np.array([0, 1, 2, 0, 1], dtype=np.int32)

# Query camera IDs (one per query image)
q_camids = np.array([0, 1, 1, 2], dtype=np.int32)

# Gallery camera IDs (one per gallery image)
g_camids = np.array([0, 1, 2, 2, 0], dtype=np.int32)

# Max rank for evaluation
max_rank = 3

# Use metric flag
use_metric_cuhk03 = True

ARGS = {
    'distmat': distmat,
    'q_pids': q_pids,
    'g_pids': g_pids,
    'q_camids': q_camids,
    'g_camids': g_camids,
    'max_rank': max_rank,
    'use_metric_cuhk03': use_metric_cuhk03
}
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
float_parameter Ran
ran on a synthesized input
TillBeemelmanns/auto-augment-tf2-operations/tfops_aug/augmentation_operations.py
code served (permissive licence) · get_code("02d4d29f63aa94f2")
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)

# Analyze the function:
# - level: int, used in arithmetic operations (level / 10)
# - maxval: float, used in multiplication
# - minval: float, used in multiplication and subtraction
# The function performs: maxval * (level / 10) + (10 - level) / 10 * minval

ARGS = {
    "level": 5,
    "maxval": 100.0,
    "minval": 10.0,
}
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
get_folder_path Ran
ran on a synthesized input
YaCpotato/deepaugmentFix/deepaugment/notebook.py
code served (permissive licence) · get_code("b02a7aace3f1f0f2")
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 str. 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)

ARGS = {
    'path': '/home/user/documents/file.txt'
}
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 str — a str output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a str 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_logger Ran
ran on a synthesized input
abcp4/DAPytorch/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
int_parameter Ran
ran on a synthesized input
TillBeemelmanns/auto-augment-tf2-operations/tfops_aug/augmentation_operations.py
code served (permissive licence) · get_code("d9e70dca8d829825")
How it ran

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

import torch
import numpy as np

torch.manual_seed(0)

# Analyze the function:
# - level: int, used in arithmetic (level / 10)
# - maxval: int, used in arithmetic (maxval * (level / 10))
# - minval: int, used in arithmetic ((10 - level) / 10 * minval)
# All parameters are simple integers used in basic arithmetic operations

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

import numpy as np

# Create a small initial_rank matrix
# The function indexes into this with [i, :k1+1] and [forward_k_neigh_index, :k1+1]
# So we need enough rows and columns
initial_rank = np.array([
    [0, 1, 2, 3, 4],
    [1, 0, 3, 2, 4],
    [2, 3, 0, 1, 4],
    [3, 2, 1, 0, 4],
    [4, 0, 1, 2, 3]
], dtype=np.int64)

# i is an index into the first dimension of initial_rank
i = 0

# k1 is used to slice the rank matrix up to k1+1
k1 = 2

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

import torch
import numpy as np

torch.manual_seed(0)

# The function normalize takes X and divides it by 255.0, then copies it
# X should be a numpy array or similar numeric container since it's divided by 255.0
# This suggests image data in 0-255 range
X = np.array([
    [[100, 150, 200, 50],
     [75, 125, 175, 225]],
    [[10, 20, 30, 40],
     [255, 200, 100, 50]]
], dtype=np.float32)

ARGS = {
    "X": X
}
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 ndarray, ndim 3, dtype family float, shape (2, 2, 4) — shape (2, 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
numpy_to_pil Ran
ran, violated the contract we drafted
barisozmen/deepaugment/src/deepaugment/augment.py
code served (permissive licence) · get_code("2c98f33a195f457b")
How it ran

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

import numpy as np

# Create a small numpy array representing an image (height=3, width=4, channels=3 for RGB)
image_array = np.random.randint(0, 256, size=(3, 4, 3), dtype=np.uint8)

ARGS = {
    "image": image_array
}
Setup block drafted by
a language model, Claude Sonnet 4.5, prompt python_fixture_v1
Imports
PIL, numpy — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type Image — a Image output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a Image output the recorded ndim 3 and dtype family int describe that coercion, not the output, and are not stated
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
param_size Ran
ran, honoured the contract we drafted
abcp4/DAPytorch/utils.py
pointer only (licence: MIT); the stored copy get_code serves, from harveyp123/maxk-gnn, is pointer only (licence: NONE) · get_code("e743627634484e6d")
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.

parse Ran
ran on a synthesized input
abcp4/DAPytorch/genotypes.py
code served (permissive licence) · get_code("ae11f865c7d70581")
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 3, dtype family float; no output shape is stated. The image it ran in was not recorded. If your copy returns the same type and ndim on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch

torch.manual_seed(0)

# alpha is a ParameterList where each element is a Parameter of shape (n_edges, n_ops)
# n_edges is the number of edges for a node
# n_ops is the number of operations (len(PRIMITIVES) = 8)
# The function iterates over alpha and processes each edge tensor

# Create a small ParameterList with 2 nodes
# Each node has 3 edges and 8 operations (7 real ops + 1 'none')
alpha = torch.nn.ParameterList([
    torch.nn.Parameter(torch.randn(3, 8)),  # First node: 3 edges, 8 ops
    torch.nn.Parameter(torch.randn(3, 8)),  # Second node: 3 edges, 8 ops
])

# k is the number of top edges to select per node
k = 2

ARGS = {
    'alpha': alpha,
    'k': k,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type list, ndim 3, 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
pil_to_numpy Ran
ran, violated the contract we drafted
barisozmen/deepaugment/src/deepaugment/augment.py
code served (permissive licence) · get_code("702d7cf93651bbf8")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Sonnet 4.5, prompt python_fixture_v1) and returned ndarray, ndim 3, dtype family int, shape (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.

from PIL import Image
import numpy as np

# Create a small PIL Image
pil_image = Image.new('RGB', (3, 4), color=(255, 128, 0))

ARGS = {
    'image': pil_image
}
Setup block drafted by
a language model, Claude Sonnet 4.5, prompt python_fixture_v1
Imports
PIL, numpy — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type ndarray, ndim 3, dtype family int, shape (4, 3, 3) — shape (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: none by the harness; any seed is in the setup block
random_flip Ran
ran on a synthesized input
YaCpotato/deepaugmentFix/deepaugment/image_generator.py
code served (permissive licence) · get_code("6e1198a9c8c47438")
How it ran

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

import numpy as np

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

# Create a small 2D array to use as input
# Using shape (2, 4) - batch of 2, width of 4
x = np.random.rand(2, 4)

ARGS = {
    "x": x
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type ndarray, ndim 2, dtype family float, shape (2, 4) — shape (2, 4) as a later run recorded it
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
re_ranking_cpu Ran
ran on a synthesized input
2han9x1a0release/RLCC/openunreid/core/utils/rerank.py
code served (permissive licence) · get_code("7aa201aa3874fe38")
How it ran

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

import numpy as np

# Construct valid arguments for re_ranking_cpu
# The function expects:
# - q_g_dist: query-gallery distance matrix (num_queries x num_galleries)
# - q_q_dist: query-query distance matrix (num_queries x num_queries)
# - g_g_dist: gallery-gallery distance matrix (num_galleries x num_galleries)
# - k1, k2, lambda_value: hyperparameters

num_queries = 2
num_galleries = 3

# Create small distance matrices
q_g_dist = np.random.rand(num_queries, num_galleries).astype(np.float32)
q_q_dist = np.random.rand(num_queries, num_queries).astype(np.float32)
g_g_dist = np.random.rand(num_galleries, num_galleries).astype(np.float32)

# Ensure distance matrices are symmetric where appropriate
q_q_dist = (q_q_dist + q_q_dist.T) / 2.0
g_g_dist = (g_g_dist + g_g_dist.T) / 2.0

ARGS = {
    "q_g_dist": q_g_dist,
    "q_q_dist": q_q_dist,
    "g_g_dist": g_g_dist,
    "k1": 2,
    "k2": 1,
    "lambda_value": 0.3
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type ndarray, ndim 2, dtype family float, shape (2, 3) — shape (2, 3) as a later run recorded it
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
shear_x Ran
ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT)
4uiiurz1/pytorch-auto-augment/auto_augment.py
code served (permissive licence) · get_code("53613a740588d619")
How it ran

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

import random
import numpy as np
from scipy import ndimage
from PIL import Image, ImageEnhance, ImageOps

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

# Create a small PIL Image with RGB channels
# Using a small image size (e.g., 8x6 pixels) with 3 color channels
img_array = np.random.randint(0, 256, size=(8, 6, 3), dtype=np.uint8)
img = Image.fromarray(img_array, mode='RGB')

# magnitude should be an integer in range [0, 9] based on the magnitudes array indexing
# (magnitude and magnitude+1 are used as indices into an 11-element array)
magnitude = 5

ARGS = {
    'img': img,
    'magnitude': magnitude
}
Setup block drafted by
a language model, Claude Sonnet 4.5, prompt python_fixture_v1
Imports
PIL, numpy, scipy — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type Image — a Image output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a Image output the recorded ndim 3 and dtype family int describe that coercion, not the output, and are not stated
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
split_dataset_train Ran
ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT)
junkwhinger/fastautoaugment_jsh/search_fastautoaugment.py
pointer only (licence: NONE) · get_code("f8a38db0674e2431")
How it ran

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

swig_ptr_from_FloatTensor Ran
ran; our contract draft was wrong, not the code
2han9x1a0release/RLCC/openunreid/core/utils/faiss_utils.py
code served (permissive licence) · get_code("f295b8050ce2a4f1")
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 SwigPyObject. 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 faiss

torch.manual_seed(0)

# Create a small contiguous float32 tensor
x = torch.randn(2, 4, dtype=torch.float32).contiguous()

ARGS = {
    'x': x
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
faiss, torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type SwigPyObject — a SwigPyObject output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a SwigPyObject 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
transform_matrix_offset_center Ran
ran; our contract draft was wrong, not the code
4uiiurz1/pytorch-auto-augment/auto_augment.py
code served (permissive licence) · get_code("3e773c6c5bc796d4")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Sonnet 4.5, prompt python_fixture_v1) and returned ndarray, ndim 2, dtype family float, shape (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 numpy as np

# Create a 3x3 transformation matrix (e.g., a rotation matrix)
matrix = np.array([[0.866, -0.5, 0],
                   [0.5, 0.866, 0],
                   [0, 0, 1]])

# Image dimensions
x = 224
y = 160

ARGS = {
    'matrix': matrix,
    'x': x,
    'y': y
}
Setup block drafted by
a language model, Claude Sonnet 4.5, prompt python_fixture_v1
Imports
numpy — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type ndarray, ndim 2, dtype family float, shape (3, 3) — shape (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: none by the harness; any seed is in the setup block
zero_pad_and_crop Ran
ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT)
YaCpotato/deepaugmentFix/deepaugment/image_generator.py
code served (permissive licence) · get_code("0f4de8752a1072ea")
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 3, dtype family float, shape (5, 7, 3) as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import numpy as np

# Create a small test image with shape (height, width, channels)
# Using distinct dimensions: 5x7x3 for height x width x channels
img = np.random.rand(5, 7, 3).astype(np.float32)

# Define arguments for zero_pad_and_crop
ARGS = {
    "img": img,
    "amount": 4
}
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 3, dtype family float, shape (5, 7, 3) — shape (5, 7, 3) as a later run recorded it
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
accuracy Not yet run
unverified (harvested, no recorded run)
2han9x1a0release/RLCC/openunreid/core/metrics/accuracy.py
code served (permissive licence) · get_code("6567404952193dea")
How it ran

no invocation recorded.

apply_policy Not yet run
unverified (harvested, no recorded run)
4uiiurz1/pytorch-auto-augment/auto_augment.py
code served (permissive licence) · get_code("bdffd25e53ddbbaf")
How it ran

no invocation recorded.

broadcast_list Not yet run
unverified (harvested, no recorded run)
abcp4/DAPytorch/models/search_cnn.py
pointer only (licence: MIT); the stored copy get_code serves, from msight-tech/research-HDAS, is pointer only (licence: NOASSERTION) · get_code("fdfb2f691ca67d7f")
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 msight-tech/research-HDAS, 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. No invocation recorded.

build_dist Not yet run
unverified (harvested, no recorded run)
2han9x1a0release/RLCC/openunreid/core/utils/compute_dist.py
code served (permissive licence) · get_code("1ec9335c14b72b00")
How it ran

no invocation recorded.

build_gan_model Not yet run
unverified (harvested, no recorded run)
2han9x1a0release/RLCC/openunreid/models/builder.py
code served (permissive licence) · get_code("4b1b3ea8808ebb91")
How it ran

no invocation recorded.

build_lr_scheduler Not yet run
unverified (harvested, no recorded run)
2han9x1a0release/RLCC/openunreid/core/solvers/lr_scheduler.py
code served (permissive licence) · get_code("3db04fbfca62bfd0")
How it ran

no invocation recorded.

build_model Not yet run
unverified (harvested, no recorded run)
2han9x1a0release/RLCC/openunreid/models/builder.py
code served (permissive licence) · get_code("6e090295d64d8710")
How it ran

no invocation recorded.

compute_class_stablization_by_entropy Not yet run
unverified (harvested, no recorded run)
2han9x1a0release/RLCC/openunreid/core/label_generators/dbscan.py
code served (permissive licence) · get_code("0359516a2e2ae26c")
How it ran

no invocation recorded.

compute_inclass_distributiions Not yet run
unverified (harvested, no recorded run)
2han9x1a0release/RLCC/openunreid/core/label_generators/dbscan.py
code served (permissive licence) · get_code("02d028e6867abbb5")
How it ran

no invocation recorded.

compute_label_transform_matrix Not yet run
unverified (harvested, no recorded run)
2han9x1a0release/RLCC/openunreid/core/label_generators/dbscan.py
code served (permissive licence) · get_code("434ddd5d59a07613")
How it ran

no invocation recorded.

data_transforms Not yet run
unverified (harvested, no recorded run)
abcp4/DAPytorch/preproc.py
code served (permissive licence) · get_code("85ad5c4c61fbeaf5")
How it ran

no invocation recorded.

drop_path_ Not yet run
unverified (harvested, no recorded run)
abcp4/DAPytorch/models/ops.py
code served (permissive licence) · get_code("654a527a9f7f0bc9")
How it ran

no invocation recorded.

from_str Not yet run
unverified (harvested, no recorded run)
abcp4/DAPytorch/genotypes.py
code served (permissive licence) · get_code("240f9fa3a917804a")
How it ran

no invocation recorded.

generate_cv_sets Not yet run
unverified (harvested, no recorded run)
junkwhinger/fastautoaugment_jsh/search_fastautoaugment.py
pointer only (licence: NONE) · get_code("6f457a08830581a5")
How it ran

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

label_generator_kmeans Not yet run
unverified (harvested, no recorded run)
2han9x1a0release/RLCC/openunreid/core/label_generators/kmeans.py
code served (permissive licence) · get_code("7abb26d9e95eace9")
How it ran

no invocation recorded.

patchgan_3layers Not yet run
unverified (harvested, no recorded run)
2han9x1a0release/RLCC/openunreid/models/backbones/discriminator.py
code served (permissive licence) · get_code("6fe5cdb6dc4e08be")
How it ran

no invocation recorded.

search_index_pytorch Not yet run
unverified (harvested, no recorded run)
2han9x1a0release/RLCC/openunreid/core/utils/faiss_utils.py
code served (permissive licence) · get_code("78ca4879f13cc9d5")
How it ran

no invocation recorded.

swig_ptr_from_LongTensor Not yet run
unverified (harvested, no recorded run)
2han9x1a0release/RLCC/openunreid/core/utils/faiss_utils.py
code served (permissive licence) · get_code("892aeccb03c9a237")
How it ran

no invocation recorded.

Also present in other papers' code

Of 43 samples lifted from this paper's linked repositories, 43 carry a function identity and 0 do not. Of the 43 distinct functions with an identity, 21 are also present in other papers whose code we hold (3 with at least one paper dated earlier, 0 the same month, 19 later) and 22 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
apply_policy 6 other papers
6 later
1903.05285 (2019-03)
All You Need is a Few Shifts: Designing Efficient Convolutional Neural Networks for Image Classification
1908.09791 (2019-08)
Once-for-All: Train One Network and Specialize it for Efficient Deployment
1909.13719 (2019-09)
RandAugment: Practical automated data augmentation with a reduced search space
and 3 more not named here
transform_matrix_offset_center 6 other papers
6 later
1903.05285 (2019-03)
All You Need is a Few Shifts: Designing Efficient Convolutional Neural Networks for Image Classification
1908.09791 (2019-08)
Once-for-All: Train One Network and Specialize it for Efficient Deployment
1909.13719 (2019-09)
RandAugment: Practical automated data augmentation with a reduced search space
and 3 more not named here
k_reciprocal_neigh 5 other papers
1 dated earlier, 4 later
1804.01438 (2018-04)
Learning Discriminative Features with Multiple Granularities for Person Re-Identification
1811.07130 (2018-11)
Batch DropBlock Network for Person Re-identification and Beyond
1812.03282 (2018-12)
Spatial-Temporal Person Re-identification
and 2 more not named here
shear_x 5 other papers
5 later
1903.05285 (2019-03)
All You Need is a Few Shifts: Designing Efficient Convolutional Neural Networks for Image Classification
1908.09791 (2019-08)
Once-for-All: Train One Network and Specialize it for Efficient Deployment
2311.16450 (2023-11)
Typhoon Intensity Prediction with Vision Transformer
and 2 more not named here
swig_ptr_from_FloatTensor 4 other papers
4 later
1911.02116 (2019-11)
Unsupervised Cross-lingual Representation Learning at Scale
2004.10566 (2020-04)
Efficient Neighbourhood Consensus Networks via Submanifold Sparse Convolutions
aaai_19970 (2022 (year only))
SECRET: Self-Consistent Pseudo Label Refinement for Unsupervised Domain Adaptive Person Re-identification
and 1 more not named here
swig_ptr_from_LongTensor 4 other papers
4 later
1911.02116 (2019-11)
Unsupervised Cross-lingual Representation Learning at Scale
2004.10566 (2020-04)
Efficient Neighbourhood Consensus Networks via Submanifold Sparse Convolutions
aaai_19970 (2022 (year only))
SECRET: Self-Consistent Pseudo Label Refinement for Unsupervised Domain Adaptive Person Re-identification
and 1 more not named here
random_flip 3 other papers
3 later
1904.12848 (2019-04)
Unsupervised Data Augmentation for Consistency Training
1905.05393 (2019-05)
Population Based Augmentation: Efficient Learning of Augmentation Policy Schedules
2008.06775 (2020-08)
Model Patching: Closing the Subgroup Performance Gap with Data Augmentation
search_index_pytorch 3 other papers
3 later
2004.10566 (2020-04)
Efficient Neighbourhood Consensus Networks via Submanifold Sparse Convolutions
aaai_19970 (2022 (year only))
SECRET: Self-Consistent Pseudo Label Refinement for Unsupervised Domain Adaptive Person Re-identification
2204.09826 (2022-04)
SimMC: Simple Masked Contrastive Learning of Skeleton Representations for Unsupervised Person Re-Identification
zero_pad_and_crop 3 other papers
3 later
1904.12848 (2019-04)
Unsupervised Data Augmentation for Consistency Training
1905.05393 (2019-05)
Population Based Augmentation: Efficient Learning of Augmentation Policy Schedules
2008.06775 (2020-08)
Model Patching: Closing the Subgroup Performance Gap with Data Augmentation
broadcast_list 2 other papers
2 later
1806.09055 (2018-06)
DARTS: Differentiable Architecture Search
2101.04028 (2021-01)
Unchain the Search Space with Hierarchical Differentiable Architecture Search
drop_path_ 2 other papers
2 later
1806.09055 (2018-06)
DARTS: Differentiable Architecture Search
2001.01431 (2020-01)
Deeper Insights into Weight Sharing in Neural Architecture Search
eval_market1501 2 other papers
2 later
1905.13143 (2019-05)
Semantics-Aligned Representation Learning for Person Re-identification
1908.01114 (2019-08)
ABD-Net: Attentive but Diverse Person Re-Identification
evaluate_py 2 other papers
2 later
1905.13143 (2019-05)
Semantics-Aligned Representation Learning for Person Re-identification
1908.01114 (2019-08)
ABD-Net: Attentive but Diverse Person Re-Identification
from_str 2 other papers
2 later
1806.09055 (2018-06)
DARTS: Differentiable Architecture Search
2001.01431 (2020-01)
Deeper Insights into Weight Sharing in Neural Architecture Search
param_size 2 other papers
2 later
1806.09055 (2018-06)
DARTS: Differentiable Architecture Search
2312.08656 (2023-12)
MaxK-GNN: Extremely Fast GPU Kernel Design for Accelerating Graph Neural Networks Training
generate_cv_sets 1 other paper
1 later
1905.00397 (2019-05)
Fast AutoAugment
get_logger 1 other paper
1 later
1806.09055 (2018-06)
DARTS: Differentiable Architecture Search
numpy_to_pil 1 other paper
1 dated earlier
1708.04552 (2017-08)
Improved Regularization of Convolutional Neural Networks with Cutout
parse 1 other paper
1 later
1806.09055 (2018-06)
DARTS: Differentiable Architecture Search
pil_to_numpy 1 other paper
1 dated earlier
1708.04552 (2017-08)
Improved Regularization of Convolutional Neural Networks with Cutout

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

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

Repositories linked to this paper

More are linked than shown here.

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

Abstract

Data augmentation is an effective technique for improving the accuracy of modern image classifiers. However, current data augmentation implementations are manually designed. In this paper, we describe a simple procedure called AutoAugment to automatically search for improved data augmentation policies. In our implementation, we have designed a search space where a policy consists of many sub-policies, one of which is randomly chosen for each image in each mini-batch. A sub-policy consists of two operations, each operation being an image processing function such as translation, rotation, or shearing, and the probabilities and magnitudes with which the functions are applied. We use a search algorithm to find the best policy such that the neural network yields the highest validation accuracy on a target dataset. Our method achieves state-of-the-art accuracy on CIFAR-10, CIFAR-100, SVHN, and ImageNet (without additional data). On ImageNet, we attain a Top-1 accuracy of 83.5% which is 0.4% better than the previous record of 83.1%. On CIFAR-10, we achieve an error rate of 1.5%, which is 0.6% better than the previous state-of-the-art. Augmentation policies we find are transferable between datasets. The policy learned on ImageNet transfers well to achieve significant improvements on other datasets, such as Oxford Flowers, Caltech-101, Oxford-IIT Pets, FGVC Aircraft, and Stanford Cars.

For agents

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

get_harvested_code_for_paper("1805.09501")
get_code_for_paper("1805.09501")
have("1805.09501")

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

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

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

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

Connect an agent — have() is free.