본 포스트는 패스트캠퍼스 파이썬 기초부터 시작하는 딥러닝 영상인식 바이블 강의를 정리한 글입니다.

올해 상반기가 지나가기 전 딥러닝 공부를 깊게 해보고 싶었다. CNN, RNN, LSTM 등의 이론은 학부생활을 하면서 꽤나 익혔는데, 딥러닝 프레임워크를 사용하여 모델링하는 것은 해보지 않았기에, 프레임워크 중 한 가지 정도는 능숙하게 사용하는 것을 목표로 삼게 되었다. 강의를 따라 keras를 사용할 예정인데, 

keras 문서 를 들어가 사용법을 볼 수 있고, 기본적인 모델링은 문서를 통해 배울 수 있을 것 같다. 

1. 필요 라이브러리 import 

# TensorFlow and tf.keras
import tensorflow as tf 
from tensorflow import keras 
#  Helper libraries 
import numpy as np 
import matplotlib.pyplot as plt 
import math

print(tf.__version__) # tensorflow 버전 확인

tensorflow, keras를 import 해준다.  필자는 google colab 에서 실습을 진행하였고, 글을 쓰는 시점을 기준으로 tf 버전 2.8.0 을 사용한다. 이 밖에 필요한 numpy, matplotlib, math를 import 해 준다. 

2. batch size, epochs, num_classes 정의

# Define Constants 
batch_size = 128 
epochs = 100 
num_classes = 10

batch_size: 데이터를 몇개씩 묶어서 학습할 것인가? -> 128개씩 묶어서 학습하겠다

ephocs: 학습을 반복하는 횟수 -> 100번 학습하겠다

num_classes: 클래스의 개수 -> MNIST는 0~9까지 10개이므로 10

• 60000장의 데이터를 한번에 학습하지 않고 batch size를 설정하는 이유

배치를 나눠서 학습하게되면 모든 데이터가 스트레이트로 쭉 학습되는 것이 아니라, batch size만큼 학습되면서 예측 값이 맞거나 틀린 경우가 각 배치마다 업데이트 되기 때문에 중간중간 가중치가 조절될 수 있으므로 더 좋은 성능을 기대해볼 수 있다.

(실제로 실험해보았더니 batch size를 60000장으로 했을 때 정확도가 0.02정도 낮게 나왔다. (MNIST 데이터 기준) 그리고 batch size가 작아질 수록 학습 속도가 느려진다. 아직 배치사이즈를 조정할 레벨은 아니지만, 배치사이즈에 따라 성능이 달라지는 것을 직접 확인하니 적절한 배치사이즈를 설정해주는 것도 중요한 부분인 것 같아보인다. )

3. MNIST 데이터셋 불러오기

# Download MNIST dataset 
mnist = keras.datasets.mnist
(train_images, train_labels), (test_images, test_labels) = mnist.load_data()

워낙 유명한 MNIST 데이터셋은 keras에서 제공해주므로 따로 다운받을 필요 없이 위와 같은 코드를 작성하여 사용할 수 있다.  

len(train_images), len(test_images)

 (60000, 10000) 

train은 60000장, test는 10000장임을 알 수 있다. 

4. 딥러닝 모델 학습

(1) normailze (0.0 ~ 1.0 사이의 값이 되도록) 

# Normalize the input image so that each pixel value is between 0 to 1 
train_images = train_images / 255.0 
test_images = test_images / 255.0

데이터를 float형으로 만들면서 0.0~1.0 사이로 정규화해준다. 

(2) 딥러닝 모델 정의

# Define the model architecture 
model = keras.Sequential([
                          keras.layers.Flatten(input_shape=(28, 28)),
                          keras.layers.Dense(128, activation=tf.nn.relu),
                          keras.layers.Dense(num_classes, activation='softmax')
])
model.compile(optimizer='adam',
              loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True),
              metrics=['accuracy'])

모델은 keras.Sequential에 층을 하나하나 추가해주는 방식이다. 직관적으로 모델링을 할 수 있다는 장점이 있다. flatten으로 한 장당 2차원 배열 28x28인 이미지를 1차원으로 만들어 준다. 그다음 Dense layer를 사용하고, activation 함수는 relu를 사용한다. 마지막 층에는 클래스의 개수와 softmax 함수를 사용함으로써 예측 결과를 클래스 별 확률로 나오게끔 만들어준다. 

model.complie로 optimizer와 loss함수, metrics (평가지표)를 설정해 준다. 

이제 모델 학습할 모든 준비가 되었다. 

(3) 딥러닝 모델 학습

history = model.fit(train_images, train_labels, epochs=epochs, batch_size=batch_size)

train 데이터셋과 앞서 지정했던 ephocs, batch_size를 설정해 준다. 

5. 딥러닝 모델 평가

(1) loss, accuracy 확인

test_loss, test_acc = model.evaluate(test_images, test_labels)
print("Test Loss: ", test_loss)
print("Test Accuracy: ", test_acc)

 Test Loss: 0.12909765541553497 

 Test Accuracy: 0.98089998960495 

아주 기본적인 딥러닝 모델을 사용하였음에도 불구하고 0.98이라는 높은 정확도가 나왔다. 모든 학습 결과가 이랬으면 좋겠다. 

(2) 필요 함수 정의 

# 1. 원하는 개수만큼 이미지를 보여주는 함수 
def show_sample(images, labels, sample_count=25):
  # Create a square with can fit {sample_count} images
  grid_count = math.ceil(math.ceil(math.sqrt(sample_count)))
  grid_count = min(grid_count, len(images), len(labels))

  plt.figure(figsize=(2*grid_count, 2*grid_count))
  for i in range(sample_count):
    plt.subplot(grid_count, grid_count, i+1)
    plt.xticks([])
    plt.yticks([])
    plt.grid(False)
    plt.imshow(images[i], cmap=plt.cm.gray)
    plt.xlabel(labels[i])
  plt.show()

###################################################################
# 2. 특정 숫자의 이미지를 보여주는 함수 
# Helper function to display specific digit images 
def show_sample_digit(images, labels, digit, sample_count=25):
  # Create a square with can fit {sample_count} images
  grid_count = math.ceil(math.ceil(math.sqrt(sample_count)))
  grid_count = min(grid_count, len(images), len(labels))

  plt.figure(figsize=(2*grid_count, 2*grid_count))
  i = 0 
  digit_count = 0 
  while digit_count < sample_count:
    i += 1 
    if digit == labels[i]: 
      plt.subplot(grid_count, grid_count, digit_count+1)
      plt.xticks([])
      plt.yticks([])
      plt.grid(False)
      plt.imshow(images[i], cmap=plt.cm.gray)
      plt.xlabel(labels[i])
      digit_count += 1 
  plt.show()


