MNIST Multi layer ver 코드

# 기존의 MNIST 예제를 multi layer 형태의 neural network을 이용해서

# 구현해 보아요!

 

# 두가지로 해 볼꺼예요! 

 

# 첫번째는 MNIST 예제를 hidden layer없이 input layer와 output layer만 이용해서 구현

# => 기존의 multinomial classification

 

# 두번째는 MNIST 예제를 hidden layer를 사용해 구현

# => multilayer를 이용한 nueral network 형태의 multinomial classification

 

# 기본적으로 sklearn으로 MNIST를 구현합니다.

 

# 그리고 각각의 case에 대해서 tensorflow 1.15버전과 tensorflow 2.x버전으로 구현합니다.

 

# 처리된 결과를 비교해 보아요!

# 당연히 multilayer를 이용한 neural network 형태의 결과가 더 좋게 나와야 합니다.

# 그리고 1.x버전보다는 2.x버전이 더 좋게 나와야 해요!

# 단, layer의 수와 각 layer안의 node개수는 동일하게 설정합니다.!

 

## MNIST multinomial classification

## 3가지 형태로 구현

 

import numpy as np

import pandas as pd     

from sklearn.model_selection import train_test_split

from sklearn.preprocessing import MinMaxScaler

 

# raw data loading

df = pd.read_csv('/content/drive/MyDrive/융복합 프로젝트형 AI 서비스 개발(2021.06)/09월/14일(화요일)/mnist/train.csv')

 

# training data와 test data(최종평가용) 분리

train_x_data, test_x_data, train_t_data, test_t_data = \

train_test_split(df.drop('label', axis=1, inplace=False),

                 df['label'],

                 test_size=0.3,

                 random_state=0,

                 stratify=df['label'])

 

# x_data에 대한 Normalization

scaler = MinMaxScaler()

scaler.fit(train_x_data)

train_x_data_norm = scaler.transform(train_x_data)

test_x_data_norm = scaler.transform(test_x_data)

 

 

---

# sklearn 구현

from sklearn.linear_model import LogisticRegression

from sklearn.metrics import classification_report

 

model = LogisticRegression(solver='saga')

 

model.fit(train_x_data_norm, train_t_data)  

   

result = classification_report(test_t_data, model.predict(test_x_data_norm))

print(result)

 

# accuracy : 0.92

 

---

# tensorflow 1.15 구현

# Colab에서는 실행안됨! (1.15버전을 설치하거나 다른 방법을 이용해야 합니다.)

# %tensorflow_version 1.x

 

import tensorflow as tf

 

print('Tensorflow Version : {}'.format(tf.__version__))

 

# Tensorflow 1.15 구현을 위한 

# label에 대해 one-hot encoding을 적용

sess = tf.Session()

train_t_data_onehot = sess.run(tf.one_hot(train_t_data, depth=10))

test_t_data_onehot = sess.run(tf.one_hot(test_t_data, depth=10))

 

# placeholder

X = tf.placeholder(shape=[None,784], dtype=tf.float32)

T = tf.placeholder(shape=[None,10], dtype=tf.float32)

 

# Weight & bias

W = tf.Variable(tf.random.normal([784,10]))

b = tf.Variable(tf.random.normal([10]))

 

# Hypothesis(Model)

logit = tf.matmul(X,W) + b

H = tf.nn.softmax(logit)

 

# loss function(cross entropy)

loss = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits_v2(logits=logit, 

                                                                 labels=T))

 

# train

train = tf.train.GradientDescentOptimizer(learning_rate=1e-1).minimize(loss)

 

# session & 초기화

sess.run(tf.global_variables_initializer())   # 초기화 코드

 

# 반복학습

num_of_epoch = 3000   

batch_size = 100

 

for step in range(num_of_epoch):    

    

    num_of_iter = train_x_data_norm.shape[0] / batch_size

    

    for i in range(int(num_of_iter)):

        batch_x = train_x_data_norm[i*batch_size:(i+1)*batch_size]

        batch_y = train_t_data_onehot[i*batch_size:(i+1)*batch_size]

        tmp, loss_val = sess.run([train, loss], feed_dict={X:batch_x, 

                                                           T:batch_y})

    if step % 300 == 0:

        print('loss : {}'.format(loss_val))

        

predict = tf.argmax(H,1)

correct = tf.equal(predict, tf.argmax(T,1))

accuracy = tf.reduce_mean(tf.cast(correct, dtype=tf.float32))

 

# test data로 accuracy를 계산

test_result = sess.run(accuracy, feed_dict={X:test_x_data_norm, 

                                            T:test_t_data_onehot})

print('test_result : {}'.format(test_result))

 

# test_result : 0.9068254232406616

 

---

# tensorflow 2.x 구현(Keras)

 

import tensorflow as tf

from tensorflow.keras.models import Sequential

