컴퓨터 비전은 머신러닝에서 가장 실용적인 분야 중 하나로, 자율주행, 의료 영상 진단, 보안 시스템 등 다양한 산업에서 활발히 사용되고 있습니다. 이 글에서는 PyTorch를 사용한 컴퓨터 비전 구현에 대해 기초부터 응용까지 체계적으로 설명합니다.

PyTorch 2.5 이상에서는 torch.compile()을 통한 최적화가 크게 개선되었습니다. 이 글의 코드 예제는 최신 모범 사례를 기반으로 작성되었습니다.

합성곱 신경망(CNN) 기초

합성곱 신경망은 이미지 인식 작업에서 표준 아키텍처로 자리 잡았습니다. CNN은 합성곱 층, 풀링 층, 완전 연결 층으로 구성되며, 이미지의 공간적 특징을 효율적으로 추출할 수 있습니다.

PyTorch에서 CNN 구현하기

다음은 이미지 분류를 위한 기본적인 CNN 모델 구현 예제입니다.

python

import torch
import torch.nn as nn
import torch.nn.functional as F

class SimpleCNN(nn.Module):
    def __init__(self, num_classes: int = 10):
        super().__init__()
        self.conv1 = nn.Conv2d(3, 32, kernel_size=3, padding=1)
        self.bn1 = nn.BatchNorm2d(32)
        self.conv2 = nn.Conv2d(32, 64, kernel_size=3, padding=1)
        self.bn2 = nn.BatchNorm2d(64)
        self.conv3 = nn.Conv2d(64, 128, kernel_size=3, padding=1)
        self.bn3 = nn.BatchNorm2d(128)
        self.pool = nn.MaxPool2d(2, 2)
        self.dropout = nn.Dropout(0.5)
        self.fc1 = nn.Linear(128 * 4 * 4, 512)
        self.fc2 = nn.Linear(512, num_classes)
    
    def forward(self, x: torch.Tensor) -> torch.Tensor:
        x = self.pool(F.relu(self.bn1(self.conv1(x))))
        x = self.pool(F.relu(self.bn2(self.conv2(x))))
        x = self.pool(F.relu(self.bn3(self.conv3(x))))
        x = x.view(-1, 128 * 4 * 4)
        x = self.dropout(F.relu(self.fc1(x)))
        x = self.fc2(x)
        return x

이 모델에서는 배치 정규화와 드롭아웃을 사용하여 과적합을 방지하면서 학습을 안정화합니다.

데이터 전처리와 데이터 증강

이미지 데이터의 전처리는 모델 성능에 큰 영향을 미칩니다. PyTorch에서는 torchvision.transforms를 사용하여 효율적으로 데이터 증강을 구현할 수 있습니다.

python

from torchvision import transforms
from torch.utils.data import DataLoader
from torchvision.datasets import ImageFolder

train_transform = transforms.Compose([
    transforms.RandomResizedCrop(224),
    transforms.RandomHorizontalFlip(),
    transforms.RandomRotation(15),
    transforms.ColorJitter(brightness=0.2, contrast=0.2, saturation=0.2),
    transforms.ToTensor(),
    transforms.Normalize(
        mean=[0.485, 0.456, 0.406],
        std=[0.229, 0.224, 0.225]
    )
])

val_transform = transforms.Compose([
    transforms.Resize(256),
    transforms.CenterCrop(224),
    transforms.ToTensor(),
    transforms.Normalize(
        mean=[0.485, 0.456, 0.406],
        std=[0.229, 0.224, 0.225]
    )
])

train_dataset = ImageFolder('data/train', transform=train_transform)
train_loader = DataLoader(
    train_dataset,
    batch_size=32,
    shuffle=True,
    num_workers=4,
    pin_memory=True
)

정규화 값은 ImageNet 데이터셋의 통계값을 사용하며, 사전 학습된 모델과의 호환성을 보장합니다.

전이 학습 실전

전이 학습은 대규모 데이터셋에서 학습된 모델을 새로운 작업에 적용하는 기법입니다. 특히 학습 데이터가 제한적인 경우에 매우 효과적입니다.

ResNet을 활용한 전이 학습

python

import torchvision.models as models

def create_transfer_model(num_classes: int, freeze_backbone: bool = True):
    model = models.resnet50(weights=models.ResNet50_Weights.IMAGENET1K_V2)
    
    if freeze_backbone:
        for param in model.parameters():
            param.requires_grad = False
    
    num_features = model.fc.in_features
    model.fc = nn.Sequential(
        nn.Dropout(0.5),
        nn.Linear(num_features, 512),
        nn.ReLU(),
        nn.Dropout(0.3),
        nn.Linear(512, num_classes)
    )
    
    return model

model = create_transfer_model(num_classes=5)

전이 학습에서는 먼저 백본을 동결하고 분류 헤드만 학습한 후, 이후 전체를 미세 조정하는 2단계 접근법이 효과적입니다.

