A Graph Talks, But Who's Listening? Rethinking Evaluations for Graph-Language Models

TL;DR

This paper critiques current evaluation methods for Graph-Language Models, introduces a new benchmark for multimodal reasoning, and finds that existing models often perform similarly to unimodal baselines, questioning the need for complex graph structures.

Contribution

It introduces the CLEGR benchmark for evaluating multimodal reasoning in GLMs and reveals that current architectures may not effectively leverage graph structure.

Findings

Unimodal baselines perform on par with GLMs on existing benchmarks.

Current GLMs show significant performance drops on structural reasoning tasks.

Existing evaluation benchmarks are insufficient for assessing multimodal reasoning capabilities.

Abstract

Developments in Graph-Language Models (GLMs) aim to integrate the structural reasoning capabilities of Graph Neural Networks (GNNs) with the semantic understanding of Large Language Models (LLMs). However, we demonstrate that current evaluation benchmarks for GLMs, which are primarily repurposed node-level classification datasets, are insufficient to assess multimodal reasoning. Our analysis reveals that strong performance on these benchmarks is achievable using unimodal information alone, suggesting that they do not necessitate graph-language integration. To address this evaluation gap, we introduce the CLEGR(Compositional Language-Graph Reasoning) benchmark, designed to evaluate multimodal reasoning at various complexity levels. Our benchmark employs a synthetic graph generation pipeline paired with questions that require joint reasoning over structure and textual semantics. We perform a thorough evaluation of representative GLM architectures and find that soft-prompted LLM baselines perform on par with GLMs that incorporate a full GNN backbone. This result calls into question the architectural necessity of incorporating graph structure into LLMs. We further show that GLMs exhibit significant performance degradation in tasks that require structural reasoning. These findings highlight limitations in the graph reasoning capabilities of current GLMs and provide a foundation for advancing the community toward explicit multimodal reasoning involving graph structure and language.

Tables

Table 1. Table 1: Accuracy on Node Classification tasks reveals two dataset categories: semantically-sufficient datasets (Computers, Photo, History, Arxiv) where soft-prompted LLMs approximate GLM performance, indicating textual content alone suffices for classification; and structurally-sufficient datasets (Cora, CiteSeer) where GNNs dominate and soft-prompted LLMs fail, suggesting graph structure is critical while semantic reasoning capabilities remain underutilized in current GLM evaluations.

Model	Computers	Photo	History	Arxiv	Cora	CiteSeer
GNNs
GAT	${93.67}_{\pm 0.28}$	${96.51}_{\pm 0.20}$	${82.81}_{\pm 0.74}$	${73.30}_{\pm 0.18}$	${86.05}_{\pm 1.37}$	${71.12}_{\pm 0.84}$
GCN	${93.94}_{\pm 0.13}$	${95.74}_{\pm 0.10}$	${82.91}_{\pm 0.45}$	${73.53}_{\pm 0.12}$	${86.98}_{\pm 0.95}$	${72.14}_{\pm 0.67}$
GraphSAGE	${93.11}_{\pm 0.23}$	${96.54}_{\pm 0.15}$	${83.24}_{\pm 0.82}$	${73.00}_{\pm 0.28}$	${87.31}_{\pm 0.81}$	${72.26}_{\pm 0.70}$
Graph–Language Models
TEA-GLM  Llama3-8B	${73.10}_{\pm 1.07}$	${70.51}_{\pm 1.33}$	${81.56}_{\pm 5.39}$	${73.08}_{\pm 0.00}$	${82.26}_{\pm 1.23}$	${48.05}_{\pm 1.28}$
TEA-GLM  Phi3-3.5B	${69.88}_{\pm 0.61}$	${64.81}_{\pm 4.13}$	${81.63}_{\pm 0.58}$	${67.38}_{\pm 1.31}$	${82.49}_{\pm 1.17}$	${42.08}_{\pm 3.36}$
G-Token (GSAGE)  Llama3-8B	${76.13}_{\pm 0.58}$	${76.61}_{\pm 0.92}$	${85.91}_{\pm 0.27}$	${75.49}_{\pm 0.28}$	${86.72}_{\pm 0.93}$	${53.23}_{\pm 0.53}$
G-Token (GSAGE)  Phi3-3.5B	${72.38}_{\pm 0.90}$	${73.50}_{\pm 2.55}$	${85.15}_{\pm 0.31}$	${71.38}_{\pm 0.19}$	${86.60}_{\pm 1.12}$	${44.69}_{\pm 1.22}$
Soft-Prompted LLMs
Llama3-8B-SPT	${74.34}_{\pm 0.63}$	${74.90}_{\pm 0.57}$	${84.99}_{\pm 0.66}$	${76.03}_{\pm 0.45}$	${28.69}_{\pm 2.70}$	${18.21}_{\pm 0.26}$
Phi3-3.5B-SPT	${69.74}_{\pm 0.26}$	${70.71}_{\pm 3.81}$	${84.55}_{\pm 0.43}$	${72.04}_{\pm 1.15}$	${29.74}_{\pm 1.12}$	${18.28}_{\pm 1.43}$

Table 2. Table 2: Hyperparameter configurations for GCN, GAT, and GraphSAGE across five benchmark datasets. ‘Norm’ abbreviates normalization (LN: LayerNorm, BN: BatchNorm), and ‘LR’ is the learning rate.

Model	Dataset	ResNet	Norm	Dropout	#Layers	Hidden Dim	LR	Epochs
GCN	Cora	False	None	0.7	3	512	0.001	500
	Citeseer	False	None	0.5	2	512	0.001	500
	Computer	False	LN	0.5	3	512	0.001	1000
	Photo	True	LN	0.5	6	256	0.001	1000
	History	True	LN	0.5	6	256	0.001	1000
	Arxiv	True	BN	0.5	5	512	0.0005	2000
GAT	Cora	True	None	0.2	3	512	0.001	500
	Citeseer	True	None	0.5	3	256	0.001	500
	Computer	False	LN	0.5	2	64	0.001	1000
	Photo	True	LN	0.5	3	64	0.001	1000
	History	True	LN	0.5	3	64	0.001	1000
	Arxiv	True	BN	0.5	5	256	0.0005	2000
GraphSAGE	Cora	False	None	0.7	3	256	0.001	500
	Citeseer	False	None	0.2	3	512	0.001	500
	Computer	False	LN	0.3	4	64	0.001	1000
	Photo	True	LN	0.2	6	64	0.001	1000
	History	True	LN	0.2	6	64	0.001	1000
	Arxiv	True	BN	0.5	4	256	0.0005	2000

Table 3. Table 3: GLM hyperparameter settings for using the G-Retriever & G-Token (GSAGE) models. All configurations use consistent hidden/project dimensions and dropout.

Dataset	GNN backbone	Task	In Dim	Hidden Dim	Out Dim	Proj Dim	Layers	Dropout
Cora	GraphSAGE	Node	500	1024	1024	1024	3	0.5
Citeseer	GraphSAGE	Node	500	1024	1024	1024	3	0.5
Arxiv	GraphSAGE	Node	128	1024	1024	1024	3	0.5
Computers	GraphSAGE	Node	768	1024	1024	1024	3	0.5
History	GraphSAGE	Node	768	1024	1024	1024	3	0.5
Photo	GraphSAGE	Node	768	1024	1024	1024	3	0.5
CLeGR-Facts	GraphSAGE	Graph	768	1024	1024	1024	3	0.5
CLeGR-Reasoning	GraphSAGE	Graph	768	1024	1024	1024	3	0.5

Table 4. Table 4: GLM hyperparameter settings for using the GAT models. All configurations use consistent hidden/project dimensions and dropout.

Dataset	GNN backbone	Task	In Dim	Hidden Dim	Out Dim	Proj Dim	Layers	Dropout
Cora	GAT	Node	500	1024	1024	1024	3	0.5
Citeseer	GAT	Node	500	1024	1024	1024	3	0.5
Arxiv	GAT	Node	128	1024	1024	1024	3	0.5
Computers	GAT	Node	768	1024	1024	1024	3	0.5
History	GAT	Node	768	1024	1024	1024	3	0.5
Photo	GAT	Node	768	1024	1024	1024	3	0.5
CLeGR-Facts	GAT	Graph	768	1024	1024	1024	3	0.5
CLeGR-Reasoning	GAT	Graph	768	1024	1024	1024	3	0.5

Table 5. Table 5: Graph statistics for CLeGR Subway Networks with different graph sizes.

Metric	CLeGR	CLeGR-Large
Average Number of Nodes	26.54 $\pm$ 5.41	73.17 $\pm$ 13.55
Average Number of Edges	28.32 $\pm$ 6.37	78.87 $\pm$ 16.41
Average Number of Lines	6.02 $\pm$ 1.23	9.97 $\pm$ 2.02

Table 6. Table 6: CLeGR  Fact-Based Question Template Definitions for the Subway Networks

