data-03-diabetes.csv

-0.29412 0.487437 0.180328 -0.29293 0 0.00149 -0.53117 -0.03333 0
-0.88235 -0.14573 0.081967 -0.41414 0 -0.20715 -0.76687 -0.66667 1
-0.05882 0.839196 0.04918 0 0 -0.30551 -0.49274 -0.63333 0
-0.88235 -0.10553 0.081967 -0.53535 -0.77778 -0.16244 -0.924 0 1
0 0.376884 -0.34426 -0.29293 -0.60284 0.28465 0.887276 -0.6 0
-0.41177 0.165829 0.213115 0 0 -0.23696 -0.89496 -0.7 1
-0.64706 -0.21608 -0.18033 -0.35354 -0.79196 -0.07601 -0.85483 -0.83333 0
0.176471 0.155779 0 0 0 0.052161 -0.95218 -0.73333 1
-0.76471 0.979899 0.147541 -0.09091 0.283688 -0.09091 -0.93168 0.066667 0
-0.05882 0.256281 0.57377 0 0 0 -0.86849 0.1 0
-0.52941 0.105528 0.508197 0 0 0.120715 -0.9035 -0.7 1
0.176471 0.688442 0.213115 0 0 0.132638 -0.60803 -0.56667 0
0.176471 0.396985 0.311475 0 0 -0.19225 0.163962 0.2 1
-0.88235 0.899497 -0.01639 -0.53535 1 -0.10283 -0.72673 0.266667 0
-0.17647 0.005025 0 0 0 -0.10581 -0.65329 -0.63333 0
0 0.18593 0.377049 -0.05051 -0.45627 0.365127 -0.59607 -0.66667 0
-0.17647 0.075377 0.213115 0 0 -0.11774 -0.8497 -0.66667 0
-0.88235 0.035176 -0.5082 -0.23232 -0.80378 0.290611 -0.91033 -0.6 1
-0.88235 0.155779 0.147541 -0.39394 -0.77305 0.031297 -0.61486 -0.63333 0
-0.64706 0.266332 0.442623 -0.17172 -0.44444 0.171386 -0.46541 -0.8 1
-0.05882 -0.00503 0.377049 0 0 0.055142 -0.73527 -0.03333 1
-0.17647 0.969849 0.47541 0 0 0.186289 -0.68147 -0.33333 0
0.058824 0.19598 0.311475 -0.29293 0 -0.13562 -0.84202 -0.73333 0
0.176471 0.256281 0.147541 -0.47475 -0.72813 -0.07303 -0.89155 -0.33333 0
-0.17647 0.477387 0.245902 0 0 0.174367 -0.84714 -0.26667 0
-0.88235 -0.02513 0.081967 -0.69697 -0.66903 -0.3085 -0.65073 -0.96667 1

위와 같은 여러 측정값이 있을때 어떤 질병이 걸렸는지 아닌지를 학습시키는 과정이다.

마지막에 0,1 이 0이면 질병이 아니고 1이면 질병에 걸린것이다.

import tensorflow as tf
import numpy as np
# 데이터를 파일에서 가져온다.
xy = np.loadtxt('data-03-diabetes.csv', delimiter=',', dtype=np.float32)
# 처음부터 마지막 컬럼 전까지 측정값이다.
x_data = xy[:, 0:-1]
# 마지막 컬럼이 결과값이다.
y_data = xy[:, [-1]]

# 구성이 어떻게 되어있는지 출력해 준다.
print(x_data.shape, y_data.shape)

# n개의 데이터가 8개의 측정값으로 구성된다.
X = tf.placeholder(tf.float32, shape=[None, 8])
# n개 의 하나의 결과치로 구성된다.
Y = tf.placeholder(tf.float32, shape=[None, 1])

# 8개의 측정값이 있고 1개의 결과가 나온다.
W = tf.Variable(tf.random_normal([8, 1]), name='weight')
# 1개의 결과가 도출된다.
b = tf.Variable(tf.random_normal([1]), name='bias')

