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.

Die Gesamtgröße der Modellartefakte, die Sie für AI Platform Prediction bereitstellen, darf maximal 250 MB betragen. Sie können ein höheres Kontingent anfordern, wenn Sie größere Modelle bereitstellen möchten.

Sie können Ihr trainiertes Modell für maschinelles Lernen als TensorFlow-SavedModel, model.joblib-Datei, model.pkl-Datei oder model.bst-Datei in das Modellverzeichnis hochladen. Ebenfalls können Sie das Modell als HDF5-Datei mit einem trainierten tf.keras-Modell oder in einem anderen serialisierten Format bereitstellen.

Zusätzlich können Sie eine Pickle-Datei mit der 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 unter Benutzerdefinierte Vorhersageroutine mit Keras erstellen oder Benutzerdefinierte Vorhersageroutine mit scikit-learn 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()

Vorhersageknoten von AI Platform 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 Feld instances aus dem Text der predict-Anfrage, um der AI Platform Training and Prediction API das Argument instances bereitzustellen. Alle anderen Felder des Anfragetexts werden geparst und der Methode predict als Einträge im Wörterbuch **kwargs bereitgestellt. Weitere Informationen finden Sie unter predict-Anfrage für die AI Platform Training and Prediction API strukturieren.

Wir ziehen noch einmal das Beispiel aus dem vorherigen Abschnitt heran und nehmen Folgendes an: Ihr Modellverzeichnis preprocessor.pkl (die Pickle-Instanz der Klasse ZeroCenterer) enthält ein trainiertes tf.keras-Modell, das als model.h5 exportiert wurde, oder ein trainiertes scikit-learn-Modell, das als model.joblib exportiert wurde.

Abhängig davon, welches ML-Framework Sie verwenden, implementieren Sie eine der folgenden Predictor-Klassen in einer Datei namens predictor.py:

TensorFlow

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)

scikit-learn

import os
import pickle

import numpy as np
from sklearn.externals import joblib

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
        scikit-learn 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
                scikit-learn 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.joblib')
        model = joblib.load(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, TensorFlow und scikit-learn im Laufzeit-Image der AI Plattform enthalten sind, müssen diese Abhängigkeiten nicht im Tarball enthalten sein. 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 Quelldistributionspaket aufnehmen, auch wenn 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/
    

Sie können Code für Ihre benutzerdefinierte Vorhersageroutine in einem oder mehreren Paketen bereitstellen. Die gesamte Dateigröße dieser Pakete darf maximal 250 MB betragen. Sie können ein höheres Kontingent anfordern, wenn Sie umfangreicheren benutzerdefinierten Code bereitstellen möchten.

Benutzerdefinierte Vorhersageroutine bereitstellen

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

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.14 \
  --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

Weitere ausführliche Informationen zum Erstellen von Modellen und Versionen oder zum Erstellen von Modellen und Versionen mit der Google Cloud Platform Console anstelle des gcloud-Tools finden Sie im Leitfaden zum Bereitstellen von Modellen.

Ein Dienstkonto angeben

Beim Erstellen einer Versionsressource können Sie optional ein Dienstkonto angeben, das Ihre benutzerdefinierte Vorhersageroutine während der Vorhersage verwenden soll. Auf diese Weise können Sie die Berechtigungen für den Zugriff auf andere Google Cloud Platform-Ressourcen anpassen. Weitere Informationen finden Sie unter Ein Dienstkonto für Ihre benutzerdefinierte Vorhersageroutine angeben.

Weitere Informationen

  • Eine Anleitung zu benutzerdefinierten Vorhersageroutinen mit Keras oder mit scikit-learn durcharbeiten, um ein umfangreicheres Beispiel für das Trainieren und Bereitstellen eines Modells mit einer benutzerdefinierten Vorhersageroutine zu sehen
  • Leitfaden zum Exportieren von Modellen lesen, um Informationen zum Exportieren von Artefakten für die Vorhersage ohne eine benutzerdefinierte Vorhersageroutine zu erhalten
  • Leitfaden zum Bereitstellen von Modellen lesen, um mehr über das Bereitstellen von model- und version-Ressourcen für Vorhersagen in der AI Platform zu erfahren
Hat Ihnen diese Seite weitergeholfen? Teilen Sie uns Ihr Feedback mit:

Feedback geben zu...