2-1. 머신러닝 모델 학습시키기

본 강좌는 2번째 강좌에 포함되있는 Google Colab 내용을 번역한 것입니다.

(https://colab.research.google.com/github/tensorflow/examples/blob/master/lite/codelabs/digit_classifier/ml/step2_train_ml_model.ipynb#scrollTo=XXX8WpQI5U6_)

 

- Copyright 2019 The Tensorflow Authors.

 

Step 2: 머신러닝 모델 학습시키기

 

이 Notebook은 Build a handwritten digit classifier app with Tensorflow Lite 의 2번째 강의에 대한 것입니다.

 

의존성 모델 설치하기

 

우리는 데이터 처리와 시각화를 위해 쓰이는 Tensorflow와 다른 모듈을 설치함으로써 시작할 것입니다.

# TensorFlow and tf.keras
import tensorflow as tf
from tensorflow import keras

# Helper libraries
import numpy as np
import matplotlib.pyplot as plt
import random

print(tf.__version__)

MNIST 데이터셋을 다운로드하고 탐험하기

 

이 MNIST 데이터베이스는 손글씨 숫자가 있는 6만개의 학습 이미지와 1만개의 시험 이미지를 포함합니다.

우리는 이 데이터셋을 우리의 숫자 인식 모델을 학습하기 위해 사용할 것입니다.

 

MNIST 데이터셋에 있는 각각의 이미지는 0부터 9의 숫자를 가지고 있고, 그 아래에는 그 숫자를 의미하는 라벨이 붙어있는 28x28 사이즈의 회색조 이미지입니다.

MNIST 이미지 예제

# Keras는 MNIST 데이터셋을 다운로드 하기 위한 편한 API를 제공합니다.
# 그리고 그들을 train 데이터셋과 test 데이터셋으로 분리합니다.
mnist = keras.datasets.mnist
(train_images, train_labels), (test_images, test_labels) = mnist.load_data()

# 입력된 이미지를 0부터 1로 각각의 픽셀 값으로 일반화합니다.
train_images = train_images / 255.0
test_images = test_images / 255.0
print('Pixels are normalized')

# train 데이터셋에 있는 첫 25개의 이미지를 출력합니다.
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.gray)
  plt.xlabel(train_labels[i])
plt.show()

 

숫자 이미지를 분류하기 위해 Tensorflow 모델을 학습시키기

 

다음으론, 우리는 Tensorflow 모델을 만들고 MNIST train 데이터셋에 있는 데이터를 학습시키기 위해 Keras API 를 사용할 것입니다. 학습 이후, 우리의 모델은 숫자 이미지를 분류할 수 있을 것입니다.

 

우리의 모델은 입력값으로 28x28 회색조 이미지를 가지고, 0부터 9까지의 숫자일 가능성을 대표하는 10개의 실수 배열을 출력할 것입니다. 

 

우리는 흔한 컴퓨터 비전 기술을 사용하는 간단한 CNN 신경망을 가지고 있습니다. 우리는 이 모델의 구조를 깊게 파고들진 않을 것입니다. 만약 다른 ML 모델 구조에 대해 깊게 이해하고 싶다면, 우리의 무료 Tensorflow 학습 코스를 고려해 보세요. (https://www.coursera.org/learn/introduction-tensorflow)

 

# 모델 구조 정의
model = keras.Sequential([
  keras.layers.InputLayer(input_shape=(28, 28)),
  keras.layers.Reshape(target_shape=(28, 28, 1)),
  keras.layers.Conv2D(filters=32, kernel_size=(3, 3), activation=tf.nn.relu),
  keras.layers.Conv2D(filters=64, kernel_size=(3, 3), activation=tf.nn.relu),
  keras.layers.MaxPooling2D(pool_size=(2, 2)),
  keras.layers.Dropout(0.25),
  keras.layers.Flatten(),
  keras.layers.Dense(10)
])

# 어떻게 모델을 학습시킬지를 정의
model.compile(optimizer='adam',
              loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True),
              metrics=['accuracy'])

