写在前面

最近我在看区分性训练的代码和论文，但我始终搞不懂它为什么叫区分性训练，为啥叫mmi，为啥现在很多地方用mmi取代了ce。当我试图去在论文中或者大部分博客中找到这个答案的时候，它们告诉我的都是一个公式：

公式虽然也不难懂，但就是搞不清是为什么。于是找了好几天的资料，从头开始补习，总结了这篇博客。

搜集资料的思路：mmi -> DT -> mle -> ce -> 熵 -> 互信息。 每一步都是考虑了公式和意义的，所以我在行文的过程中会多次提到公式该如何理解，起了什么样的作用。所以并没有特别客观。

行文思路: 熵以及信息论的基础概念 -> mle -> dt&mmi -> 论文中的描述（主要是lf-mmi）->kaldi中的实现。

我将分几篇进行描述，本篇描述的是基础内容，mle和mmi。

信息论中的一些概念

1. 熵（热力学中定义） ：
   热力学中的熵的定义， 熵是用来描述混乱程度的单位。定义为 $$k\ast lnw$$ w是微观状态数，k是玻尔兹曼常量，用来表示能量和温度的关系，取对数是因为希望两个系统结合为一个的时候是用简单的加法运算。
   比如：
   一个骰子的状态数是6，两个骰子的状态数是36。则一个骰子的混乱程度是kln6,两个是$kln{6}^2=2kln6$

2. 信息量：
   $$lo{g}_{a}1/p(x_i)$$可以看出，这里的状态数用概率的倒数进行表示。也就是说一个事件的概率越大，系统状态数也就越少，所包含的信息也就越小。

3. 熵：
   $$H(p)=\sum p(x_i){\log }_{a}1/p(x_i)$$ 约定 $0\le p\le 1$ ， $\sum p=1$，用来描述整体的不确定程度。
   实际上熵可以看作对系统状态数的期望。

4. 交叉熵（cross entropy）：
   $$H(p,q)=\sum p(x_i)log1/q(x_i)$$ 其中，p是真实分布的概率，q是自己估计出来的概率。交叉熵也是一种熵，也就是一种估计的熵值。
   根据定律，交叉熵一定大于真是分布的熵。
   因此我们平时训练就是希望ce越小越好，越小就越接近真实分布。（后面会继续提到这个问题）

5. 相对熵（KL散度）：
   作用：是用来衡量两种分布之间的差异。
   $$D(p||q)=H(p,q)-H(p)=\sum plogp-plogq$$
   也就是交叉熵与独立熵的差值。
   实际上，相对熵和交叉熵有着异曲同工的效果。

6. 条件熵：
   $H(Y|X)$意为在X的条件下，Y的概率分布熵，对X的期望。或者说是X的情况下，Y的不确定性。
   $$H(Y|X)=H(X,Y)-H(X)=-\sum _{x,y}p(x,y)log(p(y/x))$$
   $$=\sum _{x}p(x)H(Y|X=x)$$
   从公式看，可以理解为联合熵减去独立熵。“熵是数学期望，条件熵是数学期望的数学期望”。可以理解为，有X的时候Y的熵。

7. 互信息(mutual information)：
   两个随机变量的关联程度。我看到一种说法很好滴解释了互信息的意义：“有y的时候x的熵-没y的时候x的熵”。
   $$I(X,Y)=H(Y)-H(Y|X)$$ $$熵-条件熵$$
   所以我们所说的mmi准则实际上就是最大化互信息的缩写。这就是我们为什么要研究什么是互信息。

（以上这些是基于个人理解写的，如果不是很清楚的，可以去查看一些关于信息论的博客，大多写的很好。）
为什么我们之前一直用的是交叉熵，下面我们从MLE进行解释。

最大似然估计MLE

最大似然估计，即假设一种分布，用现在已知的数据去估计这种分布的参数。
然后看交叉熵，我们用估计的分布算出一个交叉熵，然后让交叉熵尽可能小达到估计真实的分布。因此我们之前的训练是属于mle，用的是交叉熵。交叉熵也就是mle的一种实现，同样如果是kl散度，也是属于mle的实现，正如我们前面说的这样。
我们语音识别的目的是最大化$P(W|O)$. w是words o是指观测序列
$P(W|O)=P(O|W)P(W)/P(O)$ .$P(O)$对于每个任务都是一样的，$P(W)$是由语言模型确定，$P(O|W)$是由声学模型确定，也称之为后验概率。
hmm也就是对$P(O|W)$进行的建模，我们所用的神经网络实际上也就是学习hmm的发射矩阵B。

mle缺点

1. 我们所学习模拟的分布是已知的。要求模型假设必须正确。
2. 训练时数据应趋向于无穷多。
3. 在解码时语言模型是趋向于真实的语言分布。

对于第一点，我们是通过gmm去模拟语音的真实分布，因为我们认为gmm可以模拟出任意一种分布。然后在此基础上去对齐训练。但是如果gmm训练的不到位呢。第二点第三点就不用再说了。

于是提出了区分性训练

区分性训练DT和最大互信息MMI

区分性训练

