Maak & softwareomgevingen in Azure Machine Learning

In dit artikel leert u hoe u uw omgevingen Azure Machine Learning beheren. Gebruik de omgevingen om de softwareafhankelijkheden van uw projecten bij te houden en te reproduceren terwijl ze zich ontwikkelen.

Beheer van softwareafhankelijkheden is een veelvoorkomende taak voor ontwikkelaars. U wilt ervoor zorgen dat builds reproduceerbaar zijn zonder uitgebreide handmatige softwareconfiguratie. De Environment Azure Machine Learning-klasse is verantwoordelijk voor lokale ontwikkelingsoplossingen, zoals pip en Conda, en gedistribueerde cloudontwikkeling via Docker-mogelijkheden.

In de voorbeelden in dit artikel wordt het volgende beschreven:

  • Maak een omgeving en geef pakketafhankelijkheden op.
  • Omgevingen ophalen en bijwerken.
  • Een omgeving gebruiken voor training.
  • Gebruik een omgeving voor webservice-implementatie.

Zie Wat zijn ML omgevingen? voor een Azure Machine Learning overzicht van hoe omgevingen in Azure Machine Learning werken. Zie hier voor meer informatie over het configureren van ontwikkelomgevingen.

Vereisten

Een omgeving maken

In de volgende secties worden de verschillende manieren verkend waarop u een omgeving voor uw experimenten kunt maken.

Een omgevingsobject instanteren

Als u handmatig een omgeving wilt maken, importeert u Environment de klasse uit de SDK. Gebruik vervolgens de volgende code om een omgevingsobject te instanteren.

from azureml.core.environment import Environment
Environment(name="myenv")

Een gecureerde omgeving gebruiken

Gecureerde omgevingen bevatten verzamelingen Python-pakketten en zijn standaard beschikbaar in uw werkruimte. Deze omgevingen worden geback-byd door Docker-afbeeldingen in de cache, waardoor de kosten voor de voorbereiding van de run worden beperkt. U kunt een van deze populaire gecureerde omgevingen selecteren om mee te beginnen:

  • De omgeving AzureML-lightgbm-3.2-ubuntu18.04-py37-cpu bevat Scikit-learn, LightGBM, XGBoost, Dask, evenals andere AzureML Python SDK en aanvullende pakketten.

  • De omgeving AzureML-sklearn-0.24-ubuntu18.04-py37-cpu bevat algemene data science-pakketten. Deze pakketten omvatten Scikit-Learn, Pandas, Matplotlib en een grotere set azureml-sdk-pakketten.

Zie het artikel over gecureerde omgevingen voor een lijst met gecureerde omgevingen.

Gebruik de Environment.get methode om een van de gecureerde omgevingen te selecteren:

from azureml.core import Workspace, Environment

ws = Workspace.from_config()
env = Environment.get(workspace=ws, name="AzureML-sklearn-0.24-ubuntu18.04-py37-cpu")

U kunt de gecureerde omgevingen en hun pakketten met behulp van de volgende code weer geven:

envs = Environment.list(workspace=ws)

for env in envs:
    if env.startswith("AzureML"):
        print("Name",env)
        print("packages", envs[env].python.conda_dependencies.serialize_to_string())

Waarschuwing

Start de naam van uw eigen omgeving niet met het AzureML-voorvoegsel. Dit voorvoegsel is gereserveerd voor gecureerde omgevingen.

Als u een gecureerde omgeving wilt aanpassen, kloont en wijzigt u de naam van de omgeving.

env = Environment.get(workspace=ws, name="AzureML-sklearn-0.24-ubuntu18.04-py37-cpu")
curated_clone = env.clone("customize_curated")

Conda-afhankelijkheden of PIP-vereistenbestanden gebruiken

U kunt een omgeving maken van een Conda-specificatie of een PIP-vereistenbestand. Gebruik de from_conda_specification() methode of de methode from_pip_requirements() . Neem in het argument method de naam van uw omgeving en het bestandspad op van het bestand dat u wilt.

# From a Conda specification file
myenv = Environment.from_conda_specification(name = "myenv",
                                             file_path = "path-to-conda-specification-file")

# From a pip requirements file
myenv = Environment.from_pip_requirements(name = "myenv",
                                          file_path = "path-to-pip-requirements-file")                                          

