TrustGTN: A Social Network Trust Evaluation Method Based on Heterogeneous Graph Neural Network

Abstract

The rapid growth of social networks and online platforms has heightened the importance of trust evaluation in various applications, including e-commerce, social networking, online collaboration, and mobile crowdsourcing. Traditional trust evaluation methods often rely on handcrafted features and simple models, which fail to fully capture the implicit patterns within the complex, heterogeneous structures of social networks. To address this issue, we propose TrustGTN, a novel method based on Heterogeneous Graph Neural Networks (HGNNs). It incorporates a soft selection mechanism that dynamically adjusts the training matrix weights. This enables it to capture the evolving structural and semantic patterns of the graph. The model can automatically learn important trust chains without the need to manually set their lengths. Experimental results show that TrustGTN outperforms existing trust evaluation methods on public datasets, demonstrating its advantages in handling heterogeneous graph data.

1. Introduction

With the rapid development of social networks, user interactions on online platforms have become an essential part of daily life. Through these platforms, users construct complex social networks by sharing content, expressing opinions, and engaging with others. By leveraging user data and behavioral patterns, advertisers can deliver more precise and targeted advertisements. Personalized content recommendations and friend suggestions can also be refined more effectively [1,2]. However, the open nature of the internet exposes social networks to misinformation propagated by malicious actors, underscoring the critical need for robust trust evaluation mechanisms.

Traditional trust evaluation methods [3,4,5,6] primarily rely on explicit features like historical interaction data and user ratings. However, these approaches tend to oversimplify trust dynamics and fail to capture the complexity and diversity of trust propagation in social networks. Social networks inherently possess a highly structured topology, where nodes represent users or entities and edges signify various relationships between them. Trust propagates through both direct and indirect interactions, forming trust paths that may involve multiple nodes and edge types. Conventional methods often fall short in leveraging the rich, implicit patterns embedded within these intricate structures. Therefore, accurately evaluating trust based on implicit features inherent in social network structures has emerged as a key research challenge.

Graph Neural Networks (GNNs) have garnered significant attention in the field of deep learning as models specifically designed to process graph-structured data. Graphs are a prevalent data representation format, with applications ranging from predicting molecular structures [7,8] and social network node classification [9,10] to recommendation systems [11]. In these graphs, nodes represent entities, and edges denote the relationships between them. The primary advantage of GNNs is their ability to directly utilize the structured nature of graph data. Through information propagation and aggregation, nodes can effectively exchange and integrate features. Moreover, GNNs can capture high-order dependencies and learn deeper structural information. They also adapt well to complex, non-Euclidean data. This makes them highly effective in various graph-related tasks, particularly in the realm of trust evaluation, where GNNs can model trust patterns through propagation and aggregation mechanisms. Trust flows through relationships between nodes, and the impact of different edge types on trust transmission varies. Furthermore, GNNs leverage multi-hop propagation mechanisms to capture indirect trust relationships. This allows them to model trust established through mutual connections. Through trust propagation, GNNs aggregate trust information from neighboring nodes. They also incorporate the current node’s characteristics to generate new node representations. Attention mechanisms further enhance this process by enabling GNNs to adaptively learn the importance of neighboring nodes, distinguishing between trustworthy and untrustworthy sources. As a result, GNNs can capture both explicit features and complex implicit trust patterns in social networks, making them a powerful tool for trust evaluation.

Figure 1 illustrates several key properties of trust. Dashed arrows denote uncertain trust relationships, solid arrows represent confirmed ones, and the numbers on the arrows indicate trust levels. Trust is propagative but not simply transitive. As shown in Figure 1a, A’s trust in B (level 2) and B’s trust in C (level 1) do not guarantee that A trusts C; such propagation requires that A endorses B’s judgment. Moreover, trust decays during propagation—the longer the chain, the weaker the strength, much like a signal attenuating over distance. Figure 1b demonstrates the composability of trust. Here, A reaches D via two paths: A → B → D and A → C → D. When evaluating the overall trust from A to D, contributions from both chains must be aggregated, reflecting how trust can be composed from multiple sources. Figure 1c highlights the asymmetry of trust: A’s trust in B does not imply B’s trust in A. This one-directional nature is essential in modeling realistic social relationships. Finally, Figure 1d presents a small trust network that integrates these properties, serving as a reference for subsequent analysis.

All the notations and their explanations used in this paper are provided in

Table 1. Notations and Explanations.

Notations	Explanations
$T_v$,$T_e$	The node/edge type
$A_t\left[i,j\right]$	The weight of the edge from node i to node j
$I$	The identity matrix
A	The original adjacency matrix of the graph
$A^{\mathrm{*}}$	The adjacency matrix of the graph with self-loop
$A^{\left(k\right)}$	The adjacency matrix output by a k-th TrustGT layer
${\tilde{D}}^{-1}$	The inverse of the degree matrix
$A_t\left[i,j\right]$	The weight of the edge from node i to node j
$A_P$	The adjacency matrix under the meta-path
${\widehat{A}}_K$	The reconstructed meta-path adjacency matrix
${\phi }^{\left(k\right)}$	The 1 × 1 convolution parameter
$\alpha$	The edge weight/filter
$W$,$a$	The parameters of neural networks
$\gamma$	The hyperparameters of neural networks
$H^{\left(0\right)},H$, $\tilde{H}$	The original node features/intermediate node features/output features from GCN
$Z_u,Z_v$	The final node embedding vector of node $u$ and node $v$
$Y$	The known trust classification value
$\tilde{Y}$	The predicted trust levels

