9 вещей, которые вы должны знать о TensorFlow

Введение.

Серия моих статей является расширенной версией того, что я хотел увидеть когда только решил познакомиться с нейронными сетями. Он рассчитан в первую очередь на программистов, желающих познакомится с tensorflow и нейронными сетями. Уж не знаю к счастью или к сожалению, но эта тема настолько обширна, что даже мало-мальски информативное описание требует большого объёма текста. Поэтому, я решил разделить повествование на 4 части:

1. Введение, знакомство с tensorflow и базовыми алгоритмами (эта статья)
2. Первые нейронные сети
3. Свёрточные нейронные сети
4. Рекуррентные нейронные сети

Изложенная ниже первая часть нацелена на то, чтобы объяснить азы работы с tensorflow и попутно рассказать, как машинное обучение работает впринципе, на примере tensorfolw. Во второй части мы наконец начнём проектировать и обучать нейронные сети, в т.ч. многослойные и обратим внимание на некоторые нюансы подготовки обучающих данных и выбора гиперпараметров.

Поскольку свёрточные сети сейчас пользуются очень большой популярность, то третья часть выделена для подробного объяснения их работы. Ну, и в заключительной части планируется рассказ о рекуррентных моделях, на мой взгляд, — это самая сложная и интересная тема.

# 9 вам не нужно начинать с нуля

Вы знаете, что не очень интересно начать машинное обучение? Пустая новая страница в вашем редакторе и никакого образцового код примера на километры вокруг. С TensorFlow Hub вы можете использовать более эффективную версию проверенной временем традиции одалживать чужой код и называть его своим собственным (иначе известной как профессиональная разработка программного обеспечения).

TensorFlow Hub – это хранилище для повторно используемых предварительно обучаемых компонентов моделей машинного обучения, упакованных для однократного повторного использования. Угощайтесь!

# 1 это мощная система машинного обучения

TensorFlow – это система машинного обучения, которая может стать вашим новым лучшим другом, если у вас много данных и желание постичь новейшее достижение в сфере искусственного интеллекта: глубокое обучение. Нейронные сети. Большие.

# 2 причудливый подход является необязательным

Я сама не своя от TensorFlow Eager.

Если вы пробовали TensorFlow в прежние времена и с воплями убежали от него, потому что вам приходилось кодить как ученому или как инопланетянину, а не как разработчику, возвращаааайтееесь!

Мгновенное исполнение (eager execution) в TensorFlow позволяет вам взаимодействовать с ним как настоящий программист на Python: вам дается вся непосредственность написания кода и отладки его строка за строкой, а не напряженное построение графиков. Я сама раньше была ученым (и, вполне возможно, инопланетянином), но я была в восторге от мгновенного исполнение TF когда он вышел. Угождает мгновенно!

# 3 вы можете строить нейронные сети по очереди

Keras TensorFlow = упрощенная конструкция нейронной сети!

Keras – это само удобство и простота прототипирования, TensorFlow они были давно нужны. Если вам нравится объектно-ориентированное мышление, и вам нравится строить нейронные сети по одному слою за раз, вам понравится tf.keras. В немногих строках кода ниже мы создали последовательную нейронную сеть со стандартными свистелками и пыхтелками в виде выпадающего списка (как нибудь я впаду в лирическое настроение и выдам вам свою метафору о выпадающих списках, в ней буду степлеры и грипп).

О, вам нравятся головоломки, не так ли? Терпение. Не думайте слишком много о степлерах.

# 4 это не только python

Хорошо, вы жаловались на одержимость TensorFlow Питоном уже некоторое время. Хорошие новости! TensorFlow теперь не только для питонщиков. Теперь он работает на многих языках, от R до Swift до JavaScript.

# 5 вы можете делать все в браузере

Говоря о JavaScript, вы можете обучать и выполнять модели в браузере с помощью TensorFlow.js. Поботайте с классными демками я подожду тут вашего возвращения.

Оценка человеческой позы в реальном времени в браузере с помощью TensorFlow.js. Включите камеру для демонстрации здесь. Или не вставайте со стула. ¯ _ (ツ) _ / ¯ Вам решать.

# 6 есть lite версия для маленьких устройств

Так и не отнесли свой старинный комп в музей? Есть тостер? (Что-нибудь такое же бесполезное?) TensorFlow Lite позволяет исполнение модели на различных устройствах, в том числе мобильниках и интернета вещей, что дает вам более чем 3-кратное ускорение вывода по сравнению с оригинальным TensorFlow.

