Введение

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

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

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

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

Эта статья является дополнением к слайдам, разговору и коду, представленным в рамках моей презентации на GDG DevFest Raipur 2022 по теме с тем же названием.

Вы можете найти слайды здесь, а код здесь.

Оглавление

Эту статью можно разделить на 2 этапа.

  • Обучение

Шаг 1. Что такое keras.applications и Hugging Face?

Шаг 2. Как использовать предварительно обученные модели?

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

  • Развертывание

Шаг 3. Используйте TensorFlow Serving и SavedModel

Шаг 4. Экспорт SavedModel в образ Docker

Шаг 5. Создайте модель Vertex AI и конечные точки

Шаг 6. Выполнение тестирования и выводов

Обучение

Шаг 1: Что такое keras.applications и Hugging Face?

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

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

Но где найти эти модели?

  • Экосистема TensorFlow-Keras

Одна из наиболее зрелых экосистем для предварительно обученных моделей доступна с использованием keras.applicationsModule или с помощью TensorFlow Hub.
keras.applications содержит в общей сложности 38 моделей Vision, предварительно обученных на наборе данных ImageNet командой разработчиков Keras. Они также предоставляют таблицу с подробной статистикой, такой как количество параметров в модели, а также контрольные показатели, такие как задержка вывода в общей конфигурации. Эти модели широко используются и доступны бесплатно.

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

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

Поскольку Keras продолжает добавлять поддержку новых моделей, вы также можете ознакомиться с дополнительными пакетами KerasCV и KerasNLP. Они содержат больший набор более экзотических моделей вместе с их предварительно обученными весами. (Вы даже можете попробовать последнюю модель Stable Diffusion непосредственно из KerasCV).
Если и это не соответствует вашим потребностям, вы можете обратиться к поддерживаемым сообществом и предоставленным моделям, доступным через TensorFlow Hub. Люди из сообщества реализуют различные модели с помощью TensorFlow/Keras, обучают их и предоставляют через этот централизованный хаб.

  • Экосистема Hugging Face

Hugging Face — одно из крупнейших, если не самое большое множество моделей в Интернете. Имея более 100 000 доступных моделей, маловероятно, что ваш вариант использования не может быть выполнен моделью отсюда. Эти модели вносятся сообществом, небольшими командами, крупными предприятиями и всем, что между ними.

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

Более того, вы получаете этот доступ бесплатно (в то время как существует платная услуга для доступа к более качественным вычислениям).

Экосистема также обеспечивает поддержку вспомогательных задач, связанных с ML, таких как Accelerate (для настройки конвейера обучения), Diffusers (для работы с диффузионными моделями), наборы данных (для доступа к последним наборам данных) и Spaces (для размещения ваших моделей) наряду со многими другими. .

Шаг 2: Как использовать предварительно обученные модели?

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

from tensorflow.keras.applications.resnet50 import ResNet50, 
preprocess_input, decode_predictions

model = ResNet50(weights='imagenet')

x = preprocess_input(image)

preds = model.predict(x)

results = decode_predictions(preds)

В приведенном выше примере мы выполняем следующие операции:

  1. Выполняем необходимые импорты и получаем модель ResNet50 и ее вспомогательные функции (присутствующие в том же подмодуле) из keras.applications в среду.
  2. Мы инициализируем модель ResNet50 с использованием весов из предварительной подготовки ImageNet.
  3. Модель keras.applications.ResNet50 требует, чтобы все изображения, переданные в качестве входных данных, были в определенном формате. Следовательно, мы должны использовать встроенную функцию preprocess_input для внесения изменений.
  4. Мы выполняем вывод, передавая наше предварительно обработанное входное изображение функции model.predict() для получения прогнозов.
  5. Поскольку прогнозы генерируются в виде показателя достоверности вместе с классами (где имена классов кодируются метками), мы используем функцию decode_predictions(), чтобы понять смысл полученных нами результатов.
  • TensorFlow Hub: получение модели MLP Mixer для генерации векторов признаков
input_layer = keras.Input(shape=(224, 224, 3))

hub_layer = hub.KerasLayer(
    "https://tfhub.dev/sayakpaul/mixer_b16_i21k_fe/1", trainable=True
)

x = hub_layer(input_layer)

output_layer = keras.layers.Dense(num_classes, activation=’softmax’)

model = keras.Model(inputs=input_layer, outputs=output_layer)

