tensorflow учебник
Начало работы с тензорным потоком

замечания

Установка или настройка

Начиная с версии Tensorflow версии 1.0 стало намного проще выполнять. При минимальной установке TensorFlow на ваш компьютер должен быть установлен пипс с версией python не менее 2.7 или 3.3+.

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

Для тензорного потока на GPU-машине (с 1.0 требуется CUDA 8.0 и cudnn 5.1, AMD GPU не поддерживается)

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

Чтобы проверить, работает ли он, откройте правильную версию python 2 или 3 и запустите

import tensorflow

Если это удалось без ошибок, то на вашем компьютере установлен тензор.

* Помните, что это ссылается на основную ветвь, которую можно изменить на ссылку выше, чтобы ссылаться на текущую стабильную версию.)

Основной пример

Tensorflow - это больше, чем просто глубокая система обучения. Это общая вычислительная структура для выполнения общих математических операций в параллельном и распределенном порядке. Пример такого описан ниже.

Линейная регрессия

Основной статистический пример, который обычно используется и достаточно прост для вычисления, - это привязка строки к набору данных. Метод для этого в тензорном потоке описан ниже в коде и комментариях.

Основные шаги сценария (TensorFlow):

1. Объявлять заполнители ( x_ph , y_ph ) и переменные ( W , b )
2. Определите оператор инициализации ( init )
3. Объявлять операции с заполнителями и переменными ( y_pred , loss , train_op )
4. Создание сеанса ( sess )
5. Запустите оператор инициализации ( sess.run(init) )
6. Запустите некоторые операции с графами (например, sess.run([train_op, loss], feed_dict={x_ph: x, y_ph: y}) )

Конструкция графика выполняется с использованием API Python TensorFlow (также может быть выполнена с использованием C ++ TensorFlow API). Запуск графика вызовет низкоуровневые подпрограммы 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())

Основы тензора

Tensorflow работает по принципу графов потока данных. Для выполнения некоторых вычислений выполняются два шага:

1. Представьте вычисление как график.
2. Выполните график.

Представление. Как и любой направленный граф, граф Tensorflow состоит из узлов и направленных ребер.

Узел: Узел также называется Op (означает операцию). Узел может иметь несколько входящих краев, но один исходящий край.

Edge: указывать входящие или исходящие данные из узла. В этом случае ввод и вывод некоторых узлов (Op).

Всякий раз, когда мы говорим данные, мы имеем в виду n-мерный вектор, известный как Тензор. Тензор имеет три свойства: ранг, форма и тип

• Ранг означает количество измерений тензора (куб или поле имеет ранг 3).
• Форма означает значения этих размеров (коробка может иметь форму 1x1x1 или 2x5x7).
• Тип означает тип данных в каждой координате тензора.

Исполнение: Несмотря на то, что граф построен, он все еще является абстрактным объектом. На самом деле вычислений не происходит, пока мы не запустим его. Чтобы запустить график, нам нужно выделить ресурс CPU для Ops внутри графика. Это делается с помощью сеансов Tensorflow. Шаги:

1. Создайте новый сеанс.
2. Запустите любую Op внутри графа. Обычно мы запускаем финальный Op, где ожидаем выход наших вычислений.

Входной край на Op подобен зависимости для данных на другой Op. Таким образом, когда мы запускаем любую Op, все входящие ребра на ней прослеживаются, а ops с другой стороны также запускаются.

Примечание. Также возможны специальные узлы, которые играют роль источника данных или приемника. Например, у вас может быть Op, который дает постоянное значение, поэтому нет входящих ребер (см. Значение «matrix1» в примере ниже) и аналогично Op без исходящих ребер, где собираются результаты (см. Значение «продукт» в примере ниже).

Пример:

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

До 10

В этом примере мы используем Tensorflow для подсчета до 10. Да, это полный избыток, но это хороший пример, чтобы показать абсолютную минимальную настройку, необходимую для использования 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)

Важно понять, что состояние, одно, дополнение и обновление фактически не содержат значений. Вместо этого они являются ссылками на объекты Tensorflow. Конечный результат не является состоянием , но вместо этого извлекается с помощью Tensorflow для его оценки с использованием sess.run (state)

Этот пример приведен из https://github.com/panchishin/learn-to-tensorflow . Там есть еще несколько примеров и хороший учебный план для ознакомления с манипуляцией графом Tensorflow в python.