이미지 처리

SRCNN 저화질 화질 고화질로 변환

2019. 3. 15. 23:27

요번에 제가 공부한거는 영상 화질 개선 쪽 관심을 갖게되어

한번 공부 하고 다른곳에 접목 시켜봐야겟다라는 취지로 공부하게 되엇고

이 공부를 하면서 처음으로 난관이엇던게 다른 딥러닝 과정과 다르게 이미지 처리 과정인 전처리 과정에서 꽤 애먹엇습니다

왜냐면 patch 사이즈가 잇는데 그것에 조건이 맞아야 되고 그 patch가 과연 어떤 저화질인가 원본이가 등등 생각을 하면서

알게된게 원본사진을 저화질 사진을 만들고 그리고 이미지를 patch 사이즈만큼 크롭 합니다 그리고 그 크롭된 이미지 바탕으로 학습시키는 것엿습니다

전 optimizer를 SGD 모멘트를 사용하엿고 단순한 SRCNN모델 구조 9-1-5 과정을 하엿습니다

변환 >>>

코드를 보시면

필요한 패키지들 import

import os

import numpy as np

from scipy import misc

import glob

import scipy.misc

import matplotlib.pyplot as plt

%matplotlib inline

import scipy.ndimage

import cv2

학습데이터셋 정리

path = 'Train/'

dir_path = os.path.join(os.getcwd(), path)  # 현재위치 주소를 가져온다 절대경로로

image_paths = glob.glob(os.path.join(dir_path, '*.bmp')) # glob 메소드를 활용해 bmp 파일을 전부 가져온다

patch 정보

I= 33

L= 21

stride = 21

scale =3

이미지 정보 사진으로 출력해보기

image =scipy.misc.imread(image_paths[0]).astype(np.int)
plt.imshow(image)
plt.show()
print(image.shape)

데이터 전처리 과정

inputs = []

labels = []

for path in image_paths:

    image =scipy.misc.imread(path).astype(np.int)

    h,w,c=image.shape

    h = h - np.mod(h,3)

    w = w - np.mod(w,3)

    image = image[:h, :w]

    label = image/255.0

    inp=cv2.GaussianBlur(label,(15,15),0)

    sub_inputs = []

    sub_labels = []

    h, w = inp.shape[0], inp.shape[1]

    offset = abs(I - L)//2

    for hh in range(0, h-I+1, stride):

        for ww in range(0, w-I+1, stride):

            sub_input = inp[hh:hh+I, ww:ww+I]

            sub_label = label[hh+offset:hh+offset+L, ww+offset:ww+offset+L]

            sub_input = sub_input.reshape(I, I, 3)

            sub_label = sub_label.reshape(L, L, 3)

            sub_inputs.append(sub_input)

            sub_labels.append(sub_label)

    inputs += sub_inputs

    labels += sub_labels

inputs = np.asarray(inputs) # shape (N, I, I, 1)

labels = np.asarray(labels) # shape (N, L, L, 1)

import torch

from torch.utils.data import Dataset, DataLoader

torch 데이터셋을 만들기위한 과정

class SRdataset(Dataset):

    def __init__(self):

        self.inputs,self.labels = inputs,labels

    def __len__(self):

        return self.inputs.shape[0]

    def __getitem__(self,idx):

        input_sample = self.inputs[idx]

        label_sample = self.labels[idx]

        input_sample = input_sample.transpose(2,0,1)

        label_sample = label_sample.transpose(2,0,1)

        input_sample, label_sample = torch.Tensor(input_sample), torch.Tensor(label_sample)

        return input_sample,label_sample

import torch

import torch.nn as nn

import torch.optim as optim

import torch.nn.functional as F

from torch.autograd import Variable

# 모델 정의

