김DJ의 IT이야기

이전 포스팅까지는

'종속 변수 Y와 한 개 이상의 독립변수 X와의 선형(Linear) 상관 관계를 모델링하는 회기분석기법',

선형회기(linear regression) 의

single & multi value(s) 학습에 대해 배웠습니다.

이번 포스팅에서는

'종속 변수 Y에 대해, 결과적으로 True(1)와 False(0)로써 구분하도록 하는 독립변수 X와의 관계 모델링 회기분석기법',

Logistic Regression에 대해 학습하겠습니다.

기존의, Linear Regression Hypothesis이란?

다음과 같이, 종속 변수 Y와 한 개 이상의 독립변수 X와의 선형(Linear) 상관 관계를 위한 Hypothesis 식을 뜻한다

Hypothesis: H(x) = Wx + b

Logistic Regression의 목적?

Logistic Regression은 '종속 변수 Y에 대해, 결과적으로 True(1)와 False(0)로써 구분하도록 하는 독립변수 X와의 관계를 모델링하는 것'

을 목표로 한다.

예를 들어, 한 학생의 공부한 기간(Day), 공부한 시간(Study-hour), 잠을 잔 시간(Sleep-hour)라는 독립변수(X)들이 있을 때, 해당 과목에 대한 PASS / No Pass(Y)의 기록(record)들을 회기 분석하는 것이 Logistic Regression의 관점이다.

Logistic Regression의 Hypothesis이란?

위와 같이 Logistic Regression의 목적에 부합하기 위해서는, 기존의 Linear Regression의 Hypothesis의 사용은 문제가 있다.

예를 들어 Y = H(X) = WX + b에서, W(기울기)와 X(독립변수)가 1을 초과할 경우, Y의 값이 0과 1사이가 아닌 값(1을 초과)이 나오므로 이를 토대로 True / False의 구분이 어렵다.
그렇기에, Logistic Regression의 Hypothesis에서는 기존의 WX(기울기 * 독립변수) 식에 0과 1로 이분할 시키기 위한, 시그모이드 함수(sigmoid function)를 적용한다.

시그모이드 함수(sigmoid function)
z값에 WX를 대입한다.(독립변수(X)에 대한, 올바른 W(기울기)찾아야 하기에)

시그모이드 함수(sigmoid function)를 적용한
Logistic Regression의 Hypothesis

Logistic Regression의 Cost function이란?

결론부터 이야기하자면, 기존의 Linear Regression의 Cost function과 다르게 Logistic Regression의 Cost function은 다음과 같다.

H(X) = Sigmoid(WX) 라는, 사실상 자연상수의 지수(e)를 사용하는 Logistic Regression의 Hypothesis의 Cost를 판단하기 위해서는, Log의 사용이 불가피한 것이다.

또한 0과 1로 이분할 시키기 위한 시그모이드 함수를 적용하였기에, Y의 값에 따라 해당 Hypothesis의 Cost또한 분리해야 한다.

이 때, 반드시 확인해야될 것은 기존의 Linear Regression의 Cost function과 마찬가지로, 독립변수(X)에 대한, 올바른 W(기울기)찾아야 하기에, Cost(W)는 항상 Cost들의 평균 값이라는 것을 기억해야한다.

Logistic Regression의 Cost function에서 Cost인, C(H(x),y)의 의미란?

위의 Logistic Regression의 Cost function 공식에서 C(H(x),y)는 y의 값이 0과 1일 때를 이분할 하였다. 이를 해석 하면 다음과 같다.

•   y가 1일 때 

- H(X) = 1가 되었다면(Hypothesis의 독립변수 X에 의해 H(X)이 1이되 었다) 예측이 성공했다는 뜻이고, 이때의 비용은 0이다.

- H(X) = 0가 되었다면(Hypothesis의 독립변수 X에 의해 H(X)이 0이되 었다) 예측이 실패했다는 뜻이고, 이때의 비용은 무한대이다.

• y가 0일 때  

- H(X) = 0가 되었다면(Hypothesis의 독립변수 X에 의해 H(X)이 0이되 었다) 예측이 성공했다는 뜻이고, 이때의 비용은 0이다.

- H(X) = 1가 되었다면(Hypothesis의 독립변수 X에 의해 H(X)이 1이되 었다) 예측이 실패했다는 뜻이고, 이때의 비용은 무한대이다.

하지만, 위와 같은 식으로 직접 코드에 적용할 경우, 조건문(if)에 따라 늘 분할 하여 Cost들을 정리해야하는 번거로움이 생긴다. 이를 해결하기 위해, Cost function을 다음과 같이 정의하였고, 이 공식은 위의 조건들을 만족한다.

늘 그랬듯이, 항상 머신러닝의 기본방식인

1. 목표에 따른 가설(Hypothesis)과 Cost function설정

