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. image.png

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.

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. image.png

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.

Recommended Posts

Déployez des fonctions avec Cloud Pak for Data
Fichier journal de sortie avec Job (Notebook) de Cloud Pak for Data
Nettoyer l'espace de déploiement Cloud Pak for Data
Exécuter l'API de Cloud Pak for Data Analysis Project Job avec des variables d'environnement
Testez les modèles et fonctions Python déployés en ligne avec Cloud Pack for Data avec des données d'entrée au format formulaire
Enregistrez les données pandas dans des actifs de données au format Excel avec Cloud Pak for Data (Watson Studio)
Meilleures pratiques pour manipuler les données avec les pandas
[GCP] Procédure de création d'une application Web avec Cloud Functions (Python + Flask)
Éliminez les caractères japonais brouillés dans les graphiques matplotlib avec Cloud Pak for Data Notebook
Exemple d'opération d'objet Cloud Pak for Data en Python (client WML, project_lib)
Bot LINE sans serveur conçu avec IBM Cloud Functions
Analyse de données pour améliorer POG 1 ~ Web scraping avec Python ~
Supprimer les données DynamoDB après 5 minutes avec AWS Step Functions
Analyse de données avec python 2
Lecture de données avec TensorFlow
Visualisation des données avec les pandas
Manipulation des données avec les Pandas!
Nuage de points avec du poivre
Mélangez les données avec les pandas
Augmentation des données avec openCV
Normariser les données avec Scipy
Analyse de données avec Python
CHARGER DES DONNÉES avec PyMysql
Cloud Functions pour redimensionner les images à l'aide d'OpenCV avec le déclencheur Cloud Storage
Technique élégante pour coller des données CSV dans Excel avec Python
Obtenez des données de l'API d'analyse avec le client API Google pour python