Generative Adversarial Networks

生成对抗网络(Generative Adversarial Networks)越来越火,最开始是用于MLP的生成对抗网络,就是Ian J. Goodfellow论文中提出的。后来出现了CNN架构的,效果确实提高了。现在还有SeqGAN,我不敢做评论。既然是Simplified DeepLearning系列的,自然尝试最简单的。


Generative Adversarial Networks原理

GAN的原理其实很简单。首先我们要学习的是生成器G关于数据x的分布p_g,问题从哪生成呢,这就需要我们定义一个噪声先验p_z(z),如一个均匀分布。那么生成的样本就是G(z)。然后我们需要一个判别器D(y),判断y是来自G还是x,也就是D要判断出输入是伪造的还是真实的。这就是一个对抗学习的过程:G尽量生成逼近真实的数据,使D不能分辨真伪。D要足够厉害,能够分辨真伪。形象的图如下:

gan
图自slideshare

形式的代价函数如下:

    \[\underset{G}{\min}~ \underset{D}{\max} ~V(D,G) = \mathbb{E}_{x \sim p_{data}(x)}[\log D(x)] +\mathbb{E}_{z \sim p_{z}(z)}[\log(1 - D(G(z)))]\]

理解这个很重要,可以看看这个。这里其实是将两个loss拼起来了,而且省去了一部分。有了目标函数,训练则是交替的训练,论文中有详细描述。简单的说,就是一步固定G,训练D,然后固定D,训练G。作者提到,为了防止”the Helvetica scenario”,要训练D多步,然后训练G一步。


一维高斯分布

看一个简单的例子,也是论文中的例子,我觉得很多人没理解论文中那个用均匀分布生成高斯分布的例子。为了深刻理解,保证自己没有理解错误,我必须再现一下。网络结构很简单,没几行如下。

然后就是训练,具体见github。怎么知道我是对的呢。可以看以下训练过程。

init
初始状态
m1
训练好的判别器
m2
交替训练几步之后
m2
最后结果

 

我还能说什么,完全符合理论D^*(y) = \frac{p_{data}(y)}{p_{data}(y) + p_{g}(y)}以及最后D(y) = \frac{1}{2}。在强调一下,这是一维的情况,也就是从真实数据给出一个数字和从G中生成一个数字如4,判别器无法判断4来自真实数据还是伪造的,因为这两个分布产生这个数字的概率是一样的,如最后一张图。如果真实数据产生4的概率大一点,判别器就能稍微判断一下,如最后第二张图。


MNIST测试

又得用到果蝇MNIST了,上面的例子太简单,可能不能令人信服。代码其实差不多,稍微加了个dropout,见github。训练中间结果如下,注意这是一张只循环一次的gif,你可能要刷新一下。

mnist gan
mnist gan (gif)

可能注意到怎么只生成两个数字,这就是所谓的”the Helvetica scenario”,我还不知道哪里出了问题。反正能生成数字了,够了。


实践出真知,show me the code!

国庆终于把坑填完了,DOTA还拿了暴走,完成了千年辅助的梦想!3天没出宿舍楼,欢度国庆,开心!


链接

神经网络近似函数

神经网络的强大在于其能在有限区间内近似任意函数,更精确的说是MLP(多层感知机)是万能的函数近似机,证明由Cybenko给出。注意是在有限区间内,论文中也是在单位超立方体(the unit hypercube)内讨论。如果不是有限区间,可能得靠RNN,比如某些具有周期性质的函数,就能使用RNN近似。


MLP近似爱心函数

看到微博上推的使用MLP来近似函数的博文,我觉得少点东西,做点补充。第一步就挑一个有趣点的函数吧,随便挑个心形函数x^2+(y-\sqrt[3]{x^2})^2。然后用keras很快就能搭个MLP,具体见github

训练之后就能得到对这个函数的近似,画成图如下:

heart
近似爱心函数

还有个哥们居然搞了个penis的函数,无法直视,有兴趣的可以尝试。


RNN近似周期函数

超出训练的范围,MLP的近似就无效了,想想也知道,泛化能力不可能那么强。而RNN在一定程度上可以弥补一下,最好是有点周期性的函数。为了简单起见,就先用\sin(x)测试好了。同样用keras快速搭个RNN,具体见github

