ffstruc2vec: Flat, Flexible, and Scalable Learning of Node Representations from Structural Identities

Featured Application

The proposed framework targets real-world network analysis tasks in which node roles are defined by structural patterns. Typical applications include fraud detection in financial transaction networks, traffic classification, and role discovery in large-scale social or biological graphs, where scalability and interpretability are critical.

Abstract

Node embedding refers to techniques that generate low-dimensional vector representations of nodes in a graph while preserving specific node properties and is widely used in applied domains such as fraud detection and social network analysis. A key challenge is the development of scalable methods that can capture structural characteristics relevant to diverse downstream application tasks. While most existing approaches focus on preserving node proximity, methods that aim to preserve structural properties often lack the flexibility required to represent different types of structural patterns. In this work, we introduce ffstruc2vec, a scalable deep learning framework for learning node embeddings that preserve structural identities, designed for real-world network analysis tasks. The proposed approach employs a flat and efficient architecture that enables flexible modeling of a wide range of structural patterns and facilitates adaptation to different downstream tasks. The experimental results across unsupervised and supervised settings demonstrate that ffstruc2vec achieves competitive and often superior performance compared to existing structure-preserving node embedding methods. In addition, the framework enhances interpretability by quantifying the influence of individual structural patterns on task outcomes, supporting the interpretation of the learned representations. These results indicate that ffstruc2vec offers a flexible and scalable solution for structure-preserving node embedding with practical applicability.

1. Introduction

Node embedding is the process of generating low-dimensional vector representations of nodes in a graph, preserving task-relevant properties of nodes, including but not limited to structure, proximity, or attributes. These embeddings can be leveraged in various downstream tasks, including node classification, link prediction, clustering, exploratory data analysis, and network visualization. The method has found broad application across diverse domains, such as fraud detection in financial networks [1], friendship recommendation and bot detection in social networks [2,3], knowledge discovery in knowledge graphs [4,5], analysis of biological networks [6,7], and fake review detection on online platforms [8].

Despite the progress in node embedding methods, a significant limitation persists: existing approaches often lack the flexibility to adapt to diverse and complex structural patterns required by specific downstream tasks. For instance, while methods like struc2vec capture structural identities, they rely on rigid multilayer graphs that cannot be easily tailored to task-specific structural patterns, such as cyclic transaction chains in fraud detection or bridge roles in social networks. This architectural rigidity limits their applicability in domains where interpretability and adaptability are critical. To address this gap, we propose ffstruc2vec, a flexible framework designed to (1) encode a wide range of structural patterns in a scalable manner, (2) allow task-specific adaptation via supervised weight optimization, and (3) provide interpretable insights into relevant structural features.

This limitation is particularly pronounced when considering the diversity of structural patterns required across different application domains. A key challenge in node embedding is developing a scalable method for preserving the structural properties of nodes suitable for the required structural patterns of a downstream application task. The type of structural patterns in which a node is embedded within the graph can vary depending on the role or function of the node in a specific application task. For instance, fraudulent activities such as money laundering can be embedded in particular money flow patterns among illicit entities, resulting in characteristic structural patterns within the financial transaction network, such as suspicious cyclic transaction chains [9]. These structural patterns differ significantly from those observed in social networks, where specific roles such as bridge and core nodes define the network’s connectivity and influence [10]. As node embedding methods cannot preserve all types of structural patterns simultaneously, they must align with the requirements of a specific application task when defining types of structural identities.

ffstruc2vec is a flexible framework capable of integrating diverse types of structural patterns, including complex ones. If specific structural patterns, such as suspicious cyclic transaction chains in fraud detection, are known to be relevant, domain-specific knowledge can be incorporated manually. At the same time, ffstruc2vec can automatically adapt to task-specific requirements by optimizing corresponding weights in a supervised manner. The optimized weights provide insights into the relevance of specific structural patterns for a given application. The resulting interpretability is particularly crucial in highly regulated domains such as fraud detection. To the best of our knowledge, ffstruc2vec is among the first node embedding frameworks to combine this level of flexibility, scalability, and structural interpretability.

A detailed overview of node embedding frameworks, their limitations, and relevant references can be found in Section 2. Most node embedding frameworks primarily focus on preserving the proximity of nodes. Frameworks that instead aim to capture structural identities often struggle to adapt effectively to the specific types of structural identities required by downstream application tasks. For instance, struc2vec, which employs a multilayer graph to encode structural similarities, is limited in its ability to capture diverse types of structural identities. The ffstruc2vec approach addresses this issue more effectively by implementing a flexible and flattened similarity graph encoding structural similarities of the nodes. This approach involves assessing structural similarity between nodes by analyzing their respective structural properties and those of their surrounding neighborhoods. This evaluation incorporates various structural properties, including centrality measures, clustering coefficients, attached graphlets, and anonymous walk-based characteristics, to accurately capture and represent structural patterns for a specific downstream task. In specific tasks, such as fraud detection, the required structural patterns can be highly complex. A well-balanced combination of multiple indicators is essential, not only for the focal node but also for the nodes in its k-hop neighborhood. The edges of the similarity graph in ffstruc2vec are assigned weights derived from the similarity measures of the node pairs. They are utilized in random walks on the similarity graph to generate sequences of nodes. These sequences are then fed into the word2vec algorithm [11] to learn embedded node representation vectors. A detailed description of the ffstruc2vec framework can be found in Section 4.

Beyond graph-based embedding frameworks, various neural and neurosymbolic learning approaches have been developed to model complex functional or symbolic relationships, including bilinear neural networks, fractional-order models, and neurosymbolic reasoning systems (see, e.g., [12]). While powerful in domains such as equation solving, symbolic inference, or multimodal reasoning, these methods are not primarily designed for learning reusable, task-adaptive structural representations of nodes in large-scale graphs. In contrast, ffstruc2vec focuses on structure-preserving node embeddings that emphasize interpretability and scalability across a wide range of graph-based downstream tasks.

The name ffstruc2vec reflects the framework’s central design principle: a flat similarity graph that flexibly captures structural identities. This architecture enables effective adaptation to diverse downstream tasks by optimizing the weights of graph indicators across multiple k-hop neighborhoods. These optimized weights not only guide the embedding process but also offer interpretability by revealing task-relevant structural patterns. Beyond its flexibility and interpretability, ffstruc2vec is designed for scalability, making it well-suited for large-scale networks. Its optimized flat architecture and flexible alignment to task-specific structural requirements allow ffstruc2vec to capture a broader range of structural identities than alternative methods such as struc2vec [13]. A direct comparison to struc2vec is presented in Section 6, while a detailed discussion of the general key contributions of ffstruc2vec is provided in Section 5.

