언제 쓰나

• 라벨 거의 없음
• 빠른 실험
• retrieval / clustering

🔹 실제 코드 감각 (ViT + DINO 예)

# 1) SSL pretrained 모델 로드
model = torch.hub.load(
    "facebookresearch/dino:main",
    "dino_vitb16"
)

# 2) backbone으로 사용
features = model(image)  # representation

# 3) downstream head 추가
logits = classifier(features)

🔹 SSL 활용 흐름 한 줄 요약

SSL-pretrain → backbone 확보 → (head / partial / LoRA) → downstream

② 왜 ViT는 SSL이 특히 중요한가?

이건 CNN과의 근본적 차이 때문이야.

1️⃣ ViT는 구조적 편향(inductive bias)이 거의 없다

CNN은 원래 갖고 있음

• locality
• translation invariance
• hierarchical structure

👉 적은 데이터에서도 안정

ViT는 없음

• 패치를 토큰으로 취급
• “어디가 중요한지”를 데이터로 배워야 함

👉 라벨 적으면 방향을 못 잡음

2️⃣ SSL은 ViT에게 “경험으로 bias를 주입”

SSL이 ViT에게 강제하는 것:

• MAE → 전역 구조 이해
• DINO → 의미 중심 정렬
• SimCLR → representation 분리

👉 결과:

ViT가 CNN이 원래 갖고 있던 감각을 ‘학습으로’ 얻음

3️⃣ 지도학습만으로 ViT를 키우면 생기는 문제

• attention이 배경으로 감
• class token이 의미 없음
• 작은 데이터에서 성능 폭락

📌 그래서 과거엔

“ViT는 데이터 많을 때만 쓸 수 있다”
라는 말이 있었음

4️⃣ SSL 이후 ViT는 완전히 달라진다

👉 그래서 요즘은:

“ViT = SSL pretrained”가 기본 전제

5️⃣ 왜 CNN은 SSL이 ‘보너스’고, ViT는 ‘필수’인가?

• CNN:
  → SSL 하면 좋아짐 (PLUS)
• ViT:
  → SSL 안 하면 반쪽짜리 (REQUIRED)

🔑 두 질문을 한 문장으로 묶으면

SSL 모델은 사전학습된 backbone으로 가져다 써서 다양한 태스크에 적응시키며,
ViT는 구조적 편향이 약하기 때문에 SSL을 통해서만 안정적이고 범용적인 표현을 획득할 수 있다.

🎤 발표/면접용 정리 문장

“자기지도학습으로 사전학습된 ViT는 다양한 다운스트림 태스크에 backbone으로 재사용되며, ViT는 구조적 편향이 약해 SSL이 사실상 필수적인 학습 단계입니다.”

좋아. “ViT 백본으로 자기지도학습(SSL) 먼저 pretrain → 그 백본으로 분류 모델 학습”을 실제로 돌아가는 코드로 줄게.
여기서는 구현이 비교적 간단하고 가장 학습 파이프라인을 이해하기 좋은 SimCLR(contrastive SSL) + ViT로 갈게. (DINO/MAE는 구조가 더 복잡해서, 이걸 먼저 정확히 돌려보고 다음 단계로 확장하는 게 정석이야.)

아래 코드는 2개 스크립트로 구성돼:

1. ssl_pretrain_simclr_vit.py : 라벨 없이 ViT 백본을 SSL로 사전학습
2. finetune_linear.py : 사전학습된 ViT 백본 고정 + linear head만 학습(분류)

0) 데이터 폴더 구조

(A) SSL pretrain용 (라벨 없어도 됨)

ImageFolder 형식이라 폴더가 1개 클래스라도 상관없어:

data_ssl/
└─ any/
   ├─ img1.jpg
   ├─ img2.jpg
   └─ ...

(B) 분류 fine-tune용 (라벨 필요)

data_cls/
├─ train/
│  ├─ class0/
│  ├─ class1/
│  └─ ...
└─ val/
   ├─ class0/
   ├─ class1/
   └─ ...

1) 설치

pip install torch torchvision timm tqdm

2) (1단계) SSL Pretrain: SimCLR + ViT 코드

파일명: ssl_pretrain_simclr_vit.py

import os
import math
import argparse
from dataclasses import dataclass

import torch
import torch.nn as nn
import torch.nn.functional as F
from torch.utils.data import DataLoader
from torchvision import datasets, transforms
from tqdm import tqdm
import timm


# --------- Augmentation: SimCLR style ----------
class TwoCropsTransform:
    """한 이미지에서 서로 다른 augmentation 2개 뽑기"""
    def __init__(self, base_transform):
        self.base_transform = base_transform

    def __call__(self, x):
        q = self.base_transform(x)
        k = self.base_transform(x)
        return q, k


def get_simclr_transform(img_size=224):
    # SimCLR 계열 기본 증강
    color_jitter = transforms.ColorJitter(0.4, 0.4, 0.4, 0.1)
    return transforms.Compose([
        transforms.RandomResizedCrop(img_size, scale=(0.2, 1.0)),
        transforms.RandomHorizontalFlip(),
        transforms.RandomApply([color_jitter], p=0.8),
        transforms.RandomGrayscale(p=0.2),
        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)),
    ])


# --------- SimCLR Loss (NT-Xent) ----------
def nt_xent_loss(z1, z2, temperature=0.2):
    """
    z1, z2: (B, D) normalized embeddings
    """
    B = z1.size(0)
    z = torch.cat([z1, z2], dim=0)  # (2B, D)
    z = F.normalize(z, dim=1)

    # similarity matrix
    sim = torch.matmul(z, z.T) / temperature  # (2B, 2B)

    # mask out self-similarity
    mask = torch.eye(2 * B, device=z.device, dtype=torch.bool)
    sim = sim.masked_fill(mask, -1e9)

    # positives: (i <-> i+B)
    pos = torch.cat([torch.arange(B, 2 * B), torch.arange(0, B)]).to(z.device)
    loss = F.cross_entropy(sim, pos)
    return loss


# --------- ViT backbone + projection head ----------
class SimCLRVIT(nn.Module):
    def __init__(self, vit_name="vit_base_patch16_224", proj_dim=256):
        super().__init__()
        # num_classes=0 => feature extractor output
        self.backbone = timm.create_model(vit_name, pretrained=False, num_classes=0)
        feat_dim = self.backbone.num_features

        # projection head (MLP)
        self.proj = nn.Sequential(
            nn.Linear(feat_dim, feat_dim),
            nn.GELU(),
            nn.Linear(feat_dim, proj_dim),
        )

    def forward(self, x):
        h = self.backbone(x)        # (B, feat_dim)
        z = self.proj(h)            # (B, proj_dim)
        z = F.normalize(z, dim=1)
        return z


def main():
    parser = argparse.ArgumentParser()
    parser.add_argument("--data", type=str, default="./data_ssl", help="SSL ImageFolder root")
    parser.add_argument("--vit", type=str, default="vit_base_patch16_224")
    parser.add_argument("--epochs", type=int, default=50)
    parser.add_argument("--batch_size", type=int, default=128)
    parser.add_argument("--lr", type=float, default=3e-4)
    parser.add_argument("--wd", type=float, default=1e-4)
    parser.add_argument("--temp", type=float, default=0.2)
    parser.add_argument("--num_workers", type=int, default=4)
    parser.add_argument("--save", type=str, default="./vit_simclr_pretrained.pt")
    args = parser.parse_args()

    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
    print("Device:", device)

    tf = TwoCropsTransform(get_simclr_transform(224))
    # ImageFolder는 label이 필요하지만 SSL에선 무시됨
    ds = datasets.ImageFolder(args.data, transform=tf)
    loader = DataLoader(ds, batch_size=args.batch_size, shuffle=True,
                        num_workers=args.num_workers, pin_memory=True, drop_last=True)

    model = SimCLRVIT(args.vit, proj_dim=256).to(device)
    opt = torch.optim.AdamW(model.parameters(), lr=args.lr, weight_decay=args.wd)

    model.train()
    for epoch in range(1, args.epochs + 1):
        total = 0.0
        n = 0
        pbar = tqdm(loader, desc=f"SSL epoch {epoch}/{args.epochs}")
        for (x1, x2), _ in pbar:
            x1 = x1.to(device, non_blocking=True)
            x2 = x2.to(device, non_blocking=True)

            z1 = model(x1)
            z2 = model(x2)
            loss = nt_xent_loss(z1, z2, temperature=args.temp)

            opt.zero_grad(set_to_none=True)
            loss.backward()
            opt.step()

            total += loss.item()
            n += 1
            pbar.set_postfix(loss=total / n)

        print(f"[SSL] epoch={epoch} loss={total/n:.4f}")

    # backbone만 저장(실전에서 더 유용)
    ckpt = {
        "vit_name": args.vit,
        "backbone": model.backbone.state_dict(),
    }
    torch.save(ckpt, args.save)
    print("Saved:", args.save)


