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

Os cientistas de dados e os programadores de IA utilizam o SDK do Azure Machine Learning para Python para compilar e executar fluxos de trabalho de machine learning com o serviço Azure Machine Learning. Pode interagir com o serviço em qualquer ambiente Python, incluindo o Jupyter Notebooks, o Visual Studio Code ou o seu IDE Python preferido.

As principais áreas do SDK incluem:

  • Explorar, preparar e gerir o ciclo de vida dos conjuntos de dados utilizados nas experimentações de machine learning.
  • Gerir recursos de cloud para monitorizar, registar e organizar as experimentações de machine learning.
  • Preparar modelos localmente ou mediante a utilização de recursos de cloud, incluindo a preparação de modelos acelerados por GPU.
  • Utilize machine learning automatizado, que aceita parâmetros de configuração e dados de treino. Itera automaticamente através de algoritmos e definições de hiperparâmetros para encontrar o melhor modelo para executar previsões.
  • Implementar serviços Web para converter os modelos preparados em serviços RESTful que podem ser consumidos em qualquer aplicação.

Para obter instruções passo a passo para começar, experimente o tutorial.

As secções seguintes são descrições gerais de algumas das mais importantes classes no SDK e mostram padrões de design comuns para as utilizar. Para obter o SDK, veja o guia de instalação.

Estável vs. experimental

O Azure Machine Learning SDK para Python fornece características estáveis e experimentais no mesmo SDK.

Estado de funcionalidade/capacidade Description
Características estáveis Produção pronta

Estas características são recomendadas para a maioria dos casos de utilização e ambientes de produção. São atualizados com menos frequência do que características experimentais.
Funcionalidades experimentais Desenvolvimento

Estas funcionalidades são atualizações de capacidades & recentemente desenvolvidas que podem não estar prontas ou totalmente testadas para uso da produção. Embora as funcionalidades sejam tipicamente funcionais, podem incluir algumas alterações de rutura. As funcionalidades experimentais são utilizadas para eliminar bugs de quebra SDK e apenas receberão atualizações durante o período de testes. As características experimentais também são referidas como funcionalidades que estão em pré-visualização.

Como o nome indica, as funcionalidades experimentais (pré-visualização) são para experimentar e não são consideradas isentas de erros ou estáveis. Por este motivo, recomendamos apenas funcionalidades experimentais para utilizadores avançados que pretendam experimentar versões iniciais de capacidades e atualizações, e pretendemos participar no reporte de bugs e falhas.

As características experimentais são rotuladas por uma secção de notas na referência SDK e denotadas por textos como, (pré-visualização) ao longo Azure Machine Learning documentação.

Área de trabalho

Espaço de nome: azureml.core.workspace.Workspace

A classe Workspace é um recurso fundamental na cloud utilizado para experimentar, preparar e implementar modelos de machine learning. Associa a sua subscrição do Azure e o seu grupo de recursos a um objeto facilmente consumido.

Ver todos os parâmetros do método create Workspace para reutilizar as instâncias existentes (Armazenamento, Key Vault, App-Informações e Azure Container Registry-ACR) bem como modificar configurações adicionais como configuração de ponto final privado e meta de computação.

Utilize o código abaixo para importar a classe e criar uma área de trabalho nova. Se já tiver um grupo de recursos do Azure e quiser utilizá-lo na área de trabalho, defina create_resource_group como False. Algumas funções poderão pedir 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'
                     )

Utilize a mesma área de trabalho em vários ambientes ao escrevê-la primeiro num ficheiro JSON de configuração. Desta forma, os dados da subscrição, do recurso e do nome da área de trabalho são guardados.

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

Leia o ficheiro de configuração para carregar a área de trabalho.

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

Em alternativa, utilize o método get() estático para carregar uma área de trabalho já existente sem utilizar os ficheiros 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 seguintes:

Experimentação

Espaço de nome: azureml.core.experiment.Experiment

A classe Experiment é outro recurso fundamental da cloud que representa uma coleção de tentativas (execuções individuais de modelos). O código seguinte obtém um objeto Experiment a partir de Workspace por nome ou, caso o nome não exista, cria um objeto Experiment novo.

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

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

