Performance of Graph Neural Networks for Point Cloud Applications
Graph Neural Networks (GNNs) have gained significant momentum recently due to
their capability to learn on unstructured graph data. Dynamic GNNs (DGNNs) are
the current state-of-the-art for point cloud applications; such applications
(viz. autonomous driving) require real-time processing at the edge with tight
latency and memory constraints. Conducting performance analysis on such DGNNs,
thus, becomes a crucial task to evaluate network suitability.
  This paper presents a profiling analysis of EdgeConv-based DGNNs applied to
point cloud inputs. We assess their inference performance in terms of
end-to-end latency and memory consumption on state-of-the-art CPU and GPU
platforms. The EdgeConv layer has two stages: (1) dynamic graph generation
using k-Nearest Neighbors (kNN) and, (2) node feature updation. The addition of
dynamic graph generation via kNN in each (EdgeConv) layer enhances network
performance compared to networks that work with the same static graph in each
layer; such performance enhancement comes, however, at the added computational
cost associated with the dynamic graph generation stage (via kNN algorithm).
Understanding its costs is essential for identifying the performance bottleneck
and exploring potential avenues for hardware acceleration. To this end, this
paper aims to shed light on the performance characteristics of EdgeConv-based
DGNNs for point cloud inputs. Our performance analysis on a state-of-the-art
EdgeConv network for classification shows that the dynamic graph construction
via kNN takes up upwards of 95% of network latency on the GPU and almost 90% on
the CPU. Moreover, we propose a quasi-Dynamic Graph Neural Network (qDGNN) that
halts dynamic graph updates after a specific depth within the network to
significantly reduce the latency on both CPU and GPU whilst matching the
original networks inference accuracy.
Dhruv Parikh, Bingyi Zhang, Rajgopal Kannan, Viktor Prasanna, Carl Busart
# Performance of Graph Neural Networks for Point Cloud Applications

###### Abstract

Graph Neural Networks (GNNs) have gained significant momentum recently due to their capability to learn on unstructured graph data. Dynamic GNNs (DGNNs) are the current state-of-the-art for point cloud applications; such applications (viz. autonomous driving) require real-time processing at the edge with tight latency and memory constraints. Conducting performance analysis on such DGNNs, thus, becomes a crucial task to evaluate network suitability.

This paper presents a profiling analysis of EdgeConv-based DGNNs applied to point cloud inputs. We assess their inference performance in terms of end-to-end latency and memory consumption on state-of-the-art CPU and GPU platforms. The EdgeConv layer has two stages: (1) dynamic graph generation using \(k\)-Nearest Neighbors (\(k\)NN) and, (2) node feature updation. The addition of dynamic graph generation via \(k\)NN in each (EdgeConv) layer enhances network performance compared to networks that work with the same static graph in each layer; such performance enhancement comes, however, at the added computational cost associated with the dynamic graph generation stage (via \(k\)NN algorithm). Understanding its costs is essential for identifying the performance bottleneck and exploring potential avenues for hardware acceleration. To this end, this paper aims to shed light on the performance characteristics of EdgeConv-based DGNNs for point cloud inputs. Our performance analysis on a state-of-the-art EdgeConv network for classification shows that the dynamic graph construction via \(k\)NN takes up upwards of \(95\%\) of network latency on the GPU and almost \(90\%\) on the CPU. Moreover, we propose a quasi-Dynamic Graph Neural Network (qDGNN) that halts dynamic graph updates after a specific depth within the network to significantly reduce the latency on both CPU and GPU whilst matching the original networks inference accuracy.

 Graph neural network, point cloud, \(k\)-nearest neighbors, dynamic graph construction, performance profiling

## I Introduction

Graphs are effective data structures for representing intricate relationships (edges) among entities (nodes) with a high degree of interpretability. This has led to the widespread adoption of graph theory in various domains.

Notably, Graph Neural Networks (GNNs) [1] have demonstrated remarkable success in addressing both conventional tasks like computer vision [2, 3] and natural language processing [4, 5], as well as non-traditional tasks such as protein interface prediction [6] and combinatorial optimization [7]. This versatility has made GNNs an integral part of deep learning methodologies, as evidenced by their numerous applications across diverse problem domains [1, 8].

A point cloud is an unstructured collection of raw data points, where each point represents a specific location associated with an object or shape, typically defined within a coordinate system (such as Cartesian or spherical). The ability of a point cloud to capture 3D environments make it crucial for numerous scene understanding tasks [9, 10] and applications across various domains. For instance, point clouds play a vital role in autonomous driving [11, 12], virtual reality [13], augmented reality [14], construction industry [15], robotics, computer graphics, and many more. The availability of affordable and accessible point cloud acquisition systems, such as LIDAR scanners and RGBD cameras [16], has further emphasized the importance of efficient learning and processing techniques for point clouds.

Prior to the advent of deep learning-based methods, learning on point clouds involved constructing hand-crafted features [17]. With the introduction of deep learning, the techniques applied to point clouds can be broadly classified into two categories. These two categories are differentiated based on the pre-processing steps performed on the point clouds prior to network input [18]: (1) _Structured-grid based networks:_ These networks preprocess point clouds into a structured input format for the deep neural network. Structuring is typically achieved by generating representative views from the point clouds [19, 20, 21] or by voxelizing the point clouds into 3D grids [22]. (2) _Raw point cloud based networks:_ In this category, networks operate directly on the raw point clouds with minimal to no preprocessing. One approach involves passing multi-layer perceptrons (MLPs) through individual point features to learn local spatial relationships [23, 24, 25]. Another approach involves systematically constructing graphs using point features and applying Graph Neural Networks (GNNs) to learn labels [26, 27, 28].

Structured-grid based networks suffer from drawbacks associated with point cloud transformation. Transforming point clouds into voxels or image views can be computationally expensive and result in bulky data that is difficult to handle. Moreover, these transformations introduce various errors, such as quantization errors, which can impact the inherent properties of point clouds [23]. To address these issues, raw point cloud based networks have emerged as a solution. Among these networks, EdgeConv based networks [26, 29, 30] have become state-of-the-art in various point cloud-related tasks. They are an advancement over the basic PointNet [23] style architectures that directly operate on point features. The EdgeConv layer excels in learning local features and relationships within point clouds while maintaining permutation
invariance [31]. The dynamic graph construction in the learned feature space allows EdgeConv to capture semantic similarities between points, regardless of their geometric separation. By leveraging these strengths, EdgeConv-based networks have shown remarkable performance in tasks involving point clouds, overcoming the limitations associated with structured-grid based approaches.

Point cloud processing finds significant application in autonomous vehicles, which serves as a prominent use case for edge computing. These applications operate under stringent latency and memory constraints [32]. In intelligent visual systems within autonomous vehicles, point cloud processing typically constitutes just one stage within a multi-stage compute pipeline. As a result, the imposed constraints on latency and memory become even more critical and imperative to address [33].

Analyzing and profiling the performance of networks that process point clouds is a crucial task, particularly considering the prominence of EdgeConv-based networks in this domain. In this work, we make the following contributions:

* **Latency analysis:** We perform an in-depth analysis of end-to-end layer-wise latency for EdgeConv-based networks used in classification and segmentation tasks on both state-of-the-art CPU and GPU platforms.
* **Breakdown analysis:** Given the two-stage operation of the EdgeConv layer involving (1) dynamic graph construction and (2) GNN-based node feature updation, we perform breakdown analysis between \(k\)NN graph construction and GNN-based feature updating at each layer and across different layers in EdgeConv networks.
* **Effects of varying \(k\):** EdgeConv networks dynamically construct a graph from a point cloud using the \(k\)-nearest neighbors (\(k\)NN) algorithm. We study the effects of varying the value of \(k\) from its optimal value, which is determined through a validation set. This analysis examines the impact of varying \(k\) on the network's inference accuracy, inference latency, and memory consumption.
* **Quasi-Dynamic GNNs:** Dynamic graph construction after each layer in a Dynamic GNN (DGNN) improves its performance compared to static GNN counterparts. We investigate the extent to which performance improvement is affected when employing a quasi-Dynamic strategy, where the graph is made static towards the end of the network.
* **Memory consumption:** We analyze the memory consumption of EdgeConv networks on both CPU and GPU platforms.
* **Bottleneck analysis:** By identifying performance bottleneck in the aforementioned networks, we suggest potential research directions that could help mitigate such bottlenecks and improve overall performance.
* **Hardware acceleration opportunities:** We discuss the potential for hardware acceleration of EdgeConv-based networks on FPGA devices, which has garnered significant research interest due to its promising benefits.

Our aim is to deepen our understanding of EdgeConv-based networks' performance characteristics when processing point clouds and provide insights into optimization opportunities and hardware acceleration possibilities.

Section II briefly introduces GNNs and GNNs as they relate to point clouds. Section III describes the networks and datasets used for the experiments, along with the computing platforms on which the experiments were performed. Results are analyzed in section IV. Discussion and conclusion follow in section V and VI respectively.

## II Background

### _Graph Neural Networks (GNNs)_

Graphs \(\mathcal{G}=(\mathcal{V},\mathcal{E})\) are defined via a set of vertices (nodes) \(\mathcal{V}\) and a set of edges (links) connecting these vertices, \(\mathcal{E}=\{(j,i):j,i\in\mathcal{V}\text{ and a link exists from }j\to i\}\). Edges typically have directional context, symbolized via the ordered pairs; an undirected edge between nodes \(i\) and \(j\) is represented often via two directed edges: \((i,j)\) and \((j,i)\). \(\mathbf{A}\in\mathbb{R}^{n\times n}\) is the adjacency matrix for a graph with \(n\) nodes representing the above edges and their weights (for a weighted graph).

A graph can have features associated with both its nodes and edges - additionally, a graph may even have global graph level attributes. Typical learning tasks on graphs occur at either the node level (viz. node classification) [34], edge level (viz. link prediction) [35] or at the graph level [36].

Neural message passing is a mechanism in GNNs whereby information is passed (shared) across nodes and edges within the graph to update node embeddings via a set of learnable parameters [37]. GNNs employing this message passing framework are called Message Passing Neural Networks (MPNNs) [37].

For a node \(i\) with a node feature vector \(\mathbf{x_{i}}\) and a neighbor set \(\mathcal{N}(i)\), the general formulation for message passing can be described by Equation 1[37] (illustrated in Figure 1),

\[\mathbf{x^{{}^{\prime}}_{i}}=\Psi_{\Theta}(\mathbf{x_{i}},\sum_{j\in\mathcal{N}(i)} \mathcal{M}_{\Phi}(\mathbf{x_{i}},\mathbf{x_{j}},\mathbf{e_{ji}})). \tag{1}\]

The above equation can be decomposed into the following stages:

* **Message generation.** A message is constructed between a node \(i\) and its neighbor \(j\) using node level features \(\mathbf{x_{i}}\) and \(\mathbf{x_{j}}\) and edge level feature \(\mathbf{e_{ji}}\) as \(\mathcal{M}_{\Phi}(\mathbf{x_{i}},\mathbf{x_{j}},\mathbf{e_{ji}})\).

Fig. 1: The message passing mechanism employed in GNNs.
* **Aggregation.** Such constructed messages from all of the nodes neighbors are aggregated via the aggregation function \(\sum_{j\in\mathcal{N}(i)}\); the aggregation function \(\sum\) is typically permutation invariant for point cloud applications.
* **Updation.** Finally, the aggregated message along with \(\mathbf{x_{i}}\) is used to learn the feature update for node \(i\), \(\mathbf{x_{i}}^{\prime}\) via the function \(\Psi_{\Theta}\).

For a given layer, such message-aggregate-update paradigm is applied to all the nodes of the graph with parameters \((\Theta,\Phi)\) shared across all the nodes within a layer. The functions \(\mathcal{M}_{\Phi}\) and \(\Psi_{\Theta}\) are typically multi-layer perceptrons (\(\mathcal{MLP}\)s).

Such GNN layers, employing the message passing framework to update the node features, as above, are central to GNNs such as Graph Convolutional Network (GCN) [1], GraphSAGE [38], Graph Isomorphism Network (GIN) [39], Graph Attention Network (GAN) [40], Principal Neighborhood Aggregation (PNA) [41], etc.

EdgeConv layer [26] also utilizes this message passing paradigm - however, unlike the above networks, each EdgeConv layer first performs dynamic graph construction via a \(k\)-nearest neighbor (\(k\)NN) algorithm to construct a \(k\)NN graph; a \(k\)NN graph is a directed graph in which each node is connected to its \(k\) nearest neighboring nodes via edges (Figure 2). Then, the EdgeConv layer performs message passing within this \(k\)NN graph to update the node embeddings.

### _GNNs for Point Clouds_

The authors in PointNet [23] introduced the notion of ingesting raw, unordered point clouds to learn directly on the associated point level features. This network, at its core, passes each point level feature vector through a shared \(\mathcal{MLP}\) to update the point features. In the message passing framework,

\[{\mathbf{x_{i}}^{\prime}}=\Psi_{\Theta}(\mathbf{x_{i}}) \tag{2}\]

