# Analyzing the Effect of Sampling in GNNs on Individual Fairness

Rebecca Salganik  Universite de Montreal/MILAMontrealQuebecCanada
<EMAIL_ADDRESS>,  Fernando Diaz
Google/MILAMontrealQuebecCanada<EMAIL_ADDRESS>and  Golnoosh Farnadi
HEC/Universite de Montreal/MILAMontrealQuebecCanada<EMAIL_ADDRESS>
(2018)

###### Abstract.

In recent years, graph neural network (GNN) based methods have saturated the
field of recommender systems. The gains of these systems have been
significant, showcasing the advantages of interpreting data through a network
structure. However, despite the noticeable benefits of using graph structures
in recommendation tasks, this representational form has also bred new
challenges which exacerbate the complexity of mitigating algorithmic bias.
When GNNs are integrated into downstream tasks, such as recommendation, bias
mitigation can become even more difficult. Furthermore, the intractability of
applying existing methods of fairness promotion to large, real world datasets
places even more serious constraints on mitigation attempts. As such, our work
sets out to fill in this gap by taking an existing method for promoting
individual fairness on graphs and extending it to support mini-batch, or sub-
sample based, training of a GNN, thus laying the groundwork for applying this
method to a downstream recommendation task. We evaluate two popular GNN
methods: Graph Convolutional Network (GCN), which trains on the entire graph,
and GraphSAGE, which uses probabilistic random walks to create subgraphs for
mini-batch training, and assess the effects of sub-sampling on individual
fairness. We implement an individual fairness notion called REDRESS, proposed
by Dong et al., which uses rank optimization to learn individual fair node, or
item, embeddings. We empirically show on two real world datasets that
GraphSAGE is able to achieve, not just, comparable accuracy, but also,
improved fairness as compared with the GCN model. These finding have
consequential ramifications to the fields of individual fairness promotion,
GNNs, and in downstream form, recommender systems, showing that mini-batch
training facilitate individual fairness promotion by allowing for local nuance
to guide the process of fairness promotion in representation learning.

Graph Neural Networks, Algorithmic Fairness, Individual Fairness

††copyright: acmcopyright††journalyear: 2018††doi: XXXXXXX.XXXXXXX††journal:
JACM††journalvolume: 37††journalnumber: 4††article: 111††publicationmonth:
8††price: 15.00††isbn: 978-1-4503-XXXX-X/18/06††ccs: Computing methodologies
Structured outputs††ccs: Computing methodologies Batch learning

##  1\. Introduction

As our consumption habits shift towards online spaces, recommender systems are
slowly becoming the gatekeepers between producers and consumers within a wide
array of domains. In recent years, the field of recommender systems has become
saturated with one particular form of representation learning: graph neural
networks (GNNs) (Wu et al., 2020; Zhang et al., 2020; Quadrana et al., 2018;
Guo et al., 2022; Da’u and Salim, 2019; Chicaiza and Díaz, 2021). The key
advantage which distinguishes GNNs from other representation learning methods
is their ability to leverage not just the information embedded in the features
associated with each data point, but also the information which can be
extracted from their interactions (Wu et al., 2021b). However, in parallel to
the proliferation of this important architecture, has come a rising level of
concern that GNNs come with their own set of unique challenges when it comes
to mitigating algorithmic bias. Findings indicating perpetuation or
exponentiation of societal biases at the hands of other deep learning models
have prompted similar questions in the field of GNNs, specifically as applied
to recommender systems (Chen et al., 2020). As such, the integration of these
architectures into recommender systems can have very real, negative
consequences on the experiences of both producers and consumers who interact
with the recommender system. Without developing bias mitigation strategies for
GNN’s we cannot properly ameliorate the biases in downstream tasks, such as
recommendation.

Within the algorithmic fairness community, there have been several major
thrusts, each associated with a broad definition of what it means to engage
with fairness from a mathematical perspective (Dwork et al., 2011; Kusner et
al., 2017; Kleinberg et al., 2016). The focus of this work is centered on the
notion of individual fairness (Dwork et al., 2011). This notion dictates that
”similar individuals should be treated similarly by an algorithmic system“.
Intuitively, promotion of this notion can begin to address problematic
discrepancies between the treatment of different consumer and producer groups
in the recommendation space (Ekstrand et al., 2018). Recent works that apply
individual fairness notions to GNNs take different perspectives on similarity
(Lahoti et al., 2019; Kang et al., 2020; Dong et al., 2021). In particular,
REDRESS, one such fairness framework, proposed by Dong et al. (2021), frames
individual fairness from a ranking perspective. This makes the approach
particularly appealing to integration with a downstream task of
recommendation.

Our main contribution addresses one of the key limitations of REDRESS (Dong et
al., 2021). The use of a Graph Convolutional Network (GCN) (Kipf and Welling,
2016) as a backbone GNN model severely limits the ability of this method to
scale to large datasets. As such, our work expands the proposed REDRESS
framework to support sub-sampling methods and assesses the effects of this
subsampling on the global individual fairness of the final embeddings. We re-
implement the methodology proposed by Dong et al. and add our own
implementation of a modified GraphSAGE (Hamilton et al., 2017) which is
compatible with individual fairness promotion. Our empirical evaluation on two
real world datasets shows that the use of subsampling can drastically improve
the individual fairness exhibited in the final embeddings. In doing so, we
uncover a connection between neighborhood selection and individual fairness
promotion.

##  2\. Related Work

In this section we lay the groundwork for the various facets of work which
play a crucial role in shaping the contribution and relevance of ours. First,
we introduce the role that GNNs play in recommender systems. In doing so, we
motivate the relevance of our approach to the recommendation space. Then, we
introduce the need for feasible individual fairness notions which can be
applied to ameliorate issues of bias in recommender systems. In this
discussion, we highlight the ways in which our specific fairness framework,
REDRESS (Dong et al., 2021), can be applied to a recommendation setting. We
follow this with a discussion of other individual fairness frameworks that
have been applied to GNNs. Our discussion contrasts the other approaches with
REDRESS, showcasing its intuitive connections with item-item relevance.
Finally, we introduce the importance of sub-sampling in GNN mini-batch
training. We position our work in relation to other surveys which explore the
relation between sub-sampling and utility gains. In doing so, we highlight the
crucial contribution of our work: the connection between sub-sampling and
individual fairness promotion.

