SYNTOLOGY HomeExplorerAtlasCodeMethodologyAboutDevelopersFeedPricing
Paper · 2006.07733 · NeurIPS · 2020

Bootstrap your own latent: A new approach to self-supervised Learning

Bilal Piot, Rémi Munos, Michal Valko, Carl Doersch, Jean-Bastien Grill, Florent Altché, Florian Strub, Pierre Richemond, Corentin Tallec, Zhaohan Guo, Mohammad Azar, Elena Buchatskaya, and 2 more

arXiv · PDF · Open in the Atlas

Code that ran

62 of 79 samples (functions and classes) lifted from this paper's linked repositories executed on a synthesized input in Syntology's jail (19 of them constructed an object rather than computing a result; 4 honoured the contract we drafted, 1 violated it and 37 have no contract verdict; 20 failures of our instrument; 17 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/2006.07733.json · badge: /api/ran/2006.07733.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
liyi01827/noisy-contrastive community
Papers with Code archive
11 ran · 1 no recorded run
lucidrains/byol-pytorch community
Papers with Code archive
9 ran · 1 no recorded run
talipucar/PyFlow_BYOL community
Papers with Code archive
6 ran · 1 no recorded run
Kennethborup/BYOL community
Papers with Code archive
6 ran · 1 no recorded run
htdt/self-supervised community
Papers with Code archive
4 ran · 4 no recorded run
yaox12/BYOL-PyTorch community
Papers with Code archive
4 ran · 0 no recorded run
copy not recorded community
not in the paper's declared repositories
4 ran · 0 no recorded run
juneweng/byol-pytorch community
Papers with Code archive
3 ran · 1 no recorded run
filipbasara0/matryoshka-representation-learning community
Papers with Code archive
3 ran · 0 no recorded run
sabadijou/byol_multi_gpu community
Papers with Code archive
2 ran · 1 no recorded run
miszkur/SelfSupervisedLearning community
Papers with Code archive
2 ran · 1 no recorded run
reshinthadithyan/BYOL-Pytorch community
Papers with Code archive
2 ran · 1 no recorded run
EchoItLiu/SelfGait community
Papers with Code archive
2 ran · 1 no recorded run
jramapuram/BYOL community
Papers with Code archive
2 ran · 0 no recorded run
amazon-research/exponential-moving-average-normalization community
Papers with Code archive
1 ran · 2 no recorded run
HibikiJie/BYOL community
Papers with Code archive
1 ran · 0 no recorded run
sthalles/PyTorch-BYOL community
Papers with Code archive
0 ran · 2 no recorded run
FunctionStatusWhere it lives
BYOLModel Ran
ran on a synthesized input
yaox12/BYOL-PyTorch/model/byol_model.py
code served (permissive licence) · get_code("2784d037b1add7b4")
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 tuple. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch
import torch.nn as nn
from torchvision import models

class MLP(nn.Module):
    def __init__(self, input_dim, hidden_dim, output_dim):
        super().__init__()
        self.l1 = nn.Linear(input_dim, hidden_dim)
        self.bn1 = nn.BatchNorm1d(hidden_dim)
        self.relu1 = nn.ReLU(inplace=True)
        self.l2 = nn.Linear(hidden_dim, output_dim)

    def forward(self, x):
        x = self.l1(x)
        x = self.bn1(x)
        x = self.relu1(x)
        x = self.l2(x)
        return x

class EncoderwithProjection(nn.Module):
    def __init__(self, config):
        super().__init__()
        pretrained = config['model']['backbone']['pretrained']
        net_name = config['model']['backbone']['type']
        base_encoder = models.__dict__[net_name](pretrained=pretrained)
        self.encoder = nn.Sequential(*list(base_encoder.children())[:-1])
        input_dim = config['model']['projection']['input_dim']
        hidden_dim = config['model']['projection']['hidden_dim']
        output_dim = config['model']['projection']['output_dim']
        self.projetion = MLP(input_dim=input_dim, hidden_dim=hidden_dim, output_dim=output_dim)

    def forward(self, x):
        x = self.encoder(x)
        x = torch.flatten(x, 1)
        x = self.projetion(x)
        return x

class Predictor(nn.Module):
    def __init__(self, config):
        super().__init__()
        input_dim = config['model']['predictor']['input_dim']
        hidden_dim = config['model']['predictor']['hidden_dim']
        output_dim = config['model']['predictor']['output_dim']
        self.predictor = MLP(input_dim=input_dim, hidden_dim=hidden_dim, output_dim=output_dim)

    def forward(self, x):
        return self.predictor(x)

class BYOLModel(torch.nn.Module):
    def __init__(self, config):
        super().__init__()
        self.online_network = EncoderwithProjection(config)
        self.target_network = EncoderwithProjection(config)
        self.predictor = Predictor(config)
        self._initializes_target_network()

    @torch.no_grad()
    def _initializes_target_network(self):
        for param_q, param_k in zip(self.online_network.parameters(), self.target_network.parameters()):
            param_k.data.copy_(param_q.data)
            param_k.requires_grad = False

    @torch.no_grad()
    def _update_target_network(self, mm):
        """Momentum update of target network"""
        for param_q, param_k in zip(self.online_network.parameters(), self.target_network.parameters()):
            param_k.data.mul_(mm).add_(1.0 - mm, param_q.data)

    def forward(self, view1, view2, mm):
        q = self.predictor(self.online_network(torch.cat([view1, view2], dim=0)))
        with torch.no_grad():
            self._update_target_network(mm)
            target_z = self.target_network(torch.cat([view2, view1], dim=0)).detach().clone()
        return (q, target_z)

INIT_ARGS = {
    'config': {
        'model': {
            'backbone': {
                'type': 'resnet18',
                'pretrained': False
            },
            'projection': {
                'input_dim': 512,
                'hidden_dim': 8,
                'output_dim': 4
            },
            'predictor': {
                'input_dim': 4,
                'hidden_dim': 6,
                'output_dim': 4
            }
        }
    }
}

ARGS = {
    'view1': torch.randn(2, 3, 32, 32),
    'view2': torch.randn(2, 3, 32, 32),
    'mm': 0.99
}
Setup block drafted by
a language model, class construct-then-call prompt, model not recorded
Imports
torch, torchvision — 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: torch and numpy seeded to 0 by the harness immediately before the class was constructed from INIT_ARGS (fixture_check.py)
BatchNorm1d Ran
ran on a synthesized input · constructed an object; no result was computed
liyi01827/noisy-contrastive/simsiam/model_factory.py
pointer only (licence: NONE) · get_code("17ab24f7892fa961")
How it ran

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

CNNEncoder Ran
ran on a synthesized input
talipucar/PyFlow_BYOL/utils/model_utils.py
pointer only (licence: NONE) · get_code("9942ab84cb1d15a2")
How it ran

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

ConvMLP Ran
ran on a synthesized input
sabadijou/byol_multi_gpu/models/byol.py
pointer only (licence: NONE) · get_code("096cfb3b42210f32")
How it ran

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

EMA Ran
ran on a synthesized input · constructed an object; no result was computed
lucidrains/byol-pytorch/byol_pytorch/byol_pytorch.py
code served (permissive licence) · get_code("f6d2ad22f5a5580f")
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, EMA: 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

torch.manual_seed(0)

ARGS = {
    "beta": 0.99
}
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 EMA — 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 EMA 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
EMA Ran
ran on a synthesized input
Kennethborup/BYOL/BYOL/byol.py
code served (permissive licence) · get_code("1ef88af7143047a0")
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 float, 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 numpy as np

# INIT_ARGS for EMA.__init__(beta)
INIT_ARGS = {
    'beta': 0.9
}

# ARGS for EMA.__call__(MA, value)
ARGS = {
    'MA': 10.0,
    'value': 5.0
}
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 float, 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)
EncodeProject Ran
ran on a synthesized input
talipucar/PyFlow_BYOL/utils/model_utils.py
pointer only (licence: NONE) · get_code("e3cbe47be1db1b63")
How it ran

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