关键是训练数据如何构造,也就是输入输出是怎样的。跟MLP不同,这里用函数值预测函数值,而不是输入x。因为在如时间序列预测的情况下,输入x是未知的,只能使用之前已知的函数值。我用相邻 feature_length个点组成一步的输入,总共 seq_length 步,其中每个点间隔 interval 。那预测就是后面的点,也可以只预测一个,我测试是预测 feature_length个,其中一半重合。比如0到32个点预测16到48个点(这样的做法似乎也能使用在MLP预测时间序列中,Quantitative Finance论文)。说不清楚看下图或者看代码。

rnn predict
RNN输入和输出

之后就是训练了,\sin(x)可以说是完美近似,后面因为累积误差导致不能近似的很好也是正常的。我又测试了\sin(x) * \sqrt[10]{x},有一个递增项,效果就没有\sin(x)好了,但短期内效果还是好的。注意我画得图的区间不在测试区间内,也就是网络没看到过的数据,正因为RNN具有一定泛化能力才能有如此表现。

sinx
sin(x)
sinxx
sin(x)*x^0.1

累积误差比较蛋疼,如下的情况,就算是测试数据的范围内也会有问题。可以用beamsearch,或者其他目标函数做,比如Q-learning。比较复杂,这里只讨论最简单的情况。

误差
累积误差

总结

MLP还是很厉害的,只要参数足够多,就能在一定区间内近似任意函数。而RNN相当于图灵机,之前也写过使用RNN做时间序列预测的博文,由于数据不能放出,所以也没有把代码放出。这次的代码与上次是类似的,改改也能试试做时间序列预测,就我的经验来看,没有传统方法好。

 

SGD算法比较

机器学习中,经常需要解决Empirical risk minimization(ERM)问题,这么晦涩的名字其实很简单,就是对于每个数据样本i定义一个损失J_i(\Vtheta}),总的损失就是

    \[J(\Vtheta}) = \frac{1}{n} \sum_i^n J_i(\Vtheta})\]

然后要找到使J(\Vtheta})最小的\Vtheta}。如SVMLogistic regression甚至分类的CNN都是属于这个问题。
这类模型通常需要使用迭代法求解(Linear regression 有闭解但考虑计算问题,一般也使用迭代法),其中梯度下降法(Gradient Descent)最常用:

    \begin{align*} \Vg_t &\gets \frac{1}{n} \sum_i^n \nabla J_{i}(\Vtheta_{t-1}) \\ \Vtheta_t & \gets \Vtheta_{t-1} - \eta \Vg_t \end{align*}

SGD

遇到数据量大的时候,很难不使用随机梯度下降法(Stochastic gradient descent, SGD)。SGD非常直观,就是随机拿一个或几个数据做个梯度下降,即

(1)   \begin{align*} \Vg_t &\gets \nabla J_{i}(\Vtheta_{t-1}) \\ \Vtheta_t & \gets \Vtheta_{t-1} - \eta \Vg_t \end{align*}

这个梯度\Vg_t是对部分数据计算所得,下面就记为\Vg_t  \gets \nabla J(\Vtheta_{t-1})\Vg_t可以看作是对真实梯度的估计,至少期望上是没有偏差的,因此在应用于凸问题时可以收敛到最优解。但是SGD有很多需要解决的问题

  • 收敛速度跟学习速率\eta关系很大,大\eta容易震荡,小的\eta收敛很慢。人为地在训练中调节是比较困难的,也难以适应数据的特征。
  • 学习速率\eta对所有的\Vtheta的特征都是一样的。事实上,应该\Vtheta中某些特征下降慢,有些快,没有考虑到稀疏性。
  • 容易陷入不太好局部最小或者鞍点。特别是在训练神经网络时,会更明显。

为此大神们设计了很多改进的算法,包括Momentum、NAG、Adagrad、RMSProp、AdaDelta、Adam….。我们一个个看过去。或者可以看这个博客


改进SGD

改进的算法实在有点多,挑几个著名的,我把这几个算法之间的进化关系(也根据出现的时间顺序)画在了一张图中。针对上述问题,主要有两种改进,一是利用物理中动量的思想,保持总的下降方向减小震荡,也比较容易地跳出不太好的局部最小。二是自动调节学习速率\eta

SGD粗略关系(看不清放大看)

不好好研究一下,实在搞不懂这些算法之间的区别。所以接下来仔细看看每个算法,比较一下优缺点。

Momentum

想象一个球从山上滚下来,刚开始速度为0,就会滚得磕磕碰碰(震荡)。经过一段时间动量(Momentum)的累加,震荡就会减少,径直往山下滚。表示为数学公式就是