GNNs in Recommender Systems: One of the main factors which cements the success
of GNN techniques in the recommendation domain is their ability to capture
both context and content based patterns (Wu et al., 2020). This enables GNNs
to encode crucial collaborative signals embedded in a network of users and/or
items as well as individual information about items and users themselves. The
basis of taste and affinity for an item can be expressed both contextually,
via our social circles, and individually, via our interactions with the item
itself. As such, GNNs ability to capture both these sources of information
enable them to build profoundly complex and robust representations of users
and items.

The motivation behind our selection of GraphSAGE (Hamilton et al., 2017) as a
comparison method with the original GCN architecture proposed by Dong et al.
is its achievements within the recommender system domain. PinSage (Ying et
al., 2018), proposed by the authors of GraphSAGE one year after its initial
release, is designed as a downstream extension of GraphSAGE to recommendation
tasks. In terms of its architecture, PinSage remains essentially the same as
GraphSAGE, with a slight modification to the neighborhood selection method,
which uses importance pooling to refine the random walks based on the
probability of a node’s occurrence. After generating item and used embeddings
using the iterative representation learning procedure of GraphSAGE, PinSage
performs recommendation based on the k-nearest neighbors of an item or a user
in the learned embedding space. As such, by implementing fairness in
GraphSAGE, we lay the foundations for easily extending this approach to the
recommendation task via PinSage.

The Need for Individual Fairness in Recommender Systems: One of the major
issues which plagues the field of recommendation is popularity, or exposure
bias (Chen et al., 2020). This phenomenon occurs when users are only exposed
to a portion of the available items. Frequently, this exposure is prioritized
in the favor of previously popular items, leaving niche or new items to be
neglected in negative feedback loop which catapults some items to superstar
popularity (Bauer et al., 2017) and leaving others languishing in obscurity.
This issue has a plethora of negative downstream consequences. First, it
deteriorates the overall quality of predictions if a recommender system is
able to serve only the needs of a mainstream audience. Second, it can create
unfairness among consumers since not all consumption reflect mainstream tastes
(Ekstrand et al., 2018). Finally, it can have very real, extremely negative
consequences on the financial prospects of producers (Zhu et al., 2021),
affecting their ability to create content, services, or merchandise.

Despite a wide range of works approaching exposure and popularity bias from
the perspectives of group fairness (Li et al., 2021a; Ekstrand et al., 2018)
and counterfactual fairness (Li et al., 2021b; Zhang et al., 2021), the
granularity of individual fairness makes the promotion of this notion
significantly more difficult. One of the benefits of the REDRESS (Dong et al.,
2021), the approach we incorporate into our work, is its flexibility in
defining what features/structure is used to define similarity among items (see
Section 4.3 for more details). For example, in the musical domain, if two
songs sound extremely similar then, by selecting the portion of their feature
set that defines their sound qualities, we can promote similarity between the
two songs and regularize for inconsistencies based on the popularity of their
respective primary artists.

Individual Fairness in Graphs: In the broader discussion of fairness in
machine learning, the tasks of promoting fairness is often broken into the
three stages of a training pipeline: pre-processing (model), in-processing
(during training, through regularization, constrained optimization, or novel
loss functions), and post-processing (outcome generation). Fairness in graph
representation learning follows a similar break down: fairness in the initial
graph (Kang et al., 2020), fairness in the mining (or representation building)
algorithm (Bose and Hamilton, 2019; Lahoti et al., 2019; Arduini et al., 2020;
Dong et al., 2021), and fairness in the final representations (or other
downstream outcomes) (Kang et al., 2020). Lastly, the approaches used can also
be loosely categorized based on their fairness notions: group (Chierichetti et
al., 2018; Bose and Hamilton, 2019; Dong et al., 2022; Arduini et al., 2020),
individual (Dong et al., 2021; Lahoti et al., 2019; Kang et al., 2020), and
counterfactual (Ma et al., 2022) fairness techniques.

Since the focus of this work is individual fairness, we will now detail some
of the most relevant individual fairness notions for GNNs. In their work, Kang
et al. convert the premise of a Lipshitz condition into the graph domain (Kang
et al., 2020). They define individual fairness as a trace maximization problem
bounded by a fairness tolerance, $\delta$. They break the task of promoting
individual fairness into three steps offering three different approaches to
satisfy the notion defined above: 1. Pre-processing the input graph 2. In-
processing within the model, or 3. Applying post processing on the generated
representations. However, due to its reliance on the graph laplacian for
defining fairness, unlike our selected method, REDRESS (Dong et al., 2021),
the methodology proposed by Kang et al. does not lend itself well to the
recommendation setting due to the nature of their fairness definition.
Furthermore, in their paper, Dong et al. show that REDRESS outperforms InFoRm
in empirical studies (Dong et al., 2021).

Meanwhile, Lahoti et al. take a different understanding of individual fairness
(Lahoti et al., 2019). Their Pairwise Fair Representation (PFR) model uses a
sparse fairness graph with expert defined pairwise similarities to learn fair
representations. Similar to the previous method, the methodology proposed by
Lahoti et al does not easily lend itself to the recommendation setting. Unlike
REDRESS which is able to perform both link prediction and node classification,
Pairwise Fair Representations (PFR) is an unsupervised learning method which
is unable to perform link prediction.

Sampling Methods in GNNs: Despite the significant advances achieved by the GCN
architectures, there are a few drawbacks to this method. The training regime
used by this architecture, which performs full-batch training on the entire
graph, has two major limitations: efficiency and scalability. Holding an
entire graph in memory whilst performing complex iterative convolutions makes
training a GCN on large graphs essentially intractable (Liu et al., 2021). As
such, a series of modifications have been proposed which enable the use of
mini-batch training while maintaining the expressive properties of a GCN’s
convolutional representation building (Hamilton et al., 2017; Ying et al.,
2018; Huang et al., 2018; Chen et al., 2018; Zou et al., 2019; Chiang et al.,
2019; Zeng et al., 2019). The variety of these sampling methods and their
effects on accuracy and performance have been well documented both empirically
(Liu et al., 2021; Wang et al., 2021) and theoretically (Cong et al., 2021).
As mentioned in our introduction of the REDRESS (Dong et al., 2021) framework,
and explored with more detail in Section 4, the primary drawback of this
method is its reliance on the GCN methodology. By exploring the effects of
subsampling with respect to individual fairness, we differentiate our findings
from the various surveys that have assessed subsampling through the lens of
utility performance.

##  3\. Graph Neural Networks

