Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.
# Paramètres et métriques de journalisation avec Amazon SageMaker Experiments
Ce guide explique comment enregistrer les paramètres et les métriques avec Amazon SageMaker Experiments. Une expérience d' SageMaker IA consiste en des essais, et chaque cycle comprend l'ensemble des entrées, des paramètres, des configurations et des résultats d'une interaction d'entraînement sur un seul modèle.
Vous pouvez journaliser les paramètres et les métriques d’une fonction distante à l’aide du décorateur @remote ou de l’API `RemoteExecutor`.
Pour journaliser les paramètres et les métriques d’une fonction distante, choisissez l’une des méthodes suivantes :
+ Instanciez une expérience d' SageMaker IA exécutée dans une fonction distante à l'aide `Run` de la bibliothèque SageMaker Experiments. Pour plus d'informations, consultez [Create an Amazon SageMaker AI Experiment](https://docs.aws.amazon.com/sagemaker/latest/dg/experiments-create.html).
+ Utilisez la `load_run` fonction dans une fonction distante de la bibliothèque SageMaker AI Experiments. Cela chargera une instance `Run` déclarée en dehors de la fonction distante.
Les sections suivantes montrent comment créer et suivre le lignage avec des essais d' SageMaker IA en utilisant les méthodes répertoriées ci-dessus. Les sections décrivent également les cas qui ne sont pas pris en charge par SageMaker la formation.
## Utilisez le décorateur @remote pour intégrer Experiments SageMaker
Vous pouvez soit instancier une expérience dans SageMaker AI, soit charger une expérience SageMaker AI en cours depuis une fonction distante. Les sections suivantes montrent comment utiliser l’une ou l’autre méthode.
### Créez une expérience avec des SageMaker expériences
Vous pouvez créer une expérience exécutée dans une expérience d' SageMaker IA. Pour ce faire, vous transmettez le nom de votre expérience, le nom de l’exécution et d’autres paramètres à votre fonction distante.
L’exemple de code suivant importe le nom de votre expérience, le nom de l’exécution et les paramètres à journaliser lors de chaque exécution. Les paramètres `param_1` et `param_2` sont journalisés au fil du temps dans une boucle d’entraînement. Les paramètres courants peuvent inclure la taille du lot ou les époques. Dans cet exemple, les métriques `metric_a` et `metric_b` sont journalisées pour une période prolongée au sein d’une boucle d’entraînement. D’autres métriques courantes peuvent inclure `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")
```
### Charger les SageMaker expériences en cours avec une tâche initiée par le décorateur @remote
Utilisez la `load_run()` fonction de la bibliothèque SageMaker Experiments pour charger l'objet d'exécution en cours à partir du contexte d'exécution. Vous pouvez également utiliser la fonction `load_run()` au sein de votre fonction distante. Chargez l’objet d’exécution initialisé localement par l’instruction `with` sur l’objet d’exécution, comme illustré dans l’exemple de code suivant.
```
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)
```
## Charger une exécution d’expérience en cours dans le cadre d’une tâche initiée avec l’API `RemoteExecutor`
Vous pouvez également charger une expérience d' SageMaker IA en cours si vos tâches ont été initiées avec l'`RemoteExecutor`API. L'exemple de code suivant montre comment utiliser l'`RemoteExecutor`API avec la `load_run` fonction SageMaker Experiments. Vous procédez ainsi pour charger une expérience d' SageMaker IA en cours et capturer des métriques dans le travail soumis par`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)
```
## Utilisations non prises en charge pour les SageMaker expériences lors de l'annotation de votre code avec un décorateur @remote
SageMaker L'IA ne permet pas de transmettre un objet `Run` de type à une fonction @remote ou d'utiliser `Run` des objets globaux. Les exemples suivants montrent le code qui lancera une `SerializationError`.
L’exemple de code suivant tente de transmettre un objet de type `Run` à un décorateur @remote et génère une erreur.
```
@remote
def func(run: Run):
run.log_metrics("metric_a", 1.0)
with Run(...) as run:
func(run) ---> SerializationError caused by NotImplementedError
```
L’exemple de code suivant tente d’utiliser un objet global `run` instancié en dehors de la fonction distante. Dans l’exemple de code, la fonction `train()` est définie dans le contexte `with Run`, faisant référence à un objet d’exécution global depuis l’intérieur. Lorsque `train()` est appelé, il génère une erreur.
```
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
```