diff --git a/ACL_TensorFlow/contrib/cv/MNN-LANENET_ID1251_for_ACL/.keep b/ACL_TensorFlow/contrib/cv/MNN-LANENET_ID1251_for_ACL/.keep new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/ACL_TensorFlow/contrib/cv/MNN-LANENET_ID1251_for_ACL/README.md b/ACL_TensorFlow/contrib/cv/MNN-LANENET_ID1251_for_ACL/README.md new file mode 100644 index 0000000000000000000000000000000000000000..6a5ec5e7e69bcc10d2f54d2aefafbc4a6dd9ed3f --- /dev/null +++ b/ACL_TensorFlow/contrib/cv/MNN-LANENET_ID1251_for_ACL/README.md @@ -0,0 +1,139 @@ +## 模型功能 + + 车道线检测 + + + + +## pb模型 + +``` + +python3.7 ckpt2pb.py +``` + +convert_ckpt_into_pb_file（）函数，pb模型 PATH=./pretrained_model/eval.pb + +## om模型 + + +使用ATC模型转换工具进行模型转换时可以参考如下指令: + + +``` + +atc --model=/usr/pb2om/eval.pb + + --framework=3 + + --output=/usr/pb2om/frozen + + --soc_version=Ascend910 + + out_nodes="lanenet/binary_seg_out:0;lanenet/instance_seg_out:0" + + --input_shape="input_tensor:1,256,512,3" + + --input_format=NHWC +``` + + + +## 使用msame工具推理 + + +参考 https://gitee.com/ascend/tools/tree/master/msame, 获取msame推理工具及使用方法。 + +获取到msame可执行文件之后，进行推理测试。 + + + +## 数据集转换bin + +``` + +python3.7 eval_pb.py +``` + +freeze_graph_test（）函数 img_feed转test_img.bin + +## 推理测试 + + +使用msame推理工具，参考如下命令，发起推理测试： + + +``` + +./msame --model "/home/test_user05/pb2om/frozen.om" + + --input "/home/test_user05/pb2om/test_img.bin" + + --output "/home/test_user05/pb2om/" + + --outfmt BIN + + --loop 1 +``` + + +## 脚本和示例代码 + +代码：链接：链接：https://pan.baidu.com/s/1oqdEQGH8ixPv4tNMBRExfQ?pwd=6666 +提取码：6666 + + +输入数据：链接：https://pan.baidu.com/s/1bwZR3FfhP18mLMa44781Gw?pwd=0000 提取码：0000 + +├── eval_data + + +1.pb预测 + +├── eval_pb.py //主代码 + +├── lanenet_model + + ├── lanenet.py //LANENET模型 + +├── README.md //代码说明文档 + + + +2.om预测 + +├── eval_om.py //主代码 + +├── lanenet_model + + ├── lanenet.py //LANENET模型 + +├── README.md //代码说明文档 + + + +3.ckpt转pb + +├── ckpt2pb.py + + + +##推理输出计算精度 + +``` + +python3.7 eval_om.py +``` + +## 推理精度 +定量指标采用准确率，精度为0.965，精度达标。 +定性指标采用论文中可视化binary segmentation和instance segmentation，输出在eval_output下 + +| gpu | npu |原论文 |推理 | +|-------|------|-------|-------| +| 96.5 | 96.5 | 96.4 |96.5 | + + + +## 推理性能 +inference time.jpg，性能达标 \ No newline at end of file diff --git a/ACL_TensorFlow/contrib/cv/MNN-LANENET_ID1251_for_ACL/ckpt2pb.py b/ACL_TensorFlow/contrib/cv/MNN-LANENET_ID1251_for_ACL/ckpt2pb.py new file mode 100644 index 0000000000000000000000000000000000000000..8710bca837580db51f5deca6d84532ff5ba34ada --- /dev/null +++ b/ACL_TensorFlow/contrib/cv/MNN-LANENET_ID1251_for_ACL/ckpt2pb.py @@ -0,0 +1,78 @@ +# Copyright 2017 The TensorFlow Authors. All Rights Reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# ============================================================================ +# Copyright 2021 Huawei Technologies Co., Ltd +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +""" +Freeze Lanenet model into frozen pb file +""" +from __future__ import absolute_import +from __future__ import division +from __future__ import print_function + +import tensorflow as tf +import os + +os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2' + + +def convert_ckpt_into_pb_file(ckpt_file_path, pb_file_path): + """ + + :param ckpt_file_path: + :param pb_file_path: + :return: + """ + with tf.Session() as sess: + + saver = tf.train.import_meta_graph(ckpt_file_path + '.meta', clear_devices=True) + input_graph_def = tf.get_default_graph().as_graph_def() + + binary_seg_node = 'lanenet/binary_seg_out' + instance_seg_node = 'lanenet/instance_seg_out' + + saver.restore(sess, ckpt_file_path) # 恢复图并得到数据 + output_graph_def = tf.graph_util.convert_variables_to_constants( # 模型持久化，将变量值固定 + sess=sess, + input_graph_def=input_graph_def, + output_node_names=['input_tensor', binary_seg_node, instance_seg_node]) + + with tf.gfile.GFile(pb_file_path, "wb") as f: # 保存模型 + f.write(output_graph_def.SerializeToString()) # 序列化输出 + print("%d ops in the final graph." % len(output_graph_def.node)) + + +if __name__ == '__main__': + """ + test code + """ + + ckpt_path = './eval_ckpt/eval.ckpt' + pb_save_path = './pretrained_model/eval.pb' + + convert_ckpt_into_pb_file( + ckpt_file_path=ckpt_path, + pb_file_path=pb_save_path + ) diff --git a/ACL_TensorFlow/contrib/cv/MNN-LANENET_ID1251_for_ACL/eval_ckpt.py b/ACL_TensorFlow/contrib/cv/MNN-LANENET_ID1251_for_ACL/eval_ckpt.py new file mode 100644 index 0000000000000000000000000000000000000000..993c5719cf80a6963538b8523ce5f5469cba4f64 --- /dev/null +++ b/ACL_TensorFlow/contrib/cv/MNN-LANENET_ID1251_for_ACL/eval_ckpt.py @@ -0,0 +1,190 @@ +# Copyright 2017 The TensorFlow Authors. All Rights Reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# ============================================================================ +# Copyright 2021 Huawei Technologies Co., Ltd +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +""" +test LaneNet model on single image +""" +import argparse +import os.path as ops +import time + +import cv2 +import numpy as np +import tensorflow as tf + +from lanenet_model import lanenet +from lanenet_model import lanenet_postprocess +from local_utils.config_utils import parse_config_utils +from local_utils.log_util import init_logger + +CFG = parse_config_utils.lanenet_cfg +LOG = init_logger.get_logger(log_file_name_prefix='lanenet_test') + +gt_path = './eval_data/gt.png' + + +def init_args(): + """ + + :return: + """ + parser = argparse.ArgumentParser() + parser.add_argument('--image_path', default='./eval_data/test_img.jpg', + type=str, help='The image path or the src image save dir') + parser.add_argument('--weights_path', default='./pretrained_model/ckpt/tusimple_lanenet.ckpt', + type=str, help='The model weights path') + parser.add_argument('--with_lane_fit', type=args_str2bool, help='If need to do lane fit', default=False) + + return parser.parse_args() + + +def args_str2bool(arg_value): + """ + + :param arg_value: + :return: + """ + if arg_value.lower() in ('yes', 'true', 't', 'y', '1'): + return True + + elif arg_value.lower() in ('no', 'false', 'f', 'n', '0'): + return False + else: + raise argparse.ArgumentTypeError('Unsupported value encountered.') + + +def minmax_scale(input_arr): + """ + + :param input_arr: + :return: + """ + min_val = np.min(input_arr) + max_val = np.max(input_arr) + + output_arr = (input_arr - min_val) * 255.0 / (max_val - min_val) + + return output_arr + + +def test_lanenet(image_path, gt_path, weights_path, with_lane_fit=False): + """ + + :param image_path: + :param weights_path: + :param with_lane_fit: + :return: + """ + assert ops.exists(image_path), '{:s} not exist'.format(image_path) + + LOG.info('Start reading image and preprocessing') + t_start = time.time() + image = cv2.imread(image_path, cv2.IMREAD_COLOR) + image_vis = image + image = cv2.resize(image, (512, 256), interpolation=cv2.INTER_LINEAR) + image = image / 127.5 - 1.0 + LOG.info('Image load complete, cost time: {:.5f}s'.format(time.time() - t_start)) + + input_tensor_0 = tf.placeholder(dtype=tf.float32, shape=[1, 256, 512, 3], name='input_tensor') + input_tensor = tf.identity(input_tensor_0, name='input_tensor') + net = lanenet.LaneNet(phase='test', cfg=CFG) + binary_seg_ret, instance_seg_ret = net.inference(input_tensor=input_tensor, name='LaneNet') + + with tf.variable_scope('lanenet/'): + binary_seg_ret = tf.identity(binary_seg_ret, name='binary_seg_out') + instance_seg_ret = tf.identity(instance_seg_ret, name='instance_seg_out') + + postprocessor = lanenet_postprocess.LaneNetPostProcessor(cfg=CFG) + + sess = tf.Session() + + # define moving average version of the learned variables for eval + with tf.variable_scope(name_or_scope='moving_avg'): + variable_averages = tf.train.ExponentialMovingAverage( + CFG.SOLVER.MOVING_AVE_DECAY) + variables_to_restore = variable_averages.variables_to_restore() + + # define saver + saver = tf.train.Saver(variables_to_restore) + + with sess.as_default(): + saver.restore(sess=sess, save_path=weights_path) + image = np.expand_dims(image, axis=0) + binary_seg_image, instance_seg_image = sess.run( + [binary_seg_ret, instance_seg_ret], + feed_dict={input_tensor: image} + ) + + postprocess_result = postprocessor.postprocess( + binary_seg_result=binary_seg_image[0], + instance_seg_result=instance_seg_image[0], + source_image=image_vis, + with_lane_fit=True, + data_source='tusimple' + ) + mask_image = postprocess_result['mask_image'] + src_image = postprocess_result['source_image'] + + # -------------- 计算准确率 ------------------ # + gt = cv2.imread(gt_path, cv2.IMREAD_COLOR) + gt_trans = cv2.resize(gt, (512, 256), interpolation=cv2.INTER_LINEAR) + + gt_gray = cv2.cvtColor(gt_trans, cv2.COLOR_BGR2GRAY) + mask_image_gray = cv2.cvtColor(mask_image, cv2.COLOR_BGR2GRAY) + WIDTH = mask_image_gray.shape[0] + HIGTH = mask_image_gray.shape[1] + tp_count = 0 + tn_count = 0 + for i in range(WIDTH): + for j in range(HIGTH): + if mask_image_gray[i, j] != 0 and gt_gray[i, j] != 0: + tp_count = tp_count + 1 + if mask_image_gray[i, j] == 0 and gt_gray[i, j] == 0: + tn_count = tn_count + 1 + Accuracy = (int(tp_count) + int(tn_count)) / (int(WIDTH) * int(HIGTH)) + + print("\n# Metric_ckpt " + "\n Accuracy：{:.3f}".format(Accuracy)) + + cv2.imwrite('./eval_output/mask_ckpt.jpg', mask_image) + cv2.imwrite('./eval_output/src_ckpt.jpg', src_image) + + saver.save(sess, './eval_ckpt/eval.ckpt') + + sess.close() + + return + + +if __name__ == '__main__': + """ + test code + """ + # init args + args = init_args() + + test_lanenet(args.image_path, gt_path, args.weights_path, with_lane_fit=args.with_lane_fit) diff --git a/ACL_TensorFlow/contrib/cv/MNN-LANENET_ID1251_for_ACL/eval_om.py b/ACL_TensorFlow/contrib/cv/MNN-LANENET_ID1251_for_ACL/eval_om.py new file mode 100644 index 0000000000000000000000000000000000000000..98a8e53736b1a127a833e9efe2ca876fa4c29cae --- /dev/null +++ b/ACL_TensorFlow/contrib/cv/MNN-LANENET_ID1251_for_ACL/eval_om.py @@ -0,0 +1,79 @@ +# Copyright 2017 The TensorFlow Authors. All Rights Reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# ============================================================================ +# Copyright 2021 Huawei Technologies Co., Ltd +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +import numpy as np +import lanenet_postprocess +from local_utils.config_utils import parse_config_utils +import cv2 + +CFG = parse_config_utils.lanenet_cfg + +image_path = './eval_data/test_img.jpg' +image_vis = cv2.imread(image_path, cv2.IMREAD_COLOR) + +b_out_path = './eval_data/frozen_output_0.bin' +i_out_path = './eval_data/frozen_output_1.bin' +b_out = np.fromfile(b_out_path, dtype=np.int64) +i_out = np.fromfile(i_out_path, dtype=np.float32) +b_out = np.reshape(b_out, (1, 256, 512)) +i_out = np.reshape(i_out, (1, 256, 512, 4)) + +postprocessor = lanenet_postprocess.LaneNetPostProcessor(cfg=CFG) +postprocess_result = postprocessor.postprocess( + binary_seg_result=b_out[0], + instance_seg_result=i_out[0], + source_image=image_vis, + with_lane_fit=True, + data_source='tusimple' + ) +mask_image = postprocess_result['mask_image'] +src_image = postprocess_result['source_image'] +gt_path = './eval_data/gt.png' +gt = cv2.imread(gt_path, cv2.IMREAD_COLOR) +gt_trans = cv2.resize(gt, (512, 256), interpolation=cv2.INTER_LINEAR) + +# -------------- 计算准确率 ------------------ # +gt_gray = cv2.cvtColor(gt_trans, cv2.COLOR_BGR2GRAY) +mask_image_gray = cv2.cvtColor(mask_image, cv2.COLOR_BGR2GRAY) +WIDTH = mask_image_gray.shape[0] +HIGTH = mask_image_gray.shape[1] +tp_count = 0 +tn_count = 0 +for i in range(WIDTH): + for j in range(HIGTH): + if mask_image_gray[i, j] != 0 and gt_gray[i, j] != 0: + tp_count = tp_count + 1 + if mask_image_gray[i, j] == 0 and gt_gray[i, j] == 0: + tn_count = tn_count + 1 +Accuracy = (int(tp_count) + int(tn_count)) / (int(WIDTH) * int(HIGTH)) + +print("\n# Metric_om " + "\n Accuracy：{:.3f}".format(Accuracy)) + +cv2.imwrite('./eval_output/mask_om.jpg', mask_image) +cv2.imwrite('./eval_output/src_om.jpg', src_image) diff --git a/ACL_TensorFlow/contrib/cv/MNN-LANENET_ID1251_for_ACL/eval_pb.py b/ACL_TensorFlow/contrib/cv/MNN-LANENET_ID1251_for_ACL/eval_pb.py new file mode 100644 index 0000000000000000000000000000000000000000..5584b4ad7a60383e1c09b65cbf69b97ed519cfb1 --- /dev/null +++ b/ACL_TensorFlow/contrib/cv/MNN-LANENET_ID1251_for_ACL/eval_pb.py @@ -0,0 +1,169 @@ +# Copyright 2017 The TensorFlow Authors. All Rights Reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# ============================================================================ +# Copyright 2021 Huawei Technologies Co., Ltd +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +import numpy as np +import os +import tensorflow as tf +from tensorflow.python.platform import gfile +import lanenet_postprocess +from local_utils.config_utils import parse_config_utils +import cv2 + + +os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2' + +image_path = './eval_data/test_img.jpg' + +test_img = cv2.imread(image_path, cv2.IMREAD_COLOR) +image_vis = test_img +test_img_trans = cv2.resize(test_img, (512, 256), interpolation=cv2.INTER_LINEAR) +test_img_trans = test_img_trans / 127.5 - 1.0 + +gt_path = './eval_data/gt.png' +gt = cv2.imread(gt_path, cv2.IMREAD_COLOR) +gt_trans = cv2.resize(gt, (512, 256), interpolation=cv2.INTER_LINEAR) + +CFG = parse_config_utils.lanenet_cfg + +pb_path = './pretrained_model/eval.pb' + +# ----------- 查看 pbnode ----------- +# read graph definition +f = gfile.FastGFile(pb_path, "rb") +gd = graph_def = tf.GraphDef() +graph_def.ParseFromString(f.read()) +tf.import_graph_def(graph_def, name='') +for i, n in enumerate(graph_def.node): + print("=====node====") + print("Name of the node - %s" % n.name) +# -------------------------------- + + +def minmax_scale(input_arr): + """ + + :param input_arr: + :return: + """ + min_val = np.min(input_arr) + max_val = np.max(input_arr) + + output_arr = (input_arr - min_val) * 255.0 / (max_val - min_val) + + return output_arr + + +def freeze_graph_test(pb_path, img_path): + # :param pb_path:pb文件的路径 + # :param test_img:测试图片的路径 + # :return: + + f = gfile.FastGFile(pb_path, "rb") + graph_def = tf.GraphDef() + graph_def.ParseFromString(f.read()) + + with tf.Graph().as_default(): + output_graph_def = tf.GraphDef() + with open(pb_path, "rb") as f: + output_graph_def.ParseFromString(f.read()) + tf.import_graph_def(graph_def, name="") + + with tf.Session() as sess: + + sess.run(tf.global_variables_initializer()) + + # 定义输入输出节点名称 + input_node = sess.graph.get_tensor_by_name("input_tensor:0") + binary_output_node = sess.graph.get_tensor_by_name("lanenet/binary_seg_out:0") + pixel_embedding_output_node = sess.graph.get_tensor_by_name("lanenet/instance_seg_out:0") + img_feed = test_img_trans.astype(np.float32) + img_feed = np.expand_dims(img_feed, axis=0) + + # img_bin = img_feed + # img_bin.tofile("./eval_data/test_img.bin") + + binary_output, pixel_embedding_output = sess.run([binary_output_node, pixel_embedding_output_node], + feed_dict={input_node: img_feed}) + + postprocessor = lanenet_postprocess.LaneNetPostProcessor(cfg=CFG) + postprocess_result = postprocessor.postprocess( + binary_seg_result=binary_output[0], + instance_seg_result=pixel_embedding_output[0], + source_image=image_vis, + with_lane_fit=True, + data_source='tusimple' + ) + mask_image = postprocess_result['mask_image'] + src_image = postprocess_result['source_image'] + # if with_lane_fit: + # lane_params = postprocess_result['fit_params'] + # LOG.info('Model have fitted {:d} lanes'.format(len(lane_params))) + # for i in range(len(lane_params)): + # LOG.info('Fitted 2-order lane {:d} curve param: {}'.format(i + 1, lane_params[i])) + + for i in range(CFG.MODEL.EMBEDDING_FEATS_DIMS): + pixel_embedding_output[:, :, i] = minmax_scale(pixel_embedding_output[:, :, i]) + embedding_image = np.array(pixel_embedding_output, np.uint8) + + # plt.figure('mask_image') + # plt.imshow(mask_image[:, :, (2, 1, 0)]) + # plt.show() + # plt.figure('src_image') + # plt.imshow(image_vis[:, :, (2, 1, 0)]) + # plt.figure('instance_image') + # plt.imshow(embedding_image[:, :, (2, 1, 0)]) + # plt.figure('binary_image') + # plt.imshow(binary_output * 255, cmap='gray') + # plt.show() + + # -------------- 计算准确率 ------------------ # + gt_gray = cv2.cvtColor(gt_trans, cv2.COLOR_BGR2GRAY) + mask_image_gray = cv2.cvtColor(mask_image, cv2.COLOR_BGR2GRAY) + WIDTH = mask_image_gray.shape[0] + HIGTH = mask_image_gray.shape[1] + tp_count = 0 + tn_count = 0 + for i in range(WIDTH): + for j in range(HIGTH): + if mask_image_gray[i, j] != 0 and gt_gray[i, j] != 0: + tp_count = tp_count + 1 + if mask_image_gray[i, j] == 0 and gt_gray[i, j] == 0: + tn_count = tn_count + 1 + Accuracy = (int(tp_count) + int(tn_count)) / (int(WIDTH) * int(HIGTH)) + + print("\n# Metric_pb " + "\n Accuracy：{:.3f}".format(Accuracy)) + + cv2.imwrite('./eval_output/mask_pb.jpg', mask_image) + cv2.imwrite('./eval_output/src_pb.jpg', src_image) + + +if __name__ == '__main__': + # 测试pb模型 + img_path = './eval_data/test_img.npy' + freeze_graph_test(pb_path=pb_path, img_path=img_path) diff --git a/ACL_TensorFlow/contrib/cv/MNN-LANENET_ID1251_for_ACL/inference time.jpg.jpg b/ACL_TensorFlow/contrib/cv/MNN-LANENET_ID1251_for_ACL/inference time.jpg.jpg new file mode 100644 index 0000000000000000000000000000000000000000..1dbe0e6e74cfff7198205dd82800bf688d4e010b Binary files /dev/null and b/ACL_TensorFlow/contrib/cv/MNN-LANENET_ID1251_for_ACL/inference time.jpg.jpg differ diff --git a/ACL_TensorFlow/contrib/cv/MNN-LANENET_ID1251_for_ACL/metric_ckpt.jpg b/ACL_TensorFlow/contrib/cv/MNN-LANENET_ID1251_for_ACL/metric_ckpt.jpg new file mode 100644 index 0000000000000000000000000000000000000000..d02d97c03ffb1318c226b88d9c8a3a46e9e4a1fd Binary files /dev/null and b/ACL_TensorFlow/contrib/cv/MNN-LANENET_ID1251_for_ACL/metric_ckpt.jpg differ diff --git a/ACL_TensorFlow/contrib/cv/MNN-LANENET_ID1251_for_ACL/metric_om.jpg b/ACL_TensorFlow/contrib/cv/MNN-LANENET_ID1251_for_ACL/metric_om.jpg new file mode 100644 index 0000000000000000000000000000000000000000..345ddcb954d0f47079f7ce518f6a9e217858f889 Binary files /dev/null and b/ACL_TensorFlow/contrib/cv/MNN-LANENET_ID1251_for_ACL/metric_om.jpg differ diff --git a/ACL_TensorFlow/contrib/cv/MNN-LANENET_ID1251_for_ACL/metric_pb.jpg b/ACL_TensorFlow/contrib/cv/MNN-LANENET_ID1251_for_ACL/metric_pb.jpg new file mode 100644 index 0000000000000000000000000000000000000000..dffa1068d7e052902161f70af06f0a725c8b2041 Binary files /dev/null and b/ACL_TensorFlow/contrib/cv/MNN-LANENET_ID1251_for_ACL/metric_pb.jpg differ