EncoderwithProjection Ran
ran on a synthesized input · constructed an object; no result was computed
yaox12/BYOL-PyTorch/model/byol_model.py
code served (permissive licence) · get_code("7dfac9bef432ab6b")
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, EncoderwithProjection: 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 torchvision import models

torch.manual_seed(0)

# Create a minimal config dict that satisfies the EncoderwithProjection.__init__ requirements
config = {
    'model': {
        'backbone': {
            'pretrained': False,
            'type': 'resnet18'
        },
        'projection': {
            'input_dim': 512,
            'hidden_dim': 256,
            'output_dim': 128
        }
    }
}

ARGS = {
    'config': config
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
torch, torchvision — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type EncoderwithProjection — 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 EncoderwithProjection 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
HiddenLayers Ran
ran on a synthesized input
talipucar/PyFlow_BYOL/utils/model_utils.py
pointer only (licence: NONE) · get_code("67317765520392ae")
How it ran

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

Hook Ran
ran on a synthesized input
Kennethborup/BYOL/BYOL/byol.py
code served (permissive licence) · get_code("688c1c4f58a24171")
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 NoneType. 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

class Hook:
    """
    A simple hook class that returns the output of a layer of a model during forward pass.
    """

    def __init__(self):
        self.output = None

    def setHook(self, module):
        """
        Attaches hook to model.
        """
        self.hook = module.register_forward_hook(self.hook_fn)

    def hook_fn(self, module, input, output):
        """
        Saves the wanted information.
        """
        self.output = output

    def val(self):
        """
        Return the saved value.
        """
        return self.output


INIT_ARGS = {}

# Create a simple model with a layer to hook
model = nn.Sequential(
    nn.Linear(4, 8),
    nn.ReLU(),
    nn.Linear(8, 3)
)

# Input tensor with batch size 2, feature dim 4
input_tensor = torch.randn(2, 4)

# We'll hook the first layer
target_module = model[0]

ARGS = {
    'module': target_module
}

METHOD = 'setHook'

# Setup and execution
hook = Hook()
hook.setHook(target_module)

# Run forward pass to trigger the hook
output = model(input_tensor)

# Verify the hook captured the output
hooked_output = hook.val()
Setup block drafted by
a language model, class construct-then-call prompt, model not recorded
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type NoneType — a NoneType output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a NoneType 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: torch and numpy seeded to 0 by the harness immediately before the class was constructed from INIT_ARGS (fixture_check.py)
Linear Ran
ran on a synthesized input · constructed an object; no result was computed
liyi01827/noisy-contrastive/simsiam/model_factory.py
pointer only (licence: NONE) · get_code("4a24b0e23a6445dd")
How it ran

The body of this sample is withheld: GitHub detected no licence in this paper's repository, liyi01827/noisy-contrastive 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; our contract draft was wrong, not the code
lucidrains/byol-pytorch/byol_pytorch/byol_pytorch.py
code served (permissive licence) · get_code("e27680ba34c9822b")
How it ran

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

import torch
import torch.nn as nn
import torch.distributed as dist

torch.manual_seed(0)

def default(val, def_val):
    return def_val if val is None else val

def MaybeSyncBatchnorm(is_distributed=None):
    is_distributed = default(is_distributed, dist.is_initialized() and dist.get_world_size() > 1)
    return nn.SyncBatchNorm if is_distributed else nn.BatchNorm1d

def MLP(dim, projection_size, hidden_size=4096, sync_batchnorm=None):
    return nn.Sequential(
        nn.Linear(dim, hidden_size),
        MaybeSyncBatchnorm(sync_batchnorm)(hidden_size),
        nn.ReLU(inplace=True),
        nn.Linear(hidden_size, projection_size)
    )

ARGS = {
    "dim": 4,
    "projection_size": 3,
    "hidden_size": 4096,
    "sync_batchnorm": False
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type Sequential — a Sequential output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a Sequential output the recorded ndim 1 and dtype family float describe that coercion, not the output, and are not stated
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
MLP Ran
ran on a synthesized input · constructed an object; no result was computed
yaox12/BYOL-PyTorch/model/byol_model.py
code served (permissive licence) · get_code("f74419add7dfb458")
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, MLP: 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

torch.manual_seed(0)

ARGS = {
    'input_dim': 4,
    'hidden_dim': 8,
    'output_dim': 3,
}
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 MLP — 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 MLP 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
MLP Ran
ran on a synthesized input · constructed an object; no result was computed
amazon-research/exponential-moving-average-normalization/models/byol.py
pointer only (licence: NONE) · get_code("100d08f2dcfe7489")
How it ran

The body of this sample is withheld: GitHub detected no licence in this paper's repository, amazon-research/exponential-moving-average-normalization 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
juneweng/byol-pytorch/byol_pytorch/byol_pytorch.py
code served (permissive licence) · get_code("66df1a1ee476a147")
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 2, dtype family float, shape (2, 3) as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch
from torch import nn

class MLP(nn.Module):

    def __init__(self, dim, projection_size, hidden_size=4096):
        super().__init__()
        self.net = nn.Sequential(nn.Linear(dim, hidden_size), nn.BatchNorm1d(hidden_size), nn.ReLU(inplace=True), nn.Linear(hidden_size, projection_size))

    def forward(self, x):
        return self.net(x)


INIT_ARGS = {
    'dim': 4,
    'projection_size': 3,
    'hidden_size': 768,
}

ARGS = {
    'x': torch.randn(2, 4),
}

if __name__ == '__main__':
    model = MLP(**INIT_ARGS)
    output = model(**ARGS)
    print(f"Output shape: {output.shape}")
    print(f"Expected shape: (2, 3)")
Setup block drafted by
a language model, class construct-then-call prompt, model not recorded
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, 3) — shape (2, 3) as a later run recorded it
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: torch and numpy seeded to 0 by the harness immediately before the class was constructed from INIT_ARGS (fixture_check.py)
MLP Ran
ran on a synthesized input
sabadijou/byol_multi_gpu/models/byol.py
pointer only (licence: NONE) · get_code("dcc9aa7b1d6a5de1")
How it ran

The body of this sample is withheld: GitHub detected no licence in this paper's repository, sabadijou/byol_multi_gpu 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
Kennethborup/BYOL/BYOL/byol.py
code served (permissive licence) · get_code("91caf7decdc1ce5f")
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 2, 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

# INIT_ARGS: parameters for MLP.__init__
INIT_ARGS = {
    'inputDim': 8,
    'projectionDim': 4,
    'hiddenDim': 12
}

# ARGS: parameters for MLP.forward
# forward expects x with shape (batch_size, inputDim)
ARGS = {
    'x': torch.randn(2, 8)
}
Setup block drafted by
a language model, class construct-then-call prompt, model not recorded
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type Tensor, ndim 2, dtype family float — no output shape is stated: observe_signature.py 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)
MLPHead Ran
ran on a synthesized input · constructed an object; no result was computed
miszkur/SelfSupervisedLearning/models/model.py
pointer only (licence: NONE) · get_code("5ec3adcd55340bbd")
How it ran

