http://blog.naver.com/atelierjpro/220697890605

2017/11/04 - [Windows] - (Windows) 윈도우 에서 Ubuntu (우분투) 실행하기

2017/11/04 - [TensorFlow&Python] - Windows 의 Ubuntu 에 TensorFlow 설치하기

 

이전 포스팅에 이어 Ubuntu  에 Open AI Gym 을 설치해보자.

gym은 파이썬 개발 라이브러리 툴킷(toolkit), 강화 학습 알고리즘 개발 도구이다.

사이트 : https://gym.openai.com/

설치 참고 : https://github.com/openai/gym#installing-everything

소스 : https://github.com/openai/gym/tree/master/gym

 

우선 tensorflow 가상환경으로 접속한다. (tensor 는 앞서 포스팅에서 정의한 디렉터리 명으로 개인마다 다를수 있다.)

source ~/tensor/bin/activate

아래 명령어를 실행한다. (파이썬 3.5 기준)

(딥러닝에 필요한 여러 툴/라이브러리 를 한꺼번에 설치하는 명렁어이다. numpy, dev, cmake.. 등등 공백기준으로 구분된다.)

(tensorflow)~$ sudo apt-get install -y python3-numpy python3-dev cmake zlib1g-dev libjpeg-dev xvfb libav-tools xorg-dev python3-opengl libboost-all-dev libsdl2-dev swig

추가로 파이썬 2. 대가 깔려있으면 위에서 python3 을 python 으로 바꾸어서 실행해야한다.

참고로 자신의 파이썬 버전을 아래 명령어로 확인이 가능하다.

pip --version

결과

pip 9.0.1 from /home/junijuniya/tensor/lib/python3.5/site-packages (python 3.5)

아래 명령어를 이용해 gym 을 가져온다.

설치가 끝났으면 gym 으로 이동한다.

cd gym

아래 명령어를 수행한다.

