Welcome to DeepLearning ON GPU’s documentation!

Contents:

数学与物理基础

DL的数学模型

\[ \begin{align}\begin{aligned}f =\sum{h(x)g(x)}\\y = f(WX+b)\\Loss = L(y-y')\\W_{i+1}=Wi - \lambda\frac{\partial{L}}{\partial{W_i}}\end{aligned}\end{align} \]

所谓的Loss函数，可以是两数之间的距离的度量，也可以两个序列之间的距离的度量。在正常情况下，我们希望两者之间的差距，越小越好。可以用cross-entroy或者协方差来表示。

ML 工作流程

_images/BasicMachineLearningWorkflow.png

P 范数。

信息流

#.Data Training, validation, Testing

digraph G { Data->model->score->loss->model; }
  1. 训练的基本问题
    • 过拟合与欠拟合 可以通过validation loss 来观察得到
    • 梯度消失

a naive dl code

class pototype:
    def train/fit(train_images,train_labels):
        # build a model of images ->labels.
    def predict(image):
        #evalute the model on the image
        return class_label


class NearestNeighbor:
    def __init__(self):
        pass

    def train(self,X,y):
        """ X is N x D where each row is an example. Y is 1-dimension of size N"""
        # the nearest neighbor classifier simply remembers all the training data
        self.Xtr = X
        self.ytr = y
    def predict(self,X):
        """ X is N x　D　where each row is an example we wish to predict label for"""
        #lets make sure that the output type meatches the input type
        Ypred = np.zeros9num_test,dtype=self.ytr.dtype)

        for i in xrange(num_test):
            #find the nearest training image to the i'th test image
            # using the L1 distance (sum of absolute vlaue differences)
            distances = np.sum(np.abs(self.Xtr-X[i,:]),axis=1)
            min_index = np.argmin(distances)
            Ypred[i]=self.ytr[min_index]

class MyModel:
    def predict(self,X):
        return X.dot(self.w)

    def fit(self,X,Y,eta,T):
         self.w = np.random.randn(X.shape[1])
         for _ in range(T):
              y_hat = self.predict(X)
              self.w = self.w - eta* X.T.dot(Y_hat -Y)
    def cost(self,X,Y):
        Y_hat = self.predict(X)
        return (Y_hat -Y).dot(Y_hat -Y)

  X, Y = load_my_dataset()
  model = MyModel()
  model.fit(X,Y)

大部分的机器学习都是在解决fit,predict 这两个函数是如何实现的。

网络的拓扑结构

有点类似于设计设计模式一样，创建型，结构型，行为型。

创建型
  1. RNN RNN是一个基本模型，在训练的时候会遇到gradient explode或者gradient vanishing的问题，导致无法训练，所以在实际中经常使用的是经过改良的LSTM RNN或者GRU RNN对输入序列进行表示，更加复杂一点可以用BiRNN、BiRNN with LSTM、BiRNN with GRU、多层RNN等模型来表示，输入序列最终表示为最后一个word的hidden state vector
  2. GAN
结构型
  1. CNN,
  2. 元胞机
行为型
  1. 增强学习

流程

  1. Define a model
  2. Compute a cost based on model output and training data
  3. Minimize the cost using gradient descent wrt model parameters

非监督学习

  1. K-Means clustering
  2. Guassian mixture models
  3. Hidden Markow Models
  4. Factor Analysis
  5. Matrix factorization
  6. Quadratic discriminator/regressor

神经学

人工智能的未来

大脑是使用记忆来创造的世界，大脑用记忆模型来预测未来，目前的深度学习也体现了这一点。

大脑和计算完全不同，大脑不是靠计算来解决掉问题，而是通过记忆来解决问题。

现在的神经网络分类是单层的分类，层次化的分类，现在还做不到。

神经网络起源

神经网络起源于对大脑皮层的研究，神纤细胞的轴突末梢（也就是终端）->神经细胞=处理端f(x)。

alternate text

GPU软件结构

大脑特征

  1. 大脑皮层具有 分布式 并行的特点，
  2. 最后的输出具有归纳和推广功能。
  3. 神经输出按照激活（fire）和不激活两种选择。
\[\begin{split}\begin{figure}[htp!] \centering \includegraphics[width=6cm]{NN.jpg}\\ \caption{神经网络基本结构} \end{figure}\end{split}\]

虽然神经网络具有复杂的结构，但是只是简单人脑的模拟，成为人工智能（ANN），利用f(x) 模拟人脑思考中的非线性。

大脑模型： 一个是人类有几十万年的进化基础，并且沉淀下来。特别是那些人类看起来很容易，但是计算机却很难的事情。 另外那就是计算量的问题，现在超算的计算量已经超过人脑了。

Hebbian theory

“Cells that fire together, wire together”. Cell A 必须参与激活Cell B。 同时激活的两个细胞必须相关，因此激活一个，有助于激活另一个。 如果一个模式重复发生 ，将会造成每个元素趋向于激活另外的相关的元素，并行熄灭另外一些相关的元素。

使用公式表示其关系就是： \(w{ij}xi xj\) 也可以写成： \(w{ij}\frac{1}{p}\sum{k1}{p}xi xj\)

问题：

  1. 目前怎样建立一个cell和另一个cell之间的联系？
  2. 这里的稀疏性是同层的，还是不同层的？目前处理这个是不是很困难？

当前神经科学的反向工程

digraph G { "模仿" -> "反向工程" -> "得到原理本质" -> "创新组合"; }

结构产生力量，

感觉神经网络的信号编码，许多都可以破译。听觉:完成，视觉:基本完成，四肢运动:部分功能。温度，痛觉都完成了

  1. 现在人工视网膜已经可以实验室里实现了

大脑也分几个等级。线虫，蟑螂，猫，人脑。蟑螂基本完成。猫脑，正在做…，人脑还早

生物进化了40亿年才得出人脑。人已经也别太着急一步到位搞出人脑级的，雷昊: 人脑的视觉v1，v2研究的也还好，v3，v4感觉就一抹黑 人脑到了中脑以后比较难研究，百亿级神经元，每个神经元有很多树突，每个轴突可以连接多个树突，还有自循环。群体到了这么大规模只研究个体还差很多啊

introduction

chaos 数论 数学分析  
张量分析 ` 复变函数 <ComplexFunction>`_ 矩阵论  
近世代数   概率统计与随机过程  

盲源分离

实变函数 集合理论 离散数学  

– Main.GegeZhang - 08 Feb 2013

方均根误差 RMSe=sqrt(sum((Ti-Ai).^2)/n)    
方均跟误差函数：std（abs（x1-x0)) x1是求得数据，x0为原始数据  

root mean square sqrt（1/N sum（（x1-x0)^2+（y1-y0)^2）） x1 和y1变动起来。 [Direct Position Determination of Multiple Radio Signals]

compact set 紧致集 相当于封闭解

详细参考

The “echo state” approach to analysing and training recurrent neural networks – with an Erratum note1

随机过程 See also ========

  1. mathoverflow 一个不错数学论坛
  2. 本科数学专业课程
  3. 数学专业的大学课程该怎么学呢？哪些课更重要？
  4. 将数系从复平面扩展至三维等高维数空间完全可能 在低维复杂的问题，到了高维就变的简单了
  5. 超越复数的三元数 ──从复平面到三维数空间
  6. 计算机与数学看看总些一下思路
  7. MIT牛人解说数学体系
  8. matth videio web
  9. 国外数学谭程
  10. Video lectures on Real Analysis?
  11. 数学之旅 上海交大
  12. 图像处理中的数学问题
  13. 群论
  14. 抽象代数
  15. 斯坦福大学公开课 ：机器学习课程 这个和自己下载的应该是配套的
  16. 离散优化
  17. 图像处理的数学方法
  18. http://www.360doc.com/content/10/1110/22/106832&#95;68338547.shtml 里面的高维图像处理是什么？
  19. 天玑学术网 看看可以快速找到方向
  20. 历年全国优秀博士学位论文评选结果
  21. Petri网 用于状态分析，工作流设计
  22. 科学家怎样做科研
  23. 运筹学石华
  24. 一个数学科普网站
  25. 我的学习经验 杨振宁
  26. 文化科普
  27. 国内建的数学科普网站

Thinking

数学分析，高等代数，概率论与数理统计，解析几何，常微分方程，实变函数论，复变函数，微分几何，近世代数，数论，我们学校还另外开了数学建模以及经济数学中那个叫啥来着……基本上就这些专业课了，LZ想跨过来的话个人以为数学分析和高等代数要系统的学了，特别是数学分析，没学好这个的话后继课程基本上学了也白搭，加油吧，毅力胜过一切！

– Main.GangweiLi - 18 Sep 2013

我学的是基础数学，数学分析高等代数解析几何是基础，抽象代数是高代的深入，实变函数又叫实分析是数学分析的深入，加上常微分方程和复变就可以了，拓扑和泛函是研究生的基础，努力学下就可以了~~~我感觉每门都很重要。都是整体，对了，还有微分几何，想学几何的话也是很重要的专业课。

– Main.GangweiLi - 18 Sep 2013

与其在低维上纠结的事情，放在高维的就变的简单了。最重要的那就是独立思考力。所以能够快速掌握利用计算机来进行推导。可能要真的去看看hackwell语言了。它能更高层面解决你的编程问题。

– Main.GangweiLi - 19 Sep 2013

梁伟说 图像搜索，视频图像处理现在比较火。

– Main.GegeZhang - 14 Oct 2013

行列式det的意义是什么？都有哪些用途？

– Main.GegeZhang - 16 Oct 2013

建模思路 Mathematical_optimization #. 建立目标方程 #. 寻找约束条件 #. 利用拉格朗日乘法与KKT来建立解方程式 #. 通过求极值或者解方程来得目标条件 #. 分析目标条件性质，再进一步优化计算，或者寻找简化计算

– Main.GangweiLi - 24 Feb 2014

图论

图论是由若干给定的点以及连接两点的线所构成的图形，这种图形用来描述实物某种特定的关系，用点代表事物，用连接两点的线表示相应的事物具有这种关系。

拓扑学说:

数学建模

首先对事物有感性认识，上升到理性认识，通过进行总结 。（牛顿万有引力）

建模首先是自己做 自己把问题进行建模。

建模不一定解决一切问题，只是一种思路吧。

我原来建模的就是问题没有深入，深入思

行列式

行列式就是全排列求合。并且全排列的性质，因为每一行，每一列都必须出现每一个无素中，所以对于任意一行,列的操作都相当于是对于行列式所有项进行操作。同时我们还可以进行行列式任意两列相同，或者一行或者一列全为零，那么两个行列式值为零。 在python中可以使用`numpy.linalg <http://docs.scipy.org/doc/numpy/reference/routines.linalg.html>`_ 来进行常规的计算。 行列式就是一个函数，把n阶方阵，映射为一个标量，并且 在欧几何中，有着“体积”的概念。同时可以做为圆锥曲线的判别式。在看到行列式的时候，就要想着那个函数求和形式。这样就会一目录了解了，其实就是一次多项式看到特定的规律排列起来。

cross-product 就是定义按照行列式的定义来写的，只不过它是向量表示，物理意义是四边形面积，一个线性变换的行列式的值，就知道是两个两个变换前后面积比值。

inner-product表示表示的是投影，或者是向量相关性.

行列式与空间的定向性，线性变换，正为同向，负为反像。

规范化正交基的行列式=1.

aug_y=(a’*a)^(-1)*a’; % 最小二乘,使残差最小<br />r_n=a’*(eye(10)-a*aug_y); % 正交 最小二乘就是直接投影到正交空间。

矩阵

一般来说，矩阵可以直接一元函数方程。如何解非线性的二元方程。二次型就是其中一种。通过左右乘同时就可以表示一个二次方程了。对于一元函数，一个矩阵表示一组方程。而二次型，二次型而是表示一个方程。 看到行列式就应该想到那个那个遍历求和式。有点类似于内积的概念。 行列式 这个里面讲了行列式的发展史，并且与各个知识的联系。

这个是矩阵 矩阵 把这两个研究明白就行了。

现在需要的是各个知识之间的联系。而各个具体知识与再用到的时候再去研究。这也许就是整体与局部的关系。我所喜欢的应该是这种整体的关系的研究。而非具体的计算。

对行矩阵 Ax=B,我们习惯于按行与按列求法不同。尤其是按列行式的行列式。最常见的x为一个列向量，而B 也是一个列向量，而A是一个矩阵。按照列看，A就是一个线性空间的基，而x就是基的坐标值了。而b 就是一个项向量。 例如是一组点。x也是一组点大坐标了。所以坐标一般都用列向量来表示。

矩阵的kronecker积有点类似于笛卡尔积。

可以用矩阵来生成线性空间。但是矩阵本身并不是代性空间。对于Ax=0,与Ax=B,其实就是一个解空间平移的过程。 初等变换 ============

左行右列。最简单的说明，那不断乘以单位阵。可以先对单位阵进行变换，然后在左乘或者右乘了。初等方阵就相当于自然数中质数，例如一个方阵都可以一组初等方阵乘积。这个就像自然数因式分解。

相似矩阵，经过有限次初等变换的能相等的矩阵那就是相似矩阵。相似型可以用来研究二次型。也就是二次函数。任意一个给定二次型都是一个对称阵。把一个二次型化成标准型，其标准形的系数就是对称阵的特征值。 矩阵乘法的理解 =====================

  1. 按照定义，最基本的理解，那就是每一个元素都是对应的左行右列，内积之后。 在这个理解里，我们要把左边的一行当做向量，而右边的一列当一个空间向量。
  2. 按边的Ax=B,x的每一列与A与相乘。最后得到结果一列。这个就是一组线性组合。
  3. 按A的每一列与X的每一行相乘。
  4. 左边一行与右边一行。 就相当于一层一层的叠加。是不是那个金字塔。 1.与复合函数 以及神经网络

方程本身就是函数的隐式写法。所以方程组也就是函数组。对于一个矩阵来说，行数代表因变量的个数，而列数代表了自变量的个数。矩阵相乘的意义，就是线性变例如A=B,B=C,然后直接求A=C的过程。简单一些就是复合函数。 例如例如两个矩阵F,G.分别代表的是f,g的系数行列。那么f(g)就是F*G,而g(f)而是G*F. 右乘就是求解变量的函数。而左乘那就是外面在加了一层。例如f(g(h))那就是如何求f呢，那就是F*G*H.

而神经网络其实也就是矩阵乘法的应用。 上三角矩阵就是利用高斯消元法 ==========================================

从而A=LU-> PA=LU使其更加通用化了，而这个P叫做置换，那就是交换其行。这个P有一些特殊的性质，每一个维空间中，它们个数是有限的，每一维都有N!个。并且其其中任何一个P的转置=P的逆。并且形成一个群。

并且在这里学明白了空间与子空间。空间是由向量而来。 集合的笛卡尔积-> 向量->空间-> 线性空间->群。 对于线性空间，要求加法与数乘。并且八大基本运算规律。这些定义一定会有零空间，与一空间。也就是与0，1.这个两个值是必然存在的。 并且二维空间的一维子空间与一维空间是不一样的。因为其向量是二维的。 对于二维空间来说，它的子空间个数也是有限的，自然，0，以及所有过原点的直线。而不是我们想像的四个象限。 对于二维空间来说，它的子空间个数也是有限的，本身，0，所有过原点平面，以及直线。 每一个矩阵都可以构杨一个空间，如何构成呢，那就是其个列向量的线性组合。

一个向量空间中，只有其Ax=0 解构子空间。 而Ax=B不能子空间，没有没有零向量。但是这些解本身又具有什么性质呢。 矩阵的秩是主元的个数，那么，是由自由变量的的个数。例如haskell解数独。 -方程组的解空间 ======================

一组方程组解就组成一个线性空间，所以方程组的解与+，乘应该还是方程的解。 把方程组相当做函数，齐次方程组，就是没有常数量，非齐次那就是有常数项。

线性空间其实也是线性方程组的解空间。这个线性方程组就叫做变换。

%RED% Ax=b,可以看做是Ax=0的平移，所以Ax=b的解个数取决于Ax=0有多少解。 是不是看f（x)=Ax看做一个函数呢。这样原来函数变化，就有可能变成了空间的移动。随着x的变化而化。如果这样是不是可以有f(x)=Ax^n+bx^(x-1)….这样的方程呢。这样的方程有什么意义。如果这样对于描述物体运动，会更好，现在的基本变化方程已经都可以完全用4*4来实现了。

如何利用有限的线段拟合一个区域边界。反过来如果线性相关，而这个线段首尾相接就形成封闭的区线，其实也就是x1+x2+x3+x4..=0,也就是Ax=0,因为解空间的个数，另外一个那就是现在加法可以任意方向因为有交换率。但是我们如果能要求加法是单向的，不能再交换。我们是不能找到这样一个有序了数列拟合任何区域的边界。就像圆的内接多边形，现在我可以要求多边形长度有变化，有向线段，如果规定逆时针为正，这样不就是求Ax=0就好了。利用曲线的曲率来决定向量的长度。

f(x)=A*T^n*G. f(x)是最终运动方程。 A是物体本身，T就是那个仿射变换，n代表做几次变换，而g是那因变量的各种函数，你如地球转动的角度是时间函数。这样不就是一个整个的运动方程了。那么我们只要输入每一个输入状态。例如当前这个一个原点的位置，那么整个物体的位置不就知道了。

%ENDCOLOR%

线性空间维，基，坐标 有基才会坐标，坐标是一维的，有了基就可以事情简化为一维的运算。 秩是向量的最大无关组，秩也代表了可以线性方程组可以多个主元。也就相当于基的维数。而自由变量代表了解决空间的维数。

二阶导数组成一个海森矩阵。

Ax=b,我们看做一个函数，而例如f=Ax是函数的象公间，所以每b都是A的各列的线性组合。所以这个方程有解前提那是。b是A列空间一个列的线性组合。其线性组合另一个空间，并且这个空间维等+加上原空间的维数=整个空间维数。空间的最大维数是什么呢。与集合的势是什么关系。 零空间就是齐次方程组的解空间。null space 也正好是其正交补补集。也就是求f=0的值，

四个基本子空间，那就是左右零空间，与行空间与列空间。 矩阵空间，秩1矩阵和小世界图 ========================================

秩1的矩阵是不是可以用压缩数据。如果发现一个矩阵秩为1，就可以直接使用，一行一列，就保存其全部信息。那么一幅的图像秩一般会是多大呢。 并且在numpy,有特殊的支持，那就是broadcast方式，np.ogrid正是为产生这各矩阵最简单的方法，例就是那乘法表的实现最简单。 对于矩阵直接使用reduce操作。在函数矩阵函数的时候这些就会非常的方便。 注意numpy中array 是针对向量组的,numpy的matrix才是针对矩阵的。 小世界图就是六度空间。 #. 原创–秩为1的矩阵相关性质 正交向量与子空间与子空间投影 ==========================================

Ax=0就得出它的零空间与Ax的空间正交的，并且两者维数是相加等空间维数，所以两个空间正交，也叫做正交补。Ax=b变成f=Ax的话，那就f值就一个由A的列生成向量空间。 投影的过程，也就是扔掉了Ax=0的那部分，而留下了Ax=B的那一部分。投影指的一个空间的向量在子空间的投影。如果在全空间的投影，那么投影矩阵就成了单位阵，并且误差投影矩阵就变成了0向量。只是一个子空间上投影。那么其误差就一定在子空间的正交空间中。并且误差投影+投影矩阵=单位阵。这也是必然的。 P=aaT/aTa 在解Ax=b,时无解时，取一个近视解，b取在A 上的投影，熏直量就是误差。误差最小是求投影。P=A(ATA)-1AT， 通过通过一般二维的投影提出了高维空间的投影问 并且P^的平方=P,

正投影指的投影方向与投影平面是垂直的，而斜投影而非垂直的，相当于把投影平面当做旋转，然后再投影。斜投影=错切+正投影，那如果投影面是区面怎么办，例如是一个球面呢。会有什么性质与效果呢。还有那就是`曲线曲面投影 <http://wenku.baidu.com/view/bf2fe54633687e21af45a964.html>`_ 这个就要用到矩阵函数了吧。 斜投影不仅要指定投影平面，还要指定投影方向。具体见快盘斜投影的论文。 + 最小二乘 算法 =====================

通过子空间投影误差矩阵,通过代性代数求正交可以快速得到，也可以通过微积分求偏导极值得到参数值是一样的过程。以前一直感觉最小二乘的神秘，现在无非二次多元多项式求偏导。求方程组的解而己。

矩阵求导

现在明白了矩阵求导基本的就是jacobian 行列式， 从这个角度理解，就比较容易理解求导是什么了。 一个 .. math:: m times 1$% 的向量对一个 .. math:: n times 1 的向量求导，雅克比矩阵就是%$ m times n, 我们实际上分析的时候都是基于jacobian行列式的。

<img src=”%ATTACHURLPATH%/leastSquare.JPG” alt=”leastSquare.JPG” width=‘563’ height=‘435’ />

Thinking

*SVD分解*左右特征值，西矩阵。西矩阵是复数=实数的正交阵。

– Main.GangweiLi - 15 Oct 2013

`奇异阵 <http://stackoverflow.com/questions/10326015/singular-matrix-issue-with-numpy>`_ 无逆，且一个行列式Det为0 并且为numpy.linalg心专门的线性代数的包，例如求rank,det等。注意求秩不直接使用matrix中那个就是返回的是维数。

– Main.GangweiLi - 16 Oct 2013

*初等方阵相当于质数*任何一个可逆方阵可都示有限个初等方阵的乘积。

– Main.GangweiLi - 17 Oct 2013

我感觉行列式和cross-product仍旧联系不起来?

– Main.GegeZhang - 20 Oct 2013

现在明白为什么要一个矩阵要乘以的转置 这个是为了解决了Ax=B的在无解的情况下，找到一个最优解。例如我们需要三个参数来建立一个方程，来求解一量。但是我们为了测量的精确，我们N组数据，这就形成了N*3的矩阵。然后，我们不知道哪一组方程是不好的，直接把它扔掉了。我们需要的基于这些值得到一个最优解。如何来得到，在方程的两边同乘以它的转置，至于是左乘还是右乘。就要看你是N*N,还是变成3*3了。并且这是一个更好的矩阵。并且这个转置矩阵秩与原来是一样的。所以取得一大组数据之后。第一步删除重复的，然后删除线性的相关。只留下线性无关的。一个向量组的秩与是等于它的维数的。[[1,2,3],[2,4,6]] 这个只是一维的。 那就有一个问题，矩阵的秩区分行与列吗。应该不区分吧？然后再乘以转置变成一个更好的矩阵。

– Main.GangweiLi - 21 Oct 2013

子空间 一个子空间的维数与正交的子空间，它们的维数之和必然要等于这个空间的维数。例一个一根直线是一维的，而法平面就是二维。这样在三维的空间。它们才是正交的。另外一个空间的子空间，是指的其一个划分呢，还是只是其低层的子空间。

– Main.GangweiLi - 21 Oct 2013

点线面 以及整个数域用集合论以空间来研究。它们属于哪一部分。

– Main.GangweiLi - 21 Oct 2013

相关=平行

– Main.GangweiLi - 21 Oct 2013

– Main.GangweiLi - 21 Oct 2013

图 用列代表结点，而行代表边，起点用-1，终点用1，无关用零。这样形成矩阵，那如何表达权重值呢，结点数-边数+环数=1

– Main.GangweiLi - 27 Oct 2013

矩阵已经看到17张了。

– Main.GangweiLi - 27 Oct 2013

sympy 中矩阵推导好像不太靠谱

– Main.GegeZhang - 04 Dec 2013

Jacobian 就是向量vector求导，有什么意思

– Main.GegeZhang - 04 Dec 2013

对于向量B=[rx,ry,rz]‘和反对称矩阵R= [0,-rz ry; rz,0,-rx;-ry,rx,0]，

– Main.GegeZhang - 16 Dec 2013

DL的用到的数学

常用的分类函数

softmax

逻辑函数 也是S函数，也就是sigmoid function. \(P(t)=\frac{1}{1+e^{-t}}\)

_images/Logistic-curve.svg.png

softmax 函数就是归一化指数函数，是逻辑函数的一种推广，它可以任意维的函数类型映射变成(0,1)的S函数，并且所有函数元素的和为1。

\[softmax_i(a)=\frac{\exp{a_i}}{\sum\exp{a_i}}\]

用python进行函数计算的示例

import math
z = [1.0, 2.0, 3.0, 4.0, 1.0, 2.0, 3.0]
z_exp = [math.exp(i) for i in z]
print(z_exp)  # Result: [2.72, 7.39, 20.09, 54.6, 2.72, 7.39, 20.09]
sum_z_exp = sum(z_exp)
print(sum_z_exp)  # Result: 114.98
softmax = [round(i / sum_z_exp, 3) for i in z_exp]
print(softmax)  # Result: [0.024, 0.064, 0.175, 0.475, 0.024, 0.064, 0.175]
Cross-Entroy

这个概念是由香农信息量 \(log\frac{1}{p}\) 。 cross-Entory 又叫相对熵或者相对熵。

https://hit-scir.gitbooks.io/neural-networks-and-deep-learning-zh_cn/content/chap3/c3s1.html

\[\sum_{k=1}^N p_k\log_2 \frac{1}{q_k}\]

交叉熵可在神经网络(机器学习)中作为损失函数，p表示真实标记的分布，q则为训练后的模型的预测标记分布，交叉熵损失函数可以衡量p与q的相似性。交叉熵作为损失函数还有一个好处是使用sigmoid函数在梯度下降时能避免均方误差损失函数学习速率降低的问题，因为学习速率可以被输出的误差所控制。

交叉熵越低说明越相似。主要是度量两个序列相似度或者相关性大小的一种测量。

交叉熵与熵相对，如同协方差与方差.

熵考察的是单个的信息，交叉熵考察的是两个的信息（分布）的期望。

张量

张量 在数学里，张量是一种几何实体，或者说广义上的“数量”。张量概念包括标量、矢量和线性算子。张量可以用坐标系统来表达，记作标量的数组，但它是定义为“不依赖于参照系的选择的”.

我们简单的理解例 C/C++中的类对象在数学上可以用张量表示。 即有数据结构，同时自带运算。

 Tensor(
     Allocator *a,
     DataType type,
      const TensorShape & shape
)

https://eigen.tuxfamily.org/dox/unsupported/classEigen_1_1Tensor.html

Introduction

小波变换区别于傅里叶变换的主要原因就是 小波变换没有特定的basis，他是根据母小波和父小波（scale function）来逐步递归确定的，因此他比较适合于有突变的地方，其中wavelet function 提供了一个多尺度分析，我想和金字塔信号，就是提供了一个伸缩函数，可以灵活的想要的分辨率。
  1. 小波变换PPT 有限长均值为0的函数都为小波函数，能量集中。再看那个差值的分布，例均值，放在左与上，差值放在右与下，这样不就形成多分辨率了，只要从左上到右下逐步取值不就形了。可以直接计算出来当前图像的大小。这样的多尺度变换与MIPMAP 的存储关系。
  2. 小波变换 完美通俗解读 正线性的空间的基与向量的最大无关组，利用最大无关组来表示其他向量。系数的个数与最大无关组的个数，那么图像我们能不能每一行当做一个向量组，然后求出最大无关组。这样不是可以压缩数据了。一般对于图像的压缩都是采用分块的模式。 amsci 从这一篇文章中我们可以看从向量的无关组来延伸出来的，Haar矩阵。wavelet in wikipedia
如何利用矩阵的初等变换与求矩阵的逆。

小波在图像中应用

残差计算，子带编码，哈尔变换。 对于图像的压缩编码，应该有逐级变换解码的算法。每一点的值，应该是有固定的路径。而不必须每一次都把全部的运算解开。%RED%可以利用这种方法来产生一个算法性texture,再加分型的应用。 %ENDCOLOR%

Hilbert 和wavelet 变换的关系

– Main.GegeZhang - 16 Aug 2013

傅里叶变换中的基也应该是正交的

– Main.GegeZhang - 16 Aug 2013

尺度函数（父小波）：对自己本身周期平移的函数两两正交，为什么

– Main.GegeZhang - 16 Aug 2013

稀疏矩阵 小波变换其实有点类似于稀疏矩阵。特别是适合于，一个主波在不同的段有不同的波形组成。

– Main.GangweiLi - 15 Sep 2013

哈尔变换 是基固定，只是用来求系数。因为只有加减运算速度很快。

– Main.GangweiLi - 15 Sep 2013

JPEG 1. DCT 计算 1. 量化 1. 变长编码 图像分成8x8的像素块来进行的。

– Main.GangweiLi - 15 Sep 2013

http://glearning.tju.edu.cn/course/view.php?id=677

– Main.GegeZhang - 23 Sep 2013

+`稀疏编码 <SparseCoding>`_

-+`条件随机场 <ConditionalRandomFields>`_

+第二集梯度下降法

我想就是求导，我想和最小二乘本质上都是一样的。只不多最小二乘是参数向量的方法。 迭代函数：

\[{\theta _{i + 1}} = {\theta _i} - \alpha \nabla {J_i}\]

+`第三集线性回归 <LogisticRegression>`_

Durbin-Watson （DW）检验

是在回归模型的残差分析中被广泛地应用的一种技术。

假设我希望用最小二乘罚处理观察值，得到线性模型:

\[y_i =\beta+ \sum_{i=1}^k \beta_i X_{it}+ \xi\]

其中: \(\xi_t\) 为第t期的残差。要是这个模型成立，\(\xi_t\) 应该是独立的，因此:

\[\xi_t =P \xi_{t-1} +U_t\]

应该有P=0， 这样就可以检验模型是否正确。

http://wenku.baidu.com/view/18a1b2e8b8f67c1cfad6b84e.html

+第四集牛顿法

原理： 并不是所有方程都可以求解，因此使用一阶泰勒展开：\(f(x)=f(x_0)+(x-x_0)f^(x_0)\) , 求解 f(x)=0， 得到：\(x=x_1=x_0-f(x)/f(x_0)\) ， 虽然x1并不能让f(x1)=0, 但是只是更接近f(x)=0, 这样产生了迭代的思想。 牛顿法： .. math:: {theta _{i + 1}} = {theta _i} - alpha {J_i}/nabla {J_i} 相比梯度下降法速度更快。 然后又将了GLM，说明最小二乘和 logistic 回归都是GLM 指数分布的特殊情况。是不是我们现在的所有问题都是指数分布？ 主要是通过把某个问题划归为某个分布，然后求出期望 .. math:: mu，从而得到h(x)函数。

梯度法和牛顿法的对比

梯度法，是从导数的角度考虑，只是一个向量，而牛顿法是从泰勒分解的角度去考虑，是使用一个曲面去拟合。 那三阶导数又代表什么？ 牛顿法相当于考虑梯度的梯度，因此收敛速度更快

梯度法和牛顿法在构造上的不同参考:http://blog.csdn.net/dsbatigol/article/details/12448627

http://www.zhihu.com/question/19723347

http://www.math.colostate.edu/~gerhard/classes/331/lab/newton.html Newton’s Method in Matlab

拟牛顿算法 -BFGS 算法

\[min f(x) x\in R^n\]

BFGS算法的迭代公式为:math:x_{k+1}=x_{k}+alpha_kp_k ，其中:math:p_k 为 \(x_k\) 的下降方向满足:math:B_kp_k+deltaf(x_k)=0, :math:‘a_k 为步长，:math:‘B_k 的校正步长为

这里使用局部一次近似，g(x)代替f(x), 开始g(x) 找到，并保证。

这里代替f(x)之后， 就可以使用拟牛顿方法

参考:非凸函数极小问题的BFGS算法结合线性搜索一般模型的局部收敛性

+第五集第六集朴生成学习算法素贝叶斯算法

生成学习算法和logistic 回归的区别在于是否对p(x|y)建模， 也就是需要估计p(y)和p(x|y) ，利用贝叶斯等式求p(y|x) ，对于后来的0概率事件，提出laplace平滑，估计为小概率事件。

就是原来学的全概率时间。 算是后验概率。

-+第七集第八集`SVM <SurportVectorMachine>`_

SVM的约束函数是通过最小几何间隔实现的，在具体优化的时候使用对偶原理求另一个问题， 在出现outliner使用，加入惩罚项； 使用kernel 把低纬非线性问题转化为高维线性问题。 在优化的时候对于多个位置变量使用sequential minimal optimization 来解决多个变量问题，速度比较快。 #. Kernel-machines #. jason_svm_tutorial

而这个与深度学习神经元方式类似，只是神经元两个反向的，对于SVM是要先核函数转化，然后再KKT求最优解。而SVM直接就是线性叠加，然后经过激活函数。

但是从大的层面来看，SVM相当单层的神经网络。 在svm中有不同的非线性函数，但是DL能够用sigmod function 实现对问题的很好刻画。 使用卷积可以模拟任何的函数。

第九集 经验风险最小化

这一节主要讲的是在我用 .. math:: hat h 估计h时的误差，从概率上来说可能成功的概率， 比如在每次估计正确和错误，总有一个概率，这个服从伯努利分布，从而误差小于多少，从而推导出Hoeffding不等式，得到误差范围，同样也说明需要的 数据采样长度。

第十集feature selection and feature selection

-+`交叉验证 <crossValidation>`_

交叉验证 根据总数据的多少，不同的数据大小,选择不同的验证方法。

模型选择 怎样选择 模型大小，保证不再过拟合和欠拟合情况。

就是怎样使用数据的过程，比如使用70% 训练，30%验证， 对于少量数据使用交叉验证， 充分利用数据，

2、特征选择，选择相似度高的特征。然后使用交叉验证

如果我使用80% 用于训练，20% 用于测试，如果误差很大的说明（多大？） 是数据的异常检测造成的，要么是数据的造成的。

-+第十一集贝叶斯统计正则化

贝叶斯正则化： 也就是加入先验概率p(theta),其实想加入惩罚项一样，可以用与减少过拟合问题。

比如原来的约束函数表示为:

\[J(\theta) = \frac{1}{2m} [\sum_{i=1}^m(h_{\theta}(x^{(i)})-y^{(i)})^2 ]\]

加入贝叶斯正则化后表示为:

\[J(\theta) = \frac{1}{2m} [\sum_{i=1}^m(h_{\theta}(x^{(i)})-y^{(i)})^2 + \lambda\sum_^{j=1}^n \theta_j^2]\]

其中 \(\lambda\) 称为正则化参数，

而如果我们将:math:lambda 设置的很大，则会出现欠拟合.

这里的贝叶斯指的是什么？

http://52opencourse.com/133/coursera%E5%85%AC%E5%BC%80%E8%AF%BE%E7%AC%94%E8%AE%B0-%E6%96%AF%E5%9D%A6%E7%A6%8F%E5%A4%A7%E5%AD%A6%E6%9C%BA%E5%99%A8%E5%AD%A6%E4%B9%A0%E7%AC%AC%E4%B8%83%E8%AF%BE-%E6%AD%A3%E5%88%99%E5%8C%96-regularization

lasso算法

http://blog.csdn.net/pi9nc/article/details/12197661

将Lasso应用于回归，可以在参数估计的同时实现变量的选择，较好的解决回归分析中的多重共线性问题，并且能够很好的解释结果。本项目注重对实际案例中的共线性问题利用Lasso的方法剔除变量，改进模型，并将其结果与以往变量选择的方法比较，提出Lasso方法的优势。 将Lasso应用于时间序列。将Lasso思想应用于AR(p)、ARMA(p)等模型，利用Lasso方法对AR(p)、ARMA(p)等模型中的变量选择，并给出具体的算法，随后进行模拟计算，阐明AR(p) 、ARMA(p)等模型的Lasso方法定阶的可行性。

debug方法 training error 和 test error 可以参看`模型调试 <http://blog.sina.com.cn/s/blog_62f4f5d30101dyk9.html>`_

是算法选择不合适还是优化问题，通过一些特性，分析

比如当人类飞行员去的更小的J(theta),说明算法的问题，
反之人类飞行员更大的J(theta),说明J(theta) 设计的不对

-+第十二集 K-Means 和EM算法 ===================================··

这主要都是非监督学习， K-means 首先假设 K中心点， 然后对中心最小化，可以得到局部最优点，相当于 坐标上升法

EM算法和高斯分类算法差不多，只是这里我们不知道y，因此EM算法假设Z，首先假设Z=P(Z|X;theta) 然后估计theta.

K-SVD

这是k-svd，直接使用原图像。

K_SVD算法模型

原始k-SVD模型同时估计稀疏字典和稀疏系数，也就是包含两个未知矩阵：

\[\min\limits_{D,X}{||Y-DX||_F^2}\; \;\;subject \;to \forall i, x_i =e_k for some k\]

其中 :math: e_k 是单位阵，这个模型中，每个test图像中向量，只有一个1，其它全为0。但是在实际中，这个约束过分苛刻，为了放松约束，只要求任意图像都可以表示为矩阵D的线性表示，并约束 \(x_i\) 满足稀疏性，得到：

\[\min\limits_{D,X}{||Y-DX||_F^2}\; \;\;subject \;to \forall i, ||x_i||_0\leq T_0\]

估计X

这里因为同时有两个位置矩阵，D 和 X.因此无法得到最优解，这里采用近似追踪方法（approximation pursuit method）。首先假设任意初始矩阵D,估计X. 比如使用OMP算法。

更新dictionary D

因为D是一个矩阵，需要求的元素很多，所以这里采用每次只估计一个 :math: D_j 原子，其他 \(j\neq k\) 不变， 这种被称为extreme sparse represention。用梯度迭代更新的方法表示为：

\[D^{(n+1)}=D^{(n)}-\eta\sum_{i=1}^N(D^{(n)}x_i-y_i)x_i^T\]
\[\begin{split}\begin{array}{l} ||Y-DX||_F^2=||Y-\sum_{j=1}^Kd_jx_T^j||_F^2\\ =||(Y-\sum_{j\neq k}d_jx_T^j)-d_kx_T^k||_F^2\\ =||E_k-d_kx_T^k||_F^2\\ \end{array}\end{split}\]

抛弃零项，减小SVD估计D和W的计算量，得到：

\[\begin{split}\begin{array}{l} E_k^R=E_k\Omega,\\ x_R^k=x_T^k\Omega \end{array}\end{split}\]

核心代码实现：

noIt = 200
[rows,cols]=size(y);
 r=randperm(cols);
A=y(:,r(1:codebook_size));
A=A./repmat(sqrt(sum(A.^2,1)),rows,1);
D=A;
X=y;
K = 50;

for it = 1:noIt
    W=OMP(D,X,4.0/5*rows);
   % As finding the truly optimal X is impossible, we use an approximation pursuit method.
    R = X - D*W;
    %这里包含的应该是误差。  如果是真的，还是应该差不多，如果不是真的，下一次应该包含些。
    %%  这里采用分向量估计的方法.
    for k=1:K
        I = find(W(k,:));
        Ri = R(:,I) + D(:,k)*W(k,I);  % 构成一个虚的向量。
        [U,S,V] = svds(Ri,1,'L');
        %重新更新D和W.
        % U is normalized
        D(:,k) = U;
        W(k,I) = S*V';
        R(:,I) = Ri - D(:,k)*W(k,I);
    end
end

假设他对的，然后更新每一个原子D。因为D，W是相互依赖的，在后续更新中，要同时更新。

算法总结:

  1. 和k-means比较近似，首先假设随机矩阵D,估计x，然后由x又开始估计D。
  2. 首先估计稀疏表示，然后估计字典，在字典估计的时候，采用每次只估计一个Dj，其他不变，交替迭代的方法。

算法存在的可改进空间：

  1. 这里使用的原图像，如果y使用特征，应该能够减少计算量，能获得更好的结果。

算法缺点：

  1. 这个算法无法得到全局最优点，只能得到局部最优点。但是实际操作中，这个效果还不错。
  2. 这个KSVD用在哪那？我想可以用在识别上。把所有每一副图像都拉成向量，但是这里是基于图像任意排列的情况，只是一些抽象的结果，没有实质性意义，比如无法得到人脑识别到的轮廓信息。这些是算法本身的一些缺点，我想怎样也无法克服。

参考：

  1. http://en.wikipedia.org/wiki/K-SVD
  2. 浅谈K-SVD http://www.cnblogs.com/salan668/p/3555871.html
  3. K-SVD: An Algorithm for Designing Overcomplete Dictionaries for Sparse Representation

第十三集 factor analysis

这里使用z表示为x的降秩， .. math:: x=/mu + Lambda z + epsilon

然后用`EM算法 <EMAlgorithm>`_ 实现：

E-step 中 估计 z的概率中的p(z|x) .. math:: mu_i,Sigma_i

M-step 中估计 .. math:: mu, Lambda , epsilon

第十四集第十五集PCA 算法 ICA算法

把数据从高维压缩到低维

马尔科夫链过程：

马尔科夫链是对复杂世界关系的模型的一种近似简化。

其难点在于模型的估计。查看<<数学之美>>关于马尔科夫链部分。

\[R({s_0},{a_0}) + \gamma R({s_1},{a_1}) + \gamma R({s_2},{a_2}) + ...\]

Bellman equation:

\[V_\pi (s)=R(s)+\gamma \sum_{s-^\prime\in S} P_{s\pi}(s^\prime)V^\pi (s^\prime)\]

后面的还不是 很懂

多层神经网络MLP

MLP模型： .. math:: f(x) = G( b^{(2)} + W^{(2)}( s( b^{(1)} + W^{(1)} x))),

第一层activation 一般是sigmod和tanh， 第二层activation一般选择softmax，输出多个离散值。

W和b是分别是两层的参数。 多个参数W是怎么调节的？

粒子群算法

第一个就是粒子本身所找到的最好解，叫 做个体极值点(用i pbest 表示其位置)。另一个极值点是整个种群目前找到的最好 解，称为全局极值点(用i gbest 表示其位置) PSO算法首先初始化一群随机粒子，在每次迭代中，粒子通过跟踪两个极值来跟踪自己。 假设问题的搜索空间是D维空间上的一个超立方体，用S表示，且 \(S=a_1,b_1\times ....\times a_D, b_D\) ，在每一次迭代找到这两 个最好解后，粒子i x 根据如下式子来更新自己的速度和位置：

\[v_{i,j}^{(k+1)} =v_{i,j}^{(k)}+ c_1+r_1(pbest_{i,j}^{(k)}-x_{i,j}^{(k)})+c_2+r_2(pbest_{j}^{(k)}-x_{i,j}^{(k)})\]
\[x_{i,j}^{(k+1)}=x_{i,j}^{(k+1)}+v_{i,j}^{(k+1)}\]

式中， \(pbest_i\) 为粒子i 经过的最好的位置(自身经验)， gbest 表示的是群体中所 有粒子经过的最好位置(群体经验)； \(c_1 、c_2\) 为正常数，称为学习因子。 \(r_1 、r_2\) 为 [0，1]区间的随机数。当粒子在某一维度上飞出问题的搜索范围时，令它在这 一维度上等于搜索区间的上界或者下界。 所有粒子都由被优化函数f (x) 评价其适应度值，对于求解 min f (x) 问题， 个体极值点 \(pbest_i\) 根据 :math: f(pbest_i) 的大小按照下述规则更新：

全局极值点gbest 取所有个体极值点中的最好点进行更新。

\[\begin{split}pbest_{i}^{\left( k+1 \right)}=\left\{ \begin{align} & x_{i}^{\left( k+1 \right)} \text{if} \text{f}\left( x_{i}^{\left( k+1 \right)} \right)<f\left( pbest_{i}^{\left( k \right)} \right) \\ & pbest_{i}^{\left( k \right)} otherwise \\ \end{align} \right.\]\end{split}\]

DPSO，对速度和位置使用0，1 构成，全部规整， 这适合于什么场合那？

http://blog.csdn.net/ztf312/article/details/76974571?locationnum=3&fps=1

遗传算法

http://blog.csdn.net/b2b160/article/details/4680853

求解入校二元函数的 最大值

\[max f(x_1,x_2) = x_1^2+x_2^2 s.t. x_1 \in {1,2,3,4,5,6,7} x_2 \in {1,2,3,4,5,6,7\]

（1）首先对个体编码

遗传算法的运算对象是表示个体的字符串，所以必须把变量 \(x_1, x_2\) 编码为符号串，本题中，用无符号二进制正数来表示。

因为 \(x_1, x_2\) 是0~7之间的整数，所以分别用3位无符号二进制整数来表示，将他们连接在一起所组成的6位无符号二进制数就形成了个体的基因型，表示一个可解行

例如，基因型 X 基因型 X＝101110 所对应的表现型是：x＝[ 5，6 ]。

个体的表现型x和基因型X之间可以通过编码和解码程序转换。 （为什么要用编码方式？）

（2）初始群体的产生

遗传算法是对群体进行的进化操作，需要给其准备一些表示起始搜索点的初始群体数据。

本例中，群体规模的大小取为4，即群体由4个个体组成，每个个体可以通过随机方法产生。

如：011101，101011，011100，111001
  1. 适应度计算

遗传算法中以个体适应度的大小来评定各个个体的优劣程度，从而决定其遗传机会的大小。

本例中，目标函数总是取非负值，并且是以求函数最大值为优化目标，故可直接李欧阳目标函数作为个体的适应度。

（4）选择运算

选择运算（或称为复制运算） 是把当前群体职工适应度较高的个体按照某种规则或者模型异常到一代群体中去。一般要求适应度较高的个体将有更多的机会遗传到下一代中。

本例中，我们采用与适应度成正比的概率来确定各个个体复制到下一代群体中的数量。

  • 先计算出群体中所有个体的适应度的总和
  • 其次计算出每个个体的相对适应度的大小 fi/delta fi, 即为每个个体被遗传到下一代群体中的概率，
  • 每个概率组成一个区域，全部概率值之和为1；
  • 最后在产生一个0~1的随机数，依据该随机数出现在上述哪个改了区域来确定各个个体被选中的次数。（不太理解）
  1. 交叉运算

交叉运算是遗传算法中产生新个体的主要操作过程，它以某种概率相互交某两个个体之间的部分染色体。 本例采用单点交叉的方法，其具体操作过程是：

  • 先对群体进行随机配对
  • 其次随机设置交叉点位置。
  • 最后在相互交换配对染色体之间的部分基因。
  1. 变异运算

变异运算是对个体的某一个或者某一些基因座的的基因值按某以较小的概率进行改变，他也产生新个体的一种操作方法。

本例中，我们采用基本位变异的方法来进行变异运算，其具体操作过程如下:

  • 首先确定各个个体的基因变异位置，下表所示为随机产生的变异点位置，其中的数字表示变异点设置在该基因座处；
  • 然后依照某一概率将变异点的原有基因值取反。
从上表中可以看出，群体经过一代进化之后，其适应度的最大值、平均值都得
到了明显的改进。事实上，这里已经找到了最佳个体“111111”。
差分进化算法DE

http://blog.csdn.net/hehainan_86/article/details/38685231

差分进化算法DE与遗传算法GA类似，下面是差分进化算法的步骤:

  1. 初始化

对于优化问题;

\[min f(x_1,x_2,...x_D) s.t. x_j^L < x_j <x_j^U, j=1,2,..,D\]

其中，D是解空间的维度，\(x_j^L, x_j^U\) 分别表示第j个分量 x_j 取值范围的上界和下界，DE算法流程如下。

  1. 初始化种群。 初始种群 :maht:`\{x_i(0)|x_{j,i}^L<x_{j,i}(0)<x_{j,i}^U, i=1,2,...,NP; j=1,2,...,D\}` 随机产生： x_{j,i}(0)= x_{j,i}^L +rand(0,1)x_{j,i}^U-x_{j,i}^L)
其中 \(x_i(0)\) 表示第0代的第i 条“染色体”（或个体）,:math:x_{j,i}(0) 表示第0代的第i条“染色体”的第j各“基因”，NP表示种群大小，rand(0,1) 表示在（0,1）区间均匀分布的随机数。
进化算法、遗传算法与粒子群算法之间的比较

http://blog.csdn.net/hehainan_86/article/details/38398031

遗传算法、粒子群算法，差分进化算法 这些算法都属于进化算法的分支，DE算法性能获得最优，而且算法比较稳定，反复都能收敛到同一个解，PSO算法收敛速度次之，但是算法不稳定, 最终收敛结果容易受参数大小和初始种群的影响，EA算法收敛速度较慢，但在处理噪声方面，EA能够很多的解决而DE算法很难处理这种噪声问题。DE算法收敛速度比较慢

协同学理论

协同学： 指的是在一个处于远离平衡态时，系统内部各个子系统会通过非线性的相互作用产生协同，在系统内部各个作用的作用下，系统会达到临界态，从而使得系统通过自组织方式转变为有序，使旧系统发展成为诸多方面都发生质的新系统，导致新的空间结构，时间结构或功能结构的形成。系统从无序转变为有序的关键是系统内的各个子系统的非线性相互作用。协同学研究焦点是复杂系统宏观特征的质变。这种“由旧结构，到处于不稳定状态，到形成 新结构”的系统演变过程揭示了事物普遍的变化规律。

协同学认为, 系统演化的过程可以用方程来表示，其一般方程为：

\[q(x,t)=N[q(x,t),\delta,\alpha,x] +F(t)\]

其中，N(.) 是个函数向量，其参数包含状态向量q、微分算子 :maht:`\delta`, 控制参数 \(\alpha\) 、空间向量x与时间向量t; 最后一项F(t) 表示系统的作用力，该作用力可能来自外界， 也可能是系统内部各子系统之间的相互作用力，在某些情况下该作用力可以忽略， 不影响系统的演变过程，而在某些情况下它对系统的演变起着决定性作用。显然， 式（2-1）是一个关于q 及其不同阶导数的动力学方程或方程组，即微分方程。

时序数据分析

ARMA模型

基本原理:

将预测指标随时间推移而形成的数据序列看做是随机序列，这组随机序列所具有的依存关系体现着原始数据在时间的延续性，一方面，影响因素的影响，假定影响因素为 \(x_1,...,x_k\) ，由回归分析

\[Y_t =\btea_1x_1+\btea_2x_2+...+\btea_px_p+Z\]

其中Y是预测对象的观测值，Z为误差，作为预测对象 \(Y_t\) 收到自身变化的影响，其规律可又下式体现:

\[Y_t =\beta_0+\btea_1Y_{t-1}+\btea_2Y_{t-2}+...+\btea_pY_{t-p}+Z_t\]

误差项在不同时期存在依存关系，表示为:

\[Z_t =\xi_t+\alpha_1\xi_{t-1}+\alpha_2\xi_{t-2}+...+\alpha_q\xi_{t-q}\]

这个说明噪声也是跟时序有关。

由此，获得ARMA模型表示:

\[Y_t =\beta_0+\btea_1Y_{t-1}+\btea_2Y_{t-2}+...+\btea_pY_{t-p}+\xi_t+\alpha_1\xi_{t-1}+\alpha_2\xi_{t-2}+...+\alpha_q\xi_{t-q}\]

如果时间序列Yt 满足：

\[Y_t =\beta_0+\btea_1Y_{t-1}+\btea_2Y_{t-2}+...+\btea_pY_{t-p}+\xi_t\]

其中:math:xi_t 是独立同分布的随机变量序列，满足：

\[Var_{\xi_t}=\delta_{\xi}^2>0\]

以及 \(E(\xi_t)=0\)

则称时间序列Yt服从p阶的自回归模型.

移动平均模型(Moving-Average MA)

如果时间徐磊Yt满足:

\[Y_t =\xi_t+\alpha_1\xi_{t-1}+\alpha_2\xi_{t-2}+...+\alpha_q\xi_{t-q}\]

则称时间序列Yt服从q阶移动平均模型

移动平均模型平稳条件:任何条件下都平稳。

自回归滑动平均模型（ARMA）

如果时间序列 Yt 满足：

\[Y_t =\beta_0+\btea_1Y_{t-1}+\btea_2Y_{t-2}+...+\btea_pY_{t-p}+\xi_t+\alpha_1\xi_{t-1}+\alpha_2\xi_{t-2}+...+\alpha_q\xi_{t-q}\]

则称时间序列Yt为服从(p,q)阶自回归滑动平均混合模型。或者记为 \(\phi(B) y_t = \theta(B)\xi_t\) .

时间序列混沌性的 嵌入维度和 李雅普诺夫指数，是什么？

怎样提高时间序列的局部波动？

Information Theoretic Learning

Renyi’s quadratic entropy 表示为:

\[H_2(X) = -log(\int_{-\inf}^{\inf} f_X^2(x)dx)\]

其中 \(f_X(\dot)\) 是 X的概率密度函数。

信道函数表示为:

\[\hat H_2(X) =-log(\frac{1}{T^2}\sum_{j=1}^T\sum_{k=1}^T G_{2\delta_{ker}^2}(x_j-x_k))\]

这样就是一个误差。 这里使用非线性核。因此被称为信息潜在。

A second important ITL measure is correntropy [19]. It is a similarity metric which “generalizes” correlation, containing second and higher-order moments which are expressed by the kernel used in its definition. If a Gaussian kernel is chosen, the correntropy between two random variables X and Y is defined by

\[\begin{split}c(X,Y) = E\{G_{\delta_{ker}^2}(X-Y)\} \\ = \int_{-\inf}^{\inf}\int_{-\inf}^{\inf} G_{\delta_{ker}^2}(x-y)f_{X,Y}(x,y)dxdy = \int_{-\inf}^{\inf} G_{\delta_{ker}^2}(e)f_E(E=e)de\end{split}\]

这个用来衡量信号的互相关

\[\begin{split}c(E) = \\int_{-\inf}^{\inf} G_{\delta_{ker}^2}(e)f_E(E=e)de\end{split}\]

二阶标准最大负熵定义为:

\[max c(E) s.t. e(n) = d(n) - f(r(n),w)\]

The principle of MCC is that the maximization of correntropy increases the similarity between the desired signal and the adaptive system output, i.e., the error values become smaller, which correspond JOURNAL OF COMMUNICATIONS AND INFORMATION SYSTEMS, VOL. 31, NO. 1, 2016. 4 to higher values of the Gaussian kernel, finally leading to an error PDF more concentrated at the origin to higher values of the Gaussian kernel, finally leading to an error PDF more concentrated at the origin.

这里使用一个相关熵，相当于

https://books.google.com/books?id=yqhPCwAAQBAJ&dq=%22A%20kernel%20based%20method%20uses%20a%20kernel%20function%20which%20is%20a%20similarity%20function%22&pg=PA165&v=onepage&source=ttb#v=onepage&q=%22A%20kernel%20based%20method%20uses%20a%20kernel%20function%20which%20is%20a%20similarity%20function%22&f=false

DTW
\[\begin{split}A = \left[ {\begin{array}{{20}{c}} {d\left( {{t_1},{r_1}} \right)}&{d\left( {{t_1},{r_2}} \right)}&{...}&{d\left( {{t_1},{r_n}} \right)}\\ {d\left( {{t_2},{r_1}} \right)}&{d\left( {{t_2},{r_2}} \right)}&{....}&{d\left( {{t_2},{r_n}} \right)}\\ \vdots & \vdots & \ddots & \vdots \\ {d\left( {{t_m},{r_1}} \right)}&{d\left( {{t_m},{r_2}} \right)}& \cdots &{d\left( {{t_m},{r_n}} \right)} \end{array}} \right]\end{split}\]

这里是一个矩阵，说明其

计算所有相似位置总和的位置最小

两个时序时序数据的关联性:

\[DTW(x,y) = min_W\{ \sum_{k=1}^K W_k\}\]

实际中使用累积距离矩阵

实际计算距离使用遍历方法找到D

http://blog.csdn.net/zouxy09/article/details/9140207

R/S 分析

用来找到时间序列的周期。

  1. 给定时间序列， \(X:(x_1,x_2,..,x_n)\)，\(x_i , i=1,...,n\)
  2. 计算序列的均值:math:x_m 和方差 \(s_n\),
  3. 然后计算这个时间序列的新值:
\[z_i = x_i -x_m\]
  1. 获得序列的累积序列:
\[y_r = \sum_{i=1}^r z_i.\]
  1. 计算y的范围:
\[R_n = max(y_1,y_2,...,y_n)- min(y_1,y_2,...,y_n)\]
  1. 除以 方差：
\[(R/S)_n=frac{R_n}{s_n}\]

Hurst 指数 是一个H值：

\[(R/S)_n=cn^H\]

判断时间序列是随机游走还是有偏的随机游走过程。

https://yq.aliyun.com/articles/50420 自适应共振理论ART模型 ———————

通过上面的分析发现，首先是

-+trace in machine learning

-+`交叉验证 <crossValidation>`_

交叉验证 根据总数据的多少，不同的数据大小,选择不同的验证方法。

d4c3b2a1

检查自变量和因变量的关系
  1. 首先检验哪些变量能够剔除，包括因子分析方法，通过因子分析方法
  2. 怎样检验变量对于自变量是否足够？ DW检验 和DH检验

D-W 检验作用

对于期望和预测之间做残差，发现残差是否还有可以提取的信息，如果有继续找相关的自变量，如果没有说明模型能有效。

  1. 机器学习公开课汇总
  2. 深度学习资料 视频
  3. 公开课可下载资源汇总
  4. 机器学习斯坦福资料
  5. 科学美国人 中文版
  6. 大数据时代的机器学习热点——国际机器学习大会ICML2013参会感想
  7. 图片库 做测试用
  8. 深度学习资料1
  9. 图片库 测试用
  10. Deep learning 进阶分析
  11. 深度学习lecture
  12. 深度学习向导
  13. deep-learning-made-easy fastml
  14. deeplearning software list
  15. machine-learning-in-ocaml-or-haskell
  16. 人工智能的新曙光 人工智能概率论介绍

大脑思考 数学模型

pydot 有下载的必要吗？

http://songshuhui.net/archives/76501>`_ 正态分布的前世今生 <非常精彩的分析了正态分布，以及二项分布，以及极大似然=平均值，以及最小二乘的关系。

Baum-Welch Algorithm 维特比算法 有空看下

分析下航空订票的原理：航空公司如何给飞机票定价？

logit 模型还不是很清楚

在svn中整体修改，多个不同位置的不同文件件

probabilistic Latent Semantic Analysis 什么

交替方法一定收敛吗?

+`高斯过程 <GaussianProcess>`_

+`条件随机场 <ConditionalRandomFields>`_

+`决策树 <DecisionTree>`_

+`张量分解 <TensorDecomposition>`_

分类器

KNN( Nearest Neighbor)

该方法的思路是： 假设一个样本在特征空间的K个最相似的样本中的大多数属于某一类别，

http://www.cnblogs.com/blfshiye/p/4573426.html

串匹配

退火算法

退火算法设计的本初：改进非凸问题中`爬山算法 <http://www.cnblogs.com/heaad/archive/2010/12/20/1911614.html>`_ 中的局部最小点。

方法：模拟自然中退火的方法，通过随机交换，求出任意两个点之间的传输距离。我想和便利算法有什么区别？ 还有什么缺点？并用`内循环终止准则，或称Metropolis抽样稳定准则（Metropolis 抽 样准则） <http://www.google.com.hk/url?sa=t&rct=j&q=+Metropolis+%E6%8A%BD+%E6%A0%B7%E5%87%86%E5%88%99&source=web&cd=4&ved=0CD8QFjAD&url=http%3a%2f%2fjingpin%2eszu%2eedu%2ecn%2fyunchouxue%2fziliao%2fkejian%2f%25E7%25AC%25AC10%25E7%25AB%25A0-%25E6%2599%25BA%25E8%2583%25BD%25E4%25BC%2598%25E5%258C%2596%2eppt&ei=JyHEUYOcMY_ZkgWPq4GYAw&usg=AFQjCNG1kEOdSgfjKesiOxiDiT8E4u4ZBQ>`_ 蒙特卡洛实验来是系统达到平稳。

解决问题： 货郎担问题 ，每次只能选择一个地方，也就是交换一个地方。遍历算法在这个问题中式难以解决的。 matlab 代码 。

优缺点： #. 优点：计算过程简单，通用，鲁棒性强，适用于并行处理，可用于求解复杂的非线性优化问题。 #. 缺点：运算量较大，下降速度和收敛稳定性的矛盾，下降速度过大，可能出现震荡。下降速度过慢，运算量大。

退火算法的改进 比如采用变化的熟练速度和刚开始收敛速度比较快，基本稳定后采用小收敛速度。

  • 思考：和图论中*最短路径算法* 剪枝算法* 最小逆序数*。

K-means 算法=expection maximum （EM）期望最大

就是一个分类器的设计 #. 深入浅出K-Means算法 K means 中K的选择，初始值的选择，里面都有。

Clustering by fast search and find of density peaks

这是2014年 science 文章

这里有两个基本的标准

这里的pho 是 局部密度，满足:

dc 是截断距离，pho基本上等于与点i的距离小于dc的点的个数。算法只对不同点的:math:pho_i 的相对大小敏感，这意味着对于大数据集，分解结果对于 dc的选择具有良好的的鲁棒性。

数据点i 的 \(\delta_i\) 是点到任何比密度大的点的距离的最小值:

对于密度大的点，我们可以得到 \(\delta_i =\max_j(d_{ij})\) .

http://blog.csdn.net/jdplus/article/details/40351541

作者主页 http://people.sissa.it/~laio/Research/Res_clustering.php

局部二次方法

假设:math:T(lambda) 是解析矩阵函数，\(\lambda_k\) 是非线性特征值问题的一个近似特征值，由Taylor公式可得:

\[T(\lambda_k + h) = T(\lambda_k ) +h T'(\lambda_k ) +\frac{1}{2}h^2T''(\lambda_k ) +\frac{1}{6}h^3 R(\lambda_k,h)\]

其中 \(R_3(\lambda_k,h)\) 是一个矩阵，是范数有界的。相应于主次线性近似，我们使用如下二次特征问题:

\[(T(\lambda_k ) +h T'(\lambda_k ) +\frac{1}{2}h^2T''(\lambda_k ))x=0\]

近似非线性特征问题（1.1）如果h是二次特征问题（2.2）模最小的特征值，则 \(\lmabda_{k+1} = \lmabda_{k} +h\) 可作为非线性特征问题的新近似特征值。

Lorenz
\[\frac{dx}{dt} = a(-x+y), frac{dy}{dt}= bx-y -xz, dz/dt=xy-cz\]

其中参数选取 a=10, b=28, c =8/3 时，系统具有混沌特性。

embeding dimension 是什么

是时延， tau是延迟参数

\[[x(t),x(t+\tau),...,x(t+m\tau)]\]

是用embeding 来估计的 他的相位空间，

See also

布朗运动， 一维延拓

布朗运动对应是什么？ 可以用在哪？

粒子群算法，反射回来。

延拓的租用？

\[\int_0^\inf 1_D(X_s)dL_s =0\]
\[v(x)=n(x)+tahn\theta(x)t(x)\]
\[dX_t=dB_t + V(x)dL\]

什么是调和函数

斜反射布朗运动：可以用在哪？

可以用在PSO中 。。

未来的发展都是基于网络的分散式样的发展，这样的

在听讲座的时候，听不懂怎么办？

CDN是什么？

umind 现在还不成熟，应该怎么办？

自己做实验，测试。

现在因为高纬度的问题，目前还没有解决。

勒贝格测度，大数定理

布朗运动和概率密度函数

异常检测

异常时在数据集中与众不同的数据，使人怀疑这些数据并非随机偏差， 而产生完全不同的机制，聚类算法对于异常的定义：异常既不属于聚类也不属于噪声。主要方法是包括：基于统计的方法，基于距离的方法，和基于偏差的方法。基于密度的方法。

基于统计的方法

Knorr 提出基于距离的异常检测方法，数据集S中一个对象与O的距离大于距离D，简单地说，基于距离的异常点就是那些没有足够多的邻居的点的对象，采用DB(p,D)-outlier 可以表示所有的基于统计的异常。

基于偏差的方法

提出一种“序列异常”的概念，算法介绍给定n个对象的集合S,建立一个子集序列{S1,S2,…,Sm} 这里

高斯马尔科夫模型

速度可以描述为如下:

\[v_n = cv_{n-1}= v_0 c^n\]

所以高斯马尔科夫测量的总开销为：

\[c_{MALM} = Kv_n =K v_0 c^n\]

这里的K是什么？

在GMLM中，高斯马尔科夫模型中节点速度描述如下:

\[v_n = \alphav_{n-1} +(1-\alpha)\mu +\sigma\sqrt{1-\alpha^2}w_{n-1}\]

其中 mu 和 sigma 是 v_n 的期望和方差，

就算我现在有很多想法，但是还是其实都没有实现，我觉得还是

用来描述速度的一个变化 参考: 一种高斯-马尔科夫模型下的车辆位置管理策略

参考: http://jiangshuxia.9.blog.163.com/blog/static/3487586020083662621887/

  1. 基于生物进化的遗传算法概述 这里面有遗传算法在各领域的应用
  2. ` De Jong's function 1 <http://www.geatbx.com/docu/fcnindex-01.html>`_ 这个函数有多个局部最优点，一般用来作为算法局部最小点的例子
  3. 退火算法
  4. ` <http://blog.sciencenet.cn/blog-1225851-761882.html>`_
  5. 大数据时代的机器学习热点——国际机器学习大会ICML2013参会感想 看不太懂，有空看看
  6. 最大似然参数估计

Thinking

模式 描绘子的组合。

– Main.GangweiLi - 24 Sep 2013

基于决策理论，基于神经网络，基于机器学习。

– Main.GangweiLi - 24 Sep 2013

西安电子科技大学陈渤 我电子所的，主要做大数据分析和机器学习 和图像识别。

– Main.GegeZhang - 04 Jun 2014

高新波 他做的方向比较新，可以看一下。

– Main.GegeZhang - 04 Jun 2014

机器学习算法汇总：人工神经网络、深度学习及其它，http://www.csdn.net/article/2014-06-27/2820429

学习方式，有监督，半监督，无监督。强化学习。

元胞机

元胞网络将更擅长于解决现实世界中具有不稳定、非线性、不确定性、非结构化以及病 态结构的复杂决策问题

L0 范数、L1范数和ridge 回归

ridge 能够实现最小化，但是不能产生稀疏值，也就是不区分稀疏值，但是实际中通常需要稀疏值，因此使用L1范数（Lasso 回归），但是L1相关的变量不起作用，因此有人提出使用L1范数和L2范数结合，即所谓的弹性网，但是弹性网还是有偏估计，因此使用SCAD和L2 范数，L2 起到合并组效应，SCAD满足稀疏估计。

递进过程也就是： ridge-》L1-> 弹性网-》弹性 SCAD

因此还需要使用SCAD正则化，

李雅普诺夫指数

http://baike.baidu.com/link?url=vFl3c6SKfWdon5BCGxiOFsgIqiz8WyIlj5gKQdM1Gi9gYmjxHpN9QKK7hcEgvGKkkd1wvbK0v5OYziea0v6SWyPsHVq90zT9Cc3bcSzLBOQnr9y0mG4ohD0Malmtc-mzX36X9AL3oTQ-yC-RJX3ojoFLe66fKgnJne8cKMHrdkq

考虑两个系统：

\[x_{n+1}= f(x_n), y_{n+1}=f(y_n)\]

设其初始值微小误差为：

\[|x_0-y_0|\]

经过一次迭代有：

\[|x_1-y_1|= |f(x_0)-f(y_0)|= \frac{|f(x_0)-f(y_0))|}{|x_0-y_0|}\aprox \frac{df}{dx}|x_0-y_0|\]

第二次迭代得到：

\[|x_n-y_n|= |\sum_{n=0}^{n=1}\frac{df}{dx}||x_0-y_0|\]

可见两个系统对初始扰动的敏感度由导数|df/dx|在x0处的值有关，它与初始值有关。

说明两个原来差值的很小，后来差别比较大，说明初始值对他有影响，也就是混沌现象。

如果两个系统初始存在细小的差异，随着时间产生分歧，分离程度用李雅普诺夫指数来度量

Volterra series

https://en.wikipedia.org/wiki/Volterra_series

假设非线性离散动力系统的输入为 \(X(n)=[x(n),x(n-\tau),...,x(n-(m-1)\tau)]\) , 输出 \(y(n)= x(n+1)\), 则非线性系统的 Volterra 展开式表示为：

\[x(n+1) =h_0 +\sum_{k=1}^P y_k(n)\]

其中

\[y_n(n) = \sum_{i_1,...,i_k=0}^{m-1} h_k(i_1,...,i_k) \prod_{j=1}^k x(n-i_j\tau)\]

这里的 \(h_k(i_1,...,i_k)\) 称为 k阶段 Volterra 核，p 为 Volterra 滤波器阶数。在实际应用中，必须采用有限次求和的形式。以二阶截断m次求和为例，用于混沌时间序列预测的滤波器为：

\[x(n+1) =h_0 +\sum_{i_1=0}^{m-1} h(i_1)x(n-i_1\tau) + \sum_{i_1,i_2=0}^{m-1} h(i_1,i_2)x(n-i_1\tau)x(n-i_2\tau)\]

这说明这个信号是有时延和历史核组成，这样有什么意义。

可用于非线性时间序列预测。但是这个只是一个模型，应该怎样求解，才是关键。

摘自：

混沌时间序列的Volterra级数多步预测研究

拓扑学

拓扑学解决什么问题？

结合基于

七桥问题: 解决路径问题

四色定理

庞加莱猜想

相关学科：

图论和几何拓扑

笛氏积

解决空间多维扩展

笛氏积：包含空间中的方向

拓扑定义：

拓扑就是在拉伸、旋转中相邻的关系还是不变的

官方： 研究图形在拓扑变换下不变性质的学科。

拓扑学经常被描述成 “橡皮泥的几何”，就是说它研究物体在连续变形下不变的性质。

盘带哪些物体是本质同一形态的？

莫比乌斯带

无法区分一个面无法区分它是正面还是反面？ 这个和拓扑有什么关系？

从扭结问题，谈到临近点的关系。

它是一种几何，但是，

扭结理论：

说明物体实际上以某种形态扭结在一起, 这和弦论有什么关系？

http://blog.sciencenet.cn/home.php?mod=space&uid=522561&do=blog&id=417414

这里的爬虫的几何很难理解。

拓扑和积分有什么关系？

http://songshuhui.net/archives/1633

拓扑空间

开集是什么？

同一集合上的不同度量可能导致相同的开集。

这说明是相同的

“同调群” 与 “基本群” 是什么？

“微分拓扑学 什么？

（同调群，同伦群

拓扑学和图论什么关系

拓扑学研究的是 在拓扑变换下的不变理论。

图论主要研究顶点， 边

紧空间
连通性

基本群和覆盖空间

单纯同调性

A small-world network is a type of mathematical graph in which most nodes are not neighbors of one another, but the neighbors of any given node are likely to be neighbors of each other and most nodes can be reached from every other node by a small number of hops or steps

https://en.wikipedia.org/wiki/Small-world_network

小世界网络： 指的是和临近的关系不近，但是可以通过几步跳称为两一个节点的邻居。

https://en.wikipedia.org/wiki/Scale-free_network

A scale-free network is a network whose degree distribution follows a power law, at least asymptotically. That is, the fraction P(k) of nodes in the network having k connections to other nodes goes for large values of k as:

\[p(k) \prox k^{-\gamma}\]

节点度服从度指数介于（2,3）的幂律分布

混沌：初始值影响很严重，分形

耗散理论 和非线性关系

http://baike.baidu.com/link?url=d9hUNIax8Z1NnBOxHlHENTxO5lztOndRiJ7rLedYIkwBdbU2mJW9B63kkKeAxi1M5hIt58_CJmO1V56d3VsOWcEdtafXb_mMTXIQWwx620B-Vj4d2cPNi9RT70v1k7Wn

耗散理论呈现出非线性

耗散结构的研究揭示了一种重要的自然现象，并对复杂系统的研究提出了新的方向。在数学上描述复杂系统的方程通常是非线性的，一般包括分岔现象。

正的Lyapunov指数表明该度量邻近的点之间发散的快慢，负的Lyapunov指数表明系统在受到扰动后多长时间能回复到初始状态。如果系统中最大的Lyapunov指数为正数，则表明系统是混沌的，

基于混沌理论的短时交通流量预测

这是不是说明贫苦家人的孩子不能嫁。

时间序列预处理

不平稳数据分析

BOX-COX 变换

差分

对于有趋势性的数据，采用差分

\[\delta X_t = X_t -X_{t-1}\]
季节差分

对于周期性时间序列采用季节差分

\[Y_t= Z_t- Z_{t-12}\]

对数变换和

https://wenku.baidu.com/view/4d375381ec3a87c24028c43a.html

多变量时间序列预处理

The purpose of presample data is to provide initial values for lagged variables. When trying to fit a model to the estimation data, you need to access earlier times. For example, if the maximum lag in a model is 4, and if the earliest time in the estimation data is 50, then the model needs to access data at time 46 when fitting the observations at time 50. By default, estimate removes the required amount of observations from the response data to use as presample data. This reduces the effective sample size. z 怎样设置 重采样时间。

偏最小二乘

解决多变量预测中x变量存在的共线性问题。

https://wenku.baidu.com/view/fc2291a9d1f34693daef3eca.html

做下变量分析，包含更多的。

数电、模电、包括更多的信息。

技术的方面，我想还是。 方便更多的信息。方便的处理。 · 招学生，现在学生比较多的爱上课。

CSDN 中 的学生偏微分。

做大数据的

tensorflow

http://www.tensorfly.cn/

基于检测的分类

利用分类对目标进行检测，

机器学习的基石是 分类和预测。

one-hot 编码是什么

如果所有的数据概率*10 要么概率非常接近1，要么为0.

softmax的作用是将数据转换成概率，然后再通过吧one-hot编码，把数据转换成分类。

并且通过交叉熵来看起距离，也就是分类

数据中误差被放大，因此要对数据做均值为0，方差为1的归一化。

kaggle 数据竞赛

随机梯度下降法对于大矩阵计算比较有效，用在深度学习中。

随机梯度 是梯度随机变化一下

权值使用：使用方差较小的权值，防止参数变化很大。

学习率的指数衰减

不平衡数据集分类

欠采样方法

从多数类中随机抽取样本而减少多数类样本的数量，使数据达到平衡。

处理非平衡数据常用的方法就是设置损失函数的权重，是的少数类别错误的损失大于多数类别错误的损失。

：

经济学：

cost-sensitive learning

从贝叶斯敏感的角度来说：

从贝叶斯后验概率角度出发，以实现损失最小为目标，优化目标如下

..math::
H(x)= arg min(sum_{jin {-,+}}P(j|x)C(i,j))

edited nearest neighbor （ENN）

如果他的大部分k临近样本都跟他自身的类别不一样，我们就将他剔除。（什么意思）

http://blog.csdn.net/a358463121/article/details/52304670

tomek link removal

如果有两耳不同类别的样本，他们的临近都是对方，就称为A，B的 Tomek link。

tomek link removal 就是将 组成tomek link的样本删除掉

代价敏感 ：http://www.jianshu.com/p/3e8b9f2764c

我真的到那种挥斥方遒的阶段了吗？

AdaCost算法

比如学习的分类是怎样的，

参考：

http://www.jianshu.com/p/3e8b9f2764c8

http://blog.csdn.net/a358463121/article/details/52304670

怎样添加规则，

比如添加关键字数仿真的长度，比如学习识别的长度，经济搜索的长度，包括时长，

利用生成网络，生成数据，

分为创业型的，科学家

focus 好奇心，对其进行分类，

还有一个应该是五个点。

过采样方法：

一个简单的方法，就是通过有放回的抽样，不断地从少数类抽取样本，不过这样很容易导致过拟合。

http://blog.csdn.net/heyongluoyao8/article/details/49408131

Smote 用来平衡算法

是属于过采样的方法

smote 是 合成新的少数样本，策略是每个少数类样本a，从它的最近邻随机选一个样本b。

考虑少数类的一个样板i，其特征向量为$x_i, iin {1,…,T}$;

1、从少数类的全部T个样本找到样本 $x_i$ 的k个近邻 x_i(near),near in{1…,k} 2、然后从k个近邻中随机选择一个样本x_i(nn),生成一个0-1之间的随机数：

\[x_{i1}= x_i+\sing_i\dot(x_{i(nn)}-x_i)\]

将步骤2 重复N次，从而合成N个新样本: x_{inew}, newin 1,…,N.

对全部的T个少数类样本进行上述操作，即可为少数类合成NT个新样本。

伯努利方程

宁可错杀一千，不可放过一个。是个概率，可以通过实现。

竞争模型

今天这个模型：竞争合作模型。

增强学习

优达学城 增强学习

学习生物的一种变化的状态，比如加入更多的思考。基于上一步的操作。时间变化。

比马尔科夫链考虑更多的问题。

马尔科夫链 加入更多：

时间序列分析：应该也可以用。

标注:数据是否需要标注，进行分

增强学习 为什么要使用每个状态。

大家都在做机器学习，我有什么特殊的？

为什么是博弈的状态？

这里我们成为物理学

markov 是什么？

下一个状态总是有概率的，转换为概率。

markov 可以记住过去吗

物理规则是不变的。

MDP ，markov decision propress

定义问题：

增强学习的概念

博弈论

http://open.163.com/movie/2016/7/A/I/MBR31E8RH_MBR31KRAI.html

最大似然：

怎样定义凸问题？

无穷范数在凸优化中的作用？

对偶问题怎么理解？

C 语言 MATLAB

fuzzy nerual network （ ） 模糊神经网络

拆成分式

\[A=\mu_1 x_1 +\mu_2 x_2+...., \mu_n x_n\]
math:是 grade of membership of x_i

x_i-> [0,1] 是一个membership

\[A=\sum+i\mu_i\]

贝叶斯信息准则（BIC）

\[AIC(p)= log\frac{||Z-X_pW_p||_2^2}{n}+\frac{2p }{n}\]
\[BIC(p)= log\frac{||Z-X_pW_p||_2^2}{n}+p\frac{logn }{n}\]

就是看这两个信息的达到最大

oracle property 就是数据在无限大，情况下，满足真是估计。

权值最小二乘（weighted least squares）WLS
\[WLS function =\sum{w_i}(y_\beta_0-\beta_1x_{1i},....,\beta_px_{pi})^2\]

对于wi就是对于每一个点的权值。

对不同的连接矩阵，

Lyapunov exponents 计算 李雅普诺夫 指数

在时间中的两个点 ||delta x_i(0)|| and |||delta x_i(t)|| 验证i方向的距离：

通过平均增长速度

\[\frac{||\delta x_i(t)||}{|||\delta x_i(0)||}= 2_i^\lambda t\]

or .. math:

\lambda_i = \frac{1}{t}log_2{\frac{||\delta x_i(t)||}{|||\delta x_i(0)||}}

||delta x_i(0)|| and |||delta x_i(t)||

Lorenz中的 三根线都是混沌的？

这里的lambda 怎样找到？

大矩阵分解方法

https://books.google.com/books?id=joO8BAAAQBAJ&dq=”The%20fast%20matrix%20multiplication%20by%20Strassen%20187%201969%20is%20based%20on%20an%20algorithm%20for%20multiplying%202%202%20block%20matrices”&pg=PA137&v=onepage&source=ttb#v=onepage&q=”The%20fast%20matrix%20multiplication%20by%20Strassen%20187%201969%20is%20based%20on%20an%20algorithm%20for%20multiplying%202%202%20block%20matrices”&f=false

这里通过分解成两个矩阵相乘，得到一个小矩阵，

strassen’ algorithm, zhge de

计算放量从 2n^3 到 4n^2.8

但是这个方法存在数值不稳定。

还有MATLAB程序

https://books.google.com/books?id=BIJZTGjTxBgC&dq=”In%20order%20to%20avoid%20B%20X%200%200%20in%20computation%20it%20is%20suggested%20to%20use%20the%20following%20formula%20to%20compute%20the%20inverse%20matrix”&pg=PA41&v=onepage&source=ttb#v=onepage&q&f=false

通过化简，

距离函数，是误差函数，这里首先把Y进行特征值和特征向量分解。

这里在D

https://books.google.com/books?id=6ZBOA-iDviQC&dq=”To%20calculate%20the%20inverse%20of%20a%20square%20matrix%20B%20the%20adjugate%20or%20adjoint%20matrix%20of%20B%20is%20first%20defined”&pg=PA83&v=onepage&source=ttb#v=onepage&q=”To%20calculate%20the%20inverse%20of%20a%20square%20matrix%20B%20the%20adjugate%20or%20adjoint%20matrix%20of%20B%20is%20first%20defined”&f=false

这也是计算逆矩阵的方法。这个方法还比较小。 这个计算逆矩阵的方法，叫做计算量。

https://books.google.com/books?id=jtX5BwAAQBAJ&dq=%22In%20this%20solving%20procedure%20the%20inverse%20problem%20is%20recast%20as%20an%20optimization%20problem%20which%20is%20solved%20by%20using%20a%20conjugate%20gradient%20strategy%20for%20updating%20at%20each%20iteration%20the%20contrast%20source%20and%20the%20contrast%20function%20in%20an%20alternate%20way%22&pg=PA257&v=onepage&source=ttb#v=onepage&q=%22In%20this%20solving%20procedure%20the%20inverse%20problem%20is%20recast%20as%20an%20optimization%20problem%20which%20is%20solved%20by%20using%20a%20conjugate%20gradient%20strategy%20for%20updating%20at%20each%20iteration%20the%20contrast%20source%20and%20the%20contrast%20function%20in%20an%20alternate%20way%22&f=false

这里使用共轭梯度法进行求解。

https://books.google.com/books?id=9kB5jE2IjS4C&dq=”Unweighted%20least%20squares%20ULS%20is%20a%20factor%20extraction%20method%20that%20minimizes%20the%20sum%20of%20the%20squared%20differences%20between%20the%20observed%20and%20reproduced%20correlation%20matrices%20ignoring%20the%20values%20on%20the%20diagonals”&pg=PA113&v=onepage&source=ttb#v=onepage&q=”Unweighted%20least%20squares%20ULS%20is%20a%20factor%20extraction%20method%20that%20minimizes%20the%20sum%20of%20the%20squared%20differences%20between%20the%20observed%20and%20reproduced%20correlation%20matrices%20ignoring%20the%20values%20on%20the%20diagonals”&f=false

从目前的角度来看，很多人在时间序列，并且方法也比较成熟了，应该研究 多

智能交通

矩阵求逆矩阵

为什么要使用共轭梯度法。

这里使用梯度投影法，解决非线性问题。。

https://books.google.com/books?id=_VwICgAAQBAJ&dq=”The%20gradient%20projection%20method%20has%20been%20successfully%20implemented%20and%20has%20been%20found%20to%20be%20effective%20in%20solving%20general%20nonlinear%20programming%20problems”&pg=PA370&v=onepage&source=ttb#v=onepage&q=”The%20gradient%20projection%20method%20has%20been%20successfully%20implemented%20and%20has%20been%20found%20to%20be%20effective%20in%20solving%20general%20nonlinear%20programming%20problems”&f=false

https://books.google.com/books?id=WyvVDAAAQBAJ&dq=%22The%20matrix%20inversion%20operation%20can%20be%20divided%20into%20three%20approaches%20explicit%20computation%20implicit%20computation%20and%20polynomial%20expansion%22&pg=PT399&v=onepage&source=ttb#v=onepage&q=%22The%20matrix%20inversion%20operation%20can%20be%20divided%20into%20three%20approaches%20explicit%20computation%20implicit%20computation%20and%20polynomial%20expansion%22&f=false 对于矩阵逆计算，主要有三种方法， 线性方法， 比如矩阵分解。 还有一种矩阵乘法。

https://books.google.com/books?id=dfa8BAAAQBAJ&dq=”Several%20numerical%20methods%20generally%20available%20in%20numerical%20analysis%20libraries%20are%20available%20for%20such%20computation%20such%20as%20matrix%20inversion%20and%20relaxation%20techniques”&pg=PA14&v=onepage&source=ttb#v=onepage&q=”Several%20numerical%20methods%20generally%20available%20in%20numerical%20analysis%20libraries%20are%20available%20for%20such%20computation%20such%20as%20matrix%20inversion%20and%20relaxation%20techniques”&f=false

这里的 relax 技术是什么？

https://books.google.com/books?id=wcS_DAAAQBAJ&pg=PA310&lpg=PA310&dq=An+iterative+method+for+matrix+inversion+such+as+the+conjugate+gradient+CG+algorithm+is+therefore+preferred&source=bl&ots=Hk7UyyEO5y&sig=QbROuRxJHUVYP62sBv2_kpiv1RM&hl=zh-CN&sa=X&ved=0ahUKEwi1neCmiPHaAhVQ9GMKHZGvAhMQ6AEIJzAA#v=onepage&q=An%20iterative%20method%20for%20matrix%20inversion%20such%20as%20the%20conjugate%20gradient%20CG%20algorithm%20is%20therefore%20preferred&f=false

这里讲的共轭，也许就是 F^H 和

共轭找到算法，

共轭梯度算法是收敛速度慢

The conjugate gradient method takes a combination of the previous direction and the new direction to approach the optimum more directly.

使用 以前的方向和 新的方向

https://books.google.com/books?id=o6aKDQAAQBAJ&dq=”A%20model’s%20prediction%20is%20in%20the%20form%20of%20a%20predictive%20distribution%20which%20is%20an%20estimate%20of%20the%20underlying%20distribution%20that%20resulted%20in%20the%20observed%20data”&pg=PT348&v=onepage&source=ttb#v=onepage&q=”A%20model’s%20prediction%20is%20in%20the%20form%20of%20a%20predictive%20distribution%20which%20is%20an%20estimate%20of%20the%20underlying%20distribution%20that%20resulted%20in%20the%20observed%20data”&f=false

使用 使用 jackknife ，反复测试模型，只留一个观察。

如果

当李雅普诺夫指数是正的时候，数据呈现成 混沌性。 reservoir connections input-driven reservoir

怎样计算 李雅普诺夫指数？

BIC 越大，说明模型对于问题的拟合越好，

这个是不是可以作为创新点。实际中使用梯度。。

h

最后的误差分为两种，系统误差，和随机误差，什么是系统误差， 系统误差是在建模中遇到的，当观察的和计算的 和真实值在一致性的偏差。

https://books.google.com/books?id=o6aKDQAAQBAJ&dq=”A%20model’s%20prediction%20is%20in%20the%20form%20of%20a%20predictive%20distribution%20which%20is%20an%20estimate%20of%20the%20underlying%20distribution%20that%20resulted%20in%20the%20observed%20data”&pg=PT348&v=onepage&source=ttb#v=onepage&q=”A%20model’s%20prediction%20is%20in%20the%20form%20of%20a%20predictive%20distribution%20which%20is%20an%20estimate%20of%20the%20underlying%20distribution%20that%20resulted%20in%20the%20observed%20data”&f=false

Introduction

digraph flow { SV [label= "support vector"] }

SVM python 解释 这个里面那个距离公式是错误的。

硬间隔最大化

支持向量机首先通过最最大化samples间隔得到如下约束函数：

\[\begin{split}min \frac {1}{2}||w||^2 \\ s.t. y_i(w\cdot x_i+b)\geq 1 \qquad \forall x_i\end{split}\]

这是一个`二次规划 <Quadratic Programming>`_ 问题，通过转换为对偶优化问题，可以找到更加有效的方法 。

对上式引入拉格朗日乘子，就可以得到以下拉格朗日函数：

\[L(w,b,\alpha)=\frac {1}{2}w^Tw-\sum_{i=1}^{N}a_i y_i(w\cdot x_i-b)\]

上式分别对w和b进行求导，分别得到：

\[w=\sum_{i=1}^{N}\alpha_i y_i x_i\]
\[\sum_{i=1}^{N} \alpha_i y_i=0\]

然后带入拉格朗日函数得到：

\[\begin{split}max W(\alpha)=\sum_{i=1}^{N}\alpha_i -\frac{1}{2}\sum_{i=1,j=1}^{N}\alpha_i \alpha_j y_i y_j x_i^T x_j \\ suject to \alpha_i \geq 0, \sum_{i=1}^{N}\alpha_i y_i =0\end{split}\]

软间隔最大化

松弛向量于软间隔最大化

当一些变量可以超出理想的边界一点的时候，使用软间隔最大化。在目标函数加入一个惩罚项，惩罚outlier， 得到新的最小化问题：

\[\begin{split}minimize_{w,b,\xi} \frac{1}{2}w^Tw+C\sum_{i=1}{N}\xi_i \\ subject to y_i(w^Tx_i -b)+\xi_i-1\geq 0, 1\leq i \leq N \\ \qquad \qquad \xi \geq N 1\leq i\leq N\end{split}\]

同样转换为对偶问题变为：

\[\begin{split}max \quad W(\alpha)=\sum_{i=1}^{N}\alpha_i -\frac{1}{2}\sum_{i=1,j=1}^{N}\alpha_i \alpha_j y_i y_j x_i^T x_j\\ subject to \quad C\geq \alpha_i \geq 0, \sum_{i=1}{N}\alpha_i y_i =0\end{split}\]

核函数

当即使不考虑outlier因素时，还是非线性曲线，就是需要把数据映射到高维，得到线性超平面，根据著名的cover定理：将复杂的模式分类问题非线性地投射到高维空间将比投射到低维空间更可能是线性可分的。但是转化到高维之后，数据是计算量增加。由考虑到我们在优化时要求是内积，和具体数据无关，因此我们值需要数据转换到高维空间的内积就可以了。核函数就是完成这个任务：

\[K(x_i,x_j)=\phi(x_i)^T\phi(x_j)\]

其中非常实用的径向基RBF函数：

\[K(x,y)=exp(-||x-y||^2/(2\sigma^2))\]

此时约束函数转化为：

\[\begin{split}max W(\alpha)=\sum_{i=1}^{N}\alpha -\frac{1}{2}\sum_{i=1,j=1}^{N}\alpha_i \alpha_j y_i y_j K(x_i, x_j) \\ suject to \quad C\geq \alpha_i \geq 0, \sum_{i=1}^{N}\alpha_i y_i =0\end{split}\]

SVM python

  1. CUDA SVM

logistic map

  1. Logistic混沌映射 系统状态与初始值相关的，不同的初始值会导致无序
    Xn+1=Xn×μ×(1-Xn) μ∈[0,4] X∈[0,1]

Thinking

feedback)，把输出当作输入，不断滚动。很容易想到，反馈的结果有若干种：发散的、收敛的、周期的等等。但是我们要问一下，一共有多少种可能的运动类型?是否存在既不收敛也不发散，也不周期循环的迭代过程? 回答是肯定的。这一点至关重要，但可惜的是人们最近才普遍认识到有这种运动类型。这说的就是有界非周期运动，它与混沌有关。

– Main.GangweiLi - 19 Sep 2013

*映射*有一维映射，二维映射， 有三维吗。

– Main.GangweiLi - 19 Sep 2013

– Main.GangweiLi - 19 Sep 2013

+`高斯过程 <http://blog.sciencenet.cn/blog-520608-718474.html>`_

高斯过程与核函数紧密联系，定义在y上的高斯分布是通过核函数表示出来的，与线性回归相比，高斯过程通过通过核函数的方式把x和y建立联系。在线性回归中，我们假设yde值服从某一个高斯分布

\[p\left( y \right){\rm{ = }}N\left( {y|{w^T}\phi \left( x \right),{\sigma ^2}} \right)，即y的均值是w的一个线性变换。\]
\[\begin{split}\begin{array}{c} {\mathop{\rm cov}} \left( {\rm{y}} \right) = E\left( {y{y^T}} \right) = E\left( {\phi w{w^T}{\phi ^T}} \right)\\ = \phi E\left( {w{w^T}} \right){\phi ^T} = \phi {\mathop{\rm cov}} \left( w \right){\phi ^T} \end{array}\end{split}\]

注意到上面phi是一个Ntimes M的设计矩阵，

这里phiphi^T可以通过一个核函数表示：

\[k\left( {{x_m},{x_n}} \right) = \phi {\left( {{x_m}} \right)^T}\phi \left( {{x_n}} \right)\]

可以理解为两个函数的相似关系。

\[\begin{split}{C_{N + 1}} = \left( {\begin{array}{\*{20}{c}} {{C_N}}&k\\ {{k^T}}&c \end{array}} \right)\end{split}\]

已知分布

\[p\left( {{t_{N + 1}}} \right) = N\left( {{t_{N + 1}}|0,{C_{N + 1}}} \right)， 因此协方差矩阵是核函数给出的，这样高斯分布的性质容易得到：\]
\[p\left( {{x_{N+1}}} \right) = N\left( {{x_{N + 1}}|{k^T}C_N^{-1}t,c - {k^T}C_N^{-1}k} \right)\]

%RED% 这里的期望怎么计算的?? %ENDCOLOR% #. 高斯过程简单理解 #. 协方差定义 #. pmk&#95;projectpage #. active Learning

深度网络的框架结构

神经网络基础

  1. 提高了模型的表达能力
  2. 使模型更易于训练
  3. 提高了模型的泛化性能

挑战4：如何像人一样从小样本进行有效学习？ 前沿4：数据 知识，深度学习与知识图谱、逻辑推理、符号学习相结合 现在的深度学习主要是从大数据进行学习，就是我给你很多标注的数据，使用深度学习算法学习得到一些模型。这种学习方式和人的智能是非常不一样的，人往往是从小样本进行学习。人对图像进行分类，如果人想知道一个图像是不是苹果，只需要很少几个样本就可以做到准确分类。两三岁小孩，开始认识世界的时候，他如果想知道什么样的动物是狗，我们给他看几张狗的图片，并且告诉他狗有什么特征，和其他动物像猫或者羊有什么区别的话，小孩可以很快很准确的识别狗。但是在ImageNet比赛里，像深度残差神经网络，一般来说一个类别大概需要上千张图片才能进行比较充分的训练，得到比较准确的结果。还有一个例子就是汽车驾驶，一般来说，通过在驾校的培训，也就是几十个小时的学习，几百公里的练习，大多数人就可以开车上路了，但是像现在的无人车可能已经行驶了上百万公里，还是达不到人的全自动驾驶的水平。原因在于，人经过有限的训练，结合规则和知识能够应付各种复杂的路况，但是当前的AI还没有逻辑思考、联想和推理的能力，必须靠大数据来覆盖各种可能的路况，但是各种可能的路况几乎是无穷的。 .. graphviz:

digraph G {
    rankdir=LR

    Memory1->Predict[label="feature1:Color"]

    Memory2->Predict [label="feature2:Construct"]

    Memory3->Predict [label="feature2:3D information"]

    Memory4->Predict [label="feature3:spatial and time seires information"]

    Predict->Output

}

基本概念

激活函数

主要的错误，就像一个哈希函数，把一个任意大小的输入映射到固定区间的大小的数据 常见的函数有: ReLu ,Sigmoid,Binary,Softplus,SoftMax,Maxout 等以及相关的变型，差不多20多种。 相当于一个压缩变换，现在最新的还有 SELU,自归一化神经网络SNN,它在训练误差上，并没有高方差，并且令激励值 达到0均值和单位方差，从而达到和批归一化类似的效果，也避免了梯度爆炸与梯度消失。 http://blog.csdn.net/zijin0802034/article/details/77334144

_images/selu.png
后向传播

主要是反馈网络的计算，这包含两个LossFunction的计算，以及如何用LossFunction来更新W参数。 主要有梯度法。 Cost/Loss 函数 主要来度量预测值与标准值之间测度。单个值对的比较有有时候没有意义。 例如二值判断，是没有办法来用距离来判断的，怎么办呢，其实是采用集合的正确率，这样一个统计值来计算出 可以量化的距离值来计算loss.

learningRate
参数的步进的速度，来解决振荡的问题。最好用的应该是AdaGrad,自适应调整。
前向传播
也就是正常推理计算，基本上者就是矩阵乘

训练的优化

  1. Gradient Descent
  2. SGD 来解决计算量太大的问题，每一次随机抽取一块来更新,并且解决陷入局部最优的问题。
  3. Momentum 根据上次的变量来加权更新当前的值
  4. Adagrad 也就是适应调整每一个参数

参数初始化

  1. 常量初始化，例如全0初始化，全1的初始化。
  2. Small Random Numbers
  3. calibrating the Variances 最好可以根据输入的结构来调整

神经元

\(y=f(\sum{W}*X +b)\)

输入层

把各种样的输入，映射到神经网络。当然各个输入之间相互独立是最好的。 一般都是 \((X,y)\) X是多维的，y是一维的，也可能 y也是多维的。

Batch Nomalization

输入正则化，并且每一次正则化一部分，也可以提前预处理全部的数据。

输入正则化的好处在于，把非线性关系，变成了线性。

\(Y=a_{n} *g_{n}(x)\) 正则化相当于把 \(Y=a_{n} *x_{n}\) 也就是所有关系转化为了最基本的加乘关系。 不然由于不同因素的变化范围与相对量的不同。也就导致前面的系数的不稳定。

Instance Normalization

_images/norms.png

batch norm是对一个batch里所有的图片的所有像素求均值和标准差。而instance norm是对单个图片的所有像素求均值和标准差。这里其实可以看到的一个问题，由于shuffle的存在，每个batch里每次的均值和标准差是不稳定，本身相当于是引入了噪声。而instance norm的信息都是来自于自身的图片，某个角度来说，可以看作是全局信息的一次整合和调整。对于训练也说也是更稳定的一种方法。其实我们完全可以把instance norm当做L2 norm这种方法的一个变种。前者适合卷积层，后者适合全连接层。仅个人意见，可能存在各种问题，欢迎大神补充讨论。

链接：https://www.zhihu.com/question/68730628/answer/266733274

_images/normalization.svg

x,y是某一层的输出，另外都是统计参数，两个scale以及offset.

  1. instance normalization 单个sample
  2. batch normalization, batch 内平均
  3. batch renormalization batch 权重平均例如softmax,softmean

#. Group normaliation,we propose GN as a layer that divides channels into groups and normalizes the features within each group

BN,LN,IN,GN,在其内部进行分组并且归一化，归一化为什么有效，这就是看绝对值更有效，还是相对值更有效。

cost函数

不同cost函数求导等一些性质也都不一样，也导致了训练效率的问题，例如交叉熵的好像，能够避免signoid函数的在极值情况下减速问题。 原因就是由于其导数结构。自然对数的导数求导，还是自然导数这个特殊的性质。 https://hit-scir.gitbooks.io/neural-networks-and-deep-learning-zh_cn/content/chap3/c3s1.html

网络的组成，可以都由一类函数来代替与输入加相关的函数来替换，特别是物理学中相关的核函数。

交叉熵 http://rdipietro.github.io/friendly-intro-to-cross-entropy-loss/

同时cost函数是整个网络拓扑功能的一个最重要特征，cost函数 就是整个网络的前进的方向。

  1. MSE(最小二乘），线性的max 函数
  2. cross-entropy, sigmoid函数
  3. log-likelihood, softmax函数。

具体采用哪一种组合呢，就看你采用哪一种解析了，如果想用要概率模型就要用softmax组合。

Stage_2/cost/LMCL.png

https://arxiv.org/pdf/1801.09414.pdf 腾讯的LMCL的cost函数，利用余弦函数，是基于Y=WX=||W||* ||X|| cos 并且再加一个常数项，给出组内距离与组间的定义，并且 组间距离，越大，而组内越小 。

隐藏层

输出层

Regularization

  1. L1 norm
  2. L2 norm
  3. Eearly Stopping
  4. Dropout
  5. Sparse regularization on columns
  6. Nuclear norm regularization
  7. Mean-constrained regularization
  8. Cluster mean-constrained regularization
  9. Graph-base similarity

bias

_images/biasVariance.png

网络结构

  1. Forward
  2. LSTM
  3. GAN
  4. Auto-Encoders
  5. CNN
  6. RNN(Recurrant)
  7. RNN(Recursive)

自动适配其实也简单，直接根据规则构造生成一个矩阵，然后那就是构造其系数，其中一个方法，那就是通过训练。其实人们平时不断重复同一个动作也是一样的。

如何开始

  1. 针对问题，选一个合适的网络结构
  2. 看看这个framework的实现有没有bugs 在梯度检查时。
  3. 参数初始化
  4. 优化
  5. 检验模型的有效性
    • 如果无效，改变model structure 或者改大网络拓扑
    • overfit, Regularize to prevvent overfitting
      • Reduce modle size
      • l1/l2 on weights
MappingFromTrendes.png
  1. 持续学习
  2. 鲁棒决策
  3. 可解决的决策
  4. 安全飞地
  5. 对抗学习
  6. 在保密数据上共享学习
  7. 为特定领域定制的硬件
  8. 组件化的AI系统
  9. 跨云端和边界的系统

一个看不出来规律，那就弄多个来对比，就像周易的演化一样。然后再平均，然后权重平均(又分线性分段，又分非线分段)，简单权重平均还还行的话，那就要非线性的加权。 也就是所谓的压缩变换。如何实现一个最合理的非线性加权，当然是网络函数最合适了。或者用理论来解释。

各种评价指标

不仅有更正确率，只有这个对于本身不平衡样本的训练就没有了意义了。召回率，以及精度。等等，包括各种cost都是一种各种有效的度量。 https://mp.weixin.qq.com/s/FaNC9RppIhPf6T_qAz3Slg

深度学习现状

深度学习源于机器学习理论。1980年代末期，用于人工神经网络的反向传播算法（Back Propagation，BP）的发明cite{fahlman1988faster,lecun1989backpropagation}，给机器学习带来了希望，由此掀起了基于统计模型的机器学习热潮。该算法可从大量的训练样本中学习出统计规律，从而对未知事件做出预测，这种结构只有一层隐层节点，因此被称为浅层学习模型。但是BP算法基于局部梯度下降，从一些随机初始点开始训练，通常陷入局部极值，并随着网络深度的增加而持续恶化，不能很好地求解深度神经网络结构问题。20世纪90 年代，各种浅层机器学习模型相继被提出，比如支撑向量机（Support Vector Machines，SVM）cite{burges1998tutorial}、Boostingcite{berger1996maximum}、最大熵方法cite{berger1996maximum}， Logistic Regressioncite{peduzzi1996simulation}等。这些模型也只有一层隐层节点（比如 Boosting、SVM)，或没有隐层节点的结构（比如LR）。这些模型在无论是理论分析，还是实际应用都获得了巨大的成功。图像是深度学习最早尝试的应用领域。早在1989年，Yann LeCun 的团队就发表了卷积神经网络（Convolution Neural Networks, CNN）的工作cite{lecun1998gradient}。CNN是一种带有卷积结构的深度神经网络，通常至少有两个非线性可训练的卷积层，两个非线性的固定卷积层（又叫Pooling Layer）和一个全连接层，一共至少5个隐含层。CNN的结构受到著名的Hubel-Wiesel生物视觉模型的启发，尤其是模拟视觉皮层V1和V2层中Simple Cell和Complex Cell的行为。在很长时间里，CNN 虽然在小规模的问题上，如手写数字，取得过当时世界最好结果，但一直没有取得巨大成功。这主要原因是，CNN 在大规模图像上效果不好，比如像素很多的自然图片内容理解，所以没有得到计算机视觉领域的足够重视。这个情况一直持续到2012年10月，Geoffrey Hinton和他的两个学生在著名的ImageNet 问题上用更深的CNN 取得世界最好结果，使得图像识别大踏步前进。在Hinton的模型里，输入就是图像的像素，没有用到任何的人工特征。但是由于理论分析的难度，训练方法需要很多经验和技巧，以及对数据和计算的要求，这时浅层人工神经网络处于较为沉默的状态。

2006年，加拿大多伦多大学教授 Hinton的团队在《科学》、Neural computation 和 NIPS上发表了4 篇文章cite{hinton2006fast,hinton2006reducing,hinton2007learning,bengio2007greedy}，提出基于深度信任网络(deep belief network，DBN)的无监督学习算法，解决了深度学习模型优化中局部解的问题。这些文章有两个主要的信息：1. 隐层的人工神经网络具有优异的特征学习能力，学习到的特征对数据有更本质的刻画，从而有利于对数据进行可视化或分类；2.可以通过“逐层初始化”（Layer-wise Pre-training）来有效克服深度神经网络在训练上的难度，在与网络大小和深度呈线性的时间复杂度上优化DBN的权值，将求解的问题分解成为若干更简单的子问题进行求解。这个模型包含一个可视层，多个隐含层，因此也被成为深度学习（Deep Learning, DL）模型。

深度学习比浅学习具有更强的表示能力，而由于深度的增加使得非凸目标函数产生的局部最优解是造成学习困难的主要因素。从具有开创性的文献发 表之后，大量研究人员对深度学习进行了广泛的研究以提高和应用深度学习技术。Bengio和Ranzato 等人提出用无监督学习初始化每一层神经网络cite{poultney2006efficient}； Ethan 等人尝试理解无监督学习对深度学习过程起帮助作用的原因cite{erhan_why_2010}；Glorot等人 研究深度结构神经网络的原始训练过程失败的原因cite{glorot2010understanding}。 文献cite{bengio_learning_2009} 对深度学习进行了较为全面的综述，基于无监督学习技术提出贪婪逐层预训练学习过程用于初始化深度学习模 型的参数，从底层开始训练每层神经网络形成输入的表示，在 无监督初始化之后，堆栈各层神经网络转换为深度监督前馈神 经网络，用梯度下降进行微调。用于深度学习的学习方法主要 集中在学习数据的有用表示，在神经网络较高层中使学习到的 特征不随变化的因素而变化，对实际数据中的突发变化具有更 强的鲁棒性cite{goodfellow2009measuring}。 文献cite{hinton2010practical}给出了训练深度学习模型的相关技巧，尤其是受限玻尔兹曼机(restricted Boltzmann machine， RBM)cite{hinton2006reducing,hinton2010practical,larochelle2008classification}，许多来自神经网络训练的想法也可以用于深度结构神 经网络学习。Bengio 在文献cite{bengio2012practical} 中给出了用于不同种类深度结构的神经网络的训练方法。已经 在语音识别cite{jia2014caffe,huang2014deep}、图像识别cite{ouyang_multi-source_2014,zeng_multi-stage_2013,sermanet_pedestrian_2013,luo_pedestrian_2013,luo_switchable_2014}、 自然语言处理cite{sarikaya2014application,manning2014stanford}，用户行为分析cite{o2014potential,hu2014discriminative,shao2014spatio}、 在线广告推送等领域取得显著进展。

自2006年以来，深度学习在整个学术界持续升温。斯坦福大学、纽约大学、加拿大蒙特利尔大学等成为研究深度学习的重镇。2010年，美国国防部DARPA 计划首次资助深度学习项目，参与方有斯坦福大学、纽约大学和NEC美国研究院。支持深度学习的一个重要依据，就是脑神经系统的确具有丰富的层次结构。一个最著名的例子就是Hubel-Wiesel 模型，由于揭示了视觉神经的机理而曾获得诺贝尔医学与生理学奖。除了仿生学的角度，目前深度学习的理论研究还基本处于起步阶段，但在应用领域已显现出巨大的能量。

2012年6月，《纽约时报》披露了Google Brain项目cite{markoff2012many}，引起了公众的广泛关注。这个项目是由著名的斯坦福大学机器学习教授Andrew Ng和在大规模计算机系统方面的世界顶尖专家Jeff Dean共同主导，用16000个CPU Core的并行计算平台训练一种称为“深层神经网络”（DNN，Deep Neural Networks）的机器学习模型，在语音识别和图像识别等领域获得了巨大的成功。2012年11月，微软在中国天津的一次活动上公开演示了一个全自动的同声传译系统，讲演者用英文演讲，后台的计算机一气呵成自动完成语音识别、英中机器翻译，以及中文语音合成，效果非常流畅。据报道，后面支撑的关键技术也是深度学习算法cite{markoff2012scientists}。2013年1月，在百度的年会上，创始人兼CEO 李彦宏高调宣布要成立百度研究院，其中第一个重点方向就是深度学习，并为此而成立Institute of Deep Learning（IDL）。2013年4月，《麻省理工学院技术评论》杂志将深度学习列为2013 年十大突破性技术（Breakthrough Technology）之首。

相比早期的浅层次学习，深度学习具有许多优点：

a)在网络表达复杂目标函数的能力方面，浅结构神经网络有时无法很好地实现高变函数等复杂高维函数的表示，而用深度结构神经网络能够较好地表征。

