Benutzerdefinierte Vorhersageroutine mit scikit-learn erstellen

Colab-Logo Diese Anleitung als Notebook in Colab ausführen GitHub-Logo Notebook auf GitHub ansehen

Überblick

In dieser Anleitung wird gezeigt, wie Sie ein trainiertes scikit-learn-Modell in AI Platform bereitstellen und Vorhersagen mithilfe einer benutzerdefinierten Vorhersageroutine durchführen. Auf diese Weise können Sie anpassen, wie AI Platform auf jede Vorhersageanfrage reagiert.

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

Die Anleitung umfasst mehrere Schritte:

  • Lokales Training eines einfachen scikit-learn-Modells (in diesem Notebook)
  • Erstellung und Bereitstellung einer benutzerdefinierten Vorhersageroutine in AI Platform
  • 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.

In dieser Anleitung geht es mehr um die Verwendung des Modells mit AI Platform als um das eigentliche Modelldesign.

Kosten

In dieser Anleitung werden kostenpflichtige Komponenten der Google Cloud Platform (GCP) verwendet:

  • AI Platform
  • Cloud Storage

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

Vorbereitung

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

  • Lokale Entwicklungsumgebung einrichten
  • GCP-Projekt mit Abrechnung und den erforderlichen APIs einrichten
  • 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.

GCP-Projekt einrichten

  1. Melden Sie sich in Ihrem Google-Konto an.

    Wenn Sie noch kein Konto haben, registrieren Sie sich hier für ein neues Konto.

  2. Wählen Sie ein Google Cloud Platform-Projekt aus oder erstellen Sie eines.

    Zur Seite "Ressourcen verwalten"

  3. Prüfen Sie, ob die Abrechnung für Ihr Google Cloud Platform-Projekt aktiviert ist.

    Informationen zum Aktivieren der Abrechnung

  4. Aktivieren Sie die AI Platform ("Cloud Machine Learning Engine") and Compute Engine erforderlichen APIs.

    Aktivieren Sie die APIs.

  5. Installieren und initialisieren Sie das Cloud SDK.

GCP-Konto authentifizieren

Sie müssen einen Dienstkontoschlüssel erstellen und eine bestimmte Umgebungsvariable für den Dateipfad zum Dienstkontoschlüssel festlegen, um die Authentifizierung einzurichten.

  1. Erstellen Sie einen Dienstkontoschlüssel für die Authentifizierung:
    1. Wechseln Sie in der GCP Console zur Seite Dienstkontoschlüssel erstellen.

      Zur Seite "Dienstkontoschlüssel erstellen"
    2. Wählen Sie aus der Drop-down-Liste Dienstkonto die Option Neues Dienstkonto aus.
    3. Geben Sie im Feld Dienstkontoname einen Namen ein.
    4. Wählen Sie aus der Drop-down-Liste Rolle die Optionen Machine Learning Engine > ML Engine-Administrator und Storage > Storage-Objekt-Administrator aus.

      Hinweis: Über das Feld Rolle wird Ihr Dienstkonto für den Zugriff auf Ressourcen autorisiert. Sie können dieses Feld später in der GCP Console ansehen und ändern. Wenn Sie eine Produktionsanwendung entwickeln, müssen Sie möglicherweise detailliertere Berechtigungen als Machine Learning Engine > ML Engine-Administrator und Storage > Storage-Objekt-Administrator angeben. Weitere Informationen finden Sie unter Zugriffssteuerung für AI Platform.
    5. Klicken Sie auf Erstellen. Eine JSON-Datei mit Ihrem Schlüssel wird auf Ihren Computer heruntergeladen.
  2. 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 in allen Cloud Storage-Buckets eindeutig sein:

BUCKET_NAME="your-bucket-name"

Wählen Sie eine Region aus, in der AI Platform-Training und -Vorhersage verfügbar sind, und erstellen Sie eine weitere Umgebungsvariable.

REGION="us-central1"

Erstellen Sie einen Cloud Storage-Bucket in dieser Region 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

scikit-learn-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

Präprozessor schreiben

Wenn Sie die Trainingsdaten so skalieren, dass jede numerische Merkmalsspalte einen Mittelwert von 0 und eine Standardabweichung von 1 aufweist, können Sie das Modell damit 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 Merkmalsspalten 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

Als Nächstes verwenden Sie preprocess.MySimpleScaler, um die Iris-Daten vorzuverarbeiten und anschließend ein einfaches Modell mit scikit-learn zu trainieren.

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

import pickle

from sklearn.datasets import load_iris
from sklearn.ensemble import RandomForestClassifier
from sklearn.externals import joblib

from preprocess import MySimpleScaler

iris = load_iris()
scaler = MySimpleScaler()
X = scaler.preprocess(iris.data)
y = iris.target

model = RandomForestClassifier()
model.fit(X, y)

joblib.dump(model, 'model.joblib')
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 bereitstellen

Benutzerdefinierten Predictor erstellen

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

Schreiben Sie den folgenden Code für predictor.py:

import os
import pickle

import numpy as np
from sklearn.datasets import load_iris
from sklearn.externals import joblib

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)
    if kwargs.get('probabilities'):
      probabilities = self._model.predict_proba(preprocessed_inputs)
      return probabilities.tolist()
    else:
      outputs = self._model.predict(preprocessed_inputs)
      return [self._class_names[class_num] for class_num in outputs]

  @classmethod
  def from_path(cls, model_dir):
    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)

Neben der Verwendung des Präprozessors, den Sie während des Trainings definiert haben, führt dieser Predictor einen Nachbearbeitungsschritt aus, bei dem die Vorhersageausgabe von Klassenindexen (0, 1, 2) in Label-Strings (den Namen der Blumenart) konvertiert wird.

Wenn der Predictor jedoch ein probabilities-Schlüsselwortargument mit dem Wert True empfängt, gibt er stattdessen ein Wahrscheinlichkeitsarray zurück. Darin wird die Wahrscheinlichkeit dafür angegeben, dass jede der drei Klassen das richtige Label ist (gemäß dem Modell). Im letzten Teil dieser Anleitung wird gezeigt, wie Sie während der Vorhersage ein Schlüsselwortargument angeben.

Paket mit benutzerdefiniertem Code erstellen

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

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

from setuptools import setup

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

Anschließend führen Sie 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 Zugriff auf die folgenden Dateien in Cloud Storage:

  • model.joblib (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.joblib 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'

Dann erstellen Sie 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 1.13 \
  --python-version 3.5 \
  --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

Dann senden Sie 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.0, 1.0, 0.0], [1.0, 0.0, 0.0]]

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

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

Feedback geben zu...

AI Platform für scikit-learn und XGBoost