seq2seq + attention_seq2seq+attention

1、思考几个问题：
    ① 为什么解码器 一般来说 需要与 编码器的 hidden_size 相同呢？

2、seq2seq + attention 注意的几个问题：
    ① 如果编码器 的 RNNCell 是LSTM ，那么它输出的高阶向量C（递归状态）的维度 = 2*hidden_size，而GRU 的C向量的
      维度 = hidden_size 

一、seq2seq 多层cell的基本结构

•          seq2seq 的应用场景

1、机器翻译
2、自动对话机器人
3、文档摘要自动生成
4、图片描述自动生成

二、attention 的作用

三、根据TensorFlow源码分析seq2seq+attention（LSTM为例）

1、encoder

    # Encoder.
    encoder_cell = copy.deepcopy(cell)
    encoder_cell = core_rnn_cell.EmbeddingWrapper(
        encoder_cell,
        embedding_classes=num_encoder_symbols,
        embedding_size=embedding_size)
    #进行类似特征提取，得出编码器的状态和输出
    encoder_outputs, encoder_state = rnn.static_rnn(
        encoder_cell, encoder_inputs, dtype=dtype)
 
    # First calculate a concatenation of encoder outputs to put attention on.
    top_states = [
        array_ops.reshape(e, [-1, 1, cell.output_size]) for e in encoder_outputs
    ]
    attention_states = array_ops.concat(top_states, 1)
    #batch_size*H*W*channel  

2、decoder

（1）decoder 上一时刻输出 hi-1 与 当前时刻输入yi-1 之间的转化关系

1、注意：
    1.1 以上这个过程只是 在预测的时候 才会执行该操作，由于预测的过程没有 label，解码器的输入 == 上一时刻解码器的输出
    1.2 seq2seq 在进行训练的时候，由于 存在label，所以当前时刻解码器的输入跟 label 有关，不再是上一时刻解码器
        的输出了，有两种方式：
            ① 使用 类似 抛硬币 概率选择输入，在 上一时刻解码器的输出与真实label中选择
            ② 直接采用 真实的 label 进行输入（为了纠错训练时解码器的输出，TensorFlow源码采用的是该方法）  

（2）decoder 加入 attention 机制的过程（TensorFlow）

• 注意：以下结构是TensorFlow内部源码的Attention的工作机制，与论文中的soft attention、hard attention、
•            local attention、self attention  的结构略有差异

     https://blog.csdn.net/qq_16555103/article/details/99760588  ---   soft attention、hard attention、 local attention  

•         结合源码分析 

注意要点：
    decoder 输入为 GO 的时刻，此时的attention向量C 是 初始化为 0向量 来计算的，即将 0向量与 GO合并做 Linear 得到真
        正的输入x，再做 .cell(x,state)，之后的计算方式与上述一样

（3）上述 (2) 中 attention 状态 TensorFlow的计算方式

•               理论公式：

•     求解value（TensorFlow LSTM 中 value向量 = key向量 = 每个时刻 编码器的输出 ht）的权重向量 α 

•     求解 attention 向量  

               https://blog.csdn.net/sdu_hao/article/details/88167962   -------------------  权重score 向量α 的计算方法

•     根据TensorFlow 源码分析 attention 向量的计算方式 

================== TensorFlow 计算 attention 的源码
with variable_scope.variable_scope(
      scope or "attention_decoder", dtype=dtype) as scope:
    dtype = scope.dtype
 
    batch_size = array_ops.shape(decoder_inputs[0])[0]  # Needed for reshaping.
    #attention_state是编码器传递的,attn_length句子的长度
    attn_length = attention_states.get_shape()[1].value
    if attn_length is None:
      attn_length = array_ops.shape(attention_states)[1]   #5句子长度
    attn_size = attention_states.get_shape()[2].value      #512字向量长度
 
    # To calculate W1 * h_t we use a 1-by-1 convolution, need to reshape before.
    hidden = array_ops.reshape(attention_states,    
                               [-1, attn_length, 1, attn_size])
    #(?,5,1,512)   1：为了卷积加的维度[batch_size,H,W,Channel]
    hidden_features = []
    v = []
    #attention_vec_size 512
    attention_vec_size = attn_size  # Size of query vectors for attention.   k为PPT中的U
    for a in xrange(num_heads):
      k = variable_scope.get_variable("AttnW_%d" % a,
                                      [1, 1, attn_size, attention_vec_size])
      hidden_features.append(nn_ops.conv2d(hidden, k, [1, 1, 1, 1], "SAME"))
      #hidden_features为PPT中U*(h1,h2,...)，attnV为PPT中的v
      v.append(
          variable_scope.get_variable("AttnV_%d" % a, [attention_vec_size]))
 
    state = initial_state    #编码器递归最后一个隐藏状态作为解码器的初始递归状态
 
    def attention(query):     #query是(递归状态:(state))，两层模型
      """Put attention masks on hidden using hidden_features and query."""
      ds = []  # Results of attention reads will be stored here.
      if nest.is_sequence(query):  # If the query is a tuple, flatten it.
        query_list = nest.flatten(query)
        for q in query_list:  # Check that ndims == 2 if specified.
          ndims = q.get_shape().ndims
          if ndims:
            assert ndims == 2
        query = array_ops.concat(query_list, 1)
      for a in xrange(num_heads):
        with variable_scope.variable_scope("Attention_%d" % a):
          y = linear(query, attention_vec_size, True)             #pre_hiddent_state*W
          y = array_ops.reshape(y, [-1, 1, 1, attention_vec_size])
          # Attention mask is a softmax of v^T * tanh(...).
          s = math_ops.reduce_sum(v[a] * math_ops.tanh(hidden_features[a] + y),
                                  [2, 3])
          a = nn_ops.softmax(s)
          # Now calculate the attention-weighted vector d.
          d = math_ops.reduce_sum(
              array_ops.reshape(a, [-1, attn_length, 1, 1]) * hidden, [1, 2])
          ds.append(array_ops.reshape(d, [-1, attn_size]))      #ds表示大框attention
      return ds

