1. Omówienie
W tym module użyjesz narzędzia What-If, aby przeanalizować model XGBoost wytrenowany na danych finansowych. Po przeanalizowaniu modelu wdrożysz go w nowym Vertex AI w Cloud.
Czego się dowiesz
Poznasz takie zagadnienia jak:
- Wytrenuj model XGBoost na publicznym zbiorze danych hipotecznych w hostowanym notatniku
- Przeprowadź analizę modelu za pomocą narzędzia What-If
- Wdrażanie modelu XGBoost w Vertex AI
Całkowity koszt uruchomienia tego modułu w Google Cloud wynosi około 1 USD.
2. Wprowadzenie do Vertex AI
W tym module wykorzystano najnowszą ofertę usług AI dostępną w Google Cloud. Vertex AI integruje ofertę systemów uczących się z całego Google Cloud, tworząc bezproblemowe środowisko programistyczne. Wcześniej modele wytrenowane z użyciem AutoML i modele niestandardowe były dostępne w oddzielnych usługach. Nowa oferta jest łączona w 1 interfejs API wraz z innymi nowymi usługami. Możesz też przenieść istniejące projekty do Vertex AI. Jeśli masz jakieś uwagi, odwiedź stronę pomocy.
Vertex AI obejmuje wiele różnych usług, które obsługują kompleksowe przepływy pracy ML. W tym module skupimy się na wyróżnionych poniżej usługach: prognozach i notatnikach.
3. Szybki kurs XGBoost
XGBoost to platforma systemów uczących się, która do tworzenia modeli prognozujących wykorzystuje drzewa decyzyjne i wzmacnianie gradientu. Łączy wiele drzew decyzyjnych na podstawie wyniku powiązanego z różnymi węzłami liści w drzewie.
Poniższy diagram przedstawia wizualizację prostego modelu drzewa decyzyjnego, który na podstawie prognozy pogody ocenia, czy należy rozegrać mecz sportowy:
Dlaczego w tym modelu używamy XGBoost? Wykazano, że tradycyjne sieci neuronowe radzą sobie najlepiej w przypadku nieuporządkowanych danych, takich jak obrazy i tekst. Jednak drzewa decyzyjne często radzą sobie bardzo dobrze w przypadku uporządkowanych danych, takich jak zbiór danych hipotecznych, który będziemy wykorzystywać w tym ćwiczeniu z programowania.
4. 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 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 2. Włącz interfejs Vertex AI API
Przejdź do sekcji Vertex AI w konsoli Cloud i kliknij Włącz interfejs Vertex AI API.
Krok 3. Utwórz instancję Notatników
W sekcji Vertex konsoli Cloud kliknij Notatniki:
Następnie kliknij Nowa instancja. Następnie wybierz typ instancji TensorFlow Enterprise 2.3 bez GPU:
Użyj opcji domyślnych i kliknij Utwórz. Po utworzeniu instancji wybierz Otwórz JupyterLab.
Krok 4. Zainstaluj XGBoost
Po otwarciu instancji JupyterLab dodaj pakiet XGBoost.
Aby to zrobić, wybierz Terminal w programie uruchamiającym:
Następnie uruchom to polecenie, aby zainstalować najnowszą wersję XGBoost obsługiwanej przez Vertex AI:
pip3 install xgboost==1.2
Po zakończeniu otwórz instancję notatnika w Pythonie 3 z programu uruchamiającego. Możesz zacząć korzystać z notatnika.
Krok 5. Zaimportuj pakiety Pythona
W pierwszej komórce notatnika dodaj poniższe importy i uruchom komórkę. Aby go uruchomić, naciśnij przycisk ze strzałką w prawo w górnym menu lub naciśnij Command i Enter:
import pandas as pd
import xgboost as xgb
import numpy as np
import collections
import witwidget
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score, confusion_matrix
from sklearn.utils import shuffle
from witwidget.notebook.visualization import WitWidget, WitConfigBuilder
5. Pobieranie i przetwarzanie danych
Do wytrenowania modelu XGBoost użyjemy zbioru danych o kredytach hipotecznych z ffiec.gov. Przeprowadziliśmy wstępne przetwarzanie pierwotnego zbioru danych i utworzyliśmy jego mniejszą wersję, której możesz używać do trenowania modelu. Model przewiduje, czy dany wniosek o kredyt hipoteczny zostanie rozpatrzony pozytywnie.
Krok 1. Pobierz wstępnie przetworzony zbiór danych
Udostępniliśmy Ci wersję zbioru danych w Google Cloud Storage. Możesz go pobrać, uruchamiając w notatniku Jupyter to polecenie gsutil:
!gsutil cp 'gs://mortgage_dataset_files/mortgage-small.csv' .
Krok 2. Odczytaj zbiór danych za pomocą usługi Pandas
Przed utworzeniem ramki DataFrame biblioteki Pandas utworzymy dict typu danych każdej kolumny, aby umożliwić Pandas prawidłowe odczytywanie zbioru danych:
COLUMN_NAMES = collections.OrderedDict({
'as_of_year': np.int16,
'agency_code': 'category',
'loan_type': 'category',
'property_type': 'category',
'loan_purpose': 'category',
'occupancy': np.int8,
'loan_amt_thousands': np.float64,
'preapproval': 'category',
'county_code': np.float64,
'applicant_income_thousands': np.float64,
'purchaser_type': 'category',
'hoepa_status': 'category',
'lien_status': 'category',
'population': np.float64,
'ffiec_median_fam_income': np.float64,
'tract_to_msa_income_pct': np.float64,
'num_owner_occupied_units': np.float64,
'num_1_to_4_family_units': np.float64,
'approved': np.int8
})
Następnie utworzymy element DataFrame, przekazując do niej typy danych określone powyżej. Dane należy tasować, jeśli oryginalny zbiór danych jest uporządkowany w określony sposób. Do tego celu użyliśmy narzędzia sklearn o nazwie shuffle, które zaimportowaliśmy w pierwszej komórce:
data = pd.read_csv(
'mortgage-small.csv',
index_col=False,
dtype=COLUMN_NAMES
)
data = data.dropna()
data = shuffle(data, random_state=2)
data.head()
data.head() umożliwia nam podgląd pierwszych 5 wierszy zbioru danych w usłudze Pandas. Po uruchomieniu kodu z górnej komórki zobaczysz coś takiego:
Oto funkcje, których użyjemy do trenowania naszego modelu. Jeśli przewiniesz do końca, zobaczysz ostatnią kolumnę approved, którą zgodnie z przewidywaniami przewidujemy. Wartość 1 oznacza, że dany wniosek został zatwierdzony, a 0 oznacza, że został odrzucony.
Aby zobaczyć rozkład zatwierdzonych / odrzuconych wartości w zbiorze danych i utworzyć tablicę numpy etykiet, uruchom to polecenie:
# Class labels - 0: denied, 1: approved
print(data['approved'].value_counts())
labels = data['approved'].values
data = data.drop(columns=['approved'])
Około 66% zbioru danych zawiera zatwierdzone aplikacje.
Krok 3. Utwórz zastępczą kolumnę dla wartości kategorialnych
Ten zbiór danych zawiera zarówno wartości kategorialne, jak i liczbowe, przy czym XGBoost wymaga, aby wszystkie cechy miały wartości liczbowe. Zamiast reprezentować wartości kategorialne za pomocą kodowania jednorazowego, w naszym modelu XGBoost użyjemy funkcji Pandas get_dummies.
get_dummies pobiera kolumnę z wieloma możliwymi wartościami i przekształca ją w serię kolumn, z których każda ma tylko 0 i 1. Jeśli np. mamy kolumnę „kolor”, z możliwymi wartościami „niebieski” i „czerwony”, get_dummies spowoduje przekształcenie tej wartości w 2 kolumny o nazwie „color_blue” i „color_red” ze wszystkimi wartościami logicznymi 0 i 1.
Aby utworzyć fikcyjne kolumny dla naszych cech kategorialnych, uruchom ten kod:
dummy_columns = list(data.dtypes[data.dtypes == 'category'].index)
data = pd.get_dummies(data, columns=dummy_columns)
data.head()
Podczas wyświetlania podglądu danych tym razem zobaczysz pojedyncze funkcje (np. purchaser_type na ilustracji poniżej) podzielone na wiele kolumn:
Krok 4. Podziel dane na zbiory do trenowania i testowania
Ważną koncepcją w przypadku systemów uczących się jest podział na trenowanie i testy. Większości naszych danych użyjemy do trenowania naszego modelu, a resztę pozostawimy na przetestowanie modelu na podstawie nieznanych wcześniej danych.
Dodaj do notatnika poniższy kod, który używa do podziału danych za pomocą funkcji Scikit-learn train_test_split:
x,y = data.values,labels
x_train,x_test,y_train,y_test = train_test_split(x,y)
Możesz teraz utworzyć i wytrenować model.
6. Zbuduj, wytrenuj i oceń model XGBoost
Krok 1. Zdefiniuj i wytrenuj model XGBoost
Tworzenie modelu w XGBoost jest proste. Do utworzenia modelu użyjemy klasy XGBClassifier, wystarczy przekazać odpowiedni parametr objective dla konkretnego zadania klasyfikacji. W tym przypadku używamy funkcji reg:logistic, ponieważ mamy problem z klasyfikacją binarną i chcemy, aby model generował jedną wartość z zakresu (0,1): 0 – niezatwierdzone i 1 – zatwierdzone.
Ten kod utworzy model XGBoost:
model = xgb.XGBClassifier(
objective='reg:logistic'
)
Możesz wytrenować model za pomocą 1 wiersza kodu, wywołując metodę fit() i przekazując mu dane treningowe oraz etykiety.
model.fit(x_train, y_train)
Krok 2. Oceń dokładność modelu
Możemy teraz używać wytrenowanego modelu do generowania prognoz na podstawie danych testowych za pomocą funkcji predict().
Następnie użyjemy funkcji accuracy_score() Scikit-learn, aby obliczyć dokładność naszego modelu na podstawie jego skuteczności na podstawie danych testowych. Przekażemy do niego wartości danych podstawowych (ground truth) wraz z prognozowanymi wartościami modelu dla każdego przykładu w naszym zbiorze testowym:
y_pred = model.predict(x_test)
acc = accuracy_score(y_test, y_pred.round())
print(acc, '\n')
Dokładność powinna wynosić około 87%, ale wartość ta będzie nieco inna, ponieważ w uczeniu maszynowym zawsze występuje element losowości.
Krok 3. Zapisz model
Aby wdrożyć model, uruchom ten kod w celu zapisania go w pliku lokalnym:
model.save_model('model.bst')
7. Interpretowanie modelu za pomocą narzędzia What-If
Krok 1. Utwórz wizualizację narzędzia What-If
Aby połączyć narzędzie What-If z modelem lokalnym, musisz przekazać mu podzbiór przykładów testowych wraz z wartościami danych podstawowych (ground truth). Utwórzmy tablicę Numpy zawierającą 500 naszych przykładów testowych wraz z ich etykietami danych podstawowych (ground truth):
num_wit_examples = 500
test_examples = np.hstack((x_test[:num_wit_examples],y_test[:num_wit_examples].reshape(-1,1)))
Utworzenie instancji narzędzia What-If wymaga jedynie utworzenia obiektu WitConfigBuilder i przesłania go modelu, który chcemy przeanalizować.
Ponieważ narzędzie What-If oczekuje listy wyników dla każdej klasy w naszym modelu (w tym przypadku 2), użyjemy metody predict_probaXGBoost z narzędziem What-If:
config_builder = (WitConfigBuilder(test_examples.tolist(), data.columns.tolist() + ['mortgage_status'])
.set_custom_predict_fn(model.predict_proba)
.set_target_feature('mortgage_status')
.set_label_vocab(['denied', 'approved']))
WitWidget(config_builder, height=800)
Pamiętaj, że wczytanie wizualizacji może potrwać około minuty. Po załadowaniu powinien pojawić się ten komunikat:
Oś Y przedstawia prognozę modelu, przy czym 1 to prognoza approved o wysokim poziomie ufności, a 0 – prognoza denied o wysokim poziomie ufności. Oś X to jedynie rozkład wszystkich wczytanych punktów danych.
Krok 2. Sprawdź poszczególne punkty danych
Domyślnym widokiem w narzędziu What-If jest karta Edytor punktów danych. W tym miejscu możesz kliknąć dowolny punkt danych, aby zobaczyć jego cechy, zmienić wartości cech i zobaczyć, jak ta zmiana wpływa na prognozę modelu w konkretnym punkcie danych.
W poniższym przykładzie wybraliśmy punkt danych bliski progu 0,5. Wniosek o kredyt hipoteczny powiązany z tym konkretnym punktem danych pochodzi z CFPB. Zmieniliśmy tę funkcję na 0 i zmieniliśmy też wartość agency_code_Department of Housing and Urban Development (HUD) na 1, aby sprawdzić, co stanie się z prognozą modelu, gdyby ta kredyt pochodziła z HUD:
Jak widać w lewym dolnym rogu narzędzia What-If, zmiana tej funkcji znacznie obniżyła prognozowaną wartość approved modelu o 32%. Może to oznaczać, że agencja, z której pochodzi pożyczka, ma duży wpływ na wyniki modelu, ale aby mieć pewność, że musimy przeprowadzić dokładniejszą analizę.
W lewym dolnym rogu interfejsu użytkownika możemy też zobaczyć wartość danych podstawowych (ground truth) dla każdego punktu danych i porównać ją z prognozą modelu:
Krok 3. Analiza kontrfaktyczna
Następnie kliknij dowolny punkt danych i przesuń suwak Pokaż najbliższy kontrfaktyczny punkt danych w prawo:
Wybranie tej opcji spowoduje wyświetlenie punktu danych, który ma najbardziej podobne wartości cech do oryginalnego wybranego punktu, ale prognoza jest odwrotna. Następnie możesz przejrzeć wartości cech, aby zobaczyć, czym różnią się te 2 punkty danych (różnice są wyróżnione kolorem zielonym i pogrubionym).
Krok 4. Przyjrzyj się wykresom zależności częściowych
Aby zobaczyć, jak poszczególne cechy wpływają na ogólne prognozy modelu, zaznacz pole Wykresy zależności częściowych i upewnij się, że wybrana jest opcja Globalne wykresy zależności częściowych:
Widać tu, że w przypadku kredytów udzielanych w systemie HUD istnieje nieco większe prawdopodobieństwo ich odrzucenia. Wykres ma taki kształt, ponieważ kod agencji jest funkcją logiczną, więc wartości mogą być tylko dokładnie 0 lub 1.
applicant_income_thousands to funkcja liczbowa, a na wykresie zależności częściowej widzimy, że wyższy dochód nieznacznie zwiększa prawdopodobieństwo zatwierdzenia zgłoszenia, ale tylko do ok. 200 tys. USD. Po 200 tys. USD ta funkcja nie wpływa na prognozę modelu.
Krok 5. Przeanalizuj ogólną skuteczność i obiektywność
Następnie przejdź do sekcji Wydajność i Obiektywność. Pokazuje ogólne statystyki wydajności modelu w dostarczonym zbiorze danych, w tym tablice pomyłek, krzywe PR i krzywe ROC.
Wybierz mortgage_status jako funkcję danych podstawowych, aby wyświetlić tablicę pomyłek:
Ta tablica pomyłek pokazuje prawidłowe i nieprawidłowe prognozy naszego modelu jako odsetek całości. Jeśli dodasz kwadraty rzeczywiste tak / prognozowane tak i rzeczywiste nie / prognozowane nie, powinny one uzyskać taką samą dokładność jak Twój model (w tym przypadku około 87%, choć model może się nieznacznie różnić, ponieważ w trenowanych modelach ML występuje element losowości).
Możesz też eksperymentować z suwakiem progu, zwiększając lub obniżając dodatni wynik klasyfikacji, który model musi zwrócić, zanim zdecyduje się na przewidywaną approved dla kredytu, i zobacz, jak zmienia to dokładność, wyniki fałszywie pozytywne i fałszywie negatywne. W tym przypadku dokładność jest najwyższa na poziomie progowym 0, 55.
Następnie w menu Wydziel według po lewej stronie wybierz loan_purpose_Home_purchase:
Teraz dane dotyczące skuteczności będą wyświetlane w dwóch podzbiorach danych: „0” wycinek pokazuje, kiedy kredyt nie dotyczy zakupu domu, oraz „1”. wycinek jest używany, gdy pożyczka jest przeznaczona na zakup domu. Sprawdź współczynniki dokładności, wyników fałszywie pozytywnych i fałszywie negatywnych między tymi dwoma wycinkami, aby znaleźć różnice w skuteczności.
Jeśli rozwiniesz wiersze, aby przyjrzeć się tablicom pomyłek, zobaczysz, że model przewiduje, że model jest „zatwierdzony” w przypadku ok. 70% wniosków o kredyt na zakup domu i tylko 46% kredytów nieobejmujących domu (dokładne wartości procentowe mogą być różne w zależności od modelu):
Jeśli za pomocą opcji po lewej stronie wybierzesz Spójność demograficzna, dwa progi zostaną dostosowane w taki sposób, że model przewiduje approved dla podobnego odsetka kandydatów w obu wycinkach. Jaki ma to wpływ na dokładność, wyniki fałszywie pozytywne i fałszywie negatywne dla każdego wycinka?
Krok 6. Poznaj rozkład funkcji
Na koniec otwórz kartę Funkcje w narzędziu What-If. Pokazuje to rozkład wartości poszczególnych cech w zbiorze danych:
Za pomocą tej karty możesz sprawdzić, czy zbiór danych jest zrównoważony. Na przykład wygląda na to, że tylko niewiele pożyczek w zbiorze danych pochodzi od Agencji Usług rolnych. Aby poprawić dokładność modelu, możemy rozważyć dodanie większej liczby pożyczek od tej agencji, jeśli dane będą dostępne.
Opisaliśmy tu tylko kilka pomysłów na eksplorację w narzędziu What-If. Możesz nadal eksperymentować z tym narzędziem, ponieważ jest jeszcze więcej obszarów do zbadania.
8. Wdrażanie modelu w Vertex AI
Nasz model działa lokalnie, ale przydałoby się prognozowanie z dowolnego miejsca (nie tylko z tego notatnika). W tym kroku wdrożymy go w chmurze.
Krok 1. Utwórz zasobnik Cloud Storage dla naszego modelu
Najpierw zdefiniujmy kilka zmiennych środowiskowych, których będziemy używać w dalszej części tego ćwiczenia. Wypełnij poniższe wartości, wpisując nazwę projektu Google Cloud, nazwę zasobnika Cloud Storage, który chcesz utworzyć (musi być globalnie unikalna) oraz nazwę wersji pierwszej wersji modelu:
# Update the variables below to your own Google Cloud project ID and GCS bucket name. You can leave the model name we've specified below:
GCP_PROJECT = 'your-gcp-project'
MODEL_BUCKET = 'gs://storage_bucket_name'
MODEL_NAME = 'xgb_mortgage'
Teraz możemy utworzyć zasobnik na dane, w którym będzie przechowywany plik modelu XGBoost. Podczas wdrażania wskażemy ten plik Vertex AI.
Aby utworzyć regionalny zasobnik na dane, uruchom to polecenie gsutil z poziomu notatnika:
!gsutil mb -l us-central1 $MODEL_BUCKET
Krok 2. Skopiuj plik modelu do Cloud Storage
Następnie skopiujemy plik zapisanego modelu XGBoost do Cloud Storage. Uruchom to polecenie gsutil:
!gsutil cp ./model.bst $MODEL_BUCKET
Otwórz przeglądarkę pamięci masowej w konsoli Cloud i sprawdź, czy plik został skopiowany:
Krok 3. Utwórz model i wdróż go w punkcie końcowym
Jesteśmy prawie gotowi do wdrożenia modelu w chmurze. W Vertex AI model może obsługiwać wiele punktów końcowych. Najpierw utworzymy model, a potem utworzymy w nim punkt końcowy i wdrożymy go.
Najpierw utwórz model za pomocą interfejsu wiersza poleceń gcloud:
!gcloud beta ai models upload \
--display-name=$MODEL_NAME \
--artifact-uri=$MODEL_BUCKET \
--container-image-uri=us-docker.pkg.dev/cloud-aiplatform/prediction/xgboost-cpu.1-2:latest \
--region=us-central1
Parametr artifact-uri wskazuje lokalizację pamięci masowej, w której został zapisany model XGBoost. Parametr container-image-uri informuje Vertex AI, który gotowy kontener ma zostać użyty do udostępniania. Po zakończeniu tego polecenia przejdź do sekcji modeli w konsoli Vertex, aby uzyskać identyfikator nowego modelu. Znajdziesz ją tutaj:
Skopiuj ten identyfikator i zapisz go w zmiennej:
MODEL_ID = "your_model_id"
Teraz czas utworzyć punkt końcowy w tym modelu. Użyjemy tego polecenia gcloud:
!gcloud beta ai endpoints create \
--display-name=xgb_mortgage_v1 \
--region=us-central1
Gdy to zrobisz, w danych wyjściowych notatnika powinna pojawić się lokalizacja punktu końcowego. Odszukaj wiersz z informacją, że punkt końcowy został utworzony ze ścieżką podobną do tej: projects/project_ID/locations/us-central1/endpoints/endpoint_ID. Następnie zastąp wartości widoczne poniżej identyfikatorami punktu końcowego utworzonego powyżej:
ENDPOINT_ID = "your_endpoint_id"
Aby wdrożyć punkt końcowy, uruchom to polecenie gcloud:
!gcloud beta ai endpoints deploy-model $ENDPOINT_ID \
--region=us-central1 \
--model=$MODEL_ID \
--display-name=xgb_mortgage_v1 \
--machine-type=n1-standard-2 \
--traffic-split=0=100
Wdrożenie punktu końcowego zajmie około 5–10 minut. Podczas wdrażania punktu końcowego otwórz sekcję modeli w konsoli. Kliknij model, a pojawi się wdrożenie modelu:
Po zakończeniu wdrażania, w miejscu wskaźnika postępu ładowania pojawi się zielony znacznik wyboru.
Krok 4. Przetestuj wdrożony model
Aby mieć pewność, że wdrożony model działa, przetestuj go za pomocą gcloud w celu utworzenia prognozy. Najpierw zapisz plik JSON z przykładem z naszego zbioru testowego:
%%writefile predictions.json
{
"instances": [
[2016.0, 1.0, 346.0, 27.0, 211.0, 4530.0, 86700.0, 132.13, 1289.0, 1408.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 1.0, 0.0, 1.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 1.0, 0.0]
]
}
Przetestuj model, uruchamiając to polecenie gcloud:
!gcloud beta ai endpoints predict $ENDPOINT_ID \
--json-request=predictions.json \
--region=us-central1
Prognoza modelu powinna pojawić się w danych wyjściowych. Ten konkretny przykład został zatwierdzony, dlatego wartość powinna być zbliżona do 1.
9. 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ć.
Aby usunąć wdrożony punkt końcowy, przejdź do sekcji Punkty końcowe w konsoli Vertex i kliknij ikonę usuwania:
Aby usunąć zasobnik na dane, w menu nawigacyjnym w konsoli Google Cloud otwórz Cloud Storage, wybierz swój zasobnik i kliknij Usuń:
