Tensorflow Fashion MNIST 에서 CNNs 사용 모델

앞에서 fashion_mnist 데이터셋을 가져와서 단순 Classification 모델링으로 학습하여 예측하는 걸 만들었다.

#Image Classification with Convolutional Neural Networks
#이 튜토리얼에서는 운동화와 셔츠와 같은 옷 이미지를 분류하는 신경망을 구축하고 훈련 할 것입니다.
#모든 것을 이해하지 못해도 괜찮습니다. 이것은 전체 TensorFlow 프로그램에 대한 빠른 진행 개요와 함께 설명을 제공합니다.
# 목표는 모든 세부 사항을 파악하는 것이 아니라 TensorFlow 프로젝트에 대한 일반적인 감각을 얻는 것입니다.
#이 가이드는 TensorFlow에서 모델을 빌드하고 학습시키는 데 고급 API 인 tf.keras를 사용합니다.
#Install and import dependencies
import tensorflow as tf
#Import TensorFlow Datasets
import tensorflow_datasets as tfds
tfds.disable_progress_bar()

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

#Logging
import logging
logger = tf.get_logger()
logger.setLevel(logging.ERROR)

#Import the Fashion MNIST dataset
dataset, metadata = tfds.load('fashion_mnist', as_supervised=True, with_info=True)
train_dataset, test_dataset = dataset['train'], dataset['test']

#데이터 세트를로드하면 메타 데이터와 학습 데이터 세트 및 테스트 데이터 세트가 반환됩니다.
#모델은 train_dataset를 사용하여 학습됩니다.
#모델은 test_dataset에 대해 테스트됩니다.
#이미지는 28 × 28 배열이며 픽셀 값은 [0, 255] 범위입니다. 레이블은 [0, 9] 범위의 정수 배열입니다. 이는 이미지가 나타내는 의복 등급에 해당합니다.
#라벨 클래스
#0 티셔츠 / 상판 T-shirt/top
#1 바지 Trouser
#2 풀오버 Pullover
#3 드레스 Dress
#4 코트 Coat
#5 샌들 Sandal
#6 셔츠 Shirt
#7 운동화 Sneaker
#8 가방 Bag
#9 발목 부츠 Ankle boot
#각 이미지는 단일 레이블에 매핑됩니다. 클래스 이름은 데이터 세트에 포함되어 있지 않으므로 나중에 이미지를 그릴 때 사용할 수 있도록 여기에 저장합니다.
class_names = ['T-shirt/top', 'Trouser', 'Pullover', 'Dress', 'Coat', 'Sandal', 'Shirt', 'Sneaker', 'Bag', 'Ankle boot']

#class_names = metadata.features['label'].names
#print("Class names: {}".format(class_names))

#데이터 탐색
#모델을 학습하기 전에 데이터 세트의 형식을 살펴 보겠습니다.
# 다음은 학습 세트에 60,000 개의 이미지가 있고 테스트 세트에 10000 개의 이미지가 있음을 보여줍니다.
num_train_examples = metadata.splits['train'].num_examples
num_test_examples = metadata.splits['test'].num_examples
print('Number of training examples : {} '.format(num_train_examples))
print('Number of test examples : {} '.format(num_test_examples))

#데이터 전처리
#이미지 데이터의 각 픽셀 값은 [0,255] 범위의 정수입니다.
# 모델이 제대로 작동하려면 이러한 값을 [0,1] 범위로 정규화해야합니다.
# 그래서 여기에서 정규화 함수를 만든 다음 테스트의 각 이미지에 적용하고 데이터 세트를 학습시킵니다.
def normalize(images, labels):
    images = tf.cast(images, tf.float32)
    images /= 255
    return images, labels

#The map function applies the normalize function to each element in th train and test datasets
train_dataset = train_dataset.map(normalize)
test_dataset = test_dataset.map(normalize)

#The first time you use the dataset, the images will be loaded from disk Caching will keep then in memory, making training faster
train_dataset = train_dataset.cache()
test_dataset = test_dataset.cache()

