操作系统线程之间的通信是一个很重要的问题，在用 C 语言在 Linux 实现经典的“生产者和消费者”以及“读者写者”问题时产生了一些疑惑，记录之。

Problem

进程间通信的需要解决的核心问题就是线程之间的同步，比如说，有一个程序，两个线程同时对一个共享变量 cnt 分别进行 n 次加法操作，如果其初始值为 0 的话，那么正确的运行结果应该是 cnt = 2n，但如果我们在一台单 CPU 的机器上运行的话，结果往往不是 2n。为什么呢？因为机器可能不会按照我们思考的方式去执行这样的指令，一种很容易想到的产生错误的方式就是：一个线程修改了值（对 cnt 进行加 1 ）之后还没写回去，这个时候另一个线程就读到了 cnt 的旧值并且在旧值之上进行了更新操作，二者都写回去的时候，cnt 的值只加一而不是加二。一个显而易见的解决方式就是将各自的操作都变成原子化，也即一个线程带来的任何改变都能被另一个线程所感知到，不过这样带来的 overhead（额外开销）过大，对性能是个很大的影响。因此伟大的计算机科学家们提出了两个概念用于解决这个问题，分别是 mutex（互斥量）和 semphore（信号量）：

Strictly speaking, a mutex is a locking mechanism used to synchronize access to a resource. Only one task (can be a thread or process based on OS abstraction) can acquire the mutex. It means there will be ownership associated with mutex, and only the owner can release the lock (mutex).

Semaphore is signaling mechanism (“I am done, you can carry on” kind of signal). For example, if you are listening songs (assume it as one task) on your mobile and at the same time your friend called you, an interrupt will be triggered upon which an interrupt service routine (ISR) will signal the call processing task to wakeup.

互斥量是一把锁，用于控制对资源的访问，同一时间只有一个线程能够获得这把锁，也只有获得锁的线程才能够释放这把锁；信号量是一个信号，用于线程之间的通讯。特别地，信号量 s 有两种操作：

• P(s)：如果 s 非零，则将 s -1 并返回；如果 s 为 0，则挂起该线程，直到 s 非 0，一般来说，是等待 V 操作的通知。
• V(s)：V 操作将 s + 1。如果有任何线程阻塞在 P 操作等待，则 V 操作会通知折线线程中的一个，让他苏醒完成 s - 1 操作。

这里几点需要注意：

1. P 和 V 操作都是原子化的，也就是说检测信号值、执行操作、写回信号值这三个子操作时不可能被打断的。也只有这样，P、V 操作才有意义。
2. V 操作唤醒等待线程时是随机的，我们无法预测哪个线程会苏醒，这里没有先来先走的事情存在

概念就先介绍到这里，可能还有一些不清楚的地方，就结合接下来的两个问题的代码实现，再进一步的讲解。
more >>

先抛出我的结论：

SeqGAN 这一框架下的 GAN-based 文本生成模型，work 很大程度上是 training trick 的堆砌，并不适合工程应用，但依旧值得探索，或者蹭热点发 Paper。

这段时间做用 GAN 做文本生成还是蛮多的，这里指的是 SeqGAN 这一框架，其简要特点如下：

1. RNN-based Generator + Classifier-based Discrminator：用一个 RNN 来建模 language model； CNN 之类分类器来对生成的文本/真实文本进行判别，或者是对文本的某种属性进行判定
2. 利用 MLE 进行 Pretrain：让 G 和 D 具备初始的能力
3. 利用 Monte Carlo 来得到 reward，通过 Policy Gradient 指导 Generator 更新

起初我也是为止着迷，认为这一框架非常 fancy，但是随着时间推移，跑了不少实验之后发现，adversarial training 在其中起到的作用实在是微不足道（对比之前的 MLE pretrain，adversarial training 并不会带来生成文本质量的显著提升），为什么呢？接下来谈一下 Adversarial Training 在 Text Generation 中的两个主要的问题。

Problem

Sparse reward

adversarial training 没起作用很大的一个原因就在于，discriminator 提供的 reward 具备的 guide signal 太少，Classifier-based Discriminator 提供的只是一个为真或者假的概率作为 reward，而这个 reward 在大部分情况下，是 0。这是因为对于 CNN 来说，分出 fake text 和 real text 是非常容易的，CNN 能在 Classification 任务上做到 99% 的 accuracy，而建模 Language Model 来进行生成，是非常困难的。除此以外，即使 generator 在这样的 reward 指导下有一些提升，此后的 reward 依旧很小。从这一点出发，现有不少工作一方法不再使用简单的 fake/true probability 作为 reward，我在之前的 GAN in NLP Notes 中也提到了有 LeakyGAN（把 CNN 的 feature 泄露给 generator），RankGAN （用 IR 中的排序作为 reward）等工作来提供更加丰富的 reward；另一个解决的思路是使用 language model-based discriminator，以提供更多的区分度，北大孙栩老师组的 DP-GAN 在使用了 Languag model discrminator 之后，在 true data 和 fake data 中间架起了一座桥梁：

从而 discriminator 不再是非 0 即 1。据其他同学的一些经验，DP-GAN 的实验效果也是非常不错的，这一点或许可以和之前的两个数据流型分布中间没有交集有关，使用了更 distinguishable 的 reward 之后，fake data 的分布和 true data 的分布加大了，GAN 的距离度量才有了变化。

Monte Carlo Search

在 SeqGAN 以及后续的很多工作之中，对于 Reward 的评估都是基于句级别的，也就是会先使用 Monte Carlo Search 的方法将句子进行补全再交给 Discriminator，但是这个采样方法的时间复杂度是 $O(n mL^2)$，其中 $n$ 是 batch size，$m$ 是采样的次数，$L$ 是句子的 max len。就 SeqGAN 的实验来说，$m = 16$ 并且 $L=20$ ，速度尚且可以接受，但是如果我们需要去生成一篇文章 $L=200$，那么每次计算 reward 就会来带很大的开销，我个人的体验是在 Tesla M40 上 $L$ 在 100 左右，$m = 16, n = 64$ 一个 batch 需要 230 s。对于常见的万级别的 corpus，一个 Epoch 的训练时间就到了一天，而最终对于性能的提升还不如 MLE 一个 epoch 来的显著，这也是我为什么不建议在工程上使用的很大程度的一个原因。

Solution

• Sparse Reward：这里可以用的除了 DP-GAN 以外，SentiGAN 也是一个不错的尝试，其 Penalty-based objective function 效果还是很不错的，可以尝试着使用一下；另外，我们也可以从 discriminator 的角度，适当地减弱其能力，像 GAN 中的一些 trick 比如 label smothing 也可以尝试。
• Monte Carlo Search：这一点的解决方法比较困难，MaskGAN 提出用 Actor-Critic 的结构来对 word level 给出 reward，并且在其“完形填空”的任务上效果不错，但对于语言模型来说， word-level reward 还是不怎么符合 intuition。降低 sample time 并不是一个可取的方案，因为本身 MC 带来的 variance 已经很大了，再降低 sample time 只能是雪上加霜；或许搜索的剪枝是一个可以考虑的方向，会去看看有没有一些方案。

