Créez une API REST d'un modèle créé en Python avec Cloud pak for Data 3.0.1 (ci-après CP4D). Vous pouvez créer une API REST en créant un modèle dans un environnement de développement appelé Watson Stuido Local et en le déployant dans un environnement d'exécution appelé Watson Machine Learning. L'API REST permet d'appeler le modèle créé à partir d'une application externe. Par exemple, si vous créez un modèle qui prédit les achats à partir du comportement d'itinérance du Web, vous pouvez placer la publicité en temps réel sur votre application pour smartphone. De plus, si vous créez un modèle qui prédit une panne à partir des données du capteur de l'appareil, vous pouvez notifier en temps réel qu'il existe une possibilité de panne.

Les frameworks pris en charge sont: Prend en charge scikitlearn, Keras, xgboost et plus encore. Framework support details https://www.ibm.com/support/knowledgecenter/en/SSQNUZ_3.0.1/wos/wos-frameworks-wml-cloud.html

■ Environnement de test CP4D: 3.0.1 WML Client: 1.0.103 Scikitlearn: 0.22.1

① Création de projet

Créez d'abord un projet pour créer un cahier pour créer un modèle. Si vous avez déjà un projet, vous pouvez l'utiliser. Dans ce cas, passez à ②.

Sélectionnez un projet dans le menu CP4D

Créez un nouveau projet.

Sélectionnez un projet d'analyse et cliquez sur Suivant.

Créez un projet vide.

Définissez un nom et créez-le.

(2) Coopération spatiale de déploiement de projet

Pour en faire une API REST avec Watson Machine Learning, il est nécessaire de préparer un emplacement appelé Deployment Space dans Watson Machine Learning et de stocker le modèle créé à cet endroit. Ici, définissez l'espace de déploiement correspondant au projet Watson Studio.

Accédez à l'onglet des paramètres du projet.

Cliquez sur le bouton Associer un espace de déploiement.

Si vous disposez d'un espace de déploiement existant, vous pouvez le sélectionner, mais pour l'instant, créez-en un nouveau et cliquez sur Associer.

Confirmez que l'association a été effectuée comme indiqué ci-dessous.

Remarque: Pour être précis, la création d'un espace de déploiement est obligatoire, mais l'association d'un projet à un espace de déploiement n'est pas obligatoire. Vous pouvez également enregistrer le modèle dans un espace de déploiement indépendant. Cependant, faire une association permet de trouver plus facilement l'uid de l'espace de déploiement, ce qui est pratique.

③ Création de modèles Scikit Learn

Créez un modèle prédictif pour Scikit Learn dans le bloc-notes de Watson Studio.

Accédez à l'onglet Actifs et cliquez sur le bouton Ajouter au projet.

Cliquez sur Notebook.

Sélectionnez "De l'URL" et spécifiez un nom. Spécifiez l'URL suivante pour l'URL du bloc-notes. https://raw.githubusercontent.com/hkwd/200701WML/master/cp4d301/iris_WMLCP4D301pub.ipynb Une fois les paramètres définis, cliquez sur Créer un bloc-notes.

Exécutez la cellule de modélisation. Je crée un modèle en lisant les données d'iris contenues dans la bibliothèque Scikitlearn. Le modèle est stocké dans une variable appelée model.

En utilisant "sepallength" (longueur du gaku), "sepalwidth" (largeur du gaku), "petallength" (longueur du pétale), "petalwidth" (largeur du pétale), l'espèce d'iris Setosa, Virginie, C'est un modèle qui discrimine et prédit l'un des Versicolor. la prédiction est le résultat de la discrimination, 0 est Setosa, 1 est Virginia et 2 est Versicolor. Les colonnes Setosa_prob, Virginia_prob et Versicolor_prob représentent la probabilité de chaque type d'iris. Dans le cas du 0ème iris dans l'exemple ci-dessous, il y a 80% de chances de prédire qu'il s'agit d'une espèce Virginica.

④ Connexion client WML

Chargez la bibliothèque cliente Watson Machine Learning à partir de votre notebook et connectez-vous au service Watson Machine Learning pour stocker et déployer votre modèle dans votre projet ou espace de déploiement.

La bibliothèque cliente de Watson Machine Learning (watson-machine-learning-client-V4) est chargée dans l'environnement Python de CP4D, mais la version est 1.0.95, qui est un peu ancienne et ne prend pas en charge CP4D 3.0.1. Commencez par mettre à jour avec pip. J'ai utilisé la version 1.0.103 ici.

!pip install --upgrade  watson-machine-learning-client-V4

Ci-dessous, vous vous connecterez au service Watson Machine Learning avec le client WML. Vous pouvez utiliser Watson Machine Learning avec un objet appelé client.

import sys,os,os.path

token = os.environ['USER_ACCESS_TOKEN']
from watson_machine_learning_client import WatsonMachineLearningAPIClient

wml_credentials = {
   "token": token,
   "instance_id" : "wml_local",
   "url": os.environ['RUNTIME_ENV_APSX_URL'],
   "version": "3.0.1"
}

client = WatsonMachineLearningAPIClient(wml_credentials)

