Chikong

Tensorflow : Tensor를 흘려보내면서 데이터를 처리하는 라이브러리

3   # 랭크 0 Tensor; shpae[ ] ==> 스칼라
[1,2,3]   # 랭크 1 Tensor; shpae[ 3 ] ==> 벡터
[[1,2,3],[4,5,6]]   # 랭크 2 Tensor; shpae[ 2,3 ] ==> 행렬
[[[1,2,3]],[[4,5,6]]]   # 랭크 3 Tensor; shpae[ 2,1,3 ] ==> Tensor

Tensorflow를 이용해 프로그램 작성시 순서

1. 그래프 생성

2. 그래프 실행

노드(node) :연산, 변수, 상수 등을 정의

엣지(edge) : 텐서를 주고받으며 계산 수행

==> 실행하기 위해서 Tensorflow 의 Session() 을 사용한다.

예제1

tf.constant  #상수텐서를 의미

# tf.constant 의 인자
tf.constant(value , dtype=' ' , shpae=' ' , name = " " )

# ex1)
node = tf.constant(1.0,shpae=[2,3]) # [[1,1,1],[1,1,1]]

3-2 Placeholder ==> 임의의 값을 받아 임의의 값을 출력

tf.placeholder(dtype, shape = [ ] , name = " " )
# 값을 입력하기 위해서는 feed_dict를 사용
feed_dict = { a : ____ , b : _____ }

예제2

3.3.1 선형회귀 및 경사하강법

회귀 : 어떤 실수값 예측 ex) 출산률, 주식시장 변동 등등..

분류 : 어떤 이산값 예측 ex) 이미지분류, 선호하는 정당 예측 등등..

* 머신러닝의 과정

① 학습하고자 하는 가설( Hx )을 수학적 표현식으로   - Hypothesis

② 가설의 성능을 측정할 수 있는 손실함수 정의         - Loss function

③ 손실함수를 최소화 할수 있는 학습 알고리즘 설계    - Minimize

가설  H = Wx + b

Loss 함수 1/2 ∑ (예측값 - 실제값 )^2  # reduce_mean ( tf.scare (가설 - y 값 ))

피라미터의 값을 적절히 업데이트 (Optimizer) --> 경사하강법 ( Gradient Descent )

# 경사 하강법 ( Gradient Descent )

- 현재 스텝의 피라미터에서 손실함수(cost, loss function) 의 미분값에 learning rate를 곱한 만큼 빼서 다음 스템의 피라미터 값으로 지정

* Loss function의 미분값이 크면 하나의 스템에서 피라미터 많이 업데이트

* Loss function의 미분값이 작으면 적게 업데이트

* learning rate 값이 크면 많이, 적으면 조금씩 업데이트 수행

3.3.2 선형회귀 알고리즘 구현 및 변수

#tf.Variable 함수의 인자 알아보기
tf.Variable(value = "__", trainable="True", name = "___")

# ex1)
w = tf.Variable(tf.random_normal([1])

예제3

tf.Variable로 초기화할수 있는 연산표

3.4 Tensorboard ( 텐서보드를 통한 시각화)

tf.summary.scalar('loss',loss) # 요약정보를 로그에 저장

merged = tf.summary.merge_all() # 모든 요약정보 병합 

tensorboard_write = tf.summary.Filewriter('./tensorboard_log',sess.graph)
# 요약정보를 저장할 폴더 경로 설정 , sess.graph를 통해 그래프 구조도 함께 저장

summary = sess.run(merged.feed_dict{x:__, y:__}
tensorboard_write.add_summary(summary,i)
# 매 스테마다 요약정보 값을 계산해서 저장

* 딥러닝 : 머신러닝을 깊게 쌓아올려 학습

1) 지도학습 : 정답데이터가 있는 상황에서 학습하는 알고리즘

                 ( x , y ) 한쌍의 데이터 ==> y 는 정답데이터

2) 비지도학습 : 정답없이 데이터의 특징만을 분류

                     ==> 보통 비지도학습 + 지도학습 형태로 사용

3) 강화학습 : Agent 가 주어진 환경에서 어떤 행동을 취하고 그에대한 보상 획득

2장. 인공지능 기술의 활용

1 ) 컴퓨터 비전 : 인간의 시각과 관련된 부분을 컴퓨터 알고리즘을 이용해 구현

                      ex) 이미지분류 , 물체검출 ==> 주로 CNN알고리즘 사용

2) 자연어 처리 : 인간의 언어와 같은 자연어로 표현된 언어를 학습

3) 음성인식 : 음성 데이터가 표현하는 문장을 학습

4) 게임 : 인공지능의 성능을 확인하기 위해 주로 개발

5) 생성 모델 : 학습데이터의 분포를 학습하여 학습한 분포로부터 새로운 데이터 생성

