Эта страница переведена с помощью Cloud Translation API.

Vertex AI: используйте пользовательские процедуры прогнозирования со Sklearn для предварительной и последующей обработки данных для прогнозов.

1. Введение

В этой лабораторной работе вы узнаете, как использовать собственные процедуры прогнозирования в Vertex AI для написания собственной логики предварительной и постобработки. Хотя в этом примере используется Scikit-learn, пользовательские процедуры прогнозирования могут работать с другими платформами машинного обучения Python, такими как XGBoost, PyTorch и TensorFlow.

Что вы узнаете

Напишите собственную логику прогнозирования с помощью пользовательских процедур прогнозирования.
Протестируйте пользовательский обслуживающий контейнер и модель локально.
Протестируйте пользовательский обслуживающий контейнер в Vertex AI Predictions

2. Знакомство с Vertex AI

В этой лаборатории используются новейшие продукты искусственного интеллекта, доступные в Google Cloud. Vertex AI интегрирует предложения машинного обучения в Google Cloud в единый процесс разработки. Раньше модели, обученные с помощью AutoML, и пользовательские модели были доступны через отдельные сервисы. Новое предложение объединяет оба API в одном API, а также другие новые продукты. Вы также можете перенести существующие проекты на Vertex AI.

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

3. Обзор вариантов использования

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

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

Введение в пользовательские процедуры прогнозирования

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

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

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

Что ты построишь

Вы настроите сеть VPC под названием aiml-vpc, состоящую из рабочей подсети, используемой для развертывания управляемого пользователем блокнота и доступа к конечной точке онлайн-прогнозирования и модели, развернутой в us-central1, как показано на рисунке 1 ниже.

                                                                            Figure1

4. Включите обучающие API

Шаг 1. Включите API Compute Engine.

Перейдите к Compute Engine и выберите «Включить», если он еще не включен. Это понадобится вам для создания экземпляра блокнота.

Шаг 2. Включите API реестра артефактов.

Перейдите в реестр артефактов и выберите «Включить», если это еще не сделано. Вы будете использовать это для создания пользовательского обслуживающего контейнера.

Шаг 3. Включите API Vertex AI.

Перейдите в раздел Vertex AI в облачной консоли и нажмите «Включить Vertex AI API».

Шаг 4. Создайте экземпляр Vertex AI Workbench.

Включите точку доступа для ноутбуков I, если она еще не включена.

5. Создайте aiml-vpc.

В этом руководстве переменные $variables используются для облегчения реализации конфигурации gcloud в Cloud Shell.

Внутри Cloud Shell выполните следующие действия:

gcloud config list project
gcloud config set project [YOUR-PROJECT-NAME]
projectid=YOUR-PROJECT-NAME
echo $projectid

Создайте aiml-vpc

Внутри Cloud Shell выполните следующие действия:

gcloud compute networks create aiml-vpc --project=$projectid --subnet-mode=custom

Создайте подсеть блокнотов, управляемую пользователем.

Внутри Cloud Shell создайте подсеть рабочей среды.

gcloud compute networks subnets create workbench-subnet --project=$projectid --range=172.16.10.0/28 --network=aiml-vpc --region=us-central1 --enable-private-ip-google-access

Облачный маршрутизатор и конфигурация NAT

Cloud NAT используется в руководстве для загрузки пакетов программного обеспечения, поскольку управляемый пользователем ноутбук не имеет внешнего IP-адреса. Облачный NAT обеспечивает возможности исходящего NAT. Это означает, что интернет-узлам не разрешается инициировать связь с ноутбуком, управляемым пользователем, что делает его более безопасным.

Внутри Cloud Shell создайте региональный облачный маршрутизатор us-central1.

gcloud compute routers create cloud-router-us-central1-aiml-nat --network aiml-vpc --region us-central1

Внутри Cloud Shell создайте региональный облачный шлюз us-central1.

gcloud compute routers nats create cloud-nat-us-central1 --router=cloud-router-us-central1-aiml-nat --auto-allocate-nat-external-ips --nat-all-subnet-ip-ranges --region us-central1

6. Создайте блокнот, управляемый пользователем.

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

В следующем разделе вы создадите управляемую пользователем учетную запись службы, которая будет связана с Vertex Workbench (Notebook), используемым в этом руководстве.

В этом руководстве к учетной записи службы будут применены следующие правила:

В Cloud Shell создайте учетную запись службы.

gcloud iam service-accounts create user-managed-notebook-sa \
    --display-name="user-managed-notebook-sa"

В Cloud Shell обновите учетную запись службы, указав роль администратора хранилища.

gcloud projects add-iam-policy-binding $projectid --member="serviceAccount:user-managed-notebook-sa@$projectid.iam.gserviceaccount.com" --role="roles/storage.admin"

В Cloud Shell обновите учетную запись службы, указав роль пользователя Vertex AI.

gcloud projects add-iam-policy-binding $projectid --member="serviceAccount:user-managed-notebook-sa@$projectid.iam.gserviceaccount.com" --role="roles/aiplatform.user"

В Cloud Shell обновите учетную запись службы, указав роль администратора реестра артефактов.

gcloud projects add-iam-policy-binding $projectid --member="serviceAccount:user-managed-notebook-sa@$projectid.iam.gserviceaccount.com" --role="roles/artifactregistry.admin"

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

gcloud iam service-accounts list

Создайте блокнот, управляемый пользователем.

В следующем разделе создайте управляемый пользователем блокнот, включающий ранее созданную учетную запись службы user-managed-notebook-sa.

Внутри Cloud Shell создайте экземпляр частного клиента.

gcloud notebooks instances create workbench-tutorial \
      --vm-image-project=deeplearning-platform-release \
      --vm-image-family=common-cpu-notebooks \
      --machine-type=n1-standard-4 \
      --location=us-central1-a \
      --shielded-secure-boot \
      --subnet-region=us-central1 \
      --subnet=workbench-subnet \
      --no-public-ip    --service-account=user-managed-notebook-sa@$projectid.iam.gserviceaccount.com

7. Напишите обучающий код

Шаг 1. Создайте корзину облачного хранилища.

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

В панели запуска откройте новый сеанс терминала.

На своем терминале выполните следующую команду, чтобы определить переменную env для вашего проекта, обязательно заменяя your-cloud-project идентификатором вашего проекта:

PROJECT_ID='your-cloud-project'

Затем выполните следующую команду в своем терминале, чтобы создать новую корзину в своем проекте.

BUCKET="gs://${PROJECT_ID}-cpr-bucket"
gsutil mb -l us-central1 $BUCKET

Шаг 2: Модель поезда

В терминале создайте новый каталог с именем cpr-codelab и перейдите в него.

mkdir cpr-codelab
cd cpr-codelab

В браузере файлов перейдите в новый каталог cpr-codelab, а затем с помощью средства запуска создайте новый блокнот Python 3 с именем Task.ipynb.

Ваш каталог cpr-codelab теперь должен выглядеть так:

+ cpr-codelab/
    + task.ipynb

В блокноте вставьте следующий код.

Сначала напишите файл require.txt.

%%writefile requirements.txt
fastapi
uvicorn==0.17.6
joblib~=1.1.1
numpy>=1.17.3, <1.24.0
scikit-learn~=1.0.0
pandas
google-cloud-storage>=2.2.1,<3.0.0dev
google-cloud-aiplatform[prediction]>=1.18.2

В развертываемой вами модели будет предустановлен другой набор зависимостей, чем в среде вашего блокнота. По этой причине вам потребуется перечислить все зависимости модели в файле require.txt, а затем использовать pip для установки тех же зависимостей в блокнот. Позже вы протестируете модель локально перед ее развертыванием в Vertex AI, чтобы дважды проверить соответствие сред.

Pip устанавливает зависимости в блокнот.

!pip install -U --user -r requirements.txt

Обратите внимание, что вам нужно будет перезапустить ядро после завершения установки pip.

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

USER_SRC_DIR = "src_dir"
!mkdir $USER_SRC_DIR
!mkdir model_artifacts

# copy the requirements to the source dir
!cp requirements.txt $USER_SRC_DIR/requirements.txt

Ваш каталог cpr-codelab теперь должен выглядеть так:

+ cpr-codelab/
    + model_artifacts/
    + scr_dir/
        + requirements.txt
    + task.ipynb
    + requirements.txt

Теперь, когда структура каталогов настроена, пришло время обучить модель!

Сначала импортируйте библиотеки.

import seaborn as sns
import numpy as np
import pandas as pd

