Créer des pipelines et les déployer¶

Vue d’ensemble¶

Les workflows machine learning (ML) impliquent généralement plusieurs étapes clés :

Exploration et préparation des données : Cette phase initiale consiste à comprendre les données brutes, à les nettoyer, à gérer les valeurs manquantes et à les transformer dans un format utilisable.

Ingénierie des données : Ici, les données brutes sont transformées en fonctionnalités qui représentent mieux le problème sous-jacent aux modèles prédictifs, impliquant souvent des techniques telles que la mise à l’échelle, l’encodage et la création de nouvelles fonctionnalités à partir de celles existantes.

Développement de modèles : Dans cette étape, divers modèles ML sont sélectionnés, entraînés sur les données préparées et réglés pour optimiser leurs performances. Les modèles développés sont rigoureusement évalués à l’aide de métriques appropriées pour évaluer leur précision, leur équité et leurs capacités de généralisation.

Déploiement du modèle : Les modèles prêts pour la production sont enregistrés dans un registre de modèles, puis déployés pour des prédictions par lots ou en temps réel sur de nouvelles données.

Le développement initial des modèles ML bénéficie souvent d’une approche agile et itérative, permettant aux scientifiques des données d’expérimenter rapidement différents algorithmes et différentes fonctionnalités. Cependant, à mesure que les modèles mûrissent et démontrent leur valeur, l’accent est mis sur l’opérationnalisation, où les pipelines sont renforcés et automatisés grâce à l’intégration continue et la livraison continue (CI/CD). Cette automatisation garantit que les modifications apportées au code, aux pipelines de données ou aux modèles sont construites, testées et déployées de manière cohérente, pour des systèmes ML plus fiables, plus efficaces et plus faciles à maintenir.

Développer¶

Démarrez avec le développement interactif dans un IDE local (par ex., VS Code) ou un notebook interactif (Snowflake Notebook ou Jupyter). Paramétrez les entrées (tables, zones de préparation, hyperparamètres) et faites en sorte que les étapes soient modulaires pour la portabilité. Par exemple, il peut être utile d’avoir une cellule/fonction pour la préparation des données, une autre pour l’ingénierie des fonctionnalités, une autre pour l’entraînement des modèles, etc.

Snowflake fournit les outils suivants pour chaque étape du cycle de vie du machine learning :

Zone de préparation	Outil	Utilisation
Exploration de données	Snowflake Notebooks	Développez dans un environnement de notebook géré, basé sur un navigateur. Utilisez Python et SQL en un seul endroit pour profiler les ensembles de données, visualiser les distributions et itérer rapidement.
	DataFrames Snowpark	Travaillez avec des APIs DataFrame habituelles qui transfèrent le calcul vers Snowflake.
Ingénierie des données	DataFrames Snowpark	Créez des transformations reproductibles à l’échelle de l’entrepôt en utilisant SQL/Python/Scala avec optimisation pushdown.
	UDFs/UDTFs	Encapsulez une logique Python personnalisée en tant que fonctions ou fonctions de table pour réutiliser des transformations complexes dans les équipes et les pipelines.
	Référentiel de fonctionnalités	Définissez, enregistrez et fournissez des fonctionnalités avec une précision ponctuelle et réutilisez-les dans différents modèles. Prend en charge des ensembles d’entraînement hors ligne cohérents et une récupération en ligne à faible latence, réduisant ainsi les fuites et les doublons.
Entraînement de modèle	Snowflake Notebooks	Entraînez des modèles ML avec des bibliothèques open source familières comme scikit-learn, XGBoost et PyTorch dans vos notebooks Snowflake. Tirez parti de l’échelle flexible, évitez les mouvements de données et conservez les modèles et le prétraitement à un seul emplacement.
	Jobs ML	Transférez les étapes exigeantes en ressources vers des options de calcul spécialisées telles que les instances à mémoire élevée, l’accélération GPU et le traitement distribué depuis n’importe quel environnement, y compris les IDEs locaux, les notebooks et les orchestrateurs hébergés en externe.
Déploiement de modèles	Registre de modèles	Enregistrez et versionnez des modèles avec des contrôles de lignée et de gouvernance. Centralise la découverte et favorise les workflows de promotion sécurisés, les audits et les restaurations.
	Inférence par lots	Servez des modèles enregistrés à partir de Python ou SQL, en conservant l’inférence à proximité des données gouvernées et en simplifiant les opérations grâce à une exécution cohérente soutenue par un registre.
	Inférence en temps réel	Déployez des modèles enregistrés vers des points de terminaison HTTPS gérés avec mise à l’échelle automatique. Élimine l’infrastructure de service, offrant une inférence simple, sécurisée et à faible latence intégrée à l’authentification et à la gouvernance de Snowflake.
	Surveillance de modèles	Créez un moniteur par version de modèle pour matérialiser les journaux d’inférence et actualiser automatiquement les métriques quotidiennes, la migration de surface, les performances et les signaux statistiques dans Snowsight. Configurez des alertes et des tableaux de bord personnalisés pour comparer les versions et diagnostiquer rapidement les problèmes de données ou de pipeline.
