【TensorFlow】LSTM(基于PTB的自然语言建模)
来源:互联网 发布:股票网络销售违法嘛 编辑:程序博客网 时间:2024/06/09 19:27
项目已上传至 GitHub —— nl-modeling
下载 PTB 数据集
官方下载地址的速度可能比较慢,这里提供了其他两种下载途径
- 原下载地址(速度可能较慢)
- 百度网盘 密码: 4gup(速度可能被恶意限制)
- CSDN下载(现在最低2积分)
需要的 PTB 数据集就在解压之后的 data/ 文件夹下,data/ 文件夹下有 7 个文件,要用的只有 3 个
ptb.test.txtptb.train.txtptb.valid.txt
要读取 PTB 数据集需要用到 reader.py,在 GitHub 上面有源码,可以下载或者直接复制下来
reader.py 提供了两个函数用于读取和处理 PTB 数据集
- ptb_raw_data(DATA_PATH):读取原始数据
- ptb_producer(raw_data,batch_size,num_steps):用于将数据组织成大小为 batch_size,长度为 num_steps 的数据组
原书中的代码没有将这两个函数的操作对象视为 tensor,而根据 reader.py 中的源码说明,它是对 tensor 进行操作的
并且 ptb_producer() 函数中使用了 tf.train.range_input_producer() 函数,所以需要开启多线程
以下代码示范了如何使用这两个函数
import readerimport tensorflow as tf# 数据路径DATA_PATH = 'simple-examples/data/'# 读取原始数据train_data, valid_data, test_data, _ = reader.ptb_raw_data(DATA_PATH)# 将数据组织成batch大小为4,截断长度为5的数据组,要放在开启多线程之前batch = reader.ptb_producer(train_data, 4, 5)with tf.Session() as sess: tf.global_variables_initializer().run() # 开启多线程 coord = tf.train.Coordinator() threads = tf.train.start_queue_runners(coord=coord) # 读取前两个batch,其中包括每个时刻的输入和对应的答案,ptb_producer()会自动迭代 for i in range(2): x, y = sess.run(batch) print('x:', x) print('y:', y) # 关闭多线程 coord.request_stop() coord.join(threads)
运行结果如下
x: [[9970 9971 9972 9974 9975] [ 332 7147 328 1452 8595] [1969 0 98 89 2254] [ 3 3 2 14 24]]y: [[9971 9972 9974 9975 9976] [7147 328 1452 8595 59] [ 0 98 89 2254 0] [ 3 2 14 24 198]]x: [[9976 9980 9981 9982 9983] [ 59 1569 105 2231 1] [ 0 312 1641 4 1063] [ 198 150 2262 10 0]]y: [[9980 9981 9982 9983 9984] [1569 105 2231 1 895] [ 312 1641 4 1063 8] [ 150 2262 10 0 507]]
完整代码
该代码实现自《TensorFlow:实战Google深度学习框架》
整个代码的结构如下
- PTBModel() 类用于创建 LSTM 网络结构及维护其状态
- run_epoch() 函数使用给定的 model 在数据集上运行 train_op 并返回 perplexity 值
- main() 函数定义图的运行
由于原书中的代码是基于 1.0,而我用的是 1.5,所以出现了很多错误,我将所遇到的错误的解决方法都记录在了文末
import readerimport numpy as npimport tensorflow as tf# 数据参数DATA_PATH = 'simple-examples/data/' # 数据存放路径VOCAB_SIZE = 10000 # 单词数量# 神经网络参数HIDDEN_SIZE = 200 # LSTM隐藏层规模NUM_LAYERS = 2 # LSTM结构层数LEARNING_RATE = 1.0 # 学习速率KEEP_PROB = 0.5 # 节点不被dropout的概率MAX_GRAD_NORM = 5 # 用于控制梯度膨胀的参数# 训练参数TRAIN_BATCH_SIZE = 20 # 训练数据batch大小TRAIN_NUM_STEP = 35 # 训练数据截断长度# 测试参数EVAL_BATCH_SIZE = 1 # 测试数据batch大小EVAL_NUM_STEP = 1 # 测试数据截断NUM_EPOCH = 2 # 使用训练数据的轮数# 通过PTBModel描述模型,方便维护循环神经网络中的状态class PTBModel(): def __init__(self, is_training, batch_size, num_steps): # 记录batch和截断长度 self.batch_size = batch_size self.num_steps = num_steps # 定义输入层 self.input_data = tf.placeholder(tf.int32, [batch_size, num_steps]) # 定义预期输出 self.targets = tf.placeholder(tf.int32, [batch_size, num_steps]) # 定义LSTM为使用dropout的两层网络 lstm_cell = tf.contrib.rnn.BasicLSTMCell(HIDDEN_SIZE) if is_training: lstm_cell = tf.contrib.rnn.DropoutWrapper( lstm_cell, output_keep_prob=KEEP_PROB) cell = tf.contrib.rnn.MultiRNNCell([lstm_cell] * NUM_LAYERS) # 初始化state self.initial_state = cell.zero_state(batch_size, tf.float32) # 将单词ID转为单词向量。每个单词都是HIDDEN_SIZE维 embedding = tf.get_variable('embedding', [VOCAB_SIZE, HIDDEN_SIZE]) # 将原本batch_size*num_steps的输入层转化为batch_size*num_steps*HIDDEN_SIZE inputs = tf.nn.embedding_lookup(embedding, self.input_data) # 只在训练时使用dropout if is_training: inputs = tf.nn.dropout(inputs, KEEP_PROB) # 定义输出列表 outputs = [] state = self.initial_state with tf.variable_scope('RNN'): for time_step in range(num_steps): if time_step > 0: tf.get_variable_scope().reuse_variables() cell_output, state = cell(inputs[:, time_step, :], state) # 将当前时刻的数据和状态传入LSTM outputs.append(cell_output) # 将当前输出加入输出列表 # 将输出列表展开成[batch,hidden_size*num_steps] # 再reshape成[batch*num_steps,hidden_size] output = tf.reshape(tf.concat(outputs, 1), [-1, HIDDEN_SIZE]) # 将输出传入全连接层,每个时刻的输出都是长度为VOCAB_SIZE的数组 weight = tf.get_variable('weight', [HIDDEN_SIZE, VOCAB_SIZE]) bias = tf.get_variable('bias', [VOCAB_SIZE]) logits = tf.matmul(output, weight) + bias # 定义交叉熵损失函数,sequence_loss_by_example计算一个序列的交叉熵的和 loss = tf.contrib.legacy_seq2seq.sequence_loss_by_example( [logits], # 预测结果 [tf.reshape(self.targets, [-1]) ], # 预期结果。将[batch_size,num_steps]压缩成一维 [tf.ones([batch_size * num_steps], dtype=tf.float32) ] # 损失的权重。这里所有的权重都为1,表示不同batch和不同时刻的重要程度都一样 ) # 计算得到每个batch的平均损失 self.cost = tf.reduce_sum(loss) / batch_size self.final_state = state # 只在训练时反向传播 if not is_training: return trainable_variables = tf.trainable_variables() grads, _ = tf.clip_by_global_norm( tf.gradients(self.cost, trainable_variables), MAX_GRAD_NORM) # 控制梯度大小。避免梯度膨胀 # 定义优化方法 optimizer = tf.train.GradientDescentOptimizer(LEARNING_RATE) # 定义训练步骤 self.train_op = optimizer.apply_gradients( zip(grads, trainable_variables))# 使用给定的model在data上运行train_op并返回在全部数据上的perplexitydef run_epoch(session, model, data_queue, train_op, output_log, epoch_size): # 计算perplexity的辅助变量 total_costs = 0.0 iters = 0 state = session.run(model.initial_state) # 使用当前数据训练或测试模型 for step in range(epoch_size): # 生成输入和答案 feed_dict = {} x, y = session.run(data_queue) feed_dict[model.input_data] = x feed_dict[model.targets] = y # 将状态转为字典 for i, (c, h) in enumerate(model.initial_state): feed_dict[c] = state[i].c feed_dict[h] = state[i].h # 获取损失值和下一个状态 cost, state, _ = session.run( [model.cost, model.final_state, train_op], feed_dict=feed_dict ) # 在当前batch上运行train_op并计算损失值。交叉熵损失函数计算的是下一个单词为给定单词的概率 total_costs += cost iters += model.num_steps # 训练时输出日志 if output_log and step % 100 == 0: print('After %d steps,perplexity is %.3f' % (step, np.exp(total_costs / iters))) return np.exp(total_costs / iters)def main(_): # 原始数据 train_data, valid_data, test_data, _ = reader.ptb_raw_data(DATA_PATH) # 计算一个epoch需要训练的次数 train_data_len = len(train_data) # 数据集的大小 train_batch_len = train_data_len // TRAIN_BATCH_SIZE # batch的个数 train_epoch_size = (train_batch_len - 1) // TRAIN_NUM_STEP # 该epoch的训练次数 valid_data_len = len(valid_data) valid_batch_len = valid_data_len // EVAL_BATCH_SIZE valid_epoch_size = (valid_batch_len - 1) // EVAL_NUM_STEP test_data_len = len(test_data) test_batch_len = test_data_len // EVAL_BATCH_SIZE test_epoch_size = (test_batch_len - 1) // EVAL_NUM_STEP # 生成数据队列,必须放在开启多线程之前 train_queue = reader.ptb_producer(train_data, train_model.batch_size, train_model.num_steps) valid_queue = reader.ptb_producer(valid_data, eval_model.batch_size, eval_model.num_steps) test_queue = reader.ptb_producer(test_data, eval_model.batch_size, eval_model.num_steps) # 定义初始化函数 initializer = tf.random_uniform_initializer(-0.05, 0.05) # 定义训练用的模型 with tf.variable_scope( 'language_model', reuse=None, initializer=initializer): train_model = PTBModel(True, TRAIN_BATCH_SIZE, TRAIN_NUM_STEP) # 定义评估用的模型 with tf.variable_scope( 'language_model', reuse=True, initializer=initializer): eval_model = PTBModel(False, EVAL_BATCH_SIZE, EVAL_NUM_STEP) with tf.Session() as sess: tf.global_variables_initializer().run() # 开启多线程从而支持ptb_producer()使用tf.train.range_input_producer() coord = tf.train.Coordinator() threads = tf.train.start_queue_runners(sess=sess, coord=coord) # 使用训练数据训练模型 for i in range(NUM_EPOCH): print('In iteration: %d' % (i + 1)) run_epoch(sess, train_model, train_queue, train_model.train_op, True, train_epoch_size) # 训练模型 valid_perplexity = run_epoch(sess, eval_model, valid_queue, tf.no_op(), False, valid_epoch_size) # 使用验证数据评估模型 print('Epoch: %d Validation Perplexity: %.3f' % (i + 1, valid_perplexity)) # 使用测试数据测试模型 test_perplexity = run_epoch(sess, eval_model, test_queue, tf.no_op(), False, test_epoch_size) print('Test Perplexity: %.3f' % test_perplexity) # 停止所有线程 coord.request_stop() coord.join(threads)if __name__ == '__main__': tf.app.run()
运行结果如下
$ python train.pyIn iteration: 1After 0 steps,perplexity is 10054.757After 100 steps,perplexity is 1403.731......After 1200 steps,perplexity is 460.833After 1300 steps,perplexity is 442.765Epoch: 1 Validation Perplexity: 270.200In iteration: 2After 0 steps,perplexity is 371.624After 100 steps,perplexity is 266.044......After 1200 steps,perplexity is 248.459After 1300 steps,perplexity is 245.637Epoch: 2 Validation Perplexity: 215.167Test Perplexity: 206.910
perplexity 运行结果为 207,表示预测下一个单词的范围是 207 个,可以通过调整 LSTM 隐藏层的节点个数和大小以及训练迭代的轮数降低
错误总结
新版本 TensorFlow 改了很多地方,下面是运行原书中的代码时出现的问题
1. 没有 rnn_cell
出现如下错误
module 'tensorflow.python.ops.nn' has no attribute 'rnn_cell'
是因为 tf.nn.rnn_cell 改成了 tf.contrib.rnn
# 原代码lstm_cell = tf.nn.rnn_cell.BasicLSTMCell(HIDDEN_SIZE)if is_training: lstm_cell = tf.nn.rnn_cell.DropoutWrapper( lstm_cell, output_keep_prob=KEEP_PROB)cell = tf.nn.rnn_cell.MultiRNNCell([lstm_cell] * NUM_LAYERS)# 修改为lstm_cell = tf.contrib.rnn.BasicLSTMCell(HIDDEN_SIZE)if is_training: lstm_cell = tf.contrib.rnn.DropoutWrapper( lstm_cell, output_keep_prob=KEEP_PROB)cell = tf.contrib.rnn.MultiRNNCell([lstm_cell] * NUM_LAYERS)
2. tf.concat()参数位置
出现如下错误
TypeError: Expected int32, got list containing Tensors of type '_Message' instead.
是因为 tf.concat 函数的参数位置换了一下
# 原代码output = tf.reshape(tf.concat(1, outputs), [-1, HIDDEN_SIZE])# 修改为output = tf.reshape(tf.concat(outputs, 1), [-1, HIDDEN_SIZE])
3. 没有 seq2seq
出现如下错误
AttributeError: module 'tensorflow.python.ops.nn' has no attribute 'seq2seq'
是因为 tf.nn.seq2seq.sequence_loss_by_example 修改成了 tf.contrib.legacy_seq2seq.sequence_loss_by_example
# 原代码loss = tf.nn.seq2seq.sequence_loss_by_example( [logits], [tf.reshape(self.targets, [-1])], [tf.ones([batch_size * num_steps], dtype=tf.float32)])# 修改为loss = tf.contrib.legacy_seq2seq.sequence_loss_by_example( [logits], [tf.reshape(self.targets, [-1])], [tf.ones([batch_size * num_steps], dtype=tf.float32)])
4. 没有 ptb_iterator
出现如下错误
AttributeError: module 'reader' has no attribute 'ptb_iterator'
是因为读取 PTB 数据集的 reader 将 ptb_iterator() 修改成了 ptb_producer()
# 原代码for step, (x, y) in enumerate( reader.ptb_iterator(data, model.batch_size, model.num_steps)):# 修改为for step, (x, y) in enumerate( reader.ptb_producer(data, model.batch_size, model.num_steps)):
之后运行的时候,还会出现如下错误
`Tensor` objects are not iterable when eager execution is not
可能是因为 ptb_producer() 返回的是 Tensor,所以不能用 numerate() 进行迭代,所以需要将获取 (x,y) 的操作抽取出来单独运行
要修改代码,需要解决三个问题
- 训练的次数。即 epoch_size 值的计算
- (x,y) 的获取。即 reader.ptb_producer() 返回结果的格式
- 开启多线程。ptb_producer() 中使用了 tf.train.range_input_producer() 控制 (x,y) 的迭代
这些问题的答案都可以从 ptb_producer() 的源码中找到,以下是该函数的源码
def ptb_producer(raw_data, batch_size, num_steps, name=None): """Iterate on the raw PTB data. This chunks up raw_data into batches of examples and returns Tensors that are drawn from these batches. Args: raw_data: one of the raw data outputs from ptb_raw_data. batch_size: int, the batch size. num_steps: int, the number of unrolls. name: the name of this operation (optional). Returns: A pair of Tensors, each shaped [batch_size, num_steps]. The second element of the tuple is the same data time-shifted to the right by one. Raises: tf.errors.InvalidArgumentError: if batch_size or num_steps are too high. """ with tf.name_scope(name, "PTBProducer", [raw_data, batch_size, num_steps]): 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 data = tf.reshape(raw_data[0 : batch_size * batch_len], [batch_size, batch_len]) epoch_size = (batch_len - 1) // num_steps assertion = tf.assert_positive( epoch_size, message="epoch_size == 0, decrease batch_size or num_steps") with tf.control_dependencies([assertion]): epoch_size = tf.identity(epoch_size, name="epoch_size") i = tf.train.range_input_producer(epoch_size, shuffle=False).dequeue() x = tf.strided_slice(data, [0, i * num_steps], [batch_size, (i + 1) * num_steps]) x.set_shape([batch_size, num_steps]) y = tf.strided_slice(data, [0, i * num_steps + 1], [batch_size, (i + 1) * num_steps + 1]) y.set_shape([batch_size, num_steps]) return x, y
首先解决循环次数的问题,即计算 epoch_size。可以看到源码中的 epoch_size 即我们要求的循环次数
......data_len = tf.size(raw_data)batch_len = data_len // batch_sizedata = tf.reshape(raw_data[0 : batch_size * batch_len], [batch_size, batch_len])epoch_size = (batch_len - 1) // num_steps......
所以我们也可以类似地求出训练、验证和测试的 epoch_size,如下所示
# 计算一个epoch需要训练的次数train_data_len = len(train_data) # 数据集的大小train_batch_len = train_data_len // TRAIN_BATCH_SIZE # batch的个数train_epoch_size = (train_batch_len - 1) // TRAIN_NUM_STEP # 该epoch的训练次数valid_data_len = len(valid_data)valid_batch_len = valid_data_len // EVAL_BATCH_SIZEvalid_epoch_size = (valid_batch_len - 1) // EVAL_NUM_STEPtest_data_len = len(test_data)test_batch_len = test_data_len // EVAL_BATCH_SIZEtest_epoch_size = (test_batch_len - 1) // EVAL_NUM_STEP
然后解决第二个问题,即 (x,y) 的获取,从源码中可以看到直接返回的 x,y 元组,所以直接接收即可,如下所示
x, y = reader.ptb_producer(data, model.batch_size, model.num_steps)
最后解决第三个问题,即开启多线程从而支持 ptb_producer() 使用 tf.train.range_input_producer(),如下所示
# 开启多线程从而支持 ptb_producer() 使用 tf.train.range_input_producer()coord = tf.train.Coordinator()threads = tf.train.start_queue_runners(coord=coord)......# 停止所有线程coord.request_stop()coord.join(threads)
完整代码已经在文章中给出,也可以去 nl-modeling 查看。经历了这个问题之后,知道了要关注工具接口的改变,以免遇到不必要的麻烦,共勉
5. 不能压平字典,键不唯一
出现如下错误
ValueError: Could not flatten dictionary: key Tensor("language_model/MultiRNNCellZeroState/DropoutWrapperZeroState/BasicLSTMCellZeroState/zeros:0", shape=(20, 200), dtype=float32) is not unique.
这个问题我搜了很久都没找到答案,最后通过查看 GitHub 上 ptb_word_lm.py 的源码,和打印出 state 的值才发现了问题所在
在程序中添加一行打印 state 的代码,然后查看输出
# 打印state的值print(state)# 输出如下(LSTMStateTuple(c=array([[ 0., 0., 0., ..., 0., 0., 0.], [ 0., 0., 0., ..., 0., 0., 0.], [ 0., 0., 0., ..., 0., 0., 0.], ..., [ 0., 0., 0., ..., 0., 0., 0.], [ 0., 0., 0., ..., 0., 0., 0.], [ 0., 0., 0., ..., 0., 0., 0.]], dtype=float32), h=array([[ 0., 0., 0., ..., 0., 0., 0.], [ 0., 0., 0., ..., 0., 0., 0.], [ 0., 0., 0., ..., 0., 0., 0.], ..., [ 0., 0., 0., ..., 0., 0., 0.], [ 0., 0., 0., ..., 0., 0., 0.], [ 0., 0., 0., ..., 0., 0., 0.]], dtype=float32)), LSTMStateTuple(c=array([[ 0., 0., 0., ..., 0., 0., 0.], [ 0., 0., 0., ..., 0., 0., 0.], [ 0., 0., 0., ..., 0., 0., 0.], ..., [ 0., 0., 0., ..., 0., 0., 0.], [ 0., 0., 0., ..., 0., 0., 0.], [ 0., 0., 0., ..., 0., 0., 0.]], dtype=float32), h=array([[ 0., 0., 0., ..., 0., 0., 0.], [ 0., 0., 0., ..., 0., 0., 0.], [ 0., 0., 0., ..., 0., 0., 0.], ..., [ 0., 0., 0., ..., 0., 0., 0.], [ 0., 0., 0., ..., 0., 0., 0.], [ 0., 0., 0., ..., 0., 0., 0.]], dtype=float32)))
从输出中可以看到,state 是 LSTMStateTuple 的元组,而 LSTMStateTuple 里面包含了数组 c 和 h,简化一下就是
( LSTMState(c,h), LSTMState(c,h))
这个 LSTMState 就是 LSTM 层中的状态的元组,再来输出它的结构看看是什么样的
# 输出state的长度print(len(state))# 输出LSTMState中c的形状print(state[0].c.shape)# 输出LSTMState中h的形状print(state[0].h.shape)# 输出结果2(20, 200)(20, 200)
从输出中可以看到 state 包含了两层 LSTM 的状态,每个 LSTMState 都是 20×200 的数组
因为我们设置一个 LSTM 隐藏层的规模为 200,所以每层 LSTM 的状态向量的大小是 200。而一个数据 batch 大小为 20,所以一共有 20×200 个参数
而错误原因在于 feed_dict 中给出的键是不唯一,这句话没怎么看懂,可以输出 model.initial_state 看看到底怎么回事
# 输出initial_state的值print(model.initial_state)# 输出结果整理之后如下( LSTMStateTuple( c=<tf.Tensor 'language_model/MultiRNNCellZeroState/DropoutWrapperZeroState/BasicLSTMCellZeroState/zeros:0' shape=(20, 200) dtype=float32>, h=<tf.Tensor 'language_model/MultiRNNCellZeroState/DropoutWrapperZeroState/BasicLSTMCellZeroState/zeros_1:0' shape=(20, 200) dtype=float32>), LSTMStateTuple( c=<tf.Tensor 'language_model/MultiRNNCellZeroState/DropoutWrapperZeroState/BasicLSTMCellZeroState/zeros:0' shape=(20, 200) dtype=float32>, h=<tf.Tensor 'language_model/MultiRNNCellZeroState/DropoutWrapperZeroState/BasicLSTMCellZeroState/zeros_1:0' shape=(20, 200) dtype=float32>))
可以看到两个 c 和两个 h 的名字是一样的,所以出现的上述错误
目前我们现在要解决的问题有三个
- 生成数据队列
- 将 x,y 放入 feed_dict
- 分别将 c,h 放入 feed_dict
首先生成数据队列,必须要将数据队列的声明放在启动多线程之前,不然会出现队列一直等待出队的状态,如下所示
......# 生成数据队列,必须放在开启多线程之前train_queue = reader.ptb_producer(train_data, train_model.batch_size, train_model.num_steps)valid_queue = reader.ptb_producer(valid_data, eval_model.batch_size, eval_model.num_steps)test_queue = reader.ptb_producer(test_data, eval_model.batch_size, eval_model.num_steps)......# 开启多线程从而支持ptb_producer()使用tf.train.range_input_producer()coord = tf.train.Coordinator()threads = tf.train.start_queue_runners(sess=sess, coord=coord)......
然后生成 x,y 并放入 feed_dict 中,如下所示
# 生成输入和答案feed_dict = {}x, y = session.run(data_queue)feed_dict[model.input_data] = xfeed_dict[model.targets] = y
最后需要分别将 c,h 放入 feed_dict 中,可以从 ptb_word_lm.py 找到方法,如下所示
# 将状态转为字典for i, (c, h) in enumerate(model.initial_state): feed_dict[c] = state[i].c feed_dict[h] = state[i].h# 获取损失值和下一个状态cost, state, _ = session.run( [model.cost, model.final_state, train_op], feed_dict=feed_dict )
完整代码已经在文章中给出,也可以去 nl-modeling 查看。这个问题网上目前没有详细的错误描述,也没有解决方法,连出现这个错误的人都很少,所以不太清除错误的根本原因是什么
- 【TensorFlow】LSTM(基于PTB的自然语言建模)
- 用深层LSTM实现简单的自然语言建模
- 解析Tensorflow官方PTB模型的demo
- 基于tensorflow的RNN-LSTM(一)实现RNN
- TensorFlow实现基于LSTM的语言模型
- TensorFlow实现经典深度学习网络(6):TensorFlow实现基于LSTM的语言模型
- Tensorflow:基于LSTM生成藏头诗
- tensorflow实现基于LSTM的文本分类方法
- TensorFlow实战12:实现基于LSTM的语言模型
- 如何用 TensorFlow 实现基于 LSTM 的文本分类
- Tensorflow实现基于LSTM的文本分类方法
- Tensorflow实例:实现基于LSTM的语言模型
- lstm的tensorflow实现
- tensorflow的lstm
- Tensorflow实战学习(十七)【自然语言处理、RNN、LSTM】
- tensorflow38《TensorFlow实战》笔记-07-02 TensorFlow实现基于LSTM的语言模型 code
- TensorFlow-Bitcoin-Robot:一个基于 TensorFlow LSTM 模型的 Bitcoin 价格预测机器人。
- TensorFlow-Bitcoin-Robot-一个基于 TensorFlow LSTM 模型的 Bitcoin 价格预测机器人
- final...?
- Android自定义对话框(Dialog)位置,大小
- linux常用命令加实例大全
- html、css
- 【安装教程】opencv3.2 contrib ubuntu16.04
- 【TensorFlow】LSTM(基于PTB的自然语言建模)
- Maven Problem: No compiler is provided in this environment
- Anroid微信支付从统一下单到唤起支付
- dumpsys的使用笔记
- Java 深入学习(21) —— 内部类
- C++的学习笔记(第三章:控制语句)
- 转:sklearn包——混淆矩阵、分类报告等自动生成
- html5及标签库
- load average详解