Essentially, no messages are passed and no aggregations occur - it directly updates all the node embeddings. The final layer is a global-level max pool layer which generates a global feature vector for graph level tasks. Due to the shared \(\mathcal{MLP}\) and global max pool layer, such a network is fully invariant to permutations in the ordering of the \(n\) input points. This permutation invariance is a key characteristic of GNNs despite the PointNet not traditionally being a graph neural network.

A class of PointNet derivative networks [42, 43, 44, 45] use associated approaches to learn directly from the point features. EdgeConv layer uses both message passing and dynamic graph construction, as shown in Figure 2, to reach state-of-the-art results for point cloud applications. The message passing paradigm in EdgeConv can be described as below, by (3),

\[{\mathbf{x_{i}}^{\prime}}=\sum_{j\in\mathcal{N}(i)}\mathcal{M}_{\Phi}(\mathbf{x_{i}}, \mathbf{x_{j}}-\mathbf{x_{i}}) \tag{3}\]

\[\sum\rightarrow\max(.) \tag{4}\]

\[\mathcal{M}_{\Phi}(\mathbf{x},\mathbf{y})\rightarrow\mathcal{MLP}_{\Phi}(\mathbf{x}\,||\, \mathbf{y}) \tag{5}\]

where the \(\max(.)\) in (4) is channel-wise along the nodes and the \(||\) in (5) is a concatenation operation; \(\mathcal{MLP}_{\Phi}\) is a multi-layer perceptron (parameterized by \(\Phi\)) with a ReLU non-linearity.

The inclusion of the edge feature \(\mathbf{x_{j}}-\mathbf{x_{i}}\) adds local context to the updated node embedding, and the node-level feature \(\mathbf{x_{i}}\) helps the network retain global information. A single EdgeConv layer takes in an input tensor \(\mathbf{X}\in\mathbb{R}^{n\times c}\) for a point cloud with \(n\) points, each point represented by a vector node embedding of length \(c\). The output of \(k\)NN graph construction on \(\mathbf{X}\) is a tensor \(\mathbf{X}^{\prime}\in\mathbb{R}^{n\times k\times c}\) representing for each node, its \(k\) neighboring nodes and their node embeddings (feature vectors). Before passing \(\mathbf{X}^{\prime}\) through an \(\mathcal{MLP}\) layer, a nodes feature vector is subtracted from the feature vector of its neighbors (\(\mathbf{x_{j}}-\mathbf{x_{i}}\)) and concatenated to the resultant (\(\mathbf{x_{i}}\,||\,\mathbf{x_{j}}-\mathbf{x_{i}}\)). The tensor thus obtained, \(\mathbf{X_{in}^{\prime}}\in\mathbb{R}^{n\times k\times 2c}\) is passed through \(\mathcal{MLP}_{\Phi}\{2c,\,a_{1},\,a_{2},\,a_{3},\,...,\,a_{m}\}\), which is an \(m\)-layer \(\mathcal{MLP}\) with ReLU activations, to generate \(\mathbf{X_{out}^{\prime}}\in\mathbb{R}^{n\times k\times a_{m}}\) which is finally aggregated (via \(\max\)) to generate \(\mathbf{Y}\in\mathbb{R}^{n\times a_{m}}\) which is the final output from the EdgeConv layer. \(\mathcal{MLP}_{\Phi}\{1024,512,256\}\) is a \(2\)-layer perceptron; the input channels to the first layer is \(1024\), the output channels of the first layer is \(512\) and the output channels of the final (second) layer is \(256\).

## III Experimental Setting

### _Platform Details_

The performance analysis for EdgeConv is conducted on state-of-the-art GPU and CPU platforms (See Table I). The GPU used, for both training and inference, is NVIDIA RTX A6000, which has \(10,752\) NVIDIA Ampere architecture CUDA cores. The CPU utilized for inference is AMD Ryzen Threadripper 3990x with 64 CPU cores. Additionally, we use the PyTorch [46] and PyTorch Geometric [47] libraries to facilitate training and inference on the above platforms - no additional kernel-level optimization is performed.

### _Networks_

The base network that we utilize in the experiments is shown in Figure 3. This network follows the network setting in [26] that achieves state-of-the-art results on the ModelNet40 [48] graph-level classification dataset. The network comprises of four (dynamic) EdgeConv layers. Each layer constructs a \(k\)-nearest neighbor graph based on the current (latest) node embeddings before performing message passing on this graph via a single-layered \(\mathcal{MLP}\) to update the embeddings. Each

