探索 YOLO v3 實現細節 – 第6篇 預測 (完結)

SpikeKing發表於2019-03-03

YOLO,即You Only Look Once的縮寫,是一個基於卷積神經網路(CNN)的物體檢測演算法。而YOLO v3是YOLO的第3個版本,即YOLOYOLO 9000YOLO v3,檢測效果,更準更強。

YOLO v3的更多細節,可以參考YOLO的官網

YOLO

YOLO是一句美國的俗語,You Only Live Once,你只能活一次,即人生苦短,及時行樂。

本文主要分享,如何實現YOLO v3的演算法細節,Keras框架。這是第6篇,檢測圖片中的物體,使用訓練完成的模型,通過框置信度與類別置信度的乘積,篩選最優的檢測框。本系列一共6篇,已完結,這是一個完整版 :)

本文的GitHub原始碼github.com/SpikeKing/k…

已更新:

歡迎關注,微信公眾號 深度演算法 (ID: DeepAlgorithm) ,瞭解更多深度技術!


1. 檢測函式

使用已經訓練完成的YOLO v3模型,檢測圖片中的物體,其中:

  • 建立YOLO類的例項yolo;
  • 使用Image.open()載入影像image;
  • 呼叫yolo.detect_image()檢測影像image;
  • 關閉yolo的session;
  • 顯示檢測完成的影像r_image;

實現:

def detect_img_for_test():
    yolo = YOLO()
    img_path = `./dataset/img.jpg`
    image = Image.open(img_path)
    r_image = yolo.detect_image(image)
    yolo.close_session()
    r_image.show()
複製程式碼

輸出:

檢測影像

2. YOLO引數

YOLO類的初始化引數:

  • anchors_path:anchor box的配置檔案,9個寬高組合;
  • model_path:已訓練完成的模型,支援重新訓練的模型;
  • classes_path:類別檔案,與模型檔案匹配;
  • score:置信度的閾值,刪除小於閾值的候選框;
  • iou:候選框的IoU閾值,刪除同類別中大於閾值的候選框;
  • class_names:類別列表,讀取classes_path;
  • anchors:anchor box列表,讀取anchors_path;
  • model_image_size:模型所檢測影像的尺寸,輸入影像都需要按此填充;
  • colors:通過HSV色域,生成隨機顏色集合,數量等於類別數class_names;
  • boxes、scores、classes:檢測的核心輸出,函式generate()所生成,是模型的輸出封裝。

實現:

self.anchors_path = `configs/yolo_anchors.txt`  # Anchors
self.model_path = `model_data/yolo_weights.h5`  # 模型檔案
self.classes_path = `configs/coco_classes.txt`  # 類別檔案

self.score = 0.20
self.iou = 0.20
self.class_names = self._get_class()  # 獲取類別
self.anchors = self._get_anchors()  # 獲取anchor
self.sess = K.get_session()
self.model_image_size = (416, 416)  # fixed size or (None, None), hw
self.colors = self.__get_colors(self.class_names)
self.boxes, self.scores, self.classes = self.generate()
複製程式碼

在__get_colors()中:

  • 將HSV的第0位H值,按1等分,其餘SV值,均為1,生成一組HSV列表;
  • 呼叫hsv_to_rgb,將HSV色域轉換為RGB色域;
  • 0~1的RGB值乘以255,轉換為完整的顏色值,(0~255);
  • 隨機shuffle顏色列表;

實現:

@staticmethod def __get_colors(names):
    # 不同的框,不同的顏色
    hsv_tuples = [(float(x) / len(names), 1., 1.)
                  for x in range(len(names))]  # 不同顏色
    colors = list(map(lambda x: colorsys.hsv_to_rgb(*x), hsv_tuples))
    colors = list(map(lambda x: (int(x[0] * 255), int(x[1] * 255), int(x[2] * 255)), colors))  # RGB
    np.random.seed(10101)
    np.random.shuffle(colors)
    np.random.seed(None)

    return colors
複製程式碼

選擇HSV劃分,而不是RGB的原因是,HSV的顏色值偏移更好,畫出的框,顏色更容易區分。


3. 輸出封裝

boxes、scores、classes是在模型的基礎上,繼續封裝,由函式generate()所生成,其中:

  • boxes:框的四個點座標,(top, left, bottom, right);
  • scores:框的類別置信度,融合框置信度和類別置信度;
  • classes:框的類別;

在函式generate()中,設定引數:

  • num_anchors:anchor box的總數,一般是9個;
  • num_classes:類別總數,如COCO是80個類;
  • yolo_model:由yolo_body所建立的模型,呼叫load_weights載入引數;

實現:

num_anchors = len(self.anchors)  # anchors的數量
num_classes = len(self.class_names)  # 類別數

self.yolo_model = yolo_body(Input(shape=(416, 416, 3)), 3, num_classes)
self.yolo_model.load_weights(model_path)  # 載入模型引數
複製程式碼

接著,設定input_image_shape為placeholder,即TF中的引數變數。在yolo_eval中:

  • 繼續封裝yolo_model的輸出output;
  • anchors,anchor box列表;
  • 類別class_names的總數len();
  • 輸入圖片的可選尺寸,input_image_shape,即(416, 416);
  • score_threshold,框的整體置信度閾值score;
  • iou_threshold,同類別框的IoU閾值iou;
  • 返回,框的座標boxes,框的類別置信度scores,框的類別classes;

實現:

self.input_image_shape = K.placeholder(shape=(2,))
boxes, scores, classes = yolo_eval(
    self.yolo_model.output, self.anchors, len(self.class_names),
    self.input_image_shape, score_threshold=self.score, iou_threshold=self.iou)
return boxes, scores, classes
複製程式碼

輸出的scores值,都會大於score_threshold,小於的在yolo_eval()中已被刪除。


4. YOLO評估

在函式yolo_eval()中,完成預測邏輯的封裝,其中輸入:

  • yolo_outputs:YOLO模型的輸出,3個尺度的列表,即13-26-52,最後1維是預測值,由255=3x(5+80)組成,3是每層的anchor數,5是4個框值xywh和1個框中含有物體的置信度,80是COCO的類別數;
  • anchors:9個anchor box的值;
  • num_classes:類別個數,COCO是80個類別;
  • image_shape:placeholder型別的TF引數,預設(416, 416);
  • max_boxes:圖中每個類別的最大檢測框數,20個;
  • score_threshold:框置信度閾值,小於閾值的框被刪除,需要的框較多,則調低閾值,需要的框較少,則調高閾值;
  • iou_threshold:同類別框的IoU閾值,大於閾值的重疊框被刪除,重疊物體較多,則調高閾值,重疊物體較少,則調低閾值;

其中,yolo_outputs格式,如下:

[(?, 13, 13, 255), (?, 26, 26, 255), (?, 52, 52, 255)]
複製程式碼

其中,anchors列表,如下:

[(10,13), (16,30), (33,23), (30,61), (62,45), (59,119), (116,90), (156,198), (373,326)]
複製程式碼

實現:

boxes, scores, classes = yolo_eval(
    self.yolo_model.output, self.anchors, len(self.class_names),
    self.input_image_shape, score_threshold=self.score, iou_threshold=self.iou)

def yolo_eval(yolo_outputs, anchors, num_classes, image_shape,
              max_boxes=20, score_threshold=.6, iou_threshold=.5):
複製程式碼

接著,處理引數:

  • num_layers,輸出特徵圖的層數,3層;
  • anchor_mask,將anchors劃分為3個層,第1層13×13是678,第2層26×26是345,第3層52×52是012;
  • input_shape:輸入影像的尺寸,也就是第0個特徵圖的尺寸乘以32,即13×32=416,這與Darknet的網路結構有關。
num_layers = len(yolo_outputs)
anchor_mask = [[6, 7, 8], [3, 4, 5], [0, 1, 2]] if num_layers == 3 else [[3, 4, 5], [1, 2, 3]]  # default setting
input_shape = K.shape(yolo_outputs[0])[1:3] * 32
複製程式碼

特徵圖越大,13->52,檢測的物體越小,需要的anchors越小,所以anchors列表以倒序賦值。

接著,在YOLO的第l層輸出yolo_outputs中,呼叫yolo_boxes_and_scores(),提取框_boxes和置信度_box_scores,將3個層的框資料放入列表boxes和box_scores,再拼接concatenate展平,輸出的資料就是所有的框和置信度。

其中,輸出的boxes和box_scores的格式,如下:

boxes: (?, 4)  # ?是框數
box_scores: (?, 80)
複製程式碼

實現:

boxes = []
box_scores = []
for l in range(num_layers):
    _boxes, _box_scores = yolo_boxes_and_scores(
        yolo_outputs[l], anchors[anchor_mask[l]], num_classes, input_shape, image_shape)
    boxes.append(_boxes)
    box_scores.append(_box_scores)
boxes = K.concatenate(boxes, axis=0)
box_scores = K.concatenate(box_scores, axis=0)
複製程式碼

concatenate的作用是:將多個層的資料展平,因為框已經還原為真實座標,不同尺度沒有差異。

在函式yolo_boxes_and_scores()中:

  • yolo_head的輸出:box_xy是box的中心座標,(0~1)相對位置;box_wh是box的寬高,(0~1)相對值;box_confidence是框中物體置信度;box_class_probs是類別置信度;
  • yolo_correct_boxes,將box_xy和box_wh的(0~1)相對值,轉換為真實座標,輸出boxes是(y_min,x_min,y_max,x_max)的值;
  • reshape,將不同網格的值展平為框的列表,即(?,13,13,3,4)->(?,4);
  • box_scores是框置信度與類別置信度的乘積,再reshape展平,(?,80);
  • 返回框boxes和框置信度box_scores。

實現:

def yolo_boxes_and_scores(feats, anchors, num_classes, input_shape, image_shape):
    ```Process Conv layer output```
    box_xy, box_wh, box_confidence, box_class_probs = yolo_head(
        feats, anchors, num_classes, input_shape)
    boxes = yolo_correct_boxes(box_xy, box_wh, input_shape, image_shape)
    boxes = K.reshape(boxes, [-1, 4])
    box_scores = box_confidence * box_class_probs
    box_scores = K.reshape(box_scores, [-1, num_classes])
    return boxes, box_scores
複製程式碼

接著:

  • mask,過濾小於置信度閾值的框,只保留大於置信度的框,mask掩碼;
  • max_boxes_tensor,圖片中每個類別的最大檢測框數,max_boxes是20;

實現:

mask = box_scores >= score_threshold
max_boxes_tensor = K.constant(max_boxes, dtype=`int32`)
複製程式碼

接著:

  • 通過掩碼mask和類別c,篩選框class_boxes和置信度class_box_scores;
  • 通過NMS,非極大值抑制,篩選出框boxes的NMS索引nms_index;
  • 根據索引,選擇gather輸出的框class_boxes和置信class_box_scores度,再生成類別資訊classes;
  • 將多個類別的資料組合,生成最終的檢測資料框,並返回。

實現:

boxes_ = []
scores_ = []
classes_ = []
for c in range(num_classes):
    class_boxes = tf.boolean_mask(boxes, mask[:, c])
    class_box_scores = tf.boolean_mask(box_scores[:, c], mask[:, c])
    nms_index = tf.image.non_max_suppression(
        class_boxes, class_box_scores, max_boxes_tensor, iou_threshold=iou_threshold)
    class_boxes = K.gather(class_boxes, nms_index)
    class_box_scores = K.gather(class_box_scores, nms_index)
    classes = K.ones_like(class_box_scores, `int32`) * c
    boxes_.append(class_boxes)
    scores_.append(class_box_scores)
    classes_.append(classes)
boxes_ = K.concatenate(boxes_, axis=0)
scores_ = K.concatenate(scores_, axis=0)
classes_ = K.concatenate(classes_, axis=0)
複製程式碼

輸出格式:

boxes_: (?, 4)
scores_: (?,)
classes_: (?,)
複製程式碼

5. 檢測方法

