«Освоение TensorFlow Extended: передовые методы создания сквозных конвейеров машинного обучения в масштабе»

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

В этой статье мы рассмотрим некоторые расширенные функции TFX и то, как их можно использовать для создания надежных и эффективных конвейеров машинного обучения. Мы рассмотрим поддержку Apache Beam в TFX, его интеграцию с TensorBoard и анализом моделей TensorFlow, его способность обрабатывать большие наборы данных с помощью Apache Arrow и поддержку распределенного обучения с помощью TensorFlow. Мы также рассмотрим простой пример использования TFX для создания конвейера машинного обучения.

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

Содержание

Введение

• Необходимость в фреймворках машинного обучения
• Введение в расширенный TensorFlow (TFX)

II. Компоненты TFX и рекомендации

• Обзор компонентов TFX
• Рекомендации по организации и управлению рабочими процессами TFX

III. Расширенные возможности TFX

• Использование Apache Beam с TFX
• Интеграция с TensorBoard и анализом моделей TensorFlow
• Обработка больших наборов данных с помощью Apache Arrow
• Распределенное обучение с TensorFlow

IV. Создание конвейера машинного обучения с помощью TFX

• Пошаговый пример построения конвейера машинного обучения с помощью TFX

В. Заключение

• Краткое изложение преимуществ и расширенных функций TFX
• Ресурсы для получения дополнительной информации о TFX

Пользовательские слои

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

Чтобы создать собственный слой в TensorFlow, нам нужно создать подкласс класса tf.keras.layers.Layer и реализовать следующие методы:

• init(self, …): этот метод используется для определения параметров слоя, таких как количество единиц, функция активации или размер ядра. Эти параметры могут быть фиксированными или обучаемыми.
• build(self, input_shape): этот метод используется для инициализации весов слоя, которые могут быть либо случайным образом инициализированы, либо предварительно обучены из другой модели. Аргумент input_shape — это кортеж, определяющий форму входных данных.
• call(self, inputs): этот метод используется для определения прямого прохода слоя, который вычисляет выходные данные слоя с учетом входных данных. Входной аргумент — это тензор, представляющий входные данные.
• compute_output_shape(self, input_shape): этот метод используется для вычисления формы выходного тензора слоя с учетом формы входного тензора. Это полезно для слоев, которые изменяют форму входных данных, таких как сверточные слои или слои объединения.

Вот пример пользовательского слоя, реализующего функцию активации SoftMax:

import tensorflow as tf
class SoftMax(tf.keras.layers.Layer):
  def __init__(self, axis=-1, **kwargs):
    super(SoftMax, self).__init__(**kwargs)
    self.axis = axis
  def call(self, inputs):
    return tf.nn.softmax(inputs, axis=self.axis)
  def compute_output_shape(self, input_shape):
    return input_shape

В этом примере мы определяем слой SoftMax, который принимает параметр оси, чтобы указать ось, вдоль которой применяется функция SoftMax. Мы реализуем метод call(), который применяет функцию SoftMax к входному тензору, и метод calculate_output_shape(), который возвращает ту же форму, что и входной тензор.

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

model = tf.keras.models.Sequential([  tf.keras.layers.Dense(64, activation='relu'),  tf.keras.layers.Dense(10),  SoftMax()])

В этом примере мы определяем последовательную модель, которая состоит из полностью подключенного слоя с 64 единицами и активацией ReLU, за которым следует еще один полностью подключенный слой с 10 единицами и без функции активации, и, наконец, наш пользовательский слой SoftMax в качестве выходного слоя. Слой SoftMax применяет функцию SoftMax к выходным данным предыдущего слоя и возвращает вероятности каждого класса.

Пользовательские функции потерь

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

Чтобы создать пользовательскую функцию потерь в TensorFlow, нам нужно определить функцию, которая принимает два аргумента: y_true и y_pred. y_true — это истинный результат, а y_pred — прогнозируемый результат модели. Функция должна возвращать скаляр, представляющий значение функции потерь для заданных входных данных.

Вот пример пользовательской функции потерь, которая реализует бинарную кросс-энтропийную потерю:

import tensorflow as tf
def binary_crossentropy(y_true, y_pred):
  epsilon = tf.keras.backend.epsilon()
  y_pred = tf.clip_by_value(y_pred, epsilon, 1 - epsilon)
  return -tf.reduce_mean(y_true * tf.math.log(y_pred) + (1 - y_true) * tf.math.log(1 - y_pred))

В этом примере мы определяем функцию с именем binary_crossentropy, которая принимает y_true и y_pred в качестве входных данных. Мы используем функцию tf.keras.backend.epsilon(), чтобы избежать численной нестабильности, и функцию tf.clip_by_value(), чтобы обрезать предсказанные значения, чтобы избежать логарифмирования нуля. Наконец, мы вычисляем бинарную кросс-энтропийную потерю, используя функцию tf.reduce_mean().

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

model = tf.keras.models.Sequential([
  tf.keras.layers.Dense(64, activation='relu'),
  tf.keras.layers.Dense(1, activation='sigmoid')
])
model.compile(optimizer='adam', loss=binary_crossentropy, metrics=['accuracy'])

В этом примере мы определяем последовательную модель, состоящую из полностью связанного слоя с 64 единицами и активацией ReLU, за которым следует одноэлементный выходной слой с сигмовидной активацией для двоичной классификации. В качестве функции потерь в методе compile() мы указываем функцию потерь binary_crossentropy, а в качестве дополнительных аргументов — оптимизатор Адама и метрику точности.

Пользовательские обратные вызовы

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

Чтобы создать собственный обратный вызов в TensorFlow, нам нужно создать подкласс класса tf.keras.callbacks.Callback и реализовать следующие методы:

• on_train_begin(self, logs=None): этот метод вызывается в начале процесса обучения.
• on_train_end(self, logs=None): этот метод вызывается в конце процесса обучения.
• on_epoch_begin(self, epoch, logs=None): этот метод вызывается в начале каждой эпохи.
• on_epoch_end(self, epoch, logs=None): этот метод вызывается в конце каждой эпохи.
• on_batch_begin(self, batch, logs=None): этот метод вызывается в начале каждого пакета.
• on_batch_end(self, batch, logs=None): этот метод вызывается в конце каждого пакета.

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

import tensorflow as tf
class SaveWeightsCallback(tf.keras.callbacks.Callback):
  def __init__(self, filepath):
    super(SaveWeightsCallback, self).__init__()
    self.filepath = filepath
  def on_epoch_end(self, epoch, logs=None):
    self.model.save_weights(self.filepath.format(epoch=epoch))

В этом примере мы определяем класс SaveWeightsCallback, который принимает аргумент пути к файлу, чтобы указать место, где должны быть сохранены веса. Мы реализуем метод on_epoch_end(), который сохраняет веса модели после каждой эпохи, используя метод model.save_weights().

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

model = tf.keras.models.Sequential([
  tf.keras.layers.Dense(64, activation='relu'),
  tf.keras.layers.Dense(10)
])
model.compile(optimizer='adam', loss='mse')
save_weights_callback = SaveWeightsCallback('weights/weights.{epoch:02d}.h5')
model.fit(X_train, y_train, epochs=10, callbacks=[save_weights_callback])

В этом примере мы определяем последовательную модель, состоящую из полностью связанного слоя с 64 единицами и активацией ReLU, за которым следует выходной слой из 10 единиц без функции активации для регрессии. Мы указываем функцию потери среднеквадратичной ошибки и оптимизатор Adam в методе compile() и передаем наш пользовательский SaveWeightsCallback в качестве обратного вызова методу fit(). Метод fit() будет вызывать метод on_epoch_end() функции SaveWeightsCallback после каждой эпохи для сохранения весов модели в указанном месте.

Пользовательские показатели

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

Чтобы создать пользовательскую метрику в TensorFlow, нам нужно определить функцию, которая принимает два аргумента: y_true и y_pred. y_true — это истинный результат, а y_pred — прогнозируемый результат модели. Функция должна возвращать скаляр, представляющий значение метрики для заданных входных данных.