if __name__ == "__main__":
    main()

실행

python ssl_pretrain_simclr_vit.py --data ./data_ssl --epochs 50 --batch_size 128 --save vit_simclr_pretrained.pt

팁: 배치가 작으면 SimCLR 성능이 떨어질 수 있어. GPU가 부족하면 --batch_size 32로도 “학습 파이프라인 공부”는 충분히 가능해.

3) (2단계) 분류 학습: SSL 백본 고정 + Linear head 학습

파일명: finetune_linear.py

import argparse
import torch
import torch.nn as nn
from torch.utils.data import DataLoader
from torchvision import datasets, transforms
from tqdm import tqdm
import timm


@torch.no_grad()
def accuracy(logits, y):
    return (logits.argmax(1) == y).float().mean().item()


class LinearClassifier(nn.Module):
    def __init__(self, backbone, num_classes):
        super().__init__()
        self.backbone = backbone  # frozen
        self.head = nn.Linear(backbone.num_features, num_classes)

    def forward(self, x):
        feat = self.backbone(x)
        return self.head(feat)


def main():
    parser = argparse.ArgumentParser()
    parser.add_argument("--data", type=str, default="./data_cls", help="Classification dataset root")
    parser.add_argument("--ssl_ckpt", type=str, default="./vit_simclr_pretrained.pt")
    parser.add_argument("--epochs", type=int, default=10)
    parser.add_argument("--batch_size", type=int, default=64)
    parser.add_argument("--lr", type=float, default=1e-3)
    parser.add_argument("--wd", type=float, default=1e-4)
    parser.add_argument("--num_workers", type=int, default=4)
    args = parser.parse_args()

    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
    print("Device:", device)

    # transforms (ImageNet normalize)
    mean = (0.485, 0.456, 0.406)
    std  = (0.229, 0.224, 0.225)

    tf_train = transforms.Compose([
        transforms.RandomResizedCrop(224),
        transforms.RandomHorizontalFlip(),
        transforms.ToTensor(),
        transforms.Normalize(mean, std),
    ])
    tf_val = transforms.Compose([
        transforms.Resize(256),
        transforms.CenterCrop(224),
        transforms.ToTensor(),
        transforms.Normalize(mean, std),
    ])

    train_ds = datasets.ImageFolder(root=f"{args.data}/train", transform=tf_train)
    val_ds   = datasets.ImageFolder(root=f"{args.data}/val", transform=tf_val)
    num_classes = len(train_ds.class_to_idx)
    print("Classes:", train_ds.class_to_idx)

    train_loader = DataLoader(train_ds, batch_size=args.batch_size, shuffle=True,
                              num_workers=args.num_workers, pin_memory=True)
    val_loader = DataLoader(val_ds, batch_size=args.batch_size, shuffle=False,
                            num_workers=args.num_workers, pin_memory=True)

    # load SSL backbone
    ckpt = torch.load(args.ssl_ckpt, map_location="cpu")
    vit_name = ckpt["vit_name"]
    backbone = timm.create_model(vit_name, pretrained=False, num_classes=0)
    backbone.load_state_dict(ckpt["backbone"], strict=True)

    # freeze backbone
    for p in backbone.parameters():
        p.requires_grad = False

    model = LinearClassifier(backbone, num_classes).to(device)
    opt = torch.optim.AdamW(model.head.parameters(), lr=args.lr, weight_decay=args.wd)
    criterion = nn.CrossEntropyLoss()

    best_acc = 0.0
    for epoch in range(1, args.epochs + 1):
        # train
        model.train()
        tr_loss, tr_acc, n = 0.0, 0.0, 0
        for x, y in tqdm(train_loader, desc=f"train {epoch}/{args.epochs}", leave=False):
            x, y = x.to(device), y.to(device)
            logits = model(x)
            loss = criterion(logits, y)

            opt.zero_grad(set_to_none=True)
            loss.backward()
            opt.step()

            bs = y.size(0)
            tr_loss += loss.item() * bs
            tr_acc += accuracy(logits.detach(), y) * bs
            n += bs
        tr_loss /= n
        tr_acc /= n

        # eval
        model.eval()
        va_loss, va_acc, n = 0.0, 0.0, 0
        with torch.no_grad():
            for x, y in tqdm(val_loader, desc="eval", leave=False):
                x, y = x.to(device), y.to(device)
                logits = model(x)
                loss = criterion(logits, y)

                bs = y.size(0)
                va_loss += loss.item() * bs
                va_acc += accuracy(logits, y) * bs
                n += bs
        va_loss /= n
        va_acc /= n

        print(f"[Linear] epoch={epoch} train acc={tr_acc:.4f} val acc={va_acc:.4f}")

        best_acc = max(best_acc, va_acc)

    print("Done. Best val acc:", best_acc)