. Additionally, a complete list of abbreviations is presented in alphabetical order in

Table 2. List of Abbreviations.

Abbreviation	Description
1-WL	1-dimensional Weisfeiler–Lehman Graph Isomorphism Test
F1-score	A balanced measure of precision and recall
GAT	Graph Attention Networks
GCN	Graph Convolutional Network
GNNs	Graph Neural Networks
GraphSAGE	A model for homogeneous graphs
Guardian	A comparative experimental model based on GNN
HAN	Heterogeneous Graph Attention Networks
HGNNs	Heterogeneous Graph Neural Networks
MAE	Mean Absolute Error
MAGNN	A model for heterogeneous graphs
MATRI	A comparative experimental model based on machine learning
MLP	Multi-Layer Perceptron
NeuralWalk	A comparative experimental model based on machine learning
RGCN	Relational Graph Convolutional Networks
RNI	Random Node Initialization
RotatE	An innovative technique for feature fusion
TrustGNN	A comparative experimental model based on HAN
TrustGT	The key module for implementing soft selection
TrustGTN	Our proposed model

.

2. Related Work

Trust evaluation plays a pivotal role in social networks, especially within online communities, social media platforms, and e-commerce, where trust significantly impacts user behavior, information dissemination, and recommendation systems. Recent research in social network trust evaluation has made substantial progress, focusing primarily on traditional trust modeling, machine learning approaches, and Graph Neural Network (GNN)-based methods.

2.1. Traditional Trust Modeling Methods

Traditional trust evaluation methods generally assess trust through attributes such as reputation, user interaction history, and authority in social networks. Notable approaches include Bayesian inference [12], subjective logic [13], and fuzzy logic [14]. While these methods can quantify trust, they often involve complex formal mathematical models, which can hinder practical application.

2.2. Machine Learning Methods

Due to the large volume and complex structure of data, traditional trust evaluation methods cannot compute trust values based on big data technologies. Machine learning, as an important and commonly used technology for handling big data, can systematically and effectively process data, improving computational efficiency. Therefore, many researchers have proposed using machine learning to evaluate trust. The goal of machine learning is to generate a model from data using computers, i.e., learning through machines. MATRI [15] combines the transitivity, multi-faceted nature, and prior knowledge of trust, optimizing trust inference through latent factor matrices and trust bias. It employs trust propagation mechanisms and matrix factorization techniques to enhance efficiency. NeuralWalk [16] proposes a multi-hop trust evaluation method based on neural networks. The core idea is to learn single-hop trust propagation and fusion rules through WalkNet, convert trust levels into vectorized opinions, and iteratively perform multi-hop inference. Compared to traditional rule-based methods, NeuralWalk shows superior performance in accuracy and robustness, making it suitable for analyzing and predicting complex trust social networks.

2.3. Graph Neural Network Methods

In the field of Graph Neural Networks (GNNs), graphs can be divided into homogeneous graphs and heterogeneous graphs based on the types of nodes and edges. Heterogeneous graphs refer to graphs where the number of node types plus edge types is greater than two. In recent years, there have been many excellent works in GNNs, such as Graph Convolutional Networks (GCN) [17], Graph Attention Networks (GAT) [18], and GraphSAGE [19] for homogeneous graphs. In the study of heterogeneous graphs, there are Heterogeneous Graph Neural Networks (HGNN) [20], Relational Graph Convolutional Networks (RGCN) [21], MAGNN [22], and Heterogeneous Graph Attention Networks (HAN) [23].

Some scholars have proposed using GNNs for trust evaluation. For example, Lin et al. proposed a GCN-based trust evaluation framework called Guardian [24], which refines popularity trust embeddings and participation trust embeddings by injecting high-order social trust relationships into multiple trust convolutional layers, effectively improving evaluation accuracy. Huo et al. proposed a HAN-based trust evaluation framework called TrustGNN [25], which fully considers the varying impacts of different types of trust chains on target nodes during trust propagation. It uses second-order meta-paths and learnable attention mechanisms to enable nodes to learn information from different trust chains, better capturing the composability of social networks. However, despite their achievements, there are still some shortcomings: (1) Although TrustGNN considers the weight issues of first-order and second-order meta-paths, the selection of meta-paths requires manual pre-definition, which significantly affects the results in downstream tasks of GNNs. (2) Trust evaluation can be considered a type of edge classification problem, but most existing deep learning trust evaluation frameworks follow the node classification approach, focusing more on node features and rarely on edge features and weights.

Based on the above factors, we propose our model, TrustGTN, with the following contributions:

• By assigning learnable weights to each edge type, the model enables a soft selection mechanism for meta-path adjacency matrices based on edge importance. This approach eliminates the necessity of manually pre-defining meta-paths, allowing for the dynamic discovery of meta-paths of arbitrary length and enhancing overall model performance.
• Edge weights are initialized based on node degree information extracted from the initial adjacency matrix. During the construction of meta-path adjacency matrices, edge weights are further refined through node feature-based recalibration. By integrating the recalibrated weights with the initial edge weights, a more expressive and adaptive meta-path adjacency matrix is reconstructed.
• To enhance message aggregation, techniques from knowledge graph embedding are incorporated, with a particular emphasis on the RotatE method. This enables the effective integration of edge feature information into the representation learning process, capturing relational dependencies more comprehensively.

3. Problem Definition and Analysis

3.1. Heterogeneous Trust Graph

In this paper, we define the trust relationships in online networks as a heterogeneous trust graph $G=\left(V,E,T_v,T_e\right)$, where each node $v\in V$ and each edge $e\in E$ have their mapping functions $T_v\left(v\right):V\to T_v$ and $T_e\left(e\right):E\to T_e$. The heterogeneous graph $G$ can be represented as a set of adjacency matrices ${\left\{A_t\right\}}_{t=1}^{\left|T_e\right|}$ or a tensor (e.g., $A\in R^{\left|V\right|\times \left|V\right|\times \left|T_e\right|}$), where $\left|V\right|=N$ and $A_t\in R^{N\times N}$ is the adjacency matrix for the t-th edge type. $A_t\left[i,j\right]$ represents the weight of the edge from node i to node j. Since trust is asymmetric, $A_t\left[i,j\right]\ne A_t\left[j,i\right]$. When $\left|T_v\right|=1$ and $\left|T_e\right|=1$, the graph becomes a homogeneous graph. Taking the public dataset Advogato as an example, there are four types of trust relationships: $\left\{Observer,Apprentice,Journeyer,Master\right\}$. Following previous work, we do not consider node types in our experiments, i.e., $\left|T_v\right|=1$ and $\left|T_e\right|=4$.

3.2. Meta-Path

Meta-path is a key concept in heterogeneous graphs. It is a path composed of one or more edges, defining the relationship structure between nodes. By specifying sequences of special types of nodes and edges, this helps capture high-order dependencies between nodes. A meta-path can be defined as:

$$v_1\stackrel{T_e\left(e_1\right)}{\to }{v}_2\stackrel{T_e\left(e_2\right)}{\to }\cdots \stackrel{T_e\left(e_l\right)}{\to }{v}_{l+1}$$

(1)

where $T_e\left(e_l\right)$ represents the edge type of the l-th edge in the meta-path. This meta-path represents a composite relationship

$$R=T_e\left(e_1\right)\circ T_e\left(e_2\right)\cdots T_e\left(e_l\right)$$

(2)

between node $v_1$ and node $v_{l+1}$, where $\circ$ represents the composite relationship operator.

3.3. Graph Convolutional Network (GCN)

In this study, we employ a Graph Convolutional Network (GCN) to effectively capture and learn node representations for classification tasks. GCN is a powerful neural network model specifically designed to process graph-structured data, allowing it to leverage both topological structures and node attributes for enhanced learning. By utilizing an end-to-end training strategy, the model can automatically extract meaningful structural dependencies and feature correlations from the given graph, ultimately improving both accuracy and robustness in classification and other downstream tasks. Let $H$ be the input feature matrix representing node attributes, and $\tilde{H}$ be the output feature matrix obtained after applying the GCN layers. The forward propagation process of GCN is formulated as follows:

$$\tilde{H}=\mathrm{\sigma }({\tilde{D}}^{-1}{A}^{\mathrm{*}}HW)$$

(3)

where $A^{\mathrm{*}}=A+I$ is the adjacency matrix of the graph $G$, with self-loops added to include the node’s own feature in the transformation. $A$ denotes the initial adjacency matrix, and $I$ denotes the identity matrix. This ensures that during message passing, each node aggregates information not only from its neighbors but also from itself. We will discuss and analyze its role in Section 5. $D$ is the diagonal degree matrix, where each entry $D_{ii}$ represents the degree (i.e., the number of connections) of node $i$ in the graph. ${\tilde{D}}^{-1}$ is the inverse of the degree matrix $D$. $W$ is a trainable weight matrix, which is learned during training to optimize feature transformation. $\mathrm{\sigma }$ is the activation function, which introduces non-linearity to the model and improves its capacity to learn complex patterns. ${\tilde{D}}^{-1}{A}^{\mathrm{*}}$ represents the normalized adjacency matrix, where each row is divided by the corresponding degree. This normalization ensures that features are aggregated in a scale-invariant manner, preventing numerical instability and improving convergence.

Our research process is shown in Figure 2. The dataset provides pre-defined adjacency matrices, node features, and edge features. Building on this, we introduce heterogeneous graphs and meta-paths and further reconstruct the adjacency matrix using meta-paths to generate a meta-path-based adjacency matrix network structure. This meta-path adjacency matrix, along with the node and edge features, is then input into a graph neural network model. The core mechanism of the model involves dynamically updating node features through information propagation and aggregation among nodes. Finally, we employ a Multi-Layer Perceptron (MLP) to predict edge types.

