import tensorflow as tf
import numpy as np
import matplotlib.pyplot as plt

# MNIST 데이터를 다운로드
(x_train, y_train), (x_test, y_test) = tf.keras.datasets.mnist.load_data()
x_train, x_test = x_train.astype('float32'), x_test.astype('float32')
x_train, x_test = x_train.reshape([-1, 784]), x_test.reshape([-1, 784])
x_train, x_test = x_train / 255., x_test / 255.

learning_rate = 0.02
training_epochs = 50     # 반복 횟수
batch_size = 256    # 배치 개수
display_step = 1    # 손실함수 출력 주기
examples_to_show = 10 # 보여줄 MNIST Reconstruction 이미지 개수
input_size = 784    # 28*28
hidden1_size = 256
hidden2_size = 128

# tf.data API를 이용해서 데이터를 섞고 batch 형태로 가져온다.
train_data = tf.data.Dataset.from_tensor_slices(x_train)
train_data = train_data.shuffle(60000).batch(batch_size)

def random_normal_initializer_with_stddev_1():
    return tf.keras.initializers.RandomNormal(mean=0.0, stddev=1.0, seed=None)

# tf.keras.Model을 이용해서 Autoencoder 모델 정의
class AutoEncoder(tf.keras.Model):
    def __init__(self):
        super(AutoEncoder, self).__init__()
        # 인코딩(Encoding) - 784 -> 256 -> 128
        self.hidden_layer_1 = tf.keras.layers.Dense(hidden1_size,
                                                    activation='sigmoid',
                                                    kernel_initializer=random_normal_initializer_with_stddev_1(),
                                                    bias_initializer=random_normal_initializer_with_stddev_1())
        self.hidden_layer_2 = tf.keras.layers.Dense(hidden2_size,
                                                    activation='sigmoid',
                                                    kernel_initializer=random_normal_initializer_with_stddev_1(),
                                                    bias_initializer=random_normal_initializer_with_stddev_1())
        # 디코딩(Decoding) 128 -> 256 -> 784
        self.hidden_layer_3 = tf.keras.layers.Dense(hidden1_size,
                                                    activation='sigmoid',
                                                    kernel_initializer=random_normal_initializer_with_stddev_1(),
                                                    bias_initializer=random_normal_initializer_with_stddev_1())
        self.output_layer = tf.keras.layers.Dense(input_size,
                                                  activation='sigmoid',
                                                  kernel_initializer=random_normal_initializer_with_stddev_1(),
                                                  bias_initializer=random_normal_initializer_with_stddev_1())
        
    def call(self, x):
        H1_output = self.hidden_layer_1(x)
        H2_output = self.hidden_layer_2(H1_output)
        H3_output = self.hidden_layer_3(H2_output)
        reconstructed_x = self.output_layer(H3_output)

        return reconstructed_x

# MSE 손실함수를 정의한다.
@tf.function
def mse_loss(y_pred, y_true):
    return tf.reduce_mean(tf.pow(y_true - y_pred, 2)) 

# 최적화를 위한 RMSProp 옵티마이저 정의
optimizer = tf.optimizers.RMSprop(learning_rate)

# 최적화를 위한 function을 정의
@tf.function
def train_step(model, x):
    # 타겟데이터는 인풋데이터 와 같다.
    y_true = x
    with tf.GradientTape() as tape:
        y_pred = model(x)
        loss = mse_loss(y_pred, y_true)
    gradients = tape.gradient(loss, model.trainable_variables)
    optimizer.apply_gradients(zip(gradients, model.trainable_variables))
    return loss

# Autoencoder 모델 선언.
AutoEncoder_model = AutoEncoder()

# 지정된 횟수만큼 최적화를 수행
for epoch in range(training_epochs):
    for batch_x in train_data:
        loss = train_step(AutoEncoder_model, batch_x)
    # 지정된 epoch마다 학습결과 출력.
    if epoch % display_step == 0:
        print("반복(Epoch): %d, 손실함수(Loss): %f" % (epoch + 1, loss))

# 테스트 데이터로 Reconstruction을 수행한다.
reconstructed_result = AutoEncoder_model(x_test[:examples_to_show])
# 원본 MNIST 데이터와 Reconstruction 결과를 비교.
f, a = plt.subplots(2, 10, figsize=(10, 2))
for i in range(examples_to_show):
    a[0][i].imshow(np.reshape(x_test[i], (28, 28)), cmap='gray')
    a[1][i].imshow(np.reshape(reconstructed_result[i], (28, 28)), cmap='gray')
f.savefig('reconstructed_mnist_image.png')  # reconstruction 결과를 png로 저장.
plt.show()
plt.draw()
plt.waitforbuttonpress()

코드를 분할해서 이해해보자.

1.MNIST 데이터 준비

# MNIST 데이터를 다운로드
(x_train, y_train), (x_test, y_test) = tf.keras.datasets.mnist.load_data()
x_train, x_test = x_train.astype('float32'), x_test.astype('float32')
x_train, x_test = x_train.reshape([-1, 784]), x_test.reshape([-1, 784])
x_train, x_test = x_train / 255., x_test / 255.

MNIST데이터셋을 다운로드하고 준비한다. MNIST는 0부터 9까지의 숫자이미지 로 구성된 데이터셋이다.

