Dela via

Skapa Azure Machine Learning-datamängder

  • Artikel

GÄLLER FÖR: Python SDK azureml v1

I den här artikeln får du lära dig hur du skapar Azure Machine Learning-datauppsättningar för att komma åt data för dina lokala experiment eller fjärrexperiment med Azure Machine Learning Python SDK. Mer information om hur datauppsättningar får plats i Azure Machine Learnings övergripande arbetsflöde för dataåtkomst finns i artikeln Om säker åtkomst till data .

När du skapar en datauppsättning skapar du en referens till datakällans plats, tillsammans med en kopia av dess metadata. Eftersom data finns kvar på den befintliga platsen medför du ingen extra lagringskostnad och du riskerar inte integriteten för dina datakällor. Dessutom utvärderas datauppsättningar lättsamt, vilket hjälper till att förbättra arbetsflödets prestandahastigheter. Du kan skapa datauppsättningar från datalager, offentliga URL:er och Azure Open Datasets. Information om en lågkodsupplevelse finns i Skapa Azure Machine Learning-datauppsättningar med Azure Machine Learning-studio.

Med Azure Machine Learning-datauppsättningar kan du:

  • Behåll en enda kopia av data i din lagring, som refereras av datauppsättningar

  • Få sömlös åtkomst till data under modellträningen utan att bekymra dig om anslutningssträng eller datasökvägar. Mer information om datamängdsträning finns i Läs mer om hur du tränar med datauppsättningar

  • Dela data och samarbeta med andra användare

Viktigt!

Objekt i den här artikeln som har markerats som "förhandsversion" finns för närvarande i offentlig förhandsversion. Förhandsversionen tillhandahålls utan ett serviceavtal och rekommenderas 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.

Förutsättningar

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

Kommentar

Vissa datamängdsklasser har beroenden för azureml-dataprep-paketet , som endast är kompatibelt med 64-bitars Python. Om du utvecklar på Linux förlitar sig dessa klasser på .NET Core 2.1, och endast specifika distributioner stöder dem. Mer information om de distributioner som stöds finns i kolumnen .NET Core 2.1 i artikeln Installera .NET på Linux .

Viktigt!

Även om paketet kan fungera med äldre versioner av Linux-distributioner rekommenderar vi inte att du använder en distribution som inte har mainstream-stöd. Distributioner som inte har mainstream-stöd kan ha säkerhetsrisker, eftersom de inte får de senaste uppdateringarna. Vi rekommenderar att du använder den senaste versionen av din distribution som är kompatibel med .

Vägledning för beräkningsstorlek

När du skapar en datauppsättning granskar du beräkningsbearbetningskraften och storleken på dina data i minnet. Storleken på dina data i lagringen är inte samma som storleken på data i en dataram. Till exempel kan data i CSV-filer expandera upp till 10 gånger i en dataram, så att en CSV-fil på 1 GB kan bli 10 GB i en dataram.

Komprimerade data kan expanderas ytterligare. Tjugo GB relativt glesa data som lagras i ett komprimerat parquet-format kan utökas till ~800 GB i minnet. Eftersom Parquet-filer lagrar data i ett kolumnformat behöver du bara läsa in ~400 GB i minnet om du bara behöver hälften av kolumnerna.

Mer information finns i Läs mer om hur du optimerar databehandling i Azure Machine Learning.

Datamängdstyper

Det finns två typer av datamängder, baserat på hur användare använder datauppsättningar i träning: FileDatasets och TabularDatasets. Azure Machine Learning-träningsarbetsflöden som omfattar skattningar, AutoML, hyperDrive och pipelines kan använda båda typerna.

FileDataset

En FileDataset refererar till en eller flera filer i dina datalager eller offentliga URL:er. Om dina data redan har rensats och är redo att användas i träningsexperiment kan du ladda ned eller montera filerna till din beräkning som ett FileDataset-objekt.

Vi rekommenderar FileDatasets för dina maskininlärningsarbetsflöden eftersom källfilerna kan vara i valfritt format. Detta möjliggör ett bredare utbud av maskininlärningsscenarier, inklusive djupinlärning.

Skapa en FileDataset med Python SDK eller Azure Machine Learning-studio.

TabularDataset

En TabularDataset parsar den angivna filen eller listan med filer för att representera data i tabellformat. Du kan sedan materialisera data till en Pandas eller Spark DataFrame för att arbeta med välbekanta dataförberedelser och träningsbibliotek medan du bor i din notebook-fil. Du kan skapa ett TabularDataset objekt från .csv, .tsv, .parquet, .json rader filer och från SQL-frågeresultat.

Med TabularDatasets kan du ange en tidsstämpel från en kolumn i data, eller från den plats där sökvägsmönsterdata lagras, för att aktivera ett tidsseriedrag. Den här specifikationen möjliggör enkel och effektiv filtrering efter tid. Ett exempel finns i Tabelltidsserierelaterad API-demo med NOAA-väderdata.

Skapa en TabularDataset med Python SDK eller Azure Machine Learning-studio.

Kommentar

Automatiserade ML-arbetsflöden som genereras via Azure Machine Learning-studio stöder för närvarande endast TabularDatasets.

För TabularDatasets som genereras från SQL-frågeresultat stöds inte heller T-SQL (t.ex. "WITH"-underfråga) eller duplicerade kolumnnamn. Komplexa T-SQL-frågor kan orsaka prestandaproblem. Dubbletter av kolumnnamn i en datauppsättning kan orsaka tvetydighetsproblem.

Få åtkomst till datauppsättningar i ett virtuellt nätverk

Om din arbetsyta finns i ett virtuellt nätverk måste du konfigurera datauppsättningen så att den hoppar över valideringen. Mer information om hur du använder datalager och datauppsättningar i ett virtuellt nätverk finns i Skydda en arbetsyta och associerade resurser.

Skapa datauppsättningar från datalager

För att göra data tillgängliga i Azure Machine Learning måste du skapa datauppsättningar från sökvägar i webb-URL:er eller Azure Machine Learning-datalager.

Dricks

Du kan skapa datauppsättningar direkt från lagrings-URL:er med identitetsbaserad dataåtkomst. Mer information finns i Ansluta till lagring med identitetsbaserad dataåtkomst.

Så här skapar du datauppsättningar från ett datalager med Python SDK:

  1. Kontrollera att du har contributor eller owner har åtkomst till den underliggande lagringstjänsten för ditt registrerade Azure Machine Learning-datalager. Kontrollera behörigheterna för ditt lagringskonto i Azure Portal.

  2. Skapa datamängden genom att referera till sökvägar i datalagringen. Du kan skapa en datauppsättning från flera sökvägar i flera datalager. Det finns ingen hård gräns för hur många filer eller datastorlek som du kan skapa en datauppsättning från.

Kommentar

För varje datasökväg skickas några förfrågningar till lagringstjänsten för att kontrollera om den pekar på en fil eller en mapp. Den här kostnaden kan leda till försämrade prestanda eller fel. En datauppsättning som refererar till en mapp med 1 000 filer inuti anses referera till en datasökväg. För optimala prestanda rekommenderar vi att du skapar datauppsättningar som refererar till färre än 100 sökvägar i datalager.

Skapa ett FileDataset

from_files() Använd -metoden i FileDatasetFactory klassen för att läsa in filer i valfritt format och för att skapa en oregistrerad FileDataset.

Om lagringen finns bakom ett virtuellt nätverk eller en brandvägg anger du parametern validate=False from_files() i -metoden. Detta kringgår det första valideringssteget och säkerställer att du kan skapa din datauppsättning från dessa säkra filer. Mer information finns i Använda datalager och datauppsättningar i ett virtuellt nätverk.

from azureml.core import Workspace, Datastore, Dataset

# create a FileDataset recursively pointing to files in 'animals' folder and its subfolder
datastore_paths = [(datastore, 'animals')]
animal_ds = Dataset.File.from_files(path=datastore_paths)

# create a FileDataset from image and label files behind public web urls
web_paths = ['https://azureopendatastorage.blob.core.windows.net/mnist/train-images-idx3-ubyte.gz',
             'https://azureopendatastorage.blob.core.windows.net/mnist/train-labels-idx1-ubyte.gz']
mnist_ds = Dataset.File.from_files(path=web_paths)

Om du vill ladda upp alla filer från en lokal katalog skapar du en FileDataset i en enda metod med upload_directory(). Den här metoden laddar upp data till din underliggande lagring och därmed medför du lagringskostnader.

