精华内容
下载资源
问答
  • 2020-12-09 21:41:54

    转载自:https://zhuanlan.zhihu.com/p/290683144


    此数据是1949 到 1960 一共 12 年,每年 12 个月的航班乘客数据,一共 144 个数据,单位是 1000。我们使用它来进行LSTM时间序列预测的实验。
    数据如图所示

    第一列为时间 第二列为数据

    编写代码

    头文件

    import numpy
    import matplotlib.pyplot as plt
    from keras.models import Sequential
    from keras.layers import Dense
    from keras.layers import LSTM
    import  pandas as pd
    import  os
    from keras.models import Sequential, load_model
    

    加载数据
    在这里我们设置时序数据的前65%为训练数据 后35%为测试数据

    dataframe = pd.read_csv('./international-airline-passengers.csv', usecols=[1], engine='python', skipfooter=3)
    dataset = dataframe.values
    # 将整型变为float
    dataset = dataset.astype('float32')
    #归一化 在下一步会讲解
    scaler = MinMaxScaler(feature_range=(0, 1))
    dataset = scaler.fit_transform(dataset)
    
    train_size = int(len(dataset) * 0.65)
    trainlist = dataset[:train_size]
    testlist = dataset[train_size:]
    

    对数据进行处理
    LSTM进行预测需要的是时序数据 根据前timestep步预测后面的数据
    假定给一个数据集
    {
    A,B,C->D
    B,C,D->E
    C,D,E->F
    D,E,F->G
    E,F,G->H
    }
    这时timestep为3,即根据前三个的数据预测后一个数据的值
    所以我们需要对数据进行转化
    举一个简单的情况 假设一个list为[1,2,3,4,5],timestep = 2
    我们转化之后要达到的效果是


    train_Xtrain_Y


    即依据前两个值预测下一个值


    对数据进行归一化
    LSTM可以不进行归一化的操作,但是这样会让训练模型的loss下降很慢。本教程如果不进行归一化,100次迭代后loss还是很高

    #上面代码的片段讲解
    scaler = MinMaxScaler(feature_range=(0, 1))
    dataset = scaler.fit_transform(dataset)
    

    对数据进行处理

    def create_dataset(dataset, look_back):
    #这里的look_back与timestep相同
        dataX, dataY = [], []
        for i in range(len(dataset)-look_back-1):
            a = dataset[i:(i+look_back)]
            dataX.append(a)
            dataY.append(dataset[i + look_back])
        return numpy.array(dataX),numpy.array(dataY)
    #训练数据太少 look_back并不能过大
    look_back = 1
    trainX,trainY  = create_dataset(trainlist,look_back)
    testX,testY = create_dataset(testlist,look_back)
    

    LSTM模型
    LSTM的输入为 [samples, timesteps, features]
    这里的timesteps为步数,features为维度 这里我们的数据是1维的

    trainX = numpy.reshape(trainX, (trainX.shape[0], trainX.shape[1], 1))
    testX = numpy.reshape(testX, (testX.shape[0], testX.shape[1] ,1 ))
    
    # create and fit the LSTM network
    model = Sequential()
    model.add(LSTM(4, input_shape=(None,1)))
    model.add(Dense(1))
    model.compile(loss='mean_squared_error', optimizer='adam')
    model.fit(trainX, trainY, epochs=100, batch_size=1, verbose=2)
    model.save(os.path.join("DATA","Test" + ".h5"))
    # make predictions
    

    进行预测

    #model = load_model(os.path.join("DATA","Test" + ".h5"))
    trainPredict = model.predict(trainX)
    testPredict = model.predict(testX)
    
    #反归一化
    trainPredict = scaler.inverse_transform(trainPredict)
    trainY = scaler.inverse_transform(trainY)
    testPredict = scaler.inverse_transform(testPredict)
    testY = scaler.inverse_transform(testY)
    

    查看结果

    plt.plot(trainY)
    plt.plot(trainPredict[1:])
    plt.show()
    plt.plot(testY)
    plt.plot(testPredict[1:])
    plt.show()
    

    这个时候我们的结果为

    在这里插入图片描述

    在这里插入图片描述

    参考
    用 LSTM 做时间序列预测的一个小例子
    Keras中文文档-Sequential model

    更多相关内容
  • LSTM Time Series Prediction with Bayesian optimization.zip
  • LSTM时间序列预测

    千次阅读 2021-09-10 09:40:11
    文章目录 1、tensorflow张量的形状 2、RNN 3、LSTM 3.1 深入了解LSTM结构 4、keras的LSTM 4.1 参数return_sequences含义 5、LSTM实现PM2.5的预测 1、tensorflow张量的形状 tensorflow中张量(tensor)的属性——维数...

    1、tensorflow张量的形状

    tensorflow中张量(tensor)的属性——维数(阶)、形状和数据类型
    在形状的中括号中有多少个数字,就代表这个张量是多少维的张量。

    形状的第一个元素要看张量最外边的中括号中有几个元素(被最外边的中括号里边的内中括号括起来的所有数据算作一个元素)被逗号隔开,有n1个则这个张量就是n1维的,形状的第一个元素就是n1;
    形状的第二个元素要看张量中最左边的第二个中括号中有几个被逗号隔开的元素,有n2个则shape的第二个元素就是n2;形状的第二个元素之后的第3,4…n个元素依次类推,分别看第n个中括号中有几个元素即可:

    1    # 形状为[]
    
    [1,2,3]   # 形状为[3]
    
    [[1,2],[3,4]]   # 形状为[2,2]
    
    [[[1,2],[3,4]],[[1,2],[3,4]]]   # 形状为[2,2,2]
    

    2、RNN

    知乎大佬,写的很棒
    LSTM物理架构
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述

    3、LSTM

    长短期记忆(Long short-term memory, LSTM)是一种特殊的RNN,主要是为了解决长序列训练过程中的梯度消失和梯度爆炸问题。简单来说,就是相比普通的RNN,LSTM能够在更长的序列中有更好的表现。
    LSTM结构(图右)和普通RNN的主要输入输出区别如下所示。

    在这里插入图片描述

    在这里插入图片描述

    3.1 深入了解LSTM结构

    在这里插入图片描述
    在这里插入图片描述

    在这里插入图片描述

    在这里插入图片描述

    4、keras的LSTM

    LSTM一般堆叠2-3层就可以了

    4.1 参数return_sequences含义

    如果设置return_sequences = True,该LSTM层会返回每一个time step的h,那么该层返回的就是1个由多个h组成的2维数组了,如果下一层不是可以接收2维数组的层,就会报错。所以一般LSTM层后面接LSTM层的话,设置return_sequences = True,如果接全连接层的话,设置return_sequences = False。
    在这里插入图片描述

    5、LSTM实现PM2.5的预测

    用24h前的特征数据,预测未来2h的pm2.5

    # -*- coding: utf-8 -*- 
    # @Time : 2021/9/9 14:20 
    # @Author : Orange
    # @File : mylstm.py
    
    import warnings
    
    warnings.filterwarnings("ignore")
    
    import pandas as pd
    import numpy as np
    from sklearn import metrics
    from keras.models import Sequential
    from keras.layers import LSTM
    from keras.layers import Dense, Activation
    from keras.layers import Dropout
    import matplotlib.gridspec as gridspec
    import matplotlib.pyplot as plt
    
    plt.rcParams['font.sans-serif'] = ['SimHei']
    plt.rcParams['axes.unicode_minus'] = False
    
    filepath = 'PRSA_data.csv'  # 文件路径
    data = pd.read_csv(filepath, index_col=0)
    print("data.shape", data.shape)
    print(data.head(10))  # 输出前10行数据
    
    # 查看每一列的缺失值的个数
    print("每一列的缺失值的个数:", data.isnull().sum())
    
    # 按月求平均并填充按月填充空值
    data["pm2.5"] = data.groupby(['year', 'month'])['pm2.5'].transform(lambda x: x.fillna(x.mean()))
    # 查看填充后数据缺失情况
    print("每一列的缺失值的个数:", data.isnull().sum())
    
    # 将cbwd指标数据类型转换成category
    cbwd_category = data['cbwd'].astype('category')
    # 使用标签的编码作为真正的数据
    data['cbwd'] = cbwd_category.cat.codes
    
    # 特征X中的pm2.5数据为前1天的24小时PM2.5浓度,而目标变量是第二天0时和1时的PM2.5浓度
    X_data = data[['pm2.5', 'DEWP', 'TEMP', 'PRES', 'cbwd', 'Iws', 'Is', 'Ir']]  # 提取特征数据
    Y_data = data[['pm2.5']]  # 提取pm2.5数据
    
    name = ['pm2.5', 'DEWP', 'TEMP', 'PRES', 'cbwd', 'Iws', 'Is', 'Ir']
    
    # 按天聚合,用前一天的24h数据预测今天的前两个小时数据
    # X第1天到1825天的24h特征数据
    X = np.array(
        data.groupby(by=['year', 'month', 'day']).apply(lambda x: np.array([x[i].values for i in name]).T).values.tolist())[
        :-1]
    
    data_new = data[data['hour'].apply(lambda x: x == 0 or x == 1)]  # 只保留小时为0和1的数据
    # Y第2天到第1826天的前2h的pm2.5数据
    Y = np.array(
        data_new.groupby(by=['year', 'month', 'day']).apply(lambda x: x['pm2.5'].values).values.tolist())[1:]
    
    # 这里将80%数据作为训练集,20%数据作为测试集,则训练集有1460个样本,测试集有365个样本
    X_train = X[:int(X.shape[0] * 0.8)]
    Y_train = Y[:int(X.shape[0] * 0.8)]
    
    X_val = X[int(X.shape[0] * 0.8)::]
    Y_val = Y[int(X.shape[0] * 0.8)::]
    
    # 标准化
    X_mean = X_train.mean(axis=0)
    X_std = X_train.std(axis=0)
    Y_mean = Y_train.mean(axis=0)
    Y_std = Y_train.std(axis=0)
    
    X_train_norm = (X_train - X_mean) / X_std
    Y_train_norm = (Y_train - Y_mean) / Y_std
    X_val_norm = (X_val - X_mean) / X_std
    Y_val_norm = (Y_val - Y_mean) / Y_std
    
    # 建模
    # 使用3层LSTM,输出层为2输出的Dense层
    model = Sequential()
    model.add(LSTM(32,
                   input_shape=(X_train_norm.shape[1], X_train_norm.shape[-1]),
                   return_sequences=False))
    # model.add(Dropout(0.2))  # 防止过拟合
    # model.add(LSTM(32, return_sequences=True))
    # model.add(Dropout(0.2))
    # model.add(LSTM(32))
    model.add(Dropout(0.2))
    
    model.add(Dense(2))
    model.add(Activation('linear'))
    model.compile(loss='mse',
                  optimizer='rmsprop')
    model.summary()
    
    ## 训练模型
    history = model.fit(X_train_norm, Y_train_norm,
                        epochs=60,
                        batch_size=128,
                        validation_data=(X_val_norm, Y_val_norm))
    
    loss = history.history['loss']
    val_loss = history.history['val_loss']
    
    plt.plot(range(len(loss)), loss, 'b-', label='训练集损失')
    plt.plot(range(len(loss)), val_loss, 'r-', label='测试集损失')
    plt.legend(loc='best')
    plt.show()
    
    model_pred = model.predict(X_val_norm)
    val_pred = model_pred * Y_std + Y_mean  # 别忘了,数据进行了标准化处理,因此预测值需要处理,再计算R方
    
    # 计算R2
    R_2_0 = metrics.r2_score(Y_val[:, 0], val_pred[:, 0])  # 计算0时预测的R方
    R_2_1 = metrics.r2_score(Y_val[:, 1], val_pred[:, 1])  # 计算1时预测的R方
    
    # 实际值与预测值对比图
    fig = plt.subplots(figsize=(12, 6))
    gs = gridspec.GridSpec(2, 1, height_ratios=[1, 1], hspace=0)
    
    ax1 = plt.subplot(gs[0])
    plt.plot(range(Y_val.shape[0]), Y_val[:, 0], 'b-', label='0时PM2.5实际图')
    plt.plot(range(Y_val.shape[0]), val_pred[:, 0], 'r-', label='0时PM2.5预测图')
    plt.legend(loc='best')
    plt.text(150, 400, '拟合R2:{0}%'.format(round(R_2_0 * 100, 2)))
    
    ax2 = plt.subplot(gs[1], sharex=ax1)
    plt.plot(range(Y_val.shape[0]), Y_val[:, 1], 'b-', label='1时PM2.5实际图')
    plt.plot(range(Y_val.shape[0]), val_pred[:, 1], 'r-', label='1时PM2.5预测图')
    ax2.set_xlabel(' ')
    plt.legend(loc='best')
    plt.text(150, 400, '拟合R2:{0}%'.format(round(R_2_1 * 100, 2)))
    plt.show()
    
    

    在这里插入图片描述

    展开全文
  • pytorch LSTM 时间序列预测

    千次阅读 热门讨论 2021-12-02 11:28:49
    pytorch LSTM 时间序列预测

    pytorch LSTM 时间序列预测

    #%%
    import pandas as pd
    import numpy as np
    import torch
    from torch import nn
    from torch.nn import functional as F
    from torch.utils.data import TensorDataset, DataLoader
    import torchkeras
    from plotly import graph_objects as go
    from sklearn.preprocessing import MinMaxScaler
    
    #%%
    # 导入数据
    # 数据下载:https://www.kaggle.com/kankanashukla/champagne-data
    # 下载地址2:https://gitee.com/jejune/Datasets/blob/master/champagne.csv
    df = pd.read_csv('champagne.csv', index_col=0)
    df.head()
    
    Month   Sales
    1964-01 2815
    1964-02	2672
    1964-03	2755
    1964-04	2721
    1964-05	2946
    
    #%%
    # 数据预览
    fig = go.Figure()
    fig.add_trace(go.Scatter(x=df.index, y=df['Sales'], name='Sales'))
    fig.show()
    

    在这里插入图片描述

    #%%
    # 数据处理
    # 归一化 [0, 1]
    scaler = MinMaxScaler()
    predict_field = 'Scaler'
    df[predict_field] = scaler.fit_transform(df['Sales'].values.reshape(-1, 1))
    df.head()
    
    Month	Sales	Scaler
    1964-01	2815    0.112133
    1964-02	2672	0.100696
    1964-03	2755	0.107334
    1964-04	2721	0.104615
    1964-05	2946	0.122611
    
    #%%
    def create_dataset(data:list, time_step: int):
        arr_x, arr_y = [], []
        for i in range(len(data) - time_step - 1):
            x = data[i: i + time_step]
            y = data[i + time_step]
            arr_x.append(x)
            arr_y.append(y)
        return np.array(arr_x), np.array(arr_y)
    
    time_step = 8
    X, Y = create_dataset(df[predict_field].values, time_step)
    
    #%%
    # cuda
    device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
    # 转化成 tensor->(batch_size, seq_len, feature_size)
    X = torch.tensor(X.reshape(-1, time_step, 1), dtype=torch.float).to(device)
    Y = torch.tensor(Y.reshape(-1, 1, 1), dtype=torch.float).to(device)
    print('Total datasets: ', X.shape, '-->', Y.shape)
    
    # 划分数据
    split_ratio = 0.8
    len_train = int(X.shape[0] * split_ratio)
    X_train, Y_train = X[:len_train, :, :], Y[:len_train, :, :]
    print('Train datasets: ', X_train.shape, '-->', Y_train.shape)
    
    Total datasets:  torch.Size([96, 8, 1]) --> torch.Size([96, 1, 1])
    Train datasets:  torch.Size([76, 8, 1]) --> torch.Size([76, 1, 1])
    
    #%%
    # 构建迭代器
    batch_size = 10
    ds = TensorDataset(X, Y)
    dl = DataLoader(ds, batch_size=batch_size, num_workers=0)
    ds_train = TensorDataset(X_train, Y_train)
    dl_train = DataLoader(ds_train, batch_size=batch_size, num_workers=0)
    # 查看第一个batch
    x, y = next(iter(dl_train))
    print(x.shape)
    print(y.shape)
    
    torch.Size([10, 8, 1])
    torch.Size([10, 1, 1])
    
    #%%
    # 定义模型
    class Net(nn.Module):
        def __init__(self):
            super(Net, self).__init__()
            self.lstm = nn.LSTM(input_size=1, hidden_size=6, num_layers=3, batch_first=True)
            self.fc = nn.Linear(in_features=6, out_features=1)
    
        def forward(self, x):
            # x is input, size (batch_size, seq_len, input_size)
            x, _ = self.lstm(x)
            # x is output, size (batch_size, seq_len, hidden_size)
            x = x[:, -1, :]
            x = self.fc(x)
            x = x.view(-1, 1, 1)
            return x
    
    #%%
    # torchkeras API 训练方式
    model = torchkeras.Model(Net())
    model.summary(input_shape=(time_step, 1))
    model.compile(loss_func=F.mse_loss, optimizer=torch.optim.Adam(model.parameters(), lr=1e-2), device=device)
    dfhistory = model.fit(epochs=50, dl_train=dl_train, log_step_freq=20)
    
    
    ----------------------------------------------------------------
            Layer (type)               Output Shape         Param #
    ================================================================
                  LSTM-1                 [-1, 8, 6]             888
                Linear-2                    [-1, 1]               7
    ================================================================
    Total params: 895
    Trainable params: 895
    Non-trainable params: 0
    ----------------------------------------------------------------
    Input size (MB): 0.000031
    Forward/backward pass size (MB): 0.000374
    Params size (MB): 0.003414
    Estimated Total Size (MB): 0.003819
    ----------------------------------------------------------------
    Start Training ...
    
    ================================================================================2022-03-28 12:21:58
    
     +-------+-------+
    | epoch |  loss |
    +-------+-------+
    |   1   | 0.045 |
    +-------+-------+
    
    ================================================================================2022-03-28 12:21:59
    
     +-------+-------+
    | epoch |  loss |
    +-------+-------+
    |   2   | 0.054 |
    +-------+-------+
    
    ...
    
    
     +-------+-------+
    | epoch |  loss |
    +-------+-------+
    |   50  | 0.003 |
    +-------+-------+
    
    ================================================================================2022-03-28 12:22:00
    Finished Training...
    
    #%%
    # 模型评估
    fig = go.Figure()
    fig.add_trace(go.Scatter(x=dfhistory.index, y=dfhistory['loss'], name='loss'))
    fig.show()
    

    在这里插入图片描述

    #%%
    # 预测验证预览
    y_true = Y.cpu().numpy().squeeze()
    y_pred = model.predict(dl).detach().cpu().numpy().squeeze()
    fig = go.Figure()
    fig.add_trace(go.Scatter(y=y_true, name='y_true'))
    fig.add_trace(go.Scatter(y=y_pred, name='y_pred'))
    fig.show()
    

    在这里插入图片描述

    #%%
    # 自定义训练方式
    model = Net().to(device)
    loss_function = nn.MSELoss()
    optimizer = torch.optim.Adam(model.parameters(), lr=1e-2)
    
    def train_step(model,features, labels):
        # 正向传播求损失
        predictions = model.forward(features)
        loss = loss_function(predictions, labels)
        # 反向传播求梯度
        loss.backward()
        # 参数更新
        optimizer.step()
        optimizer.zero_grad()
        return loss.item()
    
    
    # 测试一个batch
    features, labels = next(iter(dl_train))
    loss = train_step(model, features, labels)
    loss
    
    0.016526855528354645
    
    #%%
    # 训练模型
    def train_model(model, epochs):
        for epoch  in range(1, epochs+1):
            list_loss = []
            for features, labels in dl_train:
                lossi = train_step(model,features, labels)
                list_loss.append(lossi)
            loss = np.mean(list_loss)
            if epoch % 10 == 0:
                print('epoch={} | loss={} '.format(epoch,loss))
    
    train_model(model, 50)
    
    epoch=10 | loss=0.047142161638475955 
    epoch=20 | loss=0.03120349021628499 
    epoch=30 | loss=0.009641124575864524 
    epoch=40 | loss=0.002635095050209202 
    epoch=50 | loss=0.0018647939796210267
    
    #%%
    # 预测验证预览
    y_pred = model.forward(X).detach().cpu().numpy().squeeze()
    fig = go.Figure()
    fig.add_trace(go.Scatter(y=y_true, name='y_true'))
    fig.add_trace(go.Scatter(y=y_pred, name='y_pred'))
    fig.show()
    

    在这里插入图片描述

    展开全文
  • LSTM时间序列预测销量

    2018-12-26 19:23:17
    本代码采用python语言写的一个LSTM时间序列预测销量
  • lstm预测】基于lstm实现时间序列数据预测matlab.zip
  • (只考虑一维数据) LSTM时间序列预测可以实现单步预测、多步预测 单步预测:步预测1步 多步预测::3步预测3步 将时序数据转换为LSTM的训练数据函数如下: 输入时序数据、input_size步预测output_size步 def data_...

    1 keras

    1.1 入门

    资源:
    https://www.bilibili.com/video/BV1Ct411H7rm?from=search&seid=13437359564386162135

    keras是一种深度学习框架,用起来比tensorflow简单

    目前深度学习框架用得最多的是tensorflow,pytorch,keras,keras比tensorflow大约慢一倍。

    安装:安装好python环境后,要安装tensorflow(有CPU和GPU版本,为了简单可以安装CPU版本),之后在命令行输入 pip install keras

    1.2 简单的线性回归

    import keras
    
    import numpy as np
    
    import matplotlib.pyplot as plt
    # Sequential 按顺序构成的模型
    from keras.models import Sequential
    # Dense 全连接层
    from keras.layers import Dense
    
    # 使用numpy的随机函数生成100个点
    
    x_data = np.random.rand(100)
    noise = np.random.normal(0,0.01,x_data.shape)
    y_data = x_data*0.1 + 0.2 + noise
    
    #scatter生成散点图
    plt.scatter(x_data,y_data)
    

    在这里插入图片描述

    # 构建一个顺序模型
    model = Sequential()
    
    # 在模型中添加(add)一个全连接层(Dense)
    model.add(Dense(units=1,input_dim=1)) #参数的意思:输入输出都是一维(输入一个x,输出一个y)
    
    # 编译模型
    #sgd:随机梯度下降法
    #mse:均方误差
    model.compile(optimizer='sgd',loss='mse')
    
    # 训练模型,因此需要循环进行不断的迭代
    
    for step in range(3001):
        #把所有数据作为一个批次,每次训练一个批次
        cost = model.train_on_batch(x_data,y_data)
        #每500个batch打印依次cost值
        if step%500 == 0:
            print('batch:',step,'cost:',cost)
            
    #打印权值和偏置值
    W,b = model.layers[0].get_weights()
    print('W:',W,'b:',b)
    
    #模型训练好之后,把x_data输入网络中,得到预测值
    
    y_pred = model.predict(x_data)
    
    #显示随机点
    plt.scatter(x_data,y_data)
    
    #显示预测结果
    plt.plot(x_data,y_pred,'r-',lw=3)
    plt.show()
    

    在这里插入图片描述

    1.3 非线性回归

    • 增加隐藏层
    • 设定激活函数,在未设置激活函数时,默认为线性激活函数
      在这里插入图片描述

    2 LSTM

    如何将时间序列数据变为LSTM的输入输出数据
    (只考虑一维数据)

    LSTM时间序列预测可以实现单步预测、多步预测
    单步预测:步预测1步
    在这里插入图片描述
    多步预测::3步预测3步
    在这里插入图片描述
    将时序数据转换为LSTM的训练数据函数如下:
    输入时序数据、input_size步预测output_size步

    def data_split(data,input_size,output_size):
        X,Y = [],[]
        for arr in data:
            for i in range(len(arr)):
                if i+input_size+output_size-1 < data.shape[1]:
                    X.append(arr[i:i+input_size])
                    Y.append(arr[i+input_size:i+input_size+output_size])               
        return np.array(X),np.array(Y)
    

    例如,

    x,y = data_split(dat,3,3)
    

    data为2* 25的ndarray数组
    在这里插入图片描述
    输出的x,y为40* 3的ndarray数组
    在这里插入图片描述
    值得注意的是!!! LSTM的输入格式为:(N,T,M)
    N:训练数据长度
    T:上述模型为3输入3输出模型,T就为3
    M:1(因为是一维数,数据特征的维数)

    因此需要对输入数据进行

     x = np.reshape(x, (x.shape[0], 3,1))
    

    x,y 得到之后,模型构建如下函数:

    n_in = x.shape[1]
    n_features = .shape[2]
    n_out = y.shape[1]
    
    model = create_model(n_in,n_features,n_out)
    

    构建LSTM子函数

    def create_model(n_in,n_features,n_out):
        model = Sequential()
        model.add(LSTM(128, activation='relu', input_shape=(n_in, n_features),return_sequences=True))
        model.add(LSTM(128, activation='relu'))
        model.add(Dropout(0.3))#正则化
        model.add(Dense(n_out))
        model.compile(optimizer='adam', loss='mae')
        return model
    

    训练模型

    
    error_matrix = []
    for step in range(1001):#训练1000次
        cost = model.train_on_batch(x,y)
        error_matrix.append(cost)
        if step%100 == 0:        
            print('batch:',step,'cost:',cost)
            
            
    y_train_pred = model.predict(x)
    train_error = np.mean(abs(y_train_pred-y)/y)
    print('训练集上的误差为:',train_error*100,'%')
    plt.plot(error_matrix)
    plt.xlabel('训练次数')
    plt.ylabel('误差函数值')
    plt.savefig('fig2.png',dpi=600)
    

    误差函数变化如图:

    在这里插入图片描述
    LSTM模型的预测结果如图
    (这个图只用了前22个数据训练模型,模型为3-3)

    在这里插入图片描述

    3 附录

    构建RNN子函数

    def create_model_RNN(n_out):
        model1 = Sequential()
        model1.add(SimpleRNN(128))
        model1.add(Activation('relu'))  #激活层
        model1.add(Dropout(0.5))  # dropout层防止过拟合
        model1.add(Dense(3))      # 全连接层
        model1.add(Activation('relu'))  #激活层
        model1.compile(optimizer='adam', loss='mae')
        return model1
    
    
    展开全文
  • LSTM的控制流程:是在前向传播的过程中处理流经细胞的数据,不同之处在于 LSTM 中细胞的结构和运算有所变化。 这一系列运算操作使得 LSTM具有能选择保存信息或遗忘信息的功能。咋一看这些运算操作时可能有点复杂,...
  • 一、贝叶斯网络及LSTM简介 1 贝叶斯网络 贝叶斯网络(Bayesian network),又称信念网络(Belief Network),或有向无环图模型(directed acyclic graphical model),是一种概率图模型,于1985年由Judea Pearl首先提出。...
  • 时序预测 | MATLAB实现BiLSTM时间序列预测 目录时序预测 | MATLAB实现BiLSTM时间序列预测基本介绍程序设计单层网络多层网络参考资料致谢 基本介绍 双向 LSTM 或 biLSTM 是一种序列处理模型,由两个 LSTM 组成:一个...
  • pytorch lstm时间序列预测问题踩坑

    千次阅读 2022-01-23 22:30:11
    时间序列问题2.问题1.数据集自己做,为多个输入对应多个或一个输出2.损失函数注意:不能用交叉熵 nn.CrossEntropyLoss()3.准确率 1.做时间序列问题 2.问题 1.数据集自己做,为多个输入对应多个或一个输出 2.损失...
  • 参考链接: 在Python中使用LSTM和PyTorch进行时间序列预测 想了解更多好玩的人工智能应用,请关注公众号“机器AI学习 数据AI挖掘”,”智能应用"菜单中包括:颜值检测、植物花卉识别、文字识别、人脸美妆等有趣的...
  • 雾霾数据可视化统计与Keras LSTM时间序列预测 Laravel是一个web应用程序框架,具有表达力强、语法优雅的特点。我们认为,发展必须是一种享受和创造性的经历,才能真正实现。Laravel试图通过简化大多数web项目中使用...
  • sequenceInputLayer(numFeatures) lstmLayer(numHiddenUnits) fullyConnectedLayer(numResponses) regressionLayer]; %接下来设置求解的各项参数,指定训练选项。将求解器设置为 'adam' 并进行 250 轮训练。要防止...
  • 神经网络时间序列预测 Long Short-Term Memory 循环神经网络 电力负荷预测
  • 长短期记忆网络,预测速度与时间的关系是时间序列
  • 【Matlab时间序列预测】CNN优化LSTM时间序列预测【含源码 1688期】 二、matlab版本及参考文献 1 matlab版本 2014a 2 参考文献 [1]董渊博,茅大钧,章明明.基于CNN-LSTM的燃气轮机NOx排放预测研究[J]. 热能动力工程. ...
  • 网上有很多关于lstm时间序列的博客,我从不同博客那里借鉴了许多。 理论知识: 项目已开源上传到gitee上: 时间序列预测仓库: 本项目从简单入门到涉及部分高级预测代码,正在维护中,涉及单变量单步预测,单...
  • tensorflow下用LSTM网络进行时间序列预测,实时多变量预测以及对于未来数据的单变量预测。
  • <p>LSTM时间序列预测,预测值画出来结果成了一条直线,下面是原数据的大概样子 <p style="text-align:center"><img alt="" height="352" src=...
  • lstm时间序列预测模型 时间序列-LSTM模型 (Time Series - LSTM Model) Advertisements 广告 Previous Page 上一页 Next Page 下一页 Now, we are familiar with statistical modelling on time series...
  • LSTM时间序列预测 文章目录前言一、具体步骤1.导包、读取文件2.和上一篇的步骤一3.新预测,向下预测7步4.画图疑惑点 前言 lstm怎样实现对未来值的预测? 所拥有的数据共3648个值,目标是继续向下预测3649,3650… ...
  • pytorch实现的LSTM时间序列预测

    千次阅读 2020-07-26 14:39:27
    先占个位置,随后给出我修改的代码 ...mid=2447578969&idx=1&sn=1ae03db749b56b1d2a140e1369bd8dba&chksm=8458c6d9b32f4fcf2ade01c726fa734476a9e173eb1189cc3a4eef3e0d350a635ea986e8f35c&...
  • 时间注意力的LSTM网络用于时间序列预测
  • 提出了一种长短期记忆网络和卷积神经网络(LSTM-CNN) 相结合的方法,利用历史PM2. 5浓度数据、历史气象数据和时间数据,对空气质量监测站未来6 h PM2. 5浓度做出预测。该模型主要由2部分组成:1) 基于长短期记忆网络的...
  • matlab出图,运行保障,代码有详细说明,适用初学者。
  • 一、鲸鱼算法及LSTM简介 1 鲸鱼优化算法(Whale Optimization Algorithm,WOA)简介 鲸鱼优化算法(WOA),该算法模拟了座头鲸的社会行为,并引入了气泡网狩猎策略。 1.1 灵感 鲸鱼被认为是世界上最大的哺乳动物。一头...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 19,869
精华内容 7,947
关键字:

lstm时间序列预测