- colab에서 pretrainedmodels설치
!pip install pretrainedmodels
- 패키지 import
import pretrainedmodels
import matplotlib.pyplot as plt
import matplotlib
import argparse
import joblib
import cv2
import os
import torch
import numpy as np
import torch.nn as nn
import torch.nn.functional as F
import torch.optim as optim
import time
import pickle
import random
import torchvision
matplotlib.style.use('ggplot')
from imutils import paths
from sklearn.preprocessing import LabelBinarizer
from sklearn.model_selection import train_test_split
from sklearn.metrics import classification_report
from torchvision.transforms import transforms
from torch.utils.data import DataLoader, Dataset
from torchvision import models, datasets
from tqdm import tqdm
def seed_everything(SEED = 42): #seed값 42
random.seed(SEED)
np.random.seed(SEED)
torch.manual_seed(SEED)
torch.cuda.manual_seed(SEED)
torch.cuda.manual_seed_all(SEED)
SEED = 42
seed_everything(SEED = SEED)
batch_size = 32
learning_rate = 0.0001
num_epoch = 5
data = datasets.Caltech101("./", download=True)
image_paths = list(paths.list_images('./caltech101/101_ObjectCategories'))
data = []
labels = []
for img_path in tqdm(image_paths):
label = img_path.split(os.path.sep)[-2] #label 두번째 앞의 faces
if label == "BACKGROUND_Google":
continue
img = cv2.imread(img_path)
img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
data.append(img)
labels.append(label)
data = np.array(data, dtype=object)
labels = np.array(labels)
torch.save(model.state_dict(), f"model_{num_epoch}.pth") # .pth로 파일 저장.
print(train_accuracy)
print(train_loss)
print(val_accuracy)
print(val_loss)
# accuracy plots
plt.figure(figsize=(10, 7))
plt.plot(train_accuracy, color='green', label='train accuracy')
plt.plot(val_accuracy, color='blue', label='validataion accuracy')
plt.xlabel('Epochs')
plt.ylabel('Accuracy')
plt.legend()
plt.savefig('accuracy.png')
plt.show()
# loss plots
plt.figure(figsize=(10, 7))
plt.plot(train_loss, color='orange', label='train loss')
plt.plot(val_loss, color='red', label='validataion loss')
plt.xlabel('Epochs')
plt.ylabel('Loss')
plt.legend()
plt.savefig('loss.png')
plt.show()
import joblib
joblib.dump(train_accuracy, 'train_accuracy.pkl') #이 받아온 데이터를 저장 가능. joblib.dump로.
joblib.dump(train_loss, 'train_loss.pkl')
joblib.dump(val_accuracy, 'val_accuracy.pkl')
joblib.dump(val_loss, 'val_loss.pkl')
#여기까지 오버피팅, 정확도 최대로 올렸는지 확인
label_names = labels
lb = LabelBinarizer()
labels = lb.fit_transform(labels)
print(len(lb.classes_))
print(labels) #원핫 인코딩 되어있는 것.
print(label_names)
count_arr = []
label_arr = []
for i in range(len(lb.classes_)):
count = 0
for j in range(len(label_names)):
if lb.classes_[i] in label_names[j]:
count += 1
count_arr.append(count)
label_arr.append(lb.classes_[i])
(x_train, x_test, y_train, y_test) = train_test_split(data, labels, test_size=0.2, stratify=labels,random_state=42)
(x_train, x_val, y_train, y_val) = train_test_split(x_train, y_train, test_size=0.25, random_state=42)
print(f"x_train examples: {x_train.shape}\\nx_test examples: {x_test.shape}\\nx_val examples: {x_val.shape}")
class CustomDataset(Dataset): #dataLoader<-numpy배열.
def __init__(self, images, labels, transforms=None):
self.x = images #X에 imges들어가고,
self.y = labels #y에 labels 들어가고,
self.transforms = transforms
def __len__(self): #길이 받아오는 것.
return (len(self.x))
def __getitem__(self, i): #item받아오는 것.
data = self.x[i][:]
if self.transforms is not None:
data = self.transforms(data)
return (data, self.y[i])
train_transform = transforms.Compose([
transforms.ToPILImage(),
transforms.Resize((224, 224)),
transforms.ToTensor(),
transforms.Normalize(mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225])
])
val_transform = transforms.Compose([
transforms.ToPILImage(),
transforms.Resize((224, 224)),
transforms.ToTensor(),
transforms.Normalize(mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225])
])
print(train_transform)
train_data = CustomDataset(x_train, y_train, train_transform) #위에 CustomDataset. 함수 만들어준 것.
val_data = CustomDataset(x_val, y_val, val_transform)
test_data = CustomDataset(x_test, y_test, val_transform)
# dataloaders
train_loader = DataLoader(train_data, batch_size=batch_size, shuffle=True, drop_last=True) #
val_loader = DataLoader(val_data, batch_size=batch_size, shuffle=True, drop_last=True) #
test_loader = DataLoader(test_data, batch_size=batch_size, shuffle=False, drop_last=True) #
def imshow(img):
plt.figure(figsize=(15, 12))
npimg = img.numpy()
plt.imshow(np.transpose(npimg, (1, 2, 0)))
plt.show()
# get some random training images
images, labels = next(iter(train_loader))
# show images
imshow(torchvision.utils.make_grid(images))
def conv_1(in_dim, out_dim):
# 1x1 연산
model = nn.Sequential(nn.Conv2d(in_dim, out_dim, 1, 1),nn.ReLU(),)
return model
def conv_1_3(in_dim, mid_dim, out_dim):
# 1x1 연산 + 3x3 연산
model = nn.Sequential(
nn.Conv2d(in_dim, mid_dim, 1, 1),
nn.ReLU(),
nn.Conv2d(mid_dim, out_dim, 3, 1, 1),
nn.ReLU()
)
return model
def conv_1_5(in_dim, mid_dim, out_dim):
# 1x1 연산 + 5x5 연산
model = nn.Sequential(
nn.Conv2d(in_dim, mid_dim, 1, 1),
nn.ReLU(),
nn.Conv2d(mid_dim, out_dim, 5, 1, 2),
nn.ReLU(),
)
return model
def max_3_1(in_dim, out_dim):
# 3x3 맥스 풀링 + 1x1 연산
model = nn.Sequential(
nn.MaxPool2d(3, 1, 1),
nn.Conv2d(in_dim, out_dim, 1, 1),
nn.ReLU(),
)
return model
class inception_module(nn.Module):
def __init__(self, in_dim, out_dim_1, mid_dim_3, out_dim_3, mid_dim_5, out_dim_5, pool):
super(inception_module, self).__init__()
self.conv_1 = conv_1(in_dim, out_dim_1)
self.conv_1_3 = conv_1_3(in_dim, mid_dim_3, out_dim_3),
self.conv_1_5 = conv_1_5(in_dim, mid_dim_5, out_dim_5),
self.max_3_1 = max_3_1(in_dim, pool)
def forward(self, x):
out_1 = self.conv_1(x)
out_2 = self.conv_1_3(x)
out_3 = self.conv_1_5(x)
out_4 = self.max_3_1(x)
output = torch.cat([out_1, out_2, out_3, out_4], 1)
return output