대학생 1학년이 이해하는 kaggle Art Images 이미지 분류

https://www.kaggle.com/thedownhill/art-images-drawings-painting-sculpture-engraving

이미지 데이터 :  https://www.kaggle.com/thedownhill/art-images-drawings-painting-sculpture-engraving

이미지 데이터를 가지고 Drawing/Painting/Sculptures/Engravings/Iconography 구별하기

첫번째. 필요한 모듈 가져오기

2

import numpy as np

3

import matplotlib.pyplot as plt

4

%matplotlib inline

5

import torch

6

import torchvision

7

import torch.nn as nn

8

import torch.nn.functional as F

9

import torch.optim as optim

10

from torch.autograd import Variable

11

from torch.utils.data import DataLoader

12

from torch.utils.data import Dataset

13

import torchvision.transforms as transforms

14

import os,glob

15

from PIL import Image

16

import torchvision.transforms as transforms

두번째, 파라미터 설정

dir_path = 'training_set'    #파일 경로

batsize = 100                 #batchsize

lr = 0.002                   #running rate(학습률)

셋번째, 폴더에 잇는 이미지 파일 torch화 하기

class drawing(Dataset):

    def __init__(self,path,transform=None):

        self.className = os.listdir(path)    #self.className에 우리가 읽어야하는 폴더 이름이 들어감(예를 들면 Drawing...)

        self.path = [f"{path}/{x}/" for x in self.className]  # 파일 경로+ 우리가 가져왓던 폴더이름을 더해 경로를 지정한다

        self.file_list = [glob.glob(f"{x}/*") for x in self.path]  # 가져온 경로에 glob메소드를 *을 이용해 모든 파일을 가져온다

        self.transform = transform

        files = []

        for i, Name in enumerate(self.className):

            for j in self.file_list[i]:

                files.append([i,Name,j])

        print(len(files))         # 잘가져왓는지 확인할수잇게 len()함수를 써서 확인한다

        self.file_list = files

        files= None

    def __len__(self):

        return len(self.file_list)

    def __getitem__(self,idx):

        className = self.file_list[idx][0]

        fileName = self.file_list[idx][2]

        im = Image.open(fileName)

        if self.transform:       # 원래 이미지가 (Imgsize,Imgsize,channel)인데 이것을 (channel,Imgsize,Imgsize)로 변환한다

            im = self.transform(im) 

        return im,className      # 각 폴더에서 가져온 이미지의 라벨과 이미지를 반환한다    

# 이미지크기를 (120,120)으로 바꾸고 이미지값을 Normalize를 시키고 trainDataset으로 바꾼다

mean = [0.5, 0.5, 0.5]

std  = [0.5, 0.5, 0.5]

transform = transforms.Compose([

                                transforms.Scale((120,120)),

                                transforms.ToTensor(),

                                transforms.Normalize(mean, std)])

trainDataset = drawing(dir_path,transform=transform)

C:\anaconda\envs\py36\lib\site-packages\torchvision\transforms\transforms.py:188: UserWarning: The use of the transforms.Scale transform is deprecated, please use transforms.Resize instead.
  "please use transforms.Resize instead.")

7671

# 데이터 셋을 데이터 로더 형태로 변환해서 batch_size 만큰 데이터를 읽어들인다

1

train_loader = DataLoader(dataset = trainDataset,

2

                         shuffle = True,

3

                         batch_size = 100)

4

print(train_loader)

<torch.utils.data.dataloader.DataLoader object at 0x000001B1FE41E9E8>

넷번째, 모델 생성

class NNNNN1(nn.Module):
2
    def __init__(self):
3
        super(NNNNN1,self).__init__()
4
        #120*120
5
        self.layer1 = nn.Sequential(
6
            nn.Conv2d(3,16,kernel_size=3,stride=1,padding=1),
7
            nn.Conv2d(16,16,kernel_size=3,stride=1,padding=1),
8
            nn.BatchNorm2d(16),
9
            nn.LeakyReLU(),
10
            nn.MaxPool2d(2,2)
11
        )
12
#60*60
13
        self.layer2 = nn.Sequential(
14
            nn.Conv2d(16,32,kernel_size=3,stride=1,padding=1),
15
            nn.Conv2d(32,32,kernel_size=3,stride=1,padding=1),
16
            nn.BatchNorm2d(32),
17
            nn.ReLU(),
18
            nn.MaxPool2d(2,2),
19
        )
20
       #30*30
21
        self.layer3 = nn.Sequential(
22
            nn.Conv2d(32,64,kernel_size=3,stride=1,padding=1),
23
            nn.Conv2d(64,64,kernel_size=3,stride=1,padding=1),
24
            nn.BatchNorm2d(64),
25
            nn.ReLU(),
26
            nn.MaxPool2d(2,2),
27
        )
28
        #15*15
29
        self.layer4 = nn.Sequential(
30
            nn.Conv2d(32*2,32*4,kernel_size=3,stride=1,padding=1),
31
            nn.Conv2d(32*4,32*4,kernel_size=3,stride=1,padding=1),
32
            nn.Conv2d(32*4,32*4,kernel_size=3,stride=1,padding=1),
33
            nn.BatchNorm2d(32*4),
34
            nn.ReLU(),
35
            nn.MaxPool2d(2,2),
36
        )
