Tensorflow知识点总结（三）

大部分内容整理自《Tensorflow实战Google深度学习框架》

在前面计算图、张量、会话、Tensorflow游乐场的基础上转到神经网络，MLP的神经元，层数，参数之前已经了解。从Tensorflow游乐场模型上课看出，使用神经网络解决分类问题主要分为以下4个步骤：

1.提取问题中实现实体的特征向量作为神经网络的输入，不同的实体可以提取不同的特征向量。

2.定义神经网络的结构，并定义如何从神经网络的输入得到输出，这个过程就是神经网络的前向传播算法。输出就是所有输入的加权和。

3.通过训练数据来调整神经网络中参数的值，不同输入的权重就是我们要调节的参数

4.使用训练好的数据预测未知的数据

如下是用tensorflow通过变量实现神经网络的参数并实现前向传播的过程：

import tensorflow as tf
w1=tf.Variable(tf.random_normal([2, 3], stddev=1, seed=1),name="w1")
w2=tf.Variable(tf.random_normal([3, 1], stddev=1, seed=1),name="w2")
x=tf.constant([[0.7, 0.9]])
a=tf.matmul(x, w1)
y=tf.matmul(a, w2)

sess = tf.Session()
sess.run(w1.initializer)
sess.run(w1.initializer)
print(sess.run(y))
sess.close()

这里变量初始化也可以如下方式（上面是直接调用每个变量的初始化过程，但是当变量数目增多，变量之间存在依赖关系时，单个的调用方法就麻烦了）：

import tensorflow as tf

tf.reset_default_graph()
w1=tf.Variable(tf.random_normal([2, 3], stddev=1, seed=1),name="w1")
w2=tf.Variable(tf.random_normal([3, 1], stddev=1, seed=1),name="w2")
x=tf.constant([[0.7, 0.9]])
a=tf.matmul(x, w1)
y=tf.matmul(a, w2)
init_op=tf.initialize_all_variables()

with tf.Session() as sess:
    sess.run(init_op)
    print(sess.run(y))
    writer = tf.summary.FileWriter("D://tensorflow-log//test_tensorboard2", tf.get_default_graph())
    writer.close()
    """
    输出所有的变量
    """
    for i in tf.trainable_variables():
        print(i)
    """
    对所属的计算图进行输出,可以发现使用变量、常数、操作、以及默认图进行的输出结果是一样的
    """
    print(tf.get_default_graph())
    print(a.graph)##可以直接使用某一个操作
    print(w1.graph)
    print(x.graph)
    """
    对张量进行输出
    """
    print(tf.get_default_graph().get_tensor_by_name("w1:0")) ##合理

 类似张量，维度（shape）和类型(type)是变量的最重要两个属性，构建后类型不可以改变，维度可以改变，如下会报错：

w1=tf.Variable(tf.random_normal([2,3],stddev=1),name="w1")
w2=tf.Variable(tf.random_normal([2,3],dtype=tf.float64,stddev=1),name="w2")
w1.assign(w2)

如下可以成功执行,前提是validate_shape=False选项要加上

w1=tf.Variable(tf.random_normal([2,3],stddev=1),name="w1")
w2=tf.Variable(tf.random_normal([2,2],stddev=1),name="w2")
tf.assign(w1,w2,validate_shape=False)

设置神经网络参数的过程就是神经网络训练的过程，在神经网络的优化算法中最常用的方法是反向传播算法，在每次迭代开始先选取一小部分训练数据，这一小部分数据叫做一个batch, 可以计算出当前神经网络模型的预测答案与正确答案之间的差距。基于这个预测值和真实值之间的差距，去更新神经网络的参数。

如下是placeholfer机制的使用案例：

#!/usr/bin/env python
# -*- coding: utf-8 -*-
# author：Icecream.Shao
import tensorflow as tf

