Oktatóanyag: lemezkép besorolási modell üzembe helyezése Azure Container InstancesTutorial: Deploy an image classification model in Azure Container Instances

Ez az oktatóanyag egy kétrészes oktatóanyag-sorozat második része.This tutorial is part two of a two-part tutorial series. Az előző oktatóanyagban gépi tanulási modelleket tanított be, majd regisztrált egy modellt a felhőbeli munkaterületen.In the previous tutorial, you trained machine learning models and then registered a model in your workspace on the cloud. Most már készen áll a modell webszolgáltatásként való üzembe helyezésére.Now you're ready to deploy the model as a web service. A webszolgáltatás egy rendszerkép, ebben az esetben egy Docker-rendszerkép.A web service is an image, in this case a Docker image. Magába foglalja a pontozási logikát és a modellt.It encapsulates the scoring logic and the model itself.

Az oktatóanyag ezen részében a Azure Machine Learning a következő feladatokhoz használhatja:In this part of the tutorial, you use Azure Machine Learning for the following tasks:

  • A tesztelési környezet beállítása.Set up your testing environment.
  • A modell lekérése a munkaterületről.Retrieve the model from your workspace.
  • A modell üzembe helyezése Container Instances.Deploy the model to Container Instances.
  • Tesztelje az üzembe helyezett modellt.Test the deployed model.

A Container Instances nagyszerű megoldás a munkafolyamatok tesztelésére és megismerésére.Container Instances is a great solution for testing and understanding the workflow. Skálázható termelési környezetek esetén fontolja meg az Azure Kubernetes Service használatát.For scalable production deployments, consider using Azure Kubernetes Service. További információ: a telepítés és a hol.For more information, see how to deploy and where.

Megjegyzés

A cikkben ismertetett kód Azure Machine Learning SDK 1.0.83-verzióval lett tesztelve.Code in this article was tested with Azure Machine Learning SDK version 1.0.83.

ElőfeltételekPrerequisites

A jegyzetfüzet futtatásához először végezze el a modell betanítását az oktatóanyagban (1. rész): képbesorolási modell betanítása.To run the notebook, first complete the model training in Tutorial (part 1): Train an image classification model. Ezután nyissa meg az IMG-besorolás-part2-Deploy. ipynb notebookot a klónozott oktatóanyagok/lemezkép-besorolás-mnist-adat mappában.Then open the img-classification-part2-deploy.ipynb notebook in your cloned tutorials/image-classification-mnist-data folder.

Ez az oktatóanyag a githubon is elérhető, ha saját helyi környezetébenszeretné használni.This tutorial is also available on GitHub if you wish to use it on your own local environment. Győződjön meg arról, hogy telepítve van matplotlib és scikit-learn a környezetében.Make sure you have installed matplotlib and scikit-learn in your environment.

Fontos

A cikk többi része ugyanazt a tartalmat tartalmazza, mint amit a jegyzetfüzetben lát.The rest of this article contains the same content as you see in the notebook.

Váltson a Jupyter jegyzetfüzetre, ha a kód futtatása közben szeretné olvasni.Switch to the Jupyter notebook now if you want to read along as you run the code. Ha egyetlen kód cellát szeretne futtatni egy jegyzetfüzetben, kattintson a kód cellára, és nyomja le a SHIFT + ENTER billentyűkombinációt.To run a single code cell in a notebook, click the code cell and hit Shift+Enter. Vagy futtassa a teljes jegyzetfüzetet úgy, hogy az összes futtatása lehetőséget választja a felső eszköztáron.Or, run the entire notebook by choosing Run all from the top toolbar.

A környezet beállításaSet up the environment

Első lépésként állítsa be a tesztelési környezetet.Start by setting up a testing environment.

Csomagok importálásaImport packages

Importálja az oktatóanyaghoz szükséges Python-csomagokat.Import the Python packages needed for this tutorial.

%matplotlib inline
import numpy as np
import matplotlib.pyplot as plt
 
import azureml.core

# Display the core SDK version number
print("Azure ML SDK Version: ", azureml.core.VERSION)

Üzembe helyezés webszolgáltatáskéntDeploy as web service

A modell üzembe helyezése az ACI-ban üzemeltetett webszolgáltatásként.Deploy the model as a web service hosted in ACI.

Az ACI-hoz megfelelő környezet kialakításához biztosítsa az alábbiakat:To build the correct environment for ACI, provide the following:

  • Pontozószkript a modell használatának bemutatásáhozA scoring script to show how to use the model
  • Az ACI létrehozásához szükséges konfigurációs fájlA configuration file to build the ACI
  • Az imént betanított modellThe model you trained before

Pontozószkript létrehozásaCreate scoring script

