Ajustando um modelo de hiperparâmetro com o Azure Machine Learning (v1)

APLICA-SE A:Azure CLI ml extension v1

Importante

Alguns dos comandos da CLI do Azure neste artigo usam a extensão , ou v1, para o azure-cli-mlAzure Machine Learning. O suporte para a extensão v1 terminará em 30 de setembro de 2025. Você poderá instalar e usar a extensão v1 até essa data.

Recomendamos que você faça a transição para a mlextensão , ou v2, antes de 30 de setembro de 2025. Para obter mais informações sobre a extensão v2, consulte Extensão CLI do Azure ML e Python SDK v2.

Automatize o ajuste eficiente de hiperparâmetros usando o pacote HyperDrive do Azure Machine Learning (v1). Saiba como concluir as etapas necessárias para ajustar os hiperparâmetros com o SDK do Azure Machine Learning:

1. Definir o espaço de pesquisa de parâmetros
2. Especificar uma métrica primária para otimizar
3. Especificar a política de terminação antecipada para execuções de baixo desempenho
4. Criar e atribuir recursos
5. Iniciar uma experiência com a configuração definida
6. Visualize as execuções de treinamento
7. Selecione a melhor configuração para o seu modelo

O que é o ajuste de hiperparâmetros?

Os hiperparâmetros são parâmetros ajustáveis que permitem controlar o processo de treinamento do modelo. Por exemplo, com redes neurais, você decide o número de camadas ocultas e o número de nós em cada camada. O desempenho do modelo depende fortemente dos hiperparâmetros.

O ajuste de hiperparâmetros, também chamado de otimização de hiperparâmetros, é o processo de encontrar a configuração de hiperparâmetros que resulta no melhor desempenho. O processo é tipicamente computacionalmente caro e manual.

O Azure Machine Learning permite automatizar o ajuste de hiperparâmetros e executar experimentos em paralelo para otimizar com eficiência os hiperparâmetros.

Definir o espaço de pesquisa

Ajuste os hiperparâmetros explorando o intervalo de valores definidos para cada hiperparâmetro.

Os hiperparâmetros podem ser discretos ou contínuos e têm uma distribuição de valores descrita por uma expressão de parâmetro.

Hiperparâmetros discretos

Os hiperparâmetros discretos são especificados como um choice entre valores discretos. choice pode ser:

• um ou mais valores separados por vírgulas
• um range objeto
• qualquer objeto arbitrário list

    {
        "batch_size": choice(16, 32, 64, 128)
        "number_of_hidden_layers": choice(range(1,5))
    }

Neste caso, um dos valores [16, 32, 64, 128] e number_of_hidden_layers toma um dos valores [1, 2, 3, batch_size 4].

Os seguintes hiperparâmetros discretos avançados também podem ser especificados usando uma distribuição:

• quniform(low, high, q) - Devolve um valor como round(uniforme(baixo, alto) / q) * q
• qloguniform(low, high, q) - Devolve um valor como round(exp(uniform(low, high)) / q) * q
• qnormal(mu, sigma, q) - Devolve um valor como round(normal(mu, sigma) / q) * q
• qlognormal(mu, sigma, q) - Devolve um valor como round(exp(normal(mu, sigma)) / q) * q

Hiperparâmetros contínuos

Os hiperparâmetros contínuos são especificados como uma distribuição em um intervalo contínuo de valores:

• uniform(low, high) - Devolve um valor uniformemente distribuído entre baixo e alto
• loguniform(low, high) - Devolve um valor desenhado de acordo com exp(uniform(low, high)) para que o logaritmo do valor de retorno seja uniformemente distribuído
• normal(mu, sigma) - Devolve um valor real que é normalmente distribuído com mu médio e desvio padrão sigma
• lognormal(mu, sigma) - Devolve um valor desenhado de acordo com exp(normal(mu, sigma)) para que o logaritmo do valor de retorno seja normalmente distribuído

Um exemplo de uma definição de espaço de parâmetro:

    {    
        "learning_rate": normal(10, 3),
        "keep_probability": uniform(0.05, 0.1)
    }

Este código define um espaço de pesquisa com dois parâmetros - learning_rate e keep_probability. learning_rate tem uma distribuição normal com valor médio 10 e desvio padrão de 3. keep_probability tem uma distribuição uniforme com um valor mínimo de 0,05 e um valor máximo de 0,1.

