LightlySSL 是一个用于自监督学习的计算机视觉框架。

• 文档
• Github
• Discord

如需功能更丰富的商业版本，包括 Docker 支持以及针对嵌入、分类、检测和分割任务的一键式预训练模型，请联系 sales@lightly.ai。

我们还在此基础上构建了一个完整的平台，提供了主动学习和数据整理等附加功能。如果您对 Lightly Worker 解决方案感兴趣，该方案可轻松处理数百万个样本，并在您的数据上运行强大的算法，请访问 lightly.ai。立即开始使用完全免费！

新闻 🚀

• 2026年3月23日 - 欢迎查看我们的最新开源项目 LightlyStudio，它能让您轻松地可视化、标注和管理数据！🔍
• 2025年4月15日 - 我们很高兴地宣布，现在只需几行代码即可利用自监督学习和蒸馏预训练！通过我们的新项目 LightlyTrain，我们致力于让自监督学习变得更加易用。快去那里开始使用，为您的模型注入强大动力吧！⚡️

    

特性

该自监督学习框架提供以下特性：

• 模块化框架，公开了损失函数和模型头部等底层构建模块。
• 使用简单，采用类似 PyTorch 的风格编写。
• 支持自监督预训练的自定义骨干网络模型。
• 支持使用 PyTorch Lightning 进行分布式训练。

支持的模型

