Entraînez des modèles sur toutes les partitions de données

Utilisez le Many Model Training (MMT) pour entraîner efficacement plusieurs modèles de machine learning sur toutes les partitions de données. Il gère automatiquement l’orchestration distribuée, le stockage des modèles et la persistance des artefacts.

Le MMT partitionne votre DataFrame Snowpark selon une colonne spécifiée, et entraîne des modèles distincts sur chaque partition en parallèle. Concentrez-vous sur la logique d’entraînement de votre modèle pendant que le MMT se charge de la complexité de l’infrastructure et s’adapte automatiquement.

Vous pouvez utiliser le MMT pour entraîner efficacement plusieurs modèles sur différents segments de données. Cet outil est idéal pour les scénarios tels que l’entraînement de modèles de prévision des ventes spécifiques à une région, la création de systèmes de recommandation personnalisés où chaque groupe de clients a besoin de son propre modèle, ou la création de modèles prédictifs spécifiques à un segment. Le MMT gère automatiquement l’entraînement du modèle distribué, ce qui élimine la complexité de la gestion de l’infrastructure de calcul distribuée.

Vous pouvez utiliser le MMT pour entraîner des modèles qui utilisent des modèles et des cadres de machine learning open source tels que XGBoost, scikit-learn, PyTorch, et TensorFlow. Le MMT sérialise automatiquement les artefacts de modèle, afin que vous puissiez y accéder au moment de l’inférence.

Vous pouvez également mettre en œuvre l’interface ModelSerde pour entraîner des modèles personnalisés ou utiliser des cadres de ML non pris en charge. Cela vous permet d’intégrer le MMT à n’importe quel cadre de machine learning ou n’importe quelle architecture de modèle personnalisée que vous utilisez.

Important

Avant de commencer le MMT, assurez-vous de disposer des éléments suivants :

  • Environnement Container Runtime : le MMT nécessite un environnement de ML Container Runtime Snowflake.

  • Autorisations d’accès à la zone de préparation : le MMT stocke automatiquement les artefacts du modèle dans des zones de préparation Snowflake. Assurez-vous de disposer des autorisations appropriées pour accéder à la zone de préparation nommée spécifiée.

  • ML Prise en charge du cadre : les intégrations intégrées sont disponibles pour XGBoost, scikit-learn, PyTorch, et TensorFlow. Pour les modèles personnalisés, implémentez l’interface ModelSerde.

La section suivante vous montre comment utiliser le MMT dans un exemple de flux de travail.

Entraînement d’un modèle avec le MMT

Cette section démontre l’ensemble du flux de travail du MMT en cinq étapes clés :

  1. Importation de vos données – Chargez des données d’entraînement à l’aide de Snowpark

  2. Définition de la fonction d’entraînement – Définissez la fonction d’entraînement

  3. Entraînement des modèles sur toutes les partitions – Utilisez le MMT pour entraîner des modèles sur chaque partition en parallèle

  4. Accès aux modèles entraînés– Récupérez et utilisez les modèles entraînés pour chaque partition

  5. Persistance et récupération des modèles – Enregistrez les modèles dans des zones de préparation et restaurez-les ultérieurement

Le flux de travail gère automatiquement l’entraînement distribué, la sérialisation des modèles et le stockage des artefacts dans vos partitions de données.

Importation de vos données

Utilisez une session Snowpark pour commencer à importer vos données. La fonction de Many Model Training divise les données que vous importez en différentes partitions en utilisant la colonne que vous spécifiez.

Avant d’utiliser le MMT, créez une session Snowpark. Pour plus d’informations, consultez Création d’une session pour Snowpark Python.

Le code suivant utilise une session Snowpark pour importer vos données d’entraînement.

# Example: sales_data with columns: region, feature1, feature2, feature3, target
sales_data = session.table("SALES_TRAINING_DATA")
Copy

Définition de la fonction d’entraînement

