机器学习笔记(二)

Lecture2.Where does the error come from

机器学习笔记(1)：回归Regression中讨论的情况显示，模型越复杂并不一定error越小。那所以这些error到底来自什么地方呢？
1. bias
2. variance
在具体训练过程中，如果可以诊断error的来源就可以选择合适的方法来improve你的model。

假设真实模型（or函数）是 f^ f ^ 而预测模型是 f∗ f ∗ ，我们把 f^ f ^ 当作是靶子的靶心，而 f∗ f ∗ 是我们在靶子上预测的一个点，那么它们之间的距离就是 bias+variance b i a s + v a r i a n c e 决定的。

Variance

用的数据不一样，即使是用一样的模型( y=b+wxcp y = b + w x c p )来预测， 最后求解出来的参数 F∗ F ∗ (estimator)也是不一样的，贯彻不同模型下的100个estimator：

模型越来越复杂的时候，实际上上variance容易比较大，就是说，找到的estimator都比较散的开。简单的model比较不会受sample的影响，但是复杂的model会容易受到sample的影响。我们直接考虑最简单的模型 y=C y = C ，不论输入多少数据都不会对模型有影响，而模型越复杂的话，稍微输入不同的数据就容易拟合成不同的参数。

Bias

把所有的 f∗ f ∗ 进行平均得到 f¯ f ¯ ，会接近 f^ f ^ ，这个 f¯ f ¯ 和 f^ f ^ 之间的差就可以认为是bias。
而对于越简单的模型来说，bias可能是越大的，对于更复杂的模型， f¯ f ¯ 的bias会更小。

直观的解释，在定义一个model的时候，其实就是定义了一个function set，那么我们求解的 f∗ f ∗ 就是从中找到距离 f^ f ^ 最近的一个函数，那么如果function set中没有包含这个 f^ f ^ ，那么怎么找都找不到最优。但是在模型复杂的时候，function space就比较大，可能会包含这个target，那这个时候可能由于training data不够所以每一次找到的 f∗ f ∗ 都不一样，但是如果 f∗ f ∗ 是都散布在target附近的话(其实只要包含了target在function space里面，就一定会有 f∗ f ∗ 散布在附近的)，平均之后就会获得target的function。

综合考虑

随模型变复杂，error from variance变得越来越大，而error from bias变得越来越小，如果要取得一个trade-off，就要综合两者error一起考虑。
如果error来自于variance很大，这个状况就是overfitting。
如果error来自于bias很大，这个状况叫做underfitting。
那怎么知道状况是bias大还是variance大呢？
如果模型没有fit这些训练样本，就说明bias很大，即underfitting。
在training data上error小，但是在testing data上拟合不好，这就说明variance大，即overfitting。
当bias大的时候，需要重新设计你的模型，因为这个时候target不在function set中。
- 加入更多的特征作为输入
- 将模型变得更复杂

当variance大的时候，

• 增加training data
  是一个很有效的控制variance的方法，但不一定现实。maybe你可以generate false data according to your knowledge.

• 正则化regularization
  在model后面加一个term，term前面含一个weight，weight代表你希望这个曲线有多平滑，weight越大曲线越平滑，则variance会更小，但是在调整weight的时候就相当于只包含了比较平滑的function，那么有可能损害到bias(function space中可能不再包含 f^ f ^ )，所以选择的weight就需要在bias和variance之间取得一个平衡(trade-off between bias and variance to minimize the total error )。

Attention
在training data上，训练model，然后在testing data上做测试，求得model能在testing data(public set)上error最小的在未知testing data(private set)上的error未必是最小的，通常private set上的error是大于public set 上的error的。
rank in the public leaderboard doesn’t fit in the private leaderboard.

Solution：Cross Validation
将training data分为两组，一组(training set)拿来train model，一组(validation set)拿来选model(用error)，（如果担心training data变少了，就可以在选定model后利用全部的training data去训练model一次）。
这个时候的testing set上的error会大于validation上的error，但是只有这个时候的error才能反应在private set上的error。
不建议采用public set的error去调整模型参数，就相当于把public set上的error考虑进去了，调整以后，public set上的error就不能再反映private set上的error了。
public set上的结果不是最终的结果，有时无法避免要把testing error调整好(to look good)，但是实际上benchmark上的error是应该会大于在实际application上的error的，因为存在已经根据testing error去修改参数的这种手段。
如果validation set上的结果分错(bias不合理)，可以做下面这件事N-fold Cross Validation，操作举例three-fold validation（training set分为三分，其中两份为training set，一份为validation set，交替进行），不同的模型在不同的training+validation的分配下的error均进行求解，最后求出一个average error，average error最小的认为是最小的model，则将整个training data在best model上完整train一遍，之后在testing set(public)上进行测试，不要继续因为testing error调整参数的话，这个时候在public和private set上的error会比较接近。

Lecture3.Gradient Descent

之前介绍过整体框架，之后要介绍一些tips讲如何把它做得更好。
在ML的整个框架中的第三步中，是要找一个最好的function，即解一个optimization的问题。损失函数是model中的参数的函数，

θ∗=argmaxthetaL(θ) θ ∗ = a r g m a x t h e t a L ( θ )

L(θ) L ( θ ) 就是评价一组参数 θ θ 有多不好，所以loss function是要minimize的。如果是要maximize的话，即参数越好函数值越大，就可以叫做objective function

Tip1：learning rate
1. 每过几个epoch就减少一次learning rate，因为在离local minimum比较远的时候，选择learning rate比较大，可以让收敛的速度比较快，而在靠近minimum的时候呢，因为靠近minimum了，就让learning rate小一点，可以最后收敛到minimum。
2. 但是1也不是最好的方法，而是给不同的参数以不同的learning rate，最简单的叫做adagrad(不是说最强，但是是一个根据参数确定不同学习率的一个好例子)，即每一个参数的learning rate ηt=ηt+1√ η t = η t + 1 都除以之前的导数的root mean squar σt σ t 。（这中间就有 η η 是time-dependent，而 σ σ 是parameter dependent的， t+1−−−−√ t + 1 抵消后，最后学习率就是parameter dependent的）比adagrad更强的一般可以采用adam
3. 参数更新主要受到两个因素影响，一件是lr，一件是gradient，vanilla中是g越大就更新越快。

wt+1←wt−ηtgt w t + 1 ← w t − η t g t