The effectiveness of ffstruc2vec is demonstrated in multiple downstream application tasks:

• Unsupervised applications (Section 7.1 and Section 7.2) showcase its superior performance.
• Supervised tasks (Section 7.3) highlight its significant improvements over other node embedding methods.

In summary, the main contributions of this paper are as follows:

• We propose a flexible and flat node embedding framework that generates latent representations for nodes. This framework effectively aligns with various types of structural patterns in a graph, making it suitable for a wide range of downstream application tasks (see Section 5.1).
• In terms of interpretability, the alignment process of ffstruc2vec to a downstream application task provides insight into the graph structures of application tasks and their impact, meaning, and relevance for the examined application scenarios (see Section 5.2).
• To maintain scalability for large graphs, such as social networks with billions of nodes and edges, the time complexity of ffstruc2vec is $\mathcal{O}\left(\max \right(\left|E\right|,\left|V\right|·\log \left|V\right|\left)\right)$ for the extraction of certain structural identities, as detailed in Section 5.3.
• The ffstruc2vec framework addresses weaknesses in existing node embedding frameworks, such as struc2vec, as detailed in Section 6.
• The ffstruc2vec framework significantly outperforms other state-of-the-art node embedding frameworks in several practical downstream application tasks (see Section 7).
• Beyond structural patterns, ffstruc2vec’s modular design allows for the integration of node proximity properties and node features, enabling alignment with the specific requirements of downstream tasks.

Together, these contributions establish ffstruc2vec as a flexible, interpretable, and scalable framework for structure-preserving node embedding across diverse application domains, demonstrating consistent effectiveness across multiple unsupervised and supervised downstream tasks.

The remainder of this paper is organized as follows. Section 2 reviews related work on node embedding methods with a focus on structure-preserving approaches. Section 4 introduces the ffstruc2vec framework and details its core components. The experimental evaluation and benchmarking are presented in Section 7. Finally, Section 8 concludes the paper and discusses limitations and directions for future work.

The Supplementary Material contains additional methodological and technical details, including the graph indicators (Section S1), the integration of proximity measures and node features (Section S2), comparison functions (Section S3), hyperparameters (Section S4), the complexity analysis (Section S5), and an extended discussion of the advantages of ffstruc2vec over struc2vec (Section S6).

Figure 1 illustrates the application of ffstruc2vec to the mirrored Zachary’s Karate Club network. The upper image depicts the network, while the lower image visualizes the generated embedded vectors in a two-dimensional space. Nodes with distinct structural properties, such as central and peripheral nodes, are highlighted in color. It is evident that the ffstruc2vec approach effectively separates the embedding vectors of these nodes from the others, demonstrating its ability to distinguish structural roles.

2. Related Work

Advancements in representational learning for natural language processing have enabled new ways for feature learning of discrete objects, such as words. The Skip-gram model, introduced by Mikolov et al. [11], learns continuous word feature representations by optimizing a neighborhood-preserving likelihood objective. Inspired by this model, Perozzi et al. [14] proposed DeepWalk as an analogy for networks by treating a network as a “document”. In the same way that a document is an ordered sequence of words, sequences of nodes can be sampled from a network and transformed into an ordered sequence of nodes. Random walks generate these sequences, and language models then learn node representations by treating the sequences as sentences. Building on this, Grover and Leskovec [15] introduced the node2vec approach, which offers a more flexible biased second-order random walk model, while Ribeiro et al. [13] proposed struc2vec, focusing on global structural identities. However, struc2vec has several limitations, which are effectively addressed by ffstruc2vec (see Section 6).

Beyond random walks, other node embedding frameworks have been developed to learn low-dimensional representations of nodes in graphs. Most of these frameworks focus on preserving node proximity properties within the resulting embeddings [14,15,16,17,18,19,20,21]. However, there has been a growing interest in approaches that focus on structural patterns of nodes, independent of their proximity to others. Consequently, diverse methodologies have emerged.

An example of such an approach is struc2gauss, introduced by Pei et al. [22], which extends structure-based embeddings by representing nodes as Gaussian distributions instead of fixed vectors, capturing uncertainty and hierarchical similarities within structural roles. While struc2gauss models structural uncertainty probabilistically, ffstruc2vec takes a different approach by employing a flat similarity graph structure, which provides high flexibility in adapting to specific downstream application tasks and thereby offers interpretability while maintaining scalability (see Section 5).

Additional methods for generating node representations, often integrated into broader embedding frameworks, include self-attention-based approaches [23], attribute-aware sampling methods [24], kernel-based methods [25], recursive methods [26], matrix multiplication methods [27,28,29], spectral graph wavelet approaches [30], neighborhood-based embedding approaches focusing on local structural properties [31], contrastive learning methods, including Graph Contrastive Learning approaches [32,33,34,35], and methods targeting specific structural properties, such as role-based embeddings [36], anonymous walks [37,38,39], graphlets [40,41,42], or self-defined ripple diffusion patterns [43]. For a broader and more in-depth review of node embedding techniques and their applications, we refer the reader to existing surveys [44,45,46].

Each of these methods has its limitations. For example, matrix multiplication-based frameworks tend to be computationally intensive, struggle with flexibility regarding diverse structural patterns, and rely on assumptions about the relationship between the underlying network structure and the downstream application task. The diffusion wavelet approach in GraphWave produces embeddings that are less intuitive in terms of direct structural features and can be costly to compute at scale. Some methods explicitly assign role distributions or structural types to nodes [27,36], which can lead to reduced granularity and limit the ability to reflect nuanced structural differences in the resulting embeddings. Deep learning-based approaches, particularly those relying on Graph Neural Networks (GNNs), often face challenges with interpretability and scalability, particularly in application settings that require transparent and reusable representations. While some GNN variants attempt to incorporate structural features explicitly—such as Gralsp [47]—they require extensive labeled data and typically remain tightly coupled to specific downstream tasks, which also limits their reusability. In contrast, Graph Contrastive Learning aims to produce task-agnostic representations in a self-supervised fashion, but relies on computationally demanding data augmentation or multi-view training pipelines, which further limit its scalability and adaptability in application-specific settings.

In contrast, ffstruc2vec addresses these limitations by providing task-adaptive and transparent embeddings within a design that remains efficient even on large-scale graphs. To the best of our knowledge, ffstruc2vec is among the first frameworks to combine downstream task adaptability, interpretability, and scalability (see Section 5) within a unified design.

