텐서플로우 기본

import tensorflow as tf #텐서플로우 라이브러리 임포트하고 이름을 tf라고 한다.  

a = tf.constant(5, name='input_a')  
b = tf.constant(3, name='input_b')  

#tf.constant() 상수 생성하는 Operation // Op라고 한다.  
#하나의 텐서 값을 받아서 연결된 노드에 같은 값을 출력한다.   

c = tf.add(a,b, name='add_c')  #두 개의 입력을 받아서 더한다.  
d = tf.subtract(a,b, name='sub_d')  #두 개의 입력을 받아서 뺀다.  
e = tf.multiply(a,b, name='mul_e')  #두 개의 입력을 받아서 곱한다.  
f = tf.div(a,b, name='div_f')  
#정수형 텐서인 경우 원소간 정수 나눗셈, 실수형 텐서인 경우 원소간 실수 나눗셈  
g = tf.truediv(a,b, name='truediv_g') #요소간 실수 나눗셈  

=====================#여기까지가 그래프의 정의

sess = tf.Session()  #그래프의 실행은 sess.run(op) 이용한다.  
print('a =',sess.run(a),'  b =',sess.run(b),'\n')  
print('a + b =',sess.run(c))      
print('a - b =',sess.run(d))  
print('a * b =',sess.run(e))  
print('a % b =',sess.run(f))    
print('a % b =',sess.run(g))  


### 실행 결과 ###  

a = 5   b = 3  

a + b = 8   
a - b = 2  
a * b = 15  
a % b = 1  
a % b = 1.6666666666666667  

#스칼라는 값으로 표현  
t_0 = np.array(50,dtype=np.int32)   


#벡터는 리스트로 표현    
#문자열 배열에는 dtype(데이터 타입) 명시하면 안된다.  
t_1 = np.array(["apple", "banana", "peach" ])   


 #행렬은 리스트의 중첩으로 표현  
t_2 = np.array([ [True, False, False], [False, False, True], [False, True, False] ], dtype=np.bool)  
        
        
#텐서는 리스트의 다중 중첩으로 표현          
t_3 = np.array([ [[2],[4],[6]], [[8],[10],[12]], [[14],[16],[18]] ], dtype=np.int64)  

ㆍㆍㆍ

###### 문자열을 제외한 나머지 경우에 dtype을 명시하지 않아도 되지만,   
###### 어떤 객체가 TypeMismatchError를 발생하는지 쉽게 찾을 수 있도록   
###### 텐서 객체가 가질 숫자형에 대해서는 명확하게 정의하는 것이 좋다.  
        

Shape                         |       Rank       |    Dimension-number(차원 번호)    
[]                            |         0        |          0-D 
[D0]                          |         1        |          1-D 
[D0,D1]                       |         2        |          2-D  
[D0,D1,D2]                    |         3        |          3-D  
ㆍㆍㆍ                        |        ㆍㆍㆍ     |         ㆍㆍㆍ  
[D0,D1,D2,ㆍㆍㆍ,Dn-1]        |          n       |           n-D  

import tensorflow as tf

a = tf.constant([5,3,2])
#이전과 달리 스칼라 숫자(값)가 아닌 텐서를 입력받는 예제이다.
#하나의 노드에 1차원 텐서(값의 리스트,벡터)를 입력받았다.

#벡터나 행렬의 원소들을 연산하여 
#스칼라 값을 구하는 연산은 tf.reduce_명령 사용한다.

b = tf.reduce_sum(a)
#설정한 차원에 따라 원소들을 더한다.
    
c = tf.reduce_prod(a)
#설정한 차원에 따라 원소들을 곱한다.

d = tf.reduce_max(a)
#설정한 차원에 따라 원소들 중에서 최댓값 선택.

e = tf.reduce_min(a)
#설정한 차원에 따라 원소들 중에서 최솟값 선택.

f = tf.reduce_mean(a)
#설정한 차원에 따라 원소들을 평균낸다.

#그 밖에 아래와 같은 명령 등이 있다.  
#tf.reduce_all 설정한 축으로 이동하면서 and 논리 연산을 수행한다.  
#tf.reduce_any  설정한 축으로 이동하면서 or논리 연산을 수행한다.  

sess = tf.Session() #그래프 실행을 위함  

print('원소들의 합',sess.run(b))  
print('원소들의 곱',sess.run(c))  
print('원소들 중 최댓값',sess.run(d))  
print('원소들 중 최솟값',sess.run(e))  
print('원소들의 평균',sess.run(f))  

##### 실행결과 #####

원소들의 합 10  
원소들의 곱 30  
원소들 중 최댓값 5  
원소들 중 최솟값 2  
원소들의 평균 3  

#평균을 보면 10 / 3 = 3.333334 이지만  
#[5,3,2]가 모두 정수형이라서 정수만 반환.

tf.add: 덧셈  
tf.subtract: 뺄셈  
tf.multiply: 곱셈  
tf.div: 정수형 텐서인 경우 정수, 실수면 실수 나눗셈    
tf.truediv: 실수 나눗셈(정수 포함)
tf.pow: n-제곱(지수승)  
tf.negative: 음수 부호  

등등  
***

tf.reduce_any: 설정한 축으로 이동하면서 or논리 연산을 수행한다.  
tf.reduce_mean: 설정한 축의 평균을 구한다.  
tf.reduce_max: 설정한 축의 최댓값을 구한다.  
tf.reduce_min: 설정한 축의 최솟값을 구한다.  
tf.reduce_prod: 설정한 축의 요소를 모두 곱한 값을 구한다.  
tf.reduce_sum: 설정한 축의 요소를 모두 더한 값을 구한다.  

***
tf.abs: 절대값  
tf.sign: 부호  
tf.round: 반올림  
tf.ceil: 올림  
tf.floor: 내림  
tf.square: 제곱  
tf.sqrt: 제곱근  
tf.maximum: 두 텐서의 각 원소에서 최댓값만 반환.  
tf.minimum: 두 텐서의 각 원소에서 최솟값만 반환.  
tf.cumsum: 누적합  
tf.cumprod: 누적곱  

***

tf.matmul: 내적  
tf.matrix_inverse: 역행렬  

***
다음은 벡터와 행렬의 크기 및 차원을 바꾸는 Ops이다.  

tf.reshape: 벡터 행렬의 크기 변환  
tf.transpose: 전치 연산  
tf.expand_dims: 지정한 축으로 차원을 추가  
tf.squeeze: 벡터로 차원을 축소  

***
벡터/행렬을 나누거나 두 개 이상의 벡터/행렬을 합치는 Ops도 많이 사용된다.  

tf.slice: 특정 부분을 추출  
tf.split: 분할  
tf.concat: 합치기  
tf.tile: 복제-붙이기  
tf.stack: 합성  
tf.unstack: 분리  

***
nn 서브패키지에는 신경망에서 쓰이는 함수들도 구현되어 있다.  

tf.nn.sigmoid: 로지스틱 함수  
tf.nn.softplus: 소프트플러스 함수  
tf.nn.softsign: 소프트사인 함수  

***
등등  

with g.as_default():  
    a = tf.add(2,3)
    

a = tf.add(2, 5)  
b = tf.multiply(a, 3)  
sess = tf.Session()  

replace_dict = { a : 15 } #위에서 a의 값이 7이 되지만, 15로 대체한다.   
sess.run(b, feed_dict=replace_dict) #실행 결과 45가 반환된다.  

import tensorflow as tf  
import numpy as np  

a = tf.placeholder(tf.int32, shape=[2])  
b = tf.reduce_prod(a)  
c = tf.reduce_sum(a)  
d = tf.sum(b,c) #tf.redece_sum([b,c])도 가능  

sess = tf.Session()

input_dict = { a : np.array([5, 3]}   
#플레이스홀더의 핸들(a)이 딕셔너리의 key로 사용되고,
#우리가 전달하려는 텐서 객체(np.array([5, 3]))가 딕셔너리의 value로 사용된다.

sess.run(d, feed_dict=input_dict)  

import tensorflow as tf  

my_var = tf.Variable(3)  
add = tf.add(5, my_var)  
mul = tf.multiply(8, my_var)  

tf.zeros()  
tf.ones()  
tf.random_normal() #정규분포형태의 난수 텐서 생성  
tf.truncated_normal() #정규분포형태의 난수 텐서 생성하는데, 표준편차 2배 이상인 값은 제외한다.  
tf.random_uniform() #균등분포형태의 난수 텐서 생성  

이들은 텐서의 shape 파라미터를 받는다.  

zeros = tf.zeros([2,2])  
#2X2의 0행렬 생성

ones = tf.ones([6])  
#길이가 6인 1로 채워진 벡터 생성  


ㆍㆍㆍ

import tensorflow as tf  

init = tf.global_variables_initializer()  
sess = tf.Session()  
sess.run(init)

import tensorflow as tf  

my_var = tf.Variable(1)

my_var_times_two = my_var.assign(my_var * 2)  
#현재의 변수의 값에서 X2한 값을 부여한다.  
#my_var_times_two가 sess.run에서 실행될 때 마다 값이 바뀐다.  

init = tf.global_variables_initializer()  
sess = tf.Session()  
sess.run(init)  

sess.run(my_var_times_two) #output : 2  

sess.run(my_var_times_two) #output : 4  

sess.run(my_var_times_two) #output : 8  

sess.run(my_var.assign_add(1)) #output : 9  

sess.run(my_var.assign_sub(4)) #output : 5  

import tensorflow as tf

with tf.name_scope("Scope_A"):
    a = tf.add(1, 2)  
    b = tf.multiply(a, 3)  
    
with tf.name_scope("Scope_B"):
    c = tf.add(4, 5)  
    d = tf.multiply(c, 6)  

e = tf.add(b,d)