Template Name	Question Template	Output Type	Scope
StationPropertyCleanliness	How clean is {Station}?	String	Node
StationPropertyCleanliness2	What is the cleanliness level of {Station} station?	String	Node
StationPropertySize	How big is {Station}?	String	Node
StationPropertySize2	What size is {Station}?	String	Node
StationPropertyMusic	What music plays at {Station}?	String	Node
StationPropertyMusic2	Which type of music is played at {Station}?	String	Node
StationPropertyArchitecture	What architectural style is {Station}?	String	Node
StationPropertyArchitecture2	Describe {Station} station’s architectural style.	String	Node
StationPropertyDisabled
Access	Does {Station} have disabled access?	Boolean	Node
StationPropertyDisabled
Access2	Is there disabled access at {Station}?	Boolean	Node
StationPropertyHasRail	Does {Station} have rail connections?	Boolean	Node
StationPropertyHasRail2	Can you get rail connections at {Station}?	Boolean	Node
StationExistence1	Is there a station called {Station}?	Boolean	Node
StationExistence2	Is there a station called {FakeStationName}?	Boolean	Node
StationLine	Which lines is {Station} on?	List	Edge
StationLineCount	How many lines is {Station} on?	Numeric	Edge
StationAdjacentAlwaysTrue	Are {Station} and {Station} adjacent?	Boolean	Edge
StationAdjacent	Are {Station} and {Station} adjacent?	Boolean	Edge
EdgePropertyColor	What color is the line between {Station} and {Station}?	String	Edge
EdgePropertyAircon	Does the line between {Station} and {Station} have air conditioning?	Boolean	Edge
EdgePropertyStroke	What stroke style is the line between {Station} and {Station}?	String	Edge
EdgePropertyBuilt	When was the line between {Station} and {Station} built?	String	Edge

Table 7. Table 7: CLeGR  Reasoning-Based Question Templates for the Subway Networks (Scope: Node)

Template Name	Question Template	Output Type
StationPairAdjacent	Which station is adjacent to both {Station} and {Station}?	String
StationArchitectureAdjacent	Which {Architecture} station is adjacent to {Station}?	String
StationTwoHops	How many other stations are two stops or closer to {Station}?	Numeric
HasCycle	Is {Station} part of a cycle?	Boolean
StationOneApartTrue	Are {Station} and {Station} connected by the same station?	Boolean
StationOneApart	Are {Station} and {Station} connected by the same station?	Boolean
TopologyMostCommonArch	What is the most common architectural style of stations within 2 hops of {Station}?	String
CountIntersectionProperties	How many stations are both large and have disabled access?	Numeric
CompareArchitectureCount	Which architectural style has more stations, {Architecture} or {Architecture}?	String

Table 8. Table 8: CLeGR  Reasoning-Based Question Templates for the Subway Networks (Scope: Edge)

Template Name	Question Template	Output Type
StationSameLineTrue	Are {Station} and {Station} on the same line?	Boolean
EdgeFilterAirconCount	How many air-conditioned lines is {Station} connected to?	Numeric
EdgeFilterColorCount	How many {Color} lines is {Station} connected to?	Numeric
PathYearSpan	How many years newer is the newest line between {Station} and {Station} compared to the oldest?	Numeric
PathOptimalColor	What is the most common line color on the shortest path between {Station} and {Station}?	String
PathEarliestBuilt	What is the earliest year a line was built on the shortest path between {Station} and {Station}?	String

Table 9. Table 9: CLeGR  Reasoning-Based Question Templates for the Subway Networks (Scope: Sub-graph)

Template Name	Question Template	Output Type
LineTotalArchitectureCount	How many architectural styles does {Line} pass through?	Numeric
LineTotalMusicCount	How many music styles does {Line} pass through?	Numeric
LineTotalSizeCount	How many sizes of station does {Line} pass through?	Numeric
LineFilterMusicCount	How many stations playing {Music} does {Line} pass through?	Numeric
LineFilterCleanlinessCount	How many {Cleanliness} stations does {Line} pass through?	Numeric
LineFilterSizeCount	How many {Size} stations does {Line} pass through?	Numeric
LineFilterDisabledAccessCount	How many stations with disabled access does {Line} pass through?	Numeric
LineFilterHasRailCount	How many stations with rail connections does {Line} pass through?	Numeric
LineStations	Which stations does {Line} pass through?	List
StationShortestCount	How many stations are between {Station} and {Station}?	Numeric
StationShortestAvoidingCount	How many stations are on the shortest path between {Station} and {Station} avoiding {Cleanliness} stations?	Numeric
StationShortestAvoiding
ArchitectureCount	How many stations are on the shortest path between {Station} and {Station} avoiding {Architecture} architecture stations?	Numeric
DistinctRoutes	How many distinct routes are there between {Station} and {Station}?	Numeric
CountEqualSizeStation	How many stations in {Line} are of the same size as {Station}?	Numeric
LineIntersectionStations	How many stations are shared between the {Line} and the {Line}?	Numeric
NodeOnPath	Is {Station} on the shortest path between {Station} and {Station}?	Boolean
PathMostCommonMusic	What is the most common music style on the shortest path between {Station} and {Station}?	String
CompareLineDisabledAccess	Which line has more stations with disabled access, {Line} or {Line}?	String

Table 10. Table 10: Graph statistics for CLeGR Computer Networks with different graph sizes.

Metric	CLeGR Computer-Networks
Average Number of Nodes	21.64 ± 3.93
Average Number of Edges	28.61 ± 5.30

Table 11. Table 11: Fact-Based Question Template Definitions for the CLeGR  Computer-Networks Dataset

Template Name	Question Template	Output Type	Scope
NodePropertyStatus	What is the status of node {Node}?	String	Node
NodePropertySecurity	What is the security level of node {Node}?	String	Node
NodePropertyLocation	Which sector is node {Node} located in?	String	Node
NodePropertyFirmware	What firmware version runs on {Node}?	String	Node
NodePropertyPower	How many power units does {Node} consume?	Numeric	Node
NodeExistence1	Is there a node named {Node} in the grid?	Boolean	Node
NodeExistence2	Is there a node named {FakeNodeName} in the grid?	Boolean	Node
NodeAdjacentTrue	Are nodes {Node} and {Node} directly linked?	Boolean	Edge
NodeAdjacent	Are nodes {Node} and {Node} directly linked?	Boolean	Edge

Table 12. Table 12: Reasoning-Based Question Template Definitions for the CLeGR  Computer-Networks Dataset

Template Name	Question Template	Output Type	Scope
CountNodesWithStatus	How many nodes have status {Status}?	Numeric	Sub-graph
ListNodesInSector	List all nodes in {Sector}.	List	—
MostCommonFirmware	What is the most common firmware version?	String	Sub-graph
CountNodesWithTwoProps	How many nodes in {Sector} have security level {Security Level}?	Numeric	Sub-graph
CountNeighborsOperational	How many neighbors of {Node} are ’Operational’?	Numeric	Sub-graph
ShortestPathLen	How many nodes are on shortest path between {Node} and {Node}?	Numeric	Sub-graph
NodesBetween	How many nodes lie between {Node} and {Node} on that path?	Numeric	Sub-graph
PathAvoidingStatus	Is there a path from {Node} to {Node} avoiding status {Status}?	Boolean	Sub-graph
WithinHops	How many other nodes are within 3 hops of {Node}?	Numeric	Node
HasCycle	Is {Node} part of a cycle?	Boolean	Node
OneIntermediary	Are {Node} and {Node} connected via exactly one intermediary?	Boolean	Edge

Table 13. Table 13: Zero-shot transfer accuracy (%) from Computers to History and Photo.

Model	Computers $\to$ History	Computers $\to$ Photo
Graph-Language Models
TEA-GLM (Llama 8B)	57.94 ± 4.97	5.44 ± 2.50
TEA-GLM (Phi 3.5B)	18.16 ± 5.70	3.71 ± 0.16
G-Token (GSAGE) (Llama 8B)	25.65 ± 17.15	5.01 ± 1.65
G-Token (GSAGE) (Phi 3.5B)	19.62 ± 5.07	2.52 ± 0.22
Soft-Prompted LLMs
Llama3-8B-SPT	43.56 ± 12.50	6.00 ± 1.19
Phi3-3.5B-SPT	32.85 ± 13.79	2.85 ± 0.42
Random Baseline (1/num_classes)
Uniform Guessing	8.33	8.33

Table 14. Table 14: Zero-shot transfer accuracy (%) from Arxiv to Cora.

Model	Arxiv $\to$ Cora
Graph-Language Models
TEA-GLM (Llama 8B)	10.02 ± 2.73
TEA-GLM (Phi 3.5B)	5.80 ± 4.73
G-Token (GSAGE) (Llama 8B)	5.12 ± 4.18
G-Token (GSAGE) (Phi 3.5B)	3.76 ± 4.32
Soft-Prompted LLMs
Llama3-8B-SPT	16.57 ± 1.15
Phi3-3.5B-SPT	17.19 ± 0.68
Random Baseline (1/num_classes)
Uniform Guessing	14.29

Table 15. Table 15: Zero-shot Transfer Accuracy: Trained on CLeGR Subway Reasoning, Tested on CLeGR Computer Network Reasoning

Model	Trained $\to$ Tested	Accuracy
GraphSAGE Llama3-8B	CLeGR Subway $\to$ CLeGR Computer	33.16 ± 0.97
GraphSAGE Phi3-3.5B	CLeGR Subway $\to$ CLeGR Computer	27.33 ± 2.51
GraphSAGE Phi4-14B	CLeGR Subway $\to$ CLeGR Computer	39.3 ± 2.34
TEA-GLM Llama3-8B	CLeGR Subway $\to$ CLeGR Computer	32.92 ± 2.27
TEA-GLM Phi3-3.5B	CLeGR Subway $\to$ CLeGR Computer	27.67 ± 2.52
TEA-GLM Phi4-14B	CLeGR Subway $\to$ CLeGR Computer	40.72 ± 2.87
Llama3-8B-SPT	CLeGR Subway $\to$ CLeGR Computer	30.89 ± 0.66
Phi3-3.5B-SPT	CLeGR Subway $\to$ CLeGR Computer	26.81 ± 1.45
Phi4-14B-SPT	CLeGR Subway $\to$ CLeGR Computer	36.79 ± 1.17

Table 16. Table 16: In-Domain Accuracy: Trained and Tested on CLeGR Computer Network Reasoning

Model	Trained $\to$ Tested	Accuracy
GraphSAGE Llama3-8B	CLeGR Computer $\to$ CLeGR Computer	52.33 ± 1.34
GraphSAGE Phi3-3.5B	CLeGR Computer $\to$ CLeGR Computer	47.53 ± 1.46
TEA-GLM Llama3-8B	CLeGR Computer $\to$ CLeGR Computer	47.94 ± 4.32
TEA-GLM Phi3-3.5B	CLeGR Computer $\to$ CLeGR Computer	39.67 ± 4.39
Llama3-8B-SPT	CLeGR Computer $\to$ CLeGR Computer	48.22 ± 2.07
Phi3-3.5B-SPT	CLeGR Computer $\to$ CLeGR Computer	46.38 ± 2.48

Table 17. Table 17: Train on CLeGR  Subway Facts, Test on CLeGR  Computer (Facts / Reasoning).

Model (Method + LLM)	Train $\to$ Test	Accuracy
GraphSAGE Llama3-8B	CLeGR Subway Facts $\to$ CLeGR Computer Facts	87.99 ± 1.55
GraphSAGE Phi3-3.5B	CLeGR Subway Facts $\to$ CLeGR Computer Facts	87.96 ± 1.63
GraphSAGE Phi4-14B	CLeGR Subway Facts $\to$ CLeGR Computer Facts	99.49 ± 0.30
TEA-GLM Llama3-8B	CLeGR Subway Facts $\to$ CLeGR Computer Facts	91.68 ± 1.67
TEA-GLM Phi3-3.5B	CLeGR Subway Facts $\to$ CLeGR Computer Facts	82.65 ± 2.53
GraphSAGE Llama3-8B	CLeGR Subway Facts $\to$ CLeGR Computer Reasoning	34.34 ± 2.76
GraphSAGE Phi3-3.5B	CLeGR Subway Facts $\to$ CLeGR Computer Reasoning	31.10 ± 0.90
GraphSAGE Phi4-14B	CLeGR Subway Facts $\to$ CLeGR Computer Reasoning	40.27 ± 2.24
TEA-GLM Llama3-8B	CLeGR Subway Facts $\to$ CLeGR Computer Reasoning	34.06 ± 2.09
TEA-GLM Phi3-3.5B	CLeGR Subway Facts $\to$ CLeGR Computer Reasoning	28.17 ± 2.98

Table 18. Table 18: Train on CLeGR  Subway Reasoning, Test on CLeGR  Computer (Facts / Reasoning).

Model (Method + LLM)	Train $\to$ Test	Accuracy
GraphSAGE Llama3-8B	CLeGR Subway Reasoning $\to$ CLeGR Computer Facts	45.26 ± 35.78
GraphSAGE Phi3-3.5B	CLeGR Subway Reasoning $\to$ CLeGR Computer Facts	79.50 ± 5.98
GraphSAGE Phi4-14B	CLeGR Subway Reasoning $\to$ CLeGR Computer Facts	90.53 ± 4.83
TEA-GLM Llama3-8B	CLeGR Subway Reasoning $\to$ CLeGR Computer Facts	71.74 ± 5.81
TEA-GLM Phi3-3.5B	CLeGR Subway Reasoning $\to$ CLeGR Computer Facts	76.71 ± 2.50
GraphSAGE Llama3-8B	CLeGR Subway Reasoning $\to$ CLeGR Computer Reasoning	26.06 ± 11.86
GraphSAGE Phi3-3.5B	CLeGR Subway Reasoning $\to$ CLeGR Computer Reasoning	28.51 ± 2.45
GraphSAGE Phi4-14B	CLeGR Subway Reasoning $\to$ CLeGR Computer Reasoning	36.07 ± 2.12
TEA-GLM Llama3-8B	CLeGR Subway Reasoning $\to$ CLeGR Computer Reasoning	34.37 ± 0.94
TEA-GLM Phi3-3.5B	CLeGR Subway Reasoning $\to$ CLeGR Computer Reasoning	28.34 ± 1.40

Table 19. Table 19: Cross-Modality Transfer Between CLeGR  Subway Facts and CLeGR  Subway Reasoning.

Model (Method + LLM)	Train $\to$ Test	Accuracy
GraphSAGE Llama3-8B	CLeGR Subway Facts $\to$ CLeGR Subway Reasoning	35.66 ± 0.31
GraphSAGE Phi3-3.5B	CLeGR Subway Facts $\to$ CLeGR Subway Reasoning	30.30 ± 2.33
GraphSAGE Phi4-14B	CLeGR Subway Facts $\to$ CLeGR Subway Reasoning	36.09 ± 2.13
TEA-GLM Llama3-8B	CLeGR Subway Facts $\to$ CLeGR Subway Reasoning	33.93 ± 0.76
TEA-GLM Phi3-3.5B	CLeGR Subway Facts $\to$ CLeGR Subway Reasoning	29.19 ± 0.12
GraphSAGE Llama3-8B	CLeGR Subway Reasoning $\to$ CLeGR Subway Facts	42.38 ± 33.81
GraphSAGE Phi3-3.5B	CLeGR Subway Reasoning $\to$ CLeGR Subway Facts	62.86 ± 5.34
GraphSAGE Phi4-14B	CLeGR Subway Reasoning $\to$ CLeGR Subway Facts	72.28 ± 1.86
TEA-GLM Llama3-8B	CLeGR Subway Reasoning $\to$ CLeGR Subway Facts	69.52 ± 5.88
TEA-GLM Phi3-3.5B	CLeGR Subway Reasoning $\to$ CLeGR Subway Facts	52.86 ± 6.82

Equations

$$\hat{y}$$

$$\displaystyle=M_{l}\left({M_{P}}(M_{g}({\mathcal{G}},{n}_{i})){\big{\|}}{W}({f}_{i}){\big{\|}}{W}({q}),\right)$$

$$\hat{y}$$

$$\displaystyle=M_{l}\left({M_{P}}(\text{Pool}(M_{g}({\mathcal{G}}))){\big{\|}}{W}({f}){\big{\|}}{W}({q})\right)$$

$${\hat{y}}_{\text{soft}}$$

$${\hat{y}}=\arg\max_{i}\left(W\cdot\text{flatten}\left({M_{P}}\big{(}M_{g}({\mathcal{G}})\big{)}\right)+b\right)_{i}$$

$$h_v^{(l)}=\sigma \left(\sum _{u\in \mathcal{N}(v)\cup \{v\}}\frac{1}{\sqrt{{\hat{d}}_v{\hat{d}}_u}}{h}_u^{(l-1)}{W}^{(l)}\right),$$

$$h_v^{(l)}=\sigma \left(h_v^{(l-1)}{W}_1^{(l)}+\left({\text{mean}}_{u\in \mathcal{N}(v)}{h}_u^{(l-1)}\right)W_2^{(l)}\right),$$

$$\frac{\exp \left(\text{LeakyReLU}\left(a^{\top }[W{h}_v^{(l-1)}\Vert W{h}_u^{(l-1)}]\right)\right)}{{\sum }_{r\in \mathcal{N}(v)}\exp \left(\text{LeakyReLU}\left(a^{\top }[W{h}_v^{(l-1)}\Vert W{h}_r^{(l-1)}]\right)\right)},$$

$$h_v^{(l)}=\sigma \left(\sum _{u\in \mathcal{N}(v)}{\alpha }_{vu}^{(l)}W{h}_u^{(l-1)}\right),$$

$${\hat{y}}=\arg\max_{i}\left(W\cdot\text{flatten}\left({M_{P}}\big{(}M_{g}({\mathcal{G}})\big{)}\right)+b\right)_{i}$$

Full text

††footnotetext: Affiliations: 1 IIIT Hyderabad, India,  2 University of Virginia, USA,  3 Plaksha University, India

\faDatabase CLEGR Dataset  \faGithub rethinking-graph-language-evals

1 Introduction

The success of Vision-Language Models (VLMs) such as GPT-4V (Yang et al., 2023b) and LLaVa (Liu et al., 2023) demonstrates the transformative potential of integrating different data modalities to improve complex reasoning capabilities through visual question answering, image captioning, and multimodal instruction following (Dai et al., 2023). Inspired by this paradigm, recently there has been an increasing interest in using LLMs for graph-based applications (Li et al., 2024a). Depending on the role of LLMs and their interaction with graph neural networks (GNNs), such techniques can be classified into treating LLMs as the final component for prediction (LLM as Predictor) (Chen et al., 2024; He et al., 2024b, c; Wang et al., 2024), treating LLMs as the feature extractor for GNNs (LLM as Encoder) (Chien et al., 2022; He et al., 2024a; Liu et al., 2024), or aligning the latent space of LLMs with GNNs (LLM as Aligner) (Jin et al., 2023; Zhao et al., 2023).

Similarly, according to the relationship between graph and text presented in the application, the scenarios can be categorized into pure graphs, Text-Paired graphs (entire graphs paired with a descriptive text summary) Jin et al. (2024), and Text-Attributed Graphs (TAGs). TAGs are prevalent in real-world applications where nodes represent textual entities like documents or papers, and edges capture relationships between them Hu et al. (2021); Yang et al. (2023a). The combination of textual attributes with the graph structure has significantly improved representation learning for various applications ranging from recommendation systems to social networks (Zhu et al., 2021), with recent work further demonstrating that integrating textual semantics is critical for generalization in foundational models (Arun et al., 2025).

