Search

Although graph convolutional networks have achieved good performances in skeleton‐graph‐based action recognition, there are still some problems which include the incomplete utilization of skeleton graph features and the lacking of logical adjacency information between nodes in adjacency matrix. In this article, a human action recognition algorithm is proposed based on multiple features from the skeleton graph to solve these problems. More specifically, an improved adjacency matrix is constructed to make full use of the multiple skeleton graph features. These features include local differential features, multi‐scale edge features, features of the original skeleton graph, nodal features, and nodal motion features. Extensive results are conducted on four standard datasets (NTU RGB‐D 60, NTU RGB‐D 120, Kinetics, and Northwestern‐UCLA). The experimental results show that the proposed algorithm outperforms the SOTA action recognition algorithms. [ABSTRACT FROM AUTHOR]

ABSTRACT This paper presents a High Gain Metasurface (HGM) antenna design optimized for IoT applications. The antenna operates at a 5.8 GHz frequency and utilizes a quarter‐wavelength unit cell structure. The design employs a Graph Sample and Aggregate‐Attention Network (GSAAN) to enhance the transmission characteristics of the metasurface. To optimize the performance of GSAAN, the Giza Pyramids Construction Algorithm (GPCN) is applied to adjust the weight parameters, leading to significant improvements in radiation efficiency, bandwidth, gain, directivity, and return loss. The proposed HGM antenna is simulated in MATLAB 2023b, where it demonstrates substantial performance gains over existing methods. Specifically, the proposed design achieves 28.34% higher gain compared to the MSA‐RHCOA method, 24.47% improvement over HGM‐AD‐MATCS, 26.34% better gain than BR‐HGA‐PGM, and a 32.12% gain increase relative to MSA‐Hyb‐ADSA‐HMSOA. These enhancements make the proposed antenna design a competitive solution for high‐gain applications in wireless communication, satellite communication, and radar systems. The integration of GSAAN with GPCN optimization in the HGM antenna design enables the creation of highly directive radiation patterns, making it well‐suited for IoT applications that require high performance and reliability. The results of this study demonstrate the effectiveness of the proposed approach in achieving superior antenna performance, positioning it as a strong alternative to existing metasurface antenna designs. [ABSTRACT FROM AUTHOR]

The instability of solar energy is the biggest challenge to its successful integration with modern power grids, and accurate prediction of long‐term solar radiation can effectively solve this problem. In this study, we proposed a novel long‐term solar radiation prediction model based on time series imaging and bidirectional long short‐term memory network. First, inspired by the computer vision algorithm, the recursive graph algorithm is used to transform the one‐dimensional time series into two‐dimensional images, and then convolutional neural network is used to extract the features from the images, thus, the deeper features in the original solar radiation data can be mined. Second, to solve the problem of low accuracy of long‐term solar radiation prediction, a hybrid model BiLSTM‐Transformer is used to predict long‐term solar radiation. The hybrid prediction model can capture the long‐term dependencies, thereby further improving the accuracy of the prediction model. The experimental results show that the hybrid model proposed in this study is superior to other single models and hybrid models in long‐term solar radiation prediction accuracy. The accuracy and stability of the hybrid model are verified by many tests. [ABSTRACT FROM AUTHOR]

Deploying the Internet of Things (IoT) in integrated edge‐cloud environments exposes the IoT traffic data to performance issues such as delay, bandwidth limitation etc. Recently, Software‐Defined Wide Area Network (SD‐WAN) has emerged as an architecture that originates from the Software‐Defined Network (SDN) paradigm and provides solutions for networking multiple data centers by allowing network administrators to manage and control network layers. In this article, an SDWAN‐based policy for traffic management in IoT is introduced in which the Quality of Service (QoS) metrics such as end‐to‐end delay and bandwidth utilization are optimized. The proposed method implements the traffic management policy in the SDWAN controller. When the IoT traffic flows reach the SDWAN infrastructure network, graph search algorithms are performed to find the near‐optimal paths that affect the end‐to‐end delay of traffic flows. Because of the ability of deep learning to process complex data, a deep RNN model is used to predict the network state information, such as link latency and available bandwidth, before the traffic flows reach the infrastructure network. The proposed method consists of four key modules to predict the routes for future time intervals: (a) an SD‐WAN topology updater unit that checks the link changes and availability, (b) the network state information collector, which collects the network state information to create a dataset, (c) the learning unit, which trains a deep RNN model using the created dataset, and (d) the route predictor unit, which uses the trained model to predict the network state information using a heuristic algorithm to determine the routes. The simulation results showed that the deep RNN model can achieve high accuracy and low Mean Absolute Error (MAE), and the proposed method outperforms shortest‐path algorithms in terms of latency. At the same time, the available bandwidth is almost fairly distributed among all network links. [ABSTRACT FROM AUTHOR]

Precipitation channelled down tree stems (stemflow) or into drip points of 'throughfall' beneath trees results in spatially concentrated inputs of water and chemicals to the ground. Currently, these flows are poorly characterised due to uncertainties about which branches redirect rainfall to stemflow or throughfall drip points.We introduce a graph theoretic algorithm that 'prunes' quantitative structural models of trees (derived from terrestrial LiDAR) to identify branches contributing to stemflow and those contributing to throughfall drip points. To demonstrate the method's utility, we analysed two trees with similar canopy sizes but contrasting canopy architecture and rainfall partitioning behaviours.For both trees, the branch 'watershed' area contributing to stemflow (under conditions assumed to represent moderate precipitation intensity) was found to be only half of the total ground area covered by the canopy. The study also revealed significant variations between trees in the number and median contribution areas of modelled throughfall drip points (69 vs. 94 drip points tree−1, with contributing projected areas of 28.6 vs. 7.8 m2 tree−1, respectively). Branch diameter, surface area, volumes and woody area index of components contributing to stemflow and throughfall drip points may play a role in the trees' differing rainfall partitioning behaviours.Our pruning algorithm, enabled by the proliferation of LiDAR observations of canopy structure, promises to enhance studies of canopy hydrology. It offers a novel approach to refine our understanding of how trees interact with rainfall, thereby broadening the utility of existing LiDAR data in environmental research. [ABSTRACT FROM AUTHOR]

A minimal separator of a graph G is a set S⊆V(G) such that there exist vertices a,b∈V(G)⧹S with the property that S separates a from b in G, but no proper subset of S does. For an integer k≥0, we say that a minimal separator is k‐simplicial if it can be covered by k cliques and denote by Gk the class of all graphs in which each minimal separator is k‐simplicial. We show that for each k≥0, the class Gk is closed under induced minors, and we use this to show that the Maximum Weight Stable Set problem can be solved in polynomial time for Gk. We also give a complete list of minimal forbidden induced minors for G2. Next, we show that, for k≥1, every nonnull graph in Gk has a k‐simplicial vertex, that is, a vertex whose neighborhood is a union of k cliques; we deduce that the Maximum Weight Clique problem can be solved in polynomial time for graphs in G2. Further, we show that, for k≥3, it is NP‐hard to recognize graphs in Gk; the time complexity of recognizing graphs in G2 is unknown. We also show that the Maximum Clique problem is NP‐hard for graphs in G3. Finally, we prove a decomposition theorem for diamond‐free graphs in G2 (where the diamond is the graph obtained from K4 by deleting one edge), and we use this theorem to obtain polynomial‐time algorithms for the Vertex Coloring and recognition problems for diamond‐free graphs in G2, and improved running times for the Maximum Weight Clique and Maximum Weight Stable Set problems for this class of graphs. [ABSTRACT FROM AUTHOR]