list_experiments = Experiment.list(ws)

Utilize a função get_runs para extrair uma lista de objetos Run (avaliações) a partir de Experiment. O código seguinte obtém as execuções e imprime o ID de cada execução.

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

Há duas formas de executar avaliações de experimentações. Se estiver a experimentar interativamente num notebook do Jupyter, utilize a função start_logging. Se estiver a submeter uma experimentação a partir de um ambiente Python padrão, utilize a função submit. Ambas as funções devolvem um objeto Run. A variável experiment representa um objeto Experiment nos exemplos de código seguintes.

Executar

Espaço de nome: azureml.core.run.Run

Uma execução representa uma avaliação individual de uma experimentação. Run é objeto utilizado para monitorizar a execução assíncrona de uma avaliação, armazenar a saída da mesma, analisar os resultados e aceder aos artefactos gerados. Pode utilizar Run dentro do código da experimentação para registar métricas e artefactos no serviço de histórico de execuções. A funcionalidade inclui:

  • Armazenamento e obtenção de métricas e dados.
  • Utilização de etiquetas e da hierarquia subordinada para pesquisa fácil de execuções anteriores.
  • Registo dos ficheiros dos modelos armazenados para implementação.
  • Armazenando, modificação e obtenção das propriedades de uma execução.

Para criar um objeto Run, submeta um objeto Experiment com um objeto de configuração de execução. Utilize o parâmetro tags para anexar categorias e etiquetas personalizadas às execuções. Pode encontrá-las e obtê-las facilmente depois a partir de Experiment.

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

Utilize a função list estática para obter uma lista de todos os objetos Run a partir de Experiment. Especifique o parâmetro tags para filtrar pela etiqueta criada anteriormente.

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

Utilize a função get_details para obter a saída detalhada da execução.

run_details = run.get_details()

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

  • o ID da Execução
  • Estado
  • A hora de início e de fim
  • O destino de computação (local vs. cloud)
  • As dependências e as versões utilizadas na execução
  • Dados específicos da preparação (difere consoante o tipo de modelo)

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

Modelação

Espaço de nome: azureml.core.model.Model

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

Pode utilizar o registo de modelos para armazenar e gerir as versões dos modelos na cloud do Azure, na sua área de trabalho. Os modelos registados são identificados por nome e versão. Sempre que registar um modelo com o mesmo nome de um modelo já existente, o registo aumenta a versão. Azure Machine Learning suporta qualquer modelo que possa ser carregado através do Python 3, e não apenas Azure Machine Learning modelos.

O exemplo seguinte mostra como criar um modelo de classificação local simples com scikit-learn, registá-lo em Workspace e transferi-lo da cloud.

Crie um classificador simples, clf, para prever a taxa de abandono de clientes em função da idade. Depois, guarde o modelo num ficheiro .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")

Utilize a função register para registar o modelo na sua área de trabalho. Especifique o caminho local e o nome do modelo. Registar o mesmo nome mais de uma vez criará uma versão nova.

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á registado na área de trabalho, é fácil gerir, transferir e organizar os seus modelos. Para obter um objeto de modelo (por exemplo, noutro ambiente) a partir de Workspace, utilize o construtor de classes e especifique o nome do modelo e parâmetros opcionais. Em seguida, utilize a função download para transferir o modelo, incluindo a estrutura da pasta da cloud.

from azureml.core.model import Model
import os

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

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

model.delete()

Depois de registar um modelo, a implementação do mesmo como um serviço Web é um processo simples. Primeiro, cria e regista uma imagem. Este passo configura o ambiente Python e as respetivas dependências, juntamente com um script que define o formato do pedido e da resposta do serviço Web. Com a imagem já criada, crie uma configuração de implementação que defina os núcleos de CPU e os parâmetros da memória do destino da computação. Depois, pode anexar a imagem.

ComputeTarget, RunConfiguration e ScriptRunConfig

Espaço de nome: azureml.core.compute.ComputeTarget
Espaço de nome: azureml.core.runconfig.RunConfiguration
Espaço de nome: azureml.core.script_run_config.ScriptRunConfig

A classe ComputeTarget é a classe principal abstrata para criar e gerir destinos de computação. Os destinos de computação representam vários recursos nos quais pode preparar os seus modelos de machine learning. Podem ser um computador local ou um recurso da cloud, como a Computação do Azure Machine Learning, o Azure HDInsight ou uma máquina virtual remota.

Utilize os destinos de computação para tirar partido de máquinas virtuais robustas para preparar modelos e configure destinos de computação persistentes ou destinos temporários invocados por runtime. Para obter um guia abrangente para configurar e gerir os destinos de computação, vejas as instruções.

O código seguinte mostra um exemplo simples de como configurar um destino AmlCompute (classe subordinada de ComputeTarget). Este destino cria um recurso de computação remoto de runtime no objeto Workspace. Quando é submetido um trabalho, o recurso é dimensionado automaticamente. Após a conclusão da execução, o recurso é eliminado de forma automática.

Reutilize o modelo de taxa de abandono simples scikit-learn e crie-o no seu próprio ficheiro, train.py, no diretório atual. No final do ficheiro, crie um diretório novo com o nome outputs. Este passo cria um diretório na cloud (a sua área de trabalho) no qual armazenar o modelo preparado que o método 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, crie uma instância de um objeto RunConfiguration e configure o tipo e o tamanho do destino de computação. Este exemplo utiliza o tamanho de recurso mais pequeno (1 núcleo de CPU, 3,5 GB de memória). A variável list_vms contém uma lista das máquinas virtuais suportadas e respetivos 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"

Utilize a classe CondaDependencies para criar dependências para o ambiente Python do recurso da computação remota. O ficheiro train.py utiliza scikit-learn e numpy, que têm de estar instalados no ambiente. Também pode especificar versões das dependências. Utilize 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 tem tudo preparado para submeter a experimentação. Utilize a classe ScriptRunConfig para anexar a configuração do destino de computação e para especificar o caminho/ficheiro para o script de preparação train.py. Para submeter a experimentação, especifique o parâmetro config da função submit(). Chame wait_for_completion na execução resultante para ver a saída da execução assíncrona quando o ambiente é inicializado e o modelo preparado.

Aviso

Seguem-se limitações em torno de caracteres específicos quando utilizados em ScriptRunConfig parâmetros:

  • Os "caracteres $;e \ caracteres são escapados pela parte de trás, uma vez que são considerados personagens reservados para separar comandos de bash.
  • Os (caracteres e %>!|)^<&personagens são escapados para corridas 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 ficheiro do modelo preparado, churn-model.pkl, fica disponível na área de trabalho.

Ambiente

Espaço de nome: azureml.core.environment

Azure Machine Learning ambientes especificam os pacotes Python, variáveis ambientais e configurações de software em torno dos seus scripts de treino e pontuação. Além de Python, você também pode configurar PySpark, Docker e R para ambientes. Internamente, os ambientes resultam em imagens docker que são usadas para executar os processos de treino e pontuação no alvo do cálculo. Os ambientes são entidades geridas e versadas dentro do seu espaço de trabalho Machine Learning que permitem fluxos de trabalho de aprendizagem de máquinas reprodutíveis, auditáveis e portáteis através de uma variedade de alvos de computação e tipos de cálculo.

Pode usar um Environment objeto para:

  • Desenvolve o teu guião de treino.
  • Reutilizar o mesmo ambiente em Azure Machine Learning Compute para o treino de modelos à escala.
  • Desloque o seu modelo com esse mesmo ambiente sem estar ligado a um tipo de computação específico.

O seguinte código importa a Environment classe do SDK e instantaneamente um objeto ambiental.

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

Adicione pacotes a um ambiente utilizando ficheiros Conda, pip ou rodas privadas. Especifique a dependência de cada pacote utilizando a CondaDependency classe para adicioná-la ao ambiente PythonSection.

O exemplo a seguir acrescenta-se ao ambiente. Acrescenta a versão 1.17.0 de numpy. Também adiciona o pillow pacote ao ambiente, myenv. O exemplo utiliza o add_conda_package() método e o add_pip_package() método, 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 submeter uma corrida de treino, precisa combinar o seu ambiente, o seu alvo de computação e o seu script python de treino numa configuração de execução. Esta configuração é um objeto de invólucro que é usado para submeter corridas.

