Condividi tramite

Creare set di dati di Azure Machine Learning

  • Articolo

SI APPLICA A:azureml del Software Development Kit (SDK) di Python v1

Questo articolo illustra come creare set di dati di Azure Machine Learning per accedere a dati per gli esperimenti locali o remoti con l’SDK di Python di Azure Machine Learning. Per comprendere dove si trovano i set di dati nel flusso di lavoro complessivo di accesso ai dati di Azure Machine Learning, vedere l'articolo Accedere ai dati in modo sicuro.

Creando un set di dati, si crea un riferimento al percorso dell'origine dati, insieme a una copia dei relativi metadati. Poiché i dati rimangono nella posizione esistente, non è possibile incorrere in addebiti per costi di archiviazione aggiuntivi e non si rischia l'integrità delle origini dati. Viene inoltre eseguita una valutazione lazy dei set di dati, che facilita la velocità delle prestazioni del flusso di lavoro. È possibile creare set di dati da archivi dati, URL pubblici e set di dati aperti di Azure.

Per un'esperienza con poco codice, Creare set di dati di Azure Machine Learning con studio di Azure Machine Learning.

Con i set di dati di Azure Machine Learning è possibile:

  • Mantenere una singola copia dei dati nella risorsa di archiviazione, a cui fanno riferimento i set di dati.

  • Accedere facilmente ai dati durante il training del modello senza preoccuparsi delle stringhe di connessione o dei percorsi dati. Vedere altre informazioni su come eseguire il training con i set di dati.

  • Condividere i dati e collaborare con altri utenti.

Importante

Gli elementi in questo articolo contrassegnati come “anteprima” sono attualmente in anteprima pubblica. La versione di anteprima viene messa a disposizione senza contratto di servizio e non è consigliata per i carichi di lavoro di produzione. Alcune funzionalità potrebbero non essere supportate o potrebbero presentare funzionalità limitate. Per altre informazioni, vedere le Condizioni supplementari per l'uso delle anteprime di Microsoft Azure.

Prerequisiti

Per creare e usare set di dati, è necessario:

Nota

Alcune classi di set di dati hanno dipendenze dal pacchetto azureml-dataprep, compatibile solo con Python a 64 bit. Se si sviluppa in Linux, queste classi si basano su .NET Core 2.1 e sono supportate solo in distribuzioni specifiche. Per altre informazioni sulle distribuzioni supportate, vedere la colonna .NET Core 2.1 nell'articolo Installare .NET in Linux.

Importante

Anche se il pacchetto può funzionare nelle versioni precedenti delle distribuzioni Linux, non è consigliabile usare una distribuzione fuori dal supporto Mainstream. Le distribuzioni fuori dal supporto Mainstream potrebbero avere vulnerabilità di sicurezza, perché non ricevono gli aggiornamenti più recenti. È consigliabile usare la versione più recente supportata della distribuzione compatibile con .

Indicazioni sulle dimensioni di calcolo

Quando si crea un set di dati, esaminare la potenza di elaborazione di calcolo e le dimensioni dei dati in memoria. Le dimensioni dei dati nella risorsa di archiviazione non corrispondono alle dimensioni dei dati in un DataFrame. Ad esempio, i dati nei file CSV possono espandersi fino a 10 volte in un DataFrame, in modo che un file CSV da 1 GB possa diventare 10 GB in un DataFrame.

Se i dati sono compressi, possono espandersi ulteriormente; 20 GB di dati relativamente sparse archiviati in formato Parquet compresso possono espandersi fino a circa 800 GB in memoria. Poiché i file Parquet archiviano i dati in un formato a colonne, se sono necessarie solo la metà delle colonne, è sufficiente caricare circa 400 GB in memoria.

Altre informazioni sull'ottimizzazione dell'elaborazione dei dati in Azure Machine Learning.

Tipi di set di dati

Esistono due tipi di set di dati, in base al modo in cui gli utenti li usano nel training: oggetti FileDataset e TabularDataset. Entrambi i tipi possono essere usati nei flussi di lavoro di training di Azure Machine Learning che coinvolgono, estimatori, AutoML, hyperDrive e pipeline.

FileDataset

Un FileDataset fa riferimento a uno o più file negli archivi dati o negli URL pubblici. Se i dati sono già puliti e pronti per l'uso negli esperimenti di training, è possibile scaricare o montare i file nell’ambiente di calcolo come oggetto FileDataset.