#7*7
37
        self.fc = nn.Sequential(
38
            nn.Linear(32*4*7*7,1024),
39
            nn.ReLU(),
40
            nn.Linear(1024,1024),
41
            nn.ReLU(),
42
            nn.Linear(1024,258),
43
            nn.ReLU(),
44
            nn.Linear(258,5),
45
        )
46
​
47
    def forward(self,x):
48
        x = self.layer1(x)
49
        x = self.layer2(x)
50
        x = self.layer3(x)
51
        x = self.layer4(x)
52
        x = x.view(-1,32*4*7*7)
53
        output = self.fc(x)
54
        return output

model = NNNNN1()

model11 = model.state_dict().keys()

​

for i in model11:

    print(i)

layer1.0.weight
layer1.0.bias
layer1.1.weight
layer1.1.bias
layer1.2.weight
layer1.2.bias
layer1.2.running_mean
layer1.2.running_var
layer1.2.num_batches_tracked
layer2.0.weight
layer2.0.bias
layer2.1.weight
layer2.1.bias
layer2.2.weight
layer2.2.bias
layer2.2.running_mean
layer2.2.running_var
layer2.2.num_batches_tracked
layer3.0.weight
layer3.0.bias
layer3.1.weight
layer3.1.bias
layer3.2.weight
layer3.2.bias
layer3.2.running_mean
layer3.2.running_var
layer3.2.num_batches_tracked
layer4.0.weight
layer4.0.bias
layer4.1.weight
layer4.1.bias
layer4.2.weight
layer4.2.bias
layer4.3.weight
layer4.3.bias
layer4.3.running_mean
layer4.3.running_var
layer4.3.num_batches_tracked
fc.0.weight
fc.0.bias
fc.2.weight
fc.2.bias
fc.4.weight
fc.4.bias
fc.6.weight
fc.6.bias

# 손실함수 optimizer 생성

crition = nn.CrossEntropyLoss()

optimizer = torch.optim.SGD(model.parameters(),lr = lr , momentum=0.9)

다섯번째, 학습하기

for epoch in range(40):

2

    correct = 0

3

    scroe = 0

4

    for i , data in enumerate(train_loader):

5

        model.zero_grad()

6

        x,y = data

7

        img = Variable(x)

8

        label = Variable(y.long())

9

10

        output = model(img)

11

        loss = crition(output,label)

12

        _,predict = torch.max(output,1)

13

        correct += (predict == label).sum().float()

14

        loss.backward()

15

        optimizer.step()       

16

    scroe = 100*(correct/7671)

17

    print("{} Accursy : {}".format(epoch,scroe))

18

    if scroe > 90:

19

        torch.save(model,'drawing_model_%s_%s' %(epoch,int(scroe)))

0 Accursy : 46.74748992919922
1 Accursy : 67.48794555664062
2 Accursy : 75.1531753540039
3 Accursy : 79.03793334960938
4 Accursy : 81.81462860107422
5 Accursy : 83.47021484375
6 Accursy : 83.90040588378906
7 Accursy : 85.73849487304688
8 Accursy : 86.53369903564453
9 Accursy : 87.34193420410156
10 Accursy : 88.82804870605469
11 Accursy : 88.68465423583984
12 Accursy : 90.4706039428711

C:\anaconda\envs\py36\lib\site-packages\torch\serialization.py:250: UserWarning: Couldn't retrieve source code for container of type NNNNN1. It won't be checked for correctness upon loading.
  "type " + obj.__name__ + ". It won't be checked "

13 Accursy : 91.81332397460938
14 Accursy : 92.20440673828125
15 Accursy : 93.87303161621094
16 Accursy : 94.02946472167969
17 Accursy : 95.09842681884766
18 Accursy : 94.98109436035156
19 Accursy : 97.19723510742188
20 Accursy : 98.52691650390625
21 Accursy : 99.13961791992188
22 Accursy : 99.66105651855469
23 Accursy : 99.83053588867188
24 Accursy : 99.93482208251953
25 Accursy : 99.92178344726562
26 Accursy : 99.9869613647461
27 Accursy : 100.0
28 Accursy : 100.0

여섯번째, test 데이터 평가하기

test_file = 'validation_set'

transform = transforms.Compose([

                                transforms.Scale((120,120)),

                                transforms.ToTensor(),

                                transforms.Normalize(mean, std)])

testDataset = drawing(test_file,transform=transform)

850

test_loader = DataLoader(dataset = testDataset,

                         shuffle = False)

print(train_loader)

<torch.utils.data.dataloader.DataLoader object at 0x000001B1FE41E9E8>

#이미지 데이터가 torch화 하면서 채널이 3이 아닌 애들이 발생하면 그 데이터를 제거 해줘야되기때문에 어느 데이터가 잘못되엇는지 확인하는 과정

for i,data in enumerate(test_loader):
2
    x,y = data
3
    if x.shape[1] != 3:
4
        print(x.shape)
5
        print(y)

# 평가하기

correct = 0
2
scroe = 0
3
for i , data in enumerate(test_loader):
4
    x,y = data
5
    img = Variable(x)
6
    label = Variable(y.long())
7
        
8
    output = model(img)
9
    _,predict = torch.max(output,1)
10
    correct += (predict == label).sum().float()
11
scroe = 100*(correct/850)
12
print("Accursy : {}".format(scroe))

Accursy : 62.0