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

  • Artikel

Varning

Den här artikeln refererar till CentOS, en Linux-distribution som närmar sig EOL-status (End Of Life). Överväg att använda och planera i enlighet med detta. Mer information finns i CentOS End Of Life-vägledningen.

GÄLLER FÖR:Python SDK azureml v1

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.

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 läsa in dina data i notebook-filen 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:

Kommentar

Vissa datamängdsklasser har beroenden för azureml-dataprep-paketet . För Linux-användare stöds dessa klasser endast på följande distributioner: Red Hat Enterprise Linux, Ubuntu, Fedora och CentOS.

Använda datauppsättningar i maskininlärningsträningsskript

Om du har strukturerade data som ännu inte har 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 en 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 löser Azure Machine Learning det med ID för datauppsättningen, som du sedan kan använda för att komma åt datauppsättningen i träningsskriptet (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 datauppsättningen i en Pandas-dataram för ytterligare datautforskning och förberedelse före träning.

Kommentar

Om den ursprungliga datakällan innehåller NaN, tomma strängar eller tomma värden ersätts dessa värden som ett Null-värde när du använder to_pandas_dataframe().

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 körning.
  • Träningsskriptet train_titanic.py.
  • Indatauppsättningen för träning, titanic_ds, som ett skriptargument. Azure Machine Learning löser detta med motsvarande ID för datamängden när den skickas till skriptet.
  • Beräkningsmålet för körningen.
  • Miljön för körningen.
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 indatafildatauppsättning, mnist_ds, för dina träningsdata.
  • Anger var du ska skriva träningsresultat och för att höja upp resultaten som en FileDataset.
  • Monterar indatauppsättningen till beräkningsmålet.

Kommentar

Om du använder en anpassad Docker-basavbildning måste du installera fuse via apt-get install -y fuse som ett beroende för att datamängdsmonteringen ska fungera. Lär dig hur du skapar en anpassad build-avbildning.

I notebook-exemplet kan du läsa Så här konfigurerar du en träningskörning med indata och utdata.

Skapa en FileDataset

I följande exempel skapas en oregistrerad FileDataset från mnist_data webb-URL:er. 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-blob
    • Azure-filresurs
    • Azure Data Lake Storage generation 1 och 2
  • Spåra data härstamningen 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 begränsning.

Kommentar

Namnet på nedladdningssökvägen får inte vara längre än 255 alfanumeriska tecken för Windows OS. För Linux OS får namnet på nedladdningssökvägen inte vara längre än 4 096 alfanumeriska tecken. För Linux OS bör filnamnet (som är det sista segmentet i nedladdningssökvägen /path/to/file/{filename}) inte vara längre än 255 alfanumeriska tecken.

Följande kod monteras 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. Använd följande kod för att komma åt din arbetsyta och hämta datauppsättningen som användes i din tidigare skickade körning för att få åtkomst till din registrerade datauppsättning i experimenten. Som standard get_by_name() returnerar metoden i Dataset klassen den senaste versionen av datauppsättningen som är registrerad på 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 skalas till ett stort antal jobb som startas 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

Felsökning

Initieringen av datauppsättningen misslyckades: Tidsgränsen har överskridits om du väntar på att monteringspunkten ska vara klar:

  • Om du inte har några regler för utgående nätverkssäkerhetsgrupp och använder azureml-sdk>=1.12.0, uppdaterar azureml-dataset-runtime och dess beroenden är de senaste för den specifika delversionen, eller om du använder den i en körning, återskapar du din miljö så att den kan ha den senaste korrigeringen med korrigeringen.
  • Om du använder azureml-sdk<1.12.0uppgraderar du till den senaste versionen.
  • Om du har utgående NSG-regler kontrollerar du att det finns en utgående 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å ovan nämnda vägledning ä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 filresurs för andra arbetsbelastningar, till exempel dataöverföring, är rekommendationen att använda blobar så att filresursen kan användas för att skicka körningar.

  • Ett annat alternativ är att 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-portalen.
  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.

Skicka data som indata

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 prefixa arbetskatalogen till exempel /mnt/batch/.../tmp/dataset på beräkningsmålet för att ange var du vill att datauppsättningen ska monteras.

Nästa steg