• tf.keras.datasets.mnist.load_data()를 사용해 데이터를 로드한다.
• 이미지를 28x28크기의 2D배열에서 784크기의 1D배열로 변환한다.
• 각 픽셀 값을 0 ~ 255 범위에서 0~1범위로 정규화한다.

2.하이퍼 파라미터 설정

learning_rate = 0.02
training_epochs = 50     # 반복 횟수
batch_size = 256    # 배치 크기
display_step = 1    # 손실 함수 출력 주기
examples_to_show = 10 # 보여줄 MNIST Reconstruction 이미지 개수
input_size = 784    # 28*28
hidden1_size = 256
hidden2_size = 128

모델 학습에 필요한 여러 설정 값을 지정한다.

• learning_rate: 학습 속도
• training_epochs: 학습 반복 횟수
• batch_size: 한 번에 학습할 데이터 크기
• display_step: 손실 함수 출력 주기
• examples_to_show: 나중에 보여줄 재구성된 이미지 개수
• input_size: 입력 이미지의 크기
• hidden1_size, hidden2_size: 은닉층의 뉴런 개수

3.데이터 셋 준비

# tf.data API를 이용해서 데이터를 섞고 batch 형태로 가져온다.
train_data = tf.data.Dataset.from_tensor_slices(x_train)
train_data = train_data.shuffle(60000).batch(batch_size)

데이터를 섞고 배치 크기로 나누어 학습에 사용한다.

• shuffle(60000): 데이터셋을 섞는다.
• batch(batch_size): 데이터를 batch 크기로 나눈다.
  
  

4.모델 정의

def random_normal_initializer_with_stddev_1():
    return tf.keras.initializers.RandomNormal(mean=0.0, stddev=1.0, seed=None)

# tf.keras.Model을 이용해서 Autoencoder 모델 정의
class AutoEncoder(tf.keras.Model):
    def __init__(self):
        super(AutoEncoder, self).__init__()
        # 인코딩(Encoding) - 784 -> 256 -> 128
        self.hidden_layer_1 = tf.keras.layers.Dense(hidden1_size,
                                                    activation='sigmoid',
                                                    kernel_initializer=random_normal_initializer_with_stddev_1(),
                                                    bias_initializer=random_normal_initializer_with_stddev_1())
        self.hidden_layer_2 = tf.keras.layers.Dense(hidden2_size,
                                                    activation='sigmoid',
                                                    kernel_initializer=random_normal_initializer_with_stddev_1(),
                                                    bias_initializer=random_normal_initializer_with_stddev_1())
        # 디코딩(Decoding) 128 -> 256 -> 784
        self.hidden_layer_3 = tf.keras.layers.Dense(hidden1_size,
                                                    activation='sigmoid',
                                                    kernel_initializer=random_normal_initializer_with_stddev_1(),
                                                    bias_initializer=random_normal_initializer_with_stddev_1())
        self.output_layer = tf.keras.layers.Dense(input_size,
                                                  activation='sigmoid',
                                                  kernel_initializer=random_normal_initializer_with_stddev_1(),
                                                  bias_initializer=random_normal_initializer_with_stddev_1())
        
    def call(self, x):
        H1_output = self.hidden_layer_1(x)
        H2_output = self.hidden_layer_2(H1_output)
        H3_output = self.hidden_layer_3(H2_output)
        reconstructed_x = self.output_layer(H3_output)

        return reconstructed_x

오토인코더 모델을 정의한다.

오토인코더는 입력 데이터를 인코딩했다가. 다시 디코딩하여 원래 데이터와 비슷하게 재구성하는 모델이다.

• hidden_layer_1: 첫 번째 은닉층, 784 -> 256
• hidden_layer_2: 두 번째 은닉층, 256 -> 128
• hidden_layer_3: 세 번째 은닉층, 128 -> 256
• output_layer: 출력층, 256 -> 784
• call 메소드: 모델이 데이터를 처리하는 방법을 정의한다.
  H1output이 H2output으로 들어가고를 반복하여 reconstructed_x로 출력된다.

5. 손실 함수 및 옵티마이저 정의

# MSE 손실함수를 정의한다.
@tf.function
def mse_loss(y_pred, y_true):
    return tf.reduce_mean(tf.pow(y_true - y_pred, 2)) 

# 최적화를 위한 RMSProp 옵티마이저 정의
optimizer = tf.optimizers.RMSprop(learning_rate)

학습 과정에서 사용할 손실함수 와 옵티마이저를 정의한다.

• mse_loss: 평균 제곱 오차(MSE)를 손실 함수로 사용한다.
• optimizer: RMSProp 옵티마이저를 사용하여 모델을 최적화한다.

6. 학습과정 정의

# 최적화를 위한 function을 정의
@tf.function
def train_step(model, x):
    # 타겟데이터는 인풋데이터와 같다.
    y_true = x
    with tf.GradientTape() as tape:
        y_pred = model(x)
        loss = mse_loss(y_pred, y_true)
    gradients = tape.gradient(loss, model.trainable_variables)
    optimizer.apply_gradients(zip(gradients, model.trainable_variables))
    return loss

학습 과정에서 각 배치에 대해 모델을 최적화하는 방법을 정의한다.

