TensorFlow – 기본문법 (2)

가. Variables

[잘못된 사용의 예]

# CASE1
# 아래처럼은 동작하지 않음, 왜 냐면 Tensor 연산은 Session 위에서 이루어져야 하기 때문
try :
# 일반적인 변수처럼 처리하려고 하면 발생한느 현상
x = tf.constant(35, name='x')
y = tf.Variable(x + 5, name='y')

#<tensorflow.python.ops.variables.Variable object at 0x7fabe98cced0>
print(y)
except:
print("ERROR-1")

[잘 사용한 예]

# CASE2
# 아래처럼 실행하면 40이 리턴됨
try :
    x = tf.constant([35, 40, 45], name='x')
    y = tf.Variable(x + 5, name='y')

    # 지금까지 정의한 변수를 Session 에서 사용할 수 있도록 초기화 합니다
    model = tf.initialize_all_variables()

    # with Session as 구분 사용시 Session 종료는 자동
    with tf.Session() as session:
        session.run(model)
        print(session.run(y))
except:
    print("ERROR-2")

[Numpy 를 사용하여 사이즈간 큰 데이터 생성 및 처리 테스트]

# CASE3
# numpy 를 사용해서 사이즈가 큰 데이터를 생성하고 식을 조금 복잡하게 수행
try:
    data = np.random.randint(1000, size=10000)
    x = tf.constant(data, name='x')
    y = tf.Variable(x**2 + 5*x + 5, name='y')

    model = tf.initialize_all_variables()

    with tf.Session() as session:
        session.run(model)
        print(session.run(y))
except:
    print("ERROR-3")

 

[루프 연산]

# CASE4
# for i in range(5): 을 사용한 루프 연산
try:
    x = tf.Variable(0, name='x')

    model = tf.initialize_all_variables()

    with tf.Session() as session:
        for i in range(5):
            session.run(model)
            x = x + 1
            print(session.run(x))

except:
    print("ERROR-4")

 

[TensorBoard 연동]

TensorBoard는 별도의 실행이 필요한 Tool 로써 아래와 같이 사용하면 됨

# 실행 방법 :  tensorboard --logdir=/tmp/basic
# http://localhost:6006

[분석 파일 생성 ]

# CASE5
# TensorBoard 를 활용한 그래프 출력
try:
    data = np.random.randint(1000, size=10000)
    x = tf.constant(data, name='x')
    y = tf.Variable(x**2 + 5*x + 5, name='y')

    with tf.Session() as session:

        merged = tf.merge_all_summaries()
        writer = tf.train.SummaryWriter("/tmp/basic", session.graph)
        model = tf.initialize_all_variables()
        session.run(model)
        print(session.run(y))

        # 실행 방법 :  tensorboard --logdir=/tmp/basic
        # http://localhost:6006
except:
    print("ERROR-5")

나.  Array

[이미지 로딩]

# -*- coding: utf-8 -*-
import os
import tensorflow as tf
import matplotlib.image as mpimg

# 이미지를 로딩한다
filename = os.path.dirname(__file__) + "/MarshOrchid.jpg"
image = mpimg.imread(filename)
height, width, depth = image.shape

# 이미지의 메트릭스 형태 출력
print("1. Initial : height :{0} , width :{1} , depth :{2}".format(height, width, depth))

 

[축을 변경]

perm 에서 데이터 순서대로 축의 순서를 의미하며, 입력하는 숫자가 바꾸고 싶은 축의
변호가 된다. 아래의 예는 2 번 축과 3 번 축을 서로 바꾸겠다라는 의미가 된다

tf.transpose(x, perm=[0, 2, 1])
# 축을 변경한다
try:
    x = tf.Variable(image, name='x')

    model = tf.initialize_all_variables()

    with tf.Session() as session:
        # Array 위치가 축 (x,y,z), 거기에 입력하는 숫자가 바꾸고 싶은 차원
        x = tf.transpose(x, perm=[0, 2, 1])
        #x = tf.transpose(x, perm=[0 ,1, 2])
        session.run(model)
        result = session.run(x)

    height, width, depth = result.shape
    print("2. Transpose : height :{0} , width :{1} , depth :{2}".format(height, width, depth))

except Exception as err:
    print(err)

 

[데이터 순서 정렬]

뭔가 약간 잘 이해가 안가는 부분이 있는데 우선 아래 처럼 사용하면 X 축 데이터에 대해
역순으로 재 정렬하게 된다.

# 배열의 순서를 변경한다
try:
    #보기 좋게 데이터를 축소해보자
    tem_len = 2
    temp_img = image[0:tem_len][0:tem_len]

    x = tf.Variable(temp_img, name='x')
    model = tf.initialize_all_variables()

    #변경전 데이터 출력
    for i in range(tem_len):
        for j in range(tem_len):
            print("Before :[{0},{1}] : {2}".format(i, j, temp_img[i][j]))


    #다른 메서드들 : https://www.tensorflow.org/versions/r0.10/api_docs/python/array_ops.html
    #x는 인풋 데이터
    #데이터 사이즈 [width] * height = [5, 5, 5, 5, 5] 생성
    # seq_dim 1 : 데이터의 순서가 역순으로 정렬 됨
    # seq_dim 2 : 데이터 안의 내용이 역순 정렬
    #seq_dim 3 : seq_dim must be < input.dims() (3 vs 3)
    #batch_dim = 0 위에서 아래로 연산 수행
    with tf.Session() as session:
        x = tf.reverse_sequence(x, [tem_len] * tem_len, 2, batch_dim=0)
        session.run(model)
        result = session.run(x)

    #변경후 데이터 출력
    for i in range(tem_len):
        for j in range(tem_len):
            print("After :[{0},{1}] : {2}".format(i, j, result[i][j]))

except Exception as err:
    print(err)

 

다.  PlaceHolder

아래는 PlaceHolder  를 설명하는 예제이다 . PlaceHolder 란 값은 미정인데, 어떤 타입, 데이터 구조를 갖는 데이터를 정의하겠다라는 말이다.

아래는 어떤 데이터인지는 모르겠지만,  float  타입으로 사이즈가 3인 데이터를 정의하겠다라는 것이다. 만약 데이터의 수도 정의할 수 없다면 None 을 정의해주면 된다.

x1 = tf.placeholder("float", 3)
x2 = tf.placeholder("float", None)

이렇게 정의한 데이터는 아래와 같이 실제 데이터를 맵핑할 수 있다

with tf.Session() as session:
    result = session.run(y, feed_dict={x1: [1, 2, 3], x2: [1, 2, 3], x3: [1, 2, 3] })

[전체 코드]

# -*- coding: utf-8 -*-
import tensorflow as tf
import numpy as np


# 데이터 타입, 사이즈 정의 ,None은 무한대
x1 = tf.placeholder("float", 3)
x2 = tf.placeholder("float", None)
x3 = tf.placeholder("float", 3)
y = x1 * 2 + x2 + x3

