공부/AI

Linear Regression 공부했다

Swimming_Kim 2018. 12. 14. 01:02
Alina라는 회사에서 제공하는 AI 강의들을 듣고 있다. 양도 많지 않고, 파이썬 코드도 제공을 해 주어서 매일 한 챕터씩 공부를 해도 일주일 조금 걸릴 것 같다. 그럼 첫 강의로 Linear Regression을 복습해본다.



우선 결론부터 말해 보자면, 우리가 준비해 주어야 하는 것은 위의 4가지이다. Input과 Output Data는 서로 상관관계는 있지만, 인과관계는 없어야 한다. 




 예를 들어 위의 예시에서, 아이스크림 판매량과 해수욕장 익사자 수 사이에 무슨 관계가 있는지 살펴보자면, 아이스크림이 많이 팔렸다는 것은 그만큼 날씨가 더웠다는 것이다. 그리고, 그만큼 날이 더우면 해수욕장의 익사자 수도 많을 것이란 것을 알 수 있다. 

 다만, 그렇다면 아이스크림이 많이 팔려서 익사자가 많은 것인가 하면 그것은 아니라는 것이다. 아이스크림을 팔지 못하게 한다고, 익사자가 줄지는 않는다. 이는 통계학에서 Adversarial 하는가와도 관련이 있다. 

 그럼 본론으로 돌아와, Input과 Output Data는 우리가 준비하거나 클라이언트가 가지고 있다고 한다면, 나머지 Hypothesis와 Cost Function이 무엇인지에 대해서 알아보자.




 Hypothesis는 변역하면 가설 정도인데, 마치 프로그래밍의 함수와 같이 Input과 Output의 상관관계를 정의하는 수식이다. Linear Regression은 이 함수의 형태가 Linear
 Linear : f(ax + by) = af(x) + bf(y) 이런 모양을 가진다.



 Cost Function은 해석 그대로, 가설과 실제 데이터 값의 차이에 대한 비용과 관련된 함수이다. 무슨 말이냐 하면 예를 들어, 나는 귀여운 것을 좋아하는데

 0.5m 인형이 20000원
 1.0m 인형이 40000원
 1.5m 인형이 50000원
H(x) = 40000x

 이러한 상황에서 1.5m 인형은 50000원 인데 가설에 의하면 60000원 이었어야 한다. 그럼 이 차이가 즉 Cost를 만들어 낸다. Cost는 작을 수록 좋다. 그럼 이번에는 가설을 달리 해서

H(x) = 10000 + 25000x

 이렇게 한다면?? x가 1.5일때, 47500원 이라는 값이 나와서 Cost가 다소 작아지게 된다. 비록 앞선 두 값에서 오차가 생기게 되었지만 Cost의 총 합은 아래의 가설이 더 정확하다고 말하고 있다. Linear Regression에서는 이 10000과 25000이라는 매개변수를 최적화 시키는 문제라고 할 수 있다. Cost를 계산하는 식에 대해서는 위 그림과 같이 Reduce Mean을 사용한다고 하는데, 왜 그런지까지는 수학적으로 더 깊은 이해가 필요해서 넘어갔다.




 이 매개 변수가 Linear Regression에서는 1개의 변수 당 2개가 있다. 그럼 이 변수들을 자동으로 찾는 방법이 없을까? 이럴 때에는 위와 같이 Gradient Descent를 사용한다. 그리고 식은 다음과 같다. 




 처음 봤을 때에는 이게 뭔가 싶었지만, 상황을 대입해 보면 무척 간단한 구조였다. 매개변수들을 바꾸었는데 Cost가 증가를 했다!! 그럼 바꾸었던 그 과정이 잘못되었다는 뜻이고, 그 방향과 반대로 다시 매개변수의 값을 옮겨야 한다는 뜻이다. 그래서 변화량의 반대(-)에 일정 값(a)를 곱해서 다시 새로운 매개변수를 찾게 된다. 이 곱해주는 수를 Learning_rate라고 하는데, 이 값이 너무 크면 결과가 진동을 하게 되므로 적절한 값을 설정해 주어야 한다.

