Benutzerdefinierte Vorhersageroutine mit Keras erstellen

Colab-LogoDiese Anleitung als Notebook in Colab ausführen Logo: GitHubNotebook auf GitHub ansehen

In dieser Anleitung wird gezeigt, wie Sie ein trainiertes Keras-Modell in AI Platform Prediction bereitstellen und Vorhersagen mithilfe einer benutzerdefinierten Vorhersageroutine erstellen. Auf diese Weise können Sie anpassen, wie AI Platform Prediction auf die einzelnen Vorhersageanfragen reagiert.

In diesem Beispiel verwenden Sie eine benutzerdefinierte Vorhersageroutine, um die Vorhersageeingabe durch Skalierung vorzuverarbeiten und die Vorhersageausgabe nachzubearbeiten, indem Sie Softmax-Wahrscheinlichkeitsausgaben in Label-Strings konvertieren.

Die Anleitung umfasst mehrere Schritte:

  • Lokales Training eines einfachen Keras-Modells
  • Erstellung und Bereitstellung einer benutzerdefinierten Vorhersageroutine in AI Platform Prediction
  • Bearbeitung von Vorhersageanfragen in dieser Bereitstellung

Dataset

In dieser Anleitung wird das Iris-Dataset von R.A. Fisher verwendet, ein kleines Dataset, das häufig zum Testen von Techniken des maschinellen Lernens eingesetzt wird. Jede Instanz hat vier numerische Merkmale, bei denen es sich um verschiedene Messwerte einer Blume handelt, und ein Ziel-Label, das sie als einen von drei Schwertlilienarten kennzeichnet: Iris setosa, Iris versicolour oder Iris virginica.

In dieser Anleitung wird die Kopie des in der scikit-learn-Bibliothek enthaltenen Iris-Datasets verwendet.

Ziel

Das Ziel besteht darin, ein Modell zu trainieren, das die Messwerte einer Blume als Eingabe verwendet, um vorherzusagen, um welche Art von Schwertlilie es sich handelt.

Der Schwerpunkt dieser Anleitung liegt mehr auf der Verwendung des Modells mit AI Platform Prediction als auf dem eigentlichen Modelldesign.

Kosten

In dieser Anleitung werden kostenpflichtige Komponenten von Google Cloud verwendet.

  • AI Platform Prediction
  • Cloud Storage

Informieren Sie sich über die Preise von AI Platform Prediction und die Preise von Cloud Storage. Mit dem Preisrechner können Sie die voraussichtlichen Kosten anhand der geplanten Nutzung kalkulieren.

Vorbereitung

Bevor Sie ein Modell in AI Platform Prediction trainieren und bereitstellen können, müssen Sie einige Schritte ausführen:

  • Lokale Entwicklungsumgebung einrichten
  • Google Cloud-Projekt einrichten, 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:

  • Python 3
  • virtualenv
  • 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:

  1. Installieren Sie Python 3.

  2. Installieren Sie virtualenv und erstellen Sie eine virtuelle Umgebung, die Python 3 verwendet.

  3. Aktivieren Sie die Umgebung.

  4. Führen Sie die Schritte im folgenden Abschnitt aus, um das Cloud SDK zu installieren.

Google Cloud-Projekt einrichten

  1. 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.
  2. Wählen Sie in der Google Cloud Console auf der Seite der Projektauswahl ein Google Cloud-Projekt aus oder erstellen Sie eines.

    Zur Projektauswahl

  3. Die Abrechnung für das Cloud-Projekt muss aktiviert sein. So prüfen Sie, ob die Abrechnung für Ihr Projekt aktiviert ist.

  4. AI Platform Training & Prediction and Compute Engine APIs aktivieren.

    Aktivieren Sie die APIs

  5. Installieren und initialisieren Sie das Cloud SDK.

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.

  1. Erstellen Sie ein Dienstkonto:

    1. Wechseln Sie in der Cloud Console zur Seite Dienstkonto erstellen.

      Zur Seite „Dienstkonto erstellen“

    2. Geben Sie im Feld Dienstkontoname einen Namen ein.
    3. Optional: Geben Sie im Feld Dienstkontobeschreibung eine Beschreibung ein.
    4. Klicken Sie auf Erstellen.
    5. Klicken Sie auf das Feld Rolle auswählen. Wählen Sie unter Alle Rollen die Option Machine Learning Engine > ML Engine-Administrator aus.
    6. Klicken Sie auf Weitere Rolle hinzufügen.
    7. Klicken Sie auf das Feld Rolle auswählen. Wählen Sie unter Alle Rollen die Option Storage > Storage-Objekt-Administrator.

    8. Klicken Sie auf Fertig, um das Dienstkonto zu erstellen.

      Schließen Sie das Browserfenster nicht. Sie verwenden es in der nächsten Aufgabe.

  2. Erstellen Sie einen Dienstkontoschlüssel für die Authentifizierung:

    1. Klicken Sie in der Cloud Console auf die E-Mail-Adresse des von Ihnen erstellten Dienstkontos.
    2. Klicken Sie auf Schlüssel.
    3. Klicken Sie auf Schlüssel hinzufügen > Neuen Schlüssel erstellen.
    4. Klicken Sie auf Erstellen. Daraufhin wird eine JSON-Schlüsseldatei auf Ihren Computer heruntergeladen.
    5. Klicken Sie auf Schließen.
  3. 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