class SRCNN(nn.Module):

    def __init__(self):

        super(SRCNN,self).__init__()

        self.layer1 = nn.Sequential(

            nn.Conv2d(3,64,kernel_size=9),

            nn.ReLU(),

        self.layer2 = nn.Sequential(

            nn.Conv2d(64,32,kernel_size=1),

            nn.ReLU(),

        self.layer3 = nn.Sequential(

            nn.Conv2d(32,3,kernel_size=5),

    def forward(self,x):

        x = self.layer1(x)

#         print('1',x.shape)

        x = self.layer2(x)

#         print('2',x.shape)

        x = self.layer3(x)

#         print('3',x.shape)

        return x

model = SRCNN()
model

SRCNN(
  (layer1): Sequential(
    (0): Conv2d(3, 64, kernel_size=(9, 9), stride=(1, 1))
    (1): ReLU()
  )
  (layer2): Sequential(
    (0): Conv2d(64, 32, kernel_size=(1, 1), stride=(1, 1))
    (1): ReLU()
  )
  (layer3): Sequential(
    (0): Conv2d(32, 3, kernel_size=(5, 5), stride=(1, 1))
  )
)

손실함수 optimizer 등 정리

crition = nn.MSELoss()

optimizer = optim.SGD(model.parameters(),lr=1e-2,momentum=(0.9))

train_set = SRdataset()

train_loader = DataLoader(train_set,batch_size=64,shuffle=False)

Train 부분 학습하기

for epoch in range(100):

    for i in train_loader:

        model.zero_grad()

        x, y = i

        image_data = Variable(x)

        label_data = Variable(y)

        output_data = model(image_data)

        loss = crition(output_data,label_data)

        loss.backward()

        optimizer.step()

    print(epoch,loss.mean())

    torch.save(model,'rgb_model/SRCNN_model%s_%s.pkl'%(epoch+100,float(loss.mean())))

91 tensor(0.0007, grad_fn=<MeanBackward1>)
92 tensor(0.0007, grad_fn=<MeanBackward1>)
93 tensor(0.0007, grad_fn=<MeanBackward1>)
94 tensor(0.0007, grad_fn=<MeanBackward1>)
95 tensor(0.0007, grad_fn=<MeanBackward1>)
96 tensor(0.0007, grad_fn=<MeanBackward1>)
97 tensor(0.0007, grad_fn=<MeanBackward1>)
98 tensor(0.0007, grad_fn=<MeanBackward1>)
99 tensor(0.0007, grad_fn=<MeanBackward1>)

아무 사진이나 test 해보기

image = cv2.imread('166.jpg',0)
image = np.reshape(image,(512,512))
image.shape

inputs = []
labels = []
h,w,c=image.shape
h = h - np.mod(h,3)
w = w - np.mod(w,3)
image = image[:h, :w]
label = image/255.0
inp=cv2.GaussianBlur(label,(15,15),0)
h, w ,c= inp.shape 
print(h,w) 
test_input = inp.reshape(1, h, w, 3) 
test_input = test_input.transpose(0, 3, 1, 2)
test_input = torch.Tensor(test_input)
test_input = Variable(test_input)
test_output = model(test_input)
print(test_output.shape)
test_output = test_output.data.numpy()
test_output = test_output[0].transpose(1, 2, 0)
h, w = test_output.shape[0], test_output.shape[1]
test_output = test_output.reshape(h, w,3)

plt.imshow(label, cmap='gray')

plt.xticks([]),plt.yticks([])

plt.savefig('label.jpg')

plt.pause(0.005)

plt.imshow(inp, cmap='gray')

plt.xticks([]),plt.yticks([])

plt.savefig('inp.jpg')

plt.pause(0.005)

plt.imshow(test_output, cmap='gray')

plt.xticks([]),plt.yticks([])

plt.savefig('output.jpg')

원본 사진

원본사진을 저화질로 강제 변환

강제로 저화질로 된 사진을 고화질로 변환

'이미지 처리' 카테고리의 다른 글

대학생 1학년이 이해하는 Opencv 와 deel learning을 이용한 영상속에 나를 찾아서 주는 모델 (0)	2019.01.15
대학생 1학년이 이해하는 kaggle Art Images 이미지 분류 (1)	2019.01.08

대학생 1학년이 이해하는 Opencv 와 deel learning을 이용한 영상속에 나를 찾아서 주는 모델

2019. 1. 15. 19:19

만든 계기:

공부할 목적도잇고 이러한 비슷한 유형의 오픈소스도 많지만 저는 참고를 안하고 이 것을 생각하게 된 계기가 미션 임파셔블 영화를 보고 거기서 주인공 톰크루즈가 범인을 찾을때 범인 사진을 주고 그 길거리에서 범인 찾는것을 보고 아 만들어 보자 재미겟다 하고 프로젝트를 시행햇고 그결과 나름 괜찮은 모델이 만들어 졋으며, 길거리에서 나를 찾아주는것을 하고 싶지만 다른사람의 개인 정보 노출인것 같아서 해보지 못햇습니다 그렇지만 나중에 기회가 되면 한번 해보고 싶은 테스트 입니다

첫번째로는 제 얼굴 데이터를 가져오는게 첫번쨰 엿고

그리고 두번쨰로는 제 이미지와 다른 이미지 얼굴을 비교할 이미지엿습니다

이때 제가 이미지를 가져올때 사용한 모듈은 openCV이고 이것을 활용해서 제 이미지와 유투브에 볼수잇는 사람 얼굴 이미지를 가져왓습니다

이미지를 가져왓다는 기준에서 이미지를 전처리하고 학습하는 과정입니다

import torch

import torch.nn as nn

import torch.nn.functional as F

import torch.optim as optim

from torch.autograd import Variable

from torch.utils.data import DataLoader

from torch.utils.data import Dataset

import torchvision

import torchvision.transforms as transforms

import torchvision.utils as utils

import numpy as np

import pandas as pd

import os

import glob

from tqdm import tqdm_notebook

from PIL import Image

from torch.utils.data import TensorDataset

import cv2

이미지 파일을 저장한 파일 이름

dir_path ='image/'

이미지 파일을 가져 코드 입니다

class selfness(Dataset):

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

        self.Name = os.listdir(path)

        self.files = [f"{path}/{x}"for x in self.Name]

        self.path = [glob.glob(f"{x}/***.jpg")for x in self.files]

        self.transform = transform

        files = []

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

            for fileName in self.path[i]:

                files.append([i, className, fileName])

        self.path = files

        print(self.path[-2:])

        files=None

    def __len__(self):

        return len(self.path)

    def __getitem__(self,idx):

        className = self.path[idx][0]

        fileName = self.path[idx][2]

        im = Image.open(fileName)

        if self.transform:

            im = self.transform(im)

        return im,className

이미지를 가져오고 그 이미지를 ToTensor 화를 시켜 데이터셋으로 만듭니다

mean = [0.5, 0.5, 0.5]

std  = [0.5, 0.5, 0.5]

transform = transforms.Compose([

                                transforms.ToTensor(),

                                transforms.Normalize(mean, std)])

dataset = selfness(dir_path,transform=transform)

print(len(dataset))

[[1, 'train', 'image//train\\train_img98.jpg'], [1, 'train', 'image//train\\train_img99.jpg']]
5636

이 데이터 셋을 DataLoader를 통해 데이터 로드화를 시킵니다

Batsize = 100

dataloader = DataLoader(dataset=dataset,batch_size=Batsize,shuffle=True)

print(dataloader)

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

model 만들기

class Detect(nn.Module):

    def __init__(self):

        super(Detect,self).__init__()

        #64*64

        self.layer1 = nn.Sequential(

            nn.Conv2d(1,16,kernel_size=3,stride=1,padding=1),

            nn.Conv2d(16,16,kernel_size=3,stride=1,padding=1),

            nn.BatchNorm2d(16),

            nn.ReLU(),

            nn.MaxPool2d(2,2),

        #32*32

        self.layer2 = nn.Sequential(

            nn.Conv2d(16,32,kernel_size=3,stride=1,padding=1),

            nn.Conv2d(32,32,kernel_size=3,stride=1,padding=1),

            nn.Conv2d(32,32,kernel_size=3,stride=1,padding=1),

            nn.BatchNorm2d(32),

            nn.ReLU(),

            nn.MaxPool2d(2,2),

        #16*16

        self.layer3 = nn.Sequential(

            nn.Conv2d(32,64,kernel_size=3,stride=1,padding=1),

            nn.Conv2d(64,64,kernel_size=3,stride=1,padding=1),

            nn.Conv2d(64,64,kernel_size=3,stride=1,padding=1),

            nn.Conv2d(64,64,kernel_size=3,stride=1,padding=1),

            nn.BatchNorm2d(64),

            nn.ReLU(),

            nn.MaxPool2d(2,2),

        #8*8

        self.layer4 = nn.Sequential(

            nn.Conv2d(64,128,kernel_size=3,stride=1,padding=1),

            nn.Conv2d(128,128,kernel_size=3,stride=1,padding=1),

            nn.Conv2d(128,128,kernel_size=3,stride=1,padding=1),

            nn.Conv2d(128,128,kernel_size=3,stride=1,padding=1),

            nn.Conv2d(128,128,kernel_size=3,stride=1,padding=1),

            nn.BatchNorm2d(128),

            nn.ReLU(),

            nn.MaxPool2d(2,2),

        #4*4*128

        self.fc = nn.Sequential(

            nn.Linear(4*4*128,1024),

            nn.ReLU(),

            nn.Linear(1024,1024),

            nn.ReLU(),

            nn.Linear(1024,128),

            nn.ReLU(),

            nn.Linear(128,2),

    def forward(self,x):

        x = self.layer1(x)

        x = self.layer2(x)

        x = self.layer3(x)

        x = self.layer4(x)

        x = x.view(-1,4*4*128).squeeze(0)

        output = self.fc(x)

        return output

모델을 불러오고 이게 이진 분류이기떄문에 cross Entropy를 사용하엿습니다

옵티마이저는 SGD 를 사용하엿고요

model = Detect()
criterion= nn.CrossEntropyLoss()
optimizer = optim.SGD(model.parameters(),lr=0.02,momentum=0.9)

Epoch = 22

correct1 =0

size = len(dataset)

for epoch in range(Epoch):

    correct1 =0

    for i,data in enumerate(dataloader):

        model.zero_grad()

        x,y = data

        input = Variable(x)

        labels = Variable(y)

        output = model(input)

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

        loss = criterion(output,labels)

        correct1 += (output_index1 == labels).sum().float()

        if i %3 ==0:

            print(output_index1[:10])

            print(labels[:10])

            print(i,output[0], loss)

        loss.backward()

        optimizer.step()

    if correct1/size > 0.7:

        torch.save(model,'result4/detect_model_%s_%s.pkl' %(epoch,(correct1/size)))

if correct1/size > 0.96: break

    print('***********'*10)

    print(epoch,(correct1/size))

    print('***********'*10)

tensor([0, 0, 0, 0, 0, 0, 0, 0, 0, 0])
tensor([1, 0, 1, 1, 0, 0, 1, 1, 0, 0])
0 tensor([ 0.0280, -0.0438], grad_fn=<SelectBackward>) tensor(0.6926, grad_fn=<NllLossBackward>)
tensor([0, 0, 0, 0, 0, 0, 0, 0, 0, 0])
tensor([1, 0, 1, 1, 0, 1, 1, 0, 1, 1])
3 tensor([ 0.0192, -0.0182], grad_fn=<SelectBackward>) tensor(0.6747, grad_fn=<NllLossBackward>)
tensor([0, 0, 1, 0, 1, 1, 0, 0, 0, 0])
tensor([0, 0, 1, 0, 1, 1, 0, 0, 0, 0])
6 tensor([ 0.1548, -0.1646], grad_fn=<SelectBackward>) tensor(0.6105, grad_fn=<NllLossBackward>)
tensor([1, 1, 1, 0, 1, 0, 1, 1, 0, 1])
tensor([1, 1, 1, 0, 1, 0, 1, 1, 0, 1])
9 tensor([-0.0842,  0.0758], grad_fn=<SelectBackward>) tensor(0.5047, grad_fn=<NllLossBackward>)
tensor([0, 1, 0, 0, 1, 0, 1, 1, 0, 1])
tensor([0, 1, 0, 0, 1, 0, 1, 1, 0, 1])
12 tensor([ 0.0621, -0.0692], grad_fn=<SelectBackward>) tensor(0.3295, grad_fn=<NllLossBackward>)
tensor([0, 1, 0, 0, 0, 0, 1, 0, 1, 0])
tensor([0, 1, 0, 0, 0, 0, 1, 0, 1, 0])
15 tensor([ 1.2586, -1.2573], grad_fn=<SelectBackward>) tensor(0.0666, grad_fn=<NllLossBackward>)
tensor([0, 0, 0, 0, 1, 1, 0, 0, 0, 1])
tensor([0, 0, 0, 0, 1, 1, 0, 0, 0, 1])
18 tensor([ 3.9662, -3.9760], grad_fn=<SelectBackward>) tensor(0.0190, grad_fn=<NllLossBackward>)
tensor([1, 1, 1, 0, 0, 1, 1, 1, 1, 1])
tensor([1, 1, 1, 0, 0, 1, 1, 1, 0, 1])
21 tensor([-4.7700,  4.5682], grad_fn=<SelectBackward>) tensor(0.1105, grad_fn=<NllLossBackward>)
tensor([1, 0, 1, 0, 0, 0, 0, 1, 1, 1])
tensor([1, 0, 1, 0, 0, 0, 0, 1, 0, 1])
24 tensor([-4.1996,  4.0406], grad_fn=<SelectBackward>) tensor(0.3424, grad_fn=<NllLossBackward>)
tensor([0, 1, 0, 0, 1, 1, 1, 0, 0, 0])
tensor([0, 1, 0, 0, 1, 1, 0, 0, 0, 0])
27 tensor([ 5.5803, -5.6217], grad_fn=<SelectBackward>) tensor(0.2072, grad_fn=<NllLossBackward>)
tensor([0, 0, 1, 1, 1, 1, 0, 1, 0, 0])
tensor([0, 0, 1, 1, 1, 1, 0, 1, 0, 0])
30 tensor([ 8.9125, -8.9570], grad_fn=<SelectBackward>) tensor(0.0434, grad_fn=<NllLossBackward>)
tensor([1, 0, 0, 0, 0, 1, 0, 1, 1, 0])
tensor([1, 0, 0, 0, 0, 1, 0, 1, 1, 0])
33 tensor([-2.5862,  2.4938], grad_fn=<SelectBackward>) tensor(0.0365, grad_fn=<NllLossBackward>)
tensor([0, 1, 0, 1, 1, 1, 0, 1, 1, 1])
tensor([0, 1, 0, 1, 1, 1, 0, 1, 1, 1])
36 tensor([ 5.4982, -5.4998], grad_fn=<SelectBackward>) tensor(0.0100, grad_fn=<NllLossBackward>)
tensor([0, 0, 0, 0, 0, 0, 0, 1, 0, 0])
tensor([0, 0, 0, 0, 0, 0, 0, 1, 0, 0])
39 tensor([ 6.5110, -6.5401], grad_fn=<SelectBackward>) tensor(0.0181, grad_fn=<NllLossBackward>)
tensor([1, 1, 0, 1, 0, 1, 1, 0, 0, 0])
tensor([1, 1, 0, 1, 0, 1, 1, 0, 0, 0])
42 tensor([-1.8054,  1.7288], grad_fn=<SelectBackward>) tensor(0.0623, grad_fn=<NllLossBackward>)
tensor([0, 0, 1, 0, 1, 0, 0, 1, 1, 0])
tensor([0, 0, 1, 0, 1, 0, 0, 1, 1, 0])
45 tensor([ 9.7148, -9.7983], grad_fn=<SelectBackward>) tensor(0.1400, grad_fn=<NllLossBackward>)
tensor([0, 1, 0, 1, 0, 0, 0, 0, 1, 1])
tensor([0, 1, 0, 1, 0, 0, 0, 0, 1, 1])
48 tensor([ 5.6560, -5.6685], grad_fn=<SelectBackward>) tensor(0.1142, grad_fn=<NllLossBackward>)
tensor([1, 0, 1, 0, 1, 1, 0, 0, 0, 1])
tensor([1, 0, 1, 0, 1, 1, 0, 0, 0, 1])
51 tensor([-3.2274,  3.1140], grad_fn=<SelectBackward>) tensor(0.0149, grad_fn=<NllLossBackward>)
tensor([1, 1, 1, 1, 1, 1, 1, 0, 0, 0])
tensor([1, 1, 1, 1, 1, 1, 1, 0, 0, 0])
54 tensor([-2.9067,  2.7908], grad_fn=<SelectBackward>) tensor(0.0314, grad_fn=<NllLossBackward>

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

**************************************************************************************************************
0 tensor(0.9402)
**************************************************************************************************************
tensor([1, 0, 1, 0, 1, 1, 0, 1, 0, 0])
tensor([1, 0, 1, 0, 1, 1, 0, 1, 0, 0])
0 tensor([-4.0769,  3.9162], grad_fn=<SelectBackward>) tensor(0.0169, grad_fn=<NllLossBackward>)
tensor([1, 0, 1, 0, 1, 0, 1, 1, 0, 0])
tensor([1, 0, 1, 0, 1, 0, 1, 1, 0, 0])
3 tensor([-3.1147,  3.0043], grad_fn=<SelectBackward>) tensor(0.0201, grad_fn=<NllLossBackward>)
tensor([0, 1, 1, 0, 1, 1, 0, 1, 0, 0])
tensor([0, 1, 1, 0, 1, 1, 0, 1, 0, 0])
6 tensor([ 11.2800, -11.4009], grad_fn=<SelectBackward>) tensor(0.0050, grad_fn=<NllLossBackward>)
tensor([1, 1, 1, 1, 1, 1, 0, 0, 0, 0])
tensor([1, 1, 1, 1, 1, 1, 0, 0, 0, 0])
9 tensor([-3.1894,  3.0685], grad_fn=<SelectBackward>) tensor(0.0048, grad_fn=<NllLossBackward>)
tensor([1, 1, 1, 1, 0, 0, 1, 0, 0, 0])
tensor([1, 1, 1, 1, 0, 0, 1, 0, 0, 0])
12 tensor([-3.6513,  3.5146], grad_fn=<SelectBackward>) tensor(0.0027, grad_fn=<NllLossBackward>)
tensor([0, 1, 1, 1, 0, 1, 1, 0, 1, 1])
tensor([0, 1, 1, 1, 0, 1, 1, 0, 1, 1])
15 tensor([ 5.8190, -5.8288], grad_fn=<SelectBackward>) tensor(0.0011, grad_fn=<NllLossBackward>)
tensor([0, 1, 0, 1, 0, 0, 1, 0, 0, 0])
tensor([0, 1, 0, 1, 0, 0, 1, 0, 0, 0])
18 tensor([ 4.0300, -4.0859], grad_fn=<SelectBackward>) tensor(0.0059, grad_fn=<NllLossBackward>)
tensor([0, 0, 1, 1, 0, 0, 0, 0, 1, 0])
tensor([0, 0, 1, 1, 0, 0, 0, 0, 1, 0])
21 tensor([ 15.3868, -15.5231], grad_fn=<SelectBackward>) tensor(0.0003, grad_fn=<NllLossBackward>)
tensor([0, 0, 0, 0, 1, 1, 1, 1, 1, 1])
tensor([0, 0, 0, 0, 1, 1, 1, 1, 1, 1])
24 tensor([ 3.4316, -3.4660], grad_fn=<SelectBackward>) tensor(0.0004, grad_fn=<NllLossBackward>)
tensor([1, 0, 0, 1, 0, 1, 0, 0, 0, 0])
tensor([1, 0, 0, 1, 0, 1, 0, 0, 0, 0])
27 tensor([-4.5901,  4.4397], grad_fn=<SelectBackward>) tensor(0.0002, grad_fn=<NllLossBackward>)
tensor([0, 0, 1, 1, 0, 1, 1, 0, 0, 0])
tensor([0, 0, 1, 1, 0, 1, 1, 0, 0, 0])
30 tensor([ 8.0189, -8.0658], grad_fn=<SelectBackward>) tensor(0.0011, grad_fn=<NllLossBackward>)
tensor([1, 0, 0, 0, 0, 0, 1, 1, 1, 1])
tensor([1, 0, 0, 0, 0, 0, 1, 1, 1, 1])
33 tensor([-4.3459,  4.2037], grad_fn=<SelectBackward>) tensor(0.0026, grad_fn=<NllLossBackward>)
tensor([0, 0, 1, 1, 1, 0, 1, 1, 0, 1])
tensor([0, 0, 1, 1, 1, 0, 1, 1, 0, 1])
36 tensor([ 9.0171, -9.0800], grad_fn=<SelectBackward>) tensor(0.0010, grad_fn=<NllLossBackward>)
tensor([0, 0, 1, 0, 0, 0, 0, 1, 0, 0])
tensor([0, 0, 1, 0, 0, 0, 0, 1, 0, 0])
39 tensor([ 10.2416, -10.3436], grad_fn=<SelectBackward>) tensor(0.0002, grad_fn=<NllLossBackward>)
tensor([1, 1, 0, 0, 0, 0, 0, 1, 0, 0])
tensor([1, 1, 0, 0, 0, 0, 0, 1, 0, 0])
42 tensor([-5.2891,  5.1190], grad_fn=<SelectBackward>) tensor(0.0709, grad_fn=<NllLossBackward>)
tensor([1, 1, 0, 1, 0, 1, 1, 1, 1, 0])
tensor([1, 1, 0, 1, 0, 1, 1, 1, 1, 0])
45 tensor([-5.0690,  4.9150], grad_fn=<SelectBackward>) tensor(0.0007, grad_fn=<NllLossBackward>)
tensor([1, 1, 1, 1, 0, 0, 0, 1, 1, 0])
tensor([1, 1, 1, 1, 0, 0, 0, 1, 1, 0])
48 tensor([-5.1015,  4.9344], grad_fn=<SelectBackward>) tensor(0.0023, grad_fn=<NllLossBackward>)
tensor([1, 1, 1, 0, 1, 0, 0, 0, 0, 0])
tensor([1, 1, 1, 0, 1, 0, 0, 0, 0, 0])
51 tensor([-4.4345,  4.2825], grad_fn=<SelectBackward>) tensor(0.0002, grad_fn=<NllLossBackward>)
tensor([0, 1, 0, 0, 0, 0, 0, 0, 1, 0])
tensor([0, 1, 0, 0, 0, 0, 0, 0, 1, 0])
54 tensor([ 6.1383, -6.2095], grad_fn=<SelectBackward>) tensor(0.0002, grad_fn=<NllLossBackward>)
**************************************************************************************************************
1 tensor(0.9989)

detect_box= { 0:'Other', 1:'me'}

import cv2

cap = cv2.VideoCapture(0)

frame_size = (int(cap.get(3)),

             int(cap.get(4)))

face_cascade = cv2.CascadeClassifier('haarcascade_frontalface_default.xml')

fourcc = cv2.VideoWriter_fourcc(*'XVID')

out1 = cv2.VideoWriter('detect(onlyme)3.mp4',fourcc,20.0,frame_size)

while True:

    ret,img = cap.read()

    if not ret:

        break

    gray1 = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)

    gray =gray1.copy()

    faces = face_cascade.detectMultiScale(gray, 1.2, 5)

    if len(faces)>=1:

        for (x, y, w, h) in faces:

            cv2.rectangle(img, (x, y), (x + w, y + h), (0, 255, 0), 2)

            img1 = gray[y:y+h, x:x+w+20]

            img1 = cv2.resize(img1, (64, 64))

            gray1 = np.array(img1).reshape(1, 1, 64, 64)

            gray_Z = torch.from_numpy(gray1)

            gray_Y = torch.from_numpy(np.ones(1))

            gray_test = TensorDataset(gray_Z,gray_Y)

            grayloader = DataLoader(dataset=gray_test, batch_size=1)

            for data in grayloader:

                image,_ = data

                img111 = Variable(image.float())

                outputs = model(img111)

                key_box = int(torch.argmax(outputs))

        if key_box == 1:

            cv2.rectangle(img, (x, y), (x + w, y + h), (255, 0, 0), 2)

            cv2.putText(img, detect_box[1]+'(JONGWON)', (x,y+h), cv2.FONT_HERSHEY_PLAIN, 2, (255, 255, 255))

        else:

            cv2.rectangle(img, (x, y), (x + w, y + h), (0, 255, 0), 2)

            cv2.putText(img, detect_box[0], (x,y+h), cv2.FONT_HERSHEY_PLAIN, 2, (255, 255, 255))

    else:

        pass

    cv2.imshow('detect', img)

    out1.write(img)

    if cv2.waitKey(27) & 0xFF == ord('q'):

        break

cap.release()

cv2.destroyAllWindows()

'이미지 처리' 카테고리의 다른 글

SRCNN 저화질 화질 고화질로 변환 (0)	2019.03.15
대학생 1학년이 이해하는 kaggle Art Images 이미지 분류 (1)	2019.01.08

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

2019. 1. 8. 18:07

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 구별하기

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

import numpy as np
import matplotlib.pyplot as plt
%matplotlib inline
import torch
import torchvision
import torch.nn as nn
import torch.nn.functional as F
import torch.optim as optim
from torch.autograd import Variable
from torch.utils.data import DataLoader
from torch.utils.data import Dataset
import torchvision.transforms as transforms
import os,glob
from PIL import Image
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 만큰 데이터를 읽어들인다

train_loader = DataLoader(dataset = trainDataset,
                         shuffle = True,
                         batch_size = 100)
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):

    correct = 0

    scroe = 0

    for i , data in enumerate(train_loader):

        model.zero_grad()

        x,y = data

        img = Variable(x)

        label = Variable(y.long())

        output = model(img)

        loss = crition(output,label)

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

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

        loss.backward()

        optimizer.step()

    scroe = 100*(correct/7671)

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

    if scroe > 90:

        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)

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

'이미지 처리' 카테고리의 다른 글

SRCNN 저화질 화질 고화질로 변환 (0)	2019.03.15
대학생 1학년이 이해하는 Opencv 와 deel learning을 이용한 영상속에 나를 찾아서 주는 모델 (0)	2019.01.15

PREV 1 NEXT

프로가 되기 위한 노력 공간

이미지 처리

SRCNN 저화질 화질 고화질로 변환

'이미지 처리' 카테고리의 다른 글

대학생 1학년이 이해하는 Opencv 와 deel learning을 이용한 영상속에 나를 찾아서 주는 모델

model 만들기

'이미지 처리' 카테고리의 다른 글

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

다섯번째, 학습하기

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

'이미지 처리' 카테고리의 다른 글

+ Recent posts

티스토리툴바