Convolutional layers

The following convolutional/message-passing layers are available in Spektral.

Notation:

  • : number of nodes;
  • : size of the node attributes;
  • : size of the edge attributes;
  • : node attributes of the i-th node;
  • : edge attributes of the edge from node i to node j;
  • : adjacency matrix;
  • : node attributes matrix;
  • : edge attributes matrix;
  • : degree matrix;
  • : trainable weights matrices;
  • : trainable bias vector;
  • : one-hop neighbourhood of node ;

[source]

MessagePassing

spektral.layers.MessagePassing(aggregate='sum')

A general class for message passing networks from the paper

Neural Message Passing for Quantum Chemistry
Justin Gilmer et al.

Mode: single, disjoint.

This layer and all of its extensions expect a sparse adjacency matrix.

This layer computes:

where is a differentiable update function, is a differentiable message function, is a permutation-invariant function to aggregate the messages (like the sum or the average), and is the edge attribute of edge i-j.

By extending this class, it is possible to create any message-passing layer in single/disjoint mode.

API

propagate(x, a, e=None, **kwargs)

Propagates the messages and computes embeddings for each node in the graph.
Any kwargs will be forwarded as keyword arguments to message(), aggregate() and update().

message(x, **kwargs)

Computes messages, equivalent to in the definition.
Any extra keyword argument of this function will be populated by propagate() if a matching keyword is found.
Use self.get_i() and self.get_j() to gather the elements using the indices i or j of the adjacency matrix. Equivalently, you can access the indices themselves via the index_i and index_j attributes.

aggregate(messages, **kwargs)

Aggregates the messages, equivalent to in the definition.
The behaviour of this function can also be controlled using the aggregate keyword in the constructor of the layer (supported aggregations: sum, mean, max, min, prod).
Any extra keyword argument of this function will be populated by propagate() if a matching keyword is found.

update(embeddings, **kwargs)

Updates the aggregated messages to obtain the final node embeddings, equivalent to in the definition.
Any extra keyword argument of this function will be populated by propagate() if a matching keyword is found.

Arguments:

  • aggregate: string or callable, an aggregation function. This flag can be used to control the behaviour of aggregate() wihtout re-implementing it. Supported aggregations: 'sum', 'mean', 'max', 'min', 'prod'. If callable, the function must have the signature foo(updates, indices, n_nodes) and return a rank 2 tensor with shape (n_nodes, ...).
  • kwargs: additional keyword arguments specific to Keras' Layers, like regularizers, initializers, constraints, etc.

[source]

AGNNConv

spektral.layers.AGNNConv(trainable=True, aggregate='sum', activation=None)

An Attention-based Graph Neural Network (AGNN) from the paper

Attention-based Graph Neural Network for Semi-supervised Learning
Kiran K. Thekumparampil et al.

Mode: single, disjoint, mixed.

This layer expects a sparse adjacency matrix.

This layer computes: where and is a trainable parameter.

Input

  • Node features of shape (n_nodes, n_node_features);
  • Binary adjacency matrix of shape (n_nodes, n_nodes).

Output

  • Node features with the same shape of the input.

Arguments

  • trainable: boolean, if True, then beta is a trainable parameter. Otherwise, beta is fixed to 1;
  • activation: activation function;

[source]

APPNPConv

spektral.layers.APPNPConv(channels, alpha=0.2, propagations=1, mlp_hidden=None, mlp_activation='relu', dropout_rate=0.0, activation=None, use_bias=True, kernel_initializer='glorot_uniform', bias_initializer='zeros', kernel_regularizer=None, bias_regularizer=None, activity_regularizer=None, kernel_constraint=None, bias_constraint=None)

The APPNP operator from the paper

Predict then Propagate: Graph Neural Networks meet Personalized PageRank
Johannes Klicpera et al.

Mode: single, disjoint, mixed, batch.

This layer computes: where is the teleport probability, is a multi-layer perceptron, and is defined by the propagations argument.