from azureml.core import Workspace, Datastore, Dataset
from azureml.data.datapath import DataPath

ws = Workspace.from_config()
datastore = Datastore.get(ws, '<name of your datastore>')
ds = Dataset.File.upload_directory(src_dir='<path to you data>',
           target=DataPath(datastore,  '<path on the datastore>'),
           show_progress=True)

Om du vill återanvända och dela datamängder mellan experiment på din arbetsyta registrerar du din datauppsättning.

Skapa ett TabularDataset

from_delimited_files() Använd -metoden i TabularDatasetFactory klassen för att läsa filer i .csv- eller .tsv-format och för att skapa en oregistrerad TabularDataset. Om du vill läsa i filer från .parquet format använder du from_parquet_files() metoden . Om du läser från flera filer aggregeras resultaten till en tabellrepresentation.

Information om filformat som stöds finns i referensdokumentationen för TabularDatasetFactory och information om syntax- och designmönster som stöd för flera flöden.

Om lagringen finns bakom ett virtuellt nätverk eller en brandvägg anger du parametern validate=False i din from_delimited_files() metod. Detta kringgår det första valideringssteget och säkerställer att du kan skapa din datauppsättning från dessa säkra filer. Mer information om datalagringsresurser bakom ett virtuellt nätverk eller en brandvägg finns i datalager och datauppsättningar i ett virtuellt nätverk.

Den här koden hämtar den befintliga arbetsytan och det önskade datalagret efter namn. Sedan skickas datalager- och filplatserna till parametern path för att skapa en ny TabularDataset med namnet weather_ds:

from azureml.core import Workspace, Datastore, Dataset

datastore_name = 'your datastore name'

# get existing workspace
workspace = Workspace.from_config()
    
# retrieve an existing datastore in the workspace by name
datastore = Datastore.get(workspace, datastore_name)

# create a TabularDataset from 3 file paths in datastore
datastore_paths = [(datastore, 'weather/2018/11.csv'),
                   (datastore, 'weather/2018/12.csv'),
                   (datastore, 'weather/2019/*.csv')]

weather_ds = Dataset.Tabular.from_delimited_files(path=datastore_paths)

Ange dataschema

När du skapar en TabularDataset härleds kolumndatatyper automatiskt som standard. Om de härledda typerna inte matchar dina förväntningar kan du ange kolumntyper med följande kod för att uppdatera datauppsättningen. Parametern infer_column_type gäller endast för datauppsättningar som skapats från avgränsade filer. Mer information finns i Läs mer om datatyper som stöds.

from azureml.core import Dataset
from azureml.data.dataset_factory import DataType

# create a TabularDataset from a delimited file behind a public web url and convert column "Survived" to boolean
web_path ='https://dprepdata.blob.core.windows.net/demo/Titanic.csv'
titanic_ds = Dataset.Tabular.from_delimited_files(path=web_path, set_column_types={'Survived': DataType.to_bool()})

