1. Omówienie
W tym module użyjesz narzędzia What-If do analizy modelu XGBoost wytrenowanego na podstawie danych finansowych. Po przeanalizowaniu modelu wdrożysz go w nowym Vertex AI w Cloud.
Czego się nauczysz
Poznasz takie zagadnienia jak:
- Trenowanie modelu XGBoost na podstawie publicznego zbioru danych o kredytach hipotecznych w hostowanym notatniku
- Analizowanie modelu za pomocą narzędzia What-If
- Wdrażanie modelu XGBoost w Vertex AI
Łączny koszt przeprowadzenia tego laboratorium w Google Cloud wynosi około 1 USD.
2. Wprowadzenie do Vertex AI
Ten moduł wykorzystuje najnowszą ofertę usług AI dostępną w Google Cloud. Vertex AI integruje rozwiązania ML w Google Cloud, zapewniają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 łączy oba te interfejsy API 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 zawiera wiele różnych usług, które obsługują kompleksowe przepływy pracy związane z systemami uczącymi się. W tym module skupimy się na usługach wymienionych poniżej: Prediction i Notebooks.
3. Krótkie wprowadzenie do XGBoost
XGBoost to framework uczenia maszynowego, który do tworzenia modeli prognostycznych wykorzystuje drzewa decyzyjne i wzmacnianie gradientowe. Działa ona przez łączenie wielu drzew decyzyjnych na podstawie wyniku powiązanego z różnymi węzłami liścia w drzewie.
Diagram poniżej to wizualizacja prostego modelu drzewa decyzyjnego, który na podstawie prognozy pogody ocenia, czy warto zagrać w mecz sportowy:
Dlaczego w przypadku tego modelu używamy XGBoost? Chociaż tradycyjne sieci neuronowe sprawdzają się najlepiej w przypadku danych nieuporządkowanych, takich jak obrazy i tekst, drzewa decyzyjne często działają bardzo dobrze na danych uporządkowanych, takich jak zbiór danych o kredytach hipotecznych, którego użyjemy w tym samouczku.
4. Skonfiguruj środowisko
Aby uruchomić to ćwiczenie, musisz mieć projekt Google Cloud Platform z włączonym rozliczeniem. Aby utworzyć projekt, postępuj zgodnie z tymi instrukcjami.
Krok 1. Włącz Compute Engine API
Przejdź do Compute Engine i wybierz Włącz, jeśli usługa 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 konsoli Cloud w sekcji Vertex kliknij Notebooki:
Następnie kliknij Nowa instancja. Następnie wybierz typ instancji TensorFlow Enterprise 2.3 bez GPU:
Użyj domyślnych opcji i kliknij Utwórz. Po utworzeniu instancji kliknij Otwórz JupyterLab.
Krok 4. Zainstaluj XGBoost
Po otwarciu instancji JupyterLab musisz dodać pakiet XGBoost.
Aby to zrobić, wybierz Terminal w Menu z aplikacjami:
Następnie uruchom następujące polecenie, aby zainstalować najnowszą wersję XGBoost obsługiwanej przez Vertex AI:
pip3 install xgboost==1.2
Gdy to zrobisz, 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 te instrukcje importu 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 trenowania modelu XGBoost użyjemy zbioru danych o kredytach hipotecznych z ffiec.gov. Przeprowadziliśmy wstępne przetwarzanie oryginalnego zbioru danych i utworzyliśmy jego mniejszą wersję, którą możesz wykorzystać do trenowania modelu. Model będzie przewidywać, czy dany wniosek o kredyt hipoteczny zostanie zatwierdzony.
Krok 1. Pobierz 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
Zanim utworzymy strukturę DataFrame biblioteki Pandas, utworzymy dict typu danych każdej kolumny, aby Pandas poprawnie odczytał nasz zbiór 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żywamy narzędzia sklearn o nazwie shuffle, które zostało zaimportowane do pierwszej komórki:
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() pozwala wyświetlić podgląd pierwszych 5 wierszy zbioru danych w Pandas. Po uruchomieniu komórki powyżej powinieneś zobaczyć coś takiego:
To funkcje, których użyjemy do trenowania modelu. Jeśli przewiniesz do końca, zobaczysz ostatnią kolumnę approved, która zawiera przewidywane dane. Wartość 1 oznacza, że określona aplikacja została zatwierdzona, a wartość 0 – że została odrzucona.
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. Tworzenie kolumny zastępczej dla wartości porządkowych
Ten zbiór danych zawiera wartości liczbowe i kategorialne, ale XGBoost wymaga, aby wszystkie cechy były liczbowe. Zamiast przedstawiać wartości jakościowe za pomocą kodowania jednobitowego, w przypadku modelu XGBoost użyjemy funkcji get_dummies z biblioteki Pandas.
Funkcja get_dummies przekształca kolumnę z wieloma możliwymi wartościami w serię kolumn zawierających tylko 0 i 1. Jeśli np. mamy kolumnę „color” z możliwymi wartościami „niebieski” i „czerwony”, funkcja get_dummies przekształci ją w 2 kolumny o nazwach „color_blue” i „color_red” z wartościami logicznymi 0 i 1.
Aby utworzyć kolumny zastępcze dla cech jakościowych, uruchom ten kod:
dummy_columns = list(data.dtypes[data.dtypes == 'category'].index)
data = pd.get_dummies(data, columns=dummy_columns)
data.head()
Gdy tym razem wyświetlisz podgląd danych, zobaczysz, że pojedyncze cechy (np. purchaser_type na rysunku poniżej) są podzielone na kilka kolumn:
Krok 4. Dzielenie danych na zbiory do trenowania i testowania
Ważnym pojęciem w uczeniu maszynowym jest podział na dane szkoleniowe i testowe. Większość danych wykorzystamy do trenowania modelu, a resztę przeznaczymy na testowanie modelu na danych, których wcześniej nie widział.
Dodaj do notatnika ten kod, który używa funkcji Scikit-learn train_test_split do podziału danych:
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. Tworzenie, trenowanie i ocenianie modelu XGBoost
Krok 1. Zdefiniuj i wytrenuj model XGBoost
Utworzenie modelu w XGBoost jest proste. Do utworzenia modelu użyjemy klasy XGBClassifier. Musimy tylko przekazać odpowiedni parametr objective do 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 – nie zatwierdzono, 1 – zatwierdzone.
Poniższy kod utworzy model XGBoost:
model = xgb.XGBClassifier(
objective='reg:logistic'
)
Model można wytrenować za pomocą jednego wiersza kodu, wywołując metodę fit() i przekazując jej dane szkoleniowe 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() z biblioteki Scikit-learn, aby obliczyć dokładność modelu na podstawie jego działania na danych testowych. Przekażemy mu wartości danych podstawowych wraz z wartościami prognozowanymi przez model 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 może się nieco różnić, ponieważ systemy uczące się zawsze działają z pewnym odchyleniem.
Krok 3. Zapisz model
Aby wdrożyć model, uruchom podany niżej kod, aby zapisać 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 Twoim modelem lokalnym, musisz przekazać mu podzbiór przykładów testowych wraz z odpowiednimi wartościami danych rzeczywistych. Utwórzmy tablicę Numpy z 500 przykładami testowymi wraz z ich etykietami danych rzeczywistych:
num_wit_examples = 500
test_examples = np.hstack((x_test[:num_wit_examples],y_test[:num_wit_examples].reshape(-1,1)))
Tworzenie instancji narzędzia What-If jest tak proste, jak tworzenie obiektu WitConfigBuilder i przekazywanie mu modelu, który chcemy przeanalizować.
Narzędzie „Co jeśli?” oczekuje listy wyników dla każdej klasy w naszym modelu (w tym przypadku 2), dlatego użyjemy w nim metody predict_proba z XGBoost:
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 jego załadowaniu powinieneś zobaczyć:
Oś Y przedstawia prognozę modelu, przy czym 1 to prognoza approved o wysokiej pewności, a 0 to prognoza denied o wysokiej pewności. Oś X to po prostu rozrzut wszystkich załadowanych punktów danych.
Krok 2. Przejrzyj poszczególne punkty danych
Domyślnym widokiem w narzędziu Co jeśli jest karta Edytor punktu danych. Możesz kliknąć dowolny punkt danych, aby wyświetlić jego cechy, zmienić wartości cech i sprawdzić, jak ta zmiana wpływa na prognozę modelu dla tego punktu danych.
W poniższym przykładzie wybraliśmy punkt danych bliski progu 0,5. Wniosek o kredyt hipoteczny powiązany z tym 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 pożyczka pochodziła z HUD:
Jak widać w sekcji w lewym dolnym rogu narzędzia „Co jeśli?”, zmiana tej funkcji spowodowała znaczne obniżenie prognozy approved modelu o 32%. Może to wskazywać, że agencja, z której pochodzi kredyt, ma duży wpływ na wyniki modelu, ale aby mieć pewność, musimy przeprowadzić więcej analiz.
W lewym dolnym rogu interfejsu użytkownika można też zobaczyć wartość danych rzeczywistych dla każdego punktu danych i porównać ją z prognozą modelu:
Krok 3. Analiza kontrafaktualna
Następnie kliknij dowolny punkt danych i przesuń suwak Pokaż najbliższy punkt danych kontrafaktualnego 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 przewijać wartości cech, aby sprawdzić, w których miejscach różnią się te 2 punkty danych (różnice są wyróżnione na zielono i pogrubione).
Krok 4. Sprawdź wykresy zależności częściowej
Aby sprawdzić, jak poszczególne cechy wpływają na ogólne prognozy modelu, zaznacz pole Wykresy zależności częściowej i upewnij się, że wybrane jest Wykresy globalnej zależności częściowej:
Widać tu, że kredyty pochodzące z HUD mają nieco większą szansę na odrzucenie. Wynika to z tego, że kod agencji to cecha logiczna, która może przyjmować tylko wartości 0 i 1.
applicant_income_thousands to cecha liczbowa, a z wykresu zależności częściowej wynika, że im wyższe dochody, tym większa szansa na zatwierdzenie wniosku, ale tylko do około 200 tys. USD. Po przekroczeniu tej kwoty ta cecha nie ma wpływu na prognozę modelu.
Krok 5. Sprawdź ogólną skuteczność i sprawiedliwość
Następnie otwórz kartę 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 modelu jako odsetek wszystkich prognoz. 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, podnosząc i obniżając wynik klasyfikacji pozytywnej, który model musi zwrócić, zanim zdecyduje się przewidzieć approved dla kredytu, i obserwować, jak to wpływa na dokładność, wyniki fałszywie pozytywne i fałszywie negatywne. W tym przypadku dokładność jest najwyższa w okolicach progu 0, 55.
Następnie w menu Podział według po lewej stronie kliknij loan_purpose_Home_purchase:
Teraz zobaczysz skuteczność 2 podzbiorów danych: klatka „0” pokazuje, kiedy kredyt nie jest przeznaczony na zakup domu, a klatka „1” – kiedy jest na ten cel. Aby sprawdzić różnice w skuteczności, porównaj między 2 krojami wskaźniki dokładności, fałszywie pozytywnych i fałszywie negatywnych.
Jeśli rozwiniesz wiersze, aby wyświetlić macierze błędu, zobaczysz, że model przewiduje „zatwierdzone” w przypadku około 70% wniosków o kredyt na zakup domu i tylko 46% wniosków o kredyt na inne cele (dokładne wartości procentowe zależą od modelu):
Jeśli w przypadku opcji przycisków opcji po lewej stronie wybierzesz Parytet demograficzny, oba progi zostaną dostosowane tak, aby model przewidywał approved dla podobnego odsetka kandydatów w obu przekrojach. Jaki ma to wpływ na dokładność, wyniki fałszywie pozytywne i fałszywie negatywne dla każdego wycinka?
Krok 6. Sprawdź rozpowszechnienie funkcji
Na koniec otwórz kartę Funkcje w narzędziu What-If. Widzisz tu rozkład wartości każdej cechy w zbiorze danych:
Na tej karcie 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 zwiększyć dokładność modelu, możemy rozważyć dodanie większej liczby kredytów z tej agencji, jeśli dane są dostępne.
Poniżej opisaliśmy tylko kilka pomysłów na wykorzystanie narzędzia What-If. Możesz dalej eksperymentować z tym narzędziem, ponieważ masz do odkrycia jeszcze wiele innych obszarów.
8. Wdrażanie modelu w Vertex AI
Mamy model działający lokalnie, ale chcielibyśmy, aby można było tworzyć na jego podstawie prognozy z dowolnego miejsca (nie tylko na tym notebooku). W tym kroku wdrożymy go w chmurze.
Krok 1. Utwórz zasobnik Cloud Storage dla modelu
Najpierw zdefiniujmy kilka zmiennych środowiskowych, których będziemy używać w dalszej części tego ćwiczenia z programowania. 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'
Możemy teraz utworzyć zasobnik danych, w którym będzie przechowywany plik modelu XGBoost. Wdrożymy Vertex AI, wskazując ten plik.
Aby utworzyć regionalny zasobnik na dane, uruchom to polecenie gsutil w notatniku:
!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 już prawie gotowi do wdrożenia modelu w chmurze. W Vertex AI model może zawierać wiele punktów końcowych. Najpierw utworzymy model, a potem w jego ramach utworzymy punkt końcowy i go wdrożymy.
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órego gotowego kontenera użyć do obsługi. 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 możesz utworzyć punkt końcowy w tym modelu. Możemy to zrobić za pomocą tego polecenia gcloud:
!gcloud beta ai endpoints create \
--display-name=xgb_mortgage_v1 \
--region=us-central1
Po zakończeniu tego procesu w wyjściu z notatnika powinna być widoczna lokalizacja punktu końcowego. Znajdź wiersz, w którym jest mowa o tym, że punkt końcowy został utworzony z ścieżką podobną do tej: projects/project_ID/locations/us-central1/endpoints/endpoint_ID. Następnie zastąp podane niżej wartości identyfikatorami utworzonego powyżej punktu końcowego:
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
Wdrażanie punktu końcowego może potrwać 5–10 minut. Podczas wdrażania punktu końcowego przejdź do sekcji modeli w konsoli. Kliknij model, a pojawi się wdrożenie modelu:
Gdy wdrożanie się zakończy, w miejscu, gdzie wcześniej była ikona ładowania, zobaczysz zieloną ikonę potwierdzenia.
Krok 4. Przetestuj wdrożony model
Aby sprawdzić, czy wdrożony model działa, przeprowadź prognozowanie za pomocą gcloud. 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
W danych wyjściowych powinien pojawić się wynik prognozy modelu. W tym przykładzie reklama została zatwierdzona, więc powinna mieć wartość zbliżoną do 1.
9. Czyszczenie
Jeśli chcesz nadal korzystać z tego notebooka, 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 laboratorium, zamiast je zatrzymywać, po prostu usuń instancję notatnika.
Aby usunąć wdrożony punkt końcowy, otwórz sekcję Punkty końcowe w konsoli Vertex i kliknij ikonę usuwania:
Aby usunąć zasobnik Cloud Storage, w menu nawigacyjnym konsoli Cloud przejdź do usługi Storage, wybierz zasobnik i kliknij Usuń:
