## 5 Results
### Results  
In the first set of experiments, we evaluated the performance of our proposed algorithm, DQL with edge training (DQL-edge), against five other methods: vanilla DQL where training is performed in local devices without experience sharing (DQL-local), reinforce using our proposed edge training architecture, greedy, local execution of all tasks, and randomly offloading or executing each task. It is worth mentioning that DQL-local imposes the burden of training the neural network on mobile devices; thus, comparing it with DQL-edge raises the question of how to account for this overhead. As the workload of training a neural network depends on hardware and software implementation, we neglect the training overhead in DQL-local and, as with all other methods, will only consider the workload for task execution. Even though this will give DQL-local an unfair advantage, we show that our proposed method can outperform vanilla DQL even if we neglect the training overhead. To compare the methods, tasks are binned in buckets of five seconds from the start to the end of the simulation and the average cost, delay, and power are calculated for each bin. For example, all the tasks arriving from \(t=0\) and \(t=5\) are placed in the same bucket and used to calculate the averages. We also carried out the experiment for 100 and 50 mobile nodes in the environment and with the mobile nodes using both the more uniform and centered locations. The results of the experiment are illustrated in Figure 2.  
If the values for cost and delay increase overtime, it means that tasks are accumulating more and more in the execution queues of mobile or edge devices; hence, the delay and cost are getting worse over time. If this is the case, it means that the given method is unstable, as the delay will eventually increase and pass any acceptable range. As can be seen from the graphs, local execution of all tasks is always unstable, while the random and greedy methods manage to stay stable in some configurations. The DQL-edge and DQL-local methods on the other hand, managed to stay stable in all tested configurations, even though DQL-edge performed better in most configurations. This behavior can be attributed to the experience-sharing feature of DQL-edge, as the neural network will have more data to work with, which can lead to faster training and more resilience of the trained network. From the four tested configurations, 50 mobile nodes in the more uniform locations is the easiest configuration for a method to stay stable, as there are fewer mobile nodes to offload tasks to edge devices and the mobile nodes are distributed around all edge devices instead of a select few. In this configuration, all methods except for local execution remained stable and performed similarly. However, when the number of mobile nodes is 100 or when the mobile nodes are centered, the random method also fails to remain stable, while the greedy, DQL-local, and DQL-edge methods are still stable, even though the DQL-edge performs considerably better than the other methods. Lastly, when the mobile nodes are centered and we have 100 mobile nodes, only the DQL-local and DQL-edge methods manage to give acceptable results. The greedy method, while staying stable, only begins to plateau with a very high cost of around 50 units. The results for DQL-edge, DQL-local, reinforce-edge, and greedy are depicted in more detail in Figure 3. In this experiment, the simulation was run for mobile node numbers of 25, 50, 75, and 100, as well as for both uniform and centered configurations. As can be seen from the figure, DQL-local starts with a higher cost compared to the other two methods and closes the gap as time passes. This can be attributed to the slower learning speed of DQL-local, as it only has the experience of a single mobile device for training the network. We see some fluctuations with the reinforce method, which may be due to the fact that the reinforce method works best when we have long trajectories of experiences, which do not exist in our task offloading model.