(2)   \begin{align*} \Vg_t & \gets \nabla J(\Vtheta_{t-1}) \\ \Vv_t & \gets \gamma \Vv_{t-1} + \eta \Vg_t\\ \Vtheta_t & \gets \Vtheta_{t-1} - \Vv_t \end{align*}

可以看到跟(1)式相比就是当前下降的方向要与之前下降的方向加权平均。这里的\gamma一般取0.9就行了。直观上可以减少震荡,能更快的收敛。

NAG

NAG(Nesterov accelerated gradient)核心思想就是利用Momentum预测下一步的梯度,而不是使用当前的\Vtheta

(3)   \begin{align*} \Vg_t & \gets \nabla J(\Vtheta_{t-1} - \gamma \Vv_{t-1}) \\ \Vv_t & \gets \gamma \Vv_{t-1} + \eta \Vg_t\\ \Vtheta_t &\gets \Vtheta_{t-1} - \Vv_t \end{align*}

看出玄机没,在计算\Vg_t的时候使用的不是\Vtheta_{t-1}而是在\Vtheta_{t-1}的基础上再前进\gamma \Vv_{t-1},相当于利用当前的Momentum对下一步将走到哪进行了预测。更详细的介绍可以看这里

AdaGrad

接下来是关于学习速率的——通过算法让学习速率的选择更加容易,或者说是Adaptive Gradient。AdaGrad利用以前的梯度信息\sum_{i=1}^t \Vg_{i,j}^2判断对应的特征j是否经常被更新。因此对稀疏的数据尤其适合。写成向量形式如下:

(4)   \begin{align*} \Vg_t & \gets \nabla J(\Vtheta_{t-1}) \\ G_t &\gets G_t + \Vg_t \odot \Vg_t \\ \Vtheta_t & \gets \Vtheta_{t-1} - \frac{\eta}{\sqrt{G_t + \epsilon}} \odot \Vg_t \end{align*}

注意其中的element-wise操作,为了防止除零,\epsilon取个小量如1e-8。一般\eta取个0.01就不用管了。
在这里停顿,思考2分钟,尝试发现问题。

G_t是递增的,而且可能是比较快的递增,然后就会导致\frac{\eta}{\sqrt{G_t + \epsilon}}很小趋向于0,最后\Vtheta就不会更新了。还有就是,最开始的梯度有必要对很久以后的更新产生影响吗?

但AdaGrad的意义是非凡的,这里这样做的考虑可能是因为证明收敛更容易(见AdaGrad论文,40页我看不下去)。为了更加实用,于是就有了下面站在巨人肩膀上的算法。

RMSProp

这个算法不要太简单。是Hinton在课上提到的,甚至没有发表。RMSProp就是解决AdaGrad中学习速率趋向0的问题的。来看看如何简单。

(5)   \begin{align*} \Vg_t & \gets \nabla J(\Vtheta_{t-1}) \\ G_t &\gets \gamma G_t + (1-\gamma) \Vg_t \odot \Vg_t \\ \Vtheta_t & \gets \Vtheta_{t-1} - \frac{\eta}{\sqrt{G_t + \epsilon}} \odot \Vg_t \end{align*}

对比(4)式,多了对累计的信息的一个指数衰减(\gamma取0.9),AdaGrad的问题就没了。相对AdaGrad,不存在学习速率趋向0的问题,这里的学习速率\eta就可以取小一点如0.001

AdaDelta

AdaDelta也可以解决AdaGrad的问题,虽然经常看成与RMSProp类似的,我感觉AdaDelta更高级点,因为它连初始的学习速率都不用设置,AdaDelta有时相对比较慢。更新如下:

(6)   \begin{align*} \Vg_t & \gets \nabla J(\Vtheta_{t-1}) \\ G_t & \gets \gamma G_t + (1-\gamma) \Vg_t \odot \Vg_t \\ \Delta \Vtheta_t & \gets - \frac{\sqrt{\Delta_{t-1} + \epsilon}}{\sqrt{G_t + \epsilon}} \odot \Vg_t \\ \Vtheta_t & \gets \Vtheta_{t-1} + \Delta \Vtheta_t \\ \Delta_t & \gets \gamma \Delta_{t-1} + (1-\gamma) \Delta\Vtheta_t \odot \Delta \Vtheta_t \end{align*}

