深度学习-1深度学习总体介绍

学习经验：看paper，练习网上的focus，demo，按照自己的方向去实现不同的例子

学习书：
https://github.com/exacity/deeplearningbook-chine

代码是在Ubuntu tensorflow环境下测试的。

一.深度学习：传统到现在

1.传统机器学习和深度学习的对比

传统机器学习的流程：
1，先做数据预处理：非常general，不同数据处理方式一样的
2，特征提取：是关键阶段，特征提取形式完全由研究人员自己设计
针对不同数据特点不同，
针对不同研究对象/任务所用特征不同。
传统机器学习处理一个东西希望将其原始数据变成一个特别容易区分的feature，所以叫做特征提取。
比如毛猫和狗的图片，直接让机器学习对图片进行识别是比较难的，但是我们可以做一些特殊的特征提取。比如颜色、形状特征，用一些数字来表示。用数据来表征原来表征的那个形象。
数据对计算机来说更容易区分，所以可是使用某种分类算法对特征做区分。
3，分类器：有一个标准的准则

深度学习流程：
数据准备：
将大量数据准备好，如果数据不够还要做一些accumulation增加，数据带上label
设计模型：
选一个general的模型就可以。
图，图像相关的，一维，文本或语言相关的用RNN，视频相关的用CNN+RNN.整个模型也变成一个general的东西。
训练：也是调整一些通用的东西
人脸识别，目标分类，车辆检测发现用的模型都是一样的
总结：深度学习针对不同的任务，人为的添加的设计更少了。所以可能存在一个model，所有问题解决得都非常好。

深度学习在所有问题上变现力performance，结果比传统机器学习好很多，而且不同人为地去添加很多feature。

是不是传统机器学习不重要了？
深度学习不是万能的，有些领域做不到好的表现力：比如说需要人在中间控制比较多的物理量。而且不是一个简单的模型就可以解决多有的问题
深度学习所有好的设计的思想都来源于传统机器学习
传统机器学习的思想体现了把一个复杂问题分成小部分，然后从小部分合到一起，变成一个部分来，分而治之，逐个突破，再把信息整合的一个思想。

2.深度学习传统到现在解决问题流程的变化

比如做一个图片分类的任务
1，传统机器学习：Year 2010
有一个图片，找出来图片的特征，人为设计的特征，对原来图片做一个处理，变成一个计算机更容易识别的向量。这是传统机器学习特征提取的过程。变成向量之后，然后用比较general的SVM(主要是SVM)进行分类。
2，新的方法，从Year 2012之后到现在
不同的新的模型的提出，模型中间的那些层不用做太多的设计，把深度卷积神经网络的结构设计好，把数据放进去，直接得出结果就可以了。

2.深度学习发展的推动因素

不同的更深的更复杂的神经网络把图片识别的识别率或表现率提升得越来越高，结果越来越好，有哪些推动因素
1，理论因素：
CNN:卷积神经网络处理的一系列流程
RNN：和神经相关的神经网络的递归的处理
ReLU:在ReLU之前，神经网络基本使用Sigmoid非线性激励函数。一个概念：线性回归要变成非线性的话要加一个非线性激励函数。
正常的非线性激励函数存在一个在反向计算的过程中有一个梯度衰减的问题，但是ReLU的方程形式能够保证梯度不会衰减。
这样的好处是：比如每一层设计为50%，设计三层的网络，那么传递完之后，就变为原来的1/8，这样损失就非常大。梯度衰减的话梯度每次比参数更新的量非常小，到后来就没办法更新自己的位置了。比如说从山上高点往低点走的话，步子越来越小，小到厘米级毫米级的话，就没办法到达更好的位置。相对于神经网络模型来说没办法得到更好的参数了。所以ReLU的应用是非常重要的。
2，数据：
深度学习对数据的依赖非常大。有了这些数据支撑，就有了大量资源进行计算。
ImageNet：100万数据
LFW:人脸识别，上万数据
3，硬件：关于计算
Nvidia CUDA+GPU,现在主要的框架依赖英伟达显卡，有CUDA结构，有CUDA之后做非常大量的卷积计算就可以用GPU来做，可以省大量时间。

3.深度学习未来进展

