O que é o SDK do Azure Machine Learning para Python?

  • Artigo

Cientistas de dados e desenvolvedores de IA usam O SDK do Azure Machine Learning para o Python a fim de compilar e executar fluxos de trabalho de aprendizado de máquina com o Serviço do Azure Machine Learning. Você pode interagir com o serviço em qualquer ambiente de Python, incluindo Jupyter Notebooks, Visual Studio Code ou seu IDE favorito do Python.

As principais áreas do SDK incluem:

  • Explorar, preparar e gerenciar o ciclo de vida de seus conjuntos de informações usados em experimentos de machine learning.
  • Gerenciar recursos de nuvem para monitorar, registrar em log e organizar seus experimentos de machine learning.
  • Treine modelos localmente ou usando recursos de nuvem, incluindo o treinamento de modelo com aceleração de GPU.
  • Use o machine learning automatizado, que aceita parâmetros de configuração e dados de treinamento. Ele itera automaticamente por meio de algoritmos e configurações de hiperparâmetro para encontrar o melhor modelo para executar previsões.
  • Implante os serviços Web para converter seus modelos treinados em serviços RESTful que podem ser consumidos em qualquer aplicativo.

Para obter uma explicação passo a passo de como começar, experimente o tutorial.

As seções a seguir são visões gerais de algumas das classes mais importantes no SDK e padrões de design comuns para usá-las. Consulte o guia de instalação para obter o SDK.

Estável vs. experimental

O SDK do Azure Machine Learning para Python fornece recursos estáveis e experimentais no mesmo SDK.

Status do recurso/funcionalidade Descrição
Recursos estáveis Pronto para produção

Esses recursos são recomendados para a maioria dos casos de uso e ambientes de produção. Eles são atualizados com menos frequência do que os recursos experimentais.
Recursos experimentais Em desenvolvimento

Esses recursos são recursos recém-desenvolvidos & atualizações que podem não estar prontas ou totalmente testadas para uso em produção. Embora os recursos sejam, em sua maior parte, funcionais, eles podem incluir algumas alterações da falha. Recursos experimentais são usados para corrigir bugs de interrupção do SDK e somente receberão atualizações durante o período de teste. Os recursos experimentais também são chamados de recursos que estão em versão prévia.

Como o nome indica, os recursos experimentais (versão prévia) servem para experimentação, não sendo considerados livres de bugs nem estáveis. Por isso, recomendamos recursos experimentais apenas para usuários avançados que desejam experimentar versões novas de funcionalidades e pretendem participar dos relatórios de bugs e falhas.

Os recursos experimentais são rotulados por uma seção de observação na referência do SDK e denotados por texto, como (versão prévia), em toda a documentação do Azure Machine Learning.

Workspace

Namespace: azureml.core.workspace.Workspace

A classe Workspace é o recurso fundamental na nuvem que você usa para experimentar, treinar e implantar modelos de machine learning. Ele vincula sua assinatura do Azure e o grupo de recursos a um objeto facilmente consumido.

Exiba todos os parâmetros do método create Workspace para reutilizar as instâncias existentes (Armazenamento, Key Vault, Application Insights e ACR – Registro de Contêiner do Azure), bem como modificar configurações adicionais, como a configuração de ponto de extremidade privado e o destino de computação.

Importe a classe e crie um novo workspace usando o código a seguir. Defina create_resource_group para False se você tiver um grupo de recursos do Azure já existente que você deseje usar para o workspace. Algumas funções podem solicitar credenciais de autenticação do Azure.

from azureml.core import Workspace
ws = Workspace.create(name='myworkspace',
                      subscription_id='<azure-subscription-id>',
                      resource_group='myresourcegroup',
                      create_resource_group=True,
                      location='eastus2'
                     )

Use o mesmo workspace em vários ambientes. Para isso, primeiro grave-o em um arquivo JSON de configuração. Isso salva a assinatura, o recurso e os dados de nome do workspace.

