1. Omówienie
W tym module wykorzystasz Notatniki w AI Platform, aby utworzyć i wytrenować model do identyfikowania fałszywych transakcji oraz zrozumieć prognozy modelu za pomocą pakietu Explainable AI SDK. Wykrywanie oszustw to rodzaj wykrywania anomalii charakterystyczny dla usług finansowych i wiąże się z pewnymi interesującymi wyzwaniami dla modeli systemów uczących się: niezrównoważonymi zbiorami danych i koniecznością wyjaśnienia wyników modelu.
Czego się dowiesz
Poznasz takie zagadnienia jak:
- Obsługa niezrównoważonych zbiorów danych
- Utwórz i oceń model wykrywania oszustw za pomocą tf.keras w notatkach AI Platform.
- Użyj w notatniku Explainable AI SDK, aby dowiedzieć się, dlaczego model zaklasyfikował transakcje jako fałszywe.
- Wdrażanie modelu w AI Platform z wyjaśnieniami oraz uzyskiwanie prognoz i wyjaśnień dotyczących wdrożonego modelu
Całkowity koszt uruchomienia tego modułu w Google Cloud wynosi około 1 USD.
2. Dlaczego funkcja wykrywania oszustw?
Wykrywanie anomalii może być dobrym rozwiązaniem dla systemów uczących się, ponieważ często trudno jest napisać serię stwierdzeń opartych na regułach do identyfikacji elementów odstających w danych. Wykrywanie oszustw to rodzaj wykrywania anomalii, który wiąże się z 2 interesującymi wyzwaniami dla systemów uczących się:
- Bardzo niezrównoważone zbiory danych: anomalie są anomalią, więc nie ma ich zbyt wiele. Systemy uczące się działają najlepiej, gdy zbiory danych są zrównoważone, więc komplikacje mogą się komplikować, gdy wyniki odstające stanowią mniej niż 1% danych.
- Wyjaśnienie wyników: jeśli szukasz nieuczciwych działań, prawdopodobnie zechcesz wiedzieć, dlaczego system oznaczył coś jako oszustwo, zamiast wierzyć na to słowo. Mogą w tym pomóc narzędzia wyjaśnialności.
3. Skonfiguruj środowisko
Aby uruchomić to ćwiczenia z programowania, musisz mieć projekt Google Cloud Platform z włączonymi płatnościami. Aby utworzyć projekt, postępuj zgodnie z tymi instrukcjami.
Krok 1. Włącz Cloud AI Platform Models API
Przejdź do sekcji Modele AI Platform w konsoli Cloud i kliknij Włącz, jeśli ta opcja nie jest jeszcze włączona.
Krok 2. Włącz Compute Engine API
Przejdź do Compute Engine i wybierz opcję Włącz, jeśli nie jest jeszcze włączona. Będzie Ci to potrzebne do utworzenia instancji notatnika.
Krok 3. Utwórz instancję Notatników w AI Platform
Przejdź do sekcji Notatników AI Platform w konsoli Cloud i kliknij Nowa instancja. Następnie wybierz typ instancji TensorFlow Enterprise 2.1 bez GPU:
Użyj opcji domyślnych i kliknij Utwórz. Po utworzeniu instancji wybierz Otwórz JupyterLab:
Po otwarciu instancji wybierz w programie uruchamiającym notatnik Pythona 3:
Krok 4. Zaimportuj pakiety Pythona
Utwórz nową komórkę i zaimportuj biblioteki, których będziemy używać w tym ćwiczeniu z programowania:
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. Pobieranie i przetwarzanie danych
Do wytrenowania modelu użyjemy tego syntetycznie wygenerowanego zbioru danych z Kaggle. Oryginalny zbiór danych zawiera 6,3 miliona wierszy, z czego 8 tys.to fałszywe transakcje, co stanowi zaledwie 0,1% całego zbioru danych.
Krok 1. Pobierz zbiór danych Kaggle i odczytuj dane z użyciem Pandas
Udostępniliśmy zbiór danych Kaggle w Google Cloud Storage. Możesz go pobrać, uruchamiając w notatniku Jupyter to polecenie gsutil:
!gsutil cp gs://financial_fraud_detection/fraud_data_kaggle.csv .
Następnie odczytamy zbiór danych jako obiekt Pandas DataFrame i wyświetlmy jego podgląd:
data = pd.read_csv('fraud_data_kaggle.csv')
data = data.drop(columns=['type'])
data.head()
W podglądzie zobaczysz coś takiego:
Krok 2. Uwzględnij niezrównoważone dane
Jak wspomnieliśmy powyżej, obecnie zbiór danych zawiera 99,9% niefałszywych przykładów. Jeśli wytrenujemy model na podstawie danych w postaci, w jakiej są, jest prawdopodobne, że osiągnie dokładność na poziomie 99,9%, ponieważ odgadnie, że każda transakcja nie jest oszustwem tylko dlatego, że 99,9% danych nie stanowi oszustw.
Z niezrównoważonymi danymi można radzić sobie na kilka różnych sposobów. Tutaj użyjemy techniki downsampling. Zmniejszanie próbkowania polega na wykorzystaniu tylko niewielkiego odsetka większości klasy podczas trenowania. W tym przypadku „nie oszustwo”. to przeważająca klasa, ponieważ stanowi 99,9% danych.
Aby zmniejszyć próbkowanie naszego zbioru danych, pobierzemy ok. 8 tys. fałszywych przykładów i losową próbkę ok. 31 tys. przypadków, które nie dotyczą oszustwa. W ten sposób uzyskany zbiór danych będzie zawierał 25% przypadków oszustw – w porównaniu z wcześniej 0, 1%.
Najpierw podziel dane na 2 elementy DataFrame – jedną dotyczącą oszustwa, a drugą niezafałszowaną (wykorzystamy ją w dalszej części ćwiczeń z programowania podczas wdrażania naszego modelu):
fraud = data[data['isFraud'] == 1]
not_fraud = data[data['isFraud'] == 0]
Następnie pobierz losową próbkę przypadków, w których przypadku nie oszustwo nie było oszustwem. Używamy 0,005%, ponieważ daje to podział 25/75 na transakcje związane z oszustwami i nieoszustwami. Dzięki temu możesz połączyć dane z powrotem i tasować. Aby uprościć ten proces, usuniemy też kilka kolumn, które nie będą używane do trenowania:
# 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()
Mamy teraz znacznie bardziej zrównoważony zbiór danych. Jeśli jednak zauważymy, że nasz model jest zbieżny z dokładnością na poziomie około 75%, istnieje duże prawdopodobieństwo, że zgaduje, że „nie jest oszustwem”. za każdym razem.
Krok 3. Podziel dane na zbiory do trenowania i testowania
Ostatnią rzeczą, jaką musimy zrobić przed utworzeniem modelu, jest podział danych. Zastosujemy podział 80/20 pociągów w ramach testów:
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')
*E. A. Lopez-Rojas , A. Elmir, S. Axelsson. „PaySim: finansowy symulator pieniędzy na potrzeby wykrywania oszustw”. W: 28 Europejskie sympozjum dotyczące modelowania i symulacji (EMSS), Larnaka, Cypr. 2016
5. Utwórz, wytrenuj i oceń model tf.keras
Będziemy tworzyć materiały za pomocą interfejsu tf.keras API TensorFlow. Kod modelu w tej sekcji został utworzony na podstawie tego samouczka z dokumentacji TensorFlow. Najpierw znormalizujemy dane, a potem skompilujemy i trenujemy model, wykorzystując parametr class_weight, aby uwzględnić pozostały brak zrównoważenia danych.
Krok 1. Normalizuj dane
W przypadku trenowania modelu na danych liczbowych ważne jest jego znormalizowanie, zwłaszcza jeśli każda kolumna mieści się w innym zakresie. Może to zapobiec eksplozji przesyłek podczas treningu. Możemy znormalizować dane w ten sposób:
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)
Następnie wyświetl podgląd znormalizowanych danych:
train_set
Krok 2. Określ wagi klas
Przy zmniejszaniu próbkowania danych chcieliśmy zachować podzbiór transakcji niezawierających fałszywych informacji, aby nie utracić informacji o tych transakcjach, dlatego nie zapewniliśmy idealnego zrównoważenia danych. Ponieważ zbiór danych w dalszym ciągu jest niezrównoważony, a najważniejsze jest poprawne identyfikowanie fałszywych transakcji, chcemy, aby nasz model przyczynił się większej wagi fałszywym przykładom w zbiorze danych.
Parametr class_weight Keras pozwala nam dokładnie określić, jaką wagę mają być podawane przykłady z poszczególnych klas w zależności od tego, jak często występują one w zbiorze danych:
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}
Użyjemy tej zmiennej podczas trenowania naszego modelu w następnym kroku.
Krok 3. Wytrenuj i oceń model
Nasz model utworzymy za pomocą interfejsu Sequential Model API Keras, który pozwala zdefiniować go jako stos warstw. W trakcie trenowania będziemy śledzić szereg wskaźników, które pomogą nam poznać skuteczność naszego modelu w poszczególnych klasach w zbiorze danych.
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
Następnie określimy kilka zmiennych globalnych do wykorzystania w trakcie trenowania oraz kilka parametrów wczesnego zatrzymywania.
EPOCHS = 100
BATCH_SIZE = 512
early_stopping = tf.keras.callbacks.EarlyStopping(
monitor='val_auc',
verbose=1,
patience=10,
mode='max',
restore_best_weights=True)
Na koniec wywołamy zdefiniowaną powyżej funkcję, aby utworzyć nasz model:
model = make_model()
model.summary()
Możemy wytrenować model za pomocą metody fit(), przekazując parametry zdefiniowane powyżej:
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)
Trenowanie zajmie kilka minut.
Krok 4. Zwizualizuj wskaźniki modelu
Teraz, gdy mamy już wytrenowany model, sprawdźmy, jak on działał, nanosząc na wykresie różne wskaźniki w epokach trenowania:
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)
Wykresy powinny wyglądać mniej więcej tak (ale nie będą identyczne):
Krok 5. Wydrukuj tablicę pomyłek
Tablica pomyłek to dobry sposób na wizualizację skuteczności naszego modelu w testowym zbiorze danych. W przypadku każdej klasy pokaże nam odsetek przykładów testowych, które nasz model prognozował prawidłowo i nieprawidłowo. W aplikacji Scikit Learn znajdziesz narzędzia do tworzenia i nanoszenia macierzy pomyłek, których tutaj użyjemy.
Na początku notatnika zaimportowaliśmy narzędzie confusion_matrix. Aby z niego korzystać, najpierw utworzymy listę prognoz naszego modelu. W tym miejscu zaokrąglimy wartości zwrócone przez nasz model, aby ta lista odpowiadała naszej liście etykiet danych podstawowych:
predicted = model.predict(test_set)
y_pred = []
for i in predicted.tolist():
y_pred.append(int(round(i[0])))
Teraz możemy przekazać to do metody confusion_matrix wraz z etykietami danych podstawowych (ground truth):
cm = confusion_matrix(test_labels.values, y_pred)
print(cm)
Pokazuje to bezwzględne liczby poprawnych i niepoprawnych prognoz naszego modelu w zbiorze testowym. Liczba w lewym górnym rogu wskazuje, ile przykładów z naszego testu sklasyfikowaliśmy prawidłowo jako nieoszustwa przez nasz model. Liczba w prawym dolnym rogu pokazuje, ile osób poprawnie przewidziało jako fałszywe (dla nas jest to szczególnie ważne). Widać, że prognozuje większość próbek poprawnie dla każdej klasy.
Aby ułatwić wizualizację, dostosowaliśmy funkcję plot_confusion_matrix w dokumentacji Scikit Learn. Zdefiniuj tę funkcję tutaj:
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')
Utwórz wykres, przekazując do niego dane z naszego modelu. Ustawiamy tutaj normalize na True, by tabela pomyłek wyświetlała liczbę poprawnych i niepoprawnych prognoz wyrażoną w procentach:
classes = ['not fraud', 'fraud']
plot_confusion_matrix(cm, classes, normalize=True)
Strona powinna wyglądać mniej więcej tak (dokładne liczby mogą się różnić):
Widać tu,że nasz model poprawnie przewidział około 85% ze 1594 fałszywych transakcji z zestawu testowego. Pamiętaj, że w tym module nie skupiamy się na jakości modelu – jeśli wdrażasz model wykrywania oszustw w środowisku produkcyjnym, warto zwiększyć dokładność klasy oszustw na poziomie ponad 85%. Celem tego modułu jest zapoznanie się z narzędziami dotyczącymi objaśniania modeli trenowanych na niezrównoważonych zbiorach danych.
Następnie użyjemy pakietu Explainable AI SDK, aby dowiedzieć się, które funkcje wykorzystuje nasz model do generowania tych prognoz.
6. Korzystanie z pakietu Explainable AI SDK
Explainable AI SDK udostępnia metody użytkowe służące do uzyskiwania wyjaśnień dotyczących modelu. Jest on wstępnie zainstalowany w instancjach notatników Tensorflow AI Platform – pamiętaj, że zaimportowaliśmy go do notatnika na początku modułu. Pakiet SDK umożliwia nam atrybucje funkcji z naszego modelu w instancji notatnika, co oznacza, że nie trzeba wdrażać modelu w chmurze, aby z niego korzystać.
W tej sekcji wyeksportujemy model wytrenowany przed chwilą jako obiekt SavedModel Tensorflow, a następnie wskażemy pakiet SDK za pomocą zapisanych zasobów modelu, aby uzyskać wyjaśnienia.
Krok 1. Wyeksportuj wytrenowany model
Najpierw zapiszmy model w katalogu w naszej instancji notatnika:
model_dir = 'fraud_model'
tf.saved_model.save(model, model_dir)
Jeśli odświeżysz widok folderów na lewym pasku bocznym notatnika, powinien pojawić się nowy katalog o nazwie fraud_model/.
Krok 2. Uzyskaj metadane wyjaśnień za pomocą pakietu SDK
Następnie wskażemy ten katalog przez pakiet Explainable AI SDK. Spowoduje to wygenerowanie metadanych niezbędnych do uzyskania wyjaśnień modelu. Metoda get_metadata() wyświetla metadane, które pakiet SDK ustala na podstawie modelu, takie jak nazwy danych wejściowych:
model_builder = SavedModelMetadataBuilder(model_dir)
metadata = model_builder.get_metadata()
print(metadata)
Wyjaśnialność pomaga nam odpowiedzieć na pytanie: „Dlaczego nasz model uznał, że to oszustwo?”.
Krok 3. Określ punkt odniesienia naszego modelu
W przypadku danych tabelarycznych usługa Explainable AI zwraca wartości atrybucji dla każdej cechy. Wartości te wskazują, jak konkretna cecha wpłynęła na prognozę. Załóżmy, że kwota danej transakcji spowodowała, że nasz model zwiększył przewidywane prawdopodobieństwo oszustwa o 0,2%. Możesz pomyśleć „0,2% w stosunku do czego?”. To prowadzi nas do koncepcji punktu odniesienia.
Zasadniczo podstawą naszego modelu jest porównanie z nim. Wybieramy wartość bazową dla każdej cechy w naszym modelu, a prognoza bazowa staje się wartością prognozowaną przez nasz model, gdy cechy są na poziomie odniesienia.
Wybór wartości bazowej zależy od zadania związanego z prognozą, które rozwiązujesz. W przypadku funkcji liczbowych często jako punktu odniesienia używa się mediany wartości każdej cechy w zbiorze danych. Jednak w przypadku wykrywania oszustw nie jest to oczekiwane przez nas rozwiązanie. Najbardziej zależy nam na wyjaśnianiu przypadków, w których nasz model oznacza transakcję jako fałszywą. Oznacza to, że podstawową kwestią, z którą mamy sobie poradzić, są transakcje nieoszukańcze.
Aby to wyjaśnić, jako punktu odniesienia użyjemy wartości mediany takich transakcji z naszego zbioru danych. Możemy uzyskać medianę, korzystając z wyodrębnionej powyżej ramki DataFrame not_fraud_sample i skalując ją tak, by pasowała do oczekiwanych danych wejściowych modelu:
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)
Pamiętaj, że nie musimy określać punktu odniesienia. Jeśli tak nie jest, pakiet SDK użyje 0 jako punktu odniesienia dla każdej wartości wejściowej oczekiwanej przez model. W naszym przypadku użycia funkcji wykrywania oszustw warto podać wartość bazową, co zrobimy poniżej:
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)
Wykonanie powyższej metody save_metadata() spowodowało utworzenie w katalogu naszego modelu pliku o nazwie explanation_metadata.json. W notatniku przejdź do katalogu oszustw_model/, aby sprawdzić, czy plik został utworzony. Zawierają one metadane, których pakiet SDK użyje do wygenerowania atrybucji cech.
Krok 4. Poznanie wyjaśnień dotyczących modelu
Teraz możemy pobierać atrybucje cech dla poszczególnych przykładów. W tym celu najpierw utworzymy lokalne odwołanie do naszego modelu za pomocą pakietu SDK:
local_model = explainable_ai_sdk.load_model_from_local_path(
model_dir,
explainable_ai_sdk.SampledShapleyConfig()
)
Teraz pobierzmy prognozy i wyjaśnienia dotyczące naszego modelu z przykładowej transakcji, która powinna zostać sklasyfikowana jako oszustwo:
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()
Uruchomienie go powinno spowodować utworzenie wizualizacji, która będzie wyglądać mniej więcej tak:
W tym przykładzie największym wskaźnikiem oszustwa było początkowe saldo konta przed realizacją transakcji, przez co prognoza naszego modelu przekroczyła wartość bazową powyżej 0, 5. Kolejnymi największymi wskaźnikami były kwota transakcji, wynikowe saldo na koncie docelowym i krok. W zbiorze danych „krok” reprezentuje jednostkę czasu (1 krok to 1 godzina). Wartości atrybucji mogą być też ujemne.
„Błąd przybliżenia” który znajduje się nad wizualizacjami, aby wskazać, na ile możesz ufać wyjaśnieniu. Ogólnie błąd powyżej 5% oznacza, że możesz nie polegać na atrybucjach cech. Pamiętaj, że jakość Twoich wyjaśnień zależy od użytych danych i modelu. Poprawa danych treningowych lub modelu albo wypróbowanie innej wartości bazowej modelu może zmniejszyć błąd przybliżonego.
Możesz też zmniejszyć ten błąd, zwiększając liczbę kroków używanych w Twojej metodzie wyjaśnienia. Możesz to zmienić w pakiecie SDK, dodając do konfiguracji wyjaśnienia parametr path_count (jeśli go nie określisz, domyślna wartość to 10):
local_model = explainable_ai_sdk.load_model_from_local_path(
model_dir,
explainable_ai_sdk.SampledShapleyConfig(path_count=20)
)
Z Explainable AI można zrobić w tym modelu znacznie więcej. Oto kilka pomysłów:
- Wysyłanie do naszego modelu wielu przykładów i uśrednianie wartości atrybucji, aby sprawdzić, czy określone cechy są ogólnie ważniejsze. Możemy to wykorzystać do ulepszania modelu i potencjalnie usunąć funkcje, które nie są ważne.
- Znajdowanie fałszywych trafień, które nasz model oznacza jako oszustwo, ale nie są oszukańczymi transakcjami, oraz analizowanie ich wartości atrybucji
- Użyj innej wartości bazowej i zobacz, jak wpływa to na wartości atrybucji.
🎉 Gratulacje! 🎉
Wiesz już, jak uwzględniać niezrównoważone dane, wytrenować model TensorFlow do wykrywania fałszywych transakcji i używać pakietu Explainable AI SDK, aby zobaczyć, które funkcje Twój model najbardziej wykorzystuje do generowania poszczególnych prognoz. Jeśli chcesz, możesz zatrzymać się na tym etapie. Użycie pakietu SDK w notatniku ma na celu uproszczenie procesu tworzenia modelu dzięki dostępowi do wyjaśnień przed jego wdrożeniem. Gdy już stworzysz model, który będzie Ci się podobał, być może zechcesz go wdrożyć, aby uzyskiwać prognozy na dużą skalę. Jeśli też tak masz, przejdź do następnego opcjonalnego kroku. Gdy skończysz, przejdź do kroku Czyszczenie.
7. Opcjonalnie: wdróż model w prognozie AI Platform
Z tego kroku dowiesz się, jak wdrożyć model w AI Platform Prediction.
Krok 1. Skopiuj katalog zapisanego modelu do zasobnika Cloud Storage.
Dzięki czynnościom dotyczącym pakietu SDK, które uruchomiliśmy wcześniej, masz wszystko, czego potrzebujesz do wdrożenia modelu w AI Platform. Aby przygotować się do wdrożenia, musisz umieścić zasoby SavedModel i metadane wyjaśnień w zasobniku Cloud Storage, który może odczytywać usługa Explainable AI.
W tym celu definiujemy kilka zmiennych środowiskowych. W poniższych wartościach wpisz nazwę projektu Google Cloud i nazwę zasobnika, który chcesz utworzyć (musi być globalnie unikalna).
# Update these to your own GCP project and model
GCP_PROJECT = 'your-gcp-project'
MODEL_BUCKET = 'gs://storage_bucket_name'
Teraz możemy utworzyć zasobnik na dane, w którym będą przechowywane wyeksportowane zasoby modelu TensorFlow. Podczas wdrażania modelu wskażemy ten zasobnik AI Platform.
Aby utworzyć zasobnik, uruchom to polecenie gsutil z poziomu notatnika:
!gsutil mb -l 'us-central1' $MODEL_BUCKET
Następnie skopiuj katalog modelu lokalnego do tego zasobnika:
!gsutil -m cp -r ./$model_dir/* $MODEL_BUCKET/explanations
Krok 2. Wdróż model
Następnie zdefiniujemy kilka zmiennych, których będziemy używać w poleceniach wdrożeniowych:
MODEL = 'fraud_detection'
VERSION = 'v1'
model_path = MODEL_BUCKET + '/explanations'
Możemy utworzyć model za pomocą tego polecenia gcloud:
!gcloud ai-platform models create $MODEL --region=us-central1
Teraz możemy wdrożyć naszą pierwszą wersję tego modelu za pomocą gcloud. Wdrożenie wersji może potrwać ok. 5–10 minut:
!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
We fladze origin przekazujemy informacje o lokalizacji naszego zapisanego modelu i pliku metadanych w Cloud Storage. Explainable AI ma obecnie 2 różne metody wyjaśnienia modeli tabelarycznych. Tutaj wykorzystamy próbkę Shapleya. Parametr num-paths wskazuje liczbę ścieżek próbkowanych dla każdej cechy wejściowej. Ogólnie rzecz biorąc, im bardziej złożony model, tym więcej kroków przybliżonych, aby uzyskać uzasadnioną zbieżność.
Aby sprawdzić, czy model został poprawnie wdrożony, uruchom to polecenie gcloud:
!gcloud ai-platform versions describe $VERSION --model $MODEL --region=us-central1
Powinna to być wartość READY.
Krok 3. Uzyskiwanie prognoz i wyjaśnień dotyczących wdrożonego modelu
Na potrzeby wyjaśnialności szczególnie zależy nam na wyjaśnianiu przypadków, w których nasz model przewiduje oszustwo. Wyślemy do naszego modelu 5 przykładów testów, które przedstawiają fałszywe transakcje.
Do uzyskania prognoz użyjemy Google Cloud CLI. Uruchom ten kod, aby uzyskać indeksy wszystkich przykładów oszustw z naszego zbioru testowego:
fraud_indices = []
for i,val in enumerate(test_labels):
if val == 1:
fraud_indices.append(i)
Następnie zapiszemy 5 przykładów w formacie oczekiwanym przez model i zapiszemy je w pliku:
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)
Za pomocą gcloud możemy wysłać do naszego modelu 5 przykładów:
!gcloud beta ai-platform explain \
--model=$MODEL \
--version=$VERSION \
--region='us-central1' \
--json-request=prediction.json
W pliku JSON odpowiedzi zobaczysz wartości atrybucji dla każdej cechy w tych przykładach. Klucz example_score w każdym przykładzie zawiera prognozę modelu – w tym przypadku procentowe prawdopodobieństwo, że konkretna transakcja jest fałszywa.
8. Czyszczenie
Jeśli chcesz nadal korzystać z tego notatnika, zalecamy wyłączenie go, gdy nie jest używany. W interfejsie notatników w konsoli Cloud wybierz notatnik, a następnie kliknij Zatrzymaj:
Jeśli chcesz usunąć wszystkie zasoby utworzone w tym module, po prostu usuń instancję notatnika, zamiast ją zatrzymywać.
Za pomocą menu nawigacyjnego w konsoli Cloud przejdź do Cloud Storage i usuń oba zasobniki utworzone w celu przechowywania zasobów modelu.