b)在网络结构的计算复杂度方面，当用深度为k的网络结构能够紧凑地表达某一函数时，在采用深度小于k的网络结构表达该函数时，可能需要增加指数级规模数量的计算因子，大大增加了计算的复杂度。另外，需要利用训练样本对计算因子中的参数值进行调整，当一个网络结构的训练样本数量有限而计算因子数量增加时，其泛化能力会变得很差。

c)在仿生学角度方面，深度学习网络结构是对人类大脑皮层的最好模拟。与大脑皮层一样，深度学习对输入数据的处理是分层进行的，用每一层神经网络提取原始数据不同水平的特征。

d)在信息共享方面，深度学习获得的多重水平的提取特征可以在类似的不同任务中重复使用，相当于对任务求解提供了一些无监督的数据，可以获得更多的有用信息。

早期的深度学习都是基于单个特征的学习，这样难以模拟网路中复杂的关系，从而难以获得很好的网络预测。因此我们提出基于深度学习的网络预测，学习网络的深层次结构。

Backpropgation

整个就是一个链式求偏导的过程。 \(\frac{\PartialC}{W}\) 另外就是图论中所有路径最短的问题。

  1. 从整个学习上说，就是一个偏导函数量。要解决的一个问题包括两方面：第一个是学习速度问题，第二个是防止震荡。目前用的都是基于导数的优化。
  2. 受到cost函数影响是约束问题的松和紧。 cost ， activate MSE(最小二乘），线性的max 函数 cross-entropy, sigmoid函数 log-likelihood, softmax函数。
  3. 超参数的估计，目前是过拟合产生一个主要原因。
  4. 具体采用哪一种组合呢，就看你采用哪一种解析了，如果想用要概率模型就要用softmax组合。

单层神经网络(前向传播)

假设C类，N个训练样本的结果。

\[E^N=\frac{1}{2}\sum_{n=1}^{N}\sum_{k=1}^C(t_k^n-y_k^n)^2\]

这里 \(t_k^n\) 表示第n个样本对应的标签的第k维。 \(y_k^n\) 表示第n个样本对应的网络输出的第k 个输出。

对于样本n的误差可以表示为：

\[\begin{split}\begin{array}{l} E^n=\frac{1}{2}\sum_{k=1}^C(t_k^n-y_k^n)^2=\frac{1}{2}||\textbf{t}^n-\textbf{y}^n||_2^2\\ \end{array}\end{split}\]

那么l层的误差可以表示为：

\[\begin{split}\begin{array} E^n=\frac{1}{2}\sum_{k=1}^C(t_k^n-y_k^n)^2=\frac{1}{2}||\textbf{t}^n-\textbf{y}^n||_2^2\\ \end{array}\end{split}\]

对于传统的神经网络需要计算网络关于每一个权值的偏导数。我们用l表示当前层，那么当前层的输出可以表示为：

\[\begin{split}\begin{array} x^l=f(u^l)\\ s.t.\; u^l =W^lx^{l-1}+b^l \end{array}\end{split}\]

这里 \(x^l\) 是下一层的输入，这一层的输出。

输出激活函数 \(f(.)\) 可以有很多中，一般是sigmoid函数或者双曲线正切函数。意思是把他们进行分类。

digraph logistic_regress { node [shape = box] rankdir=LR; {node [shape=circle, style=invis] 1 2 3 4 5 } { node [shape=point,width=0] input dummy1 dummy2 dummy3 } { rank=same; posibity cost } {1 2 3 4 5}-> input-> function -> posibity -> dummy1 -> prediction -> output [weight=8]; dummy1->dummy2 [weight=8] { rank=same; dummy2 -> cost [splines="ortho"] cost -> dummy3 ; } dummy3-> input [weight=8] }

后向传导算法（BP算法）

每一层采用最小均方误差（LMS）模型，采用梯度下降法得到梯度，进而逐层传播到前向网络中去。

\[\frac{\partial E}{\partial b}=\frac{\partial E}{\partial u}\frac{\partial u}{\partial b}=\delta\]

因为 \(\frac{\partial u}{\partial b}=1\), 所以 \(\frac{\partial E}{\partial b}=\frac{\partial E}{\partial u}=\delta\), 得到后向反馈的灵敏度：

\[\delta^l = (W^{l+1})^T\delta^{l+1}\circ f\prime(u^l)\]

这个模型在无限次迭代中趋于0，也就是没有价值。

输出层的神经元的灵敏度是不一样的：

\[\delta^L= f\prime(u^L)\circ(y^n-t^n)\]

神经网络就是利用多层信息进行非线性拟合。

权值更新可以表示为：

\[\frac{\partial E}{\partial W^l}=X^{l-1}(\delta^l)^T\]
\[\Delta W^l=-\eta\frac{\partial E}{\partial W^l}\]

就是首先求最后一层的误差，逐步扩展到前一层。

实际中对数据训练都是首先前向传导求出实际输出Op,然后和理想输出做对比。得到对比函数，最后使用后向传导调整权值。

并且这种跨层反馈，并且如何自主联网。

随机梯度下降法

如果一次使用所有数据，那就是batch-gradient-descent. 但是这样对大数据来说，计算就不可形了。 mini-batch的原理，是把矩阵变小，这样不需要一次计算整个输入梯度，只用计算部分。 一次一点的来计算。 大小的选择根据硬件matrix的大小限制来进行选择。 http://neuralnetworksanddeeplearning.com/chap1.html 公式18. 随机的指的就是那个mini-batch, 正常每次全局的WB来算。 再来计算cost函数，每一次同时算，计算量太大没有办法算，只能每一次算抽取样本来模拟总体cost. 其实就是求平均值的问题，1/3(a+b+c) 与1/2(1/2(a+b)+c) 是不是趋于相当，或者相当于同阶无穷小。 这就是在第5章为什么提到sgd的噪声的原因。

W值的过大，就会出现exploading,过小就会消失。 这个是混沌理论。就是利用混沌理论来设置W值。 难点那就是保证凸就好办，不然很计算全局最优点。

牛顿法比梯度法快的原因http://www.zhihu.com/question/19723347

过拟合与规则化

规则化就是把相当于把先验知识都提前加进去。http://blog.csdn.net/zouxy09/article/details/24971995 http://blog.csdn.net/zouxy09/article/details/24972869 L1就是Lasso,L2就是ridge岭回归。L0产生稀疏，L1是L0最好的近似。

就像背单词一样，训练的迭代次数与就像背单词的记忆是一样的。http://yuedu.163.com/news_reader/#/~/source?id=b7b38304-5450-41eb-8a87-884c98c2336e_1&cid=6281da38266a4cd19fca1c2ae370377e_1 迭代是正道啊。

神经元之间的联系，是通过W值来进行，同时如何反馈关联决定的。

对于学习速度的超参数，可以先大后小，采用可变值，或者加入一个当前的梯度检测，梯度太小时，用大值，梯度小时用大值。 或者加入一个约束项。

过拟合一个原因，参数过多，另一个原因数据不够，就会出方程数少于变量数的多解问题。

特定的细胞只对特定方向的事物感兴趣，一个是利用元胞机来解决专注的问题，然后利用聚类来组网，利用遗传算法来重构网络。

迭代的终止

同时训练的时候，要解决什么时候结束训练的时候，一个简单的就是迭代次数，另外根据Error rate. 达到某个值或者保持某个范围不变之后就停止。过度训练也不好。 http://neuralnetworksanddeeplearning.com/chap3.html

为了加快计算

非导数的学习方法

学习的慢，是因为用的导数，如果不用导数呢，不要求连续函数，直接离散呢，就相当于计算机的精度问题，例如参数只能是0，1这样形成了二值网络，就加快了，学习的速度。但是二值网络如何学习呢。 神经网络也是离散的，但是还要保证其光滑的，就是像光栅化的做法一样。 是不是可以用三态门来做，再加一个不定态。

而元胞机以及遗传算法，就不需要导数。还有RNN的LSTM三态门的方法。

另外的初始化的W,B可以根据输入信号本身的特点来取列如公式123.http://neuralnetworksanddeeplearning.com/chap5.html

dropout

相当于人为减少变量的个数，这样可以减少过拟合。 因为计算的问题。 参数要比输入多的多。这样就注定不只有一个解的问题。

info flow

观察一个系统的核心，那就是看其信息流是怎样的，信息发生了哪些transform.

_images/autoencoder.png

auto coder， sparse coding。中层打label。

深度学习读书笔记之 AE（自动编码）

并且用 AE来自动学习一个物体的表征方式，是一个不错方向。 Representation Learning: A Review and New Perspectives

  1. Sparse AE
  2. Denoise AE
  3. contractive AE
  4. Stacked AE
  5. Deep AE

用于特征抽取特别有效。

model.parameters
optimizer.RMSprop(model.parameters,lr=0.1,weight_decay=0.1)

AE对图形不同位置和方向进行边缘检测。另外可用于检测图像隐藏的相关性，和PCA类似。autoencoders 利用稀疏性来对规则化。

只是da的多层堆在一起，每一层算完之后，再整体就像MLP一样计算一遍。autoAE要利用约束防止训练单位阵。

Denoising Autoencoders 原理：

使用code和decode 来求解 \(w_{ij}\) .

具体如下：

对于输入x建立神经网络：

\[y=s(Wx+b)\]

其中s是非线性函数：期望得到输出：

\[z=s(W^{T}y+b)\]

最后使用不同的reconstruction error 作为约束函数：

均方误差（square error ） 和交叉熵

最后使用均方误差作为约束函数：

\[L(x,z)=||x-z||^2\]

或者使用 交叉熵(cross-entropy) 作为约束函数：

\[L_H(x,z)=-\sum_{k=1}^d[x_klog{z_k}+(1-x)log(1-z_k)]\]

square error 只适用于高斯误差，所以cross-entropy 更加鲁棒些。

L1,L2正则化

我自己的理解就是约束优化函数出现一些没有意义的解。常规的主要L2正则化:

\[J_R(w)=\frac {1}{n}||y-xw||^2+\lambda ||w||^2\]

但是如果对于高维数据一般存在稀疏性，一般加入L1正则化：

\[J_R(w)=\frac {1}{n}||y-xw||^2+\lambda ||w||^1\]

2006年tao证明L1正则化等价于0 范数，说明其具有稀疏性。 而稀疏就意味着80/20原则，也就是起关键作用就那少数几个参数。同时也就意味着降维。

另外在实现的时候，在层与层之间传输的数据一般是用张量来表示，如何化信息流，在实现一方便数据的输入适配，同时也是信息抽象的过程。例如在caffe里采用blob的概念来打包这个数据格式，并用protobuf来实现。

AE与GAN的同与不同

https://zhuanlan.zhihu.com/p/27549418

  1. 一个是AE可以多层的，GAN现在还相当于两层的，相当于是把feedback放到foward中。
  2. AE更像一个压缩感知,把一个高维数据压缩到低维，而GAN更相反，是从低维数据生成高维数据。 而这个本质就在于层层之间转换的这个基是什么。 GAN相当于只是找到 \(y=F(x)G(X)\) 找到 \(G(x)\)
  3. Vairational AE 也是一个生成模型，而原始版本的 AE只能重构原始数据。 是在编码过程给它增加一些限制，迫使其生成的隐含向量能够粗略的遵循一个标准正态分布。 每一次生成两处向量，一个表示均值，一个表示标准差，然后通过两个统计量来合成隐含向量。

目前问题

  1. 如何构造每一个感知器，层与层之间如何连接，需要多少层？最简单的方法，每一层之间都是全连接，通过增加层数，来解决所有问题，这样的计算太大。因此如果全联接，要尽可能用剪枝算法，来减少不必要的连接。并且到底需要多少层都是根据实际的情况来的。
  2. 另外一部分那就是如何反馈，现在看到的都是利用的梯度，建立一个cost函数，然后把所有的参数都放进去，然后求梯度，theano采用链式求导，也就是复合函数求导。只要都是表达式，就可以求导，一次更新所有参数。所以反馈机制，是整体的cost,还是每一层都可以有一个cost,并且反馈采用梯度，还是牛顿法等。
  3. 多层之间是可以混合的，例如一层采用卷积，减少到一定程度，然后采用自动编码，最后是隐藏层等。另外神经元之间的横向连接如何建立，也就是层内部关联。

根据目前的论文来看，浅层更多的是通用的feature,深层是一些高阶的feature。 如果想迁移学习复用的话，就要根据相似度来选择到底需要复用几层。

容量度量
  1. 表达
  2. 优化
  3. 泛化

深度网络能够识别分类多少信息？也就是如何度量一个网络的识别能力。

本身当做一个非常好的优化库。如何理解高层空间，并且实现降维与压缩。

当深度当做最优化的一种解法

WX+B 就相当于KKT把等式与不等式的直接了起来了，原来的WX>B 可以变成WX+（-B)=0 来直判断符号了。 那是不是可以最优化理论用到这里来化简。

