SYNTOLOGY HomeExplorerAtlasCodeMethodologyAboutDevelopersFeedPricing
Paper · 2003.08907 · NeurIPS · 2021

Overinterpretation reveals image classification model pathologies

Brandon Carter, Siddhartha Jain, Jonas Mueller, David Gifford

arXiv · PDF · Open in the Atlas

Code that ran

10 of 12 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; 2 honoured the contract we drafted, 0 violated it and 1 has no contract verdict; 7 failures of our instrument; 2 no recorded run), measured 2026-11-21; 3 contract verdicts on these samples were measured on the host before the contract probe was jailed (2026-09-18T14:29:13Z) or are undated; 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/2003.08907.json · badge: /api/ran/2003.08907.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
gifford-lab/overinterpretation canonical (classifier label)
classifier basis: classifier_2025
2 ran · 1 no recorded run
b-carter/overinterpretation community
Papers with Code archive
8 ran · 1 no recorded run
FunctionStatusWhere it lives
SISResult Ran
ran on a synthesized input
b-carter/overinterpretation/sufficient_input_subsets/sis.py
code served (permissive licence) · get_code("2b3638761f79af0a")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, class construct-then-call prompt, model not recorded) and returned bool, ndim 0, 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 collections
import numpy as np

class SISResult(collections.namedtuple('SISResult', ['sis', 'ordering_over_entire_backselect', 'values_over_entire_backselect', 'mask'])):
    """Specifies a single SIS identified by the find_sis procedure.

  Fields:
    sis: Array of idxs into the mask which define the sufficient input subset.
      These idxs describe the *unmasked positions* in the input. This array
      has shape (k x idx.shape), where k is the length of the SIS
      and idx is an idx into the mask. Note that in case of any ties between
      elements during backward selection, lower indices appear later in this
      array (see docstring for find_sis).
    ordering_over_entire_backselect: Array of shape (m x idx.shape), containing
      the order of idxs masked during backward selection while identifying this
      SIS, where 1 <= m <= d (and d is the max number of maskable positions).
      Later elements in this list were masked later during backward selection.
      If this is the first SIS extracted for this input, the m = d.
      Otherwise, m < d (as elements in earlier SIS are not considered again when
      extracting additional SIS in the sis_collection procedure).
      In particular, m + the total number of elements in all previous SIS = d.
    values_over_entire_backselect: Array of floats of shape (m,) containing the
      values found during backward selection, corresponding to the idxs in
      ordering_over_entire_backselect. At each position, the value is the value
      of f *after* that corresponding position is masked. The length m is
      defined in the same way as in ordering_over_entire_backselect.
    mask: Boolean array of shape M that corresponds to this SIS. Applying this
      mask to the original input produces a version of the input where all
      values are masked except for those in the SIS. The mask and input may have
      different shape, as long as the mask is broadcastable over the input (see
      docstring of sis_collection for details/example).
  """
    __slots__ = ()

    def __len__(self):
        """Defines len of SISResult as number of elements in the SIS."""
        return self.sis.shape[0]

    def __hash__(self):
        return NotImplemented

    def __eq__(self, other):
        """Checks equality between this SISResult and another SISResult.

    Check that all fields are the exactly equal (including orderings).

    Args:
      other: A SISResult instance.

    Returns:
      True if self and other are equal, and False otherwise.
    """
        if not isinstance(other, SISResult):
            return False
        return np.array_equal(self.sis, other.sis) and np.array_equal(self.ordering_over_entire_backselect, other.ordering_over_entire_backselect) and np.array_equal(self.values_over_entire_backselect, other.values_over_entire_backselect) and np.array_equal(self.mask, other.mask)

    def approx_equal(self, other, rtol=1e-05, atol=1e-08):
        """Checks that this SISResult and another SISResult are approximately equal.

    SISResult.{sis, mask, ordering_over_entire_backselect} are compared exactly,
    while SISResult.values_over_entire_backselect are compared with slight
    tolerance (using np.allclose with provided rtol and atol). This is intended
    to check equality allowing for small differences due to floating point
    representations.

    Args:
      other: A SISResult instance.
      rtol: Float, the relative tolerance parameter used when comparing
        `values_over_entire_backselect` (see documentation for np.allclose).
      atol: Float, the absolute tolerance parameter used when comparing
        `values_over_entire_backselect` (see documentation for np.allclose).

    Returns:
      True if self and other are approximately equal, and False otherwise.
    """
        if not isinstance(other, SISResult):
            return False
        return np.array_equal(self.sis, other.sis) and np.array_equal(self.ordering_over_entire_backselect, other.ordering_over_entire_backselect) and np.allclose(self.values_over_entire_backselect, other.values_over_entire_backselect, rtol=rtol, atol=atol) and np.array_equal(self.mask, other.mask)

    def __ne__(self, other):
        return not self == other


INIT_ARGS = {
    'sis': np.array([0, 2], dtype=np.int32),
    'ordering_over_entire_backselect': np.array([1, 3], dtype=np.int32),
    'values_over_entire_backselect': np.array([0.5, 0.3], dtype=np.float32),
    'mask': np.array([True, False, True, False], dtype=bool)
}

ARGS = {
    'other': SISResult(
        sis=np.array([0, 2], dtype=np.int32),
        ordering_over_entire_backselect=np.array([1, 3], dtype=np.int32),
        values_over_entire_backselect=np.array([0.5, 0.3], dtype=np.float32),
        mask=np.array([True, False, True, False], dtype=bool)
    ),
    'rtol': 1e-05,
    'atol': 1e-08
}

METHOD = 'approx_equal'

result = SISResult(**INIT_ARGS)
print(f"Created SISResult with len={len(result)}")
print(f"SIS: {result.sis}")
print(f"Mask: {result.mask}")

is_approx_equal = result.approx_equal(**ARGS)
print(f"approx_equal result: {is_approx_equal}")

is_equal = result == ARGS['other']
print(f"__eq__ result: {is_equal}")
Setup block drafted by
a language model, class construct-then-call prompt, model not recorded
Imports
numpy — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type bool, ndim 0, dtype family float — no output shape is stated: observe_signature.py observed this class with its constructor sizes canonicalised where it could, which the node does not record, so its shape is not stated as this setup block's
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: torch and numpy seeded to 0 by the harness immediately before the class was constructed from INIT_ARGS (fixture_check.py)
_backselect Ran
ran; our contract draft was wrong, not the code
b-carter/overinterpretation/sufficient_input_subsets/sis.py
code served (permissive licence) · get_code("2da81307bc709549")
How it ran

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

import numpy as np

def dummy_f(batch_of_inputs):
    """Dummy function that takes (B x D) array and returns (B,) array of scores."""
    return np.sum(batch_of_inputs, axis=1)

# Create small test data
current_input = np.array([1.0, 2.0, 3.0, 4.0])
current_mask = np.array([True, True, False, True])
fully_masked_input = np.array([0.0, 0.0, 0.0, 0.0])

ARGS = {
    'f': dummy_f,
    'current_input': current_input,
    'current_mask': current_mask,
    'fully_masked_input': fully_masked_input
}
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 list — a list output has no array shape of its own; none is stated
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
_find_sis_from_backselect Ran
ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT)
b-carter/overinterpretation/sufficient_input_subsets/sis.py
code served (permissive licence) · get_code("1d33e984516a373d")
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.

# Setup code for _find_sis_from_backselect

# Construct backselect_stack: List of (idx, value) tuples
# idx identifies a position masked during backward selection
# value is the corresponding value after that position is masked
# Later tuples correspond to idxs masked later during backward selection

backselect_stack = [
    (0, 0.5),   # First masked position, value below threshold
    (1, 0.3),   # Second masked position, value below threshold
    (2, 0.8),   # Third masked position, value above threshold
    (3, 0.2),   # Fourth masked position, value below threshold
]

# Threshold for identifying SIS
threshold = 0.7

ARGS = {
    'backselect_stack': backselect_stack,
    'threshold': threshold,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1
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 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
_produce_next_masks Ran
ran; our contract draft was wrong, not the code
b-carter/overinterpretation/sufficient_input_subsets/sis.py
code served (permissive licence) · get_code("c713a7dcff2871db")
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

# Test case 1: Simple 1D mask with some True values
current_mask_1d = np.array([False, True, True, False])

# Test case 2: 2D mask with some True values
current_mask_2d = np.array([[True, False, True],
                             [False, True, False]])

# Test case 3: All False mask (edge case)
current_mask_all_false = np.array([False, False, False])

# Test case 4: All True mask
current_mask_all_true = np.array([True, True, True, True])

# Test case 5: 3D mask with mixed True/False
current_mask_3d = np.array([[[True, False], [False, True]],
                             [[False, True], [True, False]]])

ARGS = {
    "current_mask": current_mask_1d
}
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
_transform_index_array_into_indexer Ran
ran, honoured the contract we drafted
b-carter/overinterpretation/sufficient_input_subsets/sis.py
code served (permissive licence) · get_code("7f24f8f5f6c29543")
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, ndim 2, dtype family int; no output shape is stated. The image it ran in was not recorded. If your copy returns the same type and ndim on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import numpy as np

# The function takes idx_array and converts it to a numpy array, transposes it, and returns as tuple
# idx_array should be an array-like structure that can be converted to numpy array and transposed

# Create a simple index array - this represents indices for multi-dimensional indexing
# For example, if we want to index elements at positions (0,1), (1,2), (0,3)
# we'd pass an array like [[0, 1, 0], [1, 2, 3]]
idx_array = np.array([[0, 1, 0], [1, 2, 3]])

ARGS = {
    "idx_array": idx_array
}
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, ndim 2, dtype family int — a tuple output has no array shape of its own; none is stated
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
_transform_next_masks_index_array_into_tuple Ran
ran, honoured the contract we drafted
b-carter/overinterpretation/sufficient_input_subsets/sis.py
code served (permissive licence) · get_code("c1c5f65dfa8444b9")
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, ndim 2, dtype family int; no output shape is stated. The image it ran in was not recorded. If your copy returns the same type and ndim on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import numpy as np

# Create a simple 2D index array
# Shape (B x C) where B=3 (number of indices) and C=2 (dimensionality of each index)
idx_array = np.array([[0, 1], [1, 1], [1, 2]], dtype=np.int64)

ARGS = {
    'idx_array': idx_array
}
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, ndim 2, dtype family int — a tuple output has no array shape of its own; none is stated
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
make_empty_boolean_mask Ran
ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT)
gifford-lab/overinterpretation/sufficient_input_subsets/sis.py
code served (permissive licence) · get_code("e9cb5323eca9c3e4")
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 (2, 3, 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 takes a shape parameter which should be a tuple of array dimensions
# Looking at the function body, it uses np.full(shape, True, dtype=np.bool)
# So shape needs to be a valid tuple that can be passed to np.full

ARGS = {
    "shape": (2, 3, 4)
}
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 (2, 3, 4) — shape (2, 3, 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
make_empty_boolean_mask Ran
ran; our contract draft was wrong, not the code
b-carter/overinterpretation/sufficient_input_subsets/sis.py
code served (permissive licence) · get_code("0a0908809e1bc3b9")
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 (4, 3, 2) as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import numpy as np

# The function takes a shape parameter which should be a tuple of array dimensions
# Looking at the function body, it uses np.full(shape, True, dtype=np.bool)
# So shape needs to be a valid tuple that can be passed to np.full

ARGS = {
    "shape": (4, 3, 2)
}
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 (4, 3, 2) — shape (4, 3, 2) as a later run recorded it
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
make_empty_boolean_mask_broadcast_over_axis Ran
ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT)
gifford-lab/overinterpretation/sufficient_input_subsets/sis.py
code served (permissive licence) · get_code("0ac134043bf4c5a5")
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 float, shape (1, 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

# Test case 1: 2D array, broadcast over axis 0
shape_1 = (2, 3)
axis_1 = 0

# Test case 2: 3D array, broadcast over multiple axes
shape_2 = (4, 5, 6)
axis_2 = (0, 2)

# Test case 3: 1D array, broadcast over axis 0
shape_3 = (7,)
axis_3 = 0

ARGS = {
    "shape": (2, 3),
    "axis": 0
}
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 2, dtype family float, shape (1, 3) — shape (1, 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
produce_masked_inputs Ran
ran; our contract draft was wrong, not the code
b-carter/overinterpretation/sufficient_input_subsets/sis.py
code served (permissive licence) · get_code("34fc1f71564be44f")
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 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 seed for reproducibility
np.random.seed(0)

# Create a simple input to mask - shape D (multi-dimensional, e.g., 1D array)
input_to_mask = np.array([1.0, 2.0, 3.0, 4.0])

# Create a fully masked version - same shape as input_to_mask
fully_masked_input = np.array([0.0, 0.0, 0.0, 0.0])

# Create a batch of masks - shape (B x D) where B=2, D=4
# Masks are boolean arrays indicating which values to keep from input_to_mask
batch_of_masks = np.array([
    [True, False, True, False],
    [False, True, False, True]
])

ARGS = {
    'input_to_mask': input_to_mask,
    'fully_masked_input': fully_masked_input,
    'batch_of_masks': batch_of_masks
}
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 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
find_sis Not yet run
unverified (harvested, no recorded run)
b-carter/overinterpretation/sufficient_input_subsets/sis.py
code served (permissive licence) · get_code("8fe1a968dd21cb11")
How it ran

no invocation recorded.

produce_masked_inputs Not yet run
unverified (harvested, no recorded run)
gifford-lab/overinterpretation/sufficient_input_subsets/sis.py
code served (permissive licence) · get_code("f25a46ac3ec9a39c")
How it ran

no invocation recorded. this sample carries JSON test cases instead of a setup block; get_reference_implementation serves them with the level they back.

Also present in other papers' code

Of 12 samples lifted from this paper's linked repositories, 12 carry a function identity and 0 do not. Of the 10 distinct functions with an identity, 0 are also present in other papers whose code we hold (0 with at least one paper dated earlier, 0 the same month, 0 later) and 10 are only here among the 52,977 papers whose code Syntology holds (as of 2026-09-26).

Only here means: among the 52,977 papers whose code Syntology holds (51,887 with lifted samples, 1,090 through their assemblies only), as of 2026-09-26, no other paper's lifted samples or current assembly bricks contain an identical function body after normalisation.

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

Image classifiers are typically scored on their test set accuracy, but high accuracy can mask a subtle type of model failure. We find that high scoring convolutional neural networks (CNNs) on popular benchmarks exhibit troubling pathologies that allow them to display high accuracy even in the absence of semantically salient features. When a model provides a high-confidence decision without salient supporting input features, we say the classifier has overinterpreted its input, finding too much class-evidence in patterns that appear nonsensical to humans. Here, we demonstrate that neural networks trained on CIFAR-10 and ImageNet suffer from overinterpretation, and we find models on CIFAR-10 make confident predictions even when 95% of input images are masked and humans cannot discern salient features in the remaining pixel-subsets. We introduce Batched Gradient SIS, a new method for discovering sufficient input subsets for complex datasets, and use this method to show the sufficiency of border pixels in ImageNet for training and testing. Although these patterns portend potential model fragility in real-world deployment, they are in fact valid statistical patterns of the benchmark that alone suffice to attain high test accuracy. Unlike adversarial examples, overinterpretation relies upon unmodified image pixels. We find ensembling and input dropout can each help mitigate overinterpretation. 35th Conference on Neural Information Processing Systems (NeurIPS 2021).

For agents

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

get_harvested_code_for_paper("2003.08907")
get_code_for_paper("2003.08907")
have("2003.08907")

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

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

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

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

Connect an agent — have() is free.