A FAIR TASK OFFLOADING AND MIGRATION METHOD FOR EDGE SERVICE NETWORKS

Abstract

The present invention discloses a fair task offloading and migration method for edge service networks, taking the Pareto optimality of the utility function of all user tasks executed by the edge system as the optimization objective, this approach not only takes into account the constraints of edge network resources, but also ensures the maximization of the utility function of all user tasks in the system, it proposes a new quantitative measurement index for improving the task utility quality under multi-user competition. In addition, the present invention uses the graph neural network and reinforcement learning algorithm to solve the final optimization goal, this algorithm has high execution efficiency and returns accurate approximate results, which is particularly suitable for the scene of edge network system under multi-user complex tasks, so that when multi-user tasks compete for network resources, the edge computing network system can efficiently obtain the Pareto optimal result of multi-user utility function, greatly improving the service quality and user experience of edge network environments.

Description

TECHNICAL FIELD

The present invention belongs to the technical field of load balancing on edge computing network, in particular to a fair task offloading and migration method for edge service networks.

DESCRIPTION OF RELATED ART

In recent years, with the increasing popularity of edge computing technology, the user computing load offloading and migration technology has developed rapidly. However, server resources and link resources in the edge environment are often scarce, resulting in servers in the edge environment may not be able to support all current service types; due to the limited variety of services deployed on the server, some user tasks require migration through the current server to be executed on other servers. In response to the mobility of users and the diversity of server requests in edge network environments, and the limited computing resources of edge servers in the region, it is worth researching how to reasonably allocate different computing resources and network bandwidth resources to different users based on fair execution of these user computing offloading loads, in order to ensure that the service experience of all users reaches a fair state.

Each user has personalized needs, such as bandwidth sensitive tasks (such as live streaming services, video on demand services, etc.), and computing sensitive tasks (such as AI algorithm calculation tasks, virtual reality graphics rendering tasks, etc.); the existing research on service algorithms of edge computing networks for real-time task response needs mostly focuses on the overall efficiency of tasks, from the perspective of network bandwidth and server resource utilization, it is relatively rare to consider Pareto solutions for the utility needs of multiple different user individuals. Due to the marginal effect of the user utility function, allocating different types and quantities of resources to users may not necessarily achieve the highest overall utility for a single user; in addition, in an edge network environment with limited overall resources, there are resource allocation conflicts among multiple users, which makes it difficult to fully meet the personalized needs of users and achieve Pareto optimization solutions. In the edge network environment shown in FIG. 3, there are 5 users and 3 edge servers. Users can choose to offload tasks to any edge server in the overlapping area of edge server services; how to select edge servers for task execution for users and schedule task migration between different servers, while maximizing the utility function for all users, is a challenging problem.

Reference [Yao Zewei, Lin Jiawen, Hu Junqin, et al. PSO-GA Based Approach to Multi-edge Load Balancing [J]. Computer Science, 2021, 48(S02):8] proposed a method for balancing edge environment load, with the goal of minimizing the maximum response time of user tasks, using heuristic algorithms to make decisions on user tasks, so that multiple user tasks are assigned to different servers for execution. Reference [Liang Bing, Ji Wen. Multiuser computation offloading for edge-cloud collaboration using submodular optimization[J]. Journal on Communications, 2020, 41 (10): 12] proposed the problem of maximizing the user's utility function, which simply adds and sums the user's utility, with the goal of maximizing the efficiency of all tasks and scheduling user tasks for execution. The above two strategies cannot guarantee that all users' tasks are executed fairly, and may result in sacrificing the quality of service of certain individual users for improving overall performance, resulting in excessive execution time of certain user tasks or a decrease in user's utility function.

SUMMARY THE PRESENT INVENTION

In response to the marginal effect of resources demand for users and the nonlinear conflict of resources allocation, the present invention provides a fair task offloading and migration method for edge service networks under network operation, which can greatly improve the overall utility requirements of all users and achieve Pareto optimality for all users in edge network environments with limited resources.

