2026-01-24 | 8 min read | 177 | PyTorch 데이터 데이터로더

3-4. PyTorch: 데이터셋과 데이터 로더

1. 데이터셋과 데이터 로더의 중요성

딥러닝 모델을 학습시키기 위해서는 방대한 양의 데이터를 효율적으로 관리하고, 모델이 원하는 형태로 변환하여 제공하는 과정이 필수적입니다. PyTorch는 이러한 과정을 돕기 위해 Dataset과 DataLoader라는 두 가지 핵심적인 기능을 제공합니다. Dataset은 데이터를 저장하고 관리하는 추상 클래스이며, DataLoader는 Dataset에서 데이터를 배치 단위로 로드하고, 미니 배치(mini-batch)를 구성하여 모델 학습에 적합한 형태로 변환하는 역할을 수행합니다.

1) 왜 데이터셋과 데이터 로더가 필요할까?

딥러닝 모델은 일반적으로 대량의 데이터를 사용하여 학습합니다. 데이터를 효과적으로 처리하지 않으면,

  • 메모리 부족으로 인한 오류 발생
  • 데이터를 일일이 수동으로 처리해야 하는 번거로움
  • 학습 속도 저하
  • 데이터 전처리 과정의 비효율성

이러한 문제점을 해결하기 위해 Dataset과 DataLoader는 다음과 같은 기능을 제공합니다.

  • 데이터를 구조화하고 관리하여 효율적인 데이터 접근을 가능하게 합니다.
  • 미니 배치를 구성하여 학습 과정의 속도를 향상시키고 메모리 사용량을 최적화합니다.
  • 데이터 전처리 과정을 자동화하여 모델 학습에 필요한 데이터를 쉽게 준비할 수 있도록 돕습니다.

2. Dataset: 데이터의 구조화 및 관리

Dataset은 PyTorch에서 데이터를 표현하는 추상 클래스입니다. 사용자가 직접 Dataset을 상속받아 자신만의 데이터셋을 정의하고, 데이터를 모델에 맞게 가공할 수 있도록 합니다. Dataset은 두 가지 필수 메서드를 구현해야 합니다.

  • __len__(): 데이터셋의 전체 크기를 반환합니다.
  • __getitem__(idx): 주어진 인덱스(idx)에 해당하는 데이터를 반환합니다.

1) Custom Dataset 구현하기

자신만의 데이터셋을 정의하는 과정을 살펴보겠습니다. 다음은 간단한 예시로, 이미지 파일의 경로와 레이블을 담고 있는 CustomDataset 클래스입니다.

import torch
from torch.utils.data import Dataset
from torchvision import transforms
from PIL import Image

class CustomDataset(Dataset):
    def __init__(self, image_paths, labels, transform=None):
        self.image_paths = image_paths
        self.labels = labels
        self.transform = transform

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

    def __getitem__(self, idx):
        image_path = self.image_paths[idx]
        image = Image.open(image_path).convert("RGB") # 이미지를 RGB 형식으로 변환
        label = self.labels[idx]

        if self.transform:
            image = self.transform(image)

        return image, label

위 코드에서 __init__() 메서드는 이미지 경로(image_paths)와 레이블(labels), 그리고 이미지 변환(transform)을 초기화합니다. __len__() 메서드는 데이터셋의 크기를 반환하며, __getitem__() 메서드는 주어진 인덱스에 해당하는 이미지와 레이블을 반환합니다. 이미지 변환(transform)은 torchvision.transforms 모듈을 사용하여 정의할 수 있습니다.

2) torchvision.datasets 사용하기

PyTorch는 torchvision.datasets 모듈을 통해 다양한 종류의 데이터셋을 제공합니다. MNIST, CIFAR-10, ImageNet 등 널리 사용되는 데이터셋을 간편하게 사용할 수 있습니다.

from torchvision import datasets, transforms