\begin{table}
\begin{tabular}{c|c c} \hline
**Platforms** & CPU & GPU \\ \hline \hline Platform & AMD Threadripper 3990x & Nvidia RTX A6000 \\ Platform Technology & TSMC 7 nm & TSMC 7 nm \\ Frequency & 2.90 GHz & 1.8 GHz \\ Peak Performance & 3.7 TFLOPS & 38.7 TFLOPS \\ On-chip Memory & 256 MB L3 cache & 6 MB L2 cache \\ Memory Bandwidth & 107 GB/s & 768 GB/s \\ \hline \end{tabular}
\end{table} TABLE I: Specifications of platforms
\(\mathcal{MLP}\) in the EdgeConv layer utilizes a ReLU activation and includes a BatchNorm layer. The final \(\mathcal{MLP}\) uses a dropout layer instead of BatchNorm.

We train the above network for a range of \(k\) values (\(5\), \(10\), \(15\), \(20\), \(25\), \(30\)) for the EdgeConv layer. Additionally, we also train two quasi-Dynamic variants of such Dynamic GNNs by making static the last and the last two EdgeConv layers, respectively. Making static an EdgeConv layer, here, refers to removing the dynamic graph generating \(k\)NN block from an EdgeConv layer. In such quasi-DGNNs, we perform dynamic graph construction in each of the initial few EdgeConv layers of the network that form the dynamic portion of the network. The latter EdgeConv layers of the network (with the \(k\)NN block removed) do not reconstruct the graph again - this static portion of the network directly uses the last graph that was constructed in the dynamic portion of the network. We thus refer to dynamic EdgeConv layers (with \(k\)NN block) as Dynamic EdgeConv (DEC) and non-dynamic ones (without the \(k\)NN block) as simply EdgeConv (EC). Specifically, the last and the last two DEC layers of the network in Figure 3 are converted to EC layers to analyze the performance of quasi-DGNNs.

All the above networks are trained for a total of \(100\) epochs on the entire ModelNet40 training dataset - we use the Adam optimizer [49] with a learning rate of \(0.001\) and a step learning rate scheduler with a gamma of \(0.5\) and a step size of \(20\).

### _Datasets_

We utilize the ModelNet40 [48] dataset which contains \(12,311\) graphs. We split the entire dataset into 80% for training and 20% for testing. The dataset comprises 3D point clouds in the form of CAD models from 40 categories - we pre-process the dataset by centering it and scaling it to a range of \((-1,1)\). Additionally, we sample \(1024\) points during both training and testing. We test using a fixed random seed for reproducibility and equivalence across the tested networks.

### _Performance Metrics_

We utilize classification accuracy as the performance metric. Since point cloud applications are usually real-time, we give importance to latency and memory consumption figures while assessing the networks performance. To this extent, we perform an exhaustive analysis of how latency and memory usage are distributed across a DGNN and within a DEC layer to identify valid performance trade-offs and bottlenecks.

## IV Results and Analysis

### _Baseline Model Latency Analysis_

The baseline latency analysis is performed on a fully dynamic network (with all EdgeConv layers as Dynamic EdgeConv) (Figure 3) with \(k=20\). The value of \(k\) is obtained by cross-validation over a set of values \((5,10,15,20,25,30)\). For cross-validation, we split the training data into a train and validation set. Once a value of \(k\) is selected, we re-train the network over the entire training data.

Figure 4 contains Figure 4(a)(i) and 4(a)(ii) that show the distribution of latency across all the layers of the network shown in Figure 3 on GPU and CPU, respectively.

Figures 4(b)(i) and 4(b)(ii) contain the per-layer latency analysis and latency distribution within the DEC layers for GPU and CPU, respectively. These figures indicate that the dynamic graph construction via the \(k\)NN algorithm is the bottleneck driving down the networks (and the DEC layers) performance.

### _Analysis Under Varying \(k\)_

We analyze the effect of varying the number of nearest neighbors on the performance of the DEC layer and the point cloud classification model - we first train the network in Figure 3 for different values of \(k\) associated with its DEC layers and then perform inference latency and accuracy analysis. As seen in Figure 5(a), the performance drops as we move away from the optimal \(k\), this performance drop is sharper as we move towards the origin (towards smaller and smaller \(k\)'s). The network latency, for all \(k\) values, on both CPU and GPU, is again dominated by the \(k\)NN algorithm.

### _Quasi-Dynamic GNN (qDGNN)_

Dynamic GNNs improve upon the performance of basic GNNs - this is markedly so for point cloud applications where DGNNs have the added capability of being able to identify and learn from semantically similar points irrespective of their geometric similarity (distance). Such DGNNs, however, as already seen, have a large computational cost linked to the dynamic graph construction operation which effectively bottlenecks the networks performance.

Fig. 2: Illustration of the EdgeConv layer. A point cloud (blue) is the input to the EdgeConv layer. EdgeConv layer uses \(k\)NN to generate a directed \(k\)NN graph. The message passing paradigm, applied to this graph, uses a nodes neighbors to update node embeddings (message passing: red lines, node feature updates: green dots). The output of the EdgeConv layer is the point cloud with updated node features (green).
Figure 6(a) clearly shows that making static the latter dynamic layers does not affect the networks accuracy - the corresponding performance gains associated with such Quasi-Dynamic GNNs are indicated in Figure 6(b), 6(c)(i) and 6(c)(ii) which show a drastic speed-up when compared against the fully dynamic baseline. This suggests that we can reach state-of-the-art performance, whilst being fast enough to operate at the edge, by utilizing a combination of dynamic and static EdgeConv layers for point clouds.

### _Memory Consumption_

As an example, the memory consumed for the \(k\)NN operation is plotted in Figure 7; however, it is important to note that from a memory consumption point of view, the \(k\)NN graph construction operation is not a bottleneck - several other operators take up a much larger memory footprint compared to \(k\)NN. The linear nature of the curves is also self-explanatory, increase in \(k\) leads to a proportional increase in memory required to serve the \(k\)NN operator. Meanwhile, removing \(k\)NN from latter layers of the network (DEC \(\rightarrow\) EC) directly leads to a proportional reduction in memory consumption.

Fig. 4: Latency analysis of the baseline model. 4(a)(i) and 4(a)(ii) show the layer-wise latency (per-graph instance inference level) on GPU and CPU. DEC_2, for example, indicates the second DEC layer in Figure 3. 4(b)(i) and 4(b)(ii) analyze the individual DEC layers (comparing \(k\)NN vs update latency for each). Note that the EdgeConv layer refers to a DynamicEdgeConv layer.

Fig. 5: Accuracy and latency analysis under varying \(k\) values. 5(a) shows the variation of accuracy with \(k\). 5(b), 5(c)(i) and 5(c)(ii) show the latency variation and distribution, respectively, versus \(k\). The \(update\) legend in 5(c)(i) and 5(c)(ii) is related to the message passing layer of the Dynamic EdgeConv layer.

Fig. 3: Network utilized in the experiment (for classification task). The input point cloud of shape \(n\times 3\) (\(n\) nodes with each node having \(3\) features) is transformed by four successive Dynamic EdgeConv (DEC) layers. The Dynamic suffix underscores the graph construction that occurs in each EdgeConv layer via the \(k\)NN algorithm. The output of each DEC layer is concatenated to shape \(n\times 320\), before being passed through a linear transformation that yields a \(n\times 1024\) shaped output. A global max pool layer reduces this output to a vector of size \(1024\) that is then passed through an MLP and a log-softmax layer to finally output the class log-probability vector.
## V Discussion

The experimental results show the significant bottleneck introduced by the dynamic graph construction \(k\)NN layer in point cloud processing networks. \(k\)NN operation occupies up to \(95\%\) latency of the (base) network on GPU and close to \(90\%\) on CPU. Despite this, such a layer is crucial in boosting the network performance to enable a wide array of complex real-world edge applications. In this paper, we shed light on this problem whilst also providing a simple solution - quasi-Dynamic Graph Neural Networks (qDGNN). Such networks significantly improve the latency of the network (reduction in latency by up to \(58\%\) on GPU and up to \(69\%\) on CPU) whilst maintaining the same level of performance as is demonstrated by DGNNs. Accelerating \(k\)NN layers on FPGA and deploying the DGNN on an FPGA platform is also a potential solution that has attracted significant research interest recently [50, 51]; optimizing \(k\)NN algorithms [52] is also an area that has been studied with much interest.

## VI Conclusions and Future Work

In this paper, we examined the latency bottleneck associated with a DynamicEdgeConv (EdgeConv) layer whilst examining its inference performance - optimizing the dynamic graph construction stage in such networks is a problem that remains to be solved and a promising research avenue due to its scope of applicability.

## Acknowledgement and Statement

This work is supported by the DEVCOM Army Research Lab (ARL) under grant W911NF2220159.

**Distribution Statement A**: Approved for public release. Distribution is unlimited.