Input

  • Node features of shape ([batch], n_nodes, n_node_features);
  • Modified Laplacian of shape ([batch], n_nodes, n_nodes); can be computed with spektral.utils.convolution.gcn_filter.

Output

  • Node features with the same shape as the input, but with the last dimension changed to channels.

Arguments

  • channels: number of output channels;
  • alpha: teleport probability during propagation;
  • propagations: number of propagation steps;
  • mlp_hidden: list of integers, number of hidden units for each hidden layer in the MLP (if None, the MLP has only the output layer);
  • mlp_activation: activation for the MLP layers;
  • dropout_rate: dropout rate for Laplacian and MLP layers;
  • activation: activation function;
  • use_bias: bool, add a bias vector to the output;
  • kernel_initializer: initializer for the weights;
  • bias_initializer: initializer for the bias vector;
  • kernel_regularizer: regularization applied to the weights;
  • bias_regularizer: regularization applied to the bias vector;
  • activity_regularizer: regularization applied to the output;
  • kernel_constraint: constraint applied to the weights;
  • bias_constraint: constraint applied to the bias vector.

[source]

ARMAConv

spektral.layers.ARMAConv(channels, order=1, iterations=1, share_weights=False, gcn_activation='relu', dropout_rate=0.0, activation=None, use_bias=True, kernel_initializer='glorot_uniform', bias_initializer='zeros', kernel_regularizer=None, bias_regularizer=None, activity_regularizer=None, kernel_constraint=None, bias_constraint=None)

An Auto-Regressive Moving Average convolutional layer (ARMA) from the paper

Graph Neural Networks with convolutional ARMA filters
Filippo Maria Bianchi et al.

Mode: single, disjoint, mixed, batch.

This layer computes: where is the order of the ARMA filter, and where: is a recursive approximation of an ARMA filter, where and

Input

  • Node features of shape ([batch], n_nodes, n_node_features);
  • Normalized and rescaled Laplacian of shape ([batch], n_nodes, n_nodes); can be computed with spektral.utils.convolution.normalized_laplacian and spektral.utils.convolution.rescale_laplacian.

Output

  • Node features with the same shape as the input, but with the last dimension changed to channels.

Arguments

  • channels: number of output channels;
  • order: order of the full ARMA filter, i.e., the number of parallel stacks in the layer;
  • iterations: number of iterations to compute each ARMA approximation;
  • share_weights: share the weights in each ARMA stack.
  • gcn_activation: activation function to compute each ARMA stack;
  • dropout_rate: dropout rate for skip connection;
  • activation: activation function;
  • use_bias: bool, add a bias vector to the output;
  • kernel_initializer: initializer for the weights;
  • bias_initializer: initializer for the bias vector;
  • kernel_regularizer: regularization applied to the weights;
  • bias_regularizer: regularization applied to the bias vector;
  • activity_regularizer: regularization applied to the output;
  • kernel_constraint: constraint applied to the weights;
  • bias_constraint: constraint applied to the bias vector.

[source]

ChebConv

spektral.layers.ChebConv(channels, K=1, activation=None, use_bias=True, kernel_initializer='glorot_uniform', bias_initializer='zeros', kernel_regularizer=None, bias_regularizer=None, activity_regularizer=None, kernel_constraint=None, bias_constraint=None)

A Chebyshev convolutional layer from the paper

Convolutional Neural Networks on Graphs with Fast Localized Spectral Filtering
Michaël Defferrard et al.

Mode: single, disjoint, mixed, batch.

This layer computes: where are Chebyshev polynomials of defined as where

Input

  • Node features of shape ([batch], n_nodes, n_node_features);
  • A list of K Chebyshev polynomials of shape [([batch], n_nodes, n_nodes), ..., ([batch], n_nodes, n_nodes)]; can be computed with spektral.utils.convolution.chebyshev_filter.

Output

  • Node features with the same shape of the input, but with the last dimension changed to channels.

