def test_data_layout():
infer_server =cnis.InferServer(dev_id=0)
# Load model
model = infer_server.load_model(utils.model_dir)
# Check model input and output data type and dim order
if cnis.get_device_core_version(dev_id=0) == cnis.CoreVersion.MLU270 or \
cnis.get_device_core_version(dev_id=0) == cnis.CoreVersion.MLU220:
assert model.input_layout(0).dtype == cnis.DataType.UINT8
assert model.input_layout(0).order == cnis.DimOrder.NHWC
assert model.output_layout(0).dtype == cnis.DataType.FLOAT16
assert model.output_layout(0).order == cnis.DimOrder.NHWC
else:
assert model.input_layout(0).dtype == cnis.DataType.UINT8
assert model.input_layout(0).order == cnis.DimOrder.NHWC
assert model.output_layout(0).dtype == cnis.DataType.FLOAT32
assert model.output_layout(0).order == cnis.DimOrder.NONE
assert model.output_layout(1).dtype == cnis.DataType.INT32
assert model.output_layout(1).order == cnis.DimOrder.NONE
# Check data type size is correct
assert cnis.get_type_size(cnis.DataType.UINT8) == 1
assert cnis.get_type_size(cnis.DataType.FLOAT32) == 4
assert cnis.get_type_size(cnis.DataType.FLOAT16) == 2
assert cnis.get_type_size(cnis.DataType.INT16) == 2
assert cnis.get_type_size(cnis.DataType.INT32) == 4
def test_observer():
infer_server = cnis.InferServer(dev_id=0)
session_desc = cnis.SessionDesc()
session_desc.model = infer_server.load_model(utils.model_dir)
session_desc.show_perf = False
class TestPostproc(cnis.Postprocess):
"""To use custom postprocess, we define a class TestPostproc which inherits from cnis.Postprocess.
The execute_func API will be called by InferServer to do postprocess.
"""
def __init__(self):
super().__init__()
def execute_func(self, result, model_output, model_info):
result.set({"key1": "result1", "key2": "result2"})
return True
session_desc.postproc = cnis.Postprocessor()
session_desc.set_postproc_func(TestPostproc().execute)
class TestObserver(cnis.Observer):
"""To receive results from InferServer, we define a class TestObserver which inherits from cnis.Observer.
After a request is sent to InferServer and is processed by InferServer, the response_func API will be called with
status, results and user data.
"""
def __init__(self):
super().__init__()
self.called = False
def response_func(self, status, data, user_data):
# Check user data
assert "user_data" in user_data
assert user_data["user_data"] == "cnis"
assert len(data.data) == 1
# Check data
result = data.data[0].get_dict()
assert "key1" in result
assert "key2" in result
assert result["key1"] == "result1"
assert result["key2"] == "result2"
self.called = True
obs = TestObserver()
session = infer_server.create_session(session_desc, obs)
input_pak = cnis.Package(1, utils.tag)
if cnis.get_device_core_version(dev_id=0) == cnis.CoreVersion.MLU270 or \
cnis.get_device_core_version(dev_id=0) == cnis.CoreVersion.MLU220:
input_pak.data[0].set(
np.random.randint(0, 255, size=(300, 300, 4), dtype=np.uint8))
else:
input_pak.data[0].set(
np.random.randint(0, 255, size=(416, 416, 3), dtype=np.uint8))
infer_server.request(session, input_pak, {"user_data": "cnis"})
infer_server.wait_task_done(session, utils.tag)
assert obs.called
infer_server.destroy_session(session)
def test_video_infer_server_request_sync():
# Create VideoInferServer object
infer_server = cnis.VideoInferServer(dev_id=0)
session_desc = cnis.SessionDesc()
session_desc.name = "test_session"
# Load model
session_desc.model = infer_server.load_model(utils.model_dir)
# Create VideoPreprocessorMLU and set parameters. Use CNCV preproc.
session_desc.preproc = cnis.VideoPreprocessorMLU()
if cnis.get_device_core_version(dev_id=0) == cnis.CoreVersion.MLU270 or \
cnis.get_device_core_version(dev_id=0) == cnis.CoreVersion.MLU220:
session_desc.set_preproc_params(
cnis.VideoPixelFmt.BGRA,
cnis.VideoPreprocessType.CNCV_PREPROC,
keep_aspect_ratio=False)
else:
session_desc.set_preproc_params(
cnis.VideoPixelFmt.RGB24,
cnis.VideoPreprocessType.CNCV_PREPROC,
keep_aspect_ratio=True)
session_desc.show_perf = False
# Create synchronous session
session = infer_server.create_sync_session(session_desc)
# Prepare input video_frame
video_frame = utils.prepare_video_frame()
output = cnis.Package(1, utils.tag)
status = cnis.Status.SUCCESS
# Request VideoFrame
assert infer_server.request_sync(session, video_frame, utils.tag,
status, output)
assert status == cnis.Status.SUCCESS
# Prepare input video_frame
video_frame = utils.prepare_video_frame()
input_pak = cnis.Package(1, utils.tag)
input_pak.data[0].set(video_frame)
# Request input package
assert infer_server.request_sync(session, input_pak, status, output)
assert status == cnis.Status.SUCCESS
# Prepare input with bounding boxes
video_frame = utils.prepare_video_frame()
bbox = [cnis.BoundingBox(x=0, y=0, w=0.5, h=0.5)] * 4
output = cnis.Package(1, utils.tag)
status = cnis.Status.SUCCESS
# Request VideoFrame and bounding boxes of it
assert infer_server.request_sync(session, video_frame, bbox, utils.tag,
status, output)
assert status == cnis.Status.SUCCESS
# Destroy session
infer_server.destroy_session(session)
def prepare_input(model):
"""Read image from file. Set OpenCV mat to input package."""
img = cv2.imread(cur_file_dir + "/data/test.jpg")
# resize to model input shape
resized_img = cv2.resize(img, (get_model_input_wh(model)))
# convert color to model input pixel format
if cnis.get_device_core_version(dev_id=0) == cnis.CoreVersion.MLU270 or \
cnis.get_device_core_version(dev_id=0) == cnis.CoreVersion.MLU220:
result_img = cv2.cvtColor(resized_img, cv2.COLOR_BGR2BGRA)
else:
result_img = cv2.cvtColor(resized_img, cv2.COLOR_BGR2RGB)
# Create input package and set OpenCV mat to input package
input_pak = cnis.Package(1, utils.tag)
input_pak.data[0].set(result_img)
return input_pak
def test_video_preprocessor_mlu():
# Create VideoPreprocessorMLU
preproc = cnis.VideoPreprocessorMLU()
assert preproc
# Create InferServer object
infer_server = cnis.InferServer(dev_id=0)
session_desc = cnis.SessionDesc()
session_desc.name = "test_session"
# Load model
session_desc.model = infer_server.load_model(utils.model_dir)
# Create VideoPreprocessorMLU and set parameters. Use CNCV preproc.
session_desc.preproc = preproc
if cnis.get_device_core_version(dev_id=0) == cnis.CoreVersion.MLU270 or \
cnis.get_device_core_version(dev_id=0) == cnis.CoreVersion.MLU220:
session_desc.set_preproc_params(
cnis.VideoPixelFmt.BGRA,
cnis.VideoPreprocessType.CNCV_PREPROC,
keep_aspect_ratio=False)
else:
session_desc.set_preproc_params(
cnis.VideoPixelFmt.RGB24,
cnis.VideoPreprocessType.CNCV_PREPROC,
keep_aspect_ratio=True)
session_desc.show_perf = False
# Create synchronous session
session = infer_server.create_sync_session(session_desc)
# Request
request_package(infer_server, session)
# Destroy sessoion
infer_server.destroy_session(session)
# Use RCOP preproc.
if cnis.get_device_core_version(dev_id=0) == cnis.CoreVersion.MLU270 or \
cnis.get_device_core_version(dev_id=0) == cnis.CoreVersion.MLU220:
session_desc.set_preproc_params(
cnis.VideoPixelFmt.BGRA,
cnis.VideoPreprocessType.RESIZE_CONVERT,
keep_aspect_ratio=False)
# Create synchronous session
session = infer_server.create_sync_session(session_desc)
# Request
request_package(infer_server, session)
# Destroy sessoion
infer_server.destroy_session(session)
def __init__(self, device_id):
self.tag = "stream_0"
self.dev_id = device_id
self.core_ver = cnis.get_device_core_version(self.dev_id)
self.model_dir = "http://video.cambricon.com/models/MLU270/Primary_Detector/ssd/vgg16_ssd_b4c4_bgra_mlu270.cambricon"
if self.core_ver == cnis.CoreVersion.MLU220:
self.model_dir = "http://video.cambricon.com/models/MLU220/Primary_Detector/ssd/vgg16_ssd_b4c4_bgra_mlu220.cambricon"
elif self.core_ver == cnis.CoreVersion.MLU370:
self.model_dir = "http://video.cambricon.com/models/MLU370/yolov3_nhwc_tfu_0.8.2_uint8_int8_fp16.model"
def test_model():
infer_server = cnis.InferServer(dev_id=0)
model = infer_server.load_model(utils.model_dir)
if cnis.get_device_core_version(dev_id=0) == cnis.CoreVersion.MLU270 or \
cnis.get_device_core_version(dev_id=0) == cnis.CoreVersion.MLU220:
assert model.input_layout(0)
assert model.input_shape(0)
assert model.output_layout(0)
assert model.output_shape(0)
assert model.input_num() == 1
assert model.output_num() == 1
assert model.batch_size() == 4
assert model.get_key() == "./vgg16_ssd_b4c4_bgra_mlu270.cambricon_subnet0"
else:
assert model.input_layout(0)
assert model.input_shape(0)
assert model.output_layout(0)
assert model.output_shape(0)
assert model.output_layout(1)
assert model.output_shape(1)
assert model.input_num() == 1
assert model.output_num() == 2
assert model.batch_size() == 4
assert model.get_key() == "./yolov3_nhwc_tfu_0.8.2_uint8_int8_fp16.model"
def test_video_infer_server_request_async():
# Create VideoInferServer object
infer_server = cnis.VideoInferServer(dev_id=0)
session_desc = cnis.SessionDesc()
session_desc.name = "test_session"
# Load model
session_desc.model = infer_server.load_model(utils.model_dir)
# Create VideoPreprocessorMLU and set parameters. Use CNCV preproc.
session_desc.preproc = cnis.VideoPreprocessorMLU()
if cnis.get_device_core_version(dev_id=0) == cnis.CoreVersion.MLU270 or \
cnis.get_device_core_version(dev_id=0) == cnis.CoreVersion.MLU220:
session_desc.set_preproc_params(
cnis.VideoPixelFmt.BGRA,
cnis.VideoPreprocessType.CNCV_PREPROC,
keep_aspect_ratio=False)
else:
session_desc.set_preproc_params(
cnis.VideoPixelFmt.RGB24,
cnis.VideoPreprocessType.CNCV_PREPROC,
keep_aspect_ratio=True)
session_desc.show_perf = False
# Define a TestObserver class to receive results
class TestObserver(cnis.Observer):
"""To receive results from InferServer, we define a class MyObserver which inherits from cnis.Observer.
After a request is sent to InferServer and is processed by InferServer, the response_func API will be called with
status, results and user data.
"""
def __init__(self):
super().__init__()
self.called = False
def response_func(self, status, data, user_data):
assert status == cnis.Status.SUCCESS
assert "user_data" in user_data
assert user_data["user_data"] == "cnis"
self.called = True
# Create observer
obs = TestObserver()
# Create asynchronous session
session = infer_server.create_session(session_desc, obs)
# Prepare input video_frame
video_frame = utils.prepare_video_frame()
# Create user data
user_data = {"user_data": "cnis"}
# Request VideoFrame
assert infer_server.request(session, video_frame, utils.tag, user_data)
# Prepare input package
video_frame = utils.prepare_video_frame()
input_pak = cnis.Package(1, utils.tag)
input_pak.data[0].set(video_frame)
# Request package
assert infer_server.request(session, input_pak, user_data)
# Prepare input with bounding box
video_frame = utils.prepare_video_frame()
bbox = [cnis.BoundingBox(x=0, y=0, w=0.5, h=0.5)] * 4
# Request VideoFrame and bounding boxes of it
assert infer_server.request(session, video_frame, bbox, utils.tag,
user_data)
infer_server.wait_task_done(session, utils.tag)
assert obs.called
# Destroy session
infer_server.destroy_session(session)
