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

!3910 move callback into include/lite_session.h

Browse Source 
Merge pull request !3910 from hangq/master
pull/3910/MERGE
mindspore-ci-bot 5 years ago committed by Gitee
parent af9398b39a e41e5e644a
commit 54fbdb97ff
14 changed files with 156 additions and 79 deletions
Show Stats Download Patch File Download Diff File

15
mindspore/lite/include/lite_session.h
Unescape View File

@ -26,6 +26,13 @@
namespace mindspore {
namespace session {
struct CallBackParam {
std::string name_callback_aram;
};
using KernelCallBack = std::function<bool(std::vector<tensor::MSTensor *> inputs,
std::vector<tensor::MSTensor *> outputs, const CallBackParam &opInfo)>;
/// \brief LiteSession defined by MindSpore Lite.
class MS_API LiteSession {
public:
@ -65,12 +72,15 @@ class MS_API LiteSession {
/// \return A vector of MindSpore Lite MSTensor.
virtual std::vector<tensor::MSTensor *> GetInputsByName(const std::string &node_name) const = 0;
/// \brief Run model compiled by this session.
/// \brief Run session with callback.
///
/// \param[in] before Define a call_back_function called before running each node
/// \param[in] after Define a call_back_function called after running each node
///
/// \note RunGraph should called after CompileGraph.
///
/// \return ErrorCode of run graph.
virtual int RunGraph() = 0;
virtual int RunGraph(const KernelCallBack &before = nullptr, const KernelCallBack &after = nullptr) = 0;
/// \brief Get output MindSpore Lite MSTensors of model.
///
@ -87,4 +97,3 @@ class MS_API LiteSession {
} // namespace session
} // namespace mindspore
#endif // MINDSPORE_LITE_INCLUDE_LITE_SESSION_H

1
mindspore/lite/src/CMakeLists.txt
Unescape View File

@ -1,5 +1,6 @@
set(LITE_SRC
${CMAKE_CURRENT_SOURCE_DIR}/common/graph_util.cc
${CMAKE_CURRENT_SOURCE_DIR}/common/ms_tensor_utils.cc
${CMAKE_CURRENT_SOURCE_DIR}/runtime/allocator.cc
${CMAKE_CURRENT_SOURCE_DIR}/runtime/runtime_api.cc
${CMAKE_CURRENT_SOURCE_DIR}/runtime/thread_pool.cc

41
mindspore/lite/src/common/ms_tensor_utils.cc
Unescape View File

@ -0,0 +1,41 @@
/**
* 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 "src/common/ms_tensor_utils.h"
#include <vector>
#include "utils/log_adapter.h"
namespace mindspore {
namespace tensor {
using mindspore::lite::tensor::LiteTensor;
using mindspore::lite::tensor::Tensor;
std::vector<MSTensor *> PackToMSTensors(const std::vector<Tensor *> &in_tensors) {
std::vector<MSTensor *> ret;
for (auto *lite_tensor : in_tensors) {
MS_ASSERT(lite_tensor != nullptr);
auto *ms_tensor = new (std::nothrow) LiteTensor(lite_tensor);
if (ms_tensor == nullptr) {
MS_LOG(ERROR) << "new LiteTensor failed";
return ret;
}
ret.emplace_back();
}
return ret;
}
} // namespace tensor
} // namespace mindspore

30
mindspore/lite/src/common/ms_tensor_utils.h
Unescape View File

@ -0,0 +1,30 @@
/**
* 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.
*/
#ifndef LITE_MS_TENSOR_UTILS_H
#define LITE_MS_TENSOR_UTILS_H
#include <vector>
#include "include/ms_tensor.h"
#include "src/ir/tensor.h"
namespace mindspore {
namespace tensor {
std::vector<MSTensor *> PackToMSTensors(const std::vector<mindspore::lite::tensor::Tensor *> &in_tensors);
}
} // namespace mindspore
#endif // LITE_MS_TENSOR_UTILS_H

11
mindspore/lite/src/executor.cc
Unescape View File

@ -17,11 +17,12 @@
#include "mindspore/lite/src/executor.h"
#include "src/runtime/kernel/arm/opclib/pack.h"
#include "include/errorcode.h"
#include "src/common/ms_tensor_utils.h"
namespace mindspore::lite {
int Executor::Run(std::vector<tensor::Tensor *> &inputs, std::vector<tensor::Tensor *> &outputs,
std::vector<kernel::LiteKernel *> &kernels, Allocator *allocator,
const kernel::KernelCallBack &before, const kernel::KernelCallBack &after) {
const session::KernelCallBack &before, const session::KernelCallBack &after) {
MS_ASSERT(nullptr != allocator);
for (auto &inTensor : inputs) {
if (inTensor == nullptr) {
@ -41,11 +42,11 @@ int Executor::Run(std::vector<tensor::Tensor *> &inputs, std::vector<tensor::Ten
MS_ASSERT(nullptr != output);
output->MallocData();
}
kernel::CallBackParam callbackParam;
session::CallBackParam callbackParam;
callbackParam.name_callback_aram = kernel->Name();
if (before != nullptr) {
if (!before(kernel->GetInputs(), kernel->GetOutputs(), callbackParam)) {
if (!before(PackToMSTensors(kernel->GetInputs()), PackToMSTensors(kernel->GetOutputs()), callbackParam)) {
MS_LOG(ERROR) << "run kernel before_callback failed, name: " << kernel->Name();
}
}
@ -56,7 +57,7 @@ int Executor::Run(std::vector<tensor::Tensor *> &inputs, std::vector<tensor::Ten
}
if (after != nullptr) {
if (!after(kernel->GetInputs(), kernel->GetOutputs(), callbackParam)) {
if (!after(PackToMSTensors(kernel->GetInputs()), PackToMSTensors(kernel->GetOutputs()), callbackParam)) {
MS_LOG(ERROR) << "run kernel after_callback failed, name: " << kernel->Name();
}
}
@ -120,5 +121,3 @@ int Executor::TransformTensorLayoutUint8(tensor::Tensor *tensor, schema::Format
return RET_ERROR;
}
} // namespace mindspore::lite

4
mindspore/lite/src/executor.h
Unescape View File

@ -20,6 +20,7 @@
#include <vector>
#include "src/runtime/allocator.h"
#include "src/lite_kernel.h"
#include "include/lite_session.h"
namespace mindspore::lite {
class Executor {
@ -30,7 +31,7 @@ class Executor {
int Run(std::vector<tensor::Tensor *> &inputs, std::vector<tensor::Tensor *> &outputs,
std::vector<kernel::LiteKernel *> &kernels, Allocator *allocator = nullptr,
const kernel::KernelCallBack &before = nullptr, const kernel::KernelCallBack &after = nullptr);
const session::KernelCallBack &before = nullptr, const session::KernelCallBack &after = nullptr);
protected:
int TransformTensorLayoutFp32(tensor::Tensor *tensor, schema::Format dst_format, Allocator *allocator = nullptr);
@ -45,4 +46,3 @@ class Executor {
} // namespace mindspore::lite
#endif

8
mindspore/lite/src/lite_kernel.h
Unescape View File

@ -51,14 +51,6 @@ struct KernelKey {
}
};
class LiteKernel;
struct CallBackParam {
std::string name_callback_aram;
};
using KernelCallBack = std::function<bool(std::vector<lite::tensor::Tensor *> inputs,
std::vector<lite::tensor::Tensor *> outputs, const CallBackParam &opInfo)>;
class LiteKernel {
public:
LiteKernel() = default;

21
mindspore/lite/src/lite_session.cc
Unescape View File

@ -165,17 +165,15 @@ std::vector<mindspore::tensor::MSTensor *> LiteSession::GetInputs() const {
return ret;
}
int LiteSession::RunGraph() {
int LiteSession::RunGraph(const session::KernelCallBack &before, const session::KernelCallBack &after) {
MS_EXCEPTION_IF_NULL(this->context_);
SetMaxWokerNum(context_->thread_num_);
Executor executor;
return executor.Run(this->inputs, this->outputs, this->kernels, this->context_->allocator.get());
}
int LiteSession::RunGraph(const kernel::KernelCallBack &before, const kernel::KernelCallBack &after) {
MS_EXCEPTION_IF_NULL(this->context_);
Executor executor;
return executor.Run(this->inputs, this->outputs, this->kernels, this->context_->allocator.get(), before, after);
if (before == nullptr && after == nullptr) {
return executor.Run(this->inputs, this->outputs, this->kernels, this->context_->allocator.get());
} else {
return executor.Run(this->inputs, this->outputs, this->kernels, this->context_->allocator.get(), before, after);
}
}
std::vector<mindspore::tensor::MSTensor *> LiteSession::GetOutputs() const {
@ -262,11 +260,10 @@ session::LiteSession *session::LiteSession::CreateSession(lite::Context *context
auto session = new lite::LiteSession();
auto ret = session->Init(context);
if (ret != mindspore::lite::RET_OK) {
MS_LOG(ERROR) << "init sesssion failed";
delete session;
return nullptr;
MS_LOG(ERROR) << "init sesssion failed";
delete session;
return nullptr;
}
return session;
}
} // namespace mindspore

5
mindspore/lite/src/lite_session.h
Unescape View File

@ -46,9 +46,8 @@ class LiteSession : public session::LiteSession {
std::vector<mindspore::tensor::MSTensor *> GetInputsByName(const std::string &name) const override;
int RunGraph() override;
int RunGraph(const kernel::KernelCallBack &before = nullptr, const kernel::KernelCallBack &after = nullptr);
int RunGraph(const session::KernelCallBack &before = nullptr,
const session::KernelCallBack &after = nullptr) override;
std::vector<mindspore::tensor::MSTensor *> GetOutputs() const override;

9
mindspore/lite/src/runtime/opencl/opencl_executor.cc
Unescape View File

@ -17,11 +17,12 @@
#include "src/runtime/opencl/opencl_executor.h"
#include "src/runtime/kernel/arm/opclib/pack.h"
#include "include/errorcode.h"
#include "src/common/ms_tensor_utils.h"
namespace mindspore::lite::opencl {
int OpenCLExecutor::Run(std::vector<tensor::Tensor *> &inputs, std::vector<tensor::Tensor *> &outputs,
std::vector<kernel::LiteKernel *> &kernels, Allocator *allocator,
const kernel::KernelCallBack &before, const kernel::KernelCallBack &after) {
const session::KernelCallBack &before, const session::KernelCallBack &after) {
MS_ASSERT(nullptr != allocator);
for (auto &inTensor : inputs) {
if (inTensor == nullptr) {
@ -46,11 +47,11 @@ int OpenCLExecutor::Run(std::vector<tensor::Tensor *> &inputs, std::vector<tenso
MS_ASSERT(nullptr != output);
output->MallocData();
}
kernel::CallBackParam callbackParam;
session::CallBackParam callbackParam;
callbackParam.name_callback_aram = kernel->Name();
if (before != nullptr) {
if (!before(kernel->GetInputs(), kernel->GetOutputs(), callbackParam)) {
if (!before(PackToMSTensors(kernel->GetInputs()), PackToMSTensors(kernel->GetOutputs()), callbackParam)) {
MS_LOG(ERROR) << "run kernel before_callback failed, name: " << kernel->Name();
}
}
@ -61,7 +62,7 @@ int OpenCLExecutor::Run(std::vector<tensor::Tensor *> &inputs, std::vector<tenso
}
if (after != nullptr) {
if (!after(kernel->GetInputs(), kernel->GetOutputs(), callbackParam)) {
if (!after(PackToMSTensors(kernel->GetInputs()), PackToMSTensors(kernel->GetOutputs()), callbackParam)) {
MS_LOG(ERROR) << "run kernel after_callback failed, name: " << kernel->Name();
}
}

3
mindspore/lite/src/runtime/opencl/opencl_executor.h
Unescape View File

@ -22,6 +22,7 @@
#include "src/runtime/allocator.h"
#include "src/lite_kernel.h"
#include "src/executor.h"
#include "include/lite_session.h"
namespace mindspore::lite::opencl {
class OpenCLExecutor : Executor {
@ -34,7 +35,7 @@ class OpenCLExecutor : Executor {
int Run(std::vector<tensor::Tensor *> &inputs, std::vector<tensor::Tensor *> &outputs,
std::vector<kernel::LiteKernel *> &kernels, Allocator *allocator = nullptr,
const kernel::KernelCallBack &before = nullptr, const kernel::KernelCallBack &after = nullptr);
const session::KernelCallBack &before = nullptr, const session::KernelCallBack &after = nullptr);
protected:
int TransformTensorLayoutFp32(tensor::Tensor *tensor, schema::Format dst_format);

1
mindspore/lite/test/CMakeLists.txt
Unescape View File

@ -154,6 +154,7 @@ set(TEST_LITE_SRC
${LITE_DIR}/src/common/file_utils.cc
${LITE_DIR}/src/common/file_utils_ext.cc
${LITE_DIR}/src/common/utils.cc
${LITE_DIR}/src/common/ms_tensor_utils.cc
${LITE_DIR}/tools/common/graph_util.cc
${LITE_DIR}/tools/common/tensor_util.cc
${LITE_DIR}/tools/common/node_util.cc

83
mindspore/lite/tools/converter/quantizer/post_training.cc
Unescape View File

@ -745,15 +745,16 @@ STATUS PostTrainingQuantizer::PreProcess() {
}
STATUS PostTrainingQuantizer::CheckTensorVec(const std::string &nodeName,
const std::vector<lite::tensor::Tensor *> &tensorVec) const {
const std::vector<mindspore::tensor::MSTensor *> &tensorVec) const {
if (tensorVec.size() < 1) {
MS_LOG(ERROR) << "node: " << nodeName << " input tensors is 0";
return RET_ERROR;
}
tensor::Tensor *tensor = tensorVec[0];
auto *tensor = tensorVec[0];
if (tensor->data_type() != kNumberTypeFloat32) {
//&& tensor->RefCount() != MSCONST_WEIGHT_REFCOUNT
MS_LOG(DEBUG) << "node: " << nodeName << " will not quantize" << " tensor data_type: " << tensor->data_type();
MS_LOG(DEBUG) << "node: " << nodeName << " will not quantize"
<< " tensor data_type: " << tensor->data_type();
return RET_ERROR;
}
return RET_OK;
@ -786,28 +787,30 @@ STATUS PostTrainingQuantizer::DoInference() {
int opExecResult;
};
*/
mindspore::kernel::KernelCallBack beforeCallBack = [&](const std::vector<lite::tensor::Tensor *> &beforeInputs,
const std::vector<lite::tensor::Tensor *> &beforeOutputs,
const mindspore::kernel::CallBackParam &callParam) -> bool {
mindspore::session::KernelCallBack beforeCallBack =
[&](const std::vector<mindspore::tensor::MSTensor *> &beforeInputs,
const std::vector<mindspore::tensor::MSTensor *> &beforeOutputs,
const mindspore::session::CallBackParam &callParam) -> bool {
if (PostTrainingQuantizer::CheckTensorVec(callParam.name_callback_aram, beforeInputs) != RET_OK) {
return false;
}
auto tensor = beforeInputs[0];
const float *tData = static_cast<const float *>(tensor->Data());
const float *tData = static_cast<const float *>(tensor->MutableData());
size_t shapeSize = tensor->ElementsNum();
vector<float> data(tData, tData + shapeSize);
this->calibrator_->RecordMaxValue(callParam.name_callback_aram, data, this->calibrator_->GetInputDivergInfo());
return true;
};
// func
mindspore::kernel::KernelCallBack afterCallBack = [&](const std::vector<lite::tensor::Tensor *> &afterInputs,
const std::vector<lite::tensor::Tensor *> &afterOutputs,
const mindspore::kernel::CallBackParam &callParam) -> bool {
mindspore::session::KernelCallBack afterCallBack = [&](
const std::vector<mindspore::tensor::MSTensor *> &afterInputs,
const std::vector<mindspore::tensor::MSTensor *> &afterOutputs,
const mindspore::session::CallBackParam &callParam) -> bool {
if (PostTrainingQuantizer::CheckTensorVec(callParam.name_callback_aram, afterOutputs) != RET_OK) {
return false;
}
auto tensor = afterOutputs[0];
const float *tensor_data = static_cast<const float *>(tensor->Data());
const float *tensor_data = static_cast<const float *>(tensor->MutableData());
size_t shape_size = tensor->ElementsNum();
vector<float> data(tensor_data, tensor_data + shape_size);
this->calibrator_->RecordMaxValue(callParam.name_callback_aram, data, this->calibrator_->GetOutputDivergInfo());
@ -837,35 +840,37 @@ STATUS PostTrainingQuantizer::CollectDataFrequency() {
return RET_ERROR;
}
mindspore::kernel::KernelCallBack beforeCallBack = [&](const std::vector<lite::tensor::Tensor *> &beforeInputs,
const std::vector<lite::tensor::Tensor *> &beforeOutputs,
const mindspore::kernel::CallBackParam &callParam) {
if (PostTrainingQuantizer::CheckTensorVec(callParam.name_callback_aram, beforeInputs) != RET_OK) {
return false;
}
auto tensor = beforeInputs[0];
const float *tensor_data = static_cast<const float *>(tensor->Data());
size_t shape_size = tensor->ElementsNum();
vector<float> data(tensor_data, tensor_data + shape_size);
this->calibrator_->UpdateDataFrequency(callParam.name_callback_aram, data, tensor->shape(),
this->calibrator_->GetInputDivergInfo());
return true;
};
mindspore::session::KernelCallBack beforeCallBack =
[&](const std::vector<mindspore::tensor::MSTensor *> &beforeInputs,
const std::vector<mindspore::tensor::MSTensor *> &beforeOutputs,
const mindspore::session::CallBackParam &callParam) {
if (PostTrainingQuantizer::CheckTensorVec(callParam.name_callback_aram, beforeInputs) != RET_OK) {
return false;
}
auto tensor = beforeInputs[0];
const float *tensor_data = static_cast<const float *>(tensor->MutableData());
size_t shape_size = tensor->ElementsNum();
vector<float> data(tensor_data, tensor_data + shape_size);
this->calibrator_->UpdateDataFrequency(callParam.name_callback_aram, data, tensor->shape(),
this->calibrator_->GetInputDivergInfo());
return true;
};
mindspore::kernel::KernelCallBack afterCallBack = [&](const std::vector<lite::tensor::Tensor *> &after_inputs,
const std::vector<lite::tensor::Tensor *> &after_outputs,
const mindspore::kernel::CallBackParam &call_param) {
if (PostTrainingQuantizer::CheckTensorVec(call_param.name_callback_aram, after_outputs) != RET_OK) {
return false;
}
auto tensor = after_outputs[0];
const float *tenosr_data = static_cast<const float *>(tensor->Data());
size_t shape_size = tensor->ElementsNum();
vector<float> data(tenosr_data, tenosr_data + shape_size);
this->calibrator_->UpdateDataFrequency(call_param.name_callback_aram, data, tensor->shape(),
this->calibrator_->GetOutputDivergInfo());
return true;
};
mindspore::session::KernelCallBack afterCallBack =
[&](const std::vector<mindspore::tensor::MSTensor *> &after_inputs,
const std::vector<mindspore::tensor::MSTensor *> &after_outputs,
const mindspore::session::CallBackParam &call_param) {
if (PostTrainingQuantizer::CheckTensorVec(call_param.name_callback_aram, after_outputs) != RET_OK) {
return false;
}
auto tensor = after_outputs[0];
const float *tenosr_data = static_cast<const float *>(tensor->MutableData());
size_t shape_size = tensor->ElementsNum();
vector<float> data(tenosr_data, tenosr_data + shape_size);
this->calibrator_->UpdateDataFrequency(call_param.name_callback_aram, data, tensor->shape(),
this->calibrator_->GetOutputDivergInfo());
return true;
};
status = session_->RunGraph(beforeCallBack, afterCallBack);
if (status != RET_OK) {
MS_LOG(ERROR) << "run model failed!";

3
mindspore/lite/tools/converter/quantizer/post_training.h
Unescape View File

@ -27,6 +27,7 @@
#include "tools/converter/quantizer/quantizer.h"
#include "src/ir/primitive_t_value.h"
#include "tools/converter/converter.h"
#include "include/ms_tensor.h"
namespace mindspore {
namespace lite {
@ -71,7 +72,7 @@ class PostTrainingQuantizer : public Quantizer {
STATUS PreProcess();
STATUS CheckTensorVec(const std::string &nodeName, const std::vector<tensor::Tensor *> &tensorVec) const;
STATUS CheckTensorVec(const std::string &nodeName, const std::vector<mindspore::tensor::MSTensor *> &tensorVec) const;
STATUS DoInference();

Write Preview
Loading…
Cancel
Save