В приведенном выше примере мы создаем экземпляр модели с помощью функционального API Keras. При этом выполняем следующие шаги:

  1. Определите слой keras.Input, который действует как точка входа для входного тензора. Здесь мы определяем форму, которую мы можем ожидать от входного тензора.
  2. Мы используем пакет tensorflow_hub и импортируем модель, которую хотим использовать, как hub.KerasLayer, который загружает архитектуру модели и ее обученные веса для использования.
  3. Мы передаем входной тензор только что созданному слою, чтобы выполнить прямой проход.
  4. Мы добавляем слой keras.layers.Dense с количеством единиц, равным количеству классов, для генерации прогнозов softmax.
  5. Наконец, мы инициализируем экземпляр keras.Model с выбранными входным и выходным слоями, чтобы создать окончательную модель. Это метод создания экземпляров моделей на основе функционального API для Keras.
  • Обнимающее лицо ( transformers ): Получение модели ViT для изображений 224 x 224 x 3
from transformers import ViTForImageClassification, ViTImageProcessor

feature_extractor = ViTImageProcessor.from_pretrained(
  "google/vit-base-patch16-224"
)

inputs = feature_extractor(image, return_tensors="pt")

model =  ViTForImageClassification.from_pretrained(
  "google/vit-base-patch16-224"
)

with torch.no_grad():
    logits = model(**inputs).logits

predicted_label = logits.argmax(-1).item()

В приведенном выше примере мы используем PyTorch вместо TensorFlow. Выполняем следующие шаги:

  1. Мы выполняем необходимый импорт, чтобы получить модель ViT и необходимые вспомогательные функции обработки изображений.
  2. Мы создаем экземпляр ViTImageProcessor из предварительно обученных весов, предоставленных владельцем репозитория (в данном случае Google).
  3. Мы передаем наше изображение в средство извлечения признаков, чтобы отформатировать наши изображения и подготовить их к выводу. Модели ViT требуют, чтобы изображения передавались в виде однородных патчей. Эта конкретная модель требует, чтобы ваше изображение имело размер 224 x 224 x 3, а размер каждого патча был 16 x 16.
  4. Мы создаем экземпляр модели ViTForImageClassification и используем предварительно обученные веса из того же репозитория.
  5. Мы используем torch.no_grad(), чтобы убедиться, что градиенты не рассчитываются для прямых проходов в пределах определенной области. Это для создания прогнозов.
  6. Прогнозы представляют собой оценки достоверности для всех возможных классов. Мы выполняем argmax() по всему выходному тензору, чтобы получить наивысший результирующий класс и использовать его в качестве окончательного прогноза.

Демонстрация: использование для создания индивидуальной предварительно обученной модели

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

# To force inference using CPU only
os.environ["CUDA_VISIBLE_DEVICES"] = "-1"

# Model definition
image_input = keras.Input(shape=(None, None, 3))

# Defining a resize Layer
x = keras.layers.Resizing(
   height=224, width=224, interpolation="lanczos3", crop_to_aspect_ratio=False
)(image_input)

# Define a Rescaling layer to get image pixel values from [0, 255] to [0, 1)
x = keras.layers.Rescaling(scale=1.0 / 255, offset=0.0)(x)

# Instantiate a MobileNetV2 instance with pre-trained weights and the 
# Dense classifier being trained for ImageNet classes
mobilenet = keras.applications.MobileNetV2(
   alpha=1.0,
   include_top=True,
   weights="imagenet",
   classes=1000,
   classifier_activation="softmax",
)

# Passing input tensor for results
model_output = mobilenet(x)

# Make Keras Model
model = keras.Model(inputs=image_input, outputs=model_output)

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

Но речь шла только о разработке решения. Как мы на самом деле доносим его до всего мира?

Развертывание

Шаг 3. Используйте TensorFlow Serving и SavedModel

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

Хотя существуют более простые решения для развертывания моделей, такие как использование Flask или Django, они потребуют от вас написания и поддержки большого количества шаблонов, а также выполнения обслуживания, обработки ошибок и обработки крайних случаев для задействованной инфраструктуры. С TF-Serving все это абстрагируется.

Еще одним важным фактом является то, что TF-Serving полностью совместим с контейнеризацией, что позволяет не беспокоиться о пакетах, совместимости, проблемах с зависимостями и так далее.

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

