基于keras框架实现车辆识别模型

-- coding: utf-8 --

"""
Created on Wed Nov 14 22:12:51 2018

基于keras框架实现自动驾驶的车辆识别模型的建立
@author: ltx
"""
import argparse
import os
import matplotlib.pyplot as plt
from matplotlib.pyplot import imshow
import scipy.io
import scipy.misc
import numpy as np
import pandas as pd
import PIL
import tensorflow as tf
from keras import backend as K
from keras.layers import Input, Lambda, Conv2D
from keras.models import load_model, Model

from yad2k.models.keras_yolo import yolo_head, yolo_boxes_to_corners, preprocess_true_boxes, yolo_loss, yolo_body
import yolo_utils
import keras_yolo

def yolo_filter_boxes(box_confidence , boxes, box_class_probs, threshold = 0.6):
"""
通过阈值来过滤对象和分类的置信度。

参数：
    box_confidence  - tensor类型，维度为（19,19,5,1）,包含19x19单元格中每个单元格预测的5个锚框中的所有的锚框的pc （一些对象的置信概率）。
    boxes - tensor类型，维度为(19,19,5,4)，包含了所有的锚框的（px,py,ph,pw ）。
    box_class_probs - tensor类型，维度为(19,19,5,80)，包含了所有单元格中所有锚框的所有对象( c1,c2,c3，···，c80 )检测的概率。
    threshold - 实数，阈值，如果分类预测的概率高于它，那么这个分类预测的概率就会被保留。

返回：
    scores - tensor 类型，维度为(None,)，包含了保留了的锚框的分类概率。
    boxes - tensor 类型，维度为(None,4)，包含了保留了的锚框的(b_x, b_y, b_h, b_w)
    classess - tensor 类型，维度为(None,)，包含了保留了的锚框的索引

注意："None"是因为你不知道所选框的确切数量，因为它取决于阈值。
      比如：如果有10个锚框，scores的实际输出大小将是（10,）
"""

#第一步：计算锚框的得分
box_scores  = box_confidence * box_class_probs

#第二步：找到最大值的锚框的索引以及对应的最大值的锚框的分数
box_classes = K.argmax(box_scores, axis=-1)
box_class_scores = K.max(box_scores, axis=-1)

#第三步：根据阈值创建掩码
filtering_mask = (box_class_scores >= threshold)

#对scores, boxes 以及 classes使用掩码
scores = tf.boolean_mask(box_class_scores,filtering_mask)
boxes = tf.boolean_mask(boxes,filtering_mask)
classes = tf.boolean_mask(box_classes,filtering_mask)

return scores , boxes , classes

非最大值抑制——首先实现交并比函数

def iou(box1,box2):
""""
实现两个锚框的交并比
参数: box1:(x1,y1,x2,y2)锚框box1的左下角和右上角的坐标
box2:(x1,y1,x2,y2)锚框的box2左下角和右上角的坐标
返回：交并比的值iou
"""
#计算两个锚框的交集
x1_i=np.maximum(box1[0],box2[0])#逐位比较取最大值
y1_i=np.maximum(box1[1],box2[1])
x2_i=np.minimum(box1[2],box2[2])
y2_i=np.minimum(box1[3],box2[3])
inter_area=(x1_i-x2_i)*(y1_i-y2_i)
print("x1_i = " + str(x1_i))
print("y1_i = " + str(y1_i))
print("x2_i = " + str(x2_i))
print("y2_i = " + str(y2_i))
print("inter_area = " + str(inter_area))

#计算两个锚框的并集 公式为：Union(A,B) = A + B - Inter(A,B)
box1_area=(box1[2]-box1[0])*(box1[3]-box1[1])
box2_area=(box2[2]-box2[0])*(box2[3]-box2[1])
union_area=box1_area+box2_area-inter_area
#计算交并比
ious=inter_area/union_area
return ious

box1 = (2,1,4,3)
box2 = (1,2,3,4)

print("iou = " + str(iou(box1, box2)))

def yolo_non_max_suppression(scores, boxes, classes, max_boxes=10, iou_threshold=0.5):
"""
为锚框实现非最大值抑制（ Non-max suppression (NMS)）

参数：
    scores - tensor类型，维度为(None,)，yolo_filter_boxes()的输出
    boxes - tensor类型，维度为(None,4)，yolo_filter_boxes()的输出，已缩放到图像大小（见下文）
    classes - tensor类型，维度为(None,)，yolo_filter_boxes()的输出
    max_boxes - 整数，预测的锚框数量的最大值
    iou_threshold - 实数，交并比阈值。

返回：
    scores - tensor类型，维度为(,None)，每个锚框的预测的可能值
    boxes - tensor类型，维度为(4,None)，预测的锚框的坐标
    classes - tensor类型，维度为(,None)，每个锚框的预测的分类

注意："None"是明显小于max_boxes的，这个函数也会改变scores、boxes、classes的维度，这会为下一步操作提供方便。

"""
max_boxes_tensor = K.variable(max_boxes,dtype="int32") #用于tf.image.non_max_suppression()
K.get_session().run(tf.variables_initializer([max_boxes_tensor])) #初始化变量max_boxes_tensor

#使用使用tf.image.non_max_suppression()来获取与我们保留的框相对应的索引列表
nms_indices = tf.image.non_max_suppression(boxes, scores,max_boxes,iou_threshold)

#使用K.gather()来选择保留的锚框
scores = K.gather(scores, nms_indices)
boxes = K.gather(boxes, nms_indices)
classes = K.gather(classes, nms_indices)