Hozzon létre egy score.py nevű pontozószkriptet, amelyet a webszolgáltatás felé irányuló hívás használ a modell használatának bemutatásához.Create the scoring script, called score.py, used by the web service call to show how to use the model.

A pontozószkriptnek két függvényt kell tartalmaznia:You must include two required functions into the scoring script:

  • Az init() függvényt, amely általában a modellt tölti be a globális objektumba.The init() function, which typically loads the model into a global object. Ezt a függvényt csak egyszer kell futtatni, a Docker-tároló indításakor.This function is run only once when the Docker container is started.

  • A run(input_data) függvény a modell segítségével értékeket jelez elő a bemeneti adatok alapján.The run(input_data) function uses the model to predict a value based on the input data. A futtatás bemenetei és kimenetei általában JSON-fájlokat használnak a szerializáláshoz vagy a deszerializáláshoz, de más formátumokat is támogatnak.Inputs and outputs to the run typically use JSON for serialization and de-serialization, but other formats are supported.

%%writefile score.py
import json
import numpy as np
import os
import pickle
import joblib

def init():
    global model
    # AZUREML_MODEL_DIR is an environment variable created during deployment.
    # It is the path to the model folder (./azureml-models/$MODEL_NAME/$VERSION)
    # For multiple models, it points to the folder containing all deployed models (./azureml-models)
    model_path = os.path.join(os.getenv('AZUREML_MODEL_DIR'), 'sklearn_mnist_model.pkl')
    model = joblib.load(model_path)

def run(raw_data):
    data = np.array(json.loads(raw_data)['data'])
    # make prediction
    y_hat = model.predict(data)
    # you can return any data type as long as it is JSON-serializable
    return y_hat.tolist()

Konfigurációs fájl létrehozásaCreate configuration file

Hozzon létre egy telepítési konfigurációs fájlt, és adja meg az ACI-tárolóhoz szükséges processzorok számát, illetve a RAM gigabájtban mért mennyiségét.Create a deployment configuration file and specify the number of CPUs and gigabyte of RAM needed for your ACI container. Bár ez a modelltől is függ, az alapértelmezettként megadott 1 mag és 1 gigabyte RAM számos modell használatához elegendő.While it depends on your model, the default of 1 core and 1 gigabyte of RAM is usually sufficient for many models. Ha később többre lenne szüksége, akkor újra létre kell hoznia a rendszerképet, és újra üzembe kell helyeznie a szolgáltatást.If you feel you need more later, you would have to recreate the image and redeploy the service.

from azureml.core.webservice import AciWebservice

aciconfig = AciWebservice.deploy_configuration(cpu_cores=1, 
                                               memory_gb=1, 
                                               tags={"data": "MNIST",  "method" : "sklearn"}, 
                                               description='Predict MNIST with sklearn')

Üzembe helyezés az ACI-banDeploy in ACI

Várható befejezési idő: körülbelül 2-5 percEstimated time to complete: about 2-5 minutes

Konfigurálja, majd helyezze üzembe a rendszerképet.Configure the image and deploy. Az alábbi kód a következő lépéseket hajtja végre:The following code goes through these steps:

  1. Hozzon létre olyan környezeti objektumot, amely a modell által igényelt függőségeket tartalmazza a tutorial-env betanítás során mentett környezet () használatával.Create environment object containing dependencies needed by the model using the environment (tutorial-env) saved during training.
  2. A modell webszolgáltatásként való üzembe helyezéséhez szükséges következtetési konfiguráció létrehozása a következő használatával:Create inference configuration necessary to deploy the model as a web service using:
    • A pontozófájl (score.py)The scoring file (score.py)
    • az előző lépésben létrehozott környezeti objektumenvironment object created in previous step
  3. Telepítse a modellt az ACI-tárolóba.Deploy the model to the ACI container.
  4. A webszolgáltatás HTTP-végpontjának lekérése.Get the web service HTTP endpoint.
%%time
from azureml.core.webservice import Webservice
from azureml.core.model import InferenceConfig
from azureml.core.environment import Environment
from azureml.core import Workspace
from azureml.core.model import Model

ws = Workspace.from_config()
model = Model(ws, 'sklearn_mnist')


myenv = Environment.get(workspace=ws, name="tutorial-env", version="1")
inference_config = InferenceConfig(entry_script="score.py", environment=myenv)

service = Model.deploy(workspace=ws, 
                       name='sklearn-mnist-svc3', 
                       models=[model], 
                       inference_config=inference_config, 
                       deployment_config=aciconfig)

service.wait_for_deployment(show_output=True)

