Page d'accueil>Lié à la programmation>Python
Télécharger

Documentation | Papier | Colab Notebooks and Video Tutorials | Ressources externes | Exemples OGB

PYG (Pytorch GeoMetric) est une bibliothèque construite sur Pytorch pour écrire et former facilement les réseaux de neurones graphiques (GNNS) pour un large éventail d'applications liées aux données structurées.

Il se compose de diverses méthodes d'apprentissage en profondeur sur les graphiques et autres structures irrégulières, également connues sous le nom d'apprentissage en profondeur géométrique , à partir d'une variété d'articles publiés. De plus, il se compose de chargeurs de mini-lots faciles à utiliser pour fonctionner sur de nombreux petits et uniques graphiques géants, support multi-GPU, support torch.compile , support DataPipe , un grand nombre d'ensembles de données de référence courants (basés sur des interfaces simples pour créer la vôtre), et des transformations utiles, à la fois pour l'apprentissage sur des graphiques arbitraires ainsi que sur des mâles 3D ou des messages.

Cliquez ici pour rejoindre notre communauté Slack!

  • Points forts de la bibliothèque
  • Tour rapide pour les nouveaux utilisateurs
  • Aperçu de l'architecture
  • Modèles GNN mis en œuvre
  • Installation

Points forts de la bibliothèque

Que vous soyez un chercheur à l'apprentissage automatique ou un premier utilisateur de boîtes d'outils d'apprentissage automatique, voici quelques raisons d'essayer le PYG pour l'apprentissage automatique sur les données structurées des graphiques.

  • API facile à utiliser et unifiée : tout ce qu'il faut, c'est 10 à 20 lignes de code pour commencer la formation d'un modèle GNN (voir la section suivante pour une visite rapide). Le PYG est Pytorch-on-the-rocks : il utilise une API centrée sur le tenseur et garde les principes de conception proches du pytorch à la vanille. Si vous connaissez déjà Pytorch, l'utilisation de PYG est simple.
  • Modèles GNN complets et bien entretenus : la plupart des architectures de réseau neuronal de pointe de pointe ont été mises en œuvre par des développeurs de bibliothèques ou des auteurs d'articles de recherche et sont prêts à être appliqués.
  • Grande flexibilité : les modèles PYG existants peuvent facilement être étendus pour mener vos propres recherches avec GNNS. Faire des modifications aux modèles existants ou création de nouvelles architectures est simple, grâce à son API de passage de messages faciles à utiliser, et à une variété d'opérateurs et de fonctions utilitaires.
  • Modèles GNN du monde réel à grande échelle : Nous nous concentrons sur la nécessité d'applications GNN dans les scénarios du monde réel stimulant et prenons en charge l'apprentissage sur divers types de graphiques, y compris, mais sans s'y limiter: GNNS évolutifs pour des graphiques avec des millions de nœuds; GNNS dynamiques pour les prédictions de nœud dans le temps; GNN hétérogène avec plusieurs types de nœuds et types de bords.

Tour rapide pour les nouveaux utilisateurs

Dans cette visite rapide, nous soulignons la facilité de création et de formation d'un modèle GNN avec seulement quelques lignes de code.

Formez votre propre modèle GNN

Dans le premier aperçu de PYG, nous mettons en œuvre la formation d'un GNN pour classer les articles dans un graphique de citation. Pour cela, nous chargeons l'ensemble de données CORA et créons un modèle GCN à 2 couches simple à l'aide du GCNConv prédéfini: 

 import torch
from torch import Tensor
from torch_geometric . nn import GCNConv
from torch_geometric . datasets import Planetoid

dataset = Planetoid ( root = '.' , name = 'Cora' )

class GCN ( torch . nn . Module ):
    def __init__ ( self , in_channels , hidden_channels , out_channels ):
        super (). __init__ ()
        self . conv1 = GCNConv ( in_channels , hidden_channels )
        self . conv2 = GCNConv ( hidden_channels , out_channels )

    def forward ( self , x : Tensor , edge_index : Tensor ) -> Tensor :
        # x: Node feature matrix of shape [num_nodes, in_channels]
        # edge_index: Graph connectivity matrix of shape [2, num_edges]
        x = self . conv1 ( x , edge_index ). relu ()
        x = self . conv2 ( x , edge_index )
        return x

model = GCN ( dataset . num_features , 16 , dataset . num_classes )
Nous pouvons désormais optimiser le modèle dans une boucle de formation, similaire à la procédure de formation standard de Pytorch. 
 import torch . nn . functional as F

