TensorFlow

- 가장 널리 쓰이는 딥러닝 프레임 워크 중 하나

- 구글이 주도적으로 개발하는 플랫폼

- 파이썬 C++ API를 기본적으로 제공하고 JavaScrpt, Java, Go, Swift 등 다양한 프로그래밍 언어를 지원

- tf.keras를 중심으로 고수준 API 통합 (2.x 버전)

- TPU (Tensor Processing Unit) 지원

TPU는 GPU보다 전력을 적게 소모, 경제적

일반적으로 32비트(float32)로 수행되는 곱셈 연산을 16비트(float16)로 낮춤

 

TensorFlow Architecture

 

TensorFlow Estimators ← High-level, object-oriented API

tf.layers, tf.losses, tf.metrics ←  Reusable libraries for common model components

Python TensorFlow ← Provides Ops, which wrap C++ Kernels

C++ TensorFlow

CPU, GPU, TPU ← Kernels work on one or more platforms

 

 Getting Started with TensorFlow

 

import numpy as np
import tensorflow as tf

print(tf.__version__)   # 2.10.0

> Objects in the Tensor

- Type : string, float32, float16, int32, int8 etc.

- Shape : 0, 1, 2 Data dimensions

- Rank(axis) : the number of dimensions

 

> Dimensions and Operation of tensor

import numpy as np
import tensorflow as tf

# Scala
d0 = tf.constant(2)
print(tf.rank(d0))          # tf.Tensor(0, shape=(), dtype=int32)
print(d0)                   # tf.Tensor(2, shape=(), dtype=int32)

# Vector
d1 = tf.constant([1, 2, 3, 4, 5])
print(tf.rank(d1))          # tf.Tensor(1, shape=(), dtype=int32)
print(d1)                   # tf.Tensor([1 2 3 4 5], shape=(5,), dtype=int32)

# Matrix
d2 = tf.constant([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
print(tf.rank(d2))          # tf.Tensor(2, shape=(), dtype=int32)
print(d2)                   # tf.Tensor(
                            #[[1 2 3]
                            # [4 5 6]
                            # [7 8 9]], shape=(3, 3), dtype=int32)
                            
# Tensor
d3 = tf.constant([[[1, 2, 3], [4, 5, 6], [7, 8, 9]],
               [[10, 11, 12], [13, 14, 15], [16, 17, 18]],
               [[19, 20, 21], [22, 23, 24], [25, 26, 27]]])
print(tf.rank(d3))          # tf.Tensor(3, shape=(), dtype=int32)
print(d3)                   # tf.Tensor(
                            #[[[ 1  2  3]
                            #  [ 4  5  6]
                            #  [ 7  8  9]]

                            # [[10 11 12]
                            #  [13 14 15]
                            #  [16 17 18]]

                            # [[19 20 21]
                            #  [22 23 24]
                            #  [25 26 27]]], shape=(3, 3, 3), dtype=int32)

# String
s = tf.constant(["Hello"])
print(tf.rank(s))           # tf.Tensor(1, shape=(), dtype=int32)
print(s)                    # tf.Tensor([b'Hello'], shape=(1,), dtype=string)

### Create random values ###

# Uniform distribution
urand = tf.random.uniform([1], 0, 1) # ([shape], minval, maxval, (dtype))
print(urand.shape)           # (1,)
print(urand)                 # tf.Tensor([0.11899364], shape=(1,), dtype=float32)

# Normal distribution
nrand = tf.random.normal([1, 2], 0, 1)  # ([shape], mean, stddev, (dtype))
print(nrand.shape)              # (1, 2)
print(nrand)                    # tf.Tensor([[ 0.05588345 -0.60166097]], shape=(1, 2), dtype=float32)

# Normal distribution (Custom)
nrand1 = tf.random.normal(shape=(3, 2), mean=0, stddev=1) 
print(nrand1.shape)             # (3, 2)
print(nrand1)                   #tf.Tensor(
                                #[[ 0.29473513 -1.2786306 ]
                                # [ 0.90898395 -0.49719712]
                                # [-1.11105     2.5601935 ]], shape=(3, 2), dtype=float32)

 

Immediate-Run Mode Support (Eager Mode)

 

- 즉시 실행모드를 통해 텐서플로우를 파이썬처럼 사용할 수 있음

- 1.x 버전에서는 'Graph' 를 생성하고, 초기화한 뒤에 세션을 통해 값을 흐르게하는 작업을 진행해야 함

 

### Common Arithmetics Operators ###
a = tf.constant(3)
b = tf.constant(4)
print(tf.add(a, b)) 
print(a + b)       

print(tf.subtract(a, b))
print(a - b)

print(tf.multiply(a, b))
print(a * b)

print(tf.divide(a, b))
print(a / b)

 

Compatibility between TensorFlow and Numpy

### Compatibility bewwen TensorFlow and Numpy ###

a = tf.constant(3)
b = tf.constant(4)
c = tf.add(a, b).numpy()    # Convert to Numpy .numpy()
print(type(c))          # <class 'numpy.int32'>

c_square = np.square(c, dtype=np.float32)
c_tensor = tf.convert_to_tensor(c_square)
print(c_tensor)             # tf.Tensor(49.0, shape=(), dtype=float32)
print(type(c_tensor))       # <class 'tensorflow.python.framework.ops.EagerTensor'>

 

Use like a Numpy

### Use like a Numpy ###

t = tf.constant([[1., 2., 3.], [4., 5., 6.]])

print(t.shape)      # (2, 3)
print(t.dtype)      # <dtype: 'float32'>

# Slicing
print(t[:, 1:])     # tf.Tensor(
                    #[[2. 3.]
                    # [5. 6.]], shape=(2, 2), dtype=float32)
                    
print(t[..., 1, tf.newaxis])    #tf.Tensor(
                                #[[2.]
                                # [5.]], shape=(2, 1), dtype=float32)

print(t + 10)                   #tf.Tensor(
                                #[[11. 12. 13.]
                                # [14. 15. 16.]], shape=(2, 3), dtype=float32)

print(tf.square(t))             #tf.Tensor(
                                #[[ 1.  4.  9.]
                                # [16. 25. 36.]], shape=(2, 3), dtype=float32)
                                
print(t @ tf.transpose(t))      #tf.Tensor(
                                #[[14. 32.]
                                # [32. 77.]], shape=(2, 2), dtype=float32)

 

Type Conversion

 

> 텐서의 기본 dtype

- float형 텐서 : float32

- int형 텐서 : int32

 

> 연산시 텐서의 타입을 맞춰줘야 함

- float32 ~ float32

- int32 ~ int32

- float32 ~ int32 (x)

 

> 타입변환에는 tf.cast() 사용

 

### Type conversion ###

a = tf.constant(2)
print(a)

b = tf. constant(2.)
print(b)

# print(tf.constant(2.) + tf.constant(40))    # ERROR

print(a + tf.cast(b, tf.int32)) # tf.Tensor(4, shape=(), dtype=int32)   # CORRECT

 

Auto Graph

 

> Tensorflow가 작업을 좀 더 빠르게 동작하게 하기 위한 방법으로 Graph로 만들어 연산을 진행

> tf.Graph

> 유연성이 있음

- Mobile application, Embedded devices, Backend Server와 같이 Python Interpreter가 없는 환경에서

TensorFlow 사용 가능

 

import timeit

 

@tf.function

- 자동으로 그래프를 생성 (Auto Graph)

- 그래프로 변환하여 사용 -> GPU 연산 가능

- 파이썬으로 구성된 함수를 텐서플로우의 그래프 형태로 다루고 싶을 때 사용가능

- 원본 함수가 필요하다면 (tf.function).python_function()

 

### Auto Graph ###

import timeit

@tf.function
def my_function(x):
    return x**2 - 10*x + 3

print(my_function(2))               # tf.Tensor(-13, shape=(), dtype=int32)
print(my_function(tf.constant(2)))  # tf.Tensor(-13, shape=(), dtype=int32)


def my_function_(x):
    return x**2 - 10*x + 3

print(my_function_(2))              # -13
print(my_function_(tf.constant(2))) # tf.Tensor(-13, shape=(), dtype=int32)

tf_my_func = tf.function(my_function_)
print(tf_my_func)   # <tensorflow.python.eager.def_function.Function object at 0x000001D588B8FE20>
print(tf_my_func(2))    # tf.Tensor(-13, shape=(), dtype=int32)

print(tf_my_func.python_function(2))    # -13

# ---------------------------------- #

def function_to_get_faster(x, y, b):
    x = tf.matmul(x, y) # 행렬곱
    x = x + b
    return x

a_function_that_uses_a_graph = tf.function(function_to_get_faster)

x1 = tf.constant([[1.0, 2.0]])
y1 = tf.constant([[2.0], [3.0]])
b1 = tf.constant(4.0)

print(a_function_that_uses_a_graph(x1, y1, b1).numpy()) # [[12.]]

# ---------------------------------- #

def inner_function(x, y, b):
    x = tf.matmul(x, y)
    x = x + b
    return x

@tf.function
def outer_function(x):
    y = tf.constant([[2.0], [3.0]])
    b = tf.constant(4.0)
    return inner_function(x, y, b)

print(outer_function(tf.constant([[1.0, 2.0]])).numpy())    # [[12.]]

# TensorFlow가 tf.function 으로 변환한 코드

print(tf.autograph.to_code(my_function.python_function))

# def tf__my_function(x):
#     with ag__.FunctionScope('my_function', 'fscope', ag__.ConversionOptions(recursive=True, user_requested=True, optional_features=(), internal_convert_user_code=True)) as fscope:
#         do_return = False
#         retval_ = ag__.UndefinedReturnValue()
#         try:
#             do_return = True
#             retval_ = (((ag__.ld(x) ** 2) - (10 * ag__.ld(x))) + 3)
#         except:
#             do_return = False
#             raise
#         return fscope.ret(retval_, do_return)

### Speed up ###

class SequentialModel(tf.keras.Model):
    def __init__(self, **kwargs):
        super(SequentialModel, self).__init__(**kwargs)
        self.flatten = tf.keras.layers.Flatten(input_shape=(28, 28))
        self.dense_1 = tf.keras.layers.Dense(128, activation='relu')
        self.dropout = tf.keras.layers.Dropout(0.2)
        self.dense_2 = tf.keras.layers.Dense(10)
        
    def call(self, x):
        x = self.flatten(x)
        x = self.dense_1(x)
        x = self.dropout(x)
        x = self.dense_2(x)
        return x

input_data = tf.random.uniform([60, 28, 28])
eager_model = SequentialModel()
graph_model = tf.function(eager_model)

print("Eager time: ", timeit.timeit(lambda: eager_model(input_data), number=10000))
# Eager time:  17.7394254
print("Graph time: ", timeit.timeit(lambda: graph_model(input_data), number=10000))
# Graph time:  7.893326300000002

 

Create Variables

 

- tf.Variable

- 딥러닝 모델 학습 시, 그래프 연산이 필요할 때 사용

 

### Create Variables ###

X = tf.Variable(20.0)

print(X)    # <tf.Variable 'Variable:0' shape=() dtype=float32, numpy=20.0>

 

Autograd (자동미분)

 

- tf.GradientTape : API를 사용

- tf.Variable : 같은 일부 입력에 대한 기울기 계산 (기본적으로 한번만 사용됨)

- 변수가 포함된 연산만 기록

 

### Autograd ###

x = tf.Variable(3.0)

with tf.GradientTape() as tape:
    y = x**2

dy_dx = tape.gradient(y, x)
print(dy_dx.numpy())    # 6.0