Future

展望一下未来，只能说 SeqGAN 这个坑不出意外还会吸引很多同学义无反顾地往里跳，想要做出一些东西，还是很有挑战性的。但是 RL 和 NLP 结合的思路是没什么大毛病的，Jiwei Li 最近的几篇 Dialogue 的文章也都是用着 RL，我觉得这一点很 fancy 的一个原因是我们可以通过设计 reward 来指导生成，这其实是蛮 hand-crafted 的，把规则比较隐式地放进神经网络里，或许 RL 是一条可以走的路；IRL 在 Text Generation 上的应用邱锡鹏老师也有一篇文章。希望自己也能够在这条路上走地更远一些~

缘起

Seq2Seq 的 TensorFlow 实现有很多，而 TensorFlow 之前也推出了一套新的 API，文档依旧是令人蛋疼地杂乱。最近在用新的 API 写一个 Many2Many 结构的 Seq2Seq，踩到了一个坑，记录之，也进一步地提醒我应该把主力框架迁移到 PyTorch 提上日程了。

问题描述

根据示例，只要把 encoder 和 decoder 拼接起来，并且使用 TrainingHelper + BasicDecoder：

1
2
3
4
5
6
7
8
9
10

# 省略参数
helper_pt = tf.contrib.seq2seq.TrainingHelper()
decoder_pt = tf.contrib.seq2seq.BasicDecoder()
outputs_pt, _final_state, sequence_lengths_pt = tf.contrib.seq2seq.dynamic_decode()
# logits
logits = outputs_pt.rnn_output 
# loss
loss = tf.contrib.seq2seq.sequence_loss(logits, target, target_mask,
                    average_across_timesteps=True,
                    average_across_batch=False)

其中 logits 是 vocab_size 上的分布，shape 为 [batch_size, ?, vocab_size]

而 target 则是正确的输出，这里我将其做了 padding，补齐到最大长度，shape 为 [batch_size, max_len]，target_mask 是对应的一个权重，非补齐的部分才会参与到 loss 的计算。

如果不 Padding，则会在 feed_dict 这一步报错：

ValueError: setting an array element with a sequence.

因为 target_input 的长度是变长的 ，NumPy 无法将其视作一个 array，导致错误。

然后问题就来了，sequence_loss 函数报错，说其内部调用的 sparse_soft_max 函数的 labels 和 logits 第一维不匹配，其中：logits 的形状为 [?, vocab_size] ；label 的形状为 [batch_size x max_len]

为什么会这样呢？来进一步的分析分析

Source Code

首先是看一下 sequence_loss 的源代码：

1
2
3
4
5
6
7

with ops.name_scope(name, "sequence_loss", [logits, targets, weights]):
   num_classes = array_ops.shape(logits)[2]
   logits_flat = array_ops.reshape(logits, [-1, num_classes])
   targets = array_ops.reshape(targets, [-1])
   if softmax_loss_function is None:
     crossent = nn_ops.sparse_softmax_cross_entropy_with_logits(
         labels=targets, logits=logits_flat)

先是对 logits 和 labels 做了 reshape 操作，之前的形状也能对上，也就是说 logits reshape 之后的 ? = ? x batch_size ，那么这个 ? 究竟是是什么呢，不出意外，应该是生成的序列长度，但为什么是不定长的呢？

来看看 TrainingHelper 的核心源代码:

1
2
3
4
5
6
7
8
9
10
11

# TrainingHelper
def next_inputs(self, time, outputs, state, name=None, **unused_kwargs):
      next_time = time + 1
      finished = (next_time >= self._sequence_length)
      all_finished = math_ops.reduce_all(finished)
      def read_from_ta(inp):
        return inp.read(next_time)
      next_inputs = control_flow_ops.cond(
          all_finished, lambda: self._zero_inputs,
          lambda: nest.map_structure(read_from_ta, self._input_tas))
      return (finished, next_inputs, state)

next_inputs 函数是 RNN 不断获取下一步的迭代函数，其中 finished 相当于指示了当前的时间步是否已经超出最大长度，即 self._sequence_length 一个记录目标输出长度 int32 向量。reduce_all() 是对某一个维度求逻辑与，如果没有指定 axis 参数，则是对所有元素进行与运算。由此，我们可以得知：当未运行至 target 目标时间步时，会用 Groud-Truth 作为下一个的输入，否则则为 0。但这里并没有给出什么时候停止，所以进一步地，看看 decoder 在哪里调用这个的函数：

1
2
3
4
5
6
7
8
9
10
11
12
13

def step(self, time, inputs, state, name=None):
    cell_outputs, cell_state = self._cell(inputs, state)
    if self._output_layer is not None:
        cell_outputs = self._output_layer(cell_outputs)
    sample_ids = self._helper.sample(
    time=time, outputs=cell_outputs, state=cell_state)
    (finished, next_inputs, next_state) = self._helper.next_inputs(
              time=time,
              outputs=cell_outputs,
              state=cell_state,
              sample_ids=sample_ids)
    outputs = BasicDecoderOutput(cell_outputs, sample_ids)
    return (outputs, next_state, next_inputs, finished)

这是 decoder 的 step 函数，相当于对 helper 进一步地封装，以便使用一些功能（TrainingHelper 是训练时 feed groud-truth，在 inference 阶段会使用 GreedyEmbeddingHelper 在无 Groud-Truth 帮助下进行生成等）。再向上，我们去看 dynamic_decode 的函数：

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
26
27
28
29
30
31
32
33
34
35

# dynamic_decode 为了节约篇幅，仅保留重要的代码
def dynamic_decode():

    initial_finished, initial_inputs, initial_state = decoder.initialize()

    def condition(unused_time, unused_outputs_ta, unused_state, unused_inputs,
                  finished, unused_sequence_lengths):
      return math_ops.logical_not(math_ops.reduce_all(finished))

    def body(time, outputs_ta, state, inputs, finished, sequence_lengths):
      (next_outputs, decoder_state, 
       next_inputs, decoder_finished) = decoder.step(time, inputs, state)
		# next_finished 是 decoder_finished 和 finished 的 or
      next_finished = math_ops.logical_or(decoder_finished, finished)
      next_sequence_lengths = array_ops.where(
          math_ops.logical_not(finished),
          array_ops.fill(array_ops.shape(sequence_lengths), time + 1),
          sequence_lengths)
      return (time + 1, outputs_ta, next_state, next_inputs, next_finished,
              next_sequence_lengths)

    res = control_flow_ops.while_loop(
        condition,
        body,
        loop_vars=(
            initial_time,
            initial_outputs_ta,
            initial_state,
            initial_inputs,
            initial_finished,
            initial_sequence_lengths,
        ),
        parallel_iterations=parallel_iterations,
        maximum_iterations=maximum_iterations,
        swap_memory=swap_memory)

