'딥러닝 공부/Tensorflow'에 해당되는 글 5건

안녕하세요! 은공지능 공작소의 파이찬입니다.

올 여름은 비교적 시원한 느낌이 드네요.

그래도 컴퓨터 앞에 오래 앉아있으면 더운 느낌이 들곤하죠...

모두 학교에서 직장에서 파이팅 하시길 바랍니다!!

오늘은 tf.where 함수에 대해 알아보겠습니다.

이전 텐서플로 버전과는 다르게, 이펙티브 텐서플로 2.0에서는

where 함수에 broadcasting 기능이 추가가 되었습니다.

그럼 기본적인 사용법부터, broadcasting 개념까지

하나하나 알아보도록 하겠습니다.

1. 사전준비

import tensorflow as tf

print(tf.__version__) 

output:
2.0.0-beta1

텐서플로를 불러와 줍니다.

버전을 출력했을 때, 위의 결과창처럼 결과가 떠야 합니다.

이전 버전에서도 tf.where 함수가 있지만 broadcasting은 지원하지 않습니다.

만약 텐서플로 2.0 설치와 conda 가상환경 설정법이 궁금하신 분들은

아래의 포스팅을 참고하시면 되겠습니다.

https://chan-lab.tistory.com/11

c1 = tf.constant([1, 1])
c2 = tf.constant([2, 2])
c3 = tf.constant([0, 3])
cond = tf.constant([True, False])

tf.where의 기본적인 사용법을 알려드리겠습니다.

위와 같이 4가지 텐서를 만들어 둡니다.

c1 ~ c3는 숫자 들어간 상수 텐서이고, cond 함수는 True/False를 넣었습니다.

c1
c1.numpy()
print(c1.numpy())

def prt(input):
    print(input.numpy()) # 리턴값은 없습니다.

텐서플로 2.0에서는 따로 세션을 통해 출력을 하지 않아도 됩니다.

그래도 깔끔한 출력을 위해서 내용물을 프린트 하는 함수를

하나 만들어 두고 가겠습니다.

2. where 함수의 기본적인 사용법

tf.where(  bool type 텐서,   True일 때 출력값,   False일 때 출력값  )

tensor list:

c1:[1 1]
c2:[2 2]
c3:[0 3]
cond:[ True False]

prt(tf.where(cond, c1, c2))
prt(tf.where(tf.less(c1, c2), c1, c2))
prt(tf.where(tf.greater(c1, c3), c1, c3))

output:

[1 2]
[1 1]
[1 3]

위의 코드를 실행하면서 결과를 확인해보시길 바랍니다.

각 텐서의 원소별로 True일 때, False일 때 출력되는 것이 달라집니다.

bool type 텐서의 원소가 True 일때와 False 일때의 출력값이

달라진다는 것이 포인트입니다.

3. where 함수를 통해 알아보는 Broadcasting

브로드캐스팅(broadcasting)을 한마디로 정의하자면 바로 '확장'입니다.

where 함수에서 서로 다른 모양의 2가지 텐서가 사용되는 경우,

서로의 shape에 맞추어 행과 열을 확장해야 할 필요가 있습니다.

이럴 때 사용되는 것이 브로드캐스팅, 즉 확장입니다.

아래 코드와 그림을 통해 더 자세히 설명드리겠습니다.

c4, c5 = tf.constant([[1], [2], [3]]), tf.constant([[1, 2, 3, 4]])

output:

[[1]
 [2]
 [3]]
[[1 2 3 4]]

c4는 3 x 1 텐서, c5는 1 x 4 텐서입니다. 이 두 텐서는 서로 모양이 다릅니다.

그렇기 때문에 tf.less같은 비교연산을 위해서는 각각 행과 열을 '확장'해야 합니다.

이렇게 확장된 후에는 서로 3 x 4로 shape가 같아집니다.

이것이 바로 브로드캐스팅(broadcasting)의 개념입니다.