To effectively exploit the rich semantic information within TAGs, the LLM-as-predictor framework has emerged as a particularly promising direction (Perozzi et al., 2024). Notably, LLM-as-predictor approaches have demonstrated zero-shot transfer capabilities across datasets, allowing models trained on a single dataset to generalize effectively to unseen graphs with different features and graph structure (Wang et al., 2024).

In this work, we focus primarily on LLM-as-predictor approaches, as they represent a direct application of language models to graph question-answering tasks and align with our goal of assessing graph-language multimodal capabilities. Henceforth, we refer to this approach as Graph-Language Models (GLMs) throughout the rest of the manuscript.

We first show that including node classification datasets in graph-language benchmarks does not provide a good proxy for tasks requiring a combination of structural and semantic knowledge. By training unimodal baselines which use either the graph structure, or the text attributes associated with the nodes, we achieve performance comparable to GLMs, questioning the utility of these datasets for assessing multimodal capabilities. To accurately assess these capabilities, we further introduce a new Graph Question-Answering benchmark, CLeGR, specifically designed so that both semantic and structural understanding are necessary to accurately answer the questions. Our contributions are summarized as follows:

1. We demonstrate that current GLMs can achieve strong performance on existing benchmarks by relying solely on graph or language modalities: On semantically-sufficient datasets, we show that using a graph encoder as a backbone does not provide any advantage over using only text attributes for classification. On structurally-sufficient datasets, we use linear probing (Alain and Bengio, 2018) to show that graph-encoder representations are sufficient to achieve performance comparable to the full GLM setup, questioning the utility of these datasets in evaluating the multimodal interplay of graphs and language.

2. We introduce CLeGR (Compositional Graph-Language Reasoning), a synthetic benchmark explicitly constructed to assess multimodal graph-language reasoning. CLeGR spans over 1,000 diverse graphs and 54,000 questions designed at multiple levels of structural reasoning and reasoning. We also show that while GLMs saturate performance on CLeGR’s retrieval tasks, their performance drops significantly on tasks requiring graph reasoning, and is on par with soft-prompted LLMs.

2 Preliminaries

2.1 Graph-Language Models

Formally, a graph-language model ${\text{GLM}}=(M_{l},M_{g},{M_{P}})$ comprises three main components: $M_{l}$ is an LLM, $M_{g}$ is the graph encoder, and ${M_{P}}$ is the linear projector that aligns graph and text representations. Let ${\mathcal{G}}=({\mathcal{V}},{\mathcal{E}},{F^{{\mathcal{V}}}},{F^{{\mathcal{E}}}})$ be a Text Attributed Graph (TAG), where ${\mathcal{V}}$ is the set of nodes, ${\mathcal{E}}$ is the set of edges between nodes, ${N}=|{\mathcal{V}}|$ is the number of nodes in the graph, ${M}=|{\mathcal{E}}|$ is the number of edges, ${F^{{\mathcal{V}}}}=\{f^{{\mathcal{V}}}_{1},f^{{\mathcal{V}}}_{2},\dots,f^{{\mathcal{V}}}_{{N}}\}$ is the set of textual features of each node, and ${F^{{\mathcal{E}}}}=\{f^{{\mathcal{E}}}_{1},f^{{\mathcal{E}}}_{2},\dots,f^{{\mathcal{E}}}_{M}\}$ is the set of textual features of each edge.

For node-level question-answering tasks, given a graph ${\mathcal{G}}$, a node ${n}_{i}\in{\mathcal{V}}$, its textual features ${f}_{i}\in{F}$, and a textual question ${q}$, the prediction made by the GLM is:

[TABLE]

where ${W}\in\mathbb{R}^{|{L}|\times{d}}$ is the word embedding matrix of the LLM (${L}$ denotes the token vocabulary and ${d}$ the LLM’s hidden dimension), and {\big{\|}} denotes concatenation of token sequences. Here, $\hat{y},{q},{f}_{i}\in{L}^{*}$ where ${L}^{*}$ represents sequences of tokens from the vocabulary. The ground truth ${g}$ also belongs to ${L}^{*}$.

For graph-level question-answering tasks, given a graph ${\mathcal{G}}$ and a textual question ${q}$, the GLM makes a prediction as:

[TABLE]

where $\text{Pool}(\cdot)$ aggregates node embeddings from $M_{g}({\mathcal{G}},0),\ldots,M_{g}({\mathcal{G}},{N}-1)$ to produce a single graph-level representation, and ${f}$ represents the concatenated textual features of the entire graph.

2.2 Soft Prompting

To isolate the contribution of graph encoders in GLMs, we use soft prompting as a baseline. Soft Prompting Lester et al. (2021) introduces learnable prompt tokens which are concatenated with the embeddings of the input given to the LLM. We note here that a GLM can be viewed as a soft-prompt where a graph encoder is learnt instead of token embeddings. A soft-prompted LLM consists of components $(M_{l},\mathbf{s})$, where $M_{l}$ is the same LLM used in GLMs and $\mathbf{s}\in\mathbb{R}^{{d}}$ is the trainable soft-prompt vector. For a given task, the soft-prompted LLM prediction is:

[TABLE]

The soft-prompt vector $\mathbf{s}$ is trained using the same objective and training procedure as the GLM, effectively learning to encode task-relevant information without access to graph structure. This baseline allows us to determine whether a sophisticated graph encoder is required to achieve performance gains or it can be achieved through simple parameter optimization in the language model space.

3 Evaluating Current Benchmarks for Graph-Language Tasks

In this section, we primarily investigate the following questions: RQ1: Are node classification datasets a sufficient test for graph-language multimodality? RQ2: Do both GNN and LLM components of GLMs contribute to their strong performance on these datasets?

3.1 Experimental Setup

We evaluate all models on six widely-used TAG datasets: Cora McCallum et al. (2000), CiteSeer Yang et al. (2016), Computers (Amazon Computers), Photo (Amazon Photos), History Shchur et al. (2019), and Arxiv Hu et al. (2021), spanning diverse domains and graph structures. These datasets are specifically selected because they form the backbone of current graph-language evaluation practices, appearing across multiple prominent benchmarks including GLBench Li et al. (2024b), GraphFM Xu et al. (2024), TAG Yan et al. (2023), and Planetoid Yang et al. (2016).

Graph-Language Models. We evaluate two prominent GLM architectures: (1) TEA-GLM Wang et al. (2024), which performs zero-shot graph learning by encoding graph structure through textual descriptions and leveraging LLMs for reasoning, and (2) GraphToken Perozzi et al. (2024), which learns discrete graph tokens to represent structural information and integrates them with language model processing. Both GLMs are equipped with GraphSAGE as the backbone, and each GLM is paired with both Llama3-8B and Phi3-3.5B backbones to assess consistency across different language model scales.

Graph-Only Baselines. To isolate the contribution of structural information, we employ strong traditional GNNs that rely exclusively on graph topology: (1) GAT Veličković et al. (2018), which uses attention mechanisms to weigh the importance of neighboring nodes, (2) GCN Kipf and Welling (2017), which performs localized first-order approximations of spectral convolutions, and (3) GraphSAGE Hamilton et al. (2018a), which generates node embeddings by sampling and aggregating features from node neighborhoods.

Language Only Baselines. To isolate the contribution of textual information, we use soft-prompted LLMs Lester et al. (2021). These models use identical Llama3-8B and Phi3-3.5B backbones but operate only on the node text, augmented with trainable prompt vectors.

We employ identical training procedures across all models and report results across five random seeds. Additional implementation details are deferred to Appendix  A, sections  A.6,  A.7, A.8,  A.9.

3.2 Analysis of Modality Contribution

Informed by the performance of unimodal (graph-only vs language-only) baselines, we categorize the datasets into two groups: (a) semantically-sufficient and (b) structurally-sufficient.

First, on the Computer, Photo, History, and Arxiv datasets, which we term semantically-sufficient, we observe in Table 1 that soft-prompted LLMs achieve results that are highly competitive with GLMs across all datasets. GNNs outperform both GLMs and soft-prompted LLMs significantly on Computers and Photos, but are equally as good on History and Arxiv. These results suggest that, for these datasets, the semantic content present in the textual node attributes is sufficient to achieve performance equivalent to a multimodal model (incorporating the graph structure with the semantic content), making a graph encoder not strictly necessary for achieving high performance.

Our results on Cora and CiteSeer follow a different trend. In these datasets, we find that structural information alone can saturate performance. We term these datasets to be structurally-sufficient. Simply providing the textual attributes related to a node is not enough to classify it accurately, as is shown by the low accuracies achieved by soft-prompted LLMs. These results suggest that the addition of textual attributes does not provide any extra gains in accuracy on top of what is already learned by the graph structure. Since LLMs alone cannot achieve strong performance in these datasets, we hypothesize that the large accuracy gains that GLMs achieve over LLMs can be attributed to their graph encoder. To test this hypothesis, we perform a detailed probing analysis in the next section.

3.3 Probing Graph Tokens

To isolate and quantify the contribution of the graph encoder on structurally-sufficient datasets, we perform a linear probing analysis. First, we take a fully trained and frozen GLM and pass the graph data through its graph encoder to extract the final node representations (i.e., the graph tokens). Next, we pass these graph tokens through the language model. A simple linear classifier is then trained on top of these frozen representations to perform the node classification task. Mathematically, the prediction made by the probe can be represented as:

[TABLE]

where $W\in\mathbb{R}^{c\times d^{\prime}}$ and $b\in\mathbb{R}^{c}$ denote the classifier weights and bias, $c$ is the number of output classes, and $d^{\prime}$ is the dimensionality of the flattened embedding representation. This minimal setup isolates the graph encoder and projection module to quantify linearly separable task-specific information without the influence of the LLM ($M_{l}$).

Our probing results (shown in Figure 2) on Cora and CiteSeer using TEA-GLM and G-Token (GSAGE) reveal that a simple linear classifier applied directly to the projector outputs achieves accuracy that nearly matches the full GLM performance. This finding provides strong evidence that on structurally-sufficient datasets, the graph encoder captures all the critical information required for the task, suggesting that the LLM is functionally similar to a very large decoder network. Therefore, the textual-semantic reasoning capabilities of LLMs remain unutilized for these datasets.

Takeaway #1

Our analysis highlights a significant gap in existing benchmarks: a lack of datasets that are neither purely semantically-sufficient nor structurally-sufficient, but instead require the integration of both modalities to test true graph-language multimodality.

4 CLeGR: Compositional Language-Graph Reasoning

Having identified limitations in the current evaluation setup for graph-language models, we now introduce a framework that is neither semantically-sufficient nor structurally-sufficient. To accurately assess multimodal capabilities, we construct CLeGR, a benchmark suite to enable reasoning over graph structures with explicit node and edge textual attributes.

4.1 Overview of CLeGR

CLeGR’s design is guided by three core principles to preclude unimodal solutions: i) Structural Dependency: Tasks require multi-hop reasoning over graph topology that cannot be inferred from the node text alone, making vanilla language models insufficient as they lack access to structural relationships beyond immediate textual context Yasunaga et al. (2021); ii) Semantic grounding: Questions that require natural language understanding capabilities, making traditional GNNs inadequate as they operate on numerical representations without semantic comprehension Hamilton et al. (2018b); Ying et al. (2019); and iii) Compositional complexity: Tasks combine multiple reasoning steps that blend property lookup with logical inference, creating challenges that benefit from integrating both structural and semantic information throughout the reasoning Yang et al. (2018).

CLeGR is constructed as an extension of the foundational CLeVR-Graph dataset Mack and Jefferson (2018), which introduced synthetic graph question answering tasks using fictional subway system graphs. The synthetic design of stations, lines, and connections helps to eliminate pre-training confounds, ensuring language models cannot rely on memorized knowledge.

4.2 CLeGR Design and Structure

The CLeGR benchmark (see Figure 3) contains 1000 synthetic subway graphs split into two subsets: CLeGR-Facts (500 graphs) and CLeGR-Reasoning (500 graphs), each using a 3:1:1 train/validation/test split.

CLeGR-Facts is a purely retrieval-based benchmark, requiring node/edge property lookup without graph structure reasoning (For example, What music is played on Station X?). This subset generates exactly 22,000 questions (44 per graph from 22 templates) and serves as a baseline to assess LLM performance disparity when reasoning over graph structure is not required.

CLeGR-Reasoning extends beyond current TAG benchmarks by adding compositional reasoning over graph structure. It contains 32,248 questions generated from 34 templates, with natural filtering removing structurally invalid instances. Questions demand multi-step inference and graph traversal (e.g., What is the shortest path between Station A and B using only air-conditioned lines?). CLeGR-Reasoning systematically covers four reasoning types (Filtering, Aggregation, Path Reasoning, Topology) across three scopes (node, edge, subgraph-level). The compositional design combines multiple reasoning types to create complex multi-step problems that probe different facets of graph-language reasoning capabilities. Detailed structural statistics, template examples, and dataset construction process are present in Appendix B and Appendix C.

5 Evaluating GLMs on CLeGR

Equipped with a benchmark that necessitates the incorporation of graph structure and text semantics, we now evaluate GLMs on CLeGR. Specifically, we answer the following questions: RQ3: Does incorporating structural information into LLMs provide performance gains over soft-prompting LLMs on tasks requiring multimodal reasoning? RQ4: Do GLMs provide better zero-shot generalization to other domains? RQ5: How does GLM performance scale with increasing graph size?

5.1 Experimental Setup

5.1.1 Models

We evaluate several model categories to comprehensively assess graph reasoning capabilities. First, we include the GLMs introduced in Section 3.1. Second, we add GLMs with retrieval-augmented approaches, specifically G-Retriever He et al. (2024b), which enhances task performance through subgraph and textual retrieval to extract relevant nodes and edges for answering questions. Following G-Retriever’s setup, we adapt all GLMs to our tasks by including graphs in textualized format, ensuring consistent input prompts across models. To evaluate GLM performance across different backbones, we also evaluate GraphToken with a GAT backbone. We also include LLM-only baselines, adding Phi4-14B to our initial set of LLMs from Section 3.1 to analyze scaling effects as model size increases.

5.1.2 Training

All experiments use identical hardware configurations with consistent batch sizes and learning rates within model categories. We employ greedy decoding for generation and average results across 5 random seeds for statistical reliability. Importantly, for CLeGR, we employ the pooling operation from Equation 2 to pass the complete graph representation to all models, as reasoning questions may target any combination of nodes, edges, and subgraphs, requiring full structural context. Additional training details are provided in the Appendix D.

5.1.3 Evaluation Metrics.

Performance is evaluated using overall accuracy across all question types. A prediction is considered correct only when it precisely matches the ground truth. We provide detailed performance breakdowns across our two major subsets (Facts vs. Reasoning). Exact evaluation details are deferred to the Appendix.

5.2 Results

5.2.1 RQ3: Does incorporating structural information into LLMs provide performance gains over soft-prompting LLMs on tasks requiring multimodal reasoning?

Our results, presented in Figure 4, show that despite using diverse architectural strategies for encoding structural information into LLMs, GraphToken and TEA-GLM provide negligible performance gains, if any, over purely language-based soft-prompted baselines. Surprisingly, G-Retriever, which uses a sophisticated subgraph retrieval mechanism intended to selectively provide relevant graph substructures to the model, suffers from a degradation rather than an improvement in performance. We hypothesize that G-Retriever’s performance degradation stems from potentially retrieving incorrect subgraphs, and not having sufficient context to answer questions correctly. These findings collectively indicate that current GLMs do not utilize multimodal inputs effectively; instead, they revert to powerful but ultimately unimodal textual processing, failing to integrate the structural data in a meaningful way.

5.2.2 RQ4: Do GLMs provide better zero-shot generalization to other domains?

To assess if the structural encoding in GLMs leads to better zero-shot performance, we evaluate their transfer capability from the original subway domain presented in CLeGR-Reasoning to a new, structurally analogous Computer-Networks domain. The results are presented in Figure 5(a). Neither TEA-GLM nor GraphToken achieve significant performance improvements compared to soft-prompted LLMs, showcasing that the injection of structural information by GLMs does not have a significant impact on zero-shot transfer (More details in Appendix C.5).

5.2.3 RQ5: How does GLM performance scale with increasing graph size?

We test whether increasing the size of graphs present in CLeGR show a scenario where GLMs outperform language-only baselines. For evaluation purposes, we introduce CLeGR-Large, a modification of CLeGR that contains graphs approximately three times larger (additional details presented in Appendix B.2 Table 5). As graph complexity increased, both approaches exhibited nearly identical performance degradation on reasoning and factual tasks (see Figure 5(b)). This parallel decline demonstrates that GLMs offer no inherent advantage for handling large graph structures, as their performance scales just like simpler, text-based methods. This result corroborates our findings on RQ3 and RQ4, highlighting negligible advantages produced by GLMs.

Takeaway #2

GLMs fail to leverage their structural encoders for graph reasoning tasks. GLMs offer no significant advantage over soft-prompted baselines, and this parity holds even as graph size increases, or while performing zero-shot transfer. Our findings suggest GLMs’ capabilites are primarily driven by the LLM’s textual processing capabilities rather than an interplay of graph and text modalities.

6 Analyzing Representation Alignment

Our findings in Section 3 and Section 5 empirically demonstrate that simply soft-prompting LLMs matches or exceeds GLMs across all our evaluations (Table 1, Figure 4, Figure 5(a), and Figure 5(b)). In this section, we experimentally investigate if the cause behind similar performance metrics for different models is similar internal representations. To verify this, we employ Centered Kernel Alignment (CKA) Kornblith et al. (2019) to measure representational overlap between GLMs and soft-prompts. As shown in Figure 6, we analyze the relationship between the performance gap $|A_{\text{GLM}}-A_{\text{soft}}|$ (x-axis), where where $A$ denotes accuracy and representational similarity $\text{CKA}(\mathbf{H}_{\text{GLM}},\mathbf{H}_{\text{soft}})$ (y-axis), where $\mathbf{H}$ represents the activation over graph and soft-prompt tokens respectively.

We observe that most datasets cluster in the upper-left region of Figure 6 (low performance gap, high CKA). Semantically-sufficient datasets and CLeGR tasks maintain high CKA across all layers. Structurally-sufficient datasets show lower CKA in middle layers (9-24), correlating with our observed low performance by soft-prompted baselines on these datasets. Our analysis highlights that GLMs learn different representations only when datasets are structurally-sufficient, i.e., when the LLM’s textual reasoning capabilities are underutilized (Section 3.3).

7 Discussion