2、seq2seq + attention 过程小结

test():
1. s2s.py --> create_model()
   1). s2s_model.py --> 实例化S2SModel对象：a. 定义了两层BasicLSTMCell，维度512, 组成cell；
                                        b. 定义了embedding的权重矩阵，定义了输出的权重矩阵
                                        c. 根据最大桶设置placeholder的长度，同时放到编码和解码器输入链表中
                                        d. 解码器的预测输出就是targets
                                        e. 三大关键代码：sampled_loss编写loss函数；seq2seq_f包含seq2seq和attention;
                                                         model_with_buchets内部每个桶用到了seq2seq_f和sampled_loss
 
   2).与3大关键代码相关：a.首先执行的是model_with_buckets[seq2seq.py是源代码]：组装了seq2seq_f
                        a.其次执行的是seq2seq_f-->
                          embedding_attention_seq2seq[seq2seq.py]:1. 对输入进行embedding，实际是加在cell上，与cell绑定，
                                                                     rnn.static_rnn构建了编码器
                                                                  2. 构建解码器，将全链接输出与最后一个解码器cell绑定，
                                                                  --->
                        b. embedding_attention_decoder[seq2seq.py]:1. 将解码器的embedding需要的w变量初始化
                                                                   2. 将解码器的预测6865输出映射到vc，找出相应的字进行embedding，
                                                                      作为下一个时刻解码器的输入
                                                                      attention出现--->
 
                        c.attention_decoder[seq2seq.py]:1.解码器的从输入到预测输出，在将该输出作为下一个时刻输入的运行过程
                    
                                                        2.attention机制是怎么引入的：
                                                           1.attn_length是句长、attn_size是字的向量长
                                                           2.[-1,attn_length,1,attn_size] 分别是句数(图片数),
                                                             句子长(H),无意义(w),句向量(通道)
                                                           3.hidden就是h1,h2,...
                    d. 最后：执行的是model_with_buckets[seq2seq.py是源代码]： 组装了sampled_loss[s2s_model.py]:
                       调用tf.nn.sampled_softmax_loss
 
 
训练与预测不同的地方：
	第一：seq2seq_f 的参数do_decode 在训练的时候输入 False，在预测的时候输入True，即更改 feed_previos 的 bool参数：
                         预测的时候  loop_function = _extract_argmax_and_embed(embedding, output_projection,update_embedding_for_previous) if feed_previous else None
                         训练的时候 loop_function 选取 解码器输入 真实target  进行输入，而不是选取 解码器上一个时刻 输出 作为输入。
                第二：训练过程多了一个 BP过程
                第三：模型的输出结果不同：
                          if not forward_only:
           		 return outputs[1], outputs[2], outputs[3:]      # 训练过程输出： 更新后的 w,b          w,b的梯度 delta（w,b）      loss（损失函数的大小）
                          else:
            		 return None, outputs[0], outputs[1:]       # 预测的返回值：None 、loss（预测时困惑度的评估）、seq2seq网络真实的输出结果

四、seq2seq 经验值

1、seq2seq 处理长句子
    小技巧：将源句子顺序颠倒后再输入Encoder 中，比如源句子为“A B C”，那么输入 Encoder 的顺序为 “C B A”，经过这
           样的处理后，取得了很大的提升。

五、基于seq2seq + attention 聊天系统 优化