Docker inschakelen

Azure Machine Learning een Docker-afbeelding en maakt u een Python-omgeving binnen die container op basis van uw specificaties. De Docker-afbeeldingen worden in de cache opgeslagen en opnieuw gebruikt: de eerste keer dat de docker wordt uitgevoerd in een nieuwe omgeving duurt doorgaans langer wanneer de afbeelding wordt gebouwd. Voor lokale runs geeft u Docker op in RunConfiguration.

Standaard wordt de nieuw gebouwde Docker-afbeelding weergegeven in het containerregister dat is gekoppeld aan de werkruimte. De naam van de opslagplaats heeft de vorm azureml/azureml_ <uuid>. Het unieke id (uuid) deel van de naam komt overeen met een hash die wordt berekend op basis van de omgevingsconfiguratie. Met deze overeenkomst kan de service bepalen of er al een afbeelding voor de opgegeven omgeving bestaat voor hergebruik.

Een vooraf gebouwde Docker-afbeelding gebruiken

De service maakt standaard automatisch gebruik van een van de Ubuntu Linux basisafbeeldingen ,met name de basisafbeelding die is gedefinieerd door azureml.core.environment.DEFAULT_CPU_IMAGE . Vervolgens worden alle opgegeven Python-pakketten geïnstalleerd die zijn gedefinieerd door de opgegeven Azure ML-omgeving. Andere Azure ML CPU- en GPU-basisafbeeldingen zijn beschikbaar in de containeropslagplaats. Het is ook mogelijk om een aangepaste Docker-basisafbeelding te gebruiken.

# Specify custom Docker base image and registry, if you don't want to use the defaults
myenv.docker.base_image="your_base-image"
myenv.docker.base_image_registry="your_registry_location"

Belangrijk

Azure Machine Learning ondersteunt alleen Docker-afbeeldingen die de volgende software bieden:

  • Ubuntu 18.04 of hoger.
  • Conda 4.7.# of hoger.
  • Python 3.6+.
  • Een POSIX-compatibele shell die beschikbaar is op /bin/sh is vereist in elke containerafbeelding die wordt gebruikt voor training.

Uw eigen Dockerfile gebruiken

U kunt ook een aangepaste Dockerfile opgeven. Het is de eenvoudigste manier om te beginnen met een van Azure Machine Learning basisafbeeldingen met behulp van de Docker-opdracht en vervolgens FROM uw eigen aangepaste stappen toe te voegen. Gebruik deze methode als u niet-Python-pakketten als afhankelijkheden moet installeren. Vergeet niet om de basisafbeelding in te stellen op Geen.

Houd er rekening mee dat Python een impliciete afhankelijkheid is in Azure Machine Learning daarom moet Python zijn geïnstalleerd op een aangepast dockerfile.

# Specify docker steps as a string. 
dockerfile = r"""
FROM mcr.microsoft.com/azureml/openmpi3.1.2-ubuntu18.04
RUN echo "Hello from custom container!"
"""

# Set base image to None, because the image is defined by dockerfile.
myenv.docker.base_image = None
myenv.docker.base_dockerfile = dockerfile

# Alternatively, load the string from a file.
myenv.docker.base_image = None
myenv.docker.base_dockerfile = "./Dockerfile"

Wanneer u aangepaste Docker-afbeeldingen gebruikt, is het raadzaam pakketversies vast te maken om de reproduceerbaarheid te verbeteren.

Uw eigen Python-interpreter opgeven

In sommige gevallen bevat uw aangepaste basisafbeelding mogelijk al een Python-omgeving met pakketten die u wilt gebruiken.

Als u uw eigen geïnstalleerde pakketten wilt gebruiken en Conda wilt uitschakelen, stelt u de parameter Environment.python.user_managed_dependencies = True in. Zorg ervoor dat de basisafbeelding een Python-interpreter bevat en over de pakketten beschikt die uw trainingsscript nodig heeft.

Als u bijvoorbeeld wilt uitvoeren in een Miniconda-basisomgeving waarin het NumPy-pakket is geïnstalleerd, geeft u eerst een Dockerfile op met een stap voor het installeren van het pakket. Stel vervolgens de door de gebruiker beheerde afhankelijkheden in op True .