于是对于这些问题，就有了区分性训练，区分性训练实际上就是希望通过设置一个目标函数达到奖励正确的同时处罚错误的这样一个目的，来进行训练。(关于区分性训练我没有找到它的准确定义，于是用这种通俗易懂的方式来理解它就好了。)
它有几种实现方法，其中一种是mmi，最大化互信息，其他的还有mpe，之类的。
我们前面说到，互信息是描述两个随机变量的关联程度，于是在这里就是描述观测序列和文本的关联程度。
再来看一下互信息公式，具体的公式你不用看，只用关心$I(x,y)=H(x)-H(x|y)$。因此最大化互信息，就等于最小化条件熵。

MMI

公式：

MMI公式本身它可以看成，正确路径得分与所有路径得分的比值。当正确路径得分提升的同时，错误路径得分会减少，因此是一种区分性训练。
实际上我们就可以看成 $$\sum \log (P(O_r|w_r)P(w_r)/\sum wP(O_r|w)P(w))$$
$$=\sum \log P(O_r|w_r)P(w_r)/P(O_r)=P(W|O)$$
也就是我们是以P(W|O)作为目标函数，而不是以P(O|W)作为目标函数了。可以看到，实际上，mmi把语言模型的东西也考虑进去了。这样做相对于MLE的好处就是，即使假设的分布不是很好，得到的结果也不会太差。

区分性训练缺点

训练的数据泛化能力不强。 我的理解是，我们把一个正确的路径学的太多了，导致相对于这个训练集的错误路径的分数太低太低，因此为了增强它的泛化能力，我们适当增加错误路径的得分。或者说让声学模型在其中更具主导性，而不是一味地让语言模型进行主导。

MMI训练过程

我们在对一些参数进行更新的时候，需要用到的是前向后向算法，并且需要对分子和分母分别进行前向后向算法。这个是hmm中使用的一种方法。

Lattice

对于分子来说，这个算法是可行的，但对于分母来说，这个算法的计算量就太大了。所以为了计算可行性，我们使用lattice来进行计算，lattice实际上就是词格，词网络。我们通常使用的网络是状态级别的网络，而这里使用的词网络，这就是我们在训练前要进行对齐lats。然后我们为了方便统计信息，我们在每个词节点中加入状态信息。
所以，我们在训练chain-model的时候，使用的是wer，而不是cer。同时，值得注意的是，我们在实际使用的时候，wer也是更值得关注一些。
当然，对分母的优化只有这一点是远远不够的，在lf-mmi中会大量提及对分母的优化，包括hmm的优化，解码图的优化，以及各种tricks。这里先只提及从状态级别的转向lattice级别的优化。
（图自：An Overview of Discriminative Training for Speech Recognition --Keith Vertanen）
注意：这里要强调一点，正确的路径可能不止一条，因为可能会有多音字的情况。

对于它的训练：

• 我们还是使用MLE(CE)准则训练的模型去进行对齐得到lats。
• 一般来说，在整个训练过程中这些lats不会改变的，但也有随着训练过程而变化的情况，这样得到的效果也是不错的。
• 解码图，每个分子的解码图是根据当前句子定的，但分母的解码图都是一样的。
• 但实际上我们在kaldi训练的过程中不是这样的，kaldi中实现的是lf-mmi

MMI的问题：

对于mmi的一个问题就是，训练的数据泛化能力不强。我的理解是，我们把一个正确的路径学的太多了，导致相对于这个训练集的错误路径的分数太低太低，因此为了增强它的泛化能力，我们适当增加错误路径的得分。或者说让声学模型在其中更具主导性，而不是一味地让语言模型进行主导。
因此有几种解决方法，这里只列举几种：

• 声学参数k，增加声学参数的影响
• lat使用一个简单的语言模型，一般来说，在分母的解码图的语言模型实际上使用的是一个word-level的bigram
• boosted mmi

我们可以看到，和mmi相比，bmmi在分母上增加了一项，exp(-bA(s,sr)) 其中A(s,sr)表示的是用来描述s和sr的准确性的一个参数。

• 包括在lf-mmi中也有一些方法去解决泛化能力

大多是自己的理解，请多多包涵。

reference

https://www.cnblogs.com/welen/p/7515614.html
https://www.cnblogs.com/jenny1000000/p/7745458.html
An Overview of Discriminative Training for Speech Recognition --Keith Vertanen
https://liuyanfeier.github.io/2018/12/16/区分性训练（Discriminative-Training）及其在语音识别（ASR）上的运用/
BOOSTED MMI FOR MODEL AND FEATURE-SPACE DISCRIMINATIVE TRAINING – Dan Povey

经过差不多一个礼拜的时间的学习，终于把完整的一个利用自己爬取的图片做训练数据集的卷积神经网络的实现（基于tensorflow）

目录

总体思路

第三部分：预处理

第四部分：网络模型

第五部分：训练

2019.4.22更新

第六部分：测试

特别说明

2019.1补充说明，针对评论区的几个问题做了一些改进和更新

1、训练集和测试集的划分问题

关于训练集和测试集的补充说明:

训练集和测试集的划分很重要，我自己尝试过两种简单的方法：

1）训练集和验证集在预处理的时候按比例随机划分。在PreWork.py添加了这部分代码

2）一开始训练集和测试集就提前划分好存储在不同的.list文件里。

读训练数据集就从train_list_path下读，读测试样本就从test_list_path下读

train_list_path = './list/train.list'  # 训练样本的读入路径
# test_list_path = './list/test.list'  # 测试样本的读入路径

在实际应用中数据量不一定足够，可以采用交叉验证的方法划分训练集、验证集、测试集。这部分内容不详细展开，简单做个记录。

• 留出法。将原样本随机划分为训练集和验证集(本博文使用的方法)。缺点：具有随机性，最后评估指标与原始分组有较大关系。
• k折交叉验证。样本分为k个大小相等的样本子集，k-1个用来训练，1个用来测试，最后k次评估指标的平均值作为最终评估指标。
• 留一法。每次留一个样本作为验证(是K折交叉验证的特殊情况)，适用于数据缺乏的情况下。
• 自助法。基于自助采用，对数据集随机采样，重复m次有得到m个子集，由于有部分样本没有被抽到过，有的重复多次抽到，那么将从未被抽到的作为验证集。

2、测试代码的补充

总体思路

简单整理一下思路：

1. 获取数据集（上网爬取，或者直接找公开的图片数据集）
2. 数据集的预处理，包括reshape、去噪、对比度增强、批量剪切、图片灰度、二值化、缩放、丰富数据等等（公开数据集一般已处理完）
3. 对图片集进行处理，得到网络的输入(2、3都可以看成预处理部分)
4. 搭建卷积神经网络框架
5. 进行网络的训练
6. 读取训练好的网络模型完成测试

每三、四部分的参考和具体实现都在前面的两篇博客里提到了

搭建一个卷积神经网络

利用tensorflow训练自己的图片数据集——数据准备

再附一下重点参考：江湖人称星爷的博客。给了我很大的指引和参考。现在附的跟前面有一点改动，基本思路是一样的。

第一、二部分还有一些小问题，暂时先不放上来。

第三部分：预处理

新建PreWork.py文件

'''
PreWork.py
功能：实现对指定大小的生成图片进行sample与label分类制作
获得神经网络输入的get_files文件，同时为了方便网络的训练，输入数据进行batch处理。

2018/7/19完成
-------copyright@GCN-------
'''

import os
import numpy as np
from PIL import Image
import tensorflow as tf
import matplotlib.pyplot as plt
from numpy import *

angry = []
label_angry = []
disgusted = []
label_disgusted = []
fearful = []
label_fearful = []
happy = []
label_happy = []
sadness = []
label_sadness = []
surprised = []
label_surprised = []


def get_file(file_dir):
    # step1：获取路径下所有的图片路径名，存放到
    # 对应的列表中，同时贴上标签，存放到label列表中。
    for file in os.listdir(file_dir + '/angry'):
        angry.append(file_dir + '/angry' + '/' + file)
        label_angry.append(0)
    for file in os.listdir(file_dir + '/disgusted'):
        disgusted.append(file_dir + '/disgusted' + '/' + file)
        label_disgusted.append(1)
    for file in os.listdir(file_dir + '/fearful'):
        fearful.append(file_dir + '/fearful' + '/' + file)
        label_fearful.append(2)
    for file in os.listdir(file_dir + '/happy'):
        happy.append(file_dir + '/happy' + '/' + file)
        label_happy.append(3)
    for file in os.listdir(file_dir + '/sadness'):
        sadness.append(file_dir + '/sadness' + '/' + file)
        label_sadness.append(4)
    for file in os.listdir(file_dir + '/surprised'):
        surprised.append(file_dir + '/surprised' + '/' + file)
        label_surprised.append(5)

    # 打印出提取图片的情况，检测是否正确提取
    print("There are %d angry\nThere are %d disgusted\nThere are %d fearful\n" %(len(angry), len(disgusted), len(fearful)),end="")
    print("There are %d happy\nThere are %d sadness\nThere are %d surprised\n" %(len(happy),len(sadness),len(surprised)))

    # step2：对生成的图片路径和标签List做打乱处理把所有的合起来组成一个list（img和lab）
    # 合并数据numpy.hstack(tup)
    # tup可以是python中的元组（tuple）、列表（list），或者numpy中数组（array），函数作用是将tup在水平方向上（按列顺序）合并
    image_list = np.hstack((angry, disgusted, fearful, happy, sadness, surprised))
    label_list = np.hstack((label_angry, label_disgusted, label_fearful, label_happy, label_sadness, label_surprised))
    # 利用shuffle，转置、随机打乱
    temp = np.array([image_list, label_list])   # 转换成2维矩阵
    temp = temp.transpose()     # 转置
    # numpy.transpose(a, axes=None) 作用：将输入的array转置，并返回转置后的array
    np.random.shuffle(temp)     # 按行随机打乱顺序函数

    # 将所有的img和lab转换成list
    all_image_list = list(temp[:, 0])    # 取出第0列数据，即图片路径
    all_label_list = list(temp[:, 1])    # 取出第1列数据，即图片标签
    label_list = [int(i) for i in label_list]   # 转换成int数据类型
    
    ''' 
    # 将所得List分为两部分，一部分用来训练tra，一部分用来验证val
    n_sample = len(all_label_list)
    n_val = int(math.ceil(n_sample * ratio))  # 验证样本数, ratio是验证集的比例
    n_train = n_sample - n_val  # 训练样本数

    tra_images = all_image_list[0:n_train]
    tra_labels = all_label_list[0:n_train]
    tra_labels = [int(float(i)) for i in tra_labels]   # 转换成int数据类型
    val_images = all_image_list[n_train:-1]
    val_labels = all_label_list[n_train:-1]
    val_labels = [int(float(i)) for i in val_labels]   # 转换成int数据类型

    return tra_images, tra_labels, val_images, val_labels
    '''

    return image_list, label_list