tf.reset_default_graph()
w1=tf.Variable(tf.random_normal([2, 3], stddev=1, seed=1),name="w1")
w2=tf.Variable(tf.random_normal([3, 1], stddev=1, seed=1),name="w2")
x=tf.placeholder(tf.float32,shape=(1,2),name="input")
a=tf.matmul(x, w1)
y=tf.matmul(a, w2)

sess=tf.Session()
init_op=tf.initialize_all_variables()
sess.run(init_op)
print(sess.run(y,feed_dict={x:[[0.7,0.9]]}))

然后第3章里示例了一个完整的样例

batch size为8，128个样本，用了placeholder，定义了前向传播算法（只有一层隐藏层）,并没有加入激活函数和偏置项，训练了5000次，定义了损失函数。可以认为是一个线性的神经网络

接着讲用激活函数实现去线性化（加上激活函数和偏置项），激活函数有ReLU, Sigmoid，tanh函数

接着重点讲解了损失函数，提到了交叉熵是常用的评判方法之一。softmax回归将神经网络的输出变成一个概率分布。

                                                                            

有了求出的概率分布后，容易计算出交叉熵，公式为：

                                                                     

假设某个样本的正确答案是（1,0,0）

经softmax回归之后的预测答案是（0.5,0.4，0.1），那么交叉熵为：

