tensorflow Samouczek
Rozpoczęcie pracy z tensorflow

Uwagi

Instalacja lub konfiguracja

Od wersji Tensorflow 1.0 instalacja stała się znacznie łatwiejsza do wykonania. Co najmniej, aby zainstalować TensorFlow, należy zainstalować na swoim komputerze pip z wersją Pythona co najmniej 2.7 lub 3.3+.

pip install --upgrade tensorflow      # for Python 2.7
pip3 install --upgrade tensorflow     # for Python 3.n

Dla tensorflow na maszynie GPU (od 1.0 wymaga CUDA 8.0 i cudnn 5.1, GPU AMD nie jest obsługiwane)

pip install --upgrade tensorflow-gpu  # for Python 2.7 and GPU
pip3 install --upgrade tensorflow-gpu # for Python 3.n and GPU

Aby sprawdzić, czy zadziałało, otwórz poprawną wersję Pythona 2 lub 3 i uruchom

import tensorflow

Jeśli zakończyło się to bezbłędnie, masz zainstalowany tensorflow na swoim komputerze.

* Należy pamiętać, że odnosi się to do gałęzi master, można to zmienić w powyższym linku, aby odwołać się do bieżącej stabilnej wersji).

Podstawowy przykład

Tensorflow to coś więcej niż tylko platforma do głębokiego uczenia się. Jest to ogólna struktura obliczeniowa do wykonywania ogólnych operacji matematycznych w sposób równoległy i rozproszony. Przykład takiego opisano poniżej.

Regresja liniowa

Podstawowym przykładem statystycznym, który jest powszechnie wykorzystywany i jest raczej prosty do obliczenia, jest dopasowanie wiersza do zestawu danych. Metodę wykonania tego w tensorflow opisano poniżej w kodzie i komentarzach.

Główne kroki skryptu (TensorFlow) to:

1. Deklaracja x_ph zastępczych ( x_ph , y_ph ) i zmiennych ( W , b )
2. Zdefiniuj operator inicjalizacji ( init )
3. Deklaruj operacje na y_pred zastępczych i zmiennych ( y_pred , loss , train_op )
4. Utwórz sesję ( sess )
5. Uruchom operator inicjalizacji ( sess.run(init) )
6. Uruchom niektóre operacje na wykresie (np. sess.run([train_op, loss], feed_dict={x_ph: x, y_ph: y}) )

Konstrukcja wykresu odbywa się za pomocą interfejsu API Python TensorFlow (można to również zrobić za pomocą interfejsu API TensorFlow C ++). Uruchomienie wykresu wywoła procedury niskiego poziomu C ++.

'''
function: create a linear model which try to fit the line 
          y = x + 2 using SGD optimizer to minimize 
          root-mean-square(RMS) loss function

'''
import tensorflow as tf
import numpy as np

# number of epoch
num_epoch = 100

# training data x and label y
x = np.array([0., 1., 2., 3.], dtype=np.float32)
y = np.array([2., 3., 4., 5.], dtype=np.float32)

# convert x and y to 4x1 matrix
x = np.reshape(x, [4, 1])
y = np.reshape(y, [4, 1])

# test set(using a little trick)
x_test = x + 0.5
y_test = y + 0.5

# This part of the script builds the TensorFlow graph using the Python API

# First declare placeholders for input x and label y
# Placeholders are TensorFlow variables requiring to be explicitly fed by some 
# input data
x_ph = tf.placeholder(tf.float32, shape=[None, 1])
y_ph = tf.placeholder(tf.float32, shape=[None, 1])

# Variables (if not specified) will be learnt as the GradientDescentOptimizer
# is run
# Declare weight variable initialized using a truncated_normal law
W = tf.Variable(tf.truncated_normal([1, 1], stddev=0.1))
# Declare bias variable initialized to a constant 0.1
b = tf.Variable(tf.constant(0.1, shape=[1]))

# Initialize variables just declared 
init = tf.initialize_all_variables()

# In this part of the script, we build operators storing operations
# on the previous variables and placeholders.
# model: y = w * x + b
y_pred = x_ph * W + b

# loss function
loss = tf.mul(tf.reduce_mean(tf.square(tf.sub(y_pred, y_ph))), 1. / 2)
# create training graph
train_op = tf.train.GradientDescentOptimizer(0.1).minimize(loss)