return scores, boxes, classes

将用中心点和宽高的方式来描述锚框改为用左下角和右上角的方式来描述锚框

def yolo_boxes_to_corners(box_xy,box_wh):
boxes1=box_xy-box_wh/2 #(190,190,5,2)
boxes2=box_xy+box_wh/2 #(190,190,5,2)
box=K.concatenate([boxes1[...,1:2],boxes1[...,0:1],boxes2[...,1:2],boxes2[...,0:1]])
print("box"+str(box.shape)) #box(19, 19, 5, 4)
return box

def yolo_eval(yolo_outputs, image_shape=(720.,1280.),
max_boxes=10, score_threshold=0.6,iou_threshold=0.5):
"""
将YOLO编码的输出（很多锚框）转换为预测框以及它们的分数，框坐标和类。

参数：
    yolo_outputs - 编码模型的输出（对于维度为（608,608,3）的图片），包含4个tensors类型的变量：
                    box_confidence ： tensor类型，维度为(None, 19, 19, 5, 1)
                    box_xy         ： tensor类型，维度为(None, 19, 19, 5, 2)
                    box_wh         ： tensor类型，维度为(None, 19, 19, 5, 2)
                    box_class_probs： tensor类型，维度为(None, 19, 19, 5, 80)
    image_shape - tensor类型，维度为（2,），包含了输入的图像的维度，这里是(608.,608.)
    max_boxes - 整数，预测的锚框数量的最大值
    score_threshold - 实数，可能性阈值。
    iou_threshold - 实数，交并比阈值。

返回：
    scores - tensor类型，维度为(,None)，每个锚框的预测的可能值
    boxes - tensor类型，维度为(4,None)，预测的锚框的坐标
    classes - tensor类型，维度为(,None)，每个锚框的预测的分类
"""

#获取YOLO模型的输出
box_confidence, box_xy, box_wh, box_class_probs = yolo_outputs

#中心点转换为边角
boxes = yolo_boxes_to_corners(box_xy,box_wh)

#可信度分值过滤
scores, boxes, classes = yolo_filter_boxes(box_confidence, boxes, box_class_probs, score_threshold)

#缩放锚框，以适应原始图像
boxes = yolo_utils.scale_boxes(boxes, image_shape)

#使用非最大值抑制
scores, boxes, classes = yolo_non_max_suppression(scores, boxes, classes, max_boxes, iou_threshold)

return scores, boxes, classes

-----------------------------------------------------------------------------

--------开始完整版------------------------------

加载预先训练好了的CNN模型，YOLO模型，使用汽车检测数据集进行测试，实现图片锚框的输出。

sess=K.get_session() #会话,设计计算图

在使用YOLO模型前，需要一些数据，比如测试要用的汽车检测图片集数据（size）

比如多少个分类信息（80），多少个锚框及其属性（5），这个三个信息是从外部收集而来

加载需要输入到YOLO模型中的外部信息

class_names=yolo_utils.read_classes("model_data/coco_classes.txt") #80个类别
anchors=yolo_utils.read_anchors("model_data/yolo_anchors.txt") #5个锚框

加载已经训练好了的YOLO模型

yolo_model=load_model("model_data/yolov2.h5")

模型的输入为（m，608,608,3）输出为（m,19,19,5,85）

yolo_outputs = keras_yolo.yolo_head(yolo_model.output, anchors, len(class_names)) #return 4个参数值作为eval的输入

加载eval来过滤锚框

score_max,boxes_max,index_max=yolo_eval(yolo_outputs,image_shape=(720.,1280.))

--------------------使用真实的图片进行预测----------------------

def prediction(sess,image_file,is_show_info=True, is_plot=True):
""""
运行sess计算图来预测某张图片image_file,打印出图片以及预测出的种类、锚框信息
参数：
sess - 包含了YOLO计算图的TensorFlow/Keras的会话。
image_file - 存储在images文件夹下的图片名称
返回：
out_scores - tensor类型，维度为(None,)，锚框的预测的可能值。None=maxboxnum=12
out_boxes - tensor类型，维度为(None,4)，包含了锚框位置信息。
out_classes - tensor类型，维度为(None,)，锚框的预测的分类索引。
"""
#预处理输入的图像image_file
image, image_data =yolo_utils.preprocess_image("images/"+image_file,(608,608))
#运行会话并在feed_dict中选择正确的占位符.
out_scores, out_boxes, out_classes = sess.run([score_max,boxes_max,index_max], feed_dict = {yolo_model.input:image_data, K.learning_phase(): 0})
#打印预测信息 score_max,boxes_max,index_max
if is_show_info:
print("在" + str(image_file) + "中找到了" + str(len(out_boxes)) + "个锚框。")

#指定要绘制的边界框的颜色
colors = yolo_utils.generate_colors(class_names)

#在图中绘制边界框
yolo_utils.draw_boxes(image, out_scores, out_boxes, out_classes, class_names, colors)

#保存已经绘制了边界框的图
image.save(os.path.join("out", image_file), quality=100)

#打印出已经绘制了边界框的图
if is_plot:
    output_image = scipy.misc.imread(os.path.join("out", image_file))
    plt.imshow(output_image)
return out_scores, out_boxes, out_classes

------------------test----------------------------------------------

out_scores, out_boxes, out_classes = prediction(sess, "l1.jpg")
------------------------实验结果-----------------------------

同分布.png

不同分布效果.png