標(biāo)簽最小尺寸：0x1 標(biāo)簽最大尺寸：704x492

Efficientdet_d0SSD_mobilenet_v2YOLOv3

import tensorflow as tffrom object_detection.utils import label_map_utilfrom object_detection.utils import config_utilfrom object_detection.utils import visualization_utils as viz_utilsfrom object_detection.builders import model_builder
# Load pipeline config and build a detection modelconfigs = config_util.get_configs_from_pipeline_file('/content/efficientdet_d0_coco17_tpu-32/pipeline.config')model_config = configs['model']detection_model = model_builder.build(model_config=model_config, is_training=False)
# Restore checkpointckpt = tf.compat.v2.train.Checkpoint(model=detection_model)ckpt.restore('/content/drive/MyDrive/efficientdet/checkpoints/ckpt-104').expect_partial()
@tf.functiondef detect_fn(image):    """Detect objects in image."""
    image, shapes = detection_model.preprocess(image)    prediction_dict = detection_model.predict(image, shapes)    detections = detection_model.postprocess(prediction_dict, shapes)
    return detections
category_index = label_map_util.create_category_index_from_labelmap('/content/data/label_map.pbtxt',                                                                    use_display_name=True)                                                                 for image_path in IMAGE_PATHS:
    print('Running inference for {}... '.format(image_path), end='')
    image_np = load_image_into_numpy_array(image_path)
    input_tensor = tf.convert_to_tensor(np.expand_dims(image_np, 0), dtype=tf.float32)
    detections = detect_fn(input_tensor)    num_detections = int(detections.pop('num_detections'))    detections = {key: value[0, :num_detections].numpy()                  for key, value in detections.items()}    detections['num_detections'] = num_detections
    # detection_classes should be ints.    detections['detection_classes'] = detections['detection_classes'].astype(np.int64)
    label_id_offset = 1    image_np_with_detections = image_np.copy()
    viz_utils.visualize_boxes_and_labels_on_image_array(            image_np_with_detections,            detections['detection_boxes'],            detections['detection_classes']+label_id_offset,            detections['detection_scores'],            category_index,            use_normalized_coordinates=True,            max_boxes_to_draw=200,            min_score_thresh=.30,            agnostic_mode=False)
    %matplotlib inline    fig = plt.figure(figsize = (10,10))    plt.imshow(image_np_with_detections)    print('Done')    plt.show()

def func(input_file):  classes = ['D00', 'D10', 'D20', 'D40']  alt_names = {'D00': 'lateral_crack', 'D10': 'linear_cracks', 'D20': 'aligator_crakcs', 'D40': 'potholes'}  # initialize a list of colors to represent each possible class label  np.random.seed(42)  COLORS = np.random.randint(0, 255, size=(len(classes), 3),    dtype="uint8")  # derive the paths to the YOLO weights and model configuration  weightsPath = "/content/drive/MyDrive/yolo/yolo-obj_final.weights"  configPath = "/content/yolov3.cfg"  # load our YOLO object detector trained on COCO dataset (80 classes)  # and determine only the *output* layer names that we need from YOLO  #print("[INFO] loading YOLO from disk...")  net = cv2.dnn.readNetFromDarknet(configPath, weightsPath)  ln = net.getLayerNames()  ln = [ln[i[0] - 1] for i in net.getUnconnectedOutLayers()]
    # read the next frame from the file  frame = cv2.imread(input_file)  (H, W) = frame.shape[:2]
  # construct a blob from the input frame and then perform a forward  # pass of the YOLO object detector, giving us our bounding boxes  # and associated probabilities  blob = cv2.dnn.blobFromImage(frame, 1 / 255.0, (416, 416),    swapRB=True, crop=False)  net.setInput(blob)  start = time.time()  layerOutputs = net.forward(ln)  end = time.time()  # initialize our lists of detected bounding boxes, confidences,  # and class IDs, respectively  boxes = []  confidences = []  classIDs = []
  # loop over each of the layer outputs  for output in layerOutputs:    # loop over each of the detections    for detection in output:      # extract the class ID and confidence (i.e., probability)      # of the current object detection      scores = detection[5:]      classID = np.argmax(scores)      confidence = scores[classID]      # filter out weak predictions by ensuring the detected      # probability is greater than the minimum probability      if confidence > 0.3:        # scale the bounding box coordinates back relative to        # the size of the image, keeping in mind that YOLO        # actually returns the center (x, y)-coordinates of        # the bounding box followed by the boxes' width and        # height        box = detection[0:4] * np.array([W, H, W, H])        (centerX, centerY, width, height) = box.astype("int")        # use the center (x, y)-coordinates to derive the top        # and and left corner of the bounding box        x = int(centerX - (width / 2))        y = int(centerY - (height / 2))        # update our list of bounding box coordinates,        # confidences, and class IDs        boxes.append([x, y, int(width), int(height)])        confidences.append(float(confidence))        classIDs.append(classID)
  # apply non-maxima suppression to suppress weak, overlapping  # bounding boxes  idxs = cv2.dnn.NMSBoxes(boxes, confidences, 0.3,    0.25)  # ensure at least one detection exists  if len(idxs) > 0:    # loop over the indexes we are keeping    for i in idxs.flatten():      # extract the bounding box coordinates      (x, y) = (boxes[i][0], boxes[i][1])      (w, h) = (boxes[i][2], boxes[i][3])      # draw a bounding box rectangle and label on the frame      color = [int(c) for c in COLORS[classIDs[i]]]      cv2.rectangle(frame, (x, y), (x + w, y + h), color, 2)      label = classes[classIDs[i]]      text = "{}: {:.4f}".format(alt_names[label],        confidences[i])      cv2.putText(frame, text, (x, y - 5),        cv2.FONT_HERSHEY_SIMPLEX, 0.5, color, 2)
  cv2_imshow(frame)