ws.write_config(path="./file-path", file_name="ws_config.json")

Carregue o workspace lendo o arquivo de configuração.

from azureml.core import Workspace
ws_other_environment = Workspace.from_config(path="./file-path/ws_config.json")

Como alternativa, use o método estático get() para carregar um workspace existente sem usar arquivos de configuração.

from azureml.core import Workspace
ws = Workspace.get(name="myworkspace", subscription_id='<azure-subscription-id>', resource_group='myresourcegroup')

A variável ws representa um objeto Workspace nos exemplos de código a seguir.

Experimento

Namespace: azureml.core.experiment.Experiment

A classe Experiment é outro recurso de nuvem fundamental que representa uma coleção de avaliações (execuções de modelo individuais). O código a seguir busca um objeto Experiment de dentro de Workspace por nome ou cria um novo objeto Experiment se o nome não existe.

from azureml.core.experiment import Experiment
experiment = Experiment(workspace=ws, name='test-experiment')

Execute o código a seguir para obter uma lista de todos os objetos Experiment contidos em Workspace.

list_experiments = Experiment.list(ws)

Use a função get_runs para recuperar uma lista de objetos Run (testes) de Experiment. O código a seguir recupera as execuções e imprime cada ID de execução.

list_runs = experiment.get_runs()
for run in list_runs:
    print(run.id)

Há duas maneiras de realizar um teste de experimento. Se você estiver experimentando interativamente em um Jupyter notebook, use a função start_logging. Se você estiver enviando um experimento de um ambiente padrão do Python, use a função submit. Ambas as funções retornam um objeto Run. A variável experiment representa um objeto Experiment nos exemplos de código a seguir.

Executar

Namespace: azureml.core.run.Run

Uma execução representa um único teste de um experimento. Run é o objeto que você usa para monitorar a execução assíncrona de uma avaliação, armazenar a saída da avaliação, analisar os resultados e acessar os artefatos gerados. Você usa Run dentro do código de experimentação para registrar métricas e artefatos no serviço de Histórico de Execuções. A funcionalidade inclui:

  • armazenamento e recuperação de métricas e dados;
  • uso de marcas e a hierarquia de filhos para facilitar a pesquisa de execuções anteriores;
  • registro de arquivos de modelo armazenados para implantação;
  • armazenamento, modificação e recuperação de propriedades de uma execução.

Crie um objeto Run enviando um objeto Experiment com um objeto de configuração de execução. Você usa o parâmetro tags para anexar categorias e rótulos personalizados às suas execuções. Você pode encontrá-los e recuperá-los facilmente mais tarde de Experiment.

tags = {"prod": "phase-1-model-tests"}
run = experiment.submit(config=your_config_object, tags=tags)

Use a função list estática para obter uma lista de todos os objetos Run de Experiment. Especifique o parâmetro tags para filtrar pela marca que você criou anteriormente.

from azureml.core.run import Run
filtered_list_runs = Run.list(experiment, tags=tags)

Use a função get_details para recuperar a saída detalhada para a execução.

run_details = run.get_details()

A saída para essa função é um dicionário que inclui:

  • ID da execução
  • Status
  • Horas de início e término
  • Destino de computação (local versus nuvem)
  • Dependências e versões usadas na execução
  • Dados específicos do treinamento (diferem dependendo do tipo de modelo)

Para obter mais exemplos de como configurar e monitorar execuções, confira as instruções.

Modelo

Namespace: azureml.core.model.Model

A classe Model é usada para trabalhar com representações de nuvem de modelos de machine learning. Os métodos ajudam a transferir modelos entre ambientes de desenvolvimento local e o objeto Workspace na nuvem.

É possível usar o registro de modelo para armazenar e controlar a versão de seus modelos na nuvem do Azure no workspace. Modelos registrados são identificados por nome e versão. Cada vez que você registra um modelo com o mesmo nome de um já existente, o Registro incrementa a versão. O Azure Machine Learning é compatível com qualquer modelo que possa ser carregado por meio do Python 3, não apenas modelos do Azure Machine Learning.