###################################################################
# 3.이미지 한개를 크게 보여주는 함수 
def show_digit_image(image):
  # Draw digit image 
  fig = plt.figure()
  ax = fig.add_subplot(1, 1, 1)
  # Major ticks every 20, minor ticks every 5 
  major_ticks = np.arange(0, 29, 5)
  minor_ticks = np.arange(0, 29, 1)
  ax.set_xticks(major_ticks)
  ax.set_xticks(minor_ticks, minor=True)
  ax.set_yticks(major_ticks)
  ax.set_yticks(minor_ticks, minor=True)
  # And a corresponding grid 
  ax.grid(which='both')
  # Or if you want different settings for the grids:
  ax.grid(which='minor', alpha=0.2)
  ax.grid(which='major', alpha=0.5)
  ax.imshow(image, cmap=plt.cm.binary)

  plt.show()

28x28 배열의 이미지를 시각화로 확인해볼 수 있도록 해주는 함수이다. 

위 함수를 사용하여 잠깐 이미지를 확인해 보자. 

• show_sample 함수 사용 (원하는 개수만큼 사진 출력)

show_sample(train_images, ['Label: %s' % label for label in train_labels])

이렇게 원하는 개수 만큼 이미지를 확인해볼 수 있다. 

• show_sample_digit 함수 사용 (특정 숫자에 대한 원하는 개수만큼의 사진 출력)

show_sample_digit(train_images, train_labels, 7)

특정 숫자를 원하는 개수만큼 확인해볼 수 있다. 

(3) train 데이터셋 학습 시 ephoch에 따른 loss와 accuracy 값 시각화

# Evaluate the model using test dataset. - Show performance 
fig, loss_ax = plt.subplots()
fig, acc_ax = plt.subplots()

loss_ax.plot(history.history['loss'], 'ro')
loss_ax.set_xlabel('ephoc')
loss_ax.set_ylabel('loss')

acc_ax.plot(history.history['accuracy'], 'bo')
acc_ax.set_xlabel('ephoc')
acc_ax.set_ylabel('accuracy')

(4) test data의 예측 값과 정답 값 비교해보기

• 실제값: 그림
• 예측값: x label

# Predict the labels of digit images in our test datasets.
predictions = model.predict(test_images)

# Then plot the first 25 test images and their predicted labels.
show_sample(test_images, ['predicted: %s' % np.argmax(result) for result in predictions])

(5) show_digit_image 함수 사용

• 특정 인덱스의 사진과 그때의 예측값을 비교해 봄

Digit = 2005 #@param {type:'slider', min:1, max:10000, step:1}
selected_digit = Digit - 1 

result = predictions[selected_digit]
result_number = np.argmax(result)
print('Number is %2d' % result_number)

show_digit_image(test_images[selected_digit])

#@param을 사용하면 위와 같이 슬라이더가 생긴다. 랜덤으로 슬라이드를 해서 인덱스 값을 지정해 주면,

Number is 7

이와 같이 Number is 7 은 예측 값, 이미지는 test 이미지 (정답 값)으로 두개를 비교 확인해볼 수 있다. 

이번 포스트에서 사용한 MNIST데이터셋은 아주 간단한 딥러닝 모델인데도 성능이 좋았다. 

다음 포스팅에서는 이미지 모델학습에 최적화 되어있는 CNN 모델링을 함으로써 MNIST의 성능을 더욱 높여보는 공부를 해 볼 것이다. 

(본 프로젝트 코드는 패캠 딥러닝 강의를 참고한 코드이다)

<이전 글>

https://silvercoding.tistory.com/9

이전 글에서 fashion MNIST에 대하여 알아보았다. MNIST와 동일한 형태를 가지고 있었다. 이번 글에서는 이러한 fashion MNIST 데이터셋을 전처리하는 시간을 가져보도록 한다. 

전처리 시작 

(1) data type 변경 (정수 -> 실수)

데이터의 이미지의 값은 0-255 인 uint8 타입 이었다. 그래서 데이터 타입을 실수형으로 바꾸어 주고, 범위를 0-1 로 바꾸어 준다. 

혹시 uint8 타입이 궁금하다면 이곳에서 설명을 해둔 부분을 읽어보자. 

https://silvercoding.tistory.com/3

train_images = train_images.astype(np.float64)
test_images = test_images.astype(np.float64)

이렇게 astype 을 이용하여 코드를 작성해 주면 데이터 타입을 바꿔줄 수 있다. 이제 dtype을 찍어보면 uin8이 아닌 float64로 바뀌어 있을 것이다. 

(2) normalize 

normalize작업을 하여 0~1 의 값을 가지도록 변형해주도록 하자.
식은 다음과 같다.
normalize(x) = x - 최솟값 / 최댓값 - 최솟값
normalize(x) = x / 최댓값 (최솟값이 0일 때 : 지금 데이터셋의 경우)
현재 MNIST 는 0-255 의 숫자이므로 밑의 식을 따르면 된다.

(train_images / 255.0).min(), (train_images / 255.0).max()

이렇게 하면 바로 최솟값이 0.0, 최댓값이 1.0 으로 변화하게 된다. 

*** normalize를 함수로 구현하여 일반화 시키기 

def norm(data):
  min_v = data.min()
  max_v = data.max()

  return (data - min_v) / (max_v - min_v)

이러한 normalize 함수를 생성해 놓으면 최솟값이 0이 아닌 데이터도 손쉽게 정규화 해줄 수 있다. 

여기서 데이터의 shape, dtype, 범위(최댓값, 최솟값)을 다시 확인해 본다음 시각화로 넘어가자! (포스팅은 생략)

여러장 시각화 해보기 (ex, 5장)

이 작업도 계속 반복되므로 간단하게 작성해 나가며 마치도록 한다. 

- (5, 28, 28) ---> (28, 28 * 5) shape 변경 (hstack, transpose로 가능) 

이번에도 hstack은 생략하고, transpose 방법으로만 진행한다. 

이곳에서 hstack을 사용한 적이 있다. 

https://silvercoding.tistory.com/4

train_images[:5].transpose((1, 0, 2)).reshape(28, -1).shape

(28, 140) 이 나오면 정상! 

이제 이걸 plt로 그려보면 (코드 생략)

이렇게 오류 없이 5장을 한번에 출력할 수 있게 되었다. 

- 종류끼리 시각화 하기 

def filter(label, count=5) :
  imgs = train_images[np.argwhere(train_labels == label)[:count, ..., 0]].transpose((1, 0, 2)).reshape(28, -1)
  plt.imshow(imgs, cmap='gray')
  plt.title(idx2label(label))
  plt.show()

filter 함수를 만들어서 보고싶은 의류 종류 라벨을 집어 넣으면, 그 종류끼리 시각화를 해볼 수 있다. 저번에 만들어 두었던 idx2label 을 이용하여 title도 지정해주었다. 

filter(레이블, 시각화 갯수) 이렇게 사용하면 된다. 

filter(9, 6)

9번째 라벨인 앵클부츠 6가지를 그려 보았다. 

다음시간에는 Data augmentation과 모델링을 하는 포스팅을 할 예정이다. 

(본 프로젝트 코드는 패캠 딥러닝 강의를 참고한 코드이다)

이번에는 또 유명한 데이터인 fashion MNIST를 이용하여 멀티레이블 분류를 해볼 것이다. 

