Вступление

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

Tensorflow - это бесплатный фреймворк с открытым исходным кодом, разработанный Google Brain Team, написанный на 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 с tf.data и наборами данных, которые позволяют нам легко импортировать и обрабатывать данные. Затем мы познакомимся с распределенным обучением на нескольких процессорах, графических процессорах и TPU. Для сериализации мы можем использовать SavedModel для развертывания в TensorFlow Hub или в таких сервисах, как TensorFlow Serving, TensorFlow Lite или TensorFlow.JS:

{.ezlazyload}

[Кредит: blog.tensorflow.org]{.small}

Что нового в Tensorflow 2.0

Вот краткий обзор наиболее важных обновлений Tensorflow 2.

1. Развертывание моделей на нескольких платформах

Tensorflow всегда очень хорошо подходил для производства, но Tensorflow 2 улучшил совместимость и паритет на нескольких платформах.

Он представил новую платформу, поддерживающую SavedModel , которая позволяет нам сохранять модели Tensorflow. Новинка здесь в том, что вы можете развернуть сохраненную модель на любой платформе, например, на мобильных устройствах или устройствах Интернета вещей с помощью 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 вам нужно было создать сеанс для запуска вашей модели. Фактически, если вы хотите распечатать значение переменной только для отладки, вам сначала нужно было создать сеанс, а затем написать оператор печати внутри этого сеанса.

Вам приходилось создавать медленные и бесполезные заполнители для подачи входных данных в модель. По сути, в Tensorflow 1.x вы сначала должны построить весь граф, а затем запустить его, а не строить во время работы.

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

К счастью, это было переработано в 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-интерфейсом, к которому нужно перейти. И tf.contrib.layers и tf.layers делали одно и то же. А с tf.keras будет тройное резервирование, поскольку он содержит модуль tf.keras.layers

Команда также предоставила руководство по обновлению вашего кода с Tensorflow 1.x до Tensorflow 2.0, поскольку многие старые пакеты устарели.

4. Декоратор tf.function

Это также одна из самых интересных возможностей Tensorflow 2. Декоратор @tf.function позволяет автоматически преобразовывать ваши функции Python в графики Tensorflow .

Вы по-прежнему можете пользоваться всеми преимуществами выполнения на основе графов и избавиться от сложного программирования на основе сеансов. Применяя @tf.function к такой функции, как:

 @tf.function 
 def multiply(a, b): 
 return a * b 
 
 multiply(tf.ones([2, 2]), tf.ones([2, 2])) 

Если вам интересно, это автоматически дополняется Autograph . Он генерирует график, который имеет те же эффекты, что и функция, которую мы декорировали.

5. Обучение с использованием распределенных вычислений

Tensorflow 2.0 обладает улучшенной производительностью для обучения с использованием графических процессоров. По словам команды, эта версия в 3 раза быстрее, чем Tensorflow 1.x.

На данный момент Tensorflow также может работать с TPU. Фактически, вы можете работать с несколькими TPU и GPU в рамках подхода распределенных вычислений.

Подробнее об этом можно прочитать в официальном руководстве .

6. tf.data и наборы данных

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

Затем мы хотим удалить все повторяющиеся слова. Это легко сделать, упаковав их в Set , преобразовав его в List и отсортировав его:

 words = sorted(list(set(text))) 

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

 vocab_to_int = {word:index for index, word in enumerate(words)} 
 int_to_vocab = np.array(words) 

Теперь, чтобы преобразовать наш массив целых чисел, представляющих слова, в набор данных Tensorflow, мы будем использовать from_tensor_slices() предоставляемую tf.data.Dataset :

 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.Model новинка - это определение ваших собственных моделей путем создания подкласса от класса keras.Model.

Воспользовавшись подсказкой PyTorch, которая позволяет разработчикам создавать модели с использованием настраиваемых классов (настраивая классы, которые образуют Layer , и, таким образом, изменяя структуру модели), Tensorflow 2.0 через Keras также позволяет нам определять настраиваемые модели.

Давайте создадим Sequential модель, как если бы вы использовали 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.Model подкласс класса keras.Model:

 # 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.GradientTape

tf.GradientTape позволяет автоматически рассчитывать градиенты. Это полезно при использовании пользовательских циклов обучения.

Вы можете обучать свою модель, используя пользовательские циклы обучения, а не вызывая model.fit . Это дает вам больше контроля над тренировочным процессом, если вы хотите его настроить.

Сочетание пользовательских циклов обучения, предоставляемых tf.GradientTape с пользовательскими моделями, предоставленными keras.Model дает вам контроль над моделями и обучением, которых у вас никогда не было.

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

 """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 wrt 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 также представил новый опыт обучения для опытных практиков.