lec-17 Deep Generative Model

目标： 产生宝可梦的图片已知： 一堆高维空间中的点

参考概率视角下的分类问题参考 Distributed Representation 某一组样本点就是由一个高维空间中的概率分布产生的，只要获得了这个概率分布，我们就可以自己生成样本点。同样的道理，如果我们能找到这堆宝可梦图片（图片也是一种像素表示的高维空间样本点）的概率分布 P(x)，我们就能自己生成图片。

P(某个图片) 值较高 ---> 图片出现概率高 ---> 像是人设计的图片 ---> 图片正常
P(某个图片) 值较高 ---> 图片出现概率低 ---> 不是人设计的图片 ---> 图片诡异

枯叶蝶的进化过程

The evolution of generation

鉴别器会根据 本代生成器产生的图片 和 样本中的图片，来调整自己的参数，保证自己可以查出 生成器图片的瑕疵。

生成器会根据 上一代生成器 和 上一代鉴别器 做改进再生成图片，保证自己的图片可以骗过 上一代鉴别器。

注意生成器从来没有看过样本数据，第一代生成器基本是 random 生成。他的毕生目标只是为了骗过鉴别器。所以它可以生成 样本中没有的图片。这是 GAN 得以 work 的根本。

  鉴别器和生成器都是 NN, 生成器特别像 VAE,他的输入也是某个分布中 sample 出来的 code
  然后经过生成器生成图片。

  鉴别器就是把 生成的图片都 label 为 0.
          把 样本的图片都 label 为 1.
  他们共同组成了 一个 labelled dataset 成为训练集。
  接下来就是一个 binary classification 问题，训练好鉴别器的 NN 之后，输入一个新的图片
  输出这个图片的标签是 0 or 1.

生成器怎么更新换代呢？主要的工作就是【成功欺骗】上代鉴别器把生成器与鉴别器连在一起形成一个 NN,目标是整个 NN 的输出结果尽量接近 1 但是我们只要 生成器做 update, 保持鉴别器的参数不变 Fix the discriminator

>>> loss-fn
--------------------------------------
这里对 NN 的额外要求并没有被做进 loss-fn 中
而是 Fix 住 NN 的一部分来实现
这里提供了一种思路：
*神经网络可以只更新一部分.*
--------------------------------------

z-space 就是 decoder 的输入， 一个 hiden variable 生成器的目标就是骗过鉴别器，所以他重新调整之后会朝着左边移动向着鉴别器输出的分类概率值更大的方向移动。

Demo: http://cs.stanford.edu/people/karpathy/gan/

>>> 如何让某种分布向某个方向移动？
--------------------------------------
这里的 GAN 模型很好的给出了一种，让某种分布自动
的变成另一种分布的方法。
--------------------------------------

但是有两个问题，至今无解：

1. 不知道新的生成器到底会向那个方向移动多少，有可能一下就移过头了，所以需要【非常小心的调整】 参数。
2. 不知道鉴别器是否是正确的，如果鉴别器显的很强能一直找到瑕疵，这不代表鉴别器很好，有可能是生成器太弱了，反之也是。

所以真正在做 GAN 的时候，你会一直不断的让生成器生成一些图片看看是否比以前更好。 GAN 非常难以训练但是他就像大绝招，一旦能熟练的使用，你就牛逼了。彻底的牛逼了。

• GANs are difficult to optimize.
• No explicit signal about how good the generator is
• In standard NNs, we monitor loss
• In GANs, we have to keep “well-matched in a contest”
• When discriminator fails, it does not guarantee that generator generates realistic images
• Just because discriminator is stupid
• Sometimes generator find a specific example that can fail the discriminator
• Making discriminator more robust may be helpful.

Auto-Encoding Variational Bayes, https://arxiv.org/abs/1312.6114

Problems of VAE 他没有真的【学会人的‘观点’】：

新的生成模型：与天敌竞争

Discriminator 鉴别器的本质就是一个 贰元分类器

与 VAE decoder 部分结构一模一样，只是训练方法不同：生成器和鉴别器接起来，但是 fix 住鉴别器的参数，只用 GD 更新生成器的参数，（中间要有一个 layer 跟图片的大小是一样的）表示生成器生成的图片。

Source of images: https://zhuanlan.zhihu.com/p/24767059 DCGAN: https://github.com/carpedm20/DCGAN-tensorflow DCGAN 跟 GAN 都是一样的，不一样的地方是：Layer 的架构都是 CNN 的。 DCGAN = Deep Convolutional GAN

1. Generation
   1. Basic Idea
   2. Unified Framework
   3. WGAN
   4. Evalution
   5. Energy-based GAN
2. Transformation
   1. Paired Data
   2. Unpaied Data

生成模型都离不开概率分布，每一个分布就像一个【模版】，你可以根据模版生成无限的图片目标就是找一个 distribution.

Pdata(x) 就是我们目标分布，data 每个样本就是一个图片，把所有像素连接起来形成一个长向量。

但是目标分布就是 target-fn 一样我们不知道，我们需要找到一个 PG(x;θ) θ是我们可以操控的参数。他是最有可能产生出样本集中数据的一个目标分布的近似分布。

PG(x;θ) 可以是高斯混合，也可以是 NN,我们要的是 NN,但可以通过高斯混合来理解：我要找的就是诸多高斯的 means, variances 和 高斯的 weights.

>步骤< Maximum Likelihood 做 log 转换

这里是用 sample 的方式来计算，那是因为没有办法直接做积分来计算，所以是用 sample 的方式计算，来逼近目标分布：Pdata(x)。

x~Pdata 表示从 Pdata 这个目标分布中 sample x. Ex~pdata[logPG(x;θ)] = ∫Pdata(x)logPG(x;θ)dx

>>> 一句话理解最大似然法：
-------------------------------------------------------------------
*从 pdata 分布中取样的样本，在 PG(x;θ) 中出现的概率的期望（加权平均值）越大越好*
-------------------------------------------------------------------

