A new minor version release, including further bugfixes, official PyTorch 1.10 support, as well as additional features and operators:

Features

• Added video tutorials and Colabs from the PyTorch Geometric Tutorial project (thanks to @AntonioLonga)
• Added the GraphMultisetTransformer operator (thanks to @JinheonBaek)
• Added the PointTransformerConv operator (thanks to @QuanticDisaster)
• Added the HEATConv operator (thanks to @Xiaoyu006)
• Added the PNA GNN model (thanks to @RBendias)
• Added the AddMetaPaths transform, which will add additional edge types to a HeteroData object based on a list of metapaths (thanks to @wsad1)
• Added the Data.to_heterogeneous method to allow for the conversion from Data to HeteroData objects
• Added the AttributedGraphDataset, containing a variety of attributes graphs
• Added the Airports datasets
• Added the structured_negative_sampling_feasible method, which checks if structured_negative_sampling is feasible (thanks to @WuliangHuang)
• GATConv can now make use of multi-dimensional edge features to compute attention scores (thanks to @dongkwan-kim)
• RandomNodeSplit and RandomLinkSplit now support HeteroData as input
• MessagePassing inference can now be sped up via the decomposed_layers argument (thanks to @ZhouAo-ZA)
• negative_sampling and batched_negative_sampling now support negative sampling in bipartite graphs
• HeteroConv now supports the inclusion of arbitrary node-level or edge-level information for the underlying MessagePassing operators
• GNNExplainer now supports multiple node-level masks and explaining regression problems (thanks to @gregorkrz)

Minor Changes

• Data.to_homogeneous will now add node_type information to the homogeneous Data object
• GINEConv now allows to transform edge features automatically in case their dimensionalities do not match (thanks to @CaypoH)
• OGB_MAG will now add node_year information to paper nodes
• Entities datasets do now allow the processing of HeteroData objects via the hetero=True option
• Batch objects can now be batched together to form super batches
• Added heterogeneous graph support for Center, Constant and LinearTransformation transformations
• HeteroConv now allows to return "stacked" embeddings
• The batch vector of a Batch object will now be initialized on the GPU in case other attributes are held in GPU memory

Bugfixes

• Fixed the num_neighbors argument of NeighborLoader in order to specify an edge-type specific number of neighbors
• Fixed the collate policy of lists of integers/strings to return nested lists
• Fixed the Delaunay transformation in case the face attribute is not present in the data
• Fixed the TGNMemory module to only read from the latest update (thanks to @cwh104504)
• Fixed the pickle.PicklingError when Batch objects are used in a torch.multiprocessing.manager.Queue() (thanks to @RasmusOrsoe)
• Fixed an issue with _parent state changing after pickling of Data objects (thanks to @zepx)
• Fixed the ToUndirected transformation in case the number of edges and nodes are equal (thanks to @lmkmkrcc)
• Fixed the from_networkx routine in case node-level and edge-level features share the same names
• Removed the num_nodes warning when creating PairData objects
• Fixed the initialization of the GeneralMultiLayer module in GraphGym (thanks to @fjulian)
• Fixed custom model registration in GraphGym
• Fixed a clash in the run_dir naming of GraphGym (thanks to @fjulian)
• Includes a fix to prevent a GraphGym crash in case ROC-score is undefined (thanks to @fjulian)
• Fixed the Batch.from_data_list routine on dataset slices (thanks to @dtortorella)
• Fixed the MetaPath2Vec model in case there exists isolated nodes
• Fixed torch_geometric.utils.coalesce with CUDA tensors

PyG 2.0.1

This is a minor release, bringing some emergency fixes to PyG 2.0.

Bugfixes

• Fixed a bug in loader.DataLoader that raised a PicklingError for num_workers > 0 (thanks to @r-echeveste, @arglog and @RishabhPandit-00)
• Fixed a bug in the creation of data.Batch objects in case customized data.Data objects expect non-default arguments (thanks to @Emiyalzn)
• Fixed a bug in which SparseTensor attributes could not be batched along single dimensions (thanks to @rubenwiersma)

PyG 2.0 :tada: :tada: :tada:

PyG (PyTorch Geometric) has been moved from my own personal account rusty1s to its own organization account pyg-team to emphasize the ongoing collaboration between TU Dortmund University, Stanford University and many great external contributors. With this, we are releasing PyG 2.0, a new major release that brings sophisticated heterogeneous graph support, GraphGym integration and many other exciting features to PyG.

<p align="center"> <img height="150" src="https://raw.githubusercontent.com/pyg-team/pytorch_geometric/master/docs/source/_static/img/pyg1.svg?sanitize=true" /> </p>

If you encounter any bugs in this new release, please do not hesitate to create an issue.

Heterogeneous Graph Support

We finally provide full heterogeneous graph support in PyG 2.0. See here for the accompanying tutorial.

Highlights

• Heterogeneous Graph Storage: Heterogeneous graphs can now be stored in their own dedicated data.HeteroData class (thanks to @yaoyaowd):

  from torch_geometric.data import HeteroData
  
  data = HeteroData()
  
  # Create two node types "paper" and "author" holding a single feature matrix:
  data['paper'].x = torch.randn(num_papers, num_paper_features)
  data['author'].x = torch.randn(num_authors, num_authors_features)
  
  # Create an edge type ("paper", "written_by", "author") holding its graph connectivity:
  data['paper', 'written_by', 'author'].edge_index = ...  # [2, num_edges]
  

  data.HeteroData behaves similar to a regular homgeneous data.Data object:

  print(data['paper'].num_nodes)
  print(data['paper', 'written_by', 'author'].num_edges)
  data = data.to('cuda')
  

• Heterogeneous Mini-Batch Loading: Heterogeneous graphs can be converted to mini-batches for many small and single giant graphs via the loader.DataLoader and loader.NeighborLoader loaders, respectively. These loaders can now handle both homogeneous and heterogeneous graphs:

  from torch_geometric.loader import DataLoader
  
  loader = DataLoader(heterogeneous_graph_dataset, batch_size=32, shuffle=True)
  
  from torch_geometric.loader import NeighborLoader
  
  loader = NeighborLoader(heterogeneous_graph, num_neighbors=[30, 30], batch_size=128,
                          input_nodes=('paper', data['paper'].train_mask), shuffle=True)
  

• Heterogeneous Graph Neural Networks: Heterogeneous GNNs can now easily be created from homogeneous ones via nn.to_hetero and nn.to_hetero_with_bases. These processes take an existing GNN model and duplicate their message functions to account for different node and edge types:

  from torch_geometric.nn import SAGEConv, to_hetero
  
  class GNN(torch.nn.Module):
      def __init__(hidden_channels, out_channels):
          super().__init__()
          self.conv1 = SAGEConv((-1, -1), hidden_channels)
          self.conv2 = SAGEConv((-1, -1), out_channels)
  
      def forward(self, x, edge_index):
          x = self.conv1(x, edge_index).relu()
          x = self.conv2(x, edge_index)
          return x
  
  model = GNN(hidden_channels=64, out_channels=dataset.num_classes)
  model = to_hetero(model, data.metadata(), aggr='sum')
  

  <p align="center"> <img height="400px" src="https://raw.githubusercontent.com/pyg-team/pytorch_geometric/master/docs/source/_figures/to_hetero.svg?sanitize=true" /> </p>

Additional Features

• A heterogeneous graph tutorial describing all newly released features (thanks to @mrjel)
• A variety of heterogeneous GNN examples
• Support for lazy initialization of GNN operators by passing -1 to the in_channels argument (implemented via nn.dense.Linear). This allows to avoid calculating and keeping track of input tensor sizes, simplyfing the creation of heterogeneous graph models with varying feature dimensionalities across different node and edge types. Lazy initialization is supported for all existing PyG operators (thanks to @yaoyaowd):

  from torch_geometric.nn import GATConv
  
  conv = GATConv(-1, 64)
  
  # We can initialize the model’s parameters by calling it once:
  conv(x, edge_index)
  