这里，总算看到了我们要的 while loop，循环的控制变量是 finished，而其又 是 decoder_finished 和 finished 的逻辑或所得到，所以可以得出：当 decoder 解码到 sequence_length 时，其才会停止；另一方面，因为一个 batch 中的长度不都相同，所以得到的 dynamic_length 应该是某个 batch 中最长的一句的长度，到了这里，问题总算是知道根源所在了，那么，怎么解决呢？

Solution

GitHub 上有人提出过这个问题 Issue ，并且有很长的讨论，有一个比较粗暴的解决方案，在无法喂给它 padding 之前的情况下，对 target 做一个截取，因为之前的研究能够让我们确信生成的序列的长度是一定小于等于 batch 中 target 最长的长度的，所以：

1
2
3
4
5
6

# 获取当前的长度，max_len 和 logits 的较小者，事实上，我们可以认为就是 logits 的长度
current_ts = tf.to_int32(tf.minimum(tf.shape(self.target_input)[1], tf.shape(logits)[1]))
# 对 target 进行截取
target_sequence = tf.slice(self.target_input, begin=[0, 0], size=[-1, current_ts])
mask_ = tf.sequence_mask(lengths=self.target_len, maxlen=current_ts, dtype=logits.dtype)
logits = tf.slice(self.logits_pt, begin=[0, 0, 0], size=[-1, current_ts, -1])

截取之后，就可以保证二者的长度一致，再使用sequence_loss() 计算就可以了。

另外有一个疑问就是，有些代码是可以运行不会报错（网上 Seq2Seq 的教程都是这么写的），猜测是输入数据的格式问题，日后碰到了再提。

记录最近读的一些文本生成相关的 Paper。

Sentiment Modification

这是一个比较有趣的问题，定义如下：

The task of sentiment modification requires re- versing the sentiment of the input and preserv- ing the sentiment-independent content.

但是存在几个难点：

1. 没有 Parallel 的语料，比如“松林食堂的生煎很好吃”是 positive 的，对应的 negative 例子可能就是“松林食堂的生煎不好吃”，而这种语料是很难成 pair 出现的。
2. 没有平行语料，可能说，那我们把情感词直接换成 opposite 是不是就可以了，可能上面的例子可以 work，但是这个 “The food is cold like rock” 变成 “The food is warm like rock”就很不恰当了。

为了解决这两个问题，孙栩老师组有两篇 Paper，尝试通过不同的方式来实现 Sentiment Modification 这一任务，而其核心都是通过将句子去极性后，在进行极性的添加或者说是修改。
more >>

在从 DeeCamp 回来的高铁上，翻着开复老师新书内部版的我，想到大二就这样结束了，一些瞬间从脑海中闪过，拿出手机，开始码字。

从最近的事情说起吧，刚结束的中国高校人工智能夏令营，我作为为数不多的大二学生之一，带领团队做出了能够欺骗开复老师眼睛的嘻哈歌词机器人。虽说有一定讨巧成分，但这个应该够我吹一年了。在夏令营听了各路大咖老师的讲座，也和一线的工程师老师一起为项目奋斗了一个月，收获不必说，更多的是眼界上的开阔。我现在觉得当初选择拥抱人工智能的决定无比正确，未来十年，是属于AI的十年，不拥抱浪潮的结果就是被取代。去年暑假也随学院队伍去了深圳，但那时候的我们都是无名之辈，大公司都不愿意待见；这次，300名营员中不仅清北复交满地走（甚至很多人没听说过西电），还有KDD（世界顶级数据挖掘会议）比赛冠军和顶会作者，甚至少年班的天才也有几个。虽然西电层次不高，但出来的同学们也都是非常优秀，给学校涨了不少脸。如此质量的生源，待遇自是不可同日而语：HR 亲切问候，恨不得马上把我们抓到公司去；各大独角兽公司也都敞开大门，拿出如数家珍生怕在这里掉了价。跳出西电这一隅，发现原来外面的世界这么大，有那么多优秀的同学在向着同一目的地奋力前进，我感到很高兴，也很自豪能和他们成为伙伴。

再谈谈科研方面，进展如期，相信用不了就会出结果，虽然不是顶级会议期刊，却也是我迈出的第一步。这次夏令营也从很多同学身上做到了做研究的方法，更多是方法论的东西，也是学长学姐的血汗经验，之前也有提到，尝试用在下一篇作品上，相信会更上一层楼。另外，西电做自然语言处理的同学不多，一度让我觉得很孤独。而在北大的一个月，到计算语言所和清华智能实验室都蹭了报告，我了解到，人不多一方面是因为西电的传统（主要做雷达出身，遥感图像领域），还有一方面是因为问题很多，很难解决；并且自然语言处理处在上升的阶段，这颗人工智能皇冠上的明珠在不久的将来就能释放其巨大的能量。选择投身于此，学术上努力做一些创新的基础工作，未来工作后将其应用在各种产品之上进行落地，造福全世界的所有人，是多么有意义的事情啊。

最后，竞赛和成绩方面。去年觉得要在竞赛上下点功夫，今年也在意料之中的，拿了一些奖项。其实最初的目的就是不想让简历上显得太过寒碜。现在心态好很多，因为参与过之后，发现很多竞赛水分很大，拿奖与否更多是一个运气问题，而非实力问题。当然，做到最好同样是需要付出很大努力的，这一点毋庸置疑。在成绩方面，是看得越来越淡：100分和99分是一样的，98分和95分也没多大差别，重要的是自己从中有所收获。GPA 只是衡量一个人的一个方面，但他也仅仅是一个指标而已，太过功利于己与人都不好；并且，换个角度，GPA的投入产出比太低了，为了那么一两分削减脑袋 还不如多读两本书看两部电影或者是两篇Paper呢。

Future

打铁还要自身硬，接下来的四个学期，要做的事情其实很简单：

• 把手头的工作做好，保持和老师的联系，希望能拿到一张保研的入场券
• 没有体育课了，主动增加运动量，避免读了四年书胖了四十斤这种尴尬的事情发生在我的身上（逃
• 提升算法能力

顾城曾说：

一个彻底诚实的人是从不面对选择的，那条路永远会清楚无二地呈现在你面前，这和你的憧憬无关，就像你是一颗苹果树，你憧憬结橘子，但是你还是诚实地结出苹果一样。

知道自己要走的路了之后，就一往无前吧~

前言

非常有幸参与了 2018 Dee Camp 人工智能夏令营，在这一个月的时间里面，我们享受了来自学界、业界各种大咖的分享，同时也和导师一起参与到一个项目中，将所学知识进行落地。我们组的题目是 AI 有嘻哈，利用相关技术进行嘻哈歌词的生成。

先来看看模型的效果，给定第一句，生成接下来的几句，猜猜下面哪句是模型生成的哪句是原作？

