Zelfstudie: Een afbeeldingsclassificatiemodel trainen en implementeren met een voorbeeld Jupyter Notebook

Artikel
05/23/2023

VAN TOEPASSING OP:Python SDK azureml v1

In deze zelfstudie gaat u een machine learning-model trainen op externe rekenresources. U gebruikt de werkstroom voor training en implementatie voor Azure Machine Learning in een Python Jupyter-notebook. Vervolgens kunt u het notebook gebruiken als een sjabloon voor het trainen van uw eigen machine learning-model met uw eigen gegevens.

In deze zelfstudie traint u een eenvoudig logistieke regressiemodel met behulp van de gegevensset MNIST en scikit-learn met Azure Machine Learning. MNIST is een populaire gegevensset die bestaat uit 70.000 afbeeldingen in grijstinten. Elke afbeelding is een handgeschreven cijfer van 28 x 28 pixels, dat een getal tussen 0-9 vertegenwoordigt. Het doel is om een classificatiemechanisme met meerdere klassen te maken om het cijfer te identificeren dat een bepaalde afbeelding vertegenwoordigt.

U leert hoe u de volgende acties uitvoert:

Download een gegevensset en bekijk de gegevens.
Een model voor afbeeldingsclassificatie trainen en metrische gegevens vastleggen met behulp van MLflow.
Implementeer het model om realtime deductie uit te voeren.

Vereisten

Voltooi de Quickstart: Aan de slag met Azure Machine Learning om het volgende te doen:
- Maak een werkruimte.
- Maak een cloudgebasd rekenproces voor gebruik voor uw ontwikkelomgeving.

Een notitieblok uitvoeren vanuit uw werkruimte

Azure Machine Learning bevat een cloudnotebook-server in uw werkruimte voor een installatieloze en vooraf geconfigureerde ervaring. Gebruik uw eigen omgeving als u liever controle over uw omgeving, pakketten en afhankelijkheden hebt.

Een notebook-map klonen

U voltooit de volgende instellingen voor het experiment en voert stappen uit in Azure Machine Learning-studio. Deze geconsolideerde interface bevat machine learning-hulpprogramma's voor het uitvoeren van datawetenschap-scenario's voor datawetenschappers van alle vaardigheidsniveaus.

Meld u aan bij Azure Machine Learning Studio.
Selecteer uw abonnement en de werkruimte die u hebt gecreëerd.
Selecteer aan de linkerkant Notebooks.
Selecteer bovenaan het tabblad Voorbeelden.
Open de map SDK v1 .
Selecteer de knop ... rechts van de map zelfstudies en selecteer vervolgens Klonen.
Er wordt een lijst met mappen weergegeven, met de verschillende gebruikers die toegang hebben tot de werkruimte. Selecteer uw map om de map zelfstudies daar te klonen.

Het gekloonde notebook openen

Open de map zelfstudies die is gekloond in de sectie Gebruikersbestanden .
Selecteer het bestand quickstart-azureml-in-10mins.ipynb in de map tutorials/compute-instance-quickstarts/quickstart-azureml-in-10mins .

Pakketten installeren

Zodra het rekenproces wordt uitgevoerd en de kernel wordt weergegeven, voegt u een nieuwe codecel toe om pakketten te installeren die nodig zijn voor deze zelfstudie.

Voeg bovenaan het notebook een codecel toe.
Voeg het volgende toe aan de cel en voer de cel vervolgens uit met behulp van het hulpprogramma Uitvoeren of met Shift+Enter.
```
%pip install scikit-learn==0.22.1
%pip install scipy==1.5.2
```

Mogelijk ziet u enkele installatiewaarschuwingen. Deze kunnen veilig worden genegeerd.

Het notitieblok uitvoeren

Deze zelfstudie en het bijbehorende utils.py-bestand zijn ook beschikbaar op GitHub als u het in uw eigen lokale omgeving wilt gebruiken. Als u het rekenproces niet gebruikt, voegt u toe %pip install azureml-sdk[notebooks] azureml-opendatasets matplotlib aan de bovenstaande installatie.

Belangrijk

De rest van dit artikel bevat dezelfde inhoud als die u ziet in de notebook.