# 시그모이드함수로 가설을 세운다. 결과를 0,1 로만 나오게 하기위함이다.
hypothesis = tf.sigmoid(tf.matmul(X, W) + b)

# cost 를 계산한다.
cost = -tf.reduce_mean(Y * tf.log(hypothesis) + (1 - Y) *  tf.log(1 - hypothesis))

# cost 를 줄이도록 학습한다.
train = tf.train.GradientDescentOptimizer(learning_rate=0.01).minimize(cost)

# 결과가 0.5 이상이면 1 아니면 0 이다.
predicted = tf.cast(hypothesis > 0.5, dtype=tf.float32)
# 계산된 결과가 결과 값과 같은지 확률을 계산한다.
accuracy = tf.reduce_mean(tf.cast(tf.equal(predicted, Y), dtype=tf.float32))

# 세션을 할당하고 초기화 한다. with 문은 묶인것? 이라고 보면됨.
with tf.Session() as sess:
    sess.run(tf.global_variables_initializer())

    # 10001 번의 루프를 돌면서 파일의 내용을 학습한다.
    for step in range(10001):
        cost_val, _ = sess.run([cost, train], feed_dict={X: x_data, Y: y_data})
        # 200 번 돌때마다 화면에 step 과 cost 를 출력한다.
        if step % 200 == 0:
            print(step, cost_val)

    # 실재로 학습된 결과로 다시 파일의 내용을 측정해보고 얼마나 정확한지 Accuracy 를 출력해본다.
    h, c, a = sess.run([hypothesis, predicted, accuracy],
                       feed_dict={X: x_data, Y: y_data})
    print("\nHypothesis: ", h, "\nCorrect (Y): ", c, "\nAccuracy: ", a)

위 내용의 출력은 Hypothesis 는 학습한 결과 로직에 파일의 내용을 대입했을때 각각에 대한 결과 값이며
Correct 는 결과값에 대한 1,0 을 나타내고 이 값이 실제 값과 얼마나 맞는지 Accuracy 로 나타내는 것입니다.

결과에서보듯이 Accuracy: ', 0.76679844) 으로 76 프로의 확률로 질병인지 아닌지를 판별 가능합니다.

결과

더보기

import tensorflow as tf


X(데이터), Y(결과) 를 정의한다.

x_data = [1, 2, 3]
y_data = [1, 2, 3]

W 에 랜덤값을 준다.

W = tf.Variable(tf.random_normal([1]), name='weight')

X,Y 노드를 만든다.

X = tf.placeholder(tf.float32)
Y = tf.placeholder(tf.float32)

가설을 세우고

hypothesis = X * W

cost 를 계산한다.(square 제곱)

cost = tf.reduce_mean(tf.square(hypothesis - Y))

==========

0.1 만큼 움직이도록 최소화알고리즘에 사용한다.

learning_rate = 0.1

줄어든 값을 계산하고

gradient = tf.reduce_mean((W * X - Y) * X)

W 값에서 계산한 값을 빼고

descent = W - learning_rate * gradient

 

뺀값을 W값에 대입하도록 한다. -> 이런식으로 계속 반복하여 cost 를 최소화 한다.

update = W.assign(descent)

==========

========== 사이의 내용은 아래의 두줄 코드로 바꿀 수 있다.

cost 를 최소화하도록 훈련시키도록 한다.

optimizer = tf.train.GradientDescentOptimizer(learning_rate=0.01)
train = optimizer.minimize(cost)

루프 내부도 변경되어야한다. 

for step in range(100):
print(step, sess.run(W))
sess.run(train)

세션을 정의하고 변수를 초기화한다.

sess = tf.Session()

sess.run(tf.global_variables_initializer())

21번 만큼 루프를 돌면서 비교값을 계속 최소화 시켜나간다.

