Träna scikit-learn-modeller i stor skala med Azure Machine Learning (SDK v1)

Artikel
06/10/2023

I den här artikeln får du lära dig hur du kör dina scikit-learn-träningsskript med Azure Machine Learning.

Exempelskripten i den här artikeln används för att klassificera irisblomsbilder för att skapa en maskininlärningsmodell baserad på scikit-learns iris-datauppsättning.

Oavsett om du tränar en scikit-learn-modell för maskininlärning från grunden eller om du använder en befintlig modell i molnet kan du använda Azure Machine Learning för att skala ut träningsjobb med öppen källkod med hjälp av elastiska molnberäkningsresurser. Du kan skapa, distribuera, version och övervaka modeller i produktionsklass med Azure Machine Learning.

Förutsättningar

Du kan köra den här koden i antingen en Azure Machine Learning-beräkningsinstans eller i din egen Jupyter Notebook:

Azure Machine Learning-beräkningsinstans
- Slutför snabbstarten: Kom igång med Azure Machine Learning för att skapa en beräkningsinstans. Varje beräkningsinstans innehåller en dedikerad notebook-server som är förinstallerad med SDK:t och exempellagringsplatsen för notebook-filer.
- Välj anteckningsboksfliken i Azure Machine Learning-studio. I mappen exempelträning letar du upp en slutförd och expanderad anteckningsbok genom att gå till den här katalogen: how-to-use-azureml > ml-frameworks > scikit-learn > train-hyperparameter-tune-deploy-with-sklearn folder.
- Du kan använda den förifyllda koden i exempelmappen för träning för att slutföra den här självstudien.
Skapa en Jupyter Notebook server och kör koden i följande avsnitt.
- Installera Azure Machine Learning SDK (>= 1.13.0).
- Skapa en konfigurationsfil för arbetsytan.

Konfigurera experimentet

Det här avsnittet konfigurerar träningsexperimentet genom att läsa in nödvändiga Python-paket, initiera en arbetsyta, definiera träningsmiljön och förbereda träningsskriptet.

Initiera en arbetsyta

Azure Machine Learning-arbetsytan är den översta resursen för tjänsten. Det ger dig en central plats där du kan arbeta med alla artefakter som du skapar. I Python SDK kan du komma åt artefakterna för arbetsytan genom att skapa ett workspace -objekt.

Skapa ett arbetsyteobjekt från filen som config.jsonskapades i avsnittet förutsättningar.

from azureml.core import Workspace

ws = Workspace.from_config()

Förbereda skript

I den här självstudien har du redan fått träningsskriptet train_iris.py . I praktiken bör du kunna ta ett anpassat träningsskript som det är och köra det med Azure Machine Learning utan att behöva ändra koden.

Anteckning

Det angivna träningsskriptet visar hur du loggar vissa mått till din Azure Machine Learning-körning med hjälp av Run -objektet i skriptet.
Det angivna träningsskriptet använder exempeldata från iris = datasets.load_iris() funktionen. Om du vill använda och komma åt dina egna data kan du se hur du tränar med datauppsättningar för att göra data tillgängliga under träningen.

Definiera din miljö

Om du vill definiera azure machine learning-miljön som kapslar in ditt träningsskripts beroenden kan du antingen definiera en anpassad miljö eller använda och en Azure Machine Learning-granskad miljö.

Använda en granskad miljö

Azure Machine Learning tillhandahåller även fördefinierade, organiserade miljöer om du inte vill definiera din egen miljö.

Om du vill använda en granskad miljö kan du köra följande kommando i stället:

from azureml.core import Environment

sklearn_env = Environment.get(workspace=ws, name='AzureML-Tutorial')

Skapa en anpassad miljö

Du kan också skapa en egen anpassad miljö. Definiera dina conda-beroenden i en YAML-fil. I det här exemplet heter conda_dependencies.ymlfilen .

dependencies:
  - python=3.7
  - scikit-learn
  - numpy
  - pip:
    - azureml-defaults

Skapa en Azure Machine Learning-miljö från den här Conda-miljöspecifikationen. Miljön paketeras i en Docker-container vid körning.

from azureml.core import Environment

sklearn_env = Environment.from_conda_specification(name='sklearn-env', file_path='conda_dependencies.yml')

Mer information om hur du skapar och använder miljöer finns i Skapa och använda programvarumiljöer i Azure Machine Learning.

Konfigurera och skicka träningskörningen

Skapa en ScriptRunConfig

Skapa ett ScriptRunConfig-objekt för att ange konfigurationsinformationen för ditt träningsjobb, inklusive träningsskriptet, miljön som ska användas och beräkningsmålet som ska köras. Eventuella argument till träningsskriptet skickas via kommandoraden om de anges i parametern arguments .