1,6 секунды для вычисления? Да! Банан с вероятностью более 97%? Да! Туалетная бумага? Ну, я была в нескольких странах, где лист бумаги, типа того, который Лоуренс держит в руках, считаются за туалетную бумагу.

# 7 специализированное оборудование улучшилось

Если вы устали ждать, пока ваш процессор завершит работу с вашими данными, чтобы обучить вашу нейронную сеть, вы можете теперь использовать свои аппаратные средства, специально разработанные для работы с облачными TPU. Т — значит тензор.

# 8 новые потоки данных значительно улучшены

Что вы делаете с numpy? Если вы хотите сделать это в TensorFlow, но злитесь и бросаете, пространство имен tf.data теперь делает вашу обработку ввода в TensorFlow более выразительной и эффективной. tf.data дает вам быстрые, гибкие и простые в использовании конвейеры данных, синхронизированные с обучением.

Generative deep learning with tensorflow

Tensorboard

Крайне полезная система в составе TF — web-dashboard, который позволяет собирать статистику из дампов и логов и наблюдать, что же всё-таки происходит во время вычислений. Крайне удобно то, что дашборд работает на веб-сервере и можно, например, запустив tensorboard на удаленной машине в облаке, наблюдать происходящее у себя в окне браузера.

Tensorboard умеет:

1. Рисовать граф вычислений.
   Граф вычислений стоит посмотреть хотя бы для самопроверки, чтобы убедиться в том, что собралось и считается именно то, что планировалось, и при кодировании не допущено ошибок.
2. Показывать статистику по переменным.
   Можно собирать вообще любую статистику.
3. Есть средство для анализа многомерных данных (например, эмбеддингов).
   Для этого в дашборде встроены PCA и t-SNE, с которыми можно попробовать рассмотреть данные в 2 и 3 измерениях.
4. Гистограммы.
   Можно строить гистограммы распределений выходов слоев сетей и поведения переменных.

Обратная сторона медали — чтобы статистика попадала в дашборд, её нужно сохранять в логи (в формате protobuf) с помощью специального API. API не очень сложный, сгруппирован в tf.summary. Для сбора статистики нужно будет отдельно зарегистрировать интересующие переменные с помощью специальных функций и потом отдельно сохранить всё в лог.

Еще при использовании Tensorboard важно также не забывать про параметр name у переменных. Имя, которое будет присвоено переменной, потом будет использоваться для отрисовки графа, выбора в пользовательском интерфейсе дашборда, в общем, везде. Для небольших графов это не критично, но с ростом сложности задачи могут возникнуть проблемы с пониманием происходящего.

Есть несколько типов функций, которые сохраняют данные переменных различным образом:

tf.summary.histogram("layer_output", w_h)

Данная функция позволит собрать гистограмму для выхода слоя и примерно оценить динамику изменений при обучении. Функция tf.summary.scalar(“accuracy”, learning_rate) будет сохранять число. Еще можно сохранять аудио и картинки.

Для сохранения логов нужно чуть больше: сначала нужно создать FileWriter для записи файла.

writer = tf.summary.FileWriter("./logs/nn_logs", sess.graph) # for 1.0
merged = tf.summary.merge_all()

И объединить всю статистику в одном объекте.

Теперь нужно вот этот объект merged передать на выполнение в сессию и потом с помощью метода FileWriter добавить новые данные, полученные от сессии.

Базовые элементы tf

С помощью «Hello, world» убедимся, что всё установилось правильно:

Граф вычислений

Работа c TF строится вокруг построения и выполнения графа вычислений. Граф вычислений — это конструкция, которая описывает то, каким образом будут проводиться вычисления. В классическом императивном программировании мы пишем код, который выполняется построчно.

В TF привычный императивный подход к программированию необходим только для каких-то вспомогательных целей. Основа TF — это создание структуры, задающей порядок вычислений. Программы естественным образом структурируются на две части — составление графа вычислений и выполнение вычислений в созданных структурах.

Граф вычислений в TF по смыслу не отличается от такового в Theano. В предыдущей статье цикла дано отличное описание этой сущности.