# 데이터 변환 정의
transform = transforms.Compose([
    transforms.Resize((28, 28)),  # 이미지 크기 조정
    transforms.ToTensor(),         # 이미지를 Tensor로 변환
    transforms.Normalize((0.5,), (0.5,)) # 정규화
])

# MNIST 데이터셋 로드
train_dataset <mark class="highlight"><strong><u> datasets.MNIST(root</u></strong></mark>'./data', train=True, download=True, transform=transform)
test_dataset <mark class="highlight"><strong><u> datasets.MNIST(root</u></strong></mark>'./data', train=False, download=True, transform=transform)

위 예제는 MNIST 데이터셋을 로드하고, 이미지 크기를 조정하고 텐서로 변환하며 정규화하는 과정을 보여줍니다. root 인자는 데이터를 저장할 경로를 지정하고, train 인자는 훈련 데이터셋 또는 테스트 데이터셋을 로드할지를 결정합니다. download=True는 데이터가 없는 경우 자동으로 다운로드합니다.

3. DataLoader: 데이터 로딩 및 배치 처리

DataLoader는 Dataset에서 데이터를 미니 배치 단위로 로드하고, 데이터 변환 과정을 병렬 처리하여 모델 학습을 효율적으로 수행할 수 있도록 도와줍니다. DataLoader는 다음과 같은 주요 인자를 가집니다.

  • dataset: 로드할 Dataset 객체
  • batch_size: 미니 배치의 크기
  • shuffle: 데이터를 섞을지 여부 (True 또는 False)
  • num_workers: 데이터 로딩에 사용할 프로세스 수

1) DataLoader 사용법

DataLoader는 torch.utils.data 모듈에서 제공됩니다. 다음은 앞서 정의한 CustomDataset과 DataLoader를 사용하여 데이터를 로드하는 예시입니다.

from torch.utils.data import DataLoader

# CustomDataset 인스턴스 생성 (데이터 및 레이블은 실제 데이터로 대체)
# 예시:
# image_paths = ['image1.jpg', 'image2.jpg', ...]
# labels = [0, 1, ...]
# transform = transforms.Compose([...])
# custom_dataset = CustomDataset(image_paths, labels, transform=transform)

# DataLoader 생성
dataloader = DataLoader(custom_dataset, batch_size=32, shuffle=True, num_workers=4)

# 데이터 로딩 및 처리
for images, labels in dataloader:
    # images: (batch_size, channels, height, width) 텐서
    # labels: (batch_size,) 텐서
    # 모델 학습 코드...
    pass

위 코드에서 DataLoader는 CustomDataset에서 데이터를 32개씩 묶어 미니 배치를 생성하고, shuffle=True 옵션을 통해 데이터를 섞습니다. num_workers=4는 데이터 로딩에 4개의 프로세스를 사용하도록 지정합니다.

2) 데이터 로더의 작동 원리

DataLoader는 내부적으로 Sampler를 사용하여 데이터의 인덱스를 결정하고, collate_fn을 통해 데이터를 미니 배치로 묶습니다. num_workers를 설정하면, 데이터 로딩 작업이 여러 개의 별도 프로세스에서 병렬로 수행되어 학습 속도를 향상시킬 수 있습니다.

데이터 로더 작동 원리 설명 뒤

4. 데이터 전처리 (Data Preprocessing)

딥러닝 모델의 성능은 데이터의 품질과 형태에 크게 의존합니다. 데이터를 모델에 적합한 형태로 변환하는 전처리 과정은 매우 중요합니다. Dataset과 DataLoader를 사용하면 데이터 전처리를 효율적으로 수행할 수 있습니다.

1) torchvision.transforms 활용

torchvision.transforms 모듈은 다양한 데이터 변환 기능을 제공합니다. 이미지 크기 조정, 자르기, 회전, 색상 변환, 정규화 등 다양한 변환을 쉽게 적용할 수 있습니다.

from torchvision import transforms

