Основы TensorFlow

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

Установка TensorFlow

TensorFlow можно установить с помощью стандартного менеджера пакетов pip. Библиотека, на момент написания статьи, работает начиная с версии python 3.7 и выше. Для установки нужно ввести следующие команды:

pip install --upgrade pip
pip install tensorflow

Тензоры (Tensors)

TensorFlow выполняет операции над многомерными массивами или тензорами, которые представлены экземплярами класса tf.Tensor. Вот как выглядит пример создания трех размерного массива.

import tensorflow as tf

t = tf.constant([
    [
        [1],
        [2],
        [3],
    ],
    [
        [4],
        [1],
        [6],
    ],
    [
        [7],
        [8],
        [9],
    ],
])

print(t)

Вывод у данного кода будет следующий:

tf.Tensor(
[[[1]
  [2]
  [3]]

 [[4]
  [1]
  [6]]

 [[7]
  [8]
  [9]]], shape=(3, 3, 1), dtype=int32)

Наиболее важными атрибутами tf.Tensor являются shape и dtype:

Tensor.shape показывает размерность массива.
Tensor.dtype говорит о типе элементов в тензоре.

В результате выполнения кода ниже, можно получить вот такой вывод:

print(t.shape)
print(t.dtype)

Вывод в консоль:

(3, 3, 1)
<dtype: 'int32'>

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

t + t

Вывод в консоль:

<tf.Tensor: shape=(3, 3, 1), dtype=int32, numpy=
array([[[ 2],
        [ 4],
        [ 6]],
       [[ 8],
        [ 2],
        [12]],
       [[14],
        [16],
        [18]]], dtype=int32)>

Пример:

10 * t

Вывод в консоль:

<tf.Tensor: shape=(3, 3, 1), dtype=int32, numpy=
array([[[10],
        [20],
        [30]],

       [[40],
        [10],
        [60]],

       [[70],
        [80],
        [90]]], dtype=int32)>

Пример:

tf.reduce_sum(t)

Вывод в консоль:

<tf.Tensor: shape=(), dtype=int32, numpy=41>

Пример:

tf.concat([t, t, t], axis=0)

Вывод в консоль:

<tf.Tensor: shape=(6, 3, 1), dtype=int32, numpy=
array([[[1],
        [2],
        [3]],
       [[4],
        [1],
        [6]],
       [[7],
        [8],
        [9]],
       [[1],
        [2],
        [3]],
       [[4],
        [1],
        [6]],
       [[7],
        [8],
        [9]]], dtype=int32)>

Переменные (Variables)

Обычно объекты tf.Tensor являются иммутабельными, т.е. не изменяемыми. Для хранения весов модели или других мутабельных состояний в TensorFlow обычно используется tf.Variable. Создавать и изменять переменные можно следующими способами:

var = tf.Variable([0.0, 0.0, 0.0])
print(var)
var.assign([1, 2, 3])
print(var)
var.assign_add([1, 1, 1])
print(var)

Вывод в консоль:

<tf.Variable 'Variable:0' shape=(3,) dtype=float32, numpy=array([0., 0., 0.], dtype=float32)>
<tf.Variable 'Variable:0' shape=(3,) dtype=float32, numpy=array([1., 2., 3.], dtype=float32)>
<tf.Variable 'Variable:0' shape=(3,) dtype=float32, numpy=array([2., 3., 4.], dtype=float32)>

Графы и tf.function

TensorFlow предоставляет инструменты для:

Оптимизации производительности для увеличения скорости тренировок моделей и вывода результатов.
Экспорта модели, после того как она завершила тренировку.

Для этого необходимо использовать tf.function, чтобы отделить чистый TensorFlow код от Python. Рассмотрим на следующем примере: создадим функцию, которая будет возвращать сумму всех элементов тензора.

@tf.function
def reduce(t):
  print('Execute reduce function...')
  return tf.reduce_sum(t)

После того как мы первый раз запустим эту функцию на выполнение, то она выполнится на Python, но при этом создастся и запишется полный оптимизированный граф вычислений TensorFlow, выполняемых внутри функции.