(이걸 어떻게 아냐... 했는데 Scaling을 하고 0~1사이에 적절한 값을 해주면 될 것 같다고 판단했다.) - Scaling이란 Output Data가 20000원, 40000원 막 이럴 때 이를 그대로 쓰지 말고 0.2, 0.4 이렇게 크기를 줄여서 하는 것을 말한다.


 자 그럼, 이제 즐거운 코딩 시간이 되었다!! 매개변수 θ 들을 적절하게 찾아보자!!

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
import numpy as np
import matplotlib.pyplot as plt
def get_data():
    # x_data에 집의 넓이를 저장합니다.
    x_data = np.array([0.200.500.600.850.90])
    # y_data에 집의 가격을 저장합니다.
    y_data = np.array([0.050.500.350.550.75])
    return x_data, y_data
def predict(theta0, theta1, x):
    # x에는 집의 넓이가 저장되어 있습니다.
    # y에 집의 추정 가격이 계산하여 저장합니다.
    # x가 numpy array인 경우에는 y도 numpy array로 저장합니다.
    y = theta0 + theta1 * x
    return y
def get_cost(x_data, y_data, theta0, theta1):
    # x_data에 집의 넓이가 저장되어 있습니다.
    # y_data에 집의 가격이 저장되어 있습니다.
    # y_pred에 집의 넓이를 바탕으로 추정한 집의 가격을 저장합니다.
    y_pred = predict(theta0, theta1, x_data)
    cost = 0
    # 집 data 수 만큼 반복합니다.
    for i in range(len(x_data)):
        # y_data(집의 가격)과 y_pred(집의 넓이를 바탕으로 추정한 집의 가격)의 차의 제곱을 모든 집 data에 대해 계산해서 더합니다.
        cost += (y_data[i] - y_pred[i]) ** 2
    # 집 data 수로 나눠줘서 평균을 계산합니다.
    cost /= len(x_data)
    return cost
def draw_graph(x_data, y_data, theta0, theta1):
    # matplotlib 상태를 초기화합니다.
    plt.clf()
    plt.cla()
    plt.close()
    x = np.array([0.01.0])
    # x 집의 넓이로 추정한 집의 가격을 y에 저장합니다.
    y = predict(theta0, theta1, x)
    # x_data 집의 넓이로 추정한 집의 가격을 y_pred에 저장합니다.
    y_pred = predict(theta0, theta1, x_data)
    # cost를 cost에 저장합니다.
    cost = get_cost(x_data, y_data, theta0, theta1)
    # 그래프를 2개 생성합니다. axes[0]에 첫 번째 그래프를 그리고 axes[1]에 두 번째 그래프를 그립니다.
    fig, axes = plt.subplots(12)
    # 첫 번째 그래프를 그립니다.
    ax = axes[0]
    # 집의 추정 가격 y_pred와 집의 가격 y_data사이의 차이를 그래프상에 검은 선으로 표시합니다.
    for i in range(len(x_data)):
        ax.plot([x_data[i], x_data[i]], [y_data[i], y_pred[i]], 'k')
    # 집의 넓이 x_data, 집의 가격 y_data의 그래프를 빨간 동그라미 점으로 그립니다.
    ax.plot(x_data, y_data, 'ro')
    # h(x)의 그래프를 그립니다.
    ax.plot(x, y)
    # 각종 부가정보를 표시합니다.
    ax.set(
            xlabel='Size in 100m^2',
            ylabel='Price(KRW) in 1B',
            title='House Price\nTheta0: {}\nTheta1: {}\nCost: {}'.format(theta0, theta1, cost),
            xlim=(01.0),
            ylim=(01.0)
    )
    # 모눈모양으로 격자를 그립니다.
    ax.grid(True)
    # 두 번째 그래프를 그립니다.
    ax = axes[1]
    # -2.0부터 2.0까지 200개의 숫자를 만들어서 numpy array theta0_list에 저장합니다.
    theta0_list = np.linspace(-2.02.0200)
    # theta0_len에 theta0_list의 길이를 저장합니다.
    theta0_len = len(theta0_list)
    # -2.0부터 2.0까지 200개의 숫자를 만들어서 numpy array theta1_list에 저장합니다.
    theta1_list = np.linspace(-2.02.0200)
    # theta1_len에 theta1_list의 길이를 저장합니다.
    theta1_len = len(theta1_list)
    # theta1_len x theta0_len의 비어있는 numpy array를 생성해서 costs에 저장합니다.
    costs = np.empty([theta1_len, theta0_len])
    # theta0와 theta1을 -2.0에서 2.0까지 하나하나 바꿔가며 모든 조합의 cost를 계산해서 costs에 저장합니다.
    # 매우 큰 cost값을 다루기 위해 costs에 cost를 저장할 때 base 10의 log를 취한 cost를 costs에 저장합니다.
    for i in range(theta1_len):
        for j in range(theta0_len):
            costs[i, j] = np.log10(
                    get_cost(x_data, y_data, theta0_list[j], theta1_list[i]))
    # cost의 contour map을 그립니다.
    cs = ax.contour(theta0_list, theta1_list, costs)
    # contour map에 label을 표시합니다.
    ax.clabel(cs)
    # 현재의 theta0, theta1의 값을 빨간색 x로 표시해 줍니다.
    ax.plot(theta0, theta1, 'rx')
    # 각종 부가정보를 표시합니다.
    ax.set(
            xlabel='theta0',
            ylabel='theta1',
            title='log10(cost) Contour Map\nCost: {}'.format(cost),
    )
    # 모눈모양으로 격자를 그립니다.
    ax.grid(True)
    # 그래프를 실제 화면에 그립니다.
    plt.show()
