337 lines
15 KiB
Python
337 lines
15 KiB
Python
"""
|
||
无线资源分配环境 / Main Gym-like environment for wireless resource allocation.
|
||
|
||
该模块实现了一个用于语义和传统用户共存系统的无线资源分配环境。
|
||
它通过 Gym 风格的 reset/step 接口，处理子载波分配、功率控制和压缩率优化。
|
||
This module implements a wireless resource allocation environment for systems
|
||
with coexisting semantic and traditional users. It handles subcarrier allocation,
|
||
power control, and compression ratio optimization via a Gym-like reset/step interface.
|
||
|
||
作者/Author: Sisyphus-Junior
|
||
日期/Date: 2026-02-28
|
||
论文引用/Paper Reference: Co-MADDPG based Resource Allocation for Semantic Communication
|
||
依赖/Dependencies: numpy, envs.channel_model, envs.semantic_module
|
||
"""
|
||
|
||
import numpy as np
|
||
from envs.channel_model import ChannelModel
|
||
from envs.semantic_module import SemanticModule
|
||
|
||
class WirelessEnv:
|
||
"""
|
||
语义与传统通信共存环境。
|
||
Wireless environment with semantic and traditional communication.
|
||
|
||
管理信道状态、执行动作并计算系统范围内的 QoE。
|
||
Manages channel states, executes actions, and computes system-wide QoE.
|
||
|
||
Parameters
|
||
----------
|
||
config : dict
|
||
包含 'env' 和 'training' 部分的配置字典。
|
||
Configuration dictionary containing 'env' and 'training' sections.
|
||
"""
|
||
def __init__(self, config):
|
||
# 提取环境和训练配置 / Extract environment and training configs
|
||
env_config = config['env']
|
||
train_config = config['training']
|
||
|
||
# 核心系统参数 / Core system parameters
|
||
self.N = env_config['num_subcarriers'] # 子载波数量 N / Number of subcarriers
|
||
self.K_s = env_config['num_semantic_users'] # 语义用户数 / Number of semantic users
|
||
self.K_b = env_config['num_traditional_users'] # 传统用户数 / Number of traditional users
|
||
self.K = self.K_s + self.K_b # 总用户数 / Total number of users
|
||
|
||
# 物理层参数 / Physical layer parameters
|
||
self.P_max = env_config['max_power'] # 最大总发射功率 / Maximum total transmit power
|
||
self.R_req = env_config['min_rate_req'] # 传统用户最小速率需求 / Min rate requirement for traditional users
|
||
self.delta_f = env_config['subcarrier_spacing'] # 子载波间隔 / Subcarrier spacing
|
||
self.rho_min = env_config['rho_min'] # 最小压缩率 / Minimum compression ratio
|
||
self.rho_max = env_config['rho_max'] # 最大压缩率 / Maximum compression ratio
|
||
self.w1 = env_config['w1'] # 语义 QoE 权重 1 / Semantic QoE weight 1
|
||
self.w2 = env_config['w2'] # 语义 QoE 权重 2 / Semantic QoE weight 2
|
||
|
||
# 距离限制 / Distance limits
|
||
self.min_d = env_config.get('min_distance', 50.0)
|
||
self.max_d = env_config.get('max_distance', 500.0)
|
||
|
||
# 训练步数控制 / Training step control
|
||
self.max_steps = train_config['max_steps']
|
||
self.step_count = 0
|
||
|
||
# 初始化模型 / Initialize models
|
||
self.channel_model = ChannelModel(config)
|
||
self.semantic_module = SemanticModule(config)
|
||
|
||
# 初始状态变量 / Initial state variables
|
||
self.distances = np.zeros(self.K) # 用户距离 / User distances
|
||
self.channel_gains = np.zeros((self.K, self.N), dtype=complex) # 复信道增益 / Complex channel gains
|
||
self.content_sensitivity = 0.5 # 内容敏感度 / Content sensitivity
|
||
self.business_priority = 0.5 # 业务优先级 / Business priority
|
||
self.load_s = 0.5 # 语义流量负载 / Semantic traffic load
|
||
self.load_b = 0.5 # 传统流量负载 / Traditional traffic load
|
||
self.alloc_s = 0.0 # 语义子载波分配比例 / Semantic subcarrier allocation fraction
|
||
self.alloc_b = 0.0 # 传统子载波分配比例 / Traditional subcarrier allocation fraction
|
||
self.qoe_avg_s = 0.0 # 语义平均 QoE / Rolling average semantic QoE
|
||
self.qoe_avg_b = 0.0 # 传统平均 QoE / Rolling average traditional QoE
|
||
|
||
@property
|
||
def obs_dim(self):
|
||
"""观察维度: 子载波 (N) + 4 个额外特征。 / Observation dimension: Subcarriers (N) + 4 extra features."""
|
||
return self.N + 4
|
||
|
||
@property
|
||
def act_dim(self):
|
||
"""动作维度: 子载波比例, 功率比例, [语义: 压缩率]。 / Action dimension: Subcarrier fraction, Power fraction, [Semantic: Compression ratio]."""
|
||
return 3
|
||
|
||
def reset(self):
|
||
"""
|
||
重置环境状态。
|
||
Reset environment state.
|
||
|
||
Returns
|
||
-------
|
||
tuple
|
||
(语义智能体观察, 传统智能体观察)。
|
||
(semantic_observation, traditional_observation).
|
||
"""
|
||
# 在 [min_distance, max_distance] 内随机分配用户距离 / Random user distances in [min_distance, max_distance]
|
||
self.distances = np.random.uniform(self.min_d, self.max_d, size=self.K)
|
||
|
||
# 生成信道 (形状: K x N 复数) / Generate channel (shape: K x N complex) - Eq.(6)
|
||
self.channel_gains = self.channel_model.generate_channel(self.distances, self.N)
|
||
self.step_count = 0
|
||
|
||
# 随机设置观察参数 / Random params for observation
|
||
self.content_sensitivity = np.random.uniform(0.3, 0.8)
|
||
self.business_priority = np.random.uniform(0.3, 0.8)
|
||
self.load_s = np.random.uniform(0.2, 0.8)
|
||
self.load_b = np.random.uniform(0.2, 0.8)
|
||
|
||
# 重置分配比例和移动平均值 / Reset allocations and moving averages
|
||
self.alloc_s = 0.0
|
||
self.alloc_b = 0.0
|
||
self.qoe_avg_s = 0.0
|
||
self.qoe_avg_b = 0.0
|
||
|
||
# 获取初始观察 / Get initial observations
|
||
obs_s = self._get_observation('semantic')
|
||
obs_b = self._get_observation('traditional')
|
||
return obs_s, obs_b
|
||
|
||
def _get_observation(self, agent_type):
|
||
"""
|
||
构造智能体的观察向量。
|
||
Construct observation vector for agents.
|
||
|
||
Parameters
|
||
----------
|
||
agent_type : str
|
||
'semantic' 或 'traditional'。
|
||
'semantic' or 'traditional'.
|
||
|
||
Returns
|
||
-------
|
||
np.ndarray
|
||
归一化后的观察向量。
|
||
Normalized observation vector.
|
||
"""
|
||
if agent_type == 'semantic':
|
||
# 语义用户索引范围 / Semantic user indices range
|
||
user_indices = range(self.K_b, self.K)
|
||
if len(user_indices) > 0:
|
||
# 计算平均信道增益平方 (功率) / Mean channel power
|
||
channel_power = np.mean(np.abs(self.channel_gains[user_indices])**2, axis=0)
|
||
else:
|
||
channel_power = np.zeros(self.N)
|
||
|
||
# 归一化信道功率 / Normalize channel power
|
||
channel_norm = channel_power / (np.max(channel_power) + 1e-10)
|
||
# 拼接额外特征 / Concatenate extra features
|
||
obs = np.concatenate([channel_norm,
|
||
[self.qoe_avg_s, self.content_sensitivity, self.alloc_s, self.load_s]])
|
||
|
||
else: # 传统 / traditional
|
||
# 传统用户索引范围 / Traditional user indices range
|
||
user_indices = range(0, self.K_b)
|
||
if len(user_indices) > 0:
|
||
# 计算平均信道功率 / Mean channel power
|
||
channel_power = np.mean(np.abs(self.channel_gains[user_indices])**2, axis=0)
|
||
else:
|
||
channel_power = np.zeros(self.N)
|
||
|
||
# 归一化信道功率 / Normalize channel power
|
||
channel_norm = channel_power / (np.max(channel_power) + 1e-10)
|
||
# 拼接额外特征 / Concatenate extra features
|
||
obs = np.concatenate([channel_norm,
|
||
[self.qoe_avg_b, self.business_priority, self.alloc_b, self.load_b]])
|
||
|
||
# 返回 32位浮点型观察 / Return float32 observation
|
||
return obs.astype(np.float32)
|
||
|
||
def step(self, action_s, action_b):
|
||
"""
|
||
执行一个时间步。
|
||
Execute a single environment step.
|
||
|
||
Parameters
|
||
----------
|
||
action_s : np.ndarray
|
||
语义智能体动作 [子载波比例, 功率比例, 压缩率]。
|
||
Semantic agent action [sub_fraction, power_fraction, compression_ratio].
|
||
action_b : np.ndarray
|
||
传统智能体动作 [子载波比例, 功率比例, 冗余参数]。
|
||
Traditional agent action [sub_fraction, power_fraction, redundant_param].
|
||
|
||
Returns
|
||
-------
|
||
tuple
|
||
(obs_s, obs_b, reward_s, reward_b, done, info).
|
||
"""
|
||
self.step_count += 1
|
||
|
||
# 1. 解码动作 / Decode actions
|
||
# 计算子载波分配数量 / Compute number of subcarriers
|
||
n_sub_s = max(1, int(round(action_s[0] * self.N)))
|
||
n_sub_b = max(1, int(round(action_b[0] * self.N)))
|
||
|
||
# 限制总子载波数量 / Clip total subcarriers
|
||
if n_sub_s + n_sub_b > self.N:
|
||
total = n_sub_s + n_sub_b
|
||
n_sub_s = int(round(n_sub_s * self.N / total))
|
||
n_sub_b = self.N - n_sub_s
|
||
|
||
# 计算功率分配 / Compute power allocation
|
||
p_s = action_s[1] * self.P_max
|
||
p_b = action_b[1] * self.P_max
|
||
|
||
# 限制总功率 / Limit total power
|
||
if p_s + p_b > self.P_max:
|
||
total_p = p_s + p_b
|
||
p_s = p_s * self.P_max / total_p
|
||
p_b = p_b * self.P_max / total_p
|
||
|
||
# 解码语义压缩率 / Decode semantic compression ratio
|
||
rho = action_s[2] * (self.rho_max - self.rho_min) + self.rho_min
|
||
|
||
# 2. 分配子载波 (基于信道质量的贪婪算法) / Allocate subcarriers (greedy by channel quality)
|
||
# 计算两组用户的平均信道质量 / Mean channel quality for both groups
|
||
sem_channel = np.mean(np.abs(self.channel_gains[self.K_b:])**2, axis=0) if self.K_s > 0 else np.zeros(self.N)
|
||
trad_channel = np.mean(np.abs(self.channel_gains[:self.K_b])**2, axis=0) if self.K_b > 0 else np.zeros(self.N)
|
||
|
||
# 语义用户优先挑选最好的子载波 / Semantic users pick best subcarriers first
|
||
all_subs = np.arange(self.N)
|
||
sem_sorted = np.argsort(-sem_channel)
|
||
sem_subs = sem_sorted[:n_sub_s]
|
||
# 剩余子载波给传统用户 / Remaining subcarriers for traditional users
|
||
remaining = np.setdiff1d(all_subs, sem_subs)
|
||
|
||
if len(remaining) >= n_sub_b:
|
||
trad_quality = trad_channel[remaining]
|
||
best_idx = np.argsort(-trad_quality)[:n_sub_b]
|
||
trad_subs = remaining[best_idx]
|
||
else:
|
||
trad_subs = remaining
|
||
n_sub_b = len(trad_subs)
|
||
|
||
# 3. 功率分配 (组内均分) / Power allocation (equal within group)
|
||
noise_power = self.channel_model.noise_power
|
||
|
||
# 分配矩阵和功率矩阵 / Allocation and power matrices
|
||
alloc_matrix = np.zeros((self.K, self.N))
|
||
power_matrix = np.zeros((self.K, self.N))
|
||
|
||
# 在 K_s 个用户中循环分配语义子载波 / Distribute semantic subcarriers among K_s users round-robin
|
||
for i, k in enumerate(range(self.K_b, self.K)):
|
||
user_subs = sem_subs[i::max(1, self.K_s)]
|
||
if len(user_subs) > 0:
|
||
alloc_matrix[k, user_subs] = 1
|
||
power_matrix[k, user_subs] = p_s / max(n_sub_s, 1)
|
||
|
||
# 在 K_b 个用户中循环分配传统子载波 / Distribute traditional subcarriers among K_b users round-robin
|
||
for i, k in enumerate(range(0, self.K_b)):
|
||
user_subs = trad_subs[i::max(1, self.K_b)]
|
||
if len(user_subs) > 0:
|
||
alloc_matrix[k, user_subs] = 1
|
||
power_matrix[k, user_subs] = p_b / max(n_sub_b, 1)
|
||
|
||
# 4. 计算 SNR / Compute SNR - Eq.(8)
|
||
snr_matrix = self.channel_model.compute_snr(self.channel_gains, power_matrix, noise_power)
|
||
|
||
# 5. 计算每个用户的 QoE / Compute QoE for each user
|
||
qoe_list = []
|
||
rates = []
|
||
ssim_values = []
|
||
|
||
# 传统用户 QoE 计算 / Traditional users QoE computation - Eq.(QoE_b)
|
||
for k in range(self.K_b):
|
||
user_subs = np.where(alloc_matrix[k] > 0)[0]
|
||
if len(user_subs) == 0:
|
||
rate_k = 0.0
|
||
else:
|
||
# R_k = Σ α * Δf * log2(1 + γ) / R_k = Σ α * Δf * log2(1 + γ)
|
||
rate_k = np.sum(self.delta_f * np.log2(1 + snr_matrix[k, user_subs]))
|
||
rates.append(rate_k)
|
||
# QoE_b = min(R_k / R_req, 1) / QoE_b = min(R_k / R_req, 1)
|
||
qoe_k = min(rate_k / self.R_req, 1.0)
|
||
qoe_list.append(qoe_k)
|
||
|
||
# 语义用户 QoE 计算 / Semantic users QoE computation - Eq.(QoE_s)
|
||
for k in range(self.K_b, self.K):
|
||
user_subs = np.where(alloc_matrix[k] > 0)[0]
|
||
if len(user_subs) == 0:
|
||
ssim_k = 0.0
|
||
else:
|
||
avg_snr = np.mean(snr_matrix[k, user_subs])
|
||
# 计算语义相似度 / Compute SSim - Eq. (SSim)
|
||
ssim_k = self.semantic_module.compute_ssim(avg_snr, rho)
|
||
ssim_values.append(float(ssim_k))
|
||
# 计算语义 QoE / Compute semantic QoE
|
||
qoe_k = self.semantic_module.compute_semantic_qoe(ssim_k, rho, self.w1, self.w2, self.rho_max)
|
||
qoe_list.append(qoe_k)
|
||
|
||
# 6. 系统平均 QoE / System QoE
|
||
qoe_sys = np.mean(qoe_list) if len(qoe_list) > 0 else 0.0
|
||
qoe_s = np.mean(qoe_list[self.K_b:]) if self.K_s > 0 else 0.0
|
||
qoe_b = np.mean(qoe_list[:self.K_b]) if self.K_b > 0 else 0.0
|
||
|
||
# 更新滚动平均值 / Update rolling averages
|
||
alpha_smooth = 0.1
|
||
self.qoe_avg_s = alpha_smooth * qoe_s + (1 - alpha_smooth) * self.qoe_avg_s
|
||
self.qoe_avg_b = alpha_smooth * qoe_b + (1 - alpha_smooth) * self.qoe_avg_b
|
||
# 记录当前分配比例 / Record current allocation ratios
|
||
self.alloc_s = n_sub_s / self.N
|
||
self.alloc_b = n_sub_b / self.N
|
||
|
||
# 7. 为下一步生成新信道 (块衰落) / Regenerate channel for next step (block fading)
|
||
self.channel_gains = self.channel_model.generate_channel(self.distances, self.N)
|
||
|
||
# 8. 构造输出数据 / Build output
|
||
obs_s = self._get_observation('semantic')
|
||
obs_b = self._get_observation('traditional')
|
||
done = (self.step_count >= self.max_steps)
|
||
|
||
# 计算速率满足度 / Compute rate satisfaction for traditional users
|
||
if len(rates) > 0:
|
||
rate_satisfaction = float(np.mean([1.0 if r >= self.R_req else 0.0 for r in rates]))
|
||
else:
|
||
rate_satisfaction = 1.0
|
||
|
||
# 构造信息字典 / Construct info dictionary
|
||
info = {
|
||
'qoe_semantic': qoe_s,
|
||
'qoe_traditional': qoe_b,
|
||
'qoe_sys': qoe_sys,
|
||
'qoe_list': qoe_list,
|
||
'rates': rates,
|
||
'ssim_values': ssim_values,
|
||
'rate_satisfaction': rate_satisfaction,
|
||
'rho': rho,
|
||
'n_sub_s': n_sub_s,
|
||
'n_sub_b': n_sub_b,
|
||
}
|
||
|
||
# 返回结果 (奖励值设为各自的平均 QoE) / Return results (rewards set to respective mean QoEs)
|
||
return obs_s, obs_b, qoe_s, qoe_b, done, info
|