四、自然语言处理_04时序信号的预测思想

1、概述

时序信号在时间维度上存在先后顺序,要想对其做预测,则需要"用过去的自己"来预测"未来的自己"

画一个图来辅助理解:

复制代码
import numpy as np
from matplotlib import pyplot as plt
import os
os.environ["KMP_DUPLICATE_LIB_OK"] = "TRUE"

x = np.linspace(start=0, stop=16* np.pi, num=1000)
y = np.sin(x)

plt.xlabel('x')
plt.ylabel('y')

plt.plot(x, y)
plt.show()

上面一个正弦信号【y=sin(x)】的示例图,将x轴视为时间维度,y轴视为数据值,其即可表示为时序信号

所以,"时序信号的预测问题"就可以转换为"根据过去的x1时间对应的y值,来预测未来x2时间的y值"

面对此问题,我们有两种建模思想:

  • 1、拟合:y = f(x)

    • 输入:x

    • 输出:y

    • 方法:全连接(Linear)

  • 2、拟合:y_n = f(y_1, y_2, ..., y_n-1)

    • 输入:过去的y

    • 输出:当前的y

    • 方法:循环神经网络(RNN、LSTM、GRU等)

2、拟合:y = f(x)

Step1: 构建模型、训练参数以及训练方法

复制代码
import torch
from torch import nn

# 构建模型1:拟合:y = f(x)
class Model1(nn.Module):
    def __init__(self):
        super().__init__()
        self.linear = nn.Sequential(
            nn.Linear(in_features=1, out_features=128),
            nn.ReLU(),
            nn.Linear(in_features=128, out_features=256),
            nn.ReLU(),
            nn.Linear(in_features=256, out_features=128),
            nn.ReLU(),
            nn.Linear(in_features=128, out_features=1)
        )
    def forward(self, x):
        x = self.linear(x)
        return x

# 设备检测
device = "cuda" if torch.cuda.is_available() else "cpu"

# 将[1, N]的数组,转换为[N, 1]的张量
X = torch.tensor(data=x.reshape(-1, 1), dtype=torch.float32).to(device=device)
Y = torch.tensor(data=y.reshape(-1, 1), dtype=torch.float32).to(device=device)

# 设置训练轮次为10000轮
epocs = 10000
# 实例化模型
model1 = Model1()
model1.to(device=device)
# 定义损失函数
loss_fn = nn.MSELoss()
# 定义优化器
optimizer = torch.optim.Adam(params=model1.parameters(), lr=1e-3)

# 构建训练方法
def train():
    for epoch in range(epocs):
        # 1、正向传播
        y_pred = model1(X)
        # 2、计算损失
        loss = loss_fn(y_pred, Y)
        # 3、反向传播
        loss.backward()
        # 4、优化一步
        optimizer.step()
        # 5、清空梯度
        optimizer.zero_grad()
        # 每100轮打印一次损失值
        if epoch % 100:
            print(loss.item())

Step2: 模型训练

复制代码
train()

Step3: 构建预测方法

复制代码
def predict(X):
    if not isinstance(X, torch.Tensor):
        X = torch.tensor(data=X.reshape(-1, 1), dtype=torch.float32).to(device=device)
    else:
        X = X.reshape(-1, 1).to(device=device)
    with torch.no_grad():
        y = model1(X).cpu().numpy().reshape(-1)
        return y

Step4: 模型预测

复制代码
y_pred = predict(x)

Step5: 展示预测效果

复制代码
plt.plot(x, y)
plt.plot(x, predict(x))

3、拟合:y_n = f(y_1, y_2, ..., y_n-1)

Step1: 构建模型、训练参数以及训练方法

复制代码
import torch
from torch import nn

# 构建模型2:y_n = f(y_1, y_2, ..., y_n-1)
class Model2(nn.Module):
    def __init__(self):
        super().__init__()
        self.gru = nn.GRU(input_size=1, hidden_size=256)
        self.linear = nn.Linear(in_features=256, out_features=1)
    def forward(self, x):
        out, hn = self.gru(x)
        x = hn.squeeze(dim=0)
        x = self.linear(x)
        return x

# 设备检测
device = "cuda" if torch.cuda.is_available() else "cpu"

