本项目代码统一了训练方式只需在models文件夹中加入下面模型类即可使用该模型而不需要重新写训练模型等的代码减少了代码的冗余。

代码有注释不加解释

TimeSeriesDataset(Dataset):自定义的时间序列数据集类用于处理时间序列数据的加载和预处理。

目的是将时间序列数据准备成适合机器学习模型训练的格式(按滑动窗口划分)。

Args:data

(torch.Tensor):

if_BatchingTrue):创建自定义时间序列数据集Args:args

(Namespace):

是否批次化类似XGBoost算法不需要Returns:Tuple[TimeSeriesDataset,

TimeSeriesDataset,

pd.read_csv(os.path.join(args.root_path,

args.data_path))#

1))scaler.fit(train_data)train_data

scaler.transform(train_data)vali_data

scaler.transform(vali_data)test_data

转换为张量并添加维度train_data

torch.from_numpy(train_data).float()vali_data

torch.from_numpy(vali_data).float()test_data

torch.from_numpy(test_data).float()#

将其变为[1,

train_data.unsqueeze(0).permute(0,

1)vali_data

vali_data.unsqueeze(0).permute(0,

1)test_data

test_data.unsqueeze(0).permute(0,

1)#

按滑动时间窗口转成机器学习的数据格式training_dataset

args)valiing_dataset

args)print(ftrain:{len(training_dataset)},vali:{len(valiing_dataset)},test:{len(testing_dataset)})if

if_Batching:#

batch_sizeargs.batch_size)vali_loader

shuffleTrue,

batch_sizeargs.batch_size)test_loader

shuffleFalse,

batch_sizelen(testing_dataset))return

train_loader,

self).__init__()self.input_size

configs.input_size

