docker – create own

가. centOS Docker 설치

docker pull centos

https://hub.docker.com/_/centos/

나. Container 연결

centos Docker 를 기본으로 필요한 것들을 설치하고 이미지로 생성하여 개인 Repository 에 등록하는 순서로 진행하고자 한다.

docker run -t -i centos

 다. 개인 이미지를 만들자

컨테이너에 접속해서 원하는 라이브러리든 환경이든 구성을 한다.
예를 들면 아래와 같은 행위를 말하는 것이다. 지신이 설정하고자 하는 환경을 모두 구성한 후에 exit 명령어로 컨테이너를 종료한다

sudo yum groupinstall -y "Server with GUI"
sudo systemctl set-default graphical.target
sudo systemctl default
exit

라. Docker Commit

이제 아래와 같이 Docker 이미지를 Commit 하여 로컬에 이미지를 만든다

– m : 커밋 메시지
– a : Docker 만든 사람
– 0b261b… : 위에서 실행한 Container ID
– ouseruser/sintara:v1 : 만들고자 하는 Docker 명칭

$ docker commit -m "Added json gem" -a "Kate Smith" \
0b2616b0e5a8 tmddno1/tensormsa:v1

생성한 이미지를 확인해 보자. 정상적으로 만든 이미지가 조회가 되고 다시 컨테이너로 실행이 되면 정상이다.

docker images
docker run -t -i tmddno1/tensormsa:v1 /bin/bash

 

마. Docker Hub 에 계정 및 Repository 만들기

– https://hub.docker.com/ 에서 계정을 생성하고 Repository 를 만든다

지금까지 로컬에서 만든 이미지를 Docker Hub 에 올려서 공유해 보자
만들고 나면 docker pull tmddno1/tensormsa 이런식으로 자신의 경로가 생성된다

바. Docker Hub 에 업로드 하기

아래와 같이 로그인하고, 아까 만든 이미지를 PUSH 해주면 끝이다.

docker login 
docker push tmddno1/tensormsa

 사. Docker Hub 에서 받아서 다시 사용하기

받아서 사용하는 것은 중간에 했던 것과 동일하다.
아래와 같이 생성한 이미지를 PULL 하고 , 터미널에 실행하면 된다

docker pull tmddno1/tensormsa
docker run -t -i tmddno1/tensormsa:v1 /bin/bash

막 계정을 만들어서 최신 Tag 가 없다고 나온다면, 아래와 같이 실행하여 버전과 관계 없이 모든 내용을 다운 받도록 해보자

docker pull -a tmddno1/tensormsa

아. 사용하기

여기서 매우 중요한 것이 있다. Image 와 Container 는 다르다는 것이다.
Container 에서 아무리 수정을 하여도 Commit 하기 전까지 Image 는 절대 변경되지 않는다. 둘은 연관이 있으면서도 독립적인 관계인 것이다.
아래는 Container 관련 주요 명령어이다.

[리스트 보기]

sudo docker ps -a

[시작하기]

sudo docker start <containerID>
sudo docker attach <containerID>

[삭제하기]

sudo docker rm <containerID>

차. Docker 환경에서 Graphic 사용하기

원래 서버에는 XRDP 가 설치 되어있다고 가정하고 Container 생성시 아래와 같이 해주면 그래픽 사용가능

docker run -it --env="DISPLAY" --env="QT_X11_NO_MITSHM=1" --volume="/tmp/.X11-unix:/tmp/.X11-unix:rw" -p 8080:8080 -p 8998:8998 -p 8989:8989 -p 7077:7077 tmddno1/tensormsa:v1

Muliti – Terminal [Link]

PID=$(docker inspect --format {{.State.Pid}} 04fe75de21d4)
sudo nsenter --target $PID --mount --uts --ipc --net --pid

Container to Container Connection

sudo docker run --name db -d mongo
sudo docker run --name web -d -p 80:80 --link db:db nginx

Start Container with Daemon

docker run <option> -d <image> 
docker exec -it <container> bash

 

docker – install

처음 AWS EC2 환경을 구성하고 아무것도 없는 상태에서 테스트를 진행하였습니다.

AWS - EC2
OS : RedHat 64bit

가. 삭제하기

기존에 설치된 Docker 를 사용하거나, 신규 설치인 경우에는 불필요