⑤ Enregistrez le modèle dans le projet

À l'aide du client, qui est le client WML instancié précédemment, enregistrez le modèle, qui est le modèle de prédiction de l'iris créé dans ①, dans le projet.

Tout d'abord, connectez-vous au projet avec le client WML avec set.default_project.

project_id = os.environ['PROJECT_ID']
client.set.default_project(project_id)

Ensuite, nous créerons des métadonnées de modèle. Vous pouvez découvrir quelles sont les métadonnées dans client.repository.ModelMetaNames.show ().

Voici quelques-uns des principaux. Ce qui suit définit le schéma des variables explicatives. Avec ce paramètre, vous pouvez utiliser l'interface utilisateur pour l'exécution des tests avec l'interface graphique Watson Machine Learning. Le nom de la colonne et le type de données sont obtenus à partir de x_train, qui est un DataFrame de pandas contenant des variables explicatives.

x_fields=[{'name': i, 'type': str(v)} for i,v in x_train.dtypes.items()]

Ce qui suit définit le schéma de sortie. C'est fondamentalement une phrase fixe, mais le type de données est obtenu à partir de y_train, qui est un DataFrame de pandas contenant la variable objective.

y_fields=[{'name': 'prediction', 'type': str(y_train.dtypes[0]),'metadata': {'modeling_role': 'prediction'}}]
y_fields.append({'name': 'probability', 'type': 'list','metadata': {'modeling_role': 'probability'}})

En outre, définissez des métadonnées telles que NAME et TYPE et organisez-les dans un dictionnaire. De plus, lorsque scikit learn était égal à 0.20, RUNTIME_UID était spécifié, mais lorsque scikit learn, qui a créé ce modèle, était égal à 0.22, il était nécessaire de spécifier SOFTWARE_SPEC_UID au lieu de RUNTIME_UID.

model_name = 'iris_skl_model'
#scikit learn vaut 0.RUNTIME pour 22_LOGICIEL, pas UID_SPEC_L'UID doit être spécifié
sw_spec_uid = client.software_specifications.get_uid_by_name("scikit-learn_0.22-py3.6")

#Définir les métadonnées du modèle
pro_model_meta_props = {
    client.repository.ModelMetaNames.NAME: model_name,
    client.repository.ModelMetaNames.SOFTWARE_SPEC_UID: sw_spec_uid,
    client.repository.ModelMetaNames.TYPE: "scikit-learn_0.22",
    client.repository.ModelMetaNames.INPUT_DATA_SCHEMA:[{
        "id":"input1",
        "fields":x_fields
    }],
    client.repository.ModelMetaNames.OUTPUT_DATA_SCHEMA: {
        "id":"output",
        "fields": y_fields}
}

Enregistrez le modèle en tant qu'actif de projet avec la méthode client WML repository.store_model. Enregistrez l'ID tel qu'il est inclus dans la valeur de retour.

#Enregistrer le modèle dans le projet
stored_pro_model_details = client.repository.store_model(model,
                                               meta_props=pro_model_meta_props,
                                               training_data=x_train,
                                               training_target=y_train)

pro_model_uid=stored_pro_model_details['metadata']['guid']

Si vous examinez les actifs du projet à ce stade, vous pouvez voir qu'ils sont enregistrés en tant que modèle.

Vous pouvez faire de même avec la méthode repository.list_models () du client WML.

Remarque: Pour être précis, l'enregistrement du modèle dans le projet n'est pas essentiel pour en faire une API REST, mais en enregistrant également le modèle enregistré dans l'espace de déploiement dans le projet, sur Watson Studio Mais vous pourrez le tester et l'enregistrer dans l'espace de déploiement (fonction de promotion) avec l'interface graphique.

⑥ Enregistrez le modèle dans l'espace de déploiement

Enfin, nous enregistrerons le modèle dans l'espace de déploiement dans Watson Machine Learning.

Utilisez l'API REST appelée API Watson Data pour obtenir l'ID de l'espace de déploiement associé dans (2) et connectez-vous avec la méthode set.default_space.

#Obtenez l'ID de l'espace de déploiement associé
import json, requests
# get project info
r = requests.get(os.environ['RUNTIME_ENV_APSX_URL'] + "/v2/projects/" + os.environ['PROJECT_ID'], headers = {"Authorization": "Bearer " + os.environ['USER_ACCESS_TOKEN']})
wmlProjectCompute = [c for c in r.json()["entity"]["compute"] if c["type"] == "machine_learning"][0]
space_uid = wmlProjectCompute["properties"]["space_guid"]
print(space_uid)

#Connectez-vous à l'espace de déploiement
client.set.default_space(space_uid)

--Référence

Watson Data API (Beta) - IBM Cloud API Docs https://cloud.ibm.com/apidocs/watson-data-api#get-project

En plus des métadonnées du modèle créées dans (5) ci-dessus, définissez l'uid de l'espace de déploiement obtenu ci-dessus.

#Ajouter l'ID d'espace de déploiement aux métadonnées du modèle
ds_model_meta_props=pro_model_meta_props
ds_model_meta_props[client.repository.ModelMetaNames.SPACE_UID]= space_uid

