Creare set di dati di Azure Machine Learning
SI APPLICA A: 
Python SDK azureml 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 altre informazioni sulla modalità di adattamento dei 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.
Quando si crea un set di dati, si inserisce un riferimento alla posizione 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. Inoltre, viene eseguita una valutazione lazy dei set di dati, che consente di migliorare 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 informazioni sull’esperienza con poco codice, vedere Creare set di dati di Azure Machine Learning con studio di Azure Machine Learning.
Con i set di dati di Azure Machine Learning è possibile:
Conservare 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. Per saperne di più sul training dei set di 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:
Una sottoscrizione di Azure. Se non se ne dispone, creare un account gratuito prima di iniziare. Provare la versione gratuita o a pagamento di Azure Machine Learning
SDK di Azure Machine Learning per Python installato, che include il pacchetto azureml-datasets
Creare un’istanza di ambiente di calcolo di Azure Machine Learning, un ambiente di sviluppo completamente configurato e gestito che include notebook integrati e l'SDK già installato
OPPURE
Usare il notebook di Jupyter e installare manualmente l'SDK
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 da distribuzioni specifiche. Per altre informazioni sulle distribuzioni supportate, leggere 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 che non è supportata dalla versione mainstream. Le distribuzioni che non sono supportate dalla versione mainstream possono presentare 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 a quelle 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.
I dati compressi possono espandersi ulteriormente. Venti GB di dati relativamente sparsi archiviati in un 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.
Per saperne di più, vedere 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 vengono usati dagli utenti nel training: oggetti FileDataset e oggetti TabularDataset. I flussi di lavoro di training di Azure Machine Learning che coinvolgono valutatori, AutoML, hyperDrive e pipeline possono usare entrambi i tipi.
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 apprendimento automatico, perché i file di origine possono essere di qualsiasi formato. Ciò consente una gamma più ampia di scenari di apprendimento automatico, incluso il Deep Learning.
Creare un oggetto FileDataset con l’SDK di Python o studio di Azure Machine Learning.
TabularDataset
Un oggettoTabularDataset analizza il file o l'elenco di file fornito, per rappresentare i dati in un formato tabulare. È quindi possibile materializzare i dati in un dataframe Pandas o Spark, per lavorare con librerie di preparazione e training dei dati familiari rimanendo nel notebook. È possibile creare un TabularDataset oggetto a partire da file in linea .csv, .tsv, .parquet, .json e dai risultati di una query SQL.
Con gli oggetti TabularDataset, è possibile specificare un indicatore data/ora a partire da una colonna dei dati o dalla posizione in cui vengono archiviati i dati del modello di percorso, in modo da abilitare un tratto delle serie temporali. Questa specifica consente un filtraggio semplice ed efficiente in base al tempo. Per un esempio, visitare 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.
Inoltre, per gli oggetti TabularDataset generati dai risultati delle query SQL, i T-SQL (ad esempio, la query secondaria "WITH") o i nomi di colonna duplicati non sono supportati. Le query T-SQL complesse 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, visitare Proteggere un'area di lavoro e le risorse associate.
Creare set di dati da archivi dati
Per rendere accessibili i dati da Azure Machine Learning, è necessario creare set di dati dai percorsi negli URL web o negli archivi dati di Azure Machine Learning.
Suggerimento
È possibile creare set di dati direttamente dagli URL di archiviazione con accesso ai dati basato sull'identità. Per altre informazioni, visitare 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:
Verificare di disporre degli accessi
contributoroowneral servizio di archiviazione sottostante dell'archivio dati di Azure Machine Learning registrato. Controllare le autorizzazioni dell'account di archiviazione nel portale di Azure.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 è previsto alcun limite rigido per quanto riguarda il numero di file o la dimensione dei 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. Per ottenere prestazioni ottimali, è consigliabile creare set di dati che fanno riferimento a meno di 100 percorsi negli archivi dati.
Creare un 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 al di sotto di 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. Per altre informazioni, visitare Usare archivi dati e set di dati in una rete virtuale.
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)
Per caricare tutti i file da una directory locale, creare un oggetto FileDataset in un singolo metodo con upload_directory(). Tale metodo carica i dati nella risorsa di archiviazione sottostante, con conseguenti 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 tra gli esperimenti 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 nel formato .parquet, usare il metodo from_parquet_files(). Se si legge da più file, i risultati vengono aggregati in una rappresentazione tabulare.
Per informazioni sui formati di file supportati, visitare la documentazione di riferimento relativa all’oggetto TabularDatasetFactory e le informazioni sui modelli di sintassi e di progettazione, ad esempio sul supporto delle multilinee.
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. Per altre informazioni sulle risorse di archiviazione dei dati sottostanti una rete virtuale o un firewall, visitare Archivi dati e set di dati in una rete virtuale.
Il codice 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 denominato 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
Quando si crea un oggetto TabularDataset, i tipi di dati delle colonne vengono dedotti automaticamente per impostazione predefinita. Se i tipi dedotti non corrispondono alle aspettative, è possibile specificare i tipi di colonna con il codice seguente per aggiornare il set di dati. Il parametro infer_column_type è applicabile solo per i set di dati creati da file delimitati. Per saperne di più, visitare 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’esplorazionedei dati, prima di eseguire il training del modello. Potrebbe non essere necessario eseguire alcun data wrangling o esplorazione dei dati. In tal caso, per altre informazioni su come usare i set di dati negli script di training per gli invii di esperimenti di Machine Learning, visitareEseguire il training con i set di dati.
Filtrare i set di dati (anteprima)
Le funzionalità di filtro dipendono dal tipo di set di dati disponibile.
Importante
Il filtraggio dei set di dati con il filter()metodo di anteprima è una funzionalità di anteprima sperimentale e può cambiare in qualsiasi momento.
Per gli 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).
Questi esempi 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))
Negli oggetti FileDataset, ogni riga corrisponde a un percorso di un file, pertanto il filtro in base al valore di colonna non è utile. Tuttavia, è possibile filtrare() le righe in base ai metadati, ad esempio CreationTime, Size e così via. Questi esempi 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 set di dati, è possibile filtrare() le immagini in base ai metadati e ai valori della colonna 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
Per partizionare un set di dati, includere 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 e continuare fino alla fine del percorso del file.
Ad esempio, dato il percorso ../Accounts/2019/01/01/data.jsonl, in cui la partizione avviene in base a nome e ora del reparto, il 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 dispongono già di 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().
Questo esempio
- Crea un oggetto FileDataset da file partizionati
- Ottiene le chiavi di partizione
- Crea un nuovo oggetto FileDataset indicizzato
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 gli oggetti TabularDataset 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']
Esplorazione dei dati
Dopo aver completato il data wrangling, è possibile registrare il set di dati e quindi caricarlo nel notebook per l’esplorazione dei dati prima di eseguire il 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. Per altre informazioni, visitare Altre informazioni su montaggio e 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(). Tale metodo registra l’oggetto TabularDataset nell'area di lavoro e carica i dati nella risorsa di archiviazione sottostante. Questo processo 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, in modo da condividerli con altri utenti e riutilizzarli per gli 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
In microsoft.machinelearningservices sono disponibili molti modelli che possono essere usati per creare set di dati.
Per informazioni su questi modelli, visitareUsare 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 può contrassegnare lo stato dei dati, in modo da applicare una versione specifica dello stesso per la sperimentazione o la riproduzione futura. Per altre informazioni, visitare Versioni del 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
- Informazioni su come eseguire il training con i set di dati
- Usare Machine Learning automatizzato per eseguire il training con oggetti TabularDataset
- Per altri esempi di training del set di dati, vedere i notebook di esempio