# preview the first 3 rows of titanic_ds
titanic_ds.take(3).to_pandas_dataframe()
(Index) PassengerId Överlevde Pclass Name Kön Ålder SibSp Parch Biljett Biljettpris Hytt Inlett
0 1 Falsk 3 Braund, mr Owen Harris man 22,0 1 0 A/5 21171 7.2500 S
1 2 Sant 1 Cumings, Fru John Bradley (Florence Briggs Th... kvinna 38.0 1 0 PC 17599 71.2833 C85 C
2 3 Sant 3 Heikkinen, fröken. Laina kvinna 26,0 0 0 STON/O2. 3101282 7.9250 S

Om du vill återanvända och dela datamängder mellan experiment på din arbetsyta registrerar du din datauppsättning.

Wrangle-data

När du har skapat och registrerat din datauppsättning kan du läsa in datauppsättningen i notebook-filen för dataomvandling och utforskning, före modellträning. Du kanske inte behöver göra några dataomvandlingar eller utforskningar. Om du vill ha mer information om hur du använder datamängder i dina träningsskript för ML-experimentinlämningar kan du gå till Träna med datauppsättningar.

Filtrera datamängder (förhandsversion)

Filtreringsfunktionerna beror på vilken typ av datauppsättning du har.

Viktigt!

Att filtrera datauppsättningar med filter() förhandsgranskningsmetoden är en experimentell förhandsversionsfunktion och kan ändras när som helst.

För TabularDatasets kan du behålla eller ta bort kolumner med metoderna keep_columns() och drop_columns().

Om du vill filtrera bort rader efter ett specifikt kolumnvärde i en TabularDataset använder du metoden filter() (förhandsversion).

De här exemplen returnerar en oregistrerad datauppsättning baserat på de angivna uttrycken:

# TabularDataset that only contains records where the age column value is greater than 15
tabular_dataset = tabular_dataset.filter(tabular_dataset['age'] > 15)

# TabularDataset that contains records where the name column value contains 'Bri' and the age column value is greater than 15
tabular_dataset = tabular_dataset.filter((tabular_dataset['name'].contains('Bri')) & (tabular_dataset['age'] > 15))

I FileDatasets motsvarar varje rad en sökväg för en fil, så filtrering efter kolumnvärde hjälper inte. Du kan dock filtrera() rader efter metadata – till exempel CreationTime, Size osv. De här exemplen returnerar en oregistrerad datauppsättning baserat på de angivna uttrycken:

# FileDataset that only contains files where Size is less than 100000
file_dataset = file_dataset.filter(file_dataset.file_metadata['Size'] < 100000)

# FileDataset that only contains files that were either created prior to Jan 1, 2020 or where 
file_dataset = file_dataset.filter((file_dataset.file_metadata['CreatedTime'] < datetime(2020,1,1)) | (file_dataset.file_metadata['CanSeek'] == False))

Etiketterade datauppsättningar som skapats från bildetikettprojekt är ett specialfall. Dessa datauppsättningar är en typ av TabularDataset som består av bildfiler. För dessa datauppsättningar kan du filtrera() bilder efter metadata och label efter- och image_details kolumnvärden.

# Dataset that only contains records where the label column value is dog
labeled_dataset = labeled_dataset.filter(labeled_dataset['label'] == 'dog')

# Dataset that only contains records where the label and isCrowd columns are True and where the file size is larger than 100000
labeled_dataset = labeled_dataset.filter((labeled_dataset['label']['isCrowd'] == True) & (labeled_dataset.file_metadata['Size'] > 100000))

Partitionera data

Om du vill partitionera en datauppsättning tar du med parametern partitions_format när du skapar en TabularDataset eller FileDataset.

När du partitionerade en datauppsättning extraheras partitionsinformationen för varje filsökväg till kolumner baserat på det angivna formatet. Formatet ska börja från positionen för den första partitionsnyckeln och fortsätta till slutet av filsökvägen.

Till exempel, med tanke på sökvägen ../Accounts/2019/01/01/data.jsonl, där partitionen är efter avdelningsnamn och tid, skapar strängkolumnen partition_format='/{Department}/{PartitionDate:yyyy/MM/dd}/data.jsonl' "Avdelning" med värdet "Konton" och en datetime-kolumn "PartitionDate" med värdet 2019-01-01.

Om dina data redan har befintliga partitioner och du vill bevara det formatet ska du inkludera parametern partitioned_format i din from_files() metod för att skapa en FileDataset.

Om du vill skapa en TabularDataset som bevarar befintliga partitioner tar du med parametern partitioned_format from_parquet_files() i -metoden eller from_delimited_files() .

Det här exemplet

  • Skapar en FileDataset från partitionerade filer
  • Hämtar partitionsnycklarna
  • Skapar en ny, indexerad FileDataset

file_dataset = Dataset.File.from_files(data_paths, partition_format = '{userid}/*.wav')
ds.register(name='speech_dataset')

# access partition_keys
indexes = file_dataset.partition_keys # ['userid']

# get all partition key value pairs should return [{'userid': 'user1'}, {'userid': 'user2'}]
partitions = file_dataset.get_partition_key_values()


partitions = file_dataset.get_partition_key_values(['userid'])
# return [{'userid': 'user1'}, {'userid': 'user2'}]

# filter API, this will only download data from user1/ folder
new_file_dataset = file_dataset.filter(ds['userid'] == 'user1').download()

Du kan också skapa en ny partitionsstruktur för TabularDatasets med metoden partition_by().


 dataset = Dataset.get_by_name('test') # indexed by country, state, partition_date

# call partition_by locally
new_dataset = ds.partition_by(name="repartitioned_ds", partition_keys=['country'], target=DataPath(datastore, "repartition"))
partition_keys = new_dataset.partition_keys # ['country']

Utforska data

När du har skapat dina data kan du registrera datauppsättningen och sedan läsa in den i anteckningsboken för datautforskning före modellträning.

För FileDatasets kan du antingen montera eller ladda ned din datauppsättning och tillämpa De Python-bibliotek som du normalt använder för datautforskning. Mer information finns i Läs mer om montering kontra nedladdning.

# download the dataset 
dataset.download(target_path='.', overwrite=False) 

# mount dataset to the temp directory at `mounted_path`

import tempfile
mounted_path = tempfile.mkdtemp()
mount_context = dataset.mount(mounted_path)

mount_context.start()

För TabularDatasets använder du to_pandas_dataframe() metoden för att visa dina data i en dataram.

# preview the first 3 rows of titanic_ds
titanic_ds.take(3).to_pandas_dataframe()
(Index) PassengerId Överlevde Pclass Name Kön Ålder SibSp Parch Biljett Biljettpris Hytt Inlett
0 1 Falsk 3 Braund, mr Owen Harris man 22,0 1 0 A/5 21171 7.2500 S
1 2 Sant 1 Cumings, Fru John Bradley (Florence Briggs Th... kvinna 38.0 1 0 PC 17599 71.2833 C85 C
2 3 Sant 3 Heikkinen, fröken. Laina kvinna 26,0 0 0 STON/O2. 3101282 7.9250 S

Skapa en datauppsättning från pandas-dataramen

Om du vill skapa en TabularDataset från en minnesintern Pandas-dataram använder du register_pandas_dataframe() metoden. Den här metoden registrerar TabularDataset på arbetsytan och överför data till din underliggande lagring. Den här processen medför lagringskostnader.

from azureml.core import Workspace, Datastore, Dataset
import pandas as pd

pandas_df = pd.read_csv('<path to your csv file>')
ws = Workspace.from_config()
datastore = Datastore.get(ws, '<name of your datastore>')
dataset = Dataset.Tabular.register_pandas_dataframe(pandas_df, datastore, "dataset_from_pandas_df", show_progress=True)

Dricks

Skapa och registrera en TabularDataset från en spark-dataram i minnet eller en dask-dataram med metoderna register_spark_dataframe() för offentlig förhandsversion och register_dask_dataframe(). Dessa metoder är experimentella förhandsversionsfunktioner och kan ändras när som helst.

Dessa metoder laddar upp data till din underliggande lagring och medför därmed lagringskostnader.

Registrera datauppsättningar

För att slutföra skapandeprocessen registrerar du dina datauppsättningar med en arbetsyta. Använd metoden register() för att registrera datauppsättningar med din arbetsyta, för att dela dem med andra och återanvända dem i experiment på din arbetsyta:

titanic_ds = titanic_ds.register(workspace=workspace,
                                 name='titanic_ds',
                                 description='titanic training data')

Skapa datauppsättningar med Azure Resource Manager

Du hittar många mallar på microsoft.machinelearningservices som kan användas för att skapa datauppsättningar.

Information om dessa mallar finns i Använda en Azure Resource Manager-mall för att skapa en arbetsyta för Azure Machine Learning.

Träna med datauppsättningar

Använd dina datamängder i dina maskininlärningsexperiment för att träna ML-modeller. Läs mer om hur du tränar med datauppsättningar.

Versionsdatauppsättningar

Du kan registrera en ny datauppsättning under samma namn genom att skapa en ny version. En datamängdsversion kan bokmrätta tillståndet för dina data för att tillämpa en specifik version av datamängden för experimentering eller framtida reproduktion. Mer information finns i datauppsättningsversioner.

# create a TabularDataset from Titanic training data
web_paths = ['https://dprepdata.blob.core.windows.net/demo/Titanic.csv',
             'https://dprepdata.blob.core.windows.net/demo/Titanic2.csv']
titanic_ds = Dataset.Tabular.from_delimited_files(path=web_paths)

# create a new version of titanic_ds
titanic_ds = titanic_ds.register(workspace = workspace,
                                 name = 'titanic_ds',
                                 description = 'new titanic training data',
                                 create_new_version = True)

Nästa steg