Working with Heterogeneous Graphs

Author: Quan Gan, Minjie Wang, Mufei Li, George Karypis, Zheng Zhang

In this tutorial, you learn about:

  • Examples of heterogenous graph data and typical applications.

  • Creating and manipulating a heterogenous graph in DGL.

  • Implementing Relational-GCN, a popular GNN model, for heterogenous graph input.

  • Training a model to solve a node classification task.

Heterogeneous graphs, or heterographs for short, are graphs that contain different types of nodes and edges. The different types of nodes and edges tend to have different types of attributes that are designed to capture the characteristics of each node and edge type. Within the context of graph neural networks, depending on their complexity, certain node and edge types might need to be modeled with representations that have a different number of dimensions.

DGL supports graph neural network computations on such heterogeneous graphs, by using the heterograph class and its associated API.

Examples of heterographs

Many graph datasets represent relationships among various types of entities. This section provides an overview for several graph use-cases that show such relationships and can have their data represented as heterographs.

Citation graph

The Association for Computing Machinery publishes an ACM dataset that contains two million papers, their authors, publication venues, and the other papers that were cited. This information can be represented as a heterogeneous graph.

The following diagram shows several entities in the ACM dataset and the relationships among them (taken from Shi et al., 2015).

This graph has three types of entities that correspond to papers, authors, and publication venues. It also contains three types of edges that connect the following:

  • Authors with papers corresponding to written-by relationships

  • Papers with publication venues corresponding to published-in relationships

  • Papers with other papers corresponding to cited-by relationships

Recommender systems

The datasets used in recommender systems often contain interactions between users and items. For example, the data could include the ratings that users have provided to movies. Such interactions can be modeled as heterographs.

The nodes in these heterographs will have two types, users and movies. The edges will correspond to the user-movie interactions. Furthermore, if an interaction is marked with a rating, then each rating value could correspond to a different edge type. The following diagram shows an example of user-item interactions as a heterograph.

Knowledge graph

Knowledge graphs are inherently heterogenous. For example, in Wikidata, Barack Obama (item Q76) is an instance of a human, which could be viewed as the entity class, whose spouse (item P26) is Michelle Obama (item Q13133) and occupation (item P106) is politician (item Q82955). The relationships are shown in the following. diagram.

Creating a heterograph in DGL

You can create a heterograph in DGL using the dgl.heterograph() API. The argument to dgl.heterograph() is a dictionary. The keys are tuples in the form of (srctype, edgetype, dsttype) specifying the relation name and the two entity types it connects. Such tuples are called canonical edge types The values are data to initialize the graph structures, that is, which nodes the edges actually connect.

For instance, the following code creates the user-item interactions heterograph shown earlier.

# Each value of the dictionary is a pair of source and destination arrays.
# Nodes are integer IDs starting from zero. Nodes IDs of different types have
# separate countings.
import dgl
import numpy as np

ratings = dgl.heterograph(
    {('user', '+1', 'movie') : (np.array([0, 0, 1]), np.array([0, 1, 0])),
     ('user', '-1', 'movie') : (np.array([2]), np.array([1]))})

Manipulating heterograph

You can create a more realistic heterograph using the ACM dataset. To do this, first download the dataset as follows:

import urllib.request

data_url = ''
data_file_path = '/tmp/ACM.mat'

urllib.request.urlretrieve(data_url, data_file_path)
data =


['__header__', '__version__', '__globals__', 'TvsP', 'PvsA', 'PvsV', 'AvsF', 'VvsC', 'PvsL', 'PvsC', 'A', 'C', 'F', 'L', 'P', 'T', 'V', 'PvsT', 'CNormPvsA', 'RNormPvsA', 'CNormPvsC', 'RNormPvsC', 'CNormPvsT', 'RNormPvsT', 'CNormPvsV', 'RNormPvsV', 'CNormVvsC', 'RNormVvsC', 'CNormAvsF', 'RNormAvsF', 'CNormPvsL', 'RNormPvsL', 'stopwords', 'nPvsT', 'nT', 'CNormnPvsT', 'RNormnPvsT', 'nnPvsT', 'nnT', 'CNormnnPvsT', 'RNormnnPvsT', 'PvsP', 'CNormPvsP', 'RNormPvsP']

The dataset stores node information by their types: P for paper, A for author, C for conference, L for subject code, and so on. The relationships are stored as SciPy sparse matrix under key XvsY, where X and Y could be any of the node type code.

