mindspore 2.1.0__cp37-cp37m-manylinux1_x86_64.whl → 2.2.10__cp37-cp37m-manylinux1_x86_64.whl

mindspore/_akg/akg/utils/kernel_exec.py

@@ -1,6 +1,6 @@
 #!/usr/bin/env python3
 # coding: utf-8
-# Copyright 2019-2022 Huawei Technologies Co., Ltd
+# Copyright 2019-2023 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.
@@ -35,8 +35,6 @@ import numpy as np
 
 import akg
 import akg.tvm
-from akg.tvm import autotvm
-from akg.tvm import rpc
 from akg.tvm import _api_internal
 from akg.build_module import help_tiling_level
 from akg.utils import result_analysis as ra_util
@@ -45,16 +43,16 @@ from akg.utils import custom_tiling as ct_util
 from akg.utils import validation_check as vc_util
 from akg.utils.dsl_create import TensorUtils
 from akg.utils.util import parse_kwargs
-from akg.backend.parsing_profiling_data import HWTSLogParser
+from akg.backend.parsing_profiling_data import HWTSLogParser, max_time_consume
 from akg.backend.parsing_profiling_data import validate_and_normalize_path
 from akg.backend import aic_model
-
+from .ascend_profilier.cann_file_parser import CANNFileParser
+from .ascend_profilier.op_summary_parser import OpSummaryParser
+from .ascend_profilier.op_summary_headers import OpSummaryHeaders
 sh = logging.StreamHandler(sys.stdout)
 logging.getLogger().addHandler(sh)
 logging.getLogger().setLevel(logging.INFO)
 
-rpc_machine = {}
-rpc_lb = {}
 
 PERFORMANCE_TEST_FILE = "PERFORMANCE_TEST_FILE"
 BINDS = "binds"
@@ -173,212 +171,7 @@ def gen_name_kernel(kernel, dtype, shapes):
     return res
 
 
