[딥러닝] 이미지 인식 , 컨볼루션 신경망(CNN)

MNIST 데이터셋

 -  미국 국립표준기술원(NIST)이 고등학생과 인구조사국 직원 등이 쓴 손글씨를 이용해 만든 데이터로 구성

 -  70,000개의 글자 이미지에 각각 0부터 9까지 이름표를 붙인 데이터셋

 

MNIST 데이터셋 손글씨 데이터

 

---

손글씨 이미지를 몇 %나 정확히 맞출 수 있는가?

 

 

MNIST 데이터는 케라스를 이용해 불러올 수 있다. 

mnist.load_data() 함수 : 사용할 데이터 불러오기

 

X : 불러온 이미지 데이터

Y_class : 이 이미지에 0~9까지 붙인 이름표

 

• 학습에 사용될 부분: X_train, Y_class_train

• 테스트에 사용될 부분: X_test, Y_class_test

 

from keras.datasets import mnist
(X_train, Y_class_train), (X_test, Y_class_test) = mnist.load_data()

 

 

케라스의 MNIST 데이터는 총 70,000개의 이미지 중 60,000개를 학습용으로, 10,000개를 테스트용으로 미리 구분해 놓고 있습니다. print(“학습셋 이미지 수: %d 개” % (X_train.shape[0])) print(“테스트셋 이미지 수: %d 개” % (X_test.shape[0])) 학습셋 이미지 수: 60000 개 테스트셋 이미지 수: 10000 개

 

 

불러온 이미지 중 첫 번째 이미지 불러오기

 

먼저 matplotlib 라이브러리 불러오기

imshow() 함수 : 이미지 출력

모든 이미지가 X_train에 저장되어 있으므로 X_train[0]을 통해 첫 번째 이미지를, cmap = 'Greys' 옵션 : 흑백 출력

 

import matplotlib.pyplot as plt
plt.imshow(X_train[0], cmap='Greys')
plt.show()

실행 결과

---

이 이미지를 컴퓨터는 어떻게 인식할까?

 

 

이 이미지는 가로 28 × 세로 28 = 총 784개의 픽셀로 이루어져 있다.

각 픽셀은 밝기 정도에 따라 0부터 255까지의 등급을 매긴다.

흰색 배경이 0, 글씨가 들어간 곳은 1~255까지 숫자 중 하나로 채워져

긴 행렬로 이루어진 하나의 집합으로 변환

 

 

for x in X_train[0]:
    for i in x:
        sys.stdout.write('%d\t' % i)
    sys.stdout.write('\n')

 이미지는 다시 숫자의 집합으로 바뀌어 학습셋으로 사용

28 × 28 = 784개의 속성을 이용해 0~9까지 10개 클래스 중 하나를 맞히는 문제가 된다

 

 

 

reshape() 함수 : 주어진 가로 28, 세로 28의 2차원 배열을 784개의 1차원 배열로 바꾸기

reshape(총 샘플 수, 1차원 속성의 수)

 총 샘플 수는 앞서 사용한 X_train.shape[0] 사용, 1차원 속성의 수=784개

 

X_train = X_train.reshape(X_train.shape[0], 784)

 

데이터 정규화(normalization)

 데이터의 폭이 클 때 적절한 값으로 분산의 정도를 바꾸는 과정

 

케라스는 데이터를 0에서 1 사이의 값으로 변환한 다음 구동할 때 최적의 성능

현재 주어진 데이터의 값은 0부터 255까지의 정수로, 정규화를 위해 255로 나누어 주려면 먼저 이 값을 실수형으로 바꿔야 한다

 

astype() 함수 : 실수형으로 바꾸기, 

255로 나누기

X_train = X_train.astype(‘float64’)
X_train = X_train / 255

X_test = X_test.reshape(X_test.shape[0], 784).astype(‘float64’) / 255

 

 

 

<숫자 이미지에 매겨진 이름 확인>

 

우리는 앞서 불러온 숫자 이미지가 5라는 것을 눈으로 보아 짐작할 수 있다. 실

