From 37d193a84a0812c2ba2faa24987f35861baf3b51 Mon Sep 17 00:00:00 2001 From: Felipe Date: Sun, 31 May 2020 01:04:21 -0700 Subject: [PATCH] darknet-yolo try --- detect/yolo/darknet.py | 527 +++++++++++++++++++++++++++++++ detect/yolo/darknet_model.py | 105 ++++++ notebooks/Comparing models.ipynb | 162 +++++++++- notebooks/detector.ipynb | 353 ++++++--------------- notebooks/faces-20000.data | 5 + notebooks/faces.names | 2 + 6 files changed, 889 insertions(+), 265 deletions(-) create mode 100644 detect/yolo/darknet.py create mode 100644 detect/yolo/darknet_model.py create mode 100644 notebooks/faces-20000.data create mode 100644 notebooks/faces.names diff --git a/detect/yolo/darknet.py b/detect/yolo/darknet.py new file mode 100644 index 0000000..27a7a67 --- /dev/null +++ b/detect/yolo/darknet.py @@ -0,0 +1,527 @@ +#!python3 +""" +Python 3 wrapper for identifying objects in images + +Requires DLL compilation + +Both the GPU and no-GPU version should be compiled; the no-GPU version should be renamed "yolo_cpp_dll_nogpu.dll". + +On a GPU system, you can force CPU evaluation by any of: + +- Set global variable DARKNET_FORCE_CPU to True +- Set environment variable CUDA_VISIBLE_DEVICES to -1 +- Set environment variable "FORCE_CPU" to "true" + + +To use, either run performDetect() after import, or modify the end of this file. + +See the docstring of performDetect() for parameters. + +Directly viewing or returning bounding-boxed images requires scikit-image to be installed (`pip install scikit-image`) + + +Original *nix 2.7: https://github.com/pjreddie/darknet/blob/0f110834f4e18b30d5f101bf8f1724c34b7b83db/python/darknet.py +Windows Python 2.7 version: https://github.com/AlexeyAB/darknet/blob/fc496d52bf22a0bb257300d3c79be9cd80e722cb/build/darknet/x64/darknet.py + +@author: Philip Kahn +@date: 20180503 +""" +#pylint: disable=R, W0401, W0614, W0703 +from ctypes import * +import math +import random +import os + +def sample(probs): + s = sum(probs) + probs = [a/s for a in probs] + r = random.uniform(0, 1) + for i in range(len(probs)): + r = r - probs[i] + if r <= 0: + return i + return len(probs)-1 + +def c_array(ctype, values): + arr = (ctype*len(values))() + arr[:] = values + return arr + +class BOX(Structure): + _fields_ = [("x", c_float), + ("y", c_float), + ("w", c_float), + ("h", c_float)] + +class DETECTION(Structure): + _fields_ = [("bbox", BOX), + ("classes", c_int), + ("prob", POINTER(c_float)), + ("mask", POINTER(c_float)), + ("objectness", c_float), + ("sort_class", c_int), + ("uc", POINTER(c_float)), + ("points", c_int)] + +class DETNUMPAIR(Structure): + _fields_ = [("num", c_int), + ("dets", POINTER(DETECTION))] + +class IMAGE(Structure): + _fields_ = [("w", c_int), + ("h", c_int), + ("c", c_int), + ("data", POINTER(c_float))] + +class METADATA(Structure): + _fields_ = [("classes", c_int), + ("names", POINTER(c_char_p))] + + + +#lib = CDLL("/home/pjreddie/documents/darknet/libdarknet.so", RTLD_GLOBAL) +#lib = CDLL("libdarknet.so", RTLD_GLOBAL) +hasGPU = True +if os.name == "nt": + cwd = os.path.dirname(__file__) + os.environ['PATH'] = cwd + ';' + os.environ['PATH'] + winGPUdll = os.path.join(cwd, "yolo_cpp_dll.dll") + winNoGPUdll = os.path.join(cwd, "yolo_cpp_dll_nogpu.dll") + envKeys = list() + for k, v in os.environ.items(): + envKeys.append(k) + try: + try: + tmp = os.environ["FORCE_CPU"].lower() + if tmp in ["1", "true", "yes", "on"]: + raise ValueError("ForceCPU") + else: + print("Flag value '"+tmp+"' not forcing CPU mode") + except KeyError: + # We never set the flag + if 'CUDA_VISIBLE_DEVICES' in envKeys: + if int(os.environ['CUDA_VISIBLE_DEVICES']) < 0: + raise ValueError("ForceCPU") + try: + global DARKNET_FORCE_CPU + if DARKNET_FORCE_CPU: + raise ValueError("ForceCPU") + except NameError: + pass + # print(os.environ.keys()) + # print("FORCE_CPU flag undefined, proceeding with GPU") + if not os.path.exists(winGPUdll): + raise ValueError("NoDLL") + lib = CDLL(winGPUdll, RTLD_GLOBAL) + except (KeyError, ValueError): + hasGPU = False + if os.path.exists(winNoGPUdll): + lib = CDLL(winNoGPUdll, RTLD_GLOBAL) + print("Notice: CPU-only mode") + else: + # Try the other way, in case no_gpu was + # compile but not renamed + lib = CDLL(winGPUdll, RTLD_GLOBAL) + print("Environment variables indicated a CPU run, but we didn't find `"+winNoGPUdll+"`. Trying a GPU run anyway.") +else: + lib = CDLL("./libdarknet.so", RTLD_GLOBAL) +lib.network_width.argtypes = [c_void_p] +lib.network_width.restype = c_int +lib.network_height.argtypes = [c_void_p] +lib.network_height.restype = c_int + +copy_image_from_bytes = lib.copy_image_from_bytes +copy_image_from_bytes.argtypes = [IMAGE,c_char_p] + +def network_width(net): + return lib.network_width(net) + +def network_height(net): + return lib.network_height(net) + +predict = lib.network_predict_ptr +predict.argtypes = [c_void_p, POINTER(c_float)] +predict.restype = POINTER(c_float) + +if hasGPU: + set_gpu = lib.cuda_set_device + set_gpu.argtypes = [c_int] + +init_cpu = lib.init_cpu + +make_image = lib.make_image +make_image.argtypes = [c_int, c_int, c_int] +make_image.restype = IMAGE + +get_network_boxes = lib.get_network_boxes +get_network_boxes.argtypes = [c_void_p, c_int, c_int, c_float, c_float, POINTER(c_int), c_int, POINTER(c_int), c_int] +get_network_boxes.restype = POINTER(DETECTION) + +make_network_boxes = lib.make_network_boxes +make_network_boxes.argtypes = [c_void_p] +make_network_boxes.restype = POINTER(DETECTION) + +free_detections = lib.free_detections +free_detections.argtypes = [POINTER(DETECTION), c_int] + +free_batch_detections = lib.free_batch_detections +free_batch_detections.argtypes = [POINTER(DETNUMPAIR), c_int] + +free_ptrs = lib.free_ptrs +free_ptrs.argtypes = [POINTER(c_void_p), c_int] + +network_predict = lib.network_predict_ptr +network_predict.argtypes = [c_void_p, POINTER(c_float)] + +reset_rnn = lib.reset_rnn +reset_rnn.argtypes = [c_void_p] + +load_net = lib.load_network +load_net.argtypes = [c_char_p, c_char_p, c_int] +load_net.restype = c_void_p + +load_net_custom = lib.load_network_custom +load_net_custom.argtypes = [c_char_p, c_char_p, c_int, c_int] +load_net_custom.restype = c_void_p + +do_nms_obj = lib.do_nms_obj +do_nms_obj.argtypes = [POINTER(DETECTION), c_int, c_int, c_float] + +do_nms_sort = lib.do_nms_sort +do_nms_sort.argtypes = [POINTER(DETECTION), c_int, c_int, c_float] + +free_image = lib.free_image +free_image.argtypes = [IMAGE] + +letterbox_image = lib.letterbox_image +letterbox_image.argtypes = [IMAGE, c_int, c_int] +letterbox_image.restype = IMAGE + +load_meta = lib.get_metadata +lib.get_metadata.argtypes = [c_char_p] +lib.get_metadata.restype = METADATA + +load_image = lib.load_image_color +load_image.argtypes = [c_char_p, c_int, c_int] +load_image.restype = IMAGE + +rgbgr_image = lib.rgbgr_image +rgbgr_image.argtypes = [IMAGE] + +predict_image = lib.network_predict_image +predict_image.argtypes = [c_void_p, IMAGE] +predict_image.restype = POINTER(c_float) + +predict_image_letterbox = lib.network_predict_image_letterbox +predict_image_letterbox.argtypes = [c_void_p, IMAGE] +predict_image_letterbox.restype = POINTER(c_float) + +network_predict_batch = lib.network_predict_batch +network_predict_batch.argtypes = [c_void_p, IMAGE, c_int, c_int, c_int, + c_float, c_float, POINTER(c_int), c_int, c_int] +network_predict_batch.restype = POINTER(DETNUMPAIR) + +def array_to_image(arr): + import numpy as np + # need to return old values to avoid python freeing memory + arr = arr.transpose(2,0,1) + c = arr.shape[0] + h = arr.shape[1] + w = arr.shape[2] + arr = np.ascontiguousarray(arr.flat, dtype=np.float32) / 255.0 + data = arr.ctypes.data_as(POINTER(c_float)) + im = IMAGE(w,h,c,data) + return im, arr + +def classify(net, meta, im): + out = predict_image(net, im) + res = [] + for i in range(meta.classes): + if altNames is None: + nameTag = meta.names[i] + else: + nameTag = altNames[i] + res.append((nameTag, out[i])) + res = sorted(res, key=lambda x: -x[1]) + return res + +def detect(net, meta, image, thresh=.5, hier_thresh=.5, nms=.45, debug= False): + """ + Performs the meat of the detection + """ + #pylint: disable= C0321 + im = load_image(image, 0, 0) + if debug: print("Loaded image") + ret = detect_image(net, meta, im, thresh, hier_thresh, nms, debug) + free_image(im) + if debug: print("freed image") + return ret + +def detect_image(net, meta, im, thresh=.5, hier_thresh=.5, nms=.45, debug= False): + #import cv2 + #custom_image_bgr = cv2.imread(image) # use: detect(,,imagePath,) + #custom_image = cv2.cvtColor(custom_image_bgr, cv2.COLOR_BGR2RGB) + #custom_image = cv2.resize(custom_image,(lib.network_width(net), lib.network_height(net)), interpolation = cv2.INTER_LINEAR) + #import scipy.misc + #custom_image = scipy.misc.imread(image) + #im, arr = array_to_image(custom_image) # you should comment line below: free_image(im) + num = c_int(0) + if debug: print("Assigned num") + pnum = pointer(num) + if debug: print("Assigned pnum") + predict_image(net, im) + letter_box = 0 + #predict_image_letterbox(net, im) + #letter_box = 1 + if debug: print("did prediction") + #dets = get_network_boxes(net, custom_image_bgr.shape[1], custom_image_bgr.shape[0], thresh, hier_thresh, None, 0, pnum, letter_box) # OpenCV + dets = get_network_boxes(net, im.w, im.h, thresh, hier_thresh, None, 0, pnum, letter_box) + if debug: print("Got dets") + num = pnum[0] + if debug: print("got zeroth index of pnum") + if nms: + do_nms_sort(dets, num, meta.classes, nms) + if debug: print("did sort") + res = [] + if debug: print("about to range") + for j in range(num): + if debug: print("Ranging on "+str(j)+" of "+str(num)) + if debug: print("Classes: "+str(meta), meta.classes, meta.names) + for i in range(meta.classes): + if debug: print("Class-ranging on "+str(i)+" of "+str(meta.classes)+"= "+str(dets[j].prob[i])) + if dets[j].prob[i] > 0: + b = dets[j].bbox + if altNames is None: + nameTag = meta.names[i] + else: + nameTag = altNames[i] + if debug: + print("Got bbox", b) + print(nameTag) + print(dets[j].prob[i]) + print((b.x, b.y, b.w, b.h)) + res.append((nameTag, dets[j].prob[i], (b.x, b.y, b.w, b.h))) + if debug: print("did range") + res = sorted(res, key=lambda x: -x[1]) + if debug: print("did sort") + free_detections(dets, num) + if debug: print("freed detections") + return res + + +netMain = None +metaMain = None +altNames = None + +def performDetect(imagePath="data/dog.jpg", thresh= 0.25, configPath = "./cfg/yolov4.cfg", weightPath = "yolov4.weights", metaPath= "./cfg/coco.data", showImage= True, makeImageOnly = False, initOnly= False): + """ + Convenience function to handle the detection and returns of objects. + + Displaying bounding boxes requires libraries scikit-image and numpy + + Parameters + ---------------- + imagePath: str + Path to the image to evaluate. Raises ValueError if not found + + thresh: float (default= 0.25) + The detection threshold + + configPath: str + Path to the configuration file. Raises ValueError if not found + + weightPath: str + Path to the weights file. Raises ValueError if not found + + metaPath: str + Path to the data file. Raises ValueError if not found + + showImage: bool (default= True) + Compute (and show) bounding boxes. Changes return. + + makeImageOnly: bool (default= False) + If showImage is True, this won't actually *show* the image, but will create the array and return it. + + initOnly: bool (default= False) + Only initialize globals. Don't actually run a prediction. + + Returns + ---------------------- + + + When showImage is False, list of tuples like + ('obj_label', confidence, (bounding_box_x_px, bounding_box_y_px, bounding_box_width_px, bounding_box_height_px)) + The X and Y coordinates are from the center of the bounding box. Subtract half the width or height to get the lower corner. + + Otherwise, a dict with + { + "detections": as above + "image": a numpy array representing an image, compatible with scikit-image + "caption": an image caption + } + """ + # Import the global variables. This lets us instance Darknet once, then just call performDetect() again without instancing again + global metaMain, netMain, altNames #pylint: disable=W0603 + assert 0 < thresh < 1, "Threshold should be a float between zero and one (non-inclusive)" + if not os.path.exists(configPath): + raise ValueError("Invalid config path `"+os.path.abspath(configPath)+"`") + if not os.path.exists(weightPath): + raise ValueError("Invalid weight path `"+os.path.abspath(weightPath)+"`") + if not os.path.exists(metaPath): + raise ValueError("Invalid data file path `"+os.path.abspath(metaPath)+"`") + if netMain is None: + netMain = load_net_custom(configPath.encode("ascii"), weightPath.encode("ascii"), 0, 1) # batch size = 1 + if metaMain is None: + metaMain = load_meta(metaPath.encode("ascii")) + if altNames is None: + # In Python 3, the metafile default access craps out on Windows (but not Linux) + # Read the names file and create a list to feed to detect + try: + with open(metaPath) as metaFH: + metaContents = metaFH.read() + import re + match = re.search("names *= *(.*)$", metaContents, re.IGNORECASE | re.MULTILINE) + if match: + result = match.group(1) + else: + result = None + try: + if os.path.exists(result): + with open(result) as namesFH: + namesList = namesFH.read().strip().split("\n") + altNames = [x.strip() for x in namesList] + except TypeError: + pass + except Exception: + pass + if initOnly: + print("Initialized detector") + return None + if not os.path.exists(imagePath): + raise ValueError("Invalid image path `"+os.path.abspath(imagePath)+"`") + # Do the detection + #detections = detect(netMain, metaMain, imagePath, thresh) # if is used cv2.imread(image) + detections = detect(netMain, metaMain, imagePath.encode("ascii"), thresh) + if showImage: + try: + from skimage import io, draw + import numpy as np + image = io.imread(imagePath) + print("*** "+str(len(detections))+" Results, color coded by confidence ***") + imcaption = [] + for detection in detections: + label = detection[0] + confidence = detection[1] + pstring = label+": "+str(np.rint(100 * confidence))+"%" + imcaption.append(pstring) + print(pstring) + bounds = detection[2] + shape = image.shape + # x = shape[1] + # xExtent = int(x * bounds[2] / 100) + # y = shape[0] + # yExtent = int(y * bounds[3] / 100) + yExtent = int(bounds[3]) + xEntent = int(bounds[2]) + # Coordinates are around the center + xCoord = int(bounds[0] - bounds[2]/2) + yCoord = int(bounds[1] - bounds[3]/2) + boundingBox = [ + [xCoord, yCoord], + [xCoord, yCoord + yExtent], + [xCoord + xEntent, yCoord + yExtent], + [xCoord + xEntent, yCoord] + ] + # Wiggle it around to make a 3px border + rr, cc = draw.polygon_perimeter([x[1] for x in boundingBox], [x[0] for x in boundingBox], shape= shape) + rr2, cc2 = draw.polygon_perimeter([x[1] + 1 for x in boundingBox], [x[0] for x in boundingBox], shape= shape) + rr3, cc3 = draw.polygon_perimeter([x[1] - 1 for x in boundingBox], [x[0] for x in boundingBox], shape= shape) + rr4, cc4 = draw.polygon_perimeter([x[1] for x in boundingBox], [x[0] + 1 for x in boundingBox], shape= shape) + rr5, cc5 = draw.polygon_perimeter([x[1] for x in boundingBox], [x[0] - 1 for x in boundingBox], shape= shape) + boxColor = (int(255 * (1 - (confidence ** 2))), int(255 * (confidence ** 2)), 0) + draw.set_color(image, (rr, cc), boxColor, alpha= 0.8) + draw.set_color(image, (rr2, cc2), boxColor, alpha= 0.8) + draw.set_color(image, (rr3, cc3), boxColor, alpha= 0.8) + draw.set_color(image, (rr4, cc4), boxColor, alpha= 0.8) + draw.set_color(image, (rr5, cc5), boxColor, alpha= 0.8) + if not makeImageOnly: + io.imshow(image) + io.show() + detections = { + "detections": detections, + "image": image, + "caption": "\n
".join(imcaption) + } + except Exception as e: + print("Unable to show image: "+str(e)) + return detections + +def performBatchDetect(thresh= 0.25, configPath = "./cfg/yolov4.cfg", weightPath = "yolov4.weights", metaPath= "./cfg/coco.data", hier_thresh=.5, nms=.45, batch_size=3): + import cv2 + import numpy as np + # NB! Image sizes should be the same + # You can change the images, yet, be sure that they have the same width and height + img_samples = ['data/person.jpg', 'data/person.jpg', 'data/person.jpg'] + image_list = [cv2.imread(k) for k in img_samples] + + net = load_net_custom(configPath.encode('utf-8'), weightPath.encode('utf-8'), 0, batch_size) + meta = load_meta(metaPath.encode('utf-8')) + pred_height, pred_width, c = image_list[0].shape + net_width, net_height = (network_width(net), network_height(net)) + img_list = [] + for custom_image_bgr in image_list: + custom_image = cv2.cvtColor(custom_image_bgr, cv2.COLOR_BGR2RGB) + custom_image = cv2.resize( + custom_image, (net_width, net_height), interpolation=cv2.INTER_NEAREST) + custom_image = custom_image.transpose(2, 0, 1) + img_list.append(custom_image) + + arr = np.concatenate(img_list, axis=0) + arr = np.ascontiguousarray(arr.flat, dtype=np.float32) / 255.0 + data = arr.ctypes.data_as(POINTER(c_float)) + im = IMAGE(net_width, net_height, c, data) + + batch_dets = network_predict_batch(net, im, batch_size, pred_width, + pred_height, thresh, hier_thresh, None, 0, 0) + batch_boxes = [] + batch_scores = [] + batch_classes = [] + for b in range(batch_size): + num = batch_dets[b].num + dets = batch_dets[b].dets + if nms: + do_nms_obj(dets, num, meta.classes, nms) + boxes = [] + scores = [] + classes = [] + for i in range(num): + det = dets[i] + score = -1 + label = None + for c in range(det.classes): + p = det.prob[c] + if p > score: + score = p + label = c + if score > thresh: + box = det.bbox + left, top, right, bottom = map(int,(box.x - box.w / 2, box.y - box.h / 2, + box.x + box.w / 2, box.y + box.h / 2)) + boxes.append((top, left, bottom, right)) + scores.append(score) + classes.append(label) + boxColor = (int(255 * (1 - (score ** 2))), int(255 * (score ** 2)), 0) + cv2.rectangle(image_list[b], (left, top), + (right, bottom), boxColor, 2) + cv2.imwrite(os.path.basename(img_samples[b]),image_list[b]) + + batch_boxes.append(boxes) + batch_scores.append(scores) + batch_classes.append(classes) + free_batch_detections(batch_dets, batch_size) + return batch_boxes, batch_scores, batch_classes + +if __name__ == "__main__": + print(performDetect()) + #Uncomment the following line to see batch inference working + #print(performBatchDetect()) \ No newline at end of file diff --git a/detect/yolo/darknet_model.py b/detect/yolo/darknet_model.py new file mode 100644 index 0000000..1f88c1b --- /dev/null +++ b/detect/yolo/darknet_model.py @@ -0,0 +1,105 @@ +import sys +from .darknet import load_net_custom, load_meta, make_image, network_width, network_height, copy_image_from_bytes, detect_image +import os +import cv2 + +netMain = None +metaMain = None +altNames = None + +def convertBack(x, y, w, h): + xmin = int(round(x - (w / 2))) + xmax = int(round(x + (w / 2))) + ymin = int(round(y - (h / 2))) + ymax = int(round(y + (h / 2))) + return xmin, ymin, xmax, ymax + +def convert_points(x, y, w, h): + return list(map(int, [x, y, w, h])) + # shameless copy from video example + + xmin, ymin, xmax, ymax = convertBack(float(x), float(y), float(w), float(h)) + pt1 = (xmin, ymin) + pt2 = (xmax, ymax) + + return [xmin, ymin, xmax - xmin, ymax - ymin] + +class DarknetModel(object): + + def __init__(self, configPath, weightPath, metaPath): + global metaMain, netMain, altNames + + if not os.path.exists(configPath): + raise ValueError("Invalid config path `" + + os.path.abspath(configPath)+"`") + if not os.path.exists(weightPath): + raise ValueError("Invalid weight path `" + + os.path.abspath(weightPath)+"`") + if not os.path.exists(metaPath): + raise ValueError("Invalid data file path `" + + os.path.abspath(metaPath)+"`") + if netMain is None: + netMain = load_net_custom(configPath.encode("ascii"), weightPath.encode("ascii"), 0, 1) # batch size = 1 + if metaMain is None: + metaMain = load_meta(metaPath.encode("ascii")) + if altNames is None: + try: + with open(metaPath) as metaFH: + metaContents = metaFH.read() + import re + match = re.search("names *= *(.*)$", metaContents, + re.IGNORECASE | re.MULTILINE) + if match: + result = match.group(1) + else: + result = None + try: + if os.path.exists(result): + with open(result) as namesFH: + namesList = namesFH.read().strip().split("/n") + altNames = [x.strip() for x in namesList] + except TypeError: + pass + except Exception: + pass + + self.darknet_image = make_image(network_width(netMain), network_height(netMain), 3) + + def detect(self, image, verbose=0): + global metaMain, netMain, altNames + + frame_resized = cv2.resize(image, + (network_width(netMain), + network_height(netMain)), + interpolation=cv2.INTER_LINEAR) + + copy_image_from_bytes(self.darknet_image, frame_resized.tobytes()) + detections = detect_image(netMain, metaMain, self.darknet_image, thresh=0.25) + + # ((nameTag, dets[j].prob[i], (b.x, b.y, b.w, b.h) + # res.append((meta.names[i], dets[j].prob[i], (b.x - b.w / 2, b.y - b.h /2, b.w, b.h)))? + detector_output = [{'confidence': prob, 'box': convert_points(x, y, w, h)} for tag, prob, (x, y, w, h) in detections] + results = [1 if x == b'notmask' else 0 for x, _, _ in detections] + + for x, _, _ in detections: + if x != b'notmask' and x != b'mask': + print(x) + raise "this is wrong!" + + return results, detector_output + + +if __name__ == "__main__": + + print(sys.argv[1]) + + configPath = "../../../cfg/yolov3-tiny-masks-small.cfg" + weightPath = "../../../backup-20000/yolov3-tiny-masks-small_last.weights" + metaPath = "faces-20000.data" + + model = DarknetModel(configPath, weightPath, metaPath) + img = cv2.imread(sys.argv[1]) + print(model.detect(img)) + print(model.detect(img)) + print(model.detect(img)) + \ No newline at end of file diff --git a/notebooks/Comparing models.ipynb b/notebooks/Comparing models.ipynb index c8100db..b766b77 100644 --- a/notebooks/Comparing models.ipynb +++ b/notebooks/Comparing models.ipynb @@ -2,14 +2,15 @@ "cells": [ { "cell_type": "code", - "execution_count": 1, + "execution_count": 11, "metadata": {}, "outputs": [ { - "name": "stderr", + "name": "stdout", "output_type": "stream", "text": [ - "Using TensorFlow backend.\n" + "The autoreload extension is already loaded. To reload it, use:\n", + " %reload_ext autoreload\n" ] } ], @@ -26,15 +27,23 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 15, "metadata": {}, "outputs": [], "source": [ - "weights_path = '../weights/model-best.h5'\n", - "masks_detector = mtcnn_simple_cnn(weights_path, object_detector_confidence=0.8)\n", "data_path = '../../od-masks-dataset/od-masks-dev'" ] }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "weights_path = '../weights/model-best.h5'\n", + "masks_detector = mtcnn_simple_cnn(weights_path, object_detector_confidence=0.8)" + ] + }, { "cell_type": "code", "execution_count": 3, @@ -153,6 +162,147 @@ "print(compute_map_from_dataset(data_path, masks_detector, iou_threshold=0.5, verbose=1))" ] }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [], + "source": [ + "import cv2\n", + "from detect.yolo.darknet_model import DarknetModel" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [], + "source": [ + "configPath = \"../../darknet-ab/cfg/yolov3-tiny-masks-small.cfg\"\n", + "weightPath = \"../../darknet-ab/backup-20000/yolov3-tiny-masks-small_last.weights\"\n", + "metaPath = \"faces-20000.data\"\n", + "\n", + "model = DarknetModel(configPath, weightPath, metaPath)" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2020-05-31 00:52:00,362 [INFO] 0 ../../od-masks-dataset/od-masks-dev\\AboA_00274_m_33_i_fr_nc_no_2016_2_e0_nl_o.jpg\n", + "2020-05-31 00:52:03,923 [INFO] 100 ../../od-masks-dataset/od-masks-dev\\AboA_00280_m_33_i_fr_nc_sr_2016_2_e0_Gn_m.jpg\n", + "2020-05-31 00:52:07,464 [INFO] 200 ../../od-masks-dataset/od-masks-dev\\AboA_00286_m_33_i_fr_nc_sr_2016_2_e0_Gn_e.jpg\n", + "2020-05-31 00:52:11,010 [INFO] 300 ../../od-masks-dataset/od-masks-dev\\AheG_00290_m_23_i_nf_nc_no_2008_1_e0_Ps_m.jpg\n", + "2020-05-31 00:52:14,640 [INFO] 400 ../../od-masks-dataset/od-masks-dev\\AheG_00293_m_31_o_fr_nc_no_2016_1_en_nl_m.jpg\n", + "2020-05-31 00:52:18,189 [INFO] 500 ../../od-masks-dataset/od-masks-dev\\AhmA_00297_m_56_o_fr_nc_no_2014_1_e0_Ps_e.jpg\n", + "2020-05-31 00:52:21,704 [INFO] 600 ../../od-masks-dataset/od-masks-dev\\AhmA_00300_m_57_o_nf_nc_no_2015_1_e0_Ps_m.jpg\n", + "2020-05-31 00:52:25,225 [INFO] 700 ../../od-masks-dataset/od-masks-dev\\AhmB_00303_m_28_i_nf_nc_sd_2015_1_em_nl_h.jpg\n", + "2020-05-31 00:52:28,751 [INFO] 800 ../../od-masks-dataset/od-masks-dev\\AhmB_00306_m_29_i_nf_nc_no_2016_1_en_nl_e.jpg\n", + "2020-05-31 00:52:32,313 [INFO] 900 ../../od-masks-dataset/od-masks-dev\\AhmB_00309_m_29_i_nf_nc_hp_2016_1_en_nl_m.jpg\n", + "2020-05-31 00:52:35,980 [INFO] 1000 ../../od-masks-dataset/od-masks-dev\\AhmE_00313_m_24_o_nf_nc_no_2012_1_e0_Gn_h.jpg\n", + "2020-05-31 00:52:39,553 [INFO] 1100 ../../od-masks-dataset/od-masks-dev\\AhmG_00316_m_19_i_fr_nc_no_2015_1_e0_Gs_e.jpg\n", + "2020-05-31 00:52:43,197 [INFO] 1200 ../../od-masks-dataset/od-masks-dev\\AhmG_00319_m_19_o_fr_nc_no_2015_1_e0_Gs_m.jpg\n", + "2020-05-31 00:52:46,769 [INFO] 1300 ../../od-masks-dataset/od-masks-dev\\AhmG_00322_m_19_i_fr_nc_no_2015_1_e0_Ps_e.jpg\n", + "2020-05-31 00:52:50,346 [INFO] 1400 ../../od-masks-dataset/od-masks-dev\\AhmH_00325_m_19_i_nf_nc_no_2015_1_e0_Ps_m.jpg\n", + "2020-05-31 00:52:53,903 [INFO] 1500 ../../od-masks-dataset/od-masks-dev\\AhmI_00329_m_24_i_nf_nc_no_2013_1_e0_Gn_m.jpg\n", + "2020-05-31 00:52:57,466 [INFO] 1600 ../../od-masks-dataset/od-masks-dev\\AhmK_00332_m_25_o_fr_nc_hp_2013_1_e0_Gs_h.jpg\n", + "2020-05-31 00:53:01,079 [INFO] 1700 ../../od-masks-dataset/od-masks-dev\\AhmM_00335_m_19_i_fr_nc_no_2015_1_e0_nl_o.jpg\n", + "2020-05-31 00:53:04,679 [INFO] 1800 ../../od-masks-dataset/od-masks-dev\\AhmM_00338_m_19_i_fr_nc_no_2015_1_e0_Ps_h.jpg\n", + "2020-05-31 00:53:08,258 [INFO] 1900 ../../od-masks-dataset/od-masks-dev\\AhmM_00341_m_19_o_nf_nc_no_2015_1_em_nl_m.jpg\n", + "2020-05-31 00:53:11,907 [INFO] 2000 ../../od-masks-dataset/od-masks-dev\\AhmN_00346_m_27_o_fr_nc_no_2010_1_e0_Gs_h.jpg\n", + "2020-05-31 00:53:15,487 [INFO] 2100 ../../od-masks-dataset/od-masks-dev\\AhmN_00349_m_27_o_nf_nc_no_2010_1_e0_Ps_h.jpg\n", + "2020-05-31 00:53:19,117 [INFO] 2200 ../../od-masks-dataset/od-masks-dev\\AhmS_00352_m_20_o_nf_nc_hp_2015_1_em_nl_e.jpg\n", + "2020-05-31 00:53:22,740 [INFO] 2300 ../../od-masks-dataset/od-masks-dev\\AhmS_00355_m_20_i_fr_nc_no_2015_1_em_nl_m.jpg\n", + "2020-05-31 00:53:26,347 [INFO] 2400 ../../od-masks-dataset/od-masks-dev\\AhmZ_00358_m_21_i_fr_nc_no_2015_1_en_nl_h.jpg\n", + "2020-05-31 00:53:30,040 [INFO] 2500 ../../od-masks-dataset/od-masks-dev\\AhmZ_00362_m_21_i_fr_nc_no_2015_1_e0_Gn_m.jpg\n", + "2020-05-31 00:53:33,655 [INFO] 2600 ../../od-masks-dataset/od-masks-dev\\AhmZ_00365_m_21_i_fr_nc_no_2015_1_e0_Gs_m.jpg\n", + "2020-05-31 00:53:37,293 [INFO] 2700 ../../od-masks-dataset/od-masks-dev\\AlaG_00370_m_32_i_nf_nc_no_2016_2_e0_Ps_e.jpg\n", + "2020-05-31 00:53:40,868 [INFO] 2800 ../../od-masks-dataset/od-masks-dev\\AlaG_00374_m_32_i_fr_nc_hp_2016_2_e0_nl_o.jpg\n", + "2020-05-31 00:53:44,506 [INFO] 2900 ../../od-masks-dataset/od-masks-dev\\AlaG_00379_m_32_i_fr_nc_hp_2016_2_em_nl_e.jpg\n", + "2020-05-31 00:53:48,105 [INFO] 3000 ../../od-masks-dataset/od-masks-dev\\AlaG_00384_m_32_i_fr_nc_sr_2016_2_e0_Gs_e.jpg\n", + "2020-05-31 00:53:51,704 [INFO] 3100 ../../od-masks-dataset/od-masks-dev\\AlaG_00388_m_32_i_fr_nc_sr_2016_2_em_nl_m.jpg\n", + "2020-05-31 00:53:55,290 [INFO] 3200 ../../od-masks-dataset/od-masks-dev\\AlaG_00393_m_32_i_nf_nc_hp_2016_2_e0_Gn_m.jpg\n", + "2020-05-31 00:53:58,906 [INFO] 3300 ../../od-masks-dataset/od-masks-dev\\AlaG_00397_m_32_i_nf_nc_no_2016_2_en_nl_e.jpg\n", + "2020-05-31 00:54:02,522 [INFO] 3400 ../../od-masks-dataset/od-masks-dev\\AlaG_00401_m_32_i_fr_nc_no_2016_2_en_nl_e.jpg\n", + "2020-05-31 00:54:06,134 [INFO] 3500 ../../od-masks-dataset/od-masks-dev\\AlaG_00406_m_32_i_fr_nc_no_2016_2_e0_Gn_h.jpg\n", + "2020-05-31 00:54:09,765 [INFO] 3600 ../../od-masks-dataset/od-masks-dev\\AlaG_00409_m_32_i_fr_nc_no_2016_2_e0_Gs_h.jpg\n", + "2020-05-31 00:54:13,390 [INFO] 3700 ../../od-masks-dataset/od-masks-dev\\AlaG_00413_m_32_i_fr_nc_no_2016_2_e0_Gs_e.jpg\n", + "2020-05-31 00:54:17,087 [INFO] 3800 ../../od-masks-dataset/od-masks-dev\\AlaG_00417_m_32_i_fr_nc_hp_2016_2_e0_Gs_m.jpg\n", + "2020-05-31 00:54:20,728 [INFO] 3900 ../../od-masks-dataset/od-masks-dev\\AlaG_00420_m_32_i_fr_nc_hp_2016_2_em_nl_h.jpg\n", + "2020-05-31 00:54:24,420 [INFO] 4000 ../../od-masks-dataset/od-masks-dev\\AlaG_00424_m_32_i_fr_nc_hp_2016_2_en_nl_m.jpg\n", + "2020-05-31 00:54:28,068 [INFO] 4100 ../../od-masks-dataset/od-masks-dev\\AlaG_00429_m_32_i_fr_nc_sr_2016_2_e0_Gs_h.jpg\n", + "2020-05-31 00:54:31,892 [INFO] 4200 ../../od-masks-dataset/od-masks-dev\\AlaG_00433_m_32_i_fr_nc_sr_2016_2_e0_Gn_h.jpg\n", + "2020-05-31 00:54:35,606 [INFO] 4300 ../../od-masks-dataset/od-masks-dev\\AlaG_00436_m_32_i_fr_nc_no_2016_2_em_nl_e.jpg\n", + "2020-05-31 00:54:39,385 [INFO] 4400 ../../od-masks-dataset/od-masks-dev\\AlaG_00440_m_32_i_nf_nc_no_2016_2_em_nl_e.jpg\n", + "2020-05-31 00:54:43,393 [INFO] 4500 ../../od-masks-dataset/od-masks-dev\\test_00000034.jpg\n", + "2020-05-31 00:54:47,989 [INFO] 4600 ../../od-masks-dataset/od-masks-dev\\test_00000084.jpg\n", + "2020-05-31 00:54:51,918 [INFO] 4700 ../../od-masks-dataset/od-masks-dev\\test_00000134.jpg\n", + "2020-05-31 00:54:55,686 [INFO] 4800 ../../od-masks-dataset/od-masks-dev\\test_00000184.jpg\n", + "2020-05-31 00:54:59,367 [INFO] 4900 ../../od-masks-dataset/od-masks-dev\\test_00000234.jpg\n", + "2020-05-31 00:55:03,050 [INFO] 5000 ../../od-masks-dataset/od-masks-dev\\test_00000284.jpg\n", + "2020-05-31 00:55:06,718 [INFO] 5100 ../../od-masks-dataset/od-masks-dev\\test_00000334.jpg\n", + "2020-05-31 00:55:10,438 [INFO] 5200 ../../od-masks-dataset/od-masks-dev\\test_00000384.jpg\n", + "2020-05-31 00:55:14,452 [INFO] 5300 ../../od-masks-dataset/od-masks-dev\\test_00000434.jpg\n", + "2020-05-31 00:55:18,509 [INFO] 5400 ../../od-masks-dataset/od-masks-dev\\test_00000484.jpg\n", + "2020-05-31 00:55:22,547 [INFO] 5500 ../../od-masks-dataset/od-masks-dev\\test_00000534.jpg\n", + "2020-05-31 00:55:26,429 [INFO] 5600 ../../od-masks-dataset/od-masks-dev\\test_00000584.jpg\n", + "2020-05-31 00:55:30,329 [INFO] 5700 ../../od-masks-dataset/od-masks-dev\\test_00000634.jpg\n", + "2020-05-31 00:55:34,345 [INFO] 5800 ../../od-masks-dataset/od-masks-dev\\test_00000684.jpg\n", + "2020-05-31 00:55:38,557 [INFO] 5900 ../../od-masks-dataset/od-masks-dev\\test_00000734.jpg\n", + "2020-05-31 00:55:42,615 [INFO] 6000 ../../od-masks-dataset/od-masks-dev\\test_00000784.jpg\n", + "2020-05-31 00:55:46,671 [INFO] 6100 ../../od-masks-dataset/od-masks-dev\\test_00000834.jpg\n", + "2020-05-31 00:55:50,874 [INFO] 6200 ../../od-masks-dataset/od-masks-dev\\test_00000884.jpg\n", + "2020-05-31 00:55:54,942 [INFO] 6300 ../../od-masks-dataset/od-masks-dev\\test_00000934.jpg\n", + "2020-05-31 00:55:59,199 [INFO] 6400 ../../od-masks-dataset/od-masks-dev\\test_00000984.jpg\n", + "2020-05-31 00:56:03,336 [INFO] 6500 ../../od-masks-dataset/od-masks-dev\\test_00001034.jpg\n", + "2020-05-31 00:56:07,644 [INFO] 6600 ../../od-masks-dataset/od-masks-dev\\test_00001084.jpg\n", + "2020-05-31 00:56:12,038 [INFO] 6700 ../../od-masks-dataset/od-masks-dev\\test_00001134.jpg\n", + "2020-05-31 00:56:16,459 [INFO] 6800 ../../od-masks-dataset/od-masks-dev\\test_00001184.jpg\n", + "2020-05-31 00:56:20,786 [INFO] 6900 ../../od-masks-dataset/od-masks-dev\\test_00001234.jpg\n", + "2020-05-31 00:56:25,205 [INFO] 7000 ../../od-masks-dataset/od-masks-dev\\test_00001284.jpg\n", + "2020-05-31 00:56:29,707 [INFO] 7100 ../../od-masks-dataset/od-masks-dev\\test_00001334.jpg\n", + "2020-05-31 00:56:34,649 [INFO] 7200 ../../od-masks-dataset/od-masks-dev\\test_00001384.jpg\n", + "2020-05-31 00:56:39,286 [INFO] 7300 ../../od-masks-dataset/od-masks-dev\\test_00001434.jpg\n", + "2020-05-31 00:56:43,896 [INFO] 7400 ../../od-masks-dataset/od-masks-dev\\test_00001484.jpg\n", + "2020-05-31 00:56:48,412 [INFO] 7500 ../../od-masks-dataset/od-masks-dev\\test_00001534.jpg\n", + "2020-05-31 00:56:52,985 [INFO] 7600 ../../od-masks-dataset/od-masks-dev\\test_00001584.jpg\n", + "2020-05-31 00:56:57,559 [INFO] 7700 ../../od-masks-dataset/od-masks-dev\\test_00001634.jpg\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2020-05-31 00:57:02,172 [INFO] 7800 ../../od-masks-dataset/od-masks-dev\\test_00001684.jpg\n", + "2020-05-31 00:57:06,763 [INFO] 7900 ../../od-masks-dataset/od-masks-dev\\test_00001734.jpg\n", + "2020-05-31 00:57:11,399 [INFO] 8000 ../../od-masks-dataset/od-masks-dev\\test_00001784.jpg\n", + "2020-05-31 00:57:15,957 [INFO] 8100 ../../od-masks-dataset/od-masks-dev\\test_00001834.jpg\n", + "2020-05-31 00:57:20,527 [INFO] 8200 ../../od-masks-dataset/od-masks-dev\\test_00001884.jpg\n", + "2020-05-31 00:57:25,197 [INFO] 8300 ../../od-masks-dataset/od-masks-dev\\test_00001934.jpg\n", + "2020-05-31 00:57:29,761 [INFO] 8400 ../../od-masks-dataset/od-masks-dev\\test_00001984.jpg\n", + "2020-05-31 00:57:34,330 [INFO] 8500 ../../od-masks-dataset/od-masks-dev\\test_00002034.jpg\n", + "2020-05-31 00:57:38,906 [INFO] 8600 ../../od-masks-dataset/od-masks-dev\\test_00002084.jpg\n", + "2020-05-31 00:57:43,499 [INFO] 8700 ../../od-masks-dataset/od-masks-dev\\test_00002134.jpg\n", + "2020-05-31 00:57:48,133 [INFO] 8800 ../../od-masks-dataset/od-masks-dev\\test_00002184.jpg\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.01759154397885995\n" + ] + } + ], + "source": [ + "print(compute_map_from_dataset(data_path, model, iou_threshold=0.5, verbose=1))" + ] + }, { "cell_type": "code", "execution_count": null, diff --git a/notebooks/detector.ipynb b/notebooks/detector.ipynb index 42db85d..84da190 100644 --- a/notebooks/detector.ipynb +++ b/notebooks/detector.ipynb @@ -353,7 +353,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 6, "metadata": { "scrolled": true }, @@ -362,258 +362,18 @@ "name": "stdout", "output_type": "stream", "text": [ - "0.8274107575416565\n", - "0.8274107575416565\n", - "0.8274107575416565\n", - "0.8274107575416565\n", - "0.8274107575416565\n", - "0.8274107575416565\n", - "0.8274107575416565\n", - "0.8274107575416565\n", - "0.8274107575416565\n", - "0.8274107575416565\n", - "0.8274107575416565\n", - "0.8274107575416565\n", - "0.9908871650695801\n", - "0.9908871650695801\n", - "0.9908871650695801\n", - "0.9908871650695801\n", - "0.9908871650695801\n", - "0.9908871650695801\n", - "0.9908871650695801\n", - "0.9908871650695801\n", - "0.9908871650695801\n", - "0.9908871650695801\n", - "0.9908871650695801\n", - "0.9908871650695801\n", - "0.9513422846794128\n", - "0.9513422846794128\n", - "0.9513422846794128\n", - "0.9513422846794128\n", - "0.9513422846794128\n", - "0.9513422846794128\n", - "0.9513422846794128\n", - "0.9513422846794128\n", - "0.9513422846794128\n", - "0.9513422846794128\n", - "0.9513422846794128\n", - "0.9513422846794128\n", - "0.99628084897995\n", - "0.99628084897995\n", - "0.99628084897995\n", - "0.99628084897995\n", - "0.99628084897995\n", - "0.99628084897995\n", - "0.99628084897995\n", - "0.99628084897995\n", - "0.99628084897995\n", - "0.99628084897995\n", - "0.99628084897995\n", - "0.99628084897995\n", - "0.9996287822723389\n", - "0.9996287822723389\n", - "0.9996287822723389\n", - "0.9996287822723389\n", - "0.9996287822723389\n", - "0.9996287822723389\n", - "0.9996287822723389\n", - "0.9996287822723389\n", - "0.9996287822723389\n", - "0.9996287822723389\n", - "0.9996287822723389\n", - "0.9996287822723389\n", - "0.9999793767929077\n", - "0.9999793767929077\n", - "0.9999793767929077\n", - "0.9999793767929077\n", - "0.9999793767929077\n", - "0.9999793767929077\n", - "0.9999793767929077\n", - "0.9999793767929077\n", - "0.9999793767929077\n", - "0.9999793767929077\n", - "0.9999793767929077\n", - "0.9999793767929077\n", - "0.9961273074150085\n", - "0.9961273074150085\n", - "0.9961273074150085\n", - "0.9961273074150085\n", - "0.9961273074150085\n", - "0.9961273074150085\n", - "0.9961273074150085\n", - "0.9961273074150085\n", - "0.9961273074150085\n", - "0.9961273074150085\n", - "0.9961273074150085\n", - "0.9961273074150085\n", - "0.9955757856369019\n", - "0.9955757856369019\n", - "0.9955757856369019\n", - "0.9955757856369019\n", - "0.9955757856369019\n", - "0.9955757856369019\n", - "0.9955757856369019\n", - "0.9955757856369019\n", - "0.9955757856369019\n", - "0.9955757856369019\n", - "0.9955757856369019\n", - "0.9955757856369019\n", - "0.9628413319587708\n", - "0.9628413319587708\n", - "0.9628413319587708\n", - "0.9628413319587708\n", - "0.9628413319587708\n", - "0.9628413319587708\n", - "0.9628413319587708\n", - "0.9628413319587708\n", - "0.9628413319587708\n", - "0.9628413319587708\n", - "0.9628413319587708\n", - "0.9628413319587708\n", - "0.9484645128250122\n", - "0.9484645128250122\n", - "0.9484645128250122\n", - "0.9484645128250122\n", - "0.9484645128250122\n", - "0.9484645128250122\n", - "0.9484645128250122\n", - "0.9484645128250122\n", - "0.9484645128250122\n", - "0.9484645128250122\n", - "0.9484645128250122\n", - "0.9484645128250122\n", - "0.971864640712738\n", - "0.971864640712738\n", - "0.971864640712738\n", - "0.971864640712738\n", - "0.971864640712738\n", - "0.971864640712738\n", - "0.971864640712738\n", - "0.971864640712738\n", - "0.971864640712738\n", - "0.971864640712738\n", - "0.971864640712738\n", - "0.971864640712738\n", - "0.971889853477478\n", - "0.971889853477478\n", - "0.971889853477478\n", - "0.971889853477478\n", - "0.971889853477478\n", - "0.971889853477478\n", - "0.971889853477478\n", - "0.971889853477478\n", - "0.971889853477478\n", - "0.971889853477478\n", - "0.971889853477478\n", - "0.971889853477478\n", - "0.9442935585975647\n", - "0.9442935585975647\n", - "0.9442935585975647\n", - "0.9442935585975647\n", - "0.9442935585975647\n", - "0.9442935585975647\n", - "0.9442935585975647\n", - "0.9442935585975647\n", - "0.9442935585975647\n", - "0.9442935585975647\n", - "0.9442935585975647\n", - "0.9442935585975647\n", - "0.9767395257949829\n", - "0.9767395257949829\n", - "0.9767395257949829\n", - "0.9767395257949829\n", - "0.9767395257949829\n", - "0.9767395257949829\n", - "0.9767395257949829\n", - "0.9767395257949829\n", - "0.9767395257949829\n", - "0.9767395257949829\n", - "0.9767395257949829\n", - "0.9767395257949829\n", - "0.9992877840995789\n", - "0.9992877840995789\n", - "0.9992877840995789\n", - "0.9992877840995789\n", - "0.9992877840995789\n", - "0.9992877840995789\n", - "0.9992877840995789\n", - "0.9992877840995789\n", - "0.9992877840995789\n", - "0.9992877840995789\n", - "0.9992877840995789\n", - "0.9992877840995789\n", - "0.9328868389129639\n", - "0.9328868389129639\n", - "0.9328868389129639\n", - "0.9328868389129639\n", - "0.9328868389129639\n", - "0.9328868389129639\n", - "0.9328868389129639\n", - "0.9328868389129639\n", - "0.9328868389129639\n", - "0.9328868389129639\n", - "0.9328868389129639\n", - "0.9328868389129639\n", - "0.876582145690918\n", - "0.876582145690918\n", - "0.876582145690918\n", - "0.876582145690918\n", - "0.876582145690918\n", - "0.876582145690918\n", - "0.876582145690918\n", - "0.876582145690918\n", - "0.876582145690918\n", - "0.876582145690918\n", - "0.876582145690918\n", - "0.876582145690918\n", - "0.9418603777885437\n", - "0.9418603777885437\n", - "0.9418603777885437\n", - "0.9418603777885437\n", - "0.9418603777885437\n", - "0.9418603777885437\n", - "0.9418603777885437\n", - "0.9418603777885437\n", - "0.9418603777885437\n", - "0.9418603777885437\n", - "0.9418603777885437\n", - "0.9418603777885437\n", - "0.9834458231925964\n", - "0.9834458231925964\n", - "0.9834458231925964\n", - "0.9834458231925964\n", - "0.9834458231925964\n", - "0.9834458231925964\n", - "0.9834458231925964\n", - "0.9834458231925964\n", - "0.9834458231925964\n", - "0.9834458231925964\n", - "0.9834458231925964\n", - "0.9834458231925964\n", - "0.9960649609565735\n", - "0.9960649609565735\n", - "0.9960649609565735\n", - "0.9960649609565735\n", - "0.9960649609565735\n", - "0.9960649609565735\n", - "0.9960649609565735\n", - "0.9960649609565735\n", - "0.9960649609565735\n", - "0.9960649609565735\n", - "0.9960649609565735\n", - "0.9960649609565735\n", - "0.9992592930793762\n", - "0.9992592930793762\n", - "0.9992592930793762\n", - "0.9992592930793762\n", - "0.9992592930793762\n", - "0.9992592930793762\n", - "0.9992592930793762\n", - "0.9992592930793762\n", - "0.9992592930793762\n", - "0.9992592930793762\n", - "0.9992592930793762\n", - "0.9992592930793762\n" + "529 212 562 261 \n", + "529 212 562 261 \n", + "529 212 562 261 \n", + "529 212 562 261 \n", + "529 212 562 261 \n", + "529 212 562 261 \n", + "529 212 562 261 \n", + "529 212 562 261 \n", + "529 212 562 261 \n", + "529 212 562 261 \n", + "529 212 562 261 \n", + "529 212 562 261 \n" ] } ], @@ -648,7 +408,7 @@ " results, faces_detector_output = masks_detector.detect(frame_to_detect, verbose=0)\n", "\n", " for p, data in zip(results, faces_detector_output):\n", - " print(data['confidence'])\n", + " #print(data['confidence'])\n", " x, y, w, h = data['box']\n", " x1 = x + w\n", " y1 = y + h\n", @@ -684,22 +444,97 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "import cv2\n", + "from detect.yolo.darknet_model import DarknetModel\n", + "\n", + "configPath = \"../../darknet-ab/cfg/yolov3-tiny-masks-small.cfg\"\n", + "weightPath = \"../../darknet-ab/backup-20000/yolov3-tiny-masks-small_1000.weights\"\n", + "metaPath = \"faces-20000.data\"\n", + "\n", + "masks_detector = DarknetModel(configPath, weightPath, metaPath)\n", + "\n", + "#video_path = '../samples/wear_masks_240p.mp4'\n", + "video_path = '../data/videos/wear_masks_720p.mp4'\n", + "\n", + "# Initiate video capture for video file, here we are using the video file in which pedestrians would be detected\n", + "cap = cv2.VideoCapture(video_path)\n", + "\n", + "font = cv2.FONT_HERSHEY_SIMPLEX\n", + "fontScale = 1\n", + "fontColor = (255,255,255)\n", + "lineType = 2\n", + "frame_n = 0\n", + "frame_rate = 12\n", + "# Loop once video is successfully loaded\n", + "while cap.isOpened():\n", + "\n", + " # Reading the each frame of the video \n", + " ret, frame = cap.read()\n", + "\n", + " # Resize the frame\n", + " frame = cv2.resize(frame, None,fx=0.5, fy=0.5, interpolation = cv2.INTER_LINEAR)\n", + " \n", + " if frame_n % frame_rate == 0:\n", + " frame_to_detect = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)\n", + " results, faces_detector_output = masks_detector.detect(frame_to_detect, verbose=0)\n", + "\n", + " for p, data in zip(results, faces_detector_output):\n", + " x, y, w, h = data['box']\n", + " x1 = x + w\n", + " y1 = y + h\n", + " \n", + " mask = p == 0\n", + " color = (0, 255, 0) if mask else (255, 0, 0)\n", + " cv2.rectangle(img=frame, pt1=(x, y), pt2=(x1, y1), color=color)\n", + " \n", + " if 'keypoints' in data:\n", + " r = 5\n", + " cv2.circle(frame, data['keypoints']['left_eye'], r, (0, 0, 255))\n", + " cv2.circle(frame, data['keypoints']['right_eye'], r, (0, 0, 255))\n", + " cv2.circle(frame, data['keypoints']['nose'], r, (0, 0, 255))\n", + " cv2.circle(frame, data['keypoints']['mouth_left'], r, (0, 0, 255))\n", + " cv2.circle(frame, data['keypoints']['mouth_right'], r, (0, 0, 255))\n", + "\n", + " cv2.putText(frame, 'Mask' if mask else 'Not mask', \n", + " (x, y), \n", + " font, \n", + " fontScale,\n", + " fontColor,\n", + " lineType)\n", + " \n", + " cv2.imshow('Mask Detection', frame)\n", + " frame_n += 1\n", + " \n", + " # Wait for Esc key to stop \n", + " if cv2.waitKey(33) == 27: \n", + " break\n", + "\n", + "cap.release()\n", + "cv2.destroyAllWindows()" + ] + }, + { + "cell_type": "code", + "execution_count": 3, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "'model-best.h5'" + "'4.2.0'" ] }, - "execution_count": 13, + "execution_count": 3, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "weights_file_name" + "cv2.__version__" ] }, { @@ -726,7 +561,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.7.4" + "version": "3.7.7" } }, "nbformat": 4, diff --git a/notebooks/faces-20000.data b/notebooks/faces-20000.data new file mode 100644 index 0000000..4305ecf --- /dev/null +++ b/notebooks/faces-20000.data @@ -0,0 +1,5 @@ +classes= 2 +train = train-20000.txt +valid = dev.txt +names = faces.names +backup = backup-20000 diff --git a/notebooks/faces.names b/notebooks/faces.names new file mode 100644 index 0000000..b2c2cbb --- /dev/null +++ b/notebooks/faces.names @@ -0,0 +1,2 @@ +mask +notmask \ No newline at end of file