Upload 23 files

.gitattributes

@@ -33,3 +33,13 @@ 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
+model_farm_yolov10x_qcs6490_qnn2.31_int8_aidlite/models/cutoff_yolov10x_w8a8.qnn231.ctx.bin.aidem filter=lfs diff=lfs merge=lfs -text
+model_farm_yolov10x_qcs6490_qnn2.31_int8_aidlite/python/bus.jpg filter=lfs diff=lfs merge=lfs -text
+model_farm_yolov10x_qcs6490_qnn2.31_w8a16_aidlite/models/cutoff_yolov10x_w8a16.qnn231.ctx.bin.aidem filter=lfs diff=lfs merge=lfs -text
+model_farm_yolov10x_qcs6490_qnn2.31_w8a16_aidlite/python/bus.jpg filter=lfs diff=lfs merge=lfs -text
+model_farm_yolov10x_qcs8550_qnn2.31_fp16_aidlite/models/cutoff_yolov10x_fp16.qnn231.ctx.bin.aidem filter=lfs diff=lfs merge=lfs -text
+model_farm_yolov10x_qcs8550_qnn2.31_fp16_aidlite/python/bus.jpg filter=lfs diff=lfs merge=lfs -text
+model_farm_yolov10x_qcs8550_qnn2.31_int8_aidlite/models/cutoff_yolov10x_w8a8.qnn231.ctx.bin.aidem filter=lfs diff=lfs merge=lfs -text
+model_farm_yolov10x_qcs8550_qnn2.31_int8_aidlite/python/bus.jpg filter=lfs diff=lfs merge=lfs -text
+model_farm_yolov10x_qcs8550_qnn2.31_w8a16_aidlite/models/cutoff_yolov10x_w8a16.qnn231.ctx.bin.aidem filter=lfs diff=lfs merge=lfs -text
+model_farm_yolov10x_qcs8550_qnn2.31_w8a16_aidlite/python/bus.jpg filter=lfs diff=lfs merge=lfs -text

model_farm_yolov10x_qcs6490_qnn2.31_int8_aidlite/README.md