您可以在这里找到所有支持模型的示例代码。[https://docs.lightly.ai/self-supervised-learning/examples/models.html] 我们为所有模型提供了 PyTorch、PyTorch Lightning 和 PyTorch Lightning 分布式训练的示例，帮助您快速启动项目。

模型：

模型	年份	论文	文档	Colab (PyTorch)	Colab (PyTorch Lightning)
AIM	2024	论文	文档
Barlow Twins	2021	论文	文档
BYOL	2020	论文	文档
DCL & DCLW	2021	论文	文档
DenseCL	2021	论文	文档
DINO	2021	论文	文档
DINOv2	2023	论文	文档
iBOT	2021	论文	文档
MAE	2021	论文	文档
MSN	2022	论文	文档
MoCo	2019	论文	文档
NNCLR	2021	论文	文档
PMSN	2022	论文	文档
SimCLR	2020	论文	文档
SimMIM	2022	论文	文档
SimSiam	2021	论文	文档
SwaV	2020	论文	文档
VICReg	2021	论文	文档

教程

想直接跳到教程，看看 Lightly 的实际应用吗？

• 在 CIFAR-10 数据集上训练 MoCo
• 在服装数据集上训练 SimCLR
• 在卫星图像上训练 SimSiam
• 使用自定义增强技术与 Lightly 配合
• 用 Lightly 预训练 Detectron2 的主干网络
• 微调 Lightly 检查点
• 将 timm 模型用作主干网络

社区和合作伙伴项目：

• 在 ARM 微控制器上使用 Lightly 进行设备端深度学习

快速入门

Lightly 需要 Python 3.7+。我们建议在 Linux 或 OSX 环境中安装 Lightly。目前尚不支持 Python 3.13，因为 PyTorch 本身尚未兼容 Python 3.13。

依赖项

由于 Lightly 包的模块化特性，部分模块可以与较旧版本的依赖项一起使用。然而，为了使用当前的所有功能，Lightly 需要以下依赖项：

• PyTorch ≥ 1.11.0
• Torchvision ≥ 0.12.0
• PyTorch Lightning ≥ 1.7.1

Lightly 与 PyTorch 和 PyTorch Lightning v2.0 及以上版本兼容！

安装

您可以通过 PyPI 安装 Lightly 及其依赖项：

pip3 install lightly

我们强烈建议将 Lightly 安装在一个专用的 virtualenv 中，以避免与系统包发生冲突。

Lightly 实战

借助 Lightly，您可以以模块化的方式使用最新的自监督学习方法，并充分利用 PyTorch 的强大功能。尝试不同的主干网络、模型和损失函数。该框架从设计之初就注重易用性。更多示例请参阅我们的文档。

import torch
import torchvision

from lightly import loss
from lightly import transforms
from lightly.data import LightlyDataset
from lightly.models.modules import heads


# 创建一个用于 SimCLR 模型的 PyTorch 模块。
class SimCLR(torch.nn.Module):
    def __init__(self, backbone):
        super().__init__()
        self.backbone = backbone
        self.projection_head = heads.SimCLRProjectionHead(
            input_dim=512,  # Resnet18 特征有 512 维。
            hidden_dim=512,
            output_dim=128,
        )

    def forward(self, x):
        features = self.backbone(x).flatten(start_dim=1)
        z = self.projection_head(features)
        return z


# 使用来自 torchvision 的 resnet 主干网络。
backbone = torchvision.models.resnet18()
# 忽略分类头，因为我们只想要特征。
backbone.fc = torch.nn.Identity()

# 构建 SimCLR 模型。
model = SimCLR(backbone)

# 准备一个为每张图片生成多个随机视图的变换。
transform = transforms.SimCLRTransform(input_size=32, cj_prob=0.5)


# 从您的图像文件夹创建数据集。
dataset = LightlyDataset(input_dir="./my/cute/cats/dataset/", transform=transform)

# 构建一个 PyTorch 数据加载器。
dataloader = torch.utils.data.DataLoader(
    dataset,  # 将数据集传递给数据加载器。
    batch_size=128,  # 较大的批量有助于学习。
    shuffle=True,  # 打乱顺序很重要！
)

# Lightly 提供了诸如损失函数之类的构建模块。
criterion = loss.NTXentLoss(temperature=0.5)

# 获取一个 PyTorch 优化器。
optimizer = torch.optim.SGD(model.parameters(), lr=0.1, weight_decay=1e-6)

# 训练模型。
for epoch in range(10):
    for (view0, view1), targets, filenames in dataloader:
        z0 = model(view0)
        z1 = model(view1)
        loss = criterion(z0, z1)
        loss.backward()
        optimizer.step()
        optimizer.zero_grad()
        print(f"loss: {loss.item():.5f}")

您只需更换模型和损失函数，即可轻松使用其他模型，例如 SimSiam。

# 用于 SimSiam 模型的 PyTorch 模块。
class SimSiam(torch.nn.Module):
    def __init__(self, backbone):
        super().__init__()
        self.backbone = backbone
        self.projection_head = heads.SimSiamProjectionHead(512, 512, 128)
        self.prediction_head = heads.SimSiamPredictionHead(128, 64, 128)

    def forward(self, x):
        features = self.backbone(x).flatten(start_dim=1)
        z = self.projection_head(features)
        p = self.prediction_head(z)
        z = z.detach()
        return z, p


model = SimSiam(backbone)

# 使用 SimSiam 的损失函数。
criterion = loss.NegativeCosineSimilarity()

您可以在 这里找到更完整的 SimSiam 示例。

使用 PyTorch Lightning 训练模型：

from pytorch_lightning import LightningModule, Trainer

class SimCLR(LightningModule):
    def __init__(self):
        super().__init__()
        resnet = torchvision.models.resnet18()
        resnet.fc = torch.nn.Identity()
        self.backbone = resnet
        self.projection_head = heads.SimCLRProjectionHead(512, 512, 128)
        self.criterion = loss.NTXentLoss()

    def forward(self, x):
        features = self.backbone(x).flatten(start_dim=1)
        z = self.projection_head(features)
        return z

    def training_step(self, batch, batch_index):
        (view0, view1), _, _ = batch
        z0 = self.forward(view0)
        z1 = self.forward(view1)
        loss = self.criterion(z0, z1)
        return loss

    def configure_optimizers(self):
        optim = torch.optim.SGD(self.parameters(), lr=0.06)
        return optim


model = SimCLR()
trainer = Trainer(max_epochs=10, devices=1, accelerator="gpu")
trainer.fit(model, dataloader)

有关完整的 PyTorch Lightning 示例，请参阅 我们的文档。

或者在 4 张 GPU 上训练模型：

# 使用分布式版本的损失函数。
criterion = loss.NTXentLoss(gather_distributed=True)

trainer = Trainer(
    max_epochs=10,
    devices=4,
    accelerator="gpu",
    strategy="ddp",
    sync_batchnorm=True,
    use_distributed_sampler=True,  # 或者对于 PyTorch Lightning <2.0，使用 replace_sampler_ddp=True
)
trainer.fit(model, dataloader)

我们提供了多 GPU 训练示例，支持分布式 gather 和同步 BatchNorm。 请查看我们的分布式训练文档。

基准测试

已实现的模型及其在不同数据集上的性能。超参数并未针对最高准确率进行调优。如需查看详细结果及更多关于基准测试的信息，请点击 此处。

ImageNet1k

ImageNet1k 基准测试

注意：评估设置基于以下论文：

• 线性评估：SimCLR
• 微调：SimCLR
• KNN：InstDisc

有关详细信息，请参阅 基准测试脚本。

模型	主干网络	批量大小	轮数	线性评估 Top1	微调 Top1	kNN Top1	TensorBoard	检查点
BarlowTwins	Res50	256	100	62.9	72.6	45.6	链接	链接
BYOL	Res50	256	100	62.5	74.5	46.0	链接	链接
DINO	Res50	128	100	68.2	72.5	49.9	链接	链接
DINO	ViT-S/16	128	100	73.3	79.8	67.5	链接	链接
iBOT	ViT-S/16	128	100	72.2	78.3	65.4	链接	链接
MAE	ViT-B/16	256	100	46.0	81.3	11.2	链接	链接
MoCoV2	Res50	256	100	61.5	74.3	41.8	链接	链接
SimCLR*	Res50	256	100	63.2	73.9	44.8	链接	链接
SimCLR* + DCL	Res50	256	100	65.1	73.5	49.6	链接	链接
SimCLR* + DCLW	Res50	256	100	64.5	73.2	48.5	链接	链接
SwAV	Res50	256	100	67.2	75.4	49.5	链接	链接
TiCo	Res50	256	100	49.7	72.7	26.6	链接	链接
VICReg	Res50	256	100	63.0	73.7	46.3	链接	链接

*我们采用平方根学习率缩放而非线性缩放，因为对于较小的批量大小，前者能带来更好的效果。详见 SimCLR 论文 的附录 B.1。

ImageNet100

ImageNet100 benchmarks detailed results

Imagenette

Imagenette benchmarks detailed results

CIFAR-10

CIFAR-10 benchmarks detailed results

Terminology

Below you can see a schematic overview of the different concepts in the package. The terms in bold are explained in more detail in our documentation.

Next Steps

Head to the documentation and see the things you can achieve with Lightly!

Development

To install dev dependencies (for example to contribute to the framework) you can use the following command:

pip3 install -e ".[dev]"

For more information about how to contribute have a look here.

Running Tests

Unit tests are within the tests directory and we recommend running them using pytest. There are two test configurations available. By default, only a subset will be run:

make test-fast

To run all tests (including the slow ones) you can use the following command:

make test

To test a specific file or directory use:

pytest <path to file or directory>

Code Formatting

To format code with black and isort run:

make format

Further Reading

Self-Supervised Learning:

• Have a look at our #papers channel on discord for the newest self-supervised learning papers.
• A Cookbook of Self-Supervised Learning, 2023
• Masked Autoencoders Are Scalable Vision Learners, 2021
• Emerging Properties in Self-Supervised Vision Transformers, 2021
• Unsupervised Learning of Visual Features by Contrasting Cluster Assignments, 2021
• What Should Not Be Contrastive in Contrastive Learning, 2020
• A Simple Framework for Contrastive Learning of Visual Representations, 2020
• Momentum Contrast for Unsupervised Visual Representation Learning, 2020

FAQ

• Why should I care about self-supervised learning? Aren't pre-trained models from ImageNet much better for transfer learning?

  • Self-supervised learning has become increasingly popular among scientists over the last years because the learned representations perform extraordinarily well on downstream tasks. This means that they capture the important information in an image better than other types of pre-trained models. By training a self-supervised model on your dataset, you can make sure that the representations have all the necessary information about your images.

• How can I contribute?

  • Create an issue if you encounter bugs or have ideas for features we should implement. You can also add your own code by forking this repository and creating a PR. More details about how to contribute with code is in our contribution guide.

• Is this framework for free?

  • Yes, this framework is completely free to use and we provide the source code. We believe that we need to make training deep learning models more data efficient to achieve widespread adoption. One step to achieve this goal is by leveraging self-supervised learning. The company behind Lightly is committed to keep this framework open-source.

• If this framework is free, how is the company behind Lightly making money?

  • Training self-supervised models is only one part of our solution. The company behind Lightly focuses on processing and analyzing embeddings created by self-supervised models. By building, what we call a self-supervised active learning loop we help companies understand and work with their data more efficiently. As the Lightly Solution is a freemium product, you can try it out for free. However, we will charge for some features.
  • In any case this framework will always be free to use, even for commercial purposes.

Lightly in Research

• DINOv2-3D: Self-Supervised 3D Vision Transformer Pretraining
• Joint-Embedding vs Reconstruction: Provable Benefits of Latent Space Prediction for Self-Supervised Learning, 2025
• Reverse Engineering Self-Supervised Learning, 2023
• Learning Visual Representations via Language-Guided Sampling, 2023
• Self-Supervised Learning Methods for Label-Efficient Dental Caries Classification, 2022
• DPCL: Contrastive representation learning with differential privacy, 2022
• Decoupled Contrastive Learning, 2021
• solo-learn: A Library of Self-supervised Methods for Visual Representation Learning, 2021

Company behind this Open Source Framework

Lightly is a spin-off from ETH Zurich that helps companies build efficient active learning pipelines to select the most relevant data for their models.

You can find out more about the company and it's services by following the links below:

• Homepage
• LightlyTrain
• Web-App
• Lightly Solution Documentation (Lightly Worker & API)
• Lightly's AwesomeSSL (collection of SSL papers)

Back to top🚀

LightlySSL 快速上手指南

LightlySSL 是一个用于自监督学习（Self-Supervised Learning, SSL）的计算机视觉框架。它提供了模块化的构建块（如损失函数和模型头），风格类似 PyTorch，并支持基于 PyTorch Lightning 的分布式训练。

1. 环境准备

在开始之前，请确保您的开发环境满足以下要求：

• 操作系统: Linux, macOS 或 Windows
• Python: 3.7 或更高版本
• 核心依赖:
  • PyTorch (建议最新版本)
  • torchvision
  • PyTorch Lightning (可选，用于分布式训练示例)

提示：如果您使用 GPU 进行训练，请确保已正确安装对应版本的 CUDA 驱动和 PyTorch GPU 版本。

2. 安装步骤

您可以直接通过 PyPI 安装 Lightly。为了获得更快的下载速度，推荐使用国内镜像源（如清华大学开源软件镜像站）。

使用 pip 安装

pip install lightly -i https://pypi.tuna.tsinghua.edu.cn/simple

验证安装

安装完成后，您可以在 Python 中运行以下命令验证是否成功：

import lightly
print(lightly.__version__)

3. 基本使用

Lightly 的设计遵循 PyTorch 风格，您可以像定义普通神经网络一样定义自监督学习方法。以下是一个使用 SimCLR 算法进行自监督预训练的最简示例。

步骤 1: 准备数据加载器

首先，您需要定义数据增强策略并创建 DataLoader。Lightly 提供了常用的变换组合。

import torch
from torch.utils.data import DataLoader
from torchvision import datasets
from torchvision.transforms import transforms

import lightly

# 定义 SimCLR 风格的数据增强
transform = transforms.Compose([
    transforms.RandomResizedCrop(224),
    transforms.RandomHorizontalFlip(),
    transforms.ColorJitter(0.8, 0.8, 0.8, 0.2),
    transforms.ToTensor(),
    transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))
])