• nn.conv.HeteroConv: A generic wrapper for computing graph convolution on heterogeneous graphs (thanks to @RexYing)
• nn.conv.HGTConv: The heterogeneous graph transformer operator from the "Heterogeneous Graph Transformer" paper
• loader.HGTLoader: The heterogeneous graph sampler from the "Heterogeneous Graph Transformer" paper for learning on large-scale heterogeneous graphs (thanks to @chantat)
• Support for heterogeneous graph transformations in transforms.AddSelfLoops, transforms.ToSparseTensor, transforms.NormalizeFeatures and transforms.ToUndirected
• New heterogeneous graph datasets: datasets.OGB_MAG, datasets.IMDB, datasets.DBLP and datasets.LastFM
• Support for converting heterogeneous graphs to "typed" homogeneous ones via data.HeteroData.to_homogeneous (thanks to @yzhao062)
• A tutorial on creating a data.HeteroData object from raw *.csv files (thanks to @yaoyaowd and @mrjel)
• An example to scale heterogeneous graph models via PyTorch Lightning

Managing Experiments with GraphGym

GraphGym is now officially supported in PyG 2.0 via torch_geometric.graphgym. See here for the accompanying tutorial. Overall, GraphGym is a platform for designing and evaluating Graph Neural Networks from configuration files via a highly modularized pipeline (thanks to @JiaxuanYou):

1. GraphGym is the perfect place to start learning about standardized GNN implementation and evaluation
2. GraphGym provides a simple interface to try out thousands of GNN architectures in parallel to find the best design for your specific task
3. GraphGym lets you easily do hyper-parameter search and visualize what design choices are better

<img width=100% src="https://raw.githubusercontent.com/pyg-team/pytorch_geometric/master/docs/source/_figures/graphgym_results.png" />

Breaking Changes

• The datasets.AMiner dataset now returns a data.HeteroData object. See here for our updated MetaPath2Vec example on AMiner.
• transforms.AddTrainValTestMask has been replaced in favour of transforms.RandomNodeSplit
• Since the storage layout of data.Data significantly changed in order to support heterogenous graphs, already processed datasets need to be re-processed by deleting the root/processed folder.
• data.Data.__cat_dim__ and data.Data.__inc__ now expect additional input arguments:

  def __cat_dim__(self, key, value, *args, **kwargs):
      pass
    
  def __inc__(self, key, value, *args, **kwargs):
      pass
  

  In case you modified __cat_dim__ or __inc__ functionality in a customized data.Data object, please ensure to apply the above changes.

Deprecations

• nn.conv.PointConv is deprecated in favour of nn.conv.PointNetConv (thanks to @lelouedec and @QuanticDisaster)
• utils.train_test_split_edges is deprecated in favour of the new transforms.RandomLinkSplit transform
• All data loaders were moved from torch_geometric.data to torch_geometric.loader, e.g.:

  from torch_geometric.loader import DataLoader
  

• loader.NeighborSampler is deprecated in favour of loader.NeighborLoader in order to simplify the application of neighbor sampling and to support both neighbor sampling in homogeneous and heterogeneous graphs
• Data.contains_isolated_nodes and Data.contains_self_loops are deprecated in favour of Data.has_isolated_nodes and Data.has_self_loops, respectively

Additional Features

• torch-scatter and torch-sparse now support half-precision computation via torch.half, bringing half-precision support to PyG
• Added a GNN cheatsheet to the documentation, which lets you more easily choose a GNN operator for your specific need
• Added the transforms.RandomLinkSplit transform to easily perform a random edge-level split (thanks to @RexYing)
• Added the torch_geometric.profile package which provides a variety of utility functions for benchmarking runtimes and memory consumptions of GNN models (thanks to @yzhao062)
• nn.conv.MessagePassing now supports hooks for propagate, message, aggregate and update functions, e.g. via nn.conv.MessagePassing.register_propagate_forward_hook
• Added the nn.conv.GeneralConv operator that can handle most GNN use-cases (e.g., w/ or w/o edge features, ...) and has enough design options to be tuned (e.g., attention, skip-connections, ...) (thanks to @JiaxuanYou)
• Added the nn.models.RECT_L model for learning with completely-imbalanced labels (thanks to @Fizyhsp)
• Added the Pathfinder Discovery Network Convolutional operator nn.conv.PDNConv (thanks to @benedekrozemberczki)
• Added basic GNN model support as part of the nn.models package, e.g., nn.model.GCN, nn.models.GraphSAGE, nn.models.GAT and nn.models.GIN. Pre-defined models support customizing hidden feature dimensionality, number of layers, activation, normalization and jumping knowledge (thanks to @PabloAMC)
• Added the datasets.MD17 datasets (thanks to @M-R-Schaefer)
• Added a link-prediction example of nn.conv.RGCNConv (thanks to @moritzblum)
• Added an example of nn.pool.MemPooling (thanks to @wsad1)
• Added a return_attention_weights argument for nn.conv.TransformerConv (thanks to @wsad1)
• Batch support for utils.homophily (thanks to @wsad1)
• Added a batch_size argument to utils.to_dense_batch (thanks to @jimmiebtlr)

