Tensorflow 개념

Basic Usage

To use TensorFlow you need to understand how TensorFlow:

  • Represents computations as graphs.
  • Executes graphs in the context of Sessions.
  • Represents data as tensors.
  • Maintains state with Variables.
  • Uses feeds and fetches to get data into and out of arbitrary operations.

텐서플로우는 그래프로 데이터 계산을 구조화함.

Session 이라는 개념으로 그래프를 실행.

데이터를 tensor로 표현.

데이터의 state를 variable로 저장.

임의의 operation에서 feed와 fetch를 사용해서 데이터를 꺼내오거나 저장.

 

Overview

TensorFlow is a programming system in which you represent computations as graphs. Nodes in the graph are called ops (short for operations). An op takes zero or more Tensors, performs some computation, and produces zero or more Tensors. A Tensor is a typed multi-dimensional array. For example, you can represent a mini-batch of images as a 4-D array of floating point numbers with dimensions [batch, height, width, channels].

computation -> graph

Graph의 node ->  ops(operations)

하나의 op는 0개 이상의 Tensor를 취한 후에 computation을 하고,  역시 0개 이상의 Tensor를 생산해낸다.

Tensor는 다차원 array 타입이다. 예를 들어, 당신은 한묶음의 이미지를 floating point number의 4 dimension array로 표현할 수 있다.  [batch, height, width, channels]

A TensorFlow graph is a description of computations. To compute anything, a graph must be launched in a Session. A Session places the graph ops onto Devices, such as CPUs or GPUs, and provides methods to execute them. These methods return tensors produced by ops as numpy ndarray objects in Python, and as tensorflow::Tensor instances in C and C++.

tensorflow의 graph는 computation의 설명이다.

어떤 계산을 수행하려면, 그래프는 Session안에서 실행되어야 한다. Session은 graph ops를 Device(CPU나 GPU같은)에 위치시키고, 실행할 수 있는 메소드를 제공한다.

이러한 메소드는 tensor를 리턴하는데, 이 때 ops는 이 tensor를 파이썬 환경에서는  numpy의 ndarray 오브젝트 형태로 생성하고 c c++ 환경에서는 tensorflow::Tensor 인스턴스 형태로 생성한다.

The computation graph

TensorFlow programs are usually structured into a construction phase, that assembles a graph, and an execution phase that uses a session to execute ops in the graph.

Tensorflow 프로그램들은 다음 두가지 구조로 되어 있다.

  • graph를 만드는 construction phase

  • session을 사용해서 graph안의 ops를 실행하는 execution phase

For example, it is common to create a graph to represent and train a neural network in the construction phase, and then repeatedly execute a set of training ops in the graph in the execution phase.

construction phase에서 뉴럴넷 학습을 반영하는 graph를 만들고, execution phase 에서 graph안의 트레이닝 ops를 반복적으로 실행하는 것이 일반적이다.

TensorFlow can be used from C, C++, and Python programs. It is presently much easier to use the Python library to assemble graphs, as it provides a large set of helper functions not available in the C and C++ libraries.

The session libraries have equivalent functionalities for the three languages.

Graph를 생성함에 있어서는 C/C++ 환경보다 Python환경이 여러가지로 편리하다

Session 라이브러리는 세 환경에 동일한 기능을 가지고 있다.

Building the graph

To build a graph start with ops that do not need any input (source ops), such as Constant, and pass their output to other ops that do computation.

graph를 만들려면 , 먼저 ops로 시작한다. 아무런 인풋(source ops(노드))도 필요 없다. (constant 같은) 그리고 그 아웃풋을 계산하는 다른 ops로 보낸다.

The ops constructors in the Python library return objects that stand for the output of the constructed ops. You can pass these to other ops constructors to use as inputs.

파이썬 라이브러리의 ops constructor는 생성된 ops의 아웃풋을 의미하는 오브젝트를 리턴한다. 그러면 이것들을 다른 ops constructor로 보내서 인풋으로 사용할 수 있다.

The TensorFlow Python library has a default graph to which ops constructors add nodes. The default graph is sufficient for many applications. See the Graph class documentation for how to explicitly manage multiple graphs.

텐서플로우 파이선 라이브러리는 ops constructor 가 node를 더할 수 있는 디폴트 graph를 제공한다. 이 기본 graph는 많은 경우의 어플리케이션에 사용하기에 충분하다.

여러개의 graph를 명시적으로 사용하기 위해서는 Graph class 다큐먼트를 참고해라.

