hummingbird
/
graphengine
Not watched
2
0
Fork 0
Code
Releases 13 Wiki Activity
Issues 0 Pull Requests 0 Datasets Model Cloudbrain
Browse Source

clean bc warning and add atc.bin fwk_atc.bin

tags/v1.2.0
taoxudonghaha 4 years ago
parent
0e17f86580
commit
65b310205a
12 changed files with 257 additions and 2050 deletions
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. +123
    -3
      ge/offline/CMakeLists.txt
  2. +20
    -0
      ge/offline/atc
  3. +105
    -0
      ge/offline/module.mk
  4. +7
    -0
      ge/stub/gen_stubapi.py
  5. +1
    -1
      metadef
  6. +1
    -1
      parser
  7. +0
    -42
      tests/st/CMakeLists.txt
  8. +0
    -768
      tests/st/resnet50/common.cc
  9. +0
    -102
      tests/st/resnet50/common.h
  10. +0
    -225
      tests/st/resnet50/ptest.h
  11. +0
    -852
      tests/st/resnet50/resnet50_train.cc
  12. +0
    -56
      tests/st/test_ge_st.py

+ 123
- 3
ge/offline/CMakeLists.txt View File

@@ -11,13 +11,13 @@ set(SRC_LIST
"main.cc" "main.cc"
"single_op_parser.cc" "single_op_parser.cc"
"../session/omg.cc" "../session/omg.cc"
"../ir_build/atc_ir_common.cc"
"../ir_build/atc_ir_common.cc"
) )


############ atc ############ ############ atc ############
add_executable(atc ${SRC_LIST} ${PROTO_HDRS}) add_executable(atc ${SRC_LIST} ${PROTO_HDRS})


target_compile_options(atc PRIVATE
target_compile_options(atc PRIVATE
-Werror -Werror
-O2 -O2
-Wno-deprecated-declarations -Wno-deprecated-declarations
@@ -74,10 +74,130 @@ target_link_libraries(atc PRIVATE
-ldl -ldl
) )


############ atc.bin ############
add_executable(atc.bin ${SRC_LIST} ${PROTO_HDRS})

target_compile_options(atc.bin PRIVATE
-Werror
-O2
-Wno-deprecated-declarations
)

target_compile_definitions(atc.bin PRIVATE
PROTOBUF_INLINE_NOT_IN_HEADERS=0
COMPILE_OMG_PACKAGE
google=ascend_private
)

target_include_directories(atc.bin PRIVATE
${CMAKE_CURRENT_LIST_DIR}
${GE_CODE_DIR}
${GE_CODE_DIR}/ge
${GE_CODE_DIR}/inc/external
${GE_CODE_DIR}/common/inc/external
${GE_CODE_DIR}/common/inc/external/graph
${GE_CODE_DIR}/inc
${GE_CODE_DIR}/inc/framework
${METADEF_DIR}/inc
${METADEF_DIR}/inc/graph
${METADEF_DIR}/inc/register
${METADEF_DIR}/inc/external
${METADEF_DIR}/inc/external/graph
${METADEF_DIR}/inc/external/register
${PARSER_DIR}
${CMAKE_BINARY_DIR}
${CMAKE_BINARY_DIR}/proto/ge
#### yellow zone ####
${GE_CODE_DIR}/../inc
${GE_CODE_DIR}/../inc/common
#### blue zone ####
${GE_CODE_DIR}/third_party/fwkacllib/inc
${GE_CODE_DIR}/third_party/fwkacllib/inc/toolchain
)

target_link_libraries(atc.bin PRIVATE
$<BUILD_INTERFACE:intf_pub>
ascend_protobuf
ge_common
register
c_sec
graph
error_manager
ge_compiler
parser_common
gflags
json
runtime_compile
slog
static_mmpa
-lrt
-ldl
)

############ fwk_atc.bin ############
add_executable(fwk_atc.bin ${SRC_LIST} ${PROTO_HDRS})

target_compile_options(fwk_atc.bin PRIVATE
-Werror
-O2
-Wno-deprecated-declarations
)

target_compile_definitions(fwk_atc.bin PRIVATE
PROTOBUF_INLINE_NOT_IN_HEADERS=0
COMPILE_OMG_PACKAGE
google=ascend_private
)

target_include_directories(fwk_atc.bin PRIVATE
${CMAKE_CURRENT_LIST_DIR}
${GE_CODE_DIR}
${GE_CODE_DIR}/ge
${GE_CODE_DIR}/inc/external
${GE_CODE_DIR}/common/inc/external
${GE_CODE_DIR}/common/inc/external/graph
${GE_CODE_DIR}/inc
${GE_CODE_DIR}/inc/framework
${METADEF_DIR}/inc
${METADEF_DIR}/inc/graph
${METADEF_DIR}/inc/register
${METADEF_DIR}/inc/external
${METADEF_DIR}/inc/external/graph
${METADEF_DIR}/inc/external/register
${PARSER_DIR}
${CMAKE_BINARY_DIR}
${CMAKE_BINARY_DIR}/proto/ge
#### yellow zone ####
${GE_CODE_DIR}/../inc
${GE_CODE_DIR}/../inc/common
#### blue zone ####
${GE_CODE_DIR}/third_party/fwkacllib/inc
${GE_CODE_DIR}/third_party/fwkacllib/inc/toolchain
)

target_link_libraries(fwk_atc.bin PRIVATE
$<BUILD_INTERFACE:intf_pub>
ascend_protobuf
ge_common
register
c_sec
graph
error_manager
ge_compiler
parser_common
gflags
json
runtime_compile
slog
static_mmpa
-lrt
-ldl
)

############ install ############ ############ install ############
set(INSTALL_BASE_DIR "") set(INSTALL_BASE_DIR "")
set(INSTALL_LIBRARY_DIR lib) set(INSTALL_LIBRARY_DIR lib)


install(TARGETS atc OPTIONAL
install(TARGETS atc atc.bin fwk_atc.bin OPTIONAL
LIBRARY DESTINATION ${INSTALL_LIBRARY_DIR} LIBRARY DESTINATION ${INSTALL_LIBRARY_DIR}
) )

+ 20
- 0
ge/offline/atc View File

@@ -0,0 +1,20 @@
#!/bin/bash
#-------------------------------------------------------------------
# Purpose:
# Copyright 2020 Huawei Technologies Co., Ltd. All rights reserved.
#-------------------------------------------------------------------

LOCAL_PATH=$(cd "$(dirname "$0")"; pwd)
PKG_PATH=$(cd ${LOCAL_PATH}/..; pwd)
LIB_P="/lib64"
PYTHON_P="/python/site-packages"
LIB64_PATH="${PKG_PATH}${LIB_P}"
PYTHON_PATH="${PKG_PATH}${PYTHON_P}"
export LD_LIBRARY_PATH="${LIB64_PATH}:${LD_LIBRARY_PATH}"
export PYTHONPATH="${PYTHON_PATH}:${PYTHONPATH}"

if [ -f "${PKG_PATH}/bin/atc.bin" ];then
atc.bin $@
else
fwk_atc.bin $@
fi

+ 105
- 0
ge/offline/module.mk View File

@@ -54,3 +54,108 @@ LOCAL_LDFLAGS := -lrt -ldl


include $(BUILD_HOST_EXECUTABLE) include $(BUILD_HOST_EXECUTABLE)


include $(CLEAR_VARS)

LOCAL_MODULE := atc.bin

LOCAL_CFLAGS += -Werror -Wno-deprecated-declarations
LOCAL_CFLAGS += -DPROTOBUF_INLINE_NOT_IN_HEADERS=0 -DCOMPILE_OMG_PACKAGE -O2 -Dgoogle=ascend_private

LOCAL_SRC_FILES := \
main.cc \
single_op_parser.cc \
../session/omg.cc \
../ir_build/atc_ir_common.cc \

LOCAL_C_INCLUDES := \
$(LOCAL_PATH)/../ ./ \
$(TOPDIR)inc \
$(TOPDIR)metadef/inc \
$(TOPDIR)graphengine/inc \
$(TOPDIR)inc/external \
$(TOPDIR)metadef/inc/external \
$(TOPDIR)graphengine/inc/external \
$(TOPDIR)metadef/inc/external/graph \
$(TOPDIR)graphengine/inc/framework \
$(TOPDIR)libc_sec/include \
$(TOPDIR)metadef/inc/common/util \
$(TOPDIR)parser \
third_party/json/include \
third_party/gflags/include \
third_party/protobuf/include \
proto/om.proto \
proto/ge_ir.proto \
proto/task.proto \
proto/insert_op.proto \

LOCAL_SHARED_LIBRARIES := \
libc_sec \
libge_common \
libascend_protobuf \
libslog \
libgraph \
libregister \
liberror_manager \
libge_compiler \
libruntime_compile \
libparser_common \
liberror_manager \

LOCAL_STATIC_LIBRARIES := libgflags

LOCAL_LDFLAGS := -lrt -ldl

include $(BUILD_HOST_EXECUTABLE)

include $(CLEAR_VARS)

LOCAL_MODULE := fwk_atc.bin

LOCAL_CFLAGS += -Werror -Wno-deprecated-declarations
LOCAL_CFLAGS += -DPROTOBUF_INLINE_NOT_IN_HEADERS=0 -DCOMPILE_OMG_PACKAGE -O2 -Dgoogle=ascend_private

LOCAL_SRC_FILES := \
main.cc \
single_op_parser.cc \
../session/omg.cc \
../ir_build/atc_ir_common.cc \

LOCAL_C_INCLUDES := \
$(LOCAL_PATH)/../ ./ \
$(TOPDIR)inc \
$(TOPDIR)metadef/inc \
$(TOPDIR)graphengine/inc \
$(TOPDIR)inc/external \
$(TOPDIR)metadef/inc/external \
$(TOPDIR)graphengine/inc/external \
$(TOPDIR)metadef/inc/external/graph \
$(TOPDIR)graphengine/inc/framework \
$(TOPDIR)libc_sec/include \
$(TOPDIR)metadef/inc/common/util \
$(TOPDIR)parser \
third_party/json/include \
third_party/gflags/include \
third_party/protobuf/include \
proto/om.proto \
proto/ge_ir.proto \
proto/task.proto \
proto/insert_op.proto \

LOCAL_SHARED_LIBRARIES := \
libc_sec \
libge_common \
libascend_protobuf \
libslog \
libgraph \
libregister \
liberror_manager \
libge_compiler \
libruntime_compile \
libparser_common \
liberror_manager \

LOCAL_STATIC_LIBRARIES := libgflags

LOCAL_LDFLAGS := -lrt -ldl

include $(BUILD_HOST_EXECUTABLE)

+ 7
- 0
ge/stub/gen_stubapi.py View File

@@ -1,3 +1,10 @@
#!/usr/bin/python3.7
# -*- coding: UTF-8 -*-
#-------------------------------------------------------------------
# Purpose:
# Copyright 2020 Huawei Technologies Co., Ltd. All rights reserved.
#-------------------------------------------------------------------

import os import os
import re import re
import sys import sys


+ 1
- 1
metadef

@@ -1 +1 @@
Subproject commit 29c31bb87d8bbe6904ab6fa72034a803fb50a746
Subproject commit 5b9a7f84a4347f8816d492aa51f2414ccf8a0744

+ 1
- 1
parser

@@ -1 +1 @@
Subproject commit ba956d349d8ad3e864d27467f4f0119333cbadc6
Subproject commit 70369668abebed84942d9f355494a89e82cc1eac

+ 0
- 42
tests/st/CMakeLists.txt View File

@@ -1,42 +0,0 @@
# Copyright 2019-2020 Huawei Technologies Co., Ltd
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# ============================================================================

cmake_minimum_required(VERSION 3.0)
set(CMAKE_CXX_STANDARD 11)
project(ge_st CXX C)

set(CMAKE_CXX_FLAGS "-O1 -fPIC -Wl,-unresolved-symbols=ignore-in-shared-libs")


file(GLOB_RECURSE RES50_TRAIN_SRCS RELATIVE ${CMAKE_CURRENT_SOURCE_DIR}
"resnet50/resnet50_train.cc"
"resnet50/common.cc"
)

include_directories(${GE_SOURCE_DIR}/inc)
include_directories(${GE_SOURCE_DIR}/inc/graph)
include_directories(${GE_SOURCE_DIR}/inc/framework)
include_directories(${GE_SOURCE_DIR}/inc/external)
include_directories(${GE_SOURCE_DIR}/inc/external/ge)
include_directories(${GE_SOURCE_DIR}/inc/external/graph)
include_directories(${GE_SOURCE_DIR}/third_party/fwkacllib/inc)
include_directories(${GE_SOURCE_DIR}/third_party/fwkacllib/inc/ops)
include_directories(/usr/local/HiAI/opp/op_proto/built-in/inc)

add_executable(st_resnet50_train ${RES50_TRAIN_SRCS})
target_link_libraries(st_resnet50_train
${PROTOBUF_LIBRARY}
ge_client_train ge_memory
)

+ 0
- 768
tests/st/resnet50/common.cc View File

@@ -1,768 +0,0 @@
/**
* Copyright 2019-2020 Huawei Technologies Co., Ltd
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/

#include <math.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <iostream>
#include <vector>

#include "common.h"
#include "model.h"

#define MAX_HEAD_SIZE 50

using namespace std;
using namespace ge;

void update_op_format(Operator ops, Format format) {
printf("set format begin.........\n");
ge::TensorDesc tensor_desc_x = ops.GetInputDesc("x");
ge::TensorDesc tensor_desc_y = ops.GetOutputDesc("y");
Format f_x0 = tensor_desc_x.GetFormat();
Format f_y0 = tensor_desc_x.GetFormat();
printf("before set x format:%d \n", f_x0);
printf("before set y format:%d \n", f_y0);
printf("format to be set is :%d \n", format);
tensor_desc_x.SetFormat(format);
tensor_desc_y.SetFormat(format);
ops.UpdateInputDesc("x", tensor_desc_x);
ops.UpdateOutputDesc("y", tensor_desc_y);
Format f_x = tensor_desc_x.GetFormat();
Format f_y = tensor_desc_y.GetFormat();
printf("after set x format:%d \n", f_x);
printf("after set y format:%d \n", f_y);
}

/// getDimInfo: get dim info from data file
/// param:
/// fp: the testing datafile object
///
/// return :
/// dim_info: array to store the info of the dim in datafile, like [4,3,3,6,3,162(3*3*6*3)],4 is dim size,3,3,6,3 is the
/// dim shape data_size: the size of the testing data including the data file
void getDimInfo(FILE *fp, std::vector<uint64_t> &dim_info) {
// get dim info from hisi testing data file
uint32_t *dim_buffer = (uint32_t *)malloc(MAX_HEAD_SIZE * sizeof(uint32_t));
fread(dim_buffer, sizeof(uint32_t), MAX_HEAD_SIZE, fp);
dim_info.push_back(*dim_buffer); // get dim size

// get data shape to compute the datasize
uint64_t data_size = 1;
uint32_t i = 1;
for (; i <= dim_info[0]; i++) {
dim_info.push_back(*(dim_buffer + i));
data_size *= *(dim_buffer + i);
}
dim_info.push_back(data_size);

free(dim_buffer);
}

/// readTestDataFile: read test date from hisi .t datafile
/// param:
/// infile: the path of hisi .t datafile
/// return:
/// dim_info: array to store the info of the dim in datafile, like [4,3,3,6,3],4 is dim size,3,3,6,3 is the dim shape
void *readTestDataFile(std::string infile, std::vector<uint64_t> &dim_info) {
FILE *fp;
fp = fopen(infile.c_str(), "r");

if (fp == NULL) {
printf("ERROR: cant't open file %s\n", infile.c_str());
return NULL;
} else {
getDimInfo(fp, dim_info);
uint64_t data_size = dim_info[dim_info.size() - 1];

fclose(fp);

fp = fopen(infile.c_str(), "r");
if (fp == NULL) {
printf("ERROR: cant't open file %s\n", infile.c_str());
return NULL;
}
uint32_t *memory = (uint32_t *)malloc((dim_info[0] + 1 + data_size) * sizeof(uint32_t));
fread(memory, sizeof(uint32_t), (dim_info[0] + 1 + data_size), fp);
fclose(fp);
return memory + (dim_info[0] + 1);
}
}

void *readUint8TestDataFile(std::string infile, int size) {
FILE *fp;
fp = fopen(infile.c_str(), "r");

if (fp == NULL) {
printf("ERROR: cant't open file %s\n", infile.c_str());
return NULL;
}
uint8_t *memory = (uint8_t *)malloc((size) * sizeof(uint8_t));
fread(memory, sizeof(uint8_t), (size), fp);
fclose(fp);
return memory;
}

/// allclose
/// param:
/// a:compared file a
/// b:compared file b
/// count: the count size which will compare
/// rtol:
/// atol:
/// return:
/// true or false
bool allclose(float *a, float *b, uint64_t count, float rtol = 1e-05, float atol = 1e-08) {
uint32_t i = 0;

for (; i < count; ++i) {
if (fabs(a[i] - b[i]) > (atol + rtol * fabs(b[i]))) {
printf("compara failed: i= %d, a[i]=%f, b[i]=%f,atol=%f,rtol=%f\n", i, a[i], b[i], atol, rtol);
return false;
}
}

return true;
}

/// compFp32WithTData: compare the data with the data in hisi .t file
/// param:
/// actual_output_data: the result of ge
/// expected_data_file: the path of hisi .t result file
/// rtol:
/// atol:
/// return:
/// true of false
bool compFp32WithTData(float *actual_output_data, std::string expected_data_file, float rtol = 1e-05, float atol = 1e-08) {
std::vector<uint64_t> dim_info;
float *expected_output_data = (float *)readTestDataFile(expected_data_file, dim_info);

uint32_t i = 1;
uint64_t data_size = 1;
for (; i <= dim_info[0]; i++) {
data_size *= dim_info[i];
}
return allclose(actual_output_data, expected_output_data, data_size, rtol, atol);
}

int SwitchDatatype(DataType dt) {
int size = 1;
if (dt == ge::DT_FLOAT) size = 4;
if (dt == ge::DT_INT32) size = 4;
if (dt == ge::DT_FLOAT16) size = 2;
if (dt == ge::DT_INT64) size = 8;
return size;
}

ge::Tensor genTensor(std::vector<int64_t> tensor_shape, Format format, DataType dt) {
int size = 1;
for (int i = 0; i < tensor_shape.size(); i++) {
size = size * tensor_shape[i];
}

int data_type_size = SwitchDatatype(dt);

size = abs(size * data_type_size);
vector<uint8_t> data_value;

if (size == 0) {
TensorDesc input_tensor_desc = TensorDesc(ge::Shape(tensor_shape), format, dt);
input_tensor_desc.SetRealDimCnt(tensor_shape.size());
Tensor gen_tensor = Tensor(input_tensor_desc, data_value);
return gen_tensor;
}
for (int i = 0; i < size; i++) {
data_value.push_back(1);
}
TensorDesc input_tensor_desc = TensorDesc(ge::Shape(tensor_shape), format, dt);
input_tensor_desc.SetRealDimCnt(tensor_shape.size());
Tensor gen_tensor = Tensor(input_tensor_desc, data_value);
return gen_tensor;
}

ge::Tensor genTensor_withVaule(std::vector<int64_t> tensor_shape, float value) {
int size = 1;
for (int i = 0; i < tensor_shape.size(); i++) {
size = size * tensor_shape[i];
}

float *data_value = new float[size];
for (int i = 0; i < size; i++) {
*(data_value + i) = value;
}
Tensor gen_ge_tensor;
TensorDesc input_tensor_desc = TensorDesc(ge::Shape(tensor_shape), FORMAT_NCHW);
gen_ge_tensor.SetTensorDesc(input_tensor_desc);
gen_ge_tensor.SetData((uint8_t *)data_value, size * 4);

return gen_ge_tensor;
}

Tensor genTesnor_Shape_as_data(std::vector<int64_t> tensor_shape) {
Format format = FORMAT_NCHW;
DataType dt = DT_INT32;
int size = tensor_shape.size();
int32_t *tensor_data = new int32_t[size];
std::cout << "shape tensor size:" << size << endl;
for (int i = 0; i < size; i++) {
*(tensor_data + i) = tensor_shape[i];
}

Tensor gen_tensor;
TensorDesc input_tensor_desc = TensorDesc(ge::Shape({size}), FORMAT_NCHW, DT_INT32);
gen_tensor.SetData((uint8_t *)tensor_data, size * GetDatTypeSize(dt));
gen_tensor.SetTensorDesc(input_tensor_desc);

return gen_tensor;
}

/// train_flag is 0 when infer; train_flag is 1 when train; train_flag is 0 default
/// run_mode_path is not 0,1,2 when TBE; run_mode_path is 1 when FE; run_mode_path is 0 default
/// run_mode_path is 2 now when AICPU, ge.enabledlocalFmkop is 1
ge::Status GEInitialize_api(string train_flag, string run_mode_path) {
ge::Status ret;
if (run_mode_path == "0") {
const std::map<string, string> config = {
{"device_id", "0,2,4,6"},
{"rank_table_file", "hccl from csa/paas"},
{"ge.graphRunMode", train_flag},
{"ge.aicpuFlag", "1"},
{"ge.feFlag", "1"},
{DDK_VERSION_FLAG, "1.60.T17.B830"},
{"ge.soLoadPath",
"/usr/local/HiAI/runtime/lib64/plugin/opskernel/libfe.so:/usr/local/HiAI/runtime/lib64/plugin/opskernel/"
"libaicpu_plugin.so"}};
ret = ge::GEInitialize(config);
} else if (run_mode_path == "1") {
const std::map<string, string> config = {
{"device_id", "0,2,4,6"},
{"rank_table_file", "hccl from csa/paas"},
{"ge.graphRunMode", train_flag},
{"ge.feFlag", "1"},
{DDK_VERSION_FLAG, "1.60.T17.B830"},
{TBE_PLUGIN_PATH_FLAG, "/usr/local/HiAI/runtime/lib64/tbe_plugin/bert"},
{"ge.soLoadPath", "/usr/local/HiAI/runtime/lib64/plugin/opskernel/libfe.so"}};
ret = ge::GEInitialize(config);
} else if (run_mode_path == "2") {
const std::map<string, string> config = {{"device_id", "0,2,4,6"},
{"rank_table_file", "hccl from csa/paas"},
{"ge.graphRunMode", train_flag},
{LOCAL_FMKOP_FLAG, "1"}};
ret = ge::GEInitialize(config);
} else {
const std::map<string, string> config = {
{"device_id", "0,2,4,6"},
{"rank_table_file", "hccl from csa/paas"},
{"ge.graphRunMode", train_flag},
{DDK_VERSION_FLAG, "1.60.T17.B830"},
{TBE_PLUGIN_PATH_FLAG, "/usr/local/HiAI/runtime/lib64/tbe_plugin/" + run_mode_path}};
ret = ge::GEInitialize(config);
}
std::cout << "GEInitialize_ret is " << ret << std::endl;

return ret;
}

/// train_flag is infer default
/// run_mode: is multi group of [fe,aicpu,bert,deeplabv3,mobilenetv2,single_path_nas,ssd]
/// but bert,deeplabv3,mobilenetv2,single_path_nas,ssd can only set one value from array
/// eg:"fe,aicpu,bert" or "fe", default is “fe”
/// "fe,aicpu,bert" remain open fe aicpu and bert
ge::Status GEInitialize_api_new(string train_flag, string run_mode) {
ge::Status ret;
vector<string> modes;

char *strs = new char[run_mode.length() + 1];
strcpy(strs, run_mode.c_str());
const char *delim = ",";
char *p = strtok(strs, delim);
while (p) {
string s = p; // transform substr to string
modes.push_back(s); // save to result array
p = strtok(NULL, delim);
}

std::map<string, string> config = {
{"device_id", "0,2,4,6"},
{"rank_table_file", "hccl from csa/paas"},
{DDK_VERSION_FLAG, "1.60.T17.B830"},
{"ge.opsProtoLibPath", "/usr/local/HiAI/runtime/ops/op_proto/built-in/libopsproto.so"}};
if (train_flag == "infer")
config.insert(pair<string, string>("ge.graphRunMode", "0"));
else if (train_flag == "train")
config.insert(pair<string, string>("ge.graphRunMode", "1"));
else
std::cout << "GeInitialize give the error param" << std::endl;

for (int i = 0; i < modes.size(); i++) {
if (modes[i] == "fe") {
config.insert(pair<string, string>("ge.feFlag", "1"));
if (config.find("ge.soLoadPath") != config.end()) {
config["ge.soLoadPath"] =
"/usr/local/HiAI/runtime/lib64/plugin/opskernel/libfe.so:/usr/local/HiAI/runtime/lib64/plugin/opskernel/"
"libaicpu_plugin.so:/usr/local/HiAI/runtime/lib64/plugin/opskernel/libge_local_engine.so:/usr/local/HiAI/"
"runtime/lib64/plugin/opskernel/librts_engine.so";
} else {
config.insert(pair<string, string>(
"ge.soLoadPath",
"/usr/local/HiAI/runtime/lib64/plugin/opskernel/libfe.so:/usr/local/HiAI/runtime/lib64/plugin/opskernel/"
"libge_local_engine.so:/usr/local/HiAI/runtime/lib64/plugin/opskernel/librts_engine.so"));
}
} else if (modes[i] == "aicpu") {
config.insert(pair<string, string>("ge.aicpuFlag", "1"));
if (config.find("ge.soLoadPath") != config.end()) {
config["ge.soLoadPath"] =
"/usr/local/HiAI/runtime/lib64/plugin/opskernel/libfe.so:/usr/local/HiAI/runtime/lib64/plugin/opskernel/"
"libaicpu_plugin.so:/usr/local/HiAI/runtime/lib64/plugin/opskernel/libge_local_engine.so:/usr/local/HiAI/"
"runtime/lib64/plugin/opskernel/librts_engine.so";
} else {
config.insert(pair<string, string>(
"ge.soLoadPath",
"/usr/local/HiAI/runtime/lib64/plugin/opskernel/libaicpu_plugin.so:/usr/local/HiAI/runtime/lib64/plugin/"
"opskernel/libge_local_engine.so:/usr/local/HiAI/runtime/lib64/plugin/opskernel/librts_engine.so"));
}
} else if (modes[i] == "bert" || modes[i] == "deeplabv3" || modes[i] == "mobilenetv2" ||
modes[i] == "single_path_nas" || modes[i] == "ssd") {
config.insert(pair<string, string>(TBE_PLUGIN_PATH_FLAG, "/usr/local/HiAI/runtime/lib64/tbe_plugin/" + modes[i]));
} else if (modes[i] == "plugin") {

} else
std::cout << "GeInitialize give the error param" << std::endl;
}
ret = ge::GEInitialize(config);

std::cout << "GEInitialize_ret is " << ret << std::endl;

return ret;
}

ge::Status GEFinalize_api() {
ge::Status ret = ge::GEFinalize();
std::cout << "GEFinalize ret is " << ret << std::endl;

return ret;
}

/// set train_flag
/// if run_mode_path is "fe" remain FE process; "fe,plugin" is FE and TBE plugin process
/// "aicpu" is open aicpu plugin
int RunGraph_initData(Graph &graph, string op_name, map<string, std::vector<int64_t>> attr_test, string train_flag,
string run_mode_path) {
std::map<string, string> options = {{RUN_FLAG, "1"}};
uint32_t graph_id = 0;

ge::Status ret = GEInitialize_api_new(train_flag, run_mode_path);
EXPECT_EQ(ret, ge::SUCCESS);

ge::Session *session = new Session(options);
ASSERT_TRUE(session != NULL);

std::vector<Tensor> input;
if (attr_test.find("input1") != attr_test.end()) {
Tensor input_tensor = genTensor(attr_test["input1"]);
input.push_back(input_tensor);
}
if (attr_test.find("input2") != attr_test.end()) {
Tensor input_tensor = genTensor(attr_test["input2"]);
input.push_back(input_tensor);
}
if (attr_test.find("input3") != attr_test.end()) {
Tensor input_tensor = genTensor(attr_test["input3"]);
input.push_back(input_tensor);
}
std::vector<Tensor> output;

ret = session->AddGraph(graph_id, graph);
EXPECT_EQ(ret, ge::SUCCESS);
if (train_flag == "1") {
setenv("GE_TRAIN", "1", true);
ret = session->RunGraph(graph_id, input, output);
setenv("GE_TRAIN", "0", true);
} else {
ret = session->RunGraph(graph_id, input, output);
}
delete session;
GEFinalize_api();

if (ret != ge::SUCCESS) {
std::cout << " run graph failed" << std::endl;
return -1;
} else {
return 0;
}
}

ge::Status session_add_and_run_graph(ge::Session *session, uint32_t graph_id, Graph &graph, std::vector<Tensor> inputs,
std::vector<Tensor> &outputs) {
ge::Status ret = session->AddGraph(graph_id, graph);
EXPECT_EQ(ret, ge::SUCCESS);
ret = session->RunGraph(graph_id, inputs, outputs);

return ret;
}

ge::Session *create_session() {
// Init session
std::map<string, string> options = {{"a", "b"}, {TRAIN_FLAG, "1"}};
ge::Session *session = new Session(options);
ASSERT_TRUE(session != NULL);

return session;
}

ge::Session *create_aipp_session() {
// Init session
std::map<string, string> options = {{"a", "b"}, {TRAIN_FLAG, "1"}, {"ge.insertOpFile", "/root/host/ge/aipp.cfg"}};
ge::Session *session = new Session(options);
ASSERT_TRUE(session != NULL);

return session;
}

int buildCheckPointGraph(Graph &graph, map<string, TensorDesc> variables) {
std::vector<Operator> inputs{};
std::vector<Operator> outputs{};

for (map<string, TensorDesc>::iterator it = variables.begin(); it != variables.end(); ++it) {
auto var = op::Variable(string(it->first));
var.update_output_desc_y(it->second);
inputs.push_back(var);
graph.AddOp(var);
}

auto save = op::Save().create_dynamic_input_tensors(inputs.size());
for (int i = 0; i < inputs.size(); i++) {
save.set_dynamic_input_tensors(i, inputs[i]);
}

graph.SetInputs(inputs).SetOutputs(outputs);
return 0;
}

int buildInitGraph(Graph &graph, std::vector<TensorDesc> desc_var, std::vector<std::string> name_var,
std::vector<float> values_var) {
std::vector<Operator> inputs{};
std::vector<Operator> outputs{};

for (int i = 0; i < desc_var.size(); i++) {
desc_var[i].SetRealDimCnt(desc_var[i].GetShape().GetDimNum());
auto tensor_data = genTensor_withVaule(desc_var[i].GetShape().GetDims(), values_var[i]);
auto var_constant = op::Constant().set_attr_value(tensor_data);
var_constant.update_output_desc_y(desc_var[i]);

auto var_init = op::Variable(string(name_var[i]));
var_init.update_output_desc_y(desc_var[i]);
auto var_assign = op::Assign().set_input_ref(var_init).set_input_value(var_constant);
inputs.push_back(var_init);
}
graph.SetInputs(inputs).SetOutputs(outputs);
return 0;
}

int buildInitGraph_other_dataType(Graph &graph, std::vector<TensorDesc> desc_var, std::vector<std::string> name_var) {
std::vector<Operator> inputs{};
std::vector<Operator> outputs{};

for (int i = 0; i < desc_var.size(); i++) {
desc_var[i].SetRealDimCnt(desc_var[i].GetShape().GetDimNum());
auto tensor_data = genTensor(desc_var[i].GetShape().GetDims(), desc_var[i].GetFormat(), desc_var[i].GetDataType());
auto var_constant = op::Constant().set_attr_value(tensor_data);
var_constant.update_output_desc_y(desc_var[i]);

auto var_init = op::Variable(string(name_var[i]));
var_init.update_output_desc_y(desc_var[i]);
auto var_assign = op::Assign().set_input_ref(var_init).set_input_value(var_constant);
inputs.push_back(var_init);

graph.AddOp(var_constant);
graph.AddOp(var_init);
graph.AddOp(var_assign);
}
graph.SetInputs(inputs).SetOutputs(outputs);
return 0;
}

bool build_multi_input_multi_output_graph(Graph &graph) {
auto data1 = op::Data("Data1").set_attr_index(0);
auto data2 = op::Data("Data2").set_attr_index(1);

vector<uint64_t> dim_info;

auto relu1 = op::Relu("Relu1").set_input_x(data1);
auto relu2 = op::Relu("Relu2").set_input_x(data2);

auto eltwise = op::Eltwise("Eltwise")
.create_dynamic_input_x(2)
.set_dynamic_input_x(0, relu1)
.set_dynamic_input_x(1, relu2)
.set_attr_N(2)
.set_attr_mode(1)
.set_attr_coeff({1, 1});

auto eltwise1 = op::Eltwise("Eltwise1")
.create_dynamic_input_x(2)
.set_dynamic_input_x(0, eltwise)
.set_dynamic_input_x(1, eltwise)
.set_attr_N(2)
.set_attr_mode(1)
.set_attr_coeff({1, 1});

auto eltwise2 = op::Eltwise("Eltwise2")
.create_dynamic_input_x(2)
.set_dynamic_input_x(0, eltwise)
.set_dynamic_input_x(1, eltwise)
.set_attr_N(2)
.set_attr_mode(1)
.set_attr_coeff({1, 1});

std::vector<Operator> inputs{data1, data2};
std::vector<Operator> outputs{eltwise1, eltwise2};
graph.SetInputs(inputs).SetOutputs(outputs);
return true;
}

void build_big_graph(Graph &graph, map<string, std::vector<int64_t>> attr) {
auto data = op::Data("Data").set_attr_index(0);
auto weight = op::Const("weight1").set_attr_value(genTensor(attr["weight"]));
vector<int64_t> weight_shape(attr["weight"].begin(), attr["weight"].end());
TensorDesc weight_desc(ge::Shape(weight_shape), FORMAT_NCHW, DT_FLOAT);
weight.update_output_desc_y(weight_desc);
auto conv_1 = op::Conv2D("conv1").set_input_x(data).set_input_filter(weight).set_attr_pads({0,0,0,0}).set_attr_strides({1,1,1,1});

auto conv_2 = op::Conv2D("conv2").set_input_x(conv_1).set_input_filter(weight).set_attr_pads({0,0,0,0}).set_attr_strides({1,1,1,1});
auto conv_3 = op::Conv2D("conv3").set_input_x(conv_2).set_input_filter(weight).set_attr_pads({0,0,0,0}).set_attr_strides({1,1,1,1});
auto conv_4 = op::Conv2D("conv4").set_input_x(conv_3).set_input_filter(weight).set_attr_pads({0,0,0,0}).set_attr_strides({1,1,1,1});
auto conv_5 = op::Conv2D("conv5").set_input_x(conv_4).set_input_filter(weight).set_attr_pads({0,0,0,0}).set_attr_strides({1,1,1,1});
auto conv_6 = op::Conv2D("conv6").set_input_x(conv_5).set_input_filter(weight).set_attr_pads({0,0,0,0}).set_attr_strides({1,1,1,1});
auto conv_7 = op::Conv2D("conv7").set_input_x(conv_6).set_input_filter(weight).set_attr_pads({0,0,0,0}).set_attr_strides({1,1,1,1});
auto conv_8 = op::Conv2D("conv8").set_input_x(conv_7).set_input_filter(weight).set_attr_pads({0,0,0,0}).set_attr_strides({1,1,1,1});
auto conv_9 = op::Conv2D("conv9").set_input_x(conv_8).set_input_filter(weight).set_attr_pads({0,0,0,0}).set_attr_strides({1,1,1,1});
auto conv_10 = op::Conv2D("conv10").set_input_x(conv_9).set_input_filter(weight).set_attr_pads({0,0,0,0}).set_attr_strides({1,1,1,1});
auto conv_11 = op::Conv2D("conv11").set_input_x(conv_10).set_input_filter(weight).set_attr_pads({0,0,0,0}).set_attr_strides({1,1,1,1});
auto conv_12 = op::Conv2D("conv12").set_input_x(conv_11).set_input_filter(weight).set_attr_pads({0,0,0,0}).set_attr_strides({1,1,1,1});
auto conv_13 = op::Conv2D("conv13").set_input_x(conv_12).set_input_filter(weight).set_attr_pads({0,0,0,0}).set_attr_strides({1,1,1,1});
auto conv_14 = op::Conv2D("conv14").set_input_x(conv_13).set_input_filter(weight).set_attr_pads({0,0,0,0}).set_attr_strides({1,1,1,1});
auto conv_15 = op::Conv2D("conv15").set_input_x(conv_14).set_input_filter(weight).set_attr_pads({0,0,0,0}).set_attr_strides({1,1,1,1});
auto conv_16 = op::Conv2D("conv16").set_input_x(conv_15).set_input_filter(weight).set_attr_pads({0,0,0,0}).set_attr_strides({1,1,1,1});
auto conv_17 = op::Conv2D("conv17").set_input_x(conv_16).set_input_filter(weight).set_attr_pads({0,0,0,0}).set_attr_strides({1,1,1,1});
auto conv_18 = op::Conv2D("conv18").set_input_x(conv_17).set_input_filter(weight).set_attr_pads({0,0,0,0}).set_attr_strides({1,1,1,1});
auto conv_19 = op::Conv2D("conv19").set_input_x(conv_18).set_input_filter(weight).set_attr_pads({0,0,0,0}).set_attr_strides({1,1,1,1});
auto conv_20 = op::Conv2D("conv20").set_input_x(conv_19).set_input_filter(weight).set_attr_pads({0,0,0,0}).set_attr_strides({1,1,1,1});
auto conv_21 = op::Conv2D("conv21").set_input_x(conv_20).set_input_filter(weight).set_attr_pads({0,0,0,0}).set_attr_strides({1,1,1,1});
auto conv_22 = op::Conv2D("conv22").set_input_x(conv_21).set_input_filter(weight).set_attr_pads({0,0,0,0}).set_attr_strides({1,1,1,1});
auto conv_23 = op::Conv2D("conv23").set_input_x(conv_22).set_input_filter(weight).set_attr_pads({0,0,0,0}).set_attr_strides({1,1,1,1});
auto conv_24 = op::Conv2D("conv24").set_input_x(conv_23).set_input_filter(weight).set_attr_pads({0,0,0,0}).set_attr_strides({1,1,1,1});
auto conv_25 = op::Conv2D("conv25").set_input_x(conv_24).set_input_filter(weight).set_attr_pads({0,0,0,0}).set_attr_strides({1,1,1,1});
auto conv_26 = op::Conv2D("conv26").set_input_x(conv_25).set_input_filter(weight).set_attr_pads({0,0,0,0}).set_attr_strides({1,1,1,1});
auto conv_27 = op::Conv2D("conv27").set_input_x(conv_26).set_input_filter(weight).set_attr_pads({0,0,0,0}).set_attr_strides({1,1,1,1});
auto conv_28 = op::Conv2D("conv28").set_input_x(conv_27).set_input_filter(weight).set_attr_pads({0,0,0,0}).set_attr_strides({1,1,1,1});
auto conv_29 = op::Conv2D("conv29").set_input_x(conv_28).set_input_filter(weight).set_attr_pads({0,0,0,0}).set_attr_strides({1,1,1,1});
auto conv_30 = op::Conv2D("conv30").set_input_x(conv_29).set_input_filter(weight).set_attr_pads({0,0,0,0}).set_attr_strides({1,1,1,1});
auto conv_31 = op::Conv2D("conv31").set_input_x(conv_30).set_input_filter(weight).set_attr_pads({0,0,0,0}).set_attr_strides({1,1,1,1});
auto conv_32 = op::Conv2D("conv32").set_input_x(conv_31).set_input_filter(weight).set_attr_pads({0,0,0,0}).set_attr_strides({1,1,1,1});
auto conv_33 = op::Conv2D("conv33").set_input_x(conv_32).set_input_filter(weight).set_attr_pads({0,0,0,0}).set_attr_strides({1,1,1,1});
auto conv_34 = op::Conv2D("conv34").set_input_x(conv_33).set_input_filter(weight).set_attr_pads({0,0,0,0}).set_attr_strides({1,1,1,1});
auto conv_35 = op::Conv2D("conv35").set_input_x(conv_34).set_input_filter(weight).set_attr_pads({0,0,0,0}).set_attr_strides({1,1,1,1});
auto conv_36 = op::Conv2D("conv36").set_input_x(conv_35).set_input_filter(weight).set_attr_pads({0,0,0,0}).set_attr_strides({1,1,1,1});
auto conv_37 = op::Conv2D("conv37").set_input_x(conv_36).set_input_filter(weight).set_attr_pads({0,0,0,0}).set_attr_strides({1,1,1,1});
auto conv_38 = op::Conv2D("conv38").set_input_x(conv_37).set_input_filter(weight).set_attr_pads({0,0,0,0}).set_attr_strides({1,1,1,1});
auto conv_39 = op::Conv2D("conv39").set_input_x(conv_38).set_input_filter(weight).set_attr_pads({0,0,0,0}).set_attr_strides({1,1,1,1});
auto conv_40 = op::Conv2D("conv40").set_input_x(conv_39).set_input_filter(weight).set_attr_pads({0,0,0,0}).set_attr_strides({1,1,1,1});
auto conv_41 = op::Conv2D("conv41").set_input_x(conv_40).set_input_filter(weight).set_attr_pads({0,0,0,0}).set_attr_strides({1,1,1,1});
auto conv_42 = op::Conv2D("conv42").set_input_x(conv_41).set_input_filter(weight).set_attr_pads({0,0,0,0}).set_attr_strides({1,1,1,1});
auto conv_43 = op::Conv2D("conv43").set_input_x(conv_42).set_input_filter(weight).set_attr_pads({0,0,0,0}).set_attr_strides({1,1,1,1});
auto conv_44 = op::Conv2D("conv44").set_input_x(conv_43).set_input_filter(weight).set_attr_pads({0,0,0,0}).set_attr_strides({1,1,1,1});
auto conv_45 = op::Conv2D("conv45").set_input_x(conv_44).set_input_filter(weight).set_attr_pads({0,0,0,0}).set_attr_strides({1,1,1,1});
auto conv_46 = op::Conv2D("conv46").set_input_x(conv_45).set_input_filter(weight).set_attr_pads({0,0,0,0}).set_attr_strides({1,1,1,1});
auto conv_47 = op::Conv2D("conv47").set_input_x(conv_46).set_input_filter(weight).set_attr_pads({0,0,0,0}).set_attr_strides({1,1,1,1});
auto conv_48 = op::Conv2D("conv48").set_input_x(conv_47).set_input_filter(weight).set_attr_pads({0,0,0,0}).set_attr_strides({1,1,1,1});
auto conv_49 = op::Conv2D("conv49").set_input_x(conv_48).set_input_filter(weight).set_attr_pads({0,0,0,0}).set_attr_strides({1,1,1,1});
auto conv_50 = op::Conv2D("conv50").set_input_x(conv_49).set_input_filter(weight).set_attr_pads({0,0,0,0}).set_attr_strides({1,1,1,1});
auto conv_51 = op::Conv2D("conv51").set_input_x(conv_50).set_input_filter(weight).set_attr_pads({0,0,0,0}).set_attr_strides({1,1,1,1});
auto conv_52 = op::Conv2D("conv52").set_input_x(conv_51).set_input_filter(weight).set_attr_pads({0,0,0,0}).set_attr_strides({1,1,1,1});
auto conv_53 = op::Conv2D("conv53").set_input_x(conv_52).set_input_filter(weight).set_attr_pads({0,0,0,0}).set_attr_strides({1,1,1,1});
auto conv_54 = op::Conv2D("conv54").set_input_x(conv_53).set_input_filter(weight).set_attr_pads({0,0,0,0}).set_attr_strides({1,1,1,1});
auto conv_55 = op::Conv2D("conv55").set_input_x(conv_54).set_input_filter(weight).set_attr_pads({0,0,0,0}).set_attr_strides({1,1,1,1});
auto conv_56 = op::Conv2D("conv56").set_input_x(conv_55).set_input_filter(weight).set_attr_pads({0,0,0,0}).set_attr_strides({1,1,1,1});
auto conv_57 = op::Conv2D("conv57").set_input_x(conv_56).set_input_filter(weight).set_attr_pads({0,0,0,0}).set_attr_strides({1,1,1,1});
auto conv_58 = op::Conv2D("conv58").set_input_x(conv_57).set_input_filter(weight).set_attr_pads({0,0,0,0}).set_attr_strides({1,1,1,1});
auto conv_59 = op::Conv2D("conv59").set_input_x(conv_58).set_input_filter(weight).set_attr_pads({0,0,0,0}).set_attr_strides({1,1,1,1});
auto conv_60 = op::Conv2D("conv60").set_input_x(conv_59).set_input_filter(weight).set_attr_pads({0,0,0,0}).set_attr_strides({1,1,1,1});
auto conv_61 = op::Conv2D("conv61").set_input_x(conv_60).set_input_filter(weight).set_attr_pads({0,0,0,0}).set_attr_strides({1,1,1,1});
auto conv_62 = op::Conv2D("conv62").set_input_x(conv_61).set_input_filter(weight).set_attr_pads({0,0,0,0}).set_attr_strides({1,1,1,1});
auto conv_63 = op::Conv2D("conv63").set_input_x(conv_62).set_input_filter(weight).set_attr_pads({0,0,0,0}).set_attr_strides({1,1,1,1});
auto conv_64 = op::Conv2D("conv64").set_input_x(conv_63).set_input_filter(weight).set_attr_pads({0,0,0,0}).set_attr_strides({1,1,1,1});
auto conv_65 = op::Conv2D("conv65").set_input_x(conv_64).set_input_filter(weight).set_attr_pads({0,0,0,0}).set_attr_strides({1,1,1,1});
auto conv_66 = op::Conv2D("conv66").set_input_x(conv_65).set_input_filter(weight).set_attr_pads({0,0,0,0}).set_attr_strides({1,1,1,1});
auto conv_67 = op::Conv2D("conv67").set_input_x(conv_66).set_input_filter(weight).set_attr_pads({0,0,0,0}).set_attr_strides({1,1,1,1});
auto conv_68 = op::Conv2D("conv68").set_input_x(conv_67).set_input_filter(weight).set_attr_pads({0,0,0,0}).set_attr_strides({1,1,1,1});
auto conv_69 = op::Conv2D("conv69").set_input_x(conv_68).set_input_filter(weight).set_attr_pads({0,0,0,0}).set_attr_strides({1,1,1,1});
auto conv_70 = op::Conv2D("conv70").set_input_x(conv_69).set_input_filter(weight).set_attr_pads({0,0,0,0}).set_attr_strides({1,1,1,1});
auto conv_71 = op::Conv2D("conv71").set_input_x(conv_70).set_input_filter(weight).set_attr_pads({0,0,0,0}).set_attr_strides({1,1,1,1});
auto conv_72 = op::Conv2D("conv72").set_input_x(conv_71).set_input_filter(weight).set_attr_pads({0,0,0,0}).set_attr_strides({1,1,1,1});
auto conv_73 = op::Conv2D("conv73").set_input_x(conv_72).set_input_filter(weight).set_attr_pads({0,0,0,0}).set_attr_strides({1,1,1,1});
auto conv_74 = op::Conv2D("conv74").set_input_x(conv_73).set_input_filter(weight).set_attr_pads({0,0,0,0}).set_attr_strides({1,1,1,1});
auto conv_75 = op::Conv2D("conv75").set_input_x(conv_74).set_input_filter(weight).set_attr_pads({0,0,0,0}).set_attr_strides({1,1,1,1});
auto conv_76 = op::Conv2D("conv76").set_input_x(conv_75).set_input_filter(weight).set_attr_pads({0,0,0,0}).set_attr_strides({1,1,1,1});
auto conv_77 = op::Conv2D("conv77").set_input_x(conv_76).set_input_filter(weight).set_attr_pads({0,0,0,0}).set_attr_strides({1,1,1,1});
auto conv_78 = op::Conv2D("conv78").set_input_x(conv_77).set_input_filter(weight).set_attr_pads({0,0,0,0}).set_attr_strides({1,1,1,1});
auto conv_79 = op::Conv2D("conv79").set_input_x(conv_78).set_input_filter(weight).set_attr_pads({0,0,0,0}).set_attr_strides({1,1,1,1});
auto conv_80 = op::Conv2D("conv80").set_input_x(conv_79).set_input_filter(weight).set_attr_pads({0,0,0,0}).set_attr_strides({1,1,1,1});
auto conv_81 = op::Conv2D("conv81").set_input_x(conv_80).set_input_filter(weight).set_attr_pads({0,0,0,0}).set_attr_strides({1,1,1,1});
auto conv_82 = op::Conv2D("conv82").set_input_x(conv_81).set_input_filter(weight).set_attr_pads({0,0,0,0}).set_attr_strides({1,1,1,1});
auto conv_83 = op::Conv2D("conv83").set_input_x(conv_82).set_input_filter(weight).set_attr_pads({0,0,0,0}).set_attr_strides({1,1,1,1});
auto conv_84 = op::Conv2D("conv84").set_input_x(conv_83).set_input_filter(weight).set_attr_pads({0,0,0,0}).set_attr_strides({1,1,1,1});
auto conv_85 = op::Conv2D("conv85").set_input_x(conv_84).set_input_filter(weight).set_attr_pads({0,0,0,0}).set_attr_strides({1,1,1,1});
auto conv_86 = op::Conv2D("conv86").set_input_x(conv_85).set_input_filter(weight).set_attr_pads({0,0,0,0}).set_attr_strides({1,1,1,1});
auto conv_87 = op::Conv2D("conv87").set_input_x(conv_86).set_input_filter(weight).set_attr_pads({0,0,0,0}).set_attr_strides({1,1,1,1});
auto conv_88 = op::Conv2D("conv88").set_input_x(conv_87).set_input_filter(weight).set_attr_pads({0,0,0,0}).set_attr_strides({1,1,1,1});
auto conv_89 = op::Conv2D("conv89").set_input_x(conv_88).set_input_filter(weight).set_attr_pads({0,0,0,0}).set_attr_strides({1,1,1,1});
auto conv_90 = op::Conv2D("conv90").set_input_x(conv_89).set_input_filter(weight).set_attr_pads({0,0,0,0}).set_attr_strides({1,1,1,1});
auto conv_91 = op::Conv2D("conv91").set_input_x(conv_80).set_input_filter(weight).set_attr_pads({0,0,0,0}).set_attr_strides({1,1,1,1});
auto conv_92 = op::Conv2D("conv92").set_input_x(conv_91).set_input_filter(weight).set_attr_pads({0,0,0,0}).set_attr_strides({1,1,1,1});
auto conv_93 = op::Conv2D("conv93").set_input_x(conv_92).set_input_filter(weight).set_attr_pads({0,0,0,0}).set_attr_strides({1,1,1,1});
auto conv_94 = op::Conv2D("conv94").set_input_x(conv_93).set_input_filter(weight).set_attr_pads({0,0,0,0}).set_attr_strides({1,1,1,1});
auto conv_95 = op::Conv2D("conv95").set_input_x(conv_94).set_input_filter(weight).set_attr_pads({0,0,0,0}).set_attr_strides({1,1,1,1});
auto conv_96 = op::Conv2D("conv96").set_input_x(conv_95).set_input_filter(weight).set_attr_pads({0,0,0,0}).set_attr_strides({1,1,1,1});
auto conv_97 = op::Conv2D("conv97").set_input_x(conv_96).set_input_filter(weight).set_attr_pads({0,0,0,0}).set_attr_strides({1,1,1,1});
auto conv_98 = op::Conv2D("conv98").set_input_x(conv_97).set_input_filter(weight).set_attr_pads({0,0,0,0}).set_attr_strides({1,1,1,1});
auto conv_99 = op::Conv2D("conv99").set_input_x(conv_98).set_input_filter(weight).set_attr_pads({0,0,0,0}).set_attr_strides({1,1,1,1});
auto conv_100 = op::Conv2D("conv100").set_input_x(conv_99).set_input_filter(weight).set_attr_pads({0,0,0,0}).set_attr_strides({1,1,1,1});
auto conv_101 = op::Conv2D("conv101").set_input_x(conv_100).set_input_filter(weight).set_attr_pads({0,0,0,0}).set_attr_strides({1,1,1,1});
auto conv_102 = op::Conv2D("conv102").set_input_x(conv_101).set_input_filter(weight).set_attr_pads({0,0,0,0}).set_attr_strides({1,1,1,1});
auto conv_103 = op::Conv2D("conv103").set_input_x(conv_102).set_input_filter(weight).set_attr_pads({0,0,0,0}).set_attr_strides({1,1,1,1});
auto conv_104 = op::Conv2D("conv104").set_input_x(conv_103).set_input_filter(weight).set_attr_pads({0,0,0,0}).set_attr_strides({1,1,1,1});
auto conv_105 = op::Conv2D("conv105").set_input_x(conv_104).set_input_filter(weight).set_attr_pads({0,0,0,0}).set_attr_strides({1,1,1,1});
auto conv_106 = op::Conv2D("conv106").set_input_x(conv_105).set_input_filter(weight).set_attr_pads({0,0,0,0}).set_attr_strides({1,1,1,1});
auto conv_107 = op::Conv2D("conv107").set_input_x(conv_106).set_input_filter(weight).set_attr_pads({0,0,0,0}).set_attr_strides({1,1,1,1});
auto conv_108 = op::Conv2D("conv108").set_input_x(conv_107).set_input_filter(weight).set_attr_pads({0,0,0,0}).set_attr_strides({1,1,1,1});
auto conv_109 = op::Conv2D("conv109").set_input_x(conv_108).set_input_filter(weight).set_attr_pads({0,0,0,0}).set_attr_strides({1,1,1,1});
auto conv_110 = op::Conv2D("conv110").set_input_x(conv_109).set_input_filter(weight).set_attr_pads({0,0,0,0}).set_attr_strides({1,1,1,1});
auto conv_111 = op::Conv2D("conv111").set_input_x(conv_110).set_input_filter(weight).set_attr_pads({0,0,0,0}).set_attr_strides({1,1,1,1});
auto conv_112 = op::Conv2D("conv112").set_input_x(conv_111).set_input_filter(weight).set_attr_pads({0,0,0,0}).set_attr_strides({1,1,1,1});
auto conv_113 = op::Conv2D("conv113").set_input_x(conv_112).set_input_filter(weight).set_attr_pads({0,0,0,0}).set_attr_strides({1,1,1,1});
auto conv_114 = op::Conv2D("conv114").set_input_x(conv_113).set_input_filter(weight).set_attr_pads({0,0,0,0}).set_attr_strides({1,1,1,1});
auto conv_115 = op::Conv2D("conv115").set_input_x(conv_114).set_input_filter(weight).set_attr_pads({0,0,0,0}).set_attr_strides({1,1,1,1});
auto conv_116 = op::Conv2D("conv116").set_input_x(conv_115).set_input_filter(weight).set_attr_pads({0,0,0,0}).set_attr_strides({1,1,1,1});
auto conv_117 = op::Conv2D("conv117").set_input_x(conv_116).set_input_filter(weight).set_attr_pads({0,0,0,0}).set_attr_strides({1,1,1,1});
auto conv_118 = op::Conv2D("conv118").set_input_x(conv_117).set_input_filter(weight).set_attr_pads({0,0,0,0}).set_attr_strides({1,1,1,1});
auto conv_119 = op::Conv2D("conv119").set_input_x(conv_118).set_input_filter(weight).set_attr_pads({0,0,0,0}).set_attr_strides({1,1,1,1});
auto conv_120 = op::Conv2D("conv120").set_input_x(conv_119).set_input_filter(weight).set_attr_pads({0,0,0,0}).set_attr_strides({1,1,1,1});
auto conv_121 = op::Conv2D("conv121").set_input_x(conv_120).set_input_filter(weight).set_attr_pads({0,0,0,0}).set_attr_strides({1,1,1,1});
auto conv_122 = op::Conv2D("conv122").set_input_x(conv_121).set_input_filter(weight).set_attr_pads({0,0,0,0}).set_attr_strides({1,1,1,1});
auto conv_123 = op::Conv2D("conv123").set_input_x(conv_122).set_input_filter(weight).set_attr_pads({0,0,0,0}).set_attr_strides({1,1,1,1});
auto conv_124 = op::Conv2D("conv124").set_input_x(conv_123).set_input_filter(weight).set_attr_pads({0,0,0,0}).set_attr_strides({1,1,1,1});
auto conv_125 = op::Conv2D("conv125").set_input_x(conv_124).set_input_filter(weight).set_attr_pads({0,0,0,0}).set_attr_strides({1,1,1,1});
auto conv_126 = op::Conv2D("conv126").set_input_x(conv_125).set_input_filter(weight).set_attr_pads({0,0,0,0}).set_attr_strides({1,1,1,1});
auto conv_127 = op::Conv2D("conv127").set_input_x(conv_126).set_input_filter(weight).set_attr_pads({0,0,0,0}).set_attr_strides({1,1,1,1});
auto conv_128 = op::Conv2D("conv128").set_input_x(conv_127).set_input_filter(weight).set_attr_pads({0,0,0,0}).set_attr_strides({1,1,1,1});
auto conv_129 = op::Conv2D("conv129").set_input_x(conv_128).set_input_filter(weight).set_attr_pads({0,0,0,0}).set_attr_strides({1,1,1,1});
auto conv_130 = op::Conv2D("conv130").set_input_x(conv_129).set_input_filter(weight).set_attr_pads({0,0,0,0}).set_attr_strides({1,1,1,1});

std::vector<Operator> inputs{data};
std::vector<Operator> outputs{conv_130};
graph.SetInputs(inputs).SetOutputs(outputs);
}

int GetDatTypeSize(DataType dt) {
int dailation = 1;
if (dt == ge::DT_FLOAT)
dailation = 4;
else if (dt == ge::DT_FLOAT16)
dailation = 2;
else if (dt == ge::DT_INT16)
dailation = 2;
else if (dt == ge::DT_UINT16)
dailation = 2;
else if (dt == ge::DT_INT32)
dailation = 4;
else if (dt == ge::DT_UINT32)
dailation = 4;
else if (dt == ge::DT_INT64)
dailation = 8;
else if (dt == ge::DT_UINT64)
dailation = 8;
else if (dt == ge::DT_INT8)
dailation = 1;

return dailation;
}

int buildConvGraph_new(Graph &graph, std::vector<TensorDesc> desc_var, std::vector<std::string> name_var, int flag,
Format format) {
auto data_x_shape = op::Data("xShape").set_attr_index(0);
auto var = op::Variable(name_var[0]);
auto var1 = op::Variable(name_var[1]); //add one seat of ApplyMomentum()
auto label1 = op::Variable(name_var[2]); //add one seat of ApplyMomentum()
auto conv2dgrad = op::Conv2DBackpropFilterD("output_1");
auto test2 = op::ApplyMomentum();

var.update_output_desc_y(desc_var[0]);
var1.update_output_desc_y(desc_var[1]);
label1.update_output_desc_y(desc_var[2]);

graph.AddOp(var);
graph.AddOp(var1);
graph.AddOp(label1);

auto conv2d = op::Conv2D().set_input_x(data_x_shape).set_input_filter(var).set_attr_strides({1, 1, 1, 1}).set_attr_pads({0,0,0,0});
update_op_format(conv2d, format);
ge::TensorDesc tensor_desc_w = conv2d.GetInputDesc("filter");
tensor_desc_w.SetFormat(format);
conv2d.UpdateInputDesc("filter", tensor_desc_w);

if (flag >= 1) {
conv2dgrad.set_input_x(data_x_shape)
.set_attr_filter_size(desc_var[0].GetShape().GetDims())
.set_input_out_backprop(conv2d)
.set_attr_strides({1, 1, 1, 1})
.set_attr_pads({0, 0, 0, 0});
update_op_format(conv2dgrad, format);
graph.AddOp(conv2dgrad);
}
if (flag >= 2) {
// set conv2dgrad var
test2.set_input_accum(var1)
.set_input_grad(conv2dgrad)
.set_input_lr(label1)
.set_input_momentum(label1)
.set_input_var(var);
graph.AddOp(test2);
}

std::vector<Operator> inputs{data_x_shape}; // set all val
std::vector<Operator> outputs{conv2d};
graph.SetInputs(inputs).SetOutputs(outputs);
graph.AddOp(conv2d);

return 0;
}

/// load bin data_fail
/// input_path: path of bin data_file
/// shapes: the shape of Tensor
/// ft: the format of Tensor
/// dt: the dataType of Tensor
Tensor load_variable_input_data(string input_path, std::vector<int64_t> shapes, Format ft, DataType dt) {
vector<uint64_t> dim_info1;

uint8_t *input_data = (uint8_t *)readTestDataFile(input_path, dim_info1); // common.h
TensorDesc input_tensor_desc = TensorDesc(ge::Shape(shapes), ft, dt);
input_tensor_desc.SetRealDimCnt(shapes.size());
Tensor input_tensor = Tensor(input_tensor_desc, input_data, GetDatTypeSize(dt) * dim_info1[dim_info1[0] + 1]);
return input_tensor;
}

+ 0
- 102
tests/st/resnet50/common.h View File

@@ -1,102 +0,0 @@
/**
* Copyright 2019-2020 Huawei Technologies Co., Ltd
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/

#ifndef ST_RESNET50_GE_COMMON_H_
#define ST_RESNET50_GE_COMMON_H_
#include "common/ge_inner_error_codes.h"
#include "utils/tensor_utils.h"

#define MY_USER_GE_LOGI(...) GE_LOG_INFO(1, __VA_ARGS__)
#define MY_USER_GE_LOGW(...) GE_LOG_WARN(1, __VA_ARGS__)
#define MY_USER_GE_LOGE(...) GE_LOG_ERROR(1, 3, __VA_ARGS__)

#ifndef USER_GE_LOGI
#define USER_GE_LOGI MY_USER_GE_LOGI
#endif // USER_GE_LOGI

#ifndef USER_GE_LOGW
#define USER_GE_LOGW MY_USER_GE_LOGW
#endif // USER_GE_LOGW

#ifndef USER_GE_LOGE
#define USER_GE_LOGE MY_USER_GE_LOGE
#endif // USER_GE_LOGE

/// train_flag is 0 when infer, train_flag is 1 when train.this param is set for RunGranph_readData() and
/// RunGraph_initData()
#define TRAIN_FLAG_INFER "infer"
#define TRAIN_FLAG_TRAIN "train"

#include <string.h>
#include <unistd.h>
#include <algorithm>
#include <chrono>
#include <iostream>
#include <thread>
#include <vector>

#include "ge_api.h"
#include "graph.h"
#include "ptest.h"
#include "ops/all_ops.h"
using namespace std;
using namespace ge;

// read bin file and compile result
void update_op_format(Operator ops, Format format = ge::FORMAT_NCHW);
void getDimInfo(FILE *fp, std::vector<uint64_t> &dim_info);
void *readTestDataFile(std::string infile, std::vector<uint64_t> &dim_info);
void *readUint8TestDataFile(std::string infile, int size);
bool allclose(float *a, float *b, uint64_t count, float rtol, float atol);
bool compFp32WithTData(float *actual_output_data, std::string expected_data_file, float rtol, float atol);
Tensor load_variable_input_data(string input_path, std::vector<int64_t> shapes, Format ft = ge::FORMAT_NCHW,
DataType dt = ge::DT_FLOAT);
// constructor Tensor
int GetDatTypeSize(DataType dt);
ge::Tensor genTensor(std::vector<int64_t> tensor_shape, Format format = ge::FORMAT_NCHW, DataType dt = ge::DT_FLOAT);
ge::Tensor genTensor_withVaule(std::vector<int64_t> tensor_shape, float value = 1);
Tensor genTesnor_Shape_as_data(std::vector<int64_t> tensor_shape);
// Init GE
ge::Status GEInitialize_api(string train_flag = "0", string run_mode_path = "0");
ge::Status GEInitialize_api_new(string train_flag = "infer", string run_mode = "fe");
ge::Status GEFinalize_api();
// constructor session and build graph
ge::Session *create_aipp_session();
ge::Session *create_session();
ge::Status session_add_and_run_graph(ge::Session *session, uint32_t graphId, Graph &graph, std::vector<Tensor> inputs,
std::vector<Tensor> &outputs);

// common interface for infer
int RunGraph_initData(Graph &graph, string op_name, map<string, std::vector<int64_t>> attr_test,
string train_flag = "infer", string run_mode_path = "fe");
void Inputs_load_Data(string op_name, std::vector<Tensor> &input, map<string, std::vector<int64_t>> attr_test,
Format format = ge::FORMAT_NCHW, DataType dt = ge::DT_FLOAT);
bool comparaData(std::vector<Tensor> &output, string op_name, map<string, std::vector<int64_t>> attr_test);
int RunGraph_readData(Graph &graph, string op_name, map<string, std::vector<int64_t>> attr_test,
string train_flag = "infer", string run_mode_path = "fe", Format format = ge::FORMAT_NCHW,
DataType dt = ge::DT_FLOAT);

// common interface for train
int buildCheckPointGraph(Graph &graph, map<string, TensorDesc> variables);
int buildInitGraph(Graph &graph, std::vector<TensorDesc> desc_var, std::vector<std::string> name_var,
std::vector<float> values_var);
int buildInitGraph_other_dataType(Graph &graph, std::vector<TensorDesc> desc_var, std::vector<std::string> name_var);

bool build_multi_input_multi_output_graph(Graph &graph);
void build_big_graph(Graph &graph, map<string, std::vector<int64_t>> attr);
int buildConvGraph_new(Graph &graph, std::vector<TensorDesc> desc_var, std::vector<std::string> name_var, int flag = 2);

#endif // ST_RESNET50_GE_COMMON_H_

+ 0
- 225
tests/st/resnet50/ptest.h View File

@@ -1,225 +0,0 @@
/**
* Copyright 2019-2020 Huawei Technologies Co., Ltd
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/

#ifndef ST_RESNET50_PTEST_H_
#define ST_RESNET50_PTEST_H_

#include <stdarg.h>
#include <string.h>
#include <exception>
#include <functional>
#include <iostream>
#include <list>
#include <map>
#include <memory>
#include <string>

namespace ptest {
class assertion_error : public std::exception {
public:
const char *what() const throw() { return "Assertion Exception"; }
};

class TestFixture {
public:
virtual void SetUp() {}
virtual void TearDown() {}
void Run() { _func(); }
void BindFunction(std::function<void(void)> function) { _func = function; }
void SetName(const std::string &name) { _name = name; }
std::string Name() const { return _name; }
virtual ~TestFixture() {}

private:
std::function<void(void)> _func;
std::string _name;
};

enum TestResult { SUCCESS, FAILED, UNAVAILABLE, UNKNOWN, NOCASEFOUND };

class TestManager {
public:
static TestManager &GetSingleton() {
static TestManager instance;
return instance;
}
void RegisterTest(const std::string &name, TestFixture *fixture) { _testfixtures[name] = fixture; }

const std::string GetRunningTestcaseName() const { return _running_testcase_name; }

const std::list<std::string> GetAllTestNames() const {
std::list<std::string> result;
for (auto &t : _testfixtures) {
result.push_back(t.first);
}
return result;
}

TestResult RunTest(const std::string &name) {
if (_testfixtures.find(name) == _testfixtures.end()) {
return NOCASEFOUND;
}

_running_testcase_name = name;

do {
SetTestResult(name, UNKNOWN);
_testfixtures[name]->SetUp();
if (_testresults[name] == FAILED) {
_testresults[name] = UNAVAILABLE;
break;
}
SetTestResult(name, SUCCESS);
try {
_testfixtures[name]->Run();
} catch (assertion_error &e) {
// Do nothing as the error has been handled by the TestManager.
}
_testfixtures[name]->TearDown();
} while (0);

return _testresults[name];
}
void SetTestResult(const std::string &name, TestResult result) { _testresults[name] = result; }
TestResult GetTestResult(const std::string &name) { return _testresults[name]; }

private:
std::map<std::string, TestFixture *> _testfixtures;
std::map<std::string, TestResult> _testresults;
std::string _running_testcase_name;
};

class TestFixtureRegister {
public:
TestFixtureRegister(const std::string &name, TestFixture *fixture, std::function<void(void)> function) {
fixture->BindFunction(function);
fixture->SetName(name);
TestManager::GetSingleton().RegisterTest(name, fixture);
}
};
} // namespace ptest

#define _STR(x) #x
#define _EMPTY_NAMESPACE

#define _TEST(NAMESPACE, FIXTURECLASS, TESTNAME, CASENAME) \
void g_func_##TESTNAME##_##CASENAME(void); \
NAMESPACE::FIXTURECLASS g_fixture_##TESTNAME##_##CASENAME; \
ptest::TestFixtureRegister g_register_##TESTNAME##_##CASENAME( \
_STR(TESTNAME##_##CASENAME), &g_fixture_##TESTNAME##_##CASENAME, g_func_##TESTNAME##_##CASENAME); \
void g_func_##TESTNAME##_##CASENAME(void)

#define TEST(TESTNAME, CASENAME) _TEST(ptest, TestFixture, TESTNAME, CASENAME)

#define TEST_F(TESTFIXTURE, CASENAME) _TEST(_EMPTY_NAMESPACE, TESTFIXTURE, TESTFIXTURE, CASENAME)

#define EXPECT_TRUE(X) \
do { \
if (!(X)) { \
std::string test_name = ptest::TestManager::GetSingleton().GetRunningTestcaseName(); \
ptest::TestManager::GetSingleton().SetTestResult(test_name, ptest::FAILED); \
std::cerr << #X << "Expectation Failed\n" \
<< "Testcase Name: " << test_name << "\n" \
<< "File: " __FILE__ << "\tLine:" << __LINE__ << std::endl; \
} \
} while (0);

// With the macro definition ensures that the compiler can detect compiler warning.
#define Max_Log_Len 1024
#define PRINT_ERR(lpszFormat, ...) \
do { \
char szTmpBuf[Max_Log_Len + 1] = {0}; \
snprintf(szTmpBuf, Max_Log_Len, lpszFormat, ##__VA_ARGS__); \
std::cerr << szTmpBuf << std::endl; \
} while (0)

// Increase the content of print error messages and error to facilitate rapid analysis
#define EXPECT_TRUE_C(X, ERR_TYPE, format, ...) \
do { \
if (!(X)) { \
std::string test_name = ptest::TestManager::GetSingleton().GetRunningTestcaseName(); \
ptest::TestManager::GetSingleton().SetTestResult(test_name, ptest::FAILED); \
std::cerr << #X << " Expectation Failed." \
<< "Testcase Name: " << test_name << " File:" __FILE__ << " Line:" << __LINE__ << std::endl; \
PRINT_ERR("[" ERR_TYPE "]" format, ##__VA_ARGS__); \
} \
} while (0)

#define ASSERT_TRUE(X) \
do { \
if (!(X)) { \
std::string test_name = ptest::TestManager::GetSingleton().GetRunningTestcaseName(); \
ptest::TestManager::GetSingleton().SetTestResult(test_name, ptest::FAILED); \
std::cerr << #X << "Assertion Failed\n" \
<< "Testcase Name: " << test_name << "\n" \
<< "File: " __FILE__ << "\tLine:" << __LINE__ << std::endl; \
throw ptest::assertion_error(); \
} \
} while (0);

// Add printing error information and error line content for quick analysis
#define ASSERT_TRUE_C(X, ERR_TYPE, format, ...) \
do { \
if (!(X)) { \
std::string test_name = ptest::TestManager::GetSingleton().GetRunningTestcaseName(); \
ptest::TestManager::GetSingleton().SetTestResult(test_name, ptest::FAILED); \
std::cerr << #X << " Assertion Failed." \
<< "Testcase Name: " << test_name << " File:" __FILE__ << " Line:" << __LINE__ << std::endl; \
PRINT_ERR("[" ERR_TYPE "]" format, ##__VA_ARGS__); \
throw ptest::assertion_error(); \
} \
} while (0);

#define CONFIG_ERR "CONFIG_ERR"
#define LOAD_MODEL_ERR "LOAD_MODEL_ERR"
#define FILE_READ_ERR "FILE_READ_ERR"
#define RUN_ERROR "RUN_ERROR"
#define MEM_ERROR "MEM_ERROR"
#define RESULT_ERR "RESULT_ERR"

#define EXPECT_FALSE(X) EXPECT_TRUE(!(X))
#define EXPECT_EQ(X, Y) EXPECT_TRUE(((X) == (Y)))
#define EXPECT_NE(X, Y) EXPECT_TRUE(((X) != (Y)))
#define EXPECT_GT(X, Y) EXPECT_TRUE(((X) > (Y)))
#define EXPECT_GE(X, Y) EXPECT_TRUE(((X) >= (Y)))
#define EXPECT_LT(X, Y) EXPECT_TRUE(((X) < (Y)))
#define EXPECT_LE(X, Y) EXPECT_TRUE(((X) <= (Y)))

#define EXPECT_FALSE_C(X, ERR_TYPE, format, ...) EXPECT_TRUE_C(!(X), ERR_TYPE, format, ##__VA_ARGS__)
#define EXPECT_EQ_C(X, Y, ERR_TYPE, format, ...) EXPECT_TRUE_C(((X) == (Y)), ERR_TYPE, format, ##__VA_ARGS__)
#define EXPECT_NE_C(X, Y, ERR_TYPE, format, ...) EXPECT_TRUE_C(((X) != (Y)), ERR_TYPE, format, ##__VA_ARGS__)
#define EXPECT_GT_C(X, Y, ERR_TYPE, format, ...) EXPECT_TRUE_C(((X) > (Y)), ERR_TYPE, format, ##__VA_ARGS__)
#define EXPECT_GE_C(X, Y, ERR_TYPE, format, ...) EXPECT_TRUE_C(((X) >= (Y)), ERR_TYPE, format, ##__VA_ARGS__)
#define EXPECT_LT_C(X, Y, ERR_TYPE, format, ...) EXPECT_TRUE_C(((X) < (Y)), ERR_TYPE, format, ##__VA_ARGS__)
#define EXPECT_LE_C(X, Y, ERR_TYPE, format, ...) EXPECT_TRUE_C(((X) <= (Y)), ERR_TYPE, format, ##__VA_ARGS__)

#define ASSERT_FALSE(X) ASSERT_TRUE(!(X))
#define ASSERT_EQ(X, Y) ASSERT_TRUE(((X) == (Y)))
#define ASSERT_NE(X, Y) ASSERT_TRUE(((X) != (Y)))
#define ASSERT_GT(X, Y) ASSERT_TRUE(((X) > (Y)))
#define ASSERT_GE(X, Y) ASSERT_TRUE(((X) >= (Y)))
#define ASSERT_LT(X, Y) ASSERT_TRUE(((X) < (Y)))
#define ASSERT_LE(X, Y) ASSERT_TRUE(((X) <= (Y)))

#define ASSERT_FALSE_C(X, ERR_TYPE, format, ...) ASSERT_TRUE_C(!(X), ERR_TYPE, format, ##__VA_ARGS__)
#define ASSERT_EQ_C(X, Y, ERR_TYPE, format, ...) ASSERT_TRUE_C(((X) == (Y)), ERR_TYPE, format, ##__VA_ARGS__)
#define ASSERT_NE_C(X, Y, ERR_TYPE, format, ...) ASSERT_TRUE_C(((X) != (Y)), ERR_TYPE, format, ##__VA_ARGS__)
#define ASSERT_GT_C(X, Y, ERR_TYPE, format, ...) ASSERT_TRUE_C(((X) > (Y)), ERR_TYPE, format, ##__VA_ARGS__)
#define ASSERT_GE_C(X, Y, ERR_TYPE, format, ...) ASSERT_TRUE_C(((X) >= (Y)), ERR_TYPE, format, ##__VA_ARGS__)
#define ASSERT_LT_C(X, Y, ERR_TYPE, format, ...) ASSERT_TRUE_C(((X) < (Y)), ERR_TYPE, format, ##__VA_ARGS__)
#define ASSERT_LE_C(X, Y, ERR_TYPE, format, ...) ASSERT_TRUE_C(((X) <= (Y)), ERR_TYPE, format, ##__VA_ARGS__)

#endif // ST_RESNET50_PTEST_H_

+ 0
- 852
tests/st/resnet50/resnet50_train.cc View File

@@ -1,852 +0,0 @@
/**
* Copyright 2019-2020 Huawei Technologies Co., Ltd
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/

#include <assert.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <algorithm>
#include <chrono>
#include <ctime>
#include <sstream>

#include "common.h"
#include "ge_api.h"
#include "graph.h"
#include "ops/all_ops.h"
#include "types.h"
#include "utils/tensor_utils.h"

using namespace std;
using namespace ge;
using namespace op;

typedef bool (*Func)(Graph &graph);

#define PADDING_MODE 6
#define GRAD_PADDING_MODE 3
vector<int64_t> pad_1{1, 1, 1, 1};
vector<int64_t> pad_0{0, 0, 0, 0};
vector<int64_t> stride_1{1, 1};
vector<int64_t> stride_2{2, 2};

// (int out_channels, int h, int w, vector<uint_64> stride{1,1}, vector<uint_64> pad{1,1,1,1}, op::Data() input)
#define GENERATE_CONV_VAR(LAYER, BLK, OPNUM, in_channels, out_channels, h, w, stride, pad, input) \
auto &LAYER##_##BLK##_##OPNUM##_input = input; \
\
TensorDesc LAYER##_##BLK##_##OPNUM##_desc(ge::Shape({out_channels, in_channels, h, w}), FORMAT_NCHW, DT_FLOAT); \
auto LAYER##_##BLK##_##OPNUM##_weight = op::Variable(string(#LAYER) + string(#BLK) + string(#OPNUM) + "_weight"); \
LAYER##_##BLK##_##OPNUM##_weight.update_output_desc_y(LAYER##_##BLK##_##OPNUM##_desc); \
\
auto LAYER##_##BLK##_##OPNUM##_mom_weight = \
op::Variable(string(#LAYER) + string(#BLK) + string(#OPNUM) + "_mom_weight"); \
LAYER##_##BLK##_##OPNUM##_mom_weight.update_output_desc_y(LAYER##_##BLK##_##OPNUM##_desc); \
LAYER##_##BLK##_##OPNUM##_mom_weight.update_input_desc_x(LAYER##_##BLK##_##OPNUM##_desc); \
\
cout << string(#LAYER) + string(#BLK) + string(#OPNUM) << "'s weight shape is:" << in_channels << out_channels << h \
<< w << endl; \
cout << string(#LAYER) + string(#BLK) + string(#OPNUM) \
<< "'s input_x op's shape is:" << input.GetOutputDesc("y").GetShape().GetDim(2) << endl; \
auto LAYER##_##BLK##_##OPNUM##_tmp_dims = input.GetOutputDesc("y").GetShape().GetDims(); \
for (auto LAYER##_##BLK##_##OPNUM##_tmp_it = LAYER##_##BLK##_##OPNUM##_tmp_dims.begin(); \
LAYER##_##BLK##_##OPNUM##_tmp_it != LAYER##_##BLK##_##OPNUM##_tmp_dims.end(); \
LAYER##_##BLK##_##OPNUM##_tmp_it++) { \
cout << *LAYER##_##BLK##_##OPNUM##_tmp_it; \
} \
cout << endl; \
\
auto LAYER##_##BLK##_##OPNUM = op::Conv2D(string(#LAYER) + string(#BLK) + string(#OPNUM)) \
.set_input_x(input, "y") \
.set_input_filter(LAYER##_##BLK##_##OPNUM##_weight) \
.set_attr_strides({1, 1, stride[0], stride[1]}) \
.set_attr_pads(pad) \
.set_attr_data_format("NCHW"); \
update_op_format(LAYER##_##BLK##_##OPNUM);

#define GENERATE_CONSTANT(LAYER, BLK, OPNUM, CONSTNAME) \
Tensor LAYER##_##BLK##_##OPNUM##_##CONSTNAME##_tensor; \
float *LAYER##_##BLK##_##OPNUM##_##CONSTNAME##_data = new float[LAYER##_##BLK##_##OPNUM##_size]; \
for (int i = 0; i < (int)LAYER##_##BLK##_##OPNUM##_size; i++) { \
*(LAYER##_##BLK##_##OPNUM##_##CONSTNAME##_data + i) = 0.01; \
} \
LAYER##_##BLK##_##OPNUM##_##CONSTNAME##_tensor.SetData((uint8_t *)LAYER##_##BLK##_##OPNUM##_##CONSTNAME##_data, \
LAYER##_##BLK##_##OPNUM##_size * sizeof(float)); \
LAYER##_##BLK##_##OPNUM##_##CONSTNAME##_tensor.SetTensorDesc(LAYER##_##BLK##_##OPNUM##_desc); \
\
auto LAYER##_##BLK##_##OPNUM##_##CONSTNAME##_constant = \
op::Constant().set_attr_value(LAYER##_##BLK##_##OPNUM##_##CONSTNAME##_tensor); \
LAYER##_##BLK##_##OPNUM##_##CONSTNAME##_constant.update_output_desc_y(LAYER##_##BLK##_##OPNUM##_desc); \
delete[] LAYER##_##BLK##_##OPNUM##_##CONSTNAME##_data;

#define GENERATE_CONV_VAR_VAR(LAYER, BLK, OPNUM, in_channels, out_channels, h, w, stride, pad, input) \
TensorDesc LAYER##_##BLK##_##OPNUM##_desc(ge::Shape({out_channels, in_channels, h, w}), FORMAT_NCHW, DT_FLOAT); \
uint32_t LAYER##_##BLK##_##OPNUM##_size = LAYER##_##BLK##_##OPNUM##_desc.GetShape().GetShapeSize(); \
auto LAYER##_##BLK##_##OPNUM##_weight = op::Variable(string(#LAYER) + string(#BLK) + string(#OPNUM) + "_weight"); \
LAYER##_##BLK##_##OPNUM##_weight.update_output_desc_y(LAYER##_##BLK##_##OPNUM##_desc); \
\
auto LAYER##_##BLK##_##OPNUM##_mom_weight = \
op::Variable(string(#LAYER) + string(#BLK) + string(#OPNUM) + "_mom_weight"); \
LAYER##_##BLK##_##OPNUM##_mom_weight.update_output_desc_y(LAYER##_##BLK##_##OPNUM##_desc); \
\
GENERATE_CONSTANT(LAYER, BLK, OPNUM, weight); \
auto LAYER##_##BLK##_##OPNUM##_weight_assign = op::Assign() \
.set_input_ref(LAYER##_##BLK##_##OPNUM##_weight) \
.set_input_value(LAYER##_##BLK##_##OPNUM##_weight_constant); \
\
GENERATE_CONSTANT(LAYER, BLK, OPNUM, mom_weight); \
auto LAYER##_##BLK##_##OPNUM##_mom_weight_assign = \
op::Assign() \
.set_input_ref(LAYER##_##BLK##_##OPNUM##_mom_weight) \
.set_input_value(LAYER##_##BLK##_##OPNUM##_mom_weight_constant); \
\
input.push_back(LAYER##_##BLK##_##OPNUM##_weight); \
input.push_back(LAYER##_##BLK##_##OPNUM##_mom_weight);

// (int out_channels, Operator& input)
#define GENERATE_BN_VAR(LAYER, BLK, OPNUM, out_channels, input) \
auto &LAYER##_##BLK##_##OPNUM##_input = input; \
\
TensorDesc LAYER##_##BLK##_##OPNUM##_desc(ge::Shape({1, out_channels, 1, 1}), FORMAT_NCHW, DT_FLOAT); \
auto LAYER##_##BLK##_##OPNUM##_scale = op::Variable(string(#LAYER) + string(#BLK) + string(#OPNUM) + "_scale"); \
LAYER##_##BLK##_##OPNUM##_scale.update_output_desc_y(LAYER##_##BLK##_##OPNUM##_desc); \
\
auto LAYER##_##BLK##_##OPNUM##_mom_scale = \
op::Variable(string(#LAYER) + string(#BLK) + string(#OPNUM) + "_mom_scale"); \
LAYER##_##BLK##_##OPNUM##_mom_scale.update_output_desc_y(LAYER##_##BLK##_##OPNUM##_desc); \
\
auto LAYER##_##BLK##_##OPNUM##_b = op::Variable(string(#LAYER) + string(#BLK) + string(#OPNUM) + "_b"); \
LAYER##_##BLK##_##OPNUM##_b.update_output_desc_y(LAYER##_##BLK##_##OPNUM##_desc); \
\
auto LAYER##_##BLK##_##OPNUM##_mom_b = op::Variable(string(#LAYER) + string(#BLK) + string(#OPNUM) + "_mom_b"); \
LAYER##_##BLK##_##OPNUM##_mom_b.update_output_desc_y(LAYER##_##BLK##_##OPNUM##_desc); \
\
auto LAYER##_##BLK##_##OPNUM##_mean = op::Variable(string(#LAYER) + string(#BLK) + string(#OPNUM) + "_mean"); \
LAYER##_##BLK##_##OPNUM##_mean.update_output_desc_y(LAYER##_##BLK##_##OPNUM##_desc); \
auto LAYER##_##BLK##_##OPNUM##_variance = \
op::Variable(string(#LAYER) + string(#BLK) + string(#OPNUM) + "_variance"); \
LAYER##_##BLK##_##OPNUM##_variance.update_output_desc_y(LAYER##_##BLK##_##OPNUM##_desc); \
\
auto LAYER##_##BLK##_##OPNUM = op::FusedBatchNorm(string(#LAYER) + string(#BLK) + string(#OPNUM)) \
.set_input_x(input, "y") \
.set_input_scale(LAYER##_##BLK##_##OPNUM##_scale) \
.set_input_b(LAYER##_##BLK##_##OPNUM##_b) \
.set_input_mean(LAYER##_##BLK##_##OPNUM##_mean) \
.set_input_variance(LAYER##_##BLK##_##OPNUM##_variance) \
.set_attr_mode(1) \
.set_attr_epsilon(1e-5) \
.set_attr_is_training(true);

#define GENERATE_BN_VAR_VAR(LAYER, BLK, OPNUM, out_channels, input) \
TensorDesc LAYER##_##BLK##_##OPNUM##_desc(ge::Shape({1, out_channels, 1, 1}), FORMAT_NCHW, DT_FLOAT); \
uint32_t LAYER##_##BLK##_##OPNUM##_size = LAYER##_##BLK##_##OPNUM##_desc.GetShape().GetShapeSize(); \
auto LAYER##_##BLK##_##OPNUM##_scale = op::Variable(string(#LAYER) + string(#BLK) + string(#OPNUM) + "_scale"); \
LAYER##_##BLK##_##OPNUM##_scale.update_output_desc_y(LAYER##_##BLK##_##OPNUM##_desc); \
\
auto LAYER##_##BLK##_##OPNUM##_mom_scale = \
op::Variable(string(#LAYER) + string(#BLK) + string(#OPNUM) + "_mom_scale"); \
LAYER##_##BLK##_##OPNUM##_mom_scale.update_output_desc_y(LAYER##_##BLK##_##OPNUM##_desc); \
\
auto LAYER##_##BLK##_##OPNUM##_b = op::Variable(string(#LAYER) + string(#BLK) + string(#OPNUM) + "_b"); \
LAYER##_##BLK##_##OPNUM##_b.update_output_desc_y(LAYER##_##BLK##_##OPNUM##_desc); \
\
auto LAYER##_##BLK##_##OPNUM##_mom_b = op::Variable(string(#LAYER) + string(#BLK) + string(#OPNUM) + "_mom_b"); \
LAYER##_##BLK##_##OPNUM##_mom_b.update_output_desc_y(LAYER##_##BLK##_##OPNUM##_desc); \
\
auto LAYER##_##BLK##_##OPNUM##_mean = op::Variable(string(#LAYER) + string(#BLK) + string(#OPNUM) + "_mean"); \
LAYER##_##BLK##_##OPNUM##_mean.update_output_desc_y(LAYER##_##BLK##_##OPNUM##_desc); \
auto LAYER##_##BLK##_##OPNUM##_variance = \
op::Variable(string(#LAYER) + string(#BLK) + string(#OPNUM) + "_variance"); \
LAYER##_##BLK##_##OPNUM##_variance.update_output_desc_y(LAYER##_##BLK##_##OPNUM##_desc); \
\
GENERATE_CONSTANT(LAYER, BLK, OPNUM, scale); \
\
auto LAYER##_##BLK##_##OPNUM##_scale_assign = op::Assign() \
.set_input_ref(LAYER##_##BLK##_##OPNUM##_scale) \
.set_input_value(LAYER##_##BLK##_##OPNUM##_scale_constant); \
GENERATE_CONSTANT(LAYER, BLK, OPNUM, mom_scale); \
\
auto LAYER##_##BLK##_##OPNUM##_mom_scale_assign = \
op::Assign() \
.set_input_ref(LAYER##_##BLK##_##OPNUM##_mom_scale) \
.set_input_value(LAYER##_##BLK##_##OPNUM##_mom_scale_constant); \
\
GENERATE_CONSTANT(LAYER, BLK, OPNUM, b); \
\
auto LAYER##_##BLK##_##OPNUM##_b_assign = \
op::Assign().set_input_ref(LAYER##_##BLK##_##OPNUM##_b).set_input_value(LAYER##_##BLK##_##OPNUM##_b_constant); \
\
GENERATE_CONSTANT(LAYER, BLK, OPNUM, mom_b); \
\
auto LAYER##_##BLK##_##OPNUM##_mom_b_assign = op::Assign() \
.set_input_ref(LAYER##_##BLK##_##OPNUM##_mom_b) \
.set_input_value(LAYER##_##BLK##_##OPNUM##_mom_b_constant); \
GENERATE_CONSTANT(LAYER, BLK, OPNUM, mean); \
\
auto LAYER##_##BLK##_##OPNUM##_mean_assign = op::Assign() \
.set_input_ref(LAYER##_##BLK##_##OPNUM##_mean) \
.set_input_value(LAYER##_##BLK##_##OPNUM##_mean_constant); \
\
GENERATE_CONSTANT(LAYER, BLK, OPNUM, variance); \
\
auto LAYER##_##BLK##_##OPNUM##_variance_assign = op::Assign() \
.set_input_ref(LAYER##_##BLK##_##OPNUM##_variance) \
.set_input_value(LAYER##_##BLK##_##OPNUM##_variance_constant); \
\
input.push_back(LAYER##_##BLK##_##OPNUM##_scale); \
input.push_back(LAYER##_##BLK##_##OPNUM##_mom_scale); \
input.push_back(LAYER##_##BLK##_##OPNUM##_b); \
input.push_back(LAYER##_##BLK##_##OPNUM##_mom_b); \
input.push_back(LAYER##_##BLK##_##OPNUM##_mean); \
input.push_back(LAYER##_##BLK##_##OPNUM##_variance);

// (int out_channels, Operator& input)
#define GENERATE_RELU_VAR(LAYER, BLK, OPNUM, input) \
auto &LAYER##_##BLK##_##OPNUM##_input = input; \
auto LAYER##_##BLK##_##OPNUM = op::Relu(string(#LAYER) + string(#BLK) + string(#OPNUM)).set_input_x(input, "y");

// (int out_channels, Operator& input)
#define GENERATE_MAXPOOL_VAR(LAYER, BLK, OPNUM, input) \
auto &LAYER##_##BLK##_##OPNUM##_input = input; \
\
auto LAYER##_##BLK##_##OPNUM = op::MaxPoolWithArgmax(string(#LAYER) + string(#BLK) + string(#OPNUM)) \
.set_input_x(input, "y") \
.set_attr_ksize({1, 3, 3, 1}) \
.set_attr_padding("SAME") \
.set_attr_strides({1, 2, 2, 1});

// (int out_channels, Operator& input)
#define GENERATE_ADD_VAR(LAYER, BLK, OPNUM, input_x1, input_x2) \
auto LAYER##_##BLK##_##OPNUM = \
op::Add(string(#LAYER) + string(#BLK) + string(#OPNUM)).set_input_x1(input_x1, "y").set_input_x2(input_x2, "y");

// (int in_channels, int out_channels,vector<int64_t> stride{1,1}, Operator& input)
#define MAKE_RESIDUAL_BLOCK(LAYER, BLK, in_channels, out_channels, stride, input) \
auto &LAYER##_##BLK##_input = input; \
auto &LAYER##_##BLK##_stride = stride; \
int LAYER##_##BLK##_out_chls = out_channels / 4; \
\
GENERATE_CONV_VAR(LAYER, BLK, conv1, in_channels, LAYER##_##BLK##_out_chls, 1, 1, stride, pad_0, input); \
GENERATE_BN_VAR(LAYER, BLK, bn1, LAYER##_##BLK##_out_chls, LAYER##_##BLK##_conv1); \
GENERATE_RELU_VAR(LAYER, BLK, relu1, LAYER##_##BLK##_bn1); \
\
GENERATE_CONV_VAR(LAYER, BLK, conv2, LAYER##_##BLK##_out_chls, LAYER##_##BLK##_out_chls, 3, 3, stride_1, pad_1, \
LAYER##_##BLK##_relu1); \
GENERATE_BN_VAR(LAYER, BLK, bn2, LAYER##_##BLK##_out_chls, LAYER##_##BLK##_conv2); \
GENERATE_RELU_VAR(LAYER, BLK, relu2, LAYER##_##BLK##_bn2); \
\
GENERATE_CONV_VAR(LAYER, BLK, conv3, LAYER##_##BLK##_out_chls, out_channels, 1, 1, stride_1, pad_0, \
LAYER##_##BLK##_relu2); \
GENERATE_BN_VAR(LAYER, BLK, bn3, out_channels, LAYER##_##BLK##_conv3); \
\
GENERATE_CONV_VAR(LAYER, BLK, conv4, in_channels, out_channels, 1, 1, stride, pad_0, input); \
GENERATE_BN_VAR(LAYER, BLK, bn4, out_channels, LAYER##_##BLK##_conv4); \
\
GENERATE_ADD_VAR(LAYER, BLK, add5, LAYER##_##BLK##_bn3, LAYER##_##BLK##_bn4); \
GENERATE_RELU_VAR(LAYER, BLK, relu5, LAYER##_##BLK##_add5); \
\
auto &LAYER##_##BLK##_output = LAYER##_##BLK##_relu5; \
auto &LAYER##_##BLK##_output_label = "y";

#define MAKE_RESIDUAL_BLOCK_VAR(LAYER, BLK, in_channels, out_channels, stride, input) \
int LAYER##_##BLK##_out_chls = out_channels / 4; \
GENERATE_CONV_VAR_VAR(LAYER, BLK, conv1, in_channels, LAYER##_##BLK##_out_chls, 1, 1, stride, pad_0, input); \
GENERATE_BN_VAR_VAR(LAYER, BLK, bn1, LAYER##_##BLK##_out_chls, input); \
\
GENERATE_CONV_VAR_VAR(LAYER, BLK, conv2, LAYER##_##BLK##_out_chls, LAYER##_##BLK##_out_chls, 3, 3, stride_1, pad_1, \
input); \
GENERATE_BN_VAR_VAR(LAYER, BLK, bn2, LAYER##_##BLK##_out_chls, input); \
\
GENERATE_CONV_VAR_VAR(LAYER, BLK, conv3, LAYER##_##BLK##_out_chls, out_channels, 1, 1, stride_1, pad_0, input); \
GENERATE_BN_VAR_VAR(LAYER, BLK, bn3, out_channels, input); \
\
GENERATE_CONV_VAR_VAR(LAYER, BLK, conv4, in_channels, out_channels, 1, 1, stride, pad_0, input); \
GENERATE_BN_VAR_VAR(LAYER, BLK, bn4, out_channels, input);

// (int in_channels, int out_channels,vector<int64_t> stride{1,1}, Operator& input)
#define MAKE_NORMAL_BLOCK(LAYER, BLK, in_channels, out_channels, stride, input) \
auto &LAYER##_##BLK##_input = input; \
auto &LAYER##_##BLK##_stride = stride; \
int LAYER##_##BLK##_out_chls = out_channels / 4; \
\
GENERATE_CONV_VAR(LAYER, BLK, conv1, in_channels, LAYER##_##BLK##_out_chls, 1, 1, stride, pad_0, input); \
GENERATE_BN_VAR(LAYER, BLK, bn1, LAYER##_##BLK##_out_chls, LAYER##_##BLK##_conv1); \
GENERATE_RELU_VAR(LAYER, BLK, relu1, LAYER##_##BLK##_bn1); \
\
GENERATE_CONV_VAR(LAYER, BLK, conv2, LAYER##_##BLK##_out_chls, LAYER##_##BLK##_out_chls, 3, 3, stride_1, pad_1, \
LAYER##_##BLK##_relu1); \
GENERATE_BN_VAR(LAYER, BLK, bn2, LAYER##_##BLK##_out_chls, LAYER##_##BLK##_conv2); \
GENERATE_RELU_VAR(LAYER, BLK, relu2, LAYER##_##BLK##_bn2); \
\
GENERATE_CONV_VAR(LAYER, BLK, conv3, LAYER##_##BLK##_out_chls, out_channels, 1, 1, stride_1, pad_0, \
LAYER##_##BLK##_relu2); \
GENERATE_BN_VAR(LAYER, BLK, bn3, out_channels, LAYER##_##BLK##_conv3); \
\
GENERATE_ADD_VAR(LAYER, BLK, add5, LAYER##_##BLK##_bn3, input); \
GENERATE_RELU_VAR(LAYER, BLK, relu5, LAYER##_##BLK##_add5); \
\
auto &LAYER##_##BLK##_output = LAYER##_##BLK##_relu5; \
auto &LAYER##_##BLK##_output_label = "y";

#define MAKE_NORMAL_BLOCK_VAR(LAYER, BLK, in_channels, out_channels, stride, input) \
int LAYER##_##BLK##_out_chls = out_channels / 4; \
GENERATE_CONV_VAR_VAR(LAYER, BLK, conv1, in_channels, LAYER##_##BLK##_out_chls, 1, 1, stride, pad_0, input); \
GENERATE_BN_VAR_VAR(LAYER, BLK, bn1, LAYER##_##BLK##_out_chls, input); \
\
GENERATE_CONV_VAR_VAR(LAYER, BLK, conv2, LAYER##_##BLK##_out_chls, LAYER##_##BLK##_out_chls, 3, 3, stride_1, pad_1, \
input); \
GENERATE_BN_VAR_VAR(LAYER, BLK, bn2, LAYER##_##BLK##_out_chls, input); \
\
GENERATE_CONV_VAR_VAR(LAYER, BLK, conv3, LAYER##_##BLK##_out_chls, out_channels, 1, 1, stride_1, pad_0, input); \
GENERATE_BN_VAR_VAR(LAYER, BLK, bn3, out_channels, input);

// (int in_channels, int out_channels,vector<int64_t> stride{1,1}, Operator& input)
#define MAKE_RESIDUAL_LAYER(LAYER, in_channels, out_channels, stride, input) \
MAKE_RESIDUAL_BLOCK(LAYER, blk1, in_channels, out_channels, stride, input); \
\
auto &LAYER##_output = LAYER##_blk1_output; \
auto &LAYER##_output_label = LAYER##_blk1_output_label;

#define MAKE_RESIDUAL_LAYER_VAR(LAYER, in_channels, out_channels, stride, input) \
MAKE_RESIDUAL_BLOCK_VAR(LAYER, blk1, in_channels, out_channels, stride, input);

// (int in_channels, int out_channels,vector<int64_t> stride{1,1}, Operator& input)
#define MAKE_NORMAL_LAYER(LAYER, in_channels, out_channels, stride, input) \
MAKE_NORMAL_BLOCK(LAYER, blk1, in_channels, out_channels, stride, input); \
\
auto &LAYER##_output = LAYER##_blk1_output; \
auto &LAYER##_output_label = LAYER##_blk1_output_label;

#define MAKE_NORMAL_LAYER_VAR(LAYER, in_channels, out_channels, stride, input) \
MAKE_NORMAL_BLOCK_VAR(LAYER, blk1, in_channels, out_channels, stride, input);

#define MAKE_RESNET50(input) \
MAKE_RESIDUAL_LAYER(layer1, 64, 256, stride_1, input) \
MAKE_NORMAL_LAYER(layer2, 256, 256, stride_1, layer1_output) \
MAKE_NORMAL_LAYER(layer3, 256, 256, stride_1, layer2_output) \
MAKE_RESIDUAL_LAYER(layer4, 256, 512, stride_2, layer3_output) \
MAKE_NORMAL_LAYER(layer5, 512, 512, stride_1, layer4_output) \
MAKE_NORMAL_LAYER(layer6, 512, 512, stride_1, layer5_output) \
MAKE_NORMAL_LAYER(layer7, 512, 512, stride_1, layer6_output) \
MAKE_RESIDUAL_LAYER(layer8, 512, 1024, stride_2, layer7_output) \
MAKE_NORMAL_LAYER(layer9, 1024, 1024, stride_1, layer8_output) \
MAKE_NORMAL_LAYER(layer10, 1024, 1024, stride_1, layer9_output) \
MAKE_NORMAL_LAYER(layer11, 1024, 1024, stride_1, layer10_output) \
MAKE_NORMAL_LAYER(layer12, 1024, 1024, stride_1, layer11_output) \
MAKE_NORMAL_LAYER(layer13, 1024, 1024, stride_1, layer12_output) \
MAKE_RESIDUAL_LAYER(layer14, 1024, 2048, stride_2, layer13_output) \
MAKE_NORMAL_LAYER(layer15, 2048, 2048, stride_1, layer14_output) \
MAKE_NORMAL_LAYER(layer16, 2048, 2048, stride_1, layer15_output) \
\
auto &resnet50_output = layer16_output; \
auto &resnet50_output_label = layer16_output_label;

#define MAKE_RESNET50_VAR(inputs) \
MAKE_RESIDUAL_LAYER_VAR(layer1, 64, 256, stride_1, inputs) \
MAKE_NORMAL_LAYER_VAR(layer2, 256, 256, stride_1, inputs) \
MAKE_NORMAL_LAYER_VAR(layer3, 256, 256, stride_1, inputs) \
MAKE_RESIDUAL_LAYER_VAR(layer4, 256, 512, stride_2, inputs) \
MAKE_NORMAL_LAYER_VAR(layer5, 512, 512, stride_1, inputs) \
MAKE_NORMAL_LAYER_VAR(layer6, 512, 512, stride_1, inputs) \
MAKE_NORMAL_LAYER_VAR(layer7, 512, 512, stride_1, inputs) \
MAKE_RESIDUAL_LAYER_VAR(layer8, 512, 1024, stride_2, inputs) \
MAKE_NORMAL_LAYER_VAR(layer9, 1024, 1024, stride_1, inputs) \
MAKE_NORMAL_LAYER_VAR(layer10, 1024, 1024, stride_1, inputs) \
MAKE_NORMAL_LAYER_VAR(layer11, 1024, 1024, stride_1, inputs) \
MAKE_NORMAL_LAYER_VAR(layer12, 1024, 1024, stride_1, inputs) \
MAKE_NORMAL_LAYER_VAR(layer13, 1024, 1024, stride_1, inputs) \
MAKE_RESIDUAL_LAYER_VAR(layer14, 1024, 2048, stride_2, inputs) \
MAKE_NORMAL_LAYER_VAR(layer15, 2048, 2048, stride_1, inputs) \
MAKE_NORMAL_LAYER_VAR(layer16, 2048, 2048, stride_1, inputs) \
//---------------------------------------------------------------------------------------------

// (Operator& input)
#define GENERATE_BIASADD_GRAD(LAYER, BLK, OPNUM, input) \
auto LAYER##_##BLK##_##OPNUM##_grad = \
op::BiasAddGrad(string(#LAYER) + string(#BLK) + string(#OPNUM) + string("grad")) \
.set_input_x(input, input.name_out_dx());

// (Operator& input)
#define GENERATE_MATMUL_GRAD(LAYER, BLK, OPNUM, input) \
auto LAYER##_##BLK##_##OPNUM##_grad = \
op::MatMul(string(#LAYER) + string(#BLK) + string(#OPNUM) + string("grad")).set_input_x1(input);

// (Operator& input)
#define GENERATE_RESHAPE_GRAD(LAYER, BLK, OPNUM, input) \
auto LAYER##_##BLK##_##OPNUM##_grad = \
op::Reshape(string(#LAYER) + string(#BLK) + string(#OPNUM) + string("grad")).set_input_tensor(input);

// (Operator& input_grad, Operator& input_maxpool)
#define GENERATE_MAXPOOL_GRAD(LAYER, BLK, OPNUM, input_grad, input_maxpool) \
auto LAYER##_##BLK##_##OPNUM##_grad = \
op::MaxPoolGradWithArgmax(string(#LAYER) + string(#BLK) + string(#OPNUM) + string("grad")) \
.set_input_x(LAYER##_##BLK##_##OPNUM##_input, "y") \
.set_input_grad(input_grad) \
.set_input_argmax(input_maxpool, input_maxpool.name_out_argmax()) \
.set_attr_ksize({1, 1, 3, 3}) \
.set_attr_strides({1, 1, 2, 2}) \
.set_attr_padding("SAME");

// (Operator& input_dy)
#define GENERATE_RELU_GRAD(LAYER, BLK, OPNUM, input_dy, dy_label) \
auto LAYER##_##BLK##_##OPNUM##_grad = op::ReluGrad(string(#LAYER) + string(#BLK) + string(#OPNUM) + string("grad")) \
.set_input_gradients(input_dy, dy_label) \
.set_input_features(LAYER##_##BLK##_##OPNUM, "y");

// (Operator& input_dy)
#define GENERATE_BN_GRAD(LAYER, BLK, OPNUM, input_dy) \
auto LAYER##_##BLK##_##OPNUM##_grad = \
op::FusedBatchNormGrad(string(#LAYER) + string(#BLK) + string(#OPNUM) + string("grad")) \
.set_input_dy(input_dy, "backprops") \
.set_input_x(LAYER##_##BLK##_##OPNUM##_input, "y") \
.set_input_scale(LAYER##_##BLK##_##OPNUM##_scale) \
.set_input_save_mean(LAYER##_##BLK##_##OPNUM, "save_mean") \
.set_input_save_inv_variance(LAYER##_##BLK##_##OPNUM, "save_inv_variance") \
.set_attr_epsilon(0.0001); \
\
auto LAYER##_##BLK##_##OPNUM##_momentum_scale = \
op::ApplyMomentum() \
.set_input_accum(LAYER##_##BLK##_##OPNUM##_mom_scale) \
.set_input_grad(LAYER##_##BLK##_##OPNUM##_grad, LAYER##_##BLK##_##OPNUM##_grad.name_out_bn_scale()) \
.set_input_lr(label1) \
.set_input_momentum(label1) \
.set_input_var(LAYER##_##BLK##_##OPNUM##_scale); \
\
auto LAYER##_##BLK##_##OPNUM##_momentum_b = \
op::ApplyMomentum() \
.set_input_accum(LAYER##_##BLK##_##OPNUM##_mom_b) \
.set_input_grad(LAYER##_##BLK##_##OPNUM##_grad, LAYER##_##BLK##_##OPNUM##_grad.name_out_bn_bias()) \
.set_input_lr(label1) \
.set_input_momentum(label1) \
.set_input_var(LAYER##_##BLK##_##OPNUM##_b);

// (Operator& input)
#define GENERATE_CONV_PROP_FILTER(LAYER, BLK, OPNUM, input_bngrad, stride) \
auto LAYER##_##BLK##_##OPNUM##_propfilter = \
op::Conv2DBackpropFilterD(string(#LAYER) + string(#BLK) + string(#OPNUM) + string("_propfilter")) \
.set_input_x(LAYER##_##BLK##_##OPNUM##_input, "y") \
.set_attr_filter_size(LAYER##_##BLK##_##OPNUM##_desc.GetShape().GetDims()) \
.set_input_out_backprop(input_bngrad, input_bngrad.name_out_dx()) \
.set_attr_strides(stride) \
.set_attr_pads({1, 1, 1, 1}); \
\
update_op_format(LAYER##_##BLK##_##OPNUM##_propfilter); \
auto LAYER##_##BLK##_##OPNUM##_momentum_weight = op::ApplyMomentum() \
.set_input_accum(LAYER##_##BLK##_##OPNUM##_mom_weight) \
.set_input_grad(LAYER##_##BLK##_##OPNUM##_propfilter) \
.set_input_lr(label1) \
.set_input_momentum(label1) \
.set_input_var(LAYER##_##BLK##_##OPNUM##_weight);

///.set_attr_input_size({input_bngrad.name_out_dx().GetOutputDesc().GetShape().GetDim(0),LAYER##_##BLK##_##OPNUM##_weight.GetOutputDesc().GetShape().GetDim(1),
///input_bngrad.name_out_dx().GetOutputDesc().GetShape().GetDim(2)*stride[2],
///input_bngrad.name_out_dx().GetOutputDesc().GetShape().GetDim(3)*stride[3]})
#define GENERATE_CONV_PROP_INPUT(LAYER, BLK, OPNUM, input_bngrad, stride) \
auto LAYER##_##BLK##_##OPNUM##_propinput = \
op::Conv2DBackpropInputD(string(#LAYER) + string(#BLK) + string(#OPNUM) + string("_propinput")) \
.set_attr_input_size(LAYER##_##BLK##_##OPNUM##_input.GetOutputDesc("y").GetShape().GetDims()) \
.set_input_filter(LAYER##_##BLK##_##OPNUM##_weight) \
.set_input_out_backprop(input_bngrad, input_bngrad.name_out_dx()) \
.set_attr_strides(stride) \
.set_attr_pads({1, 1, 1, 1}); \
cout << string(#LAYER) + string(#BLK) + string(#OPNUM) + "_propinput" \
<< "'s input_x op's shape is:" << input_bngrad.GetOutputDesc("dx").GetShape().GetDim(3) * stride[3] << endl; \
cout << string(#LAYER) + string(#BLK) + string(#OPNUM) + "_propinput" \
<< "'s input_x op's shape is:" << input_bngrad.GetOutputDesc("dx").GetShape().GetDim(2) * stride[2] << endl; \
\
update_op_format(LAYER##_##BLK##_##OPNUM##_propinput); \
auto &LAYER##_##BLK##_##OPNUM##_propinput_label = "y"

// (int out_channels, Operator& input)
#define GENERATE_ADD_GRAD(LAYER, BLK, OPNUM, input_x1, input_x1_label, input_x2, input_x2_label) \
auto LAYER##_##BLK##_##OPNUM##_grad = op::Add(string(#LAYER) + string(#BLK) + string(#OPNUM) + string("grad")) \
.set_input_x1(input_x1, input_x1_label) \
.set_input_x2(input_x2, input_x2_label);

// (Operator& input)
#define MAKE_RESIDUAL_BLOCK_GRAD(LAYER, BLK, input_dy, dy_label) \
GENERATE_RELU_GRAD(LAYER, BLK, relu5, input_dy, dy_label); \
\
GENERATE_BN_GRAD(LAYER, BLK, bn4, LAYER##_##BLK##_relu5_grad); \
GENERATE_CONV_PROP_FILTER(LAYER, BLK, conv4, LAYER##_##BLK##_bn4_grad, LAYER##_##BLK##_stride); \
GENERATE_CONV_PROP_INPUT(LAYER, BLK, conv4, LAYER##_##BLK##_bn4_grad, LAYER##_##BLK##_stride); \
\
GENERATE_BN_GRAD(LAYER, BLK, bn3, LAYER##_##BLK##_relu5_grad); \
GENERATE_CONV_PROP_FILTER(LAYER, BLK, conv3, LAYER##_##BLK##_bn3_grad, stride_1); \
GENERATE_CONV_PROP_INPUT(LAYER, BLK, conv3, LAYER##_##BLK##_bn3_grad, stride_1); \
\
GENERATE_RELU_GRAD(LAYER, BLK, relu2, LAYER##_##BLK##_conv3_propinput, "y"); \
GENERATE_BN_GRAD(LAYER, BLK, bn2, LAYER##_##BLK##_relu2_grad); \
GENERATE_CONV_PROP_FILTER(LAYER, BLK, conv2, LAYER##_##BLK##_bn2_grad, stride_1); \
GENERATE_CONV_PROP_INPUT(LAYER, BLK, conv2, LAYER##_##BLK##_bn2_grad, stride_1); \
\
GENERATE_RELU_GRAD(LAYER, BLK, relu1, LAYER##_##BLK##_conv2_propinput, "y"); \
GENERATE_BN_GRAD(LAYER, BLK, bn1, LAYER##_##BLK##_relu1_grad); \
GENERATE_CONV_PROP_FILTER(LAYER, BLK, conv1, LAYER##_##BLK##_bn1_grad, LAYER##_##BLK##_stride); \
GENERATE_CONV_PROP_INPUT(LAYER, BLK, conv1, LAYER##_##BLK##_bn1_grad, LAYER##_##BLK##_stride); \
\
GENERATE_ADD_GRAD(LAYER, BLK, add5, LAYER##_##BLK##_conv1_propinput, LAYER##_##BLK##_conv1_propinput_label, \
LAYER##_##BLK##_conv4_propinput, LAYER##_##BLK##_conv4_propinput_label); \
\
auto &LAYER##_##BLK##_grad_output = LAYER##_##BLK##_add5_grad; \
auto &LAYER##_##BLK##_grad_output_label = "y"

// (Operator& input)
#define MAKE_NORMAL_BLOCK_GRAD(LAYER, BLK, input_dy, dy_label) \
GENERATE_RELU_GRAD(LAYER, BLK, relu5, input_dy, dy_label); \
\
GENERATE_BN_GRAD(LAYER, BLK, bn3, LAYER##_##BLK##_relu5_grad); \
GENERATE_CONV_PROP_FILTER(LAYER, BLK, conv3, LAYER##_##BLK##_bn3_grad, stride_1); \
GENERATE_CONV_PROP_INPUT(LAYER, BLK, conv3, LAYER##_##BLK##_bn3_grad, stride_1); \
\
GENERATE_RELU_GRAD(LAYER, BLK, relu2, LAYER##_##BLK##_conv3_propinput, "y"); \
GENERATE_BN_GRAD(LAYER, BLK, bn2, LAYER##_##BLK##_relu2_grad); \
GENERATE_CONV_PROP_FILTER(LAYER, BLK, conv2, LAYER##_##BLK##_bn2_grad, stride_1); \
GENERATE_CONV_PROP_INPUT(LAYER, BLK, conv2, LAYER##_##BLK##_bn2_grad, stride_1); \
\
GENERATE_RELU_GRAD(LAYER, BLK, relu1, LAYER##_##BLK##_conv2_propinput, "y"); \
GENERATE_BN_GRAD(LAYER, BLK, bn1, LAYER##_##BLK##_relu1_grad); \
GENERATE_CONV_PROP_FILTER(LAYER, BLK, conv1, LAYER##_##BLK##_bn1_grad, LAYER##_##BLK##_stride); \
GENERATE_CONV_PROP_INPUT(LAYER, BLK, conv1, LAYER##_##BLK##_bn1_grad, LAYER##_##BLK##_stride); \
\
GENERATE_ADD_GRAD(LAYER, BLK, add5, LAYER##_##BLK##_conv1_propinput, LAYER##_##BLK##_conv1_propinput_label, \
input_dy, dy_label); \
\
auto &LAYER##_##BLK##_grad_output = LAYER##_##BLK##_add5_grad; \
auto &LAYER##_##BLK##_grad_output_label = "y"

// (Operator& input_dy)
#define MAKE_RESIDUAL_LAYER_GRAD(LAYER, input_dy, dy_label) \
MAKE_RESIDUAL_BLOCK_GRAD(LAYER, blk1, input_dy, dy_label); \
\
auto &LAYER##_grad_output = LAYER##_blk1_grad_output; \
auto &LAYER##_grad_output_label = LAYER##_blk1_grad_output_label;

// (Operator& input_dy)
#define MAKE_NORMAL_LAYER_GRAD(LAYER, input_dy, dy_label) \
MAKE_NORMAL_BLOCK_GRAD(LAYER, blk1, input_dy, dy_label); \
\
auto &LAYER##_grad_output = LAYER##_blk1_grad_output; \
auto &LAYER##_grad_output_label = LAYER##_blk1_grad_output_label;

#define MAKE_RESNET50_GRAD(input_dy, dy_label) \
MAKE_NORMAL_LAYER_GRAD(layer16, input_dy, dy_label) \
MAKE_NORMAL_LAYER_GRAD(layer15, layer16_grad_output, layer16_grad_output_label) \
MAKE_RESIDUAL_LAYER_GRAD(layer14, layer15_grad_output, layer15_grad_output_label) \
MAKE_NORMAL_LAYER_GRAD(layer13, layer14_grad_output, layer14_grad_output_label) \
MAKE_NORMAL_LAYER_GRAD(layer12, layer13_grad_output, layer13_grad_output_label) \
MAKE_NORMAL_LAYER_GRAD(layer11, layer12_grad_output, layer12_grad_output_label) \
MAKE_NORMAL_LAYER_GRAD(layer10, layer11_grad_output, layer11_grad_output_label) \
MAKE_NORMAL_LAYER_GRAD(layer9, layer10_grad_output, layer10_grad_output_label) \
MAKE_RESIDUAL_LAYER_GRAD(layer8, layer9_grad_output, layer9_grad_output_label) \
MAKE_NORMAL_LAYER_GRAD(layer7, layer8_grad_output, layer8_grad_output_label) \
MAKE_NORMAL_LAYER_GRAD(layer6, layer7_grad_output, layer7_grad_output_label) \
MAKE_NORMAL_LAYER_GRAD(layer5, layer6_grad_output, layer6_grad_output_label) \
MAKE_RESIDUAL_LAYER_GRAD(layer4, layer5_grad_output, layer5_grad_output_label) \
MAKE_NORMAL_LAYER_GRAD(layer3, layer4_grad_output, layer4_grad_output_label) \
MAKE_NORMAL_LAYER_GRAD(layer2, layer3_grad_output, layer3_grad_output_label) \
MAKE_RESIDUAL_LAYER_GRAD(layer1, layer2_grad_output, layer2_grad_output_label) \
\
auto &resnet50_grad_output = layer1_grad_output; \
auto &resnet50_grad_output_label = layer1_grad_output_label;

bool resnet50(Graph &graph) {
auto data = op::Data().set_attr_index(0);
auto data1 = op::Data().set_attr_index(1);
TensorDesc shape_desc(ge::Shape({32, 3, 224, 224}), FORMAT_NCHW, DT_FLOAT);
data.update_output_desc_y(shape_desc);

TensorDesc desc(ge::Shape({64, 3, 7, 7}), FORMAT_NCHW, DT_FLOAT);

auto var = op::Variable("conv2d_var");
var.update_output_desc_y(desc);
var.update_input_desc_x(desc);

auto varw1 = op::Variable("conv2d_varw1");
varw1.update_output_desc_y(desc);

auto conv2d = op::Conv2D("Translate")
.set_input_x(data)
.set_input_filter(var)
.set_attr_strides({1, 1, 2, 2})
.set_attr_pads({2, 3, 2, 3})
.set_attr_data_format("NCHW");
TensorDesc desc_y;
desc_y.SetFormat(FORMAT_NCHW); // shape: 32 64 112 112
conv2d.update_output_desc_y(desc_y);

TensorDesc desc1(ge::Shape({1, 64, 1, 1}), FORMAT_NCHW, DT_FLOAT);
auto var1 = op::Variable("bn_var1");
var1.update_output_desc_y(desc1);

auto var2 = op::Variable("bn_var2");
var2.update_output_desc_y(desc1);

auto var3 = op::Variable("bn_var3");
var3.update_output_desc_y(desc1);

auto var4 = op::Variable("bn_var4");
var4.update_output_desc_y(desc1);

TensorDesc desc2(ge::Shape({2048, 1001}), FORMAT_NCHW, DT_FLOAT);

auto var5 = op::Variable("var5");
var5.update_output_desc_y(desc2);

auto var6 = op::Variable("var6");
var6.update_output_desc_y(desc2);

TensorDesc desclabel(ge::Shape({1, 1001, 1, 1}), FORMAT_NCHW, DT_FLOAT);

auto label1 = op::Variable("label1");
label1.update_output_desc_y(desclabel);

TensorDesc descmatlabel(ge::Shape({1, 1001, 1, 1}), FORMAT_NCHW, DT_FLOAT);
auto matvar = op::Variable("matvar");
matvar.update_output_desc_y(descmatlabel);

auto matvar1 = op::Variable("matvar1");
matvar1.update_output_desc_y(descmatlabel);

auto bn = op::FusedBatchNorm()
.set_input_x(conv2d, "y")
.set_input_scale(var1)
.set_input_b(var2)
.set_input_mean(var3)
.set_input_variance(var4)
.set_attr_mode(1)
.set_attr_epsilon(1e-5)
.set_attr_is_training(true)
.set_attr_is_training_fusion(true)
.set_attr_moving_average_fraction(994352128);

auto relu = op::Relu().set_input_x(bn, "y");

auto maxpool = op::MaxPoolWithArgmax()
.set_input_x(relu, "y")
.set_attr_ksize({1, 3, 3, 1})
.set_attr_padding("SAME")
.set_attr_strides({1, 2, 2, 1});

MAKE_RESNET50(maxpool);
std::vector<Operator> inputs{data}; //,var,var1,layer1_blk1_bn1_b,var3,var4};
std::vector<Operator> outputs{};

graph.SetInputs(inputs).SetOutputs(outputs);
return true;
}

#define GENERATE_CONSTANT_USE_DESC(OPNUM, desc, val) \
uint32_t OPNUM##_size = desc.GetShape().GetShapeSize(); \
Tensor OPNUM##_tensor; \
OPNUM##_tensor.SetTensorDesc(desc); \
if (desc.GetDataType() == DT_FLOAT) { \
float *OPNUM##_data = new float[OPNUM##_size]; \
for (int i = 0; i < (int)OPNUM##_size; i++) { \
*(OPNUM##_data + i) = val; \
} \
OPNUM##_tensor.SetData((uint8_t *)OPNUM##_data, OPNUM##_size * sizeof(float)); \
delete[] OPNUM##_data; \
} \
if (desc.GetDataType() == DT_INT64) { \
int64_t *OPNUM##_data = new int64_t[OPNUM##_size]; \
for (int i = 0; i < (int)OPNUM##_size; i++) { \
*(OPNUM##_data + i) = val; \
} \
OPNUM##_tensor.SetData((uint8_t *)OPNUM##_data, OPNUM##_size * sizeof(int64_t)); \
delete[] OPNUM##_data; \
} \
auto OPNUM##_constant = op::Constant().set_attr_value(OPNUM##_tensor); \
OPNUM##_constant.update_output_desc_y(desc);

#define GENERATE_VAR_LAYER(OPNUM, desc, input) \
auto OPNUM##_weight = op::Variable(string(#OPNUM)); \
OPNUM##_weight.update_output_desc_y(desc); \
auto OPNUM##_assign = op::Assign().set_input_ref(OPNUM##_weight).set_input_value(OPNUM##_constant); \
\
input.push_back(OPNUM##_weight);

#define GENERATE_VAR_LAYER_1(OPNUM, desc, var_format, input, name) \
auto OPNUM##_weight = op::Variable(string(name)); \
OPNUM##_weight.update_output_desc_y(desc); \
auto OPNUM##_assign = op::Assign().set_input_ref(OPNUM##_weight).set_input_value(OPNUM##_constant); \
\
input.push_back(OPNUM##_weight);

int BuildInitVarGraph(Graph &graph) {
std::vector<Operator> inputs{};
std::vector<Operator> outputs{};

TensorDesc desc(ge::Shape({64, 3, 7, 7}), FORMAT_NCHW, DT_FLOAT);
GENERATE_CONSTANT_USE_DESC(conv2d_var, desc, 0.01);
GENERATE_VAR_LAYER(conv2d_var, desc, inputs);

GENERATE_CONSTANT_USE_DESC(conv2d_varw1, desc, 0.01);
GENERATE_VAR_LAYER(conv2d_varw1, desc, inputs);

TensorDesc desc1(ge::Shape({1, 64, 1, 1}), FORMAT_NCHW, DT_FLOAT);
GENERATE_CONSTANT_USE_DESC(bn_var1, desc1, 0.01);
GENERATE_VAR_LAYER(bn_var1, desc1, inputs);
GENERATE_CONSTANT_USE_DESC(bn_var2, desc1, 0.01);
GENERATE_VAR_LAYER(bn_var2, desc1, inputs);
GENERATE_CONSTANT_USE_DESC(bn_var3, desc1, 0.01);
GENERATE_VAR_LAYER(bn_var3, desc1, inputs);
GENERATE_CONSTANT_USE_DESC(bn_var4, desc1, 0.01);
GENERATE_VAR_LAYER(bn_var4, desc1, inputs);

TensorDesc desc2(ge::Shape({2048, 1001}), FORMAT_NCHW, DT_FLOAT);
GENERATE_CONSTANT_USE_DESC(var5, desc2, 0.01);
GENERATE_VAR_LAYER(var5, desc2, inputs);
GENERATE_CONSTANT_USE_DESC(var6, desc2, 0.01);
GENERATE_VAR_LAYER(var6, desc2, inputs);

TensorDesc desclabel(ge::Shape({1, 1001, 1, 1}), FORMAT_NCHW, DT_FLOAT);
GENERATE_CONSTANT_USE_DESC(label1, desclabel, 0.1);
GENERATE_VAR_LAYER(label1, desclabel, inputs);

TensorDesc descmatlabel(ge::Shape({1, 1001, 1, 1}), FORMAT_NCHW, DT_FLOAT);
GENERATE_CONSTANT_USE_DESC(matvar, descmatlabel, 0.01);
GENERATE_VAR_LAYER(matvar, descmatlabel, inputs);
GENERATE_CONSTANT_USE_DESC(matvar1, descmatlabel, 0.01);
GENERATE_VAR_LAYER(matvar1, descmatlabel, inputs);

MAKE_RESNET50_VAR(inputs);

TensorDesc ctrl(ge::Shape({1, 1, 1, 1}), FORMAT_NCHW, DT_INT64);

GENERATE_CONSTANT_USE_DESC(iterations_per_loop, ctrl, 100);
GENERATE_VAR_LAYER_1(iterations_per_loop, ctrl, "4D", inputs, "npu_runconfig/iterations_per_loop");
GENERATE_CONSTANT_USE_DESC(loop_cond, ctrl, 0);
GENERATE_VAR_LAYER_1(loop_cond, ctrl, "4D", inputs, "npu_runconfig/loop_cond");
GENERATE_CONSTANT_USE_DESC(one, ctrl, 1);
GENERATE_VAR_LAYER_1(one, ctrl, "4D", inputs, "npu_runconfig/one");
GENERATE_CONSTANT_USE_DESC(zero, ctrl, 0);
GENERATE_VAR_LAYER_1(zero, ctrl, "4D", inputs, "npu_runconfig/zero");

graph.SetInputs(inputs).SetOutputs(outputs);
return 0;
}
int TestBuildGraphTest(Func fun, Graph &graph, vector<ge::Tensor> &inputs, vector<ge::Tensor> &outputs) {
bool graph_ret = fun(graph);
ge::Tensor shapeTensor;
TensorDesc shape_desc(ge::Shape({32, 3, 224, 224}), FORMAT_NCHW, DT_FLOAT);
uint32_t sizeshape = shape_desc.GetShape().GetShapeSize();
printf("[test] desc size filter shape:%u\n", sizeshape);
shapeTensor.SetTensorDesc(shape_desc);
vector<float> dataValuec;
for (int i = 0; i < sizeshape; i++) {
dataValuec.push_back(1);
}

shapeTensor.SetData((uint8_t *)dataValuec.data(), 4 * sizeshape);
inputs.push_back(shapeTensor);

ge::Tensor shapeTensor1;
TensorDesc shape_desc1(ge::Shape({1, 32, 1, 1}), FORMAT_NCHW, DT_FLOAT);
uint32_t sizeshape1 = shape_desc1.GetShape().GetShapeSize();
printf("[test] desc size filter shape:%u\n", sizeshape1);
shapeTensor1.SetTensorDesc(shape_desc1);
vector<int32_t> dataValuec1;
for (int i = 0; i < sizeshape1; i++) {
dataValuec1.push_back(1);
}

shapeTensor1.SetData((uint8_t *)dataValuec1.data(), 4 * sizeshape1);

return 0;
}
int runTrainGraph(Func fun, int loopCount) {
printf("GE BBIT begin...\n");
std::chrono::system_clock::time_point start = std::chrono::system_clock::now();

std::map<std::string, std::string> ge_options = {
{"device_id", "0"}, {"rank_table_file", ""}, {"graphType", "1"}, {"ge.graphRunMode", "2"}};

std::map<std::string, std::string> session_options = {{"a", "b"}, {TRAIN_FLAG, "1"}};

ge::Status ret;

// init ge
ret = GEInitialize_api_new("train", "fe,plugin");
printf("ge::GEInitialize ret:%d\n", ret);

// init session
ge::Session session(session_options);

int graphId_initvar = 1;
ge::Graph graph_initvar("initVarGraph");
bool graph_ret = BuildInitVarGraph(graph_initvar);

// session addgraph
int graphId = 0;

// build graph
ge::Graph graph("bigGraph");
std::vector<ge::Tensor> inputs;
ge::Tensor outputTensor;
std::vector<ge::Tensor> outputs;
graph_ret = TestBuildGraphTest(fun, graph, inputs, outputs);
printf("TestReluGrad ret:%d\n", graph_ret);

ret = session.AddGraph(graphId_initvar, graph_initvar);
printf("session.AddVarGraph ret:%d\n", ret);
if (ret) return ret;

ret = session.AddGraph(graphId, graph);
printf("session.AddGraph ret:%d\n", ret);
if (ret) return ret;

std::vector<ge::Tensor> inputs1;
std::vector<ge::Tensor> outputs1;
ret = session.RunGraph(graphId_initvar, inputs1, outputs1);

if (ret != SUCCESS) {
return ret;
}
// add loop for test of stabilty:
for (int i = 0; i < loopCount; i++) {
// session rungraph
printf("loopCount:%d\n", loopCount);
ret = session.RunGraph(graphId, inputs, outputs);
printf("session.RunGraph ret:%d\n", ret);
if (ret) return ret;

// define 99999 as loop forever
if (loopCount == 99999) i = 0;
}
std::chrono::system_clock::time_point end = std::chrono::system_clock::now();
auto millisecondsduration = std::chrono::duration_cast<std::chrono::milliseconds>(end - start);
auto ms = millisecondsduration.count();
std::stringstream ss;
ss << ms << "ms";
std::string run_time = ss.str();
printf("run time is : %s \n", run_time.c_str());

return 0;
}

int main(int argc, char *argv[]) {
// add loop for test of stabilty:
int loopCount = 1;
if (argc >= 2) loopCount = atoi(argv[1]);

Status ret = SUCCESS;
ret = runTrainGraph(resnet50, loopCount);
if (ret == SUCCESS) {
std::cout << "[train resnet50 success]" << std::endl;
} else {
std::cout << "!!! train resnet50 fail !!!" << std::endl;
}
return ret;
}

+ 0
- 56
tests/st/test_ge_st.py View File

@@ -1,56 +0,0 @@
# Copyright 2019-2020 Huawei Technologies Co., Ltd
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# ============================================================================

"""
ge st test.
"""
import pytest
import subprocess
import os

@pytest.mark.level0
@pytest.mark.platform_arm_ascend_training
@pytest.mark.platform_x86_ascend_training
@pytest.mark.env_card
@pytest.mark.component_ge
def test_resnet50_train():
ge_st_dir=os.environ.get('GE_ST_DIR',
'/home/jenkins/workspace/release_pkg/gate/graphengine_lib')
ge_lib_dir=os.environ.get('GRAPHENGINE_LIB', '/home/jenkins/workspace/release_pkg/gate/graphengine_lib')

real_pythonpath=os.environ.get('REAL_PYTHONPATH')
pythonpath=os.environ.get('PYTHONPATH')
if real_pythonpath:
if pythonpath:
os.environ['PYTHONPATH']=real_pythonpath+':'+pythonpath
else:
os.environ['PYTHONPATH']=real_pythonpath
print('PYTHONPATH: '+os.environ.get('PYTHONPATH'))

os.environ['ASCEND_OPP_PATH']='/usr/local/Ascend/opp'
os.environ['ASCEND_ENGINE_PATH']='/usr/local/Ascend/fwkacllib/lib64/plugin/opskernel/libaicpu_engine.so:' \
'/usr/local/Ascend/fwkacllib/lib64/plugin/opskernel/libfe.so:' \
'/usr/local/Ascend/fwkacllib/lib64/plugin/opskernel/librts_engine.so:'+ \
ge_lib_dir + '/libge_local_engine.so'
print('ASCEND_OPP_PATH: '+os.environ.get('ASCEND_OPP_PATH'))
print('ASCEND_ENGINE_PATH: '+os.environ.get('ASCEND_ENGINE_PATH'))
print('LD_LIBRARY_PATH: '+os.environ.get('LD_LIBRARY_PATH'))

cmd=ge_st_dir + '/st_resnet50_train'
print('cmd: '+cmd)
os.environ['SLOG_PRINT_TO_STDOUT']="1"
ret=subprocess.call([cmd], shell=True)
assert ret==0


Write Preview
Loading…
Cancel
Save