[PYTHON] Contrastive Learning에서 Negative Sample 개수 최적화 방법과 임베딩 품질 차이 해결 전략 7가지

InfoNCE (Information Noise Contrastive Estimation)

 

최근 자기지도 학습(Self-Supervised Learning)의 핵심 기술로 자리 잡은 대조 학습(Contrastive Learning)은 라벨이 없는 방대한 데이터로부터 고차원의 의미론적 특징을 추출하는 데 탁월한 성능을 보입니다. 이 프로세스의 핵심은 "유사한 것은 가깝게, 다른 것은 멀게" 배치하는 것입니다. 여기서 가장 논쟁적인 주제 중 하나가 바로 네거티브 샘플(Negative Samples)의 개수입니다. 샘플이 부족하면 모델이 변별력을 잃고, 너무 많으면 연산 비용이 기하급수적으로 증가하며 'Hard Negative'에 의한 학습 불안정이 발생합니다. 본 포스팅에서는 네거티브 샘플 수가 임베딩 공간의 구조적 품질(Alignment & Uniformity)에 미치는 영향을 심층 분석하고, 실무에서 마주하는 성능 저하 문제를 해결하기 위한 파이썬 기반의 구현 전략 7가지를 상세히 다룹니다.

---

1. 네거티브 샘플 수와 임베딩 품질의 상관관계

대조 학습의 손실 함수인 InfoNCE(Information Noise Contrastive Estimation) 수식을 살펴보면, 분모에 포함된 네거티브 샘플의 개수가 확률 밀도 추정의 정확도를 결정함을 알 수 있습니다. 샘플 수가 많아질수록 모델은 잠재 공간(Latent Space)에서 데이터의 분포를 더욱 균일하게(Uniformity) 퍼뜨리는 압력을 받게 됩니다.

주요 지표 비교: 품질과 비용의 균형

분석 항목	적은 개수 (Small Batch)	적정 개수 (Balanced)	매우 많은 개수 (Large/Memory Bank)
임베딩 분포	특정 방향으로 쏠림 (Collapse 위험)	의미론적 군집 형성	공간 전체에 고르게 분포
변별력 (Discrimination)	낮음 (쉬운 문제만 해결)	높음 (세밀한 차이 구분)	최상 (Hard Negative 탐색 가능)
학습 안정성	매우 안정적	안정적	불안정 (Gradient Noise 증가)
GPU 메모리 점유	낮음	중간	매우 높음 (해결책 필요)
대표 알고리즘	SimCLR (Small Batch)	SimCLR (Large Batch)	MoCo, PIRL (Memory Bank)

---

2. 실무 해결을 위한 파이썬 실전 예제 (7가지 전략)

네거티브 샘플의 한계를 극복하고 임베딩 품질을 극대화할 수 있는 실무 개발자용 PyTorch 기반 예제입니다. 복사하여 프로젝트의 손실 함수나 데이터 로더 부분에 바로 적용할 수 있습니다.

Example 1: InfoNCE 손실 함수 기본 구현

네거티브 샘플 개수를 매개변수로 받아 조절할 수 있는 표준 대조 손실 함수입니다.

import torch
import torch.nn.functional as F

def info_nce_loss(features, batch_size, temperature=0.07, n_negatives=None):
    # features: [2*batch_size, dim] (Positive pairs stacked)
    labels = torch.cat([torch.arange(batch_size) for i in range(2)], dim=0)
    labels = (labels.unsqueeze(0) == labels.unsqueeze(1)).float()
    
    features = F.normalize(features, dim=1)
    similarity_matrix = torch.matmul(features, features.T)
    
    # 자기 자신 제거
    mask = torch.eye(labels.shape[0], dtype=torch.bool)
    labels = labels[~mask].view(labels.shape[0], -1)
    similarity_matrix = similarity_matrix[~mask].view(similarity_matrix.shape[0], -1)
    
    # Positive 선별
    positives = similarity_matrix[labels.bool()].view(labels.shape[0], -1)
    # Negative 선별 (n_negatives 개수만큼 샘플링 가능)
    negatives = similarity_matrix[~labels.bool()].view(similarity_matrix.shape[0], -1)
    
    if n_negatives:
        negatives = negatives[:, :n_negatives]

    logits = torch.cat([positives, negatives], dim=1)
    logits /= temperature
    
    target_labels = torch.zeros(logits.shape[0], dtype=torch.long).to(features.device)
    return F.cross_entropy(logits, target_labels)
    

Example 2: Memory Bank를 활용한 대량의 Negative 유지 방법

GPU 메모리 한계를 극복하기 위해 과거 배치들의 임베딩을 저장하여 네거티브 샘플로 재활용합니다.

