Barlow Twins：基于冗余减少原则的自监督学习

概述

Barlow Twins是由Meta AI团队在ICML 2021提出的自监督学习方法¹。其核心思想来源于神经科学的冗余减少原则（Redundancy Reduction Principle）——生物视觉系统通过减少神经元之间的冗余来学习有效的表示。

特性	Barlow Twins	SimCLR	BYOL
负样本	不需要	必须	不需要
批量大小	可小	需大	中等
损失函数	互相关矩阵	InfoNCE	MSE
理论基础	冗余减少	对比学习	预测学习

1. 核心思想

1.1 冗余减少原则

Barlow Twins的灵感来自David Barlow提出的”冗余减少假说”：

“The goal of sensory processing is to recode the incoming sensory signals in such a way as to reduce the redundancy while preserving as much as possible of the information about the environment.”

在神经网络中，这意味着：

不变性：同一图像的不同视图应该产生相同表示
非冗余：不同神经元应该编码不同的信息

1.2 互相关矩阵

Barlow Twins通过构建**互相关矩阵（Cross-Correlation Matrix）**来实现这一目标：

C = \frac{1}{B} i = 1 \sum B \frac{z _{i}^{(1)} ( z _{i}^{(2)} ) ^{T}}{∥ z _{i}^{(1)} ∥∥ z _{i}^{(2)} ∥}

其中：

$z_{i}^{(1)}, z_{i}^{(2)}$ 是样本 $i$ 在两个视图上的投影表示
$B$ 是批量大小
$C$ 是 $D \times D$ 的矩阵， $D$ 是投影维度

理想情况下， $C$ 应该：

对角线元素 = 1（每个神经元对自身视图是不变的）
非对角线元素 = 0（不同神经元之间无冗余）

2. 数学形式化

2.1 损失函数

Barlow Twins损失函数包含两项：

L = 不变性项 i \sum (1 - C_{ii})^{2} + λ 冗余减少项 i \sum j \neq = i \sum C_{ij}^{2}

不变性项（Invariance Term）

L_{inv} = i \sum (1 - C_{ii})^{2}

这一项鼓励同一图像的两个视图具有相似的表示，使对角线元素接近1。

冗余减少项（Redundancy Reduction Term）

L_{red} = i \sum j \neq = i \sum C_{ij}^{2}

这一项惩罚不同神经元之间的相关性，使非对角线元素接近0。

2.2 网络架构

输入图像 x
    ↓
数据增强 → 视图1 x^1    数据增强 → 视图2 x^2
    ↓                       ↓
骨干网络 f               骨干网络 f
(共享权重)                (共享权重)
    ↓                       ↓
投影头 g                  投影头 g
(共享权重)                (共享权重)
    ↓                       ↓
  z^1 (D维)              z^2 (D维)
    ↓                       ↓
  ℂ ←────── 计算 ──────→ ℂ
    ↓
损失函数 L

关键设计：

骨干网络和投影头在两个视图间共享权重
只有输入视图不同

2.3 归一化与维度

投影输出 $z$ 通常具有较低维度（如128-2048维），并且使用逐通道归一化：

\overset{z}{^}_{i} = \frac{z _{i}}{∥ z _{i} ∥}

3. PyTorch实现

import torch
import torch.nn as nn
import torch.nn.functional as F
from torchvision.models import resnet50
 
 
class BarlowTwins(nn.Module):
    """Barlow Twins模型"""
    def __init__(self, backbone, proj_dim=2048, latent_dim=128, lambd=5e-3):
        super().__init__()
        self.lambd = lambd
        
        # 骨干网络
        self.backbone = backbone
        
        # 投影头：两层MLP + 归一化层
        # 注意：输出维度等于latent_dim，用于计算互相关矩阵
        self.projector = nn.Sequential(
            nn.Linear(backbone.output_dim, proj_dim),
            nn.BatchNorm1d(proj_dim),
            nn.ReLU(inplace=True),
            nn.Linear(proj_dim, latent_dim),
            # 不再使用BatchNorm，而是在损失中归一化
        )
    
    def forward(self, x1, x2):
        """
        Args:
            x1: 视图1
            x2: 视图2
        Returns:
            loss: Barlow Twins损失
            C: 互相关矩阵
        """
        # 提取表示
        z1 = self.projector(self.backbone(x1))
        z2 = self.projector(self.backbone(x2))
        
        # 逐样本归一化
        z1 = F.normalize(z1, dim=1)
        z2 = F.normalize(z2, dim=1)
        
        # 计算互相关矩阵
        C = self.compute_cross_correlation(z1, z2)
        
        # 计算损失
        loss = self.barlow_twins_loss(C)
        
        return loss, C
    
    def compute_cross_correlation(self, z1, z2):
        """计算互相关矩阵"""
        batch_size = z1.size(0)
        device = z1.device
        
        # 按批量计算互相关
        # C[i,j] = (1/B) * sum_b (z1_b[i] * z2_b[j])
        C = torch.mm(z1.T, z2) / batch_size
        
        return C
    
    def barlow_twins_loss(self, C):
        """Barlow Twins损失"""
        # 不变性项：对角线元素应该接近1
        invariance_loss = torch.sum((1 - torch.diag(C)) ** 2)
        
        # 冗余减少项：非对角线元素应该接近0
        redundancy_loss = torch.sum(C ** 2) - torch.sum(torch.diag(C) ** 2)
        
        # 总损失
        loss = invariance_loss + self.lambd * redundancy_loss
        
        return loss
 
 