from sklearn import preprocessing
from sklearn.ensemble import RandomForestRegressor
from sklearn.pipeline import make_pipeline
from sklearn.compose import make_column_transformer

import joblib
import logging

# set logging to see the docker container logs
logging.basicConfig(level=logging.INFO)

Затем определите следующие переменные. Обязательно замените PROJECT_ID идентификатором вашего проекта, а BUCKET_NAME — сегментом, созданным на предыдущем шаге.

REGION = "us-central1"
MODEL_ARTIFACT_DIR = "sklearn-model-artifacts"
REPOSITORY = "diamonds"
IMAGE = "sklearn-image"
MODEL_DISPLAY_NAME = "diamonds-cpr"

# Replace with your project
PROJECT_ID = "{PROJECT_ID}"

# Replace with your bucket
BUCKET_NAME = "gs://{BUCKET_NAME}"

Загрузите данные из библиотеки seaborn, а затем создайте два фрейма данных: один с объектами, а другой с меткой.

data = sns.load_dataset('diamonds', cache=True, data_home=None)

label = 'price'

y_train = data['price']
x_train = data.drop(columns=['price'])

Давайте посмотрим на данные обучения. Вы можете видеть, что каждая строка представляет собой ромб.

x_train.head()

И этикетки с соответствующими ценами.

y_train.head()

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

column_transform = make_column_transformer(
    (preprocessing.OneHotEncoder(sparse=False), [1,2,3]),
    (preprocessing.StandardScaler(), [0,4,5,6,7,8]))

Определите модель случайного леса

regr = RandomForestRegressor(max_depth=10, random_state=0)

Далее делаем sklearn-конвейер . Это означает, что данные, подаваемые в этот конвейер, сначала будут закодированы/масштабированы, а затем переданы в модель.

my_pipeline = make_pipeline(column_transform, regr)

Подгоните конвейер к обучающим данным

my_pipeline.fit(x_train, y_train)

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

my_pipeline.predict([[0.23, 'Ideal', 'E', 'SI2', 61.5, 55.0, 3.95, 3.98, 2.43]])

Теперь мы можем сохранить конвейер в каталоге model_artifacts и скопировать его в корзину Cloud Storage.

joblib.dump(my_pipeline, 'model_artifacts/model.joblib')

!gsutil cp model_artifacts/model.joblib {BUCKET_NAME}/{MODEL_ARTIFACT_DIR}/

Шаг 3. Сохраните артефакт предварительной обработки

Далее вы создадите артефакт предварительной обработки. Этот артефакт будет загружен в пользовательский контейнер при запуске сервера модели. Артефакт предварительной обработки может иметь практически любую форму (например, файл рассола), но в этом случае вы запишете словарь в файл JSON.

clarity_dict={"Flawless": "FL",
              "Internally Flawless": "IF",
              "Very Very Slightly Included": "VVS1",
              "Very Slightly Included": "VS2",
              "Slightly Included": "S12",
              "Included": "I3"}

Показатель ясности в наших тренировочных данных всегда был в сокращенной форме (т. е. «FL» вместо «Безупречный»). Во время обслуживания мы хотим проверить, что данные для этой функции также сокращены. Это потому, что наша модель умеет горячо кодировать «FL», но не «Безупречно». Эту пользовательскую логику предварительной обработки вы напишете позже. А пока просто сохраните эту таблицу поиска в файле JSON, а затем запишите ее в корзину Cloud Storage.

import json
with open("model_artifacts/preprocessor.json", "w") as f:
    json.dump(clarity_dict, f)

!gsutil cp model_artifacts/preprocessor.json {BUCKET_NAME}/{MODEL_ARTIFACT_DIR}/

Ваш локальный каталог cpr-codelab теперь должен выглядеть так:

+ cpr-codelab/
    + model_artifacts/
        + model.joblib
        + preprocessor.json
    + scr_dir/
        + requirements.txt
    + task.ipynb
    + requirements.txt

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

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

Пользовательский обслуживающий контейнер содержит следующие три фрагмента кода:

Сервер модели (он будет создан автоматически SDK и сохранен в scr_dir/)

HTTP-сервер, на котором размещена модель
Отвечает за настройку маршрутов/портов/и т.д.

Обработчик запросов

Отвечает за аспекты обработки запроса веб-сервером, такие как десериализация тела запроса и сериализация ответа, установка заголовков ответа и т. д.
В этом примере вы будете использовать обработчик по умолчанию google.cloud.aiplatform.prediction.handler.PredictionHandler, предоставленный в SDK.

