吴恩达深度学习_4_Week3目标检测

自动驾驶—目标检测

---

1、问题描述
2、YOLO
3、在图像上测试训练YOLO

---

第四门课：卷积神经网络
第三周：目标检测

您将学习使用非常强大的YOLO模型进行目标检测。本笔记本中的许多思想都在两篇YOLO论文中有所描述：Redmon等人，2016年（https://arxiv.org/abs/1506.02640）和Redmon与Farhadi，2016年（https://arxiv.org/abs/1612.08242）。
您将学习以下内容：
1、在一个汽车检测数据集上使用目标检测
2、处理边界框

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 yolo_utils import read_classes, read_anchors, generate_colors, preprocess_image, draw_boxes, scale_boxes
from yad2k.models.keras_yolo import yolo_head, yolo_boxes_to_corners, preprocess_true_boxes, yolo_loss, yolo_body

重要提示：正如您所见，将Keras的后端导入为K。这意味着在本任务使用Keras函数时，需要编写：K.function(…)。

一、问题描述

您正在开发一辆自动驾驶汽车。作为该项目的关键组成部分，您希望首先构建一个汽车检测系统。为了收集数据，您将摄像头安装在汽车的引擎盖上（即前部），在驾驶时每隔几秒拍摄前方道路的照片。
特别感谢drive.ai提供这个数据集！Drive.ai是一家开发自动驾驶车辆智能的公司。

将所有这些图像收集到一个文件夹中，并通过在每辆汽车周围绘制边界框来对它们进行标记。以上是边界框的示例。
如果您希望YOLO识别80个类别，可以将类别标签𝑐表示为1到80之间的整数，或者表示为80维向量（包含80个数字），其中一个分量为1，其余分量为0。视频讲座使用了后一种表示法；在本笔记本中，我们将根据特定步骤的方便性使用这两种表示法。
在这个练习中，您将学习YOLO的工作原理，并将其应用于汽车检测。由于YOLO模型的训练计算成本非常高，我们将为您加载预训练的权重供您使用。

二、YOLO

YOLO（“you only look once”）是一种流行的算法，因为它在实时情况下能够实现高精度。该算法在图像上“仅看一次”，这意味着它只需要一次前向传播通过网络进行预测。在非极大值抑制之后，它输出识别的对象以及边界框。

1、模型详细信息

首先需要了解的事项：
1、输入是形状为(m, 608, 608, 3)的图像批次
2、输出是一系列边界框以及识别的类别。每个边界框由6个数字 (𝑝𝑐,𝑏𝑥,𝑏𝑦,𝑏ℎ,𝑏𝑤,𝑐) 表示，如上所述。如果将𝑐扩展为80维向量，则每个边界框将由85个数字表示。
我们将使用5个锚框（anchor boxes）。因此，您可以将YOLO架构视为以下内容：图像 (m, 608, 608, 3) -> 深度卷积神经网络 -> 编码 (m, 19, 19, 5, 85)。
让我们更详细地看一下这个编码表示的内容。

如果对象的中心/中点位于一个网格单元中，则该网格单元负责检测该对象。
由于我们使用了5个锚框（anchor boxes），因此每个19x19的单元格都编码了有关5个框的信息。锚框仅由其宽度和高度定义。
为了简化起见，我们将压缩形状（19, 19, 5, 85）编码的最后两个维度。因此，深度卷积神经网络的输出为（19, 19, 425）。

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

以下是一种可视化YOLO在图像上的预测的方式：
1、对于每个19x19的网格单元，找到概率分数的最大值（在5个锚框和不同类别之间取最大值）。
2、根据网格单元认为最有可能的对象，对该网格单元进行着色。
这样做会得到下面这张图片：

请注意，这种可视化并不是YOLO算法本身用于进行预测的核心部分；它只是一种演示算法中间结果的好方法。
另一种可视化YOLO输出的方式是绘制边界框。这样做会得到如下的可视化结果：