prt(tf.where(tf.less(c4, c5), tf.multiply(c4, c4), tf.multiply(c5, -1)))

output:

[[-1  1  1  1]
 [-1 -2  4  4]
 [-1 -2 -3  9]]

이제 브로드캐스팅된 텐서 c4, c5를 통해 tf.less 연산이 수행이 됩니다.

연산은 각각의 원소마다 적용이 됩니다.

즉, c4의 1행 1열 원소는 c5의 1행 1열의 원소와 비교가 되는 방식입니다.

연산의 결과는 위에 보시는 대로 입니다.

이제 cond 결과에 따라서 True일때 출력값, False일때 출력값이 달라지게 됩니다.

초록색은 True와 연관이 있이고, 빨간색은 False와 연관이 있습니다.

즉, True일때는 c4 원소들을 제곱을 하고

False일 때는 c5 원소에 -1을 곱해주는 코드입니다.

prt(tf.where(tf.less(c4, c5), tf.multiply(c4, c4), tf.multiply(c5, -1)))

output:
[[-1  1  1  1]
 [-1 -2  4  4]
 [-1 -2 -3  9]]

결과를 다시 한 번 확인하면, 위와 같습니다.

이렇게 하여 오늘은 텐서플로 2.0 버전의 where 함수,

그리고 where함수의 브로드캐스팅 기능까지 알아보았습니다.

도움이 되셨다면 하단의 하트 버튼 한번씩 부탁드리겠습니다.

감사합니다.

안녕하세요! 은공지능 공작소의 파이찬입니다.

오늘은 텐서플로를 이용한

논리연산에 대해 알아보겠습니다.

(아래 YouTube 동영상도 참고해 주세요)

1. 논리연산의 개념

논리연산이란,

참과 거짓 두 가지 결과를 내놓는

연산을 말합니다.

수학기으로 따지자면,

등호(=)와 부등호(<, >, >=, <=) 연산이

여기에 포함됩니다.

파이썬에서 참은 True,

거짓을 False로 표현되는데요.

이러한 결과들을 내놓는 논리연산을

알아보기 이전에,

먼저 간단한 텐서와 함수들을

만들어 두고 시작하겠습니다.

2. 사전 준비

import tensorflow as tf

c1, c2 = tf.constant([1, 3]), tf.constant([5, 7])
v1, v2 = tf.Variable([1, 9]), tf.Variable([7, 7])

def sRun(input):
    with tf.Session() as sess:
        sess.run(tf.global_variables_initializer())
        rst = input.eval()
        return(rst)

def spr(a):
    print(sRun(a))

c1, c2는 Constant이고,

v1, v2는 Variable입니다.

sRun은 session run이라는 것을 줄여서

만들어 보았습니다.

텐서를 쉽게 보기 위한 함수입니다.

spr함수는 session print를 줄여서

이름을 붙였습니다.

이는 단순히 프린트를 위한 함수로,

리턴값은 없습니다.

3. 텐서플로 등호비교 함수

(tf.equal, tf.not_equal)

tensor list:
c1:  [1 3]
c2:  [5 7]
v1:  [1 9]
v2:  [7 7]

spr(tf.equal(c1, v1))
spr(tf.not_equal(c1, v1))

[ True False]
[False  True]

tf.equal 함수는

c1과 v1을 비교하여

두 텐서의 원소가 같다면 True를,

같지 않다면 False를 출력합니다.

tf.not_equal 함수는

tf.equal 함수와 정반대 개념이라고

이해하시면 편리합니다.

비교 원소가 같이 않으면 True를,

같다면 False를 출력하는 것이지요.

4. 텐서플로 대소비교 함수

(tf.less, tf.less_equal, tf.greater, tf.greater_equal)

텐서플로 대소비교함수는

두 텐서의 원소들을 비교해

True, False 두가지 결과를 내놓습니다.

위에 tf.less를 설명해놓은

그림을 보신다면 쉽게 이해하실 수 있을 겁니다.

