Chikong

코드부

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 ]

코드부

import tensorflow as tf 

# placeholder 로 2개의 변수 선언 
num1 = tf.placeholder(tf.float32) 
num2 = tf.placeholder(tf.float32) 

# placeholder로 선언된 두 변수 덧셈 
adder = num1 + num2 
print(adder) 

#세션을 열러 실행하되, feed_dict 를 통해 임의값 입력 
# feed_dict{a : 3., b: 4.} 과 feed_dict={a:[3.,2.], b:[5.,6.]} 비교 !! 
sess = tf.Session() 
print(sess.run(adder, feed_dict={num1 : 2., num2 : 4.})) 
print(sess.run(adder, feed_dict={num1 : [3.,2.], num2 : [6.,4.]})) 

# adder 에 3곱하면 ?? 
adder_tri = adder * 3 # tf.multiply(adder,3) 과 같은 형태 
print(sess.run(adder_tri, feed_dict={num1 : 2., num2 : 4.})) 
print(sess.run(adder_tri, feed_dict={num1 : [3.,2.], num2 : [6.,4.]})) 

sess.close()

출력부

Tensor("add:0", dtype=float32)
6.0
[9. 6.]
18.0
[27. 18.]

코드부

import tensorflow as tf 
# 그래프 노드 정의후 출력 
node1 = tf.constant(4.0) #암시적으로 float32 로 선언 
node2 = tf.constant(3.0) 
print("생성된 그래프 각각 출력 : ",node1,node2) 
# 그래프를 생성후 실행하지 않았기 때문에 노드에 대한 설명만이 출력된다. 

# 세션을 열어 그래프 실행 
sess = tf.Session() 
print("그래프 실행(각각 출력 ) : ",sess.run([node1,node2])) 

# 노드 값을 덧셈 
node3 = tf.add(node1,node2) 
print("덧셈 그래프 출력 : ",node3) 
print("덧셈 그래프 실행후 출력 : ", sess.run(node3)) 

sess.close()

출력부

생성된 그래프 각각 출력 :  Tensor("Const_2:0", shape=(), dtype=float32) Tensor("Const_3:0", shape=(), dtype=float32)
그래프 실행(각각 출력 ) :  [4.0, 3.0]
덧셈 그래프 출력 :  Tensor("Add_1:0", shape=(), dtype=float32)
덧셈 그래프 실행후 출력 :  7.0