Title: DFA-GNN: Forward Learning of Graph Neural Networks by Direct Feedback Alignment
Venue: NeurIPS 2024
Accepted: yes
Keywords: Graph neural network

direct feedback alignment

graph learning

non-BP training approach
Abstract: Graph neural networks (GNNs) are recognized for their strong performance across various applications, with the backpropagation (BP) algorithm playing a central role in the development of most GNN models. However, despite its effectiveness, BP has limitations that challenge its biological plausibility and affect the efficiency, scalability and parallelism of training neural networks for graph-based tasks. While several non-backpropagation (non-BP) training algorithms, such as the direct feedback alignment (DFA), have been successfully applied to fully-connected and convolutional network components for handling Euclidean data, directly adapting these non-BP frameworks to manage non-Euclidean graph data in GNN models presents significant challenges. These challenges primarily arise from the violation of the independent and identically distributed (i.i.d.) assumption in graph data and the difficulty in accessing prediction errors for all samples (nodes) within the graph. To overcome these obstacles, in this paper we propose DFA-GNN, a novel forward learning framework tailored for GNNs with a case study of semi-supervised learning. The proposed method breaks the limitations of BP by using a dedicated forward training mechanism. Specifically, DFA-GNN extends the principles of DFA to adapt to graph data and unique architecture of GNNs, which incorporates the information of graph topology into the feedback links to accommodate the non-Euclidean characteristics of graph data. Additionally, for semi-supervised graph learning tasks, we developed a pseudo error generator that spreads residual errors from training data to create a pseudo error for each unlabeled node. These pseudo errors are then utilized to train GNNs using DFA. Extensive experiments on 10 public benchmarks reveal that our learning framework outperforms not only previous non-BP methods but also the standard BP methods, and it exhibits excellent robustness against various types of noise and attacks.

DFA-GNN: Forward Learning of Graph Neural Networks by Direct Feedback Alignment

Abstract

Graph neural networks (GNNs) are recognized for their strong performance across various applications, with the backpropagation (BP) algorithm playing a central role in the development of most GNN models. However, despite its effectiveness, BP has limitations that challenge its biological plausibility and affect the efficiency, scalability and parallelism of training neural networks for graph-based tasks. While several non-backpropagation (non-BP) training algorithms, such as the direct feedback alignment (DFA), have been successfully applied to fully-connected and convolutional network components for handling Euclidean data, directly adapting these non-BP frameworks to manage non-Euclidean graph data in GNN models presents significant challenges. These challenges primarily arise from the violation of the independent and identically distributed ( i.i.d. ) assumption in graph data and the difficulty in accessing prediction errors for all samples (nodes) within the graph. To overcome these obstacles, in this paper we propose DFA-GNN , a novel forward learning framework tailored for GNNs with a case study of semi-supervised learning. The proposed method breaks the limitations of BP by using a dedicated forward training mechanism. Specifically, DFA-GNN extends the principles of DFA to adapt to graph data and unique architecture of GNNs, which incorporates the information of graph topology into the feedback links to accommodate the non-Euclidean characteristics of graph data. Additionally, for semi-supervised graph learning tasks, we developed a pseudo error generator that spreads residual errors from training data to create a pseudo error for each unlabeled node. These pseudo errors are then utilized to train GNNs using DFA. Extensive experiments on 10 public benchmarks reveal that our learning framework outperforms not only previous non-BP methods but also the standard BP methods, and it exhibits excellent robustness against various types of noise and attacks.

1 Introduction

As a class of neural networks (NNs) specifically designed to process and learn from graph data, graph neural networks (GNNs) [Zhou et al., 2020, Wu et al., 2020] have gained significant popularity in addressing graph analytical challenges. They have demonstrated outstanding success in various applications, including recommendation systems [Wu et al., 2022], drug discovery [Xiong et al., 2021] and question answering [Yasunaga et al., 2021]. The impressive accomplishments of GNNs, as well as other neural network models, are largely attributed to the backpropagation (BP) algorithm [HechtNielsen, 1992], which has emerged as the standard technique for training deep neural networks.

Loss

G

X

GNN layer 1

GNN layer 2

G pos

X pos

G neg

X neg

GNN layer 1

GNN layer 2

Goodness

Goodness

Goodness

Goodness

GNN layer 1

X

GLYPH(cmap:d835)

GNN layer 2

Local loss

Local loss

X

GNN layer 1

GNN layer 2

Loss

（

a

）

BP

（

b

）

FF

（

c

）

FORWARGNN-SF

（

d

）

DFA-GNN

Forward pass

Backpropagation of errors

Layer-wise training

G: Graph structure

X: Node features

G pos , G neg : Graph structure by positive/negative extending

X pos , X neg : Node feaatures by positive/negative extending

G

GLYPH(cmap:d835)

: Augmented graph structure

The backpropagation algorithm adjusts neural network weights based on the loss between the prediction and the ground truth, and allows the network to learn and improve over time. However, despite its effectiveness, BP draws concerns on its biological plausibility for two main reasons [Hinton, 2022, Lillicrap et al., 2016]: (1) it uses the same weights in reverse order for both feedforward and feedback paths, creating the weight symmetry problem [Lillicrap et al., 2016]; and (2) its parameter updating relies on the activity of all downstream layers, leading to the update locking problem [Dellaferrera and Kreiman, 2022]. These limitations may as well impact the efficiency, scalability and parallel processing capabilities of neural network training.

To address these limitations, direct feedback alignment (DFA) [Nøkland, 2016] offers an effective alternative to BP by training neural networks through a single forward pass. DFA uses fixed random feedback connections to project output errors directly onto hidden neurons, allowing for parallel gradient computation and eliminating the need for sequential backward error propagation. While demonstrated a limited accuracy penalty compared with BP, DFA aligns with brain-like learning mechanisms through its use of global error modulation and local synaptic activity, making it a notable non-BP method applicable in areas such as image classification [Zhao et al., 2023] and privacy protection [Ohana et al., 2021].

Directly applying DFA to GNNs, however, faces two challenges: (1) graph data often violates the independent and identically distributed ( i.i.d. ) assumption and thus ties the supervision gradients with the graph structure, making the straightforward error projection of DFA inadequate; and (2) DFA requires the prediction errors of all the input samples, while for graph data, especially under the semi-supervised setting, samples (nodes) without ground truth meet problems for the error calculation, complicating the deployment of DFA to GNNs.

To tackle these challenges, in this paper we propose DFA-GNN , a non-BP learning framework tailored for graph neural networks. Our primary contribution is to improve and extend DFA to graph neural networks. Specifically, we redesign the random feedback strategy for graph data to make the DFA portable to GNNs. The information from the graph topology, in the form of an adjacency matrix, is incorporated into the feedback links to accommodate the non-Euclidean characteristics of graph data. We take graph convolutional network (GCN) [Kipf and Welling, 2016] as a case study, and derive the specific formula for updating parameters in each GCN layer. Furthermore, for the semi-supervised graph learning task, we develop a novel pseudo error generator that spreads residual errors from training data to generate a pseudo error for each unlabeled node. Such pseudo errors are then used for the training of graph neural networks by DFA.

In summary, our proposed learning procedure for GNNs contributes in three significant folds:

We introduce DFA-GNN, a non-BP training algorithm that extends DFA to GNN architectures. It offers a more biologically plausible alternative to traditional BP methods.

For semi-supervised graph learning tasks, we develop a novel pseudo error generator that propagates residual errors from the training data to create pseudo errors for unlabeled nodes.

We prove the convergence of our DFA-GNN, and validate its effectiveness on 10 benchmarks. The experimental results demonstrate the superiority of our DFA-GNN against both traditional BP and the state-of-the-art non-BP approaches.

2 Related Work

The biological implausibility of BP mainly lies in weight transport and update locking issues. feedback alignment (FA) [Lillicrap et al., 2016] addresses the weight transport by using fixed random weights to convey error gradients. Building on this, direct feedback alignment (DFA) [Nøkland, 2016], direct random target projection (DRTP) [Frenkel et al., 2021] and PEPITA [Dellaferrera and Kreiman, 2022] further tackle the update locking problem with non-BP update methods. Prompted by the recent critiques of Hinton [2022], the forward-forward (FF) algorithm emerges as a more neurophysiologically aligned alternative, using dual forward passes with positive and negative data to simplify the training process and accommodate non-differentiable elements. The recently proposed cascaded forward algorithm (CaFo) [Zhao et al., 2023] attaches a class predictor to each layer, where only the layer-wise predictors are locally trained, with each neural block being randomly initialized and remaining fixed throughout.

Our work aims to push the frontier of the non-BP training algorithm for GNNs, which is a field still in its infancy. A remarkable recent work along the line is FORWARDGNN [Park et al., 2023] inspired by the forward-forward algorithm. FORWARDGNN avoids the constraints imposed by BP via an effective layer-wise local forward training. It trains GNNs using a single forward pass with the assistant of a data augmentation strategy. The augmented graph structure integrates virtual nodes linked only to labeled nodes, leaving the local topology of unlabeled nodes unchanged. The augmentation strategy makes it possible to operate without generating negative inputs. Despite of its advantages, FORWARDGNN still suffers from the greed-based training strategy, and thus results in inferiority in prediction performance in comparison with traditional BP algorithm.