In this work, we first demonstrate that on current graph-language benchmarks that incorporate Node Classification datasets to evaluate multimodality, performance equivalent to GLMs can be achieved by using unimodal baselines, highlighting the need for new evaluation paradigms. To fill this gap, we introduce CLeGR, a synthetic graph-language reasoning benchmark explicitly designed to assess multimodal integration. Evaluations on CLeGR highlight limitations of current GLMs, showcasing that they provide negligible gains over soft-prompting LLMs, emphasizing the need for more sophisticated methods to integrate graph information into LLMs. While CLeGR introduces a framework to evaluate multimodal capabilities, several limitations and avenues for future work remain. As GLMs continue to develop, their capacity to represent graphs are likely to increase, and our current evaluation may not encompass all their capabilities. We aim to continually refine and update CLeGR to more effectively assess the graph-language understanding and reasoning abilities of emerging GLMs.

Appendix A Models

A.1 TEA-GLM

The TEA-GLM (Token Embedding-Aligned Graph Language Model)  Wang et al. [2024] methodology is a novel framework designed to enhance zero-shot graph machine learning by integrating Graph Neural Networks (GNNs) with instruction-fine-tuned Large Language Models (LLMs). It consists of two main stages: first, pretraining a GNN using enhanced self-supervised learning with feature-wise contrastive learning to align its node representations with LLM token embeddings, enabling the GNN to leverage the LLM’s pretrained knowledge; second, training a linear projector to transform these GNN representations into a fixed number of graph token embeddings, which are incorporated into a unified instruction for various graph tasks, without tuning the LLM.

A.2 G-Retriever

G-Retriever He et al. [2024b] is a framework for question answering on textual graphs, integrating Retrieval-Augmented Generation (RAG) with Graph Neural Networks (GNNs) and Large Language Models (LLMs) to enable users to "chat with their graph." It addresses complex queries on real-world textual graphs by first developing a Graph Question Answering (GraphQA) benchmark with diverse datasets like ExplaGraphs, Scenegraphs, and WebQSP. G-Retriever employs a novel RAG approach, formulating subgraph retrieval as a Prize-Collecting Steiner Tree optimization problem to efficiently select relevant graph parts, mitigating scalability issues and LLM hallucination. The retrieved subgraph is textualized and combined with the query, then processed by a frozen LLM with soft prompting for fine-tuned, contextually accurate responses across applications like scene graph understanding, common sense reasoning, and knowledge graph reasoning.

A.3 Graph-Token (G-Token)

In the Graph-Token methodology Perozzi et al. [2024] G-Token (GSAGE) employs GraphSAGE as the GNN encoder to process the graph’s structure, generating representations through neighborhood aggregation, while G-Token (GAT) uses GAT (Graph Attention Network) as the GNN encoder, leveraging attention mechanisms to weigh node connections. The representations are then mapped by a trained linear projector into token embeddings. These tokens are prepended to the prompt of a frozen LLM.

A.4 GNN Architectures

Let a graph be $G=(\mathcal{V},\mathcal{E},X,Y)$, where $\mathcal{V}$ denotes the set of nodes, $\mathcal{E}\subseteq\mathcal{V}\times\mathcal{V}$ represents the set of edges, $X\in\mathbb{R}^{|\mathcal{V}|\times d}$ is the node feature matrix, with $|\mathcal{V}|$ representing the number of nodes and $d$ the dimension of the node features, and $Y\in\mathbb{R}^{|\mathcal{V}|\times C}$ is the one-hot encoded label matrix, with $C$ being the number of classes. Let $A\in\mathbb{R}^{|\mathcal{V}|\times|\mathcal{V}|}$ denote the adjacency matrix of $G$.

A.4.1 Graph Convolutional Networks (GCN)

GCNs  Kipf and Welling [2017] update node embeddings using a normalized sum over neighboring features:

[TABLE]

where $\hat{d}_{v}$ is the degree of node $v$ (including self-loops), $W^{(l)}$ is the trainable weight matrix at layer $l$, and $\sigma(\cdot)$ is an activation function such as ReLU.

A.4.2 GraphSAGE

GraphSAGE Hamilton et al. [2018a] aggregates neighborhood information using a fixed aggregation function (e.g., mean):

[TABLE]

where $W_{1}^{(l)}$ and $W_{2}^{(l)}$ are trainable matrices and the neighbor embeddings are averaged.

A.4.3 Graph Attention Networks (GAT)

GATs Veličković et al. [2018] apply masked self-attention over neighbors. The attention coefficient between nodes $v$ and $u$ is:

[TABLE]

and the node update is:

[TABLE]

where $W$ is the shared weight matrix, $a$ is a learnable attention vector, and $\|$ denotes concatenation and $\alpha_{vu}^{(l)}$ is the attention coefficient between nodes $v$ and $u$.

A.5 Linear Probing

Mathematically, the prediction made by the probe can be represented as:

[TABLE]

where $W\in\mathbb{R}^{c\times d^{\prime}}$ and $b\in\mathbb{R}^{c}$ denote the classifier weights and bias, $c$ is the number of output classes, and $d^{\prime}$ is the dimensionality of the flattened embedding representation. This minimal setup isolates the graph encoder and projection module to quantify linearly separable task-specific information without the influence of the LLM ($M_{l}$).

A.6 Training Details for GLMs and Soft-Prompt Baselines

All experiments are conducted using five random seeds: 0, 42, 1918, 2004, and 2024. We use a fixed number of 10 graph tokens (projector output tokens) across all GLMs and soft-prompt baselines. The input format to the LLM follows the structure:

[<BOS> + 10x<G> + Context + Question + <EOS>]

where <G> represents either the trainable graph tokens (in GLMs) or the fixed soft-prompt tokens (in soft-prompt baselines).

For both the CLeGR and node classification tasks, all Graph-Language Models (GLMs) and soft-prompt variants are trained for a single epoch using the AdamW optimizer with a constant learning rate of 0.001 and a batch size of 1 during both training and evaluation.

All GLMs are implemented using a GraphSAGE Hamilton et al. [2018a] backbone, with the exception of G-Token (GAT), which uses a GAT-based encoder. Furthermore, the TEA-GLM models are pre-trained using 1000 PCA-projected features extracted from each LLM, following the protocol described in Wang et al. [2024]. (Table 3 & Table 4)

A.7 GNN Training

We follow the works of Luo et al. [2024] for GNN baselines; we follow the same training setup, adopting their recommended hyperparameters and optimization configurations for each dataset. (Table 2)

A.8 Node Classification Evaluation

For the GNN baselines, we adopt standard evaluation pipelines as used in prior work, including accuracy-based evaluation over ground-truth node labels. Specifically, following Luo et al. [2024], models are trained and evaluated on fixed data splits, and performance is reported as the mean and standard deviation across five random seeds.

For the Graph-Language Models (GLMs) and soft-prompt models, we adopt a flexible string-matching protocol to map generated textual responses to discrete class labels. Each dataset-specific evaluator contains a fixed list of candidate class names and defines a ‘match_prediction’ function that attempts to align the raw LLM output with one of the ground-truth labels. A prediction is considered correct if it begins with the correct class name (e.g., "Asia" matches "Asia in the 20th century"). Unmatched predictions are mapped to a special None class index.

This string-based matching enables compatibility between natural language generation from LLMs and traditional classification metrics like accuracy. Final accuracy scores are computed by comparing matched predictions to the ground-truth class label.

A.9 Computing Infrastructure

All experiments are conducted on machines equipped with NVIDIA A100 GPUs with 80GB of memory.

Appendix B CLeGR Benchmark Construction

B.1 CLeGR

B.1.1 Overview

The CLeGR dataset is a graph-based question answering benchmark built on synthetic subway networks extending on the work by  Mack and Jefferson [2018]. Each graph represents a fictional subway system with randomly generated nodes and attributes. Questions are categorized into two types: Fact-Based and Reasoning.

B.1.2 Graph Generation

Graphs in CLeGR are primarily constructed using lines. Each graph begins with a predefined number of lines, where each line is assigned a unique name and the following attributes:

• •

has_aircon

• •

color

• •

stroke

• •

built

Lines may intersect with each other. Along each line, a sequence of stations is generated. Stations near line intersections may belong to two lines. Each station is assigned a unique name and the following attributes:

• •

disabled_access

• •

has_rail

• •

music

• •

architecture

• •

size

• •

cleanliness

Edges connect every pair of adjacent stations on a line, and inherit properties from the parent line. The overall size of the graph is controlled by the number of lines and the number of stations per line.

B.2 Graph Statistics

Table 5 mentions the graph statistics for CLeGR Subway Networks.

B.3 Dataset Generation Pipeline

B.3.1 Questions

The dataset contains 22 question templates for Fact Based questions and 34 question templates for Reasoning Based questions. Each generated graph will have two instances of each question template. The question templates are of the following form:

"How many stations playing {} does {} pass through?"

The empty {} in the above template will be filled by a randomly picked Music and Line.

B.3.2 Fact Based Questions

Contains 22 questions which require retrieving information about nodes, edges or the graph itself. (All the templates can be viewed in Table 6)

B.3.3 Reasoning Based Questions

Contains 34 questions which require the model to do some amount of reasoning on the information it retrieves from the graph. The different types of reasoning subgroups we try to incorporate in our dataset are listed here: Aggregation, Filtering, PathReasoning, Topology. (All the templates as per the question scope can be viewed at Table 7, Table 8, and Table 9.)

Appendix C Dataset Generation and Schema

The dataset consists of procedurally generated transit (metro system) graphs, each accompanied by a set of questions and answers derived from its structure and attributes.

C.1 Graph Generation Pipeline

