Cleanup examples

.github/workflows/examples.yml

@@ -24,13 +24,14 @@ jobs:
 
       - name: Run GCN on Cora
         run: |
-          python examples/gcn.py --wandb
+          python examples/planetoid_train.py --gnn_choice gcn --dataset Cora --wandb
         env:
           WANDB_API_KEY: ${{ secrets.WANDB_API_KEY }}
 
       - name: Run GAT on Cora
         run: |
-          python examples/gat.py --wandb
+          python examples/planetoid_train.py --gnn_choice gat --dataset Cora --wandb
+
         env:
           WANDB_API_KEY: ${{ secrets.WANDB_API_KEY }}
 

docker/README.md

@@ -44,21 +44,21 @@ To build the container, run
 then wait. Once finished, you can run the GAT example in the folder you built the image in by calling
 
 ```
-wget https://raw.githubusercontent.com/pyg-team/pytorch_geometric/master/examples/gat.py
+wget https://raw.githubusercontent.com/pyg-team/pytorch_geometric/master/examples/planetoid_train.py
 ```
 
 (to download the sample),
 
 then
 
 ```
-singularity exec geometric.sif python3 gat.py
+singularity exec geometric.sif python3 planetoid_train.py --gnn_choice gat
 ```
 
 to run on the CPU, or
 
 ```
-singularity exec --nv geometric.sif python3 gat.py
+singularity exec --nv geometric.sif python3 planetoid_train.py --gnn_choice gat
 ```
 
 to run on the GPU.

docs/source/advanced/compile.rst

@@ -78,7 +78,7 @@ Exampe Scripts
 
 We have incorporated multiple examples in :obj:`examples/compile` that further show the practical usage of :meth:`torch.compile`:
 
-#. `Node Classification <https://github.com/pyg-team/pytorch_geometric/blob/master/examples/compile/gcn.py>`__ via :class:`~torch_geometric.nn.models.GCN` (:obj:`dynamic=False`)
+#. `Node Classification <https://github.com/pyg-team/pytorch_geometric/blob/master/examples/compile/planetoid_train.py>`__ via :class:`~torch_geometric.nn.models.GCN` (:obj:`dynamic=False`)
 #. `Graph Classification <https://github.com/pyg-team/pytorch_geometric/blob/master/examples/compile/gin.py>`__ via :class:`~torch_geometric.nn.models.GIN` (:obj:`dynamic=True`)
 
 If you notice that :meth:`torch.compile` fails for a certain :pyg:`PyG` model, do not hesitate to reach out either on :github:`null` `GitHub <https://github.com/pyg-team/pytorch_geometric/issues>`_ or :slack:`null` `Slack <https://data.pyg.org/slack.html>`_.

docs/source/tutorial/dataset_splitting.rst

@@ -13,7 +13,7 @@ Node Prediction
 .. note::
 
     In this section, we'll learn how to use :class:`~torch_geometric.transforms.RandomNodeSplit` of :pyg:`PyG` to randomly divide nodes into training, validation, and test sets.
-    A fully working example on dataset :class:`~torch_geometric.datasets.Planetoid` is available in `examples/cora.py <https://github.com/pyg-team/pytorch_geometric/blob/master/examples/cora.py>`_.
+    A fully working example on dataset :class:`~torch_geometric.datasets.Planetoid` is available in `examples/planetoid_train.py <https://github.com/pyg-team/pytorch_geometric/blob/master/examples/planetoid_train.py>`_.
 
 The :class:`~torch_geometric.transforms.RandomNodeSplit` is initialized to split nodes for both a :pyg:`PyG` :class:`~torch_geometric.data.Data` and :class:`~torch_geometric.data.HeteroData` object.
 

docs/source/tutorial/neighbor_loader.rst

@@ -3,9 +3,9 @@ Scaling GNNs via Neighbor Sampling
 
 One of the challenges of Graph Neural Networks is to scale them to large graphs, *e.g.*, in industrial and social applications.
 Traditional deep neural networks are known to scale well to large amounts of data by decomposing the training loss into individual samples (called a *mini-batch*) and approximating exact gradients stochastically.
-In contrast, applying stochastic mini-batch training in GNNs is challenging since the embedding of a given node depends recursively on all its neighbor’s embeddings, leading to high inter-dependency between nodes that grows exponentially with respect to the number of layers.
+In contrast, applying stochastic mini-batch training in GNNs is challenging since the embedding of a given node depends recursively on all its neighbor's embeddings, leading to high inter-dependency between nodes that grows exponentially with respect to the number of layers.
 This phenomenon is often referred to as *neighbor explosion*.
-As a simple workaround, GNNs are typically executed in a full-batch fashion (see `here <https://github.com/pyg-team/pytorch_geometric/blob/master/examples/gcn.py>`_ for an example), where the GNN has access to all hidden node representations in all its layers.
+As a simple workaround, GNNs are typically executed in a full-batch fashion (see `here <https://github.com/pyg-team/pytorch_geometric/blob/master/examples/planetoid_train.py>`_ for an example), where the GNN has access to all hidden node representations in all its layers.
 However, this is not feasible in large-scale graphs due to memory limitations and slow convergence.
 
 Scalability techniques are indispensable for applying GNNs to large-scale graphs in order to alleviate the neighbor explosion problem induced by mini-batch training, *i.e.* **node-wise**, **layer-wise** or **subgraph-wise** sampling techniques, or to **decouple propagations from predictions**.

docs/source/tutorial/shallow_node_embeddings.rst

@@ -39,7 +39,7 @@ Node2Vec
 .. note::
 
     In this section of the tutorial, we will learn node embeddings for **homogenous graphs** using the :class:`~torch_geometric.nn.models.Node2Vec` module of :pyg:`PyG`.
-    The code is available in `examples/node2vec.py <https://github.com/pyg-team/pytorch_geometric/blob/master/examples/node2vec.py>`_ and as a `Google Colab tutorial notebook <https://colab.research.google.com/github/AntonioLonga/PytorchGeometricTutorial/blob/main/Tutorial11/Tutorial11.ipynb>`_.
+    The code is available in `examples/planetoid_train.py <https://github.com/pyg-team/pytorch_geometric/blob/master/examples/planetoid_train.py>`_ and as a `Google Colab tutorial notebook <https://colab.research.google.com/github/AntonioLonga/PytorchGeometricTutorial/blob/main/Tutorial11/Tutorial11.ipynb>`_.
 
 :class:`~torch_geometric.nn.models.Node2Vec` is a method for learning shallow node embeddings, which allows for flexible
 control of random walk procedures based on breadth-first or depth-first samplers.

examples/README.md

@@ -3,7 +3,7 @@
 This folder contains a plethora of examples covering different GNN use-cases.
 This readme highlights some key examples.
 
-A great and simple example to start with is [`gcn.py`](./gcn.py), showing a user how to train a [`GCN`](https://pytorch-geometric.readthedocs.io/en/latest/generated/torch_geometric.nn.models.GCN.html) model for node-level prediction on small-scale homogeneous data.
+A great and simple example to start with is [`planetoid_train.py`](./planetoid_train.py), showing a user how to train a [`GCN`](https://pytorch-geometric.readthedocs.io/en/latest/generated/torch_geometric.nn.models.GCN.html) model for node-level prediction on small-scale homogeneous data.
 
 For a simple link prediction example, see [`link_pred.py`](./link_pred.py).
 
@@ -22,3 +22,26 @@ For examples on scaling PyG up via multi-GPUs, see the examples under [`examples
 For examples on working with heterogeneous data, see the examples under [`examples/hetero`](./hetero).
 
 For examples on co-training LLMs with GNNs, see the examples under [`examples/llm`](./llm).
+
+# Results
+
+```
+python examples/planetoid_train.py --gnn_choice {model} --dataset {dataset}
+```
+
+| Model     | Cora       | CiteSeer   | PubMed     |
+| --------- | ---------- | ---------- | ---------- |
+| GCN       | 83.80%     | 72.40%     | 87.20%     |
+| GAT       | 91.40%     | 76.00%     | 84.20%     |
+| AGNN      | 92.00%     | 77.20%     | 87.80%     |
+| ARMA      | 88.60%     | 74.40%     | 86.60%     |
+| MixHop    | 91.40%     | 75.80%     | 84.60%     |
+| SGC       | 64.00%     | 73.60%     | 77.00%     |
+| TAGCN     | 91.20%     | 73.80%     | **89.00%** |
+| GraphUNet | 90.20%     | 77.20%     | 85.20%     |
+| PMLP      | 90.40%     | **77.40%** | 84.60%     |
+| SplineGNN | 91.60%     | **77.40%** | 87.60%     |
+| GCN2      | **92.80%** | 75.60%     | 84.60%     |
+| SuperGAT  | 88.20%     | 74.40%     | 80.60%     |
+| DNA       | 90.00%     | 75.20%     | 85.80%     |
+| Node2Vec  | 84.00%     | 55.60%     | 76.80%     |