# 设置序列长度为600
SEQ_LEN = 600

X = []
Y = []
# 使用前SEQ_LEN个y,预测下一个y
for idx in range(len(x)-SEQ_LEN):
    y_input = y[idx: idx + SEQ_LEN]
    y_output = y[idx + SEQ_LEN]
    X.append(y_input)
    Y.append(y_output)

X = np.array(X)
# 维度转换:[1, N] --> [N, 1]
Y = np.array(Y).reshape(-1, 1)

# 转张量
# permute(dims=(1, 0))将X的维度进行转换:[batch, seq_len] --> [seq_len, batch]
# unsqueeze(dim=-1)再次进行维度转换:[seq_len, batch] --> [seq_len, batch, input_size](并令input_size=1)
X = torch.tensor(data=X, dtype=torch.float32).permute(dims=(1, 0)).unsqueeze(dim=-1).to(device=device)
Y = torch.tensor(data=Y, dtype=torch.float32).to(device=device)


# 设置训练轮次为1000轮
epocs = 1000
# 实例化模型
model2 = Model2()
model2.to(device=device)
# 定义损失函数
loss_fn = nn.MSELoss()
# 定义优化器
optimizer = torch.optim.Adam(params=model2.parameters(), lr=1e-3)

# 构建训练方法
def train():
    for epoch in range(epocs):
        # 1、正向传播
        y_pred = model2(X)
        # 2、计算损失
        loss = loss_fn(y_pred, Y)
        # 3、反向传播
        loss.backward()
        # 4、优化一步
        optimizer.step()
        # 5、清空梯度
        optimizer.zero_grad()
        # 每100轮打印一次损失值
        if epoch % 100:
            print(loss.item())

Step2: 模型训练

复制代码
train()

Step3: 构建预测方法

复制代码
def predict(y, n=1):
    # 初始化一个空列表 results,用于存储每一步的预测结果
    results = []
    X = y
    for step in range(n):
        X_in = torch.tensor(data=[X], dtype=torch.float32).permute(dims=(1, 0)).unsqueeze(dim=-1).to(device=device)
        with torch.no_grad():
            # 获得预测结果
            y_pred = model2(X_in.to(device=device)).cpu().item()
            # 将预测结果保存至列表中
            results.append(y_pred)
            # 将预测结果 y_pred 添加到当前输入序列 X 的末尾
            X.append(y_pred)
            # 更新 X,移除其第一个元素,这样在下一次迭代中,模型将基于最新的序列进行预测
            X = X[1:]
    return results

Step4: 模型预测

复制代码
# 定义测试序列的起点,进行预测
SEQ_START = 88
# n=2000表示进行2000次连续的预测
y_pred = predict(y[SEQ_START:SEQ_START+SEQ_LEN].tolist(), n=2000)

Step5: 展示预测效果(整体上来看,比第一种方式预测的效果要更好一些)

复制代码
plt.plot(y)
plt.plot(y_pred)
相关推荐
有一只柴犬5 分钟前
3. 实战(一):Spring AI & Trae ,助力开发微信小程序
人工智能·spring·微信小程序
轻松Ai享生活25 分钟前
LLM 文档摘要:技术、指标和模型
人工智能
程序员JerrySUN44 分钟前
走进 detect.tflite:树莓派目标检测背后的核心模型详解
人工智能·目标检测·计算机视觉
yaocheng的ai分身1 小时前
Zed 新开源模型 Zeta 预测下一次编辑
人工智能
小白狮ww1 小时前
支持视频检测, YOLOv12 目标检测刷新速度、精度双记录
人工智能·深度学习·机器学习
wgc2k1 小时前
吴恩达深度学习复盘(2)神经网络的基本原理轮廓
人工智能·深度学习
轻松Ai享生活1 小时前
2025年的春天用三行代码就能创建第一个代理
人工智能
紫雾凌寒1 小时前
自然语言处理|人工智能如何革新作文批改:技术全解析
人工智能·深度学习·自然语言处理·easyui·长文本处理·语义理解·ai批改作文
静心问道1 小时前
CPM:大规模生成式中文预训练语言模型
人工智能·语言模型·自然语言处理
0泡2 小时前
机器学习、深度学习和神经网络
深度学习·神经网络·机器学习·ai