[PYTHON] Stellen Sie Funktionen mit Cloud Pak for Data bereit

Es ist möglich, Python-Funktionen mit Cloud Pak for Data (CP4D) bereitzustellen. Es wird hauptsächlich für die Vor- und Nachbearbeitung der Modellausführung verwendet und kann die Try & Except-Fehlerverarbeitung beinhalten. Vor allem ist es möglich, mehrere Modelle aufzurufen (ordnungsgemäß zu verwenden).

Auszug aus dem CP4D v2.5 Produkthandbuch https://www.ibm.com/support/knowledgecenter/ja/SSQNUZ_2.5.0/wsj/analyze-data/ml-deploy-functions_local.html

Python-Funktionen können auf dieselbe Weise wie das Bereitstellen eines Modells für Watson Machine Learning bereitgestellt werden. Ihre Tools und Anwendungen können den Watson Machine Learning Python-Client oder die REST-API verwenden, um Daten an bereitgestellte Funktionen zu senden, genauso wie Sie Daten an ein bereitgestelltes Modell senden. Sie können Funktionen bereitstellen, um Details (z. B. Anmeldeinformationen) auszublenden, Daten vor der Übergabe an das Modell vorzuverarbeiten, Fehler zu behandeln und Aufrufe in mehrere Modelle zu integrieren. Alle diese Funktionen sind in die bereitgestellten Funktionen integriert, nicht in die Anwendung.

Das Bereitstellen von Funktionen in WML hat Vorheriger Artikel, ist jedoch die Methode in Watson Studio des IBM Cloud-Dienstes, und die Methode unterscheidet sich geringfügig in CP4D. Ich bin süchtig danach, also werde ich ein Beispiel hinterlassen, wie es funktioniert hat. Dies ist das Ergebnis der Erstellung einer einfachen Funktion, der Bereitstellung als Online-Typ und der Überprüfung ihrer Funktion.

Konfigurationsbild

In Notebook erstellte Modelle und Funktionen werden im Bereitstellungsbereich gespeichert und jeweils als Online-Typ bereitgestellt. Wenn Sie die Funktion zum Aufrufen der Modellbereitstellung festlegen, lautet die Konfiguration wie folgt: Rufen Sie die Funktionsbereitstellung auf → Rufen Sie die Modellbereitstellung auf. Bewerten Sie am Ende des Notizbuchs die Funktionsbereitstellung, um sie in Aktion zu sehen.

Eigentlich mit Notebook machen

Melden Sie sich bei CP4D an, öffnen Sie Ihr Analyseprojekt und starten Sie ein neues Notizbuch. Die bestätigte CP4D-Version ist v3.0 LA.

Vorbereitung: Modellerstellung und -bereitstellung

Erstellen und implementieren Sie zuerst das Modell. Sie werden diese Bereitstellungs-ID später verwenden, um sie in einer Funktion aufzurufen.

(1) Erstellen Sie ein Modell

Erstellen Sie mithilfe von Irisdaten ein Modell einer zufälligen Gesamtstruktur.

#Laden Sie die Iris-Beispieldaten
import pandas as pd
from sklearn.datasets import load_iris
iris = load_iris()
df = pd.DataFrame(iris.data, columns=iris.feature_names)
df['iris_type'] = iris.target_names[iris.target]

#Erstellen Sie ein Modell in einer zufälligen Gesamtstruktur
from sklearn.model_selection import train_test_split
from sklearn.ensemble import RandomForestClassifier

X = df.drop('iris_type', axis=1)
y = df['iris_type']
X_train, X_test, y_train, y_test = train_test_split(X,y,random_state=0)

clf = RandomForestClassifier(max_depth=2, random_state=0, n_estimators=10)
model = clf.fit(X_train, y_train)

#Überprüfen Sie die Genauigkeit des Modells
from sklearn.metrics import confusion_matrix, accuracy_score
y_test_predicted = model.predict(X_test)    
print("confusion_matrix:")
print(confusion_matrix(y_test,y_test_predicted))
print("accuracy:", accuracy_score(y_test,y_test_predicted))

Das obige Modell ist das trainierte Modell.

(2) Speichern Sie das Modell und stellen Sie es bereit

Speichern Sie das Modell im Bereitstellungsbereich und erstellen Sie eine Online-Bereitstellung. Die Operation verwendet den WML-Client. (Referenzartikel)

python