Entanglement is crucial for achieving quantum advantages. However, in the context of quantum machine learning, existing optimization strategies for generating quantum classifier circuits often result in unentangled circuits, indicating an underutilization of the entanglement effect needed to learn complex patterns. In this study, we proposed a novel metaheuristic approach—genetic algorithm—for designing a quantum kernel classifier that incorporates expressive entanglement. This classifier utilizes a loopless entanglement‐directed graph, where each directed edge represents the entanglement between the target and control qubits. The proposed method consistently outperforms classical and quantum baselines across various artificial and actual datasets, achieving improvements up to 32.4% and 17.5%, respectively, compared with the best model among all other baselines. Moreover, this method successfully reconstructs the hidden entanglement structures underlying artificial datasets. The results also demonstrate that the optimized circuits exhibit diverse entanglement variations across different datasets, indicating the versatility of the proposed approach. [ABSTRACT FROM AUTHOR]

Modifying network results is the most intuitive way to inject domain knowledge into network detection algorithms to improve their performance. While advances in computation scalability have made detecting large‐scale networks possible, the human ability to modify such networks has not scaled accordingly, resulting in a huge 'interaction gap'. Most existing works only support navigating and modifying edges one by one in a graph visualization, which causes a significant interaction burden when faced with large‐scale networks. In this work, we propose a novel graph pattern mining algorithm based on the minimum description length (MDL) principle to partition and summarize multi‐feature and isomorphic sub‐graph matches. The mined sub‐graph patterns can be utilized as mediums for modifying large‐scale networks. Combining two traditional approaches, we introduce a new coarse‐middle‐fine graph modification paradigm (i.e. query graph‐based modification →$\rightarrow$ sub‐graph pattern‐based modification →$\rightarrow$ raw edge‐based modification). We further present a graph modification system that supports the graph modification paradigm for improving the scalability of modifying detected large‐scale networks. We evaluate the performance of our graph pattern mining algorithm through an experimental study, demonstrate the usefulness of our system through a case study, and illustrate the efficiency of our graph modification paradigm through a user study. [ABSTRACT FROM AUTHOR]

We introduce time‐varying extremum graph (tveg), a topological structure to support visualization and analysis of a time‐varying scalar field. The extremum graph is a sub‐structure of the Morse–Smale complex. It captures the adjacency relationship between cells in the Morse decomposition of a scalar field. We define the tveg as a time‐varying extension of the extremum graph and demonstrate how it captures salient feature tracks within a dynamic scalar field. We formulate the construction of the tveg as an optimization problem and describe an algorithm for computing the graph. We also demonstrate the capabilities of tveg towards identification and exploration of topological events such as deletion, generation, split and merge within a dynamic scalar field via comprehensive case studies including a viscous fingers and a 3D von Kármán vortex street dataset. [ABSTRACT FROM AUTHOR]

This paper presents an edge‐based event‐triggered delay distributed algorithm for solving the economic dispatch problem (EDP) in smart grids. The objective of the EDP is to minimize the total generation cost by allocating power to individual generators, each with its local generation constraint. To save the overhead of communication resources between agents, an edge‐based event‐triggered mechanism is suggested. By setting distinct triggering thresholds for each communication edge, the agent may efficiently regulate the communication frequency among all neighbors. However, in practice, owing to the instability of the network, the agent may receive information regarding its neighbors, leading to communication lags for every communication link. The virtual agent technique and double‐stochastic matrix augmentation technique provide an equivalent delay‐free EDP. It is demonstrated that the proposed algorithm can asymptotically converge to the global optimal solution as long as the communication delay is arbitrary, time‐varying, and random, but bounded. Objective and clear evidence is provided through a case study in smart grids to verify the algorithm's feasibility. [ABSTRACT FROM AUTHOR]

A moplex is a natural graph structure that arises when lifting Dirac's classical theorem from chordal graphs to general graphs. The notion is known to be closely related to lexicographic searches in graphs as well as to asteroidal triples, and has been applied in several algorithms related to graph classes, such as interval graphs, claw‐free, and diamond‐free graphs. However, while every noncomplete graph has at least two moplexes, little is known about structural properties of graphs with a bounded number of moplexes. The study of these graphs is, in part, motivated by the parallel between moplexes in general graphs and simplicial modules in chordal graphs: unlike in the moplex setting, properties of chordal graphs with a bounded number of simplicial modules are well understood. For instance, chordal graphs having at most two simplicial modules are intervals. In this work, we initiate an investigation of k $k$‐moplex graphs, which are defined as graphs containing at most k $k$ moplexes. Of particular interest is the smallest nontrivial case k=2 $k=2$, which forms a counterpart to the class of interval graphs. As our main structural result, we show that, when restricted to connected graphs, the class of 2‐moplex graphs is sandwiched between the classes of proper interval graphs and cocomparability graphs; moreover, both inclusions are tight for hereditary classes. From a complexity‐theoretic viewpoint, this leads to the natural question of whether the presence of at most two moplexes guarantees a sufficient amount of structure to efficiently solve problems that are known to be intractable on cocomparability graphs, but not on proper interval graphs. We develop new reductions that answer this question negatively for two prominent problems fitting this profile, namely, Graph Isomorphism and Max‐Cut. On the other hand, we prove that every connected 2‐moplex graph contains a Hamiltonian path, generalising the same property of connected proper interval graphs. Furthermore, for graphs with a higher number of moplexes, we lift the previously known result that graphs without asteroidal triples have at most two moplexes to the more general setting of larger asteroidal sets. [ABSTRACT FROM AUTHOR]

Purpose: To develop a highly accelerated multi‐echo spin‐echo method, TEMPURA, for reducing the acquisition time and/or increasing spatial resolution for kidney T2 mapping. Methods: TEMPURA merges several adjacent echoes into one k‐space by either combining independent echoes or sharing one echo between k‐spaces. The combined k‐space is reconstructed based on compressed sensing theory. Reduced flip angles are used for the refocusing pulses, and the extended phase graph algorithm is used to correct the effects of indirect echoes. Two sequences were developed: a fast breath‐hold sequence; and a high‐resolution sequence. The performance was evaluated prospectively on a phantom, 16 healthy subjects, and two patients with different types of renal tumors. Results: The fast TEMPURA method reduced the acquisition time from 3–5 min to one breath‐hold (18 s). Phantom measurements showed that fast TEMPURA had a mean absolute percentage error (MAPE) of 8.2%, which was comparable to a standardized respiratory‐triggered sequence (7.4%), but much lower than a sequence accelerated by purely k‐t undersampling (21.8%). High‐resolution TEMPURA reduced the in‐plane voxel size from 3 × 3 to 1 × 1 mm2, resulting in improved visualization of the detailed anatomical structure. In vivo T2 measurements demonstrated good agreement (fast: MAPE = 1.3%–2.5%; high‐resolution: MAPE = 2.8%–3.3%) and high correlation coefficients (fast: R = 0.85–0.98; high‐resolution: 0.82–0.96) with the standardized method, outperforming k‐t undersampling alone (MAPE = 3.3–4.5%, R = 0.57–0.59). Conclusion: TEMPURA provides fast and high‐resolution renal T2 measurements. It has the potential to improve clinical throughput and delineate intratumoral heterogeneity and tissue habitats at unprecedented spatial resolution. [ABSTRACT FROM AUTHOR]

