SDW2vec: learning structural representations of nodes in weighted networks

Abstract

Recent advances in machine learning have prompted researchers to integrate complex network structures into computational frameworks to improve inferential capabilities. Node embedding has become a promising technique in this area. However, challenges persist in accurately representing the structural characteristics of nodes in weighted networks. In this study, we propose SDW2vec, which learns the embeddings of nodes in weighted networks while preserving structural properties. Our proposed methodology addresses these challenges through a multi-scale comparison of link weights among adjacent nodes up to a predefined hop count. This approach facilitates the calculation of distances between nodes’ structural configurations across multiple scales. We subsequently construct weighted multi-layer graphs based on these distance measurements, apply random walks to generate node sequences, and learn the embedding representations using the Skip-gram model. The efficacy of our methodology is validated through both the interpretability of embedding representations in controlled network environments and the structural reproducibility demonstrated in real-world networks.

Introduction

Complex networks have emerged as a fundamental framework for modeling interconnected systems across diverse domains. These networks comprise elements (nodes) and their interactions (links). In weighted networks, link weights capture the strength of interactions, enabling more refined representations of real-world complexity. By leveraging link weights, one can model intricate information such as relationship strength, distance, cost, or capacity between nodes (Barrat et al. 2004). Social network analyses, for instance, can express the intensity of interpersonal connections (Opsahl et al. 2010), while transportation network studies can represent geographical distances or travel times (Barthélemy 2011).

Recent advances in machine learning have prompted researchers to investigate the integration of complex network structures into computational frameworks, seeking enhanced inferential capabilities. Node embedding has emerged as a particularly promising approach, aimed at mapping similar nodes near each other within vector spaces. This technique preserves nodes’ intrinsic characteristics by representing them as continuous vectors while maintaining their network-based similarities (Goyal and Ferrara 2018; Zhou et al. 2022). Node embedding incorporates two primary similarity criteria: nodal proximity within the network (proximity-based embedding) and the structural similarity of connection patterns (structure-based embedding) (Ahmed et al. 2020). Proximity-based embeddings focus on preserving information about node connections, rendering them particularly effective for tasks such as community clustering. Conversely, structure-based embeddings delve deeper by capturing the local connectivity patterns of nodes, demonstrating particular strength in role discovery. A critical insight in network analysis is that nodes can exhibit structural similarity through comparable degrees, even when they exist in distinct network components (non-connected sub-networks within a larger network structure) (Rossi et al. 2020). This characteristic enables the assessment of nodal similarities across disparate network configurations, transcending the limitations of traditional proximity-based methodologies. The implications of this approach extend beyond mere structural analysis. Specifically, such embeddings facilitate domain adaptation strategies that enable the transfer of node label information between heterogeneous networks (Liu et al. 2022). By capturing underlying structural similarities, researchers can develop more sophisticated methods for knowledge transfer and comparative network analysis, opening new avenues for interdisciplinary network research.

Embedding weighted networks presents significant analytical challenges. Traditional unweighted methods typically rely on binary adjacency matrices, whereas weighted networks demand more sophisticated approaches that can accommodate real-valued representations of link intensities. Proximity-based embedding methods like DeepWalk (Perozzi et al. 2014) and walklets (Perozzi et al. 2017) can be extended to weighted networks, but capturing structural features becomes substantially more complex when both link quantity and strength must be simultaneously considered. Existing approaches often struggle to adequately capture the structural properties inherent in weighted networks.

To address these limitations, we propose SDW2vec for learning embedding representations that effectively preserve nodes’ structural features in weighted networks. We define structural properties for nodes in weighted networks and develop a series of distance functions to evaluate structural similarities across multiple scales. Our proposed method generates node embeddings by adapting the struc2vec framework, with the potential for application across networks with varying characteristics. Evaluations conducted on both toy networks and real-world datasets demonstrated the significant efficacy of the proposed methodology, validating its superior performance relative to existing approaches.

The subsequent sections of this paper are organized as follows: Sect. Preliminary and related research presents related research, Sect. Methodology details our methodology, Sect. Experiments and results discusses experimental results, and Sect. Conclusion provides a conclusion.

Preliminary and related research

Weighted networks

A weighted network is formally defined as a tuple $G=(V,E)$, where $V=\{v_1,v_2,\ldots,v_n\}$ represents the set of nodes, and $E$ denotes the link set, defined as $E=\{(v_i,v_j,w_{ij}) \mid v_i,v_j \in V,\, w_{ij} \in \mathbb {R}\}$. In this representation, $w_{ij} \in \mathbb {R}$ corresponds to the weight assigned to the link between nodes $v_i$ and $v_j$.

The network taxonomy extends to more complex configurations. A network $G$ is classified as a signed network when it contains at least two distinct links with weights $w_{ij} > 0$ and $w_{kl} < 0$, respectively. Similarly, the network is termed directed when the ordering of nodes in the link tuples $(v_i,v_j,w_{ij})$ in $E$ indicates a directional relationship from node $v_i$ to $v_j$. The structural and weighted properties of $G$ are comprehensively encapsulated in its weighted adjacency matrix $W=(w_{ij})^{n\times n}$, where each entry $w_{ij}$ specifies the weight of the link from node $v_i$ to $v_j$. This research focuses on weighted networks that may exhibit variations in signs and directionality.

Structure in weighted networks

Network structure diverges fundamentally from network proximity. While proximity concerns the specific nodes to which a node is connected, structure delves into the manner of those connections. In previous studies, structural equivalence in the network has been discussed from various perspectives (Rossi and Ahmed 2014). Traditional network analysis in unweighted networks has relied on the concept of automorphic equivalence, a sophisticated notion of structural similarity. Automorphic equivalence posits that nodes $u$ and $v$ are equivalent if an automorphic mapping $p$ exists such that $u = p(v)$. More broadly, an isomorphism between graphs $G=(V_1,E_1)$ and $H=(V_2,E_2)$ requires a bijective mapping that preserves relational structures. When the graphs are identical, this mapping becomes an automorphism.

Intuitively, structural equivalence explores whether nodes can be interchanged while maintaining their relational integrity. Previous research has employed relaxed interpretations of automorphic equivalence to assess node structure (Ribeiro et al. 2017; Xu et al. 2019). Existing studies have traditionally emphasized node degree as the primary structural feature, iteratively aggregating degree information across a predefined number of hops to assess local structure (Ribeiro et al. 2017).

In this research, we simultaneously consider both node degree and link attributes (weights, signs, and directions) to define node structure as the local connection patterns. Recognizing the rarity of nodes with precisely identical link numbers and weights, we introduce a more flexible definition of structural equivalence that captures the intricate characteristics of weighted networks.

Node embedding

Node embedding represents a critical computational approach that maps network nodes to vectors in a low-dimensional space while preserving essential network characteristics (Goyal and Ferrara 2018; Zhou et al. 2022). Functioning as a pivotal bridge between network-structured data and vector-based machine learning tasks, node embedding transforms network representations into computationally tractable forms. Given a network represented as a graph $G=(V,E)$, the node embedding task involves learning a mapping function $f:V \rightarrow \mathbb {R}^d$ that projects each node $v_i \in V$ to a $d$-dimensional vector $\textbf{z}_i \in \mathbb {R}^d$, where the dimensionality $d$ is typically significantly smaller than the total number of nodes $|V|$.

The generated embeddings serve as versatile representations for numerous downstream machine learning tasks, including link prediction, node classification, and role discovery (Cui et al. 2018; Kumar et al. 2020; Tang et al. 2016; Liu et al. 2021). A fundamental principle of node embedding is that similar nodes should occupy proximal positions within the vector space, with similarity criteria varying based on network context and specific application requirements. These similarity measures predominantly encompass two primary approaches: proximity-based similarity, which focuses on nodal closeness within the network, and structure-based similarity, which examines the intricate connection patterns of nodes (Rossi et al. 2020).

