Some understandings of heterogeneous graphs in DGL and the usage of heterogeneous graph convolution heterographconv

Heterogeneous graph

Compared with isomorphic graphs , Heterogeneous graphs can have different types of nodes and edges . These different types of nodes and edges have independent properties ID Space and features . For example, in the figure below ,” user ” and ” game ” Node ID from 0 At the beginning , And the two nodes have different characteristics .

Therefore, heterogeneous graph is the most able to express and apply all kinds of expressions of our real world .

You can use DGL Create a heterogeneous diagram as follows ：

There are three entities , Heterogeneous graph of three relationships

import dgl
g = dgl.heterograph({
    
    ('user', 'follows', 'user') : ([0, 1], [1, 2]),
    ('user', 'plays', 'game') : ([0], [1]),
    ('store', 'sells', 'game')  :([0], [2])})
print(g)

Output results ：

Graph(num_nodes={
    'game': 3, 'store': 1, 'user': 3},
      num_edges={
    ('store', 'sells', 'game'): 1, ('user', 'follows', 'user'): 2, ('user', 'plays', 'game'): 1},
      metagraph=[('store', 'game', 'sells'), ('user', 'user', 'follows'), ('user', 'game', 'plays')])

DGL There are many ways to create heterogeneous diagrams in , The above description is created in a way similar to triples
for example (‘store’, ‘sells’, ‘game’), Refer to store Point to game Of sells Relationship ,([0], [2]) Means store_0 To game_2 One way sells Relationship , Therefore, the message can only be transmitted from game_2 to sells to update .

although game_0 Not used in the figure , But he will create by default .

From the above heterogeneous graph output, we can see that there are 7 Nodes ,3 Kind of relationship , In line with expectations .

Here are some operations on heterogeneous graphs

print(g.etypes)  #  Get the type of edge 
print(g.ntypes) #  Gets the type of the node 
print(g.number_of_nodes('user')) #  obtain user Number of nodes 
print(g.metagraph().edges()) #  Get binary 
print(g.nodes('user')) #  see user Node number 
g.nodes['user'].data['HP'] = th.ones(3, 1) #  Set up / obtain "user" Type of node "HP" features 
print(g.nodes['user'].data['HP'][0]) #  obtain "user"0 Type of node "HP" features 
g.edges['sells'].data['money'] = th.zeros(1, 2) #  Set up / obtain "sells" Type of edge "money" features 
print(g.edges['sells'].data['money'][0]) #  obtain "sells" Type edge 0 Of "money" features 
hg = dgl.to_homogeneous(g) #  Transform heterogeneous graphs into isomorphic graphs 
print(hg.ndata[dgl.NTYPE]) #  Original node type 
print(hg.ndata[dgl.NID]) #  The original node of a specific type ID
print(hg.edata[dgl.ETYPE]) #  Original edge type 
print(hg.edata[dgl.EID]) #  The original specific type of edge ID

HeteroGraphConv

The convolution of irregular graphs applies submodules on their association graphs , Read the feature from the source node and write the updated feature to the target node . If multiple relationships have the same target node type , Then their results will be aggregated through the specified method . If the graph has no edges , The corresponding module will not be called .

Because for the convolution of heterogeneous graphs , There are different types of edges , Then each type of edge needs to set its own parameters , Parameters cannot be shared like isomorphic graphs .

initialization

import dgl.nn.pytorch as dglnn
dglnn.HeteroGraphConv(mods, aggregate='sum')

You need to pass in two parameters , first mods It's a dictionary type , The content is { Relationship name ： The model layer , }
The second is the aggregate function , Default sum, Because there may be multiple edges gathering information from a total node , Aggregate information updating node information requires aggregate functions to play a role .

forward

forward(g, inputs, mod_args=None, mod_kwargs=None)

forward There are four parameters that can be entered ,mod_args and mod_kwargs The default can be
g Represents the input graph data
inputs It's also a dictionary type , Represents the characteristics of the input node

Example

Use the above heterogeneous graph to convolute the heterogeneous graph

First, create a heterogeneous diagram ：

import dgl
g = dgl.heterograph({
    
    ('user', 'follows', 'user') : ([0, 1], [1, 2]),
    ('user', 'plays', 'game') : ([0], [1]),
    ('store', 'sells', 'game')  :([0], [2])})
print(g)

Then initialize the heterogeneous map convolution

#  All three relationships are set as input 2 Dimension node feature output 3 Whitman's sign 
import dgl.nn.pytorch as dglnn
conv = dglnn.HeteroGraphConv({
    
    'follows' : dglnn.GraphConv(2, 3),
    'plays' : dglnn.GraphConv(2, 3),
    'sells' : dglnn.GraphConv(2, 3)},
    aggregate='sum')

Then pass in the parameters to get the result ：

import torch as th
h1 = {
    'user' : th.ones((g.number_of_nodes('user'), 2)),
      'game' : th.ones((g.number_of_nodes('game'), 2)),
      'store' : th.ones((g.number_of_nodes('store'), 2))}
print(h1)
h2 = conv(g, h1)
print(h2)
print(h2.keys())

Output results ：

{
    'user': tensor([[1., 1.],
        [1., 1.],
        [1., 1.]]), 'game': tensor([[1., 1.],
        [1., 1.],
        [1., 1.]]), 'store': tensor([[1., 1.]])}
{
    'game': tensor([[ 0.0000,  0.0000,  0.0000],
        [ 0.6098, -1.0385,  0.2647],
        [ 0.1339,  0.6426, -0.6454]], grad_fn=<SumBackward1>), 'user': tensor([[ 0.0000,  0.0000,  0.0000],
        [ 1.0880,  0.2894, -0.8723],
        [ 1.0880,  0.2894, -0.8723]], grad_fn=<SumBackward1>)}
dict_keys(['game', 'user'])

Only game and user Because these two types of nodes involve updating operations ,store Because there is no side pointing at him , There is no need to update, so there is no need to output the new features of the node .

Reference resources

https://docs.dgl.ai/guide_cn/graph-heterogeneous.html#guide-cn-graph-heterogeneous
https://docs.dgl.ai/generated/dgl.nn.pytorch.HeteroGraphConv.html#dgl.nn.pytorch.HeteroGraphConv