Orchestration des workflows	Notebooks planifiés	Paramétrez et configurez des notebooks Snowflake pour qu’ils s’exécutent de manière non interactive selon une planification.
	Graphiques des tâches	Exploitez votre pipeline ML dans un graphe acyclique dirigé (DAG) et configurez-le pour qu’il s’exécute selon un calendrier ou en fonction de déclencheurs basés sur des événements.
Sécurité et gouvernance	RBAC, balises, masquage, politiques	Appliquez des politiques d’accès basées sur les rôles, de classification des données et de masquage/ligne aux données, fonctionnalités et modèles d’entraînement. Garantit un accès avec privilèges minimaux et la conformité tout au long du cycle de vie ML.

Préparer pour la production¶

Préparer le code¶

Avant de mettre en œuvre votre pipeline, préparez votre code pour la production. Si vous avez commencé avec des notebooks, commencez par restructurer votre code en fonctions modulaires et réutilisables où chaque étape importante (préparation des données, ingénierie des fonctionnalités, entraînement des modèles, évaluation) devient une fonction distincte avec des entrées et des sorties claires. Si vous disposez déjà de scripts modulaires, assurez-vous que chaque fonction dispose d’interfaces et de responsabilités bien définies. Paramétrez toutes les valeurs de configuration comme les noms des tables et les hyperparamètres pour permettre le déploiement inter-environnements. Nous vous recommandons également de créer un script de point d’entrée qui exécute le pipeline de bout en bout localement pour le débogage et le développement ultérieur.

Exemple de structure de répertoire :

ml_pipeline_project/
├── README.md
├── requirements.txt
├── config/
├── src/ml_pipeline/
│   ├── utils/                     # Common utilities
│   ├── data/                      # Data preparation
│   ├── features/                  # Feature engineering
│   ├── models/                    # Model training
│   └── inference/                 # Model inference
├── scripts/
│   ├── run_pipeline.py            # Main entry point
│   └── dag.py
├── tests/
└── notebooks/

Copy

Exemple de script run_pipeline.py :

import argparse
from ml_pipeline.utils.config_loader import load_config
from ml_pipeline.data.ingestion import load_raw_data
from ml_pipeline.data.validation import validate_data_quality
from ml_pipeline.features.transformers import create_features
from ml_pipeline.models.training import train_model
from ml_pipeline.models.evaluation import evaluate_model
from ml_pipeline.models.registry import register_model

def main():
    parser = argparse.ArgumentParser()
    parser.add_argument("--config", required=True, help="Config file path")
    parser.add_argument("--env", default="dev", help="Environment (dev/prod)")
    args = parser.parse_args()

    # Load configuration
    config = load_config(args.config, args.env)

    # Execute pipeline stages
    raw_data = load_raw_data(config.data.source_table)
    validate_data_quality(raw_data, config.data.quality_checks)
    features = create_features(raw_data, config.features.transformations)
    model = train_model(features, config.model.hyperparameters)
    metrics = evaluate_model(model, features, config.model.eval_metrics)
    register_model(model, metrics, config.model.registry_name)

if __name__ == "__main__":
    main()

Copy

Migration des notebooks vers des tâches ML¶

La plupart du code écrit dans les notebooks Snowflake fonctionnera dans les tâches ML sans modifications nécessaires. Les quelques aspects à prendre en compte sont les suivants :

Temps d’exécution des APIs

Certaines APIs ML distribuées ne sont disponibles qu’au sein de Container Runtime, et toute tentative d’importation en dehors de cet environnement échouera. Ces APIs sont disponibles au sein des tâches ML, mais doivent être importées dans la charge utile de la tâche ML.

# Attempting to import distributed runtime APIs in local/external
# environments will fail!
from snowflake.ml.modeling.distributors.xgboost import XGBEstimator

from snowflake.ml.jobs import remote

@remote(...)
def my_remote_function(...):
  # Move imports *inside* your ML Job payloads
  from snowflake.ml.modeling.distributors.xgboost import XGBEstimator  # This works!
  ...

job = my_remote_function()  # Start ML Job
job.wait()  # Wait for job to complete

Copy

Mise à l’échelle du cluster

L’API scale_cluster() fonctionne uniquement au sein des notebooks et ne fonctionnera pas au sein des tâches ML. Au lieu de cela, spécifiez la taille de cluster souhaitée au moment de la soumission de la tâche. Voir Tâches multi-nœuds Snowflake ML pour plus d’informations.