In this section, we review several key preliminary topics which are necessary
for the discussion for understanding our discussion of REDRESS in Section 4.
Advances in the field of GNNs have come in leaps and bounds within the last
decade. Here, we briefly review the two methods integral to our work: GCN
(Kipf and Welling, 2016) and GraphSAGE (Hamilton et al., 2017). For a detailed
overview of GNN methods, we refer to the survey paper by Wu et al. (Wu et al.,
2021b) and a textbook by Hamilton (Hamilton, 2020).

Given graph data, a GNN iteratively collects feature information from the
neighbors of a node and integrates this information into the representation of
the node. As such, the basic structure of a GNN can be abstracted into two
functions, UPDATE and AGGREGATE. Here, AGGREGATE refers to the process of
gathering the neighborhood nodes and UPDATE refers to the procedure used to
update a node’s embedding with respect to its neighborhood feature set. Thus,
the GNN process of training embeddings, is based on the interactions between
these two processes. At each iteration $k$ of training, the AGGREGATE function
takes the embeddings of $u$’s neighbors, $v\in N(u)$, to generate a message
which the UPDATE function combines with the previous embedding of node $u$,
$h_{u}^{(k-1)}$, to generate the updated embedding $h_{u}^{(k)}$. This process
can be formalized as follows:

(1) $\displaystyle
h_{u}^{(k)}=\textit{UPDATE}^{(k-1)}\biggl{(}h_{u}^{(k-1)},\textit{AGGREGATE}^{(k-1)}\left(\\{h_{v}^{(k-1)},\forall
v\in N(u)\\}\right)\biggr{)}$

More formally, this can be expressed as:

(2) $\displaystyle
h_{u}^{(k)}=\sigma\biggl{(}W_{self}^{(k)}h_{u}^{(k-1)}+W_{neigh}^{(k)}\sum_{v\in
N(u)}h_{v}^{(k-1)}+b^{(k)}\biggr{)}$

where
$W_{\text{self}}^{(k)},W_{\text{neigh}}^{(k)}\in\mathbb{R}^{d^{(k)}\times
d^{(k-1)}}$ are trainable parameter matrices, $b^{(k)}$ is the bias term, and
$\sigma$ is a non-linear activation function (in our experimentation we use
ReLU (Agarap, 2018)).

####  3.0.1. GCN

The GCN method proposed by Kipf and Welling (Kipf and Welling, 2016) is unique
because of its use of neighborhood normalization. Rather than simply
aggregating over all the feature vectors of the neighborhood nodes, which can
lead to instability, the neighboring feature set is first normalized.

(3) $\displaystyle h_{u}^{(k)}=\sigma\biggl{(}W^{(k)}\sum_{\\{v\in
N(u)\\}\bigcup\\{u\\}}\frac{h_{v}}{\sqrt{|N(u)||N(v)|}}\biggr{)}$

####  3.0.2. GraphSAGE

GraphSAGE (Hamilton et al., 2017) makes two major changes to the methodology
proposed by GCN: neighborhood selection and aggregation. First, unlike GCN
which integrates information from the all the neighbors of a node, GraphSAGE
randomly samples p neighbours from the surrounding neighborhood (i.e.,
$N_{p}(u)$). Second, unlike GCN, which normalizes based on the degree of the
neighborhood nodes, GraphSAGE averages the embeddings of the neighborhood
feature set before integrating them with the representation of the current
node. As such, this can be expressed as:

(4) $\displaystyle
h_{u}^{(k)}=\sigma\biggl{(}W^{(k)}\cdot\text{MEAN}\Bigl{(}\\{h_{u}^{(k-1)}\\}\bigcup\\{h_{v}^{(k-1)},\forall
v\in N_{p}(u)\\}\Bigr{)}\biggr{)}$

where the MEAN aggregator is the elementwise mean over the feature vectors,
$h_{v}^{(k)}$ for all the neighboring nodes, $v\in N(u)$.

##  4\. Rank Based Individual Fairness in GNNs

In this section, we review the individual fairness notion called _REDRESS_
which is introduced by Dong et al. (Dong et al., 2021). We then show how
REDRESS can be implemented within the end-to-end training paradigm of a GNN.

###  4.1. REDRESS

Our problem definition is couched in the graph setting. We are given a graph,
$G=(V,E)$, with a node set, $V$, and edge set, $E$. Our setting also involves
a set of node-level features, $X\in\Re^{|V|\times d}$ where $d$ is the
dimension of each feature vector. Our current task involves training a GNN
model, $\mathcal{M}$, to perform the task of link prediction. In this setting,
$Y$ and $\hat{Y}$ represent the ground truth and learned node representations.
However, this methodology can easily be extended to the recommendation setting
by treating the nodes $v\in V$ as items and attempting to predict items which
are similar to each other, while maintaining individual fairness among them.
By training a model, $\mathcal{M}$ on graph, $G$, we can learn a series of
representations for each node, or item, $\hat{Y}\in\Re^{|V|\times m}$ where
$m$ represents the dimension of the final hidden layer in model,
$\mathcal{M}$.

The fairness notion used in this work is based on the framework proposed by
Dong et al. (Dong et al., 2021). This fairness notion, which bases itself on
ranking, is extremely well suited to recommendation tasks due to its innate
interlacing with item to item relevance. We begin by explaining this notion
intuitively and follow with a formal definition:

For each node pair $u,v$ in a graph $G$, we can define their similarity,
$s_{u,v}$ based on some similarity metric $s(.,.)$ in which we input their
initial feature vector, $X[v]\in\Re^{d}$ or learned embedding,
$\hat{Y}[v]\in\Re^{m}$. Applying this procedure in a pairwise fashion, we can
derive two matrices. The first is termed the apriori or oracle similarity,
$S_{G}$, in which similarity is based on some initial feature based,
structural, or expert defined vectors which are independent of the GNN model,
$M$. The second is termed the learned representation similarity,
$S_{\hat{Y}}$, in which similarity is based on a learned embedding generated
by the training process of a GNN model, $M$. Using these similarity matrices,
we can generate two lists which rank each node with respect to the others.
Individual fairness is upheld in this setting if the respecting orderings of
nodes in each ranked list is consistent. That is, items which were ordered
based on similarity before training, will maintain the same similarity
ordering in their embedding space. Formally, we can express this in the
following definition:

###### Definition 4.1.

(REDRESS: Individual fairness). Given some similarity metric $s(.,.)$, an
apriori pairwise similarity matrix, $S_{G}\in\Re^{|V|\times|V|}$, and a
learned pairwise similarity matrix, $S_{\hat{Y}}\in\Re^{|V|\times|V|}$,
defined by applying $s(.,.)$ to the learned graph representations, $\hat{Y}$,
we say the predictions are individual fair if for each each instance $i$, the
ranked list generated from $S_{\hat{Y}}$ is consistent with the ranked list
generated from $S_{G}$.