tensor list:
c1:  [1 3]
c2:  [5 7]
v1:  [1 9]
v2:  [7 7]

spr(tf.less(c1, v1))
spr(tf.less_equal(c1, v1))

spr(tf.greater(c1, v1))
spr(tf.greater_equal(c1, v1))

output:
[False  True]
[ True  True]

[False False]
[ True False]

tf.less 이외에도 tf.less_equal,

tf.greater, tf.greater_equal 함수가

존재합니다.

문법은 less와 동일하므로

자세한 설명은 생락하도록 하겠습니다.

5. and, or, xor, not

지금부터 살펴볼 연산들의

input은 모두 bool type 입니다.

즉, input으로 True 와 False만

사용할 수 있습니다.

tf.logical_and 연산은

input들이 모두 True 여야 True를

출력합니다.

tf.logical_or 함수는

input 들을 비교했을 때, 하나라도 True라면

True를 출력합니다.

tf.logical_xor 함수는 input들을 비교해서,

같지 않다면 True, 같다면 False를

출력합니다.

만약 True를 1이라고 하고

False를 0이라고 한다면,

이 연산은 원소들을 더한 값을

tf.mod 2하는 결과와 동일합니다.

햇갈리시는 분들은 그냥

"같지 않다면 True를 출력!"

이 점을 기억해주시면 됩니다.

tf.logical_not은

input과 반대의 결과를 내놓습니다.

input이 True라면 False를

False라면 True를 내놓는 것입니다.

c3 = tf.constant([True, False])
c4 = tf.constant([False, False])
c5 = tf.constant([True, True])

spr(tf.logical_and(c3, c5))
spr(tf.logical_or(c3, c4))
spr(tf.logical_xor(c3, c4))
spr(tf.logical_not(c3))

output:
[ True False]
[ True False]
[ True False]
[False  True]

연산들을 정리한 코드입니다.

설명은 그림을 통해 자세하게 설명했으니

여기서는 실행 결과를 봐주시면 되겠습니다.

네 이렇게 오늘은 equal 부터 시작해서

logical_not까지 텐서플로의 논리연산에 대해

살펴보는 시간을 가졌습니다.

----------------------------------

긴 글 끝까지 읽어주셔서 감사합니다 :)

안녕하세요! 은공지능 공작소입니다.

오늘은 텐서플로를 이용한

사칙연산에 대해서 알아보는

시간을 갖겠습니다.

텐서플로로 머신러닝, 딥러닝을

수행하다보면

많은 수학적인 연산이 필요합니다.

이러한 수학적인 연산의

기초가 되는 것이

오늘 다룰 사칙연산입니다.

1. 사전준비

import tensorflow as tf

c1 = tf.constant([[1, 2], [3, 4]]) # 2 x 2 행렬
c2 = tf.constant([[4, 7], [-1, 0]])
e = tf.constant([[1, 0], [0, 1]]) # 단위 행렬
v1 = tf.Variable([[10, 9], [8, 7]])
v2 = tf.Variable([[3, 6], [5, -1]])

def sRun(input): 
    with tf.Session() as sess:
        sess.run(tf.global_variables_initializer())
        rst = input.eval()
        print(rst)
        return(rst)

기본적인 텐서들을 만들어주고

이를 실행하기 위한 함수(sRun)도

하나 만들었습니다.

이제 덧셈부터

나눗셈과 나머지까지

텐서연산법에 대해 알아보겠습니다.

2. 덧셈 (tf.add vs tf.add_n)

sRun(tf.add(c1, c2))
sRun(tf.add_n([c1, c2, c1]))

sRun(tf.add(c1, v1))

output:
[[5 9]
 [2 4]]
[[ 6 11]
 [ 5  8]]
[[11 11]
 [11 11]]

덧셈의 결과는 각각의 원소들의

덧셈입니다.

예를 들어 tf.add(c1, c2)의 1행 1열은

1(c1) + 4(c2) = 5(output)

과 같은 수식을 통해 도출됩니다.