# 데이터의 형태는 아래와 같이 이중 배열로로 정의 가능
x4 = tf.placeholder("float", [None, 3])
y2 = x4 + 1

# 기본적으로 연산하려면 세션에서 해야됨
with tf.Session() as session:

    # 데이터 직접 삽입
    result = session.run(y, feed_dict={x1: [1, 2, 3], x2: [1, 2, 3], x3: [1, 2, 3] })
    print(result)

    # 데이터 직접 삽입
    x_data = [[1, 2, 3], [4, 5, 6], ]
    result2 = session.run(y2, feed_dict={x4: x_data})
    print(result2)


# 이미지와 동일하게 가로, 세로, RGB 처럼 표현하는 테스트 데이터를 만들어 보자
data1 = np.random.randint(10)    # 이미지로 치면 빨간색
data2 = np.random.randint(10)    # 초록색
data3 = np.random.randint(10)    # 파란색

# 이미지로 치면 3색 표현 , 가로 5, 세로 5 인 이미지가 되겠다
raw_image_data = [[[data1, data2, data3]] * 5 ] * 5

# 데이터! 출력
print("1. Original : {0}".format(raw_image_data))

# 홀더를 만든다 이홀더는 가로 세로 사이즈 제한은 없고 색은 3가지 RGB 로 표현
# 하는 모든 데이터를 커버 할 수 있다
image = tf.placeholder("uint8", [None, None, 3])

# 메트릭스를 자른다, 첫번째는 소스 메트릭스, 두번재는 시작 주소, 세번째는 끝 메트릭스
# 시작과 끝 사이의 데이터만 리턴한다, -1은 데이터 최대 길이라는 이야기다
slice = tf.slice(image, [0, 0, 0], [-1, 1, -1])

# 슬라이스를 연산한다
with tf.Session() as session:
    result = session.run(slice, feed_dict={image: raw_image_data})

# 슬라이스 연산후 데이터
print("2. Transformed : {0}".format(result))

 

[결과]

/root/anaconda2/bin/python /root/PycharmProjects/TensorLearn/chap3_placeholder.py
[  4.   8.  12.]
[[ 2.  3.  4.]
 [ 5.  6.  7.]]
1. Original : [[[3, 5, 9], [3, 5, 9], [3, 5, 9], [3, 5, 9], [3, 5, 9]], [[3, 5, 9], [3, 5, 9], [3, 5, 9], [3, 5, 9], [3, 5, 9]], [[3, 5, 9], [3, 5, 9], [3, 5, 9], [3, 5, 9], [3, 5, 9]], [[3, 5, 9], [3, 5, 9], [3, 5, 9], [3, 5, 9], [3, 5, 9]], [[3, 5, 9], [3, 5, 9], [3, 5, 9], [3, 5, 9], [3, 5, 9]]]
2. Transformed : [[[3 5 9]]

 [[3 5 9]]

 [[3 5 9]]

 [[3 5 9]]

 [[3 5 9]]]

 

라.  Interactive Session

[기존 방식]

# CASE 1 : with session syntax
# 아래와 같이 사용시 자동으로 세션이 종료됨, 단 Sessin.run 을 일일히 실행 필요
try:

    x = tf.constant(data, name='x')
    y = tf.Variable(x**2 + 5*x + 5, name='y')

    model = tf.initialize_all_variables()

    with tf.Session() as session:
        session.run(model)
        print(session.run(y))
except:
    print("ERROR-1")

 

[interactive 방식]

# CASE 2 : InteractiveSession
# 매번 session.run 을 할 필요가 없음, 단 마지막에 session.close() 필수
try:
    session = tf.InteractiveSession()
    x = tf.constant(data, name='x')
    y = x ** 2 + 5 * x + 5
    print(y.eval())

    session.close()

except:
    print("ERROR-2")

 

TensorFlow – 기본 문법 (1)

공식 사이트 : https://www.tensorflow.org/versions/r0.10/how_tos/variables/index.html#variables-creation-initialization-saving-and-loading

공식사이트에 있는 튜토리얼 내용을 직접 예제를 만들어 보면서  그 내용을 정리
하고자 함

가 . Variables  의 생성과 저장

시작하기에 앞서  Variables  에 대해서 설명할 필요가 있다. 모델을 구성하는 주요 값인
WEIGHT , BIAS 와  같은 학습 값의 구조, 초기 값 등을 정의하는 변수이다.

[초기값 정의 방법]

스크린샷, 2016-08-28 08-54-19

[chap1_save_variables.py]

변수를 생성하고 파일로 저장하는 예제 코드

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

import tensorflow as tf

def main(_):
    # 탠소플로우 변수 생성 , 파이선 리턴 값은 tf.Variable 이 된다.
    weights = tf.Variable(tf.random_normal([784, 200], stddev=0.35),name="weights")
    biases = tf.Variable(tf.zeros([200]), name="biases")

    # 위에 정의한 변수를 변형하여 다른 이름으로 재 정의 할 수 있다
    w2 = tf.Variable(weights.initialized_value(), name="w2")
    w_twice = tf.Variable(weights.initialized_value() * 2.0, name="w_twice")
    temp1 = tf.constant(5.0)
    temp2 = tf.constant(10.0)
    temp3 = tf.add(temp1, temp2)

    # 값을 찍어 보면 탠소 플로우 베리어블 객체의 내용을 확인 가능
    print("weight : " + str(weights.initialized_value()))
    print("biases : " + str(biases.initialized_value()))
    print("w2 : " + str(w2.initialized_value()))
    print("w_twice : " + str(w_twice.initialized_value()))
    print("temp1 : " + str(temp1))
    print("temp2 : " + str(temp2))
    print("temp3 : " + str(temp3))

    # 위에 정의한 변수들을 실제로 탠소플로우 모델 메모리에 등록한다
    init_op = tf.initialize_all_variables()

    print(init_op)
    # 값을 직어 보면 아래와 같다
    # name: "init"
    # op: "NoOp"
    # input: "^weights/Assign"
    # input: "^biases/Assign"
    # input: "^w2/Assign"
    # input: "^w_twice/Assign"


    #저장에는 tf.train.Saver 를 사용한다
    saver = tf.train.Saver()

    # 실제 메모리와 코어를 사용할 세션을 생성
    with tf.Session() as sess:
        # 메모리에 등록하는 액션을 실제로 실행
        result = sess.run(init_op)

        # 더하기 연산 수행과 그 결과
        result2 = sess.run(temp3)
        print("result2 : " + str(result2))

        #지정한 경로에 해당 세션의 모든 정보를 저장한다
        save_path = saver.save(sess, "/tmp/model.ckpt")
        print("Model saved in file: %s" % save_path)


if __name__ == '__main__':
  tf.app.run()

 

스크린샷, 2016-08-28 08-58-03

 

나. 저장된 데이터의 복구

[chap2_restore_variables.py]

저장한 변수들을 로드하는 예제 , 실제로는 모델을 훈련하는 과정 후에 저장이 되었어야
하지만 모델을 훈련하는 과정은 생략되어 있음

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

import tensorflow as tf