В TF граф состоит из плейсхолдеров, переменных и операций. Из этих элементов можно собрать граф, в котором будут вычисляться тензоры. Тензоры — многомерные массивы, они служат «топливом» для графа. Тензором может быть как отдельное число, вектор признаков из решаемой задачи или изображение, так и целый батч описаний объектов или массив из изображений.

Вместо одного объекта мы можем передать в граф массив объектов и для него будет вычислен массив ответов. Работа TF с тензорами похожа на то, как обрабатывает массивы numpy, в функциях которого можно указать ось массива, относительно которой будет выполняться вычисление.

Документация

Документации и примеров очень много.

Лучше всего ориентироваться на официальную документацию — из-за быстрого развития и частой смены api, в интернете очень много туториалов и скриптов, которые ориентированы на старые версии (ну как старые… полугодовой давности) со старым API, они не будут работать с последними версиями фреймворка.

Знакомство с tensorflow

Принципы работы с tensorflow достаточно просты. Мы должны составить граф операций, затем передать в этот граф данные и дать команду произвести вычисления. На картинке ниже вы можете увидеть 3 примера таких графов:

Граф слева содержит только одну вершину, представляющую константу со значением 1. Здесь и далее по тексту, в таких иллюстрациях, кругами с серой штриховкой будут обозначаться вершины с константами, а без штриховки вершины с операциями. Центральный граф иллюстрирует операцию сложения.

Если мы попросим tensorflow вычислить значение вершины, представляющей операцию сложения, то он вычислит значения направленных в него рёбер графа и просуммирует их(т.е. будет возвращено 3). На правом же графе у нас две вершины с операциями — вычитание и возведение в квадрат.

Пустой граф можно создать функцией tf.Graph(), кроме того граф по-умолчанию создаётся при подключении библиотеки и если вы не будете явно указывать граф, то будет использоваться именно он. В примере ниже показано, как можно создать две константы в двух разных графах.

import tensorflow as tf # в дальнейшем эта строка будет опускаться

# сохраняем граф по-умолчанию в переменную
default_graph = tf.get_default_graph()
# объявляем константу в графе по-умолчанию
c1 = tf.constant(1.0)

# создаём пустой граф
second_graph = tf.Graph()
with second_graph.as_default():
    # в этом блоке мы работаем во втором графе
    c2 = tf.constant(101.0)

print(c2.graph is second_graph, c1.graph is second_graph) # True, False
print(c2.graph is default_graph, c1.graph is default_graph) # False, True

Передача данных и выполнение операций происходят в сессиях. Запуск сессии осуществляется вызовом tf.Session, а её закрытие вызовом метода close на объекте сессии. Можно использовать конструкцию with, которая автоматический закрывает сессию:

default_graph = tf.get_default_graph()

c1 = tf.constant(1.0)

second_graph = tf.Graph()
with second_graph.as_default():
    c2 = tf.constant(101.0)

session = tf.Session() # открываем сессию на графе по-умолчанию
print(c1.eval(session=session))
# print(c2.eval(session=session)) # так нельзя, не тот граф
session.close()

# тоже самое:
with tf.Session() as session:
    print(c1.eval()) # не нужно передавать сессию в метод eval

# используем другой граф:
with tf.Session(graph=second_graph) as session:
    print(c2.eval()) # не нужно передавать сессию в метод eval

#Вывод:
# 1.0
# 1.0
# 101.0

Надеюсь про графы и сессии в общих чертах ясно, подробно их функционал тут разбираться не будет, тем кто хочет досконально разобрать эти механизмы стоит ознакомится непосредственно с документацией. А далее мы переходим к построению графов. В предыдущих примерах в граф добавлялись константы и настало время узнать что это такое и чем они отличаются от placeholder’ов и переменных. В примере ниже построен более сложный граф, представляющий выражение

Машинное обучение

Разберем для начала уже не раз упоминавшуюся здесь классическую линейную регрессию, с детальным описанием которой можно ознакомиться тут, однако для обучения будем использовать метод градиентного спуска.

Куда же без этой картинки

Начну с линейной регрессии, а потом добавлю полиномиальные признаки.Данные будут синтетические — синус с нормальным шумом:

x = np.linspace(0, 10, 1000)
y = np.sin(x)   np.random.normal(size=len(x))

Выглядеть они будут примерно так:

Я еще разобью выборку на обучающую и контрольную в пропорции 70/30, но этот и некоторые другие рутинные моменты оставлю в полном исходнике, ссылка на который будет чуть ниже.

Сначала построим простую линейную регрессию.

x_ = tf.placeholder(name="input", shape=[None, 1], dtype = tf.float32)
y_ = tf.placeholder(name= "output", shape=[None, 1], dtype = tf.float32)

model_output = tf.Variable(tf.random_normal([1]), name='bias')   tf.Variable(tf.random_normal([1]), name='k') * x_

Тут я создаю два плейсхолдера для признака и ответа и формулу вида
Нюанс — в плейсхолдере параметр формы (shape) содержит None. Размерность плейсхолдера означает, что плейсходер потребляет двумерные тензоры, но по одной из осей размер тензора не определен и может быть любым. Это сделано для того, чтобы пользователь мог передавать значения в граф сразу целыми батчами. Такие специфические размерности называют динамическими, TF рассчитывает действительную размерность связанных элементов во время выполнения графа.Плейсхолдер для признака используется в формуле, а вот плейсхолдер для ответа я подставлю в функцию потерь

loss = tf.reduce_mean(tf.pow(y_ - model_output, 2)) # функция потерь

В TF реализован десяток методов оптимизации. Мы будем использовать классический градиентный спуск, указав ему в параметрах скорость обучения.

Метод minimize создаст нам операцию, вычисление которой будет минимизировать функцию потерь.

gd = tf.train.GradientDescentOptimizer(0.001) #оптимизатор
train_step = gd.minimize(loss)

Инициализация переменных — она необходима для дальнейших вычислений:

Многослойный перцептрон

Разберем каноничный пример с запоминанием функции xor, которую линейная модель не может усвоить из-за невозможности линейного разделения пространства признаков.

Многослойные сети усваивают функцию из-за того, что делают неявное преобразование пространства признаков в разделимое или же (в зависимости от реализации) делают нелинейное разбиение этого пространства. Мы реализуем первый вариант — создадим двухслойный перцептрон с нелинейной активацией слоев.

В качестве элемента нелинейности будем использовать функцию relu.

Определим структуру сети:

x_ = tf.placeholder(name="input", shape=[None, 2], dtype=tf.float32)
y_ = tf.placeholder(name= "output", shape=[None, 1], dtype=tf.float32)
hidden_neurons = 15
w1 = tf.Variable(tf.random_uniform(shape=[2, hidden_neurons ]))
b1 = tf.Variable(tf.constant(value=0.0, shape=[hidden_neurons ], dtype=tf.float32))
layer1 = tf.nn.relu(tf.add(tf.matmul(x_, w1), b1))
w2 = tf.Variable(tf.random_uniform(shape=[hidden_neurons ,1]))
b2 =  tf.Variable(tf.constant(value=0.0, shape=[1], dtype=tf.float32))
nn_output = tf.nn.relu(tf.add(tf.matmul(layer1, w2), b2))

В отличие от keras и других более высокоуровневых библиотек, TF, подобно Theano предполагает детальное определение каждого слоя как совокупности некоторых арифметических операций. Это верно не для всех видов слоёв, например, сверточные и dropout-слои определяются одной функцией, в то время как обычный полносвязный слой представляет собой объявление не только переменных для весов и сдвигов, но и самих операций (перемножение весов с выходом предыдущего слоя, добавление сдвига, применение функции активации).

Разумеется, довольно часто всё это оборачивается в подобную функцию:

def fully_connected(input_layer, weights, biases):
    layer = tf.add(tf.matmul(input_layer, weights), biases)
    return(tf.nn.relu(layer))

При этом по моему собственному опыту объявление и инициализацию переменных удобнее оставлять снаружи: иногда требуется использовать их еще где-нибудь внутри графа (типичный пример — сиамские нейронные сети с общими весами) или же просто иметь доступ для простого логирования в файл и вывода текущих значений, а tensorboard по каким-то причинам пользоваться не хочется.

Используем элементарную функцию потерь:

gd = tf.train.GradientDescentOptimizer(0.001)
loss =  tf.reduce_mean(tf.square(nn_output - y_))
train_step = gd.minimize(loss)

и обучим:

Первый обучающий алгоритм

Чтобы tensorflow мог обучать модель нам нужно добавить ещё 2 вещи: функцию потерь и сам алгоритм оптимизации.

Функция потерь — это функция, которая принимает значение функции предсказанное моделью и фактическое значение, а возвращает расстояние между ними(будем называть это значение ошибкой). Например, если мы предсказываем вещественное значение, то в качестве функции потерь можно взять квадрат разности аргументов или модуль их разности.