yum list installed | grep docker
docker-engine.x86_64       1.12.1-1.el7.centos @docker-main-repo
sudo yum -y remove docker-engine.x86_64
rm -rf /var/lib/docker

나.  자동설치

sudo yum update 
curl -fsSL https://get.docker.com/ | sh

[trouble shooting when ssh related error happens]

sudo yum update 
curl -k -fsSL https://get.docker.com/ | sh

다. Docker 실행

sudo service docker start
sudo service docker stop
sudo service docker restart 

 라. Docker 그룹을 만든다

슈퍼 유저가 아닌 유저로도 Docker 가 잘 실행되도록 세팅하는 과정이다
(1) 슈퍼유저로 로그인 (2) 그룹 Docker 생성 (3) 그룹에 사용할 유저 추가 (4) root exit
(5) test : docker run hello-world

su
sudo groupadd docker
sudo usermod -aG docker ec2-user
exit
docker run hello-world

라. 필요 없는 이미지는 삭제

hello-world 이미지가 정상동작하는 것을 확인하고 깔끔하게 모든 Docker 이미지를 지워버리도록 하겠다

sudo docker run hello-world
docker stop $(docker ps -a -q) 
docker rm $(docker ps -a -q)

마. 부팅시 기동되도록 세팅

sudo chkconfig docker on

 

DJango – templates & static

가. 시작하기

장고에서 뷰를 개발하려고 하면 통상적으로 필요한 것이  html, js, css, img 정도가 될 것이다. 그럼 장고에서는 이러한 파일들을 어떻게 관리하고 개발하는지 세팅 부분까지만 정리하고자 한다

나. template 정의하기

[setting.py]

DIRS 부분에 templates 폴더의 위치를 지정해 준다.

TEMPLATES = [
    {
        'BACKEND': 'django.template.backends.django.DjangoTemplates',
        'DIRS': [os.path.join(BASE_DIR, 'tfmsaview/templates/')],
        'APP_DIRS': True,
        'OPTIONS': {
            'context_processors': [
                'django.template.context_processors.debug',
                'django.template.context_processors.request',
                'django.contrib.auth.context_processors.auth',
                'django.contrib.messages.context_processors.messages',
            ],
        },
    },
]
[urls.py]

아래 부분을 추가해 template 에 접근 할 수 있도록 한다

  url(r'^view/index/$', ui_view.UI_Service.as_view()),

[예제 전체]

urlpatterns = [
    url(r'^admin/', admin.site.urls),
    url(r'^nn/cnn/service/$', rest_view.CNN_Service.as_view()),
    url(r'^nn/cnn/config/$', rest_view.CNN_Config.as_view()),
    url(r'^nn/cnn/data/$', rest_view.CNN_Data.as_view()),
    url(r'^nn/cnn/stastics/$', rest_view.CNN_Stastics.as_view()),
    url(r'^view/index/$', ui_view.UI_Service.as_view()),
] + static(settings.STATIC_URL, document_root=settings.STATIC_ROOT)
[폴더 및 파일 생성]

실제 폴더를 만들고 static 으로 사용할 파일을 넣어 준다. template 도 아까 정의한 것처럼 폴더를 생성하고 html 을 넣어 준다.

%ec%8a%a4%ed%81%ac%eb%a6%b0%ec%83%b7-2016-09-11-12-16-50

[html sample code]

template 안에서 static (js, css, img) 를 불러서 사용하려면 아래와 같은 패턴으로 사용하면 된다.

{% load staticfiles %}
{% static 'img/a.png' %}

아래는 전체 예제 코드

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>
{% load staticfiles %}
<img src="{% static 'img/a.png' %}" alt="My image"/>
</body>
</html>

 다. STATIC 정의하기

기본적으로 3가지 정의는 필요하다. root 는 실제 서비스시 서버에서 이미지를 제공할 경로가 된다. url 은 urls.py 에서 정의하게 되는데 웹에서 접속시 접속 경로가 된다. dirs 는 사용자가 이미지를 올리고자 하는 위치가 된다. 뒤에서 커맨드를 실행하면 dirs 에 있는 파일이 root 로 자동으로 옮겨지는 것을 볼 수가 있다.

[settings.py]
STATIC_ROOT = os.path.join(BASE_DIR , 'tfmsaview/')
STATIC_URL = '/static/'
STATICFILES_DIRS = [
    os.path.join(BASE_DIR, "tfmsaview/static"),
]
 [urls.py]

