SYNTOLOGY HomeExplorerAtlasCodeMethodologyAboutDevelopersFeedPricing
Paper · 1708.04552 · 2017

Improved Regularization of Convolutional Neural Networks with Cutout

Terrance Devries, Graham Taylor

arXiv · PDF · Open in the Atlas

Code that ran

21 of 24 samples (functions and classes) lifted from this paper's linked repositories executed on a synthesized input in Syntology's jail (3 of them constructed an object rather than computing a result; 3 honoured the contract we drafted, 3 violated it and 3 have no contract verdict; 12 failures of our instrument; 3 no recorded run), measured 2026-11-21; 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/1708.04552.json · badge: /api/ran/1708.04552.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
albumentations-team/albumentations community
Papers with Code archive
5 ran · 0 no recorded run
barisozmen/deepaugment community
Papers with Code archive
5 ran · 0 no recorded run
Ximilar-com/tf-image community
Papers with Code archive
4 ran · 1 no recorded run
YaCpotato/B4ResearchDeepaugment community
Papers with Code archive
2 ran · 0 no recorded run
lnstadrum/fastaugment community
Papers with Code archive
1 ran · 1 no recorded run
lewis-morris/image_augment community
Papers with Code archive
1 ran · 0 no recorded run
sour4bh/cifar-10 community
Papers with Code archive
1 ran · 0 no recorded run
changewOw/Cutout-numpy community
Papers with Code archive
1 ran · 0 no recorded run
PsorTheDoctor/microarray-data community
Papers with Code archive
1 ran · 0 no recorded run
mingsun-tse/good-da-in-kd community
Papers with Code archive
0 ran · 1 no recorded run
FunctionStatusWhere it lives
Augmentation Ran
ran on a synthesized input · constructed an object; no result was computed
lewis-morris/image_augment/ImageAugment/basic_augmentation.py
pointer only (licence: GPL-3.0) · get_code("65b19ebc3c066d46")
How it ran

The body of this sample is withheld: GPL-3.0, as GitHub detects it on this paper's repository, lewis-morris/image_augment, is not in the permissive set Syntology serves inline. The setup block that called it is withheld with it, because it is written against that body. source_path and origin say where the code lives, to read under the repository's own terms. A run is recorded.

Cutout Ran
ran on a synthesized input · constructed an object; no result was computed
sour4bh/cifar-10/cutout.py
pointer only (licence: NONE) · get_code("9712ea58142deac2")
How it ran

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

Cutout Ran
ran on a synthesized input · constructed an object; no result was computed
changewOw/Cutout-numpy/cutout.py
pointer only (licence: NONE) · get_code("e4f60cb273f96e43")
How it ran

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

_bboxes_to_absolute Ran
ran, honoured the contract we drafted
Ximilar-com/tf-image/tf_image/core/erase.py
code served (permissive licence) · get_code("c19f6a181aae4d15")
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 EagerTensor, 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 tensorflow as tf
import numpy as np

# Create a small image tensor (height=4, width=3)
image = tf.constant(np.random.rand(4, 3, 3).astype(np.float32))

# Create bboxes tensor with normalized coordinates (batch_size=2, 4 coordinates)
# Each bbox has [y_min, x_min, y_max, x_max] in normalized form [0, 1]
bboxes = tf.constant([[0.1, 0.2, 0.5, 0.6],
                      [0.3, 0.4, 0.7, 0.8]], dtype=tf.float32)

