Vertex AI Workbench: обучение модели TensorFlow с данными из BigQuery

1. Обзор

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

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

Вы узнаете, как:

• Создайте и настройте экземпляр Vertex AI Workbench.
• Используйте коннектор Vertex AI Workbench BigQuery.
• Обучение модели на ядре Vertex AI Workbench

Общая стоимость запуска этой лаборатории в Google Cloud составляет около 1 доллара США .

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

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

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

Vertex AI Workbench помогает пользователям быстро создавать комплексные рабочие процессы на базе ноутбуков благодаря глубокой интеграции со службами данных (такими как Dataproc, Dataflow, BigQuery и Dataplex) и Vertex AI. Оно позволяет ученым, работающим с данными, подключаться к сервисам данных GCP, анализировать наборы данных, экспериментировать с различными методами моделирования, развертывать обученные модели в производстве и управлять MLOps на протяжении всего жизненного цикла модели.

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

В этой лабораторной работе вы изучите набор данных о прокате велосипедов в Лондоне . Эти данные содержат информацию о велосипедных поездках в рамках общественной программы совместного использования велосипедов в Лондоне с 2011 года. Вы начнете с изучения этого набора данных в BigQuery через коннектор Vertex AI Workbench BigQuery. Затем вы загрузите данные в Jupyter Notebook с помощью pandas и обучите модель TensorFlow прогнозировать продолжительность велосипедной поездки на основе того, когда произошла поездка и как далеко человек проехал на велосипеде.

В этой лаборатории используются слои предварительной обработки Keras для преобразования и подготовки входных данных для обучения модели. Этот API позволяет вам встраивать предварительную обработку непосредственно в граф вашей модели TensorFlow, снижая риск неравномерности обучения/обслуживания, гарантируя, что данные обучения и обслуживания подвергаются идентичным преобразованиям. Обратите внимание, что начиная с TensorFlow 2.6 этот API стабилен. Если вы используете более старую версию TensorFlow, вам необходимо импортировать экспериментальный символ .

4. Настройте свою среду

Для запуска этой лаборатории кода вам понадобится проект Google Cloud Platform с включенной оплатой. Чтобы создать проект, следуйте инструкциям здесь .

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

Перейдите к Compute Engine и выберите «Включить» , если он еще не включен.

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

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

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

В разделе Vertex AI облачной консоли нажмите Workbench:

Включите API ноутбуков, если это еще не сделано.

После включения нажмите «УПРАВЛЯЕМЫЕ НОУТБУКЫ» :

Затем выберите НОВЫЙ НОУТБУК .

Дайте своему блокноту имя и в разделе «Разрешения» выберите «Учетная запись службы».

Выберите Дополнительные настройки .

В разделе «Безопасность» выберите «Включить терминал», если он еще не включен.

Все остальные дополнительные настройки вы можете оставить как есть.

Далее нажмите Создать .

После создания экземпляра выберите OPEN JUPYTERLAB .

5. Изучите набор данных в BigQuery.

В экземпляре Vertex AI Workbench перейдите влево и щелкните коннектор BigQuery in Notebooks .

Соединитель BigQuery позволяет легко исследовать наборы данных BigQuery и запрашивать их. Помимо любых наборов данных в вашем проекте, вы можете просмотреть наборы данных в других проектах, нажав кнопку «Добавить проект» .

Для этой лабораторной работы вы будете использовать данные из общедоступных наборов данных BigQuery. Прокрутите вниз, пока не найдете набор данных london_bicycles . Вы увидите, что этот набор данных состоит из двух таблиц: Cycl_hire и Cycl_stations . Давайте рассмотрим каждый из них.

Сначала дважды щелкните таблицу Cycl_hire . Вы увидите, что таблица откроется как новая вкладка со схемой таблицы, а также метаданными, такими как количество строк и размер.

