简析深度学习、概率建模、特征表示-灌水篇

深度学习（Deep Learning），近几年火的近乎家喻户晓，曾经的算法、机器学习局部升了个级华丽转身成为人工智能（AI）。但传言深度学习的爆发可以从 Hinton 在 2006 年提出的Deep Belief Network (DBN) 的训练算法开始，才将数十年的多层神经网络效果差和落败于统计学习的尴尬局面得以扭转，在与统计学习之争中逐占上风，之后一发不可收拾，各种网络和模型也相继在学术界和工业界被织出来，逐步颠覆和更新了语音识别、图像识别、自然语言处理-文本等众多领域。再加上各大公众媒体的宣传，此刻及未来数年（也许）深度学习的声量（泡泡）不言而喻。。
所以，凑个热闹，记录下俺对深度学习/神经网络和许多现有的统计学、特征表示之间关系的理解和观点。

1. 三层架构-框架抽象

从模型架构的角度，我们似乎可以粗略地把绝大部分的建模架构抽象为三个组件/三大层：输入数据/特征层、特征表示/学习层和任务层。输入层可以理解成原始的特征或简单清洗后的特征，不同算法或框架的区别在第二大层和第三层上（这里的第二层是为了抽象的框架的概念，中间可以包含多层子层），比如最简单的是没有中间层，直接把输入层输出给任务层做分类；传统的人工特征工程在第二大层表现为求sin、平方、开方等简单的数学方法，产生新的特征，然后输出给第三层做分类；SVM第二层通过Kernel Method将输入层特征“升维”到高维空间张成新的特征向量，以便在第三层更容易分类；同理GBDT也是在第二层进行树形特征学习和表示，然后经过第三层的修正优化得到漂亮的分类结果；而今天的主角深度学习（网络）则是在第二层通过多层子层进行特征的学习和传递，同样通过第三层进行任务的修正优化，得到更优的结果。再进一步抽象，第三层的表示大部分可以通过GLM（广义线性模型）进行表示。特别地，深度学习网络中间的每一子层也都可以看成上一层的输入和权重的线性组合，并把结果封装传入一个简单的非线性函数（GLM的连接函数），最后通过第三大层的进行统一的优化。可以发现随着研究的进步，总的框架其实没有巨大变化，只是在中间特征学习的智能性或线性可分性的转化上是在不断的进化，本质都在做特征的抽取和学习。
深度学习其实很关键的一点就是得到好的特征表示（representation），通过深度学习第二层学习的出来的网络，即使抛弃第三层的分类/回归模型，直接把学习到的网络（参数）当做新的特征，把这堆特征丢到普通的 LR之类的分类器里，往往也会得到分类性能提高。

1.1 一个简单的例子

如图，存在红圈和黄十字两个类别，原始特征分别为一维空间-2,-1,1,2四个点，基于该数据，简单的可以直接+第三层分类任务进行建模，效果从图中容易判断，准确率最高可以达到75%，进一步，我们发现可以在第一层和第三层之间加一个简单的数学变换，即新生成一个特征Y=X的平方，然后用新的特征再进行一层分类任务后建模发现准确率可以达到100%。其实第二种方法可以简单看做深度学习的特殊情况，即X平方的转换可以看做是中间一个子层一个节点的普通网络。

一维空间.png

二维空间.png

2. 三层架构-图表示

最普通的建模方式是没有第二层，直接从第一层（数据输入层）和第三层建立连接，另外，本图表示的是参数w为非随机变量，当假设它也为随机变量时，即给其先验分布时，估计过程变成贝叶斯估计（机器学习中叫做正则化，用于降低模型的复杂度）。

普通建模过程.png

正则后：

参数先验-MAP.png

深度学习图表达：

深度学习建模过程.png

接下来，逐层拆解看看：

3. 第三层：GLM

根据上面的分析，其实可以把深度学习后两大层看做是一个递归的广义线性模型（Recursive Generalised Linear Model），即每一细分层都是一个可复制的GLM，GLM作为概率建模的基石之一，在我们接触到的应用中无处不在，也很实用。

3.1 同样从简单的例子说起

基本的线性回归模型是一个从由自变量X组成的m维空间到一组因变量Y组成的空间的线性映射，基本形式：

${E(Y_i)=u_i=x_i^T\beta;\space\Y_i:N(u_i;\sigma^2)\space[1]}$

其中，Yi为独立于关于X线性组合的随机变量，高级统计理论和现代计算性能允许我们通过更一般的情况扩展建立类似的其他线性模型：

因变量不一定是正态分布，可能会是二项分布、多项分布、泊松分布等；
因变量和自变量之间的关系不必要像上面表示的线性形式

满足上面两点性质可以共享更多分布形式的有一个族类叫“指数分布族(exponential family of distributions)”，即可以通过一个叫连接函数(link function)g来扩展[1]式：

${g(u_i)=x_i^T\beta}$

3.2 指数分布族表示

考虑一维的因变量Y，其概率分布只依赖一个参数\theta，则指数分布族可以表示为：![][2]
其中，
![][3]![][4]该式中我们感兴趣的也是需要估计的参数是\theta，其他均为“调节参数”，通常可认为已知。

3.3 普通第三层建模-数学推导

该部分为纯手工推导然后敲入，如有误欢迎指正。该部分内容可能比较枯燥，如果知晓GLM的作用和原理可忽略，或直接跳到下一部分。

目标函数表示
为了更直观了解指数分布族，我们通过普通的建模即GLM来理解，首先来看看指数分布族的期望和方差（后面模型参数推导需要），需要用个小技巧，指数分布族首先是一个分布，即满足分布函数的性质：在定义域上的积分等于1，数学表达式为：![][5]
对该积分表达式两边同时计算关于\theta的偏微分/偏导得到：![][6]
整理得到：![][7]
将分布表达式带入求解可得：![][9]![][10]
由期望基本表达式![][8]
我们解得期望的表达式:![][11]![][12]
对上述积分表达式对theta求二阶偏导得到：![][var1]
分布表达式代入得到：![][var2]
将上面计算出的E(y)结果代入整理得：![][var3]
最终得到y的方差为：![][var4]
接下来我们看看指数分布族下的极大似然loss：![][13]
进一步log-loss：![][13.1]
在实际建模时往往需要对模型的复杂度进行正则，理论上变为求最大后验loss（MAP，贝叶斯的方式，极大似然可以看做其特殊情况），即把模型的参数也看成随机变量，也就是说参数也是有分布信息的，称之为先验分布，以Lasso为例，即假设模型参数为拉普拉斯分布，可得到loss为：![][14]
其log-loss：![][14.1]
从这个角度解释极大似然估计为最大后验估计得特殊情况：极大似然估计即可看作最大后验估计中模型参数的先验分布为均匀分布（先验项为常数，梯度优化时可以忽略，即等同于极大似然估计）：![][15]
参数优化通用化-法1
以极大似然的log-loss优化为例，假设![][13.3]
则极大似然log-loss更新为：![][13.4]
对第j个w求梯度，计算结果为：![][13.2]
展开后：![][13.2.1]
通过链式法则计算得到如下结果：![][13.2.2]
接下来，对因变量Y不同的数据分布，只需要定义相应的连接函数，即可得到相应的梯度更新方程：具体地，对于Logistic Regression，连接函数:![][1.3]
梯度更新方程为:![][1.5]
整理得到：:![][1.6]
对于泊松回归，连接函数为：![][1.7]
对应的梯度更新方程为：
${\frac{\partial{L}}{\partial{w_j}}=\sum_{i=1}^n[y_ix_i^j-exp(\sum_{j=1}^mw_jx_i^j)\cdot{x_i^j}]}$

整理得到：
${\frac{\partial{L}}{\partial{w_j}}=\sum_{i=1}^n[y_i-exp(\sum_{j=1}^mw_jx_i^j)]\cdot{x_i^j}}$

[var1]: http://latex.codecogs.com/gif.latex?{\int\frac{d^{2f(y;\theta)}{d\theta}2}dy=0}
[var2]: http://latex.codecogs.com/gif.latex?{\int-\frac{g\prime\prime(\theta)}{a(\phi)}f(y;\theta)+(\frac{y-g\prime(\theta)}{a(\phi)})^2\cdot{f(y;\theta)}dy=0}
[var3]: http://latex.codecogs.com/gif.latex?{\int\f(y;\theta)[\frac{y^{2-2yE(y)+E(y)}2}{a(\phi)^2}-\frac{g\prime\prime(\theta)}{a(\phi)}]dy=0}
[var4]: http://latex.codecogs.com/gif.latex?{var(y)=a(\phi)g\prime\prime(\theta)}
参数优化通用化-法2
昨天发布以后有人反映上面的梯度求解晦涩难懂。为此，再下给出第二种通用解法，会用到关键方法：链式法则（本文中多次出现该方法，所以可以适当自行掌握），具体推导如下：
假设随机变量Y满足GLM，即指数分布族分布，我们需要估计参数w，该参数是建立Y和特征X之间关系的关键，具体通过：
${E(Y_i)=u_i}$