Minor Changes

• Heavily improved loading times of import torch_geometric
• nn.Sequential is now fully jittable
• nn.conv.LEConv is now fully jittable (thanks to @lucagrementieri)
• nn.conv.GENConv can now make use of "add", "mean" or "max" aggregations (thanks to @riskiem)
• Attributes of type torch.nn.utils.rnn.PackedSequence are now correctly handled by data.Data and data.HeteroData (thanks to @WuliangHuang)
• Added support for data.record_stream() in order to allow for data prefetching (thanks to @FarzanT)
• Added a max_num_neighbors attribute to nn.models.SchNet and nn.models.DimeNet (thanks to @nec4)
• nn.conv.MessagePassing is now jittable in case message, aggregate and update return multiple arguments (thanks to @PhilippThoelke)
• utils.from_networkx now supports grouping of node-level and edge-level features (thanks to @PabloAMC)
• Transforms now inherit from transforms.BaseTransform to ease type checking (thanks to @CCInc)
• Added support for the deletion of data attributes via del data[key] (thanks to @Linux-cpp-lisp)

Bugfixes

• The transforms.LinearTransformation transform now correctly transposes the input matrix before applying the transformation (thanks to @beneisner)
• Fixed a bug in benchmark/kernel that prevented the application of DiffPool on the IMDB-BINARY dataset (thanks to @dongZheX)
• Feature dimensionalities of datasets.WikipediaNetwork do now match which the official reported ones in case geom_gcn_preprocess=True (thanks to @ZhuYun97 and @GitEventhandler)
• Fixed a bug in the datasets.DynamicFAUST dataset in which data.num_nodes was undefined (thanks to @koustav123)
• Fixed a bug in which nn.models.GNNExplainer could not handle GNN operators that add self-loops to the graph in case self-loops were already present (thanks to @tw200464tw and @NithyaBhasker)
• nn.norm.LayerNorm may no longer produce NaN gradients (thanks to @fbragman)
• Fixed a bug in which it was not possible to customize networkx drawing arguments in nn.models.GNNExplainer.visualize_subgraph() (thanks to @jvansan)
• transforms.RemoveIsolatedNodes now correctly removes isolated nodes in case data.num_nodes is explicitely set (thanks to @blakechi)

Datasets

• The GitHub Web and ML developer dataset (thanks to @benedekrozemberczki)
• The FacebookPagePage dataset (thanks to @benedekrozemberczki)
• The Twitch gamer datasets (thanks to @benedekrozemberczki)
• The DeezerEurope dataset (thanks to @benedekrozemberczki)
• The GemsecDeezer dataset (thanks to @benedekrozemberczki)
• The LastFMAsia dataset (thanks to @benedekrozemberczki)
• The WikipediaNetwork datasets does now allow usage of the raw dataset as introduced in Multi-scale Attributed Node Embedding (thanks to @benedekrozemberczki)

Bugfixes

• Fixed an error in DeepGCNLayer in case no normalization layer is provided (thanks to @lukasfolle)
• Fixed a bug in GNNExplainer which mixed the loss computation for graph-level and node-level predictions (thanks to @panisson and @wsad1)

A minor release that brings PyTorch 1.9.0 and Python 3.9 support to PyTorch Geometric. In case you are in the process of updating to PyTorch 1.9.0, please re-install the external dependencies for PyTorch 1.9.0 as well (torch-scatter and torch-sparse).

Features