Если у нас задача классификации, то функция потерь может возвращать 0 при правильном ответе и 1 при ошибках. Грубо говоря, функция потерь должна вернуть неотрицательное вещественное число и оно должно быть тем больше, чем сильнее модель ошибается и тогда задача обучения модели сведётся к минимизации. И хотя последнее предложение не совсем корректно, зато в полной мере отражает идею машинного обучения.

Из методов оптимизации мы рассмотрим только классический градиентный спуск. Про него написано уже очень много, поэтому я не буду разбирать его «по кирпичику» и вдаваться в детали(материал и так выходит не маленький). Однако его нужно понимать, поэтому постараюсь коротко и наглядно объяснить метод при помощи визуализаций. Ниже представлены 2 варианта одного и того же графика —

Суть метода в том, чтобы идти в направлении противоположном градиенту функции в текущей точке. Градиент — это вектор, который указывает в направлении наибольшего роста функции. Математически это вектор из производных по всем аргументам —

. Функция взята наугад и вычисления на ней мы проводить не станем, для практики у нас есть более простой пример, для начала посмотрите на визуализацию нескольких шагов алгоритма:

Отдельно стоит сказать о скорости с которой нужно двигаться к минимуму(применительно к задаче машинного обучения, это будет называться скоростью обучения). Для получения первых результатов, нам достаточно будет подобрать фиксированную скорость. Однако часто бывает хорошей идеей понижать её по ходу выполнения алгоритма, т.е. двигаться всё меньшими и меньшими шажками. Пока этого достаточно, более подробно будем разбирать метод с практикой, по мере необходимости.

В следующем примере мы попытаемся восстановить значение функции

Простейшие вычисления.

В качестве примера создадим и вычислим несколько выражений.

Сессии

Вычислительные графы выполняются в сессиях. Объект сессии (tf.Session) скрывает в себе контекст выполнения графа — необходимые ресурсы, вспомогательные классы, адресные пространства.Существует два типа сессий — обычные, которые реализованы в tf.

Session и интерактивные (tf.InteractiveSession). Разница между ними в том, что интерактивная сессия больше подходит для выполнения в консоли и сразу определяет себя как сессия по умолчанию. Основной эффект — объект сессии не нужно передавать в функции вычисления как параметр.

Далее в посте будут появляться стандартные для TF картинки с изображениями графов, сгенерированные встроенной утилитой под названием Tensorboard. Обозначения там вот такие:

Сохранение и загрузка графов

Мы получили модель и было бы неплохо её сохранить. В TF всё достаточно просто — в API есть специальный объект-сериализатор, который делает две вещи:

1. Сохраняет текущий граф, его состояние и значения переменных в файл;
2. Читает всё то же самое из файла.

Вот всё что нужно — это создать этот объект:

saver = tf.train.Saver()

Сохранение состояния текущей сессии производится с помощью метода save:

saver.save(sess, "checkpoint_dir/model.ckpt")

Уже как-то принято, что сохраненные состояния модели называют чекпойнтами, отсюда название папок и расширения файлов. Восстановление производится с помощью метода restore:

ckpt = tf.train.get_checkpoint_state(ckpt_dir)
if ckpt and ckpt.model_checkpoint_path:
    print(ckpt.model_checkpoint_path)
    saver.restore(session, ckpt.model_checkpoint_path)

Сначала с помощью специальной функции получаем состояние чекпойнта (если вдруг в целевой директории нет сохраненной модели, функция вернет None). По умолчанию функция ищет файл checkpoint, но это поведение можно изменить с помощью параметра. После этого restore восстанавливает состояние графа.

Тензоры, операции и переменные

Создадим, к примеру, тензор, заполненный нулями.

zeros_tensor = tf.zeros([3, 3])

Вообще, API в TF будет во многом напоминать numpy и tf.zeros() — далеко не единственная функция, имеющая прямой аналог в numpy. Чтобы увидеть значение тензора, его нужно выполнить. Подробнее о выполнении графа чуть ниже, пока что обойдемся тем, что выведем значение тензора и сам тензор.

print(zeros_tensor.eval())
print(zeros_tensor)
>>> [[ 0.  0.  0.]
 [ 0.  0.  0.]
 [ 0.  0.  0.]]
>>> Tensor("zeros_1:0", shape=(3, 3), dtype=float32)