#Initialisierung und Authentifizierung des WML-Clients
from watson_machine_learning_client import WatsonMachineLearningAPIClient
import os
token = os.environ['USER_ACCESS_TOKEN']
url = "https://cp4d.host.name.com"
wml_credentials = {
    "token" : token,
    "instance_id" : "openshift",
    "url": url,
    "version": "3.0.0"
}
client = WatsonMachineLearningAPIClient(wml_credentials)

#Zeigen Sie die Liste der Bereitstellungsbereichs-IDs an
# client.repository.list_spaces()

#Wechseln Sie zum Bereitstellungsbereich(ID ist die obige Liste_spaces()Finden Sie es heraus in)
space_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx"
client.set.default_space(space_id)

#Beschreiben von Modell-Metainformationen
model_name = "sample_iris_model"
meta_props={
    client.repository.ModelMetaNames.NAME: model_name,
    client.repository.ModelMetaNames.RUNTIME_UID: "scikit-learn_0.22-py3.6",
    client.repository.ModelMetaNames.TYPE: "scikit-learn_0.22",
    client.repository.ModelMetaNames.INPUT_DATA_SCHEMA:{
        "id":"iris model",
        "fields":[
            {'name': 'sepal length (cm)', 'type': 'double'},
            {'name': 'sepal width (cm)', 'type': 'double'},
            {'name': 'petal length (cm)', 'type': 'double'},
            {'name': 'petal width (cm)', 'type': 'double'}
        ]
    },
    client.repository.ModelMetaNames.OUTPUT_DATA_SCHEMA: {
        "id":"iris model",
        "fields": [
            {'name': 'iris_type', 'type': 'string','metadata': {'modeling_role': 'prediction'}}
        ]
    }
}

#Modell speichern
model_artifact = client.repository.store_model(model, meta_props=meta_props, training_data=X, training_target=y)
model_id = model_artifact['metadata']['guid']

#Erstellen Sie eine Bereitstellung mit dem Typ Online
dep_name = "sample_iris_online"
meta_props = {
    client.deployments.ConfigurationMetaNames.NAME: dep_name,
    client.deployments.ConfigurationMetaNames.ONLINE: {}
}
deployment_details = client.deployments.create(model_id, meta_props=meta_props)
dep_id = deployment_details['metadata']['guid']

(3) Überprüfen der Funktion des Modells

Stellen Sie sicher, dass das von Ihnen erstellte Modell (Bereitstellung) ordnungsgemäß funktioniert. Sie können den Vorgang mit dem WML-Client überprüfen.

#Generieren Sie Beispieldaten und konvertieren Sie sie in JSON
scoring_x = pd.DataFrame(
    data = [[5.1,3.5,1.4,0.2]],
    columns=['sepal length (cm)','sepal width (cm)','petal length (cm)','petal width (cm)']
)
values = scoring_x.values.tolist()
fields = scoring_x.columns.values.tolist()
scoring_payload = {client.deployments.ScoringMetaNames.INPUT_DATA: [{'fields': fields, 'values': values}]}

#Scoring-Ausführung
prediction = client.deployments.score(dep_id, scoring_payload)
prediction

Wenn das folgende Ergebnis zurückgegeben wird, ist die Funktionsprüfung abgeschlossen.

output

{'predictions': [{'fields': ['prediction', 'probability'],
   'values': [[0, [0.8131726303900102, 0.18682736960998966]]]}]}

Eine Funktion erstellen

Es gibt verschiedene Möglichkeiten, eine Funktion zu erstellen.

• Die Funktion ist in zwei Ebenen verschachtelt
• Importieren Sie in der äußeren Funktion die Bibliothek usw.
• Der Name der inneren Funktion lautet score, und die Nutzdaten der Eingabedaten werden empfangen, verarbeitet und das Ergebnis zurückgegeben.
• Die zurückzugebenden Ausgabedaten sind ein serialisierbares JSON-Wörterbuch oder eine Liste.

Hier ist die Funktion, die ich tatsächlich erstellt habe. Informationen zur Durchführung der Bereitstellung mit dem WML-Client finden Sie unter Referenzartikel.

Eine Funktion erstellen

# variables for function
func_variables = {
    "url" : url,
    "space_id" : space_id,
    "dep_id" : dep_id,
    "token"  : token
}