t1 = tf.constant([1, 2, 3])
reduce(t1)

Вывод в консоль:

Execute reduce function...
<tf.Tensor: shape=(), dtype=int32, numpy=6>

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

t2 = tf.constant([3, 3, 3])
reduce(t2)

Вывод в консоль:

<tf.Tensor: shape=(), dtype=int32, numpy=9>

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

t3 = tf.constant([3., 3., 3.])
reduce(t3)

Вывод в консоль:

Execute reduce function...
<tf.Tensor: shape=(), dtype=float32, numpy=9.0>

Оптимизированные графы приносят следующую выгоду:

Во многих случаях они обеспечиваю значительное ускорение выполнения
Можно экспортировать эти графы с помощью tf.saved_model, для запуска их на других системах вроде сервера или мобильного устройства, без обязательной установки python.

Модули, слои и модели

tf.Module это класс для управления экземплярами tf.Variable и объектами tf.function. Класс tf.Module необходим для поддержания двух важных функций:

позволяет сохранять и восстанавливать значения переменных с помощью tf.train.Checkpoint. Это полезно в процессе тренировки модели, позволяет быстро сохранить и восстановить ее состояние.
позволяет импортировать и экспортировать значения tf.Variable и вычислительные графы tf.function с помощью tf.saved_model. Это позволяет запускать модель независимо от python программы, с помощью которой она была создана.

Рассмотрим простейший пример создания модуля, с помощью tf.Module:

class OperationModule(tf.Module):
    def __init__(self, weight: float):
        self.weight = tf.Variable(weight)

    @tf.function
    def multiply(self, multiplier: tf.constant) -> float:
        return self.weight * multiplier

op_module = OperationModule(5)
op_module.multiply(tf.constant([1, 2, 3]))

Вывод в консоль:

<tf.Tensor: shape=(3,), dtype=int32, numpy=array([ 5, 10, 15], dtype=int32)>

Сохраним модуль для его последующего переиспользования:

save_path = './saved'
tf.saved_model.save(op_module, save_path)

Теперь сохраненная модель не зависит от кода, в котором она создавалась. Попробуем восстановить ее в другую переменную и вызвать функцию multiply:

reloaded = tf.saved_model.load(save_path)
reloaded.multiply(tf.constant([5, 15, 20]))

Вывод в консоль:

<tf.Tensor: shape=(3,), dtype=int32, numpy=array([ 25,  75, 100], dtype=int32)>

tf.keras.layers.Layer и tf.keras.Model – классы, построенные на базе tf.Module, но предоставляющие дополнительную функциональность и удобство при построении, тренировке и сохранении моделей.

Создание модели

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

from matplotlib import pyplot as plt

x = tf.linspace(-2, 2, 201)  # Создаются равномерно расположенные значения в интервале
x = tf.cast(x, tf.float32)  # Приведение тензора к новому типу

def f(x):
  y = x**2 + 2*x - 5
  return y

y = f(x) + tf.random.normal(shape=[201])  # Применение функции f к тензору с добавлением случайных значений из нормального распределения
plt.plot(x.numpy(), y.numpy(), '.', label='Данные')
plt.plot(x, f(x), label='Функция f')
plt.legend()

Определим квадратичную функцию f и применим ее к набору из 201 значения по оси х, расположенных в интервале [-2.0, 2.0]. Добавим также дополнительно небольшой случайный шум. В результате получим следующий график, на котором синими точками представлены данные для обучения, а оранжевая линия – это представление функции f от x.

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

class Model(tf.Module):
  def __init__(self):
    # Генерация трех случайных весов в интервале от 0 до 5
    rand_init = tf.random.uniform(shape=[3], minval=0., maxval=5., seed=22)
    # Инициализация весов модели случайными
    self.w_q = tf.Variable(rand_init[0])
    self.w_l = tf.Variable(rand_init[1])
    self.b = tf.Variable(rand_init[2])

  @tf.function
  def __call__(self, x):
    # Квадратична функция модели: quadratic_weight * x^2 + linear_weight * x + bias
    return self.w_q * (x**2) + self.w_l * x + self.b