The following code prints out some statistics about the paper-author relationships.

print('#Papers:', data['PvsA'].shape[0])
print('#Authors:', data['PvsA'].shape[1])
print('#Links:', data['PvsA'].nnz)


<class ''>
#Papers: 12499
#Authors: 17431
#Links: 37055

Converting this SciPy matrix to a heterograph in DGL is straightforward.

pa_g = dgl.heterograph({('paper', 'written-by', 'author') : data['PvsA'].nonzero()})

You can easily print out the type names and other structural information.

print('Node types:', pa_g.ntypes)
print('Edge types:', pa_g.etypes)
print('Canonical edge types:', pa_g.canonical_etypes)

# Nodes and edges are assigned integer IDs starting from zero and each type has its own counting.
# To distinguish the nodes and edges of different types, specify the type name as the argument.
# Canonical edge type name can be shortened to only one edge type name if it is
# uniquely distinguishable.
print(pa_g.number_of_edges(('paper', 'written-by', 'author')))
print(pa_g.successors(1, etype='written-by'))  # get the authors that write paper #1

# Type name argument could be omitted whenever the behavior is unambiguous.
print(pa_g.number_of_edges())  # Only one edge type, the edge type argument could be omitted


Node types: ['author', 'paper']
Edge types: ['written-by']
Canonical edge types: [('paper', 'written-by', 'author')]
tensor([3532, 6421, 8516, 8560])

A homogeneous graph is just a special case of a heterograph with only one type of node and edge.

# Paper-citing-paper graph is a homogeneous graph
pp_g = dgl.heterograph({('paper', 'citing', 'paper') : data['PvsP'].nonzero()})
# equivalent (shorter) API for creating homogeneous graph
pp_g = dgl.from_scipy(data['PvsP'])

# All the ntype and etype arguments could be omitted because the behavior is unambiguous.


tensor([1361, 2624, 8670, 9845])

Create a subset of the ACM graph using the paper-author, paper-paper, and paper-subject relationships. Meanwhile, also add the reverse relationship to prepare for the later sections.