'- ∫Pdata(x)logPdata(x)dx' 这一项并不会影响求最大值，但是加上之后，整个式子可以化简成：KL divergence KL divergence 的作用就是衡量 两个分布的相似性，衡量两个分布的距离因为是一个距离的概念，所以 KL divergence 始终是正的。

>步骤< 问题就从 Maximum Likelihood —> Minimize KL divergence

高斯混合太不 generalize 了，他是有限制的，他没法 model 不同的 Pdata 我们可以有一个非常 generalize 非常复杂的 PG

θ 就是 NN 的参数。 z 即使是 normal distribution, 而通过一个 NN,完全可以变成一个比高斯分布还要复杂的分布。因为 NN 是十分 power 十分 generalized

PG(x;θ) -—> PG(x) PG(x) 应该是一个什么样的表达式呢？如上图的表达式，有点类似上页 ppt 的高斯混合模型的表达式：注意 I[G(z)=x] 表示： 如果[]内的表达式为真，整个式子返回 1;否则返回 0.

表达式的意义是：

• 从 NN 中输出 x 的几率是多少呢？PG(x)
• 积分所有可能的 z,每个 z 产生的几率不一样。Pprior(z)
• 每个 z 通过 NN 是否恰好能产生 x。I[G(z)=x]

但写成这样，没法算 Likelihood, 因为 G 可能很复杂，算出 PG(x) 都未必能够。没法算 Likelihood ,也就没法用 KL divergence 下面怎么办呢？

>>>>>>>>>>>>>>> GAN 登场，代替 MME+KL <<<<<<<<<<<<<<<

鉴别器可以间接起到 KL divergence 的功能。

假设世界上只有 3 种生成器：G1,G2,G3 在 V(G，D) 函数的图像中可以看到，如果我定住 G，改变 D 就可以产生不同的数值。

>>> 简单理解 arg min max
-------------------------------------------------------------------------------
G* = argmin_G max_D V(G,D)
拆成两个表达式：
1) D* = arg max_D V(G,D)
2) G* = arg min_G V
........................
1) D* = arg max_D V(G,D)
   max_D V(G,D) 这个内层的表达式的意思就是，G 已经给定了，让你找到一个 D 使 V 最大。
   注意函数图像，是固定 Gi 下的 V-D 图像，纵轴 V, 横轴 D.
   PPT 中函数图像上 三个红点的数值的纵轴 就是这个内层表达式的结果，
                 三个红点的数值的横轴 就是附属结果 D
   假设结果是：V = [(G1,3), (G2,5), (G3,2)],
   注意这个结果，这样方便下一步讨论。

   *这一步得到的结果是无限多个这样的 V 值，每个 V 值都对应一个 Gi*
   *然后从中多 V 值中找到最小的哪个 V 值，及其对应的 G*

2) G* = arg min_G V
   min_G V 这个表达式的意思就是，找到一个能让 D* 最小的 G
   整个表达式现在变成：
   V = [(G1,3), (G2,5), (G3,2)]
   G* = argmin_G[(G1,3), (G2,5), (G3,2)]
      = G3
   很明显能让 V 取最小值的是 G3.
-------------------------------------------------------------------------------

然后来看这个 V, 先别想为甚么是这个表达式，先看如果固定住函数 G, 那么 Pdata 和 PG 就是两个固定（但未知）的分布，V = xxx + xxx Ex~Pdata[logD(x)] 就可以理解为 从 Pdata 中 sample 一个 x,恰好被 D(x) 认为是 人画的概率 Ex~PG[log(1-D(x))] 就可以理解为 从 PG 中 sample 一个 x,恰好被 D(x) 认为是非人画的概率

                   两者的差距
   /--------------------^--------------\
   PG 非人画概率                        Pdata 人画概率
   /<-------------------.-------------->/
------------------------+-------------------------->
非人画                                            人画

从图中可以看出，只有 MaxVi 才能衡量出 PGi 和 Pdata 的真实差距（difference）然后从众多眾多真实差距（MaxVi) 中找到一个最小的真实差距，其对应的 Gi 和 Pdata 真实差距最小

因为求出最好的 D(x) 应该是 0~1 之间，所以在设计 鉴别器 NN 的时候，输出神经元的激活函数应该设置成 sigmoid,这样才能输出一个 0~1 之间的值。

每个 Gi 都对应无限多个 D, 找到那个等于 Pdata/(Pdata + PGi) 的 D, 这个 D 对应的 V 就是 maxVi, 也就是 Gi 与 Pdata 之间的真实差距。

PPT 中是分子分母同除以 1/2

JS divergence 是各自与平均的 divergence 之和。 KL divergence 是非对称的，而 JS divergence 是对称的对称是指：JS(A||B) = JS(B||A)

KL 就是衡量两个分布的差距，可见 JS 也是一种分布之间差距的度量。所以这个 max_D V(G,D) 确实在衡量 PG 和 Pdata 的某种差距

这里可以定义不同的 V, 那么就会有不同的 divergence JSD <—> V = Ex~Pdata[logD(x)] + Ex~PG[log(1-D(x))]

JSD(A||A) = 0 JSD(A||A 反) = log2 A||A 反 表示两者完全不同的情况下 JSD = log2 很明显，如果想找到一个 Gi 与 Pdata 真实差距最小，那么就让 PGi(x) = Pdata(x) 这是最理想的。

>>> 总结 GAN 基本过程 G 相当于一个关于 V-D 的函数，D 相当于一个数值

loop1: 首先指定一个函数 G0, 然后找到这个 G0 的最大值点（V0,D0），V0 ∝ JS0 然后根据 D0 找到众函数中对应 V 最小的那个，标示其为 G1

