Tutorial: criar pipelines de aprendizado de máquina de produção

APLICA-SE A: azure-ai-ml do SDK do Pythonv2 (atual)

Observação

Para obter um tutorial que usa o SDK v1 para criar um pipeline, consulte Tutorial: Criar um pipeline do Azure Machine Learning para classificação de imagem.

Um processo de aprendizado de máquina divide uma tarefa completa de aprendizado de máquina em um fluxo de trabalho composto por várias etapas. Cada etapa é um componente gerenciável que você pode desenvolver, otimizar, configurar e automatizar individualmente. Interfaces bem definidas conectam etapas. O serviço de pipeline do Azure Machine Learning orquestra todas as dependências entre as etapas do pipeline.

Os benefícios do uso de um pipeline são a prática de MLOps padronizada, a colaboração em equipe escalonável, a eficiência de treinamento e a redução de custos. Para saber mais sobre os benefícios dos pipelines, confira O que são os pipelines do Azure Machine Learning.

Neste tutorial, você usará o Azure Machine Learning para criar um projeto de machine learning pronto para produção usando o SDK do Python do Azure Machine Learning v2. Após este tutorial, você poderá usar o SDK do Python do Azure Machine Learning para:

• Obter um identificador para o workspace do Azure Machine Learning
• Criar ativos de dados do Azure Machine Learning
• Criar componentes reutilizáveis do Azure Machine Learning
• Criar, validar e executar pipelines do Azure Machine Learning

Neste tutorial, você criará um pipeline do Azure Machine Learning para treinar um modelo para a previsão padrão de crédito. O pipeline identifica duas etapas:

1. Preparação dos dados
2. Treinamento e registro do modelo treinado

A próxima imagem mostra um pipeline simples, tal como aparece no Azure Studio após o seu envio.

As duas etapas são preparação e treinamento de dados.

Esse vídeo mostra como começar a usar o Estúdio do Azure Machine Learning para que você possa seguir as etapas no tutorial. O vídeo mostra como criar um notebook, criar uma instância de computação e clonar o notebook. As seções a seguir também descrevem essas etapas.

Pré-requisitos

1. Para usar o Azure Machine Learning, você precisa de um workspace. Se você não tiver um, conclua a etapa Criar recursos necessários para começar para criar um workspace e saber mais sobre como usá-lo.

   Importante

   Se o seu espaço de trabalho do Azure Machine Learning estiver configurado com uma rede virtual gerenciada, talvez você precise adicionar regras de saída para permitir o acesso aos repositórios públicos de pacotes do Python. Para obter mais informações, confira Cenário: Acessar pacotes públicos de aprendizado de máquina.

2. Entre no estúdio e selecione seu workspace, caso ainda não esteja aberto.

3. Complete o tutorial Carregar, acessar e explorar seus dados para criar o ativo de dados necessário neste tutorial. Certifique-se de executar todo o código para criar o ativo de dados inicial. Explore os dados e revise-os se desejar, mas só precisará dos dados iniciais neste tutorial.

4. Abra ou crie um notebook em seu workspace:

   • Se você quiser copiar e colar código em células, crie um novo notebook.
   • Ou abra tutoriais/get-started-notebooks/quickstart.ipynb na seção Exemplos do estúdio. Em seguida, selecione Clonar para adicionar o notebook aos seus Arquivos. Para localizar notebooks de exemplo, confira o artigo Aprender com os notebooks de exemplo.

Definir o kernel e abrir no VS Code (Visual Studio Code)

1. Na barra superior acima do notebook aberto, crie uma instância de computação se você ainda não tiver uma.

   

2. Se a instância de computação for interrompida, selecione Iniciar computação e aguarde até que ela esteja em execução.

   

3. Aguarde até que a instância de computação esteja em execução. Em seguida, verifique se o kernel encontrado no canto superior direito é Python 3.10 - SDK v2. Caso contrário, use a lista de seleção para selecionar esse kernel.

   

   Se você não vir esse kernel, verifique se a instância de computação está em execução. Se estiver, selecione o botão Atualizar na parte superior direita do notebook.

4. Se você vir uma barra de notificação dizendo que você precisa de autenticação, selecione Autenticar.

5. Você pode executar o notebook aqui ou abri-lo no VS Code para um IDE (ambiente de desenvolvimento integrado) completo com o poder dos recursos do Azure Machine Learning. Selecione Abrir no VS Code e, em seguida, selecione a opção Web ou desktop. Quando iniciado dessa forma, o VS Code é anexado à instância de computação, ao kernel e ao sistema de arquivos do workspace.

   

Importante

O restante deste tutorial contém células do notebook do tutorial. Copie e cole-os em seu novo notebook ou alterne para o notebook agora se você o clonou.

Configurar os recursos de pipeline

A estrutura do Azure Machine Learning pode ser usada na CLI do Azure, no SDK do Python ou na interface do estúdio. Neste exemplo, você usará o SDK v2 do Python do Azure Machine Learning para criar um pipeline.

Antes de criar o pipeline, você precisa desses recursos:

• O ativo de dados para treinamento
• O ambiente de software para executar o pipeline
• Um recurso de computação em que o trabalho é executado

Criar identificador para o workspace

Antes de usar o código, você precisa de uma maneira de referenciar seu workspace. Crie ml_client como um identificador para o espaço de trabalho. Em seguida, você usa ml_client para gerenciar recursos e trabalhos.

Na próxima célula, insira a ID da Assinatura, o nome do Grupo de Recursos e o nome do workspace. Para encontrar esses valores:

1. Na barra de ferramentas do Estúdio do Azure Machine Learning superior direito, selecione o nome do espaço de trabalho.
2. Copie o valor do espaço de trabalho, do grupo de recursos e da ID da assinatura no código. Você precisa copiar um valor, fechar a área, colar e depois voltar para o próximo.

from azure.ai.ml import MLClient
from azure.identity import DefaultAzureCredential

# authenticate
credential = DefaultAzureCredential()

SUBSCRIPTION = "<SUBSCRIPTION_ID>"
RESOURCE_GROUP = "<RESOURCE_GROUP>"
WS_NAME = "<AML_WORKSPACE_NAME>"
# Get a handle to the workspace
ml_client = MLClient(
    credential=credential,
    subscription_id=SUBSCRIPTION,
    resource_group_name=RESOURCE_GROUP,
    workspace_name=WS_NAME,
)

Referência do SDK:

• MLClient
• DefaultAzureCredential

Observação

A criação de MLClient não conecta ao espaço de trabalho. A inicialização do cliente é lenta. Aguarda até que, pela primeira vez, precise fazer uma chamada. A inicialização ocorre na próxima célula de código.

Verifique a conexão fazendo uma chamada para ml_client. Como essa chamada é a primeira vez que você faz uma chamada para o workspace, você pode ser solicitado a autenticar.

# Verify that the handle works correctly.
# If you get an error here, modify your SUBSCRIPTION, RESOURCE_GROUP, and WS_NAME in the previous cell.
ws = ml_client.workspaces.get(WS_NAME)
print(ws.location, ":", ws.resource_group)

Referência do SDK:

• WorkspaceOperations.get

Acesse o ativo de dados registrado

Comece obtendo os dados registrados anteriormente no Tutorial: carregar, acessar e explorar seus dados no Azure Machine Learning.

Observação

O Azure Machine Learning usa um objeto Data para registrar uma definição reutilizável de dados e consumir os dados em um pipeline.

# get a handle of the data asset and print the URI
credit_data = ml_client.data.get(name="credit-card", version="initial")
print(f"Data asset URI: {credit_data.path}")

Referência do SDK:

• DataOperations.get

Criar um ambiente de trabalho para etapas de pipeline

Até agora, você criou um ambiente de desenvolvimento na instância de computação, seu computador de desenvolvimento. Você também precisará de um ambiente para usar para cada etapa do pipeline. Cada etapa pode ter seu próprio ambiente ou você pode usar alguns ambientes comuns para várias etapas.

Neste exemplo, você criará um ambiente conda para seus trabalhos usando um arquivo conda YAML. Primeiro, crie um diretório para armazenar o arquivo.

import os

dependencies_dir = "./dependencies"
os.makedirs(dependencies_dir, exist_ok=True)

Agora, crie o arquivo no diretório de dependências.

%%writefile {dependencies_dir}/conda.yaml
name: model-env
channels:
  - conda-forge
dependencies:
  - python=3.8
  - numpy=1.21.2
  - pip=21.2.4
  - scikit-learn=0.24.2
  - scipy=1.7.1
  - pandas>=1.1,<1.2
  - pip:
    - inference-schema[numpy-support]==1.3.0
    - xlrd==2.0.1
    - mlflow== 2.4.1
    - azureml-mlflow==1.51.0