Вот пример пользовательской метрики, которая вычисляет коэффициент детерминации (R²) для регрессии:

import tensorflow as tf
def coefficient_of_determination(y_true, y_pred):
    SS_res =  tf.reduce_sum(tf.square(y_true - y_pred)) 
    SS_tot = tf.reduce_sum(tf.square(y_true - tf.reduce_mean(y_true))) 
    return 1 - SS_res/(SS_tot + tf.keras.backend.epsilon())

В этом примере мы определяем функцию с именем коэффициент_определения, которая принимает y_true и y_pred в качестве входных данных. Мы используем функцию tf.reduce_sum() для вычисления суммы квадратов разностей между истинным и прогнозируемым выходными данными и функцию tf.reduce_mean() для вычисления среднего истинного выходного значения. Затем мы вычисляем коэффициент детерминации по формуле 1 — SS_res/SS_tot.

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

model = tf.keras.models.Sequential([
  tf.keras.layers.Dense(64, activation='relu'),
  tf.keras.layers.Dense(1)
])
model.compile(optimizer='adam', loss='mse', metrics=[coefficient_of_determination])

В этом примере мы определяем последовательную модель, которая состоит из полностью связанного слоя с 64 единицами и активацией ReLU, за которым следует выходной слой с одной единицей для регрессии. Мы указываем функцию потери среднеквадратичной ошибки, а также нашу пользовательскую метрику коэффициента_определения в методе compile(). Во время обучения или оценки TensorFlow будет вычислять значение метрики для каждого пакета или эпохи и отображать его в выходных данных.

Трансферное обучение

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

TensorFlow предоставляет множество предварительно обученных моделей, доступных для использования через модуль tf.keras.applications. Эти модели были обучены на больших наборах данных, таких как ImageNet, и широко используются в задачах компьютерного зрения, таких как классификация изображений, обнаружение объектов и сегментация изображений.

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

Вот пример использования трансферного обучения с предварительно обученной моделью VGG16 для классификации изображений:

import tensorflow as tf
from tensorflow.keras.applications.vgg16 import VGG16
vgg16 = VGG16(weights='imagenet', include_top=False, input_shape=(224, 224, 3))
for layer in vgg16.layers:
    layer.trainable = False
model = tf.keras.models.Sequential([
    vgg16,
    tf.keras.layers.Flatten(),
    tf.keras.layers.Dense(256, activation='relu'),
    tf.keras.layers.Dense(10, activation='softmax')
])
model.compile(optimizer='adam', loss='categorical_crossentropy', metrics=['accuracy'])
model.fit(X_train, y_train, epochs=10, validation_data=(X_test, y_test))

В этом примере мы создаем новую последовательную модель, которая берет за основу предварительно обученную модель VGG16 и добавляет к ней плоский слой и два плотных слоя для классификации изображений. Мы заморозим веса предварительно обученной модели, установив для обучаемого атрибута каждого слоя значение False. Затем мы компилируем модель с категориальной функцией кроссэнтропийных потерь и оптимизатором Адама и обучаем модель на нашем наборе данных в течение 10 эпох.

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

TensorBoard

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

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

tensorboard_callback = tf.keras.callbacks.TensorBoard(log_dir=log_dir, histogram_freq=1)
model.fit(X_train, y_train, epochs=10, validation_data=(X_test, y_test), callbacks=[tensorboard_callback])

В этом примере мы создаем обратный вызов TensorBoard и передаем его методу fit() нашей модели. Аргумент log_dir указывает каталог, в котором будут храниться файлы журналов. Аргумент histogram_freq указывает, как часто вычислять и регистрировать данные гистограммы.

После запуска кода мы можем запустить TensorBoard, выполнив следующую команду в нашем терминале:

tensorboard --logdir=log_dir

Это запустит локальный веб-сервер, к которому мы можем получить доступ в нашем браузере по адресу https://localhost:6006. Затем мы можем перейти на вкладку Скаляры, чтобы просмотреть скалярные графики наших показателей, таких как потери и точность, или на вкладку Гистограммы, чтобы просмотреть гистограммы наших весов и смещений.

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