loop2: 在 G1 这个函数中找到最大值点（V1,D1），V1 ∝ JS1 然后根据 D1 找到众函数中对应 V 最小的那个，标示其为 G2 …. —>根据一个函数找到最大点，根据这个点找最小函数–>–\ \____________________________________________

>>> 总结 GAN 基本过程
G 相当于一个关于 V-D 的函数，D 相当于一个数值

loop1:
首先指定一个函数 G0, 然后找到这个 G0 的最大值点（V0,D0），V0 ∝ JS0
然后根据 D0 找到众函数中对应 V 最小的那个，标示其为 G1

loop2:
在 G1 这个函数中找到最大值点（V1,D1），V1 ∝ JS1
然后根据 D1 找到众函数中对应 V 最小的那个，标示其为 G2
....
     /--->根据一个函数找到最大点，根据这个点找最小函数-->--\
     \____________________________________________/

仅仅看 argmin_G(xxx) 括号里的表达式就相当于 loss-fn，也是用 GD

问题是表达式里面有 max, 可以用 GD 么，完全可以，之前已经见过至少 3 个 max 都用 GD 来解了。

>>> GD 解 max
------------------------------------------------
就是看成分段函数，然后做微分即可
这一题，就是看 x 落在哪个区域，然后选择
那个区域最大的 Di ,然后这个区域的微分就用 df/dx = dDi/dx
------------------------------------------------

这个分段函数图像给的真好，每个 Gi 对应无数多个 D 从中找到可以让 V 最大的那个 Di
及其对应的 Vi, 一个 Gi 对应一个 Vi, 无限多个 Vi 对应无限多个 Gi，找到其中最小的 Gi
这是一个很简单的数字大小比较问题，但是回忆一下一开始的那张图，Vi 在找 G 这一步是一个函数。是不同的 Di
加持下的函数：
V1(G,D1)
V2(G,D2)
V3(G,D3)
V4(G,D4)
V5(G,D5)
.
.
他们共同组成一个函数 f(x) ,要在这个 f(x) 上找到最小的 G 这就又回到了 GD 优化问题上来了。

.. |  G0 ---> D0*
.. |         /
.. |        / JS↓
.. |       /
JS |       G1 ---> D1*
.. |             /
.. |            / JS↓
.. |           /
.. |          G2 ---> D2*
.. v             ......

    有一个小小的问题

如下 ppt 所示：

有个比较棘手的问题：我们的步骤是一开始给定 G0, 得到最大化 maxV0 的 D0* 然后固定 D0* 寻找能最小化 maxV0 的下一个 G,将其做为 G1.[下面注意坑来了] 这个新的 G1 就像当于一个新的函数：

 /--->根据一个函数找到最大点，根据这个点找最小函数-->--\
 \____________________________________________/

在这个新的函数上再寻找能 maxV1 的 D,称其为 D1*. 但这并不能保证
maxV1 > maxV2

之前说过：

JS1 ∝ maxV1
JS2 ∝ maxV2

所以 JS1 ?> JS2
因为中间切换了一次函数，不能保证第一个函数的最大值一定比第二个函数的最大值大。
换言之，并不能保证 JS divergence 在逐渐减小。
所以只能假设 D0*≈D1*, 每次 update G 不要太多

通常情况鉴别器都太猛了，图中三個 G, G with 25 epoch 已经很强，但是丢到 D 中，还是被一眼就看出。D 的正确率几乎就是 100%.

这样的问题是： 本来 D 是来测量 JSD 的，但实际上 D 告诉我们关于 JSD 的信息非常的少。

横轴标示第几代的 G, G0,G1,…,G40000 纵轴标示从鉴别器中显示出的 JSD 的度量，可以看到即便时很强的 G 产生出的图片人类都辨别不出真假了， JSD 还是维持一个不怎么变的平缓的值，也就是说 图片变真没有改变 D 所计算的 JSD.

这说明 D 所计算的那个 JSD 没有真实的反映出图片的质量。

为甚么出现这种情况呢？

<MLDS 要做这个>

Scott Reed, Zeynep Akata, Xinchen Yan, Lajanugen Logeswaran, Bernt Schiele, Honglak Lee, “Generative Adversarial Text-to-Image Synthesis”, ICML 2016 Han Zhang, Tao Xu, Hongsheng Li, Shaoting Zhang, Xiaolei Huang, Xiaogang Wang, Dimitris Metaxas, “StackGAN: Text to Photo-realistic Image Synthesis with Stacked Generative Adversarial Networks”, arXiv prepring, 2016 Scott Reed, Zeynep Akata, Santosh Mohan, Samuel Tenka, Bernt Schiele, Honglak Lee, “Learning What and Where to Draw”, NIPS 2016

Conditional GAN 就是要控制你的生成器。

略 Phillip Isola, Jun-Yan Zhu, Tinghui Zhou, Alexei A. Efros, “Image-to-Image Translation with Conditional Adversarial Networks”, arXiv preprint, 2016

The data we want to generate has a distribution Pdata(x) 我们认为我们要生成的点来自于一个概率分布，这里的 x 可以是任何东西，图片，句子，视频等等。

假设蓝色部分是 Pdata 概率较高的部分，蓝色区域以外是概率较低的部分。从概率高的部分 sample 出的图片就像模像样，概率低 sample 出的图片就很模糊。

输入一个 Normal Distribution 经过一个 GAN 生成一个 复杂且未知的 Distribution. 我们希望调整 NN 的参数，来让生成的 PG 跟 target distribution Pdata 越接近越好。

但是难点在于，我们没办法直接计算 PG(x),给定一个 x 没法算出 PG(x) 是多少，如果能算出 PG(x) 就可以使用 Maximize Likelyhood. 也就是说给你一张图片，我根本不知道 GAN 产生这个图片的概率值是多少。

唯一能做的事情只剩下 sample. 从 z: normal distribution 中 sample 一些点