def main(_):
    # 저장할때와 마찬가지로 변수명 자체는 생성 필요 . 이니셜 값 자체는 동일해야 함
    weights = tf.Variable(tf.random_normal([784, 200], stddev=0.35),name="weights")
    biases = tf.Variable(tf.zeros([200]), name="biases")
    w2 = tf.Variable(weights.initialized_value(), name="w2")
    w_twice = tf.Variable(weights.initialized_value() * 5.0, name="w_twice")
    temp1 = tf.constant(0.0)
    temp2 = tf.constant(0.0)
    temp3 = tf.add(temp1, temp2)

    # 값을 찍어 보면 탠소 플로우 베리어블 객체의 내용을 확인 가능
    print("weight : " + str(weights.initialized_value()))
    print("biases : " + str(biases.initialized_value()))
    print("w2 : " + str(w2.initialized_value()))
    print("w_twice : " + str(w_twice.initialized_value()))
    print("temp1 : " + str(temp1))
    print("temp2 : " + str(temp2))
    print("temp3 : " + str(temp3))

    #저장에는 tf.train.Saver 를 사용한다
    saver = tf.train.Saver()

    # 실제 메모리와 코어를 사용할 세션을 생성
    with tf.Session() as sess:
        #
        saver.restore(sess, "/tmp/model.ckpt")
        print("Model restored.")

        # 값을 찍어 보면 탠소 플로우 베리어블 객체의 내용을 확인 가능
        # 더하기 연산 수행과 그 결과
        result2 = sess.run(temp3)
        print("result2 : " + str(result2))

if __name__ == '__main__':
  tf.app.run()

 

스크린샷, 2016-08-28 08-58-30

Python 요약 정리

Certificate

좋은 어플이 있다. “Learn Python” 시간날 때마다 짬잠히 보다보니 일주일만에
완독. 단계별 설명, 예제, 실습, 연습문제, 단계별 평가문제까지 구성이 굉장히 잘
되어 있다. 다른 언어를 사용한 경험이 있다면 아주 쉽게 학습이 가능하다.
다만 문법중에 외워서 사용해야 할 것들이 있으니 Java 와 syntax 나 개념이
상이한 것 위주로 요약 노트처럼 정리해 보고자 한다.

가) Basic Concept

– 11 / 0 : 0으로 나누면 ZeroDivisionError 발생
– 3/4 = 0.75 : 정수로 나눠도 Float 타입이 된다
– 3 * 2.0 = 6.0 : Float 이랑 곱하면 당연히 Float
– 2**5 : ** 는 제곱 연산
– 20 // 6 = 3 : 몫을 연산한다
– String 은 “abcd”
– 특수문자는 \ 후 입력
– “”” 내용 “”” 으로 표현시 줄바꿈 자동 인식
– print(내용) : 콘솔 출력
– input() : 사용자 입력
-‘x’ * 3 = xxx : num * String 은 String 반복
– int(“1”) , float(“1”) : 타입 변환

나) Control Structures

(1) if
아래의 예제로 if , elif, else 의 문법은 설명이 되었고 특이한 것이 괄호를 사용하지
않고 Space 혹은 Tab 으로 줄을 맞춰서 Depth 을 인식한다는 점이 특이하다

if 10 > 5: 
    print("XXX")
    print("XXX")
    if 10 > 5 : 
      print("YYY")
elif : 
   print("SSS")
else : 
   print("ZZZ")

(2) boolean
not, and, or 연산자를 사용하여 Boolean 연산을 한다

not 1==1 and 1==2 or 1==1

(3) 기타 연산자2016-08-27-22-15-39

(4) while
예제 보면 java 랑 크게 다른 것은 없다. indent 로 Depth 를 구분한다는 점만 기억

while True :
  i = i+1 
  if i==2:
    continue
  if i==3:
    break

(5) LIST

ttt = ["sting", 0 , [1,2,3] , 1.1]
print ttt[2][2] 
# 2 출력 

str = "abcd"
print(str[1])
# b 출력 

nums = [1,2,3] 
print(nums + [4,5,6])
print(nums * 2) 
# [1,2,3,4,5,6]
# [1,2,3,1,2,3]

str = ["aaa", "bbb" ,"ccc"] 
print("aaa" in str) 
print("aaa" not in str)
#true
#false
nums = [1,2,3]
nums.append(4) 

#[1,2,3,4]

len(nums)

#4

nums.insert(0,0)

#[0,1,2,3,4]

str = ['a','b','c']
str.index('a')

#0

 

(6) Range

range(5) 
range(0,5)
range(0,5,2)

#[0,1,2,3,4]
#[0,1,2,3,4]
#[0,2,4]

 

(7) for

words = ["aaa","bbb","ccc"]
for word in words:
  print(word)

#aaa
#bbb
#ccc

다. Function & Module

(1) function
function 도 마찬가지로 아래 예제 하나면 끝

def add(x,y):
  return x + y 

