Träna modeller med Azure Machine Learning-datauppsättningar

GÄLLER FÖR:Azure Machine Learning SDK v1 för Python

I den här artikeln får du lära dig hur du arbetar med Azure Machine Learning-datauppsättningar för att träna maskininlärningsmodeller. Du kan använda datauppsättningar i ditt lokala eller fjärranslutna beräkningsmål utan att behöva bekymra dig om anslutningssträng eller datasökvägar.

• För strukturerade data, se Använda datauppsättningar i maskininlärningsträningsskript.

• Ostrukturerade data finns i Montera filer till fjärrberäkningsmål.

Azure Machine Learning-datauppsättningar ger en sömlös integrering med Azure Machine Learning-träningsfunktioner som ScriptRunConfig, HyperDrive och Azure Machine Learning-pipelines.

Om du inte är redo att göra dina data tillgängliga för modellträning, men vill ladda upp dina data till din notebook för datautforskning, kan du se hur du utforskar data i din datauppsättning.

Förutsättningar

Om du vill skapa och träna med datauppsättningar behöver du:

• En Azure-prenumeration. Om du inte har någon Azure-prenumeration kan du skapa ett kostnadsfritt konto innan du börjar. Prova den kostnadsfria eller betalda versionen av Azure Machine Learning idag.

• En Azure Machine Learning-arbetsyta.

• Azure Machine Learning SDK för Python installerat (>= 1.13.0), som innehåller azureml-datasets paketet.

Förbruka datauppsättningar i träningsskript för maskininlärning

Om du har strukturerat data som ännu inte registrerats som en datauppsättning skapar du en TabularDataset och använder den direkt i träningsskriptet för ditt lokala experiment eller fjärrexperiment.

I det här exemplet skapar du en oregistrerad TabularDataset och anger den som ett skriptargument i ScriptRunConfig-objektet för träning. Om du vill återanvända den här TabularDataset med andra experiment på din arbetsyta kan du läsa om hur du registrerar datauppsättningar på din arbetsyta.

Skapa ett TabularDataset

Följande kod skapar en oregistrerad TabularDataset från en webb-URL.

from azureml.core.dataset import Dataset

web_path ='https://dprepdata.blob.core.windows.net/demo/Titanic.csv'
titanic_ds = Dataset.Tabular.from_delimited_files(path=web_path)

Med TabularDataset-objekt kan du läsa in data i din TabularDataset till en Pandas- eller Spark DataFrame-fil så att du kan arbeta med välbekanta dataförberedelser och träningsbibliotek utan att behöva lämna anteckningsboken.

Komma åt datauppsättning i träningsskript

Följande kod konfigurerar ett skriptargument --input-data som du anger när du konfigurerar träningskörningen (se nästa avsnitt). När tabelldatauppsättningen skickas som argumentvärde omvandlar Azure Machine Learning den till dataset-ID:t. Du kan sedan använda det argumentvärdet för att komma åt datamängden i ditt träningsskript (utan att behöva hårdkoda namnet eller ID:t för datauppsättningen i skriptet). Den använder to_pandas_dataframe() sedan metoden för att läsa in datamängden i en Pandas-dataram för ytterligare datautforskning och förberedelse före träning.

Om du behöver läsa in förberedda data i en ny datauppsättning från en minnesintern Pandas-dataram skriver du data till en lokal fil, till exempel en parquet, och skapar en ny datauppsättning från den filen. Läs mer om hur du skapar datauppsättningar.

%%writefile $script_folder/train_titanic.py

import argparse
from azureml.core import Dataset, Run

parser = argparse.ArgumentParser()
parser.add_argument("--input-data", type=str)
args = parser.parse_args()

run = Run.get_context()
ws = run.experiment.workspace

# get the input dataset by ID
dataset = Dataset.get_by_id(ws, id=args.input_data)

# load the TabularDataset to pandas DataFrame
df = dataset.to_pandas_dataframe()

Konfigurera träningskörningen

Ett ScriptRunConfig-objekt används för att konfigurera och skicka träningskörningen.

Den här koden skapar ett ScriptRunConfig-objekt, src, som anger:

• En skriptkatalog för dina skript. Alla filer i den här katalogen laddas upp till klusternoderna för exekvering.
• Träningsskriptet train_titanic.py.
• Indatauppsättningen för träning, titanic_ds, som ett skriptargument. Azure Machine Learning löser det med motsvarande ID för datauppsättningen när den skickas till skriptet.
• Beräkningsmålet för körningen.
• Körningens miljö.

from azureml.core import ScriptRunConfig

src = ScriptRunConfig(source_directory=script_folder,
                      script='train_titanic.py',
                      # pass dataset as an input with friendly name 'titanic'
                      arguments=['--input-data', titanic_ds.as_named_input('titanic')],
                      compute_target=compute_target,
                      environment=myenv)
                             
# Submit the run configuration for your training run
run = experiment.submit(src)
run.wait_for_completion(show_output=True)                             

Montera filer till fjärrberäkningsmål

Om du har ostrukturerade data skapar du en FileDataset och monterar eller laddar ned dina datafiler för att göra dem tillgängliga för fjärrberäkningsmålet för träning. Lär dig mer om när du ska använda montering jämfört med nedladdning för dina fjärrträningsexperiment.

Följande exempel

• Skapar en indatafiluppsättning, mnist_ds, för dina träningsdata.
• Anger var du ska skriva träningsresultat och konvertera dessa resultat till en FileDataset.
• Monterar indatauppsättningen till beräkningsmålet.

För anteckningsexemplet, se Så här konfigurerar du en träningskörning med indata och utdata.

Skapa ett FileDataset

I följande exempel skapas en oregistrerad FileDataset mnist_data från webbadresser. Den här FileDataset är indata för din träningskörning.

Läs mer om hur du skapar datauppsättningar från andra källor.

from azureml.core.dataset import Dataset

web_paths = [
            'http://yann.lecun.com/exdb/mnist/train-images-idx3-ubyte.gz',
            'http://yann.lecun.com/exdb/mnist/train-labels-idx1-ubyte.gz',
            'http://yann.lecun.com/exdb/mnist/t10k-images-idx3-ubyte.gz',
            'http://yann.lecun.com/exdb/mnist/t10k-labels-idx1-ubyte.gz'
            ]

mnist_ds = Dataset.File.from_files(path = web_paths)

Var du kan skriva träningsutdata

Du kan ange var du vill skriva dina träningsresultat med ett OutputFileDatasetConfig-objekt.

Med OutputFileDatasetConfig-objekt kan du:

• Montera eller ladda upp utdata från en körning till molnlagring som du anger.
• Spara utdata som en FileDataset till dessa lagringstyper som stöds:
  • Azure-blobstjänst
  • Azure-filresurs
  • Azure Data Lake Storage generation 1 och 2
• Spårning av datahärkomst mellan träningskörningar.

Följande kod anger att träningsresultat ska sparas som en FileDataset i outputdataset mappen i standardblobdatalagret, def_blob_store.

from azureml.core import Workspace
from azureml.data import OutputFileDatasetConfig

ws = Workspace.from_config()

def_blob_store = ws.get_default_datastore()
output = OutputFileDatasetConfig(destination=(def_blob_store, 'sample/outputdataset'))

Konfigurera träningskörningen

Vi rekommenderar att du skickar datamängden som ett argument vid montering via parametern arguments för ScriptRunConfig konstruktorn. På så sätt får du datasökvägen (monteringspunkten) i träningsskriptet via argument. På så sätt kan du använda samma träningsskript för lokal felsökning och fjärrträning på valfri molnplattform.

I följande exempel skapas en ScriptRunConfig som skickar in FileDataset via arguments. När du har skickat körningen monteras datafiler som refereras till av datamängden mnist_ds till beräkningsmålet och träningsresultat sparas i den angivna outputdataset mappen i standarddatalagringen.

from azureml.core import ScriptRunConfig

input_data= mnist_ds.as_named_input('input').as_mount()# the dataset will be mounted on the remote compute 

src = ScriptRunConfig(source_directory=script_folder,
                      script='dummy_train.py',
                      arguments=[input_data, output],
                      compute_target=compute_target,
                      environment=myenv)