여기서 멀티레이블이 무엇인지 알아보고 넘어가자. 

Multiclass vs multi-label

Binary Classification 은 클래스가 2가지인 경우이다. 사진에 나와있는 것 처럼 (스팸, 낫스팸), 저번 프로젝트에서 했었던 성별 (남, 녀), 웃음여부 (웃음, 안웃음) 이런식이다. 

MultiClass Classification 은 여러개의 클래스를 가지고 있는 경우이다. 위 사진처럼 사진에 강아지 한마리가 있고 여러 클래스들 중 한 종류를 예측해 주는 것이다. 이번에 할 fashion Mnist를 멀티레이블로 하지 않고 그대로 분류모델을 만든다면 멀티클래스 분류모델이 될 것이다. 

Multi-label Classification 은 여러개의 클래스를 가지고 있고, 라벨링도 여러개로 되어있는 경우이다. 위 사진을 보면 사진 안에 고양이와 새가 있으니 여러 클래스들 중 두가지의 라벨링이 되어있는 것이다.

본 프로젝트에서는 멀티 레이블 분류 모델을 만들 것이기 때문에 한 사진에 의류를 무작위로 붙여주는 작업을 하여 한 사진에 의류가 최대 4가지가 들어갈 수 있는 데이터로 변형을 한다. 

<multi-label 사진 출처>

https://www.kaggle.com/c/lish-moa/discussion/180500

이제 fashion MNIST를 알아보도록 하자!

이번에도 keras에서 제공해주는 datasets에서 불러와 사용한다. 수동으로 설치하려면 밑의 링크를 이용하면 된다. 

<fashion MNIST 출처 및 다운>

https://www.kaggle.com/zalando-research/fashionmnist

MNIST 데이터와 크기가 동일하게 28x28 이다. train dataset이 60,000장, test dataset이 10,000 장인 것도 동일하다. 

Labels

Each training and test example is assigned to one of the following labels:

• 0 T-shirt/top
• 1 Trouser
• 2 Pullover
• 3 Dress
• 4 Coat
• 5 Sandal
• 6 Shirt
• 7 Sneaker
• 8 Bag
• 9 Ankle boot

클래스는 총 10개로, 티셔트, 드레스, 셔츠, 샌들, 가방 등등 여러 의류 종류가 포함되어 있다.  어느 의류의 종류인지 분류해내는 모델을 생성하는 것이 목표이다.

fashion MNIST 데이터셋 알아보기 

이제 데이터셋을 알아보는 절차는 익숙해졌을 것이다. 데이터를 불러와서 데이터의 크기, 범위, 타입을 확인하고, 어떻게 생겼는지 시각화를 해본다. 

(1) 데이터 불러오기 

fashion_mnist = keras.datasets.fashion_mnist 
((train_images, train_labels), (test_images, test_labels)) = fashion_mnist.load_data()

keras의 datasets에서 fashion MNIST를 불러온다.

labels = ["T-shirt/top",  # index 0
        "Trouser",      # index 1
        "Pullover",     # index 2 
        "Dress",        # index 3 
        "Coat",         # index 4
        "Sandal",       # index 5
        "Shirt",        # index 6 
        "Sneaker",      # index 7 
        "Bag",          # index 8 
        "Ankle boot"]   # index 9

def idx2label(idx):
  return labels[idx]

레이블의 텍스트를 리스트에 저장해서 인덱스를 이용하여 텍스트를 불러올 수 있다.

idx2label 함수를 구현하여 레이블을 함수에 넣으면 레이블의 텍스트를 불러오도록 하는 코드. 시각화에서 사용할 예정이다. 

(2) 데이터의 크기 확인 

print(f"train_images: {train_images.shape}")
print(f"train_labels: {train_labels.shape}")
print(f"test_images: {test_images.shape}")
print(f"test_labels: {test_labels.shape}")

train_images: (60000, 28, 28)

train_labels: (60000,)

test_images: (10000, 28, 28)

test_labels: (10000,)

기존 MNIST와 같은 형태를 띄는 것을 알 수 있다. 

(3) 데이터의 범위 확인 

- image 에서 0이 아닌 값 출력해보기 

train_images[train_images!=0][:50]
test_images[train_images!=0][:50]

너무 많으니 50까지만 출력해본다. 0을 제외하고 255까지의 정수들로 이루어져 있으면 정상! 

- image의 최솟값, 최댓값 구해보기 

print(train_images.min(), train_images.max())
print(test_images.min(), test_images.max())

둘다 0 255 가 나오면 정상! 

***이미지의 값을 더해서 가장 큰 index, 가장 작은 index를 구해보고 시각화 해보기 

이미지의 값들을 모두 더해서 숫자가 크다면 옷의 크기가 크고 색이 밝을 것이고, 숫자가 작다면 옷의 크기가 작으면서 색이 어두울 것으로 예상할 수 있다. 정말 그런지 확인해 보자. 

print(train_images.reshape((60000, -1)).sum(axis=1).argmax())
print(train_images.reshape((60000, -1)).sum(axis=1).argmin())

axis=1 방향으로 다 더해주면 각 이미지에 대한 값들의 합이 나올 것이다. 그중에서 최댓값의 index와 최솟값의 index를 

인덱스는 55023 9230가 나왔다. 사진을 출력해보면,

예상했던 대로 합이 큰 이미지는 밝은 부분이 많고, 합이 작은 이미지는 어두운 부분이 대부분이다. 

(4) 데이터 타입 확인 

print(train_images.dtype)
print(train_labels.dtype)
print(test_images.dtype)
print(test_labels.dtype)

모두 uint8 이 나오면 정상! 

이를 통해 알 수 있는 것은 전처리 할 때 0-1 사이의 float 형태로 바꿔 주어야 된다라는 것.  

(5) 데이터 한장씩 시각화 해보기 

def show(idx):
  plt.imshow(train_images[idx], cmap='gray')
  plt.title(idx2label(train_labels[idx]))
  plt.show()

시각화 하는 함수를 구현해주어 편리하게 사진을 확인할 수 있다. 

show(777)

train image의 777번째 사진은 sandal 

show(77)

train image의 77번째 사진은 shirt 임을 알 수 있다. 

다음 포스트에서는 fashion MNIST 전처리와 여러장 시각화하는 방법에 대하여 작성할 예정이다. 

(본 프로젝트 코드는 패캠 딥러닝 강의를 참고한 코드이다)


<이전 포스팅>
https://silvercoding.tistory.com/7

저번 포스팅까지 celeba 데이터셋에 대한 전처리를 모두 마쳤다. 이제 모델링 하는일만 남았다.
그런데 바로 이전 프로젝트였던 mnist 모델은 어느 숫자인지 맞추는 1개의 아웃풋이 나오는 분류기였다.

이번에는 성별과, 웃음 여부 두가지를 맞추어야 한다. 그래서 첫번째로 이를 따로따로 각각 모델을 만들어 보고,  두번째로는 weights는 공유하면서 아웃풋만 다르게 해주는 모델을 만들어 볼 것이다.





각각 모델링 하기
(1) simple model 구현

from keras.models import Model 
from keras.layers import Conv2D, MaxPool2D, Input, Dense, Flatten 
def simple_model(): 
	inputs = Input((72, 59, 3)) 
    x = Conv2D(32, 3, activation='relu')(inputs) 
    x = MaxPool2D(2)(x) 
    x = Conv2D(64, 3, activation='relu')(x) 
    x = MaxPool2D(2)(x) 
    x = Conv2D(64, 3, activation='relu')(x) 
    x = MaxPool2D(2)(x) 
    x = Flatten()(x) 
    x = Dense(64, activation='relu')(x) 
    
    outputs = Dense(2, activation='softmax')(x) 
    model = Model(inputs, outputs) 
    
    return model

두개를 똑같은 모델로 구현할 것이기 때문에 효율적으로 사용하기 위해 함수를 구현해 놓는다.








(2) 모델 생성 및 요약정보 출력
- 모델 생성

gender_model = simple_model() 
smile_model = simple_model()

각각에 대하여 모델을 생성한다.


- 모델 요약 정보 출력

gender_model.summary() 
smile_model.summary()

이렇게 생긴 모델이 2개가 나오게 된다.








(3) loss, optimizer, metrics 설정

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

이것 또한 동일하게 작성해준다. compile 함수를 이용하여 손실함수는 categorical crossentropy, optimizer는 adam, 평가지표는 정확도로 설정을 해주었다.

-- 두 model 의 weight 확인 해보기

gender_model.get_weights()[0][0][0][0] 
smile_model.get_weights()[0][0][0][0]

두 모델의 weight들을 얻어와보면 다른 것을 알 수 있다. 구조만 같은 모델이고, 서로 독립적으로 학습이 진행된다는 의미이다.







(4) 학습 시키기

gender_hist = gender_model.fit(train_images, train_male_labels, validation_data=(test_images, test_male_labels), epochs=15, verbose=1) 
smile_hist = smile_model.fit(train_images, train_smile_labels, validation_data=(test_images, test_smile_labels), epochs=15, verbose=1)

학습도 역시 각각 따로 시킨다. 라벨 빼고는 이미지 데이터를 비롯해 모두 동일하다.
이 시점에서 weight를 또 불러와 보면 아까와 달라져 있을 것이다. 당연히 두 모델의 weight도 여전히 다를 것이다.


참고로 verbose에 관련된 설명은 여기에 있다
https://silvercoding.tistory.com/5

(5) 학습 결과 확인
- 학습 결과 시각화

plt.plot(gender_hist.history['accuracy'], label = 'gender_accuracy') 
plt.plot(gender_hist.history['loss'], label = 'gender_loss') 
plt.plot(gender_hist.history['val_accuracy'], label = 'gender_val_accuracy') 
plt.plot(gender_hist.history['val_loss'], label = 'gender_val_loss') 

plt.plot(smile_hist.history['accuracy'], label = 'smile_accuracy') 
plt.plot(smile_hist.history['loss'], label = 'smile_loss') 
plt.plot(smile_hist.history['val_accuracy'], label = 'smile_val_accuracy') 
plt.plot(smile_hist.history['val_loss'], label = 'smile_val_loss') 

plt.legend(loc='uppder left') 
plt.show()

히스토리에 저장된 accuracy와 loss를 꺼내서 그래프를 그려보면

나름 괜찮은 모양을 띈다!


--- test image 한장으로 결과 확인해보기

gender_res = gender_model.predict(test_images[77:78]) 
smile_res = smile_model.predict(test_images[77:78]) 

77번째 사진으로 결과를 확인 해보자.

우선 77번째 사진은 위와 같다. 여자 웃음O 일 것으로 추정된다.
결과도 각각 해주어야 한다.

- gender

plt.bar(range(2), gender_res[0], color='red') 
plt.bar(np.array(range(2)) + 0.3, test_male_labels[77]) 
plt.xticks(range(2), ['female', 'male']) 
plt.show()

print(gender_res)

red가 예측, blue가 정답이다. 잘 맞추었다!

- smile

(코드 생략) gender_res ---> smile_res, test_male_labels ---> test_smile_labels 로 바꿔주면 된다.
아주 조금은 unsmiling으로 예측하고 거의 잘 맞춘 것으로 보인다!








(6) 모델 평가
모델 평가도 두개를 따로 해주어야 한다.

gender_model.evaluate(test_images, test_male_labels, verbose=2) 
smile_model.evaluate(test_images, test_smile_labels, verbose=2)

각각 정확도 94%, 89% 로 모델 평가까지 마친다.






그런데 아주 번거롭다. 두개라서 할만했지 만약 더 많은 속성을 분류하고자 했다면 정말 힘들었을 것이다. 모델 생성, 학습, 결과 확인, 평가까지 모두 따로따로 해주어야 한다. 그래서 멀티 아웃풋 모델링으로 학습을 해보려고 한다.



멀티 아웃풋 모델링
우선 아이디어는 output 이전까지는 다 같으니 똑같이 작성하고, output만 다르게 작성해준다는 것이다.

- 방법 1

from keras.models import Model 
from keras.layers import Conv2D, MaxPool2D, Input, Dense, Flatten, Concatenate 
def multi_model(): 
	inputs = Input((72, 59, 3)) 
    l1 = Conv2D(32, 3, activation='relu')(inputs) 
    l2 = MaxPool2D(2)(l1) 
    l3 = Conv2D(64, 3, activation='relu')(l2) 
    l4 = MaxPool2D(2)(l3) 
    l5 = Conv2D(64, 3, activation='relu')(l4) 
    l6 = MaxPool2D(2)(l5) 
    l7 = Flatten()(l6) 
    latent_vector = Dense(64, activation='relu')(l7) 
    
    gender_outputs = Dense(2, activation='softmax')(latent_vector) 
    smile_outputs = Dense(2, activation='softmax')(latent_vector) 
    
    outputs = Concatenate(axis=1)([gender_outputs, smile_outputs]) 
    model = Model(inputs, outputs) 
    
    return model

(1) 모델 생성 및 요약정보 출력

# 모델 생성
model = multi_model() 
# 모델 요약정보 
model.summary()

(None, 4)로 최종 아웃풋이 1개


(2) loss, optimizer, metrics 설정

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

전과 같이 해준다.

(3) 모델 학습

hist1 = model.fit(train_images, train_labels2, validation_data=(test_images, test_labels2), epochs=15, verbose=1)

(4) 결과 그래프

그래프가 굉장히 이상하다. loss가 accuracy 보다 높다. 오!



(5) 예측 확인 (테스트 데이터셋 사진 한장 확인해보기)

res = model.predict(test_images[77:78]) print(res2.shape)

res의 shape 은 (1, 4) 가 나온다.

77번째 사진은

이분이시고, 잘 예측하는지 시각화하여 확인을 해보자.

plt.bar(range(4), res[0]) 
plt.bar(np.array(range(4)) + 0.3, test_labels2[77]) 
plt.show()

77번째 이미지는 예상과 다르게 잘 맞춘 것 같다. 결과 그래프는 아주 이상했는데 꽤 맞추긴 하나보다.

(6) 모델 평가

model.evaluate(test_images, test_labels2, verbose=2)

엄청난 loss와 정확도 60%로 방법 1의 모델 평가까지 마쳤다. 한번에 합쳐서 모델링을 하려면 다른 조치가 더 필요해 보인다.






-방법 2

from keras.models import Model 
from keras.layers import Conv2D, MaxPool2D, Input, Dense, Flatten, Concatenate 
def multi_model(): 
	inputs = Input((72, 59, 3)) 
    l1 = Conv2D(32, 3, activation='relu')(inputs) 
    l2 = MaxPool2D(2)(l1) 
    l3 = Conv2D(64, 3, activation='relu')(l2) 
    l4 = MaxPool2D(2)(l3) 
    l5 = Conv2D(64, 3, activation='relu')(l4) 
    l6 = MaxPool2D(2)(l5) 
    l7 = Flatten()(l6) 
    latent_vector = Dense(64, activation='relu')(l7) 
    
    gender_outputs = Dense(2, activation='softmax')(latent_vector) 
    smile_outputs = Dense(2, activation='softmax')(latent_vector) 
    
    model = Model(inputs, [gender_outputs, smile_outputs]) 
    
    return model

여기서는 gender_outpus와 smile_outputs를 concatenate해주지 않고, model에 리스트로 묶어 바로 넣어준다. 파라미터의 개수는 절반으로 줄여주면서 처음에 했던 각각 모델링과 같은 형태의 결과가 나오게 해준다.


(1) 모델 생성 및 요약정보 출력

# 모델 생성 
model2 = multi_model() 
# 모델 요약정보 
model2.summary()

(None, 2) (None, 2) 로 최종 아웃풋이 2개


(2) loss, optimizer, metrics 설정

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

똑같이 설정!



(3) 모델 학습

hist2 = model2.fit(train_images, [train_male_labels, train_smile_labels], validation_data=(test_images, [test_male_labels, test_smile_labels]), epochs=15, verbose=1)

(4) 결과 그래프

각각 모델링 했을 때와 비슷한 형태로 나옴을 알 수 있다.


(5) 예측 확인 (테스트 데이터셋 사진 한장 확인해보기)
아까와 같은 77번째 이미지를 예측해본다.

res2 = model2.predict(test_images[77:78]) print(res[0].shape, res[1].shape)

여기서는 아웃풋이 2개이기 때문에 각각 출력해주면 (1, 2) (1, 2) 이러한 형태가 나오게 된다.
res2를 출력해보면,
[array([[9.999993e-01, 6.897806e-07]], dtype=float32),
array([[0.01424873, 0.9857512 ]], dtype=float32)] 이러한 형태가 나오게 되는 것이다.

코드는 위에서 살짝 바꿔주면 되니 생략하고, 각각 그래프를 그려보면

성별은 여자, 100%는 아니지만 웃는 사람으로 잘 판별 하는 것을 볼 수 있다.



(6) 모델 평가

model2.evaluate(test_images, [test_male_labels, test_smile_labels], verbose=2)

너무 길어서 짤렸다. 결과는 두 성별, 웃음 모델 모두 정확도 91% 정도로 나왔다. 제일 높게 나왔다!


(7) 모델 분리 해보기

gender_model2 = Model(inputs = model2.input, outputs = model2.get_layer('dense_5').output) 
gender_model2.summary()

smile_model2 = Model(inputs = model2.input, outputs = model2.get_layer('dense_6').output) 
smile_model2.summary()

model2에서 input과 gender_outputs, smile_oupts에 해당했던 layer를 get_layer를 통해 얻어와서 모델을 생성해주면 된다.
summary를 해보면 가장 처음에 했던 각각 모델링에서의 형태와 같게 나온다.


- weights 확인 해보기

smile_model2.get_weights()[0][0][0][0] 
gender_model2.get_weights()[0][0][0][0]

각각모델링에서 weights를 확인해 보았을 때는 서로 달랐다. 하지만 model2에서 weights를 공유하고 분리를 해준 위의 모델은 weights가 같은 것을 알 수 있다.



(8) 모델 저장 및 불러오기

# 모델 저장
model2.save("./multimodel.h5")

# 모델 불러오기 
model3 = tf.keras.models.load_model('./multimodel.h5')

이름 설정하고 h5로 저장하고 불러오기!


--- 코랩을 사용했다면 컴퓨터에 모델 저장하는 코드

from google.colab import files 
files.download('./multimodel.h5')

결론적으로
파라미터 개수 => 각각 모델링 (총 약 40만개) > 멀티 아웃풋 모델링 (약 20만개)
절반이 줄어들기 때문에 같은 형태의 모델의 아웃풋만 달리 해줄 때는 멀티 아웃풋 모델링이 더 효율적이라고 생각한다.


방법1 vs 방법2
방법 1 은 아웃풋이 1개 (None, 4) , 방법2는 아웃풋이 2개 (None, 2) (None, 2) (각각 모델링과 같음)
방법1은 이미지 한장은 잘 분류한 것 같은데, loss나 accuracy가 이상해서 조치를 더 취해주거나, 조금 더 알아볼 필요가 있을 것 같다.

(본 프로젝트 코드는 패캠 딥러닝 강의를 참고한 코드이다)

<이전 포스팅>
https://silvercoding.tistory.com/6

전처리를 하기 위해선 데이터를 잘 파악해야 한다. 또한 실수를 하지 않기 위해서 데이터의 범위, 크기, 데이터 타입을 수시로 확인해 주며 전처리를 진행하도록 한다. (포스팅에서는 생략)

이전 포스팅에 따르면, 범위는 0.0-1.0, 이미지 크기는 (2000, 72, 59, 3) (200, 72. 59. 3), 라벨 크기는 (2000, 2) (200, 2), 데이터 타입은 이미지 float64, 라벨은 int8 이었다.


이전에도 말했듯이 이번 프로젝트에서는 normalize를 할 필요가 없다. 따라서 이번에는 라벨만 전처리 시켜주면 된다.

전처리 시작
(1) 라벨 크기 변경
(배치, 2) --> (배치, 2) (배치, 2)
(배치, (성별, 웃음)) --> (배치, 남자, 여자) (배치, 웃음, 안웃음)

# (배치, 2) ---> (배치, 1) (배치, 2) 
train_male_labels, train_smile_labels = np.split(train_labels, 2, axis=1) 
test_male_labels, test_smile_labels = np.split(test_labels, 2, axis=1) 
# 잘 나눠졌는지 확인 
print(train_male_labels.shape, train_smile_labels.shape) 
print(train_male_labels[777], train_smile_labels[777], train_labels[777]) 

shape은 각각 (2000, 1) 이 나오면 된다. test의 shape을 출력해보면 (200, 1) 이 나올 것이다.
[0] [0] [0 0] 나눠진 라벨들과 나눠지기 전 라벨을 비교한 코드이다. 전에 777번째 사진 안웃는 여자였기 때문에 잘 출력된 것을 알 수 있다.