Arguments

  • channels: number of output channels;
  • K: order of the Chebyshev polynomials;
  • activation: activation function;
  • use_bias: bool, add a bias vector to the output;
  • kernel_initializer: initializer for the weights;
  • bias_initializer: initializer for the bias vector;
  • kernel_regularizer: regularization applied to the weights;
  • bias_regularizer: regularization applied to the bias vector;
  • activity_regularizer: regularization applied to the output;
  • kernel_constraint: constraint applied to the weights;
  • bias_constraint: constraint applied to the bias vector.

[source]

CrystalConv

spektral.layers.CrystalConv(channels, aggregate='sum', activation=None, use_bias=True, kernel_initializer='glorot_uniform', bias_initializer='zeros', kernel_regularizer=None, bias_regularizer=None, activity_regularizer=None, kernel_constraint=None, bias_constraint=None)

A crystal graph convolutional layer from the paper

Crystal Graph Convolutional Neural Networks for an Accurate and Interpretable Prediction of Material Properties
Tian Xie and Jeffrey C. Grossman

Mode: single, disjoint, mixed.

This layer expects a sparse adjacency matrix.

This layer computes: where , is a sigmoid activation, and is the activation function (defined by the activation argument).

Input

  • Node features of shape (n_nodes, n_node_features);
  • Binary adjacency matrix of shape (n_nodes, n_nodes).
  • Edge features of shape (num_edges, n_edge_features).

Output

  • Node features with the same shape of the input, but the last dimension changed to channels.

Arguments

  • channels: integer, number of output channels;
  • activation: activation function;
  • use_bias: bool, add a bias vector to the output;
  • kernel_initializer: initializer for the weights;
  • bias_initializer: initializer for the bias vector;
  • kernel_regularizer: regularization applied to the weights;
  • bias_regularizer: regularization applied to the bias vector;
  • activity_regularizer: regularization applied to the output;
  • kernel_constraint: constraint applied to the weights;
  • bias_constraint: constraint applied to the bias vector.

[source]

DiffusionConv

spektral.layers.DiffusionConv(channels, K=6, activation='tanh', kernel_initializer='glorot_uniform', kernel_regularizer=None, kernel_constraint=None)

A diffusion convolution operator from the paper

Diffusion Convolutional Recurrent Neural Network: Data-Driven Traffic Forecasting
Yaguang Li et al.

Mode: single, disjoint, mixed, batch.

This layer expects a dense adjacency matrix.

Given a number of diffusion steps and a row-normalized adjacency matrix , this layer calculates the -th channel as:

Input

  • Node features of shape ([batch], n_nodes, n_node_features);
  • Normalized adjacency or attention coef. matrix of shape ([batch], n_nodes, n_nodes); Use DiffusionConvolution.preprocess to normalize.

Output

  • Node features with the same shape as the input, but with the last dimension changed to channels.

Arguments

  • channels: number of output channels;
  • K: number of diffusion steps.
  • activation: activation function ; ( by default)
  • kernel_initializer: initializer for the weights;
  • kernel_regularizer: regularization applied to the weights;
  • kernel_constraint: constraint applied to the weights;

[source]

ECCConv

spektral.layers.ECCConv(channels, kernel_network=None, root=True, activation=None, use_bias=True, kernel_initializer='glorot_uniform', bias_initializer='zeros', kernel_regularizer=None, bias_regularizer=None, activity_regularizer=None, kernel_constraint=None, bias_constraint=None)

An edge-conditioned convolutional layer (ECC) from the paper

Dynamic Edge-Conditioned Filters in Convolutional Neural Networks on Graphs
Martin Simonovsky and Nikos Komodakis

Mode: single, disjoint, batch, mixed.

In single, disjoint, and mixed mode, this layer expects a sparse adjacency matrix. If a dense adjacency is given as input, it will be automatically cast to sparse, which might be expensive.

