1. Обзор
В ходе этой лабораторной работы вы будете использовать блокноты AI Platform для создания и обучения модели выявления мошеннических транзакций, а также для понимания прогнозов модели с помощью Объясняемого AI SDK. Обнаружение мошенничества — это тип обнаружения аномалий, специфичный для финансовых услуг, который создает некоторые интересные проблемы для моделей ML: изначально несбалансированные наборы данных и необходимость объяснять результаты модели.
Что вы узнаете
Вы узнаете, как:
- Обработка несбалансированных наборов данных
- Создайте и оцените модель обнаружения мошенничества с помощью tf.keras в блокнотах AI Platform.
- Используйте Объясняемый AI SDK из записной книжки, чтобы понять, почему модель классифицирует транзакции как мошеннические.
- Разверните модель на платформе AI с пояснениями и получите прогнозы и пояснения по развернутой модели.
Общая стоимость запуска этой лаборатории в Google Cloud составляет около 1 доллара США .
2. Зачем нужно обнаружение мошенничества?
Обнаружение аномалий может быть хорошим кандидатом на машинное обучение, поскольку зачастую сложно написать серию основанных на правилах операторов для выявления выбросов в данных. Обнаружение мошенничества — это тип обнаружения аномалий, который создает две интересные проблемы, когда дело касается машинного обучения:
- Очень несбалансированные наборы данных : поскольку аномалии — это, ну, аномалии, их не так много. Машинное обучение работает лучше всего, когда наборы данных сбалансированы, поэтому все может усложниться, если выбросы составляют менее 1% ваших данных.
- Необходимо объяснить результаты : если вы ищете мошенническую деятельность, скорее всего, вы захотите узнать, почему система пометила что-то как мошенническое, а не просто поверить ей на слово. В этом могут помочь инструменты объяснительности.
3. Настройте свою среду
Для запуска этой лаборатории кода вам понадобится проект Google Cloud Platform с включенной оплатой. Чтобы создать проект, следуйте инструкциям здесь .
Шаг 1. Включите API моделей облачной платформы искусственного интеллекта.
Перейдите в раздел «Модели платформы AI» в облачной консоли и нажмите «Включить», если он еще не включен.
Шаг 2. Включите API Compute Engine.
Перейдите к Compute Engine и выберите «Включить» , если он еще не включен. Это понадобится вам для создания экземпляра блокнота.
Шаг 3. Создайте экземпляр AI Platform Notebooks.
Перейдите в раздел «Блокноты AI Platform» в облачной консоли и нажмите «Новый экземпляр» . Затем выберите тип экземпляра TensorFlow Enterprise 2.1 без графических процессоров :
Используйте параметры по умолчанию и нажмите «Создать» . После создания экземпляра выберите «Открыть JupyterLab» :
Когда вы откроете экземпляр, выберите блокнот Python 3 в панели запуска:
Шаг 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. Вы можете загрузить его, выполнив следующую команду 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')
*Э.А. Лопес-Рохас, А. Эльмир и С. Аксельссон. «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. Определите веса классов
При уменьшении выборки данных мы по-прежнему хотели сохранить подмножество немошеннических транзакций, чтобы не потерять информацию об этих транзакциях, поэтому мы не сделали данные идеально сбалансированными. Поскольку набор данных по-прежнему несбалансирован, и мы больше всего заботимся о правильном выявлении мошеннических транзакций, мы хотим, чтобы наша модель придавала больший вес примерам мошенничества в нашем наборе данных.
Параметр Keras class_weight позволяет нам точно указать, какой вес мы хотим присвоить примерам из каждого класса, в зависимости от того, как часто они встречаются в наборе данных:
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 % для класса мошенничества. Цель этой лабораторной работы — познакомить вас с инструментами для объяснения моделей, обученных на несбалансированных наборах данных.
Далее мы воспользуемся Объясняемым AI SDK, чтобы понять, на какие функции опирается наша модель для создания таких прогнозов.
6. Использование Объясняемого AI SDK
Объясняемый AI SDK предоставляет служебные методы для получения пояснений к вашей модели. Он предустановлен в экземплярах ноутбуков Tensorflow AI Platform — обратите внимание, что мы импортировали его в наш блокнот в начале нашей лабораторной работы. С помощью SDK мы можем получить атрибуцию функций из нашей модели в экземпляре ноутбука , а это означает, что нам не нужно развертывать нашу модель в облаке, чтобы использовать ее.
В этом разделе мы экспортируем модель, которую мы только что обучили, как сохраненную модель Tensorflow, а затем направим SDK на сохраненные ресурсы модели, чтобы получить объяснения.
Шаг 1. Экспорт обученной модели
Во-первых, давайте сохраним нашу модель в каталоге экземпляра нашего блокнота:
model_dir = 'fraud_model'
tf.saved_model.save(model, model_dir)
Если вы обновите представление папки на левой боковой панели записной книжки, вы увидите новый каталог с именем fraud_model/ Created.
Шаг 2. Получите метаданные пояснений с помощью SDK.
Далее мы укажем для Объясняемого AI SDK этот каталог. При этом будут сгенерированы метаданные, необходимые для получения пояснений модели. Метод get_metadata() показывает метаданные, которые SDK извлекает из вашей модели, например имена входных данных:
model_builder = SavedModelMetadataBuilder(model_dir)
metadata = model_builder.get_metadata()
print(metadata)
Объяснимость помогает нам ответить на вопрос: «Почему наша модель сочла это мошенничеством?»
Шаг 3. Определение базовой линии нашей модели
Для табличных данных служба «Объяснимый ИИ» возвращает значения атрибуции для каждой функции. Эти значения показывают, насколько конкретная функция повлияла на прогноз. Допустим, сумма конкретной транзакции привела к тому, что наша модель увеличила прогнозируемую вероятность мошенничества на 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 для обнаружения мошеннических транзакций и использовать Объясняемый AI SDK, чтобы увидеть, на какие функции ваша модель больше всего опирается для создания индивидуальных прогнозов. Если хочешь, можешь остановиться здесь. Использование SDK в блокноте призвано упростить процесс разработки модели, предоставляя доступ к пояснениям перед ее развертыванием. Скорее всего, как только вы создадите модель, которая вас устроит, вы захотите использовать ее для получения прогнозов в большом масштабе. Если это похоже на вас, перейдите к необязательному следующему шагу. Если вы закончили, перейдите к шагу «Очистка» .
7. Необязательно: разверните модель в прогнозировании платформы искусственного интеллекта.
На этом этапе вы узнаете, как развернуть свою модель в прогнозировании платформы искусственного интеллекта.
Шаг 1. Скопируйте сохраненный каталог модели в корзину облачного хранилища.
Благодаря шагам SDK, которые мы выполняли ранее, у вас есть все необходимое для развертывания вашей модели на платформе AI. Чтобы подготовиться к развертыванию, вам необходимо поместить ресурсы SavedModel и метаданные объяснений в корзину облачного хранилища, которую сможет прочитать служба объяснения ИИ.
Для этого мы определим некоторые переменные среды. Введите в приведенные ниже значения имя вашего проекта Google Cloud и имя сегмента, который вы хотите создать (должно быть глобально уникальным).
# Update these to your own GCP project and model
GCP_PROJECT = 'your-gcp-project'
MODEL_BUCKET = 'gs://storage_bucket_name'
Теперь мы готовы создать корзину для хранения экспортированных ресурсов модели TensorFlow. Мы укажем платформу AI на этот сегмент при развертывании модели.
Запустите эту команду 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 мы передаем местоположение облачного хранилища нашей сохраненной модели и файла метаданных. Объяснимый ИИ в настоящее время имеет два разных метода объяснения табличных моделей. Здесь мы используем Sampled Shapley. Параметр num-paths указывает количество путей, выбранных для каждого входного объекта. Как правило, чем сложнее модель, тем больше шагов аппроксимации необходимо для достижения разумной сходимости.
Чтобы убедиться, что ваша модель развернута правильно, выполните следующую команду gcloud:
!gcloud ai-platform versions describe $VERSION --model $MODEL --region=us-central1
Государство должно быть READY .
Шаг 3. Получение прогнозов и пояснений по развернутой модели.
В целях объяснимости нас больше всего заботит объяснение случаев, когда наша модель предсказывает мошенничество. Мы отправим в нашу модель 5 тестовых примеров, все из которых являются мошенническими транзакциями.
Мы будем использовать Google Cloud CLI для получения прогнозов. Запустите следующий код, чтобы получить индексы всех примеров мошенничества из нашего тестового набора:
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. Очистка
Если вы хотите продолжать использовать этот ноутбук, рекомендуется выключать его, когда он не используется. В пользовательском интерфейсе ноутбуков в облачной консоли выберите блокнот и нажмите «Стоп» :
Если вы хотите удалить все ресурсы, созданные в ходе этой лабораторной работы, просто удалите экземпляр блокнота, а не останавливайте его.
Используя меню навигации в облачной консоли, перейдите к разделу «Хранилище» и удалите оба сегмента, созданные вами для хранения ресурсов модели.