Schakel nu over naar de Jupyter Notebook als u de code wilt uitvoeren terwijl u meelezen. Als u één codecel in een notebook wilt uitvoeren, klikt u op de codecel en drukt u op Shift+Enter. U kunt ook de hele notebook uitvoeren door Alle uitvoeren te kiezen op de bovenste werkbalk.

Gegevens importeren

Voordat u een model traint, moet u de gegevens begrijpen die u gebruikt om het te trainen. In deze sectie leert u het volgende:

De MNIST-gegevensset downloaden
Enkele voorbeeldafbeeldingen weergeven

U gebruikt Azure Open Datasets om de onbewerkte MNIST-gegevensbestanden op te halen. Azure Open Datasets zijn gecureerde openbare gegevenssets die u kunt gebruiken om scenariospecifieke functies toe te voegen aan machine learning-oplossingen voor betere modellen. Elke gegevensset heeft een bijbehorende klasse, in dit geval MNIST, om de gegevens op verschillende manieren op te halen.

import os
from azureml.opendatasets import MNIST

data_folder = os.path.join(os.getcwd(), "/tmp/qs_data")
os.makedirs(data_folder, exist_ok=True)

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

Bekijk de gegevens

Laad de gecomprimeerde bestanden in numpy-matrices. Gebruik vervolgens matplotlib om 30 willekeurige afbeeldingen uit de gegevensset te tekenen, met de bijbehorende labels erboven.

Voor deze stap hebt u een functie load_data nodig die is opgenomen in een bestand utils.py. Dit bestand wordt in dezelfde map geplaatst als dit notitieblok. De functie load_data parseert de gecomprimeerde bestanden simpelweg in numpy-matrices.

from utils import load_data
import matplotlib.pyplot as plt
import numpy as np
import glob


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


# now let's show some randomly chosen images from the traininng set.
count = 0
sample_size = 30
plt.figure(figsize=(16, 6))
for i in np.random.permutation(X_train.shape[0])[:sample_size]:
    count = count + 1
    plt.subplot(1, sample_size, count)
    plt.axhline("")
    plt.axvline("")
    plt.text(x=10, y=-10, s=y_train[i], fontsize=18)
    plt.imshow(X_train[i].reshape(28, 28), cmap=plt.cm.Greys)
plt.show()

In de bovenstaande code wordt een willekeurige set afbeeldingen met hun labels weergegeven, vergelijkbaar met deze:

Voorbeeldafbeeldingen met hun labels.

Model trainen en metrische gegevens vastleggen met MLflow

U traint het model met behulp van de onderstaande code. Houd er rekening mee dat u automatische logboekregistratie van MLflow gebruikt om metrische gegevens en logboekmodelartefacten bij te houden.

U gebruikt de Classificatie LogisticRegression van het SciKit Learn-framework om de gegevens te classificeren.

Notitie

De modeltraining duurt ongeveer 2 minuten.**

# create the model
import mlflow
import numpy as np
from sklearn.linear_model import LogisticRegression
from azureml.core import Workspace

# connect to your workspace
ws = Workspace.from_config()

# create experiment and start logging to a new run in the experiment
experiment_name = "azure-ml-in10-mins-tutorial"

# set up MLflow to track the metrics
mlflow.set_tracking_uri(ws.get_mlflow_tracking_uri())
mlflow.set_experiment(experiment_name)
mlflow.autolog()

# set up the Logistic regression model
reg = 0.5
clf = LogisticRegression(
    C=1.0 / reg, solver="liblinear", multi_class="auto", random_state=42
)

# train the model
with mlflow.start_run() as run:
    clf.fit(X_train, y_train)

Experiment weergeven

Selecteer taken in het linkermenu in Azure Machine Learning-studio en selecteer vervolgens uw taak (azure-ml-in10-mins-tutorial). Een taak is een groepering van veel uitvoeringen van een opgegeven script of stukje code. Meerdere taken kunnen worden gegroepeerd als een experiment.

Informatie voor de uitvoering wordt opgeslagen onder die taak. Als de naam niet bestaat wanneer u een taak verzendt en u de uitvoering selecteert, ziet u verschillende tabbladen met metrische gegevens, logboeken, uitleg, enzovoort.

Versiebeheer van uw modellen met het modelregister

