Exécuter une expérience pour comparer et sélectionner des modèles

Avec Snowflake ML Experiments, vous pouvez mettre en place des expériences, des évaluations organisées des résultats de l’entraînement des modèles. Cela vous permet de comparer rapidement les résultats de l’ajustement des hyperparamètres, différentes mesures cibles et le comportement de différents types de modèles de manière structurée afin de sélectionner le modèle le mieux adapté à vos besoins. Chaque expérience est constituée d’une série d’exécutions, qui sont des métadonnées et des artefacts de votre entraînement. Snowflake n’a pas d’avis sur vos artefacts d’exécution. Vous pouvez soumettre tout ce qui est utile pour votre processus d’évaluation de modèles.

Une fois l’expérience terminée, les résultats sont visibles sur Snowsight. Vous pouvez également récupérer des artefacts exécutés à tout moment en Python ou SQL.

Note

Snowflake Experiments nécessite snowflake-ml-python version 1.19.0 ou ultérieure.

Exigences en matière de contrôle d’accès

La création d’une expérience nécessite le privilège CREATE EXPERIMENT sur le schéma dans lequel les artefacts exécutés sont stockés. La création d’une expérience nécessite le privilège USAGE sur la base de données et le schéma parents.

Créer une expérience

Tout d’abord, créez une expérience. Cela nécessite une base de données et un schéma existants, utilisés pour stocker les informations d’exécution.

La prise en charge de l’expérience est disponible dans la classe snowflake.ml.experiment.ExperimentTracking. Utiliser la méthode set_experiment(name: Optional[str]) permet à la fois d’ouvrir une expérience avec le nom donné et de la définir dans le contexte de l’expérience active pour les journaux et les artefacts. Les expériences qui n’existent pas encore sont créées.

L’exemple suivant montre comment créer ou ouvrir une expérience nommée My_Experiment dans la base de données et le schéma actifs et le définir comme expérience active, en utilisant un fichier existant session :

from snowflake.ml.experiment import ExperimentTracking

exp = ExperimentTracking(session=session)
exp.set_experiment("My_Experiment")
Copy

Démarrer une exécution d’expérience

Chaque exécution d’une expérience possède son propre ensemble de métriques, de paramètres et d’artefacts. Ces informations sont utilisées dans Snowsight pour fournir des visualisations et des données sur votre entraînement de modèle et ses résultats.

Démarrez une exécution avec la méthode start_run(name: Optional[str]) sur votre instance ExperimentTracking. Cela renvoie une nouvelle Run, qui prend en charge l’utilisation dans une instruction with. Snowflake vous recommande d’utiliser les instructions with, de sorte que les exécutions soient correctement terminées et qu’il soit plus facile de raisonner sur la portée de l’exécution.

with exp.start_run("my_run"):
  # .. Train your model and log artifacts
Copy

Consigner automatiquement les informations d’entraînement

Vous pouvez enregistrer automatiquement des informations d’entraînement pour les modèles XGBoost, LightGBM, ou Keras pendant l’entraînement du modèle. La journalisation automatique est effectuée en enregistrant un rappel qui fait référence à votre expérience et à des informations sur le modèle que vous entraînez. Chaque fois qu’une méthode est appelée sur votre instance Model qui ajuste un paramètre ou une métrique, elle est automatiquement connectée à votre expérience pour l’exécution active.

L’exemple suivant montre comment configurer les rappels de votre expérience pour chaque modèle d’entraînement pris en charge, puis démarrer un cycle d’entraînement de base pour enregistrer les artefacts.

# exp: ExperimentTracking

from xgboost import XGBClassifier

from snowflake.ml.experiment.callback.xgboost import SnowflakeXgboostCallback
from snowflake.ml.model.model_signature import infer_signature

sig = infer_signature(X, y)
callback = SnowflakeXgboostCallback(
    exp, model_name="name", model_signature=sig
)
model = XGBClassifier(callbacks=[callback])
with exp.start_run("my_run"):
    model.fit(X, y, eval_set=[(X, y)])
Copy

Enregistrement manuel des informations d’entraînement et des artefacts

Pour les modèles qui ne prennent pas en charge la journalisation automatique ou qui sont préentraînés, vous pouvez consigner manuellement les informations d’expérience et charger des artefacts en Python. Les paramètres sont des entrées constantes dans le modèle d’entraînement, tandis que les métriques sont évaluées à une étape du modèle. Vous pouvez choisir de représenter une période d’entraînement comme une étape correspondante. L’exemple suivant montre comment enregistrer des paramètres, enregistrer des métriques et charger des artefacts.

