초보 딥러닝 - DeepLearning과 학습

딥러닝의 학습 (training)

- 훈련 데이터를 통해 최적의 가중치를 자동으로 찾기 위한 방법

 : 손실함수의 값이 최소화 되는 가중치를 찾는 작업

 

- 관련 개념

 ㆍ손실함수 (loss function)

   : 신경망 성능의 나쁨 정도를 표현하는 지표

   : 목표로 하는 데이터와 딥러닝 모델이 놓은 결과 데이터와의 오차를 표현하는 함수

 

 ㆍ특징 (feature)

   : 이미지를 분류할때의 기준이 되는 데이터

 

 ㆍOnt-hot-encoding

   : 정답을 가리키는 데이터를 1로 표기하고 그 외에 모든 데이터를 0으로 나타내는 표기법

 

 ㆍGradient (기울기 / 미분)

   : 한 순간의 변화량

   : 학습할때 이를 기준으로 오차를 구하여 오차가 0이 되는 기울기 지점을 찾음

 

 

 

 

손실함수

- 오차제곱합

 : 추정값과 참값의 차를 제곱한 후 총합을 구하여 오차를 계산하는 방법

 

- 교차엔트로피오차

 : 정답일때의 출력 값을 기준으로 오차를 계산하는 방법

 

 

 

미니배치

- 수 많은 훈련데이터 중에 일부를 무작위로 선별하여 학습

 : 코드에서는 인덱스를 표기하는 배열에 랜덤으로 데이터를 선언하여 랜덤한 인덱스를 통해 데이터를 학습

 

 

 

미분 (순간의 변화량)

- 해석적 미분

 : 수식을 전개하는 보통의 미분

 

- 수치미분

 : 근사치를 통해 계산하는 미분 

 : 아주 작은 값으로 차분으로 미분

 : 가중치 매개변수의 기울기 도출

 

- 편미분

 : 변수가 여럿인 함수에 대한 미분

 

- 기울기

 : 모든 변수의 편미분을 벡터로 정리한 것

 

 

 

경사하강법

- 기울기(Gredient)를 이용하여 최적의 가중치를 찾는 방법

 : 기계학습의 최적화와 신경망 학습에 쓰이는 기법

 

 

 

MNIST 데이터셋을 이용한 손글씨 인식

- MNIST 데이터셋

 : 기계학습 분야에서 가장 유명한 데이터셋

 : 0부터 9까지의 28*28 사이즈의 숫자이미지로 구성 (255픽셀)

 : 훈련용 이미지 6만장 / 테스트용 이미지 1만장으로 구성

 

 

# softmax classification for Mnist Dataset
import tensorflow as tf

mnist = tf.keras.datasets.mnist
(x_train, y_train), (x_test, y_test) = mnist.load_data()    # MNIST 데이터 셋 로드
x_train, x_test = x_train/255.0, x_test / 255.0             # MNIST의 x_train과 x_test 데이터를 255픽셀의 이미지로 설정

x_train = x_train.reshape(60000,784).astype('float32')     # x_train을 (60000,784)모양의 실수 행렬로 변환
x_test = x_test.reshape(10000,784).astype('float32')       # x_test를 (10000,784)모양의 실수 행렬로 변환 

nb_classes=10           # 차원의 갯수 10

y_train_one_hot = tf.one_hot(y_train, nb_classes).numpy()  # y_train one_hot_encoding
y_test_one_hot = tf.one_hot(y_test, nb_classes).numpy()    # t_test one_hot_encoding

W=tf.Variable(tf.random.normal([784,nb_classes]), name='weight')  # 가중치 정의 (784,10)모양의 난수 행렬
B=tf.Variable(tf.random.normal([nb_classes]), name='bias')        # 편향 정의 10, 모양의 난수 행렬

@tf.function
def Hypothesis(X):                                            # 가설 정의
    logits=tf.add(tf.matmul(tf.cast(X,tf.float32),W),B)       # logit 정의 (softmax 입력에 쓰이기 위함)
    return tf.nn.softmax(logits)                              # softmax로 활성화 


@tf.function
def loss(H, Y):                                               # 비용 함수 정의
    entropy=-tf.reduce_sum(Y*tf.math.log(H), axis=1)          # 엔트로피 정의 (log 함수)
    cost = tf.reduce_mean(entropy)                            # 크로스엔트로피로 비용함수 정의
    return cost

@tf.function
def train(X,Y, learning_rate=0.1):          # 손실률이 최소화 되도록 훈련 (학습률은 0.1)
    with tf.GradientTape() as tape:         # 기울기 연산을 위한 손실값 기록
        _loss=loss(Hypothesis(X),Y)
    _w,_b=tape.gradient(_loss, [W,B])       # 손실 값을 통한 조정된 가중치 및 편향 정의
    W.assign_sub(learning_rate * _w)        # 조정된 가중치 반영
    B.assign_sub(learning_rate * _b)        # 조정된 편향 반영

@tf.function
def evaluation(H,Y):                                                  # 정확도 계산
    prediction=tf.argmax(H,1)                                         # 예측값 
    correct_prediction=tf.equal(prediction, tf.argmax(Y,1))           # 목적값
    accuracy=tf.reduce_mean(tf.cast(correct_prediction, tf.float32))  # 정확도
    return prediction, accuracy

training_epochs = 50       # epoch = 전체 데이터 셋을 학습시키는 횟수
batch_size = 100           # batch = 한번에 메모르에서 처리하는 데이터의 양

for epoch in range(training_epochs):         # epoch횟수만큼 모델을 훈련
    avg_cost=0
    iterations=int(len(x_train)/batch_size)
    idx=0
    for i in range(iterations):
        batch_xs, batch_ys = x_train[idx:idx+batch_size,:], y_train_one_hot[idx:idx+batch_size,:]
        _c=loss(Hypothesis(batch_xs), batch_ys)
        train(batch_xs, batch_ys, learning_rate=0.15)
        avg_cost += _c/iterations
        idx += batch_size
    print("epoch: {:2d} loss: {}".format(epoch+1, avg_cost))
    
# report accuracy
print("\nAccuracy...")
_h=Hypothesis(x_test)
_p,_a=evaluation(_h, y_test_one_hot)
print("\nAccuracy=",_a.numpy())