Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.

# Protokollierung von Parametern und Metriken mit Amazon SageMaker Experiments
<a name="train-remote-decorator-experiments"></a>

Diese Anleitung zeigt, wie Sie Parameter und Metriken mit Amazon SageMaker Experiments protokollieren. Ein SageMaker KI-Experiment besteht aus Durchläufen, und jeder Lauf besteht aus allen Eingaben, Parametern, Konfigurationen und Ergebnissen für eine einzelne Modelltrainingsinteraktion. 

Sie können Parameter und Kennzahlen von einer Remote-Funktion aus entweder mit dem @remote Decorator oder der `RemoteExecutor` API protokollieren. 

Wählen Sie eine der folgenden Methoden aus, um Parameter und Kennzahlen von einer Remote-Funktion zu protokollieren:
+ Instanziieren Sie mithilfe `Run` der Experimentsbibliothek ein SageMaker KI-Experiment, das SageMaker in einer Remote-Funktion ausgeführt wird. Weitere Informationen finden Sie unter [Erstellen Sie ein Amazon SageMaker AI-Experiment](https://docs.aws.amazon.com/sagemaker/latest/dg/experiments-create.html).
+ Verwenden Sie die `load_run` Funktion in einer Remote-Funktion aus der SageMaker AI Experiments-Bibliothek. Dann wird eine `Run` Instance geladen, die außerhalb der Remote-Funktion deklariert wird.

In den folgenden Abschnitten wird gezeigt, wie Sie mithilfe der oben aufgeführten Methoden mithilfe von SageMaker KI-Experimentläufen eine Abstammungslinie erstellen und verfolgen können. In den Abschnitten werden auch Fälle beschrieben, die nicht durch SageMaker Schulungen unterstützt werden.

## Verwenden Sie den @remote -Decorator zur Integration mit Experiments SageMaker
<a name="train-remote-decorator-experiments-remote"></a>

Sie können entweder ein Experiment in SageMaker KI instanziieren oder ein aktuelles SageMaker KI-Experiment aus einer Remote-Funktion laden. In den folgenden Abschnitten erfahren Sie, wie Sie jede dieser beiden Methoden verwenden können. 

### Erstellen Sie ein Experiment mit Experimenten SageMaker
<a name="train-remote-decorator-experiments-remote-create"></a>

Sie können einen Experimentlauf im SageMaker KI-Experiment erstellen. Dazu übergeben Sie den Namen Ihres Experiments, den Namen des Durchgangs und weitere Parameter an Ihre Remote-Funktion.

Der folgende Beispielcode importiert den Namen Ihres Experiments, den Namen des Durchlaufs und die Parameter, die bei jedem Durchlauf protokolliert werden sollen. Die Parameter `param_1` und `param_2` werden im Laufe der Zeit in einer Trainingsschleife protokolliert. Allgemeine Parameter sind ggf. u.a. Chargengröße oder Epochen. In diesem Beispiel werden die Kennzahlen `metric_a` und `metric_b` für einen längeren Zeitraum innerhalb einer Trainingsschleife protokolliert. Weitere gängige Kennzahlen können `accuracy` oder `loss` sein. 

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

### Laden Sie aktuelle SageMaker Experimente mit einem Job, der vom @remote -Decorator initiiert wurde
<a name="train-remote-decorator-experiments-remote-current"></a>

Verwenden Sie die `load_run()` Funktion aus der SageMaker Experiments-Bibliothek, um das aktuelle Run-Objekt aus dem Run-Kontext zu laden. Sie können die `load_run()` Funktion auch in Ihrer Remote-Funktion verwenden. Laden Sie das Lauf-Objekt, das lokal durch die `with` Anweisung für das Lauf-Objekt initialisiert wird, wie im folgenden Beispielcode gezeigt.

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

## Einen aktuellen Experimentlauf in einem Job laden, der mit der `RemoteExecutor` API initiiert wird
<a name="train-remote-decorator-experiments-api"></a>

Sie können auch einen aktuellen SageMaker KI-Experimentlauf laden, wenn Ihre Jobs mit der `RemoteExecutor` API initiiert wurden. Das folgende Codebeispiel zeigt, wie Sie die `RemoteExecutor` API mit der SageMaker `load_run` Experiments-Funktion verwenden. Sie tun dies, um einen aktuellen SageMaker KI-Experimentlauf zu laden und Metriken in dem Job zu erfassen, der von eingereicht wurde`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)
```

## Nicht unterstützte Verwendungen für SageMaker Experimente beim Kommentieren Ihres Codes mit einem @remote -Decorator
<a name="train-remote-decorator-experiments-unsupported"></a>

SageMaker AI unterstützt nicht die Übergabe eines `Run` Typobjekts an eine @remote -Funktion oder die Verwendung globaler Objekte. `Run` Die folgenden Beispiele zeigen Code, der eine `SerializationError` auslöst.

Im folgenden Beispielcode wird versucht, ein Objekt vom Typ `Run` an einen @remote Decorator zu übergeben. Das führt zu einem Fehler.

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

Im folgenden Beispielcode wird versucht, ein globales `run` Objekt zu verwenden, das außerhalb der Remote-Funktion instanziiert wurde. Im Beispielcode ist die `train()` Funktion innerhalb des `with Run` Kontextes definiert und verweist von innen auf ein globales Lauf-Objekt. Wenn `train()` aufgerufen wird, kommt es zu einem Fehler.

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