MLP MNIST 숫자 분류 pytorch에서 Tensorflow로 변환

from __future__ import absolute_import, division, print_function, unicode_literals
import os
import numpy as np
import matplotlib.pyplot as plt
import tensorflow as tf
from tensorflow.keras.utils import Sequence
from tensorflow.keras.utils import to_categorical
import tensorflow.keras as keras
from keras import models
from keras import layers
from tensorflow.keras.optimizers import SGD


%matplotlib inline
keras = tf.keras

import tensorflow_datasets as tfds
tfds.disable_progress_bar()


# DATA LOAD
(train_data, train_target), (test_data, test_target) = tf.keras.datasets.mnist.load_data()

train_data = train_data / 255.0
test_data = test_data / 255.0


batch_size = 20 # BATCH 사이즈 설정
data = tf.data.Dataset.from_tensor_slices((train_data, train_target))
data = data.shuffle(buffer_size=1024).batch(batch_size)

test = tf.data.Dataset.from_tensor_slices((test_data, test_target))
test = test.shuffle(buffer_size = 1024).batch(batch_size)

# MLP 모델 
net = models.Sequential()
net.add(layers.Flatten(input_shape=(28, 28)))
net.add(layers.Dense(512, activation='relu', input_shape=(28 * 28,)))
net.add(layers.Dense(10, activation='relu'))
net.add(layers.Softmax())
net.summary()

# LOSS FUNCTION OPTIMIZER = SGD 
criterion = keras.losses.SparseCategoricalCrossentropy(from_logits = False)
optimizer=SGD(lr=0.01, momentum=0.9)

# TRAIN
epochs = 10 # 10번 반복 

for epoch in range(epochs):
  train_loss = 0.0
  for step, (train_data, train_target) in enumerate(data): # 누산기
    with tf.GradientTape() as t: # GRADIENT 연산
      output = net(train_data, training = True) # 모델학습
      loss = criterion(train_target, output) # 손실값 계산
      
    grad = t.gradient(loss, net.trainable_weights) # GRADIENT 값 가중치 계산
    optimizer.apply_gradients(zip(grad, net.trainable_weights)) # 가중치 적용
    train_loss += loss.numpy() * 20 # 오차율 저장

  train_loss = train_loss/60000 # 오차율 계산
  print('Epoch: {} \tTraining Loss: {:.6f}'.format(  # 화면에 출력
        epoch+1, 
        train_loss
        ))



# TEST
test_loss = 0.0
class_correct = list(0. for i in range(10)) # 실제 레이블과 예상 레이블을 저장
class_total = list(0. for i in range(10)) # 레이블의 개수

for step, (test_data, test_target) in enumerate(test):
  output = net(test_data, training = True) # 모델학습
  loss = criterion(test_target, output) # 손실값 계산
  test_loss = loss.numpy()*20 # 오차율 계산
  pred = net.predict(test_data) # TEST 예측
  correct = tf.equal(tf.argmax(pred, 1), test_target.numpy()) # 실제값과 같다면 TRUE, 아니면 FALSE 
  

  for i in range(batch_size): # 결과 저장
        label = test_target[i].numpy()
        class_correct[label] += correct[i].numpy()
        class_total[label] += 1

test_loss = test_loss/10000 # 오차율 계산, 출력
print('Test Loss: {:.6f}\n'.format(test_loss))

for i in range(10): # ACCURACY 계산, 출력
    if class_total[i] > 0:
        print('Test Accuracy of %5s: %2d%% (%2d/%2d)' % (
            str(i), 100 * class_correct[i] / class_total[i],
            np.sum(class_correct[i]), np.sum(class_total[i])))
    else:
        print('Test Accuracy of %5s: N/A (no training examples)' % (classes[i]))

print('\nTest Accuracy (Overall): %2d%% (%2d/%2d)' % (
    100. * np.sum(class_correct) / np.sum(class_total),
    np.sum(class_correct), np.sum(class_total)))

Pytorch와 Tensorflow를 동시에 다루는 일이 중요하다고 들었다.

이번에는 효율을 향상시킨 코드를 Colab GPU 환경에서 Tensorflow keras 코드로 변환할 것이다.

 

 Colab을 열고 노트를 GPU 런타임으로 설정한다.

실제로 실행했을 때 학습속도가 CPU와는 다르게 빠른 것이 느껴졌다.

자료를 원하는 사람들을 위해 남겨둔다.