You signed in with another tab or window. Reload to refresh your session.You signed out in another tab or window. Reload to refresh your session.You switched accounts on another tab or window. Reload to refresh your session.Dismiss alert
Paddle Graph Learning (PGL) is an efficient and flexible graph learning framework based on [PaddlePaddle](https://github.com/PaddlePaddle/Paddle).
5
+
Paddle Graph Learning (PGL) is an efficient and flexible graph learning framework based on [PaddlePaddle](https://github.com/PaddlePaddle/Paddle).
6
6
7
7
8
-
<imgsrc="https://github.com/PaddlePaddle/PGL/blob/master/docs/source/_static/framework_of_pgl.png"alt="The Framework of Paddle Graph Learning (PGL)"width="800">
8
+
<imgsrc="./docs/source/_static/framework_of_pgl.png"alt="The Framework of Paddle Graph Learning (PGL)"width="800">
9
9
10
10
11
-
We provide python interfaces for storing/reading/querying graph structured data and two fundamental computational interfaces, which are walk based paradigm and message-passing based paradigm as shown in the above framework of PGL, for building cutting-edge graph learning algorithms. Combined with the PaddlePaddle deep learning framework, we are able to support both graph representation learning models and graph neural networks, and thus our framework has a wide range of graph-based applications.
11
+
The newly released PGL supports heterogeneous graph learning on both walk based paradigm and message-passing based paradigm by providing MetaPath sampling and Message Passing mechanism on heterogeneous graph. Furthermor, The newly released PGL also support distributed graph storage and some distributed training algorithms, such as distributed deep walk and distributed graphsage. Combined with the PaddlePaddle deep learning framework, we are able to support both graph representation learning models and graph neural networks, and thus our framework has a wide range of graph-based applications.
12
12
13
13
14
-
## Highlight: Efficient and Flexible Message Passing Paradigm
14
+
## Highlight: Efficiency - Support Scatter-Gather and LodTensor Message Passing
15
15
16
16
One of the most important benefits of graph neural networks compared to other models is the ability to use node-to-node connectivity information, but coding the communication between nodes is very cumbersome. At PGL we adopt **Message Passing Paradigm** similar to [DGL](https://github.com/dmlc/dgl) to help to build a customize graph neural network easily. Users only need to write ```send``` and ```recv``` functions to easily implement a simple GCN. As shown in the following figure, for the first step the send function is defined on the edges of the graph, and the user can customize the send function  to send the message from the source to the target node. For the second step, the recv function  is responsible for aggregating  messages together from different sources.
17
17
18
18
19
19
20
-
<imgsrc="https://github.com/PaddlePaddle/PGL/blob/master/docs/source/_static/message_passing_paradigm.png"alt="The basic idea of message passing paradigm"width="800">
20
+
<imgsrc="./docs/source/_static/message_passing_paradigm.png"alt="The basic idea of message passing paradigm"width="800">
21
21
22
-
As shown in the left of the following figure, to adapt general user-defined message aggregate functions, DGL uses the degree bucketing method to combine nodes with the same degree into a batch and then apply an aggregate function  on each batch serially. For our PGL UDF aggregate function, we organize the message as a [LodTensor](http://www.paddlepaddle.org/documentation/docs/en/1.4/user_guides/howto/basic_concept/lod_tensor_en.html) in [PaddlePaddle](https://github.com/PaddlePaddle/Paddle) taking the message as variable length sequences. And we **utilize the features of LodTensor in Paddle to obtain fast parallel aggregation**.
22
+
As shown in the left of the following figure, to adapt general user-defined message aggregate functions, DGL uses the degree bucketing method to combine nodes with the same degree into a batch and then apply an aggregate function  on each batch serially. For our PGL UDF aggregate function, we organize the message as a [LodTensor](http://www.paddlepaddle.org/documentation/docs/en/1.4/user_guides/howto/basic_concept/lod_tensor_en.html) in [PaddlePaddle](https://github.com/PaddlePaddle/Paddle) taking the message as variable length sequences. And we **utilize the features of LodTensor in Paddle to obtain fast parallel aggregation**.
23
23
24
24
25
-
<imgsrc="https://github.com/PaddlePaddle/PGL/blob/master/docs/source/_static/parallel_degree_bucketing.png"alt="The parallel degree bucketing of PGL"width="800">
25
+
<imgsrc="./docs/source/_static/parallel_degree_bucketing.png"alt="The parallel degree bucketing of PGL"width="800">
26
26
27
27
28
28
Users only need to call the ```sequence_ops``` functions provided by Paddle to easily implement efficient message aggregation. For examples, using ```sequence_pool``` to sum the neighbor message.
@@ -33,14 +33,14 @@ Users only need to call the ```sequence_ops``` functions provided by Paddle to e
33
33
```
34
34
35
35
36
-
Although DGL does some kernel fusion optimization for general sum, max and other aggregate functions with scatter-gather. For **complex user-defined functions** with degree bucketing algorithm, the serial execution for each degree bucket cannot take full advantage of the performance improvement provided by GPU. However, operations on the PGL LodTensor-based message is performed in parallel, which can fully utilize GPU parallel optimization. Even without scatter-gather optimization, PGL still has excellent performance. Of course, we still provide build-in scatter-optimized message aggregation functions.
36
+
Although DGL does some kernel fusion optimization for general sum, max and other aggregate functions with scatter-gather. For **complex user-defined functions** with degree bucketing algorithm, the serial execution for each degree bucket cannot take full advantage of the performance improvement provided by GPU. However, operations on the PGL LodTensor-based message is performed in parallel, which can fully utilize GPU parallel optimization. In our experiments, PGL can reach up to 13 times the speed of DGL with complex user-defined functions. Even without scatter-gather optimization, PGL still has excellent performance. Of course, we still provide build-in scatter-optimized message aggregation functions.
37
37
38
-
## Performance
38
+
###Performance
39
39
40
40
41
-
We test all the GNN algorithms with Tesla V100-SXM2-16G running for 200 epochs to get average speeds. And we report the accuracy on test dataset without early stoppping.
41
+
We test all the following GNN algorithms with Tesla V100-SXM2-16G running for 200 epochs to get average speeds. And we report the accuracy on test dataset without early stoppping.
@@ -49,12 +49,64 @@ We test all the GNN algorithms with Tesla V100-SXM2-16G running for 200 epochs t
49
49
| Citeseer | GCN |70.2%|**0.0045**|0.0046s|
50
50
| Citeseer | GAT |68.8%|**0.0124s**|0.0139s|
51
51
52
+
53
+
If we use complex user-defined aggregation like [GraphSAGE-LSTM](https://cs.stanford.edu/people/jure/pubs/graphsage-nips17.pdf) that aggregates neighbor features with LSTM ignoring the order of recieved messages, the optimized message-passing in DGL will be forced to degenerate into degree bucketing scheme. The speed performance will be much slower than the one implemented in PGL. Performances may be various with different scale of the graph, in our experiments, PGL can reach up to 13 times the speed of DGL.
## Highlight: Flexibility - Natively Support Heterogeneous Graph Learning
62
+
63
+
Graph can conveniently represent the relation between things in the real world, but the categories of things and the relation between things are various. Therefore, in the heterogeneous graph, we need to distinguish the node types and edge types in the graph network. PGL models heterogeneous graphs that contain multiple node types and multiple edge types, and can describe complex connections between different types.
64
+
65
+
### Support meta path walk sampling on heterogeneous graph
66
+
67
+
<imgsrc="./docs/source/_static/metapath_sampling.png"alt="The metapath sampling in heterogeneous graph"width="800">
68
+
The left side of the figure above describes a shopping social network. The nodes above have two categories of users and goods, and the relations between users and users, users and goods, and goods and goods. The right of the above figure is a simple sampling process of MetaPath. When you input any MetaPath as UPU (user-product-user), you will find the following results
Then on this basis, and introducing word2vec and other methods to support learning metapath2vec and other algorithms of heterogeneous graph representation.
71
+
72
+
### Support Message Passing mechanism on heterogeneous graph
73
+
74
+
<imgsrc="./docs/source/_static/him_message_passing.png"alt="The message passing mechanism on heterogeneous graph"width="800">
75
+
Because of the different node types on the heterogeneous graph, the message delivery is also different. As shown on the left, it has five neighbors, belonging to two different node types. As shown on the right of the figure above, nodes belonging to different types need to be aggregated separately during message delivery, and then merged into the final message to update the target node. On this basis, PGL supports heterogeneous graph algorithms based on message passing, such as GATNE and other algorithms.
76
+
77
+
78
+
## Large-Scale: Support distributed graph storage and distributed training algorithms
79
+
In most cases of large-scale graph learning, we need distributed graph storage and distributed training support. As shown in the following figure, PGL provided a general solution of large-scale training, we adopted [PaddleFleet](https://github.com/PaddlePaddle/Fleet) as our distributed parameter servers, which supports large scale distributed embeddings and a lightweighted distributed storage engine so it can easily set up a large scale distributed training algorithm with MPI clusters.
80
+
81
+
<imgsrc="./docs/source/_static/distributed_frame.png"alt="The distributed frame of PGL"width="800">
82
+
83
+
84
+
## Model Zoo
85
+
The following are 13 graph learning models that have been implemented in the framework. See the details [here](https://pgl.readthedocs.io/en/latest/introduction.html#highlight-tons-of-models)
86
+
87
+
|Model | feature |
88
+
|---|---|
89
+
| GCN | Graph Convolutional Neural Networks |
90
+
| GAT | Graph Attention Network |
91
+
| GraphSage |Large-scale graph convolution network based on neighborhood sampling|
92
+
| unSup-GraphSage | Unsupervised GraphSAGE |
93
+
| LINE | Representation learning based on first-order and second-order neighbors |
94
+
| DeepWalk | Representation learning by DFS random walk |
95
+
| MetaPath2Vec | Representation learning based on metapath |
96
+
| Node2Vec | The representation learning Combined with DFS and BFS |
97
+
| Struct2Vec | Representation learning based on structural similarity |
| GES | The graph represents learning method with node features |
100
+
| DGI | Unsupervised representation learning based on graph convolution network |
101
+
| GATNE | Representation Learning of Heterogeneous Graph based on MessagePassing |
102
+
103
+
The above models consists of three parts, namely, graph representation learning, graph neural network and heterogeneous graph learning, which are also divided into graph representation learning and graph neural network.
0 commit comments