Reconstructing 2D curves from sample points has long been a critical challenge in computer graphics, finding essential applications in vector graphics. The design and editing of curves on surfaces has only recently begun to receive attention, primarily relying on human assistance, and where not, limited by very strict sampling conditions. In this work, we formally improve on the state‐of‐the‐art requirements and introduce an innovative algorithm capable of reconstructing closed curves directly on surfaces from a given sparse set of sample points. We extend and adapt a state‐of‐the‐art planar curve reconstruction method to the realm of surfaces while dealing with the challenges arising from working on non‐Euclidean domains. We demonstrate the robustness of our method by reconstructing multiple curves on various surface meshes. We explore novel potential applications of our approach, allowing for automated reconstruction of curves on Riemannian manifolds. [ABSTRACT FROM AUTHOR]

Background: Resting‐state functional magnetic resonance imaging (rs‐fMRI) technology and the complex network theory can be used to elucidate the underlying mechanisms of brain diseases. The successful application of functional brain hypernetworks provides new perspectives for the diagnosis and evaluation of clinical brain diseases; however, many studies have not assessed the attribute information of hyperedges and could not retain the high‐order topology of hypergraphs. In addition, the study of multi‐scale and multi‐layered organizational properties of the human brain can provide richer and more accurate data features for classification models of depression. Purpose: This work aims to establish a more accurate classification framework for the diagnosis of major depressive disorder (MDD) using the high‐order line graph algorithm. And accuracy, sensitivity, specificity, precision, F1 score are used to validate its classification performance. Methods: Based on rs‐fMRI data from 38 MDD subjects and 28 controls, we constructed a human brain hypernetwork and introduced a line graph model, followed by the construction of a high‐order line graph model. The topological properties under each order line graph were calculated to measure the classification performance of the model. Finally, intergroup features that showed significant differences under each order line graph model were fused, and a support vector machine classifier was constructed using multi‐kernel learning. The Kolmogorov–Smirnov nonparametric permutation test was used as the feature selection method and the classification performance was measured with the leave‐one‐out cross‐validation method. Results: The high‐order line graph achieved a better classification performance compared with other traditional hypernetworks (accuracy = 92.42%, sensitivity = 92.86%, specificity = 92.11%, precision = 89.66%, F1 = 91.23%). Furthermore, the brain regions found in the present study have been previously shown to be associated with the pathology of depression. Conclusions: This work validated the classification model based on the high‐order line graph, which can better express the topological features of the hypernetwork by comprehensively considering the hyperedge information under different connection strengths, thereby significantly improving the classification accuracy of MDD. Therefore, this method has potential for use in the clinical diagnosis of MDD. [ABSTRACT FROM AUTHOR]

A phylogenetic graph search relies on a large number of highly parameterized search procedures (e.g. branch‐swapping, perturbation, simulated annealing, genetic algorithm). These procedures vary in effectiveness over datasets and at alternative points in analytical pipelines. The multi‐armed bandit problem is applied to phylogenetic graph searching to more effectively utilize these procedures. Thompson sampling is applied to a collection of search and optimization "bandits" to favour productive search strategies over those that are less successful. This adaptive random sampling strategy is shown to be more effective in producing heuristically optimal phylogenetic graphs and more time efficient than existing uniform probability randomized search strategies. The strategy acts as a form of unsupervised machine learning that can be applied to a diversity of phylogenetic datasets without prior knowledge of their properties. [ABSTRACT FROM AUTHOR]

Summary: The breadth‐first search procedure is an algorithm that traverses the vertices of a graph, determining the distance from each vertex to the initial vertex. The distance is infinite for a non‐reachable vertex from the starting vertex. Despite having an efficient serial version, this important algorithm is irregular, making its effective parallel implementation a daunting task. This paper shows the results of an OpenMP‐based implementation of the breadth‐first search procedure using the bag data structure. Furthermore, the code relied on the C++ programming language. This paper reimplements an existing proposal coded using the Cilk++ programming language. The experiments relied on 32 strongly connected graphs and 31 disconnected graphs in executions performed on two machines. The first machine contained 28 cores and two threads per core. The second machine comprised 48 processing cores, with hyperthreading disabled. Regarding the serial version, the parallel implementation yielded a speedup of up to 20× when using 28 processing cores and up to 25× when using 56 threads in tests performed on a machine with the first generation of Intel® Xeon® Scalable processors. Furthermore, the new parallel implementation yielded speedups of up to 45× when using 48 cores in experiments performed on a machine with the second generation of Intel® Xeon® Scalable processors. [ABSTRACT FROM AUTHOR]

We introduce two new methods for approximating the all‐terminal reliability of undirected graphs. First, we introduce an edge removal process: remove edges at random, one at a time, until the graph becomes disconnected. We show that the expected number of edges thus removed is equal to (m+1)A$$ \left(m+1\right)A $$, where m$$ m $$ is the number of edges in the graph, and A$$ A $$ is the average of the all‐terminal reliability polynomial. Based on this process, we propose a Monte‐Carlo algorithm to quickly estimate the graph reliability (whose exact computation is NP‐hard). Moreover, we show that the distribution of the edge removal process can be used to quickly approximate the reliability polynomial. We then propose increasingly accurate asymptotics for graph reliability based solely on degree distributions of the graph. These asymptotics are tested against several real‐world networks and are shown to be accurate for sufficiently dense graphs. While the approach starts to fail for "subway‐like" networks that contain many paths of vertices of degree two, different asymptotics are derived for such networks. [ABSTRACT FROM AUTHOR]

Temporal trees are trees that evolve over a discrete set of time steps. Each time step is associated with a node‐weighted rooted tree and consecutive trees change by adding new nodes, removing nodes, splitting nodes, merging nodes, and changing node weights. Recently, two‐dimensional visualizations of temporal trees called temporal treemaps have been proposed, representing the temporal dimension on the x‐axis, and visualizing the tree modifications over time as temporal edges of varying thickness. The tree hierarchy at each time step is depicted as a vertical, one‐dimensional nesting relationships, similarly to standard, non‐temporal treemaps. Naturally, temporal edges can cross in the visualization, decreasing readability. Heuristics were proposed to minimize such crossings in the literature, but a formal characterization and minimization of crossings in temporal treemaps was left open. In this paper, we propose two variants of defining crossings in temporal treemaps that can be combinatorially characterized. For each variant, we propose an exact optimization algorithm based on integer linear programming and heuristics based on graph drawing techniques. In an extensive experimental evaluation, we show that on the one hand the exact algorithms reduce the number of crossings by a factor of 20 on average compared to the previous algorithms. On the other hand, our new heuristics are faster by a factor of more than 100 and still reduce the number of crossings by a factor of almost three. [ABSTRACT FROM AUTHOR]

To solve the difficulties in threshold selection and poor performance under low signal‐to‐noise ratio (SNR) conditions in existing spectrum sensing algorithms, a graph‐based spectrum sensing algorithm using nonlinear function regulation was proposed. The idea was to add a specific nonlinear transformation between the normalisation and quantization steps of the existing signal‐to‐graph converter (SGC). If the autocorrelation function of the observed signal selected as the input fed to SGC, the nonlinear function has the ability to adjust the uniformity of its probability distribution, increasing the probability of the observed signal being transformed into a complete graph under the alternative hypothesis, whereas remaining a noncomplete graph under the null hypothesis. Thus transformed the graph‐based spectrum sensing into a complete graph‐detection problem. Based on the theory of dispersive ordering, a theoretical analysis of the mechanism by which nonlinear transformations affect graph connectivity was conducted. The simulation results showed that the detection performance of the proposed algorithm was superior to that of existing graph‐based spectrum sensing algorithms. When SNR was −7 dB, the detection probability of the proposed algorithm exceeded 95%. Moreover, among the existing graph‐based spectrum sensing algorithms, the proposed algorithm exhibited the lowest computational complexity apart from the block range‐based method. [ABSTRACT FROM AUTHOR]