对比(5)式,可以发现AdaDelta用\sqrt{\Delta_{t-1} + \epsilon}来估计学习速率。这里的\gamma可以取个0.95。直观来说,就是利用之前的步长们\Delta\Vtheta_t估计下一步的步长,好像很有道理。“更有道理的是,SGD, Momentum或者AdaGrad更新时单位是不对的,或者说我们赋予了\eta一个单位。看(1)式,\Vg_t的单位是\frac{1}{\Vtheta}的单位(假设J没有单位,存疑),用它来更新\Vtheta单位可能就不对。而AdaDelta就没有这个问题\frac{\Delta\Vtheta}{ \frac{\Delta J}{\Delta\Vtheta}} \Vg_t \propto \Delta\Vtheta。”这段存疑,有兴趣的可以看AdaDelta论文

Adam

神器,相见恨晚,好快。我用了之后这种反应。首先Adam利用了AdaGrad和RMSProp在稀疏数据上的优点。对初始化的偏差的修正也让Adam表现的更好。为什么叫Adam呢,因为它是adaptive estimates of lower-order moments(我没理解moments是什么意思,应该是数学里面的moments),对1阶moments(mean)和2阶moments(variance)进行自适应调整。为什么能对初始化的偏差进行修正(Initialization Bias Correction),可以看Adam论文,我有一步没搞清楚。Adam的更新算是最复杂的了:

(7)   \begin{align*} \Vg_t &\gets \nabla J(\Vtheta_{t-1}) \\ \Vm_t & \gets \beta_1 \Vm_{t-1} + (1-\beta_1) \Vg_t \\ G_t & \gets \gamma G_t + (1-\gamma) \Vg_t \odot \Vg_t \\ \alpha & \gets \eta \frac{\sqrt{1-\gamma^t}}{1-\beta^t} \\ \Vtheta_t & \gets \Vtheta_{t-1} - \alpha \frac{\Vm_t}{\sqrt{G_t + \epsilon}} \end{align*}

与论文中的有所不同,我已经写成高效的形式。\beta_1取个0.9(可能需要衰减),\gamma取个0.999\eta取个0.001有时也要来个衰减,如\eta_t = \frac{\eta}{\sqrt{t}}。在复杂优化问题上,调参真的需要经验。但相对其他来说,Adam真的快很多,很多deep learning的优化问题都用Adam。
除了Adam,作者还给出了Adamax这一变种,有兴趣可以看论文。还有加了Nesterov的Adam,NAdam


Python实现

“纸上谈兵终觉浅”,稍微实现一下是必须的,就会发现理解上的不足。网上有很多实现,比如Keras的、Tensorflow的。我实现的应该很简单粗暴,都能看懂,代码见Github(不能保证完全正确),实现logistic regression和MLP的代码都是从Theano的教程的网站获得。当然实验数据用的是机器学习中的果蝇——mnist。

效果对比

跑一个循环所需的时间还是有差别的,但差别不大,可以自己尝试。我分别在logistic regression(凸问题)和MLP上跑了一遍。为了看得清楚,我把cost的曲线光滑了一下,效果如下图所示。

 

performance on logistic regression
performance on logistic regression
performance on MLP
performance on MLP

在这两个模型上,momentum和NAG都表现得差不多,不知道是不是我的实现有问题。Adam和Adamax都算后来居上,反正表现很好。对比AdaGrad和RMSProp,就可以发现AdaGrad到后面收敛慢的问题。AdaDelta最开始下降比较慢,因为人为没有指定学习速率,在MLP上至少比SGD好。我发现是\epsilon的问题,把AdaDelta的\epsilon1e^{-8}改到1e^{-6}表现好很多。 SGD在这两个模型上都能正确收敛,而且不慢,所以不要小瞧SGD。容易看出,算法在不同模型上表现并不一样,跟超参数学习速率\eta等也有关系,不能一概而论,也不要问什么算法最好这种问题,就像女友一样,只有最合适的没有最好的。


总结

虽然针对不同的任务,应该尝试不同的优化算法。我觉得实在不知道用什么就试试Adam。但是在训练过程中自己调整一下学习速率对于复杂优化目标是必要的(个人观点),比如一个epoch乘以0.5啥的。这就得靠经验了。别以为最普通的SGD不行,还是会被很多人使用,因为谁都不知道训练复杂模型的过程中会发生什么,而SGD是最能保证收敛的。

写了3天,好累。


参考