 Diese Anleitung als Notebook in Colab ausführen
|
Notebook auf GitHub ansehen
|
In dieser Anleitung wird gezeigt, wie Sie mit der Keras Sequential API ein neuronales Netzwerk in AI Platform trainieren und mit diesem Modell Vorhersagen bereitstellen.
Keras ist eine allgemeine API zum Erstellen und Trainieren von Deep-Learning-Modellen. tf.keras stellt die Implementierung dieser API in TensorFlow dar.
In den ersten beiden Abschnitten der Anleitung wird ein Modell in AI Platform mit Keras-Codevorlagen trainiert, in AI Platform bereitgestellt und zum Generieren von Onlinevorhersagen verwendet.
Im letzten Teil der Anleitung wird der Trainingscode beschrieben, der für dieses Modell verwendet wird. Außerdem wird erläutert, wie Sie für die Kompatibilität des Codes mit AI Platform sorgen. Weitere Informationen zum Erstellen von Modellen für maschinelles Lernen in Keras finden Sie in den Keras-Anleitungen von TensorFlow.
Dataset
In dieser Anleitung wird das vom UC Irvine Machine Learning Repository bereitgestellte United States Census Income Dataset (US-Dataset zur Einkommenserhebung) verwendet. Das Dataset enthält Informationen zu Personen aus einer Zensusdatenbank von 1994, einschließlich Alter, Bildungsgrad, Familienstand, Beruf und ob sie mehr als 50.000 $ pro Jahr verdienen.
Ziel
Das Ziel besteht darin, mit Keras ein neuronales Deep-Learning-Netzwerk zu trainieren, das auf der Grundlage anderer Zensusinformationen einer Person (Features) vorhersagt, ob eine Person mehr als 50.000 $ pro Jahr verdient (Ziel-Label).
In dieser Anleitung geht es mehr um die Verwendung des Modells mit AI Platform als um das eigentliche Modelldesign. Sie sollten beim Erstellen eines Systems für maschinelles Lernen jedoch immer mögliche Probleme und unbeabsichtigte Folgen berücksichtigen. In der Übung zum Thema Fairness im Intensivkurs zum maschinellen Lernen erhalten Sie Informationen zu Verzerrungsquellen im Zensus-Dataset sowie zur allgemeinen Fairness beim maschinellen Lernen.
Kosten
In dieser Anleitung werden kostenpflichtige Komponenten von Google Cloud verwendet:
- AI Platform Training
- AI Platform Prediction
- Cloud Storage
Informieren Sie sich über die Preise für AI Platform Training, die Preise für AI Platform Prediction und die Cloud Storage-Preise und verwenden Sie den Preisrechner, um eine Kostenschätzung anhand Ihrer prognostizierten Nutzung zu erstellen.
Hinweise
Bevor Sie ein Modell in AI Platform trainieren und bereitstellen können, müssen Sie einige Schritte ausführen:
- Lokale Entwicklungsumgebung einrichten
- Richten Sie ein Google Cloud-Projekt ein, für das die Abrechnungsfunktion und die erforderlichen APIs aktiviert sind.
- Cloud Storage-Bucket zum Speichern des Trainingspakets und des trainierten Modells erstellen
Lokale Entwicklungsumgebung einrichten
Für diese Anleitung benötigen Sie Folgendes:
- Git
- Python 3
- virtualenv
- Das Google Cloud SDK
Der Google Cloud-Leitfaden zum Einrichten einer Python-Entwicklungsumgebung enthält detaillierte Anweisungen zur Erfüllung dieser Anforderungen. Die folgenden Schritte sind eine Zusammenfassung dieser Anweisungen:
Installieren Sie virtualenv und erstellen Sie eine virtuelle Umgebung, die Python 3 verwendet.
Aktivieren Sie die Umgebung.
Führen Sie die Schritte im folgenden Abschnitt aus, um das Google Cloud SDK zu installieren.
Google Cloud-Projekt einrichten
- Melden Sie sich bei Ihrem Google Cloud-Konto an. Wenn Sie mit Google Cloud noch nicht vertraut sind, erstellen Sie ein Konto, um die Leistungsfähigkeit unserer Produkte in der Praxis sehen und bewerten zu können. Neukunden erhalten außerdem ein Guthaben von 300 $, um Arbeitslasten auszuführen, zu testen und bereitzustellen.
-
Wählen Sie in der Google Cloud Console auf der Seite der Projektauswahl ein Google Cloud-Projekt aus oder erstellen Sie eines.
-
Die Abrechnung für das Google Cloud-Projekt muss aktiviert sein.
-
AI Platform Training & Prediction and Compute Engine APIs aktivieren.
- Installieren Sie die Google Cloud CLI.
-
Führen Sie folgenden Befehl aus, um die gcloud CLI zu initialisieren:
gcloud init
-
Wählen Sie in der Google Cloud Console auf der Seite der Projektauswahl ein Google Cloud-Projekt aus oder erstellen Sie eines.
-
Die Abrechnung für das Google Cloud-Projekt muss aktiviert sein.
-
AI Platform Training & Prediction and Compute Engine APIs aktivieren.
- Installieren Sie die Google Cloud CLI.
-
Führen Sie folgenden Befehl aus, um die gcloud CLI zu initialisieren:
gcloud init
GCP-Konto authentifizieren
Für die Einrichtung der Authentifizierung müssen Sie einen Dienstkontoschlüssel erstellen und eine Umgebungsvariable für den Dateipfad zum Dienstkontoschlüssel festlegen.
-
Erstellen Sie ein Dienstkonto:
-
Wechseln Sie in der Google Cloud Console zur Seite Dienstkonto erstellen.
- Geben Sie im Feld Dienstkontoname einen Namen ein.
- Optional: Geben Sie im Feld Dienstkontobeschreibung eine Beschreibung ein.
- Klicken Sie auf Erstellen.
- Klicken Sie auf das Feld Rolle auswählen. Wählen Sie unter Alle Rollen die Option AI Platform > AI Platform-Administrator aus.
- Klicken Sie auf Weitere Rolle hinzufügen.
-
Klicken Sie auf das Feld Rolle auswählen. Wählen Sie unter Alle Rollen die Option Storage > Storage-Objekt-Administrator.
-
Klicken Sie auf Fertig, um das Dienstkonto zu erstellen.
Schließen Sie das Browserfenster nicht. Sie verwenden es in der nächsten Aufgabe.
-
-
Erstellen Sie einen Dienstkontoschlüssel für die Authentifizierung:
- Klicken Sie in der Google Cloud Console auf die E-Mail-Adresse des von Ihnen erstellten Dienstkontos.
- Klicken Sie auf Schlüssel.
- Klicken Sie auf Schlüssel hinzufügen > Neuen Schlüssel erstellen.
- Klicken Sie auf Erstellen. Daraufhin wird eine JSON-Schlüsseldatei auf Ihren Computer heruntergeladen.
- Klicken Sie auf Schließen.
-
Legen Sie die Umgebungsvariable GOOGLE_APPLICATION_CREDENTIALS auf den Pfad der JSON-Datei fest, die Ihren Dienstkontoschlüssel enthält. Diese Variable gilt nur für Ihre aktuelle Shell-Sitzung. Wenn Sie eine neue Sitzung öffnen, müssen Sie die Variable noch einmal festlegen.
Cloud Storage-Bucket erstellen
Wenn Sie einen Trainingsjob mit dem Cloud SDK senden, laden Sie ein Python-Paket mit Ihrem Trainingscode in einen Cloud Storage-Bucket hoch. AI Platform führt den Code aus diesem Paket aus. In dieser Anleitung speichert AI Platform das im Rahmen des Jobs trainierte Modell außerdem im selben Bucket. Sie können dann eine AI Platform-Modellversion basierend auf dieser Ausgabe erstellen, um Onlinevorhersagen bereitzustellen.
Legen Sie den Namen Ihres Cloud Storage-Buckets als Umgebungsvariable fest. Der Name muss sich von allen anderen Bucket-Namen in Cloud Storage unterscheiden:
BUCKET_NAME="your-bucket-name"
Wählen Sie eine Region aus, in der AI Platform Training und AI Platform Prediction verfügbar sind, und erstellen Sie eine weitere Umgebungsvariable. Beispiel:
REGION="us-central1"
Erstellen Sie in dieser Region einen Cloud Storage-Bucket und verwenden Sie später dieselbe Region für Training und Vorhersage. Führen Sie den folgenden Befehl aus, wenn noch kein Bucket vorhanden ist:
gsutil mb -l $REGION gs://$BUCKET_NAME
Kurzanleitung für das Training in AI Platform
In diesem Abschnitt der Anleitung wird das Senden eines Trainingsjobs an AI Platform beschrieben. Dieser Job führt einen Beispielcode aus, der Keras verwendet, um ein neuronales Deep-Learning-Netzwerk mit den US-Zensusdaten zu trainieren. Das trainierte Modell wird als TensorFlow SavedModel-Verzeichnis in Ihrem Cloud Storage-Bucket ausgegeben.
Trainingscode und Abhängigkeiten abrufen
Laden Sie zuerst den Trainingscode herunter und ändern Sie das Arbeitsverzeichnis:
# Clone the repository of AI Platform samples
git clone --depth 1 https://github.com/GoogleCloudPlatform/cloudml-samples
# Set the working directory to the sample code directory
cd cloudml-samples/census/tf-keras
Beachten Sie, dass der Trainingscode als Python-Paket im Unterverzeichnis trainer/ strukturiert ist:
# `ls` shows the working directory's contents. The `p` flag adds trailing
# slashes to subdirectory names. The `R` flag lists subdirectories recursively.
ls -pR
.: README.md requirements.txt trainer/ ./trainer: __init__.py model.py task.py util.py
Installieren Sie als Nächstes Python-Abhängigkeiten, um das Modell lokal zu trainieren:
pip install -r requirements.txt
Wenn Sie den Trainingsjob in AI Platform ausführen, werden Abhängigkeiten basierend auf der ausgewählten Laufzeitversion vorinstalliert.
Modell lokal trainieren
Vor dem Training in AI Platform sollten Sie den Job lokal trainieren, um die Dateistruktur und das Paket zu verifizieren.
Bei einem komplexen oder ressourcenintensiven Job empfiehlt es sich, einen kleinen Ausschnitt des Datasets lokal zu trainieren, um den Code zu verifizieren. Anschließend können Sie den Job in AI Platform ausführen, um das gesamte Dataset zu trainieren.
In diesem Beispiel wird ein relativ schneller Job für ein kleines Dataset ausgeführt. Deshalb wird für die Ausführung des lokalen Trainings und des AI Platform-Jobs derselbe Code verwendet.
Führen Sie den folgenden Befehl aus, um ein Modell lokal zu trainieren:
# This is similar to `python -m trainer.task --job-dir local-training-output`
# but it better replicates the AI Platform environment, especially
# for distributed training (not applicable here).
gcloud ai-platform local train \
--package-path trainer \
--module-name trainer.task \
--job-dir local-training-output
Beobachten Sie den Trainingsfortschritt in Ihrer Shell. Am Ende exportiert die Trainingsanwendung das trainierte Modell und gibt eine Nachricht aus, die etwa so aussieht:
Model exported to: local-training-output/keras_export/1553709223
Modell mit AI Platform trainieren
Als Nächstes senden Sie einen Trainingsjob an AI Platform. Der Dienst führt das Trainingsmodul in der Cloud aus und exportiert das trainierte Modell nach Cloud Storage.
Geben Sie Ihrem Trainingsjob zuerst einen Namen und wählen Sie ein Verzeichnis in Ihrem Cloud Storage-Bucket aus, in dem Zwischen- und Ausgabedateien gespeichert werden sollen. Diese Werte legen Sie dann als Umgebungsvariablen fest. Beispiel:
JOB_NAME="my_first_keras_job"
JOB_DIR="gs://$BUCKET_NAME/keras-job-dir"
Mit dem im Folgenden aufgeführten Befehl wird das Verzeichnis trainer/ verpackt, in das angegebene Verzeichnis --job-dir hochgeladen und AI Platform angewiesen, das Modul trainer.task aus diesem Paket auszuführen.
Durch Angabe des Flags --stream-logs haben Sie die Möglichkeit, Trainingslogs in Ihrer Shell einzusehen. In der Google Cloud Console können Sie sich auch Logs und weitere Jobdetails ansehen.
gcloud ai-platform jobs submit training $JOB_NAME \
--package-path trainer/ \
--module-name trainer.task \
--region $REGION \
--python-version 3.7 \
--runtime-version 1.15 \
--job-dir $JOB_DIR \
--stream-logs
Dieser Vorgang dauert möglicherweise länger als das lokale Training, aber Sie können den Trainingsfortschritt auf ähnliche Weise in Ihrer Shell beobachten. Am Ende exportiert der Trainingsjob das trainierte Modell in Ihren Cloud Storage-Bucket und gibt eine Meldung aus, die etwa so aussieht:
INFO 2019-03-27 17:57:11 +0000 master-replica-0 Model exported to: gs://your-bucket-name/keras-job-dir/keras_export/1553709421 INFO 2019-03-27 17:57:11 +0000 master-replica-0 Module completed; cleaning up. INFO 2019-03-27 17:57:11 +0000 master-replica-0 Clean up finished. INFO 2019-03-27 17:57:11 +0000 master-replica-0 Task completed successfully.
Hyperparameter-Abstimmung
Optional können Sie Hyperparameter mithilfe der enthaltenen Konfigurationsdatei hptuning_config.yaml abstimmen. Diese Datei weist AI Platform an, die Batchgröße und Lernrate für das Training über mehrere Versuche hinweg zu optimieren und damit die Accuracy zu maximieren.
In diesem Beispiel verwendet der Trainingscode einen TensorBoard-Callback, der Summary-Event-Ereignisse von TensorFlow während des Trainings erstellt. Anhand dieser Ereignisse kann AI Platform den Messwert verfolgen, den Sie optimieren möchten. Weitere Informationen zur Hyperparameter-Abstimmung in AI Platform Training erhalten Sie unter Hyperparameter-Abstimmung – Übersicht.
gcloud ai-platform jobs submit training ${JOB_NAME}_hpt \
--config hptuning_config.yaml \
--package-path trainer/ \
--module-name trainer.task \
--region $REGION \
--python-version 3.7 \
--runtime-version 1.15 \
--job-dir $JOB_DIR \
--stream-logs
Kurzanleitung für Onlinevorhersagen in AI Platform
In diesem Abschnitt wird beschrieben, wie Sie Cloud ML Engine und das trainierte Modell aus dem vorherigen Abschnitt verwenden, um die Einkommensklasse einer Person anhand anderer Zensusinformationen vorherzusagen.
Modell- und Versionsressourcen in AI Platform erstellen
Erstellen Sie eine model in AI Platform und darin eine model. Sie können dann Onlinevorhersagen mit dem Modell bereitstellen, das Sie in der Kurzanleitung für das Training trainiert und exportiert haben. Die Ressource, die Ihr trainiertes Modell tatsächlich zur Bereitstellung von Vorhersagen verwendet, ist die Versionsressource. Mit dieser Struktur können Sie Ihr Modell mehrfach anpassen und neu trainieren und alle Versionen in AI Platform verwalten. Weitere Informationen erhalten Sie unter Projekte, Modelle, Versionen und Jobs .
Als Erstes erstellen Sie die Modellressource und geben Ihr einen Namen:
MODEL_NAME="my_first_keras_model"
gcloud ai-platform models create $MODEL_NAME \
--regions $REGION
Created ml engine model [projects/your-project-id/models/my_first_keras_model].
Als Nächstes erstellen Sie die Modellversion. Der Trainingsjob aus der Kurzanleitung für das Training hat ein mit Zeitstempel versehenes TensorFlow SavedModel-Verzeichnis in Ihren Cloud Storage-Bucket exportiert. AI Platform verwendet dieses Verzeichnis, um eine Modellversion zu erstellen. Weitere Informationen zu SavedModel und AI Platform erhalten Sie unter Modelle bereitstellen.
Möglicherweise finden Sie den Pfad zu diesem Verzeichnis in den Logs Ihres Trainingsjobs. Suchen Sie nach einer Zeile, die in etwa so aussieht:
Model exported to: gs://your-bucket-name/keras-job-dir/keras_export/1545439782
Führen Sie den folgenden Befehl aus, um das SavedModel-Verzeichnis zu ermitteln, und erstellen Sie damit eine Modellversion:
MODEL_VERSION="v1"
# Get a list of directories in the `keras_export` parent directory. Then pick
# the directory with the latest timestamp, in case you've trained multiple
# times.
SAVED_MODEL_PATH=$(gsutil ls $JOB_DIR/keras_export | head -n 1)
# Create model version based on that SavedModel directory
gcloud ai-platform versions create $MODEL_VERSION \
--model $MODEL_NAME \
--region $REGION \
--runtime-version 1.15 \
--python-version 3.7 \
--framework tensorflow \
--origin $SAVED_MODEL_PATH
Eingabe für die Vorhersage vorbereiten
Damit Sie stichhaltige und nützliche Vorhersagen erhalten, müssen Sie die Eingabe für die Vorhersage auf dieselbe Weise vorverarbeiten wie die Trainingsdaten. In einem Produktionssystem sollten Sie am besten eine Vorverarbeitungs-Pipeline erstellen, die beim Training und bei der Vorhersage auf dieselbe Weise verwendet werden kann.
Verwenden Sie für diese Übung den Code zum Laden der Daten des Trainingspakets, um einen zufälligen Ausschnitt der Validierungsdaten auszuwählen. Diese Daten liegen in dem Format vor, das zur Bewertung der Accuracy nach jeder Trainingsphase verwendet wurde. Sie können daher ohne weitere Vorverarbeitung zum Senden von Testvorhersagen genutzt werden.
Öffnen Sie den Python-Interpreter (python) aus Ihrem aktuellen Arbeitsverzeichnis, um die nächsten Code-Snippets auszuführen:
from trainer import util
_, _, eval_x, eval_y = util.load_data()
prediction_input = eval_x.sample(20)
prediction_targets = eval_y[prediction_input.index]
prediction_input
| age | workclass | education_num | marital_status | occupation | relationship | race | capital_gain | capital_loss | hours_per_week | native_country | |
|---|---|---|---|---|---|---|---|---|---|---|---|
| 1979 | 0.901213 | 1 | 1.525542 | 2 | 9 | 0 | 4 | -0.144792 | -0.217132 | -0.437544 | 38 |
| 2430 | -0.922154 | 3 | -0.419265 | 4 | 2 | 3 | 4 | -0.144792 | -0.217132 | -0.034039 | 38 |
| 4214 | -1.213893 | 3 | -0.030304 | 4 | 10 | 1 | 4 | -0.144792 | -0.217132 | 1.579979 | 38 |
| 10389 | -0.630415 | 3 | 0.358658 | 4 | 0 | 3 | 4 | -0.144792 | -0.217132 | -0.679647 | 38 |
| 14525 | -1.505632 | 3 | -1.586149 | 4 | 7 | 3 | 0 | -0.144792 | -0.217132 | -0.034039 | 38 |
| 15040 | -0.119873 | 5 | 0.358658 | 2 | 2 | 0 | 4 | -0.144792 | -0.217132 | -0.841048 | 38 |
| 8409 | 0.244801 | 3 | 1.525542 | 2 | 9 | 0 | 4 | -0.144792 | -0.217132 | 1.176475 | 6 |
| 10628 | 0.098931 | 1 | 1.525542 | 2 | 9 | 0 | 4 | 0.886847 | -0.217132 | -0.034039 | 38 |
| 10942 | 0.390670 | 5 | -0.030304 | 2 | 4 | 0 | 4 | -0.144792 | -0.217132 | 4.727315 | 38 |
| 5129 | 1.120017 | 3 | 1.136580 | 2 | 12 | 0 | 4 | -0.144792 | -0.217132 | -0.034039 | 38 |
| 2096 | -1.286827 | 3 | -0.030304 | 4 | 11 | 3 | 4 | -0.144792 | -0.217132 | -1.648058 | 38 |
| 12463 | -0.703350 | 3 | -0.419265 | 2 | 7 | 5 | 4 | -0.144792 | 4.502280 | -0.437544 | 38 |
| 8528 | 0.536539 | 3 | 1.525542 | 4 | 3 | 4 | 4 | -0.144792 | -0.217132 | -0.034039 | 38 |
| 7093 | -1.359762 | 3 | -0.419265 | 4 | 6 | 3 | 2 | -0.144792 | -0.217132 | -0.034039 | 38 |
| 12565 | 0.536539 | 3 | 1.136580 | 0 | 11 | 2 | 2 | -0.144792 | -0.217132 | -0.034039 | 38 |
| 5655 | 1.338821 | 3 | -0.419265 | 2 | 2 | 0 | 4 | -0.144792 | -0.217132 | -0.034039 | 38 |
| 2322 | 0.682409 | 3 | 1.136580 | 0 | 12 | 3 | 4 | -0.144792 | -0.217132 | -0.034039 | 38 |
| 12652 | 0.025997 | 3 | 1.136580 | 2 | 11 | 0 | 4 | -0.144792 | -0.217132 | 0.369465 | 38 |
| 4755 | -0.411611 | 3 | -0.419265 | 2 | 11 | 0 | 4 | -0.144792 | -0.217132 | 1.176475 | 38 |
| 4413 | 0.390670 | 6 | 1.136580 | 4 | 4 | 1 | 4 | -0.144792 | -0.217132 | -0.034039 | 38 |
Kategoriale Felder wie occupation wurden bereits in Ganzzahlen konvertiert, und zwar mit der Zuordnung, die für das Training verwendet wurde. Numerische Felder wie age wurden auf einen Z-Score skaliert.
Außerdem wurden einige Felder aus den ursprünglichen Daten entfernt. Vergleichen Sie die Vorhersageeingabe mit den Rohdaten für die Beispiele:
import pandas as pd
_, eval_file_path = util.download(util.DATA_DIR)
raw_eval_data = pd.read_csv(eval_file_path,
names=util._CSV_COLUMNS,
na_values='?')
raw_eval_data.iloc[prediction_input.index]
| age | workclass | fnlwgt | education | education_num | marital_status | occupation | relationship | race | gender | capital_gain | capital_loss | hours_per_week | native_country | income_bracket | |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| 1979 | 51 | Local-Gov | 99064 | Masters | 14 | Married-civ-spouse | Prof-specialty | Husband | White | Male | 0 | 0 | 35 | United-States | <=50K |
| 2430 | 26 | Private | 197967 | HS-grad | 9 | Never-married | Craft-repair | Own-child | White | Male | 0 | 0 | 40 | United-States | <=50K |
| 4214 | 22 | Private | 221694 | Some-college | 10 | Never-married | Protective-serv | Not-in-family | White | Male | 0 | 0 | 60 | United-States | <=50K |
| 10389 | 30 | Private | 96480 | Assoc-voc | 11 | Never-married | Adm-clerical | Own-child | White | Female | 0 | 0 | 32 | United-States | <=50K |
| 14525 | 18 | Private | 146225 | 10th | 6 | Never-married | Other-service | Own-child | Amer-Indian-Eskimo | Female | 0 | 0 | 40 | United-States | <=50K |
| 15040 | 37 | Self-emp-not-inc | 50096 | Assoc-voc | 11 | Married-civ-spouse | Craft-repair | Husband | White | Male | 0 | 0 | 30 | United-States | <=50K |
| 8409 | 42 | Private | 102988 | Masters | 14 | Married-civ-spouse | Prof-specialty | Husband | White | Male | 0 | 0 | 55 | Ecuador | >50K |
| 10628 | 40 | Local-Gov | 284086 | Masters | 14 | Married-civ-spouse | Prof-specialty | Husband | White | Male | 7688 | 0 | 40 | United-States | >50K |
| 10942 | 44 | Self-emp-not-inc | 52505 | Some-college | 10 | Married-civ-spouse | Farming-fishing | Husband | White | Male | 0 | 0 | 99 | United-States | <=50K |
| 5129 | 54 | Privat | 106728 | Bachelors | 13 | Married-civ-spouse | Tech-support | Husband | White | Male | 0 | 0 | 40 | United-States | <=50K |
| 2096 | 21 | Private | 190916 | Some-college | 10 | Never-married | Sales | Own-child | White | Female | 0 | 0 | 20 | United-States | <=50K |
| 12463 | 29 | Private | 197565 | HS-grad | 9 | Married-civ-spouse | Other-service | Wife | White | Female | 0 | 1902 | 35 | United-States | >50K |
| 8528 | 46 | Private | 193188 | Masters | 14 | Never-married | Exec-managerial | Unmarried | White | Male | 0 | 0 | 40 | United-States | <=50K |
| 7093 | 20 | Private | 273147 | HS-grad | 9 | Never-married | Machine-op-inspct | Own-child | Black | Male | 0 | 0 | 40 | United-States | <=50K |
| 12565 | 46 | Private | 203653 | Bachelors | 13 | Divorced | Sales | Other-relative | Black | Male | 0 | 0 | 40 | United-States | <=50K |
| 5655 | 57 | Privat | 174662 | HS-grad | 9 | Married-civ-spouse | Craft-repair | Husband | White | Male | 0 | 0 | 40 | United-States | <=50K |
| 2322 | 48 | Private | 232149 | Bachelors | 13 | Divorced | Tech-support | Own-child | White | Female | 0 | 0 | 40 | United-States | <=50K |
| 12652 | 39 | Private | 82521 | Bachelors | 13 | Married-civ-spouse | Sales | Husband | White | Male | 0 | 0 | 45 | United-States | >50K |
| 4755 | 33 | Private | 330715 | HS-grad | 9 | Married-civ-spouse | Sales | Husband | White | Male | 0 | 0 | 55 | United-States | <=50K |
| 4413 | 44 | State-gov | 128586 | Bachelors | 13 | Never-married | Farming-fishing | Not-in-family | White | Male | 0 | 0 | 40 | United-States | <=50K |
Exportieren Sie die Vorhersageeingabe in eine durch Zeilenumbruch getrennte JSON-Datei:
import json
with open('prediction_input.json', 'w') as json_file:
for row in prediction_input.values.tolist():
json.dump(row, json_file)
json_file.write('\n')
Beenden Sie den Python-Interpreter (exit()) und prüfen Sie in Ihrer Shell prediction_input.json:
cat prediction_input.json
[0.9012127751273994, 1.0, 1.525541514460902, 2.0, 9.0, 0.0, 4.0, -0.14479173735784842, -0.21713186390175285, -0.43754385253479555, 38.0] [-0.9221541171760282, 3.0, -0.4192650914017433, 4.0, 2.0, 3.0, 4.0, -0.14479173735784842, -0.21713186390175285, -0.03403923708700391, 38.0] [-1.2138928199445767, 3.0, -0.030303770229214273, 4.0, 10.0, 1.0, 4.0, -0.14479173735784842, -0.21713186390175285, 1.5799792247041626, 38.0] [-0.6304154144074798, 3.0, 0.35865755094331475, 4.0, 0.0, 3.0, 4.0, -0.14479173735784842, -0.21713186390175285, -0.6796466218034705, 38.0] [-1.5056315227131252, 3.0, -1.5861490549193304, 4.0, 7.0, 3.0, 0.0, -0.14479173735784842, -0.21713186390175285, -0.03403923708700391, 38.0] [-0.11987268456252011, 5.0, 0.35865755094331475, 2.0, 2.0, 0.0, 4.0, -0.14479173735784842, -0.21713186390175285, -0.8410484679825871, 38.0] [0.24480069389816542, 3.0, 1.525541514460902, 2.0, 9.0, 0.0, 4.0, -0.14479173735784842, -0.21713186390175285, 1.176474609256371, 6.0] [0.0989313425138912, 1.0, 1.525541514460902, 2.0, 9.0, 0.0, 4.0, 0.8868473744801746, -0.21713186390175285, -0.03403923708700391, 38.0] [0.39067004528243965, 5.0, -0.030303770229214273, 2.0, 4.0, 0.0, 4.0, -0.14479173735784842, -0.21713186390175285, 4.7273152251969375, 38.0] [1.1200168022038106, 3.0, 1.1365801932883728, 2.0, 12.0, 0.0, 4.0, -0.14479173735784842, -0.21713186390175285, -0.03403923708700391, 38.0] [-1.2868274956367138, 3.0, -0.030303770229214273, 4.0, 11.0, 3.0, 4.0, -0.14479173735784842, -0.21713186390175285, -1.6480576988781703, 38.0] [-0.7033500900996169, 3.0, -0.4192650914017433, 2.0, 7.0, 5.0, 4.0, -0.14479173735784842, 4.5022796885373735, -0.43754385253479555, 38.0] [0.5365393966667138, 3.0, 1.525541514460902, 4.0, 3.0, 4.0, 4.0, -0.14479173735784842, -0.21713186390175285, -0.03403923708700391, 38.0] [-1.3597621713288508, 3.0, -0.4192650914017433, 4.0, 6.0, 3.0, 2.0, -0.14479173735784842, -0.21713186390175285, -0.03403923708700391, 38.0] [0.5365393966667138, 3.0, 1.1365801932883728, 0.0, 11.0, 2.0, 2.0, -0.14479173735784842, -0.21713186390175285, -0.03403923708700391, 38.0] [1.338820829280222, 3.0, -0.4192650914017433, 2.0, 2.0, 0.0, 4.0, -0.14479173735784842, -0.21713186390175285, -0.03403923708700391, 38.0] [0.6824087480509881, 3.0, 1.1365801932883728, 0.0, 12.0, 3.0, 4.0, -0.14479173735784842, -0.21713186390175285, -0.03403923708700391, 38.0] [0.0259966668217541, 3.0, 1.1365801932883728, 2.0, 11.0, 0.0, 4.0, -0.14479173735784842, -0.21713186390175285, 0.3694653783607877, 38.0] [-0.4116113873310685, 3.0, -0.4192650914017433, 2.0, 11.0, 0.0, 4.0, -0.14479173735784842, -0.21713186390175285, 1.176474609256371, 38.0] [0.39067004528243965, 6.0, 1.1365801932883728, 4.0, 4.0, 1.0, 4.0, -0.14479173735784842, -0.21713186390175285, -0.03403923708700391, 38.0]
Mit dem gcloud-Befehlszeilentool können durch Zeilenumbruch getrennte JSON-Dateien für die Onlinevorhersage verwendet werden. Dieses spezielle Keras-Modell erwartet eine einfache Liste von Zahlen für jedes Eingabebeispiel.
Wenn Sie Anfragen zu Onlinevorhersagen an die REST API ohne das gcloud-Tool senden, ist für AI Platform ein anderes Format erforderlich. Die Strukturierung Ihres Modells bestimmt auch, wie Sie Daten für die Vorhersage formatieren müssen.
Informationen zum Formatieren von Daten für die Onlinevorhersage erhalten Sie unter Eingabedaten für Vorhersagen.
Anfrage für die Onlinevorhersage senden
Verwenden Sie gcloud zum Senden einer Anfrage für die Onlinevorhersage:
gcloud ai-platform predict \
--model $MODEL_NAME \
--region $REGION \
--version $MODEL_VERSION \
--json-instances prediction_input.json
DENSE_4 [0.6854287385940552] [0.011786997318267822] [0.037236183881759644] [0.016223609447479248] [0.0012015104293823242] [0.23621389269828796] [0.6174039244651794] [0.9822691679000854] [0.3815768361091614] [0.6715215444564819] [0.001094043254852295] [0.43077391386032104] [0.22132840752601624] [0.004075437784194946] [0.22736871242523193] [0.4111979305744171] [0.27328649163246155] [0.6981356143951416] [0.3309604525566101] [0.20807647705078125]
Da die letzte Ebene des Modells zur Aktivierung eine Sigmoidfunktion verwendet, stellen Ausgabewerte zwischen 0 und 0,5 negative Vorhersagen ("<=50K") und Ausgaben zwischen 0,5 und 1 positive Vorhersagen dar (">50K").
Keras-Modell von Grund auf entwickeln
Bisher haben Sie ein Modell für maschinelles Lernen in AI Platform trainiert, das trainierte Modell als Versionsressource in AI Platform bereitgestellt und über das Deployment Onlinevorhersagen abgerufen. Im nächsten Abschnitt wird die Neuerstellung des Keras-Codes beschrieben, der zum Trainieren Ihres Modells verwendet wurde. Dabei werden folgende Schritte der Entwicklung eines Modells für maschinelles Lernen zur Verwendung mit AI Platform erläutert:
- Daten herunterladen und vorverarbeiten
- Modell entwerfen und trainieren
- Training visualisieren und das trainierte Modell exportieren
Sie erhalten in diesem Abschnitt einen detaillierten Einblick in die Aufgaben, die in den vorherigen Abschnitten ausgeführt wurden. Weitere Informationen zur Verwendung von tf.keras finden Sie im TensorFlow-Leitfaden zu Keras.
Informationen zum Strukturieren von Code als Trainingspaket für AI Platform erhalten Sie unter Paket für eine Trainingsanwendung erstellen und im umfassenden Trainingscode, der als Python-Paket strukturiert ist.
Bibliotheken importieren und Konstanten festlegen
Importieren Sie zuerst die für das Training erforderlichen Python-Bibliotheken:
import os
from six.moves import urllib
import tempfile
import numpy as np
import pandas as pd
import tensorflow as tf
# Examine software versions
print(__import__('sys').version)
print(tf.__version__)
print(tf.keras.__version__)
Legen Sie dann einige nützliche Konstanten fest:
- Informationen zum Herunterladen von Trainings- und Validierungsdaten
- Informationen, die Pandas benötigt, um die Daten zu interpretieren und kategoriale Felder in numerische Merkmale zu konvertieren
- Hyperparameter für das Training, z. B. Lernrate und Batch-Größe
### For downloading data ###
# Storage directory
DATA_DIR = os.path.join(tempfile.gettempdir(), 'census_data')
# Download options.
DATA_URL = 'https://storage.googleapis.com/cloud-samples-data/ai-platform' \
'/census/data'
TRAINING_FILE = 'adult.data.csv'
EVAL_FILE = 'adult.test.csv'
TRAINING_URL = '%s/%s' % (DATA_URL, TRAINING_FILE)
EVAL_URL = '%s/%s' % (DATA_URL, EVAL_FILE)
### For interpreting data ###
# These are the features in the dataset.
# Dataset information: https://archive.ics.uci.edu/ml/datasets/census+income
_CSV_COLUMNS = [
'age', 'workclass', 'fnlwgt', 'education', 'education_num',
'marital_status', 'occupation', 'relationship', 'race', 'gender',
'capital_gain', 'capital_loss', 'hours_per_week', 'native_country',
'income_bracket'
]
_CATEGORICAL_TYPES = {
'workclass': pd.api.types.CategoricalDtype(categories=[
'Federal-gov', 'Local-gov', 'Never-worked', 'Private', 'Self-emp-inc',
'Self-emp-not-inc', 'State-gov', 'Without-pay'
]),
'marital_status': pd.api.types.CategoricalDtype(categories=[
'Divorced', 'Married-AF-spouse', 'Married-civ-spouse',
'Married-spouse-absent', 'Never-married', 'Separated', 'Widowed'
]),
'occupation': pd.api.types.CategoricalDtype([
'Adm-clerical', 'Armed-Forces', 'Craft-repair', 'Exec-managerial',
'Farming-fishing', 'Handlers-cleaners', 'Machine-op-inspct',
'Other-service', 'Priv-house-serv', 'Prof-specialty', 'Protective-serv',
'Sales', 'Tech-support', 'Transport-moving'
]),
'relationship': pd.api.types.CategoricalDtype(categories=[
'Husband', 'Not-in-family', 'Other-relative', 'Own-child', 'Unmarried',
'Wife'
]),
'race': pd.api.types.CategoricalDtype(categories=[
'Amer-Indian-Eskimo', 'Asian-Pac-Islander', 'Black', 'Other', 'White'
]),
'native_country': pd.api.types.CategoricalDtype(categories=[
'Cambodia', 'Canada', 'China', 'Columbia', 'Cuba', 'Dominican-Republic',
'Ecuador', 'El-Salvador', 'England', 'France', 'Germany', 'Greece',
'Guatemala', 'Haiti', 'Holand-Netherlands', 'Honduras', 'Hong', 'Hungary',
'India', 'Iran', 'Ireland', 'Italy', 'Jamaica', 'Japan', 'Laos', 'Mexico',
'Nicaragua', 'Outlying-US(Guam-USVI-etc)', 'Peru', 'Philippines', 'Poland',
'Portugal', 'Puerto-Rico', 'Scotland', 'South', 'Taiwan', 'Thailand',
'Trinadad&Tobago', 'United-States', 'Vietnam', 'Yugoslavia'
]),
'income_bracket': pd.api.types.CategoricalDtype(categories=[
'<=50K', '>50K'
])
}
# This is the label (target) we want to predict.
_LABEL_COLUMN = 'income_bracket'
### Hyperparameters for training ###
# This the training batch size
BATCH_SIZE = 128
# This is the number of epochs (passes over the full training data)
NUM_EPOCHS = 20
# Define learning rate.
LEARNING_RATE = .01
Daten herunterladen und vorverarbeiten
Daten herunterladen
Als Nächstes definieren Sie Funktionen zum Herunterladen von Trainings- und Validierungsdaten. Diese Funktionen beheben außerdem kleinere Unregelmäßigkeiten in der Datenformatierung.
def _download_and_clean_file(filename, url):
"""Downloads data from url, and makes changes to match the CSV format.
The CSVs may use spaces after the comma delimters (non-standard) or include
rows which do not represent well-formed examples. This function strips out
some of these problems.
Args:
filename: filename to save url to
url: URL of resource to download
"""
temp_file, _ = urllib.request.urlretrieve(url)
with tf.gfile.Open(temp_file, 'r') as temp_file_object:
with tf.gfile.Open(filename, 'w') as file_object:
for line in temp_file_object:
line = line.strip()
line = line.replace(', ', ',')
if not line or ',' not in line:
continue
if line[-1] == '.':
line = line[:-1]
line += '\n'
file_object.write(line)
tf.gfile.Remove(temp_file)
def download(data_dir):
"""Downloads census data if it is not already present.
Args:
data_dir: directory where we will access/save the census data
"""
tf.gfile.MakeDirs(data_dir)
training_file_path = os.path.join(data_dir, TRAINING_FILE)
if not tf.gfile.Exists(training_file_path):
_download_and_clean_file(training_file_path, TRAINING_URL)
eval_file_path = os.path.join(data_dir, EVAL_FILE)
if not tf.gfile.Exists(eval_file_path):
_download_and_clean_file(eval_file_path, EVAL_URL)
return training_file_path, eval_file_path
Verwenden Sie diese Funktionen, um die Daten für das Training herunterzuladen und zu überprüfen, ob Sie CSV-Dateien für Training und Validierung haben:
training_file_path, eval_file_path = download(DATA_DIR)
Anschließend laden Sie diese Dateien mithilfe von Pandas und prüfen die Daten:
# This census data uses the value '?' for fields (column) that are missing data.
# We use na_values to find ? and set it to NaN values.
# https://pandas.pydata.org/pandas-docs/stable/generated/pandas.read_csv.html
train_df = pd.read_csv(training_file_path, names=_CSV_COLUMNS, na_values='?')
eval_df = pd.read_csv(eval_file_path, names=_CSV_COLUMNS, na_values='?')
Die folgende Tabelle zeigt einen Auszug der Daten (train_df.head()) vor der Vorverarbeitung.
| age | workclass | fnlwgt | education | education_num | marital_status | occupation | relationship | race | gender | capital_gain | capital_loss | hours_per_week | native_country | income_bracket | |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| 0 | 39 | State-gov | 77516 | Bachelors | 13 | Never-married | Adm-clerical | Not-in-family | White | Male | 2174 | 0 | 40 | United-States | <=50K |
| 1 | 50 | Self-emp-not-inc | 83311 | Bachelors | 13 | Married-civ-spouse | Exec-managerial | Husband | White | Male | 0 | 0 | 13 | United-States | <=50K |
| 2 | 38 | Private | 215646 | HS-grad | 9 | Divorced | Handlers-cleaners | Not-in-family | White | Male | 0 | 0 | 40 | United-States | <=50K |
| 3 | 53 | Private | 234721 | 11th | 7 | Married-civ-spouse | Handlers-cleaners | Husband | Black | Male | 0 | 0 | 40 | United-States | <=50K |
| 4 | 28 | Privat | 338409 | Bachelors | 13 | Married-civ-spouse | Prof-specialty | Wife | Black | Female | 0 | 0 | 40 | Cuba | <=50K |
Daten vorverarbeiten
Beim ersten Schritt der Vorverarbeitung werden bestimmte Merkmale aus den Daten entfernt und kategoriale Merkmale zur Verwendung mit Keras in numerische Werte konvertiert.
Weitere Informationen finden Sie unter Feature Engineering und Verzerrung in Daten.
UNUSED_COLUMNS = ['fnlwgt', 'education', 'gender']
def preprocess(dataframe):
"""Converts categorical features to numeric. Removes unused columns.
Args:
dataframe: Pandas dataframe with raw data
Returns:
Dataframe with preprocessed data
"""
dataframe = dataframe.drop(columns=UNUSED_COLUMNS)
# Convert integer valued (numeric) columns to floating point
numeric_columns = dataframe.select_dtypes(['int64']).columns
dataframe[numeric_columns] = dataframe[numeric_columns].astype('float32')
# Convert categorical columns to numeric
cat_columns = dataframe.select_dtypes(['object']).columns
dataframe[cat_columns] = dataframe[cat_columns].apply(lambda x: x.astype(
_CATEGORICAL_TYPES[x.name]))
dataframe[cat_columns] = dataframe[cat_columns].apply(lambda x: x.cat.codes)
return dataframe
prepped_train_df = preprocess(train_df)
prepped_eval_df = preprocess(eval_df)
Die folgende Tabelle prepped_train_df.head() zeigt, wie die Daten durch die Vorverarbeitung geändert wurden. Beachten Sie insbesondere, dass income_bracket, d. h., das Label, für dessen Vorhersage Sie das Modell trainieren, von <=50K und >50K in 0 und 1 geändert wurde:
| age | workclass | education_num | marital_status | occupation | relationship | race | capital_gain | capital_loss | hours_per_week | native_country | income_bracket | |
|---|---|---|---|---|---|---|---|---|---|---|---|---|
| 0 | 39.0 | 6 | 13.0 | 4 | 0 | 1 | 4 | 2174.0 | 0.0 | 40.0 | 38 | 0 |
| 1 | 50.0 | 5 | 13.0 | 2 | 3 | 0 | 4 | 0.0 | 0.0 | 13.0 | 38 | 0 |
| 2 | 38.0 | 3 | 9.0 | 0 | 5 | 1 | 4 | 0.0 | 0.0 | 40.0 | 38 | 0 |
| 3 | 53.0 | 3 | 7.0 | 2 | 5 | 0 | 2 | 0.0 | 0.0 | 40.0 | 38 | 0 |
| 4 | 28.0 | 3 | 13.0 | 2 | 9 | 5 | 2 | 0.0 | 0.0 | 40.0 | 4 | 0 |
Teilen Sie nun die Daten in Merkmale ("x") und Labels ("y") auf und wandeln Sie die Labelarrays in ein Format um, das Sie später mit tf.data.Dataset verwenden können.
# Split train and test data with labels.
# The pop() method will extract (copy) and remove the label column from the dataframe
train_x, train_y = prepped_train_df, prepped_train_df.pop(_LABEL_COLUMN)
eval_x, eval_y = prepped_eval_df, prepped_eval_df.pop(_LABEL_COLUMN)
# Reshape label columns for use with tf.data.Dataset
train_y = np.asarray(train_y).astype('float32').reshape((-1, 1))
eval_y = np.asarray(eval_y).astype('float32').reshape((-1, 1))
Wenn Sie die Trainingsdaten so skalieren, dass jede numerische Merkmalspalte einen Mittelwert von 0 und eine Standardabweichung von 1 enthält, lässt sich das Modell möglicherweise verbessern.
In einem Produktionssystem sollten Sie die Mittelwerte und Standardabweichungen Ihrer Trainingsdaten am besten speichern und dazu verwenden, eine identische Transformation der Testdaten bei der Vorhersage durchzuführen. Der Einfachheit halber verbinden Sie vorübergehend die Trainings- und Validierungsdaten in dieser Übung, um sie insgesamt zu skalieren:
def standardize(dataframe):
"""Scales numerical columns using their means and standard deviation to get
z-scores: the mean of each numerical column becomes 0, and the standard
deviation becomes 1. This can help the model converge during training.
Args:
dataframe: Pandas dataframe
Returns:
Input dataframe with the numerical columns scaled to z-scores
"""
dtypes = list(zip(dataframe.dtypes.index, map(str, dataframe.dtypes)))
# Normalize numeric columns.
for column, dtype in dtypes:
if dtype == 'float32':
dataframe[column] -= dataframe[column].mean()
dataframe[column] /= dataframe[column].std()
return dataframe
# Join train_x and eval_x to normalize on overall means and standard
# deviations. Then separate them again.
all_x = pd.concat([train_x, eval_x], keys=['train', 'eval'])
all_x = standardize(all_x)
train_x, eval_x = all_x.xs('train'), all_x.xs('eval')
Die nächste Tabelle train_x.head() stellt die vollständig vorverarbeiteten Daten dar:
| age | workclass | education_num | marital_status | occupation | relationship | race | capital_gain | capital_loss | hours_per_week | native_country | |
|---|---|---|---|---|---|---|---|---|---|---|---|
| 0 | 0.025997 | 6 | 1.136580 | 4 | 0 | 1 | 4 | 0.146933 | -0.217132 | -0.034039 | 38 |
| 1 | 0.828278 | 5 | 1.136580 | 2 | 3 | 0 | 4 | -0.144792 | -0.217132 | -2.212964 | 38 |
| 2 | -0.046938 | 3 | -0.419265 | 0 | 5 | 1 | 4 | -0.144792 | -0.217132 | -0.034039 | 38 |
| 3 | 1.047082 | 3 | -1.197188 | 2 | 5 | 0 | 2 | -0.144792 | -0.217132 | -0.034039 | 38 |
| 4 | -0.776285 | 3 | 1.136580 | 2 | 9 | 5 | 2 | -0.144792 | -0.217132 | -0.034039 | 4 |
Modell entwerfen und trainieren
Trainings- und Validierungs-Datasets
Erstellen Sie eine Eingabefunktion, mit der Sie Merkmale und Labels für das Training oder für die Validierung in ein tf.data.Dataset umwandeln:
def input_fn(features, labels, shuffle, num_epochs, batch_size):
"""Generates an input function to be used for model training.
Args:
features: numpy array of features used for training or inference
labels: numpy array of labels for each example
shuffle: boolean for whether to shuffle the data or not (set True for
training, False for evaluation)
num_epochs: number of epochs to provide the data for
batch_size: batch size for training
Returns:
A tf.data.Dataset that can provide data to the Keras model for training or
evaluation
"""
if labels is None:
inputs = features
else:
inputs = (features, labels)
dataset = tf.data.Dataset.from_tensor_slices(inputs)
if shuffle:
dataset = dataset.shuffle(buffer_size=len(features))
# We call repeat after shuffling, rather than before, to prevent separate
# epochs from blending together.
dataset = dataset.repeat(num_epochs)
dataset = dataset.batch(batch_size)
return dataset
Erstellen Sie als Nächstes diese Trainings- und Evaluierungs-Datasets. Verwenden Sie dazu die zuvor definierten Hyperparameter NUM_EPOCHS und BATCH_SIZE, um festzulegen, wie das Trainings-Dataset während des Trainings Beispiele für das Modell liefert. Richten Sie das Validierungs-Dataset so ein, dass alle Beispiele in einem Batch bereitgestellt werden, damit am Ende jeder Trainingsphase nur ein einziger Validierungsschritt erforderlich ist.
# Pass a numpy array by using DataFrame.values
training_dataset = input_fn(features=train_x.values,
labels=train_y,
shuffle=True,
num_epochs=NUM_EPOCHS,
batch_size=BATCH_SIZE)
num_eval_examples = eval_x.shape[0]
# Pass a numpy array by using DataFrame.values
validation_dataset = input_fn(features=eval_x.values,
labels=eval_y,
shuffle=False,
num_epochs=NUM_EPOCHS,
batch_size=num_eval_examples)
Keras-Modell entwerfen
Entwerfen Sie Ihr neuronales Netz mit der Keras Sequential API.
Dieses neuronale Deep-Learning-Netzwerk hat mehrere verborgene Ebenen. Die letzte Ebene verwendet eine Sigmoid-Aktivierungsfunktion, um einen Wert zwischen 0 und 1 auszugeben:
- Die Eingabeebene hat 100 Einheiten, die die ReLU-Aktivierungsfunktion verwenden.
- Die verborgene Ebene hat 75 Einheiten, die die ReLU-Aktivierungsfunktion verwenden.
- Die verborgene Ebene hat 50 Einheiten, die die ReLU-Aktivierungsfunktion verwenden.
- Die verborgene Ebene hat 25 Einheiten, die die ReLU-Aktivierungsfunktion verwenden.
- Die Ausgabeebene hat 1 Einheit, die eine Sigmoid-Aktivierungsfunktion verwendet.
- Die Optimierung verwendet die binäre Kreuzentropie-Verlustfunktion, die für ein binäres Klassifizierungsproblem wie dieses geeignet ist.
Sie können diese Ebenen nach Belieben ändern, wenn Sie versuchen möchten, das Modell zu verbessern:
def create_keras_model(input_dim, learning_rate):
"""Creates Keras Model for Binary Classification.
Args:
input_dim: How many features the input has
learning_rate: Learning rate for training
Returns:
The compiled Keras model (still needs to be trained)
"""
Dense = tf.keras.layers.Dense
model = tf.keras.Sequential(
[
Dense(100, activation=tf.nn.relu, kernel_initializer='uniform',
input_shape=(input_dim,)),
Dense(75, activation=tf.nn.relu),
Dense(50, activation=tf.nn.relu),
Dense(25, activation=tf.nn.relu),
Dense(1, activation=tf.nn.sigmoid)
])
# Custom Optimizer:
# https://www.tensorflow.org/api_docs/python/tf/train/RMSPropOptimizer
optimizer = tf.keras.optimizers.RMSprop(
lr=learning_rate)
# Compile Keras model
model.compile(
loss='binary_crossentropy', optimizer=optimizer, metrics=['accuracy'])
return model
Als Nächstes erstellen Sie das Keras-Modellobjekt:
num_train_examples, input_dim = train_x.shape
print('Number of features: {}'.format(input_dim))
print('Number of examples: {}'.format(num_train_examples))
keras_model = create_keras_model(
input_dim=input_dim,
learning_rate=LEARNING_RATE)
Bei Prüfung des Modells mit keras_model.summary() sollte in etwa Folgendes zurückgegeben werden:
Number of features: 11 Number of examples: 32561 WARNING:tensorflow:From /usr/local/lib/python3.6/dist-packages/tensorflow/python/ops/resource_variable_ops.py:435: colocate_with (from tensorflow.python.framework.ops) is deprecated and will be removed in a future version. Instructions for updating: Colocations handled automatically by placer. _________________________________________________________________ Layer (type) Output Shape Param # ================================================================= dense (Dense) (None, 100) 1200 _________________________________________________________________ dense_1 (Dense) (None, 75) 7575 _________________________________________________________________ dense_2 (Dense) (None, 50) 3800 _________________________________________________________________ dense_3 (Dense) (None, 25) 1275 _________________________________________________________________ dense_4 (Dense) (None, 1) 26 ================================================================= Total params: 13,876 Trainable params: 13,876 Non-trainable params: 0 _________________________________________________________________
Modell trainieren und evaluieren
Definieren Sie eine Abnahme der Lernrate, um zu ermutigen, dass Modellparameter im Laufe des Trainings kleinere Änderungen vornehmen:
# Setup Learning Rate decay.
lr_decay_cb = tf.keras.callbacks.LearningRateScheduler(
lambda epoch: LEARNING_RATE + 0.02 * (0.5 ** (1 + epoch)),
verbose=True)
# Setup TensorBoard callback.
JOB_DIR = os.getenv('JOB_DIR')
tensorboard_cb = tf.keras.callbacks.TensorBoard(
os.path.join(JOB_DIR, 'keras_tensorboard'),
histogram_freq=1)
Anschließend trainieren Sie das Modell. Stellen Sie die entsprechende steps_per_epoch-Phase für das Modell bereit, damit während jeder Phase das gesamte Trainings-Dataset (mit BATCH_SIZE-Beispielen pro Schritt) trainiert wird. Außerdem sollten Sie festlegen, dass das Modell die Validierungsgenauigkeit mit einem großen Validierungsbatch am Ende jeder Phase berechnet.
history = keras_model.fit(training_dataset,
epochs=NUM_EPOCHS,
steps_per_epoch=int(num_train_examples/BATCH_SIZE),
validation_data=validation_dataset,
validation_steps=1,
callbacks=[lr_decay_cb, tensorboard_cb],
verbose=1)
Der Trainingsfortschritt kann etwa so aussehen:
WARNING:tensorflow:From /usr/local/lib/python3.6/dist-packages/tensorflow/python/ops/math_ops.py:3066: to_int32 (from tensorflow.python.ops.math_ops) is deprecated and will be removed in a future version. Instructions for updating: Use tf.cast instead. Epoch 00001: LearningRateScheduler reducing learning rate to 0.02. Epoch 1/20 254/254 [==============================] - 1s 5ms/step - loss: 0.6986 - acc: 0.7893 - val_loss: 0.3894 - val_acc: 0.8329 Epoch 00002: LearningRateScheduler reducing learning rate to 0.015. Epoch 2/20 254/254 [==============================] - 1s 4ms/step - loss: 0.3574 - acc: 0.8335 - val_loss: 0.3861 - val_acc: 0.8131 ... Epoch 00019: LearningRateScheduler reducing learning rate to 0.010000038146972657. Epoch 19/20 254/254 [==============================] - 1s 4ms/step - loss: 0.3239 - acc: 0.8512 - val_loss: 0.3334 - val_acc: 0.8496 Epoch 00020: LearningRateScheduler reducing learning rate to 0.010000019073486329. Epoch 20/20 254/254 [==============================] - 1s 4ms/step - loss: 0.3279 - acc: 0.8504 - val_loss: 0.3174 - val_acc: 0.8523
Training visualisieren und das trainierte Modell exportieren
Training visualisieren
Durch Importieren von matplotlib können Sie die Lernkurve des Modells während des Trainingszeitraums visualisieren.
Gegebenenfalls müssen Sie "matplotlib" zuerst mit pip install matplotlib installieren.
from matplotlib import pyplot as plt
Stellen Sie den Verlust (binäre Kreuzentropie) und die Accuracy des Modells am Ende jeder Trainingsphase dar:
# Visualize History for Loss.
plt.title('Keras model loss')
plt.plot(history.history['loss'])
plt.plot(history.history['val_loss'])
plt.ylabel('loss')
plt.xlabel('epoch')
plt.legend(['training', 'validation'], loc='upper right')
plt.show()
# Visualize History for Accuracy.
plt.title('Keras model accuracy')
plt.ylabel('accuracy')
plt.xlabel('epoch')
plt.plot(history.history['acc'])
plt.plot(history.history['val_acc'])
plt.legend(['training', 'validation'], loc='lower right')
plt.show()
Mit der Zeit nimmt der Verlust ab und die Accuracy nimmt zu. Nähern sich die Werte jedoch einem stabilen Niveau an? Gibt es große Unterschiede zwischen den Trainings- und Validierungsmesswerten (ein Zeichen von Überanpassung)?
Lesen Sie nach, wie Sie Ihr Modell für maschinelles Lernen verbessern können. Anschließend können Sie die Hyperparameter oder die Modellarchitektur nach Belieben anpassen und neu trainieren.
Modell für die Bereitstellung exportieren
Verwenden Sie tf.contrib.saved_model.save_keras_model, um ein TensorFlow SavedModel-Verzeichnis zu exportieren. AI Platform benötigt dieses Format, wenn Sie eine Modellversionsressource erstellen.
Da nicht alle Optimierungen in das SavedModel-Format exportiert werden können, werden während des Exportvorgangs möglicherweise Warnmeldungen angezeigt. AI Platform kann das SavedModel für Vorhersagen verwenden, sofern Sie eine Bereitstellungsgrafik erfolgreich exportieren.
# Export the model to a local SavedModel directory
export_path = tf.contrib.saved_model.save_keras_model(keras_model, 'keras_export')
print("Model exported to: ", export_path)
WARNING: The TensorFlow contrib module will not be included in TensorFlow 2.0. For more information, please see: * https://github.com/tensorflow/community/blob/master/rfcs/20180907-contrib-sunset.md * https://github.com/tensorflow/addons If you depend on functionality not listed there, please file an issue. WARNING:tensorflow:This model was compiled with a Keras optimizer (<tensorflow.python.keras.optimizers.RMSprop object at 0x7fc198c4e400>) but is being saved in TensorFlow format with `save_weights`. The model's weights will be saved, but unlike with TensorFlow optimizers in the TensorFlow format the optimizer's state will not be saved. Consider using a TensorFlow optimizer from `tf.train`. WARNING:tensorflow:From /usr/local/lib/python3.6/dist-packages/tensorflow/python/keras/engine/network.py:1436: update_checkpoint_state (from tensorflow.python.training.checkpoint_management) is deprecated and will be removed in a future version. Instructions for updating: Use tf.train.CheckpointManager to manage checkpoints rather than manually editing the Checkpoint proto. WARNING:tensorflow:Model was compiled with an optimizer, but the optimizer is not from `tf.train` (e.g. `tf.train.AdagradOptimizer`). Only the serving graph was exported. The train and evaluate graphs were not added to the SavedModel. WARNING:tensorflow:From /usr/local/lib/python3.6/dist-packages/tensorflow/python/saved_model/signature_def_utils_impl.py:205: build_tensor_info (from tensorflow.python.saved_model.utils_impl) is deprecated and will be removed in a future version. Instructions for updating: This function will only be available through the v1 compatibility library as tf.compat.v1.saved_model.utils.build_tensor_info or tf.compat.v1.saved_model.build_tensor_info. INFO:tensorflow:Signatures INCLUDED in export for Classify: None INFO:tensorflow:Signatures INCLUDED in export for Regress: None INFO:tensorflow:Signatures INCLUDED in export for Predict: ['serving_default'] INFO:tensorflow:Signatures INCLUDED in export for Train: None INFO:tensorflow:Signatures INCLUDED in export for Eval: None INFO:tensorflow:No assets to save. INFO:tensorflow:No assets to write. INFO:tensorflow:SavedModel written to: keras_export/1553710367/saved_model.pb Model exported to: b'keras_export/1553710367'
Sie können ein SavedModel-Verzeichnis in Ihr lokales Dateisystem oder nach Cloud Storage exportieren, sofern Sie die erforderlichen Berechtigungen haben. In der aktuellen Umgebung haben Sie Ihr Google Cloud-Konto authentifiziert und die Umgebungsvariable GOOGLE_APPLICATION_CREDENTIALS angegeben, um den Zugriff auf Cloud Storage zu gewähren. Mit AI Platform-Trainingsjobs können Modelle auch direkt nach Cloud Storage exportiert werden, da AI Platform-Dienstkonten in ihrem eigenen Projekt Zugriff auf Cloud Storage-Buckets haben.
Versuchen Sie, einen direkten Export nach Cloud Storage auszuführen:
JOB_DIR = os.getenv('JOB_DIR')
# Export the model to a SavedModel directory in Cloud Storage
export_path = tf.contrib.saved_model.save_keras_model(keras_model, JOB_DIR + '/keras_export')
print("Model exported to: ", export_path)
WARNING:tensorflow:This model was compiled with a Keras optimizer (<tensorflow.python.keras.optimizers.RMSprop object at 0x7fc198c4e400>) but is being saved in TensorFlow format with `save_weights`. The model's weights will be saved, but unlike with TensorFlow optimizers in the TensorFlow format the optimizer's state will not be saved. Consider using a TensorFlow optimizer from `tf.train`. WARNING:tensorflow:Model was compiled with an optimizer, but the optimizer is not from `tf.train` (e.g. `tf.train.AdagradOptimizer`). Only the serving graph was exported. The train and evaluate graphs were not added to the SavedModel. INFO:tensorflow:Signatures INCLUDED in export for Classify: None INFO:tensorflow:Signatures INCLUDED in export for Regress: None INFO:tensorflow:Signatures INCLUDED in export for Predict: ['serving_default'] INFO:tensorflow:Signatures INCLUDED in export for Train: None INFO:tensorflow:Signatures INCLUDED in export for Eval: None INFO:tensorflow:No assets to save. INFO:tensorflow:No assets to write. INFO:tensorflow:SavedModel written to: gs://your-bucket-name/keras-job-dir/keras_export/1553710379/saved_model.pb Model exported to: b'gs://your-bucket-name/keras-job-dir/keras_export/1553710379'
Sie können dieses Modell jetzt in AI Platform bereitstellen und Vorhersagen erstellen. Führen Sie dazu die Schritte aus der Kurzanleitung für Vorhersagen aus.
Bereinigen
Wenn Sie alle für dieses Projekt verwendeten Google Cloud-Ressourcen bereinigen möchten, können Sie das Google Cloud-Projekt löschen, das Sie für diese Anleitung verwendet haben.
Alternativ können Sie mit den folgenden Befehlen einzelne Ressourcen bereinigen:
# Delete model version resource
gcloud ai-platform versions delete $MODEL_VERSION --quiet --model $MODEL_NAME
# Delete model resource
gcloud ai-platform models delete $MODEL_NAME --quiet
# Delete Cloud Storage objects that were created
gsutil -m rm -r $JOB_DIR
# If training job is still running, cancel it
gcloud ai-platform jobs cancel $JOB_NAME --quiet
Wenn Ihr Cloud Storage-Bucket keine weiteren Objekte enthält, können Sie ihn mit gsutil rm -r gs://$BUCKET_NAME löschen.
Nächste Schritte
- Sehen Sie sich den gesamten Trainingscode an, der in diesem Handbuch verwendet wird. Dabei wird der Code so strukturiert, dass benutzerdefinierte Hyperparameter als Befehlszeilen-Flags akzeptiert werden.
- Weitere Informationen zum Paketerstellungscode für einen AI Platform-Trainingsjob
- Lesen Sie nach, wie Sie ein Modell bereitstellen und für Vorhersagen verwenden.