import tensorflow as tf

# Create a Constant op that produces a 1x2 matrix.  The op is
# added as a node to the default graph.
#
# The value returned by the constructor represents the output
# of the Constant op.
matrix1 = tf.constant([[3., 3.]])

# Create another Constant that produces a 2x1 matrix.
matrix2 = tf.constant([[2.],[2.]])

# Create a Matmul op that takes 'matrix1' and 'matrix2' as inputs.
# The returned value, 'product', represents the result of the matrix
# multiplication.
product = tf.matmul(matrix1, matrix2)

The default graph now has three nodes: two constant() ops and one matmul() op. To actually multiply the matrices, and get the result of the multiplication, you must launch the graph in a session.

이 그래프는 총 3개의 노드를 가지고 있다. : 두개의 constant() ops와 하나의 matnul() ops(이 노드에서 앞의 두개의 노드를 인풋으로 받는다.) 두 매트릭스를 곱하기 위해서는 이 그래프를 세션 안에서 실행시켜야 한다.

Launching the graph in a session

Launching follows construction. To launch a graph, create a Session object. Without arguments the session constructor launches the default graph.

construction 후에는 launch해야 한다. Session 오브젝트를 만들고, 아무런 argument를 설정하지 않으면 session constructor는 디폴트 graph 를 실행한다.

See the Session class for the complete session API.

# Launch the default graph.
sess = tf.Session()

# To run the matmul op we call the session 'run()' method, passing 'product'
# which represents the output of the matmul op.  This indicates to the call
# that we want to get the output of the matmul op back.
#
# All inputs needed by the op are run automatically by the session.  They
# typically are run in parallel.
#
# The call 'run(product)' thus causes the execution of three ops in the
# graph: the two constants and matmul.
#
# The output of the op is returned in 'result' as a numpy `ndarray` object.
result = sess.run(product)
print(result)
# ==> [[ 12.]]

# Close the Session when we're done.
sess.close()

Sessions should be closed to release resources. You can also enter a Session with a “with” block. The Sessioncloses automatically at the end of the with block.

세션은 close해야 리소스를 다시 release 한다.  with 블록 안으로 들어가서 session을 실행할 수도 있다. 이때는 블록이 끝났을 때 자동적으로 session 이 종료된다.

with tf.Session() as sess:
  result = sess.run([product])
  print(result)

The TensorFlow implementation translates the graph definition into executable operations distributed across available compute resources, such as the CPU or one of your computer’s GPU cards. In general you do not have to specify CPUs or GPUs explicitly. TensorFlow uses your first GPU, if you have one, for as many operations as possible.

텐서플로우 implementation 은 정의된 그래프를 실행가능한 operation으로 translate하고, CPU나 GPU 같은 리소스에 분배한다. 보통의 경우는 CPU나 GPU를 명시하지 않아도 된다. 텐서플로우는 우선적으로 GPU를 사용해서 최대한 많은 계산을 처리한다.

If you have more than one GPU available on your machine, to use a GPU beyond the first you must assign ops to it explicitly. Use with...Device statements to specify which CPU or GPU to use for operations:

GPU가 여러개 있으면 명시적으로 ops를 지정할 수 있다. with … Device 구문으로 ops 마다 할당한다.

with tf.Session() as sess:
  with tf.device("/gpu:1"):
    matrix1 = tf.constant([[3., 3.]])
    matrix2 = tf.constant([[2.],[2.]])
    product = tf.matmul(matrix1, matrix2)
    ...

Devices are specified with strings. The currently supported devices are:

디바이스들은 스트링으로 정의된다. 지원되는 디바이스는 다음과 같다.:

  • "/cpu:0": The CPU of your machine.
  • "/gpu:0": The GPU of your machine, if you have one.
  • "/gpu:1": The second GPU of your machine, etc.

See Using GPUs for more information about GPUs and TensorFlow.

Launching the graph in a distributed session

To create a TensorFlow cluster, launch a TensorFlow server on each of the machines in the cluster. When you instantiate a Session in your client, you pass it the network location of one of the machines in the cluster:

Tensorflow 클러스터를 만들기 위해서는, 클러스터안의 개별 머신마다 tensorflow 서버를 가동시켜야 한다.

with tf.Session("grpc://example.org:2222") as sess:
  # Calls to sess.run(...) will be executed on the cluster.
  ...

This machine becomes the master for the session. The master distributes the graph across other machines in the cluster (workers), much as the local implementation distributes the graph across available compute resources within a machine.

이 머신은 세션의 마스터가 된다. 마스터는 클러스터안의 다른 머신들 사이에 그래프를 분배한다.(마치 로컬에서 적용할 때 한 머신 안에서 컴퓨터 리소스에 분배하듯이.)

You can use “with tf.device():” statements to directly specify workers for particular parts of the graph:

with tf.device("/job:ps/task:0"):
  weights = tf.Variable(...)
  biases = tf.Variable(...)

See the Distributed TensorFlow How To for more information about distributed sessions and clusters.

Interactive Usage

The Python examples in the documentation launch the graph with a Session and use the Session.run()method to execute operations.

For ease of use in interactive Python environments, such as IPython you can instead use theInteractiveSession class, and the Tensor.eval() and Operation.run() methods. This avoids having to keep a variable holding the session.

iPython 과 같은 인터랙티브한 환경에서는 Session 대신 InteractiveSession 클래스를 사용하고, Tensor.eval()와 Operation.run() 메소드를 사용한다.

이로써 variable이 session을 홀드하고 있는 상황을 피할 수 있다.

# Enter an interactive TensorFlow Session.
import tensorflow as tf
sess = tf.InteractiveSession()

x = tf.Variable([1.0, 2.0])
a = tf.constant([3.0, 3.0])

# Initialize 'x' using the run() method of its initializer op.
x.initializer.run()

# Add an op to subtract 'a' from 'x'.  Run it and print the result
sub = tf.sub(x, a)
print(sub.eval())
# ==> [-2. -1.]

# Close the Session when we're done.
sess.close()

Tensors

TensorFlow programs use a tensor data structure to represent all data — only tensors are passed between operations in the computation graph. You can think of a TensorFlow tensor as an n-dimensional array or list. A tensor has a static type, a rank, and a shape. To learn more about how TensorFlow handles these concepts, see the Rank, Shape, and Type reference.

텐서플로우는 tensor 데이터 형을 사용해서 모든 데이터를 나타낸다. 그래프안에서 operation 사이에서는 오직 tensor만이 전달될 수 있다. 텐서플로우의 tensor는 n-dimentional array라고 생각하면 된다. tensor 는 고정된 type, rank, shape을 가지고 있다. 텐서플로우가 어떻게 이러한 컨셉을 다루는지 보려면 다음 링크를 참고해라. : Rank, Shape, and Type reference.

Variables

Variables maintain state across executions of the graph. The following example shows a variable serving as a simple counter. See Variables for more details.

변수는 그래프의 실행하는 동안 state를 유지한다. 간단한 카운터 예제를 보자.

# Create a Variable, that will be initialized to the scalar value 0.
state = tf.Variable(0, name="counter")

# Create an Op to add one to `state`.
one = tf.constant(1)
# Add an op to add 'state' and 'one' -> 'new_value'
new_value = tf.add(state, one)
update = tf.assign(state, new_value)

# Variables must be initialized by running an `init` Op after having
# launched the graph.  We first have to add the `init` Op to the graph.
init_op = tf.initialize_all_variables()

# Launch the graph and run the ops.
with tf.Session() as sess:
  # Run the 'init' op
  sess.run(init_op)
  # Print the initial value of 'state'
  # 'state'도 op인데, tf.Variable(어쩌구) op이다. 이건 assign같은 역할의 op이다.
  print(sess.run(state))
  # Run the op that updates 'state' and print 'state'.
  for _ in range(3):
    sess.run(update)
    print(sess.run(state))

# output:

# 0
# 1
# 2
# 3

The assign() operation in this code is a part of the expression graph just like the add() operation, so it does not actually perform the assignment until run() executes the expression.

assign() 은 add()처럼 expression graph의 일부이다. 따라서 run()으로만 실행된다.

You typically represent the parameters of a statistical model as a set of Variables. For example, you would store the weights for a neural network as a tensor in a Variable. During training you update this tensor by running a training graph repeatedly.

주로 통계모델의 parameter들을 variable로 저장한다. 예를 들어, neural network 의 weight들을 variable 의 tensor로 저장한다. 트레이닝 동안 트레이닝 그래프를 반복적으로 수행하면서 이 tensor를 업데이트 하게되는 것이다.

Advertisements

Leave a Reply

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out / Change )

Twitter picture

You are commenting using your Twitter account. Log Out / Change )

Facebook photo

You are commenting using your Facebook account. Log Out / Change )

Google+ photo

You are commenting using your Google+ account. Log Out / Change )

Connecting to %s