举例：个人助手
主要靠语音处理/自然语言处理的技术
首先知道一些知识点，你有一些问题问他，他首先把你的语句语音识别，变成text。
对于text，做一些处理，变成计算机容易识别的矩阵，对矩阵做一些处理到响应的回归方法。

二.深度学习:应用特点

优点：
1，学习能力强：
面对同一个任务，比如图片分类。传统方法可能到60%多，深度学习可能就是90%多，
2，覆盖范围广---适应性好
比如做图片处理，传统学习模式基本上只能解决已有的一些处理，给他新的数据，他可能就完全不知道在干什么。
但是深度学习，一方面是数据特别多，覆盖到了大量的数据，所以范围很广，另一方面参数多，即使看到没有见过的东西，可以把这个东西分解为自己见过的东西的组合，从而做出比较好的判断。
3，可移植性好
迁移学习的基础。
我训练一个模型，做图片识别，这个例子可以用来做很多别的任务，做一个图片分类的model，那我在图片生成，场景识别，人脸计算，目标检测，物品分类中都可以移植他的参数。
因为我原始模型的识别能力比较好，学习的参数非常有用，这个参数如果不考虑这个模型，单独用人脸计算去训练一个模型，你会发现他的卷积核的这些参数会和我做的另一个任务的参数非常像，意思就是：神经元的结构非常类似，那么是否可以做一些迁移，把这个参数直接放到做不同任务的训练的起点，相当于你的训练做了一个非常好的一个预先设计好的一个模型。之后你只需要用少量的模型，少量的数据做少样的训练，就可以得到一个不错的模型。

缺点：
1，计算量大。便携性差：
动辄有上千个卷积核在计算，这样的过程非常依赖于功能强劲的显卡。显卡的便携性很差。所以现在在做神经网络压缩，便携性的硬件，来做响应的替代，所以如果在手机端去做只能在线去做。
2，硬件需求高
3，模型设计复杂
针对不同的任务可以用简单的模型来做一下，但是想做得更好需要设计非常复杂的结构
4，有可能被hack，hack-
深度学习认为是什么的情况，那么原来的东西一定是这样的吗？深度学习认为是车，那个东西一定是车？
5，长于计算，弱于算计
没有推理能力

三.深度学习框架比较

Theano:
主要是学术圈在用，运算方便，缺点是上手难一些，好处是做设计灵活
TensorFlow：
大部分方面比较领先，尤其是在文档方面。出来一个新的例子，会有人用TensorFlow实现，学习起来会有帮助。
Pytorch：
更简单，实现东西更快。效率比TensorFlow高一些
MXNet：
在并行方面做得最好，大型训练可以尝试用一下
Keras：
上层的包，用TensorFlow写一个东西会一层一层慢慢写，正向计算/反向计算会说一下，Keras把一些基本的操作做得更简单了。
Keras现在是TensorFlow和Theano支持的。
Pytorch和Keras难度基本相当，虽然是上层下层语言都可以编的，但是想用一个简单方式写的话，也可以实现。
Caffe：
不能自动求导

四.TensorFlow介绍

组成

组成如上图：
1，计算部分：源代码部分。知道其特点，在例子中学到什么看一下就可以。
2，教程部分：大量的不同例子的教程
tensorboard：设计的模型可以帮你画出来，训练过程中你的训练参数loss可以有实时的显示。

安装

1.工作方式

1，工作方式
TensorFlow的工作方式是用TensorFlow基本的变量和基本运算符构建一个方程，比如说写一个非常大的表达式z=ax+by，运算方法比如说+加法，ax+by都是TensorFlow定义的一个运算。
下图中TF运算--对单独一两个数据的运算符。
2，参数带入
tf.Variables相当于是中间的变量，运算过程中这些东西可以求导，这些参数可以变化，
tf.placeholder类似于一个接口，placeholder设一个形状，3*3的树，最后做带入方程计算时就是把3*3矩阵放到placeholder的臂上，比如说y=ax+b，a,b可能就是Variables，x,y是所有数据都可以fit进来的，在存在上就是一个placeholder。
tf.Variables是tf会训练的，tf.placeholder是输入不变的。
训练过程中，tf.Variables相当于是有参数的，相当于是卷积核，计算的话是有一个梯度的。
tf.placeholder就是一个单纯的输入。就是输入的那些，比如一个batch-100张图片，将这个数据fit到tf.placeholder里面。同时100张图片有label的话，也是fit到tf.placeholder里面，接收万有数据这样的形式。
tf.Variables就是中间所有的变量，不论是卷积还是全连接层，神经元的一个参数。是样本数据的一个接口。