A especificação contém alguns pacotes usuais que você usa em seu pipeline (numpy, pip), juntamente com alguns pacotes específicos do Azure Machine Learning (azureml-mlflow).

Os pacotes do Azure Machine Learning não são necessários para executar trabalhos do Azure Machine Learning. A adição desses pacotes permite que você interaja com o Azure Machine Learning para registrar métricas e registrar modelos, tudo dentro do trabalho do Azure Machine Learning. Você os usará no script de treinamento mais adiante neste tutorial.

Use o arquivo YAML para criar e registrar esse ambiente personalizado em seu espaço de trabalho:

from azure.ai.ml.entities import Environment

custom_env_name = "aml-scikit-learn"

pipeline_job_env = Environment(
    name=custom_env_name,
    description="Custom environment for Credit Card Defaults pipeline",
    tags={"scikit-learn": "0.24.2"},
    conda_file=os.path.join(dependencies_dir, "conda.yaml"),
    image="mcr.microsoft.com/azureml/openmpi4.1.0-ubuntu20.04:latest",
    version="0.2.0",
)
pipeline_job_env = ml_client.environments.create_or_update(pipeline_job_env)

print(
    f"Environment with name {pipeline_job_env.name} is registered to workspace, the environment version is {pipeline_job_env.version}"
)

Referência do SDK:

• Ambiente
• EnvironmentOperations.create_or_update

Compilar o pipeline de treinamento

Agora que você tem todos os ativos necessários para executar seu pipeline, é hora de criar o pipeline em si.

Os pipelines do Azure Machine Learning são fluxos de trabalho de ML reutilizáveis que geralmente consistem em vários componentes. A vida típica de um componente é:

• Escreva a especificação YAML do componente ou crie-o programaticamente usando ComponentMethod.
• Opcionalmente, registre o componente com um nome e uma versão em seu espaço de trabalho, para torná-lo reutilizável e compartilhável.
• Carregue esse componente do código de pipeline.
• Implemente o pipeline usando entradas, saídas e parâmetros do componente.
• Envie o pipeline.

Você pode criar um componente de duas maneiras: definição programática e definição de yaml. As próximas duas seções orientam você na criação de um componente de ambas as maneiras. Você pode criar os dois componentes tentando ambas as opções ou escolher seu método preferido.

Observação

Neste tutorial para simplificar, você usa a mesma computação para todos os componentes. No entanto, você pode definir cálculos diferentes para cada componente, por exemplo, adicionando uma linha como train_step.compute = "cpu-cluster". Para exibir um exemplo de criação de um pipeline com cálculos diferentes para cada componente, consulte a seção Trabalho de pipeline básico no tutorial de pipeline cifar-10.

Criar componente 1: preparação de dados (usando definição programática)

Comece criando o primeiro componente. Esse componente manipula o pré-processamento dos dados. A tarefa de pré-processamento é executada no arquivo Python data_prep.py.

Primeiro, crie uma pasta de origem para o componente data_prep:

import os

data_prep_src_dir = "./components/data_prep"
os.makedirs(data_prep_src_dir, exist_ok=True)

Esse script executa a tarefa simples de dividir os dados em conjuntos de dados de treinamento e teste. O Azure Machine Learning monta conjuntos de dados como pastas para os cálculos. Você criou uma função auxiliar select_first_file para acessar o arquivo de dados dentro da pasta de entrada montada.

O MLFlow é usado para registrar os parâmetros e as métricas durante a execução do pipeline.

%%writefile {data_prep_src_dir}/data_prep.py
import os
import argparse
import pandas as pd
from sklearn.model_selection import train_test_split
import logging
import mlflow


def main():
    """Main function of the script."""

    # input and output arguments
    parser = argparse.ArgumentParser()
    parser.add_argument("--data", type=str, help="path to input data")
    parser.add_argument("--test_train_ratio", type=float, required=False, default=0.25)
    parser.add_argument("--train_data", type=str, help="path to train data")
    parser.add_argument("--test_data", type=str, help="path to test data")
    args = parser.parse_args()

    # Start Logging
    mlflow.start_run()

    print(" ".join(f"{k}={v}" for k, v in vars(args).items()))

    print("input data:", args.data)

    credit_df = pd.read_csv(args.data, header=1, index_col=0)

    mlflow.log_metric("num_samples", credit_df.shape[0])
    mlflow.log_metric("num_features", credit_df.shape[1] - 1)

    credit_train_df, credit_test_df = train_test_split(
        credit_df,
        test_size=args.test_train_ratio,
    )

    # output paths are mounted as folder, therefore, we are adding a filename to the path
    credit_train_df.to_csv(os.path.join(args.train_data, "data.csv"), index=False)

    credit_test_df.to_csv(os.path.join(args.test_data, "data.csv"), index=False)

    # Stop Logging
    mlflow.end_run()


