yolo_v2_gui using gradio blocks

app.py

@@ -0,0 +1,91 @@
+import cv2
+import numpy as np
+import matplotlib.pyplot as plt
+from matplotlib.patches import Rectangle
+from load_model import load_model
+from decode_yolo_v2 import *
+from config import *
+import gradio as gr
+import json
+from glob import glob
+
+
+
+model=load_model("yolo_v2(iou_70.5945).h5")
+
+
+def get_preds(test_img,p=0.2,iou_threshold=0.3):
+    img=cv2.resize(cv2.cvtColor(cv2.imread(test_img),cv2.COLOR_BGR2RGB),[image_size,image_size])
+    img=np.expand_dims(img,axis=0)
+    y_pred=model.predict(img)
+
+
+    objs_found=get_objects(y_pred[0],p=p)
+    objs_found=nms(objs_found,iou_threshold=iou_threshold)
+    print("objs_found:",objs_found)
+    plt.axis('off')
+    # show_objects(img[0],objs_found)
+    img=pred_image(img[0],objs_found)
+    plt.imshow(img)
+    plt.show()
+
+# get_preds(input("Enter image path:"))
+# get_preds("C:/Users/Home/Downloads/image_2.jpeg")
+
+def get_output(img,p,iou_threshold):
+    h,w=img.shape[:2]
+    img=cv2.resize(img,[image_size,image_size])
+    img=np.expand_dims(img,axis=0)
+    y_pred=model.predict(img,verbose=0)
+
+
+    objs_found=get_objects(y_pred[0],p=p)
+    objs_found=nms(objs_found,iou_threshold=iou_threshold)
+    # print("objs_found:",objs_found)
+    img=pred_image(img[0],objs_found)
+    img=cv2.resize(img,[w,h])
+    return img,json.dumps({'objects_found':objs_found})
+
+
+def toggle_webcam(x):
+    if x=='upload':
+        input_image.source='upload'
+        return {'value':None,'streaming':False,'source':'upload','__type__': 'update'}
+    else:
+        input_image.source='webcam'
+        return {'value':None,'streaming':True,'source':'webcam','__type__': 'update'}
+
+def clear_all(x):
+        out_img.unrender()
+        return {'value':None,'__type__': 'update'}
+    
+with gr.Blocks(title="Yolo V2 Object detection") as app:
+    
+    with gr.Column():
+        # gr.Markdown("# Yolo V2 Object detection")
+        gr.Markdown("<h1 style=\"text-align: center;\">Yolo V2 Object detection</h1>")
+        gr.Markdown(f"we can detection 20 type of objects which are: {', '.join(class_names)}")
+    with gr.Row():
+        with gr.Box():
+            input_image=gr.Image(value=None,interactive=True)
+            with gr.Row():
+                radio_btn=gr.Radio(['upload','webcam'],value='upload',interactive=True)
+
+            conf_slider=gr.Slider(0,1,value=0.2,label='min_confidence',interactive=True)
+            nms_slider=gr.Slider(0,1,value=0.3,label='nms_iou_threshold',interactive=True)
+            
+            with gr.Row():
+                reset_btn=gr.Button('reset',visible=False)
+                submit=gr.Button('submit')
+        with gr.Box():
+            with gr.Column():
+                out_img=gr.Image(label='objects_found',interactive=False)
+                out_labels=gr.JSON(label='objects_found',interactive=False)
+
+
+    
+    # reset_btn.click(clear_all,reset_btn,out_img)
+    radio_btn.change(toggle_webcam,radio_btn,input_image)
+    submit.click(get_output,[input_image,conf_slider,nms_slider],[out_img,out_labels])
+
+app.launch()

config.py