-def load_rpc_server_info(mode):
-    """
-    load rpc server host and port info.
-
-    Args:
-        mode (str): string of runtime choose, can set ca aic and rpc.
-    """
-    env_dic = os.environ
-    if env_dic.get('RPC_HOST') and env_dic.get('RPC_PORT'):
-        return
-
-    if mode == 'rpc_cloud':
-        logging.error("runtime_mode=rpc_cloud must set 1980 host ip and port!")
-        raise Exception("ERROR:runtime_mode=rpc_cloud must set 1980 host ip and port!")
-
-    rpc_server_info_config = env_dic.get('RPC_SERVER_INFO_FILE')
-    if not rpc_server_info_config:
-        logging.error("runtime_mode=rpc must set RPC_SERVER_INFO_FILE for rpc server info config")
-        raise Exception("ERROR:runtime_mode=rpc must set RPC_SERVER_INFO_FILE for rpc server info config")
-
-    # load rpc server host and port info from local file.
-    import json
-    with open(rpc_server_info_config, 'r') as f:
-        info = json.load(f)
-
-    for i in info:
-        rpc_machine[i] = info[i]
-        rpc_lb[i] = 0.0
-    return
-
-
-def dispatch(rank=0):
-    """Function for lock waiting dispatch handle version 1."""
-
-    def _sort_by_value(d):
-        items = list(d.items())
-        random.shuffle(items)
-        items.sort(key=lambda x: x[1])
-        return list(item[0] for item in items)
-
-    for k, v in rpc_lb.items():
-        logging.info("######rpc_lb[%s]=%f", rpc_machine.get(k)[0], v)
-    lb_list = _sort_by_value(rpc_lb)
-    if len(lb_list) > rank:
-        return lb_list[rank]
-    return lb_list[len(lb_list) - 1]
-
-
-def commit(remote, weight):
-    rpc_lb[remote] = weight
-
-
-@func_time_required
-def mod_launch_rpc_worker(mod, args, outputs, host, port, tuning=False):
-    """internal RPC worker, should be called by mod_launch_rpc_thread."""
-    logging.info("%s:====start connect to rpc ip: %s, rpc port: %d ",
-                 datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S'), host, port)
-    remote = rpc.connect(host, port, session_timeout=300)
-    logging.info("%s:====connect to rpc ip: %s, rpc port: %d finished ",
-                 datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S'), host, port)
-    uuid_str = uuid.uuid4().hex
-    temp_file_name = "stackvm_%s.o" % uuid_str
-    mod.save(temp_file_name)
-    remote.upload(temp_file_name)
-    remote_mod = remote.load_module(temp_file_name)
-    ctx = remote.cce()
-    arg_list = []
-    for a in args:
-        arg_list.append(akg.tvm.nd.array(a, ctx))
-    start_time = timer()
-    remote_mod(*arg_list)
-    ctx.sync()
-    if os.path.exists(temp_file_name):
-        os.remove(temp_file_name)
-    out_list = []
-    for i in outputs:
-        out = arg_list[len(arg_list) + i if i < 0 else i].asnumpy()
-        out_list.append(out)
-    # this time measure is no accurate now, to be improved soon
-    t = timer() - start_time
-    if not tuning:
-        return out_list[0] if len(out_list) == 1 else tuple(out_list)
-    stat_info = {"run_time": t}
-    return out_list[0] if len(out_list) == 1 else tuple(out_list), stat_info
-
-
-def mod_launch_rpc_thread(mode, mod, args, outputs, results, need_retry, retry, tuning=False):
-    """internal RPC thread, should be called by mod_launch_rpc_multithread."""
-    remoteevb = '0'
-    host = None
-    port = None
-    env_dic = os.environ
-    if env_dic.get('RPC_HOST') and env_dic.get('RPC_PORT'):
-        host = env_dic.get('RPC_HOST')
-        port = int(env_dic.get('RPC_PORT'))
-    else:
-        if mode == 'rpc_cloud':
-            logging.error("runtime_mode=rpc_cloud must set 1980 host ip and port!")
-            raise Exception("ERROR:runtime_mode=rpc_cloud must set 1980 host ip and port!")
-        remoteevb = dispatch(retry)
-        host = rpc_machine.get(remoteevb)[0]
-        port = rpc_machine.get(remoteevb)[1]
-
-    start_time = timer()
-    end_time = 0.0
-    logging.debug("rpc ip: %s, rpc port: %d", host, port)
-    try:
-        out_list = mod_launch_rpc_worker(mod, args, outputs, host, port, tuning=tuning)
-        end_time = timer()
-        t = end_time - start_time
-        if not env_dic.get('RPC_HOST'):
-            commit(remoteevb, 20 if t > 20 else t)
-        logging.info("===this round host is %s time is %f", host, (end_time - start_time))
-        results[retry] = out_list
-    except RuntimeError:
-        need_retry[retry] = True
-        end_time = timer()
-        logging.error("===Failed! this round host is %s time is %f", host, (end_time - start_time))
-        if not env_dic.get('RPC_HOST'):
-            commit(remoteevb, end_time - start_time + 20 * (retry + 1))
-        logging.error("rpc retry error: %d %s", retry, sys.exc_info())
-
-
-def _get_rpc_result(poll_count, threads, thread_index, poll_interval, need_retry, results, retried):
-    """Get rpc run result."""
-    while poll_count > 0:
-        poll_count -= 1
-        # wait for the newly created thread, because it is most likely to complete first
-        threads[thread_index].join(poll_interval)
-        for poll_index in range(thread_index + 1):
-            if not threads[poll_index].is_alive() and not need_retry[poll_index]:
-                return True, results[poll_index]
-            if need_retry[poll_index] and not retried[poll_index]:
-                logging.error("Thread %d exit with error, spawn a new thread immediately", poll_index)
-                poll_count = 0
-                retried[poll_index] = True
-    return False, False
-
-
-def mod_launch_rpc(mode, mod, args, outputs, tuning=False):
-    """
-    launch rpc or rpc_cloud module with retry.
-
-    Note:
-        To minimize waiting time of struggler RPC servers, we wait for a short timeout and spawn
-        a new thread after the timeout.
-        In normal case, RPC would complete before the short timeout, so, only one thread will be created.
-        When the RPC server is slow, we create multiple threads that run concurrently.
-        We wait for the first thread that successfully completes its work and return the result.
-        If a thread fails (an exception is raised), we spawn a new thread to retry.
-        Newly spawned threads will use different RPC servers.
-        We bound the maximum number of threads, i.e. maximum number of retries.
-    """
-    max_num_threads = 5
-
-    import operator
-    arg_filter = filter(lambda x: isinstance(x, np.ndarray), args)
-    arg_tensor = list(arg_filter)
-    tensor_size = reduce(operator.add, (reduce(operator.mul, arg.shape) for arg in arg_tensor))
-    expected_upload_speed = 5e6
-    expected_upload_time = int(tensor_size / expected_upload_speed)
-
-    timeout_before_spawning_new_thread = 200 + expected_upload_time
-    poll_interval = 1
-    thread_timeout = 400 + expected_upload_time * 3
-
-    load_rpc_server_info(mode)
-
-    threads = [None] * max_num_threads
-    results = [None] * max_num_threads
-    need_retry = [None] * max_num_threads
-    retried = [False] * max_num_threads
-    for thread_index in range(max_num_threads):
-        if thread_index > 0:
-            logging.error("Thread %d run for %d seconds, spawn a new thread to retry",
-                          (thread_index - 1), timeout_before_spawning_new_thread)
-        threads[thread_index] = Thread(target=mod_launch_rpc_thread,
-                                       args=(mode, mod, args, outputs, results, need_retry, thread_index, tuning))
-        # daemonize the thread to prevent long running threads from hanging the whole process
-        threads[thread_index].daemon = True
-        threads[thread_index].start()
-        poll_count = timeout_before_spawning_new_thread // poll_interval
-        has_res, res = _get_rpc_result(poll_count, threads, thread_index, poll_interval, need_retry, results, retried)
-        if has_res:
-            return res
-
-    logging.error("All %d threads are created, poll the threads until the first one exits normally, \
-                  or all threads exit abnormally or timeout", max_num_threads)
-    poll_count = thread_timeout // poll_interval
-    for _ in range(poll_count):
-        threads[max_num_threads - 1].join(poll_interval)
-        exit_thread_count = 0
-        for poll_index in range(max_num_threads):
-            if not threads[poll_index].is_alive() and not need_retry[poll_index]:
-                return results[poll_index]
-            if not threads[poll_index].is_alive():
-                exit_thread_count += 1
-            if exit_thread_count == max_num_threads:
-                logging.error("All %d threads exit abnormally", max_num_threads)
-                return None
-
-    logging.error("All %d threads timeout", max_num_threads)
-    return None
-
-
-def profiling_mode_run(kernel_name, args, outputs, tuning, device_id):
+def profiling_mode_run(kernel_name, args, outputs, tuning, device_id, arch=None):
     """
     Function for collecting cycle data from device.
 
@@ -389,23 +182,45 @@ def profiling_mode_run(kernel_name, args, outputs, tuning, device_id):
         tuning: tuning model.
         device_id: device_id on device.
     """
-    akg.tvm.get_global_func("ascend_start_profiling")(device_id)
+    akg.tvm.get_global_func("ascend_start_profiling")(kernel_name)
     time_before_launch = time.time()
     output_data = ascend_run(kernel_name, args, outputs, device_id)
     akg.tvm.get_global_func("ascend_stop_profiling")()
-
-    cycle = profiling_analyse(device_id, time_before_launch)
-    logging.info('=====parsing cycles==============================')
+    cycle = 0
+    if arch is not None and "910B" in arch:
+        # for ascend910B profiling
+        cycle = profiling_analyse_910B(time_before_launch)
+    else:
+        cycle = profiling_analyse(device_id, time_before_launch)
+    logging.info('=====Task Duration(us)==============================')
     if cycle != PROF_ERROR_CODE:
         logging.info(cycle)
     else:
-        logging.error("OOPS, can't correctly parsing cycles!")
+        logging.error("OOPS, can't correctly Task Duration!")
     TestUtils.record_cycle(cycle)
-    logging.info('=====parsing cycles==============================')
-    if tuning:
-        return output_data, {'run_time': cycle}
-    return output_data
-
+    logging.info('=====Task Duration(us)==============================')
+    return output_data, {'run_time': cycle}
+
+def  profiling_analyse_910B(time_before_launch):
+    public_path = os.getenv('PROFILING_DIR')
+    if public_path is None:
+        raise RuntimeError("Environment PROFILING_DIR not set!")
+    public_path = validate_and_normalize_path(public_path)
+    CANNFileParser(public_path).export_cann_profiling()
+    cann_file_parser = OpSummaryParser(public_path)
+    profiler_file = cann_file_parser._profiler_path
+    logging.debug("prof file is: %s", os.path.basename(profiler_file))
+    file_create_time = os.path.getctime(profiler_file)
+    if file_create_time < time_before_launch:
+        raise RuntimeError("The PROF file is too old")
+    datas:dict = cann_file_parser.generate_op_summary_data()
+    task_duration = float(datas.get(OpSummaryHeaders.TASK_DURATION,max_time_consume))
+    # # aic_total_cycles means ai core cycle
+    # # aiv_total_cycles means ai vector cycle
+    # aiv_total_cycle = int(datas.get(OpSummaryHeaders.AIV_TOTAL_CYCLES,max_time_consume))
+    # aic_total_cycle = int(datas.get(OpSummaryHeaders.AIC_TOTAL_CYCLES,max_time_consume))
+    # return aiv_total_cycle+aic_total_cycle
+    return task_duration
 
 def profiling_analyse(device_id, time_before_launch):
     """analyse profiling."""
@@ -559,12 +374,12 @@ def get_kernel_name_from_mod(mod):
     return kernel_name
 
 
-def mod_launch_ascend_profiling(mod, args, outputs=(-1,), tuning=False, device_id=-1):
+def mod_launch_ascend_profiling(mod, args, outputs=(-1,), tuning=False, device_id=-1, arch=None):
     gc.collect()
     if device_id == -1:
         device_id = int(os.environ.get("DEVICE_ID", 0))
     kernel_name = get_kernel_name_from_mod(mod)
-    return profiling_mode_run(kernel_name, args, outputs, tuning, device_id)
+    return profiling_mode_run(kernel_name, args, outputs, tuning, device_id, arch=arch)
 
 
 def mod_launch_default(mod, args, outputs=(-1,), target=CUDA, tuning=False, device_id=-1, repeat_time=400):
@@ -598,7 +413,7 @@ def mod_launch_default(mod, args, outputs=(-1,), target=CUDA, tuning=False, devi
 
 
 @func_time_required
-def mod_launch(mod, args, outputs=(-1,), tuning=False, device_id=-1, expect=None, repeat_time=400):
+def mod_launch(mod, args, outputs=(-1,), tuning=False, device_id=-1, expect=None, repeat_time=400, arch=None):
     """
     unified run CCE kernel api.
 
@@ -609,7 +424,7 @@ def mod_launch(mod, args, outputs=(-1,), tuning=False, device_id=-1, expect=None
         tuning (bool): tuning model.
         device_id: device_id on device.
         expect: when mode in ["compile_cloud", "compile_mini"], return it.
-
+        arch: Ascend arch type
     Returns:
         output numpy array, or tuple of numpy array if multi-output.
     """
@@ -618,6 +433,20 @@ def mod_launch(mod, args, outputs=(-1,), tuning=False, device_id=-1, expect=None
     if device_id == -1:
         device_id = int(os.environ.get("DEVICE_ID", 0))
 
+    # npu-inference process
+    if isinstance(mod, str):
+        kernel_name = mod
+        run_func = ascend_run
+        run_args = [kernel_name, args, outputs, device_id]
+        if os.environ.get("PROFILING_MODE") == "true":
+            run_func = profiling_mode_run
+            run_args = [kernel_name, args, outputs, tuning, device_id, arch]
+            if os.environ.get("PROFILING_DIR", None) is None:
+                os.environ["PROFILING_DIR"] = "."
+                logging.info("[RUNTIME_WARNING] In profiling mode, while profiling dir is not set!Set to current dir by default.")
+        output = run_func(*run_args)
+        return output
+
     module = mod if mod.type_key == LLVM else mod.imported_modules[0]
     target = module.type_key
     if target == LLVM or target == CUDA:
@@ -635,8 +464,6 @@ def mod_launch(mod, args, outputs=(-1,), tuning=False, device_id=-1, expect=None
             return output
         ra_util.get_ticks(stat_info)
         return output, stat_info
-    if mode in ('rpc', 'rpc_cloud'):
-        return mod_launch_rpc(mode, mod, args, outputs, tuning)
 
     # The air_cloud is the current default mode and needs to be modified in the future
     if mode == 'air_cloud':
@@ -658,7 +485,7 @@ def mod_launch(mod, args, outputs=(-1,), tuning=False, device_id=-1, expect=None
         mod(*tvm_array)
         return tvm_array[-1].asnumpy()
 
-    raise ValueError("mode must be aic, rpc, aic_cloud, ca, compile_cloud, compile_mini, cpu, csim, ccesim or cdiff")
+    raise ValueError("mode must be aic, aic_cloud, ca, compile_cloud, compile_mini, cpu, csim, ccesim or cdiff")
 
 
 def _extract_shape_dtype(input_shapes, input_types):
@@ -1004,44 +831,6 @@ def _create_gpu_mod(s, op_var, target, shape_var, kernel_name, attrs, polyhedral
     return mod
 
 
-def _create_gpu_tuning_mod(sch_tmpl, shape_var, kernel_name, attrs, binds):
-    """Create tuning module on gpu."""
-    @autotvm.template
-    def _autotune_template():
-        s = sch_tmpl['schedule'](sch_tmpl['output'])
-        return s, op_var
-
-    # create autotune task
-    task = autotvm.task.create(_autotune_template, args=list(), target='cuda')
-    print("task config: ", task.config_space)
-
-    # set measure_option
-    measure_option = autotvm.measure_option(
-        builder=autotvm.LocalBuilder(),
-        runner=autotvm.LocalRunner(repeat=5, min_repeat_ms=150, timeout=4)
-    )
-
-    # Begin tuning, log records to file `kernel_name.log`
-    tuner = autotvm.tuner.RandomTuner(task)
-    if not os.path.exists(kernel_name + '.log'):
-        tuner.tune(n_trial=len(task.config_space),
-                   measure_option=measure_option,
-                   callbacks=[autotvm.callback.log_to_file(kernel_name + '.log')])
-
-    # query best config
-    dispatch_context = autotvm.apply_history_best(kernel_name + '.log')
-    best_config = dispatch_context.query(task.target, task.workload)
-    print("\nBest config is:")
-    print(best_config)
-
-    # apply best config
-    with autotvm.apply_history_best(kernel_name + '.log'):
-        s, op_var = _autotune_template()
-        mod = akg.build(s, op_var, "cuda", shape_var, name=kernel_name, attrs=attrs,
-                        polyhedral=False, binds=binds)
-    return mod
-
-
 def create_gpu_mod(sch_tmpl, s, op_func, op_var, shape_var, kernel_name, attrs, polyhedral, binds, dump_ir, dump_code,
                    tuning):
     """
@@ -1079,7 +868,7 @@ def create_gpu_mod(sch_tmpl, s, op_func, op_var, shape_var, kernel_name, attrs,
                 s = sch_tmpl['schedule'](sch_tmpl['output'])
                 mod = _create_gpu_mod(s, op_var, "cuda", shape_var, kernel_name, attrs, False, binds, dump_ir)
             else:
-                mod = _create_gpu_tuning_mod(sch_tmpl, shape_var, kernel_name, attrs, binds)
+                raise ValueError("Tuning is not supported.")
     else:
         mod = _create_gpu_mod(s, op_var, target, shape_var, kernel_name, attrs, polyhedral, binds, dump_ir)
     if dump_code:
@@ -1213,6 +1002,10 @@ def op_build(op_func, input_shapes, input_types, op_attrs=None, kernel_name="",
         compute_func(s)
         polyhedral = False
 
+    if attrs.get("simple_mode"):
+        attrs.pop("simple_mode")
+        return s, inputs, output, attrs
+
     level = attrs.get("help_tiling") if attrs and "help_tiling" in attrs else None
     if tuning or (level is not None and level > help_tiling_level.get('None')):
         return gen_spaces_dim_key(op_func, args, s, op_var, kernel_name, attrs, polyhedral, tuning, target)
@@ -1231,10 +1024,11 @@ def op_build(op_func, input_shapes, input_types, op_attrs=None, kernel_name="",
                             polyhedral=polyhedral, binds=binds)
             source_code = mod.get_source()
     elif target_name == CCE:
-        with akg.build_config(dump_pass_ir=dump_ir):
-            mod = akg.build(s, op_var, target, shape_var, name=kernel_name, attrs=attrs,
-                            polyhedral=polyhedral, binds=binds)
+        mod = npu_op_build(s, op_var, shape_var, kernel_name, binds, attrs, dump_ir, polyhedral)
+        if attrs.get("is_tbe_codegen"):
             source_code = mod.imported_modules[0].get_source()
+        else:
+            return mod
 
     if log_code:
         logging.debug("#################code####################")
@@ -1244,11 +1038,41 @@ def op_build(op_func, input_shapes, input_types, op_attrs=None, kernel_name="",
     return mod
 
 
+def npu_op_build(s, op_var, shape_var, kernel_name="", binds=None, attrs=None,
+                 dump_ir=True, polyhedral=True):
+    if attrs.get("is_tbe_codegen"):
+        # use akg + tbe compile
+        from akg.tvm import build_module
+        from akg.python.akg.utils.tbe_codegen_utils import build_tbe_codegen
+        if attrs is None:
+            attrs = {} 
+        attrs.update({"is_tbe_codegen":True})
+        binds, arg_list = build_module.get_binds(op_var)
+        stmt = akg.lower(s, op_var, shape_params=shape_var, name=kernel_name, binds=binds, attrs=attrs,
+            simple_mode=True, polyhedral=polyhedral, tuning=False, target="cce")
+
+        json_str = akg.tvm.save_json(stmt, "0.8.0")
+
+        args_json = []
+        for buf in enumerate(arg_list):
+            args_json.append(akg.tvm.save_json(buf, "0.8.0"))
+
+        is_success = build_tbe_codegen(kernel_name, json_str, args_json, attrs)
+        if not is_success:
+            raise TypeError("npu_inference codegen failed.")
+        return kernel_name
+    else:
+        # use the whole akg complie
+        with akg.build_config(dump_pass_ir=dump_ir):
+            mod = akg.build(s, op_var, CCE, shape_var, name=kernel_name, attrs=attrs,
+                            polyhedral=polyhedral, binds=binds)
+        return mod
+
 def get_runtime_mode():
     """get runtime mode."""
     env_dic = os.environ
     if not env_dic.get('RUNTIME_MODE'):
-        mode = 'rpc_cloud'
+        mode = 'aic_cloud'
     else:
         mode = env_dic.get('RUNTIME_MODE')
     return mode
@@ -1265,7 +1089,7 @@ def get_profiling_mode():
 def product_is_mini():
     """check whether in mini environment."""
     mode = get_runtime_mode()
-    if mode in ('rpc', 'air', 'aic', 'compile_mini'):
+    if mode in ('air', 'aic', 'compile_mini'):
         return True
     return False
 

mindspore/_akg/akg/utils/result_analysis.py

@@ -351,16 +351,8 @@ def _collect_inputs(input_desc):
     return inputs
 
 
-def _get_op_attr(op_name, attrs, attr_name):
-    """Get op attr value."""
-    for attr in attrs:
-        if attr["name"] == attr_name:
-            return attr["value"]
-    raise ValueError("Can not find attr '{}' in op {}".format(attr_name, op_name))
-
-
 def precision_analyze(desc: dict, tensors):
-    exclude_op_list = ["Minimum", "Maximum", "Reshape", "ZerosLike", "Tile", "Select", "InplaceAssign", "Greater",
+    exclude_op_list = ["Minimum", "Maximum", "Reshape", "ZerosLike", "Tile", "Select", "Greater",
                        "SelectGT", "SelectLT", "LessEqual", "Less", "EquivFormat", "ExpandDims", "Transpose",
                        "TransData", "BroadcastTo", "Assign"]
     input_tensors = _collect_inputs(desc["input_desc"])
@@ -369,21 +361,9 @@ def precision_analyze(desc: dict, tensors):
     graph = {}
     ops = {}  # recorder the operator that generates the current output
     for op in desc["op_desc"]:
-        if op["name"] == "InplaceAssign":
-            output = IOInfo(op["input_desc"][0][0]["tensor_name"], op["input_desc"][0][0]["data_type"])
-            inputs = IOInfo(op["input_desc"][1][0]["tensor_name"], op["input_desc"][1][0]["data_type"])
-            graph[output] = [inputs]
-            ops[output] = op["name"]
-            fake_output = _get_op_attr(op["name"], op["attr"], "fake_output")
-            if not fake_output:
-                output = IOInfo(op["output_desc"][0]["tensor_name"], op["output_desc"][0]["data_type"])
-                inputs = IOInfo(op["input_desc"][2][0]["tensor_name"], op["input_desc"][2][0]["data_type"])
-                graph[output] = [inputs]
-                ops[output] = op["name"]
-        else:
-            output = IOInfo(op["output_desc"][0]["tensor_name"], op["output_desc"][0]["data_type"])
-            graph[output] = _collect_inputs(op["input_desc"])
-            ops[output] = op["name"]
+        output = IOInfo(op["output_desc"][0]["tensor_name"], op["output_desc"][0]["data_type"])
+        graph[output] = _collect_inputs(op["input_desc"])
+        ops[output] = op["name"]
 
     def _precision_reduce(x: IOInfo):
         if x in input_tensors: