Wyjaśnienie modelu wykrywania oszustw za pomocą Cloud AI Platform

1. Przegląd

W tym laboratorium dowiesz się, jak za pomocą AI Platform Notebooks utworzyć i wytrenować model do identyfikowania oszukańczych transakcji oraz jak interpretować prognozy modelu za pomocą pakietu Explainable AI SDK. Wykrywanie oszustw to rodzaj wykrywania anomalii, który jest stosowany w przypadku usług finansowych i stanowi ciekawe wyzwanie dla modeli uczenia maszynowego: z natury niezrównoważone zbiory danych i konieczność wyjaśnienia wyników modelu.

Czego się nauczysz

Poznasz takie zagadnienia jak:

Obsługa niezrównoważonych zbiorów danych
Tworzenie i ocenianie modelu wykrywania oszustw za pomocą tf.keras w notatnikach AI Platform
Użyj pakietu Explainable AI SDK w notatniku, aby dowiedzieć się, dlaczego model zaklasyfikował transakcje jako oszukańcze.
wdrożyć model w AI Platform z wyjaśnieniami oraz uzyskać prognozy i wyjaśnienia dotyczące wdrożonego modelu;

Całkowity koszt ukończenia tego modułu w Google Cloud wynosi około 1 USD.

2. Dlaczego warto wykrywać oszustwa?

Wykrywanie anomalii może być dobrym zastosowaniem uczenia maszynowego, ponieważ często trudno jest napisać serię instrukcji opartych na regułach, które pozwolą zidentyfikować wartości odstające w danych. Wykrywanie oszustw to rodzaj wykrywania anomalii, który w przypadku uczenia maszynowego stwarza 2 ciekawe wyzwania:

Bardzo niezrównoważone zbiory danych: anomalie są, cóż, anomaliami, więc nie ma ich zbyt wiele. Uczenie maszynowe działa najlepiej, gdy zbiory danych są zrównoważone, więc sytuacja może się skomplikować, gdy wartości odstające stanowią mniej niż 1% danych.
Konieczność wyjaśnienia wyników: jeśli szukasz nieuczciwego działania, prawdopodobnie będziesz chcieć wiedzieć, dlaczego system oznaczył coś jako oszukańcze, zamiast po prostu mu zaufać. Pomocne mogą być narzędzia do wyjaśnialności.

3. Konfigurowanie środowiska

Aby wykonać to ćwiczenie, musisz mieć projekt w Google Cloud Platform z włączonymi płatnościami. Aby utworzyć projekt, postępuj zgodnie z instrukcjami.

Krok 1. Włącz interfejs Cloud AI Platform Models API

Otwórz sekcję AI Platform Models w konsoli Cloud i kliknij Włącz, jeśli nie jest jeszcze włączona.

Krok 2. Włącz interfejs Compute Engine API

Przejdź do Compute Engine i kliknij Włącz, jeśli nie jest jeszcze włączona. Będzie Ci potrzebny do utworzenia instancji notatnika.

Krok 3. Utwórz instancję notatników AI Platform

Otwórz sekcję AI Platform Notebooks w Cloud Console i kliknij Nowa instancja. Następnie wybierz typ instancji TensorFlow Enterprise 2.1 bez procesorów graficznych:

Użyj opcji domyślnych, a następnie kliknij Utwórz. Po utworzeniu instancji wybierz Otwórz JupyterLab:

Po otwarciu instancji wybierz z menu Python 3:

Krok 4. Zaimportuj pakiety Pythona

Utwórz nową komórkę i zaimportuj biblioteki, których będziemy używać w tym laboratorium:

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 trenowania modelu użyjemy tego wygenerowanego syntetycznie zbioru danych z Kaggle. Oryginalny zbiór danych zawiera 6,3 mln wierszy, z których 8 tys.to oszukańcze transakcje – zaledwie 0,1% całego zbioru danych.

Krok 1. Pobierz zbiór danych Kaggle i odczytaj go za pomocą biblioteki Pandas

Udostępniliśmy Ci 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 odczytajmy zbiór danych jako strukturę DataFrame biblioteki pandas 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ędnianie niezrównoważonych danych

Jak wspomnieliśmy powyżej, obecnie zbiór danych zawiera 99,9% przykładów niebędących oszustwami. Jeśli wytrenujemy model na podstawie tych danych, prawdopodobnie osiągnie on dokładność na poziomie 99,9% – po prostu zgadując, że każda transakcja nie jest oszustwem, ponieważ 99,9% danych to przypadki niebędące oszustwami.

Istnieje kilka różnych sposobów radzenia sobie z niezrównoważonymi danymi. Użyjemy tutaj techniki zwanej downsamplingiem. Downsampling oznacza używanie podczas trenowania tylko niewielkiego odsetka klasy większościowej. W tym przypadku klasa „nieoszukańcze” jest klasą większościową, ponieważ stanowi 99,9% danych.

Aby zmniejszyć próbę w naszym zbiorze danych, weźmiemy wszystkie ok. 8 tys. przykładów oszustw i losową próbę ok. 31 tys. przypadków niebędących oszustwami. W ten sposób uzyskasz zbiór danych, w którym 25% stanowią przypadki oszustwa, w porównaniu z 0,1% wcześniej.

Najpierw podziel dane na 2 ramki danych: jeden dla oszustw, a drugi dla transakcji niebędących oszustwami (wykorzystamy to później w tym laboratorium, gdy wdrożymy nasz model):

fraud = data[data['isFraud'] == 1]
not_fraud = data[data['isFraud'] == 0]

Następnie pobierz losową próbkę przypadków, w których nie doszło do oszustwa. Używamy wartości 0,005%, ponieważ daje nam to podział transakcji na oszukańcze i nieoszukańcze w stosunku 25/75. Dzięki temu możesz ponownie połączyć dane i je przetasować. Aby uprościć proces, usuniemy też kilka kolumn, których nie będziemy używać 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()

Teraz mamy znacznie bardziej zrównoważony zbiór danych. Jeśli jednak zauważymy, że nasz model osiąga dokładność na poziomie około 75%, istnieje duże prawdopodobieństwo, że w każdym przypadku zgaduje „brak oszustwa”.

Krok 3. Podziel dane na zbiory do trenowania i testowania

Ostatnią rzeczą, którą musimy zrobić przed utworzeniem modelu, jest podzielenie danych. Użyjemy podziału na zbiór treningowy i testowy w proporcji 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')

*E. A. Lopez-Rojas , A. Elmir i S. Axelsson. „PaySim: A financial mobile money simulator for fraud detection”. W: The 28th European Modeling and Simulation Symposium-EMSS, Larnaca, Cyprus. 2016

5. Tworzenie, trenowanie i ocenianie modelu tf.keras

Będziemy korzystać z interfejsu tf.keras API w TensorFlow. Kod modelu w tej sekcji jest oparty na tym samouczku z dokumentacji TensorFlow. Najpierw znormalizujemy dane, a potem zbudujemy i wytrenujemy model, używając parametru class_weight, aby uwzględnić pozostałą nierównowagę danych.

Krok 1. Znormalizuj dane

Podczas trenowania modelu na danych liczbowych ważne jest, aby je znormalizować, zwłaszcza jeśli każda kolumna mieści się w innym zakresie. Może to zapobiec utracie danych w wyniku eksplozji podczas trenowania. Dane możemy normalizować w następujący 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świetlmy podgląd znormalizowanych danych:

train_set

Krok 2. Określ wagi klas

Podczas zmniejszania liczby próbek danych chcieliśmy zachować podzbiór transakcji niebędących oszustwami, aby nie utracić informacji o tych transakcjach. Dlatego nie sprawiliśmy, że dane były idealnie zrównoważone. Ponieważ zbiór danych jest nadal niezrównoważony, a najbardziej zależy nam na prawidłowym identyfikowaniu transakcji oszukańczych, chcemy, aby nasz model nadawał większe znaczenie przykładom oszustw w naszym zbiorze danych.

Parametr Keras class_weight pozwala nam dokładnie określić, jaką wagę chcemy przypisać przykładom z każdej klasy na podstawie 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 modelu w następnym kroku.

Krok 3. Trenowanie i ocenianie modelu

Model utworzymy za pomocą interfejsu Keras Sequential Model API, który umożliwia zdefiniowanie modelu jako stosu warstw. Podczas trenowania będziemy śledzić szereg danych, które pomogą nam zrozumieć, jak nasz model działa w przypadku każdej klasy 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 zdefiniujemy kilka zmiennych globalnych do użycia podczas trenowania oraz kilka parametrów wczesnego zatrzymania.

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ć model:

model = make_model()
model.summary()

Model możemy wytrenować za pomocą metody fit(), przekazując zdefiniowane powyżej parametry:

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 potrwa kilka minut.

Krok 4. Wizualizacja danych modelu

Mamy już wytrenowany model. Sprawdźmy teraz, jak sobie radził, rysując wykresy różnych rodzajów danych w poszczególnych 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ć podobnie do tych poniżej (ale nie będą identyczne):

Krok 5. Wydrukuj tablicę pomyłek

Tablica pomyłek to dobry sposób na wizualizację wyników modelu w zbiorze testowym. W przypadku każdej klasy wyświetli odsetek przykładów testowych, które model przewidział prawidłowo i nieprawidłowo. Biblioteka Scikit Learn zawiera narzędzia do tworzenia i wykreślania macierzy pomyłek, których użyjemy w tym przykładzie.

Na początku notatnika zaimportowaliśmy narzędzie confusion_matrix. Aby z niej skorzystać, najpierw utworzymy listę prognoz modelu. Zaokrąglimy tu wartości zwrócone przez model, aby ta lista była zgodna z naszą listą 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ć te dane do metody confusion_matrix wraz z etykietami danych podstawowych:

cm = confusion_matrix(test_labels.values, y_pred)
print(cm)

Pokazuje to bezwzględne liczby prawidłowych i nieprawidłowych prognoz modelu w zbiorze testowym. Liczba w lewym górnym rogu pokazuje, ile przykładów ze zbioru testowego model prawidłowo zaklasyfikował jako niepochodzące z oszustwa. Liczba w prawym dolnym rogu pokazuje, ile transakcji zostało prawidłowo zakwalifikowanych jako oszukańcze (na tej liczbie zależy nam najbardziej). Widać, że w przypadku każdej klasy model prawidłowo przewidział większość próbek.

Aby ułatwić wizualizację, dostosowaliśmy funkcję plot_confusion_matrix z 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')

i utworzyć wykres, przekazując do niego dane z naszego modelu. Ustawiamy tutaj wartość normalize na True, aby tablica pomyłek wyświetlała liczbę prawidłowych i nieprawidłowych prognoz w procentach:

classes = ['not fraud', 'fraud']
plot_confusion_matrix(cm, classes, normalize=True)

Powinien pojawić się ekran podobny do tego (dokładne liczby mogą się różnić):

Widzimy,że nasz model prawidłowo przewidział około 85% z 1594 oszukańczych transakcji w naszym zbiorze testowym. Pamiętaj, że w tym laboratorium nie skupiamy się na jakości modelu. Jeśli wdrażasz model wykrywania oszustw w środowisku produkcyjnym, prawdopodobnie będziesz oczekiwać dokładności powyżej 85% w przypadku klasy oszustw. Celem tego modułu jest zapoznanie Cię z narzędziami do wyjaśniania modeli wytrenowanych na niezrównoważonych zbiorach danych.

Następnie użyjemy pakietu SDK Explainable AI, aby dowiedzieć się, na jakich cechach opiera się nasz model podczas tworzenia tych prognoz.

6. Korzystanie z pakietu Explainable AI SDK

Pakiet SDK Wyjaśnialnej AI udostępnia metody narzędziowe do uzyskiwania wyjaśnień dotyczących modelu. Jest on wstępnie zainstalowany w instancjach Notatników AI Platform Tensorflow. Pamiętaj, że na początku tego laboratorium zaimportowaliśmy go do naszego notatnika. Dzięki pakietowi SDK możemy uzyskać atrybucje funkcji z naszego modelu w instancji notatnika, co oznacza, że nie musimy wdrażać modelu w chmurze, aby go używać.

W tej sekcji wyeksportujemy wytrenowany model jako TensorFlow SavedModel, a następnie wskażemy pakietowi SDK zapisane zasoby modelu, aby uzyskać wyjaśnienia.

Krok 1. Wyeksportuj wytrenowany model

Najpierw zapiszmy model w katalogu w instancji notatnika:

model_dir = 'fraud_model'
tf.saved_model.save(model, model_dir)

Jeśli odświeżysz widok folderu na pasku bocznym notatnika po lewej stronie, powinien pojawić się nowy katalog o nazwie fraud_model/.

Krok 2. Uzyskaj metadane wyjaśnienia za pomocą pakietu SDK

Następnie wskażemy pakietowi SDK Explainable AI ten katalog. Spowoduje to wygenerowanie metadanych niezbędnych do uzyskania wyjaśnień modelu. Metoda get_metadata() wyświetla metadane wywnioskowane przez pakiet SDK z Twojego modelu, np. 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ślanie wartości bazowej modelu

W przypadku danych w formie tabeli usługa Explainable AI zwraca wartości atrybucji dla każdej cechy. Te wartości wskazują, w jakim stopniu dana cecha wpłynęła na prognozę. Załóżmy, że kwota konkretnej transakcji spowodowała, że nasz model zwiększył przewidywane prawdopodobieństwo oszustwa o 0,2%. Możesz się zastanawiać: „0,2% w porównaniu z czym?”. W ten sposób dochodzimy do koncepcji wartości bazowej.