把W,b当做方程组

是不是线性方程组的解空间的特质与方程本身的之间的关系，得到一些优化的的约束条件。

https://mp.weixin.qq.com/s/wJh1-9uhXX3u4CO8hdOHCg, 单层网络需要的单元数非常多，甚至比宇宙中原子数还要多，就是数学上所说的维度灾难，参数的个数是需要是方程维度的指数倍。 基本上一个一般的神经网络当相当于上万个线性方程问题，而根据贝祖定理，此时的解的数量比宇宙中原子数量还多，参数多于数据 带了退化，每一解都对应着一个无限大的解集。

过参数化意味着，神经网络有无限多个退化的全局最优解，它们在损失空间里 形成平坦的谷地。

能够神深度神经网络很好的拟合的数据都具有组俣函数的特点。 我们需要对组合函数得到一些更明确的的性，从而更好的理解神经网络的工作机制。

无穷大也是有一个数量级的，宇宙中原子数大约为

通过神经网络，我们得到在有限与无限之间，我们还是能够找到桥接点的，那就是极限，以及不动点。 同时也就是群环域中最基本的要素要求。 列如声速，光速，宇宙三速，等等这些都是不动点。质量可以通过万有引力计算，然后再换算成一个氢原子的质量。 原子的数量 10^80次方个。 地球的质量，太阳 1.96*10^30 kg. 可见范围内 1.27*10^11个星系。银河系有4*10^11次方个太阳。而地球有 5.98*10^24 kg. 10^4=1000,10^8=1亿。 例如训练好的神经网络输入全0，全1，还得单位阵图片等等，看看输出什么。

深度网络拓扑结构

digraph G { a [label="初始层"] b [label="隐层1（中层特征：边缘？？）"] c [label="隐层2（高层特征：shape？）"] d [label="决策层"] a->b [label="卷积层"] c->b [label="auto-coder"] b->d [label="跨层网络实现多尺度特征"] b->c [label="使用sparse coding层层抽象"] c->d [label="全局特征决策"] }

神经元结构

  1. 神经元从结构功能上来说：包括感知神经元和激活神经元。
  2. 从感知神经元包括：线性的，卷积，限制玻尔兹曼机。
  3. 激活函数包括（只要是连续即可）：sigmod，tanh，softmax，retified linear 。

每一种结构都是基于数学推理或者仿生学的原理。 并且网络能够自动的组成连接的拓扑，这才是人脑的过程。并且是动态的。 而现在的网络是静态的过程。

并且根据问题本身的模型来选择不同拓扑网络，现在还没有成熟的理论，只是经验性的应用。并且神经网络不会只有一种。也会需要各种类型。 并且现在神经元的构造是简单的运算来实现。是不是可以利用复杂的计算模型来构造神经元。 例如，在知道服从什么样分布的情况下，比如高斯分布，采用确定性的误差。在知道概率的情况下，使用最大似然或者熵进行推导，在概率也不知道的情况下，使用能量模型进行推导。 神经元，激活函数，误差函数，由误差到参数loss函数，

随着深度网络增加，参数呈线性增加，但对问题描述能力成指数增长。并且神经网络本身也可以用来拟合复杂的复变函数公式的。 更因为这一拟合功能，把问题统一化了，有统一的解决方式。而不再是以前不断细化与breakdown的解决问题模式。我们就可以问题的颗粒度提高DL这一层了。剩下就交给机器去计算了。深度学习也算是一个算法数据结构的大一统。

层数不够的话，就要抽象逻辑不够，并且爆仓的问题。 也就是十个苹果放在九个篮子里。当然现在容量的研究还是空白。

网络的深度与每一个神经元的本身的复杂就是一个矛盾。每一个神经元简单，就需要更多层的网络。 复杂的神经元就可以实现更少层数来设计。

从级数的角度理论，深度是可以拟合一个函数的，精度误差，只与网络的级数相关。就像PCA算法的要求时。证明在这里http://neuralnetworksanddeeplearning.com/chap4.html。这也是深度网络的泛化能力的体现。 例如把tanh的级数展开式:http://www.wolframalpha.com/input/?i=sum+x%5E%282n-1%29%2F%282n-1%29%2C+n%3D1..oo 应该是一个傅里叶级数的变种。

但是反过来求网络所构成非线性函数在理论上是可能的，但是高维的计算量复杂。

我们能否把心理学试验与DL来进行对比实验。就像认知心理学中研究的XOR学习任务一样。从XOR分类任务看人类类别学习能力的局限性.pdf

把函数式编程+多态，是不是可以很方便实现神经网络。

网络框架

  1. 基于限制波尔兹曼机
    • 卷积限制玻欠兹曼机
    • 三阶因子玻尔兹曼机
  2. 基于自编码
    • 去噪自编码器
    • 变换自编码器
  3. 卷积神经网络
    • 卷积神经网络
    • 卷积分解神经网络

卷积神经网络

_images/cnn.png

R01 卷积滤波示意图

digraph Flow { Norm->"Filter Bank"->"Non-Linar"-> "feature Pooling"; }

卷积神经网络里，简单的理解那就是每一层的Filter如选，以及Pooling的大小如何选。最后要这些每一层的信息都要传递给决策层。

不管什么神经网络最后都链接上一个MLP来做判决的。

对于深层网络,越高层的信息包含越多的语义信息，and less location information.

可视化

各种各样的白平衡，对比度，去除噪声等等。来解决各种光照的影响。

来解决尺寸的问题， 投影变换

主要是稀疏化，饱和，latel inhibition.

实际就是聚合的过程， aggregation over space or feature type.

就是分块，然后用一点来代表这一块。什么样的映射更好，有什么更好的抽样理论或者压缩理论在这里。

神经网络知识本身就那些参数空间，其实就也是各种映射，如果找到有逆射那就更好了。

算法优点：

  1. 针对图像中的像素点进行操作，通过卷积和下采样交替进行，在图像分类和识别中有重要应用。
  2. 采用感受野和权值共享达到减小隐藏层的目的，同时起到旋转不变的作用。
  3. down-sampling 达到减小分辨力的作用，同时也减小运算量。
  4. 最后在经过 logistic regression 判断求所有layers的parameters。 %RED% 不难，建立一个cost函数，然后直接梯度计算%ENDCOLOR%

除了卷积网络本身还有什么方法可以来减少的连接数的。

\[\begin{split}\begin{figure} \centering \includegraphics[width=4cm]{CNN.jpg}\\ \caption{卷积神经网络} \end{figure}\end{split}\]
\[x_j^l = f(\sum_{i\in M_j}x_i^{l-1}*k_{ij}^l+b_j^l)\]

其中 \(M_j\) 表示选择的输入maps的集合。（对于图像处理，是获取边缘信息。）

此时的灵敏度可以表示为：

\[\delta_j^l = \beta_j^{l+1}(up(\delta^{l+1})\circ f\prime(u_j^l))\]

up(.)表示上采样操作。

Sub-sampling Layers 子采样层

\[x_j^l=f(\beta_j^l down (x_j^{l-1})+b_j^l)\]

其中 \(down(.)\) 表示下采样函数。

digraph CNN { rankdir=LR; node[shape=box]; subgraph clusterA { x_1->y_1 [label="w_11"]; x_2->y_1 [label="w_21"]; x_2->y_2 [label="w_22"]; x_3->y_2 [label="w_32"]; label="layer1"; } subgraph clusterB { y_1; y_2; label="layer 2 maxpooling"; }; y_1->y; y_2->y; }

照片实别的过程

digraph flow { Pixel->edge_line->texon->motif->part->object; }

组成

卷积类型，每一次池化的大小，都是要原因的。池化的大小是不是可以用采用定理来决定 。

每一部都是这么实现了。

卷积神经网络图解, 每一层有多少kernel当相于有多少featuremap, 因为每一个kernel的参数都是独立的。相当于同时弄了多套的filter.

输出与输入这的关系:

\[ \begin{align}\begin{aligned}W_2 = (W_1 - F + 2P)/S + 1\\H_2 = (H_1 - F + 2P)/S + 1\end{aligned}\end{align} \]

每一个kenerl对应一个输出的图像，output_chanels就是指的 kernels的数量。 http://web.stanford.edu/class/cs20si/lectures/notes_07_draft.pdf

pool层相当于 attention层的一种选择机制。

dilated convolution

在相同的计算量的情况下，可以增大感受野，这在图像分割领域会特别有用。 解决了 Pooling过程的信息损失。

https://www.zhihu.com/question/54149221

1x1 conv

相当于直接相乘了一个W值来做scale的效果。但是多层组合起来，就可以用其他的用途了

GAN 对抗网络

GAN 的发展总结，https://www.jiqizhixin.com/articles/2017-03-27-4 漫化式原理讲解 https://zhuanlan.zhihu.com/p/26397259, 解决了如何别人只拿到Y/No 的回答。就不断的迭代而找到正确答案。

GAN 最好的应用那就是设计模式中生成模式，可以有各种各样的变种模式。

_images/AdversarialNetsFrameworksr.jpg _images/gan.jpg

要同时训练两个网络G,D,并且要网络之间反馈传播。

先训练D，用真实的数据给D \(x ->D ->1\) 优化方向概率为1方向。 然后输入由G生成的数据给D \(G(z) ->D -> 0\) 往零的方向优化。

而在训练G时，如何训练把第二部向1的方向优化得到G的参数，但是G的输入是什么。X再加些噪声，还是只有噪声。或者 还只是其他。G的输入应该y本身。 G的输入最好是一些有意义的输入，这样才容易控制。即使是随机数也是利用其统计特征来做的。

而最终概率为1/2时。效果最好。也是生成器做到以假乱真了。

所以在train G时 \(log(1-D(G(z)))\) 最小。 也就是 \(d(G(z))\) 尽可能为1。 而train D时，则要求 \(D(X)\) 尽可能为1。 所以两部为合而为就是如下公式

_images/GAN_Target.png
_images/gan_train_figure.png
_images/gan_train.jpg

红圈，训练D，D是希望V(G,D) 越大越好，所以是加上梯度(ascending). 第二步训练G时，V(G,D)越小越好，所以是减去梯度(descending).

这里有一个 toy版本可以用 https://github.com/MashiMaroLjc/learn-GAN/blob/master/code.ipynb

https://github.com/zhangqianhui/AdversarialNetsPapers GAN 资料大全 交叉熵的概念相难理解。

https://github.com/hwalsuklee/tensorflow-generative-model-collections tensorlfow中的GAN实现。

# 是转换卷积只是保证转换前后的，矩阵的大小保持不变。而不保证是逆运算。 ConTranv https://www.zhihu.com/question/43609045

CycleGAN

采用的对偶式学习法， X->Y->X’, 通过对比X与x’的差距来解决X-Y以及Y-X的转换。所以把图片去除衣服就变成了图片翻译过程。 所以NMT是一个基本模式。模型的不收敛，就会出去模型model collapse.

对偶式学习，特别适合没有标注数据的时候使用，例如翻译。

ATAGAN

https://arxiv.org/pdf/1802.09070.pdf 分析发现 GAN的D不能让CNN中那样有效检测目标区块。 解决在D网那块并列了CNN然后输出结果CAM与D网进行对比，然后让D网尽可能接近CNN。 有点脱裤子放屁的感觉，D的网络结构本身就没有限制，为什么不直接用CNN呢。

所谓的attention,也就是一个softmax.

Deepdefense

http://posts.careerengine.us/p/5a9f809cedfcfc6522374df9 DL易被欺骗的本质在于其线性的组合的本质。通过加入各种扰动组合来提高稳定性。当然我们可以把那些扰动训练比较加大。 例如在训练的过程中，把遇到错误样本，挑选出来进一步的训练呢。而是根据固定的规则来做。相当于attention training.对于加错误的样本加大训练。

提出了 defense distillation->detection->rejecting method.

并且这种对抗样本的通用性特别强。

从理论的角度看，这使得 DNN 模型可以直接从对抗扰动中学习并进一步对其进行防御。具体来说，就是给正确分类的样本分配更大的正则化项值，给错误分类的样本分配更小的正则化项值，来惩罚对抗扰动的范数。作为正则化项，它将和原始的学习目标函数联合优化，并且整个问题将被当做训练一个类似递归型的网络而高效地求解.

从理论的角度看，这使得 DNN 模型可以直接从对抗扰动中学习并进一步对其进行防御。具体来说，就是给正确分类的样本分配更大的正则化项值，给错误分类的样本分配更小的正则化项值，来惩罚对抗扰动的范数。作为正则化项，它将和原始的学习目标函数联合优化，并且整个问题将被当做训练一个类似递归型的网络而高效地求解. .

从理论的角度看，这使得 DNN 模型可以直接从对抗扰动中学习并进一步对其进行防御。具体来说，就是给正确分类的样本分配更大的正则化项值，给错误分类的样本分配更小的正则化项值，来惩罚对抗扰动的范数。作为正则化项，它将和原始的学习目标函数联合优化，并且整个问题将被当做训练一个类似递归型的网络而高效地求解.

DATA Augmentation GAN

https://arxiv.org/pdf/1711.04340.pdf

主要利用了GAN + transfer learning 来解决数据不足的问题，并且将用到了one-shot learning中。

bayesgan

https://github.com/andrewgordonwilson/bayesgan, 都是求一个概率分布，G,D的参数分布。 这里直接使用蒙特卡罗的方法+粒子计算的方法来参数的更新。

这种新提出的方法，简洁性是其最大的优势——推理是直接进行的、可解释的、稳定的。确实，所有的实验结果的获得，都不需要参数匹配，正则化或者任何的特别（ad-hoc）技巧。

具体如何计算与更新W,利用最大后验概率。来进行优化。我们不知道怎么办的时候，就要根据需要进行最大化概率，还是最小概率来进行。

InfoGAN

就是那种结化的生成结构。原理是互信量最大化来实现这种结构化的推理的。 把这结构化信息作为输入容易,但是如何让网络能解释这些结构是重点. 原来是利用互相性, 计算生成图片与这些之间的互相性，并且让其朝着最大化方向优化。

在神经网络中，希望两个部分强关系，就在网络中将其分离出来，然后计算互相关性，并且朝着最大化或小化方来优化。

玻尔兹曼机

_images/RBM.png

没有输出结点，只有可视节点与隐藏节点，各个节点之间自主的相互调节，最后利用达到能量平衡状态。这个有点像元胞机，可以用高维的元胞机来实现。 无监督学习核心在于自身实现完备性，这样就可以不断的自我迭代。

而限制玻尔兹曼机就是限制这种全连接，层之内不能连接，只能层与层之间连接。而DBF则是层与层之间只能单向连接。

而针对RBM的网络训练则提出了对比散度的训练模型 。

玻尔兹曼机 能量模型

EBM通过对变量的每个配置施加一个有范围限制的能量来捕获变量之间的依赖 关系。EBM有两个主要的任务，一个是推断(Inference)，它主要是在给定观察变量的情况，找到使能量值最小的那些隐变量的配置；另一个是学习(Learning)， 它主要是寻找一个恰当的能量函数，使样本中正确的输入输出的能量 比错误的输入输出的能。

这里的能量最小模型，是不是很多事物都要趋近于最小的。 原来的很多东西都是假设首先知道的，然后建立约束函数，在概率不知道的情况下使用能量函数。

能量模型是一种一般性的模型, 在分布未知情况下用能量来表示概率分布：

\[p(x) = \frac{{{e^{ - E(x)}}}}{Z}\]

其中Z为规整因子：

\[Z=\sum_x e^{-E(x)}\]
\[l(\theta,D)=-L(\theta,D)=-\frac{1}{N}\sum_{x^{(i)\in D}\log p(x^{(i)})}\]

对 \(\theta\) 求偏导，得到：

\[\Delta = \frac {\partial l(\theta, D)} {\partial \theta}\]

在有些情况下我们需要引进一些没有观察到的变量，隐含变量。为了表示所有包含v的隐含变量，表示成能量相加形式：

\[P(x)=\sum_h P(x,h)=\sum_h \frac{e^{-E(x,h)}}{Z}\]

并进行求导，但是上式中 \(Z=\sum_x e^{-E(x)}\) ,对x进行求导非常困难，因此通过采样方法获得近似值。

因此采用玻尔兹曼机实现，但是BM方法计算量非常大，后来使用RBM模型,在层内无联系。

能量函数意义 那就是定义一个合适的COST函数，而这个合适的COST可以从各种物理化学模型 中来，能量函数就是热力学中用过来的，整体的能量函数值越小，系统趋于稳定。 能量函数的定义历史

限制玻尔兹曼机

限制玻尔兹曼机是一种特殊形式的马尔科夫场，可视层和隐含层不断进行交替迭代，趋于稳定。它输入和输出都是0,1 ，为了方便计算，假设可视层和隐藏层都是满足相互独立，有：

\[\begin{split}\begin{array} p(h|v)= \prod_i p(h_i|v)\\ p(v|h)= \prod_j p(v_j|h)\\ \end{array}\end{split}\]

在v and h没有概率的情况下，使用能量函数来表示概率变量的概率密度：其中变量v and h的能量函数可以表示为：

\[E(\bf{v},\bf{h})=-\sum_{i\in pixels}b_iv_i-\sum_{j \in features}b_j h_j -\sum_{i,j}v_i h_j w_{ij}\]

RBM中使用两层，首先估计隐藏层的概率，然后用随机概率判断隐藏层发生的概率。 这个有吗？

对应的自由能量函数（就是前面的能量模型（对所有每个分量的能量相加、取log））：

\[F(v) = - b\prime v - \sum\limits_i {\log \sum\limits_{{h_i}} {{e^{{h_i}({c_i} + {{\bf{W}}_i}v)}}} }\]

对上式中的h和v进行求导，得到：

隐藏层计算 decoding：

\[h_j=\sigma(b_j+\sum_i v_i w_{ij})\]

可视层计算 encoding：

\[v_i=\sigma(b_i+\sum_j h_j w_{ij})\]

用能量函数对 \(w_{ij}\) 求导，得到：

\[\Delta w_{ij}=\varepsilon (<v_i h_j>_{data}-<v_i h_j>_{recon})\]

其中data是原始输入数据，recon是重构的数据，同样的方法更新 \(b_i\) and \(b_j\) 。

Gibbs 采样

Gibbs采样是基于马尔科夫链蒙特卡罗（MCMC）的采样方法， 就是当我们无法得到关于X的联合概率密度P(x)，可以利用条件马尔科夫条件概率密度来逼近。随着采样次数n的增加，随机变量 \([x_1(n),x_2(n),...x_K(n)]\) 的概率分布以n的几何级数的速度收敛于X的联合概率密度P(X).

因此在执行时，用一个训练样本初始化可见层的状态 \(v_0\) ，交替进行如下采样：

\[\begin{split}h_0\sim P(h|v_0), v_1\sim P(v|h_0),\\ h_1\sim P(h|v_1), v_2\sim P(v|h_1),\\ ....,v_{k+1}\sim P(P(v|h_1))\end{split}\]

对比散度算法

尽管采用GIbbs可以获得联合概率密度，但是对数似然方法，需要较大的采样步数才能保证采样样本服从目标分布，尤其是观测数据的维度比较高时。因此hinton 在2002 提出对比散度方法，只需要k=1步Gibbs 采样便可得到足够的近似。（我想是gibbs采样和梯度方法的结合吧），首先估计出 \(P(h_{1j}=1|v_1) and P(v_{2i}=1|h_1)\) , 进而产生一个可见层的重构。然后代入能量度函数更新 \(w, b\) and \(\alpha\) 。

HMC模型

HMC模型采样通过动力学方法来获得Hamiltonian 被定位为自身能量和动力学之和：

\[H(s,\phi)=E(s)+K(\phi)=E(s)+\frac{1}{2}\sum_i\phi_i^2\]

其中s位置向量， \(\phi\) 是速度向量。

HMC通过正则分布采样得到：

\[p(s,\phi)=\frac{1}{Z}exp(-H(s,\phi))=p(s)p(\phi)\]

对s and \(\phi\) 求导得到：

\[\frac {ds_i}{dt}=\frac{\partialＨ}{\partial \phi}=\phi_i\]
\[\frac {d \phi}{dt}=-\frac{\partial H}{\partial s_i}= -\frac{\partial E}{\partial s_i}\]