To provide a concise overview of representative node embedding approaches and their commonly discussed challenges in the context of structural role modeling,

Table 1. Summary of representative node embedding methods and commonly discussed challenges with respect to structural role modeling.

Method Category	Representative Approach	Common Challenges in Structural Embedding Contexts
Proximity-based embeddings	node2vec [15]	Primarily focus on local connectivity and neighborhood proximity; not explicitly designed to capture structural roles independent of node proximity.
Structural identity (multilayer graph)	struc2vec [13]	Relies on a rigid multilayer architecture, which can limit flexibility and adaptation to task-specific structural patterns, and may affect scalability.
Structural identity (probabilistic)	struc2gauss [22]	Models uncertainty in structural similarity, but provides limited mechanisms for task-specific adaptation and direct interpretability of structural feature contributions.
Contrastive learning approaches	DGI [32]	Depend on data augmentation or multi-view training pipelines, which can increase computational cost and limit interpretability and scalability in practice.

Note: This table provides a high-level categorization of representative approaches and summarizes commonly discussed challenges in the literature. It is not intended as an exhaustive or quantitative comparison.

categorizes related methods based on their primary focus.

3. Preliminaries and Definitions

This section defines the fundamental definitions and preliminary concepts required in this paper.

Definition 1

(Graph). A graph, denoted as $G=(V,E)$, is a mathematical construct comprising a set of vertices $V=\{v_1,\dots ,v_n\}$ and a set of edges $E\subseteq \left\{\{u,v\}\mid u,v\in V,u\ne v\right\}$ in the case of an undirected graph, meaning each edge is an unordered pair of distinct nodes. In contrast, in a directed graph, the edge set is defined as $E\subseteq \left\{(u,v)\mid u,v\in V,u\ne v\right\}$, where edges are ordered pairs indicating a directed connection from node u to node v.

In this work, we exclusively focus on undirected graphs, as defined above. However, the fundamental concepts introduced in this paper can be easily adapted and extended to directed graphs.

Definition 2

(Node Embedding). A node embedding of a graph $G=(V,E)$ with n nodes is defined as a mapping function f as follows:

$$f:v_i\mapsto y_i\in {\mathbb{R}}^d,\forall i\in \{1,\dots ,n\},$$

where $d\ll \left|V\right|$, and the function f preserves certain properties defined on the graph G.

Definition 3

(k-hop Neighborhood). The k-hop neighborhood of a node x in a graph is the set of all nodes that are exactly k hops away from x. Formally, it is defined as

$$N_k\left(x\right)=\{y\in V\mid \mathit{distance}(x,y)=k\},$$

where V represents the set of all nodes in the graph, and $\mathit{distance}(x,y)$ represents the length of the shortest path between nodes x and y.

For an intuitive understanding, Figure 2 visually illustrates the k-hop neighborhoods of two nodes, x and y, using color coding. Specifically, the 1-hop neighborhood is highlighted in green, the 2-hop neighborhood in blue, and the 3-hop neighborhood in gray. As an illustrative example, the 2-hop neighborhoods of nodes x and y are given by

$$N_2\left(x\right)=\{e,d\},N_2\left(y\right)=\{i,j,k\}.$$

Definition 4

(Node Degree). In accordance with Definition 1, the degree of a node v in a graph $G=(V,E)$ is defined as

$$d_v=\left|\{u\mid \{v,u\}\in E\}\right|.$$

Definition 5

(Isomorphic Graphs). Two graphs $G=(V,E)$ and $G^{\prime }=(V^{\prime },E^{\prime })$ are isomorphic if there exists a bijective mapping $g:V\to V^{\prime }$ (called the isomorphism function) such that for any two nodes $v_i,v_j\in V$, the following condition holds:

$$(v_i,v_j)\in E\mathit{iff}(g\left(v_i\right),g\left(v_j\right))\in E^{\prime }.$$

Definition 6

(Graphlets and Orbits). Graphlets are defined as small, connected, and non-isomorphic induced subgraphs (as specified in Definition 5) of a graph, consisting of at least two nodes [48]. All graphlets with 2, 3, 4, or 5 nodes and their automorphism orbits are illustrated in Figure 3. “orbit” refers to the different possible node positions within the graphlets. Symmetrical nodes are assigned the same orbit number, with 73 orbits of 30 graphlets.

Definition 7

(Anonymous Walk). Let $s=(u_1,u_2,\dots ,u_k)$ be an ordered list of elements $u_i\in V$. We define the positional function $pos$$:(s,u_i)\mapsto q$, which returns a list $q=(p_1,p_2,\dots ,p_l)$ of all positions $p_j\in \mathbb{N}$, where $u_i$ occurs in the list s.

If $w=(v_1,v_2,\dots ,v_k)$ is a random walk, then its corresponding anonymous walk is the sequence of integers $a=(f\left(v_1\right),f\left(v_2\right),\dots ,f\left(v_k\right))$, where the function f is defined as

$$f\left(v_i\right)=\underset{p_j\in pos(w,v_i)}{\min }pos(w,v_i).$$

4. The ffstruc2vec Framework

The ffstruc2vec framework learns structural node representations by capturing similarities between nodes based on their structural roles within a network. It computes structural similarity scores between node pairs using a diverse set of structural properties, including those of individual nodes and their k-hop neighborhoods. The framework provides a flexible mechanism for integrating various comparison functions and adaptive weightings (see Section 4.1), allowing for an effective and interpretable encoding of structural identities. Based on these similarities, a similarity graph is constructed, where edge weights quantify the computed relationships (see Section 4.2). To extract meaningful patterns from this graph, biased random walks are performed, with transition probabilities influenced by the similarity-based edge weights (see Section 4.3). The resulting node sequences are then used in the Skip-gram model to learn dense vector representations of nodes (see Section 4.4). Finally, a task-aware optimization step refines the embeddings to improve performance in specific downstream applications (see Section 4.5).

A formalized overview of the complete ffstruc2vec pipeline is provided in Algorithm 1. Details regarding the specific graph indicators, comparison functions, and additional hyperparameters utilized within this pipeline are provided in Supplementary Materials Sections S1–S4.

Algorithm 1 ffstruc2vec: Learning Pipeline

