> ## 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.
# PyTorch Geometric
> Intégrez W&B à PyTorch Geometric pour la visualisation de graphes et le suivi des expériences en apprentissage profond géométrique.
[PyTorch Geometric](https://github.com/pyg-team/pytorch_geometric) (PyG) est une bibliothèque d’apprentissage profond géométrique, et W\&B s’y intègre pour visualiser des graphes et suivre les expériences.
Ce guide vous explique comment vous authentifier auprès de W\&B, installer la bibliothèque `wandb`, visualiser des graphes PyG avec PyVis ou Plotly, et journaliser les métriques d’entraînement de vos flux de travail PyG. Servez-vous-en pour suivre vos expériences et partager des visualisations de graphes dans W\&B.
Après avoir installé PyTorch Geometric, suivez ces étapes pour faire vos premiers pas.
S’inscrire et créer une clé API
Une clé API authentifie votre machine auprès de W\&B. Vous pouvez générer une clé API depuis votre profil utilisateur.
Pour plus de simplicité, accédez aux [Paramètres utilisateur](https://forge.coreweave.com/settings) et créez une clé API. Copiez immédiatement la clé API et enregistrez-la dans un emplacement sécurisé, par exemple un gestionnaire de mots de passe.
1. Cliquez sur l’icône de votre profil utilisateur dans le coin supérieur droit.
2. Sélectionnez **Paramètres utilisateur**, puis faites défiler la page jusqu’à la section **API Keys**.
Installer la bibliothèque `wandb` et se connecter
Pour installer la bibliothèque `wandb` en local et vous connecter :
1. Définissez la [variable d’environnement](/fr/products/wandb/track/environment-variables) `WANDB_API_KEY` sur votre clé API. Remplacez les valeurs entre `<>` par les vôtres :
```bash theme={"system"}
export WANDB_API_KEY=
```
2. Installez la bibliothèque `wandb` et connectez-vous.
```bash theme={"system"}
pip install wandb
wandb login
```
```bash theme={"system"}
pip install wandb
```
```python theme={"system"}
import wandb
wandb.login()
```
```python theme={"system"}
!pip install wandb
import wandb
wandb.login()
```
Visualiser les graphes
Une fois connecté, vous pouvez commencer à envoyer des visualisations de graphes et des données de run à W\&B.
Vous pouvez enregistrer des informations sur les graphes d’entrée, notamment le nombre d’arêtes, le nombre de nœuds, etc. W\&B prend en charge la journalisation des graphiques Plotly et des panneaux HTML : vous pouvez donc aussi journaliser dans W\&B toutes les visualisations que vous créez pour votre graphe. Les sections suivantes présentent deux approches courantes : PyVis pour des visualisations HTML interactives et Plotly pour des visualisations sous forme de graphiques.
Utiliser PyVis
L’extrait de code suivant montre comment procéder avec PyVis et HTML.
```python theme={"system"}
from pyvis.network import Network
import wandb
with wandb.init(project="graph_vis") as run:
net = Network(height="750px", width="100%", bgcolor="#222222", font_color="white")
# Ajouter les arêtes du graphe PyG au réseau PyVis
for e in tqdm(g.edge_index.T):
src = e[0].item()
dst = e[1].item()
net.add_node(dst)
net.add_node(src)
net.add_edge(src, dst, value=0.1)
# Enregistrer la visualisation PyVis dans un fichier HTML
net.show("graph.html")
run.log({"eda/graph": wandb.Html("graph.html")})
```
Utiliser Plotly
Pour créer une visualisation de graphe avec Plotly, convertissez d’abord le graphe PyG en objet networkx. Créez ensuite des nuages de points Plotly pour les nœuds et pour les arêtes. Pour ce faire, utilisez l’extrait de code suivant.
```python theme={"system"}
def create_vis(graph):
G = to_networkx(graph)
pos = nx.spring_layout(G)
edge_x = []
edge_y = []
for edge in G.edges():
x0, y0 = pos[edge[0]]
x1, y1 = pos[edge[1]]
edge_x.append(x0)
edge_x.append(x1)
edge_x.append(None)
edge_y.append(y0)
edge_y.append(y1)
edge_y.append(None)
edge_trace = go.Scatter(
x=edge_x, y=edge_y,
line=dict(width=0.5, color='#888'),
hoverinfo='none',
mode='lines'
)
node_x = []
node_y = []
for node in G.nodes():
x, y = pos[node]
node_x.append(x)
node_y.append(y)
node_trace = go.Scatter(
x=node_x, y=node_y,
mode='markers',
hoverinfo='text',
line_width=2
)
fig = go.Figure(data=[edge_trace, node_trace], layout=go.Layout())
return fig
with wandb.init(project="visualize_graph") as run:
run.log({"graph": wandb.Plotly(create_vis(graph))})
```
Consigner des métriques
En plus des visualisations de graphe, vous pouvez utiliser W\&B pour suivre vos expériences et les métriques associées, comme les fonctions de perte, la précision, etc. Ajoutez les lignes suivantes à votre boucle d’entraînement :
```python theme={"system"}
with wandb.init(project="my_project", entity="my_entity") as run:
run.log({
'train/loss': training_loss,
'train/acc': training_acc,
'val/loss': validation_loss,
'val/acc': validation_acc
})
```
Une fois les visualisations de graphe et les métriques d’entraînement journalisées dans W\&B, vous pouvez comparer vos runs et partager les résultats de vos expériences PyG dans votre workspace W\&B.
Ressources supplémentaires
Les rapports W\&B suivants présentent des exemples concrets d’utilisation de PyG :
* [Recommander des produits Amazon à l’aide de réseaux de neurones sur graphes avec PyTorch Geometric](https://forge.coreweave.com/wandb/manan-goel/gnn-recommender/reports/Recommending-Amazon-Products-using-Graph-Neural-Networks-in-PyTorch-Geometric--VmlldzozMTA3MzYw#what-does-the-data-look-like?)
* [Classification de nuages de points avec PyTorch Geometric](https://forge.coreweave.com/wandb/geekyrakshit/pyg-point-cloud/reports/Point-Cloud-Classification-using-PyTorch-Geometric--VmlldzozMTExMTE3)
* [Segmentation de nuages de points avec PyTorch Geometric](https://forge.coreweave.com/wandb/wandb/point-cloud-segmentation/reports/Point-Cloud-Segmentation-using-Dynamic-Graph-CNN--VmlldzozMTk5MDcy)