Benutzerdefinierte Vorhersageroutinen

Mithilfe von benutzerdefinierten Vorhersageroutinen können Sie feststellen, welcher Code ausgeführt wird, wenn Sie eine Anfrage für eine Onlinevorhersage an AI Platform senden.

Wenn Sie eine Versionsressource ohne benutzerdefinierte Vorhersageroutine in AI Platform bereitstellen, führt die Plattform zur Verarbeitung von Vorhersageanfragen den Vorhersagevorgang des Frameworks für maschinelles Lernen aus, den Sie für das Training verwendet haben.

Wenn Sie jedoch eine benutzerdefinierte Vorhersageroutine als Versionsressource bereitstellen, können Sie AI Platform anweisen, als Antwort auf jede erhaltene Vorhersageanfrage benutzerdefinierten Python-Code auszuführen. Sie können die Vorhersageeingabe vorverarbeiten, bevor Sie mit dem trainierten Modell eine Vorhersage ausführen, oder Sie können die Vorhersage des Modells vor dem Senden der Vorhersageergebnisse nachbearbeiten.

Zum Erstellen einer benutzerdefinierten Vorhersageroutine müssen Sie AI Platform beim Erstellen der Modellversion zwei Teile zur Verfügung stellen:

  • Ein Modellverzeichnis in Cloud Storage, das alle für die Vorhersage zu verwendenden Artefakte enthält

  • Ein .tar.gz-Distributionspaket des Python-Quellcodes in Cloud Storage, das Ihre Implementierung der Predictor-Schnittstelle und sonstigen benutzerdefinierten Code enthält, den AI Platform zur Vorhersagezeit verwenden soll

Modellartefakte in das Modellverzeichnis hochladen

In der Anleitung zum Bereitstellen von Modellen wird beschrieben, wie Sie ein trainiertes Modell in Cloud Storage hochladen, zusammen mit anderen Dateien, die AI Platform mit Daten oder Zuständen versorgen, die während der Vorhersage zu verwenden sind.

Ihr Modellverzeichnis könnte eine SavedModel-, - oder tf.keras-Datei mit dem trainierten scikit-learn- oder XGBoost-Modell enthalten. Zusätzlich können Sie eine Pickle-Datei mit einer Instanz einer benutzerdefinierten Präprozessorklasse hinzufügen, die den serialisierten Zustand vom Training enthält.

Betrachten Sie zum Beispiel den folgenden Präprozessor, der in der Datei preprocess.py definiert ist:

import numpy as np

class ZeroCenterer(object):
    """Stores means of each column of a matrix and uses them for preprocessing.
    """

    def __init__(self):
        """On initialization, is not tied to any distribution."""
        self._means = None

    def preprocess(self, data):
        """Transforms a matrix.

        The first time this is called, it stores the means of each column of
        the input. Then it transforms the input so each column has mean 0. For
        subsequent calls, it subtracts the stored means from each column. This
        lets you 'center' data at prediction time based on the distribution of
        the original training data.

        Args:
            data: A NumPy matrix of numerical data.

        Returns:
            A transformed matrix with the same dimensions as the input.
        """
        if self._means is None:  # during training only
            self._means = np.mean(data, axis=0)
        return data - self._means

Während des Trainings mit einem numerischen Dataset zentriert der Präprozessor die Daten um 0. Dazu wird der Mittelwert jeder Spalte von jedem Wert in der Spalte subtrahiert. Anschließend können Sie die Präprozessorinstanz als Pickle-Datei (preprocessor.pkl) exportieren, um die Mittelwerte jeder Spalte, die aus den Trainingsdaten berechnet wurden, zu speichern.

Während der Vorhersage kann eine benutzerdefinierte Vorhersageroutine den Präprozessor aus dieser Datei laden, um eine identische Transformation für die Vorhersageeingabe durchzuführen.

Im nächsten Abschnitt wird die Implementierung der Predictor-Schnittstelle beschrieben. Dabei erfahren Sie, wie Sie einen zustandsorientierten Präprozessor wie diesen in einer benutzerdefinierten Vorhersageroutine verwenden können.

Ein ausführliches Beispiel für die Verwendung eines zustandsorientierten Präprozessors während des Trainings und der Vorhersage finden Sie in der Anleitung Benutzerdefinierte Vorhersageroutine mit Keras erstellen.

Predictor erstellen

