> ## 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.
> Journalisez des médias enrichis, des nuages de points 3D et des molécules jusqu’au HTML et aux histogrammes
# Journaliser des médias et des objets
export const WandbReport = ({src, title, height = 640}) => {
const isReportUrl = typeof src === 'string' && (/^https:\/\/(?:wandb\.ai|forge\.coreweave\.com\/wandb)\/[^/]+\/[^/]+\/reports\/.*-{2,3}Vmlldz[A-Za-z0-9]+/).test(src);
if (!src) {
console.error('WandbReport: missing required `src` prop.');
return null;
}
if (!isReportUrl) {
console.warn(`WandbReport: src does not look like a W&B report URL: ${src}`);
}
const frameTitle = title || 'W&B report';
if (!title) {
console.warn('WandbReport: missing `title` prop; using a generic accessible name.');
}
const frameHeight = typeof height === 'number' && height > 0 ? height : 640;
const frameSrc = isReportUrl ? `${src}${src.includes('?') ? '&' : '?'}jupyter=true` : src;
return
{isReportUrl && }
{}
View Report
;
};
export const ColabLink = ({url}) =>
Try in Colab
;
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](/fr/products/wandb/ref/python/data-types).
Pour en savoir plus, consultez un [rapport de démonstration sur la visualisation des prédictions de modèles](https://forge.coreweave.com/wandb/lavanyashukla/visualize-predictions/reports/Visualize-Model-Predictions--Vmlldzo1NjM4OA) ou regardez un [guide pas à pas en vidéo](https://www.youtube.com/watch?v=96MxRvx15Ts).
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 :
```bash theme={"system"}
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](/fr/products/wandb/app/keyboard-shortcuts#media-panels).
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](/fr/products/wandb/app/features/panels/media#compare-mode) 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.
Fournissez directement des tableaux lorsque vous construisez des images manuellement, par exemple à l’aide de [`make_grid` de `torchvision`](https://pytorch.org/vision/stable/utils.html#torchvision.utils.make_grid).
Les tableaux sont convertis au format PNG à l’aide de [Pillow](https://pillow.readthedocs.io/en/stable/index.html).
```python theme={"system"}
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`](https://pillow.readthedocs.io/en/stable/handbook/concepts.html#modes) manuellement ou simplement fournir une [`PIL.Image`](https://pillow.readthedocs.io/en/stable/reference/Image.html), 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`](https://pillow.readthedocs.io/en/stable/reference/Image.html) et fournissez-la directement.
```python theme={"system"}
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.
```python theme={"system"}
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
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 direct](https://forge.coreweave.com/wandb/stacey/deep-drive/reports/Image-Masks-for-Semantic-Segmentation--Vmlldzo4MTUwMw)
[Exemple de code](https://colab.research.google.com/drive/1SOVl3EvW82Q4QKJXX6JtHye4wFix_P4J)
```python theme={"system"}
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 direct](https://forge.coreweave.com/wandb/stacey/yolo-drive/reports/Bounding-Boxes-for-Object-Detection--Vmlldzo4Nzg4MQ)
Pour 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 :
```python theme={"system"}
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
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 :
```python theme={"system"}
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})
```
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 :
```python theme={"system"}
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
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.
```python theme={"system"}
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`.
```python theme={"system"}
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](https://forge.coreweave.com/wandb/stacey/lyft/reports/LIDAR-Point-Clouds-of-Driving-Scenes--Vmlldzo2MzA5Mg) 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.
```python theme={"system"}
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`](/fr/products/wandb/ref/python#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](#python-object).
* `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`
```python theme={"system"}
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`](/fr/products/wandb/ref/python#from_file) pour charger un fichier JSON contenant des données de nuage de points.
```python theme={"system"}
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.
```json theme={"system"}
{
"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](#numpy-array-formats), vous pouvez utiliser directement des tableaux `numpy` avec [la méthode `from_numpy`](/fr/products/wandb/ref/python#from_numpy) pour définir un nuage de points.
```python theme={"system"}
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]
]
)
)})
```
```python theme={"system"}
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],
]
)
)})
```
```python theme={"system"}
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],
]
)
)})
```
```python theme={"system"}
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`](https://www.rdkit.org/docs/index.html) et d’objets `rdkit.Chem.rdchem.Mol`.
```python theme={"system"}
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](https://wandb.me/alphafold-workspace)
Image PNG
[`wandb.Image`](/fr/products/wandb/ref/python/data-types/image) convertit par défaut les tableaux `numpy` ou les instances de `PILImage` en PNG.
```python theme={"system"}
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`](/fr/products/wandb/ref/python) :
```python theme={"system"}
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`](/fr/products/wandb/ref/python/data-types/image) et de [`rdkit`](https://www.rdkit.org/docs/index.html) :
```python theme={"system"}
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
```python theme={"system"}
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`](/fr/products/wandb/ref/query-panel/audio-file).
Vidéo
```python theme={"system"}
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`](https://www.ffmpeg.org) et la bibliothèque Python [`moviepy`](https://pypi.org/project/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](/fr/products/wandb/runs) et [Projet](/fr/products/wandb/track/project-page) de W\&B.
Pour plus d’informations sur l’utilisation, voir [`video-file`](/fr/products/wandb/ref/query-panel/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}`.
```python theme={"system"}
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.
```python theme={"system"}
table = wandb.Table(dataframe=my_dataframe)
```
Pour en savoir plus sur l’utilisation, consultez [`string`](/fr/products/wandb/ref/query-panel).
HTML
```python theme={"system"}
run.log({"custom_file": wandb.Html(open("some.html"))})
run.log({"custom_string": wandb.Html('Link')})
```
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`.
```python theme={"system"}
run.log({"custom_file": wandb.Html(open("some.html"), inject=False)})
```
Pour plus d’informations sur l’utilisation, consultez [`html-file`](/fr/products/wandb/ref/query-panel/html-file).
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](/fr/products/wandb/app/keyboard-shortcuts#media-panels).
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](/fr/products/wandb/app/features/panels/media#compare-mode) d’un volet multimédia.
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 direct](https://forge.coreweave.com/wandb/stacey/deep-drive/reports/Image-Masks-for-Semantic-Segmentation--Vmlldzo4MTUwMw)
[Exemple de code](https://colab.research.google.com/drive/1SOVl3EvW82Q4QKJXX6JtHye4wFix_P4J)
```python theme={"system"}
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.
[Voir un exemple en direct](https://forge.coreweave.com/wandb/stacey/yolo-drive/reports/Bounding-Boxes-for-Object-Detection--Vmlldzo4Nzg4MQ)
Pour 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 :
```python theme={"system"}
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})
```
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 :
```python theme={"system"}
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})
```
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 :
```python theme={"system"}
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,
}
},
)
```
