IEEE Computational Intelligence Magazine - February 2021 - 101

Thanks to the increasing popularity
of GNNs, many software libraries
implementing the building blocks of
graph representation learning have been
developed in recent years, paving the
way for the adoption of GNNs in other
fields of science. One of the major challenges faced by researchers and software
developers who wish to contribute to
the larger scientific community is to
make software both accessible and intuitive, so that even non-technical audiences can benefit from the advances
carried by intelligent systems. In this
spirit, Keras is an application programming interface (API) for creating neural
-networks, developed according to the
guiding principle that " being able to go
from idea to result with the least possible delay is key to doing good research "
[33]. Keras is designed to reduce the
cognitive load of end users, shifting the
focus away from the boilerplate implementation details and allowing instead
to focus on the creation of models. As
such, Keras is extremely beginnerfriendly and, for many, an entry point to
machine learning itself. At the same
time, Keras integrates smoothly with its
TensorFlow [34] backend and enables
users to build any model that they
could have implemented in pure TensorFlow. This flexibility makes Keras an
excellent tool even for expert deep
learning practitioners and has recently
led to TensorFlow's adoption of Keras as
the official interface to the framework.
In this paper we present Spektral, a
Python library for building graph neural
networks using TensorFlow and the
Keras API. Spektral implements some of
the most important papers from the
GNN literature as Keras layers, and it
integrates seamlessly within Keras models and with the most important features
of Keras like the training loop, callbacks,
distributed training, and automatic support for GPUs and TPUs. As such, Spektral inherits the philosophy of ease of
use and flexibility that characterizes
Keras. The components of Spektral act as
standard TensorFlow operations and can
be easily used even in more advanced
settings, integrating tightly with all the
features of TensorFlow and allowing for

easy deployment to production systems.
For these reasons, Spektral is the ideal
library to implement GNNs in the TensorFlow ecosystem, both for total beginners and experts alike.
All features of Spektral are documented in detail1 and a collection of
examples is provided with the source
code. The project is released on GitHub2
under MIT license.
II. Library Overview
A. Representing Graphs

Let G = {X, E} be a graph where
X = {x i ! R F|i = 1, f, N} is the set of
nodes with F-dimensional real attributes,
and E = {e ij ! R S|x i, x j ! X} the set
of edges with S dimensional real attributes. In Spektral, we represent G by its
binary adjacency matrix A ! {0, 1} N # N ,
node features X ! R N # F , and edge features E ! R N # N # S . Any format accepted
by Keras to represent the above matrices
is also supported by Spektral, which
means that it also natively supports the
NumPy stack of scientific computing
libraries for Python. Most of the layers
and utilities implemented in Spektral also
support the sparse matrices of the SciPy
library, making them computationally
efficient both in time and memory.
B. Data Modes

Spektral makes very few assumptions on
how a user may want to represent
graphs and transparently deals with
batches of graphs represented as higherorder tensors or disjoint unions. The
library supports four different ways of
representing graphs (or batches thereof),
which we refer to as data modes.
In single mode, the data describes a
single graph with its adjacency matrix
and attributes, and inference usually happens at the level of individual nodes. Disjoint mode is a special case of single mode,
where the graph is obtained as the disjoint union of a set of smaller graphs. In
this case the node attributes of the
graphs are stacked in a single matrix and
their adjacency matrices are combined in

a block-diagonal matrix. This is a practical way of representing batches of variable-order graphs, although it requires an
additional data structure to keep track of
the different components. Alternatively,
in batch mode, a set of graphs is represented by stacking their adjacency and attributes matrices in higher-order tensors of
shape B # N # f. This mode is akin to
traditional batch processing in machine
learning and can be more naturally
adopted in deep learning architectures.
However, it requires the graphs in a
batch to have the same number of nodes.
Finally, mixed mode is the one most often
found in traditional machine learning literature and consists of a graph with fixed
support but variable attributes. Common
examples of this mode are found in
computer vision, where images have a
fixed 2-dimensional grid support and
only differ in the pixel values (i.e., the
node attributes), and in traditional graph
signal processing applications.
The utils module exposes some
useful utilities for manipulating the data
and converting between the different
data modes.
C. Message Passing

Message-passing networks are a general
paradigm introduced by Gilmer et al.
[19] that unifies most GNN methods
found in the literature as a combination
of message, aggregation, and update functions. Message-passing layers are equivalent in role to the convolutional operators
in convolutional neural networks, and
are the essential components of graph
representation learning. Message-passing
layers in Spektral are available in the

https://graphneural.network
https://github.com/danielegrattarola/spektral

FIGURE 3 The stylised ghost logo of Spektral.

FEBRUARY 2021 | IEEE COMPUTATIONAL INTELLIGENCE MAGAZINE

101

https://graphneural.network https://github.com/danielegrattarola/spektral

IEEE Computational Intelligence Magazine - February 2021

Table of Contents for the Digital Edition of IEEE Computational Intelligence Magazine - February 2021