Amostragem do espaço de hiperparâmetros

Especifique o método de amostragem de parâmetros a ser usado no espaço de hiperparâmetros. O Azure Machine Learning dá suporte aos seguintes métodos:

• Amostragem aleatória
• Amostragem em grelha
• Amostragem bayesiana

Amostragem aleatória

A amostragem aleatória suporta hiperparâmetros discretos e contínuos. Ele suporta o término antecipado de execuções de baixo desempenho. Alguns usuários fazem uma pesquisa inicial com amostragem aleatória e, em seguida, refinam o espaço de pesquisa para melhorar os resultados.

Na amostragem aleatória, os valores de hiperparâmetros são selecionados aleatoriamente a partir do espaço de pesquisa definido.

from azureml.train.hyperdrive import RandomParameterSampling
from azureml.train.hyperdrive import normal, uniform, choice
param_sampling = RandomParameterSampling( {
        "learning_rate": normal(10, 3),
        "keep_probability": uniform(0.05, 0.1),
        "batch_size": choice(16, 32, 64, 128)
    }
)

Amostragem em grelha

A amostragem em grelha suporta hiperparâmetros discretos. Use a amostragem de grade se puder fazer um orçamento para pesquisar exaustivamente no espaço de pesquisa. Suporta o encerramento antecipado de execuções de baixo desempenho.

A amostragem de grade faz uma pesquisa de grade simples sobre todos os valores possíveis. A amostragem em grelha só pode ser utilizada com choice hiperparâmetros. Por exemplo, o espaço a seguir tem seis exemplos:

from azureml.train.hyperdrive import GridParameterSampling
from azureml.train.hyperdrive import choice
param_sampling = GridParameterSampling( {
        "num_hidden_layers": choice(1, 2, 3),
        "batch_size": choice(16, 32)
    }
)

Amostragem bayesiana

A amostragem bayesiana é baseada no algoritmo de otimização bayesiana. Ele seleciona amostras com base em como as amostras anteriores fizeram, para que novas amostras melhorem a métrica primária.

A amostragem bayesiana é recomendada se você tiver orçamento suficiente para explorar o espaço de hiperparâmetros. Para melhores resultados, recomendamos um número máximo de execuções maior ou igual a 20 vezes o número de hiperparâmetros que estão sendo ajustados.

O número de execuções simultâneas tem um impacto na eficácia do processo de ajuste. Um número menor de ensaios simultâneos pode levar a uma melhor convergência da amostragem, uma vez que o menor grau de paralelismo aumenta o número de ensaios que se beneficiam de ensaios concluídos anteriormente.

A amostragem bayesiana suporta choiceapenas , uniforme quniform distribuições sobre o espaço de pesquisa.

from azureml.train.hyperdrive import BayesianParameterSampling
from azureml.train.hyperdrive import uniform, choice
param_sampling = BayesianParameterSampling( {
        "learning_rate": uniform(0.05, 0.1),
        "batch_size": choice(16, 32, 64, 128)
    }
)

Especificar métrica primária

Especifique a métrica primária que você deseja otimizar o ajuste de hiperparâmetros. Cada corrida de treinamento é avaliada para a métrica primária. A política de encerramento antecipado usa a métrica principal para identificar execuções de baixo desempenho.

Especifique os seguintes atributos para sua métrica principal:

• primary_metric_name: O nome da métrica primária precisa corresponder exatamente ao nome da métrica registrada pelo script de treinamento
• primary_metric_goal: Pode ser um ou PrimaryMetricGoal.MAXIMIZEPrimaryMetricGoal.MINIMIZE e determina se a métrica primária será maximizada ou minimizada ao avaliar as execuções.

primary_metric_name="accuracy",
primary_metric_goal=PrimaryMetricGoal.MAXIMIZE

Esta amostra maximiza a "precisão".

Métricas de log para ajuste de hiperparâmetros

O script de treinamento para seu modelo deve registrar a métrica primária durante o treinamento do modelo para que o HyperDrive possa acessá-la para ajuste de hiperparâmetros.

Registre a métrica principal em seu script de treinamento com o seguinte trecho de exemplo:

from azureml.core.run import Run
run_logger = Run.get_context()
run_logger.log("accuracy", float(val_accuracy))