2. 가설에 대한 Cost들을 최소화

3. 실제 데이터 통한 반복 학습

이 3가지 순서를 다시 한번 기억하면서,

실전예제를 접하겠습니다.

실전예제

여러 독립 변수들과 'Pima 인디언 당뇨병(pima indians diabetes)' 진단 결과(True / False)의 상관 관계를 통해, 병에 걸린 여부를 예측하라

tensorflow가 학습할 데이터

(이때, test 항목에 negatif는 0으로, positif는 1로 치환하여 진행한다)

참조 데이터 출처: https://www.kaggle.com

위의 출처에서 CSV파일을 다운받은 뒤,

이전 포스팅 에서 했던 방식과 같이 Jupyter notebook 디렉토리에 해당 파일을 넣는다.

이 파일을 통해,

 'Pima 인디언 당뇨병(pima indians diabetes)' 진단 결과(True / False)를 예측하는 프로그래밍(하단의 코드)을 시작한다.

실전코드

import tensorflow as tf # numpy는 python 다차원 배열을 사용하기 위한 패키지 import numpy as np # 1. Logistic Regression Hypothesis 생성 # numpy.loadtxt() 또는 numpy.genfromtxt()로 파일을 읽어들인다. datas = np.loadtxt('pimaindiansdiabetes.csv', delimiter = ',' , dtype = np.float32) x_data = datas[:, 0:-1] y_data = datas[:, [-1]] # feed_dict에 feed될(to be fed) tensor를 위한 placeholder 설정 X = tf.placeholder(tf.float32, shape=[None, 8]) Y = tf.placeholder(tf.float32, shape=[None, 1]) # tf.Variable(변수)에 random number를 각각 assign W = tf.Variable(tf.random_normal([8, 1], mean=0.01, stddev=0.01), name='weight') b = tf.Variable(tf.random_normal([1]), name='bias') # logistic regression Hypothesis 설정(tf.sigmoid() == 0과 1 사이의 값을 만들기 위한 시그모이드 함수) hypothesis = tf.sigmoid(tf.matmul(X, W) + b) # 2. Cost function 최소화 #cost function(logistic regression에서, W와 b를 찾기 위한 cost) cost = -tf.reduce_mean(Y * tf.log(hypothesis) + (1 - Y) * tf.log(1 - hypothesis)) train = tf.train.GradientDescentOptimizer(learning_rate=0.0001).minimize(cost) # 정확성 측정 # tf.cast()의 첫 번째 파라미터 'if hypothesis > 0.5' then 1' 1 을 float32로 캐스팅(=1.0) predicted = tf.cast(hypothesis > 0.5, dtype=tf.float32) accuracy = tf.reduce_mean(tf.cast(tf.equal(predicted, Y), dtype=tf.float32)) # 3. 학습을 통해 실행 with tf.Session() as sess: sess.run(tf.global_variables_initializer()) feed = {X: x_data, Y: y_data} for step in range(10001): sess.run(train, feed_dict=feed) if step % 2000 == 0: print(step, sess.run(cost, feed_dict=feed)) h, c, a = sess.run([hypothesis, predicted, accuracy], feed_dict=feed) print("\nHypothesis: ", h,"\nCorrect (Y): ", c, "\nAccuracy: ", a)

결과

Accuracy: 0.710938

실전 코드의 중요 사항 및 해설

# tf.Variable(변수)에 random number를 각각 assign W = tf.Variable(tf.random_normal([8, 1], mean=0.01, stddev=0.01), name='weight') #cost function(logistic regression에서, W와 b를 찾기 위한 cost) cost = -tf.reduce_mean(Y * tf.log(hypothesis) + (1 - Y) * tf.log(1 - hypothesis)) train = tf.train.GradientDescentOptimizer(learning_rate=0.0001).minimize(cost)

위 코드에서,

1. tf.random_normal([8, 1], mean=0.01, stddev=0.01) 를 쓴 이유는?

tf.random_normal() 함수에서 mean은 평균값을 의미하고 stddev는 표준편차를 의미한다. 이를 각각 0.01로 할당한 이유는

tf.matmul(X, W)에서 W(기울기)의 값이 X(독립변수)와 곱하여 더해지는데 X(독립변수) 값이 크면 클 수록 tensorflow에서 값이 안보이는 경우가 생길 수 있기 때문에(ex. NaN) 이를 방지하고자 한 것이다.

2. tf.train.GradientDescentOptimizer(learning_rate=0.0001).minimize(cost) 를 쓴 이유는?

일단, Gradient Descent Algorithm은 기울기의 크기가 줄어드는 쪽으로 하강하여 Cost function의 최소화를 통해 원하는 값을 찾아낸다는 것이 주된 목적이다.

이 때, 기울기의 크기가 줄어 드는 Step(Cost의 미분 값 + Step)을 'Learning Rate'이라 한다.

