漫谈四种神经网络序列解码模型【附示例代码】

发表于 2016 年 3 月 24 日由 jacoxu

以下为漫谈，即瞎聊，利用通俗的语言来谈谈神经网络模型中4种序列解码模型，主要是从整体概念和思路上进行通俗解释帮助理解。预警，以下可能为了偷懒就不贴公式了，一些细节也被略过了，感兴趣的可以直接去阅读原文[1][2][3]。

[1] Sequence to Sequence Learning with Neural Networks
[2] Learning Phrase Representations using RNN Encoder–Decoder for Statistical Machine Translation
[3] Neural Machine Translation by Jointly Learning to Align and Translate

利用神经网络进行序列编码的模型主要为RNN，目前比较火的一些变种模型有LSTM和GRU，只是cell单元不同而已。以下统统用RNN来代表。

编码模型比较简单，如下图所示，输入文本{X1-X6}经过循环迭代编码，在每个时刻得到当前时刻的一个隐层状态，最后序列结束后进行特征融合得到句子的表示。注意，一种比较常用的方式是将编码模型最后一个时刻的隐层状态做为整个序列的编码表示，但是实际应用中这种效果并不太好，因而我们的图例中直接采用了整个序列隐层编码进行求和平均的方式得到序列的编码向量。

早期的一些任务主要是做一些主题分类、情感检测等等分类任务，那么在编码向量上面添加一个softmax就可以解决问题。但是对于机器翻译和语音识别等问题则需要进行序列化解码。

注意到，编码时RNN每个时刻除了自己上一时刻的隐层状态编码外，还有当前时刻的输入字符，而解码时则没有这种输入。那么，一种比较直接的方式是把编码端得到的编码向量做为解码模型的每时刻输入特征。如下图所示：

简单直观而且解码模型和编码模型并没有任何区别，然而学者感觉该模型并不优雅，那么接下来我们就来介绍一些精巧点的吧。

=============此处开始转入瞎聊模式==============

我们用考试作弊来做为一个通俗的例子来解释一下模型。

首先我们假设输入文本是所学课本，编码端则是对课本的理解所整理的课堂笔记。解码端的隐层神经网络则是我们的大脑，而每一时刻的输出则是考试时要写在卷子上的答案。在上面最简单的解码模型中，可以考虑成是考试时一边写答案一边翻看课堂笔记。如果这是一般作弊学生的做法，学霸则不需要翻书，他们有一个强大的大脑神经网络，可以记住自己的课堂笔记。解码时只需要回顾一下自己前面写过什么，然后依次认真的把答案写在答卷上，就是下面这种模型了[1]：

还有很多学弱，他们不只需要作弊，而且翻看笔记的时候还需要回顾自己上一时刻写在答卷上的答案（学弱嘛，简直弱到连自己上一时刻写在答卷上的文字都记不住了），就是下面的答题模式了[2]：

然而学渣渣也是存在的，他们不只需要作弊，不只需要回顾自己上一时刻卸载答卷上的答案，还需要老师在课本上画出重点才能整理出自己的课题笔记（这就是一种注意力机制Attention，记笔记的时候一定要根据考题画出重点啊！），真的很照顾渣渣了，他们的答题模式如下[3]：

可见，除了学霸以外，其他人都作弊了，在答题的时候翻看课堂笔记（很多文献中叫这种解码模型结构为peek(偷看)，是不是很像在作弊？），而且学渣渣还去找过老师给画过重点，有了清楚的重点之后就不用翻书偷看了，瞄一眼就可以了，文献中叫glimpse(一瞥)，是不是很像？

如果我们将他们的大脑网络设定为同样结构的话（将他们的IQ强制保持一致），肯定是作弊的同学得分最高了，学霸模式好吃亏啊。我们来简单做一个模型测试。

测试数据：

输入序列文本 = ['1 2 3 4 5'
, '6 7 8 9 10'
, '11 12 13 14 15'
, '16 17 18 19 20'
, '21 22 23 24 25']
目标序列文本 = ['one two three four five'
, 'six seven eight nine ten'
, 'eleven twelve thirteen fourteen fifteen'
, 'sixteen seventeen eighteen nineteen twenty'
, 'twenty_one twenty_two twenty_three twenty_four twenty_five']

设定一些参数如下：
-
(‘Vocab size:’, 51, ‘unique words’)
(‘Input max length:’, 5, ‘words’)
(‘Target max length:’, 5, ‘words’)
(‘Dimension of hidden vectors:’, 20)
(‘Number of training stories:’, 5)
(‘Number of test stories:’, 5)
-

观察训练过程：

其中，第一种解码模型为普通作弊，第二种解码模型为学霸模式，第三种解码模型为学弱作弊，第四种解码模型为学渣作弊。

可以看到在IQ值（解码模型的神经网络结构）相同的情况下，学渣作弊模式答题（训练收敛速度）更快，而学霸模式答题最慢。

文章[1]中已经提到过，想通过学霸模式达到一个好的性能需要模型隐层有4000个节点（学霸的IQ果然是高的，有一颗强大的大脑网络）。

可以想想，在课本内容很多很多时，学霸也会累的，而且学弱们你们确定课上能听懂吗？学渣就会笑啦，因而老师给他们画重点了！！！！

哈哈，娱乐而已。

好，学术一点，博主关注：对话与问答，信息检索，深度学习等相关。欢迎学术讨论。

博文出处：http://jacoxu.com/?p=1852

附录：

本博文中测试的示例代码见【Github地址】：

Code View Copy Print

·········10········20········30········40········50········60········70········80········90········100·······110·······120·······130·······140·······150

# -*- encoding:utf-8 -*-
“”"
测试Encoder-Decoder 2016/03/22
“”"
from keras.models import Sequential
from keras.layers.recurrent import LSTM
from keras.layers.embeddings import Embedding
from keras.layers.core import RepeatVector, TimeDistributedDense, Activation
from seq2seq.layers.decoders import LSTMDecoder, LSTMDecoder2, AttentionDecoder
import time
import numpy as np
import re
__author__ = ’http://jacoxu.com’
def pad_sequences(sequences, maxlen=None, dtype=’int32′,
padding=’pre’, truncating=’pre’, value=0.):
”’Pads each sequence to the same length:
the length of the longest sequence.
If maxlen is provided, any sequence longer
than maxlen is truncated to maxlen.
Truncation happens off either the beginning (default) or
the end of the sequence.
Supports post-padding and pre-padding (default).
# Arguments
sequences: list of lists where each element is a sequence
maxlen: int, maximum length
dtype: type to cast the resulting sequence.
padding: ’pre’ or ’post’, pad either before or after each sequence.
truncating: ’pre’ or ’post’, remove values from sequences larger than
maxlen either in the beginning or in the end of the sequence
value: float, value to pad the sequences to the desired value.
# Returns
x: numpy array with dimensions (number_of_sequences, maxlen)
”’
lengths = [len(s) for s in sequences]
nb_samples = len(sequences)
if maxlen is None:
maxlen = np.max(lengths)
# take the sample shape from the first non empty sequence
# checking for consistency in the main loop below.
sample_shape = tuple()
for s in sequences:
if len(s) > 0:
sample_shape = np.asarray(s).shape[1:]
break
x = (np.ones((nb_samples, maxlen) + sample_shape) * value).astype(dtype)
for idx, s in enumerate(sequences):
if len(s) == 0:
continue # empty list was found
if truncating == ’pre’:
trunc = s[-maxlen:]
elif truncating == ’post’:
trunc = s[:maxlen]
else:
raise ValueError(‘Truncating type ”%s” not understood’ % truncating)
# check `trunc` has expected shape
trunc = np.asarray(trunc, dtype=dtype)
if trunc.shape[1:] != sample_shape:
raise ValueError(‘Shape of sample %s of sequence at position %s is different from expected shape %s’ %
(trunc.shape[1:], idx, sample_shape))
if padding == ’post’:
x[idx, :len(trunc)] = trunc
elif padding == ’pre’:
x[idx, -len(trunc):] = trunc
else:
raise ValueError(‘Padding type ”%s” not understood’ % padding)
return x
def vectorize_stories(input_list, tar_list, word_idx, input_maxlen, tar_maxlen, vocab_size):
x_set = []
Y = np.zeros((len(tar_list), tar_maxlen, vocab_size), dtype=np.bool)
for _sent in input_list:
x = [word_idx[w] for w in _sent]
x_set.append(x)
for s_index, tar_tmp in enumerate(tar_list):
for t_index, token in enumerate(tar_tmp):
Y[s_index, t_index, word_idx[token]] = 1
return pad_sequences(x_set, maxlen=input_maxlen), Y
def tokenize(sent):
”’Return the tokens of a sentence including punctuation.
>>> tokenize(‘Bob dropped the apple. Where is the apple?’)
['Bob', 'dropped', 'the', 'apple', '.', 'Where', 'is', 'the', 'apple', '?']
”’
return [x.strip() for x in re.split('(\W+)?', sent) if x.strip()]
def main():
input_text = ['1 2 3 4 5'
, '6 7 8 9 10'
, '11 12 13 14 15'
, '16 17 18 19 20'
, '21 22 23 24 25']
tar_text = ['one two three four five'
, 'six seven eight nine ten'
, 'eleven twelve thirteen fourteen fifteen'
, 'sixteen seventeen eighteen nineteen twenty'
, 'twenty_one twenty_two twenty_three twenty_four twenty_five']
input_list = []
tar_list = []
for tmp_input in input_text:
input_list.append(tokenize(tmp_input))
for tmp_tar in tar_text:
tar_list.append(tokenize(tmp_tar))
vocab = sorted(reduce(lambda x, y: x | y, (set(tmp_list) for tmp_list in input_list + tar_list)))
# Reserve 0 for masking via pad_sequences
vocab_size = len(vocab) + 1 # keras进行embedding的时候必须进行len(vocab)+1
input_maxlen = max(map(len, (x for x in input_list)))
tar_maxlen = max(map(len, (x for x in tar_list)))
output_dim = vocab_size
hidden_dim = 20
print(‘-’)
print(‘Vocab size:’, vocab_size, ’unique words’)
print(‘Input max length:’, input_maxlen, ’words’)
print(‘Target max length:’, tar_maxlen, ’words’)
print(‘Dimension of hidden vectors:’, hidden_dim)
print(‘Number of training stories:’, len(input_list))
print(‘Number of test stories:’, len(input_list))
print(‘-’)
print(‘Vectorizing the word sequences…’)
word_to_idx = dict((c, i + 1) for i, c in enumerate(vocab)) # 编码时需要将字符映射成数字index
idx_to_word = dict((i + 1, c) for i, c in enumerate(vocab)) # 解码时需要将数字index映射成字符
inputs_train, tars_train = vectorize_stories(input_list, tar_list, word_to_idx, input_maxlen, tar_maxlen, vocab_size)
decoder_mode = 1 # 0 最简单模式，1 [1]向后模式，2 [2] Peek模式，3 [3]Attention模式
if decoder_mode == 3:
encoder_top_layer = LSTM(hidden_dim, return_sequences=True)
else:
encoder_top_layer = LSTM(hidden_dim)
if decoder_mode == 0:
decoder_top_layer = LSTM(hidden_dim, return_sequences=True)
decoder_top_layer.get_weights()
elif decoder_mode == 1:
decoder_top_layer = LSTMDecoder(hidden_dim=hidden_dim, output_dim=hidden_dim
, output_length=tar_maxlen, state_input=False, return_sequences=True)
elif decoder_mode == 2:
decoder_top_layer = LSTMDecoder2(hidden_dim=hidden_dim, output_dim=hidden_dim
, output_length=tar_maxlen, state_input=False, return_sequences=True)
elif decoder_mode == 3:
decoder_top_layer = AttentionDecoder(hidden_dim=hidden_dim, output_dim=hidden_dim
, output_length=tar_maxlen, state_input=False, return_sequences=True)
en_de_model = Sequential()
en_de_model.add(Embedding(input_dim=vocab_size,
output_dim=hidden_dim,
input_length=input_maxlen))
en_de_model.add(encoder_top_layer)
if decoder_mode == 0:
en_de_model.add(RepeatVector(tar_maxlen))
en_de_model.add(decoder_top_layer)
en_de_model.add(TimeDistributedDense(output_dim))
en_de_model.add(Activation(‘softmax’))
print(‘Compiling…’)
time_start = time.time()
en_de_model.compile(loss=’categorical_crossentropy’, optimizer=’rmsprop’)
time_end = time.time()
print(‘Compiled, cost time:%fsecond!’ % (time_end - time_start))
for iter_num in range(5000):
en_de_model.fit(inputs_train, tars_train, batch_size=3, nb_epoch=1, show_accuracy=True)
out_predicts = en_de_model.predict(inputs_train)
for i_idx, out_predict in enumerate(out_predicts):
predict_sequence = []
for predict_vector in out_predict:
next_index = np.argmax(predict_vector)
next_token = idx_to_word[next_index]
predict_sequence.append(next_token)
print(‘Target output:’, tar_text[i_idx])
print(‘Predict output:’, predict_sequence)
print(‘Current iter_num is:%d’ % iter_num)
if __name__ == ’__main__‘:
main()

《漫谈四种神经网络序列解码模型【附示例代码】》上有 44 条评论

dapeng 在 2016 年 4 月 21 日下午 6:16 说道：

keras好用吗?

回复 ↓
- jacoxu 在 2016 年 4 月 21 日下午 6:30 说道：
  
  [笑cry]
  
  回复 ↓
ryan 在 2016 年 5 月 10 日下午 6:50 说道：

您好，我最近也在用KERAS，做LSTM的时候看到的例子一直是EMBEDDING，所以输入就是定长的，怎么才能实现输入不定长呢？谢谢您

回复 ↓
- jacoxu 在 2016 年 5 月 11 日上午 9:35 说道：
  
  您好，以文本为例，词的特征维度一般是定长的，词的个数可能不定长。在输入端比较好处理，用keras的话，输入特征用0进行补位，然后在Embedding Layer中的参数mask_zero=False 改为True就可以了。如果是输出端词的个数不定长，那么需要预测一个进行批量预测后进行裁剪。祝好！
  
  回复 ↓
  - ryan 在 2016 年 5 月 17 日下午 5:40 说道：
    
    谢谢您的回复，我理解您的意思是这样子，比如我输入输出的词数都不一样，我用100维的word2vec向量表示一个词，那如果输入最长的是10个词，输入三个词的时候就是300维，补上700维，到1000维。输出的时候全都输出1000维的向量，再去0，是这个意思吗？
    
    回复 ↓
    - jacoxu 在 2016 年 5 月 27 日下午 3:51 说道：
      
      你好，差不多是这个意思，先输出再裁剪，虽然不太优雅，但效率高。另，输出长度不一定要和输入长度一致，输出的最大长度可以单独定。
      
      回复 ↓
