BCL对比学习从入门到实战：原理剖析与代码实现

1次阅读

共计 2276 个字符，预计需要花费 6 分钟才能阅读完成。

对比学习（Contrastive Learning）是自监督学习的重要分支，通过让模型学习相似样本之间的共性和差异，无需人工标注即可提取有效特征。然而，对于初学者来说，实现 BCL（Barlow Contrastive Learning）存在以下常见难点：

负样本构建困难 ：传统的对比学习方法（如 SimCLR）需要大量负样本，而 BCL 通过避免样本对之间的冗余来简化这一过程。
损失函数复杂 ：BCL 的损失函数涉及协方差矩阵的计算，初学者可能难以理解其数学原理。
调参敏感 ：超参数（如学习率、batch size）对模型性能影响较大，初学者容易陷入局部最优。

方法	是否需要负样本	损失函数复杂度	计算开销
SimCLR	是	中等	高
MoCo	是	中等	中
BCL	否	高	低

BCL 的核心思想是通过最小化特征之间的冗余来学习有意义的表示。其损失函数分为两部分：

不变性项（Invariance Term）：
$$
\mathcal{L}{inv} = \sum_i (1 – C)^2
$$
这一项确保同一图像的不同增强视图在特征空间中保持相似。
冗余减少项（Redundancy Reduction Term）：
$$
\mathcal{L}{red} = \sum^2
$$
这一项通过惩罚非对角线元素来减少特征之间的冗余。} C_{ij

最终损失函数为两者的加权和：
$$
\mathcal{L} = \lambda \mathcal{L}{inv} + \mu \mathcal{L}
$$

import torchvision.transforms as transforms

train_transform = transforms.Compose([transforms.RandomResizedCrop(32),
    transforms.RandomHorizontalFlip(),
    transforms.ToTensor(),])

import torch.nn as nn

class Encoder(nn.Module):
    def __init__(self):
        super().__init__()
        self.conv1 = nn.Conv2d(3, 64, kernel_size=3, stride=1, padding=1)
        self.bn1 = nn.BatchNorm2d(64)
        self.relu = nn.ReLU()
        self.pool = nn.MaxPool2d(2, 2)
        self.fc = nn.Linear(64 * 16 * 16, 128)

    def forward(self, x):
        x = self.pool(self.relu(self.bn1(self.conv1(x))))
        x = x.view(x.size(0), -1)
        x = self.fc(x)
        return x

def barlow_loss(z1, z2, lambda_inv=1.0, lambda_red=1.0):
    N, D = z1.shape
    z1 = (z1 - z1.mean(0)) / z1.std(0)
    z2 = (z2 - z2.mean(0)) / z2.std(0)
    C = torch.mm(z1.T, z2) / N

    invariance = torch.sum((1 - torch.diag(C)) ** 2)
    redundancy = torch.sum(C ** 2) - torch.sum(torch.diag(C) ** 2)
    loss = lambda_inv * invariance + lambda_red * redundancy
    return loss

model = Encoder()
optimizer = torch.optim.Adam(model.parameters(), lr=0.001)

for epoch in range(100):
    for x, _ in train_loader:
        x1, x2 = train_transform(x), train_transform(x)
        z1, z2 = model(x1), model(x2)
        loss = barlow_loss(z1, z2)
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()

Batch Size: 256
Learning Rate: 0.001
Epochs: 100
Optimizer: Adam

使用 t -SNE 将学习到的特征降维到 2D 空间，可以看到不同类别的样本在特征空间中形成了明显的簇。