Quality-Aware Task Allocation for Mobile Crowd Sensing Based on Edge Computing

Abstract

In the field of mobile crowd sensing (MCS), the traditional client–cloud architecture faces increasing challenges in communication and computation overhead. To address these issues, this paper introduces edge computing into the MCS system and proposes a two-stage task allocation optimization method under the constraint of limited computing resources. The method utilizes deep reinforcement learning for the selection of optimal edge servers for task deployment, followed by a greedy self-adaptive stochastic algorithm for the recruitment of sensing participants. In simulations, the proposed method demonstrated a 20% improvement in spatial coverage compared with the existing RBR algorithm and outperformed the LCBPA, SMA, and MOTA algorithms in 41, 42, and 48 tasks, respectively. This research contributes to the optimization of task allocation in MCS and advances the integration of edge computing in MCS systems.

1. Introduction

The increasing number of mobile sensing devices in traditional cloud-based mobile crowd sensing (MCS) systems can result in bottlenecks due to growing computational and communication requirements in centralized servers [1]. To address this issue, edge computing technologies have been introduced to leverage the computational capabilities of devices at the edge of networks, making the offloading of computing tasks possible [2,3]. Through the aggregation of data by edge nodes in specific areas, the communication traffic from a large number of sensing devices to the cloud can be reduced significantly, resulting in improved data analysis and sensing task allocation by edge nodes [4,5]. The utilization of edge computing enables the spatial–temporal traces of mobile sensing devices, as well as their behavior and performance in the task accomplishment process, to be efficiently discovered and analyzed, leading to optimized sensed data quality in MCS.

We consider the client–edge–cloud MCS architecture, in which edge nodes can recruit devices to perform as mobile sensing participants, aggregate their sensed data, and deliver them to the cloud. Different from the traditional two-tier client–cloud architecture, where sensing tasks are directly distributed from the cloud to participants [6,7,8,9], we developed a two-stage task allocation method in the new three-tier architecture. Firstly, the cloud can select optimal edge nodes in charge of the sensing tasks in the area where they are deployed. Secondly, the selected edge nodes can recruit proper participants to conduct the sensing tasks. Utilizing their computation capabilities, we also developed a method performed by the edge nodes to assess the sensed data quality and measure the contributions of different participants.

Due to the dynamics of the environmental conditions and sensing capabilities of mobile devices, the quality of data sensed by different edge nodes may keep changing periodically. To address this issue, we used deep reinforcement learning [10,11,12], which has been proved to be suitable for solving sequential decision problems to select the optimal edge nodes for sensing task deployment, with the consideration of dynamic computing resources and sensed data quality. For the user recruitment of the selected edge nodes, we designed a greedy self-adaptive stochastic (GAS) algorithm, which can effectively solve the problems of colossal state space and unpredictability. To evaluate the performance of our proposed two-stage task allocation method, we performed simulations. It was observed that both the edge node selection and the user recruitment algorithms can improve the sensed data quality, while spatial coverage can also be improved by GAS.

The main contributions of this paper are as follows:

• We introduced edge nodes into MCS to perform truth discovery, based on which we can measure the sensed data quality. We formulated the problem of maximizing sensed data quality with the constraints of computing resources.
• We designed a two-stage strategy for task allocation in client–edge–cloud MCS. In the first stage, we utilize deep reinforcement learning to make optimal edge node selections that take into account both computing resources and sensed data quality. In the second stage, we introduce a novel greedy self-adaptive stochastic algorithm (GAS) for user recruitment under each specific edge node.
• We conducted extensive experiments to evaluate the performance of our proposed method. Our edge node selection algorithm improved sensed data quality by 2 to 5 times compared with LCBPA (low-cost and balance-participating algorithm), MOTA (multiobjective task allocation algorithm), and SMA (stable matching algorithm). The proposed GAS algorithm also significantly improved sensed data quality compared with SMLP and RBR, while it increased spatial coverage by 20% compared with RBR.

The organization of the remainder of this paper is as follows: In Section 2, the related work is reviewed. The system model and problem formulation are presented in Section 3. A two-stage task allocation strategy for MCS is proposed in Section 4. In Section 5, we present the performance of the proposed method, whish was evaluated and analyzed using simulations. Finally, this paper is concluded in Section 6.

2. Related Work