This layer computes: where is a multi-layer perceptron that outputs an edge-specific weight as a function of edge attributes.

Input

  • Node features of shape ([batch], n_nodes, n_node_features);
  • Binary adjacency matrices of shape ([batch], n_nodes, n_nodes);
  • Edge features. In single mode, shape (num_edges, n_edge_features); in batch mode, shape (batch, n_nodes, n_nodes, n_edge_features).

Output

  • node features with the same shape of the input, but the last dimension changed to channels.

Arguments

  • channels: integer, number of output channels;
  • kernel_network: a list of integers representing the hidden neurons of the kernel-generating network;
  • 'root': if False, the layer will not consider the root node for computing the message passing (first term in equation above), but only the neighbours.
  • activation: activation function;
  • use_bias: bool, add a bias vector to the output;
  • kernel_initializer: initializer for the weights;
  • bias_initializer: initializer for the bias vector;
  • kernel_regularizer: regularization applied to the weights;
  • bias_regularizer: regularization applied to the bias vector;
  • activity_regularizer: regularization applied to the output;
  • kernel_constraint: constraint applied to the weights;
  • bias_constraint: constraint applied to the bias vector.

[source]

EdgeConv

spektral.layers.EdgeConv(channels, mlp_hidden=None, mlp_activation='relu', aggregate='sum', activation=None, use_bias=True, kernel_initializer='glorot_uniform', bias_initializer='zeros', kernel_regularizer=None, bias_regularizer=None, activity_regularizer=None, kernel_constraint=None, bias_constraint=None)

An edge convolutional layer from the paper

Dynamic Graph CNN for Learning on Point Clouds
Yue Wang et al.

Mode: single, disjoint, mixed.

This layer expects a sparse adjacency matrix.

This layer computes for each node : where is a multi-layer perceptron.

Input

  • Node features of shape (n_nodes, n_node_features);
  • Binary adjacency matrix of shape (n_nodes, n_nodes).

Output

  • Node features with the same shape of the input, but the last dimension changed to channels.

Arguments

  • channels: integer, number of output channels;
  • mlp_hidden: list of integers, number of hidden units for each hidden layer in the MLP (if None, the MLP has only the output layer);
  • mlp_activation: activation for the MLP layers;
  • activation: activation function;
  • use_bias: bool, add a bias vector to the output;
  • kernel_initializer: initializer for the weights;
  • bias_initializer: initializer for the bias vector;
  • kernel_regularizer: regularization applied to the weights;
  • bias_regularizer: regularization applied to the bias vector;
  • activity_regularizer: regularization applied to the output;
  • kernel_constraint: constraint applied to the weights;
  • bias_constraint: constraint applied to the bias vector.

[source]

GATConv

spektral.layers.GATConv(channels, attn_heads=1, concat_heads=True, dropout_rate=0.5, return_attn_coef=False, activation=None, use_bias=True, kernel_initializer='glorot_uniform', bias_initializer='zeros', attn_kernel_initializer='glorot_uniform', kernel_regularizer=None, bias_regularizer=None, attn_kernel_regularizer=None, activity_regularizer=None, kernel_constraint=None, bias_constraint=None, attn_kernel_constraint=None)

A Graph Attention layer (GAT) from the paper

Graph Attention Networks
Petar Veličković et al.

Mode: single, disjoint, mixed, batch.

This layer expects dense inputs when working in batch mode.

This layer computes a convolution similar to layers.GraphConv, but uses the attention mechanism to weight the adjacency matrix instead of using the normalized Laplacian: where where is a trainable attention kernel. Dropout is also applied to before computing . Parallel attention heads are computed in parallel and their results are aggregated by concatenation or average.

Input

  • Node features of shape ([batch], n_nodes, n_node_features);
  • Binary adjacency matrix of shape ([batch], n_nodes, n_nodes);