# 将image和label转为list格式数据，因为后边用到的的一些tensorflow函数接收的是list格式数据
# 为了方便网络的训练，输入数据进行batch处理
# image_W, image_H, ：图像高度和宽度
# batch_size：每个batch要放多少张图片
# capacity：一个队列最大多少
def get_batch(image, label, image_W, image_H, batch_size, capacity):
    # step1：将上面生成的List传入get_batch() ，转换类型，产生一个输入队列queue
    # tf.cast()用来做类型转换
    image = tf.cast(image, tf.string)   # 可变长度的字节数组.每一个张量元素都是一个字节数组
    label = tf.cast(label, tf.int32)
    # tf.train.slice_input_producer是一个tensor生成器
    # 作用是按照设定，每次从一个tensor列表中按顺序或者随机抽取出一个tensor放入文件名队列。
    input_queue = tf.train.slice_input_producer([image, label])
    label = input_queue[1]
    image_contents = tf.read_file(input_queue[0])   # tf.read_file()从队列中读取图像

    # step2：将图像解码，使用相同类型的图像
    image = tf.image.decode_jpeg(image_contents, channels=3)
    # jpeg或者jpg格式都用decode_jpeg函数，其他格式可以去查看官方文档

    # step3：数据预处理，对图像进行旋转、缩放、裁剪、归一化等操作，让计算出的模型更健壮。
    image = tf.image.resize_image_with_crop_or_pad(image, image_W, image_H)
    # 对resize后的图片进行标准化处理
    image = tf.image.per_image_standardization(image)

    # step4：生成batch
    # image_batch: 4D tensor [batch_size, width, height, 3], dtype = tf.float32
    # label_batch: 1D tensor [batch_size], dtype = tf.int32
    image_batch, label_batch = tf.train.batch([image, label], batch_size=batch_size, num_threads=16, capacity=capacity)

    # 重新排列label，行数为[batch_size]
    label_batch = tf.reshape(label_batch, [batch_size])
    # image_batch = tf.cast(image_batch, tf.uint8)    # 显示彩色图像
    image_batch = tf.cast(image_batch, tf.float32)    # 显示灰度图
    # print(label_batch) Tensor("Reshape:0", shape=(6,), dtype=int32)
    return image_batch, label_batch
    # 获取两个batch，两个batch即为传入神经网络的数据

"""
def PreWork():
    # 对预处理的数据进行可视化，查看预处理的效果
    IMG_W = 256
    IMG_H = 256
    BATCH_SIZE = 6
    CAPACITY = 64

    train_dir = 'F:/Python/PycharmProjects/DeepLearning/CK+_part'

    # image_list, label_list, val_images, val_labels = get_file(train_dir)
    image_list, label_list = get_file(train_dir)
    image_batch, label_batch = get_batch(image_list, label_list, IMG_W, IMG_H, BATCH_SIZE, CAPACITY)
    print(label_batch.shape)

    lists = ('angry', 'disgusted', 'fearful', 'happy', 'sadness', 'surprised')

    with tf.Session() as sess:
        i = 0
        coord = tf.train.Coordinator()  # 创建一个线程协调器，用来管理之后在Session中启动的所有线程
        threads = tf.train.start_queue_runners(coord=coord)
        try:
            while not coord.should_stop() and i < 1:
                # 提取出两个batch的图片并可视化。
                img, label = sess.run([image_batch, label_batch])  # 在会话中取出img和label
                # img = tf.cast(img, tf.uint8)

                '''
                1、range()返回的是range object，而np.arange()返回的是numpy.ndarray()
                range(start, end, step)，返回一个list对象，起始值为start，终止值为end，但不含终止值，步长为step。只能创建int型list。
                arange(start, end, step)，与range()类似，但是返回一个array对象。需要引入import numpy as np，并且arange可以使用float型数据。
                
                2、range()不支持步长为小数，np.arange()支持步长为小数
                
                3、两者都可用于迭代
                range尽可用于迭代，而np.nrange作用远不止于此，它是一个序列，可被当做向量使用。
                '''
                for j in np.arange(BATCH_SIZE):
                    # np.arange()函数返回一个有终点和起点的固定步长的排列
                    print('label: %d' % label[j])
                    plt.imshow(img[j, :, :, :])
                    title = lists[int(label[j])]
                    plt.title(title)
                    plt.show()
                i += 1
        except tf.errors.OutOfRangeError:
            print('done!')
        finally:
            coord.request_stop()
        coord.join(threads)

if __name__ == '__main__':
    PreWork()
"""

第四部分：网络模型

新建CNNModel.py文件

补充的知识点

在TensorFlow的世界里，变量的定义和初始化是分开的，所有关于图变量的赋值和计算都要通过tf.Session的run来进行。

想要将所有图变量进行集体初始化时应该使用tf.global_variables_initializer
tf.placehold与tf.Variable的区别：
    tf.placehold 占位符
        主要为真实输入数据和输出标签的输入， 用于在 feed_dict中的变量，不需要指定初始值，具体值在feed_dict中的变量给出。
    tf.Variable 主要用于定义weights bias等可训练会改变的变量，必须指定初始值。
        通过Variable()构造函数后，此variable的类型和形状固定不能修改了，但值可以用assign方法修改。