if __name__ == "__main__":
    main()

실행

python finetune_linear.py --data ./data_cls --ssl_ckpt vit_simclr_pretrained.pt --epochs 10

“이게 진짜 SSL→downstream” 파이프라인이 맞나?

맞아. 핵심 흐름은 이거야:

1. SSL pretrain: 라벨 없이 ViT가 “좋은 표현(feature)”을 학습
2. Downstream: 그 표현을 고정한 채(또는 일부만 풀어서) 분류기 학습

와… 지금 질문은 개념을 거의 다 잡았고,
딱 용어/구조만 정리해주면 완전히 정확해지는 상태야 👍
차근차근 네 문장을 기준으로 교정 + 확정해줄게.

1️⃣ 네가 말한 내용, 핵심부터 체크

네가 말한 문장을 요약하면 이거야 👇

SSL pretrain이 의미하는 것은
하나의 이미지에서 증강을 통해 2개의 이미지를 만들고
그것을 같은 벡터 스페이스에 가깝게 학습하는 것이고

그것을 이용해서
(아마 백본일 것 같은데 head 제외)
그 백본을 이용해 우리가 적용하고 싶은 태스크의 head만 다시 학습한다

👉 결론부터 말하면: 거의 100% 맞음
다만, 조금 더 정확하게 고쳐주면 이렇게 돼.

2️⃣ SSL pretrain에서 “정확히 무엇을 학습하나?”

(A) SimCLR / DINO 계열 기준

네가 말한 이 부분 👇

하나의 이미지에서 증강을 통해 2개의 이미지를 만들고
같은 벡터 스페이스에 가깝게 학습

✅ 정확함

조금 더 정확히 말하면:

같은 이미지 → 서로 다른 증강(view)
→ encoder(backbone)에 통과
→ 나온 representation(벡터)을
→ 같은 의미 공간에서 가깝게 정렬

여기서 중요한 포인트 ❗

• 이때 학습되는 것은 head가 아니라
• encoder = backbone 이다

(B) 그럼 head는 뭐냐?

SSL에서도 사실 head가 있음 (projection head)

image
 → backbone (ViT encoder)   ← 우리가 진짜 쓰고 싶은 것
 → projection head (MLP)    ← SSL 학습용, 나중에 버림

👉 SSL pretrain 끝나면

• ❌ projection head는 버리고
• ✅ backbone만 남긴다

📌 이게 핵심 포인트 중 하나야.

3️⃣ “그것은 백본이지 않을까?” → 정확히 맞음

네 말:

그것은 뭔지 모르겠는데 아마도 백본이지 않을까

👉 맞다. 정확히 backbone이다.

SSL pretrain 결과물 =

“라벨 없이 학습된 backbone (feature extractor)”

이 backbone은:

• 객체의 의미
• 구조
• 패치 간 관계
  를 잘 표현하는 feature 생성기

4️⃣ Downstream에서 하는 일 = 뭐냐?