(Vanilla GD)
但是新的更新法则Adagrad

wt+1←wt−η∑ti=0(gi)2−−−−−−−−√gt w t + 1 ← w t − η ∑ i = 0 t ( g i ) 2 g t

gt g t 就告诉我们梯度越大会导致下降越快(larger step)，但是 η∑ti=0(gi)2√ η ∑ i = 0 t ( g i ) 2 中显然又有梯度越大下降越慢(smaller step)，这个矛盾在，怎么直观的解释一下这件事情呢。adagrad考虑的事情就是今天这个grad有多surprise，有多反差，实际上求平均就是为了将每一次的grad都考虑进去，当反差很大的时候会导致两者一起控制变化速度而最终有一个合适的速度。
4. 在模型只有一个参数时，算出来的梯度越大就离最好的solution越远这件事情是只有一个参数时才成立的，而如果是有多个参数(cross parameters)的话，是不一定成立的，也就是不能根据梯度大小决定步长大小。参考自二次函数， thebeststep=|1stderivative2ndderivative t h e b e s t s t e p = | 1 s t d e r i v a t i v e 2 n d d e r i v a t i v e ，所以adagrad就是在模拟这种形式，考虑进去一次和二次导数，但是又不增加额外的计算开销。
Tip2：Stochastic Gradient Descent(SGD)
首先loss是在所有的训练examples上面的loss做总和，那么区别就是
Gradient Descent：做的是 θi=θi−1−η∇L(θi−1) θ i = θ i − 1 − η ∇ L ( θ i − 1 )
stochastic gradient descent：每一次拿一个example xn x n ，可以随机或者按照顺序取，如果说不是convex的函数，而是很崎岖的那种那么随机取就是会有帮助的。这个算法的loss只考虑对一个example的loss Ln L n 。
主要差异就是GD中算完所有example的loss才update一次参数(会走得比较稳定)，而SGD中是随机取一个example后就update一次参数，天下武功唯快不破，最终其实是SGD的方向可能不是最好的方向，但是走的会比较快。
Tip3:feature scaling
今天假设要做regression：
y=b+w1x1+w2x2 y = b + w 1 x 1 + w 2 x 2
如果输入的数据 x1 x 1 和 x2 x 2 的分布是很不一样的，建议做scaling，使两者range分布一样。（类BN）
这个对GD的效果是，本来loss是一个椭圆，就是说一组lr可能搞不定它，需要一直变化，但是在做scaling之后，update会比较快，因为梯度是垂直等高线的方向走的，在椭圆的时候不是直指local minimum去走的，但是在做scaling 之后却可以直指minimum走下去。
feature scaling的方法是有很多种的，一种是
xri←xri−miσi x i r ← x i r − m i σ i
where mi m i is the mean of dimension i i ， σi σ i is the standard deviation of dimension i i 。做完这步骤之后，所有dimension的mean是0，variance equals 1。

why does gradient descent work

每一次在更新参数的时候，其实新的参数 θ θ 不一定会使 L(θ) L ( θ ) 更小，尤其是用SGD做的时候。
在做GD的时候不是一次到位走到最低点的，而是一点一点移动过去的，在这个小范围内该如何才能让它更新的最快呢。
根据任何函数都能表示成泰勒展开式的形式，当 x x 接近 x0 x 0 时， h(x)≈h(x0)+h′(x0)(x−x0) h ( x ) ≈ h ( x 0 ) + h ′ ( x 0 ) ( x − x 0 )
在多变量的泰勒展开式中，最终形式就能推导出是gradient descent的形式。
因为要满足taylor series的前提，接近初始点，所以要求lr η η 是足够小的，这个时候的taylor展开式的approximation才是准确的，所以只有在 η η 无穷小的时候才能够保证每次参数更新后 L(θ) L ( θ ) 是减小的。
那可以考虑展开式中二次项的影响(牛顿法)，就可以将学习率 η η 设置大一些，这个想法是合理的，却不是practical的，因为在计算时需要计算二次微分，极大增大了计算代价，在做Deep Learning是无法承受的。

Lecture 4. Classification1：Probabilistic Generative Model

分类的任务：输入一个object x x ，输出是一个类别class(descript)。
regression时，output是number
如果硬要把classification当作是regression去做，我们举一个图示的例子，如果是classification，那么如图绿色的线应该最好的分类结果，而如果是作为regression，就要求所有的点离线不能太远，因为error要比较小，那么这个时候为了减小error，结果求出来就应该是紫色的线的结果会更好（注：regression是和类没有关系的，只是要找到能够拟合所有的点拟合得最好的线）。
那么对于分类的问题的loss应该定义成以下这个样子会是最合适的：

L(f)=∑nδ(f(xn)≠y^n) L ( f ) = ∑ n δ ( f ( x n ) ≠ y ^ n )

即分类错误的总次数，那我们希望在做分类任务的时候，这个loss值，即错误次数可以尽量小。
给出的这个loss是不可微分的，那有什么办法可以解决分类问题的求解呢，比较好的方法有：感知机perceptron，支持向量机SVM。但今天先介绍用概率的方法来解决这个问题。

对于概率模型求解，根据已经给定的 x x ，它属于类型 C1 C 1 的概率是多大，即求解 P(C1|x) P ( C 1 | x ) ，而要求解这个概率模型就要求解其他四个概率。这个模型就叫做一个generative model，因为有了这个模型就能根据 P(x) P ( x ) generate一个 x x 出来。
以pokeman为例，每一只宝可梦都是以一堆vector来描述的，这一堆vector叫做feature，probability ≠ ≠ density of probability
利用gaussian模型估计，需要找到均值 μ μ ，和协方差 Σ Σ ，然后根据 x x 在高斯模型中的分布确定分布在某个位置的概率大小。
要求解这个高斯模型最常用的方法是最大似然估计(Maximum likelihood)找一个分布能使得取到这么多个sample的likelihood能够最大，采用两个feature 分不开时，试下采用多个feature在高维空间中可能分开，继续失败的话尝试不同的模型去进行分类（不同的class有同一个covariance matrix Σ Σ ，否则参数太多，就容易variance大即overfitting）。