for step in range(21):
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))

 

결과

(0, 0.94110894, array([ 0.5509274], dtype=float32))
(1, 0.26769316, array([ 0.76049465], dtype=float32))
(2, 0.076143883, array([ 0.87226379], dtype=float32))
(3, 0.021658683, array([ 0.93187404], dtype=float32))
(4, 0.0061607012, array([ 0.96366614], dtype=float32))
(5, 0.0017523728, array([ 0.98062193], dtype=float32))
(6, 0.00049845403, array([ 0.98966503], dtype=float32))
(7, 0.0001417833, array([ 0.994488], dtype=float32))
(8, 4.0330586e-05, array([ 0.99706024], dtype=float32))
(9, 1.1471246e-05, array([ 0.99843216], dtype=float32))
(10, 3.2631249e-06, array([ 0.99916381], dtype=float32))
(11, 9.2822262e-07, array([ 0.99955404], dtype=float32))
(12, 2.638879e-07, array([ 0.99976218], dtype=float32))
(13, 7.5077573e-08, array([ 0.99987316], dtype=float32))
(14, 2.1349843e-08, array([ 0.99993235], dtype=float32))
(15, 6.0727494e-09, array([ 0.99996394], dtype=float32))
(16, 1.7274111e-09, array([ 0.99998075], dtype=float32))
(17, 4.9048293e-10, array([ 0.99998975], dtype=float32))
(18, 1.4032746e-10, array([ 0.99999452], dtype=float32))
(19, 4.0156323e-11, array([ 0.99999708], dtype=float32))
(20, 1.1581847e-11, array([ 0.99999845], dtype=float32))
 
결과의 순서는 

루프 / COST / W

[1,2,3] 의 결과가 [1,2,3] 이 나오려면 어떤 수를 곱해야하는지를 알아내는 것이라고 보면된다.

결과를 보면 알겠지만 0.55091274 부터 시작해서 점점 1에 가깝게 변하고 있다.

즉 결과는 W 는 1 이어야한다.

마지막에 W 가 1에 가까운 것을 알수 있다.

COST 는 낮을수록 좋은것이다.

 

만약에

x_data = [1, 2, 3]
y_data = [2, 4, 6]

 

이렇게 값을 주게되면 W 는 2 이어야한다.

실제 돌리면 아래와 같이 2에 가까운 W 값이 나온다.

 

0, 0.91811532, array([ 1.55644727], dtype=float32))
(1, 0.26115283, array([ 1.76343858], dtype=float32))
(2, 0.074283406, array([ 1.87383389], dtype=float32))
(3, 0.02112958, array([ 1.93271136], dtype=float32))
(4, 0.0060101724, array([ 1.96411276], dtype=float32))
(5, 0.0017095689, array([ 1.98086011], dtype=float32))
(6, 0.00048626671, array([ 1.98979211], dtype=float32))
(7, 0.00013831869, array([ 1.99455571], dtype=float32))
(8, 3.9345487e-05, array([ 1.9970963], dtype=float32))
(9, 1.1191744e-05, array([ 1.99845135], dtype=float32))
(10, 3.1841603e-06, array([ 1.999174], dtype=float32))
(11, 9.0532711e-07, array([ 1.99955952], dtype=float32))
(12, 2.5757623e-07, array([ 1.99976504], dtype=float32))
(13, 7.3224314e-08, array([ 1.99987471], dtype=float32))
(14, 2.0887404e-08, array([ 1.99993312], dtype=float32))
(15, 5.9203416e-09, array([ 1.99996436], dtype=float32))
(16, 1.6977234e-09, array([ 1.99998093], dtype=float32))
(17, 4.8156323e-10, array([ 1.99998987], dtype=float32))
(18, 1.3557629e-10, array([ 1.99999464], dtype=float32))
(19, 3.8198777e-11, array([ 1.99999714], dtype=float32))
(20, 1.1581847e-11, array([ 1.99999845], dtype=float32))

 

 

 

 