아래부분을 추가해 준다. 이는 직접적으로 url 을 통해 이미지 등에 접근 할 수 있도록 도와준다

+ static(settings.STATIC_URL, document_root=settings.STATIC_ROOT)
urlpatterns = [
    url(r'^admin/', admin.site.urls),
    url(r'^nn/cnn/service/$', rest_view.CNN_Service.as_view()),
    url(r'^nn/cnn/config/$', rest_view.CNN_Config.as_view()),
    url(r'^nn/cnn/data/$', rest_view.CNN_Data.as_view()),
    url(r'^nn/cnn/stastics/$', rest_view.CNN_Stastics.as_view()),
    url(r'^view/index/$', ui_view.UI_Service.as_view()),
] + static(settings.STATIC_URL, document_root=settings.STATIC_ROOT)
[파일 생성]

settings.py 에 정의한 것 처럼 파일(js, css, img ) 등을 넣는다

%ec%8a%a4%ed%81%ac%eb%a6%b0%ec%83%b7-2016-09-11-12-16-50

[스태틱 파일들을 모아준다]

(/home/kim/anaconda2/) root@kim:~/PycharmProjects/TensorMSA# python manage.py collectstatic --noinput -i admin

 라. 테스트

다이렉트로 이미지에 접속도 잘 되었고, template 을 통한 이미지도 잘 접속 되었다.

%ec%8a%a4%ed%81%ac%eb%a6%b0%ec%83%b7-2016-09-11-12-26-34 %ec%8a%a4%ed%81%ac%eb%a6%b0%ec%83%b7-2016-09-11-12-26-46

 

CentOS LibreOffice 설치

참조 사이트

RedHat 계열 , 64Bit 기준으로 작성되었습니다.

가.필요한 파일 다운로드

wget http://download.documentfoundation.org/libreoffice/stable/5.2.0/rpm/x86_64/LibreOffice_5.2.0_Linux_x86-64_rpm.tar.gz

 나. 기존 버전 제거

yum remove openoffice* libreoffice*

 다. 압축해제

tar -xvf LibreOffice_5.2.0_Linux_x86-64_rpm.tar.gz

 라. 설치

# cd /tmp/LibreOffice_5.2.0.4_Linux_x86-64_rpm/RPMS/
# yum localinstall *.rpm

 

 

TensorFlow – 기본문법 (6) – CNN Load & Predict

niektemme/tensorflow-mnist-predict

위 의 github 를 참조하였으며, 로컬에서 파일 로드, 배열 변환, 모델 로드 및 실행까지 간단하게 코드가 잘 정리되어 있습니다.  여기까지는 기본 구조를 파악하기 위함이었으니 기존예제들을 분석하는 위주로 진행하였지만, 다음부터는 가변적인 데이터 구조와 가변적인 모델을 감안한 개발을 시작하고자 합니다.

가. 로컬 이미지 로드 및 배열로 변환

def imageprepare(argv):
    """
    로컬에서 이미지를 받아서 Tensorflow 처리 가능한 형태로 변환하는 역할을 수행합니다.
    """
    im = Image.open(argv).convert('L')
    width = float(im.size[0])
    height = float(im.size[1])
    newImage = Image.new('L', (28, 28), (255))  # 우리가 테스트할 네트워크는 28/28 이미지이다

    # 입력된 28/28이 아닌 이미지를 28/28로 변환하기 위해 가로 세로 중 어느쪽이 큰지 확인
    if width > height:
        # 폭이 더 큰 경우 처리 로직
        nheight = int(round((20.0 / width * height), 0))  # resize height according to ratio width

        # 20/20 이미지로 변환하고
        img = im.resize((20, nheight), Image.ANTIALIAS).filter(ImageFilter.SHARPEN)
        wtop = int(round(((28 - nheight) / 2), 0))  #
        newImage.paste(img, (4, wtop))  # 리사이즈된 이미지를 흰색 바탕의 캔버스에 붙여 넣는다
    else:
        # 높이가 더 큰경우에 처리 로직
        nwidth = int(round((20.0 / height * width), 0))
        if (nwidth == 0):
            nwidth = 1
            # resize and sharpen
        img = im.resize((nwidth, 20), Image.ANTIALIAS).filter(ImageFilter.SHARPEN)
        wleft = int(round(((28 - nwidth) / 2), 0))
        newImage.paste(img, (wleft, 4))

    # newImage.save("sample.png")

    tv = list(newImage.getdata())  # 픽셀 데이터로 변환

    # 255의 RGB 0 흰색, 1 검은색의 이진수로 노멀라이제이션 작업을 수행
    tva = [(255 - x) * 1.0 / 255.0 for x in tv]
    return tva

