✨ 本团队擅长数据搜集与处理、建模仿真、程序设计、仿真代码、EI、SCI写作与指导，毕业论文、期刊论文经验交流。
✅ 专业定制毕设、代码
✅ 如需沟通交流，可以私信，或者点击《获取方式》

（1）TRNSYS仿真平台搭建与冷源系统能耗模拟验证：

以夏热冬暖地区某大型商场中央空调为蓝本，采集3个月的运行数据，包含冷水机组出水温度、冷冻水泵频率、冷却水泵频率、冷却塔风机转速及室内外温湿度等12个变量。在TRNSYS中构建冷源系统模型：2台离心式冷水机组并联，3台变流量冷冻水泵，3台冷却水泵，2台冷却塔。利用Fortran编写自定义Type模块模拟水泵性能曲线和变频效率，调用Type Studio编译。模拟运行8月典型周，设备电耗模拟值与实测值对比：冷水机组误差3.2%，水泵误差4.7%，总电耗误差3.8%。室内温度模拟平均误差3.23%，室外温度1.58%，验证了平台可用于后续算法测试。仿真模型每15分钟输出一次状态，每日96个时间步。

（2）基于Option-Critic的分层AC算法H-AC协同优化设备启停与参数：

将冷源系统优化建模为两层MDP：上层Option每1小时决定设备台数组合（冷机启停1/2台，冷冻泵2/3台等），共12种离散选项；下层动作在给定Option下，每15分钟调整连续运行参数（出水温度设定值7-12°C、水泵频率30-50Hz、冷却塔风机30%-100%）。采用H-AC算法，上层Critic评估状态-option值Q_Ω(s,ω)，Actor输出option概率π_Ω(ω|s)；下层每个option拥有独立Actor-Critic，输出连续动作。训练采用经验回放与目标网络，奖励函数R_t = - (E_total + 0.25·(comfort_penalty))，当室温超出24±2°C时给予惩罚。在TRNSYS中训练50个episode（每个episode覆盖一周），算法收敛后与固定规则对比：夏季典型周总能耗降低16.29%，室内舒适时间增加29.74%，具体到冷水机组卸载切换更合理，避免了频繁启停。

（3）分层软演员-批评家H-SAC与可解释框架：

H-AC存在样本效率低和探索不足问题，将其改进为H-SAC。引入最大熵目标，奖励中加入策略熵项，促进探索。上层离散Option的软价值函数和温度参数自动调整；下层连续动作的软策略更新。训练过程中，系统能耗在H-SAC下比H-AC进一步降低3.18%，学习曲线更平稳。同时，构建可解释性分析框架：使用Deep LIFT计算输入特征对Option选择的贡献度，解释何时会切换为双冷机模式（主要因负荷率>75%且室外湿球温度>27°C）；SHAP值局部分析揭示输出水温设定调低2°C时，接下来4步的总能耗期望变化。通过TRNSYS模拟回放，操作人员可理解RL决策逻辑，增强了实际应用可信任度。

import torch
import torch.nn as nn
import numpy as np

# 2. H-AC 网络结构
class HierarchicalActorCritic(nn.Module):
    def __init__(self, state_dim, num_options, action_dim):
        super().__init__()
        self.num_options = num_options
        self.state_encoder = nn.Sequential(nn.Linear(state_dim, 128), nn.ReLU())
        # 上层 Option policy 和 value
        self.option_policy = nn.Linear(128, num_options)
        self.option_value = nn.Linear(128, 1)
        # 每个option的下层AC
        self.lower_actors = nn.ModuleList([nn.Sequential(nn.Linear(128, 64), nn.ReLU(), nn.Linear(64, action_dim)) for _ in range(num_options)])
        self.lower_critics = nn.ModuleList([nn.Sequential(nn.Linear(128+action_dim, 64), nn.ReLU(), nn.Linear(64, 1)) for _ in range(num_options)])

    def forward(self, state):
        feat = torch.relu(self.state_encoder(state))
        option_logits = self.option_policy(feat)
        option_probs = torch.softmax(option_logits, dim=-1)
        option_value = self.option_value(feat)
        return feat, option_probs, option_value

    def lower_action_value(self, feat, option_idx, action=None):
        actor = self.lower_actors[option_idx]
        action_mean = actor(feat)
        # 简化：直接输出
        if action is None: return action_mean
        critic = self.lower_critics[option_idx]
        q = critic(torch.cat([feat, action], dim=-1))
        return action_mean, q

# 训练片段
def train_hac(model, buffer, optimizer, gamma=0.99):
    states, options, actions, rewards, next_states, dones = buffer.sample()
    # 上层Critic更新
    feat, opt_probs, opt_val = model(states)
    next_feat, _, _ = model(next_states)
    with torch.no_grad():
        next_val = model.option_value(next_feat)
        target_opt_val = rewards + gamma * (1-dones) * next_val
    loss_opt_val = torch.nn.functional.mse_loss(opt_val, target_opt_val)
    # 上层Actor 通过 option梯度
    opt_dist = torch.distributions.Categorical(opt_probs)
    log_prob_opt = opt_dist.log_prob(options)
    advantage = target_opt_val - opt_val
    loss_opt_actor = -(log_prob_opt * advantage.detach()).mean()
    # 下层更新
    loss_lower = 0
    for i in range(len(options)):
        opt_idx = options[i].item()
        _, q = model.lower_action_value(feat[i:i+1], opt_idx, actions[i:i+1])
        next_q = target_opt_val[i:i+1]   # 简化
        loss_lower += torch.nn.functional.mse_loss(q, next_q.detach())
    total_loss = loss_opt_val + loss_opt_actor + loss_lower
    optimizer.zero_grad(); total_loss.backward(); optimizer.step()

# 3. 可解释性：SHAP 近似
def shap_approximation(model, state, baseline, num_samples=50):
    state = torch.FloatTensor(state).unsqueeze(0)
    feat, probs, val = model(state)
    # 扰动各特征
    shap_vals = np.zeros(state.shape[1])
    for f in range(state.shape[1]):
        perturbed = state.clone().repeat(num_samples, 1)
        perturbed[:, f] = baseline[f] + torch.randn(num_samples) * 0.1
        _, p_pert, _ = model(perturbed)
        shap_vals[f] = (probs - p_pert.mean(dim=0)).detach().numpy().sum()
    return shap_vals

# TRNSYS 模拟环境接口（伪）
class TRNSYSEnv:
    def step(self, action):
        # 调用TRNSYS python接口
        next_state = np.random.randn(12)
        reward = -np.sum(action)   # 能耗最小化
        return next_state, reward, False, {}