leap-frog算法首先使用马尔科夫链，蛙跳速度跳过t时刻的位置而得到 \(t+0.5\delta t\) 的速度值，而位置跳过 \(t+0.5\delta t\) 的速度值而得到 \(t+\delta t\) 的位置值。应该是更新速度比较快。详细参考[[http://clzx.cqjtu.edu.cn/Upload/news/20111108215347281.pdf][分子动力学模拟]]

对于有限次采样导致变量有可能是不可逆的。因此通过Metropolis判断accept/reject 概率：

\[Pacc(\chi,\chi1)=min(1,\frac{exp(-H(s1,\phi1))}{exp(-H(s,\phi))})\]

Deep Belief Networks深信度网络

DBM是多层RBM。首先使用多层连接的RBM，最后一层使用BP网络(全局性最优的算法)，使用后向反馈对前面的隐含层进行微调。

参考

  1. http://blog.csdn.net/chlele0105/article/details/17309491}{能量模型(EBM)、限制波尔兹曼机(RBM)}
  2. http://blog.csdn.net/mytestmy/article/details/9150213}{深度学习读书笔记之RBM （限制波尔兹曼机}
  3. http://blog.sina.com.cn/s/blog_890c6aa301010oks.html}{关于数学,关于Learning的一些问题HMC}
  4. http://www.docin.com/p-558753215.html 分子动力学和蒙特卡洛模拟
  5. http://blog.csdn.net/chlele0105/article/details/17251971 RBM（限制玻尔兹曼机）、DBN（深度信念网络）介绍
  6. http://blog.csdn.net/yangyangliangliang/article/details/20644853 深度信念网络（DBN）
  7. http://www.cnblogs.com/daniel-D/archive/2013/06/03/3116278.html 反向传导网络BP算法
\[(a + b)^2 = a^2 + b^2 (a + b)^3 = a^3 + b^3\]

SOM 自组织映射

_images/unspuerviselearning.png

这个正是自己一直在到思考的网络模式，神经元之间的学习竞争模式，并且都一个都是自主的，并且每一层神经元也应该是相互独立或者正交的，每一层变换都看成输入空间的变换。

Self Organizing Maps: Fundamentals

主要是非监督原则，主要是一些聚类算法。或者采用测策，例如DL的那些超参数，可以用一些统计方法来得到。关键是要让算法自我闭合。算法能够从自身的博弈中学习。 这个对于一般人来说可能比较慢，但是对于机器来说，应该是很适合的方法。

这些图形的创造方法,原来都是曲线来表示，如果我们采用一种颜色的映射，然后将其用颜色，而非曲线表示，将会显示出来更多的信息。然后再利用图像处理的方法，来自动分割。 https://www.visualcinnamon.com/2013/07/self-organizing-maps-creating-hexagonal.html

而我们需要就是各种中数值转换模型。

最简单的映射，那就是曲线映射，颜色映射，或者一个动力物理模型的参数输入的映射。

SOM的图生成例子 http://www.ai-junkie.com/ann/som/som1.html

元胞机的池计算，把输入随机映射到元胞机的初始状态，非线性的操作通过元胞机的规则来进行。

既然是随机映射，就是矩阵乘法，就相当于每一个人记忆方式是不一样的，随机也就是随便找了一个人的思维模式。而己。 那么能否采用规则是滤波，然后是抽象。这样就有点像小波变换。例如只要达到相应的层数就行。

一种新式的网络结构， 线性矩阵来表示，线性用元素本身的更新，例如各种范数与导数来表示。

线性组合有什么好处，那就是解决一种潜在优先级，例如按字典排序，就注定了1在2前面。 如何解决这个问题呢，那就是利用w*b.添加一个权重。 这样就可以好的自然胜出。

但是按照常规的线性迭代速度又很慢，那么又能不能直接用指数级的步进速度呢。

是不是可以给出标准，来计算组间距离，然后再根据样本，来计算组内矩离。 是不是就是那个高斯过程。来根据这个来寻找映射关系。 中心点，又相当于不动点。 相当于多大的空间进行10等分。然后如何映射这种等分。

然后就是调整其各个值的比重了。 对了可以W*b.换成2^w*b.这样不是就加速计算。同时也保证了单调线性的问题。

增强学习

对于简单的分类的问题，我们可以直接用DL这种监督学习。 对于没有办法直接产生label,或者本身的label就像难以有结构化的描述时怎么办呢。 一个办法，那就是增强学习，传统的增强学习就是State,Action,reward之间的转换.

  1. 原来的label变成了 State, 是可以用一堆向量来表示。
  2. 原来的forward 就变成长了现在 Action.
  3. 原来的loss函数，现在变成reward 函数。

相当于这些通用化之后就是capsule 网络。

这样离DL的核心更进了一步。 DL可以的输出去掉active函数就是向量或者feature. 同时DL是可以模拟任何函数，而函数的本质就是映射，所以DL也就是拟合各种映应的。 而传统 Q,A 组合，本身也是会产生组合爆炸的。只能针对比较小的问题。

也就是任何一个 A->B, y=f(x), 任何关系(A,B) 我们可以用 \(f(\thea,A,B)\) 来模拟。

而DQL就是利用DL 通过 feature + 参数来拟合，Value函数与Q函数。这也正是AlphaGO所采用的方法。

AutoML则是进一步，包括超参数也变成了网络的一部分，也就是现在AlphaZero,AutoML的功能。

_images/rl.png

/mnt/c/git/DeepLearningOnGPU/source/Stage_2/toplogyStructure

本质就是一种试错学习法。当然可以是单步的试错，也可以多步回合制的试错。 介于监督学习与非监督学习之间。

_images/RL4.png

一种是对环境无知状态的学习，也就是瞎摸形式，主要依赖环境的反馈来学习， 另一种有模型的学习，这个有点偏向迁移学习。

各种方法的不同，主要是更新机制的不同。对于传统的神经网络，所有的反馈是需要我们来设计的， 而我们添加环境，这样环境会直接给出一些反馈。而不是再需要人为的设计反馈。

当然学习方法，也有offline/online,对于能够实时cost计算当然online可能会快一些。 对于一些需要多步的，offline,就可以会方便。这个就像敏捷开发，每一次选择一个模块集来实现。 然后选择最好的。然后再决定一步的开发。

Q-Learning

_images/q4.png

Q-Learning

  1. Agent
  2. State S
  3. Environment
  4. Reward
  5. action A

传统的action,reword模式解空间太大，现在都是采用增强学习模式，每一个部分都采用DL来实现。

而alphaGo就是采用的增强学习模式。而openai,elf,这些库都是用来研究RL的平台。

难点是如何定义reword,是单步的，一步回合制的。回合制是需要多步回逆的。也可以说是A*算法的，DL化。

\[Q (state， action) = R(state， action) + gamma * Max[Q(next state， all actions)]\]

简单的说那就是模仿学习。关键是如何正确的给出实时的反馈。 因为最简单的失败可能需要多步之后才能给出，这样就需要马尔科夫链之类的反馈机制。

主要利用应用领域:

  1. 游戏理论与多主体交互
  2. 机器人
  3. 电脑网络
  4. 车载导航
  5. 医学
  6. 工业物流

马尔科夫决策过程

  1. 状态集 S
  2. 协作集 A
  3. 奖励函数 R
  4. 策略 \(\pi\)
  5. 价值,V

基本理论

  1. DP 动态编程
  2. Monte Carlo 蒙特卡洛方法
  3. Temproal-Difference 时分法
  4. Q-Learning off-policy TD
  5. Sarsa on-policy TD
  6. R-Learning
  7. Policy Search/Gradient
  8. Hierarchical RL

Actor-Critic的方法，是采用的两头凑的方法。

斯坦福大学&DeepMind联合提出机器人控制新方法，RL+IL端到端地学习视觉运动策略

https://mp.weixin.qq.com/s/To3pnx1hVq_4p7UnQVMw9A

如果这个能大大加块的话，也就是我们不需要写代码来控制机制人了，而是直接演示与以及让机器人来看视频来学会做一件事情。

  1. CollectionDemonstrations
  2. Training in simulation
  3. Running on real robot

并且把演示分段成独立的子单元，可以大大加块训练的速度。同时也为开发升级新型机器人的技能提供了有效的方法。

收集视频demo,然后在物理引擎中进行模拟，然后sim2real到真实的机器上。 这个真机与模拟机的gap还是需要更好的方法来去除的。

难点在 训练极不稳定， https://blog.evjang.com/2018/01/exp-train-gen-zh-hans.html

首先我们需要模型可以从观察和实验中积极推理世界基本规律。符号推理(symbolic reasoning)和因果推理(causal inference)看起来已经是成熟的研究了， 但是对任何一种无监督学习可能都有帮助。 我想起了人类通过逻辑推理系统(数学)推导宇宙物理规律来理解天体运行。有趣的是， 在哥白尼的革命之前， 人类最初可能依赖某种贝叶斯式的启发(“迷信”)， 当我们发现经典力学以后， 这些”贝叶斯”式的模型就被抛弃了。

泛函网络

它在种个神经元之间的连接没有权值，并且神经元函数不是固定的，而是可学习的，通常是一个给定的基函数族的集合。可根据特定的问题，选择不同基函数。 基于泛函网络的多维函数逼近理论及学习算法.pdf

网络的层数与结构是根据问题的模型来的，盲目增加层数，就会使过拟合问题更加严重。太少又不足以表达。应该变成一个动态的网络。：:

Capsules net

整个网络实现由Conv实现了建模，而Primate进行最基本的feature抽取变成，而在digits层达到了 整个空间机的构建，而然后又经过三层的全连接，进行重构,来检验digits的效果。并实现n个目标的同时实别。 到digits,是实现单一目标的识别，而到重构层则实现了多个目标的实别。 从0->1-N 的过程。并且GAN的升级版。

机器之心 对于这篇论文 [3] 进行了解读 [1] . 其本质核心那就是把原来的二层的网结构。变成三层的网络。

原来网络结构 神经元->层->多层。变成了现在的神经元->Capsules->级->多级。

这样把原来层与层之间的固定关系连接关系。变成动态的。并且根据一定的协议来连接。

这就给各种不同连接协议了，就像代表了搜索空间找到一条合适的路径。在这些路径还能找到一条更好的路径。

这个相当于神经元的结构更加灵活化，基本上可以看做是向量化面向对象技术，但是这个继承关系是通过类似于 聚类的功能，自动学习出来的。

只需要更少的数据，就能得到更高的识别率，同时能够CNN识别重叠图像的问题。

这个也就进一步融合了传统知识与神经网络。通过Capule 的定义，是不是每一个Capule的都有相对明确的物理意义了，而层与层之间的连接是通过动态学习出来，而不像之前的一切都是无明确意义的参数而己。把Capsule当做一个向量化的对象或者结构体可能更恰当。 并且层层与连接也都是动态学习。出来。

_images/routingAlgorithm.png

[2] 机器之芯给出一个实现。

其实相当于cnn的两层合成了一层。把Pooling层当做一个activate函数了。这样就把原来神经元结构给泛化了。 为什么激活函数要生成一个数值呢，其实就当于高维一点，在低维空间里一个面或者线。用点线面体理论来解决可能会更好。 主要是原来的激活函数只能是一个数值，现在pooling的输出可以是一个向量了. 这个不正是聚类抽象的过程。 实现了低维向高维转化的通路。所以激活函数，本质就是抽象压缩的一个过程。只不过最初的形式太单一了。给不出 很好的物理意义。进一步pooling再到capsule这一步，就体现了抽象压缩的过程。非线性那就是那质变的过程。 现在终于抽象找到了一个很好的数学定义了，抽象的过程，可以用那些非线性过程来定义。而一些统计函数本身就是 很不错的非线性函数模型。

而capsule模型可以替代了残差网络了。

关键是在层与层的连接加入动态协商的过程，正因这个机制加入使利用先验知识能为了可能。 有点类似于AlphaGo的多张网，网与网之间的连接。

如何实现高低维的转换就是在激活函数上实现的。直接把投影变换当做激活函数。这样就可以实现立体实识别。

另换一种那就是上下层之间的连接，我们可以利用相关性。

而每一层capsule层的关系，就像贝叶斯理论来指导。总合其为1。

实现流程

  1. 大的工作流程

    _images/workflow_1.png _images/workflow_2.png 
root@48d5c7680565:/opt/pytorch/pytorch-capsule# CapsuleNetwork (
  (conv1): CapsuleConvLayer (
    (conv0): Conv2d(1, 256, kernel_size=(9, 9), stride=(1, 1), bias=False)
    (relu): ReLU (inplace)
  )
  (primary): CapsuleLayer (
    (unit_0): ConvUnit (
      (conv0): Conv2d(256, 32, kernel_size=(9, 9), stride=(2, 2), bias=False)
    )
    (unit_1): ConvUnit (
      (conv0): Conv2d(256, 32, kernel_size=(9, 9), stride=(2, 2), bias=False)
    )
    (unit_2): ConvUnit (
      (conv0): Conv2d(256, 32, kernel_size=(9, 9), stride=(2, 2), bias=False)
    )
    (unit_3): ConvUnit (
      (conv0): Conv2d(256, 32, kernel_size=(9, 9), stride=(2, 2), bias=False)
    )
    (unit_4): ConvUnit (
      (conv0): Conv2d(256, 32, kernel_size=(9, 9), stride=(2, 2), bias=False)
    )
    (unit_5): ConvUnit (
      (conv0): Conv2d(256, 32, kernel_size=(9, 9), stride=(2, 2), bias=False)
    )
    (unit_6): ConvUnit (
      (conv0): Conv2d(256, 32, kernel_size=(9, 9), stride=(2, 2), bias=False)
    )
    (unit_7): ConvUnit (
      (conv0): Conv2d(256, 32, kernel_size=(9, 9), stride=(2, 2), bias=False)
    )
  )
  (digits): CapsuleLayer (
  )
  (reconstruct0): Linear (160 -> 522)
  (reconstruct1): Linear (522 -> 1176)
  (reconstruct2): Linear (1176 -> 784)
  (relu): ReLU (inplace)
  (sigmoid): Sigmoid ()
)

  1. 数据流

    • [128,1,28,80]

      digraph Image { graph [layout=dot rankdir=LR,labeljust=1] node [shape=record,penwdith=2,fontsize=25]; subgraph cluster_input { label = "batch:1-128"; fontsize = 40; bgcolor="purple:pink"; subgraph cluster_chanel { label = "channel:1"; bgcolor = "blue:cyan"; image[label="28*28" fillcolor="red:yellow",style="filled"]; } } }
    • 经过第一层的conv+relu之后，256 kernel, 就形成了。 [128,256,20,20]
    • 然后进入primate layer. 然后是这个[128,256,20,20]进入8个并行的，并且每一个unit有32kernel. 然后再把这些kernel squash. 8个[128,32,6,6], [batch,channel,width,height] -> [batch,unit,channel,width,height] [128,8,32,6,6] 然后再压平变成[batch,unit,features]
    • Squash 就是在这些features 这个来做。
    • Digists层，相当于10个onehot vector,每一个向量具有16维，而后面的全连接，则是其参数矩阵。 来解决一个还是二个的映射组合。

这个就像人的认识过程，先做一个预处理，从大量的重复出得到pattern,然后这些pattern最小化。 Primary Caspsules 相当于是经验，一些先验知识与元认知。

  1. squish 的图形

    _images/squash.png _images/squash_wolfram.png

  2. 而累积的过程，就是靠内积空间来实现的。方向越近，值越大。不相关时是垂直。结果为0。

  1. W 的更新

进一步的实验

  1. 路由信息 - 改用把softmax 改为六siga原则，取前六， - 采用遗传算法，取前几，后面强制零0，每一次的混合都加入随机。 - 改用EM应该是已经有人在用了。
  2. 把压缩变换成PCA呢。 - 用PCA进行判别。
  3. 参数矩阵，不为方阵。是不是就意味着一定有冗余。是不是可以进一步化简得到一个方阵的约束。

通过扭曲空间来执行数据分类，基于向量场的新型神经网络

https://mp.weixin.qq.com/s/lwvRz1jtv1aCBwL9W447_A

在这个篇论文中利用场论来构造神经网络，把场函数当做一个激活函数。这样就变成了一个扭曲的场的解释，就找到种现成的数据理论来进行解释了。

其实只要任何一个差分方程，微分方程的迭代式求解都可以变成一个网络结构。W就是参数，激活函数就是基本项。 cost函数变成对抗网络中discrimiator可以变成 条件约束。例如把KKT等等约束都变成一个cost函数。

并且深度网络层数就相当于空间的维度，这样的我们可以充分利用高维空间降维，各种理论的可解释性来理解深度网络 。

另外，高维空间里，简单线性算法的潜力，还是非常大的，比如线性的LPP算法，竟然可以获得和非线性manufold learning类似的效果，也是稀奇了。DNN也可以看成是多个LPP搭起来的，加个限幅函数来减少小概率事件影响

深度网络的设计与可视化工具

简介与目标

能够使用常见的framework。

  1. 快速的搭建环境
    • 从源码编译,可以采用并行编译系统，以及Clang来加速
    • 快速的部署，能够使用docker来进行部署
  2. 能够扩展开发工具本身
    • 快速的进行trace，以及anlyasis进行各种可视化分析
    • 快速的调试
    • 并且能够优化
  3. model本身的导入与导出
  4. model模型结构层极模型可视化
  5. model的简化
  6. 实现持续的CI
    • 持续的训练
    • 持续的交付
    • 持续的反馈
    • 持续的实验，也就是GIT的流程深度化，在同一个基线版本上，同时开始尽可能多的试验。然后就是不断的集成。然后rebase.

工具

对于神经网络的应用，各种网络之间的适配那就是矩阵乘，以及如何把种数据转化为矩阵。 #. 神经网络设计工具：（CAFFE，theao）。 #. 可视化：信息流的可视化（编码），训练时的可视化(过拟合，迭代下降)。 #. 网络拓扑本身的可视化。

Comparison with Other Frameworks

https://raw.githubusercontent.com/chainer/chainer/396bc3ee8a781463734c7dfac4e892ee6f578dc5/docs/source/comparison.rst

A table for quick comparison

This table compares Chainer with other actively developed deep learning frameworks. Content is current as of July 2017.

    Chainer PyTorch TensorFlow Theano-based Caffe1/Caffe2 Torch7 MXNet DyNet PaddlePaddle DL4J CNTK neon Knet.jl Darknet Thinc
Basics Language Python Python Python Python Python/C++/ MATLAB LuaJIT Python/others Python/C++ Python/C++ Java BrainScript/ Python/C++ Python Julia C Python
  Approach define-by-run define-by-run symbolic autograd symbolic autograd static static/ manual grads symbolic autograd/ manual grads/ define-by-run [1] define-by-run symbolic autograd static/ manual grads/ symbolic autograd [2] static/ symbolic autograd static/ symbolic autograd [3] define-by-run static callback-based define-by-run
  CPU backend package NumPy TH Eigen NumPy   TH mshadow Eigen   ND4J   NumPy Julia   NumPy
  GPU backend package CuPy THC Eigen libgpuarray   THC mshadow Eigen   ND4J   neon KnetArrays   CuPy
  Primary sponsor Preferred Networks Facebook Google MILA Facebook Facebook Amazon/Apache CMU Baidu Skymind Microsoft Intel Nervana Koç University Joe Redmon Explosion AI
NNs CNNs full full full full full full full partial full full full full partial full none
  RNNs full full full full partial full full full full full full partial partial partial partial
  Reverse-mode autograd Y Y Y Y   torch-autograd Y Y Y   Y ngraph Y   with closures
  Forward-mode autograd     tensorflow-forward-ad Y                      
  Higher-order grads   Y Y Y                 Y    
  Variable-length loops native native while_loop scan RNNs only native 2017 native RNNs only none dynamic axis none native none native
  Different architectures per batch native native fold     torch-autograd MinPy native         native   native
Performance cuDNN support full full partial partial full full full partial full partial full N/A [4]   partial  
  CPU/GPU generic backend Y Y       Y Y Y Y Y Y Y Y   Y
  Multi-GPU data parallelism Y Y Y Y Y Y Y   Y Y Y Y Y Y  
  Multi-GPU model parallelism Y Y Y Y Y Y Y   Y   Y Y      
  Multiprocessing [5] full partial           full              
  Distributed training ChainerMN THD Y   2017 torch-distlearn Y   Y Spark Y Y      
Misc Runtime debugging debug mode, typechecking, pdb pdb tfdbg       Monitor pdb   Java debuggers cntk.debugging   Gallium.jl gdb pdb
  Trainer abstraction native tnt   Blocks, Lasagne, Keras native torchnet     native native native native     native
  Reporter abstraction native tnt native     torchnet native     native native        
  Web interface     TensorBoard             DL4J-UI   Nervana Cloud      
  Graph compilation engine   2017 XLA   2017   NNVM         ngraph      
[1]Define-by-run is in development as of June 2017 and tracked in dmlc/mxnet#5705. It is also possible using the much slower MinPy extension.
[2]Symbolic autograd is in development as of June 2017 and tracked in deeplearning4j/nd4j#1750.
[3]Symbolic autograd is available only with ngraph backend (experimental).
[4]Nervana provides kernels that are meant to compete with cuDNN.
[5]Multiprocessing provides a significant performance improvement only for frameworks that use Python at runtime.

NVIDIA GIGITS

https://github.com/NVIDIA/DIGITS

  1. install CUDA
  2. install nvidia-machine-learning-repo-ubuntu1604_1.0.0-1_amd64.deb
  3. pip install
# example location - can be customized
DIGITS_ROOT=~/digits
git clone https://github.com/NVIDIA/DIGITS.git $DIGITS_ROOT
sudo pip install -r $DIGITS_ROOT/requirements.txt
sudo pip install -e $DIGITS_ROOT
./digits-devserver

https://github.com/NVIDIA/DIGITS/blob/master/docs/BuildDigits.md

caffe

Linux环境的准备

主要是根据 caffe install manual 来进行的。主要库的依赖可以用这个 https://github.com/gwli/StudyNote/blob/master/caffe/install/prepare.py 来完成安装。

nvidia driver 的安装

  1. 从 官网 下载最新driver,

  2. 进入字符介面 tty1

    ctl+alt+F1

  3. 关掉 X windows.

    sudo service lightdm stop

  4. 安装driver.

    chmod +x installer.run;./installer.run

  5. 恢复 X windows.

    sudo service lightdm start

Note

正常的情况下installer会自动disable的自带的driver,如果失败的重起一下，重新执行installer就行了。

安装cuda-toolkit

这里从两种方式来安装，手动安装，或者使用 jetpack pro 只安装 host端的cuda-toolkit.

  1. 添加源

    $ dpkg -i cuda-repo-ubuntu1404_6.5_amd64.deb

  2. 安装 cuda toolkit

    $ sudo apt-get install -y cuda-toolkit-6-5

  3. 配置环境变量

      $ export PATH+=:/usr/local/cuda-6.5/bin/:
  $ LD_LIBRARY_PATH+= /usr/local/cuda-6.5/bin/lib:
  $ export LD_LIBRARY_PATH

.. note::

   也可以直接写.bashrc中就行，重启shell就行了。
相关库的安装

直接使用 https://github.com/gwli/StudyNote/blob/master/caffe/install/prepare.py 来完成就行了。

下面几个不常见库的说明

libs
Lib names Content Remark
google-glog google提供的一个C++的logging库 https://code.google.com/p/googl有e-glog/
protobuf-devel 性能更好的jason用于进程通信 相当于TCP/IP的包解析技术用在了进程通信IPC.
gflags 类似于getopt命令行处理接口 http://dreamrunner.org/blog/2014/03/09/gflags-jian-ming-shi-yong/
google snappy 一个高速的压缩库，http://www.infoq.com/cn/news/2011/04/Snappy  
google leveldb LevelDB is a fast key-value storage library written at Google that provides an ordered mapping from string keys to string values.，https://github.com/google/leveldb  
安装cudnn

  1. 从 ·https://developer.nvidia.com/cuDNN 下载 linux 官

  2. 解压安装

    $ tar -xzvf cudnn.tgz
$ mv cudnn /usr/local/cudnn

  3. 修改LD_LIBRARY_PATH

      LD_LIBRARY_PATH+=:/usr/local/cudnn:
  C_INCLUDE_PATH+=:/usr/local/cudnn:
  CPLUS_INCLUDE_PATH+=:/usr/local/cudnn:

  PATH+=:/usr/local/cuda-6.5/bin:
  LD_LIBRARY_PATH+=:/usr/local/cuda-6.5/lib64:
  LD_LIBRARY_PATH+=:/usr/local/cuda/cudnn:
  export LD_LIBRARY_PATH
  C_INCLUDE_PATH+=:/usr/local/cuda/cudnn:
  CPLUS_INCLUDE_PATH+=:/usr/local/cuda/cudnn:

由于采用 cudnn 的库与caffe兼容性问题，现在 caffe 与V1 是工作的。

一个快速灵活的办法，那就是link.

.. code-block:: bash

   ln -s  /usr/local/cudnn-6.5-linux-x64-v2-rc2/ /usr/local/cuda/cudnn
build

caffe 采用了大量的template,所以代码模式基本

digraph flow { template->code->"PIC so"-> "link to app"; }

  1. build the app

    make all |tee make.log

  2. build the test

    make test |tee test.log

  3. run the test

    make runtest |tee runtest.log

Note

cudnn-6.5-linux-R2-RC1 is compatible with caffe, cudnn-6.5-linux-R1 is good. 可以在这个https://groups.google.com/forum/#!forum/caffe-users 里找到这个问题

support python

  1. 安装依赖

    cd $caffe_root/python
for req in $(cat requirements.txt);do pip install $req; done

  2. installl scipy

there is miss requirment scipy this need fortrain compiler you can install it by

  1. install gfortran apt-get install gfortran-4.8
  2. make link due can’t find gfortran ln -s /usr/bin/gfortran-4.8 /usr/bin/gfortan

最简单的办法

apt-get install python-scipy

  1. 添加caffe to python lib

    export PYTHONPATH=/$caffe_root/python:$PYTHONPATH

  2. 生成文档

    1. install jekyll

      apt-get install jekyll doxygen texlive-full

深度学习

深度学习与前些年神经网络的区别，那就是网络层数要比以前多了。这样的话功能就大大加强了。

网络一组layer来组成，layer 又由一组node来组成，层与层之间联接是由forword与backwrod连接组成。每一层都solver，以及module. 而这里blobs 就是node. foward 用来把input -> output同时计算出 loss cost,而backword 而是根据loss cost来计算梯度来提取下一步w,b，优化到什么程度为止呢，取决于error 要求和iter numbers.

每一个小的神经网络连接再加上形成大的神经网络，就实现了脑的功能。

Blobs 是由包着数据本身（什么意思？），而数据本身四维的数组(Num,Channels,Height and Width) 有点类似于CUDA的Thread分配。Blobs更像是CUDA Array 的机制。Blobs统一管理CPU与GPU的内存。(n,k,h,w)正好每个线程计算输入都是由Blobs来的。输入传输，利用google proto来进传输。 Google Protocol Buffer 的使用和原理 google 这种机制就其名字一样，（把什么当作？）当作协议包来解析，就像网络包一样，每一个包不需要通用，只要自己能认识自己就行了。就像网络协议一样，只规定了协议包结构。就自然解析就容易了。无非两种TLV,并且进一步利用编码本身实现压缩，并且元编程实现类的自动化定义与实现。并且还支持动态编译JIT,这也就意味着没有只要有源码就行了。

同时Blobs,保存两种数据，一种是Data,一种是diff,简单的说Data是往前传，而diff计算梯度是往后传。

这个是把编码与元编程技术结合起来的。

caffe 这个神经网络还可以snapshotting与resume,这个就非常的方便。

深度网络

本质是一层一层向上抽象的过程。同时一个由无序到有序的过程。但是过程的路径又不指一条，就像人每个人的思维过程也是一样的。所以每一层的每个神经网络的抽象可以不同。并且再加上一顺序就会有各种各样的结果。到这个过程中就像需要有一个像分词库一样的东东。如果只是简单组合就能得到一属性，还是排列才能进行判定， 排列与组合是不同层次的判别路线。

深学习就是在解决如抽象概念这个难题。

caffe流程

caffe的设计原则与自己的原则一样的，分层的模块化的设计。把一个大大的问题不断的breakdown,变成几个已经解决的小问题。 #. 数据格式的转换，目前支持 lmdb,leveldb. #. 定义 network

digraph flow { Input->Forward->Output; Output->Backword->Input; }
  1. 定义 solver
  2. training
  3. testing

开发流程添加几个头文件与与源文件。然后实现setup,initial, resharp,forward,backword,然后就注册就行了。

数据的准备

在网络 里主要有 data_para 与 transform_para .

  1. from database levelDB or LMDB
  2. directly from memory
  3. from files on disk in HDF5
  4. common image formats

而预处理包括,通过指定 TransformationParameterS.

  1. mean subtraction,
  2. scaling
  3. random cropping
  4. mirroring

数据格式

key,value格式，leveldb,lmdm等等就是这种。

hdf5 用来层次化的数据格式，相当于面向对象结构串行化。 如果其看成是例如IP的解析则更容易理解，例如Mongo那种理解，就相当于TLV格式的包结构。 Hierarchical Data format http://en.wikipedia.org/wiki/Hierarchical_Data_Format.

深度学习和并行计算

早期的神经网络，因无法处理两层以上的网络，都是浅层的。目前的深度学习，因采取逐层预训练和全局微调策略，能够实现深层次的网络结构（目前通常需要10层以上的隐含层，才能够取得较好的建模效果），但实际上训练一层的神经网络是非常困难的。这是因为当前的深度学习网络中存在上百万、甚至是上千万的参数需要经过后向反馈来调整，并且深度学习需要大量的训练数据来确保分类和预测的准确性，也就意味着几百万甚至是几千万的输入数据需要运行在前向或者后向反馈中，因此计算量是非常巨大的。另一方面，深度学习由大量相同的、并行的神经元组成，能够并行映射到GPU中，能够提供巨大的计算加速。这里使用NVIDIA公司提供的深度学习平台：CAFFE。 实验已表明，当训练“reference imagenet”时， 并行计算能够获得10倍于intel ivyBridge CPU的加速。

NVIDIA cuDNN 是主要的深度学习GPU加速库，它提供深度学习中常用的操作。比如：卷积、池化、softmax、神经元激活（包括sigmoid、矫正线性器和Hyperbolic tangent ），当然这些函数都支持前向、后向传播，cuDNN主要是在以矩阵相乘的方面擅长，cuDNN特性定数据输出，支持可伸缩的维度定制， dimension ordering, striding and subregions for 对于四维张量。这些可伸缩性允许神经元积分，并且能够避免输入输出转换。

cuDNN是线程安全的，提供基于内容的APi，从而能够支持多线程和共用CUDA线程。使得开发者能够精确地使用多主线程和多GPU，控制库。确保GPU设备总是在一个特殊的主线程中使用。

cuDNN允许深度学习开发者能够掌握当前的状态并且能够把精力集中在应用和机器学习问题上，而不需要写额外的定制代码。cuDNN能够 在Windows和LInux OSes平台上。支持所有的NVIDIA GPU,从低端的GPU，比如Tegra k1 到高端的 Tesla K40. 当开发者使用cuDNN，能够确保得到目前的和未来的高性能，并且得益于GPU特性。

cuDNN是为了深度学习开发者，它非常易用，使得开发者无需知道CUDA。在CAFFE，深度学习使用基于本文的配置文件。使用CAFFE，使用定义神经网络的每一层，制定层的类型（包括数据、卷积和全连接）并且层提供他的输入。并且有类似的配置文件，定义怎样初始化神经网络参数以及训练的重复次数等等。

FC 与Conv 底层的实现都是通过GEMM来实现的，例如把几个kernel接成向量，并且组成矩阵然后再扔给GEMM来运算。 所以优化的其中一个方法，那就是调整矩阵的大小来实现GEMM的效率最大化。 http://yongyuan.name/blog/neural-network-layers-understanding.html

cudnn

cuda的deeplearning 库

流程本身与CUDA是一样的,数据格式可以改变access pattern可以尽可能利用cache来提高效率。 kernel本身计算模式的改变可以尽可能利用硬件资源。一个算法本身计算量可以大大的减少。 通过thread，L1,L2,register等等,以及 stream, cdn,cnp资源的分配来提高硬件的occupancy.

digraph flow { H2D -> "kernel exuection" -> D2H; }

目前为止，这是CUDA执行模式。各种库无非就在些基础上来进行进一步限定。

或者添加些help函数来实现实现自动的thread分配。并且把一些算法的kernel来实现一下， 并且更加上一些元编程把kernel的实现做一些自动的适配与优化。thrust都是这样干的。

checkCUDNN( cudnnConvolutionForward(cudnnHandle,
                                    &alpha,
                                    srcTensorDesc,
                                    srcData,
                                    filterDesc,
                                    conv.data_d,
                                    convDesc,
                                    algo,
                                    workSpace,
                                    sizeInBytes,
                                    &beta,
                                    dstTensorDesc,
                                    *dstData) );
  1. Convolution 的kerneldnn 自己实现了。
  2. srcTensorDesc,dstTensorDesc, 就是为描述资源的格式与大小方便后存储与对memory 以及kernel的thread的分配。
  3. 主要采用是四维的张量计算
  4. 所谓network其实就是一个cudnnCreate 一个cudaContext而己。用完之后是需要cudaDestroy的。 这样可以把数据保存显存里，然后方便多个kernel之间的计算减少D<=>H之间的传输而己。 可以使用 CUDA annalysis 对其进行分析。
  5. kernel中算法本身需要的参数

其余那就类似于 CUDA runtimeapi 一样，各种各样的get/set以及createhandle之类的东东了。

Theano

Theano

install note

  1. pip install Theano #. pip install numpy #. apt-get install python-scipy
  2. apt-get install libblas-dev #. apt-cache search blas

introduction

theano利用python的语法来实现了自己的语言。这个语言的特别之处，自己实现的用自己的，自己没有实现的就可以直接使用了python的，不过只是一个中间件语言，下层实现还是直接借用CPU与GPU的blas库。并且theano实现还是一个JIT编译器。它的主要特点那就是直接使用利用sympy以及自己的张量符号表达式来直接构造公式,在theano中公式与函数基本上可以直接化等号了。 并且theano还有自己的编译算法，它可以直接打印出依赖图，如何简化自己的逻辑图呢。

既然是语言，就要变量，循环，分支，函数。那theano中是如何实现这些的。

变量 类型两部分，基本类型本身另外那就是结构，例如tensor.dscalar,就是double类型的标量

b w i l f d c byte word int long int float double compex  
scalar vector matrix                        

循环，又分为map/reduce两种。而在theano中采用了scan 来描述。这样是为了能够让theano识别for,只是其返回值，其中update是要function来用，另外是做计算结果来使用的。

分支 对于计算模型循环要远远大于分支，并且在大量的matrix不存在分支模型。所以在计算型的语言中分支会用的比较少，例如CG编程中主要是计算。

函数 直接用表达式来构造函数，但是没有看到其作用域的使用，没有直接声明函数的{}范围，其实直接使用引用传递，与可以实现 多值反回，就可以实现n对n的输出。正常的函数输出是n对1，n对n的输出，那就可以引用传递。在python 可以使用global来实现。 theano中函数声明没有传统语言的方式，直接符号表达式使用来当做函数体。当然这个过程它也会做一些符号计算。帮你做公式推导。

theano.function这个是编译指令，然后返回一个编译后object,就像shaderobject. 函数输入，解决了python中没有引用传递的问题，如果你把变量声明成shared类型，那就是引用传递了。也可以用borrow 的属性来直接使用引用传递。但保存一些python中好的习惯，参数可以有默认的值。格式Param(y,default=1)格式，也可以name/value来赋值。 函数体的可以直接使用输出表达式，也可以用update,given来指定。update 是用来指定如何操作shared变量，而givens,用来变量替换的。 theano这种方式可以复用达到每一条指令的颗粒度，即因为在没有编译之前都是符号表达式。

函数输出可以是多值输出，这可以任意的中间状态输出。

theano 结构

现在明白了theano中对于优化问题的固定的结构，首先declare the variable, then compile the data ,input, outputs, then tain the data; finally look at the results.

declare variable->construct the expression graph-> compile->train->show the results

+theano graph

在调试的时候，我们必须知道什么是graph，包产variable，op等，首先输出的操作数，y.owner.op.name 对于函数输出y.maker.fgraph.outputs，一个函数形式，y.maker.fgraph.inputs是[x, w, b]，输入tensorvariable。

好像整个都是以函数的输出就是函数 theano.function{outputs} 中输出的类型就是function，无法得到实际数据。

多次迭代共同改变的是w的值。调节的是x，y 不断的输入，现在明白了为什么w，b是全局变量。

这里的prediction 好像没有什么用，只是预测。

  1. theano学习指南 明天看一下
  2. Intel MKL基础(1)了解MKL、MKL资源 CUDA 是不是有类似的库
  3. matlab

math compiler 公式编译器，原理你把公式写出来，编译器就会把公式化简然后转化为高性能代码来进行计算。因为各个平台都会有各自己的高性能计算库，例如blas,lapack,intel的mkl,还有nv的cuda等等都是有现成了运算库，然后我们需要把算法以及矩阵运算，然后把分块分工，然后分配给这些计算单元并行。看来编译语法分析是重点。自己一定要自己实现一个解析器。

– Main.GangweiLi - 22 Jan 2014

张量计算 这个是theano这个库所主要实现的功能，这个是sympy所没有实现的功能。另外的那就是公式编译器。其通过实现一个图，采用利用图论的最短路径来进行化简。

– Main.GangweiLi - 26 Jan 2014

theano利用自己的内存分配机制，例如share型，一个独立的类型，就像语言一样有register型，对于异构编程的时候，会有对应的内存，例如CPU内存，GPU内存，还有共享区域。

– Main.GangweiLi - 26 Jan 2014

我是不是要实现一门自己的语言，然后把它转化成各种语言，以后我只写我自己的语言，然后再进行转换。

– Main.GangweiLi - 26 Jan 2014

NVCC 这个封装与python自身的那个 destutil 差不多，自己封装一个toolchain for NVCC, 当然要写配置文件，分析配置文件直接使用的是python 的configparser 库，看来自己以后可以直接这个了。

– Main.GangweiLi - 07 Mar 2014

优化 对于不认识的新op是不会进行优化的。

– Main.GangweiLi - 07 Mar 2014

tensorflow

Installation

  1. check GPU Capacity

    ARCH CAPACITY
    Kepler 3.0
    Maxwell 5.0/5.2
    Pas  
    Volta  

  2. install cuda >8.0

    dpkg -i cuda-repo*8.0*
apt update
apt install cuda-toolkit

  3. install cudnn

    dpkg -i libcudnn-repo*8.0*
apt update
apt install libcudnn

  4. pip install tensorflow-gpu

_images/overall.png
  1. You can build any kind of customer model and use Theano/TF,as long as it’s differentiable.

无监督学习类假于autoencoders,Restricted Boltzmann Machines

很好的资源库: https://github.com/fendouai/Awesome-TensorFlow-Chinese

不错的基本原理的书: https://github.com/exacity/deeplearningbook-chinese R01 是Tensorflow的中文社区， tensorflow采用数据流图表来描述数学计算。

节点用来表示施加的数学操作，也可以表示数据输入的起点或输出的终点。或者是持久的变量，tensor.

而线用来输入输出之间的关系。

context -> ssession. tensor 来表示数据， 通过变量 维护状态 用feed与fetch 可以为任意操作赋值 与取值。

Placeholder与tf.variable的区别

神经网络库实现的难点，一个是计算的并行化，那另一个那就是variable空间的引用。也就决定了网络的拓扑的如何连线。

如何共享变量

就是通过变量的命名空间，来实现的,http://wiki.jikexueyuan.com/project/tensorflow-zh/how_tos/variable_scope.html

tf.variable_scope 定义一个命名空间，tf.get_variable就在当前空间下搜索该变量。 如果想复用，就得scope.reuse_variables() 来实现

def conv_relu(input,kernel_shape,bias_shape):
     weights = tf.get_variable("weights",kernel_shape,initializer=tf.random_normal_initializer())
     biases  = tf.get_veriable("biases",bias_shape,initializer=tf.random_normal_initializer())
     conv = tf.nn.conv2d(input,weights,strides=[1,1,1,1],padding='SAME')
     return tf.nn.relu(conv,biases)


def my_image_filter(input_images):
    with tf.variable_scope('conv1'):
         # variable will be created with name "conv1/weights","conv1/biases"
         relu1 = conv_relu(input_images,[5,5,32,32],[32])
    with tf.variable_scope('conv2'):
         # variable will be created with name "conv2/weights","conv2/biases"
         return = conv_relu(relu1,[5,5,32,32],[32])


result1 = my_image_filter(image1)
result1 = my_image_filter(image2)
#Raised varibleError(.. conv1/weights already existes)

with tf.variable_scope("image_filters") as scope:
     result1 = my_image_filter(image1)
     scope.reuse_variables()
     result2 = my_image_filter(image2)

tf.variable_op_scope tf.op_scope tf.name_scope tf.variable_scope

tf.concat

t1 = [[1,2,3],[4,5,6]]
t2 = [[7,8,9],[10,11,12]]
#concat_deim 0 表示行，1表示列
tf.concat([t1,t2],0) ==> [[1,2,3,],[4,5,6],[7,8,9],[10,11,12]]
tf.concat([t1,t2],1) ==>[[1,2,3,7,8,9],4,5,6,10,11,12]]
# < 1.0
tf.concat(0,[t1,t2]) ==> [[1,2,3,],[4,5,6],[7,8,9],[10,11,12]]