不是乐理专修 做点儿曲式研究 我们的力量来自宇宙 自己的节奏

不是乐理专修 所有听的观众 打破他们传统 进到环球 继续让你感受

再来一个：

自己就带上了有色眼镜 金钱摧毁多少事情 瓦解你的中枢神经

自己就带上了有色眼镜 我只想把世界分的更清 却发现自己却模糊了心

正确答案是：第一行都是模型生成的，第二行是原作，你答对了吗？有没有被惊艳到，我们组内的测试结果显示，大家的正确率不超过 30%，值得一提的是：输入都是来自于测试集中，没有参与到模型的训练中。

因为某些原因，代码和数据暂时无法开源，以后有机会会整理出来。

更多的例子和项目的代码已经上传到 Github，欢迎大家 Star。

数据

创新工场的导师为我们提供了 10 w 条嘻哈歌词，并且已经将一些不符合社会主义核心价值观的句子标注了出来。数据的预处理主要步骤如下：

• 在对句子进行筛选之后，我们利用 Jieba 进行分词，观察到单句长度集中在 8~10 左右；
• 在利用 Tensorflow 中的 Tokenizer 进行 tokenize 并构建 word2idex 字典后，词表大小在 11000 左右，考虑到这个大小还可以接受，没有做限制词表大小的操作；
• 利用 pad_sequence 将句子 padding 到 20（和 SeqGAN 中相同）；
• 构建 x-y pair，利用上一句预测下一句（导师后来建议可以借鉴用 Skip-gram 的思路，同时预测上一句和下一句，但没有时间去尝试了），分割数据集

知道大家都不喜欢洗数据，所以我们的训练数据也已经放到了 Google Drive，大家自取即可。

模型

我们的生成模型的整体基于 SeqGAN，并对其做了一些修改，模型架构如下：

主要改动有两点：

1. 增加输入语句的编码：这一点类似 Seq2Seq 的 Encoder，SeqGAN 原本的 initial state 是全 0 的，为了将上文的信息传递给生成器，我们采用了一个简单的全连接层（Fully Connected Layer），将输入句子的 Word Embedding 经过一个线性变化之后作为生成器的 LSTM。事实上也可以尝试使用 RNN（LSTM）来作为 Encoder，不过这样模型的速度可能会比较慢。

2. 将原先 Generator 的 Loss Function 改为 Penalty-based Objective：在训练模型的过程中我们发现，模型在 Adversarial Training 多轮之后出现了严重的 mode collapse 问题，比如：

   别质疑自己
   遮罩错的消息不要过得消极
   世间人都笑我太疯癫
   世间人都笑我太疯癫

   ​

   守护地狱每座坟墓
   世间人都笑我太疯癫
   你不知道rapper付出多少才配纸醉金迷
   世间人都笑我太疯癫

   ​

   但却从来没有心狠过
   如果你再想听
   你不知道rapper付出多少才配纸醉金迷
   你不知道rapper付出多少才配纸醉金迷

   可以看到 世间人都笑我太疯癫 和 你不知道rapper付出多少才配纸醉金迷 占据了我们生成的结果。mode collapse，简单来说就是输入的改变不会影响生成的结果。为此我们调研了一些 Paper，最终采用了SentiGAN 中提出的 Penalty-based Objective Function：

   

   SeqGAN 是将原先 Discriminator 的认为 Generator 生成句子为真的概率作为奖赏，Generator 通过最大化奖赏（最小化其相反数）来更新自己的梯度；而 SentiGAN 则恰好相反，将 Discriminator 判断为假的概率作为惩罚，Generator 通过最小化惩罚来更新自己，并且去掉了概率上的 log 函数。作者分析其起作用的效果在于：一、去掉 log，可以视作 WGAN 中的 generator loss（这一点我持怀疑态度，因为代码中并没有对梯度进行裁剪来满足 WGAN 所需的 Lipschitz 条件）；二、惩罚和奖赏存在一个 $1- V = D$ 的关系，根据 $G(X|S;\theta_g) V(X) = G(X|S;\theta_g)(1-D(X;\theta_d) )=G(X|S;\theta_g) - G(X|S;\theta_g)D(X;\theta_g)$ ，这样会让 generator 偏向于一个更小的 $G(X|S;\theta_g)$ ，即概率比较小的句子，从而避免生成很多重复（概率比较大）的句子。Anyway，在我们的模型上，SentiGAN 的 loss 立竿见影，更多的细节请大家参考原作。

押韵

嘻哈歌词非常重要的一个特点就是句与句之间的押韵，我们在实现这一功能的时候尝试了两种方案：

1. Reward based，在 reward 函数上增加额外的押韵奖赏项， $\ r_{rhyme}$：对 Generator 的生成的句子和输入的句子进行押韵的判断，如果押韵，则提供额外的奖赏。
2. Rule-based，生成时只对押韵的词进行采样：在生成句尾的词的概率分布时候，通过获取和输入句尾押韵的词，只在这些押韵的词进行采样。

方法一，如果能够通过设计 reward function 就能实现押韵的功能，那模型就是完全 end2end，非常 fancy 了。但是理想很丰满，现实很骨感，经过几天的调整押韵奖赏的权重，都没能看到押韵率（我们设置的用于检测押韵奖赏效果的指标，每个 batch 中和 input 押韵的句子的比例）的上升 。我们怀疑是这种奖赏的结合会让 Generator 产生混淆，并不能明确自己 reward 来自何处，应该需要更加具体的一些限制才能够实现这一方法。

方法二，一开始我是拒绝这么做的，用基于规则的方法不是我的理想。

但是为了做出产品来，我还是屈服了。但还有一个问题摆在面前：怎么知道生成的是句尾呢?导师提醒我们，我们可以把输入倒过来。这是 NMT 中常用的一个手段，对于 LSTM，句子是真的还是反的差别不大，即使有差别，也可以通过一个 Bi-LSTM 来捕获不同顺序的信息。而为了知道哪些字词是押韵的，我们实现制作了一张 vocab_size x vocab_size 的大表 rhyme，如果两个词（index 分别为 i, j）押韵，则 rhyme[i, j] 非 0，否则为 0。

如上图所示，如果我们的输入为“你真美丽”，句尾词为“美丽”，韵脚为 i；最终采样结果只会在押韵的词中采样，示例的采样结果为“春泥”。

据此，我们就可以对生成过程的第一个词的词表分布进行一个 mask 操作，使得非押韵的词的概率都变成 0，就能够保证押韵了，代码片段如下：

1
2
3
4
5
6
7
8
9
10
11