Output

  • Node features with the same shape as the input, but with the last dimension changed to channels;
  • if return_attn_coef=True, a list with the attention coefficients for each attention head. Each attention coefficient matrix has shape ([batch], n_nodes, n_nodes).

Arguments

  • channels: number of output channels;
  • attn_heads: number of attention heads to use;
  • concat_heads: bool, whether to concatenate the output of the attention heads instead of averaging;
  • dropout_rate: internal dropout rate for attention coefficients;
  • return_attn_coef: if True, return the attention coefficients for the given input (one n_nodes x n_nodes matrix for each head).
  • activation: activation function;
  • use_bias: bool, add a bias vector to the output;
  • kernel_initializer: initializer for the weights;
  • attn_kernel_initializer: initializer for the attention weights;
  • bias_initializer: initializer for the bias vector;
  • kernel_regularizer: regularization applied to the weights;
  • attn_kernel_regularizer: regularization applied to the attention kernels;
  • bias_regularizer: regularization applied to the bias vector;
  • activity_regularizer: regularization applied to the output;
  • kernel_constraint: constraint applied to the weights;
  • attn_kernel_constraint: constraint applied to the attention kernels;
  • bias_constraint: constraint applied to the bias vector.

[source]

GatedGraphConv

spektral.layers.GatedGraphConv(channels, n_layers, activation=None, use_bias=True, kernel_initializer='glorot_uniform', bias_initializer='zeros', kernel_regularizer=None, bias_regularizer=None, activity_regularizer=None, kernel_constraint=None, bias_constraint=None)

A gated graph convolutional layer from the paper

Gated Graph Sequence Neural Networks
Yujia Li et al.

Mode: single, disjoint, mixed.

This layer expects a sparse adjacency matrix.

This layer computes where: where is a gated recurrent unit cell.

Input

  • Node features of shape (n_nodes, n_node_features); note that n_node_features must be smaller or equal than channels.
  • Binary adjacency matrix of shape (n_nodes, n_nodes).

Output

  • Node features with the same shape of the input, but the last dimension changed to channels.

Arguments

  • channels: integer, number of output channels;
  • n_layers: integer, number of iterations with the GRU cell;
  • activation: activation function;
  • use_bias: bool, add a bias vector to the output;
  • kernel_initializer: initializer for the weights;
  • bias_initializer: initializer for the bias vector;
  • kernel_regularizer: regularization applied to the weights;
  • bias_regularizer: regularization applied to the bias vector;
  • activity_regularizer: regularization applied to the output;
  • kernel_constraint: constraint applied to the weights;
  • bias_constraint: constraint applied to the bias vector.

[source]

GCNConv

spektral.layers.GCNConv(channels, activation=None, use_bias=True, kernel_initializer='glorot_uniform', bias_initializer='zeros', kernel_regularizer=None, bias_regularizer=None, activity_regularizer=None, kernel_constraint=None, bias_constraint=None)

A graph convolutional layer (GCN) from the paper

Semi-Supervised Classification with Graph Convolutional Networks
Thomas N. Kipf and Max Welling

Mode: single, disjoint, mixed, batch.

This layer computes: where is the adjacency matrix with added self-loops and is its degree matrix.

Input

  • Node features of shape ([batch], n_nodes, n_node_features);
  • Modified Laplacian of shape ([batch], n_nodes, n_nodes); can be computed with spektral.utils.convolution.gcn_filter.

Output

  • Node features with the same shape as the input, but with the last dimension changed to channels.

Arguments

  • channels: number of output channels;
  • activation: activation function;
  • use_bias: bool, add a bias vector to the output;
  • kernel_initializer: initializer for the weights;
  • bias_initializer: initializer for the bias vector;
  • kernel_regularizer: regularization applied to the weights;
  • bias_regularizer: regularization applied to the bias vector;
  • activity_regularizer: regularization applied to the output;
  • kernel_constraint: constraint applied to the weights;
  • bias_constraint: constraint applied to the bias vector.

[source]

GeneralConv