Each graph, representing a unique transit map, is generated through a multi-stage pipeline designed to create complex and semi-realistic structures. The core generation logic is implemented in generate_graph.py.

Line Generation: A set of metro lines is created. Each line is assigned a unique ID, a name (e.g., "Blue Line", "Circle Express"), and a set of properties such as color, stroke style (solid, dashed, dotted), year of construction, and whether it has air conditioning. To ensure visual distinctiveness, combinations of color and stroke style are unique across the graph. 2. 2.

Station Placement along Curves: For each line, a cubic Bézier curve is generated with random control points within a predefined map radius. A specified number of initial station locations are then calculated by evaluating points along this curve. This method produces smooth, winding paths for metro lines rather than simple straight lines. A small amount of Gaussian noise is added to each station’s coordinates for organic variation. Each station is initialized with a unique, programmatically generated name and a set of properties (e.g., architecture, cleanliness, disabled access). 3. 3.

Station Coalescing: A critical step to create realistic interchanges. A KD-Tree is used to efficiently find all stations across all lines that are within a minimum distance threshold of each other. These nearby stations are merged into a single node using a Disjoint Set Union (DSU) algorithm. The resulting merged node, representing an interchange station, inherits the ID and properties of one of its constituent pre-merge stations. This process transforms a simple collection of lines into a more complex, interconnected network. 4. 4.

Edge Generation: After stations are coalesced, edges are created to connect consecutive stations along each line’s path. If a sequence of stations on a line was A → B → C and stations B and C were coalesced into a new station D, the resulting edges would connect A → D. Edges store the IDs of the two stations they connect and inherit properties from their parent line, such as its name, color, and stroke style. 5. 5.

Connectivity Assurance: The graph is checked for connectivity using NetworkX. If the graph consists of multiple disconnected components, new "connector" edges are added to link them. A random node is chosen from each of two components, and a new edge is created between them. This edge is styled as a dotted line to be visually distinct and is assigned to one of the existing lines. This ensures the entire graph is a single connected component, which is a prerequisite for many graph algorithms (e.g., shortest path calculations between any two nodes). 6. 6.

Integer Naming (Optional): For certain model training regimes, all human-readable station and line names can be replaced with unique integer strings. This prevents models from learning spurious correlations from the names themselves and forces them to rely solely on the graph’s topology and categorical features. When this option is enabled, an entity’s ID is also updated to match its new integer name for consistency.

The entire generation process is configurable via command-line arguments, allowing for the creation of graphs of varying sizes (small, medium, large, or a random mix), controlled by parameters like the number of lines, stations per line, and the map radius.

C.2 Feature Schema

The dataset contains three primary entities: Nodes (Stations), Edges (Tracks), and Lines. Their attributes are detailed below.

C.2.1 Node Features (Stations)

Each node represents a station and has the following attributes, which are one-hot encoded to form the node feature tensor x.

id

(String): A unique identifier for the station. If integer names are used, this is the integer as a string.

name

(String): The human-readable or integer name of the station.

x, y

(Float): The 2D coordinates of the station on the map.

disabled_access

(Boolean): Whether the station has disabled access.

has_rail

(Boolean): A categorical property, e.g., for distinguishing train stations from bus stations in a mixed-modal system.

music

(String): The genre of ambient music played (e.g., ’classical’, ’rock’, ’none’).

architecture

(String): The architectural style of the station (e.g., ’victorian’, ’modernist’).

size

(String): The relative size of the station (e.g., ’small’, ’large’).

cleanliness

(String): A binary property (’clean’ or ’dirty’).

C.2.2 Edge Features (Tracks)

Each edge represents a track segment between two stations on a specific line. Edges are directed in the PyG representation (i.e., an edge from A to B is distinct from B to A), but represent an undirected physical connection. Their attributes form the edge feature tensor edge_attr.

station1, station2

(String): The IDs of the nodes connected by the edge.

line_id

(String): The ID of the line this track segment belongs to.

line_name

(String): The name of the line.

line_color

(String): The color of the line.

line_stroke

(String): The stroke style of the line (e.g., ’solid’, ’dotted’).

properties

(Dict): A dictionary containing properties inherited from the line, such as ’line_has_aircon’ (Boolean) and ’line_built’ (String, e.g., ’1990’).

C.3 Question-Answer Generation

With a graph fully generated, the generate.py script produces a set of question-answer pairs.

Question Templates: A predefined set of QuestionForm objects encapsulate different types of questions. These are organized by group (e.g., lookup, comparison) and type (e.g., existence, counting). 2. 2.

Instantiation: For each graph, the script iterates a specified number of times to generate questions. In each iteration, it randomly selects a QuestionForm and attempts to instantiate it using the current graph. This involves sampling nodes, lines, or properties from the graph to fill in the template’s parameters. 3. 3.

Answer Derivation: The ground truth answer is derived by programmatically executing a functional representation of the question on the GraphSpec object. For example, to answer "How many stations on the Red Line are large?", the program iterates through the nodes on the Red Line and counts how many have their size attribute set to ’large’. If a question cannot be instantiated (e.g., a question about interchanges in a graph with none), the attempt is discarded, and another form is tried.

This process yields a diverse set of questions, ranging from simple property lookups ("Does Red Station have disabled access?") to complex multi-hop reasoning involving counting, comparison, and logical operations ("Which line has more modernist stations, the Blue Line or the Green Line?").

C.4 Final Data Format

The complete dataset is saved as a list of PyTorch Geometric Data objects in a single .pt file. Crucially, each Data object represents a single graph-question-answer triplet.

A companion _mappers.pkl file is also saved, containing dictionaries that map the raw string values of all categorical features to their integer indices used in the feature tensors.

Each torch_geometric.data.Data object has the following key attributes:

x

(Tensor): Node feature matrix of shape $[N,F_{node}]$, where $N$ is the number of nodes and $F_{node}$ is the size of the embedding of the sentence representing the node features encoded by BERT.

edge_index

(Tensor): Graph connectivity in COO format, a tensor of shape $[2,E]$, where $E$ is the number of directed edges.

edge_attr

(Tensor): Edge feature matrix of shape $[E,F_{edge}]$, where $F_{edge}$ is the size of the embedding of the sentence representing the edge features encoded by BERT.

question

(String): The natural language question, e.g., "How many stations are on the Cyan Line?".

label

(String): The ground truth answer, serialized to a string (e.g., ’12’, ’True’, ’Red Line’).

question_type

(String): A unique string identifying the question template used, e.g., ’CountStationsOnLine’.

question_group

(String): The general category of the question, e.g., ’count’.

C.4.1 Node Sentence Representation

The textual attributes of nodes are used to generate a sentence of the following form describing the node:

{NodeName}* {has/does not have} disabled access and {has/does not have} rail. It features {Architecture} architecture, has {Cleanliness} cleanliness, {Music} music and is {Size} in size.*

C.4.2 Edge Sentence Representation

Similarly, the textual attributes of edges are used to generate a sentence of the following form:

There is a {LineStroke} {LineColour} line from {SourceStation} to {DestinationStation}. It {has/does not have} air conditioning and was built in {BuiltYear}.

C.4.3 Graph Embeddings

The sentence representation of each node/edge is encoded into a 768 dimensional embedding using bert-base-uncased. These embeddings are passed to the GNN backbone.

C.4.4 Data Tuples

Each Data example in CLeGR is a tuple of the form (Graph, Question, Answer).

C.4.5 Dataset Statistics

The total default number of graphs generated is 500. The Small CLeGR dataset contains 22000 Fact Based questions(44 Fact Based questions per graph) and 32248 (after natural filteration of invalid questions from a total of 34000 questions) (To check and update) Reasoning questions(68 Reasoning Based questions per graph). The Train, Validation and Test set contain 300, 100 and 100 of the graphs(and their corresponding questions) respectively.

C.4.6 Output Format

The model’s output is of one of the following formats: List, Boolean, String, Numeric. The prompt passed to the model will be suffixed with text describing the output format.

C.5 CLeGR Computer-Networks

The CLeGR Computer-Networks is a dataset containing graphs representing fictional computer networks. These graphs are generated very similar to the generation used in the Subway Networks dataset. There are some differences in the graph generation primarily due to the fact that "lines" do not exist in this dataset. The differences are highlighted below:

Node-Centric Foundation (vs. Line-Centric): The process begins by generating a target number of nodes, as specified by the nodes parameter. Unlike the transit map’s structured placement along Bézier curves, these system nodes are scattered with random (x, y) coordinates across the map space. The concept of a ‘LineSpec‘ is entirely absent; nodes are the primary, independent entities from the outset. 2. 2.

Emergent Topology via Proximity (vs. Pre-Defined Paths): Edge creation is not determined by a sequential path. Instead, the gen_edges function implements a k-nearest neighbor algorithm. After the final node positions are set, a KDTree is used to find the ‘k‘ closest neighbors for each node (where ‘k‘ is derived from the avg_degree parameter). Edges are then created between a node and its neighbors. 3. 3.

Hub Formation (vs. Interchange Creation): The function coalesce_nearby_nodes serves a different conceptual purpose here. In the transit model, it created interchanges by merging nodes from different lines. Here, it addresses the potential for random placement to create unrealistic clusters of nodes. By merging nodes that are too close, such node clusters are reduced. 4. 4.

Intrinsic Edge Properties (vs. Inherited): In the transit model, edge properties (like color and stroke) were inherited from their parent line. In this dataset, every edge is assigned its own set of properties directly and randomly from the EdgeProperties dictionary. Attributes like bandwidth_units, latency_ms, and encryption_status are intrinsic to the connection itself.

