<?xml version="1.0" encoding="UTF-8"?><!DOCTYPE article PUBLIC "-//NLM//DTD Journal Publishing DTD v3.0 20080202//EN" "http://dtd.nlm.nih.gov/publishing/3.0/journalpublishing3.dtd">
<article xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink" dtd-version="3.0" xml:lang="en" article-type="research article">
 <front>
  <journal-meta>
   <journal-id journal-id-type="publisher-id">
    jcc
   </journal-id>
   <journal-title-group>
    <journal-title>
     Journal of Computer and Communications
    </journal-title>
   </journal-title-group>
   <issn pub-type="epub">
    2327-5219
   </issn>
   <issn publication-format="print">
    2327-5227
   </issn>
   <publisher>
    <publisher-name>
     Scientific Research Publishing
    </publisher-name>
   </publisher>
  </journal-meta>
  <article-meta>
   <article-id pub-id-type="doi">
    10.4236/jcc.2024.127007
   </article-id>
   <article-id pub-id-type="publisher-id">
    jcc-134823
   </article-id>
   <article-categories>
    <subj-group subj-group-type="heading">
     <subject>
      Articles
     </subject>
    </subj-group>
    <subj-group subj-group-type="Discipline-v2">
     <subject>
      Computer Science 
     </subject>
     <subject>
       Communications
     </subject>
    </subj-group>
   </article-categories>
   <title-group>
    Multipath Selection Algorithm Based on Dynamic Flow Prediction
   </title-group>
   <contrib-group>
    <contrib contrib-type="author" xlink:type="simple">
     <name name-style="western">
      <surname>
       Jingwen
      </surname>
      <given-names>
       Wang
      </given-names>
     </name>
    </contrib>
    <contrib contrib-type="author" xlink:type="simple">
     <name name-style="western">
      <surname>
       Guolong
      </surname>
      <given-names>
       Yu
      </given-names>
     </name>
    </contrib>
    <contrib contrib-type="author" xlink:type="simple">
     <name name-style="western">
      <surname>
       Xin
      </surname>
      <given-names>
       Cui
      </given-names>
     </name>
    </contrib>
   </contrib-group> 
   <aff id="affnull">
    <addr-line>
     aSchool of Computer Science and Technology, Shandong University of Technology, Zibo, China
    </addr-line> 
   </aff> 
   <pub-date pub-type="epub">
    <day>
     17
    </day> 
    <month>
     07
    </month>
    <year>
     2024
    </year>
   </pub-date> 
   <volume>
    12
   </volume> 
   <issue>
    07
   </issue>
   <fpage>
    94
   </fpage>
   <lpage>
    104
   </lpage>
   <history>
    <date date-type="received">
     <day>
      11,
     </day>
     <month>
      June
     </month>
     <year>
      2024
     </year>
    </date>
    <date date-type="published">
     <day>
      23,
     </day>
     <month>
      June
     </month>
     <year>
      2024
     </year> 
    </date> 
    <date date-type="accepted">
     <day>
      23,
     </day>
     <month>
      July
     </month>
     <year>
      2024
     </year> 
    </date>
   </history>
   <permissions>
    <copyright-statement>
     © Copyright 2014 by authors and Scientific Research Publishing Inc. 
    </copyright-statement>
    <copyright-year>
     2014
    </copyright-year>
    <license>
     <license-p>
      This work is licensed under the Creative Commons Attribution International License (CC BY). http://creativecommons.org/licenses/by/4.0/
     </license-p>
    </license>
   </permissions>
   <abstract>
    Traditional traffic management techniques appear to be incompetent in complex data center networks, so proposes a load balancing strategy based on Long Short-Term Memory (LSTM) and quantum annealing by Software Defined Network (SDN) to dynamically predict the traffic and comprehensively consider the current and predicted load of the network in order to select the optimal forwarding path and balance the network load. Experiments have demonstrated that the algorithm achieves significant improvement in both system throughput and average packet loss rate for the purpose of improving network quality of service.
   </abstract>
   <kwd-group> 
    <kwd>
     Data Center Network
    </kwd> 
    <kwd>
      Software Defined Network
    </kwd> 
    <kwd>
      Load Balance
    </kwd> 
    <kwd>
      Long Short-Term Memory
    </kwd> 
    <kwd>
      Quantum Annealing Algorithms
    </kwd>
   </kwd-group>
  </article-meta>
 </front>
 <body>
  <sec id="s1">
   <title>1. Introduction</title>
   <p>With the development of cloud computing, 5G and other technologies, under the trend of explosive traffic growth, increasing scale and complex topology in Data Center Network (DCN) <xref ref-type="bibr" rid="scirp.134823-1">
     [1]
    </xref>, the traditional network management architecture gradually exposes some deficiencies. Therefore, designing more effective and intelligent load balancing algorithms is of great research significance to improve the network performance in cloud data centers.</p>
   <p>The proposal of SDN <xref ref-type="bibr" rid="scirp.134823-2">
     [2]
    </xref> provides strong technical support for the effective detection and management of networks. SDN separates the control plane from the data plane, so that the data plane is only responsible for routing and forwarding, and the control plane implements forwarding decisions, realizing universal forwarding and efficient manipulation of network data streams, thus increasing the flexibility of the network.</p>
   <p>We first use machine learning to dynamically predict the network flow and design a multipath forwarding policy based on the current and predicted network load characteristics to dynamically adjust the network load situation. The effectiveness of this algorithm is verified by comparing it with other load balancing algorithms through simulation experiments.</p>
  </sec><sec id="s2">
   <title>2. Related Work</title>
   <p>In recent years, SDN-based network load balancing technology has received widespread attention because of its high flexibility and adjustability, and researchers at home and abroad have conducted a series of studies on it and proposed a variety of solutions.</p>
   <p>Fu Wang <xref ref-type="bibr" rid="scirp.134823-3">
     [3]
    </xref> and others proposed a Dynamic Distributed Multi-path (DDMP) load balancing algorithm, which quickly responds and adjusts the traffic according to the inverse of the buffer occupancy when certain paths in the network are loaded to prevent severe congestion. However, as the scale of the data center network expands, its energy consumption will become an important issue. M. A. Saifullah <xref ref-type="bibr" rid="scirp.134823-4">
     [4]
    </xref> et al. proposed EHLBOF (Extended Health monitoring for Load Balancing in OpenFlow based network) algorithm, which not only takes into account the current load of the servers, but also their health status, thus improving service availability and response speed. In addition, Zhang Chaohui <xref ref-type="bibr" rid="scirp.134823-5">
     [5]
    </xref> et al. proposed an energy efficient routing algorithm based on bandwidth matching, which is able to reserve sufficient space for the upcoming data streams, preventing link congestion and saving network energy consumption.</p>
   <p>A. Montazerolghaem <xref ref-type="bibr" rid="scirp.134823-6">
     [6]
    </xref> proposed a modular energy and load control system in IoMT that both reduces the number of loMT active servers and switches and balances the load distribution. Literature <xref ref-type="bibr" rid="scirp.134823-7">
     [7]
    </xref> proposed a network control mechanism based on SDN and AI, and proposed three operator network optimization algorithms, which provide effective solutions and theoretical support for telecom operators to implement intelligent network control and traffic optimization in SDN.</p>
   <p>The MTDLR <xref ref-type="bibr" rid="scirp.134823-8">
     [8]
    </xref> algorithm integrates path-level metrics to select forwarding paths and adapts to different topologies by adjusting the weights of network influences. However, MTDLR determines the weighting parameter to select the optimal path only through the average flow bandwidth utilization, which may cause the algorithm to fall into a local optimal solution and is not flexible enough for the dynamically changing network load problem.</p>
  </sec><sec id="s3">
   <title>3. Load Balancing Algorithm Based on Dynamic Flow Prediction and Multi-Constraint Routing</title>
   <sec id="s3_1">
    <title>3.1. Dynamic Flow Forecasting</title>
    <p>The LSTM model <xref ref-type="bibr" rid="scirp.134823-9">
      [9]
     </xref> was proposed by Hochreiter and Schmidhuber in 1997, which effectively solves the problem of gradient vanishing and gradient explosion encountered when dealing with long sequential data. The structure of LSTM is shown in <xref ref-type="fig" rid="fig1">
      Figure 1
     </xref>.</p>
    <fig id="fig1" position="float">
     <label>Figure 1</label>
     <caption>
      <title>
       <xref ref-type="bibr" rid="scirp.134823-"></xref>Figure 1. LSTM structure.</title>
     </caption>
     <graphic mimetype="image" position="float" xlink:type="simple" xlink:href="https://html.scirp.org/file/1732776-rId12.jpeg?20240726020619" />
    </fig>
    <p>The LSTM model adds three parts to the RNN (Recurrent Neural Network), namely, forgetting gate, input gate and output gate, and each gating unit consists of 
     <math display="inline" xmlns="http://www.w3.org/1998/Math/MathML"> <mi>
        σ 
      </mi> 
     </math> and tanh activation function.</p>
    <p>1) Forgetting gate: determines which old information is forgotten. 
     <math display="inline" xmlns="http://www.w3.org/1998/Math/MathML"> <mrow> 
       <mi>
         f 
       </mi> 
       <mrow> 
        <mo>
          ( 
        </mo> 
        <mi>
          t 
        </mi> 
        <mo>
          ) 
        </mo> 
       </mrow> 
      </mrow> 
     </math> indicates the importance of the old information, the higher the value, the more important the information.</p>
    <p>
     <math display="inline" xmlns="http://www.w3.org/1998/Math/MathML"> <mrow> 
       <mi>
         f 
       </mi> 
       <mrow> 
        <mo>
          ( 
        </mo> 
        <mi>
          t 
        </mi> 
        <mo>
          ) 
        </mo> 
       </mrow> 
       <mo>
         = 
       </mo> 
       <mi>
         σ 
       </mi> 
       <mrow> 
        <mo>
          ( 
        </mo> 
        <mrow> 
         <msub> 
          <mi>
            W 
          </mi> 
          <mi>
            f 
          </mi> 
         </msub> 
         <mrow> 
          <mo>
            [ 
          </mo> 
          <mrow> 
           <msub> 
            <mi>
              h 
            </mi> 
            <mrow> 
             <mi>
               t 
             </mi> 
             <mo>
               − 
             </mo> 
             <mn>
               1 
             </mn> 
            </mrow> 
           </msub> 
           <mo>
             , 
           </mo> 
           <msub> 
            <mi>
              x 
            </mi> 
            <mi>
              t 
            </mi> 
           </msub> 
          </mrow> 
          <mo>
            ] 
          </mo> 
         </mrow> 
         <mo>
           + 
         </mo> 
         <msub> 
          <mi>
            b 
          </mi> 
          <mi>
            f 
          </mi> 
         </msub> 
        </mrow> 
        <mo>
          ) 
        </mo> 
       </mrow> 
      </mrow> 
     </math> (1)</p>
    <p>2) Input gate: 
     <math display="inline" xmlns="http://www.w3.org/1998/Math/MathML"> <mrow> 
       <msub> 
        <mi>
          i 
        </mi> 
        <mi>
          t 
        </mi> 
       </msub> 
      </mrow> 
     </math> decides which new information is stored. is the output of the input gate, indicating the importance of the new information. 
     <math display="inline" xmlns="http://www.w3.org/1998/Math/MathML"> <mrow> 
       <msub> 
        <mover accent="true"> 
         <mi>
           C 
         </mi> 
         <mo>
           ˜ 
         </mo> 
        </mover> 
        <mi>
          i 
        </mi> 
       </msub> 
      </mrow> 
     </math> indicates new information can be stored to the current cell state.</p>
    <p>
     <math display="inline" xmlns="http://www.w3.org/1998/Math/MathML"> <mrow> 
       <msub> 
        <mi>
          i 
        </mi> 
        <mi>
          t 
        </mi> 
       </msub> 
       <mo>
         = 
       </mo> 
       <mi>
         σ 
       </mi> 
       <mrow> 
        <mo>
          ( 
        </mo> 
        <mrow> 
         <msub> 
          <mi>
            W 
          </mi> 
          <mi>
            i 
          </mi> 
         </msub> 
         <mrow> 
          <mo>
            [ 
          </mo> 
          <mrow> 
           <msub> 
            <mi>
              h 
            </mi> 
            <mrow> 
             <mi>
               t 
             </mi> 
             <mo>
               − 
             </mo> 
             <mn>
               1 
             </mn> 
            </mrow> 
           </msub> 
           <mo>
             , 
           </mo> 
           <msub> 
            <mi>
              x 
            </mi> 
            <mi>
              t 
            </mi> 
           </msub> 
          </mrow> 
          <mo>
            ] 
          </mo> 
         </mrow> 
         <mo>
           + 
         </mo> 
         <msub> 
          <mi>
            b 
          </mi> 
          <mi>
            i 
          </mi> 
         </msub> 
        </mrow> 
        <mo>
          ) 
        </mo> 
       </mrow> 
      </mrow> 
     </math> (2)</p>
    <p>
     <math display="inline" xmlns="http://www.w3.org/1998/Math/MathML"> <mrow> 
       <msub> 
        <mover accent="true"> 
         <mi>
           C 
         </mi> 
         <mo>
           ˜ 
         </mo> 
        </mover> 
        <mi>
          t 
        </mi> 
       </msub> 
       <mo>
         = 
       </mo> 
       <mi>
         tanh 
       </mi> 
       <mrow> 
        <mo>
          ( 
        </mo> 
        <mrow> 
         <msub> 
          <mi>
            W 
          </mi> 
          <mi>
            c 
          </mi> 
         </msub> 
         <mrow> 
          <mo>
            [ 
          </mo> 
          <mrow> 
           <msub> 
            <mi>
              h 
            </mi> 
            <mrow> 
             <mi>
               t 
             </mi> 
             <mo>
               − 
             </mo> 
             <mn>
               1 
             </mn> 
            </mrow> 
           </msub> 
           <mo>
             , 
           </mo> 
           <msub> 
            <mi>
              x 
            </mi> 
            <mi>
              t 
            </mi> 
           </msub> 
          </mrow> 
          <mo>
            ] 
          </mo> 
         </mrow> 
         <mo>
           + 
         </mo> 
         <msub> 
          <mi>
            b 
          </mi> 
          <mi>
            c 
          </mi> 
         </msub> 
        </mrow> 
        <mo>
          ) 
        </mo> 
       </mrow> 
      </mrow> 
     </math> (3)</p>
    <p>At this point, the cell state is updated and the updated state is 
     <math display="inline" xmlns="http://www.w3.org/1998/Math/MathML"> <mrow> 
       <msub> 
        <mi>
          C 
        </mi> 
        <mi>
          t 
        </mi> 
       </msub> 
      </mrow> 
     </math>.</p>
    <p>3) Output Gate: Determines what information will be output.</p>
    <p>
     <math display="inline" xmlns="http://www.w3.org/1998/Math/MathML"> <mrow> 
       <msub> 
        <mi>
          C 
        </mi> 
        <mi>
          t 
        </mi> 
       </msub> 
       <mo>
         = 
       </mo> 
       <msub> 
        <mi>
          f 
        </mi> 
        <mi>
          t 
        </mi> 
       </msub> 
       <msub> 
        <mi>
          C 
        </mi> 
        <mrow> 
         <mi>
           t 
         </mi> 
         <mo>
           − 
         </mo> 
         <mn>
           1 
         </mn> 
        </mrow> 
       </msub> 
       <mo>
         + 
       </mo> 
       <msub> 
        <mi>
          i 
        </mi> 
        <mi>
          t 
        </mi> 
       </msub> 
       <msub> 
        <mover accent="true"> 
         <mi>
           C 
         </mi> 
         <mo>
           ˜ 
         </mo> 
        </mover> 
        <mi>
          t 
        </mi> 
       </msub> 
      </mrow> 
     </math> (4)</p>
    <p>
     <math display="inline" xmlns="http://www.w3.org/1998/Math/MathML"> <mrow> 
       <mi>
         h 
       </mi> 
       <mrow> 
        <mo>
          ( 
        </mo> 
        <mi>
          t 
        </mi> 
        <mo>
          ) 
        </mo> 
       </mrow> 
       <mo>
         = 
       </mo> 
       <mi>
         σ 
       </mi> 
       <mrow> 
        <mo>
          ( 
        </mo> 
        <mrow> 
         <msub> 
          <mi>
            W 
          </mi> 
          <mi>
            o 
          </mi> 
         </msub> 
         <mrow> 
          <mo>
            [ 
          </mo> 
          <mrow> 
           <msub> 
            <mi>
              x 
            </mi> 
            <mi>
              t 
            </mi> 
           </msub> 
           <mo>
             , 
           </mo> 
           <msub> 
            <mi>
              h 
            </mi> 
            <mrow> 
             <mi>
               t 
             </mi> 
             <mo>
               − 
             </mo> 
             <mn>
               1 
             </mn> 
            </mrow> 
           </msub> 
          </mrow> 
          <mo>
            ] 
          </mo> 
         </mrow> 
         <mo>
           + 
         </mo> 
         <msub> 
          <mi>
            b 
          </mi> 
          <mi>
            o 
          </mi> 
         </msub> 
        </mrow> 
        <mo>
          ) 
        </mo> 
       </mrow> 
      </mrow> 
     </math> (5)</p>
    <p>In Equations (1) to (4), W is the network weight coefficient, 
     <math display="inline" xmlns="http://www.w3.org/1998/Math/MathML"> <mrow> 
       <msub> 
        <mi>
          h 
        </mi> 
        <mrow> 
         <mi>
           t 
         </mi> 
         <mo>
           − 
         </mo> 
         <mn>
           1 
         </mn> 
        </mrow> 
       </msub> 
      </mrow> 
     </math> is the output of the previous time step, 
     <math display="inline" xmlns="http://www.w3.org/1998/Math/MathML"> <mrow> 
       <msub> 
        <mi>
          h 
        </mi> 
        <mi>
          t 
        </mi> 
       </msub> 
      </mrow> 
     </math> is the output of the current time, and b is the bias of the activation value.</p>
    <p>The average absolute error (MAE), root mean square error (RMSE), average absolute percentage error (MAPE) and Symmetric Mean Absolute Percentage Error (SMAPE) are usually used to evaluate the prediction effect of the model, and the lower the value of the indexes, the more stable the model is and the more accurate the prediction results are. The formulas are as follows:</p>
    <p>
     <math xmlns="http://www.w3.org/1998/Math/MathML" display="inline"> <mrow> 
       <mtext>
         MAE 
       </mtext> 
       <mo>
         = 
       </mo> 
       <mfrac> 
        <mn>
          1 
        </mn> 
        <mi>
          m 
        </mi> 
       </mfrac> 
       <mstyle displaystyle="true"> 
        <munderover> 
         <mo>
           ∑ 
         </mo> 
         <mrow> 
          <mi>
            t 
          </mi> 
          <mo>
            = 
          </mo> 
          <mn>
            1 
          </mn> 
         </mrow> 
         <mi>
           m 
         </mi> 
        </munderover> 
        <mrow> 
         <mrow> 
          <mo>
            | 
          </mo> 
          <mrow> 
           <mrow> 
            <mo>
              ( 
            </mo> 
            <mrow> 
             <msub> 
              <mi>
                h 
              </mi> 
              <mi>
                t 
              </mi> 
             </msub> 
             <mo>
               − 
             </mo> 
             <msub> 
              <mover accent="true"> 
               <mi>
                 h 
               </mi> 
               <mo>
                 ^ 
               </mo> 
              </mover> 
              <mi>
                t 
              </mi> 
             </msub> 
            </mrow> 
            <mo>
              ) 
            </mo> 
           </mrow> 
          </mrow> 
          <mo>
            | 
          </mo> 
         </mrow> 
        </mrow> 
       </mstyle> 
      </mrow> 
     </math> (6)</p>
    <p>
     <math xmlns="http://www.w3.org/1998/Math/MathML" display="inline"> <mrow> 
       <mtext>
         RMSE 
       </mtext> 
       <mo>
         = 
       </mo> 
       <msqrt> 
        <mrow> 
         <mfrac> 
          <mn>
            1 
          </mn> 
          <mi>
            m 
          </mi> 
         </mfrac> 
         <mstyle displaystyle="true"> 
          <munderover> 
           <mo>
             ∑ 
           </mo> 
           <mrow> 
            <mi>
              t 
            </mi> 
            <mo>
              = 
            </mo> 
            <mn>
              1 
            </mn> 
           </mrow> 
           <mi>
             m 
           </mi> 
          </munderover> 
          <mrow> 
           <msup> 
            <mrow> 
             <mrow> 
              <mo>
                ( 
              </mo> 
              <mrow> 
               <msub> 
                <mi>
                  h 
                </mi> 
                <mi>
                  t 
                </mi> 
               </msub> 
               <mo>
                 − 
               </mo> 
               <msub> 
                <mover accent="true"> 
                 <mi>
                   h 
                 </mi> 
                 <mo>
                   ^ 
                 </mo> 
                </mover> 
                <mi>
                  t 
                </mi> 
               </msub> 
              </mrow> 
              <mo>
                ) 
              </mo> 
             </mrow> 
            </mrow> 
            <mn>
              2 
            </mn> 
           </msup> 
          </mrow> 
         </mstyle> 
        </mrow> 
       </msqrt> 
      </mrow> 
     </math> (7)</p>
    <p>
     <math xmlns="http://www.w3.org/1998/Math/MathML" display="inline"> <mrow> 
       <mtext>
         MAPE 
       </mtext> 
       <mo>
         = 
       </mo> 
       <mfrac> 
        <mrow> 
         <mn>
           100 
         </mn> 
         <mi>
           % 
         </mi> 
        </mrow> 
        <mi>
          m 
        </mi> 
       </mfrac> 
       <mstyle displaystyle="true"> 
        <munderover> 
         <mo>
           ∑ 
         </mo> 
         <mrow> 
          <mi>
            t 
          </mi> 
          <mo>
            = 
          </mo> 
          <mn>
            1 
          </mn> 
         </mrow> 
         <mi>
           m 
         </mi> 
        </munderover> 
        <mrow> 
         <mrow> 
          <mo>
            | 
          </mo> 
          <mrow> 
           <mfrac> 
            <mrow> 
             <msub> 
              <mover accent="true"> 
               <mi>
                 h 
               </mi> 
               <mo>
                 ^ 
               </mo> 
              </mover> 
              <mi>
                t 
              </mi> 
             </msub> 
             <mo>
               − 
             </mo> 
             <msub> 
              <mi>
                h 
              </mi> 
              <mi>
                t 
              </mi> 
             </msub> 
            </mrow> 
            <mrow> 
             <msub> 
              <mi>
                h 
              </mi> 
              <mi>
                t 
              </mi> 
             </msub> 
            </mrow> 
           </mfrac> 
          </mrow> 
          <mo>
            | 
          </mo> 
         </mrow> 
        </mrow> 
       </mstyle> 
      </mrow> 
     </math> (8)</p>
    <p>
     <math xmlns="http://www.w3.org/1998/Math/MathML" display="inline"> <mrow> 
       <mtext>
         SMAPE 
       </mtext> 
       <mo>
         = 
       </mo> 
       <mfrac> 
        <mrow> 
         <mn>
           100 
         </mn> 
         <mi>
           % 
         </mi> 
        </mrow> 
        <mi>
          m 
        </mi> 
       </mfrac> 
       <mstyle displaystyle="true"> 
        <munderover> 
         <mo>
           ∑ 
         </mo> 
         <mrow> 
          <mi>
            t 
          </mi> 
          <mo>
            = 
          </mo> 
          <mn>
            1 
          </mn> 
         </mrow> 
         <mi>
           m 
         </mi> 
        </munderover> 
        <mrow> 
         <mfrac> 
          <mrow> 
           <mrow> 
            <mo>
              | 
            </mo> 
            <mrow> 
             <msub> 
              <mi>
                h 
              </mi> 
              <mi>
                t 
              </mi> 
             </msub> 
             <mo>
               − 
             </mo> 
             <msub> 
              <mover accent="true"> 
               <mi>
                 h 
               </mi> 
               <mo>
                 ^ 
               </mo> 
              </mover> 
              <mi>
                t 
              </mi> 
             </msub> 
            </mrow> 
            <mo>
              | 
            </mo> 
           </mrow> 
          </mrow> 
          <mrow> 
           <mrow> 
            <mo>
              | 
            </mo> 
            <mrow> 
             <msub> 
              <mi>
                h 
              </mi> 
              <mi>
                t 
              </mi> 
             </msub> 
            </mrow> 
            <mo>
              | 
            </mo> 
           </mrow> 
           <mo>
             + 
           </mo> 
           <mrow> 
            <mo>
              | 
            </mo> 
            <mrow> 
             <msub> 
              <mover accent="true"> 
               <mi>
                 h 
               </mi> 
               <mo>
                 ^ 
               </mo> 
              </mover> 
              <mi>
                t 
              </mi> 
             </msub> 
            </mrow> 
            <mo>
              | 
            </mo> 
           </mrow> 
          </mrow> 
         </mfrac> 
        </mrow> 
       </mstyle> 
      </mrow> 
     </math> (9)</p>
    <p>
     <xref ref-type="bibr" rid="scirp.134823-"></xref>where m, 
     <math display="inline" xmlns="http://www.w3.org/1998/Math/MathML"> <mrow> 
       <msub> 
        <mi>
          h 
        </mi> 
        <mi>
          t 
        </mi> 
       </msub> 
      </mrow> 
     </math>, and 
     <math display="inline" xmlns="http://www.w3.org/1998/Math/MathML"> <mrow> 
       <msub> 
        <mover accent="true"> 
         <mi>
           h 
         </mi> 
         <mo>
           ^ 
         </mo> 
        </mover> 
        <mi>
          t 
        </mi> 
       </msub> 
      </mrow> 
     </math> are the total number of samples, measured values, and predicted values, respectively. MAE measures the average size of the absolute value of the difference between the predicted and actual values; RMSE is the square root of the mean of the squares of the difference between the predicted and actual values; MAPE is the average percentage of the absolute value of the ratio of the prediction error to the actual value; SMAPE reduces the problem of numerical inflation that may occur with MAPE by taking the absolute value of the predicted value and the actual value and averaging them.</p>
   </sec>
   <sec id="s3_2">
    <title>3.2. Quantum Annealing Algorithms</title>
    <p>Metropolis et al. <xref ref-type="bibr" rid="scirp.134823-10">
      [10]
     </xref> proposed the idea of Simulated Annealing (SA) in 1953, which has since been widely used in combinatorial optimization <xref ref-type="bibr" rid="scirp.134823-11">
      [11]
     </xref> problems. SA, as a heuristic global optimization algorithm, simulates the physical process of atoms rearranging to reach thermodynamic equilibrium during annealing of solid materials. Although SA can handle complex optimization problems, its convergence speed and and solution quality depend on the parameter settings, and the temperature of the object is directly proportional to the energy, at lower temperatures, according to the Metropolis criterion, it only accepts new solutions that are smaller than the current solution, or when the temperature decreases at too fast a rate, it may skip many potential globally optimal solutions, and thus easily causes the system to stay at the local optimal solution.</p>
    <p>With the development of quantum technology, Quantum Annealing (QA) algorithm <xref ref-type="bibr" rid="scirp.134823-12">
      [12]
     </xref> based on quantum tunneling effect is proposed. The so-called quantum tunneling effect, i.e., the quantum leap gives the quantum the ability to penetrate the potential barrier higher than its own energy. Simulated annealing algorithm and quantum annealing algorithm over the potential barrier are shown in <xref ref-type="fig" rid="fig2">
      Figure 2
     </xref>, the particle reaches the local optimum at point A, the simulated annealing algorithm needs to go over the potential barrier in order to achieve the global optimum, and the quantum annealing algorithm only needs to reach the global optimum point B directly through the quantum tunneling effect.</p>
    <fig id="fig2" position="float">
     <label>Figure 2</label>
     <caption>
      <title>
       <xref ref-type="bibr" rid="scirp.134823-"></xref>Figure 2. Comparison of SA and QA.</title>
     </caption>
     <graphic mimetype="image" position="float" xlink:type="simple" xlink:href="https://html.scirp.org/file/1732776-rId49.jpeg?20240726020620" />
    </fig>
    <p>The process of realizing quantum annealing requires 6 steps:</p>
    <p>Step 1: Construct the evaluation function 
     <math display="inline" xmlns="http://www.w3.org/1998/Math/MathML"> <mrow> 
       <msub> 
        <mi>
          H 
        </mi> 
        <mi>
          q 
        </mi> 
       </msub> 
       <mo>
         = 
       </mo> 
       <msub> 
        <mi>
          H 
        </mi> 
        <mrow> 
         <mi>
           p 
         </mi> 
         <mi>
           o 
         </mi> 
         <mi>
           t 
         </mi> 
        </mrow> 
       </msub> 
       <mo>
         + 
       </mo> 
       <msub> 
        <mi>
          H 
        </mi> 
        <mrow> 
         <mi>
           k 
         </mi> 
         <mi>
           i 
         </mi> 
         <mi>
           n 
         </mi> 
        </mrow> 
       </msub> 
      </mrow> 
     </math> of the quantum system, where 
     <math display="inline" xmlns="http://www.w3.org/1998/Math/MathML"> <mrow> 
       <msub> 
        <mi>
          H 
        </mi> 
        <mrow> 
         <mi>
           p 
         </mi> 
         <mi>
           o 
         </mi> 
         <mi>
           t 
         </mi> 
        </mrow> 
       </msub> 
      </mrow> 
     </math> is the potential energy to represent the objective function of the optimization problem and 
     <math display="inline" xmlns="http://www.w3.org/1998/Math/MathML"> <mrow> 
       <msub> 
        <mi>
          H 
        </mi> 
        <mrow> 
         <mi>
           k 
         </mi> 
         <mi>
           i 
         </mi> 
         <mi>
           n 
         </mi> 
        </mrow> 
       </msub> 
      </mrow> 
     </math> is the kinetic energy;</p>
    <p>Step 2: Set the initial temperature T, the transverse magnetic field strength Γ, and the maximum number of iterations Steps. Select an initial state x randomly at temperature T and calculate 
     <math display="inline" xmlns="http://www.w3.org/1998/Math/MathML"> <mrow> 
       <msub> 
        <mi>
          H 
        </mi> 
        <mi>
          q 
        </mi> 
       </msub> 
       <mrow> 
        <mo>
          ( 
        </mo> 
        <mi>
          x 
        </mi> 
        <mo>
          ) 
        </mo> 
       </mrow> 
      </mrow> 
     </math>;</p>
    <p>Step 3: Generate a new state x' by randomly perturbing state x and calculate its 
     <math display="inline" xmlns="http://www.w3.org/1998/Math/MathML"> <mrow> 
       <msub> 
        <mi>
          H 
        </mi> 
        <mi>
          q 
        </mi> 
       </msub> 
       <mrow> 
        <mo>
          ( 
        </mo> 
        <mrow> 
         <mi>
           x 
         </mi> 
         <mo>
           ′ 
         </mo> 
        </mrow> 
        <mo>
          ) 
        </mo> 
       </mrow> 
      </mrow> 
     </math>;</p>
    <p>Step 4: Calculate 
     <math display="inline" xmlns="http://www.w3.org/1998/Math/MathML"> <mrow> 
       <mi>
         Δ 
       </mi> 
       <msub> 
        <mi>
          H 
        </mi> 
        <mi>
          q 
        </mi> 
       </msub> 
       <mo>
         = 
       </mo> 
       <msub> 
        <mi>
          H 
        </mi> 
        <mi>
          q 
        </mi> 
       </msub> 
       <mrow> 
        <mo>
          ( 
        </mo> 
        <mi>
          x 
        </mi> 
        <mo>
          ) 
        </mo> 
       </mrow> 
       <mo>
         − 
       </mo> 
       <msub> 
        <mi>
          H 
        </mi> 
        <mi>
          q 
        </mi> 
       </msub> 
       <mrow> 
        <mo>
          ( 
        </mo> 
        <mrow> 
         <mi>
           x 
         </mi> 
         <mo>
           ′ 
         </mo> 
        </mrow> 
        <mo>
          ) 
        </mo> 
       </mrow> 
      </mrow> 
     </math>. If 
     <math display="inline" xmlns="http://www.w3.org/1998/Math/MathML"> <mrow> 
       <mi>
         Δ 
       </mi> 
       <msub> 
        <mi>
          H 
        </mi> 
        <mi>
          q 
        </mi> 
       </msub> 
       <mo>
         &gt; 
       </mo> 
       <mn>
         0 
       </mn> 
      </mrow> 
     </math>, or 
     <math display="inline" xmlns="http://www.w3.org/1998/Math/MathML"> <mrow> 
       <mi>
         Δ 
       </mi> 
       <msub> 
        <mi>
          H 
        </mi> 
        <mi>
          q 
        </mi> 
       </msub> 
       <mo>
         &lt; 
       </mo> 
       <mn>
         0 
       </mn> 
      </mrow> 
     </math> and 
     <math display="inline" xmlns="http://www.w3.org/1998/Math/MathML"> <mrow> 
       <msup> 
        <mtext>
          e 
        </mtext> 
        <mrow> 
         <mo>
           − 
         </mo> 
         <mfrac> 
          <mrow> 
           <mi>
             Δ 
           </mi> 
           <msub> 
            <mi>
              H 
            </mi> 
            <mi>
              q 
            </mi> 
           </msub> 
          </mrow> 
          <mi>
            T 
          </mi> 
         </mfrac> 
        </mrow> 
       </msup> 
       <mo>
         &lt; 
       </mo> 
       <mtext>
         random 
       </mtext> 
       <mrow> 
        <mo>
          ( 
        </mo> 
        <mrow> 
         <mn>
           0 
         </mn> 
         <mo>
           , 
         </mo> 
         <mn>
           1 
         </mn> 
        </mrow> 
        <mo>
          ) 
        </mo> 
       </mrow> 
      </mrow> 
     </math>, the new state x' is accepted, otherwise, return to step 3;</p>
    <p>Step 5: Perform a de-tempering and magnetic field attenuation operation;</p>
    <p>Step 6: Determine whether the maximum number of iterations or the termination condition is reached, if so terminate, otherwise return to step 3.</p>
    <p>According to the above steps, the flowchart of quantum annealing algorithm is shown in <xref ref-type="fig" rid="fig3">
      Figure 3
     </xref>:</p>
   </sec>
   <sec id="s3_3">
    <title>3.3. Multi-Constraint Based Path Forwarding Policy</title>
    <p>After a data stream is generated, there are multiple paths between its source and destination nodes in the data center, and choosing the appropriate path for forwarding can effectively maintain network load balancing. In this paper, we design the optimal forwarding path policy that satisfies the constraints through the current and predicted load balancing degree.</p>
    <fig id="fig3" position="float">
     <label>Figure 3</label>
     <caption>
      <title>
       <xref ref-type="bibr" rid="scirp.134823-"></xref>Figure 3. Flowchart of QA.</title>
     </caption>
     <graphic mimetype="image" position="float" xlink:type="simple" xlink:href="https://html.scirp.org/file/1732776-rId68.jpeg?20240726020621" />
    </fig>
    <p>Construct the data center network as a directed graph 
     <math display="inline" xmlns="http://www.w3.org/1998/Math/MathML"> <mrow> 
       <mi>
         G 
       </mi> 
       <mo>
         = 
       </mo> 
       <mrow> 
        <mo>
          ( 
        </mo> 
        <mrow> 
         <mi>
           S 
         </mi> 
         <mo>
           , 
         </mo> 
         <mi>
           L 
         </mi> 
        </mrow> 
        <mo>
          ) 
        </mo> 
       </mrow> 
      </mrow> 
     </math>, with S being the set of all nodes in the network and L being the set of all links in the network. Denote the path between the data flow source node s and the destination node d as P<sub>s</sub><sub>,</sub><sub>d</sub>.</p>
    <p>In a data center network, choosing a path each time to forward with the maximum available bandwidth between source and destination nodes can effectively alleviate and prevent load imbalance problems. Get the switch port statistics to get the number of bytes sent and received by the port and calculate the transmission rate 
     <math display="inline" xmlns="http://www.w3.org/1998/Math/MathML"> <mrow> 
       <mi>
         s 
       </mi> 
       <mi>
         p 
       </mi> 
       <mi>
         e 
       </mi> 
       <mi>
         e 
       </mi> 
       <msub> 
        <mi>
          d 
        </mi> 
        <mrow> 
         <mi>
           i 
         </mi> 
         <mo>
           , 
         </mo> 
         <mi>
           j 
         </mi> 
        </mrow> 
       </msub> 
      </mrow> 
     </math> of the port based on the last recorded number of bytes transmitted:</p>
    <p>
     <math display="inline" xmlns="http://www.w3.org/1998/Math/MathML"> <mrow> 
       <mi>
         s 
       </mi> 
       <mi>
         p 
       </mi> 
       <mi>
         e 
       </mi> 
       <mi>
         e 
       </mi> 
       <msub> 
        <mi>
          d 
        </mi> 
        <mrow> 
         <mi>
           i 
         </mi> 
         <mo>
           , 
         </mo> 
         <mi>
           j 
         </mi> 
        </mrow> 
       </msub> 
       <mo>
         = 
       </mo> 
       <mfrac> 
        <mrow> 
         <mi>
           s 
         </mi> 
         <mi>
           t 
         </mi> 
         <mi>
           a 
         </mi> 
         <mi>
           t 
         </mi> 
         <msub> 
          <mi>
            s 
          </mi> 
          <mrow> 
           <mi>
             i 
           </mi> 
           <mo>
             , 
           </mo> 
           <mi>
             j 
           </mi> 
           <mo>
             , 
           </mo> 
           <mi>
             t 
           </mi> 
          </mrow> 
         </msub> 
         <mo>
           − 
         </mo> 
         <mi>
           s 
         </mi> 
         <mi>
           t 
         </mi> 
         <mi>
           a 
         </mi> 
         <mi>
           t 
         </mi> 
         <msub> 
          <mi>
            s 
          </mi> 
          <mrow> 
           <mi>
             i 
           </mi> 
           <mo>
             , 
           </mo> 
           <mi>
             j 
           </mi> 
           <mo>
             , 
           </mo> 
           <mi>
             t 
           </mi> 
           <mo>
             − 
           </mo> 
           <mn>
             1 
           </mn> 
          </mrow> 
         </msub> 
        </mrow> 
        <mrow> 
         <mi>
           p 
         </mi> 
         <mi>
           d 
         </mi> 
        </mrow> 
       </mfrac> 
      </mrow> 
     </math> (10)</p>
    <p>In Equation (10), i and j respectively denote the source and destination switches, stats denotes the number of bytes transmitted on the port, and pd denotes the time interval between two recordings.</p>
    <p>Then the bandwidth 
     <math display="inline" xmlns="http://www.w3.org/1998/Math/MathML"> <mrow> 
       <mi>
         b 
       </mi> 
       <msub> 
        <mi>
          w 
        </mi> 
        <mi>
          l 
        </mi> 
       </msub> 
      </mrow> 
     </math> of link l is denoted as the minimum of the two ports connected, and the available bandwidth 
     <math display="inline" xmlns="http://www.w3.org/1998/Math/MathML"> <mrow> 
       <mi>
         f 
       </mi> 
       <mi>
         r 
       </mi> 
       <mi>
         e 
       </mi> 
       <mi>
         e 
       </mi> 
       <mtext>
         _ 
       </mtext> 
       <mi>
         b 
       </mi> 
       <mi>
         w 
       </mi> 
      </mrow> 
     </math> is the difference between the link capacity 
     <math display="inline" xmlns="http://www.w3.org/1998/Math/MathML"> <mrow> 
       <msub> 
        <mi>
          C 
        </mi> 
        <mi>
          l 
        </mi> 
       </msub> 
      </mrow> 
     </math> and the used bandwidth, and the minimum available bandwidth of all the links in the path is denoted as the available bandwidth of the path:</p>
    <p>
     <math display="inline" xmlns="http://www.w3.org/1998/Math/MathML"> <mrow> 
       <mi>
         b 
       </mi> 
       <msub> 
        <mi>
          w 
        </mi> 
        <mi>
          l 
        </mi> 
       </msub> 
       <mo>
         = 
       </mo> 
       <mi>
         min 
       </mi> 
       <mrow> 
        <mo>
          ( 
        </mo> 
        <mrow> 
         <mi>
           s 
         </mi> 
         <mi>
           p 
         </mi> 
         <mi>
           e 
         </mi> 
         <mi>
           e 
         </mi> 
         <msub> 
          <mi>
            d 
          </mi> 
          <mrow> 
           <mi>
             i 
           </mi> 
           <mo>
             , 
           </mo> 
           <mi>
             j 
           </mi> 
          </mrow> 
         </msub> 
         <mo>
           , 
         </mo> 
         <mi>
           s 
         </mi> 
         <mi>
           p 
         </mi> 
         <mi>
           e 
         </mi> 
         <mi>
           e 
         </mi> 
         <msub> 
          <mi>
            d 
          </mi> 
          <mrow> 
           <mi>
             j 
           </mi> 
           <mo>
             , 
           </mo> 
           <mi>
             i 
           </mi> 
          </mrow> 
         </msub> 
        </mrow> 
        <mo>
          ) 
        </mo> 
       </mrow> 
      </mrow> 
     </math> (11)</p>
    <p>
     <math display="inline" xmlns="http://www.w3.org/1998/Math/MathML"> <mrow> 
       <mi>
         f 
       </mi> 
       <mi>
         r 
       </mi> 
       <mi>
         e 
       </mi> 
       <mi>
         e 
       </mi> 
       <mtext>
         _ 
       </mtext> 
       <mi>
         b 
       </mi> 
       <msub> 
        <mi>
          w 
        </mi> 
        <mi>
          l 
        </mi> 
       </msub> 
       <mo>
         = 
       </mo> 
       <msub> 
        <mi>
          C 
        </mi> 
        <mi>
          l 
        </mi> 
       </msub> 
       <mo>
         − 
       </mo> 
       <mi>
         b 
       </mi> 
       <msub> 
        <mi>
          w 
        </mi> 
        <mi>
          l 
        </mi> 
       </msub> 
      </mrow> 
     </math> (12)</p>
    <p>
     <math display="inline" xmlns="http://www.w3.org/1998/Math/MathML"> <mrow> 
       <mi>
         A 
       </mi> 
       <mo>
         = 
       </mo> 
       <mi>
         min 
       </mi> 
       <mrow> 
        <mo>
          ( 
        </mo> 
        <mrow> 
         <mi>
           f 
         </mi> 
         <mi>
           r 
         </mi> 
         <mi>
           e 
         </mi> 
         <mi>
           e 
         </mi> 
         <mtext>
           _ 
         </mtext> 
         <mi>
           b 
         </mi> 
         <msub> 
          <mi>
            w 
          </mi> 
          <mrow> 
           <msub> 
            <mi>
              l 
            </mi> 
            <mn>
              1 
            </mn> 
           </msub> 
          </mrow> 
         </msub> 
         <mo>
           , 
         </mo> 
         <mi>
           f 
         </mi> 
         <mi>
           r 
         </mi> 
         <mi>
           e 
         </mi> 
         <mi>
           e 
         </mi> 
         <mtext>
           _ 
         </mtext> 
         <mi>
           b 
         </mi> 
         <msub> 
          <mi>
            w 
          </mi> 
          <mrow> 
           <msub> 
            <mi>
              l 
            </mi> 
            <mn>
              2 
            </mn> 
           </msub> 
          </mrow> 
         </msub> 
         <mo>
           , 
         </mo> 
         <mo>
           ⋯ 
         </mo> 
         <mo>
           , 
         </mo> 
         <mi>
           f 
         </mi> 
         <mi>
           r 
         </mi> 
         <mi>
           e 
         </mi> 
         <mi>
           e 
         </mi> 
         <mtext>
           _ 
         </mtext> 
         <mi>
           b 
         </mi> 
         <msub> 
          <mi>
            w 
          </mi> 
          <mrow> 
           <msub> 
            <mi>
              l 
            </mi> 
            <mi>
              n 
            </mi> 
           </msub> 
          </mrow> 
         </msub> 
        </mrow> 
        <mo>
          ) 
        </mo> 
       </mrow> 
      </mrow> 
     </math> (13)</p>
    <p>A link is often part of multiple paths, so the available bandwidth of different links in a path varies. To avoid overloading certain links and improve transmission efficiency, the load balancing degree of a link is considered when selecting a forwarding path. In this paper, the bandwidth equalization degree of a path is expressed as the difference between the minimum and maximum values of the bandwidth between all nodes in the path:</p>
    <p>
     <math display="inline" xmlns="http://www.w3.org/1998/Math/MathML"> <mrow> 
       <mi>
         B 
       </mi> 
       <mo>
         = 
       </mo> 
       <mfrac> 
        <mrow> 
         <mi>
           min 
         </mi> 
         <mrow> 
          <mo>
            ( 
          </mo> 
          <mrow> 
           <mi>
             f 
           </mi> 
           <mi>
             r 
           </mi> 
           <mi>
             e 
           </mi> 
           <mi>
             e 
           </mi> 
           <mtext>
             _ 
           </mtext> 
           <mi>
             b 
           </mi> 
           <msub> 
            <mi>
              w 
            </mi> 
            <mrow> 
             <msub> 
              <mi>
                l 
              </mi> 
              <mn>
                1 
              </mn> 
             </msub> 
            </mrow> 
           </msub> 
           <mo>
             , 
           </mo> 
           <mi>
             f 
           </mi> 
           <mi>
             r 
           </mi> 
           <mi>
             e 
           </mi> 
           <mi>
             e 
           </mi> 
           <mtext>
             _ 
           </mtext> 
           <mi>
             b 
           </mi> 
           <msub> 
            <mi>
              w 
            </mi> 
            <mrow> 
             <msub> 
              <mi>
                l 
              </mi> 
              <mn>
                2 
              </mn> 
             </msub> 
            </mrow> 
           </msub> 
           <mo>
             , 
           </mo> 
           <mo>
             ⋯ 
           </mo> 
           <mo>
             , 
           </mo> 
           <mi>
             f 
           </mi> 
           <mi>
             r 
           </mi> 
           <mi>
             e 
           </mi> 
           <mi>
             e 
           </mi> 
           <mtext>
             _ 
           </mtext> 
           <mi>
             b 
           </mi> 
           <msub> 
            <mi>
              w 
            </mi> 
            <mrow> 
             <msub> 
              <mi>
                l 
              </mi> 
              <mi>
                n 
              </mi> 
             </msub> 
            </mrow> 
           </msub> 
          </mrow> 
          <mo>
            ) 
          </mo> 
         </mrow> 
        </mrow> 
        <mrow> 
         <mi>
           max 
         </mi> 
         <mrow> 
          <mo>
            ( 
          </mo> 
          <mrow> 
           <mi>
             f 
           </mi> 
           <mi>
             r 
           </mi> 
           <mi>
             e 
           </mi> 
           <mi>
             e 
           </mi> 
           <mtext>
             _ 
           </mtext> 
           <mi>
             b 
           </mi> 
           <msub> 
            <mi>
              w 
            </mi> 
            <mrow> 
             <msub> 
              <mi>
                l 
              </mi> 
              <mn>
                1 
              </mn> 
             </msub> 
            </mrow> 
           </msub> 
           <mo>
             , 
           </mo> 
           <mi>
             f 
           </mi> 
           <mi>
             r 
           </mi> 
           <mi>
             e 
           </mi> 
           <mi>
             e 
           </mi> 
           <mtext>
             _ 
           </mtext> 
           <mi>
             b 
           </mi> 
           <msub> 
            <mi>
              w 
            </mi> 
            <mrow> 
             <msub> 
              <mi>
                l 
              </mi> 
              <mn>
                2 
              </mn> 
             </msub> 
            </mrow> 
           </msub> 
           <mo>
             , 
           </mo> 
           <mo>
             ⋯ 
           </mo> 
           <mo>
             , 
           </mo> 
           <mi>
             f 
           </mi> 
           <mi>
             r 
           </mi> 
           <mi>
             e 
           </mi> 
           <mi>
             e 
           </mi> 
           <mtext>
             _ 
           </mtext> 
           <mi>
             b 
           </mi> 
           <msub> 
            <mi>
              w 
            </mi> 
            <mrow> 
             <msub> 
              <mi>
                l 
              </mi> 
              <mi>
                n 
              </mi> 
             </msub> 
            </mrow> 
           </msub> 
          </mrow> 
          <mo>
            ) 
          </mo> 
         </mrow> 
        </mrow> 
       </mfrac> 
      </mrow> 
     </math> (14)</p>
    <p>Combining the available bandwidth and bandwidth equalization of the above paths with the LSTM prediction of the available traffic and bandwidth equalization, the transmission cost of the paths is used as a weight for path selection. In addition, in order to guarantee the transmission of the data flow, one path is selected at a time and only one path is selected, and there are no loops in the selected paths, so that the objective function definition is obtained:</p>
    <p>
     <math display="inline" xmlns="http://www.w3.org/1998/Math/MathML"> <mtable columnalign="left"> 
       <mtr> 
        <mtd> 
         <mi>
           min 
         </mi> 
         <mfrac> 
          <mn>
            1 
          </mn> 
          <mrow> 
           <mi>
             A 
           </mi> 
           <mo>
             + 
           </mo> 
           <mi>
             B 
           </mi> 
           <mo>
             + 
           </mo> 
           <msub> 
            <mi>
              A 
            </mi> 
            <mrow> 
             <mi>
               p 
             </mi> 
             <mi>
               r 
             </mi> 
             <mi>
               e 
             </mi> 
            </mrow> 
           </msub> 
           <mo>
             + 
           </mo> 
           <msub> 
            <mi>
              B 
            </mi> 
            <mrow> 
             <mi>
               p 
             </mi> 
             <mi>
               r 
             </mi> 
             <mi>
               e 
             </mi> 
            </mrow> 
           </msub> 
          </mrow> 
         </mfrac> 
        </mtd> 
       </mtr> 
       <mtr> 
        <mtd> 
         <mtext>
           s 
         </mtext> 
         <mtext>
           .t 
         </mtext> 
         <mo>
           . 
         </mo> 
         <mtext>
             
         </mtext> 
         <mtext>
             
         </mtext> 
         <mrow> 
          <mo>
            { 
          </mo> 
          <mrow> 
           <mtable columnalign="left"> 
            <mtr columnalign="left"> 
             <mtd columnalign="left"> 
              <mrow> 
               <mstyle displaystyle="true"> 
                <munderover> 
                 <mo>
                   ∑ 
                 </mo> 
                 <mrow> 
                  <mi>
                    r 
                  </mi> 
                  <mo>
                    = 
                  </mo> 
                  <mn>
                    1 
                  </mn> 
                 </mrow> 
                 <mi>
                   n 
                 </mi> 
                </munderover> 
                <mrow> 
                 <msub> 
                  <mi>
                    x 
                  </mi> 
                  <mi>
                    r 
                  </mi> 
                 </msub> 
                 <mo>
                   ≤ 
                 </mo> 
                 <mn>
                   1 
                 </mn> 
                </mrow> 
               </mstyle> 
              </mrow> 
             </mtd> 
            </mtr> 
            <mtr columnalign="left"> 
             <mtd columnalign="left"> 
              <mrow> 
               <mi>
                 P 
               </mi> 
               <mo>
                 = 
               </mo> 
               <mi>
                 p 
               </mi> 
              </mrow> 
             </mtd> 
            </mtr> 
           </mtable> 
          </mrow> 
         </mrow> 
        </mtd> 
       </mtr> 
      </mtable> 
     </math> (15)</p>
    <p>In Equation (15), n is the number of all forwarding paths calculated from the source destination address.</p>
   </sec>
   <sec id="s3_4">
    <title>3.4. Design of LSTM-QALB Path Forwarding Algorithm</title>
    <p>The optimal path is solved by quantum annealing algorithm and the solution process is shown in <xref ref-type="bibr" rid="scirp.134823-#Algorithm1">
      Algorithm 1
     </xref>:</p>
    <p>
     <xref ref-type="bibr" rid="scirp.134823-"></xref>Algorithm 1. Optimal path selection based on LSTM and QA.</p>
    <table class="MsoTableGrid custom-table" border="0" cellspacing="0" cellpadding="0"> 
     <tr> 
      <td class="custom-bottom-td aleft" width="97.79%" colspan="2"><p style="text-align:left">Input: topological directed graph G</p><p style="text-align:left">Output: optimal forwarding path</p></td> 
     </tr> 
     <tr> 
      <td class="custom-top-td acenter" width="5.98%"><p style="text-align:center">1</p></td> 
      <td class="custom-top-td aleft" width="91.81%"><p style="text-align:left">Get the set of forwarding paths all_paths based on the source directory address.</p></td> 
     </tr> 
     <tr> 
      <td class="acenter" width="5.98%"><p style="text-align:center">2</p></td> 
      <td class="aleft" width="91.81%"><p style="text-align:left">for path in all_paths do</p></td> 
     </tr> 
     <tr> 
      <td class="acenter" width="5.98%"><p style="text-align:center">3</p></td> 
      <td class="aleft" width="91.81%"><p style="text-align:left">Calculate the available bandwidth for all links on the path, save to total_weights.</p></td> 
     </tr> 
     <tr> 
      <td class="acenter" width="5.98%"><p style="text-align:center">4</p></td> 
      <td class="aleft" width="91.81%"><p style="text-align:left">Predict the available bandwidth of all links on the path, saved to total_forecast_weights.</p></td> 
     </tr> 
     <tr> 
      <td class="acenter" width="5.98%"><p style="text-align:center">5</p></td> 
      <td class="aleft" width="91.81%"><p style="text-align:left">for weights in total_weights do</p></td> 
     </tr> 
     <tr> 
      <td class="acenter" width="5.98%"><p style="text-align:center">6</p></td> 
      <td class="aleft" width="91.81%"><p style="text-align:left">Calculate the available bandwidth of the path and save it to free_bws.</p></td> 
     </tr> 
     <tr> 
      <td class="acenter" width="5.98%"><p style="text-align:center">7</p></td> 
      <td class="aleft" width="91.81%"><p style="text-align:left">Calculate load balancing of paths, save to balances.</p></td> 
     </tr> 
     <tr> 
      <td class="acenter" width="5.98%"><p style="text-align:center">8</p></td> 
      <td class="aleft" width="91.81%"><p style="text-align:left">for forecast_weights in total_forecast_weights do</p></td> 
     </tr> 
     <tr> 
      <td class="acenter" width="5.98%"><p style="text-align:center">9</p></td> 
      <td class="aleft" width="91.81%"><p style="text-align:left">Calculate available bandwidth for path prediction, save to forecast_free_weights.</p></td> 
     </tr> 
     <tr> 
      <td class="acenter" width="5.98%"><p style="text-align:center">10</p></td> 
      <td class="aleft" width="91.81%"><p style="text-align:left">Calculate the load balancing degree of the path prediction and save it to forecast_balances.</p></td> 
     </tr> 
     <tr> 
      <td class="acenter" width="5.98%"><p style="text-align:center">11</p></td> 
      <td class="aleft" width="91.81%"><p style="text-align:left">Define the Hamiltonian quantity.</p></td> 
     </tr> 
     <tr> 
      <td class="acenter" width="5.98%"><p style="text-align:center">12</p></td> 
      <td class="aleft" width="91.81%"><p style="text-align:left">Calculation of optimal forwarding paths based on quantum annealing algorithm.</p></td> 
     </tr> 
    </table>
   </sec>
  </sec><sec id="s4">
   <title>4. Experimental Analyses</title>
   <p>In this paper, we simulate the changes in the distribution of network traffic in the data center through python and choose a Fat-tree with k = 4 as the experimental topology, as shown in <xref ref-type="fig" rid="fig4">
     Figure 4
    </xref>, which contains 4 core switches, 8 aggregation switches, 8 edge switches and 16 servers.</p>
   <fig id="fig4" position="float">
    <label>Figure 4</label>
    <caption>
     <title>
      <xref ref-type="bibr" rid="scirp.134823-"></xref>Figure 4. Fat-tree (k = 4) topology.</title>
    </caption>
    <graphic mimetype="image" position="float" xlink:type="simple" xlink:href="https://html.scirp.org/file/1732776-rId91.jpeg?20240726020623" />
   </fig>
   <p>The link bandwidths are all set to 100 Mbps, the link delay is 1 ms, and the traffic data of 64 links are collected from the simulation environment. After a number of learning training, set the number of iterations to 250, using Adam’s algorithm, the learning rate is 0.001. Then the traffic is predicted, and four evaluation index values are obtained: MAE = 4.99, RMSE = 7.28, MAPE = 5.65%, SMAPE = 2.76%, the model prediction is more accurate.</p>
   <p>The Poisson model <xref ref-type="bibr" rid="scirp.134823-13">
     [13]
    </xref> is used, where the source and destination hosts are randomly selected each time, so that the number n of packets arriving in time sequence t satisfies the Poisson distribution with parameter 
    <math display="inline" xmlns="http://www.w3.org/1998/Math/MathML"> <mrow> 
      <mi>
        λ 
      </mi> 
      <mi>
        t 
      </mi> 
     </mrow> 
    </math>, i.e., 
    <math display="inline" xmlns="http://www.w3.org/1998/Math/MathML"> <mrow> 
      <mi>
        P 
      </mi> 
      <mrow> 
       <mo>
         ( 
       </mo> 
       <mi>
         n 
       </mi> 
       <mo>
         ) 
       </mo> 
      </mrow> 
      <mo>
        = 
      </mo> 
     </mrow> 
    </math> 
    <math display="inline" xmlns="http://www.w3.org/1998/Math/MathML"> <mrow> 
      <mfrac> 
       <mrow> 
        <msup> 
         <mtext>
           e 
         </mtext> 
         <mrow> 
          <mo>
            − 
          </mo> 
          <mi>
            λ 
          </mi> 
          <mi>
            t 
          </mi> 
         </mrow> 
        </msup> 
        <msup> 
         <mrow> 
          <mrow> 
           <mo>
             ( 
           </mo> 
           <mrow> 
            <mi>
              λ 
            </mi> 
            <mi>
              t 
            </mi> 
           </mrow> 
           <mo>
             ) 
           </mo> 
          </mrow> 
         </mrow> 
         <mi>
           n 
         </mi> 
        </msup> 
       </mrow> 
       <mrow> 
        <mi>
          n 
        </mi> 
        <mo>
          ! 
        </mo> 
       </mrow> 
      </mfrac> 
     </mrow> 
    </math>, and its corresponding sequence of packet arrivals at the time interval T is exponentially distributed, i.e., 
    <math display="inline" xmlns="http://www.w3.org/1998/Math/MathML"> <mrow> 
      <mi>
        F 
      </mi> 
      <mrow> 
       <mo>
         ( 
       </mo> 
       <mi>
         T 
       </mi> 
       <mo>
         ) 
       </mo> 
      </mrow> 
      <mo>
        = 
      </mo> 
      <mn>
        1 
      </mn> 
      <mo>
        − 
      </mo> 
      <msup> 
       <mtext>
         e 
       </mtext> 
       <mrow> 
        <mo>
          − 
        </mo> 
        <mi>
          λ 
        </mi> 
        <mi>
          t 
        </mi> 
       </mrow> 
      </msup> 
     </mrow> 
    </math>. The parameters were adjusted from 0.1 to 0.9 to simulate different network loads, and each set of experiments was repeated 10 times to improve the accuracy of experimental data.</p>
   <p>In this paper, the LSTM-QALB algorithm is compared with MTDLR and EERA algorithms for throughput and packet loss. The experimental results in <xref ref-type="fig" rid="fig5">
     Figure 5
    </xref> and <xref ref-type="fig" rid="fig6">
     Figure 6
    </xref> show that as the network load increases, the system throughput and packet loss rate both increase; when the parameter is greater than 0.5, namely, when the load is high, the system throughput increases slowly and the packet loss rate rises sharply. When the load is low, the performance of the three algorithms is similar, but when the load is high, the LSTM-QALB algorithm outperforms the other two.</p>
   <fig id="fig5" position="float">
    <label>Figure 5</label>
    <caption>
     <title>
      <xref ref-type="bibr" rid="scirp.134823-"></xref>Figure 5. Comparison of system throughput of different algorithms.</title>
    </caption>
    <graphic mimetype="image" position="float" xlink:type="simple" xlink:href="https://html.scirp.org/file/1732776-rId100.jpeg?20240726020623" />
   </fig>
   <fig id="fig6" position="float">
    <label>Figure 6</label>
    <caption>
     <title>
      <xref ref-type="bibr" rid="scirp.134823-"></xref>Figure 6. Comparison of average packet loss rate of different algorithms.</title>
    </caption>
    <graphic mimetype="image" position="float" xlink:type="simple" xlink:href="https://html.scirp.org/file/1732776-rId101.jpeg?20240726020623" />
   </fig>
  </sec><sec id="s5">
   <title>5. Conclusion</title>
   <p>In this paper, we propose a load balancing algorithm LSTM-QALB based on LSTM dynamic traffic prediction and quantum annealing, which selects the optimal forwarding path by calculating the available bandwidth of the current and predicted paths with the link bandwidth equalization. Compared with MTDLR and EERA algorithms, LSTM-QALB has obvious advantages in terms of system throughput and average packet loss rate, which achieves the purpose of load balancing and improving the network quality of service.</p>
  </sec>
 </body><back>
  <ref-list>
   <title>References</title>
   <ref id="scirp.134823-ref1">
    <label>1</label>
    <mixed-citation publication-type="other" xlink:type="simple">
     Li, W.X., Qi, H., Xu, R.H., Zhou, X.B. and Li, K.Q.Q. (2020) Data Center Network Flow Scheduling Progress and Trends. Journal of Computing, 4, 600-617.
    </mixed-citation>
   </ref>
   <ref id="scirp.134823-ref2">
    <label>2</label>
    <mixed-citation publication-type="other" xlink:type="simple">
     Macedo, D.F., Guedes, D., Vieira, L.F., Vieira, M.A. and Nogueira, M. (2015) Programmable Networks—From Software-Defined Radio to Software-Defined Networking. IEEE Communications Surveys&amp;Tutorials, 17, 1102-1125. &gt;https://doi.org/10.1109/COMST.2015.2402617 
    </mixed-citation>
   </ref>
   <ref id="scirp.134823-ref3">
    <label>3</label>
    <mixed-citation publication-type="other" xlink:type="simple">
     Wang, F., Yao, H., Zhang, Q., Wang, J., Gao, R., Guo, D. and Guizani, M. (2021) Dynamic Distributed Multi-Path Aided Load Balancing for Optical Data Center Networks. IEEE Transactions on Network and Service Management, 19, 991-1005. &gt;https://doi.org/10.1109/TNSM.2021.3125307 
    </mixed-citation>
   </ref>
   <ref id="scirp.134823-ref4">
    <label>4</label>
    <mixed-citation publication-type="other" xlink:type="simple">
     Saifullah, M.A. and Mohamed, M.M. (2016). Open Flow-Based Server Load Balancing Using Improved Server Health Reports. 2016 2nd International Conference on Advances in Electrical, Electronics, Information, Communication and Bio-Informatics, Chennai, 27-28 February 2016, 649-651. &gt;https://doi.org/10.1109/AEEICB.2016.7538369 
    </mixed-citation>
   </ref>
   <ref id="scirp.134823-ref5">
    <label>5</label>
    <mixed-citation publication-type="other" xlink:type="simple">
     Zhang, C.H. and Zhou, J.Q. Energy-Efficient Scheduling Scheme for Software-Defined Data Center Network Traffic Based on Bandwidth Matching. Systems Engineering and Electronics, 1-13. &gt;https://link.cnki.net/urlid/11.2422.TN.20240325.1505.018 
    </mixed-citation>
   </ref>
   <ref id="scirp.134823-ref6">
    <label>6</label>
    <mixed-citation publication-type="other" xlink:type="simple">
     Montazerolghaem, A. (2022) Software-Defined Internet of Multimedia Things: Energy-Efficient and Load-Balanced Resource Management. IEEE Internet of Things Journal, 9, 2432-2442. &gt;https://doi.org/10.1109/JIOT.2021.3095237 
    </mixed-citation>
   </ref>
   <ref id="scirp.134823-ref7">
    <label>7</label>
    <mixed-citation publication-type="other" xlink:type="simple">
     Guo, A. and Yuan, C. (2021) Network Intelligent Control and Traffic Optimization Based on SDN and Artificial Intelligence. Electronics, 10, Article 700. &gt;https://doi.org/10.3390/electronics10060700 
    </mixed-citation>
   </ref>
   <ref id="scirp.134823-ref8">
    <label>8</label>
    <mixed-citation publication-type="other" xlink:type="simple">
     Guo, L. (2018). Designing and Implementation of Load Balancing Methods in Data Center Networks Based on Openflow. Master’s Thesis, Beijing Institute of Technology.
    </mixed-citation>
   </ref>
   <ref id="scirp.134823-ref9">
    <label>9</label>
    <mixed-citation publication-type="other" xlink:type="simple">
     Hochreiter, S. and Schmidhuber, J. (1997) Long Short-Term Memory. Neural Computation, 9, 1735-1780. &gt;https://doi.org/10.1162/neco.1997.9.8.1735 
    </mixed-citation>
   </ref>
   <ref id="scirp.134823-ref10">
    <label>10</label>
    <mixed-citation publication-type="other" xlink:type="simple">
     Metropolis, N., Rosenbluth, A.W., Rosenbluth, M.N., Teller, A.H. and Teller, E. (1953) Equation of State Calculations by Fast Computing Machines. The Journal of Chemical Physics, 21, 1087-1092. &gt;https://doi.org/10.1063/1.1699114 
    </mixed-citation>
   </ref>
   <ref id="scirp.134823-ref11">
    <label>11</label>
    <mixed-citation publication-type="other" xlink:type="simple">
     Kirkpatrick, S., Gelatt, Jr. and Vecchi, M.P. (1983) Optimization by Simulated Annealing. Science, 220, 671-680. &gt;https://doi.org/10.1126/science.220.4598.671 
    </mixed-citation>
   </ref>
   <ref id="scirp.134823-ref12">
    <label>12</label>
    <mixed-citation publication-type="other" xlink:type="simple">
     Finnila, A.B., Gomez, M.A., Sebenik, C., Stenson, C. and Doll, J.D. (1994) Quantum Annealing: A New Method for Minimizing Multidimensional Functions. Chemical Physics Letters, 219, 343-348. &gt;https://doi.org/10.1126/science.220.4598.671 
    </mixed-citation>
   </ref>
   <ref id="scirp.134823-ref13">
    <label>13</label>
    <mixed-citation publication-type="other" xlink:type="simple">
     Zhang, B., Yang, J.H. and Wu, J.P. (2011) Survey and Analysis on the Internet Traffic Model. Journal of Software, 22, 115-131. &gt;https://doi.org/10.3724/SP.J.1001.2011.03950
    </mixed-citation>
   </ref>
  </ref-list>
 </back>
</article>