Journaliser des médias et des objets

Nous prenons en charge les images, les vidéos, l’audio et bien d’autres formats. Journalisez des médias enrichis pour explorer vos résultats et comparer visuellement vos runs, vos modèles et vos jeux de données. Poursuivez votre lecture pour découvrir des exemples et des guides pratiques.

Pour plus de détails, consultez la référence des types de données.

Pour en savoir plus, consultez un rapport de démonstration sur la visualisation des prédictions de modèles ou regardez un guide pas à pas en vidéo.

Prérequis

Pour journaliser des objets média avec le SDK W&B, vous devrez peut-être installer des dépendances supplémentaires. Pour installer ces dépendances, exécutez la commande suivante :

pip install wandb[media]

Images

Journalisez des images pour suivre les entrées, les sorties, les poids des filtres, les activations, et bien plus encore.

Les images peuvent être journalisées directement à partir de tableaux NumPy, sous forme d’images PIL ou à partir du système de fichiers. Chaque fois que vous journalisez des images à une étape, elles deviennent disponibles dans l’interface utilisateur. Développez le volet d’images, puis utilisez le curseur d’étapes pour afficher les images des différentes étapes. Vous pouvez ainsi comparer facilement l’évolution de la sortie d’un modèle au cours de l’entraînement. Cliquez sur un volet multimédia pour afficher une image en plein écran : vous pouvez alors zoomer et vous déplacer dans l’image, y compris à l’aide de raccourcis clavier. Pour comparer dans une même vue des images ou des vidéos issues de différents runs, étapes ou index, utilisez le mode de comparaison d’un volet multimédia.

Nous vous recommandons de journaliser moins de 50 images par étape, afin que la journalisation ne ralentisse pas l’entraînement et que le chargement des images ne ralentisse pas la consultation des résultats.

Journaliser des tableaux en tant qu’images
Journaliser des images PIL
Journaliser des images à partir de fichiers

Fournissez directement des tableaux lorsque vous construisez des images manuellement, par exemple à l’aide de make_grid de torchvision.Les tableaux sont convertis au format PNG à l’aide de Pillow.

import wandb

with wandb.init(project="image-log-example") as run:

    images = wandb.Image(image_array, caption="Top: Output, Bottom: Input")

    run.log({"examples": images})

L’image est considérée comme étant en niveaux de gris si la dernière dimension vaut 1, en RGB si elle vaut 3 et en RGBA si elle vaut 4. Si le tableau contient des nombres à virgule flottante, ceux-ci sont convertis en entiers compris entre 0 et 255. Pour normaliser vos images différemment, vous pouvez spécifier le mode manuellement ou simplement fournir une PIL.Image, comme décrit dans l’onglet « Journaliser des images PIL » de ce volet.

Pour contrôler entièrement la conversion des tableaux en images, construisez vous-même la PIL.Image et fournissez-la directement.

from PIL import Image

with wandb.init(project="") as run:
    # Créer une image PIL à partir d’un tableau NumPy
    image = Image.fromarray(image_array)

    # Facultatif : convertir en RGB si nécessaire
    if image.mode != "RGB":
        image = image.convert("RGB")

    # Journaliser l’image
    run.log({"example": wandb.Image(image, caption="My Image")})

Pour un contrôle encore plus poussé, créez vos images comme vous le souhaitez, enregistrez-les sur le disque et fournissez un chemin de fichier.

import wandb
from PIL import Image

with wandb.init(project="") as run:

    im = Image.fromarray(...)
    rgb_im = im.convert("RGB")
    rgb_im.save("myimage.jpg")

    run.log({"example": wandb.Image("myimage.jpg")})

Superpositions sur les images

Masques de segmentation
Boîtes englobantes

Journalisez des masques de segmentation sémantique et interagissez avec eux (modification de l’opacité, visualisation de leur évolution au fil du temps, etc.) dans l’interface utilisateur de W&B.

Pour journaliser une superposition, passez à l’argument nommé masks de wandb.Image un dictionnaire contenant les clés et valeurs suivantes :

l’une des deux clés suivantes, qui représentent le masque d’image :
- "mask_data" : un tableau NumPy 2D contenant une étiquette de classe entière pour chaque pixel
- "path" : (string) le chemin d’un fichier de masque d’image enregistré
"class_labels" : (facultatif) un dictionnaire qui associe les étiquettes de classe entières du masque d’image à des noms de classe lisibles

Pour journaliser plusieurs masques, journalisez un dictionnaire de masques comportant plusieurs clés, comme dans l’extrait de code ci-dessous.Voir un exemple en directExemple de code

mask_data = np.array([[1, 2, 2, ..., 2, 2, 1], ...])

class_labels = {1: "tree", 2: "car", 3: "road"}

mask_img = wandb.Image(
    image,
    masks={
        "predictions": {"mask_data": mask_data, "class_labels": class_labels},
        "ground_truth": {
            # ...
        },
        # ...
    },
)

Les masques de segmentation d’une clé sont définis à chaque step (chaque appel à run.log()).

Si plusieurs steps fournissent des valeurs différentes pour la même clé de masque, seule la valeur la plus récente de cette clé est appliquée à l’image.
Si plusieurs steps fournissent des clés de masque différentes, toutes les valeurs de chaque clé sont affichées, mais seules celles définies dans le step consulté sont appliquées à l’image. Afficher ou masquer les masques non définis dans ce step ne modifie pas l’image.

Journalisez des boîtes englobantes avec des images, et utilisez des filtres et des bascules pour afficher dynamiquement différents ensembles de boîtes dans l’interface utilisateur.

Voir un exemple en directPour journaliser une boîte englobante, vous devez fournir un dictionnaire contenant les clés et valeurs suivantes à l’argument nommé boxes de wandb.Image :

box_data : une liste de dictionnaires, un par boîte. Le format du dictionnaire de boîte est décrit ci-dessous.
- position : un dictionnaire représentant la position et la taille de la boîte, dans l’un des deux formats décrits ci-dessous. Toutes les boîtes ne doivent pas nécessairement utiliser le même format.
  - Option 1 : {"minX", "maxX", "minY", "maxY"}. Fournissez un ensemble de coordonnées définissant les bornes supérieure et inférieure de chaque dimension de la boîte.
  - Option 2 : {"middle", "width", "height"}. Fournissez un ensemble de coordonnées indiquant les coordonnées middle sous la forme [x,y], ainsi que width et height sous forme de scalaires.
- class_id : un entier représentant l’identité de classe de la boîte. Voir la clé class_labels ci-dessous.
- scores : un dictionnaire associant des étiquettes de type string à des valeurs numériques de score. Permet de filtrer les boîtes dans l’interface utilisateur.
- domain : spécifie les unités ou le format des coordonnées de la boîte. Définissez cette valeur sur “pixel” si les coordonnées de la boîte sont exprimées en pixels, par exemple sous forme d’entiers compris dans les limites des dimensions de l’image. Par défaut, le domaine est considéré comme une fraction ou un pourcentage de l’image, exprimé sous forme de nombre à virgule flottante compris entre 0 et 1.
- box_caption : (facultatif) une chaîne à afficher comme texte d’étiquette sur cette boîte
class_labels : (facultatif) un dictionnaire associant des class_id à des chaînes. Par défaut, les étiquettes de classe class_0, class_1, etc. sont générées automatiquement.

Consultez cet exemple :

import wandb

class_id_to_label = {
    1: "car",
    2: "road",
    3: "building",
    # ...
}

img = wandb.Image(
    image,
    boxes={
        "predictions": {
            "box_data": [
                {
                    # une boîte exprimée dans le domaine relatif/fractionnaire par défaut
                    "position": {"minX": 0.1, "maxX": 0.2, "minY": 0.3, "maxY": 0.4},
                    "class_id": 2,
                    "box_caption": class_id_to_label[2],
                    "scores": {"acc": 0.1, "loss": 1.2},
                    # une autre boîte exprimée en pixels
                    # (à titre d’illustration uniquement : en pratique, toutes les boîtes
                    # utiliseront probablement le même domaine/format)
                    "position": {"middle": [150, 20], "width": 68, "height": 112},
                    "domain": "pixel",
                    "class_id": 3,
                    "box_caption": "a building",
                    "scores": {"acc": 0.5, "loss": 0.7},
                    # ...
                    # Journalisez autant de boîtes que nécessaire
                }
            ],
            "class_labels": class_id_to_label,
        },
        # Journalisez chaque groupe de boîtes pertinent sous un nom de clé unique
        "ground_truth": {
            # ...
        },
    },
)

with wandb.init(project="my_project") as run:
    run.log({"driving_scene": img})

Superpositions sur les images dans les Tables

Masques de segmentation
Boîtes englobantes

Masques de segmentation interactifs dans les Tables

Pour journaliser des masques de segmentation dans des tableaux, vous devez fournir un objet wandb.Image pour chaque ligne du tableau.L’extrait de code ci-dessous en donne un exemple :

table = wandb.Table(columns=["ID", "Image"])

for id, img, label in zip(ids, images, labels):
    mask_img = wandb.Image(
        img,
        masks={
            "prediction": {"mask_data": label, "class_labels": class_labels}
            # ...
        },
    )

    table.add_data(id, mask_img)

with wandb.init(project="my_project") as run:
    run.log({"Table": table})

Boîtes englobantes interactives dans les Tables

Pour journaliser des images avec des boîtes englobantes dans des tableaux, vous devez fournir un objet wandb.Image pour chaque ligne du tableau.L’extrait de code ci-dessous en donne un exemple :

table = wandb.Table(columns=["ID", "Image"])

for id, img, boxes in zip(ids, images, boxes_set):
    box_img = wandb.Image(
        img,
        boxes={
            "prediction": {
                "box_data": [
                    {
                        "position": {
                            "minX": box["minX"],
                            "minY": box["minY"],
                            "maxX": box["maxX"],
                            "maxY": box["maxY"],
                        },
                        "class_id": box["class_id"],
                        "box_caption": box["caption"],
                        "domain": "pixel",
                    }
                    for box in boxes
                ],
                "class_labels": class_labels,
            }
        },
    )

Histogrammes

Journalisation de base des histogrammes
Journalisation flexible des histogrammes

Si vous fournissez une séquence de nombres (liste, tableau ou tenseur, par exemple) comme premier argument, l’histogramme est construit automatiquement par un appel à np.histogram(). Tous les tableaux et tenseurs sont aplatis. Vous pouvez utiliser l’argument nommé facultatif num_bins pour redéfinir le nombre d’intervalles par défaut, fixé à 64. Le nombre maximum d’intervalles pris en charge est de 512.Dans l’interface utilisateur, les histogrammes sont tracés avec l’étape d’entraînement sur l’axe X, la valeur de la métrique sur l’axe Y et le nombre d’occurrences représenté par la couleur, afin de faciliter la comparaison des histogrammes journalisés tout au long de l’entraînement. Pour en savoir plus sur la journalisation d’histogrammes ponctuels, consultez l’onglet « Histogrammes dans la synthèse » de ce panneau.

run.log({"gradients": wandb.Histogram(grads)})

Pour un contrôle plus fin, appelez np.histogram() et transmettez le tuple renvoyé à l’argument nommé np_histogram.

np_hist_grads = np.histogram(grads, density=True, range=(0.0, 1.0))
run.log({"gradients": wandb.Histogram(np_hist_grads)})

Visualisations 3D

Journalisez des nuages de points 3D et des scènes Lidar avec des boîtes englobantes. Transmettez un tableau NumPy contenant les coordonnées et les couleurs des points à afficher. Les nuages de points journalisés sont entièrement interactifs dans l’application W&B. Par exemple, le rapport LIDAR Point Clouds of Driving Scenes intégré ci-dessous présente des scènes du jeu de données Lyft avec des boîtes englobantes 3D. Faites glisser la souris pour faire pivoter la scène et zoomer dans la visionneuse.

point_cloud = np.array([[0, 0, 0, COLOR]])

run.log({"point_cloud": wandb.Object3D(point_cloud)})

L’interface de W&B tronque les données au-delà de 300 000 points.

Formats de tableaux NumPy

Trois formats de tableaux NumPy sont pris en charge pour permettre des schémas de couleurs flexibles.

[[x, y, z], ...] nx3
[[x, y, z, c], ...] nx4 | c is a category dans la plage [1, 14] (utile pour la segmentation)
[[x, y, z, r, g, b], ...] nx6 | r,g,b sont des valeurs comprises dans la plage [0,255]pour les canaux de couleur rouge, vert et bleu.