from tensorflow.keras.utils import to_categorical train_male_labels = to_categorical(train_male_labels) train_smile_labels = to_categorical(train_smile_labels) test_male_labels = to_categorical(test_male_labels) test_smile_labels = to_categorical(test_smile_labels)

그다음으로는 원핫인코딩으로 나누어 준다.
(2000, 2) (2000, 2)
(200, 2) (200, 2)


모델링 단계 때 성별과 웃음 여부를 각각 모델링하기도 하고, 멀티 아웃풋 모델링도 할 예정이다.
그래서 (2000, 2) (2000, 2) ---> (2000, 4) 로 합친 라벨도 필요하다. 만들어 놓자.

train_labels2 = np.concatenate([train_male_labels, train_smile_labels], axis = 1) test_labels2 = np.concatenate([test_male_labels, test_smile_labels], axis = 1) print(train_labels2.shape, test_labels2.shape)

(2000, 4) (200, 4) 이렇게 합친 라벨도 생성한다! 예를들어 남자고 웃고있지 않다면 [0 1 1 0] 이런식으로 나오게 될 것이다.

이번엔 이렇게 해서 전처리를 끝낸다.
---> 결론적으로 전처리 결과 : (배치, 2) --> (배치, 2) (배치, 2) / (배치, 4) 이렇게 두 종류의 라벨을 획득했다!



여러 장 시각화 하기
(1) 이미지 shape 변경
이 내용은 저번 프로젝트와 동일하다. 그래서 hstack 은 생략하고, transpose 함수를 사용하여 이미지의 shape을 변경해 줄 것이다.

train_images[:5].transpose((1, 0, 2, 3)).reshape((72, -1, 3)).shape

shape을 (5, 72, 59, 3) ---> (72, 5*59, 3) 으로 변경해 주어야 한다. 따라서 transpose로 위치를 변경해주고, reshape으로 shape을 맞춰주면 된다.


이를 plt로 시각화 해보면

이렇게 연속으로 5장을 시각화 할 수 있다.




이번에는 정말 간단하게 전처리와 시각화를 구현해 보았다. 다음은 여러 방법으로 모델링하는 방법을 포스팅 할 예정이다.

(본 프로젝트 코드는 패캠 딥러닝 강의를 참고한 코드이다)

<celeb_a 데이터셋 출처>
https://www.tensorflow.org/datasets/catalog/celeb_a

caleba 데이터셋은 40개의 속성, 10,177개의 신원, 20만개 이상의 유명인 이미지가 포함된 대규모 얼굴 속성 데이터셋이다.
활용 - 얼굴 속성인식, 얼굴 감지, 얼굴 위치파악

celeba의 속성들은 다음과 같이 dictionary로 구성되어 있다.

FeaturesDict({
    'attributes': FeaturesDict({
        '5_o_Clock_Shadow': tf.bool,
        'Arched_Eyebrows': tf.bool,
        'Attractive': tf.bool,
        'Bags_Under_Eyes': tf.bool,
        'Bald': tf.bool,
        'Bangs': tf.bool,
        'Big_Lips': tf.bool,
        'Big_Nose': tf.bool,
        'Black_Hair': tf.bool,
        'Blond_Hair': tf.bool,
        'Blurry': tf.bool,
        'Brown_Hair': tf.bool,
        'Bushy_Eyebrows': tf.bool,
        'Chubby': tf.bool,
        'Double_Chin': tf.bool,
        'Eyeglasses': tf.bool,
        'Goatee': tf.bool,
        'Gray_Hair': tf.bool,
        'Heavy_Makeup': tf.bool,
        'High_Cheekbones': tf.bool,
        'Male': tf.bool,
        'Mouth_Slightly_Open': tf.bool,
        'Mustache': tf.bool,
        'Narrow_Eyes': tf.bool,
        'No_Beard': tf.bool,
        'Oval_Face': tf.bool,
        'Pale_Skin': tf.bool,
        'Pointy_Nose': tf.bool,
        'Receding_Hairline': tf.bool,
        'Rosy_Cheeks': tf.bool,
        'Sideburns': tf.bool,
        'Smiling': tf.bool,
        'Straight_Hair': tf.bool,
        'Wavy_Hair': tf.bool,
        'Wearing_Earrings': tf.bool,
        'Wearing_Hat': tf.bool,
        'Wearing_Lipstick': tf.bool,
        'Wearing_Necklace': tf.bool,
        'Wearing_Necktie': tf.bool,
        'Young': tf.bool,
    }),
    'image': Image(shape=(218, 178, 3), dtype=tf.uint8),
    'landmarks': FeaturesDict({
        'lefteye_x': tf.int64,
        'lefteye_y': tf.int64,
        'leftmouth_x': tf.int64,
        'leftmouth_y': tf.int64,
        'nose_x': tf.int64,
        'nose_y': tf.int64,
        'righteye_x': tf.int64,
        'righteye_y': tf.int64,
        'rightmouth_x': tf.int64,
        'rightmouth_y': tf.int64,
    }),
})

성별, 웃음 여부, 젊음, 안경 착용, 모자 착용, 웨이브 머리, 갈색머리 여부 등등 많은 속성들이 존재한다. 이 중에서 본 프로젝트에서는 성별(Male)과 웃음 여부(Smiling)를 분류해 내는 모델을 만들 것이다.

속성을 꺼낼때는 ['attributes']['Male'] 이런식으로 꺼내주면 된다.




전체 데이터 셋 다운로드

import tensorflow_datasets as tfds 
# tfds.list_builders() -> 데이터셋 목록 전체보기 
celeb_a = tfds.load('celeb_a') # celeb_a 데이터셋 불러오기

본 프로젝트에서는 축소된 celeba 데이터셋을 사용할 것이다. 축소하는 코드는 생략하지만, 과정을 적어보면
1. celeb_a['validation']과 celeb_a['test'] 를 각각 train, test 로 할당해준다.
2. Male, Smiling 속성만 불러와 train_images, train_labels, test_images, test_labels를 생성한다.
---> 여기서 test_images와 test_labels 만 이용하여 데이터 축소
3. test_images와 test_labels에서 웃는남자, 안웃는남자, 웃는여자, 안웃는여자를 분리해내어 각각 550개씩 잘라 고르게 축소하여 합해진다 ---> 그럼 총 2200개가 된다!
4. 2200개 짜리 데이터를 섞어주고, 2000개까지 train, 나머지 200개는 test로 할당한다.
5. 이를 다시 train_images, train_labels, test_images, test_labels 로 나누어주면 끝! 축소하는 게 번거로우므로 npz파일로 저장해놓자.





celeba_small 데이터 살펴보기
(1) 데이터 불러오고 train, test 데이터 나누기

celeba_small = np.load('./celeba_small.npz') 

# 데이터 불러오기 
train_images = celeba_small['train_images'] 
train_labels = celeba_small['train_labels'] 
test_images = celeba_small['test_images'] 
test_labels = celeba_small['test_labels']

(2) 사진 한장 꺼내서 시각화 해보기

plt.imshow(train_images[777]) 
plt.colorbar() 
plt.show() 
print(train_labels[777])

777번째 사진을 꺼내보았다.

결과는 이러하다. 웃는 것 같기도 한데 웃지않는 여자라고 라벨링이 되어있다!





(3) 데이터의 범위, 크기, 데이터 타입 알아보기
- 범위

# 0이 아닌 숫자 50개만 출력해보기 
train_images[train_images != 0][:50] 
test_images[test_images != 0][:50] 
# 데이터의 최솟값 / 최댓값 
print(train_images.min(), train_images.max()) 
print(train_labels.min(), train_labels.max()) 
print(test_images.min(), test_images.max()) 
print(test_labels.min(), test_labels.max())

50개 출력한 데이터들은 모두 0과 1사이의 값들이어야 하고, 이미지의 범위는 0.0-1.0, 라벨의 범위는 0-1 으로 나오면 정상!

- 크기

print(train_images.shape, test_images.shape) 
print(train_labels.shape, test_labels.shape) 

(2000, 72, 59, 3) (200, 72, 59, 3)
(2000, 2) (200, 2)
이와 같이 나오면 정상! 사진의 크기를 데이터 축소할 때 줄여서 원본보다는 작다. 저번 프로젝트 mnist 와 달리 채널 3이 추가되어 색이 있다는 것을 알 수 있다!

- 데이터 타입

print(train_images.dtype, test_images.dtype) 
print(train_labels.dtype, test_labels.dtype) 

float64 float64
int8 int8
위와 같이 나오면 정상! 이걸 통해 안 사실은 dtype이 float64이고, 범위가 0.0 - 1.0 이므로 normalize를 안해줘도 된다는 것이다.

범위, 크기, 데이터 타입은 수시로 확인하는 습관을 갖자!

다음에는 전처리와 시각화에 대한 포스팅을 할 예정이다.

(이번 프로젝트 코드는 패캠 딥러닝 강의를 참고한 코드이다)


<이전 포스팅>
https://silvercoding.tistory.com/4

Noise 추가하기

https://www.tensorflow.org/tutorials/images/data_augmentation

우선 Data augmentation 은 무작위 변환을 적용하여 훈련 세트의 다양성을 증가시키는 기술이다.

이 사진과 같이 사람 눈에는 회전을 하든 확대를 하든 같은 꽃이라는 걸 판별할 수 있지만, 컴퓨터 입장에서는 서로 다른 사진으로 입력된다는 것이다. 따라서 이러한 무작위 변형을 시켜 훈련세트의 다양화를 하고자 한다.

이 글에서는 MNIST에 이러한 Noise를 입힌 데이터를 사용할 것이다.

(1) (28, 28) 크기의 랜덤 노이즈 생성하기
- np.random.random

print(np.random.random((2, 2))) 

np.random.random() 함수를 사용하면 0-1사이의 실수가 나오게 된다. 괄호 안에 사이즈를 입력해주면

이렇게 (2, 2) 형태로 랜덤값이 나오는 것을 알 수 있다.

np.random.random((28,28)).shape

따라서 이렇게 해주면 (28, 28) 사이즈의 랜덤 노이즈가 생성된다.
이를 plt.imshow()에 넣어 확인해보면 위에서 보았던 노이즈 그림을 볼 수 있을 것이다.

그런데 위에서 보았던 그림보다는 진하다. 노이즈를 주기엔 너무 세다.

- np.random.normal

print(np.random.normal(0.0, 0.1, (28, 28))) 

그래서 np.random.normal로 평균과 표준편차를 지정해준다. 평균 0, 표준편차 0.1 로 지정해준다.
이를 그래프로 그려주면

적당한 노이즈가 생성되었다!




(2) 이미지 한장에 적용해보기
777번째 이미지에 노이즈를 씌워보자.

noisy_image = train_images[777] + np.random.normal(0.5, 0.1, (28, 28))

차이를 더 선명히 보기 위해 평균을 0.5로 준다.

그래프를 그려보니 노이즈가 생겼지만 1이 넘는 값이 생겨버린다.

noisy_image[noisy_image > 1.0] = 1.0 

그래서 1.0이 넘는 값은 1.0으로 대체한다는 코드를 작성해주면

0과 1사이의 값으로 이루어진 노이즈 이미지가 완성된다.




(3) 모든 이미지에 노이즈 적용하기

train_noisy_images = train_images + np.random.normal(0.5, 0.1, train_images.shape) 
train_noisy_images[train_noisy_images > 1.0] = 1.0 

test_noisy_images = test_images + np.random.normal(0.5, 0.1, test_images.shape) 
test_noisy_images[test_noisy_images > 1.0] = 1.0

최종적으로 train이미지와 test이미지 모두 노이즈를 적용시키는 코드이다.
저번시간에 여러장의 이미지를 한번에 시각화하는 방법을 사용하여 첫 5개의 이미지를 출력해보면 다음과 같이 정상적으로 나오는 것을 볼 수 있다.

드디어
모델링 하기

(1) 모델링 준비 - 라벨 원핫인코딩 작업 (배치사이즈,) -> (배치사이즈, 클래스 개수)
(60000,) (10000,) 의 형태였던 라벨을 (60000, 10) (10000, 10) 의 형태로 one-hot encoding 해줄 것이다.

from keras.utils import to_categorical 
train_labels = to_categorical( train_labels, 10) 
test_labels = to_categorical( test_labels, 10) 

keras.utils의 to_categorical을 import 하여 사용한다. to_categorical(원핫인코딩할 라벨, 클래스 개수) 이렇게 사용하면 된다.




(2) simpleRNN classification 모델 생성

from keras.layers import simpleRNN 
from keras.layers import Dense, Input 
from keras.models import Model 

inputs = Input(shape=(28, 28)) 
x1 = simpleRNN(64, activation="tanh")(inputs) 
x2 = Dense(10, activation="softmax")(x1) 

model = Model(inputs, x2)

keras.layers의 simpleRNN으로 모델 생성을 한다. activation 함수는 각각 tanh, softmax로 구성이 되어있다.

model.summary()

summary함수를 이용하여 요약정보를 얻어올 수 있다. 파라미터의 개수와 아웃풋 shape을 알 수 있다.




(3) loss, optimizer, metrics 설정

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

compile 함수를 이용하여 손실함수는 categorical crossentropy, optimizer 는 adam, 지표는 정확도로 설정해 준다.




(4) 학습시키기

hist = model.fit(train_noisy_images, train_labels, validation_data=(test_noisy_images, test_labels), epochs=5, verbose=2)

다른 건 다 예상 가능하지만 verbose는 무엇인지 잘 모르겠어서 찾아보았다.

verbose: 'auto', 0, 1, or 2. Verbosity mode. 0 = silent, 1 = progress bar, 2 = one line per epoch. 'auto' defaults to 1 for most cases, but 2 when used with ParameterServerStrategy. Note that the progress bar is not particularly useful when logged to a file, so verbose=2 is recommended

