1From cff83709eb00161cfb61ad93346828bde2d9a2e8 Mon Sep 17 00:00:00 2001 2From: chengfeng27 <chengfeng27@huawei.com> 3Date: Fri, 29 Mar 2024 14:19:14 +0800 4Subject: [PATCH] add mindir ops third phase 5 6--- 7 mindspore/lite/mindir/include/mindir.h | 134 +- 8 mindspore/lite/mindir/include/mindir_types.h | 27 + 9 mindspore/lite/mindir/src/mindir.cc | 1147 +++++++++++++++++- 10 3 files changed, 1303 insertions(+), 5 deletions(-) 11 12diff --git a/mindspore/lite/mindir/include/mindir.h b/mindspore/lite/mindir/include/mindir.h 13index 4f633493..7eb3a744 100644 14--- a/mindspore/lite/mindir/include/mindir.h 15+++ b/mindspore/lite/mindir/include/mindir.h 16@@ -270,11 +270,13 @@ bool MindIR_PReLUFusion_GetChannelShared(ConstPrimitivePtr primitive); 17 void MindIR_PReLUFusion_SetChannelShared(PrimitivePtr *primitive, bool channel_shared); 18 19 // ********** QuantDTypeCast ********** 20-PrimitivePtr MindIR_QuantDTypeCast_CreatePrimitive(int64_t src_t, int64_t dst_t); 21+PrimitivePtr MindIR_QuantDTypeCast_CreatePrimitive(int64_t src_t, int64_t dst_t, int64_t axis); 22 int64_t MindIR_QuantDTypeCast_GetSrcT(ConstPrimitivePtr primitive); 23 void MindIR_QuantDTypeCast_SetSrcT(PrimitivePtr *primitive, int64_t src_t); 24 int64_t MindIR_QuantDTypeCast_GetDstT(ConstPrimitivePtr primitive); 25 void MindIR_QuantDTypeCast_SetDstT(PrimitivePtr *primitive, int64_t dst_t); 26+int64_t MindIR_QuantDTypeCast_GetAxis(ConstPrimitivePtr primitive); 27+void MindIR_QuantDTypeCast_SetAxis(PrimitivePtr *primitive, int64_t axis); 28 29 // ********** ReduceFusion ********** 30 PrimitivePtr MindIR_ReduceFusion_CreatePrimitive(bool keep_dims, ReduceMode mode, bool reduce_to_end, float coeff); 31@@ -534,6 +536,136 @@ void MindIR_Clip_SetMax(PrimitivePtr *primitive, float max); 32 float MindIR_Clip_GetMin(ConstPrimitivePtr primitive); 33 void MindIR_Clip_SetMin(PrimitivePtr *primitive, float min); 34 35+// ********** All ********** 36+PrimitivePtr MindIR_All_CreatePrimitive(int64_t keep_dims); 37+int64_t MindIR_All_GetKeepDims(ConstPrimitivePtr primitive); 38+void MindIR_All_SetKeepDims(PrimitivePtr *primitive, int64_t keep_dims); 39+ 40+// ********** Assert ********** 41+PrimitivePtr MindIR_Assert_CreatePrimitive(int64_t summarize); 42+int64_t MindIR_Assert_GetSummarize(ConstPrimitivePtr primitive); 43+void MindIR_Assert_SetSummarize(PrimitivePtr *primitive, int64_t summarize); 44+ 45+// ********** LogicalAnd ********** 46+PrimitivePtr MindIR_LogicalAnd_CreatePrimitive(); 47+ 48+// ********** LogicalNot ********** 49+PrimitivePtr MindIR_LogicalNot_CreatePrimitive(); 50+ 51+// ********** Cos ********** 52+PrimitivePtr MindIR_Cos_CreatePrimitive(); 53+ 54+// ********** Mod ********** 55+PrimitivePtr MindIR_Mod_CreatePrimitive(); 56+ 57+// ********** Neg ********** 58+PrimitivePtr MindIR_Neg_CreatePrimitive(); 59+ 60+// ********** Reciprocal ********** 61+PrimitivePtr MindIR_Reciprocal_CreatePrimitive(); 62+ 63+// ********** Sin ********** 64+PrimitivePtr MindIR_Sin_CreatePrimitive(); 65+ 66+// ********** Where ********** 67+PrimitivePtr MindIR_Where_CreatePrimitive(); 68+ 69+// ********** Log ********** 70+PrimitivePtr MindIR_Log_CreatePrimitive(); 71+ 72+// ********** LogicalOr ********** 73+PrimitivePtr MindIR_LogicalOr_CreatePrimitive(); 74+ 75+// ********** SparseToDense ********** 76+PrimitivePtr MindIR_SparseToDense_CreatePrimitive(); 77+ 78+// ********** Minimum ********** 79+PrimitivePtr MindIR_Minimum_CreatePrimitive(); 80+ 81+// ********** SpaceToDepth ********** 82+PrimitivePtr MindIR_SpaceToDepth_CreatePrimitive(int64_t block_size, Format format); 83+int64_t MindIR_SpaceToDepth_GetBlockSize(ConstPrimitivePtr primitive); 84+void MindIR_SpaceToDepth_SetBlockSize(PrimitivePtr *primitive, int64_t block_size); 85+Format MindIR_SpaceToDepth_GetFormat(ConstPrimitivePtr primitive); 86+void MindIR_SpaceToDepth_SetFormat(PrimitivePtr *primitive, Format format); 87+ 88+// ********** Round ********** 89+PrimitivePtr MindIR_Round_CreatePrimitive(); 90+ 91+// ********** Ceil ********** 92+PrimitivePtr MindIR_Ceil_CreatePrimitive(); 93+ 94+// ********** Floor ********** 95+PrimitivePtr MindIR_Floor_CreatePrimitive(); 96+ 97+// ********** L2NormalizeFusion ********** 98+PrimitivePtr MindIR_L2NormalizeFusion_CreatePrimitive(const std::vector<int64_t>& axis, float epsilon, ActivationType activation_type); 99+std::vector<int64_t> MindIR_L2NormalizeFusion_GetAxis(ConstPrimitivePtr primitive); 100+void MindIR_L2NormalizeFusion_SetAxis(PrimitivePtr *primitive, const std::vector<int64_t>& axis); 101+float MindIR_L2NormalizeFusion_GetEpsilon(ConstPrimitivePtr primitive); 102+void MindIR_L2NormalizeFusion_SetEpsilon(PrimitivePtr *primitive, float epsilon); 103+ActivationType MindIR_L2NormalizeFusion_GetActivationType(ConstPrimitivePtr primitive); 104+void MindIR_L2NormalizeFusion_SetActivationType(PrimitivePtr *primitive, ActivationType activation_type); 105+ 106+// ********** LRN ********** 107+PrimitivePtr MindIR_LRN_CreatePrimitive(int64_t depth_radius, float bias, float alpha, float beta, std::string norm_region); 108+int64_t MindIR_LRN_GetDepthRadius(ConstPrimitivePtr primitive); 109+void MindIR_LRN_SetDepthRadius(PrimitivePtr *primitive, int64_t depth_radius); 110+float MindIR_LRN_GetBias(ConstPrimitivePtr primitive); 111+void MindIR_LRN_SetBias(PrimitivePtr *primitive, float bias); 112+float MindIR_LRN_GetAlpha(ConstPrimitivePtr primitive); 113+void MindIR_LRN_SetAlpha(PrimitivePtr *primitive, float alpha); 114+float MindIR_LRN_GetBeta(ConstPrimitivePtr primitive); 115+void MindIR_LRN_SetBeta(PrimitivePtr *primitive, float beta); 116+std::string MindIR_LRN_GetNormRegion(ConstPrimitivePtr primitive); 117+void MindIR_LRN_SetNormRegion(PrimitivePtr *primitive, std::string norm_region); 118+ 119+// ********** LogSoftmax ********** 120+PrimitivePtr MindIR_LogSoftmax_CreatePrimitive(int64_t axis); 121+int64_t MindIR_LogSoftmax_GetAxis(ConstPrimitivePtr primitive); 122+void MindIR_LogSoftmax_SetAxis(PrimitivePtr *primitive, int64_t axis); 123+ 124+// ********** Crop ********** 125+PrimitivePtr MindIR_Crop_CreatePrimitive(int64_t axis, const std::vector<int64_t>& offsets); 126+int64_t MindIR_Crop_GetAxis(ConstPrimitivePtr primitive); 127+void MindIR_Crop_SetAxis(PrimitivePtr *primitive, int64_t axis); 128+std::vector<int64_t> MindIR_Crop_GetOffsets(ConstPrimitivePtr primitive); 129+void MindIR_Crop_SetOffsets(PrimitivePtr *primitive, const std::vector<int64_t>& offsets); 130+ 131+// ********** DetectionPostProcess ********** 132+PrimitivePtr MindIR_DetectionPostProcess_CreatePrimitive(Format format, int64_t input_size, const std::vector<float>& scale, float nms_iou_threshold, float nms_score_threshold, int64_t max_detections, int64_t detections_per_class, int64_t max_classes_per_detection, int64_t num_classes, bool use_regular_nms, bool out_quantized); 133+Format MindIR_DetectionPostProcess_GetFormat(ConstPrimitivePtr primitive); 134+void MindIR_DetectionPostProcess_SetFormat(PrimitivePtr *primitive, Format format); 135+int64_t MindIR_DetectionPostProcess_GetInputSize(ConstPrimitivePtr primitive); 136+void MindIR_DetectionPostProcess_SetInputSize(PrimitivePtr *primitive, int64_t input_size); 137+std::vector<float> MindIR_DetectionPostProcess_GetScale(ConstPrimitivePtr primitive); 138+void MindIR_DetectionPostProcess_SetScale(PrimitivePtr *primitive, const std::vector<float>& scale); 139+float MindIR_DetectionPostProcess_GetNmsIouThreshold(ConstPrimitivePtr primitive); 140+void MindIR_DetectionPostProcess_SetNmsIouThreshold(PrimitivePtr *primitive, float nms_iou_threshold); 141+float MindIR_DetectionPostProcess_GetNmsScoreThreshold(ConstPrimitivePtr primitive); 142+void MindIR_DetectionPostProcess_SetNmsScoreThreshold(PrimitivePtr *primitive, float nms_score_threshold); 143+int64_t MindIR_DetectionPostProcess_GetMaxDetections(ConstPrimitivePtr primitive); 144+void MindIR_DetectionPostProcess_SetMaxDetections(PrimitivePtr *primitive, int64_t max_detections); 145+int64_t MindIR_DetectionPostProcess_GetDetectionsPerClass(ConstPrimitivePtr primitive); 146+void MindIR_DetectionPostProcess_SetDetectionsPerClass(PrimitivePtr *primitive, int64_t detections_per_class); 147+int64_t MindIR_DetectionPostProcess_GetMaxClassesPerDetection(ConstPrimitivePtr primitive); 148+void MindIR_DetectionPostProcess_SetMaxClassesPerDetection(PrimitivePtr *primitive, int64_t max_classes_per_detection); 149+int64_t MindIR_DetectionPostProcess_GetNumClasses(ConstPrimitivePtr primitive); 150+void MindIR_DetectionPostProcess_SetNumClasses(PrimitivePtr *primitive, int64_t num_classes); 151+bool MindIR_DetectionPostProcess_GetUseRegularNms(ConstPrimitivePtr primitive); 152+void MindIR_DetectionPostProcess_SetUseRegularNms(PrimitivePtr *primitive, bool use_regular_nms); 153+bool MindIR_DetectionPostProcess_GetOutQuantized(ConstPrimitivePtr primitive); 154+void MindIR_DetectionPostProcess_SetOutQuantized(PrimitivePtr *primitive, bool out_quantized); 155+ 156+// ********** ScatterNd ********** 157+PrimitivePtr MindIR_ScatterNd_CreatePrimitive(); 158+ 159+// ********** Rank ********** 160+PrimitivePtr MindIR_Rank_CreatePrimitive(); 161+ 162+// ********** GatherNd ********** 163+PrimitivePtr MindIR_GatherNd_CreatePrimitive(); 164+ 165 // ********** Custom ********** 166 std::vector<const mindspore::schema::Attribute *> MindIR_Custom_GetAttr(ConstPrimitivePtr primitive); 167 std::string MindIR_Attribute_GetName(const mindspore::schema::Attribute &attr); 168diff --git a/mindspore/lite/mindir/include/mindir_types.h b/mindspore/lite/mindir/include/mindir_types.h 169index 3ee6aca1..5744441a 100644 170--- a/mindspore/lite/mindir/include/mindir_types.h 171+++ b/mindspore/lite/mindir/include/mindir_types.h 172@@ -56,28 +56,36 @@ enum NodeType : uint32_t { 173 NODE_TYPE_ABS = 1, 174 NODE_TYPE_ACTIVATION = 2, 175 NODE_TYPE_ADD_FUSION = 5, 176+ NODE_TYPE_ALL = 9, 177 NODE_TYPE_ARGMAX_FUSION = 11, 178+ NODE_TYPE_ASSERT = 13, 179 NODE_TYPE_AVG_POOL_FUSION = 17, 180 NODE_TYPE_BATCH_TO_SPACE_ND = 22, 181 NODE_TYPE_BIAS_ADD = 23, 182 NODE_TYPE_BROADCAST_TO = 27, 183 NODE_TYPE_CAST = 28, 184+ NODE_TYPE_CEIL = 29, 185 NODE_TYPE_CLIP = 30, 186 NODE_TYPE_CONCAT = 31, 187 NODE_TYPE_CONV2D_FUSION = 35, 188 NODE_TYPE_CONV2D_TRANSPOSE_FUSION = 36, 189+ NODE_TYPE_COS = 37, 190 NODE_TYPE_CONSTANT_OF_SHAPE = 38, 191+ NODE_TYPE_CROP = 39, 192 NODE_TYPE_DEPTH_TO_SPACE = 45, 193+ NODE_TYPE_DETECTION_POST_PROCESS = 46, 194 NODE_TYPE_DIV_FUSION = 47, 195 NODE_TYPE_ELTWISE = 52, 196 NODE_TYPE_EQUAL = 53, 197 NODE_TYPE_EXPFUSION = 55, 198 NODE_TYPE_EXPAND_DIMS = 56, 199 NODE_TYPE_FLATTEN = 61, 200+ NODE_TYPE_FLOOR = 63, 201 NODE_TYPE_FILL = 66, 202 NODE_TYPE_FULL_CONNECTION = 67, 203 NODE_TYPE_FUSED_BATCH_NORM = 68, 204 NODE_TYPE_GATHER = 69, 205+ NODE_TYPE_GATHER_ND = 70, 206 NODE_TYPE_GREATER = 71, 207 NODE_TYPE_GREATER_EQUAL = 72, 208 NODE_TYPE_INSTANCE_NORM = 74, 209@@ -85,28 +93,44 @@ enum NodeType : uint32_t { 210 NODE_TYPE_LEAKY_RELU = 76, 211 NODE_TYPE_LESS = 77, 212 NODE_TYPE_LESS_EQUAL = 78, 213+ NODE_TYPE_LOG = 79, 214+ NODE_TYPE_LOGICAL_AND = 81, 215+ NODE_TYPE_LOGICAL_NOT = 82, 216+ NODE_TYPE_LOGICAL_OR = 83, 217+ NODE_TYPE_L_R_N = 85, 218 NODE_TYPE_LSTM = 87, 219+ NODE_TYPE_L2_NORMALIZE_FUSION = 88, 220 NODE_TYPE_MATMUL_FUSION = 89, 221 NODE_TYPE_MAXIMUM = 90, 222 NODE_TYPE_MAX_POOL_FUSION = 92, 223+ NODE_TYPE_MINIMUM = 96, 224+ NODE_TYPE_MOD = 98, 225 NODE_TYPE_MUL_FUSION = 99, 226+ NODE_TYPE_NEG = 101, 227 NODE_TYPE_NOT_EQUAL = 103, 228 NODE_TYPE_ONE_HOT = 105, 229 NODE_TYPE_PAD_FUSION = 107, 230 NODE_TYPE_POW_FUSION = 110, 231 NODE_TYPE_PRELU_FUSION = 112, 232 NODE_TYPE_QUANT_DTYPE_CAST = 113, 233+ NODE_TYPE_RANK = 114, 234 NODE_TYPE_RANGE = 115, 235+ NODE_TYPE_RECIPROCAL = 116, 236 NODE_TYPE_REAL_DIV = 117, 237 NODE_TYPE_REDUCE_FUSION = 118, 238 NODE_TYPE_RESHAPE = 119, 239 NODE_TYPE_RESIZE = 120, 240+ NODE_TYPE_ROUND = 125, 241 NODE_TYPE_RSQRT = 126, 242 NODE_TYPE_SCALE_FUSION = 127, 243+ NODE_TYPE_SCATTER_ND = 128, 244 NODE_TYPE_SHAPE = 130, 245+ NODE_TYPE_SIN = 133, 246 NODE_TYPE_SLICE_FUSION = 135, 247 NODE_TYPE_SOFTMAX = 138, 248 NODE_TYPE_SPACE_TO_BATCH_ND = 141, 249+ NODE_TYPE_SPACE_TO_DEPTH = 142, 250+ NODE_TYPE_SPARSE_TO_DENSE = 144, 251 NODE_TYPE_SPLIT = 145, 252 NODE_TYPE_SQRT = 146, 253 NODE_TYPE_SQUEEZE = 147, 254@@ -120,8 +144,10 @@ enum NodeType : uint32_t { 255 NODE_TYPE_TRANSPOSE = 162, 256 NODE_TYPE_UNSQUEEZE = 165, 257 NODE_TYPE_UNSTACK = 166, 258+ NODE_TYPE_WHERE = 168, 259 NODE_TYPE_SELECT = 170, 260 NODE_TYPE_ERF = 178, 261+ NODE_TYPE_LOG_SOFTMAX = 189, 262 NODE_TYPE_CUSTOM = 191, 263 }; 264 265@@ -179,6 +205,7 @@ enum ReduceMode : int8_t { 266 REDUCE_MODE_SUM_SQUARE = 5, 267 REDUCE_MODE_ASUM = 6, 268 REDUCE_MODE_ALL = 7, 269+ REDUCE_MODE_L2 = 8, 270 }; 271 272 enum PoolMode : int8_t { 273diff --git a/mindspore/lite/mindir/src/mindir.cc b/mindspore/lite/mindir/src/mindir.cc 274index 36056c59..7041498a 100644 275--- a/mindspore/lite/mindir/src/mindir.cc 276+++ b/mindspore/lite/mindir/src/mindir.cc 277@@ -2896,9 +2896,9 @@ void MindIR_PReLUFusion_SetChannelShared(PrimitivePtr *primitive, bool channel_s 278 } 279 280 // ********** QuantDTypeCast ********** 281-PrimitivePtr MindIR_QuantDTypeCast_CreatePrimitive(int64_t src_t, int64_t dst_t) { 282+PrimitivePtr MindIR_QuantDTypeCast_CreatePrimitive(int64_t src_t, int64_t dst_t, int64_t axis) { 283 flatbuffers::FlatBufferBuilder fbb; 284- auto ops_offset = schema::CreateQuantDTypeCast(fbb, src_t, dst_t); 285+ auto ops_offset = schema::CreateQuantDTypeCast(fbb, src_t, dst_t, axis); 286 auto prim_offset = 287 schema::CreatePrimitive(fbb, static_cast<schema::PrimitiveType>(NODE_TYPE_QUANT_DTYPE_CAST), ops_offset.o); 288 fbb.Finish(prim_offset); 289@@ -2926,7 +2926,7 @@ void MindIR_QuantDTypeCast_SetSrcT(PrimitivePtr *primitive, int64_t src_t) { 290 auto value = prim->value_as_QuantDTypeCast(); 291 if (prim != nullptr && value != nullptr) { 292 flatbuffers::FlatBufferBuilder fbb; 293- auto ops_offset = schema::CreateQuantDTypeCast(fbb, src_t, value->dst_t()); 294+ auto ops_offset = schema::CreateQuantDTypeCast(fbb, src_t, value->dst_t(), value->axis()); 295 auto prim_offset = 296 schema::CreatePrimitive(fbb, static_cast<schema::PrimitiveType>(NODE_TYPE_QUANT_DTYPE_CAST), ops_offset.o); 297 fbb.Finish(prim_offset); 298@@ -2956,7 +2956,38 @@ void MindIR_QuantDTypeCast_SetDstT(PrimitivePtr *primitive, int64_t dst_t) { 299 auto value = prim->value_as_QuantDTypeCast(); 300 if (prim != nullptr && value != nullptr) { 301 flatbuffers::FlatBufferBuilder fbb; 302- auto ops_offset = schema::CreateQuantDTypeCast(fbb, value->src_t(), dst_t); 303+ auto ops_offset = schema::CreateQuantDTypeCast(fbb, value->src_t(), dst_t, value->axis()); 304+ auto prim_offset = 305+ schema::CreatePrimitive(fbb, static_cast<schema::PrimitiveType>(NODE_TYPE_QUANT_DTYPE_CAST), ops_offset.o); 306+ fbb.Finish(prim_offset); 307+ auto new_addr = MindIRMemoryManager::GetInstance()->CreatePrimitiveFromBuilder(fbb, prim); 308+ auto ret_value = flatbuffers::GetMutableRoot<schema::Primitive>(new_addr); 309+ *primitive = ret_value; 310+ } 311+ } 312+} 313+ 314+int64_t MindIR_QuantDTypeCast_GetAxis(ConstPrimitivePtr primitive) { 315+ if (primitive != nullptr) { 316+ auto prim = static_cast<const schema::Primitive *>(primitive); 317+ auto value = prim->value_as_QuantDTypeCast(); 318+ if (prim != nullptr && value != nullptr) { 319+ return value->axis(); 320+ } else { 321+ return 0; 322+ } 323+ } else { 324+ return 0; 325+ } 326+} 327+ 328+void MindIR_QuantDTypeCast_SetAxis(PrimitivePtr *primitive, int64_t axis) { 329+ if (primitive != nullptr && *primitive != nullptr) { 330+ auto prim = static_cast<schema::Primitive *>(*primitive); 331+ auto value = prim->value_as_QuantDTypeCast(); 332+ if (prim != nullptr && value != nullptr) { 333+ flatbuffers::FlatBufferBuilder fbb; 334+ auto ops_offset = schema::CreateQuantDTypeCast(fbb, value->src_t(), value->dst_t(), axis); 335 auto prim_offset = 336 schema::CreatePrimitive(fbb, static_cast<schema::PrimitiveType>(NODE_TYPE_QUANT_DTYPE_CAST), ops_offset.o); 337 fbb.Finish(prim_offset); 338@@ -5518,6 +5549,1114 @@ void MindIR_Clip_SetMin(PrimitivePtr *primitive, float min) { 339 } 340 } 341 342+// ********** All ********** 343+PrimitivePtr MindIR_All_CreatePrimitive(int64_t keep_dims) { 344+ flatbuffers::FlatBufferBuilder fbb; 345+ auto ops_offset = schema::CreateAll(fbb, keep_dims); 346+ auto prim_offset = schema::CreatePrimitive(fbb, static_cast<schema::PrimitiveType>(NODE_TYPE_ALL), ops_offset.o); 347+ fbb.Finish(prim_offset); 348+ auto new_addr = MindIRMemoryManager::GetInstance()->CreatePrimitiveFromBuilder(fbb, nullptr); 349+ auto ret_value = flatbuffers::GetMutableRoot<schema::Primitive>(new_addr); 350+ return ret_value; 351+} 352+ 353+int64_t MindIR_All_GetKeepDims(ConstPrimitivePtr primitive) { 354+ if (primitive != nullptr) { 355+ auto prim = static_cast<const schema::Primitive *>(primitive); 356+ auto value = prim->value_as_All(); 357+ if (prim != nullptr && value != nullptr) { 358+ return value->keep_dims(); 359+ } else { 360+ return 0; 361+ } 362+ } else { 363+ return 0; 364+ } 365+} 366+ 367+void MindIR_All_SetKeepDims(PrimitivePtr *primitive, int64_t keep_dims) { 368+ if (primitive != nullptr && *primitive != nullptr) { 369+ auto prim = static_cast<schema::Primitive *>(*primitive); 370+ auto value = prim->value_as_All(); 371+ if (prim != nullptr && value != nullptr) { 372+ flatbuffers::FlatBufferBuilder fbb; 373+ auto ops_offset = schema::CreateAll(fbb, keep_dims); 374+ auto prim_offset = schema::CreatePrimitive(fbb, static_cast<schema::PrimitiveType>(NODE_TYPE_ALL), ops_offset.o); 375+ fbb.Finish(prim_offset); 376+ auto new_addr = MindIRMemoryManager::GetInstance()->CreatePrimitiveFromBuilder(fbb, prim); 377+ auto ret_value = flatbuffers::GetMutableRoot<schema::Primitive>(new_addr); 378+ *primitive = ret_value; 379+ } 380+ } 381+} 382+ 383+// ********** Assert ********** 384+PrimitivePtr MindIR_Assert_CreatePrimitive(int64_t summarize) { 385+ flatbuffers::FlatBufferBuilder fbb; 386+ auto ops_offset = schema::CreateAssert(fbb, summarize); 387+ auto prim_offset = schema::CreatePrimitive(fbb, static_cast<schema::PrimitiveType>(NODE_TYPE_ASSERT), ops_offset.o); 388+ fbb.Finish(prim_offset); 389+ auto new_addr = MindIRMemoryManager::GetInstance()->CreatePrimitiveFromBuilder(fbb, nullptr); 390+ auto ret_value = flatbuffers::GetMutableRoot<schema::Primitive>(new_addr); 391+ return ret_value; 392+} 393+ 394+int64_t MindIR_Assert_GetSummarize(ConstPrimitivePtr primitive) { 395+ if (primitive != nullptr) { 396+ auto prim = static_cast<const schema::Primitive *>(primitive); 397+ auto value = prim->value_as_Assert(); 398+ if (prim != nullptr && value != nullptr) { 399+ return value->summarize(); 400+ } else { 401+ return 0; 402+ } 403+ } else { 404+ return 0; 405+ } 406+} 407+ 408+void MindIR_Assert_SetSummarize(PrimitivePtr *primitive, int64_t summarize) { 409+ if (primitive != nullptr && *primitive != nullptr) { 410+ auto prim = static_cast<schema::Primitive *>(*primitive); 411+ auto value = prim->value_as_Assert(); 412+ if (prim != nullptr && value != nullptr) { 413+ flatbuffers::FlatBufferBuilder fbb; 414+ auto ops_offset = schema::CreateAssert(fbb, summarize); 415+ auto prim_offset = schema::CreatePrimitive(fbb, static_cast<schema::PrimitiveType>(NODE_TYPE_ASSERT), ops_offset.o); 416+ fbb.Finish(prim_offset); 417+ auto new_addr = MindIRMemoryManager::GetInstance()->CreatePrimitiveFromBuilder(fbb, prim); 418+ auto ret_value = flatbuffers::GetMutableRoot<schema::Primitive>(new_addr); 419+ *primitive = ret_value; 420+ } 421+ } 422+} 423+ 424+// ********** LogicalAnd ********** 425+PrimitivePtr MindIR_LogicalAnd_CreatePrimitive() { 426+ flatbuffers::FlatBufferBuilder fbb; 427+ auto ops_offset = schema::CreateLogicalAnd(fbb); 428+ auto prim_offset = schema::CreatePrimitive(fbb, static_cast<schema::PrimitiveType>(NODE_TYPE_LOGICAL_AND), ops_offset.o); 429+ fbb.Finish(prim_offset); 430+ auto new_addr = MindIRMemoryManager::GetInstance()->CreatePrimitiveFromBuilder(fbb, nullptr); 431+ auto ret_value = flatbuffers::GetMutableRoot<schema::Primitive>(new_addr); 432+ return ret_value; 433+} 434+ 435+// ********** LogicalNot ********** 436+PrimitivePtr MindIR_LogicalNot_CreatePrimitive() { 437+ flatbuffers::FlatBufferBuilder fbb; 438+ auto ops_offset = schema::CreateLogicalNot(fbb); 439+ auto prim_offset = schema::CreatePrimitive(fbb, static_cast<schema::PrimitiveType>(NODE_TYPE_LOGICAL_NOT), ops_offset.o); 440+ fbb.Finish(prim_offset); 441+ auto new_addr = MindIRMemoryManager::GetInstance()->CreatePrimitiveFromBuilder(fbb, nullptr); 442+ auto ret_value = flatbuffers::GetMutableRoot<schema::Primitive>(new_addr); 443+ return ret_value; 444+} 445+ 446+// ********** Cos ********** 447+PrimitivePtr MindIR_Cos_CreatePrimitive() { 448+ flatbuffers::FlatBufferBuilder fbb; 449+ auto ops_offset = schema::CreateCos(fbb); 450+ auto prim_offset = schema::CreatePrimitive(fbb, static_cast<schema::PrimitiveType>(NODE_TYPE_COS), ops_offset.o); 451+ fbb.Finish(prim_offset); 452+ auto new_addr = MindIRMemoryManager::GetInstance()->CreatePrimitiveFromBuilder(fbb, nullptr); 453+ auto ret_value = flatbuffers::GetMutableRoot<schema::Primitive>(new_addr); 454+ return ret_value; 455+} 456+ 457+// ********** Mod ********** 458+PrimitivePtr MindIR_Mod_CreatePrimitive() { 459+ flatbuffers::FlatBufferBuilder fbb; 460+ auto ops_offset = schema::CreateMod(fbb); 461+ auto prim_offset = schema::CreatePrimitive(fbb, static_cast<schema::PrimitiveType>(NODE_TYPE_MOD), ops_offset.o); 462+ fbb.Finish(prim_offset); 463+ auto new_addr = MindIRMemoryManager::GetInstance()->CreatePrimitiveFromBuilder(fbb, nullptr); 464+ auto ret_value = flatbuffers::GetMutableRoot<schema::Primitive>(new_addr); 465+ return ret_value; 466+} 467+ 468+// ********** Neg ********** 469+PrimitivePtr MindIR_Neg_CreatePrimitive() { 470+ flatbuffers::FlatBufferBuilder fbb; 471+ auto ops_offset = schema::CreateNeg(fbb); 472+ auto prim_offset = schema::CreatePrimitive(fbb, static_cast<schema::PrimitiveType>(NODE_TYPE_NEG), ops_offset.o); 473+ fbb.Finish(prim_offset); 474+ auto new_addr = MindIRMemoryManager::GetInstance()->CreatePrimitiveFromBuilder(fbb, nullptr); 475+ auto ret_value = flatbuffers::GetMutableRoot<schema::Primitive>(new_addr); 476+ return ret_value; 477+} 478+ 479+// ********** Reciprocal ********** 480+PrimitivePtr MindIR_Reciprocal_CreatePrimitive() { 481+ flatbuffers::FlatBufferBuilder fbb; 482+ auto ops_offset = schema::CreateReciprocal(fbb); 483+ auto prim_offset = schema::CreatePrimitive(fbb, static_cast<schema::PrimitiveType>(NODE_TYPE_RECIPROCAL), ops_offset.o); 484+ fbb.Finish(prim_offset); 485+ auto new_addr = MindIRMemoryManager::GetInstance()->CreatePrimitiveFromBuilder(fbb, nullptr); 486+ auto ret_value = flatbuffers::GetMutableRoot<schema::Primitive>(new_addr); 487+ return ret_value; 488+} 489+ 490+// ********** Sin ********** 491+PrimitivePtr MindIR_Sin_CreatePrimitive() { 492+ flatbuffers::FlatBufferBuilder fbb; 493+ auto ops_offset = schema::CreateSin(fbb); 494+ auto prim_offset = schema::CreatePrimitive(fbb, static_cast<schema::PrimitiveType>(NODE_TYPE_SIN), ops_offset.o); 495+ fbb.Finish(prim_offset); 496+ auto new_addr = MindIRMemoryManager::GetInstance()->CreatePrimitiveFromBuilder(fbb, nullptr); 497+ auto ret_value = flatbuffers::GetMutableRoot<schema::Primitive>(new_addr); 498+ return ret_value; 499+} 500+ 501+// ********** Where ********** 502+PrimitivePtr MindIR_Where_CreatePrimitive() { 503+ flatbuffers::FlatBufferBuilder fbb; 504+ auto ops_offset = schema::CreateWhere(fbb); 505+ auto prim_offset = schema::CreatePrimitive(fbb, static_cast<schema::PrimitiveType>(NODE_TYPE_WHERE), ops_offset.o); 506+ fbb.Finish(prim_offset); 507+ auto new_addr = MindIRMemoryManager::GetInstance()->CreatePrimitiveFromBuilder(fbb, nullptr); 508+ auto ret_value = flatbuffers::GetMutableRoot<schema::Primitive>(new_addr); 509+ return ret_value; 510+} 511+ 512+// ********** Log ********** 513+PrimitivePtr MindIR_Log_CreatePrimitive() { 514+ flatbuffers::FlatBufferBuilder fbb; 515+ auto ops_offset = schema::CreateLog(fbb); 516+ auto prim_offset = schema::CreatePrimitive(fbb, static_cast<schema::PrimitiveType>(NODE_TYPE_LOG), ops_offset.o); 517+ fbb.Finish(prim_offset); 518+ auto new_addr = MindIRMemoryManager::GetInstance()->CreatePrimitiveFromBuilder(fbb, nullptr); 519+ auto ret_value = flatbuffers::GetMutableRoot<schema::Primitive>(new_addr); 520+ return ret_value; 521+} 522+ 523+// ********** LogicalOr ********** 524+PrimitivePtr MindIR_LogicalOr_CreatePrimitive() { 525+ flatbuffers::FlatBufferBuilder fbb; 526+ auto ops_offset = schema::CreateLogicalOr(fbb); 527+ auto prim_offset = schema::CreatePrimitive(fbb, static_cast<schema::PrimitiveType>(NODE_TYPE_LOGICAL_OR), ops_offset.o); 528+ fbb.Finish(prim_offset); 529+ auto new_addr = MindIRMemoryManager::GetInstance()->CreatePrimitiveFromBuilder(fbb, nullptr); 530+ auto ret_value = flatbuffers::GetMutableRoot<schema::Primitive>(new_addr); 531+ return ret_value; 532+} 533+ 534+// ********** SparseToDense ********** 535+PrimitivePtr MindIR_SparseToDense_CreatePrimitive() { 536+ flatbuffers::FlatBufferBuilder fbb; 537+ auto ops_offset = schema::CreateSparseToDense(fbb); 538+ auto prim_offset = schema::CreatePrimitive(fbb, static_cast<schema::PrimitiveType>(NODE_TYPE_SPARSE_TO_DENSE), ops_offset.o); 539+ fbb.Finish(prim_offset); 540+ auto new_addr = MindIRMemoryManager::GetInstance()->CreatePrimitiveFromBuilder(fbb, nullptr); 541+ auto ret_value = flatbuffers::GetMutableRoot<schema::Primitive>(new_addr); 542+ return ret_value; 543+} 544+ 545+// ********** Minimum ********** 546+PrimitivePtr MindIR_Minimum_CreatePrimitive() { 547+ flatbuffers::FlatBufferBuilder fbb; 548+ auto ops_offset = schema::CreateMinimum(fbb); 549+ auto prim_offset = schema::CreatePrimitive(fbb, static_cast<schema::PrimitiveType>(NODE_TYPE_MINIMUM), ops_offset.o); 550+ fbb.Finish(prim_offset); 551+ auto new_addr = MindIRMemoryManager::GetInstance()->CreatePrimitiveFromBuilder(fbb, nullptr); 552+ auto ret_value = flatbuffers::GetMutableRoot<schema::Primitive>(new_addr); 553+ return ret_value; 554+} 555+ 556+// ********** SpaceToDepth ********** 557+PrimitivePtr MindIR_SpaceToDepth_CreatePrimitive(int64_t block_size, Format format) { 558+ flatbuffers::FlatBufferBuilder fbb; 559+ auto ops_offset = schema::CreateSpaceToDepth(fbb, block_size, static_cast<schema::Format>(format)); 560+ auto prim_offset = schema::CreatePrimitive(fbb, static_cast<schema::PrimitiveType>(NODE_TYPE_SPACE_TO_DEPTH), ops_offset.o); 561+ fbb.Finish(prim_offset); 562+ auto new_addr = MindIRMemoryManager::GetInstance()->CreatePrimitiveFromBuilder(fbb, nullptr); 563+ auto ret_value = flatbuffers::GetMutableRoot<schema::Primitive>(new_addr); 564+ return ret_value; 565+} 566+ 567+int64_t MindIR_SpaceToDepth_GetBlockSize(ConstPrimitivePtr primitive) { 568+ if (primitive != nullptr) { 569+ auto prim = static_cast<const schema::Primitive *>(primitive); 570+ auto value = prim->value_as_SpaceToDepth(); 571+ if (prim != nullptr && value != nullptr) { 572+ return value->block_size(); 573+ } else { 574+ return 0; 575+ } 576+ } else { 577+ return 0; 578+ } 579+} 580+ 581+void MindIR_SpaceToDepth_SetBlockSize(PrimitivePtr *primitive, int64_t block_size) { 582+ if (primitive != nullptr && *primitive != nullptr) { 583+ auto prim = static_cast<schema::Primitive *>(*primitive); 584+ auto value = prim->value_as_SpaceToDepth(); 585+ if (prim != nullptr && value != nullptr) { 586+ flatbuffers::FlatBufferBuilder fbb; 587+ auto ops_offset = schema::CreateSpaceToDepth(fbb, block_size, static_cast<schema::Format>(value->format())); 588+ auto prim_offset = schema::CreatePrimitive(fbb, static_cast<schema::PrimitiveType>(NODE_TYPE_SPACE_TO_DEPTH), ops_offset.o); 589+ fbb.Finish(prim_offset); 590+ auto new_addr = MindIRMemoryManager::GetInstance()->CreatePrimitiveFromBuilder(fbb, nullptr); 591+ auto ret_value = flatbuffers::GetMutableRoot<schema::Primitive>(new_addr); 592+ free(*primitive); 593+ *primitive = ret_value; 594+ } 595+ } 596+} 597+ 598+Format MindIR_SpaceToDepth_GetFormat(ConstPrimitivePtr primitive) { 599+ if (primitive != nullptr) { 600+ auto prim = static_cast<const schema::Primitive *>(primitive); 601+ auto value = prim->value_as_SpaceToDepth(); 602+ if (prim != nullptr && value != nullptr) { 603+ return static_cast<Format>(value->format()); 604+ } else { 605+ Format en = static_cast<Format>(0); 606+ return en; 607+ } 608+ } else { 609+ Format en = static_cast<Format>(0); 610+ return en; 611+ } 612+} 613+ 614+void MindIR_SpaceToDepth_SetFormat(PrimitivePtr *primitive, Format format) { 615+ if (primitive != nullptr && *primitive != nullptr) { 616+ auto prim = static_cast<schema::Primitive *>(*primitive); 617+ auto value = prim->value_as_SpaceToDepth(); 618+ if (prim != nullptr && value != nullptr) { 619+ flatbuffers::FlatBufferBuilder fbb; 620+ auto ops_offset = schema::CreateSpaceToDepth(fbb, value->block_size(), static_cast<schema::Format>(format)); 621+ auto prim_offset = schema::CreatePrimitive(fbb, static_cast<schema::PrimitiveType>(NODE_TYPE_SPACE_TO_DEPTH), ops_offset.o); 622+ fbb.Finish(prim_offset); 623+ auto new_addr = MindIRMemoryManager::GetInstance()->CreatePrimitiveFromBuilder(fbb, nullptr); 624+ auto ret_value = flatbuffers::GetMutableRoot<schema::Primitive>(new_addr); 625+ free(*primitive); 626+ *primitive = ret_value; 627+ } 628+ } 629+} 630+ 631+// ********** Round ********** 632+PrimitivePtr MindIR_Round_CreatePrimitive() { 633+ flatbuffers::FlatBufferBuilder fbb; 634+ auto ops_offset = schema::CreateRound(fbb); 635+ auto prim_offset = schema::CreatePrimitive(fbb, static_cast<schema::PrimitiveType>(NODE_TYPE_ROUND), ops_offset.o); 636+ fbb.Finish(prim_offset); 637+ auto new_addr = MindIRMemoryManager::GetInstance()->CreatePrimitiveFromBuilder(fbb, nullptr); 638+ auto ret_value = flatbuffers::GetMutableRoot<schema::Primitive>(new_addr); 639+ return ret_value; 640+} 641+ 642+// ********** Ceil ********** 643+PrimitivePtr MindIR_Ceil_CreatePrimitive() { 644+ flatbuffers::FlatBufferBuilder fbb; 645+ auto ops_offset = schema::CreateCeil(fbb); 646+ auto prim_offset = schema::CreatePrimitive(fbb, static_cast<schema::PrimitiveType>(NODE_TYPE_CEIL), ops_offset.o); 647+ fbb.Finish(prim_offset); 648+ auto new_addr = MindIRMemoryManager::GetInstance()->CreatePrimitiveFromBuilder(fbb, nullptr); 649+ auto ret_value = flatbuffers::GetMutableRoot<schema::Primitive>(new_addr); 650+ return ret_value; 651+} 652+ 653+// ********** Floor ********** 654+PrimitivePtr MindIR_Floor_CreatePrimitive() { 655+ flatbuffers::FlatBufferBuilder fbb; 656+ auto ops_offset = schema::CreateFloor(fbb); 657+ auto prim_offset = schema::CreatePrimitive(fbb, static_cast<schema::PrimitiveType>(NODE_TYPE_FLOOR), ops_offset.o); 658+ fbb.Finish(prim_offset); 659+ auto new_addr = MindIRMemoryManager::GetInstance()->CreatePrimitiveFromBuilder(fbb, nullptr); 660+ auto ret_value = flatbuffers::GetMutableRoot<schema::Primitive>(new_addr); 661+ return ret_value; 662+} 663+ 664+// ********** L2NormalizeFusion ********** 665+PrimitivePtr MindIR_L2NormalizeFusion_CreatePrimitive(const std::vector<int64_t> &axis, float epsilon, ActivationType activation_type) { 666+ flatbuffers::FlatBufferBuilder fbb; 667+ auto ops_offset = schema::CreateL2NormalizeFusion(fbb, fbb.CreateVector(axis.data(), axis.size()), epsilon, static_cast<schema::ActivationType>(activation_type)); 668+ auto prim_offset = schema::CreatePrimitive(fbb, static_cast<schema::PrimitiveType>(NODE_TYPE_L2_NORMALIZE_FUSION), ops_offset.o); 669+ fbb.Finish(prim_offset); 670+ auto new_addr = MindIRMemoryManager::GetInstance()->CreatePrimitiveFromBuilder(fbb, nullptr); 671+ auto ret_value = flatbuffers::GetMutableRoot<schema::Primitive>(new_addr); 672+ return ret_value; 673+} 674+ 675+std::vector<int64_t> MindIR_L2NormalizeFusion_GetAxis(ConstPrimitivePtr primitive) { 676+ if (primitive != nullptr) { 677+ auto prim = static_cast<const schema::Primitive *>(primitive); 678+ auto value = prim->value_as_L2NormalizeFusion(); 679+ if (prim != nullptr && value != nullptr) { 680+ std::vector<int64_t> result; 681+ auto src = value->axis(); 682+ result.resize(src->size()); 683+ std::transform(src->begin(), src->end(), result.begin(), [](int64_t item) { return item; }); 684+ return result; 685+ } else { 686+ return {}; 687+ } 688+ } else { 689+ return {}; 690+ } 691+} 692+ 693+void MindIR_L2NormalizeFusion_SetAxis(PrimitivePtr *primitive, const std::vector<int64_t> &axis) { 694+ if (primitive != nullptr && *primitive != nullptr) { 695+ auto prim = static_cast<schema::Primitive *>(*primitive); 696+ auto value = prim->value_as_L2NormalizeFusion(); 697+ if (prim != nullptr && value != nullptr) { 698+ flatbuffers::FlatBufferBuilder fbb; 699+ auto ops_offset = schema::CreateL2NormalizeFusion(fbb, fbb.CreateVector(axis.data(), axis.size()), value->epsilon(), static_cast<schema::ActivationType>(value->activation_type())); 700+ auto prim_offset = schema::CreatePrimitive(fbb, static_cast<schema::PrimitiveType>(NODE_TYPE_L2_NORMALIZE_FUSION), ops_offset.o); 701+ fbb.Finish(prim_offset); 702+ auto new_addr = MindIRMemoryManager::GetInstance()->CreatePrimitiveFromBuilder(fbb, nullptr); 703+ auto ret_value = flatbuffers::GetMutableRoot<schema::Primitive>(new_addr); 704+ free(*primitive); 705+ *primitive = ret_value; 706+ } 707+ } 708+} 709+ 710+float MindIR_L2NormalizeFusion_GetEpsilon(ConstPrimitivePtr primitive) { 711+ if (primitive != nullptr) { 712+ auto prim = static_cast<const schema::Primitive *>(primitive); 713+ auto value = prim->value_as_L2NormalizeFusion(); 714+ if (prim != nullptr && value != nullptr) { 715+ return value->epsilon(); 716+ } else { 717+ return .0; 718+ } 719+ } else { 720+ return .0; 721+ } 722+} 723+ 724+void MindIR_L2NormalizeFusion_SetEpsilon(PrimitivePtr *primitive, float epsilon) { 725+ if (primitive != nullptr && *primitive != nullptr) { 726+ auto prim = static_cast<schema::Primitive *>(*primitive); 727+ auto value = prim->value_as_L2NormalizeFusion(); 728+ if (prim != nullptr && value != nullptr) { 729+ flatbuffers::FlatBufferBuilder fbb; 730+ auto ops_offset = schema::CreateL2NormalizeFusion(fbb, fbb.CreateVector(value->axis()->data(), value->axis()->size()), epsilon, static_cast<schema::ActivationType>(value->activation_type())); 731+ auto prim_offset = schema::CreatePrimitive(fbb, static_cast<schema::PrimitiveType>(NODE_TYPE_L2_NORMALIZE_FUSION), ops_offset.o); 732+ fbb.Finish(prim_offset); 733+ auto new_addr = MindIRMemoryManager::GetInstance()->CreatePrimitiveFromBuilder(fbb, nullptr); 734+ auto ret_value = flatbuffers::GetMutableRoot<schema::Primitive>(new_addr); 735+ free(*primitive); 736+ *primitive = ret_value; 737+ } 738+ } 739+} 740+ 741+ActivationType MindIR_L2NormalizeFusion_GetActivationType(ConstPrimitivePtr primitive) { 742+ if (primitive != nullptr) { 743+ auto prim = static_cast<const schema::Primitive *>(primitive); 744+ auto value = prim->value_as_L2NormalizeFusion(); 745+ if (prim != nullptr && value != nullptr) { 746+ return static_cast<ActivationType>(value->activation_type()); 747+ } else { 748+ ActivationType en = static_cast<ActivationType>(0); 749+ return en; 750+ } 751+ } else { 752+ ActivationType en = static_cast<ActivationType>(0); 753+ return en; 754+ } 755+} 756+ 757+void MindIR_L2NormalizeFusion_SetActivationType(PrimitivePtr *primitive, ActivationType activation_type) { 758+ if (primitive != nullptr && *primitive != nullptr) { 759+ auto prim = static_cast<schema::Primitive *>(*primitive); 760+ auto value = prim->value_as_L2NormalizeFusion(); 761+ if (prim != nullptr && value != nullptr) { 762+ flatbuffers::FlatBufferBuilder fbb; 763+ auto ops_offset = schema::CreateL2NormalizeFusion(fbb, fbb.CreateVector(value->axis()->data(), value->axis()->size()), value->epsilon(), static_cast<schema::ActivationType>(activation_type)); 764+ auto prim_offset = schema::CreatePrimitive(fbb, static_cast<schema::PrimitiveType>(NODE_TYPE_L2_NORMALIZE_FUSION), ops_offset.o); 765+ fbb.Finish(prim_offset); 766+ auto new_addr = MindIRMemoryManager::GetInstance()->CreatePrimitiveFromBuilder(fbb, nullptr); 767+ auto ret_value = flatbuffers::GetMutableRoot<schema::Primitive>(new_addr); 768+ free(*primitive); 769+ *primitive = ret_value; 770+ } 771+ } 772+} 773+ 774+// ********** LRN ********** 775+PrimitivePtr MindIR_LRN_CreatePrimitive(int64_t depth_radius, float bias, float alpha, float beta, std::string norm_region) { 776+ flatbuffers::FlatBufferBuilder fbb; 777+ auto ops_offset = schema::CreateLRN(fbb, depth_radius, bias, alpha, beta, fbb.CreateString(norm_region)); 778+ auto prim_offset = schema::CreatePrimitive(fbb, static_cast<schema::PrimitiveType>(NODE_TYPE_L_R_N), ops_offset.o); 779+ fbb.Finish(prim_offset); 780+ auto new_addr = MindIRMemoryManager::GetInstance()->CreatePrimitiveFromBuilder(fbb, nullptr); 781+ auto ret_value = flatbuffers::GetMutableRoot<schema::Primitive>(new_addr); 782+ return ret_value; 783+} 784+ 785+int64_t MindIR_LRN_GetDepthRadius(ConstPrimitivePtr primitive) { 786+ if (primitive != nullptr) { 787+ auto prim = static_cast<const schema::Primitive *>(primitive); 788+ auto value = prim->value_as_LRN(); 789+ if (prim != nullptr && value != nullptr) { 790+ return value->depth_radius(); 791+ } else { 792+ return 0; 793+ } 794+ } else { 795+ return 0; 796+ } 797+} 798+ 799+void MindIR_LRN_SetDepthRadius(PrimitivePtr *primitive, int64_t depth_radius) { 800+ if (primitive != nullptr && *primitive != nullptr) { 801+ auto prim = static_cast<schema::Primitive *>(*primitive); 802+ auto value = prim->value_as_LRN(); 803+ if (prim != nullptr && value != nullptr) { 804+ flatbuffers::FlatBufferBuilder fbb; 805+ auto ops_offset = schema::CreateLRN(fbb, depth_radius, value->bias(), value->alpha(), value->beta(), fbb.CreateString(std::string(value->norm_region()->c_str(), value->norm_region()->size()))); 806+ auto prim_offset = schema::CreatePrimitive(fbb, static_cast<schema::PrimitiveType>(NODE_TYPE_L_R_N), ops_offset.o); 807+ fbb.Finish(prim_offset); 808+ auto new_addr = MindIRMemoryManager::GetInstance()->CreatePrimitiveFromBuilder(fbb, nullptr); 809+ auto ret_value = flatbuffers::GetMutableRoot<schema::Primitive>(new_addr); 810+ free(*primitive); 811+ *primitive = ret_value; 812+ } 813+ } 814+} 815+ 816+float MindIR_LRN_GetBias(ConstPrimitivePtr primitive) { 817+ if (primitive != nullptr) { 818+ auto prim = static_cast<const schema::Primitive *>(primitive); 819+ auto value = prim->value_as_LRN(); 820+ if (prim != nullptr && value != nullptr) { 821+ return value->bias(); 822+ } else { 823+ return .0; 824+ } 825+ } else { 826+ return .0; 827+ } 828+} 829+ 830+void MindIR_LRN_SetBias(PrimitivePtr *primitive, float bias) { 831+ if (primitive != nullptr && *primitive != nullptr) { 832+ auto prim = static_cast<schema::Primitive *>(*primitive); 833+ auto value = prim->value_as_LRN(); 834+ if (prim != nullptr && value != nullptr) { 835+ flatbuffers::FlatBufferBuilder fbb; 836+ auto ops_offset = schema::CreateLRN(fbb, value->depth_radius(), bias, value->alpha(), value->beta(), fbb.CreateString(std::string(value->norm_region()->c_str(), value->norm_region()->size()))); 837+ auto prim_offset = schema::CreatePrimitive(fbb, static_cast<schema::PrimitiveType>(NODE_TYPE_L_R_N), ops_offset.o); 838+ fbb.Finish(prim_offset); 839+ auto new_addr = MindIRMemoryManager::GetInstance()->CreatePrimitiveFromBuilder(fbb, nullptr); 840+ auto ret_value = flatbuffers::GetMutableRoot<schema::Primitive>(new_addr); 841+ free(*primitive); 842+ *primitive = ret_value; 843+ } 844+ } 845+} 846+ 847+float MindIR_LRN_GetAlpha(ConstPrimitivePtr primitive) { 848+ if (primitive != nullptr) { 849+ auto prim = static_cast<const schema::Primitive *>(primitive); 850+ auto value = prim->value_as_LRN(); 851+ if (prim != nullptr && value != nullptr) { 852+ return value->alpha(); 853+ } else { 854+ return .0; 855+ } 856+ } else { 857+ return .0; 858+ } 859+} 860+ 861+void MindIR_LRN_SetAlpha(PrimitivePtr *primitive, float alpha) { 862+ if (primitive != nullptr && *primitive != nullptr) { 863+ auto prim = static_cast<schema::Primitive *>(*primitive); 864+ auto value = prim->value_as_LRN(); 865+ if (prim != nullptr && value != nullptr) { 866+ flatbuffers::FlatBufferBuilder fbb; 867+ auto ops_offset = schema::CreateLRN(fbb, value->depth_radius(), value->bias(), alpha, value->beta(), fbb.CreateString(std::string(value->norm_region()->c_str(), value->norm_region()->size()))); 868+ auto prim_offset = schema::CreatePrimitive(fbb, static_cast<schema::PrimitiveType>(NODE_TYPE_L_R_N), ops_offset.o); 869+ fbb.Finish(prim_offset); 870+ auto new_addr = MindIRMemoryManager::GetInstance()->CreatePrimitiveFromBuilder(fbb, nullptr); 871+ auto ret_value = flatbuffers::GetMutableRoot<schema::Primitive>(new_addr); 872+ free(*primitive); 873+ *primitive = ret_value; 874+ } 875+ } 876+} 877+ 878+float MindIR_LRN_GetBeta(ConstPrimitivePtr primitive) { 879+ if (primitive != nullptr) { 880+ auto prim = static_cast<const schema::Primitive *>(primitive); 881+ auto value = prim->value_as_LRN(); 882+ if (prim != nullptr && value != nullptr) { 883+ return value->beta(); 884+ } else { 885+ return .0; 886+ } 887+ } else { 888+ return .0; 889+ } 890+} 891+ 892+void MindIR_LRN_SetBeta(PrimitivePtr *primitive, float beta) { 893+ if (primitive != nullptr && *primitive != nullptr) { 894+ auto prim = static_cast<schema::Primitive *>(*primitive); 895+ auto value = prim->value_as_LRN(); 896+ if (prim != nullptr && value != nullptr) { 897+ flatbuffers::FlatBufferBuilder fbb; 898+ auto ops_offset = schema::CreateLRN(fbb, value->depth_radius(), value->bias(), value->alpha(), beta, fbb.CreateString(std::string(value->norm_region()->c_str(), value->norm_region()->size()))); 899+ auto prim_offset = schema::CreatePrimitive(fbb, static_cast<schema::PrimitiveType>(NODE_TYPE_L_R_N), ops_offset.o); 900+ fbb.Finish(prim_offset); 901+ auto new_addr = MindIRMemoryManager::GetInstance()->CreatePrimitiveFromBuilder(fbb, nullptr); 902+ auto ret_value = flatbuffers::GetMutableRoot<schema::Primitive>(new_addr); 903+ free(*primitive); 904+ *primitive = ret_value; 905+ } 906+ } 907+} 908+ 909+std::string MindIR_LRN_GetNormRegion(ConstPrimitivePtr primitive) { 910+ if (primitive != nullptr) { 911+ auto prim = static_cast<const schema::Primitive *>(primitive); 912+ auto value = prim->value_as_LRN(); 913+ if (prim != nullptr && value != nullptr) { 914+ return std::string(value->norm_region()->c_str(),value->norm_region()->size()); 915+ } else { 916+ return nullptr; 917+ } 918+ } else { 919+ return nullptr; 920+ } 921+} 922+ 923+void MindIR_LRN_SetNormRegion(PrimitivePtr *primitive, std::string norm_region) { 924+ if (primitive != nullptr && *primitive != nullptr) { 925+ auto prim = static_cast<schema::Primitive *>(*primitive); 926+ auto value = prim->value_as_LRN(); 927+ if (prim != nullptr && value != nullptr) { 928+ flatbuffers::FlatBufferBuilder fbb; 929+ auto ops_offset = schema::CreateLRN(fbb, value->depth_radius(), value->bias(), value->alpha(), value->beta(), fbb.CreateString(norm_region)); 930+ auto prim_offset = schema::CreatePrimitive(fbb, static_cast<schema::PrimitiveType>(NODE_TYPE_L_R_N), ops_offset.o); 931+ fbb.Finish(prim_offset); 932+ auto new_addr = MindIRMemoryManager::GetInstance()->CreatePrimitiveFromBuilder(fbb, nullptr); 933+ auto ret_value = flatbuffers::GetMutableRoot<schema::Primitive>(new_addr); 934+ free(*primitive); 935+ *primitive = ret_value; 936+ } 937+ } 938+} 939+ 940+// ********** LogSoftmax ********** 941+PrimitivePtr MindIR_LogSoftmax_CreatePrimitive(int64_t axis) { 942+ flatbuffers::FlatBufferBuilder fbb; 943+ auto ops_offset = schema::CreateLogSoftmax(fbb, axis); 944+ auto prim_offset = schema::CreatePrimitive(fbb, static_cast<schema::PrimitiveType>(NODE_TYPE_LOG_SOFTMAX), ops_offset.o); 945+ fbb.Finish(prim_offset); 946+ auto new_addr = MindIRMemoryManager::GetInstance()->CreatePrimitiveFromBuilder(fbb, nullptr); 947+ auto ret_value = flatbuffers::GetMutableRoot<schema::Primitive>(new_addr); 948+ return ret_value; 949+} 950+ 951+int64_t MindIR_LogSoftmax_GetAxis(ConstPrimitivePtr primitive) { 952+ if (primitive != nullptr) { 953+ auto prim = static_cast<const schema::Primitive *>(primitive); 954+ auto value = prim->value_as_LogSoftmax(); 955+ if (prim != nullptr && value != nullptr) { 956+ return value->axis(); 957+ } else { 958+ return 0; 959+ } 960+ } else { 961+ return 0; 962+ } 963+} 964+ 965+void MindIR_LogSoftmax_SetAxis(PrimitivePtr *primitive, int64_t axis) { 966+ if (primitive != nullptr && *primitive != nullptr) { 967+ auto prim = static_cast<schema::Primitive *>(*primitive); 968+ auto value = prim->value_as_LogSoftmax(); 969+ if (prim != nullptr && value != nullptr) { 970+ flatbuffers::FlatBufferBuilder fbb; 971+ auto ops_offset = schema::CreateLogSoftmax(fbb, axis); 972+ auto prim_offset = schema::CreatePrimitive(fbb, static_cast<schema::PrimitiveType>(NODE_TYPE_LOG_SOFTMAX), ops_offset.o); 973+ fbb.Finish(prim_offset); 974+ auto new_addr = MindIRMemoryManager::GetInstance()->CreatePrimitiveFromBuilder(fbb, nullptr); 975+ auto ret_value = flatbuffers::GetMutableRoot<schema::Primitive>(new_addr); 976+ free(*primitive); 977+ *primitive = ret_value; 978+ } 979+ } 980+} 981+ 982+// ********** Crop ********** 983+PrimitivePtr MindIR_Crop_CreatePrimitive(int64_t axis, const std::vector<int64_t> &offsets) { 984+ flatbuffers::FlatBufferBuilder fbb; 985+ auto ops_offset = schema::CreateCrop(fbb, axis, fbb.CreateVector(offsets.data(), offsets.size())); 986+ auto prim_offset = schema::CreatePrimitive(fbb, static_cast<schema::PrimitiveType>(NODE_TYPE_CROP), ops_offset.o); 987+ fbb.Finish(prim_offset); 988+ auto new_addr = MindIRMemoryManager::GetInstance()->CreatePrimitiveFromBuilder(fbb, nullptr); 989+ auto ret_value = flatbuffers::GetMutableRoot<schema::Primitive>(new_addr); 990+ return ret_value; 991+} 992+ 993+int64_t MindIR_Crop_GetAxis(ConstPrimitivePtr primitive) { 994+ if (primitive != nullptr) { 995+ auto prim = static_cast<const schema::Primitive *>(primitive); 996+ auto value = prim->value_as_Crop(); 997+ if (prim != nullptr && value != nullptr) { 998+ return value->axis(); 999+ } else { 1000+ return 0; 1001+ } 1002+ } else { 1003+ return 0; 1004+ } 1005+} 1006+ 1007+void MindIR_Crop_SetAxis(PrimitivePtr *primitive, int64_t axis) { 1008+ if (primitive != nullptr && *primitive != nullptr) { 1009+ auto prim = static_cast<schema::Primitive *>(*primitive); 1010+ auto value = prim->value_as_Crop(); 1011+ if (prim != nullptr && value != nullptr) { 1012+ flatbuffers::FlatBufferBuilder fbb; 1013+ auto ops_offset = schema::CreateCrop(fbb, axis, fbb.CreateVector(value->offsets()->data(), value->offsets()->size())); 1014+ auto prim_offset = schema::CreatePrimitive(fbb, static_cast<schema::PrimitiveType>(NODE_TYPE_CROP), ops_offset.o); 1015+ fbb.Finish(prim_offset); 1016+ auto new_addr = MindIRMemoryManager::GetInstance()->CreatePrimitiveFromBuilder(fbb, nullptr); 1017+ auto ret_value = flatbuffers::GetMutableRoot<schema::Primitive>(new_addr); 1018+ free(*primitive); 1019+ *primitive = ret_value; 1020+ } 1021+ } 1022+} 1023+ 1024+std::vector<int64_t> MindIR_Crop_GetOffsets(ConstPrimitivePtr primitive) { 1025+ if (primitive != nullptr) { 1026+ auto prim = static_cast<const schema::Primitive *>(primitive); 1027+ auto value = prim->value_as_Crop(); 1028+ if (prim != nullptr && value != nullptr) { 1029+ std::vector<int64_t> result; 1030+ auto src = value->offsets(); 1031+ result.resize(src->size()); 1032+ std::transform(src->begin(), src->end(), result.begin(), [](int64_t item) { return item; }); 1033+ return result; 1034+ } else { 1035+ return {}; 1036+ } 1037+ } else { 1038+ return {}; 1039+ } 1040+} 1041+ 1042+void MindIR_Crop_SetOffsets(PrimitivePtr *primitive, const std::vector<int64_t> &offsets) { 1043+ if (primitive != nullptr && *primitive != nullptr) { 1044+ auto prim = static_cast<schema::Primitive *>(*primitive); 1045+ auto value = prim->value_as_Crop(); 1046+ if (prim != nullptr && value != nullptr) { 1047+ flatbuffers::FlatBufferBuilder fbb; 1048+ auto ops_offset = schema::CreateCrop(fbb, value->axis(), fbb.CreateVector(offsets.data(), offsets.size())); 1049+ auto prim_offset = schema::CreatePrimitive(fbb, static_cast<schema::PrimitiveType>(NODE_TYPE_CROP), ops_offset.o); 1050+ fbb.Finish(prim_offset); 1051+ auto new_addr = MindIRMemoryManager::GetInstance()->CreatePrimitiveFromBuilder(fbb, nullptr); 1052+ auto ret_value = flatbuffers::GetMutableRoot<schema::Primitive>(new_addr); 1053+ free(*primitive); 1054+ *primitive = ret_value; 1055+ } 1056+ } 1057+} 1058+ 1059+// ********** DetectionPostProcess ********** 1060+PrimitivePtr MindIR_DetectionPostProcess_CreatePrimitive(Format format, int64_t input_size, const std::vector<float> &scale, float nms_iou_threshold, float nms_score_threshold, int64_t max_detections, int64_t detections_per_class, int64_t max_classes_per_detection, int64_t num_classes, bool use_regular_nms, bool out_quantized) { 1061+ flatbuffers::FlatBufferBuilder fbb; 1062+ auto ops_offset = schema::CreateDetectionPostProcess(fbb, static_cast<schema::Format>(format), input_size, fbb.CreateVector(scale.data(), scale.size()), nms_iou_threshold, nms_score_threshold, max_detections, detections_per_class, max_classes_per_detection, num_classes, use_regular_nms, out_quantized); 1063+ auto prim_offset = schema::CreatePrimitive(fbb, static_cast<schema::PrimitiveType>(NODE_TYPE_DETECTION_POST_PROCESS), ops_offset.o); 1064+ fbb.Finish(prim_offset); 1065+ auto new_addr = MindIRMemoryManager::GetInstance()->CreatePrimitiveFromBuilder(fbb, nullptr); 1066+ auto ret_value = flatbuffers::GetMutableRoot<schema::Primitive>(new_addr); 1067+ return ret_value; 1068+} 1069+ 1070+Format MindIR_DetectionPostProcess_GetFormat(ConstPrimitivePtr primitive) { 1071+ if (primitive != nullptr) { 1072+ auto prim = static_cast<const schema::Primitive *>(primitive); 1073+ auto value = prim->value_as_DetectionPostProcess(); 1074+ if (prim != nullptr && value != nullptr) { 1075+ return static_cast<Format>(value->format()); 1076+ } else { 1077+ Format en = static_cast<Format>(0); 1078+ return en; 1079+ } 1080+ } else { 1081+ Format en = static_cast<Format>(0); 1082+ return en; 1083+ } 1084+} 1085+ 1086+void MindIR_DetectionPostProcess_SetFormat(PrimitivePtr *primitive, Format format) { 1087+ if (primitive != nullptr && *primitive != nullptr) { 1088+ auto prim = static_cast<schema::Primitive *>(*primitive); 1089+ auto value = prim->value_as_DetectionPostProcess(); 1090+ if (prim != nullptr && value != nullptr) { 1091+ flatbuffers::FlatBufferBuilder fbb; 1092+ auto ops_offset = schema::CreateDetectionPostProcess(fbb, static_cast<schema::Format>(format), value->input_size(), fbb.CreateVector(value->scale()->data(), value->scale()->size()), value->nms_iou_threshold(), value->nms_score_threshold(), value->max_detections(), value->detections_per_class(), value->max_classes_per_detection(), value->num_classes(), value->use_regular_nms(), value->out_quantized()); 1093+ auto prim_offset = schema::CreatePrimitive(fbb, static_cast<schema::PrimitiveType>(NODE_TYPE_DETECTION_POST_PROCESS), ops_offset.o); 1094+ fbb.Finish(prim_offset); 1095+ auto new_addr = MindIRMemoryManager::GetInstance()->CreatePrimitiveFromBuilder(fbb, nullptr); 1096+ auto ret_value = flatbuffers::GetMutableRoot<schema::Primitive>(new_addr); 1097+ free(*primitive); 1098+ *primitive = ret_value; 1099+ } 1100+ } 1101+} 1102+ 1103+int64_t MindIR_DetectionPostProcess_GetInputSize(ConstPrimitivePtr primitive) { 1104+ if (primitive != nullptr) { 1105+ auto prim = static_cast<const schema::Primitive *>(primitive); 1106+ auto value = prim->value_as_DetectionPostProcess(); 1107+ if (prim != nullptr && value != nullptr) { 1108+ return value->input_size(); 1109+ } else { 1110+ return 0; 1111+ } 1112+ } else { 1113+ return 0; 1114+ } 1115+} 1116+ 1117+void MindIR_DetectionPostProcess_SetInputSize(PrimitivePtr *primitive, int64_t input_size) { 1118+ if (primitive != nullptr && *primitive != nullptr) { 1119+ auto prim = static_cast<schema::Primitive *>(*primitive); 1120+ auto value = prim->value_as_DetectionPostProcess(); 1121+ if (prim != nullptr && value != nullptr) { 1122+ flatbuffers::FlatBufferBuilder fbb; 1123+ auto ops_offset = schema::CreateDetectionPostProcess(fbb, static_cast<schema::Format>(value->format()), input_size, fbb.CreateVector(value->scale()->data(), value->scale()->size()), value->nms_iou_threshold(), value->nms_score_threshold(), value->max_detections(), value->detections_per_class(), value->max_classes_per_detection(), value->num_classes(), value->use_regular_nms(), value->out_quantized()); 1124+ auto prim_offset = schema::CreatePrimitive(fbb, static_cast<schema::PrimitiveType>(NODE_TYPE_DETECTION_POST_PROCESS), ops_offset.o); 1125+ fbb.Finish(prim_offset); 1126+ auto new_addr = MindIRMemoryManager::GetInstance()->CreatePrimitiveFromBuilder(fbb, nullptr); 1127+ auto ret_value = flatbuffers::GetMutableRoot<schema::Primitive>(new_addr); 1128+ free(*primitive); 1129+ *primitive = ret_value; 1130+ } 1131+ } 1132+} 1133+ 1134+std::vector<float> MindIR_DetectionPostProcess_GetScale(ConstPrimitivePtr primitive) { 1135+ if (primitive != nullptr) { 1136+ auto prim = static_cast<const schema::Primitive *>(primitive); 1137+ auto value = prim->value_as_DetectionPostProcess(); 1138+ if (prim != nullptr && value != nullptr) { 1139+ std::vector<float> result; 1140+ auto src = value->scale(); 1141+ result.resize(src->size()); 1142+ std::transform(src->begin(), src->end(), result.begin(), [](float item) { return item; }); 1143+ return result; 1144+ } else { 1145+ return {}; 1146+ } 1147+ } else { 1148+ return {}; 1149+ } 1150+} 1151+ 1152+void MindIR_DetectionPostProcess_SetScale(PrimitivePtr *primitive, const std::vector<float> &scale) { 1153+ if (primitive != nullptr && *primitive != nullptr) { 1154+ auto prim = static_cast<schema::Primitive *>(*primitive); 1155+ auto value = prim->value_as_DetectionPostProcess(); 1156+ if (prim != nullptr && value != nullptr) { 1157+ flatbuffers::FlatBufferBuilder fbb; 1158+ auto ops_offset = schema::CreateDetectionPostProcess(fbb, static_cast<schema::Format>(value->format()), value->input_size(), fbb.CreateVector(scale.data(), scale.size()), value->nms_iou_threshold(), value->nms_score_threshold(), value->max_detections(), value->detections_per_class(), value->max_classes_per_detection(), value->num_classes(), value->use_regular_nms(), value->out_quantized()); 1159+ auto prim_offset = schema::CreatePrimitive(fbb, static_cast<schema::PrimitiveType>(NODE_TYPE_DETECTION_POST_PROCESS), ops_offset.o); 1160+ fbb.Finish(prim_offset); 1161+ auto new_addr = MindIRMemoryManager::GetInstance()->CreatePrimitiveFromBuilder(fbb, nullptr); 1162+ auto ret_value = flatbuffers::GetMutableRoot<schema::Primitive>(new_addr); 1163+ free(*primitive); 1164+ *primitive = ret_value; 1165+ } 1166+ } 1167+} 1168+ 1169+float MindIR_DetectionPostProcess_GetNmsIouThreshold(ConstPrimitivePtr primitive) { 1170+ if (primitive != nullptr) { 1171+ auto prim = static_cast<const schema::Primitive *>(primitive); 1172+ auto value = prim->value_as_DetectionPostProcess(); 1173+ if (prim != nullptr && value != nullptr) { 1174+ return value->nms_iou_threshold(); 1175+ } else { 1176+ return .0; 1177+ } 1178+ } else { 1179+ return .0; 1180+ } 1181+} 1182+ 1183+void MindIR_DetectionPostProcess_SetNmsIouThreshold(PrimitivePtr *primitive, float nms_iou_threshold) { 1184+ if (primitive != nullptr && *primitive != nullptr) { 1185+ auto prim = static_cast<schema::Primitive *>(*primitive); 1186+ auto value = prim->value_as_DetectionPostProcess(); 1187+ if (prim != nullptr && value != nullptr) { 1188+ flatbuffers::FlatBufferBuilder fbb; 1189+ auto ops_offset = schema::CreateDetectionPostProcess(fbb, static_cast<schema::Format>(value->format()), value->input_size(), fbb.CreateVector(value->scale()->data(), value->scale()->size()), nms_iou_threshold, value->nms_score_threshold(), value->max_detections(), value->detections_per_class(), value->max_classes_per_detection(), value->num_classes(), value->use_regular_nms(), value->out_quantized()); 1190+ auto prim_offset = schema::CreatePrimitive(fbb, static_cast<schema::PrimitiveType>(NODE_TYPE_DETECTION_POST_PROCESS), ops_offset.o); 1191+ fbb.Finish(prim_offset); 1192+ auto new_addr = MindIRMemoryManager::GetInstance()->CreatePrimitiveFromBuilder(fbb, nullptr); 1193+ auto ret_value = flatbuffers::GetMutableRoot<schema::Primitive>(new_addr); 1194+ free(*primitive); 1195+ *primitive = ret_value; 1196+ } 1197+ } 1198+} 1199+ 1200+float MindIR_DetectionPostProcess_GetNmsScoreThreshold(ConstPrimitivePtr primitive) { 1201+ if (primitive != nullptr) { 1202+ auto prim = static_cast<const schema::Primitive *>(primitive); 1203+ auto value = prim->value_as_DetectionPostProcess(); 1204+ if (prim != nullptr && value != nullptr) { 1205+ return value->nms_score_threshold(); 1206+ } else { 1207+ return .0; 1208+ } 1209+ } else { 1210+ return .0; 1211+ } 1212+} 1213+ 1214+void MindIR_DetectionPostProcess_SetNmsScoreThreshold(PrimitivePtr *primitive, float nms_score_threshold) { 1215+ if (primitive != nullptr && *primitive != nullptr) { 1216+ auto prim = static_cast<schema::Primitive *>(*primitive); 1217+ auto value = prim->value_as_DetectionPostProcess(); 1218+ if (prim != nullptr && value != nullptr) { 1219+ flatbuffers::FlatBufferBuilder fbb; 1220+ auto ops_offset = schema::CreateDetectionPostProcess(fbb, static_cast<schema::Format>(value->format()), value->input_size(), fbb.CreateVector(value->scale()->data(), value->scale()->size()), value->nms_iou_threshold(), nms_score_threshold, value->max_detections(), value->detections_per_class(), value->max_classes_per_detection(), value->num_classes(), value->use_regular_nms(), value->out_quantized()); 1221+ auto prim_offset = schema::CreatePrimitive(fbb, static_cast<schema::PrimitiveType>(NODE_TYPE_DETECTION_POST_PROCESS), ops_offset.o); 1222+ fbb.Finish(prim_offset); 1223+ auto new_addr = MindIRMemoryManager::GetInstance()->CreatePrimitiveFromBuilder(fbb, nullptr); 1224+ auto ret_value = flatbuffers::GetMutableRoot<schema::Primitive>(new_addr); 1225+ free(*primitive); 1226+ *primitive = ret_value; 1227+ } 1228+ } 1229+} 1230+ 1231+int64_t MindIR_DetectionPostProcess_GetMaxDetections(ConstPrimitivePtr primitive) { 1232+ if (primitive != nullptr) { 1233+ auto prim = static_cast<const schema::Primitive *>(primitive); 1234+ auto value = prim->value_as_DetectionPostProcess(); 1235+ if (prim != nullptr && value != nullptr) { 1236+ return value->max_detections(); 1237+ } else { 1238+ return 0; 1239+ } 1240+ } else { 1241+ return 0; 1242+ } 1243+} 1244+ 1245+void MindIR_DetectionPostProcess_SetMaxDetections(PrimitivePtr *primitive, int64_t max_detections) { 1246+ if (primitive != nullptr && *primitive != nullptr) { 1247+ auto prim = static_cast<schema::Primitive *>(*primitive); 1248+ auto value = prim->value_as_DetectionPostProcess(); 1249+ if (prim != nullptr && value != nullptr) { 1250+ flatbuffers::FlatBufferBuilder fbb; 1251+ auto ops_offset = schema::CreateDetectionPostProcess(fbb, static_cast<schema::Format>(value->format()), value->input_size(), fbb.CreateVector(value->scale()->data(), value->scale()->size()), value->nms_iou_threshold(), value->nms_score_threshold(), max_detections, value->detections_per_class(), value->max_classes_per_detection(), value->num_classes(), value->use_regular_nms(), value->out_quantized()); 1252+ auto prim_offset = schema::CreatePrimitive(fbb, static_cast<schema::PrimitiveType>(NODE_TYPE_DETECTION_POST_PROCESS), ops_offset.o); 1253+ fbb.Finish(prim_offset); 1254+ auto new_addr = MindIRMemoryManager::GetInstance()->CreatePrimitiveFromBuilder(fbb, nullptr); 1255+ auto ret_value = flatbuffers::GetMutableRoot<schema::Primitive>(new_addr); 1256+ free(*primitive); 1257+ *primitive = ret_value; 1258+ } 1259+ } 1260+} 1261+ 1262+int64_t MindIR_DetectionPostProcess_GetDetectionsPerClass(ConstPrimitivePtr primitive) { 1263+ if (primitive != nullptr) { 1264+ auto prim = static_cast<const schema::Primitive *>(primitive); 1265+ auto value = prim->value_as_DetectionPostProcess(); 1266+ if (prim != nullptr && value != nullptr) { 1267+ return value->detections_per_class(); 1268+ } else { 1269+ return 0; 1270+ } 1271+ } else { 1272+ return 0; 1273+ } 1274+} 1275+ 1276+void MindIR_DetectionPostProcess_SetDetectionsPerClass(PrimitivePtr *primitive, int64_t detections_per_class) { 1277+ if (primitive != nullptr && *primitive != nullptr) { 1278+ auto prim = static_cast<schema::Primitive *>(*primitive); 1279+ auto value = prim->value_as_DetectionPostProcess(); 1280+ if (prim != nullptr && value != nullptr) { 1281+ flatbuffers::FlatBufferBuilder fbb; 1282+ auto ops_offset = schema::CreateDetectionPostProcess(fbb, static_cast<schema::Format>(value->format()), value->input_size(), fbb.CreateVector(value->scale()->data(), value->scale()->size()), value->nms_iou_threshold(), value->nms_score_threshold(), value->max_detections(), detections_per_class, value->max_classes_per_detection(), value->num_classes(), value->use_regular_nms(), value->out_quantized()); 1283+ auto prim_offset = schema::CreatePrimitive(fbb, static_cast<schema::PrimitiveType>(NODE_TYPE_DETECTION_POST_PROCESS), ops_offset.o); 1284+ fbb.Finish(prim_offset); 1285+ auto new_addr = MindIRMemoryManager::GetInstance()->CreatePrimitiveFromBuilder(fbb, nullptr); 1286+ auto ret_value = flatbuffers::GetMutableRoot<schema::Primitive>(new_addr); 1287+ free(*primitive); 1288+ *primitive = ret_value; 1289+ } 1290+ } 1291+} 1292+ 1293+int64_t MindIR_DetectionPostProcess_GetMaxClassesPerDetection(ConstPrimitivePtr primitive) { 1294+ if (primitive != nullptr) { 1295+ auto prim = static_cast<const schema::Primitive *>(primitive); 1296+ auto value = prim->value_as_DetectionPostProcess(); 1297+ if (prim != nullptr && value != nullptr) { 1298+ return value->max_classes_per_detection(); 1299+ } else { 1300+ return 0; 1301+ } 1302+ } else { 1303+ return 0; 1304+ } 1305+} 1306+ 1307+void MindIR_DetectionPostProcess_SetMaxClassesPerDetection(PrimitivePtr *primitive, int64_t max_classes_per_detection) { 1308+ if (primitive != nullptr && *primitive != nullptr) { 1309+ auto prim = static_cast<schema::Primitive *>(*primitive); 1310+ auto value = prim->value_as_DetectionPostProcess(); 1311+ if (prim != nullptr && value != nullptr) { 1312+ flatbuffers::FlatBufferBuilder fbb; 1313+ auto ops_offset = schema::CreateDetectionPostProcess(fbb, static_cast<schema::Format>(value->format()), value->input_size(), fbb.CreateVector(value->scale()->data(), value->scale()->size()), value->nms_iou_threshold(), value->nms_score_threshold(), value->max_detections(), value->detections_per_class(), max_classes_per_detection, value->num_classes(), value->use_regular_nms(), value->out_quantized()); 1314+ auto prim_offset = schema::CreatePrimitive(fbb, static_cast<schema::PrimitiveType>(NODE_TYPE_DETECTION_POST_PROCESS), ops_offset.o); 1315+ fbb.Finish(prim_offset); 1316+ auto new_addr = MindIRMemoryManager::GetInstance()->CreatePrimitiveFromBuilder(fbb, nullptr); 1317+ auto ret_value = flatbuffers::GetMutableRoot<schema::Primitive>(new_addr); 1318+ free(*primitive); 1319+ *primitive = ret_value; 1320+ } 1321+ } 1322+} 1323+ 1324+int64_t MindIR_DetectionPostProcess_GetNumClasses(ConstPrimitivePtr primitive) { 1325+ if (primitive != nullptr) { 1326+ auto prim = static_cast<const schema::Primitive *>(primitive); 1327+ auto value = prim->value_as_DetectionPostProcess(); 1328+ if (prim != nullptr && value != nullptr) { 1329+ return value->num_classes(); 1330+ } else { 1331+ return 0; 1332+ } 1333+ } else { 1334+ return 0; 1335+ } 1336+} 1337+ 1338+void MindIR_DetectionPostProcess_SetNumClasses(PrimitivePtr *primitive, int64_t num_classes) { 1339+ if (primitive != nullptr && *primitive != nullptr) { 1340+ auto prim = static_cast<schema::Primitive *>(*primitive); 1341+ auto value = prim->value_as_DetectionPostProcess(); 1342+ if (prim != nullptr && value != nullptr) { 1343+ flatbuffers::FlatBufferBuilder fbb; 1344+ auto ops_offset = schema::CreateDetectionPostProcess(fbb, static_cast<schema::Format>(value->format()), value->input_size(), fbb.CreateVector(value->scale()->data(), value->scale()->size()), value->nms_iou_threshold(), value->nms_score_threshold(), value->max_detections(), value->detections_per_class(), value->max_classes_per_detection(), num_classes, value->use_regular_nms(), value->out_quantized()); 1345+ auto prim_offset = schema::CreatePrimitive(fbb, static_cast<schema::PrimitiveType>(NODE_TYPE_DETECTION_POST_PROCESS), ops_offset.o); 1346+ fbb.Finish(prim_offset); 1347+ auto new_addr = MindIRMemoryManager::GetInstance()->CreatePrimitiveFromBuilder(fbb, nullptr); 1348+ auto ret_value = flatbuffers::GetMutableRoot<schema::Primitive>(new_addr); 1349+ free(*primitive); 1350+ *primitive = ret_value; 1351+ } 1352+ } 1353+} 1354+ 1355+bool MindIR_DetectionPostProcess_GetUseRegularNms(ConstPrimitivePtr primitive) { 1356+ if (primitive != nullptr) { 1357+ auto prim = static_cast<const schema::Primitive *>(primitive); 1358+ auto value = prim->value_as_DetectionPostProcess(); 1359+ if (prim != nullptr && value != nullptr) { 1360+ return value->use_regular_nms(); 1361+ } else { 1362+ return false; 1363+ } 1364+ } else { 1365+ return false; 1366+ } 1367+} 1368+ 1369+void MindIR_DetectionPostProcess_SetUseRegularNms(PrimitivePtr *primitive, bool use_regular_nms) { 1370+ if (primitive != nullptr && *primitive != nullptr) { 1371+ auto prim = static_cast<schema::Primitive *>(*primitive); 1372+ auto value = prim->value_as_DetectionPostProcess(); 1373+ if (prim != nullptr && value != nullptr) { 1374+ flatbuffers::FlatBufferBuilder fbb; 1375+ auto ops_offset = schema::CreateDetectionPostProcess(fbb, static_cast<schema::Format>(value->format()), value->input_size(), fbb.CreateVector(value->scale()->data(), value->scale()->size()), value->nms_iou_threshold(), value->nms_score_threshold(), value->max_detections(), value->detections_per_class(), value->max_classes_per_detection(), value->num_classes(), use_regular_nms, value->out_quantized()); 1376+ auto prim_offset = schema::CreatePrimitive(fbb, static_cast<schema::PrimitiveType>(NODE_TYPE_DETECTION_POST_PROCESS), ops_offset.o); 1377+ fbb.Finish(prim_offset); 1378+ auto new_addr = MindIRMemoryManager::GetInstance()->CreatePrimitiveFromBuilder(fbb, nullptr); 1379+ auto ret_value = flatbuffers::GetMutableRoot<schema::Primitive>(new_addr); 1380+ free(*primitive); 1381+ *primitive = ret_value; 1382+ } 1383+ } 1384+} 1385+ 1386+bool MindIR_DetectionPostProcess_GetOutQuantized(ConstPrimitivePtr primitive) { 1387+ if (primitive != nullptr) { 1388+ auto prim = static_cast<const schema::Primitive *>(primitive); 1389+ auto value = prim->value_as_DetectionPostProcess(); 1390+ if (prim != nullptr && value != nullptr) { 1391+ return value->out_quantized(); 1392+ } else { 1393+ return false; 1394+ } 1395+ } else { 1396+ return false; 1397+ } 1398+} 1399+ 1400+void MindIR_DetectionPostProcess_SetOutQuantized(PrimitivePtr *primitive, bool out_quantized) { 1401+ if (primitive != nullptr && *primitive != nullptr) { 1402+ auto prim = static_cast<schema::Primitive *>(*primitive); 1403+ auto value = prim->value_as_DetectionPostProcess(); 1404+ if (prim != nullptr && value != nullptr) { 1405+ flatbuffers::FlatBufferBuilder fbb; 1406+ auto ops_offset = schema::CreateDetectionPostProcess(fbb, static_cast<schema::Format>(value->format()), value->input_size(), fbb.CreateVector(value->scale()->data(), value->scale()->size()), value->nms_iou_threshold(), value->nms_score_threshold(), value->max_detections(), value->detections_per_class(), value->max_classes_per_detection(), value->num_classes(), value->use_regular_nms(), out_quantized); 1407+ auto prim_offset = schema::CreatePrimitive(fbb, static_cast<schema::PrimitiveType>(NODE_TYPE_DETECTION_POST_PROCESS), ops_offset.o); 1408+ fbb.Finish(prim_offset); 1409+ auto new_addr = MindIRMemoryManager::GetInstance()->CreatePrimitiveFromBuilder(fbb, nullptr); 1410+ auto ret_value = flatbuffers::GetMutableRoot<schema::Primitive>(new_addr); 1411+ free(*primitive); 1412+ *primitive = ret_value; 1413+ } 1414+ } 1415+} 1416+ 1417+// ********** ScatterNd ********** 1418+PrimitivePtr MindIR_ScatterNd_CreatePrimitive() { 1419+ flatbuffers::FlatBufferBuilder fbb; 1420+ auto ops_offset = schema::CreateScatterNd(fbb); 1421+ auto prim_offset = schema::CreatePrimitive(fbb, static_cast<schema::PrimitiveType>(NODE_TYPE_SCATTER_ND), ops_offset.o); 1422+ fbb.Finish(prim_offset); 1423+ auto new_addr = MindIRMemoryManager::GetInstance()->CreatePrimitiveFromBuilder(fbb, nullptr); 1424+ auto ret_value = flatbuffers::GetMutableRoot<schema::Primitive>(new_addr); 1425+ return ret_value; 1426+} 1427+ 1428+// ********** Rank ********** 1429+PrimitivePtr MindIR_Rank_CreatePrimitive() { 1430+ flatbuffers::FlatBufferBuilder fbb; 1431+ auto ops_offset = schema::CreateRank(fbb); 1432+ auto prim_offset = schema::CreatePrimitive(fbb, static_cast<schema::PrimitiveType>(NODE_TYPE_RANK), ops_offset.o); 1433+ fbb.Finish(prim_offset); 1434+ auto new_addr = MindIRMemoryManager::GetInstance()->CreatePrimitiveFromBuilder(fbb, nullptr); 1435+ auto ret_value = flatbuffers::GetMutableRoot<schema::Primitive>(new_addr); 1436+ return ret_value; 1437+} 1438+ 1439+// ********** GatherNd ********** 1440+PrimitivePtr MindIR_GatherNd_CreatePrimitive() { 1441+ flatbuffers::FlatBufferBuilder fbb; 1442+ auto ops_offset = schema::CreateGatherNd(fbb); 1443+ auto prim_offset = schema::CreatePrimitive(fbb, static_cast<schema::PrimitiveType>(NODE_TYPE_GATHER_ND), ops_offset.o); 1444+ fbb.Finish(prim_offset); 1445+ auto new_addr = MindIRMemoryManager::GetInstance()->CreatePrimitiveFromBuilder(fbb, nullptr); 1446+ auto ret_value = flatbuffers::GetMutableRoot<schema::Primitive>(new_addr); 1447+ return ret_value; 1448+} 1449+ 1450 // ********** Custom ********** 1451 std::vector<const mindspore::schema::Attribute *> MindIR_Custom_GetAttr(ConstPrimitivePtr primitive) { 1452 if (primitive == nullptr) { 1453-- 14542.17.1 1455 1456