@@ -0,0 +1,43 @@
+## Model Information
+
+### Source model
+- Input shape: [1,3,640,640]
+- Number of parameters: 30.34M
+- Model size: 112.73M
+- Output shape: [1,300,6]
+
+Source model repository: [YOLOV10-x](https://github.com/THU-MIG/yolov10)
+
+### Converted model
+
+- Precision: INT8
+- Backend: QNN2.31
+- Target Device: FV01 QCS6490
+
+## Model Conversion Reference
+User can find model conversion reference at [aimo.aidlux.com](https://aimo.aidlux.com/#/public/4ded1198-4d50-4258-9043-67f419a405c2)
+
+## Inference with AidLite SDK
+
+### SDK installation
+Model Farm uses AidLite SDK as the model inference SDK. For details, please refer to the [AidLite Developer Documentation](https://v2.docs.aidlux.com/en/sdk-api/aidlite-sdk/)
+
+- 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
+# aidlite sdk c++ check
+python3 -c "import aidlite ; print(aidlite.get_library_version())"
+
+# aidlite sdk python check
+python3 -c "import aidlite ; print(aidlite.get_py_library_version())"
+```

model_farm_yolov10x_qcs6490_qnn2.31_int8_aidlite/models/cutoff_yolov10x_w8a8.qnn231.ctx.bin.aidem

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

model_farm_yolov10x_qcs6490_qnn2.31_int8_aidlite/models/post_pro.onnx

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

model_farm_yolov10x_qcs6490_qnn2.31_w8a16_aidlite/README.md

@@ -0,0 +1,52 @@
+## Model Information
+
+### Source model
+- Input shape: [1,3,640,640]
+- Number of parameters: 30.34M
+- Model size: 112.73M
+- Output shape: [1,300,6]
+
+Source model repository: [YOLOV10-x](https://github.com/THU-MIG/yolov10)
+
+### Converted model
+
+- Precision: W8A16
+- Backend: QNN2.31
+- Target Device: FV01 QCS6490
+
+## Model Conversion Reference
+User can find model conversion reference at [aimo.aidlux.com](https://aimo.aidlux.com/#/public/95d04959-5545-4b82-ade8-f2df6036c803)
+
+## Inference with AidLite SDK
+
+### SDK installation
+Model Farm uses AidLite SDK as the model inference SDK. For details, please refer to the [AidLite Developer Documentation](https://v2.docs.aidlux.com/en/sdk-api/aidlite-sdk/)
+
+- 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
+# aidlite sdk c++ check
+python3 -c "import aidlite ; print(aidlite.get_library_version())"
+
+# aidlite sdk python check
+python3 -c "import aidlite ; print(aidlite.get_py_library_version())"
+```
+
+### Run Demo
+
+#### python
+ > Note: The ONNX model is used in the post-processing stage, and users' own models can also reuse this ONNX model.
+```bash
+cd model_farm_yolov10x_qcs6490_qnn2.31_w8a16_aidlite
+python3  python/run_test.py --target_model ./models/cutoff_yolov10x_w8a16.qnn231.ctx.bin.aidem --imgs ./python/bus.jpg  --invoke_nums 10
+```

model_farm_yolov10x_qcs6490_qnn2.31_w8a16_aidlite/models/cutoff_yolov10x_w8a16.qnn231.ctx.bin.aidem

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

model_farm_yolov10x_qcs6490_qnn2.31_w8a16_aidlite/models/post_pro.onnx

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

model_farm_yolov10x_qcs6490_qnn2.31_w8a16_aidlite/python/run_test.py

@@ -0,0 +1,265 @@
+import time
+import numpy as np
+import cv2
+import os
+import aidlite
+import argparse
+import onnxruntime  
+
+
+
+"""返回 COCO 数据集的类别名称（80 类）。"""
+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 letterbox(
+        im,
+        new_shape,
+        color=(114, 114, 114),
+        auto=False,
+        scaleFill=False,
+        scaleup=True,
+        stride=32,
+):
+    """
+    Resize and pad image while meeting stride-multiple constraints
+    Returns:
+        im (array): (height, width, 3)
+        ratio (array): [w_ratio, h_ratio]
+        (dw, dh) (array): [w_padding h_padding]
+    """
+    shape = im.shape[:2]  # current shape [height, width]
+    if isinstance(new_shape, int):  # [h_rect, w_rect]
+        new_shape = (new_shape, new_shape)
+ 
+    # Scale ratio (new / old)
+    r = min(new_shape[0] / shape[0], new_shape[1] / shape[1])
+    if not scaleup:  # only scale down, do not scale up (for better val mAP)
+        r = min(r, 1.0)
+ 
+    # Compute padding
+    ratio = r, r  # wh ratios
+    new_unpad = int(round(shape[1] * r)), int(round(shape[0] * r))  # w h
+    dw, dh = (
+        new_shape[1] - new_unpad[0],
+        new_shape[0] - new_unpad[1],
+    )  # wh padding
+ 
+    if auto:  # minimum rectangle
+        dw, dh = np.mod(dw, stride), np.mod(dh, stride)  # wh padding
+    elif scaleFill:  # stretch
+        dw, dh = 0.0, 0.0
+        new_unpad = (new_shape[1], new_shape[0])  # [w h]
+        ratio = (
+            new_shape[1] / shape[1],
+            new_shape[0] / shape[0],
+        )  # [w_ratio, h_ratio]
+ 
+    dw /= 2  # divide padding into 2 sides
+    dh /= 2
+    if shape[::-1] != new_unpad:  # resize
+        im = cv2.resize(im, new_unpad, interpolation=cv2.INTER_LINEAR)
+    top, bottom = int(round(dh - 0.1)), int(round(dh + 0.1))
+    left, right = int(round(dw - 0.1)), int(round(dw + 0.1))
+    im = cv2.copyMakeBorder(
+        im, top, bottom, left, right, cv2.BORDER_CONSTANT, value=color
+    )
+    return im, ratio, (dw, dh)
+
+
+class Colors:
+    
+    def __init__(self):
+        hexs = ('FF3838', 'FF9D97', 'FF701F', 'FFB21D', 'CFD231', '48F90A', '92CC17', '3DDB86', '1A9334', '00D4BB',
+                '2C99A8', '00C2FF', '344593', '6473FF', '0018EC', '8438FF', '520085', 'CB38FF', 'FF95C8', 'FF37C7')
+        self.palette = [self.hex2rgb(f'#{c}') for c in hexs]
+        self.n = len(self.palette)
+
+    def __call__(self, i, bgr=False):
+        c = self.palette[int(i) % self.n]
+        return (c[2], c[1], c[0]) if bgr else c
+
+    @staticmethod
+    def hex2rgb(h):
+        return tuple(int(h[1 + i:1 + i + 2], 16) for i in (0, 2, 4))
+
+
+def rescale_coords(boxes, image_shape, input_shape):
+    image_height, image_width = image_shape
+    input_height, input_width = input_shape
+    scale = min(input_width / image_width, input_height / image_height)
+    pad_w = (input_width - image_width * scale) / 2
+    pad_h = (input_height - image_height * scale) / 2
+    boxes[:, [0, 2]] = (boxes[:, [0, 2]] - pad_w) / scale
+    boxes[:, [1, 3]] = (boxes[:, [1, 3]] - pad_h) / scale
+    boxes[:, [0, 2]] = np.clip(boxes[:, [0, 2]], 0, image_width)
+    boxes[:, [1, 3]] = np.clip(boxes[:, [1, 3]], 0, image_height)
+    return boxes.astype(int)
+
+def preprocess(image, input_shape):
+    # Resize
+    input_img = letterbox(image, input_shape)[0]
+    # Transpose
+    # input_img = input_img[..., ::-1].transpose(2, 0, 1)
+    input_img = input_img[..., ::-1]
+    # Expand
+    input_img = input_img[np.newaxis, :, :, :].astype(np.float32)
+    # Contiguous
+    input_img = np.ascontiguousarray(input_img)
+    # Norm
+    blob = input_img / 255.0
+    return blob
+
+def postprocess(output_data, conf_thres, image_shape, input_shape):
+    outs = output_data  # test.py 中 output_data 已经是 (8400, 84)
+    outs = outs[outs[:, 4] >= conf_thres]
+    boxes = outs[:, :4]
+    scores = outs[:, -2]
+    labels = outs[:, -1].astype(int)
+    boxes = rescale_coords(boxes, image_shape, input_shape)
+    return boxes, scores, labels
+
+class qnn_yolov10:
+    def __init__(self,model_path,sdk="qnn",backend="npu"):
+        self.config = aidlite.Config.create_instance()
+        if self.config is None:
+            print("Create config failed !")
+            return False
+
+        self.config.implement_type = aidlite.ImplementType.TYPE_LOCAL
+        if sdk.lower()=="qnn":
+            self.config.framework_type = aidlite.FrameworkType.TYPE_QNN
+        else :
+            self.config.framework_type = aidlite.FrameworkType.TYPE_SNPE2
+            
+
+        if backend.lower() =="npu":
+            self.config.accelerate_type = aidlite.AccelerateType.TYPE_DSP
+        elif backend.lower() =="gpu":
+            self.config.accelerate_type = aidlite.AccelerateType.TYPE_GPU
+        else:
+            self.config.accelerate_type = aidlite.AccelerateType.TYPE_CPU
+        self.config.is_quantify_model = 1
+               
+        self.model = aidlite.Model.create_instance(model_path)
+        if self.model is None:
+            print("Create model failed !")
+            return False
+        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 None
+        result = self.interpreter.init()
+        if result != 0:
+            print(f"interpreter init failed !")
+            return False
+        result = self.interpreter.load_model()
+        if result != 0:
+            print("interpreter load model failed !")
+            return False
+        print("detect model load success!")
+    
+    def __del__(self):
+        self.interpreter.destory()
+    
+    def __call__(self, img_input,invoke_nums):
+        result = self.interpreter.set_input_tensor(0, img_input.data)
+        if result != 0:
+            print("interpreter set_input_tensor() failed")
+        invoke_time=[]
+        for i in range(invoke_nums):
+            t1=time.time()
+            result = self.interpreter.invoke()
+            if result != 0:
+                print("interpreter set_input_tensor() failed")
+            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("====================================")
+
+        output1 = self.interpreter.get_output_tensor(0)
+        return output1
+        
+    
+class onnx_yolov10:
+    def __init__(self,model_path):
+        self.sess_options = onnxruntime.SessionOptions()
+        self.sess_options.intra_op_num_threads = 1
+        self.sess = onnxruntime.InferenceSession(model_path,sess_options=self.sess_options)
+        self.outname = [i.name for i in self.sess.get_outputs()]
+        self.inname = [i.name for i in self.sess.get_inputs()]
+    def __call__(self,img_input):
+        inp = {self.inname[0]:img_input}
+        t1=time.time()
+        out_put = self.sess.run(self.outname,inp)[0]
+        cost_time = (time.time()-t1)*1000
+        return out_put
+    
+    
+def main(args):
+    input_shape = (640, 640)
+    conf_thres = 0.25
+    img_path = args.imgs
+    invoke_nums = args.invoke_nums
+    qnn_path = args.target_model
+    
+    # qnn +onnx推理
+    qnn_model1 = qnn_yolov10(qnn_path)
+    
+    onnx_model_path = 'models/post_pro.onnx'
+    onnx_model = onnx_yolov10(onnx_model_path)
+
+    print("Begin to run qnn...")
+    im0 = cv2.imread(img_path)
+    image_shape = im0.shape[:2]
+    img_qnn = preprocess(im0, input_shape) 
+    qnn_out_shape = (1,8400,84)
+    out1 = qnn_model1(img_qnn,invoke_nums)
+    out1 = out1.reshape(*qnn_out_shape)
+    out2 = onnx_model(out1)[0]
+       
+    boxes, scores, labels = postprocess(out2, conf_thres, image_shape, input_shape)
+    print(f"Detect {len(boxes)} targets")
+    
+    colors = Colors()
+    for label, score, box in zip(labels, scores, boxes):
+        label_text = f'{classes[label]}: {score:.2f}'
+        color = colors(label, True)
+        cv2.rectangle(im0, (box[0], box[1]), (box[2], box[3]), color, 2, lineType=cv2.LINE_AA)
+        cv2.putText(im0, label_text, (box[0], box[1] - 10), cv2.FONT_HERSHEY_SIMPLEX, 0.5, color, 2)
+
+    output_image_path = "python/detected_results.jpg"
+    cv2.imwrite(output_image_path, im0)
+    print(f"Saved detected result to {output_image_path}")
+    
+
+
+def parser_args():
+    parser = argparse.ArgumentParser(description="Inferrence yolov10 model")
+    parser.add_argument('--target_model',type=str,default='./models/cutoff_yolov10x_w8a16.qnn231.ctx.bin.aidem',help="Predict images path")
+    parser.add_argument('--imgs',type=str,default='./python/bus.jpg',help="Predict images path")
+    parser.add_argument('--invoke_nums',type=int,default=10,help="Inference nums")
+    args = parser.parse_args()
+    return args
+
+
+if __name__ == "__main__":
+    args = parser_args()
+    main(args)

model_farm_yolov10x_qcs8550_qnn2.31_fp16_aidlite/README.md

@@ -0,0 +1,52 @@
+## Model Information
+
+### Source model
+- Input shape: [1,3,640,640]
+- Number of parameters: 30.34M
+- Model size: 112.73M
+- Output shape: [1,300,6]
+
+Source model repository: [YOLOV10-x](https://github.com/THU-MIG/yolov10)
+
+### Converted model
+
+- Precision: FP16
+- Backend: QNN2.31
+- Target Device: SNM972 QCS8550
+
+## Model Conversion Reference
+User can find model conversion reference at [aimo.aidlux.com](https://aimo.aidlux.com/#/public/47ed290a-394b-4b75-8d25-5fa2058c6c48)
+
+## Inference with AidLite SDK
+
+### SDK installation
+Model Farm uses AidLite SDK as the model inference SDK. For details, please refer to the [AidLite Developer Documentation](https://v2.docs.aidlux.com/en/sdk-api/aidlite-sdk/)
+
+- 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
+# aidlite sdk c++ check
+python3 -c "import aidlite ; print(aidlite.get_library_version())"
+
+# aidlite sdk python check
+python3 -c "import aidlite ; print(aidlite.get_py_library_version())"
+```
+
+### Run Demo
+
+#### python
+ > Note: The ONNX model is used in the post-processing stage, and users' own models can also reuse this ONNX model.
+```bash
+cd model_farm_yolov10x_qcs8550_qnn2.31_fp16_aidlite
+python3  python/run_test.py --target_model ./models/cutoff_yolov10x_fp16.qnn231.ctx.bin.aidem --imgs ./python/bus.jpg  --invoke_nums 10
+```

model_farm_yolov10x_qcs8550_qnn2.31_fp16_aidlite/models/cutoff_yolov10x_fp16.qnn231.ctx.bin.aidem

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

model_farm_yolov10x_qcs8550_qnn2.31_fp16_aidlite/models/post_pro.onnx

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

model_farm_yolov10x_qcs8550_qnn2.31_fp16_aidlite/python/run_test.py

@@ -0,0 +1,265 @@
+import time
+import numpy as np
+import cv2
+import os
+import aidlite
+import argparse
+import onnxruntime  
+
+
+
+"""返回 COCO 数据集的类别名称（80 类）。"""
+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 letterbox(
+        im,
+        new_shape,
+        color=(114, 114, 114),
+        auto=False,
+        scaleFill=False,
+        scaleup=True,
+        stride=32,
+):
+    """
+    Resize and pad image while meeting stride-multiple constraints
+    Returns:
+        im (array): (height, width, 3)
+        ratio (array): [w_ratio, h_ratio]
+        (dw, dh) (array): [w_padding h_padding]
+    """
+    shape = im.shape[:2]  # current shape [height, width]
+    if isinstance(new_shape, int):  # [h_rect, w_rect]
+        new_shape = (new_shape, new_shape)
+ 
+    # Scale ratio (new / old)
+    r = min(new_shape[0] / shape[0], new_shape[1] / shape[1])
+    if not scaleup:  # only scale down, do not scale up (for better val mAP)
+        r = min(r, 1.0)
+ 
+    # Compute padding
+    ratio = r, r  # wh ratios
+    new_unpad = int(round(shape[1] * r)), int(round(shape[0] * r))  # w h
+    dw, dh = (
+        new_shape[1] - new_unpad[0],
+        new_shape[0] - new_unpad[1],
+    )  # wh padding
+ 
+    if auto:  # minimum rectangle
+        dw, dh = np.mod(dw, stride), np.mod(dh, stride)  # wh padding
+    elif scaleFill:  # stretch
+        dw, dh = 0.0, 0.0
+        new_unpad = (new_shape[1], new_shape[0])  # [w h]
+        ratio = (
+            new_shape[1] / shape[1],
+            new_shape[0] / shape[0],
+        )  # [w_ratio, h_ratio]
+ 
+    dw /= 2  # divide padding into 2 sides
+    dh /= 2
+    if shape[::-1] != new_unpad:  # resize
+        im = cv2.resize(im, new_unpad, interpolation=cv2.INTER_LINEAR)
+    top, bottom = int(round(dh - 0.1)), int(round(dh + 0.1))
+    left, right = int(round(dw - 0.1)), int(round(dw + 0.1))
+    im = cv2.copyMakeBorder(
+        im, top, bottom, left, right, cv2.BORDER_CONSTANT, value=color
+    )
+    return im, ratio, (dw, dh)
+
+
+class Colors:
+    
+    def __init__(self):
+        hexs = ('FF3838', 'FF9D97', 'FF701F', 'FFB21D', 'CFD231', '48F90A', '92CC17', '3DDB86', '1A9334', '00D4BB',
+                '2C99A8', '00C2FF', '344593', '6473FF', '0018EC', '8438FF', '520085', 'CB38FF', 'FF95C8', 'FF37C7')
+        self.palette = [self.hex2rgb(f'#{c}') for c in hexs]
+        self.n = len(self.palette)
+
+    def __call__(self, i, bgr=False):
+        c = self.palette[int(i) % self.n]
+        return (c[2], c[1], c[0]) if bgr else c
+
+    @staticmethod
+    def hex2rgb(h):
+        return tuple(int(h[1 + i:1 + i + 2], 16) for i in (0, 2, 4))
+
+
+def rescale_coords(boxes, image_shape, input_shape):
+    image_height, image_width = image_shape
+    input_height, input_width = input_shape
+    scale = min(input_width / image_width, input_height / image_height)
+    pad_w = (input_width - image_width * scale) / 2
+    pad_h = (input_height - image_height * scale) / 2
+    boxes[:, [0, 2]] = (boxes[:, [0, 2]] - pad_w) / scale
+    boxes[:, [1, 3]] = (boxes[:, [1, 3]] - pad_h) / scale
+    boxes[:, [0, 2]] = np.clip(boxes[:, [0, 2]], 0, image_width)
+    boxes[:, [1, 3]] = np.clip(boxes[:, [1, 3]], 0, image_height)
+    return boxes.astype(int)
+
+def preprocess(image, input_shape):
+    # Resize
+    input_img = letterbox(image, input_shape)[0]
+    # Transpose
+    # input_img = input_img[..., ::-1].transpose(2, 0, 1)
+    input_img = input_img[..., ::-1]
+    # Expand
+    input_img = input_img[np.newaxis, :, :, :].astype(np.float32)
+    # Contiguous
+    input_img = np.ascontiguousarray(input_img)
+    # Norm
+    blob = input_img / 255.0
+    return blob
+
+def postprocess(output_data, conf_thres, image_shape, input_shape):
+    outs = output_data  # test.py 中 output_data 已经是 (8400, 84)
+    outs = outs[outs[:, 4] >= conf_thres]
+    boxes = outs[:, :4]
+    scores = outs[:, -2]
+    labels = outs[:, -1].astype(int)
+    boxes = rescale_coords(boxes, image_shape, input_shape)
+    return boxes, scores, labels
+
+class qnn_yolov10:
+    def __init__(self,model_path,sdk="qnn",backend="npu"):
+        self.config = aidlite.Config.create_instance()
+        if self.config is None:
+            print("Create config failed !")
+            return False
+
+        self.config.implement_type = aidlite.ImplementType.TYPE_LOCAL
+        if sdk.lower()=="qnn":
+            self.config.framework_type = aidlite.FrameworkType.TYPE_QNN
+        else :
+            self.config.framework_type = aidlite.FrameworkType.TYPE_SNPE2
+            
+
+        if backend.lower() =="npu":
+            self.config.accelerate_type = aidlite.AccelerateType.TYPE_DSP
+        elif backend.lower() =="gpu":
+            self.config.accelerate_type = aidlite.AccelerateType.TYPE_GPU
+        else:
+            self.config.accelerate_type = aidlite.AccelerateType.TYPE_CPU
+        self.config.is_quantify_model = 1
+               
+        self.model = aidlite.Model.create_instance(model_path)
+        if self.model is None:
+            print("Create model failed !")
+            return False
+        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 None
+        result = self.interpreter.init()
+        if result != 0:
+            print(f"interpreter init failed !")
+            return False
+        result = self.interpreter.load_model()
+        if result != 0:
+            print("interpreter load model failed !")
+            return False
+        print("detect model load success!")
+    
+    def __del__(self):
+        self.interpreter.destory()
+    
+    def __call__(self, img_input,invoke_nums):
+        result = self.interpreter.set_input_tensor(0, img_input.data)
+        if result != 0:
+            print("interpreter set_input_tensor() failed")
+        invoke_time=[]
+        for i in range(invoke_nums):
+            t1=time.time()
+            result = self.interpreter.invoke()
+            if result != 0:
+                print("interpreter set_input_tensor() failed")
+            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("====================================")
+
+        output1 = self.interpreter.get_output_tensor(0)
+        return output1
+        
+    
+class onnx_yolov10:
+    def __init__(self,model_path):
+        self.sess_options = onnxruntime.SessionOptions()
+        self.sess_options.intra_op_num_threads = 1
+        self.sess = onnxruntime.InferenceSession(model_path,sess_options=self.sess_options)
+        self.outname = [i.name for i in self.sess.get_outputs()]
+        self.inname = [i.name for i in self.sess.get_inputs()]
+    def __call__(self,img_input):
+        inp = {self.inname[0]:img_input}
+        t1=time.time()
+        out_put = self.sess.run(self.outname,inp)[0]
+        cost_time = (time.time()-t1)*1000
+        return out_put
+    
+    
+def main(args):
+    input_shape = (640, 640)
+    conf_thres = 0.25
+    img_path = args.imgs
+    invoke_nums = args.invoke_nums
+    qnn_path = args.target_model
+    
+    # qnn +onnx推理
+    qnn_model1 = qnn_yolov10(qnn_path)
+    
+    onnx_model_path = 'models/post_pro.onnx'
+    onnx_model = onnx_yolov10(onnx_model_path)
+
+    print("Begin to run qnn...")
+    im0 = cv2.imread(img_path)
+    image_shape = im0.shape[:2]
+    img_qnn = preprocess(im0, input_shape) 
+    qnn_out_shape = (1,8400,84)
+    out1 = qnn_model1(img_qnn,invoke_nums)
+    out1 = out1.reshape(*qnn_out_shape)
+    out2 = onnx_model(out1)[0]
+       
+    boxes, scores, labels = postprocess(out2, conf_thres, image_shape, input_shape)
+    print(f"Detect {len(boxes)} targets")
+    
+    colors = Colors()
+    for label, score, box in zip(labels, scores, boxes):
+        label_text = f'{classes[label]}: {score:.2f}'
+        color = colors(label, True)
+        cv2.rectangle(im0, (box[0], box[1]), (box[2], box[3]), color, 2, lineType=cv2.LINE_AA)
+        cv2.putText(im0, label_text, (box[0], box[1] - 10), cv2.FONT_HERSHEY_SIMPLEX, 0.5, color, 2)
+
+    output_image_path = "python/detected_results.jpg"
+    cv2.imwrite(output_image_path, im0)
+    print(f"Saved detected result to {output_image_path}")
+    
+
+
+def parser_args():
+    parser = argparse.ArgumentParser(description="Inferrence yolov10 model")
+    parser.add_argument('--target_model',type=str,default='./models/cutoff_yolov10x_fp16.qnn231.ctx.bin.aidem',help="Predict images path")
+    parser.add_argument('--imgs',type=str,default='./python/bus.jpg',help="Predict images path")
+    parser.add_argument('--invoke_nums',type=int,default=10,help="Inference nums")
+    args = parser.parse_args()
+    return args
+
+
+if __name__ == "__main__":
+    args = parser_args()
+    main(args)

model_farm_yolov10x_qcs8550_qnn2.31_int8_aidlite/README.md

@@ -0,0 +1,43 @@
+## Model Information
+
+### Source model
+- Input shape: [1,3,640,640]
+- Number of parameters: 30.34M
+- Model size: 112.73M
+- Output shape: [1,300,6]
+
+Source model repository: [YOLOV10-x](https://github.com/THU-MIG/yolov10)
+
+### Converted model
+
+- Precision: INT8
+- Backend: QNN2.31
+- Target Device: SNM972 QCS8550
+
+## Model Conversion Reference
+User can find model conversion reference at [aimo.aidlux.com](https://aimo.aidlux.com/#/public/7f3bee49-98bb-4d48-8635-3ed4c9c2bfc5)
+
+## Inference with AidLite SDK
+
+### SDK installation
+Model Farm uses AidLite SDK as the model inference SDK. For details, please refer to the [AidLite Developer Documentation](https://v2.docs.aidlux.com/en/sdk-api/aidlite-sdk/)
+
+- 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
+# aidlite sdk c++ check
+python3 -c "import aidlite ; print(aidlite.get_library_version())"
+
+# aidlite sdk python check
+python3 -c "import aidlite ; print(aidlite.get_py_library_version())"
+```

model_farm_yolov10x_qcs8550_qnn2.31_int8_aidlite/models/cutoff_yolov10x_w8a8.qnn231.ctx.bin.aidem

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

model_farm_yolov10x_qcs8550_qnn2.31_int8_aidlite/models/post_pro.onnx

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

model_farm_yolov10x_qcs8550_qnn2.31_w8a16_aidlite/README.md

@@ -0,0 +1,52 @@
+## Model Information
+
+### Source model
+- Input shape: [1,3,640,640]
+- Number of parameters: 30.34M
+- Model size: 112.73M
+- Output shape: [1,300,6]
+
+Source model repository: [YOLOV10-x](https://github.com/THU-MIG/yolov10)
+
+### Converted model
+
+- Precision: W8A16
+- Backend: QNN2.31
+- Target Device: SNM972 QCS8550
+
+## Model Conversion Reference
+User can find model conversion reference at [aimo.aidlux.com](https://aimo.aidlux.com/#/public/bde0409b-1fed-4ea8-8019-104ccfbb511a)
+
+## Inference with AidLite SDK
+
+### SDK installation
+Model Farm uses AidLite SDK as the model inference SDK. For details, please refer to the [AidLite Developer Documentation](https://v2.docs.aidlux.com/en/sdk-api/aidlite-sdk/)
+
+- 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
+# aidlite sdk c++ check
+python3 -c "import aidlite ; print(aidlite.get_library_version())"
+
+# aidlite sdk python check
+python3 -c "import aidlite ; print(aidlite.get_py_library_version())"
+```
+
+### Run Demo
+
+#### python
+ > Note: The ONNX model is used in the post-processing stage, and users' own models can also reuse this ONNX model.
+```bash
+cd model_farm_yolov10x_qcs8550_qnn2.31_w8a16_aidlite
+python3  python/run_test.py --target_model ./models/cutoff_yolov10x_w8a16.qnn231.ctx.bin.aidem --imgs ./python/bus.jpg  --invoke_nums 10
+```

model_farm_yolov10x_qcs8550_qnn2.31_w8a16_aidlite/models/cutoff_yolov10x_w8a16.qnn231.ctx.bin.aidem

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

model_farm_yolov10x_qcs8550_qnn2.31_w8a16_aidlite/models/post_pro.onnx

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

model_farm_yolov10x_qcs8550_qnn2.31_w8a16_aidlite/python/run_test.py

@@ -0,0 +1,265 @@
+import time
+import numpy as np
+import cv2
+import os
+import aidlite
+import argparse
+import onnxruntime  
+
+
+
+"""返回 COCO 数据集的类别名称（80 类）。"""
+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 letterbox(
+        im,
+        new_shape,
+        color=(114, 114, 114),
+        auto=False,
+        scaleFill=False,
+        scaleup=True,
+        stride=32,
+):
+    """
+    Resize and pad image while meeting stride-multiple constraints
+    Returns:
+        im (array): (height, width, 3)
+        ratio (array): [w_ratio, h_ratio]
+        (dw, dh) (array): [w_padding h_padding]
+    """
+    shape = im.shape[:2]  # current shape [height, width]
+    if isinstance(new_shape, int):  # [h_rect, w_rect]
+        new_shape = (new_shape, new_shape)
+ 
+    # Scale ratio (new / old)
+    r = min(new_shape[0] / shape[0], new_shape[1] / shape[1])
+    if not scaleup:  # only scale down, do not scale up (for better val mAP)
+        r = min(r, 1.0)
+ 
+    # Compute padding
+    ratio = r, r  # wh ratios
+    new_unpad = int(round(shape[1] * r)), int(round(shape[0] * r))  # w h
+    dw, dh = (
+        new_shape[1] - new_unpad[0],
+        new_shape[0] - new_unpad[1],
+    )  # wh padding
+ 
+    if auto:  # minimum rectangle
+        dw, dh = np.mod(dw, stride), np.mod(dh, stride)  # wh padding
+    elif scaleFill:  # stretch
+        dw, dh = 0.0, 0.0
+        new_unpad = (new_shape[1], new_shape[0])  # [w h]
+        ratio = (
+            new_shape[1] / shape[1],
+            new_shape[0] / shape[0],
+        )  # [w_ratio, h_ratio]
+ 
+    dw /= 2  # divide padding into 2 sides
+    dh /= 2
+    if shape[::-1] != new_unpad:  # resize
+        im = cv2.resize(im, new_unpad, interpolation=cv2.INTER_LINEAR)
+    top, bottom = int(round(dh - 0.1)), int(round(dh + 0.1))
+    left, right = int(round(dw - 0.1)), int(round(dw + 0.1))
+    im = cv2.copyMakeBorder(
+        im, top, bottom, left, right, cv2.BORDER_CONSTANT, value=color
+    )
+    return im, ratio, (dw, dh)
+
+
+class Colors:
+    
+    def __init__(self):
+        hexs = ('FF3838', 'FF9D97', 'FF701F', 'FFB21D', 'CFD231', '48F90A', '92CC17', '3DDB86', '1A9334', '00D4BB',
+                '2C99A8', '00C2FF', '344593', '6473FF', '0018EC', '8438FF', '520085', 'CB38FF', 'FF95C8', 'FF37C7')
+        self.palette = [self.hex2rgb(f'#{c}') for c in hexs]
+        self.n = len(self.palette)
+
+    def __call__(self, i, bgr=False):
+        c = self.palette[int(i) % self.n]
+        return (c[2], c[1], c[0]) if bgr else c
+
+    @staticmethod
+    def hex2rgb(h):
+        return tuple(int(h[1 + i:1 + i + 2], 16) for i in (0, 2, 4))
+
+
+def rescale_coords(boxes, image_shape, input_shape):
+    image_height, image_width = image_shape
+    input_height, input_width = input_shape
+    scale = min(input_width / image_width, input_height / image_height)
+    pad_w = (input_width - image_width * scale) / 2
+    pad_h = (input_height - image_height * scale) / 2
+    boxes[:, [0, 2]] = (boxes[:, [0, 2]] - pad_w) / scale
+    boxes[:, [1, 3]] = (boxes[:, [1, 3]] - pad_h) / scale
+    boxes[:, [0, 2]] = np.clip(boxes[:, [0, 2]], 0, image_width)
+    boxes[:, [1, 3]] = np.clip(boxes[:, [1, 3]], 0, image_height)
+    return boxes.astype(int)
+
+def preprocess(image, input_shape):
+    # Resize
+    input_img = letterbox(image, input_shape)[0]
+    # Transpose
+    # input_img = input_img[..., ::-1].transpose(2, 0, 1)
+    input_img = input_img[..., ::-1]
+    # Expand
+    input_img = input_img[np.newaxis, :, :, :].astype(np.float32)
+    # Contiguous
+    input_img = np.ascontiguousarray(input_img)
+    # Norm
+    blob = input_img / 255.0
+    return blob
+
+def postprocess(output_data, conf_thres, image_shape, input_shape):
+    outs = output_data  # test.py 中 output_data 已经是 (8400, 84)
+    outs = outs[outs[:, 4] >= conf_thres]
+    boxes = outs[:, :4]
+    scores = outs[:, -2]
+    labels = outs[:, -1].astype(int)
+    boxes = rescale_coords(boxes, image_shape, input_shape)
+    return boxes, scores, labels
+
+class qnn_yolov10:
+    def __init__(self,model_path,sdk="qnn",backend="npu"):
+        self.config = aidlite.Config.create_instance()
+        if self.config is None:
+            print("Create config failed !")
+            return False
+
+        self.config.implement_type = aidlite.ImplementType.TYPE_LOCAL
+        if sdk.lower()=="qnn":
+            self.config.framework_type = aidlite.FrameworkType.TYPE_QNN
+        else :
+            self.config.framework_type = aidlite.FrameworkType.TYPE_SNPE2
+            
+
+        if backend.lower() =="npu":
+            self.config.accelerate_type = aidlite.AccelerateType.TYPE_DSP
+        elif backend.lower() =="gpu":
+            self.config.accelerate_type = aidlite.AccelerateType.TYPE_GPU
+        else:
+            self.config.accelerate_type = aidlite.AccelerateType.TYPE_CPU
+        self.config.is_quantify_model = 1
+               
+        self.model = aidlite.Model.create_instance(model_path)
+        if self.model is None:
+            print("Create model failed !")
+            return False
+        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 None
+        result = self.interpreter.init()
+        if result != 0:
+            print(f"interpreter init failed !")
+            return False
+        result = self.interpreter.load_model()
+        if result != 0:
+            print("interpreter load model failed !")
+            return False
+        print("detect model load success!")
+    
+    def __del__(self):
+        self.interpreter.destory()
+    
+    def __call__(self, img_input,invoke_nums):
+        result = self.interpreter.set_input_tensor(0, img_input.data)
+        if result != 0:
+            print("interpreter set_input_tensor() failed")
+        invoke_time=[]
+        for i in range(invoke_nums):
+            t1=time.time()
+            result = self.interpreter.invoke()
+            if result != 0:
+                print("interpreter set_input_tensor() failed")
+            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("====================================")
+
+        output1 = self.interpreter.get_output_tensor(0)
+        return output1
+        
+    
+class onnx_yolov10:
+    def __init__(self,model_path):
+        self.sess_options = onnxruntime.SessionOptions()
+        self.sess_options.intra_op_num_threads = 1
+        self.sess = onnxruntime.InferenceSession(model_path,sess_options=self.sess_options)
+        self.outname = [i.name for i in self.sess.get_outputs()]
+        self.inname = [i.name for i in self.sess.get_inputs()]
+    def __call__(self,img_input):
+        inp = {self.inname[0]:img_input}
+        t1=time.time()
+        out_put = self.sess.run(self.outname,inp)[0]
+        cost_time = (time.time()-t1)*1000
+        return out_put
+    
+    
+def main(args):
+    input_shape = (640, 640)
+    conf_thres = 0.25
+    img_path = args.imgs
+    invoke_nums = args.invoke_nums
+    qnn_path = args.target_model
+    
+    # qnn +onnx推理
+    qnn_model1 = qnn_yolov10(qnn_path)
+    
+    onnx_model_path = 'models/post_pro.onnx'
+    onnx_model = onnx_yolov10(onnx_model_path)
+
+    print("Begin to run qnn...")
+    im0 = cv2.imread(img_path)
+    image_shape = im0.shape[:2]
+    img_qnn = preprocess(im0, input_shape) 
+    qnn_out_shape = (1,8400,84)
+    out1 = qnn_model1(img_qnn,invoke_nums)
+    out1 = out1.reshape(*qnn_out_shape)
+    out2 = onnx_model(out1)[0]
+       
+    boxes, scores, labels = postprocess(out2, conf_thres, image_shape, input_shape)
+    print(f"Detect {len(boxes)} targets")
+    
+    colors = Colors()
+    for label, score, box in zip(labels, scores, boxes):
+        label_text = f'{classes[label]}: {score:.2f}'
+        color = colors(label, True)
+        cv2.rectangle(im0, (box[0], box[1]), (box[2], box[3]), color, 2, lineType=cv2.LINE_AA)
+        cv2.putText(im0, label_text, (box[0], box[1] - 10), cv2.FONT_HERSHEY_SIMPLEX, 0.5, color, 2)
+
+    output_image_path = "python/detected_results.jpg"
+    cv2.imwrite(output_image_path, im0)
+    print(f"Saved detected result to {output_image_path}")
+    
+
+
+def parser_args():
+    parser = argparse.ArgumentParser(description="Inferrence yolov10 model")
+    parser.add_argument('--target_model',type=str,default='./models/cutoff_yolov10x_w8a16.qnn231.ctx.bin.aidem',help="Predict images path")
+    parser.add_argument('--imgs',type=str,default='./python/bus.jpg',help="Predict images path")
+    parser.add_argument('--invoke_nums',type=int,default=10,help="Inference nums")
+    args = parser.parse_args()
+    return args
+
+
+if __name__ == "__main__":
+    args = parser_args()
+    main(args)