图6：每个单元格给出5个框。总共，模型通过一次对图像的前向传播就预测出了19x19x5 = 1805个框！不同的颜色代表不同的类别。
在上面的图中，我们仅绘制了模型分配高概率的框，但这仍然是太多的框。您希望将算法的输出筛选为数量更少的检测到的对象。为此，您将使用非最大值抑制。具体而言，您将执行以下步骤：
1、去除得分较低的框（表示框对于检测某个类别的信心不太高）
2、当多个框重叠并检测到相同对象时，只选择一个框

2、根据类别分数进行阈值过滤

首先通过阈值过滤应用第一个筛选条件。希望去除类别“分数”低于所选阈值的任何框。
模型给出了一共19x19x5x85个数字，每个框由85个数字描述。将（19,19,5,85）（或（19,19,425））维的张量重新排列为以下变量会很方便：
1、box_confidence：形状为（19×19,5,1）的张量，每个19x19单元格中的5个预测框的 𝑝𝑐（某个对象存在的置信概率）。
2、boxes：形状为（19×19,5,4）的张量，每个单元格中的5个框的 （𝑏𝑥,𝑏𝑦,𝑏ℎ,𝑏𝑤）。
3、box_class_probs：形状为（19×19,5,80）的张量，每个单元格中的5个框的每个80类别的检测概率 （𝑐1,𝑐2,…𝑐80）。

练习：实现yolo_filter_boxes()。
1、通过如图4所述的元素级乘法计算框得分。以下代码可能有助于选择正确的运算符：
a = np.random.randn(1919, 5, 1)
b = np.random.randn(1919, 5, 80)
c = a * b # c的形状将为（19*19, 5, 80）
2、对于每个框，找到：
具有最大框得分的类别的索引（提示）（注意选择的轴；考虑使用axis=-1）
相应的框得分（提示）（注意选择的轴；考虑使用axis=-1）
3、使用阈值创建一个掩码。作为提醒：([0.9, 0.3, 0.4, 0.5, 0.1] < 0.4) 返回：[False, True, False, False, True]。掩码应该为True，表示要保留的框。
4、使用TensorFlow将掩码应用于box_class_scores、boxes和box_classes，以过滤掉我们不想要的框。您应该只剩下您想保留的框的子集。（提示）
提醒：要调用Keras函数，您应该使用K.function(…)。

通过对对象和类别置信度进行阈值过滤，对YOLO框进行筛选。
参数：
box_confidence -- 形状为（19, 19, 5, 1）的张量
boxes -- 形状为（19, 19, 5, 4）的张量
box_class_probs -- 形状为（19, 19, 5, 80）的张量
threshold -- 实数，如果[最高类别概率得分 < 阈值]，则去除对应的框
返回：
scores -- 形状为（None,）的张量，包含所选框的类别概率得分
boxes -- 形状为（None, 4）的张量，包含所选框的（b_x, b_y, b_h, b_w）坐标
classes -- 形状为（None,）的张量，包含所选框检测到的类别的索引
注意：“None”是因为您不知道所选框的确切数量，因为它取决于阈值。
例如，如果有10个框，则得分的实际输出大小将为（10,）。

# GRADED FUNCTION: yolo_filter_boxes
def yolo_filter_boxes(box_confidence, boxes, box_class_probs, threshold = .6):
    
    # Step 1: Compute box scores
    box_scores = box_confidence * box_class_probs

    # Step 2: Find the box_classes thanks to the max box_scores, keep track of the corresponding score
    box_classes = K.argmax(box_scores, axis=-1)
    box_class_scores = K.max(box_scores, axis=-1, keepdims=False)
    
    # Step 3: Create a filtering mask based on "box_class_scores" by using "threshold". The mask should have the
    # same dimension as box_class_scores, and be True for the boxes you want to keep (with probability >= threshold)
    filtering_mask = box_class_scores >= threshold
    
    # Step 4: Apply the mask to scores, boxes and 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

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