A fair task offloading and migration method for edge service networks, comprising the following steps:

• • (1) detecting task requests of mobile users in the edge network, and determining all currently detected user task requests;
  • (2) enumerating migration paths of all user task requests transmitted to the edge server;
  • (3) establishing a fair utility evaluation function for evaluating user tasks;
  • (4) optimizing and solving the fair utility evaluation function, the migration path for each user task request can be determined.

Furthermore, for any user task request in step (2), the following three types of migration paths are enumerated:

• • E1 is a set of migration paths for edge servers directly connected to users;
  • E2 is a set of migration paths for edge servers that are indirectly connected to users in a single hop manner, and edge servers that are directly connected to users do not have processing capabilities;
  • E3 is a set of migration paths for edge servers that are indirectly connected to users in a single hop manner, and edge servers that are directly connected to users have processing capabilities.

Furthermore, an expression of the fair utility evaluation function is as follows:

$\begin{array}{c}\max U={\left(U_1,\dots ,U_N\right)}^T\\ U_i=\sum _{k\in 𝒦}{w}_k{U}_i^k,U_i^k=\frac{x_{i,k}^{1-{\alpha }_i^k}}{1-{\alpha }_i^k}\\ \sum _{i_l\in {𝒩}_{\ell }}\mathrm{trans}\left(i_l\right)<c_l,l\in ℰ\\ \sum _{i_v\in {𝒩}_v}comp\left(i_v\right)<c_v,v\in 𝒱\end{array}$

• • among them: U; is the utility function for executing the i-th user task request, if the i-th user task request cannot be unloaded and executed, then U_i=U_l, and U_l is a constant, i is a natural number and 1≤i≤N, N is the number of all users, U_i^k is the utility value of resource k occupied by executing the i-th user task request, w_k represents the weight of resource k, and is the resource set, comprising bandwidth resources and computing resources, α_i^k represents a custom parameter for the personalized utility function of resource k for the i-th user task request, and x_i,k represents the quantity value of resource k occupied by the i-th user task request; l represents any transmission link in the edge network, represents a set of transmission links in the edge network, v represents any edge server in the edge network, represents a set of edge servers in the edge network, is the set of all user task requests that occupy the transmission link l, is the set of all user task requests that are calculated on the edge server v, i_l is any user task request in the set , i_v is any user task request in the set , trans(i) is the amount of the bandwidth resource occupied by the user task request i_l on the transmission link l, comp(i_v) is the amount of the computational resource occupied by the user task request i_v on the edge server v, c_l is the actual bandwidth upper limit of the transmission link l, and c_v is the actual maximum computing power of the edge server v.

Each edge server can perform several services, and each user can only perform one service.

Furthermore, the specific process of optimizing and solving the fair utility evaluation function in step (4) is as follows:

• • 4.1. establishing a user shared neural network layer and N user decision models, wherein the user shared neural network layer comprises a graph neural network and a nonlinear aggregation function, N represents the number of all users;
  • 4.2. using the graph neural network to extract information about nodes and edges in the edge network, and combining this information into feature vectors; the nodes correspond to mobile users and edge servers in the edge network, and the edges correspond to the transmission links between mobile users and edge servers, as well as the transmission links between edge servers;
  • 4.3 using the graph neural network to extract information about nodes and edges in the task feasible migration path subgraph, and combining the information into feature vectors;
  • 4.4 for any migration path in the task feasible migration path subgraph, the graph neural network is used to extract the information of nodes and edges, and the information are combined into feature vectors;
  • 4.5 inputting all the extracted feature vectors into each user decision model, and the user decision model outputs the selected probability of each migration path corresponding to the user task requests;
  • 4.6 first determining the priority of each user task request for offloading, then determining the offloading migration path for each user's task request, and then offloading each user's task request based on the priority and offloading migration path.

Furthermore, the information of the edges comprises the bandwidth occupied by each user task request on the transmission links between the mobile users and the edge servers, as well as the actual bandwidth upper limit of the transmission links; the information of the nodes comprises the amount of computing resources required for user task requests and the actual maximum computing power of the edge servers.

Furthermore, the task feasible migration path subgraph corresponds one-to-one with the user task requests, which is composed of all user task migration paths corresponding to the request, the user task migration path represents a specific migration path used by the user task request to perform offloading.

Furthermore, the parameters θ_{user i} of the user decision model are optimized and solved through a reward function;

$r_i=\frac{1}{T}\sum _t\max \left\{\eta \left(U_i\left(t+1\right)-U_i\left(t\right)\right),\delta \right\}$

• • among them, r_i represents the reward function of the i-th user decision model, U_i(t+1) and U_i(t) represents the utility function of executing the i-th user task request during the t+1 and t iterations, respectively, η is a given parameter, t is a natural number, T is the total number of iterations, and δ is a positive smaller given parameter.

Furthermore, the parameters of the user shared neural network layer are iterated through the following formula until the utility function of all user task requests reaches Pareto optimality;

${\theta }_{\mathrm{share}}\left(t+1\right)={\theta }_{\mathrm{share}}\left(t\right)-\sum _i{\alpha }_i{\nabla }_R{ℒ}_i\left({\theta }_{\mathrm{share}},{\theta }_{\mathrm{user}i}\right)$

• • among them, θ_share (t+1) and θ_share(t) represent the parameters of the user shared neural network layer during the t+1 and t iterations, respectively, α_i is the weight value of the reward function for the i-th user decision model, ∇_R represents calculating the partial derivative, (θ_share, θ_{user i})=1/r_i.

Furthermore, the weight value α_i is obtained by solving the following loss function by using the Frank Wolfe algorithm;

$\min {\sum _i{\alpha }_i{\nabla }_R{ℒ}_i\left({\theta }_{\mathrm{share}},{\theta }_{\mathrm{user}i}\right)}_2^2$

• • wherein, ∥ ∥₂ represents a 2-norm.

Furthermore, in step 4.6, for the selected probabilities of all migration paths requested by any user task, the highest of the first K selected probabilities is averaged as the priority for offloading the user task request, the migration path corresponding to the highest selected probability is taken as the offloading migration path by the user task request, with K being a natural number greater than 1.

The present invention takes the Pareto optimality of the utility function of all user tasks executed by the edge system as the optimization objective, this approach not only takes into account the constraints of edge network resources, but also ensures the maximization of the utility function of all user tasks in the system, it proposes a new quantitative measurement index for improving the task utility quality under multi-user competition. In addition, the present invention uses the graph neural network and reinforcement learning algorithm to solve the final optimization goal, this algorithm has high execution efficiency and returns accurate approximate results, which is particularly suitable for the scene of edge network system under multi-user complex tasks, so that when multi-user tasks compete for network resources, the edge computing network system can efficiently obtain the Pareto optimal result of multi-user utility function, greatly improving the service quality and user experience of edge network environments.

BRIEF DESCRIPTION OF THE DRAWINGS

FIG. 1 (a) is a schematic diagram of the network topology that user tasks can connect to.

FIG. 1 (b) is an enumeration diagram of feasible migration paths for user tasks.

FIG. 2 is a schematic diagram of the neural network algorithm framework for calculating user migration path decisions.

FIG. 3 is a schematic diagram of the edge network system.

DETAILED DESCRIPTION OF THE INVENTION

In order to provide a more specific description of the present invention, the following will provide a detailed explanation of the technical solution of the present invention in conjunction with the accompanying drawings and specific implementation methods.

A fair task offloading and migration method for edge service networks of the present invention, comprising the following steps:

• • (1) detecting task requests of mobile users in the edge network, and determining all currently detected user task requests;
  • (2) enumerating migration paths of all user task requests transmitted to the edge server;
  • (3) establishing a fair utility evaluation function for evaluating user tasks:

$\begin{array}{cc}\max U,U={\left(U_1,\dots ,U_n\right)}^T,& n\in \end{array}𝒩$

• • among them: represents the user set, and i represents the user index; if a user task can be executed by an edge server, the fair utility function representing the user is defined as follows; otherwise, U_i=δ, and δ is a small normal number that is customized by the edge system environment in advance, this constant indicates that when user tasks can only be executed locally and cannot be migrated to the edge server for execution, user utility will be greatly reduced.

$U_i=\sum _{k\in 𝒦}{w}_k{U}_i^k,U_i^k=\frac{x_{i,k}^{1-{\alpha }_i^k}}{1-{\alpha }_i^k}$

• • wherein, the parameter α_i^k represents the personalized utility function of each user for resource k, k represents the type of user resource demand, w_k represents the weight of resource type, w_k=1, and x_i,k represents the number of resource k occupied by user i, in this embodiment, has two values: k=1 represents bandwidth resources, and k=2 represents computing resources.

As shown in FIG. 1 (b), users and servers are viewed as the vertices of the graph, where the set of servers is represented by , the set of transmission links between users and servers is represented by , the transmission link from user i to server j is represented by l_i,j, and the migration link from server j to server k is represented by l_jk, where i represents users, j, k represents edge servers, and i, j, and k belong to the set , l_i,j and l_jk belong to the set , and each link in the set has bandwidth constraints, the maximum limit of user tasks that can be transmitted is trans(i)<c_l, l∈, where c_l is the actual bandwidth parameter of the system network and is the set of all users using the link l; each edge server in has computational bandwidth constraints, and the maximum number of user tasks it can carry is comp(i)<c_v, v∈, where c_v is the actual performance parameter of the system edge server and is the set of all users when performing task calculations on edge server v.

(4) optimizing and solving the fair utility evaluation function, the migration path for each user task request can be determined, the specific implementation is as follows:

We define the server computing load as: workload_i,j+(workload_jⁱⁿ−workload_j^out), where j represents the set of users connected by server j, workloadi,j represents the amount of tasks unloaded by user i to server j, workload_jⁱⁿ represents the amount of tasks transferred by other servers to server j, and workload_j^out represents the amount of tasks transferred by server j to other servers.

Task offloading refers to the ability of users to send tasks to designated edge servers for execution within the service scope of the edge server; task migration refers to the migration of user task to an edge server other than themselves after offloading the destination server and transferring the task from one edge server to another; through the above task offloading and task migration, computing tasks of the users can ultimately reach a certain server for task execution.

The above task transmission path search algorithm is as follows: firstly, i represents the user index, m represents the server index, defined S_m as the set of adjacent servers within one hop of server m, defined O_i^c as the set of servers that cover service scope of user i, and the set of server indexes that can execute user i's tasks is O_i^e, then O_i^c-e=O_i^c\O_i^e represents servers that is directly connected to the user, but cannot execute the tasks submitted by user i. Using O_i^ce=O_i^c∩O_i^e represents servers that is directly connected to the user i, and the servers are capable of performing tasks offloaded by user i.

Adding the direct link between the server and the user in O_i^ce to the set E_i^direct, traversing the server index of O_i^c-e, and recording as z, defining a set E₁^migration=z×S_z∩O_i^e; traversing the server index of O_i^ce, and recording as j, defining a set E₂^migration=j×S_j∩O_i^e.

The first part of the migration link set (the paths composed of user nodes and the first server nodes that cannot perform tasks, as well as a server node with task services) is E₁^migration the second part of the migration link set (the paths composed of user nodes and server nodes that can perform services). From the above steps, the migration path set that user i can perform task transmission is: E_i^direct∪E₁^migration∪E₂^migration.

