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

  • Artigo

Os cientistas de dados e os programadores de IA utilizam o SDK do Azure Machine Learning para Python para criar 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 favorito.

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 preparação. 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 SDK do Azure Machine Learning para Python fornece funcionalidades estáveis e experimentais no mesmo SDK.

Estado da funcionalidade/capacidade Description
Funcionalidades estáveis Produção pronta

Estas funcionalidades são recomendadas para a maioria dos casos de utilização e ambientes de produção. São atualizados com menos frequência e depois funcionalidades experimentais.
Funcionalidades experimentais Desenvolvimento

Estas funcionalidades são funcionalidades recentemente desenvolvidas & atualizações que podem não estar prontas ou totalmente testadas para utilização de produção. Embora as funcionalidades sejam normalmente funcionais, podem incluir algumas alterações interruptivas. As funcionalidades experimentais são utilizadas para resolver erros de interrupção do SDK e só receberão atualizações durante o período de teste. As funcionalidades 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 experimentação 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 que pretendem participar no relatório de erros e falhas.

As funcionalidades experimentais são etiquetadas por uma secção de notas na referência do SDK e anotadas por texto como, por exemplo, (pré-visualização) na documentação do Azure Machine Learning.

Área de trabalho

Espaço de nomes: 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.

Veja todos os parâmetros do método create Workspace para reutilizar instâncias existentes (Armazenamento, Key Vault, App-Insights e Azure Container Registry-ACR), bem como modificar definições adicionais, como a configuração de pontos finais privados e o destino 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 nomes: 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 nomes: 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 nomes: 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. O Azure Machine Learning suporta qualquer modelo que possa ser carregado através do Python 3 e não apenas dos modelos do Azure Machine Learning.

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 nomes: azureml.core.compute.ComputeTarget
Espaço de nomes: azureml.core.runconfig.RunConfiguration
Espaço de nomes: 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 carateres específicos quando utilizados em ScriptRunConfig parâmetros:

  • Os "carateres , $, ;e \ são escapados pelo back-end, uma vez que são considerados carateres reservados para separar comandos bash.
  • Os (carateres , ), %, !, ^<, >, &e | são escapados para execuções locais no 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 nomes: azureml.core.environment

Os ambientes do Azure Machine Learning especificam os pacotes Python, as variáveis de ambiente e as definições de software em torno dos scripts de preparação e classificação. Além do Python, também pode configurar o PySpark, o Docker e o R para ambientes. Internamente, os ambientes resultam em imagens do Docker que são utilizadas para executar os processos de preparação e classificação no destino de computação. Os ambientes são entidades geridas e com versões na área de trabalho do Machine Learning que permitem fluxos de trabalho de machine learning reproduzíveis, auditáveis e portáteis numa variedade de destinos de computação e tipos de computação.

Pode utilizar um Environment objeto para:

  • Desenvolva o seu script de preparação.
  • Reutilize o mesmo ambiente na Computação do Azure Machine Learning para a preparação de modelos em escala.
  • Implemente o modelo com esse mesmo ambiente sem estar associado a um tipo de computação específico.

O código seguinte importa a Environment classe do SDK e instancia um objeto de ambiente.

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

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

O exemplo seguinte adiciona ao ambiente. Adiciona 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, respetivamente.

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 execução de preparação, tem de combinar o ambiente, o destino de computação e o script python de preparação numa configuração de execução. Esta configuração é um objeto de wrapper que é utilizado para submeter execuções.

Quando submete uma execução de preparação, a criação de um novo ambiente pode demorar vários minutos. A duração depende do tamanho das dependências necessárias. Os ambientes são colocados em cache pelo serviço. Assim, enquanto a definição do ambiente permanecer inalterada, incorre no tempo de configuração completo apenas uma vez.

O exemplo seguinte mostra onde utilizaria ScriptRunConfig como objeto de 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 não especificar um ambiente na configuração de execução antes de submeter a execução, é criado um ambiente predefinido para si.

Veja a secção Implementação de modelos para utilizar ambientes para implementar um serviço Web.

Pipeline, PythonScriptStep

Espaço de nomes: azureml.pipeline.core.pipeline.Pipeline
Espaço de nomes: 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 pipeline do Azure Machine Learning está associado a uma área de trabalho do Azure Machine Learning e um passo de pipeline está associado a um destino de computação disponível nessa área 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. Conjunto de dados que disponibiliza um arquivo de dados do 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 nomes: 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/lista de permissões
  • 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)

Implementação de modelos

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

A InferenceConfig classe destina-se a definições de configuração que descrevem o ambiente necessário para alojar o modelo e o serviço Web.

Webservice é a classe principal abstrata para criar e implementar serviços Web para os modelos. Para obter um guia detalhado sobre como preparar a implementação de modelos e a implementação de serviços Web, veja este procedimento.

Pode utilizar ambientes ao implementar o modelo como um serviço Web. Os ambientes permitem um fluxo de trabalho reproduzível e ligado, onde pode implementar o modelo com as mesmas bibliotecas na computação de preparação e na computação 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 estava a utilizar anteriormente a classe para a ContainerImage sua implementação, veja a DockerSection classe para realizar um fluxo de trabalho semelhante com ambientes.

Para implementar um serviço Web, combine o ambiente, a computação de inferência, o script de classificação e o modelo registado no objeto de implementação, deploy().

O exemplo seguinte pressupõe que já concluiu uma execução de preparação com o ambiente , myenve quer implementar esse modelo no 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 nomes: azureml.core.dataset.Dataset
Espaço de nomes: azureml.data.file_dataset.FileDataset
Espaço de nomes: 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 os dados num formato tabular criado ao analisar 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 seguinte mostra como criar uma FileDataset referência a vários URLs de ficheiro.

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.