if __name__ == "__main__":
    main()

Agora que você tem um script que pode executar a tarefa desejada, crie um componente do Azure Machine Learning por meio dele.

Você usará o CommandComponent de uso geral que pode executar ações de linha de comando. Essa ação de linha de comando pode chamar diretamente comandos do sistema ou executar um script. As entradas/saídas são especificadas na linha de comando usando a ${{ ... }} notação.

from azure.ai.ml import command
from azure.ai.ml import Input, Output

data_prep_component = command(
    name="data_prep_credit_defaults",
    display_name="Data preparation for training",
    description="reads a .xl input, split the input to train and test",
    inputs={
        "data": Input(type="uri_folder"),
        "test_train_ratio": Input(type="number"),
    },
    outputs=dict(
        train_data=Output(type="uri_folder", mode="rw_mount"),
        test_data=Output(type="uri_folder", mode="rw_mount"),
    ),
    # The source folder of the component
    code=data_prep_src_dir,
    command="""python data_prep.py \
            --data ${{inputs.data}} --test_train_ratio ${{inputs.test_train_ratio}} \
            --train_data ${{outputs.train_data}} --test_data ${{outputs.test_data}} \
            """,
    environment=f"{pipeline_job_env.name}:{pipeline_job_env.version}",
)

Referência do SDK:

• comando
• Entrada
• Saída

Opcionalmente, registre o componente no workspace para reutilização futura.

# Now register the component to the workspace
data_prep_component = ml_client.create_or_update(data_prep_component.component)

# Create and register the component in your workspace
print(
    f"Component {data_prep_component.name} with Version {data_prep_component.version} is registered"
)

Referência do SDK:

• MLClient.create_or_update

Criar componente 2: treinamento (usando definição de YAML)

O segundo componente que você cria consome os dados de treinamento e teste, treina um modelo baseado em árvore e retorna o modelo de saída. Use as funcionalidades de log do Azure Machine Learning para registrar e visualizar o progresso do aprendizado.

Você usou a classe CommandComponent para criar seu primeiro componente. Desta vez, você usará a definição de YAML para definir o segundo componente. Cada método tem suas próprias vantagens. Uma definição de yaml pode ser verificada ao longo do código e fornece acompanhamento de histórico legível. O método programático que usa CommandComponent pode ser mais fácil com documentação de classe interna e conclusão de código.

Crie o diretório para este componente:

import os

train_src_dir = "./components/train"
os.makedirs(train_src_dir, exist_ok=True)

Crie o script de treinamento no diretório:

%%writefile {train_src_dir}/train.py
import argparse
from sklearn.ensemble import GradientBoostingClassifier
from sklearn.metrics import classification_report
import os
import pandas as pd
import mlflow


def select_first_file(path):
    """Selects first file in folder, use under assumption there is only one file in folder
    Args:
        path (str): path to directory or file to choose
    Returns:
        str: full path of selected file
    """
    files = os.listdir(path)
    return os.path.join(path, files[0])


# Start Logging
mlflow.start_run()

# enable autologging
mlflow.sklearn.autolog()

os.makedirs("./outputs", exist_ok=True)


def main():
    """Main function of the script."""

    # input and output arguments
    parser = argparse.ArgumentParser()
    parser.add_argument("--train_data", type=str, help="path to train data")
    parser.add_argument("--test_data", type=str, help="path to test data")
    parser.add_argument("--n_estimators", required=False, default=100, type=int)
    parser.add_argument("--learning_rate", required=False, default=0.1, type=float)
    parser.add_argument("--registered_model_name", type=str, help="model name")
    parser.add_argument("--model", type=str, help="path to model file")
    args = parser.parse_args()

    # paths are mounted as folder, therefore, we are selecting the file from folder
    train_df = pd.read_csv(select_first_file(args.train_data))

    # Extracting the label column
    y_train = train_df.pop("default payment next month")

    # convert the dataframe values to array
    X_train = train_df.values

    # paths are mounted as folder, therefore, we are selecting the file from folder
    test_df = pd.read_csv(select_first_file(args.test_data))

    # Extracting the label column
    y_test = test_df.pop("default payment next month")

    # convert the dataframe values to array
    X_test = test_df.values

    print(f"Training with data of shape {X_train.shape}")

    clf = GradientBoostingClassifier(
        n_estimators=args.n_estimators, learning_rate=args.learning_rate
    )
    clf.fit(X_train, y_train)

    y_pred = clf.predict(X_test)

    print(classification_report(y_test, y_pred))

    # Registering the model to the workspace
    print("Registering the model via MLFlow")
    mlflow.sklearn.log_model(
        sk_model=clf,
        registered_model_name=args.registered_model_name,
        artifact_path=args.registered_model_name,
    )

    # Saving the model to a file
    mlflow.sklearn.save_model(
        sk_model=clf,
        path=os.path.join(args.model, "trained_model"),
    )

    # Stop Logging
    mlflow.end_run()


if __name__ == "__main__":
    main()

Como você pode ver neste script de treinamento, depois que o modelo é treinado, o arquivo de modelo é salvo e registrado no workspace. Agora você pode usar o modelo registrado em pontos de extremidade de inferência.

Para o ambiente desta etapa, você usará um dos ambientes internos (coletados) do Azure Machine Learning. A tag azureml instrui o sistema a procurar o nome em ambientes selecionados.

Primeiro, crie o arquivo YAML que descreve o componente:

%%writefile {train_src_dir}/train.yml
# <component>
name: train_credit_defaults_model
display_name: Train Credit Defaults Model
# version: 1 # Not specifying a version will automatically update the version
type: command
inputs:
  train_data: 
    type: uri_folder
  test_data: 
    type: uri_folder
  learning_rate:
    type: number     
  registered_model_name:
    type: string
outputs:
  model:
    type: uri_folder
code: .
environment:
  # for this step, we'll use an AzureML curate environment
  azureml://registries/azureml/environments/sklearn-1.0/labels/latest
command: >-
  python train.py 
  --train_data ${{inputs.train_data}} 
  --test_data ${{inputs.test_data}} 
  --learning_rate ${{inputs.learning_rate}}
  --registered_model_name ${{inputs.registered_model_name}} 
  --model ${{outputs.model}}
# </component>

Agora, crie e registre o componente. Registrá-lo permite reutilizá-lo em outros pipelines. Qualquer outra pessoa com acesso ao seu workspace também pode usar o componente registrado.

# importing the Component Package
from azure.ai.ml import load_component

# Loading the component from the yml file
train_component = load_component(source=os.path.join(train_src_dir, "train.yml"))

# Now register the component to the workspace
train_component = ml_client.create_or_update(train_component)

# Create and register the component in your workspace
print(
    f"Component {train_component.name} with Version {train_component.version} is registered"
)

Referência do SDK:

• carregar_componente
• MLClient.create_or_update

Criar o pipeline a partir de componentes

Agora que os dois componentes estão definidos e registrados, você pode começar a implementar o pipeline.

As funções do Python retornadas por load_component() trabalham como qualquer função regular do Python que você utiliza em um pipeline para a execução de cada etapa.

Para codificar o pipeline, você usará um decorador @dsl.pipeline específico que identifica os pipelines do Azure Machine Learning. No decorador, você pode especificar a descrição do pipeline e os recursos padrão, como computação e armazenamento. Como uma função de Python, os pipelines podem ter entradas. Em seguida, você pode criar várias instâncias de um único pipeline com entradas diferentes.

Aqui, você usa dados de entrada, taxa de divisão e nome do modelo registrado como variáveis de entrada. Em seguida, chame os componentes e conecte-os usando seus identificadores de entradas/saídas. As saídas de cada etapa podem ser acessadas com a .outputs propriedade.

# the dsl decorator tells the sdk that we are defining an Azure Machine Learning pipeline
from azure.ai.ml import dsl, Input, Output


