Python吴恩达深度学习作业15 — YOLO原理及应用（自动驾驶——汽车检测）

自动驾驶 – 车辆识别

本次作业你将学习使用YOLO模型用于目标检测。YOLO的两篇论文涵盖了此笔记本中的许多内容：Redmon et al., 2016 (https://arxiv.org/abs/1506.02640) 以及 Redmon and Farhadi, 2016 (https://arxiv.org/abs/1612.08242).

你将学会：

• 在车辆识别数据集上使用目标检测
• 处理边界框

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

%matplotlib inline

Using TensorFlow backend.

重要提示：如你所见，我们将Keras后端导入为K。这意味着要在此笔记本中使用Keras函数，你需要编写：K.function(…)。

1 问题描述

假设你正在开发自动驾驶汽车。作为该项目的重要组成部分，首先你想要构建一个车辆识别系统。为了收集数据，你已经在汽车的引擎盖（即前部）上安装了摄像头，该摄像头会在车辆行驶时每隔几秒钟拍摄一次前方道路的照片。

你已将所有这些图像收集到一个文件夹中，并通过在找到的每辆汽车周围绘制边框来标记它们。这是边界框的示例。

如果你希望YOLO识别80个类，则可以将类标签c c c表示为1到80之间的整数，或者表示为80维向量（包含80个数字），其中一个分量为1，其余均为0。在此笔记本中，我们将使用这两种表示形式，哪种方法更方便就用哪种。

在本练习中，你将学习了解YOLO的工作原理，然后将其应用于车辆识别。由于训练YOLO模型需要耗费大量时间，因此我们将加载预训练的权重供你使用。

; 2 YOLO

YOLO(“you only look once”)是一个很受欢迎的算法，因为它可以在实现高精度的同时能实时运行。网络仅需要进行一次正向传播便可预测，因此说该算法”仅看一次图像”。在非极大值抑制之后，模型将同边界框一起输出识别到的目标。

2.1 模型详细信息

首先要知道的是：

• 输入是一批维度为( m , 608 , 608 , 3 ) (m,608,608,3)(m ,608 ,608 ,3 )的图像
• 输出是边界框和已识别的类列别。如上所述，每个边界框由6个数字( p c , b x , b y , b h , b w , c ) (p_c,b_x,b_y,b_h,b_w,c)(p c ​,b x ​,b y ​,b h ​,b w ​,c )表示。如果将c c c扩展为80维向量，则每个边界框将由85个数字表示。

我们将使用5个锚框。因此，你可以将YOLO架构视为以下内容：Image ( m , 608 , 608 , 3 ) (m,608,608,3)(m ,608 ,608 ,3 )->Deep CNN ->Encoding ( m , 19 , 19 , 5 , 85 ) (m,19,19,5,85)(m ,19 ,19 ,5 ,85 )

让我们详细了解一下此编码表示：

如果目标的中心/中点落在网格单元，则该网络单元负责识别该对象。

由于我们使用的是5个锚框，因此19 × 19 19 \times 19 19 ×19单元中的每一个都对5个框的信息进行编码。锚框仅由其宽度和高度定义。

为简单起见，我们将压平编码的最后两个维度( 19 , 19 , 5 , 85 ) (19,19,5,85)(19 ,19 ,5 ,85 )，因此，CNN的输出为( 19 , 19 , 425 ) (19,19,425)(19 ,19 ,425 )。

现在，对于（每个单元格的）每个框，我们将计算以下元素乘积，并提取该框包含某个类的概率。

这是一种可视化YOLO预测图像的方法：

• 对于19 × 19 19 \times 19 19 ×19的每个网格单元，找到概率得分的最大值（在5个锚点框和不同类别中均取最大值）。
• 根据网格单元认为最可能的目标为对应的网格单元着色。

执行此操作将得到以下图片：

请注意，这种可视化不是YOLO预测算法的核心部分。这只是可视化算法中间结果的一种好方法。

可视化YOLO输出的另一种方法是绘制其输出的边界框。这样做将产生如下可视化效果：

每个单元格给你5个方框，该模型总共预测：仅查看一次图像即可一次获得19x19x5 = 1805个框（正向传播）！不同的颜色表示不同的类别。

在上图中，我们仅绘制了模型预测高概率的框，但是框仍然太多，你希望将算法的输出过滤到数量更少的目标类别。为此，你将使用非极大值抑制。具体来说，你将执行以下步骤：

• 丢弃分数较低的盒子（这意味着盒子对检测类别不是很有信心）
• 当多个框彼此重叠并检测到相同的目标时，仅选择一个框。

; 2.2 对类别分数进行过滤

你将通过阈值化应用第一个过滤器，用于丢弃类”得分”小于所选阈值的所有框。

该模型总共为你提供了19 × 19 × 5 × 85 19 \times 19 \times 5 \times 85 19 ×19 ×5 ×85个数，每个框由85个数描述。将维度为( 19 , 19 , 5 , 85 ) (19,19,5,85)(19 ,19 ,5 ,85 )（或( 19 , 19 , 425 ) (19,19,425)(19 ,19 ,425 )）的张量重新排列为以下变量将更加方便操作：

• box_confidence：维度为( 19 × 19 , 5 , 1 ) (19 \times 19,5,1)(19 ×19 ,5 ,1 )的张量包含p c p_c p c ​（存在某个目标的置信概率）个19 × 19 19 \times 19 19 ×19单元格中检测到的5个框。
• boxes：维度为( 19 × 19 , 5 , 4 ) (19 \times 19,5,4)(19 ×19 ,5 ,4 )的张量都包含( b x , b y , b h , b w ) (b_x,b_y,b_h,b_w)(b x ​,b y ​,b h ​,b w ​)每个单元格中的5个框。
• box_class_probs：维度为( 19 × 19 , 5 , 80 ) (19 \times 19,5,80)(19 ×19 ,5 ,80 )的张量，其中包含5个框中每个单元格的80个类别的对应的检测概率( c 1 , c 2 , . . . , c 80 ) (c_1,c_2,…,c_{80})(c 1 ​,c 2 ​,…,c 80 ​)。

练习：实现 yolo_filter_boxes()。

1. 按照图4所述，通过按元素乘积计算框的分数。以下代码可以帮助你选择合适的运算符：

a = np.random.randn(19*19, 5, 1)
b = np.random.randn(19*19, 5, 80)
c = a * b

1. 对于每个框，找到：
2. 具有最大值的框的类别索引(Hint)（请注意选择的轴；考虑使用axis = -1）
3. 相应的框分数 (Hint) （请注意选择的轴；考虑使用axis = -1）
4. 使用阈值创建mask。提醒一下：([0.9, 0.3, 0.4, 0.5, 0.1] < 0.4)会返回： [False, True, False, False, True]。对于要保留的框，mask应该为True。
5. 使用TensorFlow将mask应用于box_class_scores，box和box_classes，以过滤掉我们不需要的框。你应该只剩下要保留的部分框。 (Hint)

提醒：调用Keras函数应该使用K.function（…）。

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 = 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

with tf.Session() as test_a:
    box_confidence = tf.random_normal([19,19,5,1], mean=1, stddev=4, seed=1)
    boxes = tf.random_normal([19,19,5,4],  mean=1, stddev=4, seed=1)
    box_class_probs = tf.random_normal([19, 19, 5, 80], mean=1, stddev=4, seed = 1)
    scores, boxes, classes = yolo_filter_boxes(box_confidence, boxes, box_class_probs, threshold = 0.5)

    print("scores[2] = " + str(scores[2].eval()))
    print("boxes[2] = " + str(boxes[2].eval()))
    print("classes[2] = " + str(classes[2].eval()))
    print("scores.shape = " + str(scores.shape))
    print("boxes.shape = " + str(boxes.shape))
    print("classes.shape = " + str(classes.shape))

    test_a.close()

scores[2] = 10.750582
boxes[2] = [ 8.426533   3.2713668 -0.5313436 -4.9413733]
classes[2] = 7
scores.shape = (?,)
boxes.shape = (?, 4)
classes.shape = (?,)

2.3 非极大值抑制

即使在通过对类别分数进行阈值过滤后，你仍然会遇到很多重叠的框。用于选择正确框的第二个过滤器叫做非极大值抑制（NMS）。

在此示例中，该模型检测到了3辆汽车，但实际上是同一辆汽车的3个预测结果。运行非极大值抑制（NMS）将仅选择三个框中最准确的（概率最高）一个。

非极大值抑制使用非常重要的函数，即 “Intersection over Union” 或者说IoU。

“联合交集”的定义。

练习：实现iou()。提示：

• 我们仅在次练习中使用两个角（左上角和右下角）（x1，y1，x2，y2）而不是中点和高度/宽度来定义一个框。
• 要计算矩形的面积，你需要将高度（y2-y1）乘以其宽度（x2-x1）
• 你还需要找到两个框的交点的坐标（xi1，yi1，xi2，yi2）。记住：
• xi1 = 两个框的x1坐标的最大值
• yi1 = 两个框的y1坐标的最大值
• xi2 = 两个框的x2坐标的最小值
• yi2 = 两个框的y2坐标的最小值

在此代码中，我们使用以下约束条件：（0,0）代表图像的左上角，（1,0）是右上角，（1,1）是右下角。

def iou(box1, box2):
"""
    实现两个锚框的交并比的计算

    参数：
        box1 - 第一个锚框，元组类型，(x1, y1, x2, y2)
        box2 - 第二个锚框，元组类型，(x1, y1, x2, y2)

    返回：
        iou - 实数，交并比。
"""

    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 = (xi1-xi2)*(yi1-yi2)

    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

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

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

iou = 0.14285714285714285

现在你可以实现非极大值抑制，其关键步骤是：

1. 选择得分最高的框。
2. 计算它与所有其他框的重叠，并删除与其重叠超过”iou_threshold”的框。
3. 返回到步骤1并进行迭代，直到没有比当前所选框更低的框。

这将删除所有与所选框重叠较大的框。仅保留”最佳”框。

练习：使用TensorFlow实现 yolo_non_max_suppression()。TensorFlow有两个内置函数可用于实现非极大值抑制（因此你实际上不需要使用你的iou()实现方法）：

• tf.image.non_max_suppression()
• K.gather()

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")
    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

with tf.Session() as test_b:
    scores = tf.random_normal([54,], mean=1, stddev=4, seed = 1)
    boxes = tf.random_normal([54, 4], mean=1, stddev=4, seed = 1)
    classes = tf.random_normal([54,], mean=1, stddev=4, seed = 1)
    scores, boxes, classes = yolo_non_max_suppression(scores, boxes, classes)

    print("scores[2] = " + str(scores[2].eval()))
    print("boxes[2] = " + str(boxes[2].eval()))
    print("classes[2] = " + str(classes[2].eval()))
    print("scores.shape = " + str(scores.eval().shape))
    print("boxes.shape = " + str(boxes.eval().shape))
    print("classes.shape = " + str(classes.eval().shape))

    test_b.close()

scores[2] = 6.938395
boxes[2] = [-5.299932    3.1379814   4.450367    0.95942086]
classes[2] = -2.2452729
scores.shape = (10,)
boxes.shape = (10, 4)
classes.shape = (10,)

2.4 将两者组合以筛选边界框

是时候实现采用CNN输出（19 × 19 × 5 × 85 19 \times 19 \times 5 \times 85 19 ×19 ×5 ×85维度编码）并使用刚刚实现的函数对所有框进行过滤筛选了。

练习：实现 yolo_eval()，获取YOLO编码的输出，并使用得分阈值和NMS过滤框。你只需要了解最后一个实现细节。有几种表示框的方法，例如通过它们的角或中点和高度/宽度。YOLO使用以下函数（我们已提供）在不同时间内在这几种类格式之间进行转换：

boxes = yolo_boxes_to_corners(box_xy, box_wh)

它将yolo框坐标（ x , y , w , h ） （x,y,w,h）（x ,y ,w ,h ）转换为框角的坐标（ x 1 , y 1 , x 2 , y 2 ） （x1,y1,x2,y2）（x 1 ,y 1 ,x 2 ,y 2 ）以匹配 yolo_filter_boxes的输入

boxes = scale_boxes(boxes, image_shape)

YOLO的网络经过训练可以在608×608的图像上运行。如果要在其他尺寸的图像上测试此数据（例如，车辆识别数据集具有720×1280的图像），此步骤将重新调整框的比例，以便可以将其绘制在原始720×1280图像的顶部。

不用担心这两个函数；我们将向你展示哪里需要用到它们。

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)，每个锚框的预测的分类
"""

    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

with tf.Session() as test_c:
    yolo_outputs = (tf.random_normal([19, 19, 5, 1], mean=1, stddev=4, seed = 1),
                    tf.random_normal([19, 19, 5, 2], mean=1, stddev=4, seed = 1),
                    tf.random_normal([19, 19, 5, 2], mean=1, stddev=4, seed = 1),
                    tf.random_normal([19, 19, 5, 80], mean=1, stddev=4, seed = 1))
    scores, boxes, classes = yolo_eval(yolo_outputs)

    print("scores[2] = " + str(scores[2].eval()))
    print("boxes[2] = " + str(boxes[2].eval()))
    print("classes[2] = " + str(classes[2].eval()))
    print("scores.shape = " + str(scores.eval().shape))
    print("boxes.shape = " + str(boxes.eval().shape))
    print("classes.shape = " + str(classes.eval().shape))

    test_c.close()

scores[2] = 138.79124
boxes[2] = [1292.3297  -278.52167 3876.9893  -835.56494]
classes[2] = 54
scores.shape = (10,)
boxes.shape = (10, 4)
classes.shape = (10,)

YOLO总结：

• 输入图像维度为( 608 , 608 , 3 ) (608,608,3)(608 ,608 ,3 )
• 输入图像通过CNN，输出维度为( 19 , 19 , 5 , 85 ) (19,19,5,85)(19 ,19 ,5 ,85 )。
• 将最后两个维度展平后，输出为一定体积的形状( 19 , 19 , 425 ) (19,19,425)(19 ,19 ,425 )：
• 输入图像上方19 × 19 19 \times 19 19 ×19网格中的每个单元格给出425个数字。
• 425 = 5 × 85 425 = 5 \times 85 425 =5 ×85，因为每个单元格都包含5个预测框，对应于5个锚定框，如讲座中所示。
• 85 = 5 + 80 85 = 5 + 80 85 =5 +80，其中5是因为具有5个数，而80是我们要识别的类别数量
• 然后，你仅根据以下几点选择框：
• 分数阈值：丢弃检测到分数小于阈值的类别框
• 非极大值抑制：计算并集上的交点，并避免选择重叠的框
• 为你提供YOLO的最终输出。

3 输入图像测试YOLO预训练模型

在本部分中，你将使用预训练的模型并在车辆识别数据集上对其进行测试。与往常一样，你首先要 创建会话以开始计算图。
运行以下单元格。

sess = K.get_session()

3.1 定义类，锚点和图像维度

回想一下，我们在尝试识别80个类别，并使用5个定位框。我们已经在两个文件”coco_classes.txt”和”yolo_anchors.txt”中收集了有关80个类和5个框的信息。让我们通过运行下一个单元格将这些数加载到模型中。

车辆识别数据集包含720×1280图像，我们已将其预处理为608×608的图像。

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.)

3.2 加载预训练模型

训练YOLO模型需要花费很长时间，并且需要相当大的带标签的边界框数据集。你将要加载存储在”yolo.h5″中的现有预先训练的Keras YOLO模型。（这些权重来自YOLO官方网站，并使用Allan Zelener编写的函数进行转换。技术上讲，这些是”YOLOv2″模型的参数，但我们将更简单地参考（在此笔记本中为” YOLO”））
运行下面的单元格，从该文件中加载模型。

生成yolo.h5：

git clone https://github.com/allanzelener/YAD2K.git

下载yolo.weights和yolo.cfg放到文件夹，命令执行：

python yad2k.py yolo.cfg yolo.weights model_data / yolo.h5

下载地址：http://pjreddie.com/media/files/yolo.weights

https://raw.githubusercontent.com/pjreddie/darknet/master/cfg/yolo.cfg

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

加载经过训练的YOLO模型的权重。下面是模型各层信息摘要。

yolo_model.summary()

Model: "model_1"
__________________________________________________________________________________________________
Layer (type)                    Output Shape         Param #     Connected to
==================================================================================================
input_1 (InputLayer)            (None, 608, 608, 3)  0
__________________________________________________________________________________________________
conv2d_1 (Conv2D)               (None, 608, 608, 32) 864         input_1[0][0]
__________________________________________________________________________________________________
batch_normalization_1 (BatchNor (None, 608, 608, 32) 128         conv2d_1[0][0]
__________________________________________________________________________________________________
leaky_re_lu_1 (LeakyReLU)       (None, 608, 608, 32) 0           batch_normalization_1[0][0]
__________________________________________________________________________________________________
max_pooling2d_1 (MaxPooling2D)  (None, 304, 304, 32) 0           leaky_re_lu_1[0][0]
__________________________________________________________________________________________________
conv2d_2 (Conv2D)               (None, 304, 304, 64) 18432       max_pooling2d_1[0][0]
__________________________________________________________________________________________________
batch_normalization_2 (BatchNor (None, 304, 304, 64) 256         conv2d_2[0][0]
__________________________________________________________________________________________________
leaky_re_lu_2 (LeakyReLU)       (None, 304, 304, 64) 0           batch_normalization_2[0][0]
__________________________________________________________________________________________________
max_pooling2d_2 (MaxPooling2D)  (None, 152, 152, 64) 0           leaky_re_lu_2[0][0]
__________________________________________________________________________________________________
conv2d_3 (Conv2D)               (None, 152, 152, 128 73728       max_pooling2d_2[0][0]
__________________________________________________________________________________________________
batch_normalization_3 (BatchNor (None, 152, 152, 128 512         conv2d_3[0][0]
__________________________________________________________________________________________________
leaky_re_lu_3 (LeakyReLU)       (None, 152, 152, 128 0           batch_normalization_3[0][0]
__________________________________________________________________________________________________
conv2d_4 (Conv2D)               (None, 152, 152, 64) 8192        leaky_re_lu_3[0][0]
__________________________________________________________________________________________________
batch_normalization_4 (BatchNor (None, 152, 152, 64) 256         conv2d_4[0][0]
__________________________________________________________________________________________________
leaky_re_lu_4 (LeakyReLU)       (None, 152, 152, 64) 0           batch_normalization_4[0][0]
__________________________________________________________________________________________________
conv2d_5 (Conv2D)               (None, 152, 152, 128 73728       leaky_re_lu_4[0][0]
__________________________________________________________________________________________________
batch_normalization_5 (BatchNor (None, 152, 152, 128 512         conv2d_5[0][0]
__________________________________________________________________________________________________
leaky_re_lu_5 (LeakyReLU)       (None, 152, 152, 128 0           batch_normalization_5[0][0]
__________________________________________________________________________________________________
max_pooling2d_3 (MaxPooling2D)  (None, 76, 76, 128)  0           leaky_re_lu_5[0][0]
__________________________________________________________________________________________________
conv2d_6 (Conv2D)               (None, 76, 76, 256)  294912      max_pooling2d_3[0][0]
__________________________________________________________________________________________________
batch_normalization_6 (BatchNor (None, 76, 76, 256)  1024        conv2d_6[0][0]
__________________________________________________________________________________________________
leaky_re_lu_6 (LeakyReLU)       (None, 76, 76, 256)  0           batch_normalization_6[0][0]
__________________________________________________________________________________________________
conv2d_7 (Conv2D)               (None, 76, 76, 128)  32768       leaky_re_lu_6[0][0]
__________________________________________________________________________________________________
batch_normalization_7 (BatchNor (None, 76, 76, 128)  512         conv2d_7[0][0]
__________________________________________________________________________________________________
leaky_re_lu_7 (LeakyReLU)       (None, 76, 76, 128)  0           batch_normalization_7[0][0]
__________________________________________________________________________________________________
conv2d_8 (Conv2D)               (None, 76, 76, 256)  294912      leaky_re_lu_7[0][0]
__________________________________________________________________________________________________
batch_normalization_8 (BatchNor (None, 76, 76, 256)  1024        conv2d_8[0][0]
__________________________________________________________________________________________________
leaky_re_lu_8 (LeakyReLU)       (None, 76, 76, 256)  0           batch_normalization_8[0][0]
__________________________________________________________________________________________________
max_pooling2d_4 (MaxPooling2D)  (None, 38, 38, 256)  0           leaky_re_lu_8[0][0]
__________________________________________________________________________________________________
conv2d_9 (Conv2D)               (None, 38, 38, 512)  1179648     max_pooling2d_4[0][0]
__________________________________________________________________________________________________
batch_normalization_9 (BatchNor (None, 38, 38, 512)  2048        conv2d_9[0][0]
__________________________________________________________________________________________________
leaky_re_lu_9 (LeakyReLU)       (None, 38, 38, 512)  0           batch_normalization_9[0][0]
__________________________________________________________________________________________________
conv2d_10 (Conv2D)              (None, 38, 38, 256)  131072      leaky_re_lu_9[0][0]
__________________________________________________________________________________________________
batch_normalization_10 (BatchNo (None, 38, 38, 256)  1024        conv2d_10[0][0]
__________________________________________________________________________________________________
leaky_re_lu_10 (LeakyReLU)      (None, 38, 38, 256)  0           batch_normalization_10[0][0]
__________________________________________________________________________________________________
conv2d_11 (Conv2D)              (None, 38, 38, 512)  1179648     leaky_re_lu_10[0][0]
__________________________________________________________________________________________________
batch_normalization_11 (BatchNo (None, 38, 38, 512)  2048        conv2d_11[0][0]
__________________________________________________________________________________________________
leaky_re_lu_11 (LeakyReLU)      (None, 38, 38, 512)  0           batch_normalization_11[0][0]
__________________________________________________________________________________________________
conv2d_12 (Conv2D)              (None, 38, 38, 256)  131072      leaky_re_lu_11[0][0]
__________________________________________________________________________________________________
batch_normalization_12 (BatchNo (None, 38, 38, 256)  1024        conv2d_12[0][0]
__________________________________________________________________________________________________
leaky_re_lu_12 (LeakyReLU)      (None, 38, 38, 256)  0           batch_normalization_12[0][0]
__________________________________________________________________________________________________
conv2d_13 (Conv2D)              (None, 38, 38, 512)  1179648     leaky_re_lu_12[0][0]
__________________________________________________________________________________________________
batch_normalization_13 (BatchNo (None, 38, 38, 512)  2048        conv2d_13[0][0]
__________________________________________________________________________________________________
leaky_re_lu_13 (LeakyReLU)      (None, 38, 38, 512)  0           batch_normalization_13[0][0]
__________________________________________________________________________________________________
max_pooling2d_5 (MaxPooling2D)  (None, 19, 19, 512)  0           leaky_re_lu_13[0][0]
__________________________________________________________________________________________________
conv2d_14 (Conv2D)              (None, 19, 19, 1024) 4718592     max_pooling2d_5[0][0]
__________________________________________________________________________________________________
batch_normalization_14 (BatchNo (None, 19, 19, 1024) 4096        conv2d_14[0][0]
__________________________________________________________________________________________________
leaky_re_lu_14 (LeakyReLU)      (None, 19, 19, 1024) 0           batch_normalization_14[0][0]
__________________________________________________________________________________________________
conv2d_15 (Conv2D)              (None, 19, 19, 512)  524288      leaky_re_lu_14[0][0]
__________________________________________________________________________________________________
batch_normalization_15 (BatchNo (None, 19, 19, 512)  2048        conv2d_15[0][0]
__________________________________________________________________________________________________
leaky_re_lu_15 (LeakyReLU)      (None, 19, 19, 512)  0           batch_normalization_15[0][0]
__________________________________________________________________________________________________
conv2d_16 (Conv2D)              (None, 19, 19, 1024) 4718592     leaky_re_lu_15[0][0]
__________________________________________________________________________________________________
batch_normalization_16 (BatchNo (None, 19, 19, 1024) 4096        conv2d_16[0][0]
__________________________________________________________________________________________________
leaky_re_lu_16 (LeakyReLU)      (None, 19, 19, 1024) 0           batch_normalization_16[0][0]
__________________________________________________________________________________________________
conv2d_17 (Conv2D)              (None, 19, 19, 512)  524288      leaky_re_lu_16[0][0]
__________________________________________________________________________________________________
batch_normalization_17 (BatchNo (None, 19, 19, 512)  2048        conv2d_17[0][0]
__________________________________________________________________________________________________
leaky_re_lu_17 (LeakyReLU)      (None, 19, 19, 512)  0           batch_normalization_17[0][0]
__________________________________________________________________________________________________
conv2d_18 (Conv2D)              (None, 19, 19, 1024) 4718592     leaky_re_lu_17[0][0]
__________________________________________________________________________________________________
batch_normalization_18 (BatchNo (None, 19, 19, 1024) 4096        conv2d_18[0][0]
__________________________________________________________________________________________________
leaky_re_lu_18 (LeakyReLU)      (None, 19, 19, 1024) 0           batch_normalization_18[0][0]
__________________________________________________________________________________________________
conv2d_19 (Conv2D)              (None, 19, 19, 1024) 9437184     leaky_re_lu_18[0][0]
__________________________________________________________________________________________________
batch_normalization_19 (BatchNo (None, 19, 19, 1024) 4096        conv2d_19[0][0]
__________________________________________________________________________________________________
conv2d_21 (Conv2D)              (None, 38, 38, 64)   32768       leaky_re_lu_13[0][0]
__________________________________________________________________________________________________
leaky_re_lu_19 (LeakyReLU)      (None, 19, 19, 1024) 0           batch_normalization_19[0][0]
__________________________________________________________________________________________________
batch_normalization_21 (BatchNo (None, 38, 38, 64)   256         conv2d_21[0][0]
__________________________________________________________________________________________________
conv2d_20 (Conv2D)              (None, 19, 19, 1024) 9437184     leaky_re_lu_19[0][0]
__________________________________________________________________________________________________
leaky_re_lu_21 (LeakyReLU)      (None, 38, 38, 64)   0           batch_normalization_21[0][0]
__________________________________________________________________________________________________
batch_normalization_20 (BatchNo (None, 19, 19, 1024) 4096        conv2d_20[0][0]
__________________________________________________________________________________________________
space_to_depth_x2 (Lambda)      (None, 19, 19, 256)  0           leaky_re_lu_21[0][0]
__________________________________________________________________________________________________
leaky_re_lu_20 (LeakyReLU)      (None, 19, 19, 1024) 0           batch_normalization_20[0][0]
__________________________________________________________________________________________________
concatenate_1 (Concatenate)     (None, 19, 19, 1280) 0           space_to_depth_x2[0][0]
                                                                 leaky_re_lu_20[0][0]
__________________________________________________________________________________________________
conv2d_22 (Conv2D)              (None, 19, 19, 1024) 11796480    concatenate_1[0][0]
__________________________________________________________________________________________________
batch_normalization_22 (BatchNo (None, 19, 19, 1024) 4096        conv2d_22[0][0]
__________________________________________________________________________________________________
leaky_re_lu_22 (LeakyReLU)      (None, 19, 19, 1024) 0           batch_normalization_22[0][0]
__________________________________________________________________________________________________
conv2d_23 (Conv2D)              (None, 19, 19, 425)  435625      leaky_re_lu_22[0][0]
==================================================================================================
Total params: 50,983,561
Trainable params: 50,962,889
Non-trainable params: 20,672
__________________________________________________________________________________________________

注意：在某些计算机上，你可能会看到Keras发出的警告消息。如果你按要求做，就不必担心。

提示：此模型将经过预处理的一批输入图像（形状：( m , 608 , 608 , 3 ) (m,608,608,3)(m ,608 ,608 ,3 )）转换为形状为( m , 19 , 19 , 5 , 85 ) (m,19,19,5,85)(m ,19 ,19 ,5 ,85 )的张量，如图（2）所示 ）。

3.3 将模型的输出转换为可用的边界框张量

yolo_model的输出是( m , 19 , 19 , 5 , 850 (m,19,19,5,850 (m ,19 ,19 ,5 ,850张量，需要通过非特殊的处理和转换。以下单元格为你完成了该操作。

yolo_outputs = yolo_head(yolo_model.output, anchors, len(class_names))

你在图表中添加了 yolo_outputs，这4个张量准备用于 yolo_eval函数的输入。

3.4 筛选框

yolo_outputs以正确的格式为你提供了 yolo_model的所有预测框，现在，你可以执行筛选并选择最佳框。让我们调用你先前实现的 yolo_eval来执行此操作。

scores, boxes, classes = yolo_eval(yolo_outputs, image_shape)

3.5 运行计算图

你已经创建了一个（ sess）图，可以将其总结如下：

1. yolo_model.input输入 yolo_model。计算输出 yolo_model.output
2. yolo_model.output由 yolo_head处理。输出 yolo_outputs
3. yolo_outputs通过过滤函数 yolo_eval。输出预测结果：分数，框，类

练习：实现 predict()，运行计算图以在图像上测试YOLO模型。

你将需要运行一个TensorFlow会话，用其计算 scores, boxes, classes。

下面的代码还使用以下函数：

image, image_data = preprocess_image("images/" + image_file, model_image_size = (608, 608))

输出：

• 图片：用于绘图框的图片的python（PIL）表示形式，你不需要使用它。
• image_data：表示图像的numpy数组，也是CNN的输入。

重要提示：当模型使用BatchNorm（如YOLO中的情况）时，你需要在feed_dict {K.learning_phase（）：0}中传递一个附加的占位符。

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))

    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

我们来实际预测一下：

out_scores, out_boxes, out_classes = predict(sess, "test.jpg")

在test.jpg中找到了7个锚框。
car 0.60 (925, 285) (1045, 374)
bus 0.67 (5, 267) (220, 407)
car 0.68 (705, 279) (786, 351)
car 0.70 (947, 324) (1280, 704)
car 0.75 (159, 303) (346, 440)
car 0.80 (762, 282) (942, 412)
car 0.89 (366, 299) (745, 648)

刚刚运行的模型实际上可以检测”coco_classes.txt”中列出的80个不同的类。要在自己的图像上测试模型：

1. 单击此笔记本上部栏中的”File”，然后单击”Open”以在Coursera Hub上运行。
2. 将图像添加到Jupyter Notebook的目录中，在”images”文件夹中
3. 在代码上方的单元格中输入图像的名称
4. 运行代码，查看算法输出！

如果要在for循环中运行所有图像的会话。 这是你将得到的：

for i in range(1,121):

    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("绘制完成！")

当前文件：0001.jpg
当前文件：0002.jpg
当前文件：0003.jpg
car 0.69 (347, 289) (445, 321)
car 0.70 (230, 307) (318, 354)
car 0.73 (671, 284) (770, 315)
当前文件：0004.jpg
car 0.63 (400, 285) (514, 327)
car 0.66 (95, 297) (227, 342)
car 0.68 (1, 321) (121, 410)
car 0.73 (539, 277) (659, 318)
当前文件：0005.jpg
car 0.64 (207, 297) (338, 340)
car 0.64 (741, 266) (918, 313)
car 0.67 (15, 313) (128, 362)
car 0.72 (883, 260) (1026, 303)
car 0.76 (518, 282) (689, 336)
当前文件：0006.jpg
car 0.72 (72, 320) (220, 367)
car 0.72 (470, 286) (687, 343)
当前文件：0007.jpg
car 0.67 (1087, 243) (1226, 312)
car 0.78 (468, 292) (685, 353)
当前文件：0008.jpg
truck 0.63 (852, 252) (1084, 330)
car 0.78 (1083, 275) (1276, 340)
当前文件：0009.jpg
当前文件：0010.jpg
truck 0.66 (736, 266) (1053, 368)
当前文件：0011.jpg
truck 0.73 (727, 269) (1054, 376)
car 0.85 (6, 336) (211, 457)
当前文件：0012.jpg
car 0.77 (792, 279) (1163, 408)
car 0.87 (539, 330) (998, 460)
当前文件：0013.jpg
truck 0.65 (718, 275) (1053, 385)
当前文件：0014.jpg
truck 0.65 (716, 274) (1056, 385)
当前文件：0015.jpg
truck 0.72 (714, 275) (1086, 387)
当前文件：0016.jpg
truck 0.64 (710, 276) (1106, 388)
当前文件：0017.jpg
truck 0.65 (665, 273) (1063, 393)
car 0.79 (1103, 300) (1271, 356)
car 0.82 (1, 358) (184, 427)
当前文件：0018.jpg
car 0.77 (71, 362) (242, 419)
car 0.77 (340, 339) (554, 401)
当前文件：0019.jpg
truck 0.64 (713, 280) (1052, 390)
car 0.85 (16, 377) (450, 559)
当前文件：0020.jpg
truck 0.75 (538, 286) (926, 413)
当前文件：0021.jpg
car 0.64 (691, 292) (914, 403)
truck 0.72 (88, 317) (493, 450)
当前文件：0022.jpg
car 0.66 (895, 302) (980, 347)
car 0.79 (751, 318) (879, 370)
当前文件：0023.jpg
当前文件：0024.jpg
当前文件：0025.jpg
car 0.65 (664, 296) (705, 321)
当前文件：0026.jpg
当前文件：0027.jpg
当前文件：0028.jpg
car 0.73 (711, 303) (792, 369)
当前文件：0029.jpg
truck 0.63 (698, 282) (781, 336)
当前文件：0030.jpg
当前文件：0031.jpg
car 0.68 (187, 317) (314, 409)
当前文件：0032.jpg
当前文件：0033.jpg
car 0.62 (900, 279) (963, 306)
当前文件：0034.jpg
traffic light 0.61 (200, 108) (228, 170)
car 0.71 (179, 327) (313, 424)
当前文件：0035.jpg
car 0.63 (1083, 278) (1194, 319)
当前文件：0036.jpg
car 0.66 (211, 314) (349, 402)
car 0.73 (1014, 274) (1201, 338)
当前文件：0037.jpg
car 0.64 (326, 302) (419, 365)
当前文件：0038.jpg
当前文件：0039.jpg
car 0.66 (313, 301) (398, 364)
当前文件：0040.jpg
car 0.63 (330, 299) (415, 363)
当前文件：0041.jpg
car 0.65 (340, 294) (415, 367)
当前文件：0042.jpg
当前文件：0043.jpg
car 0.77 (118, 312) (237, 384)
当前文件：0044.jpg
car 0.61 (551, 282) (624, 329)
当前文件：0045.jpg
traffic light 0.70 (383, 40) (416, 101)
traffic light 0.73 (569, 32) (604, 102)
当前文件：0046.jpg
当前文件：0047.jpg
当前文件：0048.jpg
当前文件：0049.jpg
当前文件：0050.jpg
当前文件：0051.jpg
car 0.68 (151, 323) (247, 379)
traffic light 0.73 (500, 79) (532, 138)
当前文件：0052.jpg
当前文件：0053.jpg
当前文件：0054.jpg
car 0.63 (726, 293) (800, 353)
car 0.72 (786, 293) (941, 410)
当前文件：0055.jpg
car 0.73 (758, 277) (904, 388)
当前文件：0056.jpg
当前文件：0057.jpg
当前文件：0058.jpg
当前文件：0059.jpg
car 0.77 (0, 306) (257, 464)
car 0.82 (570, 277) (864, 417)
car 0.86 (85, 319) (526, 493)
当前文件：0060.jpg
当前文件：0061.jpg
当前文件：0062.jpg
当前文件：0063.jpg
当前文件：0064.jpg
当前文件：0065.jpg
car 0.69 (380, 270) (462, 324)
当前文件：0066.jpg
traffic light 0.62 (532, 68) (564, 113)
car 0.77 (372, 281) (454, 333)
当前文件：0067.jpg
traffic light 0.64 (535, 60) (569, 105)
car 0.69 (369, 281) (454, 345)
当前文件：0068.jpg
traffic light 0.64 (536, 60) (572, 108)
traffic light 0.65 (379, 87) (406, 147)
car 0.65 (367, 288) (450, 349)
当前文件：0069.jpg
traffic light 0.61 (537, 62) (577, 109)
car 0.62 (367, 289) (450, 346)
traffic light 0.63 (379, 87) (408, 148)
当前文件：0070.jpg
car 0.65 (369, 291) (452, 354)
当前文件：0071.jpg
truck 0.69 (88, 288) (569, 450)
当前文件：0072.jpg
traffic light 0.60 (535, 65) (572, 111)
car 0.62 (291, 301) (357, 351)
traffic light 0.63 (377, 91) (406, 149)
truck 0.64 (1049, 263) (1280, 399)
car 0.64 (0, 331) (84, 449)
car 0.66 (368, 292) (450, 357)
当前文件：0073.jpg
car 0.74 (145, 313) (248, 374)
car 0.86 (503, 299) (858, 422)
当前文件：0074.jpg
car 0.62 (365, 294) (450, 346)
car 0.87 (31, 319) (424, 485)
当前文件：0075.jpg
car 0.75 (151, 315) (246, 372)
当前文件：0076.jpg
traffic light 0.62 (381, 93) (407, 146)
car 0.66 (245, 298) (336, 366)
car 0.70 (368, 292) (451, 357)
car 0.75 (150, 313) (245, 375)
当前文件：0077.jpg
traffic light 0.60 (536, 65) (571, 112)
traffic light 0.60 (380, 92) (408, 148)
car 0.70 (243, 295) (345, 368)
car 0.71 (368, 292) (450, 357)
car 0.75 (150, 314) (245, 374)
当前文件：0078.jpg
traffic light 0.62 (380, 91) (407, 147)
car 0.65 (367, 293) (453, 353)
car 0.70 (242, 295) (339, 367)
car 0.75 (151, 314) (245, 373)
当前文件：0079.jpg
traffic light 0.61 (378, 92) (406, 148)
traffic light 0.61 (535, 65) (571, 111)
car 0.73 (235, 298) (326, 367)
car 0.76 (151, 314) (243, 373)
当前文件：0080.jpg
traffic light 0.61 (379, 92) (407, 147)
car 0.64 (5, 309) (188, 416)
car 0.72 (238, 298) (324, 366)
car 0.79 (714, 282) (916, 362)
当前文件：0081.jpg
car 0.68 (187, 309) (301, 381)
car 0.77 (612, 293) (722, 353)
car 0.79 (25, 328) (141, 398)
当前文件：0082.jpg
traffic light 0.61 (380, 92) (408, 147)
car 0.62 (585, 287) (661, 335)
car 0.71 (410, 282) (609, 388)
当前文件：0083.jpg
traffic light 0.63 (380, 91) (407, 148)
car 0.64 (0, 328) (82, 447)
car 0.73 (609, 280) (888, 397)
当前文件：0084.jpg
traffic light 0.62 (378, 91) (406, 150)
car 0.70 (989, 272) (1270, 381)
当前文件：0085.jpg
traffic light 0.61 (378, 92) (406, 149)
traffic light 0.61 (535, 64) (571, 115)
当前文件：0086.jpg
traffic light 0.60 (377, 92) (407, 151)
traffic light 0.61 (536, 65) (572, 113)
当前文件：0087.jpg
truck 0.61 (0, 315) (94, 404)
traffic light 0.61 (536, 65) (572, 112)
traffic light 0.61 (381, 92) (410, 149)
当前文件：0088.jpg
traffic light 0.62 (378, 91) (406, 151)
当前文件：0089.jpg
当前文件：0090.jpg
当前文件：0091.jpg
traffic light 0.71 (300, 76) (333, 159)
当前文件：0092.jpg
traffic light 0.62 (232, 25) (266, 96)
当前文件：0093.jpg
car 0.60 (361, 313) (414, 341)
当前文件：0094.jpg
当前文件：0095.jpg
当前文件：0096.jpg
car 0.68 (202, 319) (301, 369)
当前文件：0097.jpg
car 0.69 (74, 330) (188, 395)
car 0.70 (235, 315) (336, 375)
当前文件：0098.jpg
car 0.60 (747, 289) (811, 356)
car 0.64 (836, 291) (967, 406)
car 0.81 (898, 315) (1113, 452)
当前文件：0099.jpg
car 0.75 (1046, 352) (1280, 608)
car 0.78 (859, 316) (971, 427)
car 0.86 (922, 336) (1120, 476)
当前文件：0100.jpg
当前文件：0101.jpg
当前文件：0102.jpg
bus 0.79 (180, 259) (304, 362)
当前文件：0103.jpg
bus 0.75 (0, 286) (203, 420)
当前文件：0104.jpg
traffic light 0.61 (241, 24) (273, 97)
truck 0.82 (0, 223) (291, 421)
当前文件：0105.jpg
当前文件：0106.jpg
car 0.62 (1200, 287) (1276, 432)
当前文件：0107.jpg
car 0.61 (376, 309) (421, 335)
当前文件：0108.jpg
当前文件：0109.jpg
当前文件：0110.jpg
当前文件：0111.jpg
car 0.61 (97, 322) (180, 366)
fire hydrant 0.64 (1177, 374) (1237, 483)
当前文件：0112.jpg
当前文件：0113.jpg
当前文件：0114.jpg
当前文件：0115.jpg
当前文件：0116.jpg
traffic light 0.63 (522, 76) (543, 113)
car 0.80 (5, 271) (241, 671)
当前文件：0117.jpg
当前文件：0118.jpg
当前文件：0119.jpg
traffic light 0.61 (1056, 0) (1138, 131)
当前文件：0120.jpg
绘制完成！

你应该记住：

• YOLO是一种快速而准确的最新的目标检测模型
• 通过运行CNN输入图像，该CNN输出19 × 19 × 5 × 85 19 \times 19 \times 5 \times 85 19 ×19 ×5 ×85维度的体积。
• 可以将编码视为一个网格，其中19 × 19 19 \times 19 19 ×19$单元格中的每个单元格包含5个框的信息。
• 使用非极大值抑制功能过滤所有框，其中：
• 对检测到的框的类的概率进行分数阈值化
• 交并比（IoU）阈值处理，以消除重叠的框
• 因为从随机初始化的权重训练YOLO模型是不容易的，并且需要大量数据集以及大量计算，所以在此练习中我们使用了先前训练的模型参数。

如果你愿意，你也可以尝试使用自己的数据集对YOLO模型进行微调，尽管这不是一件容易的事。

Original: https://blog.csdn.net/qq_41476257/article/details/125884327
Author: Puzzle harvester
Title: Python吴恩达深度学习作业15 — YOLO原理及应用（自动驾驶——汽车检测）