12 분 소요

1. 딥러닝이란?

1) 머신러닝과 딥러닝의 차이

image

  • 📌출처 : kt 엔터프라이즈

  • Deeplearning은 Machinelearning의 일종
  • 인간의 두뇌, 즉 신경망에 영감을 얻은 학습 방식


2) 단층 퍼셉트론(Single-layer Perceptron) : 하나의 신경망

그림1.jpg

$$ y = \begin{cases} 0 & (w_1 x_1 + w_2 x_2 \le \theta) \\ 1 & (w_1 x_1 + w_2 x_2 > \theta) \end{cases} $$
  • 다수의 신호를 입력 받아 하나의 신호로 출력(임계 값θ을 기준으로 출력 여부 결정)
    • 신호 x가 가중치 w를 만나 y의 출력을 결정하는 구조


✨ 단층 퍼셉트론의 한계 : 선형성(XOR게이트 구현 불가)

  • AND게이트
x1 x2 y
0 0 0
1 0 0
0 1 0
1 1 1
  • NAND게이트
x1 x2 y
0 0 1
1 0 1
0 1 1
1 1 0 
x1 = list(range(-1, 3))
x2 = list(map(lambda x:-x + 1.5, x1))

import matplotlib.pyplot as plt
plt.axhline(0, color='black',linewidth=1)
plt.axvline(0, color='black',linewidth=1)
plt.plot(x1, x2)
plt.scatter(0, 0, color='red', marker="o", label="(0,0)")
plt.scatter(1, 0, color='green', marker="o", label="(1,0)")
plt.scatter(0, 1, color='black', marker="o", label="(0,1)")
plt.scatter(1, 1, color='blue', marker="o", label="(1,1)")
plt.legend()
plt.xlabel("X1")
plt.ylabel("X2")
plt.fill([max(x1),max(x1), min(x1)],[2.5,-0.5,2.5],alpha=0.3) # AND 게이트
plt.fill([min(x1),min(x1), max(x1)],[-0.5,2.5,-0.5],alpha=0.1) # NAND 게이트

[<matplotlib.patches.Polygon at 0x2499d02b350>]


  • OR게이트
x1 x2 y
0 0 0
1 0 1
0 1 1
1 1 1 
x1 = list(range(-1, 3))
x2 = list(map(lambda x:-x + 0.5, x1))

import matplotlib.pyplot as plt
plt.axhline(0, color='black',linewidth=1)
plt.axvline(0, color='black',linewidth=1)
plt.plot(x1, x2)
plt.scatter(0, 0, color='red', marker="o", label="(0,0)")
plt.scatter(1, 0, color='green', marker="o", label="(1,0)")
plt.scatter(0, 1, color='black', marker="o", label="(0,1)")
plt.scatter(1, 1, color='blue', marker="o", label="(1,1)")
plt.legend()
plt.xlabel("X1")
plt.ylabel("X2")
plt.fill([min(x1),min(x1), max(x1)],[-1.5,1.5,-1.5],alpha=0.1) # OR 게이트

[<matplotlib.patches.Polygon at 0x2499e2ea950>]


  • XOR 게이트(✨ 구현 불가)
x1 x2 y
0 0 0
1 0 1
0 1 1
1 1 0 
x1 = list(range(-1, 3))
x2 = list(map(lambda x:-x + 1, x1))

import matplotlib.pyplot as plt
plt.axhline(0, color='black',linewidth=1)
plt.axvline(0, color='black',linewidth=1)
plt.plot(x1, x2)
plt.scatter(0, 0, color='red', marker="x", label="0")
plt.scatter(1, 0, color='blue', marker="o", label="1")
plt.scatter(0, 1, color='blue', marker="o")
plt.scatter(1, 1, color='red', marker="x")
plt.legend()
plt.xlabel("X1")
plt.ylabel("X2")
plt.fill([min(x1),min(x1), max(x1)],[-1.0,2,-1],alpha=0.1) # XOR 게이트

[<matplotlib.patches.Polygon at 0x249a396ec90>]


3) 다층 퍼셉트론(Multi-layer Perceptron) : 여러 개의 신경망