spektral.layers.GeneralConv(channels=256, batch_norm=True, dropout=0.0, aggregate='sum', activation='prelu', use_bias=True, kernel_initializer='glorot_uniform', bias_initializer='zeros', kernel_regularizer=None, bias_regularizer=None, activity_regularizer=None, kernel_constraint=None, bias_constraint=None)

A general convolutional layer from the paper

Design Space for Graph Neural Networks
Jiaxuan You et al.

Mode: single, disjoint, mixed.

This layer expects a sparse adjacency matrix.

This layer computes:

where is an aggregation function for the messages, is an activation function, applies dropout to the node features, and applies batch normalization to the node features.

This layer supports the PReLU activation via the 'prelu' keyword.

The default parameters of this layer are selected according to the best results obtained in the paper, and should provide a good performance on many node-level and graph-level tasks, without modifications. The defaults are as follows:

  • 256 channels
  • Batch normalization
  • No dropout
  • PReLU activation
  • Sum aggregation

If you are uncertain about which layers to use for your GNN, this is a safe choice. Check out the original paper for more specific configurations.

Input

  • Node features of shape (n_nodes, n_node_features);
  • Binary adjacency matrix of shape (n_nodes, n_nodes).

Output

  • Node features with the same shape of the input, but the last dimension changed to channels.

Arguments

  • channels: integer, number of output channels;
  • batch_norm: bool, whether to use batch normalization;
  • dropout: float, dropout rate;
  • aggregate: string or callable, an aggregation function. Supported aggregations: 'sum', 'mean', 'max', 'min', 'prod'.
  • activation: activation function. This layer also supports the advanced activation PReLU by passing activation='prelu'.
  • use_bias: bool, add a bias vector to the output;
  • kernel_initializer: initializer for the weights;
  • bias_initializer: initializer for the bias vector;
  • kernel_regularizer: regularization applied to the weights;
  • bias_regularizer: regularization applied to the bias vector;
  • activity_regularizer: regularization applied to the output;
  • kernel_constraint: constraint applied to the weights;
  • bias_constraint: constraint applied to the bias vector.

[source]

GCSConv

spektral.layers.GCSConv(channels, activation=None, use_bias=True, kernel_initializer='glorot_uniform', bias_initializer='zeros', kernel_regularizer=None, bias_regularizer=None, activity_regularizer=None, kernel_constraint=None, bias_constraint=None)

A GraphConv layer with a trainable skip connection.

Mode: single, disjoint, mixed, batch.

This layer computes: where does not have self-loops.

Input

  • Node features of shape ([batch], n_nodes, n_node_features);
  • Normalized adjacency matrix of shape ([batch], n_nodes, n_nodes); can be computed with spektral.utils.convolution.normalized_adjacency.

Output

  • Node features with the same shape as the input, but with the last dimension changed to channels.

Arguments

  • channels: number of output channels;
  • activation: activation function;
  • use_bias: bool, add a bias vector to the output;
  • kernel_initializer: initializer for the weights;
  • bias_initializer: initializer for the bias vector;
  • kernel_regularizer: regularization applied to the weights;
  • bias_regularizer: regularization applied to the bias vector;
  • activity_regularizer: regularization applied to the output;
  • kernel_constraint: constraint applied to the weights;
  • bias_constraint: constraint applied to the bias vector.

[source]

GINConv

spektral.layers.GINConv(channels, epsilon=None, mlp_hidden=None, mlp_activation='relu', aggregate='sum', activation=None, use_bias=True, kernel_initializer='glorot_uniform', bias_initializer='zeros', kernel_regularizer=None, bias_regularizer=None, activity_regularizer=None, kernel_constraint=None, bias_constraint=None)

A Graph Isomorphism Network (GIN) from the paper

How Powerful are Graph Neural Networks?
Keyulu Xu et al.

Mode: single, disjoint, mixed.

This layer expects a sparse adjacency matrix.

This layer computes for each node : where is a multi-layer perceptron.