# get_data를 이용하여 집의 data를 얻어옵니다.
# x_data에 집의 넓이가 저장됩니다.
# y_data에 집의 가격이 저장됩니다.
x_data, y_data = get_data()
# theta0와 theta1을 지정합니다.
# 코드 시작
theta0 = 0.5
theta1 = 0.5
# 코드 끝
# x_data(집의 넓이), y_data(집의 가격), theta0, theta1, draw_graph를 이용하여 그래프를 그립니다.
draw_graph(x_data, y_data, theta0, theta1)
# 집의 넓이를 바탕으로 집의 가격을 predict로 추정한 결과를 y_pred에 저장합니다.
y_pred = predict(theta0, theta1, x_data)
# x_data를 이용하여 집의 넓이를 print로 출력합니다.
print('x_data', x_data)
# y_data를 이용하여 집의 가격을 print로 출력합니다.
print('y_data', y_data)
# 집의 넓이를 바탕으로 집의 가격을 predict로 추정한 결과를 print로 출력합니다.
print('y_pred', y_pred)
# 70m^2의 넓이를 가지는 집의 가격을 predict로 추정하여 결과를 print로 출력합니다.
print(predict(theta0, theta1, 0.70))
 
cs



 위 코드는 외부 패키지 사용을 최소화한 버전이다. 사실 미분도 하지 않고, 0.001증가에 대한 변화량으로 대체하였다. 그리고 수동적으로 θ의 값들을 바꾸어 주어야 하는 버전이다.


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
import numpy as np
import tensorflow as tf
 
def get_data():
    # x_data에 집의 넓이를 저장합니다.
    x_data = np.array([0.200.500.600.850.90])
    # y_data에 집의 가격을 저장합니다.
    y_data = np.array([0.050.500.350.550.75])
    return x_data, y_data
 
x_input = tf.placeholder(tf.float32)
theta0_var = tf.Variable(-0.13)
theta1_var = tf.Variable(1.0)
 
# x_input, theta0_var, theta1_var를 사용하여 집의 추정 가격의 계산과정을 정의합니다.
# x_input에는 집의 넓이 placeholder가 저장되어 있습니다.
# y_output에 집의 추정 가격 tensor를 저장합니다.
# y_output에는 function과 유사하게 계산과정이 저장되며 실제로 계산을 수행하지는 않습니다.
y_output = theta0_var + theta1_var * x_input
sess = tf.Session()
 
# x_data에 집의 넓이를 저장합니다.
# y_data에 집의 가격을 저장합니다.
x_data, y_data = get_data()
# Variable을 초기화합니다.
sess.run(tf.global_variables_initializer())
# x_input에 집의 넓이 x_data를 쏟아붓고 y_output을 통해서 집의 추정 가격이 쏟아져 나오는 것을 받습니다.
y_pred = sess.run(y_output, feed_dict={x_input: x_data})
 
print('x_data', x_data)
print('y_data', y_data)
print('y_pred', y_pred)
print(sess.run(y_output, feed_dict={x_input: 0.70}))
 
sess.close()
cs


 이 버전을 tensorflow를 이용해서 보다 간결하게 만든 버전이다. 그럼 이제 자동적으로 θ값들을 찾게 Gradient Descent를 사용해 보자!!!


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
import numpy as np
import matplotlib.pyplot as plt
 