H((1,0,0),(0.5,0.4,0.1))=-(1*log0.5+0*log0.4+0*log0.1）~0.3

tf.clip_by_value函数可以限制张量中的数值限制在一个范围内，可以避免一些运算错误，比如log0.

tf.mean函数可以求平均值，求得一个batch平均交叉熵。

tensorflow提供tf.nn.softmax_cross_entropy_with_logits(y,y_)做了封装，来计算该batch回归之后的交叉熵。

又介绍了解决回归问题最常用的损失函数均方误差

                                                            

除了以上介绍的两个函数外，还可以自定义其它损失函数

接下来重点介绍了神经网络的优化算法，

（1）用梯度下降算法调整神经网络中的参数取值

假设初始值为5，学习率0.3，梯度下降算法优化函数（损失函数的大小）J(x)=x^2

轮数	当前轮参数值	梯度*学习率	更新后参数值
1	5	2*5*0.3=3	5-3=2
2	2	2*2*0.3=1.2	2-1.2=0.8
3	0.8	2*0.8*0.3=0.48	0.8-0.48=0.32
4	0.32	2*0.32*0.3=0.192	0.32-0.192=0.128
5	0.128	2*0.128*0.3=0.0768	0.128-0.0768=0.0512

梯度下降算法并不能保证被优化函数达到全局最优，只有当损失函数为凸函数时，梯度下降算法才能保证达到全局最优解

一般会综合梯度下降算法和随机梯度下降算法，

（2）学习率（初始学习率，衰减系数和衰减速度）

（3）正则化（在损失函数中加入刻画模型复杂程度的指标），L1正则化和L2正则化

w=tf.Variable(tf.random_normal([2,1], stddev=1,seed=1))
y=tf.matmul(x,w)
loss=tf.reduce_mean(tf.square(y_-y))+tf.contrib.layers.l2_regularizer(lambda )(w)

这边的损失函数由两部分组成，第一个部分是均方差损失函数，第二个部分是正则化

可以使用tensorflow中提供的集合collection来计算损失函数

mse_loss=tf.reduce_mean(tf.square(y_ - cur_layer))
tf.add_to_collection('losses',mse_loss)
loss = tf.add_n(tf.get_collection('losses'))

最后介绍了滑动平均模型tf.train.ExponentialMovingAverage()

shadow_variable函数为影子变量，variable为代更新的变量，decay为衰减率。

接下来介绍了Mnist数据集，然后给出结合以上所有优化手段训练只有一个隐藏层的神经网络MLP

结论：在神经网络结构的设计上，需要使用激活函数和多层隐藏层，在神经网络优化时，可以使用指数衰减学习率，加入正则化损失函数，滑动平均模型。由于在MNIST，模型收敛速度很快。

使用所有优化，不用滑动平均，不用正则化，不同指数衰减学习率的正确率到98%多

不用隐藏层，不用激活函数时，只能到92%

接下来讲了变量管理。当tf.variable_scope函数使用参数reuse=True生成上下文管理器时，这个上下文管理器内所有的tf.get_variable函数会直接获取已经创建的变量。如果变量不存在，就会报错。

当tf.variable_scope函数使用参数reuse=False生成上下文管理器时，tf.get_variable操作将创建新的变量。如果同名的变量已经存在，则tf.get_variable函数将报错。

#!/usr/bin/env python
# -*- coding: utf-8 -*-
# author：Icecream.Shao
import tensorflow as tf
with tf.variable_scope("foo"):
    v=tf.get_variable("v",[1],initializer=tf.constant_initializer(1.0))

#如下语句
with tf.variable_scope("foo"):
    v=tf.get_variable("v",[1])

with tf.variable_scope("foo",reuse=True):
    v1 = tf.get_variable("v",[1])
    print(v==v1)

#如下语句会报错
with tf.variable_scope("bar",reuse=True):
    v=tf.get_variable("v",[1])

tf.variable_scope函数除了可以控制tf.get_variable执行的功能之外，这个函数也提供了一个管理变量命名空间的方式。

#!/usr/bin/env python
# -*- coding: utf-8 -*-
# author：Icecream.Shao
import tensorflow as tf
v1=tf.get_variable("v",[1])
print(v1.name)

with tf.variable_scope("foo"):
    v2=tf.get_variable("v",[1])
    print(v2.name)

with tf.variable_scope("foo"):
    with tf.variable_scope("bar"):
        v3=tf.get_variable("v",[1])
        print(v3.name)

    v4 = tf.get_variable("v1",[1])
    print(v4.name)

with tf.variable_scope("",reuse=True):
    v5=tf.get_variable("foo/bar/v")
    print(v5==v3)

    v6=tf.get_variable("foo/v1")
    print(v6==v4)

with tf.Session() as sess:
    #sess.run(tf.global_variables_initializer())
    tf.initialize_all_variables().run()
    print("v1: ", v1.eval())
    print("v2: ", v2.eval())
    print("v3: ", v3.eval())

    print("v4: ", v4.eval())
    print("v5: ", v5.eval())
    print("v6: ", v6.eval())

结果为：v1:  [-0.61839104]
v2:  [0.03291154]
v3:  [0.9467553]
v4:  [-0.49030578]
v5:  [0.9467553]
v6:  [-0.49030578]

接下来讲了模型持久化，tf.train.Saver（）会保存运行tensorflow程序所需要的的全部信息

结合变量管理机制和tensorflow模型持久化机制，介绍了一个tensorflow训练神经网络的最佳实践，将训练和测试分为两个独立的程序，有三个程序mnist_inference.py, mnist_train.py,mnist_eval.py

mnisy_inference.py程序如下：

#!/usr/bin/env python
# -*- coding: utf-8 -*-
# author：Icecream.Shao
# -*- coding: utf-8 -*-
import tensorflow as tf

# 定义神经网络结构相关的参数
INPUT_NODE = 784
OUTPUT_NODE = 10
LAYER1_NODE = 500

# 通过tf.get_variable函数来获取变量。在训练神经网络时会创建这些变量；在测试时会通
# 过保存的模型加载这些变量的取值。而且更加方便的是，因为可以在变量加载时将滑动平均变
# 量重命名，所以可以直接通过相同的名字在训练时使用变量自身，而在测试时使用变量的滑动
# 平均值。在这个函数中也会将变量的正则化损失加入到损失集合。
def get_weight_variable(shape, regularizer):
    weights = tf.get_variable(
        "weights", shape,
        initializer=tf.truncated_normal_initializer(stddev=0.1)
    )
    # 当给出了正则化生成函数时，将当前变量的正则化损失加入名字为losses的集合。在这里
    # 使用了add_to_collection函数将一个张量加入一个集合，而这个集合的名称为losses。
    # 这是自定义的集合，不在TensorFlow自动管理的集合列表中。
    if regularizer != None:
        tf.add_to_collection('losses', regularizer(weights))
    return weights

# 定义神经网络的前向传播过程
def inference(input_tensor, regularizer):
    # 声明第一层神经网络的变量并完成前向传播过程。
    with tf.variable_scope('layer1'):
        # 这里通过tf.get_variable或者tf.Variable没有本质区别，因为在训练或者测试
        # 中没有在同一个程序中多次调用这个函数。如果在同一个程序中多次调用，在第一次
        # 调用之后需要将reuse参数设置为True。
        weights = get_weight_variable(
            [INPUT_NODE, LAYER1_NODE], regularizer
        )
        biases = tf.get_variable(
            "biases", [LAYER1_NODE],
            initializer=tf.constant_initializer(0.0)
        )
        layer1 = tf.nn.relu(tf.matmul(input_tensor, weights)+biases)

    # 类似的声明第二层神经网络的变量并完成前向传播过程。
    with tf.variable_scope('layer2'):
        weights = get_weight_variable(
            [LAYER1_NODE, OUTPUT_NODE], regularizer
        )
        biases = tf.get_variable(
            "biases", [OUTPUT_NODE],
            initializer=tf.constant_initializer(0.0)
        )
        layer2 = tf.matmul(layer1, weights) + biases

    # 返回最后前向传播的结果
    return layer2

mnist_train.py程序如下：

# -*- coding: utf-8 -*-
import os

import tensorflow as tf
from tensorflow.examples.tutorials.mnist import input_data

# 加载mnist_inference.py中定义的常量和前向传播的函数。
import mnist_inference

# 配置神经网络的参数。
BATCH_SIZE = 100
LEARNING_RATE_BASE = 0.8
LEARNING_RATE_DECAY = 0.99
REGULARIZATION_RATE = 0.0001
TRAINING_STEPS = 10000
MOVING_AVERAGE_DECAY = 0.99

# 模型保存的路径和文件名
MODEL_SAVE_PATH = "./model/"
MODEL_NAME = "model.ckpt"

def train(mnist):
    # 定义输入输出placeholder。
    x = tf.placeholder(tf.float32, [None, mnist_inference.INPUT_NODE], name='x-input')
    y_ = tf.placeholder(tf.float32, [None, mnist_inference.OUTPUT_NODE], name='y-input')

    regularizer = tf.contrib.layers.l2_regularizer(REGULARIZATION_RATE)
    # 直接使用mnist_inference.py中定义的前向传播过程
    y = mnist_inference.inference(x, regularizer)


    global_step = tf.Variable(0, trainable=False)

    # 定义损失函数、学习率、滑动平均操作以及训练过程
    variable_averages = tf.train.ExponentialMovingAverage(
        MOVING_AVERAGE_DECAY, global_step
    )
    variable_averages_op = variable_averages.apply(
        tf.trainable_variables()
    )
    cross_entropy = tf.nn.sparse_softmax_cross_entropy_with_logits(
        logits=y, labels=tf.argmax(y_, 1)
    )
    cross_entropy_mean = tf.reduce_mean(cross_entropy)
    loss = cross_entropy_mean + tf.add_n(tf.get_collection('losses'))
    learning_rate = tf.train.exponential_decay(
        LEARNING_RATE_BASE,
        global_step,
        mnist.train.num_examples / BATCH_SIZE,
        LEARNING_RATE_DECAY
    )
    train_step = tf.train.GradientDescentOptimizer(learning_rate)\
                   .minimize(loss, global_step=global_step)
    with tf.control_dependencies([train_step, variable_averages_op]):
        train_op = tf.no_op(name='train')

    # 初始化TensorFlow持久化类

    saver = tf.train.Saver()
    writer = tf.summary.FileWriter("D:\\tensorflow-log\\test_mlp_true_net", tf.get_default_graph())
    writer.close()
    with tf.Session() as sess:
        tf.global_variables_initializer().run()

        # 在训练过程中不再测试模型在验证数据上的表现，验证和测试的过程将会有一个独
        # 立的程序来完成。
        for i in range(TRAINING_STEPS):
            xs, ys = mnist.train.next_batch(BATCH_SIZE)
            _, loss_value, step = sess.run([train_op, loss, global_step],
                                           feed_dict={x: xs, y_: ys})
            # 每1000轮保存一次模型
            if i % 1000 == 0:
                # 输出当前的训练情况。这里只输出了模型在当前训练batch上的损失
                # 函数大小。通过损失函数的大小可以大概了解训练的情况。在验证数
                # 据集上正确率的信息会有一个单独的程序来生成
                print("After %d training step(s), loss on training "
                      "batch is %g." % (step, loss_value))
                # 保存当前的模型。注意这里给出了global_step参数，这样可以让每个
                # 被保存的模型的文件名末尾加上训练的轮数，比如“model.ckpt-1000”，
                # 表示训练1000轮之后得到的模型。
                saver.save(
                    sess, os.path.join(MODEL_SAVE_PATH, MODEL_NAME),
                    global_step=global_step
                )
        # 将当前的计算图输出到TensorBoard日志文件。


def main(argv=None):
    mnist = input_data.read_data_sets("./data", one_hot=True)
    train(mnist)

if __name__ == "__main__":
    tf.app.run()

mnist_eval.py程序如下：

#!/usr/bin/env python
# -*- coding: utf-8 -*-
# author：Icecream.Shao
import time
import tensorflow as tf
from tensorflow.examples.tutorials.mnist import input_data

# 加载mnist_inference.py 和mnist_train.py中定义的常量和函数。
import mnist_inference
import mnist_train

# 每10秒加载一次最新的模型，并且在测试数据上测试最新模型的正确率
EVAL_INTERVAL_SECS = 10

def evaluate(mnist):
    with tf.Graph().as_default() as g:
        # 定义输入输出的格式。
        x = tf.placeholder(
            tf.float32, [None, mnist_inference.INPUT_NODE], name='x-input'
        )
        y_ = tf.placeholder(
            tf.float32, [None, mnist_inference.OUTPUT_NODE], name='y-input'
        )
        validate_feed = {x: mnist.validation.images,
                         y_: mnist.validation.labels}

        # 直接通过调用封装好的函数来计算前向传播的结果。因为测试时不关注ze正则化损失的值
        # 所以这里用于计算正则化损失的函数被设置为None。
        y = mnist_inference.inference(x, None)

        # 使用前向传播的结果计算正确率。如果需要对未知的样例进行分类，那么使用
        # tf.argmax(y,1)就可以得到输入样例的预测类别了。
        correct_prediction = tf.equal(tf.argmax(y, 1), tf.argmax(y_, 1))
        accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))

        # 通过变量重命名的方式来加载模型，这样在前向传播的过程中就不需要调用求滑动平均
        # 的函数来获取平均值了。这样就可以完全共用mnist_inference.py中定义的
        # 前向传播过程。
        variable_averages = tf.train.ExponentialMovingAverage(
            mnist_train.MOVING_AVERAGE_DECAY
        )
        variables_to_restore = variable_averages.variables_to_restore()
        saver = tf.train.Saver(variables_to_restore)

        # 每隔EVAL_INTERVAL_SECS秒调用一次计算正确率的过程以检验训练过程中正确率的
        # 变化。
        while True:
            with tf.Session() as sess:
                # tf.train.get_checkpoint_state函数会通过checkpoint文件自动
                # 找到目录中最新模型的文件名。
                ckpt = tf.train.get_checkpoint_state(
                    mnist_train.MODEL_SAVE_PATH
                )
                if ckpt and ckpt.model_checkpoint_path:
                    # 加载模型。
                    saver.restore(sess, ckpt.model_checkpoint_path)
                    # 通过文件名得到模型保存时迭代的轮数。
                    global_step = ckpt.model_checkpoint_path\
                                      .split('/')[-1].split('-')[-1]
                    accuracy_score = sess.run(accuracy,
                                              feed_dict=validate_feed)
                    print("After %s training step(s), validation "
                          "accuracy = %g" % (global_step, accuracy_score))
                else:
                    print("No checkpoint file found")
                    return
            time.sleep(EVAL_INTERVAL_SECS)

