计算机视觉--网络搭建及训练（TensorFlow pytorch caffe）

深度学习模型训练痛点及解决方法 https://blog.csdn.net/weixin_40581617/article/details/80537559 
深度学习模型训练流程 https://blog.csdn.net/Quincuntial/article/details/79242364 
深度学习模型训练技巧 https://blog.csdn.net/w7256037/article/details/52071345 
https://blog.csdn.net/u012033832/article/details/79017951 
https://blog.csdn.net/u012968002/article/details/72122965

深度学习几大难点 https://blog.csdn.net/m0_37867246/article/details/797663711 

1  TensorFlow是什么？

该框架支持各种异构平台，支持多cpu/gpu,服务器，移动设备，良好的跨平台特性，能够灵活支持各种网络模型，还要良好的扩展性

2 TensorFlow的设计理念？

TensorFlow被认为是一个“符号主义”的库。编程模式被一般分为两种，命令式编程和符号编程，命令式编程就是一般我们编写的程序，便于调试和理解，按照原有的逻辑执行，符号编程涉及很多的嵌入和优化，不容易理解和调试。但速度有所提升。torch是命令式编程，caffe,MXnet采用两种混合。

符号计算一般先定义各种变量，然后建立一个数据流图。在数据流图中规定各个变量间的计算关系，最后需要对据流图进行编译，但此时的数据流图还是一个空壳儿，里面没有任何实际数据，只有把需要运算的输入放进去后，才能在整个模型中形成数据流，从而形成输出值

例如：

