Kubeflow Pipelines (kfp)

Intégrez W&B à Kubeflow Pipelines pour suivre les expériences et visualiser les métriques à travers les composants du pipeline ML.

Kubeflow Pipelines (kfp) est une plateforme permettant de créer et de déployer des flux de travail de machine learning (ML) portables et évolutifs basés sur des conteneurs Docker.

Cette intégration permet aux utilisateurs d’appliquer des décorateurs aux composants fonctionnels Python de kfp afin de journaliser automatiquement les paramètres et les Artifacts dans W&B.

Cette fonctionnalité est disponible à partir de wandb==0.12.11 et nécessite kfp<2.0.0

Inscrivez-vous et créez une clé API

Une clé API permet d’authentifier votre machine auprès de W&B. Vous pouvez générer une clé API à partir de votre profil utilisateur.

Pour une méthode plus directe, créez une clé API en accédant directement aux Paramètres utilisateur. Copiez immédiatement la clé API nouvellement créée et conservez-la dans un endroit sûr, par exemple dans un gestionnaire de mots de passe.

1. Cliquez sur l’icône de votre profil utilisateur dans l’angle supérieur droit.
2. Sélectionnez Paramètres utilisateur, puis faites défiler jusqu’à la section Clés API.

Installez la bibliothèque wandb et connectez-vous

Pour installer la bibliothèque wandb localement et vous connecter :

Ligne de commande

1. Définissez la variable d’environnement WANDB_API_KEY avec votre clé API.

   export WANDB_API_KEY=<your_api_key>
   

2. Installez la bibliothèque wandb et connectez-vous.

   pip install wandb
   
   wandb login
   

Python

pip install wandb

import wandb
wandb.login()

Python notebook

!pip install wandb

import wandb
wandb.login()

Décorez vos composants

Ajoutez le décorateur @wandb_log et créez vos composants comme d’habitude. Cela journalisera automatiquement dans W&B les paramètres d’entrée/sortie et les artifacts chaque fois que vous exécutez votre pipeline.

from kfp import components
from wandb.integration.kfp import wandb_log


@wandb_log
def add(a: float, b: float) -> float:
    return a + b


add = components.create_component_from_func(add)

Transmettre des variables d’environnement aux conteneurs

Vous devrez peut-être transmettre explicitement des variables d’environnement à vos conteneurs. Pour une liaison bidirectionnelle, vous devez également définir la variable d’environnement WANDB_KUBEFLOW_URL avec l’URL de base de votre instance Kubeflow Pipelines. Par exemple, https://kubeflow.mysite.com.

import os
from kubernetes.client.models import V1EnvVar


def add_wandb_env_variables(op):
    env = {
        "WANDB_API_KEY": os.getenv("WANDB_API_KEY"),
        "WANDB_BASE_URL": os.getenv("WANDB_BASE_URL"),
    }

    for name, value in env.items():
        op = op.add_env_variable(V1EnvVar(name, value))
    return op


@dsl.pipeline(name="example-pipeline")
def example_pipeline(param1: str, param2: int):
    conf = dsl.get_pipeline_conf()
    conf.add_op_transformer(add_wandb_env_variables)

Accédez à vos données de manière programmatique

Via l’UI de Kubeflow Pipelines

Cliquez sur n’importe quel run dans l’UI de Kubeflow Pipelines qui a été enregistré avec W&B.

• Consultez les détails des entrées et des sorties dans les onglets Input/Output et ML Metadata.
• Consultez l’application web W&B depuis l’onglet Visualizations.

Via l’interface de l’application web

L’interface de l’application web affiche le même contenu que l’onglet Visualizations dans Kubeflow Pipelines, mais avec davantage d’espace. En savoir plus sur l’interface de l’application web ici.

Via l’API publique (pour un accès programmatique)

• Pour un accès programmatique, voir notre API publique.

Correspondance des concepts entre Kubeflow Pipelines et W&B

Voici la correspondance des concepts de Kubeflow Pipelines avec W&B

Kubeflow Pipelines	W&B	Emplacement dans W&B
Scalaire d’entrée	config	onglet Vue d’ensemble
Scalaire de sortie	summary	onglet Vue d’ensemble
Artifact d’entrée	Artifact d’entrée	onglet Artifacts
Artifact de sortie	Artifact de sortie	onglet Artifacts

Journalisation granulaire

Si vous voulez un contrôle plus fin de la journalisation, vous pouvez ajouter quelques appels à wandb.log et wandb.log_artifact dans le composant.

Avec des appels explicites à wandb.log_artifacts

Dans l’exemple ci-dessous, nous entraînons un modèle. Le décorateur @wandb_log suivra automatiquement les entrées et sorties pertinentes. Si vous souhaitez également journaliser le processus d’entraînement, vous pouvez l’ajouter explicitement comme suit :

@wandb_log
def train_model(
    train_dataloader_path: components.InputPath("dataloader"),
    test_dataloader_path: components.InputPath("dataloader"),
    model_path: components.OutputPath("pytorch_model"),
):
    with wandb.init() as run:
        ...
        for epoch in epochs:
            for batch_idx, (data, target) in enumerate(train_dataloader):
                ...
                if batch_idx % log_interval == 0:
                    run.log(
                        {"epoch": epoch, "step": batch_idx * len(data), "loss": loss.item()}
                    )
            ...
            run.log_artifact(model_artifact)

Avec les intégrations implicites de wandb

Si vous utilisez une intégration framework que nous prenons en charge, vous pouvez aussi transmettre directement le callback :

@wandb_log
def train_model(
    train_dataloader_path: components.InputPath("dataloader"),
    test_dataloader_path: components.InputPath("dataloader"),
    model_path: components.OutputPath("pytorch_model"),
):
    from pytorch_lightning.loggers import WandbLogger
    from pytorch_lightning import Trainer

    trainer = Trainer(logger=WandbLogger())
    ...  # lancer l'entraînement