# 데이터 변환 정의
transform = transforms.Compose([
    transforms.Resize((256, 256)),      # 이미지 크기 조정
    transforms.RandomCrop(224),       # 무작위 자르기
    transforms.RandomHorizontalFlip(),  # 무작위 수평 뒤집기
    transforms.ToTensor(),             # 이미지를 Tensor로 변환
    transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]) # 정규화
])

위 예제는 이미지 크기를 조정하고, 무작위로 자르고, 수평으로 뒤집고, 텐서로 변환하고, 정규화하는 변환을 정의합니다. transforms.Compose를 사용하여 여러 개의 변환을 순차적으로 적용할 수 있습니다. Normalize는 이미지의 픽셀 값을 평균과 표준편차를 사용하여 정규화합니다.

2) 사용자 정의 변환 (Custom Transformation)

torchvision.transforms에서 제공하는 기능 외에, 사용자가 직접 정의한 변환을 사용할 수도 있습니다. 사용자 정의 변환은 transforms.Lambda를 사용하여 만들거나, transforms.Compose에 함수를 직접 전달하여 구현할 수 있습니다.

from torchvision import transforms
from PIL import Image

# 사용자 정의 변환 예시: 흑백 변환
def to_grayscale(image):
    return image.convert('L') # 'L': 8-bit grayscale

# 데이터 변환 정의
transform = transforms.Compose([
    transforms.Resize((224, 224)),
    transforms.Lambda(to_grayscale),  # 사용자 정의 흑백 변환
    transforms.ToTensor(),
    transforms.Normalize(mean=[0.5], std=[0.5]) # 흑백 이미지에 맞게 정규화
])

# 데이터셋 로드 및 사용
# ...

위 예제는 to_grayscale 함수를 정의하여 이미지를 흑백으로 변환하는 사용자 정의 변환을 보여줍니다. transforms.Lambda를 사용하여 흑백 변환을 적용하고, 흑백 이미지에 맞는 정규화를 수행합니다.

3) 데이터 증강 (Data Augmentation)

데이터 증강은 데이터의 양을 늘리는 기술로, 모델의 일반화 성능을 향상시키는 데 도움을 줍니다. torchvision.transforms는 다양한 데이터 증강 기법을 제공합니다.

  • RandomHorizontalFlip: 이미지를 무작위로 수평으로 뒤집습니다.
  • RandomRotation: 이미지를 무작위 각도로 회전시킵니다.
  • ColorJitter: 이미지의 색상 (밝기, 대비, 채도, 색조)를 무작위로 조정합니다.
  • RandomResizedCrop: 이미지를 무작위로 자르고 크기를 조정합니다.
from torchvision import transforms

# 데이터 증강 변환 정의
transform = transforms.Compose([
    transforms.RandomResizedCrop(224),  # 무작위 크기 자르기
    transforms.RandomHorizontalFlip(),  # 무작위 수평 뒤집기
    transforms.ColorJitter(brightness=0.2, contrast=0.2, saturation=0.2, hue=0.1),  # 색상 왜곡
    transforms.ToTensor(),
    transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])
])

위 예제는 RandomResizedCrop, RandomHorizontalFlip, ColorJitter를 사용하여 데이터 증강을 수행합니다. 데이터 증강은 모델의 과적합을 방지하고, 일반화 성능을 향상시키는 데 기여합니다.

5. 실전 예제: 이미지 분류

MNIST 데이터셋을 사용하여 이미지 분류 모델을 학습하는 간단한 예제를 통해 Dataset, DataLoader, 데이터 전처리 과정을 실제로 적용하는 방법을 살펴보겠습니다.

import torch
import torch.nn as nn
import torch.optim as optim
from torchvision import datasets, transforms
from torch.utils.data import DataLoader

# 1. 데이터 전처리 및 데이터 로더 설정
transform = transforms.Compose([
    transforms.Resize((28, 28)),  # MNIST는 28x28 크기
    transforms.ToTensor(),
    transforms.Normalize((0.5,), (0.5,))
])

