深度学习手记（八）之PTB实现LSTM模型

PTB（Penn Treebank Dataset）文本数据集是语言模型学习中目前最广泛使用的数据集。下面将使用它构建一个长短期记忆网络（LSTM）。本文中只讲相应的代码实现，而关于LSTM的理论可以阅读这篇文章——Understanding LSTM Networks。
下面是本次构建LSTM的示意图，从图中可知，输入的词向量维度为（20，35，650），这分别代表的是批次数（batch_size）、步长数（num_steps）、隐藏层数（hidden_size）。通过两层LSTM之后扁平化，再由softmax计算出词向量预测单词的概率，比较这些概率，最终得到预测的单词。

整个模型框架分为四部分：模型输入数据预处理、模型网络构建以及训练测试部分。

1.数据预处理（utils.py）

import argparse
import os
import sys
import datetime
import collections
import tensorflow as tf
import numpy as np
"""
此例子中用到的数据是从 Tomas Mikolov 的网站取得的 PTB 数据集
PTB 文本数据集是语言模型学习中目前最广泛的数据集。
数据集中我们只需要利用 data 文件夹中的
ptb.test.txt，ptb.train.txt，ptb.valid.txt 三个数据文件
测试，训练，验证 数据集
这三个数据文件是已经经过预处理的，包含10000个不同的词语和语句结束标识符 <eos> 的要获得此数据集，只需要用下面一行命令：
wget http://www.fit.vutbr.cz/~imikolov/rnnlm/simple-examples.tgz如果没有 wget 的话，就安装一下：
sudo apt install wget解压下载下来的压缩文件：
tar xvf simple-examples.tgz==== 一些术语的概念 ====
# Batch size : 批次(样本)数目。一次迭代（Forword 运算（用于得到损失函数）以及 BackPropagation 运算（用于更新神经网络参数））所用的样本数目。Batch size 越大，所需的内存就越大
# Iteration : 迭代。每一次迭代更新一次权重（网络参数），每一次权重更新需要 Batch size 个数据进行 Forward 运算，再进行 BP 运算
# Epoch : 纪元/时代。所有的训练样本完成一次迭代# 假如 : 训练集有 1000 个样本，Batch_size=10
# 那么 : 训练完整个样本集需要： 100 次 Iteration，1 个 Epoch
# 但一般我们都不止训练一个 Epoch==== 超参数（Hyper parameter）====
init_scale : 权重参数（Weights）的初始取值跨度，一开始取小一些比较利于训练
learning_rate : 学习率，训练时初始为 1.0
num_layers : LSTM 层的数目（默认是 2）
num_steps : LSTM 展开的步（step）数，相当于每个批次输入单词的数目（默认是 35）
hidden_size : LSTM 层的神经元数目，也是词向量的维度（默认是 650）
max_lr_epoch : 用初始学习率训练的 Epoch 数目（默认是 10）
dropout : 在 Dropout 层的留存率（默认是 0.5）
lr_decay : 在过了 max_lr_epoch 之后每一个 Epoch 的学习率的衰减率，训练时初始为 0.93。让学习率逐渐衰减是提高训练效率的有效方法
batch_size : 批次(样本)数目。一次迭代（Forword 运算（用于得到损失函数）以及 BackPropagation 运算（用于更新神经网络参数））所用的样本数目
（batch_size 默认是 20。取比较小的 batch_size 更有利于 Stochastic Gradient Descent（随机梯度下降），防止被困在局部最小值）
"""data_path = "C:/Users/lenovo/PycharmProjects/DLearning/TensorflowTest/LSTMPTB/data"
save_path = "C:/Users/lenovo/PycharmProjects/DLearning/TensorflowTest/LSTMPTB/save"
# 测试时读取模型参数文件的名称
load_file = "train-checkpoint-69"
# 初始化参数解析器
parser = argparse.ArgumentParser()
parser.add_argument('--data_path', type=str, default=data_path, help="The path of the data for training and testing")
# 测试时读取模型参数文件的名称
parser.add_argument('--load_file', type=str, default=load_file, help='The path of checkpoint file of model variables saved during training')args = parser.parse_args()Py3 = sys.version_info[0] == 3# 将文件根据句末分割符 <eos> 来分割
def read_words(filename):with tf.gfile.GFile(filename, "r") as f:if Py3:return f.read().replace("\n", "<eos>").split()else:return f.read().decode('utf-8').replace("\n", "<eos>").split()# 构造从单词到唯一整数值的映射
# 后面的其他数的整数值按照它们在数据集里出现的次数多少来排序，出现较多的排前面
# 单词 the 出现频次最多，对应整数值是 0
# <unk> 表示 unknown（未知），第二多，整数值为 1
def build_vocab(filename):data = read_words(filename)# 用 Counter 统计单词出现的次数，为了之后按单词出现次数的多少来排序counter = collections.Counter(data)count_pairs = sorted(counter.items(), key=lambda x: (-x[1], x[0]))# zip(*)解压一个元组，例如：[(1,4),(2,5),(3,6)] => [(1,2,3),(4,5,6)]words, _ = list(zip(*count_pairs))# 单词到整数的映射word_to_id = dict(zip(words, range(len(words))))return word_to_id# 将文件里的单词都替换成独一的整数
def file_to_word_ids(filename, word_to_id):data = read_words(filename)return [word_to_id[word] for word in data if word in word_to_id]def load_data(data_path):# 确保包含所有数据集文件的 data_path 文件夹在所有 Python 文件# 的同级目录下。当然了，你也可以自定义文件夹名和路径if not os.path.exists(data_path):raise Exception("包含所有数据集文件{}文件夹不在此目录，请添加".format(data_path))# 三个数据集的路径train_path = os.path.join(data_path, "ptb.train.txt")valid_path = os.path.join(data_path, "ptb.valid.txt")test_path = os.path.join(data_path, "ptb.test.txt")# 建立词汇表，将所有单词（word）转为唯一对应的整数值（id）word_to_id = build_vocab(train_path)# 训练，验证和测试数据train_data = file_to_word_ids(train_path, word_to_id)valid_data = file_to_word_ids(valid_path, word_to_id)test_data = file_to_word_ids(test_path, word_to_id)# 所有不重复单词的个数vocab_size = len(word_to_id)# 反转一个词汇表：为了之后从整数转为单词id_to_word = dict(zip(word_to_id.values(), word_to_id.keys()))print(word_to_id)print("===================")print(vocab_size)print("===================")print(train_data[:10])print("===================")print(" ".join([id_to_word[x] for x in train_data[:10]]))print("===================")return train_data, valid_data, test_data, vocab_size, id_to_word# 生成批次样本
def generate_batches(raw_data, batch_size, num_steps):# 将数据转为 Tensor 类型raw_data = tf.convert_to_tensor(raw_data, name="raw_data", dtype=tf.int32)data_len = tf.size(raw_data)batch_len = data_len // batch_size# 将数据形状转为 [batch_size, batch_len]data = tf.reshape(raw_data[0: batch_size * batch_len], [batch_size, batch_len])epoch_size = (batch_len - 1) // num_steps# range_input_producer 可以用多线程异步的方式从数据集里提取数据# 用多线程可以加快训练，因为 feed_dict 的赋值方式效率不高# shuffle 为 False 表示不打乱数据而按照队列先进先出的方式提取数据i = tf.train.range_input_producer(epoch_size, shuffle=False).dequeue()# 假设一句话是这样： “我爱我的祖国和人民”# 那么，如果 x 是类似这样： “我爱我的祖国”x = data[:, i * num_steps:(i + 1) * num_steps]x.set_shape([batch_size, num_steps])# y 就是类似这样（正好是 x 的时间步长 + 1）： “爱我的祖国和”# 因为我们的模型就是要预测一句话中每一个单词的下一个单词# 当然这边的例子很简单，实际的数据不止一个维度y = data[:, i * num_steps + 1:(i + 1) * num_steps + 1]y.set_shape([batch_size, num_steps])return x, yclass Input(object):def __init__(self, batch_size, num_steps, data):self.batch_size = batch_sizeself.num_steps = num_stepsself.epoch_size = ((len(data) // batch_size) - 1) // num_stepsself.input_data, self.targets = generate_batches(data, batch_size, num_steps)

