0 导入库
from typing import Tuple
import random
import numpy as np
import torch
from statsmodels.tsa.seasonal import STL
1 EarlyStopping
- 提供了一个早停机制,用于在模型训练过程中监控验证集上的损失
- 如果损失停止改进,则停止训练
1.1 __init__
class EarlyStopping:
def __init__(self, patience=7, verbose=False, delta=0):
self.patience = patience
#早停的容忍度,如果连续 patience 次验证损失没有改善,则停止训练。
self.verbose = verbose
#决定是否输出详细信息
self.counter = 0
#记录连续未改善验证损失的次数
self.best_score = None
#用于存储目前为止最佳的验证损失分数
self.early_stop = False
#一个布尔值,指示是否应该停止训练
self.val_loss_min = np.Inf
#存储目前为止最小的验证损失
self.delta = delta
#一个阈值,用于决定损失的改善幅度
1.2 __call__
在训练过程中监控验证损失
def __call__(self, val_loss, model, path):
score = -val_loss
if self.best_score is None:
self.best_score = score
self.save_checkpoint(val_loss, model, path)
#如果这是第一次调用 __call__,初始化 best_score 为 score 并保存模型。
elif score < self.best_score + self.delta:
self.counter += 1
print(f"EarlyStopping counter: {self.counter} out of {self.patience}")
if self.counter >= self.patience:
self.early_stop = True
'''
如果 score < self.best_score + self.delta,则说明损失没有显著改善
增加 counter 并检查是否超过 patience,如果超过则停止训练
'''
else:
self.best_score = score
self.save_checkpoint(val_loss, model, path)
self.counter = 0
'''
如果 score > self.best_score + self.delta,更新 best_score 并保存模型
然后将 counter 重置为零
'''
1.3 save_checkpoint
在验证损失降低时保存模型
def save_checkpoint(self, val_loss, model, path):
if self.verbose:
print(
f"Validation loss decreased ({self.val_loss_min:.6f} --> {val_loss:.6f}). Saving model ..."
)
torch.save(model.state_dict(), path + "/" + "checkpoint.pth")
#使用 torch.save() 保存模型的状态字典
self.val_loss_min = val_loss
2 StandardScaler
实现数据标准化
2.1 __init__
class StandardScaler:
def __init__(self):
self.mean = 0.0
self.std = 1.0
2.2 fit
计算并更新 self.mean
和 self.std
def fit(self, data):
self.mean = data.mean(0)
self.std = data.std(0)
2.3 transform
将数据转换为标准化形式
def transform(self, data):
mean = (
torch.from_numpy(self.mean).type_as(data).to(data.device)
if torch.is_tensor(data)
else self.mean
)
std = (
torch.from_numpy(self.std).type_as(data).to(data.device)
if torch.is_tensor(data)
else self.std
)
'''
mean 和 std 的类型转换:
根据 data 是 torch.Tensor 还是 numpy 数组
将 self.mean 和 self.std 转换为相应类型,以确保类型匹配
'''
return (data - mean) / std
2.4 inverse_transform
将标准化后的数据还原
def inverse_transform(self, data):
mean = (
torch.from_numpy(self.mean).type_as(data).to(data.device)
if torch.is_tensor(data)
else self.mean
)
std = (
torch.from_numpy(self.std).type_as(data).to(data.device)
if torch.is_tensor(data)
else self.std
)
'''
mean 和 std 的类型转换:
根据 data 是 torch.Tensor 还是 numpy 数组
将 self.mean 和 self.std 转换为相应类型,以确保类型匹配
'''
if data.shape[-1] != mean.shape[-1]:
mean = mean[-1:]
std = std[-1:]
return (data * std) + mean
'''
通过 (data * std) + mean 将标准化后的数据还原为原始形式
'''
3 decompose
使用STL,将时间序列分解为趋势、季节性和残差成分
def decompose(
x: torch.Tensor, period: int = 7
) -> Tuple[torch.Tensor, torch.Tensor, torch.Tensor]:
#x:输入的一维时间序列,类型为 torch.Tensor,形状为 (1, seq_len)
x = x.squeeze(0).cpu().numpy()
'''
首先调用 squeeze(0) 将 x 的第一个维度去掉
然后通过 cpu().numpy() 将 x 转换为 numpy 数组,以便 STL 分解函数使用
'''
decomposed = STL(x, period=period).fit()
'''
调用 STL(x, period=period).fit() 对 x 进行分解,并返回分解结果 decomposed
其中包含了 trend(趋势)、seasonal(季节性)和 resid(残差)成分
'''
trend = decomposed.trend.astype(np.float32)
seasonal = decomposed.seasonal.astype(np.float32)
residual = decomposed.resid.astype(np.float32)
'''
将 decomposed 中的各个成分转换为 numpy 数组,并转为 float32 类型
'''
return (
torch.from_numpy(trend).unsqueeze(0),
torch.from_numpy(seasonal).unsqueeze(0),
torch.from_numpy(residual).unsqueeze(0),
)
'''
将它们转换为 torch.Tensor
并使用 unsqueeze(0) 将其包装为 (1, seq_len) 的张量,以匹配输入张量的形状
'''
4 set_seed
为 Python 中的各种随机生成器设置种子
def set_seed(seed):
random.seed(seed)
np.random.seed(seed)
torch.manual_seed(seed)
torch.cuda.manual_seed_all(seed)