class BarlowTwinsLoss(nn.Module):
    """独立的Barlow Twins损失模块"""
    def __init__(self, lambd=5e-3):
        super().__init__()
        self.lambd = lambd
    
    def forward(self, z1, z2):
        """
        Args:
            z1, z2: 归一化后的投影表示 [B, D]
        """
        # 互相关矩阵
        C = torch.mm(z1.T, z2) / z1.size(0)
        
        # 不变性损失
        diag = torch.diag(C)
        invariance_loss = torch.sum((1 - diag) ** 2)
        
        # 冗余减少损失
        off_diag = C - torch.diag(diag)
        redundancy_loss = torch.sum(off_diag ** 2)
        
        return invariance_loss + self.lambd * redundancy_loss
 
 
def train_barlow_twins(model, train_loader, optimizer, epochs=100, device='cuda'):
    """训练循环"""
    model = model.to(device)
    model.train()
    
    for epoch in range(epochs):
        total_loss = 0
        for batch_idx, (images, _) in enumerate(train_loader):
            images = images.to(device)
            
            # 创建两个视图
            x1 = augment(images)
            x2 = augment(images)
            
            # 前向传播
            loss, C = model(x1, x2)
            
            # 反向传播
            optimizer.zero_grad()
            loss.backward()
            optimizer.step()
            
            total_loss += loss.item()
        
        # 打印对角线元素（表示不变性）
        with torch.no_grad():
            print(f"Epoch {epoch+1}: Loss = {total_loss / len(train_loader):.4f}")
 
 
def augment(x):
    """数据增强"""
    from torchvision import transforms
    
    return transforms.Compose([
        transforms.RandomResizedCrop(224, scale=(0.08, 1.0)),
        transforms.RandomHorizontalFlip(),
        transforms.ColorJitter(0.4, 0.4, 0.4, 0.1),
        transforms.RandomGrayscale(p=0.1),
        transforms.GaussianBlur(kernel_size=23, sigma=(0.1, 2.0)),
        transforms.ToTensor(),
        transforms.Normalize(mean=[0.485, 0.456, 0.406],
                           std=[0.229, 0.224, 0.225])
    ])(x)

4. 与其他方法的对比

4.1 方法论对比

方法	核心机制	负样本	批量依赖
SimCLR	对比正负样本对	必须	高
MoCo	动量编码器+队列	必须	低
BYOL	预测目标网络	不需要	中等
SwAV	在线聚类	不需要	中等
Barlow Twins	冗余减少	不需要	低

4.2 批量大小影响

Barlow Twins的一个关键优势是对批量大小不敏感：

批量大小	SimCLR	Barlow Twins
256	66.4%	68.2%
512	69.1%	68.6%
2048	71.7%	69.5%
4096	73.8%	69.7%

注：ImageNet Top-1线性评估准确率

4.3 互相关矩阵可视化

训练良好的Barlow Twins模型产生的互相关矩阵：

理想状态:
┌─────────────────────┐
│ 1   0   0   0   0  │  ← 对角线 = 1
│ 0   1   0   0   0  │
│ 0   0   1   0   0  │
│ 0   0   0   1   0  │
│ 0   0   0   0   1  │
└─────────────────────┘

5. 理论分析

5.1 为什么冗余减少有效？

冗余减少背后的直觉：

信息最大化：当不同神经元编码独立信息时，总信息量最大化
效率编码：生物神经系统使用稀疏、高效的编码
下游任务：非冗余表示更容易被线性分类器利用

5.2 超参数 λ 的影响

参数 $λ$ 控制不变性和冗余减少之间的权衡：

λ 值	效果
太小	表示可能包含冗余
太大	可能破坏对角线约束
推荐值	5e-3 到 1e-2

5.3 投影维度选择

投影维度	性能	内存
256	中等	低
1024	良好	中等
2048	最佳	高

