python人工智能:完整的图片识别(非图片验证码)，以及模型的使用

作者：Python疯子

链接：https://www.jianshu.com/p/5b4e51869e64

这个可以说是一个绝对的福利中的福利。一整套的AI图片识别以及模型的使用。

一直都在说人工智能，图像识别，又有几个人会呢，网上文章成山，前一段时间因工作需要，我一个做后端开发的，要做图片识别。

于是开始了疯狂的地毯式搜索，先说网上介绍最多，最好，也是最坑的模型---AIimage，10行代码完成图像识别，通过代码是可以识现，但必须使用它们的模型，不能自己训练，于是开始找AIimage的训练模型，也找到了，也能训练，用训练好的模型，正式测试，哇，屎一样！

后来得到一位大哥真传，给了这套完整的训练+使用的完整代码，先说说这位大哥，那人真是一个好啊，我从git上获取代码，然后自己跑，各种bug+不会调试，我都不好意思问，这位大哥亲自帮忙调试，解决bug，远程调试，帮我弄到后半夜，太辛苦了，给大哥发个红包，没收，留下一句话：为了学习！！！

大哥永远是大哥

我之所以写这篇文章主要是方便像我一样的纯小白使用代码，因为源代码里没有完整的结构，也存在一些小小的问题，献上完整通过的代码。

我不会人工智能，下面内容来自大哥的原文章TensorFlow 复现ResNet系列模型

：

阅前须知：

为了使本文结构精简，理解简单，所以会尽量少涉及到有关数学公式，降低学习门槛，带领读者快速搭建ResNet-152经典模型并投入训练。

本文的最后会放出博主自己复现的ResNet模型，投入自己的数据集进行训练。

如读者在阅读时发现有错误的地方欢在评论的地方指出，共同进步

编译环境：Python3.5

TensorFlow-gpu 1.3.0

一、结构分析

关于ResNet的来源我就不进行赘述了，相信读者都对这个包揽各大图像识别赛事冠军的模型或多或少有一定的了解。

图片来源Google

说起卷积模型，LeNet、Inception、Vgg都是我们在学习图像识别领域神经网络的经典模型，以上图片模型就是经典的Vgg-19与34层传统卷积网络、ResNet-34的对比。

从计算量上来讲，Vgg-19的三层全连接神经网络的计算量明显大于传统卷积网络和resnet，传统卷积网络和resnet的参数数量相同

plain与resnet

从训练拟合度上讲，论文中分别给出了plain-18、plain-34和resnet-18、resnet-34的对比，我们不难发现plain随着层数的增加，精度并没有得到明显的提升，而resnet不仅随着层数的增加提高了训练精度，且相较同深度的plain而言精度更高

在以往的学习之中，我们知道深度网络随着层数的增加，很容易造成“退化”和“梯度消失”的问题，训练数据的过拟合。但在ResNet中，作者给出了一种解决方案：增加一个identity mapping(恒等映射，由于本文面向读者基础不同，就不加以详述，有能力的同学可以看一下ResNet作者的论文)

残差模块

上图是一个残差模块的结构示意，残差块想要有效果需要有两层或两层以上的layer，同时，输入x与输出F（x）的维度也须相同

residual block

在对于高于50层深度的resnet模型中，为了进一步减少计算量且保证模型精度，作者对残差模块进行了优化，将内部两层33layer换成11 → 33 → 11,。首先采用11卷积进行深度降维，减少残差模块在深度上的计算量，第二层33layer和之前的模块功能一样，提取图像特征，第三层1*1layer用于维度还原。

那么问题又来了，既然已经经过了3*3卷积，那输出维度怎么会一样呢？作者在论文中给出了三种解决方案：

1、维度不足部分全0填充

2、输入输出维度一致时使用恒等映射，不一致时使用线性投影

3、对于所有的block均使用线性投影。

在本文中，我们对模型主要采用全0填充。

好，以上就是简单的理论入门，接下来我们开始着手用TensorFlow对理论进行代码实现

二、实现规划(ResNet-50-101-152)

我们来选取最具有代表性的152层ResNet来进行搭建，论文的作者就是用152层模型来获得Imagenet大赛冠军的。

不同深度的ResNet结构

结构定义字典

在本文中，我们的模型搭建方式是以字典的形式进行循环堆砌

结构字典