3.4. Theoretical Basis for Trust Evaluation as an Edge Classification Problem

Trust in social networks is essentially a relational attribute, rather than a node attribute. Although existing research often models trust evaluation as a node classification task—i.e., inferring trustworthiness by learning node embedding representations—this paradigm implicitly treats trust as an intrinsic feature of nodes, overlooking the directionality, heterogeneity, and contextual dependence of trust relationships.

From a graph-theoretic perspective, trust relationships can be formalized as labels or weights on directed edges, where the value space corresponds to either discrete trust levels or continuous trust strengths. Consequently, the core task of trust evaluation is, in fact, to discriminate the trust category of each directed edge in the graph, which naturally aligns with the edge classification framework. Reformulating trust evaluation as an edge classification task offers the following theoretical advantages:

(1)

Task Alignment: The fundamental unit of trust expression is “user A’s trust in user B,” a semantic unit that corresponds to a directed edge in the graph rather than an individual node. Edge classification directly treats edges as the prediction unit, ensuring that the task objective is highly consistent with the very definition of trust.

(2)

Explicit Modeling of Relational Heterogeneity: In heterogeneous trust networks, edges convey not only trust values but also multiple relationship types (e.g., the four trust levels in the Advogato dataset). The edge classification framework enables the model to directly discriminate edge types, rather than inferring them indirectly through node representations, thereby making fuller use of edge-level information.

(3)

Natural Expression of Asymmetry: Trust is inherently asymmetric—A’s trust in B does not imply B’s trust in A. Edge classification naturally supports the modeling of directed edges, whereas node classification methods often require compensatory mechanisms such as dual-channel embeddings, which increase modeling complexity.

In summary, formalizing trust evaluation as an edge classification problem is not merely a simplification of task representation; it is a realignment with the essential nature of trust relationships. TrustGTN is built precisely on this understanding: it adopts edges as the prediction unit in its model design and achieves efficient modeling of trust relationships through edge feature learning and fusion mechanisms within heterogeneous graphs.

4. Methodology

The network structure of the l-th TrustGTN model is shown in Figure 3. We first provide a concise overview of the model architecture, followed by a detailed explanation with formulations in the subsequent sections. The adjacency matrix and node features used in our model are directly derived from the public datasets introduced in Section 5.1, without any additional manual feature engineering. The model employs a hierarchical multi-channel graph transformation architecture, whose core consists of stacked TrustGT layers. Each TrustGT layer contains multiple parallel feature learning channels, which dynamically learn and fuse the importance weights of different edge types via lightweight 1 × 1 convolutions, thereby implicitly modeling complex multi-hop semantic paths and avoiding the storage and computational overhead associated with explicit meta-path enumeration in traditional methods. The layers are cascaded to enable deep feature propagation and refinement. Within each channel, node features undergo attention-based neighborhood information aggregation and are further enhanced by a RotatE embedding module to improve the modeling of asymmetric relations. Additionally, a feature-sensitive edge-weight calibration mechanism is introduced to focus on important network connections. Finally, the outputs from all channels are effectively integrated and fed into a prediction layer for trust relation classification.

Learning meta-paths of any length by stacking TrustGT layers means we can potentially find more useful meta-paths, constructing a richer graph structure and capturing more potential patterns and relationships. The original idea of learnable meta-paths was to multiply adjacency matrices of specific edge types (e.g., $e_1,e_2\cdots e_l$) to obtain $A_p=A_{e_l}\cdots A_{e_2}{A}_{e_1}$. Based on this, each TrustGT layer uses a 1 × 1 convolution operation to softly select the adjacency matrix:

$$F(A;{\phi }^{(k)})=con{v}_{1\times 1}(A;soft\max ({\phi }^{(k)}))={\displaystyle \sum _{t=1}^{\left|T_e\right|}{\alpha }_t^{(k)}{A}_t}$$

(4)

where ${\phi }^{\left(k\right)}\in R^{1\times 1\times \left|T_e\right|}$ is the 1 × 1 convolution parameter, and the convex combination of adjacency matrices is ${\alpha }^{\left(k\right)}·A$. The meta-path adjacency matrix is obtained by multiplying the matrix of the previous (k − 1)-th TrustGT layer and the output as $A^{(k-1)}F(A;{\phi }^{(k)})$. It is normalized to prevent numerical instability and enhance the model’s convergence:

$$A^{(k)}={({\widehat{D}}^{(k)})}^{-1}{A}^{(k-1)}\cdot F(A;{\phi }^{(k)})$$

(5)

where ${({\widehat{D}}^{\left(k\right)})}^{-1}$ is the inverse degree matrix of $A^{\left(k-1\right)}\mathrm{F}(A;{\phi }^{\left(k\right)})$.

The adjacency matrix of k + 1 length meta-paths can be represented as:

$$A_P=\left({\sum }_{t_0\in T_e}{\alpha }_{t_0}^{\left(0\right)}{A}_{t_0}\right)\left({\sum }_{t_1\in T_e}{\alpha }_{t_1}^{\left(1\right)}{A}_{t_1}\right)\cdots \left({\sum }_{t_k\in T_e}{\alpha }_{t_k}^{\left(k\right)}{A}_{t_k}\right)$$