Objet Python

À l’aide de ce schéma, vous pouvez définir un objet Python et le transmettre à la méthode from_point_cloud.

points est un tableau NumPy contenant les coordonnées et les couleurs des points à afficher, selon les mêmes formats que ceux du moteur de rendu de nuage de points simple présenté ci-dessus.
boxes est un tableau NumPy de dictionnaires Python comportant trois attributs :
- corners - une liste de huit coins
- label - une chaîne représentant l’étiquette à afficher sur la boîte (facultatif)
- color - des valeurs RVB représentant la couleur de la boîte
- score - une valeur numérique affichée sur la boîte englobante, qui permet de filtrer les boîtes englobantes affichées (par exemple, pour n’afficher que les boîtes englobantes dont le score est > 0.75) (facultatif)
type est une chaîne représentant le type de scène à afficher. Pour l’instant, la seule valeur prise en charge est lidar/beta

point_list = [
    [
        2566.571924017235, # x
        746.7817289698219, # y
        -15.269245470863748,# z
        76.5, # rouge
        127.5, # vert
        89.46617199365393 # bleu
    ],
    [ 2566.592983606823, 746.6791987335685, -15.275803826279521, 76.5, 127.5, 89.45471117247024 ],
    [ 2566.616361739416, 746.4903185513501, -15.28628929674075, 76.5, 127.5, 89.41336375503832 ],
    [ 2561.706014951675, 744.5349468458361, -14.877496818222781, 76.5, 127.5, 82.21868245418283 ],
    [ 2561.5281847916694, 744.2546118233013, -14.867862032341005, 76.5, 127.5, 81.87824684536432 ],
    [ 2561.3693562897465, 744.1804761656741, -14.854129178142523, 76.5, 127.5, 81.64137897587152 ],
    [ 2561.6093071504515, 744.0287526628543, -14.882135189841177, 76.5, 127.5, 81.89871499537098 ],
    # ... et ainsi de suite
]

run.log({"my_first_point_cloud": wandb.Object3D.from_point_cloud(
     points = point_list,
     boxes = [{
         "corners": [
                [ 2601.2765123137915, 767.5669506323393, -17.816764802288663 ],
                [ 2599.7259021588347, 769.0082337923552, -17.816764802288663 ],
                [ 2599.7259021588347, 769.0082337923552, -19.66876480228866 ],
                [ 2601.2765123137915, 767.5669506323393, -19.66876480228866 ],
                [ 2604.8684867834395, 771.4313904894723, -17.816764802288663 ],
                [ 2603.3178766284827, 772.8726736494882, -17.816764802288663 ],
                [ 2603.3178766284827, 772.8726736494882, -19.66876480228866 ],
                [ 2604.8684867834395, 771.4313904894723, -19.66876480228866 ]
        ],
         "color": [0, 0, 255], # couleur RVB du cadre de délimitation
         "label": "car", # chaîne affichée sur le cadre de délimitation
         "score": 0.6 # valeur numérique affichée sur le cadre de délimitation
     }],
     vectors = [
        {"start": [0, 0, 0], "end": [0.1, 0.2, 0.5], "color": [255, 0, 0]}, # la couleur est facultative
     ],
     point_cloud_type = "lidar/beta",
)})

Lorsque vous visualisez un nuage de points, vous pouvez maintenir la touche Ctrl enfoncée et utiliser la souris pour vous déplacer dans l’espace 3D.

Fichiers de nuages de points

Vous pouvez utiliser la méthode from_file pour charger un fichier JSON contenant des données de nuage de points.

run.log({"my_cloud_from_file": wandb.Object3D.from_file(
     "./my_point_cloud.pts.json"
)})

Vous trouverez ci-dessous un exemple de mise en forme des données du nuage de points.

