Bootstrap Your Own Latent (BYOL) is a self-supervised architecture that trains an online network to predict the output of a target momentum network on an augmented view of the same image, entirely without using negative pairs. The online network uses an additional predictor MLP to map its representation to the target's projection, and the target network's weights are updated via an exponential moving average of the online network's parameters.
Glossary
BYOL

What is BYOL?
Bootstrap Your Own Latent (BYOL) is a self-supervised learning algorithm that trains a neural network to produce high-quality representations without relying on negative pairs, a common requirement in contrastive learning.
BYOL prevents representation collapse—where all inputs map to a constant vector—through the asymmetry introduced by the predictor and the stop-gradient operation on the target network, rather than by repelling dissimilar samples. This design makes BYOL more robust to small batch sizes and less dependent on carefully curated negative examples compared to frameworks like SimCLR or MoCo, achieving state-of-the-art results on ImageNet linear evaluation benchmarks.
Key Features of BYOL
Bootstrap Your Own Latent (BYOL) achieves state-of-the-art self-supervised representation learning without relying on negative pairs, using a dual-network architecture and a predictor to prevent collapse.
Online and Target Networks
BYOL employs two interacting neural networks: an online network and a target network. The online network is trained to predict the target network's representation of the same image under a different augmented view. The target network is not updated via backpropagation; instead, its weights are an exponential moving average (EMA) of the online network's weights, providing a stable regression target.
The Predictor MLP
A critical architectural component that prevents representation collapse. The online network appends a shallow Multi-Layer Perceptron (MLP) called the predictor to its encoder output. The loss is computed between the predictor's output and the target network's projection. This asymmetric design—where the target network lacks a predictor—ensures the learning task is not trivially solved by the identity function.
Negative-Free Learning
Unlike SimCLR or MoCo, BYOL does not require negative pairs. It discards the contrastive paradigm entirely. The model learns by minimizing the L2 distance between the online network's prediction and the target network's projection of a positive pair. This eliminates the engineering complexity of hard negative mining and large batch sizes, making training more robust to batch composition.
Stop-Gradient Operation
The target network receives no gradient updates. A stop-gradient operation is applied to the target branch, preventing the loss from being minimized by simply making both networks output identical vectors. This forces the online network to learn meaningful representations by predicting a slowly evolving target, a mechanism later generalized in architectures like SimSiam.
Loss Function: L2 Regression
BYOL uses a simple mean squared error (L2 loss) between the L2-normalized prediction vector and the L2-normalized target projection vector. This is a regression objective, not a classification or contrastive one. The loss is symmetrized by feeding each augmented view through both the online and target networks, doubling the training signal per image.
Empirical Performance
BYOL matches or exceeds the linear evaluation accuracy of supervised pre-training on ImageNet. With a ResNet-50 encoder, BYOL achieves 74.3% top-1 accuracy (linear eval), surpassing SimCLR and MoCo v2. When scaled to larger ResNet-200 architectures, it reaches 79.6%, demonstrating that negative pairs are not a necessity for state-of-the-art self-supervised learning.
BYOL vs. Other Self-Supervised Methods
Comparing the core mechanisms, collapse prevention strategies, and data requirements of Bootstrap Your Own Latent against other leading self-supervised learning frameworks.
| Feature | BYOL | SimCLR | MoCo v2 |
|---|---|---|---|
Negative Pairs Required | |||
Momentum Encoder | |||
Predictor MLP | |||
Collapse Prevention Mechanism | Asymmetric architecture with stop-gradient | Large batch size with NT-Xent loss | Momentum encoder with dynamic queue |
Batch Size Dependency | Low (works with 256-512) | High (requires 4096+) | Low (works with 256) |
Memory Bank or Queue | |||
Stop-Gradient Operation | |||
ImageNet Top-1 Accuracy (Linear Eval) | 74.3% | 70.0% | 71.1% |
Enabling Efficiency, Speed & Accuracy
Intelligent Analysis, Decision & Execution
We build AI systems for teams that need search across company data, workflow automation across tools, or AI features inside products and internal software.
Talk to Us
Search across company data
Give teams answers from docs, tickets, runbooks, and product data with sources and permissions.
Useful when people spend too long searching or get different answers from different systems.

Automate internal workflows
Use AI to route work, draft outputs, trigger actions, and keep approvals and logs in place.
Useful when repetitive work moves across multiple tools and teams.