tf.get_variable和tf.Variable函数差别
相同点：通过两函数创建变量的过程基本一样，
        tf.variable函数调用时提供的维度(shape)信息以及初始化方法(initializer)的参数和tf.Variable函数调用时提供的初始化过程中的参数基本类似。
不同点：两函数指定变量名称的参数不同，
        对于tf.Variable函数，变量名称是一个可选的参数，通过name="v"的形式给出
        tf.get_variable函数，变量名称是一个必填的参数，它会根据变量名称去创建或者获取变量

'''
CNNModel.py
含3层卷积池化层，2层全连接层，激活函数ReLU，采用dropout和softmax函数做分类器
2018/7/18完成搭建，2018/7/19实现文件调用，2018/7/22修改网络结构
-------copyright@GCN-------
'''
import tensorflow as tf


# 函数申明
def weight_variable(shape, n):
    # tf.truncated_normal(shape, mean, stddev)这个函数产生正态分布，均值和标准差自己设定。
    # shape表示生成张量的维度，mean是均值
    # stddev是标准差,，默认最大为1，最小为-1，均值为0
    initial = tf.truncated_normal(shape, stddev=n, dtype=tf.float32)
    return initial

def bias_variable(shape):
    # 创建一个结构为shape矩阵也可以说是数组shape声明其行列，初始化所有值为0.1
    initial = tf.constant(0.1, shape=shape, dtype=tf.float32)
    return initial

def conv2d(x, W):
    # 卷积遍历各方向步数为1，SAME：边缘外自动补0，遍历相乘
    # padding 一般只有两个值
    # 卷积层后输出图像大小为：（W+2P-f）/stride+1并向下取整
    return tf.nn.conv2d(x, W, strides=[1, 1, 1, 1], padding='SAME')

def max_pool_2x2(x, name):
    # 池化卷积结果（conv2d）池化层采用kernel大小为3*3，步数也为2，SAME：周围补0，取最大值。数据量缩小了4倍
    # x 是 CNN 第一步卷积的输出量，其shape必须为[batch, height, weight, channels];
    # ksize 是池化窗口的大小， shape为[batch, height, weight, channels]
    # stride 步长，一般是[1，stride， stride，1]
    # 池化层输出图像的大小为(W-f)/stride+1，向上取整
    return tf.nn.max_pool(x, ksize=[1, 3, 3, 1], strides=[1, 2, 2, 1], padding='SAME', name=name)


