[K-DIGITAL] 딥러닝 Tensorflow2.x 실습 - MNIST

멋쟁이사자처럼 X K-DIGITAL Training - 07.15

 

 

[tensorflow 1.x] 2021.07.15 - [python/k-digital] - [K-DIGITAL] 딥러닝 Tensorflow1.x 실습 - MNIST

[K-DIGITAL] 딥러닝 Tensorflow1.x 실습 - MNIST

---

 

TensorFlow 버전1 vs 버전2

 

2.x대부터 Keras가 텐서플로우 프로젝트에 공식적으로 편입

소스코드 단순화, 단축

session사용 불필요

placeholder 등 전역 변수 선언 생략 가능 및 내장함수 사용

속도는 텐서플로우1이 더 빠름

 

 

https://www.tensorflow.org/guide/migrate?hl=ko 

텐서플로 1 코드를 텐서플로 2로 바꾸기  |  TensorFlow Core

 

https://www.tensorflow.org/tutorials/quickstart/beginner?hl=ko 

텐서플로 2.0 시작하기: 초보자용  |  TensorFlow Core

---

 

 

라이브러리

import numpy as np
import matplotlib.pyplot as plt

import tensorflow as tf
from tensorflow.keras import datasets, utils
from tensorflow.keras import models, layers, activations, initializers, losses, optimizers, metrics

import os
os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2'

tensorflow.keras

텐서플로우 위에서 동작하는 딥러닝 프레임워크로 사용이 편리함

단순한 신경망을 구성하여 갖추어진 기능만 사용한다면 Keras만으로도 충분하나 디테일한 조작은 Tensorflow 필요

 

 

1. 데이터 준비

# 텐서플로우 이용
from tensorflow.examples.tutorials.mnist import input_data
mnist = input_data.read_data_sets("./mnist/data/", one_hot=True)

# Keras 이용
from tensorflow.keras import datasets

(train_data, train_label), (test_data, test_label) = datasets.mnist.load_data()

train_data.shape # (60000, 28, 28)
test_data.shape # (10000, 28, 28)
train_data.dtype # unit8
train_data.max() # 255
train_data[0].shape # (28, 28)

Normalization

# reshape 행렬 변환 (60000, 28*28) -> (60000, 784)
# scaling 최대가 1이 되도록 최대값으로 나눠줌
train_data = train_data.reshape(60000, 784).astype('float32') / 255.0 # 0~255 -> 0~1
test_data = test_data.reshape(10000, 784).astype('float32') / 255.0 # 0~255 -> 0~1

One-hot encoding

# before
train_label[:10] # array([5, 0, 4, 1, 9, 2, 1, 3, 1, 4], dtype=uint8)

train_label = utils.to_categorical(train_label) # 0~9 -> one-hot vector
test_label = utils.to_categorical(test_label) # 0~9 -> one-hot vector

# after
train_label[0, :10] # array([0., 0., 0., 0., 0., 1., 0., 0., 0., 0.], dtype=float32)

 

 

2. 모델 & Criterion 생성

VER 1.X

placeholder로 객체 생성

X = tf.placeholder(tf.float32, [None, 784])
Y = tf.placeholder(tf.float32, [None, 10])

모델 생성

W1 = tf.Variable(tf.random_normal([784, 256], stddev=0.01))
L1 = tf.nn.relu(tf.matmul(X, W1))
...
cost = tf.losses.softmax_cross_entropy(Y, model) 
optimizer = tf.train.AdamOptimizer(0.001).minimize(cost)
...

모델 실행(session)

init = tf.global_variables_initializer()
sess = tf.Session()
sess.run(init)

 

 

VER 2.X

순차형 모델

tf.keras.models.Sequentail()

# example
from tensorflow.python.keras.models import Sequential
from tensorflow.python.keras.layers import Dense, Activation