各种矩阵的形式转换

对于一个默认的列表 [1,2,3,5,6,7,8,9]，变成矩阵有几种变法:

  1. [[1,2,3,4,5,6,7,8,9]] 也就是1 * 9 tf.expand_dims(list,0)

#. [[1],[2],[3],[4],[5],[6],[7],[8],[9]] 9* 1 tf.expand_dim(list,1) #. 要变成一个矩阵，就相当于列表的列表，[[1,2,3,4,5,6,7]] 这在tensorflow中叫expand_dims。

网络的基本组成

现在基本上所有神经网络库都采用符号计算来进行拓扑的构造。所以要想研究新的网络拓扑，添加新原语，就得能够添加新的原语。 也就是能够扩展基本原语。

tf.Variable
主要在于一些可训练变量（trainable variables），比如模型的权重（weights，W）或者偏执值（bias）； 声明时，必须提供初始值；
tf.placeholder
用于得到传递进来的真实的训练样本： 不必指定初始值，可在运行时，通过 Session.run 的函数的 feed_dict 参数指定；
tf.name_scope
可以用来表示层的概念

tf.run 就相当于求值替换执行。用 eval 用这词就更容易理解了。 并且指定了返回值。

tf.train.Saver
用于何存变量

而矩阵乘法可以用来表征 n*m 的网络连接。 #. 初始化变量 #. 网络拓扑 #. Loss函数 #. 优化方法

global_steps 用于全局的计数器

tensorboard 的用法

http://ischlag.github.io/2016/06/04/how-to-use-tensorboard/

#Tensorflow summaries are essentially logs. And in order to write logs we need a log writer (or what it is called in tensorflow) a SummaryWriter. So for starters, we’ll add the following line before our train loop.

writer = tf.train.SummaryWriter(logs_path, graph=tf.get_default_graph())
#This will create a log folder and save the graph structure. We can now start tensorboard.
tensorboard --logdir=run1:/tmp/tensorflow/ --port 6006

tensorsummary 也是Op,也是需要在session里更新他的。

TensorFlow四种Cross Entropy算法实现和应用

http://www.weibo.com/ttarticle/p/show?id=2309404047468714166594

基本组成
  1. 变量
  • tf.Variable

用点 tensorflow与thenao基本是一致的，都是利用图来构建计算模型，这些在python里实现，而真正的计算独立来实现的。 python 只是相当于一个控制台而己。

这样结构有点类似于符号计算的味道了。 在tensorflow.

变量就相当于符号。 各种placeholader,以及各种运算都符号化了。

这也正是编程语言的下一个趋势，算法的描述。

先构建computation graph,然后初始化，再开始运行。

根据神经网络的结构来，

源码解读

R02 已经做了源码的解读，基本实现原理

  1. 脚本的语言与c/c++ 的接口用 SWIG来实现，这就意味着支持多种脚本
  2. 构建工具，
    • linux 采用bazel 的并行构建工具，每一个目录为一个包为基本单位，进行依赖计算。
    • Windows 也可以用 CMake 来时行编译
  3. 矩阵计算采用EIGEN来进行处理或者调用Nvidia-cublas来加速计算
  4. 结构化数据存储结构来用protobuf来定义

基本步骤

  1. Create the Model

    x = tf.placeholder(tf.float32,[None,784])
W = tf.Variable(tf.zeros([784,10]))
b = tf.Variable(tf.zeros([10]))
y = tf.matmul(x,W) + b

  2. Define Target

    y_ = tf.placeholder(tf.float32,[None,10])

  3. Define Loss function and Optimizer

    cross_entropy = tf.reduce_mean( tf.nn.softmax_cross_entropy_with_logits(label=y_,logits=y))
train_step = tf.train.GradientDescentOptimizer(0.5).minimize(cross_entropy)

  4. Define the Session and Initialise Variable

    sess = tf.InteractiveSession()
tf.global_variables_initializer().run()

  5. Train the Model

    for _ in range(1000):
    batch_xs,batch_ys = mnist.train.next_batch(100)
    sess.run(train_step,feed_dict={x,batch_xs,y_:batch_ys})

  6. Test Trained Model

    correct_prediction = tf.equal(tf.argmax(y,1),tf.argmax(y_,1))
accuracy = tf.readuce_mean(tf.cast(correct_prediction,tf.float32))
print(sess.run(accuracy,feed_dict={x:mnist.test.images,y_:mnist.test.labels}))

符号计算

通过符号计算，来设定计算的边界，来进行尽可能的优化。可以很方便的进行序列化。

Session的实现

实现原理 采用的是传递闭包原理。

http://www.cnblogs.com/yao62995/p/5773578.html

同时多线程实现了类似于Unreal中那样运行库。

op的实现

CPU 用EIGEN来实现，或者其他库加速库来实现。

References

https://github.com/Microsoft/CNTK 安装需要额外安装一个anaconda python 就行了。 同时用VS 来做开发，在 tools.options>python 添加新环境变量，同时在工程文件中使用右键选择新的环境变量就行了。

  1. 安装VS2017 并选择 Data Processing 模块。
  2. pip install cntk from https://docs.microsoft.com/en-us/cognitive-toolkit/Setup-Windows-Python?tabs=cntkpy22
  3. pip install keras
  4. pip install tensorflow-gpu
  5. set the backend of keras set KERAS_BACKEND=cntk

setup on Azure

  1. Deploy CNTK Azure web API
  2. Data Science Virtual Machine

使用的基本步骤，那就是建立网络拓扑，指定参数训练，输入适配。

cntk的主要用途

  1. Feed forward
  2. CNN
  3. RNN
  4. LSTM
  5. Sequence-to-Sequence

用法也应该类似于CUDA了，有自己的API来指定结构。

有两种方式，在python里，是靠重载几个子命令来实现网络拓扑的，例如linear_layer，input_variable,dense_layer,fully_connected_classifier_net等等。

采用方式类似于theano的方式，利用图来构造网络结构。 所以也就是构造图的过程。 利用input,parameter,以及基本函数来当做原语来指定输入输出。

torch

主要是相当于GPU的版本的numpy.

torch 采用 lua 来做其脚本，lua 短小精炼，集C的语法，python的缩进语法，javascript似的函数闭包。

包管理用 Luarocks 例如 i .. code-block:: bash

luarocks install XXXX

傻瓜式安装，在运行的时候，可能会遇到GPU driver的匹配问题，重启一下就好了。同时由于 torch 最新支持的cudnn5. 现在机器上的cudnn6. 两个版本改动不大。 直接发把库名与版本号检查改大就行了。

# install/share/lua/5.1/cudnn/ffi.lua
local CUDNN_PATH = os.getenv('CUDNN_PATH')
if CUDNN_PATH then
    io.stderr:write('Found Environment variable CUDNN_PATH = ' .. CUDNN_PATH)
    cudnn.C = ffi.load(CUDNN_PATH)
else

    -- local libnames = {'libcudnn.so.5', 'libcudnn.5.dylib', 'cudnn64_5.dll'}
    local libnames = {'libcudnn.so.6', 'libcudnn.6.dylib', 'cudnn64_6.dll'}
    local ok = false
    for i=1,#libnames do
        ok = pcall(function () cudnn.C = ffi.load(libnames[i]) end)
        if ok then break; end
    end

 ------------------
 -- check cuDNN version
 cudnn.version = tonumber(cudnn.C.cudnnGetVersion())
 --if cudnn.version < 5005 or cudnn.version >= 6000 then
 if cudnn.version < 5005 or cudnn.version >= 7000 then
    error('These bindings are for CUDNN 5.x (5005 <= cudnn.version > 7000) , '
         .. 'while the loaded CuDNN is version: ' .. cudnn.version
            .. '  \nAre you using an older or newer version of CuDNN?')
 end

pytorch

这个是由Facebook 重写了一遍的torch, torch 本身底层用C来实现，通常可以把PyTorch当做numpy的替代。 而torch lib 又分为

TH = TorcH
THC = TorcH Cuda
THCS = TorcH Cuda Sparse
THCUNN = TorcH CUda Neural Network (see cunn)
THD = TorcH Distributed
THNN = TorcH Neural Network
THS = TorcH Sparse
_images/overall1.png
  1. tensor的结构与numpy的都是通用互转的。

pytorch 动态指的其使用命令模式，而不是符号式。这样好处在于动态修改网络。这样的好处，就像传统的编码方式，动态性就比较好。并且传统的堆栈式调试都可以派上用场了。

对于 PyTorch 来说，Chainer 是一个先行者。PyTorch 主要受三个框架启发。在 Torch 社区中，Twitter 的某些研究人员构建了名为 Autograd 的辅助软件包，它实际上是基于 Python 社区中的 Autograd。与 Chainer 类似，Autograd 和 Torch Autograd 都采用了一种称为基于磁带（tape-based）的自动分化技术：就是说，你有一个磁带式录音机来记录你所执行的操作，然后它向后重放，来计算你的梯度。这是除了 PyTorch 和 Chainer 之外的任何其他主要框架都不具备的技术。所有其他框架都使用所谓的静态计算图，即用户构建一个图，然后将该图传递给由框架提供的执行引擎，然后框架会提前分析并执行它。

这些是两种不同的技术。基于磁带的差异化使您更容易调试，并为您提供更强大的某些功能（例如，动态神经网络）。基于静态图形的方法使您可以轻松部署到移动设备，更容易部署到异乎寻常的架构，提前执行编译器技术的能力等等。

并在Facebook内部，PyTorch用于所有研究项目，Caffe2用于所有产品项目。两者模型是可以相互转换的。

train_set = torch.FloatTensor(training_set)

工作流程

  1. 建立网络模型
  2. 数据结构建模->tensor
  3. 各种tensor之间的适配
    1. torch.squeeze(),torch.unsqueeze()
    2. torch.expand(),torch.cat()
  4. 定义优化器。

tensor基本的数学运算

torch.addcdiv

\[out_i = tensor_i + value \times \frac{tensor1_i}{tensor2_i}\]

torchvision.transforms

常用 image变换，并且chainup.

quick tutoiral

PyTorch 中文网 .. image:: /Stage_3/pytorch/dynamic_graph.gif

内存管理

也就是各种变量的使用，以及作用域。而对于深度网络的框架主要是网络参数的更新，这些参数需要与独立出来，能够加载。

变量

基本的数据结构张量(Tensor).

各种运算

  1. 各种sum的计算，可以看作是group的功能，理解为对某一行或某一例的求和吧。
  2. 其他的一些逐点计算，sqrt,还有一些那就是求导计算。
  3. 关键是乘法，有多种
    • 数乘 (变相的矩阵乘)
    • 内积 也就是标量乘 \(a*b = |a| |b| * cos\) 就是 \(mul-> x_i*y_i\)
    • 外积 也就是点乘。 *
    • 混合积
    • 范数

n对于n的数乘就是矩阵乘。

对于矩阵试编程中，随时变量实现。例如

temp = a*b
c = temp * 1
d = temp * 1.5
e = temp * 2
# implment in matrix mul
matrix_base = torch.stack[[temp] * 3,dim=0]
matrix_c = torch.sensor([c,d,e])
matrix = matrix_base *matrix_c

source code reading

torch.nn.module

整个网络层的基本结构，参数的存放，然后就是foward与backword的计算。 其他就是一些辅助函数了。就像最基本的类型

class layer :
  def __init__():
      self.W
      self.B

  def foward():
      return self.active(self.W*self.X +self.B)
  def cost():
      error = distance(self.foward(),origina_data_force)

  def backwoard():
      self.W = self.W + xxxxx

这个是网络拓扑的根结构，基本结构也就是dict,并且module是不可以不断嵌入的。

  1. addModules

    code-block:: python

    self._modules[‘module_name’] = module

#. parameters. 这个函数variable的一种封装。因为一个模块的parameter在迭代中才会更新。 当做parameters的变量传给module时，会自动变成其参数的一部分。 核心是 __init__ 在这里，生成网络。

  1. 然后是其forward函数。需要自己实现。

  2. 其核心那就是那个__call__ 的实现。

    def __call__(self, *input, **kwargs):
  for hook in self._forward_pre_hooks.values():
      hook(self, input)
  result = self.forward(*input, **kwargs)
  for hook in self._forward_hooks.values():
      hook_result = hook(self, input, result)
      if hook_result is not None:
          raise RuntimeError(
              "forward hooks should never return any values, but '{}'"
              "didn't return None".format(hook))
  if len(self._backward_hooks) > 0:
      var = result
      while not isinstance(var, Variable):
          if isinstance(var, dict):
              var = next((v for v in var.values() if isinstance(v, Variable)))
          else:
              var = var[0]
      grad_fn = var.grad_fn
      if grad_fn is not None:
          for hook in self._backward_hooks.values():
              wrapper = functools.partial(hook, self)
              functools.update_wrapper(wrapper, hook)
              grad_fn.register_hook(wrapper)
return result

optim

for input,target in dataset:
     optimizer.zero_grad()
     output=model(input)
     loss = loss_fn(output,target)
     loss.backword()
     optimizer.step()
各种优化算法的原理与区别

基本上都是采用的迭代的方法，核心 \(\Theta = \Theta - \alpha \cdot \triangledown_\Theta J(\Theta)\)

这种方法，容易停在鞍点，

Momentum算法，同时观察历史梯度 \(v_{t}\)

\[v_{t} = \gamma \cdot v_{t-1} + \alpha \cdot \triangledown_\Theta J(\Theta) \Theta = \Theta -v_{t}\]
Adagrad

是对learningrate的改变，我们采用频率较低参数采用较大的更新，相反，频率较高的参数采用较小的更新。采用累加之前的所有梯度平方的方法，这个造成训练的中后期，分母上梯度累加变大，就会造成梯度趋近于0，使得训练提前结束。

RMSprop的方法

采用计算对应的平均值，因此可缓解adagrad算法学习率下降较快的问题。

Adam

利用梯度的一阶矩估计和二阶矩估计动态调整每个参数的学习率，使得参数比较平稳。

_images/optims_1.gif

损失平面等高线随时间的变化情况

_images/optims_2.gif

不同算法在鞍点处的行为比较

http://shuokay.com/2016/06/11/optimization/

有两个超参数beta1,beta2来用计算指数移动均值的时候使用。是不是股票中移动均线的方法来计算。

beta1 : 一阶矩估计的指数衰减率 beta2 ：二阶矩估计的指数衰减率

epsilon: 该参数是非常小的数,主要为防止实现中除零10E-8.

L-BFGS算法

无约束最小化，http://www.hankcs.com/ml/l-bfgs.html，解决了计算海森矩阵的烦恼。但是吃内存，L-BFGS 就是改进内存的使用用的BFGS算法。

how to save the model

  1. torch.save(self.G.state_dict(),”model path”)

onnx

from torch.autograd import Variable
import torch.onnx
import torchvision

dummy_input = Variable(torch.randn(10,3,224,224)).cuda()
model = torchvision.models.alexnet(pretrained=True).cuda()
#。 alexnet.proro caffe 二制model,verbose会打印出可读信息
torch.onnx.export(model,dummy_input,"alexnet.proto",verbose=True)



#import model in caffe

model = onnx.load('alexnet.proto')

#Check that the IR is well formed
onnx.checker.check_model(model)

#print a human readdable represnetation of the graph
onnx.helper.printable_graph(model.graph)

符号推导

torch与 numpy不同的地方，很大一部分原因那就是对微分的符号推导的完美实现的。

通过对于一个正常的tensor添加一个wraper,就形成了，就变成了符号，但是又起了Variable的类型，这难免给你一种误解，那就是用蓝色笔来红色的红字。如果把其叫符号，不容易误解了。torch并没有实现符号推导的大部分功能，只实现了微分推导的功能，并且将其推导到了极致。但是它要求推导只能是标量，一次只能对一个Y,对多个x 求导。

一旦把 tensor-> Variable,就是意味着变成符号。但是其类型还保持原来的样子，其实就是利用链式求导法，在v.grad里实现了所有函数操作，abs,+/- tan等等操作微分求法。

由于保存了长链，需要占用大量的内存，所以默认情况下，求导只用一次，并且用完就扔了。如果二次利用就是添加retain_variables=True.

https://sherlockliao.github.io/2017/07/10/backward/, 并且backword之后，可以得到每一个因变量在此处的导数。 而且对于为什么backword可以传参数，就是为解决对tensor对tensor求导的问题。

相当于 先计算l =torch.sum(y*w),然后求l对能够影响到Y的所有变量x的导数。

https://zhuanlan.zhihu.com/p/29923090

import torch as t
from torch.autograd import Variable as v

a = t.ones(2,2)
# [1,1]
# [1,1]
x = v(a,requried_grad=True)
# [x00,x01]
# [x10,x11]

Step

整个优化迭代就在这个step函数中，

就是实现关键的 \(W_n=W_{n-1} + \triangledown\theta\)

Tensorrt

基本概念

并且所有layer与Tensor都会有名字，然后通过其名字来查找。

network definition

Layer

Tensor
tensorrt支持的格式最多8维。最基本的格式N(P_1 P_2 …) CHW. 也就是最少的就是NCHW。采用的是按列排序。 最外面是Batch的size. 最基本的infer.tensor作为输入输出结构。

而看到，GetNetBatchSize,GetNetWidth,就是指这些。

_images/DL_Deloy_flow.png
WorkSpace
用于指定layer exectuion时，所需要的临时空间大小，并且这个大小layers之间共享的。 相当于运行之间heap大小。你可以通过 getWorkspaceSize()来得到。

最基本的workflow

https://github.com/LitLeo/TensorRT_Tutorial/blob/master/TensorRT_2.1.0_User_Guide.md 使用TensorRT包括两部步骤（1）打开冰箱；（2）把大象装进去：