È consigliabile usare oggetti FileDataset per i flussi di lavoro di Machine Learning, poiché i file di origine possono essere in qualsiasi formato, che consente una gamma più ampia di scenari di Machine Learning, incluso il Deep Learning.

Creare un oggetto FileDataset con l’SDK di Python o studio di Azure Machine Learning .

TabularDataset

Un oggetto TabularDataset rappresenta i dati in un formato tabulare analizzando il file o l'elenco di file forniti. In questo modo è possibile materializzare i dati in un DataFrame Pandas o Spark, in modo da poter usare librerie di preparazione dei dati e di training familiari senza dover uscire dal notebook. È possibile creare un oggetto TabularDataset da file .csv, tsv, .parquet, .jsonl e dai risultati della query SQL.

Con il tipo di set di dati TabularDataset è possibile specificare un timestamp da una colonna nei dati o da qualsiasi posizione in cui vengono archiviati i dati del modello di percorso per abilitare un tratto della serie temporale. Questa specifica consente di filtrare in modo semplice ed efficiente in base al tempo. Ad esempio, vedere Demo dell'API relativa alle serie temporali tabulari con i dati meteorologici NOAA.

Creare un oggetto TabularDataset con l’SDK di Python o studio di Azure Machine Learning.

Nota

I flussi di lavoro automatizzati di Machine Learning generati tramite studio di Azure Machine Learning supportano attualmente solo oggetti TabularDataset.

Nota

Oggetti TabularDataset generati da risultati di query SQL, T-SQL (ad esempio, la sottoquery 'WITH') o il nome di colonna duplicato non sono supportati. Le query complesse come T-SQL possono causare problemi di prestazioni. I nomi di colonna duplicati in un set di dati possono causare problemi di ambiguità.

Accedere ai set di dati in una rete virtuale

Se l'area di lavoro si trova in una rete virtuale, è necessario configurare il set di dati per ignorare la convalida. Per altre informazioni su come usare archivi dati e set di dati in una rete virtuale, vedere Proteggere un'area di lavoro e le risorse associate.

Creare set di dati da archivi dati

Affinché i dati siano accessibili da Azure Machine Learning, i set di dati devono essere creati da percorsi in archivi dati di Azure Machine Learning o URL Web.

Suggerimento

È possibile creare set di dati direttamente dagli URL di archiviazione con accesso ai dati basato sull'identità. Per altre informazioni, vedere Connettersi alla risorsa di archiviazione con l'accesso ai dati basato sull'identità.

Per creare set di dati da un archivio dati con l’SDK di Python:

  1. Verificare di disporre degli accessi contributor o owner al servizio di archiviazione sottostante dell'archivio dati di Azure Machine Learning registrato. Controllare le autorizzazioni dell'account di archiviazione nel portale di Azure.

  2. Creare il set di dati facendo riferimento ai percorsi nell'archivio dati. È possibile creare un set di dati da più percorsi in più archivi dati. Non esiste alcun limite rigido per il numero di file o dimensioni di dati da cui è possibile creare un set di dati.

Nota

Per ogni percorso dati, alcune richieste verranno inviate al servizio di archiviazione per verificare se punta a un file o a una cartella. Questo sovraccarico può causare un calo delle prestazioni o degli errori. Un set di dati che fa riferimento a una cartella con 1000 file all'interno viene considerato come facente riferimento a un percorso dati. È consigliabile creare un set di dati che fa riferimento a meno di 100 percorsi negli archivi dati per ottenere prestazioni ottimali.

Creare un oggetto FileDataset

Usare il metodo from_files() nella classe FileDatasetFactory per caricare i file in qualsiasi formato e per creare un oggetto FileDataset non registrato.

Se la risorsa di archiviazione si trova entro una rete virtuale o un firewall, impostare il parametro validate=False nel metodo from_files(). In questo modo viene ignorato il passaggio di convalida iniziale e si garantisce di poter creare il set di dati da questi file protetti. Altre informazioni su come usare archivi dati e set di dati in una rete virtuale.

from azureml.core import Workspace, Datastore, Dataset

# create a FileDataset pointing to files in 'animals' folder and its subfolders recursively
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)