我们可以使用下面代码，进行测试一下加载的数据形式。

if __name__ == "__main__":load_data(data_path)

{‘the’: 0, ‘’: 1, ‘’: 2, ‘N’: 3, ‘of’: 4, ‘to’: 5, ‘a’: 6, ‘in’: 7, ‘and’: 8, “'s”: 9, ‘that’: 10, ‘for’: 11, ‘$’: 12, ‘is’: 13, ‘it’: 14, ‘said’: 15, ‘on’: 16, ‘by’: 17, ‘at’: 18, ‘as’: 19, ‘from’: 20, ‘million’: 21, ‘with’: 22, ‘mr.’: 23, ‘was’: 24, ‘be’: 25, ‘are’: 26, ‘its’: 27, ‘he’: 28, ‘but’: 29, ‘has’: 30, ‘an’: 31, “n’t”: 32, ‘will’: 33, ‘have’: 34, ‘new’: 35, ‘or’: 36, ‘company’: 37, ‘they’: 38, ‘this’: 39, ‘year’: 40, ‘which’: 41, ‘would’: 42, ‘about’: 43, ‘says’: 44, ‘more’: 45, ‘were’: 46, ‘market’: 47, ‘billion’: 48, ‘his’: 49, ‘had’: 50, …, ‘photography’: 9990, ‘punts’: 9991, ‘rake’: 9992, ‘regatta’: 9993, ‘rubens’: 9994, ‘sim’: 9995, ‘snack-food’: 9996, ‘ssangyong’: 9997, ‘swapo’: 9998, ‘wachter’: 9999}
===================
10000
===================
[9970, 9971, 9972, 9974, 9975, 9976, 9980, 9981, 9982, 9983]
===================
aer banknote berlitz calloway centrust cluett fromstein gitano guterman hydro-quebec

从上面结果可知，整个数据集按照单词出现的频率高低转化为了0~9999，一共10000个整数，然后，再一个批次一个批次（generate_batches）的输入模型中，完成了数据准备工作。
**

2.LSTM网络构建（network.py）

import tensorflow as tf
"""
神经网络模型相关
RNN-LSTM 循环神经网络大家之后可以加上各种的 name_scope（命名空间）
用 TensorBoard 来可视化==== 一些术语的概念 ====
# Batch size : 批次(样本)数目。一次迭代（Forword 运算（用于得到损失函数）以及 BackPropagation 运算（用于更新神经网络参数））所用的样本数目。Batch size 越大，所需的内存就越大
# Iteration : 迭代。每一次迭代更新一次权重（网络参数），每一次权重更新需要 Batch size 个数据进行 Forward 运算，再进行 BP 运算
# Epoch : 纪元/时代。所有的训练样本完成一次迭代# 假如 : 训练集有 1000 个样本，Batch_size=10
# 那么 : 训练完整个样本集需要： 100 次 Iteration，1 个 Epoch
# 但一般我们都不止训练一个 Epoch==== 超参数（Hyper parameter）====
init_scale : 权重参数（Weights）的初始取值跨度，一开始取小一些比较利于训练
learning_rate : 学习率，训练时初始为 1.0
num_layers : LSTM 层的数目（默认是 2）
num_steps : LSTM 展开的步（step）数，相当于每个批次输入单词的数目（默认是 35）
hidden_size : LSTM 层的神经元数目，也是词向量的维度（默认是 650）
max_lr_epoch : 用初始学习率训练的 Epoch 数目（默认是 10）
dropout : 在 Dropout 层的留存率（默认是 0.5）
lr_decay : 在过了 max_lr_epoch 之后每一个 Epoch 的学习率的衰减率，训练时初始为 0.93。让学习率逐渐衰减是提高训练效率的有效方法
batch_size : 批次(样本)数目。一次迭代（Forword 运算（用于得到损失函数）以及 BackPropagation 运算（用于更新神经网络参数））所用的样本数目
（batch_size 默认是 20。取比较小的 batch_size 更有利于 Stochastic Gradient Descent（随机梯度下降），防止被困在局部最小值）
"""
class Model(object):def __init__(self, input_obj, is_training, hidden_size, vocab_size, num_layers, dropout=0.5, init_scale=0.05):self.is_training = is_trainingself.vocab_size = vocab_sizeself.input_obj = input_objself.batch_size = input_obj.batch_sizeself.num_steps = input_obj.num_stepsself.hidden_size = hidden_size# 让这里的操作和变量用 CPU 来计算，因为暂时（貌似）还没有 GPU 的实现with tf.device("/cpu:0"):# 创建词向量（Word Embedding），Embedding 表示 Dense Vector（密集向量）# 词向量本质上是一种单词聚类（Clustering）的方法embedding = tf.Variable(tf.random_uniform([self.vocab_size, self.hidden_size], -init_scale, init_scale))# embedding_lookup 返回词向量inputs = tf.nn.embedding_lookup(embedding, self.input_obj.input_data)# 如果是 训练时 并且 dropout 率小于 1，使输入经过一个 Dropout 层# Dropout 防止过拟合if self.is_training and dropout < 1:inputs = tf.nn.dropout(inputs, dropout)# 状态（state）的存储和提取# 第二维是2是因为对每一个LSTM单元有两个来自上一单元的输入：# 一个是前一时刻LSTM的输出h(t-1)# 一个是前一时刻的单元状态C(t-1)# 这个C和h是用于构建之后的tf.contrib.rnn.LSTMStateTupleself.init_state = tf.placeholder(tf.float32, [num_layers, 2, self.batch_size, self.hidden_size])# 每一层的状态state_per_layer_list = tf.unstack(self.init_state, axis=0)# 初始的状态（包含前一时刻LSTM的输出h(t-1)和前一时刻的单元状态C(t-1)），用于之后的dynamic_rnnrnn_tuple_state = tuple([tf.contrib.rnn.LSTMStateTuple(state_per_layer_list[idx][0], state_per_layer_list[idx][1]) for idx in range(num_layers)])# 创建一个 LSTM 层，其中的神经元数目是 hidden_size 个（默认 650 个）cell = tf.contrib.rnn.LSTMCell(hidden_size)# 如果是训练时 并且 Dropout 率小于 1，给 LSTM 层加上 Dropout 操作# 这里只给 输出 加了 Dropout 操作，留存率(output_keep_prob)是 0.5# 输入则是默认的 1，所以相当于输入没有做 Dropout 操作if is_training and dropout < 1:cell = tf.contrib.rnn.DropoutWrapper(cell, output_keep_prob=dropout)# 如果 LSTM 的层数大于 1, 则总计创建 num_layers 个 LSTM 层# 并将所有的 LSTM 层包装进 MultiRNNCell 这样的序列化层级模型中# state_is_tuple=True 表示接受 LSTMStateTuple 形式的输入状态if num_layers > 1:cell = tf.contrib.rnn.MultiRNNCell([cell for _ in range(num_layers)], state_is_tuple=True)# dynamic_rnn（动态 RNN）可以让不同迭代传入的 Batch 可以是长度不同的数据# 但同一次迭代中一个 Batch 内部的所有数据长度仍然是固定的# dynamic_rnn 能更好处理 padding（补零）的情况，节约计算资源# 返回两个变量：# 第一个是一个 Batch 里在时间维度（默认是 35）上展开的所有 LSTM 单元的输出，形状默认为 [20, 35, 650]，之后会经过扁平层处理# 第二个是最终的 state（状态），包含 当前时刻 LSTM 的输出 h(t) 和 当前时刻的单元状态 C(t)output, self.state = tf.nn.dynamic_rnn(cell, inputs, dtype=tf.float32, initial_state=rnn_tuple_state)# 扁平化处理，改变输出形状为 (batch_size * num_steps, hidden_size)，形状默认为 [700, 650]output = tf.reshape(output, [-1, hidden_size])# Softmax 的权重（Weight）softmax_w = tf.Variable(tf.random_uniform([hidden_size, vocab_size], -init_scale, init_scale))# Softmax 的偏置（Bias）softmax_b = tf.Variable(tf.random_uniform([vocab_size], -init_scale, init_scale))# logits 是 Logistic Regression（用于分类）模型（线性方程： y = W * x + b ）计算的结果（分值）# 这个 logits（分值）之后会用 Softmax 来转成百分比概率# output 是输入（x）， softmax_w 是 权重（W），softmax_b 是偏置（b）# 返回 W * x + b 结果logits = tf.nn.xw_plus_b(output, softmax_w, softmax_b)# 将 logits 转化为三维的 Tensor，为了 sequence loss 的计算# 形状默认为 [20, 35, 10000]logits = tf.reshape(logits, [self.batch_size, self.num_steps, vocab_size])# 计算 logits 的序列的交叉熵（Cross-Entropy）的损失（loss）loss = tf.contrib.seq2seq.sequence_loss(logits,  # 形状默认为 [20, 35, 10000]self.input_obj.targets,  # 期望输出，形状默认为 [20, 35]tf.ones([self.batch_size, self.num_steps], dtype=tf.float32),average_across_timesteps=False,average_across_batch=True)# 更新代价（cost）self.cost = tf.reduce_sum(loss)# Softmax 算出来的概率self.softmax_out = tf.nn.softmax(tf.reshape(logits, [-1, vocab_size]))# 取最大概率的那个值作为预测self.predict = tf.cast(tf.argmax(self.softmax_out, axis=1), tf.int32)# 预测值和真实值（目标）对比correct_prediction = tf.equal(self.predict, tf.reshape(self.input_obj.targets, [-1]))# 计算预测的精度self.accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))# 如果是 测试，则直接退出if not is_training:return# 学习率。trainable=False 表示“不可被训练”self.learning_rate = tf.Variable(0.0, trainable=False)# 返回所有可被训练（trainable=True。如果不设定 trainable=False，默认的 Variable 都是可以被训练的）# 也就是除了不可被训练的 学习率 之外的其他变量tvars = tf.trainable_variables()# tf.clip_by_global_norm（实现 Gradient Clipping（梯度裁剪））是为了防止梯度爆炸# tf.gradients 计算 self.cost 对于 tvars 的梯度（求导），返回一个梯度的列表grads, _ = tf.clip_by_global_norm(tf.gradients(self.cost, tvars), 5)# 优化器用 GradientDescentOptimizer（梯度下降优化器）optimizer = tf.train.GradientDescentOptimizer(self.learning_rate)# apply_gradients（应用梯度）将之前用（Gradient Clipping）梯度裁剪过的梯度 应用到可被训练的变量上去，做梯度下降# apply_gradients 其实是 minimize 方法里面的第二步，第一步是 计算梯度self.train_op = optimizer.apply_gradients(zip(grads, tvars),global_step=tf.train.get_or_create_global_step())# 用于更新 学习率self.new_lr = tf.placeholder(tf.float32, shape=[])self.lr_update = tf.assign(self.learning_rate, self.new_lr)# 更新 学习率def assign_lr(self, session, lr_value):session.run(self.lr_update, feed_dict={self.new_lr: lr_value})

3.训练过程（train.py）

from utils import *
from network import *
def train(train_data, vocab_size, num_layers, num_epochs, batch_size, model_save_name,learning_rate=1.0, max_lr_epoch=10, lr_decay=0.93, print_iter=50):# 训练的输入training_input = Input(batch_size=batch_size, num_steps=35, data=train_data)# 创建训练的模型m = Model(training_input, is_training=True, hidden_size=650, vocab_size=vocab_size, num_layers=num_layers)# 初始化变量的操作init_op = tf.global_variables_initializer()# 初始的学习率（learning rate）的衰减率orig_decay = lr_decaywith tf.Session() as sess:sess.run(init_op)  # 初始化所有变量# Coordinator（协调器），用于协调线程的运行coord = tf.train.Coordinator()# 启动线程threads = tf.train.start_queue_runners(coord=coord)# 为了用 Saver 来保存模型的变量saver = tf.train.Saver() # max_to_keep 默认是 5, 只保存最近的 5 个模型参数文件# 开始 Epoch 的训练for epoch in range(num_epochs):# 只有 Epoch 数大于 max_lr_epoch（设置为 10）后，才会使学习率衰减# 也就是说前 10 个 Epoch 的学习率一直是 1, 之后每个 Epoch 学习率都会衰减new_lr_decay = orig_decay ** max(epoch + 1 - max_lr_epoch, 0)m.assign_lr(sess, learning_rate * new_lr_decay)# 当前的状态# 第二维是 2 是因为对每一个 LSTM 单元有两个来自上一单元的输入：# 一个是 前一时刻 LSTM 的输出 h(t-1)# 一个是 前一时刻的单元状态 C(t-1)current_state = np.zeros((num_layers, 2, batch_size, m.hidden_size))# 获取当前时间，以便打印日志时用curr_time = datetime.datetime.now()for step in range(training_input.epoch_size):# train_op 操作：计算被修剪（clipping）过的梯度，并最小化 cost（误差）# state 操作：返回时间维度上展开的最后 LSTM 单元的输出（C(t) 和 h(t)），作为下一个 Batch 的输入状态if step % print_iter != 0:cost, _, current_state = sess.run([m.cost, m.train_op, m.state], feed_dict={m.init_state: current_state})else:seconds = (float((datetime.datetime.now() - curr_time).seconds) / print_iter)curr_time = datetime.datetime.now()cost, _, current_state, acc = sess.run([m.cost, m.train_op, m.state, m.accuracy], feed_dict={m.init_state: current_state})# 每 print_iter（默认是 50）打印当下的 Cost（误差/损失）和 Accuracy（精度）print("Epoch {}, 第 {} 步, 损失: {:.3f}, 精度: {:.3f}, 每步所用秒数: {:.2f}".format(epoch, step, cost, acc, seconds))# 保存一个模型的变量的 checkpoint 文件saver.save(sess, save_path + '/' + model_save_name, global_step=epoch)# 对模型做一次总的保存saver.save(sess, save_path + '/' + model_save_name + '-final')# 关闭线程coord.request_stop()coord.join(threads)if __name__ == "__main__":if args.data_path:data_path = args.data_pathtrain_data, valid_data, test_data, vocab_size, id_to_word = load_data(data_path)train(train_data, vocab_size, num_layers=2, num_epochs=70, batch_size=20,model_save_name='train-checkpoint')

4.测试过程（test.py）

from utils import *
from network import *
def test(model_path, test_data, vocab_size, id_to_word):# 测试的输入test_input = Input(batch_size=20, num_steps=35, data=test_data)# 创建测试的模型，基本的超参数需要和训练时用的一致，例如：# hidden_size，num_steps，num_layers，vocab_size，batch_size 等等# 因为我们要载入训练时保存的参数的文件，如果超参数不匹配 TensorFlow 会报错m = Model(test_input, is_training=False, hidden_size=650, vocab_size=vocab_size, num_layers=2)# 为了用 Saver 来恢复训练时生成的模型的变量saver = tf.train.Saver()with tf.Session() as sess:# Coordinator（协调器），用于协调线程的运行coord = tf.train.Coordinator()# 启动线程threads = tf.train.start_queue_runners(coord=coord)# 当前的状态# 第二维是 2 是因为测试时指定只有 2 层 LSTM# 第二维是 2 是因为对每一个 LSTM 单元有两个来自上一单元的输入：# 一个是 前一时刻 LSTM 的输出 h(t-1)# 一个是 前一时刻的单元状态 C(t-1)current_state = np.zeros((2, 2, m.batch_size, m.hidden_size))# 恢复被训练的模型的变量saver.restore(sess, model_path)# 测试 30 个批次num_acc_batches = 30# 打印预测单词和实际单词的批次数check_batch_idx = 25# 超过 5 个批次才开始累加精度acc_check_thresh = 5# 初始精度的和，用于之后算平均精度accuracy = 0for batch in range(num_acc_batches):if batch == check_batch_idx:true, pred, current_state, acc = sess.run([m.input_obj.targets, m.predict, m.state, m.accuracy], feed_dict={m.init_state: current_state})pred_words = [id_to_word[x] for x in pred[:m.num_steps]]true_words = [id_to_word[x] for x in true[0]]print("\n实际的单词:")print(" ".join(true_words))  # 真实的单词print("预测的单词:")print(" ".join(pred_words))  # 预测的单词else:acc, current_state = sess.run([m.accuracy, m.state], feed_dict={m.init_state: current_state})if batch >= acc_check_thresh:accuracy += acc# 打印平均精度print("平均精度: {:.3f}".format(accuracy / (num_acc_batches - acc_check_thresh)))# 关闭线程coord.request_stop()coord.join(threads)if __name__ == "__main__":if args.data_path:data_path = args.data_pathif args.load_file:load_file = args.load_filetrain_data, valid_data, test_data, vocab_size, id_to_word = load_data(data_path)trained_model = save_path + "/" + load_filetest(trained_model, test_data, vocab_size, id_to_word)

深度学习手记（八）之PTB实现LSTM模型相关推荐

百面深度学习 | 第八期：物体检测模型的发展概况
"百面深度学习"系列连载第八期物体检测模型的发展概况引言物体检测问题是计算机视觉中极为重要的基础问题,也是解决场景理解.图像描述(Image Captioning).实例分 ...
深度学习多变量时间序列预测：Encoder-Decoder LSTM算法构建时间序列多变量模型预测交通流量+代码实战
深度学习多变量时间序列预测:Encoder-Decoder LSTM算法构建时间序列多变量模型预测交通流量+代码实战 LSTM是一种时间递归神经网络,适合于处理和预测时间序列中间隔和延迟相对较长的重要 ...
花书+吴恩达深度学习（八）优化方法之 Batch normalization
目录 0. 前言 1. Batch normalization 训练 2. Batch normalization 测试如果这篇文章对你有一点小小的帮助,请给个关注,点个赞喔~我会非常开心的~ 花书 ...
【深度学习】-Imdb数据集情感分析之模型对比（2）- LSTM
[深度学习]-Imdb数据集情感分析之模型对比(2)-LSTM 文章目录前言一.LSTM是什么? 算法介绍二.训练LSTM模型 1.数据预处理 2.构建LSTM模型设定模型参数构建并训练模型 ...
从参数数量视角理解深度学习神经网络算法 DNN, CNN, RNN, LSTM 以python为工具
从参数数量视角理解深度学习神经网络算法 DNN, CNN, RNN, LSTM 以python为工具文章目录 1. 神经网络数据预处理 1.1 常规预测情景 1.2 文本预测场景 2.全连接神经网络 ...
Keras深度学习实战（32）——基于LSTM预测股价
Keras深度学习实战(32)--基于LSTM预测股价 0. 前言 1. 模型与数据集分析 1.1 数据集分析 1.2 模型分析 2. 基于长短时记忆网络LSTM预测股价 2.1 根据最近五天的股价预 ...
Pytorch深度学习（2） -- RNN及其进阶模型实现 ( GRU LSTM Deep-Rnn Bi-Rnn)
Pytorch深度学习(2) -- RNN及其进阶模型实现 0 预测训练函数 1.RNN实现 RNN小结 2.GRU实现 GRU小结 3.LSTM实现 LSTM小结 4.Deep-RNN 加入参数nu ...
如何提升深度学习性能？数据、算法、模型一个都不能少
https://www.toutiao.com/i6635808175893250564/ 2018-12-17 12:04:48 该文来自DataCastle数据城堡(DataCastle2016) ...
【深度学习】-Imdb数据集情感分析之模型对比（4）- CNN-LSTM 集成模型
[深度学习]-Imdb数据集情感分析之模型对比(4)- CNN-LSTM 集成模型前言 [深度学习]-Imdb数据集情感分析之模型对比(3)- CNN [深度学习]-Imdb数据集情感分析之模型对比 ...
深度学习的分布式训练--数据并行和模型并行
<div class="htmledit_views"> 在深度学习这一领域经常涉及到模型的分布式训练(包括一机多GPU的情况).我自己在刚刚接触到一机多卡,或者分布式 ...