결국, 이 Learning Rate 조절을 통해 그래프 상에서 이동하는 step의 크기를 조절한다.(가장 중요한 작업)

3. Learning Rate 조절이 가장 중요한 이유는?

Learning Rate의 값이 클 경우에는, 

기울기가 줄어드는 지점으로 이동하다가 큰 Step의 간격에 의해 최소값에 도달하기 전에 그래프 반대편으로 튀어 나가 발산(overshooting)해버린다.

Learning Rate의 값이 작을 경우에는,

실제 학습(train)을 하는 과정에서 작은 Step의 간격에 의해 최소값을 찾아가는 속도가 느리게 되어, 원하는 값을 찾지 못하고 학습이 끝날 수도 있다. (ex. 반복문을 통한 학습(train)을 해도, Cost값이 줄지 않는 현상)

4. 그렇다면, Learning Rate 조절을 어떻게 해야되는지?

보통은 Learning rate의 값을 0.01로 시작해서 발산(overshooting)여부를 확인하고, 더 작게 할지 크게 할지를 조절하며 테스트한다. 

이전 포스팅에서

선형회기(linear regression) 와 Gradient Descent Algorthm 

에 대해 배웠습니다.

이번 포스팅에서는

이전의 선형회기(linear regression)의 Hypothesis

H(x) = WX + b 에서

하나의 X변수 대신, 여러 개의 변수(Multi-variable)이 적용된

선형회귀(linear regression)에 대해 학습하겠습니다.

변수(feature) X가 하나인, linear regression Hypothesis이란?

다음과 같은 Hypothesis에서 변수 x가 하나인 식을 뜻한다

Hypothesis: H(x) = Wx + b

변수(feature) X가 여러 개인, linear regression Hypothesis이란?

다음과 같은 Hypothesis에서 변수 x가 두 개 이상인 식을 뜻한다

Hypothesis: H(x) = W1x1+ W2x2 + W3x3 + b

변수(feature) X가 여러 개인, linear regression Hypothesis를 계산 하는 방법이란?

다양한 변수(feature)들의 hypothesis 계산을 보다 효율적으로 하기위해 Matrix(행렬)의 곱을 이용한다.

이때, x1 x2 x3의 값들을 통칭하여 instance라고 한다. 예를 들어, [(2, 3, 4),(22, 33, 44)]가 있을 때, (2, 3, 4)와 (22, 33, 44)는 instance1, instance2이다.

즉,  X의 instance들과 각각의 기울기(w1, w2, w3) W를 곱한 값이 다양한 변수(feature)들의 linear regression hypothesis가 된다.

Hypothesis: H(X) = WX

실전 예제
공부한 기간(Day), 공부한 시간(Study-hour), 잠을 잔 시간(Sleep-hour)라는 변수들이 있을 때, 성적(Score, 200점 만점 기준)을 예측하라.

tensorflow가 학습할 데이터

(왼쪽 부터, Day, Study-hour, Sleep-hour, Score)

엑셀(MS) or Numbers(Mac)을 통해, 

tensorflow가 학습할 데이터(위에 표와 같이)를 생성하고

 이를 csv 파일(추후 업로드 예정)로 만들어

이전 포스팅에서 했던

jupyter notebook에서 생성한 연습용 notebook 디렉토리에

생성한 data-day-study-sleep.csv(예시) 파일을 가져다 놓는다.

이 파일을 통해

공부한 기간(Day), 공부한 시간(hour), 잠을 잔 시간(hour)라는 변수들이 있을 때, 성적(200점 만점 기준)을 예측하는 프로그래밍(하단의 코드)을 시작한다.

실전코드

import tensorflow as tf

#numpy는 python 다차원 배열을 사용하기 위한 패키지
import numpy as np

#그래프 내에서 random number의 reproductibility를 위한 seed설정
tf.set_random_seed(777)

# 1. Multi-variable Linear Regression Hypothesis 생성

#numpy.loadtxt 또는 numpy.genfromtxt로 파일을 읽어들인다.
datas = np.loadtxt('data-day-study-sleep.csv', delimiter = ',', dtype = np.float32)

x_datas = datas[:, 0:-1]
y_datas = datas[:,[-1]]

'''
print(x_data.shape, x_data, len(x_data)) 의 결과

(7, 3) [[ 30.  10.   4.]
 [ 20.   8.   6.]
 [ 25.   1.  10.]
 [ 14.   4.   8.]
 [  3.  24.   0.]
 [  5.  18.   4.]
 [ 10.   5.   5.]] 7
'''
'''
print(y_data.shape, y_data, len(y_data)) 의 결과

(7, 1) [[ 196.]
 [ 160.]
 [ 120.]
 [ 100.]
 [ 140.]
 [ 150.]
 [ 170.]] 7
'''

