精华内容
下载资源
问答
  • tcn时间序列预测
    千次阅读
    2022-06-27 10:55:40

    I. 前言

    前面已经写了很多关于时间序列预测的文章:

    1. 深入理解PyTorch中LSTM的输入和输出(从input输入到Linear输出)
    2. PyTorch搭建LSTM实现时间序列预测(负荷预测)
    3. PyTorch搭建LSTM实现多变量时间序列预测(负荷预测)
    4. PyTorch搭建双向LSTM实现时间序列预测(负荷预测)
    5. PyTorch搭建LSTM实现多变量多步长时间序列预测(一):直接多输出
    6. PyTorch搭建LSTM实现多变量多步长时间序列预测(二):单步滚动预测
    7. PyTorch搭建LSTM实现多变量多步长时间序列预测(三):多模型单步预测
    8. PyTorch搭建LSTM实现多变量多步长时间序列预测(四):多模型滚动预测
    9. PyTorch搭建LSTM实现多变量多步长时间序列预测(五):seq2seq
    10. PyTorch中实现LSTM多步长时间序列预测的几种方法总结(负荷预测)
    11. PyTorch-LSTM时间序列预测中如何预测真正的未来值
    12. PyTorch搭建LSTM实现多变量输入多变量输出时间序列预测(多任务学习)
    13. PyTorch搭建ANN实现时间序列预测(风速预测)
    14. PyTorch搭建CNN实现时间序列预测(风速预测)
    15. PyTorch搭建CNN-LSTM混合模型实现多变量多步长时间序列预测(负荷预测)
    16. PyTorch搭建Transformer实现多变量多步长时间序列预测(负荷预测)
    17. 时间序列预测系列文章总结(代码使用方法)

    上述文章中都没有涉及到近些年来比较火的Attention机制,随Attention机制一起提出的是transformer模型,关于transformer模型的原理网上各种讲解很多,这里就不具体描述了,有机会再写。

    II. Transformer

    PyTorch封装了Transformer的具体实现,如果导入失败可以参考:torch.nn.Transformer导入失败

    Transformer模型搭建如下:

    class TransformerModel(nn.Module):
        def __init__(self, args):
            super(TransformerModel, self).__init__()
            self.args = args
            # embed_dim = head_dim * num_heads?
            self.input_fc = nn.Linear(args.input_size, args.d_model)
            self.output_fc = nn.Linear(args.input_size, args.d_model)
            self.pos_emb = PositionalEncoding(args.d_model)
            encoder_layer = nn.TransformerEncoderLayer(
                d_model=args.d_model,
                nhead=8,
                dim_feedforward=4 * args.d_model,
                batch_first=True,
                dropout=0.1,
                device=device
            )
            decoder_layer = nn.TransformerDecoderLayer(
                d_model=args.d_model,
                nhead=8,
                dropout=0.1,
                dim_feedforward=4 * args.d_model,
                batch_first=True,
                device=device
            )
            self.encoder = torch.nn.TransformerEncoder(encoder_layer, num_layers=5)
            self.decoder = torch.nn.TransformerDecoder(decoder_layer, num_layers=5)
            self.fc = nn.Linear(args.output_size * args.d_model, args.output_size)
            self.fc1 = nn.Linear(args.seq_len * args.d_model, args.d_model)
            self.fc2 = nn.Linear(args.d_model, args.output_size)
    
        def forward(self, x):
            # print(x.size())  # (256, 24, 7)
            y = x[:, -self.args.output_size:, :]
            # print(y.size())  # (256, 4, 7)
            x = self.input_fc(x)  # (256, 24, 128)
            x = self.pos_emb(x)   # (256, 24, 128)
            x = self.encoder(x)
            # 不经过解码器
            x = x.flatten(start_dim=1)
            x = self.fc1(x)
            out = self.fc2(x)
            # y = self.output_fc(y)   # (256, 4, 128)
            # out = self.decoder(y, x)  # (256, 4, 128)
            # out = out.flatten(start_dim=1)  # (256, 4 * 128)
            # out = self.fc(out)  # (256, 4)
    
            return out
    

    初始时的数据输入维度为7,也就是每个时刻的负荷值以及6个环境变量。在Transformer的原始论文中,文本的嵌入维度为512,而且PyTorch规定nhead数和d_model也就是嵌入维度必须满足整除关系,因此首先将原始数据从7维映射到d_model维度:

    x = self.input_fc(x)
    

    其中input_fc:

    self.input_fc = nn.Linear(args.input_size, args.d_model)
    

    然后对原始输入进行位置编码:

    x = self.pos_emb(x)
    

    然后经过编码层:

    x = self.encoder(x)
    

    得到的输出和输入维度一致。

    原始Transformer中的解码器效果很差,因此这里直接将编码器的编码结果经过两个线性层得到输出:

    x = x.flatten(start_dim=1)
    x = self.fc1(x)
    out = self.fc2(x)
    

    III. 代码实现

    3.1 数据处理

    利用前24小时的负荷值+环境变量预测后12个时刻的负荷值,数据处理和前面一致。

    3.2 模型训练/测试

    和前文一致。

    3.3 实验结果

    训练50轮,MAPE为7.09%:
    在这里插入图片描述

    IV. 源码及数据

    后面将陆续公开~

    更多相关内容
  • 序列建模基准和时间卷积网络(TCN) 该存储库包含Shaojie Bai,J。Zico Kolter和Vladlen Koltun完成的实验。 我们专门针对一整套综合任务,这些任务已被反复用来比较不同循环网络的有效性,并在循环网络的主场上评估...
  • 基于注意力的的方法,预测使用的tcntcn是比lstm更好的一种预测方法,附数据
  • 时间序列预测——时序卷积网络(TCN

    万次阅读 多人点赞 2021-04-11 08:47:38
      本文展示了使用时序卷积网络(TCN)进行时间序列预测的全过程,包含详细的注释。整个过程主要包括:数据导入、数据清洗、结构转化、建立TCN模型、训练模型(包括动态调整学习率和earlystopping的设置)、预测、...

      本文展示了使用时序卷积网络(TCN)进行时间序列预测的全过程,包含详细的注释。整个过程主要包括:数据导入、数据清洗、结构转化、建立TCN模型、训练模型(包括动态调整学习率和earlystopping的设置)、预测、结果展示、误差评估等完整的时间序列预测流程。
      本文使用的tcn库在本人上传的资源中,链接为tcn.py
      本文使用的数据集在本人上传的资源中,链接为mock_kaggle.csv

    import pandas as pd
    import numpy as np
    import math
    from matplotlib import pyplot as plt
    from matplotlib.pylab import mpl
    import tensorflow as tf
    from sklearn.preprocessing import MinMaxScaler
    from keras import backend as K
    from keras.layers import LeakyReLU
    from tcn import TCN,tcn_full_summary
    from sklearn.metrics import mean_squared_error # 均方误差
    from keras.callbacks import LearningRateScheduler
    from keras.callbacks import EarlyStopping
    from tensorflow.keras import Input, Model,Sequential
    
    
    mpl.rcParams['font.sans-serif'] = ['SimHei']   #显示中文
    mpl.rcParams['axes.unicode_minus']=False       #显示负号
    

    取数据

    data=pd.read_csv('mock_kaggle.csv',encoding ='gbk',parse_dates=['datetime'])
    Date=pd.to_datetime(data.datetime)
    data['date'] = Date.map(lambda x: x.strftime('%Y-%m-%d'))
    datanew=data.set_index(Date)
    series = pd.Series(datanew['股票'].values, index=datanew['date'])
    
    series
    
    date
    2014-01-01    4972
    2014-01-02    4902
    2014-01-03    4843
    2014-01-04    4750
    2014-01-05    4654
                  ... 
    2016-07-27    3179
    2016-07-28    3071
    2016-07-29    4095
    2016-07-30    3825
    2016-07-31    3642
    Length: 937, dtype: int64
    

    滞后扩充数据

    dataframe1 = pd.DataFrame()
    num_hour = 16
    for i in range(num_hour,0,-1):
        dataframe1['t-'+str(i)] = series.shift(i)
    dataframe1['t'] = series.values
    dataframe3=dataframe1.dropna()
    dataframe3.index=range(len(dataframe3))
    
    dataframe3
    
    t-16t-15t-14t-13t-12t-11t-10t-9t-8t-7t-6t-5t-4t-3t-2t-1t
    04972.04902.04843.04750.04654.04509.04329.04104.04459.05043.05239.05118.04984.04904.04822.04728.04464
    14902.04843.04750.04654.04509.04329.04104.04459.05043.05239.05118.04984.04904.04822.04728.04464.04265
    24843.04750.04654.04509.04329.04104.04459.05043.05239.05118.04984.04904.04822.04728.04464.04265.04161
    34750.04654.04509.04329.04104.04459.05043.05239.05118.04984.04904.04822.04728.04464.04265.04161.04091
    44654.04509.04329.04104.04459.05043.05239.05118.04984.04904.04822.04728.04464.04265.04161.04091.03964
    ......................................................
    9161939.01967.01670.01532.01343.01022.0813.01420.01359.01075.01015.0917.01550.01420.01358.02893.03179
    9171967.01670.01532.01343.01022.0813.01420.01359.01075.01015.0917.01550.01420.01358.02893.03179.03071
    9181670.01532.01343.01022.0813.01420.01359.01075.01015.0917.01550.01420.01358.02893.03179.03071.04095
    9191532.01343.01022.0813.01420.01359.01075.01015.0917.01550.01420.01358.02893.03179.03071.04095.03825
    9201343.01022.0813.01420.01359.01075.01015.0917.01550.01420.01358.02893.03179.03071.04095.03825.03642

    921 rows × 17 columns

    二折划分数据并标准化

    # pot=int(len(dataframe3)*0.8)
    pd.DataFrame(np.random.shuffle(dataframe3.values))  #shuffle
    pot=len(dataframe3)-12
    train=dataframe3[:pot]
    test=dataframe3[pot:]
    scaler = MinMaxScaler(feature_range=(0, 1)).fit(train)
    #scaler = preprocessing.StandardScaler().fit(train)
    train_norm=pd.DataFrame(scaler.fit_transform(train))
    test_norm=pd.DataFrame(scaler.transform(test))
    
    test_norm.shape,train_norm.shape
    
    ((12, 17), (909, 17))
    
    X_train=train_norm.iloc[:,:-1]
    X_test=test_norm.iloc[:,:-1]
    Y_train=train_norm.iloc[:,-1:]
    Y_test=test_norm.iloc[:,-1:]
    

    转换为3维数据 [samples, timesteps, features]

    source_x_train=X_train
    source_x_test=X_test
    X_train=X_train.values.reshape([X_train.shape[0],1,X_train.shape[1]]) #从(909,16)-->(909,1,16)
    X_test=X_test.values.reshape([X_test.shape[0],1,X_test.shape[1]])  #从(12,16)-->(12,1,16)
    Y_train=Y_train.values
    Y_test=Y_test.values
    
    X_train.shape,Y_train.shape
    
    ((909, 1, 16), (909, 1))
    
    X_test.shape,Y_test.shape
    
    ((12, 1, 16), (12, 1))
    
    type(X_train),type(Y_test)
    
    (numpy.ndarray, numpy.ndarray)
    

    动态调整学习率与提前终止函数

    def scheduler(epoch):
        # 每隔50个epoch,学习率减小为原来的1/10
        if epoch % 50 == 0 and epoch != 0:
            lr = K.get_value(tcn.optimizer.lr)
            if lr>1e-5:
                K.set_value(tcn.optimizer.lr, lr * 0.1)
                print("lr changed to {}".format(lr * 0.1))
        return K.get_value(tcn.optimizer.lr)
    
    reduce_lr = LearningRateScheduler(scheduler)
    early_stopping = EarlyStopping(monitor='loss', 
                                   patience=20, 
                                   min_delta=1e-5,
                                   mode='auto',
                                   restore_best_weights=False,#是否从具有监测数量的最佳值的时期恢复模型权重
                                   verbose=2)
    

    构造TCN模型

    batch_size=None
    timesteps=X_train.shape[1]
    input_dim=X_train.shape[2] #输入维数
    tcn = Sequential()
    input_layer =Input(batch_shape=(batch_size,timesteps,input_dim))
    tcn.add(input_layer)
    tcn.add(TCN(nb_filters=64, #在卷积层中使用的过滤器数。可以是列表。
            kernel_size=3, #在每个卷积层中使用的内核大小。
            nb_stacks=1,   #要使用的残差块的堆栈数。
            dilations=[2 ** i for i in range(6)], #扩张列表。示例为:[1、2、4、8、16、32、64]。
            #用于卷积层中的填充,值为'causal' 或'same'。
            #“causal”将产生因果(膨胀的)卷积,即output[t]不依赖于input[t+1:]。当对不能违反时间顺序的时序信号建模时有用。
            #“same”代表保留边界处的卷积结果,通常会导致输出shape与输入shape相同。
            padding='causal',
            use_skip_connections=True, #是否要添加从输入到每个残差块的跳过连接。
            dropout_rate=0.1, #在0到1之间浮动。要下降的输入单位的分数。
            return_sequences=False,#是返回输出序列中的最后一个输出还是完整序列。
            activation='relu', #残差块中使用的激活函数 o = Activation(x + F(x)).
            kernel_initializer='he_normal', #内核权重矩阵(Conv1D)的初始化程序。
            use_batch_norm=True, #是否在残差层中使用批处理规范化。
            use_layer_norm=True, #是否在残差层中使用层归一化。
            name='tcn' #使用多个TCN时,要使用唯一的名称
            ))
    tcn.add(tf.keras.layers.Dense(64))
    tcn.add(tf.keras.layers.LeakyReLU(alpha=0.3))
    tcn.add(tf.keras.layers.Dense(32))
    tcn.add(tf.keras.layers.LeakyReLU(alpha=0.3))
    tcn.add(tf.keras.layers.Dense(16))
    tcn.add(tf.keras.layers.LeakyReLU(alpha=0.3))
    tcn.add(tf.keras.layers.Dense(1))
    tcn.add(tf.keras.layers.LeakyReLU(alpha=0.3))
    tcn.compile('adam', loss='mse', metrics=['accuracy'])
    tcn.summary()
    
    Model: "sequential"
    _________________________________________________________________
    Layer (type)                 Output Shape              Param #   
    =================================================================
    tcn (TCN)                    (None, 64)                143168    
    _________________________________________________________________
    dense (Dense)                (None, 64)                4160      
    _________________________________________________________________
    leaky_re_lu (LeakyReLU)      (None, 64)                0         
    _________________________________________________________________
    dense_1 (Dense)              (None, 32)                2080      
    _________________________________________________________________
    leaky_re_lu_1 (LeakyReLU)    (None, 32)                0         
    _________________________________________________________________
    dense_2 (Dense)              (None, 16)                528       
    _________________________________________________________________
    leaky_re_lu_2 (LeakyReLU)    (None, 16)                0         
    _________________________________________________________________
    dense_3 (Dense)              (None, 1)                 17        
    _________________________________________________________________
    leaky_re_lu_3 (LeakyReLU)    (None, 1)                 0         
    =================================================================
    Total params: 149,953
    Trainable params: 148,417
    Non-trainable params: 1,536
    _________________________________________________________________
    

    训练

    history=tcn.fit(X_train,Y_train, epochs=80,batch_size=32,callbacks=[reduce_lr])
    
    Train on 909 samples
    Epoch 1/80
    909/909 [==============================] - 14s 16ms/sample - loss: 0.1332 - accuracy: 0.0187
     ......
    Epoch 10/80
    909/909 [==============================] - 1s 1ms/sample - loss: 0.0135 - accuracy: 0.0187
     ......
    Epoch 20/80
    909/909 [==============================] - 1s 1ms/sample - loss: 0.0091 - accuracy: 0.0187
     ......
    Epoch 30/80
    909/909 [==============================] - 1s 1ms/sample - loss: 0.0090 - accuracy: 0.0176
     ......
    Epoch 40/80
    909/909 [==============================] - 1s 1ms/sample - loss: 0.0059 - accuracy: 0.0187
     ......
    Epoch 50/80
    909/909 [==============================] - 1s 1ms/sample - loss: 0.0067 - accuracy: 0.0187
    lr changed to 0.00010000000474974513
     ......
    Epoch 60/80
    909/909 [==============================] - 1s 1ms/sample - loss: 0.0047 - accuracy: 0.0187
     ......
    Epoch 70/80
    909/909 [==============================] - 1s 1ms/sample - loss: 
    ......
    Epoch 80/80
    909/909 [==============================] - 1s 1ms/sample - loss: 0.0050 - accuracy: 0.0187
    
    history.history.keys() #查看history中存储了哪些参数
    plt.plot(history.epoch,history.history.get('loss')) #画出随着epoch增大loss的变化图
    #plt.plot(history.epoch,history.history.get('acc'))#画出随着epoch增大准确率的变化图
    

    在这里插入图片描述

    预测

    predict = tcn.predict(X_test)
    real_predict=scaler.inverse_transform(np.concatenate((source_x_test,predict),axis=1))
    real_y=scaler.inverse_transform(np.concatenate((source_x_test,Y_test),axis=1))
    real_predict=real_predict[:,-1]
    real_y=real_y[:,-1]
    

    误差评估

    plt.figure(figsize=(15,6))
    bwith = 0.75 #边框宽度设置为2
    ax = plt.gca()#获取边框
    ax.spines['bottom'].set_linewidth(bwith)
    ax.spines['left'].set_linewidth(bwith)
    ax.spines['top'].set_linewidth(bwith)
    ax.spines['right'].set_linewidth(bwith)
    plt.plot(real_predict,label='real_predict')
    plt.plot(real_y,label='real_y')
    plt.plot(real_y*(1+0.15),label='15%上限',linestyle='--',color='green')
    # plt.plot(real_y*(1+0.1),label='10%上限',linestyle='--')
    # plt.plot(real_y*(1-0.1),label='10%下限',linestyle='--')
    plt.plot(real_y*(1-0.15),label='15%下限',linestyle='--',color='green')
    plt.fill_between(range(0,12),real_y*(1+0.15),real_y*(1-0.15),color='gray',alpha=0.2)
    plt.legend()
    plt.show()
    

    在这里插入图片描述

    round(mean_squared_error(Y_test,predict),4)
    
    0.0012
    
    from sklearn.metrics import r2_score
    round(r2_score(real_y,real_predict),4)
    
    0.5192
    
    per_real_loss=(real_y-real_predict)/real_y
    avg_per_real_loss=sum(abs(per_real_loss))/len(per_real_loss)
    print(avg_per_real_loss)
    
    0.13984217335814073
    
    #计算指定置信水平下的预测准确率
    #level为小数
    def comput_acc(real,predict,level):
        num_error=0
        for i in range(len(real)):
            if abs(real[i]-predict[i])/real[i]>level:
                num_error+=1
        return 1-num_error/len(real)
    
    comput_acc(real_y,real_predict,0.2),comput_acc(real_y,real_predict,0.15),comput_acc(real_y,real_predict,0.1)
    
    (0.75, 0.6666666666666667, 0.33333333333333337)
    
    展开全文
  • 时序预测 | MATLAB实现TCN时间卷积神经网络的时间序列预测

    时序预测 | MATLAB实现TCN时间卷积神经网络的时间序列预测

    预测效果

    1
    2

    3

    4

    基本介绍

    MATLAB实现TCN时间卷积神经网络的时间序列预测
    运行环境Matlab2021b.

    模型特

    展开全文
  • 时间序列预测——时序卷积网络中用到的tcn库文件。
  • 利用LSTM构建的深度学习实现单变量时间序列的代码,利用Keras实现,
  • 时序预测TCN模型

    2022-05-17 20:23:33
    提示:时序预测时间卷积网络的相关模型 文章目录一、TCN二、TCN的初步改进三、TCN的进一步改进总结 一、TCN 二、TCN的初步改进 [74] Dilated Convolutional Neural Networks for Time Series Forecasting ...

    提示:时序预测中时间卷积网络的相关模型


    一、TCN

    在这里插入图片描述

    二、TCN的初步改进

    • [74] Dilated Convolutional Neural Networks for Time Series Forecasting
      在这里插入图片描述

    • [75] Probabilistic Forecasting with Temporal Convolutional Neural Network
      在这里插入图片描述
      在这里插入图片描述

    • [76] Multivariate Temporal Convolutional Network A Deep Neural Networks Approach for Multivariate Time Series Forecasting
      在这里插入图片描述
      在这里插入图片描述

    • [77] Temporal Convolutional Networks Applied to Energy-Related Time Series Forecasting
      在这里插入图片描述

    三、TCN的进一步改进

    四、其它领域的TCN模型

    • MS-TCN: Multi-Stage Temporal Convolutional Network for Action Segmentation
      在这里插入图片描述

    • MS-TCN++: Multi-Stage Temporal Convolutional Network for Action Segmentation
      在这里插入图片描述


    总结

    展开全文
  • Sequence Modeling Benchmarks and Temporal Convolutional Networks (TCN) This repository contains the experiments done in the work An Empirical Evaluation of Generic Convolutional and Recurrent Networks...
  • 时间卷积网络TCN时间序列处理的新模型

    万次阅读 多人点赞 2020-08-21 09:00:45
    然后,我们介绍了一些使用TCN的应用,包括改进交通预测,声音事件定位和检测,以及概率预测。 简单回顾一下TCN Lea等人(2016)的开创性工作首次提出了用于基于视频的动作分割的时间卷积网络(tns)。这个传统的过程包括...
  • 时序卷积网络 | Python实现TCN时序卷积网络数据预测 目录时序卷积网络 | Python实现TCN时序卷积网络数据预测基本介绍工作原理程序设计参考资料 基本介绍 本文绍时序卷积网络TCN(Temporal Convolutional Network)...
  • 时间序列预测代码matlab 时间序列预测使用深度学习生成数据 该项目研究了在使用不同的人工神经网络(即LSTM和GRU)建模的随机时间模型上可以进行多近的时间序列预测和预测。 给定的数据集包括辐照数据集和发电数据集...
  • Pytorch Forecasting旨在通过神经网络简化实际案例和研究中的时间序列预测。 具体来说,该软件包提供了有关“迈向数据科学”的文章,介绍了该软件包并提供了背景信息。 Pytorch Forecasting旨在通过神经网络简化实际...
  • 写在前面下面这篇文章首先主要简单介绍了目前较为先进的时间序列预测方法——时间卷积神经网络(TCN)的基本原理,然后基于TCN的开源代码,手把手教你如何通过时间卷积神经网络来进行股价预测,...
  • 时间序列预测 该存储库实现了时间序列预测的常用方法,尤其是TensorFlow2中的深度学习方法。 如果您有更好的主意,欢迎您贡献力量,只需创建PR。 如有任何疑问,请随时提出问题。正在进行的项目,我将继续进行改进,...
  • 为了训练我们的 TCN 网络进行预测,训练集将由(输入序列、目标序列)对给定时间序列的大小相等的子序列对组成。目标系列将是相对于其各自的输入系列向前移动一定数量 output_length 的系列。这意味着长度为 input_...
  • 本文研究时间序列的长期预测问题。先前的基于 Transformer 的模型采用各种 self-attention 机制来发现长期依赖关系。然而,长期未来的复杂时间模式使基于 Transformer 的模型无法找到可靠的依赖关系。此外,...
  • 相关cnn、lstm、gru、tcn等等一些优化过后的用于时间序列预测的方法。还有EMD、小波等算法的实现。有需要的可以私聊,可以不用积分。
  • 这本来是我回答的一个问题:有什么好的模型可以做高精度的时间序列预测呢? - BINGO Hong的回答 - 知乎 https://www.zhihu.com/question/21229371/answer/533770345但觉得在那个答案下一直更新好麻烦,干脆就移到...
  • CNN经过一些简单的调整就可以成为序列建模和预测的强大工具 尽管卷积神经网络(CNNs)通常与图像分类任务相关,但经过适当的修改,它已被证明是进行序列建模和预测的有价值的工具。在本文中,我们将详细探讨时域卷积...
  • 1、时间序列预测05 2、转发大佬贴时间序列预测
  • 传统的时间序列预测方法如ARIMA模型和Holt-Winters季节性方法具有理论上的保证,但它们主要适用于单变量预测问题,并且要求时间序列是平稳的,这大大限制了它们在现实世界复杂时间序列数据中的应用。
  • 5.1 Global: Temporal Convolution Network regularized Matrix Factorization (TCN-MF) 在本节中,我们提出了一个用于时间序列预测的低秩矩阵分解模型(low-rank matrix factorization model),该模型使用 TCN ...
  • 时间序列预测分析就是利用过去一段时间内某事件时间的特征来预测未来一段时间内该事件的特征。这是一类相对比较复杂的预测建模问题,和回归分析模型的预测不同,时间序列模型是依赖于事件发生的先后顺序的,同样大小...
  • 时间序列预测方法最全总结!

    万次阅读 多人点赞 2021-03-12 00:15:38
    时间序列预测就是利用过去一段时间的数据来预测未来一段时间内的信息,包括连续型预测(数值预测,范围估计)与离散型预测(事件预测)等,具有非常高的商业价值。需要明确一点的是,与回归分析预测模型...
  • 股票价格预测-LSTM-TCN-GBDT使用四种算法(LSTM,TCN,GRU,GBDT)进行股票价格的预测预测结果的检验。

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 470
精华内容 188
关键字:

tcn时间序列预测