The body of this sample is withheld: GitHub detected no licence in this paper's repository, miszkur/SelfSupervisedLearning 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_Base Ran
ran on a synthesized input · constructed an object; no result was computed
reshinthadithyan/BYOL-Pytorch/BYOL.py
code served (permissive licence) · get_code("ad27d03b9ab5ef12")
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, MLP_Base: 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

torch.manual_seed(0)

# Inspect MLP_Base.__init__ parameters:
# - self (implicit)
# - Inp: int (input dimension)
# - Hidden: int (hidden layer dimension)
# - Projection: int (output/projection dimension)

ARGS = {
    "Inp": 4,
    "Hidden": 8,
    "Projection": 3,
}
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 MLP_Base — 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 MLP_Base 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
MatryoshkaProjector Ran
ran on a synthesized input · constructed an object; no result was computed
filipbasara0/matryoshka-representation-learning/mrl/mrl.py
code served (permissive licence) · get_code("cf8bd65b80370c1e")
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, MatryoshkaProjector: 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

torch.manual_seed(0)

# Construct arguments for MatryoshkaProjector
nesting_dims = [2, 4, 6]  # List of nesting dimensions, increasing order
out_dims = 5  # Output dimension

ARGS = {
    'nesting_dims': nesting_dims,
    'out_dims': out_dims,
}

# Verify the setup by creating the module and running a forward pass
if __name__ == "__main__":
    model = nn.MatryoshkaProjector(**ARGS)
    x = torch.randn(2, 6)  # batch_size=2, input_dim=6 (max of nesting_dims)
    output = model(x)
    print(f"Output length: {len(output)}")
    print(f"Output shapes: {[o.shape for o in output]}")
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 MatryoshkaProjector — 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 MatryoshkaProjector 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
MaybeSyncBatchnorm Ran
ran; our contract draft was wrong, not the code
lucidrains/byol-pytorch/byol_pytorch/byol_pytorch.py
code served (permissive licence) · get_code("e0ac07cc5ef23be4")
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 type. 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
import torch.distributed as dist

torch.manual_seed(0)

# The function MaybeSyncBatchnorm takes one parameter: is_distributed
# It uses dist.is_initialized() and dist.get_world_size() internally
# The parameter is_distributed can be None or a boolean

ARGS = {
    "is_distributed": None
}
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 type — a type output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a type 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
ModelWrapper Ran
ran on a synthesized input
Kennethborup/BYOL/BYOL/byol.py
code served (permissive licence) · get_code("e5edf7e87108eca5")
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 2, 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

# Create a simple backbone model
backbone = nn.Sequential(
    nn.Linear(8, 12),
    nn.ReLU(),
    nn.Linear(12, 16),
    nn.ReLU(),
    nn.Linear(16, 10)
)

INIT_ARGS = {
    'model': backbone,
    'projectionDim': 6,
    'projectionHiddenDim': 14,
    'embeddingLayer': -2
}

ARGS = {
    'x': torch.randn(2, 8)
}
Setup block drafted by
a language model, class construct-then-call prompt, model not recorded
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type Tensor, ndim 2, dtype family float — no output shape is stated: observe_signature.py 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)
NetWrapper Ran
ran on a synthesized input · constructed an object; no result was computed
lucidrains/byol-pytorch/byol_pytorch/byol_pytorch.py
code served (permissive licence) · get_code("a8cac4c5cd21f6d9")
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, NetWrapper: 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

torch.manual_seed(0)

# Create a simple backbone network
class SimpleBackbone(nn.Module):
    def __init__(self):
        super().__init__()
        self.layer1 = nn.Linear(3, 8)
        self.layer2 = nn.Linear(8, 16)
        self.layer3 = nn.Linear(16, 32)
    
    def forward(self, x):
        x = torch.relu(self.layer1(x))
        x = torch.relu(self.layer2(x))
        x = self.layer3(x)
        return x

net = SimpleBackbone()