MCS has been used in different application areas, such as indoor intelligent sensing [13,14], urban pollution monitoring [15,16], traffic condition sensing [17,18], etc., where smart devices carried by users are used to perform complex sensing tasks. It has been proved that edge computing can significantly improve performance by means of real-time data processing and aggregating close to the data source, reducing the amount of traffic in the core network and computation overload in the cloud [4,19,20].

For task allocation in MCS, sensing quality has been an important criterion to select proper participants [21,22,23]. Guo et al. [24] proposed a novel reverse auction mechanism to enhance the quality of sensing. Their work includes strategies such as post bidding, quality-enhanced winner selection, and the multi-payment scheme. Wang et al. [25] considered both the sensed data quality and spatial–temporal coverage. They tried to enlarge sensing coverage in the temporal and spatial dimensions of the Eurolite sensing task while reducing the amount of erroneous sensed data. Ref. [26] exploited the spatial–temporal correlation of sensed data from different sub-regions in order to reduce the number of necessary sensing tasks while ensuring data quality. Han et al. [27] developed an online learning algorithm for obtaining statistical information on perceptual values and quality during participant selection. Ref. [28] proposed to quantify the perceptual quality based on default values and predict user data quality using compressed perception techniques, utilizing the narrow and sparse data structure as well as the low-rank quality matrix. The amount of necessary sensing tasks can be reduced while guaranteeing sensing quality. Wang et al. [29] created a system to track and monitor the changes in sensors and task requirements. The system reports and reallocates the tasks that cannot be completed normally according to its detection results. Additionally, it can reduce the number of sensors to lower the cost of task publishers. Zhou et al. [30] proposed a low-cost and balanced task assignment algorithm (LCBPA). The algorithm introduces a trade-off factor and uses a heuristic to avoid selecting nodes where sensing quality cannot be guaranteed. Furthermore, the proposed algorithm can avoid unbalanced task allocation, achieving the trade-off between resource cost and data quality in the accomplishment of sensing tasks. Ref. [31] considered the resource constraints and proposed a method to improve the data collection quality.

Researchers have also proposed different online and offline algorithms for user recruitment in MCS. Yu et al. [32] developed a greed strategy, SMLP, aiming to achieve the required sensing quality with the minimum number of participants. Zhao et al. [33] focused on the issue of user trustworthiness in the recruitment process and proposed the RBR algorithm, with which the quality of historic sensed data submitted by different users are recorded and their reputation can be predicted. Users with high reputation are recruited with a high probability.

Different from the existing work in the literature, in this paper, we fully leverage the advantage of edge servers, which is that they are co-located in the same area as the sensing devices, as well as their computing, caching, and communicating power, which make it more convenient for them to discover the truth value of the sensed data submitted by the participants near their location. Based on this, we can evaluate the sensing capability of different devices more accurately according to their data quality. In addition, it is more feasible for edge servers to capture the dynamics of the environmental sensing conditions and the changes in device sensing capability. Thus, with the support of edge computing, we propose a new two-stage task allocation optimization method for MCS for optimizing the sensed data quality as well as the sensing coverage.

3. System Model and Problem Formulation

First, we introduce the task allocation process model in MCS with the support of edge computing, as shown in Figure 1.

3.1. Task Allocation Process Model for MCS with Edge Computing Involved

Given a set of tasks $T=\{t_1,t_2,\dots \}$, first, the cloud server deploys each task $t_i\in T$ to multiple edge nodes to perform sensing data collection. We denote the set of edge nodes as $N=\{n_1,n_2,\dots \}$, the remaining computational resources of each edge node $n_j$ as $R_j$, and the required resource for task $t_i$ as ${\mathcal{R}}_i^{\prime }$. The edge node selects user u to execute the task and evaluates task data quality q. We use ${\alpha }_{i,j}$ to describe whether task $t_i$ is allocated to node $n_j$ as