Quando se submete um treino, a construção de um novo ambiente pode demorar vários minutos. A duração depende do tamanho das dependências exigidas. Os ambientes são cached pelo serviço. Assim, enquanto a definição de ambiente permanecer inalterada, incorrerá o tempo de configuração completo apenas uma vez.

O exemplo que se segue mostra onde usaria ScriptRunConfig como objeto de invólucro.

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 não especificar um ambiente na configuração de execução antes de submeter a execução, então é criado um ambiente padrão para si.

Consulte a secção de implantação do Modelo para utilizar ambientes para implementar um serviço web.

Pipeline, PythonScriptStep

Espaço de nome: azureml.pipeline.core.pipeline.Pipeline
Espaço de nome: azureml.pipeline.steps.python_script_step.PythonScriptStep

Um pipeline do Azure Machine Learning é um fluxo de trabalho automático de uma tarefa de machine learning completa. As subtarefas são encapsuladas como uma série de passos dentro do pipeline. Os pipelines do Azure Machine Learning podem ser tão simples como um passo que chama um script Python. Incluem funcionalidades para:

  • Treino de dados, incluindo importação, validação e limpeza, manipulação e transformação, normalização e teste
  • Configuração de preparações, incluindo a parametrização de argumentos, caminhos de ficheiros e registo/comunicação de configurações
  • Preparação e validação de forma eficiente e repetida, que pode incluir a especificação de subconjuntos de dados, diferentes recursos de computação de hardware, processamento distribuído e monitorização de progresso
  • Implementação, incluindo a gestão de versões, o dimensionamento, o aprovisionamento e o controlo de acesso
  • Publicação de pipelines para pontos finais REST para voltar a executar a partir de qualquer biblioteca HTTP

PythonScriptStep é um passo incorporado básico para executar um Script Python num destino de computação. Utiliza o nome do script e outros parâmetros opcionais, como argumentos, o destino de computação, as entradas e as saídas. O código seguinte é um exemplo simples de PythonScriptStep: Para obter um exemplo de um script train.py, veja a subseção do 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 ter sido criado pelo menos um passo, os passos podem ser associados entre os mesmos e publicados como um pipeline automático simples.

from azureml.pipeline.core import Pipeline

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

Para ver um exemplo abrangente de como criar um fluxo de trabalho de pipeline, siga o tutorial avançado.

Padrão para criar e utilizar os pipelines

Um gasoduto Azure Machine Learning está associado a um espaço de trabalho Azure Machine Learning e um passo de pipeline está associado a um alvo de computação disponível dentro desse espaço de trabalho. Para obter mais informações, veja este artigo sobre as áreas de trabalho ou esta explicação dos destinos de computação.

Um padrão comum para os passos de pipeline é:

  1. Especificar a área de trabalho, a computação e o armazenamento
  2. Configurar os dados de entrada e de saída mediante a utilização de:
    1. Dataset que disponibiliza uma loja de dados Azure existente
    2. PipelineDataset, que encapsula os dados tabulares introduzidos
    3. PipelineData, que é utilizado para os dados intermediários de ficheiros ou de diretórios escritos por um passo e destinados a serem consumidos por outro
  3. Definir um ou mais passos de pipeline
  4. Instanciar um pipeline com a área de trabalho e com passos
  5. Criar uma experimentação para a qual submeter o pipeline
  6. Monitorizar os resultados da experimentação

Este bloco de notas é um bom exemplo deste padrão. tarefa

Para obter mais informações sobre os Pipelines do Azure Machine Learning e, em particular, como estes são diferentes de outros tipos de pipelines, veja este artigo.

AutoMLConfig

Espaço de nome: azureml.train.automl.automlconfig.AutoMLConfig

