基于排队论和深度强化学习的多接入边缘计算任务卸载优化【附代码】

✅ 博主简介：擅长数据搜集与处理、建模仿真、程序设计、仿真代码、论文写作与指导，毕业论文、期刊论文经验交流。

 ✅ 具体问题可以私信或扫描文章底部二维码。

1）针对无线Mesh网络中任务卸载机制尚未系统构建的问题，本文深入探讨了面向无线Mesh多接入边缘计算网络的任务卸载策略。无线Mesh网络作为一种高灵活性、自组织、多跳的无线网络架构，具备良好的覆盖扩展能力与链路冗余特性，能够有效支撑城市广域物联网、应急通信、工业无线传感等场景下的边缘计算服务部署。在此类网络中引入MEC技术，意味着可以将计算节点部署于Mesh路由器或Mesh网关等中间节点上，从而为终端用户提供就近的算力支持。然而，传统研究多聚焦于蜂窝网络或Wi-Fi环境下的任务卸载，对Mesh网络特有的拓扑动态性、路径多样性以及节点角色异构性缺乏充分考量。为此，本文构建了一个融合Mesh客户端、Mesh路由器与边缘服务器的三层无线Mesh MECN架构，在该架构下，客户端设备产生的计算密集型任务可通过多跳中继方式卸载至具备计算能力的Mesh网关或邻近的Mesh路由器进行处理。为了实现高效的任务调度，本文提出了一种基于客户端区域划分的任务卸载算法（ABOP），该算法依据客户端在Mesh网络中的地理位置分布特征，将其划分为若干逻辑区域，并为每个区域预设最优卸载路径集合。区域划分不仅考虑了信号强度与跳数，还综合评估了各候选路径的历史吞吐量稳定性、链路拥塞趋势以及中间节点剩余计算资源状态。当任务生成时，ABOP算法首先识别其所属区域，随后根据当前网络状态从预设路径集中动态选择最合适的卸载目标节点。该方法避免了全局搜索带来的高昂开销，同时通过区域化管理提升了策略的可扩展性。此外，算法引入了一种轻量级反馈机制，允许接收任务的边缘节点定期上报自身负载情况，以便区域控制器及时调整路径权重，确保长期运行中的负载均衡。仿真结果显示，在高密度客户端部署环境下，ABOP相较于传统最短路径优先卸载策略和随机卸载策略，显著降低了任务平均处理时延，尤其在突发流量场景下表现出更强的鲁棒性。同时，由于减少了无效重传和排队等待时间，任务执行成功率得到明显提升，特别是在网络拓扑频繁变化的情况下仍能维持较高的服务质量。该研究成果填补了无线Mesh网络与MEC融合研究中的空白，为未来智能城市基础设施中分布式边缘计算系统的部署提供了可行的技术路径。