t = 8 + 9 print(t)

  在传统的程序操作中，定义了 t 的运算，在运行时就执行了，并输出 17。而在 TensorFlow中，数据流图中的节点，实际上对应的是 TensorFlow API 中的一个操作，并没有真正去运行：

 import tensorflow as tf t = tf.add(8,9) print( t）

TensorFlow 中涉及的运算都要放在图中，而图的运行只发生在会话（session）中。开启会话后，就可以用数据去填充节点，进行运算；关闭会话后，就不能进行计算了。因此，会话提供了操作运行和 Tensor 求值的环境

例如：

``` import tensorflow as tf

创建图

a = tf.constant([4.0,5.0]) b = tf.constant([6.0,7.0]) c = a * b

创建会话

sess = tf.Session()

计算c

print(sess.run(c)) #进行矩阵乘法，输出[24.,35.] sess.close() ```

3 TensorFlow的特点有哪些？

1.高度的灵活性

  TensorFlow 并不仅仅是一个深度学习库，只要可以把你的计算过程表示称一个数据流图的过程，我们就可以使用 TensorFlow 来进行计算。TensorFlow 允许我们用计算图的方式建立计算网络，同时又可以很方便的对网络进行操作。用户可以基于 TensorFlow 的基础上用 python 编写自己的上层结构和库，如果TensorFlow没有提供我们需要的API的，我们也可以自己编写底层的 C++ 代码，通过自定义操作将新编写的功能添加到 TensorFlow 中。

2.真正的可移植性

  TensorFlow 可以在 CPU 和 GPU 上运行，可以在台式机、服务器、移动设备上运行。你想在你的笔记本上跑一下深度学习的训练，或者又不想修改代码，想把你的模型在多个CPU上运行， 亦或想将训练好的模型放到移动设备上跑一下，这些TensorFlow都可以帮你做到。

3.多语言支持

  TensorFlow采用非常易用的python来构建和执行我们的计算图，同时也支持 C++ 的语言。我们可以直接写python和C++的程序来执行TensorFlow，也可以采用交互式的ipython来方便的尝试我们的想法。当然，这只是一个开始，后续会支持更多流行的语言，比如Lua，JavaScript 或者R语言。

4.丰富的算法库

  TensorFlow提供了所有开源的深度学习框架里，最全的算法库，并且在不断的添加新的算法库。这些算法库基本上已经满足了大部分的需求，对于普通的应用，基本上不用自己再去自定义实现基本的算法库了。

5.完善的文档

  TensorFlow的官方网站，提供了非常详细的文档介绍，内容包括各种API的使用介绍和各种基础应用的使用例子，也包括一部分深度学习的基础理论。

  自从宣布开源以来，大量人员对TensorFlow做出贡献，其中包括Google员工，外部研究人员和独立程序员，全球各地的工程师对TensorFlow的完善，已经让TensorFlow社区变成了Github上最活跃的深度学习框架。

4TensorFlow的编程模型是怎样的？

让向量数据在数据图流动，构建图---启动图---输入数据到图

第一部分：  构建图

TensorFlow的图类型是tf.graph，它包含计算节点和tensor的集合。tensor代表计算节点的输出，两个作用： 构建不同计算节点之间的数据流。 在启动图的时候。可以设置tensor的值，这样就完成了输入输出功能。

如下代码所示：

inImage = tf.placeholder(tf.float32,[32,32,3],"inputImage") processedImage = tf.image.per_image_standardization(inImage,"processedImage")

  这里inImage和processedImage都是tensor类型。它们代表着计算节点输出的数据，数据的值具体是多少在启动图的时候才知道。上面两个方法调用都传递了一个字符串，它是计算节点的名字，最好给节点命名，这样我们可以在图上调用gettensorby_name(name)获取对应的tensor对象，十分方便。（tensor名字为“<计算节点名字>:”）

计算节点：其功能是对tensor计算，创建tensor举个例子：

构建图，如下代码：

``` g=tf.Graph()

with g.asdefault(): inputdata=tf.placeholder(tf.float32,[None,2],"input_data") inputlabel=tf.placeholder(tf.float32,[None,2],"inputlabel")

W1=tf.Variable(tf.truncated_normal([2,2]),name="W1")
B1=tf.Variable(tf.zeros([2]),name="B1")

output=tf.add(tf.matmul(input_data,W1),B1,name="output")
cross_entropy=tf.nn.softmax_cross_entropy_with_logits(logits=output,labels=input_label)

train_step=tf.train.AdamOptimizer().minimize(cross_entropy,name="train_step")

initer=tf.global_variables_initializer()

 上面的代码中我们创建了一个图，并在上面添加了很多节点。我们可以通过调用getdefaultgraph()获取默认的图。

  Inputdata，inputlabel，W1，B1，output，crossentropy都是tensor类型，trainstep，initer，是节点类型。

有几类tensor或节点比较重要，下面介绍一下

1.placeholder

  Tensorflow，顾名思义， tensor代表张量数据，flow代表流，其最初的设计理念就是构建一张静态的数据流图。图是有各个计算节点连接而成，计算节点之间流动的便是中间的张量数据。要想让张量数据在我们构建的静态计算图中流动起来，就必须有最初的输入数据流。而placeholder，翻译过来叫做占位符，顾名思义，是给我们的输入数据提供一个接口，也就是说我们的一切输入数据，例如训练样本数据，超参数数据等都可以通过占位符接口输送到数据流图之中。使用实例如下代码：

 import tensorflow as tf x = tf.placeholder(dtype=tf.float32,shape=[],name='x') y = tf.placeholder(dtpe=tf.float32,shape=[],nmae='y') z = x*y with tf.Session() as sess: prod = sess.run(z,feed_dict={x:1.,y:5.2}) print(prod)

2. variable

  无论是传统的机器学习算法，例如线性支持向量机（Support Vector Machine, SVM)，其数学模型为y = <w,x> + b，还是更先进的深度学习算法，例如卷积神经网络（Convolutional Neural Network， CNN）单个神经元输出的模型y = w*x + b。可以看到，w和b就是我们要求的模型，模型的求解是通过优化算法（对于SVM，使用 SMO[1]算法，对于CNN，一般基于梯度下降法）来一步一步更新w和b的值直到满足停止条件。因此，大多数机器学习的模型中的w和b实际上是以变量的形式出现在代码中的，这就要求我们在代码中定义模型变量。

第二部分：启动图

以上介绍的都是构建图，创建张量和计算节点。

先了解session的概念，然后才能更好的理解图的启动。图的每个运行实例都必须在一个session里，session为图的运行提供环境。Session的类型是tf.Session，在实例化session对象时我们需要给它传递一个图对象，如果不显示给出将使用默认的图。Session有一个graph属性，我们可以通过它获取session对应的图。

代码如下：

``` numOfBatch=5 datas=np.zeros([numOfBatch,2],np.float32) labels=np.zeros([numOfBatch,2],np.float32)

sess=tf.Session(graph=g) graph=sess.graph sess.run([graph.getoperationby_name("initer")])

dataHolder=graph.gettensorbyname("inputdata:0") labelHolder=graph.gettensorbyname("inputlabel:0") train=graph.get_operationbyname("trainstep") out=graph.gettensorbyname("output:0")

for i inrange(200): result=sess.run([out,train],feed_dict={dataHolder:datas,labelHolder:labels}) if i%100==0: saver.save(sess,"./moules")

sess.close() ```

红色标记的代码段用到了session的run()方法，用来运行某个节点或者创建tensor并获取对应的值，如果我们运行的节点依赖某个placeholder，那我们必须给这个placeholder指定值，怎么指定代码里面很清楚，给关键字参数feed_dict传递一个字典即可，字典里的元素的key是placeholder对象，value是我们指定的值。值的数据的类型必须和placeholder一致，包括shape。值本身的类型是numpy数组。

实战：基于TensorFlow搭建VGG16

```python import numpy as np import tensorflow as tf

def getweightvariable(shape): return tf.get_variable('weight', shape=shape, initializer=tf.truncatednormalinitializer(stddev=0.1))

def getbiasvariable(shape): return tf.getvariable('bias', shape=shape, initializer=tf.constantinitializer(0))

def conv2d(x, w, padding = 'SAME', s=1): x = tf.nn.conv2d(x, w, strides=[1, s, s, 1], padding = padding) return x

def maxPoolLayer(x): return tf.nn.max_pool(x, ksize = [1, 2, 2, 1], strides = [1, 2, 2, 1], padding = 'SAME')

def conv2dlayer(x,inchs, outchs, ksize, layername): with tf.variablescope(layername): w = getweightvariable([ksize, ksize, inchs, outchs]) b = getbiasvariable([outchs]) y = tf.nn.relu(tf.biasadd(conv2d(x,w,padding = 'SAME', s=1), b)) return y

def fclayer(x,inkernels, outkernels, layername): with tf.variablescope(layername): w = getweightvariable([inkernels,outkernels]) b = getbiasvariable([outkernels]) y = tf.nn.relu(tf.biasadd(tf.matmul(x,w),b)) return y

def VGG16(x): conv11 = conv2dlayer(x,tf.getshape(x).aslist()[-1], 64, 3, 'conv11') conv12 = conv2dlayer(conv11,64, 64, 3, 'conv1_2') pool1 = maxPoolLayer(conv12)

conv2_1 = conv2d_layer(pool1,64, 128, 3, 'conv2_1')
conv2_2 = conv2d_layer(conv2_1,128, 128, 3, 'conv2_2')
pool2 = maxPoolLayer(conv2_2)

conv3_1 = conv2d_layer(pool2,128, 256, 3, 'conv3_1')
conv3_2 = conv2d_layer(conv3_1,256, 256, 3, 'conv3_2')
conv3_3 = conv2d_layer(conv3_2,256, 256, 3, 'conv3_3')
pool3 = maxPoolLayer(conv3_3)

conv4_1 = conv2d_layer(pool3,256, 512, 3, 'conv4_1')
conv4_2 = conv2d_layer(conv4_1,512, 512, 3, 'conv4_2')
conv4_3 = conv2d_layer(conv4_2,512, 512, 3, 'conv4_3')
pool4 = maxPoolLayer(conv4_3)

conv5_1 = conv2d_layer(pool4,512, 512, 3, 'conv5_1')
conv5_2 = conv2d_layer(conv5_1,512, 512, 3, 'conv5_2')
conv5_3 = conv2d_layer(conv5_1,512, 512, 3, 'conv5_3')
pool5 = maxPoolLayer(conv5_3)

pool5_flatten_dims = int(np.prod(pool5.get_shape().as_list()[1:]))
pool5_flatten = tf.reshape(pool5,[-1,pool5_flatten_dims])

fc_6 = fc_layer(pool5_flatten, pool5_flatten_dims, 4096, 'fc6')
fc_7 = fc_layer(fc_6, 4096, 4096, 'fc7')
fc_8 = fc_layer(fc_7, 4096, 10, 'fc8')

return fc_8

 2.1 Pytorch是什么？

 Pytorch是torch的python版本，是由Facebook开源的神经网络框架，专门针对 GPU 加速的深度神经网络（DNN）编程。Torch 是一个经典的对多维矩阵数据进行操作的张量（tensor ）库，在机器学习和其他数学密集型应用有广泛应用。与Tensorflow的静态计算图不同，pytorch的计算图是动态的，可以根据计算需要实时改变计算图。但由于Torch语言采用 Lua，导致在国内一直很小众，并逐渐被支持 Python 的 Tensorflow 抢走用户。作为经典机器学习库 Torch 的端口，PyTorch 为 Python 语言使用者提供了舒适的写代码选择。

2.2 为什么选择 Pytorch？

1.简洁：

  PyTorch的设计追求最少的封装，尽量避免重复造轮子。不像 TensorFlow 中充斥着session、graph、operation、name_scope、variable、tensor、layer等全新的概念，PyTorch 的设计遵循tensor→variable(autograd)→nn.Module 三个由低到高的抽象层次，分别代表高维数组（张量）、自动求导（变量）和神经网络（层/模块），而且这三个抽象之间联系紧密，可以同时进行修改和操作。 简洁的设计带来的另外一个好处就是代码易于理解。PyTorch的源码只有TensorFlow的十分之一左右，更少的抽象、更直观的设计使得PyTorch的源码十分易于阅读。

2.速度：

  PyTorch 的灵活性不以速度为代价，在许多评测中，PyTorch 的速度表现胜过 TensorFlow和Keras 等框架。框架的运行速度和程序员的编码水平有极大关系，但同样的算法，使用PyTorch实现的那个更有可能快过用其他框架实现的。

3.易用：

  PyTorch 是所有的框架中面向对象设计的最优雅的一个。PyTorch的面向对象的接口设计来源于Torch，而Torch的接口设计以灵活易用而著称，Keras作者最初就是受Torch的启发才开发了Keras。PyTorch继承了Torch的衣钵，尤其是API的设计和模块的接口都与Torch高度一致。PyTorch的设计最符合人们的思维，它让用户尽可能地专注于实现自己的想法，即所思即所得，不需要考虑太多关于框架本身的束缚。

4.活跃的社区：

  PyTorch 提供了完整的文档，循序渐进的指南，作者亲自维护的论坛 供用户交流和求教问题。Facebook 人工智能研究院对 PyTorch 提供了强力支持，作为当今排名前三的深度学习研究机构，FAIR的支持足以确保PyTorch获得持续的开发更新，不至于像许多由个人开发的框架那样昙花一现。

Pytorch 与 tensorflow 之间的差异在哪里？

  上面也将了PyTorch 最大优势是建立的神经网络是动态的, 对比静态的 Tensorflow, 它能更有效地处理一些问题, 比如说 RNN 变化时间长度的输出。各有各的优势和劣势。两者都是大公司发布的, Tensorflow（Google）宣称在分布式训练上下了很大的功夫, 那就默认 Tensorflow 在分布式训练上要超出 Pytorch（Facebook），还有tensorboard可视化工具, 但是 Tensorflow 的静态计算图使得在 RNN 上有一点点被动 (虽然它用其他途径解决了), 不过用 PyTorch 的时候, 会对这种动态的 RNN 有更好的理解。而且 Tensorflow 的高度工业化, 它的底层代码很难看懂， Pytorch 好那么一点点, 如果深入 PytorchAPI, 至少能比看 Tensorflow 多看懂一点点 Pytorch 的底层在干啥。

Pytorch有哪些常用工具包？

  torch ：类似 NumPy 的张量库，强 GPU 支持 ；   torch.autograd ：基于 tape 的自动区别库，支持 torch 之中的所有可区分张量运行；   torch.nn ：为最大化灵活性未涉及、与 autograd 深度整合的神经网络库；   torch.optim：与 torch.nn 一起使用的优化包，包含 SGD、RMSProp、LBFGS、Adam 等标准优化方式；   torch.multiprocessing： python 多进程并发，进程之间 torch Tensors 的内存共享；   torch.utils：数据载入器。具有训练器和其他便利功能；   torch.legacy(.nn/.optim) ：处于向后兼容性考虑，从 Torch 移植来的 legacy 代码；

caffe

1 caffe 特点：

(1)、模块化：Caffe从一开始就设计得尽可能模块化，允许对新数据格式、网络层和损失函数进行扩展。

(2)、表示和实现分离：Caffe的模型(model)定义是用Protocol Buffer语言写进配置文件的。以任意有向无环图的形式，Caffe支持网络架构。Caffe会根据网络的需要来正确占用内存。通过一个函数调用，实现CPU和GPU之间的切换。

(3)、测试覆盖：在Caffe中，每一个单一的模块都对应一个测试。

(4)、python和Matlab接口：同时提供Python和Matlab接口。

(5)、预训练参考模型：针对视觉项目，Caffe提供了一些参考模型，这些模型仅应用在学术和非商业领域，它们的license不是BSD。

 Caffe的设计思想是怎样的？

caffe 沿用了神经网络的一个简单假设--所有计算都是以层的形式表示，层做的事情就是接受一些数据，然后输出一个计算之后的结果，比如说卷积，就是输入一个图像，然后和这一层的参数做卷积，然后输出卷积的结果，每一个层需要做两个计算：前项计算和反向计算,只要这两个函数实现了以后，我们就可以把很多层连接成一个网络，这个网络做的事情就是输入我们的数据（图像或者语音），在训练的时候我们可以根据已有的标签来计算loss和梯度，然后修正网络的参数，这是caffe的一个基本流程。

  Fine tune方法：fine tuning的想法就是说，在imagenet那么大的数据集上train好一个很牛的网络了，那别的task上肯定也不错，所以我们可以把pretrain的网络拿过来，然后只重新train最后几层，重新train的意思是说，比如我以前需要classify imagenet的一千类，现在我只想识别是狗还是猫，或者是不是车牌，于是我就可以把最后一层softmax从一个40961000的分类器变成一个40962的分类器，这个strategy在应用中非常好使，所以我们经常会先在imagenet上pretrain一个网络，因为我们知道imagenet上training的大概过程会怎么样。

Caffe架构是怎样的？

1. SyncedMem

  这个类的主要功能是封装CPU和GPU的数据交互操作。一般来说，数据的流动形式都是：硬盘->CPU内存->GPU内存->CPU内存->（硬盘），所以在写代码的过程中经常会写CPU/GPU之间数据传输的代码，同时还要维护CPU和GPU两个处理端的内存指针。这些事情处理起来不会很难，但是会很繁琐。因此SyncedMem的出现就是把CPU/GPU的数据传输操作封装起来，只需要调用简单的接口就可以获得两个处理端同步后的数据。

2. Blob

  Blob是用于存储数据的对象，在Caffe中各种数据(图像输入、模型参数)都是以Blob的形式在网络中传输的，Blob提供统一的存储操作接口，可用来保存训练数据、模型参数等，同时Blob还能在CPU和GPU之间进行同步以支持CPU/GPU的混合运算。   这个类做了两个封装：一个是操作数据的封装，使用Blob可以操纵高维的数据，快速访问其中的数据，变换数据的维度等；另一个是对原始数据和更新量的封装，每一个Blob中都有data和diff两个数据指针，data用于存储原始数据，diff 用于存储反向传播（Backpropagation）的梯度更新值。Blob使用了SyncedMem，这样便于访问不同的处理端。Blob基本实现了整个Caffe数据结构部分的封装，在Net类中可以看到所有的前后向数据和参数都用Blob来表示就足够了。数据的抽象到这个就可以了，接下来作层级的抽象。神经网络的前后向计算可以做到层与层之间完全独立，只要每个层按照一定的接口规则实现，就可以确保整个网络的正确性。

4. Net

  Net是一个完整的深度网络，包含输入层、隐藏层、输出层，在Caffe中一般是一个卷积神经网络(Convolution Neural Networ，CNN)。通过定义不同类型的Layer，并用Blob将不同的Layer连接起来，就能产生一个Net。Net将数据Blob和层Layer组合起来做进一步的封装，对外提供了初始化和前后传播的接口，使得整体看上去和一个层的功能类似，但内部的组合可以是多种多样的。值得一提的是，每一层的输入输出数据统一保存在Net中，同时每个层内的参数指针也保存在Net中，不同的层可以通过WeightShare共享相同的参数，因此可以通过配置来实现多个神经网络层之间共享参数的功能。一个Net由多个Layer组成。一个典型的网络从data layer（从磁盘中载入数据）出发到loss layer结束。

5. Solver

  有了Net就可以进行神经网络的前后向传播计算了，但是还缺少神经网络的训练和预测功能，Solver类进一步封装了训练和预测相关的一些功能。它还提供了两个接口：一个是更新参数的接口，继承Solver可以实现不同的参数更新方法，如Momentum，Nesterov，Adagrad等，因此可以使用不同的优化算法。另一个接口是训练过程中每一轮特定状态下的可注入的一些回调函数，在代码中这个回调点的直接使用者就是多GPU训练算法。Solver定义了针对Net网络模型的求解方法，记录网络的训练过程，保存网络模型参数，中断并恢复网络的训练过程。自定义Solver能够实现不同的神经网络求解方式。阅读Solver的代码可以了解网络的求解优化过程。Solver是一个父类，它下面还有实现不同优化方法的子类，例如sgdsolver，adagradsovler等，Solver是通过SolverFactory来创建的。