Three steps：
- model(you can pick any distribution you like)
- Loss(Probabilistic function)
- train
为什么考虑covariance之后分界线会变成是直线呢，那就是因为说，最后形式会变为 P(C1|x)=σ(w⋅x+b) P ( C 1 | x ) = σ ( w · x + b ) 的形式，那如果是这样，为什么不直接找到 w,b w , b 呢，这就到下一节要讲的内容了。

Lecture5. Classification2：Logistic Regression

• 根据ML的3个步骤，对logistic regression和linear regression做对比：

• step1：model

• step2：loss function
• step3：train

	logistic regression	linear regression
model	fw,b(x)=σ(∑iwixi+b) f w , b ( x ) = σ ( ∑ i w i x i + b ) (output 0,1)	fw,b(x)=∑iwixi+b f w , b ( x ) = ∑ i w i x i + b
loss	training data: (xn,y^n) ( x n , y ^ n ) y^=0,1 y ^ = 0 , 1 , L(f)=∑n−[y^nlnfw,b(xn)+(1−y^n)ln(1−fw,b(xn))] L ( f ) = ∑ n − [ y ^ n l n f w , b ( x n ) + ( 1 − y ^ n ) l n ( 1 − f w , b ( x n ) ) ] (cross entropy between two Bernoulli distribution)	y^n y ^ n is real number L(f)=12∑n(f(xn)−y^n)2 L ( f ) = 1 2 ∑ n ( f ( x n ) − y ^ n ) 2
train/minimize	wi←wi−η∑n−(y^n−fw,b(xn))xni w i ← w i − η ∑ n − ( y ^ n − f w , b ( x n ) ) x i n y^∈{0,1},fw,b(xn)∈(0,1) y ^ ∈ { 0 , 1 } , f w , b ( x n ) ∈ ( 0 , 1 )	same updating rule y^,fw,b(xn)∈R y ^ , f w , b ( x n ) ∈ R

reminder:
Bernoulli distribution(0-1 distribution) p p is like
p(x=1)=y^n p ( x = 1 ) = y ^ n
p(x=0)=1−y^n p ( x = 0 ) = 1 − y ^ n
Bernoulli distribution q q is like
q(x=1)=f(xn) q ( x = 1 ) = f ( x n )
q(x=0)=1−f(xn) q ( x = 0 ) = 1 − f ( x n )
Cross Entropy
H(p,q)=−∑xp(x)ln(q(x)) H ( p , q ) = − ∑ x p ( x ) l n ( q ( x ) )
If two distribution are same,cross entropy equals 0.
Deep learning 是没有(known)真正的最优解。
What’s the problem with Logistic Regression+Square Error?
会导致梯度消失，在离目标很远的时候，梯度已经为0，参数不再更新。
梯度会非常小，就不知道lr应该设大还是小，并且由于梯度很小，更新速度会非常慢，不容易得到好的结果，用cross entropy会让整个参数更新的过程顺利很多(就是找到合适的loss function)。

Discriminative & Generative
以上logistic regression的方法是discriminative的方法，而之前用Gaussian描述posterior probability是generative的方法。实际上只要在probabilistic model中把协方差设置成share，其实generative 和 discriminative model是一样的，均为 σ(w⋅x+b) σ ( w · x + b ) 。
在generative model中，找到Gaussian matrix的参数，而在计算logistic regression中，用GD下降的方法可以直接求出 w,b w , b ，当用generative model中计算出的 μ1,μ2,Σ−1 μ 1 , μ 2 , Σ − 1 ，再去计算 w,b w , b 得出的值并不一样。因为虽然是同意个function set和同一个training set，但是做出的假设是不同的，因此最后求出来的 w,b w , b 也会不一样。在logistic regression中是没有假设的，但在probabilistic model中是有假设的比如是Gaussian或者Bernoulli。
常常是discriminative model的表现会比generative model要好。（my thoughts：可以理解为是在未知实际分布的情况下，对分布做出假设实际会干扰到数据的被分类情况，而logistic regression的情况是完全无认为参与的，这种全自动化式的效果可以达到更好）。
举个例子说明，在例子中用Naive Bayes的方法(前提是假设其中的所有变量都是互相独立的，实际并不是)会进行错误的判断。
generative model有优势的时候：
1. with the assumption of probability distribution

1. 当training data 很少的时候，需要用几率模型来脑补没有观察到的特性，来得到更准确的判断，所有在比较少的训练数据的时候是可以应该discriminative model的。
 2. 对噪声更加鲁棒。

2. posterior probability can be estimated by priors and class-dependent probabilities from different sources.

Multi-class Classification(3 as example)
softmax：对输入的所有值做normalization，实际上在概率模型中去计算 P(Ci|x) P ( C i | x ) 就是 softmax s o f t m a x 的输出。
当 softmax s o f t m a x 减少到只有两类的时候，就reduce到logistic regression的情况(reduce 到sigmoid function)，此时 w1,b1,w2,b2 w 1 , b 1 , w 2 , b 2 之间是可以合并的。
Cross entropy就是在maximize likelihood（maximize probability y1 y 1 ）