Se si desidera caricare tutti i file da una directory locale, creare un oggetto FileDataset in un singolo metodo con upload_directory(). Questo metodo carica i dati nella risorsa di archiviazione sottostante e di conseguenza comporta costi di archiviazione.

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)

Per riutilizzare e condividere set di dati nell'esperimento nell'area di lavoro, registrare il set di dati.

Creare un oggetto TabularDataset

Utilizzare il metodo from_delimited_files() nella classe TabularDatasetFactory per leggere i file in formato .csv o .tsv e per creare un oggetto TabularDataset non registrato. Per leggere i file dal formato .parquet, usare il metodo from_parquet_files(). Se si legge da più file, i risultati verranno aggregati in una rappresentazione tabulare.

Vedere la documentazione di riferimento TabularDatasetFactory per informazioni sui formati di file supportati, nonché sui modelli di sintassi e progettazione, ad esempio supporto su più righe.

Se la risorsa di archiviazione si trova entro una rete virtuale o un firewall, impostare il parametro validate=False nel metodo from_delimited_files(). In questo modo viene ignorato il passaggio di convalida iniziale e si garantisce di poter creare il set di dati da questi file protetti. Altre informazioni su come usare archivi dati e set di dati in una rete virtuale.

Il codice seguente ottiene l'area di lavoro esistente e l'archivio dati desiderato in base al nome. Passa quindi l'archivio dati e i percorsi dei file al parametro path per creare un nuovo oggetto TabularDataset, 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)

Impostare lo schema dei dati

Per impostazione predefinita, quando si crea un oggetto TabularDataset, i tipi di dati delle colonne vengono dedotti automaticamente. Se i tipi dedotti non corrispondono alle aspettative, è possibile aggiornare lo schema del set di dati specificando i tipi di colonna con il codice seguente. Il parametro infer_column_type è applicabile solo per i set di dati creati da file delimitati. Altre informazioni sui tipi di dati supportati.

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()
(Indice) PassengerId Survived ClasseP Nome Sex Età Coniug GenFi Ticket Tariffe Cabina Porto d’imbarco
0 1 Falso 3 Signor Sagese Diego male 22.0 1 0 A/5 21171 7.2500 S
1 2 Vero 1 Signora Fanucci Giorgia female 38.0 1 0 PC 17599 71.2833 C85 A
2 3 Vero 3 Signorina Costa Pupetta female 26.0 0 0 STON/O2. 3101282 7.9250 S

Per riutilizzare e condividere set di dati tra gli esperimenti nell'area di lavoro, registrare il set di dati.

Eseguire il data wrangling

Dopo aver creato e registrato il set di dati, è possibile caricarlo nel notebook per il data wrangling e l’esplorazione prima del training del modello.

Se non è necessario eseguire operazioni di data wrangling o di esplorazione, vedere come usare i set di dati negli script di training per inviare esperimenti di Machine Learning in Eseguire il training con set di dati.

Filtrare i set di dati (anteprima)

Le funzionalità di filtro dipendono dal tipo di set di dati disponibile.

Importante

Il filtro dei set di dati con il metodo di anteprima filter() è una funzionalità di anteprima sperimentale e può cambiare in qualsiasi momento.

Per oggetti TabularDataset, è possibile mantenere o rimuovere colonne con i metodi keep_columns e drop_columns().

Per filtrare le righe in base a un valore di colonna specifico in un oggetto TabularDataset, usare il metodo filter() (anteprima).

Gli esempi seguenti restituiscono un set di dati non registrato in base alle espressioni specificate.

# 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))

In un oggetto FileDatasets, ogni riga corrisponde a un percorso di un file, pertanto il filtro in base al valore di colonna non è utile. Tuttavia, è possibile usare filter() per filtrare le righe in base ai metadati, ad esempio CreationTime, Size e così via.

Gli esempi seguenti restituiscono un set di dati non registrato in base alle espressioni specificate.

# 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))

I set di dati etichettati creati da progetti di etichettatura di immagini sono un caso speciale. Questi set di dati sono un tipo di oggetto TabularDataset costituito da file di immagine. Per questi tipi di set di dati, è possibile usare filter() per filtrare immagini in base ai metadati e ai valori di colonna, ad esempio label e image_details.

# 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))

Dati di partizione

È possibile partizionare un set di dati includendo il parametro partitions_format durante la creazione di un oggetto TabularDataset o FileDataset.

