m53297601
/
mindspore
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

rmv error log

Browse Source
pull/7889/head
cjh9368 4 years ago
parent ea4df3c3c2
commit b54f7006d1
3 changed files with 37 additions and 35 deletions
Show Stats Download Patch File Download Diff File

7
mindspore/lite/tools/converter/legacy_optimizer/graph/infer_quant_param_pass.cc
Unescape View File

@ -13,10 +13,11 @@
* See the License for the specific language governing permissions and * See the License for the specific language governing permissions and
* limitations under the License. * limitations under the License.
*/ */
#include "tools/converter/legacy_optimizer/graph/infer_quant_param_pass.h"
#include <vector> #include <vector>
#include <memory> #include <memory>
#include "src/common/utils.h" #include "src/common/utils.h"
#include "tools/converter/legacy_optimizer/graph/infer_quant_param_pass.h"
#include "tools/converter/quantizer/calc_quant_param.h" #include "tools/converter/quantizer/calc_quant_param.h"
#include "tools/common/node_util.h" #include "tools/common/node_util.h"
@ -40,13 +41,13 @@ STATUS InferQuantParamPass::Run(schema::MetaGraphT *graph) {
} }
auto quantParamCalcer = quantParamRegister->GetQuantParamCalcer(GetCNodeTType(*node)); auto quantParamCalcer = quantParamRegister->GetQuantParamCalcer(GetCNodeTType(*node));
if (quantParamCalcer == nullptr) { if (quantParamCalcer == nullptr) {
MS_LOG(WARNING) << "Can not find QuantParamCalcer for " << node->name.c_str() MS_LOG(DEBUG) << "Can not find QuantParamCalcer for " << node->name.c_str()
<< ", type: " << GetCNodeTTypeName(*node).c_str() << " set node to QuantNone and skip"; << ", type: " << GetCNodeTTypeName(*node).c_str() << " set node to QuantNone and skip";
node->quantType = schema::QuantType_QUANT_NONE; node->quantType = schema::QuantType_QUANT_NONE;
} else { } else {
auto status = quantParamCalcer->Calc(graph, *node); auto status = quantParamCalcer->Calc(graph, *node);
if (status != RET_OK) { if (status != RET_OK) {
MS_LOG(WARNING) << "quantParamCalcer failed: " << status << " node: " << node->name.c_str(); MS_LOG(DEBUG) << "quantParamCalcer failed: " << status << " node: " << node->name.c_str();
node->quantType = schema::QuantType_QUANT_NONE; node->quantType = schema::QuantType_QUANT_NONE;
} else { } else {
node->quantType = schema::QuantType_AwareTraining; node->quantType = schema::QuantType_AwareTraining;

3
mindspore/lite/tools/converter/legacy_optimizer/graph/tensor_quant_pass.cc
Unescape View File

@ -85,7 +85,8 @@ STATUS TensorQuantPass::Run(schema::MetaGraphT *graph) {
return RET_ERROR; return RET_ERROR;
} }
} }
} else { // pertensor } else { // perchannel
MS_LOG(ERROR) << "perchannel doquant is not supported yet";
} }
} }
return RET_OK; return RET_OK;

60
mindspore/lite/tools/converter/quantizer/calc_quant_param.cc
Unescape View File