@dsl.pipeline(
    compute="serverless",  # "serverless" value runs pipeline on serverless compute
    description="E2E data_perp-train pipeline",
)
def credit_defaults_pipeline(
    pipeline_job_data_input,
    pipeline_job_test_train_ratio,
    pipeline_job_learning_rate,
    pipeline_job_registered_model_name,
):
    # using data_prep_function like a python call with its own inputs
    data_prep_job = data_prep_component(
        data=pipeline_job_data_input,
        test_train_ratio=pipeline_job_test_train_ratio,
    )

    # using train_func like a python call with its own inputs
    train_job = train_component(
        train_data=data_prep_job.outputs.train_data,  # note: using outputs from previous step
        test_data=data_prep_job.outputs.test_data,  # note: using outputs from previous step
        learning_rate=pipeline_job_learning_rate,  # note: using a pipeline input as parameter
        registered_model_name=pipeline_job_registered_model_name,
    )

    # a pipeline returns a dictionary of outputs
    # keys will code for the pipeline output identifier
    return {
        "pipeline_job_train_data": data_prep_job.outputs.train_data,
        "pipeline_job_test_data": data_prep_job.outputs.test_data,
    }

Referência do SDK:

• dsl.pipeline
• Entrada
• Saída

Agora, use a definição do seu pipeline para instanciar um pipeline com seu conjunto de dados, a taxa de divisão escolhida e o nome que você selecionou para o seu modelo.

registered_model_name = "credit_defaults_model"

# Let's instantiate the pipeline with the parameters of our choice
pipeline = credit_defaults_pipeline(
    pipeline_job_data_input=Input(type="uri_file", path=credit_data.path),
    pipeline_job_test_train_ratio=0.25,
    pipeline_job_learning_rate=0.05,
    pipeline_job_registered_model_name=registered_model_name,
)

Referência do SDK:

• Entrada

Enviar o trabalho

Agora envie o trabalho a ser executado no Azure Machine Learning. Desta vez, você usa create_or_update em ml_client.jobs.

Aqui você também passará um nome de experimento. Um experimento é um contêiner para todas as iterações que se faz em um determinado projeto. Todos os trabalhos enviados com o mesmo nome de experimento são listados um ao lado do outro no estúdio do Azure Machine Learning.

Após a conclusão, o pipeline registra um modelo em seu espaço de trabalho como resultado do treinamento.

# submit the pipeline job
pipeline_job = ml_client.jobs.create_or_update(
    pipeline,
    # Project's name
    experiment_name="e2e_registered_components",
)
ml_client.jobs.stream(pipeline_job.name)

Referência do SDK:

• JobOperations.create_or_update
• JobOperations.stream

Você pode acompanhar o progresso do pipeline usando o link gerado na célula anterior. Ao selecionar esse link pela primeira vez, você poderá ver que o pipeline ainda está em execução. Quando ele for concluído, você poderá examinar os resultados de cada componente.

Clique duas vezes no componente Treinar Modelo de Padrões de Crédito .

Há dois resultados importantes que você deseja ver sobre o treinamento:

• Exibir seus logs:

  1. Selecione a guia Saídas + logs.
  2. Abra as pastas para user_logs>std_log.txt Esta seção mostra o script executar stdout.

• Exibir suas métricas: selecione a guia Métricas. Esta seção mostra diferentes métricas registradas. Neste exemplo, o mlflow autologging registra automaticamente as métricas de treinamento.

  

Implantar o modelo como um ponto de extremidade online

Para aprender como implantar seu modelo em um ponto de extremidade online, consulte Implantar um modelo como um tutorial de ponto de extremidade online.

Limpar os recursos

Se você planeja continuar agora para outros tutoriais, pule para a próxima etapa.

Parar a instância de computação

Se você não vai usá-lo agora, interrompa a instância de computação:

1. No estúdio, no painel esquerdo, selecione Computação.
2. Nas guias superiores, selecione Instâncias de computação
3. Selecione a instância de computação na lista.
4. Na barra de ferramentas superior, selecione Parar.

Excluir todos os recursos

Importante

Os recursos que você criou podem ser usados como pré-requisitos em outros tutoriais e artigos de instruções do Azure Machine Learning.

Se você não pretende usar nenhum dos recursos criados, exclua-os para não gerar custos:

1. No portal do Azure, na caixa de pesquisa, insira Grupos de recursos e selecione-o nos resultados.

2. Selecione o grupo de recursos que você criou por meio da lista.

3. Na página Visão geral, selecione Excluir grupo de recursos.

   

4. Insira o nome do grupo de recursos. Em seguida, selecione Excluir.

Próxima etapa

Agendar trabalhos de pipeline de aprendizado de máquina