1 导入库& 数据说明

import  numpy as np
import torch
import matplotlib.pyplot as plt
from tensorboardX import SummaryWriter

x=np.array([[  1,   2],
       [  3,   4],
       [  5,   6],
       [  7,  10],
       [ 13,  18],
       [ 23,  30],
       [ 37,  50],
       [ 63,  86],
       [109, 146],
       [183, 246]])
xx=torch.tensor(x,dtype=torch.float32,requires_grad=True)
xx

我们有这样一组数据x，每一行代表一个时刻的二维数据，我们希望的是 $X[t]=2 \times X[t-3] + X[t-1]$

2 模型

pytorch笔记 pytorch模型中的parameter与buffer_UQI-LIUWJ的博客-CSDN博客

import torch

class Net(torch.nn.Module):
    def __init__(self,lag_list):
        super(Net,self).__init__()
        
        self.lag_list=lag_list
        #时滞集

        self.l=len(self.lag_list)
        #时滞集大小

        self.param=torch.nn.Parameter(torch.zeros(self.l))
        #自回归系数，一个time lag 一个自回归系数
        #自回归系数放入Parameter里面，那么也会随着神经网路梯度下降更新
        
    #定义前向传播方式
    def forward(self,x):
        max_len=max(self.lag_list)
        #时滞集的最大元素，从这个元素之后的一个元素开始，考虑自回归预测和本身的差距

        l=x.shape[0]
        if(type(l)==type(1)):
            pass
        else:
            l=int(l)
        #这里为什么要这么分类一下呢？其实这也是我的一个疑问。
        '''
        直接用pytorch的话，l是一个int类型的数字
        但是如果使用了tensorboardX之后，l是一个Tensor，那么就得用类型转换回int
        '''

        tensor_len=l-max_len
        #表示需要进行（自回归预测-数据本身）比较的长度
        #也就是max_len后一位开始到最后的这一部分的长度
        
        lst_lag=[]
        #不同时滞集对应的输入数据的部分
        for i in self.lag_list:
            lst_lag.append(x[max_len-i:max_len-i+tensor_len].clone())
        #这里为什么要通过这种clone+放入列表的方式呢？
        #因为如果你直接在原始数据上进行切片操作【比如x[i]=x[i-1]+x[i-2]】这种
        #它会因为切片和inplace的问题，而无法传递梯度，最终会报错

        ret_tmp_origin=x[max_len:max_len+tensor_len].clone()
        #原始数据需要比较的一部分
        
        ret_var=self.param[0]*lst_lag[0]
        for i in range(1,self.l):
            ret_var=ret_var+self.param[i]*lst_lag[i]
        #自回归预测的部分

        return(ret_var-ret_tmp_origin)
        #自回归预测的部分和原始部分的差距

3 模型训练& tensorboardＸ可视化

net=Net([3,1])

from tensorboardX import SummaryWriter
 
writer = SummaryWriter('runs/AR_pytorch')
#提供一个路径，将使用该路径来保存日志
 
writer.add_graph(net,xx)
#添加net的计算图


 
#使用Adams进行梯度下降,设置学习率为0.02
optimizer=torch.optim.Adam(net.parameters(),lr=0.02)
 

#开始训练
for epoch in range(1000):
    prediction=net(xx)
    loss=torch.linalg.norm(prediction)
    #每次损失函数都是自回归预测和原始数据之间的L2范数
    
    writer.add_scalar('loss_',loss,epoch)
    #添加loss的summary信息
    
    optimizer.zero_grad()
    #清空上一步残余的参数更新值
    
    loss.backward()
    #误差反向传播，计算参数更新值
    
    optimizer.step()
    #将参数更新值施加到net的parameters上
    
    for i in net.parameters():
        writer.add_scalar('0',i[0].item(),epoch)
        writer.add_scalar('1',i[1].item(),epoch)

在tensorboardX上，有：

3.1 损失函数图像

3.2 自回归系数图像

可以看到，最后和我们目标的[2,1]很接近了

3.3 TensorboardX 计算图

整体如下，左边是自回归的计算路径，右边是原始数据（截取max_len之后的部分）的计算路径

3.3.1 右侧计算路径

ret_tmp_origin=x[max_len:max_len+tensor_len].clone()
#原始数据需要比较的一部分

3.3.2 左侧计算路径

左右路（下） x[2:9] (X[t-1])

左左路（下） x[0:7] (X[t-3])

左中路

就是不同时滞对应的切片*对应的param值

最后这是一个减法，自回归得到的和原始数据相减

pytorch 笔记：手动实现AR （auto regressive）