Add AI to products and internal tools
Build assistants, guided actions, or decision support into the software your team or customers already use.
Useful when AI needs to be part of the product, not a separate tool.
Frequently Asked Questions
Clear, technical answers to the most common questions about Bootstrap Your Own Latent (BYOL), the self-supervised learning architecture that achieves state-of-the-art representations without relying on negative pairs.
Bootstrap Your Own Latent (BYOL) is a self-supervised representation learning architecture that trains an online network to predict the output of a target network (a momentum encoder) applied to a different augmented view of the same image, without using any negative examples. The architecture consists of two identical neural networks: the online network, which includes an encoder, a projector, and a predictor MLP, and the target network, which has only an encoder and a projector. During training, two augmented views are created from the same image. The online network processes one view and attempts to predict the target network's representation of the other view. The target network's weights are updated via an exponential moving average (EMA) of the online network's weights, not by backpropagation. Crucially, BYOL prevents representation collapse—where the encoder outputs a constant vector—by using the asymmetric predictor on the online side, which breaks the symmetry between the two branches and ensures the learning objective is meaningful without requiring negative pairs to push representations apart.
Related Terms
Explore the core architectures and mechanisms that define modern self-supervised representation learning, from negative-pair methods to collapse prevention strategies.
Momentum Encoder
A slowly evolving copy of the main encoder network updated via exponential moving average (EMA). In BYOL, the target network acts as a momentum encoder, providing stable regression targets for the online network. Unlike MoCo, BYOL does not use a memory bank of negative samples; the momentum encoder's stability alone, combined with the predictor MLP, prevents representation collapse.
SimSiam
Simple Siamese networks that explore the hypothesis that stop-gradient operations are the critical component for preventing collapse, rather than momentum encoders or negative pairs. SimSiam directly predicts the output of a shared-weight encoder without a momentum target, demonstrating that the predictor MLP and stop-gradient on one branch are sufficient to avoid trivial solutions.
Representation Collapse
A failure mode in contrastive and self-supervised learning where the encoder maps all inputs to a constant or highly similar output vector, trivializing the loss function. BYOL avoids collapse through an asymmetric architecture: the online network has a predictor MLP that the target network lacks, and the target network is updated via exponential moving average rather than backpropagation.
InfoNCE
Information Noise-Contrastive Estimation, a loss function based on categorical cross-entropy that identifies a positive pair among a set of negative samples. BYOL fundamentally differs from InfoNCE-based methods like SimCLR by eliminating negative pairs entirely, relying instead on a bootstrapping mechanism where the online network predicts the target network's representation.
DINO
Self-DIstillation with NO labels, a framework where a student network learns to match the output of a momentum teacher network. Like BYOL, DINO uses a teacher-student architecture without negative pairs, but adds sharpening and centering operations on the teacher outputs to prevent collapse, making it particularly effective for Vision Transformers.
Barlow Twins
A redundancy-reduction objective that learns representations by making the cross-correlation matrix of two distorted views close to the identity matrix. Unlike BYOL's predictive approach, Barlow Twins prevents collapse by explicitly decorrelating vector components, pushing off-diagonal elements of the correlation matrix toward zero while keeping diagonal elements near one.

About the author
Prasad Kumkar
CEO & MD, Inference Systems
Prasad Kumkar is the CEO & MD of Inference Systems and writes about AI systems architecture, LLM infrastructure, model serving, evaluation, and production deployment. Over 5+ years, he has worked across computer vision models, L5 autonomous vehicle systems, and LLM research, with a focus on taking complex AI ideas into real-world engineering systems.
His work and writing cover AI systems, large language models, AI agents, multimodal systems, autonomous systems, inference optimization, RAG, evaluation, and production AI engineering.
Partnered with leading AI, data, and software stack.
How We Work
Custom AI workflows for your Business
One-fit-all AI don't work for modern businesses. At Inferensys, we aim to understand your business & custom requirements; which we use to define most efficient agentic workflows, the data, and the tools for your business.
01
Review the use case
We understand the task, the users, and where AI can actually help.
Read more02
Pick the right approach
We define what needs search, automation, or product integration.
Read more03
Build the first useful version
We implement the part that proves the value first.
Read more04
Improve from there
We add the checks and visibility needed to keep it useful.
Read moreThe first call is a practical review of your use case and the right next step.
Talk to Us