Existing research has predominantly concentrated on proximity-based embedding approaches. Seminal works such as DeepWalk (Perozzi et al. 2014) leverage random walks to capture node adjacency relationships, while Walklets (Perozzi et al. 2017) extends this concept by incorporating skip operations to generate embeddings that consider adjacency information across multiple hops. The APP methodology (Zhou et al. 2017) introduced random walks with restart operations to accommodate asymmetric adjacency matrices. Alternatively, some methods capture structural information as part of a broader objective rather than by directly learning embeddings for each node. For example, role2vec (Ahmed et al. 2019) is a framework that focuses on embedding roles–groups of structurally equivalent nodes–instead of the nodes themselves. Another such method is xNetMF (Heimann et al. 2018), a matrix factorization technique that leverages structural similarity not as an end in itself, but as a component to align nodes across different graphs.

Structure-based embedding representation learning represents a complementary approach. The struc2vec framework (Ribeiro et al. 2017) generates embeddings through random walks on multilayer graphs that capture nodal structural characteristics across multiple hop ranges. GraphWave (Donnat et al. 2018) provides an alternative perspective by treating spectral graph wavelet diffusion patterns as probability distributions, subsequently generating embedding representations from characteristic functions. To the best of our knowledge, there are no existing structure-based embedding methods specifically designed for weighted networks in the current literature.

Graph Neural Networks (GNNs) offer an alternative mechanism for generating node embeddings that entails diverse architectures. Unlike direct embedding methods, GNNs function as end-to-end models that typically require inference labels for specific learning tasks, with node embeddings emerging as a derivative outcome. A critical limitation of GNN approaches lies in their embedding generation process, which is substantially influenced by task-specific labels and learning objectives. Consequently, these methods present significant challenges for unsupervised learning downstream tasks where explicit label information is unavailable. Consequently, GNNs fall outside the scope of this study.

Methodology

Fig. 1

Conceptual diagram of the proposed methodology. The figure illustrates the workflow from a raw weighted network to the final node embeddings and a downstream task. A A sample signed, directed, and weighted network. Node colors represent distinct structural roles. Link color indicates the sign (e.g., red for negative), and thickness corresponds to weight. B The network’s weighted adjacency matrix. C Extraction of weight lists for each node, separated into different channels (e.g., positive outgoing links). D Transformation of weight lists into rescaled weight distributions (rwd) using an entropy-optimized binning process. E Calculation of structural distances between node pairs at multiple hop depths (k = 0 to k = 3). F Construction of a multi-layer graph where each layer k connects nodes based on their k-hop structural similarity. Inter-layer links connect the same node across different layers. G Generation of node sequences (contexts) via random walks on the multi-layer graph. H Learning of low-dimensional node embeddings from the context sequences using the Skip-gram model. Structurally similar nodes (e.g., nodes 0 and 9) are mapped to nearby points in the embedding space. I Application of the learned embeddings to a downstream task, such as visualization of node structure

In this section, we introduce our proposed methodology, SDW2vec. The nomenclature reflects its application domain, where S, D, and W represent signed, directed, and weighted networks, respectively. This indicates that our method is capable of embedding nodes in signed, directed, weighted networks.

The overall workflow of the proposed methodology, as illustrated in Fig. 1, begins with deriving the weighted degree of each node (Fig. 1C) from the adjacency matrix (Fig. 1B) corresponding to the target weighted network (Fig. 1A). This is subsequently transformed into weight distributions (Fig. 1D). Subsequently, distances up to multiple hops are computed using a specific distance function (Fig. 1E). Following the struc2vec framework (Ribeiro et al. 2017), a multilayer graph where structurally similar nodes are connected with high weights is constructed (Fig. 1F), followed by context generation through random walks and embedding learning (Fig. 1G, H). We now elaborate on the weighted degree and its corresponding distance function.

Weighted degree: definition of node structure in weighted networks

In weighted signed directed networks, links are categorized into four distinct channels: +out, −out, +in, and −in. The structural properties of a node depend on the number of links, their weights, signs, and directions.

The 0-hop structural information of node $i$, as illustrated in Fig. 1C, is aggregated into a weighted degree sequence ($\textrm{wd}_i^c$, a set of real numbers), where $c$ denotes the channel ($c \in \{+\textrm{out}, -\textrm{out}, +\textrm{in}, -\textrm{in}\}$). This sequence is defined as:

$$\begin{aligned} \begin{aligned}&\textrm{wd}_i^\mathrm {+out} & = \left[ w_{ij} \mid w_{ij}> 0\right], \\&\textrm{wd}_i^\mathrm {-out} & = \left[ w_{ij} \mid w_{ij}< 0\right], \\&\textrm{wd}_i^\mathrm {+in} & = \left[ w_{ji} \mid w_{ji} > 0\right], \\&\textrm{wd}_i^\mathrm {-in} & = \left[ w_{ji} \mid w_{ji} < 0\right]. \end{aligned} \end{aligned}$$

(1)

The weighted degree sequence represents the weights of links associated with a node, where the sequence length equals the number of links in a specific channel. Depending on network properties, link weights may be discrete or continuous. For example, in e-commerce rating networks, user-to-product links often have discrete weights (e.g., integer ratings from 1 to 5), whereas gene co-expression networks may use continuous weights (e.g., correlation coefficients between $-$1.0 and +1.0).

In weighted networks, a node’s structural characteristics are determined by both its total degree (number of links) and the distribution of link weights. We hypothesize that the weights of links associated with a node follow a latent probability distribution, which encapsulates the node’s structural features. We propose that discretizing the weights in a weighted network may enable the extraction of pseudo-structures, thereby facilitating the analysis of structural equivalence that incorporates the strength of connections. To implement this, we applied a binning operation to discretize the link weights, allowing the transformation of continuous weight values into discrete intervals. This approach provides a framework for evaluating node roles and network organization while explicitly accounting for variations in connection intensity. Specifically, the weighted degree sequence is treated as a sampled realization from this latent distribution. Through a binning function $f$ (Eq. 2), the weighted degree sequence is discretized to approximate the latent weight distribution ($\textrm{rwd}_i^c$):

$$\begin{aligned} \textrm{rwd}_i^c = f\left( \textrm{wd}_i^c\right). \end{aligned}$$

(2)

The function $f$ typically partitions the weight domain into equal-intervals or equal-frequency bins. For instance, in Fig. 1C, the +out channel uses bins defined by boundaries [0.5, 1.5, 2.5, 3.5].

The selection of $f$ and the number of bins could be carried out depending on the nature of the network or the purpose of the particular task. We provide a technique to search for the optimal $f$ and the number of bins in the perspective of preserving entropy. This approach is grounded in the principle that higher entropy levels establish more robust boundaries for information preservation in embedding learning tasks. For all link weights in channel $c$, we search for the optimal combination of $f$ and the number of bins using the elbow method to preserve the entropy of $\textrm{rwd}^c$ efficiently. Let $W^c = \{w_1, w_2, \ldots, w_n\}$ be the set of link weights in channel $c$, and the optimization problem can be formulated as:

$$\begin{aligned} \min _{\{f, b\}} \left| H(W^c) - H\left( f(W^c, b)\right) \right|, \end{aligned}$$

where $H(W^c)$ is the original entropy of the link weights and $H\left(f(W^c, b)\right)$ is the entropy after applying partition function $f$ with b bins. We select $(f, b)$ that minimizes the entropy difference while maintaining the most informative representation.

The overall latent weight distribution for node $i$ across all channels is obtained by concatenating the distributions from each channel (Eq. 3), where $||$ denotes vector concatenation:

$$\begin{aligned} \textrm{rwd}_i = \textrm{rwd}_i^\mathrm {+out} \hspace{5.0pt}|| \hspace{5.0pt}\textrm{rwd}_i^\mathrm {-out} \hspace{5.0pt}|| \hspace{5.0pt}\textrm{rwd}_i^\mathrm {+in} \hspace{5.0pt}|| \hspace{5.0pt}\textrm{rwd}_i^\mathrm {-in}. \end{aligned}$$

(3)

Here, $\textrm{rwd}_i$ is termed the weighted degree of node $i$.

Distance function: assessment of distance between node structure

Next, we define the distance between weighted degrees. Since weighted degrees are essentially probability distributions, we apply Jensen–Shannon (JS) divergence to calculate the distance between distributions, due to the requirement of symmetry in the distance between weighted degrees. Since $\textrm{rwd}$ represents the number of links falling into the corresponding bin, it is divided by the sum of $\textrm{rwd}$ (namely, node degree) before calculating JS divergence:

$$\begin{aligned} D^{\prime }_\textrm{JSD}(\textrm{rwd}_i, \textrm{rwd}_j) = D_\textrm{JS}\bigg (\frac{\textrm{rwd}_i}{\sum \textrm{rwd}_i},\frac{\textrm{rwd}_j}{\sum \textrm{rwd}_j}\bigg ) \end{aligned}$$

(4)

Furthermore, it is natural to consider that links with larger weights have a greater impact on the node structure. Thus, we weight $\textrm{rwd}$ by the importance of bins. Specifically, for $\textrm{rwd}_i^c=\text {[}x_1,\cdots, x_L\text {]}$ divided into L bins, $x_1$ represents the number of links in bin 1. When the importance of bins $\text {[}1,\cdots, L\text {]}$ is $\text {[}b_1,\cdots, b_L\text {]}$, the corrected $\hat{\textrm{rwd}}_i^c$ becomes:

$$\begin{aligned} \hat{\textrm{rwd}}_i^c=\text {[}b_1x_1,\cdots, b_Lx_L\text {]} \end{aligned}$$

(5)

$b_1x_1$ represents the corrected number of links in bin 1 with weight $b_1$. In this method, we use default corrections of $b_i=i$ and $b_i=L-i+1$ for positive and negative channels, respectively.

Therefore, the adjusted version of Eq. 4 becomes:

$$\begin{aligned} D_\textrm{JSD}(\textrm{rwd}_i, \textrm{rwd}_j) = D_\textrm{JS}\bigg (\frac{\hat{\textrm{rwd}}_i}{\sum \hat{\textrm{rwd}_i}},\frac{\hat{\textrm{rwd}}_j}{\sum \hat{\textrm{rwd}_j}}\bigg ) \end{aligned}$$

(6)

In addition to the channel and weight distribution differences, node degree is another crucial structural feature. In this research, we evaluate the difference of degree by the relative difference of the maximum frequency in $\max (\textrm{rwd})$:

$$\begin{aligned} D_\textrm{scale}(\textrm{rwd}_i, \textrm{rwd}_j) = \left| \frac{\max (\textrm{rwd}_i)-\max (\textrm{rwd}_j)}{\max (\textrm{rwd}_i)+\max (\textrm{rwd}_j)}\right| \end{aligned}$$

(7)

By dividing by the sum of maximum frequencies, we can capture minor differences as fluctuations for nodes with large scales, thereby more accurately capturing the structure in scale-free networks. If two nodes have different degrees but share the same weight distributions, Eq. 7 is equivalent to $\left| \frac{d_i-d_j}{d_i+d_j}\right|$.

Consequently, to incorporate both JS divergence and the relative maximum frequency difference, we define the 0-hop distance ($d_0$) between node i and j as follows:

$$\begin{aligned} d_0(i,j)=e^S\biggl (\exp {\bigg (D_\textrm{JSD}(\textrm{rwd}_i,\textrm{rwd}_j)+ } { D_\textrm{scale}(\textrm{rwd}_i,\textrm{rwd}_j)\bigg )}-1\biggl ) \end{aligned}$$

(8)

Here, S is a constant adjusting the distance sensitivity. We proposed a technique to search for the optimal S and see Appendix C for details.

In Eq. (8), $D_\textrm{JSD}(\cdot )$ measures the difference in link weight distributions between nodes, with a value range of $[0, \log 2]$. $D_\textrm{scale}(\cdot )$ measures the frequency scale difference of maximum values, with a value range of $\text {[}0, 1\text {]}$, which is proportionally compatible with $D_\textrm{JSD}(\cdot )$’s range.

Furthermore, the distance between k-hop neighboring nodes’ $\textrm{rwd}$ sequences (denoted as $\textrm{RWD}$) of node i and j is defined as:

$$\begin{aligned} d_k(i,j)=\textrm{DTW}\left( d_0,\hspace{5.0pt}\textrm{RWD}_i,\hspace{5.0pt}\textrm{RWD}_j\right) \end{aligned}$$

(9)

