[PYTHON] Déployez des fonctions avec Cloud Pak for Data

Avec Cloud Pak for Data (CP4D), il est possible de déployer des fonctions Python. Il est principalement utilisé pour le prétraitement et le post-traitement de l'exécution du modèle, et peut incorporer le traitement des erreurs try & except .. Surtout, il est possible d'appeler (utiliser correctement) plusieurs modèles.

Extrait du manuel produit CP4D v2.5 https://www.ibm.com/support/knowledgecenter/ja/SSQNUZ_2.5.0/wsj/analyze-data/ml-deploy-functions_local.html

Les fonctions Python peuvent être déployées sur Watson Machine Learning de la même manière que le déploiement d'un modèle. Vos outils et applications peuvent utiliser le client Watson Machine Learning Python ou l'API REST pour envoyer des données aux fonctions déployées de la même manière qu'ils envoient des données à un modèle déployé. Vous pouvez déployer des fonctions pour masquer les détails (tels que les informations d'identification), prétraiter les données avant de les transmettre au modèle, effectuer la gestion des erreurs et incorporer des appels dans plusieurs modèles. Toutes ces fonctionnalités sont intégrées aux fonctions déployées, pas à l'application.

Le déploiement de fonctions dans WML a Article précédent, mais c'est la méthode dans Watson Studio du service IBM Cloud, et la méthode est légèrement différente dans CP4D. J'en suis accro, alors je vais vous laisser un exemple de son fonctionnement. C'est le résultat de la création d'une fonction simple, de son déploiement en tant que type en ligne et de la vérification de son fonctionnement.

Image de configuration

Les modèles et les fonctions créés dans Notebook sont stockés dans l'espace de déploiement et chacun est déployé en tant que type En ligne. En définissant la fonction pour appeler le déploiement de modèle, la configuration est la suivante: appelez la fonction déploiement → appelez le déploiement de modèle. À la fin du bloc-notes, notez le déploiement de la fonction pour le voir en action.

Réalisez-le avec Notebook

Connectez-vous à CP4D, ouvrez votre projet d'analyse et lancez un nouveau Notebook. La version CP4D confirmée est la v3.0 LA.

Préparation: création et déploiement du modèle

Créez et déployez d'abord le modèle. Vous utiliserez cet ID de déploiement plus tard pour l'appeler dans une fonction.

(1) Créer un modèle

Créez un modèle de forêt aléatoire à l'aide des données Iris.

#Charger des exemples de données Iris
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]

#Créer un modèle dans une forêt aléatoire
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)

#Vérifiez la précision du modèle
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))

Le `` modèle '' ci-dessus est le modèle entraîné.

(2) Enregistrer et déployer le modèle

Enregistrez le modèle dans l'espace de déploiement et créez un déploiement en ligne. L'opération utilise le client WML. (Article de référence)

python

#Initialisation et authentification du client WML
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)

#Afficher la liste des ID d'espace de déploiement
# client.repository.list_spaces()

#Passer à l'espace de déploiement(ID est la liste ci-dessus_spaces()Découvrez dans)
space_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx"
client.set.default_space(space_id)

#Décrire les méta-informations du modèle
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'}}
        ]
    }
}

#Enregistrer le modèle
model_artifact = client.repository.store_model(model, meta_props=meta_props, training_data=X, training_target=y)
model_id = model_artifact['metadata']['guid']

#Créer un déploiement avec le type en ligne
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) Vérification du fonctionnement du modèle

Assurez-vous que le modèle (déploiement) que vous avez créé fonctionne correctement. Vous pouvez vérifier l'opération à l'aide du client WML.

#Générer des exemples de données et convertir en 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}]}

#Exécution de la notation
prediction = client.deployments.score(dep_id, scoring_payload)
prediction

Si le résultat suivant est renvoyé, la vérification de l'opération est terminée.

output

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

Créer une fonction

Il existe différentes manières de créer une fonction.

• La fonction est imbriquée dans deux couches
• Dans la fonction externe, importez la bibliothèque etc.
• Le nom de la fonction interne est score, et la charge utile des données d'entrée est reçue, traitée et le résultat est renvoyé.
• Les données de sortie renvoyées sont un dictionnaire ou une liste sérialisable JSON

Voici la fonction que j'ai réellement créée. Veuillez consulter Article de référence pour savoir comment effectuer un déploiement à l'aide du client WML.

Créer une fonction

# 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
    #Remarque: wml_les informations d'identification sont définies ici
    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

Les variables utilisées à l'intérieur de la fonction sont définies en dehors de la fonction et transmises à la fonction. url est l'URL CP4D (jusqu'au FQDN, sans la dernière barre oblique), space_id est l'ID de l'espace de déploiement où vous avez déployé le modèle que vous venez de créer, et dep_id est l'ID de déploiement de ce modèle. Le contenu de la fonction consiste simplement à appeler le déploiement en ligne.

Comme je l'ai écrit dans les commentaires, le but est d'initialiser le *** client WML avec une fonction externe *** et de définir *** wml_credentials utilisé là *** dans la fonction externe. Si vous essayez de recevoir les wml_credentials définis en dehors de la fonction en tant qu'argument, cela ne fonctionnera pas. Il semble que ce soit différent de Watson Studio d'IBM Cloud, et j'y étais très accro.

Vérifiez le fonctionnement de la fonction créée. Continuez à exécuter dans le bloc-notes pour voir si la fonction appelle le déploiement avec succès. Les données d'entrée scoring_payload utilisent les exemples de données créés précédemment.

Contrôle de fonctionnement

#Exécuter la fonction(Évaluation de la fonction intérieure_passer la charge utile)
iris_scoring()(scoring_payload)

C'est OK si le résultat suivant est renvoyé.

output

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

Fonction de sauvegarde

Enregistrez la fonction dans l'espace de déploiement.

#Créer des méta-informations
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
}

#Fonction de sauvegarde
function_details = client.repository.store_function(meta_props=meta_props, function=iris_scoring)
function_id = function_details['metadata']['guid']

Dans l'espace de déploiement, vous pouvez voir qu'il est enregistré dans la section intitulée «Fonctionnalités» sous l'actif.

Déployer des fonctions

Déployez la fonction enregistrée dans l'espace de déploiement en tant que type En ligne.

#Créer des méta-informations
meta_props = {
    client.deployments.ConfigurationMetaNames.NAME: "iris_scoring_online",
    client.deployments.ConfigurationMetaNames.ONLINE: {}
}

#Créer un déploiement
function_deployment_details = client.deployments.create(function_id, meta_props=meta_props)
func_dep_id = function_deployment_details['metadata']['guid']

Vous avez maintenant déployé la fonction. Prêt à courir.

Contrôle de fonctionnement

Je vérifierai l'opération immédiatement. Faites un appel d'évaluation à votre déploiement à l'aide du client WML.

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

Si vous obtenez le même résultat qu'avant, vous réussissez.

output

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

Vous disposez désormais d'un moyen simple d'effectuer des appels de modèle à l'aide de fonctions. Je publierai plus tard des modèles d'appels multimodèles plus appliqués.