# This part of the script runs the TensorFlow graph (variables and operations
# operators) just built.
with tf.Session() as sess:
    # initialize all the variables by running the initializer operator
    sess.run(init)
    for epoch in xrange(num_epoch):
        # Run sequentially the train_op and loss operators with
        # x_ph and y_ph placeholders fed by variables x and y
        _, loss_val = sess.run([train_op, loss], feed_dict={x_ph: x, y_ph: y})
        print('epoch %d: loss is %.4f' % (epoch, loss_val))

    # see what model do in the test set
    # by evaluating the y_pred operator using the x_test data
    test_val = sess.run(y_pred, feed_dict={x_ph: x_test})
    print('ground truth y is: %s' % y_test.flatten())
    print('predict y is     : %s' % test_val.flatten())

Podstawy Tensorflow

Tensorflow działa na zasadzie grafów przepływu danych. Aby wykonać pewne obliczenia, należy wykonać dwa kroki:

1. Reprezentuj obliczenia jako wykres.
2. Wykonaj wykres.

Reprezentacja: Jak każdy ukierunkowany wykres, wykres Tensorflow składa się z węzłów i krawędzi kierunkowych.

Węzeł: Węzeł jest również nazywany Op (skrót od operacji). Węzeł może mieć wiele krawędzi przychodzących, ale jedną krawędź wychodzącą.

Edge: Wskazuje przychodzące lub wychodzące dane z węzła. W tym przypadku dane wejściowe i wyjściowe niektórych Węzłów (Op).

Ilekroć mówimy dane, mamy na myśli n-wymiarowy wektor znany jako Tensor. Tensor ma trzy właściwości: Ranga, Kształt i Typ

• Ranga oznacza liczbę wymiarów Tensora (sześcian lub pudełko ma rangę 3).
• Kształt oznacza wartości tych wymiarów (pudełko może mieć kształt 1x1x1 lub 2x5x7).
• Typ oznacza typ danych w każdej współrzędnej Tensora.

Wykonanie: Mimo że skonstruowany jest wykres, nadal jest on bytem abstrakcyjnym. Żadne obliczenia nie występują, dopóki go nie uruchomimy. Aby uruchomić wykres, musimy przydzielić zasoby procesora do operacji wewnątrz wykresu. Odbywa się to za pomocą sesji Tensorflow. Kroki to:

1. Utwórz nową sesję.
2. Uruchom dowolną operację na wykresie. Zwykle uruchamiamy ostatnią operację, w której oczekujemy wyników naszych obliczeń.

Przychodząca krawędź na Op jest jak zależność dla danych na innym Op. Tak więc, kiedy uruchamiamy dowolną operację, śledzone są wszystkie przychodzące do niej krawędzie, a operacje po drugiej stronie również są uruchamiane.

Uwaga: Możliwe są również specjalne węzły zwane grającą rolą źródła danych lub ujścia. Na przykład możesz mieć Op, który daje stałą wartość, a zatem nie ma krawędzi przychodzących (patrz wartość „matrix1” w przykładzie poniżej) i podobnie Op bez krawędzi wychodzących, w których gromadzone są wyniki (patrz wartość „produkt” w poniższym przykładzie).

Przykład:

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)

# 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()

Licząc do 10

W tym przykładzie używamy Tensorflow do zliczenia do 10. Tak, to jest całkowita nadwyżka, ale to dobry przykład, aby pokazać absolutnie minimalną konfigurację potrzebną do korzystania z Tensorflow

import tensorflow as tf

# create a variable, refer to it as 'state' and set it to 0
state = tf.Variable(0)

# set one to a constant set to 1
one = tf.constant(1)

# update phase adds state and one and then assigns to state
addition = tf.add(state, one)
update = tf.assign(state, addition )

# create a session
with tf.Session() as sess:
  # initialize session variables
  sess.run( tf.global_variables_initializer() )

  print "The starting state is",sess.run(state)

  print "Run the update 10 times..."
  for count in range(10):
    # execute the update
    sess.run(update)

  print "The end state is",sess.run(state)

Ważne jest, aby zdać sobie sprawę z tego, że stan, jeden, dodawanie i aktualizacja nie zawierają wartości. Zamiast tego są odwołaniami do obiektów Tensorflow. Ostateczny wynik nie jest stanem , ale jest pobierany za pomocą Tensorflow do oceny go za pomocą sess.run (stan)

Ten przykład pochodzi z https://github.com/panchishin/learn-to-tensorflow . Istnieje kilka innych przykładów i fajny plan uczenia się, który ma na celu zapoznanie się z manipulowaniem grafem Tensorflow w pythonie.