(6)

where $A_P$ represents the adjacency matrix under the meta-path and $T_e$ represents the edge type. ${\alpha }_{t_k}^{\left(k\right)}$ is the edge weight of $t_k$ at the k-th TrustGT layer. In uncertain scenarios, the importance of long and short meta-paths is unknown. Therefore, learning meta-paths of different lengths is essential. To achieve this, we incorporate the identity matrix into the initial adjacency matrix, i.e., $A_0=I$. This strategy enables TrustGTN to learn meta-paths of up to $k+1$ in length when stacking $k$ TrustGT layers.

However, explicit multiplication of adjacency matrices undoubtedly requires significant computational cost and memory overhead. Existing methods [26] have proven that the same features can be obtained through a series of feature transformations using differently constructed adjacency matrices, and obtaining these features is the purpose of our downstream tasks. Now, we give a brief proof of this architecture. For simplicity, we assume a single-channel setting ($C=1$), where a single GCN layer is applied to the transformed graph structure. Additionally, the channel aggregation function is defined as the identity function, i.e., $f_{agg}\left(x\right)=x$. Under this assumption, the node representations $\tilde{H}$ in the model are formulated as:

$$\tilde{H}=\sigma ({\tilde{D}}^{-1}(A^{(k)}+I)HW)$$

(7)

where $A^{\left(k\right)}$ is the adjacency matrix output by the k-th TrustGT layer. $H$ represents the input features. $W$ denotes the linear transformation parameters in the GCN layer. ${\tilde{D}}^{-1}$ is the inverse degree matrix of $A^{\left(k\right)}+I$, and $I$ is the identity matrix.

Equation (7) can also be written as:

$$\tilde{H}=\sigma ({\tilde{D}}^{-1}HW+{\tilde{D}}^{-1}({({\widehat{D}}^{(k)})}^{-1})\cdots ({({\widehat{D}}^{(1)})}^{-1}({\alpha }^{(0)}\cdot A)({\alpha }^{(1)}\cdot A))\cdots ({\alpha }^{(k)}\cdot A))HW)$$

(8)

Clearly, Equation (8) involves the multiplication of large adjacency matrices, but by applying the associative property of matrix multiplication, Equation (8) can be rewritten as follows:

$$\tilde{H}=\sigma ({\tilde{D}}^{-1}HW+{\tilde{D}}^{-1}{({\widehat{D}}^{(k)})}^{-1}\dots {({\widehat{D}}^{(1)})}^{-1}({\alpha }^{(0)}\cdot A({\alpha }^{(1)}\cdot A\dots ({\alpha }^{(k)}\cdot AHW))))$$

(9)

Since this method no longer computes the multiplication of two adjacency matrices, we are unable to calculate the degree matrices ${\tilde{D}}^{-1}{({\widehat{D}}^{(k)})}^{-1}\cdots {({\widehat{D}}^{(1)})}^{-1}$, but we can transform all the degree matrices in Equation (9) into identity matrices:

$$\tilde{H}=\sigma ({\displaystyle \frac{1}{2}}HW+{\displaystyle \frac{1}{2}}({\alpha }^{(1)}\cdot A({\alpha }^{(2)}\cdot A\dots ({\alpha }^{(k)}\cdot AHW))))$$

(10)

We reverse the order of layers from 1 to K, replace the hyperparameter $\gamma$, and incorporate our reconstructed adjacency matrix method along with the multi-channel and multi-layer settings. Therefore, the output of TrustGTN can be represented as:

$$Z^{(l+1)}=f_{agg}(\underset{C=1}{\overset{C^{(l)}}{\parallel }}\sigma (\gamma H^{(l)}{W}_C^{(l)}+(1-\gamma )H_C^{(l,k)}))$$

(11)

$$H_C^{(l,K)}=({\widehat{A}}_K\dots ({\widehat{A}}_1{H}^{\left(l\right)}{W}_C^{\left(l\right)}))$$

(12)

where $C^{\left(l\right)}$ is the number of channels, $\gamma$ is a hyperparameter, ‖ is the concatenation operator, $H^{\left(l\right)}$ is the node representation of the l-th TrustGTN layer, $W_C^{\left(l\right)}\in R^{d\left(l\right)\times d(l+1)}$ is the linear transformation of the c-th channel of the l-th TrustGTN layer provided by GCNConv, and ${\widehat{A}}_K$ is the reconstructed meta-path adjacency matrix. The difference between it and the meta-path adjacency matrix with self-loops is the stored edge weights, i.e., we propose reconstructing the meta-path adjacency matrix. Its formula can be expressed as:

$${{\widehat{A}}_K}_{(i,j)}={\displaystyle \frac{({\alpha }^{(l,K,C)}{{\widehat{A}}_{K-1})}_{(i,j)}+\mathit{exp}(-elu(a\cdot [(H^{\left(l\right)}{W}_C^{\left(l\right)})[i],(H^{\left(l\right)}{W}_C^{\left(l\right)})[j]))}{2}}$$

(13)

where ${\alpha }^{(l,K,C)}$ is the c-th filter for the k-th TrustGT layer of the l-th TrustGTN layer, $(H^{\left(l\right)}{W}_C^{\left(l\right)})[i]$ and $(H^{\left(l\right)}{W}_C^{\left(l\right)})[j]$ are the features of the source and target nodes after channel linear transformation, $a$ is a set of learnable parameters, $H^{\left(0\right)}$ is the feature matrix, ${\widehat{A}}_0={\tilde{D}}^{-1}(A+I)$ and $f_{agg}$ is the channel aggregation function.

The RotatE method [27] is an innovative technique for feature fusion, particularly suitable for handling complex feature relationships between nodes and edges in heterogeneous graph neural networks. This method rearranges node or edge features in the feature space through specific rotational transformations, enhancing feature expression and introducing more semantic information. Let $h={\widehat{A}}_K{H}^{\left(l\right)}{W}_C^{\left(l\right)}$; we combine entities and relationships in the complex plane and define each relationship as a rotation from the source entity to the target entity. Specifically, we expect $h^{\prime }=h\circ r$, where $h,r,h^{\prime }\in C$ is the embedding, $\left|r_i\right|=1$, and ∘ represents the Hadamard (element-wise) product.

Node features are utilized to predict trust relationships. From the final feature representation, we extract the feature representations of two nodes, $Z_u$ and $Z_v$. The model’s prediction result is

$${\tilde{y}}_{u-v}=\sigma \left(MLP\right(Z_u\left|\right|Z_v\left)\right)$$

(14)

where ‖ is the concatenation operation, MLP() is a Multi-Layer Perceptron, and $\sigma (\cdot )$ is the activation function. For trust issues, mapping different levels of trust values to different trust types allows us to treat it as an edge classification problem. Therefore, we choose cross-entropy loss as the loss function

$$L=cross\_entropy(Y,\tilde{Y})$$

(15)

where $Y$ is the known edge classification value in the trust graph, and $\tilde{Y}$ is the edge classification value predicted by the TrustGTN model.

5. Experiments and Analysis

In this section, we introduce the dataset, experimental setup, and related baselines. We then compare our method with these baselines to determine whether it has superior performance.

5.1. Dataset

The Advogato dataset is a classic social network dataset from a developer community website, often used to study trust relationship networks, graph analysis, and machine learning tasks such as community detection, trust prediction, and link prediction. It is a directed weighted graph where nodes represent users, edges represent trust relationships between users, and edge weights represent trust levels. The trust levels are divided into four categories, Observer, Apprentice, Journeyer, and Master, with trust levels increasing from Observer to Master. It is a sparse network containing thousands of nodes and edges, with no additional attribute information attached to the nodes, primarily focusing on trust relationships.

5.2. Baselines

(1)

MATRI [15]: MATRI is a trust inference model that integrates multi-faceted characteristics and transitivity. It transforms the trust problem into a recommendation problem, using collaborative filtering to represent the multi-faceted latent characteristics between trustors and trustees. It introduces three trust biases as prior knowledge: global bias, trustor bias, and trustee bias, and the model automatically learns the weight relationships between these biases and latent factors. It updates the latent factor matrix (trustors and trustees) through matrix factorization.

(2)

OpinionWalk [28]: OpinionWalk models trust using Dirichlet distributions and uses matrices to represent direct trust relationships between users. It searches the network in a BFS manner and iteratively calculates user trustworthiness. To achieve iterative calculations, the authors use an opinion matrix to represent the network and a personal opinion vector to store the trustworthiness of all users. This addresses the issue that many trust evaluation calculations are either inaccurate or very slow.

(3)

NeuralWalk [16]: NeuralWalk uses a neural network architecture called WalkNet to capture trust propagation and fusion in trust social networks. It iteratively uses the trained WalkNet to perform single-hop trust inference on unknown trust relationships and then traverses the entire trust evaluation network in a breadth-first manner to achieve multi-hop trust evaluation.

(4)

Guardian [24]: Guardian proposes an end-to-end learning framework based on Graph Convolutional Networks (GCN) to efficiently and accurately evaluate trust relationships in social networks. It models the social network as a graph, where nodes represent users and edges represent trust relationships between users. The core of the framework is the trust convolutional layer, which uses local convolution to capture the propagation and composability of social trust. Considering the asymmetry of trust, each trust convolutional layer consists of popularity trust propagation and participation trust propagation, comprehensively considering trust degree and being-trusted degree.

(5)

TrustGNN [25]: TrustGNN is also a graph neural network-based method that further captures the propagation and composability between trust graphs. It views trust propagation as a chain and uses attention mechanisms to distinguish the importance of different chains. It also uses a dual-channel fusion algorithm to learn node representations from both trustor to trustee and trustee to trustor directions, obtaining a more comprehensive node embedding, and then uses the learned node embeddings for trust prediction.

5.3. Evaluation Metrics

Following the evaluation criteria used in Guardian [24] and TrustGNN [25], we adopt F1-score and Mean Absolute Error (MAE) as our primary evaluation metrics. The F1-score measures the balance between precision and recall, with a higher value indicating better classification performance. Meanwhile, MAE quantifies the average absolute difference between the predicted and true values, where a lower MAE signifies higher prediction accuracy. To ensure the reliability of our experimental results, we report the average performance over 10 independent runs. For Guardian and TrustGNN, we reproduced their results by running their original implementations with default hyperparameters on our computing infrastructure. The performance of other baseline methods is taken from the reported results in TrustGNN. This approach ensures fair comparisons and minimizes potential biases introduced by differences in hardware or software environments.

5.4. Parameter Settings and Equipment

We randomly select 80% of the data as the training set and the remaining 20% as the test set. For the random seed, we fix it to be consistent with TrustGNN. The learning rate is set to 0.005, weight decay is set to 0.001, the number of epochs is set to 300, and the multi-channel parameter is set to 2. All our experiments are conducted on a personal computer, with the experimental environment being Python 3.9, PyTorch 2.1, Windows 10, Intel(R) Core(TM) i5-12600KF 3.70 GHz CPU, 16 GB RAM, and NVIDIA 4060ti 8 G GPU. Due to problems with the hardware devices, we were unable to conduct experiments on PGP, another dataset mentioned in previous work, because it has about 6 times the data volume of Advogato.

5.5. Visualization and Parameter Analysis

We visualize the performance of TrustGTN on the Advogato dataset, and the results are shown in

Table 3. Performance on Advogato. The best results are in bold.

Methods	Advogato
	F1-Score	MAE
TrustGTN	75.0%	0.079
TrustGNN	74.4%	0.081
Guardian	73.0%	0.087
NeuralWalk	74.0%	0.082
OpinionWalk	63.3%	0.232
Matri	65.0%	0.141

, with the best results in bold. TrustGTN achieves the best results in both F1-score and MAE metrics. Compared to the best-performing TrustGNN, TrustGTN improves the F1-score by 0.6%. In terms of MAE, TrustGTN also leads TrustGNN and NeuralWalk, achieving 0.079.

To evaluate the robustness of our proposed method, we conduct a series of experiments on the Advogato dataset, comparing the performance of TrustGTN, TrustGNN, and Guardian under different training set ratios (80%, 60%, and 40%). As shown in

Table 4. Performance with different sizes of training set on Advogato. The best results are in bold.

Methods	Training Set (%)	F1-Score	MAE
TrustGTN	80%	75.0%$\mathbf{\pm }$0.1%	0.079$\mathbf{\pm }$0.001
	60%	73.0%$\mathbf{\pm }$0.1%	0.087$\mathbf{\pm }$0.001
	40%	70.8%$\mathbf{\pm }$0.1%	0.094$\mathbf{\pm }$0.001
TrustGNN	80%	$74.4\% \pm$ 0.1%	$0.081 \pm$ 0.001
	60%	$72.6\% \pm$ 0.1%	$0.088 \pm$ 0.001
	40%	$70.1\% \pm$ 0.1%	$0.096 \pm$ 0.001
Guardian	80%	$73.0\% \pm$ 0.1%	$0.087 \pm$ 0.001
	60%	$71.7\% \pm$ 0.1%	$0.091 \pm$ 0.001
	40%	$69.7\% \pm$ 0.1%	$0.098 \pm$ 0.001

, TrustGTN consistently achieves the highest F1-score and the lowest MAE across all training set sizes. This result highlights the superior generalization ability of our approach, even when the available training data is limited. Additionally, we conduct 10 rounds of experiments for both TrustGTN and TrustGNN and visualize the variation trends of F1-score and MAE, as illustrated in Figure 4 and Figure 5. The results indicate that TrustGTN exhibits relatively low variance across different runs, further demonstrating its stability.

Our memory and training time analysis is illustrated in Figure 6. Notably, through a series of algorithmic and engineering optimizations, our model successfully translates the increased theoretical component complexity into high efficiency during actual operation. Specifically, we eliminate the need for explicit meta-path enumeration and storage inherent in traditional methods, replacing them with a dynamic soft-selection mechanism and inter-layer 1 × 1 convolutional weights to simulate meta-path fusion, thereby significantly conserving storage resources and substantially enhancing computational efficiency. The experimental results demonstrate that under identical hardware conditions, while achieving superior predictive performance, TrustGTN attains an average per-epoch training time reduction of approximately 55% and a reduction in peak memory usage of about 18%, indicating higher parameter and data efficiency. This efficiency improvement not only confirms the model’s scalability under practical resource constraints but also enhances its adaptability and potential for application to complex graph structures through its capability to automatically discover significant propagation paths.

We compare randomly generated learnable node features and edge features with node features extracted using node2vec and one-hot vectors as edge features. The experimental results show that randomly generated learnable node features and edge features perform better, as shown in

Table 5. Comparison of different node and edge types. The best results are in bold.

Node	Edge	F1-Score	MAE
Random	Random	75.0%	0.079
Random	One-hot	73.5%	0.084
Node2vec	Random	66.0%	0.108
Node2vec	One-hot	65.8%	0.109

. The optimal settings are a node dimension of 512 and an edge dimension of 512, as shown in

Table 6. F1-scores of different node and edge dimensions. The best results are in bold.

	Node_Dim	64	128	256	512	1024
Edge_Dim
64		69.4%	71.6%	73.6%	74.4%	74.6%
128		70.4%	72.6%	74.1%	74.8%	74.7%
256		71.3%	73.2%	74.5%	74.9%	74.6%
512		71.8%	73.4%	74.6%	75.0%	74.6%
1024		71.9%	73.6%	74.7%	74.9%	74.6%

.

We argue that the effectiveness of random node initialization (RNI) [29] in our experiments stems fundamentally from its ability to break the 1-WL expressiveness bottleneck that limits standard GNNs. Deterministic structured embeddings, such as node2vec, fail to assign discriminative representations to nodes in symmetric structures. In contrast, RNI injects random noise to enable node individualization, allowing the model to effectively distinguish 1-WL indistinguishable graphs while preserving permutation invariance. Our experimental results directly support this interpretation, demonstrating that RNI is not a mere heuristic, but a principled strategy for overcoming the expressiveness limitations of GNNs.

In Section 3.3, we mentioned that we added self-loops to the initial adjacency matrix, which is a common and essential design in Graph Neural Networks (GNNs), serving two main purposes: (1) preserving a node’s own features during aggregation to maintain its identity and mitigate over-smoothing; and (2) ensuring numerical stability by preventing zero-degree nodes in normalization. Experimental results (as shown in Figure 7) demonstrate that adding self-loops consistently yields significant performance gains, which strongly supports the above motivations.

As mentioned earlier, we can achieve multi-hop meta-path aggregation by stacking TrustGT layers. We show the results under different training set sizes in Figure 8, and we also show the impact of the hyperparameter $\gamma$ in Figure 9, which controls the residual fusion of node features. The experimental results show that stacking TrustGT layers exhibits the same problem as stacking graph neural networks, with the best model performance appearing only in the first layer. This means that a meta-path of length 2 is the optimal meta-path length for the current task. The reason may be that a longer meta-path may introduce information that is not relevant to the target task, for example, in a social network, friends of friends of friends may already contain a larger number of unrelated users. Often, indirect trust (i.e., length = 2) already describes the relationship well, while a longer path may introduce too many indirect relationships and weaken the expression of trust.

.

The hyperparameter γ controls the fusion ratio of features before and after propagation, affecting the model’s tradeoff between historical and new fusion information. As can be seen from the results in Figure 9, the model effect gradually deteriorates as γ increases. This is a normal phenomenon, indicating that the effect of information propagation and aggregation is limited when the model relies too much on its own characteristics and weakens the influence of neighbor or multi-hop information. In other words, this further verifies that the model can integrate local and global information more effectively under a reasonable value of γ, thereby improving the overall performance.

5.6. Ablation Study

As introduced in the introduction, some modules in our TrustGTN model have an impact on the model’s performance. Now, we prove the usefulness of these modules. We name the basic TrustGTN model as TrustGTN-1. The message passing process of TrustGTN-1 is matrix multiplication, i.e., the adjacency matrix multiplied by the feature matrix. The adjacency matrix is a combination of learnable edge type weights and initial edge weights based on node degrees. Then, we propose a new message passing method, which considers edge weights calculated based on the features of the starting nodes in addition to the previous two weights. We name this model TrustGTN-2. Finally, we apply the RotatE transformation to the basic model TrustGTN-1 and name this model TrustGTN-3. The experimental results demonstrate the effectiveness of these two methods, as shown in Figure 10.

6. Conclusions

TrustGTN is a deep learning model for trust evaluation in social networks, which formulates the trust problem as a heterogeneous trust graph and leverages the concept of meta-paths to capture relationships between nodes and multiple edges. Without requiring explicit meta-path definitions, the model can theoretically learn node representations under meta-paths of any length by stacking layers. Experimental results on real-world datasets demonstrate the superior performance of TrustGTN, while ablation studies further validate the effectiveness of its design.

7. Future Work

Despite the proposed framework’s theoretical capacity to model heterogeneous graphs with diverse node and edge types, our experimental validation in this study was conducted exclusively on datasets containing a single node type. We acknowledge this as a clear limitation, as it does not fully exploit the model’s architectural potential and leaves its claimed heterogeneity-handling capability empirically underverified. This constraint was primarily due to the lack of publicly available heterogeneous graph benchmarks that simultaneously align with the trust evaluation task—a challenge we aim to address in subsequent work.

Furthermore, we intend to extend the current framework toward dynamic trust evaluation. Trust relationships in practical systems are rarely static; they evolve over time as new interactions occur, historical behaviors accumulate, and contextual factors shift. Incorporating temporal dynamics into heterogeneous trust modeling presents both theoretical and technical challenges—ranging from capturing non-stationary trust patterns to maintaining computational efficiency over evolving graph snapshots. We plan to investigate temporal heterogeneous graph neural networks that integrate time-decay mechanisms, recurrent architectures, or continuous-time process models, enabling the framework to learn both structural and temporal trust dependencies. By bridging the gap between static heterogeneity modeling and dynamic evolution, we aim to build a more faithful and deployable solution for real-time trust assessment in open, decentralized environments.