Upload 20 files

model_farm_real_esrgan_x4plus_qcs6490_qnn2.31_int8_aidlite/README.md

@@ -0,0 +1,49 @@
+## Model Information
+
+### Source model
+- Input shape: [1x3x128x128]
+- Number of parameters: 15.92M
+- Model size: 67.76M
+- Output shape: [1x3x512x512]
+
+Source model repository: [Real-ESRGAN-x4plus](https://github.com/xinntao/Real-ESRGAN)
+
+### 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/f0a4a851-b89a-4ccb-9035-ddd7b6494801)
+
+## 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
+```bash
+cd model_farm_real_esrgan_x4plus_qcs6490_qnn2.31_int8_aidlite
+python3 python/run_test.py --target_model ./models/real_esrgan_x4plus_w8a8.qnn231.ctx.bin --imgs ./python/original_image.jpg   --invoke_nums 10 
+```

model_farm_real_esrgan_x4plus_qcs6490_qnn2.31_int8_aidlite/models/real_esrgan_x4plus_w8a8.qnn231.ctx.bin

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

model_farm_real_esrgan_x4plus_qcs6490_qnn2.31_int8_aidlite/python/run_test.py

@@ -0,0 +1,100 @@
+import sys
+import time
+import aidlite
+import cv2
+import numpy as np
+import argparse
+import json
+
+def run(input_shapes,output_shapes,is_quant=True):
+    args = parser_args()
+    model_path = args.target_model
+    img_path = args.imgs
+    model_type = args.model_type
+    invoke_nums = int(args.invoke_nums)
+
+    model = aidlite.Model.create_instance(model_path)
+    model.set_model_properties(input_shapes, aidlite.DataType.TYPE_FLOAT32,
+                               output_shapes, aidlite.DataType.TYPE_FLOAT32)
+                               
+    config = aidlite.Config.create_instance()
+    config.implement_type = aidlite.ImplementType.TYPE_LOCAL
+    if model_type.lower()=="qnn" :
+        config.framework_type = aidlite.FrameworkType.TYPE_QNN231
+        config.accelerate_type = aidlite.AccelerateType.TYPE_DSP
+    elif model_type.lower()=="snpe2" or model_type.lower()=="snpe":
+        config.framework_type = aidlite.FrameworkType.TYPE_SNPE2
+        config.accelerate_type = aidlite.AccelerateType.TYPE_DSP
+        
+    config.number_of_threads = 4
+    if is_quant:
+        config.is_quantify_model = 1
+                               
+    interpreter = aidlite.InterpreterBuilder.build_interpretper_from_model_and_config(model, config)
+    if interpreter is None:
+        print("build_interpretper_from_model_and_config failed !")
+    result = interpreter.init()
+    if result != 0:
+        print(f"interpreter init failed !")
+        return False
+    result = interpreter.load_model()
+    if result != 0:
+        print("interpreter load model failed !")
+        return False
+    print("detect model load success!")
+        
+    
+    frame = cv2.imread(img_path)
+    frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
+    img_input=cv2.resize(frame,(128,128))
+    img_input = img_input/255.
+    img_input = img_input.astype(np.float32)
+    
+
+    invoke_time=[]
+    for i in range(invoke_nums):
+        result = interpreter.set_input_tensor(0, img_input.data)
+        if result != 0:
+            print("interpreter set_input_tensor() failed")
+        t1=time.time()
+        result = interpreter.invoke()
+        cost_time = (time.time()-t1)*1000
+        invoke_time.append(cost_time)
+        if result != 0:
+            print("interpreter set_input_tensor() failed")
+        qnn_out = interpreter.get_output_tensor(0)
+        if qnn_out is None:
+            print("sample : interpreter->get_output_tensor() 0 failed !")
+    result = interpreter.destory()
+
+    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 time:\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("====================================")
+    
+    return qnn_out
+
+    
+
+def parser_args():
+    parser = argparse.ArgumentParser(description="Run model benchmarks")
+    parser.add_argument('--target_model',type=str,default='./models/real_esrgan_x4plus_w8a8.qnn231.ctx.bin',help="Inference model path")
+    parser.add_argument('--imgs',type=str,default='./python/baboon.png',help="Predict images path")
+    parser.add_argument('--invoke_nums',type=str,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__":
+    input_shapes=[[1,128,128,3]]
+    output_shapes=[[1,512,512,3]]
+    qnn_out=run(input_shapes,output_shapes)
+    qnn_out = qnn_out.reshape(1,512,512,3)
+    qnn_img = (qnn_out[0]*255).astype(np.uint8)
+    qnn_img = cv2.cvtColor(qnn_img, cv2.COLOR_RGB2BGR)
+    cv2.imwrite("python/results.png",qnn_img)
+        

model_farm_real_esrgan_x4plus_qcs6490_qnn2.31_w8a16_aidlite/README.md

@@ -0,0 +1,49 @@
+## Model Information
+
+### Source model
+- Input shape: [1x3x128x128]
+- Number of parameters: 15.92M
+- Model size: 67.76M
+- Output shape: [1x3x512x512]
+
+Source model repository: [Real-ESRGAN-x4plus](https://github.com/xinntao/Real-ESRGAN)
+
+### 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/898d1eba-352d-441a-8b83-663e86cd433b)
+
+## 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
+```bash
+cd model_farm_real_esrgan_x4plus_qcs6490_qnn2.31_w8a16_aidlite
+python3 python/run_test.py --target_model ./models/real_esrgan_x4plus_w8a16.qnn231.ctx.bin --imgs ./python/original_image.jpg   --invoke_nums 10 
+```

model_farm_real_esrgan_x4plus_qcs6490_qnn2.31_w8a16_aidlite/models/real_esrgan_x4plus_w8a16.qnn231.ctx.bin

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

model_farm_real_esrgan_x4plus_qcs6490_qnn2.31_w8a16_aidlite/python/run_test.py

@@ -0,0 +1,100 @@
+import sys
+import time
+import aidlite
+import cv2
+import numpy as np
+import argparse
+import json
+
+def run(input_shapes,output_shapes,is_quant=True):
+    args = parser_args()
+    model_path = args.target_model
+    img_path = args.imgs
+    model_type = args.model_type
+    invoke_nums = int(args.invoke_nums)
+
+    model = aidlite.Model.create_instance(model_path)
+    model.set_model_properties(input_shapes, aidlite.DataType.TYPE_FLOAT32,
+                               output_shapes, aidlite.DataType.TYPE_FLOAT32)
+                               
+    config = aidlite.Config.create_instance()
+    config.implement_type = aidlite.ImplementType.TYPE_LOCAL
+    if model_type.lower()=="qnn" :
+        config.framework_type = aidlite.FrameworkType.TYPE_QNN231
+        config.accelerate_type = aidlite.AccelerateType.TYPE_DSP
+    elif model_type.lower()=="snpe2" or model_type.lower()=="snpe":
+        config.framework_type = aidlite.FrameworkType.TYPE_SNPE2
+        config.accelerate_type = aidlite.AccelerateType.TYPE_DSP
+        
+    config.number_of_threads = 4
+    if is_quant:
+        config.is_quantify_model = 1
+                               
+    interpreter = aidlite.InterpreterBuilder.build_interpretper_from_model_and_config(model, config)
+    if interpreter is None:
+        print("build_interpretper_from_model_and_config failed !")
+    result = interpreter.init()
+    if result != 0:
+        print(f"interpreter init failed !")
+        return False
+    result = interpreter.load_model()
+    if result != 0:
+        print("interpreter load model failed !")
+        return False
+    print("detect model load success!")
+        
+    
+    frame = cv2.imread(img_path)
+    frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
+    img_input=cv2.resize(frame,(128,128))
+    img_input = img_input/255.
+    img_input = img_input.astype(np.float32)
+    
+
+    invoke_time=[]
+    for i in range(invoke_nums):
+        result = interpreter.set_input_tensor(0, img_input.data)
+        if result != 0:
+            print("interpreter set_input_tensor() failed")
+        t1=time.time()
+        result = interpreter.invoke()
+        cost_time = (time.time()-t1)*1000
+        invoke_time.append(cost_time)
+        if result != 0:
+            print("interpreter set_input_tensor() failed")
+        qnn_out = interpreter.get_output_tensor(0)
+        if qnn_out is None:
+            print("sample : interpreter->get_output_tensor() 0 failed !")
+    result = interpreter.destory()
+
+    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 time:\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("====================================")
+    
+    return qnn_out
+
+    
+
+def parser_args():
+    parser = argparse.ArgumentParser(description="Run model benchmarks")
+    parser.add_argument('--target_model',type=str,default='./models/real_esrgan_x4plus_w8a16.qnn231.ctx.bin',help="Inference model path")
+    parser.add_argument('--imgs',type=str,default='./python/baboon.png',help="Predict images path")
+    parser.add_argument('--invoke_nums',type=str,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__":
+    input_shapes=[[1,128,128,3]]
+    output_shapes=[[1,512,512,3]]
+    qnn_out=run(input_shapes,output_shapes)
+    qnn_out = qnn_out.reshape(1,512,512,3)
+    qnn_img = (qnn_out[0]*255).astype(np.uint8)
+    qnn_img = cv2.cvtColor(qnn_img, cv2.COLOR_RGB2BGR)
+    cv2.imwrite("python/results.png",qnn_img)
+        

model_farm_real_esrgan_x4plus_qcs8550_qnn2.31_fp16_aidlite/README.md

@@ -0,0 +1,49 @@
+## Model Information
+
+### Source model
+- Input shape: [1x3x128x128]
+- Number of parameters: 15.92M
+- Model size: 67.76M
+- Output shape: [1x3x512x512]
+
+Source model repository: [Real-ESRGAN-x4plus](https://github.com/xinntao/Real-ESRGAN)
+
+### 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/c32bd626-0d40-4367-942f-03576c5118f5)
+
+## 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
+```bash
+cd model_farm_real_esrgan_x4plus_qcs8550_qnn2.31_fp16_aidlite
+python3 python/run_test.py --target_model ./models/real_esrgan_x4plus_fp16.qnn231.ctx.bin --imgs ./python/original_image.jpg   --invoke_nums 10 
+```

model_farm_real_esrgan_x4plus_qcs8550_qnn2.31_fp16_aidlite/models/real_esrgan_x4plus_fp16.qnn231.ctx.bin

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

model_farm_real_esrgan_x4plus_qcs8550_qnn2.31_fp16_aidlite/python/run_test.py

@@ -0,0 +1,100 @@
+import sys
+import time
+import aidlite
+import cv2
+import numpy as np
+import argparse
+import json
+
+def run(input_shapes,output_shapes,is_quant=True):
+    args = parser_args()
+    model_path = args.target_model
+    img_path = args.imgs
+    model_type = args.model_type
+    invoke_nums = int(args.invoke_nums)
+
+    model = aidlite.Model.create_instance(model_path)
+    model.set_model_properties(input_shapes, aidlite.DataType.TYPE_FLOAT32,
+                               output_shapes, aidlite.DataType.TYPE_FLOAT32)
+                               
+    config = aidlite.Config.create_instance()
+    config.implement_type = aidlite.ImplementType.TYPE_LOCAL
+    if model_type.lower()=="qnn" :
+        config.framework_type = aidlite.FrameworkType.TYPE_QNN231
+        config.accelerate_type = aidlite.AccelerateType.TYPE_DSP
+    elif model_type.lower()=="snpe2" or model_type.lower()=="snpe":
+        config.framework_type = aidlite.FrameworkType.TYPE_SNPE2
+        config.accelerate_type = aidlite.AccelerateType.TYPE_DSP
+        
+    config.number_of_threads = 4
+    if is_quant:
+        config.is_quantify_model = 1
+                               
+    interpreter = aidlite.InterpreterBuilder.build_interpretper_from_model_and_config(model, config)
+    if interpreter is None:
+        print("build_interpretper_from_model_and_config failed !")
+    result = interpreter.init()
+    if result != 0:
+        print(f"interpreter init failed !")
+        return False
+    result = interpreter.load_model()
+    if result != 0:
+        print("interpreter load model failed !")
+        return False
+    print("detect model load success!")
+        
+    
+    frame = cv2.imread(img_path)
+    frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
+    img_input=cv2.resize(frame,(128,128))
+    img_input = img_input/255.
+    img_input = img_input.astype(np.float32)
+    
+
+    invoke_time=[]
+    for i in range(invoke_nums):
+        result = interpreter.set_input_tensor(0, img_input.data)
+        if result != 0:
+            print("interpreter set_input_tensor() failed")
+        t1=time.time()
+        result = interpreter.invoke()
+        cost_time = (time.time()-t1)*1000
+        invoke_time.append(cost_time)
+        if result != 0:
+            print("interpreter set_input_tensor() failed")
+        qnn_out = interpreter.get_output_tensor(0)
+        if qnn_out is None:
+            print("sample : interpreter->get_output_tensor() 0 failed !")
+    result = interpreter.destory()
+
+    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 time:\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("====================================")
+    
+    return qnn_out
+
+    
+
+def parser_args():
+    parser = argparse.ArgumentParser(description="Run model benchmarks")
+    parser.add_argument('--target_model',type=str,default='./models/real_esrgan_x4plus_fp16.qnn231.ctx.bin',help="Inference model path")
+    parser.add_argument('--imgs',type=str,default='./python/baboon.png',help="Predict images path")
+    parser.add_argument('--invoke_nums',type=str,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__":
+    input_shapes=[[1,128,128,3]]
+    output_shapes=[[1,512,512,3]]
+    qnn_out=run(input_shapes,output_shapes)
+    qnn_out = qnn_out.reshape(1,512,512,3)
+    qnn_img = (qnn_out[0]*255).astype(np.uint8)
+    qnn_img = cv2.cvtColor(qnn_img, cv2.COLOR_RGB2BGR)
+    cv2.imwrite("python/results.png",qnn_img)
+        

model_farm_real_esrgan_x4plus_qcs8550_qnn2.31_int8_aidlite/README.md

@@ -0,0 +1,48 @@
+## Model Information
+
+### Source model
+- Input shape: [1x3x128x128]
+- Number of parameters: 15.92M
+- Model size: 67.76M
+- Output shape: [1x3x512x512]
+
+Source model repository: [Real-ESRGAN-x4plus](https://github.com/xinntao/Real-ESRGAN)
+### 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/82096bda-553e-42a7-a4b9-39083ea2ce9f)
+
+## 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
+```bash
+cd model_farm_real_esrgan_x4plus_qcs8550_qnn2.31_int8_aidlite
+python3 python/run_test.py --target_model ./models/real_esrgan_x4plus_w8a8.qnn231.ctx.bin --imgs ./python/original_image.jpg   --invoke_nums 10 
+```

model_farm_real_esrgan_x4plus_qcs8550_qnn2.31_int8_aidlite/models/real_esrgan_x4plus_w8a8.qnn231.ctx.bin

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

model_farm_real_esrgan_x4plus_qcs8550_qnn2.31_int8_aidlite/python/run_test.py

@@ -0,0 +1,100 @@
+import sys
+import time
+import aidlite
+import cv2
+import numpy as np
+import argparse
+import json
+
+def run(input_shapes,output_shapes,is_quant=True):
+    args = parser_args()
+    model_path = args.target_model
+    img_path = args.imgs
+    model_type = args.model_type
+    invoke_nums = int(args.invoke_nums)
+
+    model = aidlite.Model.create_instance(model_path)
+    model.set_model_properties(input_shapes, aidlite.DataType.TYPE_FLOAT32,
+                               output_shapes, aidlite.DataType.TYPE_FLOAT32)
+                               
+    config = aidlite.Config.create_instance()
+    config.implement_type = aidlite.ImplementType.TYPE_LOCAL
+    if model_type.lower()=="qnn" :
+        config.framework_type = aidlite.FrameworkType.TYPE_QNN231
+        config.accelerate_type = aidlite.AccelerateType.TYPE_DSP
+    elif model_type.lower()=="snpe2" or model_type.lower()=="snpe":
+        config.framework_type = aidlite.FrameworkType.TYPE_SNPE2
+        config.accelerate_type = aidlite.AccelerateType.TYPE_DSP
+        
+    config.number_of_threads = 4
+    if is_quant:
+        config.is_quantify_model = 1
+                               
+    interpreter = aidlite.InterpreterBuilder.build_interpretper_from_model_and_config(model, config)
+    if interpreter is None:
+        print("build_interpretper_from_model_and_config failed !")
+    result = interpreter.init()
+    if result != 0:
+        print(f"interpreter init failed !")
+        return False
+    result = interpreter.load_model()
+    if result != 0:
+        print("interpreter load model failed !")
+        return False
+    print("detect model load success!")
+        
+    
+    frame = cv2.imread(img_path)
+    frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
+    img_input=cv2.resize(frame,(128,128))
+    img_input = img_input/255.
+    img_input = img_input.astype(np.float32)
+    
+
+    invoke_time=[]
+    for i in range(invoke_nums):
+        result = interpreter.set_input_tensor(0, img_input.data)
+        if result != 0:
+            print("interpreter set_input_tensor() failed")
+        t1=time.time()
+        result = interpreter.invoke()
+        cost_time = (time.time()-t1)*1000
+        invoke_time.append(cost_time)
+        if result != 0:
+            print("interpreter set_input_tensor() failed")
+        qnn_out = interpreter.get_output_tensor(0)
+        if qnn_out is None:
+            print("sample : interpreter->get_output_tensor() 0 failed !")
+    result = interpreter.destory()
+
+    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 time:\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("====================================")
+    
+    return qnn_out
+
+    
+
+def parser_args():
+    parser = argparse.ArgumentParser(description="Run model benchmarks")
+    parser.add_argument('--target_model',type=str,default='./models/real_esrgan_x4plus_w8a8.qnn231.ctx.bin',help="Inference model path")
+    parser.add_argument('--imgs',type=str,default='./python/baboon.png',help="Predict images path")
+    parser.add_argument('--invoke_nums',type=str,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__":
+    input_shapes=[[1,128,128,3]]
+    output_shapes=[[1,512,512,3]]
+    qnn_out=run(input_shapes,output_shapes)
+    qnn_out = qnn_out.reshape(1,512,512,3)
+    qnn_img = (qnn_out[0]*255).astype(np.uint8)
+    qnn_img = cv2.cvtColor(qnn_img, cv2.COLOR_RGB2BGR)
+    cv2.imwrite("python/results.png",qnn_img)
+        

model_farm_real_esrgan_x4plus_qcs8550_qnn2.31_w8a16_aidlite/README.md

@@ -0,0 +1,49 @@
+## Model Information
+
+### Source model
+- Input shape: [1x3x128x128]
+- Number of parameters: 15.92M
+- Model size: 67.76M
+- Output shape: [1x3x512x512]
+
+Source model repository: [Real-ESRGAN-x4plus](https://github.com/xinntao/Real-ESRGAN)
+
+### 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/51fdc8f0-c87a-4b55-8ac5-bf4a7e637c62)
+
+## 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
+```bash
+cd model_farm_real_esrgan_x4plus_qcs8550_qnn2.31_w8a16_aidlite
+python3 python/run_test.py --target_model ./models/real_esrgan_x4plus_w8a16.qnn231.ctx.bin --imgs ./python/original_image.jpg   --invoke_nums 10 
+```

model_farm_real_esrgan_x4plus_qcs8550_qnn2.31_w8a16_aidlite/models/real_esrgan_x4plus_w8a16.qnn231.ctx.bin

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

model_farm_real_esrgan_x4plus_qcs8550_qnn2.31_w8a16_aidlite/python/run_test.py

@@ -0,0 +1,100 @@
+import sys
+import time
+import aidlite
+import cv2
+import numpy as np
+import argparse
+import json
+
+def run(input_shapes,output_shapes,is_quant=True):
+    args = parser_args()
+    model_path = args.target_model
+    img_path = args.imgs
+    model_type = args.model_type
+    invoke_nums = int(args.invoke_nums)
+
+    model = aidlite.Model.create_instance(model_path)
+    model.set_model_properties(input_shapes, aidlite.DataType.TYPE_FLOAT32,
+                               output_shapes, aidlite.DataType.TYPE_FLOAT32)
+                               
+    config = aidlite.Config.create_instance()
+    config.implement_type = aidlite.ImplementType.TYPE_LOCAL
+    if model_type.lower()=="qnn" :
+        config.framework_type = aidlite.FrameworkType.TYPE_QNN231
+        config.accelerate_type = aidlite.AccelerateType.TYPE_DSP
+    elif model_type.lower()=="snpe2" or model_type.lower()=="snpe":
+        config.framework_type = aidlite.FrameworkType.TYPE_SNPE2
+        config.accelerate_type = aidlite.AccelerateType.TYPE_DSP
+        
+    config.number_of_threads = 4
+    if is_quant:
+        config.is_quantify_model = 1
+                               
+    interpreter = aidlite.InterpreterBuilder.build_interpretper_from_model_and_config(model, config)
+    if interpreter is None:
+        print("build_interpretper_from_model_and_config failed !")
+    result = interpreter.init()
+    if result != 0:
+        print(f"interpreter init failed !")
+        return False
+    result = interpreter.load_model()
+    if result != 0:
+        print("interpreter load model failed !")
+        return False
+    print("detect model load success!")
+        
+    
+    frame = cv2.imread(img_path)
+    frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
+    img_input=cv2.resize(frame,(128,128))
+    img_input = img_input/255.
+    img_input = img_input.astype(np.float32)
+    
+
+    invoke_time=[]
+    for i in range(invoke_nums):
+        result = interpreter.set_input_tensor(0, img_input.data)
+        if result != 0:
+            print("interpreter set_input_tensor() failed")
+        t1=time.time()
+        result = interpreter.invoke()
+        cost_time = (time.time()-t1)*1000
+        invoke_time.append(cost_time)
+        if result != 0:
+            print("interpreter set_input_tensor() failed")
+        qnn_out = interpreter.get_output_tensor(0)
+        if qnn_out is None:
+            print("sample : interpreter->get_output_tensor() 0 failed !")
+    result = interpreter.destory()
+
+    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 time:\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("====================================")
+    
+    return qnn_out
+
+    
+
+def parser_args():
+    parser = argparse.ArgumentParser(description="Run model benchmarks")
+    parser.add_argument('--target_model',type=str,default='./models/real_esrgan_x4plus_w8a16.qnn231.ctx.bin',help="Inference model path")
+    parser.add_argument('--imgs',type=str,default='./python/baboon.png',help="Predict images path")
+    parser.add_argument('--invoke_nums',type=str,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__":
+    input_shapes=[[1,128,128,3]]
+    output_shapes=[[1,512,512,3]]
+    qnn_out=run(input_shapes,output_shapes)
+    qnn_out = qnn_out.reshape(1,512,512,3)
+    qnn_img = (qnn_out[0]*255).astype(np.uint8)
+    qnn_img = cv2.cvtColor(qnn_img, cv2.COLOR_RGB2BGR)
+    cv2.imwrite("python/results.png",qnn_img)
+