1. Omówienie
W tym module poznasz różne narzędzia w Notatkach w AI Platform do eksploracji danych i prototypowania modeli ML.
Czego się dowiesz
Poznasz takie zagadnienia jak:
- Tworzenie i dostosowywanie instancji Notatników w AI Platform
- Śledź kod notatników za pomocą Gita, który jest bezpośrednio zintegrowany z Notatnikami w AI Platform
- Użyć narzędzia What-If w notatniku
Całkowity koszt uruchomienia tego modułu w Google Cloud wynosi około 1 USD. Szczegółowe informacje na temat cen notatników w AI Platform znajdziesz tutaj.
2. Tworzenie instancji notatek w AI Platform
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 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ę notatnika
Przejdź do sekcji Notatników AI Platform w konsoli Cloud i kliknij Nowa instancja. Następnie wybierz najnowszy typ instancji TensorFlow 2 Enterprise bez GPU:
Nadaj instancji nazwę lub użyj domyślnej. Następnie omówimy opcje dostosowywania. Kliknij przycisk Dostosuj:
Notatniki w AI Platform mają wiele różnych opcji dostosowywania, w tym region, w którym wdrożona jest instancja, typ obrazu, rozmiar maszyny, liczba procesorów graficznych itp. Użyjemy wartości domyślnych dla regionu i środowiska. Do konfiguracji maszyny użyjemy maszyny n1-standard-8:
Nie będziemy dodawać żadnych GPU i będziemy korzystać z ustawień domyślnych dotyczących dysku rozruchowego, sieci i uprawnień. Kliknij Utwórz, aby utworzyć instancję. Ich wykonanie może potrwać kilka minut.
Gdy instancja zostanie utworzona, w interfejsie notatników pojawi się zielony znacznik wyboru. Wybierz Otwórz JupyterLab, aby otworzyć instancję i rozpocząć prototyp:
Gdy otworzysz instancję, utwórz nowy katalog o nazwie Codelab. Oto katalog, w którym będziemy pracować w tym module:
Kliknij nowo utworzony katalog codelab, klikając go dwukrotnie, a następnie wybierz notatnik w języku Python 3 w programie uruchamiającym:
Zmień nazwę notatnika na demo.ipynb lub inną.
Krok 4. Zaimportuj pakiety Pythona
Utwórz nową komórkę w notatniku i zaimportuj biblioteki, których będziemy używać w tym ćwiczeniu z programowania:
import pandas as pd
import tensorflow as tf
from tensorflow.keras import Sequential
from tensorflow.keras.layers import Dense
import numpy as np
import json
from sklearn.model_selection import train_test_split
from sklearn.utils import shuffle
from google.cloud import bigquery
from witwidget.notebook.visualization import WitWidget, WitConfigBuilder
3. Połącz dane BigQuery z notatnikiem
BigQuery, hurtownia big data w Google Cloud, udostępnia publicznie wiele zbiorów danych na potrzeby eksploracji. Notatniki w AI Platform obsługują bezpośrednią integrację z BigQuery bez konieczności uwierzytelniania.
W tym module użyjemy zbioru danych przyrodniczych. Zawiera on dane dotyczące niemal każdego narodzin w USA w okresie 40 lat, w tym masę urodzeniową dziecka oraz dane demograficzne dotyczące rodziców dziecka. Do przewidywania masy urodzeniowej dziecka wykorzystamy podzbiór funkcji.
Krok 1. Pobierz dane BigQuery do naszego notatnika
Użyjemy biblioteki klienta w języku Python dla BigQuery, aby pobrać dane do Pandas DataFrame. Oryginalny zbiór danych ma 21 GB i zawiera 123 mln wierszy. Dla uproszczenia użyjemy tylko 10 000 wierszy ze zbioru danych.
Utwórz zapytanie i wyświetl podgląd wynikowej ramki DataFrame za pomocą poniższego kodu. Pobraliśmy 4 cechy z oryginalnego zbioru danych oraz wagę dziecka (co przewidzi nasz model). Zbiór danych ma wiele lat, ale w tym modelu użyjemy tylko danych sprzed 2000 roku:
query="""
SELECT
weight_pounds,
is_male,
mother_age,
plurality,
gestation_weeks
FROM
publicdata.samples.natality
WHERE year > 2000
LIMIT 10000
"""
df = bigquery.Client().query(query).to_dataframe()
df.head()
Aby uzyskać podsumowanie funkcji liczbowych w naszym zbiorze danych, uruchom polecenie:
df.describe()
Podaje średnią, odchylenie standardowe, wartość minimalną i inne dane dla naszych kolumn liczbowych. Na koniec zbieramy dane w kolumnie z wartościami logicznymi wskazującymi płeć dziecka. Możemy to zrobić przy użyciu metody value_counts Pandas:
df['is_male'].value_counts()
Wygląda na to, że zbiór danych jest prawie zrównoważony w 50/50 według płci.
Krok 2. Przygotuj zbiór danych do trenowania
Po pobraniu zbioru danych do notatnika w postaci Pandas DataFrame możemy przeprowadzić wstępne przetwarzanie i podzielić go na zbiory do trenowania i testowania.
Najpierw upuśćmy wiersze z wartościami null ze zbioru danych i przetasujemy dane:
df = df.dropna()
df = shuffle(df, random_state=2)
Następnie wyodrębnij kolumnę etykiet do osobnej zmiennej i utwórz DataFrame zawierającą wyłącznie nasze funkcje. Ponieważ is_male jest wartością logiczną, przekonwertujemy ją na liczbę całkowitą, by wszystkie dane wejściowe do naszego modelu miały wartości liczbowe:
labels = df['weight_pounds']
data = df.drop(columns=['weight_pounds'])
data['is_male'] = data['is_male'].astype(int)
Jeśli wyświetlisz podgląd naszego zbioru danych, uruchamiając polecenie data.head(), zobaczysz 4 funkcje, których będziemy używać do trenowania.
4. Zainicjuj git
Notatniki w AI Platform są bezpośrednio zintegrowane z git, dzięki czemu kontrolę wersji można kontrolować bezpośrednio w środowisku notatników. Obsługuje to zatwierdzanie kodu bezpośrednio w interfejsie notatnika lub za pomocą terminala dostępnego w JupyterLab. W tej sekcji zainicjujemy repozytorium git w naszym notatniku i wykonamy pierwsze zatwierdzenie w interfejsie.
Krok 1. Zainicjuj repozytorium Git
W katalogu ćwiczeń z programowania wybierz Git, a następnie Init na górnym pasku menu w JupyterLab:
Gdy pojawi się pytanie, czy chcesz ustawić ten katalog jako repozytorium Git, wybierz Yes. Następnie wybierz ikonę Git na lewym pasku bocznym, aby zobaczyć stan plików i zatwierdzeń:
Krok 2. Wykonaj pierwsze zobowiązanie
W tym interfejsie możesz dodawać pliki do zatwierdzenia, wyświetlać różnice między plikami (omówimy to później) i zatwierdzać zmiany. Zacznijmy od zatwierdzenia dodanego właśnie pliku notatnika.
Zaznacz pole obok pliku notatnika demo.ipynb, aby zebrać go na potrzeby zatwierdzenia (możesz zignorować katalog .ipynb_checkpoints/). Wpisz w polu tekstowym komunikat zatwierdzenia i kliknij znacznik wyboru, aby zatwierdzić zmiany:
Gdy pojawi się prośba, wpisz swoje imię i nazwisko oraz adres e-mail. Następnie wróć na kartę Historia, aby zobaczyć pierwsze zatwierdzenie:
Pamiętaj, że ze względu na aktualizacje od czasu opublikowania tego modułu zrzuty ekranu mogą nie być dokładnie takie same jak w interfejsie użytkownika.
5. Tworzenie i trenowanie modelu TensorFlow
Na podstawie pobranego przez nas zbioru danych naturalnych BigQuery z notatnika stworzymy model, który prognozuje wagę dziecka. W tym module skoncentrujemy się na narzędziach do obsługi notatników, a nie na dokładności samego modelu.
Krok 1. Podziel dane na zbiory do trenowania i testowania
Przed utworzeniem modelu użyjemy narzędzia Scikit Learn train_test_split, aby podzielić nasze dane:
x,y = data,labels
x_train,x_test,y_train,y_test = train_test_split(x,y)
Teraz możemy utworzyć nasz model TensorFlow.
Krok 2. Utwórz i wytrenuj model TensorFlow
Tworzymy ten model za pomocą interfejsu API modelu tf.keras Sequential, który pozwala zdefiniować go jako stos warstw. Cały kod potrzebny do zbudowania modelu znajduje się tutaj:
model = Sequential([
Dense(64, activation='relu', input_shape=(len(x_train.iloc[0]),)),
Dense(32, activation='relu'),
Dense(1)]
)
Potem skompilujemy nasz model, aby można go było wytrenować. Wybieramy optymalizator, funkcję utraty i wskaźniki, które model ma rejestrować podczas trenowania. Jest to model regresji (prognozujący wartość liczbową), dlatego zamiast wartości dokładności używamy błędu średniokwadratowego:
model.compile(optimizer=tf.keras.optimizers.RMSprop(),
loss=tf.keras.losses.MeanSquaredError(),
metrics=['mae', 'mse'])
Za pomocą dostępnej w Keraście funkcji model.summary() możesz w każdej warstwie sprawdzić kształt i liczbę parametrów z możliwością trenowania.
Teraz możemy trenować nasz model. Wystarczy wywołać metodę fit(), przekazać jej dane treningowe oraz etykiety. W tym miejscu użyjemy opcjonalnego parametru Valid_split, który zawiera część naszych danych treningowych, aby zweryfikować model na każdym etapie. Idealnie byłoby, gdyby utrata wyników trenowania i walidacji spadała oba. Pamiętaj jednak, że w tym przykładzie koncentrujemy się bardziej na narzędziach do obsługi modeli i notatników, a nie jakości modelu:
model.fit(x_train, y_train, epochs=10, validation_split=0.1)
Krok 3. Wygeneruj prognozy na przykładach testowych
Aby sprawdzić wydajność naszego modelu, wygenerujmy prognozy testowe dla pierwszych 10 przykładów z testowego zbioru danych.
num_examples = 10
predictions = model.predict(x_test[:num_examples])
Następnie przeprowadzamy powtarzanie prognoz naszego modelu, porównując je z rzeczywistą wartością:
for i in range(num_examples):
print('Predicted val: ', predictions[i][0])
print('Actual val: ',y_test.iloc[i])
print()
Krok 4. Użyj git diff i zatwierdź zmiany
Po wprowadzeniu zmian w notatniku możesz wypróbować funkcję git diff dostępną w interfejsie git notatnika. Notatnik demo.ipynb powinien się teraz znajdować w sekcji „Zmienione” w interfejsie. Najedź kursorem na nazwę pliku i kliknij ikonę różnic:
Powinno to spowodować różnice między poszczególnymi zmianami, na przykład:
Tym razem zatwierdzimy zmiany za pomocą wiersza poleceń, używając terminala. W menu Git na górnym pasku menu JupyterLab wybierz Polecenie Git w terminalu. Jeśli po uruchomieniu poniższych poleceń masz otwartą kartę git na lewym pasku bocznym, zmiany będą widoczne w interfejsie Git.
W nowej instancji terminala uruchom to polecenie, aby zebrać plik notatnika pod kątem zatwierdzenia:
git add demo.ipynb
Następnie uruchom to polecenie, aby zatwierdzić zmiany (możesz użyć dowolnego komunikatu zatwierdzenia):
git commit -m "Build and train TF model"
Następnie w historii powinno pojawić się ostatnie zatwierdzenie:
6. Użyj narzędzia What-If bezpośrednio z notatnika
What-If Tool to interaktywny interfejs wizualny, który pomaga w wizualizacji zbiorów danych i lepszym rozumieniu danych wyjściowych modeli ML. Jest to narzędzie typu open source stworzone przez zespół PAIR w Google. Działa z każdym modelem, ale niektóre funkcje są stworzone wyłącznie z myślą o Cloud AI Platform.
Narzędzie What-If jest wstępnie zainstalowane w instancjach notatników Cloud AI Platform z użyciem TensorFlow. Użyjemy go, aby sprawdzić ogólną skuteczność modelu i sprawdzić jego zachowanie na punktach danych ze zbioru testowego.
Krok 1. Przygotuj dane do użycia narzędzia What-If
Aby w pełni wykorzystać możliwości narzędzia What-If, wyślemy mu przykłady z naszego zbioru testowego wraz z etykietami danych podstawowych (ground truth) do tych przykładów (y_test). W ten sposób możemy porównać prognozy naszego modelu z danymi podstawowymi. Uruchom poniższy wiersz kodu, aby utworzyć nową ramka DataFrame z naszymi przykładami testowymi i ich etykietami:
wit_data = pd.concat([x_test, y_test], axis=1)
W tym module połączymy narzędzie What-If z modelem, który właśnie wytrenowaliśmy w naszym notatniku. Aby to zrobić, musimy napisać funkcję, która posłuży do uruchomienia w modelu tych punktów danych testowych:
def custom_predict(examples_to_infer):
preds = model.predict(examples_to_infer)
return preds
Krok 2. Utwórz instancję narzędzia What-If
Utworzymy instancję narzędzia What-If, przekazując do niego 500 przykładów ze połączonego testowego zbioru danych oraz utworzonych przed chwilą etykiet danych podstawowych. Tworzymy instancję WitConfigBuilder, aby skonfigurować to narzędzie, przekazać je nam, niestandardową funkcję prognozowania zdefiniowaną powyżej, z celem (co przewidujemy) oraz z typem modelu:
config_builder = (WitConfigBuilder(wit_data[:500].values.tolist(), data.columns.tolist() + ['weight_pounds'])
.set_custom_predict_fn(custom_predict)
.set_target_feature('weight_pounds')
.set_model_type('regression'))
WitWidget(config_builder, height=800)
Po wczytaniu narzędzia What-If zobaczysz coś takiego:
Na osi X widoczne są punkty danych testowych rozłożone według przewidywanej wartości wagi modelu (weight_pounds).
Krok 3. Poznaj zachowanie modelu za pomocą narzędzia What-If
Narzędzie What-If pozwala zrobić wiele ciekawych rzeczy. W tym miejscu omówimy tylko niektóre z nich. Najpierw przyjrzyjmy się edytorowi punktów danych. Możesz wybrać dowolny punkt danych, aby zobaczyć jego cechy i zmienić wartości cech. Najpierw kliknij dowolny punkt danych:
Po lewej stronie wyświetlą się wartości cech dla wybranego punktu danych. Możesz też porównać etykietę danych podstawowych (ground truth) tego punktu danych z wartością prognozowaną przez model. Na pasku bocznym po lewej stronie możesz też zmienić wartości cech i ponownie uruchomić prognozę modelu, aby sprawdzić wpływ tej zmiany na model. Można na przykład zmienić gestation_weeks na 30 dla tego punktu danych, klikając go dwukrotnie, co spowoduje ponowne uruchomienie prognozy:
Korzystając z menu w sekcji wykresu w narzędziu What-If, możesz tworzyć różne niestandardowe wizualizacje. Na przykład mamy wykres przedstawiający model prognozowana waga na osi x, wiek matki na osi Y oraz punkty oznaczone kolorami ich błędu wnioskowania (ciemniejszy oznacza większą różnicę między wagą prognozowaną a rzeczywistą). Oto, jak to wygląda, gdy waga spada, błąd modelu nieznacznie zwiększa się:
Następnie sprawdź przycisk Wykresy zależności częściowych po lewej stronie. Pokazuje to, jak każda cecha wpływa na prognozę modelu. Na przykład wraz ze wydłużeniem czasu ciąży przewidywana przez nasz model waga dziecka również wzrasta:
Więcej pomysłów na eksplorację w narzędziu What-If znajdziesz pod linkami na początku tej sekcji.
7. Opcjonalnie: połącz lokalne repozytorium GitHub z GitHubem
Na koniec dowiemy się, jak połączyć repozytorium Git w instancji notatnika z repozytorium na koncie GitHub. Jeśli chcesz to zrobić, musisz mieć konto GitHub.
Krok 1. Utwórz nowe repozytorium w GitHubie
Utwórz nowe repozytorium na swoim koncie GitHub. Nadaj mu nazwę i opis, zdecyduj, czy ma być publiczne, i wybierz Utwórz repozytorium (nie musisz inicjować go za pomocą README). Na następnej stronie wykonasz instrukcje przesyłania istniejącego repozytorium z wiersza poleceń.
Otwórz okno terminala i dodaj nowe repozytorium jako zdalne. Zastąp username w poniższym adresie URL repozytorium swoją nazwą użytkownika GitHub, a your-repo – nazwą właśnie utworzonej właśnie nazwy:
git remote add origin git@github.com:username/your-repo.git
Krok 2. Uwierzytelnij się w GitHubie w instancji notatników
Następnie musisz uwierzytelnić się w GitHubie z poziomu instancji notatnika. Ten proces różni się w zależności od tego, czy masz włączone uwierzytelnianie dwuskładnikowe na GitHubie.
Jeśli nie wiesz, od czego zacząć, wykonaj czynności opisane w dokumentacji GitHuba, aby utworzyć klucz SSH, a następnie dodaj nowy klucz do GitHuba.
Krok 3. Sprawdź, czy repozytorium GitHub jest prawidłowo połączone
Aby sprawdzić, czy wszystko jest prawidłowo skonfigurowane, uruchom w terminalu git remote -v. Nowe repozytorium powinno być widoczne jako zdalne. Gdy zobaczysz adres URL repozytorium GitHub i przeprowadzisz uwierzytelnienie w GitHubie z poziomu notatnika, możesz przekazać dane bezpośrednio do GitHuba z instancji notatnika.
Aby zsynchronizować repozytorium git lokalnego notatnika z nowo utworzonym repozytorium GitHub, kliknij przycisk przesyłania do chmury u góry paska bocznego Git:
Odśwież repozytorium GitHub. Kod notatnika powinien pojawić się przy poprzednich zatwierdzeniach. Jeśli inne osoby mają dostęp do Twojego repozytorium GitHub i chcesz pobrać najnowsze zmiany do swojego notatnika, kliknij ikonę pobierania do chmury, aby je zsynchronizować.
Na karcie Historia w interfejsie GitHuba możesz sprawdzić, czy lokalne zatwierdzenia są zsynchronizowane z GitHubem. W tym przykładzie origin/master odpowiada naszemu repozytorium na GitHubie:
Gdy tworzysz nowe zatwierdzenia, ponownie kliknij przycisk przesyłania do chmury, aby przekazać je do repozytorium GitHub.
8. Gratulacje!
W tym module udało Ci się wiele osiągnąć 👏👏
Podsumowując, omówiliśmy, jak:
- Tworzenie dostosowywania instancji notatnika w AI Platform
- Zainicjuj w tej instancji lokalne repozytorium Git, dodaj zatwierdzenia za pomocą interfejsu Git lub wiersza poleceń, wyświetl git diff w interfejsie git notatnika
- Utwórz i wytrenuj prosty model TensorFlow 2
- Używanie narzędzia What-If w instancji notatnika
- Połącz repozytorium Git Notatnika z zewnętrznym repozytorium w GitHubie
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ć.
Za pomocą menu nawigacyjnego w konsoli Cloud przejdź do Cloud Storage i usuń oba zasobniki utworzone w celu przechowywania zasobów modelu.