Improving In-Network Computing in IoT Through Degeneracy

TL;DR

This paper introduces a new approach to in-network computing in IoT by leveraging degeneracy, which involves multiple network options to optimize performance metrics like delay and energy consumption.

Contribution

It proposes a novel degeneracy concept for INC, along with an efficient algorithm to identify multiple functional alternatives, enhancing computation success rates.

Findings

Significant improvement in successful computation rate

Ability to meet delay and energy constraints

Effective exploitation of network degeneracy

Abstract

We present a novel way of considering in-network computing (INC), using ideas from statistical physics. We define degeneracy for INC as the multiplicity of possible options available within the network to perform the same function with a given macroscopic property (e.g. delay). We present an efficient algorithm to determine all these alternatives. Our results show that by exploiting the set of possible degenerate alternatives, we can significantly improve the successful computation rate of a symmetric function, while still being able to satisfy requirements such as delay or energy consumption.

Equations

$$f(x_S)=g^{\Pi (S)}(f(x_{s_1}),\dots ,f(x_{s_k})).$$

$$g_W(G,X,Y,f,d)=|\{H(G,X,Y,f,d)\}|,$$

$$B_{n+1}=\sum _{k=0}^n\left(\genfrac{}{}{0ex}{}{n}{k}\right)B_n,$$