输出结果：
classes[2]=7
scores.shape=(?,)
boxes.shape=(?, 4)
classes.shape=(?,)
scores[2]=10.7506
boxes[2]=[ 8.42653275 3.27136683 -0.5313437 -4.94137383]

3、非最大值抑制

即使通过对类别分数进行阈值过滤，仍然会出现很多重叠的框。选择正确框的第二个过滤器称为非最大值抑制（NMS）。

图7：在这个例子中，模型预测了3辆汽车，但实际上是对同一辆汽车的3个预测。运行非最大值抑制（NMS）将只选择3个框中最准确（概率最高）的一个。
非最大值抑制使用了一个非常重要的函数，称为“交并比”（Intersection over Union，IoU）

练习：实现iou()函数。一些提示：
1、在这个练习中，我们使用两个角（左上角和右下角）来定义一个框：(x1, y1, x2, y2)，而不是使用中点和高度/宽度来定义。
2、计算矩形的面积需要将其高度（y2 - y1）乘以其宽度（x2 - x1）。
3、您还需要找到两个框相交的坐标（xi1, yi1, xi2, yi2）。请记住：
xi1 = 两个框的x1坐标的最大值
yi1 = 两个框的y1坐标的最大值
xi2 = 两个框的x2坐标的最小值
yi2 = 两个框的y2坐标的最小值
在这段代码中，我们使用的约定是（0,0）是图像的左上角，（1,0）是右上角，（1,1）是右下角。

实现框1和框2之间的交并比（IoU）
参数：
box1 -- 第一个框，具有坐标（x1，y1，x2，y2）的列表对象
box2 -- 第二个框，具有坐标（x1，y1，x2，y2）的列表对象

# GRADED FUNCTION: iou
def iou(box1, box2):
    # Calculate the (y1, x1, y2, x2) coordinates of the intersection of box1 and box2. Calculate its Area.
    xi1 = max(box1[0], box2[0])
    yi1 = max(box1[1], box2[1])
    xi2 = min(box1[2], box2[2])
    yi2 = min(box1[3], box2[3])
    inter_area = (xi2 - xi1) * (yi2 - yi1)

    # Calculate the Union area by using Formula: 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
    
    # compute the IoU
    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()

对一组框应用非最大值抑制（NMS）
参数：
scores -- 形状为（None,）的张量，yolo_filter_boxes()的输出
boxes -- 形状为（None, 4）的张量，经过缩放到图像大小的yolo_filter_boxes()的输出（稍后解释）
classes -- 形状为（None,）的张量，yolo_filter_boxes()的输出
max_boxes -- 整数，期望的最大预测框数
iou_threshold -- 实数，“交并比”阈值，用于NMS过滤
返回：
scores -- 形状为（，None）的张量，每个框的预测得分
boxes -- 形状为（4, None）的张量，预测框的坐标
classes -- 形状为（，None）的张量，每个框的预测类别
注意：输出张量的“None”维度显然需要小于max_boxes。还请注意，该函数会转置得分、框和类别的形状，这是为了方便

# GRADED FUNCTION: yolo_non_max_suppression
def yolo_non_max_suppression(scores, boxes, classes, max_boxes = 10, iou_threshold = 0.5):
    max_boxes_tensor = K.variable(max_boxes, dtype='int32')     # tensor to be used in tf.image.non_max_suppression()
    K.get_session().run(tf.variables_initializer([max_boxes_tensor])) # initialize variable max_boxes_tensor
    
    # Use tf.image.non_max_suppression() to get the list of indices corresponding to boxes you keep
    nms_indices = tf.image.non_max_suppression(boxes, scores, max_boxes, iou_threshold, name=None)
    
    # Use K.gather() to select only nms_indices from scores, boxes and classes
    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))

输出：
classes[2]= -2.24527
scores.shape= (10,)
boxes.shape= (10, 4)
classes.shape=(10,)
scores[2]=6.9384
boxes[2]=[-5.299932 3.13798141 4.45036697 0.95942086]

4、完成过滤

现在是时候实现一个函数，接受深度CNN的输出（19x19x5x85维编码）并使用您刚刚实现的函数对所有框进行过滤了。

练习：实现yolo_eval()函数，它接受YOLO编码的输出，并使用得分阈值和NMS对框进行过滤。还有一个最后的实现细节需要了解。有几种表示框的方式，例如通过它们的角或者通过它们的中点和高度/宽度。YOLO在不同的时间段使用以下函数在几种不同的格式之间进行转换（我们已经提供了这些函数）：boxes = yolo_boxes_to_corners(box_xy, box_wh)
将YOLO框坐标（x，y，w，h）转换为框角的坐标（x1，y1，x2，y2），以适应yolo_filter_boxes的输入。
boxes = scale_boxes(boxes, image_shape)
YOLO的网络是在608x608的图像上训练的。如果您要在不同大小的图像上测试这些数据，例如汽车检测数据集使用的是720x1280的图像，这一步将重新调整框的大小，以便可以在原始的720x1280图像上绘制。
不用担心这两个函数；我们会告诉您它们需要被调用的位置。

将YOLO编码的输出（很多框）转换为预测框，包括它们的得分、框坐标和类别。
参数：
yolo_outputs -- 编码模型的输出（对于图像形状为（608, 608, 3）），包含4个张量：
box_confidence：形状为（None, 19, 19, 5, 1）的张量
box_xy：形状为（None, 19, 19, 5, 2）的张量
box_wh：形状为（None, 19, 19, 5, 2）的张量
box_class_probs：形状为（None, 19, 19, 5, 80）的张量
image_shape -- 形状为（2，）的张量，包含输入形状，在本笔记本中我们使用（608.， 608.）（必须是float32 dtype）
max_boxes -- 整数，期望的最大预测框数
score_threshold -- 实数，如果[最高类别概率得分<阈值]，则去除相应的框
iou_threshold -- 实数，“交并比”阈值，用于NMS过滤
返回：
scores -- 形状为（None，）的张量，每个框的预测得分
boxes -- 形状为（None，4）的张量，预测框的坐标
classes -- 形状为（None，）的张量，每个框的预测类别

# GRADED FUNCTION: yolo_eval
def yolo_eval(yolo_outputs, image_shape = (720., 1280.), max_boxes=10, score_threshold=.6, iou_threshold=.5):
 
    # Retrieve outputs of the YOLO model (≈1 line)
    box_confidence, box_xy, box_wh, box_class_probs = yolo_outputs
    # Convert boxes to be ready for filtering functions
    boxes = yolo_boxes_to_corners(box_xy, box_wh) 
    # Use one of the functions you've implemented to perform Score-filtering with a threshold of score_threshold (≈1 line)
    scores, boxes, classes = yolo_filter_boxes(box_confidence, boxes, box_class_probs, score_threshold)
    # Scale boxes back to original image shape.
    boxes = scale_boxes(boxes, image_shape)
    
    # Use one of the functions you've implemented to perform Non-max suppression with a threshold of iou_threshold (≈1 line)
    scores, boxes, classes = yolo_non_max_suppression(scores, boxes, classes, max_boxes, iou_threshold)
    
    return scores, boxes, classes
    
with tf.Session() as test_b:
    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))

输出：
classes[2]=54
scores.shape= (10,)
boxes.shape=(10, 4)
classes.shape=(10,)
scores[2]=138.791
boxes[2]=[ 1292.32971191 -278.52166748 3876.98925781 -835.56494141]