def main(argv=None):
    mnist = input_data.read_data_sets("./data", one_hot=True)
    evaluate(mnist)

if __name__ == "__main__":
    tf.app.run()

卷积神经网络能够很好的利用图像的结构信息，在全连接神经网络中，每相邻两层之间的节点都有边相连，对于卷积神经网络，相邻两层之间只有部分节点相连。tensorflow训练一个卷积神经网络和全连接神经网络没有任何区别。对于mnist数据集，假设用全连接神经网络，每一张图片的大小为28*28*1，所以输入有28*28*1个节点，假设第一层隐藏层的节点数为500个，那么一个全连接神经网络有28*28*500+500个参数。假设是cifar-10图像，大小为32*32*3，则输入层有32*32*3个节点，假设隐藏层有500个节点，则有32*32*3*500+500~150万个参数。

CNN主要有三大特色，分别是局部感知、权重共享和多卷积核。

局部感知就是所说的感受野，实际上就是卷积核和图像卷积的时候，每次卷积核所覆盖的像素只是一小部分，是局部特征，所以说是局部感知。感受野的计算见我之前的博客

权重共享，不同的图像或者同一张图像共用一个卷积核，减少重复的卷积核。同一张图像当中可能会出现相同的特征，共享卷积核能够进一步减少权值参数。