# feed_dict에 feed될(to be fed) tensor를 위한 placeholder 설정
X = tf.placeholder(tf.float32, shape=[None, 3])
Y = tf.placeholder(tf.float32, shape=[None, 1])

# tf.Variable(변수)에 random number를 각각 assign
W = tf.Variable(tf.random_normal([3, 1]), name='weight')
b = tf.Variable(tf.random_normal([1]), name='bias')

# linear regression Hypothesis 설정(tf.matmul == matrix[행렬]의 곱)
hypothesis = tf.matmul(X, W) + b



# 2. Cost function 최소화

# cost function(실제 data와 떨어진 거리의 평균의 합)
cost  = tf.reduce_mean(tf.square(hypothesis - Y))

# gradient descent algorithm를 위한 optimizer 객체생성 및 learning rate설정 
# cost 최소화
optimizer = tf.train.GradientDescentOptimizer(learning_rate=1e-5)
train = optimizer.minimize(cost)



# 3. 학습을 통해 실행


# 실행을 위한 세션 생성
sess = tf.Session()

# tf.global_variables_initializer()는 variable을 쓰기 위한 초기화 함수 실행
sess.run(tf.global_variables_initializer())


#반복문을 통해 학습
for step in range(2001):
    cost_value, hy_value, _ = sess.run(
       [cost, hypothesis, train], 
       feed_dict={X: x_datas, Y: y_datas})
    if step % 200 == 0:
        print(step,'번째 ', '비용은 ', cost_value, '\n 가설 값은 : ', hy_value)
        

#20일 간 ,6시간 공부하고, 4시간자면, 200점 만점의 몇 점일지 예상
print('\n\n예상 score: ', sess.run(hypothesis, feed_dict={X:[[20, 6, 4]]}))

결과

0 번째  비용은  14321.7 
 가설 값은 :  [[ 56.52085876]
 [ 42.62973404]
 [ 58.14524841]
 [ 35.93222046]
 [  2.14042115]
 [ 12.34821796]
 [ 24.61151123]]
200 번째  비용은  2435.4 
 가설 값은 :  [[ 182.89918518]
 [ 134.52552795]
 [ 147.18841553]
 [  99.14560699]
 [  86.89736176]
 [  88.3307724 ]
 [  75.84979248]]
400 번째  비용은  1509.31 
 가설 값은 :  [[ 205.16610718]
 [ 151.66650391]
 [ 157.77346802]
 [ 109.84855652]
 [ 117.92753601]
 [ 113.16294098]
 [  86.07308197]]
600 번째  비용은  1274.12 
 가설 값은 :  [[ 207.69248962]
 [ 154.39060974]
 [ 155.34371948]
 [ 110.8802948 ]
 [ 133.36581421]
 [ 124.53527069]
 [  88.20375061]]
800 번째  비용은  1178.19 
 가설 값은 :  [[ 206.86050415]
 [ 154.49468994]
 [ 151.96211243]
 [ 110.45672607]
 [ 142.47412109]
 [ 131.0561676 ]
 [  88.74027252]]
1000 번째  비용은  1135.65 
 가설 값은 :  [[ 205.72154236]
 [ 154.23001099]
 [ 149.44781494]
 [ 110.04037476]
 [ 148.21104431]
 [ 135.18591309]
 [  88.96354675]]
1200 번째  비용은  1115.74 
 가설 값은 :  [[ 204.75746155]
 [ 153.98947144]
 [ 147.792099  ]
 [ 109.81544495]
 [ 151.897995  ]
 [ 137.90638733]
 [  89.12474823]]
1400 번째  비용은  1105.56 
 가설 값은 :  [[ 203.98477173]
 [ 153.81713867]
 [ 146.75326538]
 [ 109.75018311]
 [ 154.27709961]
 [ 139.73550415]
 [  89.27240753]]
1600 번째  비용은  1099.62 
 가설 값은 :  [[ 203.35528564]
 [ 153.69975281]
 [ 146.12696838]
 [ 109.79390717]
 [ 155.80900574]
 [ 140.98698425]
 [  89.41545868]]
1800 번째  비용은  1095.58 
 가설 값은 :  [[ 202.82566833]
 [ 153.62036133]
 [ 145.77061462]
 [ 109.90763092]
 [ 156.789505  ]
 [ 141.86073303]
 [  89.55519867]]
2000 번째  비용은  1092.43 
 가설 값은 :  [[ 202.36526489]
 [ 153.56619263]
 [ 145.58929443]
 [ 110.06480408]
 [ 157.41091919]
 [ 142.48652649]
 [  89.69168091]]


예상 score:  [[ 135.58346558]]

Gradient Descent Algorithm이란?

