import torch import torch.nn as nn import torch.nn.functional as F import torch.optim as optim import numpy as np import tqdm import numpy as np import torch from scipy.fft import fft, fftfreq from sklearn.metrics import mean_squared_error, mean_absolute_error model='STGCN' train_month=12 import yaml import os import yaml import torch import numpy as np from sklearn.linear_model import Ridge from collections import defaultdict, deque import numpy as np from torch.utils.data import DataLoader from datetime import datetime from models import STGCN,AGCRN,DCRNN,GWNET,MTGNN,causal_model from tools.data_tools import load_data, get_datasets, expand_adjacency_matrix, load_paper_adj from Dataset import STDataset import csv from sklearn.metrics import mean_absolute_error, mean_squared_error import logging from collections import deque import numpy as np model_dict={'STGCN':STGCN,'AGCRN':AGCRN,'DCRNN':DCRNN,'GWNET':GWNET,'MTGNN':MTGNN} def init_model(model_name='STGCN',model_path='saved_models\STGCN_nycbike_train_months_12final_model.pth',config_path=r'models\nycbike_config.yaml'): with open(config_path, 'r') as config_file: config = yaml.safe_load(config_file) device = config['device'] # Get datasets and scaler train_dataset, val_dataset, test_dataset, scaler,valid_gird = get_datasets( config) logging.info("Configuration:") for key, value in config.items(): logging.info(f"{key}: {value}") # Create data loaders train_loader = DataLoader(train_dataset, batch_size=config['batch_size'], shuffle=True) val_loader = DataLoader(val_dataset, batch_size=config['batch_size'], shuffle=False) test_loader = DataLoader(test_dataset,1, shuffle=False) adj_mx = load_paper_adj(config, valid_gird) config['adj_mx_file'] = os.path.join(config.get('resolved_dataset_dir', 'dataset'), 'adj_mx.npy') config['num_nodes']=len(valid_gird) model=causal_model.CausalModel(model_dict[model_name].Model,config,adj_mx).to(device) model.load_state_dict(torch.load(model_path)) return model,train_loader,val_loader,test_loader,scaler,config,adj_mx class StudentModel(nn.Module): def __init__(self, input_len, output_len, num_nodes): super(StudentModel, self).__init__() self.input_len = input_len self.output_len = output_len self.num_nodes = num_nodes # 学生网络：轻量级模型，处理残差 self.fc = nn.Sequential( nn.Linear((input_len + output_len) * num_nodes * 2, 128), nn.ReLU(), nn.Linear(128, 64), nn.ReLU(), nn.Linear(64, output_len * num_nodes * 2) ) def forward(self, x_hist, teacher_pred): """学生网络前向传播 Args: x_hist (torch.Tensor): 历史数据 (B, L, N, 2) teacher_pred (torch.Tensor): 教师预测 (B, H, N, 2) Returns: torch.Tensor: 残差预测 (B, H, N, 2) """ B = x_hist.shape[0] # 展平历史数据和教师预测 x_flat = x_hist.reshape(B, -1) t_flat = teacher_pred.reshape(B, -1) # 拼接作为学生网络输入 x = torch.cat([x_flat, t_flat], dim=1) out = self.fc(x) # 重塑为输出形状 return out.reshape(B, self.output_len, self.num_nodes, 2) class DSOF(nn.Module): def __init__(self, base_model: nn.Module, input_len, output_len, num_nodes, device, buffer_size=100, batch_size=32, gamma=0.7): """ DSOF在线预测模型 Args: base_model: 基础教师模型 (B, L, N, 2) -> (B, H, N, 2) input_len: 输入序列长度L output_len: 预测序列长度H num_nodes: 区域节点数 device: 运行设备 buffer_size: 经验回放缓冲区大小 batch_size: 批次大小 gamma: 时间差分衰减因子 """ super(DSOF, self).__init__() self.base_model = base_model self.student = StudentModel(input_len, output_len, num_nodes).to(device) self.device = device self.input_len = input_len self.output_len = output_len self.num_nodes = num_nodes # 在线学习参数 self.buffer = deque(maxlen=buffer_size) self.batch_size = batch_size self.gamma = gamma # 不同优化器设置 self.er_optimizer = optim.Adam( list(self.base_model.parameters()) + list(self.student.parameters()), lr=1e-4 ) self.td_optimizer = optim.Adam( self.student.parameters(), lr=1e-3 ) def forward(self, x_hist): """完整前向预测（教师+学生） Args: x_hist (torch.Tensor): 历史数据 (B, L, N, 2) Returns: torch.Tensor: 最终预测 (B, H, N, 2) """ with torch.no_grad(): teacher_pred = self.base_model(x_hist) student_pred = self.student(x_hist, teacher_pred) return teacher_pred + student_pred def _teacher_prediction(self, x_hist): """单独教师预测""" return self.base_model(x_hist) def online(self, test_loader, scaler): """在线预测流程（含双流更新） Args: test_loader: 测试数据加载器 scaler: 数据归一化器 Returns: tuple: 预测结果和真实值 """ self.base_model.train() self.student.train() preds, truths = [], [] batch_idx=0 # 迭代处理每个时间点 for (batch_x, batch_y) in tqdm.tqdm(test_loader): batch_x = batch_x.to(self.device) # (B, L, N, 2) batch_y = batch_y.to(self.device) # (B, H, N, 2) # === 1. 模型预测当前时序 === teacher_pred = self.base_model(batch_x) student_pred = self.student(batch_x, teacher_pred) total_pred = teacher_pred + student_pred preds.append(total_pred.detach().cpu().numpy()) truths.append(batch_y.detach().cpu().numpy()) # === 2. 经验回放更新（慢速流）=== if len(self.buffer) >= self.batch_size+10000000: # 从缓冲区随机采样 indices = np.random.choice(len(self.buffer), self.batch_size, replace=False) batch_samples = [self.buffer[i] for i in indices] # 解压数据 x_batch, y_batch = zip(*batch_samples) x_batch = torch.concatenate(x_batch,dim=0).to(self.device) y_batch = torch.concatenate(y_batch,dim=0).to(self.device) # 教师+学生联合预测 teacher_batch = self.base_model(x_batch) student_batch = self.student(x_batch, teacher_batch) pred_batch = teacher_batch + student_batch # 计算损失并更新 loss_er = nn.MSELoss()(pred_batch, y_batch) self.er_optimizer.zero_grad() loss_er.backward() self.er_optimizer.step() # === 3. 时间差分更新（快速流）=== if batch_idx > 10000000: # 需至少有一次历史预测 # 获取历史预测（上一时间点） prev_x, prev_pred = self.buffer[-1] # 构建伪标签 [y_t, teacher_pred_t+1:t+H] # with torch.no_grad(): # 教师对当前时序预测（包含新数据） current_teacher = self.base_model(batch_x) # 真实值仅取第一个时间点 (y_t) real_first = batch_y[:, :1, :, :] # 教师预测后续时间点 (y_t+1 到 y_t+H) teacher_rest = current_teacher[:, :self.output_len-1, :, :] # 拼接伪标签 pseudo_label = torch.cat([real_first, teacher_rest], dim=1) # 计算加权TD损失 weights = torch.tensor( [self.gamma ** i for i in range(self.output_len)], device=self.device ).view(1, -1, 1, 1) # 计算上一预测与伪标签差异 td_loss = (prev_pred - pseudo_label).pow(2) * weights td_loss = td_loss.mean() # 仅更新学生模型 self.td_optimizer.zero_grad() td_loss.backward() self.td_optimizer.step() # === 4. 更新经验回放缓冲区 === # 存入当前预测（等待未来真实值） self.buffer.append(( batch_x.detach().clone(), teacher_pred.detach().clone() # 存储基础教师预测 )) # === 5. 添加新数据到缓冲区（当获得完整真实值）=== # 注意：实际应用中需等待H步后获取完整真实值 if batch_idx >= self.output_len: # 获取完整真实值序列（H步前预测） past_index = batch_idx - self.output_len (x_past, y_past) = test_loader.dataset[past_index] self.buffer.append(( x_past.unsqueeze(0).to(self.device), y_past.unsqueeze(0).to(self.device) )) batch_idx=batch_idx+1 # 返回逆归一化的结果 preds = scaler.inverse_transform(np.concatenate(preds, axis=0)) truths = scaler.inverse_transform(np.concatenate(truths, axis=0)) mae= np.mean(np.abs(preds-truths)) rmse= np.sqrt(np.mean((preds-truths)**2)) print('mae:' ,mae) print('rmse:' ,rmse) return preds, truths if __name__=='__main__': model,train_loader,val_loader,test_loader,scaler,config,adj_mx=init_model(model_name='GWNET',model_path='saved_models\GWNET_chitaxi_final_model.pth',config_path=r'models\chitaxi_config.yaml') from types import SimpleNamespace config = SimpleNamespace(**config) online_model= DSOF( model,6,1,len(adj_mx),'cuda:0',batch_size=32) online_model.online(test_loader,scaler)