Decomposing the feasible connection graph of each user (i.e. FIG. 1 (a)) to obtain the feasible connection subgraph of each user (i.e. FIG. 1 (b)), combining the information extraction of each user's feasible connection graph, performing edge and fixed point feature learning on each user's subgraph, and obtaining the graph embedding feature information of each user's task migration path in FIG. 1 (b). On the basis of embedding feature information in the connection feasibility map of all users at all current times, prioritizing the current users, and users with higher priority can perform task offloading and execution; once the user offloads the task, based on the embedding feature information in the user subgraph, a feasible task execution plan is selected, which is to assign an edge server to the task for task offload, if the task needs to be migrated, the edge server for task migration is also specified. The optional execution strategy scheme for user tasks consists of all possible migration paths for the tasks, as shown in FIG. 1 (b). Task 4 of user 1 can be executed by migrating three migration strategies: subgraph 1, subgraph 2, and subgraph 3 to the edge server; using e_i,s represents a graph encoding feature vector of the task migration path s of user i, the set of feasible execution migration paths for user i's task is , where s belongs to .

The following is a detailed description of two types of embedding encoding information for the edge server network system, including embedding encoding information for each element node in the user feasible migration subgraph and embedding encoding information for each element node in the edge network global graph.

Embedding encoding information for feasible migration subgraphs for user i:

The set of all links in the feasible migration subgraph for user i is , the set of servers is φ, and the feature vectors of user nodes in the migration path are u_i; the feature vector fea_l=o_l¹, o_l², . . . , , o_lⁿ (n∈) of the link l represents the bandwidth resources occupied by the user n on the link l, while the feature vector of the server c is fea_c=[p_c¹, p_c², . . . , ], p_cⁿ(n∈) represents the computing resources occupied by user n on the server c. Using a graph neural network g( ) to calculate the embedding encoding information [ω_i^sub, ωⁱ_c, ωⁱ_l]=g(u_i, F_l, F_c) of all element nodes (users, links, servers) in the migration subgraph of user i, fea_l∈F_l, fea_c∈F_c, F_l and F_c represent the set of feature vectors for all links and servers in the feasible migration subgraph. ωⁱ_c=[c₁, c₂, . . . , ], ωⁱ_l=[l₁, l₂, . . . , l_|φ|], c_k(k∈φ) is embedding encoding information for servers, l_k(k∈) is embedding encoding information for links, ω_i^sub(i∈) is embedding encoding information for users, || represents the size of the set of links, and |φ| represents the size of the set of servers.

For global edge network embedding encoding information:

The feature vector of the link l is fea_l=[o_l¹, o_l², . . . , ], o_lⁿ, n∈ represents the bandwidth resources occupied by the user n on the link l. The feature vector of the server c is fea_c=[p_c¹, p_c², . . . , ], p_cⁿ (n∈) represents the computational resources occupied by user n on the server c. Using the graph neural network f( ) to calculate the embedding encoding information [ω_u^g, ω^g_c, ω^g_l]=g(u_i, F_l, F_c) of all element nodes (users, links, servers) in the migration subgraph of user i, fea_l∈F_l, fea_c∈F_c, F_l and F_c represent the set of feature vectors for all links and servers in the feasible migration subgraph. ω^g_c=[c₁, c₂, . . . , ], c_k(k∈) is the embedding encoding information for all servers, || represents the size of the set of links; ω^g_l=[l₁, l₂, . . . , ], l_k(k∈ε) is the embedding encoding information for links, ω_u^g=[u₁, u₂, . . . , ] is embedding encoding information for all users, || representing the size of the set for all servers.

Embedding encoding information after CNN network aggregation:

The input of the CNN network is the [ω_i^sub, ωⁱ_c, ωⁱ_l] of the feasible migration subgraph of all users and the [ω_u^g, ω^g_c, ω^g_l] of the global edge network, the output of the CNN network is [ω_u, ω_l, ω_c], where ω_u represents the embedding encoding information of all users after aggregation, ω_l represents the embedding encoding information of all links after aggregation, and ω_c represents the embedding encoding information of all servers after aggregation.

