Upload folder using huggingface_hub

.gitattributes

@@ -33,3 +33,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+code/python/bus.jpg filter=lfs diff=lfs merge=lfs -text

README.md

@@ -0,0 +1,36 @@
+---
+license: agpl-3.0
+pipeline_tag: object-detection
+tags:
+- AIoT
+- QNN
+---
+
+![](https://aiot.aidlux.com/_next/image?url=%2Fapi%2Fv1%2Ffiles%2Fmodel%2Fcover%2F%25E5%259B%25BE-10.png&w=640&q=75)
+
+## YOLOv8s: Target Detection
+
+YOLOv8 is a cutting-edge, state-of-the-art (SOTA) model that builds upon the success of previous YOLO versions and introduces new features and improvements to further boost performance and flexibility. YOLOv8 is designed to be fast, accurate, and easy to use, making it an excellent choice for a wide range of object detection and tracking, instance segmentation, image classification and pose estimation tasks. 
+
+### Source model
+
+- Input shape: 640x640
+- Number of parameters: 25.91M
+- Model size: 98.9MB
+- Output shape: 1x84x8400
+
+Source model repository: [yolov8](https://github.com/ultralytics/ultralytics)
+
+## Performance Reference
+
+Please search model by model name in [Model Farm](https://aiot.aidlux.com/en/models)
+
+## Inference & Model Conversion
+
+Please search model by model name in [Model Farm](https://aiot.aidlux.com/en/models)
+
+## License
+
+- Source Model: [AGPL-3.0](https://github.com/ultralytics/ultralytics/blob/main/LICENSE)
+
+- Deployable Model: [AGPL-3.0](https://github.com/ultralytics/ultralytics/blob/main/LICENSE)

code/README.md

@@ -0,0 +1,47 @@
+## Model Information
+### Source model
+- Input shape: 640x640
+- Number of parameters: 25.91M
+- Model size: 98.9MB
+- Output shape: 1x84x8400
+
+Source model repository: [yolov8](https://github.com/ultralytics/ultralytics)
+
+## Inference with AidLite SDK
+
+### SDK installation
+Model Farm uses AidLite SDK as the model inference SDK. For details, please refer to the https://docs.aidlux.com/software/ai-sdk/aidlite_guide(https://docs.aidlux.com/software/ai-sdk/aidlite_guide)
+
+- install AidLite SDK
+
+```bash
+# Install the appropriate version of the aidlite sdk
+sudo aid-pkg update
+sudo aid-pkg install aidlite-sdk
+# Download the qnn version that matches the above backend. Eg Install QNN2.23 Aidlite: sudo aid-pkg install aidlite-qnn223
+sudo aid-pkg install aidlite-{QNN VERSION}
+```
+
+- Verify AidLite SDK
+
+```bash
+# Install the appropriate version of the aidlite sdk
+sudo aid-pkg update
+sudo aid-pkg install aidlite-sdk
+# Download the qnn version that matches the above backend. Eg Install QNN2.23 Aidlite: sudo aid-pkg install aidlite-qnn223
+sudo aid-pkg install aidlite-{QNN VERSION}
+# eg: Install QNN 2.23 Aidlite: sudo aid-pkg install aidlite-qnn223
+```
+
+### Run Demo
+
+#### python
+```bash
+cd model_farm_yolov8m_qcs8550_qnn2.36_fp16_aidlite
+python3  python/run_test.py --target_model ./[model_file_path] --imgs ./python/bus.jpg  --invoke_nums 10
+```
+
+#### 
+```bash
+
+```

code/python/run_test.py

@@ -0,0 +1,30 @@
+import cv2
+import argparse
+from yolov8m import Yolov8M
+from utils import draw_detect_res
+
+def parser_args():
+    parser = argparse.ArgumentParser(description="Run model benchmarks")
+    parser.add_argument('--target_model',type=str,default='./models/cutoff_yolov8m_qcs8550_fp16.qnn236.ctx.bin',help="inference model path")
+    parser.add_argument('--imgs',type=str,default='./python/bus.jpg',help="Predict images path")
+    parser.add_argument('--height',type=int,default=640,help="run backend")
+    parser.add_argument('--weight',type=int,default=640,help="run backend")
+    parser.add_argument('--cls_num',type=int,default=80,help="run backend")
+    parser.add_argument('--invoke_nums',type=int,default=10,help="Inference nums")
+    parser.add_argument('--model_type',type=str,default='QNN',help="run backend")
+    args = parser.parse_args()
+    return args
+
+if __name__ == "__main__":
+    args = parser_args()
+    height = args.height
+    weight = args.weight
+
+    
+    model = Yolov8M(args.target_model, args.weight, args.height, args.cls_num)
+    frame = cv2.imread(args.imgs)
+    
+    out_boxes= model(frame,args.invoke_nums)
+    print(f"=================== \n Detect {len(out_boxes)} targets.")
+    result = draw_detect_res(frame, out_boxes)
+    cv2.imwrite("./python/result.jpg", result)

code/python/utils.py

@@ -0,0 +1,123 @@
+import numpy as np
+import cv2
+
+CLASSES = ("person", "bicycle", "car", "motorbike ", "aeroplane ", "bus ", "train", "truck ", "boat", "traffic light",
+           "fire hydrant", "stop sign ", "parking meter", "bench", "bird", "cat", "dog ", "horse ", "sheep", "cow", "elephant",
+           "bear", "zebra ", "giraffe", "backpack", "umbrella", "handbag", "tie", "suitcase", "frisbee", "skis", "snowboard", "sports ball", "kite",
+           "baseball bat", "baseball glove", "skateboard", "surfboard", "tennis racket", "bottle", "wine glass", "cup", "fork", "knife ",
+           "spoon", "bowl", "banana", "apple", "sandwich", "orange", "broccoli", "carrot", "hot dog", "pizza ", "donut", "cake", "chair", "sofa",
+           "pottedplant", "bed", "diningtable", "toilet ", "tvmonitor", "laptop	", "mouse	", "remote ", "keyboard ", "cell phone", "microwave ",
+           "oven ", "toaster", "sink", "refrigerator ", "book", "clock", "vase", "scissors ", "teddy bear ", "hair drier", "toothbrush ")
+           
+def eqprocess(image, size1, size2):
+    h,w,_ = image.shape
+    mask = np.zeros((size1,size2,3),dtype=np.float32)
+    scale1 = h /size1
+    scale2 = w / size2
+    if scale1 > scale2:
+        scale = scale1
+    else:
+        scale = scale2
+    img = cv2.resize(image,(int(w / scale),int(h / scale)))
+    mask[:int(h / scale),:int(w / scale),:] = img
+    return mask, scale
+
+def xywh2xyxy(x):
+    '''
+    Box (center x, center y, width, height) to (x1, y1, x2, y2)
+    '''
+    y = np.copy(x)
+    y[:, 0] = x[:, 0] - x[:, 2] / 2  # top left x
+    y[:, 1] = x[:, 1] - x[:, 3] / 2  # top left y
+    y[:, 2] = x[:, 0] + x[:, 2] / 2  # bottom right x
+    y[:, 3] = x[:, 1] + x[:, 3] / 2  # bottom right y
+    return y
+
+def xyxy2xywh(box):
+    '''
+    Box (left_top x, left_top y, right_bottom x, right_bottom y) to (left_top x, left_top y, width, height)
+    '''
+    box[:, 2:] = box[:, 2:] - box[:, :2]
+    return box
+
+def NMS(dets, scores, thresh):
+    '''
+    单类NMS算法
+    dets.shape = (N, 5), (left_top x, left_top y, right_bottom x, right_bottom y, Scores)
+    '''
+    x1 = dets[:,0]
+    y1 = dets[:,1]
+    x2 = dets[:,2]
+    y2 = dets[:,3]
+    areas = (y2-y1+1) * (x2-x1+1)
+    keep = []
+    index = scores.argsort()[::-1]
+    while index.size >0:
+        i = index[0]       # every time the first is the biggst, and add it directly
+        keep.append(i)
+        x11 = np.maximum(x1[i], x1[index[1:]])    # calculate the points of overlap 
+        y11 = np.maximum(y1[i], y1[index[1:]])
+        x22 = np.minimum(x2[i], x2[index[1:]])
+        y22 = np.minimum(y2[i], y2[index[1:]])
+        w = np.maximum(0, x22-x11+1)    # the weights of overlap
+        h = np.maximum(0, y22-y11+1)    # the height of overlap
+        overlaps = w*h
+        ious = overlaps / (areas[i]+areas[index[1:]] - overlaps)
+        idx = np.where(ious<=thresh)[0]
+        index = index[idx+1]   # because index start from 1
+ 
+    return keep
+
+
+def draw_detect_res(img, det_pred):
+    '''
+    检测结果绘制
+    '''
+    if det_pred is None:
+        return img
+
+    img = img.astype(np.uint8)
+    im_canvas = img.copy()
+    color_step = int(255/len(CLASSES))
+    for i in range(len(det_pred)):
+        x1, y1, x2, y2 = [int(t) for t in det_pred[i][:4]]
+        cls_id = int(det_pred[i][5])
+        print(i+1,[x1,y1,x2,y2],det_pred[i][4], f'{CLASSES[cls_id]}')
+        cv2.putText(img, f'{CLASSES[cls_id]}', (x1, y1-6), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (255, 255, 255), 1)
+        cv2.rectangle(img, (x1, y1), (x2, y2), (0, int(cls_id*color_step), int(255-cls_id*color_step)),thickness = 2)
+    img = cv2.addWeighted(im_canvas, 0.3, img, 0.7, 0)
+    return img
+
+def scale_mask(masks, im0_shape):
+    masks = cv2.resize(masks, (im0_shape[1], im0_shape[0]),
+                        interpolation=cv2.INTER_LINEAR)
+    if len(masks.shape) == 2:
+        masks = masks[:, :, None]
+    return masks
+
+def crop_mask(masks, boxes):
+    n, h, w = masks.shape
+    x1, y1, x2, y2 = np.split(boxes[:, :, None], 4, 1)
+    r = np.arange(w, dtype=x1.dtype)[None, None, :]
+    c = np.arange(h, dtype=x1.dtype)[None, :, None]
+    return masks * ((r >= x1) * (r < x2) * (c >= y1) * (c < y2))
+
+def process_mask(protos, masks_in, bboxes, im0_shape):
+    c, mh, mw = protos.shape
+    masks = np.matmul(masks_in, protos.reshape((c, -1))).reshape((-1, mh, mw)).transpose(1, 2, 0)  # HWN
+    masks = np.ascontiguousarray(masks)
+    masks = scale_mask(masks, im0_shape)  # re-scale mask from P3 shape to original input image shape
+    masks = np.einsum('HWN -> NHW', masks)  # HWN -> NHW
+    masks = crop_mask(masks, bboxes)
+    return np.greater(masks, 0.5)
+
+def masks2segments(masks):
+    segments = []
+    for x in masks.astype('uint8'):
+        c = cv2.findContours(x, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_NONE)[0]  # CHAIN_APPROX_SIMPLE
+        if c:
+            c = np.array(c[np.array([len(x) for x in c]).argmax()]).reshape(-1, 2)
+        else:
+            c = np.zeros((0, 2))  # no segments found
+        segments.append(c.astype('float32'))
+    return segments

code/python/yolov8m.py

@@ -0,0 +1,91 @@
+import numpy as np
+import cv2
+import aidlite
+from utils import eqprocess, xywh2xyxy, NMS
+import time
+
+OBJ_THRESH = 0.45
+NMS_THRESH = 0.45
+
+class Yolov8M(object):
+    def __init__(self, model_path, width, height, class_num):
+        self.class_num = class_num
+        self.width = width
+        self.height = height
+        input_shape = [[1,height,width,3]]
+        self.blocks = int(height * width * ( 1 / 64 + 1 / 256 + 1 / 1024))
+        self.maskw = int(width / 4)
+        self.maskh = int(height / 4)
+        self.output_shape = [[1,4,self.blocks],[1,class_num,self.blocks]]
+    
+        self.model = aidlite.Model.create_instance(model_path)
+        if self.model is None:
+            print("Create model failed !")
+            return
+        self.model.set_model_properties(input_shape, aidlite.DataType.TYPE_FLOAT32, self.output_shape, aidlite.DataType.TYPE_FLOAT32)
+        
+        self.config = aidlite.Config.create_instance()
+        if self.config is None:
+            print("build_interpretper_from_model_and_config failed !")
+            return
+        
+        self.config.implement_type = aidlite.ImplementType.TYPE_LOCAL
+        self.config.framework_type = aidlite.FrameworkType.TYPE_QNN
+        self.config.accelerate_type = aidlite.AccelerateType.TYPE_DSP
+        self.config.is_quantify_model = 1
+        
+        self.interpreter = aidlite.InterpreterBuilder.build_interpretper_from_model_and_config(self.model, self.config)
+        if self.interpreter is None:
+            print("build_interpretper_from_model_and_config failed !")
+            return
+        
+        self.interpreter.init()
+        self.interpreter.load_model()
+    
+    def __del__(self):
+        self.interpreter.destory()
+    
+    def __call__(self, frame,invoke_nums):
+        img = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
+        img, scale = eqprocess(img, self.height, self.width)
+        img = img / 255
+        img = img.astype(np.float32)
+        self.interpreter.set_input_tensor(0,img.data)
+        
+        invoke_time=[]
+        for i  in range(invoke_nums):
+            t1=time.time()
+            self.interpreter.invoke()
+            cost_time = (time.time()-t1)*1000
+            invoke_time.append(cost_time)
+
+        max_invoke_time = max(invoke_time)
+        min_invoke_time = min(invoke_time)
+        mean_invoke_time = sum(invoke_time)/invoke_nums
+        var_invoketime=np.var(invoke_time)
+        print("====================================")
+        print(f"QNN invoke {invoke_nums} times:\n --mean_invoke_time is {mean_invoke_time} \n --max_invoke_time is {max_invoke_time} \n --min_invoke_time is {min_invoke_time} \n --var_invoketime is {var_invoketime}")
+        print("====================================")
+
+        qnn_1 = self.interpreter.get_output_tensor(0)
+        qnn_2 = self.interpreter.get_output_tensor(1)
+        qnn_out = sorted([qnn_1,qnn_2], key=len)
+
+        qnn_local = qnn_out[0].reshape(*self.output_shape[0])
+        qnn_conf = qnn_out[1].reshape(*self.output_shape[1])
+
+        
+        x = np.concatenate([qnn_local, qnn_conf], axis = 1).transpose(0,2,1)
+        x = x[np.amax(x[..., 4:], axis=-1) > OBJ_THRESH]
+        if len(x) < 1:
+            return None, None
+    
+        x = np.c_[x[..., :4], np.amax(x[..., 4:], axis=-1), np.argmax(x[..., 4:], axis=-1)]
+        
+        x[:, :4] = xywh2xyxy(x[:, :4])
+        index = NMS(x[:, :4], x[:, 4], NMS_THRESH)
+        out_boxes = x[index]
+        out_boxes[..., :4] = out_boxes[..., :4] * scale
+        
+        return out_boxes
+

models/QCS8550/FP16/cutoff_yolov8m_qcs8550_fp16.qnn236.ctx.bin

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:5563318d29916d0b364fab3ec75b1ff85b52722642dd99286764e3610f2790b2
+size 54079176

models/QCS8550/W8A8/cutoff_yolov8m_qcs8550_w8a8.qnn236.ctx.bin

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

models/QCS8550/unknown_precision/cutoff_yolov8m_qcs8550_w8a16.qnn236.ctx.bin

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