SYNTOLOGY HomeExplorerAtlasCodeMethodologyAboutDevelopersFeedPricing
Paper · 2111.06377 · CVPR · 2021

Masked Autoencoders Are Scalable Vision Learners

Kaiming He, Saining Xie, Piotr Dollár, Ross Girshick, Yanghao Li, Xinlei Chen

arXiv · PDF · Open in the Atlas

Code that ran

86 of 137 samples (functions and classes) lifted from this paper's linked repositories executed on a synthesized input in Syntology's jail (40 of them constructed an object rather than computing a result; 9 honoured the contract we drafted, 1 violated it and 54 have no contract verdict; 22 failures of our instrument; 51 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/2111.06377.json · badge: /api/ran/2111.06377.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
yangsun22/tc-moa community
not in the paper's declared repositories
12 ran · 6 no recorded run
facebookresearch/multimodal community
Papers with Code archive
11 ran · 1 no recorded run
yangyucheng000/mae community (classifier label)
classifier basis not recorded on the link
9 ran · 0 no recorded run
DarshanDeshpande/jax-models community
Papers with Code archive
7 ran · 5 no recorded run
FlyEgle/MAE-pytorch community
Papers with Code archive
7 ran · 4 no recorded run
IcarusWizard/MAE community
Papers with Code archive
6 ran · 0 no recorded run
0jason000/mae_vit community (classifier label)
classifier basis not recorded on the link
4 ran · 4 no recorded run
PatrickHua/SimpleMAE community
not in the paper's declared repositories
4 ran · 0 no recorded run
BUPT-PRIV/MAE-priv community
Papers with Code archive
3 ran · 5 no recorded run
guilk/vlc community
Papers with Code archive
3 ran · 1 no recorded run
hkbu-vscomputing/2022_mm_dmae-mocap community
Papers with Code archive
3 ran · 0 no recorded run
liujiyuan13/MAE-code community
not in the paper's declared repositories
2 ran · 1 no recorded run
wangsr126/mae-lite community
not in the paper's declared repositories
2 ran · 1 no recorded run
isaaccorley/hydro-foundation-model community
Papers with Code archive
2 ran · 0 no recorded run
zinengtang/tvlt community
not in the paper's declared repositories
2 ran · 0 no recorded run
nasa-impact/hls-foundation-os community (classifier label)
classifier basis not recorded on the link
2 ran · 0 no recorded run
bwconrad/masked-autoencoder community
Papers with Code archive
1 ran · 9 no recorded run
yongyupei/papers_with_examps community (classifier label)
classifier basis not recorded on the link
1 ran · 2 no recorded run
Nullius-2020/MAE-Paddle community (classifier label)
classifier basis not recorded on the link
1 ran · 1 no recorded run
qiaopTDUN/mae-repo community
not in the paper's declared repositories
1 ran · 0 no recorded run
keytoyze/visionts community
Papers with Code archive
1 ran · 0 no recorded run
mx-mark/videotransformer-pytorch community
not in the paper's declared repositories
1 ran · 0 no recorded run
copy not recorded community
not in the paper's declared repositories
1 ran · 0 no recorded run
pengzhiliang/MAE-pytorch community
not in the paper's declared repositories
0 ran · 3 no recorded run
alibaba/EasyCV community
not in the paper's declared repositories
0 ran · 2 no recorded run
FunctionStatusWhere it lives
Attention Ran
ran on a synthesized input · constructed an object; no result was computed
DarshanDeshpande/jax-models/jax_models/models/masked_autoencoder.py
code served (permissive licence) · get_code("2caebdfa70d265d1")
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 an instance of its own class, Attention: the run constructed the object and did not call it, so no result was computed. 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 jax
import jax.numpy as jnp
import flax.linen as nn
from typing import Optional, Callable

# Set random seed for reproducibility
jax.config.update('jax_platform_name', 'cpu')

# Create sample input tensor
batch_size = 2
sequence_length = 3
dim = 4

# Create input: shape (batch, n, channels)
key = jax.random.PRNGKey(0)
inputs = jax.random.normal(key, (batch_size, sequence_length, dim))

# Define ARGS dict with all parameters for Attention module
ARGS = {
    'dim': 4,
    'num_heads': 2,
    'use_bias': False,
    'att_drop': 0.0,
    'proj_drop': 0.0,
    'kernel_init': nn.initializers.xavier_uniform(),
    'deterministic': None,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
flax, jax — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type Attention — the run constructed an instance of its own class and did not call it; no shape is stated — the instrument coerces any output to an array; for a Attention 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
Attention Ran
ran on a synthesized input · constructed an object; no result was computed
hkbu-vscomputing/2022_mm_dmae-mocap/model/dmae.py
pointer only (licence: GPL-3.0) · get_code("331e0a44942a0951")
How it ran

The body of this sample is withheld: GPL-3.0, as GitHub detects it on this paper's repository, hkbu-vscomputing/2022_mm_dmae-mocap, 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.

Attention Ran
ran on a synthesized input · constructed an object; no result was computed
liujiyuan13/MAE-code/model.py
pointer only (licence: GPL-3.0) · get_code("5671450eaed4b12b")
How it ran

The body of this sample is withheld: GPL-3.0, as GitHub detects it on this paper's repository, liujiyuan13/MAE-code, 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.

Attention Ran
ran on a synthesized input · constructed an object; no result was computed
wangsr126/mae-lite/projects/mae_lite/models_mae.py
code served (permissive licence) · get_code("52e133864e98cbdc")
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 an instance of its own class, Attention: the run constructed the object and did not call it, so no result was computed. 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
from timm.models.vision_transformer import Attention as BaseAttn

torch.manual_seed(0)

# Create a minimal Attention instance with required parameters
# BaseAttn.__init__ signature: (dim, num_heads=8, qkv_bias=False, attn_drop=0., proj_drop=0.)

dim = 4
num_heads = 2
qkv_bias = False
attn_drop = 0.0
proj_drop = 0.0

# Create the base Attention module to extract its initialized attributes
base_attn = BaseAttn(dim=dim, num_heads=num_heads, qkv_bias=qkv_bias, 
                     attn_drop=attn_drop, proj_drop=proj_drop)

ARGS = {
    'dim': dim,
    'num_heads': num_heads,
    'qkv_bias': qkv_bias,
    'attn_drop': attn_drop,
    'proj_drop': proj_drop,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
timm, torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type Attention — the run constructed an instance of its own class and did not call it; no shape is stated — the instrument coerces any output to an array; for a Attention 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
Attention Ran
ran on a synthesized input
guilk/vlc/vlc/modules/mae_transformer.py
pointer only (licence: NONE) · get_code("b1605707f77d1785")
How it ran

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

Block Ran
ran on a synthesized input · constructed an object; no result was computed
yangsun22/tc-moa/model/ViT_MAE.py
pointer only (licence: NONE) · get_code("861a1945b7d265b5")
How it ran

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

Block Ran
ran on a synthesized input · constructed an object; no result was computed
wangsr126/mae-lite/projects/mae_lite/models_mae.py
code served (permissive licence) · get_code("f85de2d93369d9d8")
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 an instance of its own class, Block: the run constructed the object and did not call it, so no result was computed. 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
from timm.models.vision_transformer import DropPath, Mlp, Attention as BaseAttn

torch.manual_seed(0)

ARGS = {
    "dim": 64,
    "num_heads": 4,
    "mlp_ratio": 4.0,
    "qkv_bias": False,
    "drop": 0.0,
    "attn_drop": 0.0,
    "drop_path": 0.0,
    "act_layer": nn.GELU,
    "norm_layer": nn.LayerNorm,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
timm, torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type Block — the run constructed an instance of its own class and did not call it; no shape is stated — the instrument coerces any output to an array; for a Block 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
Block Ran
ran on a synthesized input · constructed an object; no result was computed
guilk/vlc/vlc/modules/mae_transformer.py
pointer only (licence: NONE) · get_code("ad2aca1970e4adb8")
How it ran

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

DMaeV5 Ran
ran on a synthesized input · constructed an object; no result was computed
hkbu-vscomputing/2022_mm_dmae-mocap/model/dmae.py
pointer only (licence: GPL-3.0) · get_code("497da9d8d920d347")
How it ran

The body of this sample is withheld: GPL-3.0, as GitHub detects it on this paper's repository, hkbu-vscomputing/2022_mm_dmae-mocap, 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.

DecoderEmbeddings Ran
ran on a synthesized input · constructed an object; no result was computed
facebookresearch/multimodal/torchmultimodal/models/masked_auto_encoder/model.py
code served (permissive licence) · get_code("50340b2a447969fb")
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 an instance of its own class, DecoderEmbeddings: the run constructed the object and did not call it, so no result was computed. 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
from torch import nn

torch.manual_seed(0)

ARGS = {
    "encoder_embed_dim": 4,
    "decoder_embed_dim": 8,
    "image_size": 224,
    "patch_size": 16,
}
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 DecoderEmbeddings — the run constructed an instance of its own class and did not call it; no shape is stated — the instrument coerces any output to an array; for a DecoderEmbeddings 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
DepthwiseConv2D Ran
ran on a synthesized input · constructed an object; no result was computed
DarshanDeshpande/jax-models/jax_models/models/masked_autoencoder.py
code served (permissive licence) · get_code("1eb614b14acb62c8")
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 an instance of its own class, DepthwiseConv2D: the run constructed the object and did not call it, so no result was computed. 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 jax
import jax.numpy as jnp
import flax.linen as nn
from typing import Sequence, Tuple, Callable, Optional, Union

# Set random seed for reproducibility
jax.config.update('jax_platform_name', 'cpu')

ARGS = {
    'kernel_shape': (3, 3),
    'stride': (1, 1),
    'padding': 'SAME',
    'channel_multiplier': 2,
    'use_bias': True,
    'weights_init': nn.initializers.lecun_uniform(),
    'bias_init': nn.initializers.zeros,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
flax, jax — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type DepthwiseConv2D — the run constructed an instance of its own class and did not call it; no shape is stated — the instrument coerces any output to an array; for a DepthwiseConv2D 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
DropPath Ran
ran on a synthesized input · constructed an object; no result was computed
DarshanDeshpande/jax-models/jax_models/models/masked_autoencoder.py
code served (permissive licence) · get_code("a84a5b2f271cf15c")
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 an instance of its own class, DropPath: the run constructed the object and did not call it, so no result was computed. 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 jax.numpy as jnp
import flax.linen as nn
from typing import Optional
import jax.random as random

class DropPath(nn.Module):
    """
    Implementation referred from https://github.com/rwightman/pytorch-image-models/blob/master/timm/models/layers/drop.py
    """
    dropout_prob: float = 0.1
    deterministic: Optional[bool] = None

    @nn.compact
    def __call__(self, input, deterministic=None):
        deterministic = nn.merge_param('deterministic', self.deterministic, deterministic)
        if deterministic:
            return input
        keep_prob = 1 - self.dropout_prob
        shape = (input.shape[0],) + (1,) * (input.ndim - 1)
        rng = self.make_rng('drop_path')
        random_tensor = keep_prob + random.uniform(rng, shape)
        random_tensor = jnp.floor(random_tensor)
        return jnp.divide(input, keep_prob) * random_tensor


# Create test input tensor: shape (2, 4) for batch_size=2, feature_dim=4
input_tensor = jnp.ones((2, 4), dtype=jnp.float32)

ARGS = {
    'dropout_prob': 0.1,
    'deterministic': False,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
flax, jax — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type DropPath — the run constructed an instance of its own class and did not call it; no shape is stated — the instrument coerces any output to an array; for a DropPath 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
DropPath Ran
ran on a synthesized input
BUPT-PRIV/MAE-priv/mae/modeling_pretrain.py
pointer only (licence: NOASSERTION) · get_code("762514af1d1eeb94")
How it ran

The body of this sample is withheld: GitHub could not classify the licence of this paper's repository, BUPT-PRIV/MAE-priv (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. A run is recorded.

LinearDecoder Ran
ran on a synthesized input · constructed an object; no result was computed
bwconrad/masked-autoencoder/src/model.py
pointer only (licence: NONE) · get_code("8c2a5e9356370f98")
How it ran

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

MAE Ran
ran on a synthesized input · constructed an object; no result was computed
PatrickHua/SimpleMAE/mae.py
pointer only (licence: NONE) · get_code("e0ce63efd1bd3605")
How it ran

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

MAE Ran
ran on a synthesized input · constructed an object; no result was computed
qiaopTDUN/mae-repo/vit_pytorch/mae.py
pointer only (licence: NONE) · get_code("62051d3ebdd50d03")
How it ran

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

MAEOutput Ran
ran on a synthesized input · constructed an object; no result was computed
facebookresearch/multimodal/torchmultimodal/models/masked_auto_encoder/model.py
code served (permissive licence) · get_code("a9991ea23ae0f3d2")
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 an instance of its own class, MAEOutput: the run constructed the object and did not call it, so no result was computed. 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
from typing import Callable, NamedTuple, Optional, Tuple, Union, List

torch.manual_seed(0)

class TransformerOutput(NamedTuple):
    last_hidden_state: Optional[torch.Tensor] = None
    pooler_output: Optional[torch.Tensor] = None
    hidden_states: Optional[List[torch.Tensor]] = None
    attentions: Optional[List[torch.Tensor]] = None
    image_labels: Optional[torch.Tensor] = None
    current_key_values: Optional[List[Tuple[torch.Tensor, torch.Tensor]]] = None

class MAEOutput(NamedTuple):
    encoder_output: Union[TransformerOutput, torch.Tensor]
    decoder_pred: Optional[torch.Tensor] = None
    label_patches: Optional[torch.Tensor] = None
    mask: Optional[torch.Tensor] = None

# Create small tensors for construction
encoder_hidden_state = torch.randn(2, 5, 4)
decoder_pred_tensor = torch.randn(2, 6, 3)
label_patches_tensor = torch.randn(2, 6, 7)
mask_tensor = torch.randn(2, 6)

# Create TransformerOutput with optional tensors
transformer_out = TransformerOutput(
    last_hidden_state=encoder_hidden_state,
    pooler_output=torch.randn(2, 4),
    hidden_states=[torch.randn(2, 5, 4), torch.randn(2, 5, 4)],
    attentions=[torch.randn(2, 8, 5, 5)],
    image_labels=torch.randint(0, 10, (2,)),
    current_key_values=[(torch.randn(2, 8, 5, 4), torch.randn(2, 8, 5, 4))]
)

ARGS = {
    "encoder_output": transformer_out,
    "decoder_pred": decoder_pred_tensor,
    "label_patches": label_patches_tensor,
    "mask": mask_tensor,
}
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 MAEOutput — the run constructed an instance of its own class and did not call it; no shape 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
MAE_Decoder Ran
ran on a synthesized input · constructed an object; no result was computed
IcarusWizard/MAE/model.py
code served (permissive licence) · get_code("171529a77f4acb67")
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 an instance of its own class, MAE_Decoder: the run constructed the object and did not call it, so no result was computed. 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
from einops import repeat, rearrange
from einops.layers.torch import Rearrange
from timm.models.layers import trunc_normal_
from timm.models.vision_transformer import Block

torch.manual_seed(0)

# The MAE_Decoder is instantiated with these parameters
ARGS = {
    'image_size': 32,
    'patch_size': 2,
    'emb_dim': 192,
    'num_layer': 4,
    'num_head': 3,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
einops, timm, torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type MAE_Decoder — the run constructed an instance of its own class and did not call it; no shape is stated — the instrument coerces any output to an array; for a MAE_Decoder 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
MAE_Encoder Ran
ran on a synthesized input · constructed an object; no result was computed
IcarusWizard/MAE/model.py
code served (permissive licence) · get_code("5a460b0d402e326f")
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 an instance of its own class, MAE_Encoder: the run constructed the object and did not call it, so no result was computed. 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 einops import repeat, rearrange
from timm.models.layers import trunc_normal_
from timm.models.vision_transformer import Block

torch.manual_seed(0)
np.random.seed(0)

ARGS = {
    "image_size": 8,
    "patch_size": 2,
    "emb_dim": 4,
    "num_layer": 2,
    "num_head": 2,
    "mask_ratio": 0.75,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
einops, numpy, timm, torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type MAE_Encoder — the run constructed an instance of its own class and did not call it; no shape is stated — the instrument coerces any output to an array; for a MAE_Encoder 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
MAE_ViT Ran
ran on a synthesized input · constructed an object; no result was computed
IcarusWizard/MAE/model.py
code served (permissive licence) · get_code("7df7897de7c5b685")
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 an instance of its own class, MAE_ViT: the run constructed the object and did not call it, so no result was computed. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch
import numpy as np

torch.manual_seed(0)
np.random.seed(0)

ARGS = {
    'image_size': 32,
    'patch_size': 2,
    'emb_dim': 192,
    'encoder_layer': 12,
    'encoder_head': 3,
    'decoder_layer': 4,
    'decoder_head': 3,
    'mask_ratio': 0.75
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
einops, numpy, timm, torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type MAE_ViT — the run constructed an instance of its own class and did not call it; no shape is stated — the instrument coerces any output to an array; for a MAE_ViT 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
MEF_MSSSIM Ran
ran on a synthesized input · constructed an object; no result was computed
yangsun22/tc-moa/model/ViT_MAE.py
pointer only (licence: NONE) · get_code("d20317addad2ec2a")
How it ran

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

MLP Ran
ran on a synthesized input · constructed an object; no result was computed
yangsun22/tc-moa/model/ViT_MAE.py
pointer only (licence: NONE) · get_code("bc87b313b8223daa")
How it ran

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

MaskEmbeeding Ran
ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT)
FlyEgle/MAE-pytorch/model/Transformers/VIT/mae.py
pointer only (licence: NONE) · get_code("7168cb5bb5682694")
How it ran

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

MaskTransLayerNorm Ran
ran on a synthesized input · constructed an object; no result was computed
FlyEgle/MAE-pytorch/model/Transformers/VIT/mae.py
pointer only (licence: NONE) · get_code("214b8df5981d09c7")
How it ran

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

MaskedAutoencoderViT Ran
ran on a synthesized input · constructed an object; no result was computed
keytoyze/visionts/visionts/models_mae.py
code served (permissive licence) · get_code("5c85cd8b5812d34f")
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 an instance of its own class, MaskedAutoencoderViT: the run constructed the object and did not call it, so no result was computed. 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
from timm.models.vision_transformer import PatchEmbed, Block
import numpy as np

torch.manual_seed(0)

ARGS = {
    'img_size': 224,
    'patch_size': 16,
    'in_chans': 3,
    'embed_dim': 64,
    'depth': 2,
    'num_heads': 4,
    'decoder_embed_dim': 32,
    'decoder_depth': 1,
    'decoder_num_heads': 2,
    'mlp_ratio': 4.0,
    'norm_layer': nn.LayerNorm,
    'norm_pix_loss': False,
    'quantile': False,
    'quantile_head_num': 9,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy, timm, torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type MaskedAutoencoderViT — the run constructed an instance of its own class and did not call it; no shape is stated — the instrument coerces any output to an array; for a MaskedAutoencoderViT 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
PatchEmbed Ran
ran on a synthesized input · constructed an object; no result was computed
yangsun22/tc-moa/model/ViT_MAE.py
pointer only (licence: NONE) · get_code("87472fa3925de39b")
How it ran

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

PatchEmbed Ran
ran on a synthesized input · constructed an object; no result was computed
DarshanDeshpande/jax-models/jax_models/models/masked_autoencoder.py
code served (permissive licence) · get_code("8c15bb7018339540")
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 an instance of its own class, PatchEmbed: the run constructed the object and did not call it, so no result was computed. 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 jax
import jax.numpy as jnp
import flax.linen as nn

# Create a small stand-in input tensor
# Shape: (batch=2, height=32, width=32, channels=3)
batch_size = 2
height = 32
width = 32
channels = 3
inputs = jnp.ones((batch_size, height, width, channels), dtype=jnp.float32)

# Define kernel_init - using Flax's xavier_uniform initializer
kernel_init = nn.initializers.xavier_uniform()

ARGS = {
    'patch_size': 16,
    'emb_dim': 768,
    'use_norm': False,
    'kernel_init': kernel_init
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
flax, jax — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type PatchEmbed — the run constructed an instance of its own class and did not call it; no shape is stated — the instrument coerces any output to an array; for a PatchEmbed 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
PatchEmbed Ran
ran on a synthesized input · constructed an object; no result was computed
guilk/vlc/vlc/modules/mae_transformer.py
pointer only (licence: NONE) · get_code("aca1bd49f0338dbf")
How it ran

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

PatchEmbed Ran
ran on a synthesized input · constructed an object; no result was computed
FlyEgle/MAE-pytorch/model/Transformers/VIT/mae.py
pointer only (licence: NONE) · get_code("fef9f7a5f84c313e")
How it ran

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

PatchEmbed Ran
ran on a synthesized input
BUPT-PRIV/MAE-priv/mae/modeling_pretrain.py
pointer only (licence: NOASSERTION) · get_code("19e9a6ad7bef0ec3")
How it ran

The body of this sample is withheld: GitHub could not classify the licence of this paper's repository, BUPT-PRIV/MAE-priv (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. A run is recorded.

PatchEmbeddings Ran
ran on a synthesized input · constructed an object; no result was computed
facebookresearch/multimodal/torchmultimodal/models/masked_auto_encoder/model.py
code served (permissive licence) · get_code("8163b722029972c0")
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 an instance of its own class, PatchEmbeddings: the run constructed the object and did not call it, so no result was computed. 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
from typing import Union, Tuple, Optional

torch.manual_seed(0)

ARGS = {
    "image_size": 224,
    "patch_size": 16,
    "num_channels": 3,
    "hidden_size": 768,
    "hidden_dropout_prob": 0.1,
    "use_image_masking": False,
    "patch_drop_rate": None,
    "include_cls_embed": True,
}
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 PatchEmbeddings — the run constructed an instance of its own class and did not call it; no shape is stated — the instrument coerces any output to an array; for a PatchEmbeddings 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
PatchEmbeddingsOutput Ran
ran on a synthesized input · constructed an object; no result was computed
facebookresearch/multimodal/torchmultimodal/models/masked_auto_encoder/model.py
code served (permissive licence) · get_code("bb30b6d29305dccf")
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 an instance of its own class, PatchEmbeddingsOutput: the run constructed the object and did not call it, so no result was computed. 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
from torch import nn, Tensor
from typing import Optional

torch.manual_seed(0)

# Create sample tensors with distinct dimensions
embeddings = torch.randn(2, 4)  # batch_size=2, embedding_dim=4
random_mask = torch.randint(0, 2, (2, 3))  # batch_size=2, num_patches=3
ids_restore = torch.randint(0, 12, (2, 12))  # batch_size=2, num_patches=12

ARGS = {
    "embeddings": embeddings,
    "random_mask": random_mask,
    "ids_restore": ids_restore,
}
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 PatchEmbeddingsOutput — the run constructed an instance of its own class and did not call it; no shape 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
PatchShuffle Ran
ran on a synthesized input · constructed an object; no result was computed
IcarusWizard/MAE/model.py
code served (permissive licence) · get_code("a9838138fb194e4e")
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 an instance of its own class, PatchShuffle: the run constructed the object and did not call it, so no result was computed. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch
import numpy as np

torch.manual_seed(0)
np.random.seed(0)

# PatchShuffle.__init__ takes ratio parameter
# PatchShuffle.forward takes patches: torch.Tensor with shape (T, B, C)

# Create a small patches tensor with distinct dimensions:
# T (time/sequence length) = 8
# B (batch) = 2
# C (channels) = 4
patches = torch.randn(8, 2, 4)

# ratio parameter: shuffle ratio between 0 and 1
ratio = 0.25

ARGS = {
    "ratio": ratio
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
einops, numpy, torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type PatchShuffle — the run constructed an instance of its own class and did not call it; no shape is stated — the instrument coerces any output to an array; for a PatchShuffle 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
PatchShuffler Ran
ran on a synthesized input · constructed an object; no result was computed
PatrickHua/SimpleMAE/mae.py
pointer only (licence: NONE) · get_code("4e3aa5c38953cd03")
How it ran

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

PositionEmbed Ran
ran on a synthesized input · constructed an object; no result was computed
FlyEgle/MAE-pytorch/model/Transformers/VIT/mae.py
pointer only (licence: NONE) · get_code("5c8ef9e803d379dd")
How it ran

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

RandomMaskGenerator Ran
ran on a synthesized input
mx-mark/videotransformer-pytorch/mask_generator.py
pointer only (licence: NONE) · get_code("db04c09ee238a7d0")
How it ran

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

RandomMaskingOutput Ran
ran on a synthesized input · constructed an object; no result was computed
facebookresearch/multimodal/torchmultimodal/models/masked_auto_encoder/model.py
code served (permissive licence) · get_code("c2ccb58b26b80780")
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 an instance of its own class, RandomMaskingOutput: the run constructed the object and did not call it, so no result was computed. 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
from torch import nn, Tensor

torch.manual_seed(0)

# RandomMaskingOutput is a NamedTuple with 4 fields:
# - x_masked: Tensor (the masked input)
# - mask: Tensor (binary mask indicating which tokens are masked)
# - ids_restore: Tensor (indices to restore original order)
# - ids_keep: Tensor (indices of kept tokens)

# Create small tensors with distinct dimensions for clarity
batch_size = 2
seq_length = 4
hidden_dim = 3

# x_masked: shape (batch_size, seq_length, hidden_dim)
x_masked = torch.randn(batch_size, seq_length, hidden_dim)

# mask: shape (batch_size, seq_length) - binary mask
mask = torch.randint(0, 2, (batch_size, seq_length)).float()

# ids_restore: shape (batch_size, seq_length) - indices for restoration
ids_restore = torch.arange(seq_length).unsqueeze(0).expand(batch_size, -1)

# ids_keep: shape (batch_size, num_keep) where num_keep < seq_length
num_keep = 2
ids_keep = torch.tensor([[0, 2], [1, 3]])

ARGS = {
    "x_masked": x_masked,
    "mask": mask,
    "ids_restore": ids_restore,
    "ids_keep": ids_keep,
}
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 RandomMaskingOutput — the run constructed an instance of its own class and did not call it; no shape 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
Relative_Position_Layer Ran
ran on a synthesized input · constructed an object; no result was computed
yangsun22/tc-moa/model/ViT_MAE.py
pointer only (licence: NONE) · get_code("674cd8263656f0a9")
How it ran

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

ShuffleIndex Ran
ran; our contract draft was wrong, not the code
FlyEgle/MAE-pytorch/model/Transformers/VIT/mae.py
pointer only (licence: NONE) · get_code("757bdfb554d8bc1c")
How it ran

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

SimMIM Ran
ran on a synthesized input
isaaccorley/hydro-foundation-model/src/models/simmim.py
code served (permissive licence) · get_code("ea3ec9aaa022ab81")
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 Tensor, 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 torch
import torch.nn as nn
import numpy as np
from collections import OrderedDict

# Stand-in encoder module
class TinyEncoder(nn.Module):
    def __init__(self, in_chans=3, embed_dim=4, num_layers=2):
        super().__init__()
        self.num_features = embed_dim
        self.patch_embed = nn.Conv2d(in_chans, embed_dim, kernel_size=2, stride=2)
        self.blocks = nn.ModuleList([
            nn.Sequential(
                nn.LayerNorm(embed_dim),
                nn.Linear(embed_dim, embed_dim),
                nn.GELU()
            ) for _ in range(num_layers)
        ])
        self.norm = nn.LayerNorm(embed_dim)

    def forward(self, x, mask=None):
        x = self.patch_embed(x)
        B, C, H, W = x.shape
        x = x.flatten(2).transpose(1, 2)
        for blk in self.blocks:
            x = blk(x)
        x = self.norm(x)
        x = x.transpose(1, 2).reshape(B, C, H, W)
        return x

# Config dict
config = type('Config', (), {
    'NORM_TARGET': type('NormTarget', (), {
        'ENABLE': True,
        'PATCH_SIZE': 3
    })
})()

# INIT_ARGS
INIT_ARGS = {
    'config': config,
    'encoder': TinyEncoder(in_chans=3, embed_dim=4),
    'encoder_stride': 2,
    'in_chans': 3,
    'patch_size': 2
}

# ARGS for forward call
B, C, H, W = 2, 3, 8, 8
x = torch.randn(B, C, H, W)
mask = torch.rand(B, H // INIT_ARGS['patch_size'], W // INIT_ARGS['patch_size']) > 0.5
mask = mask.float()

ARGS = {
    'x': x,
    'mask': mask
}
Setup block drafted by
a language model, class construct-then-call prompt, model not recorded
Imports
numpy, torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type Tensor, 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)
SparseDispatcher Ran
ran on a synthesized input · constructed an object; no result was computed
yangsun22/tc-moa/model/ViT_MAE.py
pointer only (licence: NONE) · get_code("15b2b3f169df4432")
How it ran

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

Transformer Ran
ran on a synthesized input · constructed an object; no result was computed
hkbu-vscomputing/2022_mm_dmae-mocap/model/dmae.py
pointer only (licence: GPL-3.0) · get_code("4ee06daa6459c4aa")
How it ran

The body of this sample is withheld: GPL-3.0, as GitHub detects it on this paper's repository, hkbu-vscomputing/2022_mm_dmae-mocap, 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.

Transformer Ran
ran on a synthesized input · constructed an object; no result was computed
liujiyuan13/MAE-code/model.py
pointer only (licence: GPL-3.0) · get_code("2535ae01b09ade02")
How it ran

The body of this sample is withheld: GPL-3.0, as GitHub detects it on this paper's repository, liujiyuan13/MAE-code, 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.

Transformer Ran
ran on a synthesized input · constructed an object; no result was computed
PatrickHua/SimpleMAE/mae.py
pointer only (licence: NONE) · get_code("f510e0f909e0f1d0")
How it ran

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

TransformerMLP Ran
ran on a synthesized input · constructed an object; no result was computed
DarshanDeshpande/jax-models/jax_models/models/masked_autoencoder.py
code served (permissive licence) · get_code("d250b23f4ed3fd00")
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 an instance of its own class, TransformerMLP: the run constructed the object and did not call it, so no result was computed. 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 jax
import jax.numpy as jnp
import flax.linen as nn
from typing import Optional, Union, Tuple, Callable, Sequence

# Set random seed for reproducibility
jax.config.update('jax_platform_name', 'cpu')

# Create a small input tensor for testing
# Shape: (batch=2, sequence_length=16, input_features=4)
batch_size = 2
seq_length = 16
input_dim = 4
output_dim = 5

inputs = jnp.ones((batch_size, seq_length, input_dim), dtype=jnp.float32)

ARGS = {
    'dim': 8,
    'out_dim': output_dim,
    'dropout': 0.1,
    'use_dwconv': False,
    'linear': True,
    'dense_kernel_init': nn.initializers.xavier_uniform(),
    'conv_kernel_init': nn.initializers.xavier_normal(),
    'deterministic': None,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
flax, jax — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type TransformerMLP — the run constructed an instance of its own class and did not call it; no shape is stated — the instrument coerces any output to an array; for a TransformerMLP 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
TransformerOutput Ran
ran on a synthesized input · constructed an object; no result was computed
facebookresearch/multimodal/torchmultimodal/models/masked_auto_encoder/model.py
code served (permissive licence) · get_code("56d769a7351c787e")
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 an instance of its own class, TransformerOutput: the run constructed the object and did not call it, so no result was computed. 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
from typing import Callable, NamedTuple, Optional, Tuple, List

torch.manual_seed(0)

# Construct tiny tensors for each parameter
last_hidden_state = torch.randn(2, 4)  # batch_size=2, hidden_dim=4
pooler_output = torch.randn(2, 4)  # batch_size=2, hidden_dim=4
hidden_states = [torch.randn(2, 4) for _ in range(3)]  # List of 3 hidden state tensors
attentions = [torch.randn(2, 3, 4, 4) for _ in range(2)]  # List of 2 attention tensors
image_labels = torch.tensor([0, 1])  # batch_size=2
current_key_values = [(torch.randn(2, 3, 4), torch.randn(2, 3, 4)) for _ in range(2)]  # List of (key, value) tuples

ARGS = {
    "last_hidden_state": last_hidden_state,
    "pooler_output": pooler_output,
    "hidden_states": hidden_states,
    "attentions": attentions,
    "image_labels": image_labels,
    "current_key_values": current_key_values,
}
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 TransformerOutput — the run constructed an instance of its own class and did not call it; no shape 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
UnMaskEmbeeding Ran
ran on a synthesized input · constructed an object; no result was computed
FlyEgle/MAE-pytorch/model/Transformers/VIT/mae.py
pointer only (licence: NONE) · get_code("315d68728f9a0983")
How it ran

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

_mef_ssim Ran
ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT)
yangsun22/tc-moa/model/ViT_MAE.py
pointer only (licence: NONE) · get_code("a02c6d0a4898ab3c")
How it ran

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

_random_masking_1d Ran
ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT)
facebookresearch/multimodal/torchmultimodal/models/masked_auto_encoder/model.py
code served (permissive licence) · get_code("cad22d0081516d4a")
How it ran

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

import torch
from torch import nn, Tensor

torch.manual_seed(0)

# Analyze the function:
# - x: Tensor with shape (n, num_patches_h, num_patches_w, d)
# - mask_ratio: float between 0 and 1
# - num_patches_h: int, height dimension for patches
# - num_patches_w: int, width dimension for patches
# Returns: Tuple[Tensor, int]

# Create a small tensor with distinct dimensions
# Shape: (batch=2, num_patches_h=3, num_patches_w=5, d=4)
batch_size = 2
num_patches_h = 3
num_patches_w = 5
d = 4

x = torch.randn(batch_size, num_patches_h, num_patches_w, d)
mask_ratio = 0.5

ARGS = {
    "x": x,
    "mask_ratio": mask_ratio,
    "num_patches_h": num_patches_h,
    "num_patches_w": num_patches_w,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type tuple — a tuple output has no array shape of its own; none is stated
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
build_2d_sincos_position_embedding Ran
ran, honoured the contract we drafted
BUPT-PRIV/MAE-priv/mae/modeling_pretrain.py
pointer only (licence: NOASSERTION) · get_code("3ee2c04c92f6e311")
How it ran

The body of this sample is withheld: GitHub could not classify the licence of this paper's repository, BUPT-PRIV/MAE-priv (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. A run is recorded.

check_obs_url Ran
ran on a synthesized input
yangyucheng000/mae/src/helper.py
code served (permissive licence) · get_code("d5d542acf05a4fd3")
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 bool, 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

ARGS = {
    "url": "s3://bucket/path/to/object"
}
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 bool, 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
compute_mae_video Ran
ran; our contract draft was wrong, not the code
zinengtang/tvlt/model/modules/objectives.py
code served (permissive licence) · get_code("b6e1b0c89f370eb3")
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 dict. 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)

# Build a minimal pl_module that satisfies the function's usage
class MinimalTransformer(nn.Module):
    def __init__(self):
        super().__init__()
        self.linear = nn.Linear(768, 768)
    
    def mae_score_video(self, video_feats):
        # video_feats shape: (N, L, D)
        # Should output predictions matching target shape from patchify_video
        # target shape: (N, L, patch_size**2 * 3) = (N, L, 768)
        return self.linear(video_feats)

class MinimalPLModule(nn.Module):
    def __init__(self):
        super().__init__()
        self.transformer = MinimalTransformer()
        self.training = True
        self._train_mae_video_loss = nn.Identity()
        self._val_mae_video_loss = nn.Identity()
    
    def infer(self, batch, mask_text=False, mask_visual=False, use_mae=False):
        # Return dict with required keys
        # video shape: (N, T, 3, H, W) where H, W are divisible by patch_size
        # For patch_size=16, we need H, W to be multiples of 16
        video = torch.randn(2, 3, 3, 32, 32)  # (N=2, T=3, C=3, H=32, W=32)
        
        # video_feats should have shape (N, L, D) where L = T * (H/p) * (W/p)
        # L = 3 * 2 * 2 = 12, D = 768
        video_feats = torch.randn(2, 12, 768)
        
        # video_masks shape: (N, L) for masking patches
        video_masks = torch.ones(2, 12)
        
        return {
            'video': video,
            'video_feats': video_feats,
            'video_masks': video_masks
        }
    
    def train_mae_video_loss(self, loss):
        return loss
    
    def val_mae_video_loss(self, loss):
        return loss
    
    def log(self, key, value):
        pass

# Create batch (not used directly but included for completeness)
batch = {}

# Create pl_module
pl_module = MinimalPLModule()

ARGS = {
    'pl_module': pl_module,
    'batch': batch,
    'patch_size': 16,
    'num_patches': 14
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type dict — a dict output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a dict 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_window Ran
ran, honoured the contract we drafted
yangsun22/tc-moa/model/ViT_MAE.py
pointer only (licence: NONE) · get_code("ea765f7aef3e0254")
How it ran

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

float_parameter Ran
ran, honoured the contract we drafted
0jason000/mae_vit/src/transforms.py
pointer only (licence: Apache-2.0); the stored copy get_code serves, from chenchenzong/dpc, is pointer only (licence: NONE) · get_code("40d3c39a403ae1f7")
How it ran

The body of this sample is withheld: this paper's link allows the body inline (Apache-2.0), but get_code serves the stored copy, first harvested from chenchenzong/dpc, 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.

gaussian Ran
ran, honoured the contract we drafted
this paper's copy was not recorded; identical code first harvested from Xinjie-Q/LDMIC
pointer only · get_code("c56b7ef16f309a45")
How it ran

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

get_1d_sin_cos_embeddings Ran
ran; our contract draft was wrong, not the code
facebookresearch/multimodal/torchmultimodal/models/masked_auto_encoder/model.py
code served (permissive licence) · get_code("3dc442f442bab69d")
How it ran

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

torch.manual_seed(0)

# The function expects:
# - embed_dim: int - embedding dimension
# - positions: Tensor - 1d tensor with position ids

# From the function body:
# - embed_dim is used to compute omega via torch.arange(embed_dim // 2, ...)
# - positions is used in torch.einsum('i,j->ij', positions, omega) where i indexes positions
# - The result concatenates sin and cos embeddings along dim=1

# Create small test values
embed_dim = 4  # Must be even for embed_dim // 2
positions = torch.tensor([0, 1], dtype=torch.float)  # 1d tensor with 2 positions

ARGS = {
    "embed_dim": embed_dim,
    "positions": positions,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type Tensor, ndim 2, dtype family float, 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
get_1d_sincos_pos_embed_from_grid Ran
ran on a synthesized input
nasa-impact/hls-foundation-os/geospatial_fm/geospatial_fm.py
code served (permissive licence) · get_code("f6ed4fbd11e09648")
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 (3, 8) 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 torch

torch.manual_seed(0)

# Analyze function usage:
# - embed_dim: int, used in assertions and arithmetic (embed_dim % 2, embed_dim / 2.0)
# - pos: torch.Tensor, reshaped to (-1,) and used in einsum with shape (M,)
# Returns numpy array of shape (M, embed_dim)

embed_dim = 8  # must be even
pos = torch.tensor([0.0, 1.0, 2.0], dtype=torch.float32)  # shape (3,)

ARGS = {
    "embed_dim": embed_dim,
    "pos": pos,
}
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 (3, 8) — shape (3, 8) 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_2d_sin_cos_embeddings Ran
ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT)
facebookresearch/multimodal/torchmultimodal/models/masked_auto_encoder/model.py
code served (permissive licence) · get_code("931261dd3b92624d")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned Tensor, ndim 3, dtype family float, shape (1, 13, 16) 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
from torch import nn

torch.manual_seed(0)

ARGS = {
    "embed_dim": 16,
    "input_size": (4, 3),
    "include_cls_embed": True,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type Tensor, ndim 3, dtype family float, shape (1, 13, 16) — shape (1, 13, 16) 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_3d_sincos_pos_embed Ran
ran on a synthesized input
nasa-impact/hls-foundation-os/geospatial_fm/geospatial_fm.py
code served (permissive licence) · get_code("c6230d72998a4af2")
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 (24, 16) 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 torch

torch.manual_seed(0)

ARGS = {
    "embed_dim": 16,
    "grid_size": (2, 3, 4),
    "cls_token": False,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy, torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type ndarray, ndim 2, dtype family float, shape (24, 16) — shape (24, 16) 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_logger Ran
ran on a synthesized input
yangyucheng000/mae/src/logger.py
code served (permissive licence) · get_code("8765fe83bed1a28f")
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 os
import sys
import tempfile
from datetime import datetime

logger_name = 'mindspore-benchmark'

class LOGGER(logging.Logger):
    """
    LOGGER
    """

    def __init__(self, logger_name_local, rank=0):
        super().__init__(logger_name_local)
        self.log_fn = None
        if rank % 8 == 0:
            console = logging.StreamHandler(sys.stdout)
            console.setLevel(logging.INFO)
            formatter = logging.Formatter('%(asctime)s:%(levelname)s:%(message)s', '%Y-%m-%d %H:%M:%S')
            console.setFormatter(formatter)
            self.addHandler(console)

    def setup_logging_file(self, log_dir, rank=0):
        """setup_logging_file"""
        self.rank = rank
        if not os.path.exists(log_dir):
            os.makedirs(log_dir, exist_ok=True)
        log_name = datetime.now().strftime('%Y-%m-%d_time_%H_%M_%S') + '_rank_{}.log'.format(rank)
        log_fn = os.path.join(log_dir, log_name)
        fh = logging.FileHandler(log_fn)
        fh.setLevel(logging.INFO)
        formatter = logging.Formatter('%(asctime)s:%(levelname)s:%(message)s')
        fh.setFormatter(formatter)
        self.addHandler(fh)
        self.log_fn = log_fn

    def info(self, msg, *args, **kwargs):
        """info"""
        if self.isEnabledFor(logging.INFO):
            self._log(logging.INFO, msg, args, **kwargs)

    def save_args(self, args):
        """save_args"""
        self.info('Args:')
        if isinstance(args, (list, tuple)):
            for value in args:
                message = '--> {}'.format(value)
                self.info(message)
        else:
            if isinstance(args, dict):
                args_dict = args
            else:
                args_dict = vars(args)
            for key in args_dict.keys():
                message = '--> {}: {}'.format(key, args_dict[key])
                self.info(message)
        self.info('')

def get_logger(path, rank=0):
    """get_logger"""
    logger = LOGGER(logger_name, rank)
    logger.setup_logging_file(path, rank)
    return logger

# Create temporary directory for logging
temp_log_dir = tempfile.mkdtemp()

ARGS = {
    'path': temp_log_dir,
    'rank': 0
}
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

Showing the first 60. An agent gets every one from get_harvested_code_for_paper("2111.06377").

Also present in other papers' code

Of 137 samples lifted from this paper's linked repositories, 137 carry a function identity and 0 do not. Of the 131 distinct functions with an identity, 49 are also present in other papers whose code we hold (27 with at least one paper dated earlier, 4 the same month, 44 later) and 82 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
window_reverse
brick of this paper's assembly: helper
227 other papers
16 dated earlier, 4 the same month, 207 later · 34 only as an assembly brick
1608.03983 (2016-08)
SGDR: Stochastic Gradient Descent with Warm Restarts
1711.10925 (2017-11)
Deep Image Prior
2003.13678 (2020-03)
Designing Network Design Spaces
and 224 more not named here
window_partition
brick of this paper's assembly: helper
223 other papers
16 dated earlier, 2 the same month, 205 later · 32 only as an assembly brick
1706.03762 (2017-06)
Attention Is All You Need
1711.10925 (2017-11)
Deep Image Prior
2003.13678 (2020-03)
Designing Network Design Spaces
and 220 more not named here
get_2d_sincos_pos_embed_from_grid
brick of this paper's assembly: helper
190 other papers
2 dated earlier, 188 later · 65 only as an assembly brick
1807.10221 (2018-07)
Unified Perceptual Parsing for Scene Understanding
2105.12723 (2021-05)
Nested Hierarchical Transformer: Towards Accurate, Data-Efficient and Interpretable Visual Understanding
2202.00660 (2022-02)
Interactron: Embodied Adaptive Object Detection
and 187 more not named here
gaussian
brick of this paper's assembly: helper
160 other papers
13 dated earlier, 2 the same month, 144 later, 1 same year, order not determinable · 7 only as an assembly brick
1812.11941 (2018-12)
High Quality Monocular Depth Estimation via Transfer Learning
1904.01538 (2019-04)
Spatial Attentive Single-Image Deraining with a High Quality Real Rain Dataset
1907.11628 (2019-07)
Unsupervised Learning for Optical Flow Estimation Using Pyramid Convolution LSTM
and 157 more not named here
get_2d_sincos_pos_embed
brick of this paper's assembly: helper
95 other papers
2 dated earlier, 93 later · 33 only as an assembly brick
1807.10221 (2018-07)
Unified Perceptual Parsing for Scene Understanding
2105.12723 (2021-05)
Nested Hierarchical Transformer: Towards Accurate, Data-Efficient and Interpretable Visual Understanding
2202.00660 (2022-02)
Interactron: Embodied Adaptive Object Detection
and 92 more not named here
get_1d_sincos_pos_embed_from_grid
brick of this paper's assembly: helper
39 other papers
1 dated earlier, 38 later · 25 only as an assembly brick
2105.12723 (2021-05)
Nested Hierarchical Transformer: Towards Accurate, Data-Efficient and Interpretable Visual Understanding
2204.09435 (2022-04)
Hephaestus: A large scale multitask dataset towards InSAR understanding
2206.00272 (2022-06)
Vision GNN: An Image is Worth Graph of Nodes
and 36 more not named here
shear_x 27 other papers
3 dated earlier, 24 later
1811.12814 (2018-11)
Graph-Based Global Reasoning Networks
2109.03508 (2021-09)
RepNAS: Searching for Efficient Re-parameterizing Blocks
2109.06165 (2021-09)
CDTrans: Cross-domain Transformer for Unsupervised Domain Adaptation
and 24 more not named here
shear_y 27 other papers
3 dated earlier, 24 later
1811.12814 (2018-11)
Graph-Based Global Reasoning Networks
2109.03508 (2021-09)
RepNAS: Searching for Efficient Re-parameterizing Blocks
2109.06165 (2021-09)
CDTrans: Cross-domain Transformer for Unsupervised Domain Adaptation
and 24 more not named here
translate_x_rel 26 other papers
3 dated earlier, 23 later
1811.12814 (2018-11)
Graph-Based Global Reasoning Networks
2109.03508 (2021-09)
RepNAS: Searching for Efficient Re-parameterizing Blocks
2109.06165 (2021-09)
CDTrans: Cross-domain Transformer for Unsupervised Domain Adaptation
and 23 more not named here
DropPath
brick of this paper's assembly: helper
25 other papers
1 dated earlier, 24 later · 14 only as an assembly brick
2106.08254 (2021-06)
BEIT: BERT Pre-Training of Image Transformers
2201.12096 (2022-01)
Mask-based Latent Reconstruction for Reinforcement Learning
2203.12119 (2022-03)
Visual Prompt Tuning
and 22 more not named here
is_model 22 other papers
7 dated earlier, 15 later
1409.4842 (2014-09)
Going deeper with convolutions
1512.00567 (2015-12)
Rethinking the Inception Architecture for Computer Vision
1608.06993 (2016-08)
Densely Connected Convolutional Networks
and 19 more not named here
float_parameter 15 other papers
9 dated earlier, 6 later
1409.4842 (2014-09)
Going deeper with convolutions
1512.00567 (2015-12)
Rethinking the Inception Architecture for Computer Vision
1608.06993 (2016-08)
Densely Connected Convolutional Networks
and 12 more not named here
rand_bbox 14 other papers
1 dated earlier, 13 later
2109.03508 (2021-09)
RepNAS: Searching for Efficient Re-parameterizing Blocks
2206.13559 (2022-06)
ST-Adapter: Parameter-Efficient Image-to-Video Transfer Learning
2212.00776 (2022-12)
ResFormer: Scaling ViTs with Multi-Resolution Training
and 11 more not named here
Transformer
brick of this paper's assembly: helper, model
11 other papers
5 dated earlier, 6 later · 2 only as an assembly brick
2010.11929 (2020-10)
An Image is Worth 16x16 Words: Transformers for Image Recognition at Scale
2101.11986 (2021-01)
Tokens-to-Token ViT: Training Vision Transformers from Scratch on ImageNet
2103.14899 (2021-03)
CrossViT: Cross-Attention Multi-Scale Vision Transformer for Image Classification
and 8 more not named here
PatchEmbed
brick of this paper's assembly: model
10 other papers
4 dated earlier, 6 later · 7 only as an assembly brick
2010.11929 (2020-10)
An Image is Worth 16x16 Words: Transformers for Image Recognition at Scale
2103.10619 (2021-03)
Scalable Vision Transformers with Hierarchical Pooling
2106.02034 (2021-06)
DynamicViT: Efficient Vision Transformers with Dynamic Token Sparsification
and 7 more not named here
int_parameter 8 other papers
4 dated earlier, 4 later
1409.4842 (2014-09)
Going deeper with convolutions
1512.00567 (2015-12)
Rethinking the Inception Architecture for Computer Vision
1608.06993 (2016-08)
Densely Connected Convolutional Networks
and 5 more not named here
Block
brick of this paper's assembly: helper
7 other papers
7 later · 1 only as an assembly brick
2204.01678 (2022-04)
MultiMAE: Multi-modal Multi-task Masked Autoencoders
2209.08956 (2022-09)
Panoramic Vision Transformer for Saliency Detection in 360 • Videos
2302.01056 (2023-02)
Beyond Pretrained Features: Noisy Image Modeling Provides Adversarial Defense
and 4 more not named here
Attention
brick of this paper's assembly: helper, model
5 other papers
2 dated earlier, 3 later · 3 only as an assembly brick
2010.11929 (2020-10)
An Image is Worth 16x16 Words: Transformers for Image Recognition at Scale
2101.11986 (2021-01)
Tokens-to-Token ViT: Training Vision Transformers from Scratch on ImageNet
2203.03598 (2022-03)
Audio-visual Generalised Zero-shot Learning with Cross-modal Attention and Language
and 2 more not named here
Block
brick of this paper's assembly: helper, model
5 other papers
5 later · 3 only as an assembly brick
2201.12096 (2022-01)
Mask-based Latent Reconstruction for Reinforcement Learning
2203.12602 (2022-03)
VideoMAE: Masked Autoencoders are Data-Efficient Learners for Self-Supervised Video Pre-Training
2211.10636 (2022-11)
EVEREST: Efficient Masked Video Autoencoder by Removing Redundant Spatiotemporal Tokens
and 2 more not named here
DepthwiseConv2D
brick of this paper's assembly: helper
5 other papers
4 dated earlier, 1 later
2102.12122 (2021-02)
Pyramid Vision Transformer: A Versatile Backbone for Dense Prediction without Convolutions
2103.14030 (2021-03)
Swin Transformer: Hierarchical Vision Transformer using Shifted Windows
2105.01601 (2021-05)
MLP-Mixer: An all-MLP Architecture for Vision
and 2 more not named here

Shown: the 20 functions present in the most other papers. 29 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

This paper shows that masked autoencoders (MAE) are scalable self-supervised learners for computer vision. Our MAE approach is simple: we mask random patches of the input image and reconstruct the missing pixels. It is based on two core designs. First, we develop an asymmetric encoder-decoder architecture, with an encoder that operates only on the visible subset of patches (without mask tokens), along with a lightweight decoder that reconstructs the original image from the latent representation and mask tokens. Second, we find that masking a high proportion of the input image, e.g., 75%, yields a nontrivial and meaningful self-supervisory task. Coupling these two designs enables us to train large models efficiently and effectively: we accelerate training (by 3× or more) and improve accuracy. Our scalable approach allows for learning high-capacity models that generalize well: e.g., a vanilla ViT-Huge model achieves the best accuracy (87.8%) among methods that use only ImageNet-1K data. Transfer performance in downstream tasks outperforms supervised pretraining and shows promising scaling behavior.

For agents

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

get_harvested_code_for_paper("2111.06377")
get_code_for_paper("2111.06377")
have("2111.06377")

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

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

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

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

Connect an agent — have() is free.