> ## Documentation Index > Fetch the complete documentation index at: https://docs.coreweave.com/llms.txt > Use this file to discover all available pages before exploring further. # Utiliser Weave avec les runs d’entraînement W&B > Intégrez les traces Weave aux runs d’entraînement W&B pour consulter les détails d’exécution des fonctions aux côtés des métriques de ML dans les tableaux de bord du workspace.

Journaliser des traces pendant les runs d’entraînement de modèles

Vous pouvez journaliser des traces Weave pendant les runs d’entraînement de modèles et les consulter dans votre workspace personnel. Un workspace W&B affichant un panneau de traces Weave à côté des métriques d’un run d’entraînement. Les workspaces personnels sont des tableaux de bord personnalisables de l’interface utilisateur qui vous permettent de consulter des analyses approfondies et des visualisations de données de vos runs d’entraînement de modèles. En ajoutant des panneaux Weave à votre workspace, vous pouvez accéder aux données de trace journalisées pendant les runs de modèles et les consulter, afin de mieux comprendre le comportement de vos modèles pendant l’entraînement. Par exemple, si vous effectuez le fine-tuning d’un LLM et que votre workspace W\&B indique une chute de la précision à l’étape 500, les traces Weave intégrées peuvent révéler précisément ce qui s’est passé : votre modèle a peut-être commencé à générer des réponses trop verbeuses qui ne satisfaisaient pas aux critères d’évaluation.

Utiliser les panneaux Weave

Lorsque vous [décorez les fonctions avec `@weave.op`](/fr/products/wandb/weave/quickstart) dans vos pipelines de ML, leurs informations d’exécution sont capturées automatiquement et vous pouvez les consulter dans un workspace personnel. Par exemple, le script suivant montre comment les traces Weave s’intègrent aux runs d’entraînement W\&B. Il simule une boucle d’entraînement de machine learning dans laquelle chaque étape d’entraînement journalise des métriques dans W\&B tout en créant des traces Weave détaillées. Les décorateurs `@weave.op` appliqués aux fonctions capturent automatiquement les entrées, les sorties et les détails d’exécution. Lorsque la boucle d’entraînement journalise des métriques avec `wandb.log()`, elle journalise également les informations de trace Weave dans votre projet. ```python lines theme={"system"} import wandb import weave import random # Initialiser W&B et Weave avec le même projet project = "my-workspace-project" weave.init(project) @weave.op def evaluate_model(model_state, epoch): # Simuler des métriques d’évaluation accuracy = 0.7 + epoch * 0.02 + random.uniform(-0.05, 0.05) # Suivre certains comportements précis du modèle test_responses = { "conciseness_check": "Model generated 500 words for simple question", "accuracy_check": "Model answered 8/10 questions correctly", "hallucination_check": "No factual errors detected" } return { "accuracy": accuracy, "diagnostic_results": test_responses } @weave.op def training_step(epoch, lr): # Simuler la logique d’entraînement loss = 1.0 / (epoch + 1) + random.uniform(-0.1, 0.1) # Évaluation tracée eval_results = evaluate_model(f"checkpoint_{epoch}", epoch) return { "loss": loss, "accuracy": eval_results["accuracy"], "diagnostics": eval_results["diagnostic_results"] } # Boucle d’entraînement with wandb.init(project=project, config={"lr": 0.01}) as run: for epoch in range(5): # Exécuter l’entraînement avec le traçage Weave results = training_step(epoch, run.config.lr) # Journaliser dans W&B : c’est le point d’intégration run.log({ "epoch": epoch, "loss": results["loss"], "accuracy": results["accuracy"] }) ``` Vous pouvez exécuter cet exemple de script pour voir comment les traces sont journalisées avec le reste des informations de votre run. Une fois le run lancé, vous pouvez consulter les informations de trace dans votre workspace, pendant ou après le run. Ouvrez le lien affiché dans le terminal au démarrage du run (il se présente ainsi : `wandb: 🚀 View run at https://forge.coreweave.com/wandb/wandb/my-project/runs/[RUN-ID]`), ou accédez au workspace dans l’interface utilisateur. Pour accéder à un workspace depuis l’interface utilisateur : 1. Ouvrez l’interface utilisateur de Weights & Biases et cliquez sur l’onglet **Projects**. La liste de vos projets s’affiche. 2. Dans la liste des projets, cliquez sur le projet dans lequel vous avez journalisé votre run. La page **Workspaces** s’ouvre. 3. Si vous avez configuré votre workspace en mode automatique, celui-ci se remplit automatiquement de visualisations de données et d’informations sur votre run. Les données de trace de votre run se trouvent dans la section **Weave** du workspace. Si votre workspace est en mode manuel, vous pouvez ajouter des panneaux Weave en cliquant sur **Add panels**, puis en sélectionnant des panneaux dans la section **Weave** du menu Add Panels. Pour en savoir plus sur les workspaces, consultez [Afficher les résultats des expériences](/fr/products/wandb/track/workspaces).

Associer des traces à un run W\&B spécifique