Ниже мы сначала напишем функцию вывода. Эта функция будет использоваться TensorFlow Serving для обработки ввода и предоставления результатов.

version_number = 1

@tf.function(input_signature=[tf.TensorSpec(name="image_bytes", 
  shape=None, dtype=tf.string)])
def predict_b64_string(b64str_tensor):
   img = tf.reshape(b64str_tensor, [])

   img = tf.io.decode_image(img, 
      channels=3, 
      dtype=tf.float16, 
      expand_animations=False
    )

   tensor = tf.expand_dims(img, axis=0)

   return model.call(tensor)

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

Декоратор tf.function(), пожалуй, самая важная строка кода в приведенном выше фрагменте. Этот декоратор выполнит трассировку функции и сгенерирует для нее граф вычислений. По умолчанию TensorFlow 2.0 использует Eager Execution, чтобы обеспечить лучшую отладку. Но самый производительный способ выполнения — в графическом режиме. Этот декоратор запустит тяжелую работу и подготовит функцию в определении, не зависящем от языка. Здесь мы определяем tf.TensorSpec, который позволяет нам определить тип входного тензора, который должна ожидать функция. Это означает, что мы примем ввод, состоящий из байтов изображения в виде строки Base64.

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

model.save(
   f'./mobilenetv2-imagenet-devfest/{version_number}',
   save_format='tf',
   include_optimizer=True,
   overwrite=True,
   signatures={
       "serving_image_b64string":predict_b64_string
   }
)

Здесь мы называем model.save() функцией, которая является неотъемлемой частью процесса развертывания. Для этого требуются следующие аргументы:

  1. Путь к файлу: TF-Serving требует, чтобы вы сохранили его в формате {имя_модели}/{номер_версии}.
  2. Формат сохранения: если установить для этого параметра значение 'tf', модель будет сохранена как Keras SavedModel, что поможет вам сохранить метаданные модели, пользовательские функции, веса, состояния оптимизатора и т. д. Это необходимо для TF-Serving, поскольку модель будет работать только в графическом режиме.
  3. Включить оптимизатор: выберите, следует ли включать состояние оптимизатора в сохраненный пакет.
  4. Перезаписать: выберите, следует ли перезаписывать старые данные, которые могут присутствовать в том же месте назначения файла.
  5. Подписи: здесь мы должны определить функцию, которую TF-Serving должен использовать для создания конечной точки модели и последующего использования ее для вывода. Здесь мы даем имя сигнатуре и передаем ей объект функции в виде словаря

Шаг 4. Экспорт SavedModel в образ Docker

[suvaditya@fedora ~ ]$ docker run -d --name serving_base tensorflow/serving

[suvaditya@fedora ~ ]$ docker cp /absolute/path/to/saved_model/model_name \
serving_base:/models/model_name

[suvaditya@fedora ~ ]$ docker commit --change “ENV MODEL_NAME model_name” \ 
serving_base devfest-mobilenet-demo

[suvaditya@fedora ~ ]$ docker run -t -p 8501:8501 devfest-mobilenet-demo

Фрагмент кода выше представляет собой серию команд Docker, которые будут выполнять следующие шаги:

  • Сначала мы создаем фиктивный контейнер, который инициализируется с помощью образа tensorflow/serving, представленного в Docker Hub. Мы запускаем его в автономном режиме.
  • Мы даем инструкцию cp, которая скопирует содержимое из источника в целевой каталог для Dockerfile образа. Здесь мы копируем содержимое файловой структуры SavedModel в путь в файловой системе контейнера, где TF-Serving ожидает, что файлы вашей модели будут.
  • Мы commit вносим изменения в Dockerfile, вставляем новую переменную Environment для контейнера и даем новое имя этому измененному Dockerfile как devfest-mobilenet-demo исходя из контейнера serving_base в качестве основы.
  • Наконец, мы запускаем новый контейнер, используя только что созданный образ. Мы открываем и пересылаем запросы на порт 8501, поскольку TF-Serving настроен на обслуживание запросов REST API на этом порту. При необходимости на порту 8500 также доступен отдельный сервер gRPC, который можно открыть аналогичным образом.

Шаг 5: Создайте модель Vertex AI и конечные точки

Примечание. Для выполнения следующих действий требуется учетная запись Google Cloud Billing. GCP предлагает кредиты на сумму 300 долларов США сроком на 90 дней. Чтобы узнать больше, нажмите здесь.