# 获取 input 的最后一个词
first_token = self.inputs[:, 0]  # (batch_size, 1)
# 控制押韵的概率, 现在设置为 1.0 ，即 100% 押韵
select_sampler = Bernoulli(probs=1.0, dtype=tf.bool)
select_sample = select_sampler.sample(sample_shape=self.batch_size)
# 获取对应的 index 押韵行
token_rhyme = tf.cast(tf.gather(self.table, first_token), tf.float32)
# 进行 mask
prob_masked = tf.where(select_sample, tf.log(tf.multiply(token_rhyme, tf.nn.softmax(o_t))),tf.log(tf.nn.softmax(o_t)))
# 根据 mask 之后的概率分布进行采样
next_token = tf.cast(tf.reshape(tf.multinomial(prob_masked, 1), [self.batch_size])

不过这个制表的过程比较耗费时间（大约跑了 3 个小时，i7）。另一种思路是可以根据韵脚对字词进行分类，将相同韵脚的词的 index 编到一起，这样我们可以通过获取每个词的韵脚来知道目标词的范围，而不用挨个的去判断是否押韵。

结语

在 DeeCamp 的一个月里，除了讲座以外，更让我觉得收获许多的是认识了很多非常优秀的小伙伴，以及开拓了自己的视野，看到了更大的舞台。我愈发地坚信，未来的十年，是属于人工智能的，是属于愿意投身于这波浪潮中我们的。也再次向大家安利一波 DeeCamp，如果你对人工智能感兴趣，明年暑假，千万别错过~ 最后希望 DeeCamp 能够一直办下去，并且越办越好！

Controllable Text Generation

文本生成，包括机器翻译、文档摘要、Image Caption 在内，是一个非常广泛的问题，而这篇文章所讲述的文本生成，并不是类似机器翻译一样有具体的目的，有 x-y pair 的监督学习任务，而是侧重于无监督的生成模型。而这生成模型是可控的，即并不是仅仅根据 corpus 进行学习语言模型进行分布的模拟（SeqGAN），同时我们也希望能够对于生成的文本具备一定的控制能力，例如，我们可以控制生成的文本和某个主题相关，又或者是具有某种情感极性，在 charbot 这样的场景下，能够做到这到这一点是非常重要的。本文从三种模型架构出发，介绍关于可控文本生成的一些工作。
more >>

一开始并不抱太大希望往 DeeCamp 投了简历，笔试最后一道题犯了低级错误，还以为要与这次夏令营失之交臂，结果居然成为了 300 个幸运儿之一。7.20 考完试稍微收拾一下，怀着忐忑的心情，第二天就坐上了去北京的高铁。唰的一下，紧张而又充实的一周就这样度过了。

北大，第二次见面

上一次到北大还是高中毕业旅行，那时候是个游客，靠着同学姐姐带了进来，走马观花地游览了一番。还是觉得蛮神奇的，两年之后再次和北大见面，并且这里要在生活一个月。虽然只是营员，但是拿到北大学生卡的时候还是小小激动了一把。在这第一个礼拜里，吃了学五鸡腿饭，松林的包子，和高中同学一起夜游北大…… 都是缘分呐。

环境方面，心里难免会和西电做个比较。宿舍方面，西电算是胜出吧，毕竟西北第一，两室一厅也是没谁（虽然今年的新生是 10 间，gg）；食堂方面，虽然说非本校学生要加 15%，但我觉得北大的食堂还是很棒的，整体比我校要看起来干净许多，不过人也是爆多了，毕竟知名学府2333；教学楼方面，北大胜出，就凭打热水的机器还有常温水的选择，我就给他满分！而且教室整体也都高出西电一个档次（钱多就是好啊）。

知识课，饕餮盛宴

昨天刚上完知识课，导师的阵容应该是找不出第二家了，并且内容基本上 cover 了人工智能相关的各个方面。不过因为我主要研究的是自然语言处理，所以很多其他领域的 talk 并不能 follow 很多，但整个一周下来，也算是对 AI 的全景有了一个整体上的感知。

印象比较深的几个讲座有下面几个：

• 李开复老师讲 AI 的全景，人才的培养，甚至后面单独拿出一个午休的时间来答疑。原先我看过李开复老师的一些书，比如说《人工智能》，当然这本书可能更适合非专业人士来了解 AI，因为其写的过于浅显导致我甚至怀疑李开复老师的水平（捂脸）。但当他作为亲历者，给我们娓娓道来整个 AI 的发展浪潮，了解到他所研究的项目包括 CV、语音识别、下棋都是当时世界顶级的，事实上，他是在学界、工业界都非常有成就的，我为自己的无知感到无比羞愧。李开复老师真的有一种谦谦君子温润如玉的感觉，还把他的微信小号分享给大家。这种 dalao 真的见一次能让你感受到什么叫 level 上的差距，后面景驰的 CEO 说他当年也是李开复的迷弟，没想到今天李开复就成了他的投资人，一起喝酒说要做点什么。希望有一天我也能和李开复一起做点事情（逃
• 孙栩老师讲 NLP：因为我本身做 NLP，所以最感兴趣的自然是北大孙老师的自然语言处理课程。之前也看过孙老师的主页，感觉真人比照片上更精干一些，也更睿智一些。内容方面因为考虑到大家水平层次不齐，所以都是比较基础的内容。但是课间的时候同学们向孙老师咨询问题的时候，我凑上去旁听也问了几个问题，收获还是蛮大的。我问了一个问题是 word embedding 是一种好的表示吗（或者说是只有这样一条路子来做词的表示吗？），孙老师指出 COLING 18 有相关的工作不仅考虑 word embedding，同时把语言模型的参数也附加进来的一种方法，开拓了我的思路。另外发现孙老师组的作品有一个共性，就是看待问题的方式是很新颖的，比如把 Multi-label Classification 任务看成是生成任务，一篇 SGM 也因此拿了 COLING 的 best paper。总的来说，孙老师人很 nice，希望明年有时间的话能到孙老师组实习。
• 王咏刚老师讲创新创业：先前在学校里上过创新创业课程，不得不说，差距还是太大了，毕竟创业工场是国内最著名的孵化器，作为其中的 AI 工程院副院长的王老师眼光自然很是毒辣，其所经历的和。王老师拿 pdd 做例子告诉我们，即使在座的 300 人里没有用 pdd 的，但它还是成功了。中国的人口那么多，流量怎么下沉？黄峥多次到四五线城市去调研，就是为了发觉这一部分人群真正的需求。而技术人员、学生创业很容易陷入怪圈，并且告诫我们，在创业的时候一定要问问自己：看到是个体需求，还是普遍逻辑？是技术闪光点，还是大的框架？以前自己真的是很 naive 了，啊我有个 Paper 效果很好，accuracy 很高，但是抱歉，市场不买账。另外，AI 在未来毫无疑问是重中之重，但是它能够 to C 吗？不能，纯 AI 并不能作为一个独立的产品，往往是卖给企业，和已有的环节结合，赋能增效，创造更大的价值。

Find My Way

收获最大的是孙栩老师让他的研究生，同时也是今年 COLING Best Paper 的第一作者杨鹏程来给我们讲工作以及科研的经历。其中他说到，首先我们需要想清楚自己要做什么？是一个 researcher 还是一个 engineer，甚至是一个 PM。当然了，目前我的选择就是 research，而如果选择做科研那么就就会经常处于两中情况：

• 没有 Idea：
  1. 尝试做一个应用型任务，学以致用
  2. 多读论文，厚积薄发
  3. 重视小的创新，循序渐进，积少成多
• 有了 Idea：
  1. 能否进一步创新，拉大与 baseline 的 gap
  2. 成功的 idea 存在什么问题，能否进一步解决
  3. 如何解释 idea 成功的原因
  4. 如何设计全方位的实验来验证 motivation 以及解释原因

之前有过写一篇 Paper 的经历，知道了 Paper 的架构是怎么样的，对整个流程也有一个模糊的概念，但始终没有梳理出一个框架来。而杨鹏程学长的分享让我有一种醍醐灌顶的感觉，据说这也是其和组内师兄总结得出的，我想这一周最大的收获莫过于此。

在机器之心上看到说 Goodfellow 给一篇刚上 arXiv 的 The relativistic discriminator: a key element missing from standard GAN 文章点了赞，就去看了眼，发现确实很有意思。

Intuition

文章说标准的 GAN（SGAN） 在 Generator（下文用 G 代替） 生成的样本越来越逼真的时候 Discriminator 缺了个东西。什么呢？相对的概念，先来看下面这张图片：

可以看到，我们的 real data 是面包，fake data 是柯基（好萌啊2333)，$C(x)$ 越大则说明是面包的概率越大。图中列出了三种情况：