{
    "boxes": [
        {
            "color": [
                0,
                255,
                0
            ],
            "score": 0.35,
            "label": "My label",
            "corners": [
                [
                    2589.695869075582,
                    760.7400443552185,
                    -18.044831294622487
                ],
                [
                    2590.719039645323,
                    762.3871153874499,
                    -18.044831294622487
                ],
                [
                    2590.719039645323,
                    762.3871153874499,
                    -19.54083129462249
                ],
                [
                    2589.695869075582,
                    760.7400443552185,
                    -19.54083129462249
                ],
                [
                    2594.9666662674313,
                    757.4657929961453,
                    -18.044831294622487
                ],
                [
                    2595.9898368371723,
                    759.1128640283766,
                    -18.044831294622487
                ],
                [
                    2595.9898368371723,
                    759.1128640283766,
                    -19.54083129462249
                ],
                [
                    2594.9666662674313,
                    757.4657929961453,
                    -19.54083129462249
                ]
            ]
        }
    ],
    "points": [
        [
            2566.571924017235,
            746.7817289698219,
            -15.269245470863748,
            76.5,
            127.5,
            89.46617199365393
        ],
        [
            2566.592983606823,
            746.6791987335685,
            -15.275803826279521,
            76.5,
            127.5,
            89.45471117247024
        ],
        [
            2566.616361739416,
            746.4903185513501,
            -15.28628929674075,
            76.5,
            127.5,
            89.41336375503832
        ]
    ],
    "type": "lidar/beta"
}

Tableaux NumPy

Avec les mêmes formats de tableau que ceux définis ci-dessus, vous pouvez utiliser directement des tableaux numpy avec la méthode from_numpy pour définir un nuage de points.

run.log({"my_cloud_from_numpy_xyz": wandb.Object3D.from_numpy(
     np.array(  
        [
            [0.4, 1, 1.3], # x, y, z
            [1, 1, 1], 
            [1.2, 1, 1.2]
        ]
    )
)})

run.log({"my_cloud_from_numpy_cat": wandb.Object3D.from_numpy(
     np.array(  
        [
            [0.4, 1, 1.3, 1], # x, y, z, catégorie 
            [1, 1, 1, 1], 
            [1.2, 1, 1.2, 12], 
            [1.2, 1, 1.3, 12], 
            [1.2, 1, 1.4, 12], 
            [1.2, 1, 1.5, 12], 
            [1.2, 1, 1.6, 11], 
            [1.2, 1, 1.7, 11], 
        ]
    )
)})

run.log({"my_cloud_from_numpy_rgb": wandb.Object3D.from_numpy(
     np.array(  
        [
            [0.4, 1, 1.3, 255, 0, 0], # x, y, z, r, g, b 
            [1, 1, 1, 0, 255, 0], 
            [1.2, 1, 1.3, 0, 255, 255],
            [1.2, 1, 1.4, 0, 255, 255],
            [1.2, 1, 1.5, 0, 0, 255],
            [1.2, 1, 1.1, 0, 0, 255],
            [1.2, 1, 0.9, 0, 0, 255],
        ]
    )
)})

run.log({"protein": wandb.Molecule("6lu7.pdb")})

Journalisez des données moléculaires dans l’un des 10 formats de fichier suivants :pdb, pqr, mmcif, mcif, cif, sdf, sd, gro, mol2 ou mmtf. W&B prend également en charge la journalisation de données moléculaires à partir de chaînes SMILES, de fichiers mol rdkit et d’objets rdkit.Chem.rdchem.Mol.

resveratrol = rdkit.Chem.MolFromSmiles("Oc1ccc(cc1)C=Cc1cc(O)cc(c1)O")

run.log(
    {
        "resveratrol": wandb.Molecule.from_rdkit(resveratrol),
        "green fluorescent protein": wandb.Molecule.from_rdkit("2b3p.mol"),
        "acetaminophen": wandb.Molecule.from_smiles("CC(=O)Nc1ccc(O)cc1"),
    }
)

Une fois votre run terminé, vous pourrez interagir avec des visualisations 3D de vos molécules dans l’interface utilisateur. Voir un exemple en direct avec AlphaFold

Image PNG

wandb.Image convertit par défaut les tableaux numpy ou les instances de PILImage en PNG.

run.log({"example": wandb.Image(...)})
# Ou plusieurs images
run.log({"example": [wandb.Image(...) for img in images]})

Vidéo

Les vidéos sont journalisées à l’aide du type de données wandb.Video :

run.log({"example": wandb.Video("myvideo.mp4")})

Vous pouvez désormais afficher des vidéos dans le navigateur multimédia. Accédez au workspace de votre projet, au workspace de votre run ou à votre rapport, puis cliquez sur Add visualization pour ajouter un volet de médias enrichis.

