吴恩达第四课第三周编程作业

目的

汽车识别

连接

链接：https://pan.baidu.com/s/1OmP2kolqjAXG5KaZvljAYQ 
提取码：o8fw 

代码

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

#分类阈值过滤
def yolo_filter_boxes(box_confidence , boxes, box_class_probs, threshold = 0.6):
    """
    :param box_confidence: 维度（19,19,5,1），包含五个瞄框中的pc值
    :param boxes:维度（15,15,5,4），包含（px，py，ph，pw）
    :param box_class_probs:维度（15,15,5,80），包含所有对象检测的概率（c1~~~c80）
    :param threshold:阈值，高于他将会保留
    """
    #计算瞄框的得分
    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=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):
    #计算相交域的面积
    xi1=np.maximum(box1[0],box2[0])
    yi1=np.maximum(box1[1],box2[1])
    xi2=np.minimum(box1[2],box2[2])
    yi2=np.minimum(box1[3],box2[3])
    inter_area=(xi2-xi1)*(yi2-yi1)
    #并集计算
    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
    #交并集
    iou=inter_area/union_area
    return iou
def yolo_non_max_suppression(scores, boxes, classes, max_boxes=10, iou_threshold=0.5):
    """
    :param scores,boxes,classes: yolo_filter_boxes()的输出
    :param max_boxes:整数，预测的锚框数量的最大值
    :param iou_threshold:实数，交并比阈值。
    """
    max_boxes_tensor =K.variable(max_boxes,dtype='int32')
    K.get_session().run(tf.variables_initializer([max_boxes_tensor]))#初始化变量
    #获取与我们保留的框相对应的索引列表
    nms_indices=tf.image.non_max_suppression(boxes,scores,max_boxes,iou_threshold)

    scores=K.gather(scores,nms_indices)
    boxes=K.gather(boxes,nms_indices)
    classes=K.gather(classes,nms_indices)
    return scores,boxes,classes
#对所有框进行过滤
def yolo_eval(yolo_outputs, image_shape=(720.,1280.),
              max_boxes=10, score_threshold=0.6,iou_threshold=0.5):
    """
    :param yolo_outputs: 所有元素，维度（None，19,19,5，x）
    :param image_shape:输入图像的维度
    :param max_boxes:瞄框数量的最大值
    :param score_threshold:可能性阈值
    :param iou_threshold:交并比阈值
    """
    #获取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



sess = K.get_session()
class_names = yolo_utils.read_classes("model_data/coco_classes.txt")
anchors = yolo_utils.read_anchors("model_data/yolo_anchors.txt")
image_shape = (720.,1280.)
yolo_model = load_model("model_data/yolov2.h5")
yolo_model.summary()
yolo_outputs = yolo_head(yolo_model.output, anchors, len(class_names))
scores, boxes, classes = yolo_eval(yolo_outputs, image_shape)
def predict(sess, image_file, is_show_info=True, is_plot=True):
    """
    运行存储在sess的计算图以预测image_file的边界框，打印出预测的图与信息。

    参数：
        sess - 包含了YOLO计算图的TensorFlow/Keras的会话。
        image_file - 存储在images文件夹下的图片名称
    返回：
        out_scores - tensor类型，维度为(None,)，锚框的预测的可能值。
        out_boxes - tensor类型，维度为(None,4)，包含了锚框位置信息。
        out_classes - tensor类型，维度为(None,)，锚框的预测的分类索引。
    """
    #图像预处理
    image, image_data = yolo_utils.preprocess_image("images/" + image_file, model_image_size = (608, 608))

    #运行会话并在feed_dict中选择正确的占位符.
    out_scores, out_boxes, out_classes = sess.run([scores, boxes, classes], feed_dict = {yolo_model.input:image_data, K.learning_phase(): 0})

    #打印预测信息
    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

for i in range(1,120):

    #计算需要在前面填充几个0
    num_fill = int( len("0000") - len(str(1))) + 1
    #对索引进行填充
    filename = str(i).zfill(num_fill) + ".jpg"

    print("当前文件：" + str(filename))
    #开始绘制，不打印信息，不绘制图
    out_scores, out_boxes, out_classes = predict(sess, filename,is_show_info=False,is_plot=False)


print("绘制完成！")

注：参考网址：https://blog.csdn.net/u013733326/article/details/80341740