Распределенное обучение

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

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

Чтобы использовать TensorFlow Distributed, нам нужно создать кластер рабочих узлов и узел сервера параметров. Рабочие узлы отвечают за вычисление градиентов, а узел сервера параметров отвечает за агрегирование градиентов и обновление весов модели.

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

import tensorflow as tf
# Define the cluster specification
cluster_spec = tf.train.ClusterSpec({
    "worker": ["worker0.example.com:2222", "worker1.example.com:2222"],
    "ps": ["ps0.example.com:2222"]
})
# Create the server
server = tf.distribute.Server(cluster_spec, job_name="worker", task_index=0)
# Create a MirroredStrategy for distributed training
strategy = tf.distribute.MirroredStrategy()
# Define the model within the strategy scope
with strategy.scope():
    model = tf.keras.Sequential([
        tf.keras.layers.Dense(64, activation='relu', input_shape=(784,)),
        tf.keras.layers.Dense(10, activation='softmax')
    ])
    model.compile(optimizer='adam', loss='categorical_crossentropy', metrics=['accuracy'])
# Create a tf.distribute.experimental.MultiWorkerMirroredStrategy for multi-worker training
multi_worker_strategy = tf.distribute.experimental.MultiWorkerMirroredStrategy()
# Define the model within the multi-worker strategy scope
with multi_worker_strategy.scope():
    model = tf.keras.Sequential([
        tf.keras.layers.Dense(64, activation='relu', input_shape=(784,)),
        tf.keras.layers.Dense(10, activation='softmax')
    ])
    model.compile(optimizer='adam', loss='categorical_crossentropy', metrics=['accuracy'])

В этом примере мы сначала определяем спецификацию кластера с двумя рабочими узлами и одним узлом сервера параметров. Затем мы создаем сервер с указанной спецификацией кластера, именем задания и индексом задачи, равными 0.

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

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

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

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

На высоком уровне TFX можно рассматривать как состоящую из нескольких компонентов, которые работают вместе, чтобы сформировать полный конвейер машинного обучения. Эти компоненты включают в себя:

1. Прием данных.TFX предоставляет инструменты для приема и обработки данных из различных источников, включая файловые системы, базы данных и потоковые системы. Сюда входит поддержка популярных форматов данных, таких как CSV, JSON и Parquet.
2. Проверка данных. TFX предоставляет инструменты для проверки данных, чтобы убедиться, что они соответствуют определенным стандартам качества, прежде чем они будут использоваться для обучения модели машинного обучения. Сюда входят проверки отсутствия значений, несоответствия типов данных и других распространенных проблем.
3. Преобразование данных.TFX предоставляет набор функций преобразования, которые можно использовать для предварительной обработки и преобразования данных перед их использованием для обучения. Это включает в себя поддержку общих задач, таких как масштабирование функций, горячее кодирование и предварительная обработка текста.
4. Обучение модели.TFX предоставляет инструменты для обучения моделей машинного обучения с использованием TensorFlow или других популярных платформ машинного обучения, таких как XGBoost и Scikit-Learn. Сюда входит поддержка распределенного обучения с использованием таких технологий, как Apache Beam и Apache Spark.
5. Оценка модели.TFX предоставляет инструменты для оценки моделей машинного обучения, чтобы убедиться, что они соответствуют определенным стандартам качества перед их развертыванием. Это включает в себя поддержку вычисления показателей, таких как точность, точность и полнота.
6. Обслуживание моделей. TFX предоставляет инструменты для развертывания моделей машинного обучения в рабочих средах. Сюда входит поддержка популярных платформ обслуживания, таких как TensorFlow Serving и Kubeflow.

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

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

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

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

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

Пример TFX: использование TFX для построения конвейера машинного обучения

Чтобы проиллюстрировать, как можно использовать TFX для построения конвейера машинного обучения, давайте рассмотрим простой пример. В этом примере мы построим конвейер, который принимает, преобразует, обучает и развертывает модель машинного обучения для прогнозирования того, выжил ли пассажир на «Титанике» или нет.

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