• train_step: 한 단계 학습을 수행하는 함수입니다
• GradientTape: 손실에 대한 그래디언트를 계산합니다.
• optimizer.apply_gradients: 계산된 그래디언트를 사용하여 모델의 가중치를 업데이트합니다.

7. 모델 학습

# Autoencoder 모델 선언.
AutoEncoder_model = AutoEncoder()

# 지정된 횟수만큼 최적화를 수행
for epoch in range(training_epochs):
    for batch_x in train_data:
        loss = train_step(AutoEncoder_model, batch_x)
    # 지정된 epoch마다 학습결과 출력.
    if epoch % display_step == 0:
        print("반복(Epoch): %d, 손실함수(Loss): %f" % (epoch + 1, loss))

모델을 학습시킨다.

• 각 epoch 동안 데이터셋의 각 배치에 대해 train_step을 호출하여 모델을 최적화한다.
• 매 display_step마다 현재 에폭과 손실 함수를 출력한다.

8. 결과 확인

# 테스트 데이터로 Reconstruction을 수행한다.
reconstructed_result = AutoEncoder_model(x_test[:examples_to_show])
# 원본 MNIST 데이터와 Reconstruction 결과를 비교.
f, a = plt.subplots(2, 10, figsize=(10, 2))
for i in range(examples_to_show):
    a[0][i].imshow(np.reshape(x_test[i], (28, 28)), cmap='gray')
    a[1][i].imshow(np.reshape(reconstructed_result[i], (28, 28)), cmap='gray')
f.savefig('reconstructed_mnist_image.png')  # reconstruction 결과를 png로 저장.
plt.show()
plt.draw()
plt.waitforbuttonpress()

테스트 데이터를 사용하여 모델이 입력 데이터를 얼마나 잘 재구성하는지 확인한다.

위 과정을 통해 오토인코더 모델이 데이터를 압축했다가 다시 복원하는 능력을 학습하게 된다.

모델이 잘 학습되면 재구성된 이미지가 유사하게 나타난다.

오토인코더 는 대표적인 비지도 학습을 위한 인공신경망 구조 중 하나이다.

비지도 학습은 어떤값을 예측하거나 분류하는 목적인 지도학습 과 는 다르게 데이터의 숨겨진 구조를 발견하는 것이 목표인 학습방법 이다.

오토인코더의 구조

오토인코더는 출력충의 노드 개수와 입력층의 노드 개수가 동일한 구조의 인공신경망이다. 오토인코더의 구조는 다음과 같이 나뉜다.

• 입력층(Input Layer) 원본 데이터를 입력받는 층
• 은닉층(Hidden Layer) 입력 데이터를 압축하여 중요한 특징만을 추출하는 층
• 출력층(Output Layer) 원본 데이터를 재구축하는 층

오토인코더의 동작방식

주요동작과정은 다음과 같다.

• 입력데이터 재구축
  출력은 원본데이터를 재구축한 결과이다.
  예를들어 MNIST데이털르 재구축한 결과는 약간의 노이즈가 포함된 원본데이터와 유사한 이미지를 나타낸다.
• 은닉층의 중요성
  중요한 것은 출력값이 아닌 은닉층의 출력값이다.
  은닉층의 출력은 원본데이터에서 불필요한 특징들을 제거한 압축된 특징을 학습하게 된다.

오토인코더의 특징

은닉층의 노드개수 가 입력층과 출력층의 노드 개수보다 적다.

은닉층은 더 작은 표현력으로 원본 데이터의 모든특징을 학습해야 한다.

결과적으로 은닉층의 출력값은 원본데이터의 불필요한 특징을 제거한 압축된 특징을 나타낸다.

import tensorflow as tf

# MNIST 데이터를 다운로드
(x_train, y_train), (x_test, y_test) = tf.keras.datasets.mnist.load_data()
x_train, x_test = x_train.astype('float32'), x_test.astype('float32')
x_train, x_test = x_train.reshape([-1, 784]), x_test.reshape([-1, 784])
x_train, x_test = x_train / 255., x_test / 255.
y_train, y_test = tf.one_hot(y_train, depth=10), tf.one_hot(y_test, depth=10)

learning_rate = 0.001
num_epochs = 30
batch_size = 256
display_step = 1
input_size = 784
hidden1_size = 256
hidden2_size = 256
output_size = 10

train_data = tf.data.Dataset.from_tensor_slices((x_train, y_train))
train_data = train_data.shuffle(60000).batch(batch_size)

def random_normal_intializer_with_stddev_1():
    return tf.keras.initializers.RandomNormal(mean=0.0, stddev=1.0, seed=None)

class ANN(tf.keras.Model):
    def __init__(self):
        super(ANN, self).__init__()
        self.hidden_layer_1 = tf.keras.layers.Dense(hidden1_size,
                                                    activation='relu',
                                                    kernel_initializer=random_normal_intializer_with_stddev_1(),
                                                    bias_initializer=random_normal_intializer_with_stddev_1())
        self.hidden_layer_2 = tf.keras.layers.Dense(hidden2_size,
                                                    activation='relu',
                                                    kernel_initializer=random_normal_intializer_with_stddev_1(),
                                                    bias_initializer=random_normal_intializer_with_stddev_1())
        self.output_layer = tf.keras.layers.Dense(output_size,
                                                  activation=None,
                                                  kernel_initializer=random_normal_intializer_with_stddev_1(),
                                                  bias_initializer=random_normal_intializer_with_stddev_1())
        
    def call(self, x):
        H1_output = self.hidden_layer_1(x)
        H2_output = self.hidden_layer_2(H1_output)
        logits = self.output_layer(H2_output)

        return logits
        