# Submit the run configuration for your training run
run = experiment.submit(src)
run.wait_for_completion(show_output=True)

Enkelt träningsskript

Följande skript skickas via ScriptRunConfig. Den läser datamängden mnist_ds som indata och skriver filen till outputdataset mappen i standard-blobdataarkivet, def_blob_store.

%%writefile $source_directory/dummy_train.py

# Copyright (c) Microsoft Corporation. All rights reserved.
# Licensed under the MIT License.
import sys
import os

print("*********************************************************")
print("Hello Azure Machine Learning!")

mounted_input_path = sys.argv[1]
mounted_output_path = sys.argv[2]

print("Argument 1: %s" % mounted_input_path)
print("Argument 2: %s" % mounted_output_path)
    
with open(mounted_input_path, 'r') as f:
    content = f.read()
    with open(os.path.join(mounted_output_path, 'output.csv'), 'w') as fw:
        fw.write(content)

Montera kontra ladda ned

Montering eller nedladdning av filer i valfritt format stöds för datauppsättningar som skapats från Azure Blob Storage, Azure Files, Azure Data Lake Storage Gen1, Azure Data Lake Storage Gen2, Azure SQL Database och Azure Database for PostgreSQL.

När du monterar en datauppsättning bifogar du filerna som refereras av datauppsättningen till en katalog (monteringspunkt) och gör den tillgänglig på beräkningsmålet. Montering stöds för Linux-baserade beräkningar, inklusive Azure Machine Learning Compute, virtuella datorer och HDInsight. Om datastorleken överskrider storleken på beräkningsdisken går det inte att ladda ned. I det här scenariot rekommenderar vi montering eftersom endast de datafiler som används av skriptet läses in vid tidpunkten för bearbetningen.

När du laddar ned en datauppsättning laddas alla filer som refereras av datauppsättningen ned till beräkningsmålet. Nedladdning stöds för alla beräkningstyper. Om skriptet bearbetar alla filer som refereras av datauppsättningen och beräkningsdisken passar din fullständiga datauppsättning rekommenderar vi att du laddar ned för att undvika att strömma data från lagringstjänster. För nedladdningar med flera noder, se hur du undviker fördröjning.

Följande kod monterar dataset i temp-katalogen på mounted_path

import tempfile
mounted_path = tempfile.mkdtemp()

# mount dataset onto the mounted_path of a Linux-based compute
mount_context = dataset.mount(mounted_path)

mount_context.start()

import os
print(os.listdir(mounted_path))
print (mounted_path)

Hämta datamängder i maskininlärningsskript

Registrerade datauppsättningar är tillgängliga både lokalt och via fjärranslutning i beräkningskluster som Azure Machine Learning-beräkningen. För att få åtkomst till din registrerade datauppsättning i olika experiment, använd följande kod för att komma åt din arbetsyta och hämta den datauppsättning som användes i ditt tidigare inlämnade körningsförsök. Som standard inställning returnerar metoden get_by_name() i Dataset-klassen den senaste versionen av datamängd som registrerats i arbetsytan.

%%writefile $script_folder/train.py

from azureml.core import Dataset, Run

run = Run.get_context()
workspace = run.experiment.workspace

dataset_name = 'titanic_ds'

# Get a dataset by name
titanic_ds = Dataset.get_by_name(workspace=workspace, name=dataset_name)

# Load a TabularDataset into pandas DataFrame
df = titanic_ds.to_pandas_dataframe()

Få åtkomst till källkod under träning

Azure Blob Storage har högre dataflödeshastigheter än en Azure-filresurs och skalar till ett stort antal jobb som startats parallellt. Därför rekommenderar vi att du konfigurerar dina körningar för att använda Blob Storage för överföring av källkodsfiler.

Följande kodexempel anger i körningskonfigurationen vilket blobdatalager som ska användas för källkodsöverföringar.

# workspaceblobstore is the default blob storage
src.run_config.source_directory_data_store = "workspaceblobstore" 

Notebook-exempel

• För fler exempel och begrepp avseende datamängder, se dataset-anteckningsböckerna.
• Se hur du parametrisera datamängder i dina ML-pipelines.

Felsökning

Initiering av datauppsättningen misslyckades: Väntetiden för att monteringspunkten ska bli klar har överskridits

• Om du inte har några utgående regler i nätverkssäkerhetsgruppen och använder azureml-sdk>=1.12.0, uppdatera azureml-dataset-runtime och dess beroenden till den senaste versionen för den specifika delversionen. Om du använder den i en körning, återskapa din miljö så att den kan ha den senaste korrigeringsuppdateringen.
• Om du använder azureml-sdk<1.12.0uppgraderar du till den senaste versionen.
• Om du har NSG-regler för utgående trafik, se till att det finns en regel som tillåter all trafik för tjänsttaggen AzureResourceMonitor.

Det gick inte att initiera datauppsättningen: StreamAccessException orsakades av ThrottlingException

För filnedladdningar med flera noder kan alla noder försöka ladda ned alla filer i fildatauppsättningen från Azure Storage-tjänsten, vilket resulterar i ett begränsningsfel. För att undvika begränsning anger du först miljövariabeln AZUREML_DOWNLOAD_CONCURRENCY till ett värde på åtta gånger så många CPU-kärnor dividerat med antalet noder. Att konfigurera ett värde för den här miljövariabeln kan kräva vissa experiment, så den tidigare vägledningen är en startpunkt.

I följande exempel förutsätts 32 kärnor och 4 noder.

from azureml.core.environment import Environment 
myenv = Environment(name="myenv")
myenv.environment_variables = {"AZUREML_DOWNLOAD_CONCURRENCY":64}

AzureFile-lagring

Det går inte att ladda upp projektfiler till arbetskatalogen i AzureFile eftersom lagringen är överbelastad:

• Om du använder fildelning för andra arbetsbelastningar, till exempel dataöverföring, rekommenderar vi att du använder blobar så att fildelningen kan användas för att skicka in körningar.

• Du kan också dela upp arbetsbelastningen mellan två olika arbetsytor.

ConfigException: Det gick inte att skapa en anslutning till AzureFileService på grund av saknade autentiseringsuppgifter. Antingen måste en kontonyckel eller EN SAS-token länkas till standardlagringsplatsen för arbetsytans blob.

Utför följande steg för att säkerställa att dina autentiseringsuppgifter för lagringsåtkomst är länkade till arbetsytan och det associerade fildataarkivet:

1. Gå till din arbetsyta i Azure Portal.
2. Välj lagringslänken på arbetsytans översiktssida .
3. På lagringssidan väljer du Åtkomstnycklar på menyn till vänster.
4. Kopiera nyckeln.
5. Gå till Azure Machine Learning studio för din arbetsyta.
6. I studion väljer du det fildatalager som du vill ange autentiseringsuppgifter för.
7. Välj Uppdatera autentisering.
8. Klistra in nyckeln från föregående steg.
9. Välj Spara.

Överföra data som inmatning

TypeError: FileNotFound: Ingen sådan fil eller katalog: Det här felet inträffar om filsökvägen du anger inte är där filen finns. Du måste se till att sättet du refererar till filen på stämmer överens med var du monterade datamängden på beräkningsmålet. För att säkerställa ett deterministiskt tillstånd rekommenderar vi att du använder den abstrakta sökvägen när du monterar en datamängd till ett beräkningsmål. I följande kod monterar vi till exempel datamängden under roten i filsystemet för beräkningsmålet. /tmp

# Note the leading / in '/tmp/dataset'
script_params = {
    '--data-folder': dset.as_named_input('dogscats_train').as_mount('/tmp/dataset'),
} 

Om du inte inkluderar det inledande snedstrecket, '/', måste du ange arbetskatalogens prefix, till exempel /mnt/batch/.../tmp/dataset på beräkningsenheten, för att ange var datauppsättningen ska monteras.

Nästa steg

• Träna maskininlärningsmodeller automatiskt med TabularDatasets.

• Träna bildklassificeringsmodeller med FileDatasets.

• Träna med datauppsättningar med hjälp av pipelines.