Input: Graph $G(V,E)$, maximum neighborhood depth $k^{*}$ (defining the maximum k-hop neighborhood), l graph indicators ${\left\{I_i\right\}}_{i=1}^l$, l comparison functions ${\left\{f_i\right\}}_{i=1}^l$, p: number of random walks per node, $L_w$: length of each random walk, d: embedding dimension. Output: Node representation vectors ${\left\{r_x\right\}}_{x\in V}$ in ${\mathbb{R}}^d$.   1: for all $x\in V$  do   2:    Compute graph indicators ${\left\{I_i\left(x\right)\right\}}_{i=1}^l$   3: end for   4: Initialize weights $\left\{w_{ik}\right\}$ for all $(i,k)\in \{1,\dots ,l\}\times \{0,\dots ,k^{*}\}$   5: for all $(x,y)\in V\times V$  do   6:    $sim(x,y)\leftarrow$computeStructuralSimilarity$(x,y,\left\{I_i\right\},\left\{f_i\right\},\left\{w_{ik}\right\},k^{*})$  // see Algorithm 2   7: end for   8: $G^{\prime }\leftarrow$similarityGraph$(V,sim)$                 // see Algorithm 3   9: for all $x\in V$  do 10:    $context\left(x\right)\leftarrow$performRandomWalks$(G^{\prime },x,p,L_w)$    // see Algorithm 4 11: end for 12: $r\leftarrow$word2vec$\left({\bigcup }_{x\in V} context\left(x\right),d\right)$              // see Section 4.4 13: Task-aware optimization: adjust $\left\{w_{ik}\right\}$ (if applicable)    // see Section 4.5

4.1. Measuring Structural Similarity

The ffstruc2vec framework begins by evaluating the structural similarity between pairs of nodes in a graph, leveraging graph indicators as metrics to quantify the structural properties of individual nodes. Notably, the similarity between a node x and a node y is not solely determined by their respective structural properties but also accounts for the structural characteristics of the nodes within their k-hop neighborhoods, $N_k\left(x\right)$ and $N_k\left(y\right)$ (see Definition 3).

As an initial step, the structural similarity of the k-hop neighborhoods of x and y, denoted as $si{m}_k(x,y)$, is computed by comparing the graph indicator values of the nodes in $N_k\left(x\right)$ with those of the nodes in $N_k\left(y\right)$. Let $I=\{I_1,I_2,\dots ,I_l\}$ be a set of graph indicators $I_i:V\to W\left(I_i\right)$, where each indicator describes a specific structural property of a node, and $W\left(I_i\right)$ denotes the value range of the indicator. Examples of such graph indicators are provided in Supplementary Materials Section S1.

To quantify the similarity, let

$$f_i:\mathcal{P}\left(W\left(I_i\right)\right)\times \mathcal{P}\left(W\left(I_i\right)\right)\to \mathbb{R},i\in \{1,\dots ,l\},$$

denote a set of functions that compare the values of the graph indicators between two sets of nodes, where $\mathcal{P}\left(W\left(I_i\right)\right)$ denotes the power set of $W\left(I_i\right)$, i.e., the set of all subsets of the value range of the graph indicator $I_i$. Specific examples of these comparison functions are detailed in Supplementary Materials Section S3. The structural similarity $si{m}_k(x,y)$ is then computed as defined in Equation (1).

$$si{m}_k(x,y)=\sum _{i=1}^l{w}_{ik}·f_i\left(\bigcup _{v\in N_k\left(x\right)}\left\{I_i\left(v\right)\right\},\bigcup _{v\in N_k\left(y\right)}\left\{I_i\left(v\right)\right\}\right),$$

(1)

where $w_{ik}\in \mathbb{R}$ are weighting factors applied to the values of graph indicators $I_i$ for the k-hop neighborhoods.

In the subsequent step of the ffstruc2vec framework, the overall structural similarity $sim(x,y)$ between nodes x and y is computed as the sum of the structural similarities between their respective k-hop neighborhoods, denoted as $si{m}_k(x,y)$, for all $k\le k^{*}$. Here, $k^{*}$ is a predefined constant that determines the maximum neighborhood depth considered when describing the structural properties of a node’s neighborhood (see Equation (2)).

$$sim(x,y)=\sum _{k=0}^{k^{*}}si{m}_k(x,y).$$

(2)

By substituting Equation (1) into Equation (2), we obtain the following expanded expression:

$$sim(x,y)=\sum _{k=0}^{k^{*}}\sum _{i=1}^l{w}_{ik}·f_i\left(\bigcup _{v\in N_k\left(x\right)}\left\{I_i\left(v\right)\right\},\bigcup _{v\in N_k\left(y\right)}\left\{I_i\left(v\right)\right\}\right)$$

(3)

For notational convenience, we extend the function $I_i$ to sets by defining

$$I_i\left(N_k\left(x\right)\right):=\bigcup _{v\in N_k\left(x\right)}\left\{I_i\left(v\right)\right\}.$$

(4)

Using Equation (4), we can rewrite Equation (3) in a more compact form as follows:

$$sim(x,y)=\sum _{k=0}^{k^{*}}\sum _{i=1}^l{w}_{ik}·f_i(I_i\left(N_k\left(x\right)\right),I_i\left(N_k\left(y\right)\right)).$$

(5)

The weighting of graph indicators in different k-hop neighborhoods using the weighting factors $w_{ik}$ in Equation (5) is a key aspect of ffstruc2vec’s flexibility (see Section 4.5 and Section 5.1) in extracting diverse types of structural identities tailored to various downstream application tasks.

The computation of the structural similarity defined above is summarized in Algorithm 2.

Algorithm 2 Compute Structural Similarity

Input: Nodes $x,y$, graph indicators ${\left\{I_i\right\}}_{i=1}^l$, comparison functions ${\left\{f_i\right\}}_{i=1}^l$, weights $\left\{w_{ik}\right\}$, maximum neighborhood depth $k^{*}$ Output: Structural similarity score $sim(x,y)$   1: $sim(x,y)\leftarrow 0$   2: for $k=0$ to $k^{*}$ do   3:    for $i=1$ to l do   4:       Compute $f_i(I_i\left(N_k\left(x\right)\right),I_i\left(N_k\left(y\right)\right))$   5:       $sim(x,y)\leftarrow sim(x,y)+w_{ik}·f_i(·)$   6:    end for   7: end for   8: return $sim(x,y)$

Remark 1.

When employing a large number of graph indicators $\left(l\right)$ and multiple k-hop neighborhoods $(k^{*}+1)$, the search for $l·(k^{*}+1)$ weighting factors suitable for a specific downstream application task—e.g., through heuristic optimization—can be computationally intensive. The following strategies help mitigate the computational cost of determining suitable weighting factors.