###  4.2. REDRESS Fairness Construction

Minimizing the differences between the two ranked lists can be seen as a form
of ranking optimization. In order to formulate this task as a differentiable
operation, we can draw on the work in the field of learning to rank (Burges et
al., 2006) to formulate loss based on a probabilistic approach. Using these
matrices, $S_{G}$ and $S_{\hat{Y}}$, we define two probability matrices,
$P\in\Re^{|V|\times|V|\times|V|}$ and $\hat{P}\in\Re^{|V|\times|V|\times|V|}$.
In essence, for every node $u_{i}$, we can define its similarity with two
neighboring nodes $u_{j},u_{m}$ as $s_{i,j}$ and $s_{i,m}$ in the case of
$S_{G}$ or $\hat{s}_{i,j}$ and $\hat{s}_{i,m}$ in the case of $S_{\hat{Y}}$.
Using these values, the matrices $P$ and $\hat{P}$ codify the probability
$P_{j,m}(s_{i,j},s_{i,m})$ that node $u_{i}$ is more similar to node $u_{j}$
than $u_{m}$.

Thus, for each individual node, $u_{i}$ and two other nodes selected from the
remaining graph, $u_{j},u_{m}$, the embedding based matrix, $\hat{P}$ is
defined as:

$\hat{P}_{j,m}(\hat{s}_{i,j},\hat{s}_{i,m})=\frac{1}{1+\exp\Bigl{(}{-\alpha(\hat{s}_{i,j}-\hat{s}_{i,m)}}\Bigr{)}}$

where $\alpha$ is a scalar which can be treated as a hyperparameter.
Similarly, the feature based matrix, $P$ can be defined as:

$P_{j,m}(s_{i,j},s_{i,m})=\begin{cases}1&s_{i,j}>s_{i,m}\\\
0.5&s_{i,j}=s_{i,m}\\\ 0&s_{i,j}<s_{i,m}\end{cases}$

###  4.3. Training Individually Fair Embeddings

In defining these matrices, we can now train for fairness by using standard
cross entropy loss. For a node $i$, we define:

(5) $\displaystyle L_{j,m}(i)$
$\displaystyle=-P_{j,m}\log\hat{P_{j,m}}-(1-P_{j,m})\log(1-\hat{P_{j,m}})$

And over all the nodes $i\in V$:

(6) $\displaystyle L_{fairness}=\sum_{i}\sum_{j,m}L_{j,m}(i)$

Finally, in order to ease the computational complexity, we can add a weighing
factor based on the changes in NDCG to restrict our modifications to changes
in the top k values of each ranked list. Once we define $z_{@k}(.,.)$ as
NDCG@k, we can express the fairness loss as:

(7) $\displaystyle L_{fairness}=\sum_{i}\sum_{j,m}L_{j,m}(i)|\triangle
z_{@k}|_{j,m}$

where $\triangle$ represents the change in NDCG between the two lists.

The broad process of training occurs using two stages: utility based loss and
utility + fairness based loss. The utility loss, $L_{utility}$, is the classic
cross entropy loss:

(8) $\displaystyle L_{utility}=-\sum_{u,v\in G}Y_{uv}ln\hat{Y}_{uv}$

and the joint utility + fairness loss can be defined as:

(9) $\displaystyle L_{total}=L_{utility}+\gamma L_{fairness}$

where $\gamma$ is a scalable hyperparameter which controls the focus given to
fairness. By using the NDCG metric, commonly used in ranking and
recommendation tasks, REDRESS formulates a fairness loss that is,
intrinsically, performing the relevance/fairness balance that is so important
to developing novel bias mitigation techniques in recommendation settings.
Furthermore, by creating a loss which can easily interpolate between utility,
or relevance, and fairness, REDRESS follows methodology very similar to a
large body of work in recommendation fairness (Wu et al., 2021a; Mehrotra et
al., 2018). .

##  5\. Experiments

In this section, we evaluate two implementations of REDRESS, comparing the
results between GCN and GraphSAGE as the backbone model, $\mathcal{M}$. This
section shows the effectiveness of sub-sampling on utility and fairness
through empirical evaluations on two widely known real world benchmark
datasets: BlogCatalog (Tang and Liu, 2009a) and Flickr (Tang and Liu, 2009b).
Table 1 presents the statistics of these two datasets.
The code and data used to obtain these results can be found at FacctRec2022
Github Repository.

Dataset | # Nodes | # Edges | # Features
---|---|---|---
BlogCatalog (Tang and Liu, 2009a) | 5,196 | 171,743 | 8,189
Flickr (Tang and Liu, 2009b) | 7,575 | 239,738 | 1,406
Table 1. Dataset Statistics

Experiments are implemented in Python using the Pytorch compatible version of
DGL (Wang et al., 2019). In order to remain faithful to the validation splits
used in the REDRESS experiments, we split the dataset using 40% of the edges
for train, 40% for validation, and 20% for test. For the GCN implementation,
we used the hyperparameter settings which had been fine-tuned by Dong et al.
During hyperparameter tuning for GraphSAGE, we used grid search to explore
learning rates $\sim$ (0.0001, 0.001, and 0.1), negative sampling of (1, 3 and
5) edges per positive edge, dropout of $\sim$ (0.0, 0.01, 0.03), weight decay
of either (0.0, 0.001, or 0.003), warmup epochs of (30, 60, 100, 120) and
fairness epochs of (30, 60, 100). Finally, to enable valid comparison with the
results attained in REDRESS (Dong et al., 2021), we performed PCA with 200
components to lower the dimensionality of the feature sets before assigning
them to each node.

The best GraphSAGE results for both BlogCatalog and Flickr are achieved using
2 layers of convolutions, a hidden size of $256$, a learning rate of $0.001$,
no dropout, $30$ epochs of ”warm up” (utility only) training followed by $60$
epochs of utility + fairness training, and a batch size of $32$. In both
cases, the best neighborhood size performance was achieved using the smallest
neighborhood tests. In the case of BlogCatalog, this was a neighborhood of
size 5 (per layer) and in the case of Flickr, this was a neighborhood of size
10 (per layer).