#어떻게 생겼는지보기 위해 이미지를 플로팅 해 봅시다.
#Take a single image, and remove the color dimension by reshaping
for image, label in test_dataset.take(1):
    break
image = image.numpy().reshape((28,28))
#Plot the image - voila a piece of fashion clothing
plt.figure()
plt.imshow(image, cmap=plt.cm.binary)
plt.colorbar()
plt.grid(False)
plt.show()

#훈련 세트에서 처음 25 개의 이미지를 표시하고 각 이미지 아래에 클래스 이름을 표시합니다.
# 데이터가 올바른 형식인지 확인하고 네트워크를 구축하고 훈련 할 준비가되었습니다.
plt.figure(figsize=(10,10))
i = 0
for (image, label) in test_dataset.take(25):
    image = image.numpy().reshape((28,28))
    plt.subplot(5,5,i+1)
    plt.xticks([])
    plt.yticks([])
    plt.grid(False)
    plt.imshow(image, cmap=plt.cm.binary)
    plt.xlabel(class_names[label])
    i += 1
plt.show()

#모델 구축
#신경망을 구축하려면 모델의 계층을 구성한 다음 모델을 컴파일해야합니다.

#레이어 설정
#신경망의 기본 구성 요소는 계층입니다. 레이어는 입력 된 데이터에서 표현을 추출합니다.
# 바라건대, 일련의 연결된 계층은 당면한 문제에 의미있는 표현을 생성합니다.
#많은 딥 러닝은 간단한 레이어를 연결하는 것으로 구성됩니다.
# tf.keras.layers.Dense와 같은 대부분의 레이어에는 훈련 중에 조정 ("learned")되는 내부 매개 변수가 있습니다.
model = tf.keras.Sequential([
    tf.keras.layers.Conv2D(32, (3,3), padding='same', activation=tf.nn.relu, input_shape=(28,28,1)),
    tf.keras.layers.MaxPooling2D((2,2), strides=2),
    tf.keras.layers.Conv2D(64, (3,3), padding='same', activation=tf.nn.relu),
    tf.keras.layers.MaxPooling2D((2,2), strides=2),
    tf.keras.layers.Flatten(),
    tf.keras.layers.Dense(128, activation=tf.nn.relu),
    tf.keras.layers.Dense(10, activation=tf.nn.softmax)
])
#이 네트워크 계층은 다음과 같습니다.
#"convolutions"tf.keras.layers.Conv2D 및 MaxPooling2D-네트워크는 두 쌍의 Conv / MaxPool로 시작됩니다.
# 첫 번째 레이어는 입력 이미지에 적용되는 Conv2D 필터 (3,3)이며,
# 패딩을 사용하여 원래 이미지 크기를 유지하고 32 개의 출력 (convoluted) 이미지를 생성합니다 (따라서이 레이어는 입력과 동일한 크기의 32 개의 복잡한 이미지를 생성합니다).
# 그 후, 32 개의 출력은 stride 2 인 MaxPooling2D (2,2)를 사용하여 크기가 축소됩니다.
# 다음 Conv2D는 또한 (3,3) 커널을 가지고 있으며 32 개의 이미지를 입력으로 취하고 다시 64 개의 출력을 생성합니다.
# MaxPooling2D 레이어에 의해 크기가 줄어 듭니다.
# 지금까지 Convolution이 하는 일에 대해 설명했지만, 이들의 배수를 함께 연결하는 방법은 아직 다루지 않았습니다.
# 컬러 이미지를 사용할 때 4 장에서 다시 살펴 보겠습니다.
# 이 시점에서 컨볼 루션 필터가 수행하는 작업의 종류를 이해하면 충분합니다.
#output tf.keras.layers.Dense — 128- 뉴런과 10 노드 소프트 맥스 계층이 뒤 따릅니다.
# 각 노드는 의류 클래스를 나타냅니다.
# 이전 계층에서와 같이 최종 계층은 이전 계층의 128 개 노드에서 입력을 받아 [0, 1] 범위의 값을 출력하여 이미지가 해당 클래스에 속할 확률을 나타냅니다.
# 10 개 노드 값의 합계는 1입니다.