# 一个简单的卷积神经网络，卷积+池化层 x2，全连接层x2，最后一个softmax层做分类。
# 64个3x3的卷积核（3通道），padding=’SAME’，表示padding后卷积的图与原图尺寸一致，激活函数relu()
def deep_CNN(images, batch_size, n_classes):
    # 搭建网络
    # 第一层卷积
    # 第一二参数值得卷积核尺寸大小，即patch；第三个参数是通道数；第四个是卷积核个数
    with tf.variable_scope('conv1') as scope:
        # 所谓名字的scope，指当绑定了一个名字到一个对象的时候，该名字在程序文本中的可见范围
        w_conv1 = tf.Variable(weight_variable([3, 3, 3, 64], 1.0), name='weights', dtype=tf.float32)
        b_conv1 = tf.Variable(bias_variable([64]), name='biases', dtype=tf.float32)   # 64个偏置值
        # tf.nn.bias_add 是 tf.add 的一个特例:tf.add(tf.matmul(x, w), b) == tf.matmul(x, w) + b
        # h_conv1 = tf.nn.relu(tf.nn.bias_add(conv2d(images, w_conv1), b_conv1), name=scope.name)
        h_conv1 = tf.nn.relu(conv2d(images, w_conv1)+b_conv1, name='conv1')  # 得到128*128*64(假设原始图像是128*128)
    # 第一层池化
    # 3x3最大池化，步长strides为2，池化后执行lrn()操作，局部响应归一化，增强了模型的泛化能力。
    # tf.nn.lrn(input,depth_radius=None,bias=None,alpha=None,beta=None,name=None)
    with tf.variable_scope('pooling1_lrn') as scope:
        pool1 = max_pool_2x2(h_conv1, 'pooling1')   # 得到64*64*64
        norm1 = tf.nn.lrn(pool1, depth_radius=4, bias=1.0, alpha=0.001 / 9.0, beta=0.75, name='norm1')

    # 第二层卷积
    # 32个3x3的卷积核（16通道），padding=’SAME’，表示padding后卷积的图与原图尺寸一致，激活函数relu()
    with tf.variable_scope('conv2') as scope:
        w_conv2 = tf.Variable(weight_variable([3, 3, 64, 32], 0.1), name='weights', dtype=tf.float32)
        b_conv2 = tf.Variable(bias_variable([32]), name='biases', dtype=tf.float32)   # 32个偏置值
        h_conv2 = tf.nn.relu(conv2d(norm1, w_conv2)+b_conv2, name='conv2')  # 得到64*64*32

    # 第二层池化
    # 3x3最大池化，步长strides为2，池化后执行lrn()操作
    with tf.variable_scope('pooling2_lrn') as scope:
        pool2 = max_pool_2x2(h_conv2, 'pooling2')  # 得到32*32*32
        norm2 = tf.nn.lrn(pool2, depth_radius=4, bias=1.0, alpha=0.001 / 9.0, beta=0.75, name='norm2')

    # 第三层卷积
    # 16个3x3的卷积核（16通道），padding=’SAME’，表示padding后卷积的图与原图尺寸一致，激活函数relu()
    with tf.variable_scope('conv3') as scope:
        w_conv3 = tf.Variable(weight_variable([3, 3, 32, 16], 0.1), name='weights', dtype=tf.float32)
        b_conv3 = tf.Variable(bias_variable([16]), name='biases', dtype=tf.float32)   # 16个偏置值
        h_conv3 = tf.nn.relu(conv2d(norm2, w_conv3)+b_conv3, name='conv3')  # 得到32*32*16

    # 第三层池化
    # 3x3最大池化，步长strides为2，池化后执行lrn()操作
    with tf.variable_scope('pooling3_lrn') as scope:
        pool3 = max_pool_2x2(h_conv3, 'pooling3')  # 得到16*16*16
        norm3 = tf.nn.lrn(pool3, depth_radius=4, bias=1.0, alpha=0.001 / 9.0, beta=0.75, name='norm3')

    # 第四层全连接层
    # 128个神经元，将之前pool层的输出reshape成一行，激活函数relu()
    with tf.variable_scope('local3') as scope:
        reshape = tf.reshape(norm3, shape=[batch_size, -1])
        dim = reshape.get_shape()[1].value
        w_fc1 = tf.Variable(weight_variable([dim, 128], 0.005),  name='weights', dtype=tf.float32)
        b_fc1 = tf.Variable(bias_variable([128]), name='biases', dtype=tf.float32)
        h_fc1 = tf.nn.relu(tf.matmul(reshape, w_fc1) + b_fc1, name=scope.name)

    # 第五层全连接层
    # 128个神经元，激活函数relu()
    with tf.variable_scope('local4') as scope:
        w_fc2 = tf.Variable(weight_variable([128 ,128], 0.005),name='weights', dtype=tf.float32)
        b_fc2 = tf.Variable(bias_variable([128]), name='biases', dtype=tf.float32)
        h_fc2 = tf.nn.relu(tf.matmul(h_fc1, w_fc2) + b_fc1, name=scope.name)


    # 对卷积结果执行dropout操作
    # keep_prob = tf.placeholder(tf.float32)
    h_fc2_dropout = tf.nn.dropout(h_fc2, 0.5)
    # tf.nn.dropout(x, keep_prob, noise_shape=None, seed=None, name=None)
    # 第二个参数keep_prob: 设置神经元被选中的概率,在初始化时keep_prob是一个占位符

    # Softmax回归层
    # 将前面的FC层输出，做一个线性回归，计算出每一类的得分，在这里是6类，所以这个层输出的是六个得分。
    with tf.variable_scope('softmax_linear') as scope:
        weights = tf.Variable(weight_variable([128, n_classes], 0.005), name='softmax_linear', dtype=tf.float32)
        biases = tf.Variable(bias_variable([n_classes]), name='biases', dtype=tf.float32)
        softmax_linear = tf.add(tf.matmul(h_fc2_dropout, weights), biases, name='softmax_linear')
        # softmax_linear = tf.nn.softmax(tf.add(tf.matmul(h_fc2_dropout, weights), biases, name='softmax_linear'))
    return softmax_linear
    # 最后返回softmax层的输出


# loss计算
# 传入参数：logits，网络计算输出值。labels，真实值，0或者1
# 返回参数：loss，损失值
def losses(logits, labels):
    with tf.variable_scope('loss') as scope:
        cross_entropy = tf.nn.sparse_softmax_cross_entropy_with_logits(logits=logits, labels=labels, name='xentropy_per_example')
        loss = tf.reduce_mean(cross_entropy, name='loss')
        tf.summary.scalar(scope.name + '/loss', loss)
    return loss

# loss损失值优化
# 输入参数：loss。learning_rate，学习速率。
# 返回参数：train_op，训练op，这个参数要输入sess.run中让模型去训练。
def trainning(loss, learning_rate):
    with tf.name_scope('optimizer'):
        optimizer = tf.train.AdamOptimizer(learning_rate=learning_rate)
        global_step = tf.Variable(0, name='global_step', trainable=False)
        train_op = optimizer.minimize(loss, global_step=global_step)
    return train_op

# 评价/准确率计算
# 输入参数：logits，网络计算值。labels，标签，也就是真实值，在这里是0或者1。
# 返回参数：accuracy，当前step的平均准确率，也就是在这些batch中多少张图片被正确分类了。
def evaluation(logits, labels):
    with tf.variable_scope('accuracy') as scope:
        correct = tf.nn.in_top_k(logits, labels, 1)
        accuracy = tf.reduce_mean(tf.cast(correct, tf.float16))
        tf.summary.scalar(scope.name + '/accuracy', accuracy)
    return accuracy

第五部分：训练

新建Train.py文件

这部分代码基本来自参考博文。

'''
Train.py
对搭建好的网络进行训练，并保存训练参数，以便下次使用
2018/7/19实现文件调用，2018/7/22实现最终网络的训练
-------copyright@GCN-------
'''
# 导入文件
import os
import numpy as np
import tensorflow as tf
from PreWork import get_file, get_batch
from CNNModel import deep_CNN, losses, trainning, evaluation