2.代码示例

'''
basic tf operation examples, 
1. write a tf function use tf.xxxx
2. feed data to tf.placeholder and set data to tf.Variable
3.run...
'''
#
import tensorflow as tf

# direct sum with constand value
a = tf.constant(2) # 创建一个常数张量
b = tf.constant(3)
c=a+b
d=a*b

#Session属于一个激活状态
sess=tf.compat.v1.Session()
print(sess.run(c)) #直接run这个c。如果a,b需要输入，这里会有一个输入的地方。如果直接是一个常量，直接进行计算的，那就直接把值输出就可以。
print(sess.run(d))

#placeholder可以作占位符的理解。先占据这个位置，a和b都是int16。
a = tf.compat.v1.placeholder(tf.int16)
# placeholder()函数是在神经网络构建graph的时候在模型中的占位，
# 此时并没有把要输入的数据传入模型，它只会分配必要的内存。
# 等建立session，在会话中，运行模型的时候通过feed_dict()函数向占位符喂入数据。
b = tf.compat.v1.placeholder(tf.int16)

#加法，乘法的简单计算
add = tf.add(a, b) #定义相加运算。
mul = tf.multiply(a, b) #定义相乘运算
#每次run之前需要import session，让session处于激活的状态。不过前面已经import了。
print(sess.run(add, feed_dict={a: 2, b: 3})) #add结果，run这个add。把想求的add的值-目标数字放到里面就可以。feed_dict是输入的字典表示，变量和数字对应。
print(sess.run(mul, feed_dict={a: 2, b: 3}))
#意思是说在设计时候，定义了placeholder。新的数据来的时候，要fit进去这个地方，
#a,b相当于是方程，方程表达式。刚才说的y=ax+by，式子中x,y就是这里程序中的a,b.我用未知的表达量参与这个计算，得到一个方程。
#tensorflow在计算时候只需要中间那些计算量，可以直接告诉它a，b。然后告诉它想得到add这个结果，a,b是怎么表达的？用feed_dict-a是啥，b是啥，当然a和b也可能是一个矩阵。

#矩阵
matrix1 = tf.constant([[3., 3.]])
matrix2 = tf.constant([[2.],[2.]])
product = tf.matmul(matrix2, matrix1)
print(sess.run(product))

#here you should also be able to use tf.placeholder
mat1=tf.Variable(tf.random.normal([3,2])) #定义矩阵
mat2=tf.Variable(tf.random.normal([2,3]))
#做矩阵运算。
product=tf.matmul(mat1,mat2)

m1=[[1,3],[2,1],[0,5]]
m2=[[3,2,1],[1,2,3]]

print(sess.run(product,feed_dict={mat1:m1,mat2:m2}))
#我们做机器学习时候，product是最终的predict，中间好多卷积层/全连接层，输入时候得到一个图片。mat1是image图片，经过大量运算，会得到一个predict：product。
#

3.代码示例

'''
linear regression experiment, hope you can know:
1. how to design the learning model
2. optimize the model
3. dealing with the dataset

Original Author: Aymeric Damien
Edited by Wei Li for ChinaHadoop Deep learning course
Project: https://github.com/aymericdamien/TensorFlow-Examples/
'''
import tensorflow as tf
import numpy
rng = numpy.random

# model params额外的参数
learning_rate = 0.02
training_epochs = 3000
display_step=50
# data:X,Y数据
train_X = numpy.asarray([3.3,4.4,5.5,6.71,6.93,4.168,9.779,6.182,7.59,2.167,
                         7.042,10.791,5.313,7.997,5.654,9.27,3.1])
train_Y = numpy.asarray([1.7,2.76,2.09,3.19,1.694,1.573,3.366,2.596,2.53,1.221,
                         2.827,3.465,1.65,2.904,2.42,2.94,1.3])
n_samples = train_X.shape[0]

# tf Graph Input
#X和Y是从外面接过来的，直接设计一个placeholder
X = tf.compat.v1.placeholder ("float")
Y = tf.compat.v1.placeholder ("float")