나. 훈련시 사용한 모델을 동일하게 재 정의 합니다.

x = tf.placeholder(tf.float32, [None, 784])
    W = tf.Variable(tf.zeros([784, 10]))
    b = tf.Variable(tf.zeros([10]))

    def weight_variable(shape):
        initial = tf.truncated_normal(shape, stddev=0.1)
        return tf.Variable(initial)

    def bias_variable(shape):
        initial = tf.constant(0.1, shape=shape)
        return tf.Variable(initial)

    def conv2d(x, W):
        return tf.nn.conv2d(x, W, strides=[1, 1, 1, 1], padding='SAME')

    def max_pool_2x2(x):
        return tf.nn.max_pool(x, ksize=[1, 2, 2, 1], strides=[1, 2, 2, 1], padding='SAME')

    W_conv1 = weight_variable([5, 5, 1, 32])
    b_conv1 = bias_variable([32])

    x_image = tf.reshape(x, [-1, 28, 28, 1])
    h_conv1 = tf.nn.relu(conv2d(x_image, W_conv1) + b_conv1)
    h_pool1 = max_pool_2x2(h_conv1)

    W_conv2 = weight_variable([5, 5, 32, 64])
    b_conv2 = bias_variable([64])

    h_conv2 = tf.nn.relu(conv2d(h_pool1, W_conv2) + b_conv2)
    h_pool2 = max_pool_2x2(h_conv2)

    W_fc1 = weight_variable([7 * 7 * 64, 1024])
    b_fc1 = bias_variable([1024])

    h_pool2_flat = tf.reshape(h_pool2, [-1, 7 * 7 * 64])
    h_fc1 = tf.nn.relu(tf.matmul(h_pool2_flat, W_fc1) + b_fc1)

    keep_prob = tf.placeholder(tf.float32)
    h_fc1_drop = tf.nn.dropout(h_fc1, keep_prob)

    W_fc2 = weight_variable([1024, 10])
    b_fc2 = bias_variable([10])

    y_conv = tf.nn.softmax(tf.matmul(h_fc1_drop, W_fc2) + b_fc2)

다. 모델 복구 및 실행

init_op = tf.initialize_all_variables()
 saver = tf.train.Saver()

 """
 모델을 saver 를 사용하여 복구합니다.
 sess.run(init_op)
 saver.restore(sess, "model2.ckpt")
 """
 with tf.Session() as sess:
     sess.run(init_op)
     saver.restore(sess, "model2.ckpt")
     prediction = tf.argmax(y_conv, 1)
     return prediction.eval(feed_dict={x: [imvalue], keep_prob: 1.0}, session=sess)

전체 코드 링크

TensorFlow – 기본문법 (5) – CNN Train & Save

가. 테스트 코드 개요

본 테스트 코드는 TensorFlow 를 활용하여 CNN , max pool , drop out, softmax 를 적용하여 MNLP(손글씨 예제)를 학습 시키고 저장하는 예제이다.

테스트 코드 다운로드

나. 테스트 데이터 로딩 및 변수 선언

아래처럼 메트릭스 연산이 수행되기 때문에 위와 같이 데이터 사이즈를 잡은 것이다.
x : 인풋레이어에 사용할 변수 정의
y : 아웃풋레이어에 사용할 변수 정의
w : 784 X 10 개의 초기값 0을 갖는 메트릭스 생성
b : 10개짜리 배열 생성
y = x * w + b
x (784) * w(784*10) = x*w(10)
x*w(10) + b(10) = y(10)

#레파지토리에서 테스트 프로그램에 필요한 데이터 다운로드
mnist = input_data.read_data_sets("MNIST_data/", one_hot=True)

sess = tf.InteractiveSession()

x = tf.placeholder(tf.float32, [None, 784])
y_= tf.placeholder(tf.float32, [None, 10])
W = tf.Variable(tf.zeros([784, 10]))
b = tf.Variable(tf.zeros([10]))
y = tf.nn.softmax(tf.matmul(x, W) + b)

 다. CNN(Convolutional Neural Network)

필터에 대해서 설명하고자 하면 CNN 의 동작 원리를 설명해야만한다. [5, 5, 1, 32] 는 5X5 사이즈의 단위 필터를 사용해서 인풋데이터(여기서는 28 X 28 사이즈 메트릭스)를 CNN연산을 하겠다는 것이다. Stride 가 [1,1] 이라고 하면 28X28크기 행렬을 5X5 사이즈의 메트릭스로가로세로 한칸씩 이동하면서 필터에 연산하겠다는 의미가 된다. 결과적으로 아웃풋은 24X24 사이즈가 된다. 왜냐하면 5X5 사이즈의  메트릭스로 이동할 수 있는 한계가 있기 때문이다. (메트릭스 끝부분 까지 이동할 수 없음) 이러한 경우 패딩 옵션을 사용하여 0으로 태두리를 채워넣어 메특릭스 사이즈를 동일하게 유지할 수도 있다
참조 :http://deeplearning4j.org/convolutionalnets.html

# 원하는 행렬 사이즈로 초기 값을 만들어서 리턴하는 메서드
def weight_variable(shape):
  initial = tf.truncated_normal(shape, stddev=0.1)
  return tf.Variable(initial)

# 0.1 로 초기값 지정하여 원하는 사이즈로 리턴
def bias_variable(shape):
  initial = tf.constant(0.1, shape=shape)
  return tf.Variable(initial)
def conv2d(x, W):
# tf.nn.conv2d(input, filter, strides, padding, use_cudnn
# _on_gpu=None, data_format=None, name=None)
# strides= [1 , stride, stride, 1] 차원축소 작업시 마스크 메트릭스를 이동하는 보복
# padding='SAME' 다음 레벨에서도 메특릭스가 줄어들지 않도록 패딩을 추가한다
  return tf.nn.conv2d(x, W, strides=[1, 1, 1, 1], padding='SAME')

# [filter_height, filter_width, in_channels, out_channels]
W_conv1 = weight_variable([5, 5, 1, 32])
b_conv1 = bias_variable([32])

 라. Max Pool

보통은 이렇게 생성한 메트릭스를 max pooling 을 사용하여 다시 한번 간소화한다.  위에서 필터링이 마스크에 대한 & 연산이었다면, max Pooling은 메트릭스에서 가장 큰 값 하나만 뽑아서 사용하는 방법이다. 아래와 같은 max pooling 정의 (mask [2,2] , stride[2,2] )를 4X4 메트릭스에 적용하면 2X2 메트릭스가 되는 것이다

# x :  [batch, height, width, channels]
# 2x2 행열에 가장 큰 값을 찾아서 추출, 가로세로 2칸씩이동
def max_pool_2x2(x):
  return tf.nn.max_pool(x, ksize=[1, 2, 2, 1],
                        strides=[1, 2, 2, 1], padding='SAME')

 마. Layer 1 :CNN + MaxPool

아래의 3줄로써 인풋 레이어에 대한 정의는 완료된다. 28X28 행렬 하나를 넣고 28X28행렬(원래는 24X24가 되지만 Padding 적용) 32개를 만들고 다시 max pool (2,2) 를 사용하여 14X14 메트릭스 32개를 리턴하는 레이어를 정의하였다
※ 메트릭스 단위로 정리하면 인풋 1개, 아웃풋 32개 이다

#인풋 데이터터 메트릭스를 변형한다. 784 개의 행렬을 갖는 복수의 데이터를
#[-1, 28, 28,1] 로 의 형태로 변형한다. 테스트 데이터 수 만큼 (-1) ,
#[28x28] 행렬로 만드는데 각 픽셀데이터는 rgb 데이터가 아니고 하나의 값만 갖도 변환
x_image = tf.reshape(x, [-1,28,28,1])
h_conv1 = tf.nn.relu(conv2d(x_image, W_conv1) + b_conv1)
h_pool1 = max_pool_2x2(h_conv1)

 바. Layer 2

1번 레이어에서 아웃풋을 32개를 전달하였음으로 2번 레이어의 인풋은 16X16 메트릭스 32개 그리고 아웃풋은 동일한 max pool 을 적용하여 8×8 메트릭스 64개를 출력한다.
정리하면 인풋 32개(14X14) 아웃풋 64개(7X7) 이 된다

