[머신러닝] Keras를 이용한 CNN으로 이미지 분류

이전 포스팅에서는

RNN을 통해서 이미지를 분류하는

방법에 대해 포스팅했었고,

---

https://lhh3520.tistory.com/375

[머신러닝] Keras를 이용한 간단한 이미지 분류

---

이번에는 CNN을 통해서

이미지를 분류하는 과정에 대해

포스팅해보겠습니다.

 

 

RNN과 마찬가지로

1. 데이터 탐색
2. 모델 구성
3. 모델 훈련
4. 평가
5. 예측하기

순으로 따라가면서 진행해 보겠습니다.

 

 

텐서 플로우와 케라스를 임포트 합니다.

import tensorflow as tf
from tensorflow import keras
from tensorflow.keras import utils
from tensorflow.keras import layers
from tensorflow.keras import datasets
from tensorflow.keras.callbacks import EarlyStopping
from tensorflow.keras.layers import Dense, Dropout, Flatten, Conv2D, MaxPooling2D

 

그다음 유용한 라이브러리들도 임포트 해줍니다.

import numpy as np
import matplotlib.pyplot as plt

 

 

 

---

1. 데이터 탐색

이미지 분류에 사용될 리소스를

불러옵니다.

cifar_mnist = datasets.cifar10

(train_images, train_labels), (test_images, test_labels) = cifar_mnist.load_data()

 

처음 로딩을 한다면

아래처럼 다운로드가 진행됩니다.

 

로드된 데이터들이 어떤 형태로

되어있는지 확인해 보겠습니다.

# 미리 정해진 사물들을 알기쉽게 텍스트로.
class_names = [
    'Airplane',
    'Car',
    'Birs',
    'Cat',
    'Deer',
    'Dog',
    'Frog',
    'Horse',
    'Ship',
    'Truck'
]

plt.figure(figsize=(10,10))
for i in range(25):
    plt.subplot(5,5,i+1)
    plt.xticks([])
    plt.yticks([])
    plt.grid(False)
    plt.imshow(train_images[i], cmap=plt.cm.binary)
    plt.xlabel(class_names[train_labels[i]])
plt.show()

 

실행해주면 대략

아래처럼 확인해 볼 수 있습니다.

 

이제 이 데이터들을

선 처리해 줍니다.

batch_size = 64
num_classes = 10
epochs = 35

train_images = train_images.astype('float32')
train_images = train_images / 255

test_images = test_images.astype('float32')
test_images = test_images / 255

train_labels = utils.to_categorical(train_labels, num_classes)
test_labels = utils.to_categorical(test_labels, num_classes)

 

 

 

---

2. 모델 구성

이제 CNN 모델을 구성해 줍니다.

model = keras.Sequential([
    Conv2D(32, kernel_size=(3, 3), padding='same', input_shape=train_images.shape[1:], activation=tf.nn.relu),
    MaxPooling2D(pool_size=(2, 2)),
    Dropout(0.25),
    
    Conv2D(64, kernel_size=(3, 3), padding='same', activation=tf.nn.relu),
    MaxPooling2D(pool_size=(2, 2)),
    Dropout(0.25),
    
    Flatten(),
    Dense(64, activation=tf.nn.relu),
    Dropout(0.25),
    Dense(num_classes, activation=tf.nn.softmax)
])

model.summary()

 

모델의 구성은 아래처럼 구성되었고,

보시다시피 RNN의 구조보다

파라미터도 많고 층도 많기 때문에

학습시간이 훨씬 더 많이 필요해집니다.

생성된 CNN 모델

 

생성된 모델을 컴파일해줍니다.

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

 

 

 

---

3. 모델 훈련

생성된 모델을 훈련시킵니다.

# 과대적합을 막기위해서 설정
early_stopping = EarlyStopping(monitor='val_loss', patience=10)

history = model.fit(
    train_images, train_labels,
    epochs=epochs,
    validation_data=(test_images, test_labels),
    shuffle=True,
    callbacks=[early_stopping]
)

 

제 컴퓨터는 CPU만 사용할 수 있어서

Epoch를 35 정도만 주었지만

학습이 반복되면서 Loss와 Acc가

점점 나아지는 걸 볼 수 있습니다.

학습시간이 RNN에 비해서 꽤나 오래 걸립니다.

 

 

---

4. 평가

훈련이 완료되고 나면 훈련이 제대로 되었는지

테스트를 진행해 줍니다.

loss, acc = model.evaluate(test_images, test_labels)

print("\nLoss: {}, Acc: {}".format(loss, acc))

학습을 충분히 시키지 못해서

Loss도 약간 높고 Acc도 약간 낮은

수치가 나왔습니다.

 

모델을 어떤 과정으로 학습했는지

확인해 보자면..

def plt_show_loss(history):
    plt.plot(history.history['loss'])
    plt.plot(history.history['val_loss'])
    plt.title('Model Loss')
    plt.ylabel('Loss')
    plt.xlabel('Epoch')
    plt.legend(['Train', 'Test'], loc=0)

def plt_show_acc(history):
    plt.plot(history.history['acc'])
    plt.plot(history.history['val_acc'])
    plt.title('Model accuracy')
    plt.ylabel('Accuracy')
    plt.xlabel('Epoch')
    plt.legend(['Train', 'Test'], loc=0)
    
plot_loss(history)
plt.show()

plot_acc(history)
plt.show()

좋은 학습 그래프를 그려주고 있지만

학습량이 모자라서 정확도가 약간

낮은 것을 확인할 수 있습니다.

 

학습의 횟수를 늘려주고,

GPU를 통해서 더 빠르게

학습을 진행해 주는 방식으로

해결해 볼 수 있을 것 같습니다.

 

 

 

---

5. 예측하기

위에서 훈련된 모델을 가지고

예측을 해봅니다.

# 예측
predictions = model.predict(test_images)

 

 

예측된 데이터들을 가지고

보기 쉽게 표로 그려봅니다.

def plot_image(i, predictions_array, true_label, img):
  predictions_array, true_label, img = predictions_array[i], true_label[i], img[i]
  plt.grid(False)
  plt.xticks([])
  plt.yticks([])

  plt.imshow(img, cmap=plt.cm.binary)

  predicted_label = np.argmax(predictions_array)
  if predicted_label == np.argmax(true_label):
    color = 'blue'
  else:
    color = 'red'

  plt.xlabel("{} {:2.0f}% ({})".format(class_names[predicted_label],
                                100*np.max(predictions_array),
                                class_names[np.argmax(true_label)]),
                                color=color)

def plot_value_array(i, predictions_array, true_label):
  predictions_array, true_label = predictions_array[i], true_label[i]
  plt.grid(False)
  plt.xticks([])
  plt.yticks([])
  thisplot = plt.bar(range(10), predictions_array, color="#777777")
  plt.ylim([0, 1])
  predicted_label = np.argmax(predictions_array)

  thisplot[predicted_label].set_color('red')
  thisplot[np.argmax(true_label)].set_color('blue')
  
  
num_rows = 5
num_cols = 3
num_images = num_rows*num_cols
plt.figure(figsize=(2*2*num_cols, 2*num_rows))
for i in range(num_images):
  plt.subplot(num_rows, 2*num_cols, 2*i+1)
  plot_image(i, predictions, test_labels, test_images)
  plt.subplot(num_rows, 2*num_cols, 2*i+2)
  plot_value_array(i, predictions, test_labels)
plt.show()

이미지가 작아서 잘 안 보이지만..

대략적으로 이미지 예측을

잘하고 있음을 알 수 있습니다.