In contrast, our method does not necessitate data augmentation for graph data; instead, it directly utilizes the discrepancy between predictions and actual ground truth to update each layer. Our approach directly outputs the prediction of the multi-class distribution, eliminating the need to calculate the goodness between unlabeled nodes and virtual nodes. As a result, our method offers convenience for multi-class prediction tasks and gains improvements in prediction performance.

3 Preliminaries

3.1 Problem Definition

An attributed relational graph of n nodes can be represented by G = ( V , E , X ) , where V = { v 1 , v 2 , · · · , v n } represents the set of n nodes, and E = { e ij } signifies the set of edges. X = { x T 1 ; x T 2 ; · · · ; x T n } ∈ R n × d is the attribute set for all nodes, with x i being the d -dimensional attribute vector for node v i . The adjacency matrix A = { a ij } ∈ R n × n denotes the topological structure of graph G , where a ij > 0 if there exists an edge e ij between nodes v i and v j and a ij = 0 otherwise.

For semi-supervised node classification, the node set V can be split into a labeled node set V L ⊂ V with attributes X L ⊂ X and an unlabeled one V U = V / V L with attributes X U = X / X L . 2 We assume that each node belongs to exactly one class, and denote y L = { y i } as the ground-truth labels of node set V L where y i denotes the class label of node v i ∈ V L .

The objective of semi-supervised node classification is to train a classifier using the graph and the known labels y L , and then apply this classifier to predict the labels for the unlabeled nodes v U . Define a classifier f θ : (˜ y L , ˜ y U ) ← f θ ( X , A , y L ) , where θ is the parameters of model. ˜ y L and ˜ y U are the predicted labels of nodes v L and v U respectively. Generally, the goal is to make the predicted labels ˜ y L align as closely as possible with the actual ground-truth labels y L in favor of: θ ∗ = arg min θ d (˜ y L , y L ) = arg min θ d ( f θ ( X , A , y L ) , y L ) , where d ( · , · ) represents a measure of some type of distance between two sets of labels.

3.2 Direct Feedback Alignment

While BP relies on symmetric weights for error propagation to hidden layers, there is evidence suggesting that symmetrical weight distribution may not be crucial for learning. For example, the study of feedback alignment (FA) shows that learning can still occur when errors are back propagated using randomly fixed weights. Direct feedback alignment (DFA) advances in this direction by directly transmitting output errors to each hidden layer through fixed linear feedback links. Specifically, for an L layer network, feedback matrices B ( l ) ∈ R n L × n l are employed to replace the derivatives ∂ x ( L ) /∂ x ( l ) of output neurons with respect to hidden neurons in the l -th layer. The approximate gradient δ W ( l ) for the weights of the l -th hidden layer is then computed as: δ W ( l ) = ∂ L ∂ x ( L ) B ( l +1) ∂ x ( l +1) ∂ W ( l ) , where x ( l ) represents the latent representation of a sample at the l -th layer, and L the loss value. In DFA, the feedback matrices assigned to hidden layers are randomly selected and remain unchanged throughout the training process. The effectiveness of DFA hinges on the alignment between forward weights and feedback matrices, leading to a congruence between the estimated and the actual gradient. When the angle between these gradients remains below 90 degrees, the update direction points to a downward trajectory. DFA has been successfully implemented in popular deep learning architectures such as fully-connected neural network (FC) [Zhang et al., 2017] and convolutional neural network (CNN) [Li et al., 2021a]. However, extending DFA to graph neural networks remains unexplored.

4 Proposed DFA-GNN

As depicted in Fig. 1, our DFA-GNN aims to train GNN models in non-BP framework by extending the DFA algorithm. Different from the original DFA algorithm designed on FC for Euclidean data, two key issues should be solved when extending it to GNN for graph data: (1) the original random feedback operations need to be reformulated to handle the dependence between samples (nodes); and (2) high-quality pseudo errors for test samples are required as they are not isolated from the training procedure. To this end, in Sec. 4.1 we redesign the random feedback strategy specified for graph data, and in Sec. 4.2 we develop a novel pseudo error generator for semi-supervised graph learning tasks. Finally, we provide deep insight of our DFA-GCN about its convergence and optimization in Sec. 4.3.

4.1 Generalizing DFA to GNN

The training process of traditional BP for GNN is listed in Algo. 1 of Appx. A.1, and it uses both a forward propagation and a backward one in each epoch. Generally, different GNN models may differ in the operations of aggregation and combination, and we provide a typical implementation in Algo. 1. We take graph convolutional network (GCN) [Kipf and Welling, 2016], one of the most classic and successful GNN models, as a case study to integrate DFA for graph learning.

For illustrative purpose, we consider a three-layer GCN model with ReLU for hidden activation and sigmoid for output activation. The forward propagation process could be written as:

where S = ˜ D -1 2 ˜ A ˜ D -1 2 , ˜ A = A + I is the adjacency matrix of graph G after adding self loop. ˜ D = diag( ˜ A ) the diagonal matrix of ˜ A , W ( l -1) a trainable weight matrix of the l -th layer and σ a non-linear activation function. X ( l ) ∈ R n × d denotes the latent representation matrix of the l -th layer and X (0) = X . If we choose sigmoid activation function in the output layer and a binary cross-entropy (BCE) loss function, the loss J for a graph with n nodes and the gradient E at the output layer are calculated as:

where ˜ Y and Y ∈ R n × c are respectively prediction and one-hot ground truth; m and k are respectively sample index and output unit. It is important to highlight that E represents the exact error between the prediction and the ground truth. For GCN, the gradients for hidden layers are calculated according to Algo. 1 as: δ X (2) = S T δ H (2) = S T EW (2) T , δ X (1) = S T δ H (1) = S T δ X (2) W (1) T .

As demonstrated by the work of FF [Lillicrap et al., 2016] and DFA [Nøkland, 2016], learning can be effective when errors are back propagated using randomly fixed weights. Similarly, we establish parallel direct feedback links for each layer. We approximate the update directions for the hidden layers as follows:

where B ( i ) is a fixed random weight matrix with appropriate dimension. δ X (1) can be then written as:

and the weight updates for all layers are calculated as:

The above derivations can be easily extended to GCNs with more layers, as done in our experiments.

4.2 Pseudo Error Generator by Spreading Residual Errors

In the computation of gradient (Eq. 6), the labels of all nodes are required, but not all nodes are labeled in the semi-supervised learning task. To address this issue, we introduce a mechanism to generate errors, assigning a pseudo error to each unlabeled node. The underlying principle is the expectation that errors in initial predictions are likely to propagate along the graph edges. That is, an error at a given node v suggests a higher likelihood of similar errors to its the neighbor nodes. This concept of error propagation across the graph is supported by previous studies [Jia and Benson, 2020]. Our approach draws inspiration from the strategy of residual propagation used in node regression tasks, and more broadly, from the frameworks of generalized least squares and correlated error models [Shalizi, 2013].

In semi-supervised graph learning, the error matrix E = { e T 1 ; e T 2 ; · · · ; e T n } ∈ R n × c as described in Eq. 3 is modified as the residual on the training nodes, while being set to zero for all other nodes. This adjustment entails initializing e i as a zero vector for all nodes v i ∈ V U .

The residuals in the rows of E for the training nodes are zero only when the forward process achieves perfect predictions. We utilize the label spreading technique [Zhou et al., 2003] to smooth the error with the goal of optimizing the following objective:

where tr ( · ) denotes the trace of a matrix. The first term enhances the smoothness of the error estimation throughout the graph, while the second term ensures that the final solution stays consistent with the initial error estimate E . Following the optimization methodology in Zhou et al. [2003] and Huang et al. [2021], the solution to Eq. 7 can be obtained through iterative processing

This process represents the diffusion of error, and such propagation is demonstrably appropriate within the context of regression problems under a Gaussian assumption. Nevertheless, for classification tasks like ours, the smoothed error Z ∗ might not align with the correct scale. Typically, ∥ Z ( t +1) ∥ 2 ≤ (1 -α ) ∥ E ∥ 2 + α ∥ S ∥ 2 ∥ E ( t ) ∥ 2 = (1 -α ) ∥ E ∥ 2 + α ∥ Z ( t ) ∥ 2 . Starting with Z (0) = E , we find that ∥ Z ( t ) ∥ 2 ≤ ∥ E ∥ 2 , indicating a need to adjust the scale of residuals adaptively. The aim is to match the magnitude of error in Z ∗ to that in E as closely as possible. Given that we only have accurate error information for labeled nodes, we use the average error across these nodes to estimate the appropriate scale. Specifically, with e i , z ∗ i ∈ R c representing the i -th row of E and Z ∗ respectively, the adjusted error for an unlabeled node j is calculated as: ˆ e j = η/ ∥ z ∗ j ∥ 1 · z ∗ j , in which η = 1 |V L | ∑ v i ∈V L ∥ e i ∥ 1 .