# 变量声明
N_CLASSES = 6
IMG_W = 28  # resize图像，太大的话训练时间久
IMG_H = 28
BATCH_SIZE = 20     # 每个batch要放多少张图片
CAPACITY = 200      # 一个队列最大多少
MAX_STEP = 10000 
learning_rate = 0.0001  # 一般小于0.0001

# 获取批次batch
train_dir = './CK+_part'  # 训练样本的读入路径
logs_train_dir = './CK+_part'  #logs存储路径
train, train_label = get_file(train_dir)
# 训练数据及标签
train_batch, train_label_batch = get_batch(train, train_label, IMG_W, IMG_H, BATCH_SIZE, CAPACITY)

# 训练操作定义
train_logits = deep_CNN(train_batch, BATCH_SIZE, N_CLASSES)
train_loss = losses(train_logits, train_label_batch)
train_op = trainning(train_loss, learning_rate)
train_acc = evaluation(train_logits, train_label_batch)

# 这个是log汇总记录
summary_op = tf.summary.merge_all()

# 产生一个会话
sess = tf.Session()
train_writer = tf.summary.FileWriter(logs_train_dir, sess.graph)
# 产生一个saver来存储训练好的模型
saver = tf.train.Saver()
# 所有节点初始化
sess.run(tf.global_variables_initializer())
# 队列监控
coord = tf.train.Coordinator() # 设置多线程协调器
threads = tf.train.start_queue_runners(sess=sess, coord=coord)

# 进行batch的训练
try:
    # 执行MAX_STEP步的训练，一步一个batch
    for step in np.arange(MAX_STEP):
        if coord.should_stop():
            break
        # 启动以下操作节点，有个疑问，为什么train_logits在这里没有开启？
        _, tra_loss, tra_acc = sess.run([train_op, train_loss, train_acc])

        # 每隔50步打印一次当前的loss以及acc，同时记录log，写入writer
        if step % 100 == 0:
            print('Step %d, train loss = %.2f, train accuracy = %.2f%%' % (step, tra_loss, tra_acc * 100.0))
            summary_str = sess.run(summary_op)
            train_writer.add_summary(summary_str, step)

        # 保存最后一次网络参数
        checkpoint_path = os.path.join(logs_train_dir, 'thing.ckpt')
        saver.save(sess, checkpoint_path)

        '''
        # 每隔100步，保存一次训练好的模型
        if (step + 1) == MAX_STEP:
            checkpoint_path = os.path.join(logs_train_dir, 'thing.ckpt')
            saver.save(sess, checkpoint_path, global_step=step)
        '''
        

except tf.errors.OutOfRangeError:
    print('Done training -- epoch limit reached')

finally:
    coord.request_stop()
coord.join(threads)
sess.close()

2019.4.22更新

之前用的数据集(CK+表情数据库)有一点问题：由于数据集中既有灰度图也有彩色图，在程序中设置通道数的时候就没有统一成一样的，所以测试的时候总出错。

为了方便，直接把图片都换成3通道的彩色图像，修改测试代码。（当然也可以在预处理阶段，把所有的图片转换为统一通道数）

从网上爬取了三个分类数据集(guitar, house, rabbit)，将所有图片借用之前提到的参考文献的代码reshape成相同大小，数据集很小比较简单，所以跑了2000次，简单训练生成网络模型参数文件。

测试代码终于可以跑通了，不过因为我模拟训练的时候数据不平衡，训练的样本也很小，实际测试的时候偶尔效果并不好。真正做的时候要根据实际问题的需求改进，这里只是做个示范就没有考虑这么多，仅供参考！

第六部分：测试

新建Test.py文件，修改完成

在‘hijacklei’的提醒下加了一行初始化代码

'''
Test.py
2019/4/22完成最终网络的测试
-------copyright@GCN-------
'''
# 导入必要的包
import os
import numpy as np
from PIL import Image
import tensorflow as tf
import matplotlib.pyplot as plt
from CNNModel import deep_CNN

N_CLASSES = 3

img_dir = './Input_data/test/'
log_dir = './Input_data'
lists = ['guitar', 'house', 'rabbit']


# 从测试集中随机挑选一张图片看测试结果
def get_one_image(img_dir):
    imgs = os.listdir(img_dir)
    img_num = len(imgs)
    # print(imgs, img_num)
    idn = np.random.randint(0, img_num)
    image = imgs[idn]
    image_dir = img_dir + image
    print(image_dir)
    image = Image.open(image_dir)
    plt.imshow(image)
    plt.show()
    image = image.resize([28, 28])
    image_arr = np.array(image)
    return image_arr


def test(image_arr):
    with tf.Graph().as_default():
        image = tf.cast(image_arr, tf.float32)
        image = tf.image.per_image_standardization(image)
        image = tf.reshape(image, [1, 28, 28, 3])
        # print(image.shape)
        p = deep_CNN(image, 1, N_CLASSES)
        logits = tf.nn.softmax(p)
        x = tf.placeholder(tf.float32, shape=[28, 28, 3])
        saver = tf.train.Saver()
        sess = tf.Session()
        sess.run(tf.global_variables_initializer())
        ckpt = tf.train.get_checkpoint_state(log_dir)
        if ckpt and ckpt.model_checkpoint_path:
            # print(ckpt.model_checkpoint_path)
            saver.restore(sess, ckpt.model_checkpoint_path)
            # 调用saver.restore()函数，加载训练好的网络模型
            print('Loading success')
        prediction = sess.run(logits, feed_dict={x: image_arr})
        max_index = np.argmax(prediction)
        print('预测的标签为：', max_index, lists[max_index])
        print('预测的结果为：', prediction)