from tensorflow.keras.layers import Flatten, Dense

from tensorflow.keras.optimizers import Adam

 

keras_model = Sequential()

keras_model.add(Flatten(input_shape=(train_x_data_norm.shape[1],)))

keras_model.add(Dense(10, activation='softmax'))

 

keras_model.compile(optimizer=Adam(learning_rate=1e-1),

                    loss='sparse_categorical_crossentropy',

                    metrics=['accuracy'])

 

history = keras_model.fit(train_x_data_norm,

                          train_t_data,

                          epochs=100,

                          verbose=0,

                          batch_size=100,

                          validation_split=0.2)

print(classification_report(test_t_data,      

                            tf.argmax(keras_model.predict(test_x_data_norm), axis=1).numpy()))

 

# accuracy  0.89

 

---

## MNIST multinomial classification

## Tensorflow 1.15버전으로 구현(Multilayer Neural Network)

 

import tensorflow as tf

 

# Tensorflow 1.15 구현을 위한 

# label에 대해 one-hot encoding을 적용

sess = tf.Session()

train_t_data_onehot = sess.run(tf.one_hot(train_t_data, depth=10))

test_t_data_onehot = sess.run(tf.one_hot(test_t_data, depth=10))

 

# placeholder

X = tf.placeholder(shape=[None,784], dtype=tf.float32)

T = tf.placeholder(shape=[None,10], dtype=tf.float32)

 

# Weight & bias

W2 = tf.Variable(tf.random.normal([784,256]))

b2 = tf.Variable(tf.random.normal([256]))

layer2 = tf.sigmoid(tf.matmul(X,W2) + b2)

 

W3 = tf.Variable(tf.random.normal([256,512]))

b3 = tf.Variable(tf.random.normal([512]))

layer3 = tf.sigmoid(tf.matmul(layer2,W3) + b3)

 

W4 = tf.Variable(tf.random.normal([512,128]))

b4 = tf.Variable(tf.random.normal([128]))

layer4 = tf.sigmoid(tf.matmul(layer3,W4) + b4)

 

W5 = tf.Variable(tf.random.normal([128,10]))

b5 = tf.Variable(tf.random.normal([10]))

# Hypothesis(Model)

logit = tf.matmul(layer4,W5) + b5

H = tf.nn.softmax(logit)

 

# loss function(cross entropy)

loss = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits_v2(logits=logit, 

                                                                 labels=T))

 

# train

train = tf.train.GradientDescentOptimizer(learning_rate=1e-1).minimize(loss)

 

# session & 초기화

sess.run(tf.global_variables_initializer())   # 초기화 코드

 

# 반복학습

num_of_epoch = 300   

batch_size = 100

 

for step in range(num_of_epoch):    

    

    num_of_iter = train_x_data_norm.shape[0] / batch_size

    

    for i in range(int(num_of_iter)):

        batch_x = train_x_data_norm[i*batch_size:(i+1)*batch_size]

        batch_y = train_t_data_onehot[i*batch_size:(i+1)*batch_size]

        tmp, loss_val = sess.run([train, loss], feed_dict={X:batch_x, 

                                                           T:batch_y})

    if step % 30 == 0:

        print('loss : {}'.format(loss_val))

        

predict = tf.argmax(H,1)

correct = tf.equal(predict, tf.argmax(T,1))

accuracy = tf.reduce_mean(tf.cast(correct, dtype=tf.float32))

 

# test data로 accuracy를 계산

test_result = sess.run(accuracy, feed_dict={X:test_x_data_norm, 

                                            T:test_t_data_onehot})

print('test_result : {}'.format(test_result))

 

# test_result : 0.8950793743133545   ??????????? 모징??

 

---

## MNIST multinomial classification

## Tensorflow 2.x버전으로 구현(Multilayer Neural Network)

 

import tensorflow as tf

from tensorflow.keras.models import Sequential

from tensorflow.keras.layers import Flatten, Dense

from tensorflow.keras.optimizers import Adam

 

keras_model = Sequential()

keras_model.add(Flatten(input_shape=(train_x_data_norm.shape[1],)))

keras_model.add(Dense(256, activation='sigmoid'))

keras_model.add(Dense(512, activation='sigmoid'))

keras_model.add(Dense(128, activation='sigmoid'))

keras_model.add(Dense(10, activation='softmax'))

 

keras_model.compile(optimizer=Adam(learning_rate=1e-1),

                    loss='sparse_categorical_crossentropy',

                    metrics=['accuracy'])

 

history = keras_model.fit(train_x_data_norm,

                          train_t_data,

                          epochs=100,

                          verbose=0,

                          batch_size=100,

                          validation_split=0.2)

print(classification_report(test_t_data,      

                            tf.argmax(keras_model.predict(test_x_data_norm), axis=1).numpy()))

 

# accuracy  : 0.11 ??????????????????