Give the rescaled pseudo error ˆ e for each unlabeled node, we define ˆ E ∈ R n × c , where the i -th row is set to e T i for nodes v i ∈ V L and to ˆ e T i for other nodes. The matrix ˆ E can then be directly utilized in Eqs. 5 and 6 for GCN training. Nevertheless, not all rescaled error of unlabeled nodes are accurate and useful. To address this, a mask is implemented to filter out these nodes. Define ˆ Y = ˜ Y -ˆ E as the corrected prediction. For labeled nodes, this corrected prediction equals to the one-hot ground truth. We introduce a mask vector p ∈ R n to facilitate this process. Formally, the setup is as follows:

where p i is the i -th element ( 1 ≤ i ≤ n ) of the vector p , ϵ a manually set threshold for controlling filtering and count( · ) a counting function. Eq. 9 focuses on retaining only those well predicted nodes, characterized by a single category being identified as positive and the rest as negative. With the mask, the filtering operations could be performed on ˆ E and S by row through the mask. The weight updates in Eq. 6 are modified as:

where S ( k ) f , ˆ E f , H ( k ) f represent the row filtering of S k , ˆ E and H ( k ) respectively, according to the mask p . As ( S T ) k ˆ E exactly denotes the accumulation of errors related to the k -hop neighbors of each node, the difference between Eq. 6 and Eq. 10 lies in the partial sampling of neighbors to approximate the update directions, as compared with using all neighbors. Given that only poorly predicted nodes are excluded and they constitute a small fraction, the update directions in both approaches generally remain aligned. The formal description of our algorithm is provided in Appx. A.2.

4.3 Insights of DFA-GNN

DFA-GNN provides a non-BP training procedure for GNN. For GCN we provide a detailed analysis on how such an asymmetric feedback path introduced in Sec. 4.1 can provide learning by aligning the gradients of backward propagation and forward propagation with its own. Nøkland [2016] has originally proved the conclusion for fully-connected layer architectures. We can show that this conclusion is equally valid for the GCN architecture, and provide the detailed proof in Appx. A.3.

Experiments in Fig. 2(a) validate the dynamic process of alignment between B and W during training, and the weight alignment leads to gradient alignment because for weight alignment of DFA:

where the symbol ∝ represents a positive scalar multiple relationship. As gradient alignment requires δ X ( l ) DFA ∝ δ X ( l ) BP , i.e. , ( S T ) L -l EB ( l ) ∝ S T δ X ( l +1) W ( l ) T , the weight alignment directly implies gradient alignment if the feedback matrices are assumed right-orthogonal, i.e. , BB T = I . This assumption holds if the feedback matrices elements are sampled i.i.d. from a Gaussian distribution since E [ BB T ] ∝ I , hence Eq. 11 induces the weights, by the orthogonality condition, to cancel out by pairs of two:

The alignments of weights and gradients make our method trained with DFA tend to converge to a specific region within the landscape, guided by the structure of the feedback matrices, while the optimization paths trained with BP according to stochastic gradient descent often exhibit divergent within the loss landscape, as shown in Fig. 2 (d).

For deeper understanding of the training mechanism in our method, we divide the entire training process into three stages: Stage 1 (train layers 1 and 2 while freezing layer 3), Stage 2 (freeze layers 1 and 2 while training layer 3) and Stage 3 (train layers 1 and 2 while freezing layer 3). The results in Figs. 2(b,c) show a strong correlation between weight alignment and the fitting degree of the model, as indicated by the loss. Notably, even though our method updates parameters of each layer in parallel, the effective update follows a backward-to-forward manner. As shown in Fig. 2 (b), when the parameters of layer l are not effectively learned, updating the preceding layers does not enhance fitting ability of the model. This behavior contrasts with the characteristics of traditional BP, which indicates that the alignment of weights and gradients also adhere to a backward-to-forward sequence.

0

200

400

600

800

20

40

60

80

100

degree(°)/accuracy(%)

valid accuracy

(

W T

2

,

B

2)

(

W T

1

,

B T

2

B

1)

(a)

0

250

500

750

1000

1250

1500

0.500

0.525

0.550

0.575

0.600

0.625

0.650

0.675

0.700

loss

training loss

stage 1

stage 2

stage 3

(b)

0

250

500

750

1000

1250

1500

78

80

82

84

86

88

degree(°)

(

W T

2

,

B

2)

(

W T

1

,

B T

2

B

1)

stage 1

stage 2

stage 3

(c)

BP paths

DFA paths

(d)

5 Experiments

5.1 Comparison with Baseline Training Algorithms

We evaluate our method on 10 benchmark datasets across various domains and compare it with the BP [Rumelhart et al., 1986], PEPITA [Dellaferrera and Kreiman, 2022], two versions of the FF ( abbr. FF+LA, FF+VN) [Hinton, 2022, Park et al., 2023], two versions of the CaFo ( abbr. CaFo+MSE, CaFo+CE) [Zhao et al., 2023] and the FORWARDGNN-SF ( abbr. SF) [Park et al., 2023]. Detailed datasets and experimental setup information can be found in Appx. A.4 and Appx. A.5, respectively. The comparative analysis of various algorithms on benchmark datasets is summarized in Tab. 1. While the non-BP methods such as PEPITA, CaFo and FF have proven effective for architectures involving fully-connected and convolutional layers with Euclidean data, they exhibit weaker performance with non-Euclidean graph data. This is primarily due to the unique challenges posed by graph data.

Firstly, in typical fully-connected and convolutional layers, shallow layers capture coarse-grained features while deep layers handle fine-grained features, with these two types of features usually being highly correlated. However, in GNNs, different layers aggregate information from varying neighborhood ranges, resulting in layers that often contain uncorrelated information. Particularly in heterophilic graphs, the information extracted by deep and shallow layers may be entirely unrelated

or even have opposing effects on predictions. This lack of correlation complicates the application of layer-wise optimization strategies, which rely on greedy strategies and local loss calculations common in traditional networks. This is a key reason for the underperformance of methods like PEPITA, CaFo and FF in GNNs, as evidenced in Tab. 1, particularly on datasets characterized by low homophily. Secondly, since graph data do not adhere to the i.i.d. assumption, sampling positive and negative samples based on features (FF+LA) and topology (FF+VN) for the FF algorithm can be unreliable, potentially leading to inconsistent results. Notably, FF+VN modifies the original graph topology by introducing virtual nodes into both positive and negative graphs, which results in overall unsatisfactory performance in benchmarks. For CaFo, the rigidity in fixing the parameters of each block, with only the predictors being learnable, further constrains its adaptability. As the most recently proposed non-BP GNN training approach, SF shows a performance that is superior to PEPITA, CaFo and FF but still lags behind the traditional BP method on most datasets. The reason lies in that SF also introduces virtual nodes that disrupt graph topology and employs a layer-wise training strategy. By contrast, our method well adapts to graph data and gains significant improvement in testing accuracy in comparison with the baseline algorithms, achieving the best or second-best results across all datasets.

The training times for each method are shown in Appx. A.6. Our approach demonstrates a general time advantage over CaFo, FF and SF. Our method includes a forward propagation and a parameter update where all layers execute in parallel during each iteration, which offers greater parallelism compared with layer-wise update methods like CaFo, FF and SF. Our method has a higher training time consumption compared with BP, primarily due to the additional time needed for generating pseudo errors and filtering masks, as discussed in Sec. 4.2.

5.2 Ablation Study

We ablate the proposed method to study the importance of designs in DFA-GNN. Two designs are studied including the pseudo error generator ( abbr. EG) and the node filter ( abbr. NF). For trials with EG, the pseudo error generator is applied according to Eq. 7 to assign a pseudo error for each unlabeled node. It worth noting that when ER is removed from the method, only the errors of labeled nodes are used for the updating of parameters according to Eq. 6. For trials with NF, the mask calculated as Eq. 9 is introduced in training process and the parameters are updated according to Eq. 10. The ablation results are included in Tab. 2. We note that even the most naive version of DFA-GNN elaborated in Sec. 4.1 achieves comparable results in comparison with BP. Furthermore, both the two designs introduced in Sec. 4.2 contribute to our training framework, making significant enhancement to DFA-GNN to outperform BP method.

5.3 Visualization of Convergence

To better illustrate the training convergence of DFA-GNN, we plot the training and validation accuracy of the proposed DFA-GNN and BP over training epochs on three datasets, as shown in Fig. 3. In general, our method shows similar convergence to BP. For both BP and our method, the convergence of validation accuracy occurs much earlier than that of training accuracy due to overfitting. The validation convergent epoch of DFA-GNN is nearly the same as BP on Cora and CiteSeer (around 100 epochs), while it is 100 epochs later than BP on PubMed (around 200 epochs). Our method achieves better validation accuracy on all these datasets and suffers less from overfitting compared with BP. In terms of training accuracy, the convergence of our method is slightly slower than BP because the update direction of our method is not exactly opposite to the gradient direction but maintains a small angle. Since our method considers both the errors of labeled nodes and pseudo errors of unlabeled nodes as supervision information, which is different from BP that only uses the loss of labeled nodes

0

200

400