Punkt odniesienia dla naszego modelu to w zasadzie to, z czym jest on porównywany. Wybieramy wartość bazową dla każdej cechy w naszym modelu, a prognoza bazowa staje się wartością, którą model przewiduje, gdy cechy są ustawione na wartość bazową.

Wybór punktu odniesienia zależy od zadania prognozowania, które rozwiązujesz. W przypadku cech numerycznych jako wartość bazową zwykle stosuje się medianę każdej cechy w zbiorze danych. W przypadku wykrywania oszustw nie jest to jednak dokładnie to, czego oczekujemy. Najbardziej zależy nam na wyjaśnieniu przypadków, w których nasz model oznacza transakcję jako oszukańczą. Oznacza to, że punktem odniesienia, z którym chcemy porównać transakcje, są transakcje niebędące oszustwami.

Aby to uwzględnić, jako wartość odniesienia użyjemy wartości mediany transakcji niebędących oszustwami w naszym zbiorze danych. Medianę możemy uzyskać, korzystając z wyodrębnionego powyżej obiektu not_fraud_sample DataFrame i skalując go tak, aby pasował 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ć wartości bazowej. Jeśli tego nie zrobimy, pakiet SDK użyje wartości 0 jako wartości bazowej dla każdej wartości wejściowej, której oczekuje nasz model. W naszym przypadku wykrywania oszustw warto określić 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)

Uruchomienie powyższej metody save_metadata() spowodowało utworzenie w katalogu modelu pliku o nazwie explanation_metadata.json. W notatniku przejdź do katalogu fraud_model/, aby sprawdzić, czy plik został utworzony. Zawiera metadane, których pakiet SDK będzie używać do generowania atrybucji funkcji.

Krok 4. Uzyskiwanie wyjaśnień dotyczących modelu

Możemy teraz uzyskać atrybucje cech w przypadku poszczególnych przykładów. Aby to zrobić, najpierw utworzymy lokalną referencję do naszego modelu za pomocą pakietu SDK:

local_model = explainable_ai_sdk.load_model_from_local_path(
    model_dir, 
    explainable_ai_sdk.SampledShapleyConfig()
)

Następnie uzyskajmy prognozy i wyjaśnienia dotyczące naszego modelu na podstawie przykładowej transakcji, która powinna zostać zaklasyfikowana jako oszukańcza:

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()

Po uruchomieniu tego kodu powinna powstać wizualizacja podobna do tej poniżej:

W tym przykładzie największym wskaźnikiem oszustwa było początkowe saldo konta przed transakcją, które spowodowało, że prognoza naszego modelu wzrosła z wartości bazowej o ponad 0,5. Kolejnymi najważniejszymi wskaźnikami były kwota transakcji, 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” wyświetlany nad wizualizacjami informuje, w jakim stopniu możesz ufać wyjaśnieniu. Zazwyczaj błąd powyżej 5% oznacza, że nie możesz polegać na atrybucjach funkcji. Pamiętaj, że jakość wyjaśnień zależy od danych treningowych i użytego modelu. Zmniejszenie błędu aproksymacji może nastąpić dzięki ulepszeniu danych treningowych lub modelu albo wypróbowaniu innego modelu bazowego.

Możesz też zmniejszyć ten błąd, zwiększając liczbę kroków używanych w metodzie wyjaśniania. Możesz to zmienić w pakiecie SDK, dodając do konfiguracji wyjaśnienia parametr path_count (domyślnie jest to 10, jeśli nie określisz innej wartości):

local_model = explainable_ai_sdk.load_model_from_local_path(
    model_dir, 
    explainable_ai_sdk.SampledShapleyConfig(path_count=20)
)

Dzięki wyjaśnialnej AI możesz zrobić z tym modelem o wiele więcej. Oto kilka pomysłów:

Wysyłanie do naszego modelu wielu przykładów i obliczanie średniej wartości atrybucji, aby sprawdzić, czy niektóre funkcje są ogólnie ważniejsze. Możemy wykorzystać te informacje do ulepszenia naszego modelu i ewentualnego usunięcia funkcji, które nie są ważne.
Wyszukiwanie wyników fałszywie pozytywnych, które nasz model oznacza jako oszustwo, ale które są transakcjami niebędącymi oszustwem, oraz sprawdzanie ich wartości atrybucji.
Użyj innej wartości bazowej i sprawdź, jak wpłynie to na wartości atrybucji

🎉 Gratulacje! 🎉

Wiesz już, jak uwzględniać niezrównoważone dane, trenować model TensorFlow do wykrywania nieuczciwych transakcji i używać pakietu Explainable AI SDK, aby sprawdzać, na których cechach model opiera się najbardziej przy generowaniu poszczególnych prognoz. Jeśli chcesz, możesz na tym poprzestać. Korzystanie z pakietu SDK w notatniku ma na celu uproszczenie procesu tworzenia modelu poprzez zapewnienie dostępu do wyjaśnień przed wdrożeniem modelu. Gdy już utworzysz model, z którego jesteś zadowolony, prawdopodobnie zechcesz go wdrożyć, aby uzyskiwać prognozy na dużą skalę. Jeśli tak jest w Twoim przypadku, przejdź do następnego kroku (opcjonalnego). Jeśli wszystko jest gotowe, przejdź do kroku Czyszczenie.

7. Opcjonalnie: wdrażanie modelu w prognozowaniu w AI Platform

Z tego kroku dowiesz się, jak wdrożyć model w AI Platform Prediction.

Krok 1. Skopiuj zapisany katalog modelu do zasobnika Cloud Storage.

Po wykonaniu kroków związanych z pakietem SDK masz wszystko, czego potrzebujesz, aby wdrożyć model na platformie AI Platform. Aby przygotować się do wdrożenia, musisz umieścić zasoby SavedModel i metadane wyjaśnienia w zasobniku Cloud Storage, z którego usługa Explainable AI może odczytywać dane.

Aby to zrobić, zdefiniujemy kilka zmiennych środowiskowych. Wpisz poniżej 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 pamięci, w którym będziemy przechowywać wyeksportowane zasoby modelu TensorFlow. Podczas wdrażania modelu wskażemy AI Platform ten zasobnik.

Aby utworzyć zasobnik, uruchom to polecenie gsutil w notatniku:

!gsutil mb -l 'us-central1' $MODEL_BUCKET

Następnie skopiuj lokalny katalog modeli do tego zasobnika:

!gsutil -m cp -r ./$model_dir/* $MODEL_BUCKET/explanations

Krok 2. Wdróż model

Następnie zdefiniujemy zmienne, których będziemy używać w poleceniach wdrażania:

MODEL = 'fraud_detection'
VERSION = 'v1'
model_path = MODEL_BUCKET + '/explanations'

Model możemy utworzyć za pomocą tego polecenia gcloud:

!gcloud ai-platform models create $MODEL --region=us-central1

Teraz możemy wdrożyć pierwszą wersję tego modelu za pomocą gcloud. Wdrożenie wersji zajmie około 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

W przypadku flagi origin przekazujemy lokalizację zapisanego modelu i pliku metadanych w Cloud Storage. Wyjaśnialna AI ma obecnie 2 różne metody wyjaśniania dostępne w przypadku modeli tabelarycznych. Używamy tu próbkowanej wartości Shapleya. Parametr num-paths wskazuje liczbę ścieżek próbkowanych dla każdej cechy wejściowej. Ogólnie im bardziej złożony jest model, tym więcej kroków przybliżania jest potrzebnych do osiągnięcia rozsądnej zbieżności.

Aby sprawdzić, czy model został prawidłowo wdrożony, uruchom to polecenie gcloud:

!gcloud ai-platform versions describe $VERSION --model $MODEL --region=us-central1

Stan powinien być READY.

Krok 3. Uzyskiwanie prognoz i wyjaśnień dotyczących wdrożonego modelu

Na potrzeby wyjaśnialności najbardziej zależy nam na wyjaśnieniu przypadków, w których nasz model przewiduje oszustwo. Do naszego modelu wyślemy 5 przykładowych transakcji testowych, które są transakcjami oszukańczymi.

Do uzyskiwania prognoz będziemy używać Google Cloud CLI. Aby uzyskać indeksy wszystkich przykładów oszustw z naszego zbioru testowego, uruchom ten kod:

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 nasz 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)

Możemy wysłać do naszego modelu te 5 przykładów za pomocą gcloud:

!gcloud beta ai-platform explain \
--model=$MODEL \
--version=$VERSION \
--region='us-central1' \
--json-request=prediction.json

W odpowiedzi JSON zobaczysz wartości atrybucji dla każdej funkcji w tych przykładach. Klucz example_score w każdym przykładzie zawiera prognozę modelu – w tym przypadku procentowe prawdopodobieństwo, że dana transakcja jest oszustwem.

8. Czyszczenie

Jeśli chcesz nadal korzystać z tego notebooka, zalecamy wyłączanie go, gdy nie jest używany. W interfejsie Notebooks 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ć.

W menu nawigacyjnym w konsoli Cloud otwórz Storage i usuń oba utworzone zasobniki do przechowywania zasobów modelu.