#모델 컴파일
#모델을 학습 할 준비가되기 전에 몇 가지 설정이 더 필요합니다. 이들은 모델의 컴파일 단계에서 추가됩니다.
#Loss function — 모델의 출력이 원하는 출력에서 얼마나 멀리 떨어져 있는지 측정하는 알고리즘입니다. 훈련의 목표는 손실을 측정하는 것입니다.
#Optimizer — 손실을 최소화하기 위해 모델의 내부 매개 변수를 조정하는 알고리즘입니다.
#Metrics — 교육 및 테스트 단계를 모니터링하는 데 사용됩니다. 다음 예제에서는 정확하게 분류 된 이미지의 일부인 정확도를 사용합니다.
model.compile(optimizer='adam',
              loss=tf.keras.losses.SparseCategoricalCrossentropy(),
              metrics=['accuracy'])

#모델 훈련
#먼저 train data set에 대한 반복 동작을 정의합니다.

#dataset.repeat ()를 지정하여 영원히 반복합니다 (아래 설명 된 epochs 매개 변수는 학습 수행 시간을 제한합니다).
#dataset.shuffle (60000)은 순서를 무작위 화하므로 모델이 예제 순서에서 아무것도 배울 수 없습니다.
#dataset.batch (32)는 모델 변수를 업데이트 할 때 32 개의 이미지와 레이블의 배치를 사용하도록 model.fit에 지시합니다.
#model.fit 메서드를 호출하여 훈련을 수행합니다.

#train_dataset을 사용하여 훈련 데이터를 모델에 공급합니다.
#모델은 이미지와 라벨을 연결하는 방법을 배웁니다.
#epochs = 5 매개 변수는 훈련 데이터 세트의 전체 반복 5 회로 훈련을 제한하므로 총 5 * 60000 = 300000 개의 예제가됩니다.
#(step_per_epoch에 대해 걱정하지 마십시오.이 플래그가 있어야한다는 요구 사항이 곧 제거됩니다.)
BATH_SIZE = 32
train_dataset = train_dataset.cache().repeat().shuffle(num_train_examples).batch(BATH_SIZE)
test_dataset = test_dataset.cache().batch(BATH_SIZE)

model.fit(train_dataset, epochs=5, steps_per_epoch=math.ceil(num_train_examples/BATH_SIZE))
#모델 학습, 손실 및 정확도 메트릭이 표시됩니다. 이 모델은 훈련 데이터에서 약 0.97 (또는 97 %)의 정확도에 도달합니다.

#정확성 평가
#다음으로 모델이 테스트 데이터 세트에서 어떻게 수행되는지 비교합니다.
# 정확성을 평가하기 위해 테스트 데이터 세트에있는 모든 예제를 사용하십시오.
test_loss, test_accuracy = model.evaluate(test_dataset, steps=math.ceil(num_test_examples/32))
print("Accuracy on test dataset : ", test_accuracy)

#결과적으로 테스트 데이터 세트의 정확도는 훈련 데이터 세트의 정확도보다 작습니다.
# 모델이 train_dataset에서 학습되었으므로 이것은 완전히 정상입니다.
# 모델이 학습 중에 (즉, test_dataset에서) 본 적이없는 이미지를 볼 때 성능이 저하 될 것으로 예상 할 수 있습니다.

#예측 및 탐색
#훈련 된 모델을 사용하여 일부 이미지에 대한 예측을 할 수 있습니다.
for test_images, test_labels in test_dataset.take(1):
    test_images = test_images.numpy()
    test_labels = test_labels.numpy()
    predictions = model.predict(test_images)

predictions.shape

#여기에서 모델은 테스트 세트의 각 이미지에 대한 레이블을 예측했습니다. 첫 번째 예측을 살펴 보겠습니다.
predictions[0]

#예측은 10 개의 숫자로 구성된 배열입니다.
# 이들은 이미지가 10 개의 서로 다른 의류 품목 각각에 해당한다는 모델의 "confidence"를 설명합니다.
# confidence 값이 가장 높은 레이블을 확인할 수 있습니다.
np.argmax(predictions[0])