U kunt modelregistratie gebruiken om uw modellen op te slaan en te versien in uw werkruimte. Geregistreerde modellen worden geïdentificeerd met naam en versie. Telkens wanneer u een model registreert met dezelfde naam als een bestaand model, wordt de versie in het register verhoogd. Met de onderstaande code wordt het model dat u hierboven hebt getraind, geregistreerd en gebruikt. Zodra u de onderstaande codecel hebt uitgevoerd, kunt u het model in het register zien door Modellen te selecteren in het linkermenu in Azure Machine Learning-studio.

# register the model
model_uri = "runs:/{}/model".format(run.info.run_id)
model = mlflow.register_model(model_uri, "sklearn_mnist_model")

Het model implementeren voor realtime deductie

In deze sectie leert u hoe u een model implementeert, zodat een toepassing het model kan gebruiken (deductie) via REST.

Implementatieconfiguratie maken

De codecel krijgt een gecureerde omgeving, die alle afhankelijkheden specificeert die nodig zijn om het model te hosten (bijvoorbeeld de pakketten zoals scikit-learn). U maakt ook een implementatieconfiguratie, waarmee de hoeveelheid rekenkracht wordt opgegeven die nodig is om het model te hosten. In dit geval heeft de rekenkracht 1CPU en 1 GB geheugen.

# create environment for the deploy
from azureml.core.environment import Environment
from azureml.core.conda_dependencies import CondaDependencies
from azureml.core.webservice import AciWebservice

# get a curated environment
env = Environment.get(
    workspace=ws, 
    name="AzureML-sklearn-0.24.1-ubuntu18.04-py37-cpu-inference",
    version=1
)
env.inferencing_stack_version='latest'

# create deployment config i.e. compute resources
aciconfig = AciWebservice.deploy_configuration(
    cpu_cores=1,
    memory_gb=1,
    tags={"data": "MNIST", "method": "sklearn"},
    description="Predict MNIST with sklearn",
)

Model implementeren

Met deze volgende codecel wordt het model geïmplementeerd in Azure Container Instance.

Notitie

De implementatie duurt ongeveer 3 minuten.**

%%time
import uuid
from azureml.core.model import InferenceConfig
from azureml.core.environment import Environment
from azureml.core.model import Model

# get the registered model
model = Model(ws, "sklearn_mnist_model")

# create an inference config i.e. the scoring script and environment
inference_config = InferenceConfig(entry_script="score.py", environment=env)

# deploy the service
service_name = "sklearn-mnist-svc-" + str(uuid.uuid4())[:4]
service = Model.deploy(
    workspace=ws,
    name=service_name,
    models=[model],
    inference_config=inference_config,
    deployment_config=aciconfig,
)

service.wait_for_deployment(show_output=True)

Het scorescriptbestand waarnaar in de bovenstaande code wordt verwezen, bevindt zich in dezelfde map als dit notebook en heeft twee functies:

Een init functie die eenmaal wordt uitgevoerd wanneer de service wordt gestart. In deze functie haalt u normaal gesproken het model op uit het register en stelt u globale variabelen in
Een run(data) functie die wordt uitgevoerd telkens wanneer de service wordt aangeroepen. In deze functie formatteerde u normaal gesproken de invoergegevens, voert u een voorspelling uit en voert u het voorspelde resultaat uit.

Eindpunt weergeven

Zodra het model is geïmplementeerd, kunt u het eindpunt weergeven door te navigeren naar Eindpunten in het linkermenu in Azure Machine Learning-studio. U kunt de status van het eindpunt (in orde/niet in orde) zien, logboeken en verbruiken (hoe toepassingen het model kunnen gebruiken).

De modelservice testen

U kunt het model testen door een onbewerkte HTTP-aanvraag te verzenden om de webservice te testen.

# 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"}

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

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

Resources opschonen

Als u dit model niet meer gaat gebruiken, verwijdert u de Modelservice met behulp van:

# if you want to keep workspace and only delete endpoint (it will incur cost while running)
service.delete()

Als u de kosten verder wilt beheren, stopt u het rekenproces door de knop Compute stoppen te selecteren naast de vervolgkeuzelijst Compute . Start het rekenproces de volgende keer dat u het nodig hebt opnieuw.

Alles verwijderen

Gebruik deze stappen om uw Azure Machine Learning-werkruimte en alle rekenresources te verwijderen.