import paddleclass Autoregressive(paddle.nn.Layer):
    def __init__(self, y_features, x_features, e_features):
        # y_features 是一个整数，是因变量的阶数
        # x_features 是一个由整数组成的list，是自变量的阶数，例如有10个自变量，则list的长度为10，每个变量的阶数都可以有所不同
        # e_features 是一个整数，误差的阶数
        super(Autoregressive, self).__init__()

        self.y_features = y_features
        self.x_features = x_features
        self.e_features = e_features        # 构造一个linear_list用于动态构造Linear层
        linear_list = []        if y_features != 0:
            linear_list.append(paddle.nn.Linear(y_features, 1, bias_attr=True))        for _x in x_features:
            linear_list.append(paddle.nn.Linear(_x, 1, bias_attr=True))        if e_features != 0:
            linear_list.append(paddle.nn.Linear(e_features, 1, bias_attr=True))        
        # 将构造好的网络进行组合
        self.linear_list = paddle.nn.Sequential(*linear_list)    def forward(self, *inputs):
        # 自回归模型本质是各个Linear的加法，用0初始化输出变量
        output = paddle.to_tensor([0]).astype('float32')        # 逐个Linear计算
        for i in range(len(self.linear_list)):
            output += self.linear_list[i](inputs[i])            
        return output

model = Autoregressive(0, [1], 0)
x = paddle.to_tensor(1,dtype='float32').reshape([1,1])
model(x)

import paddleclass AR(paddle.nn.Layer):
    def __init__(self, y_features):
        super(AR, self).__init__()
        self.y_features = y_features
        self.Autoregressive = Autoregressive(y_features, [], 0)    def forward(self, *inputs):
        # 只有自回归变量y输入，传入inputs和传入inputs[0]都可以
        output = self.Autoregressive(inputs[0])        return output

model = AR(5)
paddle.summary(model,(5,5))

# 读取数据，复现时请到上述链接中下载文件，解压后，将csv文件放在aistudio目录中import pandas as pdimport numpy as np

df = pd.read_csv('AirQualityUCI.csv', sep=';')
df = df.dropna(how = 'all')
y = df.iloc[:,3].to_list()# 对y进行简单预处理，映射为均值为1的序列y = (np.array(y)/np.array(y).mean()).tolist()

import paddleclass MyDateset(paddle.io.Dataset):
    def __init__(self, y_list = y, q = 100, mode = 'train'): # q是阶数
        super(MyDateset, self).__init__()

        self.mode = mode
        self.y = y
        self.q = q    def __getitem__(self, index):
        data = self.y[index:index+self.q]
        label = self.y[index + self.q]
        data = paddle.to_tensor(data, dtype='float32').reshape([self.q])
        label = paddle.to_tensor(label, dtype='float32')        return data,label    def __len__(self):
        return len(self.y)-self.qif 1:
    train_dataset=MyDateset(y, 100)

    train_dataloader = paddle.io.DataLoader(
        train_dataset,
        batch_size=16,
        shuffle=True,
        drop_last=False)    for step, data in enumerate(train_dataloader):
        data, label = data        print(step, data.shape, label.shape)        break

model = AR(100)
model.train()if 1:    try:        # 接续之前的模型重复训练
        param_dict = paddle.load('./model.pdparams')
        model.load_dict(param_dict)    except:        print('no such model file')

train_dataset=MyDateset(y, 100)
train_dataloader = paddle.io.DataLoader(
    train_dataset,
    batch_size=64,
    shuffle=True,
    drop_last=False)

max_epoch=100scheduler = paddle.optimizer.lr.CosineAnnealingDecay(learning_rate=0.00001, T_max=max_epoch)
opt = paddle.optimizer.Adam(learning_rate=scheduler, parameters=model.parameters())

now_step=0for epoch in range(max_epoch):    for step, data in enumerate(train_dataloader):
        now_step+=1

        img, label = data
        pre = model(img)
        loss = paddle.nn.functional.mse_loss(pre, label).mean()

        loss.backward()
        opt.step()
        opt.clear_gradients()        if now_step%100==0:            print("epoch: {}, batch: {}, loss is: {}".format(epoch, step, loss.mean().numpy()))

paddle.save(model.state_dict(), 'model.pdparams')

data = y[-100:]for i in range(100):
    input_y = data[i:i+100]
    input_y = paddle.to_tensor(input_y).reshape([1,100])
    output_y = model(input_y)
    data.append(output_y.numpy()[0][0])

|- PaddleAutoregressive
   |- __init__.py # 留空即可
   |- AR.py # AR的模型声明，需要从Autoregressive.py中import Autoregressive，打包后import路径要从包名开始
   |- Autoregressive.py # 基础模型的声明|-setup.py

from setuptools import setup, find_packages

setup(    name='PaddleAutoregressive',    packages=find_packages()
)

# 下载代码! git clone https://github.com/Liyulingyue/PaddleAutoregressive.git
%cd ~/PaddleAutoregressive# 安装! pip install -e .

%cd ~import PaddleAutoregressive.AR as ARimport paddle
model = AR.AR(5)
paddle.summary(model,(5,5))