精华内容
下载资源
问答
  • RNN(反馈神经网络)之LSTM学习记录新的改变功能快捷键合理的创建标题,有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右...

    RNN(反馈神经网络)之LSTM学习记录


    RNN反馈神经网络也称循环神经网络,每个时刻网络的输出都可以在下一时刻直接作用到自身,及当前时刻网络的最终结果是该时刻的输入信息与所有历史信息的共同作用的结果,因此RNN可以处理时间序列的信息。但随着网络的增加,神经元个数的不断增加,RNN在实际训练时常常出现梯度消失和梯度爆炸的问题,导致网络最终无法正常训练。于是出现了LSTM(Long Short-Term Memory)长短时序记忆,通过门控制和更新细胞状态将短期记忆与长期记忆结合起来,解决了神经网络中长期依赖问题,让网络能够默认记忆长期信息。
    在这里插入图片描述
    LSTM神经元包含输入门i、遗忘门f、细胞状态C、输出门O,通过门和细胞状态来控制长短期记忆。其计算过程可以表示表示为公式(1)到(6)其中ht-1为t-1时刻的隐藏层输出,Ct-1为t-1时刻的细胞状态,xt为t时刻的输入信息,w为权值,b为偏置值,σ和tanh为激活函数。公式(1)中,输入门t时刻的信息it为上一时刻ht-1和t时刻的输入信息xt的结合,公式(2)通过ht-1和xt计算得到t时刻的候选细胞状态C~\tilde{C}t。公式(3)为遗忘门,用于计算前一时刻的信息保留比例,公式(4)结合输入门和遗忘门来更新t时刻的细胞状态Ct,,公式(5)和公式(6)计算输出t时刻的隐藏层信息ht。LSTM网络通过不断更新每个时刻的细胞状态,结合门控制达到记忆时序数据长短期信息的目的。

    在这里插入图片描述

    展开全文
  • 这篇记一下时间序列分解和长短记忆神经网络lstm如何一起用 vmd+lstm 用python实现 首先预设的流程是: 读取数据、vmd时间分解(把信号分解成5行),最大最小归一化、给模型设置参数、编译、fit函数(训练)、反归一...

    这篇记一下时间序列分解和长短记忆神经网络lstm如何一起用
    vmd+lstm
    用python实现

    首先预设的流程是:

    读取数据、vmd时间分解(把信号分解成5行),最大最小归一化、给模型设置参数、编译、fit函数(训练)、反归一化、得到的五个信号相加、保存模型、绘图、保存数据

    首先vmd返回值是u,u_hat,omega。

        '''
        u       - the collection of decomposed modes 分解模态的集合
        u_hat   - spectra of the modes 模态的谱
        omega   - estimated mode center-frequencies 估计模态中心频率
        '''
    
        u = np.zeros((K, len(t)))
        u_hat = np.zeros((T//2, K), dtype=complex)
        omega = omega_plus[0:N, :]
        return u, u_hat, omega
    

    截止目前,不太明白
    np.zeros((K,len(t)))产生K行,len(t)列的数组

        T = len(f)
        t = [(i + 1) / T for i in range(T)]  # 列表从1开始
    

    最终t=[1/T,2/T,···,1]
    t的长度和T的长度一样


    vmd分解是把一个数据分成几个模态,每个模态分别构建一个lstm模型预测,再相加。

    展开全文
  • # 构建计算——LSTM模型 # embedding # LSTM # fc # train_op # 训练流程代码 # 数据集封装 # api: next_batch(batch_size) # 词表封装: # api: sentence2id(text_sentence): 句子转换id # 类别的封装: # api: ...

    本文目录

    1.实现代码

    # 构建计算图——LSTM模型
    #    embedding
    #    LSTM
    #    fc
    #    train_op
    # 训练流程代码
    # 数据集封装
    #    api: next_batch(batch_size)
    # 词表封装:
    #    api: sentence2id(text_sentence): 句子转换id
    # 类别的封装:
    #    api: category2id(text_category).
    
    import tensorflow as tf
    import os
    import sys
    import numpy as np
    import math
    
    tf.logging.set_verbosity(tf.logging.INFO)
    print("ok1")
    
    # 定义数据超参数
    def get_default_params():
        return tf.contrib.training.HParams(
            num_embedding_size = 16,  # 词的embedding长度
            num_timesteps = 50,   # lstm步长,一个句子词的个数
            num_lstm_nodes = [32, 32],
            num_lstm_layers = 2,
            num_fc_nodes = 32,
            batch_size = 100,
            clip_lstm_grads = 1.0,   # 梯度上限
            learning_rate = 0.001,
            num_word_threshold = 10,   # 词频阈值
        )
    hps = get_default_params()
    
    train_file = 'F:/channelE/lstm/text_classification_data/cnews.train.seg.txt'
    val_file = 'F:/channelE/lstm/text_classification_data/cnews.val.seg.txt'
    test_file = 'F:/channelE/lstm/text_classification_data/cnews.test.seg.txt'
    vocab_file = 'F:/channelE/lstm/text_classification_data/cnews.vocab.txt'
    category_file = 'F:/channelE/lstm/text_classification_data/cnews.category.txt'
    output_folder = 'F:/channelE/lstm/run_text_rnn'
    if not os.path.exists(output_folder):
        os.mkdir(output_folder)
    print("ok2")
    
    # 词表封装类
    class Vocab:
        def __init__(self, filename, num_word_threshold):
            self._word_to_id = {}
            self._unk = -1
            self._num_word_threshold = num_word_threshold
            self._read_dict(filename)
    
        def _read_dict(self, filename):
            with open(filename, 'r', encoding='utf-8') as f:
                lines = f.readlines()
            for line in lines:
                word, frequency = line.strip('\r\n').split('\t')
                #             word = word.decode('utf-8')
                frequency = int(frequency)
                if frequency < self._num_word_threshold:
                    continue
                idx = len(self._word_to_id)
                if word == '<UNK>':
                    self._unk = idx
                self._word_to_id[word] = idx
    
        def word_to_id(self, word):
            return self._word_to_id.get(word, self._unk)
    
        @property
        def unk(self):
            return self._unk
    
        def size(self):
            return len(self._word_to_id)
    
        def sentence_to_id(self, sentence):
            word_ids = [self.word_to_id(cur_word) \
                        for cur_word in sentence.split()]
            return word_ids
    
    # 类别封装
    class CategoryDict:
        def __init__(self, filename):
            self._category_to_id = {}
            with open(filename, 'r') as f:
                lines = f.readlines()
            for line in lines:
                category = line.strip('\r\n')
                idx = len(self._category_to_id)
                self._category_to_id[category] = idx
    
        def size(self):
            return len(self._category_to_id)
    
        def category_to_id(self, category):
            if not category in self._category_to_id:
                pass
                # raise Execption(
                #     "%s is not in our category list" % category_name)
            return self._category_to_id[category]
    
    vocab = Vocab(vocab_file, hps.num_word_threshold)
    vocab_size = vocab.size()
    tf.logging.info('vocab_size: %d' % vocab_size)
    print("vocab_size:",vocab_size)   # vocab_size: 77323
    
    category_vocab = CategoryDict(category_file)
    num_classes = category_vocab.size()
    tf.logging.info('num_classes: %d' % num_classes)
    test_str = '时尚'
    tf.logging.info(
        'label: %s, id: %d' % (
            test_str,
            category_vocab.category_to_id(test_str)))
    print("label: %s, id: %d", (test_str,category_vocab.category_to_id(test_str)))
    print("ok3")
    
    # 数据集封装
    class TextDataSet:
        def __init__(self, filename, vocab, category_vocab, num_timesteps):
            self._vocab = vocab
            self._category_vocab = category_vocab
            self._num_timesteps = num_timesteps
            # matrix
            self._inputs = []
            # vector
            self._outputs = []
            self._indicator = 0
            self._parse_file(filename)
    
        def _parse_file(self, filename):
            '''
            解析文件
            :param filename:
            :return:
            '''
            tf.logging.info('Loading data from %s', filename)
            with open(filename, 'r', encoding='utf-8') as f:
                lines = f.readlines()
            for line in lines:
                label, content = line.strip('\r\n').split('\t')
                id_label = self._category_vocab.category_to_id(label)
                id_words = self._vocab.sentence_to_id(content)
                id_words = id_words[0: self._num_timesteps]
                padding_num = self._num_timesteps - len(id_words)
                id_words = id_words + [
                    self._vocab.unk for i in range(padding_num)]
                self._inputs.append(id_words)
                self._outputs.append(id_label)
            self._inputs = np.asarray(self._inputs, dtype=np.int32)
            self._outputs = np.asarray(self._outputs, dtype=np.int32)
            self._random_shuffle()
    
        def _random_shuffle(self):
            p = np.random.permutation(len(self._inputs))
            self._inputs = self._inputs[p]
            self._outputs = self._outputs[p]
    
        def next_batch(self, batch_size):
            end_indicator = self._indicator + batch_size
            if end_indicator > len(self._inputs):
                self._random_shuffle()
                self._indicator = 0
                end_indicator = batch_size
            if end_indicator > len(self._inputs):
                raise Execption("batch_size: %d is too large" % batch_size)
    
            batch_inputs = self._inputs[self._indicator: end_indicator]
            batch_outputs = self._outputs[self._indicator: end_indicator]
            self._indicator = end_indicator
            return batch_inputs, batch_outputs
    
    train_dataset = TextDataSet(
        train_file, vocab, category_vocab, hps.num_timesteps)
    val_dataset = TextDataSet(
        val_file, vocab, category_vocab, hps.num_timesteps)
    test_dataset = TextDataSet(
        test_file, vocab, category_vocab, hps.num_timesteps)
    
    print("train_dataset.__sizeof__()",train_dataset)
    print("val_dataset.__sizeof__()",val_dataset.__sizeof__())
    print("test_dataset.__sizeof__",test_dataset.__sizeof__())
    
    print(train_dataset.next_batch(2))
    print(val_dataset.next_batch(2))
    print(test_dataset.next_batch(2))
    print("ok4")
    
    # 分类模型
    def create_model(hps, vocab_size, num_classes):
        num_timesteps = hps.num_timesteps
        batch_size = hps.batch_size
    
        inputs = tf.placeholder(tf.int32, (batch_size, num_timesteps))
        outputs = tf.placeholder(tf.int32, (batch_size,))
        keep_prob = tf.placeholder(tf.float32, name='keep_prob')
    
        global_step = tf.Variable(
            tf.zeros([], tf.int64), name='global_step', trainable=False)
    
        embedding_initializer = tf.random_uniform_initializer(-1.0, 1.0)
        with tf.variable_scope(
                'embedding', initializer=embedding_initializer):
            embeddings = tf.get_variable(
                'embedding',
                [vocab_size, hps.num_embedding_size],
                tf.float32)
            # [1, 10, 7] -> [embeddings[1], embeddings[10], embeddings[7]]
            embed_inputs = tf.nn.embedding_lookup(embeddings, inputs)
    
        # LSTM
        scale = 1.0 / math.sqrt(hps.num_embedding_size + hps.num_lstm_nodes[-1]) / 3.0
        lstm_init = tf.random_uniform_initializer(-scale, scale)
    
        def _generate_params_for_lstm_cell(x_size, h_size, bias_size):
            """generates parameters for pure lstm implementation."""
            x_w = tf.get_variable('x_weights', x_size)
            h_w = tf.get_variable('h_weights', h_size)
            b = tf.get_variable('biases', bias_size,
                                initializer=tf.constant_initializer(0.0))
            return x_w, h_w, b
    
        with tf.variable_scope('lstm_nn', initializer=lstm_init):
            """
            cells = []
            for i in range(hps.num_lstm_layers):
                cell = tf.contrib.rnn.BasicLSTMCell(
                    hps.num_lstm_nodes[i],
                    state_is_tuple = True)
                cell = tf.contrib.rnn.DropoutWrapper(
                    cell,
                    output_keep_prob = keep_prob)
                cells.append(cell)
            cell = tf.contrib.rnn.MultiRNNCell(cells)
    
            initial_state = cell.zero_state(batch_size, tf.float32)
            # rnn_outputs: [batch_size, num_timesteps, lstm_outputs[-1]]
            rnn_outputs, _ = tf.nn.dynamic_rnn(
                cell, embed_inputs, initial_state = initial_state)
            last = rnn_outputs[:, -1, :]
            """
            with tf.variable_scope('inputs'):
                ix, ih, ib = _generate_params_for_lstm_cell(
                    x_size=[hps.num_embedding_size, hps.num_lstm_nodes[0]],
                    h_size=[hps.num_lstm_nodes[0], hps.num_lstm_nodes[0]],
                    bias_size=[1, hps.num_lstm_nodes[0]]
                )
            with tf.variable_scope('outputs'):
                ox, oh, ob = _generate_params_for_lstm_cell(
                    x_size=[hps.num_embedding_size, hps.num_lstm_nodes[0]],
                    h_size=[hps.num_lstm_nodes[0], hps.num_lstm_nodes[0]],
                    bias_size=[1, hps.num_lstm_nodes[0]]
                )
            with tf.variable_scope('forget'):
                fx, fh, fb = _generate_params_for_lstm_cell(
                    x_size=[hps.num_embedding_size, hps.num_lstm_nodes[0]],
                    h_size=[hps.num_lstm_nodes[0], hps.num_lstm_nodes[0]],
                    bias_size=[1, hps.num_lstm_nodes[0]]
                )
            with tf.variable_scope('memory'):
                cx, ch, cb = _generate_params_for_lstm_cell(
                    x_size=[hps.num_embedding_size, hps.num_lstm_nodes[0]],
                    h_size=[hps.num_lstm_nodes[0], hps.num_lstm_nodes[0]],
                    bias_size=[1, hps.num_lstm_nodes[0]]
                )
            state = tf.Variable(
                tf.zeros([batch_size, hps.num_lstm_nodes[0]]),
                trainable=False
            )
            h = tf.Variable(
                tf.zeros([batch_size, hps.num_lstm_nodes[0]]),
                trainable=False
            )
    
            for i in range(num_timesteps):
                # [batch_size, 1, embed_size]
                embed_input = embed_inputs[:, i, :]
                embed_input = tf.reshape(embed_input,
                                         [batch_size, hps.num_embedding_size])
                forget_gate = tf.sigmoid(
                    tf.matmul(embed_input, fx) + tf.matmul(h, fh) + fb)
                input_gate = tf.sigmoid(
                    tf.matmul(embed_input, ix) + tf.matmul(h, ih) + ib)
                output_gate = tf.sigmoid(
                    tf.matmul(embed_input, ox) + tf.matmul(h, oh) + ob)
                mid_state = tf.tanh(
                    tf.matmul(embed_input, cx) + tf.matmul(h, ch) + cb)
                state = mid_state * input_gate + state * forget_gate
                h = output_gate * tf.tanh(state)
            last = h
    
    
    
    
    
    
        fc_init = tf.uniform_unit_scaling_initializer(factor=1.0)
        with tf.variable_scope('fc', initializer=fc_init):
            fc1 = tf.layers.dense(last,
                                  hps.num_fc_nodes,
                                  activation=tf.nn.relu,
                                  name='fc1')
            fc1_dropout = tf.contrib.layers.dropout(fc1, keep_prob)
            logits = tf.layers.dense(fc1_dropout,
                                     num_classes,
                                     name='fc2')
    
        with tf.name_scope('metrics'):
            softmax_loss = tf.nn.sparse_softmax_cross_entropy_with_logits(
                logits=logits, labels=outputs)
            loss = tf.reduce_mean(softmax_loss)
            # [0, 1, 5, 4, 2] -> argmax: 2
            y_pred = tf.argmax(tf.nn.softmax(logits),
                               1,
                               output_type=tf.int32)
            correct_pred = tf.equal(outputs, y_pred)
            accuracy = tf.reduce_mean(tf.cast(correct_pred, tf.float32))
    
        with tf.name_scope('train_op'):
            tvars = tf.trainable_variables()
            for var in tvars:
                tf.logging.info('variable name: %s' % (var.name))
            grads, _ = tf.clip_by_global_norm(
                tf.gradients(loss, tvars), hps.clip_lstm_grads)   # 限制梯度,防止梯度爆炸
            optimizer = tf.train.AdamOptimizer(hps.learning_rate)
            train_op = optimizer.apply_gradients(
                zip(grads, tvars), global_step=global_step)
    
        return ((inputs, outputs, keep_prob),
                (loss, accuracy),
                (train_op, global_step))
    
    
    placeholders, metrics, others = create_model(
        hps, vocab_size, num_classes)
    
    inputs, outputs, keep_prob = placeholders
    loss, accuracy = metrics
    train_op, global_step = others
    print("ok5")
    
    
    
    
    init_op = tf.global_variables_initializer()
    train_keep_prob_value = 0.8
    test_keep_prob_value = 1.0
    
    num_train_steps = 10000
    
    # Train: 99.7%
    # Valid: 92.7%
    # Test:  93.2%
    with tf.Session() as sess:
        sess.run(init_op)
        for i in range(num_train_steps):
            batch_inputs, batch_labels = train_dataset.next_batch(
                hps.batch_size)
            outputs_val = sess.run([loss, accuracy, train_op, global_step],
                                   feed_dict = {
                                       inputs: batch_inputs,
                                       outputs: batch_labels,
                                       keep_prob: train_keep_prob_value,
                                   })
            loss_val, accuracy_val, _, global_step_val = outputs_val
            if global_step_val % 20 == 0:
                tf.logging.info("Step: %5d, loss: %3.3f, accuracy: %3.3f"
                                % (global_step_val, loss_val, accuracy_val))
    
    
    展开全文
  • 因为LSTM和RNN这里确实要比其他神经网络复杂一些,于是就手写了一个LSTM和RNN的前向传播,了解其内部的运行逻辑。RNN的前向传播代码网上有现成的,而且也比较简单,这里只贴出来自己写的LSTM代码。 LSTM前向传播 ...

    前言

    学习到LSTM这里,着实花费了不少力气,查阅过各种文章,进行过各种冥想,最终收获也是很大,学到了不少好东西。
    因为LSTM和RNN这里确实要比其他神经网络复杂一些,于是就手写了一个LSTM和RNN的前向传播,了解其内部的运行逻辑。RNN的前向传播代码网上有现成的,而且也比较简单,这里只贴出来自己写的LSTM代码。

    LSTM前向传播

    俗话说:开局一张图,内容全靠编。
    lstm结构图
    简单的先阐述一下流程:

    1. 先计算出来三个门,都是sigmoid函数
    2. 不要忘了还有个tanh这一项,就是个np.tanh()
    3. 然后可以对隐状态(c_state)进行计算,需要计算四次,先乘,再加,再tanh,再乘
    4. 收集每一次的输出 h

    代码如下:

    # -*- coding:utf-8 -*-
    # 手动编写一个lstm 前向传播
    
    import numpy as np
    
    timesteps = 10
    input_features = 16
    output_features = 32
    
    inputs = np.random.random((timesteps, input_features)) # (10, 32)
    
    c_state = np.zeros(shape=(output_features,)) # init state c
    h_state = c_state # 初始化 都等于 0
    
    def generate_parames_for_lstm_cell(x_size, h_size, bias_size):
        '''
        随机生成单元内部参数
        :param x_size: 输入数据 参数
        :param h_size: 上一层输出数据 参数
        :param bias_size: 偏置
        :return:
        '''
        w = np.random.random(x_size)
        u = np.random.random(h_size)
        b = np.random.random(bias_size)
        return w, u, b
    
    def sigmoid(x):
        # 定义 sigmoid函数
        s=1.0/(1.0+np.exp(-x))
        return s
    # 遗忘门参数
    forget_gate_w, forget_gate_u, forget_gate_b = \
        generate_parames_for_lstm_cell((input_features, output_features),
                                       (output_features, output_features),
                                       (1, output_features)
                                       )
    # 输入门参数
    input_gate_w, input_gate_u, input_gate_b = \
        generate_parames_for_lstm_cell((input_features, output_features),
                                       (output_features, output_features),
                                       (1, output_features)
                                       )
    # 输出门参数
    output_gate_w, output_gate_u, output_gate_b = \
        generate_parames_for_lstm_cell((input_features, output_features),
                                       (output_features, output_features),
                                       (1, output_features)
                                       )
    # tanh层参数
    tanh_w, tanh_u, tanh_b = \
        generate_parames_for_lstm_cell((input_features, output_features),
                                       (output_features, output_features),
                                       (1, output_features)
                                       )
    
    h_list = []
    for i in range(timesteps):
    
        # 遗忘门
        forget_gate = sigmoid(np.dot(h_state, forget_gate_u) + np.dot(inputs[i], forget_gate_w) + forget_gate_b)
        # 输入门
        input_gate = sigmoid(np.dot(h_state, input_gate_u) + np.dot(inputs[i], input_gate_w) + input_gate_b)
        # 输出门
        output_gate = sigmoid(np.dot(h_state, output_gate_u) + np.dot(inputs[i], output_gate_w) + output_gate_b)
        # tanh
        tanh_gate = np.tanh(np.dot(h_state, tanh_u) + np.dot(inputs[i], tanh_w) + tanh_b)
    
        c_state = c_state * forget_gate + input_gate * tanh_gate # shape (1, 64)
    
        h_state = np.tanh(c_state) * output_gate # (1, 64)
    
        h_list.append(h_state)
    
    h_list = np.vstack(h_list)
    
    
    print('最后一个cell的输出:')
    print(h_state)
    
    print('每一层cell的输出:')
    print(h_list)
    
    
    展开全文
  • GNN图神经网络详述-02

    千次阅读 2020-05-27 06:25:19
    本文作为第2部分,主要...这篇论文是第一个提出Graph Neural Network模型的论文,它将神经网络使用在结构数据上,并细述了神经网络模型了结构组成、计算方法、优化算法、流程实现等等。论文后面还对模型的复杂度进行
  • keras构造神经网络,非常之方便!以后就它了。本文给出了三个例子,都是普通的神经...keras对于神经网络给出的流程图,非常容易理解。 图片来源:https://www.jianshu.com/p/6c08f4ceab4c 【重点】训练神经网络围...
  • 使用LSTM生成文本

    千次阅读 2019-04-17 11:38:48
    使用LSTM生成文本概述如何生成序列数据生成文本的采样策略文本序列生成程序流程准备并解析初始文本将字符序列向量化构建神经网络模型训练语言模型并采样用模型生成文本 概述 我们的感知模式、语言和艺术作品都具有...
  • 这是我看完很多博客和视频以后对LSTM和Attention Model的一个理解和总结,有一些公式的地方感觉在数学上不能严格的推导出来,就直接贴了流程图。自己能推导出来的,我用白话文字解释了公式的意思,尽量避免用一些难...
  • 小样本图像分类

    2021-03-30 09:56:06
    小样本图像分类流程 数据集处理 让模型适应数据, 针对数据的特点进行建模 ...循环神经网络RNN 解决了短期记忆的问题 长短期记忆网络LSTM 解决了短期记忆和长期依赖的问题 应用 直接利用LSTM对图像进行编码
  • 五:循环神经网络的计算 六:序列模型解决的问题 七:BPTT(随时间反向传播)—重点 1)前向传播 2)反向传播 八:双向循环神经网络 九:长期依赖的挑战 十:LSTM 十一:GRU ...
  • Matlab-Deep Learning Toolbox

    2019-04-08 21:32:13
    您可以使用卷积神经网络(ConvNets,CNN)和长期短期记忆(LSTM)网络对图像,时间序列和文本数据进行分类和回归。应用程序和图表可帮助您可视化激活,编辑网络体系结构以及监控培训进度。 对于小型训练集,您可以...
  • Deep-Image-Captioning-源码

    2021-04-08 03:06:17
    改变其特征表示中的任何输入(即数字矢量)的神经网络是编码器。 例如,我们要使用图像来预测单词。 由于图像无法直接分辨出该单词应该是什么,因此我们想使用其功能来帮助我们确定下一个单词。 因此,用于更改
  • 3-7神经网络案例-训练神经网络完成分类任务 13:26 下篇章节 1深度学习入门课程01 感受卷积神经网络的强大 14:55 2深度学习入门课程02 卷积层详解 12:53 3深度学习入门课程03 卷积计算流程 12:30 4深度学习入门课程...
  • Kovalchuk和MM Gaber撰写的文章“基于图形的方法解释过程挖掘中的递归神经网络”的补充材料。 此存储库中提供的代码可用于执行以下任务: •预测要在流程实例中执行的下一个活动。 •预测流程实例的继续(即其后缀...
  • 提示:文章写完后,目录可以自动生成,如何生成可参考右边的帮助文档 生成式深度学习前言一、使用LSTM 生成文本1.生成式网络的历史2....变分自编码器五、生成式对抗网络简介1.GAN 的简要实现流程2.大量技
  • 关键词: session, LSTM聚合(GGNN), 最后一个表session, local和全局 (整体流程可以抄, 更换内部组件. 就像: Global Context Enhanced Graph Neural ... 之前用RNN建模, 现在用GGNN(门控图神经网络) 贡献: ..
  • 对于前者,卷积神经网络(CNN)与各种体系结构一起使用,可以训练可以准确分类单词的模型。对于后者,使用长短期记忆网络(LSTM)进行卷积以构造每个字符的边界框。然后将分割后的字符传递到CNN进行分类,然后根据...

空空如也

空空如也

1 2 3 4
收藏数 61
精华内容 24
关键字:

lstm神经网络流程图