6. 实验结果

6.1 ImageNet线性评估

方法	Top-1准确率	Top-5准确率
Barlow Twins	73.2%	91.0%
SimCLR	71.7%	90.1%
BYOL	74.3%	91.6%
MoCo v2	71.1%	-
Supervised	76.5%	93.1%

6.2 迁移学习

Barlow Twins在多个下游任务上表现出色：

数据集	任务类型	Barlow Twins	Supervised
CIFAR-10	分类	98.0%	98.5%
CIFAR-100	分类	88.2%	88.9%
ImageNet	检测	67.4%	68.5%
VOC	分割	74.8%	75.4%

7. 实践技巧

7.1 数据增强

Barlow Twins使用的增强与SimCLR类似：

BARLOW_TWINS_AUGMENTATION = transforms.Compose([
    transforms.RandomResizedCrop(224, scale=(0.08, 1.0)),
    transforms.RandomHorizontalFlip(),
    transforms.ColorJitter(brightness=0.4, contrast=0.4, 
                          saturation=0.4, hue=0.1),
    transforms.RandomGrayscale(p=0.1),  # 概率较低
    transforms.GaussianBlur(kernel_size=23, 
                           sigma=(0.1, 2.0)),  # 关键增强
    transforms.ToTensor(),
    transforms.Normalize(mean=[0.485, 0.456, 0.406],
                       std=[0.229, 0.224, 0.225])
])

7.2 超参数配置

参数	推荐值
投影维度	2048
输出维度	128-8192
λ	5e-3
学习率	0.05 (LARS)
批量大小	256-4096
温度（可选）	0.07

7.3 LARS优化器

原论文使用LARS优化器：

from torchlars import LARS
 
optimizer = LARS(
    model.parameters(),
    lr=0.05 * (batch_size / 256),
    weight_decay=1e-6,
    momentum=0.9
)

8. 变体与扩展

8.1 VicregL

VicregL将Barlow Twins的思想扩展到局部表示，用于密集预测任务。

8.2 Whitening

使用**白化（Whitening）**操作替代BatchNorm，提高稳定性。

8.3 iBot变体

iBot将Barlow Twins的思想与掩码图像建模结合。

9. 总结

Barlow Twins的核心贡献：

理论基础：首次将神经科学的冗余减少原则形式化
无需负样本：通过互相关矩阵实现
批量无关：对批量大小不敏感
简单高效：损失函数仅包含两个简单项

Barlow Twins证明了统计独立性是学习好表示的有效目标，为自监督学习提供了新的理论视角。

参考

Zbontar, J., et al. (2021). “Barlow Twins: Self-Supervised Learning via Redundancy Reduction”. ICML 2021. arXiv:2103.03230 ↩

Metaphor

探索

Barlow Twins：基于冗余减少原则的自监督学习

概述

1. 核心思想

1.1 冗余减少原则

1.2 互相关矩阵

2. 数学形式化

2.1 损失函数

不变性项（Invariance Term）

冗余减少项（Redundancy Reduction Term）

2.2 网络架构

2.3 归一化与维度

3. PyTorch实现

4. 与其他方法的对比

4.1 方法论对比

4.2 批量大小影响

4.3 互相关矩阵可视化

5. 理论分析

5.1 为什么冗余减少有效？

5.2 超参数 λ 的影响

5.3 投影维度选择

6. 实验结果

6.1 ImageNet线性评估

6.2 迁移学习

7. 实践技巧

7.1 数据增强

7.2 超参数配置

7.3 LARS优化器

8. 变体与扩展

8.1 VicregL

8.2 Whitening

8.3 iBot变体

9. 总结

参考

关系图谱

目录

反向链接

Metaphor

探索

Barlow Twins：基于冗余减少原则的自监督学习

概述

1. 核心思想

1.1 冗余减少原则

1.2 互相关矩阵

2. 数学形式化

2.1 损失函数

不变性项（Invariance Term）

冗余减少项（Redundancy Reduction Term）

2.2 网络架构

2.3 归一化与维度

3. PyTorch实现

4. 与其他方法的对比

4.1 方法论对比

4.2 批量大小影响

4.3 互相关矩阵可视化

5. 理论分析

5.1 为什么冗余减少有效？

5.2 超参数 λ 的影响

5.3 投影维度选择

6. 实验结果

6.1 ImageNet线性评估

6.2 迁移学习

7. 实践技巧

7.1 数据增强

7.2 超参数配置

7.3 LARS优化器

8. 变体与扩展

8.1 VicregL

8.2 Whitening

8.3 iBot变体

9. 总结

参考

Footnotes

关系图谱

目录

反向链接