Input

  • Node features of shape (n_nodes, n_node_features);
  • Binary adjacency matrix of shape (n_nodes, n_nodes).

Output

  • Node features with the same shape of the input, but the last dimension changed to channels.

Arguments

  • channels: integer, number of output channels;
  • epsilon: unnamed parameter, see the original paper and the equation above. By setting epsilon=None, the parameter will be learned (default behaviour). If given as a value, the parameter will stay fixed.
  • mlp_hidden: list of integers, number of hidden units for each hidden layer in the MLP (if None, the MLP has only the output layer);
  • mlp_activation: activation for the MLP layers;
  • activation: activation function;
  • use_bias: bool, add a bias vector to the output;
  • kernel_initializer: initializer for the weights;
  • bias_initializer: initializer for the bias vector;
  • kernel_regularizer: regularization applied to the weights;
  • bias_regularizer: regularization applied to the bias vector;
  • activity_regularizer: regularization applied to the output;
  • kernel_constraint: constraint applied to the weights;
  • bias_constraint: constraint applied to the bias vector.

[source]

GraphSageConv

spektral.layers.GraphSageConv(channels, aggregate='mean', activation=None, use_bias=True, kernel_initializer='glorot_uniform', bias_initializer='zeros', kernel_regularizer=None, bias_regularizer=None, activity_regularizer=None, kernel_constraint=None, bias_constraint=None)

A GraphSAGE layer from the paper

Inductive Representation Learning on Large Graphs
William L. Hamilton et al.

Mode: single, disjoint, mixed.

This layer expects a sparse adjacency matrix.

This layer computes: where is a function to aggregate a node's neighbourhood. The supported aggregation methods are: sum, mean, max, min, and product.

Input

  • Node features of shape (n_nodes, n_node_features);
  • Binary adjacency matrix of shape (n_nodes, n_nodes).

Output

  • Node features with the same shape as the input, but with the last dimension changed to channels.

Arguments

  • channels: number of output channels;
  • aggregate_op: str, aggregation method to use ('sum', 'mean', 'max', 'min', 'prod');
  • activation: activation function;
  • use_bias: bool, add a bias vector to the output;
  • kernel_initializer: initializer for the weights;
  • bias_initializer: initializer for the bias vector;
  • kernel_regularizer: regularization applied to the weights;
  • bias_regularizer: regularization applied to the bias vector;
  • activity_regularizer: regularization applied to the output;
  • kernel_constraint: constraint applied to the weights;
  • bias_constraint: constraint applied to the bias vector.

[source]

TAGConv

spektral.layers.TAGConv(channels, K=3, aggregate='sum', activation=None, use_bias=True, kernel_initializer='glorot_uniform', bias_initializer='zeros', kernel_regularizer=None, bias_regularizer=None, activity_regularizer=None, kernel_constraint=None, bias_constraint=None)

A Topology Adaptive Graph Convolutional layer (TAG) from the paper

Topology Adaptive Graph Convolutional Networks
Jian Du et al.

Mode: single, disjoint, mixed.

This layer expects a sparse adjacency matrix.

This layer computes:

Input

  • Node features of shape (n_nodes, n_node_features);
  • Binary adjacency matrix of shape (n_nodes, n_nodes).

Output

  • Node features with the same shape of the input, but the last dimension changed to channels.

Arguments

  • channels: integer, number of output channels;
  • K: the order of the layer (i.e., the layer will consider a K-hop neighbourhood for each node);
  • activation: activation function;
  • use_bias: bool, add a bias vector to the output;
  • kernel_initializer: initializer for the weights;
  • bias_initializer: initializer for the bias vector;
  • kernel_regularizer: regularization applied to the weights;
  • bias_regularizer: regularization applied to the bias vector;
  • activity_regularizer: regularization applied to the output;
  • kernel_constraint: constraint applied to the weights;
  • bias_constraint: constraint applied to the bias vector.