from tfx.components import CsvExampleGen
# Define the input schema
schema = tfdv.load_schema_text('titanic_schema.pbtxt')
# Load the data
examples = CsvExampleGen(input_base='/path/to/data').outputs['examples']

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

from tfx.components import Transform
from tfx.utils.dsl_utils import csv_input
# Define the transformation function
def preprocessing_fn(inputs):
    # ...
    return outputs
# Apply the transformation function
transform = Transform(
    examples=examples,
    schema=schema,
    module_file='/path/to/preprocessing_fn.py',
    force_tf_compat_v1=True
)

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

import tensorflow as tf
from tensorflow import keras
# Define the model
model = keras.Sequential([
    keras.layers.Dense(64, activation='relu'),
    keras.layers.Dense(1, activation='sigmoid')
])
model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy'])

Затем мы можем обучить модель на предварительно обработанных обучающих данных, используя компонент Trainer TFX:

from tfx.components import Trainer
from tfx.components.trainer.executor import GenericExecutor
# Define the Trainer component
trainer = Trainer(
    examples=transform.outputs['transformed_examples'],
    schema=schema,
    module_file='/path/to/model.py',
    train_args=GenericExecutor.GenericTrainArgs(
        num_steps=10000
    ),
    eval_args=GenericExecutor.GenericEvalArgs(
        num_steps=1000
    ),
    custom_executor_spec=executor_spec.ExecutorClassSpec(GenericExecutor)
)
# Train the model
trainer.run()

Наконец, мы можем оценить обученную модель с помощью компонента Evaluator TFX и развернуть ее с помощью компонента Pusher TFX:

from tfx.components import Evaluator, Pusher
from tfx.proto import pusher_pb2
# Evaluate the model
evaluator = Evaluator(
    examples=transform.outputs['transformed_examples'],
    model=trainer.outputs['model'],
    eval_config=tfma.EvalConfig(
        metrics_specs=[
            tfma.MetricsSpec(
                metrics=[
                    tfma.MetricConfig(class_name='BinaryAccuracy'),
                    tfma.MetricConfig(class_name='AUC')
                ]
            )
        ]
    )
)
evaluation = evaluator.outputs['evaluation']
# Deploy the model
pusher = Pusher(
    model=trainer.outputs['model'],
    push_destination=pusher_pb2.PushDestination(
        filesystem=pusher_pb2.PushDestination.Filesystem(
            base_directory='/path/to/saved_model'
        )
    )
)
pusher.run()

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

Заключение

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

В этой статье мы рассмотрели некоторые расширенные функции TFX, в том числе поддержку Apache Beam, интеграцию с TensorBoard и анализ моделей TensorFlow, возможность обработки больших наборов данных с помощью Apache Arrow и поддержку распределенного обучения с помощью TensorFlow. . Мы также рассмотрели простой пример использования TFX для создания конвейера машинного обучения.

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

Ресурсы

1. Официальная документация по TFX. Официальная документация содержит исчерпывающее руководство по функциям, компонентам и рекомендациям TFX.
2. Репозиторий TFX на GitHub.Репозиторий TFX на GitHub содержит множество примеров, руководств и фрагментов кода для использования TFX в реальных приложениях.
3. Расширенный канал TensorFlow на YouTube. На расширенном канале TensorFlow на YouTube представлена ​​серия видеороликов о TFX, включая учебные пособия, доклады и демонстрации.
4. Форум TensorFlow.Форум TensorFlow — это сообщество разработчиков, специалистов по данным и инженеров по машинному обучению, которые обсуждают и делятся знаниями о TensorFlow и связанных с ним инструментах, включая TFX.
5. Мастерство машинного обучения. Популярный блог, посвященный машинному обучению, содержит множество руководств, статей и ресурсов по машинному обучению, включая TFX.
6. TFX на Medium. Команда TFX в Google регулярно публикует на Medium статьи о функциях TFX, примерах использования и рекомендациях.

Изучая эти ресурсы, вы сможете глубже понять TFX и его возможности, а также научиться применять его в своих собственных проектах машинного обучения.