Vue 2D d’une molécule

Vous pouvez journaliser une vue 2D d’une molécule à l’aide du type de données wandb.Image et de rdkit :

molecule = rdkit.Chem.MolFromSmiles("CC(=O)O")
rdkit.Chem.AllChem.Compute2DCoords(molecule)
rdkit.Chem.AllChem.GenerateDepictionMatching2DStructure(molecule, molecule)
pil_image = rdkit.Chem.Draw.MolToImage(molecule, size=(300, 300))

run.log({"acetic_acid": wandb.Image(pil_image)})

Autres médias

W&B prend également en charge la journalisation de nombreux autres types de médias.

Audio

run.log({"whale songs": wandb.Audio(np_array, caption="OooOoo", sample_rate=32)})

Vous pouvez journaliser jusqu’à 100 clips audio par étape. Pour en savoir plus sur l’utilisation, consultez audio-file.

Vidéo

run.log({"video": wandb.Video(numpy_array_or_path_to_video, fps=4, format="gif")})

Si un tableau numpy est fourni, ses dimensions sont interprétées, dans l’ordre, comme suit : temps, canaux, largeur, hauteur. Par défaut, une image GIF à 4 fps est créée (ffmpeg et la bibliothèque Python moviepy sont requis pour transmettre des objets numpy). Les formats pris en charge sont "gif", "mp4", "webm" et "ogg". Si vous transmettez une chaîne de caractères à wandb.Video, nous vérifions que le fichier existe et que son format est pris en charge avant de le téléverser vers wandb. La transmission d’un objet BytesIO crée un fichier temporaire dont l’extension correspond au format spécifié. Vos vidéos s’affichent dans la section Media des pages Run et Projet de W&B. Pour plus d’informations sur l’utilisation, voir video-file.

Texte

Utilisez wandb.Table pour journaliser du texte dans des tableaux afin de l’afficher dans l’interface utilisateur. Par défaut, les en-têtes de colonne sont ["Input", "Output", "Expected"]. Pour garantir des performances optimales de l’interface utilisateur, le nombre maximum de lignes est fixé par défaut à 10 000. Vous pouvez toutefois redéfinir explicitement ce maximum avec wandb.Table.MAX_ROWS = {DESIRED_MAX}.

with wandb.init(project="my_project") as run:
    columns = ["Text", "Predicted Sentiment", "True Sentiment"]
    # Méthode 1
    data = [["I love my phone", "1", "1"], ["My phone sucks", "0", "-1"]]
    table = wandb.Table(data=data, columns=columns)
    run.log({"examples": table})

    # Méthode 2
    table = wandb.Table(columns=columns)
    table.add_data("I love my phone", "1", "1")
    table.add_data("My phone sucks", "0", "-1")
    run.log({"examples": table})

Vous pouvez également passer un objet DataFrame pandas.

table = wandb.Table(dataframe=my_dataframe)

Pour en savoir plus sur l’utilisation, consultez string.

HTML

run.log({"custom_file": wandb.Html(open("some.html"))})
run.log({"custom_string": wandb.Html('<a href="https://mysite">Link</a>')})

Journalisez du HTML personnalisé sous n’importe quelle clé pour afficher un panneau HTML sur la page du run. Des styles par défaut sont injectés automatiquement ; pour les désactiver, passez inject=False.

run.log({"custom_file": wandb.Html(open("some.html"), inject=False)})

Pour plus d’informations sur l’utilisation, consultez html-file.

​Prérequis

​Images

​Superpositions sur les images

​Superpositions sur les images dans les Tables

​Histogrammes

​Visualisations 3D

​Formats de tableaux NumPy

​Objet Python

​Fichiers de nuages de points

​Tableaux NumPy

​Image PNG

​Vidéo

​Vue 2D d’une molécule

​Autres médias

​Audio

​Vidéo

​Texte

​HTML

Prérequis

Images

Superpositions sur les images

Superpositions sur les images dans les Tables

Histogrammes

Visualisations 3D

Formats de tableaux NumPy

Objet Python

Fichiers de nuages de points

Tableaux NumPy

Image PNG

Vidéo

Vue 2D d’une molécule

Autres médias

Audio

Vidéo

Texte

HTML