from snowflake.ml.jobs import remote

@remote(..., target_instances=4)
def my_remote_function(...):
  # 4-node cluster will be provisioned for distributed processing
  # inside this job. The cluster will be automatically cleaned up on
  # job termination.

Copy

Orchestration de pipeline¶

Une fois que vous avez préparé votre pipeline de bout en bout, mettez-le en œuvre à l’aide d’un orchestrateur tel que Snowflake Task Graphs, Scheduled Notebooks ou des orchestrateurs externes tels qu’Airflow. L’utilisation d’un cadre d’orchestration offre plusieurs avantages clés :

Tolérance aux pannes et fiabilité grâce aux tentatives automatiques et à l’isolation des pannes
Observabilité avec historique d’exécution, statut en temps réel et alertes
Planification et coordination pour les graphiques de dépendance complexes et les déclencheurs divers
Nettoyage opérationnel avec l’intégration du contrôle de version et la gestion de la configuration

Snowflake ML est compatible avec la plupart des cadres d’orchestration, y compris Airflow, Dagster et Prefect. Si vous disposez déjà d’un workflow existant ou d’une configuration DAG, nous vous recommandons simplement d’intégrer vos workflows existants aux fonctionnalités ML Snowflake et de décharger les étapes gourmandes en calcul ou en données vers les tâches ML ou les UDFs. Si vous n’avez pas de configuration DAG existante, vous pouvez utiliser Snowflake Task Graphs pour une solution native Snowflake.

Pour configurer l’orchestration avec un DAG sur Snowflake, procédez comme suit :

Préparez votre code de pipeline local selon Préparer le code
Créez un nouveau fichier dag.py (ou tout autre nom) pour contenir votre définition DAG
Implémentez le formulaire DAG de votre pipeline selon ce guide
Exécutez le script dag.py pour déployer le graphique des tâches (Task Graph) dans votre compte Snowflake

Astuce

L’exécution d’un script de graphique de tâches n’exécute pas nécessairement le graphe ; un script de graphique de tâches basique définit et déploie simplement le graphique des tâches. Le graphique des tâches doit être déclenché séparément pour être exécuté, soit manuellement, soit selon une planification.

Séparer le développement et la production¶

Nous vous recommandons de paramétrer votre script DAG pour prendre en charge l’isolation de vos environnements de développement (DEV) et de production (PROD). Pour ce faire, vous pouvez utiliser la gestion des connexions Snowflake, les configurations spécifiques à l’application ou toute combinaison des deux. Le niveau d’isolation nécessaire dépend de vos exigences en matière de gouvernance, mais en général nous vous recommandons d’utiliser des bases de données distinctes pour les environnements DEV et PROD, où la base de données PROD est protégée par des politiques RBAC qui limitent l’accès aux administrateurs et aux comptes de service spécialisés.

CI/CD¶

Vous pouvez automatiser la validation et le déploiement de vos pipelines à l’aide de pipelines CI/CD tels que Azure Pipelines et GitHub Actions. En général, nous recommandons d’effectuer des tests dans un environnement DEV ou STAGING avant déploiement en PROD. Une bonne pratique consiste à configurer votre référentiel de contrôle source avec des passerelles de fusion qui valident les modifications de code en phase DEV avant de les fusionner dans votre branche de production. Les modifications apportées à la branche de production peuvent être déployées en PROD en continu (c’est-à-dire pour chaque changement) ou à intervalles réguliers (quotidien/hebdomadaire). Une bonne pratique consiste à exécuter une validation finale de l’état de la branche de production dans un environnement DEV ou STAGING avant de déployer des modifications en PROD. Utilisez des fonctionnalités de la plateforme comme GitHub Action Deployments et Environments pour définir et configurer les connexions à chaque environnement de déploiement. Configurer votre pipeline CI/CD pour pousser vos modifications dans l’environnement de déploiement, notamment :

(Facultatif) Créer des bibliothèques et des modules en tant que paquets Python et les pousser dans un flux de paquets propriétaire
(Facultatif) Importer de fichiers dans une zone de préparation Snowflake

Cela est généralement nécessaire lorsque vous utilisez snowflake.ml.jobs.submit_from_stage() dans votre pipeline

Vous pouvez également utiliser l’intégration GitHub de Snowflake pour suivre directement votre référentiel GitHub en tant que zone de préparation Snowflake
Exécuter dag.py pour déployer le graphique de tâches dans l’environnement configuré
(Facultatif) Déclencher et surveiller l’exécution du graphique de tâches nouvellement déployé pour vérifier la validité

Ressources supplémentaires¶

Démarrage rapide du graphique de tâches E2E