Using R_i=[e_i¹, e_i², . . . , e_i^s, . . . , ] represent a set of feature vectors of the task migration path of user i, starting from the migration user, the edge server nodes of the user, task migration link, task path, and the edge server node that the task finally reaches as elements in the set; if task migration path of user i s∈E_i^direct, the feature vector is e^s_i=[ω_u(i, s), ω_l(i, s), ω_c (i, s), 0,0], otherwise s∈E₁^migration∪E₂^migration, the feature vector is:

e ^s _i=[ω_u(i, s), ω_l(i, s), ω_c(i, s), ω_l(i, s), ω_c(i, s)]

• • among them: ω_u(i, s) represents the embedding encoding information of user i on the migration path s, ω_l(i, s) and ω_c(i, s) respectively represents the embedding encoding information of server c and link I belonging to user i's task migration path s, and l′ and c′ represents the link and server of the second hop of user i's task migration path s.

As shown in FIG. 2, R={R₁, R₂, . . . , R_i, . . . , } is defined as a set of feature vectors for each user's migration path, Z represents the output of each user's decision model, the i-th user component Zⁱ in Z represents the user's task migration path decision vector.

We aim to maximize fairness for all users, and in the design of the present invention, the system uses the fair utility function value generated by the decision as the evaluation criterion; after the system makes a decision, if all users' fair utility can increase, the system reward function value is (U_i(t+1)−U_i(t))*η, which η is a constant, otherwise, the reward function value for the user is 0. The system is modeled by maximizing the reward function value as a reward in the reinforcement learning model.

The specific description of the system reward function is:

$r_i=\frac{1}{T}\sum _t\max \left\{\eta \left(U_i\left(t+1\right)-U_i\left(t\right)\right),\delta \right\}$

• • wherein: δ is a smaller positive number, and is a given parameter.

The goal of the reinforcement learning algorithm of the present invention is to maximize the reward function. The system uses the policy gradient method to train the offloading and transfer decisions of user tasks, and defines the parameters in the user decision model neural network as θ_{user i}. So policy represents the probability that the system will take action a_t during the state s_t, with a value of π_{θuser i} (s_t, a_t), where action refers to the server selection and migration path selection for the system to offload user tasks. In the operation of the system, each user decision model adopts a formula to update the neural network parameters θ_{user i} of the decision model: θ_{user i}=θ_{user i}+αΣ_t∈T∇_{θuser i} logπ_{θuser i}(s_t, a_t)(Σ_t′=t^|T|r_t′−b_t), α represents a customized learning rate parameter, and b_t represents a benchmark value b_t=Σ_t′∈tr_t′ defined to reduce the average user reward generated by the decision.

The above reinforcement learning algorithm ensures the maximum fair utility function value for all users, but cannot guarantee that the utility of each user is the fairest state; in order to obtain Pareto optimality for all users, the present invention proposes a Pareto fairness algorithm for calculating neural network parameters. As shown in FIG. 2, the parameters of the neural network graph f(⋅), g(⋅) table and CNN network are merged and defined as shared parameters θ_share, which R are the output of the user shared neural network layer, and =r_t is the loss function corresponding to user i, once the reinforcement learning algorithm mentioned above is updated θ_{user i}, α₁, α₂, . . . , α_n are solved using the FRANK WOLFE SOLVER method:

$\min {\sum _{i\in 𝒩}{\alpha }_i{\nabla }_R{ℒ}_i\left({\theta }_{\mathrm{share}},{\theta }_{\mathrm{user}i}\right)}_2^2\mathrm{and}\sum _{i\in 𝒩}{\alpha }_i=1$

• • among them, ε represents the accuracy requirements of the system and the set system parameters, after multiple iterations of the algorithm steps mentioned above, if the accuracy requirements of the above equation are still met, then the system assumes that all users have met the Pareto fairness requirements, and the shared parameters at this time are θ_share.

