Criar conjuntos de dados no Azure Machine Learning
APLICA-SE A: 
SDK do Python do AzureMLv1
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 obter mais informações sobre como os conjuntos de dados se encaixam no fluxo de trabalho geral de acesso a dados do Azure Machine Learning, visite o artigo Acessar dados de maneira segura.
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 sua localização existente, você não incorre em nenhum custo de armazenamento extra e não corre o risco de integridade de suas fontes de dados. Além disso, os conjuntos de dados são avaliados de forma preguiçosa, o que ajuda a melhorar as 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 obter informações sobre uma experiência de baixo código, 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, é possível:
Manter uma única cópia de dados em seu armazenamento, referenciada por conjuntos de dados
Acessar dados diretamente 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 do conjunto de dados, visite Saiba mais sobre como treinar com conjuntos de dados
Compartilhar dados e colaborar com outros usuários
Importante
Os itens neste artigo marcados "versão prévia" estão em versão prévia pública no momento. A versão prévia é fornecida sem um contrato de nível de serviço e não é recomendada para cargas de trabalho de produção. Alguns recursos podem não ter suporte ou podem ter restrição de recursos. Para obter mais informações, consulte Termos de Uso Complementares de Versões Prévias do Microsoft Azure.
Pré-requisitos
Para criar e trabalhar com conjuntos de dados, você precisa do seguinte:
Uma assinatura do Azure. Se você não tiver uma conta gratuita, crie uma antes de começar. Experimente a versão gratuita ou paga 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 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 contarão com o .NET Core 2.1 e apenas distribuições específicas dão suporte a elas. Para obter mais informações sobre as distribuições com suporte, leia 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 recomendamos o uso de uma distribuição fora do suporte principal. As distribuições que estão fora do suporte principal 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, examine o poder de processamento de computação e o tamanho dos dados na memória. O tamanho dos dados no armazenamento não é igual ao tamanho deles 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 se tornar 10 GB em um dataframe.
Os dados compactados podem expandir ainda mais. Vinte GB de dados relativamente esparsos armazenados em um formato parquet compactado podem ser expandidos para cerca de 800 GB na 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.
Para obter mais informações, visite Saiba mais sobre como otimizar o processamento de dados no Azure Machine Learning.
Tipos de conjunto de dados
Há dois tipos de conjunto de dados, com base em como os usuários consomem conjuntos de dados no treinamento: FileDatasets e TabularDatasets. Fluxos de trabalho de treinamento do Azure Machine Learning que envolvem estimativas, AutoML, hyperDrive e pipelines podem usar ambos os tipos.
FileDataset
Um FileDataset faz referência a um ou a vários arquivos em seus armazenamentos de dados ou URLs públicas. Se os dados já estiverem limpos e estiverem 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 machine learning, pois os arquivos de origem podem estar em qualquer formato. Isso permite uma gama maior de cenários de aprendizado de máquina, incluindo aprendizado profundo.
Crie um FileDataset com o SDK do Python ou o Estúdio do Azure Machine Learning.
TabularDataset
Um TabularDataset analisa o arquivo ou a lista de arquivos fornecidos para representar dados em um formato tabular. Em seguida, você pode materializar os dados em um Pandas ou Spark DataFrame para trabalhar com bibliotecas de preparação e treinamento de dados familiares enquanto estiver no bloco de anotações. Você pode criar um objeto TabularDataset com base em arquivos .csv, .tsv,.parquet, .json Lines e em resultados da consulta SQL.
Com TabularDatasets, você pode especificar um carimbo de data/hora de uma coluna nos dados ou do local onde os dados de padrão de caminho são armazenados, para habilitar uma característica de série temporal. Essa especificação permite filtragem fácil e eficiente por tempo. Por exemplo, visite 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.
Além disso, para TabularDatasets gerados com base nos resultados da consulta SQL, T-SQL (por exemplo, subconsulta "WITH") ou nomes de colunas duplicados não têm suporte. Consultas T-SQL complexas 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
Se o workspace 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 workspace e recursos associados.
Criar conjuntos de dados por meio do armazenamento de dados
Para tornar os dados acessíveis pelo Azure Machine Learning, você deve criar conjuntos de dados de caminhos em URLs da Web ou armazenamentos de dados do Azure Machine Learning.
Dica
É possível criar conjuntos de dados diretamente a partir de URLs de armazenamento com acesso a data baseado em identidade. Para obter mais informações, visite Conectar-se ao armazenamento com acesso a dados baseados 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 no número de arquivos ou tamanho de dados do qual você pode 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. Para um desempenho ideal, recomendamos a criação de conjuntos de dados que fazem referência a menos de 100 caminhos em armazenamentos de dados.
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 por trás de uma rede virtual ou firewall, defina o parâmetro validate=False no 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. Para obter mais informações, visite usar armazenamentos de dados 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 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(). Se você estiver lendo de vários arquivos, os resultados serão agregados em uma representação tabular.
Para obter informações sobre formatos de arquivo com suporte, 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 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. Para obter mais informações sobre os recursos de armazenamento de dados por trás de uma rede virtual ou firewall, visite armazenamentos de dados e conjuntos de dados em uma rede virtual.
Esse código obtém o workspace existente e o armazenamento de dados desejado pelo nome. Em seguida, ele passa o armazenamento de dados e os locais do arquivo para o parâmetro path 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)
Configurar o 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 a conjuntos de dados criados a partir de arquivos delimitados. Para obter mais informações, visite Saiba mais sobre os tipos de dados com suporte.
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 carregar esse conjunto de dados em seu notebook para estruturação e exploração de dados, antes do treinamento do modelo. Talvez você não precise fazer qualquer estrutura de dados ou exploração. 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 do conjunto de dados.
Importante
Filtrar conjuntos de dados com o método de visualização filter() é uma versão prévia do recurso experimental e pode ser alterada 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).
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 filter() 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 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 conjuntos de dados, você pode filter() imagens por metadados e por valores de coluna 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
Para particionar um conjunto de dados, inclua 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 e continuar 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 e hora do departamento, 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 partições existentes, inclua o parâmetro partitioned_format no método from_parquet_files() ou from_delimited_files().
Esse exemplo
- Cria um FileDataset com base em 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 reorganizar seus dados, você pode registrar seu conjunto de dados e carregá-los no 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, além de aplicar as bibliotecas Python que normalmente seriam usadas para a 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 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 a partir 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. Esse 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)
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 com seu workspace, para compartilhá-los com outras pessoas e reutilizá-los em experimentos em seu workspace:
titanic_ds = titanic_ds.register(workspace=workspace,
name='titanic_ds',
description='titanic training data')
Criar conjuntos de dados com 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 workspace 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. Uma versão do conjunto de dados pode marcar o estado dos 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ó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 exemplo