G = dgl.heterograph({
        ('paper', 'written-by', 'author') : data['PvsA'].nonzero(),
        ('author', 'writing', 'paper') : data['PvsA'].transpose().nonzero(),
        ('paper', 'citing', 'paper') : data['PvsP'].nonzero(),
        ('paper', 'cited', 'paper') : data['PvsP'].transpose().nonzero(),
        ('paper', 'is-about', 'subject') : data['PvsL'].nonzero(),
        ('subject', 'has', 'paper') : data['PvsL'].transpose().nonzero(),



Graph(num_nodes={'author': 17431, 'paper': 12499, 'subject': 73},
      num_edges={('author', 'writing', 'paper'): 37055, ('paper', 'cited', 'paper'): 30789, ('paper', 'citing', 'paper'): 30789, ('paper', 'is-about', 'subject'): 12499, ('paper', 'written-by', 'author'): 37055, ('subject', 'has', 'paper'): 12499},
      metagraph=[('author', 'paper', 'writing'), ('paper', 'paper', 'cited'), ('paper', 'paper', 'citing'), ('paper', 'subject', 'is-about'), ('paper', 'author', 'written-by'), ('subject', 'paper', 'has')])

Metagraph (or network schema) is a useful summary of a heterograph. Serving as a template for a heterograph, it tells how many types of objects exist in the network and where the possible links exist.

DGL provides easy access to the metagraph, which could be visualized using external tools.

# Draw the metagraph using graphviz.
import pygraphviz as pgv
def plot_graph(nxg):
    ag = pgv.AGraph(strict=False, directed=True)
    for u, v, k in nxg.edges(keys=True):
        ag.add_edge(u, v, label=k)


Learning tasks associated with heterographs

Some of the typical learning tasks that involve heterographs include:

  • Node classification and regression to predict the class of each node or estimate a value associated with it.

  • Link prediction to predict if there is an edge of a certain type between a pair of nodes, or predict which other nodes a particular node is connected with (and optionally the edge types of such connections).

  • Graph classification/regression to assign an entire heterograph into one of the target classes or to estimate a numerical value associated with it.

In this tutorial, we designed a simple example for the first task.

A semi-supervised node classification example

Our goal is to predict the publishing conference of a paper using the ACM academic graph we just created. To further simplify the task, we only focus on papers published in three conferences: KDD, ICML, and VLDB. All the other papers are not labeled, making it a semi-supervised setting.

The following code extracts those papers from the raw dataset and prepares the training, validation, testing split.

import numpy as np
import torch
import torch.nn as nn
import torch.nn.functional as F

pvc = data['PvsC'].tocsr()
# find all papers published in KDD, ICML, VLDB
c_selected = [0, 11, 13]  # KDD, ICML, VLDB
p_selected = pvc[:, c_selected].tocoo()
# generate labels
labels = pvc.indices
labels[labels == 11] = 1
labels[labels == 13] = 2
labels = torch.tensor(labels).long()

# generate train/val/test split
pid = p_selected.row
shuffle = np.random.permutation(pid)
train_idx = torch.tensor(shuffle[0:800]).long()
val_idx = torch.tensor(shuffle[800:900]).long()
test_idx = torch.tensor(shuffle[900:]).long()

Relational-GCN on heterograph

We use Relational-GCN to learn the representation of nodes in the graph. Its message-passing equation is as follows:

\[h_i^{(l+1)} = \sigma\left(\sum_{r\in \mathcal{R}} \sum_{j\in\mathcal{N}_r(i)}W_r^{(l)}h_j^{(l)}\right)\]

Breaking down the equation, you see that there are two parts in the computation.

  1. Message computation and aggregation within each relation \(r\)

  2. Reduction that merges the results from multiple relationships

Following this intuition, perform message passing on a heterograph in two steps.

  1. Per-edge-type message passing

  2. Type wise reduction

import dgl.function as fn

class HeteroRGCNLayer(nn.Module):
    def __init__(self, in_size, out_size, etypes):
        super(HeteroRGCNLayer, self).__init__()
        # W_r for each relation
        self.weight = nn.ModuleDict({
                name : nn.Linear(in_size, out_size) for name in etypes

    def forward(self, G, feat_dict):
        # The input is a dictionary of node features for each type
        funcs = {}
        for srctype, etype, dsttype in G.canonical_etypes:
            # Compute W_r * h
            Wh = self.weight[etype](feat_dict[srctype])
            # Save it in graph for message passing
            G.nodes[srctype].data['Wh_%s' % etype] = Wh
            # Specify per-relation message passing functions: (message_func, reduce_func).
            # Note that the results are saved to the same destination feature 'h', which
            # hints the type wise reducer for aggregation.
            funcs[etype] = (fn.copy_u('Wh_%s' % etype, 'm'), fn.mean('m', 'h'))
        # Trigger message passing of multiple types.
        # The first argument is the message passing functions for each relation.
        # The second one is the type wise reducer, could be "sum", "max",
        # "min", "mean", "stack"
        G.multi_update_all(funcs, 'sum')
        # return the updated node feature dictionary
        return {ntype : G.nodes[ntype].data['h'] for ntype in G.ntypes}

Create a simple GNN by stacking two HeteroRGCNLayer. Since the nodes do not have input features, make their embeddings trainable.

class HeteroRGCN(nn.Module):
    def __init__(self, G, in_size, hidden_size, out_size):
        super(HeteroRGCN, self).__init__()
        # Use trainable node embeddings as featureless inputs.
        embed_dict = {ntype : nn.Parameter(torch.Tensor(G.number_of_nodes(ntype), in_size))
                      for ntype in G.ntypes}
        for key, embed in embed_dict.items():
        self.embed = nn.ParameterDict(embed_dict)
        # create layers
        self.layer1 = HeteroRGCNLayer(in_size, hidden_size, G.etypes)
        self.layer2 = HeteroRGCNLayer(hidden_size, out_size, G.etypes)

    def forward(self, G):
        h_dict = self.layer1(G, self.embed)
        h_dict = {k : F.leaky_relu(h) for k, h in h_dict.items()}
        h_dict = self.layer2(G, h_dict)
        # get paper logits
        return h_dict['paper']

Train and evaluate

Train and evaluate this network.

# Create the model. The output has three logits for three classes.
model = HeteroRGCN(G, 10, 10, 3)

opt = torch.optim.Adam(model.parameters(), lr=0.01, weight_decay=5e-4)

best_val_acc = 0
best_test_acc = 0

for epoch in range(100):
    logits = model(G)
    # The loss is computed only for labeled nodes.
    loss = F.cross_entropy(logits[train_idx], labels[train_idx])

    pred = logits.argmax(1)
    train_acc = (pred[train_idx] == labels[train_idx]).float().mean()
    val_acc = (pred[val_idx] == labels[val_idx]).float().mean()
    test_acc = (pred[test_idx] == labels[test_idx]).float().mean()

    if best_val_acc < val_acc:
        best_val_acc = val_acc
        best_test_acc = test_acc


    if epoch % 5 == 0:
        print('Loss %.4f, Train Acc %.4f, Val Acc %.4f (Best %.4f), Test Acc %.4f (Best %.4f)' % (


Loss 1.0355, Train Acc 0.4725, Val Acc 0.5100 (Best 0.5100), Test Acc 0.4690 (Best 0.4690)
Loss 0.9336, Train Acc 0.5150, Val Acc 0.5500 (Best 0.5500), Test Acc 0.5059 (Best 0.5017)
Loss 0.7770, Train Acc 0.6525, Val Acc 0.6000 (Best 0.6000), Test Acc 0.5503 (Best 0.5503)
Loss 0.5482, Train Acc 0.8200, Val Acc 0.6500 (Best 0.6600), Test Acc 0.6742 (Best 0.6575)
Loss 0.3502, Train Acc 0.9200, Val Acc 0.7200 (Best 0.7200), Test Acc 0.7521 (Best 0.7387)
Loss 0.2183, Train Acc 0.9638, Val Acc 0.7100 (Best 0.7200), Test Acc 0.7688 (Best 0.7387)
Loss 0.1360, Train Acc 0.9962, Val Acc 0.7200 (Best 0.7200), Test Acc 0.7806 (Best 0.7387)
Loss 0.0867, Train Acc 0.9987, Val Acc 0.7800 (Best 0.7800), Test Acc 0.8007 (Best 0.8007)
Loss 0.0597, Train Acc 1.0000, Val Acc 0.8100 (Best 0.8100), Test Acc 0.8065 (Best 0.8065)
Loss 0.0446, Train Acc 1.0000, Val Acc 0.8300 (Best 0.8300), Test Acc 0.8132 (Best 0.8149)
Loss 0.0356, Train Acc 1.0000, Val Acc 0.8300 (Best 0.8400), Test Acc 0.8074 (Best 0.8141)
Loss 0.0297, Train Acc 1.0000, Val Acc 0.8100 (Best 0.8400), Test Acc 0.8049 (Best 0.8141)
Loss 0.0255, Train Acc 1.0000, Val Acc 0.8100 (Best 0.8400), Test Acc 0.8023 (Best 0.8141)
Loss 0.0227, Train Acc 1.0000, Val Acc 0.8000 (Best 0.8400), Test Acc 0.8032 (Best 0.8141)
Loss 0.0205, Train Acc 1.0000, Val Acc 0.7900 (Best 0.8400), Test Acc 0.7998 (Best 0.8141)
Loss 0.0185, Train Acc 1.0000, Val Acc 0.7800 (Best 0.8400), Test Acc 0.8007 (Best 0.8141)
Loss 0.0169, Train Acc 1.0000, Val Acc 0.7700 (Best 0.8400), Test Acc 0.7998 (Best 0.8141)
Loss 0.0158, Train Acc 1.0000, Val Acc 0.7700 (Best 0.8400), Test Acc 0.7973 (Best 0.8141)
Loss 0.0148, Train Acc 1.0000, Val Acc 0.7600 (Best 0.8400), Test Acc 0.7915 (Best 0.8141)
Loss 0.0141, Train Acc 1.0000, Val Acc 0.7500 (Best 0.8400), Test Acc 0.7906 (Best 0.8141)

What’s next?

  • Check out our full implementation in PyTorch here.

  • We also provide the following model examples:

    • Graph Convolutional Matrix Completion <>_, which we implement in MXNet here.

    • Heterogeneous Graph Attention Network requires transforming a heterograph into a homogeneous graph according to a given metapath (i.e. a path template consisting of edge types). We provide dgl.transform.metapath_reachable_graph() to do this. See full implementation here.

    • Metapath2vec requires generating random walk paths according to a given metapath. Please refer to the full metapath2vec implementation here.

  • Full heterograph API reference.

Total running time of the script: ( 0 minutes 5.066 seconds)

Gallery generated by Sphinx-Gallery