@@ -0,0 +1,17 @@
+import numpy as np
+image_size=416
+num_anchors=4
+output_size=image_size/32
+class_names=['aeroplane', 'bicycle', 'bird', 'boat', 'bottle', 'bus', 'car', 'cat', 'chair', 'cow', 'diningtable', 'dog', 'horse', 'motorbike', 'person', 'pottedplant', 'sheep', 'sofa', 'train', 'tvmonitor']
+class_colors={class_name:np.random.rand(3) for class_name in class_names}
+
+
+anchor_boxes = np.array( [[1.07709888,  1.78171903],  # anchor box 1, width , height
+                       [2.71054693,  5.12469308],  # anchor box 2, width,  height
+                       [10.47181473, 10.09646365],  # anchor box 3, width,  height
+                       [5.48531347,  8.11011331]] ,dtype='float32')
+
+
+cell_size=image_size/output_size
+class_to_idx={class_name:i for i,class_name in enumerate(class_names)}
+idx_to_class={i:class_name for i,class_name in enumerate(class_names)}

decode_yolo_v2.py

@@ -0,0 +1,109 @@
+import numpy as np
+import matplotlib.pyplot as plt
+from matplotlib.patches import Rectangle
+import copy
+import tensorflow.keras.backend as K
+from config import *
+import cv2
+
+
+tf_anchors=K.reshape(K.variable(anchor_boxes),[1, 1, 1, num_anchors, 2])
+
+def get_objects(y_pred,p=0.5,decode_preds=True,idx=None):
+  y_pred=copy.deepcopy(y_pred)
+  if decode_preds:
+    y_pred[...,0]=K.sigmoid(y_pred[...,0])
+    y_pred[...,3:5]=np.clip((K.exp(y_pred[...,3:5])*tf_anchors).numpy(),0,output_size)
+  # y_pred[...,3:5]=np.clip(y_pred[...,3:5],0,output_size)
+  objs_found=[]
+  idxs=np.where(y_pred[...,0]>=p)
+  if np.size(idxs):
+    for i,obj in enumerate(y_pred[idxs[0],idxs[1],idxs[2],:]):
+      # obj (p,x,y,w,h,c_1,c_2,c_3,c_4,c_5.......c_n)
+      if decode_preds:
+        obj[1:3]=K.sigmoid(obj[1:3]) # x,y
+    
+      prob=obj[0]
+      obj=obj[1:]
+      # obj[4]=np.argmax(K.softmax(obj[4:]))
+      obj[4]=np.argmax(obj[4:])
+      obj=obj[:5]
+      obj[:-1]*=cell_size # scaling back w and h
+
+      obj[0]=(idxs[1][i]*cell_size)+obj[0]  # center x
+      obj[1]=(idxs[0][i]*cell_size)+obj[1]  # center y
+
+      obj[0]=np.clip(obj[0]-(obj[2]/2),0,image_size)  # xmin
+      obj[1]=np.clip(obj[1]-(obj[3]/2),0,image_size)  # ymin
+      
+      
+      obj_name=idx_to_class[obj[4]]
+      
+      # plt.gca().add_patch(Rectangle((obj[0],obj[1]),(obj[2]),(obj[3]),linewidth=4,edgecolor=class_colors[obj_name],facecolor='none'))
+      # plt.text(obj[0],obj[1],obj_name)
+      
+      obj_details={'p':float(prob),'xywh':obj[:-1].astype(int).tolist(),'class_idx':int(obj[4]),'class':obj_name}
+    
+      if idx is not None:obj_details['idx']=idx
+      objs_found.append(obj_details)
+  objs_found=sorted(objs_found,key=lambda x:x['p'],reverse=True)
+  return objs_found
+
+def list_get_iou(bboxes1, bboxes2):
+
+    bboxes1 = [bboxes1[0],bboxes1[1],bboxes1[0]+bboxes1[2],bboxes1[1]+bboxes1[3]]
+    bboxes2 = [bboxes2[0],bboxes2[1],bboxes2[0]+bboxes2[2],bboxes2[1]+bboxes2[3]]
+
+    xA = max(bboxes1[0], bboxes2[0])
+    yA = max(bboxes1[1], bboxes2[1])
+    xB = min(bboxes1[2], bboxes2[2])
+    yB = min(bboxes1[3], bboxes2[3])
+
+    intersection_area = max(0, xB - xA ) * max(0, yB - yA )
+
+    box1_area = (bboxes1[2] - bboxes1[0] ) * (bboxes1[3] - bboxes1[1] )
+    box2_area = (bboxes2[2] - bboxes2[0] ) * (bboxes2[3] - bboxes2[1] )
+
+    iou = intersection_area / float(box1_area + box2_area - intersection_area+1e-6)
+
+    return iou
+
+def nms(objs_found,iou_threshold=0.2):
+  objs_found=np.array(copy.deepcopy(objs_found))
+  best_boxes=[]
+  while len(objs_found)>0:
+    obj=objs_found[0]
+    objs_found=objs_found[1:]
+
+    delete_idx=[]
+    for b_idx,b in enumerate(objs_found):
+
+      if obj['class_idx']==b['class_idx']:
+        iou=list_get_iou(obj['xywh'],b['xywh'])
+        if iou>= iou_threshold:
+          delete_idx.append(b_idx)
+    objs_found=np.delete(objs_found,delete_idx)
+    best_boxes.append(obj)
+  return best_boxes
+
+def show_objects(img,objs_found,return_img=False):
+  plt.imshow(img)
+  for i in range(len(objs_found)):  
+    p=objs_found[i]['p']
+    obj=objs_found[i]['xywh']
+    obj_name=objs_found[i]['class']
+    plt.gca().add_patch(Rectangle((obj[0],obj[1]),(obj[2]),(obj[3]),linewidth=4,edgecolor=class_colors[obj_name],facecolor='none'))
+    plt.text(obj[0],obj[1],obj_name)
+
+
+
+def pred_image(img,objs_found):
+  for i in range(len(objs_found)):  
+    p=objs_found[i]['p']
+    obj=objs_found[i]['xywh']
+    obj_name=objs_found[i]['class']
+    
+    img=cv2.rectangle(img,(int(obj[0]),int(obj[1])),(int(obj[0]+obj[2]),int(obj[1]+obj[3])),(class_colors[obj_name]*255),4)
+    img=cv2.putText(img,obj_name,(int(obj[0]),int(obj[1])),cv2.FONT_HERSHEY_SIMPLEX,1, (0,0,0), 2, lineType=cv2.LINE_AA)
+    # draw_text(img, "world", font_scale=4, pos=(10, 20 + h), text_color_bg=(255, 0, 0))
+  return img