$\textrm{DTW}$ is the Dynamic Time Warping function, an algorithm capable of measuring similarity between time series of varying lengths, calculating the differences between sequences by identifying the optimal alignment between them Salvador and Chan (2007). $\textrm{DTW}(f,A,B)$ measures the distance between two sequences A and B using the function f.

struc2vec framework: generating embeddings in multiple scales

We apply the struc2vec framework (Ribeiro et al. 2017) to generate embeddings from the structural distance between nodes on multiple hops. The struc2vec framework involves constructing multilayer networks (Fig. 1F), generating contexts via random walks (Fig. 1G), and learning embeddings.

To construct multilayer network, we first calculate the structural similarity between all node pairs using the following equations.

$$\begin{aligned} \begin{aligned}&f_{k}(i, j) = & f_{k-1}(i, j) + d_k(i,j),\\&f_{0}(i, j) = & d_0(i,j). \end{aligned} \end{aligned}$$

(10)

Then, we construct a $k^{\textrm{max}}$-layer weighted graph with inter-layer link weights defined as:

$$\begin{aligned} w_k(i, j) = e^{-f_k(i,j)}, \quad k=0,\cdots,k^{\textrm{max}}. \end{aligned}$$

(11)

Connections between the same nodes between layers follow:

$$\begin{aligned}&w(i_k, i_{k+1}) = \log {(\Gamma {k(i)} + e)}, \quad & k=0,\cdots,k^{\textrm{max}}-1, \end{aligned}$$

(12)

$$\begin{aligned}&w(i_k, i_{k-1}) = 1, \quad & k=1,\cdots,k^{\textrm{max}}, \end{aligned}$$

(13)

where $\Gamma {k(i)}$ counts how often node i’s link weights exceed the layer average.

Random walks on the multilayer graph generate context sequences containing structurally similar nodes. Intra-layer transition probabilities are:

$$\begin{aligned} p_k(i,j)=q\frac{e^{-f_k(i,j)}}{\sum _{t\in {V}, t\ne i}{e^{-f_k(i,t)}}}, \end{aligned}$$

(14)

with inter-layer transitions governed by:

$$\begin{aligned}&p_k(i_k, i_{k+1}) = \frac{w(i_k, i_{k+1})}{w(i_k, i_{k+1}) + w(i_k, i_{k-1})}, \end{aligned}$$

(15)

$$\begin{aligned}&p_k(i_k, i_{k-1}) = 1 - p_k(i_k, i_{k+1}). \end{aligned}$$

(16)

Finally, Skip-Gram (Mikolov et al. 2013) learns node embeddings from context sequences, aligning with its distributional hypothesis that structurally similar nodes appear in analogous contexts.

Experiments and results

In this section, we present a systematic comparison between SDW2vec and existing methods. In Sect. Visualization of node structure in toy networks we employ four small-scale toy networks to visually demonstrate the structural embedding capabilities of our method. In Sect. Reconstruction of networks in real networks, we conduct validation using real-world networks spanning diverse domains. Through two network reconstruction tasks, we quantitatively illustrate that the embeddings learned by our method inherently preserve structural information.

Visualization of node structure in toy networks

Fig. 2

Visualization results of node embedding representations. The figure displays the node embedding representations learned by SDW2vec and other comparison methods for various toy networks. A1–D1 Visualizations of the four toy networks: star, mesh, ring, and path networks. Node colors indicate structurally equivalent nodes, considering link signs, directions, and weights. Link colors represent link signs, and link thickness corresponds to link weights. A2–D2 Silhouette scores for different methods on the particular network. A higher Silhouette score indicates better clustering of structurally equivalent nodes. A3–D10 Node embeddings for four networks produced by SDW2vec, struc2vec, GraphWave, DeepWalk, walklets, app, role2vec, and xNetMF, respectively. In each scatter plot, ideally, points of the same color (representing structural equivalence) should be clustered together

Dataset

To intuitively demonstrate the proposed method’s ability to learn nodes’ structural embedding representations, we conducted an experiment to verify the interpretability of the embedding representations. As shown in Figs. 2A1–D1, we focused on weighted signed directed toy networks based on network topology.