Dans certains cas, vous voudrez peut-être joindre des traces à un run autre que celui que Weave détecte automatiquement. Par défaut, Weave détecte automatiquement le `wandb.run` actif et y associe les traces. Pour associer des traces à un run spécifique autre que le `wandb.run` global, utilisez `set_wandb_run_context`. Pour associer des traces à un run et à une étape de run précis, définissez les valeurs des arguments `run_id` et `step` de la méthode : ```python lines highlight={6} theme={"system"} import weave client = weave.init("[YOUR-TEAM-NAME]/[YOUR-PROJECT-NAME]") # Associer toutes les traces ultérieures à un run spécifique. client.set_wandb_run_context(run_id="[YOUR-RUN-ID]", step=[INTEGER]) @weave.op def my_function(x): return x * 2 my_function(10) # Cette trace est liée à « my-run-id » à l’étape 5. ``` Le `run_id` correspond à l’ID court du run (par exemple, `38m4t5ja`), et non au chemin complet `entity/project/run_id`. Vous trouverez l’ID court d’un run dans l’URL du run (`https://forge.coreweave.com/wandb/team/project/runs/[RUN-ID]`) ou en [accédant à `wandb.run.id` dans le code](/fr/products/wandb/runs/run-identifiers#find-and-customize-a-runs-id-or-name). Pour mettre fin à la redéfinition et revenir au `wandb.run` global, appelez `clear_wandb_run_context` : ```python lines theme={"system"} client.clear_wandb_run_context() my_function(20) # Cette trace utilise le wandb.run global (le cas échéant). ```

Référencer des artifacts W\&B dans une trace Weave

Vous pouvez référencer des [artifacts W\&B](/fr/products/wandb/artifacts) (tels que des modèles, des jeux de données et des points de contrôle) dans vos traces Weave. Cela crée dans l’interface Weights & Biases un lien cliquable qui mène directement à la page de détails de l’artifact, ce qui vous permet de suivre les versions d’artifact utilisées lors d’opérations spécifiques. Par exemple, si vous avez entraîné deux versions d’un modèle (`v1` et `v2`), vous pouvez ajouter la référence de l’artifact `v1` comme attribut de la trace lorsque vous interrogez ce modèle. Vous pouvez ainsi identifier précisément la version d’artifact qui a produit une sortie donnée. Pour associer un artifact à une trace, construisez l’URL de l’artifact en concaténant le préfixe `wandb-artifact:///` et le nom complet de l’artifact, selon la syntaxe suivante : `wandb-artifact:///[FULL-NAME-OF-ARTIFACT]`. Transmettez-la ensuite à Weave de l’une des deux manières suivantes : * Comme attribut arbitraire * Comme attribut d’un `Model` Le nom complet de l’artifact figure sur sa page de détails dans l’interface Weights & Biases. Il se présente ainsi : `[ENTITY]/[PROJECT]/[ARTIFACT-NAME]:[VERSION]`. Vous pouvez copier le nom complet depuis la page de détails de l’artifact dans l’interface Weights & Biases. Les sections suivantes présentent chacune de ces approches.

Ajouter un artifact comme attribut d’une trace

Pour ajouter un artifact comme attribut d’une trace, transmettez-le sous forme de paire clé-valeur au gestionnaire de contexte `weave.attributes()` : ```python lines {10} theme={"system"} import weave weave.init("[YOUR-TEAM-NAME]/[YOUR-PROJECT-NAME]") @weave.op def my_function(name: str): return f"Hello, {name}!" # Ajoutez un nom de clé arbitraire, avec l’URL de l’artifact comme valeur with weave.attributes({'artifact_id': 'wandb-artifact:///team-name/project-name/run-38m4t5ja-history:v0'}): result = my_function("World") ``` ```typescript twoslash lines {12} theme={"system"} // @noErrors import {init, op, withAttributes} from 'weave'; async function main() { await init('wandb/docs'); const myFunction = op(async function myFunction(name: string) { return `Hello, ${name}!`; }); // Ajoutez un nom de clé arbitraire, avec l’URL de l’artifact comme valeur const result = await withAttributes( {artifact_id: "wandb-artifact:///team-name/project-name/run-38m4t5ja-history:v0"}, async () => myFunction('World') ); console.log('Result:', result); } main().catch(console.error); ```

Ajouter un artifact comme attribut d’un `Model`

Pour ajouter un artifact comme attribut d’un `Model`, transmettez l’URL de l’artifact lors de l’instanciation du modèle : La classe `Model` n’est prise en charge que dans le SDK Python de Weave. ```python lines {7,17} theme={"system"} import weave weave.init("[YOUR-TEAM-NAME]/[YOUR-PROJECT-NAME]") class MyModel(weave.Model): # Stocker la référence de l’artifact dans un attribut du modèle artifact_id: str temperature: float = 0.7 @weave.op def predict(self, query: str) -> str: # Placez ici votre logique d’inférence return f"Response to: {query}" # Transmettre l’URL de l’artifact en tant qu’attribut du modèle model = MyModel( artifact_id="wandb-artifact:///team-name/project-name/run-38m4t5ja-history:v0" ) result = model.predict("Hello, World!") ``` ## Related topics - [Comment utiliser W&B avec le multiprocessing, par exemple pour l’entraînement distribué ?](/fr/support/models/articles/how-can-i-use-wandb-with-multiprocessing.md)