第1步,影像處理:

  1. 將影像等比例轉換為檢測尺寸,檢測尺寸需要是32的倍數,周圍進行填充;
  2. 將圖片增加1維,符合輸入引數格式;
if self.model_image_size != (None, None):  # 416x416, 416=32*13,必須為32的倍數,最小尺度是除以32
    assert self.model_image_size[0] % 32 == 0, `Multiples of 32 required`
    assert self.model_image_size[1] % 32 == 0, `Multiples of 32 required`
    boxed_image = letterbox_image(image, tuple(reversed(self.model_image_size)))  # 填充影像
else:
    new_image_size = (image.width - (image.width % 32), image.height - (image.height % 32))
    boxed_image = letterbox_image(image, new_image_size)
image_data = np.array(boxed_image, dtype=`float32`)
print(`detector size {}`.format(image_data.shape))
image_data /= 255.  # 轉換0~1
image_data = np.expand_dims(image_data, 0)  # 新增批次維度,將圖片增加1維
複製程式碼

第2步,feed資料,影像,影像尺寸;

out_boxes, out_scores, out_classes = self.sess.run(
    [self.boxes, self.scores, self.classes],
    feed_dict={
        self.yolo_model.input: image_data,
        self.input_image_shape: [image.size[1], image.size[0]],
        K.learning_phase(): 0
    })
複製程式碼

第3步,繪製邊框,自動設定邊框寬度,繪製邊框和類別文字,使用Pillow繪相簿。

font = ImageFont.truetype(font=`font/FiraMono-Medium.otf`,
                          size=np.floor(3e-2 * image.size[1] + 0.5).astype(`int32`))  # 字型
thickness = (image.size[0] + image.size[1]) // 512  # 厚度
for i, c in reversed(list(enumerate(out_classes))):
    predicted_class = self.class_names[c]  # 類別
    box = out_boxes[i]  # 框
    score = out_scores[i]  # 執行度

    label = `{} {:.2f}`.format(predicted_class, score)  # 標籤
    draw = ImageDraw.Draw(image)  # 畫圖
    label_size = draw.textsize(label, font)  # 標籤文字

    top, left, bottom, right = box
    top = max(0, np.floor(top + 0.5).astype(`int32`))
    left = max(0, np.floor(left + 0.5).astype(`int32`))
    bottom = min(image.size[1], np.floor(bottom + 0.5).astype(`int32`))
    right = min(image.size[0], np.floor(right + 0.5).astype(`int32`))
    print(label, (left, top), (right, bottom))  # 邊框

    if top - label_size[1] >= 0:  # 標籤文字
        text_origin = np.array([left, top - label_size[1]])
    else:
        text_origin = np.array([left, top + 1])

    # My kingdom for a good redistributable image drawing library.
    for i in range(thickness):  # 畫框
        draw.rectangle(
            [left + i, top + i, right - i, bottom - i],
            outline=self.colors[c])
    draw.rectangle(  # 文字背景
        [tuple(text_origin), tuple(text_origin + label_size)],
        fill=self.colors[c])
    draw.text(text_origin, label, fill=(0, 0, 0), font=font)  # 文案
    del draw
複製程式碼

補充

1. concatenate

concatenate將相同維度的資料元素連線到一起。

實現:

from keras import backend as K

sess = K.get_session()

a = K.constant([[2, 4], [1, 2]])
b = K.constant([[3, 2], [5, 6]])
c = [a, b]
c = K.concatenate(c, axis=0)

print(sess.run(c))
"""
[[2. 4.] [1. 2.] [3. 2.] [5. 6.]]
"""
複製程式碼

2. gather

gather以索引選擇列表元素。

實現:

from keras import backend as K

sess = K.get_session()

a = K.constant([[2, 4], [1, 2], [5, 6]])
b = K.gather(a, [1, 2])

print(sess.run(b))
"""
[[1. 2.] [5. 6.]]
"""
複製程式碼

OK, that`s all! Enjoy it!

歡迎關注,微信公眾號 深度演算法 (ID: DeepAlgorithm) ,瞭解更多深度技術!

相關文章