Criar conjuntos de dados do Azure Machine Learning

APLICA-SE A: Python SDK azureml v1

Neste artigo, você aprenderá a criar conjuntos de dados do Azure Machine Learning para acessar dados para seus experimentos locais ou remotos com o SDK Python do Azure Machine Learning. Para obter mais informações sobre como os conjuntos de dados se ajustam ao fluxo de trabalho geral de acesso a dados do Azure Machine Learning, visite o artigo Acesso seguro aos dados .

Ao criar um conjunto de dados, você cria uma referência ao local da fonte de dados, juntamente com uma cópia de seus metadados. Como os dados permanecem em seu local existente, você não incorre em nenhum custo adicional de armazenamento e não arrisca a integridade de suas fontes de dados. Além disso, os conjuntos de dados são avaliados com preguiça, o que ajuda a melhorar as velocidades de desempenho do fluxo de trabalho. Você pode criar conjuntos de dados a partir de armazenamentos de dados, URLs públicas e Conjuntos de Dados Abertos do Azure. Para obter informações sobre uma experiência low-code, visite Criar conjuntos de dados do Azure Machine Learning com o estúdio do Azure Machine Learning.

Com os conjuntos de dados do Azure Machine Learning, você pode:

• Mantenha uma única cópia dos dados em seu armazenamento, referenciada por conjuntos de dados

• Acesse dados sem problemas durante o treinamento do modelo sem se preocupar com cadeias de conexão ou caminhos de dados. Para obter mais informações sobre o treinamento de conjuntos de dados, visite Saiba mais sobre como treinar com conjuntos de dados

• Partilhe dados e colabore com outros utilizadores

Pré-requisitos

Para criar e trabalhar com conjuntos de dados, você precisa:

• Uma subscrição do Azure. Se não tiver uma, crie uma conta gratuita antes de começar. Experimente a versão gratuita ou paga do Azure Machine Learning

• Um espaço de trabalho do Azure Machine Learning

• O SDK do Azure Machine Learning para Python instalado, que inclui o pacote azureml-datasets

• Crie uma instância de computação do Azure Machine Learning, um ambiente de desenvolvimento totalmente configurado e gerenciado que inclui blocos de anotações integrados e o SDK já instalado

  OU

• Trabalhe em seu próprio notebook Jupyter e instale o SDK você mesmo

Orientação de tamanho de computação

Ao criar um conjunto de dados, revise seu poder de processamento de computação e o tamanho dos dados na memória. O tamanho dos dados no armazenamento não é o mesmo que o tamanho dos dados em um dataframe. Por exemplo, os dados em arquivos CSV podem se expandir até 10 vezes em um dataframe, de modo que um arquivo CSV de 1 GB pode se tornar 10 GB em um dataframe.

Os dados compactados podem se expandir ainda mais. Vinte GB de dados relativamente esparsos armazenados em um formato de parquet compactado podem se expandir para ~800 GB de memória. Como os arquivos Parquet armazenam dados em um formato colunar, se você só precisa de metade das colunas, então você só precisa carregar ~ 400 GB na memória.

Para obter mais informações, visite Saiba mais sobre como otimizar o processamento de dados no Azure Machine Learning.

Tipos de conjuntos de dados

Há dois tipos de conjuntos de dados, com base em como os usuários consomem conjuntos de dados em treinamento: FileDatasets e TabularDatasets. Os fluxos de trabalho de treinamento do Azure Machine Learning que envolvem estimadores, AutoML, hyperDrive e pipelines podem usar ambos os tipos.

FileDataset

Um FileDataset faz referência a um ou vários arquivos em seus armazenamentos de dados ou URLs públicas. Se seus dados já estiverem limpos e prontos para uso em experimentos de treinamento, você poderá baixar ou montar os arquivos em sua computação como um objeto FileDataset.

Recomendamos FileDatasets para seus fluxos de trabalho de aprendizado de máquina, porque os arquivos de origem podem estar em qualquer formato. Isso permite uma gama mais ampla de cenários de aprendizado de máquina, incluindo deep learning.

Crie um FileDataset com o SDK do Python ou o estúdio do Azure Machine Learning.

TabularDataset

Um TabularDataset analisa o arquivo fornecido ou a lista de arquivos, para representar dados em um formato tabular. Em seguida, você pode materializar os dados em um pandas ou Spark DataFrame, para trabalhar com bibliotecas familiares de preparação e treinamento de dados enquanto permanece em seu bloco de anotações. Você pode criar um TabularDataset objeto a partir de arquivos de linhas .csv, .tsv, .parquet .json e dos resultados da consulta SQL.

