As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.
# Registrando parâmetros e métricas com Amazon SageMaker Experiments
Este guia mostra como registrar parâmetros e métricas com o Amazon SageMaker Experiments. Um experimento de SageMaker IA consiste em execuções, e cada execução consiste em todas as entradas, parâmetros, configurações e resultados para uma única interação de treinamento de modelo.
Você pode registrar parâmetros e métricas em uma função remota usando o decorador @remote ou a API `RemoteExecutor`.
Para registrar parâmetros e métricas em uma função remota, escolha um dos seguintes métodos:
+ Instancie um experimento de SageMaker IA executado dentro de uma função remota usando a `Run` biblioteca SageMaker Experiments. Para obter mais informações, consulte [Criar um experimento de SageMaker IA da Amazon](https://docs.aws.amazon.com/sagemaker/latest/dg/experiments-create.html).
+ Use a `load_run` função dentro de uma função remota da biblioteca SageMaker AI Experiments. Isso carregará uma instância `Run` declarada fora da função remota.
As seções a seguir mostram como criar e rastrear linhagens com execuções de experimentos de SageMaker IA usando os métodos listados anteriormente. As seções também descrevem casos que não são suportados pelo SageMaker treinamento.
## Use o decorador @remote para integrar com Experiments SageMaker
Você pode instanciar um experimento em SageMaker IA ou carregar um experimento de SageMaker IA atual de dentro de uma função remota. As seções a seguir mostram como usar qualquer um dos métodos.
### Crie um experimento com SageMaker Experimentos
Você pode criar um experimento executado no experimento de SageMaker IA. Para fazer isso, você passa o nome do experimento, o nome da execução e outros parâmetros para a função remota.
O exemplo de código a seguir importa o nome do experimento e da execução e os parâmetros a serem registrados durante cada execução. Os parâmetros `param_1` e `param_2` são registrados ao longo do tempo dentro de um ciclo de treinamento. Os parâmetros comuns poderão incluir tamanho do lote ou épocas. Neste exemplo, as métricas `metric_a` e `metric_b` são registradas para uma corrida ao longo do tempo dentro de um ciclo de treinamento. Outras métricas comuns poderão incluir `accuracy` ou `loss`.
```
from sagemaker.remote_function import remote
from sagemaker.experiments.run import Run
# Define your remote function
@remote
def train({{value_1}}, {{value_2}}, {{exp_name}}, {{run_name}}):
...
...
#Creates the experiment
with Run(
experiment_name=exp_name,
run_name=run_name,
) as run:
...
#Define values for the parameters to log
run.log_parameter("{{param_1}}", value_1)
run.log_parameter("{{param_2}}", value_2)
...
#Define metrics to log
run.log_metric("{{metric_a}}", 0.5)
run.log_metric("{{metric_b}}", 0.1)
# Invoke your remote function
train(1.0, 2.0, "my-exp-name", "my-run-name")
```
### Carregue SageMaker os experimentos atuais com um trabalho iniciado pelo decorador @remote
Use a `load_run()` função da biblioteca SageMaker Experiments para carregar o objeto de execução atual a partir do contexto de execução. Você também pode usar a função `load_run()` na função remota. Carregue o objeto de execução inicializado localmente pela instrução `with` no objeto de execução, conforme mostrado no exemplo de código a seguir.
```
from sagemaker.experiments.run import Run, load_run
# Define your remote function
@remote
def train({{value_1}}, {{value_2}}):
...
...
with load_run() as run:
run.log_metric("{{metric_a}}", value_1)
run.log_metric("{{metric_b}}", value_2)
# Invoke your remote function
with Run(
experiment_name="{{my-exp-name}}",
run_name="{{my-run-name}}",
) as run:
train(0.5, 1.0)
```
## Carregar um experimento atual executado em um trabalho iniciado com a API `RemoteExecutor`
Você também pode carregar um experimento de SageMaker IA atual executado se seus trabalhos foram iniciados com a `RemoteExecutor` API. O exemplo de código a seguir mostra como usar a `RemoteExecutor` API com a `load_run` função SageMaker Experiments. Você faz isso para carregar um experimento de SageMaker IA atual executado e capturar métricas no trabalho enviado por`RemoteExecutor`.
```
from sagemaker.experiments.run import Run, load_run
def square(x):
with load_run() as run:
result = x * x
run.log_metric("result", result)
return result
with RemoteExecutor(
max_parallel_job=2,
instance_type="{{ml.m5.large}}"
) as e:
with Run(
experiment_name="{{my-exp-name}}",
run_name="{{my-run-name}}",
):
future_1 = e.submit(square, 2)
```
## Usos não suportados para SageMaker experimentos ao anotar seu código com um decorador @remote
SageMaker A IA não suporta a passagem `Run` de um objeto de tipo para uma função @remote nem o uso de `Run` objetos globais. Os exemplos a seguir mostram um código que emitirá um `SerializationError`.
O exemplo de código a seguir tenta passar um objeto de tipo `Run` para um decorador @remote e gera um erro.
```
@remote
def func(run: Run):
run.log_metrics("metric_a", 1.0)
with Run(...) as run:
func(run) ---> SerializationError caused by NotImplementedError
```
O exemplo de código a seguir tenta usar um objeto `run` global instanciado fora da função remota. No exemplo de código, a função `train()` é definida dentro do contexto `with Run`, fazendo referência a um objeto global executado de dentro. Quando o `train()` é chamado, ele gera um erro.
```
with Run(...) as run:
@remote
def train({{metric_1}}, {{value_1}}, {{metric_2}}, {{value_2}}):
run.log_parameter(metric_1, value_1)
run.log_parameter(metric_2, value_2)
train("p1", 1.0, "p2", 0.5) ---> SerializationError caused by NotImplementedError
```