精华内容
下载资源
问答
  • 长短记忆网络
    2021-03-22 22:50:15

    LSTM(长短记忆网络)

    一:LSTM简介

    ​ 传统的循环网络RNN可以通过记忆体实现短期记忆进行连续数据的预测,但是当连续数据的序列变长时,会使时间展开步更长,在反向传播更新参数时,梯度要按时间步连续相乘,会导致梯度消失,所以出现了长短记忆网络。长短记忆网路引入了如下概念:

    • 输入门(门限):it = α(Wi[ht-1,xt] + bi)

    • 遗忘门(门限):ft = α(Wj[ht-1,xt] + bf)

    • 输出门(门限):ot = α(Wo[ht-1,xt] + bo)

    • 细胞态(长期记忆):Ct = ft * Ct-1 + it * C`t

    • 记忆体(短期记忆):ht = ot * tanh(Ct)

    • 候选态(归纳出的新知识):C`t = tanh(Wc[ht-1, xt] + bc)

    ​ 其中Wi,Wf,Wo,Wc都是待训练参数矩阵,bi,bf,bo,bc都是待训练偏置项,it,ft,ot都经过sigmoid激活函数使门限的范围在0到1之间

    ​ 细胞态表示长期记忆,等于上个时刻的长期记忆乘以遗忘门,加上当前时刻归纳出的新知识,乘以输入门,

    ​ 记忆体属于短期记忆,属于长期记忆的一部分,是细胞态过tanh函数乘以输出门的结果

    ​ 候选态表示归纳出的待存入细胞态的新知识,是当前时刻的输入特征xt和上个时刻的短期记忆ht-1的函数

    二:LSTM通俗理解

    ​ LSTM就是你上课听课的过程,你当前记住的内容是学期开始时到到你现在所学的长期记忆Ct,这个长期记忆Ct由两部分组成,一部分是学期开始到昨天你学的内容,也就是上一时刻的长期记忆Ct-1 ,你不可能记住全部内容,肯定会忘记一些,所以上个时刻的长期记忆Ct-1要乘以遗忘门,Ct-1*ft表示留存在你脑中的对过去的记忆。另一部分是你今天听到的知识,它是由今天你听到的知识xt和昨天短期记忆的留存ht-1组成,你的脑袋把当前时刻的输入xt和上一时刻的短期记忆ht-1,归纳形成即将存入你脑中的现在的记忆C`t,现在存储的记忆乘以输入门it与过去的记忆一同存储为长期记忆。

    ​ 当你把今天学习的内容讲给你室友时,你不可能一字不落的讲出来,你讲的是留在你脑中的长期记忆,经过输出门筛选后的内容,这就是记忆体的输出ht。即当有多层循环网络时,第二层循环网络的输入xt就是第一层网络的输出ht,输入第二层网络的是第一层网络提取出的精华,可以认为,你扮演的就是第一层网络,你将学到的精华输出给你的室友,你的室友作为第二层网络,接受到的数据是你的长期记忆经过tanh激活函数,乘以输出门提取出的短期记忆ht。这就是LSTM的计算过程

    三:Tensorflow描述LSTM层

    tf.keras.layers.LSTM(记忆体个数,return_sequences=是否返回输出)
    # return_sequences = True  各时间步输出ht
    # return_sequences = False  仅最后时间步输出ht(默认)
    # 一般最后一层用False,中间层用True
    

    四:LSTM实现股票预测

    from tensorflow.keras.layers import SimpleRNN, Dense, Dropout, LSTM
    from sklearn.preprocessing import MinMaxScaler
    import matplotlib.pyplot as plt
    import tensorflow as tf
    import pandas as pd
    import numpy as np
    import os
    
    # 读取股票文件
    maotai = pd.read_csv("SH600519.csv")
    
    #划分训练集和测试集,最后300天作为测试集
    traning_set = maotai.iloc[0:2642-300, 2:3].values
    test_set = maotai.iloc[2642-300:, 2:3].values
    
    # 归一化
    sc = MinMaxScaler(feature_range=(0, 1))  # 定义归一化:归一化到(0,1)之间
    traning_set_scaled = sc.fit_transform(traning_set)  # 求得训练集的最大值、最小值这些训练集固有的属性,并在训练集上进行归一化
    test_set = sc.transform(test_set)  # 利用训练集的属性对测试集进行归一化
    
    x_train = []
    y_train = []
    
    x_test = []
    y_test = []
    
    # 利用for循环,遍历整个训练集,提取训练集中连续60天的开盘价格作为输入特征x_train,第61天的特征作为y_train
    for i in range(60, len(traning_set_scaled)):
        x_train.append(traning_set_scaled[i-60:i, 0])
        y_train.append(traning_set_scaled[i, 0])
    
    # 乱序
    np.random.seed(7)
    np.random.shuffle(x_train)
    np.random.seed(7)
    np.random.shuffle(y_train)
    np.random.seed(7)
    
    # 训练集转换格式
    x_train = np.array(x_train)
    x_train = np.reshape(x_train, (x_train.shape[0], 60, 1))  # 使x_train符合RNN输入格式
    y_train = np.array(y_train)
    
    # 测试集格式转换
    # 利用for循环,遍历整个测试集,提取测试集中连续60天的数据作为输入特征x_test, 第61天的数据作为y_test
    for i in range(60, len(test_set)):
        x_test.append(test_set[i-60:i, 0])
        y_test.append(test_set[i, 0])
    
    # 转换格式
    x_test = np.array(x_test)
    x_test = np.reshape(x_test, (x_test.shape[0], 60, 1))
    y_test = np.array(y_test)
    
    # 搭建神经网络
    model = tf.keras.Sequential([
        LSTM(80, return_sequences=True),
        Dropout(0.2),
        LSTM(100),
        Dropout(0.2),
        Dense(1)
    ])
    
    # 参数配置
    # 该应用只观测loss数值,不观测准确率,所以删去metrics选项,一会在每个epoch迭代显示时只显示loss值
    model.compile(
        optimizer=tf.keras.optimizers.Adam(0.001),
        loss="mean_squared_error"  # 损失函数用均方误差
    )
    
    checkpoint_save_path = "./checkpoint/rnn_stock.ckpt"
    
    if os.path.exists(checkpoint_save_path + ".index"):
        print("------------load model-----------")
        model.load_weights(checkpoint_save_path)
    
    cp_callback = tf.keras.callbacks.ModelCheckpoint(
        filepath=checkpoint_save_path,
        save_best_only=True,
        save_weights_only=True,
        monitor="val_loss"
    )
    
    # 训练模型
    history = model.fit(x_train, y_train, batch_size=64, epochs=50, validation_data=(x_test, y_test), validation_freq=1, callbacks=[cp_callback])
    
    # 参看模型结构
    model.summary()
    
    # 保存模型参数到txt文本中
    with open("weights.txt", "w") as f:
        for v in model.trainable_variables:
            f.write(str(v.name) + "\n")
            f.write(str(v.shape) + "\n")
            f.write(str(v.numpy()) + "\n")
    
    loss = history.history["loss"]
    val_loss = history.history["val_loss"]
    
    # 绘图
    plt.plot(loss, label="Traing Loss")
    plt.plot(val_loss, label="Validition Loss")
    plt.title("Training And Validition Loss")
    plt.legend()
    plt.show()
    
    # 测试集输入模型进行预测
    predicted_stock_price = model.predict(x_test)
    # 对预测数据进行还原---从(0,1)反归一化到原始范围
    predicted_stock_price = sc.inverse_transform(predicted_stock_price)
    # 对真实数据进行还原---从(0,1)反归一化到原始范围
    real_stock_price = sc.inverse_transform(test_set[60:])
    # 画出真实数据和预测数据的对比曲线
    plt.plot(predicted_stock_price, color="red", label="Predicted Price")
    plt.plot(real_stock_price, color="blue", label="Real Price")
    plt.title("Price Prediction")
    plt.xlabel("Time")
    plt.ylabel("Price")
    plt.legend()
    plt.show()
    
    更多相关内容
  • 基于python3、tensorflow库的bilstm程序。双向长短记忆网络。python文件。
  • BiLSTM+CRF实现AI诗人与长短记忆网络 所用程序说明: main.py : 为主程序, 在命令行运行方式为:python main.py –-mode train 或 python main.py –-mode test或 python main.py –-mode head make...

    BiLSTM+CRF实现AI诗人与长短记忆网络


    所用程序说明:
    main.py: 为主程序, 在命令行运行方式为:python main.py –-mode train 或 python main.py –-mode test或 python main.py –-mode head
    makedata.py: 将三万首唐诗制作成若干批训练集。并将此诗集出现的所有汉字制成一个字典。
    header.py: 一些全局参数的定义。
    model.py: 构建模型。训练模型。测试模型。
    本实训旨在通过AI诗人神经网络让学员了解如何用Tensorflow构建反馈网络。完成本实训项目大约需要100分钟。
    实验目标:
    1、熟悉自然语言处理及文本读取。

    2、熟悉如何用向量表征语言。

    3、掌握如何用Tensorflow编写反馈网络。
    主要步骤:
    1、 将三万多首唐诗通过makedata.py输入到模型中
    2、 搭建训练模型
    3、 构建训练过程
    4、 编写写诗过程

    step1 makedata.py

    步骤一 将三万多首唐诗通过makedata.py输入到模型中。通过命令行一步一步熟悉如此处理文字文件和数据。
    具体的过程实现如下图所示:流程

    1-1、1-2将line字符串的前后空格删除,将它以’:'为分割标志,分成title和poem。

    poems = []
        file = open(filename, "r", encoding="gbk")
        for line in file:  # 每行储存一首诗
            # 将line开头及结尾处的空格删除,然后分成题目title与诗体peom
            title,poem=line.strip().split(':')
            ## strip()将line开头及结尾处的空格等其它非文字符号删除
            ## split是分割函数,将字符串分割成“字符”,保存在一个列表中
    

    1-3、1-4、1-5去除空格、其他字符,获取题目与诗的内容

     poem = poem.replace(' ','') #去除诗中的空格
            ## replace替换函数。
            if '_' in poem or '《' in poem or '[' in poem or '(' in poem or '(' in poem:
                continue
            ## 去除poem的其它字符
            if len(poem) < 10 or len(poem) > 128:
                continue
            ## 确保poem长度适当
            poem = '[' + poem + ']' #add start and end signs
            poems.append(poem)
            # 将poem加到列表 poems当中
    
    

    1-6 动作:将诗集中出现的汉字根据出现频次制作一个字典,储存于变量allWords之中。

    allWords = {}
        # 定义一个空的字典(dictionary)
        # key:为汉字
        # 字典的值value:为该汉字出现的频次
        # 代码仿照写处2
        for poem in poems: # 枚举诗歌列表中所有诗
            for word in poem: # 枚举每首诗中所有的字
    
                if word not in allWords:
                    allWords[word] = 1  # 假如该汉字还没出现过
                else:
                    allWords[word] += 1
        # 删除低频字
        erase = []
        for key in allWords: # 枚举字典allwords中的所有字key
            if allWords[key] < 2:  #假如其频次小于2,加入待删列表
                erase.append(key)
        for key in erase:
            del allWords[key]
    

    1-7 将每首诗转换成一个向量

    wordPairs = sorted(allWords.items(), key = lambda x: -x[1])
        # 所有出现的汉字按出现频次,由多到少排序。
        # 函数items,用于取出字典的key和值。
        # key = lamda表示按key的值进行排序,按x的第1维进行排序
        words, a= zip(*wordPairs)  # *wordpairs 将wordpairs解压(unzip)
                                   # zip()将输入变量变成turple
        words += (" ", )           # 将空格加在最后。
        wordToID = dict(zip(words, range(len(words)))) #word to ID
                                                       # 把每个汉字赋予一个数。
    
        wordTOIDFun = lambda A: wordToID.get(A, len(words))  # 转化成函数,
                                                            # 输入汉字,输出它对应的数。
        poemsVector = [([wordTOIDFun(word) for word in poem]) for poem in poems] # poem to vector
    
    
        ## 将所有的诗转化成向量,其中一首诗中,数字用turple储存,在外面用列表储存。
        ## 类似这样。[(1 3 2 4), (2 3 4 1), (1 5 6 2)]
    

    1-8制作训练样本

         batchNum  = (len(poemsVector) - 1) // batchSize  # // 除法将余数去掉,如10//3 = 3
        X = []
        Y = []
        #create batch
        for i in range(batchNum):
            batch = poemsVector[i * batchSize: (i + 1) * batchSize]
            # batch 储存了 batchsize诗的向量
    
            maxLength = max([len(vector) for vector in batch])
            # 得到一个batch其中一首最长的诗的长度
    
            temp = np.full((batchSize, maxLength), wordTOIDFun(" "), np.int32)
            #将temp初始化成batchsize * maxlength的矩阵,其中矩阵元素初始值皆为空格对应的IDfor j in range(batchSize):
                temp[j, :len(batch[j])] = batch[j]
            #将temp 储存了一批诗对应的矩阵
            # 代码粘贴处4
            X.append(temp)  # 把这个矩阵放入列表X中,
            temp2 = np.copy(temp)
            temp2[:, :-1] = temp[:, 1:]#将诗向前挪一个字的位置对应的向量放入Y中。
            Y.append(temp2)
            #提示:比如:输入X =“白日依山近…”,输出Y=“日依山近, …”。
            # 将字往向前移一个字。比如
            # temp = [(白日依山进),()]->temp2 [(日依山进进), ()]
            # X -> Y相当于只挪动一个字。
        return X, Y, len(words) + 1, wordToID, words
    
    

    step2 搭建训练模型 model.py

    下图为buildmodel函数的示意图。它的基本思路:先将一批样本gtX[16X122]矩阵(相当于整数表征)通过embedding_lookup,将其转成向量表征inputbatch;然后,搭建动态RNN,这个RNN基本单元basicCell是一个LSTM,由它堆两层形成stackCell,然后再动态形成RNN(其中 t = 1到122)

    在这里插入图片描述

    2-1将输入buildmodel的变量gtX(整数表征),通过内嵌表embedding,转变成向量表征变量inputbatch。

    
        with tf.variable_scope("embedding"): #embedding
               embedding = tf.get_variable("embedding", [wordNum, hidden_units], dtype = tf.float32)
               # embedding 为 n * m维的矩阵,其中n为涉及的汉字的数目,m为隐藏LSTM单元的数目
               # 将汉字用hidden_units维向量重新表征,训练RNN的其中一个目的就是为了找到embedding这个矩阵
               ## 代码仿写处 1
               #将输入buildmodel的变量gtX(整数表征),通过内嵌表embedding,转变成向量表征变量inputbatch。
               inputbatch = tf.nn.embedding_lookup(embedding, gtX)
               # 将16首诗转化为向量表达。
               # embedding_lookup(params, ids)其实就是按照ids顺序返回params中的第ids行。比如说,
               #ids=[1,3,2],就是返回params中第1,3,2行。返回结果为由params的1,3,2行组成的tensor。
               # gtx: batchsize * hidden_units, embedding (wordnum*hidden)
               # inputbatch: batchsize * maxLength * hidden
    

    1-2构建LSTM单元

    basicCell = tf.contrib.rnn.BasicLSTMCell(hidden_units, state_is_tuple = True)   
    
    

    2-3 动作:将LSTM单元垒起来。

    #将LSTM单元垒起来
    stackCell = tf.contrib.rnn.MultiRNNCell([basicCell] * layers)  
    

    2-4 动作:构建动态RNN

    #构建动态RNN。
    initState = stackCell.zero_state(np.shape(gtX)[0], tf.float32)
    outputs, finalState = tf.nn.dynamic_rnn(stackCell, inputbatch, initial_state = initState)
    outputs = tf.reshape(outputs, [-1, hidden_units])
      
    

    step3 定义训练过程

    计算成本函数。将一个样本gtX,gtY代入buildmodel函数计算出logits, probs之后,就可以计算其成本函数了

    loss = tf.contrib.legacy_seq2seq.sequence_loss_by_example([logits], [targets],
                              [tf.ones_like(targets, dtype=tf.float32)], wordNum)
    cost = tf.reduce_mean(loss) # 定义损耗函数
    

    计算梯度
    相关资料如下,有多种计算梯度的方法
    在这里插入图片描述

    选择优化方法
    optimizer = tf.train.AdamOptimizer(learningRate)
    构建训练器
    trainOP = optimizer.apply_gradients(zip(grads, tvars))

    step4、编写写诗过程

    (只实训head这个过程。)比如输入"白黄",它返回"白日依山近,黄河入海流。"
    理解probtoword函数。训练好的Model最终输入下一个字出现的概率(它依赖于前面几个字的输入)。它储存在一个5667维的数组,即这5667汉字的出现的概率分别是多少。当然可取概率最大的那个,但这将导致每次都出现同一个词。因此,需要将概率较大的几个当中随机选择一个,但同时使得概率原来越大的被选中的概率也越大。
    完成probtoword函数。输入一个概率分布weights(5667个小于1的数字),在概率较大的几个中随机选择一个输出汉字。为了达到这个目的,先用cumsum(累加)函数将分布变成累积分布函数,这样只要取0到1的一个随机数,那么可以证明它落入初始概率大的那个格子的概率正比于原来分布中的概率,如下图所示。
    完成testhead函数。请仔细阅读testhead函数。它先导入训练好的网络参数,然后构建初始状态。一个个字往后预测出后面的字出现的概率,并概率转变成汉字
    打开文件main.py,修改第33行(也可不改),尝试输入不同的四个或多个汉字(每句诗的诗头),然后 在命令行输入。(比如"白黄欲更")看看AI能创造出什么诗来

    具体代码见https://github.com/Arfer-ustc/AI_Poem_BiLstm_CRF.git

    展开全文
  • 论文阅读 使用空间LSTMs(长短记忆网络)的生成图像建模 Generative Image Modeling Using Spatial LSTMs 论文 简述 模型 基础知识 问题 LSTMs解释1 LSTMs解释2

    LSTMs (长短期记忆网络)是RNN的特殊类型,可以学习远期依赖信息。

    远期依赖信息就是当前信息跟数百个或更多之前的输入有关,远期记忆有不可忽视的影响。
    请添加图片描述
    RNN结构


    请添加图片描述
    LSTM结构


    请添加图片描述
    在这里插入图片描述
    细胞状态就是记忆。乘法是损失一部分记忆,加法是当前状态对记忆做出的改变。


    在这里插入图片描述
    黄色的这个就是门。

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

    引用
    LSTMs解释1
    LSTMs解释2
    RNN循环神经网络到LSTM

    论文阅读
    使用空间LSTMs(长短期记忆网络)的生成图像建模
    Generative Image Modeling Using Spatial LSTMs
    在这里插入图片描述

    论文

    简述

    RNN可以成功的解决远依赖问题,但它直到最近才找到方法对图像生成进行建模。之前的模型在对自然图像分布进行建模时有困难,部分是因为统计依赖性可以扩展到数百个像素。作者提出的模型处理任意大小的图像,在计算上都是易于处理的。

    模型

    多维循环神经网络与专家组合相结合,模型主体是LSTM。
    在这里插入图片描述
    A图,x(ij)的预测可能却决于x(<ij)的任何像素。
    B图,MCGSM(mixtures of conditional Gaussian scale mixtures)的因果邻域仅限一个小区域。
    C图,第一层SLSTM(spatial LSTM),一个像素的预测取决于相邻的绿色部分像素。第二层SLSTM扩展了这一范围,红色部分像素也参与了预测。
    通过将图像视为平稳随机过程的实例,该模型允许我们采样和捕获任意大图像的相关性。(LSTM是一个链状的结构,与空间LSTM相区分)

    基础知识

    1.多模态数据:模态是信息的来源或形式,比如视觉,文字,加速度计。多模态数据就是有不同的来源和形式的数据。
    2.一维LSTM在文本、演讲上的建模比较成功。
    3.多维LSTM由于它们的空间结构和捕获远期相关性的能力,很适合对生成图像建模。

    问题

    MCGAM是什么?这数学推导部分给人看麻了。

    展开全文
  • 长短记忆网络(Long Short Term Memory Network, LSTM),它有效地解决了原始循环神经网络(RNN)的缺陷,在语音识别、图片描述、自然语言处理等许多领域中成功应用。本文讲解由三个Gate(input、forget、output)和一...
  • 长短记忆网络LSTM(MATLAB),解决分类或回归问题有例子,易上手,只要换数据就行,保证正常运行。 ID:6918668740821442

    长短记忆网络LSTM(MATLAB),解决分类或回归问题有例子,易上手,只要换数据就行,保证正常运行。
    请添加图片描述

    ID:6918668740821442

    展开全文
  • 长短记忆网络(LSTM)

    2021-07-07 06:56:10
    长短记忆网络 循环神经网络很难训练的原因导致它的实际应用中很处理长距离的依赖。本文将介绍改进后的循环神经网络:长短记忆网络(LongShortTermMemoryNetwork,LSTM),   原始RNN的隐藏层只有一个...
  • LSTM-长短记忆网络

    2021-09-07 16:51:17
    选择性保留或丢弃上一层信息
  • 长短记忆网络(Long Short Term Memory (LSTM)) LSTM 模型 LSTM模型是RNN 模型的改进,可以避免梯度消失的问题,有更长的记忆。 LSTM也是一种循环神经网络,每当读取一个输入x就会更新状态h。LSTM的结构比简单RNN...
  • 长短记忆网络LSTM

    2021-08-11 11:18:32
    循环神经网络RNN在训练的过程中会有长期依赖的问题,这是由于RNN模型在训练时会遇到梯度消失(大部分情况)或者梯度爆炸(很少,但对优化过程影响很大)的问题。对于梯度爆炸是很好解决的,可以使用梯度修剪(Gradient ...
  • #定义RNN网络 def RNN ( X , weights , biases ) #input的需要,需要调整成三维的 inputs = tf . reshape ( X , [ - 1 , max_time , n_inputs ] ) #定义LSTM lstm_cell = tf . nn . rnn_cell . ...
  • 资源,提出了一种针对区域级负荷的深度长短记忆网络超 短期预测方法,该方法包括输入数据的预处理、深度长短时 记忆(long short-term memory,LSTM)网络的构建以及模型 的训练和超参数的寻找等步骤。其中采用随机...
  • 长短记忆神经网络(LSTM)

    万次阅读 多人点赞 2020-09-24 20:27:36
    下面为翻译文章,会稍有增删: ...循环神经网络 人类不会每秒都从头开始思考。 阅读本文时,您会根据对先前单词的理解来理解每个单词。 您不会丢掉一切,重新从头开始思考。 传统的神经网络无法做到这一
  • 长短记忆网络--代码实现

    千次阅读 2017-12-28 15:12:55
    import matplotlib.pyplot as plt import numpy as npclass IdentityActivator(object): def forward(self, weighted_input): return weighted_input def backward(self, output): return 1 ...
  • 理解RNNs —— 长短记忆网络(LSTMS)

    千次阅读 2017-04-06 18:37:55
    递归神经网络 人类并不是每时每刻都从头开始思考。正如你阅读这篇文章的时候,你是在理解前面词语的基础上来理解每个词。你不会丢弃所有已知的信息而从头开始思考。你的思想具有持续性。 传统的神经网络不能做到这...
  • 长短记忆网络.zip

    2021-03-09 14:51:25
    长短记忆网络
  • 深度学习之循环神经网络(8)长短记忆网络(LSTM)0. LSTM原理1. 遗忘门2. 输入门3. 刷新Memory4. 输出门5. 小结  循环神经网络除了训练困难,还有一个更严重的问题,那就是短时记忆(Short-term memory)。考虑...
  • 主要介绍了循环神经网络RNN和长短记忆网络LSTM,并对其中的原理和网络结构进行了详细的推导和解释。
  • 双向长短记忆循环神经网络

    千次阅读 2019-05-27 21:02:16
    与其说长短记忆是一种循环神经网络,倒不如说是一个加强版的组件被放在了循环神经网络中。 LSTM单元能够很好的解决跨时间记忆以及梯度消失的问题。LSTM结构的形式化定义如下: LSTM时刻j的状态由两...
  • 长短记忆网络,,深度学习,,SHENDUXUEXI
  • 本实验使用环境为Anaconda3 Jupyter,调用Sklearn包、Keras包,请提前准备好。只提供数据格式而不提供数据,本人是代码缝合怪小白,望大牛指点。 1.导包 主要包含pandas、numpy、绘图包、日期格式、数学计算、pyhht ...
  • 擅长智能优化算法、神经网络预测、信号处理、元胞自动机、图像处理、路径规划、无人机等多种领域的Matlab仿真。
  • 基于卷积神经网络与双向长短记忆网络组合模型的短时交通流预测.pdf
  • :针对热力站为多变量、非线性...以包头某热力站大量实时工况 数据通过 tensorflow 框架搭建神经网络模型,仿真对比结果表明,长短记忆网络建模能有 效的减小建模误差,进一步提高神经网络在热力站系统建模中的精度。
  • 基于长短记忆神经网络的短期光伏发电预测技术研究.pdf
  • 长短记忆神经网络在流行性感冒暴发预测中的应用.pdf
  • 联合卷积与长短记忆神经网络的桥梁结构损伤识别研究.pdf
  • 长短记忆神经网路简介
  • 基于遗传算法优化卷积长短记忆混合神经网络模型的光伏发电功率预测.pdf
  • 在本文中,我们将介绍一种改进之后的循环神经网络:长短记忆网络(Long Short Term Memory Network, LSTM),它成功的解决了原始循环神经网络的缺陷,成为当前最流行的RNN,在语音识别、图片描述、自然语言处理等...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 8,132
精华内容 3,252
关键字:

长短记忆网络

友情链接: USB-firmware-.rar