bug fix:   程序BUG
 1. /->tf.div  （ TensorFlow 中 除法 不要直接用  /）;    *->tf.mul
 
 change and optimize:
 1.gradient :    adamoptimizer(*)                                         seq2seq_model
 2.modify participle                                                
 3.learning_rate_decay_op                                                 seq2seq_model
 
 add:      优化
 1.swift cpu&gpu by the global_-->DEV_FLAG                                global_
 2.add dropout just for input;maybe you like drop output and change       seq2seq_model
 3.add epoch                                                              train(lib)
 4.add Chinese chat                                                       _*_
 5.add tensorboard loss-show                                              seq2seq_model
 6.add the 5th min loss point                                             lib/trian for model   # 保
                                                                       存loss下降 5个 局部最优点
 7.add stop early criteria                                                lib/trian      # earty_stop
 8.add L2 regularization                                                  seq2seq_enhance linear_function_enhance
 9.add the current loss point                                             --for training breakpoint

------------------------------------------------------------------ 常见的优化 --------------------------------------------------------------------------------------
 
 ********** 10.add stop_word                                                         _*_                             目的：可以提高模型的效果
          "呀 吗 吧 呢 呵 呃 呕 呗 呜 哎 唉 啊 啦 的 得 地 你 了 ， ？ ！ ! ? 、 。 , ~ ."
		原因：seq2seq 本质上是一个概率模型，模型偏向于频率较高的词汇，但是像 语气词、代词、标点 ...  这些词在 QA对话中 没有什么意义，但是频率很高，因此需要对其进行停止词。
	         注意：停止词通常只有对 Q 序列进行操作，而A 序列不进行操作，因此停止词不能用于VC表内部，应当在内存中对序列进行匹配，在输入网络之前去除。
                 tip：停用表用的是字典trie，字典 key hash，搜索速度较快。
			eg ：    Q  你明天还会来吗？                                        Q  明天还会来
		                        A  当然呀！                         >>>>>>>>>      A   当然呀！
 
*********** 11. stride ----> 2、3 【卷积核的步子、跳帧（语音独有）】                                               目的 ： 加速网络的运行速度    dfsmn
12. 卷积核的设计【3*5 ----> 11*21，将对称的设计为非对称】                                            目的：增加模型的抗噪声能力
13. 网络层数【VGG变体】
14. 网络结构【普通cnn ---> inception/resnet结构】                                                           也可能是调参  
15. Bilstm ---->row conv    # 思想：用 行卷积 代替 双向LSTM，加速模型速度                                                                                                deepspeech2
*********** 16. 使用jieba分词的embeding 效果好于 直接使用 字 embeding
*********** 17. 添加并调整 dropout 
*********** 18. sorted words cut                                             按照词频对词进行排序
 		optimizing:
 		1.cancel the redundant punctuation and right side
 		2.
 
 
 debug:   调参
 1. unit_size 2048    bath_size  256                                      OOM（程序持续运行，没有终止）
 2. unit_size (256->64) unit_size(2048->256)              
 3. lr(0.5->0.1) bath_size(64->10) unit_size(256->300) (split("[]/'?.")->split(" "))
 4. lr(0.1->0.001) bach_size(10->32) unit_size(300->500)                  En--overfitting
 5. lr(0.001) min_lr(0.00001) bach_size(10) unit_size(100)                Ch--fine 

语料的预处理：
0. 爬取                              --------- 源：① 微信/QQ 聊天 ② 微博对话 ③ 百度知道、知乎..... ④ 电影对白、话剧对白
*********** 1. 去重                              ---------- QA 重复 或者 作用相近，例： 你好 与 你好！  等等                               方法：查询百度
*********** 2. 清洗--违禁词与长句        ---------- 网络上有 违禁词表（含有违禁词，删除QA）
3. 人工校对                                       ----------- 正规公司内部有专业校对人员
*********** 4. 数据扩增                      ------------- 仿真现实对话，用于模拟常见的真实回答 与 ‘艺术感’的感性回答  
                        原因：因为爬取的数据来源不同，对话运用的场景不同，根据业务进行数据扩增。
                              由于语料中可能存在 Q相似而答案比较突兀的回答，因为这些回答可能有之前对话的场景，
                              而模型预测的时候需要大概率回答正常的answer，小概率会‘艺术性’answer，这时
                              候就要对 QA进行语料扩增。如下所示：
			Q      你好                                                                     Q     你好
			A      你好 			                                                A      你怎么来这么早
                     扩增： 30倍（语料库中扩展30次，但是需要随机插入                
                                            到语料中，不可连续出现）		                  扩增：5倍		  
			常见对话 30倍 ....                                                           不常见话剧对话  5/10倍
           tip： 之所以要用‘艺术性’answer是为了让模型看起来不太‘呆滞’，具有人情味。