p12346870
/
mindspore
forked from mindspore-Ecosystem/mindspore
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

fix 310 mindir infer error: undefined symbol

This commit is contained in:
luoyang 2021-09-15 18:04:15 +08:00
parent af61d6a0ca
commit 7ef569ad26
14 changed files with 418 additions and 110 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

28
include/api/model.h
View File

@ -75,16 +75,29 @@ class MS_API Model {
Status Predict(const std::vector<MSTensor> &inputs, std::vector<MSTensor> *outputs,
const MSKernelCallBack &before = nullptr, const MSKernelCallBack &after = nullptr);
/// \brief Inference model, only for cv model inference.
/// \brief Inference model with preprocess in model.
///
/// \param[in] inputs A string represents the file path of input image.
/// \param[in] inputs A vector where model inputs are arranged in sequence.
/// \param[out] outputs Which is a pointer to a vector. The model outputs are filled in the container in sequence.
/// \param[in] whether to use data preprocess in model.
/// \param[in] before CallBack before predict.
/// \param[in] after CallBack after predict.
///
/// \return Status.
inline Status Predict(const std::string &input, std::vector<MSTensor> *outputs,
const MSKernelCallBack &before = nullptr, const MSKernelCallBack &after = nullptr);
Status PredictWithPreprocess(const std::vector<MSTensor> &inputs, std::vector<MSTensor> *outputs,
const MSKernelCallBack &before = nullptr, const MSKernelCallBack &after = nullptr);
/// \brief Apply data preprocess if it exits in model.
///
/// \param[in] inputs A vector where model inputs are arranged in sequence.
/// \param[out] outputs Which is a pointer to a vector. The model outputs are filled in the container in sequence.
///
/// \return Status.
Status Preprocess(const std::vector<MSTensor> &inputs, std::vector<MSTensor> *outputs);
/// \brief Check if data preprocess exists in model.
/// \return true if data preprocess exists.
bool HasPreprocess();
/// \brief Load config file.
///
@ -201,8 +214,6 @@ class MS_API Model {
std::vector<std::vector<char>> GetOutputTensorNamesChar();
MSTensor GetOutputByTensorName(const std::vector<char> &tensor_name);
std::vector<MSTensor> GetOutputsByNodeName(const std::vector<char> &node_name);
Status Predict(const std::vector<char> &input, std::vector<MSTensor> *outputs, const MSKernelCallBack &before,
const MSKernelCallBack &after);
std::shared_ptr<ModelImpl> impl_;
};
@ -220,10 +231,5 @@ MSTensor Model::GetOutputByTensorName(const std::string &tensor_name) {
std::vector<MSTensor> Model::GetOutputsByNodeName(const std::string &node_name) {
return GetOutputsByNodeName(StringToChar(node_name));
}
Status Model::Predict(const std::string &input, std::vector<MSTensor> *outputs, const MSKernelCallBack &before,
const MSKernelCallBack &after) {
return Predict(StringToChar(input), outputs, before, after);
}
} // namespace mindspore
#endif // MINDSPORE_INCLUDE_API_MODEL_H

12
include/api/types.h
View File

@ -104,6 +104,13 @@ class MS_API MSTensor {
static inline MSTensor *CreateDevTensor(const std::string &name, DataType type, const std::vector<int64_t> &shape,
const void *data, size_t data_len) noexcept;
/// \brief Creates a MSTensor object from local image file, must be used in pairs with DestroyTensorPtr.
///
/// \param[in] image_file Path of image file.
///
/// \return A pointer of MSTensor.
static inline MSTensor *CreateImageTensor(const std::string &image_file) noexcept;
/// \brief Create a string type MSTensor object whose data can be accessed by Model only after being copied, must be
/// used in pair with DestroyTensorPtr.
///
@ -261,6 +268,7 @@ class MS_API MSTensor {
const void *data, size_t data_len) noexcept;
static MSTensor *CreateDevTensor(const std::vector<char> &name, enum DataType type, const std::vector<int64_t> &shape,
const void *data, size_t data_len) noexcept;
static MSTensor *CreateImageTensor(const std::vector<char> &image_file) noexcept;
static MSTensor *CharStringsToTensor(const std::vector<char> &name, const std::vector<std::vector<char>> &str);
static std::vector<std::vector<char>> TensorToStringChars(const MSTensor &tensor);
@ -307,6 +315,10 @@ MSTensor *MSTensor::CreateDevTensor(const std::string &name, enum DataType type,
return CreateDevTensor(StringToChar(name), type, shape, data, data_len);
}
MSTensor *MSTensor::CreateImageTensor(const std::string &image_file) noexcept {
return CreateImageTensor(StringToChar(image_file));
}
MSTensor *MSTensor::StringsToTensor(const std::string &name, const std::vector<std::string> &str) {
return CharStringsToTensor(StringToChar(name), VectorStringToChar(str));
}

102
mindspore/ccsrc/cxx_api/dlutils.h Normal file
View File

@ -0,0 +1,102 @@
/**
* Copyright 2021 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 MINDSPORE_CCSRC_CXX_API_DLUTILS_H_
#define MINDSPORE_CCSRC_CXX_API_DLUTILS_H_
#if !defined(_WIN32) && !defined(_WIN64)
#include <dlfcn.h>
#include <dirent.h>
#include <memory>
#include <string>
#include <fstream>
#include "utils/file_utils.h"
namespace mindspore {
inline Status DLSoPath(std::string *so_path) {
if (so_path == nullptr) {
return Status(kMEFailed, "Input so_path can not be nullptr.");
}
Dl_info dl_info;
dladdr(reinterpret_cast<void *>(DLSoPath), &dl_info);
std::string libmindspore_so = dl_info.dli_fname;
auto pos = libmindspore_so.find("libmindspore.so");
if (pos == std::string::npos) {
return Status(kMEFailed, "Could not find libmindspore.so, check path.");
}
std::string parent_dir = libmindspore_so.substr(0, pos) + "../";
std::string c_dataengine_so;
DIR *dir = opendir(parent_dir.c_str());
if (dir != nullptr) {
// access all the files and directories within directory
dirent *ent = readdir(dir);
while (ent != nullptr) {
if (std::string(ent->d_name).find("_c_dataengine") != std::string::npos) {
c_dataengine_so = std::string(ent->d_name);
break;
}
ent = readdir(dir);
}
closedir(dir);
} else {
return Status(kMEFailed, "Could not open directory: " + parent_dir);
}
std::string unreal_path = parent_dir + c_dataengine_so;
auto realpath = FileUtils::GetRealPath(unreal_path.c_str());
if (!realpath.has_value()) {
return Status(kMEFailed, "Get c_dataengine_so real path failed, path: " + unreal_path);
}
*so_path = realpath.value();
return kSuccess;
}
inline Status DLSoOpen(const std::string &dl_path, const std::string &func_name, void **handle, void **function) {
// do dlopen and export functions from c_dataengine
*handle = dlopen(dl_path.c_str(), RTLD_LAZY | RTLD_LOCAL);
if (*handle == nullptr) {
return Status(kMEFailed, "dlopen failed, the pointer[handle] is null.");
}
*function = dlsym(*handle, func_name.c_str());
if (*function == nullptr) {
return Status(kMEFailed, "Could not find " + func_name + " in " + dl_path);
}
return kSuccess;
}
inline void DLSoClose(void *handle) {
if (handle != nullptr) {
(void)dlclose(handle);
}
}
#define CHECK_FAIL_AND_RELEASE(_s, _handle, _e) \
do { \
Status __rc = (_s); \
if (__rc.IsError()) { \
MS_LOG(ERROR) << (_e); \
DLSoClose((_handle)); \
return __rc; \
} \
} while (false)
} // namespace mindspore
#endif
#endif // MINDSPORE_CCSRC_CXX_API_DLUTILS_H_

22
mindspore/ccsrc/cxx_api/model/model.cc
View File

@ -94,13 +94,29 @@ Status Model::Predict(const std::vector<MSTensor> &inputs, std::vector<MSTensor>
return impl_->Predict(inputs, outputs);
}
Status Model::Predict(const std::vector<char> &input, std::vector<MSTensor> *outputs, const MSKernelCallBack &before,
const MSKernelCallBack &after) {
Status Model::PredictWithPreprocess(const std::vector<MSTensor> &inputs, std::vector<MSTensor> *outputs,
const MSKernelCallBack &before, const MSKernelCallBack &after) {
if (impl_ == nullptr) {
MS_LOG(ERROR) << "Failed because this model has not been built.";
return kMCFailed;
}
return impl_->Predict(CharToString(input), outputs);
return impl_->PredictWithPreprocess(inputs, outputs);
}
Status Model::Preprocess(const std::vector<MSTensor> &inputs, std::vector<MSTensor> *outputs) {
if (impl_ == nullptr) {
MS_LOG(ERROR) << "Failed because this model has not been built.";
return kMCFailed;
}
return impl_->Preprocess(inputs, outputs);
}
bool Model::HasPreprocess() {
if (impl_ == nullptr) {
MS_LOG(ERROR) << "Failed because this model has not been built.";
return false;
}
return impl_->HasPreprocess();
}
std::vector<MSTensor> Model::GetInputs() {

108
mindspore/ccsrc/cxx_api/model/model_impl.cc
View File

@ -14,9 +14,7 @@
* limitations under the License.
*/
#include "cxx_api/model/model_impl.h"
#include <fstream>
#include "debug/common.h"
#include "cxx_api/dlutils.h"
namespace mindspore {
Status ModelImpl::Predict(const std::vector<MSTensor> &inputs, std::vector<MSTensor> *outputs) {
@ -45,78 +43,52 @@ Status ModelImpl::Predict(const std::vector<MSTensor> &inputs, std::vector<MSTen
return kSuccess;
}
Status ModelImpl::Predict(const std::string &input, std::vector<MSTensor> *outputs) {
bool ModelImpl::HasPreprocess() { return graph_->graph_data_->GetPreprocess().empty() ? false : true; }
Status ModelImpl::Preprocess(const std::vector<MSTensor> &inputs, std::vector<MSTensor> *outputs) {
#if !defined(_WIN32) && !defined(_WIN64)
auto realpath = Common::GetRealPath(input);
if (!realpath.has_value()) {
MS_LOG(ERROR) << "Get real path failed, path=" << input;
return Status(kMEInvalidInput, "Get real path failed, path=" + input);
}
MS_EXCEPTION_IF_NULL(outputs);
// Read image file
auto file = realpath.value();
if (file.empty()) {
return Status(kMEInvalidInput, "can not find any input file.");
}
std::ifstream ifs(file, std::ios::in | std::ios::binary);
if (!ifs.good()) {
return Status(kMEInvalidInput, "File: " + file + " does not exist.");
}
if (!ifs.is_open()) {
return Status(kMEInvalidInput, "File: " + file + " open failed.");
}
auto &io_seekg1 = ifs.seekg(0, std::ios::end);
if (!io_seekg1.good() || io_seekg1.fail() || io_seekg1.bad()) {
ifs.close();
return Status(kMEInvalidInput, "Failed to seekg file: " + file);
}
size_t size = ifs.tellg();
MSTensor buffer(file, mindspore::DataType::kNumberTypeUInt8, {static_cast<int64_t>(size)}, nullptr, size);
auto &io_seekg2 = ifs.seekg(0, std::ios::beg);
if (!io_seekg2.good() || io_seekg2.fail() || io_seekg2.bad()) {
ifs.close();
return Status(kMEInvalidInput, "Failed to seekg file: " + file);
}
auto &io_read = ifs.read(reinterpret_cast<char *>(buffer.MutableData()), size);
if (!io_read.good() || io_read.fail() || io_read.bad()) {
ifs.close();
return Status(kMEInvalidInput, "Failed to read file: " + file);
}
ifs.close();
// Config preprocessor, temporary way to let mindspore.so depends on _c_dataengine
std::string dataengine_so_path;
Status dlret = DLSoPath(&dataengine_so_path);
CHECK_FAIL_AND_RELEASE(dlret, nullptr, "Parse dataengine_so failed: " + dlret.GetErrDescription());
// Run preprocess
std::vector<MSTensor> transform_inputs;
std::vector<MSTensor> transform_outputs;
transform_inputs.emplace_back(std::move(buffer));
MS_LOG(DEBUG) << "transform_inputs[0].Shape: " << transform_inputs[0].Shape();
auto preprocessor = graph_->graph_data_->GetPreprocess();
if (!preprocessor.empty()) {
for (auto exes : preprocessor) {
MS_EXCEPTION_IF_NULL(exes);
Status ret = exes->operator()(transform_inputs, &transform_outputs);
if (ret != kSuccess) {
MS_LOG(ERROR) << "Run preprocess failed.";
return ret;
}
MS_LOG(DEBUG) << "transform_outputs[0].Shape: " << transform_outputs[0].Shape();
transform_inputs = transform_outputs;
}
} else {
std::string msg = "Attempt to predict with data preprocess, but no preprocess operation is defined in MindIR.";
MS_LOG(ERROR) << msg;
return Status(kMEFailed, msg);
if (!HasPreprocess()) {
return Status(kMEFailed, "Attempt to predict with data preprocessor, but no preprocessor is defined in MindIR.");
}
std::vector<std::shared_ptr<dataset::Execute>> preprocessor = graph_->graph_data_->GetPreprocess();
void *handle = nullptr;
void *function = nullptr;
dlret = DLSoOpen(dataengine_so_path, "ExecuteRun_C", &handle, &function);
CHECK_FAIL_AND_RELEASE(dlret, handle, "Parse ExecuteRun_C failed: " + dlret.GetErrDescription());
auto ExecuteRun =
(void (*)(const std::vector<std::shared_ptr<dataset::Execute>> &, const std::vector<mindspore::MSTensor> &,
std::vector<mindspore::MSTensor> *, Status *))(function);
ExecuteRun(preprocessor, inputs, outputs, &dlret);
CHECK_FAIL_AND_RELEASE(dlret, handle, "Run preprocess failed: " + dlret.GetErrDescription());
DLSoClose(handle);
return kSuccess;
#else
MS_LOG(ERROR) << "Data preprocess is not supported on Windows yet.";
return Status(kMEFailed, "Data preprocess is not supported on Windows yet.");
#endif
}
Status ModelImpl::PredictWithPreprocess(const std::vector<MSTensor> &inputs, std::vector<MSTensor> *outputs) {
#if !defined(_WIN32) && !defined(_WIN64)
// Run preprocess
std::vector<MSTensor> preprocess_outputs;
Status ret = Preprocess(inputs, &preprocess_outputs);
if (ret != kSuccess) {
return ret;
}
// Run prediction
Status ret = Predict(transform_outputs, outputs);
ret = Predict(preprocess_outputs, outputs);
if (ret != kSuccess) {
MS_LOG(ERROR) << ret.GetErrDescription();
MS_LOG(ERROR) << "Run predict failed: " << ret.GetErrDescription();
return ret;
}
return kSuccess;

6
mindspore/ccsrc/cxx_api/model/model_impl.h
View File

@ -39,13 +39,17 @@ class ModelImpl {
virtual Status Predict(const std::vector<MSTensor> &inputs, std::vector<MSTensor> *outputs);
virtual Status Predict(const std::string &input, std::vector<MSTensor> *outputs);
virtual Status PredictWithPreprocess(const std::vector<MSTensor> &inputs, std::vector<MSTensor> *outputs);
virtual std::vector<MSTensor> GetInputs() = 0;
virtual std::vector<MSTensor> GetOutputs() = 0;
virtual bool CheckModelSupport(enum ModelType model_type) { return false; }
virtual Status Preprocess(const std::vector<MSTensor> &inputs, std::vector<MSTensor> *outputs);
virtual bool HasPreprocess();
protected:
Status Load(const std::shared_ptr<GraphCell> &graph_cell, uint32_t device_id) {
MS_EXCEPTION_IF_NULL(graph_cell);

66
mindspore/ccsrc/cxx_api/serialization.cc
View File

@ -20,6 +20,7 @@
#include "utils/log_adapter.h"
#include "mindspore/core/load_mindir/load_model.h"
#if !defined(_WIN32) && !defined(_WIN64)
#include "cxx_api/dlutils.h"
#include "minddata/dataset/engine/serdes.h"
#include "minddata/dataset/include/dataset/execute.h"
#endif
@ -160,9 +161,8 @@ Status Serialization::Load(const std::vector<char> &file, ModelType model_type,
const std::vector<char> &dec_mode) {
std::stringstream err_msg;
if (graph == nullptr) {
err_msg << "Output args graph is nullptr.";
MS_LOG(ERROR) << err_msg.str();
return Status(kMEInvalidInput, err_msg.str());
MS_LOG(ERROR) << "Output args graph is nullptr.";
return Status(kMEInvalidInput, "Output args graph is nullptr.");
}
std::string file_path;
@ -193,18 +193,28 @@ Status Serialization::Load(const std::vector<char> &file, ModelType model_type,
}
auto graph_data = std::make_shared<Graph::GraphData>(anf_graph, kMindIR);
#if !defined(_WIN32) && !defined(_WIN64)
// Config preprocessor, temporary way to let mindspore.so depends on _c_dataengine
std::string preprocessor = LoadPreprocess(file_path);
if (!preprocessor.empty()) {
std::string dataengine_so_path;
Status dlret = DLSoPath(&dataengine_so_path);
CHECK_FAIL_AND_RELEASE(dlret, nullptr, "Parse dataengine_so failed: " + dlret.GetErrDescription());
void *handle = nullptr;
void *function = nullptr;
dlret = DLSoOpen(dataengine_so_path, "ParseMindIRPreprocess_C", &handle, &function);
CHECK_FAIL_AND_RELEASE(dlret, handle, "Parse ParseMindIRPreprocess_C failed: " + dlret.GetErrDescription());
auto ParseMindIRPreprocessFun =
(void (*)(const std::string &, const std::string &, std::vector<std::shared_ptr<mindspore::dataset::Execute>> *,
Status *))(function);
std::vector<std::shared_ptr<dataset::Execute>> data_graph;
status = dataset::Serdes::ParseMindIRPreprocess(preprocessor, "image", &data_graph);
if (status != kSuccess) {
MS_LOG(ERROR) << status.GetErrDescription();
return status;
}
ParseMindIRPreprocessFun(preprocessor, "image", &data_graph, &dlret);
CHECK_FAIL_AND_RELEASE(dlret, handle, "Load preprocess failed: " + dlret.GetErrDescription());
DLSoClose(handle);
if (!data_graph.empty()) {
graph_data->SetPreprocess(data_graph);
} else {
MS_LOG(WARNING) << "Load preprocess failed, no data preprocess operations found in MindIR.";
}
}
#endif
@ -230,9 +240,8 @@ Status Serialization::Load(const std::vector<std::vector<char>> &files, ModelTyp
std::vector<Graph> *graphs, const Key &dec_key, const std::vector<char> &dec_mode) {
std::stringstream err_msg;
if (graphs == nullptr) {
err_msg << "Output args graph is nullptr.";
MS_LOG(ERROR) << err_msg.str();
return Status(kMEInvalidInput, err_msg.str());
MS_LOG(ERROR) << "Output args graph is nullptr.";
return Status(kMEInvalidInput, "Output args graph is nullptr.");
}
if (files.size() == 1) {
@ -266,6 +275,21 @@ Status Serialization::Load(const std::vector<std::vector<char>> &files, ModelTyp
MS_LOG(ERROR) << err_msg.str();
return Status(kMEInvalidInput, err_msg.str());
}
#if !defined(_WIN32) && !defined(_WIN64)
// Dataset so loading
std::string dataengine_so_path;
Status dlret = DLSoPath(&dataengine_so_path);
CHECK_FAIL_AND_RELEASE(dlret, nullptr, "Parse dataengine_so failed: " + dlret.GetErrDescription());
void *handle = nullptr;
void *function = nullptr;
dlret = DLSoOpen(dataengine_so_path, "ParseMindIRPreprocess_C", &handle, &function);
CHECK_FAIL_AND_RELEASE(dlret, handle, "Parse ParseMindIRPreprocess_C failed: " + dlret.GetErrDescription());
auto ParseMindIRPreprocessFun =
(void (*)(const std::string &, const std::string &, std::vector<std::shared_ptr<mindspore::dataset::Execute>> *,
Status *))(function);
#endif
std::vector<Graph> results;
for (size_t i = 0; i < anf_graphs.size(); ++i) {
if (anf_graphs[i] == nullptr) {
@ -278,25 +302,25 @@ Status Serialization::Load(const std::vector<std::vector<char>> &files, ModelTyp
return Status(kMEInvalidInput, err_msg.str());
}
auto graph_data = std::make_shared<Graph::GraphData>(anf_graphs[i], kMindIR);
#if !defined(_WIN32) && !defined(_WIN64)
// Config preprocessor, temporary way to let mindspore.so depends on _c_dataengine
std::string preprocessor = LoadPreprocess(files_path[i]);
if (!preprocessor.empty()) {
std::vector<std::shared_ptr<dataset::Execute>> data_graph;
auto status = dataset::Serdes::ParseMindIRPreprocess(preprocessor, "image", &data_graph);
if (status != kSuccess) {
MS_LOG(ERROR) << status.GetErrDescription();
return status;
}
ParseMindIRPreprocessFun(preprocessor, "image", &data_graph, &dlret);
CHECK_FAIL_AND_RELEASE(dlret, handle, "Load preprocess failed: " + dlret.GetErrDescription());
if (!data_graph.empty()) {
graph_data->SetPreprocess(data_graph);
} else {
MS_LOG(WARNING) << "Load preprocess failed, no data preprocess operations found in MindIR.";
}
}
#endif
results.emplace_back(graph_data);
}
#if !defined(_WIN32) && !defined(_WIN64)
// Dataset so release
DLSoClose(handle);
#endif
*graphs = std::move(results);
return kSuccess;
}

65
mindspore/ccsrc/cxx_api/types.cc
View File

@ -14,10 +14,12 @@
* limitations under the License.
*/
#include "include/api/types.h"
#include <fstream>
#include <numeric>
#include "securec/include/securec.h"
#include "mindspore/core/ir/api_tensor_impl.h"
#include "mindspore/core/utils/convert_utils_base.h"
#include "utils/file_utils.h"
namespace mindspore {
class Buffer::Impl {
@ -184,6 +186,69 @@ MSTensor *MSTensor::CreateDevTensor(const std::vector<char> &name, enum DataType
}
}
MSTensor *MSTensor::CreateImageTensor(const std::vector<char> &image_file) noexcept {
std::string image_file_str = CharToString(image_file);
try {
auto realpath = FileUtils::GetRealPath(image_file_str.c_str());
if (!realpath.has_value()) {
MS_LOG(ERROR) << "Get real path failed, path=" << image_file_str;
return nullptr;
}
// Read image file
auto file = realpath.value();
if (file.empty()) {
MS_LOG(ERROR) << "can not find any input file.";
return nullptr;
}
std::ifstream ifs(file, std::ios::in | std::ios::binary);
if (!ifs.good()) {
MS_LOG(ERROR) << "File: " + file + " does not exist.";
return nullptr;
}
if (!ifs.is_open()) {
MS_LOG(ERROR) << "File: " + file + " open failed.";
return nullptr;
}
auto &io_seekg1 = ifs.seekg(0, std::ios::end);
if (!io_seekg1.good() || io_seekg1.fail() || io_seekg1.bad()) {
ifs.close();
MS_LOG(ERROR) << "Failed to seekg file: " + file;
return nullptr;
}
size_t size = ifs.tellg();
MSTensor *ret =
new MSTensor(file, mindspore::DataType::kNumberTypeUInt8, {static_cast<int64_t>(size)}, nullptr, size);
auto &io_seekg2 = ifs.seekg(0, std::ios::beg);
if (!io_seekg2.good() || io_seekg2.fail() || io_seekg2.bad()) {
ifs.close();
MS_LOG(ERROR) << "Failed to seekg file: " + file;
return nullptr;
}
auto &io_read = ifs.read(reinterpret_cast<char *>(ret->MutableData()), size);
if (!io_read.good() || io_read.fail() || io_read.bad()) {
ifs.close();
MS_LOG(ERROR) << "Failed to read file: " + file;
return nullptr;
}
ifs.close();
return ret;
} catch (const std::bad_alloc &) {
MS_LOG(ERROR) << "Malloc memory failed.";
return nullptr;
} catch (...) {
MS_LOG(ERROR) << "Unknown error occurred.";
return nullptr;
}
}
MSTensor *MSTensor::CharStringsToTensor(const std::vector<char> &name, const std::vector<std::vector<char>> &str) {
// num(4 bytes) + offset1(4 bytes) + offset2(4 bytes) + ... + data1(str1.len) + data2(str2.len) + ...
// str1.len() = offset2 - offset1

36
mindspore/ccsrc/minddata/dataset/api/execute.cc
View File

@ -665,5 +665,41 @@ Status Execute::DeviceMemoryRelease() {
return Status::OK();
}
Status Execute::Run(const std::vector<std::shared_ptr<dataset::Execute>> &data_graph,
const std::vector<mindspore::MSTensor> &inputs, std::vector<mindspore::MSTensor> *outputs) {
std::vector<MSTensor> transform_inputs = inputs;
std::vector<MSTensor> transform_outputs;
if (!data_graph.empty()) {
for (auto exes : data_graph) {
CHECK_FAIL_RETURN_UNEXPECTED(exes != nullptr, "Given execute object is null.");
Status ret = exes->operator()(transform_inputs, &transform_outputs);
if (ret != kSuccess) {
MS_LOG(ERROR) << "Run preprocess failed:" << ret.GetErrDescription();
return ret;
}
MS_LOG(DEBUG) << "transform_outputs[0].Shape: " << transform_outputs[0].Shape();
transform_inputs = transform_outputs;
}
*outputs = std::move(transform_outputs);
} else {
std::string msg = "The set of Executors can not be empty.";
MS_LOG(ERROR) << msg;
RETURN_STATUS_UNEXPECTED(msg);
}
return Status::OK();
}
// In the current stage, there is a cyclic dependency between libmindspore.so and c_dataengine.so,
// we make a C function here and dlopen by libminspore.so to avoid linking explicitly,
// will be fix after decouling libminspore.so into multi submodules
extern "C" {
// ExecuteRun_C has C-linkage specified, but returns user-defined type 'mindspore::Status' which is incompatible with C
void ExecuteRun_C(const std::vector<std::shared_ptr<dataset::Execute>> &data_graph,
std::vector<mindspore::MSTensor> &inputs, std::vector<mindspore::MSTensor> *outputs, Status *s) {
Status ret = Execute::Run(data_graph, inputs, outputs);
*s = Status(ret);
}
}
} // namespace dataset
} // namespace mindspore

13
mindspore/ccsrc/minddata/dataset/engine/serdes.cc
View File

@ -369,5 +369,18 @@ Status Serdes::ParseMindIRPreprocess(const std::string &dataset_json, const std:
return Status::OK();
}
// In the current stage, there is a cyclic dependency between libmindspore.so and c_dataengine.so,
// we make a C function here and dlopen by libminspore.so to avoid linking explicitly,
// will be fix after decouling libminspore.so into multi submodules
extern "C" {
// ParseMindIRPreprocess_C has C-linkage specified, but returns user-defined type 'mindspore::Status'
// which is incompatible with C
void ParseMindIRPreprocess_C(const std::string &dataset_json, const std::string &process_column,
std::vector<std::shared_ptr<mindspore::dataset::Execute>> *data_graph, Status *s) {
Status ret = Serdes::ParseMindIRPreprocess(dataset_json, process_column, data_graph);
*s = Status(ret);
}
}
} // namespace dataset
} // namespace mindspore

4
mindspore/ccsrc/minddata/dataset/include/dataset/execute.h
View File

@ -106,6 +106,10 @@ class Execute {
/// \return Status error code, returns OK if no error encountered.
Status operator()(const std::vector<mindspore::MSTensor> &input_tensor_list, std::vector<mindspore::MSTensor> *out);
/// \brief Given a set of Executes, run them
static Status Run(const std::vector<std::shared_ptr<dataset::Execute>> &data_graph,
const std::vector<mindspore::MSTensor> &inputs, std::vector<mindspore::MSTensor> *outputs);
/// \brief The function to release device memory on Ascend310.
Status DeviceMemoryRelease();

14
mindspore/lite/src/cxx_api/model/model.cc
View File

@ -109,12 +109,22 @@ Status Model::Predict(const std::vector<MSTensor> &inputs, std::vector<MSTensor>
return impl_->Predict(inputs, outputs, before, after);
}
Status Model::Predict(const std::vector<char> &input, std::vector<MSTensor> *outputs, const MSKernelCallBack &before,
const MSKernelCallBack &after) {
Status Model::PredictWithPreprocess(const std::vector<MSTensor> &inputs, std::vector<MSTensor> *outputs,
const MSKernelCallBack &before, const MSKernelCallBack &after) {
MS_LOG(ERROR) << "Unsupported Feature.";
return kLiteNotSupport;
}
Status Model::Preprocess(const std::vector<MSTensor> &inputs, std::vector<MSTensor> *outputs) {
MS_LOG(ERROR) << "Unsupported Feature.";
return kLiteNotSupport;
}
bool Model::HasPreprocess() {
MS_LOG(ERROR) << "Unsupported Feature.";
return false;
}
Model::Model() : impl_(nullptr) {}
Model::~Model() {}

2
model_zoo/official/cv/resnext/ascend310_infer/src/CMakeLists.txt
View File

@ -13,4 +13,4 @@ file(GLOB_RECURSE MD_LIB ${MINDSPORE_PATH}/_c_dataengine*)
add_executable(main main.cc utils.cc)
target_link_libraries(main ${MS_LIB} ${MD_LIB} gflags)
add_executable(main_preprocess main_preprocess.cc utils.cc)
target_link_libraries(main_preprocess ${MS_LIB} ${MD_LIB} gflags)
target_link_libraries(main_preprocess ${MS_LIB} gflags)

50
model_zoo/official/cv/resnext/ascend310_infer/src/main_preprocess.cc
View File

@ -63,14 +63,58 @@ int main(int argc, char **argv) {
return 1;
}
std::vector<MSTensor> outputs;
ret = model.Predict(FLAGS_image_path, &outputs);
std::cout << "Check if data preprocess exists: " << model.HasPreprocess() << std::endl;
// way 1, construct a common MSTensor
std::vector<MSTensor> inputs1 = {ReadFileToTensor(FLAGS_image_path)};
std::vector<MSTensor> outputs1;
ret = model.PredictWithPreprocess(inputs1, &outputs1);
if (ret.IsError()) {
std::cout << "ERROR: Predict failed." << std::endl;
return 1;
}
auto shape = outputs[0].Shape();
std::ofstream o1("result1.txt", std::ios::out);
o1.write(reinterpret_cast<const char *>(outputs1[0].MutableData()), std::streamsize(outputs1[0].DataSize()));
// way 2, construct a pointer of MSTensor, be careful of destroy
MSTensor *tensor = MSTensor::CreateImageTensor(FLAGS_image_path);
std::vector<MSTensor> inputs2 = {*tensor};
MSTensor::DestroyTensorPtr(tensor);
std::vector<MSTensor> outputs2;
ret = model.PredictWithPreprocess(inputs2, &outputs2);
if (ret.IsError()) {
std::cout << "ERROR: Predict failed." << std::endl;
return 1;
}
std::ofstream o2("result2.txt", std::ios::out);
o2.write(reinterpret_cast<const char *>(outputs2[0].MutableData()), std::streamsize(outputs2[0].DataSize()));
// way 3, split preprocess and predict
std::vector<MSTensor> inputs3 = {ReadFileToTensor(FLAGS_image_path)};
std::vector<MSTensor> outputs3;
ret = model.Preprocess(inputs3, &outputs3);
if (ret.IsError()) {
std::cout << "ERROR: Preprocess failed." << std::endl;
return 1;
}
std::vector<MSTensor> outputs4;
ret = model.Predict(outputs3, &outputs4);
if (ret.IsError()) {
std::cout << "ERROR: Preprocess failed." << std::endl;
return 1;
}
std::ofstream o3("result3.txt", std::ios::out);
o3.write(reinterpret_cast<const char *>(outputs4[0].MutableData()), std::streamsize(outputs4[0].DataSize()));
// check shape
auto shape = outputs1[0].Shape();
std::cout << "Output Shape: " << std::endl;
for (auto s : shape) {
std::cout << s << ", ";