End-to-end
가짜 이미지 탐지 모델 학습

발상 전환

지난 시간에는 CLIP 모델을 활용해 진짜와 가짜 이미지를 구분하는 과정을 배웠습니다. CLIP은 미리 학습된 딥러닝 모델로, 이미지의 특징을 추출하고 이를 기반으로 k-NN 알고리즘을 사용해 가짜 이미지를 분류했죠. 여러분은 이 과정에서 딥러닝 모델이 이미지를 분석하고 진짜와 가짜를 구분하는 데 얼마나 강력한지 직접 확인할 수 있었습니다.

그런데 한 가지 궁금하지 않나요?
"우리가 직접 딥러닝 모델을 학습시킨다면 어떨까요?"

CLIP과 같은 사전 학습된 모델은 이미 수많은 데이터를 기반으로 학습된 결과물이지만, 이번에는 여러분이 직접 딥러닝 모델을 설계하고, 학습시키고, 진짜와 가짜 이미지를 분류하는 과정을 체험해 볼 거예요. "내가 만든 모델이 정말 가짜 이미지를 잘 찾아낼까?"라는 질문과 함께 말이죠!

이번 차시에는 간단한 CNN(Convolutional Neural Network) 모델을 사용해 진짜와 가짜 이미지를 분류하는 방법을 배웁니다. 이번 학습을 통해 CNN이 이미지를 이해하는 과정을 탐구하면서, 특징 추출과 분류가 어떻게 이루어지는지 배울 수 있습니다.

학습내용

학습목표

핵심 키워드

프로젝트를 위한 사전 준비물 혹은 설치해야 하는 소프트웨어

2-1. End-to-end 학습

지난 시간에는 이미지를 분석해서 중요한 특징을 먼저 뽑아내고, 그 특징으로 진짜인지 가짜인지 예측했어요. 이번에는 End-to-End 학습 방법을 써서 이미지를 모델에 넣기만 하면, 바로 진짜인지 가짜인지 결과를 알려주는 방법을 배워볼 거예요. 모델이 스스로 배우고 똑똑해지는 과정을 함께 알아봅시다.

End-to-end 학습이란?

End-to-End 학습은 처음부터 끝까지 한 번에 모든 과정을 배우는 방법이에요. 가짜 이미지 탐지에서는 이미지를 모델에 넣으면, 모델이 진짜인지 가짜인지 바로 판단할 수 있도록 학습합니다. 이 방식은 사람이 직접 단계별로 작업을 설계할 필요 없이, 모델이 스스로 필요한 특징을 찾아내고 결과를 보여줘요.

예를 들어, 기존 방식에서는 이미지를 분석하기 위해 여러 단계를 거쳤지만, End-to-End 학습은 이 모든 단계를 하나의 모델로 통합해 처리합니다. 이 덕분에 더 간단하고 효율적인 학습이 가능해요.

두 방법의 비교

End-to-end 학습의 장점

End-to-end 학습의 단점

2-2. ResNet의 구성요소 이해하기

ResNet-18이라는 모델은 탐정과 판사 팀이 협력해 이미지를 분석하고 진짜인지 가짜인지 판단하는 과정을 거칩니다. 여기서 탐정은 Convolutional Layer, 판사는 Linear Layer 역할을 합니다. 이제 이 팀이 어떻게 일을 하는지 차근차근 알아볼게요!

1. Convolutional Layer (탐정)

탐정은 이미지를 보면서 중요한 단서를 찾아냅니다. 처음에는 간단한 단서를 보고, 나중에는 더 복잡한 단서를 찾아요.

탐정 (Convolutional Layer) 코드

코드를 통해 탐정이 하는 일을 좀 더 자세히 살펴봅시다. 탐정은 이미지에서 단서를 찾는 역할을 합니다. ResNet-18의 Conv1은 가장 첫 번째 탐정 역할을 수행하며, 단순한 선과 색상 같은 기본적인 패턴을 찾습니다.

Python# ResNet-18 모델 불러오기
model = models.resnet18(pretrained=True)

# 첫 번째 Convolutional Layer 확인 (탐정의 첫 번째 역할)
conv1 = model.conv1
print(conv1)

OutputConv2d(3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False)

탐정의 진행 과정 (Residual Block)

탐정은 처음에 찾은 단서를 가지고 더 복잡한 단서를 찾아갑니다. Residual Block은 탐정이 정보를 잃지 않고 더 깊은 분석을 가능하게 합니다.

Python# Residual Block 확인 (탐정의 두 번째 역할)
layer1 = model.layer1
print(layer1)

