1. Обзор
В этой лабораторной работе вы используете Vertex AI для создания конвейера обучения пользовательской модели Keras в TensorFlow. Затем мы воспользуемся новыми функциями, доступными в Vertex AI Experiments, для отслеживания и сравнения результатов работы модели, чтобы определить, какая комбинация гиперпараметров обеспечивает наилучшую производительность.
Чему вы научитесь
Вы научитесь:
- Обучите собственную модель Keras для прогнозирования рейтингов игроков (например, с помощью регрессии).
- Используйте SDK Kubeflow Pipelines для создания масштабируемых конвейеров машинного обучения.
- Создайте и запустите пятиэтапный конвейер, который будет получать данные из облачного хранилища, масштабировать данные, обучать модель, оценивать ее и сохранять полученную модель обратно в облачное хранилище.
- Используйте метаданные Vertex ML для сохранения артефактов модели, таких как модели и метрики модели.
- Используйте Vertex AI Experiments для сравнения результатов различных запусков конвейера обработки данных.
Общая стоимость запуска этой лабораторной работы в Google Cloud составляет около 1 доллара .
2. Введение в Vertex AI
В этой лабораторной работе используется новейший продукт для искусственного интеллекта, доступный в Google Cloud. Vertex AI интегрирует предложения машинного обучения в Google Cloud в единый процесс разработки. Ранее модели, обученные с помощью AutoML, и пользовательские модели были доступны через отдельные сервисы. Новое предложение объединяет оба варианта в единый API, а также включает другие новые продукты. Вы также можете перенести существующие проекты в Vertex AI.
Vertex AI предлагает множество различных продуктов для поддержки комплексных рабочих процессов машинного обучения. В этой лабораторной работе мы сосредоточимся на продуктах, перечисленных ниже: Experiments , Pipelines , ML Metadata и Workbench.
3. Обзор вариантов использования
Мы будем использовать популярный набор данных по футболу, взятый из серии видеоигр FIFA от EA Sports . Он включает более 25 000 футбольных матчей и более 10 000 игроков за сезоны 2008-2016 годов. Данные предварительно обработаны, поэтому вы сможете сразу же приступить к работе. Вы будете использовать этот набор данных на протяжении всего лабораторного занятия, и теперь он находится в общедоступном хранилище Cloud Storage. Более подробную информацию о том, как получить доступ к набору данных, мы предоставим позже в этом практическом занятии. Наша конечная цель — предсказать общий рейтинг игрока на основе различных действий в игре, таких как перехваты и пенальти.
Почему Vertex AI Experiments полезен для анализа данных?
Наука о данных по своей природе экспериментальна — в конце концов, таких специалистов называют учеными. Хорошие специалисты по данным руководствуются гипотезами, используя метод проб и ошибок для проверки различных гипотез в надежде, что последующие итерации приведут к созданию более эффективной модели.
Хотя команды специалистов по анализу данных активно используют эксперименты, им часто бывает сложно отслеживать свою работу и «секретный ингредиент», обнаруженный в ходе этих экспериментов. Это происходит по нескольким причинам:
- Отслеживание результатов обучения может стать сложной задачей, из-за чего легко упустить из виду, что работает, а что нет.
- Эта проблема усугубляется, если рассматривать ситуацию в масштабах всей команды специалистов по анализу данных, поскольку не все ее члены могут отслеживать эксперименты или даже делиться своими результатами с другими.
- Сбор данных занимает много времени, и большинство команд используют ручные методы (например, таблицы или документы), что приводит к получению противоречивой и неполной информации, из которой трудно извлечь уроки.
Вкратце: Vertex AI Experiments делает всю работу за вас, помогая вам проще отслеживать и сравнивать результаты ваших экспериментов.
Почему Vertex AI проводит эксперименты в игровой индустрии?
Игровая индустрия исторически являлась площадкой для экспериментов в области машинного обучения и машинного обучения. Игры не только генерируют миллиарды событий в реальном времени ежедневно, но и используют все эти данные, применяя машинное обучение и эксперименты в этой области для улучшения игрового процесса, удержания игроков и оценки различных пользователей на своей платформе. Поэтому мы решили, что игровой набор данных хорошо подходит для нашего общего эксперимента.
4. Настройте свою среду.
Для выполнения этого практического задания вам потребуется проект Google Cloud Platform с включенной оплатой. Чтобы создать проект, следуйте инструкциям здесь .
Шаг 1: Включите API Compute Engine.
Перейдите в раздел Compute Engine и выберите «Включить», если эта функция еще не включена.
Шаг 2: Включите API Vertex AI
Перейдите в раздел Vertex AI в вашей облачной консоли и нажмите «Включить API Vertex AI» .
Шаг 3: Создайте экземпляр Vertex AI Workbench.
В разделе Vertex AI вашей облачной консоли нажмите на Workbench:
Включите API для блокнотов, если он еще не включен.
После включения нажмите «УПРАВЛЯЕМЫЕ ЗАПИСНЫЕ КНИЖКИ» :
Затем выберите «Создать новый блокнот» .
Присвойте своему блокноту имя, а затем нажмите «Дополнительные настройки» .
В разделе «Дополнительные настройки» включите функцию автоматического выключения в режиме ожидания и установите количество минут равным 60. Это означает, что ваш ноутбук будет автоматически выключаться, когда не используется, чтобы избежать лишних расходов.
Шаг 4: Откройте свой блокнот
После создания экземпляра выберите «Открыть JupyterLab» .
Шаг 5: Аутентификация (только при первом прохождении)
При первом использовании нового экземпляра вам будет предложено пройти аутентификацию. Для этого следуйте инструкциям в пользовательском интерфейсе.
Шаг 6: Выберите подходящее ядро.
Managed-notebooks предоставляет несколько ядер в одном пользовательском интерфейсе. Выберите ядро для Tensorflow 2 (локальное).
5. Начальные шаги настройки вашего ноутбука
Перед созданием конвейера вам потребуется выполнить ряд дополнительных шагов для настройки среды в вашем ноутбуке. Эти шаги включают в себя: установку дополнительных пакетов, настройку переменных, создание хранилища в облаке, копирование игрового набора данных из общедоступного хранилища, а также импорт библиотек и определение дополнительных констант.
Шаг 1: Установка дополнительных пакетов
Нам потребуется установить дополнительные пакеты-зависимости, которые в данный момент не установлены в вашей среде ноутбука. Например, это может быть KFP SDK.
!pip3 install --user --force-reinstall 'google-cloud-aiplatform>=1.15' -q --no-warn-conflicts
!pip3 install --user kfp -q --no-warn-conflicts
После этого вам потребуется перезапустить ядро ноутбука, чтобы вы могли использовать загруженные пакеты в своем ноутбуке.
# Automatically restart kernel after installs
import os
if not os.getenv("IS_TESTING"):
# Automatically restart kernel after installs
import IPython
app = IPython.Application.instance()
app.kernel.do_shutdown(True)
Шаг 2: Установка переменных
Нам нужно определить наш PROJECT_ID . Если вы не знаете свой Project_ID , вы можете получить PROJECT_ID с помощью gcloud.
import os
PROJECT_ID = ""
# Get your Google Cloud project ID from gcloud
if not os.getenv("IS_TESTING"):
shell_output = !gcloud config list --format 'value(core.project)' 2>/dev/null
PROJECT_ID = shell_output[0]
print("Project ID: ", PROJECT_ID)
В противном случае укажите здесь свой PROJECT_ID .
if PROJECT_ID == "" or PROJECT_ID is None:
PROJECT_ID = "[your-project-id]" # @param {type:"string"}
Нам также потребуется установить переменную REGION , которая будет использоваться на протяжении всего остального блокнота. Ниже перечислены регионы, поддерживаемые Vertex AI. Мы рекомендуем выбрать регион, ближайший к вам.
- Америка: центральная Америка
- Европа: europe-west4
- Азиатско-Тихоокеанский регион: Азия-Восток1
Пожалуйста, не используйте мультирегиональный сегмент для обучения с помощью Vertex AI. Не все регионы поддерживают все сервисы Vertex AI. Узнайте больше о регионах Vertex AI .
#set your region
REGION = "us-central1" # @param {type: "string"}
Наконец, мы установим переменную TIMESTAMP . Эта переменная используется для предотвращения конфликтов имен между пользователями при создании ресурсов. Вы создаете переменную TIMESTAMP для каждой сессии экземпляра и добавляете ее к имени ресурсов, создаваемых в этом руководстве.
#set timestamp to avoid collisions between multiple users
from datetime import datetime
TIMESTAMP = datetime.now().strftime("%Y%m%d%H%M%S")
Шаг 3: Создайте сегмент облачного хранилища.
Вам потребуется указать и использовать временный сегмент Cloud Storage. В этом сегменте хранятся все данные, связанные с вашим набором данных и ресурсами модели, между сессиями.
Укажите ниже имя вашего сегмента Cloud Storage. Имена сегментов должны быть уникальными во всех проектах Google Cloud, включая те, которые находятся за пределами вашей организации.
#set cloud storage bucket
BUCKET_NAME = "[insert bucket name here]" # @param {type:"string"}
BUCKET_URI = f"gs://{BUCKET_NAME}"
Если ваш сегмент хранилища ЕЩЕ НЕ существует, вы можете запустить следующую ячейку, чтобы создать свой сегмент Cloud Storage.
! gsutil mb -l $REGION -p $PROJECT_ID $BUCKET_URI
Затем вы можете проверить доступ к своему облачному хранилищу, запустив следующую ячейку.
#verify access
! gsutil ls -al $BUCKET_URI
Шаг 4: Скопируйте наш игровой набор данных.
Как уже упоминалось ранее, вы будете использовать популярный игровой набор данных из хитовых видеоигр EA Sports — FIFA. Мы уже выполнили предварительную обработку, поэтому вам останется только скопировать набор данных из общедоступного хранилища и переместить его в созданное вами хранилище.
# copy the data over to your cloud storage bucket
DATASET_URI = "gs://cloud-samples-data/vertex-ai/structured_data/player_data"
!gsutil cp -r $DATASET_URI $BUCKET_URI
Шаг 5: Импорт библиотек и определение дополнительных констант
Далее нам потребуется импортировать наши библиотеки для Vertex AI, KFP и так далее.
import logging
import os
import time
logger = logging.getLogger("logger")
logging.basicConfig(level=logging.INFO)
import kfp.v2.compiler as compiler
# Pipeline Experiments
import kfp.v2.dsl as dsl
# Vertex AI
from google.cloud import aiplatform as vertex_ai
from kfp.v2.dsl import Artifact, Input, Metrics, Model, Output, component
from typing import NamedTuple
Мы также определим дополнительные константы, на которые будем ссылаться на протяжении всего остального блокнота, например, путь(и) к файлам с обучающими данными.
#import libraries and define constants
# Experiments
TASK = "regression"
MODEL_TYPE = "tensorflow"
EXPERIMENT_NAME = f"{PROJECT_ID}-{TASK}-{MODEL_TYPE}-{TIMESTAMP}"
# Pipeline
PIPELINE_URI = f"{BUCKET_URI}/pipelines"
TRAIN_URI = f"{BUCKET_URI}/player_data/data.csv"
LABEL_URI = f"{BUCKET_URI}/player_data/labels.csv"
MODEL_URI = f"{BUCKET_URI}/model"
DISPLAY_NAME = "experiments-demo-gaming-data"
BQ_DATASET = "player_data"
BQ_LOCATION = "US"
VIEW_NAME = 'dataset_test'
PIPELINE_JSON_PKG_PATH = "experiments_demo_gaming_data.json"
PIPELINE_ROOT = f"gs://{BUCKET_URI}/pipeline_root"
6. Давайте создадим наш конвейер обработки данных.
Теперь начинается самое интересное, и мы можем начать использовать Vertex AI для создания нашего конвейера обучения. Мы инициализируем SDK Vertex AI, настроим задачу обучения как компонент конвейера, создадим наш конвейер, запустим его (или несколько запусков) и будем использовать SDK Vertex AI для просмотра экспериментов и мониторинга их статуса.
Шаг 1: Инициализация Vertex AI SDK
Инициализируйте SDK Vertex AI, задав значения PROJECT_ID и BUCKET_URI .
#initialize vertex AI SDK
vertex_ai.init(project=PROJECT_ID, staging_bucket=BUCKET_URI)
Шаг 2: Настройте нашу задачу обучения как компонент конвейера.
Для начала проведения экспериментов нам необходимо определить задачу обучения, задав её в качестве компонента конвейера. Наш конвейер будет принимать на вход обучающие данные и гиперпараметры (например, DROPOUT_RATE , LEARNING_RATE , EPOCHS ), а на выходе — метрики модели (например, MAE и RMSE ) и артефакт модели.
@component(
packages_to_install=[
"numpy==1.21.0",
"pandas==1.3.5",
"scikit-learn==1.0.2",
"tensorflow==2.9.0",
]
)
def custom_trainer(
train_uri: str,
label_uri: str,
dropout_rate: float,
learning_rate: float,
epochs: int,
model_uri: str,
metrics: Output[Metrics],
model_metadata: Output[Model],
):
# import libraries
import logging
import uuid
from pathlib import Path as path
import pandas as pd
import tensorflow as tf
from tensorflow import keras
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense
from tensorflow.keras.layers import Dropout
from tensorflow.keras.metrics import Metric
from sklearn.metrics import accuracy_score
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.metrics import mean_absolute_error
import numpy as np
from math import sqrt
import os
import tempfile
# set variables and use gcsfuse to update prefixes
gs_prefix = "gs://"
gcsfuse_prefix = "/gcs/"
train_path = train_uri.replace(gs_prefix, gcsfuse_prefix)
label_path = label_uri.replace(gs_prefix, gcsfuse_prefix)
model_path = model_uri.replace(gs_prefix, gcsfuse_prefix)
def get_logger():
logger = logging.getLogger(__name__)
logger.setLevel(logging.INFO)
handler = logging.StreamHandler()
handler.setFormatter(
logging.Formatter("%(asctime)s - %(name)s - %(levelname)s - %(message)s")
)
logger.addHandler(handler)
return logger
def get_data(
train_path: str,
label_path: str
) -> (pd.DataFrame):
#load data into pandas dataframe
data_0 = pd.read_csv(train_path)
labels_0 = pd.read_csv(label_path)
#drop unnecessary leading columns
data = data_0.drop('Unnamed: 0', axis=1)
labels = labels_0.drop('Unnamed: 0', axis=1)
#save as numpy array for reshaping of data
labels = labels.values
data = data.values
# Split the data
labels = labels.reshape((labels.size,))
train_data, test_data, train_labels, test_labels = train_test_split(data, labels, test_size=0.2, shuffle=True, random_state=7)
#Convert data back to pandas dataframe for scaling
train_data = pd.DataFrame(train_data)
test_data = pd.DataFrame(test_data)
train_labels = pd.DataFrame(train_labels)
test_labels = pd.DataFrame(test_labels)
#Scale and normalize the training dataset
scaler = StandardScaler()
scaler.fit(train_data)
train_data = pd.DataFrame(scaler.transform(train_data), index=train_data.index, columns=train_data.columns)
test_data = pd.DataFrame(scaler.transform(test_data), index=test_data.index, columns=test_data.columns)
return train_data,train_labels, test_data, test_labels
""" Train your Keras model passing in the training data and values for learning rate, dropout rate,and the number of epochs """
def train_model(
learning_rate: float,
dropout_rate: float,
epochs: float,
train_data: pd.DataFrame,
train_labels: pd.DataFrame):
# Train tensorflow model
param = {"learning_rate": learning_rate, "dropout_rate": dropout_rate, "epochs": epochs}
model = Sequential()
model.add(Dense(500, input_dim=train_data.shape[1], activation= "relu"))
model.add(Dropout(param['dropout_rate']))
model.add(Dense(100, activation= "relu"))
model.add(Dense(50, activation= "relu"))
model.add(Dense(1))
model.compile(
tf.keras.optimizers.Adam(learning_rate= param['learning_rate']),
loss='mse',
metrics=[tf.keras.metrics.RootMeanSquaredError(),tf.keras.metrics.MeanAbsoluteError()])
model.fit(train_data, train_labels, epochs= param['epochs'])
return model
# Get Predictions
def get_predictions(model, test_data):
dtest = pd.DataFrame(test_data)
pred = model.predict(dtest)
return pred
# Evaluate predictions with MAE
def evaluate_model_mae(pred, test_labels):
mae = mean_absolute_error(test_labels, pred)
return mae
# Evaluate predictions with RMSE
def evaluate_model_rmse(pred, test_labels):
rmse = np.sqrt(np.mean((test_labels - pred)**2))
return rmse
#Save your trained model in GCS
def save_model(model, model_path):
model_id = str(uuid.uuid1())
model_path = f"{model_path}/{model_id}"
path(model_path).parent.mkdir(parents=True, exist_ok=True)
model.save(model_path + '/model_tensorflow')
# Main ----------------------------------------------
train_data, train_labels, test_data, test_labels = get_data(train_path, label_path)
model = train_model(learning_rate, dropout_rate, epochs, train_data,train_labels )
pred = get_predictions(model, test_data)
mae = evaluate_model_mae(pred, test_labels)
rmse = evaluate_model_rmse(pred, test_labels)
save_model(model, model_path)
# Metadata ------------------------------------------
#convert numpy array to pandas series
mae = pd.Series(mae)
rmse = pd.Series(rmse)
#log metrics and model artifacts with ML Metadata. Save metrics as a list.
metrics.log_metric("mae", mae.to_list())
metrics.log_metric("rmse", rmse.to_list())
model_metadata.uri = model_uri
Шаг 3: Создание нашего конвейера обработки данных
Теперь мы настроим наш рабочий процесс, используя Domain Specific Language (DSL) , доступный в KFP, и скомпилируем наш конвейер в файл JSON .
# define our workflow
@dsl.pipeline(name="gaming-custom-training-pipeline")
def pipeline(
train_uri: str,
label_uri: str,
dropout_rate: float,
learning_rate: float,
epochs: int,
model_uri: str,
):
custom_trainer(
train_uri,label_uri, dropout_rate,learning_rate,epochs, model_uri
)
#compile our pipeline
compiler.Compiler().compile(pipeline_func=pipeline, package_path="gaming_pipeline.json")
Шаг 4: Отправьте результаты выполнения нашего конвейера обработки данных.
Основная работа по настройке компонента и определению конвейера завершена. Мы готовы запустить несколько вариантов выполнения указанного выше конвейера. Для этого нам потребуется определить значения для различных гиперпараметров следующим образом:
runs = [
{"dropout_rate": 0.001, "learning_rate": 0.001,"epochs": 20},
{"dropout_rate": 0.002, "learning_rate": 0.002,"epochs": 25},
{"dropout_rate": 0.003, "learning_rate": 0.003,"epochs": 30},
{"dropout_rate": 0.004, "learning_rate": 0.004,"epochs": 35},
{"dropout_rate": 0.005, "learning_rate": 0.005,"epochs": 40},
]
После определения гиперпараметров мы можем использовать for loop для успешной передачи данных между различными этапами конвейера:
for i, run in enumerate(runs):
job = vertex_ai.PipelineJob(
display_name=f"{EXPERIMENT_NAME}-pipeline-run-{i}",
template_path="gaming_pipeline.json",
pipeline_root=PIPELINE_URI,
parameter_values={
"train_uri": TRAIN_URI,
"label_uri": LABEL_URI,
"model_uri": MODEL_URI,
**run,
},
)
job.submit(experiment=EXPERIMENT_NAME)
Шаг 5: Используйте SDK Vertex AI для просмотра экспериментов.
SDK Vertex AI позволяет отслеживать состояние выполнения конвейеров. Вы также можете использовать его для получения параметров и метрик выполнения конвейеров в эксперименте Vertex AI. Используйте следующий код, чтобы увидеть параметры, связанные с вашими запусками, и их текущее состояние.
# see state/status of all the pipeline runs
vertex_ai.get_experiment_df(EXPERIMENT_NAME)
Вы можете использовать приведенный ниже код для получения обновлений о статусе выполнения ваших конвейеров.
#check on current status
while True:
pipeline_experiments_df = vertex_ai.get_experiment_df(EXPERIMENT_NAME)
if all(
pipeline_state != "COMPLETE" for pipeline_state in pipeline_experiments_df.state
):
print("Pipeline runs are still running...")
if any(
pipeline_state == "FAILED"
for pipeline_state in pipeline_experiments_df.state
):
print("At least one Pipeline run failed")
break
else:
print("Pipeline experiment runs have completed")
break
time.sleep(60)
Вы также можете вызывать конкретные задания конвейера, используя параметр run_name .
# Call the pipeline runs based on the experiment run name
pipeline_experiments_df = vertex_ai.get_experiment_df(EXPERIMENT_NAME)
job = vertex_ai.PipelineJob.get(pipeline_experiments_df.run_name[0])
print(job.resource_name)
print(job._dashboard_uri())
Наконец, вы можете обновлять состояние своих запусков через заданные интервалы (например, каждые 60 секунд), чтобы увидеть, как состояния меняются с RUNNING на FAILED или COMPLETE .
# wait 60 seconds and view state again
import time
time.sleep(60)
vertex_ai.get_experiment_df(EXPERIMENT_NAME)
7. Определите наиболее успешный заезд.
Отлично, теперь у нас есть результаты выполнения нашего конвейера. Возможно, вы спросите, что я могу узнать из этих результатов? Выходные данные ваших экспериментов должны содержать пять строк, по одной для каждого запуска конвейера. Это будет выглядеть примерно так:
И MAE, и RMSE измеряют среднюю ошибку прогнозирования модели, поэтому в большинстве случаев желательно более низкое значение для обеих метрик. Как видно из результатов экспериментов Vertex AI, наиболее успешным по обеим метрикам оказался заключительный запуск с dropout_rate 0,001, learning_rate 0,001 и общим количеством epochs 20. На основе этого эксперимента можно сделать вывод, что эти параметры модели будут использоваться в производственной среде, поскольку они обеспечивают наилучшую производительность модели.
На этом лабораторная работа завершена!
🎉 Поздравляем! 🎉
Вы научились использовать Vertex AI для:
- Обучите собственную модель Keras для прогнозирования рейтингов игроков (например, с помощью регрессии).
- Используйте SDK Kubeflow Pipelines для создания масштабируемых конвейеров машинного обучения.
- Создайте и запустите пятиэтапный конвейер, который будет получать данные из GCS, масштабировать данные, обучать модель, оценивать её и сохранять полученную модель обратно в GCS.
- Используйте метаданные Vertex ML для сохранения артефактов модели, таких как модели и метрики модели.
- Используйте Vertex AI Experiments для сравнения результатов различных запусков конвейера обработки данных.
Чтобы узнать больше о различных компонентах Vertex, ознакомьтесь с документацией .
8. Уборка
Чтобы избежать списания средств, рекомендуется удалить ресурсы, созданные в ходе этой лабораторной работы.
Шаг 1: Остановите или удалите свой экземпляр Notebooks.
Если вы хотите продолжить использовать созданный в этой лабораторной работе блокнот, рекомендуется выключать его, когда он не используется. В интерфейсе блокнотов в вашей облачной консоли выберите блокнот, а затем выберите «Остановить» . Если вы хотите полностью удалить экземпляр, выберите «Удалить» .
Шаг 2: Удалите свой сегмент облачного хранилища.
Чтобы удалить сегмент хранилища, воспользуйтесь меню навигации в консоли Cloud Console, перейдите в раздел «Хранилище», выберите свой сегмент и нажмите «Удалить».
