[딥러닝] 로지스틱 회귀: 참 거짓의 판단 장치

아래 내용은 '모두의 딥러닝' 책을 스터디 하여 정리한 내용입니다.

참 거짓 판단 장치: 로지스틱 회귀

참과 거짓 중에 하나를 내놓는 과정은 로지스틱 회귀의 원리를 거쳐 이루어진다.

참, 거짓을 구분하는 로지스틱 회귀의 원리를 이용해 '참, 거짓 미니 판단 장치'를 만들어 주어진 입력 값의 특징을 추출하고,

이를 저장해서 '모델'을 만든다.

그 후 누군가 비슷한 질문을 하면 지금까지 만들어 놓은 이 모델을 꺼내어 답을 한다.

이것이 바로 딥러닝의 동작 원리이다.

1. 로지스틱 회귀의 정의

좌표의 형태가 직선으로 해결되기에 적절하지 않은 경우도 있다.

예를 들어 공부한 시간에 따른 합격 여부가 있다고 해보자.

합격을 1, 불합격을 0이라고 했을 때 이는 일차 방정식을 만들 수 있을까?

점들의 특성을 정확하게 담아내려면 직선이 아니라 다음과 같이 S자 형태여야 한다.

이처럼 로지스틱 회귀는 선형 회귀와 마찬가지로

적절한 선을 그려가는 과정이다.

다만, 직선이 아니라 참(1)과 거짓(0) 사이를 구분하는 S자 형태의 선을 그어주는 작업이다.

2. 시그모이드 함수

이렇게 S자 형태로 그래프가 그려지는 함수가 시그모이드 함수이다.

우리가 구해야 하는 값은 결국 ax+b이다.

앞서 구한 직선 방정식과는 다르게 여기에서 a와 b는 어떤 의미를 가지고 있을까?

먼저 a는 그래프의 경사도를 결정한다.

a값이 커지면 경사가 커지고 a값이 작아지면 경사가 작아진다.

b는 그래프의 좌우이동을 의미한다.

b가 크면 오른쪽(+)으로, 작아지면 왼쪽(-)으로 이동한다.

따라서 a와 b의 값이 클수록 오차가 생긴다.

a가 작아질수록 오차는 무한대로 커지지만, a가 커진다고 해서 오차가 무한대로 커지지는 않는다.

b값은 너무 크거나 작을 경우 오차가 무한대로 커지므로 이차 함수 그래프로 표현할 수 있다.

3. 오차 공식

시그모이드 함수에서 a와 b의 값을 어떻게 구할까?

경사하강법으로 구할 수 있다.

경사 하강법은 먼저 오차를 구한 다음 오차가 작은 쪽으로 이동시키는 방법이었다.

그렇다면 이번에도 오차를 구하는 공식이 필요한데, 오차 공식을 도출하기 위해

시그모이드 함수 그래프의 특징을 살펴보면,

y값이 0과 1 사이라는 것이다.

따라서 실제 값이 1일 때 예측 값이 0에 가까워지면 오차가 커져야 한다.

반대로 실제 값이 0일 때 예측 값이 1에 가까워지는 경우에도 오차가 커진다.

이를 공식으로 만들 수 있게 해 주는 함수가 바로 로그 함수이다.

4. 로그 함수

공식을 보면 실제 값 y가 1이면 B부분이 없어지고 0이면 A부분이 없어진다.

따라서 y값에 따라 각 그래프를 사용하게 된다.

5. 코딩으로 확인하기(로지스틱 회귀)

import tensorflow as tf
import numpy as np
 
# x,y의 데이터 값
data = [[2, 0], [4, 0], [6, 0], [8, 1], [10, 1], [12, 1], [14, 1]]
x_data = [x_row[0] for x_row in data]
y_data = [y_row[1] for y_row in data]
 
# a와 b의 값을 임의로 정한다.
a = tf.Variable(tf.random_normal([1], dtype=tf.float64, seed=0))
b = tf.Variable(tf.random_normal([1], dtype=tf.float64, seed=1))
 
# y 시그모이드 함수의 방정식을 세운다.
y = 1/(1 + np.e**(-a*x_data + b))
 
# loss를 구하는 함수
loss = -tf.reduce_mean(np.array(y_data) * tf.log(y) + (1-np.array(y_data))* tf.log(1-y))
 
# 학습률 값
learning_rate = 0.5
 
# loss를 최소로 하는 값 찾기
gradient_decent = tf.train.GradientDescentOptimizer(learning_rate).minimize(loss)
 
# 학습
with tf.Session() as sess:
    sess.run(tf.global_variables_initializer())
 
    for i in range(60001):
        sess.run(gradient_decent)
        if i % 6000 ==0:
            print("Epoch: %.f, loss = %.4f, 기울기 a = %.4f, y절편 =%.4f" % (i, sess.run(loss), sess.run(a), sess.run(b)))

오차(loss)값이 점점 줄어들고 a와 b의 최적값을 찾아가는 것을 볼 수 있다.

6. 여러 입력 값을 갖는 로지스틱 회귀

선형 회귀때와 마찬가지로 변수가 많아지면 더 정확하게 예측을 할 수 있다.

변수가 x에서 x1, x2로 추가되면 각각의 기울기 a1, a2도 계산해야 한다.