def get_data():
    # x_data에 집의 넓이를 저장합니다.
    x_data = np.array([0.200.500.600.850.90])
    # y_data에 집의 가격을 저장합니다.
    y_data = np.array([0.050.500.350.550.75])
    return x_data, y_data
 
def predict(theta0, theta1, x):
    # x에는 집의 넓이가 저장되어 있습니다.
    # y에 집의 추정 가격이 계산하여 저장합니다.
    # x가 numpy array인 경우에는 y도 numpy array로 저장합니다.
    y = theta0 + theta1 * x
    return y
 
def get_cost(x_data, y_data, theta0, theta1):
    # x_data에 집의 넓이가 저장되어 있습니다.
    # y_data에 집의 가격이 저장되어 있습니다.
    # y_pred에 집의 넓이를 바탕으로 추정한 집의 가격을 저장합니다.
    y_pred = predict(theta0, theta1, x_data)
    cost = 0
    # 집 data 수 만큼 반복합니다.
    for i in range(len(x_data)):
        # y_data(집의 가격)과 y_pred(집의 넓이를 바탕으로 추정한 집의 가격)의 차의 제곱을 모든 집 data에 대해 계산해서 더합니다.
        cost += (y_data[i] - y_pred[i]) ** 2
    # 집 data 수로 나눠줘서 평균을 계산합니다.
    cost /= len(x_data)
    return cost
 
def draw_graph(x_data, y_data, theta0, theta1):
    # matplotlib 상태를 초기화합니다.
    plt.clf()
    plt.cla()
    plt.close()
 
    x = np.array([0.01.0])
    # x 집의 넓이로 추정한 집의 가격을 y에 저장합니다.
    y = predict(theta0, theta1, x)
    # x_data 집의 넓이로 추정한 집의 가격을 y_pred에 저장합니다.
    y_pred = predict(theta0, theta1, x_data)
    # cost를 cost에 저장합니다.
    cost = get_cost(x_data, y_data, theta0, theta1)
 
    # 그래프를 2개 생성합니다. axes[0]에 첫 번째 그래프를 그리고 axes[1]에 두 번째 그래프를 그립니다.
    fig, axes = plt.subplots(12)
 
    # 첫 번째 그래프를 그립니다.
    ax = axes[0]
    # 집의 추정 가격 y_pred와 집의 가격 y_data사이의 차이를 그래프상에 검은 선으로 표시합니다.
    for i in range(len(x_data)):
        ax.plot([x_data[i], x_data[i]], [y_data[i], y_pred[i]], 'k')
    # 집의 넓이 x_data, 집의 가격 y_data의 그래프를 빨간 동그라미 점으로 그립니다.
    ax.plot(x_data, y_data, 'ro')
    # h(x)의 그래프를 그립니다.
    ax.plot(x, y)
    # 각종 부가정보를 표시합니다.
    ax.set(
            xlabel='Size in 100m^2',
            ylabel='Price(KRW) in 1B',
            title='House Price\nTheta0: {}\nTheta1: {}\nCost: {}'.format(theta0, theta1, cost),
            xlim=(01.0),
            ylim=(01.0)
    )
    # 모눈모양으로 격자를 그립니다.
    ax.grid(True)
 
    # 두 번째 그래프를 그립니다.
    ax = axes[1]
    # -2.0부터 2.0까지 200개의 숫자를 만들어서 numpy array theta0_list에 저장합니다.
    theta0_list = np.linspace(-2.02.0200)
    # theta0_len에 theta0_list의 길이를 저장합니다.
    theta0_len = len(theta0_list)
    # -2.0부터 2.0까지 200개의 숫자를 만들어서 numpy array theta1_list에 저장합니다.
    theta1_list = np.linspace(-2.02.0200)
    # theta1_len에 theta1_list의 길이를 저장합니다.
    theta1_len = len(theta1_list)
    # theta1_len x theta0_len의 비어있는 numpy array를 생성해서 costs에 저장합니다.
    costs = np.empty([theta1_len, theta0_len])
    # theta0와 theta1을 -2.0에서 2.0까지 하나하나 바꿔가며 모든 조합의 cost를 계산해서 costs에 저장합니다.
    # 매우 큰 cost값을 다루기 위해 costs에 cost를 저장할 때 base 10의 log를 취한 cost를 costs에 저장합니다.
    for i in range(theta1_len):
        for j in range(theta0_len):
            costs[i, j] = np.log10(
                    get_cost(x_data, y_data, theta0_list[j], theta1_list[i]))
    # cost의 contour map을 그립니다.
    cs = ax.contour(theta0_list, theta1_list, costs)
    # contour map에 label을 표시합니다.
    ax.clabel(cs)
    # 현재의 theta0, theta1의 값을 빨간색 x로 표시해 줍니다.
    ax.plot(theta0, theta1, 'rx')
    # 각종 부가정보를 표시합니다.
    ax.set(
            xlabel='theta0',
            ylabel='theta1',
            title='log10(cost) Contour Map\nCost: {}'.format(cost),
    )
    # 모눈모양으로 격자를 그립니다.
    ax.grid(True)
    # 그래프를 실제 화면에 그립니다.
    plt.show()
 
def train_step(x_data, y_data, theta0, theta1, learning_rate):
    epsilon = 0.001
    # 현재의 cost값을 계산하여 cost에 저장합니다.
    cost = get_cost(x_data, y_data, theta0, theta1)
    # theta0이 약간 증가한 경우 증가한 theta0에 대한 cost의 변화량을 d_theta0에 저장합니다.
    d_theta0 = (get_cost(x_data, y_data, theta0 + epsilon, theta1) - cost) / epsilon
    # theta1이 약간 증가한 경우 증가한 theta1에 대한 cost의 변화량을 d_theta1에 저장합니다.
    d_theta1 = (get_cost(x_data, y_data, theta0, theta1 + epsilon) - cost) / epsilon
    # cost가 감소하는 방향으로 d_theta0 * learning_rate만큼 theta0에 변화를 줘서 new_theta0에 저장합니다.
    new_theta0 = theta0 - d_theta0 * learning_rate
    # cost가 감소하는 방향으로 d_theta1 * learning_rate만큼 theta1에 변화를 줘서 new_theta1에 저장합니다.
    new_theta1 = theta1 - d_theta1 * learning_rate
    return new_theta0, new_theta1
 
# x_data에 집의 넓이를 저장합니다.
# y_data에 집의 가격을 저장합니다.
x_data, y_data = get_data()
 
# theta0와 theta1을 지정합니다.
theta0 = 0.5
theta1 = 0.5
#theta0 = 1.0
#theta1 = 0.0
 
# learning_rate를 지정합니다.
learning_rate = 0.5
#learning_rate = 1.0
#learning_rate = 0.1
 
# theta0, theta1을 조금씩 변경하는 것을 100번 반복하여 최적은 theta0, theta1을 찾습니다.
for i in range(100):
    # 10번에 한 번씩 그래프를 그립니다.
    if i % 10 == 0:
        draw_graph(x_data, y_data, theta0, theta1)
    # train_step을 사용하여 theta0, theta1을 약간 변경하여 cost가 작아지게 합니다.
    theta0, theta1 = train_step(x_data, y_data, theta0, theta1, learning_rate)
draw_graph(x_data, y_data, theta0, theta1)
 
# 집의 넓이를 바탕으로 집의 가격을 predict로 추정한 결과를 y_pred에 저장합니다.
y_pred = predict(theta0, theta1, x_data)
 
# x_data를 이용하여 집의 넓이를 print로 출력합니다.
print('x_data', x_data)
 
# y_data를 이용하여 집의 가격을 print로 출력합니다.
print('y_data', y_data)
 
# 집의 넓이를 바탕으로 집의 가격을 predict로 추정한 결과를 print로 출력합니다.
print('y_pred', y_pred)
 
# 70m^2의 넓이를 가지는 집의 가격을 predict로 추정하여 결과를 print로 출력합니다.
print(predict(theta0, theta1, 0.70))
cs



 이 버전은 아래와 같이 θ 값의 변화에 따라 Cost 가 어떻게 변화하는지 Contour로 보여준다.




 그럼 이번에도 예외 없이 tensorflow를 사용한 버전이다!!



1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
import numpy as np
import tensorflow as tf
 
def get_data():
    # x_data에 집의 넓이를 저장합니다.
    x_data = np.array([0.200.500.600.850.90])
    # y_data에 집의 가격을 저장합니다.
    y_data = np.array([0.050.500.350.550.75])
    return x_data, y_data
 
x_input = tf.placeholder(tf.float32)
y_input = tf.placeholder(tf.float32)
 
theta0_var = tf.Variable(0.5)
theta1_var = tf.Variable(0.5)
 
# x_input, theta0_var, theta1_var를 사용하여 집의 추정 가격의 계산과정을 정의합니다.
# x_input에는 집의 넓이 placeholder가 저장되어 있습니다.
# y_output에 집의 추정 가격 tensor를 저장합니다.
# y_output에는 function과 유사하게 계산과정이 저장되며 실제로 계산을 수행하지는 않습니다.
y_output = theta0_var + theta1_var * x_input
 
# y_input은 집의 넓이가 쏟아져 들어올 placeholder가 저장되어 있습니다.
# y_output은 집의 넓이로 부터 집의 가격을 추정하는 tensor가 저장되어 있습니다.
# tf.reduce_mean은 주어진 tensor안에 있는 값들을 평균하는 tensor를 return합니다.
# cost_output에 cost값을 계산하는 tensor를 저장합니다.
cost_output = tf.reduce_mean((y_output - y_input) ** 2)
 
learning_rate = 0.5
# GradientDescentOptimizer를 사용하여 learning rate를 learning_rate로 설정하고,
# theta0_var, theta1_var를 약간 변경하여 cost_output에 저장되어 있는 cost를 작게 만드는 작업을 하는
#  operation을 train_step에 저장합니다.
train_step = tf.train.GradientDescentOptimizer(learning_rate).minimize(cost_output)
 
sess = tf.Session()
 
# x_data에 집의 넓이를 저장합니다.
# y_data에 집의 가격을 저장합니다.
x_data, y_data = get_data()
theta0 = 0
theta1 = 0
cost = 0
# variable들을 초기화합니다.
sess.run(tf.global_variables_initializer())
# theta0, theta1을 조금씩 변경하는 것을 100번 반복하여 최적의 theta0, theta1을 찾습니다.
for i in range(100):
    # 10번에 한 번씩 현재 상황을 출력합니다.
    if i % 10 == 0:
        # 현재의 theta0, theta1를 얻어오고, cost를 x_data 집의 넓이, y_data 집의 가격을 사용하여 계산합니다.
        theta0, theta1, cost = sess.run(
                [theta0_var, theta1_var, cost_output],
                feed_dict={x_input: x_data, y_input: y_data})
        print('train_step: {}, theta0: {}, theta1: {}, cost: {}'.format(
                i, theta0, theta1, cost))
    # Gradient Descent를 사용하여 cost가 약간 작아지도록 theta0, theta1을 변경합니다.
    sess.run(train_step, feed_dict={x_input: x_data, y_input: y_data})
 
# theta0_var tensor, theta1_var variable로부터 값을 읽어서 theta0, theta1에 저장합니다.
# theta0_var tensor와 theta1_var variable를 계산하기 위해 필요한 input data가 필요없기 때문에 feed_dict는 넘기지 않아도 됩니다.
theta0, theta1 = sess.run([theta0_var, theta1_var])
# x_data 집의 넓이를 x_input에 넣고, y_data 집의 가격을 y_input에 넣어서 cost_output을 통해서 cost값을 얻어서 cost에 저장합니다.
cost = sess.run(cost_output, feed_dict={x_input: x_data, y_input: y_data})
# sess.run에 x_data 집의 넓이를 x_input에 feed_dict로 넘기면서 집의 추정 가격을 y_output을 통해서 얻어옵니다.
y_pred = sess.run(y_output, feed_dict={x_input: x_data})
 
print('')
print('theta0', theta0)
print('theta1', theta1)
print('cost', cost)
 
# x_data를 이용하여 집의 넓이를 print로 출력합니다.
print('x_data', x_data)
 
# y_data를 이용하여 집의 가격을 print로 출력합니다.
print('y_data', y_data)
 
# 집의 넓이를 바탕으로 집의 가격을 추정한 결과를 print로 출력합니다.
print('y_pred', y_pred)
 
# 70m^2의 넓이를 가지는 집의 가격을 추정하여 결과를 print로 출력합니다.
print(sess.run(y_output, feed_dict={x_input: 0.70}))
 
sess.close()
cs



 tensorflow에서 제공하는 함수로 GradientDescentOptimizer를 사용하였다.


자, 사실 Linear Regression은 인공지능 축에 속하지도 못하는 간단한 편이라고 한다.

그럼 다음 시간에는 Logistic Regression을 공부해 본다.


출처: alina ai-pm 강의