Original: Graph Few-shot Learning with Task-specific Structures
Revised: Graph Few-shot Learning with Task-specific Structures

Original: Anonymous Author(s)
Revised: Anonymous Author(s)

Original: AffiliationAddress email
Revised: AffiliationAddress email

Original: Abstract
Revised: Abstract

Original: Graph few-shot learning is of great importance among various graph learningtasks.
Revised: Graph few-shot learning is of great importance among various graph learningtasks.

Original: Under the few-shot scenario, models are required to conduct classificationgiven limited labeled samples.
Revised: Under the few-shot scenario, models are required to conduct classificationgiven limited labeled samples.

Original: Existing graph few-shot learning methods typicallyleverage Graph Neural Networks (GNNs) and perform classification across a seriesof meta-tasks.
Revised: Existing graph few-shot learning methods typicallyleverage Graph Neural Networks (GNNs) and perform classification across a seriesof meta-tasks.

Original: Nevertheless, these methods generally rely on the original graph(i.e., the graph that the meta-task is sampled from) to learn node representations.
Revised: Nevertheless, these methods generally rely on the original graph(i.e., the graph that the meta-task is sampled from) to learn node representations.

Original: Consequently, the graph structure used in each meta-task is identical.
Revised: Consequently, the learned representations for the same nodes are identical in allmeta-tasks.

Original: Since the classsets are different across meta-tasks, node representations should be learned in a taskspecific manner to promote classification performance.
Revised: Since the class sets are different across meta-tasks, node representations should be task-specific to promote classification performance.

Original: Therefore, to adaptivelylearn node representations across meta-tasks, we propose a novel framework thatlearns a task-specific structure for each meta-task.
Revised: Therefore,to adaptively learn node representations across meta-tasks, we propose a novelframework that learns a task-specific structure for each meta-task.

Original: To handle the variety of nodesacross meta-tasks, we extract relevant nodes and learn task-specific structuresbased on node influence and mutual information.
Revised: To handle the variety of nodes across meta-tasks, we extract relevant nodes and learn task-specificstructures based on node influence and mutual information.

Original: In this way, we can learn noderepresentations with the task-specific structure tailored for each meta-task.
Revised: In this way, we canlearn node representations with the task-specific structure tailored for each metatask.

Original: Wefurther conduct extensive experiments on five node classification datasets underboth single- and multiple-graph settings to validate the superiority of our frameworkover the state-of-the-art baselines.
Revised: We further conduct extensive experiments on five node classification datasetsunder both single- and multiple-graph settings to validate the superiority of ourframework over the state-of-the-art baselines.

Original:  Introduction
Revised:  Introduction

Original: Nowadays, graph-structured data is playing a crucial role in various real-world applications, such asmolecular property prediction [1], knowledge graph completion [2] and recommender systems [3].
Revised: Nowadays, graph-structured data is playing a crucial role in various real-world applications, such asmolecular property prediction [1], knowledge graph completion [2] and recommender systems [3].

Original: More recently, Graph Neural Networks (GNNs) [4, 5, 6, 7] have been proposed to learn noderepresentations via information aggregation based on the given graph structure.
Revised: More recently, Graph Neural Networks (GNNs) [4, 5, 6, 7] have been proposed to learn noderepresentations via information aggregation based on the given graph structure.

Original: Generally, thesemethods adopt a semi-supervised learning strategy to train models on a graph with abundant labeledsamples [8].
Revised: Generally, thesemethods adopt a semi-supervised learning strategy to train models on a graph with abundant labeledsamples [8].

Original: However, in practice, it is often difficult to obtain sufficient labeled samples due to thelaborious labeling process [9].
Revised: However, in practice, it is often difficult to obtain sufficient labeled samples due to thelaborious labeling process [9].

Original: Hence, there is a surge of research interests aiming at performing graphlearning with limited labeled samples as references, known as graph few-shot learning [10, 11, 12].
Revised: Hence, there is a surge of research interests aiming at performing graphlearning with limited labeled samples as references, known as graph few-shot learning [10, 11, 12].

Original: Among various types of graph few-shot learning tasks, few-shot node classification is essential inreal-world scenarios, including protein classification [13] and document categorization [14].
Revised: Among various types of graph few-shot learning tasks, few-shot node classification is essential inreal-world scenarios, including protein classification [13] and document categorization [14].

Original: To dealwith the label deficiency issue in node classification, many recent works [15, 9, 1, 11] incorporateexisting few-shot learning frameworks from other domains [16, 17] into GNNs.
Revised: To dealwith the label deficiency issue in node classification, many recent works [15, 9, 1, 11] have proposedto incorporate existing few-shot learning frameworks from other domains [16, 17] into GNNs.

Original: Specifically,few-shotclassification during evaluation is conducted on a specific number of meta-test tasks. Each meta-testtask contains a small number of labeled nodes as references (i.e., support nodes) and several unlabelednodes for classification (i.e., query nodes). To extract transferable knowledge from classes withabundant labeled nodes, the model is  trained on a series of meta-training tasks  that aresampled fromthese disjoint  classes but share similar structures with meta-test tasks.
Revised: Specifically, the model is first trained on a series of meta-training tasks to learn meta-knowledge fromclasses with abundant labeled nodes (typically from an auxiliary dataset). Then the model generalizesthe meta-knowledge to novel tasks (i.e., meta-test tasks) with limited labeled nodes, and these nodesbelong to classes that are disjoint from the classes of meta-training tasks.

Original: We refer to meta-trainingand meta-test tasks  as meta-tasks.
Revised: These meta-training andmeta-test tasks are referred to as meta-tasks.

Revised: Generally, each meta-task contains a small numberof labeled nodes as references (i.e., support nodes) and several unlabeled nodes for classification

Original:  Note that few-shot node classification can be conducted on a single graph (e.g., a citation network for author classification) or across multiple graphs (e.g., a set ofprotein-protein interaction networks for drug discovery).
Revised: (i.e., query nodes). Note that few-shot node classification can be conducted on a single graph (e.g.,a citation network for author classification) or across multiple graphs (e.g., a set of protein-proteininteraction networks for drug discovery).

Original: Here each meta-task is  sampled fromonesingle graph in both single-graph and multiple-graph settings, since each meta-test task is conductedon one graph.
Revised: Here each meta-task is often sampled from one singlegraph.

Original: Despite the success of recent studies on few-shot node classification, they mainlylearn node representations from the original graph (i.e., the graph that the meta-task is sampledfrom).
Revised: On the other hand, despite the success of recent studies on few-shot node classification, thesemethods mainly learn node representations from the original graph (i.e., the graph that the meta-taskis sampled from).

Original: However, the whole graph can be redundant and uninformative for a specific meta-task aseach meta-task only contains a small number of nodes.
Revised: Nevertheless, the whole graph can be redundant and uninformative for a specificmeta-task as each meta-task only takes up a small number of nodes on the graph.

Original: As a result, the learned node representationsare not tailored for the meta-task (i.e., task-specific), which increases the difficulties of few-shotlearning.
Revised: As a result, thelearned node representations are not tailored for the meta-task (i.e., task-specific), which increasesthe difficulties of few-shot classification.

Original: Thus, instead of leveraging the same original graph for all meta-tasks, it is crucial to learn atask-specific structure for each meta-task.
Revised: Therefore, instead of leveraging the same original graph forall meta-tasks, it is crucial to learn a task-specific structure for each meta-task.

Original: Intuitively, the task-specific structure should contain nodes in the meta-task along with other relevantnodes from the original graph.
Revised: Intuitively, the task-specific structure should contain nodes in the meta-task along with other relevantnodes from the original graph.

Original: Moreover, the edge weights among these nodes should also belearned in a task-specific manner.
Revised: Moreover, the edge weights among these nodes should also belearned in a task-specific manner.

Original: Nevertheless, it remains a daunting problem to learn a task-specificstructure for each meta-task due to two challenges: (1) It is non-trivial to select relevant nodes for thetask-specific structure.
Revised: Nevertheless, it remains a daunting problem to learn a task-specificstructure for each meta-task due to two challenges: (1) It is non-trivial to select relevant nodes for thetask-specific structure.

Original: Particularly, this structure should contain nodes that are maximally relevant tothe support nodes in the meta-task.
Revised: Particularly, this structure should contain nodes that are maximally relevant tothe support nodes in the meta-task.

Original: Nevertheless, since each meta-task consists of multiple supportnodes, it is difficult to select nodes that are relevant to the entire support node set.
Revised: Nevertheless, since each meta-task consists of multiple supportnodes, it is difficult to select nodes that are relevant to the entire support node set.

Original: (2) It is challengingto learn edge weights for the task-specific structure.
Revised: (2) It is challengingto learn edge weights for the task-specific structure.

Original: The task-specific structure should maintainstrong correlations for nodes in the same class, so that the learned node representations will be similar.
Revised: The task-specific structure should maintainstrong correlations for nodes in the same class, so that the learned node representations will be similar.

Original: Nonetheless, the support nodes in the same class could be distributed across the original graph, whichincreases the difficulty of enhancing such correlations for the task-specific structure.
Revised: Nonetheless, the support nodes in the same class could be distributed across the original graph, whichincreases the difficulty of enhancing such correlations for the task-specific structure.

Original: To address these challenges, we propose a novel G raph few-shot L earning framework w IT h T asksp E cific st R uctures - GLITTER, which aims at effectively learning a task-specific structure for eachmeta-task in graph few-shot learning.
Revised: To address these challenges, we propose a novel G raph few-shot L earning framework w IT h T asksp E cific st R uctures - GLITTER, which aims at effectively learning a task-specific structure for eachmeta-task in graph few-shot learning.

Original: Specifically, to reduce the irrelevant information from theoriginal graph, we propose to select nodes via two strategies according to their overall node influenceon support nodes in each meta-task.
Revised: Specifically, to reduce the irrelevant information from theoriginal graph, we propose to select nodes via two strategies according to their overall node influenceon support nodes in each meta-task.

Original: Moreover, we learn edge weights in the task-specific structurebased on node influence within classes and mutual information between query nodes and labels.
Revised: Moreover, we learn edge weights in the task-specific structurebased on node influence within classes and mutual information between query nodes and labels.

Original: Withthe learned task-specific structures, our framework can effectively learn node representations that aretailored for each meta-task.
Revised: Withthe learned task-specific structures, our framework can effectively learn node representations that aretailored for each meta-task.

Original: In summary, the main contributions of our framework are as follows:(1)
Revised: In summary, the main contributions of our framework are as follows:(1)

Original: We selectively extract relevant nodes from the original graph and learn a task-specific structurefor each meta-task based on node influence and mutual information.
Revised: We selectively extract relevant nodes from the original graph and learn a task-specific structurefor each meta-task based on node influence and mutual information.

Original: The proposed frameworkcan handle graph few-shot learning under both single-graph and multiple-graph settings.
Revised: The proposed frameworkcan handle graph few-shot learning under both single-graph and multiple-graph settings.

Original: Differently,most existing works only focus on the single-graph setting.
Revised: Differently,most existing works only focus on the single-graph setting.

Original: (3) We conduct extensive experiments onfive real-world datasets under single-graph and multiple-graph settings.
Revised: (3) We conduct extensive experiments onfive real-world datasets under single-graph and multiple-graph settings.

Original: The superior performanceover the state-of-the-art methods further validates the effectiveness of our framework.
Revised: The superior performanceover the state-of-the-art methods further validates the effectiveness of our framework.

Original:  Problem Formulation
Revised:  Problem Formulation

Original: Denote the set of input graphs as G = { G 1 , . .
Revised: Denote the set of input graphs as G = { G 1 , . .

Original: , G M } (for the single-graph setting, |G| = 1 ), where
Revised: , G M } (for the single-graph setting, |G| = 1 ), where

Original: M is the number of graphs.
Revised: M is the number of graphs.

Original: Here each graph can be represented as G =
Revised: Here each graph can be represented as G =

Original: ( V , E , X ) , where V is theset of nodes, E is the set of edges, and X ∈ R |V|× d is a feature matrix with the i -th row vector ( ddimensional) representing the attribute of the i -th node.
Revised: ( V , E , X ) , where V is theset of nodes, E is the set of edges, and X ∈ R |V|× d is a feature matrix with the i -th row vector ( ddimensional) representing the attribute of the i -th node.

Original: Under the prevalent meta-learning framework,the training process is conducted on a series of meta-training tasks {T 1 , . .
Revised: Under the prevalent meta-learning framework,the training process is conducted on a series of meta-training tasks {T 1 , . .

Original: , T T } , where T is thenumber of meta-training tasks.
Revised: , T T } , where T is thenumber of meta-training tasks.

Original: More specifically, T i =
Revised: More specifically, T i =

Original: {S i , Q i } , where S i is the support set of T i andconsists of K labeled nodes for each of N classes (i.e., |S i | = NK ).
Revised: {S i , Q i } , where S i is the support set of T i andconsists of K labeled nodes for each of N classes (i.e., |S i | = NK ).

Original: The corresponding label set of T iis Y i , where |Y i | = N .
Revised: The corresponding label set of T iis Y i , where |Y i | = N .

Original: Y i is sampled from the whole training label set Y train .
Revised: Y i is sampled from the whole training label set Y train .

Original: With S i as references,the model is required to classify nodes in the query set Q i , which contains Q unlabeled samples.
Revised: With S i as references,the model is required to classify nodes in the query set Q i , which contains Q unlabeled samples.

Original: Note that the actual labels of query nodes are from Y i .
Revised: Note that the actual labels of query nodes are from Y i .

Original: After training, the model will be evaluated ona series of meta-test tasks, which follow a similar setting as meta-training tasks, except that the labelset in each meta-test task is sampled from a distinct label set Y test (i.e., Y test ∩ Y train = ∅ ).
Revised: After training, the model will be evaluated ona series of meta-test tasks, which follow a similar setting as meta-training tasks, except that the labelset in each meta-test task is sampled from a distinct label set Y test (i.e., Y test ∩ Y train = ∅ ).

Original: It isnoteworthy that under the multiple-graph setting, meta-training and meta-test tasks can be sampledfrom different graphs, while each meta-task is sampled from one single graph.
Revised: It isnoteworthy that under the multiple-graph setting, meta-training and meta-test tasks can be sampledfrom different graphs, while each meta-task is sampled from one single graph.

Original:  Methodology
Revised:  Methodology

Original: In this section, we introduce our framework that explores task-specific structures for different metatasks in graph few-shot learning.
Revised: In this section, we introduce our framework that explores task-specific structures for different metatasks in graph few-shot learning.

Original: The detailed framework is illustrated in Figure 1.
Revised: The detailed framework is illustrated in Figure 1.

Original: We first elaborate
Revised: We first elaborate

Original: [Figure]
Revised: [Figure]

Original: : Multiple graphs
Revised: : Multiple graphs

Original: [Figure]
Revised: [Figure]

Original: specific Structure
Revised: specific Structure

Original: Support
Revised: Support

Original: Relevant
Revised: Relevant

Original: Node Influence
Revised: Node Influence

Original: Mutual Information
Revised: Mutual Information

Original: GNN 𝜃
Revised: GNN 𝜃

Original: Query
Revised: Query

Original: Query Emb.
Revised: Query Emb.

Original: ClassifierLoss
Revised: ClassifierLoss

Original: Unlabeled
Revised: Unlabeled

Original: Optimize Optimize
Revised: Optimize Optimize

Original: ClassifierLoss
Revised: ClassifierLoss

Original: Meta-optimize
Revised: Meta-optimize

Original: Optimize
Revised: Optimize

Original: Support Emb.
Revised: Support Emb.

Original: Extracted Nodes ? ?
Revised: Extracted Nodes ? ?

Original: [Figure]
Revised: [Figure]

Original: on the process of selecting relevant nodes based on node influence to construct the task-specific structure in each meta-task.
Revised: on the process of selecting relevant nodes based on node influence to construct the task-specific structure in each meta-task.

Original: Then we provide the detailed process of learning task-specific edgeweights via maximizing node influence within classes and mutual information between query nodesand labels.
Revised: Then we provide the detailed process of learning task-specific edgeweights via maximizing node influence within classes and mutual information between query nodesand labels.

Original: Finally, we describe the meta-learning strategy used to optimize model parameters.
Revised: Finally, we describe the meta-learning strategy used to optimize model parameters.

Original: 3.1 Selecting Nodes for Task-specific Structures
Revised: 3.1 Selecting Nodes for Task-specific Structures

Original: Given a meta-task T = {S , Q} , we first aim to extract relevant nodes that are helpful for T andconstruct a task-specific structure G T based on these nodes.
Revised: Given a meta-task T = {S , Q} , we first aim to extract relevant nodes that are helpful for T andconstruct a task-specific structure G T based on these nodes.

Original: In this way, we can avoid redundantinformation on the original graph and focus on meta-task T .
Revised: In this way, we can avoid redundantinformation on the original graph and focus on meta-task T .

Original: Nevertheless, it remains difficult todetermine which nodes are useful for classification in T .
Revised: Nevertheless, it remains difficult todetermine which nodes are useful for classification in T .

Original: The reason is that the support nodes in Tcan be distributed across the original graph, which increases the difficulty of selecting nodes that arerelevant to all these support nodes.
Revised: The reason is that the support nodes in Tcan be distributed across the original graph, which increases the difficulty of selecting nodes that arerelevant to all these support nodes.

Original: Therefore, we propose to leverage the concept of node influenceto select relevant nodes.
Revised: Therefore, we propose to leverage the concept of node influenceto select relevant nodes.

Original: Here we first define node influence based on [1, 5, 18] as follows:
Revised: Here we first define node influence based on [1, 5, 18] as follows:

Original: Definition 1 (Node Influence) .
Revised: Definition 1 (Node Influence) .

Original: The node influence from node v i to node v j is defined as I ( v i , v j ) =
Revised: The node influence from node v i to node v j is defined as I ( v i , v j ) =

Original: ∥
Revised: ∥

Original: ∂ h i /∂ h j ∥ , where h i and h j are the output representations of v i and v j in a GNN, respectively.∂ h
Revised: ∂ h i /∂ h j ∥ , where h i and h j are the output representations of v i and v j in a GNN, respectively.∂ h

Original: i /∂
Revised: i /∂

Original: h
Revised: h

Original: j is a Jacobian matrix, and the norm can be any specific subordinate norm.
Revised: j is a Jacobian matrix, and the norm can be any specific subordinate norm.

Original: According to Definition 1, large node influence denotes that the representation of a node can be easilyimpacted by another node, thus rendering stronger correlations.
Revised: According to Definition 1, large node influence denotes that the representation of a node can be easilyimpacted by another node, thus rendering stronger correlations.

Original: Intuitively, we need to incorporatemore nodes with large influence on the support nodes into G T .
Revised: Intuitively, we need to incorporatemore nodes with large influence on the support nodes into G T .

Original: In this way, G T can maintain themost crucial information that is useful for classification based on support nodes.
Revised: In this way, G T can maintain themost crucial information that is useful for classification based on support nodes.

Original: To effectively selectnodes with larger influence on the support nodes, we consider important factors that affect nodeinfluence.
Revised: To effectively selectnodes with larger influence on the support nodes, we consider important factors that affect nodeinfluence.

Original: The following theorem provides a universal pattern for node influence on support nodes:
Revised: The following theorem provides a universal pattern for node influence on support nodes:

Original: Theorem 3.1.
Revised: Theorem 3.1.

Original: Consider the node influence from node v k to the i -th class (i.e., C i ) in a meta-task
Revised: Consider the node influence from node v k to the i -th class (i.e., C i ) in a meta-task

Original: T .
Revised: T .

Original: Denote the geometric mean of the node influence values to all support nodes in C i as I C
Revised: Denote the geometric mean of the node influence values to all support nodes in C i as I C

Original: i ( v k ) =
Revised: i ( v k ) =

Original: K (cid:113)(cid:81) Kj =

Revised: K (cid:113)(cid:81) Kj =

Original: I ( v k , s i,j ) , where s i,j is the j -th support node in C i .
Revised: I ( v k , s i,j ) , where s i,j is the j -th support node in C i .

Original: Assume the node degrees are randomlydistributed with the mean value as ¯ d .
Revised: Assume the node degrees are randomlydistributed with the mean value as ¯ d .

Original: Then, E (log I C
Revised: Then, E (log I C

Original: i ( v k )) ≥ − log ¯ d · (cid:80) Kj =1 SPD ( v k , s i,j ) /K , where
Revised: i ( v k )) ≥ − log ¯ d · (cid:80) Kj =1 SPD ( v k , s i,j ) /K , where

Original: SPD ( v k , s i,j ) denotes the shortest path distance between v k and s i,j .
Revised: SPD ( v k , s i,j ) denotes the shortest path distance between v k and s i,j .

Original: The proof is provided in Appendix A. Theorem 3.1 indicates that the lower bound of the nodeinfluence on a specific class is measured by its shortest path distances to all support nodes in thisclass.
Revised: The proof is provided in Appendix A. Theorem 3.1 indicates that the lower bound of the nodeinfluence on a specific class is measured by its shortest path distances to all support nodes in thisclass.

Original: Therefore, to effectively select nodes with large influence on a specific class, we can choosenodes with small average shortest path distances to support nodes of this class.
Revised: Therefore, to effectively select nodes with large influence on a specific class, we can choosenodes with small average shortest path distances to support nodes of this class.

Original: Based on this theorem,we propose two strategies, namely local sampling and common sampling , to select nodes for thetask-specific structure G T .
Revised: Based on this theorem,we propose two strategies, namely local sampling and common sampling , to select nodes for thetask-specific structure G T .

Original: In particular, we combine the selected nodes with support and querynodes in the meta-task (i.e., S and Q ) to obtain the final node set V T =
Revised: In particular, we combine the selected nodes with support and querynodes in the meta-task (i.e., S and Q ) to obtain the final node set V T =

Original: V l ∪ V c ∪ S ∪ Q .
Revised: V l ∪ V c ∪ S ∪ Q .

Original: Here V l and
Revised: Here V l and

Original: V c are the node sets extracted based on local sampling and common sampling, respectively.
Revised: V c are the node sets extracted based on local sampling and common sampling, respectively.

Original: S and Qare the support set and the query set of T , respectively.
Revised: S and Qare the support set and the query set of T , respectively.

Original: Then we introduce the two strategies in detail.
Revised: Then we introduce the two strategies in detail.

Original: • Local Sampling.
Revised: • Local Sampling.

Original: In this strategy, we extract the local neighbor nodes of support nodes within a
Revised: In this strategy, we extract the local neighbor nodes of support nodes within a

Original: specific distance (i
Revised: specific distance (i

Original: e., neighborhood size).
Revised: e., neighborhood size).

Original: Intuitively, the neighbor nodes can maintain a small
Revised: Intuitively, the neighbor nodes can maintain a small

Original: shortest path distance to a specific support node.
Revised: shortest path distance to a specific support node.

Original: Therefore, by combining neighbor nodes of
Revised: Therefore, by combining neighbor nodes of

Original: all support nodes in a class, we can obtain nodes with considerable node influence on this class
Revised: all support nodes in a class, we can obtain nodes with considerable node influence on this class

Original: without
Revised: without

Original: calculating the shortest path distances
Revised: calculating the shortest path distances

Original: Specifically
Revised: Specifically

Original: , the extracted node set is denoted as
Revised: , the extracted node set is denoted as

Original: V l
Revised: V l

Original: =
Revised: =

Original: ∪ v i ∈S N l
Revised: ∪ v i ∈S N l

Original: v i )
Revised: v i )

Original: where N l ( v i )
Revised: where N l ( v i )

Original: = { u | d ( u,
Revised: = { u | d ( u,

Original: v i
Revised: v i

Original: ) ≤ h
Revised: ) ≤ h

Original: and h
Revised: and h

Original: is
Revised: is

Original: the
Revised: the

Original: pre
Revised: pre

Original: -defined
Revised: -defined

Original: neighborhood size.
Revised: neighborhood size.

Original: • Common Sampling.
Revised: • Common Sampling.

Original: In this strategy, we select nodes that maintain a small average distance to
Revised: In this strategy, we select nodes that maintain a small average distance to

Original: all nodes in the same class.
Revised: all nodes in the same class.

Original: In this way, the node influence on an entire class can be considered.
Revised: In this way, the node influence on an entire class can be considered.

Original: Specifically, for each of N classes in T , we extract nodes with the smallest average distances to
Revised: Specifically, for each of N classes in T , we extract nodes with the smallest average distances to

Original: nodes in this support class.
Revised: nodes in this support class.

Original: The overall extracted node set V c can be presented as follows
Revised: The overall extracted node set V c can be presented as follows

Original: [Equation]
Revised: [Equation]

Original: where s i,j is
Revised: where s i,j is

Original: the j -th
Revised: the j -th

Original: node of
Revised: node of

Original: the i -th class in
Revised: the i -th class in

Original: T .
Revised: T .

Original: Here we extract C nodes with the smallest sum ofshortest path distances to nodes in
Revised: Here we extract C nodes with the smallest sum ofshortest path distances to nodes in

Original: each
Revised: each

Original: class.
Revised: class.

Original: Then we aggregate these nodes into the final node set
Revised: Then we aggregate these nodes into the final node set

Original: V c .
Revised: V c .

Original: In this way, we can select nodes with large influence on an entire class.
Revised: In this way, we can select nodes with large influence on an entire class.

Original: As a result, the selectednodes will bear more
Revised: As a result, the selectednodes will bear more

Original: crucial
Revised: crucial

Original: information for classifying a specific class.
Revised: information for classifying a specific class.

Original: Note that
Revised: Note that

Original: since
Revised: since

Original: there
Revised: there

Original: are
Revised: are

Original: only N classes in T , the maximum size of V c is NC ,
Revised: only N classes in T , the maximum size of V c is NC ,

Original: i
Revised: i

Original: .e.
Revised: .e.

Original: , |V c | ≤
Revised: , |V c | ≤

Original: NC
Revised: NC

Original: Edge Weight Functions.
Revised: Edge Weight Functions.

Original: With the extracted node set V T , we intend to learn task-specific edgeweights for G T .
Revised: With the extracted node set V T , we intend to learn task-specific edgeweights for G T .

Original: Intuitively, although the original structural information is crucial for classification, itcan also be redundant for meta-task T .
Revised: Intuitively, although the original structural information is crucial for classification, itcan also be redundant for meta-task T .

Original: Therefore, we propose to construct the edges based on bothnode representations and the shortest path distance between two nodes.
Revised: Therefore, we propose to construct the edges based on bothnode representations and the shortest path distance between two nodes.

Original: In this way, the model willlearn to maintain and learn beneficial edges for T .
Revised: In this way, the model willlearn to maintain and learn beneficial edges for T .

Original: Particularly, the edge weight starting from node v ito node v j is denoted as a i,j = ( a ri,j + a si,j ) / 2 , where a ri,j and a si,j are learned by two functions thatutilize node representations and structures as input, respectively.
Revised: Particularly, the edge weight starting from node v ito node v j is denoted as a i,j = ( a ri,j + a si,j ) / 2 , where a ri,j and a si,j are learned by two functions thatutilize node representations and structures as input, respectively.

Original: • Node representations as input.
Revised: • Node representations as input.

Original: [Equation]
Revised: [Equation]

Original: 2) where ϕ is a non-linear activation function, and x i denotes the input feature vector of node v i .
Revised: 2) where ϕ is a non-linear activation function, and x i denotes the input feature vector of node v i .

Original: W 1 ∈ R d a × d and W 2 ∈ R d a × d are learnable parameters, where d a is the dimension size of W 1 x iand W 2 x j .
Revised: W 1 ∈ R d a × d and W 2 ∈ R d a × d are learnable parameters, where d a is the dimension size of W 1 x iand W 2 x j .

Original: a ri,j is the edge weight between node v i and v j learned from node representations.
Revised: a ri,j is the edge weight between node v i and v j learned from node representations.

Original: Sucha design naturally satisfies that a ri,j ∈ (0 , 1] .
Revised: Sucha design naturally satisfies that a ri,j ∈ (0 , 1] .

Original: Moreover, by introducing two weight matrices W 1and W 2 , the learned task-specific structured will be a directed graph to encode more information.
Revised: Moreover, by introducing two weight matrices W 1and W 2 , the learned task-specific structured will be a directed graph to encode more information.

Original: • Structures as input.
Revised: • Structures as input.

Original: [Equation]
Revised: [Equation]

Original: where ψ is a learned function that outputs a scalar while utilizing the shortest path distance betweenv i and v j (i.e., SPD ( v i , v j ) ) on the original graph.
Revised: where ψ is a learned function that outputs a scalar while utilizing the shortest path distance betweenv i and v j (i.e., SPD ( v i , v j ) ) on the original graph.

Original: In this way, we can preserve the structuralinformation on the original graph by mapping the distance to a scalar.
Revised: In this way, we can preserve the structuralinformation on the original graph by mapping the distance to a scalar.

Original: For example, if ψ is learnedas a decreasing function regarding the input SPD ( v i , v j ) , the obtained task-specific structure willresult in stronger correlations among nodes that are close to each other on the original graph.
Revised: For example, if ψ is learnedas a decreasing function regarding the input SPD ( v i , v j ) , the obtained task-specific structure willresult in stronger correlations among nodes that are close to each other on the original graph.

Original: 3.2 Learning Task-specific Structures from Labeled Nodes
Revised: 3.2 Learning Task-specific Structures from Labeled Nodes

Original: With the proposed functions for edge weights, we still need to optimize these weights to obtain thetask-specific structure for T .
Revised: With the proposed functions for edge weights, we still need to optimize these weights to obtain thetask-specific structure for T .

Original: In particular, we can leverage the label information inside labeled nodes(i.e.
Revised: In particular, we can leverage the label information inside labeled nodes(i.e.

Original: , support nodes in each meta-task).
Revised: , support nodes in each meta-task).

Original: Intuitively, the task-specific structure should ensure thatthe learned representations of nodes in the same class are similar, so that the classification of thisclass will be easier.
Revised: Intuitively, the task-specific structure should ensure thatthe learned representations of nodes in the same class are similar, so that the classification of thisclass will be easier.

Original: According to Definition 1, larger node influence represents stronger correlationsbetween nodes, which will increase the similarity between the learned representations.
Revised: According to Definition 1, larger node influence represents stronger correlationsbetween nodes, which will increase the similarity between the learned representations.

Original: Therefore,we propose to enhance the node influence between support nodes in each class to optimize thetask-specific structure.
Revised: Therefore,we propose to enhance the node influence between support nodes in each class to optimize thetask-specific structure.

Original: However, directly calculating the Jacobian matrix ∥
Revised: However, directly calculating the Jacobian matrix ∥

Original: ∂ h
Revised: ∂ h

Original: i /∂ h
Revised: i /∂ h

Original: j ∥ can result in anexcessively large computational cost, especially when the representations are high-dimensional [18].
Revised: j ∥ can result in anexcessively large computational cost, especially when the representations are high-dimensional [18].

Original: Hence, instead of directly computing the node influence, we propose to enhance the node influencebased on the following theorem:
Revised: Hence, instead of directly computing the node influence, we propose to enhance the node influencebased on the following theorem:

Original: Theorem 3.2 (Node Influence within Classes) .
Revised: Theorem 3.2 (Node Influence within Classes) .

Original: Consider the expectation of node influence from the jth node v j to all nodes in its same class C on G , where v j ∈ C .
Revised: Consider the expectation of node influence from the jth node v j to all nodes in its same class C on G , where v j ∈ C .

Original: Assume that |C| = K > 2 .
Revised: Assume that |C| = K > 2 .

Original: The overallnode influence is E (cid:16)(cid:80) v i ∈C\{ v j } I ( v i , v j ) (cid:17) =
Revised: The overallnode influence is E (cid:16)(cid:80) v i ∈C\{ v j } I ( v i , v j ) (cid:17) =

Original: (cid:80) v i ∈C\{ v j } K − 2 n − 1 h ⊤ j
Revised: (cid:80) v i ∈C\{ v j } K − 2 n − 1 h ⊤ j

Original: · h i / ∥
Revised: · h i / ∥

Original: h j ∥ 2 − (cid:80) v k ∈V\C K − 1 n − 1 h ⊤ j ·h k / ∥
Revised: h j ∥ 2 − (cid:80) v k ∈V\C K − 1 n − 1 h ⊤ j ·h k / ∥

Original: h j ∥ 2 , where n is the number of nodes in G .
Revised: h j ∥ 2 , where n is the number of nodes in G .

Original: The proof is deferred to Appendix B. Theorem 3.2 states that maximizing the node influence withinone class is equivalent to maximizing the similarity within classes while minimizing similaritybetween classes.
Revised: The proof is deferred to Appendix B. Theorem 3.2 states that maximizing the node influence withinone class is equivalent to maximizing the similarity within classes while minimizing similaritybetween classes.

Original: Specifically, the similarity is measured by the dot product between representationsof v j and other nodes.
Revised: Specifically, the similarity is measured by the dot product between representationsof v j and other nodes.

Original: In this way, we can effectively optimize the edge weights by increasingthe node influence within each class without a significant computational cost.
Revised: In this way, we can effectively optimize the edge weights by increasingthe node influence within each class without a significant computational cost.

Original: The overall loss inmeta-task T can be formulated as follows:
Revised: The overall loss inmeta-task T can be formulated as follows:

Original: [Equation]
Revised: [Equation]

Original: where C l denotes the node set of the l -th support class in meta-task T , and |C l | = K .
Revised: where C l denotes the node set of the l -th support class in meta-task T , and |C l | = K .

Original: 3.3 Learning Task-specific Structures from Unlabeled Nodes
Revised: 3.3 Learning Task-specific Structures from Unlabeled Nodes

Original: Mutual Information.
Revised: Mutual Information.

Original: Although we have leveraged the information in support nodes by enhancingnode influence, the unlabeled nodes (i.e., query nodes) in G T remain unused.
Revised: Although we have leveraged the information in support nodes by enhancingnode influence, the unlabeled nodes (i.e., query nodes) in G T remain unused.

Original: Thus, we furtherpropose to utilize the query nodes to improve the learning of task-specific structures.
Revised: Thus, we furtherpropose to utilize the query nodes to improve the learning of task-specific structures.

Original: Specifically, weleverage the concept of mutual information (MI) [19] by maximizing the MI between query nodesand their potential labels.
Revised: Specifically, weleverage the concept of mutual information (MI) [19] by maximizing the MI between query nodesand their potential labels.

Original: Formally, the MI can be represented as follows:
Revised: Formally, the MI can be represented as follows:

Original: [Equation]
Revised: [Equation]

Original: where p ij := P ( y i =
Revised: where p ij := P ( y i =

Original: j | x i ) and ¯ p j = (cid:80) i ∈Q p ij / |Q| .
Revised: j | x i ) and ¯ p j = (cid:80) i ∈Q p ij / |Q| .

Original: Q is the query node set in meta-task T .
Revised: Q is the query node set in meta-task T .

Original: Here
Revised: Here

Original: X Q and Y Q are the features and labels of query nodes, respectively.
Revised: X Q and Y Q are the features and labels of query nodes, respectively.

Original: In particular, by maximizingthe mutual information between query nodes and their labels, the learned task-specific structure caneffectively leverage the information from the query set.
Revised: In particular, by maximizingthe mutual information between query nodes and their labels, the learned task-specific structure caneffectively leverage the information from the query set.

Original: Transformed Markov Chain.
Revised: Transformed Markov Chain.

Original: Although the strategy of maximizing MI between X Q and Y Q hasproven to be effective in few-shot learning, it remains non-trivial to utilize such a strategy for learningtask-specific structures.
Revised: Although the strategy of maximizing MI between X Q and Y Q hasproven to be effective in few-shot learning, it remains non-trivial to utilize such a strategy for learningtask-specific structures.

Original: Specifically, the crucial part is to model the dependency of classificationprobabilities (i.e., p ij ) on the learned task-specific structure.
Revised: Specifically, the crucial part is to model the dependency of classificationprobabilities (i.e., p ij ) on the learned task-specific structure.

Original: In this way, we can leverage the mutualinformation to help optimize the task-specific structure.
Revised: In this way, we can leverage the mutualinformation to help optimize the task-specific structure.

Original: To estimate the classification probability,we propose to utilize node influence inferred from the task-specific structure in each meta-task.
Revised: To estimate the classification probability,we propose to utilize node influence inferred from the task-specific structure in each meta-task.

Original: Intuitively, we can assume that the higher node influence between two nodes can represent a largerprobability that they share the same class.
Revised: Intuitively, we can assume that the higher node influence between two nodes can represent a largerprobability that they share the same class.

Original: As a result, by estimating the node influence betweena query node and a support node, we can optimize the task-specific structure based on Eq.
Revised: As a result, by estimating the node influence betweena query node and a support node, we can optimize the task-specific structure based on Eq.

Original: However, it still remains challenging to obtain an exact value of the node influence due to thepotential computation cost of calculating the Jacobian matrix.
Revised: However, it still remains challenging to obtain an exact value of the node influence due to thepotential computation cost of calculating the Jacobian matrix.

Original: Therefore, we propose to estimatenode influence via the absorbing probability in a Markov chain [20].
Revised: Therefore, we propose to estimatenode influence via the absorbing probability in a Markov chain [20].

Original: Particularly, we create a Markovchain with absorbing states, where each state corresponds to a node on G T .
Revised: Particularly, we create a Markovchain with absorbing states, where each state corresponds to a node on G T .

Original: Here the support nodesin G T will be transformed into the absorbing states.
Revised: Here the support nodesin G T will be transformed into the absorbing states.

Original: Denoting the current adjacency matrix for G Tas A , we obtain the transition matrix of the Markov chain from A as follows: (1) The transitionprobability from a support node to other nodes is 0 (i.e., the absorbing state).
Revised: Denoting the current adjacency matrix for G Tas A , we obtain the transition matrix of the Markov chain from A as follows: (1) The transitionprobability from a support node to other nodes is 0 (i.e., the absorbing state).

Original: Each entry isrow-wise normalized to ensure that the sum of each row equals 1 (i.e., the transition probabilitiesstarting from one node should sum up to 1).
Revised: Each entry isrow-wise normalized to ensure that the sum of each row equals 1 (i.e., the transition probabilitiesstarting from one node should sum up to 1).

Original: Denoting the obtained transition probability matrix as ˜ A .
Revised: Denoting the obtained transition probability matrix as ˜ A .

Original: Here we theoretically validate that the node influence between a query node and a support node canbe effectively and efficiently estimated by the absorbing probability.
Revised: Here we theoretically validate that the node influence between a query node and a support node canbe effectively and efficiently estimated by the absorbing probability.

Original: Theorem 3.3 (Absorbing Probabilities and Node Influence) .
Revised: Theorem 3.3 (Absorbing Probabilities and Node Influence) .

Original: Consider the Markov chain with atransition matrix ˜
Revised: Consider the Markov chain with atransition matrix ˜

Original: A derived from a graph G .
Revised: A derived from a graph G .

Original: Denote the probability of being absorbed in the j -thstate (absorbing state) when starting from the i -th state as b i,j .
Revised: Denote the probability of being absorbed in the j -thstate (absorbing state) when starting from the i -th state as b i,j .

Original: Then, I ( v i , v j )
Revised: Then, I ( v i , v j )

Original: =
Revised: =

Original: b i,j , where I ( v i , v j )is the node influence from the i -th node v i to the j -th node v j on G .
Revised: b i,j , where I ( v i , v j )is the node influence from the j -th node v i to the i -th node v j on G .

Original: The proof is provided in Appendix C. Theorem 3.3 provides that with the learned task-specificstructure in meta-task T , the node influence of a support node on a query node equals the absorbingprobability starting from the query node to the support node in the Markov chain.
Revised: The proof is provided in Appendix C. Theorem 3.3 provides that with the learned task-specificstructure in meta-task T , the node influence of a support node on a query node equals the absorbingprobability starting from the query node to the support node in the Markov chain.

Original: In consequence, wecan leverage the property of Markov chains to provide an efficient approximation for node influence.
Revised: In consequence, wecan leverage the property of Markov chains to provide an efficient approximation for node influence.

Original: Theorem 3.4 (Approximation of Absorbing Probabilities) .
Revised: Theorem 3.4 (Approximation of Absorbing Probabilities) .

Original: Denote t as the number of non-absorbingstates in the Markov chain, i.e., t = |V T | − |S| , where |V T | is the node set in G T .
Revised: Denote t as the number of non-absorbingstates in the Markov chain, i.e., t = |V T | − |S| , where |V T | is the node set in G T .

Original: Denote Q ∈ R t × tas the transition probability matrix for non-absorbing states in the Markov chain.
Revised: Denote Q ∈ R t × tas the transition probability matrix for non-absorbing states in the Markov chain.

Original: Estimating b i,jwith ˜ b
Revised: Estimating b i,jwith ˜ b

Original: i,j = (cid:80) tk =1 ˜
Revised: i,j = (cid:80) tk =1 ˜

Original: A k,j · (cid:80) mh
Revised: A k,j · (cid:80) mh

Original: =0 (cid:0) Q h (cid:1) i,k , then the absolute error is upper bounded as | b i,j − ˜
Revised: =0 (cid:0) Q h (cid:1) i,k , then the absolute error is upper bounded as | b i,j − ˜

Original: b i,j | ≤
Revised: b i,j | ≤

Original: C/t m − 1 ( t − 1) , where m controls the upper bound, and C is a constant.
Revised: C/t m − 1 ( t − 1) , where m controls the upper bound, and C is a constant.

Original: The proof is provided in Appendix D. Theorem 3.4 indicates that the estimation error of nodeinfluence is upper bounded by C/t m − 1 ( t − 1) , which is controlled by m .
Revised: The proof is provided in Appendix D. Theorem 3.4 indicates that the estimation error of nodeinfluence is upper bounded by C/t m − 1 ( t − 1) , which is controlled by m .

Original: Therefore, we can adjustthe value of m to fit in different application scenarios.
Revised: Therefore, we can adjustthe value of m to fit in different application scenarios.

Original: With Theorem 3.3 and Theorem 3.4, we canestimate the value of the classification probability as follows:
Revised: With Theorem 3.3 and Theorem 3.4, we canestimate the value of the classification probability as follows:

Original: [Equation]
Revised: [Equation]

Original: As a result, we can optimize the objective in Eq.
Revised: As a result, we can optimize the objective in Eq.

Original: (5) according to the estimated node influence.
Revised: (5) according to the estimated node influence.

Original: In thisway, we can adjust edge weights to reach a state that is tailored for this meta-task T and beneficialfor the following classification of query nodes.
Revised: In thisway, we can adjust edge weights to reach a state that is tailored for this meta-task T and beneficialfor the following classification of query nodes.

Original: 3.4 Meta Optimization
Revised: 3.4 Meta Optimization

Original: To effectively accumulate learned meta-knowledge across a variety of meta-tasks, we adopt theprevalent meta-optimization strategy based on MAML [21].
Revised: To effectively accumulate learned meta-knowledge across a variety of meta-tasks, we adopt theprevalent meta-optimization strategy based on MAML [21].

Original: Generally, MAML aims at learning theunique update scheme based on each meta-task for fast adaptation to novel meta-tasks.
Revised: Generally, MAML aims at learning theunique update scheme based on each meta-task for fast adaptation to novel meta-tasks.

Original: Specifically,for each meta-task, we first perform several update steps to learn task-specific structures based onthe two structure losses: θ ( i ) S
Revised: Specifically,for each meta-task, we first perform several update steps to learn task-specific structures based onthe two structure losses: θ ( i ) S

Original: = θ ( i − 1)
Revised: = θ ( i − 1)

Original: S − α ∇L ( i ) S , where θ S denotes the parameters used to learntask-specific structures, and L ( i ) S
Revised: S − α ∇L ( i ) S , where θ S denotes the parameters used to learntask-specific structures, and L ( i ) S

Original: =
Revised: =

Original: L ( i ) N + L ( i ) M .
Revised: L ( i ) N + L ( i ) M .

Original: During each update step, we leverage a GNN to learnnode representations from the current task-specific structure, followed by an MLP layer to classifythe support nodes: θ ( i ) G
Revised: During each update step, we leverage a GNN to learnnode representations from the current task-specific structure, followed by an MLP layer to classifythe support nodes: θ ( i ) G

Original: = θ
Revised: = θ

Original: ( i − 1) G − α ∇L ( i ) support , where L ( i ) support = − (cid:80) k ∈S (cid:80)
Revised: ( i − 1) G − α ∇L ( i ) support , where L ( i ) support = − (cid:80) k ∈S (cid:80)

Original: j y k,j log p ( i ) k,j is thecross-entropy loss, and α is the base learning rate.
Revised: j y k,j log p ( i ) k,j is thecross-entropy loss, and α is the base learning rate.

Original: Here y k,j ∈ { 0 , 1 } and y k,j = 1 if the k -th nodein S (i.e., the support set) belongs to the j -th support class in meta-task T ; otherwise y k,j = 0 .
Revised: Here y k,j ∈ { 0 , 1 } and y k,j = 1 if the k -th nodein S (i.e., the support set) belongs to the j -th support class in meta-task T ; otherwise y k,j = 0 .

Original: p ( i ) k,jis the j -the entry of the class distribution vector p ( i ) k calculated by p ( i ) k
Revised: p ( i ) k,jis the j -the entry of the class distribution vector p ( i ) k calculated by p ( i ) k

Original: = Softmax ( MLP ( h ( i ) k )) ,where h ( i ) k is extracted from the learned node representations H ( i ) =
Revised: = Softmax ( MLP ( h ( i ) k )) ,where h ( i ) k is extracted from the learned node representations H ( i ) =

Original: GNN ( A ( i ) , X ) .
Revised: GNN ( A ( i ) , X ) .

Original: Here A ( i ) isthe edge weights during the i -th step.
Revised: Here A ( i ) isthe edge weights during the i -th step.

Original: θ G denotes the parameters of the GNN and the MLP classifier.
Revised: θ G denotes the parameters of the GNN and the MLP classifier.

Original: After repeating these steps for η times, the loss on the query set will be used for the meta-update:θ G = θ ( η ) G − β 1 ∇L ( η ) query and θ S = θ ( η ) S − β 2 ∇L ( η ) S , where β 1 and β 2 are the meta-learning rates,and L ( η ) query is the cross-entropy loss calculated on query nodes.
Revised: After repeating these steps for η times, the loss on the query set will be used for the meta-update:θ G = θ ( η ) G − β 1 ∇L ( η ) query and θ S = θ ( η ) S − β 2 ∇L ( η ) S , where β 1 and β 2 are the meta-learning rates,and L ( η ) query is the cross-entropy loss calculated on query nodes.

Original: For the meta-test tasks, we will usethe final meta-updated parameters to evaluate the model.
Revised: For the meta-test tasks, we will usethe final meta-updated parameters to evaluate the model.

Original:  Experiments
Revised:  Experiments

Original: Experimental settings.
Revised: Experimental settings.

Original: The training process of our framework is conducted on a series ofmeta-training tasks.
Revised: The training process of our framework is conducted on a series ofmeta-training tasks.

Original: After training, the model will be evaluated on a specific number of metatest tasks.
Revised: After training, the model will be evaluated on a specific number of metatest tasks.

Original: Here we introduce four few-shot node classification settings for the experiments.
Revised: Here we introduce four few-shot node classification settings for the experiments.

Original: Shared graphs with disjoint labels.
Revised: Shared graphs with disjoint labels.

Original: Under this setting, the meta-training and meta-test tasks are sampled from the same graph set.
Revised: Under this setting, the meta-training and meta-test tasks are sampled from the same graph set.

Original: The labels in meta-test tasks are disjoint from those in meta-trainingtasks.
Revised: The labels in meta-test tasks are disjoint from those in meta-trainingtasks.

Original: (2) Disjoint graphs with shared labels.
Revised: (2) Disjoint graphs with shared labels.

Original: Under this setting, the meta-training tasks and meta-testtasks are from disjoint graph sets.
Revised: Under this setting, the meta-training tasks and meta-testtasks are from disjoint graph sets.

Original: In other words, the graphs in meta-test tasks will be new graphsunseen during training.
Revised: In other words, the graphs in meta-test tasks will be new graphsunseen during training.

Original: The labels are shared during training and test, which slightly decrease thedifficulty.
Revised: The labels are shared during training and test, which slightly decrease thedifficulty.

Original: (3) Disjoint graphs with disjoint labels.
Revised: (3) Disjoint graphs with disjoint labels.

Original: Under this setting, both the graph set and the labelset of meta-test tasks are disjoint from those in meta-training tasks.
Revised: Under this setting, both the graph set and the labelset of meta-test tasks are disjoint from those in meta-training tasks.

Original: That being said, the model is required to handle new labels on graphs unseen during training, which renders the highest difficulty.
Revised: That being said, the model is required to handle new labels on graphs unseen during training, which renders the highest difficulty.

Original: Single graph with disjoint labels.
Revised: Single graph with disjoint labels.

Original: This setting is widely adopted in existing graph few-shot learningmethods [9, 22, 10].
Revised: This setting is widely adopted in existing graph few-shot learningmethods [9, 22, 10].

Original: Under this setting, all nodes will be sampled from the same graph.
Revised: Under this setting, all nodes will be sampled from the same graph.

Original: Note thatsetting (1) and setting (2) are proposed in G-Meta [1], while setting (3) is a new setting introduced inthis paper.
Revised: Note thatsetting (1) and setting (2) are proposed in G-Meta [1], while setting (3) is a new setting introduced inthis paper.

Original: Detailed experimental and parameter settings are provided in Appendix E.
Revised: Detailed experimental and parameter settings are provided in Appendix E.

Original: Datasets.
Revised: Datasets.

Original: To evaluate the performance of GLITTER on the few-shot node classification task, weconduct experiments on five prevalent real-world graph datasets, two for the multiple-graph settingand three for the single-graph setting.
Revised: To evaluate the performance of GLITTER on the few-shot node classification task, weconduct experiments on five prevalent real-world graph datasets, two for the multiple-graph settingand three for the single-graph setting.

Original: The detailed statistics are provided in Table 1.
Revised: The detailed statistics are provided in Table 1.

Original: For the multiplegraph setting, we use the following two datasets: (1) Tissue-PPI [23] consists of 24 protein-proteininteraction (PPI) networks obtained from different types of tissues.
Revised: For the multiplegraph setting, we use the following two datasets: (1) Tissue-PPI [23] consists of 24 protein-proteininteraction (PPI) networks obtained from different types of tissues.

Original: Specifically, node featuresare gene signatures, and labels are gene ontology functions.
Revised: Specifically, node featuresare gene signatures, and labels are gene ontology functions.

Original: This dataset consists of ten binaryclassification tasks.
Revised: This dataset consists of ten binaryclassification tasks.

Original: (2) Fold-PPI [1] contains of 144 tissue PPI networks, where the node labels areprotein structures in SCOP database [24].
Revised: (2) Fold-PPI [1] contains of 144 tissue PPI networks, where the node labels areprotein structures in SCOP database [24].

Original: Moreover, the node features are conjoint triad proteindescriptors [25].
Revised: Moreover, the node features are conjoint triad proteindescriptors [25].

Original: There are 29 classes in this dataset.
Revised: There are 29 classes in this dataset.

Original: For the single-graph setting, we leveragethree datasets: (1) DBLP [14] is a citation network with nodes and edges representing papers andcitation relations, respectively.
Revised: For the single-graph setting, we leveragethree datasets: (1) DBLP [14] is a citation network with nodes and edges representing papers andcitation relations, respectively.

Original: The node features are based on the paper abstracts, and the labelsare determined by the paper venues.
Revised: The node features are based on the paper abstracts, and the labelsare determined by the paper venues.

Original: This dataset consists of 137 classes.
Revised: This dataset consists of 137 classes.

Original: (2) Cora-full [26] is also acitation network which contains 70 classes.
Revised: (2) Cora-full [26] is also acitation network which contains 70 classes.

Original: (3) ogbn-arxiv [27] is a citation network that consists of20 classes and significantly more nodes than other datasets.
Revised: (3) ogbn-arxiv [27] is a citation network that consists of20 classes and significantly more nodes than other datasets.

Original: [Table]
Revised: [Table]

Original: Baseline methods.
Revised: Baseline methods.

Original: (1) KNN [28] trains a GNN based on all samples in training graphs to learn noderepresentations.
Revised: (1) KNN [28] trains a GNN based on all samples in training graphs to learn noderepresentations.

Original: Then it classifies query samples according to the labels in the support set of eachmeta-task.
Revised: Then it classifies query samples according to the labels in the support set of eachmeta-task.

Original: (2) ProtoNet [17] learns the prototype of each class by averaging its node representations.
Revised: (2) ProtoNet [17] learns the prototype of each class by averaging its node representations.

Original: Then it classifies query samples based on their distances to the prototypes.
Revised: Then it classifies query samples based on their distances to the prototypes.

Original: (3) MAML [21] adoptsthe meta-learning strategy and learns node representations via GNNs.
Revised: (3) MAML [21] adoptsthe meta-learning strategy and learns node representations via GNNs.

Original: (4) Meta-GNN combines
Revised: (4) Meta-GNN combines

Original: MAML with Simple Graph Convolution (SGC) [29].
Revised: MAML with Simple Graph Convolution (SGC) [29].

Original: (5) G-Meta [1] learns node representationsfrom extracted local subgraphs and further adopts MAML for meta-learning.
Revised: (5) G-Meta [1] learns node representationsfrom extracted local subgraphs and further adopts MAML for meta-learning.

Original: (6) GPN [9] learnsprototypes based on node importance and classifies query nodes according to their distances to thelearned prototypes.
Revised: (6) GPN [9] learnsprototypes based on node importance and classifies query nodes according to their distances to thelearned prototypes.

Original: (7) RALE [11] learns node dependencies based on node locations on the graph.
Revised: (7) RALE [11] learns node dependencies based on node locations on the graph.

Original: It is noteworthy that Meta-GNN, GPN, and RALE only work for the single-graph setting, while otherbaseline methods can be applied to both single-graph and multiple-graph settings.
Revised: It is noteworthy that Meta-GNN, GPN, and RALE only work for the single-graph setting, while otherbaseline methods can be applied to both single-graph and multiple-graph settings.

Original: 4.1 Main Results
Revised: 4.1 Main Results

Original: Table 2 and Table 3 present the performance comparison of our framework GLITTER and allbaselines on few-shot node classification under the multiple-graph setting and the single-graphsetting, respectively.
Revised: Table 2 and Table 3 present the performance comparison of our framework GLITTER and allbaselines on few-shot node classification under the multiple-graph setting and the single-graphsetting, respectively.

Original: Specifically, for the multiple-graph task, we conduct experiments under threesettings (i.e., shared graphs with disjoint labels, disjoint graphs with shared labels, and disjoint graphswith disjoint labels).
Revised: Specifically, for the multiple-graph task, we conduct experiments under threesettings (i.e., shared graphs with disjoint labels, disjoint graphs with shared labels, and disjoint graphswith disjoint labels).

Original: For the single-graph task, we choose two different few-shot settings to obtaina more comprehensive comparison: 5-way 3-shot (i.e., N = 5 and K = 3 ) and 10-way 3-shot(i.e.
Revised: For the single-graph task, we choose two different few-shot settings to obtaina more comprehensive comparison: 5-way 3-shot (i.e., N = 5 and K = 3 ) and 10-way 3-shot(i.e.

Original: , N = 10 and K = 3 ).
Revised: , N = 10 and K = 3 ).

Original: For the evaluation metric, we utilize the average classification accuracyover 10 repetitions.
Revised: For the evaluation metric, we utilize the average classification accuracyover 10 repetitions.

Original: From Table 2 and Table 3, we can obtain the follow observations: (1) Ourframework GLITTER outperforms all other baselines in all multiple-graph and single-graph datasets.
Revised: From Table 2 and Table 3, we can obtain the follow observations: (1) Ourframework GLITTER outperforms all other baselines in all multiple-graph and single-graph datasets.

Original: GLITTER also consistently achieves the best results under different settings, which validates thesuperiority of GLITTER on few-shot node classification problems.
Revised: GLITTER also consistently achieves the best results under different settings, which validates thesuperiority of GLITTER on few-shot node classification problems.

Original: (2) When the multiple-graphsetting is conducted with disjoint graphs, GLITTER has the least performance drop compared withother baselines.
Revised: (2) When the multiple-graphsetting is conducted with disjoint graphs, GLITTER has the least performance drop compared withother baselines.

Original: This is because the learned task-specific structure is tailored for each meta-taskand is thus more capable in the multiple-graph setting, where the structures in meta-tasks acrossgraphs can vary greatly.
Revised: This is because the learned task-specific structure is tailored for each meta-taskand is thus more capable in the multiple-graph setting, where the structures in meta-tasks acrossgraphs can vary greatly.

Original: The performance improvement of GLITTER over other baselines isrelatively larger on Fold-PPI and DBLP .
Revised: The performance improvement of GLITTER over other baselines isrelatively larger on Fold-PPI and DBLP .

Original: This is because these datasets consist of more classes thanother datasets under the same setting.
Revised: This is because these datasets consist of more classes thanother datasets under the same setting.

Original: Since the classes in different meta-tasks are more diversely distributed, the task-specific structures learned by GLITTER will provide better performance in thissituation.
Revised: Since the classes in different meta-tasks are more diversely distributed, the task-specific structures learned by GLITTER will provide better performance in thissituation.

Original: (4) When the value of N increases (i.e., larger class set in each meta-task), the performanceof all baselines drops significantly due to the higher classification difficulty.
Revised: (4) When the value of N increases (i.e., larger class set in each meta-task), the performanceof all baselines drops significantly due to the higher classification difficulty.

Original: Nevertheless, GLITTERconsistently outperforms the other baselines.
Revised: Nevertheless, GLITTERconsistently outperforms the other baselines.

Original: The reason is that a larger class set in a meta-task willrequire more specific representations for classification due to the variety of classes.
Revised: The reason is that a larger class set in a meta-task willrequire more specific representations for classification due to the variety of classes.

Original: [Table]
Revised: [Table]

Original: [Table] [Table]
Revised: [Table] [Table]

Original: [Table] [Table]
Revised: [Table] [Table]

Original: 4.2 Ablation Study
Revised: 4.2 Ablation Study

Original: In this section
Revised: In this section

Original: [Table]
Revised: [Table]

Original: we perform a series of ablations studies to evaluate the effectiveness of differentcomponents in our framework GLITTER.
Revised: we perform a series of ablations studies to evaluate the effectiveness of differentcomponents in our framework GLITTER.

Original: The results are presented in Figure 2.
Revised: The results are presented in Figure 2.

Original: Specifically, wecompare our proposed framework GLITTER with three degenerate versions: (1) GLITTER withoutsampling relevant nodes (i.e., the task-specific structure only consists of support nodes and querynodes), denoted as GLITTER\S; (2) GLITTER without enhancing the node influence within classes,denoted as GLITTER\N; (3) GLITTER without maximizing the mutual information between querynodes and their potential labels, denoted as GLITTER\M. From Figure 2, we can obtain severalmeaningful observations.
Revised: Specifically, wecompare our proposed framework GLITTER with three degenerate versions: (1) GLITTER withoutsampling relevant nodes (i.e., the task-specific structure only consists of support nodes and querynodes), denoted as GLITTER\S; (2) GLITTER without enhancing the node influence within classes,denoted as GLITTER\N; (3) GLITTER without maximizing the mutual information between querynodes and their potential labels, denoted as GLITTER\M. From Figure 2, we can obtain severalmeaningful observations.

Original: First, our framework consistently outperforms all variants with certaincomponents removed, which demonstrates that each module in GLITTER plays a crucial role inlearning task-specific structures.
Revised: First, our framework consistently outperforms all variants with certaincomponents removed, which demonstrates that each module in GLITTER plays a crucial role inlearning task-specific structures.

Original: Second, removing the relevant nodes deteriorates the performanceunder the multiple-graph setting with disjoint graphs more than that on shared graphs.
Revised: Second, removing the relevant nodes deteriorates the performanceunder the multiple-graph setting with disjoint graphs more than that on shared graphs.

Original: The reasonis meta-knowledge from training graphs can be uninformative for a novel graph during evaluation.
Revised: The reasonis meta-knowledge from training graphs can be uninformative for a novel graph during evaluation.

Original: As a result, the relevant nodes on the novel graph become more crucial for learning task-specificstructures.
Revised: As a result, the relevant nodes on the novel graph become more crucial for learning task-specificstructures.

Original: Third, the performance decreases differently by removing the node influence moduleor the mutual information module.
Revised: Third, the performance decreases differently by removing the node influence moduleor the mutual information module.

Original: Specifically, removing node influence generally causes a moresignificant drop when N increases.
Revised: Specifically, removing node influence generally causes a moresignificant drop when N increases.

Original: This is due to that a larger class set in each meta-task requiresmore distinct node representations in different classes.
Revised: This is due to that a larger class set in each meta-task requiresmore distinct node representations in different classes.

Original: Therefore, enhancing the node influence canprovide better performance by enlarging correlations within classes.
Revised: Therefore, enhancing the node influence canprovide better performance by enlarging correlations within classes.

Original:  Related Work
Revised:  Related Work

Original: Few-shot Learning on Graphs.
Revised: Few-shot Learning on Graphs.

Original: Few-shot learning aims at effectively solving tasks with scarcelabeled samples as references.
Revised: Few-shot learning aims at effectively solving tasks with scarcelabeled samples as references.

Original: The general approach is to learn meta-knowledge from tasks withabundant labeled samples and generalize it to a new task with few labeled samples.
Revised: The general approach is to learn meta-knowledge from tasks withabundant labeled samples and generalize it to a new task with few labeled samples.

Original: Few-shot learning
Revised: Few-shot learning

Original: VKDUHGJUDSKVGLVMRLQWODEHOV GLVMRLQWJUDSKVVKDUHGODEHOV GLVMRLQWJUDSKVGLVMRLQWODEHOV    
Revised: VKDUHGJUDSKVGLVMRLQWODEHOV GLVMRLQWJUDSKVVKDUHGODEHOV GLVMRLQWJUDSKVGLVMRLQWODEHOV    

Original: [Figure]
Revised: [Figure]

Original: H V W  $ FF X U DF \     */,77( */,77(5? */,77(5? */,77(5?
Revised: H V W  $ FF X U DF \     */,77( */,77(5? */,77(5? */,77(5?

Original: [Figure]
Revised: [Figure]

Original: VKDUHGJUDSKVGLVMRLQWODEHOV GLVMRLQWJUDSKVVKDUHGODEHOV GLVMRLQWJUDSKVGLVMRLQWODEHOV   
Revised: VKDUHGJUDSKVGLVMRLQWODEHOV GLVMRLQWJUDSKVVKDUHGODEHOV GLVMRLQWJUDSKVGLVMRLQWODEHOV   

Original: 
Revised: 

Original: [Figure]
Revised: [Figure]

Original:  */,77( */,77(5? */,77(5? */,77(5?
Revised:  */,77( */,77(5? */,77(5? */,77(5?

Original: [Figure]
Revised: [Figure]

Original: &RUDIXOO RJEQDU[LY
Revised: &RUDIXOO RJEQDU[LY

Original: [Figure]
Revised: [Figure]

Original:    
Revised:    

Original: [Figure]
Revised: [Figure]

Original: DF
Revised: DF

Original: [Figure]
Revised: [Figure]

Original:  */,77( */,77(5? */,77(5?
Revised:  */,77( */,77(5? */,77(5?

Original: [Figure]
Revised: [Figure]

Original: &RUDIXOO RJEQDU[LY
Revised: &RUDIXOO RJEQDU[LY

Original: [Figure]
Revised: [Figure]

Original:    
Revised:    

Original: [Figure]
Revised: [Figure]

Original: frameworks generally adopt the meta-learning strategy, which means both training and test processeswill be conducted on a series of learning tasks.
Revised: frameworks generally adopt the meta-learning strategy, which means both training and test processeswill be conducted on a series of learning tasks.

Original: Existing few-shot learning methods can be broadlydivided into two categories: (1) Metric-based approaches, which aim at learning a metric functionbetween the query set and the support set for classification [16, 30, 31, 17].
Revised: Existing few-shot learning methods can be broadlydivided into two categories: (1) Metric-based approaches, which aim at learning a metric functionbetween the query set and the support set for classification [16, 30, 31, 17].

Original: (2) Optimization-basedapproaches, which focus on updating model parameters according to gradients calculated on thesupport set in each meta-task [32, 33, 21, 34].
Revised: (2) Optimization-basedapproaches, which focus on updating model parameters according to gradients calculated on thesupport set in each meta-task [32, 33, 21, 34].

Original: Recently, many works propose to incorporate existingfew-shot learning frameworks into graph few-shot learning problems [11, 22, 12, 35, 36, 37, 38].
Revised: Recently, many works propose to incorporate existingfew-shot learning frameworks into graph few-shot learning problems [11, 22, 12, 35, 36, 37, 38].

Original: Forexample, GPN [9] leverages the importance of nodes and combines Prototypical Networks [17] tosolve few-shot node classification problem.
Revised: Forexample, GPN [9] leverages the importance of nodes and combines Prototypical Networks [17] tosolve few-shot node classification problem.

Original: G-Meta [1] extracts local subgraphs for nodes for fastadaptations across multiple graphs.
Revised: G-Meta [1] extracts local subgraphs for nodes for fastadaptations across multiple graphs.

Original: Graph Neural Networks.
Revised: Graph Neural Networks.

Original: Recently, many researchers have focused on using Graph Neural Networks(GNNs) to learn effective representation for nodes on graphs [39, 5, 40, 41, 42, 43, 40].
Revised: Recently, many researchers have focused on using Graph Neural Networks(GNNs) to learn effective representation for nodes on graphs [39, 5, 40, 41, 42, 43, 40].

Original: With GNNs,models will gradually learn comprehensive node representations based on the specific downstreamtasks [44].
Revised: With GNNs,models will gradually learn comprehensive node representations based on the specific downstreamtasks [44].

Original: In particular, GNNs learn node representations from neighbor nodes via an informationaggregation mechanism.
Revised: In particular, GNNs learn node representations from neighbor nodes via an informationaggregation mechanism.

Original: As a result, GNNs can incorporate both structural information and nodefeature information into the representation learning process.
Revised: As a result, GNNs can incorporate both structural information and nodefeature information into the representation learning process.

Original: For example, Graph Convolutional
Revised: For example, Graph Convolutional

Original: Networks (GCNs) [8] leverage a first-order approximation to learn node representations with graphconvolution layers in a simplified manner.
Revised: Networks (GCNs) [8] leverage a first-order approximation to learn node representations with graphconvolution layers in a simplified manner.

Original: Graph Attention Networks (GATs) [6] learn adjustableweights for neighbors nodes via the attention mechanism to aggregate features of neighboring nodesin an adaptive manner.
Revised: Graph Attention Networks (GATs) [6] learn adjustableweights for neighbors nodes via the attention mechanism to aggregate features of neighboring nodesin an adaptive manner.

Original:  Conclusion
Revised:  Conclusion

Original: In this paper, we propose to learn task-specific structures for each meta-task in graph few-shot learning,so that the learned node representations will be tailored for each meta-task.
Revised: In this paper, we propose to learn task-specific structures for each meta-task in graph few-shot learning,so that the learned node representations will be tailored for each meta-task.

Original: To handle the varietyof nodes among meta-tasks, we propose an innovative framework, GLITTER, to extract importantnodes and learn task-specific structures based on node influence and mutual information.
Revised: To handle the varietyof nodes among meta-tasks, we propose an innovative framework, GLITTER, to extract importantnodes and learn task-specific structures based on node influence and mutual information.

Original: As a result,our framework can adaptively learn node representations to promote classification performance ineach meta-task.
Revised: As a result,our framework can adaptively learn node representations to promote classification performance ineach meta-task.

Original: We conduct extensive experiments on five node classification datasets under both thesingle-graph and multiple-graph settings, and
Revised: We conduct extensive experiments on five node classification datasets under both thesingle-graph and multiple-graph settings, and

Original: Checklist
Revised: Checklist

Original: For all authors...
Revised: For all authors...

Original: (a) Do the main claims made in the abstract and introduction accurately reflect the paper’s
Revised: (a) Do the main claims made in the abstract and introduction accurately reflect the paper’s

Original: contributions and scope?
Revised: contributions and scope?

Original: [Yes]
Revised: [Yes]

Original: (b) Did you describe the limitations of your work?
Revised: (b) Did you describe the limitations of your work?

Original: [Yes] See Appendix F.
Revised: [Yes] See Appendix F.

Original: (c) Did you discuss any potential negative societal impacts of your work?
Revised: (c) Did you discuss any potential negative societal impacts of your work?

Original: [Yes] See
Revised: [Yes] See

Original: Appendix F.
Revised: Appendix F.

Original: (d) Have you read the ethics review guidelines and ensured that your paper conforms to
Revised: (d) Have you read the ethics review guidelines and ensured that your paper conforms to

Original: them?
Revised: them?

Original: [Yes]
Revised: [Yes]

Original: If you are including theoretical results...
Revised: If you are including theoretical results...

Original: (a) Did you state the full set of assumptions of all theoretical results?
Revised: (a) Did you state the full set of assumptions of all theoretical results?

Original: [Yes] See AppendixA.(b)
Revised: [Yes] See AppendixA.(b)

Original: Did you include complete proofs of all theoretical results?
Revised: Did you include complete proofs of all theoretical results?

Original: [Yes] See Appendix A, B,C, and D.3.
Revised: [Yes] See Appendix A, B,C, and D.3.

Original: If you ran experiments...
Revised: If you ran experiments...

Original: (a) Did you include the code, data, and instructions needed to reproduce the main experimental results (either in the supplemental material or as a URL)?
Revised: (a) Did you include the code, data, and instructions needed to reproduce the main experimental results (either in the supplemental material or as a URL)?

Original: [Yes] See thesupplemental materials.
Revised: [Yes] See thesupplemental materials.

Original: (b) Did you specify all the training details (e
Revised: (b) Did you specify all the training details (e

Original: g., data splits, hyperparameters,
Revised: g., data splits, hyperparameters,

Original: how they
Revised: how they

Original: were chosen)?
Revised: were chosen)?

Original: [Yes] See Appendix E
Revised: [Yes] See Appendix E

Original: (c) Did you report error bars (e
Revised: (c) Did you report error bars (e

Original: g., with respect to the random seed after running experiments multiple times)?
Revised: g., with respect to the random seed after running experiments multiple times)?

Original: [Yes] See Table 2 and Table 3.
Revised: [Yes] See Table 2 and Table 3.

Original: (d) Did you include the total amount of compute and the type of resources used (e.g., typeof GPUs, internal cluster, or cloud provider)?
Revised: (d) Did you include the total amount of compute and the type of resources used (e.g., typeof GPUs, internal cluster, or cloud provider)?

Original: [Yes] See Appendix E
Revised: [Yes] See Appendix E

Original: If you are using existing assets (e.g., code, data, models) or curating/releasing new assets...
Revised: If you are using existing assets (e.g., code, data, models) or curating/releasing new assets...

Original: (a) If your work uses existing assets, did you cite the creators?
Revised: (a) If your work uses existing assets, did you cite the creators?

Original: [Yes] See Section 4.
Revised: [Yes] See Section 4.

Original: (b) Did you mention the license of the assets?
Revised: (b) Did you mention the license of the assets?

Original: [Yes] See Appendix E.
Revised: [Yes] See Appendix E.

Original: (c) Did you include any new assets either in the supplemental material or as a URL?
Revised: (c) Did you include any new assets either in the supplemental material or as a URL?

Original: [Yes]
Revised: [Yes]

Original: The source code of our proposed framework is included in the supplemental materials.
Revised: The source code of our proposed framework is included in the supplemental materials.

Original: (d) Did you discuss whether and how consent was obtained from people whose data
Revised: (d) Did you discuss whether and how consent was obtained from people whose data

Original: you’re using/curating?
Revised: you’re using/curating?

Original: [N/A]
Revised: [N/A]

Original: The datasets are developed based on public data by the
Revised: The datasets are developed based on public data by the

Original: corresponding authors.
Revised: corresponding authors.

Original: (e) Did you discuss whether the data you are using/curating contains personally identifiable
Revised: (e) Did you discuss whether the data you are using/curating contains personally identifiable

Original: information or offensive content?
Revised: information or offensive content?

Original: [N/A]
Revised: [N/A]

Original: The data used in this paper does not contain
Revised: The data used in this paper does not contain

Original: identifiable information or offensive content.
Revised: identifiable information or offensive content.

Original: If you used crowdsourcing or conducted research with human subjects...
Revised: If you used crowdsourcing or conducted research with human subjects...

Original: (a) Did you include the full text of instructions given to participants and screenshots, if
Revised: (a) Did you include the full text of instructions given to participants and screenshots, if

Original: applicable?
Revised: applicable?

Original: [N/A]
Revised: [N/A]

Original: (b) Did you describe any potential participant risks, with links to Institutional Review
Revised: (b) Did you describe any potential participant risks, with links to Institutional Review

Original: Board (IRB) approvals, if applicable?
Revised: Board (IRB) approvals, if applicable?

Original: [N/A]
Revised: [N/A]

Original: (c) Did you include the estimated hourly wage paid to participants and the total amount
Revised: (c) Did you include the estimated hourly wage paid to participants and the total amount

Original: spent on participant compensation?
Revised: spent on participant compensation?

Original: [N/A]
Revised: [N/A]