[PYTHON] [Azure] Créer, déployer et réapprendre un modèle [ML Studio classic]

Je ne connais pas le document officiel.

J'ai créé et déployé des modèles plusieurs fois avec ML Studio classic. Cette fois, j'ai lu le document officiel parce que je voulais le réapprendre, mais je ne l'ai pas bien compris et j'ai fait des allers-retours. J'ai réussi à le faire, alors je vais écrire un article pour ne pas l'oublier. De plus, puisque j'écris pour ceux qui l'utilisent pour la première fois, j'ai omis les détails, alors pardonnez-moi.

Écoulement brutal

1. Faites une expérience d'apprentissage
2. Faites une expérience prédictive
3. Déployer des expériences prédictives
4. Déployer le réapprentissage
5. Réapprendre
6. Refléter le résultat du réapprentissage dans l'expérience de prédiction
7. Testez s'il est reflété

est.

Environnement d'exploitation

Puisque Python sera utilisé en cours de route, écrivez l'environnement et celui importé.

• python3.7
• blobStorage

À propos des données à utiliser

Commençons par les données utilisées cette fois. Je veux savoir si j'ai pu me recycler, j'utilise donc des données trop monotones. Écrivez les données d'entraînement, les données de test et les données de remodelage ci-dessous.

train1.csv

id,target
1,1
2,1
3,1
4,1
5,1

remodel0.csv

id,target
1,0
2,0
3,0
4,0
5,0

Dans le modèle créé, attendez-vous à un modèle qui renvoie toujours 1, quel que soit le nombre que vous saisissez. Ainsi, même si vous mettez les données de test, elles doivent toutes être renvoyées à 1. Attendez-vous à ce que 0 soit renvoyé en apprenant que tout est égal à 0.

Ce n'est pas du tout un bon modèle, donc je ne l'utiliserai que pour les tests.

Créer une expérience d'apprentissage

Créons maintenant un modèle. Après vous être connecté à ML Studio, sélectionnez «EXPÉRIENCES» et cliquez sur «NOUVEAU» en bas de l'écran.

Cliquez ensuite sur «Expérience vierge». Vous êtes maintenant prêt à créer un modèle prédictif.

Faisons en fait un modèle. Recherchez simplement le bloc requis dans cette fenêtre de recherche et ajoutez-le.

Cette fois, il s'agit d'un terme binaire (pour le moment), placez donc la boîte créée en recherchant avec deux classes. Cette fois, j'ai utilisé "Arbre de décision boosté à deux classes". Recherchez d'autres blocs de la même manière et organisez-les comme indiqué dans l'image.

Ensuite, définissez chaque bloc. Cliquez sur le bloc Les éléments de réglage apparaîtront sur le côté droit de la page. Les paramètres peuvent être définis dans le bloc d'algorithme. Cette fois, vous pouvez le laisser tel quel.

Vient ensuite l'importation de données. Ici, spécifiez les données à utiliser pour l'apprentissage. Décrivez votre nom d'utilisateur, votre clé et le chemin d'accès au fichier. Le format de ces données est csv, mais comme le fichier a un en-tête, vérifions "Le fichier a une ligne d'en-tête".

Enfin, le modèle de train. Ici, nous allons spécifier le nom de la colonne de la cible à apprendre. Cette fois, je veux apprendre "target", donc je vais remplir "target" avec "Launch column selector".

Lorsque vous avez terminé, connectons les blocs avec une ligne. Veuillez noter que le modèle de train ne peut pas être connecté par des lignes sur les côtés gauche et droit. Si vous pouvez l'organiser comme ci-dessous, cliquez sur «RUN» en bas de l'écran pour l'exécuter.

