> ## 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.
> L’Embedding Projector de W&B vous permet de représenter graphiquement des embeddings multidimensionnels sur un plan 2D à l’aide d’algorithmes de réduction de dimension courants comme PCA, UMAP et t-SNE.
# Intégrer des objets
Les [embeddings](https://developers.google.com/machine-learning/crash-course/embeddings/video-lecture) représentent des objets tels que des personnes, des images, des publications ou des mots sous la forme d’une liste de nombres, parfois appelée *vecteur*. En machine learning et en science des données, il existe de nombreuses approches pour générer des embeddings, dans un large éventail d’applications. Cette page part du principe que vous connaissez déjà les embeddings et que vous souhaitez les analyser visuellement dans W\&B.
Ce guide vous montre comment journaliser des embeddings dans W\&B et utiliser l’Embedding Projector pour les représenter sur un plan 2D à l’aide d’algorithmes de réduction de dimension tels que PCA, UMAP et t-SNE. Cette visualisation vous aide à explorer les clusters, à examiner les relations entre les points de données et à vérifier que vos embeddings capturent bien la structure attendue.
Exemples d’embeddings
Avant de l’essayer vous-même, découvrez l’Embedding Projector en action grâce aux ressources suivantes :
* [Rapport de démonstration interactif en direct](https://forge.coreweave.com/wandb/timssweeney/toy_datasets/reports/Feature-Report-W-B-Embeddings-Projector--VmlldzoxMjg2MjY4?accessToken=bo36zrgl0gref1th5nj59nrft9rc4r71s53zr2qvqlz68jwn8d8yyjdz73cqfyhq)
* [Exemple de notebook Colab](https://colab.research.google.com/drive/1DaKL4lZVh3ETyYEM1oJ46ffjpGs8glXA#scrollTo=D--9i6-gXBm_)
Hello world
Cet exemple minimal présente le code strictement nécessaire pour journaliser des embeddings et les visualiser dans le projecteur. W\&B vous permet de journaliser des embeddings à l’aide de la classe `wandb.Table`. Prenons l’exemple suivant de trois embeddings comportant chacun cinq dimensions :
```python theme={"system"}
import wandb
with wandb.init(project="embedding_tutorial") as run:
embeddings = [
# D1 D2 D3 D4 D5
[0.2, 0.4, 0.1, 0.7, 0.5], # embedding 1
[0.3, 0.1, 0.9, 0.2, 0.7], # embedding 2
[0.4, 0.5, 0.2, 0.2, 0.1], # embedding 3
]
run.log(
{"embeddings": wandb.Table(columns=["D1", "D2", "D3", "D4", "D5"], data=embeddings)}
)
run.finish()
```
Une fois le code précédent exécuté, le tableau de bord W\&B contient un nouveau tableau avec vos données. Sélectionnez **2D Projection** dans le sélecteur de panneau en haut à droite pour représenter les embeddings sur un graphique en deux dimensions. W\&B choisit automatiquement des valeurs par défaut pertinentes, que vous pouvez remplacer dans le menu de configuration en cliquant sur l’icône d’engrenage. Dans cet exemple, W\&B utilise les cinq dimensions numériques disponibles.
Digits MNIST
L’exemple suivant illustre un flux de travail plus réaliste, avec des données de plus grande dimension et des superpositions plus riches. L’exemple précédent présente les mécanismes de base de la journalisation des embeddings, mais en pratique, vous travaillez généralement avec beaucoup plus de dimensions et d’échantillons. Prenons le jeu de données MNIST Digits ([UCI ML hand-written digits dataset](https://archive.ics.uci.edu/ml/datasets/Optical+Recognition+of+Handwritten+Digits)), disponible via [SciKit-Learn](https://scikit-learn.org/stable/modules/generated/sklearn.datasets.load_digits.html). Ce jeu de données contient 1 797 enregistrements de 64 dimensions chacun. Il s’agit d’un problème de classification à 10 classes. Vous pouvez également convertir les données d’entrée en images pour les visualiser.
```python theme={"system"}
import wandb
from sklearn.datasets import load_digits
with wandb.init(project="embedding_tutorial") as run:
# Charger le jeu de données
ds = load_digits(as_frame=True)
df = ds.data
# Créer une colonne « target »
df["target"] = ds.target.astype(str)
cols = df.columns.tolist()
df = df[cols[-1:] + cols[:-1]]
# Créer une colonne « image »
df["image"] = df.apply(
lambda row: wandb.Image(row[1:].values.reshape(8, 8) / 16.0), axis=1
)
cols = df.columns.tolist()
df = df[cols[-1:] + cols[:-1]]
run.log({"digits": df})
```
Après avoir exécuté le code précédent, l’interface affiche de nouveau un tableau. Sélectionnez **2D Projection** pour configurer la définition de l’embedding, la coloration, l’algorithme (PCA, UMAP, t-SNE), ses paramètres et la superposition. Ici, W\&B affiche l’image lorsque vous survolez un point. Ces valeurs par défaut sont choisies intelligemment : un simple clic sur **2D Projection** devrait vous donner un résultat similaire. [Interagissez avec cet exemple du tutoriel sur les embeddings](https://forge.coreweave.com/wandb/timssweeney/embedding_tutorial/runs/k6guxhum?workspace=user-timssweeney).
Options de journalisation
Les sections suivantes décrivent les façons prises en charge de structurer les données d’embeddings lorsque vous les journalisez dans W\&B. Vous pouvez journaliser des embeddings dans plusieurs formats :
* **Colonne d’embedding unique :** vos données se présentent souvent déjà sous une forme matricielle. Dans ce cas, vous pouvez créer une seule colonne d’embedding, dont les cellules peuvent contenir des valeurs de type `list[int]`, `list[float]` ou `np.ndarray`.
* **Plusieurs colonnes numériques :** les deux exemples précédents utilisent cette approche et créent une colonne par dimension. W\&B accepte les types Python `int` ou `float` pour les cellules.
Comme pour tout tableau, vous disposez de plusieurs options pour le construire :
* Directement à partir d’un **dataframe** avec `wandb.Table(dataframe=df)`.
* Directement à partir d’une **liste de données** avec `wandb.Table(data=[...], columns=[...])`.
* Construire le tableau **de manière incrémentielle, ligne par ligne** (idéal si votre code contient une boucle). Ajoutez des lignes à votre tableau avec `table.add_data(...)`.
* Ajouter une **colonne d’embeddings** à votre tableau (idéal si vous disposez d’une liste de prédictions sous forme d’embeddings) : `table.add_col("col_name", ...)`.
* Ajouter une **colonne calculée** (idéal si vous souhaitez appliquer une fonction ou un modèle à chaque ligne de votre tableau) : `table.add_computed_columns(lambda row, ndx: {"embedding": model.predict(row)})`.
Options d’affichage
Après avoir journalisé vos embeddings, vous pouvez ajuster leur projection et leur rendu. Après avoir sélectionné **2D Projection**, cliquez sur l’icône d’engrenage pour modifier les paramètres de rendu. En plus de choisir les colonnes souhaitées (voir les sections précédentes), vous pouvez choisir l’algorithme qui vous intéresse ainsi que ses paramètres. Les images suivantes présentent les paramètres d’UMAP et de t-SNE.
Pour les trois algorithmes, W\&B sous-échantillonne les données en un sous-ensemble aléatoire de 1 000 lignes et 50 dimensions.
## Related topics
- [Exemples de code et notebooks](/fr/products/wandb/examples.md)