Zum Bereitstellen einer benutzerdefinierten Vorhersageroutine müssen Sie die trainierten Modellartefakte und den benutzerdefinierten Code in Cloud Storage hochladen.

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 Prediction verfügbar ist, und erstellen Sie eine weitere Umgebungsvariable.

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

Keras-Modell erstellen und trainieren

Häufig können Sie Daten nicht in ihrer Rohform verwenden, um ein Modell für maschinelles Lernen zu trainieren. Selbst wenn dies möglich ist, kann das Modell oft verbessert werden, wenn Sie die Daten vor der Verwendung für das Training vorverarbeiten.

Wenn Sie davon ausgehen, dass die Eingabe für die Vorhersage dasselbe Format wie Ihre Trainingsdaten hat, müssen Sie während des Trainings und der Vorhersage eine identische Vorverarbeitung anwenden, um zu gewährleisten, dass Ihr Modell konsistente Vorhersagen liefert.

In diesem Abschnitt erstellen Sie ein Vorverarbeitungsmodul, das Sie im Rahmen des Trainings verwenden. Dann exportieren Sie einen Präprozessor mit während des Trainings erlernten Eigenschaften, um diesen später in Ihrer benutzerdefinierten Vorhersageroutine zu verwenden.

Abhängigkeiten für lokales Training installieren

Lokales Training erfordert mehrere Abhängigkeiten:

pip install numpy scikit-learn 'tensorflow=2.3'

Präprozessor schreiben

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.

Erstellen Sie die Datei preprocess.py, die eine Klasse für diese Skalierung enthält:

import numpy as np

class MySimpleScaler(object):
  def __init__(self):
    self._means = None
    self._stds = None

  def preprocess(self, data):
    if self._means is None: # during training only
      self._means = np.mean(data, axis=0)

    if self._stds is None: # during training only
      self._stds = np.std(data, axis=0)
      if not self._stds.all():
        raise ValueError('At least one column has standard deviation of 0.')

    return (data - self._means) / self._stds

Eine Instanz von MySimpleScaler speichert die Mittelwerte und Standardabweichungen der einzelnen Feature-Spalten bei der ersten Verwendung. Danach nutzt es diese zusammenfassenden Statistiken zur Skalierung von Daten, die später neu hinzukommen.

Dadurch können Sie Eigenschaften der Trainingsdistribution speichern und für die identische Vorverarbeitung zur Vorhersagezeit verwenden.

Modell trainieren

Verwenden Sie als Nächstes preprocess.MySimpleScaler, um die Iris-Daten vorzuverarbeiten und anschließend ein einfaches neuronales Netzwerk mit Keras zu trainieren.

Zum Abschluss exportieren Sie Ihr trainiertes Keras-Modell als HDF5-Datei (.h5) und Ihre MySimpleScaler-Instanz als Pickle-Datei (.pkl):

import pickle

from sklearn.datasets import load_iris
import tensorflow as tf

from preprocess import MySimpleScaler

iris = load_iris()
scaler = MySimpleScaler()
num_classes = len(iris.target_names)
X = scaler.preprocess(iris.data)
y = tf.keras.utils.to_categorical(iris.target, num_classes=num_classes)