class MemoryBank:
    def __init__(self, size, dim, device):
        self.bank = torch.randn(size, dim).to(device)
        self.bank = F.normalize(self.bank, dim=1)
        self.ptr = 0
        self.size = size

    def update(self, features):
        batch_size = features.size(0)
        out_ptr = self.ptr + batch_size
        if out_ptr <= self.size:
            self.bank[self.ptr:out_ptr] = features.detach()
        else:
            self.bank[self.ptr:] = features.detach()[:self.size-self.ptr]
        self.ptr = out_ptr % self.size

    def get_negatives(self):
        return self.bank
    

Example 3: Hard Negative Mining (품질 개선 핵심)

단순한 네거티브보다 임베딩 거리가 가까운 '어려운' 샘플에 가중치를 두어 변별력을 높입니다.

def hard_negative_mining_loss(positives, negatives, tau_plus=0.1, beta=1.0):
    # Debiased Contrastive Learning 개념 적용
    # negatives: [batch_size, num_negatives]
    neg_exp = torch.exp(negatives / 0.07)
    
    # Hard negative 가중치 계산
    imp = (beta * neg_exp).softmax(dim=-1)
    reweighted_neg = (imp * neg_exp).sum(dim=-1)
    
    loss = -torch.log(torch.exp(positives / 0.07) / (torch.exp(positives / 0.07) + reweighted_neg))
    return loss.mean()
    

Example 4: 배치 크기에 따른 Temperature($\tau$) 동적 스케일링

네거티브 샘플 수가 변할 때 손실 함수의 민감도를 조절하여 임베딩 붕괴(Collapse)를 방지합니다.

def get_dynamic_temp(n_negatives, base_temp=0.07):
    # 샘플 수가 많아질수록 분포가 뾰족해지므로 온도 조절이 필요할 수 있음
    # 실무적으로 log scale에 비례하여 미세 조정
    import math
    return base_temp * (1.0 + 0.1 * math.log(n_negatives / 256))
    

Example 5: Momentum Encoder를 이용한 Negative 일관성 확보

MoCo(Momentum Contrast) 방식처럼 네거티브 샘플을 생성하는 인코더를 서서히 업데이트하여 품질을 안정화합니다.

@torch.no_grad()
def momentum_update(model_q, model_k, m=0.999):
    for param_q, param_k in zip(model_q.parameters(), model_k.parameters()):
        param_k.data = param_k.data * m + param_q.data * (1. - m)
    

Example 6: Mixed Precision 기반 Large Batch 학습

물리적인 네거티브 샘플 수를 늘리기 위해 메모리 효율을 극대화하는 기법입니다.

from torch.cuda.amp import GradScaler, autocast

scaler = GradScaler()
def train_step(model, images, optimizer):
    with autocast():
        features = model(images)
        loss = info_nce_loss(features, batch_size=images.size(0)//2)
    
    scaler.scale(loss).backward()
    scaler.step(optimizer)
    scaler.update()
    

Example 7: Uniformity와 Alignment 지표 측정

네거티브 샘플 수가 임베딩 품질에 미치는 영향을 수치적으로 모니터링합니다.

def validate_embedding_quality(features, p_features):
    # Alignment: Positive pair 간의 거리 (낮을수록 좋음)
    align = (features - p_features).norm(p=2, dim=1).pow(2).mean()
    
    # Uniformity: 전체 임베딩의 가우시안 커널 밀도 (낮을수록 좋음)
    dist = torch.pdist(features, p=2).pow(2)
    uniform = dist.mul(-2).exp().mean().log()
    
    return align.item(), uniform.item()
    

---

3. 결론: 최적의 네거티브 샘플 구성을 위한 가이드

실험적 데이터에 따르면 네거티브 샘플의 개수는 다익익선(More is Better)인 경우가 많으나, 특정 임계점(보통 4,096~65,536개)을 넘어서면 성능 향상 폭이 둔화됩니다. 이때부터는 양보다 질(Hardness)에 집중해야 합니다.

임베딩 품질을 높이려면 다음 단계를 권장합니다.

1. GPU가 허용하는 최대 배치 크기로 시작하십시오.
2. 메모리가 부족하다면 Example 2의 Memory Bank나 Example 5의 Momentum Encoder를 도입하십시오.
3. 모델이 빠르게 수렴하지만 검증 성능이 낮다면 Example 3의 Hard Negative Mining을 통해 학습 난이도를 높이십시오.

---

참고 문헌 및 출처

• Chen, T., et al. "A Simple Framework for Contrastive Learning of Visual Representations." ICML 2020.
• He, K., et al. "Momentum Contrast for Unsupervised Visual Representation Learning." CVPR 2020.
• Wang, T., & Isola, P. "Understanding Contrastive Representation Learning through Alignment and Uniformity on the Hypersphere." ICML 2020.
• PyTorch Official Documentation (torch.nn.functional).