600

800

1000

Epoch

60

65

70

75

80

85

90

95

100

BP train

BP val

ours train

ours val

0

200

400

600

800

1000

Epoch

65

70

75

80

85

90

95

100

BP train

BP val

ours train

ours val

(b) CiteSeer

0

200

400

600

800

1000

Epoch

80.0

82.5

85.0

87.5

90.0

92.5

95.0

97.5

100.0

BP train

BP val

ours train

ours val

(c) PubMed

3

4

5

6

7

8

9

10

11

12

13

14

15

the number of layers

10

20

30

40

50

60

70

80

90

accuracy(%)

CiteSeer BP

CiteSeer ours

CiteSeer SF

PubMed BP

PubMed ours

PubMed SF

(a)

0.2

0.4

0.6

0.8

perturbation rate

30

40

50

60

70

80

accuracy(%)

CiteSeer BP

CiteSeer ours

CiteSeer SF

PubMed BP

PubMed ours

PubMed SF

(b)

0.2

0.4

0.6

0.8

perturbation rate

30

40

50

60

70

80

accuracy(%)

CiteSeer BP

CiteSeer ours

CiteSeer SF

PubMed BP

PubMed ours

PubMed SF

(c)

0.2

0.4

0.6

0.8

perturbation rate

30

40

50

60

70

80

accuracy(%)

CiteSeer BP

CiteSeer ours

CiteSeer SF

PubMed BP

PubMed ours

PubMed SF

(d)

for supervision, the convergent value of training accuracy for our method is slightly lower than BP. However, this does not affect our method achieving better validation results.

5.4 Robustness Analysis

We focus on over-smoothing and random structural attack, two common sources of perturbation that reduce GNN performance. Over-smoothing [Keriven, 2022] is a problematic issue in GNNs, stemming from the aggregation mechanism within GNNs, which hinders the expansion of GNN models to a large number of layers. We test the robustness of our method against over-smoothing in Fig. 4 (a). Our method demonstrates greater robustness compared with BP, particularly when dealing with architectures that have a large number of layers. This enhanced robustness is due to the fact that the global loss directly contributes to the optimization of each individual layer. SF is less effected by over-smoothing due to its layer-wise optimization with local loss. However, its performance largely depends on shallow layers and the best performance on each dataset is inferior to ours.

For random structural attack [Li et al., 2021b], three random attack types are implemented on the original graph topology with a perturbation rate λ from 0.2 to 0.8. To better compare the robustness of different methods, we employ a more challenging experimental setup with a sparse supervision pattern, where each class has only 20 labeled nodes. The node split follows Kipf and Welling [2016]. The detailed operating description for attacking type is summarized as follows: (1) add : randomly add λ |E| edges to the original graph for a denser topology; (2) remove : randomly remove λ |E| edges from the original graph for a sparser topology; and (3) flip : randomly choose λ |E| node pairs, and remove the edge if there exists one between the pair, and otherwise add an edge to connect the pair.

Our method is less sensitive to all types of perturbations as shown in Figs. 4 (b-d), consistently outperforms two approaches on each trial, and exhibits exciting robustness even under a high perturbation rate. As the pseudo error generator derives pseudo error for each unlabeled node to update each layer, this supervision generation mechanism helps enhance robustness of the model against noise and attacks. Interestingly, a comparison of results across three different types of attacks shows that removing edges has the least adverse effect, suggesting that injecting incorrect topological information could be more detrimental to GNN performance than losing valuable original topology.

5.5 Scalability on Large Datasets

Our method is well-suited for large datasets. When the graph scale is large, we can use edge indices instead of an adjacency matrix to store the graph. For forward propagation (Eq. 1), the complexity

of neighbor aggregation can be reduced from O ( n 2 d ) to O ( |E| d ) , where |E| denotes the number of edges. For direct feedback alignment (Eq. 10), as ( S T ) k ˆ E is exactly the aggregation of errors for k times, the time and space complexity can be reduced to O ( kc |E| ) , without the need to calculate the k -th power of the adjacency matrix. Similarly, complexity reduction can also be achieved in the node filtering process. The experimental results on the Flickr [Zeng et al., 2020], Reddit [Hamilton et al., 2017], and ogbn-arxiv [Hu et al., 2020] datasets, as presented in Tab. 3, demonstrate that our method is effective on large-scale datasets, delivering strong performance. Our method achieves results comparable to BP while surpassing other non-BP methods, all with a small memory footprint (2043 MiB for Flickr, 11675 MiB for Reddit, and 2277 MiB for ogbn-arxiv). This indicates that our method not only scales well to large graphs but also maintains efficiency in terms of space usage.

5.6 Portability Analysis

We apply our training algorithm to five popular GNN models [Wu et al., 2019, Veliˇ ckovi´ c et al., 2018, Hamilton et al., 2017, Gasteiger et al., 2018, Defferrard et al., 2016] and report the mean accuracy across ten random splits in Tab. 4. Each of the testing models is modified to fit our framework. Specifically, for SGC, which only has a single learnable linear output layer, the training of our framework involves no direct feedback but only incorporates the pseudo error generator and node filter. For GraphSage, we utilize a mean-aggregator for message aggregation. Our observations indicate that our method can be effectively ported to mainstream GNN models. All test models integrated with our algorithm work well and surpass the performance of traditional BP in most scenarios. It demonstrates the effectiveness of our method across various GNN models and underscores its excellent portability and potential generalization ability to other innovative GNN models.

6 Conclusion

In this paper, we investigate the potential of non-backpropagation training methods within the context of graph learning. We adapt the direct feedback alignment algorithm for training graph neural networks on graph data and introduce DFA-GNN. This new approach incorporates a meticulously designed random feedback strategy, a pseudo error generator, and a node filter to effectively spread residual errors. Through mathematical formulations, we demonstrate that our method can align with backpropagation in terms of parameter update gradients and perform effective training. Extensive experiments on real-world datasets confirm the effectiveness, efficiency, robustness and versatility of our proposed forward graph learning framework.

Acknowledgments

This work is supported by the National Nature Science Foundation of China (Nos. 62076021 and 62376020). Haibin Ling was not supported by any fund for this work.

References

Jie Zhou, Ganqu Cui, Shengding Hu, Zhengyan Zhang, Cheng Yang, Zhiyuan Liu, Lifeng Wang, Changcheng Li, and Maosong Sun. Graph neural networks: A review of methods and applications. AI Open , 1:57-81, 2020.

Zonghan Wu, Shirui Pan, Fengwen Chen, Guodong Long, Chengqi Zhang, and S Yu Philip. A comprehensive survey on graph neural networks. IEEE Transactions on Neural Networks and Learning Systems , 32(1):4-24, 2020.

Shiwen Wu, Fei Sun, Wentao Zhang, Xu Xie, and Bin Cui. Graph neural networks in recommender systems: a survey. ACM Computing Surveys , 55(5):1-37, 2022.

Jiacheng Xiong, Zhaoping Xiong, Kaixian Chen, Hualiang Jiang, and Mingyue Zheng. Graph neural networks for automated de novo drug design. Drug Discovery Today , 26(6):1382-1393, 2021.

Michihiro Yasunaga, Hongyu Ren, Antoine Bosselut, Percy Liang, and Jure Leskovec. Qa-gnn: Reasoning with language models and knowledge graphs for question answering. arXiv preprint arXiv:2104.06378 , 2021.

Robert Hecht-Nielsen. Theory of the backpropagation neural network. In Neural Networks for Perception , pages 65-93. 1992.

Geoffrey Hinton. The forward-forward algorithm: Some preliminary investigations. arXiv preprint arXiv:2212.13345 , 2022.

Timothy P Lillicrap, Daniel Cownden, Douglas B Tweed, and Colin J Akerman. Random synaptic feedback weights support error backpropagation for deep learning. Nature Communications , 7(1): 13276, 2016.

Giorgia Dellaferrera and Gabriel Kreiman. Error-driven input modulation: Solving the credit assignment problem without a backward pass. In International Conference on Machine Learning , pages 4937-4955, 2022.

Arild Nøkland. Direct feedback alignment provides learning in deep neural networks. Advances in Neural Information Processing Systems , 29, 2016.

Gongpei Zhao, Tao Wang, Yidong Li, Yi Jin, Congyan Lang, and Haibin Ling. The cascaded forward algorithm for neural network training. arXiv preprint arXiv:2303.09728 , 2023.

Ruben Ohana, Hamlet Medina, Julien Launay, Alessandro Cappelli, Iacopo Poli, Liva Ralaivola, and Alain Rakotomamonjy. Photonic differential privacy with direct feedback alignment. Advances in Neural Information Processing Systems , 34:22010-22020, 2021.

Thomas N Kipf and Max Welling. Semi-supervised classification with graph convolutional networks. In International Conference on Learning Representations , 2016.

Charlotte Frenkel, Martin Lefebvre, and David Bol. Learning without feedback: Fixed random learning signals allow for feedforward training of deep neural networks. Frontiers in Neuroscience , 15:629892, 2021.