O script de treinamento calcula e val_accuracy registra como a métrica primária "precisão". Cada vez que a métrica é registrada, ela é recebida pelo serviço de ajuste de hiperparâmetros. Cabe a você determinar a frequência dos relatórios.

Para obter mais informações sobre o registro em log de valores em execuções de treinamento de modelo, consulte Habilitar o registro em log em execuções de treinamento do Aprendizado de Máquina do Azure.

Especificar a política de rescisão antecipada

Termine automaticamente as execuções com baixo desempenho com uma política de rescisão antecipada. A terminação antecipada melhora a eficiência computacional.

Você pode configurar os seguintes parâmetros que controlam quando uma política é aplicada:

• evaluation_interval: a frequência de aplicação da política. Cada vez que o script de treinamento registra, a métrica primária conta como um intervalo. Um evaluation_interval de 1 aplicará a política sempre que o script de treinamento relatar a métrica principal. Um evaluation_interval de 2 aplicará a política a cada duas vezes. Se não for especificado, evaluation_interval é definido como 1 por padrão.
• delay_evaluation: atrasa a primeira avaliação da política para um número especificado de intervalos. Este é um parâmetro opcional que evita o término prematuro de execuções de treinamento, permitindo que todas as configurações sejam executadas por um número mínimo de intervalos. Se especificado, a política aplica todos os múltiplos de evaluation_interval que são maiores ou iguais a delay_evaluation.

O Azure Machine Learning dá suporte às seguintes políticas de encerramento antecipado:

• Política de bandidos
• Mediana da política de paragem
• Política de seleção de truncamento
• Nenhuma política de rescisão

Política de bandidos

A política de bandidos é baseada no fator de folga/quantidade de folga e intervalo de avaliação. O bandit termina quando a métrica primária não está dentro do fator de folga/quantidade de folga especificada da execução mais bem-sucedida.

Nota

A amostragem bayesiana não suporta a terminação antecipada. Ao usar a amostragem bayesiana, defina early_termination_policy = None.

Especifique os seguintes parâmetros de configuração:

• slack_factor ou slack_amount: a folga permitida em relação à corrida de treino com melhor desempenho. slack_factor especifica a folga permitida como uma proporção. slack_amount especifica a margem disponível permitida como um montante absoluto, em vez de um rácio.

  Por exemplo, considere uma política de bandidos aplicada no intervalo 10. Suponha que a execução com melhor desempenho no intervalo 10 relatou que uma métrica primária é 0,8 com o objetivo de maximizar a métrica primária. Se a política especificar um slack_factor de 0,2, qualquer execução de treinamento cuja melhor métrica no intervalo 10 seja inferior a 0,66 (0,8/(1+slack_factor)) será encerrada.

• evaluation_interval: (facultativo) a frequência de aplicação da apólice

• delay_evaluation: (opcional) atrasa a primeira avaliação da política para um número especificado de intervalos

from azureml.train.hyperdrive import BanditPolicy
early_termination_policy = BanditPolicy(slack_factor = 0.1, evaluation_interval=1, delay_evaluation=5)