<출처>
https://keras.io/api/models/model_training_apis/

** 비교해보기
- verbose = 1

- verbose = 2

(5) 학습 결과 확인

plt.plot(hist.history['accuracy'], label='accuracy') plt.plot(hist.history['loss'], label='loss') plt.plot(hist.history['val_accuracy'], label='val_accuracy') plt.plot(hist.history['val_loss'], label='val_loss') plt.legend(loc='upper left') plt.show()

학습한 결과를 그래프로 그려보았을 때 정확도는 매우 높고 오류는 매우 낮은 걸 볼 수 있다. 간단한 RNN모델로 구현을 하여도 성능이 괜찮다!


--- 완성된 모델에 test 이미지 한장으로 결과 확인해보기

res = model.predict( test_noisy_images[777:778] ) 

777번째 이미지를 확인해보자.

plt.bar(range(10), res[0], color='red') plt.bar(np.array(range(10)) + 0.35, test_labels[777]) plt.show()

red가 예측한 확률, blue가 정답이다. 보면 1로 잘 예측했지만, 7과 8로 예측한 것이 미세하게 보인다. 성능은 나쁘지 않아보인다.




(6) 테스트 데이터셋으로 평가하기

loss, acc = model.evaluate(test_noisy_images, test_labels, verbose=2) print(loss, acc)

evaluate에 테스트 데이터셋을 넣어주면 된다.

정확도 95%로 모델 평가까지 마쳤다.




(7) 모델 저장하고 불러오기

# 모델 저장 
model.save("./mnist_rnn.h5")

# 모델 불러오기 
new_model = tf.keras.models.load_model('./mnist_rnn.h5')

h5로 저장해주면 된다.


** 혹시 코랩으로 했다면, 코랩에 저장된 모델을 컴퓨터에 저장하는 코드

from google.colab import files 
files.download('./mnist_rnn.h5')

(이번 프로젝트 코드는 패캠 딥러닝 강의를 참고한 코드이다)


<이전 포스팅>
https://silvercoding.tistory.com/3

이번에는 RNN모델링을 위한 MNIST 데이터셋 전처리를 한다. 모델링도 중요하지만 이미 훌륭하신 분들이 만들어 놓은 성능 좋은 모델들을 사용하는 것이 대부분이기 때문에 요새 딥러닝에서는 전처리 또한 중요한 부분인 것 같다.


우선 중간중간에 데이터의 크기나 타입, 범위를 확인하는 것이 데이터를 다루는 데에 중요한 습관이라고 한다. 나중에 모든 분석을 끝냈는데 갑자기 손상된 데이터가 있다는 것을 알게되는 경우가 실제로 일어날 수 있고, 따라서 이를 대비해야하기 때문이다.


전처리 시작

(1) 데이터의 범위 확인
저번시간에 MNIST데이터는 0-255로 이루어져 있는 uint8 데이터임을 알았다. 따라서 맞는지 확인해 보도록 하자.
- 0이 아닌 숫자 출력

print(list(filter(lambda x: x != 0, train_images[0].reshape(-1)))[:50]) 
print(list(filter(lambda x: x != 0, test_images[0].reshape(-1)))[:50]) 

MNIST이미지에서 배경부분은 모두 0이었다. 그렇기에 0이 아닌 숫자들만 출력하여 데이터를 확인해보자. 너무 많으니 50개까지만 출력하여 확인했다.

- 최댓값, 최솟값 출력

print(max(train_images.reshape(-1)), min(train_images.reshape(-1)) ) 
print(max(test_images.reshape(-1)), min(test_images.reshape(-1)) )

이번엔 train과 test이미지 전체 숫자중에서 최댓값과 최솟값을 출력해보았다. 둘다 255 0 이 나온다면 이상없음!



(2) data type 변경하기 (정수형 -> 실수형)
딥러닝은 대부분 0과 1사이의 실수형으로 이루어져 있는게 효율적이므로 정수형이었던 MNIST데이터를 실수형으로 바꾸어주는 절차가 필요하다.

test_images = test_images.astype(np.float64) 
train_images = train_images.astype(np.float64)

astype 함수로 타입을 바꾸어줄 수 있다. 위와같이 작성하여 uint8 -> float64 데이터 형변환을 해보았다.
다시 위에서 해보았던 dtype으로 찍어보면 float64로 바뀐 것을 알 수 있다.



(3) normalize (정규화) 하기
normalize작업을 하여 0~1 의 값을 가지도록 변형해주도록 하자.
식은 다음과 같다.
normalize(x) = x - 최솟값 / 최댓값 - 최솟값
normalize(x) = x / 최댓값 (최솟값이 0일 때 : 지금 데이터셋의 경우)
현재 MNIST 는 0-255 의 숫자이므로 밑의 식을 따르면 된다.

train_images = train_images / 255 
test_images = test_images / 255

간단히 최댓값으로 나누어주면 0-1사이의 데이터 값으로 변형이 될 것이다.
이쯤에서 앞에서 작성했던 코드들을 복붙하여 범위, 데이터크기, 데이터 타입을 모두 확인하고 넘어가자!
범위 0-1, 데이터크기 앞과 동일, 이미지 데이터 타입 float64, 라벨 데이터 타입 uint8 이면 모두 정상.





***이미지 여러장 시각화
저번시간에도 했듯이 이미지 하나를 시각화 하는 것은 어렵지 않았다. 그냥 (28, 28) 이미지 한 장이었기 때문이다. 그런데 한번에 5장을 시각화 하려고 할 때는 train_image[:5] 를 뽑아서 시각화하게 되면 오류가 난다.

plt.imshow(train_images[:5])

TypeError: Invalid shape (5, 28, 28) for image data
이렇게 하면 image data로 인식 하지 못한다는 것이다.

따라서 (28, 5 * 28) 형태로 변환해주어야 한다. (이 형태 변환에 대해서는 나중에 자세히 포스팅해야겠다.)

- numpy 의 hstack 사용

np.hstack(train_images[:5]).shape

- transpose 함수 사용

train_images[:5].transpose( (1, 0, 2) ).reshape(28, -1)

hstack이 더 간결해 보이지만 numpy의 함수이므로 한정적이다. tensorflow 에서 제공하는 transpose를 사용하는 것이 더 안정적이다. transpose는 위치를 바꿔주는 함수이다. transpose((1, 0, 2)) : (0, 1, 2) -> (1, 0, 2) : 1번째 자리를 0번째 자리로, 0번째 자리를 1번째 자리로, 2번째 자리는 2번째 그대로 둔다는 의미

이제 이렇게 해서 plt.imshow()에 넣어주면

오류없이 시각화가 잘 된다!




이번에는 MNIST 데이터셋 전처리, 여러장 시각화 하는 방법을 알아보았다. 다음에는 이미지에 노이즈 추가한 후 대망의 모델링을 하여 손글씨를 분류해보는 작업까지 마치도록 하겠다.