어떤 값 이상이면 activate하는 Activation function 이 존재합니다.



그렇다면 3-level 은 어떻게 할까요?


이런경우에 맨 앞부분을 Input과 관련되었으므로 input layer 마지막은 Output layer 가운데는 Hidden layer 라고 합니다.





그러나 한개 한것보다 안좋은 성능이 나왔습니다.

왜 이런 문제가 발생할까요?


2단, 3단 을 풀 때는 잘 풀리던게 9단 10 단 부터는 문제가 발생한 것입니다.

그 이유는 무엇일까요?


항상 sigmoid 함수를 통과하기 때문에 0과 1사이 값만 나오고

chain 을 거칠 때마다 0.01 * 0.01 * 0.03 처럼 0에 점점 가까워집니다.

따라서 처음의 입력이 level 이 높아질 수록 영향이 낮아지는것입니다.


Vanishing gradient로 인해서 2차 winter 에 진입하게됩니다. 


sigmoid 함수를 잘못쓴거같아. 이 함수에서는 항상 1보다 작은값이므로 점점 작아질 수밖에없다.

1보다 작지 않도록 해보자!



ReLU : Rectified Linear Unit

더 이상 sigmoid를 사용하지 않는것이 좋습니다.


그래도 마지막의 출력은 0~1사이의 값이 나와야하므로 이때만 sigmoid함수를 씁니다.



이렇게하면 Works very well .


cost function 도 잘 감소되는 것을 알 수있었습니다.




다음과같은 함수들이 있습니다.


RELU 가 나쁘지않은 성과를 보여준다는것을 알 수있습니다!

sigmoid 는 굳이 쓸필요가 없겠죠?

인류의 Ultimate dream : thinking machine  을 만드는 것.

처음에 뇌가 굉장히 복잡하게 연결된 것을 보고 놀랐지만 그 단위인 뉴런이 생각보다 너무 단순하였습니다.

어떤 input 이 있고 그 input 에 weight 를 곱한것들의  sum 이 일어난다. 어떤 bias 가 더해지고 그 값이 일정 값 이상이라면 활성화가 된다.



따라서 이것을 한번 구현해보았습니다.


output 은 1 또는 0 입니다.


당시의 인공지능을 구현하고 많은 관심을 불러 일으켰습니다.

But there are many Fasle Promises

it expects will be able to walk, talk, see, write, reproduce itself an be conscious of its existence


the problem is AND/OR problem : linearly separable

but XOR graph is different.

there are no way that make a line to separate + from -.



여러개를 합치면 할 수있다는 것을 증명했다! 그러나 w,b 를 학습을 할 수없다.

"No one on earth had found a viable way to train"

그렇게 할 수없다고 생각하던 중 w,b 를 학습방법을 해결했습니다.


이 방법을 제안했지만 처음에는 외면당했습니다. but atmosphere is cold.

Hinton rediscover the theory.

so complicated algorithm included xor is possible .



신경이 한번에 활성되지않고 부분적으로 활성화 된다는것을 발견했습니다!

동시에 그림 전체를 보는것이아니라 일부를 담당하고 그것들이 나중에 조합되는것이 아닐까?라는 생각으로  cnn 을 개발했습니다.


책을 읽어들이는 기계, 자동주행 자동차 등을 개발됬습니다.

터미너이터에서도 등장할정도 였습니다.


그러나 또다른 Big problem 에 봉착하였습니다.


Back propagation 을 할 때 Many layers에서 성능이 더 떨어졌습니다.

Neural network 보다 더 간단한 알고리즘들이 더 잘 동작되었습니다. (SVM , RandomForest 등)

사람들은 두번째 문제에 그럼그렇지~ 라는 반응을 보였죠.



이 단체는 당장 neural network 활용되지않아도 연구를 많이 지원해주곤 했습니다. canada 출신 AI가 그래서 많습니다.

"Everyone else was doing something different"




이 CIFAR 에서 Breakthrough 를 발견했습니다.

초기값을 주고 학습을 시켰는데 이 초기값을 잘주게 된다면 학습할 수있다!

초기값을 잘 주는 것이 중요해! 라는 것을 2006에 논문으로 입증하였습니다.

그리고 복잡한 신경망도 구현할 수 있다.



imagenet 이라는 이미지를 판별하는 대회를합니다.

alexnet 이라는 박사과정 연구생이 26.2 -> 15.3 으로 오류율을 줄여서 관심을 갖게되었습니다.

현재 deep learning은 3%로 줄어들었습니다.

Human은 5% 로 딥러닝이 뛰어넘었습니다.


그림을 설명할 수도 있게되었습니다.


어떤 API를 써야하는지 등등 을 판별하는 연구를 하고있습니다.

25%의 정확도를 딥러닝을 이용하여 65%까지 올라갔습니다.


90% 까지 사람의 말을 알아들을 수 있게되었습니다.

또한 알파고는 사람의 대표를 이겼습니다.



지금까지 안됬던 이유 네가지를 hinton 이 발표했습니다.

이건 다음시간에 알아보도록 합시다.


딥러닝 활용 : 

자막을 사람이 치지않고 받아들입니다.

페이스북 필터링을 해줍니다.

NEFLIX , Amazon 등이 있습니다.

옷가게만 해도 어떤물건을 진열해야할 지 딥러닝으로 판단할 수 있게됩니다.


지금 시작해도 세계적인 전문가가 될 수있습니다.

늦지않았습니다. 실용적으로 써보고 싶다 하시는 분들도 90%이상의 정확도를 가지고있어 여러분의 삶을 도울 수준이 되었습니다.

재미있는 분야입니다!

어떤 모델이 얼마나 훌륭한가? 성공적으로 예측할 수 있을까? 를 어떻게 평가할까요?


앞부분을 Training data set 뒷부분을 test set 이라고 합니다.

test set 은 숨겨놓고 training set으로 학습을 시킵니다.

학습이 끝난 뒤에 test set 으로 예측값과 실제값을 비교해서 평가를 하면 됩니다.

교과서와 실전문제(모의고사) 라고 생각하시면 됩니다.


일반적으로 Training set으로 학습을 시킨 후에 Validation set 으로 이 중에 어떤값이 좋을까 튜닝을 하는 것입니다.

완료되면 Testing은 마지막에 시험본다고 생각하시면 됩니다.




Online learning 이라는 학습법도 있습니다.

100만의 data가 있다면 여러개로 잘라서 따로 학습시킵니다.

추가로 10만개가 들어온다면 새로할 필요없이 그대로 학습 시킬 수 있습니다.





MINIST Dataset 에서 숫자를 컴퓨터가 인식시키는것입니다.

여기서도 Training set과 그에 대한 답인 labels 그리고 test set, test able 등으로 나누어져 있습니다.



Accuracy

실제 데이터 값과 모델이 예측한 값의 정확성을 평가합니다.

분야에 따라 다르지만 보통 이미지분야는 95%~를 넘고있습니다.


Logistic regression 에서

H(X) = WX 에서 return  하는값이 100, 200 등이 나올 수 있기 때문에 0이나 1을 필요로하는 Binary classification 에는

적합하지 않았습니다. 따라서 0~1사이의 값으로 압축할 수 있는 함수 g(z) 가 필요로 했습니다.

따라서 알아낸 sigmoid 함수(logistic 이라고도 함)를 도입했습니다.


둘을 구분하는 선을 찾는 것! 이 궁극적인 목표입니다


이 아이디어를 Multinomial classification 으로 가져와 봅시다!



이러한 Hyperplace 가 생성될 텐데요.


각각의 classify에 대하여 Hypothesis 가 생길 것입니다.

이것은 다음과같이 3가지의 Classification 으로 나뉘어 집니다.





행렬로써 표기하면 다음과같은 3가지의 식이 나오고요.



이걸 한번의 연산으로 바꿔주기 위해서 3x3 행렬을 만들어주면 다음과 같습니다.






이것을 모두다 합했을 때 1이 되도록 하는 함수를 만들자!





가장 큰값을 1로하고 나머지는 0으로 바꿔줍니다.

이것을 ONE_HOT Encoding 이라고 하며 argmax를 사용하면 구현가능합니다.



Y = L = B 인 실제값 이라고 하고

Y_hat = B 인 예측성공한 값 -> Cost 값이 작도록

Y_hat = A 인 예측실패한 값 -> Cost 값이 크도록



사실 상 두개의 Cost function 은 동일하다고 할 수있는데요?

잘 생각해보시면 이유를 아실 것입니다.



이론시간 에 배웠던 Logistic Regression 을 한번더 살펴보면 다음과 같습니다!


아직 X의 크기가 정해지지 않았기 때문에 len을 입력합니다.


data 는 다음과 같습니다.

이 때 X0를 모두 1로 해준 이유는 b를 제거하기 위해서입니다.



코드는 다음과 같습니다. 


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
import tensorflow as tf
import numpy as np
 
xy = np.loadtxt('train.txt',unpack=True, dtype = 'float32')
x_data = xy[0:-1]
y_data = xy[-1];
= tf.placeholder(tf.float32)
= tf.placeholder(tf.float32)
 
= tf.Variable(tf.random_uniform([1,len(x_data)],-1.0,1.0))
 
#Our hypothesis
= tf.matmul(W, X)
hypothesis = tf.div(1.1.+tf.exp(-h))
#cost function
cost = -tf.reduce_mean(Y*tf.log(hypothesis)) - (1-Y)*tf.log(1-hypothesis)
 
#Minimize
= tf.Variable(0.1)    #Learning rate, alpha
optimizer = tf.train.GradientDescentOptimizer(a)
train = optimizer.minimize(cost)
 
#Before starting, initialize the variables. We will 'run' this first.
init = tf.initialize_all_variables()
 
#Launch the graph.
sess = tf.Session()
sess.run(init)
 
#Fit the line.
for step in xrange(2001):
    sess.run(train, feed_dict = {X:x_data, Y:y_data})
    if step % 20 ==0:
        print step, sess.run(cost, feed_dict={X:x_data, Y:y_data}), sess.run(W)
 
print '---------------------------------------'
#study hour attendance
print sess.run(hypothesis, feed_dict = {X:[[1],[2],[2]]})>0.5
print sess.run(hypothesis, feed_dict={X:[[1],[5],[5]]})>0.5
 
print sess.run(hypothesis, feed_dict = {X:[[11], [43] ,[35]]})>0.5
 
cs


이 트레이닝 data 를 토대로 Ask to ML 을 해보도록 하겠습니다.

x1 = 5, x2 = 3 인사람이 통과할 수 있을까요?


1
2
3
4
5
6
7
print '---------------------------------------'
#study hour attendance
print sess.run(hypothesis, feed_dict = {X:[[1],[2],[2]]})>0.5
print sess.run(hypothesis, feed_dict={X:[[1],[5],[5]]})>0.5
 
print sess.run(hypothesis, feed_dict = {X:[[1,1][4,3],[3,5]]})>0.5
 
cs


다음과 같이 한명을 물어볼 수도, 벡터를 통해서 여러명을 물어볼 수도 있습니다!



이렇게 결과를 알 수 있습니다!

우리의 궁극적인목표는 deep learning 과 neural network 인데 이 알고리즘은

중요한 component 이므로 잘 이해하는 것이 중요합니다!


그럼 복습의 의미로 linear regression 을 짧게 살펴볼까요?


cost : 우리가 세운 가설과 실제 값의 차이이며

이 cost 를 최소화하는 알고리즘이 Gradient decent 알고리즘 입니다.