제로 이 숫자의 레이블이 어떤지를 불러오고자 Y_class_train[0]을 다음과 같이 출력하면

 

이 숫자의 레이블 값인 5가 출력

class : 5

 

print(“class : %d “ % (Y_class_train[0]))

 

 

 

딥러닝의 분류 문제를 해결하려면 원-핫 인코딩 방식을 적용해야 한다

 

즉, 0~9까지의 정수형 값을 갖는 현재 형태에서 0 또는 1로만 이루어진 벡터로 값을 수정

np_utils.to_categorical() 함수 : 지금 우리가 열어본 이미지의 class [5]를 [0,0,0,0,0,1,0,0,0,0]로 바꾸기  

to_categorical(클래스, 클래스의 개수)

 

Y_train = np_utils.to_categorical(Y_class_train,10)
Y_test = np_utils.to_categorical(Y_class_test,10)

print(Y_train[0]) 로 확인한 결과 : [ 0. 0. 0. 0. 0. 1. 0. 0. 0. 0. 0.]

 

 

---

from keras.datasets import mnist
from keras.utils import np_utils
 
import numpy
import sys
import tensorflow as tf
  
# seed 값 설정
seed = 0
numpy.random.seed(seed)
tf.random.set_seed(3)
  
# MNIST 데이터셋 불러오기
(X_train, Y_class_train), (X_test, Y_class_test) = mnist.load_data()
 
print("학습셋 이미지 수 : %d 개" % (X_train.shape[0]))
print("테스트셋 이미지 수 : %d 개" % (X_test.shape[0]))
  
# 그래프로 확인
import matplotlib.pyplot as plt
plt.imshow(X_train[0], cmap='Greys')
plt.show()
  
# 코드로 확인
for x in X_train[0]:
    for i in x:
        sys.stdout.write('%d\t' % i)
    sys.stdout.write('\n')
  
# 차원 변환 과정
X_train = X_train.reshape(X_train.shape[0], 784)
X_train = X_train.astype('float64')
X_train = X_train / 255
 
X_test = X_test.reshape(X_test.shape[0], 784).astype('float64') / 255
  
# 클래스 값 확인
print("class : %d " % (Y_class_train[0]))
  
# 바이너리화 과정
Y_train = np_utils.to_categorical(Y_class_train, 10)
Y_test = np_utils.to_categorical(Y_class_test, 10)
 
print(Y_train[0])

 

 

---

딥러닝 실행

 

프레임 설정-총 784개의 속성, 10개의 클래스

딥러닝 프레임 : 

model = Sequential()
model.add(Dense(512, input_dim=784, activation=‘relu’))
model.add(Dense(10, activation=‘softmax’))

 

입력 값(input_dim)= 784개, 은닉층= 512개 출력= 10개인 모델

활성화 함수 -- 은닉층 relu, 출력층 softmax

그리고 딥러닝 실행 환경을 위해 오차 함수 categorical_crossentropy, 최적화 함수 adam

model.compile(loss=‘categorical_crossentropy’, optimizer=‘adam’, metrics=[‘accuracy’])

 

 

 

모델의 실행에 앞서 모델의 성과를 저장하고

10회 이상 모델의 성과 향상이 없으면 자동으로 학습 중단(모델의 최적화 단계)

import os
from keras.callbacks import ModelCheckpoint,EarlyStopping


MODEL_DIR = ’./model/’
if not os.path.exists(MODEL_DIR):
    os.mkdir(MODEL_DIR)



modelpath=”./model/{epoch:02d}-{val_loss:.4f}.hdf5”
checkpointer = ModelCheckpoint(filepath=modelpath, monitor=‘val_loss’, verbose=1, save_best_only=True)
early_stopping_callback = EarlyStopping(monitor=‘val_loss’, patience=10)

 

 

샘플 200개를 모두 30번 실행하도록,

테스트셋으로 최종 모델의 성과를 측정하여 그 값을 출력

history = model.fit(X_train, Y_train, validation_data=(X_test, Y_test), epochs=30, batch_size=200, verbose=0, callbacks=[early_stopping_callback,checkpointer])
 
