1. Przegląd
W tym module poznasz różne narzędzia w AI Platform Notebooks, które służą do eksplorowania danych i tworzenia prototypów modeli ML.
Czego się nauczysz
Poznasz takie zagadnienia jak:
- Tworzenie i dostosowywanie instancji notatników AI Platform
- Śledzenie kodu notatników za pomocą Gita zintegrowanego bezpośrednio z Notatnikami w AI Platform
- Korzystanie z narzędzia What-If w notatniku
Całkowity koszt ukończenia tego laboratorium w Google Cloud wynosi około 1 USD. Szczegółowe informacje o cenach notatników AI Platform znajdziesz tutaj.
2. Tworzenie instancji notatników AI Platform
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 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ę notatnika
Otwórz sekcję AI Platform Notebooks w Cloud Console i kliknij Nowa instancja. Następnie wybierz najnowszy typ instancji TensorFlow 2 Enterprise bez procesorów graficznych:
Nadaj instancji nazwę lub użyj nazwy domyślnej. Następnie przyjrzymy się opcjom dostosowywania. Kliknij przycisk Dostosuj:
AI Platform Notebooks ma wiele różnych opcji dostosowywania, w tym region, w którym jest wdrażana instancja, typ obrazu, rozmiar maszyny, liczba procesorów graficznych i inne. Użyjemy domyślnych ustawień regionu i środowiska. W konfiguracji maszyny użyjemy maszyny n1-standard-8:
Nie dodamy żadnych procesorów GPU i użyjemy domyślnych ustawień dysku rozruchowego, sieci i uprawnień. Kliknij Utwórz, aby utworzyć instancję. Ich wykonanie może potrwać kilka minut.
Gdy instancja zostanie utworzona, w interfejsie Notebooks obok niej pojawi się zielony znacznik wyboru. Aby otworzyć instancję i rozpocząć prototypowanie, kliknij Otwórz JupyterLab:
Po otwarciu instancji utwórz nowy katalog o nazwie codelab. To jest katalog, w którym będziemy pracować w tym module:
Kliknij dwukrotnie nowo utworzony katalog codelab, a następnie wybierz notatnik Python 3 z programu uruchamiającego:
Zmień nazwę notatnika na demo.ipynb lub dowolną 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:
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. Łączenie danych BigQuery z notatnikiem
BigQuery, hurtownia danych Big Data od Google, udostępnia publicznie wiele zbiorów danych, które możesz eksplorować. Notatniki AI Platform obsługują bezpośrednią integrację z BigQuery bez konieczności uwierzytelniania.
W tym laboratorium użyjemy zbioru danych natality. Zawiera dane dotyczące niemal wszystkich urodzeń w USA w ciągu 40 lat, w tym wagę urodzeniową dziecka i dane demograficzne rodziców. Do przewidywania masy urodzeniowej dziecka użyjemy podzbioru tych cech.
Krok 1. Pobierz dane BigQuery do notatnika
Do pobrania danych do obiektu Pandas DataFrame użyjemy biblioteki klienta BigQuery w Pythonie. Oryginalny zbiór danych ma 21 GB i zawiera 123 mln wierszy. Dla uproszczenia użyjemy tylko 10 tys. wierszy z tego zbioru danych.
Utwórz zapytanie i wyświetl podgląd wynikowego obiektu DataFrame za pomocą tego kodu. W tym przypadku pobieramy 4 cechy z oryginalnego zbioru danych wraz z wagą dziecka (czyli wartością, którą będzie przewidywać nasz model). Zbiór danych obejmuje wiele lat, ale w przypadku tego modelu użyjemy tylko danych z okresu po 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:
df.describe()
Wyświetla średnią, odchylenie standardowe, wartość minimalną i inne dane w przypadku kolumn numerycznych. Na koniec pobierzmy dane z kolumny logicznej wskazującej płeć dziecka. Możemy to zrobić za pomocą metody value_counts biblioteki Pandas:
df['is_male'].value_counts()
Wygląda na to, że zbiór danych jest prawie zrównoważony pod względem płci (50/50).
Krok 2. Przygotuj zbiór danych do trenowania
Po pobraniu zbioru danych do notatnika jako struktury DataFrame biblioteki pandas możemy przeprowadzić wstępne przetwarzanie i podzielić go na zbiory treningowe i testowe.
Najpierw usuńmy z zbioru danych wiersze z wartościami null i potasujmy dane:
df = df.dropna()
df = shuffle(df, random_state=2)
Następnie wyodrębnij kolumnę etykiet do osobnej zmiennej i utwórz strukturę DataFrame zawierającą tylko nasze cechy. Ponieważ is_male to wartość logiczna, przekonwertujemy ją na liczbę całkowitą, aby wszystkie dane wejściowe modelu były numeryczne:
labels = df['weight_pounds']
data = df.drop(columns=['weight_pounds'])
data['is_male'] = data['is_male'].astype(int)
Jeśli teraz wyświetlisz podgląd zbioru danych, uruchamiając data.head(), zobaczysz 4 cechy, których będziemy używać do trenowania.
4. Inicjowanie Gita
Usługa AI Platform Notebooks jest bezpośrednio zintegrowana z Gitem, dzięki czemu możesz przeprowadzać kontrolę wersji bezpośrednio w środowisku notatnika. Umożliwia 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 dokonamy pierwszego zatwierdzenia za pomocą interfejsu.
Krok 1. Zainicjuj repozytorium Git
W katalogu codelab wybierz Git, a następnie Init na górnym pasku menu w JupyterLab:
Gdy pojawi się pytanie, czy chcesz przekształcić ten katalog w repozytorium Git, wybierz Tak. Następnie wybierz ikonę Git na pasku bocznym po lewej stronie, aby zobaczyć stan plików i zatwierdzeń:
Krok 2. Utwórz pierwszy commit
W tym interfejsie możesz dodawać pliki do zatwierdzenia, wyświetlać różnice między plikami (do tego wrócimy później) i zatwierdzać zmiany. Zacznijmy od zatwierdzenia dodanego właśnie pliku notatnika.
Zaznacz pole obok pliku demo.ipynb notebooka, aby przygotować go do zatwierdzenia (możesz zignorować katalog .ipynb_checkpoints/). Wpisz wiadomość o zatwierdzeniu w polu tekstowym, a następnie 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ć pierwszy commit:
Pamiętaj, że zrzuty ekranu mogą nie odpowiadać dokładnie Twojemu interfejsowi ze względu na aktualizacje wprowadzone od czasu opublikowania tego laboratorium.
5. Tworzenie i trenowanie modelu TensorFlow
Do utworzenia modelu, który będzie przewidywać wagę dziecka, użyjemy zbioru danych BigQuery dotyczącego urodzeń, który został pobrany do notatnika. W tym laboratorium skupimy się na narzędziach notatnika, 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 do podzielenia danych:
x,y = data,labels
x_train,x_test,y_train,y_test = train_test_split(x,y)
Teraz możemy utworzyć model TensorFlow.
Krok 2. Utwórz i wytrenuj model TensorFlow
Ten model utworzymy za pomocą interfejsu Sequentialmodel API tf.keras, który umożliwia zdefiniowanie modelu jako stosu warstw. Oto cały kod potrzebny do utworzenia modelu:
model = Sequential([
Dense(64, activation='relu', input_shape=(len(x_train.iloc[0]),)),
Dense(32, activation='relu'),
Dense(1)]
)
Następnie skompilujemy model, aby można było go wytrenować. Wybierzemy tutaj optymalizator modelu, funkcję utraty i dane, które model ma rejestrować podczas trenowania. Ponieważ jest to model regresji (prognozujący wartość liczbową), zamiast dokładności używamy średniego błędu kwadratowego:
model.compile(optimizer=tf.keras.optimizers.RMSprop(),
loss=tf.keras.losses.MeanSquaredError(),
metrics=['mae', 'mse'])
Możesz użyć przydatnej funkcji model.summary() w Keras, aby sprawdzić kształt i liczbę parametrów podlegających trenowaniu w modelu na każdej warstwie.
Możemy już wytrenować model. Wystarczy wywołać metodę fit(), przekazując jej dane treningowe i etykiety. Użyjemy tutaj opcjonalnego parametru validation_split, który będzie przechowywać część danych treningowych, aby weryfikować model na każdym etapie. Najlepiej, gdyby strata podczas trenowania i weryfikacji malała. Pamiętaj jednak, że w tym przykładzie bardziej skupiamy się na narzędziach do modeli i notatników niż na jakości modelu:
model.fit(x_train, y_train, epochs=10, validation_split=0.1)
Krok 3. Generowanie prognoz na podstawie przykładów testowych
Aby sprawdzić, jak działa nasz model, wygenerujmy prognozy testowe na podstawie pierwszych 10 przykładów z naszego testowego zbioru danych.
num_examples = 10
predictions = model.predict(x_test[:num_examples])
Następnie będziemy iterować po prognozach 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 polecenia git diff i zatwierdź zmiany
Po wprowadzeniu zmian w notatniku możesz wypróbować funkcję git diff dostępną w interfejsie Git w Notatnikach. Notatnik demo.ipynb powinien teraz znajdować się w sekcji „Zmienione” w interfejsie. Najedź kursorem na nazwę pliku i kliknij ikonę różnic:
Powinna pojawić się różnica między zmianami, np. taka:
Tym razem zatwierdzimy zmiany za pomocą wiersza poleceń w Terminalu. W menu Git na górnym pasku menu JupyterLab wybierz Git Command in Terminal (Polecenie Git w terminalu). Jeśli podczas wykonywania poniższych poleceń masz otwartą kartę Git na pasku bocznym po lewej stronie, zobaczysz zmiany odzwierciedlone w interfejsie Git.
W nowej instancji terminala uruchom to polecenie, aby przygotować plik notatnika do zatwierdzenia:
git add demo.ipynb
Następnie uruchom to polecenie, aby zatwierdzić zmiany (możesz użyć dowolnego komunikatu):
git commit -m "Build and train TF model"
W historii powinno pojawić się ostatnie zatwierdzenie:
6. Korzystanie z narzędzia What-If bezpośrednio w notatniku
Narzędzie What-If to interaktywny interfejs wizualny, który pomaga wizualizować zbiory danych i lepiej rozumieć wyniki modeli ML. Jest to narzędzie open source stworzone przez zespół PAIR w Google. Usługa działa z każdym typem modelu, ale ma też funkcje przeznaczone wyłącznie dla Cloud AI Platform.
Narzędzie What-If jest wstępnie zainstalowane w instancjach notatników AI Platform w Google Cloud z TensorFlow. Użyjemy go, aby sprawdzić ogólną skuteczność modelu i przeanalizować jego zachowanie w przypadku punktów danych z naszego zbioru testowego.
Krok 1. Przygotuj dane dla narzędzia What-If Tool
Aby w pełni wykorzystać możliwości narzędzia What-If Tool, wyślemy do niego przykłady z naszego zbioru testowego wraz z etykietami danych podstawowych dla 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ć nowy obiekt DataFrame z naszymi przykładami testowymi i ich etykietami:
wit_data = pd.concat([x_test, y_test], axis=1)
W tym laboratorium połączymy narzędzie What-If z modelem, który właśnie wytrenowaliśmy w notatniku. Aby to zrobić, musimy napisać funkcję, której narzędzie będzie używać do uruchamiania tych punktów danych testowych w naszym modelu:
def custom_predict(examples_to_infer):
preds = model.predict(examples_to_infer)
return preds
Krok 2. Utwórz instancję narzędzia What-If Tool
Utworzymy instancję narzędzia What-If Tool, przekazując do niej 500 przykładów z połączonego zbioru danych testowych i etykiet danych podstawowych, które właśnie utworzyliśmy. Tworzymy instancję WitConfigBuilder, aby skonfigurować narzędzie, przekazując do niego nasze dane, zdefiniowaną powyżej niestandardową funkcję przewidywania, a także cel (to, co przewidujemy) i typ 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 Tool zobaczysz coś takiego:
Na osi X zobaczysz punkty danych testowych rozłożone według przewidywanej przez model wartości wagi, weight_pounds.
Krok 3. Sprawdź działanie modelu za pomocą narzędzia What-If Tool
Narzędzie What-If ma wiele przydatnych funkcji. Przyjrzymy się tylko kilku z nich. Najpierw przyjrzyjmy się edytorowi punktów danych. Możesz wybrać dowolny punkt danych, aby wyświetlić jego cechy i zmienić wartości cech. Zacznij od kliknięcia dowolnego punktu danych:
Po lewej stronie zobaczysz wartości cech dla wybranego punktu danych. Możesz też porównać etykietę danych podstawowych tego punktu danych z wartością przewidzianą przez model. Na pasku bocznym po lewej stronie możesz też zmienić wartości cech i ponownie uruchomić prognozę modelu, aby zobaczyć, jak ta zmiana wpłynęła na model. Możemy na przykład zmienić wartość gestation_weeks na 30 dla tego punktu danych, klikając go dwukrotnie i ponownie uruchamiając prognozę:
Za pomocą menu w sekcji wykresu w narzędziu What-If Tool możesz tworzyć różnego rodzaju wizualizacje niestandardowe. Na przykład na tym wykresie na osi X znajduje się przewidywana waga modeli, na osi Y wiek matki, a punkty są pokolorowane w zależności od błędu wnioskowania (ciemniejszy kolor oznacza większą różnicę między przewidywaną a rzeczywistą wagą). Widać, że wraz ze spadkiem wagi błąd modelu nieznacznie rośnie:
Następnie po lewej stronie kliknij przycisk Wykresy zależności częściowej. Pokazuje, jak poszczególne cechy wpływają na prognozę modelu. Na przykład w miarę wydłużania się czasu trwania ciąży przewidywana przez nasz model masa dziecka również rośnie:
Więcej pomysłów na eksploracje z narzędziem What-If Tool znajdziesz w linkach na początku tej sekcji.
7. Opcjonalnie: połącz lokalne repozytorium Git z GitHubem
Na koniec dowiesz 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
Na koncie GitHub utwórz nowe repozytorium. Nadaj mu nazwę i opis, zdecyduj, czy ma być publiczny, i kliknij Utwórz repozytorium (nie musisz inicjować go za pomocą pliku README). Na następnej stronie znajdziesz instrukcje dotyczące przesyłania istniejącego repozytorium z wiersza poleceń.
Otwórz okno terminala i dodaj nowe repozytorium jako repozytorium zdalne. Zastąp username w adresie URL repozytorium poniżej nazwą użytkownika GitHub, a your-repo – nazwą właśnie utworzonego repozytorium:
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 GitHub, aby utworzyć klucz SSH, a następnie dodać go do GitHub.
Krok 3. Sprawdź, czy repozytorium GitHub zostało prawidłowo połączone
Aby sprawdzić, czy konfiguracja jest prawidłowa, uruchom w terminalu polecenie git remote -v. Nowe repozytorium powinno być widoczne jako repozytorium zdalne. Gdy zobaczysz adres URL repozytorium GitHub i uwierzytelnienie w GitHubie z poziomu notatnika, możesz bezpośrednio przesyłać zmiany do GitHuba z instancji notatnika.
Aby zsynchronizować lokalne repozytorium Git z nowo utworzonym repozytorium GitHub, kliknij przycisk przesyłania do chmury u góry paska bocznego Git:
Odśwież repozytorium GitHub. Powinien się w nim pojawić kod notatnika z poprzednimi zmianami. Jeśli inne osoby mają dostęp do Twojego repozytorium GitHub i chcesz pobrać najnowsze zmiany w notatniku, kliknij ikonę pobierania z chmury, aby zsynchronizować te zmiany.
Na karcie Historia w interfejsie Git notatników możesz sprawdzić, czy lokalne commity są zsynchronizowane z GitHubem. W tym przykładzie origin/master odpowiada naszemu repozytorium w GitHubie:
Za każdym razem, gdy wprowadzasz nowe zmiany, kliknij ponownie przycisk przesyłania do chmury, aby przenieść te zmiany do repozytorium GitHub.
8. Gratulacje!
W tym laboratorium wykonano wiele zadań 👏👏👏
Podsumowując, wiesz już, jak:
- Tworzenie i dostosowywanie instancji notatnika AI Platform
- Zainicjuj lokalne repozytorium Git w tej instancji, dodaj commity za pomocą interfejsu Git lub wiersza poleceń, wyświetl różnice w interfejsie Git w notatniku.
- Tworzenie i trenowanie prostego modelu TensorFlow 2
- Korzystanie z narzędzia What-If w instancji notatnika
- Łączenie repozytorium Git notatnika z zewnętrznym repozytorium w GitHub
9. 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.