# 숫자 인식 모델을 학습시키기
model.fit(train_images, train_labels, epochs=5)

모델 구조에 좀 파고들어 봅시다.

model.summary()

이것은 batch dimension 이라 불리는, 우리의 모델의 모든 계층마다 None 모양을 가지고 있는 추가적인 dimension 입니다. 머신러닝에서는, 우리는 주로 처리량을 향상시키기 위해 batches에서 데이터를 처리합니다. 그래서 Tensorflow는 자동적으로 dimension을 추가합니다.

 

우리의 모델을 평가하기

 

학습 모델이 학습하지 않은 "test" 데이터셋에 대해 숫자 분류 모델을 실행하여 데이터셋을 학습하고 처리함으로써 모델이 단순히 자릿수를 기억하는 것이 아니라 새로운 이미지에 맞게 일반화되었음을 확인한다.

# Evaluate 데이터셋에 있는 모든 이미지를 사용한 모델을 평가한다.
test_loss, test_acc = model.evaluate(test_images, test_labels)

print('Test accuracy:', test_acc)

비록 우리의 모델이 상대적으로 간단하더라도, 우리는 모델이 본 적 없는 이미지들을 98%에 가깝게 인식하는 좋은 정확도를 얻을 수 있다. 이제 결과를 시각화 해봅시다.

# helper 함수는 인자로 받은 두개의 수가 동일한지 아닌지를 통해
# black 또는 red를 반환합니다.
def get_label_color(val1, val2):
  if val1 == val2:
    return 'black'
  else:
    return 'red'

# 우리의 test 데이터셋의 숫자를 예상하게 합니다
predictions = model.predict(test_images)

# 출력값인 10개의 실수가 이미지가 0부터 9일지의 가능성을 대표함으로써
# 우리는 모델이 어떤 숫자를 예측했는지 찾기 위해 
# 10개의 실수 중 제일 큰 값을 찾아야 합니다.
prediction_digits = np.argmax(predictions, axis=1)

# 그리고 100개의 랜덤 테스트 이미지와 그의 예상된 숫자값을 분류합니다.
# 만약 결과값이 test 데이터셋에서 제공된 라벨과 다를 시,
# 빨간색으로 강조될 것 입니다.
plt.figure(figsize=(18, 18))
for i in range(100):
  ax = plt.subplot(10, 10, i+1)
  plt.xticks([])
  plt.yticks([])
  plt.grid(False)
  image_index = random.randint(0, len(prediction_digits))
  plt.imshow(test_images[image_index], cmap=plt.cm.gray)
  ax.xaxis.label.set_color(get_label_color(prediction_digits[image_index],\
                                           test_labels[image_index]))
  plt.xlabel('Predicted: %d' % prediction_digits[image_index])
plt.show()

 

Keras 모델을 Tensorflow Lite 로 변환시키기

 

우리는 이제 숫자 인식 모델을 훈련시켰고, 이제 모바일에 배포하기 위해 Tensorflow Lite로 변환할 것입니다.

# Keras 모델을 Tensorflow Lite 포맷으로 변환
converter = tf.lite.TFLiteConverter.from_keras_model(model)
tflite_float_model = converter.convert()

# 모델의 용량을 킬로바이트 단위로 출력합니다.
float_model_size = len(tflite_float_model) / 1024
print('Float model size = %dKBs.' % float_model_size)

우리가 모바일 장치로 배포를 할 것이므로, 우리는 우리의 모델이 가능한 한 빠를 것을 원할 것입니다.

양자와(Quantization)은 머신러닝 모델을 축소하기 위해 자주 쓰이는 일반적인 기술입니다. 여기 우리는 8-비트 숫자를 모델 사이즈를 4개의 인자로 축소하기 위한 32-bit 용량에 접근하기 위해 사용할 것입니다.

# 양자화를 이용해 모델을 Tensorflow Lite로 변환
converter.optimizations = [tf.lite.Optimize.DEFAULT]
tflite_quantized_model = converter.convert()