print("\n Test Accuracy: %.4f" % (model.evaluate(X_test, Y_test)[1]))

 

 

학습셋의 오차를 그래프로 표현

학습셋의 오차= 1- 학습셋의 정확도

 

학습셋의 오차와 테스트셋의 오차를 그래프 하나로 나타내기

import matplotlib.pyplot as plt
 
y_vloss = history.history['val_loss']
  
# 학습셋의 오차
y_loss = history.history['loss']
  
# 그래프로 표현
x_len = numpy.arange(len(y_loss))
plt.plot(x_len, y_vloss, marker='.', c="red", label='Testset_loss')
plt.plot(x_len, y_loss, marker='.', c="blue", label='Trainset_loss')
  
# 그래프에 그리드를 주고 레이블을 표시
plt.legend(loc='upper right')
plt.grid()
plt.xlabel('epoch')
plt.ylabel('loss')
plt.show()

 

---

도식

from keras.datasets import mnist
from keras.utils import np_utils
from keras.models import Sequential
from keras.layers import Dense
from keras.callbacks import ModelCheckpoint,EarlyStopping
 
import matplotlib.pyplot as plt
import numpy
import os
import tensorflow as tf
  
# seed 값 설정
seed = 0
numpy.random.seed(seed)
tf.set_random_seed(3)
  
# MNIST 데이터 불러오기
(X_train, Y_train), (X_test, Y_test) = mnist.load_data()
 
X_train = X_train.reshape(X_train.shape[0], 784).astype('float32') / 255
X_test = X_test.reshape(X_test.shape[0], 784).astype('float32') / 255
 
Y_train = np_utils.to_categorical(Y_train, 10)
Y_test = np_utils.to_categorical(Y_test, 10)
  
# 모델 프레임 설정
model = Sequential()
model.add(Dense(512, input_dim=784, activation='relu'))
model.add(Dense(10, activation='softmax'))
  
# 모델 실행 환경 설정
model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy'])
  
# 모델 최적화 설정
MODEL_DIR = './model/'
if not os.path.exists(MODEL_DIR):
    os.mkdir(MODEL_DIR)
 
modelpath="./model/{epoch:02d}-{val_loss:.4f}.hdf5"
checkpointer = ModelCheckpoint(filepath=modelpath, monitor='val_loss', verbose=1, save_best_only=True)
early_stopping_callback = EarlyStopping(monitor='val_loss', patience=10)
  
# 모델의 실행
history = model.fit(X_train, Y_train, validation_data=(X_test, Y_test), epochs=30, batch_size=200, verbose=0, callbacks=[early_stopping_callback,checkpointer])
  
# 테스트 정확도 출력
print("\n Test Accuracy: %.4f" % (model.evaluate(X_test, Y_test)[1]))
  
# 테스트셋의 오차
y_vloss = history.history['val_loss']
  
# 학습셋의 오차
y_loss = history.history['loss']
  
# 그래프로 표현
x_len = numpy.arange(len(y_loss))
plt.plot(x_len, y_vloss, marker='.', c="red", label='Testset_loss')
plt.plot(x_len, y_loss, marker='.', c="blue", label='Trainset_loss')
  
# 그래프에 그리드를 주고 레이블을 표시
plt.legend(loc='upper right')
# plt.axis([0, 20, 0, 0.35])
plt.grid()
plt.xlabel('epoch')
plt.ylabel('loss')
plt.show()

Epoch 00009: val_loss improved from 0.05961 to 0.05732, saving model to ./model/09-0.0573.hdf5 Epoch 00010: val_loss did not improve from 0.05732

Epoch 00011: val_loss did not improve from 0.05732

Epoch 00012: val_loss did not improve from 0.05732

Epoch 00013: val_loss did not improve from 0.05732

Epoch 00014: val_loss did not improve from 0.05732

Epoch 00015: val_loss did not improve from 0.05732

Epoch 00016: val_loss did not improve from 0.05732