@ -36,7 +36,7 @@ STATUS QuantParamCalcer::ComputeConstQuantParam(const schema::TensorT &tensor, Q
return RET_OK; return RET_OK;
} }
if (tensor.dataType != TypeId::kNumberTypeFloat) { if (tensor.dataType != TypeId::kNumberTypeFloat) {
MS_LOG(ERROR) << "Const Tensor without quantParam should has float dataType, in fact: " << tensor.dataType; MS_LOG(DEBUG) << "Const Tensor without quantParam should has float dataType, in fact: " << tensor.dataType;
return RET_ERROR; return RET_ERROR;
} }
const auto *constData = reinterpret_cast<const float *>(tensor.data.data()); const auto *constData = reinterpret_cast<const float *>(tensor.data.data());
@ -115,15 +115,15 @@ int QuantParamCalcer::Calc(MetaGraphT *graph, const CNodeT &node) {
int CommonCalcer::Calc(MetaGraphT *subGraph, const CNodeT &node) { int CommonCalcer::Calc(MetaGraphT *subGraph, const CNodeT &node) {
auto status = QuantParamCalcer::Calc(subGraph, node); auto status = QuantParamCalcer::Calc(subGraph, node);
if (status != RET_OK) { if (status != RET_OK) {
MS_LOG(ERROR) << "Call QuantParamCalcer::Calc failed: " << status; MS_LOG(DEBUG) << "Call QuantParamCalcer::Calc failed: " << status;
return status; return status;
} }
if (inputParamDone != node.inputIndex.size()) { if (inputParamDone != node.inputIndex.size()) {
MS_LOG(ERROR) << "Can not determine inputTensor quantParam, node " << node.name; MS_LOG(DEBUG) << "Can not determine inputTensor quantParam, node " << node.name;
return RET_ERROR; return RET_ERROR;
} }
if (outputParamDone != node.outputIndex.size()) { if (outputParamDone != node.outputIndex.size()) {
MS_LOG(ERROR) << "Can not determine outputTensor quantParam, node " << node.name; MS_LOG(DEBUG) << "Can not determine outputTensor quantParam, node " << node.name;
return RET_ERROR; return RET_ERROR;
} }
return RET_OK; return RET_OK;
@ -132,7 +132,7 @@ int CommonCalcer::Calc(MetaGraphT *subGraph, const CNodeT &node) {
int ConvCalcer::Calc(MetaGraphT *subGraph, const CNodeT &node) { int ConvCalcer::Calc(MetaGraphT *subGraph, const CNodeT &node) {
auto status = CommonCalcer::Calc(subGraph, node); auto status = CommonCalcer::Calc(subGraph, node);
if (status != RET_OK) { if (status != RET_OK) {
MS_LOG(WARNING) << "Call CommonCalcer::Calc failed: " << status; MS_LOG(DEBUG) << "Call CommonCalcer::Calc failed: " << status;
return status; return status;
} }
if (node.inputIndex.size() == BIAS_SIZE) { if (node.inputIndex.size() == BIAS_SIZE) {
@ -147,7 +147,7 @@ int ConvCalcer::Calc(MetaGraphT *subGraph, const CNodeT &node) {
int BiasAddCalcer::Calc(MetaGraphT *subGraph, const CNodeT &node) { int BiasAddCalcer::Calc(MetaGraphT *subGraph, const CNodeT &node) {
auto status = CommonCalcer::Calc(subGraph, node); auto status = CommonCalcer::Calc(subGraph, node);
if (status != RET_OK) { if (status != RET_OK) {
MS_LOG(WARNING) << "Call CommonCalcer::Calc failed: " << status; MS_LOG(DEBUG) << "Call CommonCalcer::Calc failed: " << status;
return status; return status;
} }
if (node.inputIndex.size() == BIAS_ADD_SIZE) { if (node.inputIndex.size() == BIAS_ADD_SIZE) {
@ -162,7 +162,7 @@ int BiasAddCalcer::Calc(MetaGraphT *subGraph, const CNodeT &node) {
int LinearCalcer::Calc(MetaGraphT *graph, const CNodeT &node) { int LinearCalcer::Calc(MetaGraphT *graph, const CNodeT &node) {
auto status = QuantParamCalcer::Calc(graph, node); auto status = QuantParamCalcer::Calc(graph, node);
if (status != RET_OK) { if (status != RET_OK) {
MS_LOG(ERROR) << "Call QuantParamCalcer::Calc failed: " << status; MS_LOG(DEBUG) << "Call QuantParamCalcer::Calc failed: " << status;
return status; return status;
} }
if (inputParamDone != node.inputIndex.size()) { if (inputParamDone != node.inputIndex.size()) {
@ -172,7 +172,7 @@ int LinearCalcer::Calc(MetaGraphT *graph, const CNodeT &node) {
auto outputQuantParam = GetTensorQuantParam(outTensor); auto outputQuantParam = GetTensorQuantParam(outTensor);
MS_ASSERT(outputQuantParam != nullptr); MS_ASSERT(outputQuantParam != nullptr);
if (outputQuantParam == nullptr || !outputQuantParam->inited) { if (outputQuantParam == nullptr || !outputQuantParam->inited) {
MS_LOG(ERROR) << "Can not determine inputTensor quantParam from outputTensor for node " << node.name; MS_LOG(DEBUG) << "Can not determine inputTensor quantParam from outputTensor for node " << node.name;
return RET_ERROR; return RET_ERROR;
} }
for (unsigned int i : node.inputIndex) { for (unsigned int i : node.inputIndex) {
@ -192,7 +192,7 @@ int LinearCalcer::Calc(MetaGraphT *graph, const CNodeT &node) {
MS_ASSERT(inTensor != nullptr); MS_ASSERT(inTensor != nullptr);
auto inQuantParam = GetTensorQuantParam(inTensor); auto inQuantParam = GetTensorQuantParam(inTensor);
if (inQuantParam == nullptr || !inQuantParam->inited) { if (inQuantParam == nullptr || !inQuantParam->inited) {
MS_LOG(ERROR) << "Can not determine outputTensor quantParam from inputTensor for node %s" << node.name; MS_LOG(DEBUG) << "Can not determine outputTensor quantParam from inputTensor for node %s" << node.name;
return RET_ERROR; return RET_ERROR;
} }
for (size_t i = 0; i < node.outputIndex.size(); i++) { for (size_t i = 0; i < node.outputIndex.size(); i++) {
@ -222,12 +222,12 @@ class CalcConcat : public QuantParamCalcer {
MS_ASSERT(node.outputIndex.size() == 1); MS_ASSERT(node.outputIndex.size() == 1);
auto status = QuantParamCalcer::Calc(graph, node); auto status = QuantParamCalcer::Calc(graph, node);
if (status != RET_OK) { if (status != RET_OK) {
MS_LOG(ERROR) << "Call QuantParamCalcer::Calc failed: " << status; MS_LOG(DEBUG) << "Call QuantParamCalcer::Calc failed: " << status;
return status; return status;
} }
if (inputParamDone != node.inputIndex.size()) { if (inputParamDone != node.inputIndex.size()) {
MS_LOG(ERROR) << "Can not determine concat inputTensor quantParam, node " << node.name; MS_LOG(DEBUG) << "Can not determine concat inputTensor quantParam, node " << node.name;
return RET_ERROR; return RET_ERROR;
} }
@ -267,7 +267,7 @@ class CalcConcat : public QuantParamCalcer {
status = quant::CalQuantizationParams(outQuantParam.get(), minMin, maxMax, narrowRange, numBits); status = quant::CalQuantizationParams(outQuantParam.get(), minMin, maxMax, narrowRange, numBits);
if (status != RET_OK) { if (status != RET_OK) {
MS_LOG(ERROR) << "in aware quantization run CalQuantizationParams failed!"; MS_LOG(DEBUG) << "in aware quantization run CalQuantizationParams failed!";
return RET_ERROR; return RET_ERROR;
} }
outTensor->quantParams.emplace_back(std::move(outQuantParam)); outTensor->quantParams.emplace_back(std::move(outQuantParam));
@ -288,12 +288,12 @@ class CalcAdd : public QuantParamCalcer {
MS_ASSERT(node.outputIndex.size() == 1); MS_ASSERT(node.outputIndex.size() == 1);
auto status = QuantParamCalcer::Calc(graph, node); auto status = QuantParamCalcer::Calc(graph, node);
if (status != RET_OK) { if (status != RET_OK) {
MS_LOG(ERROR) << "Call QuantParamCalcer::Calc failed: " << status; MS_LOG(DEBUG) << "Call QuantParamCalcer::Calc failed: " << status;
return status; return status;
} }
if (inputParamDone != 2) { if (inputParamDone != 2) {
MS_LOG(ERROR) << "Can not determine add inputTensor quantParam, node " << node.name; MS_LOG(DEBUG) << "Can not determine add inputTensor quantParam, node " << node.name;
return RET_ERROR; return RET_ERROR;
} }
if (outputParamDone != 1) { if (outputParamDone != 1) {
@ -318,7 +318,7 @@ class CalcAdd : public QuantParamCalcer {
biasTensor = &tensor1; biasTensor = &tensor1;
paramTensor = &tensor0; paramTensor = &tensor0;
} else { } else {
MS_LOG(ERROR) << "Can not determine add outputTensor quantParam, node " << node.name; MS_LOG(DEBUG) << "Can not determine add outputTensor quantParam, node " << node.name;
return RET_ERROR; return RET_ERROR;
} }
auto quantParam = GetTensorQuantParam(*paramTensor); auto quantParam = GetTensorQuantParam(*paramTensor);
@ -333,7 +333,7 @@ class CalcAdd : public QuantParamCalcer {
auto *bias = static_cast<float *>(oriTensorData); auto *bias = static_cast<float *>(oriTensorData);
status = quant::CalQuantizationParams(outQuantParam.get(), min + (*bias), max + (*bias)); status = quant::CalQuantizationParams(outQuantParam.get(), min + (*bias), max + (*bias));
if (status != RET_OK) { if (status != RET_OK) {
MS_LOG(ERROR) << "in aware quantization run CalQuantizationParams failed!"; MS_LOG(DEBUG) << "in aware quantization run CalQuantizationParams failed!";
return RET_ERROR; return RET_ERROR;
} }
} else if ((*biasTensor)->dataType == TypeId::kNumberTypeUInt8) { } else if ((*biasTensor)->dataType == TypeId::kNumberTypeUInt8) {
@ -342,11 +342,11 @@ class CalcAdd : public QuantParamCalcer {
auto *bias = static_cast<uint8_t *>(oriTensorData); auto *bias = static_cast<uint8_t *>(oriTensorData);
status = quant::CalQuantizationParams(outQuantParam.get(), min + (*bias), max + (*bias)); status = quant::CalQuantizationParams(outQuantParam.get(), min + (*bias), max + (*bias));
if (status != RET_OK) { if (status != RET_OK) {
MS_LOG(ERROR) << "in aware quantization run CalQuantizationParams failed!"; MS_LOG(DEBUG) << "in aware quantization run CalQuantizationParams failed!";
return RET_ERROR; return RET_ERROR;
} }
} else { } else {
MS_LOG(ERROR) << "Unsupported tensor dataType: " << (*biasTensor)->dataType; MS_LOG(DEBUG) << "Unsupported tensor dataType: " << (*biasTensor)->dataType;
return RET_ERROR; return RET_ERROR;
} }
} }
@ -366,12 +366,12 @@ class CalcRealDiv : public QuantParamCalcer {
MS_ASSERT(node.outputIndex.size() == 1); MS_ASSERT(node.outputIndex.size() == 1);
auto status = QuantParamCalcer::Calc(graph, node); auto status = QuantParamCalcer::Calc(graph, node);
if (status != RET_OK) { if (status != RET_OK) {
MS_LOG(ERROR) << "Call QuantParamCalcer::Calc failed: " << status; MS_LOG(DEBUG) << "Call QuantParamCalcer::Calc failed: " << status;
return status; return status;
} }
if (inputParamDone != 2) { if (inputParamDone != 2) {
MS_LOG(ERROR) << "Can not determine realdiv inputTensor quantParam, node " << node.name; MS_LOG(DEBUG) << "Can not determine realdiv inputTensor quantParam, node " << node.name;
return RET_ERROR; return RET_ERROR;
} }
if (outputParamDone != 1) { if (outputParamDone != 1) {
@ -397,7 +397,7 @@ class CalcRealDiv : public QuantParamCalcer {
MS_ASSERT(*div != 0); MS_ASSERT(*div != 0);
status = quant::CalQuantizationParams(outQuantParam.get(), min / (*div), max / (*div)); status = quant::CalQuantizationParams(outQuantParam.get(), min / (*div), max / (*div));
if (status != RET_OK) { if (status != RET_OK) {
MS_LOG(ERROR) << "in aware quantization run CalQuantizationParams failed!"; MS_LOG(DEBUG) << "in aware quantization run CalQuantizationParams failed!";
return RET_ERROR; return RET_ERROR;
} }
} else if (tensor1->dataType == TypeId::kNumberTypeUInt8) { } else if (tensor1->dataType == TypeId::kNumberTypeUInt8) {
@ -406,17 +406,17 @@ class CalcRealDiv : public QuantParamCalcer {
auto *div = static_cast<uint8_t *>(oriTensorData); auto *div = static_cast<uint8_t *>(oriTensorData);
status = quant::CalQuantizationParams(outQuantParam.get(), min / (*div), max + (*div)); status = quant::CalQuantizationParams(outQuantParam.get(), min / (*div), max + (*div));
if (status != RET_OK) { if (status != RET_OK) {
MS_LOG(ERROR) << "in aware quantization run CalQuantizationParams failed!"; MS_LOG(DEBUG) << "in aware quantization run CalQuantizationParams failed!";
return RET_ERROR; return RET_ERROR;
} }
} else { } else {
MS_LOG(ERROR) << "Unsupported tensor dataType: " << tensor1->dataType; MS_LOG(DEBUG) << "Unsupported tensor dataType: " << tensor1->dataType;
return RET_ERROR; return RET_ERROR;
} }
outTensor->quantParams.front() = std::move(outQuantParam); outTensor->quantParams.front() = std::move(outQuantParam);
} }
} else { } else {
MS_LOG(ERROR) << "Can not determine realDiv outputTensor quantParam, node " << node.name; MS_LOG(DEBUG) << "Can not determine realDiv outputTensor quantParam, node " << node.name;
return RET_ERROR; return RET_ERROR;
} }
} }
@ -434,19 +434,19 @@ class CalcToSet : public QuantParamCalcer {
MS_ASSERT(node.outputIndex.size() == 1); MS_ASSERT(node.outputIndex.size() == 1);
auto status = QuantParamCalcer::Calc(graph, node); auto status = QuantParamCalcer::Calc(graph, node);
if (status != RET_OK) { if (status != RET_OK) {
MS_LOG(ERROR) << "Call QuantParamCalcer::Calc failed: %d" << status; MS_LOG(DEBUG) << "Call QuantParamCalcer::Calc failed: %d" << status;
return status; return status;
} }
// input // input
if (inputParamDone != node.inputIndex.size()) { if (inputParamDone != node.inputIndex.size()) {
MS_LOG(ERROR) << "Can not determine inputTensor quantParam, node " << node.name; MS_LOG(DEBUG) << "Can not determine inputTensor quantParam, node " << node.name;
return RET_ERROR; return RET_ERROR;
} }
// output // output
if (outputParamDone != node.outputIndex.size()) { if (outputParamDone != node.outputIndex.size()) {
std::unique_ptr<QuantParamT> quantParam = std::make_unique<QuantParamT>(); std::unique_ptr<QuantParamT> quantParam = std::make_unique<QuantParamT>();
if (quantParam == nullptr) { if (quantParam == nullptr) {
MS_LOG(ERROR) << "new QuantParamT failed"; MS_LOG(DEBUG) << "new QuantParamT failed";
return RET_ERROR; return RET_ERROR;
} }
quantParam->scale = (max - min) / 256; quantParam->scale = (max - min) / 256;
@ -493,18 +493,18 @@ QuantParamCalcRegister::QuantParamCalcRegister() {
bool hasError = false; bool hasError = false;
std::shared_ptr<QuantParamCalcer> baseCalcer = std::make_shared<QuantParamCalcer>(); std::shared_ptr<QuantParamCalcer> baseCalcer = std::make_shared<QuantParamCalcer>();
if (baseCalcer == nullptr) { if (baseCalcer == nullptr) {
MS_LOG(ERROR) << "new QuantParamCalcer failed"; MS_LOG(DEBUG) << "new QuantParamCalcer failed";
hasError = true; hasError = true;
} }
std::shared_ptr<QuantParamCalcer> commonCalcer = std::make_shared<CommonCalcer>(); std::shared_ptr<QuantParamCalcer> commonCalcer = std::make_shared<CommonCalcer>();
if (commonCalcer == nullptr) { if (commonCalcer == nullptr) {
MS_LOG(ERROR) << "new commonCalcer failed"; MS_LOG(DEBUG) << "new commonCalcer failed";
hasError = true; hasError = true;
} }
std::shared_ptr<QuantParamCalcer> linearCalcer = std::make_shared<LinearCalcer>(); std::shared_ptr<QuantParamCalcer> linearCalcer = std::make_shared<LinearCalcer>();
if (linearCalcer == nullptr) { if (linearCalcer == nullptr) {
MS_LOG(ERROR) << "new linearCalcer failed"; MS_LOG(DEBUG) << "new linearCalcer failed";
hasError = true; hasError = true;
} }
if (!hasError) { if (!hasError) {

Write Preview
Loading…
Cancel
Save