Fix some typos (intput, dics_intput, etc.) (#61786)

co63oc · web-flow · commit 7a6ba34d18df · 2024-02-21T10:23:08.000+08:00
diff --git a/test/auto_parallel/spmd_rules/test_reshape_rule.py b/test/auto_parallel/spmd_rules/test_reshape_rule.py
@@ -407,7 +407,7 @@ def test_reshape_infer_backward(self):
             infered_output_dist_attrs[0].dims_mapping, [-1, -1, 0, -1, 1]
         )
 
-        # shape: [6, 12, 48, 24] --> [6, 12, 48, 24] (intput --> output)
+        # shape: [6, 12, 48, 24] --> [6, 12, 48, 24] (input --> output)
         # dims_mapping: [-1, -1, 0, 1] --> [-1, -1, 0, 1], [-1, -1, 0, 1] (output --> input, output)
         self.output_dist_tensor_spec.shape = [6, 12, 48, 24]
         self.output_dist_tensor_spec.set_dims_mapping([-1, -1, 0, 1])
@@ -426,7 +426,7 @@ def test_reshape_infer_backward(self):
             infered_output_dist_attrs[0].dims_mapping, [-1, -1, 0, 1]
         )
 
-        # shape: [6, 12, 48, 24] --> [72, 3, 16, 24] (intput --> output)
+        # shape: [6, 12, 48, 24] --> [72, 3, 16, 24] (input --> output)
         # dims_mapping: [0, 1, -1, -1] --> [0, -1, 1, -1], [0, 1, -1, -1] (output --> input, output)
         self.output_dist_tensor_spec.shape = [72, 3, 16, 24]
         self.output_dist_tensor_spec.set_dims_mapping([0, 1, -1, -1])
@@ -445,7 +445,7 @@ def test_reshape_infer_backward(self):
             infered_output_dist_attrs[0].dims_mapping, [0, 1, -1, -1]
         )
 
-        # shape: [6, 12, 48, 24] --> [72, 3, 16, 24] (intput --> output)
+        # shape: [6, 12, 48, 24] --> [72, 3, 16, 24] (input --> output)
         # dims_mapping: [1, -1, -1, -1] --> [1, -1, -1, -1], [1, -1, -1, -1] (output --> input, output)
         self.output_dist_tensor_spec.shape = [72, 3, 16, 24]
         self.output_dist_tensor_spec.set_dims_mapping([1, -1, -1, -1])
@@ -464,7 +464,7 @@ def test_reshape_infer_backward(self):
             infered_output_dist_attrs[0].dims_mapping, [1, -1, -1, -1]
         )
 
-        # shape: [6, 12, 48, 24] --> [1, 72, 48, 4, 6] (intput --> output)
+        # shape: [6, 12, 48, 24] --> [1, 72, 48, 4, 6] (input --> output)
         # dims_mapping: [-1, 0, -1, -1, 1] --> [0, -1, -1, -1], [-1, 0, -1, -1, -1] (output --> input, output)
         self.output_dist_tensor_spec.shape = [1, 72, 48, 4, 6]
         self.output_dist_tensor_spec.set_dims_mapping([-1, 0, -1, -1, 1])
@@ -483,7 +483,7 @@ def test_reshape_infer_backward(self):
             infered_output_dist_attrs[0].dims_mapping, [-1, 0, -1, -1, -1]
         )
 
-        # shape: [6, 12, 48, 24] --> [3, 24, 6, 8, 24] (intput --> output)
+        # shape: [6, 12, 48, 24] --> [3, 24, 6, 8, 24] (input --> output)
         # dims_mapping: [-1, 1, -1, -1, 0] --> [-1, -1, -1, 0], [-1, -1, -1, -1, 0] (output --> input, output)
         self.output_dist_tensor_spec.shape = [3, 24, 6, 8, 24]
         self.output_dist_tensor_spec.set_dims_mapping([-1, 1, -1, -1, 0])
diff --git a/test/ir/inference/test_trt_convert_batch_norm.py b/test/ir/inference/test_trt_convert_batch_norm.py
@@ -72,7 +72,7 @@ def generate_MomentumTensor(attrs: list[dict[str, Any]], batch):
                 },
                 {},
             ]