Epoch 00017: val_loss did not improve from 0.05732

Epoch 00018: val_loss did not improve from 0.05732

Epoch 00019: val_loss did not improve from 0.05732

10000/10000 [==============================] - 0s 33us/step

 

Test Accuracy: 0.9830

 

20번째 실행에서 멈춤

 

 

---

기본 딥러닝 프레임 +이미지 인식 분야에서 강력한 성능을 보이는 컨볼루션 신경망(Convolutional Neural Network, CNN)

 

컨볼루션 신경망 = 입력된 이미지에서 다시 한번 특징을 추출하기 위해 마스크(필터, 윈도 또는 커널이라고도 함)를 도입하는 기법

 

 

원래 값에 가중치 x1,x0을 곱하는 마스크를 한 칸씩 옮겨 적용함

새롭게 만들어진 층 = 합성곱(컨볼루션)

 

컨볼루션을 만들면 입력 데이터로부터 더욱 정교한 특징을 추출할 수 있다. 

MNIST 손글씨 인식률 향상시키기:

 

Conv2D() : 케라스에서 컨볼루션 층을 추가하는 함수

model.add(Conv2D(32, kernel_size=(3, 3), input_shape=(28, 28, 1), activation=‘relu’))

1 | 첫 번째 인자: 마스크를 몇 개 적용할지 정합니다. 앞서 살펴본 것처럼 여러 개의 마스크를 적용하면 서로 다른 컨볼루션이 여러 개 나옵니다. 여기서는 32개의 마스크를 적용했습니다.

2 | kernel_size: 마스크(커널)의 크기를 정합니다. kernel_size=(행, 열) 형식으로 정하며, 여기서는 3×3 크기의 마스크를 사용하게끔 정하였습니다.

3 | input_shape: Dense 층과 마찬가지로 맨 처음 층에는 입력되는 값을 알려주어야 합니다. input_shape=(행, 열, 색상 또는 흑백) 형식으로 정합니다. 만약 입력 이미지가 색상이면 3, 흑백이면 1을 지정합니다.

4 | activation: 활성화 함수를 정의합니다.

 

 

 

다음과 같이 마스크 64개를 적용한 새로운 컨볼루션 층을 추가할 수 있다.

model.add(Conv2D(64, (3, 3), activation=‘relu’))

 

컨볼루션층 적용 도식

풀링(pooling) 또는 서브 샘플링(sub sampling) : 컨볼루션 층을 통해 이미지 특징을 도출한 결과가 여전히 크고 복잡하면 다시 한번 축소하는 과정

풀링 기법: 맥스 풀링(max pooling) = 정해진 구역 안에서 최댓값 뽑음 , 

 평균 풀링(average pooling) =  평균값 뽑음

 

맥스 풀링(max pooling) 

원래 이미지

맥스 풀링 적용하여 구역을 나눔

각 구역에서 최댓값 뽑음

MaxPooling2D() 함수 : 맥스 풀링 구현

pool_size = 풀링 창의 크기, 2로 정하면 전체 크기가 절반으로 줄어듦

model.add(MaxPooling2D(pool_size=2))

 

드롭아웃, 플래튼

 

노드가 많아지거나 층이 많아진다고 해서 학습이 무조건 좋아지는 것은 아니다 (과적합)

학습을 실행시 가장 중요한 것은 과적합을 얼마나 효과적으로 피해가는지에 달려 있다고 해도 과언이 아니다.

과적합 방지에 간단하지만 효과가 큰 기법은 드롭아웃(drop out)

 드롭아웃 = 은닉층에 배치된 노드 중 일부를 임의로 꺼주는 것

 

 

드롭아웃의 개요, 검은색으로 표시된노드는 계산하지 않는다.  

model.add(Dropout(0.25))

 

 

예를 들어, 케라스에서 25%의 노드를 끄려면 다음과 같이 코드 작성

model.add(Flatten())

 

앞에서 Dense() 함수를 이용해 만들었던 기본 층에 연결하기 : 

 