def test(func, x, y)
  return func(func(func(x,y), func(x,y))

a = 5
b = 10 

print(test(add, a, b))

#30

(2) 주석

# abcd abcd  

""" abcd abcd 
    abcd abcd 
"""

(3) Module

import random as ran
ran.randint(1,6) # 1~6사이 랜덤 

from math import pi # from 은 패키지 경로 import 는 Class

 

라. Exception & File

(1) Exception 종류

2016-08-27-22-51-02

 

(2) Exception Catch

try : 
  print("xxx")
exception 캐치할 종류 
  print("--------")
finally:
  print("xxxxxxx")

(3) Raise Exception

raise NameError("invaild Name Error")

#NameError : invaild Name Error

(4) Assertions

def aaa(x,y):
  return x+y 
asert aaa(1,1) == 3 

#AssertionError

(5) Opening Files

try:
  file = open("filename.txt" , "w")   # 쓰기 모드 
  file = open("filename.txt" , "r")   # 일기 모드 
  file = open("filename.txt" , "wb")  # 바이트 쓰기 모드 

  file.write("xxxxx")
  file.read()
finally:
  file.close()

마. 다른 타입

(가) Null = NONE

(나) Dictionaries

dic = { 
  "red" :[255,0,0],
  "blue" :[255,0,0],
  "green" :[255,0,0],
}

print(dic["red"])
#[255,0,0]

print("red" in dic)
#true 

print(dic.get("red"))
#[255,0,0]

print(dic.get("xxx"))
#None

(다) Tuples

Tuple 은 변형이 불가능한 데이터 타입  그 외의 속성은 리스트와 동일

tup = ("aaa","bbb","ccc")

(라) List

squa = [0,1,2,3,4,5,6]
print(squa[0:2])
print(squa[:2])  # 표시 안하면 무한대 R문법 이랑 비슷
print(squa[2:])
print(squa[2::2] # 2부터 2개씩 끝날때 까지 
print(squa[2:-1] # 2부터 맨뒤에서 하나 빼고

(마) List 조건문

이런 부분들은 R 과 유사한 점이 많다

evens = [i**2 for i in range(10) if i**2 %2==0]  # 0~9 까지짝수의 제곱 
#[0,4,16,36,64]

(바) String Formatting

nums = [4,5,6]
msg = "Number: {0}{1}{2}".format(nums[0],nums[1],nums[2])
print(msg)

#Number : 4 5 6

(사) 유용한 기능들

print(",".join(["spam","eggs","ham"]))
#"spam,eggs,ham"

print("Hello Me".replace("ME","world"))
#Hello Wrold 

print("this is a senstence.".startswith("this"))
#true 

print("this is a sensrence.".ensswith("sentence.")) 
#true 

print("this is a senstence".upper())
#THIS IS A SENSTENCE

print("AN ALL CAPS SENTENCE".lower())
#an all caps sentence 

print("spam, eggs, ham".split(","))
#["spam","eggs","ham"]
print(min(1,2,3,4,5))
#1
print(max([1,2,3,4,5])
#5
print(abs(-99))
#99
print(abs(42))
#42
print(sum([1,2,3,4,5]))
#15
nums = [55,44,22,33,11]
if all([i>5 for i in nums]):
  print("true 1")
# true 1

if any([i%2 ==0 for i in nums]):
  print("true 2")
# true 2

for v in enumerate(nums):
  print(v)
# (0,55)
# (1,44)
# (2,22)

바 . Functional Programming

(1) Lamda

print((lambda x:x**2 +5)(-4))
# -11 출력 

double = lambda x:x*2 
print(double(7))
# 14 출력

(2) map

뭔가 R 에 있는 apply 류 함수 같은 느낌의 함수들

def add_five(x):
  return x+5 

nums = [11,22,33]
result = list(map(addfive, nms))           # 함수 적용
print(result)
# [16,27,38]

res = list(filter(lambda x:x%2==0, nums))  # 조건 검색 
print(res)
# [16, 38]

 

(3) Generators

이건 좀 생소하다. 마치 일반 변수를 즉석해서 array로 만든느 그럼 느낌

def countdown():
i=5
  while i>0:
    yield i
    i -= 1

for i in countdown():
  print(i)

#5
#4
#3
#2
#1

def numbers(x):
  for i in range(x):
    if i%2 ==0:
      yield i

print(list(numbers(11)))

#[1,2,4,6,8,10]

 

(4) decoration

def decor2(func):  def wrap():
    print("============")
    func()
    print("============")
  return wrap

@decor2 
def print_text():
  print("Hello World!")

print_text();

#==============
#Hello World!
#==============

 

(5) recursion

여기서 if x==1 구문이 없으면 무한 반복이 되어 애러가 난다, recursion 은
무한 반복이 되지 않도록 End 지점을 지정하는 것이 중요하다

def factorial(x):
  if x== 1:
    return 1 
  else :
    return x * factoral(x-1)

print(factoral(5))

#120

 

(6) Data Structures

– Dictionaries : Key:Value  , 변경 가능
. {key :vlaue , key:value }
– Lists : 순차적 접근, 중복허용, 변경 가능
. [1,2,3,4,]
– Tuple : 중복 허용, 순차적 접근, 변경 불가
. (1,2,3,4,)
– Sets : 중복 불가, 변경 가능
. {1,2,3,4,}
. sets = set([1,2,3,4,])

nums = {1,1,2,2,3,3,}
nums.add(-1)
print(nums)
nums.remove(1)
print(nums)

# {-1,1,2,3,}
# {-1,2,3,}

fi = {1,2,}
se = {2,3,}
print(fi | se)
print(fi & se)
print(fi -se)
print(fi ^ se)

# {1,2,3,}
# {2}
# {1}
# {1,3,}

 

(7) Itertools

from itertools import count, cycle, repeat, accumulate, takewhile, product, permutations 

for i in count(3) # 3부터 무한대로 증가
for i in cycle(리스트) # 리스트 무한반복 
for i in repeat(오브젝트) # 오브젝트 반복 
list(accumulate(range(5)) # 1,3,6 이런식으로 누계 연산 
list(takewhile(lambda x:x <=6, nums)) # 조건에 맞는 대상 리턴 

letters1 = ("A","B")
letters2 = ("C","D")

list(product(letters1, letters2))
# [('A','C') , ('A','D'), ('B','C'),('B','D')]

list(permutation(letters1))
# [('A','B') , ('B','A')]

 

사. Object Oriented Programming

(1) Class

class Dog:
  def __init__(self, name, color):
    self.name = name 
    self.color = color 
  
  def bark(self):
    print("!!!")

fido = Dog("AAA", "BBB")
print(fido.name)
fido.bark()

#AAA
#!!!

 

(2) Inheritance

class Animal 
  def __init__(self, name)
    self.name = name 
  def action (self)
    print(name)

class Cat(Animal)                         # 상속 
  def action(self)                        # override 
    print(self.name + " - override")

cats = Cat("KKK")
cats.action() 
# KKK - override

 

(3) Magic Methods

기본 연산자를 Overrideing 할 수 있는 Method 명들이 있다. 이런 메서드는
통상적으로 __XXXX__ 이런 모양을 갖는데. 예를 들면 이런식이다. __add__()
이런 메서드는 funcA + funcB 연산을 할때 동작한다.

class Vector2D:
  def __init__(self, x,y)
    self.x = x 
    self.y = y
  def __add__(self, other):
    return Vector2D(self.x + other.X , self.y+ other.y)

first = Vecto2D(5,7)
second = Vector2D(3,9)
result = first + second 
print(result.x)
print(result.y)

#8
#16

 

2016-08-28-11-48-21

2016-08-28-11-48-40

2016-08-28-11-49-00

(4) Data Hiding

JAVA 에서 Private 변수 같은 것에 대한 설명인데
_XXXX 언더바 한번은 접근은 가능하지만 그냥 이건 내부에서 쓰는 용도다라고 선언
하는 정도로 사용하는 것이다
__XXXX 언더바 두번은 그냥은 접근이 안되도록 실질적으로 차단이 되지만, 구지
바로 접근하고자 한다면 아래와 같이 접근은 가능하다.

class Spam:
  __egg = 7 
  def print_egg(self):
    print(self.__egg)

s = Spam()
s.print_egg()          #접근 가능 
print(s._Spam__egg)    #접근 가능 
print(s.__egg)         #접근 불가

 

(5) Class & Static Methods

지금까지 설명한 Class 의 Method 들은 self 파라메터를 받는 종류의 메서드들
이었다면, Class Method 는 Class 자체를 받아서 사용가능한 형태의 메서드이며,
Static Method 는 slef도 cls 도 받지 않고 독립적으로 사용가능한 메서드이다
※ Class Method 는 Java 의 Constructor 처럼 사용하면 될 것으로 보인다.

class Rectangle:
  name = None 
  def __init__(self, width, height):
    self.width = width 
    self.height  = height 

  def calculate_area(self):
    return str(self.width * self.height) + name 

  @classmethod 
  def new_square(cls, side_length, name):
    cls.name = name 
    return cls(side_length, side_length)

  @staticmethod 
  def testtest(width, height):
    if(widht * height > 10) 
      print("too big")

square = Rectangle.new_square(5, "xxx") 
print(square.calculate_area()) 
# 25XXX

Rectangle.testtest(10,10)
#too big

 

(6) Properties

JAVA 의 Getter , Setter 를 지정해 놓고 완전히 변수처럼 사용하는 문법
아래 예제에서는 사용자 input 를 받아서 처리하는 응용로직이 들어 있지만, 단순하게
사용한다면, getter, setter 처러 사용하면 어떨까 싶다

class Pizza:

  def __init__(self, toppings):
    self.toppings = toppings
    self._pineapple_allowed = False

  @property
  def pineapple_allowed(self):
    return self._pineapple_allowed

  @pineapple_allowed.setter
  def pineapple_allowed(self, value):
    if value:
      password = input("Enter the password: ")
      if password == "Sw0rdf1sh!":
        self._pineapple_allowed = value
      else:
        raise ValueError("Alert! Intruder!")

pizza = Pizza(["cheese", "tomato"])
print(pizza.pineapple_allowed)
pizza.pineapple_allowed = True
print(pizza.pineapple_allowed)

 


 

아. Regural Expression

(1) character Classes

Java 나 Javascript 에 보면 String 패턴 비교하는 문법들에 대한 설명

import re                        #regural Expression Class 

pattern1 = r"[aeiou]"             #찾을 패턴 정의시에는 앞에 r 을 넣어 줌 
pattern2 = r"abcd"                #abcd 패턴을 찾음 
pattern3 = r"[abcd]"              #a, b , c, d 가 들어 있는 패턴을 찾음 
pattern4 = r"[A-Z][0-9]"          #A ~ Z , 0 ~ 9 가 들어 있는 패턴 찾음 
pattern5 = r"^[A-Z]"              #A ~ Z 가 아닌 모든 패턴 찾음 
pattern6 = r"a(bcd)*"             #a , abcd , abcdbcd (bcd)는 0번~무한대 
pattern7 = r"a(bcd)+"             # (bcd) 한번 이상 
pattern8 = r"a(bcd)?"             # (bcd) 0번 or 1번 
pattern9 = r"a{1,3}$"             # a가 1에서 3번 반복
pattern10 = r"gr.y"               # . 자리에는 아무거나 OK 
pattern11 = r"^gr.y$"             # g로만 시작하면되고 y로만 끝나면 됨 
 
re.search(pattern, "grey")

 

(2) Groups

grp1 = r"a(bc)(d(e)f)" 
grp2 = r"(?P<fi>abcd)(?:def)(ghi)         #?P<fi> = abcd에fi검색tag부착
                                          #def 는 group count 증가 X 
grp3 = r"gr(a|e)y"                        #gray 혹은 grey  

re.match(grp, "abcdefghijk")              
print(match.group(0))                     #abcdefghijk
print(match.group(1))                     #bc  

 

 

 

Python – postgresql – Django – REST – TensorFlow 서비스 개발(3)

가. 지금까지 완료 된 것

– 1부 링크  : http://wp.me/p7xrpI-9h
– 2부 링크 :  http://wp.me/p7xrpI-9G

– Anaconda 설치
– TensorFlow 설치
– Pycharm 설치
– postgresql 설치
– Django 설치
– Django Service 생성
– snippets APP 생성 완료
– Snippet Model 생성
– postgresql  동기화 완료
– Serializer 생성 , REST API  생성 & TEST
– Class Based REST API

나. 이제 하려고 하는것

– REST 요청을 통해서 동적 Network Configuration 생성 (4부)
– REST 요청을 통해서 Training 기동 (기본 예제 사용)
– Trainging 결과를 Tensorflow Serving 을 통해서 DB 저장
– REST 요청을 통해서 Training 된 결과(모델 구조, 학습결과) 조회 (4부)
– REST 요청을 통해서 TensorFlow Serving 기동 저장된 결과를 읽어서 모델을 구성하고
요청된 결과에 대한 예측을 수행하여 리턴

다. Rest  –  TensorFlow  예제 호출

단순히 REST호출을 통해서 TensorFlow 가 정상적으로 동작하는지 확인

[urls.py]

스크린샷, 2016-08-28 06-06-52

[views.py]

스크린샷, 2016-08-28 06-09-34

[tensor_test.py]

스크린샷, 2016-08-28 06-07-17

[테스트 결과 – 서버]

스크린샷, 2016-08-28 06-11-06

[테스트 결과 – 클라이언트]

스크린샷, 2016-08-28 06-08-09

라. Rest  – Iris  예제 학습 및 저장

간단히 REST호출을 통해서 TensorFlow DNN 을 학습하고 그 결과를 파일로 저장

[urls.py]

스크린샷, 2016-08-28 23-21-46

[views.py]

스크린샷, 2016-08-28 23-22-11

[tensor_test.py]

스크린샷, 2016-08-28 22-47-11

[테스트]

스크린샷, 2016-08-28 23-23-33

마. Rest  – Iris  학습 모델 로드 및 예측

이전에 학습한 모델을 복구해서 별도의 학습없이 테스트 케이스에 대해
예측만 실행하여 리턴 테스트

[tensor_test.py]측

스크린샷, 2016-08-28 23-21-17

[테스트]

스크린샷, 2016-08-28 23-23-03

Python – postgresql – Django – REST – TensorFlow 서비스 개발(2)

가. 지금까지 완료 된 것

– 1부 링크  : http://wp.me/p7xrpI-9h

– Anaconda 설치
– TensorFlow 설치
– Pycharm 설치
– postgresql 설치
– Django 설치
– Django Service 생성
– snippets APP 생성 완료
– Snippet Model 생성
– postgresql  동기화 완료

나.  Serializer

우리가 위에서 정의한  Snippet 데이터 클레스를 받아서  JSON 데이터로 변환하거나 ,
그 반대를 수행하는 클래스라고 생각하면 된다. 아래와 같이 프로젝트에 파일을 추가하고
콘솔을 실행하여 몇 가지 예를 테스트해보면 더 이해가 용이할 것이이다.

[Serializer 생성]

스크린샷, 2016-08-25 04-33-37

from rest_framework import serializers
from snippets.models import Snippet, LANGUAGE_CHOICES, STYLE_CHOICES


class SnippetSerializer(serializers.Serializer):
    pk = serializers.IntegerField(read_only=True)
    title = serializers.CharField(required=False, allow_blank=True, max_length=100)
    code = serializers.CharField(style={'base_template': 'textarea.html'})
    linenos = serializers.BooleanField(required=False)
    language = serializers.ChoiceField(choices=LANGUAGE_CHOICES, default='python')
    style = serializers.ChoiceField(choices=STYLE_CHOICES, default='friendly')

    def create(self, validated_data):
        """
        Create and return a new `Snippet` instance, given the validated data.
        """
        return Snippet.objects.create(**validated_data)

    def update(self, instance, validated_data):
        """
        Update and return an existing `Snippet` instance, given the validated data.
        """
        instance.title = validated_data.get('title', instance.title)
        instance.code = validated_data.get('code', instance.code)
        instance.linenos = validated_data.get('linenos', instance.linenos)
        instance.language = validated_data.get('language', instance.language)
        instance.style = validated_data.get('style', instance.style)
        instance.save()
        return instance

 

[테스트 결과]

스크린샷, 2016-08-25 04-42-05

[디장고 쉘 실행]

python manage.py shell

 

[디비에 데이터 두건 삽입]

from snippets.models importSnippetfrom snippets.serializers importSnippetSerializerfrom rest_framework.renderers importJSONRendererfrom rest_framework.parsers importJSONParser snippet =Snippet(code='foo = "bar"\n') snippet.save() snippet =Snippet(code='print "hello, world"\n') snippet.save()

 

[정렬된 파이선 기본 데이터 타입]

serializer =SnippetSerializer(snippet) serializer.data

ReturnDict([('pk', None),
            ('title', u''),
            ('code', u'foo = "bar"\n'),
            ('linenos', False),
            ('language', 'python'),
            ('style', 'friendly')])

 

[정렬된 파이선 데이터를 JSON으로 변환]

content =JSONRenderer().render(serializer.data) content

'[{"pk":1,"title":"","code":"foo = \\"bar\\"\\n","linenos":false,"language":"python","style":"friendly"},{"pk":2,"title":"","code":"print \\"hello, world\\"\\n","linenos":false,"language":"python","style":"friendly"}]'

 

[JSON 파싱]

from django.utils.six importBytesIO stream =BytesIO(content) data =JSONParser().parse(stream)

 

[역정렬 – 데이터 객체로 만들고 다시 저장까지]

serializer =SnippetSerializer(data=data) serializer.is_valid()# True serializer.validated_data # OrderedDict([('title', ''), ('code', 'print "hello, world"\n'), ('linenos', False), ('language', 'python'), ('style', 'friendly')]) serializer.save()# <Snippet: Snippet object>

 

[현재 디비에 저장된 모든 항목 출력]

serializer =SnippetSerializer(Snippet.objects.all(), many=True) serializer.data

Out[34]: [OrderedDict([('pk', 1), ('title', u''), ('code', u'foo = "bar"\n'), ('linenos', False), ('language', 'python'), ('style', 'friendly')]), OrderedDict([('pk', 2), ('title', u''), ('code', u'print "hello, world"\n'), ('linenos', False), ('language', 'python'), ('style', 'friendly')])]

 

다. ModelSerializer 사용

위에서 정의한 꽤나 긴 Serialzier Code 를 아래와 같이 단순화 할 수 있다

class SnippetSerializer(serializers.ModelSerializer):
    class Meta:
        model = Snippet
        fields = ('id', 'title', 'code', 'linenos', 'language', 'style')

 

라.  views.py

실제로 서비스를 제공할 로직을 구현한다. 아래의 예제는  snippet_list 와  snippet_detail
두 가지 서비스에 대한 코드로 호출 주소에 대한 규칙은  urls.py 에 정의한다.
그리고 해당 메서드를 rest 로 정의하는 코드는 @api_view 로 처리하고자 하는 CRUD
를 정의하고 분기하여 처리한다.

from rest_framework import status
from rest_framework.decorators import api_view
from rest_framework.response import Response
from snippets.models import Snippet
from snippets.serializers import SnippetSerializer



@api_view(['GET', 'POST'])
def snippet_list(request, format=None):
    """
    List all snippets, or create a new snippet.
    """
    if request.method == 'GET':
        snippets = Snippet.objects.all()
        serializer = SnippetSerializer(snippets, many=True)
        return Response(serializer.data)

    elif request.method == 'POST':
        serializer = SnippetSerializer(data=request.data)
        if serializer.is_valid():
            serializer.save()
            return Response(serializer.data, status=status.HTTP_201_CREATED)
        return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)


@api_view(['GET', 'PUT', 'DELETE'])
def snippet_detail(request, pk, format=None):
    """
    Retrieve, update or delete a snippet instance.
    """
    try:
        snippet = Snippet.objects.get(pk=pk)
    except Snippet.DoesNotExist:
        return Response(status=status.HTTP_404_NOT_FOUND)

    if request.method == 'GET':
        serializer = SnippetSerializer(snippet)
        return Response(serializer.data)

    elif request.method == 'PUT':
        serializer = SnippetSerializer(snippet, data=request.data)
        if serializer.is_valid():
            serializer.save()
            return Response(serializer.data)
        return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)

    elif request.method == 'DELETE':
        snippet.delete()
        return Response(status=status.HTTP_204_NO_CONTENT)

 

마. urls.py

from django.conf.urls import url
from django.contrib import admin
from rest_framework.urlpatterns import format_suffix_patterns
from snippets import views

urlpatterns = [
    url(r'^admin/', admin.site.urls),
    url(r'^snippets/$', views.snippet_list),
    url(r'^snippets/(?P<pk>[0-9]+)$', views.snippet_detail),
]

urlpatterns = format_suffix_patterns(urlpatterns)

 

바. TEST

[snippet_list]

http http://127.0.0.1:8000/snippets/ Accept:application/json

스크린샷, 2016-08-25 06-38-41

[snippet_detail]

http form POST http://127.0.0.1:8000/snippets/ code=”print 123″

스크린샷, 2016-08-25 06-38-59

사. Class Based View

위 의 예제는 annotation 을 지정하여 사용하는 전형적인 REST 서버의 모습이었다고 하면, 클래스 형태로  REST  서비스를 구성하는 패턴도 있다

[views.py]

from snippets.models import Snippet
from snippets.serializers import SnippetSerializer
from django.http import Http404
from rest_framework.views import APIView
from rest_framework.response import Response
from rest_framework import status


class SnippetList(APIView):
    """
    List all snippets, or create a new snippet.
    """
    def get(self, request, format=None):
        snippets = Snippet.objects.all()
        serializer = SnippetSerializer(snippets, many=True)
        return Response(serializer.data)

    def post(self, request, format=None):
        serializer = SnippetSerializer(data=request.data)
        if serializer.is_valid():
            serializer.save()
            return Response(serializer.data, status=status.HTTP_201_CREATED)
        return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)

 

class SnippetDetail(APIView): """ Retrieve, update or delete a snippet instance. """ def get_object(self, pk): try: return Snippet.objects.get(pk=pk) except Snippet.DoesNotExist: raise Http404 def get(self, request, pk, format=None): snippet = self.get_object(pk) serializer = SnippetSerializer(snippet) return Response(serializer.data) def put(self, request, pk, format=None): snippet = self.get_object(pk) serializer = SnippetSerializer(snippet, data=request.data) if serializer.is_valid(): serializer.save() return Response(serializer.data) return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST) def delete(self, request, pk, format=None): snippet = self.get_object(pk) snippet.delete() return Response(status=status.HTTP_204_NO_CONTENT)

 

[urls.py]

from django.conf.urls import url
from django.contrib import admin
from rest_framework.urlpatterns import format_suffix_patterns
from snippets import views

urlpatterns = [
    url(r'^admin/', admin.site.urls),
    url(r'^snippets/$', views.SnippetList.as_view()),
    url(r'^snippets/(?P<pk>[0-9]+)/$', views.SnippetDetail.as_view()),
]

urlpatterns = format_suffix_patterns(urlpatterns)

 

Python – postgresql – Django – REST – TensorFlow 서비스 개발(1)

Anaconda , Django, Djangorestframework, Tensorflow, postgres 환경에서 REST API 호출을 통해  간단한 Tensorflow 예제를 실행하고 결과를 리턴하는 것까지 설명하고자 한다. Spark 연동 및 Tensorflow Serving 을 연동하는 부분은 따로 설명하겠다

[링크]
Anaconda – PyCharm – Tensorflow  환경 구성 : http://wp.me/p7xrpI-8Q

가. Anaconda sub Library Install

virtualenv 설정은 사용하지 않고 바로 설치하고 진행

[Django 설치]

conda install -c anaconda django=1.9.5

[Django Rest Frame Work]

conda install -c ioos djangorestframework=3.3.3

[postgress 연동 plugin]

conda install -c anaconda psycopg2=2.6.1

[pygments 설치]

conda install -c anaconda pygments=2.1.3

나. PostgresSql  설치

[설치]

yum install postgresql-server

[계정확인 / 비밀번호 지정]

cat /etc/passwd | grep postgres
 sudo passwd postgres

[DB  생성 경로 확인]

cat /var/lib/pgsql/.bash_profile
 env | grep PGDATA

[DB 초기화/실행]

sudo -i -u postgres
initdb
pg_ctl start
ps -ef | grep postgress

[DB 접속 / database 생성]

# psql
postgres=# create database test1  ;
postgres=# select *   from pg_database  ;

 

스크린샷, 2016-08-21 04-41-22

 

[user  생성 및 권한 부여 ]

postgres=#CREATE USER testuser WITH PASSWORD '1234';
postgres=#ALTER ROLE testuser SET client_encoding TO 'utf8'; 
postgres=#ALTER ROLE testuser SET default_transaction_isolation TO 'read committed'; postgres=#ALTER ROLE testuser SET timezone TO 'UTC';
postgres=#GRANT ALL PRIVILEGES ON DATABASE test1 TO testuser;


[생성 유저 테스트]

psql -U testuser test1

[psql command]

순서대로 전체 DATABASE LIST 출력, 선택한 DATABASE 접속, 해당 DATABASE TABLES

postgres=#\list 
postgres=#\connect DATABASE_NAME 
postgres=#\dl+

 

 다. Django 작업 목차

[1. 뼈대 구성]

startproject : 프로젝트 생성 
settings.py : 프로젝트 설정 항목 변경 
migrate : 유저/그룹 테이블 생성 
createsuperuser : 프로젝트 관리자 생성 
startaup : 북마크 앱 생성 
settings.py : 북마크 앱 등록

[2. 모델 코딩]

models.py : 모델(테이블)정의
admin.py : Admin 사이트에 모델 등록 
makemigrations  : 모델을 데이터베이스에 반영 
migrate

[3. 기타]

urls.py : URL 정의 
views.py : 뷰 로직 작성 
templates directory : 템플릿 파일 작성

라. 프로젝트 생성

[프로젝트 생성]

# cd ~/PycharmProjects 
# django-admin.py startproject djangodemo

 

마.북마크 앱 생성/등록

[북마크 앱 생성 ]

python manage.py startapp snippets

 

스크린샷, 2016-08-21 06-16-09

[북마크 앱 등록]

INSTALLED_APPS =(...'rest_framework','snippets.apps.SnippetsConfig',)

 

바. 디비 정보 세팅

[settings.py  수정 – 디비 정보 입력]

vi ~/PycharmProjects/djangodemo/djangodemo/settings.py
DATABASES = { 'default': { 'ENGINE': 'django.db.backends.postgresql_psycopg2', 'NAME': 'test1', 'USER': 'testuser', 'PASSWORD': '1234', 'HOST': 'localhost', 'PORT': '', } }

사. Model 생성

[models.py]

스크린샷, 2016-08-21 06-45-38

[예제 코드]

from django.db import models
from pygments.lexers import get_all_lexers
from pygments.styles import get_all_styles

LEXERS = [item for item in get_all_lexers() if item[1]]
LANGUAGE_CHOICES = sorted([(item[1][0], item[0]) for item in LEXERS])
STYLE_CHOICES = sorted((item, item) for item in get_all_styles())


class Snippet(models.Model):
 created = models.DateTimeField(auto_now_add=True)
 title = models.CharField(max_length=100, blank=True, default='')
 code = models.TextField()
 linenos = models.BooleanField(default=False)
 language = models.CharField(choices=LANGUAGE_CHOICES, default='python', max_length=100)
 style = models.CharField(choices=STYLE_CHOICES, default='friendly', max_length=100)

 class Meta:
 ordering = ('created',)

아. Admin.py 등록

위에 정의한 테이블 구조에 맞춰 admin UI 에서도 볼 수 있도록 정의해 줍니다.

[admin.py]

from django.contrib import admin
from snippets.models import Snippet

# Register your models here.

class SnippetsAdmin(admin.ModelAdmin):
        list_display = ('created','title','code','linenos','language','style')

admin.site.register(Snippet, SnippetsAdmin)

차.  Project Migration

[migration]

python manage.py makemigrations 
python manage.py migrate

[reset migration]

python manage.py migrate --fake <app-name> zero

 

[실행 결과]

스크린샷, 2016-08-21 06-46-50

[Postgres DB Table 생성 확인]

마이그레이션은 기본적으로 디비와 모델을 동기화하는 작업

SELECT * FROM information_schema.tables ;
SELECT  <table name>  FROM information_schema.tables  ;

 

스크린샷, 2016-08-21 08-03-25

카. 슈퍼유저 생성 및 서버 테스트

[Create Super User]

python manage.py createsuperuser

[슈퍼유저 정보 입력]

Username (leave blank to use 'root'): kim
Email address: kim@naver.com
Password: 
Password (again): 

 

[Server Start]

프로젝트 폴더로 이동 (프로젝트 폴더에 manage.py   가 있는 위치) 하여   서버를 기동한다.

ip addr | grep "inet "
python manage.py runserver localhost:8989

 

 

 

스크린샷, 2016-08-21 05-53-58

[Admin Page]

http://등록한 주소 : 포트 /admin

계정은 아까 위에서 생성한 슈퍼 유저 (저는 OS 계정과 동일하게 설정)
위에서 생성한 테이블까지 출력된다면, 여기까지 문제없이 진행된 것

스크린샷, 2016-08-21 07-29-59

타. REST Service App 개발

– 참조 사이트 :  http://www.django-rest-framework.org/tutorial/1-serialization/

– 현재 상태
. snippets APP 생성 완료
. Snippet Model 생성
. postgresql  동기화 완료

==> 다음 포스트에서 작성

 

[환경 설정] Anaconda-PyCharm-TensorFlow

[참조 사이트]
https://www.tensorflow.org/versions/r0.10/get_started/os_setup.html#download-and-setup
http://yeramee.tistory.com/1

어짜피 GPU 는 없는 관계로  CPU 버전으로 심플하게 설치

가. Anaconda 설치

[설치 파일 다운로드]
– 다운로드 :  https://www.continuum.io/downloads

wget https://repo.continuum.io/archive/Anaconda2-4.1.1-Linux-x86_64.sh

 

[설치 및 설정]
아래와 같이

bash /home/user/Downloads/Anaconda2-4.1.1-Linux-x86_64.sh
vi ~/.bashrc
export PATH="$HOME/anaconda2/bin;$PATH"
$ python
Python 2.7.12 |Anaconda 4.1.1 (64-bit)

[Trouble Shooting]
– 기 설치된 python 과 충돌하는 경우 해결방안
– .bashrc 에 추가 : source ~/anaconda2/bin/activate ~/anaconda2/
* 이 방법이 최선인지는 잘 모르겠음, 우선 문제는 해결

나. TensorFlow 설치

아래의 두 가지 방법중 어떤 것으로 설치하여도 상관 없다

[Using PIP]

https://www.tensorflow.org/versions/r0.10/get_started/os_setup.html#download-and-setup 에서 참조하여 자신의 OS 및 파이썬 버전에 맞는 경로를 세팅할 수 있도록 한다.

# Ubuntu/Linux 64-bit, CPU only, Python 2.7 $ export TF_BINARY_URL=https://storage.googleapis.com/tensorflow/linux/cpu/tensorflow-0.10.0rc0-cp27-none-linux_x86_64.whl
# Python 2 
$ source activate tensorflow
$ pip install --ignore-installed --upgrade $TF_BINARY_UR

[Using Conda]

$ conda create -n tensorflow python=2.7
$ source activate tensorflow
$ conda install -c conda-forge tensorflow
다.  pyCharm 설치

[다운로드]
-다 운로드 : https://www.jetbrains.com/pycharm/download/#section=linux

wget https://download.jetbrains.com/python/pycharm-community-2016.2.3.tar.gz

[설치 및 실행]

tar xvzf /home/user/Downloads/pycharm-community-2016.2.1.tar.gz pyc
bash /home/user/Downloads/pyc/bin/pycharm.sh

[Interpreator 설정]

File >> Settings >> Project >> ProjectInterpreator 
root/anaconda2/bin/python 으로 설정

[TEST]

https://github.com/aymericdamien/TensorFlow-Examples

아무 소스코드나 복사하여 실행하여 테스트

스크린샷, 2016-08-18 22-35-31

RHEL- bitnami – Redmine 간편 설치

  1. 다운로드  : https://bitnami.com/stack/redmine/installer
  2. chmod 700 bitnami-redmine-3.3.0-1-linux-x64-installer.run
  3. sudo bitnami-redmine-3.3.0-1-linux-x64-installer.run

[bitnami 관리 Application]

  • Manager 실행 : manager-linux-x64.run (root 권한으로 설치한 경우)
  • web 접속 : http://ip/redmine

스크린샷, 2016-08-15 06-10-07

[개발 일정 관리 달력]

스크린샷, 2016-08-15 06-24-31

[개발 Task 관리 간트 차트]

스크린샷, 2016-08-15 06-24-45

[자료 공유 게시판]

스크린샷, 2016-08-15 06-25-06

[WIKI 자료 공유]

스크린샷, 2016-08-15 06-25-24

[Task 관리]

스크린샷, 2016-08-15 06-35-11

RHEL7 – Redmine 설치하기

A. Ruby 설치

– repository  조회

grep -B1 -i optional /etc/yum.repos.d/*

 – optional source  아닌 repository 탐색 하여 enable

yum-config-manager --enable <repo-id>
sudo yum makecache

– 필요한 패키지 인스톨

yum -y install gcc mysql-devel ruby-devel rubygems
sudo yum install gcc g++ make automake autoconf curl-devel openssl-devel zlib-devel httpd-devel apr-devel apr-util-devel sqlite-devel
sudo yum install ruby-rdoc ruby-devel

B.  git 설치

yum install perl-devel
yum install perl-CPAN
# C compiler install  
yum groupinstall 'Development Tools'
# yum install curl-devel expat-devel gettext-devel \
  openssl-devel zlib-devel
$ tar -zxf git-1.7.2.2.tar.gz
$ cd git-1.7.2.2
$ make prefix=/usr/local all
$ sudo make prefix=/usr/local install

C. MySQL 설치

-이동 : https://dev.mysql.com/downloads/repo/
-다운로드 : mysql57-community-release-el7-8.noarch.rpm
-repository 설치 : # yum localinstall mysql57-community-release-el7-8.noarch.rpm
-repository 설정 확인 : # yum repolist enabled | grep "mysql*-community*"
-MySql 설치 : yum --disablerepo=\* --enablerepo='mysql*-community*' install mysql-server

E. 의존성 설치

gem install ruby-openid
yum install ImageMagick-devel -y

F. DB 설정

# service mysqld start
 # service mysqld status
 # grep 'temporary password' /var/log/mysqld.log
 # mysql -u root -p
mysql> SET PASSWORD = PASSWORD('xxxxxxxxxxxx');
Query OK, 0 rows affected, 1 warning (0.00 sec)
mysql> CREATE DATABASE redmine CHARACTER SET utf8;
Query OK, 1 row affected (0.00 sec)
mysql> CREATE USER 'redmine'@'localhost' IDENTIFIED BY 'xxxxxxx';
Query OK, 0 rows affected (0.00 sec)
mysql> GRANT ALL PRIVILEGES ON redmine.* TO 'redmine'@'localhost';
Query OK, 0 rows affected (0.00 sec)

참조 : http://stackoverflow.com/questions/33510184/change-mysql-root-password-on-centos7

 

E. RedMine 설치

– 참조 사이트

https://www.easyredmine.com/resources/installation/custom-installation
$ gem install redmine-installer
$ wget http://www.redmine.org/releases/redmine-3.2.3.zip
$ redmine install redmine-3.2.3.zip

- 진행을 하면 입력란이 아래와 같이 순서대로 나옵니다. 아까 만들었던 DB 정보를 참조하여 넣어 줍니다.

1) Redmine Root – you need to define a folder where Redmine will be installed
2) Load Package
3) Database configuration – definition of database type (MySQL of PostgreSQL)
4) E-mail configuration
5) Installation
6) Moving Redmine – Redmine is moved to the defined root (step 1)
7) Webserver configuration

– 입력 내용 예

Database: redmine
Host [localhost]: localhost
Username: root
Password: 
Encoding [utf8]: utf8
Port [3306]: 3306

 - 나중에 변경을 원할 경우 아래 파일 수정

  redmin/config/database.yml