U kunt ook een pad naar een specifieke Python-interpreter in de afbeelding opgeven door de variabele in te Environment.python.interpreter_path stellen.

dockerfile = """
FROM mcr.microsoft.com/azureml/openmpi3.1.2-ubuntu18.04:20210615.v1
RUN conda install numpy
"""

myenv.docker.base_image = None
myenv.docker.base_dockerfile = dockerfile
myenv.python.user_managed_dependencies=True
myenv.python.interpreter_path = "/opt/miniconda/bin/python"

Waarschuwing

Als u een aantal Python-afhankelijkheden in uw Docker-installatieprogramma installeert en vergeet in te stellen, bestaan deze pakketten niet in de uitvoeringsomgeving, waardoor user_managed_dependencies=True runtimefouten ontstaan. Azure ML bouwt standaard een Conda-omgeving met afhankelijkheden die u hebt opgegeven en voert de uitvoering uit in die omgeving in plaats van python-bibliotheken te gebruiken die u op de basisafbeelding hebt geïnstalleerd.

Afbeeldingsdetails ophalen

Voor een geregistreerde omgeving kunt u afbeeldingsgegevens ophalen met behulp van de volgende code, waarbij een exemplaar details van DockerImageDetails is (AzureML Python SDK >= 1.11) en alle informatie over de omgevingsafbeelding bevat, zoals de dockerfile, het register en de naam van de afbeelding.

details = environment.get_image_details(workspace=ws)

Gebruik de volgende code om de afbeeldingsgegevens op te halen uit een omgeving die automatisch wordt opgeslagen bij het uitvoeren van een uitvoering:

details = run.get_environment().get_image_details(workspace=ws)

Bestaande omgevingen gebruiken

Als u een bestaande Conda-omgeving op uw lokale computer hebt, kunt u de service gebruiken om een omgevingsobject te maken. Met behulp van deze strategie kunt u uw lokale interactieve omgeving opnieuw gebruiken op externe runs.

Met de volgende code maakt u een omgevingsobject van de bestaande Conda-omgeving. mycondaenv Hierbij wordt de methode from_existing_conda_environment() gebruikt.

myenv = Environment.from_existing_conda_environment(name="myenv",
                                                    conda_environment_name="mycondaenv")

Een omgevingsdefinitie kan worden opgeslagen in een map in een gemakkelijk bewerkbare indeling met de save_to_directory() methode . Zodra de wijziging is gemaakt, kan een nieuwe omgeving worden gemaakt door bestanden uit de map te laden.

# save the enviroment
myenv.save_to_directory(path="path-to-destination-directory", overwrite=False)
# modify the environment definition
newenv = Environment.load_from_directory(path="path-to-source-directory")

Impliciet de standaardomgeving gebruiken

Als u geen omgeving opgeeft in de configuratie van de scriptrun voordat u de uitvoering indient, wordt er een standaardomgeving voor u gemaakt.

from azureml.core import ScriptRunConfig, Experiment, Environment
# Create experiment 
myexp = Experiment(workspace=ws, name = "environment-example")

# Attach training script and compute target to run config
src = ScriptRunConfig(source_directory=".", script="example.py", compute_target="local")

# Submit the run
run = myexp.submit(config=src)

# Show each step of run 
run.wait_for_completion(show_output=True)

Pakketten toevoegen aan een omgeving

Voeg pakketten toe aan een omgeving met behulp van Conda-, PIP- of persoonlijke wheel-bestanden. Geef elke pakketafhankelijkheid op met behulp van de CondaDependency klasse . Voeg deze toe aan de van de PythonSection omgeving.

Conda- en PIP-pakketten

Als een pakket beschikbaar is in een Conda-pakketopslagplaats, raden we u aan de Conda-installatie te gebruiken in plaats van de PIP-installatie. Conda-pakketten worden meestal met vooraf gebouwde binaire bestanden gebruikt die de installatie betrouwbaarder maken.

In het volgende voorbeeld wordt toegevoegd aan de omgeving myenv . Hiermee wordt versie 1.17.0 van numpy toegevoegd. Ook wordt het pakket pillow toegevoegd. In het voorbeeld worden add_conda_package() respectievelijk de methode en de methode add_pip_package() gebruikt.