nn.Sequential(nn.Conv1d(in_channelsself.input_size,

out_channels64,

输入特征维度为input_size输出通道数为64卷积核大小为kernel_sizenn.ReLU(),

ReLU激活函数nn.MaxPool1d(kernel_sizeself.kernel_size,

stride1)

nn.Sequential(nn.Conv1d(in_channels64,

out_channels128,

输入通道数为64输出通道数为128卷积核大小为2nn.ReLU(),

ReLU激活函数nn.MaxPool1d(kernel_sizeself.kernel_size,

stride1)

根据卷积操作后的数据格式和输出大小计算线性层的输入维度conv_output_size

self._calculate_conv_output_size()#

线性层1输入维度为卷积层输出大小输出维度为50self.linear1

50)#

线性层2输入维度为50输出维度为预测结果的维度self.linear2

nn.Linear(50,

_calculate_conv_output_size(self):自动计算卷积层输出形状此操作避免手算该参数

参数:input_size(

self.conv1(input_tensor)conv2_output

self.conv2(conv1_output)conv_output_size

conv2_output.view(conv2_output.size(0),

-1).size(1)return

在非循环层之间应用的丢弃比例默认为0.0没有丢弃。

self.bidirectional

创建GRU层

nn.GRU(input_sizeself.input_size,

num_layersself.num_layers,dropoutself.dropout,

bidirectionalself.bidirectional,

batch_firstTrue)#

Variable(torch.zeros(self.num_layers,

x.size(0),

self).__init__()self.input_size

configs.input_size

在非循环层之间应用的丢弃比例默认为0.0没有丢弃。

self.bidirectional

如果为TrueLSTM将是双向的包括前向和后向默认为False。

self.lstm

nn.LSTM(input_sizeconfigs.input_size,

hidden_sizeconfigs.hidden_size,num_layersconfigs.num_layers,

dropoutself.dropout,

bidirectionalself.bidirectional,batch_firstTrue)

LSTM

Variable(torch.zeros(self.num_layers,

x.size(0),

Variable(torch.zeros(self.num_layers,

x.size(0),

提取最后一个时间步的隐藏状态并进行形状变换使用LSTM的最后一个时间步的隐藏状态h_out作为线性层的输入是因为模型将隐藏状态视为包含了序列信息的高层表示。

在许多情况下使用最后一个时间步的隐藏状态进行预测已经足够。

out

self.fc(h_out)

self).__init__()self.input_size

configs.input_size

输入特征的大小即输入层的维度。

self.output_size

configs.output_size

输出的大小即预测结果的维度。

self.channel_sizes

[int(size)

configs.channel_sizes.split(,)]

一个整数列表指定每个隐藏层的单元数量。

列表的长度表示隐藏层的层数每个元素表示对应隐藏层的单元数量。

self.time_step

[]input_adjust_size

range(len(self.channel_sizes)):if

0:#

对于第一层创建一个从input_size到channel_sizes[i]的线性层self.linear

self.channel_sizes[i])self.init_weights()

[self.linear,

将线性层和ReLU激活函数添加到layers列表中else:#

对于后续层创建一个从channel_sizes[i-1]到channel_sizes[i]的线性层self.linear

1],

self.channel_sizes[i])self.init_weights()

[self.linear,

创建最后一个线性层从channel_sizes[-1]到output_sizeself.linear

nn.Linear(self.channel_sizes[-1],

self.output_size)self.init_weights()

[self.linear]

使用layers列表创建一个Sequential网络self.network

init_weights(self):#

使用均值为0标准差为0.01的正态分布初始化线性层的权重self.linear.weight.data.normal_(0,

0.01)def

无论输入数据的特征数和时间步数如何都能适应到模型中。

这个修改应该可以适用于不同维度的输入数据。

x

x.view(x.size(0),

self).__init__()self.input_size

configs.input_size

在非循环层之间应用的丢弃比例默认为0.0没有丢弃。

self.bidirectional

如果为TrueLSTM将是双向的包括前向和后向默认为False。

#

定义RNN结构输入特征大小、隐藏状态维度、层数等参数self.rnn

nn.RNN(input_sizeself.input_size,

dropoutself.dropout,bidirectionalself.bidirectional,

batch_firstTrue)#

Variable(torch.zeros(self.num_layers,

x.size(0),

通过RNN传播输入数据获取输出out和最终隐藏状态h_0out,

h_0

TCN模型结构Chomp1d模块用于从卷积层的输出中移除无效的时间步。

class

self).__init__()self.chomp_size

chomp_sizedef

Chomp1d模块的作用是从卷积层的输出中移除无效的时间步即通过切片操作去掉最后的self.chomp_size个时间步。

#

由于切片操作可能导致存储不连续因此在返回结果之前需要使用contiguous()方法确保存储连续性。

return

x[:,

:-self.chomp_size].contiguous()

TemporalBlock模块包含两个卷积层和相应的正则化、激活函数和dropout操作。

第一个卷积层使用权重归一化通过Chomp1d组件移除无效的时间步然后经过ReLU激活函数和dropout操作。

第二个卷积层也经过相同的处理流程。

通过残差连接将第二个卷积层的输出和输入进行相加并通过ReLU激活函数得到最终的输出。

class

dropout0.2):super(TemporalBlock,

self).__init__()#

weight_norm(nn.Conv1d(n_inputs,

3096,

随机失活dropout。

随机失活是一种常用的正则化技术用于减少过拟合self.dropout1

nn.Dropout(dropout)#

如果输入通道数和输出通道数不相同则需要进行下采样self.downsample

nn.Conv1d(n_inputs,

使用均值为0标准差为0.01的正态分布初始化权重self.conv1.weight.data.normal_(0,

0.01)self.conv2.weight.data.normal_(0,

0.01)if

None:self.downsample.weight.data.normal_(0,

0.01)def

connection是一种在神经网络中引入跨层连接的技术。

它的目的是解决深层神经网络训练中的梯度消失或梯度爆炸问题并促进信息在网络中的流动。

#

在TCN模型中残差连接被用于将每个TemporalBlock的输出与输入进行相加。

这种设计使得信息可以直接通过跨层连接流动有助于梯度的传播和模型的训练。

#

具体地在TemporalBlock的forward方法中首先通过两个卷积层进行特征提取和建模然后将第二个卷积层的输出和输入进行相加。

这个相加的操作实现了残差连接。

最终通过ReLU激活函数对相加的结果进行非线性变换。

#

残差连接的好处是即使在网络较深的情况下梯度可以通过跨层连接直接传播到前面的层次减少了梯度消失的问题。

同时它也提供了一种捕捉输入与输出之间的细微差异和变化的机制有助于提高模型的性能。

TCN

模型的核心由多个TemporalBlock组成的网络层次结构。

每个层次上的TemporalBlock的参数根据当前层次的位置和前一层的输出通道数进行确定。

class

dropout0.2):super(TemporalConvNet,

[]self.relu

range(num_levels):dilation_size

iin_channels

dilationdilation_size,padding(kernel_size

dilation_size,

将所有的TemporalBlock按顺序组合成一个网络self.network

forward(self,

它包括一个TemporalConvNet一个线性层和一个下采样层。

输入数据首先经过TemporalConvNet进行序列建模和特征提取然后通过ReLU激活函数和残差连接进行处理。

最后通过线性层进行预测并通过下采样层将输入数据的通道数降低到与TemporalBlock的输出通道数相同以便在残差连接中使用。

class

self).__init__()self.input_size

configs.input_size

卷积层通道数的列表用于定义TemporalConvNet的深度self.kernel_size

configs.kernel_size

TemporalConvNet(self.input_size,

self.num_channels,

nn.Linear(self.num_channels[-1],

self.output_size)#

init_weights(self):self.linear.weight.data.normal_(0,

0.01)self.downsample.weight.data.normal_(0,

0.01)def

Models.layers.Transformer.decoder

import

Models.layers.Transformer.encoder

import

Models.layers.Transformer.utils

import

Need的Transformer模型。

适用于顺序数据的经典Transformer模型。

嵌入Embedding已被替换为全连接层最后一层softmax函数替换为sigmoid函数。

属性----------layers_encoding:

:py:class:list

:class:Encoder.Encoder编码器层的堆叠。

layers_decoding:

:py:class:list

:class:Decoder.Decoder解码器层的堆叠。

参数----------d_input:模型输入的维度。

d_model:输入向量的维度。

d_output:模型输出的维度。

q:查询和键的维度。

v:值的维度。

h:头数。

N:要堆叠的编码器和解码器层数量。

attention_size:应用注意力机制的反向元素数量。

如果为

None。

dropout:每个多头自注意力MHA或前馈全连接PFF块之后的dropout概率。

默认为

chunk、window

configs):根据Encoder和Decoder块创建Transformer结构。

super(Model,

configs.d_outputq

nn.ModuleList([Encoder(d_model,q,v,h,attention_sizeattention_size,dropoutdropout,chunk_modechunk_mode)

for

nn.ModuleList([Decoder(d_model,q,v,h,attention_sizeattention_size,dropoutdropout,chunk_modechunk_mode)

for

pe_functions.keys():self._generate_PE

pe_functions[pe]self._pe_period

pe_periodelif

torch.Tensor:通过Transformer进行输入传播。

通过嵌入模块、编码器和解码器堆叠以及输出模块进行输入传播。

参数----------x:形状为

(batch_size,

**pe_params)positional_encoding

positional_encoding.to(encoding.device)encoding.add_(positional_encoding)#

编码器堆叠for

self._d_model)positional_encoding

positional_encoding.to(decoding.device)decoding.add_(positional_encoding)for

layer