Semantic Segmentation시맨틱 세그멘테이션

예시 이미지에 개 두 마리가 있을 때:

시맨틱:  [개][개][배경][배경]   ← 두 개를 같은 "개" 클래스로 처리
인스턴스: [개_1][개_2][배경]     ← 두 개를 각각 다른 객체로 구분
파노픽:  [개_1][개_2][잔디][하늘] ← 인스턴스 + 배경 클래스 동시 처리

1. 데이터 수집 및 픽셀 단위 주석(Annotation)
      ↓
2. CNN/Transformer 기반 인코더-디코더 모델 선택
      ↓
3. 학습: 각 픽셀의 클래스 확률 예측 → 손실 계산
      ↓
4. 추론: 새 이미지 입력 → 픽셀별 클래스 확률 맵 출력
      ↓
5. Argmax → 최종 세그멘테이션 맵 (H × W, 각 값 = 클래스 인덱스)

입력 이미지 (H×W×3)
    ↓
[인코더] — 다운샘플링, 특성 추출 (ResNet, Swin 등)
    ↓  skip connections (U-Net 방식)
[디코더] — 업샘플링, 공간 해상도 복원
    ↓
출력 맵 (H×W×C) → argmax → 세그멘테이션 맵

import torch.nn as nn
import torchvision

class FCN(nn.Module):
    def __init__(self, num_classes=21):
        super().__init__()
        backbone = torchvision.models.vgg16(pretrained=True).features
        self.encoder = backbone
        # FC → 1×1 Conv 변환 (임의 해상도 지원)
        self.classifier = nn.Sequential(
            nn.Conv2d(512, 4096, 1), nn.ReLU(), nn.Dropout(),
            nn.Conv2d(4096, 4096, 1), nn.ReLU(), nn.Dropout(),
            nn.Conv2d(4096, num_classes, 1),
        )
        self.upsample = nn.ConvTranspose2d(num_classes, num_classes, 32, stride=32)

    def forward(self, x):
        x = self.encoder(x)
        x = self.classifier(x)
        return self.upsample(x)

import torch
import torch.nn as nn

class DoubleConv(nn.Module):
    def __init__(self, in_ch, out_ch):
        super().__init__()
        self.net = nn.Sequential(
            nn.Conv2d(in_ch, out_ch, 3, padding=1), nn.BatchNorm2d(out_ch), nn.ReLU(inplace=True),
            nn.Conv2d(out_ch, out_ch, 3, padding=1), nn.BatchNorm2d(out_ch), nn.ReLU(inplace=True),
        )
    def forward(self, x): return self.net(x)

class UNet(nn.Module):
    def __init__(self, in_channels=3, num_classes=21):
        super().__init__()
        f = [64, 128, 256, 512]
        self.enc = nn.ModuleList([DoubleConv(in_channels if i==0 else f[i-1], f[i]) for i in range(4)])
        self.pool = nn.MaxPool2d(2)
        self.bottleneck = DoubleConv(f[-1], f[-1]*2)
        self.up  = nn.ModuleList([nn.ConvTranspose2d(f[-1]*2 if i==0 else f[3-i+1], f[3-i], 2, 2) for i in range(4)])
        self.dec = nn.ModuleList([DoubleConv(f[3-i]*2, f[3-i]) for i in range(4)])
        self.out_conv = nn.Conv2d(f[0], num_classes, 1)

    def forward(self, x):
        skips = []
        for enc in self.enc:
            x = enc(x); skips.append(x); x = self.pool(x)
        x = self.bottleneck(x)
        for i, (up, dec) in enumerate(zip(self.up, self.dec)):
            x = up(x)
            x = torch.cat([skips[3-i], x], dim=1)
            x = dec(x)
        return self.out_conv(x)

model = UNet()
print(model(torch.randn(2, 3, 256, 256)).shape)  # (2, 21, 256, 256)

class AtrousConv(nn.Module):
    """팽창 합성곱: 필터 사이에 dilation 간격을 두어 넓은 영역 수용"""
    def __init__(self, in_ch, out_ch, dilation):
        super().__init__()
        self.conv = nn.Conv2d(in_ch, out_ch, 3, padding=dilation, dilation=dilation)
        self.bn   = nn.BatchNorm2d(out_ch)
    def forward(self, x):
        return nn.functional.relu(self.bn(self.conv(x)))