model = tf.keras.Sequential()
model.add(tf.keras.layers.Dense(25, activation=tf.nn.relu))
model.add(tf.keras.layers.Dense(25, activation=tf.nn.relu))
model.add(tf.keras.layers.Dense(num_classes, activation=tf.nn.softmax))
model.compile(
  optimizer='adam', loss='categorical_crossentropy', metrics=['accuracy'])
model.fit(X, y, epochs=10, batch_size=1)

model.save('model.h5')
with open ('preprocessor.pkl', 'wb') as f:
  pickle.dump(scaler, f)

Benutzerdefinierte Vorhersageroutine bereitstellen

Zum Bereitstellen einer benutzerdefinierten Vorhersageroutine für Vorhersagen mit Ihrem trainierten Modell müssen Sie folgende Schritte ausführen:

  • Benutzerdefinierten Predictor zur Verarbeitung von Anfragen erstellen
  • Paket mit dem Predictor und dem Vorverarbeitungsmodul erstellen
  • Modellartefakte und benutzerdefinierten Code in Cloud Storage hochladen
  • Benutzerdefinierte Vorhersageroutine in AI Platform Prediction bereitstellen

Benutzerdefinierten Predictor erstellen

Zum Bereitstellen einer benutzerdefinierten Vorhersageroutine müssen Sie eine Klasse erstellen, die die Predictor-Schnittstelle implementiert. Dadurch wird AI Platform Prediction mitgeteilt, wie Ihr Modell geladen und Vorhersageanfragen verarbeitet werden sollen.

Schreiben Sie den folgenden Code in predictor.py:

import os
import pickle

import numpy as np
from sklearn.datasets import load_iris
import tensorflow as tf

class MyPredictor(object):
  def __init__(self, model, preprocessor):
    self._model = model
    self._preprocessor = preprocessor
    self._class_names = load_iris().target_names

  def predict(self, instances, **kwargs):
    inputs = np.asarray(instances)
    preprocessed_inputs = self._preprocessor.preprocess(inputs)
    outputs = self._model.predict(preprocessed_inputs)
    if kwargs.get('probabilities'):
      return outputs.tolist()
    else:
      return [self._class_names[index] for index in np.argmax(outputs, axis=1)]

  @classmethod
  def from_path(cls, model_dir):
    model_path = os.path.join(model_dir, 'model.h5')
    model = tf.keras.models.load_model(model_path)

    preprocessor_path = os.path.join(model_dir, 'preprocessor.pkl')
    with open(preprocessor_path, 'rb') as f:
      preprocessor = pickle.load(f)

    return cls(model, preprocessor)

Neben der Verwendung des Präprozessors, den Sie während des Trainings definiert haben, führt dieser Predictor einen Nachbearbeitungsschritt aus, bei dem die Softmax-Ausgabe des neuronalen Netzwerks (ein Array, das für jedes Label die Wahrscheinlichkeit angibt, dass es das richtige ist) in das Label mit der höchsten Wahrscheinlichkeit konvertiert wird.

Wenn der Predictor jedoch ein probabilities-Schlüsselwortargument mit dem Wert True empfängt, gibt er stattdessen das Wahrscheinlichkeitsarray zurück. Im letzten Teil dieser Anleitung wird gezeigt, wie Sie dieses Schlüsselwortargument angeben.

Paket mit benutzerdefiniertem Code erstellen

Sie müssen predictor.py und preprocess.py als .tar.gz-Quelldistributionspaket verpacken und das Paket in AI Platform Prediction bereitstellen, damit der benutzerdefinierte Code für Vorhersagen verwendet werden kann.

Schreiben Sie folgende setup.py-Datei, um Ihr Paket zu definieren:

from setuptools import setup

setup(
    name='my_custom_code',
    version='0.1',
    scripts=['predictor.py', 'preprocess.py'])

Führen Sie dann den folgenden Befehl aus, um dist/my_custom_code-0.1.tar.gz zu erstellen:

python setup.py sdist --formats=gztar

Modellartefakte und benutzerdefinierten Code in Cloud Storage hochladen

Bevor Sie Ihr Modell für Vorhersagen bereitstellen können, benötigt AI Platform Prediction Zugriff auf die folgenden Dateien in Cloud Storage:

  • model.h5 (Modellartefakt)
  • preprocessor.pkl (Modellartefakt)
  • my_custom_code-0.1.tar.gz (benutzerdefinierter Code)