• EGConv (thanks to @shyam196)
• GATv2Conv (thanks to @shakedbr)
• GraphNorm normalization layer
• GNNExplainer now supports explaining graph-level predictions (thanks to @wsad1)
• bro and gini regularization (thanks to @rhsimplex)
• train_test_split_edges() and to_undirected() can now edge features (thanks to @saiden89 and @SherylHYX)
• Datasets can now be accessed with np.ndarray as well (thanks to @josephenguehard)
• dense_to_sparse can now handle batched adjacency matrices
• numba is now an optional dependency

Datasets

• The tree-structured fake news propagation UPFD dataset (thanks to @YingtongDou)
• The large-scale AmazonProducts graph from the GraphSAINT paper
• Added support for two more datasets in the SNAPDataset benchmark suite (thanks to @SherylHYX)

Issues

• Fixed an issue in which SuperGATConv used all positive edges for computing the auxiliary loss (thanks to @anniekmyatt)
• Fixed a bug in which MemPooling produced NaN gradients (thanks to @wsad1)
• Fixed an issue in which the schnetpack package was required for training SchNet (thanks to @mshuaibii)
• Modfied XConv to sample without replacement in case dilation > 1 (thanks to @mayur-ag)
• GraphSAINTSampler can now be used in combination with PyTorch Lightning
• Fixed a bug in HypergraphConv in case num_nodes > num_edges (thanks to @THinnerichs)

Major Features

• Temporal Graph Network and an example utilizing graph attention, (thanks to @emalgorithm)
• CorrectAndSmooth and an example on ogbn-products
• PyTorch Lightning support, see here for the accompanying examples (thanks to @tchaton)
• Sequential API, see here for the accompanying example
• FiLMConv and an example on PPI (thanks to @ldv1)
• SuperGAT and an example on Cora (thanks to @dongkwan-kim)
• MemPooling (thanks to @wsad1)
• PANConv (thanks to @YuGuangWang)
• DiffGroupNorm (thanks to @wsad1)
• ResGatedGraphConv (thanks to @ldv1)
• FAConv (thanks to @wsad1)
• AttentiveFP model for molecular graph learning and an example on ESOL (thanks to @thegodone)
• Shadow k-hop Sampler (currently requires torch-sparse from master)

Additional Features

• Inductive Deep Graph Infomax example (thanks to @harrygcoppock)
• WLConv and an example of the Weisfeiler-Lehman subtree kernel (thanks to @chrsmrrs)
• LabelPropagation
• AddTrainValTestMask transform for creating various splitting strategies (thanks to @dongkwan-kim)
• homophily measurement (thanks to @ldv1)
• to_cugraph conversion

Minor Changes

• More memory-efficient implementation of GCN2Conv
• Improved TransformerConv with the beta argument being input and message dependent (thanks to @ldv1)
• NeighborSampler now works with SparseTensor and supports an additional transform argument
• Batch.from_data_list now supports batching along a new dimension via returning None in Data.__cat_dim__, see here for the accompanying tutorial (thanks to @Linux-cpp-lisp)
• MetaLayer is now "jittable"
• Lazy loading of torch_geometric.nn and torch_geometric.datasets, leading to faster imports (thanks to @Linux-cpp-lisp)
• GNNExplainer now supports various output formats of the underlying GNN model (thanks to @wsad1)

Datasets

• JODIE datasets for temporal graph learning
• WordNet18RR (thanks to @minhtriet)
• Reddit2
• MixHopSyntheticDataset (thanks to @ldv1)
• NELL

Bugfixes

• Fixed SparseAdam usage in examples/metapath2vec.py (thanks to @declanmillar)
• Fixed from_networkx to support empty edge lists (thanks to @shakedbr)
• Fixed a numerical issue in softmax
• Fixed an issue in DenseGraphConv with aggr="max" (thanks to @quqixun)
• Fixed the norm computation in GraphSAINTSampler (thanks to @austintwang)
• Cartesian and LocalCartesian now compute Cartesian coordinates from target to source nodes (thanks to @ldv1)

• Fixed a crucial bug in which InMemoryDatasets with the usage of pre_transform led to an error
• New datasets: WikipediaNetwork and Actor
• Added homophily ratio utility function: torch_geometric.utils.homophily_ratio

Features