몽땅 정리가 되어있는 글.

https://www.chatbotkorea.com/magazine/1

https://www.chatbotkorea.com/magazine/2

sung kim 교수님의 소개자료

https://www.youtube.com/watch?v=K9Oesd9or3E&app=desktop

 

GPU 를 클라우드 환경에서 사용할수 있게 해주는 것으로

로컬에서 돌리던 학습처리를 클라우드에 올려서 GPU 를 이용해 빠르게 학습할 수 있다고 한다.

sung kim 교수님도 참여하는것 같아 더 관심이간다.

아직 오픈은 된거 같지않고 아래 링크에서 알파 테스트를 모집하고 있다.

신청은 했는데 될런지는 모르겠다.;

https://research.clova.ai/nsml-alpha

pycharm-community-2017.2.3

python 에서 제공해 주는 편집기인 IDLE 는 줄번호가 표시되지 않는다.

가장 하단에 선택한 라인이 몇번째 줄인지는 알려주지만

Visual Studio 에 익숙한 나로써는 영 불편한찰라

pycharm 을 알고 깔아보았다. UI 가 visual studio 와 똑같지는 않지만 비슷하고

파이썬 코딩을 쉽게 실행해 볼수 있게 되어있다.

그래서 설치 과정을 설명해본다.

 

https://www.jetbrains.com/pycharm/

사이트로 들어간다.

DOWNLOAD NOW 를 선택

Community .. 에서 DOWNLOAD 를 선택

위 빈칸에 메일 적을 필요없다 기다리면 위처럼 파일을 받을 수 있다.

받은 파일을 실행한다.

64비트 운영체제라서 64 비트 런쳐만 바탕화면에 보이도록하고

.py 에 체크

 

Pycharm 의 설치는 끝났고 실행해본다.

환경 설정을 따로 저장이 가능한것 같은데 저장한게 없으니 아래그림과 같이 선택

동의.

화면 디자인을 선택한다. 미리보기가 되므로 보고 결정한다.

기존에 있던 파일을 열어보거나 새로운 파일을 하나 만든다.

Settings 로 들어간다.

python 이 제대로 연결되어있는지 확인한다.

아래 처럼 오른쪽에 Projector interpreter 에 python.exe 파일이 선택이 안되어있다면 선택해야한다.

Run 메뉴를 이용해 파이썬 파일을 디버깅 할 수 있다.

 

 

1. 파일에서 학습할 데이터를 가져옵니다.

2017/10/25 - [TensorFlow&Python] - (TensorFlow) 파일에서 (학습할)데이터 읽어오기

import numpy as np
import tensorflow as tf

xy = np.loadtxt('testData.csv',delimiter=',',dtype=np.float32)
x_data = xy[:, 0:-1]
y_data = xy[:, [-1]]

print(x_data.shape, x_data, len(x_data))
print(y_data.shape, y_data, len(y_data))

 

2. Node 를 구성합니다. (학습할 데이터의 구성을 정의합니다.)

// n 개의 3가지 숫자값을 가지는 구성의 x
X = tf.placeholder(tf.float32, shape=[None, 3])
// 1 개의 결과 숫자값을 가지는 구성의 y
Y = tf.placeholder(tf.float32, shape=[None, 1])

// 3개가 들어가서 1개의 결과로 나온다.
W = tf.Variable(tf.random_normal([3, 1]), name='weight')
// 1개의 출력값을 갖는다.
b = tf.Variable(tf.random_normal([1]), name='bias')

 

3. 학습을 어떻게 할것인지 정의합니다.

// 가설을 세우고
hypothesis = tf.matmul(X, W) + b
// 비용을 계산
cost = tf.reduce_mean(tf.square(hypothesis - Y))

