Azure Machine Learning-experimenten

Voltooid

Net als bij elke wetenschappelijke discipline moeten voor gegevenswetenschappen experimenten worden uitgevoerd, doorgaans om gegevens te verkennen of om voorspellende modellen te bouwen en te evalueren. In Azure Machine Learning is een experiment een benoemd proces, meestal het uitvoeren van een script of een pijplijn, waarmee metrische gegevens en uitvoer kunnen worden gegenereerd en dat kan worden bijgehouden in de Azure Machine Learning-werkruimte.

Een experimentuitvoering waarmee metrische gegevens en uitvoer worden gegenereerd

Een experiment kan meerdere keren worden uitgevoerd, met verschillende gegevens, code of instellingen. Ook houdt Azure Machine Learning elke uitvoering bij, zodat u de uitvoeringsgeschiedenis kunt bekijken en de resultaten voor elke uitvoering kunt vergelijken.

<a name="the-experiment-run-context">De context van de experimentuitvoering

Wanneer u een experiment verzendt, gebruikt u de uitvoeringscontext van het experiment om de experimentuitvoering te initialiseren en te beëindigen die wordt bijgehouden in Azure Machine Learning, zoals wordt weergegeven in het volgende codevoorbeeld:

from azureml.core import Experiment

# create an experiment variable
experiment = Experiment(workspace = ws, name = &quot;my-experiment")

# start the experiment
run = experiment.start_logging()

# experiment code goes here

# end the experiment
run.complete()

Nadat de experimentuitvoering is voltooid, kunt u de details van de uitvoering bekijken op het tabblad Experimenten in Azure Machine Learning Studio.

Metrische gegevens vastleggen en uitvoer maken

Experimenten zijn het handigst wanneer ze metrische gegevens en uitvoer genereren die kunnen worden bijgehouden voor meerdere uitvoeringen.

Metrische gegevens vastleggen

Met elk experiment worden logboekbestanden gegenereerd die de berichten bevatten die tijdens interactieve uitvoering naar de terminal worden geschreven. Zo kunt u eenvoudige print-instructies gebruiken om berichten naar het logboek te schrijven. Als u echter benoemde metrische gegevens wilt vastleggen voor de vergelijking van uitvoeringen, kunt u dit doen met behulp van het object Run. Hiermee beschikt u over een reeks registratiefuncties die specifiek zijn voor dit doel. Deze omvatten:

  • log: leg één benoemde waarde vast.
  • log_list: leg een benoemde lijst met waarden vast.
  • log_row: leg een rij met meerdere kolommen vast.
  • log_table: leg een woordenboek vast als een tabel.
  • log_image: leg een afbeeldingsbestand of een tekening vast.

Meer informatie: Zie Azure ML-experimentuitvoeringen en metrische gegevens bewaken in de Azure Machine Learning-documentatie voor meer informatie over het vastleggen van metrische gegevens tijdens experimentuitvoeringen.

Met de volgende code bijvoorbeeld wordt het aantal observaties (records) vastgelegd in een CSV-bestand:

from azureml.core import Experiment
import pandas as pd

# Create an Azure ML experiment in your workspace
experiment = Experiment(workspace = ws, name = 'my-experiment')

# Start logging data from the experiment
run = experiment.start_logging()

# load the dataset and count the rows
data = pd.read_csv('data.csv')
row_count = (len(data))

# Log the row count
run.log('observations', row_count)

# Complete the experiment
run.complete()

Vastgelegde metrische gegevens ophalen en weergeven

U kunt de metrische gegevens weergeven die zijn vastgelegd bij een experimentuitvoering in Azure Machine Learning Studio of door de widget RunDetails te gebruiken in een notebook, zoals hier wordt weergegeven:

from azureml.widgets import RunDetails

RunDetails(run).show()

U kunt de metrische gegevens ook ophalen met behulp van de get_metrics-methode van het Run-object. Hiermee wordt een JSON-weergave van de metrische gegevens geretourneerd, zoals hier wordt weergegeven:

import json

# Get logged metrics
metrics = run.get_metrics()
print(json.dumps(metrics, indent=2))

Met de voorgaande code kan uitvoer worden geproduceerd die er ongeveer als volgt uitziet:

{
  "observations": 15000
}

Uitvoerbestanden van experimenten

Naast logboekregistratiegegevens kan een experiment uitvoerbestanden genereren. Vaak zijn dit getrainde machine learning-modellen, maar u kunt een willekeurig soort bestand opslaan en dit beschikbaar maken als uitvoer van de experimentuitvoering. De uitvoerbestanden van een experiment worden opgeslagen in de map outputs.

De methode die u gebruikt om bestanden toe te voegen aan de uitvoer van een experiment, is afhankelijk van hoe u het experiment uitvoert. Met de voorgaande voorbeelden wordt de levenscyclus van experimenten in de code beheert. Bij deze benadering kunt u lokale bestanden uploaden naar de map outputs van de uitvoering door de methode upload_file van het object Run in uw experimentcode te gebruiken, zoals hier wordt weergegeven:

run.upload_file(name='outputs/sample.csv', path_or_stream='./sample.csv')

Bij het uitvoeren van een experiment in een externe berekeningscontext (die verderop in deze cursus wordt besproken), worden alle bestanden die in de berekeningscontext naar de map outputs worden geschreven, automatisch geüpload naar de map outputs van de uitvoering wanneer de uitvoering is voltooid.

U kunt bij elke benadering die u gebruikt om uw experiment uit te voeren, een lijst met uitvoerbestanden ophalen uit het Run-object, zoals:

import json

files = run.get_file_names()
print(json.dumps(files, indent=2))

Met de voorgaande code wordt uitvoer geproduceerd die er ongeveer als volgt uitziet:

[
  "outputs/sample.csv"
]

Een script uitvoeren als een experiment

U kunt een experiment inline uitvoeren met behulp van de methode start_logging van het object Experiment, maar het is gebruikelijker de logica voor het experiment in een script op te nemen en het script als een experiment uit te voeren. Het script kan worden uitgevoerd in elke geldige berekeningscontext, waardoor dit een flexibele oplossing is voor het uitvoeren van experimenten als schaal.

Een experimentscript is gewoon een Python-codebestand met de code die u in het experiment wilt uitvoeren. Om toegang te krijgen tot de uitvoeringscontext van het experiment (die nodig is voor het vastleggen van metrische gegevens) moet met het script de azureml.core.Run-klasse worden geïmporteerd en de get_context-methode hiervan worden aangeroepen. Het script kan vervolgens de uitvoeringscontext gebruiken voor het vastleggen van metrische gegevens, het uploaden van bestanden en het voltooien van het experiment, zoals in het volgende voorbeeld wordt weergegeven:

from azureml.core import Run
import pandas as pd
import matplotlib.pyplot as plt
import os

# Get the experiment run context
run = Run.get_context()

# load the diabetes dataset
data = pd.read_csv('data.csv')

# Count the rows and log the result
row_count = (len(data))
run.log('observations', row_count)

# Save a sample of the data
os.makedirs('outputs', exist_ok=True)
data.sample(100).to_csv("outputs/sample.csv", index=False, header=True)

# Complete the run
run.complete()

Als u een script als experiment wilt uitvoeren, moet u eerst een scriptconfiguratie definiëren waarmee het script dat moet worden uitgevoerd en de Python-omgeving waarin het script moet worden uitgevoerd, worden beschreven. Dit wordt met behulp van een ScriptRunConfig-object geïmplementeerd.

De volgende code bijvoorbeeld kan worden gebruikt om een experiment uit te voeren op basis van een script in de map experiment_files (die ook de bestanden moet bevatten die door het script worden gebruikt, zoals het bestand data. csv in het vorige voorbeeld van scriptcode):

from azureml.core import Experiment, ScriptRunConfig

# Create a script config
script_config = ScriptRunConfig(source_directory=experiment_folder,
                                script='experiment.py') 

# submit the experiment
experiment = Experiment(workspace = ws, name = 'my-experiment')
run = experiment.submit(config=script_config)
run.wait_for_completion(show_output=True)

Notitie

Met een impliciet gemaakt RunConfiguration-object wordt de Python-omgeving voor het experiment gedefinieerd, inclusief de pakketten die beschikbaar zijn voor het script. Als uw script afhankelijk is van pakketten die niet zijn opgenomen in de standaardomgeving, moet u het ScriptRunConfig-object koppelen aan een Environment-object dat gebruikmaakt van een CondaDependencies-object om de vereiste Python-pakketten op te geven. Runtime-omgevingen worden later in deze cursus in meer details besproken.