Quando si partiziona un set di dati, le informazioni sulla partizione di ogni percorso di file vengono estratte in colonne in base al formato specificato. Il formato deve iniziare dalla posizione della prima chiave di partizione fino alla fine del percorso del file.

Ad esempio, dato il percorso ../Accounts/2019/01/01/data.jsonl in cui la partizione è in base al nome e all'ora del reparto; partition_format='/{Department}/{PartitionDate:yyyy/MM/dd}/data.jsonl' crea una colonna stringa 'Reparto' con il valore 'Account' e una colonna datetime 'PartitionDate' con il valore 2019-01-01.

Se i dati presentano partizioni esistenti e si vuole mantenere tale formato, includere il parametro partitioned_format nel metodo from_files() per creare un oggetto FileDataset.

Per creare un oggetto TabularDataset che mantiene le partizioni esistenti, includere il parametro partitioned_format nel metodo from_parquet_files() o from_delimited_files().

L'esempio seguente:

  • Crea un oggetto FileDataset da file partizionati.
  • Ottiene le chiavi di partizione
  • Crea un nuovo oggetto FileDataset indicizzato usando

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()

È anche possibile creare una nuova struttura di partizioni per TabularDatasets con il metodo partitions_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']

Esplorare i dati

Dopo aver completato il data wrangling, è possibile registrare il set di dati e quindi caricarli nel notebook per l'esplorazione dei dati prima del training del modello.

Per l’oggetto FileDataset, è possibile montare o scaricare il set di dati e applicare le librerie Python usate normalmente per l'esplorazione dei dati. Altre informazioni sul montaggio e sul download.

# 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()

Per l’oggetto TabularDataset, usare il metodo to_pandas_dataframe() per visualizzare i dati in un DataFrame.

# preview the first 3 rows of titanic_ds
titanic_ds.take(3).to_pandas_dataframe()
(Indice) PassengerId Survived ClasseP Nome Sex Età Coniug GenFi Ticket Tariffe Cabina Porto d’imbarco
0 1 Falso 3 Signor Sagese Diego male 22.0 1 0 A/5 21171 7.2500 S
1 2 Vero 1 Signora Fanucci Giorgia female 38.0 1 0 PC 17599 71.2833 C85 A
2 3 Vero 3 Signorina Costa Pupetta female 26.0 0 0 STON/O2. 3101282 7.9250 S

Creare un set di dati da un DataFrame Pandas

Per creare un oggetto TabularDataset da un DataFrame Pandas in memoria, usare il metodo register_pandas_dataframe(). Questo metodo registra l’oggetto TabularDataset nell'area di lavoro e carica i dati nella risorsa di archiviazione sottostante, che comporta costi di archiviazione.

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)

Suggerimento

Creare e registrare un oggetto TabularDataset da un DataFrame Spark o un DataFrame Dask in memoria con i metodi di anteprima pubblica, register_spark_dataframe() e register_dask_dataframe(). Questi metodi sono funzionalità di anteprima sperimentali e possono cambiare in qualsiasi momento.

Caricano i dati nella risorsa di archiviazione sottostante e di conseguenza comportano costi di archiviazione.

Registrare i set di dati

Per completare il processo di creazione, registrare i set di dati con un'area di lavoro. Usare il metodo register() per registrare i set di dati nell'area di lavoro per condividerli con altri utenti e riutilizzarli tra esperimenti nell'area di lavoro:

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

Creare set di dati con Azure Resource Manager

Sono presenti molti modelli nella pagina https://github.com/Azure/azure-quickstart-templates/tree/master//quickstarts/microsoft.machinelearningservices che possono essere usati per creare set di dati.

Per informazioni sull'uso di questi modelli, vedere Usare un modello di Azure Resource Manager per creare un'area di lavoro per Azure Machine Learning.

Eseguire il training con set di dati

Usare i set di dati negli esperimenti di Machine Learning per il training dei modelli di Machine Learning. Vedere altre informazioni su come eseguire il training con i set di dati.

Set di dati delle versioni

È possibile registrare un nuovo set di dati con lo stesso nome creando una nuova versione. Una versione del set di dati è un modo per aggiungere un segnalibro allo stato dei dati in modo da poter applicare una versione specifica del set di dati per la sperimentazione o la riproduzione futura. Altre informazioni sulle versioni dei set di dati.

# 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)

Passaggi successivi