Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.

# Registrazione di parametri e metriche con Amazon Experiments SageMaker
<a name="train-remote-decorator-experiments"></a>

Questa guida mostra come registrare parametri e metriche con Amazon SageMaker Experiments. Un esperimento di SageMaker intelligenza artificiale è composto da esecuzioni e ogni esecuzione è composta da tutti gli input, i parametri, le configurazioni e i risultati per un'interazione formativa basata su un singolo modello. 

È possibile registrare parametri e metriche da una funzione remota utilizzando il decoratore @remote o l'API `RemoteExecutor`. 

Per registrare i parametri e le metriche da una funzione remota, scegli uno dei metodi riportati di seguito:
+ Crea un'istanza di un esperimento di SageMaker intelligenza artificiale eseguito all'interno di una funzione remota utilizzando `Run` la libreria Experiments. SageMaker Per ulteriori informazioni, consulta [Create an Amazon SageMaker AI Experiment](https://docs.aws.amazon.com/sagemaker/latest/dg/experiments-create.html).
+ Usa la `load_run` funzione all'interno di una funzione remota della libreria SageMaker AI Experiments. Questo caricherà un'istanza `Run` dichiarata al di fuori della funzione remota.

Le sezioni seguenti mostrano come creare e tracciare il lignaggio con le esecuzioni di esperimenti di SageMaker intelligenza artificiale utilizzando i metodi elencati in precedenza. Le sezioni descrivono anche i casi che non sono supportati dalla SageMaker formazione.

## Usa il decoratore @remote per l'integrazione con SageMaker Experiments
<a name="train-remote-decorator-experiments-remote"></a>

Puoi creare un'istanza di un esperimento di SageMaker intelligenza artificiale o caricare un esperimento di intelligenza SageMaker artificiale corrente dall'interno di una funzione remota. Nelle sezioni seguenti viene illustrato come utilizzare entrambi i metodi. 

### Crea un esperimento con Experiments SageMaker
<a name="train-remote-decorator-experiments-remote-create"></a>

Puoi creare un esperimento eseguito in SageMaker AI Experiment. A tal fine, dovrai inoltrare il nome dell'esperimento, il nome dell'esecuzione e altri parametri alla funzione remota.

Il seguente esempio di codice importa il nome dell'esperimento, il nome dell'esecuzione e i parametri da registrare durante ogni esecuzione. I parametri `param_1` e `param_2` vengono registrati nel tempo all'interno di un ciclo di addestramento. I parametri comuni possono includere le dimensioni dei lotti o le epoche. In questo esempio, le metriche `metric_a` e `metric_b` vengono registrate per un'esecuzione nel tempo all'interno di un ciclo di addestramento. Altre metriche comuni possono includere `accuracy` o `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")
```

### Carica SageMaker gli esperimenti attuali con un lavoro avviato dal decoratore @remote
<a name="train-remote-decorator-experiments-remote-current"></a>

Utilizzate la `load_run()` funzione della libreria SageMaker Experiments per caricare l'oggetto run corrente dal contesto di esecuzione. È inoltre possibile utilizzare la funzione `load_run()` all'interno della funzione remota. Carica l'oggetto di esecuzione inizializzato localmente dall'istruzione `with` sull'oggetto di esecuzione, come illustrato nel seguente esempio di codice.

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

## Carica un esperimento corrente eseguito all'interno di un processo avviato con l'API `RemoteExecutor`
<a name="train-remote-decorator-experiments-api"></a>

Puoi anche caricare un esperimento di SageMaker intelligenza artificiale in corso se i tuoi lavori sono stati avviati con l'`RemoteExecutor`API. Il seguente esempio di codice mostra come utilizzare l'`RemoteExecutor`API con la `load_run` funzione SageMaker Experiments. Questa operazione viene eseguita per caricare un esperimento di SageMaker intelligenza artificiale in corso e acquisire le metriche del lavoro inviato da`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)
```

## Usi non supportati per SageMaker gli esperimenti durante l'annotazione del codice con un decoratore @remote
<a name="train-remote-decorator-experiments-unsupported"></a>

SageMaker L'intelligenza artificiale non supporta il passaggio `Run` di un oggetto di tipo a una funzione @remote o l'utilizzo di oggetti globali. `Run` I seguenti esempi mostrano il codice che genererà un `SerializationError`.

Il seguente esempio di codice tenta di trasmettere un oggetto tipo `Run` a un decoratore @remote e genera un errore.

```
@remote
def func(run: Run):
    run.log_metrics("metric_a", 1.0)
    
with Run(...) as run:
    func(run) ---> SerializationError caused by NotImplementedError
```

Il seguente esempio di codice tenta di utilizzare un oggetto `run` globale istanziato all'esterno della funzione remota. Nell'esempio di codice, la funzione `train()` è definita all'interno del contesto `with Run`, facendo riferimento a un oggetto di esecuzione globale dall'interno. Quando `train()` viene richiamato, genera un errore.

```
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
```