Gradient decent 알고리즘은 기울기를 작게하는 방향으로 한발짝씩 움직여 기울기가 0인부분에 수렴하도록

하는 것입니다. 이 때의 한발짝을 learning rate 라고 부릅니다.

이 기울기는 Cost function 을 미분하는 것입니다.



두개로 분류하는 것이라고 생각하시면됩니다.

Facebook 에서 어떤 타임라인은 보여주고 어떤것은 보여주지 말자 이런것을 판단하는 알고리즘이 필요할 것입니다.

뭔가 카드거래가 기존 패턴과 다르다? 라는 것을 판단하여 도난여부도 판단합니다.




따라서 두가지를 1 or 0 으로 나타내면 됩니다.


요즘의 주식예측은 이미 머신러닝이 사람을 뛰어넘었다고 합니다.



이번에는 공부량에 대한 시험 통과여부를 판단하는 머신러닝을 생각해봅시다.



이 때 생각해볼 문제점이 있습니다.

만약에 50시간 공부해서 합격한사람의 data가 입력되었을 때 그래프의 기울기가 기울어 질것입니다.

그렇다면 합/불의 기준선도 급격히 변화할 것입니다.



또 다른 문제점은 반드시 0과 1사이의 값이 나와야합니다.

그러나 0보다 작거나 1보다 큰 값이 나올 수 있습니다.

H(x) = Wx + b  에서 x = [1,2,5,10,11] , W = 0.5 , b = 0 인 data 를 학습시킨 후

x = 100 인 data가 들어와 값이 50 인 모델이 생길 수있다.


따라서 Linear Regression 이 간단하고 좋지만 이것을 0~1 사이의 값으로 압축하는 함수를 도입했습니다.


이 함수는 sigmoid 라고 불립니다. z 가 무한히 커진다면 1로 수렴하고 작아질수록 0에 수렴합니다!

따라서 이 함수의 특성을 이용해서 Logistic Hypothesis 를 구현합니다.



이제 남은 일은 cost function과 gradient decent 를 구현하면 됩니다.

원래의 Cost function 은 다음과 같았습니다.


이번에는 H(X)에 sigmoid 함수를 도입해보겠습니다.

원래는 H(X)가 Linear 하므로 cost function 의 모양은 밥그릇 모양이 되겠지만 이젠

1차원이아니므로 다음처럼 구불구불한 모양의 cost function이 주어질 것입니다.


이 때 문제점은 우리가 지금까지 사용한 gradient algorithm을 사용하면

시작점이 다른경우 결과가 달라질 수 있게됩니다.

우리가 찾고자하는 것은 Global minimum 인데 찾을 수 없게될 수 있습니다.


따라서 cost 함수를 바꿔야합니다.


왜 이렇게 할까요?

cost 함수의 정의는 실제의 값과 예측한값이 같을 수록 작아지고 다를 수록 커지는 것입니다.

따라서 이 cost 를 최소화 하는것인데, 

y = 1 인 case 를 생각해봅시다. 우리의 예측한값도 H(x) = 1 로 일치했다고 하면 cost(1) = 0 에 가깝게 될것입니다.

이번에는 가설이 H(x) = 0 으로 틀렸다고 하면 cost는 무한대로 수렴하게 됩니다.

y = 0 인 case 에서는 우리의 예측이 H(x) = 0 으로 일치하면 cost = 0 으로 수렴할것입니다.

예측이 H(X) = 1 로 실패했다면 cost 는 무한대로 커집니다



따라서 요약하면 다음과같습니다.

이 때 if condition 이 있다면 코딩하기 불편하므로 제거하기 위해서 맨 마지막과 같은 식을 쓰곤 합니다!


그다음 단계는 이제 Minimize cost하기 입니다.



이 미분한 값을 이용해서 Gradient decent algorithm 을 구현하면 됩니다.




지난 이론시간에 Multivariable example 을 이용한 linear regression을 학습했습니다.