Gradient Descent Algorithm은 선형회귀(Linear Regression)에서 Cost Function(= Hypothesis을 토대로, 실제 데이터와의 거리를 찾는 방법, 거리값의 합 평균)을 minimize 하기 위한 알고리즘이다.

말 그대로 Gradient, 경사도 or 변화도 Descent, 하강 or 강하 

"경사도를 내려오면서 최저점에 도달하는 알고리즘"

Linear Regression에서의 Cost Function의 공식

Gradient Descent Algorithm

경사도를 따라 Learning rate(=기울기를 따라 강하하는 폭)의 속도로 반복적으로 내려오면서(학습) 최저점(global optimum)을 찾는다. 

즉, Gradient Descent Algorithm에서는 단 하나의 최저점(global optimum)을 찾는 것이 최종 목표이다.

하지만, 다음 3차원 그래프와 같이 서로 다른 경로를 따라 최저점이 2개가 생기는 경우가 있습니다. 

이 경우의 해당 최저점은 Local optimum일뿐 global optimum이 아니기에 Gradient Descent Algorithm이 해결하려는 Cost Function, 더나아가 Hypothesis가 잘못되었다는 이야기입니다.

Cost Function이 Convergence를 찾기 적합한 convex graph가

되어야 Gradient Descent Algorithm을 목표를 이룰수 있습니다.

Gradient Descent Algorithm의  global optimum(convergence)를 찾는 공식 (Linear Regression)

다음과 같은 Cost Function 식에서 

H(x) = Wx(W는 기울기)으로 치환 하고 미분(그래프 접점의 기울기)을 적용

즉, 이전포스팅에서 선형회귀(Linear Regression)을 주피터노트북(Jupyter notebook)을 통해 Tensorflow로 구현하면서 적용했던 코드처럼

# 2. Cost function 최소화


# tf.reduce_mean()은 값들의 합의 평균을 구하는 함수
# tf.square()는 제곱을 해주는 함수
cost_function = tf.reduce_mean(tf.square(hypothesis - Y))

# gradient descent algorithm를 위한 optimizer 객체생성
# 생성자에 learning_rate는 "A Tensor or a floating point value. The learning rate to use."이라고 Tensorflow reference에서 나오지만
# 기울기 W의 값을 조절하면서 Cost function의 값을 최소화 하기위해 기울기가 이동하는 폭을 learning rate라한다.
optimizer = tf.train.GradientDescentOptimizer(learning_rate=0.01)

# optimizer 객체를 통해 Cost function 최소화(= tf.train.GradientDescentOptimizer.minimize())
training = optimizer.minimize(cost_function)

결국

정확한 Hypothesis 생성을 통해

Cost Function을 만들고,

이를 Optimizing하는 알고리즘으로,

Data Training Set을 학습시켜

Convergence를 찾는 것이,

'머신러닝의 기본' 입니다.

머신러닝(기계학습, Machine Learning)이란?

"기계가 일일이 코드로 명시하지 않은 동작을 데이터로부터 학습하여 실행할 수 있도록 하는 알고리즘을 개발하는 연구" - 아서 사무엘

머신 러닝은 알고리즘을 이용하여 데이터를 분석하고, 학습하고, 학습한 경험들을 바탕으로 판단이나 예측을 합니다.

결국, 머신러닝은 어떠한 문제를 위한 의사결정 기준을 직접 개발자가 Coding을 하는 것이 아니라 데이터들과 알고리즘을 통해 컴퓨터 자체가 '학습'을 통해 작업을 수행하는 것을 목표로 합니다.

머신러닝(Machine Learning)의 학습법

1. 지도학습(Supervised Learning)

- 의사결정에 대한 분류(Classification)를 하기 위해 특정 Data Training Set(=학습하려는 데이터들)에 미리 Label을 지정하여 학습시키는 것

- 예를 들어, 사자와 호랑이(Label)의 사진을 학습시켜 새로운 사진이 주어졌을때, 이를 분류(Classification)할 수 있도록 학습시키는 것

2. 자율학습(Unsupervised Learning)

- 사전의 어떠한 정보제공 없이, 입력되는 데이터의 집합을 추론과 패턴분석으로 학습시켜 이를 통해 의사결정을 하는 것

- 예를 들어, 실제 google에서는 자율학습(Unsupervised Learning)을 통해, Label이 없는 뉴스기사와 토픽을 자동적으로 분류(Classification)하여 유사한 주제끼리 Grouping을 한다.

선형회귀(Linear Regression)란?

지도학습(Supervised Learning)의 종류로써, 종속 변수 Y와 한 개 이상의 독립변수 X와의 선형(Linear) 상관 관계를 모델링하는 회기분석기법

예를 들어, 머신러닝에서 Data Training Set(=학습하려는 데이터들)들이 X = 1, Y = 1, X = 1.1, Y = 1.1 처럼 Y = X의 꼴의 대표되는 그래프를 가질때, 이를 회귀선이라 한다.