C.6 Feature Schema

The feature schema is completely redesigned to reflect the computer network domain.

C.6.1 Node Features (System Nodes)

Each node represents a computer system, server, or device. Its attributes are one-hot encoded into the node feature tensor x.

id

(String): A unique identifier for the system node.

name

(String): The programmatically generated name of the node.

x, y

(Float): The 2D coordinates of the node in the grid space.

status

(String): The operational status of the node (e.g., ’Operational’, ’Offline’, ’Overloaded’).

security_level

(String): An assigned security clearance level (e.g., ’Public’, ’Internal’, ’Restricted’).

location_sector

(String): The logical or physical sector where the node is located (e.g., ’Sector_Red’).

firmware_version

(String): The version of the node’s firmware (e.g., ’v1.1’, ’v2.0’).

power_consumption_units

(Integer): A measure of the node’s power draw.

C.6.2 Edge Features (Connections)

Each edge represents a network connection between two system nodes. There is no ‘LineSpec‘ entity. Edge attributes are one-hot encoded into the edge feature tensor edge_attr.

node1_id, node2_id

(String): The IDs of the two nodes being connected. The class attribute is named station1, station2 to be compatible with the other domain’s codebase.

bandwidth_units

(Integer): A measure of the connection’s data throughput capacity.

latency_ms

(Integer): The latency of the connection in milliseconds.

encryption_status

(String): The encryption state of the connection (e.g., ’Encrypted’, ’Unencrypted’).

C.6.3 Node Sentence Representation

Similar to the Subway Netowrks dataset, the textual attributes of nodes are used to generate a sentence of the following form describing the node:

System node {NodeName} is in {LocationSector} with status {Status}. It has security level {SecurityLevel}, firmware {FirmwareVersion}, and consumes {PowerConsumptionUnits} power units.

C.6.4 Edge Sentence Representation

Similarly, the textual attributes of edges are used to generate a sentence of the following form:

*A link connects {SourceNodeName} and {DestinationNodeName}. It has {BandwidthUnits} bandwidth units, *{Latency}ms latency, and its encryption status is {EncryptionStatus}.

C.7 Graph Statistics

Table 10 shows the graph statistics for CLeGR Computer Networks, which is also similar to that of CLeGR Subway Networks.

All the question templates for the CLeGR Computer Networks are present at Table 11 & Table 12

Appendix D CLeGR Evaluation

D.1 Evaluation Metrics by Answer Type

CLeGR includes four distinct answer formats, each evaluated with tailored methods:

• •

Categorical Answers (e.g., station names, architecture types):

Evaluated using exact match after normalization (lowercasing and punctuation removal).

• •

Boolean Answers (e.g., yes/no questions):

Text responses such as “yes”, “no”, “true”, or “false” are mapped to binary values. We compute accuracy, F1-score, and Matthews Correlation Coefficient (MCC).

• •

Numeric Answers (e.g., distances, years):

Evaluated using approximate equality via numpy.isclose. If direct parsing fails, we extract numbers using regex. Metrics include accuracy, Mean Absolute Error (MAE), and Root Mean Square Error (RMSE).

• •

Set-Valued Answers (e.g., lists of stations):

Scored using set-based precision, recall, and F1-score, based on overlap with the ground truth set.

D.2 Overall Evaluation

Each question is scored using the appropriate method for its answer type. We report overall accuracy as the primary evaluation metric, defined as the proportion of correctly answered questions across the full test set. This ensures a fair and consistent comparison across models and tasks.

Appendix E Prompt Templates

E.1 Example Prompts for NC, each dataset

E.1.1 Arxiv

Textual Prompt Format

<s>[INST] Title: {Title}\nAbstract: {Abstract}\nAnswer the following question: Which subcategory does this paper belong to? Please only output the most likely answer from the following subcategories and nothing else: {Comma seperated Category List}. \nAnswer: [/INST] {Label} [/s]

E.1.2 Cora

Textual Prompt Format

<s>[INST] Title: {Title}\nAbstract: {Abstract}\nAnswer the following question: Which subcategory does this paper belong to? Please only output the most likely answer from the following subcategories and nothing else: theory, reinforcement learning, genetic algorithms, neural networks, probabilistic methods, case based, rule learning. \nAnswer: [/INST] {Label} [/s]

E.1.3 CiteSeer

Textual Prompt Format

<s>[INST] Text: {Text}\nAnswer the following question: Which category does this paper belong to? Please only output the most likely answer from the following categories directly and nothing else: Agents, AI, DB, IR, ML, HCI. \nAnswer: [/INST] {Label} [/s]

E.1.4 Computers

Textual Prompt Format

<s>[INST] {Context}\nAnswer the following question: Which computer product subcategory does this review belong to? Please only output the most likely answer from the following subcategories and nothing else: computer accessories and peripherals, tablet accessories, laptop accessories, computers and tablets, computer components, data storage, networking products, monitors, servers, tablet replacement parts \n\n Answer: [/INST] {Label} [/s]

E.1.5 Photo

Textual Prompt Format

<s>[INST] {Context}\nAnswer the following question: Which photography related subcategory does this description belong to? Please only output the most likely answer from the following subcategories and nothing else: Film Photography, Video, Digital Cameras, Accessories, Binoculars & Scopes, Lenses, Bags & Cases, Lighting & Studio, Flashes, Tripods & Monopods, Underwater Photography, Video Surveillance \n\n Answer: [/INST] {Label} [/s]

E.1.6 History

Textual Prompt Format

<s>[INST] {Context}\nAnswer the following question: Which history related subcategory does this description belong to? Please only output the most likely answer from the following subcategories and nothing else: World, Americas, Asia, Military, Europe, Russia, Africa, Ancient Civilizations, Middle East, Historical Study & Educational Resources, Australia & Oceania, Arctic & Antarctica \n\n Answer: [/INST] {Label} [/s]

E.1.7 CLeGR Facts and CLeGR Reasoning

Textual Prompt Format

<s>[INST] --- Nodes ---\n{CSV String describing all the Nodes}\n--- Edges ---\n{CSV String describing all the Edges}Above is the representation of a synthetic subway network. All stations and lines are completely fictional. Keep in mind that the subway network is not real. All information necessary to answer the question is present in the above representation. The question is: {Question}\n\n{Answer Format Suffix} [/INST] {Label} [/s]

CSV String describing all the Nodes: A string describing all the nodes formatted like a CSV files with rows representing each node and columns describing different attributes of the nodes following the G-Retriever He et al. [2024b] pipeline.

CSV Header

“id", “name", “disabled_access", “has_rail", “architecture", “cleanliness", “music", “size"

CSV String describing all the Edges: A string describing all the nodes formatted like a CSV files with rows representing each edge and columns describing different attributes of the edges.

CSV Header

“source_id", “target_id", “line_color", “line_stroke", “has_aircon", “built"

Answer Format Suffix: Depending on the question and the output format expected by the question, one of the following is suffixed to the question.

Output Format Suffixes

String Output: Answer directly:

Bool Output: Answer with ‘True’ or ‘False’: \n\nAnswer:

List Output: Output a comma-separated list:

Count Output: Answer with a number: \n\nAnswer:

Cycle Detection Question: Answer with ‘True’ if it is in a cycle, otherwise ‘False’: \n\nAnswer:

Appendix F Extended Experimental Results

F.1 Node Classification (Zero-Shot Transfer)

Effective zero-shot transfer learning is a key advantage claimed by GLMs like TEA-GLM. To evaluate this, we perform zero-shot transfer experiments across distinct semantic domains (Computers to History and Photo, and Arxiv to Cora). Surprisingly, our results (Table 13 and Table 14) indicate negligible gains for GLMs over soft-prompted LLM baselines, and in some cases, GLMs even perform worse. This finding challenges the claimed superior generalization of GLMs, highlighting that even in tasks considered advantageous for GLMs, simple soft-prompted LLMs exhibit comparable or superior performance, raising questions about the practical value of current GLM designs in zero-shot contexts of Node classification.

To achieve cross-dataset transfer capability, where models trained on one graph dataset can perform reasoning on different target datasets, we design instructions that include both the task description and the complete set of alternative answers from both source and target domains. This approach follows the methodology established by TEA-GLM.

For the Arxiv → Cora transfer scenario, the training instruction is structured as: "Which research area does this paper belong to? Please directly give the most likely answer from the following categories: ans", where ans contains class labels from both the Arxiv dataset (computer science subcategories such as "cs.AI", "cs.LG") and the Cora dataset (machine learning areas such as "Neural Networks", "Reinforcement Learning").

Similarly, for the Computers → History and Computers → Photo transfers, the instruction follows: "Which product category does this item belong to? Please select from the following options: ans", where ans includes classes from the Computers dataset alongside the respective target dataset classes (History product types or Photo equipment categories). Including alternative answers from both source and target datasets enables the model to learn the task of "selecting the correct answer from a given set according to the reasoning requirements" rather than memorizing dataset-specific label mappings, thus facilitating effective knowledge transfer across different graph domains.

F.2 CLeGR (Zero Shot Transfer)

This section presents the accuracy results of GLMs on different transfer learning scenarios across domains and knowledge types (Facts vs. Reasoning). We present 5 tables (Table 15, Table 16, Table 17, Table 18, and Table 19) testing various scenarios like Zero-Shot domain transfer (e.g. CLeGR Subway Networks to CLeGR Computer Networks) and Zero-Shot in-domain but question-type transfer (e.g. CLeGR Facts to CLeGR Reasoning and vice versa).