多卷积核，一种卷积核代表的是一种特征，为获得更多不同的特征集合，卷积层会有多个卷积核，生成不同的特征，这也是为什么卷积后的图片的高，每一个图片代表不同的特征，一般输出单位节点矩阵的深度代表卷积核的个数

共享每一层卷积层中过滤器中的参数可巨幅减少神经网络上的参数。以cifar-10问题为例，输入层矩阵的维度为32*32*3，假设第一层卷积层使用尺寸为5*5，深度为16的过滤器，那么这个卷积层参数的个数为5*5*3*16+16=1216个。相比较前面150万个参数减少很多。

全0填充，一定步长，一定大小的过滤器卷积后的图像大小计算见我之前博客。

可以自己构建一个参数矩阵去遍历图像实现

当中四维矩阵前两维代表过滤器的尺寸，第三个代表深度，第四个表示过滤器的深度

filter_weight = tf.get_variable('weights',[5,5,3,16],initializer=tf.truncated_normal_initializer(stddev=0.1))
biases=tf.get_variable('biases',[16],initializer=tf.constant_initializer(0.1))

但可以用tf.nn.conv2d来实现卷积层前向传播的算法，第一个输入为当前层的节点矩阵，这个矩阵是四维矩阵，后面三维对应一个节点矩阵，第一维对应一个输入batch, 第二个参数提供了卷积层的权重，第三个参数为不同维度上的步长，第一维和最后一维的数字要求一定为1，最后一个是填充的方法，SAME表示全0填充，VALID表示不添加