ResNet_demo = { "layer_50":[{"depth": 256,"num_class": 3}, 
 {"depth": 512,"num_class": 4}, 
 {"depth": 1024,"num_class": 6}, 
 {"depth": 2048,"num_class": 3}], 
 "layer_101": [{"depth": 256, "num_class": 3},
 {"depth": 512, "num_class": 4}, 
 {"depth": 1024, "num_class": 23}, 
 {"depth": 2048, "num_class": 3}], 
 "layer_152": [{"depth": 256, "num_class": 3}, 
 {"depth": 512, "num_class": 8}, 
 {"depth": 1024, "num_class": 36}, 
 {"depth": 2048, "num_class": 3}]

子类模块规划

在ResNet网络传递的过程中，我们来探讨一些即将遇到的问题：

1.降采样过程

2.通道填充

降采样示意

降采样过程用于不同类瓶颈模块之间传递的过程，例如上图中粉色卷积层和蓝色卷积层之间的数据交互，蓝色卷积层中的/2就是降采样处理

降采样模块代码实现

def sampling(input_tensor, #Tensor入口 
 ksize = 1, #采样块大小 
 stride = 2): #采样步长 
data = input_tensor 
data = slim.max_pool2d(data,ksize,stride = stride) 
return data

通道填充用于输入数据x与结果数据F（x）生成残差和时造成的通道不匹配问题

通道填充模块代码实现

def depthFilling(input_tensor, #输入
 Tensor depth): #输出深度 
data = input_tensor #取出输入tensor的深度 
input_depth = data.get_shape().as_list()[3]
 #tf.pad用与维度填充，不理解的同学可以去TensoFLow官网了解一下
data = tf.pad(data,[[0,0], 
 [0,0], 
 [0,0], 
 [abs(depth - input_depth)//2, abs(depth - input_depth)//2]]) 
return data

好的，两个子类问题已经得到解决，下面来对残差模块进行规划实现

残差模块

因为搭建方向选择layer大于等于50层，所以我们采用论文中给出的第二种残差模块（11+33+1*1）

残差模块代码实现

def bottleneck(input_tensor,output_depth):
 #取出通道 
 redepth = input_tensor.get_shape().as_list()[3] 
 # 当通道不相符时，进行全零填充并降采样 
 if output_depth != redepth:
 #全零填充
 input_tensor = depthFilling(input_tensor,output_depth) 
 #降采样 
 input_tensor= sampling(input_tensor)
data = input_tensor 
#降通道处理 
data = slim.conv2d(inputs = data,
 num_outputs = output_depth//4,
 kernel_size = 1,stride = 1) 
#提取特征 
data = slim.conv2d(inputs = data,
 num_outputs = output_depth//4,
 kernel_size = 3,stride = 1)
#通道还原 
data = slim.conv2d(inputs = data,
 num_outputs = output_depth,
 kernel_size = 1,stride = 1,
 activation_fn=None,
 normalizer_fn=None) 
#生成残差 
data = data + input_tensor 
data = tf.nn.relu(data) 
return data

有了残差模块，我们就可以对网络结构进行堆砌了

不过，为了精简我们的代码块，我选择把全连接层拿出来单独写成一个模块

FC代码实现

这一模块没有什么技术含量，和我们入门时的BP神经网络差不多

def cnn_to_fc(input_tensor, #Tensor入口 
 num_output, #输出接口数量 
 train = False, #是否使用dropout 
 regularizer = None): #正则函数 
data = input_tensor #得到输出信息的维度，用于全连接层的输入 
data_shape = data.get_shape().as_list() 
nodes = data_shape[1] * data_shape[2] * data_shape[3] 
reshaped = tf.reshape(data, [data_shape[0], nodes]) 
#最后全连接层 
with tf.variable_scope('layer-fc'): 
 fc_weights = tf.get_variable("weight",
 [nodes,num_output], 
 initializer=tf.truncated_normal_initializer(stddev=0.1)) 
 if regularizer != None:
 tf.add_to_collection('losses', regularizer(fc_weights))
 fc_biases = tf.get_variable("bias", [num_output], 
 initializer=tf.constant_initializer(0.1)) 
fc = tf.nn.relu(tf.matmul(reshaped, fc_weights) + fc_biases) 
if train:
 fc = tf.nn.dropout(fc, 0.5) 
return fc

定义传递规则

inference

#堆叠ResNet模块
def inference(input_tensor, #数据入口
 demos, #模型资料（list）
 num_output, #出口数量
 is_train):
data = input_tensor #第一层卷积7*7,stride = 2,深度为64
data = conv2d_same(data,64,7,2,is_train,None,normalizer_fn = False)
data = slim.max_pool2d(data,3,2,scope="pool_1")
with tf.variable_scope("resnet"): #堆叠总类瓶颈模块
 demo_num = 0
 for demo in demos:
 demo_num += 1
 print("--------------------------------------------") #堆叠子类瓶颈模块
 for i in range(demo["num_class"]):
 print(demo_num)
 if demo_num is not 4:
 if i == demo["num_class"] - 1:
 stride = 2
 else:
 stride = 1
 else:
 stride = 1
 data = bottleneck(data,demo["depth"],stride,is_train)
 print("--------------------------------------------")
data = tf.layers.batch_normalization(data,training=is_train)
data = tf.nn.relu(data) #平均池化，也可用Avg_pool函数
data = tf.reduce_mean(data, [1, 2], keep_dims=True)
print("output : ", data) #最后全连接层
data = slim.conv2d(data,num_output,1,activation_fn=None)
data_shape = data.get_shape().as_list()
nodes = data_shape[1] * data_shape[2] * data_shape[3]
data = tf.reshape(data, [-1, nodes])
return data

inference调用方式

 inference(input_tensor = 数据入口
 demos = ResNet_demo["layer_101"], #获取模型词典
 num_output = 出口数量,
 is_train = False) # BN是否被训练

参考文献：

https://arxiv.org/pdf/1512.03385.pdf

http://blog.csdn.net/xxy0118/article/details/78324256

http://blog.csdn.net/mao_feng/article/details/52734438

使用介绍

图片分类以及目录结构

Snip20181114_1.png

第一步、运行FlowIO.py

image.png

第二步、运行train.py 训练模型 我这里图片少，训练的次数也少，真实情况要大量训练

image.png

第三步、运行Evaluation.py，测试结果集，可跳过

选择正确的模型：

正确的模型.png

第四步、使用模型useModel.py，进行图片识别

image.png

结果是对的！！！

请忽略我的结果，因为我只有8张训练集，这个每类最少要80张训练集。

稍后我多下些训练集试试