// optimizer를 생성하여 비용(cost) 이 적은 방향으로 학습시키도록 정의
optimizer = tf.train.GradientDescentOptimizer(learning_rate=1e-5)
train = optimizer.minimize(cost)

 

4. 학습합니다.

// session 을 가져와 변수 초기화
sess = tf.Session()
sess.run(tf.global_variables_initializer())

// 2001 번 루프 돌면서 학습을 시킵니다.
// feed_dict 에 학습된 결과가 저장됩니다.
for step in range(2001):
    cost_val, hy_val, _ = sess.run(
        [cost, hypothesis, train], feed_dict={X: x_data, Y: y_data})
    if step % 10 == 0:
        print(step, "Cost: ", cost_val, "\nPrediction:\n", hy_val)

 

5. 학습한결과로 예측해봅니다.

// 학습한 내용을 가지고 결과를 예측해봅니다. (100,70,101) 인 경우 결과를 예측합니다.
print("Your score will be ", sess.run(
    hypothesis, feed_dict={X: [[100, 70, 101]]}))

Your score will be [[ 170.03196716]]

// [60, 70, 110], [90, 100, 80] 에대한 결과를 예측해 봅니다. 2가지 조건을 넣었으므로 두가지 예측 결과가 나타납니다.
print("Other scores will be ", sess.run(hypothesis,
                                        feed_dict={X: [[60, 70, 110], [90, 100, 80]]}))

Other scores will be  [[ 149.67153931]
 [ 188.85415649]]

 

 

 

 

전체코드
import numpy as np
import tensorflow as tf

xy = np.loadtxt('testData.csv',delimiter=',',dtype=np.float32)
x_data = xy[:, 0:-1]
y_data = xy[:, [-1]] 

print(x_data.shape, x_data, len(x_data))
print(y_data.shape, y_data, len(y_data))

X = tf.placeholder(tf.float32, shape=[None, 3])
Y = tf.placeholder(tf.float32, shape=[None, 1])

W = tf.Variable(tf.random_normal([3, 1]), name='weight')
b = tf.Variable(tf.random_normal([1]), name='bias')

hypothesis = tf.matmul(X, W) + b
cost = tf.reduce_mean(tf.square(hypothesis - Y))

optimizer = tf.train.GradientDescentOptimizer(learning_rate=1e-5)
train = optimizer.minimize(cost)

sess = tf.Session()
sess.run(tf.global_variables_initializer())
for step in range(2001):
    cost_val, hy_val, _ = sess.run(
        [cost, hypothesis, train], feed_dict={X: x_data, Y: y_data})
    if step % 10 == 0:
        print(step, "Cost: ", cost_val, "\nPrediction:\n", hy_val)

print("Your score will be ", sess.run(hypothesis, feed_dict={X: [[100, 70, 101]]}))

print("Other scores will be ", sess.run(hypothesis,feed_dict={X: [[60, 70, 110], [90, 100, 80]]}))

 

 

 

여러 로직을 처리하다보면 입력값 즉, 학습할 데이터를 넣을때

값이 많은 경우 코드로 입력하기는 힘듭니다.

그래서 파일을 이용하여 학습할 데이터를 넣는 과정을 소개합니다.