Stellen Sie in AI Platform eine Predictor-Klasse bereit, um vorzugeben, wie Vorhersageanfragen verarbeitet werden sollen. Diese Klasse implementiert die folgende Schnittstelle:

class Predictor(object):
    """Interface for constructing custom predictors."""

    def predict(self, instances, **kwargs):
        """Performs custom prediction.

        Instances are the decoded values from the request. They have already
        been deserialized from JSON.

        Args:
            instances: A list of prediction input instances.
            **kwargs: A dictionary of keyword args provided as additional
                fields on the predict request body.

        Returns:
            A list of outputs containing the prediction results. This list must
            be JSON serializable.
        """
        raise NotImplementedError()

    @classmethod
    def from_path(cls, model_dir):
        """Creates an instance of Predictor using the given path.

        Loading of the predictor should be done in this method.

        Args:
            model_dir: The local directory that contains the exported model
                file along with any additional files uploaded when creating the
                version resource.

        Returns:
            An instance implementing this Predictor class.
        """
        raise NotImplementedError()

AI Platform-Vorhersageknoten verwenden die Klassenmethode from_path, um eine Instanz Ihres Predictors zu laden. Bei dieser Methode sollten die im Modellverzeichnis gespeicherten Artefakte geladen werden, deren Inhalte aus Cloud Storage an einen Speicherort kopiert werden, der durch das Argument model_dir angezeigt wird.

Immer wenn Ihre Bereitstellung eine Anfrage für eine Onlinevorhersage erhält, verwendet die von from_path zurückgegebene Instanz der Predictor-Klasse die zugehörige predict-Methode, um Vorhersagen zu generieren. AI Platform serialisiert den Rückgabewert dieser Methode in JSON und sendet ihn als Antwort auf die Vorhersageanfrage.

Die Methode predict muss keine Eingabe von JSON in Python-Objekte oder Ausgabewerte in JSON konvertieren. Dies findet außerhalb der Methode predict in AI Platform statt.

AI Platform parst das instances-Feld aus dem Text der predict-Anfrage, um der AI Platform Training und Prediction API das instances-Argument bereitzustellen. Alle anderen Felder des Anfragetexts werden geparst und der Methode predict als Einträge im **kwargs-Wörterbuch bereitgestellt. Weitere Informationen dazu, wie Sie eine predict-Anfrage an die AI Platform Training und Prediction API strukturieren, finden Sie unter predict.

Wir ziehen noch einmal das Beispiel aus dem vorherigen Abschnitt heran und gehen davon aus, dass Ihr Modellverzeichnis preprocessor.pkl (die Pickle-Instanz der Klasse ZeroCenterer) und ein trainiertes tf.keras-Modell enthält, das als model.h5 exportiert wurde.

In diesem Fall könnten Sie die folgende Predictor-Klasse in einer Datei mit dem Namen predictor.py implementieren:

import os
import pickle

import numpy as np
from tensorflow import keras

class MyPredictor(object):
    """An example Predictor for an AI Platform custom prediction routine."""

    def __init__(self, model, preprocessor):
        """Stores artifacts for prediction. Only initialized via `from_path`.
        """
        self._model = model
        self._preprocessor = preprocessor

    def predict(self, instances, **kwargs):
        """Performs custom prediction.

        Preprocesses inputs, then performs prediction using the trained Keras
        model.

        Args:
            instances: A list of prediction input instances.
            **kwargs: A dictionary of keyword args provided as additional
                fields on the predict request body.

        Returns:
            A list of outputs containing the prediction results.
        """
        inputs = np.asarray(instances)
        preprocessed_inputs = self._preprocessor.preprocess(inputs)
        outputs = self._model.predict(preprocessed_inputs)
        return outputs.tolist()

    @classmethod
    def from_path(cls, model_dir):
        """Creates an instance of MyPredictor using the given path.

        This loads artifacts that have been copied from your model directory in
        Cloud Storage. MyPredictor uses them during prediction.

        Args:
            model_dir: The local directory that contains the trained Keras
                model and the pickled preprocessor instance. These are copied
                from the Cloud Storage model directory you provide when you
                deploy a version resource.

        Returns:
            An instance of `MyPredictor`.
        """
        model_path = os.path.join(model_dir, 'model.h5')
        model = 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)

Die Methode predict konvertiert die Vorhersageergebnisse mit der Methode tolist in eine Liste, bevor sie sie zurückgibt. NumPy-Arrays können nicht in JSON serialisiert werden. Daher müssen Sie sie in Listen mit Nummern konvertieren (die in JSON serialisiert werden können). Andernfalls sendet AI Platform keine Antwort auf die Vorhersageanfrage.