from azureml.core.environment import Environment
from azureml.core.conda_dependencies import CondaDependencies

myenv = Environment(name="myenv")
conda_dep = CondaDependencies()

# Installs numpy version 1.17.0 conda package
conda_dep.add_conda_package("numpy==1.17.0")

# Installs pillow package
conda_dep.add_pip_package("pillow")

# Adds dependencies to PythonSection of myenv
myenv.python.conda_dependencies=conda_dep

Belangrijk

Als u dezelfde omgevingsdefinitie gebruikt voor een andere run, gebruikt Azure Machine Learning service de in de cache opgeslagen afbeelding van uw omgeving opnieuw. Als u bijvoorbeeld een omgeving maakt met een losgemaakte pakketafhankelijkheid, blijft die omgeving de pakketversie gebruiken die is geïnstalleerd op het moment dat de numpy omgeving wordt gemaakt. Bovendien blijft elke toekomstige omgeving met overeenkomende definitie de oude versie gebruiken. Zie Omgeving bouwen, opslaan in de cachingen hergebruik voor meer informatie.

Persoonlijke Python-pakketten

Zie het artikel Persoonlijke Python-pakketten gebruiken als u Python-pakketten privé en veilig wilt gebruiken zonder ze bloot te stellen aan het openbare internet.

Omgevingen beheren

Beheer omgevingen zodat u deze kunt bijwerken, bijhouden en hergebruiken in rekendoelen en met andere gebruikers van de werkruimte.

Omgevingen registreren

De omgeving wordt automatisch geregistreerd bij uw werkruimte wanneer u een run indient of een webservice implementeert. U kunt de omgeving ook handmatig registreren met behulp van de register() methode . Deze bewerking maakt van de omgeving een entiteit die in de cloud wordt bijgespoord en er versies van worden gemaakt. De entiteit kan worden gedeeld tussen werkruimtegebruikers.

Met de volgende code wordt de myenv omgeving geregistreerd bij de ws werkruimte.

myenv.register(workspace=ws)

Wanneer u de omgeving voor het eerst gebruikt in de training of implementatie, wordt deze geregistreerd bij de werkruimte. Vervolgens wordt het gebouwd en geïmplementeerd op het rekendoel. De service cachet de omgevingen. Het opnieuw gebruiken van een omgeving in de cache kost veel minder tijd dan het gebruik van een nieuwe service of een service die is bijgewerkt.

Bestaande omgevingen op halen

De Environment klasse biedt methoden waarmee u bestaande omgevingen in uw werkruimte kunt ophalen. U kunt omgevingen ophalen op naam, als een lijst of door een specifieke trainingsrun. Deze informatie is handig voor probleemoplossing, controle en reproduceerbaarheid.

Een lijst met omgevingen weergeven

Bekijk de omgevingen in uw werkruimte met behulp van de Environment.list(workspace="workspace_name") klasse . Selecteer vervolgens een omgeving die u opnieuw wilt gebruiken.

Een omgeving op naam krijgen

U kunt ook een specifieke omgeving op naam en versie krijgen. In de volgende code wordt de get() methode gebruikt om de versie van de omgeving op te halen in de 1 myenv ws werkruimte.

restored_environment = Environment.get(workspace=ws,name="myenv",version="1")

Een run-specifieke omgeving trainen

Gebruik de methode in de klasse om de omgeving op te halen die is gebruikt voor een specifieke run nadat de training get_environment() is Run uitgevoerd.

from azureml.core import Run
Run.get_environment()

Een bestaande omgeving bijwerken

Stel dat u een bestaande omgeving wijzigt, bijvoorbeeld door een Python-pakket toe te voegen. Het duurt even om te bouwen als er een nieuwe versie van de omgeving wordt gemaakt wanneer u een uitvoering indient, een model implementeert of de omgeving handmatig registreert. Met versie-versies kunt u de wijzigingen in de omgeving na een periode bekijken.

Als u een Python-pakketversie in een bestaande omgeving wilt bijwerken, geeft u het versienummer voor dat pakket op. Als u niet het exacte versienummer gebruikt, gebruikt Azure Machine Learning de bestaande omgeving opnieuw met de oorspronkelijke pakketversies.

