Consigner manuellement des données dans une exécution de test

Métriques récapitulatives

Les métriques récapitulatives sont des métriques scalaires à valeur unique stockées à côté des métriques de séries temporelles. Elles représentent un résumé final d'une exécution de test.

Un exemple de cas d'utilisation est l'arrêt prématuré lorsqu'une configuration patience permet une poursuite de l'entraînement, mais que le modèle candidat est restauré à partir d'une étape précédente et que les métriques calculées pour le modèle à cette étape seraient représentées comme une métrique récapitulative, car la dernière métrique de séries temporelles n'est pas représentative du modèle restauré. L'API log_metrics pour les métriques récapitulatives est utilisée à cette fin.

def log_metrics_sample(
    experiment_name: str,
    run_name: str,
    metrics: Dict[str, float],
    project: str,
    location: str,
):
    aiplatform.init(experiment=experiment_name, project=project, location=location)

    aiplatform.start_run(run=run_name)

    aiplatform.log_metrics(metrics)

Métriques de séries temporelles

Pour enregistrer les métriques de séries temporelles, les tests de Vertex AI nécessitent une instance de sauvegarde Vertex AI TensorBoard.

Attribuez une ressource TensorBoard à Vertex AI pour la journalisation des métriques de séries temporelles.

Toutes les métriques enregistrées via log_time_series_metrics sont stockées en tant que métriques de séries temporelles. Vertex AI TensorBoard est le magasin de métriques de séries temporelles de sauvegarde.

Le experiment_tensorboard peut être défini aux niveaux test et exécution du test. La définition de experiment_tensorboard au niveau de l'exécution remplace le paramètre au niveau du test. Une fois que le experiment_tensorboard est défini dans une exécution, son experiment_tensorboard ne peut plus être modifié.

• Définir experiment_tensorboard au niveau du test :

    aiplatform.init(experiment='my-experiment',
                 experiment_tensorboard='projects/.../tensorboard/my-tb-resource')
  

• Définir experiment_tensorboard au niveau de l'exécution : Remarque : Cela remplace le paramètre au niveau du test.

    aiplatform.start_run(run_name='my-other-run',
                      tensorboard='projects/.../.../other-resource')
  aiplatform.log_time_series_metrics(...)
  

def log_time_series_metrics_sample(
    experiment_name: str,
    run_name: str,
    metrics: Dict[str, float],
    step: Optional[int],
    wall_time: Optional[timestamp_pb2.Timestamp],
    project: str,
    location: str,
):
    aiplatform.init(experiment=experiment_name, project=project, location=location)

    aiplatform.start_run(run=run_name, resume=True)

    aiplatform.log_time_series_metrics(metrics=metrics, step=step, wall_time=wall_time)

Étape et durée d'exécution

L'API log_time_series_metrics accepte éventuellement step et walltime.

• step : facultatif. Index des étapes de ce point de données dans l'exécution. Si cette valeur n'est pas fournie, un incrément pour la dernière étape parmi toutes les métriques de séries temporelles déjà consignées est utilisé. Si l'étape existe pour l'une des clés de métriques fournies, elle est remplacée.
• wall_time : facultatif. Secondes après l'epoch de la métrique enregistrée. Si cet argument n'est pas spécifié, la valeur par défaut est la valeur time.time de Python.

Exemple :

aiplatform.log_time_series_metrics({"mse": 2500.00, "rmse": 50.00})

Se connecter à une étape spécifique

aiplatform.log_time_series_metrics({"mse": 2500.00, "rmse": 50.00}, step=8)

Inclure wall_time

aiplatform.log_time_series_metrics({"mse": 2500.00, "rmse": 50.00}, step=10)

Paramètres

Les paramètres sont des valeurs d'entrée à clé qui configurent une exécution, régulent le comportement de l'exécution et affectent les résultats de l'exécution. Exemples : taux d'apprentissage, taux d'abandon et nombre d'étapes d'entraînement. Paramètres de journalisation via la méthode log_params.

def log_params_sample(
    experiment_name: str,
    run_name: str,
    params: Dict[str, Union[float, int, str]],
    project: str,
    location: str,
):
    aiplatform.init(experiment=experiment_name, project=project, location=location)

    aiplatform.start_run(run=run_name, resume=True)

    aiplatform.log_params(params)

aiplatform.log_params({"learning_rate": 0.01, "n_estimators": 10})

Métriques de classification

Outre les métriques récapitulatives et les métriques de séries temporelles, les matrices de confusion et les courbes ROC sont des métriques couramment utilisées. Elles peuvent être enregistrées dans les tests Vertex AI à l'aide de l'API log_classification_metrics.

def log_classification_metrics_sample(
    experiment_name: str,
    run_name: str,
    project: str,
    location: str,
    labels: Optional[List[str]] = None,
    matrix: Optional[List[List[int]]] = None,
    fpr: Optional[List[float]] = None,
    tpr: Optional[List[float]] = None,
    threshold: Optional[List[float]] = None,
    display_name: Optional[str] = None,
) -> None:
    aiplatform.init(experiment=experiment_name, project=project, location=location)

    aiplatform.start_run(run=run_name, resume=True)

    aiplatform.log_classification_metrics(
        labels=labels,
        matrix=matrix,
        fpr=fpr,
        tpr=tpr,
        threshold=threshold,
        display_name=display_name,
    )