data = dataset [ 0 ]
optimizer = torch . optim . Adam ( model . parameters (), lr = 0.01 )

for epoch in range ( 200 ):
    pred = model ( data . x , data . edge_index )
    loss = F . cross_entropy ( pred [ data . train_mask ], data . y [ data . train_mask ])

    # Backpropagation
    optimizer . zero_grad ()
    loss . backward ()
    optimizer . step ()

Plus d'informations sur l'évaluation des performances du modèle final peuvent être trouvées dans l'exemple correspondant.

Créez votre propre couche GNN

En plus de l'application facile des GNN existants, PYG facilite la mise en œuvre de réseaux de neurones graphiques personnalisés (voir ici pour le tutoriel d'accompagnement). Par exemple, c'est tout ce qu'il faut pour implémenter la couche de convolution de bord de Wang et al. :

$$ x_i ^ { prime} ~ = ~ max_ {j in mathcal {n} (i)} ~ textrm {mlp} _ { theta} Left ([~ x_i, ~ x_j - x_i ~] droite) $$ 

 import torch
from torch import Tensor
from torch . nn import Sequential , Linear , ReLU
from torch_geometric . nn import MessagePassing

class EdgeConv ( MessagePassing ):
    def __init__ ( self , in_channels , out_channels ):
        super (). __init__ ( aggr = "max" )  # "Max" aggregation.
        self . mlp = Sequential (
            Linear ( 2 * in_channels , out_channels ),
            ReLU (),
            Linear ( out_channels , out_channels ),
        )

    def forward ( self , x : Tensor , edge_index : Tensor ) -> Tensor :
        # x: Node feature matrix of shape [num_nodes, in_channels]
        # edge_index: Graph connectivity matrix of shape [2, num_edges]
        return self . propagate ( edge_index , x = x )  # shape [num_nodes, out_channels]

    def message ( self , x_j : Tensor , x_i : Tensor ) -> Tensor :
        # x_j: Source node features of shape [num_edges, in_channels]
        # x_i: Target node features of shape [num_edges, in_channels]
        edge_features = torch . cat ([ x_i , x_j - x_i ], dim = - 1 )
        return self . mlp ( edge_features )  # shape [num_edges, out_channels]

Aperçu de l'architecture

PYG fournit un cadre multicouche qui permet aux utilisateurs de créer des solutions de réseau neuronal graphiques à des niveaux faibles et élevés. Il comprend les composants suivants:

  • Le moteur PYG utilise le puissant cadre d'apprentissage en profondeur Pytorch avec un support complet torch.compile et de torchscript, ainsi que des ajouts de bibliothèques CPU / CUDA efficaces pour fonctionner sur des données clairsemées, par exemple , pyg-lib .
  • Le stockage PYG gère les pipelines de traitement des données, de transformation et de chargement. Il est capable de gérer et de traiter les ensembles de données de graphiques à grande échelle et fournit des solutions efficaces pour les graphiques hétérogènes. Il fournit en outre une variété de solutions d'échantillonnage, qui permettent la formation des GNN sur les graphiques à grande échelle.
  • Les opérateurs PYG regroupent les fonctionnalités essentielles pour implémenter les réseaux de neurones graphiques. PYG prend en charge d'importants blocs de construction GNN qui peuvent être combinés et appliqués à diverses parties d'un modèle GNN, garantissant une riche flexibilité de la conception GNN.
  • Enfin, PYG fournit un ensemble abondant de modèles GNN et des exemples qui présentent des modèles GNN sur des repères graphiques standard. Grâce à sa flexibilité, les utilisateurs peuvent facilement créer et modifier les modèles GNN personnalisés pour répondre à leurs besoins spécifiques.

Modèles GNN mis en œuvre

Nous énumérons actuellement les modèles, les couches et les opérateurs PYG en fonction de la catégorie:

Couches GNN: toutes les couches de réseau de neurones graphiques sont implémentées via l'interface nn.MessagePassing . Une couche GNN spécifie comment effectuer le passage du message, c'est-à-dire en concevant différentes fonctions de message, d'agrégation et de mise à jour telles que définies ici. Ces couches GNN peuvent être empilées pour créer des modèles de réseau neuronal graphique.

  • GCNCONV de KIPF et Welling: classification semi-supervisée avec des réseaux de convolution graphique (ICLR 2017) [ Exemple ]
  • Chebconv de Defferrard et al. : Réseaux de neurones convolutionnels sur des graphiques avec filtrage spectral localisé rapide (NIPS 2016) [ Exemple ]
  • GATCONV de Veličković et al. : Graphy Attention Networks (ICLR 2018) [ Exemple ]