train_dataset <mark class="highlight"><strong><u> datasets.MNIST(root</u></strong></mark>'./data', train=True, download=True, transform=transform)
test_dataset <mark class="highlight"><strong><u> datasets.MNIST(root</u></strong></mark>'./data', train=False, download=True, transform=transform)

train_dataloader = DataLoader(train_dataset, batch_size=64, shuffle=True, num_workers=4)
test_dataloader = DataLoader(test_dataset, batch_size=64, shuffle=False, num_workers=4)

# 2. 모델 정의
class SimpleCNN(nn.Module):
    def __init__(self):
        super(SimpleCNN, self).__init__()
        self.conv1 = nn.Conv2d(1, 32, kernel_size=3, padding=1)  # (in_channels, out_channels, kernel_size, stride=1, padding=0)
        self.relu1 = nn.ReLU()
        self.pool1 = nn.MaxPool2d(kernel_size=2, stride=2)
        self.conv2 = nn.Conv2d(32, 64, kernel_size=3, padding=1)
        self.relu2 = nn.ReLU()
        self.pool2 = nn.MaxPool2d(kernel_size=2, stride=2)
        self.fc1 = nn.Linear(64 * 7 * 7, 10)  # MNIST 이미지 크기 고려

    def forward(self, x):
        x = self.pool1(self.relu1(self.conv1(x)))
        x = self.pool2(self.relu2(self.conv2(x)))
        x = x.view(-1, 64 * 7 * 7)  # Flatten
        x = self.fc1(x)
        return x

model = SimpleCNN()

# 3. 손실 함수 및 옵티마이저 설정
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=0.001)

# 4. 모델 학습
epochs = 5
for epoch in range(epochs):
    model.train() # 학습 모드로 설정
    running_loss = 0.0
    for i, (images, labels) in enumerate(train_dataloader):
        optimizer.zero_grad()  # Gradient 초기화
        outputs = model(images)
        loss = criterion(outputs, labels)
        loss.backward()  # 역전파
        optimizer.step()  # 가중치 업데이트

        running_loss += loss.item()
        if (i + 1) % 100 == 0:
            print(f'Epoch [{epoch+1}/{epochs}], Step [{i+1}/{len(train_dataloader)}], Loss: {running_loss/100:.4f}')
            running_loss = 0.0

# 5. 모델 평가
model.eval() # 평가 모드로 설정
correct = 0
total = 0
with torch.no_grad():
    for images, labels in test_dataloader:
        outputs = model(images)
        _, predicted = torch.max(outputs.data, 1)
        total += labels.size(0)
        correct += (predicted == labels).sum().item()

print(f'Accuracy of the model on the 10000 test images: {100 * correct / total:.2f}%')

1) 코드 설명

  • 데이터 전처리 및 데이터 로더 설정: MNIST 데이터셋을 로드하고, 이미지 크기를 조정, 텐서로 변환, 정규화하는 transform을 정의합니다. DataLoader를 사용하여 batch_size, shuffle, num_workers를 설정합니다.
  • 모델 정의: 간단한 CNN 모델(SimpleCNN)을 정의합니다. Conv2d, ReLU, MaxPool2d, Linear 레이어를 사용하여 이미지 특징을 추출하고 분류합니다.
  • 손실 함수 및 옵티마이저 설정: CrossEntropyLoss를 손실 함수로, Adam을 옵티마이저로 설정합니다.
  • 모델 학습: train_dataloader를 사용하여 모델을 학습합니다. 각 epoch마다 batch 단위로 데이터를 로드하고, forward pass, loss 계산, backward pass, optimizer.step()을 수행합니다.
  • 모델 평가: test_dataloader를 사용하여 모델의 성능을 평가합니다.

6. 주의사항과 트러블슈팅

Dataset과 DataLoader를 사용할 때 발생할 수 있는 몇 가지 문제와 해결 방법을 소개합니다.

