1. Обзор
В этой лабораторной работе вы будете использовать блокноты AI Platform для создания и обучения модели выявления мошеннических транзакций, а также разберёте прогнозы модели с помощью SDK Explainable AI. Выявление мошенничества — это тип обнаружения аномалий, характерный для финансовых услуг, и он представляет собой ряд интересных задач для моделей машинного обучения: по своей природе несбалансированные наборы данных и необходимость объяснения результатов модели.
Чему вы научитесь
Вы научитесь:
- Обработка несбалансированных наборов данных
- Создайте и оцените модель обнаружения мошенничества с помощью tf.keras в блокнотах AI Platform.
- Используйте SDK Explainable AI из блокнота, чтобы понять, почему модель классифицировала транзакции как мошеннические.
- Разверните модель на платформе ИИ с пояснениями и получите прогнозы и пояснения по развернутой модели.
Общая стоимость запуска этой лабораторной работы в Google Cloud составляет около 1 доллара .
2. Зачем нужна система обнаружения мошенничества?
Обнаружение аномалий может быть хорошим кандидатом для машинного обучения, поскольку часто бывает сложно написать серию правил для выявления выбросов в данных. Обнаружение мошенничества — это один из типов обнаружения аномалий, и он представляет две интересные проблемы с точки зрения машинного обучения:
- Очень несбалансированные наборы данных : поскольку аномалии — это, собственно, аномалии, их немного. Машинное обучение работает лучше всего, когда наборы данных сбалансированы, поэтому ситуация может осложниться, если выбросы составляют менее 1% ваших данных.
- Необходимо объяснить результаты : если вы ищете мошеннические действия, скорее всего, вам захочется узнать, почему система пометила что-то как мошенничество, а не просто поверить ей на слово. Инструменты для объяснения результатов могут в этом помочь.
3. Настройте свою среду.
Для выполнения этого практического задания вам потребуется проект Google Cloud Platform с включенной функцией оплаты. Чтобы создать проект, следуйте инструкциям здесь .
Шаг 1: Включите API моделей облачной платформы ИИ.
Перейдите в раздел «Модели платформы ИИ» в консоли Cloud Console и нажмите «Включить», если эта функция еще не включена.
Шаг 2: Включите API Compute Engine.
Перейдите в Compute Engine и выберите «Включить», если эта опция еще не включена. Она понадобится для создания экземпляра ноутбука.
Шаг 3: Создайте экземпляр AI Platform Notebooks.
Перейдите в раздел «Блокноты платформы ИИ» в консоли Cloud и нажмите «Создать экземпляр» . Затем выберите тип экземпляра TensorFlow Enterprise 2.1 без графических процессоров :
Используйте параметры по умолчанию, а затем нажмите «Создать ». После создания экземпляра выберите «Открыть JupyterLab» :
При запуске экземпляра выберите «Python 3 notebook» в меню запуска:
Шаг 4: Импорт пакетов Python
Создайте новую ячейку и импортируйте библиотеки, которые мы будем использовать в этом практическом занятии:
import itertools
import numpy as np
import pandas as pd
import tensorflow as tf
import json
import matplotlib as mpl
import matplotlib.pyplot as plt
import explainable_ai_sdk
from sklearn.utils import shuffle
from sklearn.metrics import confusion_matrix
from sklearn.preprocessing import StandardScaler
from tensorflow import keras
from explainable_ai_sdk.metadata.tf.v2 import SavedModelMetadataBuilder
4. Загрузка и обработка данных
Для обучения нашей модели мы будем использовать этот синтетически сгенерированный набор данных с Kaggle. Исходный набор данных содержит 6,3 миллиона строк, из которых 8 тысяч — это мошеннические транзакции, что составляет всего 0,1% от всего набора данных!
Шаг 1: Загрузите набор данных Kaggle и прочитайте его с помощью Pandas.
Мы предоставили вам доступ к набору данных Kaggle в Google Cloud Storage. Вы можете загрузить его, выполнив следующую команду gsutil в своем блокноте Jupyter:
!gsutil cp gs://financial_fraud_detection/fraud_data_kaggle.csv .
Далее, давайте прочитаем набор данных как DataFrame Pandas и посмотрим его предварительный просмотр:
data = pd.read_csv('fraud_data_kaggle.csv')
data = data.drop(columns=['type'])
data.head()
В предварительном просмотре вы должны увидеть что-то подобное:
Шаг 2: Учет несбалансированных данных
Как уже упоминалось выше, в настоящий момент набор данных содержит 99,9% примеров, не связанных с мошенничеством. Если мы обучим модель на данных в их текущем виде, высока вероятность того, что модель достигнет точности в 99,9%, предполагая, что каждая транзакция не является мошеннической, просто потому что 99,9% данных содержат немошеннические случаи.
Существует несколько различных подходов к работе с несбалансированными данными. Здесь мы будем использовать метод, называемый даунсэмплингом . Даунсэмплинг означает использование лишь небольшого процента мажоритарного класса в обучающей выборке. В данном случае мажоритарным классом является «немошенничество», поскольку он составляет 99,9% данных.
Чтобы уменьшить размер выборки в нашем наборе данных, мы возьмем все ~8 тысяч случаев мошенничества и случайную выборку из ~31 тысячи случаев, не связанных с мошенничеством. Таким образом, в полученном наборе данных будет 25% случаев мошенничества, по сравнению с 0,1%, которые были у нас раньше.
Сначала разделим данные на два DataFrame: один для случаев мошенничества, а другой для случаев, не связанных с мошенничеством (мы воспользуемся этим позже в практическом задании при развертывании нашей модели):
fraud = data[data['isFraud'] == 1]
not_fraud = data[data['isFraud'] == 0]
Затем возьмите случайную выборку случаев, не связанных с мошенничеством. Мы используем 0,005%, так как это даст нам соотношение 25/75 мошеннических и немошеннических транзакций. После этого вы можете собрать данные обратно и перемешать их. Для упрощения мы также удалим несколько столбцов, которые не будем использовать для обучения:
# Take a random sample of non fraud rows
not_fraud_sample = not_fraud.sample(random_state=2, frac=.005)
# Put it back together and shuffle
df = pd.concat([not_fraud_sample,fraud])
df = shuffle(df, random_state=2)
# Remove a few columns (isFraud is the label column we'll use, not isFlaggedFraud)
df = df.drop(columns=['nameOrig', 'nameDest', 'isFlaggedFraud'])
# Preview the updated dataset
df.head()
Теперь у нас гораздо более сбалансированный набор данных. Однако, если мы заметим, что точность нашей модели приближается к ~75%, велика вероятность, что она в каждом случае угадывает «не мошенничество».
Шаг 3: Разделите данные на обучающую и тестовую выборки.
Последнее, что нужно сделать перед построением модели, — это разделить данные. Мы будем использовать соотношение 80/20 между обучающей и тестовой выборками:
train_test_split = int(len(df) * .8)
train_set = df[:train_test_split]
test_set = df[train_test_split:]
train_labels = train_set.pop('isFraud')
test_labels = test_set.pop('isFraud')
*EA Lopez-Rojas, A. Elmir и S. Axelsson. «PaySim: финансовый симулятор мобильных платежей для обнаружения мошенничества». В: 28-й Европейский симпозиум по моделированию и симуляции (EMSS), Ларнака, Кипр. 2016
5. Создайте, обучите и оцените модель tf.keras.
Мы будем использовать API tf.keras из TensorFlow. Код модели в этом разделе основан на этом руководстве из документации TensorFlow. Сначала мы нормализуем данные, а затем построим и обучим нашу модель, используя параметр class_weight для учета оставшегося дисбаланса данных.
Шаг 1: Нормализация данных
При обучении модели на числовых данных важно нормализовать данные, особенно если каждый столбец находится в разном диапазоне. Это поможет предотвратить резкое увеличение функции потерь во время обучения. Нормализацию данных можно выполнить следующим образом:
scaler = StandardScaler()
train_set = scaler.fit_transform(train_set) # Only normalize on the train set
test_set = scaler.transform(test_set)
# clip() ensures all values fall within the range [-5,5]
# useful if any outliers remain after normalizing
train_set = np.clip(train_set, -5, 5)
test_set = np.clip(test_set, -5, 5)
Теперь давайте посмотрим на наши нормализованные данные:
train_set
Шаг 2: Определите весовые коэффициенты класса.
При уменьшении выборки данных мы все же хотели сохранить подмножество немошеннических транзакций, чтобы не потерять информацию о них, поэтому мы не стремились к идеальному балансу данных. Поскольку набор данных все еще несбалансирован, и для нас наиболее важно правильно идентифицировать мошеннические транзакции, мы хотим, чтобы наша модель придавала больший вес мошенническим примерам в нашем наборе данных.
Параметр class_weight в Keras позволяет точно указать, какой вес мы хотим присвоить примерам из каждого класса в зависимости от того, как часто они встречаются в наборе данных:
weight_for_non_fraud = 1.0 / df['isFraud'].value_counts()[0]
weight_for_fraud = 1.0 / df['isFraud'].value_counts()[1]
class_weight = {0: weight_for_non_fraud, 1: weight_for_fraud}
Мы будем использовать эту переменную при обучении нашей модели на следующем шаге.
Шаг 3: Обучение и оценка модели.
Мы будем создавать нашу модель, используя API последовательной модели Keras, который позволяет определить модель как стек слоев. В процессе обучения мы будем отслеживать ряд метрик, которые помогут нам понять, насколько хорошо наша модель работает с каждым классом в нашем наборе данных.
METRICS = [
keras.metrics.TruePositives(name='tp'),
keras.metrics.FalsePositives(name='fp'),
keras.metrics.TrueNegatives(name='tn'),
keras.metrics.FalseNegatives(name='fn'),
keras.metrics.BinaryAccuracy(name='accuracy'),
keras.metrics.Precision(name='precision'),
keras.metrics.Recall(name='recall'),
keras.metrics.AUC(name='auc'),
]
def make_model(metrics = METRICS):
model = keras.Sequential([
keras.layers.Dense(
16, activation='relu',
input_shape=(train_set.shape[-1],)),
keras.layers.Dropout(0.5),
keras.layers.Dense(1, activation='sigmoid'),
])
model.compile(
optimizer=keras.optimizers.Adam(lr=1e-3),
loss=keras.losses.BinaryCrossentropy(),
metrics=metrics)
return model
Затем мы определим несколько глобальных переменных для использования во время обучения, а также некоторые параметры ранней остановки.
EPOCHS = 100
BATCH_SIZE = 512
early_stopping = tf.keras.callbacks.EarlyStopping(
monitor='val_auc',
verbose=1,
patience=10,
mode='max',
restore_best_weights=True)
Наконец, мы вызовем функцию, определенную выше, чтобы создать нашу модель:
model = make_model()
model.summary()
Мы можем обучить нашу модель с помощью метода fit() , передав параметры, определенные выше:
results = model.fit(
train_set,
train_labels,
batch_size=BATCH_SIZE,
epochs=EPOCHS,
callbacks = [early_stopping],
validation_data=(test_set, test_labels),
class_weight=class_weight)
Тренировка займет всего несколько минут.
Шаг 4: Визуализация метрик модели
Теперь, когда у нас есть обученная модель, давайте посмотрим, как она себя показала, построив графики различных метрик на протяжении всех эпох обучения:
mpl.rcParams['figure.figsize'] = (12, 10)
colors = plt.rcParams['axes.prop_cycle'].by_key()['color']
def plot_metrics(history):
metrics = ['loss', 'auc', 'precision', 'recall']
for n, metric in enumerate(metrics):
name = metric.replace("_"," ").capitalize()
plt.subplot(2,2,n+1)
plt.plot(history.epoch, history.history[metric], color=colors[0], label='Train')
plt.plot(history.epoch, history.history['val_'+metric],
color=colors[0], linestyle="--", label='Val')
plt.xlabel('Epoch')
plt.ylabel(name)
if metric == 'loss':
plt.ylim([0, plt.ylim()[1]])
elif metric == 'auc':
plt.ylim([0.8,1])
else:
plt.ylim([0,1])
plt.legend()
plot_metrics(results)
Ваши графики должны выглядеть примерно так (но не будут в точности идентичны):
Шаг 5: Распечатайте матрицу ошибок.
Матрица ошибок — это удобный способ визуализации того, как наша модель показала себя на тестовом наборе данных. Для каждого класса она покажет нам процент тестовых примеров, которые наша модель предсказала правильно и неправильно. В Scikit Learn есть несколько утилит для создания и построения матриц ошибок, которые мы и будем использовать здесь.
В начале нашего блокнота мы импортировали утилиту confusion_matrix . Чтобы использовать её, сначала создадим список предсказаний нашей модели. Здесь мы округлим значения, возвращаемые нашей моделью, так чтобы этот список соответствовал нашему списку истинных меток:
predicted = model.predict(test_set)
y_pred = []
for i in predicted.tolist():
y_pred.append(int(round(i[0])))
Теперь мы готовы передать эти данные в метод confusion_matrix вместе с нашими эталонными метками:
cm = confusion_matrix(test_labels.values, y_pred)
print(cm)
Здесь показаны абсолютные числа правильных и неправильных предсказаний нашей модели на тестовом наборе данных. Число в верхнем левом углу показывает, сколько примеров из нашего тестового набора модель правильно предсказала как немошеннические. Число в нижнем правом углу показывает, сколько примеров она правильно предсказала как мошеннические (это число для нас наиболее важно). Вы можете видеть, что она правильно предсказала большинство образцов для каждого класса.
Для упрощения визуализации мы адаптировали функцию plot_confusion_matrix из документации Scikit Learn. Определите эту функцию здесь:
def plot_confusion_matrix(cm, classes,
normalize=False,
title='Confusion matrix',
cmap=plt.cm.Blues):
"""
This function prints and plots the confusion matrix.
Normalization can be applied by setting `normalize=True`.
"""
plt.imshow(cm, interpolation='nearest', cmap=cmap)
plt.title(title)
plt.colorbar()
tick_marks = np.arange(len(classes))
plt.xticks(tick_marks, classes, rotation=45)
plt.yticks(tick_marks, classes)
if normalize:
cm = np.round(cm.astype('float') / cm.sum(axis=1)[:, np.newaxis], 3)
thresh = cm.max() / 2.
for i, j in itertools.product(range(cm.shape[0]), range(cm.shape[1])):
plt.text(j, i, cm[i, j],
horizontalalignment="center",
color="white" if cm[i, j] > thresh else "black")
plt.tight_layout()
plt.ylabel('True label')
plt.xlabel('Predicted label')
И создадим график, передав ему данные из нашей модели. Здесь мы устанавливаем normalize в True , чтобы матрица ошибок отображала количество правильных и неправильных прогнозов в процентах:
classes = ['not fraud', 'fraud']
plot_confusion_matrix(cm, classes, normalize=True)
Вы должны увидеть что-то подобное (точные цифры могут отличаться):
Здесь мы видим, что наша модель правильно предсказала около 85% из 1594 мошеннических транзакций из нашего тестового набора. Обратите внимание, что в этой лабораторной работе основное внимание уделяется не качеству модели — если вы развертываете модель обнаружения мошенничества в производственной среде, вам, вероятно, потребуется точность выше 85% для класса мошенничества. Цель этой лабораторной работы — познакомить вас с инструментами для объяснения моделей, обученных на несбалансированных наборах данных.
Далее мы воспользуемся SDK Explainable AI, чтобы понять, на какие характеристики опирается наша модель при построении этих прогнозов.
6. Использование SDK для объяснимого искусственного интеллекта
SDK Explainable AI предоставляет вспомогательные методы для получения пояснений к вашей модели. Он предустановлен в экземплярах блокнотов Tensorflow AI Platform — обратите внимание, что мы импортировали его в наш блокнот в начале лабораторной работы. С помощью SDK мы можем получать атрибуты признаков из нашей модели внутри экземпляра блокнота , а это значит, что нам не нужно развертывать нашу модель в облаке, чтобы использовать ее.
В этом разделе мы экспортируем только что обученную модель в виде сохраненной модели TensorFlow (SevedModel), а затем укажем SDK на сохраненные ресурсы модели, чтобы получить пояснения.
Шаг 1: Экспорт обученной модели
Для начала сохраним нашу модель в директорию в нашем экземпляре ноутбука:
model_dir = 'fraud_model'
tf.saved_model.save(model, model_dir)
Если вы обновите представление папок в левой боковой панели вашего блокнота, вы увидите, что создана новая директория с именем fraud_model/ .
Шаг 2: Получите метаданные пояснения с помощью SDK.
Далее мы укажем SDK Explainable AI на этот каталог. Это позволит сгенерировать метаданные, необходимые для получения объяснений модели. Метод get_metadata() отображает метаданные, которые SDK получает из вашей модели, например, имена входных данных:
model_builder = SavedModelMetadataBuilder(model_dir)
metadata = model_builder.get_metadata()
print(metadata)
Объяснимость помогает нам ответить на вопрос: «Почему наша модель посчитала это мошенничеством?»
Шаг 3: Определение базового уровня нашей модели.
Для табличных данных сервис Explainable AI возвращает значения атрибуции для каждой характеристики. Эти значения показывают, насколько та или иная характеристика повлияла на прогноз. Допустим, сумма конкретной транзакции привела к тому, что наша модель увеличила прогнозируемую вероятность мошенничества на 0,2%. Вы можете подумать: «0,2% относительно чего??». Это подводит нас к концепции базового уровня.
Базовым значением для нашей модели, по сути, является то, с чем она сравнивает свои результаты. Мы выбираем базовое значение для каждого признака в нашей модели, и, следовательно, базовое предсказание становится тем значением, которое наша модель предсказывает, когда признаки установлены на базовом уровне.
Выбор базового уровня зависит от решаемой задачи прогнозирования. Для числовых признаков обычно в качестве базового уровня используют медианное значение каждого признака в наборе данных. Однако в случае обнаружения мошенничества это не совсем то, что нам нужно. Нас больше всего интересует объяснение случаев, когда наша модель помечает транзакцию как мошенническую. Это означает, что базовым случаем, с которым мы хотим сравнивать, являются немошеннические транзакции.
Чтобы учесть это, мы будем использовать медианные значения немошеннических транзакций в нашем наборе данных в качестве базового уровня. Мы можем получить медиану, используя DataFrame not_fraud_sample , который мы извлекли выше, и масштабировав его в соответствии с ожидаемыми входными данными нашей модели:
not_fraud_sample = not_fraud_sample.drop(columns=['nameOrig', 'nameDest', 'isFlaggedFraud', 'isFraud'])
baseline = scaler.transform(not_fraud_sample.values)
baseline = np.clip(baseline, -5, 5)
baseline_values = np.median(baseline, axis=0)
Обратите внимание, что указывать базовый уровень не обязательно . В противном случае SDK будет использовать 0 в качестве базового уровня для каждого входного значения, ожидаемого нашей моделью. В нашем случае обнаружения мошенничества указание базового уровня имеет смысл, что мы и сделаем ниже:
input_name = list(metadata['inputs'])[0]
model_builder.set_numeric_metadata(input_name, input_baselines=[baseline_values.tolist()], index_feature_mapping=df.columns.tolist()[:6])
model_builder.save_metadata(model_dir)
При выполнении метода save_metadata() описанного выше, в каталоге нашей модели был создан файл explanation_metadata.json . В вашем блокноте перейдите в каталог fraud_model/, чтобы убедиться в создании этого файла. Он содержит метаданные, которые SDK будет использовать для генерации атрибутов признаков.
Шаг 4: Получение пояснений к модели
Теперь мы готовы получить информацию о характеристиках отдельных примеров. Для этого сначала создадим локальную ссылку на нашу модель с помощью SDK:
local_model = explainable_ai_sdk.load_model_from_local_path(
model_dir,
explainable_ai_sdk.SampledShapleyConfig()
)
Далее, давайте получим прогнозы и пояснения к нашей модели на примере транзакции, которую следует классифицировать как мошенническую :
fraud_example = [0.722,0.139,-0.114,-0.258,-0.271,-0.305]
response = local_model.explain([{input_name: fraud_example}])
response[0].visualize_attributions()
При выполнении этой команды должна быть создана визуализация, которая выглядит следующим образом:
В этом примере начальный баланс счета до совершения транзакции оказался наиболее значимым индикатором мошенничества, повысив прогноз нашей модели более чем на 0,5 по сравнению с базовым уровнем. Следующими по значимости индикаторами были сумма транзакции, итоговый баланс на целевом счете и шаг транзакции. В наборе данных «шаг» представляет собой единицу времени (1 шаг равен 1 часу). Значения атрибутивного анализа также могут быть отрицательными.
Показатель «ошибка аппроксимации», отображаемый над визуализациями, позволяет оценить степень доверия к объяснению. Как правило, ошибка более 5% означает, что на атрибуцию признаков полагаться нельзя. Помните, что качество ваших объяснений зависит от качества используемых обучающих данных и модели. Улучшение обучающих данных, модели или использование другой базовой модели может уменьшить ошибку аппроксимации.
Вы также можете уменьшить эту ошибку, увеличив количество шагов, используемых в вашем методе объяснения. Вы можете изменить это с помощью SDK, добавив параметр path_count в конфигурацию объяснения (по умолчанию — 10, если вы его не указываете):
local_model = explainable_ai_sdk.load_model_from_local_path(
model_dir,
explainable_ai_sdk.SampledShapleyConfig(path_count=20)
)
С помощью объяснимого ИИ на этой модели можно сделать гораздо больше. Вот несколько идей:
- Отправка множества примеров нашей модели и усреднение значений атрибутивности позволяют определить, какие характеристики в целом более важны. Это можно использовать для улучшения модели и, возможно, удаления неважных характеристик.
- Выявление ложных срабатываний, которые наша модель помечает как мошенничество, но которые на самом деле не являются мошенническими транзакциями, и анализ значений их атрибутивной принадлежности.
- Используйте другой базовый уровень и посмотрите, как это повлияет на значения атрибуции.
🎉 Поздравляем! 🎉
Вы научились учитывать несбалансированные данные, обучать модель TensorFlow для обнаружения мошеннических транзакций и использовать SDK Explainable AI, чтобы увидеть, на какие признаки ваша модель больше всего полагается при построении индивидуальных прогнозов. Вы можете остановиться здесь, если хотите. Использование SDK в блокноте призвано упростить процесс разработки модели, предоставляя вам доступ к пояснениям перед развертыванием модели. Вероятно, после создания модели, которая вас устраивает, вы захотите развернуть её для получения прогнозов в больших масштабах. Если это так, перейдите к необязательному следующему шагу. Если вы закончили, перейдите к шагу «Очистка» .
7. Дополнительно: Разверните модель на платформе прогнозирования ИИ.
На этом этапе вы узнаете, как развернуть свою модель на платформе прогнозирования AI Platform Prediction.
Шаг 1: Скопируйте каталог с сохраненными моделями в облачное хранилище.
Выполнив описанные ранее шаги с использованием SDK, вы получили все необходимое для развертывания вашей модели на платформе AI Platform. Для подготовки к развертыванию вам потребуется поместить ваши сохраненные ресурсы SavedModel и метаданные объяснения в хранилище Cloud Storage Bucket, доступное для чтения сервисом Explainable AI.
Для этого мы определим несколько переменных окружения. Заполните приведенные ниже значения именем вашего проекта Google Cloud и именем корзины, которую вы хотите создать (она должна быть уникальной для всего мира).
# Update these to your own GCP project and model
GCP_PROJECT = 'your-gcp-project'
MODEL_BUCKET = 'gs://storage_bucket_name'
Теперь мы готовы создать хранилище для сохранения экспортированных ресурсов нашей модели TensorFlow. Мы укажем AI Platform на это хранилище при развертывании модели.
Выполните следующую команду gsutil в своем ноутбуке, чтобы создать корзину:
!gsutil mb -l 'us-central1' $MODEL_BUCKET
Затем скопируйте локальную директорию с вашей моделью в этот репозиторий:
!gsutil -m cp -r ./$model_dir/* $MODEL_BUCKET/explanations
Шаг 2: Развертывание модели
Далее мы определим несколько переменных, которые будем использовать в командах развертывания:
MODEL = 'fraud_detection'
VERSION = 'v1'
model_path = MODEL_BUCKET + '/explanations'
Создать модель можно с помощью следующей команды gcloud:
!gcloud ai-platform models create $MODEL --region=us-central1
Теперь мы готовы развернуть первую версию этой модели с помощью gcloud. Развертывание займет примерно 5-10 минут:
!gcloud beta ai-platform versions create $VERSION \
--model $MODEL \
--origin $model_path \
--runtime-version 2.1 \
--framework TENSORFLOW \
--python-version 3.7 \
--machine-type n1-standard-4 \
--explanation-method 'sampled-shapley' \
--num-paths 10 \
--region=us-central1
В флаге origin мы передаем местоположение сохраненной модели и файла метаданных в Cloud Storage. В Explainable AI в настоящее время доступны два различных метода объяснения для табличных моделей. Здесь мы используем Sampled Shapley. Параметр num-paths указывает количество путей, выбранных для каждого входного признака. Как правило, чем сложнее модель, тем больше шагов аппроксимации требуется для достижения приемлемой сходимости.
Чтобы убедиться в корректности развертывания модели, выполните следующую команду gcloud:
!gcloud ai-platform versions describe $VERSION --model $MODEL --region=us-central1
Государство должно быть READY .
Шаг 3: Получение прогнозов и пояснений по развернутой модели.
В целях обеспечения объяснимости нам важнее всего объяснить случаи, когда наша модель предсказывает мошенничество. Мы отправим нашей модели 5 тестовых примеров, представляющих собой мошеннические транзакции.
Для получения прогнозов мы воспользуемся интерфейсом командной строки Google Cloud. Запустите следующий код, чтобы получить индексы всех примеров мошенничества из нашего тестового набора:
fraud_indices = []
for i,val in enumerate(test_labels):
if val == 1:
fraud_indices.append(i)
Далее мы сохраним 5 примеров в формате, ожидаемом нашей моделью, и запишем их в файл:
num_test_examples = 5
instances = []
for i in range(num_test_examples):
ex = test_set[fraud_indices[i]]
instances.append({input_name: ex.tolist()})
with open('prediction.json', 'a') as outputfile:
json.dump({"instances": instances}, outputfile)
Мы можем отправить эти пять примеров в нашу модель с помощью gcloud:
!gcloud beta ai-platform explain \
--model=$MODEL \
--version=$VERSION \
--region='us-central1' \
--json-request=prediction.json
В JSON-ответе вы увидите значения атрибутов для каждой характеристики в этих примерах. Ключ example_score для каждого примера включает предсказание модели — в данном случае, процентную вероятность того, что конкретная транзакция является мошеннической.
8. Уборка
Если вы хотите продолжить использование этого блокнота, рекомендуется выключать его, когда он не используется. В интерфейсе блокнотов в вашей облачной консоли выберите блокнот, а затем выберите «Остановить» :
Если вы хотите удалить все ресурсы, созданные в этой лабораторной работе, просто удалите экземпляр блокнота, а не останавливайте его.
В консоли Cloud Console, используя меню навигации, перейдите в раздел «Хранилище» и удалите оба сегмента, созданных для хранения ресурсов вашей модели.