[DACON] 사물 이미지 분류 경진대회 With Pytorch
from google.colab import drive
drive.mount('/content/drive')
코랩과 구글 드라이브를 연동하는 코드입니다. 구글 드라이브 내 파일을 코랩에서도 접근할 수 있게됩니다.
# !unzip -qq '/content/drive/MyDrive/ObjectDetect/data.zip'
데이터를 저장하는 다른 더 좋고 빠른 방법이 있을 수도 있는데, 제가 발견한 방법 중 가장 좋은 방법을 소개합니다.
우선 데이콘 내 데이터를 압축된 형태로 다운받고, 구글 드라이브 내 압축된 파일 그대로 업로드 합니다.
(제 기준 /content/drive/MyDrive/ObjectDetect 공간에 data.zip 파일을 넣었습니다. 여러분 상황에 맞게 주소를 바꾸시면 됩니다.)
그 후 위 코드를 주석을 해제한 뒤 주소를 data.zip을 저장한 위치로 수정하시고 코드를 실행하시면 약 5분 뒤 압축 해제가 잘 됩니다.
압축 해제 후 구글 드라이브 업로드, 구글 드라이브 내 압축 해제보다는 이 방법이 괜찮은 것 같아 소개합니다.
더 좋은 방법 있으면 같이 공유 부탁드려요~
import os
from glob import glob
from typing import Tuple, Sequence, Callable
import numpy as np
import pandas as pd
import PIL
from PIL import Image
from matplotlib.pyplot import imshow
import torch
import torch.optim as optim
from torch import nn, Tensor
import torch.nn.functional as F
from torch.utils.data import Dataset, DataLoader
!pip install torchinfo
from torchinfo import summary
import torchvision
from torchvision import transforms
from torchvision.models import resnet50
from tqdm import tqdm, tqdm_notebook
파이토치, 넘파이, 판다스 등 필요한 패키지를 임포트 했습니다.
path = '/content/drive/MyDrive/ObjectDetect/'
batch_size = 32
num_epochs = 20
learning_rate = 0.001
labels = {0:'airplane', 1:'automobile', 2:'bird', 3:'cat', 4:'deer',
5:'dog', 6:'frog', 7:'horse', 8:'ship', 9:'truck'}
# gpu 사용중일땐 cuda, gpu 사용 불가능할땐 cpu 사용.
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
torch.manual_seed(777)
if device =='cuda':
torch.cuda.manual_seed_all(777)
데이터의 저장 위치와 배치 사이즈, 에포크 수, 러닝 레이트 값, 장치 등을 지정했습니다.
각 레이블 번호는 알파벳 순서대로 배정했습니다.
이 코드를 따라하신다면 path만 파일 저장 위치로 바꾸시면 됩니다.
img = Image.open(path + 'train/airplane/0001.jpg')
imshow(np.asarray(img))
PIL와 matplotlib 패키지를 가지고 이미지를 시각화 할 수 있습니다.
데이터 분석을 하기 전 그래도 이미지 데이터인데 한번 시각적으로 확인했습니다.
train_images = []
train_labels = []
i = 0
for filename in sorted(glob(path + "train/*")):
for img in tqdm(glob(filename + "/*.jpg")):
an_img = PIL.Image.open(img) # 이미지를 읽습니다.
img_array = np.array(an_img) # 이미지 데이터를 숫자로 변환합니다.
train_images.append(img_array) # 리스트에 데이터 실기.
label = i
train_labels.append(label)
i += 1 # 다음 폴더에는 다음 라벨
train_images = np.array(train_images)
print(train_images.shape)
파이토치 내 ImageFolder 함수를 사용하는 것이 편리하지만, 이후 모델 학습시 데이터를 찾을때 계속 구글드라이브를 탐색하는 형태이기 때문에 지나치게 느립니다.
그래서 트레인 데이터를 폴더 별로 반복문을 사용해 모두 직접 다운로드 하였습니다.
sorted로 폴더 이름을 정렬한 뒤 i를 업데이트 했기 때문에 알파벳 순서대로 라벨 숫자를 입력했습니다.
입력된 데이터를 관찰하면 개수가 5만개이며 32 * 32 이미지 픽셀이고, 3채널(RGB값) 으로 구성되있습니다!
test_images = []
for filename in tqdm(sorted(glob(path + "test/*.jpg"))):
an_img = PIL.Image.open(filename) # 이미지를 읽습니다.
img_array = np.array(an_img) # 이미지 데이터를 숫자로 변환합니다.
test_images.append(img_array) # 리스트에 데이터 실기.
test_images = np.array(test_images)
테스트 데이터도 마찬가지로 진행했습니다.
class CustomDataset(Dataset):
def __init__(self, transform, mode = 'train'):
self.transform = transform
if mode == 'train':
self.img_list = train_images
self.img_labels = train_labels
elif mode == 'test':
self.img_list = test_images
self.img_labels = [0] * 10000 # 형식을 맞추기 위해
def __len__(self):
return len(self.img_list)
def __getitem__(self, idx):
return self.transform(self.img_list[idx]), self.img_labels[idx]
파이토치 내 Dataset 클래스를 상속해서 Dataset을 정의했습니다. 뒤에 다루는 DataLoader 클래스와 호환이 되기 때문에 반드시 필요합니다.
추상 클래스이기 때문에 반드시 새로 정의해야 하는 함수는 init, len, getitem 입니다.
init 부분은 클래스 선언시 자동으로 실행되는 함수입니다. 생성자 개념이죠. 이미지 데이터와 라벨값을 저장해줍니다.
이때 테스트 데이터는 라벨이 없지만, 형식을 맞춰주기 위해 임의로 0라벨을 붙히겠습니다.
len 부분은 데이터 길이만 배출하면 됩니다. getitem 부분은 정해진 인덱스의 데이터를 출력해줘야 합니다.
DataLoader가 len과 getitem 함수를 사용하기 때문에 잘 정의해야합니다.
tensor = transforms.Compose(
[transforms.ToTensor()]
)
train_set = CustomDataset(tensor, mode = 'train')
test_set = CustomDataset(tensor, mode = 'test')
파이토치 모델은 텐서 단위로 다루기 때문에 텐서로 변환하는 transforms 을 만든 뒤 데이터 셋을 만듭니다.
meanRGB = [np.mean(x.numpy(), axis=(1,2)) for x,_ in train_set]
stdRGB = [np.std(x.numpy(), axis=(1,2)) for x,_ in train_set]
meanR = np.mean([m[0] for m in meanRGB])
meanG = np.mean([m[1] for m in meanRGB])
meanB = np.mean([m[2] for m in meanRGB])
stdR = np.mean([s[0] for s in stdRGB])
stdG = np.mean([s[1] for s in stdRGB])
stdB = np.mean([s[2] for s in stdRGB])
print(meanR, meanG, meanB)
print(stdR, stdG, stdB)
입력된 이미지 데이터를 정규화(표준화) 시켜주겠습니다. 정규화를 위해서 표본 평균과 표준오차를 구하는 모습입니다.
transform = transforms.Compose([
transforms.ToTensor(),
transforms.Normalize([meanR, meanG, meanB], [stdR, stdG, stdB])
])
train_set.transform = transform
test_set.transform = transform
파이토치 내 Compose 함수를 한번 더 사용하고, 앞서 구한 표본평균과 표준오차를 이용해 transform을 만들었습니다.
데이터를 데이터 셋 형태로 정리했기 때문에 'train_set.transform = transform' 이 코드만 사용하면 간편하게 적용이 가능합니다.
train_set.__len__()
train_set.__getitem__(40)
실제 값으로 확인해보면 32 * 32가 맞는것으로 보이며, 뒤에 라벨 값으로 0이 달려있는 모습입니다.
len , getitem 함수로 데이터 값을 불러올 수 있는 걸 보니 파이토치 내 Dataset 클래스 형태로 데이터가 잘 입력된 것 같습니다.
train_loader = DataLoader(train_set, batch_size = batch_size, num_workers=2, shuffle=True)
test_loader = DataLoader(test_set, batch_size = batch_size, num_workers=2)
앞서 정의한 데이터 셋을 파이토치 내 데이터 로더에 실습니다. 이렇게 하는 이유는 배치단위로 모델에 적용하기 쉽기 때문입니다.
여기서 중요한 점은 테스트 데이터는 셔플을 해줘야 합니다. 데이터가 라벨 값으로 정렬되어 있는데, 학습에 큰 문제가 되기 때문입니다.
셔플을 True로 해주게 되면 또 하나의 장점이 에포크가 바뀔때마다 로더 내 데이터 패치를 다시 섞어줍니다.
for batch_idx, samples in enumerate(train_loader):
if batch_idx > 0:
break
print(samples[0].shape)
print(samples[1])
데이터 로더를 보다 상세히 관찰해보면 배치단위, 채널수, 32 * 32 로 잘 들어가 있는걸 관찰할 수 있으며, 라벨값도 잘 들어가 있습니다.
class Model(nn.Module):
def __init__(self) -> None:
super().__init__()
self.resnet = resnet50(pretrained=False)
self.classifier = nn.Linear(1000, 10)
def forward(self, x):
x = self.resnet(x)
x = self.classifier(x)
return x
파이토치 내 nn.Module 클래스를 상속하고 resnet50 을 사용하여 모델을 정의했습니다.
이때 대회 규칙 상 사전학습이 안되므로 pretrained=False 로 잘 지정해줘야합니다.
model = Model().to(device)
print(summary(model, input_size = (1,3,32,32)))
파이토치에서 중요하게 알아두어야 할 것이 디바이스(GPU를 주로 사용합니다) 내 실어줘야 하는것이 모델과 입력 값, 라벨 값 입니다.
여기서 to(device) 를 사용하여 모델을 디바이스 내 실어주었습니다.
앞서 정의한 모델을 직관적으로 관찰하기 위해 torchinfo(summary) 를 사용하였습니다.
모델 구조가 복잡한 것도 그렇고, 모델 파라미터는 25,567,042개니 역시 '딥'러닝이네요.
optimizer = optim.Adam(model.parameters(), lr = learning_rate)
criterion = nn.CrossEntropyLoss()
model.train()
for epoch in range(num_epochs):
for i, (images, targets) in tqdm(enumerate(train_loader)):
optimizer.zero_grad()
images = images.to(device)
targets = targets.to(device)
outputs = model(images)
loss = criterion(outputs, targets)
loss.backward()
optimizer.step()
if (i+1) % 200 == 0:
max_vals, max_indices = torch.max(outputs, 1)
acc = (targets == max_indices).float().mean()
print(f'{loss.item():.5f}, {acc.item():.5f}')
옵티마이저로 Adam을, 손실함수로 크로스엔트로피 함수를 사용합니다. 파이토치 내 전부 내장되어있죠.
모델을 학습형태로 바꾼 뒤 설정한 에포크 만큼 학습을 진행하겠습니다. 20 에포크 코랩 무료 GPU 기준 1시간정도 걸리네요.
a = [[0.1, 0.2, 0.3], [0.3,0.4,0.2]]
a = torch.tensor(a)
torch.max(a, 1)
파이토치 내 max 함수를 사용했을때 결과입니다. 결과를 보시면 윗 반복문 내 if문을 저렇게 사용했는지 아실것 같습니다.
sample_submission = pd.read_csv(path + 'sample_submission.csv')
model.eval()
batch_index = 0
for i, (images, targets) in enumerate(test_loader):
images = images.to(device)
outputs = model(images)
batch_index = i * batch_size
max_vals, max_indices = torch.max(outputs, 1)
sample_submission.iloc[batch_index:batch_index + batch_size, 1:] = max_indices.long().cpu().numpy()[:,np.newaxis]
모델을 평가모드로 바꾸고 (가중치 업데이트를 하지 않기 때문입니다.) 테스트 데이터 로더를 모델에 넣습니다.
테스트 데이터도 마찬가지로 gpu 사용을 위해선 device에 넣어줘야 합니다.
labels = {0:'airplane', 1:'automobile', 2:'bird', 3:'cat', 4:'deer',
5:'dog', 6:'frog', 7:'horse', 8:'ship', 9:'truck'}
sample_submission['target'] = sample_submission['target'].map(labels)
sample_submission.to_csv('dacon_object_1.csv', index=False)
숫자로 나온 값을 문자로 매핑시킨 뒤 csv 파일로 저장합니다. public 값 기준 0.7662정도 나왔는데 과적합이 된 것으로 보여요.