（2）针对现有任务卸载研究普遍局限于单一无线接入模式、未能充分利用有线网络资源的问题，本文提出了一种面向无线有线融合型多接入边缘计算网络的任务卸载框架。随着光纤到户、千兆宽带的普及以及企业园区内部高速以太网的广泛应用，大量终端设备实际上处于无线与有线并存的混合接入环境中。然而，当前多数任务卸载方案仅关注移动终端向无线边缘节点的卸载过程，忽视了固定终端或可通过有线连接访问更高性能边缘服务器的可能性。本文认为，若能实现无线终端向有线边缘设备的任务迁移，则可大幅提升整体系统资源利用率并缓解无线链路拥塞问题。基于此，本文构建了一个包含移动终端、无线接入点、有线终端、边缘交换机及边缘服务器的异构融合MECN架构。在此架构中，移动设备可通过Wi-Fi或5G接入无线AP，再经由核心交换机连接至部署在局域网内的高性能计算节点；同时，部分具备计算能力的有线终端（如高性能PC、工作站）也可作为边缘计算资源池的一部分参与任务执行。为建模这一跨接入域的任务卸载过程，本文设计了一套统一的任务表征体系，将任务按计算量、数据大小、时延敏感度等维度分类，并定义了从无线端到有线端的跨层传输模型，涵盖无线接入时延、骨干网转发延迟、目标节点处理能力等多个因素。在此基础上，提出了基于保护时间阈值的任务卸载算法（GTCO）。该算法的核心思想在于：为每一类任务设定一个“保护时间阈值”，即任务在本地处理所能容忍的最大完成时间。当本地处理预估时间超过该阈值时，任务将被触发卸载流程。GTCO算法进一步引入“资源贡献度”评估机制，用于衡量潜在卸载目标节点（包括无线边缘服务器和有线计算节点）的服务质量历史表现，并结合当前网络负载状况动态调整卸载决策权重。特别地，算法允许管理员设定“有线资源使用占比上限”，以防止关键业务终端因过度参与边缘计算而导致自身性能下降，从而实现可控的资源共享。仿真实验表明，在典型办公园区场景中，GTCO算法能够有效引导高算力需求任务向空闲的有线计算节点转移，显著提高了整体计算资源的利用率，尤其在高峰时段避免了无线边缘节点的过载现象。与此同时，任务平均处理时延下降明显，任务执行失败率也因更合理的资源分配而大幅降低。更重要的是，该算法展现出良好的适应性，能够在不同规模、不同业务混合度的网络环境中保持稳定性能，证明了其在实际部署中的可行性与优越性。该研究突破了传统任务卸载局限于无线域的思维定式，推动了边缘计算向全网协同、资源融合的方向发展。

（3）面对跨异构接入网络环境下任务卸载决策复杂度高、环境动态性强、传统优化方法难以应对的挑战，本文提出了一种基于深度强化学习的智能任务卸载分流机制。现代边缘计算网络往往包含多种接入技术（如4G/5G、Wi-Fi、蓝牙、以太网）、多种终端类型（智能手机、IoT设备、车载终端）以及多样化的边缘计算节点（微数据中心、基站集成MEC、家庭网关），形成了高度异构且持续变化的网络环境。在这种背景下，任务卸载不再是一个静态规划问题，而是一个需要实时感知、动态响应的序贯决策过程。传统的启发式算法或数学规划方法在面对如此复杂的环境时，往往因模型假设过强、求解耗时过长或泛化能力不足而难以适用。为此，本文构建了一个精细化的无线有线融合MECN模型，涵盖无线信道质量波动、有线链路带宽分配、任务到达随机性、边缘节点计算能力差异等多个现实因素。在此基础上，建立了完整的任务卸载分流模型，明确任务在本地执行、卸载至无线边缘节点、卸载至有线边缘节点三种模式之间的选择逻辑，并进一步构建了任务排队计算模型，用以刻画任务在传输队列、处理队列中的等待行为。通过综合分析无线网络传输时延、有线网络转发时延、任务排队等待时延及实际计算耗时，本文推导出任务从生成到完成的平均总时延表达式，并以此为目标函数构建了一个复杂的非凸优化问题。为求解该问题，本文采用马尔可夫决策过程（MDP）对其进行建模，将任务卸载视为一个状态-动作-奖励的交互过程。其中，系统状态包括当前任务特征、各候选节点的资源占用情况、网络链路质量等；动作空间涵盖不同的卸载目的地选择；奖励函数则设计为时延负值与资源消耗惩罚项的加权和，以引导智能体学习出兼顾效率与公平的策略。

import numpy as np
import random
import networkx as nx
from collections import defaultdict
import matplotlib.pyplot as plt