conv = tf.nn.conv2d(input,filter_weight,strides=[1,1,1,1],padding='SAME')
bias = tf.nn.bias_add(conv, biases)
actived_conv = tf.nn.relu(bias)

一个卷积神经网络主要由以下5中结构组成：

输入层、卷积层、池化层、全连接层、softmax层

pool=tf.nn.max_pool(actived_conv,ksize=[1,3,3,1],strides=[1,2,2,1],padding="SAME")

和卷积层类似，要先传入四维矩阵，第二个参数为过滤器的尺寸，第三个参数为步长，第四个参数和卷积层设置保持一致

接下来分析了经典的卷积网络模型LeNet-5模型，可以对比我的博客：caffe使用命令行方式训练预测mnist、cifar10及自己的数据集中caffe实现的LeNet-5结构

并给出了实现LetNet-5模型的tensorflow程序，只需要修改前面的mnist_inference.py即可，在这个程序中使用了dropout方法，dropout可以进一步提升模型可靠性并防止过拟合，dropout过程只在训练时使用。

后面又介绍了Inception-v3模型

后面又介绍了卷积神经网络迁移学习的程序示例

图像数据处理，多线程输入，循环神经网络，计算加速。

tensorflow源码编译可见我之前的博客win7下VS2015编译tensorflow源码教程（在线和离线）及调用配置