Vision Transformer 활용

최근에는 Vision Transformer(ViT)가 CNN을 능가하는 성능을 보여주는 사례가 늘어나고 있습니다.

python

from torchvision.models import vit_b_16, ViT_B_16_Weights

def create_vit_model(num_classes: int):
    model = vit_b_16(weights=ViT_B_16_Weights.IMAGENET1K_V1)
    
    for param in model.parameters():
        param.requires_grad = False
    
    model.heads = nn.Sequential(
        nn.Linear(model.heads.head.in_features, 512),
        nn.GELU(),
        nn.Dropout(0.3),
        nn.Linear(512, num_classes)
    )
    
    for param in model.heads.parameters():
        param.requires_grad = True
    
    return model

학습 루프 구현

PyTorch에서는 학습 루프를 명시적으로 작성해야 합니다. 다음은 혼합 정밀도 학습과 그래디언트 클리핑을 포함한 구현 예제입니다.

python

from torch.amp import GradScaler, autocast
from torch.optim import AdamW
from torch.optim.lr_scheduler import CosineAnnealingLR

def train_model(
    model: nn.Module,
    train_loader: DataLoader,
    val_loader: DataLoader,
    epochs: int = 50,
    device: str = 'cuda'
):
    model = model.to(device)
    optimizer = AdamW(model.parameters(), lr=1e-4, weight_decay=0.01)
    scheduler = CosineAnnealingLR(optimizer, T_max=epochs)
    scaler = GradScaler()
    criterion = nn.CrossEntropyLoss()
    
    best_val_acc = 0.0
    
    for epoch in range(epochs):
        model.train()
        train_loss = 0.0
        
        for images, labels in train_loader:
            images, labels = images.to(device), labels.to(device)
            
            optimizer.zero_grad()
            
            with autocast(device_type='cuda'):
                outputs = model(images)
                loss = criterion(outputs, labels)
            
            scaler.scale(loss).backward()
            scaler.unscale_(optimizer)
            torch.nn.utils.clip_grad_norm_(model.parameters(), max_norm=1.0)
            scaler.step(optimizer)
            scaler.update()
            
            train_loss += loss.item()
        
        val_acc = evaluate(model, val_loader, device)
        scheduler.step()
        
        if val_acc > best_val_acc:
            best_val_acc = val_acc
            torch.save(model.state_dict(), 'best_model.pth')
        
        print(f'Epoch {epoch+1}/{epochs}, Loss: {train_loss/len(train_loader):.4f}, Val Acc: {val_acc:.4f}')
    
    return model

def evaluate(model: nn.Module, loader: DataLoader, device: str) -> float:
    model.eval()
    correct = 0
    total = 0
    
    with torch.no_grad():
        for images, labels in loader:
            images, labels = images.to(device), labels.to(device)
            outputs = model(images)
            _, predicted = torch.max(outputs, 1)
            total += labels.size(0)
            correct += (predicted == labels).sum().item()
    
    return correct / total

모델 최적화와 배포

PyTorch 2.x에서는 torch.compile()을 사용하여 모델을 최적화할 수 있습니다.

python

import torch

model = create_transfer_model(num_classes=10)
model = torch.compile(model, mode='reduce-overhead')

# ONNX 형식으로 내보내기
torch.onnx.export(
    model,
    torch.randn(1, 3, 224, 224),
    'model.onnx',
    input_names=['input'],
    output_names=['output'],
    dynamic_axes={
        'input': {0: 'batch_size'},
        'output': {0: 'batch_size'}
    }
)

Data Science & ML 면접 준비가 되셨나요?

인터랙티브 시뮬레이터, flashcards, 기술 테스트로 연습하세요.

Data Science & ML 탐색하기

면접에서 자주 나오는 컴퓨터 비전 질문

데이터 사이언스나 머신러닝 엔지니어 면접에서는 컴퓨터 비전에 관한 기술적 질문이 자주 출제됩니다.

CNN 관련 질문

Q: 합성곱 층과 풀링 층의 차이점은 무엇입니까?

합성곱 층은 학습 가능한 필터를 사용하여 특징을 추출하고, 풀링 층은 고정된 연산(최대값 또는 평균값 선택)으로 다운샘플링을 수행합니다. 합성곱 층은 파라미터를 갖지만, 풀링 층은 파라미터가 없습니다.

Q: 배치 정규화의 목적과 효과적인 이유를 설명해 주십시오.

배치 정규화는 각 층의 입력을 정규화하여 내부 공변량 변화를 완화합니다. 이를 통해 더 높은 학습률을 사용할 수 있고, 학습이 안정화되며, 정규화 효과도 얻을 수 있습니다.

Q: 수용 영역(Receptive Field)이란 무엇입니까?

수용 영역은 출력의 한 뉴런이 "볼" 수 있는 입력 이미지의 영역입니다. 깊은 층일수록 수용 영역이 커지며, 더 넓은 문맥을 파악할 수 있습니다.

전이 학습 관련 질문

Q: 전이 학습을 사용할 때와 전체를 재학습할 때의 판단 기준은 무엇입니까?

전이 학습은 타겟 데이터셋이 작거나 소스 도메인과 타겟 도메인이 유사한 경우에 효과적입니다. 데이터셋이 충분히 크고 도메인이 크게 다른 경우에는 전체를 재학습하는 것이 더 좋은 결과를 얻을 수 있습니다.

Q: 미세 조정 시 어떤 층을 동결해야 합니까?

일반적으로 초기 층은 범용적인 특징(엣지, 텍스처 등)을 학습하므로 동결하고, 후반 층은 작업 고유의 특징을 학습하므로 동결을 해제합니다. 데이터 양이 적은 경우에는 더 많은 층을 동결합니다.

구현 관련 질문

Q: 과적합을 방지하기 위해 어떤 기법을 사용합니까?

데이터 증강, 드롭아웃, 정규화(L2/Weight Decay), 조기 종료, 배치 정규화 등이 있습니다. 또한 더 작은 모델을 사용하거나 전이 학습을 활용하는 것도 효과적입니다.

Q: 혼합 정밀도 학습(Mixed Precision Training)의 장점은 무엇입니까?

혼합 정밀도 학습은 float16과 float32를 조합하여 사용함으로써 메모리 사용량을 줄이고 계산 속도를 향상시킵니다. 정확도 저하는 거의 없으며, 특히 대규모 모델 학습에서 효과적입니다.

성능 최적화 모범 사례

프로덕션 환경에서 모델을 운영하려면 효율적인 추론이 중요합니다.

python

class OptimizedInference:
    def __init__(self, model_path: str, device: str = 'cuda'):
        self.device = device
        self.model = self._load_model(model_path)
        self.transform = val_transform
    
    def _load_model(self, path: str) -> nn.Module:
        model = create_transfer_model(num_classes=10)
        model.load_state_dict(torch.load(path, map_location=self.device))
        model = model.to(self.device)
        model.eval()
        return torch.compile(model, mode='reduce-overhead')
    
    @torch.inference_mode()
    def predict(self, image: torch.Tensor) -> tuple[int, float]:
        image = self.transform(image).unsqueeze(0).to(self.device)
        output = self.model(image)
        probabilities = F.softmax(output, dim=1)
        confidence, predicted = torch.max(probabilities, 1)
        return predicted.item(), confidence.item()
    
    @torch.inference_mode()
    def predict_batch(self, images: list) -> list[tuple[int, float]]:
        batch = torch.stack([self.transform(img) for img in images])
        batch = batch.to(self.device)
        outputs = self.model(batch)
        probabilities = F.softmax(outputs, dim=1)
        confidences, predictions = torch.max(probabilities, 1)
        return list(zip(predictions.tolist(), confidences.tolist()))

결론

이 글에서는 PyTorch를 사용한 컴퓨터 비전 구현에 대해 CNN 기초부터 전이 학습, 면접 대비까지 폭넓게 다루었습니다. 핵심 포인트는 다음과 같습니다.

CNN의 기본 구조를 이해하고 적절하게 모델을 설계한다
데이터 증강을 활용하여 과적합을 방지한다
전이 학습을 효과적으로 활용하여 제한된 데이터로도 높은 정확도를 달성한다
혼합 정밀도 학습과 torch.compile()로 학습 및 추론을 최적화한다
면접에서는 이론적 이해와 구현 경험 모두가 요구된다

컴퓨터 비전은 빠르게 발전하는 분야이므로 최신 연구와 모범 사례를 지속적으로 따라가는 것이 중요합니다. PyTorch 생태계를 활용하면 효율적으로 고성능 모델을 구축할 수 있습니다.

2026년 PyTorch 컴퓨터 비전 완벽 가이드: CNN, 전이 학습, 면접 질문

합성곱 신경망(CNN) 기초

PyTorch에서 CNN 구현하기

데이터 전처리와 데이터 증강

전이 학습 실전

ResNet을 활용한 전이 학습

Vision Transformer 활용

학습 루프 구현

모델 최적화와 배포

Data Science & ML 면접 준비가 되셨나요?

면접에서 자주 나오는 컴퓨터 비전 질문

CNN 관련 질문

전이 학습 관련 질문

구현 관련 질문

성능 최적화 모범 사례

결론

관련 기사

2026년 데이터 사이언티스트를 위한 LangChain: LLM, 에이전트, 면접 질문

2026년 MLOps: MLflow, 모델 레지스트리와 기술 면접 질문

RAG와 LLM 2026년판: 데이터 사이언스 면접을 위한 검색 증강 생성 완벽 가이드