The set of migration paths for user feasible task transmission is defined as E_i=E_i^direct∪E₁^migration∪E₂^migration, where the elements of the output vector of the neural network system shown in FIG. 2 correspond one-to-one to the decision vector Z_i of the task migration path for each user i, each element in the Z_i is used as a judgment value for whether each task path is selected for E_i, which Z_i^k represents the judgment value of the kth feasible task migration path E_i selected by user i.

The present invention designs an optimal sorting function tpk(X)=X/k, which returns the average value of the largest first k components in the input vector, defining the user who prioritizes the task migration path in each iteration of the system as i*=argmax; {V₁, V₂, . . . , V_n}, V=[tpk(Z¹), tpk(Z²),tpk(Z³), . . . ,tpk(Z^N)]. Once the user is selected, the system assigns the optimal task migration path to them, using the largest component k=argmax_k{Z_i^k} in each user's decision vector as the final selected task migration path index for each user, selecting the k-th migration path in the set E_i of migration paths for user i's task transmission.

Under the constraint conditions trans(i)<c_l, l∈ and comp(i)<c_v, v∈, repeating the above selection until any constraint is not met. At this point, the path selection decision vectors for each user are obtained, and users without assigned migration paths choose to execute locally.

According to the neural network algorithm framework shown in FIG. 2, backpropagation training is conducted. On the premise of meeting the accuracy requirements ε, the edge network is simulated for user task input until the system reward function tends to converge. At this time, the parameters in the neural network are used as the final parameters of the edge network user task utility fairness load transfer method.

The above description of the embodiments is for the convenience of ordinary technical personnel in the art to understand and apply the present invention. Those familiar with the art can clearly make various modifications to the above embodiments and apply the general principles explained here to other embodiments without the need for creative labor. Therefore, the present invention is not limited to the aforementioned embodiments. According to the disclosure of the present invention, the improvements and modifications made by those skilled in the art should be within the scope of protection of the present invention.

Claims

1. A fair task offloading and migration method for edge service networks, comprising the following steps: (1) detecting task requests of mobile users in the edge network, and determining all currently detected user task requests;(2) enumerating migration paths of all user task requests transmitted to the edge server;(3) establishing a fair utility evaluation function for evaluating user tasks, wherein, an expression of the fair utility evaluation function is as follows:

2. The fair task offloading and migration method for edge service networks according to claim 1, wherein, for any user task request in step (2), the following three types of migration paths are enumerated: E1 is a set of migration paths for edge servers directly connected to users;E2 is a set of migration paths for edge servers that are indirectly connected to users in a single hop manner, and edge servers that are directly connected to users do not have processing capabilities;E3 is a set of migration paths for edge servers that are indirectly connected to users in a single hop manner, and edge servers that are directly connected to users have processing capabilities.

3. (canceled)

4. (canceled)

5. The fair task offloading and migration method for edge service networks according to claim 1, wherein, the information of the edges comprises the bandwidth occupied by each user task request on the transmission links between the mobile users and the edge servers, as well as the actual bandwidth upper limit of the transmission links; the information of the nodes comprises the amount of computing resources required for user task requests and the actual maximum computing power of the edge servers.

6. (canceled)

7. The fair task offloading and migration method for edge service networks according to claim 1, wherein, the parameters θuser i of the user decision model are optimized and solved through a reward function;

8. The fair task offloading and migration method for edge service networks according to claim 7, wherein, the parameters of the user shared neural network layer are iterated through the following formula until the utility function of all user task requests reaches Pareto optimality;

9. The fair task offloading and migration method for edge service networks according to claim 8, wherein, the weight value αi is obtained by solving the following loss function by using the Frank Wolfe algorithm;

10. The fair task offloading and migration method for edge service networks .according to claim 1, wherein, in step 4.6, for the selected probabilities of all migration paths requested by any user task, the highest of the first K selected probabilities is averaged as the priority for offloading the user task request, the migration path corresponding to the highest selected probability is taken as the offloading migration path by the user task request, with K being a natural number greater than 1.