• In practical applications, a choice of $k^{*}\le 4$ is reasonable for most downstream application tasks. This is supported by empirical research on the Facebook network of active users, which found an average shortest path length of 4.74 between two nodes [50].
• To reduce the number of flexible weighting factors from $l·(k^{*}+1)$ to $l+k^{*}+1$, the weighting factors for graph indicators and k-hop neighborhoods can be integrated independently, as shown in Equation (6). While this modification improves the computational efficiency of ffstruc2vec, it comes at the expense of a slight reduction in expressive power.

  $$sim(x,y)=\sum _{k=0}^{k^{*}}{w}_k^{\mathit{hop}}\sum _{i=1}^l{w}_i^{\mathit{ind}}·f_i(I_i\left(N_k\left(x\right)\right),I_i\left(N_k\left(y\right)\right)).$$

  (6)
• To determine $l·(k^{*}+1)$ suitable weighting factors for large values of l and $k^{*}$, a smaller graph subset can be used during the optimization phase before applying ffstruc2vec to the full graph with the optimized weighting factors. This approach enhances computational efficiency during optimization but increases the risk of selecting weighting factors that may be less optimal for specific downstream application tasks.

4.2. Constructing the Similarity Graph

As defined in Definition 1, the original graph is denoted as $G=(V,E)$. A fully connected weighted graph $G^{\prime }=(V^{\prime },E^{\prime })$ is constructed, to encode the structural similarities between all nodes in G. Specifically, the node set remains unchanged, i.e., $V^{\prime }=V$, while the edge weights in $E^{\prime }$ are assigned for $(x,y)\in E^{\prime }$ based on the structural similarity between nodes x and y in the original graph G, quantified by $sim(x,y)$ in Equation (5).

The edge weights are computed by applying a transformation function to $sim(x,y)$, ensuring that structurally similar nodes receive higher weights. The choice of this function in $G^{\prime }$ is designed to be flexible and is treated as a hyperparameter (see Supplementary Materials Section S4). This adaptability allows the weighting function to be customized for the specific requirements of a given downstream application task.

The construction of the similarity graph defined above is summarized in Algorithm 3.

An illustrative example of this process is provided in Figure 4. Nodes in G with identical structural properties are depicted in the same color. In $G^{\prime }$, edges connecting these structurally similar nodes are assigned higher weights, which are visually represented as thicker lines.

Algorithm 3 Similarity Graph Construction

Input: Node set V, similarity scores $sim(x,y)$ Output: Similarity graph $G^{\prime }(V^{\prime },E^{\prime })$   1: $V^{\prime }\leftarrow V$   2: for all $(x,y)\in V\times V$ do   3:    Compute edge weight $w_{xy}$ from $sim(x,y)$   4:    Add edge $(x,y)$ with weight $w_{xy}$ to $E^{\prime }$   5: end for   6: return $G^{\prime }(V^{\prime },E^{\prime })$

4.3. Performing Biased Random Walks

To generate node representation vectors using the similarity graph $G^{\prime }$, we first perform a biased random walk on $G^{\prime }$. During this process, the selection of the next node to visit is determined by the edge weights in $G^{\prime }$, ensuring that transitions favor structurally similar nodes.

The transition probability from node x to node y, denoted as $P_r(x\to y)$, is computed as

$$P_r(x\to y)={\displaystyle \frac{w_{xy}}{{\sum }_{j=1}^n{w}_{xj}}},$$

(7)

where n represents the total number of nodes in the graph, and $w_{xy}$ denotes the edge weight of the edge connecting nodes x and y in $G^{\prime }$.

Multiple random walks of a specified length are initiated from each node, generating sequences of nodes. The selection of the next node in these walks follows the transition probabilities defined in Equation (7), ensuring that transitions occur based on the edge weights in $G^{\prime }$. Since the edge weights in the fully connected graph $G^{\prime }$ encode the structural similarities between nodes in G (as described in Section 4.2), the random walks naturally tend to position structurally similar nodes in similar contexts within the generated node sequences (as illustrated in Figure 5).

The generation of node contexts via random walks on the similarity graph is summarized in Algorithm 4.

Algorithm 4 Perform Random Walks

Input: Similarity graph $G^{\prime }$, start node x, number of walks p, walk length $L_w$ Output: Set of node sequences $\mathrm{context}\left(x\right)$   1: Initialize empty set $\mathrm{context}\left(x\right)$   2: for $i=1$ to p do   3:    Initialize walk $w\leftarrow \left[x\right]$   4:    for $t=1$ to $L_w-1$ do   5:       Sample the next node y according to $P_r(x\to y)$ in Equation (7)   6:       Append node to w   7:    end for   8:    Add w to $\mathrm{context}\left(x\right)$   9: end for 10: return $\mathrm{context}\left(x\right)$

4.4. Generating Node Representation Vectors

The Skip-gram language model [11] is employed to generate similar representation vectors for nodes that appear in similar contexts within these sequences. Since similar structural identities in G produce similar node contexts in the sequences, the model learns low-dimensional node representation vectors in a continuous vector space, ensuring that structurally similar nodes in G yield similar representations (as illustrated in Figure 6).

More specifically, the Skip-gram model learns a function $\Phi$ that maps nodes to their representation vectors by maximizing the conditional probability:

$$P_r\left(\{v_{i-w},\dots ,v_{i-1},v_{i+1},\dots ,v_{i+w}\}\mid \Phi \left(v_i\right)\right),$$

where the context of node $v_i$ in a sequence is defined as a window of size w centered on the node.

4.5. Task-Aware Optimization of Node Representations

Different downstream application tasks rely on different types of structural identities within a network, as discussed in Section 2 and Section 5.1. ffstruc2vec is highly flexible, allowing for the seamless integration of various graph indicators with corresponding selectable comparison functions (see Supplementary Materials Sections S1–S3). Moreover, it enables the task-specific weighting of these structural properties for each graph indicator i, both for the nodes themselves and for each of their k-hop neighborhoods, using the parameters $w_{ik}$ for all $(i,k)\in \{1,\dots ,l\}\times \{0,\dots ,k^{*}\}$ (see Section 4.1), where $k^{*}$ defines the maximum neighborhood depth under consideration.

These parameters can either be set manually or, if a downstream application task is accompanied by a loss function, optimized accordingly to align with the task-specific objective. A straightforward approach is to apply heuristic methods such as evolutionary strategies or Bayesian optimization techniques—for example, the Tree-structured Parzen Estimator (TPE) [51]. For large datasets with high values of l and $k^{*}$, the measures discussed in Remark 1 can be applied to ensure scalability.

5. Key Contributions and Advantages of ffstruc2vec

5.1. Flexibility in Extracting Diverse Structural Identities

The structural identity of a node can be described through various types of structural patterns. The type of structural patterns relevant to a downstream application task may vary depending on the specific case. To ensure the effective application of node embedding vectors, they must preserve the types of structural patterns relevant to the given task. Therefore, a node embedding framework has to possess the capability to adapt flexibly to the specific requirements of application tasks. Many existing approaches lack this flexibility (see Section 2).

The flexibility of ffstruc2vec is achieved through a modular design centered on a flat similarity graph. The framework allows the weighted integration of diverse properties. This integration includes structural graph indicators, and can be extended to incorporate node proximity measures and node features, all weighted across different layers of a node’s k-hop neighborhood (see Definition 3). This weighting scheme, formalized in Section 4.1, enables the model to adapt its structural focus to meet the specific requirements of a given downstream task. For instance, a task might emphasize the properties of the node itself ($k=0$), while another might prioritize patterns in its extended neighborhood ($k\ge 1$). Examples of graph indicators, comparison functions, and other configurable hyperparameters are provided in Supplementary Materials Sections S1–S4.

Optimized hyperparameters can be determined through various methods. Depending on the requirements of the application task, various evaluation metrics can be employed to assess the effectiveness of the selected hyperparameters and the associated structural patterns. The continuous nature of the weights results in a vast hyperparameter space. Therefore, we optimized the accuracy score for the classification task described in Section 7.3 using the Tree-structured Parzen Estimator (TPE), as introduced by Bergstra et al. [51].

The resulting hyperparameter configurations provide valuable insights into the explanation and interpretation of the structural patterns relevant to the application task, as discussed in Section 5.2. ffstruc2vec supports this level of interpretability through its adaptable framework, which formulates the optimization problem in a linear search space (see Section 4.1).

5.2. Interpretability

The explainability and interpretability of machine learning algorithms [52,53] are becoming increasingly important in many practical applications, especially in highly regulated domains.

By generating structural signatures, ffstruc2vec can provide valuable insights into downstream application tasks. For example, the optimized hyperparameters of the flexible ffstruc2vec framework—such as the weights assigned to graph indicators and k-hop neighborhoods (see Section 5.1)—can reveal typical structural patterns associated with the embedding of specific nodes in the context of the application.

An illustrative example is a classification task for detecting financial fraud in transaction graphs, where edges represent financial interactions between entities. Optimized weights may highlight structural motifs, such as triangular patterns or graphlets within a node’s neighborhood, as indicative of fraudulent behavior. In the case of an air traffic network (see Section 7.3), high centrality or bridge scores for an airport or its neighbors may correspond to high passenger volumes. In contrast, in social networks, the same indicators may suggest different behavioral or relational dynamics, depending on the specific application context [10].

To further improve the interpretability of learned weights, preprocessing steps such as normalization or standardization of graph indicators can be beneficial.

5.3. Scalability

ffstruc2vec is designed to scale efficiently with the number of nodes and edges in the input graph, making it suitable for real-world scenarios such as large-scale social networks with billions of elements. Optimization measures applied to the algorithm result in the following time complexity for the extraction of certain structural identities:

$$\mathcal{O}\left(\max \right(\left|E\right|,\left|V\right|·log\left|V\right|\left)\right).$$

Details on the complexity analysis for the optimized version of ffstruc2vec are provided in Supplementary Materials Section S5.

6. Comparative Analysis of ffstruc2vec and struc2vec

In node embedding, struc2vec is a state-of-the-art framework that employs random walks to preserve nodes’ structural identities. The following points summarize the advantages of ffstruc2vec over struc2vec, with additional discussion provided in Supplementary Materials Section S6.

(a)

Greater Flexibility.

ffstruc2vec offers a high degree of flexibility in extracting various types of structural identities, enabling better alignment with specific requirements of downstream application tasks.

(b)

Interpretability.

The alignment process of ffstruc2vec with downstream application tasks provides valuable insights into graph structures, highlighting their impact, meaning, and relevance.

(c)

Superior Scalability.

ffstruc2vec is more scalable for large graphs, with a time complexity of $\mathcal{O}\left(\max \right(\left|E\right|,\left|V\right|·\log \left|V\right|\left)\right)$ for the extraction of certain structural identities, compared to struc2vec, whose original multilayer construction can become cubic in the number of nodes in the worst case.

(d)

Optimized Flat Similarity Graph.

Unlike struc2vec’s multilayer graph, ffstruc2vec employs a flat structure to generate node embeddings, improving efficiency and performance.

(e)

Fewer Restrictions on Structural Identity Extraction.

struc2vec’s design imposes limitations on extracting certain structural identities for specific tasks, whereas ffstruc2vec provides a more adaptable framework.

(f)

Better Downstream Performance.

ffstruc2vec outperforms struc2vec across supervised and unsupervised downstream tasks, as demonstrated in Section 7.

7. Experimental Evaluation and Benchmarking

In this section, ffstruc2vec demonstrates its ability to extract structural identities by applying two unsupervised tasks, detailed in Section 7.1 and Section 7.2, and a supervised task in Section 7.3. Specifically, visualization, clustering, and outlier detection are used for unsupervised tasks, while node classification is applied to supervised tasks. Additionally, the performance of ffstruc2vec is evaluated by benchmarking it against other node embedding frameworks.

7.1. Zachary’s Karate Club

The Zachary’s Karate Club network, originally introduced by Zachary [54], consists of 34 nodes and 78 edges. Each node represents a club member, while the edges denote interactions between members outside the club. These edges are commonly interpreted as indicators of friendship among members.

In this section, we utilize a network previously used by Ribeiro et al. [13] to compare ffstruc2vec with the node embedding methods struc2vec, node2vec, and DeepWalk. This network comprises two identical copies of Zachary’s Karate Club network, designated as $G_1$ and $G_2$. Each node in $G_1$, denoted as v, has a corresponding mirror node in $G_2$, denoted as u, where u and v share identical structural properties. These properties are expected to be preserved in the node embedding vectors.

To ensure a fair comparison, the two networks were connected by an additional edge between the pair of mirrored nodes, 1 and 37. This modification was originally introduced because DeepWalk and node2vec cannot place nodes from different connected components in the same context. Figure 7 illustrates the mirrored network, with corresponding node pairs highlighted in the same color. Nodes 1 and 34, along with their corresponding mirrored nodes (37 and 42), represent the club instructor, Mr. Hi, and his administrator, John A. The network was constructed following a conflict between the two, which divided the club members into two factions, each centered around either Mr. Hi or John A. Consequently, nodes 1 and 34 occupy prominent central roles as leaders within their respective groups.

The node embedding vectors of the mirrored Karate network, generated by ffstruc2vec, are visualized in two-dimensional space in Figure 8. Additionally, Figure 9 illustrates the node representation vectors produced by the struc2vec method, as presented in Ribeiro et al. [13]. While both methods capture the structural identity of nodes, it is evident that ffstruc2vec extracts additional structural patterns compared to struc2vec.

Specifically, ffstruc2vec clearly separates the node pair (12, 67) from the rest of the nodes, whereas struc2vec places this pair within the primary node group. Similarly, node pair (17, 52) is distinctly separated by ffstruc2vec, whereas struc2vec positions it at the periphery of the primary group. Furthermore, ffstruc2vec distinctly separates the node pairs (25, 44) and (26, 57) from the rest of the network, unlike struc2vec.

A structural analysis of these nodes, identified by ffstruc2vec as structurally outstanding, is provided below for further examination.

• Nodes 12 and 67 possess a unique structural role within Zachary’s Karate Club network, as they are the only nodes with a degree of 1.
• Nodes 17 and 52 possess a unique role as the only outstanding nodes associated with the central club instructor nodes 1 and 37, positioned at the end of a small sub-cluster. This is evident from their assignment to these central nodes while being two hops away from them.
• Nodes 25, 44, 26, and 57 possess a unique role as the only outstanding nodes associated with the central club administrator nodes 34 and 42. This is evident from their assignment to these central nodes while being two hops away from them.

In summary, ffstruc2vec captures a broader range of structural roles than struc2vec, which aligns with its advantages discussed in Section 6.

Furthermore, ffstruc2vec and struc2vec successfully extracted multiple structural properties from the Karate network. Both methods were able to group mirrored node pairs—i.e., nodes of the same color—such that they remain close together in the latent space. Additionally, both methods identified nodes 1 and 34, along with their corresponding mirrored nodes (37 and 42), as a separate cluster in the latent space. These nodes represent the central club instructor and the central club administrator. Moreover, ffstruc2vec and struc2vec identified nodes 2, 3, and 33, along with their mirrored counterparts (38, 39, and 51), as distinct from the rest of the network. These nodes also exhibit distinct structural identities, playing central roles within the network and possessing high node degrees.

Figure 10 presents the top 20 absolute anomaly scores for the nodes obtained by applying an Isolation Forest to the ffstruc2vec representation vectors. A higher score indicates a greater likelihood that a node is an outlier with respect to its structural embedding within the graph. Notably, due to their distinct roles in the mirrored Zachary’s Karate Club network, the nodes identified as structurally outstanding in the structural analysis above exhibit anomaly scores exceeding $0.5$.

Applying a k-means clustering algorithm to the node embedding representations generated by ffstruc2vec to extract four clusters with similar structural properties results in the clusters shown in Figure 11, with each represented by a different color. It is visually evident that the clusters formed from these embeddings correspond to specific roles within the graph.

• White nodes represent ordinary nodes that do not exhibit outstanding structural properties distinguishing them from the majority of the network.
• Gray nodes occupy certain central roles within the network.
• Blue and green nodes are separated from the other nodes due to the specific structural properties described above, which ffstruc2vec was able to extract more effectively than struc2vec.

A comparison of the node embeddings generated by ffstruc2vec and struc2vec with those of DeepWalk and node2vec reveals that the embeddings from DeepWalk and node2vec fail to capture these structural patterns and do not group structurally equivalent nodes in the latent space, as shown in Figure 12a,b.

7.2. Barbell Graph

Figure 13 illustrates the application of the ffstruc2vec algorithm to a Barbell graph. Nodes with similar structural identities, as shown in the left image, are distinguished by uniform coloring. The ffstruc2vec algorithm effectively separates the embedding vectors of these nodes from the other nodes and positions nodes with similar structural identities closer to each other, as demonstrated in the right image.

The graph consists of two cliques, each comprising 10 nodes, interconnected by a path of 10 nodes. The nodes within the cliques that share identical structural identities are denoted in blue, while the nodes linking the cliques to the path are marked in green. ffstruc2vec positions the vectors of the blue nodes of the cliques closely together. In contrast, due to their additional connections to the path, the green nodes are positioned slightly apart from the blue nodes but remain relatively close, as expected.

Each node within the path has two neighbors and is colored red, blue, yellow, purple, or white, corresponding to its increasing distance from the cliques. As expected, ffstruc2vec places the nodes of the path far from the nodes of the cliques while preserving the relative order between them based on their distances to the cliques.

Figure 14 demonstrates ffstruc2vec’s flexibility in aligning with the demands of various downstream application tasks by emphasizing different types of structural identities. This adaptability is achieved by adjusting the weighting of k-hop neighborhood layers, which influences how structural similarities are captured in the latent space.

In Figure 14a, higher weighting is assigned to more distant k-hop neighborhood layers, leading to improved separation of nodes near the middle of the Barbell graph path, such as the blue, yellow, purple, and white nodes. This effect occurs because these nodes share a similar local neighborhood structure, meaning their distinction arises solely from the structural properties of their more distant neighborhoods. By prioritizing these higher-hop connections, ffstruc2vec enhances its ability to differentiate nodes based on structural roles beyond immediate proximity.

Conversely, in Figure 14b, higher weighting is applied to closer k-hop neighborhood layers. As a result, ffstruc2vec extracts similar structural identities for the blue, yellow, purple, and white nodes while simultaneously enabling better separation of the blue and green nodes. This shows how modifying the weighting scheme can shift the emphasis from long-range structural properties to local neighborhood similarities, highlighting ffstruc2vec’s adaptability in capturing different structural identities.

In contrast, Figure 13 applies equal weighting to the first five k-hop neighborhoods when generating node representation vectors. This uniform weighting approach fails to highlight structural nuances as effectively as the adaptive weighting strategies shown in Figure 14. The comparison highlights the advantage of flexibly adjusting neighborhood influences, enabling ffstruc2vec to extract more meaningful representations by aligning with the requirements of the corresponding downstream application task.

Figure 15 presents the latent representations for the nodes of the Barbell graph obtained using struc2vec, DeepWalk, and node2vec, as reported by Ribeiro et al. [13]. Struc2vec demonstrates structural preservation by grouping structurally equivalent nodes of the same color in the same vicinity in the latent space (Figure 15a). However, it falls short compared to ffstruc2vec (Figure 13), as highlighted by the following discrepancies.

• The nodes’ structural identities in the Barbell graph’s path are distinguished only by their distance to the two cliques. While ffstruc2vec maintains the relative ordering of red to white nodes, struc2vec fails to do so consistently in the embedding space.
• The nodes belonging to the two cliques in the Barbell graph have fundamentally different structural identities compared to the path nodes (e.g., $degree\ge 8$ vs. $degree=2$). In the embedding space, ffstruc2vec effectively separates these two groups, whereas struc2vec does not. For example, struc2vec positions the purple nodes significantly closer to the clique nodes than to the yellow nodes, even though the graph structure suggests that their structural identity is more aligned with that of the yellow nodes (see left image in Figure 13).

Section 6 provides a detailed discussion of the limitations of struc2vec in extracting structural identities compared to ffstruc2vec.

For completeness, Figure 15 also includes the embeddings generated by DeepWalk (Figure 15b) and node2vec (Figure 15c), which were used as a baseline comparison in the struc2vec paper. Both fail to preserve the structural properties of the nodes, despite varying the parameters p and q, which are designed in node2vec to control the balance between local and global exploration and can be adjusted to emphasize structural identities.

7.3. Air Traffic Network

The node representation vectors generated by ffstruc2vec can serve as input for node classification tasks, provided that the labels for nodes correspond to the type of structural identities that ffstruc2vec can preserve. To evaluate its effectiveness, particularly in comparison to struc2vec, we use three benchmark datasets introduced in the struc2vec paper by Ribeiro et al. [13]. These datasets consist of unweighted, undirected air traffic networks, where nodes represent airports and edges indicate the presence of commercial flights. Each airport is assigned one of four labels based on its activity level, measured by the number of flights or passengers. Specifically, the empirical activity distribution was divided into quartiles, with label 1 assigned to the $25\%$ least active airports and label 4 to the $25\%$ most active airports. All classes are of equal size and correspond to some type of structural role of the airport within the air traffic network. The details of the three benchmark datasets are listed in

Table 2. An overview of the three air traffic network datasets used for evaluation. Each dataset is an unweighted, undirected graph where nodes represent airports and edges indicate commercial flight connections. The activity measurement is the basis for assigning activity-level labels to airports for the classification algorithm.

Dataset	Nodes	Edges	Activity Measurement
Brazilian air traffic network	131	1038	Number of landings plus takeoffs
American air traffic network	1190	13,599	Number of passengers that passed the airport
European air traffic network	399	5995	Number of landings plus takeoffs

.

Although a regression algorithm might yield better results, we follow the classification approach established in the struc2vec paper to ensure better comparability between the frameworks. To generate node embeddings for each air traffic network, we applied ffstruc2vec, struc2vec, node2vec, and DeepWalk. The resulting embeddings were then used to train a supervised vector-based classification model. Instead of the grid search approach used in the struc2vec paper, we employed the Tree-structured Parzen Estimator (TPE) [51] to optimize hyperparameters, including the selection of the most suitable classification algorithm, thereby ensuring a fair benchmarking of all embedding methods. We considered node degree as the sole input feature, as it is a reasonable structural property for this task. Following the methodology of the struc2vec paper, we assessed performance using the accuracy score, given the balanced class distribution. Each experiment was repeated ten times with random training samples, using $80\%$ of the nodes for training. Moreover, we report the average performance across runs.

Table 3. Classification accuracy of node embedding methods across three air traffic network datasets. The best-performing method for each dataset is in bold.

Algorithm	Brazil	Europe	America	Average
DeepWalk	53.3%	48.1%	62.4%	54.6%
node2vec	58.9%	50.8%	66.2%	58.6%
Node degree	81.1%	57.0%	58.2%	65.4%
struc2vec	75.9%	61.6%	67.1%	68.2%
ffstruc2vec	82.6%	61.6%	69.7%	71.3%

summarizes the classification performance of the examined methods across all air traffic networks. DeepWalk yielded the lowest accuracy, as it primarily captures node proximity. For node2vec, the TPE algorithm favored larger values of p and smaller values of q, indicating a preference for structural properties over proximity. Consequently, node2vec achieved a $4\%$ higher average accuracy than DeepWalk by emphasizing structural features. Incorporating pure node degree as an input feature for the classification algorithms led to an additional $6.8\%$ improvement in accuracy compared to node2vec.

Struc2vec, which explicitly considers the structural properties of node neighborhoods, further enhanced the average accuracy by $2.8\%$. The highest accuracy was achieved with ffstruc2vec, which outperformed struc2vec by $3.1\%$ due to its optimized flat framework and greater flexibility in capturing diverse structural identities.

8. Conclusions

In this work, we introduced ffstruc2vec, a novel node embedding framework that effectively preserves structural identities by encoding a principled integration of multiple structural properties of nodes and their neighborhoods into an auxiliary flat similarity graph. By leveraging customizable comparison functions, even complex structural attributes can be seamlessly incorporated, enhancing the expressiveness of the learned embeddings.

A key strength of ffstruc2vec lies in its flexibility and its ability to provide interpretable representations of structural patterns. Most existing node embedding frameworks only focus on specific structural patterns or lack interpretability. In contrast, ffstruc2vec can be aligned to the specific requirements of downstream applications by optimizing weights—providing insight into the impact of individual structural characteristics on the given downstream application task. Our experimental evaluations on both supervised and unsupervised tasks confirm that ffstruc2vec outperforms existing methods in capturing structural identities.

To ensure scalability, ffstruc2vec achieves a time complexity of

$$\mathcal{O}\left(\max \right(\left|E\right|,\left|V\right|·\log \left|V\right|\left)\right),$$

for practically relevant settings, where (i) informative structural identities are predominantly captured by a node itself and its immediate neighborhood, and (ii) downstream applications rely on structural indicators and comparison functions that are efficiently computable at scale.

Limitations. While ffstruc2vec demonstrates strong performance across a variety of downstream tasks, certain limitations should be acknowledged. In particular, the framework involves trade-offs related to computational complexity when considering deeper neighborhood structures. In addition, property aggregation requires balancing expressiveness, interpretability, and scalability.

Future work. We identify two key directions:

• Complexity analysis: For more complex structural patterns, particularly when considering neighborhood depths $k\ge 2$, the current worst-case complexity can increase to $\mathcal{O}\left(\max \right(\left|E\right|·\left|V\right|,\left|V\right|·\log \left|V\right|\left)\right)$; future work will explore approximations (e.g., neighborhood sampling) to reduce this cost.
• Property aggregation: Future work will explore property aggregation strategies that balance the trade-off between representational power, flexibility, interpretability, and scalability.

Concluding remarks. By striking a balance between expressiveness, flexibility, interpretability, and scalability, ffstruc2vec establishes itself as a powerful framework for structural node embeddings.