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

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

As principais áreas do SDK incluem:

• Explore, prepare e gerencie o ciclo de vida de seus conjuntos de dados usados em experimentos de aprendizado de máquina.
• Gerencie recursos de nuvem para monitorar, registrar e organizar seus experimentos de aprendizado de máquina.
• Treine modelos localmente ou usando recursos de nuvem, incluindo treinamento de modelo acelerado por GPU.
• Use o aprendizado de máquina automatizado, que aceita parâmetros de configuração e dados de treinamento. Ele itera automaticamente através de algoritmos e configurações de hiperparâmetros para encontrar o melhor modelo para executar previsões.
• Implante serviços Web para converter seus modelos treinados em serviços RESTful que podem ser consumidos em qualquer aplicativo.

Para obter um 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 do SDK e padrões de design comuns para usá-las. Para obter o SDK, consulte o guia de instalação do .

Estável vs experimental

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

Os recursos experimentais são rotulados por uma seção de anotação na referência do SDK e indicados por texto, como (visualização) em toda documentação do Azure Machine Learning.

Espaço de trabalho

Namespace: azureml.core.workspace.Workspace

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

Exiba todos os parâmetros do método create Workspace para reutilizar instâncias existentes (Storage, Key Vault, App-Insights e Azure Container Registry-ACR), bem como modificar configurações adicionais, como configuração de ponto de extremidade privado e destino de computação.

Importe a classe e crie um novo espaço de trabalho usando o código a seguir. Defina create_resource_group para False se você tiver um grupo de recursos do Azure existente anteriormente que deseja usar para o espaço de trabalho. 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 espaço de trabalho em vários ambientes gravando-o primeiro em um arquivo JSON de configuração. Isso salva seus dados de assinatura, recurso e nome do espaço de trabalho.

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

Carregue seu espaço de trabalho 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 get() estático para carregar um espaço de trabalho 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.

Experiência

Namespace: azureml.core.experiment.Experiment

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

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 no Workspace.

list_experiments = Experiment.list(ws)

Use a função get_runs para recuperar uma lista de objetos Run (avaliações) 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 executar um teste de experimento. Se você estiver experimentando interativamente em um notebook Jupyter, use a função start_logging. Se você estiver enviando um experimento de um ambiente Python padrão, 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 uma única tentativa 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 resultados e acessar artefatos gerados. Você usa Run dentro do código de experimentação para registrar métricas e artefatos no serviço Histórico de Execução. A funcionalidade inclui:

• Armazenamento e recuperação de métricas e dados.
• Usando tags e a hierarquia filho para facilitar a pesquisa de execuções passadas.
• Registrando arquivos de modelo armazenados para implantação.
• Armazenar, modificar e recuperar propriedades de uma execução.

Crie um objeto Run enviando um objeto Experiment com um execute a configuração objeto. Use o parâmetro tags para anexar categorias e rótulos personalizados às suas execuções. Você pode facilmente encontrá-los e recuperá-los 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 a ser filtrado pela tag criada 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 esta função é um dicionário que inclui:

• ID de execução
• Situação
• Hora de início e de fim
• Destino de computação (local versus nuvem)
• Dependências e versões usadas na execução
• Dados específicos do treinamento (difere dependendo do tipo de modelo)

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

Modelo

Namespace: azureml.core.model.Model

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

Você pode usar o registro de modelo para armazenar e fazer a versão de seus modelos na nuvem do Azure, em seu espaço de trabalho. Os modelos registados são identificados por nome e versão. Cada vez que você registra um modelo com o mesmo nome de um existente, o registro incrementa a versão. O Azure Machine Learning suporta qualquer modelo que possa ser carregado através 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 no Workspacee baixar o modelo da nuvem.

Crie um classificador simples, clf, para prever a rotatividade do cliente com base na sua idade. Em seguida, despeje o modelo em um arquivo .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 em seu espaço de trabalho. 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 em seu espaço de trabalho, é fácil gerenciar, baixar e organizar seus 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 quaisquer parâmetros opcionais. Em seguida, use a função download para baixar o modelo, incluindo a estrutura de pastas na 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 do Workspace.

model.delete()

Depois de ter um modelo registrado, implantá-lo como um serviço Web é um processo simples. Primeiro você criar e registrar uma imagem. Esta etapa configura o ambiente Python e suas 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ê criar uma de configuração de implantação que defina os núcleos de CPU e os parâmetros de memória para o destino de computação. Em seguida, anexe a sua 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 onde você pode treinar seus modelos de aprendizado de máquina. Um destino de computação pode ser uma máquina local ou um recurso de nuvem, como o Azure Machine Learning Compute, o Azure HDInsight ou uma máquina virtual remota.

Use destinos de computação para aproveitar máquinas virtuais poderosas para treinamento de modelos e configure destinos de computação persistentes ou destinos temporários invocados em tempo de execução. Para obter um guia abrangente sobre como configurar e gerenciar destinos de computação, consulte o de instruções .

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

Reutilize o modelo de scikit-learn simples e construa-o em seu próprio arquivo, train.py, no diretório atual. No final do arquivo, crie um novo diretório chamado outputs. Esta etapa cria um diretório na nuvem (seu espaço de trabalho) para armazenar seu modelo treinado que joblib.dump() serializado.

# 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 (1 núcleo de CPU, 3,5 GB de memória). A variável list_vms contém uma lista de máquinas virtuais suportadas e seus 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 Python do recurso de computação remota usando a classe CondaDependencies. O arquivo 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 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 à medida que o ambiente é inicializado e o modelo é treinado.

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 estará disponível em seu espaço de trabalho.

Meio 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 torno de seus scripts de treinamento e pontuação. Além do Python, você também pode configurar PySpark, Docker e R para ambientes. Internamente, os ambientes resultam em imagens do Docker que são usadas para executar os processos de treinamento e pontuação no destino de computação. Os ambientes são entidades gerenciadas e versionadas em seu espaço de trabalho de Aprendizado de Máquina que permitem fluxos de trabalho de aprendizado de máquina reproduzíveis, auditáveis e portáteis em uma variedade de destinos e tipos de computação de computação.

Você pode usar um objeto Environment para:

• Desenvolva seu roteiro de treinamento.
• Reutilize o mesmo ambiente no Azure Machine Learning Compute para treinamento de modelo em escala.
• Implante 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 para instanciar um objeto de ambiente.

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

Adicione pacotes a um ambiente usando arquivos Conda, pip ou private wheel. Especifique cada dependência de pacote usando a classe CondaDependency para adicioná-la ao PythonSectiondo ambiente.

O exemplo a seguir adiciona ao ambiente. Ele adiciona a versão 1.17.0 do 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, de destino de computação e seu 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 construção de um novo 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 total apenas uma vez.

O exemplo a seguir mostra onde você usaria ScriptRunConfig como seu 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ê.

Consulte a seção Model deploy 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 do Azure Machine Learning é um fluxo de trabalho automatizado de uma tarefa completa de aprendizado de máquina. As subtarefas são encapsuladas como uma série de etapas dentro do pipeline. Um pipeline do 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, munging e transformação, normalização e preparação
• Configuração de treinamento, incluindo parametrização de argumentos, caminhos de arquivo e configurações de log/relatório
• Treinamento e validação de forma eficiente e repetitiva, 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
• Publicando um pipeline em um ponto de extremidade REST para executar novamente a partir de qualquer biblioteca HTTP

Um PythonScriptStep é uma etapa básica e integrada para executar um script Python em um destino de computação. Ele usa um nome de script e outros parâmetros opcionais, 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 , 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
)

Depois de pelo menos uma etapa ter sido criada, 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 está associado a um espaço de trabalho do Azure Machine Learning e uma etapa do pipeline está associada a um destino de computação disponível nesse espaço de trabalho. Para obter mais informações, consulte este artigo sobre espaços de trabalho ou esta explicação sobre destinos de computação.

Um padrão comum para as etapas do pipeline é:

1. Especificar espaço de trabalho, computação e armazenamento
2. Configure seus dados de entrada e saída usando
   1. Dataset que disponibiliza um armazenamento de dados do Azure existente
   2. PipelineDataset que encapsula dados tabulares digitados
   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 do pipeline
4. Instanciar um pipeline usando seu espaço de trabalho e etapas
5. Criar um experimento para o qual você envia o pipeline
6. Monitorar os resultados do experimento

Este de caderno é um bom exemplo deste padrão. emprego

Para obter mais informações sobre os Pipelines do 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 automatizado de aprendizado de máquina. O aprendizado de máquina automatizado itera em muitas combinações de algoritmos de aprendizado de máquina e configurações de hiperparâmetros. Em seguida, ele encontra o modelo mais adequado com base na métrica de precisão escolhida. A configuração permite especificar:

• Tipo de tarefa (classificação, regressão, previsão)
• Número de iterações de algoritmo e tempo máximo por iteração
• Métrica de precisão para otimizar
• Algoritmos para lista de bloqueio/lista de permissões
• Número de validações cruzadas
• Alvos de computação
• Dados de formação

Para obter guias detalhados e exemplos de configuração de experimentos automatizados de aprendizado de máquina, consulte o tutorial e instruções.

O código a seguir ilustra a criação de um objeto de configuração de aprendizado de máquina automatizado para um modelo de classificação e o uso dele quando você estiver enviando 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 do treinamento para cada iteração à medida que ela termina. Depois que a execução for concluída, um objeto AutoMLRun (que estende a classe Run) será retornado. Obtenha o modelo mais adequado 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 do 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 obter um guia detalhado sobre como preparar a implantação do modelo e implantar serviços Web, consulte este de instruções .

Você pode usar ambientes ao implantar seu modelo como um serviço Web. Os ambientes permitem um fluxo de trabalho reprodutível e conectado, onde você pode implantar seu modelo usando as mesmas bibliotecas na computação de treinamento e na computação de inferência. Internamente, os ambientes são implementados como imagens do Docker. Você pode usar imagens fornecidas pela Microsoft ou usar suas próprias imagens personalizadas do Docker. Se você estava usando anteriormente a classe ContainerImage para sua implantação, consulte a classe DockerSection para realizar 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 ambiente, myenve deseja implantar esse modelo em 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 em pequena escala e implantações rápidas. Para implantar seu modelo como um serviço Web em escala de produção, use o Serviço Kubernetes do Azure (AKS). Para obter mais informações, consulte classe AksCompute.

Conjunto de dados

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 salvar o conjunto de dados em seu espaço de trabalho AML para obter recursos de controle de versão e reprodutibilidade. Os conjuntos de dados são facilmente consumidos pelos modelos durante o treinamento. Para obter exemplos detalhados de uso, consulte o guia de instruções .

• TabularDataset representa dados em um formato tabular criado pela análise de um arquivo ou lista de arquivos.
• FileDataset faz referência a um ou vários arquivos em armazenamentos de dados 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 fazendo referência a várias 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óximos passos

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

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

• Procure classes e módulos na documentação de referência deste site usando o índice à esquerda.