• GCN2Conv [Cora example, PPI example]
• TransformerConv
• New Dataset: WebKB
• New Google Colab: Explaining GNN Model Predictions using Captum (thanks to @m30m)
• Distributed training examples for node classification and graph classification (thanks to @maqy1995)
• Node2Vec can now handle different p and q values other than 1 (torch-cluster update required)
• GraphSAGE unsupervised training example (thanks to @yuanx749)
• Linear GAE example (thanks to @GuillaumeSalha)

Minor improvements

• The SIGN example now operates on mini-batches of nodes
• Improved data loading runtime of InMemoryDatasets
• NeighborSampler does now work with SparseTensor as input
• ToUndirected transform in order to convert directed graphs to undirected ones
• GNNExplainer does now allow for customizable edge and node feature loss reduction
• aggr can now passed to any GNN based on the MessagePassing interface (thanks to @m30m)
• Runtime improvements in SEAL (thanks to @muhanzhang)
• Runtime improvements in torch_geometric.utils.softmax (thanks to @Book1996)
• GAE.recon_loss now supports custom negative edge indices (thanks to @reshinthadithyan)
• Faster spmm computation and random_walk sampling on CPU (torch-sparse and torch-cluster updates required)
• DataParallel does now support the follow_batch argument
• Parallel approximate PPR computation in the GDC transform (thanks to @klicperajo)
• Improved documentation by providing an autosummary of all subpackages (thanks to @m30m)
• Improved documentation on how edge weights are handled in various GNNs (thanks to @m30m)

Bugfixes

• Fixed a bug in GATConv when computing attention coefficients in bipartite graphs
• Fixed a bug in GraphSAINTSampler that led to wrong edge feature sampling
• Fixed the DimeNet pretraining link
• Fixed a bug in processing ego-twitter and ego-gplus of the SNAPDataset collection
• Fixed a number of broken dataset URLs (ICEWS18, QM9, QM7b, MoleculeNet, Entities, PPI, Reddit, MNISTSuperpixels, ShapeNet)
• Fixed a bug in which MessagePassing.jittable() tried to write to a file without permission (thanks to @twoertwein)
• GCNConv does not require edge_weight in case normalize=False
• Batch.num_graphs will now report the correct amount of graphs in case of zero-sized graphs

This is a minor release, mostly focusing on PyTorch 1.6.0 support. All external wheels are now also available for PyTorch 1.6.0.

New Features

• WikiCS dataset
• DeepGCN via GENConv and DeepGCNLayer (thanks to @lightaime)
• PairNorm (thanks to @gupta-abhay)
• LayerNorm (thanks to @aluo-x)

Bugfixes

• Fixed a bug which prevented GNNExplainer to work with GATConv
• Fixed the MessagePassing.jittable call when installing PyG via pip
• Fixed a bug in torch-sparse where reduce functions with dim=0 did not yield the correct result
• Fixed a bug in torch-sparse which suppressed all warnings

A new major release, introducing TorchScript support, memory-efficient aggregations, bipartite GNN modules, static graphs and much more!

Major Features

• TorchScript support, see here for the accompanying tutorial (thanks to @lgray and @liaopeiyuan)
• Memory-efficient aggregations via torch_sparse.SparseTensor, see here for the accompanying tutorial
• Most GNN modules can now operate on bipartite graphs (and some of them can also operate on different feature dimensionalities for source and target nodes), useful for neighbor sampling or heterogeneous graphs:

conv = SAGEConv(in_channels=(32, 64), out_channels=64)
out = conv((x_src, x_dst), edge_index)

• Static graph support:

conv = GCNConv(in_channels=32, out_channels=64)

x = torch.randn(batch_size, num_nodes, in_channels)
out = conv(x, edge_index)
print(out.size())
>>> torch.Size([batch_size, num_nodes, out_channels])

Additional Features

• PNAConv (thanks to @lukecavabarrett and @gcorso)
• Pre-Trained DimeNet on QM9
• SEAL link prediction example (thanks to @muhanzhang)
• ClusterGCNConv
• Cluster-GCN PPI example (thanks to @CFF-Dream)
• WeightedEdgeSampler for GraphSAINT (thanks to @KiddoZhu)
• Better num_workers support for GraphSAINT
• The automatic addition of self-loops can now be disabled via the add_self_loops argument, e.g., for GCNConv

Breaking Changes

• Memory-efficient RGCNConv: The old RGCNConv implementation has been moved to FastRGCNConv