YOLO摘要：
1、输入图像大小为（608，608，3）
2、输入图像经过CNN处理，得到（19，19，5，85）维度的输出。
3、将最后两个维度展平后，输出是一个形状为（19，19，425）的张量：19x19网格中的每个单元格给出425个数字。
4、425 = 5 x 85，因为每个单元格包含对应于5个锚框的预测，如讲座中所见。
5、85 = 5 + 80，其中5是因为（𝑝𝑐,𝑏𝑥,𝑏𝑦,𝑏ℎ,𝑏𝑤）有5个数字，80是我们希望检测的类别数。
6、然后，根据以下几个条件仅选择少数框：
通过得分阈值筛选：丢弃检测到得分低于阈值的类别的框。
非最大值抑制：计算交并比，避免选择重叠的框。
7、这就是YOLO的最终输出。

三、 在图像上测试预训练的YOLO模型

在这部分中，您将使用预训练模型并在汽车检测数据集上进行测试。像往常一样，首先创建一个会话来启动图形。

sess = K.get_session()

1、定义类别、锚框和图像形状

回忆一下，我们试图检测80个类别，并使用5个锚框。我们已经在两个文件 “coco_classes.txt” 和 “yolo_anchors.txt” 中收集了关于80个类别和5个锚框的信息。让我们通过运行下一个单元格将这些量加载到模型中。
汽车检测数据集的图像大小为720x1280，我们对其进行了预处理，变为608x608的图像。

class_names = read_classes("model_data/coco_classes.txt")
anchors = read_anchors("model_data/yolo_anchors.txt")
image_shape = (720., 1280.)    

2、加载预训练模型

训练一个YOLO模型需要很长时间，并且需要一个相当大的带有标记边界框的数据集，用于许多目标类别。您将加载一个现有的预训练的Keras YOLO模型，存储在 “yolo.h5” 文件中。（这些权重来自官方YOLO网站，并使用Allan Zelener编写的函数进行了转换。参考资料在本笔记本的末尾。从技术上讲，这些是"YOLOv2"模型的参数，但在本笔记本中我们将更简单地将其称为"YOLO"。）运行下面的单元格以从该文件中加载模型。

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

# 这将加载已经训练好的YOLO模型的权重。以下是模型包含的层的摘要。
yolo_model.summary()

注意：在某些计算机上，您可能会看到来自Keras的警告消息。如果有的话，不用担心，这是正常的。
提醒：此模型将经过预处理的输入图像批次（形状：(m, 608, 608, 3)）转换为形状为(m, 19, 19, 5, 85)的张量，如图2所述。

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

yolo_model的输出是一个形状为(m, 19, 19, 5, 85)的张量，需要经过非平凡的处理和转换。

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

将yolo_outputs添加到图形中。这组4个张量已准备好作为yolo_eval函数的输入使用。

4、过滤边界框

yolo_outputs给出了yolo_model的所有预测边界框，并以正确的格式呈现。现在，您可以进行过滤并仅选择最佳的边界框。现在调用之前实现的yolo_eval函数来完成这个任务。

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

5、在图像上运行图片

让乐趣开始吧。已经创建了一个（sess）图形，可以总结如下：
1、将yolo_model.input提供给yolo_model。模型用于计算输出yolo_model.output
2、yolo_model.output通过yolo_head进行处理。它给出了yolo_outputs
3、yolo_outputs通过过滤函数yolo_eval进行处理。它输出了预测结果：scores、boxes、classes

练习：实现predict()函数，它在图像上运行图形以测试YOLO。您需要运行一个TensorFlow会话，以便让它计算scores、boxes和classes。
以下代码还使用了以下函数：
image, image_data = preprocess_image(“images/” + image_file, model_image_size = (608, 608))
它的输出为：
1、image：图像的Python（PIL）表示，用于绘制边界框。您不需要使用它。
2、image_data：表示图像的NumPy数组。这将作为CNN的输入。

重要提示：当一个模型使用BatchNorm（如YOLO）时，您需要在feed_dict中传递一个额外的占位符 {K.learning_phase(): 0}。