一开始的分布是如图，产生一个 D1(X):使得靠近绿色分布的地方输出高，蓝色地方的输出低蓝色分布会向右边移动， 移动的过程中有可能跑过头，然后训练一个新的 D2(x):仍旧是绿色函数值高，蓝色低函数值 …… Di(x): 随着蓝色分布和绿色分布重合的越来越多，Di(x) 会越来越平缓直到最后，两者重合，Di(x)变成一条直线。

• Sebastian Nowozin, Botond Cseke, Ryota
Tomioka, “f-GAN: Training Generative Neural
Samplers using Variational Divergence
Minimization”, NIPS, 2016
• One sentence: you can use any f-divergence

Basic Idea 讲的是 GAN 与 JSD 有关，但你可以重新定义 V 定义完全不同的 divergence

f-divergence 定义了一个 divergence 框架，上面的公式 f 可以是任何的函数，只要满足：

1. f is convex
2. f(1) = 0

这两个条件即可。

--------------------------------------------------
下面的这个 convex f 的转换是这节课的重点，不理解也要背诵下来：
∫qf(p/q)dx >= f(∫q(p/q)) = f(1) = 0
--------------------------------------------------

每一个 convex function 都有一个‘伙伴’叫做 conjugate 每一个 convex f 都有一个同源函数 f* 这里的 f* 的感觉有点像是上一节 basic idea 中 G&D 的取值方式先固定函数 G 在 G 里找一个最大值 D,然后固定 D,在所有的函数中找最小值。

这里也是假设给定一个 t1: f*(t1) = max{xt1 - f(x)} 也就固定了一个函数：xt1 - f(x) 从这个函数中找到最大值：x1

如果给定另一个 t2: 也就固定了另一个函数：xt2 - f(x) 从这个函数中找到最大值：x3

如果没有给定 t,而是给定 x 呢？那么 max 里面那部分就只是 3t - 2 这种形式, 也就是一个线性函数而已。不同的 x 会对应不同的线性函数。

下面就给定一个 t, 看看哪个函数可以给你一个最大值。比如给定 t1, 照着他画一条直线，看看切过的所有线性函数里哪一个最大。就选那个函数。最后构成一个凸函数：f*(t)

所以也把这个函数背下来吧，整个函数的意思就是： 用小树枝搭一个鸟巢，用最上面那一层 f'(t) = max(xt - f(x))

t 作为未知数，给定不同的 x 值，就会根据 xt-f(x) 产生不同的直线。每一个 t 值都对应无数个 x, 每一个 x 都对应一个线性函数。每一个 t 值都从无数个线性函数中挑一个最大的。

因为凸函数存在一个同源函数，所以我们可以把 f-divergence 里的可以随便设置只要满足两个条件 1.convex 2.f(1)=0 的这个 f 置换成 他的同源函数的表达式: f(x) = max{xt - f*(t)}

置换之后，把 t 用 D(x) 取代，怎么跑出来一个 D(x) 呢？ 暂时不要想這些，只需要直到 D 是一个函数，输入 x 输出 t: t = D(x), 但是没法保证这里的 D(x) 输出的 t 可以让上面的式子 max. 所以这里用一个 >= ,表式这是一个 lower bound.

因为带 D 的表达式是 f-divergence 的 low-bound, 如果我能最大化这个 带 D 的表达式，他不就逼近 f-divergence 了么。 所以下面的工作就是：argMax_D(xxx). 找到一个可以让 low-bound 最大的 D.

>>> 我去！如何从高数到概率，这个转换数次用到，很重要
------------------------------------------
怎么把积分变成期望再变成取样：
做期望值这件事情可以用取样来近似
积分  --->  期望 ---> 取样
∫p(x)f(x)dx = Ex~p[f(x)] ≈ samples from p
------------------------------------------

实际做的时候没法算积分，所以只能用 sample 的方法来近似了。到这里既可以看看 basic idea of GAN 了。

>>> 如何定义 V
------------------------------------------------------
这里是类似的，只是在 basic idea of GAN 中没有指明 V 是从哪来的。
这里可以看出，V 是如何定义的：
找出一个 convex-fn f, 找到他的 conjugate-fn f*
把他们带入 Ex~pdata[D(x)] - Ex~pG[f*(D(x))] 就可以了
------------------------------------------------------

>>> double-loop algo
---------------------
give G0
loop: to get (Gi+1,Di)
      loop: to get D0
      once: to get G1
---------------------

>>> single-step algo
-----------------------
give G0 D0
loop: to get (Gi+1,Di+1)
      once: BP,D↑
      once: BP,G↓
-----------------------

感觉 single-step algo 不但实做简单，而且更容易理解：
每一次 D 要朝着让 V 变大的方向走一步
      G 要朝着让 V 变小的方向走一步

https://arxiv.org/pdf/1606.00709.pdf

当 Generator 不够强的时候，确实会有差别比如当你想要用一个高斯来逼近混合高斯时，minimize 不同的 divergence 会产生完全不同的近似结果。

可以看到，当 data 分布是由两个高斯产生的时候， minimize JSD 会让近似的高斯很【偏激】 minimize KLD 会让近似的高斯很【中庸】

这也让一个认识被【证误】了：
-----------------------------------------------------------------------------
× 过去大家都认为 GAN 生成的图片总是【太集中，多样性不够】是因为我们选取的最小化目标 V 是 JSD
-----------------------------------------------------------------------------

但通过下面那张表可以说明：（这里我没听懂，为甚么那张表可以说明 不论用哪个 divergence 生成的图片都会很集中，很没有多样性）

如何 sample Ppenalty 点？

1. 从 Ppenalty 和 PG 各 sample 一个点
2. 两个点连线，再从线上 sample 一个点作为 Ppenalty 点

可以想成 Ppenalty 就是介于 Pdata 和 PG 之间的一个分布

原 paper 给出为甚么这么做的解释：

“Given that enforcing the Lipschitz constraint everywhere is intractable, enforcing it only along these straight lines seems sufficient and experimentally results in good performance.”

李老师给出为甚么这么做的解释：

Only give gradient constraint to the region between P data and P G because they influence how P G moves to P data

鉴别器 D 的作用是什么，就是引导生成器分布 PG 挪向 Pdata. 所以真正重要的是 Pdata 和 PG 之间的连线的斜率才会真正影响这个‘挪动’。而连线以外的事情就算有影响也是小的。所以仅仅关注 Ppenalty 分布中处在 PG 和 Pdata 之间连线的部分。

与 max(0,//∇xD(x)// - 1) 相比我们更希望 ∇xD(x) 越接近 1 越好。

回忆一下我们对于 D(x) 的期望，我们希望他可以做到很好的【辨别】出 Pdata 和 PG
两个分布的点，借以【引导】G 生成器来优化自己。所以单就【辨别】这个目标来看，我们
希望：D(x) (x 假设是图片）
           1) 当 x 处在 Pdata 附近时 D(x)值越大越好；
           2) 当 x 处在 PG    附近时 D(x)值越小越好；
           1) + 2) ====> D(x) 斜率要足够大
但是由于之前的限制（g radient penalty），我们不希望 D(x) 太陡峭，也就是 D(x)
的 gradient <=1. 所以：
           //∇xD(x)// -> 1   <===> (//∇xD(x)//-1)^2 -> 0

“One may wonder why we penalize the norm of the gradient for differing from 1, instead of just penalizing large gradients. The reason is that the optimal critic … actually has gradients with norm 1 almost everywhere under Pr and Pg” (check the proof in the appendix)

“Simply penalizing overly large gradients also works in theory, but experimentally we found that this approach converged faster and to better optima.”

之前的例子是：
            sentence -> _image_
现在我想做一个类似 chat-bot 的东西，它可以：
            sentence -> _sentence_

怎么做呢？前面不用动，我只要能把 sentence 也表示成一个 'image' 就可以了。

image 可以是固定大小的 matrix, sentence 怎么变成 matrix 呢？
      回忆如何把一篇文章构造成一个长向量，bag of word 是把整个常用英文词典
      构成一个长向量，每个单词出现的次数就是长向量相应位置的值。这个向量得以成型的重要
      原因是词典的【长度是固定】的，一整个长向量就代表一篇文章。

      对 'good bye.' 用 one-hot encoding, 如果把【句子的长度给定住】－－－句子
      的长度按字母和符号个数度量， 每个字母和符号都可以代表长向量的一个位。那么一个定
      长的句子，就可以【句子长度×每个字母的句子长度向量】这样一个正方矩阵来表示。

句子不可能都是一样长的，该怎么办呢？这个简单，把句子长度设置 1000 个字母，然后如果句子短，不够 1000 的部分全部用一个自己规定的‘null’的 one-hot encoding 来补全就可以了。

还一个问题：真实的句子都是每一个位置是 1 or 0 的矩阵，而通过 GAN 来训练的时候，目标字母分布是一个概率，我们生成的矩阵可能都是概率，0.1 or 0.9 这样的。就算加 soft-max 来让大的更大小的更小，也没法让小的变成 0. 这样又会遇到与 image generation 一样的问题：JSD 太跳跃了，导致所有从 G 生成的句子都会被 D 认为是假的。 WGAN 出现来解决这种情况。

•••SeqGAN

• Lantao Yu, Weinan Zhang, Jun Wang, Yong Yu, SeqGAN: Sequence Generative Adversarial Nets with Policy Gradient, AAAI, 2017 • Jiwei Li, Will Monroe, Tianlin Shi, Sébastien Jean, Alan Ritter, Dan Jurafsky, Adversarial Learning for Neural Dialogue Generation, arXiv preprint, 2017

•••Boundary seeking GAN • R Devon Hjelm, Athul Paul Jacob, Tong Che, Kyunghyun Cho, Yoshua Bengio, “Boundary-Seeking Generative Adversarial Networks”, arXiv preprint, 2017

•••Gumbel-Softmax • Matt J. Kusner, José Miguel Hernández-Lobato, GANS for Sequences of Discrete Elements with the Gumbel-softmax Distribution, arXiv preprint, 2016 • Tong Che, Yanran Li, Ruixiang Zhang, R Devon Hjelm, Wenjie Li, Yangqiu Song, Yoshua Bengio, Maximum-Likelihood Augmented Discrete Generative Adversarial Networks, arXiv preprint, 2017

这里的想法是这样的：
找一个 F(x),Pdata 的图片让他的值很高，PG 的图片 让他的值比较低，找到
一个能让 F(x) 很大的 x,然后我就能通过 F(x) 来产生图片。

我们之前的想法是这样的：
我们有一堆已经准备好的图片，我们假设这些图片都是出一个分布种取样出来的。
既然可以取样出来至少说明，他们再这个分布中的概率比较高，所以我们给出这样的推断：
          符合人的逻辑和审美－－》取样出来的－－》概率高
          不符合人逻辑和审美－－》取样出来的－－》概率低
也就是说，我们手上的图片处于这个分布的高概率区域，而没有的那些图片，那些不符合
逻辑和审美的图片处于低概率区域。

但是我们不知道这样一个分布是什么样子的，所以我们希望训练出一个分布，来逼近这个目标
分布。然后从这个分布中 sample 一些点出来，既然能被 sample 出来，而且训练的分布
和目标分布很相似，我们就认为 smaple 出来的图片也符合这样的推断：
          符合人的逻辑和审美－－》取样出来的－－》概率高
          不符合人逻辑和审美－－》取样出来的－－》概率低

>>>>>>>>>
但是，似乎我们并不需要哪些‘不符合人逻辑和审美的’图片，最好就根本 smaple 不出来他们。
所以我们不仅仅是：
          训练一个分布逼近目标分布。
          通过 D(x) 的取值来引导分布的移动。