# 加载数据集 (以 CIFAR10 为例)
dataset = datasets.CIFAR10(root='./data', train=True, download=True, transform=transform)
dataloader = DataLoader(dataset, batch_size=64, shuffle=True, num_workers=4)

步骤 2: 定义模型与自监督方法

选择一个骨干网络（Backbone）并将其包装在自监督方法中。

import torch.nn as nn
from lightly.models import ResNetGenerator
from lightly.loss import NTXentLoss
from lightly.methods import SimCLR

# 1. 创建骨干网络 (例如 ResNet-18)
backbone = ResNetGenerator('resnet-18', 1)
last_conv_channels = list(backbone.children())[-1].in_features

# 2. 创建投影头 (Projection Head)
projection_head = lightly.models.modules.heads.SimCLRProjectionHead(
    input_dim=last_conv_channels,
    hidden_dim=last_conv_channels,
    output_dim=128
)

# 3. 组合成 SimCLR 方法
model = SimCLR(backbone, projection_head)

# 4. 定义损失函数
criterion = NTXentLoss()

步骤 3: 设置优化器并开始训练

您可以直接使用 PyTorch 的原生训练循环，或者使用 PyTorch Lightning（推荐）来简化流程。以下是原生 PyTorch 的训练循环示例：

device = "cuda" if torch.cuda.is_available() else "cpu"
model.to(device)
optimizer = torch.optim.SGD(model.parameters(), lr=0.01, momentum=0.9, weight_decay=1e-6)

model.train()
for epoch in range(10):
    total_loss = 0
    for batch_idx, (x0, x1), _ in enumerate(dataloader):
        x0 = x0.to(device)
        x1 = x1.to(device)
        
        # 前向传播
        z0, z1 = model(x0, x1)
        
        # 计算损失
        loss = criterion(z0, z1)
        
        # 反向传播
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()
        
        total_loss += loss.item()
        
    print(f"Epoch {epoch}: Loss = {total_loss / len(dataloader):.4f}")

print("训练完成！模型权重已更新。")

下一步

• 更多模型: Lightly 支持 Barlow Twins, BYOL, DINO, MoCo, MAE 等多种主流 SSL 算法。
• PyTorch Lightning: 查看官方文档中的 examples/notebooks/pytorch_lightning 目录，获取基于 Lightning 的分布式训练示例。
• 预训练模型: 访问 Lightly 文档 获取各模型的详细代码和 Colab 演示。