(파이썬 3.5 기준의 라이브러리들로 gym 이 설치 된다. (파이썬 2.7 이면 => pip2.7 install -e '.[all])

pip install -e '.[all]'

gym 설치는 완료되었다.

 

추가로 윈도우 상에서 gym 에서 실행시 화면을 나타내주기 위해선

xming 이 필요하다.

아래 파일을 다운받아 설치하거나 아래 링크로 가서 다운받아 설치하자

Xming-6-9-0-31-setup.exe

https://sourceforge.net/projects/xming/

아래는 의미없는 설치 과정이다.^^

설치가 완료되어 실행이 되면 아래처럼 시계표시줄에 Xming 아이콘이 나타난다.

반드시 아래 아이콘이 보여야 실행이 된것이다 컴퓨터를 재부팅하면 다시 실행해 주어야한다.

 

이제 준비는 끝났고 테스트 해보자.

 

gym 에는 여러 테스트 게임이나 샘플이 존재한다고 하는데 그중에 하나를 테스트 해본다.

아래 내용을 text.py 로 저장한다.

import gym
env = gym.make('CartPole-v0')
env.reset()
for _ in range(1000):
    env.render()
    env.step(env.action_space.sample()) # take a random action

D:\tensorflow\test.py 로 만들었다고 하면

아래 처럼 명령어를 수행한다.

- 영상출력을 위한 준비를 하고

export DISPLAY=:0

- 경로로 이동하여 파일을 실행한다.

cd /mnt/d/tensorflow

python3 test.py

아래처럼 팝업으로 화면이 하나 뜨면서 실행이 되는걸 확인 할수 있다.

 

끝.

 

참고

http://blog.naver.com/PostView.nhn?blogId=chandong83&logNo=220843584767&categoryNo=37&parentCategoryNo=0&viewDate=&currentPage=1&postListTopCurrentPage=1&from=postView

http://jinman190.blogspot.kr/2017/10/openai-gym.html

인공지능(AI) 
세 개념 중 가장 큰 범주인 인공지능은 기계가 주변 환경과 상호 작용을 하는 다양한 방법을 말합니다. 사람과 비슷한 뛰어난 지능 덕분에 AI기술이 탑재된 기계나 기기는 인간처럼 행동하거나 인간처럼 업무를 수행하죠. 

오늘날 우리가 주변에 접하는 인공지능과 관련된 많은 이야기들은 주로 음성 인식(인공지능 가상 비서 등), 안면 인식(SNS에서 많이 사용되고 있는 필터 기능 등), 혹은 사물 인식(사과나 오렌지와 같은 사물의 이미지로 검색하는 기능 등)과 관련한 것이 많습니다. 그렇다면 이런 기능들은 어떤 식으로 지능화되는 걸까요?

기본적으로 AI기술을 탑재한 기계는 사람들이 위의 물체들을 '사과'와 '오렌지'라고 인식하는 것처럼 인간의 사고 프로세스를 모방합니다.

머신러닝(기계학습) 
머신러닝은 AI의 부분집합으로, AI 접근방식의 하나입니다. 특정 업무를 처리하는 컴퓨터 프로그래밍 접근법이 아니라 '러닝(학습)'이라는 것에 초점이 맞춰져 있죠. 머신러닝이 가능한 기계는 복잡한 알고리즘을 이용해 대량의 데이터를 분석해 그 중 패턴을 인식하고, 그것을 바탕으로 예측을 합니다. 이 과정에서 인간이 소프트웨어에 특정 명령을 입력할 필요는 없습니다. 분석 과정에서 만약 치즈 과자를 오렌지로 잘못 인식했다면, 시스템의 패턴 인식 기능은 마치 인간처럼 스스로 오류를 수정하고, 실수로부터 학습하며 정확도를 점점 높여갑니다.

머신러닝이 가능한 시스템은 자신의 실수를 토대로 학습하며 패턴 인식 능력을 스스로 향상시킵니다.

딥러닝(심층학습) 
앞서 설명한 머신러닝의 부분 집합인 딥러닝은 컴퓨터의 지능을 한 차원 더 올려놓는 역할을 하며, 대량의 데이터와 컴퓨팅 기술을 활용해 심층신경망(Deep Neural Networks, 링크)을 구현합니다. 심층신경망의 기본적인 원리는 인간 두뇌의 연결성을 모방해 데이터 세트를 분류하고, 데이터 간 상관 관계를 찾아내는 것입니다. 이렇게 인간의 도움 없이도 새롭게 발견한 지식을 바탕으로, 기계는 다른 데이터 세트에 통찰력을 적용합니다. 처리하는 데이터의 양이 많아질수록 기계의 예측도 더 정확해집니다.

가령, 딥러닝이 가능한 기기는 과일의 색상, 형태, 크기, 최적 수확시기, 원산지 등 대량의 데이터 세트를 검토해, 이 사과가 홍옥 사과가 맞는지, 이 오렌지가 감귤인지 구분할 수 있는 것입니다.

딥러닝이 가능한 기계는 대량의 데이터를 처리해 복잡한 패턴을 인식하고 그 결과 더 구체적인 통찰을 제공합니다

이처럼 인공지능과 머신러닝, 딥러닝의 차이점은 사과나 오렌지의 구분만큼 명확하지는 않지만, 미묘한 차이가 있는 것이죠.  퀄컴은 이러한 인공지능(AI) 기술을 퀄컴 스냅드래곤 모바일 플랫폼에 적용, 주변의 사물과 사용자에 대해 학습하도록 하여 더 직관적이고 뛰어난 경험을 가능하도록 노력합니다.

https://m.blog.naver.com/PostView.nhn?blogId=qualcommkr&logNo=221123371711&proxyReferer=&proxyReferer=http%3A%2F%2Fblog.naver.com%2Fqualcommkr%2F221123371711

2017/11/04 - [Windows] - (Windows) 윈도우 에서 Ubuntu (우분투) 실행하기

위 글에서 우분투를 설치해 보았고 이제 텐서플로우를 설치해보자.

 

아래 명령어를 실행한다.

sudo apt-get install python3-pip python3-dev python-virtualenv

혹 위 명령어 실행이 에러가 발생된다면

sudo apt-get update

명령어를 실행한 후 실행하면 될것이다.

 

아래 명령어를 실행하여 가상 tensorflow 환경을 설정한다.

마지막에 tensor 은 변경해도 된다. (임의로 지정한것이다.) => TargetDirectory 를 나타냄 - https://www.tensorflow.org/install/install_linux#InstallingVirtualenv)

virtualenv --system-site-packages -p python3 tensor


이제 가상환경의 tensorflow 으로 진입해보자.

source ~/tensor/bin/activate


진입하게되면 아래처럼 맨 앞에 (tensor) 가 보이게 된다.

(위에서 지정한 이름이 괄호안에 들어가서 보이게된다.)

이제 최신환경으로 업그레이드 해주자

(tensor) junijuniya@kjunMainPC:~$ pip3 install --upgrade tensorflow


이상 우분투에 텐서플로우 환경을 구성하는 방법이다.


참고

http://jinman190.blogspot.kr/2017/10/openai-gym.html


아래는 설치 로그

더보기

[0.,1.,2.,3.,4.,5.,6.]

Rank : 몇차원 배열인지 = 1 (ndim) -> 처음 시작하는 [ (대괄호)의 수

Shape : 몇개의 엘리먼트가 있는지 = 7 -> [[1,2,3],[4,5,6]] => (2,3) 뒤에 내용부터 가장 낮은 단위.

[-1] 가장 마지막을 의미한다.

[2:5] : 2에서 5바로 앞까지 (2,3,4,)

[4:-1] : 4에서 가장 마지막 앞까지 (4,5)

[:2] => (0,1)

[3:] => (3,4,5,6)

Axis : 각 엘리먼트의 열 정보 , 바깥쪽 대괄호 부터 axis = 0 으로 명명하고
        그 안쪽 대괄호는 axis=1 이런식으로 숫자가 커진다. 

 

Reduce_mean 평균을 내서 여러개의 행열 값을 줄여주는 함수

tf.reduce_mean([1,2], axis =0).eval() => 1 axis  가 0 이므로 1만 가지고 평균을 구한것임.

x = [[1.,2.]
      [3.,4.]]
tf.reduce_mean(x).eval() => 2.5 : 전체 다 더해서 4로 나눠 평균

tf.reduce_mean(x, axis=0).eval() => 2,3 : 1,3 의 평균 2 , 2,4의 평균 3

tf.reduce_mean(x, axis=1).eval() => 1.5,3.5 : 1,2 의 평균 1.5 , 3,4의 평균 3.5 (axis = -1 은 가장 안쪽의 값을 나타낸다.)

 

Reduce_sum 합계를 낸다 Reduce_mean  과 사용방식은 같다.

Argmax 가장 큰것의 위치를 나타낸다.

x=[[0, 1, 2],
    [2, 1, 0]]
tf.argmax(x, axis=0).eval() => (1,0,0) 0,2 중에 2가 크므로 1 (0,1 인덱스중에 1) / 1,1 은 같으므로 0 / 2,0 중에 2가 크므로 0

Reshape  행열의 구성을 다시 재구성한다. 가장 안쪽의 값은 유지하도록 한다.

squeeze 값을 펼친다. [[0],[1],[2]] => [0,1,2]

expand_dims squeeze 와 반대의 의미로 보면되면 펼쳐져 있는것을 구조화한다.

tf.expand_dims([0,1,2], 1).eval() => [[0],[1],[2]]

ones_like(x)  x 구조와 같지만 데이터는 모두 1로 채운다.

zeros_like(x)  x 구조와 같지만 데이터는 모두 0로 채운다.

학습할 데이터 내용중 너무 튀는 값이 있어서 학습결과가 안좋을때

MinMaxScaler 함수를 이용해 모두 0~1 사이수로 나오게 하여 학습결과를 좋게 하는것이다.

=> Normalized

* Learning Rate : 이 값이 너무 크거나 작으면 결과 값을 찾기가 힘들어 질수 있다.
  - overshooting (값이 커서 결과값에 다가가질 못하고 튕겨나감)
  - takes too long(오래걸리고) , stop at local minimum (특정한 부분이 잠깐 내려갔다 올라오는데가 있을때 그 부분에서 멈출수 있다.)
  => 0.01 로 시작하되 결과를 보고 조정하는 것이 좋다.

* preprocessing : 데이터가 너무 차이가 크거나 할 때 정제하는 과정을 거쳐야한다.
  - zero-centered data : 데이터를 0 이 중심으로 가게한다.
  - normalized data : 어떤 범위안에 들어가도록 한다.

* Overfitting : 너무 정확하게 선을 구분하여 예측하려고 한다면 일반적인 선 구분으로 예측한 것 보다 예측률이 떨어질 수 있다.
  - 훈련 데이터가 많아야한다.
  - 변수를 줄여라
  - 일반화 시켜라. Regularization : 값이 너무 큰 값을 갖지 않도록 한다.

* Regularization  : 항목은 W의 값이 너무 크게 가지도록 하지 말자는 것입니다. W 값이 클수록 구분선이 더 구부러지는 형태를 띄게되는데
구부러진 구분선을 좀 더 펴주기 위한 스킬로써 cost 함수에 Regularization strength를 추가해주는 형태를 이용합니다.일반화 상수가 0이면 일반화를 시키지 않겠다는 뜻이고 1이면 정말 크게 적용하겠다는 의미가 됩니다. (보통 그래서 소수점단위로 쓴다고합니다) <= 펌

data-04-zoo.csv

import tensorflow as tf
import numpy as np

# 분류하고자하는 동물의 특징들과 분류 결과가 있는 학습데이터를 읽어옵니다.
xy = np.loadtxt('data-04-zoo.csv', delimiter=',', dtype=np.float32)

# 처름부터 마지막 컬럼 전까지가 특징들입니다.
x_data = xy[:, 0:-1]

# 마지막 컬럼이 분류된 결과 입니다. (0~6 로 구분)
y_data = xy[:, [-1]]

# x, y 데이터 구성을 출력합니다.
print(x_data.shape, y_data.shape)

# 0~6 까지 7까지 분류를 합니다.
nb_classes = 7 

# n 개의 데이터들이 16 가지 특징을 가집니다.
X = tf.placeholder(tf.float32, [None, 16])
# n 개의 데이터가 1개의 결과를 나타냅니다.
Y = tf.placeholder(tf.int32, [None, 1])  # 0 ~ 6
# One Hot 을 이용해 7개의 분류도 나누되 0,1 로 구분지을수 있도록 합니다. [[0],[3]] => [[[1000000]],[[0001000]]]
Y_one_hot = tf.one_hot(Y, nb_classes)  # one hot
print("one_hot", Y_one_hot)
# 차원이 하나 더 생겼으므로 차원을 제거합니다. [[[1000000]][[0001000]]] => [[1000000],[0001000]]
Y_one_hot = tf.reshape(Y_one_hot, [-1, nb_classes])
print("reshape", Y_one_hot)

# 입력은 16개 출력은 7가지로
W = tf.Variable(tf.random_normal([16, nb_classes]), name='weight')
# 출력은 7가지
b = tf.Variable(tf.random_normal([nb_classes]), name='bias')

# cost 를 계산한다.
# logits 는 결과 데이터 이며
logits = tf.matmul(X, W) + b
# 결과데이터를 softmax 를 이용하여 합계가 1 이되도록 확률로 계산하도록 가설을 세운다.

hypothesis = tf.nn.softmax(logits)

# cost 가 최소화되도록 한다.
# (cost = tf.reduce_mean(-tf.reduce_sum(Y * tf.log(hypothesis), axis=1)) 를 함수화 함)
cost_i = tf.nn.softmax_cross_entropy_with_logits(logits=logits, labels=Y_one_hot) 
cost = tf.reduce_mean(cost_i)
optimizer = tf.train.GradientDescentOptimizer(learning_rate=0.1).minimize(cost)

# 가설을 이용한 결과 값(prediction)과 onehot 을 이용한 결과 값이 같은지 비교하고 얼마나 정확한지 (accuracy)를 나타냅니다.
prediction = tf.argmax(hypothesis, 1)
correct_prediction = tf.equal(prediction, tf.argmax(Y_one_hot, 1))
accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))

# 학습합니다.
with tf.Session() as sess:
    sess.run(tf.global_variables_initializer())

    for step in range(2000):
        sess.run(optimizer, feed_dict={X: x_data, Y: y_data})
        if step % 100 == 0:
            loss, acc = sess.run([cost, accuracy], feed_dict={X: x_data, Y: y_data})
            print("Step: {:5}\tLoss: {:.3f}\tAcc: {:.2%}".format(step, loss, acc))

    # 학습한 결과로 엑셀데이터를 실제로 분류해봅니다.
    pred = sess.run(prediction, feed_dict={X: x_data})
    # flatten => [[0],[1]] => [0,1] ,zip 은 묶어서 처리하는것으로 아래 코드는 zip 으로 묶어 앞에껀 p 로 뒤에껀 y 로 처리한다는 의미.
    for p, y in zip(pred, y_data.flatten()):
        print("[{}] Prediction: {} True Y: {}".format(p == int(y), p, int(y))) # 결과(TRUE/FALSE), 예측한결과값, 실제값
        

아래 결과를 보면 알겠지만 accuracy 가 100% 입니다.
이를 보면 학습하는 데이터가 좋을수록 분류를 잘한다는걸 알 수 있습니다.

결과

더보기

어떤 결과치의 합을 1로 나타내도록 하는 것

여러 결과를 나타내고자 할때 사용된다. (A,B,C...)

A,B,C 를 판별한다고 할때

X값일때  A 인지 물어보면 결과가 0.7(A), 0.2(B), 0.1(C) 이런 식으로 나오게 된다

그러므로 X 일때 A 결과가 맞다고 보면된다.

이를 1.0, 0.0, .0.0 으로 명확하게 구분지으려고 할때는 ONE-HOT ENCODING 을 사용하면된다.

 

코드

import tensorflow as tf

x_data = [[1, 2, 1, 1],
          [2, 1, 3, 2],
          [3, 1, 3, 4],
          [4, 1, 5, 5],
          [1, 7, 5, 5],
          [1, 2, 5, 6],
          [1, 6, 6, 6],
          [1, 7, 7, 7]]
y_data = [[0, 0, 1],
          [0, 0, 1],
          [0, 0, 1],
          [0, 1, 0],
          [0, 1, 0],
          [0, 1, 0],
          [1, 0, 0],
          [1, 0, 0]]

X = tf.placeholder("float", [None, 4])
Y = tf.placeholder("float", [None, 3])
nb_classes = 3

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

# tf.nn.softmax computes softmax activations
# softmax = exp(logits) / reduce_sum(exp(logits), dim)
hypothesis = tf.nn.softmax(tf.matmul(X, W) + b)

# Cross entropy cost/loss
cost = tf.reduce_mean(-tf.reduce_sum(Y * tf.log(hypothesis), axis=1))

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

# Launch graph
with tf.Session() as sess:
    sess.run(tf.global_variables_initializer())

    for step in range(2001):
        sess.run(optimizer, feed_dict={X: x_data, Y: y_data})
        if step % 200 == 0:
            print(step, sess.run(cost, feed_dict={X: x_data, Y: y_data}))

    # 학습된 결과로 결론을 도출해봅니다.
    a = sess.run(hypothesis, feed_dict={X: [[1, 11, 7, 9]]})
    # argmax 는 그중에 최고값을 가려냅니다.
    print(a, sess.run(tf.argmax(a, 1)))

 결과

(0, 5.048625)
(200, 0.5484252)
(400, 0.43214869)
(600, 0.35246667)
(800, 0.27682927)
(1000, 0.23268281)
(1200, 0.21055315)
(1400, 0.19221503)
(1600, 0.17675203)
(1800, 0.16353439)
(2000, 0.15210819)
--------------
(array([[  1.38904958e-03,   9.98601854e-01,   9.06129117e-06]], dtype=float32), array([1]))

 

마지막줄에서 중간의 9.98601854e-01 값이 0.9 로 가장 큰 값을 가지므로 몇번째 있는지 확인하여 1 을 리턴한다. (0,1,2)

 

아래처럼 단일 값이 아닌 여러 값을 가지고 예측할수 있다.

 

    all = sess.run(hypothesis, feed_dict={
                   X: [[1, 11, 7, 9], [1, 3, 4, 3], [1, 1, 0, 1]]})
    print(all, sess.run(tf.argmax(all, 1)))

+ Recent posts