我们更希望：
          训练一个分布他可以把目标分布的高概率区域更高； 低概率区域更低。
这是一种思想，在 structured perceptron 中也有。

在 structured perceptron 算法里面就有这种思想：更新 w 的时候，增加对的，减少错的。但是在整个算法中，穷举所有的 y,找到最好的 y~ 这一步是很麻烦的。

原来的视角：D(x)是指定的某个函数，只不过形状会有所变化

新的视角：F(x) 不指定为任一函数，随圆就方

这是另一种 train GAN 的视角：与之前那种固定 D(x)(eg:sigmoid,linear), 然后让 PG 朝 F(x)更大值的地方移动不同。 这里的方法是说：F(x) 不事先假定其为 sigmoid 形状 or linear 形状， F(x) 像是一块布（一个随时变换的函数），凡是 Pdata 范围的点就往上抬，凡是压到 PG 的范围就使劲压，直到 PG 被‘捋’到 Pdata 那里为止，这时候往上抬和往下压的力量相互抵消，

最后 F(x) 和 PG 就都变成和 Pdata 一样的了

所以 F(x) 和 D(x) 有两点不同：
--------------------------------------------------------
1) D(x) 事先指定函数，   F(x) 不指定函数
2) D(x) 最后还是这个函数，F(x) 最后会成为和 Pdata 一样形状的函数
3) D(x) 仅仅引导 PG 向 Pdata 移动
   F(x) 不仅引导 PG 向 Pdata 移动，而且最后 F(x) = Pdata
--------------------------------------------------------

Experience replay: parameters from last iteration 新视角下的 GAN 训练的参数可以复用。

可以复用 —> Energy-based

1. Viewing the discriminator as an energy function (negative evaluation function)
2. Auto-encoder as discriminator (energy function)
3. Loss function with margin for discriminator training
4. Generate reasonable-looking images from the ImageNet dataset at 256 x 256 pixel resolution without a multiscale approach

这里要统一称呼，原来 GAN 的 discriminator 改为用 F(x), F(x) 取相反数就是 energy-function. 这个叫做能量函数值越小越好。能量函数 = \\x - x~\\, 能量值就是 reconstruction-error

这里生成的图片经过 endocer-decoder 之后还是 image,但是 GAN 要求鉴别器输出的是一个 scalar. 所以就用训练 encoder-decoder NN 的方式，比较 x 和 x~ . 对这个向量取 norm-1 distance. 这实际就是一个 reconstruction error. 这个 \\x-x~\\ = [0,∞], 如果 x 是一个真实图片希望这个值接近 0, 如果是一个生成图片希望这个值越大越好。这一点跟 WGAN 和 GAN 是真好相反的。

