Criar conjuntos de dados no Azure Machine Learning
APLICA-SE A
SDK do Python azureml v1
Neste artigo, você aprenderá a criar conjuntos de dados do Azure Machine Learning a fim de acessar dados para realizar experimentos locais ou remotos com o SDK Python do Azure Machine Learning. Para entender a função dos conjuntos de dados no fluxo de trabalho geral de acesso a dados do Azure Machine Learning, consulte o artigoAcessar dados de maneira segura.
Ao criar um conjunto de dados, você cria uma referência para o local da fonte de dados com uma cópia de seus metadados. Como os dados permanecem no local existente, você não tem nenhum custo de armazenamento adicional e não arrisca a integridade de suas fontes de dados. Além disso, os conjuntos de itens são avaliados lentamente, o que auxilia nas velocidades de desempenho do fluxo de trabalho. É possível criar conjuntos de dados por meio de armazenamentos de dados, de URLs públicas e do Azure Open Datasets.
Para ter uma experiência com pouca codificação, consulte 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, é possível:
Manter uma única cópia dos dados em seu armazenamento, referenciada pelos conjuntos de dados.
Acessar dados diretamente durante o treinamento do modelo sem se preocupar com cadeias de conexão ou caminhos de dados. Saiba mais sobre como treinar com conjuntos de dados.
Compartilhar dados e colaborar com outros usuários.
Pré-requisitos
Para criar e trabalhar com conjuntos de dados, você precisa do seguinte:
Uma assinatura do Azure. Se você não tiver uma, crie uma conta gratuita antes de começar. Experimente a versão gratuita ou paga do Azure Machine Learning.
O SDK Python do Azure Machine Learning instalado, que inclui o pacote azureml-datasets.
- Crie umainstância de computação do Azure Machine Learning, que consiste em um ambiente de desenvolvimento totalmente configurado e gerenciado que inclui notebooks integrados e o SDK já instalado.
OR
- Trabalhe em seu próprio notebook Jupyter e instale o SDK por conta própria.
Observação
Algumas classes de conjunto de dados têm dependências no pacote azureml-dataprep, que só é compatível com Python de 64 bits. Se você estiver desenvolvendo no Linux, essas classes dependerão do .NET Core 2.1. Elas só têm suporte em distribuições específicas. Para obter mais informações sobre as distribuições com suporte, consulte a coluna .NET Core 2.1 no artigo Instalar o .NET no Linux.
Importante
Embora o pacote possa funcionar em versões mais antigas de distribuições do Linux, não é recomendável usar uma distribuição que esteja fora do suporte base. As distribuições fora do suporte base podem ter vulnerabilidades de segurança, pois não recebem as atualizações mais recentes. É recomendável usar a versão mais recente com suporte da sua distribuição que seja compatível.
Diretrizes de tamanho de computação
Ao criar um conjunto de dados, revise sua capacidade de processamento de computação e o tamanho dos seus dados na memória. O tamanho dos dados no armazenamento não é igual ao tamanho dos dados em um dataframe. Por exemplo, os dados em arquivos CSV podem ser expandidos até 10 vezes em um dataframe, de modo que um arquivo CSV de 1 GB pode chegar a 10 GB em um dataframe.
Se os dados estiverem compactados, eles poderão ser expandidos, pois 20 GB de dados relativamente esparsos armazenados no formato Parquet compactado podem ser expandidos para aproximadamente 800 GB de memória. Como os arquivos Parquet armazenam dados em um formato de coluna, se você precisar só de metade das colunas, será necessário carregar aproximadamente 400 GB de memória.
Saiba mais sobre como otimizar o processamento de dados no Azure Machine Learning.
Tipos de conjunto de dados
Há dois tipos de conjuntos de dados, com base em como os usuários os consomem no treinamento: FileDataSets e TabularDatasets. Os dois tipos podem ser usados nos fluxos de trabalho de treinamento do Azure Machine Learning, como estimadores, AutoML, hyperDrive e pipelines.
FileDataset
Um FileDataset faz referência a um ou a 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.
O FileDatasets é recomendado para seus fluxos de trabalho de machine learning, pois os arquivos de origem podem estar em qualquer formato, o que permite uma ampla variedade de cenários de machine learning, incluindo aprendizado profundo.
Crie um FileDataset com o SDK Python ou o Estúdio do Azure Machine Learning.
TabularDataset
Um TabularDataset representa dados em um formato de tabela, com base na análise dos arquivos fornecidos. Com isso, é possível materializar os dados em um Pandas ou no Dataframe do Spark para trabalhar com bibliotecas de treinamento e preparação de dados conhecidas sem precisar sair do notebook. Você pode criar um objeto TabularDataset com arquivos .csv, .tsv, .parquet, .jsonl e com os resultados da consulta SQL.
Com TabularDatasets, é possível especificar um carimbo de data/hora de uma coluna nos dados ou de onde quer que os dados de padrão de caminho estejam armazenados para habilitar uma característica de série temporal. Essa especificação permite uma filtragem fácil e eficiente ao longo do tempo. Para obter um exemplo, consulte Demonstração de API relacionada à série temporal tabular com dados meteorológicos da NOAA.
Crie um TabularDataset com o SDK Python ou o Estúdio do Azure Machine Learning.
Observação
Os fluxos de trabalho de ML automatizado gerados por meio do Estúdio do Azure Machine Learning atualmente só dão suporte a TabularDatasets.
Observação
Para TabularDatasets que geram a partir dos resultados da consulta SQL, não há suporte para T-SQL (por exemplo, subconsulta 'WITH') ou nome de coluna duplicada. Consultas complexas como o T-SQL podem causar problemas de desempenho. Nomes de coluna duplicados em um conjunto de dados podem causar problemas de ambiguidade.
Acessar conjuntos de dados em uma rede virtual
Para espaços de trabalho em redes virtuais, configure 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, consulte Proteger um espaço de trabalho e os recursos associados.
Criar conjuntos de dados por meio do armazenamento de dados
Para que os dados sejam acessíveis ao Azure Machine Learning, os conjuntos de dados devem ser criados com base em caminhos nos armazenamentos de dados do Azure Machine Learning ou em URLs da web.
Dica
É possível criar conjuntos de dados diretamente a partir de URLs de armazenamento com acesso a data baseado em identidade. Saiba mais em Conectar-se ao armazenamento com o acesso a dados baseado em identidade.
Para criar conjuntos de itens por meio de um armazenamento de dados com o SDK Python:
Verifique se você tem acesso
contributorouownerao serviço de armazenamento subjacente do seu armazenamento de dados registrado do Azure Machine Learning. Verifique as permissões de sua conta de armazenamento no portal do Azure.Crie o conjunto de dados referenciando caminhos no armazenamento de dados. É possível criar um conjunto de dados a partir de diversos caminhos em diversos armazenamentos de dados. Não há nenhum limite rígido para o número de arquivos ou o tamanho dos dados a partir dos quais é possível criar um conjunto de dados.
Observação
Algumas solicitações serão enviadas ao serviço de armazenamento para verificar se cada caminho de dados aponta para um arquivo ou uma pasta. Essa sobrecarga pode levar à degradação do desempenho ou à falha. Um conjunto de dados que faz referência a uma pasta com 1000 arquivos também faz referência a um caminho de dados. Recomenda-se criar um conjunto de dados que faça referência a menos de 100 caminhos no armazenamento de dados para obter um desempenho ideal.
Criar um FileDataset
Use o método from_files() na classe FileDatasetFactory para carregar arquivos em qualquer formato e criar um FileDataset não registrado.
Se o armazenamento estiver protegido por uma rede virtual ou um firewall, defina o parâmetro validate=False em seu método from_files(). Isso ignora a etapa de validação inicial e garante que você possa criar seu conjunto de dados a partir de seus arquivos seguros. Saiba mais sobre como usar armazenamentos de dados e conjuntos de dados em uma rede virtual.
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 você quiser carregar todos os arquivos de um diretório local, crie um FileDataset em um único método com o upload_directory(). Ele carrega dados para o armazenamento subjacente, o que resulta 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 no experimento de seu espaço de trabalho, registre-os.
Criar um TabularDataset
Use o método from_delimited_files() na classe TabularDatasetFactory para ler os arquivos no formato .csv ou .tsv e criar um TabularDataset não registrado. Para ler arquivos do formato .parquet, use o método from_parquet_files(). No caso da leitura de muitos arquivos, os resultados são agregados em uma representação tabular.
Confira a documentação de referência do TabularDatasetFactory para obter informações sobre formatos de arquivo com suporte, bem como padrões de sintaxe e de design tais como o suporte multilinha.
Se o armazenamento estiver protegido por uma rede virtual ou um firewall, defina o parâmetro validate=False em seu método from_delimited_files(). Isso ignora a etapa de validação inicial e garante que você possa criar seu conjunto de dados a partir de seus arquivos seguros. Saiba mais sobre como usar armazenamentos de dados e conjuntos de dados em uma rede virtual.
O código a seguir obtém o espaço de trabalho existente e o armazenamento de dados desejado pelo nome. Em seguida, ele transfere o armazenamento de dados e os locais de arquivos para o parâmetro path a fim de criar um novo 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)
Configurar o esquema de dados
Por padrão, ao criar um TabularDataset, os tipos de dados de coluna são inferidos automaticamente. Se os tipos inferidos não corresponderem às suas expectativas, atualize o esquema do conjunto de dados especificando os tipos de coluna com o código a seguir. O parâmetro infer_column_type só é aplicável a conjuntos de dados criados a partir de arquivos delimitados. 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()
| (Índice) | PassengerId | Survived | Pclass | Nome | Gênero | Idade | SibSp | Parch | Tíquete | Tarifa | Cabine | Embarcou |
|---|---|---|---|---|---|---|---|---|---|---|---|---|
| 0 | 1 | Falso | 3 | Braund, Sr. Owen Harris | masculino | 22,0 | 1 | 0 | A/5 21171 | 7.2500 | S | |
| 1 | 2 | True | 1 | Cumings, Sra. John Bradley (Florence Briggs Th... | feminino | 38.0 | 1 | 0 | PC 17599 | 71.2833 | C85 | C |
| 2 | 3 | True | 3 | Heikkinen, Miss. Laina | feminino | 26,0 | 0 | 0 | STON/O2. 3101282 | 7.9250 | S |
Para reutilizar e compartilhar conjuntos de dados no experimento de seu espaço de trabalho, registre-os.
Preparação de dados
Depois de criar e registrar seu conjunto de dados, você pode carregá-lo no notebook para a preparação e a exploração de dados antes do treinamento do modelo.
Se você não precisar fazer a preparação ou a exploração de dados, consulte como consumir conjuntos de dados em seus scripts de treinamento para enviar experimentos de ML em Treinar com conjuntos de dados.
Filtrar conjuntos de dados (visualização)
Os recursos de filtragem dependem do tipo do conjunto de dados.
Importante
A filtragem de conjuntos de dados com o método de versão preliminar filter() é uma versão prévia do recurso experimental que pode ser alterado a qualquer momento.
Para TabularDatasets, você pode manter ou remover colunas com os métodos keep_columns() e drop_columns().
Para filtrar as linhas por um valor de coluna específico em um TabularDataset, use o método filter() (visualização).
Os exemplos a seguir 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 arquivo, portanto, a filtragem por valor de coluna não é útil. No entanto, é possível usar filter() nas linhas para filtrar por metadados como a hora de criação, o tamanho etc.
Os exemplos a seguir 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 por meio dos projetos de rotulagem de dados são um caso particular. Eles são um tipo de TabularDataset composto por arquivos de imagem. Para esses tipos de conjuntos de dados, você pode usar filter() nas imagens para filtrar por metadados e por valores de coluna como 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))
Dados de partição
Você pode particionar um conjunto de dados incluindo o parâmetro partitions_format 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 da posição da primeira chave de partição até o final do caminho do arquivo.
Por exemplo, dado o caminho ../Accounts/2019/01/01/data.jsonl em que 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 "Department" com o valor "Accounts" e uma coluna datetime "PartitionDate" com o valor 2019-01-01.
Se os dados já tiverem partições existentes e você quiser preservar esse formato, inclua o parâmetro partitioned_format em seu método from_files() para criar um FileDataset.
Para criar um TabularDataset que preserva as partições existentes, inclua o parâmetro partitioned_format no método from_parquet_files() ou from_delimited_files().
O exemplo a seguir,
- Cria um FileDataset com arquivos particionados.
- Obtém as chaves de partição
- Cria um novo FileDataset indexado 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()
Você também pode criar uma nova estrutura de partições para TabularDatasets com o método 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']
Explorar dados
Depois de concluir a preparação de dados, você pode registrar seu conjunto de dados e carregá-lo em seu notebook para a exploração dos dados antes do treinamento do modelo.
Para FileDatasets, você pode montar ou baixar seu conjunto de dados, além de aplicar as bibliotecas Python que normalmente seriam usadas para a exploração de dados. 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 método to_pandas_dataframe() a fim de exibir seus dados em um dataframe.
# preview the first 3 rows of titanic_ds
titanic_ds.take(3).to_pandas_dataframe()
| (Índice) | PassengerId | Survived | Pclass | Nome | Gênero | Idade | SibSp | Parch | Tíquete | Tarifa | Cabine | Embarcou |
|---|---|---|---|---|---|---|---|---|---|---|---|---|
| 0 | 1 | Falso | 3 | Braund, Sr. Owen Harris | masculino | 22,0 | 1 | 0 | A/5 21171 | 7.2500 | S | |
| 1 | 2 | True | 1 | Cumings, Sra. John Bradley (Florence Briggs Th... | feminino | 38.0 | 1 | 0 | PC 17599 | 71.2833 | C85 | C |
| 2 | 3 | True | 3 | Heikkinen, Miss. Laina | feminino | 26,0 | 0 | 0 | STON/O2. 3101282 | 7.9250 | S |
Criar um conjunto de dados a partir de um dataframe do Pandas
Para criar um TabularDataset de um dataframe pandas na memória, use o método register_pandas_dataframe(). Esse método registra o TabularDataset no workspace e carrega dados no armazenamento subjacente, o que 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)
Dica
Crie e registre um TabularDataset de um dataframe do Spark ou do Dask na memória com métodos de visualização pública register_spark_dataframe() e register_dask_dataframe(). Esses métodos são uma versão prévia experimental do recurso, e podem ser alterados a qualquer momento.
Eles carregam dados para o armazenamento subjacente, o que resulta em custos de armazenamento.
Registrar conjuntos de dados
Para concluir o processo de criação, registre seus conjuntos de dados com um espaço de trabalho. Use o método register() para registrar conjuntos de dados em seu espaço de trabalho a fim de compartilhá-los com outras pessoas e reutilizá-los em experimentos no espaço de trabalho:
titanic_ds = titanic_ds.register(workspace=workspace,
name='titanic_ds',
description='titanic training data')
Criar conjuntos de dados com o Azure Resource Manager
Há muitos modelos em https://github.com/Azure/azure-quickstart-templates/tree/master//quickstarts/microsoft.machinelearningservices que podem ser usados para criar conjuntos de dados.
Para saber mais sobre como usar esses modelos, consulte Usar um modelo do Azure Resource Manager para criar um espaço de trabalho para o Azure Machine Learning.
Treinar com conjuntos de dados
Use seus conjuntos de dados em experimentos de machine learning para o treinamento de modelos de ML. Saiba mais sobre como treinar com conjuntos de dados.
Versões de conjunto de dados
Você pode registrar um novo conjunto de dados com o mesmo nome criando uma nova versão. O controle de versão de conjunto de dados é uma maneira de indicar o estado de seus dados de forma que você possa aplicar uma versão específica do conjunto de dados para experimentos ou reproduções futuras. Saiba mais sobre as versões de 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óximas etapas
- Saiba como treinar com conjuntos de dados.
- Use o machine learning automatizado para treinar com TabularDatasets.
- Para obter mais exemplos de treinamento de conjunto de dados, consulte notebooks de amostra.