W_conv2 = weight_variable([5, 5, 32, 64])
b_conv2 = bias_variable([64])

h_conv2 = tf.nn.relu(conv2d(h_pool1, W_conv2) + b_conv2)
h_pool2 = max_pool_2x2(h_conv2)

 사. Layer 3

현재 최종 데이터의 수는 7 X 7 X 64 = 3136 개 이지만 1024 개 를 사용한다
1024는 임의의 선택 값이다

W_fc1 = weight_variable([7 * 7 * 64, 1024])
b_fc1 = bias_variable([1024])
h_pool2_flat = tf.reshape(h_pool2, [-1, 7*7*64])
h_fc1 = tf.nn.relu(tf.matmul(h_pool2_flat, W_fc1) + b_fc1)

 아. Drop Out

Dropout 은 데이터 간의 연과 관계가 큰 데이터들을 제거함으로써 과적합 문제를 해결하는 기법의 하나이다.

# drop out 연산의 결과를 담을 변수
keep_prob = tf.placeholder(tf.float32)
h_fc1_drop = tf.nn.dropout(h_fc1, keep_prob)

차. Output Layer

마지막으로 1024개의 노드에서 10개의 (0~9까지 숫자)에 대한 확률을 Soft Max 를 이용하여 도출할 수 있도록 한다

W_fc2 = weight_variable([1024, 10])
b_fc2 = bias_variable([10])

y_conv=tf.nn.softmax(tf.matmul(h_fc1_drop, W_fc2) + b_fc2)

 카. 최적화

# Define loss and optimizer
cross_entropy = -tf.reduce_sum(y_*tf.log(y_conv))
train_step = tf.train.AdamOptimizer(1e-4).minimize(cross_entropy)
correct_prediction = tf.equal(tf.argmax(y_conv,1), tf.argmax(y_,1))
accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))

 타. 실행 및 저장

#50개씩, 20000번 반복학습
for i in range(20000):
  batch = mnist.train.next_batch(50)
  # 10회 단위로 한번씩 모델 정합성 테스트
  if i%100 == 0:
    train_accuracy = accuracy.eval(feed_dict={
        x:batch[0], y_: batch[1], keep_prob: 1.0})
    print("step %d, training accuracy %g"%(i, train_accuracy))
  # batch[0] 28X28 이미지,  batch[1] 숫자태그, keep_prob : Dropout 비율
  train_step.run(feed_dict={x: batch[0], y_: batch[1], keep_prob: 0.5})

# 모델에 사용된 모든 변수 값을 저장한다
save_path = saver.save(sess, "model2.ckpt")
print ("Model saved in file: ", save_path)

#최종적으로 모델의 정합성을 체크한다
print("test accuracy %g"%accuracy.eval(feed_dict={
    x: mnist.test.images, y_: mnist.test.labels, keep_prob: 1.0}))

sess.close()

 

[전체 코드]

# -*- coding: utf-8 -*-

"""
niektemme/tensorflow-mnist-predict 를 참조하였음

"""

import tensorflow as tf
from tensorflow.examples.tutorials.mnist import input_data

#레파지토리에서 테스트 프로그램에 필요한 데이터 다운로드
mnist = input_data.read_data_sets("MNIST_data/", one_hot=True)

sess = tf.InteractiveSession()
"""
모델 생성에 필요한 데이터 정의
x : 인풋레이어에 사용할 변수 정의
y : 아웃풋레이어에 사용할 변수 정의
w : 784 X 10 개의 초기값 0을 갖는 메트릭스 생성
b : 10개짜리 배열 생성
y = x * w + b
x (784) * w(784*10) = x*w(10)
x*w(10) + b(10) = y(10)
위에처럼 메트릭스 연산이 수행되기 때문에 위와 같이 데이터 사이즈를 잡은 것이다.
"""
x = tf.placeholder(tf.float32, [None, 784])
y_= tf.placeholder(tf.float32, [None, 10])
W = tf.Variable(tf.zeros([784, 10]))
b = tf.Variable(tf.zeros([10]))
y = tf.nn.softmax(tf.matmul(x, W) + b)


# 원하는 행렬 사이즈로 초기 값을 만들어서 리턴하는 메서드
def weight_variable(shape):
  initial = tf.truncated_normal(shape, stddev=0.1)
  return tf.Variable(initial)