Fouten opsporen in de build van de afbeelding

In het volgende voorbeeld wordt de build() methode gebruikt om handmatig een omgeving te maken als een Docker-afbeelding. Hiermee worden de uitvoerlogboeken van de build van de afbeelding bewaakt met behulp van wait_for_completion() . De gebouwde afbeelding wordt vervolgens weergegeven in het Azure Container Registry van Azure Container Registry werkruimte. Deze informatie is handig voor het opsporen van gegevens.

from azureml.core import Image
build = env.build(workspace=ws)
build.wait_for_completion(show_output=True)

Het is handig om eerst lokaal afbeeldingen te bouwen met behulp van de build_local() methode . Als u een Docker-afbeelding wilt maken, stelt u de optionele parameter useDocker=True in. Als u de resulterende afbeelding naar het containerregister van de AzureML-werkruimte wilt pushen, stelt u pushImageToWorkspaceAcr=True in.

build = env.build_local(workspace=ws, useDocker=True, pushImageToWorkspaceAcr=True)

Waarschuwing

Het wijzigen van de volgorde van afhankelijkheden of kanalen in een omgeving leidt tot een nieuwe omgeving en vereist een nieuwe build van de afbeelding. Als u bovendien de methode voor een bestaande afbeelding build() aanroept, worden de afhankelijkheden bijgewerkt als er nieuwe versies zijn.

Beheerloze Azure Container Registry (ACR) gebruiken met VNet

Het is niet langer vereist dat gebruikers de beheermodus hebben ingeschakeld voor hun werkruimte die is gekoppeld aan ACR in VNet-scenario's. Zorg ervoor dat de buildtijd van de afgeleide afbeelding op de berekening minder dan 1 uur is om een geslaagde build mogelijk te maken. Zodra de afbeelding naar de ACR van de werkruimte is ge pusht, is deze afbeelding nu alleen toegankelijk met een rekenidentiteit. Zie Beheerde identiteiten gebruiken met Azure Machine Learning voor meer informatie over het instellen.

Omgevingen gebruiken voor training

Als u een trainingsrun wilt verzenden, moet u uw omgeving,rekendoel en uw Python-script voor training combineren in een uitvoeringsconfiguratie. Deze configuratie is een wrapper-object dat wordt gebruikt voor het verzenden van uitvoeringen.

Wanneer u een trainingsrun indient, kan het bouwen van een nieuwe omgeving enkele minuten duren. De duur is afhankelijk van de grootte van de vereiste afhankelijkheden. De omgevingen worden in de cache opgeslagen door de service. Zolang de omgevingsdefinitie ongewijzigd blijft, wordt de volledige installatie slechts één keer gebruikt.

In het volgende voorbeeld van het uitvoeren van een lokaal script ziet u waar u als ScriptRunConfig uw wrapper-object zou gebruiken.

from azureml.core import ScriptRunConfig, Experiment
from azureml.core.environment import Environment

exp = Experiment(name="myexp", workspace = ws)
# Instantiate environment
myenv = Environment(name="myenv")

# Configure the ScriptRunConfig and specify the environment
src = ScriptRunConfig(source_directory=".", script="train.py", compute_target="local", environment=myenv)

# Submit run 
run = exp.submit(src)

Notitie

Als u de rungeschiedenis wilt uitschakelen of momentopnamen wilt uitvoeren, gebruikt u de instelling onder src.run_config.history .

Belangrijk

CPU-SKU's gebruiken voor elke build van een afbeelding op rekenkracht.

Als u de omgeving niet opgeeft in de uitvoeringsconfiguratie, maakt de service een standaardomgeving wanneer u de uitvoering indient.

Omgevingen gebruiken voor webservice-implementatie

U kunt omgevingen gebruiken wanneer u uw model als een webservice implementeert. Deze mogelijkheid maakt een reproduceerbare, verbonden werkstroom mogelijk. In deze werkstroom kunt u uw model trainen, testen en implementeren met behulp van dezelfde bibliotheken in zowel uw trainingsrekenproces als uw deferentiereken.

Als u uw eigen omgeving voor webservice-implementatie definit, moet u versie azureml-defaults >= 1.0.45 als pip-afhankelijkheid gebruiken. Dit pakket bevat de functionaliteit die nodig is om het model als een webservice te hosten.