Complementary Frameworks

• DeepSNAP: A PyTorch library that bridges between graph libraries such as NetworkX and PyTorch Geometric
• PyTorch Geometric Temporal: A temporal GNN library built upon PyTorch Geometric

Datasets

• GNNBenchmarkDataset suite from the Benchmarking Graph Neural Networks paper
• WordNet18

Bugfixes

• Fixed a bug in the VGAE KL-loss computation (thanks to @GuillaumeSalha)

This release is a big one thanks to many wonderful contributors. You guys are awesome!

Breaking Changes and Highlights

• NeighborSampler got completely revamped: it's now much faster, allows for parallel sampling, and allows to easily apply skip-connections or self-loops. See examples/reddit.py or the newly introduced OGB examples (examples/ogbn_products_sage.py and examples/ogbn_products_gat.py). The latter also sets a new SOTA on the OGB leaderboards (reaching 0.7945 ± 0.0059 test accuracy)
• SAGEConv now uses concat=True by default, and there is no option to disable it anymore
• Node2Vec got enhanced by a parallel sampling mechanism, and as a result, its API slightly changed
• MetaPath2Vec: The first model in PyG that is able to operate on heteregenous graphs
• GNNExplainer: Generating explanations for graph neural networks
• GraphSAINT: A graph sampling based inductive learning method
• SchNet model for learning on molecular graphs, comes with pre-trained weights for each target of the QM9 dataset (thanks to @Nyuten)

Additional Features

• ASAPooling: Adaptive structure aware pooling for learning hierarchical graph representations (thanks to @ekagra-ranjan)
• ARGVA node clustering example, see examples/argva_node_clustering.py (thanks to @gsoosk)
• MFConv: Molecular fingerprint graph convolution operator (thanks to @rhsimplex)
• GIN-E-Conv that extends the GINConv to also account for edge features
• DimeNet: Directional message passing for molecular graphs
• SIGN: Scalable inception graph neural networks
• GravNetConv (thanks to @jkiesele)

Datasets

• Yelp
• Flickr
• AMiner (first real heterogeneous graph)

Minor changes

• GATConv can now return attention weights via the return_attention_weights argument (thanks to @douglasrizzo)
• InMemoryDataset now has a copy method that converts sliced datasets back into a contiguous memory layout
• Planetoid got enhanced by the ability to let users choose between different splitting methods (thanks to @dongkwan-kim)
• k_hop_subgraph: Computes the k-hop subgraph around a subset of nodes
• geodesic_distance: Geodesic distances can now be computed in parallel (thanks to @jannessm)
• tree_decomposition: The tree decompostion algorithm for generating junction trees from molecules
• SortPool benchmark script now uses 1-D convolutions after pooling, leading to better performance (thanks to @muhanzhang)

Bugfixes

• Fixed a bug in write_off
• Fixed a bug in the processing of the GEDDataset dataset
• to_networkx conversion can now also properly handle non-tensor attributes
• Fixed a bug in read_obj (thanks to @mwussow)

Features

• Cluster-GCN via ClusterData and ClusterLoader for operating on large-scale graphs, see examples/cluster_gcn.py for an example on how to use
• Added a tutorial about advanced mini-batching scenarios
• Added a tensorboard logging example

Datasets

• CitationFull: The full citation network dataset suite
• SNAPDataset: A subset of graph datasets from the SNAP dataset collection
• SuiteSparseMatrixCollection
• TrackMLParticleTrackingDataset

Minor Changes

• Added the concat argument to SAGEConv
• Outsourced the train_test_split_edges method of the graph autoencoder GAE class to torch_geometric.utils

Bugfixes

• Fixed SplineConv compatibility with latest torch-spline-conv package
• trimesh conversion utilities do not longer result in a permutation of the input data

Minor Changes

• There are now Python wheels available for torch-scatter and torch-sparse which should make the installation procedure much more user-friendly. Simply run

pip install torch-scatter==latest+${CUDA} torch-sparse==latest+${CUDA} -f https://pytorch-geometric.com/whl/torch-1.4.0.html
pip install torch-geometric

where ${CUDA} should be replaced by either cpu, cu92, cu100 or cu101 depending on your PyTorch installation.

