TensorFlow 두번째 모델 Fashion MNIST

지난번에 만든 모델은 Regression을 이용한 예측값을 예측하는 모델이었다.

이번 모델은 Classification 으로 주어진 데이터로 입력데이터의 확률분포를 출력하는 모델이다.

intro_to_modeling.ipynb - Colaboratory (google.com)

Google Colaboratory

이렇게 Colab에 자세히 되어 있지만 직접 코딩해보는 것과 읽어보는것은 천지차이

일단 코딩을 해보았다.

#종속성 설치 및 가져 오기
#Classification
#데이터 세트 다운로드 및 액세스를 단순화하고 작업 할 여러 샘플 데이터 세트를 제공하는 API 인 TensorFlow_datasets가 필요합니다.
# 또한 몇 가지 도우미 라이브러리를 사용하고 있습니다.
# !pip install -U tensorflow_datasets 실행해서 tensorflow_datasets를 설치합니다.

#먼저 import
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 = 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 the 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 them in memory, making training faster
train_dataset = train_dataset.cache()
test_dataset = test_dataset.cache()

#처리된 데이터를 plot 해서 보자.
#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))
for i, (image, label) in enumerate(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])
#plt.show() 잠시 그래프를 안보이게 하고

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

#레이어 설정
#신경망의 기본 구성 요소는 계층입니다. 레이어는 입력 된 데이터에서 표현을 추출합니다.
# 바라건대, 일련의 연결된 계층은 당면한 문제에 의미있는 표현을 생성합니다.
#많은 딥 러닝은 간단한 레이어를 연결하는 것으로 구성됩니다.
# tf.keras.layers.Dense와 같은 대부분의 레이어에는 훈련 중에 조정 ("learned")되는 내부 매개 변수가 있습니다.
model = tf.keras.Sequential([
    tf.keras.layers.Flatten(input_shape=(28,28,1)),
    tf.keras.layers.Dense(128, activation=tf.nn.relu),
    tf.keras.layers.Dense(10, activation=tf.nn.softmax)
])
#여기에는 세개의 layer가 있다.
#input tf.keras.layers.Flatten —이 레이어는 이미지를 28 x 28 픽셀의 2d 배열에서 784 픽셀 (28 * 28)의 1d 배열로 변환합니다.
# 이 레이어를 이미지에서 픽셀 행을 스택 해제하고 정렬하는 것으로 생각하십시오. 이 레이어에는 데이터를 다시 형식화하기 때문에 학습 할 매개 변수가 없습니다.
#"hidden"tf.keras.layers.Dense-128 개의 뉴런으로 구성된 조밀하게 연결된 계층입니다.
# 각 뉴런 (또는 노드)은 이전 계층의 모든 784 개 노드에서 입력을 가져와 훈련 중에 학습 될 숨겨진 매개 변수에 따라 해당 입력에 가중치를 부여하고 단일 값을 다음 계층에 출력합니다.
#output tf.keras.layers.Dense — 128- 뉴런과 10 노드 소프트 맥스 계층이 뒤 따릅니다.
# 각 노드는 의류 클래스를 나타냅니다.
# 이전 계층에서와 같이 최종 계층은 이전 계층의 128 개 노드에서 입력을 받아 [0, 1] 범위의 값을 출력하여 이미지가 해당 클래스에 속할 확률을 나타냅니다.
# 10 개 노드 값의 합계는 1입니다.

#모델 컴파일
#모델을 학습 할 준비가되기 전에 몇 가지 설정이 더 필요합니다. 이들은 모델의 컴파일 단계에서 추가됩니다.
#손실 함수 — 모델의 출력이 원하는 출력에서 얼마나 멀리 떨어져 있는지 측정하는 알고리즘입니다. 훈련의 목표는 손실을 측정하는 것입니다.
#Optimizer — 손실을 최소화하기 위해 모델의 내부 매개 변수를 조정하는 알고리즘입니다.
#메트릭 — 교육 및 테스트 단계를 모니터링하는 데 사용됩니다. 다음 예제에서는 정확하게 분류 된 이미지의 일부인 정확도를 사용합니다.
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에 대해 걱정하지 마십시오.이 플래그가 있어야한다는 요구 사항이 곧 제거됩니다.)
BATCH_SIZE = 32
train_dataset = train_dataset.cache().repeat().shuffle(num_train_examples).batch(BATCH_SIZE)
test_dataset = test_dataset.cache().batch(BATCH_SIZE)

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

#정확성 평가
#다음으로 모델이 테스트 데이터 세트에서 어떻게 수행되는지 비교합니다.
# 정확성을 평가하기 위해 테스트 데이터 세트에있는 모든 예제를 사용하십시오.
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_label, img = prediction_array[i], true_labels[i], images[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_label:
        color = 'blue'
    else:
        color = 'red'

    plt.xlabel("{} {:2.0f}% ({})".format(class_names[predicted_label],
                                         100*np.max(prediction_array),
                                         class_names[true_label]),
               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)
#plt.show()

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)
plt.show()

#예측과 함께 여러 이미지를 플로팅 해 봅시다.
# 올바른 예측 레이블은 파란색이고 잘못된 예측 레이블은 빨간색입니다.
# 숫자는 예측 된 레이블에 대한 백분율 (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)
_ = plt.xticks(range(10), class_names, rotation=45)

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

Colab에 있는 것을 그대로 따라 한것에 불과하지만 이해는 쏙 되었다.

plot가 여러개 있는데 처음에 분류 배열을 보여주고 첫번째 이미지의 값을 살펴보고

15개의 이미지의 예측 결과를 보여주는 plot으로 구성되어 있다.

모델 훈련 fit함수에서 epochs는 반복 훈련 횟수인데 코드상 5회이지만 10회로 올려보니 정확도가 상승하는 것을 볼 수 있었다.