if __name__ == '__main__':
    img = get_one_image(img_dir)
    test(img)

说明：测试集不是训练集的一部分！测试集没有参与训练！

来看一下测试效果，结果如下

显示随机的测试图片

关闭图片后会出现测试结果

2019.08.14

看到有评论说测试代码总是只能测出一个结果，我特地用二分类做了一下简单的测试，不规范是真的，最终结果应该没什么问题。

 我把这份完整的代码包括数据集和训练模型参数打包放到github上，剩下的大家就根据实际情况修改吧！

特别说明

注意，真实训练的时候，测试数据集应该是和训练数据集不一样的，这里只是做个示例。

总的说来，现在看这份代码，其实有很多不规范的地方，所以仅作参考。

数据库用的是CK+表情数据库中的原图

放上完整的项目链接CNN(from github)

2019-8-14用二分类做的小测试完整项目A-Simple-Two-Classification-Problem-Based-on-CNN

Fast-ReID前期准备

前言

FastReID 是一个 SOTA 级的 ReID 方法集合工具箱（SOTA ReID Methods and Toolbox），同时面向学术界和工业界落地，此外该团队还发布了在多个不同任务、多种数据集上的SOTA模型。
FastReID中实现的四大ReID任务：
行人重识别
部分区域的行人重识别
跨域的行人重识别
车辆的重识别

论文：https://arxiv.org/pdf/2006.02631.pdf
代码：https://github.com/JDAI-CV/fast-reid

一、Fast-ReID 介绍

Fast-ReID 特点

提供了针对ReID任务的完整的工具箱，包括训练、评估、微调和模型部署，另外实现了在多个任务中的最先进的模型。
1）模块化和灵活的设计，方便研究者快速将新的模块插入和替换现有流程中，帮助学界快速验证新思路；

2）易于管理的系统配置，FastReID用PyTorch实现，可提供在多GPU服务器的快速训练，模型结构、训练和测试可以用YAML文件方便定义，并对每一块提供了众多可定义选项（主干网、训练策略、聚合策略、损失函数等）。

3）丰富的评估系统，不仅实现了CMC评估指标，还包括ROC、mINP等，可以更好的反应模型性能。

4）易于工程部署，FastReID不仅提供了有效的知识蒸馏模块以得到精确且高效的轻量级模型，而且提供了PyTorch->Caffe和PyTorch->TensorRT模型转换工具。

5）众多的State-of-the-art预训练模型，官方计划发布人员重识别（person re-id）,部分可见的人员重识别（ partial re-id）, 跨域人员重识别（cross-domain re-id） 和 车辆重识别（vehicle re-id） 等众多模型。

FastReID 架构

训练阶段包括模块：
1）预处理Pre-processing，其实就是各种数据增广方法，如 Resize,Flipping,Random erasing,Auto-augment（automl 中的技巧，使用该技巧去实现有效的数据增强，提高特征的鲁棒性）,Random patch,Cutout等；其中Random erasing在reid任务中效果显著。

2）骨干网（Backbone），包括主干网的选择（如ResNet,ResNest,ResNeXt等）和可以增强主干网表达能力的特殊模块（如non-local、instance batch normalization (IBN)模块等）；

3）聚合模块（Aggregation），用于将骨干网生成的特征聚合成一个全局特征，如max pooling, average pooling, GeM pooling ， attention pooling等方法；

4）Head 模块，用于对生成的全局特征进行归一化、纬度约减等。

5）训练策略，包含Learning rate，warm-up,Backbone freeze，余弦衰减（consine decay）等。

6）特别值得一提的是其损失函数，不仅包括常见的Cross-entropy loss， Triplet loss，Arcface loss，还实现了今年上半年刚出的旷视CVPR 2020 Oral 论文中的Circle loss！（被认为是目前在各种度量学习任务中表现最好的）可见FastReID开发团队紧跟前沿。

在推理阶段，包含模块：
1）度量部分，除支持常见的余弦和欧式距离，还添加了局部匹配方法 deep spatial reconstruction (DSR)；

2）后处理部分，指对检索结果的处理，包括K-reciprocal coding 和 Query Expansion (QE) 两种重排序方法。

二、Fast-ReID 复现

安装fast-reid： 代码会更新详情可见官方Installation
conda create -n fastreid python=3.7
conda activate fastreid
conda install pytorch==1.6.0 torchvision tensorboard -c pytorch
pip install -r requirements
pip install faiss-cpu # faiss-cpu此方法能正确安装

按照官方方法即可 Getting Started with Fastreid
cd fastreid/evaluation/rank_cylib; make all

pytorch支持半精度训练，需安装apex
$ git clone https://github.com/NVIDIA/apex
$ cd apex
$ pip install -v --no-cache-dir --global-option="–pyprof" --global-option="–cpp_ext" --global-option="–cuda_ext" ./
环境搞好后可先用Market1501数据集训练起来，说明安装没有问题。
fast-reid封装的非常繁琐，初次一看很难看懂，下次将详细讲述fast-reid源码。训练以及调优过程

下一节 Fast-ReID 代码讲解