# 모델의 용량을 킬로바이트 단위로 출력
quantized_model_size = len(tflite_quantized_model) / 1024
print('Quantized model size = %dKBs,' % quantized_model_size)
print('which is about %d%% of the float model size.'\
      % (quantized_model_size * 100 / float_model_size))

 

Tensorflow Lite 모델을 평가하기

 

양자화를 사용함으로써, 우리는 용량이 작아진 모델의 이익을 위해 어느정도의 정확도를 버려야 합니다.

한 번 우리의 양자화된 모델의 하락된 정확도를 계산해봅시다. 

# test 데이터셋을 사용하는 Tensorflow Lite Model를 평가하기 위한 보조 함수
def evaluate_tflite_model(tflite_model):
  # 모델을 사용하는 Tensorflow Lite 인터프리터를 초기화합니다.
  interpreter = tf.lite.Interpreter(model_content=tflite_model)
  interpreter.allocate_tensors()
  input_tensor_index = interpreter.get_input_details()[0]["index"]
  output = interpreter.tensor(interpreter.get_output_details()[0]["index"])

  # test 데이터셋의 모든 이미지에 대해 예측합니다.
  prediction_digits = []
  for test_image in test_images:
    # Pre-processing: 모델의 입력값 형식과 일치시키기 위해 
    # batch dimension을 추가하고 float32 형식으로 변환합니다.
    test_image = np.expand_dims(test_image, axis=0).astype(np.float32)
    interpreter.set_tensor(input_tensor_index, test_image)

    # 추론을 시작합니다.
    interpreter.invoke()

    # Post-processing: batch dimension을 제거하고 제일 큰 가능성을 가진 숫자를 찾습니다.
    digit = np.argmax(output()[0])
    prediction_digits.append(digit)

  # 정확도를 계산하기 위해 예측한 결과를 수집된 숫자와 비교합니다.
  accurate_count = 0
  for index in range(len(prediction_digits)):
    if prediction_digits[index] == test_labels[index]:
      accurate_count += 1
  accuracy = accurate_count * 1.0 / len(prediction_digits)

  return accuracy

# Tensorflow Lite Model를 평가합니다. 그 모델의 정확도는 Tensorflow Lite로 변환하기 전 
# Keras 모델과 동일할 것입니다. 왜냐하면 그들은 근본적으로 같은 모델이고 그저 다른 형식으로
# 저장됬을 뿐이기 때문입니다.
float_accuracy = evaluate_tflite_model(tflite_float_model)
print('Float model accuracy = %.4f' % float_accuracy)

# 양자화된 Tensorflow Lite를 평가합니다.
# 원래 모델의 정확도보다 양자화된 모델의 정확도가 높다고 놀라지 마세요.
# 그저 가끔 일어나는 일일 뿐이니까요 :)
quantized_accuracy = evaluate_tflite_model(tflite_quantized_model)
print('Quantized model accuracy = %.4f' % quantized_accuracy)
print('Accuracy drop = %.4f' % (float_accuracy - quantized_accuracy))

Tensorflow Lite 모델 다운로드하기

 

우리의 모델을 얻고 Android 앱과 통합해 봅시다.

만약 당신이 Colab으로부터 mnist.tflite를 다운로드하는데 에러가 발생한다면, 다시 한번 실행해 보세요.

# Download 폴더에 양자화된 모델을 저장
f = open('mnist.tflite', "wb")
f.write(tflite_quantized_model)
f.close()

# 숫자 인식 모델을 다운로드
from google.colab import files
files.download('mnist.tflite')

print('`mnist.tflite` has been downloaded')

 

성공!

이제 Step 2-1이 끝났습니다. 이제 다음 Step 3로 진행하세요.

 

본 강의는 구글의 Codelab 강의 중 "Build a handwritten digit classifier app with Tensorflow Lite" 강의를 

번역할 것이며, 제가 직접 번역하였기에 오역과 의역이 있음을 알립니다.