Similarity Notions: We use the cosine similarity metric (Khatter et al., 2021)
to define both the apriori and prediction matrices $S_{G}$ and $S_{\hat{Y}}$,
respectively. The purpose of selecting this method is to combine the idea of
individual characteristics native to individual fairness with a commonly used
similarity measure within the recommendation domain. More specifically, cosine
similarity is a feature based metric which measures the distance between items
in their feature or embedding space. Note that, although this method is
flexible to selecting only portions of the feature set to define similarity,
in our experiments we use the entire feature set when defining cosine
similarity between node pairs.

Please note that in order to allow for valid comparison between the results
listed in the REDRESS paper and the results which we have achieved, we re-run
their implementation with a $\gamma=1$ for both architectures. As such, the
results we are listing here do not reflect the results listed in their paper
(since they are using $\gamma$ values which have been fine-tuned to balance
utility and fairness).

Neighborhood Selection: We extensively test various neighborhood sizes of
GraphSAGE, motivating the importance of neighborhood selection on fairness
promotion. As shown in Table 4, we compare neighborhood sizes of 35, 30, 25,
10, and 5 for subsampling of a 2-hop subgraph in GraphSAGE mini-batch
training.

Evaluation Metric In order to evaluate the performance of the two models on
each dataset, we use the area under receiver operating curve (AUC) metric.
Meanwhile, in order to evaluate the fairness performance, we calculate the
NDCG@10 (Järvelin and Kekäläinen, 2002) between the apriori similarities,
$S_{G}$ and learned representation similarities, $S_{\hat{Y}}$ averaged over
all the nodes (see Appendix A for more details).

##  6\. Results

We investigate four research questions in our experiments:

RQ1: How does the selection of sub-sampling technique affect fairness
promotion? As shown in Table 2, we can see that GraphSAGE not only meets, but
exceeds the performance achieved by the GCN method proposed in REDRESS (Dong
et al., 2021) even before the bias mitigation loop (see Vanilla GraphSAGE vs
REDRESS GraphSAGE). For example, when looking at the experiments run on the
Flickr data, the GCN method with REDRESS fairness promotion is able to achieve
a maximum fairness of 20.38 using Cosine similarity but GraphSAGE, without
mitigation, achieves 30.24. This shows that even the use of sub-sampling is
beneficial for individual fairness. Similarly on the BlogCatalog dataset, the
REDRESS GCN achieves a maximum fairness of 19.64 using Cosine similarity,
while Vanilla GraphSAGE achieves 29.95 and REDRESS GraphSAGE achieves 52.02.
Intuitively, we believe that this finding can be attributed to the size of
neighborhood which is being used to define individual fairness. In training
over an entire graph, we are attempting to fix all the discrepancies in the
ranked list between disparate areas of the graph. However, it is possible that
the features, or structural elements, affecting fairness have local
variations, which are too granular to notice when training over the entire
graph. By training over a smaller sub-graph, we are able to use local nuances
to fine-tune the embeddings towards individual fairness. See RQ4 for more
detailed experiments and explanations.

|  | Cosine |
---|---|---|---
Data | Model | AUC | Fairness |
BlogCatalog | Vanilla GCN | 86.75 (-) | 16.60 (-) |
| REDRESS GCN | 64.15 (-26%) | 19.64 (+18%) |
| Vanilla GraphSAGE | 90.86 (-) | 29.95 (-) |
| REDRESS GraphSAGE | 71.27 (-21%) | 52.02 (+73%) |
Flickr | Vanilla GCN | 86.16 (-) | 16.72 (-) |
| REDRESS GCN | 63.31 (-26%) | 20.38 (+21%) |
| Vanilla GraphSAGE | 85.80 (-) | 30.24 (-) |
| REDRESS GraphSAGE | 64.09 (-25%) | 41.51 (+37%) |
Table 2. Results for both BlogCatalog and Flickr. Note: the small values in
parenthesis indicating a ($+/-$ %) are meant to indicate the change between a
utility based model (such as Vanilla GCN) and a fairness promoting model (such
as REDRESS GCN)

RQ2: How does the selection of model affect the training time? As shown in
Table 2, GraphSAGE is able to achieve improved performance on both utility and
fairness metrics. In addition, as shown in Table 3, the mini-batch training
protocol of GraphSAGE enables it to train for significantly less epochs than
GCN. For example, on Flickr, GCN required 200 epochs of pre-training (utility
based) and 100 epochs of integrated fairness training to achieve it maximal
results. Meanwhile, on the same dataset, GraphSAGE required only 30 epochs of
pre-training and 60 epochs of fairness training. Similarly for BlogCatalog,
GCN required 200 epochs of pretraining and 60 epochs of fairness training,
while GraphSAGE required only 30 pretraining epochs and 60 fairness training
epochs. For the sake of comparison, we selected minimally sized graphs (less
then 100K nodes) to allow for a valid comparison between GCN and GraphSAGE.
The intractability of training a GCN on a larger graph has been heavily
documented among the graph community (Liu et al., 2021; Cong et al., 2021).

|  | Cosine |
---|---|---|---
Data | Model | Pre-training epochs | Fairness training epochs |
BlogCatalog | GCN | 200 | 60 |
| GraphSAGE | 30 | 60 |
Flickr | GCN | 200 | 100 |
| GraphSAGE | 30 | 60 |
Table 3. Number of Epochs to Achieve Maximal Fairness Performance

RQ3: How does the fairness promotion affect the utility performance of
GraphSAGE? As shown in Table 2, we can see that with both GCN and GraphSAGE,
the promotion of individual fairness leads to a drop in utility performance.
For example, in BlogCatalog, the rounds of cosine similarity based fairness
training caused the GCN model’s performance to drop by 26% while GraphSAGE
dropped by 21%. Given the formulation of the fairness and utility losses, this
balance, between utility and fairness, can be managed by tuning the
hyperparameter for $\gamma$ in the loss function (see 4.3 for more details).
We leave the experimentation of hyperparameter tuning for future work.

RQ4: How does the neighborhood selection affect the ability of GraphSAGE to
promote individual fairness? As shown in the discussion of the previous
research questions, there is a noticeable improvement in GraphSAGE over GCN
for the promotion of individual fairness. We hypothesize that this differences
is rooted in the mini-batch training. GraphSAGE’s mini-batch training, uses a
sampled sub-graph, while GCN uses the entire graph. We believe that the
noticeably smaller neighborhood size used in GraphSAGE updates can allow for
better fine-tuning of fairness in the representation learning. This is because
the features which affect fairness can potentially differ between disparate
areas of the graph. In order to test this hypothesis, we perform experiments
with 5 neighborhood allocations. As mentioned in 3.0.2, GraphSAGE selects a
neighborhood by randomly sampling p neighbors from its surrounding
neighborhood. As shown in Table 4, we can see that as the neighborhood size
grows, the fairness performance drops. Thus, showing a clear connection
between neighborhood size and fairness promotion.