#따라서 모델은이 이미지가 셔츠 또는 class_names [6]라고 가장 확신합니다.
# 그리고 이것이 올바른지 테스트 레이블을 확인할 수 있습니다.
test_labels[0]

#이것을 그래프로 그려서 10 개의 클래스 예측의 전체 세트를 볼 수 있습니다.
def plot_image(i, prediction_array, true_labels, images):
    prediction_array, true_labels, img = prediction_array[i], true_labels[i], image[i]
    plt.grid(False)
    plt.xticks([])
    plt.yticks([])

    plt.imshow(img[...,0], cmap=plt.cm.binary)

    predicted_label = np.argmax(prediction_array)
    if predicted_label == true_labels:
        color = 'blue'
    else:
        color = 'red'
    plt.xlabel("{} {:2.0f}% ({})".format(class_names[predicted_label],
                                         100*np.max(prediction_array),
                                         class_names[true_labels]),
               color = color)
def plot_value_array(i, prediction_array, true_label):
    prediction_array, true_label = prediction_array[i], true_label[i]
    plt.grid(False)
    plt.xticks([])
    plt.yticks([])
    thisplot = plt.bar(range(10), prediction_array, color="#777777")
    plt.ylim([0,1])
    predicted_label = np.argmax(prediction_array)

    thisplot[predicted_label].set_color('red')
    thisplot[true_label].set_color('blue')

#0 번째 이미지, 예측 및 예측 배열을 살펴 보겠습니다.
i = 0
plt.figure(figsize=(6,3))
plt.subplot(1,2,1)
plot_image(i, predictions, test_labels, test_images)
plt.subplot(1,2,2)
plot_value_array(i, predictions, test_labels)

#12번째 이미지
i = 12
plt.figure(figsize=(6,3))
plt.subplot(1,2,1)
plot_image(i, predictions, test_labels, test_images)
plt.subplot(1,2,2)
plot_value_array(i, predictions, test_labels)

#예측과 함께 여러 이미지를 플로팅 해 봅시다.
# 올바른 예측 레이블은 파란색이고 잘못된 예측 레이블은 빨간색입니다.
# 숫자는 예측 된 레이블에 대한 백분율 (100 점 만점)을 제공합니다. 매우 확신 할 때도 틀릴 수 있습니다.

#Plot the first X test images, their predicted label, and the true label
#Color correct predictions in blue, incorrect predictions in red
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()

#마지막으로 학습 된 모델을 사용하여 단일 이미지에 대한 예측을 수행합니다.
#Grab an image from the test dataset
img = test_images[0]
print(img.shape)

#tf.keras 모델은 한 번에 예제의 일괄 또는 모음에 대한 예측을 수행하도록 최적화되어 있습니다.
# 따라서 단일 이미지를 사용하더라도 목록에 추가해야합니다.
#Add the image to a batch where it's the only member
img = np.array([img])
print(img.shape)

#Predict the image
predictions_single = model.predict(img)
print(predictions_single)

plot_value_array(0, predictions_single, test_labels)
q=plt.xticks(range(10), class_names, rotation=45)

#model.predict는 데이터 배치의 각 이미지에 대해 하나씩 목록 목록을 반환합니다. (유일한) 이미지에 대한 예측을 일괄 처리합니다.
np.argmax(predictions_single[0])
#그리고 이전과 마찬가지로 모델은 레이블 6 (셔츠)을 예측합니다.

 

 

앞의 예제와 같고 모델 구축부분에서 Conv2D 및 MaxPooling2D 의 레이어를 추가해서 신경망을 구축한 부분만 틀리다.

앞의 예제에서는 약 88%의 정확도를 보였고 이번 예제는 약 97%의 정확도를 보였다.

단, 아무래도 레이어가 추가되어서 학습하는데에 시간이 배로 많이 걸린다.

Epoch 수가 예제에 10이지만 너무 느려서 5로 낮춰도 학습이 오래 걸린다. 대신 정확도는 확실하게 올라간다.

학습수가 10에서 5로 낮춰도 약 94%의 결과를 가진다.