O exemplo a seguir mostra como criar um modelo de classificação local simples com scikit-learn, registrar o modelo em Workspace e baixar o modelo da nuvem.

Crie um classificador simples, clf, para prever a rotatividade de clientes com base na idade deles. Em seguida, despeje o modelo em um arquivo de .pkl no mesmo diretório.

from sklearn import svm
import joblib
import numpy as np

# customer ages
X_train = np.array([50, 17, 35, 23, 28, 40, 31, 29, 19, 62])
X_train = X_train.reshape(-1, 1)
# churn y/n
y_train = ["yes", "no", "no", "no", "yes", "yes", "yes", "no", "no", "yes"]

clf = svm.SVC(gamma=0.001, C=100.)
clf.fit(X_train, y_train)

joblib.dump(value=clf, filename="churn-model.pkl")

Use a função register para registrar o modelo no workspace. Especifique o caminho do modelo local e o nome do modelo. Registrar o mesmo nome mais de uma vez criará uma nova versão.

from azureml.core.model import Model

model = Model.register(workspace=ws, model_path="churn-model.pkl", model_name="churn-model-test")

Agora que o modelo está registrado no workspace, é fácil gerenciar, baixar e organizar os modelos. Para recuperar um objeto de modelo (por exemplo, em outro ambiente) de Workspace, use o construtor de classe e especifique o nome do modelo e os parâmetros opcionais. Em seguida, use a função download para baixar o modelo, incluindo a estrutura da pasta de nuvem.

from azureml.core.model import Model
import os

model = Model(workspace=ws, name="churn-model-test")
model.download(target_dir=os.getcwd())

Use a função delete para remover o modelo de Workspace.

model.delete()

Depois que você tiver um modelo registrado, implantá-lo como um serviço Web será um processo simples. Primeiro, você cria e registra uma imagem. Esta etapa configura o ambiente do Python e as respectivas dependências, juntamente com um script para definir os formatos de solicitação e resposta do serviço Web. Depois de criar uma imagem, você cria uma configuração de implantação que define os núcleos de CPU e os parâmetros de memória para o destino de computação. Em seguida, você anexa a imagem.

ComputeTarget, RunConfiguration e ScriptRunConfig

Namespace: azureml.core.compute.ComputeTarget
Namespace: azureml.core.runconfig.RunConfiguration
Namespace: azureml.core.script_run_config.ScriptRunConfig

A classe ComputeTarget é a classe pai abstrata para criar e gerenciar destinos de computação. Um destino de computação representa uma variedade de recursos em que você pode treinar seus modelos de machine learning. Um destino de computação pode ser um computador local ou um recurso de nuvem, tal como Computação do Azure Machine Learning, Azure HDInsight ou uma máquina virtual remota.

Use destinos de computação para tirar proveito de máquinas virtuais poderosas para treinamento de modelos e configurar destinos de computação persistentes ou destinos invocados por runtimes temporários. Para obter um guia abrangente sobre como configurar e gerenciar destinos de computação, confira as instruções.

O código a seguir mostra um exemplo simples de configuração de um destino de AmlCompute (classe filho de ComputeTarget). Esse destino cria um recurso de computação remota em runtime no objeto Workspace. O recurso é dimensionado automaticamente quando um trabalho é enviado. Ele é excluído automaticamente quando a execução é concluída.

Reutilize o modelo de rotatividade de scikit-learn simples e crie-o em seu próprio arquivo, train.py, no diretório atual. No final do arquivo, crie um diretório chamado outputs. Essa etapa cria um diretório na nuvem (seu workspace) para armazenar o modelo treinado que joblib.dump() serializou.

# train.py

from sklearn import svm
import numpy as np
import joblib
import os

# customer ages
X_train = np.array([50, 17, 35, 23, 28, 40, 31, 29, 19, 62])
X_train = X_train.reshape(-1, 1)
# churn y/n
y_train = ["yes", "no", "no", "no", "yes", "yes", "yes", "no", "no", "yes"]