Теперь мы переходим к Google Cloud Platform и ее современному предложению Vertex AI.

Что такое вершинный ИИ?

Vertex AI — это официальное комплексное решение для всего, что связано с машинным обучением в GCP. Он предлагает инструменты для работы над каждым аспектом полного жизненного цикла машинного обучения.

  • Сбор наборов данных и контроль версий
  • Маркировка
  • Предварительная обработка
  • Обучение
  • Развертывание
  • Версия модели
  • Регистрация и мониторинг

Мы уже создали образ Docker, который обслуживает модель внутри среды выполнения TF-Serving. Процесс развертывания модели Vertex AI будет состоять из следующих шагов:

  • Разверните разработанный нами образ Docker в Реестр артефактов Google. Это делается для того, чтобы поддерживать центральный источник для всех версий модели. Google Artifact Registry — лучшее решение для хранения артефактов, поскольку он позволяет использовать несколько различных форматов, таких как пакеты Maven, образы Docker и т. д., в одном месте по сравнению со старым реестром контейнеров Google.
  • Импортируйте и создайте ресурс Vertex AI Model из реестра артефактов.
  • Создайте Конечную точку Vertex AI, которая примет модель Vertex AI.
  • Разверните конечную точку Vertex AI и обслуживайте ее для трафика запросов-ответов из Интернета.
  1. Поместить изображение в реестр артефактов

[suvaditya@fedora ~]$ docker tag devfest-mobilenet-demo \
us-central1-docker.pkg.dev/test-da9ec/devfest-vertex-ai/devfest-mobilenet-demo

[suvaditya@fedora ~]$ docker push \
us-central1-docker.pkg.dev/test-da9ec/devfest-vertex-ai/devfest-mobilenet-demo

Здесь мы сначала переходим на экран Artifact Registry и создаем репозиторий. Мы настраиваем его для хранения образов Docker. Мы помечаем изображение, используя URL-адрес репозитория, который имеет формат

{region}-{zone}-docker.pkg.dev/{project-id}/{repository_name}/{artifact_name}

Мы отправляем изображение на тот же URL-адрес, и после создания изображения и его последующей загрузки оно будет отображаться в консоли.

2. Создайте ресурс Vertex AI Model.

Чтобы развернуть нашу модель, у нас есть два шага. Во-первых, мы должны определить экземпляр Vertex AI Model. Это делается путем импорта образа контейнера из реестра артефактов Google.

В нашем случае сначала мы устанавливаем devfest-mobilenet-imagenet в качестве имени нашей модели. Мы также можем предоставить небольшое описание модели для документации.

После того, как модель названа, мы выбираем фактический образ контейнера из реестра артефактов Google, который мы собираемся использовать. Возвращаясь к нашему примеру, мы используем наше предыдущее изображение devfest-mobilenet-demo в качестве основы нашей модели.

Если ваше решение более индивидуальное (возможно, с использованием другого TF-Serving), вы можете переопределить строку CMD или ENTRYPOINT вашего Dockerfile, используя поле Command во время настройки. Также присутствуют параметры для установки новых переменных среды или аргументов для процесса.

Наконец, сохранение модели позволит вам увидеть ее в консоли.

3. Создайте ресурс Vertex AI Endpoint.

Подготовив модель Vertex AI, мы теперь используем консоль для создания ресурса Vertex AI Endpoint. Эта конечная точка будет контролировать полное развертывание, будь то автоматическое масштабирование, безопасность, обслуживание и т. д.

Мы можем нажать Создать конечную точку, что приведет нас к мастеру создания конечной точки.

В первой строке мы даем имя нашей новой конечной точке, а затем настраиваем ее в определенном регионе. Здесь, поскольку наш проект настроен в us-central1, мы будем ограничены только этим. Если у нас мультирегиональный проект, мы можем выбрать и другие локации. Мы также получаем возможность настроить доступ к конечной точке. Если мы выберем, мы можем предоставить конечную точку для доступа в Интернет или сделать конечную точку частной с помощью сети VPC.

Теперь мы соединяем модель Vertex AI с конечной точкой, используя определенную нами модель. Мы можем выбрать версию модели, которую хотим развернуть. Если у нас есть несколько экземпляров, обслуживающих модель на конечной точке, мы можем выбрать разделение трафика. Но если это один экземпляр, мы придерживаемся полного 100% разделения.

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

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

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

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