Enregistrez le modèle dans repository.store_model comme dans ⑤ ci-dessus, et récupérez l'uid du modèle à partir de la valeur de retour.

#Enregistrer le modèle dans l'espace de déploiement
stored_ds_model_details = client.repository.store_model(model,
                                               meta_props=ds_model_meta_props,
                                               training_data=x_train,
                                               training_target=y_train)
ds_model_uid = stored_ds_model_details["metadata"]["guid"]

Le modèle est désormais également enregistré dans l'espace de déploiement. Essayez d'ouvrir un déploiement d'analyse.

Cliquez sur l'espace de déploiement associé au projet dans ②.

Vous pouvez voir que le modèle est enregistré comme indiqué ci-dessous.

⑦ Déployez le modèle en tant que scoring en ligne

Déployez le modèle enregistré dans l'espace de déploiement pour en faire une API REST.

Il est possible de déployer avec l'interface graphique de déploiement d'analyse, mais ici nous allons essayer d'utiliser l'API client WML.

Tout d'abord, définissez les métadonnées de déploiement. Vous pouvez vérifier le type de métadonnées dont vous disposez avec client.deployments.ConfigurationMetaNames.get (). Ici, spécifiez NOM et EN LIGNE. Si ONLINE est spécifié, la variable objectif du résultat de la prédiction peut être renvoyée en temps réel en saisissant la variable explicative dans l'API REST. Il existe d'autres méthodes de déploiement telles que BATCH.

deployment_on_name = 'iris_skl_model_rt'
#Définition des métadonnées de scoring en ligne
deploy_on_meta_props = {
    client.deployments.ConfigurationMetaNames.NAME: deployment_on_name,
    client.deployments.ConfigurationMetaNames.ONLINE: {}
}

--Référence

https://www.ibm.com/support/knowledgecenter/en/SSQNUZ_3.0.1/wsj/wmls/deploy-models.html

Déployez le modèle avec la méthode deployments.create. Pour artifact_uid, spécifiez l'uid du modèle enregistré dans l'espace de déploiement. Notez qu'il ne s'agit pas de l'uid du modèle enregistré dans le projet.

#Déployer le modèle
deployment_on_details = client.deployments.create(
    artifact_uid=ds_model_uid, 
    meta_props=deploy_on_meta_props)

Cela prendra un certain temps et le modèle sera déployé avec le message suivant.

Obtenez l'uid du déploiement tel qu'il est inclus dans la valeur de retour.

deployment_on_uid = client.deployments.get_uid(deployment_on_details)

Accédez au déploiement analytique et assurez-vous qu'il est déployé.

Cliquez sur le modèle que vous venez d'enregistrer.

Vous pouvez voir qu'il est déployé en tant que type en ligne comme indiqué ci-dessous. Cliquez sur Déploiement.

Vous verrez l'URL du point de terminaison de l'API REST pour ce déploiement et un exemple de code dans différentes langues.

⑧ Notation

L'usage original est de marquer à partir d'une application externe comme indiqué dans la figure ci-dessous en utilisant l'exemple de code mentionné précédemment, mais ici, à titre de test, évaluons à partir de Notebook en utilisant le client WML.

Tout d'abord, créez une variable explicative qui est des données d'entrée provenant de pandas de données de test. Ici, x_test [0: 2] est utilisé pour extraire les deux premières lignes.

payload = {
    client.deployments.ScoringMetaNames.INPUT_DATA:[{
        "fields": x_test.columns.tolist(),
        "values": x_test[0:2].values.tolist()
    }]
}

J'ai fait les données suivantes comme données d'entrée. Noms des variables explicatives et leurs valeurs [4.5, 2.3, petal length], "sepallength", "sepalwidth", "petallength", "petalwidth" Deux cas, 1,3, 0,3] et [6,0, 3,4, 4,5, 1,6] sont donnés.

La notation est effectuée par la méthode de deployments.score. Donne l'uid et les données d'entrée pour le déploiement.

predict=client.deployments.score(deployment_on_uid, payload )
}

Les résultats suivants sont renvoyés.

Le premier résultat est [1, [0.0, 0.99, 0.01]]. Premièrement, 1 est renvoyé comme prédiction, il est donc prédit qu'il s'agit de la Virginie. La liste suivante [0.0, 0.99, 0.01] est Setosa_prob, Virginia_prob, Versicolor_prob. Virginica prédit une chance de 99%. De même, le deuxième cas devrait être Sentosa avec une probabilité de 100%.

Résumé

Le modèle créé par Scikit Learn de Python est devenu une API REST et peut être utilisé par les applications.

Voici le cahier complété. https://github.com/hkwd/200701WML/blob/master/cp4d301/iris_WMLCP4D301pub.ipynb

référence

Exemple d'opération d'objet Cloud Pak for Data en Python (client WML, project_lib) --Qiita https://qiita.com/ttsuzuku/items/eac3e4bedc020da93bc1

API REST du modèle réalisé avec Python avec Watson Machine Learning (édition CP4D)