Tracer les fonctions générateurs

W&B Weave prend en charge le traçage des fonctions générateurs synchrones et asynchrones, y compris dans les structures profondément imbriquées. Cette page vous montre comment décorer des fonctions générateurs avec @weave.op afin que Weave capture leurs entrées, les valeurs de sortie produites et la hiérarchie complète des appels imbriqués. Utilisez cette approche si votre code comporte des chemins en streaming ou à évaluation paresseuse dont vous souhaitez inspecter les sorties dans l’interface Weights & Biases, aux côtés de vos autres traces.

Comme les générateurs produisent leurs valeurs de manière paresseuse, Weave ne journalise les sorties qu’une fois le générateur entièrement consommé (par exemple, lorsque vous le convertissez en liste). Pour que Weave capture les sorties dans la trace, consommez entièrement le générateur (par exemple, avec list()).

Python
TypeScript

from typing import Generator
import weave

weave.init("my-project")

# Cette fonction utilise un générateur synchrone.
# Weave trace l’appel et son entrée (`x`),
# mais les valeurs de sortie ne sont capturées qu’une fois le générateur consommé (par exemple, avec `list()`).
@weave.op
def basic_gen(x: int) -> Generator[int, None, None]:
    yield from range(x)

# Une fonction synchrone classique utilisée dans le pipeline du générateur.
# Ses appels sont également tracés indépendamment par Weave.
@weave.op
def inner(x: int) -> int:
    return x + 1

# Un générateur synchrone qui appelle une autre fonction tracée (`inner`).
# Chaque valeur produite provient d’un appel tracé distinct à `inner`.
@weave.op
def nested_generator(x: int) -> Generator[int, None, None]:
    for i in range(x):
        yield inner(i)

# Un générateur qui s’appuie sur le générateur ci-dessus.
# Le traçage produit ici une arborescence d’appels hiérarchique :
# - `deeply_nested_generator` (parent)
#   - `nested_generator` (enfant)
#     - `inner` (petit-enfant)
@weave.op
def deeply_nested_generator(x: int) -> Generator[int, None, None]:
    for i in range(x):
        for j in nested_generator(i):
            yield j

# Le générateur doit être *consommé* pour que Weave capture les sorties.
# Cela vaut aussi bien pour les générateurs synchrones qu’asynchrones.
res = deeply_nested_generator(4)
list(res)  # Déclenche le traçage de tous les appels imbriqués et des valeurs produites

This feature is not available in the TypeScript SDK yet.

La capture d’écran suivante montre la page Traces avec une trace sélectionnée issue du code précédent. Le panneau central affiche l’arborescence de la trace sélectionnée, dans laquelle figurent les ops deeply_nested_generator, nested_generator et inner selon leur hiérarchie. Page Traces de Weave affichant une arborescence de trace sélectionnée illustrant des ops profondément imbriqués

Page Traces de Weave affichant une arborescence de trace sélectionnée illustrant des ops profondément imbriqués

Consommer les générateurs

Cette section explique pourquoi vous devez consommer les générateurs pour que Weave enregistre leurs sorties, et quels modes de consommation fonctionnent. Weave ne capture les sorties d’un générateur qu’une fois celui-ci entièrement consommé. Pour consommer le générateur, parcourez-le (par exemple, avec list(), une boucle for ou des appels à next() jusqu’à épuisement). Il en va de même pour les générateurs asynchrones consommés avec async for ou un mécanisme équivalent. Pour plus d’informations sur la décoration des fonctions et des méthodes avec @weave.op, voir Créer des appels.

Accumuler les valeurs produites dans une seule trace

Si vous souhaitez que Weave enregistre un résultat combiné (comme une chaîne concaténée ou une liste) plutôt que la séquence brute des valeurs produites, utilisez un accumulateur. Le paramètre accumulator de weave.op vous permet de personnaliser la manière dont les valeurs produites par les fonctions génératrices sont combinées, par exemple pour concaténer en une seule chaîne des jetons de texte transmis en streaming. L’accumulateur est une fonction à deux arguments que Weave appelle une fois par valeur produite, afin de construire le résultat de manière incrémentielle.

Le paramètre accumulator n’est pas disponible pour TypeScript.

L’exemple suivant présente un accumulateur personnalisé qui ajoute chaque valeur produite à une liste, de sorte que Weave enregistre cette liste comme sortie de l’appel une fois le générateur entièrement consommé.

from typing import Generator
import weave

weave.init("your-team-name/your-project-name")

# Weave appelle cette fonction après chaque yield. acc vaut None lors du premier appel.
# La dernière valeur que vous renvoyez devient la sortie tracée de l’op.
def list_accumulator(acc, value):
    if acc is None:
        acc = []
    acc.append(value)
    return acc

# Définir le paramètre accumulator
@weave.op(accumulator=list_accumulator)
def basic_gen_with_accumulator(x: int) -> Generator[int, None, None]:
    yield from range(x)

# Itérer jusqu’au bout pour que chaque yield s’exécute et que l’accumulateur puisse produire la sortie tracée finale.
result = list(basic_gen_with_accumulator(3))
print(result)

​Consommer les générateurs

​Accumuler les valeurs produites dans une seule trace

Consommer les générateurs

Accumuler les valeurs produites dans une seule trace