-            dics_intput = [
+            dics_input = [
                 {
                     "X": ["batch_norm_input"],
                     "Bias": ["Bias"],
@@ -89,7 +89,7 @@ def generate_MomentumTensor(attrs: list[dict[str, Any]], batch):
                     "Variance": ["Variance"],
                 },
             ]
-            dics_intputs = [
+            dics_inputs = [
                 {
                     "Bias": TensorConfig(
                         data_gen=partial(generate_bias, dics, batch)
@@ -129,7 +129,7 @@ def generate_MomentumTensor(attrs: list[dict[str, Any]], batch):
             ops_config = [
                 {
                     "op_type": "batch_norm",
-                    "op_inputs": dics_intput[num_input],
+                    "op_inputs": dics_input[num_input],
                     "op_outputs": {
                         "Y": ["batch_norm_out"],
                         "MeanOut": ["Mean"],
@@ -143,14 +143,14 @@ def generate_MomentumTensor(attrs: list[dict[str, Any]], batch):
             ops = self.generate_op_config(ops_config)
             program_config = ProgramConfig(
                 ops=ops,
-                weights=dics_intputs[num_input],
+                weights=dics_inputs[num_input],
                 inputs={
                     "batch_norm_input": TensorConfig(
                         data_gen=partial(generate_input1, dics, batch)
                     )
                 },
                 outputs=["batch_norm_out"],
-                no_cast_list=list(dics_intputs[num_input].keys()),
+                no_cast_list=list(dics_inputs[num_input].keys()),
             )
 
             yield program_config
diff --git a/test/ir/inference/test_trt_convert_concat.py b/test/ir/inference/test_trt_convert_concat.py
@@ -79,7 +79,7 @@ def generate_weight1(attrs: List[Dict[str, Any]]):
                         self.num_input = num_input
                         self.dims = dims
                         dics = [{"axis": axis}, {}]
-                        dics_intput = [
+                        dics_input = [
                             {
                                 "X": [
                                     "concat_input1",
@@ -138,7 +138,7 @@ def generate_weight1(attrs: List[Dict[str, Any]]):
                         ops_config = [
                             {
                                 "op_type": "concat",
-                                "op_inputs": dics_intput[num_input],
+                                "op_inputs": dics_input[num_input],
                                 "op_outputs": {"Out": ["concat_output"]},
                                 "op_attrs": dics[0],
                             }
diff --git a/test/ir/inference/test_trt_convert_expand_as_v2.py b/test/ir/inference/test_trt_convert_expand_as_v2.py
@@ -193,7 +193,7 @@ def generate_input1(attrs: List[Dict[str, Any]]):
                     },
                 ]
                 self.dims = dims
-                dics_intput = [
+                dics_input = [
                     {"X": ["expand_v2_input"], "Y": ["shapeT1_data"]},
                 ]
                 ops_config = [
@@ -209,7 +209,7 @@ def generate_input1(attrs: List[Dict[str, Any]]):
                     },
                     {
                         "op_type": "expand_as_v2",
-                        "op_inputs": dics_intput[0],
+                        "op_inputs": dics_input[0],
                         "op_outputs": {"Out": ["expand_v2_out"]},
                         "op_attrs": dics[0],
                     },
diff --git a/test/ir/inference/test_trt_convert_expand_v2.py b/test/ir/inference/test_trt_convert_expand_v2.py
@@ -67,12 +67,12 @@ def generate_shapeT2_data(attrs: List[Dict[str, Any]]):
                     },
                 ]
                 self.dims = dims
-                dics_intput = [{"X": ["expand_v2_input"]}]
+                dics_input = [{"X": ["expand_v2_input"]}]
 
                 ops_config = [
                     {
                         "op_type": "expand_v2",
-                        "op_inputs": dics_intput[0],
+                        "op_inputs": dics_input[0],
                         "op_outputs": {"Out": ["expand_v2_out"]},
                         "op_attrs": dics[0],
                     }
@@ -199,7 +199,7 @@ def generate_input1(attrs: List[Dict[str, Any]]):
                     },
                 ]
                 self.dims = dims
-                dics_intput = [
+                dics_input = [
                     {"X": ["expand_v2_input"], "Shape": ["shapeT1_data"]},
                 ]
                 ops_config = [
@@ -215,7 +215,7 @@ def generate_input1(attrs: List[Dict[str, Any]]):
                     },
                     {
                         "op_type": "expand_v2",
-                        "op_inputs": dics_intput[0],
+                        "op_inputs": dics_input[0],
                         "op_outputs": {"Out": ["expand_v2_out"]},
                         "op_attrs": dics[0],
                     },
@@ -291,7 +291,7 @@ def generate_input1(attrs: List[Dict[str, Any]]):
                     },
                 ]
                 self.dims = dims
-                dics_intput = [
+                dics_input = [
                     {
                         "X": ["expand_v2_input"],
                         "expand_shapes_tensor": [
@@ -345,7 +345,7 @@ def generate_input1(attrs: List[Dict[str, Any]]):
                     },
                     {
                         "op_type": "expand_v2",
-                        "op_inputs": dics_intput[0],
+                        "op_inputs": dics_input[0],
                         "op_outputs": {"Out": ["expand_v2_out"]},
                         "op_attrs": dics[0],
                     },
diff --git a/test/ir/inference/test_trt_convert_fill_any_like.py b/test/ir/inference/test_trt_convert_fill_any_like.py
@@ -81,12 +81,12 @@ def generate_shapeT2_data(attrs: List[Dict[str, Any]]):
                     ]
                     self.dims = dims
                     self.dtype = dtype
-                    dics_intput = [{"X": ["fill_any_like_input"]}]
+                    dics_input = [{"X": ["fill_any_like_input"]}]
 
                     ops_config = [
                         {
                             "op_type": "fill_any_like",
-                            "op_inputs": dics_intput[0],
+                            "op_inputs": dics_input[0],
                             "op_outputs": {"Out": ["fill_any_like_out"]},
                             "op_attrs": dics[0],
                         }
diff --git a/test/ir/inference/test_trt_convert_scale.py b/test/ir/inference/test_trt_convert_scale.py
@@ -81,14 +81,14 @@ def generate_weight1(attrs: list[dict[str, Any]], is_int):
                 {},
             ]
 
-            dics_intput = [
+            dics_input = [
                 {
                     "X": ["scale_input"],
                     "ScaleTensor": ["ScaleTensor"],
                 },
                 {"X": ["scale_input"]},
             ]
-            dics_intputs = [
+            dics_inputs = [
                 {
                     "ScaleTensor": TensorConfig(
                         data_gen=partial(
@@ -104,15 +104,15 @@ def generate_weight1(attrs: list[dict[str, Any]], is_int):
             ops_config = [
                 {
                     "op_type": "scale",
-                    "op_inputs": dics_intput[num_input],
+                    "op_inputs": dics_input[num_input],
                     "op_outputs": {"Out": ["scale_out"]},
                     "op_attrs": dics[0],
                 }
             ]
             ops = self.generate_op_config(ops_config)
             program_config = ProgramConfig(
                 ops=ops,
-                weights=dics_intputs[num_input],
+                weights=dics_inputs[num_input],
                 inputs={
                     "scale_input": TensorConfig(
                         data_gen=partial(
diff --git a/test/ir/inference/test_trt_convert_split.py b/test/ir/inference/test_trt_convert_split.py
@@ -131,7 +131,7 @@ def generate_SectionsTensorList2(attrs: List[Dict[str, Any]]):
                                         {},
                                     ]
 
-                                    dics_intput = [
+                                    dics_input = [
                                         {
                                             "X": ["split_input"],
                                             "AxisTensor": ["AxisTensor"],
@@ -142,7 +142,7 @@ def generate_SectionsTensorList2(attrs: List[Dict[str, Any]]):
                                         },
                                         {"X": ["split_input"]},
                                     ]
-                                    dics_intputs = [
+                                    dics_inputs = [
                                         {
                                             "AxisTensor": TensorConfig(
                                                 data_gen=partial(
@@ -168,15 +168,15 @@ def generate_SectionsTensorList2(attrs: List[Dict[str, Any]]):
                                     ops_config = [
                                         {
                                             "op_type": "split",
-                                            "op_inputs": dics_intput[num_input],
+                                            "op_inputs": dics_input[num_input],
                                             "op_outputs": {"Out": Out},
                                             "op_attrs": dics[0],
                                         }
                                     ]
                                     ops = self.generate_op_config(ops_config)
                                     program_config = ProgramConfig(
                                         ops=ops,
-                                        weights=dics_intputs[num_input],
+                                        weights=dics_inputs[num_input],
                                         inputs={
                                             "split_input": TensorConfig(
                                                 data_gen=partial(
@@ -311,7 +311,7 @@ def generate_input1(attrs: List[Dict[str, Any]]):
                             "axis": axis,
                         }
                     ]
-                    dics_intput = [
+                    dics_input = [
                         {
                             "X": ["split_input"],
                             "SectionsTensorList": [
@@ -354,7 +354,7 @@ def generate_input1(attrs: List[Dict[str, Any]]):
                         },
                         {
                             "op_type": "split",
-                            "op_inputs": dics_intput[0],
+                            "op_inputs": dics_input[0],
                             "op_outputs": {
                                 "Out": [
                                     "output_var0",
diff --git a/test/ir/inference/test_trt_convert_tile.py b/test/ir/inference/test_trt_convert_tile.py
@@ -130,7 +130,7 @@ def generate_input1(attrs: List[Dict[str, Any]]):
             return np.ones([1, 2, 3, 4]).astype(np.float32)
 
         dics = [{}]
-        dics_intput = [
+        dics_input = [
             {"X": ["tile_input"], "RepeatTimes": ["repeat_times"]},
         ]
         ops_config = [
@@ -146,7 +146,7 @@ def generate_input1(attrs: List[Dict[str, Any]]):
             },
             {
                 "op_type": "tile",
-                "op_inputs": dics_intput[0],
+                "op_inputs": dics_input[0],
                 "op_outputs": {"Out": ["tile_out"]},
                 "op_attrs": dics[0],
             },
@@ -218,7 +218,7 @@ def generate_input1(attrs: List[Dict[str, Any]]):
             return np.ones([1, 2, 3, 4]).astype(np.float32)
 
         dics = [{}]
-        dics_intput = [
+        dics_input = [
             {
                 "X": ["tile_input"],
                 "repeat_times_tensor": ["repeat_times1", "repeat_times2"],
@@ -247,7 +247,7 @@ def generate_input1(attrs: List[Dict[str, Any]]):
             },
             {
                 "op_type": "tile",
-                "op_inputs": dics_intput[0],
+                "op_inputs": dics_input[0],
                 "op_outputs": {"Out": ["tile_out"]},
                 "op_attrs": dics[0],
             },
diff --git a/test/xpu/test_reduce_amax_op_xpu.py b/test/xpu/test_reduce_amax_op_xpu.py
@@ -45,10 +45,10 @@ def set_case(self):
                 'X': np.random.randint(0, 100, self.shape).astype("float32")
             }
 
-            expect_intput = self.inputs['X']
+            expect_input = self.inputs['X']
             self.outputs = {
                 'Out': np.amax(
-                    expect_intput,
+                    expect_input,
                     axis=self.attrs['dim'],
                     keepdims=self.attrs['keep_dim'],
                 )

Original file line number	Diff line number	Diff line change
`@@ -79,7 +79,7 @@ def generate_weight1(attrs: List[Dict[str, Any]]):`
`79`	`79`	`self.num_input = num_input`
`80`	`80`	`self.dims = dims`
`81`	`81`	`dics = [{"axis": axis}, {}]`
`82`		`- dics_intput = [`
	`82`	`+ dics_input = [`
`83`	`83`	`{`
`84`	`84`	`"X": [`
`85`	`85`	`"concat_input1",`
`@@ -138,7 +138,7 @@ def generate_weight1(attrs: List[Dict[str, Any]]):`
`138`	`138`	`ops_config = [`
`139`	`139`	`{`
`140`	`140`	`"op_type": "concat",`
`141`		`- "op_inputs": dics_intput[num_input],`
	`141`	`+ "op_inputs": dics_input[num_input],`
`142`	`142`	`"op_outputs": {"Out": ["concat_output"]},`
`143`	`143`	`"op_attrs": dics[0],`
`144`	`144`	`}`
Original file line number	Diff line number	Diff line change
`@@ -193,7 +193,7 @@ def generate_input1(attrs: List[Dict[str, Any]]):`
`193`	`193`	`},`
`194`	`194`	`]`
`195`	`195`	`self.dims = dims`
`196`		`- dics_intput = [`
	`196`	`+ dics_input = [`
`197`	`197`	`{"X": ["expand_v2_input"], "Y": ["shapeT1_data"]},`
`198`	`198`	`]`
`199`	`199`	`ops_config = [`
`@@ -209,7 +209,7 @@ def generate_input1(attrs: List[Dict[str, Any]]):`
`209`	`209`	`},`
`210`	`210`	`{`
`211`	`211`	`"op_type": "expand_as_v2",`
`212`		`- "op_inputs": dics_intput[0],`
	`212`	`+ "op_inputs": dics_input[0],`
`213`	`213`	`"op_outputs": {"Out": ["expand_v2_out"]},`
`214`	`214`	`"op_attrs": dics[0],`
`215`	`215`	`},`
Original file line number	Diff line number	Diff line change
`@@ -67,12 +67,12 @@ def generate_shapeT2_data(attrs: List[Dict[str, Any]]):`
`67`	`67`	`},`
`68`	`68`	`]`
`69`	`69`	`self.dims = dims`
`70`		`- dics_intput = [{"X": ["expand_v2_input"]}]`
	`70`	`+ dics_input = [{"X": ["expand_v2_input"]}]`
`71`	`71`
`72`	`72`	`ops_config = [`
`73`	`73`	`{`
`74`	`74`	`"op_type": "expand_v2",`
`75`		`- "op_inputs": dics_intput[0],`
	`75`	`+ "op_inputs": dics_input[0],`
`76`	`76`	`"op_outputs": {"Out": ["expand_v2_out"]},`
`77`	`77`	`"op_attrs": dics[0],`
`78`	`78`	`}`
`@@ -199,7 +199,7 @@ def generate_input1(attrs: List[Dict[str, Any]]):`
`199`	`199`	`},`
`200`	`200`	`]`
`201`	`201`	`self.dims = dims`
`202`		`- dics_intput = [`
	`202`	`+ dics_input = [`
`203`	`203`	`{"X": ["expand_v2_input"], "Shape": ["shapeT1_data"]},`
`204`	`204`	`]`
`205`	`205`	`ops_config = [`
`@@ -215,7 +215,7 @@ def generate_input1(attrs: List[Dict[str, Any]]):`
`215`	`215`	`},`
`216`	`216`	`{`
`217`	`217`	`"op_type": "expand_v2",`
`218`		`- "op_inputs": dics_intput[0],`
	`218`	`+ "op_inputs": dics_input[0],`
`219`	`219`	`"op_outputs": {"Out": ["expand_v2_out"]},`
`220`	`220`	`"op_attrs": dics[0],`
`221`	`221`	`},`
`@@ -291,7 +291,7 @@ def generate_input1(attrs: List[Dict[str, Any]]):`
`291`	`291`	`},`
`292`	`292`	`]`
`293`	`293`	`self.dims = dims`
`294`		`- dics_intput = [`
	`294`	`+ dics_input = [`
`295`	`295`	`{`
`296`	`296`	`"X": ["expand_v2_input"],`
`297`	`297`	`"expand_shapes_tensor": [`
`@@ -345,7 +345,7 @@ def generate_input1(attrs: List[Dict[str, Any]]):`
`345`	`345`	`},`
`346`	`346`	`{`
`347`	`347`	`"op_type": "expand_v2",`
`348`		`- "op_inputs": dics_intput[0],`
	`348`	`+ "op_inputs": dics_input[0],`
`349`	`349`	`"op_outputs": {"Out": ["expand_v2_out"]},`
`350`	`350`	`"op_attrs": dics[0],`
`351`	`351`	`},`
Original file line number	Diff line number	Diff line change
`@@ -81,12 +81,12 @@ def generate_shapeT2_data(attrs: List[Dict[str, Any]]):`
`81`	`81`	`]`
`82`	`82`	`self.dims = dims`
`83`	`83`	`self.dtype = dtype`
`84`		`- dics_intput = [{"X": ["fill_any_like_input"]}]`
	`84`	`+ dics_input = [{"X": ["fill_any_like_input"]}]`
`85`	`85`
`86`	`86`	`ops_config = [`
`87`	`87`	`{`
`88`	`88`	`"op_type": "fill_any_like",`
`89`		`- "op_inputs": dics_intput[0],`
	`89`	`+ "op_inputs": dics_input[0],`
`90`	`90`	`"op_outputs": {"Out": ["fill_any_like_out"]},`
`91`	`91`	`"op_attrs": dics[0],`
`92`	`92`	`}`
Original file line number	Diff line number	Diff line change
`@@ -81,14 +81,14 @@ def generate_weight1(attrs: list[dict[str, Any]], is_int):`
`81`	`81`	`{},`
`82`	`82`	`]`
`83`	`83`
`84`		`- dics_intput = [`
	`84`	`+ dics_input = [`
`85`	`85`	`{`
`86`	`86`	`"X": ["scale_input"],`
`87`	`87`	`"ScaleTensor": ["ScaleTensor"],`
`88`	`88`	`},`
`89`	`89`	`{"X": ["scale_input"]},`
`90`	`90`	`]`
`91`		`- dics_intputs = [`
	`91`	`+ dics_inputs = [`
`92`	`92`	`{`
`93`	`93`	`"ScaleTensor": TensorConfig(`
`94`	`94`	`data_gen=partial(`
`@@ -104,15 +104,15 @@ def generate_weight1(attrs: list[dict[str, Any]], is_int):`
`104`	`104`	`ops_config = [`
`105`	`105`	`{`
`106`	`106`	`"op_type": "scale",`
`107`		`- "op_inputs": dics_intput[num_input],`
	`107`	`+ "op_inputs": dics_input[num_input],`
`108`	`108`	`"op_outputs": {"Out": ["scale_out"]},`
`109`	`109`	`"op_attrs": dics[0],`
`110`	`110`	`}`
`111`	`111`	`]`
`112`	`112`	`ops = self.generate_op_config(ops_config)`
`113`	`113`	`program_config = ProgramConfig(`
`114`	`114`	`ops=ops,`
`115`		`- weights=dics_intputs[num_input],`
	`115`	`+ weights=dics_inputs[num_input],`
`116`	`116`	`inputs={`
`117`	`117`	`"scale_input": TensorConfig(`
`118`	`118`	`data_gen=partial(`
Original file line number	Diff line number	Diff line change
`@@ -131,7 +131,7 @@ def generate_SectionsTensorList2(attrs: List[Dict[str, Any]]):`
`131`	`131`	`{},`
`132`	`132`	`]`
`133`	`133`
`134`		`- dics_intput = [`
	`134`	`+ dics_input = [`
`135`	`135`	`{`
`136`	`136`	`"X": ["split_input"],`
`137`	`137`	`"AxisTensor": ["AxisTensor"],`
`@@ -142,7 +142,7 @@ def generate_SectionsTensorList2(attrs: List[Dict[str, Any]]):`
`142`	`142`	`},`
`143`	`143`	`{"X": ["split_input"]},`
`144`	`144`	`]`
`145`		`- dics_intputs = [`
	`145`	`+ dics_inputs = [`
`146`	`146`	`{`
`147`	`147`	`"AxisTensor": TensorConfig(`
`148`	`148`	`data_gen=partial(`
`@@ -168,15 +168,15 @@ def generate_SectionsTensorList2(attrs: List[Dict[str, Any]]):`
`168`	`168`	`ops_config = [`
`169`	`169`	`{`
`170`	`170`	`"op_type": "split",`
`171`		`- "op_inputs": dics_intput[num_input],`
	`171`	`+ "op_inputs": dics_input[num_input],`
`172`	`172`	`"op_outputs": {"Out": Out},`
`173`	`173`	`"op_attrs": dics[0],`
`174`	`174`	`}`
`175`	`175`	`]`
`176`	`176`	`ops = self.generate_op_config(ops_config)`
`177`	`177`	`program_config = ProgramConfig(`
`178`	`178`	`ops=ops,`
`179`		`- weights=dics_intputs[num_input],`
	`179`	`+ weights=dics_inputs[num_input],`
`180`	`180`	`inputs={`
`181`	`181`	`"split_input": TensorConfig(`
`182`	`182`	`data_gen=partial(`
`@@ -311,7 +311,7 @@ def generate_input1(attrs: List[Dict[str, Any]]):`
`311`	`311`	`"axis": axis,`
`312`	`312`	`}`
`313`	`313`	`]`
`314`		`- dics_intput = [`
	`314`	`+ dics_input = [`
`315`	`315`	`{`
`316`	`316`	`"X": ["split_input"],`
`317`	`317`	`"SectionsTensorList": [`
`@@ -354,7 +354,7 @@ def generate_input1(attrs: List[Dict[str, Any]]):`
`354`	`354`	`},`
`355`	`355`	`{`
`356`	`356`	`"op_type": "split",`
`357`		`- "op_inputs": dics_intput[0],`
	`357`	`+ "op_inputs": dics_input[0],`
`358`	`358`	`"op_outputs": {`
`359`	`359`	`"Out": [`
`360`	`360`	`"output_var0",`
Original file line number	Diff line number	Diff line change
`@@ -45,10 +45,10 @@ def set_case(self):`
`45`	`45`	`'X': np.random.randint(0, 100, self.shape).astype("float32")`
`46`	`46`	`}`
`47`	`47`
`48`		`- expect_intput = self.inputs['X']`
	`48`	`+ expect_input = self.inputs['X']`
`49`	`49`	`self.outputs = {`
`50`	`50`	`'Out': np.amax(`
`51`		`- expect_intput,`
	`51`	`+ expect_input,`
`52`	`52`	`axis=self.attrs['dim'],`
`53`	`53`	`keepdims=self.attrs['keep_dim'],`
`54`	`54`	`)`