experiments/STT-tensorflow
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Qualify uses of std::string

Browse Source 
PiperOrigin-RevId: 317003622
Change-Id: Iae6a9a287ffd3b97dee8b9993c443db322936592
This commit is contained in:
A. Unique TensorFlower 2020-06-17 17:56:36 -07:00 committed by TensorFlower Gardener
parent adf0573f9d
commit 56db128697
3 changed files with 77 additions and 72 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

67
tensorflow/lite/toco/logging/conversion_log_util.cc
View File

@ -34,8 +34,8 @@ namespace toco {
namespace { namespace {
string TryGetOperatorName(const Operator& op) { std::string TryGetOperatorName(const Operator& op) {
string op_name; std::string op_name;
if (!op.tensorflow_node_def.empty()) { if (!op.tensorflow_node_def.empty()) {
// Parse op name from serialized NodeDef. // Parse op name from serialized NodeDef.
tensorflow::NodeDef node_def; tensorflow::NodeDef node_def;
@ -63,8 +63,8 @@ string TryGetOperatorName(const Operator& op) {
return op_name; return op_name;
} }
string GetOSVersion() { std::string GetOSVersion() {
string os_info; std::string os_info;
#ifdef __linux__ #ifdef __linux__
utsname info; utsname info;
if (uname(&info)) { if (uname(&info)) {
@ -72,12 +72,13 @@ string GetOSVersion() {
LOG(ERROR) << "Cannot get OS info."; LOG(ERROR) << "Cannot get OS info.";
return ""; return "";
} }
os_info = string(info.sysname) + ";OSVer=" + string(info.release) + ";"; os_info =
std::string(info.sysname) + ";OSVer=" + std::string(info.release) + ";";
#endif #endif
return os_info; return os_info;
} }
string ShapeToStringNoSpace(const Shape& shape) { std::string ShapeToStringNoSpace(const Shape& shape) {
if (shape.dimensions_count() == 0) { if (shape.dimensions_count() == 0) {
return "[]"; return "[]";
} }
@ -85,13 +86,13 @@ string ShapeToStringNoSpace(const Shape& shape) {
return absl::StrCat("[", absl::StrJoin(shape.dims(), ","), "]"); return absl::StrCat("[", absl::StrJoin(shape.dims(), ","), "]");
} }
string GetOperatorSignature( std::string GetOperatorSignature(
const Model& model, const Operator& op, const Model& model, const Operator& op,
const std::map<OperatorType, std::unique_ptr<tflite::BaseOperator>>& const std::map<OperatorType, std::unique_ptr<tflite::BaseOperator>>&
op_types_map) { op_types_map) {
// The signature of an op has the following schema: // The signature of an op has the following schema:
// INPUT:SHAPE::TYPE::OUTPUT:SHAPE::TYPE::NAME:VERSION: // INPUT:SHAPE::TYPE::OUTPUT:SHAPE::TYPE::NAME:VERSION:
string op_signature; std::string op_signature;
constexpr char delimiter[] = "::"; constexpr char delimiter[] = "::";
// Get input shapes and types. // Get input shapes and types.
@ -137,8 +138,8 @@ string GetOperatorSignature(
} // namespace } // namespace
std::vector<string> GetOperatorNames(const Model& model) { std::vector<std::string> GetOperatorNames(const Model& model) {
std::vector<string> op_names; std::vector<std::string> op_names;
for (const auto& op : model.operators) { for (const auto& op : model.operators) {
op_names.push_back(TryGetOperatorName(*op)); op_names.push_back(TryGetOperatorName(*op));
} }
@ -146,9 +147,9 @@ std::vector<string> GetOperatorNames(const Model& model) {
} }
void CountOperatorsByType(const Model& model, void CountOperatorsByType(const Model& model,
std::map<string, int>* built_in_ops, std::map<std::string, int>* built_in_ops,
std::map<string, int>* custom_ops, std::map<std::string, int>* custom_ops,
std::map<string, int>* select_ops) { std::map<std::string, int>* select_ops) {
for (const auto& op : model.operators) { for (const auto& op : model.operators) {
OperatorSignature op_signature = {op.get(), &model}; OperatorSignature op_signature = {op.get(), &model};
const auto ops_by_type = const auto ops_by_type =
@ -156,7 +157,7 @@ void CountOperatorsByType(const Model& model,
tflite::details::OperatorKey op_key(op_signature, ops_by_type, tflite::details::OperatorKey op_key(op_signature, ops_by_type,
true /*enable_select_tf_ops*/); true /*enable_select_tf_ops*/);
const string op_name = TryGetOperatorName(*op); const std::string op_name = TryGetOperatorName(*op);
if (op_key.is_custom_op()) { if (op_key.is_custom_op()) {
(*custom_ops)[op_name]++; (*custom_ops)[op_name]++;
} else if (op_key.is_flex_op()) { } else if (op_key.is_flex_op()) {
@ -168,8 +169,9 @@ void CountOperatorsByType(const Model& model,
} }
void GetInputAndOutputTypes( void GetInputAndOutputTypes(
const Model& model, TFLITE_PROTO_NS::RepeatedPtrField<string>* input_types, const Model& model,
TFLITE_PROTO_NS::RepeatedPtrField<string>* output_types) { TFLITE_PROTO_NS::RepeatedPtrField<std::string>* input_types,
TFLITE_PROTO_NS::RepeatedPtrField<std::string>* output_types) {
for (const auto& input_array : model.flags.input_arrays()) { for (const auto& input_array : model.flags.input_arrays()) {
const Array& array = model.GetArray(input_array.name()); const Array& array = model.GetArray(input_array.name());
input_types->Add(ArrayDataTypeName(array.data_type)); input_types->Add(ArrayDataTypeName(array.data_type));
@ -180,15 +182,16 @@ void GetInputAndOutputTypes(
} }
} }
string GetTfLiteVersion() { return TFLITE_VERSION_STRING; } std::string GetTfLiteVersion() { return TFLITE_VERSION_STRING; }
string GetCachedOSVersion() { std::string GetCachedOSVersion() {
static string* version = new string(GetOSVersion()); static std::string* version = new std::string(GetOSVersion());
return *version; return *version;
} }
void GetOpSignatures(const Model& model, void GetOpSignatures(
TFLITE_PROTO_NS::RepeatedPtrField<string>* op_signatures) { const Model& model,
TFLITE_PROTO_NS::RepeatedPtrField<std::string>* op_signatures) {
const auto& op_types_map = const auto& op_types_map =
tflite::BuildOperatorByTypeMap(true /*enable_select_tf_ops*/); tflite::BuildOperatorByTypeMap(true /*enable_select_tf_ops*/);
for (const auto& op : model.operators) { for (const auto& op : model.operators) {
@ -196,7 +199,7 @@ void GetOpSignatures(const Model& model,
} }
} }
string GetModelHash(const Model& model) { std::string GetModelHash(const Model& model) {
// TODO(b/123519920): Implement the hash function for Model. // TODO(b/123519920): Implement the hash function for Model.
// Need to consider different implementations for public/private models. // Need to consider different implementations for public/private models.
return ""; return "";
@ -204,18 +207,18 @@ string GetModelHash(const Model& model) {
// This function scans through the error message string, extracts the part about // This function scans through the error message string, extracts the part about
// missing ops and prunes away all other information in the error info. // missing ops and prunes away all other information in the error info.
string SanitizeErrorMessage(const string& error_message) { std::string SanitizeErrorMessage(const std::string& error_message) {
const string s1 = "Ops that can be supported by the flex runtime"; const std::string s1 = "Ops that can be supported by the flex runtime";
const string s2 = "Ops that need custom implementation"; const std::string s2 = "Ops that need custom implementation";
string pruned_message; std::string pruned_message;
size_t pos = error_message.find(s1); size_t pos = error_message.find(s1);
if (pos != string::npos) { if (pos != std::string::npos) {
// Find the terminate point for flex op list. // Find the terminate point for flex op list.
auto end = error_message.find(".", pos); auto end = error_message.find(".", pos);
pruned_message.append(error_message.substr(pos, end - pos + 1)); pruned_message.append(error_message.substr(pos, end - pos + 1));
} }
pos = error_message.find(s2); pos = error_message.find(s2);
if (pos != string::npos) { if (pos != std::string::npos) {
// Find the terminate point for custom op list. // Find the terminate point for custom op list.
auto end = error_message.find(".", pos); auto end = error_message.find(".", pos);
pruned_message.append(error_message.substr(pos, end - pos + 1)); pruned_message.append(error_message.substr(pos, end - pos + 1));
@ -225,18 +228,18 @@ string SanitizeErrorMessage(const string& error_message) {
void PopulateConversionLog(const Model& model, TocoConversionLog* log) { void PopulateConversionLog(const Model& model, TocoConversionLog* log) {
// Get the list of ops after conversion. // Get the list of ops after conversion.
const std::vector<string> op_names = GetOperatorNames(model); const std::vector<std::string> op_names = GetOperatorNames(model);
for (const auto& op_name : op_names) { for (const auto& op_name : op_names) {
log->add_op_list(op_name); log->add_op_list(op_name);
} }
// Get op signatures. // Get op signatures.
TFLITE_PROTO_NS::RepeatedPtrField<string> op_signatures; TFLITE_PROTO_NS::RepeatedPtrField<std::string> op_signatures;
GetOpSignatures(model, &op_signatures); GetOpSignatures(model, &op_signatures);
log->mutable_op_signatures()->CopyFrom(op_signatures); log->mutable_op_signatures()->CopyFrom(op_signatures);
// Get op counts by category: custom, built-in or select. // Get op counts by category: custom, built-in or select.
std::map<string, int> custom_ops, select_ops, built_in_ops; std::map<std::string, int> custom_ops, select_ops, built_in_ops;
CountOperatorsByType(model, &built_in_ops, &custom_ops, &select_ops); CountOperatorsByType(model, &built_in_ops, &custom_ops, &select_ops);
log->mutable_custom_ops()->insert(custom_ops.cbegin(), custom_ops.cend()); log->mutable_custom_ops()->insert(custom_ops.cbegin(), custom_ops.cend());
log->mutable_built_in_ops()->insert(built_in_ops.cbegin(), log->mutable_built_in_ops()->insert(built_in_ops.cbegin(),
@ -244,7 +247,7 @@ void PopulateConversionLog(const Model& model, TocoConversionLog* log) {
log->mutable_select_ops()->insert(select_ops.cbegin(), select_ops.cend()); log->mutable_select_ops()->insert(select_ops.cbegin(), select_ops.cend());
// Get the model's input and output types. // Get the model's input and output types.
TFLITE_PROTO_NS::RepeatedPtrField<string> input_types, output_types; TFLITE_PROTO_NS::RepeatedPtrField<std::string> input_types, output_types;
GetInputAndOutputTypes(model, &input_types, &output_types); GetInputAndOutputTypes(model, &input_types, &output_types);
log->mutable_input_tensor_types()->CopyFrom(input_types); log->mutable_input_tensor_types()->CopyFrom(input_types);
log->mutable_output_tensor_types()->CopyFrom(output_types); log->mutable_output_tensor_types()->CopyFrom(output_types);

22
tensorflow/lite/toco/logging/conversion_log_util.h
View File

@ -25,37 +25,39 @@ namespace toco {
// This function scans through the error message string, extracts the part about // This function scans through the error message string, extracts the part about
// missing ops and prunes away all other information in the error info. // missing ops and prunes away all other information in the error info.
string SanitizeErrorMessage(const string& error_message); std::string SanitizeErrorMessage(const std::string& error_message);
// Populates the TocoConversionLog proto after analyzing the model. // Populates the TocoConversionLog proto after analyzing the model.
void PopulateConversionLog(const Model& model, TocoConversionLog* log); void PopulateConversionLog(const Model& model, TocoConversionLog* log);
// Returns the names of the operators in the model. // Returns the names of the operators in the model.
std::vector<string> GetOperatorNames(const Model& model); std::vector<std::string> GetOperatorNames(const Model& model);
// Counts the number of different types of operators in the model: // Counts the number of different types of operators in the model:
// Built-in ops, custom ops and select ops. // Built-in ops, custom ops and select ops.
// Each map is mapping from the name of the operator (such as 'Conv') to its // Each map is mapping from the name of the operator (such as 'Conv') to its
// total number of occurrences in the model. // total number of occurrences in the model.
void CountOperatorsByType(const Model& model, void CountOperatorsByType(const Model& model,
std::map<string, int>* built_in_ops, std::map<std::string, int>* built_in_ops,
std::map<string, int>* custom_ops, std::map<std::string, int>* custom_ops,
std::map<string, int>* select_ops); std::map<std::string, int>* select_ops);
// Gets the input and output types of the model. The input and output is // Gets the input and output types of the model. The input and output is
// specified by model.flags.input_arrays and model.flags.output_arrays. // specified by model.flags.input_arrays and model.flags.output_arrays.
void GetInputAndOutputTypes( void GetInputAndOutputTypes(
const Model& model, TFLITE_PROTO_NS::RepeatedPtrField<string>* input_types, const Model& model,
TFLITE_PROTO_NS::RepeatedPtrField<string>* output_types); TFLITE_PROTO_NS::RepeatedPtrField<std::string>* input_types,
TFLITE_PROTO_NS::RepeatedPtrField<std::string>* output_types);
// Calculates signatures for all the ops in the model. An op signature is // Calculates signatures for all the ops in the model. An op signature is
// defined by its input/output shapes and types, op name and its version. // defined by its input/output shapes and types, op name and its version.
void GetOpSignatures(const Model& model, void GetOpSignatures(
TFLITE_PROTO_NS::RepeatedPtrField<string>* op_signatures); const Model& model,
TFLITE_PROTO_NS::RepeatedPtrField<std::string>* op_signatures);
// TODO(b/123519920): Implement this. // TODO(b/123519920): Implement this.
// Calculates a unique hash for the model. // Calculates a unique hash for the model.
string GetModelHash(const Model& model); std::string GetModelHash(const Model& model);
} // namespace toco } // namespace toco

60
tensorflow/lite/toco/logging/conversion_log_util_test.cc
View File

@ -58,9 +58,9 @@ TEST(ConversionLogUtilTest, TestCountOperatorsByType) {
Model model; Model model;
// 1st Conv operator. // 1st Conv operator.
std::unique_ptr<ConvOperator> conv1(new ConvOperator()); std::unique_ptr<ConvOperator> conv1(new ConvOperator());
const string conv1_input_name = "conv_input1"; const std::string conv1_input_name = "conv_input1";
const string conv1_filter_name = "conv_filter1"; const std::string conv1_filter_name = "conv_filter1";
const string conv1_output_name = "conv_output1"; const std::string conv1_output_name = "conv_output1";
conv1->inputs.push_back(conv1_input_name); conv1->inputs.push_back(conv1_input_name);
conv1->inputs.push_back(conv1_filter_name); conv1->inputs.push_back(conv1_filter_name);
conv1->outputs.push_back(conv1_output_name); conv1->outputs.push_back(conv1_output_name);
@ -71,9 +71,9 @@ TEST(ConversionLogUtilTest, TestCountOperatorsByType) {
// 2nd Conv operator. // 2nd Conv operator.
std::unique_ptr<ConvOperator> conv2(new ConvOperator()); std::unique_ptr<ConvOperator> conv2(new ConvOperator());
const string conv2_input_name = "conv_input2"; const std::string conv2_input_name = "conv_input2";
const string conv2_filter_name = "conv_filter2"; const std::string conv2_filter_name = "conv_filter2";
const string conv2_output_name = "conv_output2"; const std::string conv2_output_name = "conv_output2";
conv2->inputs.push_back(conv2_input_name); conv2->inputs.push_back(conv2_input_name);
conv2->inputs.push_back(conv2_filter_name); conv2->inputs.push_back(conv2_filter_name);
conv2->outputs.push_back(conv2_output_name); conv2->outputs.push_back(conv2_output_name);
@ -83,7 +83,7 @@ TEST(ConversionLogUtilTest, TestCountOperatorsByType) {
// Mean operator. // Mean operator.
std::unique_ptr<MeanOperator> mean(new MeanOperator()); std::unique_ptr<MeanOperator> mean(new MeanOperator());
const string mean_input_name = "mean_input"; const std::string mean_input_name = "mean_input";
mean->inputs.push_back(mean_input_name); mean->inputs.push_back(mean_input_name);
array_map[mean_input_name] = std::unique_ptr<Array>(new Array); array_map[mean_input_name] = std::unique_ptr<Array>(new Array);
@ -111,26 +111,26 @@ TEST(ConversionLogUtilTest, TestCountOperatorsByType) {
model.operators.push_back(std::move(elu_grad)); model.operators.push_back(std::move(elu_grad));
model.operators.push_back(std::move(my_custom_op)); model.operators.push_back(std::move(my_custom_op));
std::map<string, int> built_in_ops, select_ops, custom_ops; std::map<std::string, int> built_in_ops, select_ops, custom_ops;
CountOperatorsByType(model, &built_in_ops, &custom_ops, &select_ops); CountOperatorsByType(model, &built_in_ops, &custom_ops, &select_ops);
EXPECT_THAT(built_in_ops, EXPECT_THAT(built_in_ops,
UnorderedElementsAre(std::pair<string, int>("Conv", 2), UnorderedElementsAre(std::pair<std::string, int>("Conv", 2),
std::pair<string, int>("Mean", 1))); std::pair<std::string, int>("Mean", 1)));
EXPECT_THAT(select_ops, EXPECT_THAT(select_ops,
UnorderedElementsAre(std::pair<string, int>("AvgPool3D", 1), UnorderedElementsAre(std::pair<std::string, int>("AvgPool3D", 1),
std::pair<string, int>("EluGrad", 1))); std::pair<std::string, int>("EluGrad", 1)));
EXPECT_THAT(custom_ops, UnorderedElementsAre( EXPECT_THAT(custom_ops, UnorderedElementsAre(std::pair<std::string, int>(
std::pair<string, int>("MyAwesomeCustomOp", 1))); "MyAwesomeCustomOp", 1)));
} }
TEST(ConversionLogUtilTest, TestGetInputAndOutputTypes) { TEST(ConversionLogUtilTest, TestGetInputAndOutputTypes) {
Model model; Model model;
auto& array_map = model.GetMutableArrayMap(); auto& array_map = model.GetMutableArrayMap();
const string input1 = "conv_input"; const std::string input1 = "conv_input";
const string input2 = "conv_filter"; const std::string input2 = "conv_filter";
const string input3 = "feature"; const std::string input3 = "feature";
const string output = "softmax"; const std::string output = "softmax";
array_map[input1] = std::unique_ptr<Array>(new Array); array_map[input1] = std::unique_ptr<Array>(new Array);
array_map[input1]->data_type = ArrayDataType::kFloat; array_map[input1]->data_type = ArrayDataType::kFloat;
array_map[input2] = std::unique_ptr<Array>(new Array); array_map[input2] = std::unique_ptr<Array>(new Array);
@ -149,7 +149,7 @@ TEST(ConversionLogUtilTest, TestGetInputAndOutputTypes) {
*model.flags.add_input_arrays() = input_arrays[2]; *model.flags.add_input_arrays() = input_arrays[2];
model.flags.add_output_arrays(output); model.flags.add_output_arrays(output);
TFLITE_PROTO_NS::RepeatedPtrField<string> input_types, output_types; TFLITE_PROTO_NS::RepeatedPtrField<std::string> input_types, output_types;
GetInputAndOutputTypes(model, &input_types, &output_types); GetInputAndOutputTypes(model, &input_types, &output_types);
EXPECT_THAT(input_types, ElementsAre("float", "float", "int16")); EXPECT_THAT(input_types, ElementsAre("float", "float", "int16"));
@ -161,9 +161,9 @@ TEST(ConversionLogUtilTest, TestGetOpSignatures) {
auto& array_map = model.GetMutableArrayMap(); auto& array_map = model.GetMutableArrayMap();
std::unique_ptr<ConvOperator> conv(new ConvOperator()); std::unique_ptr<ConvOperator> conv(new ConvOperator());
const string conv_input_name = "conv_input"; const std::string conv_input_name = "conv_input";
const string conv_filter_name = "conv_filter"; const std::string conv_filter_name = "conv_filter";
const string conv_output_name = "conv_output"; const std::string conv_output_name = "conv_output";
conv->inputs.push_back(conv_input_name); conv->inputs.push_back(conv_input_name);
conv->inputs.push_back(conv_filter_name); conv->inputs.push_back(conv_filter_name);
conv->outputs.push_back(conv_output_name); conv->outputs.push_back(conv_output_name);
@ -177,15 +177,15 @@ TEST(ConversionLogUtilTest, TestGetOpSignatures) {
array_map[conv_output_name]->data_type = ArrayDataType::kFloat; array_map[conv_output_name]->data_type = ArrayDataType::kFloat;
array_map[conv_output_name]->copy_shape({4, 4, 2}); array_map[conv_output_name]->copy_shape({4, 4, 2});
const string mean_input_name = "mean_input"; const std::string mean_input_name = "mean_input";
const string mean_output_name = "mean_output"; const std::string mean_output_name = "mean_output";
std::unique_ptr<MeanOperator> mean(new MeanOperator()); std::unique_ptr<MeanOperator> mean(new MeanOperator());
mean->inputs.push_back(mean_input_name); mean->inputs.push_back(mean_input_name);
mean->outputs.push_back(mean_output_name); mean->outputs.push_back(mean_output_name);
array_map[mean_input_name] = std::unique_ptr<Array>(new Array); array_map[mean_input_name] = std::unique_ptr<Array>(new Array);
array_map[mean_output_name] = std::unique_ptr<Array>(new Array); array_map[mean_output_name] = std::unique_ptr<Array>(new Array);
const string avg_pool_3d_output_name = "avg_pool_output"; const std::string avg_pool_3d_output_name = "avg_pool_output";
auto avg_pool_3d = absl::make_unique<TensorFlowUnsupportedOperator>(); auto avg_pool_3d = absl::make_unique<TensorFlowUnsupportedOperator>();
avg_pool_3d->tensorflow_op = "AvgPool3D"; avg_pool_3d->tensorflow_op = "AvgPool3D";
tensorflow::NodeDef node_def; tensorflow::NodeDef node_def;
@ -197,7 +197,7 @@ TEST(ConversionLogUtilTest, TestGetOpSignatures) {
array_map[avg_pool_3d_output_name]->data_type = ArrayDataType::kInt32; array_map[avg_pool_3d_output_name]->data_type = ArrayDataType::kInt32;
array_map[avg_pool_3d_output_name]->copy_shape({2, 2}); array_map[avg_pool_3d_output_name]->copy_shape({2, 2});
const string custom_op_output_name = "custom_op_output"; const std::string custom_op_output_name = "custom_op_output";
auto my_custom_op = absl::make_unique<TensorFlowUnsupportedOperator>(); auto my_custom_op = absl::make_unique<TensorFlowUnsupportedOperator>();
my_custom_op->tensorflow_op = "MyAwesomeCustomOp"; my_custom_op->tensorflow_op = "MyAwesomeCustomOp";
my_custom_op->inputs.push_back(avg_pool_3d_output_name); my_custom_op->inputs.push_back(avg_pool_3d_output_name);
@ -211,7 +211,7 @@ TEST(ConversionLogUtilTest, TestGetOpSignatures) {
model.operators.push_back(std::move(avg_pool_3d)); model.operators.push_back(std::move(avg_pool_3d));
model.operators.push_back(std::move(my_custom_op)); model.operators.push_back(std::move(my_custom_op));
TFLITE_PROTO_NS::RepeatedPtrField<string> op_signatures; TFLITE_PROTO_NS::RepeatedPtrField<std::string> op_signatures;
GetOpSignatures(model, &op_signatures); GetOpSignatures(model, &op_signatures);
EXPECT_THAT(op_signatures, EXPECT_THAT(op_signatures,
UnorderedElementsAre( UnorderedElementsAre(
@ -225,14 +225,14 @@ TEST(ConversionLogUtilTest, TestGetOpSignatures) {
} }
TEST(ConversionLogUtilTest, TestSanitizeErrorMessage) { TEST(ConversionLogUtilTest, TestSanitizeErrorMessage) {
const string error = const std::string error =
"error: failed while converting: 'main': Ops that can be supported by " "error: failed while converting: 'main': Ops that can be supported by "
"the flex runtime (enabled via setting the -emit-select-tf-ops flag): " "the flex runtime (enabled via setting the -emit-select-tf-ops flag): "
"ResizeNearestNeighbor,ResizeNearestNeighbor. Ops that need custom " "ResizeNearestNeighbor,ResizeNearestNeighbor. Ops that need custom "
"implementation (enabled via setting the -emit-custom-ops flag): " "implementation (enabled via setting the -emit-custom-ops flag): "
"CombinedNonMaxSuppression.\nTraceback (most recent call last): File " "CombinedNonMaxSuppression.\nTraceback (most recent call last): File "
"/usr/local/bin/toco_from_protos, line 8, in <module>"; "/usr/local/bin/toco_from_protos, line 8, in <module>";
const string pruned_error = const std::string pruned_error =
"Ops that can be supported by " "Ops that can be supported by "
"the flex runtime (enabled via setting the -emit-select-tf-ops flag): " "the flex runtime (enabled via setting the -emit-select-tf-ops flag): "
"ResizeNearestNeighbor,ResizeNearestNeighbor.Ops that need custom " "ResizeNearestNeighbor,ResizeNearestNeighbor.Ops that need custom "
@ -242,7 +242,7 @@ TEST(ConversionLogUtilTest, TestSanitizeErrorMessage) {
} }
TEST(ConversionLogUtilTest, TestSanitizeErrorMessageNoMatching) { TEST(ConversionLogUtilTest, TestSanitizeErrorMessageNoMatching) {
const string error = const std::string error =
"error: failed while converting: 'main': Traceback (most recent call " "error: failed while converting: 'main': Traceback (most recent call "
"last): File " "last): File "
"/usr/local/bin/toco_from_protos, line 8, in <module>"; "/usr/local/bin/toco_from_protos, line 8, in <module>";