코드부

import tensorflow as tf 

#MNIST 데이터 다운로드 
from tensorflow.examples.tutorials.mnist import input_data 
mnist = input_data.read_data_sets("/tmp/data/",one_hot=True)

# 학습에 사용될 변수들 설정 
learning_rate = 0.001 
num_epochs = 30 
batch_size = 256 
displa_step = 1 
input_size = 784 
hidden1_size = 256 
hidden2_size = 256 
output_size = 10

#입력값과 출력값을 받기 위한 플레이스 홀더 설정 
x = tf.placeholder(tf.float32, shape = [None, input_size]) 
y = tf.placeholder(tf.float32, shape = [None, output_size])

ANN 모델에 사용될 각종 변수를 초기화 한다.

# ANN 모델 정의 
def build_ANN(x): 
    W1 = tf.Variable(tf.random_normal(shape = [input_size, hidden1_size])) 
    b1 = tf.Variable(tf.random_normal(shape = [hidden1_size])) 
    H1_output = tf.nn.relu(tf.matmul(x,W1) + b1) 
    W2 = tf.Variable(tf.random_normal(shape = [hidden1_size, hidden2_size])) 
    b2 = tf.Variable(tf.random_normal(shape = [hidden2_size])) 
    H2_output = tf.nn.relu(tf.matmul(H1_output,W2) + b2) 
    w_output = tf.Variable(tf.random_normal(shape = [hidden2_size, output_size])) 
    b_output = tf.Variable(tf.random_normal(shape = [output_size])) 
    logits = tf.matmul(H2_output,w_output) + b_output 
     
    return logits

# ANN 모델 선언 
predicted_value = build_ANN(x)

딥러닝의 개념은 여러 노드를 깊게 파고 드는 것이다.

따라서 weight 값과 bias 값을 여러층으로 ( 예제에서는 총 3층 ) 계산토록 한다.

이해하기 쉽게 하기 위하여..

weight 의 shape 값은 [입력값 , 출력값] 이라고 생각하자.. 그렇게 해야지만 이해가 된다

bias 의 shape값은 쉽게 생각하자. 각 노드를 이어주는 선으로 생각하면 이해가 잘될것이다. --> [ weight의 출력값 ]

Hypothesis 는 [ x * W + B ] 임을 기억!! ==> x 값에 대해 생각을 해 보았다. 

결국 가설(hypothesis) 은 입력값 * W + b 인데.. 왜 각 층마다 이전 노드의 hypothesis를 곱하는 걸까..

이유야 간단하다.

초기 Hypothesis 는 x 값에 의해 계산되는것이 맞고,

이후의 노드들은 W1 , B1 에 의해 가설이 재생성된다.

따라서 이후 가설에 대해서는 이전 가설의 값에 의해 계산되는것이 당연하다.

위처럼 이해하고 모델을 구성한다면 다음과 같을것이다.

#손실함수와 옵티마이저 정의
loss = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits_v2(logits = predicted_value, labels = y))
train_step = tf.train.AdamOptimizer(learning_rate = learning_rate).minimize(loss)

손실함수를 정의, 역시나 Softmax 의 Cross entropy 를 사용하며,

인자로는 ( 가설 , labels ) 인데..

labels 는 쉽게 말해 분류될 갯수를 나타내는것 같다. 따라서 y 값이 들어가게 된다.

Optimizer 를 정의한다.

여태까지 예제에서는 optimizer 로 Gradient 알고리즘을 사용했는데 갑자기 Adam 알고리즘을 사용했다.

무슨 차이인지는 더 공부를 해 봐야 겠지만 책에 설명에 의하면

Gradient 알고리즘은 0에 도달하면 더이상 파라미터를 업데이트 하지 않기 때문에 다른 종류의 알고리즘을 사용한다고 설명되어 있다.

제일 많이 사용되는 Optimizer 가 Adam 과 Gradient 인것 같다.

optimizer 의 인자는 ( 학습률(러닝레이트) ) 이며, 이의 최소값을 찾는것이므로 .minimize(loss) 를 덧붙인다.

# 세션을 열러 변수 초기화후 그래프 실행
with tf.Session() as sess:
    sess.run(tf.global_variables_initializer())
    
    for epoch in range(num_epochs):
        average_loss = 0.
        #전체배치 사이즈 불러오기
        total_batch = int(mnist.train.num_examples/batch_size)
        #모든 배치들에 대해서 최적화 수행
        for i in range(total_batch):
            batch_x, batch_y = mnist.train.next_batch(batch_size)
            #옵티마이저를 시행하고, 파라미터 업데이트 수행
            _, cost = sess.run([train_step,loss],feed_dict={x:batch_x, y:batch_y})
            #평균 소실 측정
            average_loss += cost / total_batch
            # 지정된 epoch마다 학습결과 출력
        if epoch % displa_step == 0:
            print("Step : %d\tLoss : %f"%((epoch+1),average_loss))
        
    #테스트 데이터를 이용해 학습모델의 정확도 출력
    correct_prediction = tf.equal(tf.argmax(predicted_value,1),tf.argmax(y,1))
    acc = tf.reduce_mean(tf.cast(correct_prediction,"float"))
    print("정확도 : %f"%(acc.eval(feed_dict={x:mnist.test.images, y:mnist.test.labels})))