Följande kod konfigurerar ett ScriptRunConfig-objekt för att skicka jobbet för körning på den lokala datorn.

from azureml.core import ScriptRunConfig

src = ScriptRunConfig(source_directory='.',
                      script='train_iris.py',
                      arguments=['--kernel', 'linear', '--penalty', 1.0],
                      environment=sklearn_env)

Om du i stället vill köra jobbet på ett fjärrkluster kan du ange önskat beräkningsmål till parametern compute_target ScriptRunConfig.

from azureml.core import ScriptRunConfig

compute_target = ws.compute_targets['<my-cluster-name>']
src = ScriptRunConfig(source_directory='.',
                      script='train_iris.py',
                      arguments=['--kernel', 'linear', '--penalty', 1.0],
                      compute_target=compute_target,
                      environment=sklearn_env)

Skicka din körning

from azureml.core import Experiment

run = Experiment(ws,'Tutorial-TrainIRIS').submit(src)
run.wait_for_completion(show_output=True)

Varning

Azure Machine Learning kör träningsskript genom att kopiera hela källkatalogen. Om du har känsliga data som du inte vill ladda upp använder du en .ignore-fil eller tar inte med den i källkatalogen . I stället kan du komma åt dina data med hjälp av en Azure Machine Learning-datauppsättning.

Vad händer vid körning

När körningen körs går den igenom följande steg:

Förbereder: En Docker-avbildning skapas enligt den definierade miljön. Avbildningen laddas upp till arbetsytans containerregister och cachelagras för senare körningar. Loggar strömmas också till körningshistoriken och kan visas för att övervaka förloppet. Om en granskad miljö anges i stället används den cachelagrade avbildningsstöd som den organiserade miljön.
Skalning: Klustret försöker skala upp om Batch AI-klustret kräver fler noder för att köra körningen än vad som för närvarande är tillgängligt.
Körs: Alla skript i skriptmappen laddas upp till beräkningsmålet, datalager monteras eller kopieras och script körs. Utdata från stdout och mappen ./logs strömmas till körningshistoriken och kan användas för att övervaka körningen.
Efterbearbetning: Mappen ./outputs för körningen kopieras till körningshistoriken.

Spara och registrera modellen

När du har tränat modellen kan du spara och registrera den på din arbetsyta. Med modellregistrering kan du lagra och versionshantera dina modeller på din arbetsyta för att förenkla modellhantering och distribution.

Lägg till följande kod i träningsskriptet, train_iris.py, för att spara modellen.

import joblib

joblib.dump(svm_model_linear, 'model.joblib')

Registrera modellen på din arbetsyta med följande kod. Genom att ange parametrarna model_framework, model_framework_versionoch resource_configuration, blir modelldistribution utan kod tillgänglig. Med modelldistribution utan kod kan du distribuera din modell direkt som en webbtjänst från den registrerade modellen, och ResourceConfiguration objektet definierar beräkningsresursen för webbtjänsten.

from azureml.core import Model
from azureml.core.resource_configuration import ResourceConfiguration

model = run.register_model(model_name='sklearn-iris', 
                           model_path='outputs/model.joblib',
                           model_framework=Model.Framework.SCIKITLEARN,
                           model_framework_version='0.19.1',
                           resource_configuration=ResourceConfiguration(cpu=1, memory_in_gb=0.5))

Distribution

Den modell som du precis har registrerat kan distribueras på exakt samma sätt som andra registrerade modeller i Azure Machine Learning. Distributionsguiden innehåller ett avsnitt om att registrera modeller, men du kan hoppa direkt till [skapa ett beräkningsmålhow-to-deploy-and-where.md#choose-a-compute-target) för distribution, eftersom du redan har en registrerad modell.

(Förhandsversion) Distribution utan kodmodell

Viktigt

Den här funktionen är för närvarande i allmänt tillgänglig förhandsversion. Den här förhandsversionen tillhandahålls utan serviceavtal och vi rekommenderar den inte för produktionsarbetsbelastningar. Vissa funktioner kanske inte stöds eller kan vara begränsade.

Mer information finns i Kompletterande villkor för användning av Microsoft Azure-förhandsversioner.

I stället för den traditionella distributionsvägen kan du också använda distributionsfunktionen utan kod (förhandsversion) för scikit-learn. Distribution utan kodmodell stöds för alla inbyggda scikit-learn-modelltyper. Genom att registrera din modell enligt ovan med parametrarna model_framework, model_framework_versionoch resource_configuration kan du helt enkelt använda den deploy() statiska funktionen för att distribuera din modell.

web_service = Model.deploy(ws, "scikit-learn-service", [model])