Если вы нажмете на вкладку «Предварительный просмотр» , вы сможете увидеть образец данных. Давайте выполним простой запрос, чтобы узнать, какие поездки наиболее популярны. Сначала нажмите кнопку Запросить таблицу .

Затем вставьте следующее в редактор SQL и нажмите «Отправить запрос» .

SELECT
  start_station_name,
  end_station_name,
  IF(start_station_name = end_station_name,
    TRUE,
    FALSE) same_station,
  AVG(duration) AS avg_duration,
  COUNT(*) AS total_rides
FROM
  `bigquery-public-data.london_bicycles.cycle_hire`
GROUP BY
  start_station_name,
  end_station_name,
  same_station
ORDER BY
  total_rides DESC

Из результатов запроса вы увидите, что наибольшей популярностью пользовались велосипедные поездки на станцию ​​Hyde Park Corner и обратно.

Затем дважды щелкните таблицу Cycl_stations , в которой представлена ​​информация о каждой станции.

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

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

Скопируйте следующий запрос в редактор SQL и нажмите «Отправить запрос». Обратите внимание, что в условии JOIN есть три таблицы, поскольку нам нужно дважды соединить таблицу станций, чтобы получить широту/долготу как для начальной, так и для конечной станции цикла.

WITH staging AS (
    SELECT
        STRUCT(
            start_stn.name,
            ST_GEOGPOINT(start_stn.longitude, start_stn.latitude) AS POINT,
            start_stn.docks_count,
            start_stn.install_date
        ) AS starting,
        STRUCT(
            end_stn.name,
            ST_GEOGPOINT(end_stn.longitude, end_stn.latitude) AS point,
            end_stn.docks_count,
            end_stn.install_date
        ) AS ending,
        STRUCT(
            rental_id,
            bike_id,
            duration, --seconds
            ST_DISTANCE(
                ST_GEOGPOINT(start_stn.longitude, start_stn.latitude),
                ST_GEOGPOINT(end_stn.longitude, end_stn.latitude)
            ) AS distance, --meters
            start_date,
            end_date
        ) AS bike
        FROM `bigquery-public-data.london_bicycles.cycle_stations` AS start_stn
        LEFT JOIN `bigquery-public-data.london_bicycles.cycle_hire` as b
        ON start_stn.id = b.start_station_id
        LEFT JOIN `bigquery-public-data.london_bicycles.cycle_stations` AS end_stn
        ON end_stn.id = b.end_station_id
        LIMIT 700000)

SELECT * from STAGING

6. Обучение модели ML на ядре TensorFlow

Vertex AI Workbench имеет уровень совместимости вычислений, который позволяет запускать ядра для TensorFlow, PySpark, R и т. д. из одного экземпляра ноутбука. В этой лабораторной работе вы создадите блокнот, используя ядро ​​TensorFlow.

Создать фрейм данных

После выполнения запроса нажмите «Копировать код для DataFrame». Это позволит вам вставить код Python в блокнот, который подключается к клиенту BigQuery и извлекает эти данные в виде DataFrame pandas.

Затем вернитесь в панель запуска и создайте блокнот TensorFlow 2.

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

# The following two lines are only necessary to run once.
# Comment out otherwise for speed-up.
from google.cloud.bigquery import Client, QueryJobConfig
client = Client()

query = """WITH staging AS (
    SELECT
        STRUCT(
            start_stn.name,
            ST_GEOGPOINT(start_stn.longitude, start_stn.latitude) AS POINT,
            start_stn.docks_count,
            start_stn.install_date
        ) AS starting,
        STRUCT(
            end_stn.name,
            ST_GEOGPOINT(end_stn.longitude, end_stn.latitude) AS point,
            end_stn.docks_count,
            end_stn.install_date
        ) AS ending,
        STRUCT(
            rental_id,
            bike_id,
            duration, --seconds
            ST_DISTANCE(
                ST_GEOGPOINT(start_stn.longitude, start_stn.latitude),
                ST_GEOGPOINT(end_stn.longitude, end_stn.latitude)
            ) AS distance, --meters
            start_date,
            end_date
        ) AS bike
        FROM `bigquery-public-data.london_bicycles.cycle_stations` AS start_stn
        LEFT JOIN `bigquery-public-data.london_bicycles.cycle_hire` as b 
        ON start_stn.id = b.start_station_id
        LEFT JOIN `bigquery-public-data.london_bicycles.cycle_stations` AS end_stn
        ON end_stn.id = b.end_station_id
        LIMIT 700000)

SELECT * from STAGING"""
job = client.query(query)
df = job.to_dataframe()