tf.add_n도 tf.add와 마찬가지입니다.

다만, tf.add_n과 tf.add의 차이는

tf.add_n은 많은 양의 텐서를 

한 번에 처리할 수 있다는 것입니다.

여기서 주의할 점은

tf.add_n은 텐서들을 반드시

대괄호 안에 넣어줘야

한다는 것입니다.

(그렇지 않으면 TypeError가 발생)

또한 tf.add(c1, v2)처럼

constant 텐서와 variable 텐서 간의

연산도 가능하니,

이 점 참고해 주시면 되겠습니다.

3. 뺄셈 (tf.subtract)

sRun(tf.subtract(v1, v2))

output:
[[7 3]
 [3 8]]

다음으로 알아볼 것은 뺄셈입니다.

이전 텐서플로 버전에서는

tf.sub라는 명령어였던 것으로

기억하고 있습니다.

새로운 텐서플로 버전에서는

tf.sub -> tf.subtract로 업데이트

되었습니다.

텐서플로 뺄셈도 덧셈과 동일하게

원소들의 뺄샘으로 이루어집니다.

그러니 자세한 설명은

생략하도록 하겠습니다.

4. 곱셈 (tf.multiply vs tf.matmul)

sRun(tf.multiply(c1, e)) # 원소곱
sRun(tf.matmul(c1, e)) # 행렬곱

output:
[[1 0]
 [0 4]]
[[1 2]
 [3 4]]

텐서플로의 곱셈입니다.

곱셈 함수는 크게 2가지가 있습니다.

tf.multiply와 tf.matmul 입니다.

tf.multiply는 원소들의 곱입니다.

같은 색 숫자끼리의 곱셈이라고

이해하시면 쉬울 것입니다.

그러나 이는 우리가 흔이 알고있는

행렬의 곱셈은 아닙니다.

행렬의 곱셈은

tf.matmul 이라는 함수를 통해

구현할 수 있습니다.

tf.matmul을 통해

행렬의 곱셈을 구현할 수 있습니다.

연산방식은 위의 그림을

참조해주시면 됩니다.

5. 나눗셈 (tf.divide, tf.mod)

c3 = tf.constant(10)
c4 = tf.constant(7)

sRun(tf.divide(c3, c4))
sRun(tf.mod(c3, c4))

output:
1.4285714285714286
3

텐서플로 나눗셈을 쉽게 이해하기 위해

c3, c4 텐서를 새롭게 만들었습니다.

tf.divide(~를, ~로 나누면?)         
tf.mod(~를, ~로 나눈 나머지는?)

위와 같은 문법으로 이해하시면

쉬울 것 같습니다.

코드 결과를 참조해주시면 됩니다.

아, 참고로 행렬의 나눗셈도 동작하며

행렬의 나눗셈은 원소들의 나눗셈으로

연산이 됩니다.

-----------------------------------------------

오늘 포스팅은 여기서 마치겠습니다.

감사합니다.

1. 텐서란 무엇인가?

텐서(tensor)란, 일종의 행렬입니다.

이는 스칼라가 될 수도 있고,

다차원의 벡터도 될 수 있습니다.

텐서플로(tensorflow)는 말 그대로

텐서(tensor)의 흐름(flow)를

설계하는 것이라고 볼 수 있습니다.

텐서는 다양한 방법을 통해

정의될 수 있습니다.

오늘은 가장 기본적인 텐서들에 대해서

다루어 보겠습니다.

def sRun(input):
    with tf.Session() as sess:
        sess.run(tf.global_variables_initializer())
        rst = input.eval()
        print(rst)
        return(rst)

들어가기에 앞서,

텐서의 내용물을 확인해볼 수 있는

간단한 함수를 하나 만들겠습니다.

이는 지난 시간의

세션에 관련된 포스팅을 보셨다면

이해하실 수 있습니다.

2019/07/06 - [딥러닝 공부/Tensorflow] - [tensorflow] Session에 관하여