运行存储在 "sess" 中的图形，对 "image_file" 进行预测边界框。打印并绘制预测结果。
参数：
sess -- 包含YOLO图形的tensorflow/Keras会话
image_file -- 存储在 "images" 文件夹中的图像的名称。
返回：
out_scores -- 形状为(None, )的张量，预测边界框的分数
out_boxes -- 形状为(None, 4)的张量，预测边界框的坐标
out_classes -- 形状为(None, )的张量，预测边界框的类别索引
注意："None"实际上表示预测边界框的数量，它在0和max_boxes之间变化。

def predict(sess, image_file):
    # Preprocess your image
    image, image_data = preprocess_image("images/" + image_file, model_image_size = (608, 608))

    # Run the session with the correct tensors and choose the correct placeholders in the feed_dict.
    # You'll need to use feed_dict={yolo_model.input: ... , K.learning_phase(): 0})
    out_scores, out_boxes, out_classes = sess.run([scores, boxes, classes], feed_dict = {yolo_model.input:image_data, K.learning_phase(): 0})
    
    # Print predictions info
    print('Found {} boxes for {}'.format(len(out_boxes), image_file))
    # Generate colors for drawing bounding boxes.
    colors = generate_colors(class_names)
    # Draw bounding boxes on the image file
    draw_boxes(image, out_scores, out_boxes, out_classes, class_names, colors)
    # Save the predicted bounding box on the image
    image.save(os.path.join("out", image_file), quality=90)
    # Display the results in the notebook
    output_image = scipy.misc.imread(os.path.join("out", image_file))
    imshow(output_image)
    
    return out_scores, out_boxes, out_classes
# Run the following cell on the "test.jpg" image to verify that your function is correct.
out_scores, out_boxes, out_classes = predict(sess, "test.jpg")

您刚刚运行的模型实际上可以检测到 “coco_classes.txt” 中列出的80个不同类别。
要在自己的图像上测试模型，请按照以下步骤操作：

1. 点击笔记本上方的 “文件”，然后点击 “打开”，进入您的Coursera Hub。
2. 将您的图像添加到此Jupyter笔记本目录中的 “images” 文件夹中。
3. 在上面的代码单元格中写入您的图像名称。
4. 运行代码并查看算法的输出！

记住：

1. List item
2. YOLO是一种先进的目标检测模型，速度快且准确。
3. 它通过一个卷积神经网络将输入图像转化为一个19x19x5x85维的张量。
4. 这个编码可以被看作是一个网格，其中每个19x19的单元格包含关于5个边界框的信息。
5. 通过非极大值抑制，筛选出所有的边界框。具体来说：使用概率阈值对类别检测的概率进行筛选，只保留准确的（高概率）边界框。
6. 使用交并比（IoU）阈值排除重叠的边界框。
7. 由于从随机初始化权重开始训练一个YOLO模型非常困难，并且需要大量的数据集和计算资源，因此在本练习中我们使用了预训练的模型参数。如果你愿意，也可以尝试使用自己的数据集对YOLO模型进行微调，但这需要相当大的困难。

参考文献：本笔记本中提出的思想主要来自两篇关于YOLO的论文。在实现中，我们也得到了Allan Zelener的GitHub仓库的许多启发并使用了其中的组件。本练习中使用的预训练权重来自官方YOLO网站。

1. Joseph Redmon，Santosh Divvala，Ross Girshick，Ali Farhadi - You Only Look Once: Unified, Real-Time Object Detection（2015）
2. Joseph Redmon，Ali Farhadi - YOLO9000: Better, Faster, Stronger（2016）
3. Allan Zelener - YAD2K: Yet Another Darknet 2 Keras
4. 官方YOLO网站（https://pjreddie.com/darknet/yolo/）

车辆检测数据集：知识共享许可证
Drive.ai样本数据集（由drive.ai提供）采用知识共享署名4.0国际许可证。我们特别感谢Brody Huval、Chih Hu和Rahul Patel收集和提供了这个数据集。