build阶段，TensorRT进行网络定义、执行优化并生成推理引擎 execution阶段，需要将input和output在GPU上开辟空间并将input传输到GPU上，调用推理接口得到output结果，再将结果拷贝回host端。 build阶段比较耗时间，特别是在嵌入式平台上。所以典型的使用方式就是将build后的引擎序列化（序列化后可写到硬盘里）供以后使用。

  1. 读网络定义

  2. buildnet

  3. optimize

  4. provide intput/output. 默认的输入输出已经是host memory了。

  5. create engine context

  6. do infer

    context.execute(batchSize,buffers);
//or
context.enqueue(batchSize,buffers,stream,nullptr);

输入输出，都在buffers 里，执行完，直接把buffers中ouputbuffer的Tensor结构copy回去就行了。

//建立一个builder+log 来实现各种framework的转换
IBuilder * builder = createInferBuilder(*plogger)

INetworkDefinition  *network = build->createNetwork();

主要用来推理，并且 并且能够层级融合优化。 #. 合并 tensor及layers. #. 参数的调优

_images/tensorrt_optimize.png _images/tensorrt_proformance.png

现在已经可以做到7ms的时延了。

这种编程模式已经进化了，加载了网络图的定义，然后再加载参数，然后执行，这不就是新行的加编程模型了。

应用研究

Deeplearning 在各个应用领域的发展情况。

deep learning 论文笔记

Deep Learning Shape Priors for Object Segmentation

形状，这个是在模拟人的情况吗？ modeling high-dimensional richly structured data

deep learning 为什么能建模高纬度数据？？

在网络中使用deeplearning 还是有些不太方便的，低层次

Switchable Deep Network for Pedestrian Detection

创新点：

  1. 这个是使用deep learning 做行人探测，首先使用卷积神经网络得到低层次特征，进一步使用限制玻尔兹曼机得到中层和高层特征, 用logistic 回归得到高层次特征。
  2. 加入更多实际的因素，比如前景和背景，特征有无，从而建立如下模型：
\[E(x,y,h,s,m;\Theta ) = \sum\limits_{k = 1}^K {\left( {{s_k}h_k^T({W_k}(x \circ {m_k}) + {b_k}} \right)} - \sum\limits_{k = 1}^K {{s_k}c_k^T(x \circ {m_k})} - {y^T}{\bf{U}}\sum\limits_{k = 1}^K {{s_k}{h_k} - {d^T}y}\]

其中K是元素个数,在实际中表示有些人坐着，有些人站着，就是不同的K。\(\Theta= \{W,b,c,U,d\}\) 是所有未知的待估计的参数。其中U是全连接矩阵。\(s_k\) 判断某个元素是否激活；\(m_k\) 是saliency map 代表前景还是背景。比如，0 代表背景，1代表目标行人。

算法步骤：

  1. 首先是卷积神经网络，得到轮廓信息。
  2. 采取kMeans 算法对训练数据进行分组。
  3. 采用EM算法，估计S和参数 \(\Theta\) 。
  4. 使用 logistic 回归得到labels信息。
  5. 使用误差熵进行反馈微调。

可能的创新点：

  1. 在人脸识别中遮挡部分也可以switchable 变量来表示遮挡。但是人脸是一个相对简单的问题。

疑问：

  1. 在算法预训练中S 和其他参数是怎样估计的，为什么首先估计S? 是不是使用决策树会更好一点。
  2. 怎样区分前景和背景？
  3. 这里的head shoulder， upper body， 这些都是怎么来的信息？

扩展阅读：

Learning and selecting features jointly with point-wise gated Boltzmann machines

利用特征对物体进行分类，前景特征和背景特征。

Facial Expression Recognition via a Boosted Deep Belief Network

早期的分类都是基于固定特征的分类，特征没有为具体的分类进行定制，这篇文章首先使用多个DBN，最顶层使用分类器进行判决。

L层的联合概率密度函数可以表示为：

\[Prob(H^0,H^1,...,H^L)=\prod_{l=0}^{L-2}Prob(H^l|H^{l-1})Prob(H^{L-1},H^L)\]

\(Prob(H^{l-1},H^l)\) 和 \(Prob(H^{l},H^{l-1})\) 分别表示为：

\[Prob(H^{l-1}|H^l)=\frac{1}{1+\exp((W^{(l,l+1)}H^l+b_h^{l+1}))}\]

在最高层次的输出 \(H^L\) 可以表示为：

\[H^L= W^{L-1,L}H^{L-1}\]

其中 \(W^{L-1,L}H^{L-1}\) 是第最顶层的权值矩阵。

最后形成强分类器：

\[\xi_{strong}=\sum_{i=1}^{N_I}\beta_i[\frac{1}{1+\exp(-\sum_{j=1}^M\alpha_j sgn (W_j^{(L-1,L)}H_{i,j}^{L-1}-T_j) )}-E_i]^2\]

其中 \(\alpha\) 和 T是弱分类器的门限，使用梯度下降方向。

弱分类器：

\[\xi_{}= \sum_{j=1}^M\alpha_j \sum_{i=1}^{N_I}\beta_i[\frac{1+ sgn (W_j^{(L-1,L)}H_{i,j}^{L-1}-T_j}{2}-E_i]^2\]

最后判决使用分类器，并使用联合梯度下降方法更新权值W：

\[\xi=\lambda\xi_{strong}+\xi_{weak}\]

top 两层使用boosting 结构， {0，L-2}层使用后向反馈算法。

算法整个流程：

digraph G { a [label="图像"]; b [label="特征" ]; c [label="分类器（强分类器和弱分类器）"]; a->b [label="1.图像分块"]; b->c [label="2.学习层级的特征"]; c->b [label="3.根据反馈调整前向特征"]; }

疑问：

这里为什么要在输入的时候使用相互交叠的patches那？这样计算量不是很大吗？

算法创新点：

  1. 以前的算法都是基于特征学习、特征选择、分类约束，这三个过程是顺序并且是独立的，缺少全局反馈，此方法中形成整一个系统，使用全局微调，交替估计这三个状态的值，做出最优的分类。
  2. 这个算法中使用局部面部图像，比如nose，eye and mouth，达到更好的面部特征识别。

扩展阅读：

  1. On deep generative models with applications to recognition
  2. Disentangling factors of variation for facial expression recognition.

这两个文章使用层级的特征表示和logistic 回归交替估计用于目标分类，但是这个文章使用整张脸来做面部表情识别。

  1. Facial action unit recognition with sparse representation.
  2. Sparse coding for flexible, robust 3d facial-expression synthesis.

这两篇文章使用sparse coding 呈现轮廓特征。

可能的创新点：

Pedestrian Parsing via Deep Decompositional Network

算法创新点：

  1. 首先估计遮挡部位，然后进行补全。

算法步骤：

digraph G { a [label="图像"]; b [label="特征" ]; c [label="判断是否遮挡？"]; d [label="使用降噪autocoder补全component"]; e[label="判断是否是背景？"]; a->b->c->d->e }

扩展阅读：

Body part detectors trained using 3d human pose annotations.

利用人类3d骨骼轮廓探测身体每个部分。

Robust boltzmann machines for recognition and denoising.

使用RBM学习遮挡部分和非遮挡部分。

The shape boltzmann machine: a strong model of object shape

generative model for partsbased object segmentation

利用玻尔兹曼机不全离散数据。

Stacked denoising autoencoders: Learning useful representations in a deep network with a local denoising criterion

使用降噪aucoder来恢复破坏的数据。我想这个可以用于人职业规划中。

Discriminative Deep Metric Learning for Face Verification in the Wild

Mahalanobis Distance Metric Learning

传统的Mahalanobis 距离试图找到方矩阵 \(M\in R^{d\times d}\)

Hybrid Deep Learning for Face Verification

在deep learning 中一直都使用卷积，怎样能确定那？哪里是特征，其实现在特征就是不明显了。

这里建立两张脸的特征，是什么意思？

扩展阅读：

Deep convolutional network cascade for facial point detection 使用卷积神经网络来探测脸部区域。

这个文章看起来真是费劲，

DeepFace: Closing the Gap to Human-Level Performance in Face Verification

使用三维脸建模，使用deep learning。

Deep Learning Face Representation from Predicting 10,000 Classes

创新点：

#. 使用跨层信息获得多尺度信息 #.

\[y^{j(r)} max(0,b^{j(r)\sum i k^{ij(r)}*x^{i(r)}})\]

联合贝叶斯：

\[x \mu\xi\]

这两个算法：

\[\Sum I\]
\[r(x1,x2) \log\frac{P(x1,x2|HI)}{x1,x2|HE}\]

疑问：

  1. 为什么不使用全局脸，和非全局脸部区域。
  2. The hidden neurons are ReLUs and the output neuron is sigmoid

扩展阅读：

Imagenet classification with deep convolutional neural networks.

使用非线性函数max()作为激活函数。

深度学习总结：

深度学习中通过简单的wxb模型实现复杂的网络参数估计，我觉得太神奇了。用来模拟非线性问题。但是怎样设计结构，是随机的，还是需要特定设置？但是需要多少的训练

ImageNet 当前现状和评价标准

ImageNet相关数据分析， 评价标准：

在分类过程中，只要一类对应label即可，并且最大判决的概率是正确的label时为正确。

error即是错误在总体中的计数：

\[\]
<<<<<<< HEAD
error =frac{1}{N}sum_{i=1}^N min_j d_{ij}
error frac{1}{N}sum min d{ij}

>>>>>>> 155a0ad53209f66425c1cbc4b0a2005a86c1caf5

在单目标定位时，只有完全正确的标注好目标，并且距离不能超过多少才算成功。

也就是使用算法：

\[d{ij} \max(d(c{ij},Ci),\min d(b{ij},B{ik}))\]
\[Recall(t) \frac{\sum{ij}1[s{ij}\geq t]z{ij}}{N}\]
\[Precision(t)\frac{\sum{ij}1[s{ij}\geq t]z{ij}}{\sum{ij}1[s{ij}\geq t]}\]

另外有算法对边界进行修改：

\[ \begin{align}\begin{aligned}thr(B)=\min(0.5,\frac{wh}{(w+10)(h+10)})\\thr(B)\min(0.5,\frac{wh}{(w10)(h10)})\end{aligned}\end{align} \]

目标探测

标准：用来惩罚丢失目标的算法，和错误探测的目标。（b{ij},s{ij}）用来表示目标的位置b和目标判别。

历年最成功的算法

ILSVRC2010.

关注的算法： Fisher vector based methods 线性SVM。

2013 年：卷积神经网络 dropout technique

2014 年： google GoogLeNet

使用图像分类作为多目标识别的训练数据。

错误训练原因：

The most common error that an untrained annotator is susceptible to is a failure to consider a relevant class as a possible label because they are unaware of its existence. Therefore, in evaluating the human accuracy we relied primarily on expert annotators who learned to recognize a large portion of the 1000 ILSVRC classes. During training, the annotators labeled a few hundred validation images for practice and later switched to the test set images.

参考： ImageNet Large Scale Visual Recognition Challenge

扩展阅读：

PASCAL Visual Object Classes Challenge (VOC) http://www.pascalnetwork. org/challenges/VOC/voc2012/workshop/index.html. 实现算法评定。

新方向：

Segmentation Propagation in ImageNet 新图像定位方法：使用弱监督定位方法。

Devise: A deep visual-semantic embedding model. large-scale zero-shot learning

What Does Classifying More Than 10,000 Image Categories Tell Us?

这个文章提出在大数据环境下使用层级结构，来表述分类器，使得分类器能够表述更多信息。

Going deeper with convolutions

在这个文章中要提出利用稀疏，使得可以利用更少的数据表示。 使用Hebbian原则和多尺度处理（多尺度处理，体现在哪里？）

Provable bounds for learning some deep representations

问题：

这里的网络拓扑和实际中的网络拓扑有什么关系？ 从稀疏到浓密？？

卷积可视化

从联合概率密度的角度来说，第一层概率是f(a),第二层是f(a)g(c-a), 这个解释似乎比李刚的更好。

但是每一次都是可以直接看到。

这是不是可以说明这一层和上一层是相互独立的？

这里仅仅是方向，没有强度的概率？方向和强度。

这个模型中层层抽象是怎样表达的？

神经元是有方向的，

这里是从信号而来的，对应于两维卷积。

信号的平移，形成很多信号。

卷积好处

可以描述实际过程中的稀疏 计算量较小，卷积中的计算量为 \(O(n^2)\) ， 并且使用深度数学观点，计算量可以达到 \(O(n\log(n))\). (还不太明白)

机器阅读与理解

机器阅读的类型

  1. 基本的完形填空式
  2. cloze style queries.
  3. 推理
  4. 与外界知识库的融合
  5. SQuAD数据集这类没有候选项且答案可能是多个词的machine comprehension问题。

R01_ 介绍了深度学习解决机器阅读理解任务的研究进展，提出三种内容表示的方法。 R02 介绍了WordEmbed的用意义，同时　R03 知乎解释当前Word Represntation的方法， R04 是stanford 开放的训练好的库，GloVe: Global Vectors for Word Representation. R05 知乎专栏对这个有专门的一期。

_images/Model1.jpg

模型1 用BIRNN 来表征文档

_images/Model2.jpg
_images/Model3.jpg

模型三是在模型1的基础上改进来的，使用双向RNN来表征每个单词及其上下文的语言信。 但是RNN对于太长的内容表征能力不足，会存在大量的信息丢失。

机器阅读理解问题形式: 人工合成问答，cloze style queries以及选择题等方式。，也是文档内容本身的表示以及问题本身的表示。对于问题本身的理解，也要有一个推理过程。对于更加复杂的事情还需要世界知识库融合的一个过程。

\({D,Q,A,a}\) D->document,Q->Questions,AnswerSet,a->right answer.

三种模型

_images/1d_model.jpg

所以将这个结构为一维匹配模型，主要是计算问题Q和文章中单词序列的匹配过程形成了一维线性结构。 现在Attension Sum Reader, AS Reader, Stanford Attentive Reader. Gated-AttensionReader GA reader. Attentive Reader,AMRRNN都是这种结构。

rnn可以理解为一个人看完了一段话，他可能只记得最后几个词说明的意思，但是如果你问他前面的信息，他就不能准确地回答，attention可以理解为，提问的信息只与之前看完的那段话中一部分关系密切，而其他部分关系不大，这个人就会将自己的注意力锁定在这部分信息中。

关键是匹配函数的定义

  1. AS Reader \(F(D_i,Q)=D_iQ\)
  2. Attentive Reader \(F(D_i,Q)=tanh(W_DDi,W_QQ)\)
  3. Stanford AR 采用又线性函数(Bilinear) \(F(D_i,Q)=D_iWQ\)

注意力机制分为 Complex attention 与simple attention模型。

_images/complex_attention.png
_images/simple_attention.png

卷积注意力模型（convolutional attention-based encoder），用来确保每一步生成词的时候都可以聚焦到合适的输入上,

_images/2d_model.jpg

Consensus Attension,Attention-over-Attention AOA,Math-LSTM都属于这种模型。

一般通过加深网络的层数来模拟不断增加的推理步骤。

_images/3d_model.jpg
_images/3d_model_GA.jpg

GA Reader 的推理过程

_images/3d_model_IA.jpg

IA Reader 的推理过程

_images/3d_model_AMRNN.jpg

AMRNN Reader 的推理过程

_images/3d_model_MemoryNetworks.jpg

记忆网络 的推理过程

其它模型

主要是EpiReader,EpiReader和动态实体表示模型(Dynamic Entity Representation) DER模型

EpiReader是目前机器阅读理解模型中效果最好的模型之一，其思路相当于使用AS Reader的模型先提供若干候选答案，然后再对候选答案用假设检验的验证方式再次确认来获得正确答案。假设检验采用了将候选答案替换掉问题中的PlaceHolder占位符，即假设某个候选答案就是正确答案，形成完整的问题句子，然后通过判断问题句和文章中每个句子多大程度上是语义蕴含(Entailment)的关系来做综合判断，找出经过检验最合理的候选答案作为正确答案。这从技术思路上其实是采用了多模型融合的思路，本质上和多Reader进行模型Ensemble起到了异曲同工的作用，可以将其归为多模型Ensemble的集成方案，但是其假设检验过程模型相对复杂，而效果相比模型集成来说也不占优势，实际使用中其实不如直接采取某个模型Ensemble的方案更实用。

DER模型在阅读理解时，首先将文章中同一实体在文章中不同的出现位置标记出来，每个位置提取这一实体及其一定窗口大小对应的上下文内容，用双向RNN对这段信息进行编码，每个位置的包含这个实体的片段都编码完成后，根据这些编码信息与问题的相似性计算这个实体不同语言片段的Attention信息，并根据Attention信息综合出整篇文章中这个实体不同上下文的总的表示，然后根据这个表示和问题的语义相近程度选出最可能是答案的那个实体。DER模型尽管看上去和一维匹配模型差异很大，其实两者并没有本质区别，一维匹配模型在最后步骤相同单词的Attention概率合并过程其实和DER的做法是类似的。

https://evolution.ai/#technology 已经做到实用阶段。 例如国内在做让机器人高考也是朝着方面走。

现在内容表达式方法有三种。 一种那就是把文档本身当做单词的序列来这样理解。 由于每一个单词的权重也是不一样的。这样也可以再计算出来语言来。

整体分为一维的方法，二维的方法，三维的方法。

二维的方法

也就是把整个文档与问题之间做一个二维mapping矩阵，相当于每一个单词的对最终的权重也都是不一样的。

数据集

  1. bAbi
  2. CNN
  3. Daily Mail
  4. SQuAD 数据集
  5. 中文语料库 R08
  6. English Gigaword数据集，该数据集包括了六大主流媒体机构的新闻文章，包括纽约时报和美联社，每篇文章都有清晰的内容和标题，并且内容被划分为段落。经过一些预处理之后，训练集包括5.5M篇新闻和236M单词

CNN,daily Mail 数据集生成方法，见 R06 中文解读见 R07

  1. spaCy coreNLP非常好用的工具包。

当前的问题

  1. 更大难度的阅读理解数据集
  2. 神经网络模型单一
  3. 二维匹配模型需要做更深入的探索
  4. 世界知识(World Knowledge)的引入
  5. 发展更为完善的的推理机制,目前的推理还是停留在注意力焦点转移的机制。
  6. 常用评价指标 R10

自我理解的方向

如何用神经网络表达一个知识库，并且随着知识的增长，如何扩展知识库。如何自动增加层数。 同时来了新的东东，如何实现与新旧知识之间的融合，也就不可避免添加适配层来进行适配训练融合。 如何用网络结构来实现迭代的符号化推导。而现在的神经网络是一个简单的强映射关系。

对于文档与内容的表示，一般用双向RNN来做。 机器阅读理解中文章和问题的深度学习表示方法 文章与问题的表示方法

自动文摘的功能

Summarization. R09 介绍了两种方法 抽取式，与摘要式。 现在还没有很好的解决方式，由于信息的过载。人们迫切有一个工具用最短的时间了解最多的最有用的信息。 根据人们的提出问题，来查询相关的论文，然后自动形成综述。 但是目前还没有很的解决方法。

machine translation是最活跃的一个研究领域，seq2seq框架就是从该领域中提炼出来的，attention model也是借鉴于soft alignment，对于文本摘要这个问题来说，套用seq2seq只能解决headlines generation的问题，面对传统的single document summarization和multi document summarization任务便束手无策了，因为输入部分的规模远大于输出部分的话，seq2seq的效果不会很好，因此说abstractive summarization的研究还长路漫漫。不过这里可以将extractive和abstractive结合在一起来做，用extractive将一篇文档中最重要的一句话提取出来作为输入，套用seq2seq来做abstractive，本质上是一个paraphrase的任务，在工程中可以试一下这种思路。在后续的研究中也可以尝试将extractive和abstractive的思路结合在一起做文本摘要

难点在于自动评价的标准建模。

  1. MRT+NHG 这个效果目前是比较好的。
  2. R11 教机器学习摘要
  3. R12 分析常用的方法与派系。
  4. R13 摘要系统的实现
  5. [R13] 是由saleforce 实现的基于增强学习实现的摘要，是目前的最高水平

用seq2seq的思路来解决文本摘要问题仍停留在short text的生成水平上，最多到paragraph level。原因也比较简单，rnn也好，gru、lstm也罢，终究都面临着一个长程依赖的问题，虽然说gru、lstm等技术用gate机制在一定程度上缓解了长程依赖和梯度消失、爆炸的问题，但终究文本过长的话，神经网络的深度就会随之变得非常深，训练起来难度就会随之增加。所以，这也是为什么document level或者说multi document level的abstractive式的摘要生成问题至今都是一个难以解决的问题。确实，short text的理解、表示在一定程度上有了很大的突破，也可以在工程上有不错的应用，比如机器翻译。但text变了之后，一篇很长的文章如何更加准确地理解和表示是一个非常难的问题，attention是一个不错的解决方案，在decoder的部分不需要考虑encoder的全部，只需确定需要注意的几个点就可以了，其实人在看一篇长文的时候也是这样一种机制，从某种角度上来讲，attention在decoder时提供了一种降维的手段，让model更能捕捉到关键的信息。

那些老的基于统计的方法，只是基于词频的方法的实用性极差，google 搜索提供的textsum 看起来还不错。 最新的水平

语料库可以在 nlpcn.org 上找不到少。 github.com/thunlp 清华大学的自然语言处理

对于字幕分析

# https://github.com/Diaoul/subliminal
$ docker run --rm --name subliminal -v subliminal_cache:/usr/src/cache -v /tvshows:/tvshows -it diaoulael/subliminal download -l en /tvshows/The.Big.Bang.Theory.S05E18.HDTV.x264-LOL.mp4

  1. 爬取数据 - 要利用代理与匿名网络来解决IP被封的问题 - 利用多线程并行，来加快速度

  2. 数据的清洗 - 词性，格式 - 中英文的问题

  3. 分析

    • 词汇量

    • 用到的人名，地名

    • 用到颜色的名字

    • 心情的的词语

    • 车，酒，等等

    • 分词,摘要

      • yaha 具有自动摘要的功能
      pip install jieba,yaha

    • 如何判断经典句子

  4. 词云的生成 - wordCloud see github - 中文的支持主要是字体的设置

  5. 每一次更新之后

    • 最热的词汇排行有什么变化
    • 有哪些新增，新增有哪些变化。
    • 读一批书，帮助自己快速的了解一个行业
    • 把一次把一千本书，压缩一下。看看哪些是重复的句子。也就是所谓的金句。

  6. 如果一次一千本，那么重复1000次，然后可可视化看看一些参数的变化。

    • 就像我们的阅读用同样的方法，重复读几遍，就会有不一样的认识，那我如果用机器来重复这样的事情呢。

python 任意中文文本的生成 http://blog.csdn.net/fontthrone/article/details/72988956

Char-RNN

对于特别常的文档，生成效果也不好，例如ku,用了115M,然而生成的效果很差。

reference

推荐系统

[1] 总结推荐系统的特点，预测，推荐，反馈，这个商业推荐中应用特别多。这个其实也是个性定制的必由之路。同时可以做为闭环系统中一个基于历史知识的反馈系统。并且推荐应该是基于预测来进行，而不是简单相似性来推。

就像现在bug系统，自动聚类，并且计算出优先级。并且根据现有人员的修bug的记录的能力，得出应该由谁来修理会更好。

如何做一个学习的推荐系统。需要解决的问题

  1. 你感兴趣的信息与话题 如何聚类来批量学习，或者自我迭代实现
  2. 你现有知识体系对于感兴趣方向的预测，主要搜索相关最新信息
  3. 刻意的练习相关的知识？ 能否推荐系统自动的计算出一个最佳路径，这样学习才能即轻松又高效。 能度太大的，进展就会慢，并且也就厌烦。

经常用RBM与autoencoder.

Auto Encoder 可以用keras来实现可以参考https://blog.keras.io/building-autoencoders-in-keras.html

IM2Markup

一个常用的功能那就是把数学公式的图片，直接生成latex这样的markup. 然后就方便进行二次的利用。 如果实现只需要截图 + 再加识别生成。 如果训练好之后，直接用现在Snipaste-1.12-x64，

[R01] 论文

_images/topology.png

AI降噪

采用各种合成软件，生成器噪声模型与原声模型，然后合成降噪。 [RTN] 用实现DL来实现RTN的编码与解码，同时实现降噪的功能。就是把RTN当做一个autoendcode.

把chanel当做一个通道，误码率就是天然loss函数。根据硬件约束，来用网络生成transimiter and receiver. 然后利用 training来得到设计参数。

[RTN]https://github.com/gram-ai/radio-transformer-networks

视觉推理

推理有两个方向，一个symbols方向，另一个connectionist方向。 clevr测试集 https://cs.stanford.edu/people/jcjohns/clevr/

一种是分解一个成一个个小问题的组合，通过回答这些小问题，最终回答这个大问题。 另一种是把图形与问题放在一起，然后扔到高层join训练 。

如果能做到实时的话，就相当于自动驾驶中，那个路况的查看过程了.

tbd-nets

  1. 即然是module化的开发，网络的结构也都大同小异，如何区分各个模块的功能。 如何功能块的特征，靠经验的理解设计+cost函数的设计。

    _images/tbd-net_modules.png

  2. relate 模块是如何定义

  3. Or/And 是直接通过取Max/min来得到。

    def forward(self,attn1,attn2):
    out = torch.max(attn1,attn2)
    return out

  4. Attention是如何体现的。通过mask来体现的,也就是直接通过W*X 来实现的。把其高亮为红色。 .. code-block:: python

    def forward(self,feats,attn):

    attended_feats = torch.mul(feats,attn.repeat(1,self.dim,1,1)) out = F.relu(self.conv1(attended_feats)) out = F.relu(self.conv2(out)) out = F.sigmoid(self.conv3(out)) return out

  5. QueryModule 基本结构与attentionmodule是一样的。没有看出来是如何实现编码的功能的。

  6. RelateModule,主要是通过扩大 receptive field by dilated convolutions. https://zhuanlan.zhihu.com/p/27285612

  7. QueryModule是一样的。 生成attention的最后一层sigmoid,不然都是relu. 编码是用Seq2seq来生成的把任意图的问题，变成一个原基本词汇组成的语法表，然后tbd-nets对于每一个元语都有一个元module来实现的。 .. code-block:: python

    for module_name in vocab[‘program_token_to_idx’]:

    # skip list # hook module if module_name = “scene”:

    module = None;

    elif module_name = “intersect”:

    module = modules.AndModule()

    elif module_name = “union”:

    module = modules.OrModule()

    #…. self.function_modules[module_name]=module self.add_module(module_name,module)

    def foward():

    #… #.就是一个传统的状态机,构造神经网络 for i in reversed(programs.data[n].cpu().numpy()):

    module_type = self.vocab[‘program_idx_to_token’][i] #skip list module = self.function_modules[module_type] if module_type = “scene”:

    # do something

    if ‘equal’ in module_type or module_type in {‘intersecct’,’union’,’less_than’,’greater_than’]:

  8. Comparison Encoding*encoding

    output = module(out,saved_output)

  9. reasoning chain 是如何体现的 是通过那个programs chain来来体现用seq2seq生成的。

  10. 是如何训练的与定义cost函数的。 是用交叉熵来做cost的。

MAC 机器推理

MAC 模仿的的计算体系架构,Control,Memory,Attention. 其实也就是相当遗传进化选择的过程。

它的做法相当于tbd-nets中人为设计的原语直接用相关性+attention 的Control给取代了。 https://mp.weixin.qq.com/s/sbV5SL6fAGad5KlBoqUKFQ

并且将推理过程放到Key-Value Memory Networks中，这里key-value也都是机器学习来的。

_images/mac_fw.png _images/mac_cell_structure.png
  1. 输入的信息流是怎么的。
  2. 如何与其他框架模块接口
  3. 每一子块是如何计算的
  4. 如何演化以及停止
  5. 都有哪些超参数
  6. 如何可视化
  7. 有保证的健壮性。

实现推理的合心，如何量化一个符号，然后把推理过程，可以定义一个计算过程，如果这个过程是是可微分的话会更好。

NYU联合Google Brain提出结合工作记忆的视觉推理架构和数据集 COG

https://mp.weixin.qq.com/s/mPN3MXueeZImY2z0KBD6CA

它实现了一个可配置的Input Dataset. 相当于实现一个模拟器而己。 #. 它解决了检测神经网络是不是凑答案的问题。 #. 通过控制输入的种类与数量，来研究网络的容量问题。 #. 另外可以利用传感器与以及gameengine来建设大量的模拟器，就像NV的虚拟训练一样。 #. 通过虚拟化与数字化来解决各种物理规律的制约。

Indices and tables