좋은 성과를 내기 위해서는 적절한 feature 을 뽑아내는게 중요하다고 했었죠.

어려운건 없고 단지 feature 가 여러개일 뿐입니다.

두개의 weight를 학습해야 한다고 해봅시다.



코드는 다음과 같이 할 수있겠죠?


이런 방식으로 여러개의 W에 대한 linear regression 이 가능해집니다!


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
import tensorflow as tf
 
x1_data = [1,0,3,0,5]
x2_data = [0,2,0,4,0]
y_data = [1,2,3,4,5]
 
#Try to find values for W and b that compute y_data = W * x_data + b
# (We know that W should be 1 and b 0, but Tensorflow will)
# figure that our for us.)
 
W1 = tf.Variable(tf.random_uniform([1],-1.0,1.0))
W2 = tf.Variable(tf.random_uniform([1],-1.0,1.0))
 
= tf.Variable(tf.random_uniform([1],-1.0,1.0))
 
#Our hypothesis
hypothesis = W1 * x1_data + W2*x2_data +b
 
#Simplified cost function
cost = tf.reduce_mean(tf.square(hypothesis - y_data))
 
#Minimize
= tf.Variable(0.1)  # Learning rate, alpha
optimizer = tf.train.GradientDescentOptimizer(a)
train = optimizer.minimize(cost)
 
#Before starting, initialize the variables. We will 'run' this first.
init = tf.initialize_all_variables()
 
#Launch the graph.
sess = tf.Session()
sess.run(init)
 
#Fit the line.
for step in xrange(2001):
    sess.run(train)
    if step % 20 == 0:
    print step, sess.run(cost), sess.run(W1), sess.run(W2), sess.run(b)
cs


해당 코드를 실행하면 처음에는 다음과 같이 random 한 값이 주어집니다.



하지만 결국 X1 = 1, X2 = 1, b = 0 에 수렴하는것 알 수 있습니다.




이번에는 이 복잡한 수식을 Matrix 로 표현해볼까요?



 W data 를 1x2 배열로 구현한다!



matmul 은 두 행렬의 곱을 나타낸다.


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
import tensorflow as tf
x_data = [[0.2.0.4.,0.],
          [1.0.3.0.5.]]
y_data = [1234,5]
 
# Try to find values for W
= tf.Variable(tf.random_uniform([1,2],-1.0,1.0))
= tf.Variable(tf.random_uniform([1],-1.0,1.0))
 
#our hypothesis
# matrix multiplication
hypothesis = tf.matmul(W, x_data) + b
# Simplified cost function
cost = tf.reduce_mean(tf.square(hypothesis - y_data))
 