Теперь давайте посмотрим на наше развертывание в действии!

Шаг 6: Выполните тестирование и вывод

Сначала выполните аутентификацию в gcloud SDK на локальном компьютере. Подготовьте запрос в виде файла JSON, который будет отправлен в теле запроса. Убедитесь, что вы включили имя подписи, поскольку оно становится неотъемлемой частью модели.

[suvaditya@fedora ~]$ gcloud auth application-default login

[suvaditya@fedora ~]$ echo {
            "instances": [{
                "image_bytes": {
                      "b64": “<BASE64-OF-IMAGE-HERE>”
                }
             }
            ],
            "signature_name": "serving_image_b64string"
} >> sample_request.json

Для большей удобочитаемости добавьте предоставленный Vertex AI идентификатор конечной точки и идентификатор проекта в качестве переменных среды в вашей оболочке. Наконец, мы определяем запрос cURL POST в соответствии со спецификациями в приведенном ниже фрагменте кода.

[suvaditya@fedora ~]$ ENDPOINT_ID="<YOUR-ENDPOINT-ID-HERE>"
PROJECT_ID="YOUR-PROJECT-ID-HERE"
INPUT_DATA_FILE="sample_request.json"

[suvaditya@fedora ~]$ curl \
-X POST \
-H "Authorization: Bearer $(gcloud auth print-access-token)" \
-H "Content-Type: application/json" \
https://us-central1-aiplatform.googleapis.com/v1/projects/${PROJECT_ID}/locations/us-central1/endpoints/${ENDPOINT_ID}:rawPredict \
-d "@${INPUT_DATA_FILE}"

Прогнозы:

То, что вы видите ниже, — это прогнозы формы (1, 1000), которые представляют тензор с выходными показателями достоверности для каждого из 1000 классов ImageNet.

Чего мы достигли?

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

  • Масштаб. Мы сделали решение, которое можно использовать в производственных условиях. Благодаря возможностям Vertex AI и службам автоматического масштабирования и мониторинга вы можете использовать самые современные технологии, чтобы убедиться, что ваша модель развернута максимально эффективно.
  • Возможность интеграции с конвейерами CI/CD.Наше решение можно интегрировать в конвейеры CI/CD благодаря реестру артефактов Google, для чего достаточно просто отправить данные в реестр. Вы можете использовать другие службы GCP (или Vertex AI), которые позволят вам автоматически организовывать обновления.
  • Оптимизация: TF-Serving по своей сути эффективен, что позволяет без проблем обслуживать вашу модель. Из-за низкой задержки и выполнения в графическом режиме вам не о чем беспокоиться о производительности.
  • Модульность.Каждый из этих компонентов легко заменяется или относительно легко ремонтируется по сравнению с более жесткими или неотлаживаемыми продуктами.
  • Отслеживание. Благодаря современным функциям отслеживания эффективность вашей модели находится всего в одном клике. Вы также можете использовать автоматические идеи от Vertex AI.

Куда пойти отсюда?

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

Ниже приведены некоторые интересные справочные ссылки, которые помогут вам глубже изучить мир TensorFlow Serving и Vertex AI.

  1. Руководство по TF-Serving (официальная документация TensorFlow)
  2. Видео Приянки Вергадиа: Ускорьте эксперименты и развертывание машинного обучения с помощью Vertex AI
  3. Архитектура MLOps с использованием GCP
  4. Что такое трансферное обучение?

Справочные документы

  1. Сервис TFX с Docker
  2. Документация по GCP Vertex AI

Благодарности

Спасибо Vaibhav Malpani из GDG Cloud Mumbai за предоставление кредитов GCP, необходимых для запуска демонстрации.

Спасибо Ромину Ирани за возможность опубликовать блог в этом издании.

Спасибо Sayak Paul за то, что направил меня к Vertex AI (очень полезная демонстрация, созданная им, которую я использовал в качестве ориентира: Развертывание ViT на Vertex AI)

Спасибо всем, кто просматривал мои слайды в рамках моего выступления на GDG DevFest Raipur на ту же тему.

Обо мне

Спасибо, что прошлись по этой статье! Я Сувадитья Мукерджи. Следуйте за мной в социальных сетях, чтобы получать больше контента, связанного с глубоким обучением, MLOps и многим другим!

ЛинкедИн

Твиттер

"Середина"