# 0.1 로 초기값 지정하여 원하는 사이즈로 리턴
def bias_variable(shape):
  initial = tf.constant(0.1, shape=shape)
  return tf.Variable(initial)

"""
필터에 대해서 설명하고자 하면 CNN 의 동작 원리를 설명해야만한다.
[5, 5, 1, 32] 는 5X5 사이즈의 단위 필터를 사용해서 인풋데이터
(여기서는 28 X 28 사이즈 메트릭스)를 CNN연산을 하겠다는 것이다.
Stride 가 [1,1] 이라고 하면 28X28크기 행렬을 5X5 사이즈의
메트릭스로가로세로 한칸씩 이동하면서 필터에 연산하겠다는 의미가 된다.
결과적으로 아웃풋은 24X24 사이즈가 된다. 왜냐하면 5X5 사이즈의
메트릭스로 이동할 수 있는 한계가 있기 때문이다.
(메트릭스 끝부분 까지 이동할 수 없음)
이러한 경우 패딩 옵션을 사용하여 0으로 태두리를 채워넣어 메특릭스
사이즈를 동일하게 유지할 수도 있다
참조:http://deeplearning4j.org/convolutionalnets.html

"""
def conv2d(x, W):
# tf.nn.conv2d(input, filter, strides, padding, use_cudnn
# _on_gpu=None, data_format=None, name=None)
# strides= [1 , stride, stride, 1] 차원축소 작업시 마스크 메트릭스를 이동하는 보복
# padding='SAME' 다음 레벨에서도 메특릭스가 줄어들지 않도록 패딩을 추가한다
  return tf.nn.conv2d(x, W, strides=[1, 1, 1, 1], padding='SAME')


"""
보통은 이렇게 생성한 메트릭스를 max pooling 을 사용하여 다시 한번 간소화한다.
위에서 필터링이 마스크에 대한 & 연산이었다면, max Pooling은 메트릭스에서 가장
큰 값 하나만 뽑아서 사용하는 방법이다. 아래와 같은 max pooling 정의
(mask [2,2] , stride[2,2] )를 4X4 메트릭스에 적용하면 2X2 메트릭스가 될 것이다
"""
# x :  [batch, height, width, channels]
# 2x2 행열에 가장 큰 값을 찾아서 추출, 가로세로 2칸씩이동
def max_pool_2x2(x):
  return tf.nn.max_pool(x, ksize=[1, 2, 2, 1],
                        strides=[1, 2, 2, 1], padding='SAME')


# [filter_height, filter_width, in_channels, out_channels]
W_conv1 = weight_variable([5, 5, 1, 32])
b_conv1 = bias_variable([32])

"""
Layer 1
아래의 3줄로써 인풋 레이어에 대한 정의는 완료된다. 28X28 행렬 하나를 넣고
28X28행렬(원래는 24X24가 되지만 Padding 적용) 32개를 만들고 다시 max pool
(2,2)를 사용하여 14X14 메트릭스 32개를 리턴하는 레이어를 정의하였다
메트릭스 단위로 정리하면 인풋 1개, 아웃풋 32개 이다 트
"""
#인풋 데이터터 메트릭스를 변형한다. 784 개의 행렬을 갖는 복수의 데이터를
#[-1, 28, 28,1] 로 의 형태로 변형한다. 테스트 데이터 수 만큼 (-1) ,
#[28x28] 행렬로 만드는데 각 픽셀데이터는 rgb 데이터가 아니고 하나의 값만 갖도 변환
x_image = tf.reshape(x, [-1,28,28,1])
h_conv1 = tf.nn.relu(conv2d(x_image, W_conv1) + b_conv1)
h_pool1 = max_pool_2x2(h_conv1)

"""
Layer 2
1번 레이어에서 아웃풋을 32개를 전달하였음으로 2번 레이어의 인풋은
14X14 메트릭스 32개 그리고 아웃풋은 동일한 max pool 을 적용하여 8x8 메트릭스
64개를 출력한다. 정리하면 인풋 32개(14X14) 아웃풋 64개(7X7) 이 된다
"""
W_conv2 = weight_variable([5, 5, 32, 64])
b_conv2 = bias_variable([64])

h_conv2 = tf.nn.relu(conv2d(h_pool1, W_conv2) + b_conv2)
h_pool2 = max_pool_2x2(h_conv2)

"""
Layer 3
현재 최종 데이터의 수는 7 X 7 X 64 = 3136 개 이지만 1024 개 를 사용한다
1024는 임의의 선택 값이다
"""
W_fc1 = weight_variable([7 * 7 * 64, 1024])
b_fc1 = bias_variable([1024])
h_pool2_flat = tf.reshape(h_pool2, [-1, 7*7*64])
h_fc1 = tf.nn.relu(tf.matmul(h_pool2_flat, W_fc1) + b_fc1)


"""
Drop Out
Dropout 은 데이터 간의 연과 관계가 큰 데이터들을 제거함으로써 과적합 문제를
해결하는 기법의 하나이다.
"""
# drop out 연산의 결과를 담을 변수
keep_prob = tf.placeholder(tf.float32)
h_fc1_drop = tf.nn.dropout(h_fc1, keep_prob)


"""
Out put Layer
마지막으로 1024개의 노드에서 10개의 (0~9까지 숫자)에 대한 확률을 Soft Max 를
이용하여 도출할 수 있도록 한다
"""
W_fc2 = weight_variable([1024, 10])
b_fc2 = bias_variable([10])

y_conv=tf.nn.softmax(tf.matmul(h_fc1_drop, W_fc2) + b_fc2)

# Define loss and optimizer
cross_entropy = -tf.reduce_sum(y_*tf.log(y_conv))
train_step = tf.train.AdamOptimizer(1e-4).minimize(cross_entropy)
correct_prediction = tf.equal(tf.argmax(y_conv,1), tf.argmax(y_,1))
accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))


"""
Train & Save Model
"""
saver = tf.train.Saver()
sess.run(tf.initialize_all_variables())

#50개씩, 20000번 반복학습
for i in range(20000):
  batch = mnist.train.next_batch(50)
  # 10회 단위로 한번씩 모델 정합성 테스트
  if i%100 == 0:
    train_accuracy = accuracy.eval(feed_dict={
        x:batch[0], y_: batch[1], keep_prob: 1.0})
    print("step %d, training accuracy %g"%(i, train_accuracy))
  # batch[0] 28X28 이미지,  batch[1] 숫자태그, keep_prob : Dropout 비율
  train_step.run(feed_dict={x: batch[0], y_: batch[1], keep_prob: 0.5})

# 모델에 사용된 모든 변수 값을 저장한다
save_path = saver.save(sess, "model2.ckpt")
print ("Model saved in file: ", save_path)

#최종적으로 모델의 정합성을 체크한다
print("test accuracy %g"%accuracy.eval(feed_dict={
    x: mnist.test.images, y_: mnist.test.labels, keep_prob: 1.0}))

sess.close()

 

Python – TensorFlow – Django 개발환경 구축 종합

가. OS  환경 구축 및 기본 설정 (링크)
Linux 계정 생성

나. Anaconda 및 Pycharm 설치 (링크)

다. GitHub – Pycharm  연동 (링크)

라. Django – Rest F/W – TensorFlow 연동
설치 및 개발 1부
설치 및 개발 2부
설치 및 개발 3부

마.  Jenkins  CI 환경 구축 및 활용 (링크)

PyCharm – Git 연동

가.   Git Account Create

아래의 주소에 접속하여 계정을 생성

– URL : https://github.com/

나. 프로젝트를 생성스크린샷, 2016-09-03 11-58-04

다. Pycharm 연동

[상단 메뉴 > VCS >> Check Out from .. >> Github]

아래와 같은 창이 나오면, 아까 생성했던 계정을 입력해 주세요

스크린샷, 2016-09-03 12-00-08

[해당 환경에서 앞으로 사용할 비밀번호 생성]

스크린샷, 2016-09-03 12-01-05

[어떤 프로젝트를 가지고 올지 결정] 스크린샷, 2016-09-03 12-02-03

[프로젝트 로드 완료]  스크린샷, 2016-09-03 12-03-24

[자원 커밋하기]

GIT   에 자원은 커밋하는 순서는  add > commit > push  순서이다.
커밋하고자 하는 자원을 선택하고 > 마우스 우클릭 >  git 메뉴에서 (add, commit, push) 를선택하여 수행할 수 있다.

커밋시에 Description  은 필수 사항이다

스크린샷, 2016-09-03 12-11-01 스크린샷, 2016-09-03 12-11-22