Modellartefakte müssen zusammen in einem Modellverzeichnis gespeichert werden, auf das der Predictor als model_dir-Argument in seiner Klassenmethode from_path zugreifen kann. Der benutzerdefinierte Code muss sich nicht im selben Verzeichnis befinden. Führen Sie die folgenden Befehle aus, um Ihre Dateien hochzuladen:

gsutil cp ./dist/my_custom_code-0.1.tar.gz gs://$BUCKET_NAME/custom_prediction_routine_tutorial/my_custom_code-0.1.tar.gz
gsutil cp model.h5 preprocessor.pkl gs://$BUCKET_NAME/custom_prediction_routine_tutorial/model/

Benutzerdefinierte Vorhersageroutine bereitstellen

Erstellen Sie eine Modellressource und eine Versionsressource, um die benutzerdefinierte Vorhersageroutine bereitzustellen. Definieren Sie zuerst Umgebungsvariablen mit Ihren Ressourcennamen:

MODEL_NAME='IrisPredictor'
VERSION_NAME='v1'

Erstellen Sie dann das Modell:

gcloud ai-platform models create $MODEL_NAME \
  --regions $REGION

Als Nächstes erstellen Sie eine Version. Geben Sie in diesem Schritt Pfade zu den Artefakten und dem benutzerdefinierten Code an, die Sie in Cloud Storage hochgeladen haben:

gcloud components install beta

gcloud beta ai-platform versions create $VERSION_NAME \
  --model $MODEL_NAME \
  --runtime-version 2.3 \
  --python-version 3.7 \
  --origin gs://$BUCKET_NAME/custom_prediction_routine_tutorial/model/ \
  --package-uris gs://$BUCKET_NAME/custom_prediction_routine_tutorial/my_custom_code-0.1.tar.gz \
  --prediction-class predictor.MyPredictor

Weitere Informationen zu den Optionen, die Sie beim Bereitstellen einer benutzerdefinierten Vorhersageroutine angeben müssen, finden Sie hier.

Onlinevorhersagen bereitstellen

Senden Sie eine Anfrage für eine Onlinevorhersage, um die Bereitstellung zu testen. Installieren Sie zuerst die Google APIs-Clientbibliothek für Python:

pip install --upgrade google-api-python-client

Senden Sie dann zwei Instanzen von Iris-Daten an die bereitgestellte Version:

import googleapiclient.discovery

instances = [
  [6.7, 3.1, 4.7, 1.5],
  [4.6, 3.1, 1.5, 0.2],
]

service = googleapiclient.discovery.build('ml', 'v1')
name = 'projects/{}/models/{}/versions/{}'.format(PROJECT_ID, MODEL_NAME, VERSION_NAME)

response = service.projects().predict(
    name=name,
    body={'instances': instances}
).execute()

if 'error' in response:
    raise RuntimeError(response['error'])
else:
  print(response['predictions'])
['versicolor', 'setosa']

Schlüsselwortargumente senden

Wenn Sie eine Vorhersageanfrage an eine benutzerdefinierte Vorhersageroutine senden, können Sie zusätzliche Felder im Anfragetext angeben. Die Methode predict des Predictors empfängt diese als Felder des **kwargs-Wörterbuchs.

Mit dem folgenden Code wird dieselbe Anfrage wie zuvor gesendet. Dieses Mal wird im Anfragetext jedoch das Feld probabilities hinzugefügt:

response = service.projects().predict(
    name=name,
    body={'instances': instances, 'probabilities': True}
).execute()

if 'error' in response:
    raise RuntimeError(response['error'])
else:
  print(response['predictions'])
[[0.0019204545533284545, 0.8623144626617432, 0.13576509058475494], [0.999488353729248, 0.000511515187099576, 1.293626752385535e-07]]

Bereinigen

Zum Bereinigen aller in diesem Projekt verwendeten GCP-Ressourcen können Sie das GCP-Projekt löschen, das Sie für die Anleitung verwendet haben.

Alternativ können Sie mit den folgenden Befehlen einzelne Ressourcen bereinigen:

# Delete version resource
gcloud ai-platform versions delete $VERSION_NAME --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 gs://$BUCKET_NAME/custom_prediction_routine_tutorial

Weitere Informationen