main_informer.py 源码详情注释
import argparse
import datetime
import json
import os
import shutil
import sys
import pandas as pd
import torch
from exp.exp_informer import Exp_Informer
from utils.visualization import *
from utils.initialize_random_seed import *
from pyecharts.globals import CurrentConfig, OnlineHostType
def init_parser():
parser = argparse.ArgumentParser(description='[Informer] Long Sequences Forecasting')
parser.add_argument('--model', type=str, required=False, default='informer',
help='model of experiment, options: [informer, informerstack, informerlight(TBD)]')
parser.add_argument('--data', type=str, required=False, default='C5', help='data them--------------//')
parser.add_argument('--root_path', type=str, default='./data/C5/',
help='数据文件的根路径（root path of the data file）---------------//')
# parser.add_argument('--root_path', type=str, default='./data/ETT/', help='数据文件的根路径（root path of the data file）')
# parser.add_argument('--data_path', type=str, default='ETTh1.csv', help='data file')
parser.add_argument('--data_path', type=str, default='C5#21.csv', help='data file--------------//')
parser.add_argument('--features', type=str, default='MS',
help='预测任务选项（forecasting task, options）:[M, S, MS]; ------------------//'
'M:多变量预测多元（multivariate predict multivariate）, '
'S:单变量预测单变量（univariate predict univariate）, '
'MS:多变量预测单变量（multivariate predict univariate）')
parser.add_argument('--target', type=str, default='NH3', help='S或MS任务中的目标特征列名（target feature in S or MS task）//')
parser.add_argument('--freq', type=str, default='15t',
help='时间特征编码的频率（freq for time features encoding）, ---------------------//'
'选项（options）:[s:secondly, t:minutely, h:hourly, d:daily, b:工作日（business days）, w:weekly, m:monthly], '
'你也可以使用更详细的频率，比如15分钟或3小时（you can also use more detailed freq like 15t or 3h）')
parser.add_argument('--checkpoints', type=str, default='./checkpoints/',
help='模型检查点的位置（location of model checkpoints）')
# seq_len其实就是n个滑动窗口的大小，pred_len就是一个滑动窗口的大小
# [24,36,48,96,128]
parser.add_argument('--seq_len', type=int, default=96,
help='Informer编码器的输入序列长度（input sequence length of Informer encoder）原始默认为96++++++++++++')
parser.add_argument('--label_len', type=int, default=48,
help='inform解码器的开始令牌长度（start token length of Informer decoder），原始默认为48++++++++++++++')
parser.add_argument('--pred_len', type=int, default=76,
help='预测序列长度（prediction sequence length）原始默认为24++++++++++++++++++')
# pred_len就是要预测的序列长度（要预测未来多少个时刻的数据），也就是Decoder中置零的那部分的长度
# Informer decoder input: concat[start token series(label_len), zero padding series(pred_len)]
parser.add_argument('--enc_in', type=int, default=5, help='编码器输入大小（encoder input size）')
parser.add_argument('--dec_in', type=int, default=5, help='解码器输入大小（decoder input size）')
parser.add_argument('--c_out', type=int, default=1, help='输出尺寸（output size）')
parser.add_argument('--d_model', type=int, default=16, help='模型维数（dimension of model）默认是512********************')
parser.add_argument('--n_heads', type=int, default=8, help='（num of heads）***************')
parser.add_argument('--e_layers', type=int, default=2, help='编码器层数（num of encoder layers）*************')
parser.add_argument('--d_layers', type=int, default=1, help='解码器层数（num of decoder layers）*******************')
parser.add_argument('--s_layers', type=str, default='3,2,1',
help='堆栈编码器层数（num of stack encoder layers）*****************')
parser.add_argument('--d_ff', type=int, default=64, help='fcn维度（dimension of fcn），默认是2048****************')
parser.add_argument('--factor', type=int, default=5, help='probsparse attn factor')
parser.add_argument('--padding', type=int, default=0, help='padding type')
parser.add_argument('--distil', action='store_true', help='是否在编码器中使用蒸馏，使用此参数意味着不使用蒸馏'
'（whether to use distilling in encoder, using this argument means not using distilling）',
default=True)
parser.add_argument('--dropout', type=float, default=0.5, help='dropout******************')
parser.add_argument('--seed', type=int, default=12345, help='random seed 随机数种子')
parser.add_argument('--random_choos', type=bool, default=True, help='random seed 随机数种子')
parser.add_argument('--attn', type=str, default='prob', help='用于编码器的注意力机制，选项：[prob, full]'
'（attention used in encoder, options:[prob, full]）')
"""
enc_in: informer的encoder的输入维度
dec_in: informer的decoder的输入维度
c_out: informer的decoder的输出维度
d_model: informer中self-attention的输入和输出向量维度
n_heads: multi-head self-attention的head数
e_layers: informer的encoder的层数
d_layers: informer的decoder的层数
d_ff: self-attention后面的FFN的中间向量表征维度
factor: probsparse attention中设置的因子系数
padding: decoder的输入中，作为占位的x_token是填0还是填1
distil: informer的encoder是否使用注意力蒸馏
attn: informer的encoder和decoder中使用的自注意力机制
embed: 输入数据的时序编码方式
activation: informer的encoder和decoder中的大部分激活函数
output_attention: 是否选择让informer的encoder输出attention以便进行分析
小数据集的预测可以先使用默认参数或适当减小d_model和d_ff的大小
"""
# 时间特征编码【未知】
parser.add_argument('--embed', type=str, default='timeF', help='时间特征编码，选项：[timeF, fixed, learned]'
'（time features encoding, options:[timeF, fixed, learned]）')
parser.add_argument('--activation', type=str, default='gelu', help='activation')
parser.add_argument('--output_attention', action='store_true', help='是否在编码器中输出注意力'
'（whether to output attention in ecoder）')
parser.add_argument('--do_predict', action='store_true', default=True, help='是否预测看不见的未来数据'
'（whether to predict unseen future data）*********************')
parser.add_argument('--mix', action='store_false', help='在生成解码器中使用混合注意力'
'（use mix attention in generative decoder）', default=True)
parser.add_argument('--cols', type=str, nargs='+', help='将数据文件中的某些cols作为输入特性'
'（certain cols from the data files as the input features）')
parser.add_argument('--num_workers', type=int, default=0, help='工作的数据加载器数量'
'data loader num workers')
parser.add_argument('--itr', type=int, default=5, help='次实验------------'
'experiments times')
"""
"""
parser.add_argument('--train_epochs', type=int, default=200, help='train epochs------------')
parser.add_argument('--batch_size', type=int, default=64, help='训练输入数据的批大小-------------'
'batch size of train input data')
parser.add_argument('--patience', type=int, default=5, help='提前停止的连续轮数'
'early stopping patience')
parser.add_argument('--learning_rate', type=float, default=0.001,
help='optimizer learning rate*******************')
parser.add_argument('--des', type=str, default='test', help='实验描述'
'exp description')
parser.add_argument('--loss', type=str, default='mse', help='loss function')
parser.add_argument('--loss_jude', type=str, default='mse', help='loss function')
parser.add_argument('--lradj', type=str, default='type1', help='校正的学习率'
'adjust learning rate')
parser.add_argument('--use_amp', action='store_true', help='使用自动混合精度训练'
'use automatic mixed precision training', default=True)
parser.add_argument('--output', type=str, default='./output', help='输出路径')
# 想要获得最终预测的话这里应该设置为True；否则将是获得一个标准化的预测。
parser.add_argument('--inverse', action='store_true', help='逆标准化输出数据'
'inverse output data', default=True)
parser.add_argument('--use_gpu', type=bool, default=True, help='use gpu')
parser.add_argument('--gpu', type=int, default=0, help='gpu')
parser.add_argument('--use_multi_gpu', action='store_true', help='use multiple gpus', default=False)
parser.add_argument('--devices', type=str, default='0,1', help='device ids of multile gpus')
# 进行parser的变量初始化，获取实例。
args = parser.parse_args()
return args
if __name__ == '__main__':
args = init_parser()
# print(torch.cuda.is_available())
# 判断GPU是否能够使用，并获取标识
args.use_gpu = True if torch.cuda.is_available() and args.use_gpu else False
# 判断是否使用多块GPU，默认不使用多块GPU
if args.use_gpu and args.use_multi_gpu:
# 获取显卡列表，type：str
args.devices = args.devices.replace(' ', '')
# 拆分显卡获取列表，type：list
device_ids = args.devices.split(',')
# 转换显卡id的数据类型
args.device_ids = [int(id_) for id_ in device_ids]
# 获取第一块显卡
args.gpu = args.device_ids[0]
# 初始化数据解析器，用于定义训练模式、预测模式、数据粒度的初始化选项。
"""
字典格式：{数据主题：{data：数据路径，'T':目标字段列名,'M'：，'S'：，'MS':}}
'M:多变量预测多元（multivariate predict multivariate）'，
'S:单变量预测单变量（univariate predict univariate）'，
'MS:多变量预测单变量（multivariate predict univariate）'。
"""
data_parser = {
'ETTh1': {'data': 'ETTh1.csv', 'T': 'OT', 'M': [7, 7, 7], 'S': [1, 1, 1], 'MS': [7, 7, 1]},
'ETTh2': {'data': 'ETTh2.csv', 'T': 'OT', 'M': [7, 7, 7], 'S': [1, 1, 1], 'MS': [7, 7, 1]},
'ETTm1': {'data': 'ETTm1.csv', 'T': 'OT', 'M': [7, 7, 7], 'S': [1, 1, 1], 'MS': [7, 7, 1]},
'ETTm2': {'data': 'ETTm2.csv', 'T': 'OT', 'M': [7, 7, 7], 'S': [1, 1, 1], 'MS': [7, 7, 1]},
'WTH': {'data': 'WTH.csv', 'T': 'WetBulbCelsius', 'M': [12, 12, 12], 'S': [1, 1, 1], 'MS': [12, 12, 1]},
'ECL': {'data': 'ECL.csv', 'T': 'MT_320', 'M': [321, 321, 321], 'S': [1, 1, 1], 'MS': [321, 321, 1]},
'Solar': {'data': 'solar_AL.csv', 'T': 'POWER_136', 'M': [137, 137, 137], 'S': [1, 1, 1], 'MS': [137, 137, 1]},
'electric_power': {'data': 'electric.csv', 'T': 'spg', 'M': [5, 5, 5], 'S': [1, 1, 1], 'MS': [5, 5, 1]},
'C5': {'data': 'C5#21.csv', 'T': 'NH3', 'M': [4, 4, 4], 'S': [1, 1, 1], 'MS': [4, 4, 1]},
}
# 判断在parser中定义的数据主题是否在解析器中
if args.data in data_parser.keys():
# 根据args里面定义的数据主题，获取对应的初始化数据解析器info信息，type：dict
data_info = data_parser[args.data]
# 获取该数据主题的数据文件的路径
args.data_path = data_info['data']
# 从数据解析器中获取 S或MS任务中的目标特征列名。
args.target = data_info['T']
# 从数据解析器中 根据变量features的初始化信息 获取 编码器输入大小，解码器输入大小，输出尺寸
args.enc_in, args.dec_in, args.c_out = data_info[args.features]
# 堆栈编码器层数，type：list
args.s_layers = [int(s_l) for s_l in args.s_layers.replace(' ', '').split(',')]
# 时间特征编码的频率，就是进行特征工程的时候时间粒度选取多少
args.detail_freq = args.freq
args.freq = args.freq[-1:]
print('Args in experiment:')
print(args.freq)
print(args)
now_time = datetime.datetime.now().strftime('%mM_%dD %HH:%Mm:%Ss').replace(" ", "_").replace(":", "_")
# 获取模型实例
Exp = Exp_Informer
# 获取page实例
page_loss = get_page_loss(args.itr)
page_pt = get_page_value(args.itr)
page_p = get_page_noTrue(args.itr)
# 未来的那段时间的真实值
def get_true_month(sheet_name):
data = pd.read_excel('./TrueValue/C5真实值.xls',sheet_name=sheet_name)
true_month = [round(i, 3) for i in data["NH3"].values.tolist()]
return true_month
def get_true_date(sheet_name):
data = pd.read_excel('./TrueValue/C5真实值.xls',sheet_name=sheet_name)
true_date = [round(i, 3) for i in data["NH3"].values.tolist()]
return true_date
them = "11日"
# 存储数据的字典，为了将预测和均值和真实值存储到本地,(若是没有真实值，那么不存储真实值)
data_dict = dict()
# 存储未来预测值的真实数据，为了做可视化和评估未来
true = []
# 存储模型信息的json文件
info_dict = dict()
# 存储预测未来的时候生成的时间
pred_dates = []
if data_parser["C5"]["data"] == "C5#21.csv":
# args.batch_size = 32
them = '11日'
# args.freq = 'h'
try:
true_date = get_true_date(them)
# args.pred_len = len(true_date)
true = true_date
data_dict["true"] = true_date
except:
print("提示：由于未来还没有发生，在真实值数据中没有这个月份数据，故而无法画出未来预测值~未来值的对比图!")
finally:
print("Program to continue！>>>")
else:
# args.batch_size = 32
them = '11日'
# args.freq = 'h'
try:
true_month = get_true_month(them)
# args.pred_len = len(true_month)
true = true_month
data_dict["true"] = true_month
except:
print("提示：由于未来还没有发生，在真实值数据中没有这个月份数据，故而无法画出未来预测值~未来值的对比图!")
finally:
print("Program to continue！>>>")
# 构建单次运行的存储路径：
run_name_dir_old = them + "_" + args.model + "_" + data_parser["C5"]["data"][
-4] + "_" + now_time + "_" + args.data
args.output = os.path.join(args.output, data_parser["C5"]["data"][-4])
run_name_dir = os.path.join(args.output, run_name_dir_old)
if not os.path.exists(run_name_dir):
os.makedirs(run_name_dir)
# 单次运行的n个实验的模型存储的路径：需要判断是否存在，训练的时候已经判断了
args.checkpoints = os.path.join(args.checkpoints, data_parser["C5"]["data"][:-4])
run_name_dir_ckp = os.path.join(args.checkpoints, run_name_dir_old)
# 存储整个实验的info信息
info_file = os.path.join(run_name_dir, "{}_info_{}_{}.json".format(them, args.model, args.data))
is_show_label_sign = data_parser["C5"]["data"][-4]
df_columns = []
# 要进行多少次实验，一次实验就是完成一个模型的训练-测试-预测 过程。默认2次
for ii in range(args.itr):
run_ex_dir = os.path.join(run_name_dir, "第_{}_次实验记录".format(ii + 1))
if args.random_choos == True:
pass
else:
setup_seed(args.seed)
if not os.path.exists(run_ex_dir):
os.makedirs(run_ex_dir)
# 添加实验info
info_dict["实验序号"] = ii
info_dict["model"] = args.model
info_dict["data_them"] = args.data
info_dict["编码器的输入序列长度【滑动窗口大小】"] = args.seq_len
info_dict["预测序列长度"] = args.pred_len
info_dict["时间特征编码的频率【数据粒度】freq"] = args.freq
info_dict["dorpout"] = args.dropout
info_dict["batch_size"] = args.batch_size
info_dict["损失函数loss"] = args.loss
info_dict["提前停止的连续轮数patience"] = args.patience
info_dict["随机种子"] = args.seed
info_dict["是否随机选择"] = args.random_choos
# 实验设置记录要点，方便打印，同时也作为文件名字传入参数，setting record of experiments
setting = '{}_{}_ft{}_sl{}_ll{}_pl{}_dm{}_nh{}_el{}_dl{}_df{}_at{}_fc{}_eb{}_dt{}_mx{}_{}_{}'.format(args.model,
args.data,
args.features,
args.seq_len,
args.label_len,
args.pred_len,
args.d_model,
args.n_heads,
args.e_layers,
args.d_layers,
args.d_ff,
args.attn,
args.factor,
args.embed,
args.distil,
args.mix,
args.des,
ii)
# 设置实验，将数据参数和模型变量传入实例
exp = Exp(args) # set experiments
# 训练模型
print('>>>>>>>start training : {} >>>>>>>>>>>>>>>>>>>>>>>>>>'.format(setting))
model, info_dict, all_epoch_train_loss, all_epoch_vali_loss, all_epoch_test_loss, epoch_count = exp.train(
setting, info_dict, run_name_dir_ckp, run_ex_dir, args)
# 模型测试
print('>>>>>>>testing : {} <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<'.format(setting))
info_dict, test_pred, test_true = exp.test(setting, info_dict, run_ex_dir, args)
# print(test_pred)
# print(test_true)
future_pred, pred_date = 0, 0
# 做预测
if args.do_predict:
print('>>>>>>>predicting : {} <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<'.format(setting))
# 模型预测未来
future_pred, pred_date = exp.predict(setting, run_name_dir_ckp, run_ex_dir, args, True)
pred_dates = pred_date
# print("未来的预测值：",future_pred)
# print("未来的时间范围：",pred_date)
# 存储实验的info信息：
with open(info_file, mode='a', encoding='utf-8') as f:
json.dump(info_dict, f, indent=4, ensure_ascii=False)
# 存储数据：
df = pd.DataFrame(data={"NH3": future_pred, "time": pred_date}, columns=["NH3", "time"])
df.to_csv(os.path.join(run_ex_dir, "第{}次实验_未来预测结果.csv".format(ii + 1)), index=False, encoding='utf-8')
# 存储预测结果到字典
data_dict["实验{}".format(ii + 1)] = future_pred
# 添加字段名字
df_columns.append("实验{}".format(ii + 1))
# 可视化：
line_p = chart_predict(pred_date, future_pred, run_ex_dir, args, ii + 1, is_show_label_sign)
line_loss = chart_loss(all_epoch_train_loss, all_epoch_vali_loss, all_epoch_test_loss, epoch_count, run_ex_dir,
args, ii + 1)
# 将预测的预测和未来的真实值一起进行可视化
if true != []:
line_pt = chart_predict_and_true(pred_date, future_pred, true, run_ex_dir, args, ii + 1, is_show_label_sign)
page_pt.add(line_pt)
# 将图表加入page
page_loss.add(line_loss)
page_p.add(line_p)
# 清除cuda的缓存
torch.cuda.empty_cache()
# 删除存储的模型
shutil.rmtree(run_name_dir_ckp)
# 可视化page
page_loss.render(os.path.join(run_name_dir, "训练-验证-损失可视化-test.html"))
page_loss.save_resize_html(source=os.path.join(run_name_dir, "训练-验证-损失可视化-test.html"),
cfg_file=os.path.join('./output/', "chart_config.json"),
dest=os.path.join(run_name_dir, "训练-验证-损失可视化.html"))
page_p.render(os.path.join(run_name_dir, "predict-test.html"))
page_p.save_resize_html(source=os.path.join(run_name_dir, "predict-test.html"),
cfg_file=os.path.join('./output/', "chart_config.json"),
dest=os.path.join(run_name_dir, "predict.html"))
# 存储字典文件
data_dict["date"] = pred_dates
# print(data_dict['true'])
# print(data_dict['实验1'])
# print(data_dict['date'])
# print(len(data_dict['true']))
# print(len(data_dict['实验1']))
# print(len(data_dict['date']))
# sys.exit()
df = pd.DataFrame(data_dict)
df["pred_mean_NH3"] = df[df_columns].mean(axis=1)
df_columns.insert(0, 'pred_mean_NH3')
if true != []:
df_columns.insert(0, 'true')
page_pt.render(os.path.join(run_name_dir, "predict-true-test.html"))
page_pt.save_resize_html(source=os.path.join(run_name_dir, "predict-true-test.html"),
cfg_file=os.path.join('./output/', "chart_config.json"),
dest=os.path.join(run_name_dir, "predict-true.html"))
df_columns.insert(0, 'date')
df = df[df_columns]
df["pred_mean_NH3"] = round(df["pred_mean_NH3"], 3)
df.to_csv(os.path.join(run_name_dir, "{}次实验_{}未来预测结果.csv".format(args.itr, them)), index=False, encoding='utf-8',
sep=',')
# print(df)