Com TabularDatasets, você pode especificar um carimbo de data/hora a partir de uma coluna nos dados ou do local onde os dados do padrão de caminho são armazenados, para habilitar uma característica de série temporal. Esta especificação permite uma filtragem fácil e eficiente por tempo. Para obter um exemplo, visite Demonstração da API relacionada a séries temporais tabulares com dados meteorológicos da NOAA.

Crie um TabularDataset com o SDK do Python ou o estúdio do Azure Machine Learning.

Acessar conjuntos de dados em uma rede virtual

Se o espaço de trabalho estiver localizado em uma rede virtual, você deverá configurar o conjunto de dados para ignorar a validação. Para obter mais informações sobre como usar armazenamentos de dados e conjuntos de dados em uma rede virtual, visite Proteger um espaço de trabalho e recursos associados.

Criar conjuntos de dados a partir de armazenamentos de dados

Para tornar os dados acessíveis pelo Azure Machine Learning, você deve criar conjuntos de dados a partir de caminhos em URLs da Web ou armazenamentos de dados do Azure Machine Learning.

Para criar conjuntos de dados a partir de um armazenamento de dados com o SDK do Python:

1. Verifique se você tem contributor ou owner acesso ao serviço de armazenamento subjacente do seu armazenamento de dados registrado do Azure Machine Learning. Verifique as permissões da sua conta de armazenamento no portal do Azure.

2. Crie o conjunto de dados fazendo referência a caminhos no armazenamento de dados. Você pode criar um conjunto de dados a partir de vários caminhos em vários armazenamentos de dados. Não há limite rígido para o número de arquivos ou tamanho de dados a partir dos quais você pode criar um conjunto de dados.

Criar um FileDataset

Use o from_files() método na FileDatasetFactory classe para carregar arquivos em qualquer formato e para criar um FileDataset não registrado.

Se o seu armazenamento estiver protegido por uma rede virtual ou firewall, defina o from_files() parâmetro validate=False no método. Isso ignora a etapa de validação inicial e garante que você possa criar seu conjunto de dados a partir desses arquivos seguros. Para obter mais informações, visite usar datastores e conjuntos de dados em uma rede virtual.

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)

Para carregar todos os arquivos de um diretório local, crie um FileDataset em um único método com upload_directory(). Esse método carrega dados para o armazenamento subjacente e, como resultado, você incorre em custos de armazenamento.

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)

Para reutilizar e compartilhar conjuntos de dados entre experimentos em seu espaço de trabalho, registre seu conjunto de dados.

Criar um TabularDataset

Use o from_delimited_files() método na TabularDatasetFactory classe para ler arquivos no formato .csv ou .tsv e para criar um TabularDataset não registrado. Para ler em arquivos de .parquet formato, use o from_parquet_files() método. Se você estiver lendo a partir de vários arquivos, os resultados serão agregados em uma representação tabular.

Para obter informações sobre formatos de arquivo suportados, visite a documentação de referência TabularDatasetFactory e informações sobre sintaxe e padrões de design, como suporte a várias linhas.

Se o seu armazenamento estiver protegido por uma rede virtual ou firewall, defina o parâmetro validate=False no seu from_delimited_files() método. Isso ignora a etapa de validação inicial e garante que você possa criar seu conjunto de dados a partir desses arquivos seguros. Para obter mais informações sobre recursos de armazenamento de dados por trás de uma rede virtual ou firewall, visite datastores e conjuntos de dados em uma rede virtual.

Esse código obtém o espaço de trabalho existente e o armazenamento de dados desejado pelo nome. Em seguida, ele passa o armazenamento de dados e os locais de arquivo para o path parâmetro para criar um novo TabularDataset chamado 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)

Definir esquema de dados

Quando você cria um TabularDataset, os tipos de dados de coluna são automaticamente inferidos por padrão. Se os tipos inferidos não corresponderem às suas expectativas, você poderá especificar tipos de coluna com o código a seguir para atualizar seu conjunto de dados. O parâmetro infer_column_type só é aplicável para conjuntos de dados criados a partir de arquivos delimitados. Para obter mais informações, visite Saiba mais sobre os tipos de dados suportados.

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

Para reutilizar e compartilhar conjuntos de dados entre experimentos em seu espaço de trabalho, registre seu conjunto de dados.

Dados de wrangle

Depois de criar e registrar seu conjunto de dados, você pode carregá-lo em seu bloco de anotações para disputa e exploração de dados, antes do treinamento do modelo. Talvez não seja necessário fazer nenhuma disputa ou exploração de dados. Nesse caso, para obter mais informações sobre como consumir conjuntos de dados em seus scripts de treinamento para envios de experimentos de ML, visite Treinar com conjuntos de dados.