load_model.py

@@ -0,0 +1,137 @@
+import os
+import tensorflow as tf
+from config import *
+from tensorflow.keras import Model,layers
+
+os.environ['CUDA_VISIBLE_DEVICES'] = '-1'
+# custom layer for reshaping last layer
+
+class yolo_dynamic_reshape(tf.keras.layers.Layer):
+  def __init__(self, **kwargs):
+    super(yolo_dynamic_reshape,self).__init__()
+    self.scaler=32
+    self.last_item=(5+len(class_names))
+  def call(self,input_layer,output_layer):
+    # print(input_layer.shape)
+    if input_layer.shape[1] is not None:
+      return layers.Reshape(((input_layer.shape[1]//self.scaler),(input_layer.shape[2]//self.scaler),num_anchors,self.last_item))(output_layer)
+    return layers.Reshape((0,0,num_anchors,self.last_item))(output_layer)
+
+def create_model():
+
+    def space_to_depth_x2(x):
+        return tf.nn.space_to_depth(x,block_size=2)
+
+    x_input=layers.Input(shape=(416,416,3))
+    x=layers.Lambda(lambda x:x/255.)(x_input)
+    x=layers.Conv2D(32,(3,3),strides=(1,1),padding='same',name='conv_1',use_bias=False)(x)
+    x=layers.BatchNormalization(name='norm_1')(x)
+    x=layers.LeakyReLU(alpha=0.1)(x)
+    x=layers.MaxPooling2D(pool_size=(2,2))(x)
+
+    x=layers.Conv2D(64,(3,3),strides=(1,1),padding='same',name='conv_2',use_bias=False)(x)
+    x=layers.BatchNormalization(name='norm_2')(x)
+    x=layers.LeakyReLU(alpha=0.1)(x)
+    x=layers.MaxPooling2D(pool_size=(2,2))(x)
+
+    x=layers.Conv2D(128,(3,3),strides=(1,1),padding='same',name='conv_3',use_bias=False)(x)
+    x=layers.BatchNormalization(name='norm_3')(x)
+    x=layers.LeakyReLU(alpha=0.1)(x)
+
+    x=layers.Conv2D(64,(1,1),strides=(1,1),padding='same',name='conv_4',use_bias=False)(x)
+    x=layers.BatchNormalization(name='norm_4')(x)
+    x=layers.LeakyReLU(alpha=0.1)(x)
+
+    x=layers.Conv2D(128,(3,3),strides=(1,1),padding='same',name='conv_5',use_bias=False)(x)
+    x=layers.BatchNormalization(name='norm_5')(x)
+    x=layers.LeakyReLU(alpha=0.1)(x)
+    x=layers.MaxPooling2D(pool_size=(2,2))(x)
+
+    x=layers.Conv2D(256,(3,3),strides=(1,1),padding='same',name='conv_6',use_bias=False)(x)
+    x=layers.BatchNormalization(name='norm_6')(x)
+    x=layers.LeakyReLU(alpha=0.1)(x)
+
+    x=layers.Conv2D(128,(1,1),strides=(1,1),padding='same',name='conv_7',use_bias=False)(x)
+    x=layers.BatchNormalization(name='norm_7')(x)
+    x=layers.LeakyReLU(alpha=0.1)(x)
+
+    x=layers.Conv2D(256,(3,3),strides=(1,1),padding='same',name='conv_8',use_bias=False)(x)
+    x=layers.BatchNormalization(name='norm_8')(x)
+    x=layers.LeakyReLU(alpha=0.1)(x)
+    x=layers.MaxPooling2D(pool_size=(2,2))(x)
+
+    x=layers.Conv2D(512,(3,3),strides=(1,1),padding='same',name='conv_9',use_bias=False)(x)
+    x=layers.BatchNormalization(name='norm_9')(x)
+    x=layers.LeakyReLU(alpha=0.1)(x)
+
+    x=layers.Conv2D(256,(1,1),strides=(1,1),padding='same',name='conv_10',use_bias=False)(x)
+    x=layers.BatchNormalization(name='norm_10')(x)
+    x=layers.LeakyReLU(alpha=0.1)(x)
+
+    x=layers.Conv2D(512,(3,3),strides=(1,1),padding='same',name='conv_11',use_bias=False)(x)
+    x=layers.BatchNormalization(name='norm_11')(x)
+    x=layers.LeakyReLU(alpha=0.1)(x)
+
+    x=layers.Conv2D(256,(1,1),strides=(1,1),padding='same',name='conv_12',use_bias=False)(x)
+    x=layers.BatchNormalization(name='norm_12')(x)
+    x=layers.LeakyReLU(alpha=0.1)(x)
+
+    x=layers.Conv2D(512,(3,3),strides=(1,1),padding='same',name='conv_13',use_bias=False)(x)
+    x=layers.BatchNormalization(name='norm_13')(x)
+    x=layers.LeakyReLU(alpha=0.1)(x)
+
+    skip_connection = x
+
+    x=layers.MaxPooling2D(pool_size=(2,2))(x)
+
+    x=layers.Conv2D(1024,(3,3),strides=(1,1),padding='same',name='conv_14',use_bias=False)(x)
+    x=layers.BatchNormalization(name='norm_14')(x)
+    x=layers.LeakyReLU(alpha=0.1)(x)
+
+    x=layers.Conv2D(512,(1,1),strides=(1,1),padding='same',name='conv_15',use_bias=False)(x)
+    x=layers.BatchNormalization(name='norm_15')(x)
+    x=layers.LeakyReLU(alpha=0.1)(x)
+
+    x=layers.Conv2D(1024,(3,3),strides=(1,1),padding='same',name='conv_16',use_bias=False)(x)
+    x=layers.BatchNormalization(name='norm_16')(x)
+    x=layers.LeakyReLU(alpha=0.1)(x)
+
+    x=layers.Conv2D(512,(1,1),strides=(1,1),padding='same',name='conv_17',use_bias=False)(x)
+    x=layers.BatchNormalization(name='norm_17')(x)
+    x=layers.LeakyReLU(alpha=0.1)(x)
+
+    x=layers.Conv2D(1024,(3,3),strides=(1,1),padding='same',name='conv_18',use_bias=False)(x)
+    x=layers.BatchNormalization(name='norm_18')(x)
+    x=layers.LeakyReLU(alpha=0.1)(x)
+
+    x=layers.Conv2D(1024,(3,3),strides=(1,1),padding='same',name='conv_19',use_bias=False)(x)
+    x=layers.BatchNormalization(name='norm_19')(x)
+    x=layers.LeakyReLU(alpha=0.1)(x)
+
+    x=layers.Conv2D(1024,(3,3),strides=(1,1),padding='same',name='conv_20',use_bias=False)(x)
+    x=layers.BatchNormalization(name='norm_20')(x)
+    x=layers.LeakyReLU(alpha=0.1)(x)
+
+    skip_connection=layers.Conv2D(64,(1,1),strides=(1,1),padding='same',name='conv_21',use_bias=False)(skip_connection)
+    skip_connection=layers.BatchNormalization(name='norm_21')(skip_connection)
+    skip_connection=layers.LeakyReLU(alpha=0.1)(skip_connection)
+    skip_connection=layers.Lambda(space_to_depth_x2)(skip_connection) # halfs the resolution and add more depth
+
+    x=layers.concatenate([skip_connection,x])
+    x=layers.Conv2D(1024,(3,3),strides=(1,1),padding='same',name='conv_22',use_bias=False)(x)
+    x=layers.BatchNormalization(name='norm_22')(x)
+    x=layers.LeakyReLU(alpha=0.1)(x)
+
+    x=layers.Conv2D((num_anchors*(5+len(class_names))),(1,1),strides=(1,1),padding='same',name='conv_23')(x)
+    out=yolo_dynamic_reshape()(x_input,x)
+
+    model=Model(x_input,out,name='yolo_v2_model')
+    # model.summary()
+    return model
+
+def load_model(path):
+    # model=tf.keras.models.load_model(path,custom_objects={'yolo_dynamic_reshape':yolo_dynamic_reshape},compile=False)
+    model=create_model()
+    model.load_weights(path)
+    # model=tf.keras.models.load_model(path)
+    return model

test.py

@@ -0,0 +1,38 @@
+import h5py
+
+def print_structure(weight_file_path):
+    """
+    Prints out the structure of HDF5 file.
+    Args:
+      weight_file_path (str) : Path to the file to analyze
+    """
+    f = h5py.File(weight_file_path)
+    try:
+        if len(f.attrs.items()):
+            print("{} contains: ".format(weight_file_path))
+            print("Root attributes:")
+        for key, value in f.attrs.items():
+            print("  {}: {}".format(key, value))
+
+        if len(f.items())==0:
+            return 
+
+        for layer, g in f.items():
+            print("  {}".format(layer))
+            print("    Attributes:")
+            for key, value in g.attrs.items():
+                print("      {}: {}".format(key, value))
+
+            print("    Dataset:")
+            for p_name in g.keys():
+                param = g[p_name]
+                subkeys = param.keys()
+                for k_name in param.keys():
+                    print("      {}/{}: {}".format(p_name, k_name, param.get(k_name)[:]))
+    finally:
+        f.close()
+ 
+try:
+    print_structure("yolo_v2(iou_70.5945).h5")
+except:
+    pass

yolo_v2(iou_70.5945).h5

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6f9495daa9752653b365f652eb7f904b4d5b58ef26b3896f14f5077f8767a6a8
+size 608026904