Note

La valeur d’étape par défaut est 0.

# Logging requires an active run for the exp: ExperimentTracker instance.

# Log model parameters with the log_param(...) or log_params(...) methods
exp.log_param("learning_rate", 0.01)
exp.log_params({"optimizer": "adam", "batch_size": 64})

# Log model metrics with the log_metric(...) or log_metrics(...) methods
exp.log_metric("loss", 0.3, step=100)
exp.log_metrics({"loss": 0.4, "accuracy": 0.8}, step=200)

# Log your model to the experiment's model registry with the log_model(...) method.
exp.log_model(model, model_name="my_model", signatures={"predict": model_signature})
exp.log_model(model, model_name="my_model", sample_input_data=data)

# Log local artifacts to an experiment run with the log_artifact(...) method.
exp.log_artifact('/tmp/file.txt', artifact_path='artifacts')
Copy

Note

La journalisation des artefacts n’est pas prise en charge dans les entrepôts Notebooks.

Terminer une exécution

Terminer une exécution ne permet plus de la modifier et la présente comme terminée dans Snowsight.

Si vous avez démarré une exécution dans le cadre d’une instruction with, l’exécution est automatiquement terminée lors de la sortie de la portée. Sinon, vous pouvez mettre fin à une exécution en appelant la méthode end_run(name: Optional[str]) de votre expérience avec le nom de l’exécution à terminer :

experiment.end_run("my_run")
Copy

Comparer les exécutions au sein d’une expérience

L’évaluation de l’expérience est effectuée via Snowsight. Dans le menu de navigation, sélectionnez AI & ML » Experiments et choisissez l’expérience à examiner dans la liste.

La vue d’expérience contient des informations sur Run count over time, un affichage de votre métrique actuellement sélectionnée et une liste de vos exécutions disponibles dans l’expérience. La liste déroulante supérieure droite fournit une liste des métriques disponibles à inspecter, qui renseigne le graphique Metric Value Range dans la vue d’expérience.

La liste des exécutions sur cette page comprend Run name, Status, lorsque l’exécution était Created, et une colonne supplémentaire pour chaque métrique disponible dans l’expérience. Des informations sur les paramètres et les versions de modèle sont disponibles dans la vue de comparaison des exécutions.

Vous pouvez sélectionner jusqu’à cinq exécutions dans votre expérience, puis sélectionner le bouton Compare pour voir la vue de comparaison, qui affiche les métadonnées d’exécution, les paramètres, les métriques et les informations sur la version du modèle. Chaque métrique est affichée, ce qui peut être modifié en utilisant le bouton bascule dans la section Metrics pour basculer entre Charts et Tables.

Récupérer les artefacts d’une exécution

À tout moment, pendant ou après une exécution, vous pouvez récupérer des artefacts. L’exemple suivant montre comment dresser la liste des artefacts disponibles d’une exécution dans le chemin logs, et télécharger l’artefact logs/log0.txt pour l’exécution my_run dans l’expérience my_experiment du répertoire local /tmp :

# exp: ExperimentTracking
exp.set_experiment("my_experiment")

exp.list_artifacts("my_run", artifact_path="logs")
exp.download_artifacts("my_run", artifact_path="logs/log0.txt", target_path="/tmp")
Copy

Supprimer des exécutions et des expériences

Après avoir terminé une expérience, vous pouvez la supprimer et tous les artefacts d’exécution qui lui sont associés. L’exemple suivant supprime l’expérience my_experiment :

# exp: ExperimentTracking
exp.delete_experiment("my_experiment")
Copy

Vous pouvez également supprimer une exécution individuelle d’une expérience. L’exemple suivant supprime l’exécution my_run de l’expérience my_experiment :

# exp: ExperimentTracking
exp.set_experiment("my_experiment")
exp.delete_run("my_run")
Copy

Limitations

Les Snowflake Experiments sont soumises aux limitations suivantes :

  • Chaque schéma est limité à 500 expériences.

  • Chaque expérience est limitée à 500 exécutions.

  • Les exécutions sont stockées pendant un an au maximum.

  • Les paramètres et métriques d’exécution individuels sont limités à 200 KB au total.

Considérations relatives aux clients

L’utilisation de Snowflake Experiments engendre des coûts standard basés sur la consommation Snowflake. Il s’agit notamment des éléments suivants :

Langage: Français