@tf.function
def cross_entropy_loss(logits, y):
    return tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(logits=logits, labels=y))

optimizer = tf.optimizers.Adam(learning_rate)

@tf.function
def train_step(model, x, y):
    with tf.GradientTape() as tape:
        y_pred = model(x)
        loss = cross_entropy_loss(y_pred, y)
    gradients = tape.gradient(loss, model.trainable_variables)
    optimizer.apply_gradients(zip(gradients, model.trainable_variables))
    return loss

@tf.function
def compute_accuracy(y_pred, y):
    correct_prediction = tf.equal(tf.argmax(y_pred, 1), tf.argmax(y, 1))
    accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))
    return accuracy

ANN_model = ANN()

for epoch in range(num_epochs):
    average_loss = 0.
    total_batch = int(x_train.shape[0] / batch_size)
    for batch_x, batch_y in train_data:
        current_loss = train_step(ANN_model, batch_x, batch_y)
        average_loss += current_loss / total_batch
    if epoch % display_step == 0:
        print("반복(Epoch): %d, 손실함수(Loss): %f" % ((epoch+1), average_loss))

accuracy = compute_accuracy(ANN_model(x_test), y_test)
print("정확도(Accuracy): %f" % accuracy)

코드 부분을 한부분씩 잘라서 이해해보자.

데이터 전처리

# MNIST 데이터를 다운로드
(x_train, y_train), (x_test, y_test) = tf.keras.datasets.mnist.load_data()
# 이미지들을 float32 데이터 타입으로 변경
x_train, x_test = x_train.astype('float32'), x_test.astype('float32')
# 28*28 형태의 이미지를 784차원으로 flattening 한다.
x_train, x_test = x_train.reshape([-1, 784]), x_test.reshape([-1, 784])
# [0, 255] 사이의 값을 [0, 1] 사이의 값으로 Normalize한다.
x_train, x_test = x_train / 255., x_test / 255.
# 레이블 데이터에 one-hot encoding을 적용한다.
y_train, y_test = tf.one_hot(y_train, depth=10), tf.one_hot(y_test, depth=10)

https://inradestrt.tistory.com/664

위 MNIST데이터셋을 다운로드하여 사용한다.

데이터타입을 float32형식으로 변환한다.

• 이미지데이터는 기본적으로 uint8형식으로 되어있으나, 신경망 모델은 float32 타입의 데이터를 다루기 때문.

이미지 평탄화(Flattening)

• MNIST이미지는 28x28픽셀 크기의 2D배열 형태이다. 이 이미지를 1D형태로 변환하여 신경만의 입력으로 사용하기 위해 평탄화(flatten)한다.

정규화(Normalize)

• 이미지 픽셀값은 [0, 255](흑백) 값을 가지는데, 모델이 학습할 떄 더 빠르고 안정적으로 학습할 수 있도록 [0, 1] 사이로 정규화한다.

One-Hot 인코딩

• 레이블 데이터는 0에서 9까지의 정수값이다. 이를 신경망 출력과 비교하기 쉽게 One-hot인코딩을 통해 이진벡터로 변환하여 키값을 레이블 해준다.

데이터셋 준비

learning_rate = 0.001
num_epochs = 30
batch_size = 256
display_step = 1
input_size = 784
hidden1_size = 256
hidden2_size = 256
output_size = 10

학습률(learning_rate)

• 모델의 학습 속도를 결정한다. 내려가는 경사도라고 이해하면됨

에포크 수(num_epochs)

• 전체 데이터셋 학습을 몇 번 반복할지 설정한다.

배치 크기(batch_size)

• 한번에 학습할 데이터의 크기를 설정한다. 256개씩 묶음
  한번에 모든 데이터를 학습하게 되면 너무 느리기 때문에, 부분부분씩 잘라서 학습한다고 생각하자.

레이어 크기(hidden, output_size)

• 노드의 크기를 설정한다.

모델 정의

class ANN(tf.keras.Model):
    def __init__(self):
        super(ANN, self).__init__()
        self.hidden_layer_1 = tf.keras.layers.Dense(hidden1_size,
                                                    activation='relu',
                                                    kernel_initializer=random_normal_intializer_with_stddev_1(),
                                                    bias_initializer=random_normal_intializer_with_stddev_1())
        self.hidden_layer_2 = tf.keras.layers.Dense(hidden2_size,
                                                    activation='relu',
                                                    kernel_initializer=random_normal_intializer_with_stddev_1(),
                                                    bias_initializer=random_normal_intializer_with_stddev_1())
        self.output_layer = tf.keras.layers.Dense(output_size,
                                                  activation=None,
                                                  kernel_initializer=random_normal_intializer_with_stddev_1(),
                                                  bias_initializer=random_normal_intializer_with_stddev_1())
        
    def call(self, x):
        H1_output = self.hidden_layer_1(x)
        H2_output = self.hidden_layer_2(H1_output)
        logits = self.output_layer(H2_output)

        return logits