Различие между строчками состоит в том, что в первой строке происходит вычисление тензора, а во второй строке мы просто печатаем представление объекта.

Описание тензора показывает нам несколько важных вещей:

1. У тензоров есть имена. У нашего оно zeros:0
2. Существует понятие формы тензора, оно похоже на размерность массива из numpy.
3. Тензоры типизированы и типы для них задаются из библиотеки.

Над тензорами можно совершать разнообразные операции:

Управление ресурсами

Довольно часто мир бывает несправедлив, и задача может не помещаться полностью в одно устройство. Или же менеджмент купил всего одну Tesla, и разработчики периодически вступают в конфликты из-за занятой карточки. В TF на такие случаи есть механизмы управления вычислениями.

with tf.device('/cpu:0'):
    a = ...    

В этом примере переменная а отправится на процессор.

Еще можно передать в сессию конфигурационный объект, с помощью которого можно изменять проведение вычислений графа. Выглядит это примерно так:

cfg = tf.ConfigProto()
sess = tf.Session(config=cfg)

В конфиге первым делом можно включить параметр log_device_placement, чтобы понимать, в какое вычислительное устройство отправилось вычисление той или иной части графа.

Допустим, в команде разработчиков можно договориться об ограничении потребления памяти GPU. Сделать это можно с помощью такого кода:

gpu_opts = tf.GPUOptions(per_process_gpu_memory_fraction = 0.25)
sess = tf.Session(config=tf.ConfigProto(gpu_options = gpu_opts))

В такой конфигурации сессия не будет потреблять более четверти памяти GPU, а это значит, что можно одновременно запустить расчеты еще нескольких моделей, а еще можно запустить модель считаться на CPU, но проще всего включить параметр allow_soft_placement, чтобы TF решал эти проблемы сам.

Для этой части API документация еще довольно фрагментарна и некоторые ссылки ведут сразу на гитхаб в исходники конфигурационных классов. Часть свойств там отмечена как устаревшая, другая часть — как экспериментальная, поэтому тут будет нужна аккуратность.

Установка

TF устанавливается стандартно через python pip. Есть нюанс: существуют отдельные алгоритмы установки для работы на CPU и на видеокартах.

В случае с CPU всё просто: нужно поставить из pip пакет под названием tensorflow.

Во втором случае нужно:

1. проверить совместимость с видеокартой. Параметр CUDA Compute Capability должен быть больше 3.0, найти его для своей видеокарты можно тут
2. Установить CUDA Toolkit восьмой версии
3. Установить cuDNN версии 5.1
4. Установить из pip пакет tensorflow-gpu

Впрочем, документация утверждает, что поддерживаются и более ранние версии CUDA Toolkit и cuDNN, но рекомендует устанавливать версии, указанные выше.

Разработчики рекомендуют устанавливать TF в отдельную среду с virtualenv, чтобы избежать возможные проблемы с версионированием и зависимостями.

Еще один вариант установки — Docker. По умолчанию из контейнера будет работать только CPU-версия, но если использовать специальный nvidia docker, то можно использовать и GPU.

Сам я не пробовал, но говорят, что TF работает даже с Windows. Установка проводится через тот же pip и, говорят, работает без проблем.

Я пропускаю процесс сборки из исходников, однако и такой вариант может иметь смысл. Дело в том, что пакет из репозитория собирается без поддержки SSE и прочих плюшек. В последних версиях TF проверяет наличие таких плюшек и сообщает, что из исходников он будет работать быстрее.

Подробно процесс установки описан тут.

Установка tensorflow

Хотя описание процесса установки tensorflow и не является целью статьи, я вкратце опишу процесс установки cpu-версии для 64-разрядных windows систем и дополнений, используемых далее в тексте.

1. Скачиваем и устанавливаем python версии 3.5.* (последняя версия на момент написания 3.5.3). В процессе установки установите галочку в пункте «Add Python 3.5 to PATH». Если же вы не хотите добавлять директории этой версию python в переменные окружения, например из-за активного использования другой версии интерпретатора, то дальнейшие шаги вы должны выполнять из папки Scripts, указанной версии дистрибутива(cd «путь к python 3.5/Scripts»).
2. После установки запустите командную строку (именно после установки, иначе директории python не попадут в переменную среды PATH).
3. Далее выполните команды:
   1. обновление pip: «pip install –upgrade pip»
   2. обновление setuptools: «pip install -U pip setuptools»
   3. устнановка tensorflow 1.0.1 под CPU: «pip install –ignore-installed –upgrade ci.tensorflow.org/view/Nightly/job/nightly-win/DEVICE=cpu,OS=windows/lastSuccessfulBuild/artifact/cmake_build/tf_python/dist/tensorflow-1.0.1-cp35-cp35m-win_amd64.whl»
   4. установка matplotlib(для графиков): «pip install matplotlib»
   5. установка Jupyter: «pip install jupyter»