Figure 2A1’s star network features a central node 0 with 16 other nodes connected to this central node in a star-like structure. Figure 2B1’s mesh is a complete network consisting of 8 nodes. Figure 2C1’s ring is a circular network where each node connects to two adjacent nodes. Figure 2D1’s path network has four paths connected to nodes 4 or 5.

Some links are negative or unidirectional. Link colors represent link signs, and link thickness corresponds to the link weights indicated by link labels. Node colors indicate structurally equivalent nodes, considering link signs, directions, and weights.

Comparison methods

As comparison methods, we used structure-based approaches struc2vec (Ribeiro et al. 2022), GraphWave (Donnat et al. 2018), role2vec (Ahmed et al. 2019) and xNetMF (Heimann et al. 2018), proximity-based methods DeepWalk (Perozzi et al. 2014) and walklets (Perozzi et al. 2017), and app (Zhou et al. 2017).

struc2vec cannot handle link signs, directions, and weights, so it uses an unsigned, undirected binary network as input. GraphWave does not support link signs and weights, so it uses a network retaining only directional information.

Experimental setup

SDW2vec hyperparameters were set as follows: 100 walks per node, walk length of 80, window size of 5, maximum layers of 5, and output dimension of 2. For the discretization function of $\textrm{rwd}$ in Eq. 2, we used equally spaced bins with a maximum of 10 bins, configured for directed and signed networks.

To ensure a fair and reproducible comparison, hyperparameters for all methods were aligned where possible. The specific settings for the comparison methods are detailed in Appendix E.

Results

The learned node embedding representations from each method were visualized in two-dimensional scatter plots, as shown in Fig. 2. Since node colors represent structural equivalence, it is desirable for points of the same color to be clustered together.

In the star network (Fig. 2A3), SDW2vec clearly forms color-based clusters, positioning structurally equivalent nodes close to each other in the embedding space. In contrast, comparison methods (Figs. 2A4 to A10) show mixed-color clusters, poorly reflecting structural equivalence.

For the mesh network (Figs. 2B3 to B10), all methods struggled to capture the network structure. This is likely due to the dense clique structure, where small differences are obscured by overall homogeneity. GraphWave (Fig. 2B5) performed relatively better but, being limited to directional information, positioned nodes 1 and 3 in the same location as nodes 5 and 7.

In the ring network (Fig. 2C3) and path network (Fig. 2D3), SDW2vec forms color-separated clusters, whereas comparison methods show mixed colors, failing to reflect structural features.

Overall, the proposed SDW2vec method effectively achieved color-based cluster formation in most networks, appropriately reflecting nodes’ structural equivalence in the embedding representation. While some comparison methods demonstrated moderate performance on specific networks, they generally failed to capture network structures effectively. xNetMF performed well on the ring and path networks, but poorly on the star and mesh networks.

This performance difference stems from SDW2vec’s ability to extract nodes’ structural features from the perspectives of link signs, directions, and weights. In contrast, comparison methods insufficiently utilize sign and weight information, and differences in learning objectives likely contribute to their suboptimal results.

We also carried out an experiment to demonstrate the impact of maximum hop $k_max$ on embedding quality. See Appendix A for details.

Reconstruction of networks in real networks

To verify whether the embeddings appropriately preserve link weight information, we conducted a network reconstruction experiment using real-world datasets. Specifically, we focused on predicting link weights and node strengths, evaluating the embeddings’ ability to reconstruct the original network structure. The embeddings were derived from the original network structure, with link and node target labels also derived from the same structure.

Datasets

The real-networks employed in this experiment span biological, social, and transportation systems. They are moreno_kangaroo¹ (Grant 1973), moreno_lesmis² (Knuth 1993), moreno_train³ (Hayes 2006), moreno_beach⁴ (Freeman et al. 1998), moreno_rhesus⁵ (Sade 1972), moreno_sampson⁶ (Breiger et al. 1975), moreno_sheep⁷ (Hass 1991), ucidata-gama⁸ (Read 1954), advogato⁹ (Massa et al. 2009), opsahl-usairport¹⁰ (Opsahl 2011), socsign-bitcoinalpha¹¹ (Kumar et al. 2016); Kunegis 2013). Appendix D provides the statistics for the datasets and the execution time of the proposed method.

Comparison methods and settings

Comparison methods and their hyperparameters remained the same as in the previous experiment. For the proposed method, we set the maximum layer number to 3 and the embedding representation dimension to 16, a result of balancing network scale and computational cost.

Link weight prediction

We first obtained 16-dimensional node embeddings from each method, concatenating source and target node embeddings to create a 32-dimensional link embedding.

Using link embeddings as explanatory variables and link weights as labels, we randomly split links into 80% test data and 20% validation data, trained a Ridge regression model (Pedregosa et al. 2011) using test data, and predicted labels on validation data. Ridge regression was chosen to eliminate machine learning model influences and focus solely on embedding quality. Root Mean Square Error (RMSE) was used as the performance metric, with lower RMSE indicating higher accuracy. The experiment was repeated 100 times with different data splits, and the average results were reported.

Table 1 Results of link-weight prediction on real networks. s2v, wl, mf, dw, r2v, and gw represent struc2vec, walklets, xNetMF, DeepWalk, role2vec, and GraphWave, respectively

Link weight prediction results

The results are presented in Table 1. SDW2vec outperformed other methods in 7 out of 11 datasets, demonstrating the highest performance. This indicates that SDW2vec embeddings effectively preserve link weight information. In contrast, DeepWalk, struc2vec, and xNetMF achieved the best performance in 2, 1, and 1 datasets, respectively. Note that xNetMF and role2vec failed to generate embeddings for two datasets.

The lower performance of the proposed method in some datasets can be attributed to potentially non-optimal weight discretization settings. For instance, in the opsahl-usairport network, discretizing into 10 bins likely resulted in significant information loss, given the 9,968 unique weight values. In the ucidata-gama network, with weights limited to −1 and +1, the network is essentially a signed network without weights, which falls outside the designed scope of the proposed method.

Node strength prediction

We conducted a network reconstruction experiment by predicting node strengths. Node strength is defined as the sum of weights of links connected to a node, namely, $s_i^c = \sum _{j\in N(i)}w_{ij}^c$. We predicted strengths for each channel.

We used 16-dimensional node embeddings from each method as explanatory variables and the channel-wise strengths as labels, randomly split nodes into 80% test data and 20% validation data. After trained a multi-label Ridge regression model using test data, we predicted labels on validation data. Performance was measured by RMSE score, with lower RMSE indicating higher accuracy. The experiment was repeated 100 times with different data splits, and average results were reported.

Node strength prediction results

Table 2 Results of node-strength prediction on real networks. s2v, wl, mf, dw, r2v, and gw represent struc2vec, walklets, xNetMF, DeepWalk, role2vec, and GraphWave, respectively

The results are presented in Table 2. SDW2vec outperformed other methods in 6 out of 11 datasets, demonstrating the highest performance. This suggests that SDW2vec embeddings effectively capture node strength information. Struc2vec and DeepWalk achieved the best RMSE in two networks each. xNetMF achieved the best RMSE in one network, but failed to generate proper embedding in two networks. The inferior performance in some networks is similarly attributed to weight discretization challenges, consistent with the link weight prediction results.

Case study: detecting important subgraphs via structural embeddings

As an example of a downstream task, we conducted an experiment to detect important subgraphs using structural embeddings. The results demonstrate both the feasibility and superiority of the proposed method. Detailed information is provided in Appendix B.

Conclusion

In this research, we proposed a learning method for embedding representations that capture structural information in weighted networks. We introduced weighted degrees and weight probability distributions that account for structural attributes such as link signs, directions, and weights, and defined distance functions to measure their similarities. Through experimental validation, we demonstrated the method’s superior interpretability and structural reconstruction capabilities.

Future research directions include (1) investigating practical applications of structural information across various real-world domains, extending the method’s utility beyond network analysis, (2) developing strategies to reduce the computational complexity of the proposed method, potentially through algorithmic optimization or approximation techniques, (3) exploring adaptive embedding learning approaches that can dynamically adjust representation strategies based on specific downstream tasks and network characteristics.