[TensorFlow] Logistic Regression

[TensorFlow] Linear Regression Start

BioinformaticsAndMe

[TensorFlow] Logistic Regression

---

: TensorFlow 2.0 에서 수행되는 로지스틱 회귀분석 과정

: MNIST 데이터베이스 (Modified National Institute of Standards and Technology database)의 '0~9 손글씨' 데이터 사용

→ 60,000개의 Training 이미지 및 10,000개의 Testing 이미지 포함

→ 각 MINST 이미지 크기는 28x28 픽셀이며, 픽셀 하나는 0~255 사이의 숫자값(density)을 가짐

: 이 예제 과정에서 각 이미지는 1) float32로 변환,  2) 784개 feature(28x28)의 1차원 배열화,  3) [0, 1]로 표준화 수행

# '__future__' : python 2에서 python 3 문법 사용 가능
from __future__ import absolute_import, division, print_function

# 텐서플로우, 넘파이 라이브러리 임포트
import tensorflow as tf
import numpy as np

# MNIST 데이터셋 파라미터 설정
num_classes = 10       # 0에서부터 9까지 숫자 종류
num_features = 784    # 28*28 = 784 

# 학습 파라미터 설정
learning_rate = 0.01
training_steps = 1000
batch_size = 256
display_step = 50

# MNIST 데이터 로딩
from tensorflow.keras.datasets import mnist
(x_train, y_train), (x_test, y_test) = mnist.load_data()    # 파이썬 튜플 자료형으로 데이터 저장

# 1) float32로 변환
x_train, x_test = np.array(x_train, np.float32), np.array(x_test, np.float32)
# 2) 이미지 포맷을 28*28=784 픽셀의 1차원 배열로 변환
x_train, x_test = x_train.reshape([-1, num_features]), x_test.reshape([-1, num_features])
# 3) 255을 나누어 [0, 1] 값으로 표준화
x_train, x_test = x_train / 255., x_test / 255.
Downloading data from https://storage.googleapis.com/tensorflow/tf-keras-datasets/mnist.npz
11493376/11490434 [==============================] - 1s 0us/step

# tf.data API를 사용하여 데이터 셔플링 및 배치화
train_data = tf.data.Dataset.from_tensor_slices((x_train, y_train))
train_data = train_data.repeat().shuffle(5000).batch(batch_size).prefetch(1)

# Weight matrix 생성을 위해, 총 784*10개의 weights 필요
W = tf.Variable(tf.ones([num_features, num_classes]), name="weight")
b = tf.Variable(tf.zeros([num_classes]), name="bias")

# 로지스틱 회귀식 (Wx + b) 정의
def logistic_regression(x):
    # softmax 함수 적용
    return tf.nn.softmax(tf.matmul(x, W) + b)

# Cross Entropy 손실 함수 정의
def cross_entropy(y_pred, y_true):
    # one hot vector 인코딩 (텍스트를 유의한 벡터로 변환하는 방법론)
    y_true = tf.one_hot(y_true, depth=num_classes)
    # log(0) error를 피함
    y_pred = tf.clip_by_value(y_pred, 1e-9, 1.)
    # Cross Entropy 계산
    return tf.reduce_mean(-tf.reduce_sum(y_true * tf.math.log(y_pred)))

# 정확도 척도 정의
def accuracy(y_pred, y_true):
    # 예측 클래스는 예측 벡터에서 가장 높은 스코어 인덱스
    correct_prediction = tf.equal(tf.argmax(y_pred, 1), tf.cast(y_true, tf.int64))
    return tf.reduce_mean(tf.cast(correct_prediction, tf.float32))

# Stochastic Gradient Descent (SGD;확률적경사하강법) 알고리즘
optimizer = tf.optimizers.SGD(learning_rate)

# 학습 알고리즘 최적화 과정
def run_optimization(x, y):
    # 텐서플로우는 자동 미분(주어진 입력 변수에 대한 연산의 gradient를 계산하는 것)을 위한 tf.GradientTape 함수 사용
    with tf.GradientTape() as g:
        pred = logistic_regression(x)
        loss = cross_entropy(pred, y)

    # gradients 계산
    gradients = g.gradient(loss, [W, b])
    
    # gradients에 따라 Weight(W)와 bias(b) 업데이트
    optimizer.apply_gradients(zip(gradients, [W, b]))