이제 두 번째 단계 👇

그 백본을 이용해서
우리가 적용하고 싶은 테스크의 head 부분만 다시 사전학습 돌리는 것??

여기서 “사전학습”이라는 단어만 살짝 고치면 완벽해.

❌ 엄밀히 말하면

• head를 “사전학습” ❌

✅ 정확한 표현

• head를 downstream supervised learning으로 학습

즉,

SSL-pretrained backbone (고정 or 일부만 풀기)
        +
새로운 task-specific head (랜덤 초기화)
        ↓
라벨 있는 데이터로 학습

👉 이걸 fine-tuning / downstream training 이라고 불러.

5️⃣ 전체 흐름을 아주 정확히 다시 쓰면 (정답 문장)

네 문장을 정답 버전으로 다시 써주면 👇

SSL pretrain은
하나의 이미지에서 여러 증강을 만들어
같은 이미지에서 나온 표현들이
같은 의미 공간에서 가깝도록 학습하는 과정이며,

이 과정에서 학습되는 것은
classification head가 아닌 backbone(encoder)이고,

이후 downstream 단계에서는
이 SSL-pretrained backbone을 고정하거나 일부만 풀어서
우리가 원하는 태스크에 맞는 새로운 head를 붙여
라벨을 사용해 학습한다.

👉 이 문장은 논문/면접/발표 어디서 써도 정확함.

6️⃣ 구조 그림으로 최종 정리 (아주 중요)

🔹 SSL pretrain 단계

image
 → ViT backbone 🔥🔥🔥  (학습됨)
 → projection head 🔥  (SSL 전용)

➡️ 결과: backbone만 저장

🔹 Downstream 단계

image
 → SSL-pretrained ViT backbone ❄️ (또는 일부 🔥)
 → task-specific head 🔥

7️⃣ 한 줄 핵심 요약 (이 문장 기억해)

SSL pretraining은 backbone이 좋은 표현을 학습하도록 만드는 과정이고,
downstream 학습은 그 backbone 위에 태스크 전용 head를 얹어 사용하는 과정이다.

8️⃣ 너 지금 어느 단계까지 이해한 상태냐면

솔직히 말하면 👇

• ❌ 입문자 아님
• ❌ 개념만 아는 단계 아님
• ✅ “SSL–Foundation–Downstream 파이프라인을 이해한 상태”

이제 다음으로 가면 딱 좋은 질문은:

• 🔥 “그럼 projection head는 왜 필요하고 왜 버리나?”
• 🔥 “DINO/MAE에서는 head 구조가 어떻게 다른가?”
• 🔥 “언제 backbone을 풀고, 언제 완전히 고정하나?”

원하면 다음 질문 바로 던져 👍

좋아. 이 3개는 SSL을 ‘제대로 이해했는지’를 가르는 핵심 질문이야.
아래를 끝까지 보면 왜 구조가 그렇게 설계됐는지가 머릿속에서 딱 맞아떨어질 거야.

① 🔥 projection head는 왜 필요하고, 왜 버리나?

결론 한 줄

projection head는 “SSL 학습을 쉽게 하기 위한 장치”이고,
우리가 쓰고 싶은 표현은 backbone에서 이미 끝났기 때문에 버린다.

1️⃣ projection head가 뭐냐?

SSL 구조를 다시 보면:

image
 → backbone (ViT encoder)        ← 진짜 표현 학습
 → projection head (MLP)         ← SSL loss 계산용

• 보통 2~3층 MLP
• 차원 줄이거나(non-linear mapping)
• loss가 계산되는 전용 공간

2️⃣ 왜 backbone 출력에 바로 loss를 안 거나?

이게 핵심 이유야.

이유 ① SSL loss가 backbone을 망가릴 수 있음

• Contrastive / distillation loss는

  • 거리
  • 분포
  • 정렬
    을 강하게 강제함

• 이걸 backbone 표현에 직접 적용하면

  • downstream에 필요한 정보까지 깎아먹음

👉 projection head가 완충 장치(buffer) 역할

이유 ② “좋은 SSL 표현” ≠ “좋은 downstream 표현”

• SSL에서 좋은 표현:

  • invariance 강함
  • augmentation에 둔감

