fix int64

mindspore/ccsrc/transform/graph_ir/op_declare/array_ops_declare.cc

@@ -52,7 +52,7 @@ REG_ADPT_DESC(FlattenGrad, kNameFlattenGrad, ADPT_DESC(Reshape))
 
 // TransShape
 INPUT_MAP(TransShape) = {{1, INPUT_DESC(x)}};
-INPUT_ATTR_MAP(TransShape) = {{2, ATTR_DESC(outShape, AnyTraits<int>(), AnyTraits<std::vector<int64_t>>())}};
+INPUT_ATTR_MAP(TransShape) = {{2, ATTR_DESC(outShape, AnyTraits<int64_t>(), AnyTraits<std::vector<int64_t>>())}};
 ATTR_MAP(TransShape) = EMPTY_ATTR_MAP;
 OUTPUT_MAP(TransShape) = {{0, OUTPUT_DESC(y)}};
 REG_ADPT_DESC(TransShape, kNameTransShape, ADPT_DESC(TransShape))
@@ -77,14 +77,14 @@ REG_ADPT_DESC(ExpandDims, kNameExpandDims, ADPT_DESC(ExpandDims))
 
 // Squeeze
 INPUT_MAP(Squeeze) = {{1, INPUT_DESC(x)}};
-ATTR_MAP(Squeeze) = {{"axis", ATTR_DESC(axis, AnyTraits<int>(), AnyTraits<std::vector<int64_t>>())}};
+ATTR_MAP(Squeeze) = {{"axis", ATTR_DESC(axis, AnyTraits<int64_t>(), AnyTraits<std::vector<int64_t>>())}};
 OUTPUT_MAP(Squeeze) = {{0, OUTPUT_DESC(y)}};
 REG_ADPT_DESC(Squeeze, prim::kPrimSqueeze->name(), ADPT_DESC(Squeeze))
 
 // ReverseSequence
 INPUT_MAP(ReverseSequence) = {{1, INPUT_DESC(x)}, {2, INPUT_DESC(seq_lengths)}};
-ATTR_MAP(ReverseSequence) = {{"seq_dim", ATTR_DESC(seq_dim, AnyTraits<int>())},
-                             {"batch_dim", ATTR_DESC(batch_dim, AnyTraits<int>())}};
+ATTR_MAP(ReverseSequence) = {{"seq_dim", ATTR_DESC(seq_dim, AnyTraits<int64_t>())},
+                             {"batch_dim", ATTR_DESC(batch_dim, AnyTraits<int64_t>())}};
 OUTPUT_MAP(ReverseSequence) = {{0, OUTPUT_DESC(y)}};
 REG_ADPT_DESC(ReverseSequence, kNameReverseSequence, ADPT_DESC(ReverseSequence))
 

mindspore/ccsrc/transform/graph_ir/op_declare/elewise_calculation_ops_declare.cc

@@ -132,28 +132,28 @@ REG_ADPT_DESC(OnesLike, kNameOnesLike, ADPT_DESC(OnesLike))
 
 // ArgMaxD
 INPUT_MAP(ArgMaxD) = {{1, INPUT_DESC(x)}};
-ATTR_MAP(ArgMaxD) = {{"axis", ATTR_DESC(dimension, AnyTraits<int>())},
+ATTR_MAP(ArgMaxD) = {{"axis", ATTR_DESC(dimension, AnyTraits<int64_t>())},
                      {"output_type", ATTR_DESC(dtype, AnyTraits<GEType>())}};
 OUTPUT_MAP(ArgMaxD) = {{0, OUTPUT_DESC(y)}};
 REG_ADPT_DESC(ArgMaxD, kNameArgmax, ADPT_DESC(ArgMaxD))
 
 // ArgMinD
 INPUT_MAP(ArgMinD) = {{1, INPUT_DESC(x)}};
-ATTR_MAP(ArgMinD) = {{"axis", ATTR_DESC(dimension, AnyTraits<int>())},
+ATTR_MAP(ArgMinD) = {{"axis", ATTR_DESC(dimension, AnyTraits<int64_t>())},
                      {"output_type", ATTR_DESC(dtype, AnyTraits<GEType>())}};
 OUTPUT_MAP(ArgMinD) = {{0, OUTPUT_DESC(y)}};
 REG_ADPT_DESC(ArgMinD, kNameArgmin, ADPT_DESC(ArgMinD))
 
 // ArgMaxWithValue
 INPUT_MAP(ArgMaxWithValue) = {{1, INPUT_DESC(x)}};
-ATTR_MAP(ArgMaxWithValue) = {{"axis", ATTR_DESC(dimension, AnyTraits<int>())},
+ATTR_MAP(ArgMaxWithValue) = {{"axis", ATTR_DESC(dimension, AnyTraits<int64_t>())},
                              {"keep_dims", ATTR_DESC(keep_dims, AnyTraits<bool>())}};
 OUTPUT_MAP(ArgMaxWithValue) = {{0, OUTPUT_DESC(indice)}, {1, OUTPUT_DESC(values)}};
 REG_ADPT_DESC(ArgMaxWithValue, kNameArgMaxWithValue, ADPT_DESC(ArgMaxWithValue))
 
 // ArgMinWithValue
 INPUT_MAP(ArgMinWithValue) = {{1, INPUT_DESC(x)}};
-ATTR_MAP(ArgMinWithValue) = {{"axis", ATTR_DESC(dimension, AnyTraits<int>())},
+ATTR_MAP(ArgMinWithValue) = {{"axis", ATTR_DESC(dimension, AnyTraits<int64_t>())},
                              {"keep_dims", ATTR_DESC(keep_dims, AnyTraits<bool>())}};
 OUTPUT_MAP(ArgMinWithValue) = {{0, OUTPUT_DESC(indice)}, {1, OUTPUT_DESC(values)}};
 REG_ADPT_DESC(ArgMinWithValue, kNameArgMinWithValue, ADPT_DESC(ArgMinWithValue))

mindspore/ccsrc/transform/graph_ir/op_declare/hcom_ops_declare.cc

@@ -22,14 +22,14 @@ INPUT_MAP(HcomAllReduce) = {{1, INPUT_DESC(x)}};
 OUTPUT_MAP(HcomAllReduce) = {{0, OUTPUT_DESC(y)}};
 ATTR_MAP(HcomAllReduce) = {{"op", ATTR_DESC(reduction, AnyTraits<std::string>())},
                            {"group", ATTR_DESC(group, AnyTraits<std::string>())},
-                           {"fusion", ATTR_DESC(fusion, AnyTraits<int>())}};
+                           {"fusion", ATTR_DESC(fusion, AnyTraits<int64_t>())}};
 REG_ADPT_DESC(HcomAllReduce, kNameAllReduce, ADPT_DESC(HcomAllReduce))
 
 // HCOMBraodcast
 INPUT_MAP(HcomBroadcast) = EMPTY_INPUT_MAP;
 DYN_INPUT_MAP(HcomBroadcast) = {{1, DYN_INPUT_DESC(x)}};
 DYN_OUTPUT_MAP(HcomBroadcast) = {{0, DYN_OUTPUT_DESC(y)}};
-ATTR_MAP(HcomBroadcast) = {{"root_rank", ATTR_DESC(root_rank, AnyTraits<int>())},
+ATTR_MAP(HcomBroadcast) = {{"root_rank", ATTR_DESC(root_rank, AnyTraits<int64_t>())},
                            {"group", ATTR_DESC(group, AnyTraits<std::string>())}};
 REG_ADPT_DESC(HcomBroadcast, kNameBroadcast, ADPT_DESC(HcomBroadcast))
 
@@ -37,7 +37,7 @@ REG_ADPT_DESC(HcomBroadcast, kNameBroadcast, ADPT_DESC(HcomBroadcast))
 INPUT_MAP(HcomAllGather) = {{1, INPUT_DESC(x)}};
 OUTPUT_MAP(HcomAllGather) = {{0, OUTPUT_DESC(y)}};
 ATTR_MAP(HcomAllGather) = {{"group", ATTR_DESC(group, AnyTraits<std::string>())},
-                           {"rank_size", ATTR_DESC(rank_size, AnyTraits<int>())}};
+                           {"rank_size", ATTR_DESC(rank_size, AnyTraits<int64_t>())}};
 REG_ADPT_DESC(HcomAllGather, kNameAllgather, ADPT_DESC(HcomAllGather))
 
 // HCOMReduceScatter
@@ -45,6 +45,6 @@ INPUT_MAP(HcomReduceScatter) = {{1, INPUT_DESC(x)}};
 OUTPUT_MAP(HcomReduceScatter) = {{0, OUTPUT_DESC(y)}};
 ATTR_MAP(HcomReduceScatter) = {{"group", ATTR_DESC(group, AnyTraits<std::string>())},
                                {"op", ATTR_DESC(reduction, AnyTraits<std::string>())},
-                               {"rank_size", ATTR_DESC(rank_size, AnyTraits<int>())}};
+                               {"rank_size", ATTR_DESC(rank_size, AnyTraits<int64_t>())}};
 REG_ADPT_DESC(HcomReduceScatter, kNameReduceScatter, ADPT_DESC(HcomReduceScatter))
 }  // namespace mindspore::transform

mindspore/ccsrc/transform/graph_ir/op_declare/logging_ops_declare.cc

@@ -26,7 +26,7 @@ REG_ADPT_DESC(Print, kNamePrint, ADPT_DESC(Print))
 #ifdef ENABLE_GE
 INPUT_MAP(Assert) = {{1, INPUT_DESC(input_condition)}};
 DYN_INPUT_MAP(Assert) = {{2, DYN_INPUT_DESC(input_data)}};
-ATTR_MAP(Assert) = {{"summarize", ATTR_DESC(summarize, AnyTraits<int>())}};
+ATTR_MAP(Assert) = {{"summarize", ATTR_DESC(summarize, AnyTraits<int64_t>())}};
 REG_ADPT_DESC(Assert, kNameAssert, ADPT_DESC(Assert))
 #endif
 }  // namespace mindspore::transform

mindspore/ccsrc/transform/graph_ir/op_declare/nn_detect_ops_declare.cc

@@ -59,11 +59,11 @@ REG_ADPT_DESC(CheckValid, kNameCheckValid, ADPT_DESC(CheckValid))
 // ROIAlign
 INPUT_MAP(ROIAlign) = {{1, INPUT_DESC(features)}, {2, INPUT_DESC(rois)}};
 OUTPUT_MAP(ROIAlign) = {{0, OUTPUT_DESC(y)}};
-ATTR_MAP(ROIAlign) = {{"pooled_height", ATTR_DESC(pooled_height, AnyTraits<int>())},
-                      {"pooled_width", ATTR_DESC(pooled_width, AnyTraits<int>())},
+ATTR_MAP(ROIAlign) = {{"pooled_height", ATTR_DESC(pooled_height, AnyTraits<int64_t>())},
+                      {"pooled_width", ATTR_DESC(pooled_width, AnyTraits<int64_t>())},
                       {"spatial_scale", ATTR_DESC(spatial_scale, AnyTraits<float>())},
-                      {"sample_num", ATTR_DESC(sample_num, AnyTraits<int>())},
-                      {"roi_end_mode", ATTR_DESC(roi_end_mode, AnyTraits<int>())}};
+                      {"sample_num", ATTR_DESC(sample_num, AnyTraits<int64_t>())},
+                      {"roi_end_mode", ATTR_DESC(roi_end_mode, AnyTraits<int64_t>())}};
 REG_ADPT_DESC(ROIAlign, kNameROIAlign, ADPT_DESC(ROIAlign))
 
 // ROIAlignGrad
@@ -71,9 +71,9 @@ INPUT_MAP(ROIAlignGrad) = {{1, INPUT_DESC(ydiff)}, {2, INPUT_DESC(rois)}};
 OUTPUT_MAP(ROIAlignGrad) = {{0, OUTPUT_DESC(xdiff)}};
 ATTR_MAP(ROIAlignGrad) = {
   {"xdiff_shape", ATTR_DESC(xdiff_shape, AnyTraits<std::vector<int64_t>>(), AnyTraits<std::vector<int64_t>>())},
-  {"pooled_height", ATTR_DESC(pooled_height, AnyTraits<int>())},
-  {"pooled_width", ATTR_DESC(pooled_width, AnyTraits<int>())},
+  {"pooled_height", ATTR_DESC(pooled_height, AnyTraits<int64_t>())},
+  {"pooled_width", ATTR_DESC(pooled_width, AnyTraits<int64_t>())},
   {"spatial_scale", ATTR_DESC(spatial_scale, AnyTraits<float>())},
-  {"sample_num", ATTR_DESC(sample_num, AnyTraits<int>())}};
+  {"sample_num", ATTR_DESC(sample_num, AnyTraits<int64_t>())}};
 REG_ADPT_DESC(ROIAlignGrad, kNameROIAlignGrad, ADPT_DESC(ROIAlignGrad))
 }  // namespace mindspore::transform

mindspore/ccsrc/transform/graph_ir/op_declare/nn_norm_ops_declare.cc

@@ -82,8 +82,8 @@ REG_ADPT_DESC(LogSoftmaxV2, prim::kPrimLogSoftmax->name(), ADPT_DESC(LogSoftmaxV
 
 // LayerNorm
 INPUT_MAP(LayerNorm) = {{1, INPUT_DESC(x)}, {2, INPUT_DESC(gamma)}, {3, INPUT_DESC(beta)}};
-ATTR_MAP(LayerNorm) = {{"begin_norm_axis", ATTR_DESC(begin_norm_axis, AnyTraits<int>())},
-                       {"begin_params_axis", ATTR_DESC(begin_params_axis, AnyTraits<int>())},
+ATTR_MAP(LayerNorm) = {{"begin_norm_axis", ATTR_DESC(begin_norm_axis, AnyTraits<int64_t>())},
+                       {"begin_params_axis", ATTR_DESC(begin_params_axis, AnyTraits<int64_t>())},
                        {"epsilon", ATTR_DESC(epsilon, AnyTraits<float>())}};
 OUTPUT_MAP(LayerNorm) = {{0, OUTPUT_DESC(y)}, {1, OUTPUT_DESC(mean)}, {2, OUTPUT_DESC(variance)}};
 REG_ADPT_DESC(LayerNorm, prim::kPrimLayerNorm->name(), ADPT_DESC(LayerNorm))

mindspore/ccsrc/transform/graph_ir/op_declare/nn_pooling_ops_declare.cc

@@ -20,8 +20,8 @@
 namespace mindspore::transform {
 // MaxPool
 INPUT_MAP(MaxPool) = {{1, INPUT_DESC(x)}};
-ATTR_MAP(MaxPool) = {{"ksize", ATTR_DESC(ksize, AnyTraits<int>(), AnyTraits<std::vector<int64_t>>())},
-                     {"strides", ATTR_DESC(strides, AnyTraits<int>(), AnyTraits<std::vector<int64_t>>())},
+ATTR_MAP(MaxPool) = {{"ksize", ATTR_DESC(ksize, AnyTraits<int64_t>(), AnyTraits<std::vector<int64_t>>())},
+                     {"strides", ATTR_DESC(strides, AnyTraits<int64_t>(), AnyTraits<std::vector<int64_t>>())},
                      {"padding", ATTR_DESC(padding, AnyTraits<std::string>())},
                      {"data_format", ATTR_DESC(data_format, AnyTraits<std::string>())}};
 OUTPUT_MAP(MaxPool) = {{0, OUTPUT_DESC(y)}};
@@ -29,8 +29,8 @@ REG_ADPT_DESC(MaxPool, kNameMaxPool, ADPT_DESC(MaxPool))
 
 // AvgPool
 INPUT_MAP(AvgPool) = {{1, INPUT_DESC(x)}};
-ATTR_MAP(AvgPool) = {{"ksize", ATTR_DESC(ksize, AnyTraits<int>(), AnyTraits<std::vector<int64_t>>())},
-                     {"strides", ATTR_DESC(strides, AnyTraits<int>(), AnyTraits<std::vector<int64_t>>())},
+ATTR_MAP(AvgPool) = {{"ksize", ATTR_DESC(ksize, AnyTraits<int64_t>(), AnyTraits<std::vector<int64_t>>())},
+                     {"strides", ATTR_DESC(strides, AnyTraits<int64_t>(), AnyTraits<std::vector<int64_t>>())},
                      {"padding", ATTR_DESC(padding, AnyTraits<std::string>())},
                      {"data_format", ATTR_DESC(data_format, AnyTraits<std::string>())}};
 OUTPUT_MAP(AvgPool) = {{0, OUTPUT_DESC(y)}};
@@ -38,8 +38,8 @@ REG_ADPT_DESC(AvgPool, kNameAvgPool, ADPT_DESC(AvgPool))
 
 // MaxPoolGrad
 INPUT_MAP(MaxPoolGrad) = {{1, INPUT_DESC(x1)}, {2, INPUT_DESC(x2)}, {3, INPUT_DESC(grad)}};
-ATTR_MAP(MaxPoolGrad) = {{"ksize", ATTR_DESC(ksize, AnyTraits<int>(), AnyTraits<std::vector<int64_t>>())},
-                         {"strides", ATTR_DESC(strides, AnyTraits<int>(), AnyTraits<std::vector<int64_t>>())},
+ATTR_MAP(MaxPoolGrad) = {{"ksize", ATTR_DESC(ksize, AnyTraits<int64_t>(), AnyTraits<std::vector<int64_t>>())},
+                         {"strides", ATTR_DESC(strides, AnyTraits<int64_t>(), AnyTraits<std::vector<int64_t>>())},
                          {"padding", ATTR_DESC(padding, AnyTraits<std::string>())},
                          {"data_format", ATTR_DESC(data_format, AnyTraits<std::string>())}};
 OUTPUT_MAP(MaxPoolGrad) = {{0, OUTPUT_DESC(y)}};
@@ -47,8 +47,8 @@ REG_ADPT_DESC(MaxPoolGrad, kNameMaxPoolGrad, ADPT_DESC(MaxPoolGrad))
 
 // avgpoolgrad
 INPUT_MAP(AvgPoolGrad) = {{1, INPUT_DESC(orig_input_shape)}, {2, INPUT_DESC(input_grad)}};
-ATTR_MAP(AvgPoolGrad) = {{"ksize", ATTR_DESC(ksize, AnyTraits<int>(), AnyTraits<std::vector<int64_t>>())},
-                         {"strides", ATTR_DESC(strides, AnyTraits<int>(), AnyTraits<std::vector<int64_t>>())},
+ATTR_MAP(AvgPoolGrad) = {{"ksize", ATTR_DESC(ksize, AnyTraits<int64_t>(), AnyTraits<std::vector<int64_t>>())},
+                         {"strides", ATTR_DESC(strides, AnyTraits<int64_t>(), AnyTraits<std::vector<int64_t>>())},
                          {"padding", ATTR_DESC(padding, AnyTraits<std::string>())},
                          {"data_format", ATTR_DESC(data_format, AnyTraits<std::string>())}};
 OUTPUT_MAP(AvgPoolGrad) = {{0, OUTPUT_DESC(out_grad)}};
@@ -56,17 +56,18 @@ REG_ADPT_DESC(AvgPoolGrad, kNameAvgPoolGrad, ADPT_DESC(AvgPoolGrad))
 
 // MaxPoolWithArgmax
 INPUT_MAP(MaxPoolWithArgmax) = {{1, INPUT_DESC(x)}};
-ATTR_MAP(MaxPoolWithArgmax) = {{"ksize", ATTR_DESC(ksize, AnyTraits<int>(), AnyTraits<std::vector<int64_t>>())},
-                               {"strides", ATTR_DESC(strides, AnyTraits<int>(), AnyTraits<std::vector<int64_t>>())},
+ATTR_MAP(MaxPoolWithArgmax) = {{"ksize", ATTR_DESC(ksize, AnyTraits<int64_t>(), AnyTraits<std::vector<int64_t>>())},
+                               {"strides", ATTR_DESC(strides, AnyTraits<int64_t>(), AnyTraits<std::vector<int64_t>>())},
                                {"padding", ATTR_DESC(padding, AnyTraits<std::string>())}};
 OUTPUT_MAP(MaxPoolWithArgmax) = {{0, OUTPUT_DESC(y)}, {1, OUTPUT_DESC(argmax)}};
 REG_ADPT_DESC(MaxPoolWithArgmax, kNameMaxPoolWithArgmax, ADPT_DESC(MaxPoolWithArgmax))
 
 // MaxPoolGradWithArgmax
 INPUT_MAP(MaxPoolGradWithArgmax) = {{1, INPUT_DESC(x)}, {2, INPUT_DESC(grad)}, {3, INPUT_DESC(argmax)}};
-ATTR_MAP(MaxPoolGradWithArgmax) = {{"ksize", ATTR_DESC(ksize, AnyTraits<int>(), AnyTraits<std::vector<int64_t>>())},
-                                   {"strides", ATTR_DESC(strides, AnyTraits<int>(), AnyTraits<std::vector<int64_t>>())},
-                                   {"padding", ATTR_DESC(padding, AnyTraits<std::string>())}};
+ATTR_MAP(MaxPoolGradWithArgmax) = {
+  {"ksize", ATTR_DESC(ksize, AnyTraits<int64_t>(), AnyTraits<std::vector<int64_t>>())},
+  {"strides", ATTR_DESC(strides, AnyTraits<int64_t>(), AnyTraits<std::vector<int64_t>>())},
+  {"padding", ATTR_DESC(padding, AnyTraits<std::string>())}};
 OUTPUT_MAP(MaxPoolGradWithArgmax) = {{0, OUTPUT_DESC(y)}};
 REG_ADPT_DESC(MaxPoolGradWithArgmax, kNameMaxPoolGradWithArgmax, ADPT_DESC(MaxPoolGradWithArgmax))
 }  // namespace mindspore::transform

mindspore/ccsrc/transform/graph_ir/op_declare/selection_ops_declare.cc

@@ -40,8 +40,8 @@ OUTPUT_MAP(CumprodD) = {{0, OUTPUT_DESC(y)}};
 REG_ADPT_DESC(CumprodD, kNameCumProd, ADPT_DESC(CumprodD))
 
 INPUT_MAP(SliceD) = {{1, INPUT_DESC(x)}};
-INPUT_ATTR_MAP(SliceD) = {{2, ATTR_DESC(offsets, AnyTraits<int>(), AnyTraits<std::vector<int64_t>>())},
-                          {3, ATTR_DESC(size, AnyTraits<int>(), AnyTraits<std::vector<int64_t>>())}};
+INPUT_ATTR_MAP(SliceD) = {{2, ATTR_DESC(offsets, AnyTraits<int64_t>(), AnyTraits<std::vector<int64_t>>())},
+                          {3, ATTR_DESC(size, AnyTraits<int64_t>(), AnyTraits<std::vector<int64_t>>())}};
 ATTR_MAP(SliceD) = EMPTY_ATTR_MAP;
 OUTPUT_MAP(SliceD) = {{0, OUTPUT_DESC(y)}};
 REG_ADPT_DESC(SliceD, kNameSlice, ADPT_DESC(SliceD))
@@ -54,7 +54,7 @@ REG_ADPT_DESC(TopK, kNameTopK, ADPT_DESC(TopK))
 
 // TileD
 INPUT_MAP(TileD) = {{1, INPUT_DESC(x)}};
-INPUT_ATTR_MAP(TileD) = {{2, ATTR_DESC(multiples, AnyTraits<int>(), AnyTraits<std::vector<int64_t>>())}};
+INPUT_ATTR_MAP(TileD) = {{2, ATTR_DESC(multiples, AnyTraits<int64_t>(), AnyTraits<std::vector<int64_t>>())}};
 ATTR_MAP(TileD) = EMPTY_ATTR_MAP;
 OUTPUT_MAP(TileD) = {{0, OUTPUT_DESC(y)}};
 REG_ADPT_DESC(TileD, kNameTile, ADPT_DESC(TileD))
@@ -136,7 +136,7 @@ REG_ADPT_DESC(UnsortedSegmentMin, prim::kPrimUnsortedSegmentMin->name(), ADPT_DE
 
 // ReverseV2
 INPUT_MAP(ReverseV2D) = {{1, INPUT_DESC(x)}};
-ATTR_MAP(ReverseV2D) = {{"axis", ATTR_DESC(axis, AnyTraits<int>(), AnyTraits<std::vector<int64_t>>())}};
+ATTR_MAP(ReverseV2D) = {{"axis", ATTR_DESC(axis, AnyTraits<int64_t>(), AnyTraits<std::vector<int64_t>>())}};
 OUTPUT_MAP(ReverseV2D) = {{0, OUTPUT_DESC(y)}};
 REG_ADPT_DESC(ReverseV2D, kNameReverseV2, ADPT_DESC(ReverseV2D))
 }  // namespace mindspore::transform

mindspore/ccsrc/transform/graph_ir/op_declare/split_combination_ops_declare.cc

@@ -19,15 +19,15 @@
 namespace mindspore::transform {
 // SplitD
 INPUT_MAP(SplitD) = {{1, INPUT_DESC(x)}};
-ATTR_MAP(SplitD) = {{"axis", ATTR_DESC(split_dim, AnyTraits<int>())},
-                    {"output_num", ATTR_DESC(num_split, AnyTraits<int>())}};
+ATTR_MAP(SplitD) = {{"axis", ATTR_DESC(split_dim, AnyTraits<int64_t>())},
+                    {"output_num", ATTR_DESC(num_split, AnyTraits<int64_t>())}};
 DYN_OUTPUT_MAP(SplitD) = {{0, DYN_OUTPUT_DESC(y)}};
 REG_ADPT_DESC(SplitD, kNameSplitD, ADPT_DESC(SplitD))
 
 // Pack
 INPUT_MAP(Pack) = EMPTY_INPUT_MAP;
 DYN_INPUT_MAP(Pack) = {{1, DYN_INPUT_DESC(x)}};
-ATTR_MAP(Pack) = {{"num", ATTR_DESC(N, AnyTraits<int>())}, {"axis", ATTR_DESC(axis, AnyTraits<int>())}};
+ATTR_MAP(Pack) = {{"num", ATTR_DESC(N, AnyTraits<int64_t>())}, {"axis", ATTR_DESC(axis, AnyTraits<int64_t>())}};
 OUTPUT_MAP(Pack) = {{0, OUTPUT_DESC(y)}};
 REG_ADPT_DESC(Pack, kNamePack, ADPT_DESC(Pack))
 
@@ -35,8 +35,8 @@ REG_ADPT_DESC(Pack, kNamePack, ADPT_DESC(Pack))
 INPUT_MAP(ConcatD) = EMPTY_INPUT_MAP;
 DYN_INPUT_MAP(ConcatD) = {{1, DYN_INPUT_DESC(x)}};
 ATTR_MAP(ConcatD) = {
-  {"axis", ATTR_DESC(concat_dim, AnyTraits<int>())},
-  {"inputNums", ATTR_DESC(N, AnyTraits<int>())},
+  {"axis", ATTR_DESC(concat_dim, AnyTraits<int64_t>())},
+  {"inputNums", ATTR_DESC(N, AnyTraits<int64_t>())},
 };
 OUTPUT_MAP(ConcatD) = {{0, OUTPUT_DESC(y)}};
 REG_ADPT_DESC(ConcatD, prim::kPrimConcat->name(), ADPT_DESC(ConcatD))

mindspore/ccsrc/transform/graph_ir/op_declare/transformation_ops_declare.cc

@@ -26,22 +26,23 @@ REG_ADPT_DESC(Flatten, prim::kPrimFlatten->name(), ADPT_DESC(Flatten))
 
 // Unpack
 INPUT_MAP(Unpack) = {{1, INPUT_DESC(x)}};
-ATTR_MAP(Unpack) = {{"axis", ATTR_DESC(axis, AnyTraits<int>())}, {"num", ATTR_DESC(num, AnyTraits<int>())}};
+ATTR_MAP(Unpack) = {{"axis", ATTR_DESC(axis, AnyTraits<int64_t>())}, {"num", ATTR_DESC(num, AnyTraits<int64_t>())}};
 DYN_OUTPUT_MAP(Unpack) = {{0, DYN_OUTPUT_DESC(y)}};
 REG_ADPT_DESC(Unpack, kNameUnpack, ADPT_DESC(Unpack))
 
 // ExtractImagePatches
 INPUT_MAP(ExtractImagePatches) = {{1, INPUT_DESC(x)}};
-ATTR_MAP(ExtractImagePatches) = {{"ksizes", ATTR_DESC(ksizes, AnyTraits<int>(), AnyTraits<std::vector<int64_t>>())},
-                                 {"strides", ATTR_DESC(strides, AnyTraits<int>(), AnyTraits<std::vector<int64_t>>())},
-                                 {"rates", ATTR_DESC(rates, AnyTraits<int>(), AnyTraits<std::vector<int64_t>>())},
-                                 {"padding", ATTR_DESC(padding, AnyTraits<std::string>())}};
+ATTR_MAP(ExtractImagePatches) = {
+  {"ksizes", ATTR_DESC(ksizes, AnyTraits<int64_t>(), AnyTraits<std::vector<int64_t>>())},
+  {"strides", ATTR_DESC(strides, AnyTraits<int64_t>(), AnyTraits<std::vector<int64_t>>())},
+  {"rates", ATTR_DESC(rates, AnyTraits<int64_t>(), AnyTraits<std::vector<int64_t>>())},
+  {"padding", ATTR_DESC(padding, AnyTraits<std::string>())}};
 OUTPUT_MAP(ExtractImagePatches) = {{0, OUTPUT_DESC(y)}};
 REG_ADPT_DESC(ExtractImagePatches, kNameExtractImagePatches, ADPT_DESC(ExtractImagePatches))
 
 // Transpose
 INPUT_MAP(TransposeD) = {{1, INPUT_DESC(x)}};
-INPUT_ATTR_MAP(TransposeD) = {{2, ATTR_DESC(perm, AnyTraits<int>(), AnyTraits<std::vector<int64_t>>())}};
+INPUT_ATTR_MAP(TransposeD) = {{2, ATTR_DESC(perm, AnyTraits<int64_t>(), AnyTraits<std::vector<int64_t>>())}};
 ATTR_MAP(TransposeD) = EMPTY_ATTR_MAP;
 // Do not set Transpose operator output descriptor
 REG_ADPT_DESC(TransposeD, prim::kPrimTranspose->name(), ADPT_DESC(TransposeD))