$${\alpha }_{i,j}=\left\{\begin{array}{ll}1,& \mathrm{task}{t}_i\mathrm{is}\mathrm{allocated}\mathrm{to}{n}_j,\\ 0,& \mathrm{task}{t}_i\mathrm{is}\mathrm{not}\mathrm{allocated}\mathrm{to}{n}_j.\end{array}\right.$$

(1)

The computational resource allocated for task $t_i$ by edge node $n_j$ is denoted as ${\zeta }_{i,j}$. When the cloud platform distributes the sensing task to the edge node, it is necessary to satisfy the constraint that the required computational resource is not larger than that available at the edge node, i.e., ${\sum }_i{\alpha }_{i,j}{\zeta }_{i,j}\le R_j$.

We use $U_j=\left\{u_j^1,u_j^2,\dots ,u_j^k\right\}$ to denote the candidate user set who can be recruited by edge node $n_j$ and ${\beta }_{i,j}^k$ to describe whether the user under node $n_j$ is recruited for task $t_i$ as

$${\beta }_{i,j}^k=\left\{\begin{array}{ll}1,& u_j^k\mathrm{performs}\mathrm{the}\mathrm{task}{t}_i,\\ 0,& u_j^k\mathrm{does}\mathrm{not}\mathrm{performs}\mathrm{the}\mathrm{task}{t}_i.\end{array}\right.$$

(2)

After performing sensing task $t_i$, user $u^k$ uploads sensing data $x_{i,j}^k$ to edge node $n_j$, which can evaluate and send feedback on sensed data quality $q_{i,j}^k=f\left(x_{i,j}^k\right)$.

3.2. Problem of Sensing Quality Maximization

With the constraint of resource cost, we assume that the maximum number of users that may be recruited is S. The problem of maximizing the quality of user-sensed data with limited resources can be formulated as follows:

$$\begin{array}{cc}\hfill max& \sum _i\sum _j\sum _k{\alpha }_{i,j}{\beta }_{i,j}^k{q}_{i,j}^k,\hfill \end{array}$$

(3)

$$\begin{array}{cc}\hfill s.t.& \sum _i{\alpha }_{i,j}{\zeta }_{i,j}\le R_j,\hfill \end{array}$$

(4)

$$\begin{array}{cc}\hfill & \sum _j\sum _k{\alpha }_{i,j}{\beta }_{i,j}^k\le S,\forall i\hfill \end{array}$$

(5)

$$\begin{array}{cc}\hfill & {\alpha }_{i,j},{\beta }_{t_i,j,k}\in \{0,1\},\forall i,j,k.\hfill \end{array}$$

(6)

where ${\alpha }_{i,j}$ denotes the selection factor for edge nodes and ${\beta }_{i,j}^k$ denotes the recruitment factor for users. $R_j$ denotes the remaining computational resources of node $n_j$. Constraint (4) in the above problem ensures that the edge nodes are sufficient to handle the tasks needed to be deployed, and (5) denotes the limitation of the number of recruited users.

4. Two-Stage Task Allocation Strategy for MCS

We allocate the sensing tasks in two phases. In the first phase, the cloud server selects the optimal edge nodes to deploy sensing tasks based on deep reinforcement learning, and in the second phase, the edge nodes recruit proper mobile devices using a random adaptive greedy algorithm. To evaluate the sensing capabilities of different users, edge nodes perform truth value discovery for MCS.

4.1. Truth Value Discovery Based on Edge Computing

We propose an edge-based truth value discovery method for MCS, in which edge nodes aggregate parameters of user-submitted data and estimate the truth value [31]. The method consists of three basic steps: weight update, truth value update, and truth value aggregation. It is assumed that the truth value is some fixed value $x^{*}$. The three basic steps are iteratively taken, with the participating users under the edge server and their sensed data as inputs. After each iteration, the edge node obtains a new estimated truth value, ${x^{*}}^{\prime }$. The iteration stops when the estimated ${x^{*}}^{\prime }$ no longer changes or the iteration number exceeds a certain threshold.

4.1.1. Weight Update

The basic idea of this step is that the closer the data provided by a user are to the truth value, the higher weight the user can obtain. At each edge server $n_j$, the weight of a certain user $u_k$ is calculated as

$$w_{j,k}=f\left(d\left(x_{j,k},x_j^{*}\right)\right),$$

(7)

where $d(·)$ denotes the evaluation function of the distance between data $x_{j,k}$ of user $u_k$ under edge node $n_j$ and truth value $x_j^{*}$. $f(·)$ is a monotonic descent function. $f(·)$ and $d(·)$ are defined as

$$f(·)=\frac{1}{d},$$

(8)

$$d(·)=\frac{{\left(x_{j,k}-x_j^{*}\right)}^2}{{\sum }_k{\left(x_{j,k}-x_j^{*}\right)}^2}.$$

(9)

4.1.2. Truth Value Update

In this step, we assume that the weights of each user have been fixed. We can estimate the truth value of the sensing task on the edge nodes as

$${x_j^{*}}^{\prime }=\frac{{\sum }_k{w}_{j,k}{x}_{j,k}}{{\sum }_k{w}_{j,k}}.$$

(10)

4.1.3. Truth Value Aggregation

After the truth value on each edge node is obtained, we aggregate the values of different edge nodes in this step and derive the global truth value.

$${x^{*}}^{\prime }=\frac{{\sum }_j{x_j^{*}}^{\prime }}{{\sum }_{j}1}.$$

(11)

4.2. Deep Reinforcement Learning-Based Task Deployment to Edge Nodes

For the edge nodes, their available computing resource and associated mobile user set may keep changing, resulting in their sensing capabilities not being stable. In the design of strategies for the deployment of sensing tasks to edge nodes, we take the dynamics into consideration and model the edge node selection problem as a Markov decision process.

The Markov decision process can be defined as $<\mathcal{S},\mathcal{A},\mathcal{T},r>$, where $\mathcal{S}$ is the state space, $\mathcal{A}$ is the action space, $\mathcal{T}$ is the state transfer equation $\mathcal{S}\times \mathcal{A}\to \mathcal{S}$, r is the reward function $\mathcal{S}\to R$, and R is the set of real numbers. In the scenario of sensing task allocation, $\mathcal{S}$ consists of the task deployment states in each time slot, and ${\mathcal{S}}_{\tau }$ denotes the tasks deployed to all the edge nodes in time slot $\tau$.

$${\mathcal{S}}_{\tau }=\{s_{\tau },\{R_1\left(\tau \right),R_2\left(\tau \right),\dots ,R_j\left(\tau \right),\dots ,R_{\left|N\right|}\left(\tau \right)\}\},{\mathcal{S}}_{\tau }\in \mathcal{S},$$

(12)

where $s_{\tau }=\{{\sum }_i{\alpha }_{i,1},{\sum }_i{\alpha }_{i,2},\dots ,{\sum }_i{\alpha }_{i,\left|N\right|}\}$ and $R_j\left(\tau \right)$ denotes the remaining computational resource of node $n_j$ in time slot $\tau$.

Action space $\mathcal{A}$ consists of task deployment strategies in each time slot, where ${\mathcal{A}}_{\tau }$ describes the actions that can be taken in time slot $\tau$.

$${\mathcal{A}}_{\tau }=\{a_1\left(\tau \right),a_2\left(\tau \right),\dots ,a_j\left(\tau \right),\dots ,a_{\left|N\right|}\left(\tau \right)\},{\mathcal{A}}_{\tau }\in \mathcal{A},$$

(13)

where $a_j\left(\tau \right)$ represents whether the cloud server selects node $n_j$ for task deployment in slot $\tau$. If $n_j$ is selected, $a_j\left(\tau \right)=1$; otherwise, $a_j\left(\tau \right)=0$.

State transfer function $\mathcal{T}$ is defined as

$$\mathcal{T}({\mathcal{S}}_{\tau -1},{\mathcal{A}}_{\tau },{\mathcal{S}}_{\tau })=P({\mathcal{S}}_{\tau }\mid {\mathcal{S}}_{\tau -1},{\mathcal{A}}_{\tau }).$$

(14)

We evaluate reward value $r_t$ for the task deployment strategy based on the user set associated with the edge nodes and the available computational resource state.

Theorem 1.

The reward obtained when selecting node$n_j$for the deployment of task$t_i$in time slot τ is defined as$r_{i,j}\left(\tau \right)$.

$$\begin{array}{c}\hfill r_{i,j}\left(\tau \right)=\left\{\begin{array}{cc}\frac{{\sum }_{k=0}^U{w}_{j,k}}{N},\hfill & if the remaining computational capacity of\hfill \\ & the edge server satisfies requirements of the task,\hfill \\ 0,\hfill & otherwise,\hfill \end{array}\right.\end{array}$$

(15)

where${\sum }_{k=0}^U{w}_{j,k}$denotes the sensed data quality of the user set associated with the edge node.

Due to the actual environment and system conditions for sensing tasks being unknown and dynamic, we train the system’s state using a model-free deep reinforcement learning algorithm to obtain the best task scheduling strategy. The key idea of reinforcement learning is to learn by trial and feedback from interaction with the environment, maximizing the reward for a certain action as a guide for subsequent actions. For the task deployment problem, we record a series of deployment strategies and observe their obtained rewards, learning to make the optimal deployment decision for the next action. In order to maximize the sensed data quality of the user set while making full use of the available computational resources, we define the value function for optimal behavior as $Q^{*}(s,a)$. We assume that the discount rate of future rewards is $\gamma$ and that the future discounted return in slot $\tau$ is $R{e}_{\tau }={\sum }_{{\tau }^{\prime }=\tau }^{\mathcal{T}}{\gamma }^{{\tau }^{\prime }-\tau }{r}_{{\tau }^{\prime }}$. $Q^{*}(s,a)$ can be defined as follows.

Theorem  2.

When we have a certain sequence s and action a is taken on it, the maximum expected return that can be obtained by any strategy is

$$Q^{*}(s,a)=\underset{\pi }{max}\mathbb{E}\left[R{e}_{\tau }\mid s_{\tau }=s,a_{\tau }=a,\pi \right],$$

(16)

where π denotes the optimal strategy.

We choose decision variable $a^{\prime }$ to approximate target return $r+\gamma Q^{*}\left(s^{\prime },a^{\prime }\right)$ using optimal decision making. A Q-learning network containing a parameter $\theta$ is proposed for this process. We use variable v to denote the iteration number of each round, and the loss function $L_v\left({\theta }_v\right)$ of Q-learning is defined as

$$L_v\left({\theta }_v\right)={\mathbb{E}}_{s,a}\left[{\left(y_v-Q\left(s,a;{\theta }_v\right)\right)}^2\right],$$

(17)

where $y_v$ is the optimal solution for each round. $y_v$ can be expressed as

$$y_v={\mathbb{E}}_{s^{\prime }}\left[r+\gamma \underset{a^{\prime }}{max}Q\left(s^{\prime },a^{\prime };{\theta }_{v-1}\right)\mid s,a\right].$$

(18)

The proposed deep reinforcement learning-based task deployment algorithm is shown in Algorithm 1.

The deployment algorithm still uses the traditional gradient descent method to reduce the gap between the prediction and actual results. It stores the last F empirical data elements in data D, and samples them uniformly and randomly when performing updates.

Algorithm 1: Deep reinforcement learning-based task deployment for edge nodes

Input: Computing resources for all edge node $R=\left\{R_j\left(\tau \right)\right\}$, parameters of sensed data quality $W=\left\{w_{j,k}\right\}$, task assignment characterization parameters $s_{\tau }$, probability $\epsilon$, running epochs $ep$, time slot limitation H Output: Task deployment policy ${\omega }_s$ 1: Initialize parameter vector $\theta$ with random weight; 2: Initialize temporary state sequence; 3: for episode = 1 to $ep$ do 4:    Set pre-processing sequences ${\varphi }_1=\varphi \left(s_{\tau }\right)$; 5:    for $\tau =1$ to H do 6:      $\delta =Random(0,1)$ 7:      if $\delta >\epsilon$ then 8:         Select a random action $a_{\tau }$; 9:      else 10:         Select $a_{\tau }={max}_a{Q}^{*}\left(\varphi \left(s_{\tau }\right),a;\theta \right)$; 11:      end if 12:      Execute action $a_{\tau }$; 13:      Get reward $r_{\tau }$, next state $s_{\tau +1}$ and remaining computing resources $R_j(\tau +1)$ of the edge node j; 14:      Set ${\varphi }_{\tau +1}=\varphi \left(s_{\tau +1}\right)$; 15:      Store transition $\left({\varphi }_{\tau },a_{\tau },r_{\tau },{\varphi }_{\tau +1}\right)$ in replay memory D; 16:      Sampling $\left({\varphi }_j,a_j,r_j,{\varphi }_{j+1}\right)$ from replay memory D; 17:      Set $y_i=r_{\tau }$; 18:      Train Q network whose weight is $\theta$ with ${\left(y_j-Q\left({\varphi }_j,a_j;\theta \right)\right)}^2$ as the loss function; 19:    end for 20: end for 21: ${\varphi }_s=(R_j,w_i,\epsilon )$ 22: ${\omega }_s=\underset{a_s}{argmax}Q({\varphi }_s,a_s,\theta )$

4.3. Greedy Self-Adaptive Stochastic User Recruitment

Once the edge nodes for the deployment of tasks are selected, we use a greedy self-adaptive stochastic algorithm to recruit users for each node to perform sensing tasks. There are three critical steps in the design of the algorithm, i.e., greedy policy, user candidate set selection, and value settings of the algorithm parameters. The greedy policy is used to evaluate the sensing capability of each user to determine whether it can be selected as a candidate. A specific random factor is taken to filter the elements in the candidate set to approximate the optimal solution. Another key parameter in the design of the algorithm is a strategy indicator $\lambda$, which determines the adaptiveness of the selection strategy from totally random to greedy. $\lambda =0$ means that the elements of the candidate set will be selected entirely randomly, and $\lambda =1$ means that the selection will be entirely greedy. We implement the algorithm as shown in Algorithm 2, where a completely random strategy is adopted to select participants from the candidate user set.

To accommodate the different sensing capability of the user set associated with different edge nodes, we use the probability distribution of users under different edge nodes (${\pi }_k\left(n_j\right)$) as a factor of the greedy strategy. When the set of candidates is generated, a completely random policy is used to select the final users who perform the sensing task.

The flow chart of the complete algorithm is shown in Figure 2.

Algorithm 2: Greedy self-adaptive stochastic user recruitment algorithm

Input: the set of users U, parameters of sensed data quality $W=\left\{w_{j,k}\right\}$, the distribution of the user under different edge servers ${\pi }_k\left(n_j\right)$, the candidate set size b, the number of recruited users $b^{*}$ Output: the set of recruited users $U^{*}$  Set $U^{*}=\varnothing$ , $\upsilon =\varnothing$;  for $i=1$ to $b^{*}$ do     ${\upsilon }_i=\varnothing$;     Calculate ${\pi }_i\left(n_j\right)*w_i$, $\forall u_i\in U\setminus U^{*}$;     for $k=1$ to b do       ${\upsilon }_i={\upsilon }_i\cup \underset{i}{argmax}\left\{{\pi }_i\left(n_j\right)*w_i\right\}$;     end for     Select $u^{*}$ from ${\upsilon }_i$ randomly;     $U^{*}=U^{*}\cup \left\{u^{*}\right\}$;  end for  return $U^{*}$

5. Performance Evaluation

In this section, we present the evaluation of the performance of our proposed two-stage task allocation method conducted using simulations.

5.1. Experiment Settings

We simulated a piece of squared area divided into different subspaces. In each subspace, there were randomly distributed edge nodes and mobile users. Users were recruited using the GAS algorithm to perform sensing tasks and upload sensory data, the quality of which was evaluated by the edge nodes.

First, we investigated the performance of GAS and compared it with that of the existing SMLP and RBR user recruitment algorithms, respectively. SMLP selects participants based on a greedy strategy, aiming to minimize the number of participants while achieving the quality required. RBR recruits users according to their reputation.

After that, we analyzed the performance of our proposed deep reinforcement learning-based edge server task deployment (DeepRL-Based) algorithm, comparing it with the LCBPA, MOTA, and SMA task deployment algorithms. LCBPA dynamically adjusts the probability of each node being assigned to a task by introducing a trade-off factor $\lambda$, which can prevent task deployment from clustering in nodes with poor data quality and thus improve the overall quality. MOTA is a task deployment algorithm based on multiobjective optimization with deep learning. Moreover, it uses a specialized archive selection mechanism to enhance diversity in the search space. SMA uses The List Generation Algorithm to solve the best matching problem of perceptual tasks and nodes to obtain the best task assignment scheme.

5.2. Simulation Results Analysis

We investigated the performance of GAS in simulations with varying numbers of sensing task rounds and users. Our experimental setup consisted of four edge nodes, a target of 35 recruited users per edge node, and 1000 users. The number of tasks was randomly selected between 500 and 800, with 16 values tested. We evaluated the sensed data quality and spatial coverage after each round of tasks and present the results in Figure 3, Figure 4 and Figure 5. As depicted in Figure 3, the cumulative sensing quality using GAS was significantly improved compared with the other algorithms. Figure 4 demonstrates that GAS outperformed both SMLP and RBR in terms of sensed data quality for each task as the number of tasks increased. Furthermore, Figure 5 shows that GAS achieved more extensive spatial coverage than RBR, while SMLP performed best in terms of full spatial coverage but with no consideration for minimizing the number of participating users.

In order to evaluate the effect of varying the number of users on the performance of the GAS algorithm, we conducted experiments in a simulated environment with randomly distributed edge nodes and mobile users. The number of edge nodes and the required recruitment amount were fixed, while the number of tasks was set to 200. To test the robustness of the GAS algorithm in dynamic user environments, sixteen different values for the number of users were selected between 100 and 1000, and individual experiments were conducted for each setting. The results of these experiments, depicted in Figure 6, Figure 7 and Figure 8, demonstrate that as the number of users increased, the cumulative quality of the sensed data obtained using the three recruitment algorithms, including SMLP, RBR, and GAS, decreased. However, the GAS algorithm consistently exhibited the smallest decrease gradient, showcasing its robustness and effectiveness in dynamic user environments. The results also reveal that for individual sensing tasks, the GAS algorithm provided superior-quality sensed data and higher spatial coverage than RBR. In contrast, its coverage was comparable to that of the SMLP algorithm. These findings further highlight the effectiveness of the GAS algorithm in improving the quality of sensed data.

In order to evaluate the effectiveness of our proposed DeepRL-Based task deployment method, we conducted experiments using the real-world CROWD TEMPERATURE dataset [16] obtained from the CRAWDAD repository. The dataset was divided into 48 blocks, each of which was treated as a separate sensing task. We established 15 edge nodes and equally assigned all the sensing users to each node, resulting in approximately 20 users for each node.

The experiments consisted of three stages. In the first stage, tasks were deployed to the edge nodes using four algorithms: DeepRL-Based, LCBPA, MOTA, and SMA. In the second stage, the edge nodes recruited users using the GAS algorithm. Finally, the average quality of the sensed data was calculated and recorded for both the DeepRL-Based and LCBPA algorithms. The results of the experiments are shown in Figure 9 and Figure 10. The results demonstrate the effectiveness and robustness of our proposed DeepRL-Based task deployment method in real-world scenarios.

The experimental results presented in Figure 9 demonstrate the superior performance of the proposed DeepRL-Based task deployment algorithm compared with the LCBPA, SMA, and MOTA algorithms. The results show that the DeepRL-Based algorithm outperformed the LCBPA algorithm in 41 out of the 48 tasks, the SMA algorithm in 42 tasks, and the MOTA algorithm in all 48 tasks. These results demonstrate the effectiveness of the DeepRL-Based algorithm. Additionally, as shown in Figure 10, although the DeepRL-Based algorithm performed slightly worse than the LCBPA algorithm at the beginning of the reinforcement learning phase, this was due to the lower initial greediness and random exploration. However, after several induction tasks, the accuracy of the DeepRL-Based algorithm was significantly improved. The temporary lead of SMA was based on the same principle, and the MOTA algorithm was outperformed by the DeepRL-Based algorithm throughout the entire experiment. The results show that the average quality of the sensed data obtained by the DeepRL-Based algorithm was about three times higher than that obtained by the MOTA algorithm, indicating that the DeepRL-Based algorithm can outperform state-of-the-art task assignment algorithms. These results highlight the potential of the proposed DeepRL-Based algorithm to provide high-quality sensing data in real-world environments.

6. Conclusions

In this paper, we address the problem of maximizing sensing quality while considering the limited computing resources in MCS with edge computing support. To achieve this goal, we propose a two-stage task allocation strategy that leverages deep reinforcement learning for edge node selection and a greedy self-adaptive stochastic algorithm for user recruitment. The proposed method was evaluated through extensive experiments, and the results show that it significantly improved the sensing quality. Compared with the existing algorithms, our approach demonstrated a 20% improvement in spatial coverage and outperformed the LCBPA, SMA, and MOTA algorithms in 41, 42, and 48 tasks, respectively. These results demonstrate the effectiveness of our proposed method and provide valuable insights for future research in the field of MCS with edge computing support.