鉴别器的训练就是要 minimize:
     LD(x,z) = D(x) + max(0, m-D(G(z))
     m 就是 margin, 事先定好的值，后面会讲到动态 margin
生成器的训练就是要 minimize:
     LG(z) = D(G(z))

Energy-fn 是 -F(x), 上面 ppt 展示的就是 Energy-fn 的函数图像。

鉴别器训练：
    最原始的想法是：让 Pdata 图片的能量函数值越小越好，让 PG 图片的能量越大越好。
    但是这样做：对于 autoencoder 是有问题的“hard to reconstruct, easy to destroy”
    所以，autoencoder 会倾向于随机搞 PG,也就是 reconsturction error -> ∞

    所以，不能让 PG 图片的能量越大越好，而是给一个 threshold:m, 能量一旦超过 m,就把
    这个图片的能力置 0. 图片在 m 以下才计算他与 m 的差值作为能量。
    一旦大过 m, minimize LD(x,z) = D(x) ,也就是集中对 Pdata 图片的能量进行最小化。
    这是合理的。
生成器训练：
    生成器训练的目标只有一个，就是希望生成的图片的能量越小越好。
    既然 real data 能量小，generated data 就会往 real data
    区域靠近。

这个式子 LD(x,z) = D(x) + max(0, m-D(x)) 当最后结果，PG 与 Pdata 一致了，会出现什么情况呢？假设 D(x) = γ， 所以当γ = 0, LD = m 0< γ < m, LD = γ + m - γ = m γ = m, LD = m

>>>>>>>>>>> [qqq]这里几乎没听懂 <<<<<<<<<<<<

Pulling-away term 是希望生成器可以生成多样性较高的图片。

xi --> Encoder -> ei -> Decoder --> xi~

这里取一堆生成图片：S={...xi...xj...}
取各个图片的中间结果：{...ei...ej...}

计算他们两两之间的 cos 相似性：fPT(S) ,希望这个值越低越好，
fPT(S)越低 --> diversity 高

>>> 如何更好的训练这个 auto-encoder for EBGAN
----------------------------------------------------------------
不但希望，auto-encoder 可以最小化 real image 的 reconstruction-error
还希望，他可以最大化 fake image 的 reconstruction-error, 以此制衡 auto
encoder 达到 regular 的效果。
----------------------------------------------------------------

EBGAN 中的 LD 中的 m 设置多少合适呢？

只看两张图中 EBGAN 的部分：
ppt 上面是 real data 的 energy
    可以看到好像前给个轮数模型的力气都用来让 generated data 的能量上升了
    所以 real data 在前几轮并没有发生什么变化，直到后面才开始下降。
ppt 下面是 generated data 的 energy, 其中黑线是 m 的 log 能量值
    可以看到，随着轮数进行的越来越多，生成图片的能量值确实会超过 m.

再看 MAGAN 的部分： 两张图中的能量都是在下降，似乎是说，生成器很快就学会如何生成以假乱真的图片了

MAGAN, 动态的 margin Dynamic margin m: As the generator generates better images, the margin becomes smaller and smaller

LSGAN 也是一个 adaptive margin

Reference: Guo-Jun Qi, “Loss-Sensitive Generative Adversarial Networks on Lipschitz Densities”, arXiv preprint, 2017

LSGAN allows the generator to focus on improving poor data points that are far apart from real examples. Connecting LSGAN with WGAN

Δ(x,G(z)) 是表示两张图片的差距：具体怎么计算可以用像素间的差距（效果不好），也可以用
          train 好的 CNN,把某个 hiden layer 拿出来看两者像不像（效果好）

三张图片：G(z), G(z'), x
x - real image
G(z) - bad generated image
G(z')- good generated image

LSGAN 完全可以对比 EBGAN 的 LD 来理解：
EBGAN LD:
LD(x,z) = D(x) + max(0, m-D(G(z)))
LSGAN LD:
LD(x,z) = D(x) + max(0, Δ(x,G(z)) - (D(G(z)) - D(x)))
                        ---------    --------------
                            m            D(G(z))



因为 Δ(x,G(z)) 很高， 这个式子会把 G(z) 顶的高一点；
因为 Δ(x,G(z')) 不高， 这个式子会把 G(z) 顶的低一点；
怎么‘顶’的呢？
D(x) - D(G(z)) > 两个图片之间的差距Δ(x,G(z)), 这个就是 margin
因为两张图片的差距会随着生成器能力不同而产生不同的图片，所以
这个 margin 是一个动态的。


这个 margin 的概念在 structured learning 中也有用到。

Ref: David Berthelot, Thomas Schumm, Luke Metz, “BEGAN: Boundary Equilibrium Generative Adversarial Networks”, arXiv preprint, 2017

着他妈产生的人脸也太 tm 好了吧

   之前说过直接 - D(G(z)) 会有问题，这里是加了一个跟轮数有关的 kt.

   一开始 k0 = 0, 也就是说不管 D(G(z)),只让鉴别器把精力放在 最小化 D(x)上

   什么时候 kt 开始增加呢？也就是什么时候开始考虑 fake image, 开始考虑把 D(G(z))开始拉高呢？
   γ 是一个需要自己设置的值； λ 就像 learning-rate 一样是一个正值。

   当 D(G(z))/D(x) < γ， 也就是当 D(G(z)) 太小的时候,也就是当 fake image
   的 reconstruction-error 太小的时候。

上面的是机器生成的，下面的是 celebA 的。

作业四 Outline • Policy Gradient • SeqGAN • Two techniques: MCMC, partial • Experiments: SeqGAN and dialogue • Original GAN • MadliGAN • Gumbel

要记得之前的对话，之前说过的句子也要放进 encoder 里面去

用 RNN 把输入的句子读一遍。

如果你希望还考虑对话者的表情，那么你就可以再接入一个图片信息作为 encoder 的输入。总之，encoder 可以吃各种各样的输入，这取决于你希望 chat-bot 要考虑多复杂的情况。

如果今天 input-information 比较复杂的话，你可能需要一个 hierarchical encoder. 然后你就会有第二阶 encoder(红色方块),他吃比较低阶的 encoder 的输出，然后再做一次 encode.把输出丢给 generator

[勘误]左下角应该是 encoder,不是 decoder

encoder 给了 generator 一个 vector. 然后 generator 产生一个 word 的分布，表示产生的句子的第一个词汇，除此之外还会给 generator 一个特别的 symbol,代表 begin of sentence.

这里的 generator 一般是一个 RNN.他在第一个 time 输出一个 word distribution. 然后我们从这个 word distribution 里面 sample. eg, sample 的是 word B, 这就是句子的第一个单词。

然后把这个 word B 用 one-hot encoding 编码，然后跟新的 encoder 的输出一起丢到 RNN 在第二个 time 里会产生第二个 word distribution. 然后根据这个 distribution 再 sample 出一个单词。eg, sample 出 word A

如果给 红色的方块 encoder 加入 attention mechanism 的话，encoder 会是不一样的。

training 的时候你有标准答案，标准答案会告诉说，现在应该输出什么样的 sentence. 假设 sentence 应该是 ABB.

在第一个 time, model 就会看自己的输出跟 sentence 第一个 word:A 会有多少差异性。差异性：就是算 time-1 输出的分布与目标分布的 cross-entropy:C1

接下来在 training 的时候会把 Reference 丢到下一个 time. 而在 testing 的时候会把 time-1 的输出 丢到下一个 time.

第二个也是一样的过程。

把所有的 C: C1,C2,C3… 统统加起来作为 loss-fn. 调整所有的 encoder 和 generator 的参数来 minimize loss-fn.

[勘误] -logP(x1|h)P(xt|x1:t-1,h)... 应该是 -logP(x1|h)P(x2|x1:1,h)...
                    ^    ^                             ^
就是展开 C 的和式，然后 log 相加变成相乘再 log: loga + logb = log(a*b)

minimize cross-entropy 之和，就是 maximize log likelyhood. 为甚么呢？

假设我们的训练数据是：（h,x^），input h, output should be x^.
h and x^ 都是 sentence.
h 可以是一个句子和一些历史、环境信息（语者的表情等等）

x^1:t, 表示 x^ 这个句子的第 1 到 t 个 word.

t=0 P(h) ---*
t=1 P(x1|h) |-> P(x1,h)--*
t=2 P(x2|x1,h)           |-> P(x2,x1,h)--*
t=3 P(x3|x2,x1,h)                        |-> P(x3,x2,x1,h) = P(x^,h)
但是现在没有 P(h), 他们都是连乘关系，所以去掉 P(h) 后的结果为：P(x^,h)/P(h) = P(x^|h)

C = -ΣlogP(xt|x1:t,h)
  = -logP(x^|h)
        -------
          V

这个公式代表什么呢？

就是如果给定 h,希望输出 x^ 的概率越大越好。所以传统的方法 train 这个模型的方法就是：maximize likelyhood. 下面讲怎么用 RL 来代替 maximum likelyhood 来训练这个模型。

想象出有一个人，他在模型输出之后，会把模型的输入和输出一起拿过来看一看是不是 input 和 outpu 匹配的足够好。人会给这个输入和输出打分： Reward(h,x)

机器要做的就是 update θ，使得之后 input 产生新的 output,这个新的 (h,x') 对可以获得 Reward 越高越好。

Expected Reward: R-θ R-θ 的意思是：如果 chat-bot(encoder+generator) 以后都用 θ 这套参数跟人互动，他 期待得到的 Reward 会是多少。

.  Rθ = ΣP(h)ΣR(h,x)Pθ(x|h)
.       -----
.       v
.       穷举世界上所有可能的输入 h 的概率之和
.
.  Rθ = ΣP(h)ΣR(h,x)Pθ(x|h)
.            -------
.             v
.           所有可能的 Reward,为甚么是所有可能的 Reward 呢？
.           因为给固定的 h, 这个 chat-bot 的输出可能是不一样的，
.           因为 chat-bot = encoder + generator,
.           而 generator 是一个 RNN 他的输出是一个 distribution
.           然后 sample 出一个 word, 有一定的随机性。
.           虽然有随机性，但是分布是固定的，怎么固定的呢？通过 h 和 θ。
.                                                /
.  Rθ = ΣP(h)ΣR(h,x)Pθ(x|h)   <-----------------/
.                   -------
.                    v
.                 在给定 h 和 chat-bot 的一套参数 θ 的时候
.                 chat-bot 输出 x 的几率是多少。
.
.  Rθ = ΣP(h)         ΣR(h,x)Pθ(x|h)
.        ---           -----  -----
.       所以可能的输入    reward 所有可能的输出

下面的事情就是找到一个 θ 来最大化 这个 Rθ

>>> 这里又见到： 积分（和式）-> 期望 -> 取样 -> 平均

但是想要求 θ* = argmax Rθ
需要用 Gradient ascent， 需要求 ∂R/θ

where is θ？

但是这里经过 积分（求和）－》期望－》取样－》平均 这一套近似之后
变量里已经没有 θ 了。 虽然形式上的没有 θ，但其实 θ 是隐藏起来了。
θ 会影响 sample 出来的值。

但我们用 Gradient ascent 是需要形式上的θ的。怎么办？Policy Gradient

这里依然使用 RNN 作为 Generator。这时候就不需要 code 在这个 normal distribution 来提供·「随机性」， 因为 RNN 的输出本身就是一个 distribution. 他会再从这个 distribution 中 sample 一个点作为 sentence x。

train 这个 model 需要两个步骤：

1. 训练鉴别器：鉴别器的目标就是让 fake sentence 对应的输出越低越好让 real sentence 对应的输出越高越好。这里的鉴别器可以使用任何的 GAN 来做，普通的 GAN 来是 WGAN 都可以。
2. 训练生成器：稍微有点麻烦

[作业三是 conditional GAN]

Chat-bot 跟 sentence generation 不同需要使用 conditional GAN

一个 chat-bot 就是一个生成器，然后放在整个 GAN 里面来 train. 目标就是让 chat-bot 产生的句子越来越像人对话。

这里使用 conditional GAN. 鉴别器的输入是两个东西：一个是 chat-bot 的输入，另一个是 chat-bot 的输出，然后通过比对真正的人的对话，来给 chat-bot 输入和 chat-bot 输出的匹配程度打分。

T 表示经过 T 个 time,每个 time 输出一个单词，总计 T 个单词。
Q(hi,xi1,xi2,...) 对比原式理解  R = Σ(R(xi,hi)-b)logP(xi|hi)
                              R = Σ{(Q(x1,h1)-b)logP(x1|h1)+
                                    (Q(x2,x1,h1)-b)logP(x2|h1,x1)+
                                    (Q(x3,x2,x1,h1)-b)logP(x3|h1,x1,x2)

.
.   /-----------------------\
.   h -->chatbot--> x1 -->R(x1,h)
.
.   /-----------------------\
.x1,h -->chatbot--> x2 -->R(x2,x1,h)
[对 RL 的 seq generation 理解不够]

这样就可以理解 Q 为甚么是这个样子了？然后如何计算 Q: 1. 蒙特卡洛搜寻算法 2. DFPDS

从训练数据中抽出一部分作为 seqGAN 的训练数据，之前 seqGAN 的训练数据是从分布中直接 sample 出来的，没有利用這些已知的数据。

>>>>>>>>>>>>[qqq] 这里没听懂 <<<<<<<<<<<<<<

对话质量是一件很主观的事情，怎么衡量对话质量的好坏呢？

把 seqGAN 先当作一个学生，用一个很容易比对好坏的模型 LSTM 去生成一些 data 用他来作为数据，喂给 seqGAN 看 seqGAN 的【学习能力】如何，看他能不能学到 LSTM 这个生成模型的概率分布。

然后让 LSTM 计算所有 seqGAN 生成的句子的 NLL,越 small 越 better.

MLE = maximum likelyhood

To learn more …… • Professor forcing • Alex Lamb, Anirudh Goyal, Ying Zhang, Saizheng Zhang, Aaron Courville, Yoshua Bengio, “Professor Forcing: A New Algorithm for Training Recurrent Networks”, NIPS, 2016 • Handling discrete output by methods other than policy gradient • MaliGAN, Boundary-seeking GAN • Yizhe Zhang, Zhe Gan, Lawrence Carin, “Generating Text via Adversarial Training”, Workshop on Adversarial Training, NIPS, 2016 • Matt J. Kusner, José Miguel Hernández-Lobato, “GANS for Sequences of Discrete Elements with the Gumbel- softmax Distribution”, arXiv preprint, 2016

(and other generative models)

• Lucas Theis, Aäron van den Oord, Matthias Bethge, “A note on the evaluation of generative models”, arXiv preprint, 2015 这篇 paper 不是针对 GAN 写的，而是针对所有的 Generative model 生成模型所以具有普适性