파이토치 데이터 공정

import torch, torchvision

print('PyTorch', torch.__version__)

from pathlib import Path

data_dir = Path('data/oxford-iiit-pet')
assert data_dir.exists() and data_dir.is_dir(), f'{data_dir} 경로가 존재하지 않습니다.'

이미지파일 = list((data_dir / 'images').glob('*.jpg'))
이미지파일.sort()
print(f'파일 개수: {len(이미지파일)}')
print(f'첫 번째 파일: {이미지파일[0]}')

from pathlib import Path
from PIL import Image

class OxfordIIITPetDataset:
    def __init__(self, 폴더, transform=None, return_image_id=False):
        dir_path = Path(폴더)
        assert dir_path.exists() and dir_path.is_dir(), f'{폴더} 경로가 존재하지 않습니다.'
        
        self.이미지파일 = list((dir_path / 'images').glob('*.jpg'))
        self.이미지파일.sort()
        self.transform = transform
        self.return_image_id = return_image_id

    def __len__(self):
        return len(self.이미지파일)
    
    def __getitem__(self, idx):
        이미지경로 = self.이미지파일[idx]
        sample = None
        with Image.open(이미지경로) as img:
            # 이미지 객체를 반환하려면 복사본을 만들어야 합니다.
            sample = img.copy()

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

        if self.return_image_id:
            return {'img_id': 이미지경로.name, 'sample': sample}
        
        return sample

dataset = OxfordIIITPetDataset('data/oxford-iiit-pet', transform=None)
print(f'데이터셋 크기: {len(dataset)}')
sample = dataset[0]
print(type(sample), sample.size, sample.mode)

transform = torchvision.transforms.Compose([
    torchvision.transforms.Resize((200, 200)),
    torchvision.transforms.ToTensor()])

dataset = OxfordIIITPetDataset('data/oxford-iiit-pet', transform=transform)
sample = dataset[0]
print(type(sample), sample.shape, sample.dtype, sample.device)

dataset = OxfordIIITPetDataset('data/oxford-iiit-pet', transform=transform, return_image_id=True)
sample = dataset[0]
print(type(sample), sample['img_id'], type(sample['sample']))

transform = torchvision.transforms.Compose([
    # 배치를 위해 3채널로 변환
    torchvision.transforms.Lambda(lambda img: img.convert('RGB')),
    torchvision.transforms.Resize((200, 200)),
    torchvision.transforms.ToTensor()])

dataset = OxfordIIITPetDataset('data/oxford-iiit-pet', transform=transform)
loader = torch.utils.data.DataLoader(dataset, batch_size=32, shuffle=True)

batch = next(iter(loader))
print(type(batch), batch.shape, batch.dtype, batch.device)

# 배치 크기별 로드 속도 측정
import time
import pandas as pd

batch_sizes = [1, 8, 32, 64, 128, 256, 512, 1024]

results = {}
for num_workers in [0, 2, 4, 8]:
    print(f'멀티 프로세스 수: {num_workers}')
    for batch_size in batch_sizes:
        print(f'배치 크기: {batch_size}', end=' ')
        loader = torch.utils.data.DataLoader(
            dataset, batch_size=batch_size, shuffle=True, num_workers=num_workers)
        
        start_time = time.time()
        for batch in loader:
            pass
        end_time = time.time()
        
        elapsed_time = end_time - start_time
        print(f'소요 시간 (초): {elapsed_time:.1f}')
        results[(batch_size, num_workers)] = elapsed_time

frame = pd.Series(results).unstack(level=1)
frame.index.name = 'batch size'
frame.columns.name = 'num_workers'
frame.round(1)