# Function for scoring model only
def iris_scoring(func_vars=func_variables):
    from watson_machine_learning_client import WatsonMachineLearningAPIClient
    #Hinweis: wml_Anmeldeinformationen werden hier definiert
    wml_credentials = {
                   "token" : func_vars['token'],
                   "instance_id": "openshift",
                   "url": func_vars['url'],
                   "version" : "3.0.0"
                  }
    client = WatsonMachineLearningAPIClient(wml_credentials)

    def score(scoring_payload):
        try:
            client.set.default_space(func_vars['space_id'])
            prediction = client.deployments.score(func_vars['dep_id'], scoring_payload)
            return prediction

        except Exception as e:
            return {'error': repr(e)}

    return score

Innerhalb der Funktion verwendete Variablen werden außerhalb der Funktion definiert und an die Funktion übergeben. url ist die CP4D-URL (bis zum FQDN ohne den letzten Schrägstrich), space_id ist die ID des Bereitstellungsbereichs, in dem Sie das gerade erstellte Modell bereitgestellt haben, und dep_id ist die Bereitstellungs-ID dieses Modells. Der Inhalt der Funktion besteht einfach darin, die Online-Bereitstellung aufzurufen.

Wie ich im Kommentar geschrieben habe, geht es darum, den *** WML-Client mit einer äußeren Funktion zu initialisieren und die dort verwendeten *** wml_credentials in der äußeren Funktion zu definieren. Wenn Sie versuchen, außerhalb der Funktion definierte wml_credentials als Argument zu erhalten, funktioniert dies nicht. Es scheint, dass dies anders ist als Watson Studio von IBM Cloud, und ich war sehr süchtig danach.

Überprüfen Sie die Funktion der erstellten Funktion. Führen Sie in Ihrem Notizbuch die folgenden Schritte aus, um festzustellen, ob die Funktion die Bereitstellung erfolgreich aufruft. Eingabedaten Scoring_Payload verwendet die zuvor erstellten Beispieldaten.

Funktionsprüfung

#Funktion ausführen(Wertung zur inneren Funktion_Nutzlast weitergeben)
iris_scoring()(scoring_payload)

Es ist in Ordnung, wenn das folgende Ergebnis zurückgegeben wird.

output

{'predictions': [{'fields': ['prediction', 'probability'],
   'values': [['setosa', [0.9939393939393939, 0.006060606060606061, 0.0]]]}]}

Funktion speichern

Speichern Sie die Funktion im Bereitstellungsbereich.

#Erstellen Sie Metainformationen
meta_props = {
    client.repository.FunctionMetaNames.NAME: 'iris_scoring_func',
    client.repository.FunctionMetaNames.RUNTIME_UID: "ai-function_0.1-py3.6",
    client.repository.FunctionMetaNames.SPACE_UID: space_id
}

#Funktion speichern
function_details = client.repository.store_function(meta_props=meta_props, function=iris_scoring)
function_id = function_details['metadata']['guid']

Im Bereitstellungsbereich können Sie sehen, dass er im Abschnitt "Funktionen" unter dem Asset registriert ist.

Funktionen bereitstellen

Stellen Sie die im Bereitstellungsbereich gespeicherte Funktion als Online-Typ bereit.

#Erstellen Sie Metainformationen
meta_props = {
    client.deployments.ConfigurationMetaNames.NAME: "iris_scoring_online",
    client.deployments.ConfigurationMetaNames.ONLINE: {}
}

#Erstellen Sie eine Bereitstellung
function_deployment_details = client.deployments.create(function_id, meta_props=meta_props)
func_dep_id = function_deployment_details['metadata']['guid']

Sie haben die Funktion jetzt bereitgestellt. Bereit zu rennen.

Funktionsprüfung

Ich werde den Betrieb sofort überprüfen. Rufen Sie Ihre Bereitstellung mithilfe des WML-Clients auf.

prediction = client.deployments.score(func_dep_id, scoring_payload)
prediction

Wenn Sie das gleiche Ergebnis wie zuvor erhalten, sind Sie erfolgreich.

output

{'predictions': [{'fields': ['prediction', 'probability'],
   'values': [['setosa', [0.9939393939393939, 0.006060606060606061, 0.0]]]}]}

Sie haben jetzt eine einfache Möglichkeit, Modellaufrufe mithilfe von Funktionen durchzuführen. Ich werde später mehr angewandte Multi-Model-Aufrufmuster veröffentlichen.