m53297601
/
graphengine
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '71788dcc50'
${ noResults }
graphengine/ge/graph/preprocess/multi_batch_options.cc

595 lines
25 KiB
Raw Blame History

/**
* Copyright 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 "multi_batch_options.h"
#include "framework/common/debug/ge_log.h"
#include "framework/omg/omg_inner_types.h"
#include "framework/common/util.h"
#include "framework/common/string_util.h"
#include "common/formats/utils/formats_trans_utils.h"
#include "common/util/error_manager/error_manager.h"
#include "graph/debug/ge_attr_define.h"
#include "graph/utils/node_utils.h"
#include "graph/ge_context.h"
#include "graph/common/local_context.h"
#include "framework/common/types.h"
#include "graph/compute_graph.h"
#include "graph/utils/graph_utils.h"
#include "graph/common/omg_util.h"
namespace ge {
namespace multibatch {
constexpr int kDecimal = 10;
constexpr uint8_t kMaxShapesCount = 100;
constexpr uint8_t kMinShapesCount = 2;
const int kDynmaicDims = -1;
const int kDynamicBatchDynamicDimsNum = 1;
const int kDynamicImgSizeDynamciDimsNum = 2;
const size_t kMaxNDDimNum = 4;
const size_t kMinNDDimNum = 1;
const size_t kNumOfGetnextNode = 1;
const int kDivisionConst = 2;
const char *const kSubstrOfGetNextNosinkName = "IteratorGetNext";
const char *const kShapeDataName = "ascend_mbatch_shape_data";
const char *const kGetNextName = "IteratorV2";
inline bool IsGetNextType(const NodePtr &node) {
std::string original_type;
GE_IF_BOOL_EXEC(GetOriginalType(node, original_type) != SUCCESS,
GELOGW("Get original type failed."); return false);
return (original_type == kGetNextName);
}
void ParseDynamicSize(string dynamic_size, vector<vector<int64_t>> &shapes) {
std::vector<std::string> shape_strs = ge::StringUtils::Split(dynamic_size, ';');
for (const auto &shape_str : shape_strs) {
if (shape_str.empty()) {
continue;
}
std::vector<int64_t> shape;
std::vector<std::string> dims = ge::StringUtils::Split(shape_str, ',');
for (const auto &dim : dims) {
if (dim.empty()) {
continue;
}
shape.emplace_back(std::strtol(dim.c_str(), nullptr, kDecimal));
}
if (!shape.empty()) {
shapes.emplace_back(shape);
}
}
}
Status DistinguishGetNextAndData(ComputeGraphPtr &graph, vector<NodePtr> &data_nodes,
vector<NodePtr> &getnext_nosink_nodes, vector<NodePtr> &getnext_sink_nodes) {
GELOGD("Start distinguish getnext and data node.");
for (NodePtr &input_node : graph->GetDirectNode()) {
GE_CHECK_NOTNULL(input_node);
OpDescPtr op_desc = input_node->GetOpDesc();
GE_CHECK_NOTNULL(op_desc);
if (op_desc->GetType() == DATA && op_desc->GetName() != kShapeDataName) {
if (op_desc->GetName().find(kSubstrOfGetNextNosinkName) == string::npos) {
data_nodes.emplace_back(input_node);
} else {
getnext_nosink_nodes.emplace_back(input_node);
}
}
if (IsGetNextType(input_node)) {
GELOGD("Name of getnext sink is %s.", op_desc->GetName().c_str());
getnext_sink_nodes.emplace_back(input_node);
}
}
GELOGI("Data count is %zu, getnext nosink count is %zu, getnext sink count is %zu.", data_nodes.size(),
getnext_nosink_nodes.size(), getnext_sink_nodes.size());
return SUCCESS;
}
Status CheckSequenceOfData(ComputeGraphPtr &graph, const vector<NodePtr> &data_nodes) {
GELOGD("Start check input sequence from data nodes and input shape.");
if (data_nodes.size() != GetLocalOmgContext().user_input_dims.size()) {
GELOGE(PARAM_INVALID, "The count of input shape:%zu should be equal to the count of data num:%zu.",
GetLocalOmgContext().user_input_dims.size(), data_nodes.size());
return PARAM_INVALID;
}
for (size_t i = 0; i < data_nodes.size(); ++i) {
auto data_node = data_nodes.at(i);
GE_CHECK_NOTNULL(data_node);
GE_CHECK_NOTNULL(data_node->GetOpDesc());
auto output_shape = data_node->GetOpDesc()->GetOutputDesc(0).GetShape().GetDims();
auto dynamic_dims = GetLocalOmgContext().user_input_dims.at(i).second;
if (output_shape.empty() && dynamic_dims.size() == 1 && dynamic_dims.at(0) == 0) {
GELOGI("No need to check sequence for constant.");
continue;
}
if (dynamic_dims.size() != output_shape.size()) {
GELOGE(PARAM_INVALID, "The output shape of %s is %s, the input shape from options of %s is %s.",
data_node->GetName().c_str(), formats::JoinToString(output_shape).c_str(),
GetLocalOmgContext().user_input_dims.at(i).first.c_str(), formats::JoinToString(dynamic_dims).c_str());
return PARAM_INVALID;
}
for (size_t j = 0; j < dynamic_dims.size(); ++j) {
if (dynamic_dims.at(j) != kDynmaicDims && dynamic_dims.at(j) != output_shape.at(j)) {
GELOGE(INTERNAL_ERROR, "Value of input shape %s should be equal to %s.",
formats::JoinToString(dynamic_dims).c_str(), formats::JoinToString(output_shape).c_str());
return INTERNAL_ERROR;
}
}
}
return SUCCESS;
}
Status CheckSequenceOfGetnext(ComputeGraphPtr &graph, const vector<NodePtr> &getnext_sink_node) {
GELOGD("Start check input sequence from getnext sink nodes and input shape.");
if (getnext_sink_node.size() != kNumOfGetnextNode) {
GELOGE(PARAM_INVALID, "Not support dynamic dims when a graph with multi getnext nodes.");
return PARAM_INVALID;
}
auto data_node = getnext_sink_node.at(0);
GE_CHECK_NOTNULL(data_node);
auto op_desc = data_node->GetOpDesc();
GE_CHECK_NOTNULL(op_desc);
size_t data_count = data_node->GetAllOutDataAnchors().size() / kDivisionConst;
if (data_count != GetLocalOmgContext().user_input_dims.size()) {
GELOGE(PARAM_INVALID, "Output count of %s is %zu, should be equal to count of input shape: %zu",
op_desc->GetName().c_str(), data_count, GetLocalOmgContext().user_input_dims.size());
return PARAM_INVALID;
}
for (size_t i = 0; i < data_count; ++i) {
auto output_shape = data_node->GetOpDesc()->GetOutputDesc(i).GetShape().GetDims();
auto dynamic_dims = GetLocalOmgContext().user_input_dims.at(i).second;
if (output_shape.empty() && dynamic_dims.size() == 1 && dynamic_dims.at(0) == 0) {
GELOGI("No need to check sequence for constant.");
continue;
}
if (dynamic_dims.size() != output_shape.size()) {
GELOGE(PARAM_INVALID, "the output_shape of %s is %s, the input_shape from options of %s is %s.",
data_node->GetName().c_str(), formats::JoinToString(output_shape).c_str(),
GetLocalOmgContext().user_input_dims.at(i).first.c_str(), formats::JoinToString(dynamic_dims).c_str());
return PARAM_INVALID;
}
for (size_t j = 0; j < dynamic_dims.size(); ++j) {
if (dynamic_dims.at(j) != kDynmaicDims && dynamic_dims.at(j) != output_shape.at(j)) {
GELOGE(INTERNAL_ERROR, "value of input_shape %s should be equal to %s.",
formats::JoinToString(dynamic_dims).c_str(), formats::JoinToString(output_shape).c_str());
return INTERNAL_ERROR;
}
}
}
return SUCCESS;
}
Status CheckSequenceOfOptions(ComputeGraphPtr &graph, vector<NodePtr> &data_nodes,
vector<NodePtr> &getnext_nosink_nodes, vector<NodePtr> &getnext_sink_nodes) {
if (GetLocalOmgContext().dynamic_node_type.empty()) {
GELOGI("No need to CheckSequenceOfOptions.");
return SUCCESS;
}
if (DistinguishGetNextAndData(graph, data_nodes, getnext_nosink_nodes, getnext_sink_nodes) != SUCCESS) {
GELOGE(PARAM_INVALID, "DistinguishGetNextAndData failed.");
return PARAM_INVALID;
}
if (GetLocalOmgContext().dynamic_node_type == DATA) {
GELOGD("Users want data nodes to be dynamic.");
if (CheckSequenceOfData(graph, data_nodes) != SUCCESS) {
GELOGE(PARAM_INVALID, "Failed to check sequence of data nodes.");
return PARAM_INVALID;
}
} else {
GELOGD("Users want getnext nodes to be dynamic.");
if (!getnext_nosink_nodes.empty()) {
if (CheckSequenceOfData(graph, getnext_nosink_nodes) != SUCCESS) {
GELOGE(PARAM_INVALID, "Failed to check sequence of getnext nosink nodes.");
return PARAM_INVALID;
}
} else {
if (CheckSequenceOfGetnext(graph, getnext_sink_nodes) != SUCCESS) {
GELOGE(PARAM_INVALID, "Failed to check sequence of getnext sink nodes.");
return PARAM_INVALID;
}
}
}
return SUCCESS;
}
Status UpdateNameOfData(ComputeGraphPtr &graph, const vector<NodePtr> &data_nodes) {
GELOGD("Update first value of input shape by data nodes.");
if (data_nodes.size() != GetLocalOmgContext().user_input_dims.size()) {
GELOGE(PARAM_INVALID, "count of data_nodes: %zu should be equal to input_shape count: %zu.",
data_nodes.size(), GetLocalOmgContext().user_input_dims.size());
return PARAM_INVALID;
}
for (size_t i = 0; i < data_nodes.size(); ++i) {
GELOGD("The %zu data name is %s.", i, data_nodes.at(i)->GetOpDesc()->GetName().c_str());
GetLocalOmgContext().user_input_dims.at(i).first = data_nodes.at(i)->GetOpDesc()->GetName();
}
return SUCCESS;
}
Status UpdateNameOfGetnext(ComputeGraphPtr &graph, const vector<NodePtr> &getnext_sink_nodes) {
GELOGD("Update first value of input shape by getnext sink nodes.");
if (getnext_sink_nodes.size() != kNumOfGetnextNode) {
GELOGE(PARAM_INVALID, "Not support dynamic dims when a graph with multi getnext nodes.");
return PARAM_INVALID;
}
auto input_node = getnext_sink_nodes.at(0);
GE_CHECK_NOTNULL(input_node);
auto op_desc = input_node->GetOpDesc();
GE_CHECK_NOTNULL(op_desc);
// user want getnext dynamic, just getnext or data+getnext_sink
size_t data_count = input_node->GetAllOutDataAnchors().size() / kDivisionConst;
if (data_count != GetLocalOmgContext().user_input_dims.size()) {
GELOGE(PARAM_INVALID, "Output count of %s is %zu, should be equal to count of input shape: %zu",
op_desc->GetName().c_str(), data_count, GetLocalOmgContext().user_input_dims.size());
return PARAM_INVALID;
}
for (size_t i = 0; i < data_count; ++i) {
string data_name = op_desc->GetName() + "_" + std::to_string(i);
GELOGD("Data just from getnext sink is %s.", data_name.c_str());
GetLocalOmgContext().user_input_dims.at(i).first = data_name;
}
return SUCCESS;
}
// need to distinguish online and offline, offline no need to update the name of input_shape
Status UpdateNameOfInputShape(ComputeGraphPtr &graph, const vector<NodePtr> &data_nodes,
const vector<NodePtr> &getnext_nosink_nodes, const vector<NodePtr> &getnext_sink_nodes) {
if (GetLocalOmgContext().dynamic_node_type.empty()) {
GELOGI("No need to update first value of input shape when offline infer.");
return SUCCESS;
}
if (GetLocalOmgContext().dynamic_node_type == DATA) {
GELOGD("Users want data nodes to be dynamic.");
if (UpdateNameOfData(graph, data_nodes) != SUCCESS) {
GELOGE(PARAM_INVALID, "Failed to update first value of input shape of data nodes.");
return PARAM_INVALID;
}
} else {
GELOGD("Users want getnext nodes to be dynamic.");
if (!getnext_nosink_nodes.empty()) {
if (UpdateNameOfData(graph, getnext_nosink_nodes) != SUCCESS) {
GELOGE(PARAM_INVALID, "Failed to update first value of input shape of getnext nosink nodes.");
return PARAM_INVALID;
}
} else {
if (UpdateNameOfGetnext(graph, getnext_sink_nodes) != SUCCESS) {
GELOGE(PARAM_INVALID, "Failed to update first value of input shape of getnext sink nodes.");
return PARAM_INVALID;
}
}
}
return SUCCESS;
}
Status DeleteIdentityInsertByAdapter(ComputeGraphPtr &graph) {
GELOGD("Start delete identity node inserted by adapter.");
for (NodePtr &node : graph->GetDirectNode()) {
GE_CHECK_NOTNULL(node);
OpDescPtr op_desc = node->GetOpDesc();
GE_CHECK_NOTNULL(op_desc);
if (IsGetNextType(node)) {
for (auto &out_data_anchor : node->GetAllOutDataAnchors()) {
GE_IF_BOOL_EXEC(out_data_anchor == nullptr, continue);
for (auto &peer_in_anchor : out_data_anchor->GetPeerInDataAnchors()) {
GE_IF_BOOL_EXEC(peer_in_anchor == nullptr, continue);
auto dst_node = peer_in_anchor->GetOwnerNode();
GE_IF_BOOL_EXEC(dst_node == nullptr, continue);
if (dst_node->GetType() == IDENTITY) {
GELOGI("Need to remove %s.", dst_node->GetName().c_str());
if (ge::GraphUtils::RemoveNodeWithoutRelink(graph, dst_node) != GRAPH_SUCCESS) {
GELOGE(FAILED, "Remove Identity node %s failed.", dst_node->GetName().c_str());
return FAILED;
}
}
}
}
}
}
return SUCCESS;
}
Status CheckNegativeCountOfOptions(const std::vector<std::vector<int64_t>> &shapes) {
if (!GetLocalOmgContext().dynamic_dims.empty()) {
size_t negative_count = 0;
for (size_t i = 0; i < GetLocalOmgContext().user_input_dims.size(); ++i) {
for (size_t j = 0; j < GetLocalOmgContext().user_input_dims.at(i).second.size(); ++j) {
if (GetLocalOmgContext().user_input_dims.at(i).second.at(j) == kDynmaicDims) {
negative_count++;
}
}
}
for (size_t i = 0; i < shapes.size(); ++i) {
if (shapes.at(i).size() != negative_count) {
GELOGE(PARAM_INVALID, "Each gear num of dynamic_dims is %zu should be equal to %zu.", shapes.at(i).size(),
negative_count);
return PARAM_INVALID;
}
}
}
return SUCCESS;
}
///
/// @ingroup ge
/// @brief Init Dynamic Param from Options.
/// @param [out] std::vector<std::vector<int64_t>> &shapes: Result for Params.
/// @return true: Configed for Multi batch / false: Not configed for Multi batch.
///
bool InitDynamicParams(vector<vector<int64_t>> &shapes) {
if (!GetLocalOmgContext().dynamic_batch_size.empty()) {
GELOGD("Found dynamic batch option, value %s", GetLocalOmgContext().dynamic_batch_size.c_str());
std::vector<std::string> dims = ge::StringUtils::Split(GetLocalOmgContext().dynamic_batch_size, ',');
for (const auto &dim : dims) {
if (dim.empty()) {
continue;
}
shapes.emplace_back(std::vector<int64_t>({std::strtol(dim.c_str(), nullptr, kDecimal)}));
GELOGI("Found dynamic batch, shape %s", formats::JoinToString(*shapes.rbegin()).c_str());
}
}
if (!GetLocalOmgContext().dynamic_image_size.empty()) {
GELOGD("Found dynamic image size option, value %s", GetLocalOmgContext().dynamic_image_size.c_str());
ParseDynamicSize(GetLocalOmgContext().dynamic_image_size, shapes);
for (const auto &shape : shapes) {
GELOGI("Found dynamic image size, shape %s", formats::JoinToString(shape).c_str());
}
}
if (!GetLocalOmgContext().dynamic_dims.empty()) {
GELOGD("Found dynamic dims option, value %s", GetLocalOmgContext().dynamic_dims.c_str());
ParseDynamicSize(GetLocalOmgContext().dynamic_dims, shapes);
for (const auto &shape : shapes) {
GELOGI("Found dynamic dims, shape %s", formats::JoinToString(shape).c_str());
}
}
return !shapes.empty();
}
///
/// @ingroup ge
/// @brief parse each data's own dynamic dims.
/// @param [out] map<string, vector<vector<int64_t>>> &data_to_dynamic_info: key:data_name. value:dynamic dims.
/// @return true: Configed for Multi batch / false: Not configed for Multi batch.
///
Status ParserDataToDynmaicInfo(const vector<vector<int64_t>> &shapes,
vector<pair<string, vector<int64_t>>> &data_name_and_shape,
map<string, vector<vector<int64_t>> > &data_to_dynamic_info) {
size_t cur_data_index = 0;
for (size_t index = 0; index < data_name_and_shape.size(); ++index) {
auto &cur_item = data_name_and_shape[index];
auto &data_name = cur_item.first;
auto &data_shape = cur_item.second;
auto dynamic_dims_num = std::count_if(data_shape.begin(), data_shape.end(),
[&data_shape](int64_t dim){ return dim < 0; });
GELOGI("Train_Dynamic dynamic_dims_num of %s is %zu", data_name.c_str(), dynamic_dims_num);
vector<vector<int64_t> > dynamic_info;
for (auto &dynamic_gear_info : shapes) {
GELOGI("Train_Dynamic dynamic_gear_info is %s", formats::JoinToString(dynamic_gear_info).c_str());
vector<int64_t> one_gear;
if (dynamic_gear_info.size() == static_cast<size_t>(dynamic_dims_num)) {
one_gear = dynamic_gear_info;
} else if (dynamic_gear_info.size() > static_cast<size_t>(dynamic_dims_num)) {
auto tmp_index = cur_data_index;
for (size_t i = 0; i < static_cast<size_t>(dynamic_dims_num); ++i) {
if (tmp_index >= dynamic_gear_info.size()) {
ErrorManager::GetInstance().ATCReportErrMessage(
"E10045", {"name", "shape"}, {data_name, formats::JoinToString(data_shape)});
GELOGE(PARAM_INVALID, "Data: %s shape: %s make dynamic dims overflow", data_name.c_str(),
formats::JoinToString(data_shape).c_str());
return FAILED;
}
one_gear.push_back(dynamic_gear_info[tmp_index++]);
}
} else {
ErrorManager::GetInstance().ATCReportErrMessage(
"E10046", {"name", "shape"}, {data_name, formats::JoinToString(data_shape)});
GELOGE(PARAM_INVALID, "Dynamic dims num of data: %s shape: %s can not be more than one gear dynamic info size",
data_name.c_str(), formats::JoinToString(data_shape).c_str());
return FAILED;
}
GELOGI("Train_Dynamic one_gear is %s.", formats::JoinToString(one_gear).c_str());
dynamic_info.push_back(one_gear);
}
cur_data_index += dynamic_dims_num;
data_to_dynamic_info[data_name] = dynamic_info;
}
return SUCCESS;
}
///
/// @ingroup ge
/// @brief Check Dynamic Param is invalid.
/// @param [in] const vector<vector<int64_t>> &shapes: Params for check.
/// @return SUCCESS: valid / PARAM_INVALID: invalid.
///
Status CheckDynamicParams(const vector<vector<int64_t>> &shapes) {
if (shapes.size() < kMinShapesCount) {
ErrorManager::GetInstance().ATCReportErrMessage(
"E10035", {"shapesize", "minshapesize"}, {std::to_string(shapes.size()), std::to_string(kMinShapesCount - 1)});
GELOGE(PARAM_INVALID,
"Input parameter[--dynamic_batch_size, --dynamic_image_size or --dynamic_dims]'s "
"value size [%zu] must be greater than [%zu].",
shapes.size(), kMinShapesCount - 1);
return PARAM_INVALID;
}
if (shapes.size() > kMaxShapesCount) {
ErrorManager::GetInstance().ATCReportErrMessage(
"E10036", {"shapesize", "maxshapesize"}, {std::to_string(shapes.size()), std::to_string(kMaxShapesCount + 1)});
GELOGE(PARAM_INVALID,
"Input parameter[--dynamic_batch_size, --dynamic_image_size or --dynamic_dims]'s "
"value size [%zu] must be less than [%zu].",
shapes.size(), kMaxShapesCount + 1);
return PARAM_INVALID;
}
std::set<std::vector<int64_t>> shapes_set;
size_t shape_size = shapes.at(0).size();
for (auto &shape : shapes) {
if (shape_size != shape.size()) {
ErrorManager::GetInstance().ATCReportErrMessage("E10037", {"shapesize1", "shapesize2"},
{std::to_string(shape_size), std::to_string(shape.size())});
GELOGE(PARAM_INVALID,
"Input parameter[--dynamic_batch_size, --dynamic_image_size or --dynamic_dims]'s "
"value size must be same, first group's size is %zu and another's is %zu.",
shape_size, shape.size());
return PARAM_INVALID;
}
for (auto dim : shape) {
if (dim <= 0) {
ErrorManager::GetInstance().ATCReportErrMessage("E10038", {"dim"}, {std::to_string(dim)});
GELOGE(PARAM_INVALID, "Invalid dim %ld, all dims must be greater than 0", dim);
return PARAM_INVALID;
}
}
shapes_set.insert(shape);
}
if (shapes_set.size() != shapes.size()) {
ErrorManager::GetInstance().ATCReportErrMessage("E10039");
GELOGE(PARAM_INVALID,
"Input parameter[--dynamic_batch_size, --dynamic_image_size or --dynamic_dims] exist duplicate shapes.");
return PARAM_INVALID;
}
return SUCCESS;
}
///
/// @ingroup ge
/// @brief Get GeShape from configed shape.
/// @param [in] const std::vector<int64_t> &batch_shape: Configed shape.
/// @param [out] GeShape &data_shape: GeShape for configed shape.
/// @return SUCCESS / PARAM_INVALID
///
Status CalcShape(const std::vector<int64_t> &batch_shape, GeShape &data_shape) {
size_t batch_shape_index = 0;
for (size_t i = 0; i < data_shape.GetDimNum(); ++i) {
if (data_shape.GetDim(i) < 0) {
if (batch_shape_index >= batch_shape.size()) {
ErrorManager::GetInstance().ATCReportErrMessage(
"E19012", {"function", "reason"},
{"CalcShape", "the batch shape count " + std::to_string(batch_shape.size()) +
" does not match the data shape " + data_shape.ToString()});
GELOGE(PARAM_INVALID,
"Failed to calc tensor shape, the batch shape count %zu, does not match the data shape %s",
batch_shape.size(), data_shape.ToString().c_str());
return PARAM_INVALID;
}
data_shape.SetDim(i, batch_shape[batch_shape_index++]);
}
}
GELOGI("CalcShape size of batch_shape is %zu, batch_shape_index is %zu.", batch_shape.size(), batch_shape_index);
if (batch_shape_index != batch_shape.size()) {
ErrorManager::GetInstance().ATCReportErrMessage(
"E19012", {"function", "reason"}, {"CalcShape", "the batch shape count " + std::to_string(batch_shape.size()) +
" does not match the data shape " + data_shape.ToString()});
GELOGE(PARAM_INVALID, "Failed to calc tensor shape, the batch shape count %zu, does not match the data shape %s",
batch_shape.size(), data_shape.ToString().c_str());
return PARAM_INVALID;
}
return SUCCESS;
}
///
/// @ingroup ge
/// @brief Set mbatch_dynamic_type on node.
/// @param [in] const OpDescPtr &op_desc: Node for set attribute.
/// @return 0: SUCCESS / others: INTERNAL_ERROR
///
Status StampDynamicType(const OpDescPtr &op_desc) {
GE_CHECK_NOTNULL(op_desc);
int32_t dynamic_type = static_cast<int32_t>(FIXED);
if (!GetLocalOmgContext().dynamic_batch_size.empty()) {
dynamic_type = static_cast<int32_t>(DYNAMIC_BATCH);
}
if (!GetLocalOmgContext().dynamic_image_size.empty()) {
dynamic_type = static_cast<int32_t>(DYNAMIC_IMAGE);
}
if (!GetLocalOmgContext().dynamic_dims.empty()) {
dynamic_type = static_cast<int32_t>(DYNAMIC_DIMS);
}
if (!AttrUtils::SetInt(op_desc, ATTR_DYNAMIC_TYPE, dynamic_type)) {
GELOGE(INTERNAL_ERROR, "Failed to add dynamic type attr for node %s", op_desc->GetName().c_str());
return INTERNAL_ERROR;
}
return SUCCESS;
}
///
/// @ingroup ge
/// @brief Check dynamic batch Shape.
/// @param [in] const vector<int64_t> &shape: data_shape to be checked.
/// @param [in] const string &data_name: cur data name.
/// @return 0: true/false
///
bool CheckDynamicBatchShape(const vector<int64_t> &shape, const string &data_name) {
if (shape[0] == kDynmaicDims) {
for (size_t i = 1; i < shape.size(); ++i) {
if (shape[i] < 1) {
ErrorManager::GetInstance().ATCReportErrMessage("E10018", {"index", "shape"},
{std::to_string(i), std::to_string(shape[i])});
GELOGE(ge::PARAM_INVALID,
"Only batch N can be -1 when set --dynamic_batch_size, current data: %s shape[%zu] is %ld",
data_name.c_str(), i, shape[i]);
return false;
}
}
return true;
} else {
return false;
}
}
///
/// @ingroup ge
/// @brief Check Dynamic image size shape.
/// @param [in] unordered_map<string, vector<int64_t>> &shape_map: map of data_name and data_shape.
/// @param [in] const std::string &input_format: format of input.
/// @return 0: true/false
///
bool CheckDynamicImageSizeShape(const vector<int64_t> &shape, const string &data_name,
const std::string &input_format) {
int64_t height = 0;
int64_t width = 0;
if (input_format == "NCHW") {
height = shape[NCHW_DIM_H];
width = shape[NCHW_DIM_W];
}
if (input_format == "NHWC") {
height = shape[NHWC_DIM_H];
width = shape[NHWC_DIM_W];
}
if (height == kDynmaicDims && width == kDynmaicDims &&
std::count(shape.begin(), shape.end(), kDynmaicDims) == kDynamicImgSizeDynamciDimsNum) {
return true;
} else {
ErrorManager::GetInstance().ATCReportErrMessage("E10019");
GELOGE(ge::PARAM_INVALID,
"--input_shape's shape is invalid, only height and width can be -1 when set --dynamic_image_size.");
return false;
}
}
} // namespace multibatch
} // namespace ge
Reference in new issue View Git Blame Copy Permalink