# 주어진 스텝에 맞춰 training 시작
for step, (batch_x, batch_y) in enumerate(train_data.take(training_steps), 1):
    # Weight(W)와 bias(b) 업데이트를 위해 사전 정의된 최적화 과정 실행
    run_optimization(batch_x, batch_y)
    
    # display_step(50, 100, 150...)에서 적용 중인 파라미터값 출력
    if step % display_step == 0:
        pred = logistic_regression(batch_x)
        loss = cross_entropy(pred, batch_y)
        acc = accuracy(pred, batch_y)
        print("step: %i, loss: %f, accuracy: %f" % (step, loss, acc))
step: 50, loss: 666.254395, accuracy: 0.765625
step: 100, loss: 515.914062, accuracy: 0.828125
step: 150, loss: 614.817017, accuracy: 0.832031
step: 200, loss: 620.690918, accuracy: 0.820312
step: 250, loss: 520.586487, accuracy: 0.867188
step: 300, loss: 580.417847, accuracy: 0.871094
step: 350, loss: 484.761322, accuracy: 0.839844
step: 400, loss: 621.492798, accuracy: 0.820312
step: 450, loss: 791.947632, accuracy: 0.820312
step: 500, loss: 616.336060, accuracy: 0.828125
step: 550, loss: 645.748718, accuracy: 0.851562
step: 600, loss: 732.390259, accuracy: 0.761719
step: 650, loss: 631.023621, accuracy: 0.832031
step: 700, loss: 74.979805, accuracy: 0.914062
step: 750, loss: 48.739697, accuracy: 0.941406
step: 800, loss: 70.699936, accuracy: 0.910156
step: 850, loss: 60.746632, accuracy: 0.937500
step: 900, loss: 57.646683, accuracy: 0.937500
step: 950, loss: 95.919128, accuracy: 0.890625
step: 1000, loss: 72.987892, accuracy: 0.929688

# 테스트 셋을 사용해 훈련된 모델의 정확도 측정
pred = logistic_regression(x_test)
print("Test Accuracy: %f" % accuracy(pred, y_test))
Test Accuracy: 0.913800

# 예측 결과 시각화
import matplotlib.pyplot as plt

# 훈련된 모델에서 5개 이미지 예측
n_images = 5
test_images = x_test[:n_images]
predictions = logistic_regression(test_images)

# 이미지 결과 시각화 및 모델 예측
for i in range(n_images):
    plt.imshow(np.reshape(test_images[i], [28, 28]), cmap='gray')
    plt.show()
    print("Model prediction: %i" % np.argmax(predictions.numpy()[i]))

Model prediction: 7
Model prediction: 2
Model prediction: 1
Model prediction: 0
Model prediction: 4

#참고 - [TensorFlow] 원-핫 인코딩(One-hot encoding)

: 원-핫 인코딩은 표현하고 싶은 단어 인덱스에 1을, 다른 인덱스에는 0을 부여하는 단어의 벡터 표현 방식

(1) 각 단어에 고유한 인덱스를 부여 (정수 인코딩)

(2) 표현하고 싶은 단어의 인덱스 위치에 1을 부여하고, 다른 단어의 인덱스의 위치에 0을 부여

#Reference

1) https://github.com/aymericdamien/TensorFlow-Examples/tree/master/tensorflow_v2

2) http://yann.lecun.com/exdb/mnist/

3) https://ko.wikipedia.org/wiki/MNIST_%EB%8D%B0%EC%9D%B4%ED%84%B0%EB%B2%A0%EC%9D%B4%EC%8A%A4

4) https://mmlind.github.io/Simple_1-Layer_Neural_Network_for_MNIST_Handwriting_Recognition/

5) https://wikidocs.net/22647

[TensorFlow] Logistic Regression End

BioinformaticsAndMe