#Minimize
= tf.Variable(0.1# Learning rate, alpha
optimizer = tf.train.GradientDescentOptimizer(a)
train = optimizer.minimize(cost)
 
#Before starting, initialize the variables. We will ' run' this first.
init = tf.initialize_all_variables()
 
#Launch the graph.
sess = tf.Session()
sess.run(init)
 
#Fit the line.
for step in xrange(2001):
    sess.run(train)
    if step % 20 == 0:
        print step, sess.run(cost), sess.run(W), sess.run(b)
cs

실행하면 다음과 같이 이차원의 형태로 출력되는 것을 알 수있다.


동일하게 3개의 변수를 갖도록 해봅시다.

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
import tensorflow as tf
x_data = [[1.1.1.1.,1.],
          [0.2.0.4.0.],
          [1.0.3.0.5.]]
y_data = [1234,5]
 
# Try to find values for W
= tf.Variable(tf.random_uniform([1,3],-1.0,1.0))
 
#our hypothesis
# matrix multiplication
hypothesis = tf.matmul(W, x_data)
# Simplified cost function
cost = tf.reduce_mean(tf.square(hypothesis - y_data))
 
#Minimize
= tf.Variable(0.1# Learning rate, alpha
optimizer = tf.train.GradientDescentOptimizer(a)
train = optimizer.minimize(cost)
 
#Before starting, initialize the variables. We will ' run' this first.
init = tf.initialize_all_variables()
 
#Launch the graph.
sess = tf.Session()
sess.run(init)
 
#Fit the line.
for step in xrange(2001):
    sess.run(train)
    if step % 20 == 0:
        print step, sess.run(cost), sess.run(W)
cs


실행 결과는 다음과 같이 되겠죠?


마지막으로 Loading data from file 을 배워봅시다.

1
2
3
4
5
6
import tensorflow as tf
import numpy as np
xy = np.loadtxt('train.txt', unpack = True, dtype = 'float32')
x_data = xy[0:-1]
y_data = xy[-1];
 
cs


다음과 같이 하면 텍스트파일에서 읽어올 수 있습니다.

C 의 freopen과 같다고 할 수가 있겠죠?

상수를 제거함으로써 hypothesis 를 다음과 같이 간략해보자.




matplotlib은 그래프를 출력하기위한 library 이다.

x축은 W에 로, y 축은 cost 로한다.


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
 
import tensorflow as tf
import pylab as plt
import matplotlib.pyplot as plt
#tf Graph Input
= [1.,2.,3.]
= [1.,2.,3.]
= n_samples = len(X)
 
#Set model weights
= tf.placeholder(tf.float32)
 
#Construct a linear model
hypothesis = tf.mul(X,W)
 
#Cost function
cost = tf.reduce_sum(tf.pow(hypothesis-Y,2))/(m)
 
#Initializing the variables
init = tf.global_variables_initializer()
 
#For graphs
W_val = []
cost_val = []
 
#Launch the graph
sess = tf.Session()
sess.run(init)
for i in range(-30,50):
    print i*0.1, sess.run(cost, feed_dict={W: i*0.1})
    W_val.append(i*0.1)
    cost_val.append(sess.run(cost,feed_dict={W: i*0.1}))
 
#Graphic display
plt.plot(W_val, cost_val, 'ro')
plt.ylabel('Cost')
plt.xlabel('W')
plt.show()
 
 
cs


실행하면 다음과 같은 그래프가 실행된다.

cost 가 최소가되는 점이 생기고 이점에서의 기울기가 0 임을 알 수 있다.





이제 descent algorithm에 의해서 이 때의 W값을 구해보자.






는 어느정도 내려가는 지 정도를 나타냄

기울기가 +이면 W를 더작게 하고 -이면 W를 증가시켜 기울기가 0 인부분을 구한다.



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
import tensorflow as tf
x_data = [1.,2.,3.]
y_data = [1.,2.,3.]
 
#Try to find values for W and b that compute y_Data
#  = W * x_data  = W * x_data + b
# (We know that W should be 1 and b 0, but Tensorflow will
# figure that out for us.)
 
= tf.Variable(tf.random_uniform([1],-10.0,10.0))
 
= tf.placeholder(tf.float32)
= tf.placeholder(tf.float32)
 
# Our hypothesis
hypothesis = W * X
 
# Simplified cost function
cost = tf.reduce_sum(tf.square(hypothesis - Y))
 
#Minimize
descent = W- tf.mul(0.1, tf.reduce_mean(tf.mul((tf.mul(W,X)-Y),X)))
update = W.assign(descent)
# Before startin, initialize the variables. We wiil run this first.
init = tf.initialize_all_variables()
 
#For graphs
W_val = []
cost_val = []
 
#Launch the graph
sess = tf.Session()
sess.run(init)
for step in xrange(100):
  sess.run(update, feed_dict = {X:x_data, Y:y_data})
  print step,sess.run(cost, feed_dict = {X:x_data, Y:y_data}),sess.run(W)
cs



실행하면 cost 는 0 W는 1에 수렴함을 알 수있다!

지난시간에 학습했던 linear regression을 실습해보겠습니다!

우리의 최종목표는 cost 값을  minimize 하는 W,b 값을 구하는 것입니다.



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
# -*- coding: utf-8 -*-
# 한글주석 사용을 위한 명령어
import tensorflow as tf
 
x_data = [1,2,3]
y_data = [1,2,3]
#training data입니다
 
= tf.Variable(tf.random_uniform([1],-1.0,1.0))
= tf.Variable(tf.random_uniform([1],-1.0,1.0))
 
#variable 로 지정해야 나중에  업데이트할 수 있다
 
hypothesis = W * x_data + b
 
cost = tf.reduce_mean(tf.square(hypothesis - y_data))
#reduce_mean 은 평균을 구하는 것
#지금은 계산하지않고 operation 만 설정해놓는다
 
a  = tf.Variable(0.1)
optimizer = tf.train.GradientDescentOptimizer(a)
train = optimizer.minimize(cost)
#위 세줄은 블랙박스로써 minimize 를 사용하는구나 라고 알아만두자
init = tf.initialize_all_variables()
#init 를 Session을 만든 다음에 실행을 한번 시켜줘야 합니다 안하면 에러발생
sess = tf.Session()
sess.run(init)
 
for step in xrange(2001):
    sess.run(train)
    if step % 20 == 0:
        print step, sess.run(cost), sess.run(W), sess.run(b)
        #각 스텝, cost, W, b 값을 20번의 step마다 출력합니다
        # cost는 0에 W 는 1에 b는 0에 수렴하는 것을 알 수있다
cs



placeholder 변수에 값을 넣어주지 않고 타입만 정해 둔 후 실행 직전에 값을 대입한다.

이전에는 placeholder 를 쓰지않고 linear regression 을 구현했는데 placeholder를 사용하면 이제는 모델을 재활용 할 수있습니다!

전에 학습했던 model 을 이용해서 X:5 일 때의 Y 값을 구하고싶다면 이 때 placeholder 라면 재사용이 가능하다!


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
# -*- coding: utf-8 -*-
# 한글주석 사용을 위한 명령어
import tensorflow as tf
 
x_data = [1.,2.,3.]
y_data = [1.,2.,3.]
 
= tf.Variable(tf.random_uniform([1],-1.0,1.0))
= tf.Variable(tf.random_uniform([1],-1.0,1.0))
 
#variable 로 지정하야 나중에 업데이트할 수 있다
= tf.placeholder(tf.float32)
= tf.placeholder(tf.float32)
# 아직 x,y 를 정하지 않고 실행 시에 지정한다
hypothesis = W * X + b
 
cost = tf.reduce_mean(tf.square(hypothesis - Y))
#reduce_mean 은 평균을 구하는 것
#지금은 계산하지않고 operation 만 설정해놓는다
 
a  = tf.Variable(0.1)
optimizer = tf.train.GradientDescentOptimizer(a)
train = optimizer.minimize(cost)
#위 세줄은 블랙박스로써 minimize 를 사용하는구나 라고 알아만두자
init = tf.initialize_all_variables()
#init 를 Session을 만든 다음에 실행을 한번 시켜줘야 합니다 안하면 에러발생
sess = tf.Session()
sess.run(init)
 
for step in xrange(2001):
    sess.run(train, feed_dict = {X:x_data, Y :y_data})
    if step % 20 == 0:
        print step, sess.run(cost, feed_dict={X:x_data, Y:y_data}), sess.run(W), sess.run(b)
        #각 스텝, cost, W, b 값을 20번의 step마다 출력합니다
        # cost는 0에 W 는 1에 b는 0에 수렴하는 것을 알 수있다
 
print sess.run(hypothesis, feed_dict = {X:5})
print sess.run(hypothesis, feed_dict={X:2.5})
cs

이전 training data를 바탕으로  X : 2.5 , 5 일 때에 대한 Y값을 구할 수 있었습니다!


TensorFlow

* TensorFlow is an open source software library for numerical computation using data flow graphs.

* Python!


What is a data Flow Graph?

* Nodes in the graph represent mathematical operations (수학적 연산)

* Edges represent the multidimensional data arrays(행렬, 벡터) communicated between them.

노드가 operation 이고 Edge 가 data(tensor) 이다.



따라서 이 그래프를 이용함으로써

 1. 딥러닝 이나 linear regression 등 많은 작업 수행가능하게하고

 2. 각 노드들이 여러개의 cpu로 분산될 수 있다는 장점도 있습니다.

 그러므로 딥러닝, 머신러닝에 적당한 framework입니다!


Installation(mac os 기준입니다!)

맥북에는 기본적으로 python이 설치되어있지만 tensorflow를 바로 설치하기에는 에러가 자주 발생하는 것같습니다.

해매던 중 정식홈페이지의 설치방법을 자세히 읽어본 후 설치를 완료 했습니다!

(처음 그냥 설치 할 때 numpy? 관련 에러가 발생했습니다)

바로  virtualenv를 설치해야 하는것 인데요. 이 가상환경을 설치해야 정상적으로 설치됩니다.

무겁지않고 매우 간단한 설치입니다!



https://www.tensorflow.org/get_started/os_setup 

이 사이트에 들어가서 차례대로 하면됩니다! 이 때 바로 tensorflow를 설치하지마시고 virtualenv 를 클릭하여

절차대로 진행하시면 virtualenv가 active되고 (venv)라는 문구가 뜹니다! 

이 문구가 앞에 있는 상태에서 나머지 tensorflow를 설치해주시면 마무리됩니다.


처음에 이 virtualenv 를 설치하지 않음으로써 많은 에러들이 발생하여 하루종일 애먹었습니다!


자 설치가 완료되었으면 기본 코드를 실행시켜볼까요!?


tensorflow 기본코드

1
2
3
4
5
6
7
8
9
10
11
12
13
import tensorflow as tf
 
hellow = tf.constant('Hello, TensorFlow!')
// 이거 자체도 operator 가된다 (node)
 
print hello
//상수값이 나오지않고 Tensor 라는 것이 나온다.
 
sess = tf.Session()
 
print sess.run(hello)
//node를 실행시키는 것, 실행이 되야 의미를 갖는것.
 




1
2
3
4
5
6
7
8
9
10
11
12
13
14
import tensorflow as tf
 
sess  = tf.Session()
= tf.constant(2)
= tf.constant(3)
 
= a+b
//Everything is operation!
print c
//실행이 아니라 노드의 형태만 출력됌.
 
print sess.run(c)
//이것이 실행.
 
cs



1
2
3
4
5
6
7
8
9
import tensorflow as tf
sess = tf.Session()
 
= tf.constant(2)
= tf.constant(3)
 
= a+b
print c
print sess.run(c)
cs



Basic operations

1
2
3
4
5
6
7
8
9
10
import tensorflow as tf
 
= tf.constant(2)
= tf.constant(3)
 
with tf.Session() as less:
print "a=2, b=3"
print "Addition with c constants : %i " %sess.run(a+b)
print "Multiplication with constants : %i" %sess.run(a*b)
 
cs


Placeholder

1
2
3
4
5
6
7
8
9
10
11
12
import tensorflow as tf
 
= tf.placeholder(tf.int16)
= tf.placeholder(tf.int16)
 
add = tf.add(a,b)
mul = tf.mul(a,b)
 
with tf.Session() as less:
print "Addition with variables: %i" %sess.run(add, feed_dict = {a: 2,b :3})
print "Multiplication with variables: %i" %sess.run(mum, feed_dict= {a: 2,b: 3})
cs


a*b 라는 model 을 정의할 때 데이타 타입만 정해주고 실행 시킬 때에 값을 넘겨준다.

함수가 아님에도 실행시점에서 값을 바꾸게 하는 powerful한 기능.


이상 tensorflow 를 설치하고 기본코드를 실행시켜 보았습니다.



+ Recent posts