즉, 머신러닝에서의 선형회귀(Linear Regression)은 주어진 데이터를 대표하는 하나의 직선(회귀선)을 기준으로, 다른 좌표값이 나왔을때 회귀선과의 거리를 계산해서 유사도를 학습시키는 것

또한, 이때의 회귀선을 머신러닝에서는 Hypothesis(가설)이라한다. 

Hypothesis: H(x) = Wx + b 

다음과 같은 가설을 세우고, 이를 토대로 다른 좌표가 주어졌을 때 그 거리를 계산하여 유사도를 학습!

Cost Function(= Squred Error Function or Loss Function)이란?

Cost Function은 선형회귀(Linear Regression)에서 생성한 Hypothesis을 토대로, 가장 근접한 거리를 찾는 방법을 말한다. 

(Hypothesis과 실제 데이터(좌표값)들의 거리를 찾고, 이를 평균화한다)

즉, 머신러닝(Machine Learning) Linear Regression 학습은 Hypothesis와 새로운 데이터의 거리를 최소화 하기 위한 W(기울기)와 b(절편)을 구하기 위해, 실제 데이터(=Data Training Set)를 학습시키는 것이다.

이번포스팅에서는

이러한 Linear Regression 학습을 이전포스팅에서 처럼

주피터 노트북(jupyter notebook)을 이용하여 

Tensorflow로 구현해보겠습니다.

주피터노트북(jupyter notebook) 실행 방법을 잊으셨다면, 이전포스팅을 참고하세요!

주피터 노트북(Jupyter notebook)으로 Tensorflow Linear Regression 코드 작성