Under the envisioned smart grid paradigm, there is an increasing demand for a fast, accurate, and efficient power flow solution for distribution system operation and control. Various solution techniques have been proposed, each with its own unique formulation, solution methodology, advantages, and drawbacks. Motivated by challenges associated with the integration of renewable distributed energy resources and electric vehicles into distribution systems and further by the speed and convergence limitations of existing tools, this paper presents a novel graph‐based power flow solution for smart grid's real‐time operation and control, named Flow‐AugmentationPF algorithm. The proposed method formulates a power flow problem as a network‐flow problem and solves it by using a maximum‐flow algorithm, inspired by the push‐relabel max‐flow technique. The performance of the proposed algorithm is tested and validated using several benchmark networks of different sizes, topologies, and parameters and compared against the most commonly used solution techniques and commercial software packages, namely PSS/E and PSCAD. The proposed formulation is simple, accurate, fast, yet computationally efficient, as it is based on matrix‐vector multiplication, and is also scalable, considering the formulation works as a graph‐based method, which, inherently, allows for parallel computation for added computational speed. [ABSTRACT FROM AUTHOR]

Algebraic multigrid (AMG) methods are often robust and effective solvers for solving the large and sparse linear systems that arise from discretized PDEs and other problems, relying on heuristic graph algorithms to achieve their performance. Reduction‐based AMG (AMGr) algorithms attempt to formalize these heuristics by providing two‐level convergence bounds that depend concretely on properties of the partitioning of the given matrix into its fine‐ and coarse‐grid degrees of freedom. MacLachlan and Saad (SISC 2007) proved that the AMGr method yields provably robust two‐level convergence for symmetric and positive‐definite matrices that are diagonally dominant, with a convergence factor bounded as a function of a coarsening parameter. However, when applying AMGr algorithms to matrices that are not diagonally dominant, not only do the convergence factor bounds not hold, but measured performance is notably degraded. Here, we present modifications to the classical AMGr algorithm that improve its performance on matrices that are not diagonally dominant, making use of strength of connection, sparse approximate inverse (SPAI) techniques, and interpolation truncation and rescaling, to improve robustness while maintaining control of the algorithmic costs. We present numerical results demonstrating the robustness of this approach for both classical isotropic diffusion problems and for non‐diagonally dominant systems coming from anisotropic diffusion. [ABSTRACT FROM AUTHOR]

Spatial clusters contain biases and artifacts, whether they are defined via statistical algorithms or via expert judgment. Graph‐based partitioning of spatial data and associated heuristics gained popularity due to their scalability but can define suboptimal regions due to algorithmic biases such as chaining. Despite the broad literature on deterministic regionalization methods, approaches that quantify regionalization probability are sparse. In this article, we propose a local method to quantify regionalization probabilities for regions defined via graph‐based cuts and expert‐defined regions. We conceptualize spatial regions as consisting of two types of spatial elements: core and swing. We define three distinct types of regionalization biases that occur in graph‐based methods and showcase the use of the proposed method to capture these types of biases. Additionally, we propose an efficient solution to the probabilistic graph‐based regionalization problem via performing optimal tree cuts along random spanning trees within an evidence accumulation framework. We perform statistical tests on synthetic data to assess resulting probability maps for varying distinctness of underlying regions and regionalization parameters. Lastly, we showcase the application of our method to define probabilistic ecoregions using climatic and remotely sensed vegetation indicators and apply our method to assign probabilities to the expert‐defined Bailey's ecoregions. [ABSTRACT FROM AUTHOR]

The Internet of Vehicles (IoV) autonomous driving technology based on deep learning has achieved great success. However, under the tunnel environment, the computer vision‐based IoV may fail due to low illumination. In order to handle this issue, this paper deploys an image enhancement module at the terminal of the IoV to alleviate the low illumination influence. The enhanced images can be submitted through IoT to the cloud server for further processing. The core algorithm of image enhancement is implemented by a dynamic graph embedded transformer network based on federated learning which can fully utilize the data resources of multiple devices in IoV and improve the generalization. Extensive comparative experiments are conducted on the publicly available dataset and the self‐built dataset which is collected under the tunnel environment. Compared with other deep models, all results confirm that the proposed graph embedded Transformer model can effectively enhance the detail information of the low‐light image, which can greatly improve the following tasks in IoV. [ABSTRACT FROM AUTHOR]

In the last two decades, we are witnessing a huge increase of valuable big data structured in the form of graphs or networks. To apply traditional machine learning and data analytic techniques to such data it is necessary to transform graphs into vector‐based representations that preserve the most essential structural properties of graphs. For this purpose, a large number of graph embedding methods have been proposed in the literature. Most of them produce general‐purpose embeddings suitable for a variety of applications such as node clustering, node classification, graph visualization and link prediction. In this article, we propose two novel graph embedding algorithms based on random walks that are specifically designed for the node classification problem. Random walk sampling strategies of the proposed algorithms have been designed to pay special attention to hubs–high‐degree nodes that have the most critical role for the overall connectedness in large‐scale graphs. The proposed methods are experimentally evaluated by analyzing the classification performance of three classification algorithms trained on embeddings of real‐world networks. The obtained results indicate that our methods considerably improve the predictive power of examined classifiers compared with currently the most popular random walk method for generating general‐purpose graph embeddings (node2vec). [ABSTRACT FROM AUTHOR]

With the continuous development of automated driving, the path planning algorithm of unmanned vehicles has been continuously innovated. First, some basic concepts of path planning are briefly introduced. Secondly, starting with the classification idea of path planning algorithm based on graph structure and sampling, the paper introduces four typical basic algorithms: Dijkstra algorithm, A* algorithm, PRM algorithm and RRT algorithm. In addition, the Apollo algorithm, which has been studied most at present, is also introduced. The principle and application scenario of each algorithm are summarized. Finally, several new algorithms and their development prospects are introduced. [ABSTRACT FROM AUTHOR]

Aiming at the actual industrial process background that different modes share the same system configurations and control structure, this article proposes a novel structured discriminant Gaussian graph learning for multimode process monitoring. The proposed method considers not only the sparsity of graph model but also the measurement of data variation based on a mismatched graph and the common node support between different graphical structures. The objective function involves two sets of regularization terms: the trace terms for mismatched measurements and the ℓ2,1‐norm imposed on the union of decomposed graph matrices. Due to the introduced mismatched trace terms, the cost of matching the data points and graph models that have inconsistent class labels can be expanded, which brings more discrimination for the graph‐based mode identification. While the common structure extracted by the ℓ2,1‐norm forces the estimated graph models to have structural similarities, thus alleviating the negative influence caused by graph discrimination. Once a relatively accurate and discriminative reference graph model is obtained, the downstream test graph learning and analysis can be conducted online by employing the moving window techniques. By comparing the matched and mismatched graph‐based measurements, the process mode can be identified correctly and stably. To grasp the abnormal process changes, the ℓ2,1‐norm for the row sparsity is again applied to the graph difference matrices, the sensitive monitoring statistics and the fault isolation results can be obtained effectively. All the optimization problems in this paper can be solved using the alternating direction multiplier (ADMM) algorithm. The effectiveness of our proposed approach is illustrated by the application to a real blast furnace iron‐making production process. This article proposes a process monitoring method based on a structured sparse Gaussian graphical model, which is more suitable for real‐world industrial processes with multiple modes. The proposed method considers not only the sparsity of graph model, but also the measurement of data variation based on a mismatched graph and the common node support between different graphical structures. And the accuracy of mode identification and the monitoring effectiveness is illustrated by a real blast furnace iron‐making production process. [ABSTRACT FROM AUTHOR]