실질적으로 실행을 한다.

출력부

Step : 1	Loss : 242.606340
Step : 2	Loss : 60.441268
Step : 3	Loss : 40.113990
Step : 4	Loss : 29.587428
Step : 5	Loss : 23.835133
Step : 6	Loss : 18.871365
Step : 7	Loss : 14.436662
Step : 8	Loss : 12.715328
Step : 9	Loss : 10.469781
Step : 10	Loss : 8.280394
Step : 11	Loss : 6.889524
Step : 12	Loss : 5.830906
Step : 13	Loss : 4.759171
Step : 14	Loss : 4.020574
Step : 15	Loss : 3.047320
Step : 16	Loss : 2.572009
Step : 17	Loss : 2.120104
Step : 18	Loss : 1.746665
Step : 19	Loss : 1.404878
Step : 20	Loss : 1.175315
Step : 21	Loss : 0.874911
Step : 22	Loss : 0.636827
Step : 23	Loss : 0.526886
Step : 24	Loss : 0.428142
Step : 25	Loss : 0.361234
Step : 26	Loss : 0.304521
Step : 27	Loss : 0.272772
Step : 28	Loss : 0.211142
Step : 29	Loss : 0.216332
Step : 30	Loss : 0.179863
정확도 : 0.939800

94% 정확도가 출력되었다.

머신러닝 기법의 Softmax 방식에서는 정확도가 92% 였지만, 딥러닝을 적용후 94%의 정확도 까지 올라갔음을 확인할수 있다.

참고 : Softmax 의 정확도 

코드부

import tensorflow as tf 

# MNIST 데이터 다운로드 
from tensorflow.examples.tutorials.mnist import input_data 

#mnist = input_data.read_data_sets("/tmp/data/", one_hot=True) # one-hot 엔코딩으로 정답레이블 표시 - 방법 1 (원핫 표현 가능한 경우) 

mnist = input_data.read_data_sets("/tmp/data/", one_hot=False) # one-hot 엔코딩 x  - 방법2 (원핫 표현 불가능한 경우) 

epoch = 1000 
# 입력값과 출력값을 받기위한 플레이스홀더 정의 
x = tf.placeholder(tf.float32, shape=[None, 784]) #28*28 = 784 784차원의 이미지, 임의의 입력 데이터 None 

#y = tf.placeholder(tf.float32, shape=[None,10]) # (원핫을 표현 ) 0~9 까지 10개 레이블, 임의의 타겟 데이터 None - 방법 1 

y = tf.placeholder(tf.int64, shape=[None]) # 0~9 까지 10개 레이블, 임의의 타겟 데이터 None - 방법 2 

# 변수설정, 소프트맥스 회귀 모델 정의 
W = tf.Variable(tf.zeros(shape=[784,10])) 
b = tf.Variable(tf.zeros(shape=[10])) 
logits = tf.matmul(x,W) + b 
y_pred = tf.nn.softmax(logits) 

# cross-entropy 를 정의하고 옵티마이저 설정 
# loss = tf.reduce.mean(-tf.reduce_sum(y * tf.log(y_pred) 

#loss = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits_v2(logits=logits , labels=y)) # one-hot으로 표현된 경우 - 방법 1 

loss = tf.reduce_mean(tf.nn.sparse_softmax_cross_entropy_with_logits(logits=logits , labels=y)) #  - 방법 2 
train_step = tf.train.GradientDescentOptimizer(learning_rate=0.5).minimize(loss) 

#세션을 열고 변수 초기화 
sess = tf.Session() 
sess.run(tf.global_variables_initializer()) 

# mini_betch를 이용해 100 개씩 학습 1000 번 
for i in range (epoch): 
    batch_x , batch_y = mnist.train.next_batch(100) 
    cost,_ = sess.run([loss,train_step],feed_dict={x:batch_x, y:batch_y}) 
    if i % 50 == 0: 
        print("step : {}\tloss : {}".format(i,cost)) 