ARGS = {
    "image": image,
    "bboxes": bboxes
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy, tensorflow — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type EagerTensor, 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
_bboxes_to_relative Ran
ran, violated the contract we drafted
Ximilar-com/tf-image/tf_image/core/erase.py
code served (permissive licence) · get_code("909fa545052a99f8")
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 SymbolicTensor. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import tensorflow as tf
import numpy as np

# Create a small image tensor (height=4, width=3, channels=3)
image = tf.constant(np.random.randint(0, 256, (4, 3, 3), dtype=np.uint8), dtype=tf.float32)

# Create bounding boxes in absolute coordinates
# Shape: (2, 4) where each row is [y1, x1, y2, x2] in absolute pixel coordinates
bboxes = tf.constant([
    [1.0, 1.0, 3.0, 2.0],
    [0.5, 0.5, 2.5, 1.5]
], dtype=tf.float32)

ARGS = {
    "image": image,
    "bboxes": bboxes
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy, tensorflow — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type SymbolicTensor — a SymbolicTensor 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
_random_erasing Ran
ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT)
Ximilar-com/tf-image/tf_image/core/erase.py
code served (permissive licence) · get_code("8a71fb8f5184a010")
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 EagerTensor, ndim 4, dtype family float, shape (2, 8, 6, 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 tensorflow as tf
import numpy as np

# Set seed for reproducibility
tf.random.set_seed(0)

# Create a small test image: shape (batch, height, width, channels)
# Using distinct dimensions: batch=2, height=8, width=6, channels=3
image = tf.random.uniform((2, 8, 6, 3), dtype=tf.float32, minval=0, maxval=1)

# max_area: maximum area of the erasing region
max_area = 12

# erased_value: the value to fill the erased region with
erased_value = 0.5

ARGS = {
    "image": image,
    "max_area": max_area,
    "erased_value": erased_value,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy, tensorflow — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type EagerTensor, ndim 4, dtype family float, shape (2, 8, 6, 3) — shape (2, 8, 6, 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
apply_inpainting Ran
ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT)
albumentations-team/albumentations/albumentations/augmentations/dropout/functional.py
code served (permissive licence) · get_code("6ffc19e585a6e93e")
How it ran

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

# Create a small test image (grayscale, 10x10)
img = np.random.randint(0, 256, size=(10, 10, 3), dtype=np.uint8)

# Create holes as array of [x1, y1, x2, y2] coordinates
# Two small rectangular holes
holes = np.array([
    [2, 2, 4, 4],
    [6, 6, 8, 8]
], dtype=np.int32)

# Choose inpainting method
method = 'inpaint_telea'

ARGS = {
    'img': img,
    'holes': holes,
    'method': method
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1
Imports
albucore, cv2, 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 (10, 10, 3) — shape (10, 10, 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
apply_policy Ran
ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT)
barisozmen/deepaugment/src/deepaugment/transforms.py
code served (permissive licence) · get_code("725a089326cde6b7")
How it ran

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

# Create a small test image (32x32 RGB)
test_image = np.random.randint(0, 256, size=(32, 32, 3), dtype=np.uint8)

# Create a simple augmentation policy with various transforms and magnitudes
policy = [
    ('rotate', 0.5),
    ('flip_h', 0.7),
    ('brightness', 0.3),
    ('blur', 0.4),
    ('color_jitter', 0.2),
]

ARGS = {
    'image': test_image,
    'policy': policy,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1
Imports
PIL, numpy, torchvision — 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 (32, 32, 3) — shape (32, 32, 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
clamp Ran
ran, violated the contract we drafted
barisozmen/deepaugment/src/deepaugment/transforms.py
code served (permissive licence) · get_code("77de6eeb25f3b2cc")
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

# The function clamp takes:
# - x: a value or array to clamp
# - min_val: minimum bound (default 0.0)
# - max_val: maximum bound (default 1.0)
# 
# The function uses np.clip, so x should be a numpy array or scalar

# Create test data
x = np.array([[-0.5, 0.3, 0.8, 1.5],
              [2.0, -1.2, 0.5, 0.9]])

min_val = 0.0
max_val = 1.0

ARGS = {
    "x": x,
    "min_val": min_val,
    "max_val": max_val,
}
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
convert_type Ran
ran; our contract draft was wrong, not the code
Ximilar-com/tf-image/tf_image/core/erase.py
code served (permissive licence) · get_code("c632411042c122ec")
How it ran

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

import tensorflow as tf
import numpy as np

# Define a simple decorated function that convert_type will wrap
@tf.function
def simple_augmentation(image, bboxes):
    """A simple augmentation function that convert_type will decorate"""
    # Just return the inputs as-is for this test
    return image, bboxes

# Apply the decorator
def convert_type(function):
    """
    Often, we need the input image and bounding boxes to have a specific dtype and format.
    This decorator converts image (and bounding boxes) and provides it to decorated function.
    After teh function is done, reverse conversion is done to return the same format for a user of the function.

    Image formats are the standard one accepted by TensorFlow. For Bounding boxes, we use:
    - integer types for absolute coordinates or
    - float types for relative coordinates.

    Be careful, this decorator expects specific format of function parameters:
    - without bounding boxes: image, kwargs
    - with bouding boxes: image, bounding boxes, other args, kwargs

    :param function: function to be decorated, see the requirements in the description of the decorator!
    :return: decorated function
    """
    from functools import wraps

    @wraps(function)
    def wrap(image, *args, **kwargs):
        image_type = image.dtype
        image = tf.image.convert_image_dtype(image, tf.float32)
        if len(args) >= 1:
            bboxes = args[0]
            bboxes_type = bboxes.dtype
            bboxes_absolute = bboxes_type.is_integer
            bboxes = tf.cast(bboxes, tf.float32)
            bboxes = _bboxes_to_relative(image, bboxes) if bboxes_absolute else bboxes
            bboxes = tf.clip_by_value(bboxes, 0.0, 1.0)
            image, bboxes = function(image, bboxes, *args[1:], **kwargs)
            image = tf.clip_by_value(image, 0.0, 1.0)
            image = tf.image.convert_image_dtype(image, image_type, saturate=True)
            bboxes = tf.clip_by_value(bboxes, 0.0, 1.0)
            bboxes = _bboxes_to_absolute(image, bboxes) if bboxes_absolute else bboxes
            bboxes = tf.cast(bboxes, bboxes_type)
            return (image, bboxes)
        image = function(image, **kwargs)
        image = tf.clip_by_value(image, 0.0, 1.0)
        image = tf.image.convert_image_dtype(image, image_type, saturate=True)
        return image
    return wrap

@tf.function
def _bboxes_to_absolute(image, bboxes):
    image_height, image_width = (tf.shape(image)[0], tf.shape(image)[1])
    bboxes_update = tf.cast(tf.stack([image_height, image_width, image_height, image_width]), dtype=tf.float32)
    return bboxes * bboxes_update

@tf.function
def _bboxes_to_relative(image, bboxes):
    image_height, image_width = (tf.shape(image)[0], tf.shape(image)[1])
    bboxes_update = tf.cast(tf.stack([image_height, image_width, image_height, image_width]), dtype=tf.float32)
    return bboxes / bboxes_update

# Create test inputs
# Image: shape (4, 3, 3) - 4 height, 3 width, 3 channels, uint8 dtype
image = tf.constant(np.random.randint(0, 256, (4, 3, 3), dtype=np.uint8), dtype=tf.uint8)

# Bounding boxes: shape (2, 4) - 2 boxes, 4 coordinates (absolute, so int32)
# Coordinates are [y1, x1, y2, x2] in absolute pixel coordinates
bboxes = tf.constant([[1, 1, 3, 2], [0, 0, 2, 1]], dtype=tf.int32)

# The function parameter is the decorator itself
function = convert_type

ARGS = {
    "function": function
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy, tensorflow — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type function — a function output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a function output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not stated
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
create_cutout_mask Ran
ran; our contract draft was wrong, not the code
YaCpotato/B4ResearchDeepaugment/deepaugment/lib/cutout.py
code served (permissive licence) · get_code("9b004be093898ee9")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1) and returned 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)

# Define arguments for create_cutout_mask
ARGS = {
    "img_height": 32,
    "img_width": 32,
    "num_channels": 3,
    "size": 8
}
Setup block drafted by
a language model, Claude Haiku 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 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
cutout Ran
ran; our contract draft was wrong, not the code
PsorTheDoctor/microarray-data/utils/augmentation.py
pointer only (licence: NONE) · get_code("4a5f5e6272b139bf")
How it ran

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

cutout Ran
ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT)
albumentations-team/albumentations/albumentations/augmentations/dropout/functional.py
code served (permissive licence) · get_code("d912ce51776a4d78")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1) and returned 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.

import numpy as np

# Create a small test image (4x3 with 3 channels for BGR)
img = np.random.randint(0, 256, size=(4, 3, 3), dtype=np.uint8)

# Create holes array with [x1, y1, x2, y2] coordinates
# Single hole: from (1,1) to (2,2)
holes = np.array([[1, 1, 2, 2]], dtype=np.int32)

# Create a random generator
random_generator = np.random.default_rng(seed=42)

# Test with different fill values
fill_value = (128, 128, 128)  # tuple of floats for RGB channels

ARGS = {
    'img': img,
    'holes': holes,
    'fill': fill_value,
    'random_generator': random_generator,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1
Imports
albucore, cv2, 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
cutout_numpy Ran
ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT)
YaCpotato/B4ResearchDeepaugment/deepaugment/lib/cutout.py
code served (permissive licence) · get_code("b09aaca166fba057")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1) and returned ndarray, ndim 3, dtype family float, shape (32, 32, 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: 32x32 image with 3 channels
img_height = 32
img_width = 32
num_channels = 3

# Create a random numpy image with values in [0, 1]
np.random.seed(0)
img = np.random.rand(img_height, img_width, num_channels).astype(np.float32)

# Define cutout size
size = 16

ARGS = {
    "img": img,
    "size": size,
}
Setup block drafted by
a language model, Claude Haiku 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 3, dtype family float, shape (32, 32, 3) — shape (32, 32, 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
fill_holes_with_random Ran
ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT)
albumentations-team/albumentations/albumentations/augmentations/dropout/functional.py
code served (permissive licence) · get_code("8e25588616aec646")
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 int, shape (10, 8, 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 (3 channels, height=10, width=8)
img = np.random.randint(0, 256, size=(10, 8, 3), dtype=np.uint8)

# Define holes as list of [x_min, y_min, x_max, y_max] coordinates
holes = np.array([
    [1, 1, 3, 4],  # First hole
    [5, 2, 7, 5],  # Second hole
])

# Create a random generator
random_generator = np.random.default_rng(seed=42)

# uniform flag
uniform = False

ARGS = {
    "img": img,
    "holes": holes,
    "random_generator": random_generator,
    "uniform": uniform,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
albucore, 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 (10, 8, 3) — shape (10, 8, 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
fill_holes_with_value Ran
ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT)
albumentations-team/albumentations/albumentations/augmentations/dropout/functional.py
code served (permissive licence) · get_code("108e7feedea6f696")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1) and returned ndarray, ndim 3, dtype family int, shape (10, 8, 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 sample image (height=10, width=8, 3 channels for RGB)
img = np.ones((10, 8, 3), dtype=np.uint8) * 100

# Create holes as array of [x1, y1, x2, y2] coordinates
# Two holes: one from (1,1) to (3,3) and another from (5,2) to (7,5)
holes = np.array([
    [1, 1, 3, 3],
    [5, 2, 7, 5]
], dtype=np.int32)

# Fill value (e.g., black for RGB image)
fill = np.array([0, 0, 0], dtype=np.uint8)

ARGS = {
    "img": img,
    "holes": holes,
    "fill": fill
}
Setup block drafted by
a language model, Claude Haiku 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 3, dtype family int, shape (10, 8, 3) — shape (10, 8, 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
generate_random_fill Ran
ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT)
albumentations-team/albumentations/albumentations/augmentations/dropout/functional.py
code served (permissive licence) · get_code("2e63069222acc030")
How it ran

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

import numpy as np

# Create a random generator
random_generator = np.random.Generator(np.random.PCG64(seed=42))

# Define arguments for generate_random_fill
ARGS = {
    "dtype": np.dtype('uint8'),
    "shape": (4, 3),
    "random_generator": random_generator,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1
Imports
albucore, 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 int, shape (4, 3) — shape (4, 3) as a later run recorded it
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
listify Ran
ran, honoured the contract we drafted
lnstadrum/fastaugment/tensorflow/fast_augment.py
code served (permissive licence) · get_code("f66d6a0103a637b1")
How it ran

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

import torch
import numpy as np

torch.manual_seed(0)

# The function listify takes a single parameter 'it' and returns it as-is if it's
# a list or tuple, otherwise wraps it in a list.
# We need to test with different types of inputs.

# Test case 1: a scalar value
scalar_value = 42

# Test case 2: a list
list_value = [1, 2, 3, 4]

# Test case 3: a tuple
tuple_value = (5, 6, 7)

# Test case 4: a tensor
tensor_value = torch.randn(2, 4)

# Test case 5: a string
string_value = "hello"

# For the ARGS dict, we'll use one representative input
# The function works with any single argument, so we'll use a scalar
ARGS = {
    "it": 42
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1
Imports
numpy, torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type list, 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
make_transform Ran
ran; our contract draft was wrong, not the code
barisozmen/deepaugment/src/deepaugment/transforms.py
code served (permissive licence) · get_code("a88a0ebd4d7051a8")
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 RandomRotation. 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
from torchvision.transforms import v2 as T

torch.manual_seed(0)

# Define valid test arguments for make_transform function
ARGS = {
    'name': 'rotate',
    'magnitude': 0.5
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy, torch, torchvision — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type RandomRotation — a RandomRotation output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a RandomRotation 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
numpy_to_pil Ran
ran, honoured the contract we drafted
barisozmen/deepaugment/src/deepaugment/transforms.py
code served (permissive licence) · get_code("138b15df97d8f22d")
How it ran

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

import numpy as np
from PIL import Image

# Create a small numpy array with valid uint8 values (0-255)
# Using shape (4, 3) to have distinct dimensions
numpy_image = np.array([
    [255, 128, 64],
    [200, 100, 50],
    [150, 75, 25],
    [10, 5, 1]
], dtype=np.uint8)

ARGS = {
    "image": numpy_image
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
PIL, numpy — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type Image — a Image output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a Image output the recorded ndim 2 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
pil_to_numpy Ran
ran, violated the contract we drafted
barisozmen/deepaugment/src/deepaugment/transforms.py
code served (permissive licence) · get_code("88618f34ed54e2bc")
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 int, shape (3, 4, 3) as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import numpy as np
from PIL import Image

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

# Create a numpy array as alternative input
numpy_array = np.array([[1, 2, 3], [4, 5, 6]])

ARGS = {
    'image': pil_image
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
PIL, numpy — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type ndarray, ndim 3, dtype family int, shape (3, 4, 3) — shape (3, 4, 3) as a later run recorded it
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
augment Not yet run
unverified (harvested, no recorded run)
lnstadrum/fastaugment/tensorflow/fast_augment.py
code served (permissive licence) · get_code("57014965cf3804dc")
How it ran

no invocation recorded.

cutout Not yet run
unverified (harvested, no recorded run)
mingsun-tse/good-da-in-kd/helper/loops.py
pointer only (licence: NONE) · get_code("0972fd225cc9b653")
How it ran

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

random_erasing Not yet run
unverified (harvested, no recorded run)
Ximilar-com/tf-image/tf_image/core/erase.py
code served (permissive licence) · get_code("53b07796c4e8aaae")
How it ran

no invocation recorded.

Also present in other papers' code

Of 24 samples lifted from this paper's linked repositories, 24 carry a function identity and 0 do not. Of the 24 distinct functions with an identity, 3 are also present in other papers whose code we hold (0 with at least one paper dated earlier, 0 the same month, 3 later) and 21 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
create_cutout_mask
brick of this paper's assembly: helper
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
numpy_to_pil
brick of this paper's assembly: helper
1 other paper
1 later
1805.09501 (2018-05)
AutoAugment: Learning Augmentation Policies from Data
pil_to_numpy
brick of this paper's assembly: helper
1 other paper
1 later
1805.09501 (2018-05)
AutoAugment: Learning Augmentation Policies from Data

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-21.

Repositories linked to this paper

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

Abstract

Convolutional neural networks are capable of learning powerful representational spaces, which are necessary for tackling complex learning tasks. However, due to the model capacity required to capture such representations, they are often susceptible to overfitting and therefore require proper regularization in order to generalize well. In this paper, we show that the simple regularization technique of randomly masking out square regions of input during training, which we call cutout, can be used to improve the robustness and overall performance of convolutional neural networks. Not only is this method extremely easy to implement, but we also demonstrate that it can be used in conjunction with existing forms of data augmentation and other regularizers to further improve model performance. We evaluate this method by applying it to current state-of-the-art architectures on the CIFAR-10, CIFAR-100, and SVHN datasets, yielding new state-ofthe-art results of 2.56%, 15.20%, and 1.30% test error respectively. Code available at https://github.com/ uoguelph-mlrg/Cutout.

For agents

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

get_harvested_code_for_paper("1708.04552")
get_code_for_paper("1708.04552")
have("1708.04552")

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

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

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

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

Connect an agent — have() is free.