| Cosine |
---|---|---
REDRESS GraphSAGE | Nodes in layer 1 | Nodes in layer 2 | AUC | Fairness |
| 5 | 5 | 65.86 | 58.04 |
| 10 | 10 | 46.24 | 56.95 |
| 25 | 15 | 71.27 | 52.02 |
| 30 | 30 | 69.32 | 48.71 |
| 35 | 35 | 67.17 | 46.29 |
Table 4. Neighborhood Comparison

##  7\. Conclusion

The advances in the field of GNNs have prompted this architecture to become
widely adopted into many graph-structured tasks. In tandem with the
proliferation of these models, specifically in the space of recommender
systems, has come a growing concern of the exponentiation of biases embedded
in their outcomes. Although a growing body of recent work has aimed to
implement various notions of fairness within the graph space, the area of
individual fairness, has not yet been fully explored. Furthermore, many of the
methods proposed in this sub-field remain intractable to the large, real world
datasets used in recommender settings. Our work sets out to fill in this gap,
by implementing REDRESS, an existing framework for individual fairness, and
extending it to GraphSAGE, a scalable GNN architecture. In doing so, we show
that the addition of mini-batch training via sub-sampling can significantly
improve the promotion of individual fairness. Our findings indicate that this
improvement is rooted in the neighborhood selection method, which defines the
granularity of local fairness patterns. Due to the prevalence of GNNs in
recommender systems, these findings also have ripple effects into the domain
of recommendations. Given the shown scalability of this individual fairness
notion and the significant ties between GraphSAGE and, its down stream
recommmender model, PinSage, we lay the foundation for this individual
fairness method to be applied to recommendations. By imposing the need for
items which are similar in their initial feature space to remain bounded by
this similarity in their embedding space, we believe we can mitigate harmful
biases prevalent among recommender systems, such as popularity bias. Our
findings show the important connection between individual fairness and
neighborhood selection. As such, we believe that this work shows the potential
for future implications in field of both GNNs and recommender systems.

## Acknowledgements

Funding support for project activities has been partially provided by Canada
CIFAR AI Chair, Facebook-MEI award, IVADO grant, and NSERC Discovery Grants
program (2021-04378).

##  Appendix A Calculating NDCG

Classically, NDCG is defined as a ratio between Discounted Cumulative Gain
(DCG) and Ideal Discounted Cumulative Gain (IDCG) with the Normalized
Discounted Cumulative Gain defined as $NDCG=\frac{DCG}{IDCG}$.
Following the procedure laid out in REDRESS (Dong et al., 2021), we follow
following format for the NDCG calculation. Given a node $u$, we generate two
ranked lists, $L_{G}$ and $L_{\hat{Y}}$. Each of these lists is populated with
the similarity values from the apriori matrix, $S_{G}$. The first list,
$L_{G}$, follows an ordering based on $S_{G}$. Meanwhile the second list,
$L_{\hat{Y}}$, follows an ordering based on $S_{\hat{Y}}$. Thus, we define:

(10) $\displaystyle
IDCG(u)=\sum_{i=0}^{k}\frac{2^{s_{u,v_{i}}}-1}{log_{2}(2+i)}$

where ${s}_{u,v_{i}}$ represents the similarity between nodes $u$ and $v_{i}$
as defined by the apriori matrix, $S_{G}$ and the nodes $v_{i}$ are selected
from $L_{G}$.

(11) $\displaystyle
DCG(u)=\sum_{i=0}^{k}\frac{2^{{s}_{u,v_{i}}}-1}{log_{2}(2+i)}$

where ${s}_{u,v_{i}}$ represents the similarity between nodes $u$ and $v_{i}$
as defined by the apriori matrix, $S_{G}$ and the nodes $v_{i}$ are selected
from $L_{\hat{Y}}$.