Kérje le a pontozási webszolgáltatás REST-ügyfélhívásokat fogadó HTTP-végpontját.Get the scoring web service's HTTP endpoint, which accepts REST client calls. Ez a végpont bárkivel megosztható, aki tesztelni szeretné a webszolgáltatást vagy integrálni szeretné azt egy alkalmazásban.This endpoint can be shared with anyone who wants to test the web service or integrate it into an application.

print(service.scoring_uri)

A modell teszteléseTest the model

Tesztelési célú adatfájlok letöltéseDownload test data

A tesztelési célú adatfájlok letöltése a ./Data/ könyvtárbaDownload the test data to the ./data/ directory

import os
from azureml.core import Dataset
from azureml.opendatasets import MNIST

data_folder = os.path.join(os.getcwd(), 'data')
os.makedirs(data_folder, exist_ok=True)

mnist_file_dataset = MNIST.get_file_dataset()
mnist_file_dataset.download(data_folder, overwrite=True)

Tesztadatok betöltéseLoad test data

A tesztadatokat az oktatóanyag követése során létrehozott ./data/ mappából töltheti be.Load the test data from the ./data/ directory created during the training tutorial.

from utils import load_data
import os
import glob

data_folder = os.path.join(os.getcwd(), 'data')
# note we also shrink the intensity values (X) from 0-255 to 0-1. This helps the neural network converge faster
X_test = load_data(glob.glob(os.path.join(data_folder,"**/t10k-images-idx3-ubyte.gz"), recursive=True)[0], False) / 255.0
y_test = load_data(glob.glob(os.path.join(data_folder,"**/t10k-labels-idx1-ubyte.gz"), recursive=True)[0], True).reshape(-1)

A tesztadatok előrejelzésePredict test data

Az előrejelzés elkészítéséhez töltse be a tesztadatkészletet a modellbe.Feed the test dataset to the model to get predictions.

Az alábbi kód a következő lépéseket hajtja végre:The following code goes through these steps:

  1. Az adatok elküldése egy JSON-tömbként az ACI-ban üzemeltetett webszolgáltatásba.Send the data as a JSON array to the web service hosted in ACI.

  2. A szolgáltatás meghívása az SDK run API-jának használatával.Use the SDK's run API to invoke the service. A curl vagy bármely egyéb HTTP-eszköz használatával nyers hívásokat is indíthat.You can also make raw calls using any HTTP tool such as curl.

import json
test = json.dumps({"data": X_test.tolist()})
test = bytes(test, encoding='utf8')
y_hat = service.run(input_data=test)

A keveredési mátrix vizsgálataExamine the confusion matrix

Hozzon létre egy keveredési mátrixot, és ellenőrizze, hogy a tesztkészletből hány minta kapott helyes besorolást.Generate a confusion matrix to see how many samples from the test set are classified correctly. Figyelje meg a helytelen előrejelzéseknél szereplő hibás besorolási értéket.Notice the mis-classified value for the incorrect predictions.

from sklearn.metrics import confusion_matrix

conf_mx = confusion_matrix(y_test, y_hat)
print(conf_mx)
print('Overall accuracy:', np.average(y_hat == y_test))

A kimenet a keveredési mátrixot jeleníti meg:The output shows the confusion matrix:

[[ 960    0    1    2    1    5    6    3    1    1]
 [   0 1112    3    1    0    1    5    1   12    0]
 [   9    8  920   20   10    4   10   11   37    3]
 [   4    0   17  921    2   21    4   12   20    9]
 [   1    2    5    3  915    0   10    2    6   38]
 [  10    2    0   41   10  770   17    7   28    7]
 [   9    3    7    2    6   20  907    1    3    0]
 [   2    7   22    5    8    1    1  950    5   27]
 [  10   15    5   21   15   27    7   11  851   12]
 [   7    8    2   13   32   13    0   24   12  898]]
Overall accuracy: 0.9204

Használja a matplotlib kódtárat a keveredési mátrix grafikonként való megjelenítéséhez.Use matplotlib to display the confusion matrix as a graph. Ezen a grafikonon az X tengely képviseli a tényleges értékeket, az Y tengely pedig az előre jelzett értékeket.In this graph, the X axis represents the actual values, and the Y axis represents the predicted values. Az egyes rácsok színe a hibaarányt jelöli.The color in each grid represents the error rate. Minél világosabb a szín, annál magasabb a hibaarány.The lighter the color, the higher the error rate is. Például sok 5-ös hibásan 3-as besorolást kapott.For example, many 5's are mis-classified as 3's. Így a fényes rács jelenik meg (5, 3).So you see a bright grid at (5,3).