class ASPP(nn.Module):
    """Atrous Spatial Pyramid Pooling: 다중 스케일 문맥 정보 통합"""
    def __init__(self, in_ch, out_ch=256):
        super().__init__()
        self.branches = nn.ModuleList([
            nn.Sequential(nn.Conv2d(in_ch, out_ch, 1), nn.BatchNorm2d(out_ch), nn.ReLU()),
            AtrousConv(in_ch, out_ch, dilation=6),
            AtrousConv(in_ch, out_ch, dilation=12),
            AtrousConv(in_ch, out_ch, dilation=18),
        ])
        self.global_pool = nn.Sequential(
            nn.AdaptiveAvgPool2d(1),
            nn.Conv2d(in_ch, out_ch, 1), nn.BatchNorm2d(out_ch), nn.ReLU()
        )
        self.proj = nn.Conv2d(out_ch * 5, out_ch, 1)

    def forward(self, x):
        H, W = x.shape[2:]
        feats = [b(x) for b in self.branches]
        gp = nn.functional.interpolate(self.global_pool(x), (H, W), mode='bilinear', align_corners=False)
        feats.append(gp)
        return self.proj(torch.cat(feats, dim=1))

입력 특성 맵
    ↓ 4가지 풀링 (1×1, 2×2, 3×3, 6×6 grid)
[Global][반전역][중간][지역] 풀링
    ↓ 업샘플링 후 concatenation
다중 스케일 문맥 통합 → 최종 예측

import torch
import torch.nn.functional as F

# 1. Cross-Entropy Loss (표준)
criterion = torch.nn.CrossEntropyLoss(ignore_index=255)
loss = criterion(pred, target)

# 2. Dice Loss (클래스 불균형 완화)
def dice_loss(pred, target, smooth=1e-6):
    pred   = pred.softmax(dim=1)
    target = F.one_hot(target, num_classes=pred.shape[1]).permute(0,3,1,2).float()
    intersection = (pred * target).sum(dim=(2,3))
    dice = (2*intersection + smooth) / (pred.sum(dim=(2,3)) + target.sum(dim=(2,3)) + smooth)
    return 1 - dice.mean()

# 3. Focal Loss (어려운 픽셀에 집중)
def focal_loss(pred, target, gamma=2.0):
    ce = F.cross_entropy(pred, target, reduction='none')
    pt = torch.exp(-ce)
    return ((1 - pt) ** gamma * ce).mean()

# 실제로는 Cross-Entropy + Dice 혼합 사용이 많음
total_loss = criterion(pred, target) + dice_loss(pred, target)

IoU = TP / (TP + FP + FN)
    = 교집합 / 합집합

mIoU = 모든 클래스의 IoU 평균 (벤치마크 표준 지표)

def mean_iou(pred, target, num_classes):
    """mIoU = 클래스별 IoU의 평균"""
    ious = []
    pred   = pred.flatten()
    target = target.flatten()
    for cls in range(num_classes):
        pred_cls   = (pred == cls)
        target_cls = (target == cls)
        intersection = (pred_cls & target_cls).sum().float()
        union        = (pred_cls | target_cls).sum().float()
        if union == 0:
            continue
        ious.append((intersection / union).item())
    return sum(ious) / len(ious) if ious else 0.0

# Pixel Accuracy (픽셀 정확도)
def pixel_accuracy(pred, target):
    correct = (pred == target).sum().float()
    return correct / target.numel()

정밀도 = TP / (TP + FP)   ← 예측이 얼마나 정확한가
재현율 = TP / (TP + FN)   ← 실제 객체를 얼마나 놓치지 않는가

AP = 정밀도-재현율 곡선 아래 면적
AP50  = IoU ≥ 0.50 조건에서의 AP
AP75  = IoU ≥ 0.75 조건에서의 AP (더 엄격한 기준)
mAP   = 모든 클래스의 AP 평균