Guia de Início Rápido: Introdução ao Azure Machine Learning

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

Este tutorial apresenta alguns dos recursos mais usados do serviço do Azure Machine Learning. Você cria, registra e implanta um modelo. Este tutorial ajuda você a se familiarizar com os principais conceitos do Azure Machine Learning e o uso mais comum deles.

Você aprende a executar um trabalho de treinamento em um recurso de computação escalonável, implantá-lo e, por fim, testar a implantação.

Você cria um script de treinamento para lidar com a preparação de dados, treinar e registrar um modelo. Depois de treinar o modelo, você o implanta como um endpoint e, em seguida, chama o endpoint para inferência.

As etapas são:

Para obter uma visão geral das etapas neste início rápido, assista a este vídeo.

Pré-requisitos

1. Para usar o Azure Machine Learning, você precisa de um workspace. Se você não tiver um, conclua 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 ele ainda não esteja aberto.

3. 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 os notebooks de exemplo, confira 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 suspensa 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.

   

Criar identificador para o workspace

Antes de se aprofundar no código, você precisa de uma maneira de referenciar seu workspace. O workspace é o recurso de nível superior para o Azure Machine Learning. Ele fornece um local centralizado para trabalhar com todos os artefatos que você cria ao usar o Azure Machine Learning.

Crie ml_client como um identificador para o workspace. Use 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.
3. Você precisa copiar um valor, fechar a área e colá-la. Em seguida, volte para o próximo valor.

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,
)

# Verify that the handle works correctly.
# If you ge 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)

Criar o script de treinamento

Crie o script de treinamento, que é o arquivo python main.py .

Primeiro, crie uma pasta de origem para o script:

import os

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

Esse script pré-processa os dados e os divide em conjuntos de dados de teste e treinamento. Ele treina um modelo baseado em árvore usando esses dados e retorna o modelo de saída.

Durante a execução do pipeline, use o MLFlow para registrar em log os parâmetros e as métricas.

A célula a seguir usa a magia IPython para gravar o script de treinamento no diretório que você acabou de criar.

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

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("--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")
    args = parser.parse_args()
   
    # Start Logging
    mlflow.start_run()

    # enable autologging
    mlflow.sklearn.autolog()

    ###################
    #<prepare the data>
    ###################
    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)

    train_df, test_df = train_test_split(
        credit_df,
        test_size=args.test_train_ratio,
    )
    ####################
    #</prepare the data>
    ####################

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

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

    # 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))
    ###################
    #</train the model>
    ###################

    ##########################
    #<save and register model>
    ##########################
    # Registering the model to the workspace
    print("Registering the model via MLFlow")

    # pin numpy
    conda_env = {
        'name': 'mlflow-env',
        'channels': ['conda-forge'],
        'dependencies': [
            'python=3.10.15',
            'pip<=21.3.1',
            {
                'pip': [
                    'mlflow==2.17.0',
                    'cloudpickle==2.2.1',
                    'pandas==1.5.3',
                    'psutil==5.8.0',
                    'scikit-learn==1.5.2',
                    'numpy==1.26.4',
                ]
            }
        ],
    }

    mlflow.sklearn.log_model(
        sk_model=clf,
        registered_model_name=args.registered_model_name,
        artifact_path=args.registered_model_name,
        conda_env=conda_env,
    )

    # Saving the model to a file
    mlflow.sklearn.save_model(
        sk_model=clf,
        path=os.path.join(args.registered_model_name, "trained_model"),
    )
    ###########################
    #</save and register model>
    ###########################
    
    # Stop Logging
    mlflow.end_run()

if __name__ == "__main__":
    main()

Quando o modelo é treinado, o script salva e registra o arquivo de modelo no workspace. Você pode usar o modelo registrado em pontos de extremidade de inferência.

Talvez seja necessário selecionar Atualizar para ver a nova pasta e o script em seus Arquivos.

Configurar o comando

Agora você tem um script que pode executar as tarefas desejadas e um cluster de computação para executar o script. Use um comando de finalidade geral que possa executar ações de linha de comando. Essa ação de linha de comando pode chamar diretamente comandos do sistema ou executar um script.

Crie variáveis de entrada para especificar os dados de entrada, a taxa de divisão, a taxa de aprendizado e o nome do modelo registrado. O script de comando:

• Usa um ambiente que define bibliotecas de software e runtime necessárias para o script de treinamento. O Azure Machine Learning fornece muitos ambientes coletados ou prontos para uso, que são úteis para cenários comuns de treinamento e inferência. Você usa um desses ambientes aqui. Em Tutorial: treinar um modelo no Azure Machine Learning, você aprende a criar um ambiente personalizado.
• Configura a ação de linha de comando em si – python main.py nesse caso. As entradas e saídas são acessíveis no comando por meio da ${{ ... }} notação.
• Acessa os dados de um arquivo na Internet.
• Como você não especificou um recurso de computação, o script é executado em um cluster de computação sem servidor que é criado automaticamente.

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

registered_model_name = "credit_defaults_model"

job = command(
    inputs=dict(
        data=Input(
            type="uri_file",
            path="https://azuremlexamples.blob.core.windows.net/datasets/credit_card/default_of_credit_card_clients.csv",
        ),
        test_train_ratio=0.2,
        learning_rate=0.25,
        registered_model_name=registered_model_name,
    ),
    code="./src/",  # location of source code
    command="python main.py --data ${{inputs.data}} --test_train_ratio ${{inputs.test_train_ratio}} --learning_rate ${{inputs.learning_rate}} --registered_model_name ${{inputs.registered_model_name}}",
    environment="azureml://registries/azureml/environments/sklearn-1.5/labels/latest",
    display_name="credit_default_prediction",
)