HUANMIE 在 2016 年 6 月 3 日下午 7:23 说道：

您好，非常感谢您分享的代码，我在用您的模型更换数据的时候，用的中文新闻，在输出target output 和predict output的时候，输出的并不是中文，而是一堆编码形式的类似于{‘Target output:’, ‘\xeb\xaf\xb8\xec\x93\xb0\xeb\xb9\x84\xec\x8b\x9c, \xea\xb2\xbd\xec\xa3\xbc\xeb\x8c\x80\xed\x9a\x8c\xec\x97\x90 \xeb\x9e\x9c\xec\x84\x9c \xec\x97\x90\xeb\xb3\xbc\xeb\xa3\xa8\xec\x85\x98 \xec\xa0\x9c\xea\xb3\xb5′)
(‘Predict output:’, “[‘quot’, ‘quot’, ‘quot’, ‘quot’, ‘quot’, ‘quot’, ‘quot’, ‘quot’, ‘quot’, ‘quot’, ‘quot’, ‘quot’, ‘quot’, ‘quot’, ‘qu} 这种形式的数据，是因为什么啊。我尝试改变编码或者运用decode（），encode（），但是都解决不了问题。。。。请您赐教

回复 ↓
- jacoxu 在 2016 年 6 月 4 日上午 9:26 说道：
  
  您好，可以尝试把代码187和188行中
  print(‘Target output:’, tar_text[i_idx])
  print(‘Predict output:’, predict_sequence)
  中的括号去掉，如
  print ‘Target output:’, tar_text[i_idx]
  print ‘Predict output:’, predict_sequence
  
  回复 ↓
HUANMIE 在 2016 年 6 月 30 日下午 5:36 说道：

您好，请问一下，如果encoder和decoder我不想只用一层，而分别想用两个隐层，应该怎么叠加啊，我看simpleseq2seq是有一个参数是depth，但是LSTMdecoder，Attentiondecoder好像没有depth这个参数啊，谢谢

回复 ↓
- jacoxu 在 2016 年 7 月 13 日下午 1:36 说道：
  
  你好，encoder可以累加多层，decoder如果想累加多层的话需要自己设计，无方便直接实现。
  
  回复 ↓
  - lyi 在 2017 年 7 月 28 日下午 5:11 说道：
    
    您好，请问encoder如何累加多层？谢谢
    
    回复 ↓
    - jacoxu 在 2017 年 7 月 29 日上午 9:08 说道：
      
      L166处，多add 几个encoder_top_layer即可。
      
      回复 ↓
      - lyi 在 2017 年 7 月 29 日下午 1:57 说道：
        
        报错：请指导
        RuntimeError: maximum recursion depth exceeded
ysl 在 2016 年 9 月 6 日下午 4:24 说道：

请问，可以用于中文文本处理吗，如果是中文文本处理需要修改色什么？

回复 ↓
- jacoxu 在 2016 年 9 月 7 日下午 11:10 说道：
  
  您好，可以直接处理中文。
  
  回复 ↓
minuoe 在 2016 年 10 月 11 日下午 10:54 说道：

你好，我想问一下代码显示：ImportError: No module named keras.models
是什么问题呢？

回复 ↓
- Gillian 在 2017 年 3 月 10 日下午 4:15 说道：
  
  你好，我还是新手小白，也遇到这样的问题了，请问你后面是如何解决的？谢谢
  
  回复 ↓
  - jacoxu 在 2017 年 3 月 11 日上午 8:40 说道：
    
    您好，应该是缺少Keras包，依赖的Keras和Seq2seq已经上传到Github上了，请从Github上下载了完整文件。
    
    回复 ↓
candy 在 2016 年 10 月 11 日下午 11:18 说道：

你好，有java的代码吗？

回复 ↓
- jacoxu 在 2016 年 10 月 17 日上午 10:00 说道：
  
  抱歉没有关注过，祝好！
  
  回复 ↓
sugger 在 2016 年 10 月 11 日下午 11:29 说道：

你好，我想问下运行出现
ImportError: No module named keras.models
这是什么问题？

回复 ↓
sugger 在 2016 年 10 月 12 日下午 9:30 说道：

请问运行提示
ImportError: No module named keras.models
是为啥呀？

回复 ↓
- jacoxu 在 2016 年 10 月 17 日上午 9:59 说道：
  
  请安装依赖包 Keras [建议0.3.x版本] 和 Seq2Seq
  
  回复 ↓
  - sugger 在 2016 年 10 月 17 日下午 7:55 说道：
    
    你好，如何观察训练过程呢？或者说那张图是怎么得来的呢？
    
    回复 ↓
zzkszzks 在 2016 年 10 月 17 日上午 11:17 说道：

写的真不错！！！再加点attention训练方式的更好。划重点的老师也各不一样？哈哈

回复 ↓
- jacoxu 在 2016 年 10 月 19 日上午 9:03 说道：
  
  哈哈。
  
  回复 ↓
sugger 在 2016 年 10 月 17 日下午 8:03 说道：

不好意思贸然打扰了，我现在在做这一块的研究，想更进一步请教些问题，请问可以发邮件给你或者有什么其他联系方式吗？

回复 ↓
- jacoxu 在 2016 年 10 月 19 日上午 8:59 说道：
  
  您好，我的邮箱 jacoxu@126.com
  
  回复 ↓
刘海在 2016 年 12 月 24 日下午 12:07 说道：

博主您好~ 您讲的四种模型挺清楚的，但是代码里import的那个seq2seq.layer是属于哪个module？我不太清楚这一点~

回复 ↓
刘海在 2016 年 12 月 24 日下午 12:07 说道：

博主您好~请问代码里import的那个seq2seq.layer是属于哪个module？谢谢~

回复 ↓
- jacoxu 在 2016 年 12 月 25 日下午 8:21 说道：
  
  最新的seq2seq包可能有改动，我将老版的seq2seq包 fork到了github代码中，应该可以直接下载运行。
  
  回复 ↓
Mei Dong 在 2016 年 12 月 24 日下午 2:27 说道：

您好，我想用于时间序列识别，输入是一总共10个月每隔五分钟的采样电压数据，想先对规定长度数据聚类，比如一天，一周，然后输入一段长度数据来识别，感觉和单词有相似之处，请问这方面可行么？

回复 ↓
Ken Deng 在 2017 年 1 月 13 日下午 2:35 说道：

非常感谢分享，受益良多！

好奇问一下。现有代码依赖 theano，有没有基于 tensorflow 的版本？

回复 ↓
- jacoxu 在 2017 年 1 月 16 日上午 11:03 说道：
  
  您好，该示例代码其实是基于Keras的写的，Keras既可支持Theano，也可支持Tensorflow，所以配置一下Keras应该可以在tensorflow上跑，祝好！
  
  回复 ↓
Snake 在 2017 年 2 月 26 日下午 5:43 说道：

LZ,你发布在Github上的代码是基于keras0.3的现在keras最新版是1.0的直接用会有什么影响吗？

回复 ↓
- jacoxu 在 2017 年 2 月 28 日上午 10:48 说道：
  
  您好，不确定keras是否向下兼容，一些接口可能会重新定义并命名，直接使用应该会报错，可根据错误信息修改下应该比较容易地在keras1.0版本上跑起来。
  
  回复 ↓
Freedom 在 2017 年 3 月 25 日下午 4:36 说道：

您好!
我对keras 的TimeDistributed wrapper 比较疑惑.
不清楚它实现了什么功能.
能麻烦您解释一下么?

回复 ↓
- jacoxu 在 2017 年 3 月 25 日下午 10:50 说道：
  
  LSTM的参数return_sequences=False则只返回(Batch, Hidden_dim)的向量，直接采用Dense全连接层即可，但是如果LSTM的return_sequences=True，则返回(Batch, Time_step, Hidden_dim)的向量，多了time_step的维度，那么一个(Hidden_dim, output_dim)的Dense层需要在Time维度上都计算一遍，那么就用到了TimeDistributed.
  
  回复 ↓
zhjia 在 2017 年 4 月 29 日下午 1:00 说道：

您好，我想做一个基于attention的分类模型，目标输出是1和0，请问怎么转化为您这个模型中的输出格式啊！

回复 ↓
- jacoxu 在 2017 年 5 月 1 日下午 6:44 说道：
  
  您好，分类问题目标文本序列固定为1，指导标签为类别标签即可。
  
  回复 ↓
Pingback 引用通告： –>>>深度学习 | _梦境
lyi 在 2017 年 7 月 29 日下午 2:46 说道：

你好，我使用tensorflow（0.11.0）为后端，跑脚本报错了：请指导~
File “encoder_decoder.py”, line 194, in
main()
File “encoder_decoder.py”, line 176, in main
en_de_model.compile(loss=’categorical_crossentropy’, optimizer=’rmsprop’)
File “/opt/.lyi/encoder_decoder-master/keras/models.py”, line 507, in compile
self.y_train = self.get_output(train=True)
File “/opt/.lyi/encoder_decoder-master/keras/layers/containers.py”, line 130, in get_output
return self.layers[-1].get_output(train)
File “/opt/.lyi/encoder_decoder-master/keras/layers/core.py”, line 737, in get_output
X = self.get_input(train)
File “/opt/.lyi/encoder_decoder-master/keras/layers/core.py”, line 241, in get_input
previous_output = self.previous.get_output(train=train)
File “/opt/.lyi/encoder_decoder-master/keras/layers/core.py”, line 1148, in get_output
X = self.get_input(train) # (samples, timesteps, input_dim)
File “/opt/.lyi/encoder_decoder-master/keras/layers/core.py”, line 241, in get_input
previous_output = self.previous.get_output(train=train)
File “/opt/.lyi/encoder_decoder-master/seq2seq/layers/decoders.py”, line 152, in get_output
self.b_o, self.b_x])
File “/usr/local/lib/python2.7/dist-packages/theano/scan_module/scan.py”, line 383, in scan
non_seqs.append(tensor.as_tensor_variable(elem))
File “/usr/local/lib/python2.7/dist-packages/theano/tensor/basic.py”, line 212, in as_tensor_variable
raise AsTensorError(“Cannot convert %s to TensorType” % str_x, type(x))
theano.tensor.var.AsTensorError: (‘Cannot convert to TensorType’, )

回复 ↓
sun 在 2017 年 8 月 9 日下午 4:20 说道：

您好，我运行代码报错了，win764 python3.5 keras0.3.0 theano0.9.0,无GPU
报错:AttributeError: module ‘theano’ has no attribute ‘gof’.考虑是因为版本不兼容的原因，想问一下，楼主用的什么平台及版本？谢谢！

回复 ↓
- jacoxu 在 2017 年 8 月 9 日下午 5:18 说道：
  
  您好，应该是win764, python2.7, keras0.3.3, theano0.8.0。
  
  回复 ↓

刻骨铭心

印入心底的点滴

漫谈四种神经网络序列解码模型【附示例代码】

《漫谈四种神经网络序列解码模型【附示例代码】》上有 44 条评论

发表评论取消回复

《漫谈四种神经网络序列解码模型【附示例代码】》上有 44 条评论

发表评论 取消回复

发表评论取消回复