Let G=(V,E)$$ G=\left(V,E\right) $$ be a graph with unit‐length edges and nonnegative costs assigned to its vertices. Given a list of pairwise different vertices S=(s1,s2,...,sp)$$ S=\left({s}_1,{s}_2,\dots, {s}_p\right) $$, the prioritized Voronoi diagram of G$$ G $$ with respect to S$$ S $$ is the partition of G$$ G $$ in p$$ p $$ subsets V1,V2,...,Vp$$ {V}_1,{V}_2,\dots, {V}_p $$ so that, for every i$$ i $$ with 1≤i≤p$$ 1\le i\le p $$, a vertex v$$ v $$ is in Vi$$ {V}_i $$ if and only if si$$ {s}_i $$ is a closest vertex to v$$ v $$ in S$$ S $$ and there is no closest vertex to v$$ v $$ in S$$ S $$ within the subset {s1,s2,...,si−1}$$ \left\{{s}_1,{s}_2,\dots, {s}_{i-1}\right\} $$. For every i$$ i $$ with 1≤i≤p$$ 1\le i\le p $$, the load of vertex si$$ {s}_i $$ equals the sum of the costs of all vertices in Vi$$ {V}_i $$. The load of S$$ S $$ equals the maximum load of a vertex in S$$ S $$. We study the problem of adding one more vertex v$$ v $$ at the end of S$$ S $$ in order to minimize the load. This problem occurs in the context of optimally locating a new service facility (e.g., a school or a hospital) while taking into account already existing facilities, and with the goal of minimizing the maximum congestion at a site. There is a brute‐force algorithm for solving this problem in 풪(nm) time on n$$ n $$‐vertex m$$ m $$‐edge graphs. We prove a matching time lower bound–up to sub‐polynomial factors–for the special case where m=n1+o(1)$$ m={n}^{1+o(1)} $$ and p=1$$ p=1 $$, assuming the so called Hitting Set Conjecture of Abboud et al. On the positive side, we present simple linear‐time algorithms for this problem on cliques, paths and cycles, and almost linear‐time algorithms for trees, proper interval graphs and (assuming p$$ p $$ to be a constant) bounded‐treewidth graphs. [ABSTRACT FROM AUTHOR]

This paper investigates the issue of finite-time synchronization and topology identification of delayed multi-group models with stochastic perturbation and multiple dispersal. Based on the graph-theoretic approach, a novel finite-time topology identification scheme is proposed via drive-response synchronization. Then, several useful finite-time topology identification criteria are presented. The topology identification of delayed multi-group models with stochastic perturbation and multiple dispersal is acquired in finite time under the desired feedback controller. Finally, a numerical example is given to validate the effectiveness of the result developed. [ABSTRACT FROM AUTHOR]

Contrastive learning is an increasingly important research direction and has attracted considerable attention in the field of computer vision. It can greatly improve the representativeness of image features through data augmentation, unsupervised learning, and pre‐trained models. However, in the field of traffic flow forecasting, most graph‐based models focus on the construct of spatial–temporal relationships between road segments and ignore the use of temporal data augmentation and pre‐trained models, which can improve the representation ability of the forecasting model. Therefore, in this work, contrastive learning are used to expand the distribution of sequence samples and improve the quality and generalization of forecasting models. Based on this, a novel forecasting model called contrastive learning based on multi graph convolution network (CLMGCN) is proposed, which is combined with four components: multi graph convolution network, which learns the spatial–temporal feature of the input traffic data; temporal data augmentation, which obtains the augmentation data of the input traffic data; contrastive learning, which achieves the pre‐training phase and improve the quality of output feature of multi graph convolution network; output block, which utilizes the enhanced output feature of multi graph convolution network for predicting the future traffic data. Finally, by the experimental results of four public traffic flow datasets, it can be shown that CLMGCN achieves higher traffic forecasting accuracy with lower model complexity. [ABSTRACT FROM AUTHOR]

Since many NP$\mathsf {NP}$‐complete graph problems are polynomial‐time solvable when restricted to claw‐free graphs, we study the problem of determining the distance of a given graph to a claw‐free graph, considering vertex elimination a measure. Claw‐free Vertex Deletion (CFVD) consists of determining the minimum number of vertices to be removed from a graph such that the resulting graph is claw‐free. Although CFVD is NP$\mathsf {NP}$‐hard in general and recognizing claw‐free graphs is still a challenge, where the current best deterministic algorithm for a graph G consists of performing |V(G)|$|V(G)|$ executions of the best algorithm for matrix multiplication, we present linear‐time algorithms for CFVD on weighted block graphs and weighted graphs with bounded treewidth. Furthermore, we show that this problem on forests can be solved in linear time by a simpler algorithm, and we determine the exact values for full k‐ary trees. On the other hand, we show that CFVD is NP$\mathsf {NP}$‐hard even when the input graph is a split graph. We also show that the problem is hard to be approximated within any constant factor better than 2, assuming the unique games conjecture. [ABSTRACT FROM AUTHOR]

In this paper, we introduce, study and analyze several classes of compact formulations for the symmetric Hamiltonian p$$ p $$‐median problem (Hp$$ p $$MP). Given a positive integer p$$ p $$ and a weighted complete undirected graph G=(V,E)$$ G=\left(V,E\right) $$ with weights on the edges, the Hp$$ p $$MP on G$$ G $$ is to find a minimum weight set of p$$ p $$ elementary cycles partitioning the vertices of G$$ G $$. The advantage of developing compact formulations is that they can be readily used in combination with off‐the‐shelf optimization software, unlike other types of formulations possibly involving the use of exponentially sized sets of variables or constraints. The main part of the paper focuses on compact formulations for eliminating solutions with less than p$$ p $$ cycles. Such formulations are less well known and studied than formulations which prevent solutions with more than p$$ p $$ cycles. The proposed formulations are based on a common motivation, that is, the formulations contain variables that assign labels to nodes, and prevent less than p$$ p $$ cycles by stating that different depots must have different labels and that nodes in the same cycle must have the same label. We introduce and study aggregated formulations (which consider integer variables that represent the label of the node) and disaggregated formulations (which consider binary variables that assign each node to a given label). The aggregated models are new. The disaggregated formulations are not, although in all of them new enhancements have been included to make them more competitive with the aggregated models. The two main conclusions of this study are: (i) in the context of compact formulations, it is worth looking at the models with integer node variables, which have a smaller size. Despite their weaker LP relaxation bounds, the fewer variables and constraints lead to faster integer resolution, especially when solving instances with more than 50 nodes; (ii) the best of our compact models exhibit a performance that, overall, is comparable to that of the best methods known for the Hp$$ p $$MP (including branch‐and‐cut algorithms), solving to optimality instances with up to 226 nodes within 1 h. This corroborates our message that the knowledge of the inequalities for preventing less than p$$ p $$ cycles is much less well understood. [ABSTRACT FROM AUTHOR]

