Huawei_Technology
/
MindSpore-AKG
Not watched
1
0
Fork 0
Code
Releases 1 Wiki evaluate Activity
Issues 0 Pull Requests 0 Datasets Model Cloudbrain HPC
You can not select more than 25 topics Topics must start with a chinese character,a letter or number, can include dashes ('-') and can be up to 35 characters long.
Tree: a5a856cd2c
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'a5a856cd2c'
${ noResults }
MindSpore-AKG/tests/common/gen_json_data.py

457 lines
21 kB
Raw Blame History 

  1. # Copyright 2020-2021 Huawei Technologies Co., Ltd

  2. #

  3. # Licensed under the Apache License, Version 2.0 (the "License");

  4. # you may not use this file except in compliance with the License.

  5. # You may obtain a copy of the License at

  6. #

  7. # http://www.apache.org/licenses/LICENSE-2.0

  8. #

  9. # Unless required by applicable law or agreed to in writing, software

  10. # distributed under the License is distributed on an "AS IS" BASIS,

  11. # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

  12. # See the License for the specific language governing permissions and

  13. # limitations under the License.

  14. 

  15. """generate numpy data for composite json"""

  16. import json

  17. import logging

  18. import inspect

  19. import numpy as np

  20. from tests.common.gen_random import random_gaussian

  21. 

  22. 

  23. def get_attr(attr_desc, attr_type):

  24.     """get op attr by type"""

  25.     for attr in attr_desc:

  26.         if attr["name"] == attr_type:

  27.             return attr["value"]

  28.     logging.warning("attr {} not found, please check.".format(attr_type))

  29.     return None

  30. 

  31. 

  32. class CodePrinter(object):

  33.     """print numpy file"""

  34. 

  35.     def __init__(self, out_file):

  36.         self.fout_ = open(out_file, 'w')

  37.         self.indent_ = 0

  38. 

  39.     def __del__(self):

  40.         self.fout_.close()

  41. 

  42.     def out(self, data, new_line=False):

  43.         """write data"""

  44.         if new_line:

  45.             self.fout_.write("\n")

  46.             for i in range(0, self.indent_):

  47.                 self.fout_.write('    ')

  48.         if isinstance(data, str):

  49.             self.fout_.write(data)

  50.         else:

  51.             self.fout_.write(str(data))

  52. 

  53.     def null_line(self):

  54.         """add null line"""

  55.         self.fout_.write("\n")

  56. 

  57.     def close(self):

  58.         """close file"""

  59.         self.fout_.close()

  60. 

  61. 

  62. def get_input(desc):

  63.     """get input values"""

  64.     value = desc.get('value', None)

  65.     return value if value is not None else desc['tensor_name']

  66. 

  67. 

  68. def reduce_str(inputs, output, attr, op_type):

  69.     """gen sum string"""

  70.     axis = []

  71.     keepdims = False

  72.     axis_value = get_attr(attr, "axis")

  73.     if axis_value:

  74.         axis = list(axis_value) if isinstance(axis_value, (list, tuple)) else [axis_value]

  75.     keepdims_value = get_attr(attr, "keep_dims")

  76.     keepdims = keepdims_value if keepdims_value else keepdims

  77. 

  78.     if axis == []:

  79.         s = "%s = np.%s(%s.astype(np.float32) if %s.dtype == np.float16 else %s, keepdims=%s).astype(%s.dtype)" % (

  80.             output[0]['tensor_name'], op_type, get_input(inputs[0][0]), get_input(inputs[0][0]),

  81.             get_input(inputs[0][0]), keepdims, get_input(inputs[0][0]))

  82.     else:

  83.         s = "%s = np.%s(%s.astype(np.float32) if %s.dtype == np.float16 else %s, axis=tuple(%s), keepdims=%s).astype(%s.dtype); %s = np.reshape(%s, %s) " %\

  84.             (output[0]['tensor_name'], op_type, get_input(inputs[0][0]), get_input(inputs[0][0]),

  85.              get_input(inputs[0][0]), axis, keepdims, get_input(inputs[0][0]),

  86.              output[0]['tensor_name'], output[0]['tensor_name'], output[0]['shape'])

  87.     return s

  88. 

  89. 

  90. def cast_str(inputs, output, attr):

  91.     """gen cast string"""

  92.     dst_type = get_attr(attr, "dst_type")

  93.     s = "%s = np.array(%s).astype(np.%s) if isinstance(%s, (float, int)) else %s.astype(np.%s)" % (

  94.         output[0]['tensor_name'], get_input(inputs[0][0]), dst_type, get_input(inputs[0][0]),

  95.         get_input(inputs[0][0]), dst_type)

  96.     return s

  97. 

  98. 

  99. def broadcast_str(inputs, output, attr):

  100.     """gen broadcast string"""

  101.     dst_shape = get_attr(attr, "shape")

  102.     s = "%s = np.broadcast_to(%s, %s)" % (

  103.         output[0]["tensor_name"], get_input(inputs[0][0]), dst_shape)

  104.     return s

  105. 

  106. 

  107. def transpose_str(inputs, output, attr):

  108.     """gen transpose string"""

  109.     axes = None

  110.     axes_value = get_attr(attr, "perm")

  111.     axes = axes_value if axes_value else axes

  112.     s = "%s = np.transpose(%s, axes=%s)" % (

  113.         output[0]['tensor_name'], get_input(inputs[0][0]), axes)

  114.     return s

  115. 

  116. 

  117. def trans_data_two2fractal(input_, src_format, dst_format):

  118.     shape = list(input_.shape)

  119.     dtype = input_.dtype

  120.     if dtype == "float32":

  121.         input_ = input_.astype(np.float16)

  122.     if src_format == "DefaultFormat":

  123.         m, n = shape[-2], shape[-1]

  124.         m1, n1 = m // 16, n // 16

  125.         m0, n0 = 16, 16

  126.         needPad = m % 16 != 0 or n % 16 != 0

  127.         if needPad:

  128.             pad_m, pad_n = (m + 15) // 16 * 16, (n + 15) // 16 * 16

  129.             pad_shape = [x for x in shape]

  130.             pad_shape[-1] = pad_n

  131.             pad_shape[-2] = pad_m

  132.             pad_input = np.zeros(pad_shape).astype(dtype)

  133.             if len(shape) == 2:

  134.                 pad_input[:m, :n] = input_

  135.             elif len(shape) == 3:

  136.                 pad_input[:, :m, :n] = input_

  137.             elif len(shape) == 4:

  138.                 pad_input[:, :, :m, :n] = input_

  139.             m1, n1 = pad_m // 16, pad_n // 16

  140.             reshape_shape = shape[:-2] + [m1, m0, n1, n0]

  141.             reshape_input = pad_input.reshape(reshape_shape)

  142.         else:

  143.             reshape_shape = shape[:-2] + [m1, m0, n1, n0]

  144.             reshape_input = input_.reshape(reshape_shape)

  145.         if dst_format == "FRACTAL_NZ":

  146.             transpose_axis = [2, 0, 1, 3]

  147.             new_shape = [n1, m1, m0, n0]

  148.         else:

  149.             raise ValueError("dst_fromat %s is not suppored when src_format is %s" % (

  150.                 dst_format, src_format))

  151.         transpose_axis = [x + len(shape) - 2 for x in transpose_axis]

  152.         transpose_axis = [x for x in range(len(shape) - 2)] + transpose_axis

  153.         new_shape = shape[:-2] + new_shape

  154.         bench_mark = reshape_input.transpose(transpose_axis).astype('float16')

  155.         return bench_mark

  156. 

  157. 

  158. def trans_data_fractal2two(input_, src_format, dst_format, shape_origin):

  159.     shape_origin = [int(_) for _ in shape_origin]

  160.     shape = list(input_.shape)

  161.     n1, m1, m0, n0 = shape[-4:]

  162.     new_shape = shape[:-4] + [m1 * m0, n1 * n0]

  163.     tranpose_axis = [1, 2, 0, 3]

  164.     tranpose_axis = [x + len(shape) - 4 for x in tranpose_axis]

  165.     tranpose_axis = [i for i in range(len(shape) - 4)] + tranpose_axis

  166.     bench_mark = input_.transpose(tranpose_axis).reshape(new_shape)

  167.     if new_shape != shape_origin:

  168.         if len(shape_origin) == 2:

  169.             bench_mark = bench_mark[:shape_origin[0], :shape_origin[1]]

  170.         elif len(shape_origin) == 3:

  171.             bench_mark = bench_mark[:, shape_origin[0], :shape_origin[1]]

  172.         elif len(shape_origin) == 4:

  173.             bench_mark = bench_mark[:, :, shape_origin[0], :shape_origin[1]]

  174.     return bench_mark

  175. 

  176. 

  177. def trans_data_dsl(inputs, output, attr):

  178.     src_format = attr[0]['value']

  179.     dst_format = attr[1]['value']

  180. 

  181.     support_formats = [("DefaultFormat", "FRACTAL_NZ"),

  182.                        ("FRACTAL_NZ", "DefaultFormat")]

  183. 

  184.     if (src_format, dst_format) not in support_formats:

  185.         raise ValueError("src_format %s and dst_format %s is not supported!" %

  186.                          (src_format, dst_format))

  187. 

  188.     if src_format == 'DefaultFormat' and dst_format == 'FRACTAL_NZ':

  189.         res = "%s \n%s = %s(%s, '%s', '%s')" % (inspect.getsource(trans_data_two2fractal),

  190.                                                 output[0]['tensor_name'], trans_data_two2fractal.__name__, get_input(

  191.                                                     inputs[0][0]),

  192.                                                 attr[0]['value'], attr[1]['value'])

  193.     elif src_format == 'FRACTAL_NZ' and dst_format == 'DefaultFormat':

  194.         res = "%s \n%s = %s(%s, '%s', '%s', %s)" % (inspect.getsource(trans_data_fractal2two),

  195.                                                     output[0]['tensor_name'], trans_data_fractal2two.__name__, get_input(

  196.                                                         inputs[0][0]),

  197.                                                     attr[0]['value'], attr[1]['value'], attr[2]['value'])

  198.     return res

  199. 

  200. 

  201. def batchmatmul_str(inputs, output, attr):

  202.     trans_a = get_attr(attr, "transpose_a")

  203.     trans_b = get_attr(attr, "transpose_b")

  204.     if trans_a and trans_b:

  205.         res = "%s = np.matmul(np.swapaxes(%s, -1, -2), np.swapaxes(%s, -1, -2))" %\

  206.               (output[0]['tensor_name'], get_input(inputs[0][0]), get_input(inputs[1][0]))

  207.     elif trans_a:

  208.         res = "%s = np.matmul(np.swapaxes(%s, -1, -2), %s)" %\

  209.               (output[0]['tensor_name'], get_input(inputs[0][0]), get_input(inputs[1][0]))

  210.     elif trans_b:

  211.         res = "%s = np.matmul(%s, np.swapaxes(%s, -1, -2))" %\

  212.               (output[0]['tensor_name'], get_input(inputs[0][0]), get_input(inputs[1][0]))

  213.     else:

  214.         res = "%s = np.matmul(%s, %s)" %\

  215.               (output[0]['tensor_name'], get_input(inputs[0][0]), get_input(inputs[1][0]))

  216.     return res

  217. 

  218. 

  219. op_dsl = {

  220.     "ReduceSum": lambda inputs, output, attr: reduce_str(inputs, output, attr, "sum"),

  221.     "ReduceMax": lambda inputs, output, attr: reduce_str(inputs, output, attr, "max"),

  222.     "ReduceMin": lambda inputs, output, attr: reduce_str(inputs, output, attr, "min"),

  223.     "Tanh": lambda inputs, output, attr: "%s = np.tanh(%s)" %

  224.         (output[0]['tensor_name'], get_input(inputs[0][0])),

  225.     "Mul": lambda inputs, output, attr: "%s = np.multiply(%s, %s)" %

  226.         (output[0]['tensor_name'], get_input(

  227.         inputs[0][0]), get_input(inputs[1][0])),

  228.     "Pow": lambda inputs, output, attr: "%s = np.power(%s, %s)" %

  229.         (output[0]['tensor_name'], get_input(

  230.         inputs[0][0]), get_input(inputs[1][0])),

  231.     "Sub": lambda inputs, output, attr: "%s = np.subtract(%s, %s)" %

  232.         (output[0]['tensor_name'], get_input(

  233.         inputs[0][0]), get_input(inputs[1][0])),

  234.     "TensorAdd": lambda inputs, output, attr: "%s = np.add(%s, %s)" %

  235.         (output[0]['tensor_name'], get_input(

  236.         inputs[0][0]), get_input(inputs[1][0])),

  237.     "Add": lambda inputs, output, attr: "%s = np.add(%s, %s)" %

  238.     (output[0]['tensor_name'], get_input(

  239.         inputs[0][0]), get_input(inputs[1][0])),

  240.     "Rsqrt": lambda inputs, output, attr: "%s = 1.0/np.sqrt(%s)" %

  241.         (output[0]['tensor_name'], get_input(inputs[0][0])),

  242.     "Neg": lambda inputs, output, attr: "%s = np.negative(%s)" %

  243.         (output[0]['tensor_name'], get_input(inputs[0][0])),

  244.     "Exp": lambda inputs, output, attr: "%s = np.exp(%s)" %

  245.         (output[0]['tensor_name'], get_input(inputs[0][0])),

  246.     "RealDiv": lambda inputs, output, attr: "%s = np.divide(%s, %s)" %

  247.         (output[0]['tensor_name'], get_input(

  248.         inputs[0][0]), get_input(inputs[1][0])),

  249.     "Minimum": lambda inputs, output, attr: "%s = np.minimum(%s, %s)" %

  250.         (output[0]['tensor_name'], get_input(

  251.         inputs[0][0]), get_input(inputs[1][0])),

  252.     "Maximum": lambda inputs, output, attr: "%s = np.maximum(%s, %s)" %

  253.         (output[0]['tensor_name'], get_input(

  254.         inputs[0][0]), get_input(inputs[1][0])),

  255.     "Log": lambda inputs, output, attr: "%s = np.log(%s)" %

  256.         (output[0]['tensor_name'], get_input(inputs[0][0])),

  257.     "Sqrt": lambda inputs, output, attr: "%s = np.sqrt(%s)" %

  258.         (output[0]['tensor_name'], get_input(inputs[0][0])),

  259.     "Cast": lambda inputs, output, attr: cast_str(inputs, output, attr),

  260.     "Reshape": lambda inputs, output, attr: "%s = np.reshape(%s, %s)" %

  261.         (output[0]['tensor_name'], get_input(inputs[0][0]), attr[0]['value']),

  262.     "OneHot": lambda inputs, output, attr: "%s = np.one_hot(%s, %s, %s, %s, %s, %s)" %

  263.         (output[0]['tensor_name'], get_input(inputs[0][0]), get_input(inputs[1][0]), get_input(inputs[2][0]),

  264.         attr[0]['value'], attr[1]['value'], inputs[0][0]['data_type']),

  265.     "ZerosLike": lambda inputs, output, attr: "%s = np.zeros_like(%s)" %

  266.         (output[0]['tensor_name'], get_input(inputs[0][0])),

  267.     "AddN": lambda inputs, output, attr: "%s = %s" %

  268.         (output[0]['tensor_name'], ' + '.join([get_input(inputs[0][i])

  269.                                            for i in range(0, len(inputs[0]))])),

  270.     "Tile": lambda inputs, output, attr: "%s = np.tile(%s, %s)" %

  271.         (output[0]['tensor_name'], get_input(

  272.         inputs[0][0]), attr[0]['value']),

  273.     "Reciprocal": lambda inputs, output, attr: "%s = np.divide(1.0, %s)" %

  274.         (output[0]['tensor_name'], get_input(inputs[0][0])),

  275.     "Equal": lambda inputs, output, attr: "%s = np.equal(%s, %s)" %

  276.         (output[0]['tensor_name'], get_input(

  277.         inputs[0][0]), get_input(inputs[1][0])),

  278.     "GreaterEqual": lambda inputs, output, attr: "%s = np.greater_equal(%s, %s)" %

  279.         (output[0]['tensor_name'], get_input(

  280.         inputs[0][0]), get_input(inputs[1][0])),

  281.     "Select": lambda inputs, output, attr: "%s = np.where(%s, %s, %s)" %

  282.         (output[0]['tensor_name'], get_input(inputs[0][0]),

  283.         get_input(inputs[1][0]), get_input(inputs[2][0])),

  284.     "InplaceAssign": lambda inputs, output, attr: "%s = %s; %s = %s" %

  285.         (get_input(inputs[0][0]), get_input(inputs[1][0]),

  286.         output[0]['tensor_name'], get_input(inputs[2][0])),

  287.     "Greater": lambda inputs, output, attr: "%s = np.greater(%s, %s)" %

  288.         (output[0]['tensor_name'], get_input(

  289.         inputs[0][0]), get_input(inputs[1][0])),

  290.     "SelectGT": lambda inputs, output, attr: "%s = np.where(%s > %s, %s, %s)" %

  291.         (output[0]['tensor_name'], get_input(inputs[0][0]), get_input(inputs[1][0]),

  292.         get_input(inputs[2][0]), get_input(inputs[3][0])),

  293.     "SelectLT": lambda inputs, output, attr: "%s = np.where(%s < %s, %s, %s)" %

  294.         (output[0]['tensor_name'], get_input(inputs[0][0]), get_input(inputs[1][0]),

  295.         get_input(inputs[2][0]), get_input(inputs[3][0])),

  296.     "Abs": lambda inputs, output, attr: "%s = np.absolute(%s)" %

  297.         (output[0]['tensor_name'], get_input(inputs[0][0])),

  298.     "LessEqual": lambda inputs, output, attr: "%s = np.less_equal(%s, %s)" %

  299.         (output[0]['tensor_name'], get_input(inputs[0][0]), get_input(inputs[1][0])),

  300.     "EquivFormat": lambda inputs, output, attr: "%s = %s" %

  301.         (output[0]['tensor_name'], get_input(inputs[0][0])),

  302.     "ExpandDims": lambda inputs, output, attr: "%s = np.expand_dims(%s, %s)" %

  303.         (output[0]['tensor_name'], get_input(inputs[0][0]), attr[0]['value']),

  304.     "Transpose": lambda inputs, output, attr: transpose_str(inputs, output, attr),

  305.     "TransData": trans_data_dsl,

  306.     "BroadcastTo": lambda inputs, output, attr: broadcast_str(inputs, output, attr),

  307.     "BatchMatMul": lambda inputs, output, attr: batchmatmul_str(inputs, output, attr),

  308.     "Assign": lambda inputs, output, attr: "%s = %s; %s = %s" %

  309.         (get_input(inputs[0][0]), get_input(inputs[1][0]), output[0]['tensor_name'],

  310.         get_input(inputs[1][0]))

  311. }

  312. 

  313. 

  314. def gen_json_data(op_desc):

  315.     """Generating test data for composite json"""

  316.     desc = json.loads(op_desc)

  317.     input_for_mod = []

  318.     input_dict = {}

  319.     input_order = {}

  320.     output_indexes = []

  321.     expect = []

  322. 

  323.     p = CodePrinter('json_data.py')

  324.     idx = 0

  325. 

  326.     # Collect input which should be processed by atomic clean.

  327.     clean_input = []

  328.     sum_out = None

  329.     for op in desc["op_desc"]:

  330.         if op["name"] == "ReduceSum":

  331.             for a in op["attr"]:

  332.                 if a["name"] == "enable_atomic_add":

  333.                     sum_out = op["output_desc"][0]["tensor_name"]

  334.                     break

  335.         elif op["name"] == "InplaceAssign":

  336.             if not sum_out:

  337.                 continue

  338.             if op["input_desc"][1][0]["tensor_name"] == sum_out:

  339.                 clean_input.append(op["input_desc"][0][0]["tensor_name"])

  340. 

  341.     for input_desc in desc["input_desc"] if desc["input_desc"] is not None else []:

  342.         shape = [1] if not input_desc[0]["shape"] else input_desc[0]["shape"]

  343.         dtype = input_desc[0]["data_type"]

  344.         tensor_name = input_desc[0]["tensor_name"]

  345.         if tensor_name in clean_input:

  346.             item = np.zeros(shape).astype(dtype)

  347.         else:

  348.             item = random_gaussian(shape, miu=1, sigma=0.1).astype(dtype)

  349.         input_for_mod.append(item)

  350.         input_order[tensor_name] = idx

  351.         input_dict[tensor_name] = item

  352.         p.out("%s = np.array(input_dict.get('%s'))" % (tensor_name, tensor_name),

  353.             new_line=False if idx == 0 else True)

  354.         idx += 1

  355. 

  356.     inplace_assign_write = []

  357.     fake_output_tensors = []

  358.     elemwise_op_list = ["TensorAdd", "Add", "RealDiv", "Mul", "Minimum", "Maximum", "Sub"]

  359.     for op in desc["op_desc"]:

  360.         dsl_fun = op_dsl.get(op["name"], None)

  361.         if op["name"] in ("InplaceAssign", "Assign"):

  362.             if op["name"] == "InplaceAssign":

  363.                 fake_output = False

  364.                 for attr in op["attr"]:

  365.                     if attr["name"] == "fake_output":

  366.                         fake_output = attr["value"]

  367.                 if fake_output:

  368.                     fake_output_tensors.append(op["output_desc"][0]["tensor_name"])

  369.             inplace_assign_write.append(op["input_desc"][0][0]["tensor_name"])

  370.         elif op["name"] in elemwise_op_list and "format" in op["output_desc"][0]and \

  371.              op["output_desc"][0]["format"] =="FRACTAL_NZ":

  372.             if op["input_desc"][0][0]["format"] == "DefaultFormat" and \

  373.                op["input_desc"][1][0]["format"] == "FRACTAL_NZ":

  374.                 fractal_tensor = op["input_desc"][1][0]

  375.                 default_tensor = op["input_desc"][0][0]

  376.                 need_reshape = True

  377.             elif op["input_desc"][0][0]["format"] == "FRACTAL_NZ" and \

  378.                  op["input_desc"][1][0]["format"] == "DefaultFormat":

  379.                 fractal_tensor = op["input_desc"][0][0]

  380.                 default_tensor = op["input_desc"][1][0]

  381.                 need_reshape = True

  382.             if need_reshape:

  383.                 shape_fractal = fractal_tensor["shape"]

  384.                 shape_default = default_tensor["shape"]

  385.                 orig_shape = shape_fractal[:-4] + [shape_fractal[-3] * shape_fractal[-2]] + [shape_fractal[-4] * shape_fractal[-1]]

  386.                 shape_tmp = []

  387.                 shape_out = []

  388.                 diff_dims = len(orig_shape) - len(shape_default)

  389.                 for i in range(diff_dims):

  390.                     shape_tmp.append(1)

  391.                     shape_out.append(orig_shape[i])

  392.                 for i in range(len(shape_default)):

  393.                     shape_tmp.append(shape_default[i])

  394.                     if orig_shape[i + diff_dims] == 1:

  395.                         shape_out.append(shape_default[i])

  396.                     else:

  397.                         shape_out.append(orig_shape[i + diff_dims])

  398.                 shape_new = []

  399.                 for i in range(len(shape_out) - 2):

  400.                     shape_new.append(shape_out[i])

  401.                 if shape_tmp[-2] == 1 and shape_tmp[-1] == 1:

  402.                     shape_new.extend([1, 1, 1, 1])

  403.                 elif shape_tmp[-2] == 1 and shape_tmp[-1] == shape_default[-1]:

  404.                     shape_new.extend([shape_fractal[-4], 1, 1, shape_fractal[-1]])

  405.                 elif shape_tmp[-2] == shape_default[-2] and shape_tmp[-1] == 1:

  406.                     shape_new.extend([1, shape_fractal[-3], shape_fractal[-2], 1])

  407.                 if "value" in default_tensor:

  408.                     sent_reshape_tensor = "%s = np.full(%s, %s, np.%s)" \

  409.                         % (default_tensor["tensor_name"], shape_new, default_tensor["value"],

  410.                            default_tensor["data_type"])

  411.                 else:

  412.                     sent_reshape_tensor = "%s = np.reshape(%s, %s)" \

  413.                         % (default_tensor["tensor_name"], default_tensor["tensor_name"], tuple(shape_new))

  414.                 p.out(sent_reshape_tensor, True)

  415.         if dsl_fun is None:

  416.             logging.info("[%s] is not support for %s", op["name"], op)

  417.             continue

  418.         sent = dsl_fun(op['input_desc'], op['output_desc'], op['attr'])

  419.         logging.debug(sent)

  420.         p.out(sent, True)

  421. 

  422.     idx = 0

  423.     out_nums = len(desc["output_desc"])

  424.     for output_desc in desc["output_desc"]:

  425.         shape = [1] if not output_desc["shape"] else output_desc["shape"]

  426.         dtype = output_desc["data_type"]

  427.         item = np.full(shape, np.nan, dtype)

  428.         input_for_mod.append(item)

  429.         tensor_name = output_desc["tensor_name"]

  430.         if tensor_name not in fake_output_tensors:

  431.             real_idx = idx - out_nums

  432.             output_indexes.append(real_idx)

  433.             p.out("expect.append(%s)" % (tensor_name), True)

  434.         idx += 1

  435. 

  436.     # Add inplace tensors to expect, and add their index to output_indexes.

  437.     if inplace_assign_write:

  438.         inplace_tensors = "["

  439.         inplace_tensors_index = []

  440. 

  441.         for tensor_name in inplace_assign_write:

  442.             inplace_tensors_index.append(input_order[tensor_name])

  443.             inplace_tensors += "{}, ".format(tensor_name)

  444.         inplace_tensors += "]"

  445. 

  446.         p.out("inplace_tensors = {}".format(inplace_tensors), True)

  447.         p.out("expect.extend(inplace_tensors)", True)

  448.         output_indexes.extend(inplace_tensors_index)

  449. 

  450.     p.close()

  451. 

  452.     with open("json_data.py", 'r') as f:

  453.         sent = f.read()

  454.     exec(sent)

  455. 

  456.     return input_for_mod, expect, output_indexes