【吴恩达课后编程作业】Course 4 - 卷积神经网络 - 第三周作业

 

自己在学习的时候遇到了很多问题，参考了很多大神的代码，发现网上其他的例子大多用的旧版的tensorflow和keras，由于tensorflow与keras都存在新旧版不兼容的情况，代码不能直接拿来用，这里提供一个python=3.8;tensorflow=2.3.0;keras=2.4.3环境下可以运行的代码

过程中遇到的报错：

 “No training configuration found in save file:the model was *not* compiled. Compile it manually”

tensorflow.python.framework.errors_impl.FailedPreconditionError: Error while reading resource variable conv2d_10/kernel from Container: localhost. This could mean that the variable was uninitialized. Not found: Container localhost does not exist. (Could not find resource: localhost/conv2d_10/kernel)

'numpy.dtype[float32]' object has no attribute 'base_dtype'

参考

https://blog.csdn.net/u013733326/article/details/80341740

https://blog.csdn.net/Solo95/article/details/85262828

https://github.com/Dragon-GCS/Python/blob/master/%E5%90%B4%E6%81%A9%E8%BE%BE%E6%B7%B1%E5%BA%A6%E5%AD%A6%E4%B9%A0%E8%AF%BE%E5%90%8E%E4%BD%9C%E4%B8%9A/%E7%AC%AC%E5%9B%9B%E5%91%A8/3_vehicle_identification.py

https://stackoverflow.com/questions/57555407/numpy-dtype-object-has-no-attribute-base-dtype-in-keras

 

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 tensorflow import keras
import keras.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
tf.compat.v1.disable_eager_execution()


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

    # 计算并集，公式为：Union(A,B) = A + B - Inter(A,B)
    box1_area = (box1[0]-box1[2])*(box1[1]-box1[3])
    box2_area = (box2[0]-box2[2])*(box2[1]-box2[3])
    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):
    """
        为锚框实现非最大值抑制（ 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()
    tf.compat.v1.Session().run(tf.compat.v1.variables_initializer([max_boxes_tensor]))#初始化变量max_boxes_tensor

    # 使用使用tf.image.non_max_suppression()来获取与我们保留的框相对应的索引列表
    nms_indices = tf.compat.v1.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_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


def predict(model, image_file, is_show_info=True, is_plot=True):
    """
        运行存储在sess的计算图以预测image_file的边界框，打印出预测的图与信息。
        和网上多数代码区别最大的地方就在这一段，1.把模型的加载移到了函数外部，避免多次加载产生报错；2.对输入数据类型进行了调整

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

    # 预测图像，结果为（1，19，19，425）最后的维度为5个锚框x85个属性
    yolo_model_output = model.predict(image_data)

    # 直接将yolo_model_output输入yolo_head会导致报错，需要用K.constant()对数据类型进行修改
    yolo_outputs = yolo_head(K.constant(yolo_model_output), anchors, len(class_names))
    scores, boxes, classes = yolo_eval(yolo_outputs, image_shape)

    # 打印预测信息
    if is_show_info:
        print("在" + str(image_file) + "中找到了" + str(len(K.get_value(boxes))) + "个锚框。")

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

    # 在图中绘制边界框
    yolo_utils.draw_boxes(image, K.get_value(scores), K.get_value(boxes), K.get_value(classes), class_names, colors)#用K.get_value()规范输入数据的类型

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

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

    return scores, boxes, classes


yolo_model = keras.models.load_model("model_data/yolo.h5")
predict(yolo_model, "test.jpg")



for i in range(1, 121):
    # 计算需要在前面填充几个0
    num_fill = int(len("0000") - len(str(1))) + 1

    # 对索引进行填充
    filename = str(i).zfill(num_fill) + ".jpg"

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

print("绘制完成！")