$$r(H_a,H_b)=\{\begin{array}{l}1\text{, if }{U}_a\cap U_b=X\cup Y,\\ 0\text{, otherwise.}\end{array}$$

$$R(G,Y,f)=\frac{1}{|\{X\}|}\sum _{\{X\}}\frac{1}{N_X}\underset{i\ne j}{\sum _{\{H_i,H_j\}}}r(H_i,H_j),$$

$$P_{f_i}=P_{c_i}\cdot (1-{\alpha }_i),$$

$$P_{S_c}=\prod _{i\in U}(1-P_{f_i}),$$

Full text

I Introduction

Internet of Things (IoT) networks perform actions or make decisions powered by access to raw or processed data gathered by spatially distributed “things”. Distributed in-network computation (INC) approaches, i.e. the processing of raw data within the IoT network, are becoming increasingly popular in that they can potentially achieve higher energy efficiency, lower computational delay, and higher robustness compared to the traditional approach, which involves transmitting raw data to the sink and then performing the computation.

As IoT networks become increasingly large, their intercommunication becomes complex enough as to resemble a thermodynamic system of many interacting objects. This situation leads naturally to a physics-inspired study of their behavior using statistical mechanics and a concept known as degeneracy. Degeneracy arises from structurally different configurations of a system (microstates) having functionally similar/identical macroscopic properties (macrostates). A concise definition of degeneracy comes from a modern review of the use of the term: “degeneracy describes the ability of different structures to be conditionally interchangeable in their contribution to system functions” [1]. In the context of INC, we view these different structures as functional topologies (FT) [2]: subsets of the network which enable the computation of a distributed function. In this paper, we consider degeneracy as the multiplicity of available FTs that enable the distributed INC with a given macroscopic observable property i.e. delay.

The intended application of an IoT network usually defines the type of functions being considered. This in turn naturally defines the observables (macrostates) of interest to analyze these functions. The distributed computing literature [3, 4, 5, 6, 7] usually assumes an error free scenario, i.e. no node failures, and mainly focuses on the optimization of the computational rate and the communication cost. On the other hand, we are interested in a more realistic network setup, in which node failures do exist, and we study the impact of degenerate computation and communication paths on the success rate of the computation.

Authors like [3, 4, 5, 6, 7, 8, 9] address communication aspects of distributed in-network computation. They focus on the optimization of the communication/computation parameters, like computational complexity, energy efficiency, computational throughput and computational delay. In contrast, we focus on the degeneracy of the network by finding the multiple feasible computational graphs that satisfy a given requirement (e.g. delay), rather than a single optimal computational graph. This way, it is possible to fully harness the computational capability of the network and significantly increase the robustness of the computation, while still being able to satisfy requirements, such as delay or energy consumption. Even though the INC literature features analysis of functions ranging from distributed neural networks [8] to very complex computational frameworks like MapReduce and Dryad [5], the majority of IoT applications, however, rely on simple aggregate functions like max, min, count, sum [3]. The distributed computation of these functions is usually modeled with tree structures, e.g. Steiner trees [3, 4]. Closely related to the approach proposed in our work is the standard Steiner Tree Packing (STP) problem111The Steiner Tree Packing problem is to find the maximum number of edge-disjoint subgraphs of a given graph that connect a given set of required points. [10] and its well know relaxation, i.e. the Fractional Steiner Tree Problem. Instead of using the standard STP, we rather extend the search from minimum weight Steiner trees to all existing Steiner trees in which the sum of the weights on the links is lower than a predefined value.

The main contributions of this work are: an efficient algorithm that generates all functional topologies satisfying a given delay requirement, for any physical topology; a formal definition and calculation of degeneracy and the related concept of redundancy in terms of distributed computing over IoT networks; a comparison of degenerate INC and a traditional multi-hop scheme that selects a single graph for the computation showing that it is possible to significantly increase the probability of successful computation by exploiting degeneracy.

II Framework

We define a physical network $G=(V,E)$, as a simple graph that contains no self-edges or repeated edges, where the set of nodes $V$ represents the physical nodes in the network (e.g. sensors in an IoT network), and the set of edges $E$ represents the physical links between the nodes that can interact directly with each other. Mathematical functions, $f$, can be represented as subgraphs $H$ of the overall network which we refer to as FTs. Even though the definition of FTs is much broader [2], in terms of INC the FTs are directed, rooted trees, i.e. Steiner trees, with all edges pointing towards the root, $Y$. This root/sink node is where the result of a particular function $f$ must reach. The leaves of this in-tree are the inputs of the function, $X$. These inputs may take the form of entries in a distributed database or measurements of the environment such as temperature. The set of inputs, $x_{i}\in X$, are generated in nodes $v_{i}$.

The individual operations of a given function, $f(X)$, are mapped to specific nodes in the network. Each FT, $H$, is some subset of $U\subset V$ and $D\subset E$ in which each node and edge is involved in computing and routing $f(X)$. Multiple, unique FTs which model the same function, $f(X)$, can be chosen from the same physical topology, $G$. Any distinct FTs that perform the same calculation and result in the same observable macrostate of the network function are considered to be degenerate. The overall delay associated with a given FT is the principal macrostate of interest in this paper. We define the delay as the maximum graph distance between the sink node, $Y$, and any other node, $u\in H$. Alternative macrostates of potential interest are energy efficiency, which could be approximated by the number of edges in FT $H$, and computational throughput (number of function calculations per unit delay).

In [11], the authors made the distinction between two classes of network functions, namely divisible and indivisible. Denote a set $W=\{1,\ldots,|W|\}$ and a subset $S=\{i_{1},\ldots,i_{k}\}\subset W$, where $i_{1},<i_{2},<\ldots,<i_{k}$. Let $x_{S}$ be a set $\{x_{i_{1}},x_{i_{2}},\ldots,x_{i_{k}}\}$. A function, $f:x_{S}\rightarrow y$, is divisible if given any partition of $S$, $\Pi(S)=\{s_{1},\ldots,s_{j}\}$ of $S\subset W$, there exists a function $g^{\Pi{(S)}}$ such that for any $x_{S}$,

[TABLE]

Otherwise, $f$ is indivisible.

II-A Degeneracy of Functional Topologies

Degeneracy can be considered in terms of these two classes of network functions. We define strong degeneracy to be the multiplicity of FTs of an indivisible network function. We define weak degeneracy to be the multiplicity of FTs of divisible functions. The aggregate functions mentioned in Sec I are all examples of divisible functions. Due to the previously discussed importance of these aggregate functions for distributed computing, we focus on the aspects of weak degeneracy in this paper.

For a physical topology, $G$, a network function, $f$, and an input & output set of nodes, $X$ & $Y$, we can define weak degeneracy of the physical topology, $G$, with respect to an observable (e.g., delay, energy efficiency) as the multiplicity of FTs,

[TABLE]

with a given delay, $d$. For completeness, strong degeneracy is defined as the multiplicity of FTs on top of a physical topology $G$ with respect to an observable, with input nodes $X$, performing an indivisible function in which the sub-operations must be performed in an exact ordering, $g_{S}(G,X,Y,f,d)$.

Since $f(X)$ is divisible, we can perform the calculation using any partition $s$ of $X$ and combine the result of each subset $f(x_{s})$ in any order. Weak degeneracy of a full mesh physical topology is therefore dependent on the number of ways of partitioning a set, known as the Bell number,

[TABLE]

for a set of $n+1$ elements and $B_{0}=B_{1}=1$. It should be noted that the Bell number is an upper bound for the weak degeneracy. The weak degeneracy of a generic physical topology has to further account for the number of mappings of these partitions to a given FT. This is the number of ways we can route each partition such that the suboperation $f(x_{s_{i}})$ on partition $s_{i}$ occurs when the elements of partition $s_{i}$ intersect for the first time.

Our degeneracy analysis allows us to both identify the set of subgraphs which perform a function and to sort these with regard to observables like delay, energy efficiency or computational throughput. This insight may be used in future to improve computational throughput, computational resilience, deploy superior network configurations, or to analyze the degeneracy potential of a routing protocol, i.e., how many of the feasible FTs can a routing protocol discover.

II-B Redundancy of Functional Topologies

Degeneracy arises from structurally different FTs having functionally identical properties. We can also define redundancy in FTs, which is related to degeneracy, with two redundant FTs not sharing any common nodes or edges apart from their common $X$ and $Y$. The redundancy between two FTs, $r(H_{a},H_{b})$, is defined as

[TABLE]

We define the average redundancy,

[TABLE]

the mean over the number of FTs which are redundant to any other given FT. The sum is over all $N_{X}$ possible FTs and the set of all possible input sets, $\{X\}$. The total redundancy gives a measure of the number of ways to choose alternate FTs which bypass nodes in case of node/link failure.

II-C *Find all weakly degenerate functional

topologies*

In the context of INC, an FT describes the interactions between network nodes in the course of computing a distributed function [2]. For the INC of divisible functions FTs are Steiner trees, i.e. they include only the nodes and edges from the physical topology that are involved in the computation and/or routing of the function.

To generate an FT, consider a partition $S$ of the input set $X$. For each subset $s\in S$, the function $f$ acts on the elements in $s$ at their first meeting point node in $H$. For a subset $s=\{x_{1},x_{2}\}$, we construct paths, $p_{1}=x_{1},v_{1},\ldots,v_{i},\ldots,Y$ and $p_{2}=x_{2},u_{1},\ldots u_{k},\ldots,Y$. The sub-operation $f(x_{1},x_{2})$ occurs where these paths meet for the first time, $v_{l}=u_{k}$. Paths $p_{1}$ and $p_{2}$ must contain at least one crossing point since they have a common root at $Y$. Having met at $u_{k}=v_{l}$, the result of sub-operation $f(x_{1},x_{2})$ can be routed down either sub-path to $Y$. If there exist further subsets $s$ in the partition, these are treated in the same manner. The order in which we combine paths between any subsets, $s$, and $Y$ does not matter since $f$ is divisible.

If we consider a specific path each from $x_{1}$ and $x_{2}$ to $Y$ and take the union of the nodes and edges in each path, we generate a subgraph of $G$ rooted at $Y$ and with leaves $X$. If the union of the paths join and later diverge, one or more undirected cycles have been formed. Each independent path around the cycle results in a different FT. These FTs can be identified by finding the unique spanning trees of the cycle-containing subgraphs and removing the resulting leaves which are not inputs, $X$, since they don’t perform a computational or routing role.

We assume that $G$ is connected and there exist paths from each input node to the sink. To aid in simulation, we restrict the maximum path length (delay), $d_{\mathrm{max}}$, to the maximum graph distance between the sink and any other node, known as the eccentricity. Figure 1 depicts this process of extracting the FTs from a physical topology and Fig. 2 outlines our algorithm. Our algorithm extends the standard Steiner Tree Packing problem and its relaxation, i.e. the Fractional Steiner Tree Problem (which are known to be NP-hard [10]), by extending the search from minimum weight Steiner trees to all existing Steiner trees in which the sum of the weights on the links is lower than a predefined value. To the best of our knowledge, this problem has not been addressed in the literature so far.

III Analysis

We now present the numerical analysis of the degeneracy and redundancy of two different physical topologies: an $11\times 11$ square lattice and a randomly placed sensor network with the same number of nodes. In the lattice case, we place the sink node, $Y$, in the centre of the lattice and we restrict the maximum delay to $10$ hops, equal to the eccentricity of the sink node. In the case of a random topology, we consider an area of $1\times 1$ km, place the sink node at the centre of the area, and randomly distribute the remaining $120$ nodes. The edges are chosen to connect each node to its four closest neighbors222It is worth noting that this results in a non-uniform distribution of the edges.. The simulation involves calculating all FTs for randomly sampled input node pairs, $X$, which are chosen to be within three hops from each other, since in-network computation is typically used for data collected by nearby sensors. To calculate the average number of degenerate FTs with a given delay, this process is repeated $500$ times. The standard errors on the means are estimated using bootstrap resampling of all simulations, and are in-fact smaller than the plot markers.

Shown in Fig. 3 are the cumulative degeneracy of FTs and cumulative average redundancy for both topologies. For the lattice case, the cumulative number of degenerate FTs (blue markers) is seen to increase exponentially with the increasing delay limit. This same exponential behaviour has also been seen in independent experiments on different lattice sizes. It is a result of the branching process associated with FTs of increasing size gaining access to more and more nodes and their respective edges. The cumulative redundancy of FTs (red markers) also increases exponentially with delay limit. Although the cumulative degeneracy and redundancy are lower in the case of a random topology than those observed in a lattice, they still increase exponentially as the delay limit increases. The increase in cumulative redundancy demonstrates that the ability for physical topologies to perform parallel computing using independent FTs is higher for less restrictive delay limits.

Using the numerical estimates of degeneracy, we now examine the computational robustness of INC. Let us first define the probability of computational success, $\alpha_{i}$, at node $i$ as the number of successful computations as a fraction of attempts. The probability of a node failing during the computation of a function is then found to be,

[TABLE]

where, $P_{c_{i}}$, is the probability of a node occurring in any feasible FT. A computation may fail at a node for a number of reasons such as excessive load or during a sleep cycle. The probability of a successful computation is given as

[TABLE]

where $U$ are the nodes in the FT that performs the computation. Figure 4 compares the probability of successful computation using a single FT, e.g. selected as the optimal computational graph in terms of delay or energy consumption, and a random selection of one of the multiple FTs that can perform the same computation while satisfying a maximum delay requirement ($10$ for the results in figure). In the case of a single optimal FT, $P_{c_{i}}=1$ for all nodes, since all nodes in the optimal graph must be used for INC. Considering the degeneracy of FTs from Fig. 3, each computation can potentially be performed by using any of the degenerate FTs. Therefore, we estimate $P_{c_{i}}$ for the randomly selected FT, that is going to perform the computation, as the frequency of occurrences of the node $i$ in all the degenerate FTs. This $P_{c_{i}}$ is then used to compute the corresponding $P_{S_{c}}$ according to (6) and (7).

Results are then averaged over all the $500$ input pairs. The results in Fig. 4 show that it is possible to significantly increase the probability of successful computation by exploiting the multiplicity of FTs, i.e. the degeneracy.

IV Conclusion

We presented a novel way of considering INC using ideas from statistical physics. In particular, we defined degeneracy and the related concept of redundancy for distributed computation in networks, and we introduced an algorithm to efficiently compute all degenerate and redundant functional topologies. Our results show that the cumulative degeneracy and redundancy of functional topologies increase exponentially as the accepted delay limit for the computation is increased. The successful computation rate of a symmetric function is shown to be significantly higher using the set of possible degenerate functional topologies as opposed to exclusively using the optimal functional topology. This means that we can considerably improve the robustness of the computation, while still being able to satisfy requirements, such as delay or energy consumption. Future work will focus on exploiting degenerate and redundant FTs to perform parallel computing. The case of redundant, i.e. independent FTs, is of particular interest in that bottlenecks can be avoided with no coordination between the nodes of different FTs.

IoT Internet of Things FFT Fast Fourier Transform SVD Singular-Value Decomposition