## References

  * (1)
  * Agarap (2018) Abien Fred Agarap. 2018\.  Deep learning using rectified linear units (relu).  _arXiv preprint arXiv:1803.08375_ (2018).
  * Arduini et al. (2020) Mario Arduini, Lorenzo Noci, Federico Pirovano, Ce Zhang, Yash Raj Shrestha, and Bibek Paudel. 2020\.  Adversarial Learning for Debiasing Knowledge Graph Embeddings.  (2020).  https://doi.org/10.48550/ARXIV.2006.16309
  * Bauer et al. (2017) Christine Bauer, Marta Kholodylo, and Christine Strauss. 2017\.  Music Recommender Systems Challenges and Opportunities for Non-Superstar Artists. In _Bled eConference_.
  * Bose and Hamilton (2019) Avishek Bose and William Hamilton. 2019.  Compositional Fairness Constraints for Graph Embeddings. In _Proceedings of the 36th International Conference on Machine Learning_ _(Proceedings of Machine Learning Research, Vol. 97)_ , Kamalika Chaudhuri and Ruslan Salakhutdinov (Eds.). PMLR, 715–724.  https://proceedings.mlr.press/v97/bose19a.html
  * Burges et al. (2006) Christopher Burges, Robert Ragno, and Quoc Le. 2006.  Learning to Rank with Nonsmooth Cost Functions. In _Advances in Neural Information Processing Systems_ , B. Schölkopf, J. Platt, and T. Hoffman (Eds.), Vol. 19. MIT Press.  https://proceedings.neurips.cc/paper/2006/file/af44c4c56f385c43f2529f9b1b018f6a-Paper.pdf
  * Chen et al. (2020) Jiawei Chen, Hande Dong, Xiang Wang, Fuli Feng, Meng Wang, and Xiangnan He. 2020\.  Bias and Debias in Recommender System: A Survey and Future Directions.  https://doi.org/10.48550/ARXIV.2010.03240
  * Chen et al. (2018) Jie Chen, Tengfei Ma, and Cao Xiao. 2018.  FastGCN: Fast Learning with Graph Convolutional Networks via Importance Sampling.  https://doi.org/10.48550/ARXIV.1801.10247
  * Chiang et al. (2019) Wei-Lin Chiang, Xuanqing Liu, Si Si, Yang Li, Samy Bengio, and Cho-Jui Hsieh. 2019\.  Cluster-GCN. In _Proceedings of the 25th ACM SIGKDD International Conference on Knowledge Discovery & Data Mining_. ACM.  https://doi.org/10.1145/3292500.3330925
  * Chicaiza and Díaz (2021) Janneth Chicaiza and Priscila Valdiviezo Díaz. 2021\.  A Comprehensive Survey of Knowledge Graph-Based Recommender Systems: Technologies, Development, and Contributions.  _Inf._ 12 (2021), 232.
  * Chierichetti et al. (2018) Flavio Chierichetti, Ravi Kumar, Silvio Lattanzi, and Sergei Vassilvitskii. 2018.  Fair Clustering Through Fairlets.  (2018).  https://doi.org/10.48550/ARXIV.1802.05733
  * Cong et al. (2021) Weilin Cong, Morteza Ramezani, and Mehrdad Mahdavi. 2021\.  On the Importance of Sampling in Training GCNs: Tighter Analysis and Variance Reduction.  https://doi.org/10.48550/ARXIV.2103.02696
  * Da’u and Salim (2019) Aminu Da’u and Naomie Salim. 2019.  Recommendation system based on deep learning methods: a systematic review and new directions.  _Artificial Intelligence Review_ 53 (2019), 2709–2748.
  * Dong et al. (2021) Yushun Dong, Jian Kang, Hanghang Tong, and Jundong Li. 2021\.  Individual Fairness for Graph Neural Networks: A Ranking Based Approach. In _Proceedings of the 27th ACM SIGKDD Conference on Knowledge Discovery &; Data Mining_ (Virtual Event, Singapore) _(KDD ’21)_. Association for Computing Machinery, New York, NY, USA, 300–310.  https://doi.org/10.1145/3447548.3467266
  * Dong et al. (2022) Yushun Dong, Ninghao Liu, Brian Jalaian, and Jundong Li. 2022\.  EDITS: Modeling and Mitigating Data Bias for Graph Neural Networks. In _Proceedings of the ACM Web Conference 2022_. ACM.  https://doi.org/10.1145/3485447.3512173
  * Dwork et al. (2011) Cynthia Dwork, Moritz Hardt, Toniann Pitassi, Omer Reingold, and Rich Zemel. 2011.  Fairness Through Awareness.  https://doi.org/10.48550/ARXIV.1104.3913
  * Ekstrand et al. (2018) Michael Ekstrand, Mucun Tian, Ion Azpiazu, Jennifer Ekstrand, Oghenemaro Anuyah, David McNeill, and Maria Pera. 2018.  All The Cool Kids, How Do They Fit In?: Popularity and Demographic Biases in Recommender Evaluation and Effectiveness.
  * Guo et al. (2022) Qingyu Guo, Fuzhen Zhuang, Chuan Qin, Hengshu Zhu, Xing Xie, Hui Xiong, and Qing He. 2022.  A Survey on Knowledge Graph-Based Recommender Systems.  _IEEE Transactions on Knowledge and Data Engineering_ 34, 8, 3549–3568.  https://doi.org/10.1109/TKDE.2020.3028705
  * Hamilton (2020) William L. Hamilton. 2020\.  Graph Representation Learning.  _Synthesis Lectures on Artificial Intelligence and Machine Learning_ 14, 3, 1–159.
  * Hamilton et al. (2017) William L. Hamilton, Rex Ying, and Jure Leskovec. 2017\.  Inductive Representation Learning on Large Graphs.  https://doi.org/10.48550/ARXIV.1706.02216
  * Huang et al. (2018) Wenbing Huang, Tong Zhang, Yu Rong, and Junzhou Huang. 2018\.  Adaptive Sampling Towards Fast Graph Representation Learning. In _Advances in Neural Information Processing Systems_ , S. Bengio, H. Wallach, H. Larochelle, K. Grauman, N. Cesa-Bianchi, and R. Garnett (Eds.), Vol. 31. Curran Associates, Inc.  https://proceedings.neurips.cc/paper/2018/file/01eee509ee2f68dc6014898c309e86bf-Paper.pdf
  * Järvelin and Kekäläinen (2002) Kalervo Järvelin and Jaana Kekäläinen. 2002.  Cumulated Gain-Based Evaluation of IR Techniques.  _ACM Trans. Inf. Syst._ 20, 4 (oct 2002), 422–446.  https://doi.org/10.1145/582415.582418
  * Kang et al. (2020) Jian Kang, Jingrui He, Ross Maciejewski, and Hanghang Tong. 2020\.  InFoRM: Individual Fairness on Graph Mining. In _Proceedings of the 26th ACM SIGKDD International Conference on Knowledge Discovery &; Data Mining_ (Virtual Event, CA, USA) _(KDD ’20)_. Association for Computing Machinery, New York, NY, USA, 379–389.  https://doi.org/10.1145/3394486.3403080
  * Khatter et al. (2021) Harsh Khatter, Nishtha Goel, Naina Gupta, and Muskan Gulati. 2021\.  Movie Recommendation System using Cosine Similarity with Sentiment Analysis. In _2021 Third International Conference on Inventive Research in Computing Applications (ICIRCA)_. 597–603.  https://doi.org/10.1109/ICIRCA51532.2021.9544794
  * Kipf and Welling (2016) Thomas N. Kipf and Max Welling. 2016.  Semi-Supervised Classification with Graph Convolutional Networks.  https://doi.org/10.48550/ARXIV.1609.02907
  * Kleinberg et al. (2016) Jon Kleinberg, Sendhil Mullainathan, and Manish Raghavan. 2016\.  Inherent Trade-Offs in the Fair Determination of Risk Scores.  https://doi.org/10.48550/ARXIV.1609.05807
  * Kusner et al. (2017) Matt J. Kusner, Joshua R. Loftus, Chris Russell, and Ricardo Silva. 2017.  Counterfactual Fairness.  https://doi.org/10.48550/ARXIV.1703.06856
  * Lahoti et al. (2019) Preethi Lahoti, Krishna P. Gummadi, and Gerhard Weikum. 2019\.  Operationalizing individual fairness with pairwise fair representations.  _Proceedings of the VLDB Endowment_ 13, 4 (dec 2019), 506–518.  https://doi.org/10.14778/3372716.3372723
  * Li et al. (2021a) Yunqi Li, Hanxiong Chen, Zuohui Fu, Yingqiang Ge, and Yongfeng Zhang. 2021a.  User-oriented Fairness in Recommendation. In _Proceedings of the Web Conference 2021_. ACM.  https://doi.org/10.1145/3442381.3449866
  * Li et al. (2021b) Yunqi Li, Hanxiong Chen, Shuyuan Xu, Yingqiang Ge, and Yongfeng Zhang. 2021b.  Towards Personalized Fairness based on Causal Notion. In _Proceedings of the 44th International ACM SIGIR Conference on Research and Development in Information Retrieval_. ACM.  https://doi.org/10.1145/3404835.3462966
  * Liu et al. (2021) Xin Liu, Mingyu Yan, Lei Deng, Guoqi Li, Xiaochun Ye, and Dongrui Fan. 2021\.  Sampling methods for efficient training of graph convolutional networks: A survey.  https://doi.org/10.48550/ARXIV.2103.05872
  * Ma et al. (2022) Jing Ma, Ruocheng Guo, Mengting Wan, Longqi Yang, Aidong Zhang, and Jundong Li. 2022\.  Learning Fair Node Representations with Graph Counterfactual Fairness. In _Proceedings of the Fifteenth ACM International Conference on Web Search and Data Mining_. ACM.  https://doi.org/10.1145/3488560.3498391
  * Mehrotra et al. (2018) Rishabh Mehrotra, James McInerney, Hugues Bouchard, Mounia Lalmas, and Fernando Diaz. 2018\.  Towards a Fair Marketplace: Counterfactual Evaluation of the Trade-off between Relevance, Fairness &; Satisfaction in Recommendation Systems. In _Proceedings of the 27th ACM International Conference on Information and Knowledge Management_ (Torino, Italy) _(CIKM ’18)_. Association for Computing Machinery, New York, NY, USA, 2243–2251.  https://doi.org/10.1145/3269206.3272027
  * Quadrana et al. (2018) Massimo Quadrana, Paolo Cremonesi, and Dietmar Jannach. 2018\.  Sequence-Aware Recommender Systems.  _ACM Comput. Surv._ 51, 4, Article 66, 36 pages.  https://doi.org/10.1145/3190616
  * Tang and Liu (2009a) Lei Tang and Huan Liu. 2009a.  Relational Learning via Latent Social Dimensions. In _Proceedings of the 15th ACM SIGKDD International Conference on Knowledge Discovery and Data Mining_ (Paris, France) _(KDD ’09)_. Association for Computing Machinery, New York, NY, USA, 817–826.  https://doi.org/10.1145/1557019.1557109
  * Tang and Liu (2009b) Lei Tang and Huan Liu. 2009b.  Relational Learning via Latent Social Dimensions. In _Proceedings of the 15th ACM SIGKDD International Conference on Knowledge Discovery and Data Mining_ (Paris, France) _(KDD ’09)_. Association for Computing Machinery, New York, NY, USA, 817–826.  https://doi.org/10.1145/1557019.1557109
  * Wang et al. (2019) Minjie Wang, Da Zheng, Zihao Ye, Quan Gan, Mufei Li, Xiang Song, Jinjing Zhou, Chao Ma, Lingfan Yu, Yu Gai, Tianjun Xiao, Tong He, George Karypis, Jinyang Li, and Zheng Zhang. 2019.  Deep Graph Library: A Graph-Centric, Highly-Performant Package for Graph Neural Networks.  https://doi.org/10.48550/ARXIV.1909.01315
  * Wang et al. (2021) Zhaokang Wang, Yunpan Wang, Chunfeng Yuan, Rong Gu, and Yihua Huang. 2021.  Empirical analysis of performance bottlenecks in graph neural network training and inference with GPUs.  _Neurocomputing_ 446 (2021), 165–191.  https://doi.org/10.1016/j.neucom.2021.03.015
  * Wu et al. (2021a) Haolun Wu, Chen Ma, Bhaskar Mitra, Fernando Diaz, and Xue Liu. 2021a.  Multi-FR: A Multi-Objective Optimization Method for Achieving Two-sided Fairness in E-commerce Recommendation.  _ArXiv_ abs/2105.02951 (2021).
  * Wu et al. (2020) Shiwen Wu, Fei Sun, Wentao Zhang, Xu Xie, and Bin Cui. 2020.  Graph Neural Networks in Recommender Systems: A Survey.  https://doi.org/10.48550/ARXIV.2011.02260
  * Wu et al. (2021b) Zonghan Wu, Shirui Pan, Fengwen Chen, Guodong Long, Chengqi Zhang, and Philip S. Yu. 2021b.  A Comprehensive Survey on Graph Neural Networks.  _IEEE Transactions on Neural Networks and Learning Systems_ 32, 1 (Jan 2021), 4–24.  https://doi.org/10.1109/tnnls.2020.2978386
  * Ying et al. (2018) Rex Ying, Ruining He, Kaifeng Chen, Pong Eksombatchai, William L. Hamilton, and Jure Leskovec. 2018.  Graph Convolutional Neural Networks for Web-Scale Recommender Systems. In _Proceedings of the 24th ACM SIGKDD International Conference on Knowledge Discovery & Data Mining_. ACM.  https://doi.org/10.1145/3219819.3219890
  * Zeng et al. (2019) Hanqing Zeng, Hongkuan Zhou, Ajitesh Srivastava, Rajgopal Kannan, and Viktor Prasanna. 2019\.  GraphSAINT: Graph Sampling Based Inductive Learning Method.  https://doi.org/10.48550/ARXIV.1907.04931
  * Zhang et al. (2020) Shuai Zhang, Lina Yao, Aixin Sun, and Yi Tay. 2020\.  Deep Learning Based Recommender System.  _Comput. Surveys_ 52, 1 (jan 2020), 1–38.  https://doi.org/10.1145/3285029
  * Zhang et al. (2021) Yang Zhang, Fuli Feng, Xiangnan He, Tianxin Wei, Chonggang Song, Guohui Ling, and Yongdong Zhang. 2021.  Causal Intervention for Leveraging Popularity Bias in Recommendation. In _Proceedings of the 44th International ACM SIGIR Conference on Research and Development in Information Retrieval_. ACM.  https://doi.org/10.1145/3404835.3462875
  * Zhu et al. (2021) Ziwei Zhu, Yun He, Xing Zhao, Yin Zhang, Jianling Wang, and James Caverlee. 2021\.  Popularity-Opportunity Bias in Collaborative Filtering. In _Proceedings of the 14th ACM International Conference on Web Search and Data Mining_ (Virtual Event, Israel) _(WSDM ’21)_. Association for Computing Machinery, New York, NY, USA, 85–93.  https://doi.org/10.1145/3437963.3441820
  * Zou et al. (2019) Difan Zou, Ziniu Hu, Yewen Wang, Song Jiang, Yizhou Sun, and Quanquan Gu. 2019\.  Layer-Dependent Importance Sampling for Training Deep and Large Graph Convolutional Networks.