model = Sequential()
model.add(Dense(units=64, input_dim=784))
model.add(Activation('softmax')

# example2
model = Sequential([Dense(64, input_shape=(784,), activation='softmax')]) # model list

함수형 모델

입력과 출력을 정의한 뒤 모델을 인스턴스화 해줌

inputs= Input(shape=(784,))
x = Dense(64, activation='relu')(inputs)
x = Dense(32, activation='relu')(x)
outputs = Dense(10, activation='softmax')(x)

 

모델 설정

모델 정의 후 학습하기 전 .comile() 메서드로 학습에 대한 설정을 해줘야함

model.compile(
    optimizer='sgd', # 최적화 함수
    loss='categorical_crossentropy', # 손실함수
    metrics=['accuracy'] # 성능 판단에 쓰일 지표 함수
)

---

 

빈 모델 생성

model = models.Sequential()

레이어 층을 쌓아 순차형 모델을 만듬

 

layer 생성

model.add(layers.Dense(input_dim=28*28, units=256, activation=None, kernel_initializer=initializers.he_uniform())) 
model.add(layers.BatchNormalization())
model.add(layers.Activation('relu')) # layers.ELU or layers.LeakyReLU
model.add(layers.Dropout(rate=0.2))

model.add(layers.Dense(units=256, activation=None, kernel_initializer=initializers.he_uniform())) 
model.add(layers.BatchNormalization())
model.add(layers.Activation('relu')) # layers.ELU or layers.LeakyReLU
model.add(layers.Dropout(rate=0.2))

model.add(layers.Dense(units=10, activation='softmax')) # 0~9 
# (Output) Dense-layer with softmax function, 0~9 -> 10

 

* tf.keras.layers.Dense() 신경망 형태의 층을 만드는 함수

Dense(
    units, # 퍼셉트론 수
    activation = 'softmax', # 활성화 함수
    use_bias = True, # 편향을 사용할지 여부
    kernel_initializer ='initializers.he_uniform()', # 가중치(W) 초기화 함수 / he_uniform-ReLU
    bias_initializer = 'zeros', # 편향 초기화 함수
    kernel_regularizer = None, # 가중치 정규화 방법
    bias_reqularizer = None, # 편향 정규화 방법
    activity_reqularizer = None, # 출력 값 정규화 방법
    kernel_constraint = None, # Optimizer에 의해 업데이트된 이후에 가중치에 적용되는 부가적인 제약함수
    bias_constraint=None, # Optimizer에 의해 업데이트된 이후에 편향에 적용되는 부가적인 제약함수
    **kwargs
 )

 

모델 학습 전 세팅

model.compile(optimizer='adam', # optimizers.Adam()
              loss=losses.categorical_crossentropy,
              metrics=[metrics.categorical_accuracy]) # metrics=['accuracy'])

# metrics = Precision / Recall / F1-Score 등 적용 가능

* 옵티마이저 learning rate 직접 세팅하여 생성 가능

from tensorflow.keras import optimizers

optimizers.Adam(lr=0.001) # learning rate

 

 

3. 모델 학습

history = model.fit(train_data, train_label, batch_size=100, epochs=15, validation_split=0.2)

* ver2부터 실행 상황이 바 형태로 보여짐

 

 

4. 모델 테스트

result = model.evaluate(test_data, test_label, batch_size=100)

print('loss (cross-entropy) :', result[0])
print('test accuracy :', result[1])

 

 

5. 결과 시각화

history.history.keys()

>> dict_keys(['loss', 'categorical_accuracy', 'val_loss', 'val_categorical_accuracy'])

 

val_acc = history.history['val_categorical_accuracy']
acc = history.history['categorical_accuracy']

x_len = np.arange(len(acc)) # x좌표 직접 생성
plt.figure(figsize=(12, 12))
plt.plot(x_len, acc, marker='.', c='blue', label="Train-set Acc.")
plt.plot(x_len, val_acc, marker='.', c='red', label="Validation-set Acc.")

plt.legend(loc='upper right')
plt.grid()
plt.xlabel('epoch')
plt.ylabel('Accuracy')
plt.show()

다소 과적합된 모습이 보임,,