1. 真的面包，真的柯基：这种情况二者的区别很明显，因而 $P(bread |\bar C) = 1$
2. 真的面包，柯基屁股（很像面包）：这种情况区别就没有第一种那么明显了，因而 $P$ 有所下降
3. 像狗的面包，真的柯基：和第二种情况类似，相对的区别度降低了， $P$ 同样有所下降

有了一个模糊的印象之后，我们展开说说这个相对究竟是什么。

Arguments of RaGAN

相对，一言以蔽之：Discriminator（下文中用 D 代替）衡量样本真实性的时候，应该要同时利用 real data 和 fake data，衡量的由绝对的真假变成相对的为真或为假的概率。 作者从三个方面论述了其观点：

Priori Knowledge

先验知识的利用，即每次我们喂给 Discriminator（下文中用 D 代替） 的样本中，基本上是一半 real data，一半 fake（Generator generated）。也就是说，不知道这个前提的话，那么如果 G 生成的样本（比如说图片）能够以假乱真的话，那么 D 会认为所有的样本都是 real 的，而如果知道这个前提，那么当 fake 比 real 更 real 的时候，discrinimator 应该给 real samples 打低分（认为他们是 fake） 而不是认为所有的 samples 都是 real。因为在看到了更 real 的 fake samples 之后，相对地，利用先验知识，我们会认为不那么 real 的 samples（比如狗面包）是 fake 的。而 SGAN 的训练中并没有利用到这一部分先验知识。

Divergence Optimization

我们知道，SGAN 在训练 D 的时候事实上是在 minimize 生成器分布和真实数据分布的 JS-Divergence，而 JS-Divergence 在两个分布相同时达到最小值，其表现是 D 无法区分 real data 和 fake data，认为其为真的概率均为 0.5；JS-Divergence 在两个分布差异较大的时候较大，即 D 认为 real data 为真的概率为 1，而认为 fake data 为真的概率为 0。理想的训练过程是如下 (C) 图所示：

但事实上，我们在训练的时候一味地希望生成的图片足够逼真，即一直在将 D(fake_data) 向 1 推，而不管 D(real_data)。这有做是达不到最小值的，这样的 optimization 过程是存在问题的，WGAN 论文中似乎也有提到这一点。

Gradient

WGAN 等一系列对 GAN 做了改进的 GAN 被称为 IPM-based GAN，作者将其梯度和标准的 GAN 进行了对比：

下面是 IPM-based GAN 的梯度：

当下面这些条件满足的时候，两式相等：

1. 在训练 D 的时候，$D(x_r) = 0, D(x_f) = 1$
2. 训练 G 的时候，$D(x_f) = 0$
3. $C(x) \in \mathit{F}$，其中 $F$ 是一类实值函数（这个一般都能满足）

考虑到 IPM-based GAN 相对于 SGAN 具有更好的稳定性，可以推断，如果将 SGAN 推向 IPM-based GAN，能够提高其稳定性。怎么才能达到这个转变呢？如果我们认为 D 足够好，即能够在训练 G 时做到认为 $D(x_r) = 1 \ and \ D(x_f) = 0 ​$（这是一个比较强的假设，但是在训练一开始是能够满足的），而在训练 D 的时候 $D(x_r) = D(x_f) = 1 ​$，如开头图片的 (b) 所示那种情况，那么唯一缺少的条件就是 $D(x_r) = 0 ​$。但是在 SGAN 中，$D(x_r)​$ 只跟 real data 有关，也即是绝对的真假，如果 G 生成的样本能够影响 $D(x_r)​$，让它变得不那么真实，也即相对的真假。这个时候，$D(x_r)​$ 才可能变成 0。总结起来一句话就是，在 $D(x_f)​$ 提升的时候 $D(x_r)​$ 相应地减少（这是一种相对的变化），这样 GAN 的训练才能更加稳定。

Methods

Relativistic GAN

如何把这种相对为真和为假的概率考虑进去？很简单，只要把 logits 做一个简单相减，即：

这里用 sigmoid 函数将 logits 转化成概率，然后再取对数；我们可以很容易地把这个式子进行泛化，即用更一般的函数（不一定是似然函数）来替换它。

Relativistic average GAN

不过这个时候，我们发现 GAN 中 D 的功能已经悄然发生的改变，由原来的：衡量输入数据为真的概率，变成了输入的数据与其对立类型随机的一个样本（如果输入为 real data，那么衡量其比 fake data 更像真的概率，反之亦然）相比更像真的的概率。那么，更一般地，我们利用对立类型的平均真实度来作为更可靠的参照对象。

所谓平均真实度，就是对整个（或者一个 mini-batch） real data 和 fake data 求其 $D(x)$ 的数学期望，这样的估计能够更加整体的反映训练在这一时刻生成器生成的 fake data 的真实程度。同样，我们可以轻易地将其泛化到别的函数之上。最后整个算法流程如下：

Toy Demo

原作给了很多例子来说明 RaGAN 的效果，并且也提供了相应的代码。这里我就拿 MNIST 做一个小小的 Demo，在原版的 GAN 的 demo 上做了一个很小的改动，就是把 loss 计算中的 logits 进行对应的相减。

Generator

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

# Generator Net
Z = tf.placeholder(tf.float32, shape=[None, 100])

G_W1 = tf.Variable(xavier_init([100, 128]), name="G_W1")
G_W2 = tf.Variable(xavier_init([128, 784]), name="G_W2")

G_b1 = tf.Variable(tf.zeros([128]), name="G_b1")
G_b2 = tf.Variable(tf.zeros([784]), name="G_21")

theta_G = [G_W1, G_W2, G_b1, G_b2]

def generator(z):
    G_h1 = tf.nn.relu(tf.matmul(z, G_W1) + G_b1)
    G_log_prob = tf.matmul(G_h1, G_W2) + G_b2
    G_prob = tf.nn.sigmoid(G_log_prob)

    return G_prob

Discriminator

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

# Discriminator Net
D_W1 = tf.Variable(xavier_init([784, 128]), name="D_W1")
D_b1 = tf.Variable(tf.zeros(shape=[128]), name="D_b1")

D_W2 = tf.Variable(xavier_init([128, 1]), name="D_W2")
D_b2 = tf.Variable(tf.zeros(shape=[1]), name="D_b2")

theta_D = [D_W1, D_W2, D_b1, D_b2]

def discriminator(x):
    D_h1 = tf.nn.relu(tf.matmul(x, D_W1) + D_b1)
    D_logit = tf.matmul(D_h1, D_W2) + D_b2
    D_prob = tf.nn.sigmoid(D_logit)

    return D_prob, D_logit

RaGAN

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

# Ra GAN  simple version 
mnist = input_data.read_data_sets('MNIST_data', one_hot=True)
X = tf.placeholder(tf.float32, shape=[None, 784], name="X")


G_sample = generator(Z)
D_real, D_logit_real = discriminator(X)
D_fake, D_logit_fake = discriminator(G_sample)
# discriminator 
# log( real_logits - fake_logits)
D_loss = tf.reduce_mean(tf.nn.sigmoid_cross_entropy_with_logits(logits=D_logit_real - D_logit_fake, labels=tf.ones_like(D_logit_fake)))

# generator loss
# log(fake_logits - real_logits )
G_loss = tf.reduce_mean(tf.nn.sigmoid_cross_entropy_with_logits(logits=D_logit_fake - D_logit_real, labels=tf.ones_like(D_logit_fake)))

# optimizer
D_solver = tf.train.AdamOptimizer().minimize(D_loss, var_list=theta_D)
G_solver = tf.train.AdamOptimizer().minimize(G_loss, var_list=theta_G)

Train

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
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58

def sample_Z(m, n):
    return np.random.uniform(-1., 1., size=[m, n])


steps = 1000001
mb_size = 128
Z_dim = 100


def plot(samples):
    fig = plt.figure(figsize=(4, 4))
    gs = gridspec.GridSpec(4, 4)
    gs.update(wspace=0.05, hspace=0.05)

    for i, sample in enumerate(samples):
        ax = plt.subplot(gs[i])
        plt.axis('off')
        ax.set_xticklabels([])
        ax.set_yticklabels([])
        ax.set_aspect('equal')
        plt.imshow(sample.reshape(28, 28), cmap='Greys_r')

    plt.show(block=False)
    return fig


with tf.Session() as sess:
    sess.run(tf.global_variables_initializer())
    num = 0
    for i in range(steps):
        X_mb, _ = mnist.train.next_batch(mb_size)
        
        _, D_loss_curr = sess.run([D_solver, D_loss], feed_dict={
            X: X_mb,
            Z: sample_Z(mb_size, Z_dim)
        })
        # 注意，这里的 feed_dict 和原来不一样了
        _, G_loss_curr = sess.run([G_solver, G_loss], feed_dict={
            X: X_mb, Z: sample_Z(mb_size, Z_dim)
        })
        # 下面的 vanilla GAN 的 loss
        # _, G_loss_curr = sess.run([G_solver, G_loss], feed_dict={Z: sample_Z(mb_size, Z_dim)})

        if i % 100 == 0:
            print("Step %d" % i)
            print("G loss: %f" % G_loss_curr)
            print("D loss: %f" % D_loss_curr)
            print()

        if i % 1000 == 0:
            samples = sess.run(G_sample, feed_dict={Z: sample_Z(16, Z_dim)})
            fig = plot(samples)
            fname = '{}.png'.format(str(num).zfill(5))
            plt.savefig(fname, bbox_inches='tight')
            print('saved image ' + fname)
            num += 1
            # plt.clf()
            plt.close(fig)

Summary

GAN 的难训练是臭名昭著了，作者通过考虑引入相对这个概念来使得训练过程变得更加稳定。这类见微知著的工作，还有前不久的 IndRNN 真的非常符合我的胃口了。

深度学习框架很多，TensorFlow 算是比较流行的了，但静态图有时候确实写的很难受，以及一些比较复杂的 model 实现起来比较蛋疼；最近在看的文章的实现没有 TensorFlow 版本，起初我想改写一个 TensorFlow 版本出来，结果实现不了，一方面可能我确实比较菜，另一方面，也只能说 TensorFlow 有些东西在设计上让人为难。所以，那就试试 PyTorch 咯。这篇文章主要是记录我学习 PyTorch 官方 60 分钟教程的过程。

Tensor

逃不开的还是 Tensor 这个对象，PyTorch 创建、操作 Tensor 的方法和 numpy 很类似，据说 Torch 一开始就是 Numpy 的 GPU 加速版，简单列些一些 API：

1
2
3

x = torch.empty(5, 3) # 创建一个未初始化的 5x3 tensor
x = torch.rand(5, 3) # 随机生成 5x3 
x = torch.zeros(5, 3, dtype=torch.long)

比较有意思的是，创建 Tensor 的时候 size 参数不是一个 tuple e.g. (5, 3) ，而是用 *args 的方式传入。

常用的算术操作可以通过 x+y 或者是 torch.add(x, y) 来实现，同时 PyTorch 也提供了就地 (in place) 的操作：

1

y.add_(x) # equals y = y + x

所有的操作名 + 下划线都是一个就地操作，x.copy_(y) 会用 y 的值替代x。

另外，对于单元素的 Tensor，可以通过使用 .item() 来获取它；TensorFlow 中的 reshape() 对应的是 view()，并且，和 numpy 一样，Tensor 支持切片操作：

1
2
3

x = torch.randn(4, 4) # x -> 4x4
x.view(-1 , 8) # x -> 2 x 8
x[:, 1] # 取第二列的所有元素

既然之前说 Torch 是 Numpy 的一个 GPU 版本，也就支持 ndarray 和 Tensor 的相互转化（这就比 TensorFlow 用起来舒服很多），可以用 Tensor.numpy() 获取到对应的 ndarray，逆操作则是 torch.from_numpy()：

1
2
3
4
5
6
7
8
9
10
11
12
13

# example 1 tensor -> numpy
a = torch.ones(3) # tensor([1., 1. , 1.])
b = a.numpy() # 通过 tensor.numpy() 获取对应的 ndarray 对象
a.add_(1)  # 就地 + 1 , a= a+1
print(a)# tensor([2., 2., 2.])
print(b) # [2., 2., 2.]

# example 2   numpy -> tensor
a = np.ones(3)
b = torch.from_numpy(a)
np.add(a, 1, out=a)
print(a)  # [2., 2., 2.]
print(b) # tensor([2., 2., 2.])

上面这个例子很重要，说明了ndarray 和 Tensor 对象之间的转换是一种引用关系，而非创建新的对象。也就是说，任何一个相关对象的变化都会影响到另一方，就像例子 1 中，我们对原始的 a 进行 add_(1)，在此之前得到的 b 对象的值也改变了，例子二中同样出现了这样的情况，这一点需要特别注意。

CUDA Tensors

我们可以把 Tensor 放到 GPU 上来加速计算，而 PyTorch 为此提供了很方便的方式：

1
2
3
4
5
6
7

if torch.cuda.is_available(): # 如果 CUDA 可用
    device = torch.device("cuda")          # CUDA 设备对象
    y = torch.ones_like(x, device=device)  # 直接在 GPU 上创建 Tensor 对象
    x = x.to(device)                       # 也可以用``.to("cuda")`` 代替
    z = x + y
    print(z)
    print(z.to("cpu", torch.double))       # ``.to`` 同时可以改变数据类型

如上面的例子所示，我们可以在创建 Tensor 对象时指定 device 参数来指明 Tensor 创建的位置，也可以再创建了之后使用 .to() 方法来进行双向的迁移：既可以从 CPU 到 GPU（例子中的 x.to(device)，也可以从 GPU 到 CPU（z.to("cpu", torch.double)）。对比 TensorFlow ：

1
2
3
4

with tf.device('/cpu:0'):
    # something you want to do on CPU
with tf.device('/gpu:0'):
    # somethin you want to do on GPU

就我所知，TensorFlow 只能在创建的时候指明位置，而无法像 PyTorch 这般灵活的迁移。

Autograd

自动求导已经是深度学习框架的必备了，首先，我们可以通过设置 Tensor 的 .requires_grad 参数来指明 Tensor 是否参与梯度运算，这和 TensorFlow 中的 trainable 是类似的；接着我们通过对某个对象（比如 loss ）函数进行 .backward() 操作，来进行反向梯度的计算，并且能够通过计算链上对象的 .grad 属性来获取到对应的梯度。拿官方的例子做一个简单的说明：

1
2
3
4

x = torch.ones(2, 2, requires_grad=True) # 声明 x，指明需要参加梯度的计算 x: 2x2 全 1
y = x + 2
z = y * y * 3 # z = 3 * (x+2)^2
out = z.mean()

梯度计算的过程如下：

$o =\frac{1}{4}\sum_i z_i$

$z_i = 3(x_i+2)^2$

$z_i\bigr\rvert_{x_i=1} = 27$

$\frac{\partial o}{\partial x_i} = \frac{3}{2}(x_i+2)$

$\frac{\partial o}{\partial x_i}\bigr\rvert_{x_i=1} = \frac{9}{2} = 4.5$

因此，x.grad 的值在我们对 out 进行 out.backward() 操作之后，结果为：

tensor([[ 4.5000, 4.5000],

​ [ 4.5000, 4.5000]])

backward() 函数的原型如下：

torch.autograd.backward(tensors, grad_tensors=None, retain_graph=None, create_graph=False, grad_variables=None)

其中第一个参数用来声明梯度的权重。如果目标函数是一个标量，则可以不传这个参数，比如上面的 out.backward() ，则默认权重为 1 ，如果我们改成 out.backward(torch.tensor(2,dtype=torch.float)) 则各个

Build A Neural Network

学框架不搭一个 NN 来玩 MNIST 或者 CIFAR 怎么能叫入门呢？来来来，走一波~

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
26
27

class Net(nn.Module):
    def __init__(self):
        super(Net, self).__init__()
        self.conv1 = nn.Conv2d(3, 6, 5) # input 3 channels, output 6 channels , filter size = 5
        self.conv2 = nn.Conv2d(6, 16, 5) # input 3 channels, output 16 channels, filter size = 5
        # Wx + b
        self.fc1 = nn.Linear(16 * 5 * 5, 120)
        self.fc2 = nn.Linear(120, 84)
        self.fc3 = nn.Linear(84, 10)

    def forward(self, x):
        # max pooling, window size : 2x2
        x = F.max_pool2d(F.relu(self.conv1(x)), (2, 2))
        # 如果是 方形的输入，window size 可以只用一个参数
        x = F.max_pool2d(F.relu(self.conv2(x)), 2)
        x = x.view(-1, self.num_flat_features(x))
        x = F.relu(self.fc1(x))
        x = F.relu(self.fc2(x))
        x = self.fc3(x)
        return x

    def num_flat_features(self, x): # 展平 x
        size = x.size()[1:]  # 获取各个维度的大小，除了第一维 batch_size
        num_features = 1
        for s in size:
            num_features *= s
        return num_features

诶，有没有觉得有点像 Keras，不过高级的 API 用起来就是爽，不用写那么多代码2333，接下来就是定义 loss 和进行 backprop 来更新参数：

1
2
3
4
5
6
7
8
9
10
11
12

import torch.optim as optim
# 定义 loss
criterion = nn.CrossEntropy()
# 创建 optimizer
optimizer = optim.SGD(net.parameters(), lr=0.01)

# 在循环里不断进行如下操作：
optimizer.zero_grad()   # 清零梯度
output = net(input)
loss = criterion(output, target)
loss.backward()
optimizer.step()    # 梯度更新

和 TensorFlow 的区别就在于，TensorFlow 的话只要我们用 session.run(optimizer) 就可以完成梯度的更新操作，而 PyTorch 则需要：

1. Optimizer 清零梯度
2. 对 loss 进行手动的 backward() 操作
3. Optimizer 更新 .step()

三步走，记住了没有！

还有一点比较方便的是，和 Tensor 类似，我们可以使用 Net.to() 来把模型部署到 GPU 上：

1

net.to("cuda:0")

但是！记得要把你的输入也放到 GPU 上，不然就会报错：

1

inputs, labels = inputs.to(device), labels.to(device) # 把 input 和 label 同样迁移到 GPU 上

Summary

初体验如果要给个评价的话，我觉得是比 TensorFlow 好很多（毕竟 TensorFlow 一上来的 Session、静态图会让人有点摸不着头脑）。但用什么框架其实都无所谓，就和语言一样，虽然争来争去，但每种语言都有自己的用武之地，以前我还会和室友争辩 Java 和 Python 谁才是最好的语言，现在就不会了（因为我也觉得 Python 好写一点，逃）。框架更不用说，TensorFlow 有他应用的工业场景（希望能早日接触到），PyTorch 现在看来也许更适合需要快速实现原型的科研人员。而我们能做的，就是多接触，横向比较着来看而不要因为自己擅长而蒙蔽了双眼，多学一技压身，总是没错的。