• downstream에서 좋은 표현:

  • 클래스 분리 잘 됨
  • 정보 손실 적음

👉 두 목표가 완전히 같지 않다

이유 ③ 실험적으로 증명됨 (아주 중요)

논문들에서 공통 결론:

projection head를 쓰고,
downstream에서는 backbone 출력만 쓰는 게 성능이 더 좋다

즉,

• SSL 최적화 공간 ≠ 실제 표현 공간

3️⃣ 그래서 왜 “버리나?”

SSL가 끝난 뒤 우리가 원하는 건:

범용 feature extractor (backbone)

projection head는:

• SSL loss 전용
• downstream에 불필요
• 오히려 방해 가능

👉 그래서 과감히 버림

② 🔥 DINO / MAE에서는 head 구조가 어떻게 다른가?

이제 “SSL마다 head가 왜 다른지”를 보자.

🔹 DINO의 head 구조

구조

ViT backbone
 → projection head
 → prototype / softmax head

• teacher / student 둘 다 head 있음
• 출력은 확률 분포
• class token 기반

특징

• head는 의미 정렬용
• EMA teacher가 안정된 목표 제공
• attention이 객체 중심으로 발전

👉 DINO에서 head는:

“의미 공간을 정렬하는 장치”

📌 downstream에서는?

• ❌ DINO head 버림
• ✅ backbone만 사용

🔹 MAE의 head 구조

구조

encoder (ViT backbone)
 → (latent representation)
 → decoder (복원용 head)

• decoder = head 역할
• encoder는 마스크 안 된 패치만 처리
• decoder가 전체 이미지 복원

특징

• encoder 출력은 매우 범용적
• decoder는 복원 전용

👉 MAE에서:

encoder만 foundation model
decoder는 100% 버림

🔹 한눈에 비교

③ 🔥 언제 backbone을 풀고, 언제 완전히 고정하나?

이건 실전에서 가장 중요한 판단 기준이야.

1️⃣ backbone 완전히 고정 (freeze)

언제?

• 데이터 아주 적음
• SSL pretrain 데이터와 도메인이 유사
• 빠른 베이스라인 필요
• 과적합 위험 큼

구조

[ SSL-pretrained backbone ❄️ ]
[ task head 🔥 ]

👉 feature extractor 방식

2️⃣ backbone 일부만 풀기 (partial fine-tuning)

언제?

• 데이터 중간 규모
• 도메인이 약간 다름
• 성능 더 필요
• 안정성도 중요

ViT 기준

early blocks ❄️
last N blocks 🔥
head 🔥

👉 가장 많이 쓰는 현실적인 선택

3️⃣ backbone 전부 풀기 (full fine-tuning)

언제?

• 데이터 많음
• 도메인이 크게 다름
• SSL 표현이 부족할 때
• 충분한 compute 있음

주의

• learning rate 매우 작게
• warmup 필수

👉 ViT에서는 가장 위험하지만 가장 강력

4️⃣ LoRA / Adapter를 쓰는 경우

언제?

• backbone은 “건드리면 안 되는 자산”
• 메모리 제한
• 여러 태스크 반복

backbone ❄️
LoRA / Adapter 🔥
head 🔥

👉 요즘 foundation model 표준

5️⃣ 실전 결정표 (이거 외우면 끝)

🧠 최종 한 문장 요약 (3개 통합)

Projection head는 SSL 학습을 안정화하기 위한 전용 모듈이라 downstream에서는 버리며,
DINO와 MAE는 각기 의미 정렬과 구조 복원을 위해 다른 head를 사용하지만 결과적으로 backbone만 남긴다.
이후 downstream에서는 데이터 규모와 도메인 차이에 따라 backbone을 고정하거나 일부/전체를 풀어 학습한다.

지금 이 정도 이해면,
이제는 “논문 구조를 보면 왜 이렇게 설계됐는지 바로 보이는 단계”야.

다음으로 가면 딱 좋은 주제는:

• 🔥 왜 projection head 차원이 성능에 영향 주나
• 🔥 DINO attention map 실제 코드로 보기
• 🔥 SSL backbone + LoRA 전체 실전 파이프라인

원하면 바로 이어서 가자.