Après avoir obtenu vos données, vous définissez la fonction d’entraînement que le MMT utilise pour entraîner les modèles sur toutes les partitions. La fonction d’entraînement reçoit un connecteur de données et un objet contextuel qui le dirige vers la partition de données sur laquelle il s’entraîne. Cette section contient des exemples qui définissent une fonction d’entraînement pour l’entraînement d’un modèle XGBoost, ainsi que des exemples qui tirent parti de TensorFlow et PyTorch.

Votre fonction d’entraînement doit avoir cette signature exacte : (data_connector, context). Pour chaque partition de données, le MMT appelle train_xgboost_model avec les arguments suivants :

  • data_connector : un connecteur de données qui donne accès aux données qui le MMT partitionne. train_xgboost_model convertit ce dataframe en pandas.

  • context : un objet qui fournit les partition_id à la fonction``train_xgboost_model``. Cet ID est le nom de la colonne sur laquelle vous partitionnez.

Vous n’appelez pas cette fonction vous-même. Le MMT gère l’exécution sur toutes les partitions.

Utilisez le code suivant pour définir votre fonction d’entraînement. Après avoir modifié le code pour refléter les fonctionnalités de vos données, vous pouvez les transmettre à la fonction du MMT.

Utilisez XGBoost pour entraîner des modèles sur toutes les partitions de données. XGBoost fournit d’excellentes performances pour les données structurées et traite automatiquement les valeurs manquantes.

def train_xgboost_model(data_connector, context):
    df = data_connector.to_pandas()
    print(f"Training model for partition: {context.partition_id}")

    # Prepare features and target
    X = df[['feature1', 'feature2', 'feature3']]
    y = df['target']

    # Train the model
    from xgboost import XGBRegressor
    model = XGBRegressor(
        n_estimators=100,
        max_depth=6,
        learning_rate=0.1,
        random_state=42
    )
    model.fit(X, y)
    return model

trainer = ManyModelTraining(train_xgboost_model, "model_stage")
Copy

Entraînement des modèles sur toutes les partitions

Après avoir défini votre fonction d’entraînement, vous pouvez utiliser le MMT pour entraîner des modèles sur toutes les partitions. Spécifiez la colonne de partition et la zone de préparation où les modèles sont enregistrés.

Le code suivant partitionne les données d’après la colonne region et utilise la fonction train_xgboost_model pour entraîner des modèles distincts pour chaque région en parallèle.

Par exemple, si les valeurs suivantes étaient les valeurs possibles pour la colonne region :

  • Nord

  • Sud

  • Est

  • Ouest

  • Centre

La fonction ManyModelTraining créerait une partition de données distincte pour chacune des régions précédentes et entraînerait un modèle sur chaque partition.

from snowflake.ml.modeling.distributors.many_model import ManyModelTraining

trainer = ManyModelTraining(train_xgboost_model, "model_stage") # Specify the stage to store the models
training_run = trainer.run(
    partition_by="region",  # Train separate models for each region
    snowpark_dataframe=sales_data,
    run_id="regional_models_v1" # Specify a unique ID for the training run
)

# Monitor training progress
final_status = training_run.wait()
print(f"Training completed with status: {final_status}")
Copy

Les modèles sont stockés dans la zone de préparation à run_id/{partition_id} où partition_id est la valeur de la colonne de partition.

Accès aux modèles entraînés

Lorsque le MMT a fini, vous avez entraîné des modèles pour chaque partition de données stockée dans la zone de préparation spécifiée. Chaque modèle est entraîné sur des données spécifiques à sa partition. Par exemple, un modèle «  Nord » est entraîné uniquement sur les données de la région Nord.

L’objet de l’exécution d’entraînement fournit des méthodes pour accéder à ces modèles et vérifier l’état d’entraînement pour chaque partition.

Le code suivant récupère les vérifications de l’état de l’exécution d’entraînement et récupère les modèles entraînés pour chaque partition :

if final_status == RunStatus.SUCCESS:
    # Access models for each partition
    for partition_id in training_run.partition_details:
        trained_model = training_run.get_model(partition_id)
        print(f"Model for {partition_id}: {trained_model}")

        # You can now use the model for predictions or further analysis
        # Example: model.predict(new_data)