Summary: Task‐based systems have become popular due to their ability to utilize the computational power of complex heterogeneous systems. A typical programming model used is the Sequential Task Flow (STF) model, which unfortunately only supports static task graphs. This can result in submission overhead and a static task graph that is not well‐suited for execution on heterogeneous systems. A common approach is to find a balance between the granularity needed for accelerator devices and the granularity required by CPU cores to achieve optimal performance. To address these issues, we have extended the STF model in the StarPU runtime system by introducing the concept of hierarchical tasks. This allows for a more dynamic task graph and, when combined with an automatic data manager, it is possible to adjust granularity at runtime to best match the targeted computing resource. That data manager makes it possible to switch between various data layout without programmer input and allows us to enforce the correctness of the DAG as hierarchical tasks alter it during runtime. Additionally, submission overhead is reduced by using large‐grain hierarchical tasks, as the submission process can now be done in parallel. We have shown that the hierarchical task model is correct and have conducted an early evaluation on shared memory heterogeneous systems using the Chameleon dense linear algebra library. [ABSTRACT FROM AUTHOR]

Summary: Graph clustering is a primitive operation for graph data mining. It plays an important role to reveal community clusters, hubs, and outliers in complex networks. There are several graph clustering algorithms have been proposed based on the well‐studied SCAN algorithm in recent years. However, SCAN and its improved sequential variants are prohibitively slow due to their iterative computations. The parallel variants are focusing on improving the efficiency of graph clustering by utilizing multi‐cores computer architectures on single computing node with complex optimization techniques. Therefore, SCAN and its variants are not suitable for processing very large graphs due to the limitations of memory size and storage volume on a single node. In this article, we proposed a distributed parallel structural clustering algorithm using MapReduce. In order to improve the efficiency further, we proposed optimization techniques including partition based clustering and simplified combination with labels to accelerate the operations. We conducted extensive experiments on real world datasets. The experimental results showed our algorithm is high efficiency and scales well under different settings. [ABSTRACT FROM AUTHOR]

Let G ${\mathscr{G}}$ be a class of graphs with a membership test, k∈N $k\in {\mathbb{N}}$, and let Gk ${{\mathscr{G}}}^{k}$ be the class of graphs in G ${\mathscr{G}}$ of path‐width at most k $k$. We present an interactive framework that finds an unavoidable set for Gk ${{\mathscr{G}}}^{k}$, which is a set of graphs U ${\mathscr{U}}$ such that any graph in Gk ${{\mathscr{G}}}^{k}$ contains an isomorphic copy of a graph in U ${\mathscr{U}}$. At the core of our framework is an algorithm that verifies whether a set of graphs is, indeed, unavoidable for Gk ${{\mathscr{G}}}^{k}$. While obstruction sets are well‐studied, so far there is no general theory or algorithm for finding unavoidable sets. In general, it is undecidable whether a finite set of graphs is unavoidable for a given graph class. However, we give a criterion for termination: our algorithm terminates whenever G ${\mathscr{G}}$ is locally checkable of bounded maximum degree and U ${\mathscr{U}}$ is a finite set of connected graphs. For example, l $l$‐regular graphs, l $l$‐colourable graphs, and H $H$‐free graphs are locally checkable classes. We put special emphasis on the case that G ${\mathscr{G}}$ is the class of cubic graphs and tailor the algorithm to this case. In particular, we introduce the new concept of high‐degree‐first path‐decompositions, which enables highly efficient pruning techniques. We exploit our framework to prove a new lower bound on the path‐width of cubic graphs. Moreover, we determine the extremal girth values of cubic graphs of path‐width k $k$ for all k∈{3,...,10} $k\in \{3,\ldots ,10\}$ and all smallest graphs which take on these extremal girth values. Further, we present a new constructive characterisation of the extremal cubic graphs of path‐width 3 and girth 4. [ABSTRACT FROM AUTHOR]

Given a graph G$$ G $$ of degree k$$ k $$ over n$$ n $$ vertices, we consider the problem of computing a near maximum cut or a near minimum bisection in polynomial time. For graphs of girth 2L$$ 2L $$, we develop a local message passing algorithm whose complexity is O(nkL)$$ O(nkL) $$, and that achieves near optimal cut values among all L$$ L $$‐local algorithms. Focusing on max‐cut, the algorithm constructs a cut of value nk/4+nP⋆k/4+err(n,k,L)$$ nk/4+n{P}_{\star}\sqrt{k/4}+\mathsf{err}\left(n,k,L\right) $$, where P⋆≈0.763166$$ {P}_{\star}\approx 0.763166 $$ is the value of the Parisi formula from spin glass theory, and err(n,k,L)=on(n)+nok(k)+nkoL(1)$$ \mathsf{err}\left(n,k,L\right)={o}_n(n)+n{o}_k\left(\sqrt{k}\right)+n\sqrt{k}{o}_L(1) $$ (subscripts indicate the asymptotic variables). Our result generalizes to locally treelike graphs, that is, graphs whose girth becomes 2L$$ 2L $$ after removing a small fraction of vertices. Earlier work established that, for random k$$ k $$‐regular graphs, the typical max‐cut value is nk/4+nP⋆k/4+on(n)+nok(k)$$ nk/4+n{P}_{\star}\sqrt{k/4}+{o}_n(n)+n{o}_k\left(\sqrt{k}\right) $$. Therefore our algorithm is nearly optimal on such graphs. An immediate corollary of this result is that random regular graphs have nearly minimum max‐cut, and nearly maximum min‐bisection among all regular locally treelike graphs. This can be viewed as a combinatorial version of the near‐Ramanujan property of random regular graphs. [ABSTRACT FROM AUTHOR]

How efficiently can we find an unknown graph using distance queries between its vertices? We assume that the unknown graph is connected, unweighted, and has bounded degree. The goal is to find every edge in the graph. This problem admits a reconstruction algorithm based on multi‐phase Voronoi‐cell decomposition and using Õ(n3/2)$$ \overset{\widetilde }{O}\left({n}^{3/2}\right) $$ distance queries. In our work, we analyze a simple reconstruction algorithm. We show that, on random Δ$$ \Delta $$‐regular graphs, our algorithm uses Õ(n)$$ \overset{\widetilde }{O}(n) $$ distance queries. As by‐products, with high probability, we can reconstruct those graphs using log2n$$ {\log}^2n $$ queries to an all‐distances oracle or Õ(n)$$ \overset{\widetilde }{O}(n) $$ queries to a betweenness oracle, and we bound the metric dimension of those graphs by log2n$$ {\log}^2n $$. Our reconstruction algorithm has a very simple structure, and is highly parallelizable. On general graphs of bounded degree, our reconstruction algorithm has subquadratic query complexity. [ABSTRACT FROM AUTHOR]

Summary: Array‐unit dual‐usage register is a kind of register resource that can be read or written as a whole or individually. It is mainly configured in processors with SIMD processing units and provides register‐level speed data transfer between the scalar and vector processing units. To improve the efficiency of algorithms by using an array‐unit dual‐usage register, we investigate in this article the problem of adapting register allocation to code containing array‐unit dual‐usage register names. We propose a corresponding global register allocation method by combining the allocation of regular registers with array‐unit dual‐usage register, ensuring that the names of array‐unit dual‐usage register can be used in the input code of register allocation. Moreover, we present the processing framework of this method and the specific algorithms of some related vital aspects and demonstrate the working principles of the algorithms by an example. Experimental studies were conducted on a platform based on the FT‐M7002 DSP core, and showing that our register allocation method can effectively handle codes containing array‐unit dual‐usage register names and support relevant application algorithms to improve their data transfer scheme. For some typical algorithms with input matrix, substantial performance improvements of twofold or higher are achieved. [ABSTRACT FROM AUTHOR]