# Set model weights
#W和B是参数，tf.Variable，初始值是rng.randn，给它一个name
W = tf.Variable(rng.randn(), name="weight")
b = tf.Variable(rng.randn(), name="bias")

# Construct a linear model
#predict是做一个相乘，WX+b.
pred = tf.add(tf.multiply(X, W), b)

# Mean squared error
#得到predict,要和真值做一个比较
cost = tf.reduce_sum(tf.pow(pred-Y, 2))/(2*n_samples)
# Gradient descent
#
optimizer = tf.compat.v1.train.GradientDescentOptimizer(learning_rate).minimize(cost)

# Initializing the variables
init = tf.compat.v1.global_variables_initializer()

# Launch the graph
with tf.compat.v1.Session() as sess:
    sess.run(init) #初始化

    # Fit all training data，开始训练
    #训练时，目的是要有一个慢慢优化的过程，所以这里期望得到一个optimizer
    #把optimizer设为要计算得到的东西的话，相当于cos/loss会用于gradient的update，参数就会得到优化
    for epoch in range(training_epochs):
        for (x, y) in zip(train_X, train_Y):
            sess.run(optimizer, feed_dict={X: x, Y: y})
     #feed_dict中，X就是train_X数据，每次投入一个小的数据，一次一次fit进来
        # Display logs per epoch step
        if (epoch+1) % display_step == 0:
            c = sess.run(cost, feed_dict={X: train_X, Y:train_Y})
            #前面的sess.run(optimizer, feed_dict={X: x, Y: y})是带着optimizer模型优化的，这里的计算c = sess.run(cost, feed_dict={X: train_X, Y:train_Y})就没有，因为这里相当于计算出某一个量来，我把输入给你，你把量计算出来，然后把量显示一下。如果你也想让这里的模型优化的话，会做前向和反向运算的话，是要把这里写成optimizer。如果只有cost，那就是只有前向运算。把中间某曾的feature放到这里的话，你就是做一个pitch structure的过程。
            print("Epoch:", '%04d' % (epoch+1), "cost=", "{:.9f}".format(c), \
                "W=", sess.run(W), "b=", sess.run(b))

    training_cost = sess.run(cost, feed_dict={X: train_X, Y: train_Y})
    print("Training cost=", training_cost, "W=", sess.run(W), "b=", sess.run(b), '\n') 

    # the testing data
    test_X = numpy.asarray([6.83, 4.668, 8.9, 7.91, 5.7, 8.7, 3.1, 2.1])
    test_Y = numpy.asarray([1.84, 2.273, 3.2, 2.831, 2.92, 3.24, 1.35, 1.03])

    print("Tssting...")
    testing_cost = sess.run(
        tf.reduce_sum(tf.pow(pred - Y, 2)) / (2 * test_X.shape[0]),
        feed_dict={X: test_X, Y: test_Y})  # same function as cost above
    print("Test LOSS=", testing_cost)
    print("Final Loss:", abs(
        training_cost - testing_cost))

五.一些深度学习的基本概念

1.神经元

最初出现在传统神经网络中。 
什么叫传统神经网络：
从简单的线性方程开始说：
我们有一个输入，a1....ak，k长的一个vector向量。要对这个向量进行理解，在计算时，每个输入对应一个小的变量w，k长的向量对应k个vector，每个w和其中一个子集符合，可以产生一个激励，这个激励是线型分布的，是和他线型相关的，在很多任务中，一个线型的描述没有很强的描述能力，所以我们加上一个非线性激励Activation function,得到一个a。
这么一个整个的概念是什么意思？就是一个小的线性计算或小的线性回归器加上一个非线性激励，合到一起，我们可以列一个小的非线性激励单元。
我们在计算时候认为，一个非线性单元其计算能力/表征能力有限，我们就把它做成好多个这样的单元。图1中的一个小的单元是图2中的一个小圆，这样的结构来好多，然后就有了一个所谓的网络结构，这样的网络结构来好几层，这样的整体结构很像基本的简单的神经元做一些简单的处理，然后把所有神经元合到一起做整合处理的过程，所以我们叫他神经网络。
神经元就是整个，叫他神经网络也好，感知机也好，全连接layer也好，这样的一个基本的计算单位，每一个神经元和前几层的所有输入是全连接的，然后有一个输出，并列得排了很多很多神经元，下一层的神经元和这一层的神经元也是每个线性连接，计算之后有一个非线性激励，就这样一层一层得到一个激励的结果。

2.卷积核–图像处理基本算子

边界/边缘检测算子

边界/边缘检测算子：
图像方面的特征提取大多从边缘开始，然后不断向上构成更高层次的特征描述。
边缘和物体的边界并不等同，边缘指的是图像中像素的值有突变的地方，而物体间的边界指的是现实场景中的存在于物体之间的边界。
用来产生图像边缘增强效果的运算单元。取2×2或3×3的矩阵。当取2×2矩阵时,可增强被该运算单元所覆盖区域的左上角像素与周围像素间的灰度差,当取3×3矩阵时被增强的像素则位于所覆盖区域的中心。通常使用的边缘算子有离散梯度算子、Roberts算子、Laplacian算子和Sobel算子等。

知道卷积核计算的方式，卷积核和图片进行处理时数学上是怎么存在的，卷积核的作用是什么。
作用是：不同的卷积核，这里是用边界算子，还有角点算子，把图片变模糊，他们对图片处理有一些相应的但是不同的物理意义。单一物理算子有不同物理意义，如果有成千上万个卷积核进行运算，再把运算结果进行整合，那就会产生非常有意思的应用，那就是卷积神经网络。
边界算子：
就是用边界算子可以算出图像的楞线/边线。边界是什么样子的。
比如说这里的图片，把边界算子放到这里，图片是由pixel像素组成的，从数学上看，这个图片其实是一堆二维的灰度矩阵(这是一张灰度图),拿这个卷积核和这个矩阵从一个地方进行计算的话，会得到一个相应的激励。
是怎么从一个图片得到一张边界图的？
我有这样一个算子，比如这张图片是100*100，边界算子是3*3的，在100*100的左上角的地方，我找一个3*3区间，我把这个边界算子(3*3矩阵)和他进行计算，计算时每个位置进行相乘，得到的的9个值相加，先相乘再相加得到一个值，得到的这个值把它放到对应的这个位置作为它的pixel。
这种结构的特点：比如说有另外一个矩阵，他在图片里面是一个边界，边界的这一层是1,1,1，这层都是0,0,0---由1和0组成的矩阵和边界算子计算，就对得到一个不是0的值。但是如果是一个白板，全都是10，和这个边界算子相乘就会全都是0.
所以图1这个矩阵就是在找局部结构是横线的结构，使得产生的值比较大，图2矩阵是找二维矩阵中是局部竖直结构的结构。最终结果是横的竖的响应位置都比较大，
下图就是一个卷积核和图片计算得到的结果。

边界算子如何取：
这是传统机器学习的东西，这些边界算子是这些科学家看到图片的这种结构之后设计出来的，但是卷积核不是这样的。
卷积核在进行计算时候一开始让他直接变成一个random的高斯卷积核就可以。
做深度学习时一开始就是把卷积核的值随便取，比如高斯卷积分布，经过训练之后卷积核会变成一些有物理意义的样子，这和传统机器学习不一样。
传统机器学习提前知道某个卷积核设计的什么样，大概有一个什么样的水平，直接知道他的水平是什么样的，然后直接提取一个特征，用提取的特征进行计算。
现在的卷积神经网络训练，直接原来就是一个随机的，训练完成后变成有物理意义的，具体什么物理意义也不知道。看的时候才发现这是某个作用。

卷积核就是一个矩阵，现在主流是3*3大的矩阵。
如下图的卷积核可视化：
卷积核可视化，直接变为图片。图中每个图片即每个小卷积核的物理意义不同。

2.传统神经网络

3.CNN-卷积神经网络

卷积神经网络其实就是卷积核的汇集

3.CNN的应用

1. 分类
   
2. 回归

回归侧重连续量的变化

3. 生成

也可以认为是回归，

生成-注意力图

生成-分割图

生成-艺术风格

四.问题解答

目标跟踪就是很多帧的目标检测
现在的参数调整比较自动化
其实所有的深度学习都是在开一个方程式，只不过哪个方程式是由大一些的卷积核组成的。
方程拟合是一个模型的训练，一个神经网络的训练也是一个大方程的拟合。