Автор оригинала: Guest Contributor.
Вступление
Если вы инженер по машинному обучению, специалист по обработке данных или любитель время от времени разрабатывать модели машинного обучения просто для удовольствия, то очень вероятно, что вы знакомы с Tensorflow.
Tensorflow-это бесплатный фреймворк с открытым исходным кодом, разработанный командой Google Brain и написанный на Python, C++ и CUDA. Он используется для разработки, тестирования и развертывания моделей машинного обучения.
Изначально Tensoflow не имел полной поддержки нескольких платформ и языков программирования, и он был не очень быстрым и эффективным для обучения моделей машинного обучения, но со временем и после нескольких обновлений Tensorflow теперь рассматривается как платформа для разработки, обучения и развертывания моделей машинного обучения.
Tensorflow 1.x
Tensorflow 1.x также был огромным скачком для этой структуры. Он ввел множество новых функций, улучшил производительность и внес вклад с открытым исходным кодом. Он представил высокоуровневый API для TensorFlow, что позволило очень легко создавать прототипы в кратчайшие сроки.
Он был сделан совместимым с Керасом. Но главное, что раздражало разработчиков, – это то, что им не хотелось пользоваться простотой Python при использовании TensorFlow.
В TensorFlow каждая модель представлена в виде графа, а узлы представляют вычисления в графе. Это пример “Символического программирования” и в то время как Python является “Императивным программированием” Языком.
Я не буду вдаваться в подробности, поскольку это выходит за рамки данной статьи. Но дело здесь в том, что с выпуском PyTorch (который во многом ориентирован на императивное программирование и использует преимущества динамического поведения Python) новички и ученые-исследователи обнаружили, что PyTorch легче понять и изучить, чем Tensorflow, и в мгновение ока PyTorch начал набирать популярность.
Каждый разработчик Tensorflow требовал того же от Tensorflow и команды Google Brain. Кроме того, TensorFlow 1.x прошел большую разработку, в результате которой появилось множество API, т. е. tf.layers, tf.contrib.layers, tf.keras и у разработчиков было много вариантов на выбор, что приводило к конфликтам.
Анонс Tensorflow 2.0
Было совершенно очевидно, что команда Tensorflow должна была решить эти проблемы, поэтому они объявили Tensorflow 2.0.
Это был огромный шаг, потому что для решения всех проблем им пришлось внести огромные изменения. Многие люди сталкивались с другим опытом обучения, но улучшения сделали его достойным повторного изучения.
На этапе обучения мы знакомимся с tf.data и наборами данных, которые позволяют нам легко импортировать и обрабатывать данные. Затем мы познакомимся с распределенным обучением на нескольких процессорах, графических процессорах и процессорах. Для сериализации мы можем использовать Сохраненную модель либо для развертывания в TensorFlow Hub, либо для таких сервисов, как TensorFlow Serving, TensorFlow Lite или TensorFlow.JS:
Кредит: Кредит:
Что нового в Tensorflow 2.0
Вот краткий обзор наиболее важных обновлений, которые пришли с Tensorflow 2.
1. Развертывание моделей на нескольких платформах
Tensorflow всегда очень хорошо подходил для производства, но Tensorflow 2 улучшил совместимость и четность на нескольких платформах.
Он представил новую платформу поддержки формата Saved Model , которая позволяет нам сохранять модели Tensorflow. Новизна здесь заключается в том, что вы можете развернуть сохраненную модель на любой платформе, то есть на мобильных или IoT-устройствах с помощью Tensorflow Lite или Node.js с Tensorflow.js . Кроме того, вы можете использовать в производственных средах Tensorflow Serving .
Давайте посмотрим, как вы можете сохранить скомпилированную модель:
import os
import tensorflow as tf
# Building the Model
model = tf.keras.Sequential([
tf.keras.layers.Dense(5,actiavtion='relu',input_shape=(16,)),
tf.keras.layers.Dense(1,activation='sigmoid')])
# Compiling the Model
model.compile(loss='binary_crossentropy',optimizer='adam')
# Saving the Model
save_path = path + "/version_number/"
save_path = os.path.join
tf.saved_model.save(model, save_path)
И вот вы идете. Теперь вы можете развернуть его с помощью любой из вышеупомянутых служб.
2. Нетерпеливое Исполнение
До Tensorflow 2 вам нужно было создать сеанс для запуска вашей модели. На самом деле, если вы хотите напечатать значение переменной только для отладки, вам сначала нужно создать сеанс, а затем написать инструкцию print внутри этого сеанса.
Вы должны были создать медленные и бесполезные заполнители для подачи входных данных в модель. В принципе, в Tensorflow 1.x вы сначала построите весь граф, а затем запустите его, в отличие от построения его во время выполнения.
Это казалось статичным и неуклюжим, особенно в отличие от питча, который позволял пользователям создавать динамические графики во время выполнения.
К счастью, это было обновлено в Tensorflow 2.0, который познакомил нас с нетерпеливым исполнением . Давайте посмотрим, как мы построили бы график в Tensorflow 1.x vs 2.0:
import tensorflow as tf """Creating the Graph""" # Tensorflow 1.x # Defining two Tensorflow variables a = tf.Variable(4) b = tf.Variable(5) result = tf.multiply(a,b)
Теперь, чтобы получить доступ к переменной result , нам придется выполнить график в сеансе:
# Creating a session
with tf.Session() as sess:
# Initializing all the Variables
sess.run(tf.global_variables_initializer())
print(sess.run(result))
Теперь, вместо этого, мы можем просто напрямую получить к ним доступ:
import tensorflow as tf # Tensorflow 2.0 a = tf.Variable(4) b = tf.Variable(5) # No need to create a session print(float(a*b))
3. Интеграция Keras с Tensorflow
Keras-это нейронная сеть и API глубокого обучения, построенная поверх Tensorflow.
Большинство людей начинают с Keras, прежде чем перейти к Tensorflow или PyTorch. Он был разработан для быстрого экспериментирования с глубокими нейронными сетями и поэтому проще.
До Tensorflow 2.0 он поддерживался библиотекой, но не был интегрирован . Теперь это официально API высокого уровня. Нет необходимости устанавливать его явно, он поставляется вместе с Tensorflow и теперь доступен через tf.keras .
Это , следовательно, приводит к очистке API и удалению tf.contrib.layers | tf.layers и т. Д. tf.keras теперь является API go-to. Оба tf.contrib.layers и tf.layers делали одно и то же. А с tf.keras будет тройная избыточность , так как он содержит tf.keras.слои модуль.
Команда также предоставила руководство для обновления вашего кода с Tensorflow 1.x до Tensorflow 2.0, поскольку многие старые пакеты теперь устарели.
4. tf.функция декоратора
Это также одна из самых интересных особенностей Tensorflow 2. @tf.function decorator позволяет вашим функциям Python автоматически преобразовываться в Графики тензорного потока .
Вы все еще можете иметь все преимущества графического исполнения и избавиться от изрядного сессионного программирования. Применяя @tf.function decorator к такой функции, как:
@tf.function def multiply(a, b): return a * b multiply(tf.ones([2, 2]), tf.ones([2, 2]))
Если вам интересно, это автоматически дополняется Автографом . Он генерирует график, который имеет те же эффекты, что и функция, которую мы украсили.
5. Обучение с использованием распределенных вычислений
Tensorflow 2.0 поставляется с улучшенной производительностью для обучения с использованием графических процессоров. По словам команды, эта версия в 3 раза быстрее, чем Tensorflow 1.x.
И на данный момент Tensorflow также может работать с TPUs. Фактически, вы можете работать с несколькими процессорами и графическими процессорами в рамках подхода распределенных вычислений.
Подробнее об этом вы можете прочитать в официальном руководстве .
6. tf.данные и наборы данных
С помощью tf.data теперь очень легко создавать пользовательские конвейеры данных. Нет необходимости использовать feed_dict . tf.data поддерживает множество типов входных форматов, таких как текст, изображения, видео, временные ряды и многое другое.
Он обеспечивает очень чистые и эффективные входные трубопроводы. Например, скажем, мы хотим импортировать текстовый файл с некоторыми словами, которые будут предварительно обработаны и использованы в модели. Давайте сделаем классическую предварительную обработку для большинства проблем НЛП.
Давайте сначала прочитаем файл, переведем все слова в нижний регистр и разделим их на список:
import numpy as np text_file = "file.txt" text = open(text_file,'r').read() text = text.lower() text = text.split()
Затем мы захотим отбросить все повторяющиеся слова. Это легко сделать , упаковав их в Набор , преобразовав его в Список и отсортировав:
words = sorted(list(set(text)))
Теперь, когда мы рассортировали уникальные слова, мы составим из них словарь. Каждому слову будет присвоен уникальный цифровой идентификатор:
vocab_to_int = {word:index for index, word in enumerate(words)}
int_to_vocab = np.array(words)
Теперь, чтобы преобразовать наш массив целых чисел, представляющих слова, в набор данных Tensorflow, мы будем использовать функцию form_tensor_slices () , предоставляемую tf.data.Набор данных :
words_dataset = tf.data.Dataset.from_tensor_slices(words_as_int)
Теперь мы можем выполнять операции с этим набором данных, например, разбивать его на более мелкие последовательности:
seq_len = 50 sequences = words_dataset.batch(seq_len+1,drop_remainder=True)
Теперь при обучении мы можем легко получать пакеты из объекта Dataset:
for (batch_n,inp) in enumerate(dataset):
Кроме того, вы можете напрямую загрузить уже существующие наборы данных в объекты Dataset :
import tensorflow_datasets as tfds
mnist_data = tfds.load("mnist")
mnist_train, mnist_test = mnist_data["train"], mnist_data["test"]
7. тф.керас.Модель
Любимая новинка-это определение ваших собственных пользовательских моделей с помощью подклассов keras.Модель класс.
Взяв подсказку от PyTorch, которая позволяет разработчикам создавать модели с использованием пользовательских классов (настраивая классы , образующие Слой , и таким образом изменяя структуру модели) – Tensorflow 2.0, через Keras, позволяет нам также определять пользовательские модели.
Давайте создадим Последовательную модель, как вы могли бы использовать Tensorflow 1:
# Creating a Model model = tf.keras.Sequential([ tf.keras.layers.Dense(512,activation='relu',input_shape=(784,)), tf.keras.layers.Dropout(0.2), tf.keras.layers.Dense(512,activation='relu'), tf.keras.layers.Dropout(0.2), tf.keras.layers.Dense(10,activation='softmax') ])
Теперь, вместо использования модели Sequential , давайте создадим нашу собственную модель, подклассировав keras.Модель класс:
# Creating a Model
class mnist_model(tf.keras.Model):
def __init__(self):
super(mnist_model,self).__init__()
self.dense1 = tf.keras.layers.Dense(512)
self.drop1 = tf.keras.layers.Dropout(0.2)
self.dense2 = tf.keras.layers.Dense(512)
self.drop2 = tf.keras.layers.Dropout(0.2)
self.dense3 = tf.keras.layers.Dense(10)
def call(self,x):
x = tf.nn.relu(self.dense1(x))
x = self.drop1(x)
x = tf.nn.relu(self.dense2(x))
x = self.drop2(x)
x = tf.nn.softmax(self.dense3(x))
return x
Мы фактически создали одну и ту же модель здесь, хотя этот подход позволяет нам полностью настраивать и создавать модели в соответствии с нашими потребностями.
8. tf.Градиентная лента
tf.Gradient Tape позволяет автоматически вычислять градиенты. Это полезно при использовании пользовательских циклов обучения.
Вы можете обучить свою модель с помощью пользовательских обучающих циклов, а не вызывать model.fit . Это дает вам больше контроля над тренировочным процессом, если вы хотите его настроить.
Сопряжение пользовательских обучающих петель, доступных с помощью tf.Gradient Tape , с пользовательскими моделями, доступными с помощью keras.Модель дает вам контроль над моделями и обучением, которых у вас никогда раньше не было.
Они быстро стали очень любимыми чертами в сообществе. Вот как вы можете создать пользовательскую модель с оформленными функциями и пользовательским циклом обучения:
"""Note: We'll be using the model created in the previous section."""
# Creating the model
model = mnist_model()
# Defining the optimizer and the loss
optimizer = tf.keras.optimizers.Adam(learning_rate=0.001)
loss_object = tf.keras.losses.CategoricalCrossentropy(from_logits=False)
@tf.function
def step(model,x,y):
"""
model: in this case the mnist_model
x: input data in batches
y: True labels """
# Use GradientTape to monitor trainable variables
with tf.GradientTape() as tape:
# Computing predictions
predictions = model(x)
# Calculating Loss
loss = loss_object(y,predictions)
# Extracting all the trainable variables
trainable_variables = model.trainable_variables()
# Computing derivative of loss w.r.t variables/weights
gradients = tape.gradient(loss,trainable_variables)
# Updating the weights
optimizer.apply_gradients(zip(gradients,trainable_variables))
return loss
Теперь вы можете просто вызвать функцию step () , передавая модель и обучающие данные пакетами с помощью цикла.
Вывод
С появлением Tensorflow 2.0 многие неудачи были переработаны. От расширения разнообразия системной поддержки и новых сервисов до пользовательских моделей и обучающих циклов – Tensorflow 2.0 также представил новый опыт обучения для опытных практиков.