quad_model = Model()

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

def plot_preds(x, y, f, model, title):
  plt.figure()
  plt.plot(x, y, '.', label='Данные')
  plt.plot(x, f(x), label='Функция f')
  plt.plot(x, model(x), label='Прогноз модели')
  plt.title(title)
  plt.legend()

plot_preds(x, y, f, quad_model, 'До тренировки')

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

def mse_loss(y_pred, y):
  return tf.reduce_mean(tf.square(y_pred - y))

Напишем базовый тренировочный цикл для модели. Цикл будет использовать функцию потерь и ее градиенты по отношению к входным данным для итеративного обновления параметров модели. Использование мини батчей для обучения обеспечит эффективность использования памяти и быструю сходимость. API tf.data.Dataset имеет полезные функции для работы с батчами и перемешивания.

batch_size = 32  # Задаем размер батча
dataset = tf.data.Dataset.from_tensor_slices((x, y))  # Создаем датасет из тензоров x и y
dataset = dataset.shuffle(buffer_size=x.shape[0]).batch(batch_size)  # Перемешиваем записи в датасете

# Задаем тренировочные параметры
epochs = 100
learning_rate = 0.01
losses = []

for epoch in range(epochs):
  for x_batch, y_batch in dataset:
    with tf.GradientTape() as tape:
      batch_loss = mse_loss(quad_model(x_batch), y_batch)
    # Обновляем веса модели в соответствии с вычислениями градиента
    grads = tape.gradient(batch_loss, quad_model.variables)
    for g,v in zip(grads, quad_model.variables):
        v.assign_sub(learning_rate*g)
  # Сохраняем значения потерь модели на каждой эпохе
  loss = mse_loss(quad_model(x), y)
  losses.append(loss)
  if epoch % 10 == 0:
    print(f'Среднеквадратичная ошибка для шага {epoch}: {loss.numpy():0.3f}')

# Plot model results
print("\n")
plt.plot(range(epochs), losses)
plt.xlabel("Эпоха")
plt.ylabel("Среднеквадратичная ошибка (MSE)")
plt.title('MSE по эпохам')

В результате получим следующий график:

Оценим прогноз модели после обучения:

plot_preds(x, y, f, quad_model, 'После обучения')

Модель обучена и работает. Но следует помнить, что реализации обучающих функций доступны в модуле tf.keras, при написании модели лучше рассмотреть сначала эти модули, прежде чем писать свои. Рассмотрим использование модуля tf.keras в нашем случае.

Начнем с создания последовательной модели keras с использованием tf.keras.Sequential. Один из простейших слоев в keras – это dense слой. Он способен обучаться многомерным линейным связям вида Y = W*X + b. Слой lambda необходим для выполнения трансформации данных на вход dense слою.

new_model = tf.keras.Sequential([
    tf.keras.layers.Lambda(lambda x: tf.stack([x, x**2], axis=1)),
    tf.keras.layers.Dense(units=1, kernel_initializer=tf.random.normal)])

new_model.compile(
    loss=tf.keras.losses.MSE,
    optimizer=tf.keras.optimizers.SGD(learning_rate=0.01))

history = new_model.fit(x, y,
                        epochs=100,
                        batch_size=32,
                        verbose=0)

new_model.save('./new_model.keras')

plt.plot(history.history['loss'])
plt.xlabel('Эпоха')
plt.ylim([0, max(plt.ylim())])
plt.ylabel('Потери [MSE]')
plt.title('Keras тренировочный прогресс')

plot_preds(x, y, f, new_model, 'После тренировки: Keras')

После выполнения этого кода будут отображены два графика:

На этом завершаем базовое рассмотрение основных элементов библиотеки TensorFlow. Jupyter ноутбук доступен в нашем репозитории по ссылке.

Тэги:

tensorflow

Дата публикации:

23.04.2024

master

Admin