ARGS = {
    'net': net,
    'projection_size': 128,
    'projection_hidden_size': 2048,
    'layer': -2,
    'use_simsiam_mlp': False,
    'sync_batchnorm': None,
    'use_simplicial_embeddings': False,
    'sem_num_simplices': 32,
    'sem_simplex_dim': 8,
    'sem_temperature': 0.1,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
einops, torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type NetWrapper — 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 NetWrapper 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
NetWrapper Ran
ran on a synthesized input
juneweng/byol-pytorch/byol_pytorch/byol_pytorch.py
code served (permissive licence) · get_code("4bb4f89baaa7a100")
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 tuple. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch
import torch.nn as nn

# Create a simple stand-in network
class SimpleNet(nn.Module):
    def __init__(self):
        super().__init__()
        self.conv1 = nn.Conv2d(3, 8, 3, padding=1)
        self.relu = nn.ReLU()
        self.conv2 = nn.Conv2d(8, 16, 3, padding=1)
        self.fc = nn.Linear(16 * 8 * 8, 10)
    
    def forward(self, x):
        x = self.conv1(x)
        x = self.relu(x)
        x = self.conv2(x)
        x = self.relu(x)
        x = x.view(x.size(0), -1)
        x = self.fc(x)
        return x

net = SimpleNet()

INIT_ARGS = {
    'net': net,
    'projection_size': 128,
    'projection_hidden_size': 256,
    'layer': -2
}

ARGS = {
    'x': torch.randn(2, 3, 8, 8)
}
Setup block drafted by
a language model, class construct-then-call prompt, model not recorded
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: torch and numpy seeded to 0 by the harness immediately before the class was constructed from INIT_ARGS (fixture_check.py)
PreActBlock Ran
ran on a synthesized input · constructed an object; no result was computed
liyi01827/noisy-contrastive/simsiam/model_factory.py
pointer only (licence: NONE) · get_code("9cf7c8e34248b087")
How it ran

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

PreActBottleneck Ran
ran on a synthesized input · constructed an object; no result was computed
liyi01827/noisy-contrastive/simsiam/model_factory.py
pointer only (licence: NONE) · get_code("48c90dc3cead67c6")
How it ran

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

Predictor Ran
ran on a synthesized input · constructed an object; no result was computed
yaox12/BYOL-PyTorch/model/byol_model.py
code served (permissive licence) · get_code("03e75d5f5306b451")
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, Predictor: 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

torch.manual_seed(0)

config = {
    'model': {
        'predictor': {
            'input_dim': 4,
            'hidden_dim': 8,
            'output_dim': 3
        }
    }
}

ARGS = {
    'config': config
}
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 Predictor — 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 Predictor 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
Predictor Ran
ran on a synthesized input
talipucar/PyFlow_BYOL/utils/model_utils.py
pointer only (licence: NONE) · get_code("7641e6d697e6dffa")
How it ran

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

Projector Ran
ran on a synthesized input
talipucar/PyFlow_BYOL/utils/model_utils.py
pointer only (licence: NONE) · get_code("bd8fca31411b4514")
How it ran

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

RandomApply Ran
ran on a synthesized input · constructed an object; no result was computed
lucidrains/byol-pytorch/byol_pytorch/byol_pytorch.py
code served (permissive licence) · get_code("faf380e1645f84b0")
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, RandomApply: 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 torch.nn import Module
import random

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

# Define a simple function to apply
class SimpleTransform(Module):
    def __init__(self):
        super().__init__()
        self.linear = nn.Linear(4, 3)
    
    def forward(self, x):
        return self.linear(x)

# Create instances for ARGS
fn = SimpleTransform()
p = 0.5

ARGS = {
    "fn": fn,
    "p": p
}
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 RandomApply — 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 RandomApply 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
RandomApply Ran
ran on a synthesized input
juneweng/byol-pytorch/byol_pytorch/byol_pytorch.py
code served (permissive licence) · get_code("8d381c72dbc91f6f")
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 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
import random

class RandomApply(nn.Module):

    def __init__(self, fn, p):
        super().__init__()
        self.fn = fn
        self.p = p

    def forward(self, x):
        if random.random() > self.p:
            return x
        return self.fn(x)


# Create a simple function to apply randomly
simple_fn = nn.ReLU()

INIT_ARGS = {
    'fn': simple_fn,
    'p': 0.5
}

ARGS = {
    'x': torch.randn(2, 4)
}

# Construct and call
module = RandomApply(**INIT_ARGS)
output = module(**ARGS)
Setup block drafted by
a language model, class construct-then-call prompt, model not recorded
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: torch and numpy seeded to 0 by the harness immediately before the class was constructed from INIT_ARGS (fixture_check.py)
RandomApply Ran
ran on a synthesized input
Kennethborup/BYOL/BYOL/byol.py
code served (permissive licence) · get_code("062cc33741812100")
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 2, dtype family float, shape (2, 4) as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch
import torch.nn as nn

class RandomApply(nn.Module):
    """
    Randomly apply function with probability p.
    
    :param func: function; takes input x (likely augmentation)
    :param p: float; probability of applying func
    """

    def __init__(self, func, p):
        super(RandomApply, self).__init__()
        self.func = func
        self.p = p

    def forward(self, x):
        if torch.rand(1) > self.p:
            return x
        else:
            return self.func(x)


def simple_augmentation(x):
    return x * 2.0


INIT_ARGS = {
    'func': simple_augmentation,
    'p': 0.7
}

ARGS = {
    'x': torch.randn(2, 4)
}

if __name__ == '__main__':
    module = RandomApply(**INIT_ARGS)
    output = module(**ARGS)
    print(output)
Setup block drafted by
a language model, class construct-then-call prompt, model not recorded
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: torch and numpy seeded to 0 by the harness immediately before the class was constructed from INIT_ARGS (fixture_check.py)
ReLIC Ran
ran on a synthesized input · constructed an object; no result was computed
filipbasara0/matryoshka-representation-learning/mrl/mrl.py
code served (permissive licence) · get_code("37caddd65d22b0fe")
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, ReLIC: 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
import copy
import math

torch.manual_seed(0)

# Create a minimal encoder that outputs features
class SimpleEncoder(nn.Module):
    def __init__(self):
        super(SimpleEncoder, self).__init__()
        # Input: (batch, 3, 32, 32)
        # Output: (batch, 16) - feature dimension
        self.conv1 = nn.Conv2d(3, 8, kernel_size=3, padding=1)
        self.pool = nn.AdaptiveAvgPool2d((1, 1))
        self.fc = nn.Linear(8, 16)
    
    def forward(self, x):
        x = self.conv1(x)
        x = self.pool(x)
        x = x.view(x.size(0), -1)
        x = self.fc(x)
        return x

# Create encoder instance
encoder = SimpleEncoder()

# Set up ReLIC arguments
ARGS = {
    'encoder': encoder,
    'proj_out_dim': 64,
    'nesting_dims': None,  # Will be auto-computed from encoder output size
    'proj_in_dim': None,   # Will be auto-computed from encoder output size
    'matryoshka_bias': False
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type ReLIC — 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 ReLIC 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
ResNet Ran
ran on a synthesized input · constructed an object; no result was computed
liyi01827/noisy-contrastive/simsiam/model_factory.py
pointer only (licence: NONE) · get_code("ba93c0af999b7a85")
How it ran

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

ResNet101 Ran
ran; our contract draft was wrong, not the code
liyi01827/noisy-contrastive/simsiam/model_factory.py
pointer only (licence: NONE) · get_code("1d47aaa21a3bb862")
How it ran

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

ResNet152 Ran
ran; our contract draft was wrong, not the code
liyi01827/noisy-contrastive/simsiam/model_factory.py
pointer only (licence: NONE) · get_code("f8d0daa856a02a03")
How it ran

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

ResNet18 Ran
ran; our contract draft was wrong, not the code
liyi01827/noisy-contrastive/simsiam/model_factory.py
pointer only (licence: NONE) · get_code("1c728412af1388f5")
How it ran

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

ResNet18 Ran
ran on a synthesized input · constructed an object; no result was computed
miszkur/SelfSupervisedLearning/models/model.py
pointer only (licence: NONE) · get_code("3df1625e8f0b9699")
How it ran

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

ResNet34 Ran
ran; our contract draft was wrong, not the code
liyi01827/noisy-contrastive/simsiam/model_factory.py
pointer only (licence: NONE) · get_code("a30de131b4f273c8")
How it ran

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

ResNet50 Ran
ran; our contract draft was wrong, not the code
liyi01827/noisy-contrastive/simsiam/model_factory.py
pointer only (licence: NONE) · get_code("d20bc483f371ec97")
How it ran

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

SEM Ran
ran on a synthesized input · constructed an object; no result was computed
lucidrains/byol-pytorch/byol_pytorch/byol_pytorch.py
code served (permissive licence) · get_code("d86a281b947c32ef")
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, SEM: 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 einops import rearrange

torch.manual_seed(0)

# The SEM class expects:
# - dim: an integer that is divisible by dim_simplex
# - temperature: a float (default 0.1)
# - dim_simplex: an integer (default 8)

# For forward(), it expects a tensor t with shape (..., dim)
# where dim is divisible by dim_simplex

ARGS = {
    'dim': 8,
    'temperature': 0.1,
    'dim_simplex': 8,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
einops, torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type SEM — 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 SEM 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
SimSiamMLP Ran
ran; our contract draft was wrong, not the code
lucidrains/byol-pytorch/byol_pytorch/byol_pytorch.py
code served (permissive licence) · get_code("5d81cae15b63b2d0")
How it ran

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

import torch
from torch import nn

torch.manual_seed(0)

def default(val, def_val):
    return def_val if val is None else val

def MaybeSyncBatchnorm(is_distributed=None):
    is_distributed = default(is_distributed, False)
    return nn.SyncBatchNorm if is_distributed else nn.BatchNorm1d

ARGS = {
    "dim": 64,
    "projection_size": 32,
    "hidden_size": 128,
    "sync_batchnorm": False,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type Sequential — a Sequential output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a Sequential output the recorded ndim 1 and dtype family float describe that coercion, not the output, and are not stated
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
SkeletonNet Ran
ran on a synthesized input · constructed an object; no result was computed
reshinthadithyan/BYOL-Pytorch/BYOL.py
code served (permissive licence) · get_code("55863b2dc4aac43d")
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, SkeletonNet: 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
import torchvision.models

torch.manual_seed(0)

# SkeletonNet requires two parameters: Hid and Proj
# Hid: hidden dimension for the MLP
# Proj: projection dimension for the MLP output

Hid = 128
Proj = 64

ARGS = {
    "Hid": Hid,
    "Proj": Proj
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
torch, torchvision — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type SkeletonNet — 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 SkeletonNet 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
TripletLoss Ran
ran on a synthesized input
EchoItLiu/SelfGait/trainer.py
pointer only (licence: NONE) · get_code("e693eee1106320c1")
How it ran

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

TripletSampler Ran
ran on a synthesized input
EchoItLiu/SelfGait/trainer.py
pointer only (licence: NONE) · get_code("c9ab21522dc83e5e")
How it ran

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

conv3x3 Ran
ran; our contract draft was wrong, not the code
liyi01827/noisy-contrastive/simsiam/model_factory.py
pointer only (licence: NONE) · get_code("ec20f22a185cd708")
How it ran

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

cosine_loss_fn Ran
ran; our contract draft was wrong, not the code
lucidrains/byol-pytorch/byol_pytorch/byol_pytorch.py
code served (permissive licence) · get_code("aaecf667988ce174")
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 1, dtype family float, shape (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 torch
import torch.nn.functional as F

torch.manual_seed(0)

def l2norm(t):
    return F.normalize(t, dim=-1, p=2)

def cosine_loss_fn(x, y):
    x = l2norm(x)
    y = l2norm(y)
    return 2 - 2 * (x * y).sum(dim=-1)

# Create two small tensors with batch size 2 and embedding dimension 4
x = torch.randn(2, 4)
y = torch.randn(2, 4)

ARGS = {
    "x": x,
    "y": y,
}
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 1, dtype family float, shape (2,) — shape (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
default Ran
ran, violated the contract we drafted
this paper's copy was not recorded; identical code first harvested from lucidrains/byol-pytorch
pointer only · get_code("1c0f269ae9673b08")
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.

eval_knn Ran
ran; our contract draft was wrong, not the code
htdt/self-supervised/methods/byol.py
pointer only (licence: NONE) · get_code("2ed1c82b5ad2ee9f")
How it ran

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

flatten Ran
ran, honoured the contract we drafted
this paper's copy was not recorded; identical code first harvested from juneweng/byol-pytorch
pointer only · get_code("4daa3e876f494d75")
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_data Ran
ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT)
htdt/self-supervised/methods/byol.py
pointer only (licence: NONE) · get_code("ceeec13af255b5bc")
How it ran

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

get_feature_size Ran
ran, honoured the contract we drafted
filipbasara0/matryoshka-representation-learning/mrl/mrl.py
code served (permissive licence) · get_code("74d6aa7ba8ab5ca6")
How it ran

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

import torch
import torch.nn as nn

torch.manual_seed(0)

class SimpleEncoder(nn.Module):
    """Minimal encoder that takes input and produces feature output."""
    def __init__(self):
        super().__init__()
        self.conv1 = nn.Conv2d(3, 16, kernel_size=3, padding=1)
        self.conv2 = nn.Conv2d(16, 32, kernel_size=3, padding=1)
    
    def forward(self, x):
        x = self.conv1(x)
        x = self.conv2(x)
        return x

encoder = SimpleEncoder()

ARGS = {
    "encoder": encoder
}
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 int, ndim 0, dtype family int, shape () — shape () as a later run recorded it
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
get_head Ran
ran; our contract draft was wrong, not the code
htdt/self-supervised/methods/byol.py
pointer only (licence: NONE) · get_code("2d19f4f3143c2ccf")
How it ran

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

get_module_device Ran
ran; our contract draft was wrong, not the code
this paper's copy was not recorded; identical code first harvested from microsoft/vision-longformer
pointer only · get_code("f8ef5ca2539fcee5")
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_resnet Ran
ran; our contract draft was wrong, not the code
talipucar/PyFlow_BYOL/utils/model_utils.py
pointer only (licence: NONE) · get_code("d35a3394eb6872b1")
How it ran

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

l2norm Ran
ran; our contract draft was wrong, not the code
lucidrains/byol-pytorch/byol_pytorch/byol_pytorch.py
code served (permissive licence) · get_code("09b2eed13fab23fa")
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
import torch.nn.functional as F

torch.manual_seed(0)

# The function l2norm takes a tensor t and normalizes it along the last dimension
# It uses F.normalize with dim=-1 and p=2
# So we need to pass a tensor as the argument 't'

t = torch.randn(2, 4)

ARGS = {
    't': t
}
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
loss_function Ran
ran, honoured the contract we drafted
HibikiJie/BYOL/utiles/loss_function.py
pointer only (licence: NONE) · get_code("d1695fe8fcdca12a")
How it ran

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

loss_function Ran
ran; our contract draft was wrong, not the code
jramapuram/BYOL/objective.py
code served (permissive licence) · get_code("5c93a9f666df290c")
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 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

torch.manual_seed(0)

# The function expects 4 tensors as arguments
# Looking at the function body:
# - regression_loss is called on pairs of tensors
# - It computes norms, element-wise multiplication, and sum over dim=-1
# - So tensors should have at least 2 dimensions (batch, feature)
# - detach() is called on target projections (doesn't affect shape requirements)
# - torch.mean() is called on the result

# Create small tensors: batch_size=2, feature_dim=4
batch_size = 2
feature_dim = 4

online_prediction1 = torch.randn(batch_size, feature_dim)
online_prediction2 = torch.randn(batch_size, feature_dim)
target_projection1 = torch.randn(batch_size, feature_dim)
target_projection2 = torch.randn(batch_size, feature_dim)

ARGS = {
    "online_prediction1": online_prediction1,
    "online_prediction2": online_prediction2,
    "target_projection1": target_projection1,
    "target_projection2": target_projection2,
}
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 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
norm_mse_loss Ran
ran, honoured the contract we drafted
htdt/self-supervised/methods/byol.py
pointer only (licence: NONE) · get_code("a2d406a0a54489bf")
How it ran

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

partLoss Ran
ran; our contract draft was wrong, not the code
Kennethborup/BYOL/BYOL/byol.py
code served (permissive licence) · get_code("2fc1e20b19ae6392")
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 Tensor, ndim 1, dtype family float, shape (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 torch

torch.manual_seed(0)

# Create small tensors for x and y
# The function normalizes them and computes a loss based on their dot product
# Batch size: 2, Feature dimension: 4
x = torch.randn(2, 4)
y = torch.randn(2, 4)

ARGS = {
    "x": x,
    "y": y,
}
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 Tensor, ndim 1, dtype family float, shape (2,) — shape (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

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

Also present in other papers' code

Of 79 samples lifted from this paper's linked repositories, 79 carry a function identity and 0 do not. Of the 79 distinct functions with an identity, 13 are also present in other papers whose code we hold (7 with at least one paper dated earlier, 1 the same month, 12 later) and 66 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
conv3x3
brick of this paper's assembly: helper
686 other papers
226 dated earlier, 11 the same month, 448 later, 1 same year, order not determinable · 31 only as an assembly brick
1406.2661 (2014-06)
Generative Adversarial Networks
1409.0575 (2014-09)
ImageNet Large Scale Visual Recognition Challenge
1412.6572 (2014-12)
Explaining and Harnessing Adversarial Examples
and 683 more not named here
default
brick of this paper's assembly: helper
11 other papers
11 later
2010.10241 (2020-10)
BYOL works even without batch statistics
2011.10043 (2020-11)
Propagate Yourself: Exploring Pixel-Level Consistency for Unsupervised Visual Representation Learning
2102.06810 (2021-02)
Understanding self-supervised Learning Dynamics without Contrastive Pairs
and 8 more not named here
flatten
brick of this paper's assembly: helper
9 other papers
9 later · 1 only as an assembly brick
2010.10241 (2020-10)
BYOL works even without batch statistics
2103.03230 (2021-03)
Barlow Twins: Self-Supervised Learning via Redundancy Reduction
2103.06695 (2021-03)
BYOL for Audio: Self-Supervised Learning for General-Purpose Audio Representation
and 6 more not named here
singleton
brick of this paper's assembly: helper
8 other papers
8 later
2010.10241 (2020-10)
BYOL works even without batch statistics
2103.06695 (2021-03)
BYOL for Audio: Self-Supervised Learning for General-Purpose Audio Representation
2110.03414 (2021-10)
SERAB: A multi-lingual benchmark for speech emotion recognition
and 5 more not named here
get_module_device
brick of this paper's assembly: helper
5 other papers
5 later · 3 only as an assembly brick
2102.12122 (2021-02)
Pyramid Vision Transformer: A Versatile Backbone for Dense Prediction without Convolutions
2103.15358 (2021-03)
Multi-Scale Vision Longformer: A New Vision Transformer for High-Resolution Image Encoding
2206.12038 (2022-06)
BYOL-S: Learning Self-supervised Speech Representations by Bootstrapping
and 2 more not named here
get_head
brick of this paper's assembly: model
4 other papers
1 dated earlier, 3 later · 2 only as an assembly brick
2002.05709 (2020-02)
A Simple Framework for Contrastive Learning of Visual Representations
2105.10123 (2021-05)
Backdoor Attacks on Self-Supervised Learning
2303.09079 (2023-03)
SSL-Cleanse: Trojan Detection and Mitigation in Self-Supervised Learning
and 1 more not named here
EMA
brick of this paper's assembly: update_rule
3 other papers
3 later · 3 only as an assembly brick
2105.05682 (2021-05)
Multi-Scale Contrastive Siamese Networks for Self-Supervised Graph Representation Learning
2204.04385 (2022-04)
Divergence-aware Federated Self-Supervised Learning
2206.12038 (2022-06)
BYOL-S: Learning Self-supervised Speech Representations by Bootstrapping
eval_knn
brick of this paper's assembly: helper
2 other papers
1 dated earlier, 1 later · 2 only as an assembly brick
2002.05709 (2020-02)
A Simple Framework for Contrastive Learning of Visual Representations
2408.08533 (2024-08)
Adv-SSL: Adversarial Self-Supervised Representation Learning with Theoretical Guarantees
eval_sgd
brick of this paper's assembly: helper
2 other papers
1 dated earlier, 1 later · 1 only as an assembly brick
2002.05709 (2020-02)
A Simple Framework for Contrastive Learning of Visual Representations
2408.08533 (2024-08)
Adv-SSL: Adversarial Self-Supervised Representation Learning with Theoretical Guarantees
get_data
brick of this paper's assembly: helper
2 other papers
1 dated earlier, 1 later · 2 only as an assembly brick
2002.05709 (2020-02)
A Simple Framework for Contrastive Learning of Visual Representations
2408.08533 (2024-08)
Adv-SSL: Adversarial Self-Supervised Representation Learning with Theoretical Guarantees
get_model
brick of this paper's assembly: model
2 other papers
1 dated earlier, 1 later · 1 only as an assembly brick
2002.05709 (2020-02)
A Simple Framework for Contrastive Learning of Visual Representations
2105.10123 (2021-05)
Backdoor Attacks on Self-Supervised Learning
norm_mse_loss
brick of this paper's assembly: helper
2 other papers
2 later · 1 only as an assembly brick
2105.00470 (2021-05)
On Feature Decorrelation in Self-Supervised Learning
2305.16789 (2023-05)
Modulate Your Spectrum in Self-Supervised Learning
BaseMethod
brick of this paper's assembly: model
1 other paper
1 dated earlier · 1 only as an assembly brick
2002.05709 (2020-02)
A Simple Framework for Contrastive Learning of Visual Representations

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

We introduce Bootstrap Your Own Latent (BYOL), a new approach to self-supervised image representation learning. BYOL relies on two neural networks, referred to as online and target networks, that interact and learn from each other. From an augmented view of an image, we train the online network to predict the target network representation of the same image under a different augmented view. At the same time, we update the target network with a slow-moving average of the online network. While state-of-the art methods rely on negative pairs, BYOL achieves a new state of the art without them. BYOL reaches 74.3% top-1 classification accuracy on ImageNet using a linear evaluation with a ResNet-50 architecture and 79.6% with a larger ResNet. We show that BYOL performs on par or better than the current state of the art on both transfer and semi-supervised benchmarks. Our implementation and pretrained models are given on GitHub. 3 * Equal contribution; the order of first authors was randomly selected.

For agents

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

get_harvested_code_for_paper("2006.07733")
get_code_for_paper("2006.07733")
have("2006.07733")

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

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

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

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

Connect an agent — have() is free.