else:
    # Handle training failures
    for partition_id, details in training_run.partition_details.items():
        if details.status != "DONE":
            print(f"Training failed for {partition_id}")
            error_logs = details.logs
Copy

Persistance et récupération des modèles

Le MMT conserve automatiquement les modèles entraînés dans la zone de préparation Snowflake spécifiée pendant le processus d’entraînement. Chaque modèle est stocké avec un chemin structuré qui inclut l’ID de l’exécution et l’identificateur de partition, ce qui facilite l’organisation et la récupération des modèles par la suite.

La persistance automatique signifie que vous n’avez pas besoin d’enregistrer manuellement les modèles. Le MMT gère la sérialisation et le stockage pour vous, ce qui élimine le risque de perdre les modèles entraînés en raison des délais d’inactivité de session ou des problèmes de connexion.

Vous pouvez restaurer les exécutions d’entraînement précédentes et accéder à leurs modèles même après la fin de votre session d’origine. Ce mécanisme de persistance vous permet de :

  • Reprendre le travail dans différentes sessions

  • Partager les modèles entraînés avec les membres de l’équipe

  • Créer des flux de travail de gestion des versions des modèles

  • Intégrer des pipelines d’inférence en aval

Les modèles sont automatiquement enregistrés dans la zone de préparation spécifiée et peuvent être récupérés ultérieurement :

# Restore training run from stage
restored_run = ManyModelTraining.restore_from("regional_models_v1", "model_stage")

# Access models from restored run
north_model = restored_run.get_model("North")
south_model = restored_run.get_model("South")
Copy

Entraînement de modèles personnalisés

Pour les modèles personnalisés ou les cadres ML non pris en charge, mettez en place l’interface ModelSerde. Vous pouvez définir votre propre logique de sérialisation et de désérialisation pour les modèles personnalisés. Cela vous permet d’intégrer le MMT à n’importe quel cadre de machine learning ou n’importe quelle architecture de modèle personnalisée que vous utilisez.

from snowflake.ml.modeling.distributors.many_model import ModelSerde

class CustomModelSerde(ModelSerde):
    def serialize(self, model, path):
        # Custom serialization logic
        pass

    def deserialize(self, path):
        # Custom deserialization logic
        pass

def train_custom_model(data_connector, context):
    # Your custom training logic
    model = your_custom_model_training(data_connector.to_pandas())
    return model

trainer = ManyModelTraining(
    train_custom_model,
    "custom_model_stage",
    model_serde=CustomModelSerde()
)
Copy

Intégration à Model Registry

Le MMT peut être intégré au Snowflake Model Registry pour une gestion améliorée des modèles. Le Model Registry fournit une gestion centralisée des versions des modèles, du suivi des métadonnées et de la gestion du déploiement dans l’ensemble de votre organisation. Cette intégration est particulièrement précieuse lors de l’entraînement de plusieurs modèles avec un MMT, car il vous aide à organiser, suivre et gouverner tous les modèles spécifiques à la partition à partir d’un seul emplacement.

L’utilisation du Model Registry avec le MMT vous permet d’effectuer les opérations suivantes :

  • Suivre différentes itérations de vos modèles spécifiques à une partition

  • Stocker les métriques de performance du modèle, les paramètres d’entraînement et les informations de lignée

  • Gérer les versions de modèle déployées en production pour chaque partition

  • Partager les modèles avec les équipes avec des contrôles d’accès et une documentation appropriés

  • Mettre en œuvre des flux de travail d’approbation et un suivi de la conformité pour les déploiements de modèles

# Register trained models to Model Registry
for partition_id in training_run.partition_details:
    model = training_run.get_model(partition_id)

    # Register to Model Registry
    model_ref = registry.log_model(
        model,
        model_name=f"sales_model_{partition_id.lower()}",
        version_name="v1"
    )
Copy
Langage: Français