(참고: 

https://www.tensorflow.org)

import tensorflow as tf



# 1. Linear Regression Hypothesis 생성


# 기울기 W, 절편 b를 위해 1의 자리의 랜덤상수 발생
random1 = tf.random_normal([1])
random2 = tf.random_normal([1])

# tf.Variable(변수)에 random1, random2 각각 assign
W = tf.Variable(random1, name = "weight")
b = tf.Variable(random2, name = "bias")

# Data Training Set (X, Y) 사용하기 위해
# tf.placeholder(feed_dict를 사용하여 값을 주기 위해)선언
X = tf.placeholder(tf.float32, shape = [None])
Y = tf.placeholder(tf.float32, shape = [None])

# Linear Regression의 대표 직선(=회귀선, 가설)의 공식 선언
hypothesis = X * W +b



# 2. Cost function 최소화


# tf.reduce_mean()은 값들의 합의 평균을 구하는 함수
# tf.square()는 제곱을 해주는 함수
cost_function = tf.reduce_mean(tf.square(hypothesis - Y))

# gradient descent algorithm를 위한 optimizer 객체생성
# optimizer 생성자의 parameter인 learning_rate는 "A Tensor or a floating point value. The learning rate to use."
# 이라고 Tensorflow reference에서 나오지만, 이해하기 어렵다. 풀어서 쓰면,
# 기울기 W의 값을 조절하면서 Cost function의 값을 최소화 하기위해 기울기가 이동하는 폭을 learning rate라한다.
optimizer = tf.train.GradientDescentOptimizer(learning_rate=0.01)

# optimizer 객체를 통해 Cost function 최소화(= tf.train.GradientDescentOptimizer.minimize())
training = optimizer.minimize(cost_function)



# 3. 학습


# 실행을 위한 세션 생성
sess = tf.Session()

# tf.global_variables_initializer()는 variable을 쓰기 위한 초기화 함수 실행
sess.run(tf.global_variables_initializer())

# training()에 따라 Data Training Set을 루프를 2018번돌면서 데이터 학습시킨다.
# 200번째 마다 step, cost_function, W, b 값을 출력
for step in range(2018):
    cost_value, W_value, b_value, train_array = sess.run([cost_function,W,b, training], feed_dict={X:[1,2,3], Y:[1,2,3]})
    if step % 200 == 0:
        print(step, "번째, ", "Data Traning Set합의 평균: ", cost_value,
              ", 예상되는 기울기 W의 값: ", W_value,", 예상되는 절편 b의 값: ", b_value)
        
        
print("5를 넣었을떄, 나오는 Cost_funtion의 값: ", sess.run(hypothesis, feed_dict={X:[5]}))

실행결과

0 번째,  Data Traning Set합의 평균:  9.113637 , 예상되는 기울기 W의 값:  [-0.19424118] , 예상되는 절편 b의 값:  [-0.1128295]
200 번째,  Data Traning Set합의 평균:  0.0065755956 , 예상되는 기울기 W의 값:  [0.9060453] , 예상되는 절편 b의 값:  [0.21358106]
400 번째,  Data Traning Set합의 평균:  0.0025108887 , 예상되는 기울기 W의 값:  [0.9419418] , 예상되는 절편 b의 값:  [0.13198002]
600 번째,  Data Traning Set합의 평균:  0.00095877895 , 예상되는 기울기 W의 값:  [0.96412355] , 예상되는 절편 b의 값:  [0.08155557]
800 번째,  Data Traning Set합의 평균:  0.00036610593 , 예상되는 기울기 W의 값:  [0.9778305] , 예상되는 절편 b의 값:  [0.0503964]
1000 번째,  Data Traning Set합의 평균:  0.00013979767 , 예상되는 기울기 W의 값:  [0.98630065] , 예상되는 절편 b의 값:  [0.03114183]
1200 번째,  Data Traning Set합의 평균:  5.338082e-05 , 예상되는 기울기 W의 값:  [0.99153465] , 예상되는 절편 b의 값:  [0.01924378]
1400 번째,  Data Traning Set합의 평균:  2.0382997e-05 , 예상되는 기울기 W의 값:  [0.9947689] , 예상되는 절편 b의 값:  [0.01189146]
1600 번째,  Data Traning Set합의 평균:  7.783329e-06 , 예상되는 기울기 W의 값:  [0.9967676] , 예상되는 절편 b의 값:  [0.00734813]
1800 번째,  Data Traning Set합의 평균:  2.9719788e-06 , 예상되는 기울기 W의 값:  [0.9980025] , 예상되는 절편 b의 값:  [0.00454069]
2000 번째,  Data Traning Set합의 평균:  1.1349313e-06 , 예상되는 기울기 W의 값:  [0.99876565] , 예상되는 절편 b의 값:  [0.00280594]

5를 넣었을떄, 나오는 Cost_funtion의 값:  [4.9967694]

이전 포스팅에서, 

텐서플로우를 위한 아나콘다 및 주피터노트북 설정방법에 대해 이야기했습니다.

아나콘다(anaconda)란?

"The Most Popular Python Data Science Platform"으로써, python Data Science 패키지를 담고있는 플랫폼입니다. 그렇기에 기존의 python의 패키지 매니저인, 'pip'을 통해 데이터 사이언스에 필요한 패키지를 별도로 다운로드하는 번거로움없이, 아나콘다(anaconda)를 통해 사용자가 쉽게 python Data Science 패키지를 사용할 수 있습니다.

주피터 노트북(jupyter notebook)이란? 

오프소스 웹 응용프로그램으로써, python, R, Scala 등의 데이터 사이언스(data science) 언어 40여개를 지원하는 tool입니다.

그 중에서 저희는 머신러닝을 위한 'tensorflow' 공부를 위해, 주피터 노트북을 일종의 '연습장' 처럼 사용하겠습니다.

텐서플로우(tensorflow)란?

텐서플로우(tensorflow)는 구글(Google)에서 만든, 일종의 머신러닝(machine learning)과 딥러닝(Deep learning)을 위한 오픈소스 패키지입니다. 이러한 학습(learning)을 가능하게 만들기 위해, 텐서플로우(tensorflow)는 'Data Flow Graphs'를 기반으로 동작합니다.

'Data Flow Graph'는 수학(numeric)계산(operation)과 데이터의 흐름을 표현하기 위해, 노드(Node)와 엣지(Edge), 방향이 있는 그래프(Directed Graphs)들로 나타냅니다.

노드(Node)는 수학적 계산(numeric operation), 데이터 입/출력 및 생성 수정 저장 삭제 등의 일종의 기능(operation)을 수행합니다. 

엣지(Edge)는 노드(Node)들 간 데이터의 입출력 관계로써, 동적 다차원 데이터 Array(텐서, Tensor)들이 방향이 있는 그래프(Directed Graphs)에 따라이동하는 경로입니다.

즉, 텐서플로우의 역할은 

'Data Flow Graphs를 기반으로, 동적 다차원 데이터 배열(텐서)을 흐름에 따라 수학적으로 연산작업(Node)하며 데이터를 과학적으로 학습' 시킵니다.

텐서플로우(tensorflow)의 특징

• Data Flow Graph를 통한 학습지원
• 별도 수정없이 C(G)PU mode 지원
• Graph 빌드와 target 함수만 정의하면 자동으로 미분(그래프에 대한 접선 기울기, 기울기 정도에 따라 정확도를 향상하는 학습)지원
• Python/C++ 지원 

1. 주피터 노트북(jupyter notebook)실행

아나콘다 네비게이터에서 이전포스팅에서 만든 py_env환경을 클릭 후

'Open Terminal' 클릭

Terminal에서 이전포스팅에서 만든,

py_env환경이 있는 디렉토리로 들어가서

py_env환경을 활성화 합니다.

그리고

Jupyter notebook을 실행합니다.

주피터노트북에서 이전포스팅에서 만든,

우측상단에 있는 'new' 박스를 클릭해서,

'python(tf)'라는 노트북으로 들어갑니다.

주피터노트북의 저희의 첫번째 'python(tf)' 노트북(연습장)에

첫 노트를 작성하기 앞서,

좌측상단에 'Untitled1'을 클릭해서 파일명을 변경합니다.

(안하셔도 되지만, 하는게 좋을거같아요)

이번 포스팅에서는 'data flow graphs를 이용한 numeric계산'을 배울 것입니다.

기본적인 텐서플로우의 문법(?, python문법)을 통해 

1. graph build(node)

2.  operation

을 해보겠습니다.

2. 텐서플로우(tensor)를 위한 기본적인 Node & Operation 생성

tensorflow를 import해서 tf라고 별칭(alias)을 줍니다.

또한 텐서플로우의 버전을 확인합니다.

첫 번째, Hello Tensoflow 출력!

노드 생성 및 출력

이때, 노드의 정보 출력과 노드의 값(value)출력 차이를 주목

여기까지 캡처이고 밑에 실제 코드를 삽입해 두었습니다.

코드 마다 적힌 주석(comments)을 통해 학습바랍니다.

최종 코드

#tensor flow import 
import tensorflow as tf

tf.__version__

#hello 노드 생성
hello = tf.constant("Hello Tensorflow")

#실행을 위한 세션 생성 (Session 대문자 주의)
sess = tf.Session()

#세션 run함수로 hello 노드 value 출력
print(sess.run(hello))



#computational graph

# 1. 그래프 만들기(노드들 생성)
node1 = tf.constant(3.0, tf.float32, name='node1') #value ==  3.0 , type == tf.float32, name == 'node1'
node2 = tf.constant(2.0)
node3 = tf.add(node1, node2) #node3 = node1 + node2 

print(node1, node2) #node1, node2의 정보 출력
print(node3) #node3의 정보 출력

print("------------------------")

sess = tf.Session() #실행을 위한 세션 생성

print(sess.run([node1, node2])) #[node1, node2] 배열을 출력
print(sess.run(node3))



#tensor?
#다차원 어레이의 일반화(the n-dimensional abstraction of matrices)
#아무 차원이나 갖을 수 있는 값들의 집합
#(A tensor consists of a set of primitive values shaped into an array of any number of dimensions. ) 

#tensor를 할당을 위한 placeholder 선언
a = tf.placeholder(tf.float32) #type == tf.float32
b = tf.placeholder(tf.float32) #type == tf.float32

add_operation = tf.add(a, b) #변수 a, b의 add() operation 생성

#a, b의 variable생성

var1 = { a : 3, b : 4 } #a = 3, b =4
var2 = { a : 3.5, b : 4.5 } #a = 3.5, b =4.5
var3 = { a : [3.3, 1.1], b : [1.1, 2.2] } #a 배열 [3.3, 1.1], b 배열 [3.3, 1.1]  assign

sess = tf.Session() #실행을 위한 세션 생성

#add_operation에 feed_dict를 이용하여, 
#placeholder로 선언한 변수에 적용된 tensor들을 매핑
#이를 출력
print(sess.run(add_operation, feed_dict = var1))
print(sess.run(add_operation, feed_dict = var2))
print(sess.run(add_operation, feed_dict = var3))

아나콘다 및 주피터노트북 환경설정

mac os을 기준으로 설정(Windows환경도 같은 설정방식)

anaconda & jupyter notebook setup

based on MAC OS(same the Windows OS setup )

1. 아나콘다 사이트 접속 및 다운로드

 access Anaconda web site & download

(https://www.anaconda.com/download/)

2. 아나콘다 설치파일 실행 execute Anaconda setup file 

3. 아나콘다 네비게이터실행 execute Anaconda navigator

4. Environment에서 base(host) 실행버튼 클릭 & Open Terminal 클릭 click 'base(host)' on Environment,  click 'Open Terminal' 

py-project 라는 임의의 디렉토리를 만들어서, 해당 디렉토리도 이동 후, 

아나콘다를 위한 개발 환경을 생성한다.

Proceed ([y]/n) ? Y를 입력 후 진행

py-env(아나콘다를 위한 환경) 활성화

 아나콘다 버전 확인 후, 텐서플로우 설치

Proceed ([y]/n) ? Y를 입력 후 진행

아나콘다를 위한 커널설정

아나콘다 라이브러리를 주피터노트북에서 사용하기 위해,

"python(tf)"라는 새로운 노트북 지정

주피터노트북 실행

최종 콘솔 명령어

conda create -n "env-name"

conda activate "env-name"

conda install tensorflow

conda install ipykernel

python -m ipykernel install --user --name py-env --display-name "python(tf)"

jupyter notebook