Namyong Park, Xing Wang, Antoine Simoulin, Shuai Yang, Grey Yang, Ryan A Rossi, Puja Trivedi, and Nesreen K Ahmed. Forward learning of graph neural networks. In International Conference on Learning Representations , 2023.

Yuchen Zhang, Jason Lee, Martin Wainwright, and Michael I Jordan. On the learnability of fullyconnected neural networks. In Artificial Intelligence and Statistics , pages 83-91, 2017.

Zewen Li, Fan Liu, Wenjie Yang, Shouheng Peng, and Jun Zhou. A survey of convolutional neural networks: analysis, applications, and prospects. IEEE Transactions on Neural Networks and Learning Systems , 33(12):6999-7019, 2021a.

Junteng Jia and Austion R Benson. Residual correlation in graph neural network regression. In ACM SIGKDD International Conference on Knowledge Discovery & Data Mining , pages 588-598, 2020.

Cosma Shalizi. Advanced data analysis from an elementary point of view. 2013.

Dengyong Zhou, Olivier Bousquet, Thomas Lal, Jason Weston, and Bernhard Schölkopf. Learning with local and global consistency. Advances in Neural Information Processing Systems , 16, 2003.

Qian Huang, Horace He, Abhay Singh, Ser-Nam Lim, and Austin Benson. Combining label propagation and simple models out-performs graph neural networks. In International Conference on Learning Representations , 2021.

David E Rumelhart, Geoffrey E Hinton, and Ronald J Williams. Learning representations by back-propagating errors. Nature , 323(6088):533-536, 1986.

Nicolas Keriven. Not too little, not too much: a theoretical analysis of graph (over) smoothing. Advances in Neural Information Processing Systems , 35:2268-2281, 2022.

Yaxin Li, Wei Jin, Han Xu, and Jiliang Tang. Deeprobust: a platform for adversarial attacks and defenses. In AAAI Conference on Artificial Intelligence , volume 35, pages 16078-16080, 2021b.

Hanqing Zeng, Hongkuan Zhou, Ajitesh Srivastava, Rajgopal Kannan, and Viktor Prasanna. Graphsaint: Graph sampling based inductive learning method. In International Conference on Learning Representations , 2020.

Will Hamilton, Zhitao Ying, and Jure Leskovec. Inductive representation learning on large graphs. Advances in Neural Information Processing Systems , 30, 2017.

Weihua Hu, Matthias Fey, Marinka Zitnik, Yuxiao Dong, Hongyu Ren, Bowen Liu, Michele Catasta, and Jure Leskovec. Open graph benchmark: Datasets for machine learning on graphs. Advances in Neural Information Processing Systems , 33:22118-22133, 2020.

Felix Wu, Amauri Souza, Tianyi Zhang, Christopher Fifty, Tao Yu, and Kilian Weinberger. Simplifying graph convolutional networks. In International Conference on Machine Learning , pages 6861-6871, 2019.

Petar Veliˇ ckovi´ c, Guillem Cucurull, Arantxa Casanova, Adriana Romero, Pietro Liò, and Yoshua Bengio. Graph attention networks. In International Conference on Learning Representations , 2018.

Johannes Gasteiger, Aleksandar Bojchevski, and Stephan Günnemann. Predict then propagate: Graph neural networks meet personalized pagerank. In International Conference on Learning Representations , 2018.

Michaël Defferrard, Xavier Bresson, and Pierre Vandergheynst. Convolutional neural networks on graphs with fast localized spectral filtering. Advances in Neural Information Processing Systems , 29, 2016.

Prithviraj Sen, Galileo Namata, Mustafa Bilgic, Lise Getoor, Brian Galligher, and Tina Eliassi-Rad. Collective classification in network data. AI Magazine , 29(3):93-93, 2008.

Zhilin Yang, William Cohen, and Ruslan Salakhudinov. Revisiting semi-supervised learning with graph embeddings. In International Conference on Machine Learning , pages 40-48, 2016.

Julian McAuley, Christopher Targett, Qinfeng Shi, and Anton Van Den Hengel. Image-based recommendations on styles and substitutes. In International ACM SIGIR Conference on Research and Development in Information Retrieval , pages 43-52, 2015.

Benedek Rozemberczki, Carl Allen, and Rik Sarkar. Multi-scale attributed node embedding. Journal of Complex Networks , 9(2):cnab014, 2021.

Hongbin Pei, Bingzhe Wei, Kevin Chen-Chuan Chang, Yu Lei, and Bo Yang. Geom-gcn: Geometric graph convolutional networks. In International Conference on Learning Representations , 2019.

Oleg Platonov, Denis Kuznedelev, Michael Diskin, Artem Babenko, and Liudmila Prokhorenkova. A critical look at the evaluation of gnns under heterophily: Are we really making progress? In International Conference on Learning Representations , 2022.

Minjie Wang, Lingfan Yu, Da Zheng, Quan Gan, Yu Gai, Zihao Ye, Mufei Li, Jinjing Zhou, Qi Huang, Chao Ma, Ziyue Huang, Qipeng Guo, Hao Zhang, Haibin Lin, Junbo Zhao, Jinyang Li, Alexander J. Smola, and Zheng Zhang. Deep graph library: Towards efficient and scalable deep learning on graphs. In ICLR Workshop on Representation Learning on Graphs and Manifolds , 2019.

A APPENDIX

Here we provide some implementation details of our methods to help readers further understand the algorithms and experiments in this paper.

A.1 GNN Training Process of BP

A.2 GCN Training Process of Our Method

A.3 Proof of Theorem in Sec. 4.3

Theorem. For a GCN model with two hidden layers k and k + 1 where k connects to k + 1 in sequence, we have x ( k +1) = σ ( a ( k +1) ) and a ( k +1) = g ( Wx ( k ) ) , where σ is the activation function and g ( · ) the aggregation operation in Algo. 1. Let the layers be updated according to the non-zero update directions δ x ( k ) and δ x ( k +1) where δ x ( k ) ∥ δ x ( k ) ∥ and δ x ( k +1) ∥ δ x ( k +1) ∥ are constant for each data point. The negative update directions will minimize the following layer-wise criterion:

Minimizing P will lead to an increase in the gradient, thereby enhancing the alignment criterion:

where

g ′ ( · ) is the aggregation of gradients in Algo. 1, (line 13). If Q ( k ) > 0 , then -δ x ( k ) serves as a direction of descent to minimize P ( k +1) .

Proof. Let i be the any of the layers k or k +1 , and prescribed update -δ x ( i ) is the steepest descent direction to minimize P ( i ) . Since any partial derivative of δ x ( i ) ∥ δ x ( i ) ∥ is zero, we have:

where α ( i ) = 1 ∥ δ x ( i ) ∥ > 0 . As δ a ( i ) = ∂ x ( i ) ∂ a ( i ) δ x ( i ) = δ x ( i ) ⊙ σ ′ ( a ( i ) ) , the gradients maximizing Q ( k ) and Q ( k +1) are:

When ignoring the magnitude of the gradients we have ∂ Q ∂ W ≈ ∂ Q ( k ) ∂ W ≈ ∂ Q ( k +1) ∂ W . If x ( i ) is projected onto δ x ( i ) we have x ( i ) = x ( i ) T δ x ( i ) ∥ δ x ( i ) ∥ 2 δ x ( i ) + x ( i ) res . The prescribed update for W is:

It is obvious that Q ( k ) and Q ( k +1) can be maximized when the component of ∂ Q ( k ) ∂ W in δ W is maximized by minimizing P ( k ) . The gradient to minimize P ( k ) is the prescribed update -δ x ( k ) . The

angle between δ x ( k ) and the gradient of BP c ( k ) is within 90 ◦ if Q ( k ) > 0 because the cosine of the two vector is Q ( k ) ∥ c ( k ) ∥ > 0 , and it also indicates that c ( k ) is nonzero and therefore in a descending trend. Consequently, δ x ( k ) will be oriented towards a descending direction since any vector that lies within 90 ◦ of the steepest descent direction will similarly point downwards, in other words, for GCN, a broad spectrum of asymmetric feedback paths can offer a descending gradient direction for a hidden layer as long as Q ( i ) > 0 .

From Eq. 5, it is obvious one advantage of our method is that δ x ( i ) is non-zero for any non-zero error e , as a randomly generated matrix B ( i ) is highly likely to be of full rank. Ensuring δ x ( i ) is non-zero is crucial for achieving Q ( i ) > 0 . Maintaining static feedback across training helps preserve the characteristic, and also simplifies the process of maximizing Q ( i ) due to the more consistent direction to δ x ( i ) . Our method shows better biological plausibility in GNN training, which introduces asymmetric feedback paths to take place of BP, not only solving the weight transport problem and partially solving the update locking problem, but also releasing the requirement to store neural activations and accumulated gradients for backward propagation.

A.4 Datasets Statistics

We evaluate our method on 10 benchmark datasets across domains: citation networks (Cora, CiteSeer, PubMed) [Sen et al., 2008, Yang et al., 2016], Amazon co-purchase graph (Photo, Computer) [McAuley et al., 2015], Wikipedia graphs (Chameleon, Squirrel) [Rozemberczki et al., 2021], actor co-occurrence graph (Actor) [Pei et al., 2019] and webpage graphs from WebKB (Texas, Cornell) [Pei et al., 2019]. The datasets adopted are representative which describe diverse reallife scenarios. Some of them are highly homophilic while others are heterophilic. Note that for Chameleon and Squirrel, we use the filtered version from Platonov et al. [2022], as the original version from [Rozemberczki et al., 2021] may contain duplicated nodes. The detailed statistics of the datasets are summarized in Tab. 5. We compute the node homophily for each dataset using the method proposed by Pei et al. [2019], referred to as the homophily value.

Cora , CiteSeer and PubMed [Sen et al., 2008] are three classic homophilic citation networks. In these networks, nodes correspond to academic papers, and edges signify the citation links between papers. The node features are derived from bag-of-word representations of the papers, and the labels categorize each paper into specific research topics.

Computer and Photo [McAuley et al., 2015] are segments of the Amazon co-purchase graph, where nodes represent goods, edges indicate that two goods are frequently bought together, node features are bag-of-words encoded product reviews, and class labels are given by the product category.

Chameleon and Squirrel [Rozemberczki et al., 2021] are two heterophilic networks derived from Wikipedia. In these networks, nodes represent Wikipedia web pages, and edges correspond to hyperlinks between these pages. The features are comprised of informative nouns extracted from the Wikipedia content, while the labels reflect the average traffic of each web page.

Actor [Pei et al., 2019] is a heterophilic actor co-occurrence network where nodes represent actors, and edges signify that two actors have appeared together in the same movie. The features are derived from keywords found on the actors' Wikipedia pages, while the labels consist of significant words associated with each actor.

Cornell and Texas [Pei et al., 2019] are heterophilic networks from the WebKB1 project representing computer science departments at three universities. Nodes are departmental web pages, edges represent hyperlinks, features are derived using bag-of-words, and labels categorize page types. These networks illustrate heterophilic connections where linked pages often differ in type.

A.5 Experimental Settings

We conduct the semi-supervised node classification task using a basic GCN model, where the node set is randomly divided into the train/validation/test set with 60%/20%/20%. For fairness, we generate 10 random splits using different seeds and evaluate all approaches on these identical splits, reporting the average performance for each method. Our method is compared with five baseline training strategies including the traditional backpropagation (BP) [Rumelhart et al., 1986], PEPITA [Dellaferrera and Kreiman, 2022], two versions of the forward-forward algorithm ( abbr. FF+LA, FF+VN) [Hinton, 2022, Park et al., 2023], two versions of the cascaded forward algorithm ( abbr. CaFo+MSE, CaFo+CE) [Zhao et al., 2023] and the FORWARDGNN Single-Forward algorithm ( abbr. SF) [Park et al., 2023] specifically designed for GNNs. To ensure fairness, we train all approaches using the same GCN architecture, which includes 3 graph convolutional layers and 64 hidden units-sufficiently representative for all datasets. We employ Adam as the optimization algorithm, refraining from using any regularization techniques other than an appropriate L2 penalty specific to Adam. The evaluation metric used is accuracy (acc), presented with a 95% confidence interval.

The codes of DFA-GNN are based on the GNNs in the PyTorch version by Deep Graph Library (DGL) [Wang et al., 2019]. To generate pseudo errors, we search the optimal α in Eq. 8 within {0.001, 0.01, 0.1, 0.3, 0.5, 0.7, 0.9}, the iteration epoch for Eq. 8 within {5, 10, 30, 50, 100, 150, 200}, ϵ in Eq. 9 within {0.3, 0.5, 0.7, 0.9}. For the training of our method, we search the learning rate within {0.001, 0.01, 0.1} and weight decay within {0.0005, 0}. All the experiments are run on AMDEPYC 7542 32-Core Processor with Nvidia GeForce RTX 3090. We list the hyper-parameter values used in our model in Tab. 6.

A.6 Time Comparison

A.7 Comparison of BP and DFA with Pseudo-Error Generation

Although the pseudo-error generation process is essential for our method, it is also an optional choice for backpropagation. We integrate this component into BP, and the experimental results from Tab. 8 show that although this component contributes to DFA in our method, it does not positively enhance BP overall. Even with pseudo-error generation, BP cannot outperform our method. This observation indicates that direct feedback of errors may benefit more from pseudo-errors rather than the layer-by-layer backward pass.

A.8 DFA-GNN with Alternative Activation Functions

We conduct experiments for our method with four different activation functions ( i.e. , Sigmoid, Tanh, ELU and LeakyReLU) as shown in Tab. 9. The results demonstrate our method is well integrated with different activation functions and derives consistently good results.

NeurIPS Paper Checklist

1. Claims

Question: Do the main claims made in the abstract and introduction accurately reflect the paper's contributions and scope?

Answer: [Yes]

Justification: The abstract and introduction clearly state the claims made.

Guidelines:

The answer NA means that the abstract and introduction do not include the claims made in the paper.

The abstract and/or introduction should clearly state the claims made, including the contributions made in the paper and important assumptions and limitations. A No or NA answer to this question will not be perceived well by the reviewers.

The claims made should match theoretical and experimental results, and reflect how much the results can be expected to generalize to other settings.

It is fine to include aspirational goals as motivation as long as it is clear that these goals are not attained by the paper.

2. Limitations

Question: Does the paper discuss the limitations of the work performed by the authors?

Answer: [Yes]

Justification: Please see Secs. 4 and 5.

Guidelines:

The answer NA means that the paper has no limitation while the answer No means that the paper has limitations, but those are not discussed in the paper.

The authors are encouraged to create a separate "Limitations" section in their paper.

The paper should point out any strong assumptions and how robust the results are to violations of these assumptions (e.g., independence assumptions, noiseless settings, model well-specification, asymptotic approximations only holding locally). The authors should reflect on how these assumptions might be violated in practice and what the implications would be.

The authors should reflect on the scope of the claims made, e.g., if the approach was only tested on a few datasets or with a few runs. In general, empirical results often depend on implicit assumptions, which should be articulated.

The authors should reflect on the factors that influence the performance of the approach. For example, a facial recognition algorithm may perform poorly when image resolution is low or images are taken in low lighting. Or a speech-to-text system might not be used reliably to provide closed captions for online lectures because it fails to handle technical jargon.

The authors should discuss the computational efficiency of the proposed algorithms and how they scale with dataset size.

If applicable, the authors should discuss possible limitations of their approach to address problems of privacy and fairness.

While the authors might fear that complete honesty about limitations might be used by reviewers as grounds for rejection, a worse outcome might be that reviewers discover limitations that aren't acknowledged in the paper. The authors should use their best judgment and recognize that individual actions in favor of transparency play an important role in developing norms that preserve the integrity of the community. Reviewers will be specifically instructed to not penalize honesty concerning limitations.

3. Theory Assumptions and Proofs

Question: For each theoretical result, does the paper provide the full set of assumptions and a complete (and correct) proof?

Answer: [Yes]

Justification: Please see Sec. 4.3 and Appx. A.3.

Guidelines:

The answer NA means that the paper does not include theoretical results.

All the theorems, formulas, and proofs in the paper should be numbered and crossreferenced.

All assumptions should be clearly stated or referenced in the statement of any theorems.

The proofs can either appear in the main paper or the supplemental material, but if they appear in the supplemental material, the authors are encouraged to provide a short proof sketch to provide intuition.

Inversely, any informal proof provided in the core of the paper should be complemented by formal proofs provided in appendix or supplemental material.

Theorems and Lemmas that the proof relies upon should be properly referenced.

4. Experimental Result Reproducibility

Question: Does the paper fully disclose all the information needed to reproduce the main experimental results of the paper to the extent that it affects the main claims and/or conclusions of the paper (regardless of whether the code and data are provided or not)?

Answer: [Yes]

Justification: The detailed experimental settings are included in Appx. A.5.

Guidelines:

The answer NA means that the paper does not include experiments.

If the paper includes experiments, a No answer to this question will not be perceived well by the reviewers: Making the paper reproducible is important, regardless of whether the code and data are provided or not.

If the contribution is a dataset and/or model, the authors should describe the steps taken to make their results reproducible or verifiable.

Depending on the contribution, reproducibility can be accomplished in various ways. For example, if the contribution is a novel architecture, describing the architecture fully might suffice, or if the contribution is a specific model and empirical evaluation, it may be necessary to either make it possible for others to replicate the model with the same dataset, or provide access to the model. In general. releasing code and data is often one good way to accomplish this, but reproducibility can also be provided via detailed instructions for how to replicate the results, access to a hosted model (e.g., in the case of a large language model), releasing of a model checkpoint, or other means that are appropriate to the research performed.

While NeurIPS does not require releasing code, the conference does require all submissions to provide some reasonable avenue for reproducibility, which may depend on the nature of the contribution. For example

(a) If the contribution is primarily a new algorithm, the paper should make it clear how to reproduce that algorithm.

(b) If the contribution is primarily a new model architecture, the paper should describe the architecture clearly and fully.