Предсказатель

Отвечает за логику ML для обработки запроса прогнозирования.

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

Предиктор отвечает за логику машинного обучения для обработки запроса прогнозирования, например пользовательскую предварительную и постобработку. Чтобы написать собственную логику прогнозирования, вы создадите подкласс интерфейса Vertex AI Predictor.

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

Ниже вы можете увидеть пример предиктора Sklearn . Это весь код, который вам нужно будет написать для создания сервера собственной модели.

Вставьте в свой блокнот приведенный ниже код, чтобы создать подкласс SklearnPredictor, и запишите его в файл Python в каталоге src_dir/. Обратите внимание, что в этом примере мы настраиваем только методы загрузки, предварительной обработки и постобработки, но не метод прогнозирования.

%%writefile $USER_SRC_DIR/predictor.py

import joblib
import numpy as np
import json

from google.cloud import storage
from google.cloud.aiplatform.prediction.sklearn.predictor import SklearnPredictor


class CprPredictor(SklearnPredictor):

    def __init__(self):
        return

    def load(self, artifacts_uri: str) -> None:
        """Loads the sklearn pipeline and preprocessing artifact."""

        super().load(artifacts_uri)

        # open preprocessing artifact
        with open("preprocessor.json", "rb") as f:
            self._preprocessor = json.load(f)


    def preprocess(self, prediction_input: np.ndarray) -> np.ndarray:
        """Performs preprocessing by checking if clarity feature is in abbreviated form."""

        inputs = super().preprocess(prediction_input)

        for sample in inputs:
            if sample[3] not in self._preprocessor.values():
                sample[3] = self._preprocessor[sample[3]]
        return inputs

    def postprocess(self, prediction_results: np.ndarray) -> dict:
        """Performs postprocessing by rounding predictions and converting to str."""

        return {"predictions": [f"${value}" for value in np.round(prediction_results)]}

Давайте более подробно рассмотрим каждый из этих методов.

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

Затем используйте Vertex AI Python SDK для создания образа. Используя пользовательские процедуры прогнозирования, будет сгенерирован Dockerfile и для вас будет создан образ.

from google.cloud import aiplatform

aiplatform.init(project=PROJECT_ID, location=REGION)

import os

from google.cloud.aiplatform.prediction import LocalModel

from src_dir.predictor import CprPredictor  # Should be path of variable $USER_SRC_DIR

local_model = LocalModel.build_cpr_model(
    USER_SRC_DIR,
    f"{REGION}-docker.pkg.dev/{PROJECT_ID}/{REPOSITORY}/{IMAGE}",
    predictor=CprPredictor,
    requirements_path=os.path.join(USER_SRC_DIR, "requirements.txt"),
)

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

import json

sample = {"instances": [
  [0.23, 'Ideal', 'E', 'VS2', 61.5, 55.0, 3.95, 3.98, 2.43],
  [0.29, 'Premium', 'J', 'Internally Flawless', 52.5, 49.0, 4.00, 2.13, 3.11]]}

with open('instances.json', 'w') as fp:
    json.dump(sample, fp)

Протестируйте контейнер локально, развернув локальную модель.

with local_model.deploy_to_local_endpoint(
    artifact_uri = 'model_artifacts/', # local path to artifacts
) as local_endpoint:
    predict_response = local_endpoint.predict(
        request_file='instances.json',
        headers={"Content-Type": "application/json"},
    )

    health_check_response = local_endpoint.run_health_check()

Посмотреть результаты прогноза можно с помощью:

predict_response.content

9. Развертывание модели в Vertex AI.

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

Сначала настройте Docker для доступа к реестру артефактов.

!gcloud artifacts repositories create {REPOSITORY} --repository-format=docker \
--location=us-central1 --description="Docker repository"

!gcloud auth configure-docker {REGION}-docker.pkg.dev --quiet

Затем нажмите на изображение.

local_model.push_image()

И загрузите модель.

model = aiplatform.Model.upload(local_model = local_model,
                                display_name=MODEL_DISPLAY_NAME,
                                artifact_uri=f"{BUCKET_NAME}/{MODEL_ARTIFACT_DIR}",)

Когда модель будет загружена, вы должны увидеть ее в консоли:

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