image

  • 현재 딥러닝의 기본적인 구조
  • 입력층과 출력층 사이에 다수의 은닉층, 가중치들이 존재(비선형성 갖춤)

image


2. 딥러닝의 학습 방법

1) 활성화 함수(Activation Function)

  • 임계값θ 대신 활용하여 비선형성을 확보한 방법

image

  • 📌출처 : 위키피디아


(1) 활성화 함수(Activation Function)의 종류

image


  • 계단(step) 함수(0, 1 : 이진분류)
    • 단점 : 미분 불가능 → 경사하강법 이용 불가(사실상 거의 이용하지 않음)
$$ y = \begin{cases} 0 & (x < 0) \\ 1 & (x > 0) \end{cases} $$ 
import numpy as np
import matplotlib.pylab  as plt

## 함수 구현
def step_function(x):
    return np.array(x>0, dtype=int)

## 그래프
x = np.arange(-5.0, 5.0, 0.1)
y = step_function(x)
plt.plot(x, y)
plt.show()


  • 시그모이드(Sigmoid) 함수(0~1 : T/F확률)
    • 계단함수를 미분 가능하도록 개선한 방식, 주로 이진 분류 출력층에 사용.
    • 단점 : 기울기 소실 → 입력값이 매우 크거나 작으면 기울기가 0에 가까워져 (경사하강법을 이용한) 학습 속도가 느려짐
$$ sigmoid(x) = \frac{1}{1 + e^{-x}} $$
import numpy as np
import matplotlib.pylab  as plt

## 함수 구현
def sigmoid(x):
    return 1 / (1 + np.exp(-x))

## 그래프
x = np.arange(-5.0, 5.0, 0.1)
y = sigmoid(x)
plt.plot(x,y)
plt.show()



## 도함수 그래프
x = np.arange(-5.0, 5.0, 0.1)
y = sigmoid(x)*(1-sigmoid(x))
plt.plot(x,y)
plt.ylim(-0.1, 1.1)
plt.show()


  • 하이퍼볼릭 탄젠트(Tanh) 함수(-1~1)
    • 시그모이드 함수의 출력값 표현력을 개선한 모델
    • 단점 : 기울기 소실 → 입력값이 매우 크거나 작으면 기울기가 0에 가까워짐(단, sigmoid보단 개선됨)
$$ tanh(x) = \frac{e^{x}-e^{-x}}{e^{x}+e^{-x}}$$
import numpy as np
import matplotlib.pylab  as plt

## 함수 구현
def tanh(x):
    return (np.exp(x) - np.exp(-x)) / (np.exp(x) + np.exp(-x))

## 그래프
x = np.arange(-5.0, 5.0, 0.1)
y = tanh(x)
plt.plot(x,y)
plt.show()



## 도함수 그래프
x = np.arange(-5.0, 5.0, 0.1)
y = (1 - tanh(x))*(1 + tanh(x))
plt.plot(x,y)
plt.ylim(-0.1, 1.1)
plt.show()


  • 렐루(ReLu) 함수(0, x : 양수면 자기 값)
    • 기울기 소실 문제 개선(단, 음수 입력값에 대한 정보 손실), 주로 은닉층에 사용.
    • 단점 : 음수에 대한 기울기 소실 → 0보다 작은 수에 대해 기울기 0
$$f(x) = max(0, x)$$ 
import numpy as np
import matplotlib.pylab  as plt

## 함수 구현
def relu(x):
    return np.maximum(0,x)

## 그래프 그리기
x = np.arange(-5.0, 5, 1)
y = relu(x)
plt.plot(x,y)

[<matplotlib.lines.Line2D at 0x249a4d20950>]


  • 리키 렐루(Leaky ReLu) 함수
    • ReLu함수의 음수 입력값에 대한 정보 손실 개선
$$f(x) = max(0.01x, x)$$ 
import numpy as np
import matplotlib.pylab  as plt

## 함수 구현
def relu(x):
    return np.maximum(0.01*x,x)

## 그래프 그리기
x = np.arange(-5.0, 5, 0.01)
y = relu(x)
plt.plot(x,y)

[<matplotlib.lines.Line2D at 0x249a50febd0>]


  • 소프트맥스(softmax) 함수(0~1 : 클래스별 확률)
    • 전체 합산이 1, 주로 다중 클래스 출력층에 사용.
    • 단점
      • 기울기 폭발 → 입력 값이 클수록 급격하게 기울기 상승
      • 기울기 소실 → 입력 값이 작을 수록 기울기 소실
$$softmax(x_i) = \frac{e^{x_i}}{\sum_{j=1}^{n} e^{x_j}}$$
def softmax(x):
    exp_x = np.exp(x)
    sum_exp_x = np.sum(exp_x)
    y = exp_x / sum_exp_x
    return y

## 그래프 그리기
x = np.arange(-5.0, 5, 0.1)
y = softmax(x)
plt.plot(x,y)

[<matplotlib.lines.Line2D at 0x249a5168b50>]


2) 순전파(Feedfoward)와 역전파(Backpropagation)

  • 순전파 정의 : 입력층에서 출력층 방향으로 이동하면서 은닉층에서 가중치w가 곱해져 최종 결과가 출력되는 과정
    • ✨ 가중치w는 첫 순전파때 랜덤하게 배정된 뒤 여러 차례의 역전파-순전파를 통해 조정된다.
  • 역전파 정의 : 출력층 값을 활용하여 가중치w를 조정하는 과정
    • ✨ 출력값과 실제값을 활용하여 손실함수(Loss Function)을 정의하고, 경사하강법(미분 값을 활용)을 통해 가중치 w를 조정

image


(1) 손실함수(Loss Function) : 역전파(Backpropagation)의 기준

  • ✨어째서 정확도(accuracy)를 기준으로 쓰지 않는 걸까?
    • 기울기 계산의 어려움 : 크게 변동될 수 있거나, 변동하지 않을 수 있기 때문


  • MSE(Mean Squared Error)
    • 예측한 값과 실제 값 사이의 평균 제곱 오차(회귀분석)
$$ MSE = \frac{1}{N}\sum^{N}_{i=1}{(y_{i}-\hat{y_{i}})^{2}} $$

y : 실제값
$\hat{y}$ : 예측값
N : 데이터수


  • RMSE(Root Mean Squared Error)
    • MSE 오류의 제곱을 구하기 때문에 값 왜곡을 줄이기 위해 루트를 씌운 값(회귀분석)
$$ RMSE = \sqrt{\frac{1}{N}\sum^{N}_{i=1}{(y_{i}-\hat{y_{i}})^{2}}} $$

y : 실제값
$\hat{y}$ : 예측값
N : 데이터수


  • Binary Crossentropy
    • 실제 레이블과 예측 레이블 간의 교차 엔트로피 손실을 계산(이진 분류)
$$ BCE = \frac{1}{N} \sum^{N}_{i=1}{-(y_{i}*log(p_{i})+(1-y_{i})*log(1-p_{i}))} $$

$y_{i}$ : 실제값
$p_{i}$ : 예측한 확률
N : 데이터수


  • Categorical Crossentropy
    • 실제 레이블과 예측 레이블 간의 교차 엔트로피 손실을 계산(다중 클래스 분류 + 원핫 인코딩)
$$ L = -\frac{1}{N} \sum^{N}_{j=1} \sum^{C}_{i=1} y_{ij}*log(p_{ij}) $$

$y_{ij}$ : 실제값
$p_{ij}$ : 예측한 확률
N : 데이터수
C : 클래스수


  • Sparse Categorical Crossentropy
    • 실제 레이블과 예측 레이블 간의 교차 엔트로피 손실을 계산(다중 클래스 분류 + 라벨 인코딩)


  • 원핫 인코딩 vs 라벨 인코딩

image


(2) 옵티마이저(Optimizer) : 역전파(Backpropagation) 시 가중치 조정 방법

  • 정의 : 손실함수(Loss function)의 가중치w에 대한 미분값을 활용하여 최소값을 찾아가는 방법

image


  • 발전방향

image


  • GD(경사 하강법)
    • 전체 데이터에 대해 가중치 조절
    • 단점 : 리소스 사용 과다
  • SGD(확률적 경사 하강법)
    • 랜덤하게 추출한 일부 데이터에 대해 가중치 조절
    • 장점 : 빠르다.
    • 단점 : 전역적 극소점(Global minima)을 못찾을 수 있다.
$$W_{t+1} = W_{t} - \alpha \frac{\partial L}{\partial W_{t}} $$

t : 시점
α : 학습률
W : 가중치
L : 손실함수

image


  • Momentum
    • SGD + 모멘텀(이전의 학습결과 반영)
    • 장점 : SGD보다 빠르다, 국지적 극소점(Local minima)에 빠지는 것을 피할 수 있다.
    • 단점 : 전역적 극소점(Global minima)에서 발산할 수 있다.
$$ v_{t} ← \alpha v_{t-1} - \eta \frac{\partial L}{\partial W_{t}} $$
$$W_{t+1} ← W_{t} + v_{t} $$

t : 시점
v : 관성계수
α : 관성계수 감쇠율 $\approx$ 0.9
η : 학습률
W : 가중치
L : 손실함수


  • AdaGrad
    • SGD + 학습률 감소(과거의 기울기 제곱)
    • 장점 : 안정적인 학습 가능하도록 함
    • 단점 : 학습이 길어지면 학습률이 0에 도달(국지적 극소점(Local minima)에 그칠 수 있다)
$$ h_{t} ← h_{t-1} + \frac{\partial L}{\partial W_{t}} ⊙ \frac{\partial L}{\partial W_{t}}$$
$$W_{t+1} ← W_{t} - \eta \frac{1}{\sqrt{h}_{t}} \frac{\partial L}{\partial W_{t}}$$

t : 시점
h : 학습률 조정 값
⊙ : 행렬의 원소별 곱셈
η : 학습률
W : 가중치
L : 손실함수


  • RMSProp
    • SGD + 학습률 감소(과거의 기울기 지수이동평균)
    • 한계 : AdaGrad의 단점의 완전히 해소하지 못함
$$ h_{t} ← ph_{t-1} + (1-p)\frac{\partial L}{\partial W_{t}} ⊙ \frac{\partial L}{\partial W_{t}}$$
$$W_{t+1} ← W_{t} - \eta \frac{1}{\sqrt{h_{t}}} \frac{\partial L}{\partial W_{t}}$$

t : 시점
p : 지수이동평균(0~1)
h : 학습률 조정 값
⊙ : 행렬의 원소별 곱셈
η : 학습률
W : 가중치
L : 손실함수


  • Adam✨✨
    • Momentum, RMSProp 융합한 기법(✨✨관성과 학습률 조정을 동시에 하는 기법)
    • ✨현 최고의 Optimizer
$$ m_{t} = \beta_{1}m_{t-1}+(1-\beta_{1})\frac{\delta L}{\delta W_{t}} $$
$$ v_{t} = \beta_{2}v_{t-1}+(1-\beta_{2}) \frac{\delta L}{\delta W_{t}} ⊙ \frac{\delta L}{\delta W_{t}}$$
$$ \hat{m_{t}} = \frac{m_{t}}{1-\beta^{t}_{1}}\quad \hat{v_{t}} = \frac{v_{t}}{1-\beta^{t}_{2}} $$
$$ W_{t+1} = W_{t} - \eta \frac{\hat{m_{t}}}{\sqrt{\hat{v_{t}}+\epsilon}} $$

t : 시점
m : 관성계수
$\beta_{1}$ : 관성계수의 지수이동평균 $\approx$ 0.9
$ \hat{m} $ : 관성계수의 가중평균식
v : 학습률 조정 값
$\beta_{2}$ : 학습률 조정 값의 지수이동평균 $\approx$ 0.999
$ \hat{v} $ : 학습률 조정 값의 가중평균식
⊙ : 행렬의 원소별 곱셈
η : 학습률
W : 가중치
L : 손실함수


  • 성능비교✨✨

image

image


  • 극소점을 찾는 모습 코드 구현(Adam)
import matplotlib.pyplot as plt
import numpy as np
from matplotlib.animation import FuncAnimation
import matplotlib.animation as animation

fig =plt.figure()
ax = plt.axes(xlim=(-10,10))
start_x = -8
learning_rate=1.3

## loss_function
def loss_function(x) :
    return (1/200)*(x-9)*(x)*(x+1)*(x+6) + 4

## loss_function's gradient
def loss_gradient(x) :
    return (1/100)*(2*np.power(x, 3)-3*np.power(x, 2)-57*x-27)

xrange = np.arange(-10,10,0.1)
loss_array = []

for x in xrange :
    loss = loss_function(x)
    loss_array.append(loss)
    
ax.plot(xrange, loss_array)
ax.set_xlabel('x')
ax.set_ylabel('loss')

train_x = []
beta1 = 0.9
beta2 = 0.999
v = 0
s = 0

for i in range(100) :
    if i == 0 :
        pass
    else:
        ## Adam Optimizer
        dL_dx = loss_gradient(start_x)
        v = beta1*v + (1-beta1)*dL_dx
        s = beta2*s + (1-beta2)*dL_dx**2
        v_avg = v/(1-np.power(beta1, i))
        s_avg = s/(1-np.power(beta2, i))
        start_x = start_x - learning_rate*(1/(np.sqrt(s_avg)+1e-10))*v_avg
    train_x.append(start_x)
    
redDot, = ax.plot([], [], 'ro')

def animate(frame) :
    loss = loss_function(frame)
    redDot.set_data(frame, loss)
    return redDot

ani = FuncAnimation(fig, animate, frames=train_x)
FFwriter = animation.FFMpegWriter(fps=5)
ani.save('adam.gif')

adam.gif

  • 📌출처 : https://toyourlight.tistory.com/33(https://toyourlight.tistory.com/33)


  • ✨ 안장점 이슈
    • 안장점이란? “극대점”이자 “극소점”이 되는 구간 즉, 최소값이 아니지만 미분값이 0이 되는 지점

    image

3. 딥러닝 코드 구현

1) 딥러닝 학습과정 정리✨✨

  1. 다층 퍼셉트론을 구성하고, 실제 신경망의 임계값 대신 다양한 활성화 함수를 구성하여 비선형성을 갖춘다.
  2. 순전파의 과정을 통해 랜덤하게 배정된 각 가중치와 곱하여 예측값을 도출한다.
  3. 손실함수를 정의하여 실제값과 예측값의 차이를 규정한다.
  4. 역전파의 과정을 통해 각 가중치를 손실함수에 의거 각종 옵티마이저를 통해 전역적 극소점을 가지는 가중치로 업데이트 한다.

2) 코드구현 : tensorflow✨✨

  • 데이터셋 불러오기
    • tensorflow 제공 데이터 : 보스턴 집값
import tensorflow as tf

(x_train, y_train), (x_test, y_test) = tf.keras.datasets.boston_housing.load_data()
x_train.shape, y_train.shape, x_test.shape, y_test.shape

Downloading data from https://storage.googleapis.com/tensorflow/tf-keras-datasets/boston_housing.npz
57026/57026 [==============================] - 0s 0us/step

((404, 13), (404,), (102, 13), (102,))


  • 신경망 구성하기
import tensorflow as tf

model = tf.keras.Sequential()
model.add(tf.keras.Input(shape=(13,))) # 입력층
model.add(tf.keras.layers.Dense(8, activation='relu')) # 노드 8개 은닉층, 활성화함수 : relu
model.add(tf.keras.layers.Dense(4, activation='relu')) # 노드 4개 은닉층, 활성화함수 : relu
model.add(tf.keras.layers.Dense(1, activation='relu')) # 출력층, 활성화함수 : relu
model.summary()

Model: "sequential_7"
_________________________________________________________________
 Layer (type)                Output Shape              Param #   
=================================================================
 dense_9 (Dense)             (None, 8)                 112       
                                                                 
 dense_10 (Dense)            (None, 4)                 36        
                                                                 
 dense_11 (Dense)            (None, 1)                 5         
                                                                 
=================================================================
Total params: 153 (612.00 Byte)
Trainable params: 153 (612.00 Byte)
Non-trainable params: 0 (0.00 Byte)
_________________________________________________________________


  • Param : 각 레이어별 가중치 개수(bias(편향 미제거 기준)

    • (인풋(13) + 1) * 노드 개수(8) = 112

    • (이전 노드 개수(8) + 1) * 노드 개수(4) = 36

    • (이전 노드 개수(4) + 1) * 노드 개수(1) = 5


  • 컴파일 : 옵티마이저 설정, 손실함수 정의, metrics(평가요소) 설정
optimizer = tf.keras.optimizers.Adam(learning_rate=1e-3) ## 옵티마이저 : 아담, 학습률(1e-3)
lossfunction = 'mse' ## 손실함수 : Mean squared error
model.compile(optimizer=optimizer, loss=lossfunction, metrics=['mae', 'mse']) ## 옵티마이저, 손실함수 대입, 평가요소 설정(mae, mse)


  • 모델학습
history = model.fit(x_train, y_train, epochs=20) ## history 객체에 모델 학습결과 담기 / 학습횟수(epochs) 20회

Epoch 1/20
13/13 [==============================] - 0s 3ms/step - loss: 1093.3164 - mae: 18.4993 - mse: 1093.3164
Epoch 2/20
13/13 [==============================] - 0s 2ms/step - loss: 969.5359 - mae: 17.1256 - mse: 969.5359
Epoch 3/20
13/13 [==============================] - 0s 2ms/step - loss: 871.4448 - mae: 16.0362 - mse: 871.4448
Epoch 4/20
13/13 [==============================] - 0s 2ms/step - loss: 789.7881 - mae: 15.1139 - mse: 789.7881
Epoch 5/20
13/13 [==============================] - 0s 2ms/step - loss: 714.2711 - mae: 14.4676 - mse: 714.2711
Epoch 6/20
13/13 [==============================] - 0s 2ms/step - loss: 648.0341 - mae: 13.8079 - mse: 648.0341
Epoch 7/20
13/13 [==============================] - 0s 2ms/step - loss: 586.7796 - mae: 13.2222 - mse: 586.7796
Epoch 8/20
13/13 [==============================] - 0s 2ms/step - loss: 534.5012 - mae: 12.8259 - mse: 534.5012
Epoch 9/20
13/13 [==============================] - 0s 2ms/step - loss: 489.7008 - mae: 12.3977 - mse: 489.7008
Epoch 10/20
13/13 [==============================] - 0s 2ms/step - loss: 447.6282 - mae: 11.9009 - mse: 447.6282
Epoch 11/20
13/13 [==============================] - 0s 2ms/step - loss: 411.8113 - mae: 11.5876 - mse: 411.8113
Epoch 12/20
13/13 [==============================] - 0s 2ms/step - loss: 379.8321 - mae: 11.3213 - mse: 379.8321
Epoch 13/20
13/13 [==============================] - 0s 2ms/step - loss: 346.5337 - mae: 10.9670 - mse: 346.5337
Epoch 14/20
13/13 [==============================] - 0s 2ms/step - loss: 317.8628 - mae: 10.5855 - mse: 317.8628
Epoch 15/20
13/13 [==============================] - 0s 3ms/step - loss: 291.1151 - mae: 10.2904 - mse: 291.1151
Epoch 16/20
13/13 [==============================] - 0s 3ms/step - loss: 269.0137 - mae: 10.1115 - mse: 269.0137
Epoch 17/20
13/13 [==============================] - 0s 3ms/step - loss: 247.3324 - mae: 9.8335 - mse: 247.3324
Epoch 18/20
13/13 [==============================] - 0s 2ms/step - loss: 229.4131 - mae: 9.5082 - mse: 229.4131
Epoch 19/20
13/13 [==============================] - 0s 2ms/step - loss: 211.4243 - mae: 9.2610 - mse: 211.4243
Epoch 20/20
13/13 [==============================] - 0s 2ms/step - loss: 196.5922 - mae: 9.0761 - mse: 196.5922


  • MAE : Mean absolute error, MSE : Mean Squared error로 학습 결과 확인하기(로스함수 감소 확인)
plt.figure(figsize=(15,4))

plt.subplot(1,2,1)
plt.plot(history.history['mae'])
plt.title('Mean absolute error')
plt.ylabel('mae')
plt.xlabel('epochs')

plt.subplot(1,2,2)
plt.plot(history.history['mse'])
plt.title('Mean squared error')
plt.ylabel('mse')
plt.xlabel('epochs')
plt.show()


  • 실제값과 예측값 시각화 해보기
## x_test데이터로 예측값(y_pred) 도출
y_pred = model.predict(x_test)

## 예측값(y_pred)과 실제값(y_test) 비교
plt.title("predict vs target")
plt.scatter(np.arange(y_pred.shape[0]), y_pred, marker='x', label="model_predict")
plt.scatter(np.arange(y_test.shape[0]), y_test, marker='o', label="target")
plt.legend()
plt.show()

4/4 [==============================] - 0s 2ms/step

  • 비슷한 영역(0~60정도)에서 형성되는 것을 볼 수 있다.


  • 사전에 설정한 metrics로 모델 평가

    • MAE로 봤을 때, 약 8정도의 오차가 있는 것을 알 수 있다.
model.evaluate(x_test, y_test)

4/4 [==============================] - 0s 3ms/step - loss: 145.4071 - mae: 7.9725 - mse: 145.4071

[145.40708923339844, 7.972545146942139, 145.40708923339844]


3) 모델 평가 : 과소적합(Underfitting), 과적합(Overfitting)

image


  • 과소적합 : (훈련 데이터에 대해서도) 설명력이 없는 모델
  • 과적합 : (훈련 데이터에 대해) 과하게 설명력이 있는 모델 → 일반화하기 힘든 모델
    • 이를 평가하고자 train data, test data를 구분해 평가한다.
    • epochs가 너무 적으면 과소적합, 너무 많으면 과적합 문제를 일으킨다.(모델에 따라 달라, 다수의 실험과 검증이 필요)
    • 과적합을 막기위해 일부 노드를 랜덤하게 삭제하는 Dropout을 사용하기도 한다.
    • 일반적으로 전체 데이터 셋의 하위 집합을 만들어 배치의 형태로 학습한다.
      1. 과적합 방지
      2. 메모리 사용 감소 → 학습 속도 향상
      3. 수렴 안정성 향상
    • 학습률, epochs과 같은 하이퍼 파라미터 조율을 위해서 추가적으로 validation data를 생성하기도 한다.


4. 정리 및 발전

  • 손실함수(Loss Function)은 모델에 따라 무엇을 정의해야할 지 다르다. 필요할 때 얼마든 지 자의적으로 조작 가능한 부분으로 보인다.
    • 분류모델 : Cross entrophy 등
    • 회귀모델 : MSE, MAE 등

  • 반면 옵티마이저(Optimizer)는 Adam이 가장 선호되나, SGD로도 극소점에 도달할 수 있다. 항상 안장점에 도달한 것이 아닐 지 주의가 필요하다.

  • 딥러닝의 기본적인 구조를 정리하였기에 다음엔 CNN, RNN, LSTM 등의 CV, NLP의 영역 뿐만 아니라 콜백(callback) 함수, 가중치 초기화, 배치 정규화, L1/L2규제, 전이 학습, KeraTuner, W&B 등 모델 학습 시 필요한 여러 도구들을 따로 정리해보고자 한다.

댓글남기기

참고

레디스) 레디스 세팅 및 기본 사용법

4 분 소요

0. redis 공부 이유 오픈 소스를 활용해, 자체 프로그램을 개발하기 위해 공부하게 되었다. kafka와 마찬가지로 짬이 난 김에 정리해두려 한다.

카프카) 카프카 세팅 및 기본 사용법

4 분 소요

0. kafka 공부 이유 회사에서 초당 6만 건 이상 메시징을 처리해야 하다보니, 파이썬 멀티스레딩, redis, kafka 등에 익숙해져야 했다.

Docker 활용기2) - 원격 GPU 개발 환경 구축

4 분 소요

1. Why 제게는 노트북이 2개가 있는데, RTX 3050 TI가 달린 것과 1kg 이하 매우 가벼운 것을 가지고 있습니다. 집에서 집중이 안될 때마다 가벼운 노트북을 카페로 들고가 작업을 하곤 했습니다. 그러나 GPU가 더러 필요한 순간이 있을 때마다 무거운 노트북을 들고...