(c) If the contribution is a new model (e.g., a large language model), then there should either be a way to access this model for reproducing the results or a way to reproduce the model (e.g., with an open-source dataset or instructions for how to construct the dataset).

(d) We recognize that reproducibility may be tricky in some cases, in which case authors are welcome to describe the particular way they provide for reproducibility. In the case of closed-source models, it may be that access to the model is limited in some way (e.g., to registered users), but it should be possible for other researchers to have some path to reproducing or verifying the results.

5. Open access to data and code

Question: Does the paper provide open access to the data and code, with sufficient instructions to faithfully reproduce the main experimental results, as described in supplemental material?

Answer: [Yes]

Justification: In Appx. A.4, we provide the sources of the datasets. We provide the key parts of the algorithm in the supplementary. The complete version will be made publicly available once it is fully organized.

Guidelines:

The answer NA means that paper does not include experiments requiring code.

Please see the NeurIPS code and data submission guidelines ( https://nips.cc/ public/guides/CodeSubmissionPolicy ) for more details.

While we encourage the release of code and data, we understand that this might not be possible, so 'No' is an acceptable answer. Papers cannot be rejected simply for not including code, unless this is central to the contribution (e.g., for a new open-source benchmark).

The instructions should contain the exact command and environment needed to run to reproduce the results. See the NeurIPS code and data submission guidelines ( https: //nips.cc/public/guides/CodeSubmissionPolicy ) for more details.

The authors should provide instructions on data access and preparation, including how to access the raw data, preprocessed data, intermediate data, and generated data, etc.

The authors should provide scripts to reproduce all experimental results for the new proposed method and baselines. If only a subset of experiments are reproducible, they should state which ones are omitted from the script and why.

At submission time, to preserve anonymity, the authors should release anonymized versions (if applicable).

Providing as much information as possible in supplemental material (appended to the paper) is recommended, but including URLs to data and code is permitted.

6. Experimental Setting/Details

Question: Does the paper specify all the training and test details (e.g., data splits, hyperparameters, how they were chosen, type of optimizer, etc.) necessary to understand the results?

Answer: [Yes]

Justification: Please see Sec. 5 and Appx. A.5.

Guidelines:

The answer NA means that the paper does not include experiments.

The experimental setting should be presented in the core of the paper to a level of detail that is necessary to appreciate the results and make sense of them.

The full details can be provided either with the code, in appendix, or as supplemental material.

7. Experiment Statistical Significance

Question: Does the paper report error bars suitably and correctly defined or other appropriate information about the statistical significance of the experiments?

Answer: [Yes]

Justification: We report mean accuracy (%) ± 95% confidence interval in Tabs.1, 2 and 4.

Guidelines:

The answer NA means that the paper does not include experiments.

The authors should answer "Yes" if the results are accompanied by error bars, confidence intervals, or statistical significance tests, at least for the experiments that support the main claims of the paper.

The factors of variability that the error bars are capturing should be clearly stated (for example, train/test split, initialization, random drawing of some parameter, or overall run with given experimental conditions).

The method for calculating the error bars should be explained (closed form formula, call to a library function, bootstrap, etc.)

The assumptions made should be given (e.g., Normally distributed errors).

It should be clear whether the error bar is the standard deviation or the standard error of the mean.

It is OK to report 1-sigma error bars, but one should state it. The authors should preferably report a 2-sigma error bar than state that they have a 96% CI, if the hypothesis of Normality of errors is not verified.

For asymmetric distributions, the authors should be careful not to show in tables or figures symmetric error bars that would yield results that are out of range (e.g. negative error rates).

If error bars are reported in tables or plots, The authors should explain in the text how they were calculated and reference the corresponding figures or tables in the text.

8. Experiments Compute Resources

Question: For each experiment, does the paper provide sufficient information on the computer resources (type of compute workers, memory, time of execution) needed to reproduce the experiments?

Answer: [Yes]

Justification: The information on the computer resources is discussed in Appx. A.5 and A.6.

Guidelines:

The answer NA means that the paper does not include experiments.

The paper should indicate the type of compute workers CPU or GPU, internal cluster, or cloud provider, including relevant memory and storage.

The paper should provide the amount of compute required for each of the individual experimental runs as well as estimate the total compute.

The paper should disclose whether the full research project required more compute than the experiments reported in the paper (e.g., preliminary or failed experiments that didn't make it into the paper).

9. Code Of Ethics

Question: Does the research conducted in the paper conform, in every respect, with the NeurIPS Code of Ethics https://neurips.cc/public/EthicsGuidelines ?

Answer: [Yes]

Justification: Yes, we do.

Guidelines:

The answer NA means that the authors have not reviewed the NeurIPS Code of Ethics.

If the authors answer No, they should explain the special circumstances that require a deviation from the Code of Ethics.

The authors should make sure to preserve anonymity (e.g., if there is a special consideration due to laws or regulations in their jurisdiction).

10. Broader Impacts

Question: Does the paper discuss both potential positive societal impacts and negative societal impacts of the work performed?

Answer: [NA]

Justification: There is no societal impact of the work performed and we cannot foresee any possible negative impacts, due to the highly technical nature of the task under consideration. Guidelines:

The answer NA means that there is no societal impact of the work performed.

If the authors answer NA or No, they should explain why their work has no societal impact or why the paper does not address societal impact.

Examples of negative societal impacts include potential malicious or unintended uses (e.g., disinformation, generating fake profiles, surveillance), fairness considerations (e.g., deployment of technologies that could make decisions that unfairly impact specific groups), privacy considerations, and security considerations.

The conference expects that many papers will be foundational research and not tied to particular applications, let alone deployments. However, if there is a direct path to any negative applications, the authors should point it out. For example, it is legitimate to point out that an improvement in the quality of generative models could be used to generate deepfakes for disinformation. On the other hand, it is not needed to point out that a generic algorithm for optimizing neural networks could enable people to train models that generate Deepfakes faster.

The authors should consider possible harms that could arise when the technology is being used as intended and functioning correctly, harms that could arise when the technology is being used as intended but gives incorrect results, and harms following from (intentional or unintentional) misuse of the technology.

If there are negative societal impacts, the authors could also discuss possible mitigation strategies (e.g., gated release of models, providing defenses in addition to attacks, mechanisms for monitoring misuse, mechanisms to monitor how a system learns from feedback over time, improving the efficiency and accessibility of ML).

11. Safeguards

Question: Does the paper describe safeguards that have been put in place for responsible release of data or models that have a high risk for misuse (e.g., pretrained language models, image generators, or scraped datasets)?

Answer: [NA]

Justification: The paper poses no such risks.

Guidelines:

The answer NA means that the paper poses no such risks.

Released models that have a high risk for misuse or dual-use should be released with necessary safeguards to allow for controlled use of the model, for example by requiring that users adhere to usage guidelines or restrictions to access the model or implementing safety filters.

Datasets that have been scraped from the Internet could pose safety risks. The authors should describe how they avoided releasing unsafe images.

We recognize that providing effective safeguards is challenging, and many papers do not require this, but we encourage authors to take this into account and make a best faith effort.

12. Licenses for existing assets

Question: Are the creators or original owners of assets (e.g., code, data, models), used in the paper, properly credited and are the license and terms of use explicitly mentioned and properly respected?

Answer: [Yes]

Justification: We have cited the original paper that produced the code package or dataset.

Guidelines:

The answer NA means that the paper does not use existing assets.

The authors should cite the original paper that produced the code package or dataset.

The authors should state which version of the asset is used and, if possible, include a URL.

The name of the license (e.g., CC-BY 4.0) should be included for each asset.

For scraped data from a particular source (e.g., website), the copyright and terms of service of that source should be provided.

If assets are released, the license, copyright information, and terms of use in the package should be provided. For popular datasets, paperswithcode.com/datasets has curated licenses for some datasets. Their licensing guide can help determine the license of a dataset.

For existing datasets that are re-packaged, both the original license and the license of the derived asset (if it has changed) should be provided.

If this information is not available online, the authors are encouraged to reach out to the asset's creators.

13. New Assets

Question: Are new assets introduced in the paper well documented and is the documentation provided alongside the assets?

Answer: [NA]

Justification: The paper does not release new assets.

Guidelines:

The answer NA means that the paper does not release new assets.

Researchers should communicate the details of the dataset/code/model as part of their submissions via structured templates. This includes details about training, license, limitations, etc.

The paper should discuss whether and how consent was obtained from people whose asset is used.

At submission time, remember to anonymize your assets (if applicable). You can either create an anonymized URL or include an anonymized zip file.

14. Crowdsourcing and Research with Human Subjects

Question: For crowdsourcing experiments and research with human subjects, does the paper include the full text of instructions given to participants and screenshots, if applicable, as well as details about compensation (if any)?

Answer: [NA]

Justification: No crowdsourcing or research with human subjects involved.

Guidelines:

The answer NA means that the paper does not involve crowdsourcing nor research with human subjects.

Including this information in the supplemental material is fine, but if the main contribution of the paper involves human subjects, then as much detail as possible should be included in the main paper.

According to the NeurIPS Code of Ethics, workers involved in data collection, curation, or other labor should be paid at least the minimum wage in the country of the data collector.

15. Institutional Review Board (IRB) Approvals or Equivalent for Research with Human Subjects

Question: Does the paper describe potential risks incurred by study participants, whether such risks were disclosed to the subjects, and whether Institutional Review Board (IRB) approvals (or an equivalent approval/review based on the requirements of your country or institution) were obtained?

Answer: [NA]

Justification: No crowdsourcing or research with human subjects involved.

Guidelines:

The answer NA means that the paper does not involve crowdsourcing nor research with human subjects.

Depending on the country in which research is conducted, IRB approval (or equivalent) may be required for any human subjects research. If you obtained IRB approval, you should clearly state this in the paper.

We recognize that the procedures for this may vary significantly between institutions and locations, and we expect authors to adhere to the NeurIPS Code of Ethics and the guidelines for their institution.

For initial submissions, do not include any information that would break anonymity (if applicable), such as the institution conducting the review.

Peer reviews:
{"IS_META_REVIEW": false, "comments": "SUMMARY:\nThe paper introduces DFA-GNN, a new framework designed to train Graph Neural Networks (GNNs) using Direct Feedback Alignment (DFA). Traditional methods like backpropagation (BP), though effective, have several limitations, including inefficiency, scalability issues, and a lack of biological plausibility. DFA-GNN aims to address these problems by utilizing a forward training mechanism specifically tailored for the unique challenges posed by graph data.\n\nSTRENGTHS:\nThe paper is well written and easy to follow.\n\nPerformance: DFA-GNN achieves better performance compared to other non-BP methods and even standard BP methods.\n\nRobustness: The framework exhibits resilience to noise and different types of attacks, ensuring its reliability in various scenarios.\n\nEfficiency: By enabling parallel gradient computation, DFA-GNN improves the efficiency of the training process.\n\nWEAKNESSES:\nThe novelty of this paper is somewhat limited as it primarily extends the principles of DFA to GNNs. The core ideas are based on the foundations laid out in the Shalizi et al. (2013) paper.\n\nThe paper lacks a discussion on the computational complexity of the proposed algorithm.\n\nThere is a notable variation in the performance improvements observed across different datasets. For instance, DFA-GNN shows a significant accuracy improvement on the Texas and Cornell datasets, while the improvements on other datasets are relatively modest. The paper does not adequately explain the reasons behind this variation in performance.\n\nThe dataset used for experiments is quite small.\n\nQUESTIONS:\nWhy the proposed method doesnot outperform on the computer and chameleon dataset.\n\nHow does DFA-GNN scale when applied to larger datasets e.g. flicker, Reddit, OBGN ?\n\nWhat is the time complexity of the proposed method?\n\nLIMITATIONS:\nNo societal impacts.", "TITLE": "Official Review", "RECOMMENDATION": 4, "REVIEWER_CONFIDENCE": 4, "SOUNDNESS_CORRECTNESS": 2, "DATE": "2024-07-12"}

{"IS_META_REVIEW": false, "comments": "SUMMARY:\nThe authors propose to apply the Direct Feedback Alignment (DFA) algorithm for backpropagation-free training to graph neural networks. The DFA algorithm is combined with a pseudo-error generation mechanism to provide additional error signals for missing targets in the setting of semi-supervised node classification. The experimental results with a 3-layer GCN model over 10 commonly adopted benchmarks show the proposed model performing generally better than backpropagation and other training algorithms. The ablation analysis confirms that improvements by the proposed DFA-GNN approach can be ascribed to the pseudo-error generation mechanism.\n\nSTRENGTHS:\n**Originality**\nThe application of DFA to GNNs was already introduced in *J. Launay, I. Poli, F. Boniface, and F. Krzakala, “Direct feedback alignment scales to modern deep learning tasks and architectures,” NeurIPS 2020*. However, the addition of pseudo-error generation and the extensive experiments are entirely novel contributions.\n\n**Quality**\nThe submission is technically sound and its claims are well supported.\n\n**Clarity**\nThe paper is clearly written and well organized.\n\n**Significance**\nThe results of this paper can contribute to the research on addressing the training challenges of deep graph neural networks.\n\nWEAKNESSES:\n1. The computational cost per epoch of the proposed algorithm is 5 to 10 times larger than backpropagation.\n2. No comparison of the overall training costs, including the different number of epochs required for training convergence among the different methods.\n3. The ablation indicates that the accuracy improvements are ascribed to the pseudo-error propagation mechanism. As the latter could be applied also to e.g. backpropagation, such experimental evaluation would have provided further interesting insights.\n4. In the experiments the model is limited to 3 layers; deeper models would have provided more interesting insights, as depth increases the issues connected with gradient backpropagation. (Long-range graph benchmarks such as those from *V. P. Dwivedi et al., “Long Range Graph Benchmark,” in NeurIPS 2022 Track on Datasets and Benchmarks* could be adopted in this case.)\n5. Only node classification tasks are considered, no graph-level or edge-level tasks.\n\nQUESTIONS:\n1. Why is pseudo-error generation spreading, which must be done at teach gradient update iteration, instead of augmenting training labels via label spreading (plus the masking of eq. (9)), which would be only required once?\n2. How would the other training methods such as backpropagation perform with pseudo-error generation spreading?\n3. How many epochs are required for training convergence by DFA-GNN? How do they compare with the number of epochs required by the other training algorithms?\n\nLIMITATIONS:\nThe limitations of this submission have not been properly discussed. For example, in lines 278-280, it is stated that the \"method has a higher training time consumption compared with BP, primarily due to the additional time needed for generating pseudo errors and filtering masks\". However, in the conclusions, it is claimed that *efficiency* is one of the advantages of the proposed method.", "TITLE": "Official Review", "RECOMMENDATION": 6, "REVIEWER_CONFIDENCE": 4, "SOUNDNESS_CORRECTNESS": 3, "DATE": "2024-07-13"}

{"IS_META_REVIEW": false, "comments": "SUMMARY:\nRecently, some studies have been exploring new optimization methods that can replace backpropagation, and one of the popular methods is direct feedback alignment (DFA). This paper adapts DFA to graph neural networks (GNNs). It replaces the gradient with a randomly initialized matrix multiplying the prediction error, so that we do not need to use backpropagation to update the parameters. We can directly update the model parameters based on the prediction error. Besides, for semi-supervised graphs where the label is scarce, we only have prediction errors for a few nodes, so the parameter update is not that effective. To overcome this drawback, the paper assumes that nearby nodes have similar prediction errors, so it uses a smoothing technique to generate pseudo prediction errors for unlabeled nodes.\n\nSTRENGTHS:\n(1) The studied problem is very interesting. The non-backpropagation optimization method is a very new field.\n\n(2) The method design is good. Though it is an adaptation of direct feedback alignment (DFA) which has been used for Euclidean data, since this area has been rarely studied, I think the adaptation is also a contribution.\n\n(3) There are some theories supporting the method.\n\n(4) Extensive experiments verify its effectiveness, and it can outperform backpropagation.\n\nWEAKNESSES:\n(1) In Formula (4), it ignores the activation function when calculating the parameter update. Since the activation function is ReLU, ignoring it might not cause a big problem. However, when we apply other activation functions, or when we use a complex GNN architecture, I am afraid this method might not work as well.\n\n(2) From Table 1, we can see that DFA achieves the best performance, while backpropagation is also very good on some datasets. I encourage the authors to add some discussions about when the proposed method is more useful than backpropagation, on what kinds of datasets, and what kinds of GNN models. Besides, the authors explained why DFA is better than previous non-backpropagation methods in Lines 254-274, but it would be better if the authors could explain why DFA is better than backpropagation.\n\n(3) The authors can consider introducing a little more about the limitations of backpropagation and the non-backpropagation optimization methods in the introduction or related work. Since most readers are not familiar with non-backpropagation optimization methods, it deserves more introduction.\n\n(4) The authors can improve some notations and make them clearer. For example, in Formula (5), the multiplication of $B^{(2)}$ and $B^{(1)}$ is written as $B^{(1)}$.\n\nQUESTIONS:\n(1) What is $W$ in Formula (7)?\n\n(2) In Section 4.3, the authors point out that W will converge to be similar to B. Since B is randomly initialized, if B is at a high point in the loss landscape, then will the optimization fail? Is the randomness of B important to the performance?\n\n(3) I might have not fully understood the intuition behind DFA. I am confused about why DFA performs better than backpropagation. I look forward to intuitive explanations.\n\n(4) Table 6 shows that all the non-backpropagation methods require more time than backpropagation. If I have correctly understood, DFA can directly calculate the parameter update for every layer from the loss, so it does not need to calculate the parameter update layer by layer as in backpropagation, then why does it need more time than backpropagation?\n\nLIMITATIONS:\nThe authors have discussed the limitations. I encourage the authors to further explain what kinds of datasets and what kinds of GNN models DFA is most suitable for.", "TITLE": "Official Review", "RECOMMENDATION": 6, "REVIEWER_CONFIDENCE": 2, "SOUNDNESS_CORRECTNESS": 3, "DATE": "2024-07-16"}