Neste exemplo, a política de rescisão antecipada é aplicada em todos os intervalos em que as métricas são relatadas, começando no intervalo de avaliação 5. Qualquer execução cuja melhor métrica seja inferior a (1/(1+0,1) ou 91% da execução com melhor desempenho será encerrada.

Mediana da política de paragem

A parada mediana é uma política de encerramento antecipado baseada em médias de execução de métricas primárias relatadas pelas execuções. Esta política calcula médias de execução em todas as execuções de treinamento e paradas de execuções cujo valor métrico primário é pior do que a mediana das médias.

Esta política utiliza os seguintes parâmetros de configuração:

• evaluation_interval: a frequência de aplicação da política (parâmetro opcional).
• delay_evaluation: atrasa a primeira avaliação da política para um número especificado de intervalos (parâmetro opcional).

from azureml.train.hyperdrive import MedianStoppingPolicy
early_termination_policy = MedianStoppingPolicy(evaluation_interval=1, delay_evaluation=5)

Neste exemplo, a política de rescisão antecipada é aplicada em todos os intervalos a partir do intervalo de avaliação 5. Uma corrida é interrompida no intervalo 5 se sua melhor métrica primária for pior do que a mediana das médias de corrida em intervalos de 1:5 em todas as corridas de treinamento.

Política de seleção de truncamento

A seleção de truncamento cancela uma porcentagem de execuções de desempenho mais baixo em cada intervalo de avaliação. As execuções são comparadas usando a métrica primária.

Esta política utiliza os seguintes parâmetros de configuração:

• truncation_percentage: a percentagem de execuções com pior desempenho a terminar em cada intervalo de avaliação. Um valor inteiro entre 1 e 99.
• evaluation_interval: (facultativo) a frequência de aplicação da apólice
• delay_evaluation: (opcional) atrasa a primeira avaliação da política para um número especificado de intervalos
• exclude_finished_jobs: especifica se os trabalhos concluídos devem ser excluídos ao aplicar a política

from azureml.train.hyperdrive import TruncationSelectionPolicy
early_termination_policy = TruncationSelectionPolicy(evaluation_interval=1, truncation_percentage=20, delay_evaluation=5, exclude_finished_jobs=true)

Neste exemplo, a política de rescisão antecipada é aplicada em todos os intervalos a partir do intervalo de avaliação 5. Uma execução termina no intervalo 5 se seu desempenho no intervalo 5 estiver nos 20% mais baixos de desempenho de todas as execuções no intervalo 5 e excluirá trabalhos concluídos ao aplicar a política.

Nenhuma política de rescisão (padrão)

Se nenhuma política for especificada, o serviço de ajuste de hiperparâmetros permitirá que todas as execuções de treinamento sejam executadas até a conclusão.

policy=None

Escolher uma política de rescisão antecipada

• Para uma política conservadora que proporcione economia sem encerrar empregos promissores, considere uma Política de Parada Mediana com evaluation_interval 1 e delay_evaluation 5. Essas são configurações conservadoras, que podem fornecer aproximadamente 25% a 35% de economia sem perda na métrica primária (com base em nossos dados de avaliação).
• Para economias mais agressivas, use a Política de Bandido com uma folga permitida menor ou a Política de Seleção de Truncamento com uma porcentagem de truncamento maior.

Criar e atribuir recursos

Controle seu orçamento de recursos especificando o número máximo de execuções de treinamento.

• max_total_runs: Número máximo de corridas de treino. Deve ser um número inteiro entre 1 e 1000.
• max_duration_minutes: (opcional) Duração máxima, em minutos, da experiência de afinação de hiperparâmetros. As execuções após esta duração são canceladas.

Nota

Se ambos max_total_runs forem max_duration_minutes especificados, o experimento de ajuste de hiperparâmetros terminará quando o primeiro desses dois limites for atingido.

Além disso, especifique o número máximo de execuções de treinamento a serem executadas simultaneamente durante a pesquisa de ajuste de hiperparâmetros.

• max_concurrent_runs: (opcional) Número máximo de execuções que podem ser executadas simultaneamente. Se não for especificado, todas as execuções serão iniciadas em paralelo. Se especificado, deve ser um número inteiro entre 1 e 100.

Nota

O número de execuções simultâneas é limitado aos recursos disponíveis no destino de computação especificado. Certifique-se de que o destino de computação tenha os recursos disponíveis para a simultaneidade desejada.

max_total_runs=20,
max_concurrent_runs=4

Esse código configura o experimento de ajuste de hiperparâmetros para usar um máximo de 20 execuções totais, executando quatro configurações ao mesmo tempo.

Configurar experimento de ajuste de hiperparâmetros

Para configurar seu experimento de ajuste de hiperparâmetros, forneça o seguinte:

• O espaço de pesquisa de hiperparâmetros definido
• A sua política de rescisão antecipada
• A métrica primária
• Configurações de alocação de recursos
• ScriptRunConfig script_run_config

O ScriptRunConfig é o script de treinamento que será executado com os hiperparâmetros de exemplo. Ele define os recursos por trabalho (único ou multinó) e o destino de computação a ser usado.

Nota

O destino de computação usado deve script_run_config ter recursos suficientes para satisfazer seu nível de simultaneidade. Para obter mais informações sobre ScriptRunConfig, consulte Configurar execuções de treinamento.

Configure seu experimento de ajuste de hiperparâmetros:

from azureml.train.hyperdrive import HyperDriveConfig
from azureml.train.hyperdrive import RandomParameterSampling, BanditPolicy, uniform, PrimaryMetricGoal

param_sampling = RandomParameterSampling( {
        'learning_rate': uniform(0.0005, 0.005),
        'momentum': uniform(0.9, 0.99)
    }
)

early_termination_policy = BanditPolicy(slack_factor=0.15, evaluation_interval=1, delay_evaluation=10)

hd_config = HyperDriveConfig(run_config=script_run_config,
                             hyperparameter_sampling=param_sampling,
                             policy=early_termination_policy,
                             primary_metric_name="accuracy",
                             primary_metric_goal=PrimaryMetricGoal.MAXIMIZE,
                             max_total_runs=100,
                             max_concurrent_runs=4)

O HyperDriveConfig define os parâmetros passados para o ScriptRunConfig script_run_config. O script_run_config, por sua vez, passa parâmetros para o roteiro de treinamento. O trecho de código acima é retirado do bloco de anotações de exemplo Train, hyperparameter tune e deploy with PyTorch. Nesta amostra, os learning_rate parâmetros e momentum serão ajustados. A parada antecipada de execuções será determinada por um BanditPolicy, que interrompe uma execução cuja métrica principal está fora da (consulte Referência slack_factor de classe BanditPolicy).

O código a seguir do exemplo mostra como os valores ajustados são recebidos, analisados e passados para a função do fine_tune_model script de treinamento:

# from pytorch_train.py
def main():
    print("Torch version:", torch.__version__)

    # get command-line arguments
    parser = argparse.ArgumentParser()
    parser.add_argument('--num_epochs', type=int, default=25,
                        help='number of epochs to train')
    parser.add_argument('--output_dir', type=str, help='output directory')
    parser.add_argument('--learning_rate', type=float,
                        default=0.001, help='learning rate')
    parser.add_argument('--momentum', type=float, default=0.9, help='momentum')
    args = parser.parse_args()

    data_dir = download_data()
    print("data directory is: " + data_dir)
    model = fine_tune_model(args.num_epochs, data_dir,
                            args.learning_rate, args.momentum)
    os.makedirs(args.output_dir, exist_ok=True)
    torch.save(model, os.path.join(args.output_dir, 'model.pt'))

Importante

Cada execução de hiperparâmetro reinicia o treinamento do zero, incluindo a reconstrução do modelo e de todos os carregadores de dados. Você pode minimizar esse custo usando um pipeline do Azure Machine Learning ou um processo manual para fazer o máximo de preparação de dados possível antes das execuções de treinamento.

Enviar experimento de ajuste de hiperparâmetro

Depois de definir sua configuração de ajuste de hiperparâmetro, envie o experimento:

from azureml.core.experiment import Experiment
experiment = Experiment(workspace, experiment_name)
hyperdrive_run = experiment.submit(hd_config)

Ajuste de hiperparâmetros de inicialização a quente (opcional)

Encontrar os melhores valores de hiperparâmetros para o seu modelo pode ser um processo iterativo. Você pode reutilizar o conhecimento das cinco execuções anteriores para acelerar o ajuste de hiperparâmetros.

O arranque a quente é tratado de forma diferente, dependendo do método de amostragem:

• Amostragem bayesiana: Os ensaios da execução anterior são usados como conhecimento prévio para escolher novas amostras e melhorar a métrica primária.
• Amostragem aleatória ou amostragem de grade: o encerramento antecipado usa o conhecimento de execuções anteriores para determinar execuções de baixo desempenho.

Especifique a lista de execuções pai a partir das quais você deseja começar a quente.

from azureml.train.hyperdrive import HyperDriveRun

warmstart_parent_1 = HyperDriveRun(experiment, "warmstart_parent_run_ID_1")
warmstart_parent_2 = HyperDriveRun(experiment, "warmstart_parent_run_ID_2")
warmstart_parents_to_resume_from = [warmstart_parent_1, warmstart_parent_2]

Se um experimento de ajuste de hiperparâmetro for cancelado, você poderá retomar as execuções de treinamento a partir do último ponto de verificação. No entanto, seu script de treinamento deve lidar com a lógica de ponto de verificação.

A execução de treinamento deve usar a mesma configuração de hiperparâmetro e montou as pastas de saída. O script de treinamento deve aceitar o argumento, que contém o resume-from ponto de verificação ou os arquivos de modelo a partir dos quais retomar a execução do treinamento. Você pode retomar as execuções de treinamento individuais usando o seguinte trecho:

from azureml.core.run import Run

resume_child_run_1 = Run(experiment, "resume_child_run_ID_1")
resume_child_run_2 = Run(experiment, "resume_child_run_ID_2")
child_runs_to_resume = [resume_child_run_1, resume_child_run_2]

Você pode configurar seu experimento de ajuste de hiperparâmetros para iniciar a quente de um experimento anterior ou retomar execuções de treinamento individuais usando os parâmetros resume_from opcionais e resume_child_runs na configuração:

from azureml.train.hyperdrive import HyperDriveConfig

hd_config = HyperDriveConfig(run_config=script_run_config,
                             hyperparameter_sampling=param_sampling,
                             policy=early_termination_policy,
                             resume_from=warmstart_parents_to_resume_from,
                             resume_child_runs=child_runs_to_resume,
                             primary_metric_name="accuracy",
                             primary_metric_goal=PrimaryMetricGoal.MAXIMIZE,
                             max_total_runs=100,
                             max_concurrent_runs=4)

Visualize execuções de ajuste de hiperparâmetros

Você pode visualizar suas execuções de ajuste de hiperparâmetro no estúdio do Azure Machine Learning ou pode usar um widget de bloco de anotações.

Studio

Você pode visualizar todas as suas execuções de ajuste de hiperparâmetro no estúdio do Azure Machine Learning. Para obter mais informações sobre como exibir um experimento no portal, consulte Exibir registros de execução no estúdio.

• Gráfico de métricas: esta visualização rastreia as métricas registradas para cada execução filho do hyperdrive durante a duração do ajuste do hiperparâmetro. Cada linha representa uma execução filho e cada ponto mede o valor da métrica primária nessa iteração de tempo de execução.

  

• Gráfico de coordenadas paralelas: esta visualização mostra a correlação entre o desempenho da métrica primária e os valores de hiperparâmetros individuais. O gráfico é interativo através do movimento de eixos (clique e arraste pelo rótulo do eixo) e destacando valores em um único eixo (clique e arraste verticalmente ao longo de um único eixo para destacar um intervalo de valores desejados). O gráfico de coordenadas paralelas inclui um eixo na parte mais à direita do gráfico que plota o melhor valor métrico correspondente aos hiperparâmetros definidos para essa instância de execução. Este eixo é fornecido para projetar a legenda do gradiente do gráfico nos dados de uma forma mais legível.

  

• Gráfico de Dispersão 2-Dimensional: Esta visualização mostra a correlação entre quaisquer dois hiperparâmetros individuais, juntamente com o seu valor métrico primário associado.

  

• Gráfico de Dispersão 3-Dimensional: Esta visualização é a mesma que 2D, mas permite três dimensões hipermétricas de correlação com o valor métrico primário. Você também pode clicar e arrastar para reorientar o gráfico para visualizar diferentes correlações no espaço 3D.

  

Widget do bloco de notas

Use o widget Bloco de anotações para visualizar o progresso de suas execuções de treinamento. O trecho a seguir visualiza todas as execuções de ajuste de hiperparâmetros em um só lugar em um bloco de anotações Jupyter:

from azureml.widgets import RunDetails
RunDetails(hyperdrive_run).show()

Esse código exibe uma tabela com detalhes sobre as execuções de treinamento para cada uma das configurações de hiperparâmetros.

Você também pode visualizar o desempenho de cada uma das corridas à medida que o treinamento progride.

Encontre o melhor modelo

Quando todas as execuções de ajuste de hiperparâmetros forem concluídas, identifique a configuração de melhor desempenho e os valores de hiperparâmetros:

best_run = hyperdrive_run.get_best_run_by_primary_metric()
best_run_metrics = best_run.get_metrics()
parameter_values = best_run.get_details()['runDefinition']['arguments']

print('Best Run Id: ', best_run.id)
print('\n Accuracy:', best_run_metrics['accuracy'])
print('\n learning rate:',parameter_values[3])
print('\n keep probability:',parameter_values[5])
print('\n batch size:',parameter_values[7])

Exemplo de caderno

Consulte os blocos de anotações train-hyperparameter-* nesta pasta:

• how-to-use-azureml/ml-frameworks

Saiba como executar blocos de notas ao seguir o artigo Utilizar blocos de notas Jupyter para explorar este serviço.

Próximos passos

• Rastrear um experimento
• Implantar um modelo treinado