A wave delay neural network for solving label-constrained shortest route query on time-varying communication networks

Design of WDNN

The wave delay neuron network is an auto wave neuron-based neural network. Using WDNN to address LTSRQ, the structure of WDNN depends on the topology of the time-varying network, i.e., each node and arc on the time-varying network respectively correspond to a neuron and a link (synapse) that between two neurons. The operating mechanism of the wave delay neural network is as follows: first, activate the root neuron. For non-root neurons, they will only be activated after receiving valid waves (waves that comply with their own label constraints); only activated neurons can generate concurrent waves; the neural network stops running when it reaches the given delay threshold, and the destination neuron selects the shortest route among all the received waves, which is the label-constrained time-varying shortest route.

Auto wave is the medium for neurons to transmit information, which also is regarded as the data packet. As a data packet transmission on an arc, there are delay and cost associated with a wave travel the corresponding synapse, where the delay is calculated by the synapse and the label is calculated by the neuron that sent the wave. Each wave contains three information, namely $P_{g,i}^t$, $A_{g,i}^t$, and $L_{g,i}^t$.

Figure 1 shows a general auto wave neuron’s structure. Each auto wave neuron consists of seven parts: input, wave receiver, wave filter, state updater, wave generator, wave sender, and output. The illustration and function of each part as following:

1. Input: The input of neurons is usually composed of multiple ports used to receive waves sent by other neurons. The number of input ports often depends on the in-degree of the neuron.

2. Wave receiver: The wave receiver is used to receive, cache, and decode auto waves. The wave receiver layer consists of several sub receivers, whose number depends on the number of input ports, which also enables each input port to correspond to one sub receiver one by one. When a neuron receives a wave at the current moment, $P_{g,i}^t$, $A_{g,i}^t$, and $L_{g,i}^t$ in its corresponding sub receivers will be assigned based on the information of the wave; if no waves are received, then $P_{g,i}^t$, $A_{g,i}^t$, and $L_{g,i}^t$ will be assigned an initial value. Where, the $P_{g,i}^t$ is used to cache the path in the wave sent by neuron g to current neuron i, the $A_{g,i}^t$ is used to cache the arrival time of the wave, and the $L_{g,i}^t$ is used to cache the labels in the wave. (2)${\displaystyle P_{g,i}^t=\left\{\begin{array}{c}{P}_{g,i}^t,\text{Receive a wave}{Y}_{g,i}^t\text{at time}t.\hfill \\ null,\text{Not receive a wave at time}t.\hfill \end{array}\right.}$ (3)${\displaystyle A_{g,i}^t=\left\{\begin{array}{c}{A}_{g,i}^t,\text{Receive a wave}{Y}_{g,i}^t\text{at time}t.\hfill \\ M,\text{Not receive a wave at time}t.\hfill \end{array}\right.}$ (4)${\displaystyle L_{g,i}^t=\left\{\begin{array}{c}{L}_{g,i}^t,\text{Receive a wave}{Y}_{g,i}^t\text{at time}t.\hfill \\ null,\text{Not receive a wave at time}t.\hfill \end{array}\right.}$

3. Wave filter: Wave filters are used to filter the data in the wave receiver. Firstly, based on the label information of the wave, select the wave that the current neuron can process, next determine whether the wave type meet the constrained label, and then determine whether the type of wave has been received. If the wave type is not a type that the current neuron can recognize or not meet the label constrain or has already received the type of wave, so the wave will be abandoned (since the length of the first received wave must be the shortest, only the earliest arriving wave needs to be recorded.).

4. State updater: The state updater is used to update and record the latest state of the current neuron. It includes three sub modules: $P_i^r$, $A_i^r$ and $L_i^r$, which are used to update and record the current shortest route sequence, the arrival time of the wave, and the label of the received wave.

5. Wave generator: The wave generator is used to calculate the values of new auto waves. It consists of three parts: $P_{i,q}^t$, $A_{i,q}^t$, and $L_{i,q}^t$, $q\in V_i^F$, their expressions are as following: (5)${\displaystyle \left\{\begin{array}{c}{P}_{i,q}^t=p_j\leftarrow \left\{i,t\right\}\hfill \\ A_{i,q}^t=t+len\left(T{W}_{i,q}\left(t\right)\right)\hfill \\ L_{i,q}^t=l^j\hfill \\ \hfill \end{array}\right.}$ where, the $l^j\in L_i^r$ is the one of label momerized by current neuron.

6. Wave sender: The wave sender is used to encode and send waves, which may be regarded as the inverse process of the wave receiver. It consists of $P_{i,q}^t$, $A_{i,q}^t$, and $L_{i,q}^t$, $q\in V_i^F$.

7. Output: The output is the port of auto wave output to successor neurons. Its function is similar to the axon site of biological neurons. The number of output ports depends on the current neuron output.

WDNN algorithm

The underlying idea of using WDNN to solve LTSP according to the following mechanisms: (1) initialize all neurons and activate the root neuron; (2) all non-root neurons receive auto waves, update neuron’s state at special time step; (3) all activated neurons generate auto waves and send to its successor neurons at special time step; (4) the shortest path depends on the wave that arrive destination neuron earliest and satisfied the label constrain L^c. Note that, the condition for activate non-root neuron is that the wave receiver receives one or more waves. The detailed procedures of the WDNN algorithm are summarized as shown in Algorithm 1 – 3 . All symbols that used in Algorithm 1 – 3 are summarized in Table 1.

Algorithm 1

WDNN

Input: V, E, L, s, d, Δt, k, L^c;

Output: report label-constrained shortest route;

 
 
 1:  t = ts; /*Initialize neuron timer.*/ 
 2:  initializing each neuron by using INA; 
 3:  while Lrd == ∅ and   t − ts <= k do 
  4:       update each neuron by using UNA; 
 5:       t = t + Δt; /*Iterative update of neuron timer.*/ 
 6:  end while 
  7:  report the shortest route Ptd.    

Algorithm 2

Initializing neuron algorithm (INA)

Input: i, d, t;

Output: $P_i^r$, $A_i^r$, $L_i^r$;

 
 
 1:  if  (i = r) then /* Initializing root neuron */ 
 2:       set Pri = Pri ← i; 
 3:       set Ari = Ari ← t; 
 4:       set Lri = Li; 
 5:  end if 
  6:  if  (i ⁄= d) then /* Initializing non-root neuron */ 
 7:       set Pri = ∅; 
 8:       set Ari = ∅; 
 9:       set Lri = ∅; 
 10:  end if    

Algorithm 3

Updating neuron algorithm (UNA)

Input: i, L_i, L^c, $L_i^r$, t, $V_i^F$, $V_i^P$, $Y_{f,i}^t$; /* $f\in V_i^P$.*/

Output: $Y_{i,q}^t$; /* $q\in V_i^F$. */;

 
 
  1:  for   f ∈ V Pi  do /*Receive waves sent by precursor neurons.*/ 
 2:       if   Y tg,i ⁄= ∅ then 
  3:             set Ptf,i = Ptf,i ∈ Y tf,i; 
 4:             set Atf,i = Atf,i ∈ Y tf,i; 
 5:             set Ltf,i = Ltf,i ∈ Y tf,i; 
 6:       else/*No wave received, set receiver to initial value.*/ 
 7:             set Ptf,i = ∅; 
 8:             set Atf,i = M; 
 9:             set Ltf,i = ∅; 
 10:       end if 
 11:       if   Ltf,i ∈ Li   and   Ltf,i ∈ Lc  then /*Determine whether the re- 
   ceived wave satisfies the label constraints of the current neu- 
   ron and whether this type of wave has been received.*/ 
 12:             if   not Ltf,i ∈ LtI  then 
 13:                   Pri = Pri ← Ptf,i; 
 14:                   Ari = Ari ← Atf,i; 
 15:                   Lri = Lri ← Ltf,i; 
 16:             end if 
 17:       end if 
 18:  end for 
 19:  for   j ∈ V Fi  do /*Send waves to each succeeding neuron.*/ 
 20:       set Ati,q = t + len(TWi,q(t)); 
 21:       set Pti,q = pj ←{i,t}; 
 22:       set Lti,q = lj; 
 23:       set Y ti,q = {Pti,q,Ati,q,Lti,q}; 
 24:  end for    

Time complexity of WDNN

Theorem 1. Let n be the number of nodes on the time-varying network, the m is the number of all arcs, the $V_i^P$ be the number of the neuron i’s input arcs, the $V_i^F$ be the number of the neuron i’s output arcs, k be the arrival time of destination node on output path, and Δt is the step (unit) of iteration. The time complexity of WDNN is equal to $O\left(\frac{2k}{\Delta t}\cdot m+n\right)$.

Proof: The WDNN algorithm consists of four main steps (step 1: line 1; step 2: line 2; step 3: line 3-6; step 4: line 7), the time complexity of step 1 and step 4 are all equal to O(1) due to without loop, iteration or recursion. The step 2 and step 3 are relatively complicated operations, the detailed analysis as following:

As to step 2 in WDNN, all neurons need to call INA for initializing. The times for running INA depends on the number of neurons in the neural network. Furthermore, the INA does not contain loop. Then, the time complexity of this step is equal to O(n).

Step 3 in WDNN is a loop, the number of iterations of the loop is limited by the k. Then, each neuron needs to run UNA for update at each time, which times depends on the number of neurons on the neural network. As to UNA, each neuron needs to send a wave to its precurssors and successors, its complexity is determined by $V_i^P+V_i^F$. Therefore, the time complexity of this step is equal to $O\left(\left(k/\Delta t\right)\cdot {\sum }_{i=1}^n{V}_i^P+V_i^F\right)$.

In summary, the time complexity of the WDNN algorithm is equal to: (6)${\displaystyle O\left(n+\frac{k}{\Delta t}\cdot \sum _{i=1}^n{m}_i\right)=O\left(\sum _{i=1}^n\left(1+\frac{k}{\Delta t}\cdot \left(V_i^P+V_i^F\right)\right)\right)=O\left(\frac{2k}{\Delta t}\cdot m+n\right).}$

It is worth noting that WDNN is a parallel algorithm, all neurons on the neural network are calculated in parallel. Therefore, in an ideal situation, the number of neurons does not affect the algorithm execution speed, the theoretical time complexity of WDNN algorithm is equal to $O\left(1+\frac{k}{\Delta t}\cdot \left(V_i^P+V_i^F\right)\right)$.

Correctness of WDNN

Theorem 2. The first auto-wave that arrives at the destination neuron and satisfies the label constraint determines the shortest route from root neuron to destination neuron.

Proof: Let x₁, x₂, and x₃ be the precursor neurons of neuron z (see Fig. 2). If the first auto-wave that received by neuron z is sent by neuron x₁, then the delay is T_P1 + w_x1 + T_P2, the label set is {a, b, c}. If the second auto-wave that received by neuron z is sent by neuron x₂, then the delay is T_P3 + w_x3 + T_P4, the label set is {a, b}. If the third auto-wave that received by neuron z is sent by neuron x₃, then the delay is T_P5 + w_x3 + T_P6, the label set is {a, b}. Because the destination neuron z will no longer receive the auto-wave after receiving the auto-wave that meets the label threshold, so if the second automatic wave is received, it is apparent that the label {c} is not in the constrained label set; if the third auto-wave is received by neuron z, it is apparent that T_P3 + w_x3 + T_P4 > T_P5 + w_x3 + T_P6, in reality, it contradicts the algorithmic process. In summary, Theorem 2 is correct.

Effect of different nodes

In this experiment, the performance of the proposed algorithm is evaluated by varying number of nodes between 50 to 200. Table 3 shows the effectiveness of the proposed algorithm and existing algorithms in solving 40 randomly generated label time-varying networks with different nodes. As shown in Table 3, compared to Yang, Veneti and Tu, the proposed algorithm obtain the optimal solution of the problem, while Yang algorithm has a relative error ratio between 0.123 and 0.219, the Veneti algorithm has a relative error ratio between 0.131 and 0.383, and the relative error ratio of Tu algorithm is shown a increasing trend from 0.019 to 0.027. It can be seen that the change in the number of nodes does not affect the accuracy of the Veneti, Yang and WDNN algorithms. This is because changes in the number of nodes only cause changes in the network size, while the degree and edge length between nodes do not have any significant changes, as the number of nodes does not affect the accuracy of the three algorithm. However, as the network size increases (the number of nodes increases), the error ratio of Tu algorithm is showing an upward trend, which means that Tu is not suitable for label-constrained shortest route solving on large time-varying networks. Furthermore, the reason why the algorithm proposed in this article can obtain the optimal solution on label time-varying networks with different number of nodes (network size) is that the neural network maps each node to a neuron, and changes in network size only cause changes in the network size, that is, an increase in the number of neurons, so it does not affect the performance of the algorithm. The compute time with different nodes are shown in Fig. 3.

In terms of computational time, although the proposed algorithm has a slightly slower computational speed than Yang algorithm when the network size is small (between 50 and 150 nodes), the loudness speed of WDNN is actually better than Yang, Veneti and Tu algorithms when the network size is large. It is because that the Yang algorithm adopts a heuristic search mechanism similar to the Dijkstra algorithm, which does not require synchronization in the time dimension. On large scale networks, the advantages of the proposed algorithm are presented due to the parallel computation of each neuron. The Veneti and Tu algorithms requires a lot of computation time due to the need to handle a large scale number of labels. In summary, although the proposed algorithm is slightly slower than Yang algorithm on smaller networks, it has better solution accuracy. On larger networks, the proposed WDNN outperforms existing algorithms in terms of response speed and solution accuracy.

Effect of different time windows

In this experiment, the performance of the proposed algorithm is evaluated by varying number of time windows between 1 to 5. Table 4 shows the effectiveness of the proposed algorithm and existing algorithms in solving 50 randomly generated label time-varying networks with different time windows. As shown in Table 4, compared to Yang, Veneti and Tu, the proposed algorithm obtain the optimal solution of the problem, while Yang algorithm has a relative error ratio of 0.15 to 0.22, the Veneti algorithm has a relative error ratio of 0.12 to 0.38, and the relative error ratio of Tu from 0 to 0.028. Figure 4 shows the relative error trend of the four algorithms when the number of time windows for each arc changes from 1 to 5. From Fig. 4, it can be seen that the proposed algorithm can obtain the optimal solution on time-varying networks with different number of time windows. The relative error of Yang and Tu algorithms increases with the increase of the number of time windows. Although the relative error of Veneti algorithm shows a decreasing trend, there is still an error of over 0.1 at 5 time windows. Figure 5 shows the compute time trend of the proposed WDNN, Yang, Veneti and Tu algorithms on a network with varying number of time windows. As shown in Fig. 5, both WDNN, the Yang and Tu algorithms show an upward trend with the increase of the number of time windows. This is because as the number of time windows increases, the algorithm needs to consume a certain amount of time when selecting a time window. Although the query time of the Veneti algorithm does not show an upward trend, this is because the time spent selecting the time window is relatively small compared to the search path of the Veneti algorithm, so it is not shown. Furthermore, the speed at which the proposed algorithm increases with the number of time windows is smaller than that of the Yang and Tu algorithms, while the Veneti algorithm has a computation time that is one order of magnitude higher than the proposed algorithm. In the case of more time windows, the proposed algorithm still has the best performance. In summary, the proposed algorithm has better performance compared to existing algorithms with varying time windows.

Experimental results on large-scale networks

This experiment will evaluate the performance of the proposed algorithm on large-scale real-world networks. Tables 5 and 6 show the response times of the proposed WDNN algorithm and Veneti, Yang, and Tu algorithms on real networks N-Net and I-Net, respectively, for solving the time-varying label-constrained shortest route problem on subnets with different number of time windows. Meanwhile, Figs. 6 and 7 respectively show the relative errors of the WDNN algorithm and Veneti, Yang, and Tu algorithms in solving the time-varying label-constrained shortest route problem on subnets with different number of time windows in these two real networks. From Table 5, it is evident that in the N-Net network with approximately 4,000 nodes, the proposed algorithm shows a significant improvement in computational speed compared to Veneti and Yang algorithms. Furthermore, compared to Tu algorithm, the computational speed of WDNN has also increased by about twice. In an I-Net network with approximately 20,000 nodes, it can be clearly observed from Table 6 that the proposed algorithm shows a significant improvement in computational speed compared to Veneti, Yang, and Tu algorithms. This result indicates that the proposed algorithm is better suited for label-constrained time-varying shortest routing query problems on large-scale networks. Through the comprehensive analysis of Figs. 6 and 7, it can be concluded that the proposed WDNN does not decrease accuracy as the number of time windows increases, and always maintains the ability to query the optimal solution. This is because WDNN is able to flexibly choose the most suitable departure time based on the time window to ensure earlier arrival at the next node. However, other algorithms lack a time window selection mechanism, and as the number of time windows increases, the query error shows an upward trend.