즉 ax부분이 a1x1 + a2x2로 바뀐다. 이는 행렬곱을 이용해 [a1, a2] * [x1, x2] 로도 표현할 수 있다.

텐서플로에서는 matmul() 함수를 이용해 행렬곱을 적용할 수 있다.

import tensorflow as tf
import numpy as np
 
# 실행할 때마다 같은 결과를 출력하기 위한 seed값 설정
seed = 0
np.random.seed(seed)
tf.set_random_seed(seed)
 
# x,y의 데이터 값
x_data = np.array([[2, 3], [4, 3], [6, 4], [8, 6], [10, 7], [12, 8], [14, 9]])
y_data = np.array([0, 0, 0, 1, 1, 1, 1]).reshape(7, 1)
 
# 입력 값을 플레이스 홀더에 저장 (플레이스홀더는 입력 값을 저장하는 일종의 그릇이다)
X = tf.placeholder(tf.float64, shape=[None, 2])
Y = tf.placeholder(tf.float64, shape=[None, 1])
 
# a와 b의 값을 임의로 정한다.
a = tf.Variable(tf.random_uniform([2, 1], dtype=tf.float64)) # [2,1] 의미 : 들어오는 값은 2개, 나가는 값은 1개
b = tf.Variable(tf.random_uniform([1], dtype=tf.float64))
 
# y 시그모이드 함수의 방정식을 세운다.
# 변수가 x에서 x1, x2로 추가되면 각각의 기울기 a1, a2도 계산해야 한다.
# 즉 ax부분이 a1x1 + a2x2로 바뀐다. 이는 행렬곱을 이용해 [a1, a2] * [x1, x2] 로도 표현할 수 있다.
# 텐서플로에서는 matmul() 함수를 이용해 행렬곱을 적용할 수 있다.
y = tf.sigmoid(tf.matmul(X, a) + b)
 
# loss를 구하는 함수
loss = -tf.reduce_mean(Y * tf.log(y) + (1-Y) * tf.log(1-y))
 
# 학습률 값
learning_rate = 0.1
 
# loss를 최소로 하는 값 찾기
gradient_decent = tf.train.GradientDescentOptimizer(learning_rate).minimize(loss)
 
predicted = tf.cast(y > 0.5, dtype=tf.float64)
accuracy = tf.reduce_mean(tf.cast(tf.equal(predicted, Y), dtype=tf.float64))
 
# 학습
with tf.Session() as sess:
    sess.run(tf.global_variables_initializer())
 
    for i in range(3001):
        a_, b_, loss_, _ = sess.run([a, b, loss, gradient_decent], feed_dict={X: x_data, Y: y_data})
        if (i+1) % 300 == 0:
            print("step=%d, a1=%.4f, a2=%.4f, b=%4f, loss=%.4f" % (i+1, a_[0], a_[1], b_, loss_))
 
    # 실제 값 적용하기
    new_x = np.array([7, 6.]).reshape(1, 2) # 7, 6은 각각 공부한 시간과 과외 수업 수
    new_y = sess.run(y, feed_dict={X: new_x})
 
    print("공부한 시간 : %d, 과외 수업 횟수: %d" % (new_x[:,0], new_x[:,1]))
    print("합격 가능성: %6.2f %%" % (new_y*100))

오차 값이 점차 줄어들고 a1, a2, b가 각각 최적값을 찾아가는 것을 알 수 있다.

7. 실제 값 적용하기

공부한 시간과 과외 수업 횟수에 대한 예측 값을 구해보자.

예를들어 7시간 공부하고 과외를 6번 받은 학생의 합격 가능성을 계산해 보겠다고 하자.

    # 실제 값 적용하기

    new_x = np.array([7, 6.]).reshape(1, 2) # 7, 6은 각각 공부한 시간과 과외 수업 수

    new_y = sess.run(y, feed_dict={X: new_x})

    print("공부한 시간 : %d, 과외 수업 횟수: %d" % (new_x[:,0], new_x[:,1]))

    print("합격 가능성: %6.2f %%" % (new_y*100))

[실제 결과]

공부한 시간 : 7, 과외 수업 횟수: 6

합격 가능성:  85.66 %

8. 로지스틱 회귀에서 퍼셉트론으로

입력 값을 통해 출력 값을 구하는 함수 y는 다음과 같이 표현할 수 있었다.

y = a1x1 + a2x2 + b

우리가 가진 값은 x1, x2이고 이를 입력값이라고 한다.

그리고 계산으로 얻는 값 y를 출력 값이라고 한다.

즉 출력 값 y를 구하려면 a값과 b 값이 필요하다.

x1과 x2가 입력되고, 각각 가중치 a1, a2를 만난다. 여기에 b 값을 더한 후 시그모이드 함수를 거쳐 1 또는 0의 출력 값 y를 출력한다.

1957년, 코넬 항공 연구소의 프랑크 로젠블라트라는 사람이 이 개념을 고안해 발표하고 여기에 '퍼셉트론'이라는 이름을 붙였다.

이 퍼셉트론은 그 후 여러 학자들의 노력을 통해 인공신경망, 오차 역전파 등의 발전을 거쳐 지금의 딥러닝으로 이어지게 된다.