${f(u_i)=x_i^Tw}$

这里的f()为连接函数，也就是说Y和X之间是通过连接函数建立线性关系。对于任意Y，建立log-likelihood函数（指数分布族公式上文找）如下：
${L_i=\frac{y_i\theta_i-g(\theta_i)}{a(\phi)}+\Phi(y_i;\phi)}$

以及：
${E(Y_i)=u_i=g\prime(\theta_i)}$

${var(Y_i)=a(\phi)g\prime\prime(\theta_i)}$

${f(u_i)=x_i^Tw=\eta_i}$

对于所有观测到的Y，log-likelihood函数为：
${L=\sum_{i=1}^nL_i=\sum_{i=1}^n[\frac{y_i\theta_i-g(\theta_i)}{a(\phi)}+\Phi(y_i;\phi)]}$

再次利用链式法则及极大似然估计，计算参数wj（第j个特征的参数，似然函数中i是第i个样本，注意这两个下标的含义）的梯度如下：
${\frac{\partial{L}}{\partial{w_j}}=\sum_{i=1}^n(\frac{\partial{L_i}}{\partial{\theta_i}}\cdot\frac{\partial{\theta_i}}{\partial{u_i}}\cdot\frac{\partial{u_i}}{\partial{w_i}})}$

接下来，对每一项分别求解(对ui的求导会用到上面计算过的y的方差)：![][var4]
${\frac{\partial{L_i}}{\partial{\theta_i}}=\frac{y_i-g\prime(\theta)}{a(\phi)}=\frac{y_i-u_i}{a(\phi)}}$