clf = svm.SVC(gamma=0.001, C=100.)
clf.fit(X_train, y_train)

os.makedirs("outputs", exist_ok=True)
joblib.dump(value=clf, filename="outputs/churn-model.pkl")

Em seguida, você cria o destino de computação instanciando um objeto RunConfiguration e definindo o tipo e o tamanho. Este exemplo usa o menor tamanho de recurso (um núcleo de CPU, 3,5 GB de memória). A variável list_vms contém uma lista de máquinas virtuais compatíveis e os respectivos tamanhos.

from azureml.core.runconfig import RunConfiguration
from azureml.core.compute import AmlCompute
list_vms = AmlCompute.supported_vmsizes(workspace=ws)

compute_config = RunConfiguration()
compute_config.target = "amlcompute"
compute_config.amlcompute.vm_size = "STANDARD_D1_V2"

Crie dependências para o ambiente do Python do recurso de computação remota usando a classe CondaDependencies. O arquivo de train.py está usando scikit-learn e numpy, que precisam ser instalados no ambiente. Você também pode especificar versões de dependências. Use o objeto dependencies para definir o ambiente em compute_config.

from azureml.core.conda_dependencies import CondaDependencies

dependencies = CondaDependencies()
dependencies.add_pip_package("scikit-learn")
dependencies.add_pip_package("numpy==1.15.4")
compute_config.environment.python.conda_dependencies = dependencies

Agora você está pronto para enviar o experimento. Use a classe ScriptRunConfig para anexar a configuração de destino de computação e para especificar o caminho/arquivo para o script de treinamento train.py. Envie o experimento especificando o parâmetro config da função submit(). Chame wait_for_completion na execução resultante para ver a saída de execução assíncrona enquanto o ambiente é inicializado e o modelo é treinado.

Aviso

A seguir estão as limitações em relação a caracteres específicos quando usados em parâmetros de ScriptRunConfig:

  • Os caracteres ", $, ; e \ são ignorados pelo back-end, pois são considerados caracteres reservados para a separação de comandos bash.
  • Os caracteres (, ), %, !, ^, <, >, & e | têm escape para execuções locais em Windows.
from azureml.core.experiment import Experiment
from azureml.core import ScriptRunConfig

script_run_config = ScriptRunConfig(source_directory=os.getcwd(), script="train.py", run_config=compute_config)
experiment = Experiment(workspace=ws, name="compute_target_test")
run = experiment.submit(config=script_run_config)
run.wait_for_completion(show_output=True)

Após a conclusão da execução, o arquivo de modelo treinado churn-model.pkl está disponível no workspace.

Ambiente

Namespace: azureml.core.environment

Os ambientes do Azure Machine Learning especificam os pacotes Python, as variáveis de ambiente e as configurações de software em relação aos scripts de treinamento e pontuação. Além do Python, você também pode configurar o PySpark, Docker e R para ambientes. Internamente, os ambientes resultam em imagens do Docker usadas para executar os processos de treinamento e pontuação no destino de computação. Os ambientes são entidades gerenciadas e com controle de versão dentro de seu workspace do Machine Learning que habilitam fluxos de trabalho de aprendizado de máquina portáteis, reproduzíveis e auditáveis em uma variedade de destinos e tipos de computação.

Você pode usar um objeto Environment para:

  • Desenvolver seu script de treinamento.
  • Reutilizar o mesmo ambiente na Computação do Azure Machine Learning para treinamento de modelos em escala.
  • Implantar seu modelo com esse mesmo ambiente sem estar vinculado a um tipo de computação específico.

O código a seguir importa a classe Environment do SDK e cria uma instância de um objeto de ambiente.

from azureml.core.environment import Environment
Environment(name="myenv")

Adicione pacotes a um ambiente usando arquivos Conda, pip ou de roda privada. Especifique cada dependência de pacote usando a classe CondaDependency para adicioná-la à PythonSection do ambiente.