Summary: The growing need for extracting information from large graphs has been pushing the development of parallel graph algorithms. However, the highly irregular structure of the real‐world graphs limits the performance and energy improvements of graph applications. In this paper, we show that, in most cases, using all the available cores of the multiprocessor is not the best option in terms of the aforementioned non‐functional requirements. Based on that, we propose GraphKat, a framework that enables the simultaneous processing of several algorithms/graphs instead of executing them serially (i.e., one after another), increasing efficiency in terms of performance and energy. GraphKat works in two steps: (i) it characterizes the graph applications with a specific number of threads based on their efficiency levels; and (ii) it defines the execution order of all graph applications in the target system. Experimental results on three multicore processors (Intel and AMD) show that GraphKat improves the overall system's efficiency related to performance (up to 434.26×$$ 434.26\times $$) and energy‐saving (up to 245.21×$$ \times $$), and reduces the graph applications' execution time (up to 17.70×$$ 17.70\times $$) and energy consumption (up to 6.64×$$ \times $$) compared to the default execution of parallel applications on HPC systems. [ABSTRACT FROM AUTHOR]

Most prior multimodal transport networks have been organized as relational databases with multilayer structures to support transport management and routing; however, database expandability and update efficiency in new networks and timetables are low due to the strict database schemas. This study aimed to develop multimodal transport networks using a graph database that can accommodate efficient updates and extensions, high relation‐based query performance, and flexible integration in multimodal routing. As a case study, a database was constructed for London transport networks, and routing tests were performed under various conditions. The constructed multimodal graph database showed stable performance in processing iterative queries, and efficient multi‐stop routing was particularly enhanced. By applying the proposed framework, databases for multimodal routing can be readily constructed for other regions, while enabling responses to diversified routings, such as personalized routing through integration with various unstructured information, due to the flexible schema of the graph database. [ABSTRACT FROM AUTHOR]

The above article from IET Communications, published online on 31 October 2022 in Wiley Online Library (wileyonlinelibrary.com), has been retracted by agreement between the Interim Editor‐in‐Chief, Jian Ren, the Institution of Engineering and Technology (the IET) and John Wiley and Sons Ltd. This article was published as part of a Guest Edited special issue. Following an investigation, the IET and the journal have determined that the article was not reviewed in line with the journal's peer review standards and there is evidence that the peer review process of the special issue underwent systematic manipulation. Accordingly, we cannot vouch for the integrity or reliability of the content. As such we have taken the decision to retract the article. The authors have been informed of the decision to retract. [ABSTRACT FROM AUTHOR]

Motivated by the study of greedy algorithms for graph coloring, we introduce a new graph parameter, which we call weak degeneracy. By definition, every d $d$‐degenerate graph is also weakly d $d$‐degenerate. On the other hand, if G $G$ is weakly d $d$‐degenerate, then χ(G)≤d+1 $\chi (G)\le d+1$ (and, moreover, the same bound holds for the list‐chromatic and even the DP‐chromatic number of G $G$). It turns out that several upper bounds in graph coloring theory can be phrased in terms of weak degeneracy. For example, we show that planar graphs are weakly 4‐degenerate, which implies Thomassen's famous theorem that planar graphs are 5‐list‐colorable. We also prove a version of Brooks's theorem for weak degeneracy: a connected graph G $G$ of maximum degree d⩾3 $d\geqslant 3$ is weakly (d−1) $(d-1)$‐degenerate unless G≅Kd+1 $G\cong {K}_{d+1}$. (By contrast, all d $d$‐regular graphs have degeneracy d $d$.) We actually prove an even stronger result, namely that for every d⩾3 $d\geqslant 3$, there is ϵ>0 $\epsilon \gt 0$ such that if G $G$ is a graph of weak degeneracy at least d $d$, then either G $G$ contains a (d+1) $(d+1)$‐clique or the maximum average degree of G $G$ is at least d+ϵ $d+\epsilon $. Finally, we show that graphs of maximum degree d $d$ and either of girth at least 5 or of bounded chromatic number are weakly (d−Ω(d)) $(d-{\rm{\Omega }}(\sqrt{d}))$‐degenerate, which is best possible up to the value of the implied constant. [ABSTRACT FROM AUTHOR]

Finding the centrality measures of nodes in a graph is a problem of fundamental importance due to various applications from social networks, biological networks, and transportation networks. Given the large size of such graphs, it is natural to use parallelism as a recourse. Several studies show how to compute the various centrality measures of nodes in a graph on parallel architectures, including multi‐core systems and GPUs. However, as these graphs evolve and change, it is pertinent to study how to update the centrality measures on changes to the underlying graph. In this article, we show novel parallel algorithms for updating the betweenness‐ and closeness‐centrality values of nodes in a dynamic graph. Our algorithms process a batch of updates in parallel by extending the approach of handling a single update for betweenness‐ and closeness‐centrality. For the latter, we also introduce techniques based on traversals of the block‐cut tree of a graph. Besides, our algorithms incorporate mechanisms to exploit the structural properties of graphs for enhanced performance. We implement our algorithms on two parallel architectures: an Intel 24‐core CPU and an Nvidia Tesla V100 GPU. To the best of our knowledge, we are the first to show GPU algorithms for the above two problems. In addition, we conduct detailed experiments to study the impact of various parameters associated with our algorithms and their implementation. Our results on a collection of real‐world graphs indicate that our algorithms achieve a significant speedup over corresponding state‐of‐the‐art algorithms. [ABSTRACT FROM AUTHOR]

Given the growth of uncertainty in the real world, analysing probabilistic graphs is crucial. Clustering is one of the most fundamental methods of mining probabilistic graphs to discover the hidden patterns in them. This survey examines an extensive and organized analysis of the clustering techniques of large probabilistic graphs proposed in the literature. First, the definition of probabilistic graphs and modelling them are introduced. Second, the clustering of such graphs and their challenges, such as uncertainty of edges, high dimensions, and the impossibility of applying certain graph clustering techniques directly, are expressed. Then, a taxonomy of clustering approaches is discussed in two main categories: threshold‐based and possible worlds‐based methods. The techniques presented in each category are explained and examined. Here, these methods are evaluated on real datasets, and their performance is compared with each other. Finally, the survey is summarized by describing some of the applications of probabilistic graph clustering and future research directions. [ABSTRACT FROM AUTHOR]

One of the most important and costly stages in software development is maintenance. Understanding the structure of software will make it easier to maintain it more efficiently. Clustering software modules is thought to be an effective reverse engineering technique for deriving structural models of software from source code. In software module clustering, the most essential objectives are to minimize connections between produced clusters, maximize internal connections within created clusters, and maximize clustering quality. Finding the appropriate software system clustering model is considered an NP‐complete task. The previously proposed approaches' key limitations are their low success rate, low stability, and poor modularization quality. In this paper, for optimal clustering of software modules, Chaotic based heuristic method using a forest optimization algorithm is proposed. The impact of chaos theory on the performance of the other SFLA‐GA and PSO‐GA has also been investigated. The results show that using the logistic chaos approach improves the performance of these methods in the software‐module clustering problem. The performance of chaotic based FOA, SFLA‐GA and PSO‐GA is superior to the other heuristic methods in terms of modularization quality and stability of the results. [ABSTRACT FROM AUTHOR]

Owing to the advantages of low cost, flexibility, and the transmission characteristics of air–ground (AG) channels, using the unmanned aerial vehicle (UAV) as mobile relay to assist wireless communication has received significant interest recently. A green non‐orthogonal multiple access (NOMA)‐based multi‐UAV‐enabled relaying system with different rate requirements is proposed here. To improve energy efficiency (EE) of the UAV relays, an optimization problem for user grouping, UAV trajectory design and resource allocation under the constraints of information causality constraint, UAVs' maximum service capacity, maximum transmit power constraint, and different communication rate requirements of the mobile users (MUs) is formulated. According to the grouping results, the UAVs' trajectory and power allocation by Dinkelbach method, successive convex approximation, and condensation algorithm are alternately optimized. To solve this highly coupled non‐linear mixed integer programming problem, a graph‐based grouping algorithm is proposed to reduce the relative distance between the UAV relay and the MU. Simulation results show that the proposed optimization algorithm can effectively improve the EE performance of this NOMA‐based multi‐UAV‐enabled relaying system. [ABSTRACT FROM AUTHOR]

Summary: Sparse neural networks are shown to give accurate predictions competitive to denser versions, while also minimizing the number of arithmetic operations performed. However current GPU hardware can only exploit structured sparsity patterns for better efficiency. We propose a framework for generating structured multilevel block sparse neural networks by using the theory of graph products. Our Ramanujan bipartite graph product (RBGP) framework uses products of Ramanujan graphs to obtain the best connectivity for a given level of sparsity. This essentially ensures that the i.) the networks has the structured block sparsity for which runtime efficient algorithms exists, ii.) the model gives high prediction accuracy, due to the better expressive power derived from the connectivity of the graph, iii.) the graph data structure has a succinct representation that can be stored efficiently in memory. We use our framework to design a specific connectivity pattern called RBGP4 which makes efficient use of the memory hierarchy available on GPU. We benchmark our approach on image classification and machine translation tasks with an edge (Jetson Nano 2GB) as well as server (V100) GPUs. When compared with commonly used sparsity patterns like unstructured and block, we obtain significant speedups while achieving the same level of accuracy. [ABSTRACT FROM AUTHOR]

An independent set of a graph is a subset of the nodes such that no two nodes in it are adjacent. The maximum independent set (MIS) problem is an optimization problem to find a largest independent set. The main contribution of this article is to introduce a generic iterative trial search algorithm that we call iMIS for finding approximate solutions for the MIS problem. The generic algorithm iMIS is designed so that it can be implemented to run on GPUs very efficiently. Since the performance of the algorithm varies depending on its search strategy, we present a hybrid algorithm that combines three strategies of the iMIS such that best one of them for an input graph is automatically selected. We have implemented our hybrid algorithm to run on a multi‐GPU server with eight NVIDIA A100 GPUs. And evaluated the performance for 66 DIMACS benchmark graphs and 78 random graphs with up to 256M nodes. We have also evaluated the performance of three previously published algorithms for the MIS problem and an approach using Gurobi linear programming solver. The experimental results show that our hybrid algorithm can find larger independent sets for all 144 graphs compared to other methods. [ABSTRACT FROM AUTHOR]

Extracting robust feature representation is one of the key challenges for person re‐identification (ReID) task. Although convolution neural network (CNN)‐based methods have achieved great success, they still cannot handle the part occlusion and misalignment caused by limited receptive field. Recently, pure transformer models have shown its power in the person ReID task. However, current transformer models adopt patches of equal‐scale as input, and cannot solve the problem of cross‐scale interaction properly. To overcome this problem, an adaptive cross‐scale transformer from a perspective of the graph signal, named ACSFormer, is proposed. Specifically, the self‐attention module is first treated as an undirected fully connected graph. And then, "node variation" is introduced as an indicator to adaptively merge neighbourhood tokens. To the best of the authors' knowledge, their ACSFormer is the first work to attempt to combine pure transformers and graph signal processing in the field of person ReID. Extensive evaluations are conducted on three person ReID datasets to validate the performance of ACSFormer. Experiments demonstrate that this ACSFormer performs on par with state‐of‐the‐art CNN‐based methods and consistently improves transformer‐based baseline, for example, surpassing ViT‐baseline by 2.5%, 2.7% and 4.8% mAP on Market1501, DukeMTMC‐reID and MSMT17, respectively. [ABSTRACT FROM AUTHOR]

Knowledge graphs are a key technique for linking and integrating cross‐domain data, concepts, tools, and knowledge to enable data‐driven analytics. As much of the world's data have become massive in size, visualizing graph entities and their interrelationships intuitively and interactively has become a crucial task for ingesting and better utilizing graph content to support semantic reasoning, discovering hidden knowledge discovering, and better scientific understanding of geophysical and social phenomena. Despite the fact that many such phenomena (e.g., disasters) have clear spatial footprints and geographic properties, their location information is considered only as a textual label in existing graph visualization tools, limiting their capability to reveal the geospatial distribution patterns of the graph nodes. In addition, most graph visualization techniques rely on 2D graph visualization, which constrains the dimensions of information that can be presented and lacks support for graph structure examination from multiple angles. To tackle the above challenges, we developed a novel 3D map‐based graph visualization algorithm to enable interactive exploration of graph content and patterns in a spatially explicit manner. The algorithm extends a 3D force directed graph by integrating a web map, an additional geolocational force, and a force balancing variable that allows for the dynamic adjustment of the 3D graph structure and layout. This mechanism helps create a balanced graph view between the semantic forces among the graph nodes and the attractive force from a geolocation to a graph node. Our solution offers a new perspective in visualizing and understanding spatial entities and events in a knowledge graph. [ABSTRACT FROM AUTHOR]

The Floyd‐Warshall algorithm is the most popular algorithm for determining the shortest paths between all vertex pairs in a graph. It is a very simple and an elegant algorithm. However, for graphs without any negative weighted edges, using Dijkstra's shortest path algorithm for every vertex as a source vertex to produce all‐pairs shortest paths works significantly better than the Floyd‐Warshall algorithm, especially for large graphs. Furthermore, for graphs with negative weighted edges, with no negative cycle, in general Johnson's algorithm also performs better than the Floyd‐Warshall algorithm for large graphs. Johnson's algorithm first transforms the graph into a non‐negative one by using the Bellman‐Ford algorithm, then applies the Dijkstra's algorithm to the transformed graph. Thus, mainly, the Floyd‐Warshall algorithm is quite inefficient, especially for large graphs. In this paper, we show a simple improvement on the Floyd‐Warshall algorithm that will increases its efficiency, especially for very sparse graphs (i.e., the number of its edges is less than the number of its vertices), so it can be used instead of more complicated alternatives. We also show that our approach is also very effective for denser disconnected graphs. Since the new algorithm modifies the original Floyd‐Warshall algorithm, it is mainly aimed for directed graphs without negative cycles. Most programmers prefer to implement the Floyd‐Warshall algorithm over more complicated but more efficient alternatives for solving all‐pairs shortest path problems. In this work, we show that without the addition of any complicated data structures, the performance of the Floyd‐Warshall algorithm can be improved very easily. Our practical approach works even better than its alternatives for large sparse graphs. [ABSTRACT FROM AUTHOR]