不同于caffe,使用tensorflow框架基本还是在python环境下去搭建网络结构（可结合keras快速搭建），训练和测试

我的其它博客有介绍如何源码编译caffe，并在matlab、python、c++环境下去搭建网络、训练网络、预测图片

其中keras的.h5模型可以转化为tensorflow的pb模型，供c++及python版tensorflow使用。对我而言如果需要用c++环境去训练和预测图片，我会优先选择caffe来做。如果是python环境去训练和预测图片，我会优先考虑tensorflow结合keras。caffe也可以输出网络结构图及打印损失率及精度曲线，我的其它博客有介绍。目前来看常用的还是用在python环境下使用tensorflow或者keras去定义网络结构, 该训练好的模型可以生成pb文件，直接给c++版的tensorflow去预测。很少去用tensorflow 的c++版去训练网络结构。

补充：

1.正则化的好的帖子

深度学习入门——神经网络的正则化_神经网络正则化_yasNing的博客-CSDN博客

04-03 Deep_Neural_Network--正则化与Dropout - 知乎

2.训练集和验证集

【深度学习】训练集、测试集和验证集_训练集测试集验证集_莫克_Cheney的博客-CSDN博客

深度学习：08 训练、测试和验证集的说明_训练验证测试_夏天是冰红茶的博客-CSDN博客

过拟合、验证集、交叉验证

验证集的作用是调整超参数，那么Keras的验证集的作用在训练过程中调整了哪些超参数？ - 知乎

验证集的作用是调整超参数，那么Keras的验证集的作用在训练过程中调整了哪些超参数？ - 知乎

https://www.cnblogs.com/renyuzhuo/p/12617224.html

训练集(train)验证集(validation)测试集(test)与交叉验证法 - 知乎

交叉验证与训练集、验证集、测试集_训练集,验证集,测试集的处理顺序_chaolei_9527的博客-CSDN博客

3.网络参数和计算量

全卷积神经网络（FCN）和卷积神经网络（CNN）的主要区别_全卷积神经网络和卷积神经网络_来包番茄沙司的博客-CSDN博客
卷积神经网络（ CNN）与全卷积神经网络（FCN）_全卷积神经网络和卷积神经网络_展希希鸿的博客-CSDN博客
 

深度学习模型参数量/计算量和推理速度计算

深度学习基础之 --- 参数量和计算量 - 知乎

深度学习卷积网络浮点计算量和参数量的计算（附Pytorch代码） - 知乎

轻量级网络-Mobilenet系列(v1,v2,v3) - 知乎

普通卷积与深度可分离卷积的区别_深度可分离卷积与普通卷积的区别_肖飒风的博客-CSDN博客

https://www.cnblogs.com/dengshunge/p/11334640.html

4.卷积类型

卷积网络CNN中各种常见卷积过程 - 简书