O exemplo a seguir é adicionado ao ambiente. Ele adiciona a versão 1.17.0 de numpy. Ele também adiciona o pacote de pillow ao ambiente, myenv. O exemplo usa o método add_conda_package() e o método add_pip_package(), respectivamente.

from azureml.core.environment import Environment
from azureml.core.conda_dependencies import CondaDependencies

myenv = Environment(name="myenv")
conda_dep = CondaDependencies()

# Installs numpy version 1.17.0 conda package
conda_dep.add_conda_package("numpy==1.17.0")

# Installs pillow package
conda_dep.add_pip_package("pillow")

# Adds dependencies to PythonSection of myenv
myenv.python.conda_dependencies=conda_dep

Para enviar uma execução de treinamento, você precisa combinar seu ambiente, o destino de computação e o script Python de treinamento em uma configuração de execução. Essa configuração é um objeto wrapper usado para enviar execuções.

Quando você envia uma execução de treinamento, a criação de um ambiente pode levar vários minutos. A duração depende do tamanho das dependências necessárias. Os ambientes são armazenados em cache pelo serviço. Assim, desde que a definição do ambiente permaneça inalterada, você incorrerá no tempo de configuração completa apenas uma vez.

O exemplo a seguir mostra onde você poderia usar ScriptRunConfig como objeto wrapper.

from azureml.core import ScriptRunConfig, Experiment
from azureml.core.environment import Environment

exp = Experiment(name="myexp", workspace = ws)
# Instantiate environment
myenv = Environment(name="myenv")

# Add training script to run config
runconfig = ScriptRunConfig(source_directory=".", script="train.py")

# Attach compute target to run config
runconfig.run_config.target = "local"

# Attach environment to run config
runconfig.run_config.environment = myenv

# Submit run 
run = exp.submit(runconfig)

Se você não especificar um ambiente em sua configuração de execução antes de enviar a execução, um ambiente padrão será criado para você.

Confira a seção Implantação de modelo para usar ambientes para implantar um serviço Web.

Pipeline, PythonScriptStep

Namespace: azureml.pipeline.core.pipeline.Pipeline
Namespace: azureml.pipeline.steps.python_script_step.PythonScriptStep

Um pipeline de Azure Machine Learning é um fluxo de trabalho automatizado de uma tarefa de machine learning completa. As subtarefas são encapsuladas como uma série de etapas no pipeline. Um pipeline Azure Machine Learning pode ser tão simples quanto uma etapa que chama um script Python. Os pipelines incluem funcionalidade para:

  • Preparação de dados, incluindo importação, validação e limpeza, mudanças irreversíveis e transformação, normalização e preparo
  • Configuração de treinamento, incluindo argumentos de parametrização, filePaths e configurações de log/relatório
  • Treinamento e validação com eficiência e repetição, o que pode incluir a especificação de subconjuntos de dados específicos, diferentes recursos de computação de hardware, processamento distribuído e monitoramento de progresso
  • Implantação, incluindo controle de versão, dimensionamento, provisionamento e controle de acesso
  • Publicação de um pipeline em um ponto de extremidade REST para executar novamente de qualquer biblioteca HTTP

Uma PythonScriptStep é uma etapa básica e interna para executar um script do Python em um destino de computação. Ele usa um nome de script e outros parâmetros opcionais, tais como argumentos para o script, destino de computação, entradas e saídas. O código a seguir é um exemplo simples de um PythonScriptStep. Para obter um exemplo de um script de train.py, consulte a subseção tutorial.

from azureml.pipeline.steps import PythonScriptStep

train_step = PythonScriptStep(
    script_name="train.py",
    arguments=["--input", blob_input_data, "--output", output_data1],
    inputs=[blob_input_data],
    outputs=[output_data1],
    compute_target=compute_target,
    source_directory=project_folder
)