1) 메모리 부족 (Out of Memory)

대용량 데이터를 처리하거나, batch_size를 너무 크게 설정하면 메모리 부족 오류가 발생할 수 있습니다.

  • batch_size를 줄여 봅니다.
  • num_workers를 적절하게 설정하여 데이터 로딩 속도를 조절합니다.
  • 데이터 전처리 과정에서 불필요한 연산을 최적화합니다.
  • GPU를 사용하고, CUDA 메모리 관리 기능을 활용합니다.

2) 데이터 로딩 속도 저하

num_workers가 너무 크거나, 데이터 전처리 과정이 복잡하면 데이터 로딩 속도가 느려질 수 있습니다.

  • num_workers를 조절하여 데이터 로딩 속도를 최적화합니다. (시스템의 CPU 코어 수에 따라 적절한 값을 설정)
  • 데이터 전처리 과정을 최적화하거나, 병렬 처리를 고려합니다.
  • 데이터셋을 디스크에서 읽어오는 대신, 메모리에 로드하여 접근 속도를 높입니다.

3) 데이터 불일치 (Data Mismatch)

데이터셋의 크기나 형태가 모델의 입력과 일치하지 않으면 오류가 발생할 수 있습니다.

  • Dataset의 __len__() 메서드와 __getitem__() 메서드가 정확하게 구현되었는지 확인합니다.
  • 데이터 전처리 과정에서 데이터의 형태가 모델의 입력과 일치하도록 확인합니다.
  • DataLoader에서 batch_size가 올바르게 설정되었는지 확인합니다.

7. 결론

Dataset과 DataLoader는 PyTorch에서 딥러닝 모델 학습을 위한 핵심 구성 요소입니다. 데이터를 효율적으로 관리하고, 모델에 적합한 형태로 변환하여 제공함으로써 딥러닝 모델의 성능과 효율을 크게 향상시킬 수 있습니다. 자신만의 데이터셋을 정의하고, 다양한 데이터 변환 기법을 활용하여 모델의 성능을 최적화하는 연습을 꾸준히 해보는 것이 중요합니다.

Python & Pytorch의 다른 글

Python & Pytorch
2026-01-24

3-2. PyTorch: 텐서 연산

텐서 연산(덧셈, 뺄셈, 곱셈, 나눗셈), 차원 변환
Python & Pytorch
2026-01-24

3-3. PyTorch: 자동 미분 (Autograd)

자동 미분 개념, requires_grad, grad
Python & Pytorch
2026-01-27

4-1. 신경망 기초: 선형 회귀

선형 회귀 모델 구현, 손실 함수, 경사 하강법
Python & Pytorch
2026-01-27

4-2. 신경망 기초: 로지스틱 회귀

로지스틱 회귀 모델 구현, 시그모이드 함수, 이진 분류

비슷한 글 추천

AI Project
2026-01-18

심층 강화학습 알고리즘 구현: DQN, Double DQN, PER 비교 분석

DQN, Double DQN, PER 세 가지 강화학습 알고리즘을 CartPole, Acrobot, MountainCar 환경에서 비교 실험하고 각 알고리즘의 특성과 한계를 분석한다.
Deep Learning
2026-01-08

4-3. PyTorch 설치 및 기본 사용법: 텐서 연산, 자동 미분

PyTorch 라이브러리의 설치 방법과 기본적인 사용법(텐서 연산, 자동 미분)을 소개하고, 예제 코드를 제공합니다.
Python & Pytorch
2026-01-24

3-1. PyTorch 소개: 텐서

PyTorch 소개, 텐서 생성, 텐서 자료형
Deep Learning
2026-01-08

4-5. MNIST 손글씨 숫자 인식: PyTorch 실습

MNIST 손글씨 숫자 인식 문제를 PyTorch를 이용하여 해결하는 실습 과정을 상세히 설명합니다.

Comments (0)

No comments yet. Be the first to comment!