Paket mit dem Predictor und den zugehörigen Abhängigkeiten erstellen

Sie müssen den Predictor als .tar.gz-Distributionspaket der Quellen verpacken. Da NumPy und TensorFlow im Laufzeitimage von AI Platform enthalten sind, müssen Sie diese Abhängigkeiten nicht in das Tarball-Paket aufnehmen. Achten Sie jedoch darauf, alle Abhängigkeiten des Predictors hinzuzufügen, die nicht in AI Platform vorinstalliert sind.

Für das obige Beispiel müssen Sie preprocess.py in das Distributionspaket der Quellen aufnehmen, obwohl der Predictor die Datei nicht explizit importiert. Andernfalls schlägt preprocessor = pickle.load(f) fehl, weil Python die Klasse der ZeroCenterer-Instanz in der Pickle-Datei nicht erkennt.

Die folgende setup.py-Datei zeigt eine Möglichkeit, diese Skripts zu verpacken:

from setuptools import setup

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

So verpacken Sie den auf dieser Seite beschriebenen benutzerdefinierten Beispielcode und laden ihn anschließend hoch:

  1. Erstellen Sie die in den vorherigen Abschnitten beschriebenen Dateien preprocess.py, predictor.py und setup.py im selben Verzeichnis. Rufen Sie dieses Verzeichnis in Ihrer Shell auf.

  2. Führen Sie python setup.py sdist --formats=gztar aus, um dist/my_custom_code-0.1.tar.gz zu erstellen.

  3. Laden Sie dieses Tarball-Paket an einen Staging-Speicherort in Cloud Storage hoch.

    Dieser muss nicht mit Ihrem Modellverzeichnis identisch sein. Wenn Sie beabsichtigen, mehrere Versionen der benutzerdefinierten Vorhersageroutine zu iterieren und bereitzustellen, sollten Sie Ihre benutzerdefinierten Codepakete in ein festgelegtes Staging-Verzeichnis hochladen. Zur Unterscheidung verschiedener Versionen können Sie das version-Argument in setup.py erhöhen, wenn Sie den Code aktualisieren.

    Der folgende Befehl ist eine Möglichkeit, um das Distributionspaket der Quellen in Cloud Storage hochzuladen:

    gsutil cp dist/my_custom_code-0.1.tar.gz gs://your-bucket/path-to-staging-dir/
    

Benutzerdefinierte Vorhersageroutine bereitstellen

Zuerst wählen Sie eine Region aus, in der Onlinevorhersagen verfügbar sind, und erstellen eine Modellressource mit gcloud:

gcloud ai-platform models create model-name \
  --regions chosen-region

Die gcloud beta-Komponente sollte aktualisiert sein. Erstellen Sie eine Versionsressource und beachten Sie dabei die folgenden gcloud-Flags:

  • --origin: Der Pfad zu Ihrem Modellverzeichnis in Cloud Storage.
  • --package-uris: Eine durch Kommas getrennte Liste von Nutzercode-Tarballs in Cloud Storage, einschließlich des Pakets, das Ihre Predictor-Klasse enthält.
  • --prediction-class: Der vollständig qualifizierte Name der Predictor-Klasse (module_name.class_name).
  • --framework: Geben Sie bei der Bereitstellung einer benutzerdefinierten Vorhersageroutine kein Framework an.
  • --runtime-version: Benutzerdefinierte Vorhersageroutinen sind in den Laufzeitversionen ab 1.4 verfügbar.

Im folgenden Befehl wird gezeigt, wie Sie auf Basis der in den vorherigen Abschnitten beschriebenen Beispieldateien eine Versionsressource erstellen:

gcloud components install beta

gcloud beta ai-platform versions create version-name \
  --model model-name \
  --runtime-version 1.13 \
  --python-version 3.5 \
  --origin gs://your-bucket/path-to-model-dir \
  --package-uris gs://your-bucket/path-to-staging-dir/my_custom_code-0.1.tar.gz \
  --prediction-class predictor.MyPredictor

Ausführliche Informationen zum Erstellen von Modellen und Versionen finden Sie unter Modelle bereitstellen.

Weitere Informationen

Hat Ihnen diese Seite weitergeholfen? Teilen Sie uns Ihr Feedback mit:

Feedback geben zu...

AI Platform für TensorFlow