Filtrar conjuntos de dados (visualização)

Os recursos de filtragem dependem do tipo de conjunto de dados que você tem.

Para TabularDatasets, você pode manter ou remover colunas com os métodos keep_columns() e drop_columns( ).

Para filtrar linhas por um valor de coluna específico em um TabularDataset, use o método filter() (visualização).

Estes exemplos retornam um conjunto de dados não registrado com base nas expressões especificadas:

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

Em FileDatasets, cada linha corresponde a um caminho de um arquivo, portanto, filtrar por valor de coluna não ajuda. No entanto, você pode filtrar () linhas por metadados - por exemplo, CreationTime, Size etc. Estes exemplos retornam um conjunto de dados não registrado com base nas expressões especificadas:

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

Os conjuntos de dados rotulados criados a partir de projetos de etiquetagem de imagens são um caso especial. Esses conjuntos de dados são um tipo de TabularDataset composto de arquivos de imagem. Para esses conjuntos de dados, você pode filtrar() imagens por metadados e por valores de image_details label coluna.

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

Dados de partição

Para particionar um conjunto de dados, inclua o partitions_format parâmetro ao criar um TabularDataset ou FileDataset.

Quando você particiona um conjunto de dados, as informações de partição de cada caminho de arquivo são extraídas em colunas com base no formato especificado. O formato deve começar a partir da posição da primeira chave de partição e continuar até o final do caminho do arquivo.

Por exemplo, dado o caminho ../Accounts/2019/01/01/data.jsonl, onde a partição é por nome de departamento e hora, o partition_format='/{Department}/{PartitionDate:yyyy/MM/dd}/data.jsonl' cria uma coluna de cadeia de caracteres 'Departamento' com o valor 'Contas', e uma coluna datetime 'PartitionDate' com o valor 2019-01-01.

Se seus dados já tiverem partições existentes e você quiser preservar esse formato, inclua o partitioned_format parâmetro em seu from_files() método para criar um FileDataset.

Para criar um TabularDataset que preserve partições existentes, inclua o partitioned_format parâmetro no from_parquet_files() ou no from_delimited_files() método.

Este exemplo

• Cria um FileDataset a partir de arquivos particionados
• Obtém as chaves de partição
• Cria um novo FileDataset indexado

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

Você também pode criar uma nova estrutura de partições para TabularDatasets com o método 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']

Explorar dados

Depois de distorcer os dados, você pode registrar seu conjunto de dados e, em seguida, carregá-lo em seu bloco de anotações para exploração de dados antes do treinamento do modelo.

Para FileDatasets, você pode montar ou baixar seu conjunto de dados e aplicar as bibliotecas Python que normalmente usaria para exploração de dados. Para obter mais informações, visite Saiba mais sobre montagem vs 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()

Para TabularDatasets, use o to_pandas_dataframe() método para exibir seus dados em um dataframe.

# preview the first 3 rows of titanic_ds
titanic_ds.take(3).to_pandas_dataframe()

Criar um conjunto de dados a partir de pandas dataframe

Para criar um TabularDataset a partir de um dataframe pandas na memória, use o register_pandas_dataframe() método. Esse método registra o TabularDataset no espaço de trabalho e carrega dados para o armazenamento subjacente. Este processo incorre em custos de armazenamento.

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)

Registrar conjuntos de dados

Para concluir o processo de criação, registre seus conjuntos de dados em um espaço de trabalho. Use o register() método para registrar conjuntos de dados em seu espaço de trabalho, compartilhá-los com outras pessoas e reutilizá-los em experimentos em seu espaço de trabalho:

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

Criar conjuntos de dados usando o Azure Resource Manager

Você pode encontrar muitos modelos em microsoft.machinelearningservices que podem ser usados para criar conjuntos de dados.

Para obter informações sobre esses modelos, visite Usar um modelo do Azure Resource Manager para criar um espaço de trabalho para o Azure Machine Learning.

Preparar com conjuntos de dados

Use seus conjuntos de dados em seus experimentos de aprendizado de máquina para treinar modelos de ML. Saiba mais sobre como treinar com conjuntos de dados.

Conjuntos de dados de versão

Você pode registrar um novo conjunto de dados com o mesmo nome criando uma nova versão. Uma versão do conjunto de dados pode marcar o estado dos seus dados para aplicar uma versão específica do conjunto de dados para experimentação ou reprodução futura. Para obter mais informações, visite versões do conjunto de dados.

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

Próximos passos

• Saiba como treinar com conjuntos de dados
• Use o aprendizado de máquina automatizado para treinar com TabularDatasets
• Para obter mais exemplos de treinamento de conjunto de dados, consulte os blocos de anotações de exemplo