class MeshMECN:
    def __init__(self, num_clients, num_routers, num_gateways):
        self.clients = [f'client_{i}' for i in range(num_clients)]
        self.routers = [f'router_{j}' for j in range(num_routers)]
        self.gateways = [f'gateway_{k}' for k in range(num_gateways)]
        self.nodes = self.clients + self.routers + self.gateways
        self.graph = nx.Graph()
        self._build_topology()
        self.resource_pool = {node: random.randint(50, 200) for node in self.routers + self.gateways}
        self.task_queue = defaultdict(list)
        
    def _build_topology(self):
        for client in self.clients:
            connected_routers = random.sample(self.routers, random.randint(1, 2))
            for router in connected_routers:
                self.graph.add_edge(client, router, weight=random.uniform(1.0, 5.0))
        for router in self.routers:
            connected_gateways = random.sample(self.gateways, random.randint(1, len(self.gateways)))
            for gw in connected_gateways:
                self.graph.add_edge(router, gw, weight=random.uniform(0.5, 2.0))
                
    def abop_offload(self, task_size, source_client):
        areas = self._define_areas()
        client_area = None
        for area, members in areas.items():
            if source_client in members:
                client_area = area
                break
        candidates = []
        for node in self.routers + self.gateways:
            if node in self.resource_pool and self.resource_pool[node] >= task_size:
                path = nx.shortest_path(self.graph, source_client, node, weight='weight')
                total_delay = sum(self.graph[path[i]][path[i+1]]['weight'] for i in range(len(path)-1))
                candidates.append((node, total_delay))
        if not candidates:
            return None, float('inf')
        best_candidate = min(candidates, key=lambda x: x[1])
        return best_candidate

    def _define_areas(self):
        area划分 = {}
        for i, gw in enumerate(self.gateways):
            area划分[f'area_{i}'] = [gw]
            connected_routers = [n for n in self.routers if self.graph.has_edge(n, gw)]
            area划分[f'area_{i}'].extend(connected_routers)
            for router in connected_routers:
                clients_attached = [n for n in self.clients if self.graph.has_edge(n, router)]
                area划分[f'area_{i}'].extend(clients_attached)
        return area划分

class WiredWirelessMECN:
    def __init__(self):
        self.wireless_devices = [f'mobile_{i}' for i in range(10)]
        self.wired_devices = [f'pc_{j}' for j in range(8)]
        self.edge_servers = ['server_A', 'server_B']
        self.resource_capacity = {dev: random.randint(100, 300) for dev in self.wired_devices}
        self.resource_capacity.update({srv: 500 for srv in self.edge_servers})
        self.network_delay = defaultdict(dict)
        self._setup_delays()
        
    def _setup_delays(self):
        for wd in self.wireless_devices:
            for target in self.wired_devices + self.edge_servers:
                self.network_delay[wd][target] = random.uniform(2.0, 15.0)
        for pc in self.wired_devices:
            for target in self.edge_servers:
                self.network_delay[pc][target] = random.uniform(0.5, 3.0)
                
    def gtco_offload(self, task_size, source_device, max_local_time):
        local_processing_time = task_size / 10.0
        if local_processing_time <= max_local_time:
            return 'local', local_processing_time
        candidates = []
        for node, capacity in self.resource_capacity.items():
            if capacity >= task_size:
                exec_time = task_size / (random.uniform(15.0, 30.0))
                total_delay = self.network_delay[source_device][node] + exec_time
                candidates.append((node, total_delay))
        if not candidates:
            return 'local', local_processing_time
        best_node, min_delay = min(candidates, key=lambda x: x[1])
        if min_delay < max_local_time:
            return best_node, min_delay
        return 'local', local_processing_time

class SatelliteMECN:
    def __init__(self, num_satellites=24):
        self.satellites = [f'sat_{i}' for i in range(num_satellites)]
        self.ground_stations = ['gs_0', 'gs_1']
        self.orbit_height = 550
        self.velocity = 7.8
        self.sat_compute = {sat: random.randint(200, 400) for sat in self.satellites}
        self.visibility = self._compute_visibility()
        
    def _compute_visibility(self):
        vis = defaultdict(list)
        for gs in self.ground_stations:
            visible = random.sample(self.satellites, random.randint(3, 6))
            vis[gs] = visible
        return vis
        
    def lssbco_offload(self, task_size, ground_station):
        visible_sats = self.visibility[ground_station]
        candidates = []
        for sat in visible_sats:
            if self.sat_compute[sat] >= task_size:
                propagation_delay = self.orbit_height / 300000 * 2
                processing_delay = task_size / 25.0
                total_delay = propagation_delay + processing_delay
                candidates.append((sat, total_delay))
        if not candidates:
            return None, float('inf')
        return min(candidates, key=lambda x: x[1])

如有问题，可以直接沟通

👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