4. Установка завершена, для запуска Jupyter выполните команду «jupyter notebook» и в открывшейся вкладке можете открыть ipynb версию статьи (брать тут).

Ниже приведён

, если вы просто хотите быстро установить весь нужный софт, не вдаваясь в детали, то просто запустите его и следуйте инструкциям:

'получаем версию питона по-умолчанию
Function GetPythonVersion()
	On Error Resume Next
	Err.Clear
	GetPythonVersion = vbNullString
	Set WshShell = CreateObject("WScript.Shell")
	Set WshExec = WshShell.Exec("python --version")
	If Err.Number = 0 Then ' если питон вообще есть
		Set TextStream = WshExec.StdOut
		Str = vbNullString
		While Not TextStream.AtEndOfStream
			Str = Str & Trim(TextStream.ReadLine()) & vbCrLf
		Wend
		Set objRegExp = CreateObject("VBScript.RegExp")
		objRegExp.Pattern = "(d .?) "
		objRegExp.Global = True
		Set objMatches = objRegExp.Execute(Str)
		PythonVersion = "0"
		For i=0 To objMatches.Count-1 ' должно быть только одно совпадение
			PythonVersion = objMatches.Item(i).Value
		Next
		GetPythonVersion = PythonVersion
	Else
		Err.Clear
	End If
End Function

Function DownloadPython()
	Err.Clear
	Set x = CreateObject("WinHttp.WinHttpRequest.5.1")
	call x.Open("GET", "https://www.python.org/ftp/python/3.5.3/python-3.5.3-amd64-webinstall.exe", 0)
	x.Send()
	Set s = CreateObject("ADODB.Stream")
	s.Mode = 3
	s.Type = 1
	s.Open()
	s.Write(x.responseBody)
	call s.SaveToFile("python-3.5.3-amd64-webinstall.exe", 2)
	DownloadPython = "python-3.5.3-amd64-webinstall.exe"
End Function

Function InstallPython()
	InstallPython = False
	PythonVersion = GetPythonVersion()
	If Mid(PythonVersion, 1, 3)="3.5" Then
		InstallPython = True
	Else
		txt = vbNullString
		If Len(PythonVersion) > 0 Then
			txt = "Обнаружена не подходящая версия питона"
		Else
			txt = "Питон не установлен"
		End If
		If MsgBox(txt & vbCrLf & "Скачать подходящую версию?", 4) = 6 Then
			MsgBox("Не забудьте поставить галочку в пункте 'Add Python 3.5 to PATH'")
			Set WshShell = WScript.CreateObject("WScript.Shell")
			WshShell.Run DownloadPython(), 0, True
			MsgBox("установка питона завершена, запустите скрипт повторно для продолжения установки")
		End If
	End If
End Function

If InstallPython() Then
	Set WshShell = WScript.CreateObject("WScript.Shell")
	'установка tensorflow
	WshShell.Run "pip install --upgrade pip", 1, True
	WshShell.Run "pip install --ignore-installed --upgrade https://ci.tensorflow.org/view/Nightly/job/nightly-win/DEVICE=cpu,OS=windows/lastSuccessfulBuild/artifact/cmake_build/tf_python/dist/tensorflow-1.0.1-cp35-cp35m-win_amd64.whl", 1, True
	WshShell.Run "pip install -U pip setuptools", 1, True
	WshShell.Run "pip install matplotlib" , 1, True
	WshShell.Run "pip install jupyter" , 1, True
	If MsgBox("Всё готово, запустить Jupyter notebook?", 4) = 6 Then
		WshShell.Run "jupyter notebook" , 1, False
	End If
End If

Заключение

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

Автор выражает благодарность sovcharenko, Ferres и bauchgefuehl за помощь в подготовке текста.

UPD:Jupyter-ноутбук со статьей и всеми исходниками доступен тут.