Lorsque toutes les cases sont cochées, vous avez terminé. Si vous vous arrêtez au milieu, il doit y avoir quelque chose qui cloche. Le nom du fichier blob peut être différent (histoire d'expérience)

Si tout est coché, le modèle est complet!

Faites une expérience prédictive

Maintenant, utilisons le modèle que nous avons créé plus tôt pour créer quelque chose qui retournera une réponse lorsque nous lançons des données. Cliquez sur «Service Web Predictiv» dans «CONFIGURER LE SERVICE WEB» à côté de «EXÉCUTER».

Ensuite, la boîte se déplacera et ressemblera à celle ci-dessous. Apportez ʻExport Data` de la fenêtre de recherche et écrivez le nom d'utilisateur du blob, etc. Le résultat du test sera affiché dans le chemin écrit ici.

Faisons à nouveau RUN

S'il est vérifié comme précédemment, il est terminé. Cliquez sur «DÉPLOYER LE SERVICE WEB» lorsque vous avez terminé. Après un certain temps, l'écran changera et la clé API etc. sera affichée. Cliquer sur «DEMANDE / RÉPONSE» fera apparaître l'API, que vous pouvez vous attendre à utiliser. Vous pouvez également faire un test simple sur cette page. Cliquons en fait sur le bouton bleu TEST et mettons 3 dans l'id et 1 dans la cible pour expérimenter. Après un certain temps, le résultat sera renvoyé au bas de la page. Le nom de la colonne, le type de colonne et la valeur sont renvoyés dans une liste.

return

Result: {"Results":{"output1":{"type":"table","value":{"ColumnNames":["id","target","Scored Labels","Scored Probabilities"],"ColumnTypes":["Int32","Int32","Int32","Double"],"Values":[["3","1","1","0.142857149243355"]]}}}}

Puisque «Étiquettes notées» est le résultat, 1 est renvoyé dans ce cas, ce qui est comme prévu.

Je déploierai le réapprentissage

Cliquez maintenant sur "Afficher le dernier" pour revenir à l'écran précédent.

Ensuite, allez dans l'onglet Expérience de formation et ajoutez Entrée de service Web et Sortie de service Web à RUN.

Cliquez ensuite sur «Déployer le service Web» dans «CONFIGURER LE SERVICE WEB» ci-dessous.

Le déploiement est maintenant terminé. Vous aurez besoin de la clé API et de l'URL d'API plus tard. La clé API est ce que vous voyez à l'écran. L'URL peut être trouvée en cliquant sur «BATCH EXECTION». L'URL de l'API à utiliser est avant «? Api-version…», c'est-à-dire l'URL se terminant par «job». J'ai trébuché ici.

Réapprendrons!

Réapprendrons. Le réapprentissage lui-même a été fait avec python. C # est également un exemple, mais il peut ne pas fonctionner à moins que vous ne le modifiiez à certains endroits. (C'était le cas avec python3.7.)

Tout d'abord, le programme que vous utilisez réellement.

retrain.py

# python 3.7 Alors changez urllib2
import urllib
import urllib.request
import json
import time
from azure.storage.blob import *

def printHttpError(httpError):
    print(f"The request failed with status code: {str(httpError.code)}")
    print(json.loads(httpError.read()))
    return


def processResults(result):
    results = result["Results"]
    for outputName in results:
        result_blob_location = results[outputName]
        sas_token = result_blob_location["SasBlobToken"]
        base_url = result_blob_location["BaseLocation"]
        relative_url = result_blob_location["RelativeLocation"]
        print(f"The results for {outputName} are available at the following Azure Storage location:")
        print(f"BaseLocation: {base_url}")
        print(f"RelativeLocation: {relative_url}")
        print(f"SasBlobToken: {sas_token}")
    return



def uploadFileToBlob(input_file, input_blob_name, storage_container_name, storage_account_name, storage_account_key):
    #Il semble qu'il n'y ait pas de BlobService, alors changez-le
    blob_service = BlockBlobService(account_name=storage_account_name, account_key=storage_account_key)
    print("Uploading the input to blob storage...")
    blob_service.create_blob_from_path(storage_container_name, input_blob_name, input_file)

def invokeBatchExecutionService():

    storage_account_name = "nom d'utilisateur blob"
    storage_account_key = "touche blob"
    storage_container_name = "nom du conteneur d'objets blob"
    connection_string = f"DefaultEndpointsProtocol=https;AccountName={storage_account_name};AccountKey={storage_account_key}"
    api_key = "Réapprentissage de la clé API"
    url = "URL de l'API"



    uploadFileToBlob("Chemin du fichier à télécharger",
                     "Chemin du fichier après le téléchargement", 
                     storage_container_name, storage_account_name, storage_account_key)

    payload =  {
        "Inputs": {
            "input1": { 
                "ConnectionString": connection_string, 
                "RelativeLocation": f"/{storage_container_name}/Chemin de fichier de l'objet blob à remodeler" 
            },
        },
        "Outputs": {
            "output1": { 
                "ConnectionString": connection_string, 
                "RelativeLocation": f"/{storage_container_name}/Chemin du fichier blob pour les résultats de remodelage.ilearner" 
            },
        },
        "GlobalParameters": {
        }
    }

    body = str.encode(json.dumps(payload))
    headers = { "Content-Type":"application/json", "Authorization":("Bearer " + api_key)}
    print("Submitting the job...")

    req = urllib.request.Request(url + "?api-version=2.0", body, headers)
    response = urllib.request.urlopen(req)

    result = response.read()
    job_id = result[1:-1] 
    # job_J'étais en colère parce que l'identifiant n'était pas str, alors je l'ai converti
    job_id=job_id.decode('utf-8')
    print(f"Job ID: {job_id}")

    print("Starting the job...")    
    headers = {"Authorization":("Bearer " + api_key)}
    req = urllib.request.Request(f"{url}/{job_id}/start?api-version=2.0", headers=headers, method="POST")
    response = urllib.request.urlopen(req)

    url2 = url + "/" + job_id + "?api-version=2.0"

    while True:
        print("Checking the job status...")
        req = urllib.request.Request(url2, headers = { "Authorization":("Bearer " + api_key) })

        response = urllib.request.urlopen(req)

        result = json.loads(response.read())
        status = result["StatusCode"]
        if (status == 0 or status == "NotStarted"):
            print(f"Job: {job_id} not yet started...")
        elif (status == 1 or status == "Running"):
            print(f"Job: {job_id} running...")
        elif (status == 2 or status == "Failed"):
            print(f"Job: {job_id} failed!")
            print("Error details: " + result["Details"])
            break
        elif (status == 3 or status == "Cancelled"):
            print(f"Job: {job_id} cancelled!")
            break
        elif (status == 4 or status == "Finished"):
            print(f"Job: {job_id} finished!")
        
            processResults(result)
            break
        time.sleep(1) # wait one second
    return

invokeBatchExecutionService()

C'est presque le même que l'échantillon, mais quelques modifications ont été apportées. (Je l'ai écrit dans les commentaires.) Veuillez réécrire l'URL, la clé, le CHEMIN, etc. en fonction de chaque environnement. Ensuite, préparez les données et exécutez-les.

console

>python remodel.py

Uploading the input to blob storage...
Submitting the job...
Job ID: ID
Starting the job...
Checking the job status...
JobID not yet started...
Checking the job status...
JobID running...
Checking the job status...
JobID running...
Checking the job status...
JobID running...
Checking the job status...
JobID running...
Checking the job status...
JobID running...
Checking the job status...
JobID running...
Checking the job status...
JobID running...
Checking the job status...
JobID finished!
The results for output1 are available at the following Azure Storage location:
BaseLocation: URL
RelativeLocation: PATH
SasBlobToken: KEY

Vous devriez obtenir le résultat comme ci-dessus. Les trois suivants seront utilisés plus tard.

Réflexion sur le réapprentissage

Eh bien, j'ai exécuté le remodelage, mais cela n'a pas encore été réfléchi. Ouvrez Nouvelle expérience de services Web à partir de cet écran. À ce stade, si «[exp. Prédictive]» n'est pas ajouté après le nom du modèle en haut de la page, cliquez sur «Expérience créée sur… [Exp. Prédictive]» pour la déplacer.

Je pense qu'il est normal d'écraser l'existant, mais la plupart du temps, je vais le garder. Créez donc un nouveau point de terminaison. Appuyez sur le bouton gauche de cet écran ... (J'ai peur que les flèches soient en désordre.) Cliquez sur «+ NOUVEAU» et enregistrez le point de terminaison avec le nom que vous souhaitez utiliser.

Cliquer sur le nom du point de terminaison créé vous amènera à un écran comme celui ci-dessus, alors ouvrez l'onglet «Consommer».

Lorsque vous l'ouvrez, diverses CLÉS et URL apparaissent. Cette fois, nous utiliserons «Clé primaire» et «Patch». ''

Utilisez-les pour exécuter le code suivant.

update.py

import urllib
import urllib.request
import json 

data =  {
            "Resources": [
                {
                    "Name": "Nom du modèle",
                    "Location": 
			            {
                            "BaseLocation": "URL de résultat",
                            "RelativeLocation": "Résultat PATH",
                            "SasBlobToken": "CLÉ de résultat"
			            }
                }
            ]
        }

body = str.encode(json.dumps(data))

url = "Valeur du patch"
api_key = "Valeur de la clé primaire" # Replace this with the API key for the web service
headers = {'Content-Type':'application/json', 'Authorization':('Bearer '+ api_key)}

req = urllib.request.Request(url, body, headers)
req.get_method = lambda: 'PATCH'
response = urllib.request.urlopen(req)
result = response.read()
print(result) 

C'est comme ça. Si vous ouvrez l'aide de l'API sous Patch sur la page précédente, il y a un exemple, donc je pense que vous devriez l'écrire tel quel. Lançons-le.

«b» est renvoyé. Je vois? Mais cela semble aller bien. Enfin déployez ceci. La procédure de déploiement est

Avez-vous réappris?

Testons en ouvrant l'onglet Test en haut de la page. Vous avez peut-être besoin de recharger. id = 3, cible = 1. Il semble que ce soit 0 correctement. C'était bien…

Résumé

J'ai réussi à déployer le modèle recyclé. La précision du modèle que vous utilisez diminue-t-elle? Si vous pensez que oui, réapprenez et continuez à utiliser le modèle!