Для целей этой лабораторной работы мы ограничиваем набор данных до 700 000, чтобы сократить время обучения. Но не стесняйтесь изменять запрос и экспериментировать со всем набором данных.

Далее импортируйте необходимые библиотеки.

from datetime import datetime
import pandas as pd
import tensorflow as tf

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

values = df['bike'].values
duration = list(map(lambda a: a['duration'], values))
distance = list(map(lambda a: a['distance'], values))
dates = list(map(lambda a: a['start_date'], values))
data = pd.DataFrame(data={'duration': duration, 'distance': distance, 'start_date':dates})
data = data.dropna()

Столбец start_date представляет собой datetime Python. Вместо непосредственного использования этой datetime в модели вы создадите две новые функции, указывающие день недели и час дня, когда произошла поездка на велосипеде.

data['weekday'] = data['start_date'].apply(lambda a: a.weekday())
data['hour'] = data['start_date'].apply(lambda a: a.time().hour)
data = data.drop(columns=['start_date'])

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

data['duration'] = data['duration'].apply(lambda x:float(x / 60))

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

data.head()

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

# Use 80/20 train/eval split
train_size = int(len(data) * .8)
print ("Train size: %d" % train_size)
print ("Evaluation size: %d" % (len(data) - train_size))

# Split data into train and test sets
train_data = data[:train_size]
val_data = data[train_size:]

Создать модель TensorFlow

Вы создадите модель TensorFlow, используя Keras Functional API . Для предварительной обработки входных данных вы будете использовать API слоев предварительной обработки Keras.

Следующая служебная функция создаст tf.data.Dataset из кадра данных pandas.

def df_to_dataset(dataframe, label, shuffle=True, batch_size=32):
  dataframe = dataframe.copy()
  labels = dataframe.pop(label)
  ds = tf.data.Dataset.from_tensor_slices((dict(dataframe), labels))
  if shuffle:
    ds = ds.shuffle(buffer_size=len(dataframe))
  ds = ds.batch(batch_size)
  ds = ds.prefetch(batch_size)
  return ds

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

train_dataset = df_to_dataset(train_data, 'duration')
validation_dataset = df_to_dataset(val_data, 'duration')

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

• Уровень нормализации : выполняет пофункциональную нормализацию входных объектов.
• Слой IntegerLookup : превращает целочисленные категориальные значения в целочисленные индексы.
• Уровень кодирования категории : превращает целочисленные категориальные функции в одно-, много-горячие или плотные представления TF-IDF.

Обратите внимание, что эти слои не поддаются обучению. Вместо этого вы устанавливаете состояние слоя предварительной обработки, подвергая его обучающим данным с помощью метода adapt() .

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

def get_normalization_layer(name, dataset):
  # Create a Normalization layer for our feature.
  normalizer = tf.keras.layers.Normalization(axis=None)

  # Prepare a Dataset that only yields our feature.
  feature_ds = dataset.map(lambda x, y: x[name])

  # Learn the statistics of the data.
  normalizer.adapt(feature_ds)

  return normalizer

Аналогично, следующая функция создает кодировку категории, которую вы будете использовать для функций часов и дней недели.