2. Constant 와 Variable

constant는 상수를 뜻합니다.

수학에서 상수는 변수와 구분되는 개념으로,

변하지 않고 고정된 값을 의미합니다.

텐서플로에서 tf.constant() 함수를 통해

상수 텐서를 만들 수 있습니다.

Variable은 변수를 뜻합니다.

변수는 수학에서 투입값에 따라

변하는 숫자를 의미하지만, 

텐서플로의 Variable은 Constant와

큰 차이가 없습니다.

# constant
c1 = tf.constant(1)
c2 = tf.constant([1])
c3 = tf.constant([[1, 2], [3, 4]])

# variable
v1 = tf.Variable(1)
v2 = tf.Variable([1])
v3 = tf.Variable([[-1, 0], [10, 5]])

간단하게 constant와 Variable을

만들어 보았습니다.

대괄호 [ ]를 쓴 것과

안 쓴 것의 차이를 잘 봐주세요.

대괄호를 써주어야 텐서의 shape가

형성이 됩니다.

아래 출력문을 통해 확인해보겠습니다.

print(c1) # Tensor("Const_26:0", shape=(), dtype=int32)
print(c2) # Tensor("Const_27:0", shape=(1,), dtype=int32)
print(c3) # Tensor("Const_28:0", shape=(2, 2), dtype=int32)

sRun(c1) # 1
sRun(c2) # [1]
sRun(c3) # [[1 2] [3 4]]

print(v1) # <tf.Variable 'Variable:0' shape=() dtype=int32_ref>
print(v2) # <tf.Variable 'Variable_1:0' shape=(1,) dtype=int32_ref>
print(v3) # <tf.Variable 'Variable_2:0' shape=(2, 2) dtype=int32_ref>

sRun(v1) # 1
sRun(v2) # [1]
sRun(v3) # [[-1  0] [10  5]]

현재로서 constant와 Variable은

차이가 거의 없다고 보셔도 될 듯 합니다.

나중에 텐서 그래프에서

런타임, 리소스 등에서 차이가 발생할

수도 있지만 그것은 논외로 하겠습니다.

여기서 포인트는

어떻게 constant와 Variable을 만드는지, 

또 shape를 확인하는 법에

맞춰주시면 됩니다.

그럼 이제부터는 get_variable 함수에 대해

알아보도록 하겠습니다.

3. get_variable

with tf.variable_scope("a", reuse=tf.AUTO_REUSE):
    sRun(tf.get_variable("v", [1]))
    sRun(tf.get_variable("v2", [2, 2]))

output:
[0.7743064]
[[ 0.7424123  1.0585083]
 [-0.9365851  0.4901656]]

아까 봤던 Variable과 get_variable은

비슷해 보이지만 엄연히 다른 녀석입니다.

get_variable은 shape에 맞춰서

랜덤값을 생성해 줍니다.

이 함수를 동작하기 위해서

variable_scope(범위)의 이름과

get_variable의 이름을

지정해주어야 합니다.

(조금 까다롭습니다.)

또한 계속 값이 랜덤으로 바뀌는 것을

확인하기 위해서

reuse 옵션을 AUTO_REUSE로

맞춰주시는 것도 잊지 마셔야 겠습니다.

굳이 Variable과의 차이점이라고 한다면,

Variable 함수는 픽스된 고정값을

생성해 주는 반면에,

get_variable은 매번 새로운 랜덤값을

생성해주고 범위 이름과 변수 이름이

지정되어야 한다는 점입니다.

-----------------------------------------------

오늘 포스팅은 여기서 마치겠습니다.

감사합니다.

1. 왜 텐서플로 세션을 이해해야 하는가?

2. 세션 작동법

세션 작동은 크게 3부분으로 이루어집니다.

세션 선언문은 세션을 만들어 주는 역할을 합니다.

지금부터 sess라는 변수에 세션을 하나 할당하겠다는 의미입니다.

세션은 기본적으로 크게 2가지가 있는데,

tf.Session()과 tf.InteractiveSession()입니다.

tf.InteractiveSession은 자동으로 터미널에 default session을 할당하지만,

tf.Session은 그렇지 않기 때문에

항상 with 절과 사용해야 하는 차이점이 있습니다.

세션 실행문은 sess.run() 함수로 실행됩니다.

괄호 안에 텐서나 텐서연산을 넣어서 실행을 해주면 됩니다.

텐서 종료문은 sess.close() 함수로 실행이 됩니다.

단, 이 종료문은 with 절에서는 굳이 안써줘도 무방합니다.

3. 코드 실습

import tensorflow as tf

a = tf.constant(2)
b = tf.constant(3)
c = tf.multiply(a, b)

위의 코드는 텐서플로 라이브러리를 불러와서

a, b, c 라는 텐서를 생성하는 코드입니다.

a, b는 상수로, c는 a와 b를 곱한 결과를 담았습니다.

# session -> 일종의 실행창

sess = tf.Session() # 세션 선문
sess.run(tf.global_variables_initializer()) # 변수 초기화 -> 습과화하는 것이 좋아요

print(sess.run(c)) # 세션 실행문
# print(c.eval()) # 오류 발생 -> default session이 지정되지 않았기 때문.
sess.close() # 세션 종료문

설명은 코드 주석으로 대체하겠습니다.

여기서 eval() 함수는 작동하지 않습니다.

텐서는 세션 내에서만 작동합니다.

그런데 eval() 함수는 세션을 거치지 않고

c라는 텐서에 담겨있는 결과를 볼 수 있는 기본명령어입니다.

eval()이 작동하기 위해서는

세션 밖에서 c라는 텐서를 보기 위한

기본(default) 세션이 지정되어야 합니다.

tf.Session()은 default 세션을 지정해주지 않습니다.

defalut 세션을 지정해주려면 다른 명령어를 사용하거나,

with 절과 함께 사용,

tf.InteractiveSession() 명령어를 써줘야합니다.

또한 세션 종료문으로 세션을 종료해주시는 것도 잊지 말아주세요.

with tf.Session() as sess:
    
    sess.run(tf.global_variables_initializer())
    print(sess.run(c))
    print(c.eval()) # with 절에서는 해당 명령어가 잘 작동합니다.

with 절에서는 tf.close()를 써주지 않아도 무방합니다.

또한 여기서 c.eval() 함수는 제대로 동작합니다.

with 절 내에서 세션선언이 default로 되어있기 때문입니다.

sess = tf.InteractiveSession() # 자동으로 default session을 지정해줌
sess.run(tf.global_variables_initializer())

print(c.eval()) # 제대로 작동
print(sess.run(c)) 

sess.close()

자동으로 defalut 세션을 지정해주는

InteractiveSession 선언문입니다.

c.eval() 이 제대로 작동하는 것을 보면

default 세션이 제대로 작동하는 것을 알 수 있습니다.

with 절을 쓰지 않았기 때문에

sess.close() 문도 써주는 것을 잊지 마세요.

4. 정리

정리하자면 Session을 동작하는 방법에는

크게 2가지가 있다고 보시면 됩니다.

with tf.Session() as sess:
    
    sess.run(tf.global_variables_initializer())
    print(sess.run(c))
    print(c.eval())

위와 같이 with 절과 함께 Session을 쓰는 것이

첫번째 방법입니다.

가장 대중적으로 쓰이는 방법이기도 합니다.

sess = tf.InteractiveSession() # 자동으로 default session을 지정해줌
sess.run(tf.global_variables_initializer())

print(c.eval()) # 제대로 작동
print(sess.run(c)) 

sess.close()

두번재 방법은 위와 같이

InteractiveSession 선언을 해주는 것입니다.

하지만 이는 세선 종료문을 써줘야 한다는

번거로움이 있기도 합니다.

오늘 포스팅은 여기서 마치겠습니다.

감사합니다.