!Limitation of Logistic Regression（简单神经元的限制）
简单的神经元无法实现的一个操作是异或。
因为一条直线没法将两边（两个类别）分开。
How to deal with it?
可以把试着做一下feature transformation(特征转换），转换成logistic regression可以处理的问题。(this is not always easy,domain knowledge can be helpful.)这个问题实际上可以看作是多个logistic regression的堆叠。
conclusion：**logistic regression虽然是没有办法做太复杂的事情的，但是能串联起多个单元，一部分负责做**feature transformation，一部分是做classification就能够做很复杂的任务。把其中的所有参数全部联合起来，一起学习，这就是deep learning。每一个logistic regression就是一个neuron，总的叫做neural network完成的工作叫做deep learning。

Lecture 6.Introduction of deep learning

Development

perceptron(1958) → → perceptron(1969) → → Multi-layer perceptron(1980s) → → backpropagation(1986) → → 1 hidden layer is “good enough”(1989) → → RBM-Restricted Boltzman Machine initialization(breakthrough)(of little use)(2006) → → GPU(2009) → → start to be popular in speech recognition(2011) → → win ILSVRC image competition(2012)

Three steps for deep learning

step1	step2	step3
define a set of function(NN)	goodness of function	pick the best function

Step1(structure : Fully Connect Feedforward Network)

先决定一个网络结构的话，就是定义一个function set，然后如果通过各种算法找到optimal solution就是找到一个optimal function that applies to the specific task.
每一层神经元的数目都相同，神经元之间是全连接的结构。
输入层(input layer)实际上并不算是一个层，因为输入曾并不是由神经元组成的，因此神经元层数的计算是从input layer以后的hidden layer 开始往后直到output layer的层数来统计的。
deep learning = many hidden layers
the famous NN originates from the ILSVRC :
AlexNet → → VGG → → GoogleNet → → ResNet
FCFN的计算常用series of Matrix operation 表示，正因为是一连串的矩阵运算所以可以利用GPU加速。
the job of the hidden layers is to implement feature extraction or feature engineering(feature transformation)，and that of the the output layer is a multi-class classifier, like softmax layer .

Example application:
Input is to computer a vector,stretched into a line of numbers, the output layer is then regarded as the probability(confidence) of corresponding digit.
The function or NN given in example represents a function set containing the candidates for Handwriting Digit Recognition. The only prerequisite for the NN is input and output shape, so how should the structure(function) be designed is especially important to achieve good performance.
Q&A
**Q:**How many layers？How many neurons for each layer?
**A:**Trial and Error+ Intuition+Domain knowledge. So ML is not much easier, the reason it gets popular is the feature extraction is no longer hand-crafted(however the network still needs to be designed).
**Q:**Can the structure be automatically determined?
**A:**E.g. Evolutionary ANN
**Q:**Can we design the network structure?
**A:**Sure you can, a special connection make it CNN.

Step2: Goodness of function(structure multi-class classification)
A sudden thought: cross entropy is more often applied to classification and MSE is more often applied to regression problem.
HTML grammar also applies.
We use loss function + gradient descent to find the optimal solution for the problem. Gradient Descent is the most common way to train the model in deep learning.
It’s like all tools offered online is to help researchers implement BP(to implement GD) more conveniently.
**Q:Deeper is Better?
A:Yes if you have enough training data.**
实际上有一个univesality theorem，只要hidden layer中神经元的数目够多，那么就可以实现任意function，那么为什么要做deep而不是fat呢？这部分留给后续再讲。

lecture7.Backpropagation

review the Chain Rule

• case1:

  y=g(x),z=h(y),dzdx=dzdydydx y = g ( x ) , z = h ( y ) , d z d x = d z d y d y d x

• case2:

  x=g(s),y=h(s),z=k(x,y),dzds=∂z∂xdxds+∂z∂ydyds x = g ( s ) , y = h ( s ) , z = k ( x , y ) , d z d s = ∂ z ∂ x d x d s + ∂ z ∂ y d y d s
  
  Therefore：
  z=xqw1+x2w2+b,loss=label−activation(z) z = x q w 1 + x 2 w 2 + b , l o s s = l a b e l − a c t i v a t i o n ( z )
  ∂z∂w∂l∂z ∂ z ∂ w ∂ l ∂ z

two steps of BP:
1. Forward pass
compute ∂z∂w ∂ z ∂ w for all parameters (ans is the value of the input connected by the weight) trivial

2. Backward pass
compute ∂l∂z ∂ l ∂ z for all activation function input z z , z z is determined in the forward pass
∂l∂a∂a∂z ∂ l ∂ a ∂ a ∂ z where a=σ(z) a = σ ( z ) ， ∂a∂z ∂ a ∂ z is trivial
∂l∂a=∂l∂z′w3+∂l∂z′′w4 ∂ l ∂ a = ∂ l ∂ z ′ w 3 + ∂ l ∂ z ″ w 4 （一直循环直到碰到output layer）compute ∂l∂z ∂ l ∂ z recursively
it’s much easier to compute ∂l∂z ∂ l ∂ z from the output layer. 因为是从后往前的计算（更简便），所以叫backward propagation。
最后求出 ∂l∂w ∂ l ∂ w 这个偏微分，用GD来求解参数。

Lecture8：“Hello world”of deep learning

TensorFlow and theano are both very flexible，可以把它们当作是微分器，它们完全可以做deep learning以外的事情，因为它主要的任务就是算微分，把微分的值计算出来以后，就可以用来做Gradient Descent，正因为是灵活所以才困难。
但是Keras是有可能在很短的时间内熟悉并且implement自己的DNN，Keras实际上就是Interface of TensorFlow or Theano，所以Keras就是在使用TF，只不过有人把TF的操作都写好了，所以会好学，也比较灵活。You can modify it if you can write TensorFlow or Theano.
Rumor has it that Keras might become the official api of TensorFlow.

Handwritting Digit Recognition is the prime task for Deep-learning learner like “hello world”.
在MNIST任务中就是要做输入一张数字图片，输出image是0-9的哪一个数字。
Step1 : define a set of function → → Step2 : goodness of function → → pick the best function.
建立一个网络结构为：
28 × × 28 image → → 500-neuron layer → → 500-neuron layer → → Softmax(output probability)

//---Step 1 : Define a set of function----//
model = Sequential()//establish a model
model.add(Dense(input_dim=28*28,
                output_dim=500))//dense represents a fully connected layer
model.add(Activation('sigmoid'))//tells the model which activation function it should choose
model.add(Dense(output_dim=500))//define another fc layer without defining another input dim cause it's connected to top of last layer
model.add(Activation('sigmoid'))
//output classifying results
model.add(Dense(output_dim=10))
model.add(Activation('softmax'))
//-------------End of Step1------------//
//--Step2: evaluate the goodness of the function---//
model.compile(loss='categorical_crossentropy',
              optimizer='adam',
              metrics=['accuracy'])
//----------End of Step2------------//
//----Step3: pick the best function---//
//configuration:in compile 'optimizer'part, different optimizer offers different ways of updating learning rate
model.fit(x_train,y_train,batch_size=100,nb_epoch=10)\\train operation

Mini-batch
we don’t really minimize total loss

in practice，把training data分成一个一个的batch

• randomly initialize network parameters
• pick the 1st 1 s t batch to sum up the loss of each elements in the batch L′=l1+l31+..... L ′ = l 1 + l 31 + . . . . . , update parameters once.
• pick the 2nd 2 n d batch L′′=l2+l16+...... L ″ = l 2 + l 16 + . . . . . . ,update parameters once
• until all mini-batches have been picked
• this is one epoch process,then repeat the above procedure

if batch_size=1,then it equals to Stochastic Gradient Descent(much faster，每次update的方向不一样，但是更新很快)
Why mini-batch is necessary?

• Speed:smaller batch size means more updates in one epoch

  1.batch size 很小的时候，一个epoch上更新参数所需要的时间会很长(owe credit to GPU)

  1. batch size稍大一些其实会使训练更加稳定，收敛更快(但是同时考虑超大的batch size时，有可能爆显存，而且在整体一起考虑的时候很容易卡住由于沿着total loss的路线走，却不是convex的，而SGD是有一定的随机性的)

GPU如何平行加速的？
因为NN就是setries of Matrix Operation
why mini-batch is faster than SGD?
SGD:每一组参数主次更新
mini-batch：把不同组的参数组合成一个vector，然后进行矩阵运算，运算时间开销和上述一组参数的计算是一致的，但mini-batch同时进行了多组数据的运算。GPU+mini-batch kills

Lecture 9： Tips for Deep Learning

DL没有那么简单，如果得到的结果不是很好，该从那个方向来做改进呢。
仍然是三个步骤：1. define a set of function 2. evaluate the goodness of function 3. find the best function
这就得到一个NN，接下来第一步要做的事情就是要检查模型是否能在training set上取得好的结果（因为在训练的时候可能收敛在local minimum或者saddle point这些地方，所以训练完NN之后不一定就会得到好的performance），如果结果不好，就需要看看哪一个步骤修改后可以在training data上面可以得到好的结果；如果在Training data上的结果好，那么就要看看在testing data上的结果怎样（如果在testing data上的结果不好那就是overfitting，结果也好就是一个成功的NN）
跟一般ML的方法不一样，如decision tree只要树够深，或者SVM只要用RBF kernel，只要你想可以轻易在training set上得到100%正确率，但在deep learning中不是这样。
所谓overfitting是会在training data上performance好但是testing data上performance差，因此overfitting的判定是需要同时观测两边的performance的。
针对在不同set(training or testing)上的效果提升，有不同的方法：
1. 在training set上的结果不好（Deeper usually does not imply better）
- New activation function
- Adaptive Learning Rate
2.在testing set上的结果不好
- Early stopping
- Regularization
- Dropout

Vanishing Gradient Problem
Demonstration:
network很深的时候，有可能出现梯度消失，靠近输入层的几层gradient是比较小的，而在靠近输出层的几层的gradient是比较大的，如果每个参数的learning rate都是一样大，靠近input layer的几层学习速度是非常慢的，靠近output层的那几层相对来说是比前面几层学习要快得多的。所以会出现一种现象，就是在前面几层的参数几乎还没有更新的时候还是随机的状态（randomly initialized），最后几层的参数就已经几乎收敛，这个时候的整个training 就停下来了，但是表现并不好，因为后面的结果的是由前面的output作为input得到的，前面的特征提取不好，虽然这层参数正确，但是结果会不好。

Why Vanishing Gradient exists?

这个问题是来自于sigmoid函数，a little trick for you : 所谓的gradient，如果要计算某个参数对loss的偏微分(derivative)，就把参数小小地变化一下，然后看看loss 的变化有多大，就可以估测一下这个参数的微分（ ∂l∂w≈ΔlΔw ∂ l ∂ w ≈ Δ l Δ w ）。
sigmoid会使输入的 Δw Δ w 衰减，所以每通过一个layer，变化都会衰减一点，到最后 Δl Δ l 就很小，所以造成在靠近input的地方算出来的梯度( ∂l∂w ∂ l ∂ w )很小。（改变activation function来结局这个问题，也可以设计dynamic的learning rate(可以解决vanishing问题还能学的更好)）

substitution activation function

1. ReLU(Rectified Linear Unit)（如果是激活函数的输入小于0，就输出0对后面没有影响，等同于不存在，但是如果是大于0，就是一个linear function，最后整个网络只含有linear的neuron，整个网络就在特定输入下变成一个thinner linear network，那么input layer的参数就不会比output layer那边变化小，就不存在梯度消失的问题了，即小范围线性但是整体还是非线性）
   
   • fast to compute
   • biological reason
   • infinite sigmoid with different biases
   • Vanishing gradient problem
   • variants：Leaky ReLU，parametric ReLU，Exponential Linear Unit
2. Maxout(可以让network学习自己的activation function，ReLU是一个special case，Ｍaxout实际上会需要更多的参数，几乎是两倍的关系，因为这个时候maxout函数也是需要自己学习的，you can have more than 2 elements in a group。但是这个时候应该怎么微分呢？它不是在每一个地方都可以微分，但是可以算出参数的变化对loss的变化就可以用GD来train网络，可以这么理解在给定input的时候整个网络可以当作是一个linear的function)对同一幅图片来说是一个linear function\thinner linear network，但是对于一个batch来说就是non-linear的。
   
   • Learnable activation funcntion
   • pixel-wise linear activation function
   • how many pieces depend on how many elements in one group

Adaptive learning rate

Review Adagrad:

wt+1←wt−η∑ti=0(gi)2−−−−−−−−√gt w t + 1 ← w t − η ∑ i = 0 t ( g i ) 2 g t

用一次微分的值估计二次微分的值，因为二次微分的值影响着在梯度下降时采取的步长。
想要有效训练Deep Learning的话，会需要比Adagrad更有效的方法。
RMSProp(Hinton在他的课上propose)

w1←w0−ησ0g0 w 1 ← w 0 − η σ 0 g 0 ， σ0=g0 σ 0 = g 0

w2←w1−ησ1g1 w 2 ← w 1 − η σ 1 g 1 ， σ1=α(σ0)2+(1−α)(g1)2−−−−−−−−−−−−−−−−−√ σ 1 = α ( σ 0 ) 2 + ( 1 − α ) ( g 1 ) 2

w3←w2−ησ2g2 w 3 ← w 2 − η σ 2 g 2 ， σ2=α(σ1)2+(1−α)(g2)2−−−−−−−−−−−−−−−−−√ σ 2 = α ( σ 1 ) 2 + ( 1 − α ) ( g 2 ) 2 wt+1←wt−ησtgt w t + 1 ← w t − η σ t g t ， σt=α(σt−1)2+(1−α)(gt)2−−−−−−−−−−−−−−−−−−√ σ t = α ( σ t − 1 ) 2 + ( 1 − α ) ( g t ) 2 **！！！Momentum（惯性）** 我们发现在minimize loss function去找local minimum的过程中，这个过程虽然被我们比作是找最低点的过程，但是实际上又跟物理上的下落到最低点的运动不同，因为实际物体的运动是有惯性的，于是在optimizing求loss最小值的过程中将**下降时前行的惯性**考虑进去，或可帮助跨过local minimum甚至可以达到global minimum，但是不能确保。 这就是Momentum的含义和用途。 **Vanilla Gradient Descent：** compute gradient at θ0← θ 0 ← Move to θ1=θ0−η∇L(θ0) θ 1 = θ 0 − η ∇ L ( θ 0 ) （沿负梯度方向走） → → compute gradient at θ1→ θ 1 → Move to θ2=θ1−η∇L(θ1)…→ θ 2 = θ 1 − η ∇ L ( θ 1 ) … → till ∇L(θt)≈0 ∇ L ( θ t ) ≈ 0 **Momentum** 考虑两件事情：1.Gradient的方向;2.惯性Momentum(用上一步的运动作为惯性) start at point θ0 θ 0 Movement v0=0 v 0 = 0 compute gradient at θ0 θ 0 Movement v1=λv0−η∇L(θ0) v 1 = λ v 0 − η ∇ L ( θ 0 ) move to θ1=θ0+v1 θ 1 = θ 0 + v 1 compute gradient at θ1 θ 1 Movement v2=λv1−η∇L(θ1) v 2 = λ v 1 − η ∇ L ( θ 1 ) move to θ2=θ1+v2 θ 2 = θ 1 + v 2 这样一来运动就不仅基于梯度，也基于之前的运动。 vi v i 其实是之前所有的梯度的加权和，所以是每一次的移动都有把之前所有的梯度给考虑进来。

#### Adam(RMSProp+Momentum) 算法超复杂的！！！ ### Overtfitting(train好但是test不好) **1. early stopping** 假设lr设置的很对，那么在training set上的error就会慢慢减小，直到后来loss没办法下降，但在testing data上的data上的error会慢慢变小然后最终变大。那我们关注的主要是testing error，那么停在testing error最低的地方，在实验中，就应该用validation set 去取代这里的testing set，也就是说在训练时到validation set上的error到最小时就应该停下整个训练过程。 **2. regularization** 在人脑的发育过程中，从出生到6岁会发现神经元间的联结越来越多，但是在从6岁到14岁的过程中，这些联结又会慢慢地减少. Our brain prunes out the useless link between neurons.如果对ML中的神经元做同样的事情，也会改善效果。 正则化就是希望参数的norm能越接近0越好， L′(θ)=L(θ)+λ12∥θ∥n L ′ ( θ ) = L ( θ ) + λ 1 2 ‖ θ ‖ n 常取L1-norm和L2-norm 1. 如果是L2-norm，其中 θ={w1,w2,…} θ = { w 1 , w 2 , … } 则 ∥θ∥2=(w1)2+(w2)2+… ‖ θ ‖ 2 = ( w 1 ) 2 + ( w 2 ) 2 + … (通常是hi不考虑biases的) 这个时候的new loss是 L′(θ)=L(θ)+λ12∥θ∥2 L ′ ( θ ) = L ( θ ) + λ 1 2 ‖ θ ‖ 2 Gradient： ∂L′∂w=∂L∂w+λw ∂ L ′ ∂ w = ∂ L ∂ w + λ w Update： wt+1←wt−η∂L′∂w=wt−η(∂L∂w+λwt)=(1−ηλ)wt−η∂L∂w w t + 1 ← w t − η ∂ L ′ ∂ w = w t − η ( ∂ L ∂ w + λ w t ) = ( 1 − η λ ) w t − η ∂ L ∂ w 所以参数更新策略中由 wt−η∂L∂w w t − η ∂ L ∂ w 变成了 (1−ηλ)wt−η∂L∂w ( 1 − η λ ) w t − η ∂ L ∂ w 而其中的 1−ηλ 1 − η λ 是小于1大于0的数，所以 (1−ηλ)wt ( 1 − η λ ) w t 就越来越小，但是更新策略的右边两项前一项越来越小，后面一项要与前面一项取得平衡，导致参数不再更新，就完成训练。如果说有参数对loss的导数 ∂L∂w ∂ L ∂ w 为0，那么就说明这个参数对loss没有影响，最终这个参数就会变为0，但是有用的参数会在右边两项中最终取得平衡。**L2-norm的regularization又叫做weight decay。** 2. 如果是L1-norm ∥θ∥1=|w1|+|w2|+… ‖ θ ‖ 1 = | w 1 | + | w 2 | + … New loss L′(θ)=L(θ)+λ∥θ∥1 L ′ ( θ ) = L ( θ ) + λ ‖ θ ‖ 1 Gradient ∂L′∂w=∂L∂w+λsgn(w) ∂ L ′ ∂ w = ∂ L ∂ w + λ s g n ( w ) Update: wt+1←wt−η∂L′∂w=wt−η∂L∂w−ληsgn(wt) w t + 1 ← w t − η ∂ L ′ ∂ w = w t − η ∂ L ∂ w − λ η s g n ( w t ) 那么参数更新规则中就多了 −ηλsgn(wt) − η λ s g n ( w t ) 这一项，具体实现的效果就是大于0就减去一个 ηλ η λ ，小于0就加上一个 ηλ η λ ，也就是让参数尽量靠近0，这个功能和L2-norm类似。 3. 差别：L2-norm会使参数最终接近0，而L1-norm会让参数差异很大，有些参数很大，一些参数接近0。 4. 帮助其实是很有限的，如果是SVM，扔进去一个问题就能输出结果，regularization是对SVM很重要的。但是对NN，因为有初始化，用GD做优化，initial value已经都是接近0开始，early stopping 和regularization的角色蛮重叠的，所以其实regularization在DNN中是没有那么有用的。 **3. dropout** 有DL特色的方法。 运作方式： -train:对每一个neuron做sampling，甚至对input做sampling，每一个神经元有p的概率被drop，所以与之相连的权重也会失去作用，那么网络架构就直接改变了thinner，就相当于每次训练用的都是thinner的network，**每一次(每一轮新的mini-batch)参数更新之前都要做一次dropout，每次drop的神经元都不同** -test:**测试时不dropout，并且如果在训练时的dropout rate=p%，那么测试时所有权重都乘以1-p%。**原因是在test时不乘1-p，那么导致输出值会比train的时候大，只有乘1-p之后才能使状况和训练时一致。 原理 Dropout is a kind of ensemble. 把training set分成几个part分别进入不同network进行训练，所有训练结果进行平均的结果会很好bias很小。虽然参数复杂，variance大但是平均以后会bias小（ **权重乘以1-p就模拟了平均的过程**）。 一个batch训练一个网络会不会太少次训练？不会，因为参数是share的，就是说用很多个batch去训练了一个参数，并不存在training data太少的问题。 **权重乘以1-p就模拟了平均的过程理论上只是linear activation function才work，但是实际上对于non-linear activation function也是work的** maxout+dropout 效果很好(对linear activation function效果很好) # Lecture 10：CNN CNN(NN应用在图像处理上)是一个很好的例子告诉我们说，network的架构我们是可以自己设计的。如果直接设计fully connected network，就是一个超大的function set里面找到optimal function，如果是CNN就是在很大的function space中，只有少量function 是需要考虑的，其他function在实际apply之前就知道效果会不好，所以直接不进行考虑，这样会比较容易learn到好的参数，比较不容易overfitting，variance会比较小。 CNN其实是FCN的一个简化版本，参数是比较少的。 ## Why CNN for image?(CNN设计的motivation) CNN通常用在影像的辨识上面，给machine一张image(一个matrix)，network（比如说分类network）根据matrix来决定网络里面的内容是什么。 1. Some patterns are much smaller than the whole image. 比如说一个神经元的作用是识别鸟嘴，那鸟嘴占的部分输入神经元就会产生很大的输出，或者说要识别鸟嘴，只要把鸟嘴的部分输入神经元而不需要整张图片输入进去。 2. The same patterns appear in different regions. 仍以鸟嘴为例，我们如果要识别鸟嘴，用同一个神经元和同一组参数就可以实现，而不需要分成不同位置的鸟嘴（对应不同未知的神经元）来侦测（识别）。 3. Subsampling the pixels will not change the object. 对于图像来说有一个特性，就是沿横纵轴做下采样时，图像中物体的形状不会改变，但是有一个好处是，图像变小了，那么网络中需要的参数也相应变少了，但是却不影响影像辨识的结果。 **总结一下**，其实这3个理由都是要让网络的参数变少。 ## The whole CNN image → → Convolution → → Max pooling → → Convolution → → Max pooling(C+M can repeat many times) → → Flatten → → Fully Connected Feedforward Network → → Classification result 以上网络的所有参数是被一起找出来的（同时train）。 convolution考虑的是上面的property 1（识别特征只需要一小部分的图片）和2（识别同一个特征只需要同一个神经元同一组参数），而Max pooling则是考虑到property 3（图像下采样之后其中物体的形状不变）。 ### CNN-Convolution 实际的操作是怎么做的呢？ 在convolution layer里面，有一把filter，每一组filter其实就是一个矩阵，filter有多少个和其尺寸都是预先决定好的（超参数？，就像是hidden layer的size一样），但是其中的参数是learn到的。 filter的size(**property 1**)，比如 3×3 3 × 3 意味着尺寸这么大的filter就苦于把特征给提取出来，也就是说pattern的size是小于 3×3 3 × 3 的。 **那有了这些filter应该怎么去使用呢？** 按如图的filter，一个filter要找的部分就是跟这个filter做卷积之后结果会使最大的region，because it contains the corresponding pattern of the filter（ 3×3 3 × 3 的矩阵的对角为1，其余为 −1 − 1 ，那么作用就是寻找对角为1的region）。这样就能用同一组参数，同一个kernel寻找特定的pattern，这就**对应了property2。** filter里面只有1和-1，但是在初始pic里面只有0和1，这样就不存在说有 −1×−1=1 − 1 × − 1 = 1 的这种情况来使响应最大。（为什么filter会学习成这样呢？？？） ***filter和图片按stride做convolution之后的结果叫做feature map。***这个feature map可以当作一个新的图片，那么得到的这个新的image是会比原来的图片要小；原来的图片每个位置只有一个数值来描述它，但是因为有 n n 个filter，那么就相应地会有 n n 个feature map，因此在新的图中，每个位置会有 n n 个数值来描述它。 **对RGB图像和灰度图像的卷积的差别** 对灰度图片的卷积过程如上已经陈述清楚，那么RGB彩色图像其实就是有3个channel的图像，相当于3幅并列的灰度图，如果在灰度图filter size是 3×3 3 × 3 ，对彩色图filter就变成 3×3×3 3 × 3 × 3 ，就是说会有3个size为 3×3 3 × 3 的filter，每个通道上的灰度图对应一个filter，当然这个filter中间的参数都是训练出来的。 #### Convolution v.s. Fully Connected convolution是fully connected network的简化版，FCN的话就是对于输入层之后接神经元，然后每个神经元和前一层全连接，但是换成是CNN之后，卷积kernel和图片输入层的连接只有filter_size × × filter_size个，这就导致less parameters。再有一点是convolution里的kernel因为只有一个，也就是后层神经元和前一层神经元之间的权重是repeat的，这就导致even less parameters。 所以可以理解为CNN是FCN的简化版本。 ### CNN-Max Pooling Max-Pooling就是把feature map里面几个位置一组，进行max out，一个值得思考的问题就是在进行max的操作时，是否还能顺利进行GD，之前在激活函数Max-out part已经讲过，用 ∇L∇w ∇ L ∇ w 模拟 ∂L∂w ∂ L ∂ w 。 除了Max Pooling 还有Average Pooling，两者其实可以一起使用，就是用两个值去代表那个group。 convolution+max pooling之后得到的feature map就认为是一个相对原图要小得多的image，其channel数就取决于filter的个数。 ### Flatten 在经过不断的卷积和pooling层之后，得到的image足够小了，就可以放心地把图片给flatten成一个vector，把这个vector作为FCN的输入，最后FCN就会给我们一个输出。 ## CNN in Keras

model2.add(Convolution2D(25,3,3,input_shape=(28,28,1)))
model2.add(MaxPooling2D((2,2)))
model2.add(Flatten())
// Fully Connected Feedforward Network
model2.add(Dense(output_dim=100))
model2.add(Activation('relu'))
model2.add(Dense(output_dim=10))
model2.add(Activation('softmax'))

通常filter的设定是靠近input的地方filter少，越往后的地方filter越多，这也是有道理的，因为在最开始的pattern是相对简单和basic的feature，basic的feature是比较少的，越往后的feature是越来越抽象的（是之前的feature的组合），所以后来的feature会越来越多，因此需要的filter也就越多。在做pooling的时候如果

What does the machine learn?

1. 可以直接拿kernel里的权重过来，看看里面是什么内容，就知道学习的是什么，这一般只是适用于与输入层相连的layer。对于第二层以后的layer就要知道前一层的输出是什么才能知道后一层的output是什么。
2. 但是对于高层的网络，我们应该怎么分析它们相应的功能是什么呢？举例来说，我们可以把某一个神经元拿出来，然后把某个filter在某个位置的输出拿出来，把所有图片输进去CNN，观察neuron(就是filter，之前已经讲到CNN是FCN的简化形式)什么时候activated最强，就知道其功能是什么，比如在论文“Rich feature hierarchies for accurate object detection and semantic segmentation”中，这个例子里框的左上角是激活的强度，白色框的大小是检测的范围(因为高层检测的是前一层的输出，所以检测的范围是比较大的)，那么观测同一个filter响应强的地方，就会知道该filter的功能是什么。
3. 还有其他的分析方法，比如这个梯度上升(gradient ascent)的方法。
   我们假设第k个filter的输出是一个11 × × 11的滤波器，并且定义第 k k 个滤波器的激活程度是
   ak=∑i=111∑j=111akij a k = ∑ i = 1 11 ∑ j = 1 11 a i j k
   
   要求解某一个filter的作用是什么，就先固定住网络的参数，不断改变输入已知到使得该filter输出的图得到的激活程度能最大，也就是求解这样一个函数的解
   
   x∗=arg maxxak x ∗ = a r g   m a x x a k
   
   用梯度上升的方法尽心那个求解，得到相应的 x∗ x ∗ 之后就能观察出相应filter的功能是什么。对于FCN的分析也是一样的，选取FCN某一层的某一个neuron，然后计算出使其激活程度最大的图片，就能知道该神经元感兴趣的特征是什么。
   
   x∗=arg maxxaj x ∗ = a r g   m a x x a j
   
   要检测输出层的每一个神经元对应什么类别，如果也采用相应的方法，就会发现结果并不如我们想象的那样，会是标准的数字图片，反而是一堆看起来没有实际意义的噪声，甚至会以超高的置信率进行错判。可以参考这段视频Deep Neural Networks are Easily Fooled，那就显示其实DNN不是那么好的一个识别工具，是很容易被骗过的，但我们也同样可以理解为DNN并没有把输入的图片背下来，它采用了一种我们不能理解的方法去识别。
   在这种时候，加入constraints(其实就似乎domain knowledge)是会很有帮助的，在CNN的基础上再加入视觉图像的一些基本规律，就能够产生更符合人体直觉感官的图片，比如计入一个条件
   
   x∗=arg maxx(yi+∑i,j|xij|) x ∗ = a r g   m a x x ( y i + ∑ i , j | x i j | )
   
   就会产生一个更为合理的图片。
   但是选择输入彩色图片时，如果用相同的办法去可视化就能够得到以下这样相对美好的结果。
   图片来自Deep Inside Convolutional Networks:Visualising Image Classification Models and Saliency Maps
   在这里注意一点，网络对物体的识别方法可能会和我们进行物体分类采取的依据不一样，举个例子，我们可能说要看到这个物体的第一眼就把物体给识别出来了，但是有可能网络会根据图片上的小logo来识别物体的种类。
   4.原理类似上面，但不采用生成，而采用改变图像上某个像素的值的方法来判断对分类结果最重要的像素。即根据
   |∂yk∂xij | ∂ y k ∂ x i j
   的值来决策某一个像素对分类结果的影响程度。有人用这个方法来判断saliency，但是人不一定会值关注到物体本身，人有可能被其他部分distract，同样网络不一定会根据物体分类，网络有可能根据对人来说非slient的部分进行分类。所以在准备数据的时候需要尤其注意，而可视化训练过程也由此对我们改进训练过程有很重要的作用。
4. 要判断网络识别依据的最简单的一种方法就是，对输入图片进行遮挡，在遮挡到哪个部位时，网络会对图片进行错误分类，那个部位就是准确分类的关键部位。这个方法来自论文Visualizing and understanding convolutional networks

Appliccations of forementioned content

1. Deep Dream
   reference site
   实现原理：在分类CNN中，将某个filter的输出值进行夸张化（符号不变，令绝对值增大），由这部分网络参数去修改输入图片(gradient ascend)，就可以得到神奇的效果。
2. Deep Style
   reference site
   实现原理：网络提出的原理是这样，文章认为CNN的filter提取的一部分是content，另一部分是style，那么我们只要找到另一个CNN，让网络提取的content像一张图，提取的style像另一张图，再利用gradient ascend的方法，实现图片风格的转换。
   reference paper
3. playing Go
   用来下围棋这个应用是非常popular的啦，围棋棋盘是19 × × 19的一个分布，如果用FCN去训练的话，就把输入当作一个19 × × 19的vector训练，如果是用CNN训练，就把输入当作一个19 × × 19的matrix训练，而实际CNN的参数会更少，用CNN训练可以更优。就是根据特定输入，制定特定输出，使loss最小的方式训练。（而最强alpha go是利用增强学习的方式来训练的）。
   同时，训练围棋的domain knowledge也是和CNN的前提要求是一致的，for convolution,因为patterns are smaller than the whole pic& same patterns appear in different regions。
   For max pooling,subampling will not change the object，那这一点就让人想不通了，围棋上如果随意增减行数怎么会不影响下一步进行落子的位置呢？
   而实际上这一点在alpha go的网络设计结构中，也是没有max pooling这一项的。那给我们的启发就是，对于一个有specific 应用的task，我们应该根据问题的具体内容结合相应的domain knowledge去设计task-specific的网络结构，而不是直接生搬硬套。
4. Speech recognition
   用CNN也可以用来做语音识别？当把声音这种一维信号，做一些简单的变换，变成二维的图像(spectrogram)，就可以利用识别图像的方法来进行语音识别。到目前，state-of-the-art的语音识别系统都是在底层运用到CNN的。