def get_category_encoding_layer(name, dataset, dtype, max_tokens=None):
  index = tf.keras.layers.IntegerLookup(max_tokens=max_tokens)

  # Prepare a Dataset that only yields our feature
  feature_ds = dataset.map(lambda x, y: x[name])

  # Learn the set of possible values and assign them a fixed integer index.
  index.adapt(feature_ds)

  # Create a Discretization for our integer indices.
  encoder = tf.keras.layers.CategoryEncoding(num_tokens=index.vocabulary_size())

  # Apply one-hot encoding to our indices. The lambda function captures the
  # layer so we can use them, or include them in the functional model later.
  return lambda feature: encoder(index(feature))

Затем создайте часть предварительной обработки модели. Сначала создайте слой tf.keras.Input для каждого объекта.

# Create a Keras input layer for each feature
numeric_col = tf.keras.Input(shape=(1,), name='distance')
hour_col = tf.keras.Input(shape=(1,), name='hour', dtype='int64')
weekday_col = tf.keras.Input(shape=(1,), name='weekday', dtype='int64')

Затем создайте слои нормализации и кодирования категорий, сохранив их в списке.

all_inputs = []
encoded_features = []

# Pass 'distance' input to normalization layer
normalization_layer = get_normalization_layer('distance', train_dataset)
encoded_numeric_col = normalization_layer(numeric_col)
all_inputs.append(numeric_col)
encoded_features.append(encoded_numeric_col)

# Pass 'hour' input to category encoding layer
encoding_layer = get_category_encoding_layer('hour', train_dataset, dtype='int64')
encoded_hour_col = encoding_layer(hour_col)
all_inputs.append(hour_col)
encoded_features.append(encoded_hour_col)

# Pass 'weekday' input to category encoding layer
encoding_layer = get_category_encoding_layer('weekday', train_dataset, dtype='int64')
encoded_weekday_col = encoding_layer(weekday_col)
all_inputs.append(weekday_col)
encoded_features.append(encoded_weekday_col)

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

all_features = tf.keras.layers.concatenate(encoded_features)
x = tf.keras.layers.Dense(64, activation="relu")(all_features)
output = tf.keras.layers.Dense(1)(x)
model = tf.keras.Model(all_inputs, output)

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

model.compile(optimizer = tf.keras.optimizers.Adam(0.001),
              loss='mean_squared_logarithmic_error')

Теперь, когда вы определили модель, вы можете визуализировать архитектуру.

tf.keras.utils.plot_model(model, show_shapes=True, rankdir="LR")

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

Давайте потренируемся в течение 1 эпохи, чтобы убедиться, что код работает.

model.fit(train_dataset, validation_data = validation_dataset, epochs = 1)

Модель поезда с графическим процессором

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

Чтобы изменить профиль оборудования, нажмите тип машины в правом верхнем углу и выберите «Изменить оборудование» .

Выберите «Подключить графические процессоры» и выберите графический процессор NVIDIA T4 с тензорным ядром.

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

model.fit(train_dataset, validation_data = validation_dataset, epochs = 5)

Можете ли вы придумать, как сделать предсказания более точными? Как насчет того, чтобы попытаться объединить данные о цикле с ежедневными данными о погоде Национального управления океанических и атмосферных исследований (NOAA)?

🎉Поздравляем! 🎉

Вы узнали, как использовать Vertex AI Workbench, чтобы:

• Изучите данные в BigQuery
• Используйте клиент BigQuery для загрузки данных в Python
• Обучение модели TensorFlow с помощью слоев предварительной обработки Keras и графического процессора

Чтобы узнать больше о различных частях Vertex AI, ознакомьтесь с документацией .

7. Очистка

Поскольку мы настроили блокнот на тайм-аут после 60 минут простоя, нам не нужно беспокоиться об отключении экземпляра. Если вы хотите вручную завершить работу экземпляра, нажмите кнопку «Стоп» в разделе консоли Vertex AI Workbench. Если вы хотите полностью удалить блокнот, нажмите кнопку «Удалить».