![][p10]![][p11]![][p12]
通用算式已准备完毕，接下来以Logstic Regression为例，Y的发生服从贝努力分布（N=1的二项分布），我们有![][p13]![][p14]对应的分布函数可以表示为：![][p15]可以发现符合指数分布族的表达，容易得到：![][p16]![][p17]![][p18]以自然参数theta表达式作为连接函数时Y与theta的关系是线性的，符合我们线性转换的条件，重新与指数分布族推导的通用表达式和参数梯度建立关系，有：
${E(y)=u_i=g'(\theta)=1\cdot{p(y=1)+0\cdot{p(y=0)}}=\pi_i}$

所以连接函数f()重写为：
${f(u_i)=\log(\frac{u_i}{1-u_i})=x_i^Tw=\eta_i}$

逆函数为：
${u_i=\frac{1}{1+e^{-\eta_i}}=\frac{1}{1+e^{-x_i^Tw}}}$

${\frac{\partial{u_i}}{\partial{\eta_i}}=\frac{e^{-\eta_i}}{(1+e^{-\eta_i})^2}=u_i(1-u_i)}$

${var(y_i)=a(\phi)g''(\theta)=u_i-u_i^2=u_i(1-u_i)}$

所以最终我们得到（与法1相同）：
${\frac{\partial{L}}{\partial{w_j}}=\sum[\frac{y_i-u_i}{u_i(1-u_i)}\cdot{u_i(1-u_i)}]x_i^j=\sum[y_i-\frac{1}{1+e^{-x_i^Tw}}]x_i^j}$

[p10]: http://latex.codecogs.com/gif.latex?{\frac{\partial{\theta_i}}{\partial{u_i}}=1/(\frac{\partial{u_i}}{\partial{\theta_i}})=1/(g\prime\prime(\theta_i))=1/(\frac{var(y_i)}{a(\phi)})}
[p11]: http://latex.codecogs.com/gif.latex?{\frac{\partial{u_i}}{\partial{w_j}}=\frac{\partial{u_i}}{\partial{\eta_i}}\cdot\frac{\partial{\eta_i}}{\partial{w_j}}=\frac{\partial{u_i}}{\partial{\eta_i}}x_i^j}
[p12]: http://latex.codecogs.com/gif.latex?{\frac{\partial{L}}{\partial{w_j}}=\sum_{i=1}^{n[\frac{y_i-u_i}{var(y_i)}\cdot\frac{\partial{u_i}}{\partial{\eta_i}}]x_i}j}
[p13]: http://latex.codecogs.com/gif.latex?{p(y_i=1)=\pi_i}
[p14]: http://latex.codecogs.com/gif.latex?{p(y_i=0)=1-\pi_i}
[p15]: http://latex.codecogs.com/gif.latex?{p(y_i|\pi_i)=\pi_i^{{y_i}(1-\pi_i)}{1-y_i}=exp[y_i\log(\frac{\pi_i}{1-\pi_i})-\log(\frac{1}{1-\pi_i})]}
[p16]: http://latex.codecogs.com/gif.latex?{\theta_i=\log(\frac{\pi_i}{1-\pi_i})}
[p17]: http://latex.codecogs.com/gif.latex?{g(\theta_i)=\log(\frac{1}{1-\pi_i})}
[p18]: http://latex.codecogs.com/gif.latex?{a(\phi)=1}
今天有人问，为啥做Logistic regression 参数估计时不用OLS了呢？问这个问题是说明其对ols那个“误差平方和”怎么来的没搞清楚，他认为用Logistic regression的连接函数(log(p/1-p)-wx)^2就可以套用所谓的”OLS“了，其实不然。首先，书本上OLS基本都是以线性模型为例去介绍，直接来一个误差平方和然后求解，这其实是一个误导：对于线性模型，我们是假设响应变量Y服从正态分布，为方便说明我们假设Y服从N(u,1)的正态分布（正态分布的方差与期望无关可以忽略，原因自己悟），于是我们有：![][z1]
对应指数分布族我们有：
连接函数![][z2]
套用指数分布族的参数梯度公式很容易得到：![][z3]

接下来为了和OLS的误差平方和相对应，我们直接通过极大似然估计得到OLS的“误差平方和”如下(log-likelihood)：![][z4]
式中后面一项为常数项，求最大最小可省去，所以要估计参数只要使得该似然函数最大时的参数即可，于是有：![][z5]
对该式求偏导数得到和指数分布族同样的结果，剩下的自行求解与比较。
[z1]: http://latex.codecogs.com/gif.latex?{f(y;u)=\frac{1}{\sqrt{2\pi}}exp[-\frac{1}{2}(y-u)^2]=exp[uy-u2/2-(y^2/2+1/2\cdot{log(2\pi)})]}
[z2]: http://latex.codecogs.com/gif.latex?{f(u_i)=u_i=x_i^Tw=\eta_i}
[z3]: http://latex.codecogs.com/gif.latex?{\frac{\partial{L}}{\partial{w_j}}=\sum[\frac{y_i-x_i^{Tw}{1}\cdot{1}]x_i}j=\sum[y-x_i^Tw]x_ij}
[z4]: http://latex.codecogs.com/gif.latex?{L=\sum{L_i}=\sum[-({y_i-u_i})^{2+\log(\frac{1}{\sqrt{2\pi}})}n]}
[z5]: http://latex.codecogs.com/gif.latex?{argmax(L)=argmax(\sum-({y_i-u_i})^{2)=argmin(\sum({y_i-u_i})}2)=argmin(\sum({y_i-x_i^Tw})2)}

基于Tensorflow实现：

import numpy as np
from sklearn import datasets, linear_model
import matplotlib.pyplot as plt
import tensorflow as tf
class Config:
    # Gradient descent parameters (I picked these by hand)
    epsilon = 0.01  # learning rate for gradient descent
    reg_lambda = 0.01  # regularization strength
    x_dim=2
def generate_data():
    np.random.seed(0)
    X, y = datasets.make_moons(200, noise=0.20)
    return X, y
def visualize(X, y):
    # plt.scatter(X[:, 0], X[:, 1], s=40, c=y, cmap=plt.cm.Spectral)
    # plt.show()
    #plot_decision_boundary(lambda x:predict(model,x), X, y)
    plt.scatter(X[:, 0], X[:, 1], c=y, cmap=plt.cm.Spectral)
    plt.title("Logistic Regression")
    plt.show()
_X,_y=generate_data()
visualize(_X,_y)
#begin LR model
io_tf = lambda dim: tf.placeholder(tf.float32, dim)
var_tf = lambda init: tf.Variable(init)
def tf_logistic(_X):  
    return 1/(1 + tf.exp(-_X))
x_dim=Config.x_dim
#定义likelihood-function
with tf.device('/cpu:0'):
    x = io_tf([None, x_dim])
    y = io_tf([None, 1])
    W = var_tf(tf.zeros([x_dim, 1]))
    b = var_tf(tf.zeros([1]))
    y_ = tf_logistic(tf.matmul(x, W) + b)
    loglikelihood = tf.reduce_sum(tf.log((1-y_)*(1-y) + y*y_))
lr = Config.epsilon  # Learning rate
with tf.device('/cpu:0'):
    dydW = tf.gradients(loglikelihood, W)[0]
    dydb = tf.gradients(loglikelihood, b)[0]
    gradient_ascend = tf.group(
        W.assign_add(lr*dydW),
        b.assign_add(lr*dydb))
err_min = 0.01
max_iter = 1000
data_X=_X
trY=_y
temp = trY.shape
data_y = _y.reshape(temp[0],1)
#print _y.reshape(200,1)
#print data_X
#梯度更新
with tf.Session() as sess:
    #tf.global_variables_initializer().run()
    tf.global_variables_initializer().run()
    
    def classifier(_X):
        _y = sess.run(y_, feed_dict={x: _X})
        _Y = np.column_stack((_y, 1 - _y))
        return _Y
    #lll_old = sess.run(loglikelihood, feed_dict={x:data_X, y:data_y})
    for i in range(max_iter):
        #for (x, y) in zip(data_X, data_y):
        lll_old = sess.run(loglikelihood, feed_dict={x:data_X, y:data_y})
        sess.run(gradient_ascend, feed_dict={x:data_X, y:data_y})
        lll = sess.run(loglikelihood, {x:data_X, y:data_y})
        if abs(lll - lll_old) < err_min:
            break
        print("Epoch = %d,Error== %.2f")%(i,abs(lll - lll_old))
            
    print("Optimization finished in ", i, " iterations.")

Label数据类型	分布类型	连接函数	逆连接函数	激活函数名称
Binary	Binomial	![][f1]	![][f2]	Sigmoid
Binary	Probit	![][f3]	![][f4]	Probit
Categorical	Multinomial		![][f5]	Softmax
Counts	Poisson	![][f6]	![][f7]
Sparse	Tobit		![][f8]	ReLU

Label数据类型	分布类型	连接函数	逆连接函数	激活函数名称
Binary	Binomial	![][f1]	![][f2]	Sigmoid
Binary	Probit	![][f3]	![][f4]	Probit
Categorical	Multinomial		![][f5]	Softmax
Counts	Poisson	![][f6]	![][f7]
Sparse	Tobit		![][f8]	ReLU

4. 第二层：特征学习/表示-正谈

接下来，我们来拆解第二层，即真正的网络层，从前面的介绍以及图表示环节，大概需要理解两个关键环节：顶层（第三层）Loss function的构建、优化（即第三层与中间第二层以及第一层之间参数如何传递和共享）。对于Loss function的构建需要观测到的数据（人工标注的label或target，或自产生的label-典型如RNN），前面我们分析过，中间层其实也是一个个GLM的小模块，由前一层的输出作为输入的线性组合与连接函数（激活函数）组成：在优化环节如何把标注的信息通过参数或梯度传递给前面隐层达到整体效果优化的目的呢，这里有一个核心方法叫“后向传播”（Back Propagation），为了方便理解，后面的解析结合图形以及以单节点的多层网络为例，首先我们看一个2层（针对中间层定义）单节点网络：

单节点网络.png

从图中可以看出，每个神经元节点都是连接上一层的函数，从两外一角度来看，当我们改变w1的数值，神经元节点的结果“h1”和“h2”层的结果都会发生变化，最终将变化传导给output Y，即顶层，由上面的解析，我们最终是通过设计顶层的Loss function来进行参数的优化和传导，用数学公式将顶层的output表达为一个混合函数如下：

${Y=g3(w3\cdot{h2})}$

${h2=g2(w2\cdot{h1})}$

${h1=g1(w1\cdot{X})}$

所以最终output的表达式为：![][4.4]
也就是说整个中间层输出给顶层的output是一个由各层参数、输入层数据/特征以及activation function(s)的混合函数。接下来如果想对每个参数求梯度（以w1为例），采用链式法（chain rule）则逐个求解即可：![][4.5]

[4.4]: http://latex.codecogs.com/gif.latex?{Y=g3(w3\cdot{g2(w2\cdot{g1(w1\cdot{X})})})}
[4.5]: http://latex.codecogs.com/gif.latex?{\frac{\partial}{\partial{w1}}Y=\frac{\partial}{\partial{h2}}Y\cdot\frac{\partial}{\partial{h1}}{h2}\cdot\frac{\partial}{\partial{w1}}h1}
接下来，我们使用上一节推导的Loss function以及观测到的Target Y将第二层的输出和第三层进行连接，如图：

网络-loss.png

由上一节推导，我们得到顶层的Loss function通用方程为：![][4.6]
将第二层输出的output综合表达函数带入得到：![][4.7]
注意！这里的g1、g2、g3为中间层的连接函数，g为顶层的连接函数。此时，我们已经通过Loss function和连接函数把整个三层建立联系，接下来可以最终对每个层的每个参数进行梯度求解和更新，依然以w1为例：![][4.8]
接下来使用观测到的数据运用后向传播和梯度更新，逐步迭代直至得到整个网络所有参数的值，用图示表达为：

后向传播路径.png

基于Tensorflow实现：

#以多层线性回归为例
import tensorflow as tf

n_units_l = (1, 10, 10, 10, 10, 10, 10, 10, 1)

io_tf = lambda dim: tf.placeholder(tf.float32, dim)
trX=np.linspace(-1, 1, 200)
trX=trX.reshape(200,1)
trY=2 * trX + np.random.randn(*trX.shape) * 0.33
trY=trY.reshape(200,1)
def tf_logistic(_X):  
    return 1/(1 + tf.exp(-_X))

def tf_leaky_relu(_X, leak=0.1):  
    return tf.maximum(_X, leak*_X)

x = io_tf([None, 1])
y = io_tf([None, 1])

def hidden_layer(_input, n_units):
    n_in = int(_input.get_shape()[1])
    W = tf.Variable(tf.random_uniform([n_in, n_units], minval=-1, maxval=1))
    b = tf.Variable(tf.random_uniform([n_units], minval=-1, maxval=1))
    return tf.nn.relu(tf.matmul(_input, W) + b), W, b
    # return tf_leaky_relu(tf.matmul(_input, W) + b), W, b

layer = []
Ws = []
bs = []
_l, _W, _b = hidden_layer(x, n_units_l[1])
Ws.append(_W)
bs.append(_b)
layer.append(_l)
for n_l in n_units_l[2:-1]:
    _l, _W, _b = hidden_layer(_l, n_l)
    Ws.append(_W)
    bs.append(_b)
    layer.append(_l)
    
W_out = tf.Variable(tf.random_uniform([n_l, 1]))
b_out = tf.Variable(tf.random_uniform([1])) 
net = tf.matmul(layer[-1], W_out) + b_out



MSE = tf.reduce_mean(tf.squared_difference(net, y))

import numpy as np
import matplotlib.pyplot as plt
# train_step = tf.train.AdadeltaOptimizer(0.01).minimize(MSE)
train_step = tf.train.RMSPropOptimizer(0.01).minimize(MSE)
init = tf.global_variables_initializer()
sess = tf.Session()
sess.run(init)

def regressor1D(x_mesh):
    X = x_mesh.reshape(-1,1)
    return np.ravel(sess.run(net, feed_dict={x: X}))
n_batches = 5
n_samples=200
batch_size = n_samples//n_batches
print(trX.shape)
for i in range(10000):
    for j in range(n_batches):
        sess.run(train_step, feed_dict={x: trX[batch_size*j:batch_size*(j+1)-1,], y: trY[batch_size*j:batch_size*(j+1)-1]})
        if not i % 2000 and j == 1:
            print(sess.run(MSE, feed_dict={x: trX, y: trY}))

[4.6]: http://latex.codecogs.com/gif.latex?{L(\theta|D)=\sum_{i=1}^n[\frac{f(wTX){y_i}-g(f(w^TX))}{a(\phi)}+\Phi(y;\phi)]}
[4.7]: http://latex.codecogs.com/gif.latex?{L(\theta|D)=\sum_{i=1}^n[\frac{g3(w3\cdot{g2(w2\cdot{g1(w1\cdot{x_i})})}){y_i}-g(g3(w3\cdot{g2(w2\cdot{g1(w1\cdot{X})})})))}{a(\phi)}+\Phi(y;\phi)]}
[4.8]: http://latex.codecogs.com/gif.latex?{\frac{\partial}{\partial{w1}}L=\frac{\partial}{\partial{Y}}L\cdot\frac{\partial}{\partial{h2}}Y\cdot\frac{\partial}{\partial{h1}}{h2}\cdot\frac{\partial}{\partial{w1}}h1}

5. 第二层：特征学习/表示-杂谈

我们在建模的时候，非常重要且往往决定结果好坏的环节是特征的提取，也就是我们谈的第二层的内容，而特征的提取无非就人工和机器自动提取两种，有一个有意思的观点认为无论是深度学习还是人工特征浅层学习，目的都是有目的的进行“信息丢失”的过程，其实这个可以从数学上严格证明(参见：Data Processing Inequality)，因为在不添加新数据的条件下，原始数据包含的信息量是最大的，之后对其进行处理和特征工程，信息就是在逐步损失掉，那么有人可能要疑问了：既然只要做特征，信息就减少，岂不是效果会变差吗？其实，并不矛盾，我们容易想到，无论建立何种模型、进行何种特征学习都是为了完成某个领域的任务，那么进一步可以想到原始数据中一定包含该任务下不需要的信息，所以理论上，我们做建模和特征工程理想情况是努力把为完成某项任务不需要的信息损失掉，从而使得模型效果反而提高，其实对应人脑信息损失的过程也可以理解为“抽象”的过程。例如，我们大脑储存了大量的信息和记忆，如果给定一个任务去判断某动物是不是狗，那么人通常会是从脑中记忆的大量信息中丢弃与狗无关的信息，并把狗想关的多种扁平特征抽象到一个高维“立体”空间来进行判断，最终得到该动物是否为狗的识别。
“抽象”在数学概念里（与我们今天讨论话题相关的概念）可以用一个词叫“线性可分性”来约等于，很面熟的一个概念，很多人对这个概念的了解可能会出自于流行多年的SVM，大概的过程是判断原始特征是否“线性可分”，如果不可分，则采用核方法将原始特征“升维”以获得更丰富的数据表达，以实现在新的空间里“线性可分”，核方法是非参数的思想，基本思路是通过一个正定核，得到一个线性映射将数据映射到一个RKHS（ Reproducing Kernel Hilbert Space）中，然后使用RKHS中的线性模型来处理数据，可能有人要疑问了，为啥一定要“线性可分”而不是直接找一个非线性的表达来做。道理很简单，线性函数非常容易表达和估计，我们无法找到一个具体的非线性表达来对原始数据进行抽象，所以不论是SVM也好还是神经网络，本质都是通过可以抽象出来的通用变换来产生新的空间，并使得输入层可以在新的空间找到线性表达完成模型任务。

6. 结论

绝大部分的建模过程都可以粗略的抽象为输入、特征学习、任务三层，目的是通过任务层，对特征学习层进行抽象，得到线性可分的特征空间，反过来提高任务层的性能。

[1.3]: http://latex.codecogs.com/gif.latex?{g(f(w^{TX))=-\log[\frac{1}{1+exp(\sum_{j=1}}mw_jx^j)}]}
[1.4]: http://latex.codecogs.com/gif.latex?{g(f(w^{TX))=-\log[\frac{1}{1+exp(\sum_{j=1}}mw_jx^j)}]}
[1.5]: http://latex.codecogs.com/gif.latex?{\frac{\partial{L}}{\partial{w_j}}=\sum_{i=1}^n[y_ix_ij+\frac{1+exp(\sum_{j=1}^m-w_jx_ij)}{exp(\sum_{j=1}^m-w_jx_ij)}\cdot\frac{-1\cdot{exp(\sum_{j=1}^m-w_jx_ij)}}{(1+exp(\sum_{j=1}^m-w_jx_ij))^2}\cdot{x_ij}]}
[1.6]: http://latex.codecogs.com/gif.latex?{\frac{\partial{L}}{\partial{w_j}}=\sum_{i=1}^{n[y_i-\frac{1}{1+exp(\sum_{j=1}}m-w_jx_i^{j)}]\cdot{x_i}j}}

[1.7]: http://latex.codecogs.com/gif.latex?{g(f(w^{TX))=exp(\sum_{j=1}}mw_jx^j)}

附录：各个公式
指数分布族分布表达式
![][2]
[2]: http://latex.codecogs.com/gif.latex?{f(y;\theta)=t(y;\phi)s(\theta;\phi)e^{\frac{\theta\y}{a(\phi)}}\=exp[\frac{\theta\y-g(\theta)}{a(\phi)}+\Phi(y;\phi)]}
其中，
![][3]
[3]: http://latex.codecogs.com/gif.latex?{t(y;\phi)=exp[\Phi(y;\phi)]}
![][4]
[4]: http://latex.codecogs.com/gif.latex?{s(\theta;\phi)=exp[\frac{-g(\theta)}{a(\phi)}]}
分布函数在定义域内积分等于1
![][5]
[5]: http://latex.codecogs.com/gif.latex?{\int\f(y;\theta)\space\dy=1}
两边同时取对theta求偏导数
![][6]
[6]: http://latex.codecogs.com/gif.latex?{\frac{d}{d\theta}\int\f(y;\theta)dy=\frac{d}{d\theta}\cdot1=0}
![][7]
[7]: http://latex.codecogs.com/gif.latex?{\int\frac{df(y;\theta)}{d\theta}dy=0}
期望的积分表达式
![][8]
[8]: http://latex.codecogs.com/gif.latex?{E(x)=\int\x\cdot\f(x)dx}
进一步推导
![][9]
[9]: http://latex.codecogs.com/gif.latex?{\frac{df(y;\theta)}{d\theta}=[\frac{y}{a(\phi)}-\frac{g^\prime(\theta)}{a(\phi)}]f(y;\theta)}

![][10]
[10]: http://latex.codecogs.com/gif.latex?{\int\frac{df(y;\theta)}{d\theta}=\int[\frac{y}{a(\phi)}-\frac{g^\prime(\theta)}{a(\phi)}]f(y;\theta)dy=0}
![][11]
[11]: http://latex.codecogs.com/gif.latex?{[\frac{E(y)}{a(\phi)}-\frac{g^\prime(\theta)}{a(\phi)}]=0}
最终得到指数分布族的期望通用解：
![][12]
[12]: http://latex.codecogs.com/gif.latex?{E(y)=g^\prime(\theta)}
似然-loss
![][13]
[13]: http://latex.codecogs.com/gif.latex?{l(\theta|D)=\prod_{i=1}^nexp[\frac{\theta{y_i}-g(\theta)}{a(\phi)}+\Phi(y;\phi)]}
似然-log-loss
![][13.1]
[13.1]: http://latex.codecogs.com/gif.latex?{L(\theta|D)=\sum_{i=1}^n[\frac{\theta{y_i}-g(\theta)}{a(\phi)}+\Phi(y;\phi)]}
对参数求偏导数
![][13.2]
[13.2]: http://latex.codecogs.com/gif.latex?{\frac{\partial\L}{w_j}=\frac{\partial\sum_{i=1}^n[\frac{f(wTX)y_i-g(f(w^TX))}{a(\phi)}]}{\partial{w_j}}}
![][13.2.1]
[13.2.1]: http://latex.codecogs.com/gif.latex?{\frac{\partial{L}}{w_j}=\frac{\partial\sum_{i=1}^{n[\frac{f(\sum_{j=1}}{m}w_jx_i^{j)y_i-g(f(\sum_{j=1}}{m}w_jx_i^j))}{a(\phi)}]}{\partial{w_j}}}
链式法则
![][13.2.2]
[13.2.2]: http://latex.codecogs.com/gif.latex?{\frac{\partial\L}{w_j}=\sum_{i=1}^{n[\frac{y_i}{a(\phi)}\cdot\frac{\partial{f(\sum_{j=1}}mw_jx_i^{j)}}{\partial\sum_{j=1}}mw_jx_i^{j}\cdot\frac{\partial\sum_{j=1}}mw_jx_i^{j}{w_j}-\frac{1}{a(\phi)}\cdot\frac{g(f(\sum_{j=1}}mw_jx_i^{j))}{\partial{f(\sum_{j=1}}mw_jx_i^{j)}}\cdot\frac{\partial{f(\sum_{j=1}}mw_jx_i^{j)}}{\partial\sum_{j=1}}mw_jx_i^{j}\cdot\frac{\partial\sum_{j=1}}mw_jx_i^j}{\partial{w_j}}]}
给theta赋予自变量的表达
![][13.3]
[13.3]: http://latex.codecogs.com/gif.latex?{\theta=f(w^TX)}

![][13.4]
[13.4]: http://latex.codecogs.com/gif.latex?{L(\theta|D)=\sum_{i=1}^n[\frac{f(wTX){y_i}-g(f(w^TX))}{a(\phi)}+\Phi(y;\phi)]}
Lasso
![][14]
[14]: http://latex.codecogs.com/gif.latex?{l(\theta|D)=\prod_{i=1}^{nexp[\frac{\theta{y_i}-g(\theta)}{a(\phi)}+\Phi(y;\phi)]\cdot\prod_{j=1}}d\frac{1}{2b}exp^{-\frac{|w_j|}{b}}}

![][14.1]
[14.1]: http://latex.codecogs.com/gif.latex?{L(\theta|D)=\sum_{i=1}^{n[\frac{\theta{y_i}-g(\theta)}{a(\phi)}+\Phi(y;\phi)]+\sum_{j=1}}d{\frac{\log(2b)}{b}\cdot{|w_j|}}}
普通似然loss的后验估计表示
![][15]
[15]: http://latex.codecogs.com/gif.latex?{l(\theta|D)=\prod_{i=1}^{nexp[\frac{\theta{y_i}-g(\theta)}{a(\phi)}+\Phi(y;\phi)]\cdot(\frac{1}{b-a})}d}