OutputSequential(
  (0): BasicBlock(
    (conv1): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
    (bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
    (relu): ReLU(inplace=True)
    (conv2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
    (bn2): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
  )
  (1): BasicBlock( ... 동일 구조 ... )
)

2. Linear Layer (판사)

탐정이 단서를 모두 모아오면, 이제 판사가 "이 단서들을 보니, 이건 진짜야!" 또는 "이건 가짜야!"라고 판단합니다.

판사 (Linear Layer) 코드

탐정이 단서를 모두 정리하면, 판사는 이를 종합하여 "진짜"인지 "가짜"인지 최종 결론을 내립니다.

Python# ResNet-18의 Linear Layer 확인 (판사 역할)
model.fc = nn.Linear(model.fc.in_features, 2)  # 2개의 출력값 (진짜/가짜)
print(model.fc)

OutputLinear(in_features=512, out_features=2, bias=True)

3. 탐정과 판사의 협력 과정

Python# 임의의 입력 이미지 텐서 생성 (3x224x224 크기)
# 배치 크기 1, RGB 채널 3, 크기 224x224
dummy_image = torch.randn(1, 3, 224, 224)

# 첫 번째 탐정(Conv1)이 단서를 찾음
features = model.conv1(dummy_image)
print(f"Conv1 출력 크기: {features.shape}")

OutputConv1 출력 크기: torch.Size([1, 64, 112, 112])

→ 64개의 특징 맵(단서)을 찾고, 이미지 크기는 절반(112×112)으로 줄어듭니다.

Python# 전체 모델을 통해 최종 출력 생성
model.fc = nn.Linear(model.fc.in_features, 2)  # 두 가지 분류를 하는 판사
model = model.to("cpu")  # CPU로 이동
output = model(dummy_image)  # 임의의 이미지로 예측
print(f"최종 출력: {output}")

Output최종 출력: tensor([[0.1456, 0.1755]], grad_fn=<AddmmBackward0>)

두 개의 값(진짜, 가짜)에 대한 점수를 출력합니다.
예시처럼 두 값 중 더 높은 값이 가짜(1)로 분류됩니다.

이번에는 ResNet-18 모델을 사용해 이미지를 "진짜"와 "가짜"로 분류하는 과정을 체험해 볼 거예요. ResNet-18은 탐정(Convolutional Layer)과 판사(Linear Layer)로 구성된 팀처럼 작동합니다.

탐정과 판사 팀의 여정

11단계 학습 파이프라인 한눈에 보기

Step 1필수 라이브러리 설치

Colab에서 실행할 코드를 준비하려면, 먼저 필요한 도구들을 설치해야 합니다.

Colab# Google Colab에서만 실행하세요. 이 명령어는 딥러닝과 데이터 처리를 위한 라이브러리를 설치합니다.
%pip install torch torchvision matplotlib tqdm scikit-learn gdown

Step 2라이브러리 불러오기

필수 라이브러리를 불러와 코드를 준비합니다.

Pythonimport os       # 폴더와 파일을 다루기 위한 라이브러리
import random   # 랜덤하게 데이터를 섞기 위한 라이브러리
import numpy as np      # 수학 계산용 라이브러리
from PIL import Image  # 이미지를 다루기 위한 라이브러리
import matplotlib.pyplot as plt   # 그래프와 이미지를 시각화하기 위한 라이브러리
from tqdm import tqdm        # 진행 상태를 보여주는 라이브러리

import torch                       # 딥러닝의 핵심 라이브러리
import torch.nn as nn             # 신경망 구성에 필요한 모듈
import torch.optim as optim       # 최적화를 위한 모듈
from torchvision import models, transforms   # 사전 학습된 모델과 데이터 변환 모듈
from torch.utils.data import DataLoader, Dataset   # 데이터 로딩에 필요한 모듈

Step 3데이터 경로 설정

1차시와 같이 진짜/가짜 이미지 데이터셋을 다운받고 압축을 풀어줍니다.

Python%gdown https://drive.google.com/uc?id=1q8mDau3_VCXqKamNqkfqVw3hAzy600jD
%unzip /content/real_vs_fake_dataset.zip

# Real과 Fake 이미지를 저장한 폴더 경로를 입력합니다.
real_image_dir = "/content/real_vs_fake_dataset/0_real"   # Real 이미지가 들어 있는 폴더
fake_image_dir = "/content/real_vs_fake_dataset/1_fake"   # Fake 이미지가 들어 있는 폴더

Step 4데이터 처리 클래스 정의

탐정이 이미지를 쉽게 분석할 수 있도록 데이터를 준비합니다. 이미지가 들어있는 폴더에서 하나씩 이미지를 불러오고 라벨(진짜/가짜)도 정해줍니다.

Python# 이미지를 불러오고, 변환하며, 학습에 사용할 준비를 합니다.
class ImageDataset(Dataset):
    def __init__(self, image_dirs, labels, transform=None):
        self.image_paths = []
        self.labels = []
        for image_dir, label in zip(image_dirs, labels):
            paths = [os.path.join(image_dir, img)
                     for img in os.listdir(image_dir)
                     if img.endswith(('.png', '.jpg', '.jpeg'))]
            self.image_paths.extend(paths)
            self.labels.extend([label] * len(paths))
        self.transform = transform

    def __len__(self):
        return len(self.image_paths)

    def __getitem__(self, idx):
        image = Image.open(self.image_paths[idx]).convert("RGB")
        label = self.labels[idx]
        if self.transform:
            image = self.transform(image)
        return image, label

Step 5데이터 전처리

이미지를 ResNet-18에 맞게 변환합니다.

Pythontransform = transforms.Compose([
    # ResNet-18은 224x224 크기의 이미지를 입력으로 받습니다.
    transforms.Resize((224, 224)),
    # 이미지를 텐서(숫자 배열)로 변환합니다.
    transforms.ToTensor(),
    # ResNet-18에 맞는 표준화 값
    transforms.Normalize(mean=[0.485, 0.456, 0.406],
                         std=[0.229, 0.224, 0.225])
])

Step 6데이터셋 생성 및 분리

전체 데이터를 학습용 80%와 테스트용 20%로 나눠요. 학습용 데이터로 모델을 배우게 하고, 테스트용 데이터로 모델이 잘 배웠는지 확인합니다.

Python# Real과 Fake 이미지를 라벨링하여 데이터셋을 생성합니다.
real_label = 0   # Real 이미지는 0으로 라벨링
fake_label = 1   # Fake 이미지는 1로 라벨링

dataset = ImageDataset([real_image_dir, fake_image_dir],
                       [real_label, fake_label],
                       transform=transform)

# 데이터셋을 학습용과 테스트용으로 나눕니다.
train_size = int(0.8 * len(dataset))
test_size = len(dataset) - train_size
train_dataset, test_dataset = torch.utils.data.random_split(dataset, [train_size, test_size])

# DataLoader를 사용해 데이터를 배치로 나눕니다.
batch_size = 16   # 한 번에 처리할 데이터 개수
train_loader = DataLoader(train_dataset, batch_size=batch_size, shuffle=True)
test_loader = DataLoader(test_dataset, batch_size=batch_size, shuffle=False)

Step 7ResNet-18 모델 정의 — 모델 만들기와 학습 준비

탐정과 판사가 팀을 이뤄 이미지를 분석합니다.

Python# 사전 학습된 ResNet-18 모델을 불러오고 출력 크기를 조정합니다.
model = models.resnet18(pretrained=True)

# 모델의 마지막 레이어를 2개의 출력 노드(진짜/가짜)로 변경합니다.
model.fc = nn.Linear(model.fc.in_features, 2)

# 모델을 GPU로 이동합니다 (가능한 경우).
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
model = model.to(device)

Step 8학습 준비 (손실 함수와 최적화 정의)

Python# 분류 문제에 적합한 손실 함수
criterion = nn.CrossEntropyLoss()
# 모델 학습을 위한 최적화 알고리즘
optimizer = optim.Adam(model.parameters(), lr=0.001)

Step 9모델 학습 함수 정의 — 탐정과 판사의 학습

탐정은 이미지를 분석하며 단서를 찾고, 판사는 결과를 판단합니다.

Python# 모델을 학습시키기 위한 함수입니다.
def train_model(model, train_loader, criterion, optimizer, epochs=5):
    model.train()   # 모델을 학습 모드로 설정
    for epoch in range(epochs):
        total_loss = 0
        for images, labels in tqdm(train_loader, desc=f"Epoch {epoch + 1}/{epochs}"):
            images, labels = images.to(device), labels.to(device)

            # 모델이 예측한 결과와 손실 계산
            outputs = model(images)
            loss = criterion(outputs, labels)

            # 역전파를 통해 모델 가중치 업데이트
            optimizer.zero_grad()
            loss.backward()
            optimizer.step()

            total_loss += loss.item()
        print(f"Epoch {epoch + 1}, Loss: {total_loss / len(train_loader):.4f}")

Step 10모델 평가 함수 정의 — 학습한 탐정과 판사의 평가

탐정과 판사 팀이 협력해 이미지를 분석하고 학습한 모델이 얼마나 잘 판단하는지 최종 평가합니다.

Python# 모델을 평가하기 위한 함수입니다.
def evaluate_model(model, test_loader):
    model.eval()   # 모델을 평가 모드로 설정
    correct = 0
    total = 0
    with torch.no_grad():   # 평가 시에는 가중치 업데이트를 하지 않음
        for images, labels in test_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()
    print(f"Accuracy: {100 * correct / total:.2f}%")

Step 11모델 학습 및 평가 실행

Pythontrain_model(model, train_loader, criterion, optimizer, epochs=5)
evaluate_model(model, test_loader)

1차시에서 만든 CLIP+k-NN 모델과 비교해서, 이번에 만든 ResNet-18 End-to-End 모델은 어떤 결과를 보여줬나요? 정확도, 학습 시간, 데이터 양과의 관계를 정리해 봅시다.

실험 기록 권장 양식

핵심 개념 정리

자주 만나는 에러와 해결

더 알아보기

• ResNet 논문: "Deep Residual Learning for Image Recognition" (He et al., 2015) — Residual Block의 원리
• PyTorch 공식 튜토리얼: pytorch.org/tutorials — Transfer Learning, CIFAR-10 분류 예제
• torchvision.models: ResNet 외에도 EfficientNet, ViT 등 다양한 사전학습 모델 제공
• 데이터 증강: transforms.RandomHorizontalFlip(), RandomRotation(), ColorJitter() 등