• torch-cluster is now an optional dependency. All methods that rely on torch-cluster will result in an error requesting you to install torch-cluster.
• torch_geometric.data.Dataset can now also be indexed and shuffled:

dataset.shuffle()[:50]

Bugfixes

• Fixed a bug that prevented the user from saving MessagePassing modules.
• Fixed a bug in RGCNConv when using root_weight=False.

This release mainly focuses on torch-scatter=2.0 support. As a result, PyTorch Geometric now requires PyTorch 1.4. If you are in the process of updating to PyTorch 1.4, please ensure that you also re-install all related external packages.

Features

• Graph Diffusion Convolution
• MinCUT Pooling
• CGCNNConv
• TUDataset cleaned versions, containing only non-isomorphic graphs
• GridSampling transform
• ShapeNet dataset now comes with normals and better split options
• TriMesh conversion utilities
• ToSLIC transform for superpixel generation from images
• Re-writing of MessagePassing interface with custom aggregate methods (no API changes)

Bugfixes

• Fixed some failure modes of from_networkx.

This release focuses on Pytorch 1.2 support and removes all torch.bool deprecation warnings. As a result, this release now requires PyTorch 1.2. If you are in the process of updating to PyTorch 1.2, please ensure that you also re-install all related external packages.

Overall, this release brings the following new features/bugfixes:

Features

• Prints out a warning in case the pre_transform and pre_filter arguments differ from an already processed version

Bugfixes

• Removed all torch.bool deprecation warnings
• Fixed ARGA initialization bug
• Fixed a pre-processing bug in QM9

This is a minor release which is mostly distributed for official PyTorch 1.2 support. In addition, it provides minor bugfixes and the following new features:

Modules

• Non-normalized ChebConv in combination with a largest eigenvalue transform
• TAGCN
• Graph U-Net
• Node2Vec
• EdgePooling
• Alternative GMMConv formulation with separate kernels
• Alternative Top-K pooling formulation based on thresholds with examples on synthetic COLORS and TRIANGLES datasets

Datasets

• Pascal VOC 2011 with Berkeley keypoint annotations (PascalVOCKeypoints)
• DBP15K dataset
• WILLOWObjectClass dataset

Please also update related external packages via, e.g.:

$ pip install --upgrade torch-cluster

• Support for giant graph handling using NeighborSampler and bipartite message passing operators
• Debugging support using the new debug API
• Fixed TUDataset download errors
• Added FeasStConv module
• Improved networkx conversion functionality
• Improved Data and DataLoader handling with customizable number_of_nodes (e.g. for holding two graphs in a single Data object)
• Added GeniePath example
• Added SAGPool module
• Added geodesic distance computation using gdist (optional)
• Improved PointNet and DGCNN classification and segmentation examples
• Added subgraph functionality
• Fixed GMMConv
• Added a bunch of new datasets
• Added fast implementations for random graph generation
• Improved loop API
• Minor bugfixes

Thanks to all contributors!

• More convenient self-loop API (including addition of edge weights)
• Small bugfixes, .e.g., DiffPool NaNs and empty edge indices treatment
• New datasets have been added:
  • GEDDataset
  • DynamicFAUST
  • TOSCA
  • SHREC2016

• New models and operators, e.g., RENet, Signed Graph Convolution, Deep Graph Infomax, PPFNet, ...
• Minor bugfixes
• New converts

• bugfixes for bipartite message passing API

PointConv bugfix for bipartite graphs.

This release includes:

• All Variants of Graph Autoencoders
• Gated Graph Conv
• DataParallel bugfixes
• New transforms (Line Graph Transformation, Local Degree Profile, Sample Points with Normals)
• PointNet++ example

• Added remove_faces parameter for face transforms

• Finally completed documentation
• Finally achieved 100% code coverage (every single line is tested)
• Fixed a few minor bugs
• Added the GlobalAttention layer from Li et al.

We made a bunch of improvements to PyTorch Geometric and added various new convolution and pooling operators, e.g., top_k pooling, PointCNN, Iterative Farthest Point Sampling, PointNet++, ...

• minor bug fixes (e.g. calls to torch-sparse had wrong argument order)
• new operators and examples (GINConv and Infomax example)
• added helpful evaluation functions