Se développer pour voir toutes les couches GNN implémentées ...
  • GCN2CONV de Chen et al. : Réseaux de convolution des graphiques simples et profonds (ICML 2020) [ Exemple1 , Exemple2 ]
  • Splineconv de Fey et al. : Splinecnn: apprentissage en profondeur géométrique rapide avec des noyaux continues B-spline (CVPR 2018) [ Exemple1 , exemple2 ]
  • NNCONV de Gilmer et al. : Message neuronal passant pour la chimie quantique (ICML 2017) [ Exemple1 , exemple2 ]
  • CGCONV de Xie et Grossman: Crystal Graph Convolutionnel Neural Networks pour une prédiction précise et interprétable des propriétés matérielles (Lettres d'examen physique 120, 2018)
  • ECCONV de Simonovsky et Komodakis: Convolution conditionnée par le bord sur les graphiques (CVPR 2017)
  • EGCONV de Tailor et al. : Filtres adaptatifs et fusion d'agrégateurs pour des convolutions de graphes efficaces (GNNSYS 2021) [ Exemple ]
  • GATV2CONV de Brody et al. : Dans quelle mesure les réseaux d'attention graphiques sont-ils attentifs? (ICLR 2022)
  • TransformerConv de Shi et al. : Prédiction d'étiquette masquée: modèle de passage de messages unifié pour la classification semi-supervisée (Corr 2020) [ Exemple ]
  • Sageconv de Hamilton et al. : Apprentissage de la représentation inductive sur les grands graphiques (NIPS 2017) [ Exemple1 , exemple2 , exemple3 , exemple4 ]
  • GraphConv de, par exemple , Morris et al. : Weisfeiler et Leman Go Neural: Networks de neurones de graphiques d'ordre supérieur (AAAI 2019)
  • GatedgraphConv de Li et al. : Réseaux de neurones de séquence de graphes fermés (ICLR 2016)
  • ResgedGraphConv de Bresson et Laurent: Convalets de graphes fermés résiduels (Corr 2017)
  • Ginconv de Xu et al. : Quelle est la puissance des réseaux de neurones graphiques? (ICLR 2019) [ Exemple ]
  • Gineconv de Hu et al. : Stratégies pour les réseaux de neurones du graphique pré-formation (ICLR 2020)
  • Armaconv de Bianchi et al. : Graphiquement des réseaux de neurones avec filtres ARMA convolutionnels (Corr 2019) [ Exemple ]
  • SGCONV de Wu et al. : Simplifier les réseaux de convolution des graphiques (Corr 2019) [ Exemple ]
  • Appnp de Klicpera et al. : Prédire ensuite Propagate: les réseaux de neurones graphiques rencontrent PageRank personnalisé (ICLR 2019) [ Exemple ]
  • MFCONV de Duvenaud et al. : Réseaux convolutionnels sur les graphiques pour apprendre les empreintes digitales moléculaires (NIPS 2015)
  • Agnnconv de Thekumparampil et al. : Réseau de neurones graphiques basé sur l'attention pour l'apprentissage semi-supervisé (Corr 2017) [ Exemple ]
  • Tagconv de Du et al. : Topology Adaptive Graph Convolutionnel Networks (Corr 2017) [ Exemple ]
  • PNACONV de Corso et al. : Aggrégation principale du quartier pour les filets graphiques (Corr 2020) [ Exemple ]
  • FACONV de Bo et al. : Au-delà des informations à basse fréquence dans les réseaux de convolution des graphiques (AAAI 2021)
  • PDNCONV de Rozemberczki et al. : Pathfinder Discovery Networks for Neural Message Passing (www 2021)
  • RGCNCONV de Schlichtkrull et al. : Modélisation des données relationnelles avec des réseaux de convolution graphique (ESWC 2018) [ Exemple1 , exemple2 ]
  • RGATCONV de Busbridge et al. : Réseaux d'attention des graphiques relationnels (Corr 2019) [ Exemple ]
  • FilmConv de Brockschmidt: GNN-Film: Graph Neural Networks avec modulation linéaire en fonction des fonctionnalités (ICML 2020) [ Exemple ]
  • SignedConv de Derr et al. : Signed Graph Convolutional Network (ICDM 2018) [ Exemple ]
  • DNACONV de FEY: Just Jump: Dynamic Neighbourhood Aggregation in Graph Neural Networks (ICLR-W 2019) [ Exemple ]
  • Panconv de Ma et al. : Path Convolution basée sur l'intégralité et la mise en commun pour les réseaux de neurones graphiques (Neirips 2020)
  • PointNetConv (y compris l'échantillonnage des points le plus éloigné itératif , la génération de graphiques dynamiques basée sur le voisin le plus proche ou la distance maximale et l'interpolation K-NN pour l'échantillonnage) de Qi et al. : PointNet: Deep Learning on Point Sets for 3D Classification and Segmentation (CVPR 2017) et PointNet ++: Deep Hiérarchical Feature Learning on Point Set dans un espace métrique (NIPS 2017) [ Exemple1 , Exemple2 ]
  • Edgeconv de Wang et al. : Graphique dynamique CNN pour l'apprentissage sur les nuages ponctuels (Corr, 2018) [ Exemple1 , exemple2 ]
  • XCONV de Li et al. : POINTCNN: Convolution sur les points transformés en X (Neirips 2018) [ Exemple ]
  • PPFCONV de Deng et al. : PPFNET: fonctionnalités locales de conscience du contexte mondial pour une correspondance de points 3D robuste (CVPR 2018)
  • GMMCONV de Monti et al. : Apprentissage en profondeur géométrique sur les graphiques et les collecteurs à l'aide du modèle de mélange CNNS (CVPR 2017)
  • FEASTCONV de Verma et al. : FEASTNET: Convolutions de graphiques à ventre pour l'analyse de forme 3D (CVPR 2018)
  • PointTransformerConv de Zhao et al. : Transformer Point (2020)
  • Hypergraphconv de Bai et al. : Convolution hypergraphique et attention hypergraphique (Corr 2019)
  • GravNetConv de Qasim et al. : Représentations d'apprentissage de la géométrie irrégulière des particules avec des réseaux graphiques pondérés à distance (European Physics Journal C, 2019)
  • Supergat de Kim et OH: Comment trouver votre quartier sympathique: conception de l'attention du graphique avec auto-supervision (ICLR 2021) [ Exemple ]
  • HGTCONV de Hu et al. : Transformateur de graphe hétérogène (www 2020) [ Exemple ]
  • HeatConv de Mo et al. : Réseau d'attention du graphique amélioré par le bord hétérogène pour la prédiction de trajectoire multi-agents (Corr 2021)
  • SSGCONV de Zhu et al. : Convolution de graphe spectrale simple (ICLR 2021)
  • Fusedgatconv de Zhang et al. : Comprendre le graphique de calcul GNN: un calcul coordonné, une IO et une perspective de mémoire (MLSYS 2022)
  • GPSCONV de Rampášek et al. : Recette pour un transformateur de graphe général, puissant et évolutif (Neirips 2022) [ Exemple ]

Couches de regroupement: les couches de regroupement de graphiques combinent les représentations vectoriales d'un ensemble de nœuds dans un graphique (ou un sous-graphique) en une représentation vectorielle unique qui résume ses propriétés des nœuds. Il est généralement appliqué aux tâches au niveau du graphique, qui nécessitent de combiner les fonctionnalités de nœud en une seule représentation de graphique.

  • Envoi de Kid-K à partir de GAO et JI: graphes U-NETS (ICML 2019), Cangea et al. : Vers des classificateurs de graphiques hiérarchiques clairsemés (Neirips-W 2018) et Knyazev et al. : Comprendre l'attention et la généralisation dans les réseaux de neurones graphiques (ICLR-W 2019) [ Exemple ]
  • Diffpool de Ying et al. : Apprentissage de représentation de graphe hiérarchique avec un accouchement différenciable (Neirips 2018) [ Exemple ]
Développez pour voir toutes les couches de mise en commun implémentées ...
  • L'agrégation attentionnelle de Li et al. : Réseaux de correspondance de graphiques pour apprendre la similitude des objets structurés graphiques (ICML 2019) [ Exemple ]
  • Set2Set de Vinyals et al. : Order Matters: séquence à séquence pour les ensembles (ICLR 2016) [ Exemple ]
  • Trier l'agrégation de Zhang et al. : Une architecture d'apprentissage en profondeur de bout en bout pour la classification des graphiques (AAAI 2018) [ Exemple ]
  • La mise en commun de Mincut de Bianchi et al. : Clustering spectral avec réseaux de neurones graphiques pour la mise en commun des graphiques (ICML 2020) [ Exemple ]
  • DMON Pooling de Tsitsulin et al. : Regroupement de graphiques avec des réseaux de neurones graphiques (Corr 2020) [ Exemple ]
  • Graclus se souciant de Dhillon et al. : Coupes de graphiques pondérés sans vecteurs propres: une approche à plusieurs niveaux (Pami 2007) [ Exemple ]
  • Voxel Grid Envocant de, par exemple , Simonovsky et Komodakis: filtres dynamiques conditionnés par le bord dans les réseaux de neurones convolutionnaux sur les graphiques (CVPR 2017) [ Exemple ]
  • Avanage des affaissement de Lee et al. : La mise en commun des graphiques d'auto-agencement (ICML 2019) et Knyazev et al. : Comprendre l'attention et la généralisation dans les réseaux de neurones graphiques (ICLR-W 2019) [ Exemple ]
  • La mise en commun des bords de Diehl et al. : Vers la mise en commun des graphiques par la contraction des bords (ICML-W 2019) et Diehl: Pooling de contraction des bords pour les réseaux de neurones graphiques (Corr 2019) [ Exemple ]
  • Asapooling de Ranjan et al. : ASAP: Structure adaptative Association de conscience pour l'apprentissage des représentations de graphiques hiérarchiques (AAAI 2020) [ Exemple ]
  • Panpooling de Ma et al. : Path Convolution basée sur l'intégralité et la mise en commun pour les réseaux de neurones graphiques (Neirips 2020)
  • Mempooling de Khasahmadi et al. : Réseaux de graphiques basés sur la mémoire (ICLR 2020) [ Exemple ]
  • Transformateur multiset graphique de Baek et al. : Apprentissage précis des représentations de graphiques avec regroupement multiset graphique (ICLR 2021) [ Exemple ]
  • L'agrégation d'équilibre de Bartunov et al. : (Uai 2022) [ Exemple ]

Modèles GNN: Nos modèles GNN pris en charge intègrent plusieurs couches de passage de messages, et les utilisateurs peuvent utiliser directement ces modèles prédéfinis pour faire des prédictions sur les graphiques. Contrairement à l'empilement simple des couches GNN, ces modèles pourraient impliquer le prétraitement, les paramètres apprendables supplémentaires, les connexions de saut, le grossissement du graphique, etc.

  • Schnet de Schütt et al. : Schnet: un réseau neuronal convolutionnel à filtre continu pour la modélisation des interactions quantiques (NIPS 2017) [ Exemple ]
  • Dimennet et Dimenetplusplus de Klicpera et al. : Message directionnel passant pour les graphiques moléculaires (ICLR 2020) et le message directionnel rapide et incertain passant pour les molécules non d'équilibre (Neirips-W 2020) [ Exemple ]
  • Node2Vec de Grover et Leskovec: Node2Vec: Apprentissage des fonctionnalités évolutives pour les réseaux (KDD 2016) [ Exemple ]
  • Graphique profond Infomax de Veličković et al. : Deep Graph InfoMax (ICLR 2019) [ Exemple1 , Exemple2 ]
  • Graphique multiplex profond Infomax de Park et al. : Intégration du réseau multiplicateur attribué non survisé (AAAI 2020) [ Exemple ]
  • Prédiction étiquetée masquée de Shi et al. : Prédiction d'étiquette masquée: modèle de passage de messages unifié pour la classification semi-supervisée (Corr 2020) [ Exemple ]
  • Le PMLP de Yang et al. : Les réseaux de neurones graphiques sont intrinsèquement de bons généralisateurs: les idées en pontant les GNN et les MLP (ICLR 2023)
Se développer pour voir tous les modèles GNN implémentés ...
  • Les connaissances de saut de Xu et al. : Représentation Learning on Graphs with Jumping Knowledge Networks (ICML 2018) [ Exemple ]
  • Un Metalayer pour construire tout type de réseau graphique similaire à la bibliothèque de graphiques TensorFlow de Battaglia et al. : Les préjugés inductifs relationnels, les réseaux d'apprentissage en profondeur et les graphiques (Corr 2018)
  • Metapath2Vec de Dong et al. : Metapath2Vec: Apprentissage de représentation évolutive pour les réseaux hétérogènes (KDD 2017) [ Exemple ]
  • Toutes les variantes d' autoencodeurs graphiques et les autoencodeurs variationnels de:
    • Auto-codeurs de graphiques variationnels de KIPF et Welling (NIPS-W 2016) [ Exemple ]
    • Autoencoder graphique régularisé adversarialement pour l'intégration de graphiques de Pan et al. (Ijcai 2018) [ Exemple ]
    • Autoencoders graphiques simples et efficaces avec des modèles linéaires à HOP de Salha et al. (ECML 2020) [ Exemple ]
  • Sceau de Zhang et Chen: Prédiction de liaison basée sur les réseaux de neurones graphiques (Neirips 2018) [ Exemple ]
  • Renet de Jin et al. : Réseau d'événements récurrent pour raisonner sur les graphiques de connaissances temporelles (ICLR-W 2019) [ Exemple ]
  • Graphunet de GAO et JI: Graph U-NETS (ICML 2019) [ Exemple ]
  • Attentielfp de Xiong et al. : Repousser les limites de la représentation moléculaire pour la découverte de médicaments avec le mécanisme d'attention du graphique (J. Med. Chem. 2020) [ Exemple ]
  • DeepGCN et le GenConv de Li et al. : DeepGCNS: Les GCN peuvent-ils aller aussi profondément que CNNS? (ICCV 2019) et Deegergcn: Tout ce dont vous avez besoin pour former des GCN plus profonds (Corr 2020) [ Exemple ]
  • Rect de Wang et al. : L'intégration du réseau avec des étiquettes complètement définies (TKDE 2020) [ Exemple ]
  • GNNExplaileur de Ying et al. : GNNEXPLAINER: Génération d'explications pour les réseaux de neurones graphiques (Neirips 2019) [ Exemple1 , exemple2 , exemple3 ]
  • Réseaux de neurones sans graphes de Zhang et al. : Réseaux de neurones sans graphe: Enseignement de l'ancien MLPS Nouvelles astuces via la distillation (Corr 2021) [ Exemple ]
  • Linkx de Lim et al. : Apprentissage à grande échelle sur des graphiques non homophiles: nouvelles références et méthodes simples fortes (NEIRIPS 2021) [ Exemple ]
  • Revgnn de Li et al. : Graphique de formation neuronale avec 1000 couches (ICML 2021) [ Exemple ]
  • Transe de Bordes et al. : Traduire des intérêts pour la modélisation de données multi-relations (NIPS 2013) [ Exemple ]
  • Complexe de Trouillon et al. : Embeddings complexes pour une prédiction de liaison simple (ICML 2016) [ Exemple ]
  • Distmult de Yang et al. : Incorporer les entités et les relations pour l'apprentissage et l'inférence dans les bases de connaissances (ICLR 2015) [ Exemple ]
  • Tourner de Sun et al. : Rotation: Graphique de connaissances intégrée par rotation relationnelle dans un espace complexe (ICLR 2019) [ Exemple ]

Opérateurs et services publics GNN: PYG est livré avec un riche ensemble d'opérateurs de réseau neuronal qui sont couramment utilisés dans de nombreux modèles GNN. Ils suivent une conception extensible: il est facile d'appliquer ces opérateurs et de graphiquement des utilitaires aux couches et modèles GNN existants pour améliorer davantage les performances du modèle.

  • Ground de Rong et al. : Grochedge: Vers des réseaux convolutionnels sur les graphiques profonds sur la classification des nœuds (ICLR 2020)
  • Dropnode , maskfeature et addrandomedge de vous et al. : Apprentissage contrastif graphique avec augmentations (Neirips 2020)
  • GrodPath de Li et al. : Maskgae: La modélisation de graphiques masqués rencontre des autoencoders graphiques (Arxiv 2022)
  • Shufflenode de Veličković et al. : Deep Graph Infomax (ICLR 2019)
  • Graphnorm de Cai et al. : Graphnorm: une approche de principe pour accélérer la formation du réseau neuronal du graphique (ICML 2021)
  • GDC de Klicpera et al. : La diffusion améliore l'apprentissage des graphiques (Neirips 2019) [ Exemple ]
Développez pour voir tous les opérateurs et services publics GNN mis en œuvre ...
  • Graphsizenorm de Dwivedi et al. : Réseaux de neurones du graphique d'analyse comparative (Corr 2020)
  • Pairnorm de Zhao et Akoglu: Pairnorm: Tackling Overshoothing in GNNS (ICLR 2020)
  • SIBILITATIONNEMENT NORM de Yang et al. : Revisiter "sur-lisse" dans les GCN profonds (Corr 2020)
  • Diffgroupnorm de Zhou et al. : Vers des réseaux de neurones plus profonds avec une normalisation de groupe différenciable (Neirips 2020)
  • La décomposition des arbres de Jin et al. : Autoencoder variationnel de l'arbre à jonction pour la génération de graphiques moléculaires (ICML 2018)
  • TGN de Rossi et al. : Réseaux de graphiques temporels pour l'apprentissage en profondeur sur les graphiques dynamiques (GRL + 2020) [ Exemple ]
  • WEISFEILER LEHMAN Opérateur de Weisfeiler et Lehman: une réduction d'un graphique à une forme canonique et une algèbre résultant de cette réduction (Nauchno-Technicheskaya Informatsia 1968) [ Exemple ]
  • Opérateur continu Weisfeiler Lehman de Togninalli et al. : Wasserstein Weisfeiler-Lehman Graph Bernels (Neirips 2019)
  • Propagation de l'étiquette de Zhu et Ghahramani: apprentissage à partir de données étiquetées et non marquées avec propagation d'étiquette (CMU-Cald 2002) [ Exemple ]
  • Profil de diplôme local de CAI et Wang: une ligne de base simple mais efficace pour la classification des graphiques non attribués (Corr 2018)
  • Correctandshooth de Huang et al. : Combiner la propagation des étiquettes et les modèles simples sur les réseaux de neurones graphiques (Corr 2020) [ Exemple ]
  • La régularisation de Gini et Bro de Henderson et al. : Amélioration de l'explication du réseau neuronal du graphique moléculaire avec l'orthonormalisation et la rareté induite (ICML 2021)
  • RootEdEgonets et rootedrwsubgraph de Zhao et al. : Des étoiles aux sous-graphes: élevant tout GNN avec une sensibilisation à la structure locale (ICLR 2022)
  • Propagation de caractéristiques de Rossi et al. : Sur l'efficacité déraisonnable de la propagation des fonctionnalités dans l'apprentissage sur des graphiques avec des fonctionnalités de nœuds manquantes (Corr 2021)

GNNS évolutifs: PYG prend en charge la mise en œuvre de réseaux de neurones graphiques qui peuvent évoluer vers des graphiques à grande échelle. Une telle application est difficile car l'ensemble du graphique, ses fonctionnalités associées et les paramètres GNN ne peuvent pas s'intégrer dans la mémoire GPU. De nombreuses approches d'évolutivité de pointe relèvent ce défi en échantillonnant les quartiers pour la formation de mini-lots, le regroupement de graphiques et le partitionnement, ou en utilisant des modèles GNN simplifiés. Ces approches ont été mises en œuvre dans PYG et peuvent bénéficier des couches, opérateurs et modèles GNN ci-dessus.

  • Voisine de Hamilton et al. : Représentation inductive Learning sur les grands graphiques (NIPS 2017) [ Exemple1 , exemple2 , exemple3 ]
  • ClusterGCN de Chiang et al. : Cluster-GCN: un algorithme efficace pour la formation de réseaux de convolutionne profonde et de gros graphiques (KDD 2019) [ Exemple1 , exemple2 ]
  • Graphsaint de Zeng et al. : Graphsaint: Méthode d'apprentissage inductive basée sur l'échantillonnage des graphiques (ICLR 2020) [ Exemple ]
Développez pour voir tous les GNN évolutifs implémentés ...
  • Shadow de Zeng et al. : Découplage de la profondeur et de la portée des réseaux de neurones graphiques (Neirips 2021) [ Exemple ]
  • Signe de Rossi et al. : Signe: réseaux de neurones de graphe de création évolutifs (Corr 2020) [ Exemple ]
  • Hgtloader de Hu et al. : Transformateur de graphe hétérogène (www 2020) [ Exemple ]

Installation

PYG est disponible pour Python 3.9 à Python 3.12.

Anaconda

Vous pouvez désormais installer PYG via Anaconda pour toutes les principales combinaisons OS / Pytorch / Cuda? Si vous n'avez pas encore installé Pytorch, installez-le via conda comme décrit dans la documentation officielle de Pytorch. Étant donné que vous avez installé Pytorch ( >=1.8.0 ), exécutez simplement 

 conda install pyg -c pyg

PYPI

À partir de PYG 2.3 , vous pouvez installer et utiliser PYG sans aucune bibliothèque externe requise à l'exception de Pytorch. Pour cela, courez simplement 

 pip install torch_geometric

Bibliothèques supplémentaires

Si vous souhaitez utiliser l'ensemble complet de fonctionnalités de PYG, il existe plusieurs bibliothèques supplémentaires que vous souhaiterez peut-être installer:

  • pyg-lib : Opérateurs GNN hétérogènes et routines d'échantillonnage de graphiques
  • torch-scatter : réduction accélérée et efficace clairsemée
  • torch-sparse : SparseTensor Soutien
  • torch-cluster : Routines de regroupement de graphiques
  • torch-spline-conv : SplineConv Support

Ces packages sont livrés avec leurs propres implémentations de noyau CPU et GPU basées sur l'interface d'extension Pytorch C ++ / CUDA / HIP (ROCM). Pour une utilisation de base de PYG, ces dépendances sont entièrement facultatives . Nous vous recommandons de commencer avec une installation minimale et d'installer des dépendances supplémentaires une fois que vous avez commencé à en avoir besoin.

Pour faciliter l'installation de ces extensions, nous fournissons des roues pip pour toutes les principales combinaisons OS / Pytorch / Cuda, voir ici.

Pytorch 2.5

Pour installer les binaires pour Pytorch 2.5.0, exécutez simplement 

 pip install pyg_lib torch_scatter torch_sparse torch_cluster torch_spline_conv -f https://data.pyg.org/whl/torch-2.5.0+${CUDA}.html

où ${CUDA} doit être remplacé par cpu , cu118 , cu121 ou cu124 en fonction de votre installation Pytorch.

cpu cu118 cu121 cu124
Linux ✅ ✅ ✅ ✅
Fenêtre ✅ ✅ ✅ ✅
macos ✅

Pytorch 2.4

Pour installer les binaires pour Pytorch 2.4.0, exécutez simplement 

 pip install pyg_lib torch_scatter torch_sparse torch_cluster torch_spline_conv -f https://data.pyg.org/whl/torch-2.4.0+${CUDA}.html

où ${CUDA} doit être remplacé par cpu , cu118 , cu121 ou cu124 en fonction de votre installation Pytorch.

cpu cu118 cu121 cu124
Linux ✅ ✅ ✅ ✅
Fenêtre ✅ ✅ ✅ ✅
macos ✅

Remarque: Des binaires des versions plus anciennes sont également fournies pour Pytorch 1.4.0, Pytorch 1.5.0, Pytorch 1.6.0, Pytorch 1.7.0 / 1.7.1, Pytorch 1.8.0 / 1.8.1, pytorch 1.9.0, pytorch 1.10.0 / 1.10.1 / 1.10.2, pytorch 1.11.0, pyTTOR 1.12.0 / 1.12.1, Pytorch 1.13.0 / 1.13.1, Pytorch 2.0.0 / 2.0.1, Pytorch 2.1.0 / 2.1.1 / 2.1.2, Pytorch 2.2.0 / 2.2.1 / 2.2.2, et Pytorch 2.3.0 / 2.3.1 (suivant la même procédure). Pour les anciennes versions, vous devrez peut-être explicitement spécifier le dernier numéro de version pris en charge ou installer via pip install --no-index afin d'empêcher une installation manuelle de Source. Vous pouvez rechercher le dernier numéro de version pris en charge ici.

Conteneur nvidia pyg

Nvidia fournit un conteneur Docker PYG pour la formation et le déploiement de GPU GPU accélérés avec PYG, voir ici.

Nightly and Master

Au cas où vous souhaitez expérimenter les dernières fonctionnalités PYG qui ne sont pas encore entièrement publiées, installez la version nocturne de PYG via 

 pip install pyg-nightly

ou installer pyg de maître via 

 pip install git+https://github.com/pyg-team/pytorch_geometric.git

Roues rocm

Le référentiel externe pyg-rocm-build fournit des roues et des instructions détaillées sur la façon d'installer PYG pour ROCM. Si vous avez des questions à ce sujet, veuillez ouvrir un problème ici.

Citer

Veuillez citer notre article (et les articles respectifs des méthodes utilisées) si vous utilisez ce code dans votre propre travail: 

 @inproceedings{Fey/Lenssen/2019,
  title={Fast Graph Representation Learning with {PyTorch Geometric}},
  author={Fey, Matthias and Lenssen, Jan E.},
  booktitle={ICLR Workshop on Representation Learning on Graphs and Manifolds},
  year={2019},
}

N'hésitez pas à nous envoyer un e-mail si vous souhaitez que votre travail soit répertorié dans les ressources externes. Si vous remarquez quelque chose d'inattendu, veuillez ouvrir un problème et le faire savoir. Si vous avez des questions ou si vous manquez une fonctionnalité spécifique, n'hésitez pas à en discuter avec nous. Nous sommes motivés à rendre constamment des PYG encore meilleurs.

Développer
Informations supplémentaires
Applications connexes
Recommandé pour vous
Actualités connexes Tout