# 모델의 정확도 출력 
#correct_prediction = tf.equal(tf.argmax(y_pred,1),tf.argmax(y,1)) - # 방법 1 - 정답 y 레이블이 원핫 인코딩값 
correct_prediction = tf.equal(tf.argmax(y_pred,1),y)  # 방법 2 - 정답 y 레이블이 스칼라 값이므로 argmax 필요 x 
# argmax - 출력값중 가장 높은값 출력 - 2번째 파라미터는 차원을 나타냄 0 을 열 , 1 은 행 , 2 는 행렬 

acc = tf.reduce_mean(tf.cast(correct_prediction,tf.float32)) 
print("정확도 : {}".format(sess.run(acc,feed_dict={x: mnist.test.images, y: mnist.test.labels})))

출력부

step : 0	loss : 2.3025853633880615
step : 50	loss : 0.40749335289001465
step : 100	loss : 0.3820759057998657
step : 150	loss : 0.3541696071624756
step : 200	loss : 0.4479416608810425
step : 250	loss : 0.3463912904262543
step : 300	loss : 0.20941297709941864
step : 350	loss : 0.400729775428772
step : 400	loss : 0.3737364113330841
step : 450	loss : 0.49058398604393005
step : 500	loss : 0.41620102524757385
step : 550	loss : 0.2729890048503876
step : 600	loss : 0.33347684144973755
step : 650	loss : 0.2736334502696991
step : 700	loss : 0.29564809799194336
step : 750	loss : 0.3730275332927704
step : 800	loss : 0.39759576320648193
step : 850	loss : 0.4126603603363037
step : 900	loss : 0.2376338243484497
step : 950	loss : 0.41531482338905334
정확도 : 0.920199990272522

코드부

import tensorflow as tf 
#선형회귀(Linear Regression) 모델 정의 = Wx + b 
W = tf.Variable(tf.random_normal([1]),name="W") 
b = tf.Variable(tf.random_normal([1]),name="b") 
X = tf.placeholder(dtype=tf.float32,name="X")    # 데이터 셋 
Y = tf.placeholder(dtype=tf.float32,name="Y") 
epoch = 1000 

#가설 
Linear_model = W * X + b 

# cost 함수 정의 (가설 - Y)제곱 의 평균 
loss = tf.reduce_mean(tf.square(Linear_model - Y)) 

# 손실함수를 최적화 하기 위해 Gradient_Descent 사용 
optimizer = tf.train.GradientDescentOptimizer(learning_rate=0.01) 
train_step = optimizer.minimize(loss) 

#데이터셋 정의 
x_train = [ 2,3,4,5,6,7,8,9,10 ] 
y_train = [ 3,4,5,6,7,8,9,10,11] 

# 세션을 열어 tf.global_variables_initializer() 초기화 
sess = tf.Session() 
sess.run(tf.global_variables_initializer()) # W 와 b 값에 초기값 할당 --> Variable 에 할당. 

# 텐서보드를 위해 요약정보 저장 
tf.summary.scalar('loss',loss) 
merged = tf.summary.merge_all() # 요약정보 하나로 합치기 
tensorboard_write = tf.summary.FileWriter('./tensorboard_log',sess.graph) # 요약 정보를 파일로 저장 


# epoch 만큼 학습시켜, 선형회귀 학습 
for i in range(epoch): 
    cost ,_ = sess.run([loss,train_step], feed_dict={X:x_train , Y:y_train}) 
    summary = sess.run(merged,feed_dict={X:x_train,Y:y_train}) 
    tensorboard_write.add_summary(summary,i) 
    if i % 50 == 0: 
        print("Step : {}\tLoss : {}".format(i, cost)) 

# 모델 테스트 
x_test = [12,3.5,96,100] 
# 정답 : [ 13, 4.5, 97 101 ] 
print(sess.run(Linear_model, feed_dict={X:x_test})) 

sess.close()

출력부

Step : 0	Loss : 0.4130171537399292
Step : 50	Loss : 0.260214626789093
Step : 100	Loss : 0.19144833087921143
Step : 150	Loss : 0.14085480570793152
Step : 200	Loss : 0.10363136231899261
Step : 250	Loss : 0.07624498009681702
Step : 300	Loss : 0.05609585717320442
Step : 350	Loss : 0.04127151146531105
Step : 400	Loss : 0.03036479465663433
Step : 450	Loss : 0.022340409457683563
Step : 500	Loss : 0.016436535865068436
Step : 550	Loss : 0.012092893011868
Step : 600	Loss : 0.008897127583622932
Step : 650	Loss : 0.006545921787619591
Step : 700	Loss : 0.004816039931029081
Step : 750	Loss : 0.0035433073062449694
Step : 800	Loss : 0.0026069271843880415
Step : 850	Loss : 0.001918009016662836
Step : 900	Loss : 0.001411122502759099
Step : 950	Loss : 0.001038226648233831
[ 13.048492    4.4646196  97.87736   101.916824 ]