# normalize the diagonal cells so that they don't overpower the rest of the cells when visualized
row_sums = conf_mx.sum(axis=1, keepdims=True)
norm_conf_mx = conf_mx / row_sums
np.fill_diagonal(norm_conf_mx, 0)

fig = plt.figure(figsize=(8, 5))
ax = fig.add_subplot(111)
cax = ax.matshow(norm_conf_mx, cmap=plt.cm.bone)
ticks = np.arange(0, 10, 1)
ax.set_xticks(ticks)
ax.set_yticks(ticks)
ax.set_xticklabels(ticks)
ax.set_yticklabels(ticks)
fig.colorbar(cax)
plt.ylabel('true labels', fontsize=14)
plt.xlabel('predicted values', fontsize=14)
plt.savefig('conf.png')
plt.show()

A zavart mátrixot bemutató diagram

Előrejelzések megjelenítéseShow predictions

Tesztelje a központilag telepített modellt a tesztelési adatokból származó, 30 rendszerképekből álló véletlenszerű mintával.Test the deployed model with a random sample of 30 images from the test data.

  1. A kapott előrejelzések kinyomtatása és a bemeneti képekkel való ábrázolása.Print the returned predictions and plot them along with the input images. A piros betűk és az inverz (fekete alapon fehér) képek kiemelik a tévesen besorolt mintákat.Red font and inverse image (white on black) is used to highlight the misclassified samples.

Mivel a modell pontossága magas, előfordulhat, hogy a tévesen besorolt minta megtekintése előtt néhány alkalommal futtatnia kell a következő kódot.Since the model accuracy is high, you might have to run the following code a few times before you can see a misclassified sample.

import json

# find 30 random samples from test set
n = 30
sample_indices = np.random.permutation(X_test.shape[0])[0:n]

test_samples = json.dumps({"data": X_test[sample_indices].tolist()})
test_samples = bytes(test_samples, encoding='utf8')

# predict using the deployed model
result = service.run(input_data=test_samples)

# compare actual value vs. the predicted values:
i = 0
plt.figure(figsize = (20, 1))

for s in sample_indices:
    plt.subplot(1, n, i + 1)
    plt.axhline('')
    plt.axvline('')
    
    # use different color for misclassified sample
    font_color = 'red' if y_test[s] != result[i] else 'black'
    clr_map = plt.cm.gray if y_test[s] != result[i] else plt.cm.Greys
    
    plt.text(x=10, y=-10, s=result[i], fontsize=18, color=font_color)
    plt.imshow(X_test[s].reshape(28, 28), cmap=clr_map)
    
    i = i + 1
plt.show()

A webszolgáltatás teszteléséhez nyers HTTP-kérést is küldhet.You can also send raw HTTP request to test the web service.

import requests

# send a random row from the test set to score
random_index = np.random.randint(0, len(X_test)-1)
input_data = "{\"data\": [" + str(list(X_test[random_index])) + "]}"

headers = {'Content-Type': 'application/json'}

# for AKS deployment you'd need to the service key in the header as well
# api_key = service.get_key()
# headers = {'Content-Type':'application/json',  'Authorization':('Bearer '+ api_key)} 

resp = requests.post(service.scoring_uri, input_data, headers=headers)

print("POST to url", service.scoring_uri)
#print("input data:", input_data)
print("label:", y_test[random_index])
print("prediction:", resp.text)

Az erőforrások eltávolításaClean up resources

Ha az erőforráscsoportot és a munkaterületet más oktatóanyagokhoz és feltáráshoz szeretné megőrizni, csak a Container Instances üzemelő példányt törölheti az alábbi API-hívás használatával:To keep the resource group and workspace for other tutorials and exploration, you can delete only the Container Instances deployment by using this API call:

service.delete()

Fontos

Az Ön által létrehozott erőforrások előfeltételként használhatók más Azure Machine Learning oktatóanyagokhoz és útmutató cikkekhez.The resources that you created can be used as prerequisites to other Azure Machine Learning tutorials and how-to articles.

Ha nem tervezi a létrehozott erőforrások használatát, törölje őket, így nem számítunk fel díjat:If you don't plan to use the resources that you created, delete them so you don't incur any charges:

  1. Az Azure Portalon válassza az Erőforráscsoportok lehetőséget a bal szélen.In the Azure portal, select Resource groups on the far left.

  2. Válassza ki a létrehozott erőforráscsoportot a listából.From the list, select the resource group that you created.

  3. Válassza az Erőforráscsoport törlése elemet.Select Delete resource group.

    Az Azure Portalon található erőforráscsoport törlését ábrázoló képernyőkép.

  4. Írja be az erőforráscsoport nevét.Enter the resource group name. Ezután válassza a Törlés elemet.Then select Delete.

Következő lépésekNext steps