이때 컨볼루션 층이나 맥스 풀링은 주어진 이미지를 2차원 배열인 채로 다루므로

이를 1차원 배열로 바꿔야 활성화 함수가 있는 층에서 사용 가능

 

따라서 Flatten() 함수로 2차원 배열을 1차원으로 바꾸기

 

드롭아웃과 플래튼 추가

---

전체코드 :  딥러닝 기본 프레임을 그대로 이용하되 model 설정 부분만 지금까지 나온 내용으로 바꿔주면 됨

 

from keras.datasets import mnist
from keras.utils import np_utils
from keras.models import Sequential
from keras.layers import Dense, Dropout, Flatten, Conv2D, MaxPooling2D
from keras.callbacks import ModelCheckpoint,EarlyStopping
 
import matplotlib.pyplot as plt
import numpy
import os
import tensorflow as tf
  
# seed 값 설정
seed = 0
numpy.random.seed(seed)
tf.random.set_seed(3)
  
# 데이터 불러오기
(X_train, Y_train), (X_test, Y_test) = mnist.load_data()
X_train = X_train.reshape(X_train.shape[0], 28, 28, 1).astype('float32') / 255
X_test = X_test.reshape(X_test.shape[0], 28, 28, 1).astype('float32') / 255
Y_train = np_utils.to_categorical(Y_train)
Y_test = np_utils.to_categorical(Y_test)
  
# 컨볼루션 신경망 설정
model = Sequential()
model.add(Conv2D(32, kernel_size=(3, 3), input_shape=(28, 28, 1), activation='relu'))
model.add(Conv2D(64, (3, 3), activation='relu'))
model.add(MaxPooling2D(pool_size=2))
model.add(Dropout(0.25))
model.add(Flatten())
model.add(Dense(128, activation='relu'))
model.add(Dropout(0.5))
model.add(Dense(10, activation='softmax'))
 
model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy'])
  
# 모델 최적화 설정
MODEL_DIR = './model/'
if not os.path.exists(MODEL_DIR):
    os.mkdir(MODEL_DIR)
 
modelpath="./model/{epoch:02d}-{val_loss:.4f}.hdf5"
checkpointer = ModelCheckpoint(filepath=modelpath, monitor='val_loss', verbose=1, save_best_only=True)
early_stopping_callback = EarlyStopping(monitor='val_loss', patience=10)
  
# 모델의 실행
history = model.fit(X_train, Y_train, validation_data=(X_test, Y_test), epochs=30, batch_size=200, verbose=0, callbacks=[early_stopping_callback,checkpointer])
  
# 테스트 정확도 출력
print("\n Test Accuracy: %.4f" % (model.evaluate(X_test, Y_test)[1]))
  
# 테스트셋의 오차
y_vloss = history.history['val_loss']
  
# 학습셋의 오차
y_loss = history.history['loss']
  
# 그래프로 표현
x_len = numpy.arange(len(y_loss))
plt.plot(x_len, y_vloss, marker='.', c="red", label='Testset_loss')
plt.plot(x_len, y_loss, marker='.', c="blue", label='Trainset_loss')
  
# 그래프에 그리드를 주고 레이블을 표시
plt.legend(loc='upper right')
plt.grid()
plt.xlabel('epoch')
plt.ylabel('loss')
plt.show()

Epoch 00012: val_loss improved from 0.02822 to 0.02565, saving model to ./model/12-0.0257.hdf5

Epoch 00013: val_loss did not improve from 0.02565

Epoch 00014: val_loss did not improve from 0.02565

Epoch 00015: val_loss did not improve from 0.02565

Epoch 00016: val_loss did not improve from 0.02565

Epoch 00017: val_loss did not improve from 0.02565

Epoch 00018: val_loss did not improve from 0.02565

Epoch 00019: val_loss did not improve from 0.02565

Epoch 00020: val_loss did not improve from 0.02565

Epoch 00021: val_loss did not improve from 0.02565

Epoch 00022: val_loss did not improve from 0.02565 10000/10000 [==============================] - 2s 204us/step

 

 

Test Accuracy: 0.9921