모델 클래스 정의

• 딥러닝 모델 정의

첫 번째 은닉층

• 256개의 뉴런을 가진 첫 번째 은닉층, ReLU활성화 함수 사용

두 번째 은닉층

• • 256개의 뉴런을 가진 첫 번째 은닉층, ReLU활성화 함수 사용

출력층

• 10개의 뉴런을 가진 출력층, 나중에 소프트맥스 적용을 위해 활성화 함수가 없다.

손실 함수 정의

@tf.function
def cross_entropy_loss(logits, y):
    return tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(logits=logits, labels=y))

교차 엔트로피 손실 함수

• 예측값과 실제값 차이를 계산하는 함

학습의 불일치 부분을 확인하고 모델의 성능을 향상시키기 위해 생성함.

옵티마이저 정의

optimizer = tf.optimizers.Adam(learning_rate)

Adam최적화기

• 모델 가중치 학습을 위한 최적화 알고리즘

학습 단계 정의

@tf.function
def train_step(model, x, y):
    with tf.GradientTape() as tape:
        y_pred = model(x)
        loss = cross_entropy_loss(y_pred, y)
    gradients = tape.gradient(loss, model.trainable_variables)
    optimizer.apply_gradients(zip(gradients, model.trainable_variables))
    return loss

학습 단계

• 모델의 가중치를 업데이트하는 단계 정의, 손실을 계산하고 그에따른 그래디언트를 구해 가중치를 조정한다.

모델 학습 및 평가

ANN_model = ANN()

for epoch in range(num_epochs):
    average_loss = 0.
    total_batch = int(x_train.shape[0] / batch_size)
    for batch_x, batch_y in train_data:
        current_loss = train_step(ANN_model, batch_x, batch_y)
        average_loss += current_loss / total_batch
    if epoch % display_step == 0:
        print("반복(Epoch): %d, 손실함수(Loss): %f" % ((epoch+1), average_loss))

accuracy = compute_accuracy(ANN_model(x_test), y_test)
print("정확도(Accuracy): %f" % accuracy)

모델 인스턴스화

• ANN모델 인스턴스 화

모델 학습

• 설정한 에포크 수 만큼 학습한다. 각 배치마다 손실을 계산하고 가중치 업데이트.

모델 평가

• 테스트 데이터로 모델의 정확도를 계산하고 출력.

퍼셉트론

이전에 인공신경망의 개념을 제안하였지만, 개념적인 시도로써 공학적인 구현을 최초로 제안한 개념

무려 1958년에 나온 논문이다.

퍼셉트론 은 생물학적 뉴런을 공학적인 구조로 변형한 그림이다.

퍼셉트론은 입력층(Input [ in(t) ] )와 출력층(Output [ out(t) ] ) 을 가진다.

퍼셉트론은 입력층에서 인풋데이터 X를 받고 이를 가중치 W와 곱한 후 이 값에 바이어스 b를 더한다.

이 값을 활성함수 (시그모이드 함수) 의 입력값으로 대입해서, 출력층은 최종적으로 0 또는 1의 값으로 출력한다.

활성함수는 계단함수를 사용해서 0보다 작으면 0 크면 1 이런식으로 0 또는 1로 표현하게 한다.

W는 가중치를 의미한다.

의사결정에 대한 값은 X라고 할때

W1 ~ Wn까지는 임의의 가중치 이다.

고려사항을 Perceptron의 input에 넣을 수 있다.

( 어떤 행동을 할 때 확인해야할 조건문 )

퍼셉트론은 지금의 딥러닝 화제처럼, 실제 인간과 같은 인공지능을 만들 수 있을것이라는 기대를 받았으나,

퍼셉트론은 단순한 선형 분류기에 불과하며 단순한 XOR문제도 해결할 수 없다는 사실을 수학적으로 증명하면서 인기가 사라졌다.

즉, 퍼셉트론은 선형분류이기 때문에, 직선 한개로 구분하지 못하는 상황은 해결할 수 없다는 시사점이 있다.

다층 퍼셉트론 MLP( Mutli - Layer Perceptron ) = 인공신경망 ( ANN )

( 퍼셉트론 개선 )

인공신경망 대신 논리적인 추론을 이용하는 방법으로 연구했다. 퍼셉트론을 여러층으로 쌓아올린 다층 퍼셉트론(Multi - Layer Perceptron(MLP)가 나타났다.

다중 퍼셉트론을 이용하면 선형 분리가 불가능한 문제도 해결할 수 있다는 사실이 밝혀졌다.

ANN이라는 용어를 사용할때 일반적으로는 다층 퍼셉트론을 의미한다.

다층 퍼셉트론은 입력층, 은닉층, 출력층 으로 구성되어있으며, 은닉층 은 입출력과정에서 직접적으로 보이지는 않지만 숨겨진 특징을 학습하는 역할을 한다.

위 다층 퍼셉트론을 한부분만 보면 퍼셉트론 한개가 보이는걸 볼 수 있다.

이러한 다층 퍼셉트론은 퍼셉트론을 여러개 겹쳐놓은것 이라고 이해하면 된다.

이러한 다층 퍼셉트론은 활성 함수로 계단함수 가 아닌 비선형 함수인 시그모이드 와 쌍곡 탄젠트혹은 ReLU를 사용한다.

활성함수의 출력 결과인 y를 활성값 Activation이라고 부른다.

과거에는 Sigmoid함수를 많이 사용하였지만, 최근에는 ReLU가 딥러닝 학습에 더 적합하다고 알려져서 ReLU를 더 많이 사용하는 추세이다.

배니싱 그레디언트 프라브럼 문제를 해결하기 위해서 ReLu를 사용한다.

그레디언트 는 결국 미분값 이다. 여기서 시그모이드 함수의 차트상, 일정 범위를 벗어나게 되면 0으로 빠져버려서 값이 무시되는 문제가 발생한다.

ReLu의 경우 0보다 작으면 무조건 미분값이 0으로 빠지지만, ReLu의 경우 0보다 크다면, 항상 위로 수렴하기 때문에 값이 무시되지 않는다.

위 그래프를 보고 이해해보자.

시그모이드 함수 (Sigmoid Function)

$ \sigma(x) = \frac{1}{1+e^{-x}} $

특징으로는 출력값을 0 과 1사이에 위치하게 하며, 입력값이 커질 수록 1에 가까워지고 입력값이 작아질수록 0에 가까워지게 한다.

매우 큰 양수나, 음수 값에서 그래디언트가 거의 0에 가까워지는 배니싱 그라디언트 문제가 발생.

쌍곡 탄젠트 함수(Tanh Funtion)

$ tanh(x) = \frac{e^{x} - e^{-x}}{e^{x} + e^{-x}} $

특징으로는 출력값이 -1과 1사이에 위치하며 중심이 0이라서 시그모이드 함수보다 학습이 잘 되는 경우가 많다.

시그모이드 함수와 유사하게 큰 양수나 음수에서 그래디언트가 거의 0에 가까워지는 배니싱 그라디언트 문제가 발생

ReLU함수(Rectified Linear Unit Function)

$ ReLU(x) = max(0, x) $

출력값이 0 또는 입력값 자체가 된다. 음수 입력값에 대해서는 0을 출력하고, 양수는 그대로 출력한다.

배니싱그라디언트 문제를 완화할 수 있다. 양수 입력에 대해서는 그래디언트가 0이 아님으로, 신경망의 깊은층 학습이 잘 이루어진다.

음수 입력값이 많을 경우 뉴런이 죽어버리는 다잉ReLU문제가 발생할 수 있다.

ImageAiCon PP

진행중인 작업

프리뷰 로드아웃 제작중

알고리즘 학습중...

사전지식

결과물

https://inradestrt.tistory.com/659

https://inradestrt.tistory.com/667

진행 예정 작업
(예상)

1. Unreal의 ImageAI공부하기
   
   1. CNN알고리즘 다시 복기하기
   2. 알고리즘 선별( 현 예상안 으로는,DQN알고리즘 사용예정)
   3. 알고리즘 관련 강의 학습( 자본이 준비되면 강의학습을 진행하며 정리사항 정리예정)
2. Unreal ImageRetargeting 코드제작
   1. 언리얼 함수 상으로 지정된 카메라의 타겟뷰를 이미지값으로 저장 반환하는 방식이 존재함.
   2. TCP방식으로 데이터 통신처리를 진행
   3. TensorFlow를 사용하여 전달받은 이미지로 학습 알고리즘 연산.
   4. 연산결과를 다시 언리얼로 전달하여 학습된 데이터를 갱신.
   5. 4번과 3번을 반복
3. 학습결과확인 후 재학습
4.  5와 6을 원하는 AI행동패턴이 나타날때까지 반복

목표

1. TensorFlow를 사용하여 알고리즘이 동작하는지 직접적인 확인을 진행.
2. TensorFlow 를 사용하지 않고, 스스로의 C++코드로 알고리즘 함수 구현부를 직접 제작하여 사용하는것
   (파이썬만으로 k means clustering를 구현하였을 때, 구현객체가 C++의 연산처리속도를 따라잡지 못하는 상황이 있었음)
3. UI관련 제작방식은 C#으로, 함수부는 DLL파일로 포팅하여 언리얼 엔진에 집어넣기.

완료된 작업

import tensorflow as tf

## 
# MNIST 데이터를 다운로드
(x_train, y_train), (x_test, y_test) = tf.keras.datasets.mnist.load_data()
# 이미지들을 float32 데이터 타입으로 변경
x_train, x_test = x_train.astype('float32'), x_test.astype('float32')
# 28*28 형태의 이미지를 784차원으로 flattening 한다.
x_train, x_test = x_train.reshape([-1, 784]), x_test.reshape([-1, 784])
# [0, 255] 사이의 값을 [0, 1] 사이의 값으로 Normalize한다.
x_train, x_test = x_train / 255., x_test / 255.
# 레이블 데이터에 one-hot encoding을 적용한다.
y_train, y_test = tf.one_hot(y_train, depth=10), tf.one_hot(y_test, depth=10)
## 데이터형태를 학습용 데이터로 재가공.

## 
# tf.data API를 이용해서 데이터를 섞고 batch 형태로 가져온다.
train_data = tf.data.Dataset.from_tensor_slices((x_train, y_train))
train_data = train_data.repeat().shuffle(60000).batch(100)
train_data_iter = iter(train_data)
## 원하는 배치로 데이터를 끊어서 더 효율적으로 사용

##
# tf.keras.Model을 이용해서 SoftMax Regression 모델을 정의한다.
class SoftmaxRegression(tf.keras.Model):
    def __init__(self):
        super(SoftmaxRegression, self).__init__()
        self.softmax_layer = tf.keras.layers.Dense(10,
                                                   activation=None,
                                                   kernel_initializer='zeros',
                                                   bias_initializer='zeros')
        
    def call(self, x):
        logits = self.softmax_layer(x)
        return tf.nn.softmax(logits)

## 케라스 서브클레싱 방식을 사용해서 생성자로, 
# 하위 API로 모델구조를 정의. call에는 인자값으로 인풋, 출력으로 반환으로 하여 %로 볼 수 있게함


## 
# cross-entropy 손실 함수를 정의한다.
@tf.function
def cross_entropy_loss(y_pred, y):
    return tf.reduce_mean(-tf.reduce_sum(y * tf.math.log(y_pred), axis=[1]))
## 학습가중치에 따른 불일치부분 확인용 손실함수 정의


# 최적화를 위한 그라디언트 디센트 옵티마이저를 정의
optimizer = tf.optimizers.SGD(0.5)

##
# 최적화를 위한 function을 정의.
@tf.function
def train_step(model, x, y):
    with tf.GradientTape() as tape:
        y_pred = model(x)
        loss = cross_entropy_loss(y_pred, y)
    gradients = tape.gradient(loss, model.trainable_variables)
    optimizer.apply_gradients(zip(gradients, model.trainable_variables))
## 그레이시언 디센트를 직접 수행하는 함수 정의

##
# 모델의 정확도를 출력하는 함수를 정의.
@tf.function
def compute_accuracy(y_pred, y):
    correct_prediction = tf.equal(tf.argmax(y_pred, 1), tf.argmax(y, 1))
    accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))
    return accuracy
## 학습이 끝났을 때 정확도를 출력하는 함수


# SoftmaxRegression 모델을 선언
SoftmaxRegression_model = SoftmaxRegression()


## 
# 1000번 반복을 수행하면서 최적화를 수행.
for i in range(1000):
    batch_xs, batch_ys = next(train_data_iter)
    train_step(SoftmaxRegression_model, batch_xs, batch_ys)
## 학습부


# 학습이 끝나면 학습된 모델의 정확도를 출력
accuracy = compute_accuracy(SoftmaxRegression_model(x_test), y_test)
print("정확도(Accuracy): %f" % accuracy)
# 정확도 약 91%

코드 부분을 한부분씩 잘라서 이해해보자.

데이터 전처리

# MNIST 데이터를 다운로드
(x_train, y_train), (x_test, y_test) = tf.keras.datasets.mnist.load_data()
# 이미지들을 float32 데이터 타입으로 변경
x_train, x_test = x_train.astype('float32'), x_test.astype('float32')
# 28*28 형태의 이미지를 784차원으로 flattening 한다.
x_train, x_test = x_train.reshape([-1, 784]), x_test.reshape([-1, 784])
# [0, 255] 사이의 값을 [0, 1] 사이의 값으로 Normalize한다.
x_train, x_test = x_train / 255., x_test / 255.
# 레이블 데이터에 one-hot encoding을 적용한다.
y_train, y_test = tf.one_hot(y_train, depth=10), tf.one_hot(y_test, depth=10)

https://inradestrt.tistory.com/664

위 MNIST데이터셋을 다운로드하여 사용한다.

데이터타입을 float32형식으로 변환한다.

• 이미지데이터는 기본적으로 uint8형식으로 되어있으나, 신경망 모델은 float32 타입의 데이터를 다루기 때문.

이미지 평탄화(Flattening)

• MNIST이미지는 28x28픽셀 크기의 2D배열 형태이다. 이 이미지를 1D형태로 변환하여 신경만의 입력으로 사용하기 위해 평탄화(flatten)한다.

정규화(Normalize)

• 이미지 픽셀값은 [0, 255](흑백) 값을 가지는데, 모델이 학습할 떄 더 빠르고 안정적으로 학습할 수 있도록 [0, 1] 사이로 정규화한다.

One-Hot 인코딩

• 레이블 데이터는 0에서 9까지의 정수값이다. 이를 신경망 출력과 비교하기 쉽게 One-hot인코딩을 통해 이진벡터로 변환하여 키값을 레이블 해준다.

데이터셋 준비

# tf.data API를 이용해서 데이터를 섞고 batch 형태로 가져온다.
train_data = tf.data.Dataset.from_tensor_slices((x_train, y_train))
train_data = train_data.repeat().shuffle(60000).batch(100)
train_data_iter = iter(train_data)

데이터셋 생성

• tf.data.Dataset.from_tensor_slices를 사용하여 x_train과 y_train 데이터를 TensorFlow데이터셋 으로 만든다.
  (API에 알맞게 데이터를 정리한다고 이해하면 된다)

