del multi-processing

oneflow_yolov3/model/data_preprocess_multiprocess.py

-import time
-from multiprocessing import Process, Queue
-from multiprocessing import Value, RawArray
-
-import cv2
-import numpy as np
-
-
-def resize_image(img, origin_h, origin_w, image_height, image_width):
-    w = image_width
-    h = image_height
-    resized = np.zeros((3, image_height, image_width), dtype=np.float32)
-    part = np.zeros((3, origin_h, image_width), dtype=np.float32)
-    w_scale = (float)(origin_w - 1) / (w - 1)
-    h_scale = (float)(origin_h - 1) / (h - 1)
-
-    for c in range(w):
-        if c == w - 1 or origin_w == 1:
-            val = img[:, :, origin_w - 1]
-        else:
-            sx = c * w_scale
-            ix = int(sx)
-            dx = sx - ix
-            val = (1 - dx) * img[:, :, ix] + dx * img[:, :, ix + 1]
-        part[:, :, c] = val
-    for r in range(h):
-        sy = r * h_scale
-        iy = int(sy)
-        dy = sy - iy
-        val = (1 - dy) * part[:, iy, :]
-        resized[:, r, :] = val
-        if r == h - 1 or origin_h == 1:
-            continue
-        resized[:, r, :] = resized[:, r, :] + dy * part[:, iy + 1, :]
-    return resized
-
-
-def image_preprocess_v2(img_path, image_height, image_width):
-    img = cv2.imread(img_path, cv2.IMREAD_COLOR)
-    img = img.transpose(2, 0, 1).astype(np.float32)  # hwc->chw
-    img = img / 255  # /255
-    img[[0, 1, 2], :, :] = img[[2, 1, 0], :, :]  # bgr2rgb
-
-    w = image_width
-    h = image_height
-    origin_h = img.shape[1]
-    origin_w = img.shape[2]
-    new_w = origin_w
-    new_h = origin_h
-    if w / origin_w < h / origin_h:
-        new_w = w
-        new_h = origin_h * w // origin_w
-    else:
-        new_h = h
-        new_w = origin_w * h // origin_h
-    resize_img = resize_image(img, origin_h, origin_w, new_h, new_w)
-
-    dw = (w - new_w) // 2
-    dh = (h - new_h) // 2
-
-    padh_before = int(dh)
-    padh_after = int(h - new_h - padh_before)
-    padw_before = int(dw)
-    padw_after = int(w - new_w - padw_before)
-    result = np.pad(
-        resize_img,
-        pad_width=(
-            (0,
-             0),
-            (padh_before,
-             padh_after),
-            (padw_before,
-             padw_after)),
-        mode='constant',
-        constant_values=0.5)
-    result = np.expand_dims(result, axis=0)
-    origin_image_info = np.zeros((1, 2), dtype=np.int32)
-    origin_image_info[0, 0] = origin_h
-    origin_image_info[0, 1] = origin_w
-    return result.astype(np.float32), origin_image_info
-
-
-def batch_image_preprocess_v2(img_path_list, image_height, image_width):
-    result_list = []
-    origin_info_list = []
-    for img_path in img_path_list:
-        img = cv2.imread(img_path, cv2.IMREAD_COLOR)
-        img = img.transpose(2, 0, 1).astype(np.float32)  # hwc->chw
-        img = img / 255  # /255
-        img[[0, 1, 2], :, :] = img[[2, 1, 0], :, :]  # bgr2rgb
-
-        w = image_width
-        h = image_height
-        origin_h = img.shape[1]
-        origin_w = img.shape[2]
-        new_w = origin_w
-        new_h = origin_h
-        if w / origin_w < h / origin_h:
-            new_w = w
-            new_h = origin_h * w // origin_w
-        else:
-            new_h = h
-            new_w = origin_w * h // origin_h
-        resize_img = resize_image(img, origin_h, origin_w, new_h, new_w)
-
-        dw = (w - new_w) // 2
-        dh = (h - new_h) // 2
-
-        padh_before = int(dh)
-        padh_after = int(h - new_h - padh_before)
-        padw_before = int(dw)
-        padw_after = int(w - new_w - padw_before)
-        result = np.pad(
-            resize_img,
-            pad_width=(
-                (0,
-                 0),
-                (padh_before,
-                 padh_after),
-                (padw_before,
-                 padw_after)),
-            mode='constant',
-            constant_values=0.5)
-        origin_image_info = [origin_h, origin_w]
-        result_list.append(result)
-        origin_info_list.append(origin_image_info)
-    results = np.asarray(result_list).astype(np.float32)
-    origin_image_infos = np.asarray(origin_info_list).astype(np.int32)
-    return results, origin_image_infos
-
-
-img_path_list = []
-image_height = 608
-image_width = 608
-batch_size = 16
-num_worker = 4
-queue_size = batch_size // num_worker
-
-size = queue_size * 3 * image_height * image_width
-origin_info_size = queue_size * 2
-
-
-def worker(idx, flag, buffer, origin_info_buffer, queue):
-    while True:
-        time1 = time.time()
-        img_path_list = []
-        for i in range(queue_size):
-            path = queue.get()
-            img_path_list.append(path)
-        images, origin_image_info = batch_image_preprocess_v2(
-            img_path_list, image_width, image_width)
-        while flag.value != 0:
-            time.sleep(0.01)
-        arr = np.ctypeslib.as_array(buffer)
-        arr[:] = images.flatten()
-        origin_info_arr = np.ctypeslib.as_array(origin_info_buffer)
-        origin_info_arr[:] = origin_image_info.flatten()
-
-        flag.value = 1
-        #print("make data time", time.time()-time1)
-
-
-def make_work(idx):
-    flag = Value('i', 0, lock=True)
-    buffer = RawArray('f', size)
-    origin_info_buffer = RawArray('i', origin_info_size)
-    queue = Queue(queue_size)
-    proc = Process(
-        target=worker,
-        args=(
-            idx,
-            flag,
-            buffer,
-            origin_info_buffer,
-            queue))
-    return proc, flag, queue, buffer, origin_info_buffer
-
-# if __name__ == '__main__':
-#    workers = []
-#    for i in range(num_worker):
-#        workers.append(make_work(i))
-#    for w in workers:
-#        w[0].start()
-#
-#    ss = time.time()
-#
-#    for it in range(1, 5):
-#        path=['../../data/images/00000'+str(it)+'.jpg'] * 16
-#        for i in range(num_worker):
-#            _, _, w_q, _, _ = workers[i]
-#            for j in range(queue_size):
-#                w_q.put(path[i * queue_size + j])
-#
-#        s = time.time()
-#        batch_image = np.zeros((num_worker, queue_size*3*image_height*image_width))
-#        batch_origin_info = np.zeros((num_worker, queue_size*2))
-#        for i in range(num_worker):
-#            (proc, w_f, _, w_b, w_origin_info_b) = workers[i]
-#            while w_f.value == 0:
-#                time.sleep(0.01)
-#            ret = np.ctypeslib.as_array(w_b)
-#            batch_image[i,:] = ret
-#            ret_origin_info = np.ctypeslib.as_array(w_origin_info_b)
-#            batch_origin_info[i,:] = ret_origin_info
-#            w_f.value = 0
-#
-#        e = time.time()
-#        print(it, e - s, e)
-#
-#    for w in workers:
-#        w[0].terminate()
-#
-#    for w in workers:
-#        w[0].join()

oneflow_yolov3/model/python_load_data_predict_with_print_box_multiprocessing.py

-import argparse
-import os
-import time
-
-import numpy as np
-import oneflow as flow
-from data_preprocess_multiprocess import make_work
-from yolo_net import YoloPredictNet
-
-import oneflow_yolov3
-
-parser = argparse.ArgumentParser(description="flags for predict")
-parser.add_argument(
-    "-g",
-    "--gpu_num_per_node",
-    type=int,
-    default=1,
-    required=False)
-parser.add_argument("-load", "--pretrained_model", type=str, required=True)
-parser.add_argument(
-    "-image_height",
-    "--image_height",
-    type=int,
-    default=608,
-    required=False)
-parser.add_argument(
-    "-image_width",
-    "--image_width",
-    type=int,
-    default=608,
-    required=False)
-parser.add_argument("-img_list", "--image_list_path", type=str, required=True)
-parser.add_argument(
-    "-label_to_name_file",
-    "--label_to_name_file",
-    type=str,
-    required=True)
-parser.add_argument(
-    "-batch_size",
-    "--batch_size",
-    type=int,
-    default=1,
-    required=False)
-parser.add_argument(
-    "-total_batch_num",
-    "--total_batch_num",
-    type=int,
-    default=308,
-    required=False)
-parser.add_argument(
-    "-loss_print_steps",
-    "--loss_print_steps",
-    type=int,
-    default=1,
-    required=False)
-parser.add_argument(
-    "-use_tensorrt",
-    "--use_tensorrt",
-    type=int,
-    default=0,
-    required=False)
-parser.add_argument(
-    "-image_path_list",
-    "--image_path_list",
-    type=str,
-    nargs='+',
-    required=True)
-
-
-args = parser.parse_args()
-
-assert os.path.exists(args.pretrained_model)
-assert os.path.exists(args.image_path_list[0])
-assert os.path.exists(args.label_to_name_file)
-
-
-flow.config.load_library(oneflow_yolov3.lib_path())
-func_config = flow.FunctionConfig()
-func_config.default_distribute_strategy(flow.distribute.consistent_strategy())
-func_config.default_data_type(flow.float)
-if args.use_tensorrt != 0:
-    func_config.use_tensorrt(True)
-# func_config.tensorrt.use_fp16()
-
-label_2_name = []
-
-with open(args.label_to_name_file, 'r') as f:
-    label_2_name = f.readlines()
-
-nms = True
-
-
-def print_detect_box(positions, probs):
-    if nms:
-        batch_size = positions.shape[0]
-        for k in range(batch_size):
-            for i in range(1, 81):
-                for j in range(positions.shape[2]):
-                    if positions[k][i][j][1] != 0 and positions[k][i][j][2] != 0 and probs[k][i][j] != 0:
-                        print(label_2_name[i - 1],
-                              " ",
-                              probs[k][i][j] * 100,
-                              "%",
-                              "  ",
-                              positions[k][i][j][0],
-                              " ",
-                              positions[k][i][j][1],
-                              " ",
-                              positions[k][i][j][2],
-                              " ",
-                              positions[k][i][j][3])
-    else:
-        for j in range(positions.shape[1]):
-            for i in range(1, 81):
-                if positions[0][j][1] != 0 and positions[0][j][2] != 0 and probs[0][j][i] != 0:
-                    print(label_2_name[i - 1],
-                          " ",
-                          probs[0][j][i] * 100,
-                          "%",
-                          "  ",
-                          positions[0][j][0],
-                          " ",
-                          positions[0][j][1],
-                          " ",
-                          positions[0][j][2],
-                          " ",
-                          positions[0][j][3])
-
-
-def xywh_2_x1y1x2y2(x, y, w, h, origin_image):
-    x1 = (x - w / 2.) * origin_image[1]
-    x2 = (x + w / 2.) * origin_image[1]
-    y1 = (y - h / 2.) * origin_image[0]
-    y2 = (y + h / 2.) * origin_image[0]
-    return x1, y1, x2, y2
-
-
-def batch_boxes(positions, probs, origin_image_info):
-    batch_size = positions.shape[0]
-    batch_list = []
-    if nms:
-        for k in range(batch_size):
-            box_list = []
-            for i in range(1, 81):
-                for j in range(positions.shape[2]):
-                    if positions[k][i][j][2] != 0 and positions[k][i][j][3] != 0 and probs[k][i][j] != 0:
-                        x1, y1, x2, y2 = xywh_2_x1y1x2y2(
-                            positions[k][i][j][0], positions[k][i][j][1], positions[k][i][j][2], positions[k][i][j][3], origin_image_info[k])
-                        bbox = [i - 1, x1, y1, x2, y2, probs[k][i][j]]
-                        box_list.append(bbox)
-            batch_list.append(np.asarray(box_list))
-    else:
-        for k in range(batch_size):
-            box_list = []
-            for j in range(positions.shape[1]):
-                for i in range(1, 81):
-                    if positions[k][j][2] != 0 and positions[k][j][3] != 0 and probs[k][j][i] != 0:
-                        x1, y1, x2, y2 = xywh_2_x1y1x2y2(
-                            positions[k][j][0], positions[k][j][1], positions[k][j][2], positions[k][j][3], origin_image_info[k])
-                        bbox = [i - 1, x1, y1, x2, y2, probs[k][j][i]]
-                        box_list.append(bbox)
-            batch_list.append(np.asarray(box_list))
-    return batch_list
-
-
-input_blob_def_dict = {
-    "images": flow.FixedTensorDef(
-        (args.batch_size,
-         3,
-         args.image_height,
-         args.image_width),
-        dtype=flow.float),
-    "origin_image_info": flow.FixedTensorDef(
-        (args.batch_size,
-         2),
-        dtype=flow.int32),
-}
-
-
-@flow.global_function((func_config))
-def yolo_user_op_eval_job(
-        images=input_blob_def_dict["images"],
-        origin_image_info=input_blob_def_dict["origin_image_info"]):
-    yolo_pos_result, yolo_prob_result = YoloPredictNet(
-        images, origin_image_info, trainable=False)
-    return yolo_pos_result, yolo_prob_result, origin_image_info
-
-
-if __name__ == "__main__":
-    flow.config.gpu_device_num(args.gpu_num_per_node)
-    flow.env.ctrl_port(9789)
-
-    check_point = flow.train.CheckPoint()
-    if not args.pretrained_model:
-        check_point.init()
-    else:
-        check_point.load(args.pretrained_model)
-    fmt_str = "{:>12}   {:>12.10f} {:>12.10f} {:>12.3f}"
-    print(
-        "{:>12}   {:>12}  {:>12}  {:>12}".format(
-            "iter",
-            "reg loss value",
-            "cls loss value",
-            "time"))
-    global cur_time
-    cur_time = time.time()
-
-    num_worker = 4
-    queue_size = args.batch_size // num_worker
-    image_height = 608
-    image_width = 608
-    workers = []
-    for i in range(num_worker):
-        workers.append(make_work(i))
-    for w in workers:
-        w[0].start()
-
-    batch_image = np.zeros(
-        (num_worker,
-         queue_size *
-         3 *
-         image_height *
-         image_width),
-        dtype=np.float32)
-    batch_origin_info = np.zeros((num_worker, queue_size * 2), dtype=np.int32)
-
-    image_list_len = len(args.image_path_list)
-    for step in range(args.total_batch_num):
-        #img_path = args.image_path_list[step % image_list_len]
-        path = ['data/images/00000' + str(step + 1) + '.jpg'] * 16
-        for i in range(num_worker):
-            _, _, w_q, _, _ = workers[i]
-            for j in range(queue_size):
-                w_q.put(path[i * queue_size + j])
-
-        for i in range(num_worker):
-            (proc, w_f, _, w_b, w_origin_info_b) = workers[i]
-            while w_f.value == 0:
-                time.sleep(0.01)
-            ret = np.ctypeslib.as_array(w_b)
-            batch_image[i, :] = ret
-            ret_origin_info = np.ctypeslib.as_array(w_origin_info_b)
-            batch_origin_info[i, :] = ret_origin_info
-            w_f.value = 0
-        yolo_pos, yolo_prob, origin_image_info = yolo_user_op_eval_job(
-            batch_image.reshape(
-                args.batch_size, 3, image_height, image_width), batch_origin_info.reshape(
-                args.batch_size, 2)).get()
-        batch_list = batch_boxes(yolo_pos, yolo_prob, origin_image_info)
-        print("batch_list", batch_list)
-
-    for w in workers:
-        w[0].terminate()
-
-    for w in workers:
-        w[0].join()

yolo_predict_python_data_preprocess_multiprocess.sh

-model_dir=of_model/of_yolov3_model/
-image_list_file=data/with_dir_data_names
-label_2_name_file=data/coco.names
-export ONEFLOW_DEBUG_MODE=""
-
-python3 oneflow_yolov3/model/python_load_data_predict_with_print_box_multiprocessing.py --total_batch_num=4 \
---gpu_num_per_node=1 --batch_size=16  --pretrained_model=$model_dir \
---image_list_path=$image_list_file --label_to_name_file=$label_2_name_file \
---use_tensorrt=0  \
---image_path_list 'data/images/000001.jpg' 'data/images/000002.jpg' 'data/images/000003.jpg' 'data/images/000004.jpg' 'data/images/000011.jpg' 'data/images/000012.jpg' 'data/images/000013.jpg' 'data/images/000014.jpg'
-