(Sung Kim 교수님의 동영상을 참고 했습니다. https://www.youtube.com/watch?v=o2q4QNnoShY)

 

#E1,E2,E3,R
73,80,75,152
93,88,93,185
89,91,90,180
96,98,100,196
73,66,70,142
53,45,55,101

우선 위 내용으로 (학습데이터) csv 파일을 하나 만듭니다.

파일 내용은 아시겠지만 E1,E2,E3 대한 결과값(R)입니다.

testData.csv

만약 실제 코드로 한다면 아래 처럼 지저분해집니다.

x_data = [[73., 80., 75.],
          [93., 88., 93.],
          [89., 91., 90.],
          [96., 98., 100.],
          [73., 66., 70.]]
y_data = [[152.],
          [185.],
          [180.],
          [196.],
          [142.]]

 

먼저 numpy 를 import 합니다. (숫자를 다룰때 사용하는 라이브러리 입니다.)

import numpy as np

numpy 에 loadtxt 라는 함수가 있는데 이 함수가 파일을 읽어오게끔 해줍니다.

xy = np.loadtxt('testData.csv',delimiter=',',dtype=np.float32)

loadtxt(파일이름, 구분자, 타입) 형태가 됩니다.

이제 변수에 데이터를 넣습니다.

x_data = xy[:, 0:-1]

x_data 는 E1,E2,E3 데이터로 위 표현은 0 에서 부터 마지막 -1 값까지(마지막 컬럼?을 제외한 값)만 읽으라는 뜻입니다.

y_data = xy[:, [-1]]

y_data 는 R 값으로 위표현은 마지막 값만을 읽으라는 뜻입니다.

이제 출력해 봅니다.

print(x_data.shape, x_data, len(x_data))
print(y_data.shape, y_data, len(y_data))

위 명령을 수행하면 행렬의 구성, 데이터, 길이 를 출력하게됩니다.

import numpy as np
xy = np.loadtxt('testData.csv',delimiter=',',dtype=np.float32)
x_data = xy[:, 0:-1]
y_data = xy[:, [-1]]
print(x_data.shape, x_data, len(x_data))
print(y_data.shape, y_data, len(y_data))

TensorBoard는 TensorFlow에 기록된 로그를 그래프로 시각화시켜서 보여주는 도구라고 합니다.

텐서보드는 위 언급한대로 로그 파일이 존재해야 볼수가 있습니다.

로그파일을 만들어보겠습니다.

쥬피터(Juypter를 실행합니다.

파이썬 파일 하나 만들고 아래 처럼 코딩해봅니다.

import tensorflow as tf
a = tf.constant(3.0)
b = tf.constant(5.0)
c = a * b

# tensorboard에 point라는 이름으로 표시됨
c_summary = tf.summary.scalar('point', c)
merged = tf.summary.merge_all()

with tf.Session() as sess:
    writer = tf.summary.FileWriter('./board/5Step', sess.graph)
    result = sess.run([merged])
    sess.run(tf.global_variables_initializer())
    writer.add_summary(result[0])

 

실행하게 되면 5Step 로그 폴더가 하나 생겨지게 됩니다.

각 PC 환경에 따라 다르겠지만 전 C:\Users\kjun\Documents\Test\board 이쪽에 폴더가 만들어졌습니다.

 

이제 텐서 보드를 실행할 준비는 마쳤습니다.

 

cmd(명령프롬프트) 를 관리자 모드로 실행하여 아래 명령어를 입력합니다.

tensorboard --logdir=C:\Users\kjun\Documents\Test\board\5step

그러면 아래 처럼 명령이 실행되면서 사이트 주소가 하나 보입니다.

Default 로는 6006 포트를 사용하는 주소를 사용합니다. (http://kjunMainPC:6006)

아래처럼 뒤에 포트를 명시해 주면 원하는 포트로 변경이 가능합니다.

tensorboard --logdir=C:\Users\kjun\Documents\Test\board\5step --port=8008

위 사이트주소를 크롬에서 실행해 봅니다. (Explorer 에서는 제대로 동작이 안되더군요;)

위와 같이 시각화면 로그 파일을 확인해 볼수 있습니다.

더 상세한 사항은 아래 참고 사이트를 확인해 주세요~

 

참고

http://pythonkim.tistory.com/39

강의동영상

https://goo.gl/2cqKLz

 

깃허브

https://github.com/hunkim

 

http://byteofpython-korean.sourceforge.net/byte_of_python.html#first_steps

체계적으로 설명이 잘되어있다.

(편집기 설치하는과정까지도 나온다.)

+ Recent posts