Após a criação de pelo menos uma etapa, as etapas podem ser vinculadas e publicadas como um pipeline automatizado simples.

from azureml.pipeline.core import Pipeline

pipeline = Pipeline(workspace=ws, steps=[train_step])
pipeline_run = experiment.submit(pipeline)

Para obter um exemplo abrangente de criação de um fluxo de trabalho de pipeline, siga o tutorial avançado.

Padrão para criar e usar pipelines

Um pipeline do Azure Machine Learning é associado a um workspace do Azure Machine Learning e uma etapa de pipeline é associada a um destino de computação disponível nesse espaço de trabalho. Para obter mais informações, confira este artigo sobre workspaces ou esta explicação de destinos de computação.

Um padrão comum para etapas de pipeline é:

  1. Especificar workspace, computação e armazenamento
  2. Configurar os dados de entrada e saída usando
    1. Dataset, que disponibiliza um armazenamento de dados existente do Azure
    2. PipelineDataset, que encapsula dados tabulares tipados
    3. PipelineData, que é usado para arquivos intermediários ou dados de diretório gravados por uma etapa e destinados a serem consumidos por outra
  3. Definir uma ou mais etapas de pipeline
  4. Criar uma instância de um pipeline usando seu workspace e suas etapas
  5. Criar um experimento para o qual você envia o pipeline
  6. Monitorar os resultados do experimento

Este notebook é um bom exemplo desse padrão. trabalho

Para obter mais informações sobre pipelines de Azure Machine Learning e, em particular, como eles são diferentes de outros tipos de pipelines, consulte este artigo.

AutoMLConfig

Namespace: azureml.train.automl.automlconfig.AutoMLConfig

Use a classe AutoMLConfig para configurar parâmetros para treinamento do machine learning automatizado. O machine learning automatizado itera em várias combinações de algoritmos de machine learning e configurações de hiperparâmetro. Em seguida, ele encontra o modelo de melhor ajuste com base na métrica de precisão escolhida. A configuração permite especificar:

  • Tipo de tarefa (classificação, regressão, previsão)
  • O número de iterações de algoritmos e o tempo máximo por iteração
  • Métrica de precisão para otimizar
  • Algoritmos para lista de bloqueados/lista de permitidos
  • Número de validações cruzadas
  • Destinos de computação
  • Dados de treinamento

Observação

Use o automl extra em sua instalação para usar o machine learning automatizado.

Para obter guias e exemplos detalhados de como configurar experiências de machine learning automatizado, confira o tutorial e as instruções.

O código a seguir ilustra como criar um objeto de configuração de machine learning automatizado para um modelo de classificação e usá-lo ao enviar um experimento.

from azureml.train.automl import AutoMLConfig

automl_config = AutoMLConfig(task="classification",
                             X=your_training_features,
                             y=your_training_labels,
                             iterations=30,
                             iteration_timeout_minutes=5,
                             primary_metric="AUC_weighted",
                             n_cross_validations=5
                            )

Use o objeto automl_config para enviar um experimento.

from azureml.core.experiment import Experiment

experiment = Experiment(ws, "automl_test_experiment")
run = experiment.submit(config=automl_config, show_output=True)

Depois de enviar o experimento, a saída mostra a precisão de treinamento para cada iteração à medida que ela é concluída. Depois que a execução é concluída, um objeto AutoMLRun (que estende a classe Run) é retornado. Obtenha o modelo de melhor ajuste usando a função get_output() para retornar um objeto Model.

best_model = run.get_output()
y_predict = best_model.predict(X_test)

Implantação de modelo

Namespace: azureml.core.model.InferenceConfig
Namespace: azureml.core.webservice.webservice.Webservice

A classe InferenceConfig é para definições de configuração que descrevem o ambiente necessário para hospedar o modelo e o serviço Web.

Webservice é a classe pai abstrata para criar e implantar serviços Web para seus modelos. Para ver um guia detalhado sobre como se preparar para a implantação de modelo e como implantar serviços Web, confira estas instruções.

Use ambientes ao implantar um modelo como um serviço Web. Os ambientes habilitam um fluxo de trabalho reproduzível e conectado em que é possível implantar um modelo usando as mesmas bibliotecas na computação de treinamento e de inferência. Internamente, os ambientes são implementados como imagens do Docker. Você pode usar qualquer uma das imagens fornecidas pela Microsoft ou usar suas próprias imagens personalizadas do Docker. Se você já tiver usado a classe ContainerImage na implantação, confira a classe DockerSection para criar um fluxo de trabalho semelhante com ambientes.

Para implantar um serviço Web, combine o ambiente, a computação de inferência, o script de pontuação e o modelo registrado em seu objeto de implantação, deploy().

O exemplo a seguir pressupõe que você já concluiu uma execução de treinamento usando o ambiente, myenv, e deseja implantar esse modelo nas Instâncias de Contêiner do Azure.

from azureml.core.model import InferenceConfig, Model
from azureml.core.webservice import AciWebservice, Webservice

# Register the model to deploy
model = run.register_model(model_name = "mymodel", model_path = "outputs/model.pkl")

# Combine scoring script & environment in Inference configuration
inference_config = InferenceConfig(entry_script="score.py",
                                   environment=myenv)

# Set deployment configuration
deployment_config = AciWebservice.deploy_configuration(cpu_cores = 1,
                                                       memory_gb = 1)

# Define the model, inference, & deployment configuration and web service name and location to deploy
service = Model.deploy(workspace = ws,
                       name = "my_web_service",
                       models = [model],
                       inference_config = inference_config,
                       deployment_config = deployment_config)

Este exemplo cria um serviço Web de Instâncias de Contêiner do Azure, que é melhor para testes de pequena escala e implantações rápidas. Para implantar o modelo como um serviço Web em escala de produção, use o AKS (Serviço de Kubernetes do Azure). Para obter mais informações, confira Classe AksCompute.

Dataset

Namespace: azureml.core.dataset.Dataset
Namespace: azureml.data.file_dataset.FileDataset
Namespace: azureml.data.tabular_dataset.TabularDataset

A classe Dataset é um recurso fundamental para explorar e gerenciar dados no Azure Machine Learning. Você pode explorar seus dados com estatísticas resumidas e salvá-lo no workspace do AML para obter funcionalidades de controle de versão e de reprodutibilidade. Os conjuntos de dados são facilmente consumidos por modelos durante o treinamento. Para obter exemplos de uso detalhados, confira o guia de instruções.

  • TabularDataset representa dados em um formato tabular criado analisando um arquivo ou lista de arquivos.
  • FileDataset faz referência a um ou vários arquivos em repositórios de armazenamento ou de URLs públicas.

O exemplo a seguir mostra como criar um TabularDataset apontando para um único caminho em um armazenamento de dados.

from azureml.core import Dataset

dataset = Dataset.Tabular.from_delimited_files(path = [(datastore, 'train-dataset/tabular/iris.csv')])
dataset.take(3).to_pandas_dataframe()

O exemplo a seguir mostra como criar um FileDataset referenciando múltiplas URLs de arquivo.

from azureml.core.dataset import Dataset

url_paths = [
            'http://yann.lecun.com/exdb/mnist/train-images-idx3-ubyte.gz',
            'http://yann.lecun.com/exdb/mnist/train-labels-idx1-ubyte.gz',
            'http://yann.lecun.com/exdb/mnist/t10k-images-idx3-ubyte.gz',
            'http://yann.lecun.com/exdb/mnist/t10k-labels-idx1-ubyte.gz'
            ]
dataset = Dataset.File.from_files(path=url_paths)

Próximas etapas

Experimente estas próximas etapas para aprender a usar o SDK do Azure Machine Learning para Python:

  • Siga o tutorial para aprender a criar, treinar e implantar um modelo em Python.

  • Pesquise classes e módulos na documentação de referência deste site usando o sumário à esquerda.