Als u een webservice wilt implementeren, combineert u de omgeving, de deference compute, het scorescript en het geregistreerde model in uw implementatieobject, deploy() . Zie How and where to deploy models (Modellen implementeren) voor meer informatie.

In dit voorbeeld wordt ervan uitgenomen dat u een trainingsuitloop hebt voltooid. Nu wilt u dat model implementeren in Azure Container Instances. Wanneer u de webservice bouwt, worden het model en de scoring-bestanden aan de afbeelding bevestigd en wordt Azure Machine Learning de deference stack toegevoegd aan de afbeelding.

from azureml.core.model import InferenceConfig, Model
from azureml.core.webservice import AciWebservice, Webservice

# Register the model to deploy
model = run.register_model(model_name = "mymodel", model_path = "outputs/model.pkl")

# Combine scoring script & environment in Inference configuration
inference_config = InferenceConfig(entry_script="score.py", environment=myenv)

# Set deployment configuration
deployment_config = AciWebservice.deploy_configuration(cpu_cores = 1, memory_gb = 1)

# Define the model, inference, & deployment configuration and web service name and location to deploy
service = Model.deploy(
    workspace = ws,
    name = "my_web_service",
    models = [model],
    inference_config = inference_config,
    deployment_config = deployment_config)

Notebooks

Codevoorbeelden in dit artikel zijn ook opgenomen in de notebook voor het gebruik van omgevingen.

Zie Add a new Jupyter kernel (Een nieuwe Jupyter-kerneltoevoegen) voor het installeren van een Conda-omgeving als een kernel in een notebook.

Een model implementeren met behulp van een aangepaste Docker-basisafbeelding laat zien hoe u een model implementeert met behulp van een aangepaste Docker-basisafbeelding.

In dit voorbeeldnoteboek wordt gedemonstreerd hoe u een Spark-model implementeert als een webservice.

Omgevingen maken en beheren met de Azure CLI

Belangrijk

Voor de Azure CLI-opdrachten in dit artikel is de extensie , of azure-cli-ml 1.0, vereist voor Azure Machine Learning. De verbeterde 2.0 CLI (preview) met behulp van de ml extensie is nu beschikbaar en aanbevolen. De extensies zijn niet compatibel, dus 2.0 CLI-opdrachten werken niet voor de stappen in dit artikel. Met machine learning werkruimten en alle onderliggende resources kan echter vanuit beide worden geinteractiviteit, wat betekent dat de ene gebruiker een werkruimte kan maken met de 1.0 CLI en een andere gebruiker taken naar dezelfde werkruimte kan verzenden met de 2.0 CLI.

Als u wilt weten welke extensies u hebt geïnstalleerd, gebruikt az extension list u . Als de lijst met extensies azure-cli-ml bevat, hebt u de juiste extensie voor de stappen in dit artikel.

Zie de volgende artikelen voor meer informatie over het installeren en gebruiken van de verschillende extensies:

De Azure Machine Learning CLI weerspiegelt de meeste functionaliteit van de Python SDK. U kunt deze gebruiken om omgevingen te maken en te beheren. De opdrachten die we in deze sectie bespreken, demonstreren de fundamentele functionaliteit.

De volgende opdracht wordt de bestanden voor een standaard omgevingsdefinitie in de opgegeven map. Deze bestanden zijn JSON-bestanden. Ze werken als de bijbehorende klasse in de SDK. U kunt de bestanden gebruiken om nieuwe omgevingen met aangepaste instellingen te maken.

az ml environment scaffold -n myenv -d myenvdir

Voer de volgende opdracht uit om een omgeving te registreren vanuit een opgegeven map.

az ml environment register -d myenvdir

Voer de volgende opdracht uit om alle geregistreerde omgevingen weer te geven.

az ml environment list

Download een geregistreerde omgeving met behulp van de volgende opdracht.

az ml environment download -n myenv -d downloaddir

Omgevingen maken en beheren met Visual Studio Code

Met de Azure Machine Learning-extensie kunt u omgevingen maken en beheren in Visual Studio Code. Zie Manage Azure Machine Learning resources with the VS Code extension (Resources beheren met de VS Code-extensie) voor meer informatie.

Volgende stappen