반복 및 섞기(shuffle)

• 데이터셋을 무작위로 섞어서 학습의 편향을 줄이고, 무한 반복하여 학습할 수 있도록 설정한다.
  (학습의 제한사항을 최대한 여유롭게 풀어준다고 이해하면 된다.)

배치 처리(batch(100))

• 학습 속도를 높이고 메모리 효율성을 높이기 위해 데이터를 일정 크기의 배치로 나눈다. 여기서는 100개씩 묶는다.
  모델이 한번에 처리할 수 있는 적당한 크기의 데이터 덩어리를 만든다.
  
  한번에 모든 데이터를 학습하게 되면 너무 느리기 때문에, 부분부분씩 잘라서 학습한다고 생각하자.

이터레이터 생성

• 학습 중에 매번 새로운 배치를 가져오기 위해 이터레이터를 생성한다.
  학습때 필요한 배치를 한개씩 꺼내쓰기 위해 연결고리를 만들어놓는다고 이해하자.

모델 정의

class SoftmaxRegression(tf.keras.Model):
    def __init__(self):
        super(SoftmaxRegression, self).__init__()
        self.softmax_layer = tf.keras.layers.Dense(10,
                                                   activation=None,
                                                   kernel_initializer='zeros',
                                                   bias_initializer='zeros')
        
    def call(self, x):
        logits = self.softmax_layer(x)
        return tf.nn.softmax(logits)

모델 클래스 정의

• 사용자 정의 모델을 생성하기 위해 케라스의 서브클래싱 API를 이용한다.

Dense층 정의

• 10개의 뉴런을 가진 Dense(완전 연결) 층을 추가한다. 각 뉴런은 하나의 클래스(0-9)를 예측하게 된다.
  입력데이터에 대해 각 클래스에 대한 점수를 계산하는 층이다.

가중치와 바이어스 초기화

• 가중치와 바이어스를 0으로 초기화한다.
  초기값을 정의하여 학습을 통해 최적값을 찾는다.

출력 정의

• Dense층의 출력을 Softmax 함수에 통과시켜 클래스 확률을 계산한다.
  각 분포 확률을 얻어 예측할 수 있도록 한다.

손실 함수 정의

@tf.function
def cross_entropy_loss(y_pred, y):
    return tf.reduce_mean(-tf.reduce_sum(y * tf.math.log(y_pred), axis=[1]))

손실 함수 정의

• Cross-entropy 손실 함수는 예측값과 실제값 사이의 차이를 측정한다.
  모델의 예측이 실제값과 얼마나 다른지 평가하여 수정할 수 있도록 한다.

학습의 불일치 부분을 확인하고 모델의 성능을 향상시키기 위해 생성함.

옵티마이저 정의

optimizer = tf.optimizers.SGD(0.5)

옵티마이저 정의

• 경사 하강법(SGD) 옵티마이저는 손실을 줄이기 위해 모델의 가중치를 업데이트 한다.

학습률(0.5)

• 가중치를 업데이트 할 때의 스텝 크기를 결정한다.
  적절한 학습률을 통해 빠르고 안정적인 학습을 유도한다.

학습 단계 정의

@tf.function
def train_step(model, x, y):
    with tf.GradientTape() as tape:
        y_pred = model(x)
        loss = cross_entropy_loss(y_pred, y)
    gradients = tape.gradient(loss, model.trainable_variables)
    optimizer.apply_gradients(zip(gradients, model.trainable_variables))

학습 함수 정의

• train_step함수는 한 번의 학습 단계에서 모델을 업데이트 한다.
  모델을 학습시키기 위한 모든 작업을 하나의 함수에 모음

GradientTape(tape.gradient(...))

• 자동으로 미분을 계산하여 손실의 기울기를 추적한다.
  모델의 가중치를 업데이트하기 위함.

기울기 계산 및 적용(.apply_gradients(...))

• 손실의 기울기를 계산하고 옵티마이저로 모델 가중치를 업데이트

정확도 계산 함수 정의

@tf.function
def compute_accuracy(y_pred, y):
    correct_prediction = tf.equal(tf.argmax(y_pred, 1), tf.argmax(y, 1))
    accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))
    return accuracy

정확도 함수 정의

• compute_accuracy 함수는 모델 예측 정확도를 계산한다.
  
  API를 쓴다고 이해하자.

모델 학습

# SoftmaxRegression 모델을 선언
SoftmaxRegression_model = SoftmaxRegression()

# 1000번 반복을 수행하면서 최적화를 수행.
for i in range(1000):
    batch_xs, batch_ys = next(train_data_iter)
    train_step(SoftmaxRegression_model, batch_xs, batch_ys)

모델 인스턴스 생성

• SoftmaxRegression모델을 인스턴스화 하여 학습에 사용한다.
  모델을 준비

학습 반복

• 1000번 반복하면서 모델을 학습시킨다.
  충분한 반복을 통해 데이터를 학습하고 손실을 최소화하도록 한다.

배치 학습

• 매 반복마다 새로운 배치를 가져와서 train_step함수를 호출한다.
  데이터의 일부를 사용하여 모델을 학습시킴으로써 효율적인 학습을 수행한다.