Utilize a classe AutoMLConfig para configurar os parâmetros da preparação do machine learning automático. O machine learning automático itera por várias combinações de algoritmos de machine learning e de definições de hiperparâmetros. Depois, encontra o modelo mais adequado de acordo com a métrica de precisão que tiver sido escolhida. A configuração permite especificar:

  • O tipo de tarefa (classificação, regressão, previsão)
  • O número de iterações do algoritmo e o tempo máximo por iteração
  • A métrica de precisão em função da qual otimizar
  • Algoritmos para bloquear/permitir lista
  • O número de validações cruzadas
  • Os destinos de computação
  • Dados de preparação

Nota

Para recorrer ao machine learning automático, utilize o automl adicional na sua instalação.

Para obter guias e exemplos de como configurar as experimentações de machine learning automático, veja o tutorial e as instruções.

O código abaixo ilustra a criação de um objeto de configuração de machine learning automático para um modelo de classificação e mostra como o utilizar quando estiver a submeter uma experimentação.

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
                            )

Para submeter uma experimentação, utilize o objeto automl_config.

from azureml.core.experiment import Experiment

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

Depois de submeter a experimentação, a saída mostra a precisão da preparação de cada iteração, à medida que as iterações terminam. Após a conclusão da execução, é devolvido um objeto AutoMLRun (que amplia a classe Run). Para obter o modelo mais adequado, utilize a função get_output() para devolver um objeto Model.

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

Implantação de modelos

Espaço de nome: azureml.core.model.InferenceConfig
Espaço de nome: azureml.core.webservice.webservice.Webservice

A InferenceConfig classe destina-se a configurações que descrevem o ambiente necessário para hospedar o modelo e o serviço web.

Webservice é a classe principal abstrata para criar e implementar serviços Web para os modelos. Para um guia detalhado sobre a preparação para a implementação do modelo e implementação de serviços web, consulte este como fazê-lo.

Pode utilizar ambientes quando implementar o seu modelo como serviço web. Os ambientes permitem um fluxo de trabalho reprodutível e conectado onde pode implementar o seu modelo utilizando as mesmas bibliotecas tanto no seu compute de treino como no seu cálculo de inferência. Internamente, os ambientes são implementados como imagens do Docker. Pode utilizar as imagens fornecidas pela Microsoft ou utilizar as suas próprias imagens personalizadas do Docker. Se já estava a utilizar a classe para a ContainerImage sua implantação, consulte a DockerSection classe para realizar um fluxo de trabalho semelhante com ambientes.

Para implementar um serviço web, combine o ambiente, inferência computacional, script de pontuação e modelo registado no seu objeto de implantação, deploy().

O exemplo a seguir, assume que já completou uma formação utilizando o ambiente, myenve quer implementar esse modelo para Azure Container Instances.

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 o serviço Web Azure Container Instances, que é mais indicado para testes de pequena escala e implementações rápidas. Para implementar o modelo como um serviço Web para escala de produção, utilize o Azure Kubernetes Service (AKS). Para obter mais informações, veja a classe AksCompute.

Conjunto de dados

Espaço de nome: azureml.core.dataset.Dataset
Espaço de nome: azureml.data.file_dataset.FileDataset
Espaço de nome: azureml.data.tabular_dataset.TabularDataset

A classe Dataset é um recurso fundamental para explorar e gerir dados no Azure Machine Learning. Pode explorar os dados com estatísticas de resumo e guardar o Conjunto de Dados na área de trabalho do AML para beneficiar de capacidades de gestão de versões e de reprodutibilidade. Os conjuntos de dados são facilmente consumidos pelos modelos durante a preparação. Para obter exemplos de utilização detalhados, veja as instruções.

  • TabularDataset representa dados num formato tabular criado através da análise de um ficheiro ou lista de ficheiros.
  • FileDataset referencia ficheiros individuais ou múltiplos em arquivos de dados ou a partir de URLs públicos.

O exemplo seguinte mostra como criar um TabularDataset que aponta para um caminho individual num arquivo 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 URLs de ficheiros múltiplos de referência.

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)

Passos seguintes

Experimente estes passos seguintes para aprender a utilizar o SDK do Azure Machine Learning para Python:

  • Siga o tutorial para aprender a criar, preparar e implementar um modelo em Python.

  • Utilize o índice no lado esquerdo para procurar classes e módulos na documentação de referência neste site.