Enviar o trabalho

Envie o trabalho a ser executado no Azure Machine Learning. Desta vez, use create_or_update em ml_client.

ml_client.create_or_update(job)

Exiba a saída do trabalho e aguarde a conclusão dele

Veja o trabalho no Estúdio do Azure Machine Learning selecionando o link na saída da célula anterior.

A saída desse trabalho é parecida com esta no Estúdio do Azure Machine Learning. Explore as abas para obter vários detalhes, como métricas, saídas e muito mais. Depois de concluído, o trabalho registra um modelo em seu espaço de trabalho como resultado do processo de treinamento.

Implantar o modelo como um ponto de extremidade online

Implante seu modelo de machine learning como um serviço Web na nuvem do Azure usando um online endpoint.

Para implantar um serviço de machine learning, use o modelo que você registrou.

Criar um ponto de extremidade online

Agora que você registrou um modelo, configure seu endpoint online. O nome do ponto de extremidade deve ser exclusivo em toda a região do Azure. Para este tutorial, crie um nome exclusivo usando UUID.

import uuid

# Creating a unique name for the endpoint
online_endpoint_name = "credit-endpoint-" + str(uuid.uuid4())[:8]

Crie o ponto de extremidade.

# Expect the endpoint creation to take a few minutes
from azure.ai.ml.entities import (
    ManagedOnlineEndpoint,
    ManagedOnlineDeployment,
    Model,
    Environment,
)

# create an online endpoint
endpoint = ManagedOnlineEndpoint(
    name=online_endpoint_name,
    description="this is an online endpoint",
    auth_mode="key",
    tags={
        "training_dataset": "credit_defaults",
        "model_type": "sklearn.GradientBoostingClassifier",
    },
)

endpoint = ml_client.online_endpoints.begin_create_or_update(endpoint).result()

print(f"Endpoint {endpoint.name} provisioning state: {endpoint.provisioning_state}")

Depois de criar o endpoint, recupere-o conforme mostrado no código a seguir:

endpoint = ml_client.online_endpoints.get(name=online_endpoint_name)

print(
    f'Endpoint "{endpoint.name}" with provisioning state "{endpoint.provisioning_state}" is retrieved'
)

Implantar o modelo ao ponto de extremidade

Depois de criar o endpoint, implante o modelo usando o script inicial. Cada ponto de extremidade pode ter diversas implantações. Você pode especificar regras para direcionar o tráfego para essas implantações. Neste exemplo, você cria uma única implantação que manipula 100% do tráfego de entrada. Escolha um nome de cor para a implantação, como azul, verde ou vermelho. A escolha é arbitrária.

Para encontrar a versão mais recente do modelo registrado, verifique a página Modelos no Estúdio do Azure Machine Learning. Como alternativa, use o código a seguir para recuperar o número de versão mais recente.

# Let's pick the latest version of the model
latest_model_version = max(
    [int(m.version) for m in ml_client.models.list(name=registered_model_name)]
)
print(f'Latest model is version "{latest_model_version}" ')

Implante a versão mais recente do modelo.

# picking the model to deploy. Here we use the latest version of our registered model
model = ml_client.models.get(name=registered_model_name, version=latest_model_version)

# Expect this deployment to take approximately 6 to 8 minutes.
# create an online deployment.
# if you run into an out of quota error, change the instance_type to a comparable VM that is available.
# Learn more on https://azure.microsoft.com/pricing/details/machine-learning/.
blue_deployment = ManagedOnlineDeployment(
    name="blue",
    endpoint_name=online_endpoint_name,
    model=model,
    instance_type="Standard_DS3_v2",
    instance_count=1,
)

blue_deployment = ml_client.begin_create_or_update(blue_deployment).result()

Quando a implantação for concluída, você estará pronto para testá-la.

Teste com uma consulta de amostra

Depois de implantar o modelo no ponto de extremidade, execute a inferência usando o modelo.

Crie um arquivo de solicitação de exemplo que siga o design esperado no método run no script de pontuação.

deploy_dir = "./deploy"
os.makedirs(deploy_dir, exist_ok=True)

%%writefile {deploy_dir}/sample-request.json
{
  "input_data": {
    "columns": [0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22],
    "index": [0, 1],
    "data": [
            [20000,2,2,1,24,2,2,-1,-1,-2,-2,3913,3102,689,0,0,0,0,689,0,0,0,0],
            [10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 10, 9, 8]
        ]
  }
}

# test the blue deployment with some sample data
ml_client.online_endpoints.invoke(
    endpoint_name=online_endpoint_name,
    request_file="./deploy/sample-request.json",
    deployment_name="blue",
)

Limpar os recursos

Se você não precisar do ponto de extremidade, exclua-o para parar de usar o recurso. Verifique se nenhuma outra implantação está usando um ponto de extremidade antes de excluí-lo.

ml_client.online_endpoints.begin_delete(name=online_endpoint_name)

Parar a instância de computação

Se você não precisar dele 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

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óximas etapas

Agora que você tem uma ideia do que está envolvido no treinamento e na implantação de um modelo, saiba mais sobre o processo nestes tutoriais: