Verbalized Graph Representation Learning: A Fully Interpretable Graph Model Based on Large Language Models Throughout the Entire Process

## Abstract

Abstract Representation learning on text-attributed graphs (TAGs) has attracted significant interest due to its wide-ranging real-world applications, particularly through Graph Neural Networks (GNNs). Traditional GNN methods focus on encoding the structural information of graphs, often using shallow text embeddings for node or edge attributes. This limits the model to understand the rich semantic information in the data and its reasoning ability for complex downstream tasks, while also lacking interpretability. With the rise of large language models (LLMs), an increasing number of studies are combining them with GNNs for graph representation learning and downstream tasks. While these approaches effectively leverage the rich semantic information in TAGs datasets, their main drawback is that they are only partially interpretable, which limits their application in critical fields. In this paper, we propose a verbalized graph representation learning (VGRL) method which is fully interpretable. In contrast to traditional graph machine learning models, which are usually optimized within a continuous parameter space, VGRL constrains this parameter space to be text description which ensures complete interpretability throughout the entire process, making it easier for users to understand and trust the decisions of the model. We conduct several studies to empirically evaluate the effectiveness of VGRL and we believe this method can serve as a stepping stone in graph representation learning. The source code of our model is available at https://anonymous.4open.science/r/VGRL-7E1E

## 1 Introduction

Many real-world graphs incorporate textual data, forming what are known as Text-Attributed Graphs (TAGs) (Yang et al., ). In TAGs, nodes represent textual entitities such as papers, while edges denote relationships between them, such as citations or co-authorships. For instance, the Cora dataset can be modeled as a TAG, where each node represents a research paper, and the node attributes include features such as the paper’s title, abstract, and keywords. By integrating textual attributes with graph topology, TAGs facilitate more effective representation learning, making them valuable for tasks like document classification, clustering  (Wang et al., ), citation analysis, and recommendation systems  (Zhu et al., ; Zhang et al., ). This combination of textual and relational data offers deeper insights, especially when both content and connections are essential to the analysis.

Although traditional Graph Neural Network (GNN) models, such as Graph Convolutional Network (GCN) (Kipf & Welling, ) and Graph Attention Network (GAT)  (Veličković et al., ), have achieved significant performance improvements across multiple tasks, they generally suffer from a lack of interpretability. As these models largely rely on complex network architectures and implicit feature learning processes, understanding their internal decision mechanisms and how specific features influence task outcomes becomes challenging, thereby limiting their transparency and trustworthiness in practical applications. To address this issue, researchers have proposed several interpretable GNN models.
These interpretable methods can generally be divided into input interpretability, training process interpretability, and decision-making process interpretability. For example, GNNExplainer  (Ying et al., ) is a method for input interpretability, which selects a small subgraph of the input graph together with a small subset of node features that are most influential for the prediction as an explanation, XGNN  (Yuan et al., ) is a method for training process interpretability which reveals the basis of the model’s predictions by generating interpretable graph structures, and SE-SGformer  (Li et al., ) is a method for decision-making process interpretability which constructs a novel explainable decision process by discovering the $K$-nearest (farthest) positive (negative) neighbors of a node for predicting edge signs. Clearly, while these methods all have a certain degree of interpretability, they can only explain one part of the entire process of model input, training, and output. Therefore, our goal is to implement comprehensive interpretability by simultaneously achieving input interpretability, training process interpretability, and decision-making process interpretability.

Figure: Figure 1: Comparison of Graph Representation Learning Methods (a) Traditional Graph Neural Networks (GNNs) rely on graph structures and initial features for embedding generation and prediction. (b) Incorporating a Language Model (LM) enhances GNNs, where a Large Language Model (LLM) provides explanations that refine the embedding process for improved predictions. (c) Our proposed Verbalized Graph Representation Learning (VGRL) framework introduces an iterative optimization process involving multiple frozen LLMs (Enhancer, Predictor, Optimizer, and Summary), emphasizing interpretability and parameter tuning through verbalized model adjustments.
Refer to caption: x1.png

In recent years, with the breakthroughs of large language models (LLMs) in the field of natural language processing, researchers have gradually begun to integrate them with GNNs to enhance model performance and capabilities.
For instance, LLMs can act as predictors  (Tang et al., ), generating more accurate predictions by analyzing node features and structural information for the TAGs. Also, TAPE  (He et al., ) prompts a powerful LLM to explain its predictions and serve explanations as supplementary text attributes for the downstream LMs and GNN models. Due to the powerful text inference capabilities of LLMs, they are capable of processing TAGs, reasoning about the node classification prediction process of TAGs, and generating explanations in text that is comprehensible to humans. Therefore, we consider the use of LLMs to achieve comprehensive interpretability.
However, using LLMs to handle graph tasks and provide interpretability is not easy. Specifically, there are currently two main approaches to applying LLMs in the field of graph: one is to pre-train or fine-tune LLMs to adapt to various graph downstream tasks. But due to the vast number of parameters typically found in LLMs, the cost of fine-tuning LLMs is quite high and the training time is long. The second is to directly freeze the LLMs for inference but this method does not yield good results. For example, we directly froze the predictor LLMs for node classification prediction in subsequent experiments, and the prediction accuracy was generally not high, as shown in Table 5.2.

In summary, we face two major challenges to achieve comprehensive interpretability with LLMs:

Challenge 1: How can we ensure that a model is interpretable in terms of input, training process, and decision-making simultaneously?

Challenge 2: How can we optimize the performance of LLMs without fine-tuning the model parameters to reduce costs?

To address these challenges, we propose the Verbalized Graph Representation Learning (VGRL) method. For Challenge 1, VGRL utilizes a verbalized approach to create intuitive connections between input features and predictions and VGRL generates textual explanations at each iteration stage, helping researchers and practitioners better grasp the training dynamics of the model. Also, VGRL provides natural language descriptions for the model’s predictions, clearly explaining the rationale behind each decision. For Challenge 2, instead of relying on costly fine-tuning of the LLM parameters, VGRL leverages a prompt-based optimization strategy. This involves crafting task-specific prompts to guide the LLM in generating optimal predictions without modifying its internal parameters. By utilizing prompt engineering techniques, VGRL maintains high performance while significantly reducing computational costs associated with traditional fine-tuning methods. Additionally, this approach allows the model to remain versatile across various tasks, as it can be adapted to new datasets or problems simply by adjusting the prompts, further enhancing its efficiency and scalability.

Our contributions are as follows:

- •
We propose a novel verbalized graph learning framework that ensures complete interpretability throughout the entire process, from input to training and decision-making, enabling users to fully understand the operational mechanisms of the model.
- •
We seek to reduce the high GPU overhead associated with pre-training or fine-tuning in current graph plus LLMs paradigms by utilizing a new model optimization approach, known as Iterative Training through Prompt Optimization.
- •
We validate the effectiveness of this method from multiple perspectives on real-world datasets.

## 2 Preliminaries

In this section, we introduce the essential concepts, notations, and problem settings considered in this research. Our primary focus is on the node classification task over text-attributed graphs, which represents a fundamental downstream task within the field of graph learning. We begin by defining text-attributed graphs.

Text-Attributed Graphs. Text-attributed graphs (TAGs) can be formally described as $\mathcal{G}=(\mathcal{V},\mathcal{A},\{\mathcal{X}_{n}\}_{n\in\mathcal{V}})$, where $\mathcal{V}$ represents a set of $\mathcal{N}$ nodes, $\mathcal{A}\in\mathbb{R}^{\mathcal{N}\times\mathcal{N}}$ is the adjacency matrix, and $\mathcal{X}_{n}\in\mathcal{D}^{\mathcal{L}_{n}}$ denotes a sequential text associated with each node $v_{n}\in\mathcal{V}$. Here, $\mathcal{D}$ is the dictionary of words or tokens, and $\mathcal{L}_{n}$ is the length of the sequence. In this paper, we focus on the problem of node classification in TAGs. Specifically, given a subset of labeled nodes $\mathcal{L}\subseteq\mathcal{V}$, the task is to predict the labels of the remaining unlabeled nodes $\mathcal{U}=\mathcal{V}\setminus\mathcal{L}$.And iterates over the input mini-batch $\mathcal{B}$ one-pass input.

One-hop neighbors. Given a node $v_{i}\in\mathcal{V}$, the set of one-hop neighbors, denoted as $\mathcal{N}(v)$, where $\mathcal{N}(v_{i})=\{v_{j}\in\mathcal{V}|(v_{i},v_{j})\in\mathcal{E}\}$

$k$-hop neighbors. Given a node $v_{i}$, for $k\geq 2$, the $k$-hop neighbors of $v_{i}$ can be denoted as $\mathcal{N}^{k}(v_{i})$, where $\mathcal{N}^{k}(v_{i})=\left\{v_{j}\in\mathcal{V}\mid\exists v_{m}\in\mathcal{
N}^{k-1}(v_{i}),(v_{m},v_{j})\in\mathcal{E}\land v_{j}\notin\mathcal{N}^{k-1}(
v_{i})\right\}$.

## 3 Related Work

In this section, we review the existing literature related to integrating Large Language Models (LLMs) and Graph Neural Networks (GNNs). Prior work has focused on several key areas, including traditional methods for trusted GNNs, the role of LLMs in graph-based tasks, and recent advances in optimization frameworks utilizing LLMs. We explore these approaches to highlight their contributions and limitations, establishing the foundation for our proposed Verbalized Graph Representation Learning (VGRL) framework.

### 3.1 Graph and LLMs

Traditional approaches to trusted GNNs.
There are currently two main approaches: post-hoc explanation methods and self-interpretable models . The former tries to interpret the output of the model by adding a model-independent interpreter, for example  (Ying et al., ; Vu & Thai, ; Zhang et al., ). However, this can lead to incomplete explanatory information in the output, or even generate explanatory information that is incorrect in the opinion of humans. The latter tries to solve this problem by constructing models that themselves have interpretable principles, for example  (Dai & Wang, ; Zhang et al., ). However, these interpretable principles are based on their inductive bias, and only experts in the relevant fields can accurately judge whether such inductive bias is reasonable or not.

LLM in Graph.
Existing methods are mainly categorized into three types: (1) LLM as Enhancer which mainly enhances the performance of GNNs by adding LLM-generated information, for example  (He et al., ; Chen et al., ; Ni et al., ); (2) LLM as Predictor which mainly performs a downstream task by directly inputting the graph structure into the LLM, for example  (Tang et al., ; Qin et al., ); (3) LLM as Alignment which mainly enhances the performance by aligning embedding spaces of GNNs and LLMs, for example  (Yang et al., ; Mavromatis et al., ). Among them, there is explanation-based LLM-as-Enhancer approach  (He et al., ), which achieves better performance by letting LLM generate natural language explanation information of graph structures and then embedding it into GNNs for downstream tasks. However, after the embedding from natural language to graph structure is not directly visible as a black box to humans, and can only be proven effective indirectly through the performance of downstream tasks.

### 3.2 LLMs Optimization

LLMs for planning and optimization. Large language models (LLMs) have been successfully applied to planning tasks for embodied agents  (Song et al., ; Xie et al., ; Li et al., ; Liang et al., ), enabling them to follow natural language instructions and complete complex tasks. More recently, LLMs have also been utilized to tackle optimization problems by generating new solutions from prompts that incorporate previously generated solutions and their associated loss values. While these LLM-based optimization  (Xiao et al., ; Yang et al., ) methods bear some resemblance to our approach, as we also use LLMs to address optimization challenges, a key limitation of existing work is that it has not yet been explored in the graph domain. To address this gap, we propose an extension of this framework to the graph domain, introducing Verbalized Graph Representation Learning (VGRL), which applies LLMs to graph neural networks (GNNs) and opens new possibilities for solving graph-based optimization problems through natural language interactions.

Prompt engineering and optimization. Numerous prompting techniques  (Wei et al., ; Zhang et al., ; Zhou et al., ; Wang et al., ; Yao et al., ; ; Weston & Sukhbaatar, ) have been developed to enhance the reasoning capabilities of LLMs. To minimize the manual effort required in designing effective prompts, various automatic prompt optimization approaches  (Zhang et al., ; Zhou et al., ; Yang et al., ; Pryzant et al., ; Wen et al., ; Deng et al., ; Li et al., ; Ma et al., ; Sordoni et al., ) have been introduced. However, traditional prompt optimization methods primarily focus on refining the text prompt without changing its underlying semantic meaning. In contrast, our VGRL framework goes beyond mere prompt adjustments by directly updating the parameters of the language-based model through the integration or modification of prior information. This not only improves optimization but also ensures that the learner model remains fully interpretable in its predictions, offering a more robust and transparent solution for graph-based learning tasks.

LLMs for multi-agent systems. Given their strong instruction-following capabilities, LLMs can assume various roles within multi-agent systems (Qian et al., ; Wu et al., ; Hong et al., ; Li et al., ). For instance, explore multi-agent collaboration systems designed to solve complex tasks such as software development. In the VGRL framework, this concept is extended to a two-agent system, where one LLM functions as the learner and the other as the optimizer.

Our approach sidesteps the problem of modeling black boxes by having the LLM generate human-readable information as promt of another LLM making it perform the downstream task. This can be viewed as a “guidance-feedback-redirection” process between models, which, after many iterations, returns the optimal guidance solution for a given task, which is directly human-readable.

Figure: Figure 2: An overview of iterative optimization and text prompt templates for the predictor, optimizer, and summary LLM in the node classification example
Refer to caption: x2.png

## 4 Proposed Method

In this paper, we present the Verbalized Graph Representation Learning (VGRL) framework, a pioneering approach that integrates large language models (LLMs) with graph-based tasks while ensuring full interpretability throughout the process. Our methodology encompasses four innovative components, each designed to enhance both the performance and the transparency of LLMs in handling graph data.

### 4.1 Incorporating Graph Structure into LLM Predictions

Although Large Language Models (LLMs) can achieve competitive zero-shot performance on specific datasets without considering graph structures, their performance often lags behind Graph Neural Networks (GNNs) on benchmark datasets such as CORA, CITESEER, and OGBN-ARXIV. This gap underscores the importance of graph structural information in tasks like node classification, indicating the need to explore how incorporating graph structures into prompts could enhance LLM performance.

Given that LLMs (e.g., ChatGPT) are not natively designed to process adjacency matrices or perform graph-based computations, it is impractical to directly integrate graph operations into LLMs. Thus, an alternative approach is to verbalize graph information as text that LLMs can process effectively. This transformation allows LLMs to interpret node relationships and structural dependencies in natural language format. In (Chen et al., ), various methods are evaluated to represent node connections textually, aiming to enhance LLM reasoning capabilities for graph-based tasks.

One effective method is the ‘ego-graph’ approach, which focuses on the local subgraph surrounding a target node. By constraining the LLM’s focus to a limited number of nodes, this method reduces complexity while preserving key local graph structure. To simulate the neighborhood aggregation process typical in GNNs, the input prompt incorporates a summary of attributes from neighboring nodes. Thus, important information from the graph is conveyed to the LLM without altering its reasoning mechanisms. This process can be formalized as:

$$ $Z_{v_{i}}^{1}=f_{e}\left(\mathcal{X}_{v_{i}},\left\{\mathcal{X}_{v_{j}}\mid v_ {j}\in\mathcal{N}(v_{i})\right\}\right)$ (1) $$

where $Z_{v_{i}}^{1}$ is the enhanced representation of node $v_{i}$ with one-hop neighbor information, $\mathcal{X}_{v_{i}}$ represents the features of node $v_{i}$, and $\mathcal{N}(v_{i})$ denotes the set of one-hop neighbors of $v_{i}$. The function $f_{e}$ encapsulates the process of verbalizing neighborhood information and processing it by the LLM.

Inspired by this ego-graph approach, we have also introduced a method for incorporating structural information into our model. By embedding the attributes and relationships of neighboring nodes into the prompt, we aim to enable the LLM to better capture the interactions between nodes. Below is an example of a neighbor summary in Table 1:

Table: Table 1: Prompts used to generate neighbor summary.

### 4.2 Verbalizing Model Parameters for Interpretability

Traditional machine learning models, such as neural networks, rely on numerical parameters, $\theta=\{\theta_{1},\theta_{2},\dots,\theta_{t}\}$, which are often difficult to interpret. These parameters are typically represented as abstract numerical values, making it complex and non-intuitive to understand or explain the internal workings of the model. In contrast, the Verbalized Graph Representation Learning (VGRL) framework leverages large language models (LLMs) to express model parameters through natural language, providing full interpretability.

In VGRL, the model parameters $\theta_{t}$ are defined by a text prompt, which consists of human-readable natural language tokens, $\theta_{t}\in\Theta_{\text{language}}$, where $\Theta_{\text{language}}$ is the set of all interpretable text sequences. This approach contrasts with traditional models where parameters are abstract numbers, which are hard to interpret directly. The VGRL framework unifies both data and model parameters into a natural language-based format that is inherently understandable.

The key features of this framework include:

- •
Discrete Parameters: The natural language used to express parameters $\theta$ is inherently discrete. This is in contrast to the continuous parameter representations in traditional models, enhancing the intuitiveness of parameter interpretation.
- •
Sequential Structure: The parameters exhibit a sequential structure, as $\theta=\{\theta_{1},\theta_{2},\dots,\theta_{t}\}$, reflecting the temporal or contextual relationships between parameters. This sequential nature aids in capturing and understanding the dynamics between parameters.
- •
Human Interpretability: Since the parameters $\theta_{t}$ are verbalized in natural language, they are inherently comprehensible to humans. This allows the model’s reasoning process and learning mechanisms to be more transparent, facilitating interpretability and easier analysis.

An advantage of using natural language for model parameters is that it enables the integration of prior knowledge and inductive biases directly into the model. As the model updates its parameters $\theta_{t}$, the changes are fully interpretable, providing clear insights into what the model is learning. For example, changes in $\theta_{t}$ can be directly mapped to natural language descriptions, offering an intuitive understanding of the model’s learning process.

Our empirical evidence demonstrates that text-based parameters often correspond to recognizable patterns in the data, further reinforcing the interpretability and transparency of the VGRL approach. This natural language parameterization not only enhances the intuitiveness of model but also improves its application, offering clearer insights into model tuning and interpretation in real-world scenarios.

### 4.3 Leveraging LLMs for Node Classification

Our approach centers on utilizing LLMs as interpretable predictors by querying them in an ‘open-ended’ manner. Unlike existing methods that primarily rely on message passing mechanisms, our method employs a label feature matching mechanism. We match based on the inherent characteristics of the nodes themselves and the information from their neighbors. This label feature matching mechanism places a stronger emphasis on the intrinsic attributes of node, as it aligns with the insights provided in the prompt.

The core of this method is represented by the following equation:

$$ $\hat{y}_{v_{i}}=f_{p}(Z_{v_{i}}^{k},\theta_{t-1})$ (2) $$

Here, $\hat{y}_{v_{i}}$ denotes the predicted label for node $v_{i}$, and $Z_{v_{i}}^{k}$ represents the enhanced node representation incorporating $v_{i}$’s $k$-hop neighbors. $\theta_{t-1}$ refers to the LLM’s parameters at the previous step, enabling the model to leverage its prior knowledge and reasoning capabilities to generate the prediction. The function $f_{p}$ serves as the predictor that utilizes the enhanced representation and model parameters to produce the label output. This formulation emphasizes the LLM’s role as a predictor, focusing on generating interpretable outputs.

For each node $v_{i}\in\mathcal{V}$, a prompt is crafted that includes not only the node’s features, such as the paper title and abstract, but also relevant graph structure information. Specifically, the attributes of neighboring nodes up to the $k$-hop neighborhood are embedded in the prompt, as encapsulated in $Z_{v_{i}}^{k}$. This enables the LLM to better understand the node’s context and surroundings within the graph, leading to more informed and accurate predictions.

### 4.4 LLM as an optimizer with interpretable optimization process

For the predictor LLM, we provide textual descriptions of node categories, which serve as model parameter $\theta$, and the model determines which category the input node $v_{i}$ belongs to based on the given descriptions. The quality of node category descriptions $\theta$ directly affects the performance of LLM predictions; hence, obtaining suitable node category descriptions is very important. Additionally, for better explainability, VGRL imposes a strong constraint on $\theta$, ensuring that the updated $\theta$ still belong to natural language sequences that humans can understand.

Under these conditions, it is not advisable to use classical machine learning optimization methods such as gradient descent to optimize $\theta$. Inspired by Xiao et al. (), the optimizer LLM can output natural language that satisfies the constraints, so we only need to ask the LLM to play the role of an optimizer, then optimized category descriptions are also in natural language understandable by humans. Therefore, we directly use another LLM to optimize $\theta$. Given a mini-batch $\mathcal{B}$, the optimization process is as follows:

$$ $\widetilde{\theta}_{v_{i}}^{t}={g_{opt}}(Z_{v_{i}}^{k},y_{v_{i}},\hat{y}_{v_{i }},\theta_{t-1},\Psi),v_{i}\in\mathcal{B}$ (3) $$

where $y_{v_{i}}$ is the true label of $v_{i}$, $\widetilde{\theta}_{v_{i}}^{t}$ represents the intermediate parameter values for node $v_{i}$ during the $t$-th iteration, and $\Psi$ denotes the parameter of the optimizer LLM, which is a text prompt. Specifically, we optimize the intermediate parameter value $\widetilde{\theta}_{v_{i}}^{t}$ of each node $v_{i}$ in $\mathcal{B}$, and then summarize the intermediate parameter values of these nodes through a summary LLM (Section 4.5) to obtain a new round of parameter $\theta_{t}$.
The overall framework for optimizer optimization and the text prompt template are given in Figure 2. The parameter $\Psi$ of the optimizer LLM is actually a text prompt provided by humans and is not updated. The text prompt linguistically specifies the optimization loss function, guiding the optimizer LLM to optimize $\theta$. The LLM-parameterized optimizer allows users to interact with it directly, which not only helps to trace model failures but also permits the incorporation of prior knowledge to enhance optimization.
In addition, we also guide the LLM to output explanations of the optimization process, demonstrating the explainability of the VGRL optimization process.

### 4.5 Summary LLM

The role of the Summary LLM is to aggregate and summarize the updated intermediate parameters from the optimizer LLM, generated during the previous minibatch, to obtain updated $\theta$. Specifically, given a set of updated parameters from the last minibatch $\mathcal{B}$, the Summary LLM consolidates these updates into a new set of parameters, $\theta_{t}$. This process can be formalized as:

$$ $\theta_{t}=f_{s}\left(\{\widetilde{\theta}_{v_{i}}^{t}\mid v_{i}\in\mathcal{B} \}\right)$ (4) $$

Here, $\widetilde{\theta}_{v_{i}}^{t}$ represents the intermediate parameter values for node $v_{i}$ during the $t$-th iteration, and $\mathcal{B}$ denotes the set of nodes in the current minibatch. The function $f_{s}$ operates by combining these parameter updates to produce a cohesive set of parameters, $\theta_{t}$, which reflects the overall learning progress across the minibatch. This aggregation ensures that key information from each node’s updated parameters is captured while maintaining coherence in the overall optimization process.

### 4.6 Chain-of-Thought Prompting

Inspired by  (Wei et al., ), we introduce the zero-shot and one-shot Chain-of-Thought (CoT) methods in prompt. For the zero-shot method, we encourage the LLM to perform step-by-step text generation by restricting and guiding the LLM to make the generated explanatory information as structured and precise as possible, in order to achieve a better final result generation based on the self-generated information. Although zero-shot VGRL is already fully interpretable, we still want to customize the interpretation in specific domains to ensure that the interpretation information is more in line with the norms of the human mind and thus enhance the model’s performance. Therefore, we introduce the one-shot method by manually constructing a sample of the CoT, so that the model can generate the interpretation information and the final output based on the sample. The motivation for the one-shot approach is that we believe that the content generated by the LLM based on a sample that conforms to the logic of the human mind will better contribute to the completion of the final task.

## 5 Experiments

In this section, We will compare the performance of the VGRL framework with diverse backbone models for the TAG node classification task.We will answer the following questions:

- •
Q1: Can VGRL framework increase the performance of backbone models?
- •
Q2: Do each part of the VGRL framework play a positive role?

### 5.1 Baseline and Experiment Setting

We use two LLM-as-predictor models as backbones  (Chen et al., ), and add our framework on top of them for comparisons. Information on our equipment can be found at Table 2.

- •
Node only: ‘node only’ refers to the features considering only the node itself, excluding any neighbor information.
- •
Summary: ‘Summary’ indicates that we used an independent LLM to summarize the node’s $k$-hop information, which can be viewed as the introduction of an enhancer LLM for encoding the graph structure. The prompt for the enhancer LLM is shown in Table 1.

**Table 2: Information on our equipment**
| Devices |  |
| --- | --- |
| OS | Ubuntu 22.04.4 LTS x86_64 |
| Language | Python 3.10.14 |
| Frameworks | pytorch 2.4.0 + cuda 12.4 |
| CPU | Intel Xeon Silver 4310 (48) @ 3.300GHz |
| GPU | 3 * NVIDIA L20 (48G) |
| Memory | 128508MiB |

During the experiments, we used one-hop neighbor information for summarization and set model temperature $\tau=0.1$ as default. Additionally, we introduced prior knowledge in our comparison by manually constructing prior knowledge as the initial optimize $\theta$ for iterative processing. And we setting a mini-batch training process with a batch size of 8, i.e. $|\mathcal{B}|=8$.

### 5.2 Main Results (Q1)

We conducted evaluations on the Cora TAG  (McCallum et al., ) dataset (See  AppendixB) by comparing our optimization iterative process with the baseline that excludes the VGRL framework  (Chen et al., ). The results are presented in Table 5.2. We extracted a subset of nodes from the Cora dataset as our experimental data. For further steps, we blurred the concept of epochs and treated each batch as a single step.

Table: Table 3: Node classification accuracy for the Cora dataset

| Cora | w/ prior | w/o prior |  |  |
| --- | --- | --- | --- | --- |
| zero-shot | one-shot | zero-shot | one-shot |  |
| Node only | 0.625 | 0.400 | 0.675 | 0.100 |
| Node only + VGRL | 0.650 | 0.625 | 0.675 | 0.475 |
| Summary | 0.650 | 0.550 | 0.700 | 0.475 |
| Summary + VGRL | 0.800 | 0.700 | 0.875 | 0.700 |

Table: Table 4: Ablation study on the Cora dataset, showing the effects of different variants base on Summary + VGRL on the accuracy performance

| Cora Summary + VGRL | w/ prior | w/o prior |  |  |
| --- | --- | --- | --- | --- |
| zero-shot | one-shot | zero-shot | one-shot |  |
| original method | 0.800 | 0.700 | 0.875 | 0.700 |
| w/o optimizer LLM | 0.650 | 0.550 | 0.700 | 0.475 |
| w/o summary LLM | 0.650 | 0.625 | 0.725 | 0.625 |

Figure: Figure 3: Summary+VGRL Acc-Step

Our comparison reveals that our framework, through the iterative process, achieves better performance, demonstrating the effectiveness of the VGRL framework in representation learning. VGRL gradually refines the label features through repeated iterations, as shown in Figure 3, which illustrates the change in test accuracy during the mini-batch iterations. Additionally, we used the open-source Llama3.1 8B model for all experiments, which not only significantly reduced costs but also proved the optimization capability of the framework itself.

### 5.3 Ablation Experiments (Q2)

We conducted ablation experiments on the Summary + VGRL architecture to assess the importance and relevance of each module. The results of the ablation experiments are shown in Table 5.2.

- •
w/o optimizer LLM: This variant removes the optimizer LLM, i.e., there is no iterative optimization process, which is equivalent to using the predictor LLM to make the final decision.
- •
w/o summary LLM: This variant removes the summary LLM, i.e., after each optimization update, instead of summarizing the information through the summary LLM, the results of a batch update are directly used in the next iteration.

### 5.4 Case Study

Figure: Figure 4: Case study for one-shot wo prior Summary + VGRL: (1) The left figure shows the explanation information and prediction labels output by predictor LLM; (2) The right figure shows the optimization process of optimizer LLM for the predicted content of predictor LLM in the left figure.(3) The top-right figure shows an example of the one-hop neighbors of a predicted sample.
Refer to caption: x3.png

To explore the impact of the VGRL framework on the TAG node classification task, we conducted an analysis of a particular training sample from the Cora dataset, as shown in Figure 4. In the paper ‘Evolving Sensors in Environments of Controlled Complexity’ the one-hop neighboring nodes all have the label ‘Genetic_Algorithms’ while the actual label of the node is ‘Reinforcement_Learning’ This heterogeneity can significantly disrupt the node’s feature information during neighborhood aggregation, resulting in biased classification results. However, VGRL is able to effectively capture unique characteristics of each category, using them as a basis for matching the node’s own features. This addresses the issue of information corruption caused by the propagation mechanism in heterogeneous graphs.

Moreover, in the Cora dataset, paper categories cannot be strictly divided into binary classes. It is not uncommon for some nodes to belong to two categories simultaneously. In such cases, the label-feature matching mechanism proves to be more reasonable than the message-passing mechanism, as it focuses more on the node’s own information (as can be inferred from the formulation of $\theta$). Making judgments and decisions based on one’s existing knowledge ($\theta$) is the most fundamental decision-making process for humans.

‘Judgment’ and ‘Step-by-Step Analysis’ represent the model’s label matching process, which is also human-readable and interpretable. Whether its the Predictor LLM’s process of analyzing the node’s own features and supplementing it with neighborhood information, or the Optimizer LLM’s analysis and adjustment of the two categories involved in classification errors, both demonstrate a complete and interpretable optimization process. The model explains each update iteration in detail, presenting it in human-readable language. With the help of the Summary LLM, the Predictor LLM and Optimizer LLM communicate and feedback effectively, ultimately constructing the best decision-making basis from scratch for the node classification task on the current dataset.

For a detailed training process see  Appendix C to  Appendix G.

## 6 theoretical analysis

In this section, our goal is to demonstrate that the category descriptions generated by LLM can provide useful information for predicting label categories. Specifically, if the obtained category descriptions can faithfully represent the information of each category, then they are useful. At the same time, the LLM is non-redundant, as it can provide information that $X$ cannot provide. Let $\theta$ be the textual category descriptions generated by LLM; $H_{l}$ are the embeddings of category from the LLM; $X$ are the input of graph structure embeddings, $y$ is the target and $H(\cdot|\cdot)$ is the conditional entropy. The specific proof process can be found in Appendix A.

###### Theorem .

Given the following conditions:
1) Fidelity: $\theta$ can faithfully represent the information of $H_{l}$ such that $H(H_{l}|\theta)=\epsilon,$ with $\epsilon>0$;
2)Non-redundancy: $H_{l}$ contains information not present in $X$, that is,
$H(y|X,H_{l})=H(y|X)-\epsilon^{{}^{\prime}}$, with $\epsilon^{{}^{\prime}}>\epsilon$. Then it follows that $H(y|X,\theta)<H(y|X)$.

###### Theorem .

## 7 Conclusion

This paper introduces Verbalized Graph Representation Learning (VGRL), a novel approach to text-attributed graph learning that ensures full interpretability by representing learned parameters as textual descriptions instead of continuous vectors. This method enhances transparency and user understanding of the decision-making process, fostering greater trust in the model’s outputs. While the current application is limited to foundational graph learning paradigms, VGRL shows promise for broader use in more complex models, offering potential advancements in explainable AI and graph-based learning systems.

## Appendix

## Appendix A Theoretical analysis

In this section, our goal is to demonstrate that the category descriptions generated by LLM can provide useful information for predicting label categories. We formulate our theorem as follows:

###### Theorem .

Given the following conditions:
1) Fidelity: $\theta$ can faithfully represent the information of $H_{l}$ such that

$$ $H(H_{l}|\theta)=\epsilon,\epsilon>0;$ (5) $$

2)Non-redundancy: $H_{l}$ contains information not present in $X$, that is

$$ $H(y|X,H_{l})=H(y|X)-\epsilon^{{}^{\prime}},\epsilon^{{}^{\prime}}>\epsilon;$ (6) $$

Then we can obtain:

$$ $H(y|X,\theta)<H(y|X).$ (7) $$

where $\theta$ be the textual category descriptions generated by $LLM$; $H_{l}$ are the embeddings of category from the $LLM$; $X$ are the input of graph structure embeddings, $y$ is the target and $H(\cdot|\cdot)$ is the conditional entropy.

###### Proof.

We aim to demonstrate that $H(y|X,\theta)<H(y|X)$, the process is following:
Start with:

$$ $H(y|X,\theta)$ (8) $$

We decompose the original expression Equation 8 into two parts based on the properties of entropy:

$$ $H(y|X,\theta)=H(y|X,H_{l},\theta)+I(y;H_{l}|X,\theta)$ (9) $$

Based on the definition of mutual information, we can obtain:

$$ $I(y;H_{l}|X,\theta)=H(H_{l}|X,\theta)-H(H_{l}|X,\theta,y)$ (10) $$

Due to the non-negativity of conditional entropy, we have:

$$ $I(y;H_{l}|X,\theta)\leq H(H_{l}|X,\theta)$ (11) $$

By substituting Equation 11 into Equation 9, we further obtain:

$$ $H(y|X,\theta)\leq H(y|X,H_{l},\theta)+H(H_{l}|X,\theta)$ (12) $$

When conditional variables decrease, the conditional entropy increases; so we have:

$$ $H(y|X,\theta)\leq H(y|X,H_{l})+H(H_{l}|\theta)$ (13) $$

Applying the two aforementioned conditions and substituting Equations 5 and 6 into Equation 12, we can obtain:

$$ $H(y|X,\theta)\leq H(y|X)+\epsilon-\epsilon^{{}^{\prime}}<H(y|X)$ (14) $$

The conclusion is thus proven.
∎

###### Theorem .

###### Proof.

## Appendix B Dataset Description

Cora  (McCallum et al., ): The Cora dataset consists of Machine Learning papers. These papers are classified into one of the following seven classes: Case_Based, Genetic_Algorithms, Neural_Networks, Probabilistic_Methods, Reinforcement_Learning, Rule_Learning, Theory. The papers were selected in a way such that in the final corpus every paper cites or is cited by atleast one other paper. There are 2708 papers and 5429 links in the whole corpus.

## Appendix C one-shot CoT

The one-shot example.

[Uncaptioned image]: x4.png

## Appendix D Training Detail for Summary + VGRL

### D.1 one-shot w/o prior Summary + VGRL Step 1

[Uncaptioned image]: x5.png

### D.2 one-shot w/o prior Summary + VGRL Step 2

[Uncaptioned image]: x8.png

### D.3 one-shot w/o prior Summary + VGRL Step 80

[Uncaptioned image]: x11.png

## Appendix E one-shot w/ prior Summary + VGRL

### E.1 one-shot w/ prior Summary + VGRL Step 1

[Uncaptioned image]: x14.png

### E.2 one-shot w/ prior Summary + VGRL Step 2

[Uncaptioned image]: x17.png

### E.3 one-shot w/ prior Summary + VGRL Step 80

[Uncaptioned image]: x20.png

## Appendix F zero-shot w/o prior Summary + VGRL

### F.1 zero-shot w/o prior Summary + VGRL Step 1

[Uncaptioned image]: x23.png

### F.2 zero-shot w/o prior Summary + VGRL Step 2

[Uncaptioned image]: x26.png

### F.3 zero-shot w/o prior Summary + VGRL Step 80

[Uncaptioned image]: x29.png

## Appendix G zero-shot w/ prior Summary + VGRL

### G.1 zero-shot w/ prior Summary + VGRL Step 1

[Uncaptioned image]: x32.png

### G.2 zero-shot w/ prior Summary + VGRL Step 2

[Uncaptioned image]: x35.png

### G.3 zero-shot w/ prior Summary + VGRL Step 80

[Uncaptioned image]: x38.png

## Peer Reviews

confidence: 4
contribution: 2
initial_rating: 1
presentation: 2
questions: Same as weakenss.
soundness: 1
strengths: I don't recognize a notable strength of this paper.
summary: This paper discussses a training-free LLM framework VGRL for node classification on graph structured data. The core idea is to optimize the verbalization prompt called LLM optimizer.
weaknesses: 1. The paper seems to combine the recent work [1] and verbalized prompt based node classification work [2] together and only shows improvements on one obsolete graph benchmark: Cora. 

2. The proposed work doesn't seem to be tailored for graph tasks, which doesn't solve challenges specific on graph strctured data. And author also don't mention graph in the two challenges they proposed. 

[1] Verbalized machine learning: Revisiting machine learning with language models
[2] HARNESSING EXPLANATIONS: LLM-TO-LM INTERPRETER FOR ENHANCED TEXT-ATTRIBUTED GRAPH REPRESENTATION LEARNING

---

confidence: 4
contribution: 2
initial_rating: 3
presentation: 1
questions: See weeknesses
soundness: 2
strengths: The authors seek to develop a fully interpretable method for graph representation learning, which a promising research direction.

The authors provide open-source code for peer review.
summary: This paper tries to solve two major challenges in representation learning on text-attributed graphs, including the interpretability of models and efficiency in model optimization. The former is solved by creating intuitive connections and generating textual explanations, while the latter is addressed by leveraging prompt engineering approaches.
weaknesses: The presentation requires significant improvement.  For example, 

    In line 141, “And iterates over the input mini-batch B one-pass input.”   
    In line 144, the definition of one-hop neighbors.   

In the experimental section, the authors present only ablation studies without any comparison to SOTA methods.

While the authors emphasize interpretability and efficiency as their primary contributions, they provide no empirical results or theoretical analysis to substantiate these claims.

In the theoretical analysis section, the theorem and proof closely resemble existing work [1] but lack proper citation, which may constitute plagiarism.

[1] Xiaoxin He, Xavier Bresson, Thomas Laurent, Adam Perold, Yann LeCun, and Bryan Hooi. Harnessing explanations: Llm-to-lm interpreter for enhanced text-attributed graph representation learning. arXiv preprint arXiv:2305.19523, 2023.

---

confidence: 4
contribution: 1
initial_rating: 1
presentation: 1
questions: See Weaknesses above.
soundness: 1
strengths: This paper introduces a new way to utilize LLMs for interpretable graph learning.
summary: The paper introduces an interpretable framework, VGRL, which constrains the model parameter space to text descriptions to ensure full interpretability throughout the entire process. Specifically, VGRL performs node classification on TAGs by utilizing a frozen LLM as an enhancer, predictor, optimizer, and summarizer to simulate iterative training.
weaknesses: - The experiments include only a single dataset. The authors validate their method solely on the Cora dataset, which is a small TAG. Experiments on additional TAGs, such as Citeseer and ogbn-arxiv, should be considered.
- Lack of baselines and SOTA models. The authors compare their method only with a vanilla LLM, without any comparison to existing related work. This omission prevents readers from assessing whether the proposed method represents an improvement and by how much compared to existing work.
- Section 6 (THEORETICAL ANALYSIS) and Appendix A are nearly identical to Section 4.4 and Appendix A in [1], with only variable names changed, which constitutes plagiarism. It is recommended that the authors address this issue seriously and provide clarification.

[1] Harnessing Explanations: LLM-to-LM Interpreter for Enhanced Text-Attributed Graph Representation Learning, ICLR 2024, https://arxiv.org/pdf/2305.19523

---

confidence: 5
contribution: 1
initial_rating: 3
presentation: 1
questions: 1. I do not quite understand the whole process of the methodology. Could you summarize it as an algorithm?
2. What's the "embedding" in line 268? How do you implement it?
soundness: 1
strengths: 1. This article explores an interesting question: how to explore the explainability of traditional models, such as GNNs, in the text space? To address this question, the article proposes a viable solution through performing optimization in the text space.
summary: This article mainly studies how to improve the explainability of Graph Neural Networks (GNNs), particularly focusing on the joint explainability across three levels: input, training process, and decision making. The authors propose to address this problem in the text space and put forward a framework that utilizes a Large Language Model (LLM) as both a predictor and an optimizer to generate explanations in natural language.
weaknesses: 1. This article's writing suffers from vagueness, often employing ambiguous sentences that hinder readers from effectively grasping the technical details. For instance, the use of "stepping stone" in line 31 and "deeper insight" in line 44 lack concrete explanations or specific examples. Additionally, the use of certain technical terms needs to be more precise. For example, "training dynamics" in line 109 is mentioned without any subsequent elaboration or relevant content in the later sections. This lack of clarity and precision in language can significantly impede the reader's understanding of the proposed methods and contributions.
2. For lines 85-100, it's confusing that authors directly turn to the discussion of Graph LLMs without motivating its relationship to the explainability of GNNs
3. I strongly recommend that authors check the rigorous definition of explainability in machine learning, such as [1]. The author seems to misunderstand the concept of explainability.  They assume that expressing the prediction logic in natural language automatically equates to explainability. However, this is not the case.  Natural language can generate irrelevant or even misleading explanations that do not reflect the true underlying reasoning of the model. 
4. Following the previous points, there's no experiment evaluating the explainability of the model but focusing on the accuracy of prediction. A case study is not a rigorous way to check the effectiveness. 
5. No explainability-related work is considered in the related works part. Specifically, some highly relevant works like [2] are omitted. In terms of prompt optimization, the general philosophy is highly similar to [3]. 
6. The methodology part is hard to follow. I strongly recommend that the authors summarize it into some algorithms. 
7. The theoretical part is a simple replication of the one in [4], which can't well explain the empirical part. 

[1] Carvalho, D. V., Pereira, E. M., & Cardoso, J. S. (2019). Machine learning interpretability: A survey on methods and metrics. Electronics, 8(8), 832.

[2] Zhang, J., Liu, J., Luo, D., Neville, J., & Wei, H. (2024). LLMExplainer: Large Language Model based Bayesian Inference for Graph Explanation Generation. arXiv preprint arXiv:2407.15351.

[3] Yuksekgonul, M., Bianchi, F., Boen, J., Liu, S., Huang, Z., Guestrin, C., & Zou, J. (2024). TextGrad: Automatic" Differentiation" via Text. arXiv preprint arXiv:2406.07496.

[4] He, X., Bresson, X., Laurent, T., Perold, A., LeCun, Y., & Hooi, B. (2023). Harnessing explanations: Llm-to-lm interpreter for enhanced text-attributed graph representation learning. arXiv preprint arXiv:2305.19523.