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

!19940 [MSLITE][DEVELOP] modify lite for new api 

Merge pull request !19940 from yangruoqi713/master
This commit is contained in:
i-robot 2021-07-12 09:34:48 +00:00 committed by Gitee
parent 5a5e6d82a9 f53e607cfd
commit 90f37a98c4
378 changed files with 2535 additions and 1738 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
cmake/package_lite.cmake
View File

@ -216,8 +216,6 @@ if(PLATFORM_ARM64)
endif()
install(FILES ${TOP_DIR}/mindspore/core/ir/dtype/type_id.h DESTINATION ${RUNTIME_INC_DIR}/ir/dtype
COMPONENT ${RUNTIME_COMPONENT_NAME})
install(FILES ${TOP_DIR}/mindspore/core/ir/format.h DESTINATION ${RUNTIME_INC_DIR}/ir
COMPONENT ${RUNTIME_COMPONENT_NAME})
install(DIRECTORY ${TOP_DIR}/include/api/ DESTINATION ${RUNTIME_INC_DIR}/api
COMPONENT ${RUNTIME_COMPONENT_NAME} FILES_MATCHING PATTERN "*.h" PATTERN "ops*" EXCLUDE)
__install_micro_wrapper()
@ -269,8 +267,6 @@ elseif(PLATFORM_ARM32)
endif()
install(FILES ${TOP_DIR}/mindspore/core/ir/dtype/type_id.h DESTINATION ${RUNTIME_INC_DIR}/ir/dtype
COMPONENT ${RUNTIME_COMPONENT_NAME})
install(FILES ${TOP_DIR}/mindspore/core/ir/format.h DESTINATION ${RUNTIME_INC_DIR}/ir
COMPONENT ${RUNTIME_COMPONENT_NAME})
install(DIRECTORY ${TOP_DIR}/include/api/ DESTINATION ${RUNTIME_INC_DIR}/api
COMPONENT ${RUNTIME_COMPONENT_NAME} FILES_MATCHING PATTERN "*.h" PATTERN "ops*" EXCLUDE)
__install_micro_wrapper()
@ -306,6 +302,8 @@ elseif(WIN32)
DESTINATION ${CONVERTER_ROOT_DIR}/lib COMPONENT ${RUNTIME_COMPONENT_NAME})
install(FILES ${glog_LIBPATH}/../bin/libglog.dll DESTINATION ${CONVERTER_ROOT_DIR}/lib
COMPONENT ${RUNTIME_COMPONENT_NAME})
install(DIRECTORY ${TOP_DIR}/include/api/ DESTINATION ${CONVERTER_ROOT_DIR}/include/api
COMPONENT ${RUNTIME_COMPONENT_NAME} FILES_MATCHING PATTERN "*.h" PATTERN "ops*" EXCLUDE)
install(DIRECTORY ${TOP_DIR}/mindspore/core/abstract/ DESTINATION ${CONVERTER_ROOT_DIR}/include/core/abstract
COMPONENT ${RUNTIME_COMPONENT_NAME} FILES_MATCHING PATTERN "*.h")
install(DIRECTORY ${TOP_DIR}/mindspore/core/base/ DESTINATION ${CONVERTER_ROOT_DIR}/include/core/base
@ -372,8 +370,6 @@ elseif(WIN32)
COMPONENT ${RUNTIME_COMPONENT_NAME})
install(FILES ${TOP_DIR}/mindspore/core/ir/dtype/type_id.h DESTINATION ${RUNTIME_INC_DIR}/ir/dtype
COMPONENT ${RUNTIME_COMPONENT_NAME})
install(FILES ${TOP_DIR}/mindspore/core/ir/format.h DESTINATION ${RUNTIME_INC_DIR}/ir
COMPONENT ${RUNTIME_COMPONENT_NAME})
install(DIRECTORY ${TOP_DIR}/include/api/ DESTINATION ${RUNTIME_INC_DIR}/api
COMPONENT ${RUNTIME_COMPONENT_NAME} FILES_MATCHING PATTERN "*.h" PATTERN "ops*" EXCLUDE)
install(FILES ${TOP_DIR}/build/mindspore/src/${MINDSPORE_LITE_LIB_NAME}.a DESTINATION ${RUNTIME_LIB_DIR}
@ -404,8 +400,6 @@ else()
COMPONENT ${RUNTIME_COMPONENT_NAME})
install(FILES ${TOP_DIR}/mindspore/core/ir/dtype/type_id.h DESTINATION ${RUNTIME_INC_DIR}/ir/dtype
COMPONENT ${RUNTIME_COMPONENT_NAME})
install(FILES ${TOP_DIR}/mindspore/core/ir/format.h DESTINATION ${RUNTIME_INC_DIR}/ir
COMPONENT ${RUNTIME_COMPONENT_NAME})
install(DIRECTORY ${TOP_DIR}/include/api/ DESTINATION ${RUNTIME_INC_DIR}/api
COMPONENT ${RUNTIME_COMPONENT_NAME} FILES_MATCHING PATTERN "*.h" PATTERN "ops*" EXCLUDE)
install(FILES ${TOP_DIR}/mindspore/lite/build/src/${MINDSPORE_LITE_LIB_NAME}.so DESTINATION ${RUNTIME_LIB_DIR}
@ -423,6 +417,8 @@ else()
install(DIRECTORY ${TOP_DIR}/mindspore/lite/include/ DESTINATION ${CONVERTER_ROOT_DIR}/include
COMPONENT ${RUNTIME_COMPONENT_NAME} FILES_MATCHING PATTERN "*.h"
PATTERN "train*" EXCLUDE PATTERN "delegate.h" EXCLUDE PATTERN "lite_session.h" EXCLUDE)
install(DIRECTORY ${TOP_DIR}/include/api/ DESTINATION ${CONVERTER_ROOT_DIR}/include/api
COMPONENT ${RUNTIME_COMPONENT_NAME} FILES_MATCHING PATTERN "*.h" PATTERN "ops*" EXCLUDE)
install(DIRECTORY ${TOP_DIR}/mindspore/core/abstract/ DESTINATION ${CONVERTER_ROOT_DIR}/include/core/abstract
COMPONENT ${RUNTIME_COMPONENT_NAME} FILES_MATCHING PATTERN "*.h")
install(DIRECTORY ${TOP_DIR}/mindspore/core/base/ DESTINATION ${CONVERTER_ROOT_DIR}/include/core/base

8
mindspore/lite/include/allocator.h → include/api/allocator.h
View File

@ -14,11 +14,11 @@
* limitations under the License.
*/
#ifndef MINDSPORE_LITE_INCLUDE_ALLOCATOR_H_
#define MINDSPORE_LITE_INCLUDE_ALLOCATOR_H_
#ifndef MINDSPORE_INCLUDE_API_ALLOCATOR_H
#define MINDSPORE_INCLUDE_API_ALLOCATOR_H
#include <memory>
#include "include/lite_utils.h"
#include "include/api/types.h"
namespace mindspore {
/// \brief Allocator defined a memory pool for malloc memory and free memory dynamically.
@ -85,4 +85,4 @@ class MS_API Allocator {
size_t aligned_size_ = 32;
};
} // namespace mindspore
#endif // MINDSPORE_LITE_INCLUDE_ALLOCATOR_H_
#endif // MINDSPORE_INCLUDE_API_ALLOCATOR_H

4
include/api/context.h
View File

@ -36,6 +36,7 @@ enum DeviceType {
};
class Allocator;
class Delegate;
class DeviceInfoContext;
class MS_API Context {
@ -57,6 +58,9 @@ class MS_API Context {
void SetEnableParallel(bool is_parallel);
bool GetEnableParallel() const;
void SetDelegate(const std::shared_ptr<Delegate> &delegate);
std::shared_ptr<Delegate> GetDelegate() const;
std::vector<std::shared_ptr<DeviceInfoContext>> &MutableDeviceInfo();
private:

1
include/api/data_type.h
View File

@ -23,6 +23,7 @@ enum class DataType : int {
kObjectTypeList = 13,
kObjectTypeTuple = 14,
kObjectTypeTensorType = 17,
kNumberTypeBegin = 29,
kNumberTypeBool = 30,
kNumberTypeInt8 = 32,
kNumberTypeInt16 = 33,

29
mindspore/lite/include/delegate.h → include/api/delegate.h
View File

@ -14,15 +14,14 @@
* limitations under the License.
*/
#ifndef MINDSPORE_LITE_DELEGATE_DELEGATE_H_
#define MINDSPORE_LITE_DELEGATE_DELEGATE_H_
#ifndef MINDSPORE_INCLUDE_API_DELEGATE_H
#define MINDSPORE_INCLUDE_API_DELEGATE_H
#include <map>
#include <vector>
#include <memory>
#include "include/ms_tensor.h"
#include "include/context.h"
#include "include/kernel.h"
#include "schema/model_generated.h"
#include "include/api/kernel.h"
namespace mindspore {
typedef enum {
@ -35,8 +34,8 @@ using KernelIter = std::vector<kernel::Kernel *>::iterator;
class MS_API DelegateModel {
public:
/// \brief Constructor of MindSpore Lite DelegateModel.
DelegateModel(std::vector<kernel::Kernel *> *kernels, const std::vector<tensor::MSTensor *> &inputs,
const std::vector<tensor::MSTensor *> &outputs,
DelegateModel(std::vector<kernel::Kernel *> *kernels, const std::vector<MSTensor> &inputs,
const std::vector<MSTensor> &outputs,
const std::map<kernel::Kernel *, const schema::Primitive *> &primitives, SchemaVersion version)
: kernels_(kernels), inputs_(inputs), outputs_(outputs), primitives_(primitives), version_(version) {}
@ -71,12 +70,12 @@ class MS_API DelegateModel {
/// \brief Get the input tensors of DelegateModel.
///
/// \return The input tensor vector of DelegateModel.
const std::vector<mindspore::tensor::MSTensor *> &inputs() { return this->inputs_; }
const std::vector<mindspore::MSTensor> &inputs() { return this->inputs_; }
/// \brief Get the output tensors of DelegateModel.
///
/// \return The ioutput tensor vector of DelegateModel.
const std::vector<mindspore::tensor::MSTensor *> &outputs() { return this->outputs_; }
const std::vector<mindspore::MSTensor> &outputs() { return this->outputs_; }
/// \brief Get the ms model version.
///
@ -85,14 +84,12 @@ class MS_API DelegateModel {
protected:
std::vector<kernel::Kernel *> *kernels_;
const std::vector<mindspore::tensor::MSTensor *> &inputs_;
const std::vector<mindspore::tensor::MSTensor *> &outputs_;
const std::vector<mindspore::MSTensor> &inputs_;
const std::vector<mindspore::MSTensor> &outputs_;
const std::map<kernel::Kernel *, const schema::Primitive *> &primitives_;
SchemaVersion version_;
};
typedef void (*DelegateHook)(std::shared_ptr<Delegate> delegate);
static void HookNullFuc(std::shared_ptr<Delegate> delegate) {}
class MS_API Delegate {
public:
/// \brief Constructor of MindSpore Lite Delegate.
@ -112,10 +109,6 @@ class MS_API Delegate {
///
/// \param[in] model Define the delegate model to be built.
virtual int Build(DelegateModel *model) = 0;
DelegateHook init_hook_ = HookNullFuc;
DelegateHook build_hook_ = HookNullFuc;
DelegateHook run_hook_ = HookNullFuc;
};
} // namespace mindspore
#endif // MINDSPORE_LITE_DELEGATE_DELEGATE_H_
#endif // MINDSPORE_INCLUDE_API_DELEGATE_H

6
mindspore/core/ir/format.h → include/api/format.h
View File

@ -16,8 +16,8 @@
* limitations under the License.
*/
#ifndef MINDSPORE_CORE_IR_FORMAT_H_
#define MINDSPORE_CORE_IR_FORMAT_H_
#ifndef MINDSPORE_INCLUDE_API_FORMAT_H
#define MINDSPORE_INCLUDE_API_FORMAT_H
#include <cstdint>
@ -43,4 +43,4 @@ enum Format : int64_t {
NCW = 17
};
} // namespace mindspore
#endif // MINDSPORE_CORE_IR_FORMAT_H_
#endif // MINDSPORE_INCLUDE_API_FORMAT_H

39
mindspore/lite/include/kernel.h → include/api/kernel.h
View File

@ -14,22 +14,22 @@
* limitations under the License.
*/
#ifndef MINDSPORE_LITE_SRC_KERNEL_H_
#define MINDSPORE_LITE_SRC_KERNEL_H_
#ifndef MINDSPORE_INCLUDE_API_KERNEL_H
#define MINDSPORE_INCLUDE_API_KERNEL_H
#include <vector>
#include <string>
#include <utility>
#include "schema/model_generated.h"
#include "include/lite_utils.h"
#include "include/context.h"
#include "include/api/types.h"
#include "include/api/context.h"
namespace mindspore::kernel {
class Kernel {
public:
Kernel() = default;
Kernel(const std::vector<tensor::MSTensor *> &inputs, const std::vector<tensor::MSTensor *> &outputs,
const schema::Primitive *primitive, const lite::Context *ctx)
Kernel(const std::vector<mindspore::MSTensor> &inputs, const std::vector<mindspore::MSTensor> &outputs,
const schema::Primitive *primitive, const mindspore::Context *ctx)
: inputs_(std::move(inputs)), outputs_(std::move(outputs)), primitive_(primitive), context_(ctx) {
if (primitive != nullptr) {
type_ = primitive->value_type();
@ -46,33 +46,34 @@ class Kernel {
virtual schema::PrimitiveType type() const { return type_; }
virtual void set_inputs(const std::vector<mindspore::tensor::MSTensor *> &in_tensors) { this->inputs_ = in_tensors; }
virtual void set_input(mindspore::tensor::MSTensor *in_tensor, int index) { this->inputs_[index] = in_tensor; }
virtual void set_inputs(const std::vector<mindspore::MSTensor> &in_tensors) { this->inputs_ = in_tensors; }
virtual void set_outputs(const std::vector<mindspore::tensor::MSTensor *> &out_tensors) {
this->outputs_ = out_tensors;
}
virtual void set_input(mindspore::MSTensor in_tensor, int index) { this->inputs_[index] = in_tensor; }
virtual void set_output(mindspore::tensor::MSTensor *out_tensor, int index) { this->outputs_[index] = out_tensor; }
virtual void set_outputs(const std::vector<mindspore::MSTensor> &out_tensors) { this->outputs_ = out_tensors; }
virtual const std::vector<mindspore::tensor::MSTensor *> &inputs() { return this->inputs_; }
virtual void set_output(mindspore::MSTensor out_tensor, int index) { this->outputs_[index] = out_tensor; }
virtual const std::vector<mindspore::tensor::MSTensor *> &outputs() { return this->outputs_; }
virtual const std::vector<mindspore::MSTensor> &inputs() { return this->inputs_; }
virtual const std::vector<mindspore::MSTensor> &outputs() { return this->outputs_; }
std::string name() const { return this->name_; }
void set_name(const std::string &name) { this->name_ = name; }
const lite::Context *context() const { return this->context_; }
const mindspore::Context *context() const { return this->context_; }
const schema::Primitive *primitive() const { return this->primitive_; }
protected:
std::vector<mindspore::tensor::MSTensor *> inputs_;
std::vector<mindspore::tensor::MSTensor *> outputs_;
std::vector<mindspore::MSTensor> inputs_;
std::vector<mindspore::MSTensor> outputs_;
schema::PrimitiveType type_ = schema::PrimitiveType_NONE;
std::string name_;
const schema::Primitive *primitive_ = nullptr;
const lite::Context *context_ = nullptr;
const mindspore::Context *context_ = nullptr;
};
} // namespace mindspore::kernel
#endif // MINDSPORE_LITE_SRC_KERNEL_H_
#endif // MINDSPORE_INCLUDE_API_KERNEL_H

13
include/api/types.h
View File

@ -23,6 +23,7 @@
#include <functional>
#include "include/api/data_type.h"
#include "include/api/dual_abi_helper.h"
#include "include/api/format.h"
#ifdef _WIN32
#define MS_API __declspec(dllexport)
@ -56,6 +57,7 @@ enum OptimizationLevel : uint32_t {
kOptimizationType = 0xFFFFFFFF
};
class Allocator;
class MS_API MSTensor {
public:
class Impl;
@ -91,6 +93,17 @@ class MS_API MSTensor {
MSTensor *Clone() const;
bool operator==(std::nullptr_t) const;
bool operator!=(std::nullptr_t) const;
bool operator==(const MSTensor &tensor) const;
void SetShape(const std::vector<int64_t> &shape);
void SetDataType(enum DataType data_type);
void SetTensorName(const std::string &name);
void SetAllocator(std::shared_ptr<Allocator> allocator);
std::shared_ptr<Allocator> allocator() const;
void SetFormat(mindspore::Format format);
mindspore::Format format() const;
void SetData(void *data);
const std::shared_ptr<Impl> impl() const { return impl_; }
private:
// api without std::string

2
mindspore/core/utils/check_convert_utils.h
View File

@ -27,7 +27,7 @@
#include "base/base.h"
#include "ir/anf.h"
#include "ir/dtype/type_id.h"
#include "ir/format.h"
#include "include/api/format.h"
#include "utils/log_adapter.h"
namespace mindspore {
typedef std::pair<std::map<std::string, int64_t>, std::map<int64_t, std::string>> AttrConverterPair;

6
mindspore/lite/include/registry/kernel_interface.h
View File

@ -22,7 +22,7 @@
#include <vector>
#include <memory>
#include "include/model.h"
#include "include/ms_tensor.h"
#include "include/api/types.h"
#include "schema/model_generated.h"
namespace mindspore {
@ -46,7 +46,7 @@ class MS_API KernelInterface {
/// \param[in] primitive Define the attributes of op.
///
/// \return STATUS as an error code of inferring, STATUS is defined in errorcode.h..
virtual int Infer(const std::vector<tensor::MSTensor *> &inputs, const std::vector<tensor::MSTensor *> &outputs,
virtual int Infer(std::vector<mindspore::MSTensor> *inputs, std::vector<mindspore::MSTensor> *outputs,
const schema::Primitive *primitive) {
return 0;
}
@ -58,7 +58,7 @@ class MS_API KernelInterface {
/// \param[in] param Define the contr of performance.
///
/// \return STATUS as an error code of inferring, STATUS is defined in errorcode.h.
virtual int GetCapability(const std::vector<tensor::MSTensor *> &tensor_in, const schema::Primitive *primitive,
virtual int GetCapability(const std::vector<mindspore::MSTensor> &tensor_in, const schema::Primitive *primitive,
CapabilityParam *param) {
return 0;
}

11
mindspore/lite/include/registry/register_kernel.h
View File

@ -22,9 +22,10 @@
#include <vector>
#include <memory>
#include "schema/model_generated.h"
#include "include/context.h"
#include "include/ms_tensor.h"
#include "include/kernel.h"
#include "include/api/context.h"
#include "include/api/types.h"
#include "include/api/kernel.h"
#include "ir/dtype/type_id.h"
namespace mindspore {
namespace kernel {
@ -57,8 +58,8 @@ struct MS_API KernelDesc {
///
/// \return Smart Pointer of kernel.
using CreateKernel = std::function<std::shared_ptr<kernel::Kernel>(
const std::vector<tensor::MSTensor *> &inputs, const std::vector<tensor::MSTensor *> &outputs,
const schema::Primitive *primitive, const lite::Context *ctx)>;
const std::vector<MSTensor> &inputs, const std::vector<MSTensor> &outputs, const schema::Primitive *primitive,
const mindspore::Context *ctx)>;
/// \brief RegisterKernel Defined registration of kernel.
class MS_API RegisterKernel {

6
mindspore/lite/micro/cmake/file_list.cmake
View File

@ -127,9 +127,13 @@ set(CODER_OPCODERS_SRC
)
set(LITE_SRC
${LITE_DIR}/src/cxx_api/tensor_utils.cc
${LITE_DIR}/src/cxx_api/types.cc
${LITE_DIR}/src/cxx_api/tensor/tensor_impl.cc
${LITE_DIR}/src/common/file_utils.cc
${LITE_DIR}/src/common/graph_util.cc
${LITE_DIR}/src/common/prim_util.cc
${LITE_DIR}/src/common/string_util.cc
${LITE_DIR}/src/common/tensor_util.cc
${LITE_DIR}/src/runtime/infer_manager.cc
${LITE_DIR}/src/registry/kernel_interface.cc
@ -137,12 +141,14 @@ set(LITE_SRC
${LITE_DIR}/src/registry/register_kernel.cc
${LITE_DIR}/src/registry/register_kernel_impl.cc
${LITE_DIR}/src/lite_model.cc
${LITE_DIR}/src/ms_tensor.cc
${LITE_DIR}/src/tensorlist.cc
${LITE_DIR}/src/tensor.cc
${LITE_DIR}/src/weight_decoder.cc
${LITE_DIR}/src/huffman_decode.cc
${LITE_DIR}/src/common/log_adapter.cc
${LITE_DIR}/src/common/utils.cc
${LITE_DIR}/../core/utils/status.cc
### tools
${LITE_DIR}/tools/common/flag_parser.cc
)

2
mindspore/lite/micro/coder/generator/component/const_blocks/mtensor.cc
View File

@ -38,7 +38,7 @@ const char tensor_header[] = R"RAW(
#define MINDSPORE_LITE_MICRO_LIBRARY_SOURCE_TENSOR_H_
#include "include/ms_tensor.h"
#include "include/ir/format.h"
#include "include/api/format.h"
namespace mindspore {
namespace lite {

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

@ -62,6 +62,7 @@ endif()
set(LITE_SRC
${API_SRC}
${CMAKE_CURRENT_SOURCE_DIR}/common/context_util.cc
${CMAKE_CURRENT_SOURCE_DIR}/common/file_utils.cc
${CMAKE_CURRENT_SOURCE_DIR}/common/utils.cc
${CMAKE_CURRENT_SOURCE_DIR}/common/graph_util.cc

120
mindspore/lite/src/common/context_util.cc Normal file
View File

@ -0,0 +1,120 @@
/**
* 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.
*/
#include "src/common/context_util.h"
#include <set>
#include <map>
#include <memory>
#include <string>
#include "src/common/log_adapter.h"
namespace mindspore {
namespace lite {
namespace {
template <class T>
void PassBasicProperties(std::shared_ptr<T> device_info, const lite::DeviceContext &device_context) {
device_info->SetProvider(device_context.provider_);
device_info->SetProviderDevice(device_context.provider_device_);
device_info->SetAllocator(device_context.allocator_);
}
std::shared_ptr<mindspore::CPUDeviceInfo> CPUDeviceInfoFromCPUDeviceContext(const lite::DeviceContext &cpu_context) {
if (cpu_context.device_type_ != DT_CPU) {
MS_LOG(ERROR) << "function input parameter is not cpu context.";
return nullptr;
}
auto cpu_info = std::make_shared<mindspore::CPUDeviceInfo>();
cpu_info->SetEnableFP16(cpu_context.device_info_.cpu_device_info_.enable_float16_);
PassBasicProperties(cpu_info, cpu_context);
return cpu_info;
}
std::shared_ptr<mindspore::MaliGPUDeviceInfo> GPUDeviceInfoFromGPUDeviceContext(
const lite::DeviceContext &gpu_context) {
if (gpu_context.device_type_ != DT_GPU) {
MS_LOG(ERROR) << "function input parameter is not gpu context.";
return nullptr;
}
auto gpu_info = std::make_shared<mindspore::MaliGPUDeviceInfo>();
gpu_info->SetEnableFP16(gpu_context.device_info_.gpu_device_info_.enable_float16_);
PassBasicProperties(gpu_info, gpu_context);
return gpu_info;
}
std::shared_ptr<mindspore::KirinNPUDeviceInfo> NPUDeviceInfoFromNPUDeviceContext(
const lite::DeviceContext &npu_context) {
if (npu_context.device_type_ != DT_NPU) {
MS_LOG(ERROR) << "function input parameter is not npu context.";
return nullptr;
}
auto npu_info = std::make_shared<mindspore::KirinNPUDeviceInfo>();
npu_info->SetFrequency(npu_context.device_info_.npu_device_info_.frequency_);
PassBasicProperties(npu_info, npu_context);
return npu_info;
}
} // namespace
mindspore::Context *MSContextFromContext(const lite::Context *context) {
if (context == nullptr) {
MS_LOG(ERROR) << "context is nullptr";
return nullptr;
}
auto ms_context = new (std::nothrow) mindspore::Context();
if (ms_context == nullptr) {
MS_LOG(ERROR) << "New Context failed";
return nullptr;
}
ms_context->SetThreadNum(context->thread_num_);
ms_context->SetThreadAffinity(context->affinity_core_list_);
ms_context->SetEnableParallel(context->enable_parallel_);
ms_context->SetDelegate(context->delegate);
auto &device_infos = ms_context->MutableDeviceInfo();
std::map<DeviceType, std::function<std::shared_ptr<mindspore::DeviceInfoContext>(const lite::DeviceContext &)>>
transfer_funcs = {{DT_CPU, CPUDeviceInfoFromCPUDeviceContext},
{DT_GPU, GPUDeviceInfoFromGPUDeviceContext},
{DT_NPU, NPUDeviceInfoFromNPUDeviceContext}};
for (auto &device_context : context->device_list_) {
auto device_type = device_context.device_type_;
if (transfer_funcs.find(device_type) == transfer_funcs.end()) {
MS_LOG(ERROR) << "device type is invalid.";
return nullptr;
}
auto device_info = transfer_funcs[device_type](device_context);
if (device_info == nullptr) {
MS_LOG(ERROR) << "transfer device context to device info failed.";
return nullptr;
}
if (device_type == DT_CPU) {
ms_context->SetThreadAffinity(device_context.device_info_.cpu_device_info_.cpu_bind_mode_);
}
device_infos.push_back(device_info);
}
return ms_context;
}
std::set<std::string> ProvidersFromMSContext(const mindspore::Context *context) {
std::set<std::string> providers;
if (context == nullptr) {
return providers;
}
auto &device_infos = const_cast<mindspore::Context *>(context)->MutableDeviceInfo();
for (auto &device_info : device_infos) {
providers.emplace(device_info->GetProvider());
}
return providers;
}
} // namespace lite
} // namespace mindspore

31
mindspore/lite/src/common/context_util.h Normal file
View File

@ -0,0 +1,31 @@
/**
* 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_LITE_SRC_COMMON_CONTEXT_UTIL_H_
#define MINDSPORE_LITE_SRC_COMMON_CONTEXT_UTIL_H_
#include <set>
#include <string>
#include "include/context.h"
#include "include/api/context.h"
namespace mindspore {
namespace lite {
mindspore::Context *MSContextFromContext(const lite::Context *context);
std::set<std::string> ProvidersFromMSContext(const mindspore::Context *context);
} // namespace lite
} // namespace mindspore
#endif // MINDSPORE_LITE_SRC_COMMON_CONTEXT_UTIL_H_

2
mindspore/lite/src/common/string_util.h
View File

@ -20,7 +20,7 @@
#include <vector>
#include <string>
#include <utility>
#include "mindspore/lite/src/tensor.h"
#include "src/tensor.h"
#include "src/common/log_adapter.h"
#include "tools/common/option.h"
#include "include/errorcode.h"

10
mindspore/lite/src/common/tensor_util.cc
View File

@ -270,5 +270,15 @@ int CheckTensorsInvalid(const std::vector<Tensor *> &tensors) {
}
return RET_OK;
}
std::vector<mindspore::MSTensor> LiteTensorsToMSTensors(const std::vector<lite::Tensor *> &lite_tensors) {
std::vector<mindspore::MSTensor> tensors;
std::transform(lite_tensors.begin(), lite_tensors.end(), std::back_inserter(tensors), [](lite::Tensor *tensor) {
return mindspore::MSTensor(std::make_shared<mindspore::MSTensor::Impl>(tensor));
});
return tensors;
}
} // namespace lite
} // namespace mindspore

6
mindspore/lite/src/common/tensor_util.h
View File

@ -17,10 +17,13 @@
#ifndef MINDSPORE_LITE_SRC_COMMON_TENSOR_UTIL_H_
#define MINDSPORE_LITE_SRC_COMMON_TENSOR_UTIL_H_
#include <vector>
#include <memory>
#include "src/tensor.h"
#include "src/tensorlist.h"
#include "nnacl/tensor_c.h"
#include "nnacl/infer/common_infer.h"
#include "src/cxx_api/tensor/tensor_impl.h"
namespace mindspore {
namespace lite {
@ -40,6 +43,9 @@ int GenerateOutTensorC(const OpParameter *const parameter, const std::vector<lit
const std::vector<lite::Tensor *> &outputs, std::vector<TensorC *> *out_tensor_c);
int CheckTensorsInvalid(const std::vector<Tensor *> &tensors);
std::vector<mindspore::MSTensor> LiteTensorsToMSTensors(const std::vector<lite::Tensor *> &lite_tensors);
} // namespace lite
} // namespace mindspore

18
mindspore/lite/src/cxx_api/context.cc
View File

@ -40,6 +40,7 @@ struct Context::Data {
bool enable_parallel_ = false;
std::vector<int32_t> affinity_core_list_;
int affinity_mode_ = 2;
std::shared_ptr<Delegate> delegate = nullptr;
};
struct DeviceInfoContext::Data {
@ -100,6 +101,7 @@ bool Context::GetEnableParallel() const {
MS_LOG(ERROR) << "Invalid context.";
return false;
}
return data_->enable_parallel_;
}
@ -137,6 +139,22 @@ std::vector<int32_t> Context::GetThreadAffinityCoreList() const {
return data_->affinity_core_list_;
}
void Context::SetDelegate(const std::shared_ptr<Delegate> &delegate) {
if (data_ == nullptr) {
MS_LOG(ERROR) << "Invalid context.";
return;
}
data_->delegate = delegate;
}
std::shared_ptr<Delegate> Context::GetDelegate() const {
if (data_ == nullptr) {
MS_LOG(ERROR) << "Invalid context.";
return nullptr;
}
return data_->delegate;
}
std::vector<std::shared_ptr<DeviceInfoContext>> &Context::MutableDeviceInfo() {
static std::vector<std::shared_ptr<DeviceInfoContext>> empty;
if (data_ == nullptr) {

2
mindspore/lite/src/cxx_api/converters.cc
View File

@ -82,7 +82,7 @@ Status A2L_ConvertContext(Context *a_context, lite::Context *l_context) {
return kLiteInputParamInvalid;
}
}
l_context->delegate = a_context->GetDelegate();
return kSuccess;
}
} // namespace mindspore

1
mindspore/lite/src/cxx_api/model/model_impl.cc
View File

@ -132,6 +132,7 @@ Status ModelImpl::RunGraph(const MSKernelCallBack &before, const MSKernelCallBac
mscall_param.node_type_ = call_param.node_type;
return before(inputs, outputs, mscall_param);
};
auto after_call_back = [&](const std::vector<mindspore::tensor::MSTensor *> &before_inputs,
const std::vector<mindspore::tensor::MSTensor *> &before_outputs,
const CallBackParam &call_param) {

1
mindspore/lite/src/cxx_api/model/model_impl.h
View File

@ -100,7 +100,6 @@ class ModelImpl {
void SetGraph(const std::shared_ptr<Graph> &graph) { graph_ = graph; }
void SetContext(const std::shared_ptr<Context> &context) { context_ = context; }
void SetConfig(const std::shared_ptr<TrainCfg> cfg) { cfg_ = cfg; }
lite::CpuBindMode GetCpuBindMode();
Status RunGraph(const MSKernelCallBack &before, const MSKernelCallBack &after);
};
} // namespace mindspore

25
mindspore/lite/src/cxx_api/tensor/tensor_impl.cc
View File

@ -14,6 +14,7 @@
* limitations under the License.
*/
#include "src/cxx_api/tensor/tensor_impl.h"
#include <cstddef>
#include <numeric>
#include <memory>
@ -21,15 +22,8 @@
#include <string>
#include <vector>
#include <functional>
#include "src/cxx_api/tensor/tensor_impl.h"
#include "src/cxx_api/tensor_utils.h"
#include "include/api/types.h"
#include "include/api/status.h"
#include "include/ms_tensor.h"
#include "src/common/string_util.h"
#include "src/tensor.h"
#include "src/common/log_adapter.h"
#include "ir/dtype/type_id.h"
namespace mindspore {
using mindspore::lite::RET_OK;
@ -37,7 +31,12 @@ using mindspore::lite::RET_OK;
std::shared_ptr<MSTensor::Impl> MSTensor::Impl::CreateTensorImpl(const std::string &name, enum DataType type,
const std::vector<int64_t> &shape, const void *data,
size_t data_len) {
std::vector<int32_t> truncated_shape = TruncateShape(shape, static_cast<enum TypeId>(type), data_len, true);
std::vector<int32_t> truncated_shape;
if (data_len == 0) {
truncated_shape = TruncateShape(shape, static_cast<enum TypeId>(type), data_len, false);
} else {
truncated_shape = TruncateShape(shape, static_cast<enum TypeId>(type), data_len, true);
}
if (truncated_shape.empty() && !(shape.empty())) {
MS_LOG(ERROR) << "Invalid shape for creating tensor.";
return nullptr;
@ -80,4 +79,14 @@ std::shared_ptr<MSTensor::Impl> MSTensor::Impl::StringsToTensorImpl(const std::s
impl->set_from_session(false);
return impl;
}
std::vector<std::string> MSTensor::Impl::TensorImplToStrings(const std::shared_ptr<Impl> &impl) {
std::vector<std::string> empty;
auto lite_tensor = impl->lite_tensor();
if (lite_tensor == nullptr) {
MS_LOG(ERROR) << "Invalid tensor impl.";
return empty;
}
return lite::MSTensorToStrings(lite_tensor);
}
} // namespace mindspore

103
mindspore/lite/src/cxx_api/tensor/tensor_impl.h
View File

@ -26,9 +26,9 @@
#include <functional>
#include "include/api/types.h"
#include "include/api/status.h"
#include "include/errorcode.h"
#include "include/lite_utils.h"
#include "include/ms_tensor.h"
#include "src/tensor.h"
#include "src/common/log_adapter.h"
namespace mindspore {
@ -38,7 +38,7 @@ class MSTensor::Impl {
public:
Impl() {}
virtual ~Impl() {
~Impl() {
if (lite_tensor_ == nullptr) {
return;
}
@ -57,22 +57,15 @@ class MSTensor::Impl {
}
}
static std::shared_ptr<Impl> CreateTensorImpl(const std::string &name, enum DataType type,
const std::vector<int64_t> &shape, const void *data, size_t data_len);
static std::shared_ptr<Impl> MS_API CreateTensorImpl(const std::string &name, enum DataType type,
const std::vector<int64_t> &shape, const void *data,
size_t data_len);
static std::shared_ptr<Impl> StringsToTensorImpl(const std::string &name, const std::vector<std::string> &str);
static std::shared_ptr<Impl> MS_API StringsToTensorImpl(const std::string &name, const std::vector<std::string> &str);
static std::vector<std::string> TensorImplToStrings(const std::shared_ptr<Impl> &impl) {
std::vector<std::string> empty;
auto lite_tensor = impl->lite_tensor();
if (lite_tensor == nullptr) {
MS_LOG(ERROR) << "Invalid tensor impl.";
return empty;
}
return lite::MSTensorToStrings(lite_tensor);
}
static std::vector<std::string> MS_API TensorImplToStrings(const std::shared_ptr<Impl> &impl);
virtual const std::string &Name() const {
const std::string &Name() const {
static std::string empty = "";
if (lite_tensor_ == nullptr) {
MS_LOG(ERROR) << "Invalid tensor.";
@ -81,7 +74,15 @@ class MSTensor::Impl {
return tensor_name_;
}
virtual enum DataType DataType() const {
void SetName(const std::string &name) {
if (lite_tensor_ == nullptr) {
MS_LOG(ERROR) << "Invalid tensor.";
return;
}
lite_tensor_->set_tensor_name(name);
}
enum DataType DataType() const {
if (lite_tensor_ == nullptr) {
MS_LOG(ERROR) << "Invalid tensor.";
return DataType::kTypeUnknown;
@ -89,6 +90,14 @@ class MSTensor::Impl {
return static_cast<enum DataType>(lite_tensor_->data_type());
}
void SetDataType(enum DataType data_type) {
if (lite_tensor_ == nullptr) {
MS_LOG(ERROR) << "Invalid tensor.";
return;
}
lite_tensor_->set_data_type(static_cast<enum TypeId>(data_type));
}
int64_t ElementNum() const {
if (lite_tensor_ == nullptr) {
MS_LOG(ERROR) << "Invalid tensor.";
@ -97,7 +106,7 @@ class MSTensor::Impl {
return static_cast<int64_t>(lite_tensor_->ElementsNum());
}
virtual const std::vector<int64_t> &Shape() {
const std::vector<int64_t> &Shape() {
static std::vector<int64_t> empty;
if (lite_tensor_ == nullptr) {
MS_LOG(ERROR) << "Invalid tensor.";
@ -109,7 +118,50 @@ class MSTensor::Impl {
return shape_;
}
virtual std::shared_ptr<const void> Data() const {
void SetShape(const std::vector<int64_t> &shape) {
if (lite_tensor_ == nullptr) {
MS_LOG(ERROR) << "Invalid tensor.";
return;
}
std::vector<int> tensor_shape;
tensor_shape.resize(shape.size());
std::transform(shape.begin(), shape.end(), tensor_shape.begin(), [](int64_t c) { return static_cast<int>(c); });
lite_tensor_->set_shape(tensor_shape);
}
std::shared_ptr<Allocator> allocator() const {
if (lite_tensor_ == nullptr) {
MS_LOG(ERROR) << "Invalid tensor.";
return nullptr;
}
return lite_tensor_->allocator();
}
void SetAllocator(std::shared_ptr<Allocator> allocator) {
if (lite_tensor_ == nullptr) {
MS_LOG(ERROR) << "Invalid tensor.";
return;
}
lite_tensor_->set_allocator(allocator);
}
mindspore::Format format() {
if (lite_tensor_ == nullptr) {
MS_LOG(ERROR) << "Invalid tensor.";
return mindspore::Format::NHWC;
}
return lite_tensor_->format();
}
void SetFormat(mindspore::Format format) {
if (lite_tensor_ == nullptr) {
MS_LOG(ERROR) << "Invalid tensor.";
return;
}
lite_tensor_->set_format(format);
}
std::shared_ptr<const void> Data() const {
if (lite_tensor_ == nullptr) {
MS_LOG(ERROR) << "Invalid tensor.";
return nullptr;
@ -123,14 +175,15 @@ class MSTensor::Impl {
return std::shared_ptr<const void>(lite_tensor_->data(), [](const void *) {});
}
virtual void *MutableData() {
void *MutableData() {
if (lite_tensor_ == nullptr) {
MS_LOG(ERROR) << "Invalid tensor.";
return nullptr;
}
return lite_tensor_->MutableData();
}
virtual size_t DataSize() const {
size_t DataSize() const {
if (lite_tensor_ == nullptr) {
MS_LOG(ERROR) << "Invalid tensor.";
return 0;
@ -138,7 +191,15 @@ class MSTensor::Impl {
return lite_tensor_->Size();
}
virtual bool IsDevice() const { return false; }
void SetData(void *data) {
if (lite_tensor_ == nullptr) {
MS_LOG(ERROR) << "Invalid tensor.";
return;
}
lite_tensor_->set_data(data);
}
bool IsDevice() const { return false; }
tensor::MSTensor *lite_tensor() const { return lite_tensor_; }

1
mindspore/lite/src/cxx_api/tensor_utils.cc
View File

@ -16,6 +16,7 @@
#include "src/cxx_api/tensor_utils.h"
#include "src/common/log_adapter.h"
#include "src/tensor.h"
namespace mindspore {
std::vector<int32_t> TruncateShape(const std::vector<int64_t> &shape, enum TypeId type, size_t data_len,

9
mindspore/lite/src/cxx_api/tensor_utils.h
View File

@ -26,11 +26,12 @@
#include "src/cxx_api/tensor/tensor_impl.h"
namespace mindspore {
std::vector<int32_t> TruncateShape(const std::vector<int64_t> &shape, enum TypeId type, size_t data_len,
bool verify_size);
Status LiteTensorToMSTensor(tensor::MSTensor *srcTensor, MSTensor *dstTensor);
std::vector<int32_t> MS_API TruncateShape(const std::vector<int64_t> &shape, enum TypeId type, size_t data_len,
bool verify_size);
std::vector<MSTensor> LiteTensorsToMSTensors(const std::vector<mindspore::tensor::MSTensor *> &srcTensors);
Status MS_API LiteTensorToMSTensor(tensor::MSTensor *srcTensor, MSTensor *dstTensor);
std::vector<MSTensor> MS_API LiteTensorsToMSTensors(const std::vector<mindspore::tensor::MSTensor *> &srcTensors);
} // namespace mindspore

106
mindspore/lite/src/cxx_api/types.cc
View File

@ -21,11 +21,12 @@
#include "include/api/status.h"
#include "include/api/dual_abi_helper.h"
#include "src/cxx_api/tensor/tensor_impl.h"
#include "src/common/string_util.h"
#include "src/tensor.h"
#include "src/common/log_adapter.h"
namespace mindspore {
namespace {
constexpr int64_t MAX_MALLOC_SIZE = static_cast<size_t>(2000) * 1024 * 1024;
}
class Buffer::Impl {
public:
Impl() : data_() { MS_LOG(ERROR) << "Unsupported feature."; }
@ -71,28 +72,37 @@ bool MSTensor::operator==(std::nullptr_t) const { return impl_ == nullptr; }
bool MSTensor::operator!=(std::nullptr_t) const { return impl_ != nullptr; }
bool MSTensor::operator==(const MSTensor &tensor) const { return impl_->lite_tensor() == tensor.impl_->lite_tensor(); }
MSTensor *MSTensor::CreateTensor(const std::vector<char> &name, enum DataType type, const std::vector<int64_t> &shape,
const void *data, size_t data_len) noexcept {
if (data_len < 0 || data_len > MAX_MALLOC_SIZE) {
MS_LOG(ERROR) << "data_len is error.";
return nullptr;
}
auto new_data = malloc(data_len);
if (new_data == nullptr) {
MS_LOG(ERROR) << "Allocate data failed.";
return nullptr;
void *new_data = nullptr;
if (data != nullptr) {
new_data = malloc(data_len);
if (new_data == nullptr) {
MS_LOG(ERROR) << "Allocate data failed.";
return nullptr;
}
::memcpy(new_data, data, data_len);
}
::memcpy(new_data, data, data_len);
auto impl = Impl::CreateTensorImpl(CharToString(name), type, shape, new_data, data_len);
if (impl == nullptr) {
MS_LOG(ERROR) << "Allocate tensor impl failed.";
free(new_data);
if (new_data != nullptr) {
free(new_data);
}
return nullptr;
}
auto ms_tensor = new (std::nothrow) MSTensor(impl);
if (ms_tensor == nullptr) {
MS_LOG(ERROR) << "Allocate tensor impl failed.";
free(new_data);
if (new_data != nullptr) {
free(new_data);
}
return nullptr;
}
impl->set_own_data(true);
@ -172,7 +182,7 @@ MSTensor *MSTensor::Clone() const {
std::vector<char> MSTensor::CharName() const {
if (impl_ == nullptr) {
MS_LOG(ERROR) << "Invalid tensor inpmlement.";
MS_LOG(ERROR) << "Invalid tensor implement.";
return std::vector<char>();
}
return StringToChar(impl_->Name());
@ -180,7 +190,7 @@ std::vector<char> MSTensor::CharName() const {
int64_t MSTensor::ElementNum() const {
if (impl_ == nullptr) {
MS_LOG(ERROR) << "Invalid tensor inpmlement.";
MS_LOG(ERROR) << "Invalid tensor implement.";
return -1;
}
return impl_->ElementNum();
@ -188,7 +198,7 @@ int64_t MSTensor::ElementNum() const {
enum DataType MSTensor::DataType() const {
if (impl_ == nullptr) {
MS_LOG(ERROR) << "Invalid tensor inpmlement.";
MS_LOG(ERROR) << "Invalid tensor implement.";
return DataType::kTypeUnknown;
}
return impl_->DataType();
@ -197,7 +207,7 @@ enum DataType MSTensor::DataType() const {
const std::vector<int64_t> &MSTensor::Shape() const {
static std::vector<int64_t> empty;
if (impl_ == nullptr) {
MS_LOG(ERROR) << "Invalid tensor inpmlement.";
MS_LOG(ERROR) << "Invalid tensor implement.";
return empty;
}
return impl_->Shape();
@ -205,7 +215,7 @@ const std::vector<int64_t> &MSTensor::Shape() const {
std::shared_ptr<const void> MSTensor::Data() const {
if (impl_ == nullptr) {
MS_LOG(ERROR) << "Invalid tensor inpmlement.";
MS_LOG(ERROR) << "Invalid tensor implement.";
return nullptr;
}
return impl_->Data();
@ -213,7 +223,7 @@ std::shared_ptr<const void> MSTensor::Data() const {
void *MSTensor::MutableData() {
if (impl_ == nullptr) {
MS_LOG(ERROR) << "Invalid tensor inpmlement.";
MS_LOG(ERROR) << "Invalid tensor implement.";
return nullptr;
}
return impl_->MutableData();
@ -221,7 +231,7 @@ void *MSTensor::MutableData() {
size_t MSTensor::DataSize() const {
if (impl_ == nullptr) {
MS_LOG(ERROR) << "Invalid tensor inpmlement.";
MS_LOG(ERROR) << "Invalid tensor implement.";
return 0;
}
return impl_->DataSize();
@ -238,6 +248,70 @@ void MSTensor::DestroyTensorPtr(MSTensor *tensor) noexcept {
}
}
void MSTensor::SetShape(const std::vector<int64_t> &shape) {
if (impl_ == nullptr) {
MS_LOG(ERROR) << "Invalid tensor implement.";
return;
}
impl_->SetShape(shape);
}
void MSTensor::SetDataType(enum DataType data_type) {
if (impl_ == nullptr) {
MS_LOG(ERROR) << "Invalid tensor implement.";
return;
}
impl_->SetDataType(data_type);
}
void MSTensor::SetTensorName(const std::string &name) {
if (impl_ == nullptr) {
MS_LOG(ERROR) << "Invalid tensor implement.";
return;
}
impl_->SetName(name);
}
void MSTensor::SetAllocator(std::shared_ptr<Allocator> allocator) {
if (impl_ == nullptr) {
MS_LOG(ERROR) << "Invalid tensor implement.";
return;
}
return impl_->SetAllocator(allocator);
}
std::shared_ptr<Allocator> MSTensor::allocator() const {
if (impl_ == nullptr) {
MS_LOG(ERROR) << "Invalid tensor implement.";
return nullptr;
}
return impl_->allocator();
}
void MSTensor::SetFormat(mindspore::Format format) {
if (impl_ == nullptr) {
MS_LOG(ERROR) << "Invalid tensor implement.";
return;
}
return impl_->SetFormat(format);
}
mindspore::Format MSTensor::format() const {
if (impl_ == nullptr) {
MS_LOG(ERROR) << "Invalid tensor implement.";
return mindspore::Format::NHWC;
}
return impl_->format();
}
void MSTensor::SetData(void *data) {
if (impl_ == nullptr) {
MS_LOG(ERROR) << "Invalid tensor implement.";
return;
}
return impl_->SetData(data);
}
Buffer::Buffer() : impl_(nullptr) { MS_LOG(ERROR) << "Unsupported feature."; }
Buffer::Buffer(const void *data, size_t data_len) : impl_(nullptr) { MS_LOG(ERROR) << "Unsupported feature."; }
Buffer::~Buffer() = default;

2
mindspore/lite/src/delegate/delegate.cc
View File

@ -14,7 +14,7 @@
* limitations under the License.
*/
#include "include/delegate.h"
#include "include/api/delegate.h"
namespace mindspore {
const schema::Primitive *DelegateModel::GetPrimitive(kernel::Kernel *kernel) const {
if (primitives_.find(kernel) != primitives_.end()) {

2
mindspore/lite/src/delegate/delegate_utils.cc
View File

@ -16,7 +16,7 @@
#include "src/delegate/delegate_utils.h"
namespace mindspore::lite {
bool IsSubGraphInputTensor(const std::vector<mindspore::tensor::MSTensor *> &inputs, tensor::MSTensor *input) {
bool IsSubGraphInputTensor(const std::vector<mindspore::MSTensor> &inputs, mindspore::MSTensor input) {
if (find(inputs.begin(), inputs.end(), input) != inputs.end()) {
return true;
}

37
mindspore/lite/src/delegate/delegate_utils.h
View File

@ -17,17 +17,17 @@
#define MINDSPORE_LITE_SRC_DELEGATE_DELEGATE_UTILS
#include <vector>
#include "include/ms_tensor.h"
#include "include/delegate.h"
#include "include/api/delegate.h"
#include "src/common/log_adapter.h"
#include "src/delegate/tensorrt/op/tensorrt_op.h"
namespace mindspore::lite {
bool IsSubGraphInputTensor(const std::vector<mindspore::tensor::MSTensor *> &inputs, tensor::MSTensor *input);
bool IsSubGraphInputTensor(const std::vector<mindspore::MSTensor> &inputs, mindspore::MSTensor input);
template <typename T>
std::vector<mindspore::tensor::MSTensor *> GetGraphInTensors(std::vector<T *> ops) {
std::vector<mindspore::tensor::MSTensor *> inputs;
auto is_op_output = [&](tensor::MSTensor *tensor) -> bool {
std::vector<mindspore::MSTensor> GetGraphInTensors(std::vector<T *> ops) {
std::vector<mindspore::MSTensor> inputs;
auto is_op_output = [&](mindspore::MSTensor tensor) -> bool {
for (auto op : ops) {
auto out_tensors = op->outputs();
if (find(out_tensors.begin(), out_tensors.end(), tensor) != out_tensors.end()) {
@ -39,7 +39,7 @@ std::vector<mindspore::tensor::MSTensor *> GetGraphInTensors(std::vector<T *> op
for (auto op : ops) {
for (auto in_tensor : op->inputs()) {
if (in_tensor->data() == nullptr && !is_op_output(in_tensor)) {
if (in_tensor.Data() == nullptr && !is_op_output(in_tensor)) {
inputs.push_back(in_tensor);
}
}
@ -48,9 +48,9 @@ std::vector<mindspore::tensor::MSTensor *> GetGraphInTensors(std::vector<T *> op
}
template <typename T>
std::vector<mindspore::tensor::MSTensor *> GetGraphOutTensors(const std::vector<T *> &ops) {
std::vector<mindspore::tensor::MSTensor *> outputs;
auto is_op_input = [&](const tensor::MSTensor *tensor) -> bool {
std::vector<mindspore::MSTensor> GetGraphOutTensors(const std::vector<T *> &ops) {
std::vector<mindspore::MSTensor> outputs;
auto is_op_input = [&](const mindspore::MSTensor tensor) -> bool {
for (auto op : ops) {
auto in_tensors = op->inputs();
if (find(in_tensors.begin(), in_tensors.end(), tensor) != in_tensors.end()) {
@ -86,13 +86,13 @@ std::vector<mindspore::tensor::MSTensor *> GetGraphOutTensors(const std::vector<
}
template <typename T>
std::vector<tensor::MSTensor *> GraphInTensors(const std::vector<T *> &ops, DelegateModel *model, KernelIter from,
KernelIter end) {
std::vector<mindspore::MSTensor> GraphInTensors(const std::vector<T *> &ops, DelegateModel *model, KernelIter from,
KernelIter end) {
auto in_tensors = GetGraphInTensors(ops);
std::vector<tensor::MSTensor *> all_in_tensors;
std::vector<mindspore::MSTensor> all_in_tensors;
for (auto op : ops) {
for (auto in_tensor : op->inputs()) {
if (in_tensor->data() != nullptr && find(in_tensors.begin(), in_tensors.end(), in_tensor) == in_tensors.end()) {
if (in_tensor.Data() != nullptr && find(in_tensors.begin(), in_tensors.end(), in_tensor) == in_tensors.end()) {
all_in_tensors.push_back(in_tensor);
}
}
@ -113,10 +113,10 @@ std::vector<tensor::MSTensor *> GraphInTensors(const std::vector<T *> &ops, Dele
}
template <typename T>
std::vector<tensor::MSTensor *> GraphOutTensors(const std::vector<T *> &ops, DelegateModel *model, KernelIter from,
KernelIter end) {
std::vector<mindspore::MSTensor> GraphOutTensors(const std::vector<T *> &ops, DelegateModel *model, KernelIter from,
KernelIter end) {
auto out_tensors = GetGraphOutTensors(ops);
std::vector<tensor::MSTensor *> all_out_tensors;
std::vector<mindspore::MSTensor> all_out_tensors;
for (auto op : ops) {
for (auto out_tensor : op->outputs()) {
if (find(out_tensors.begin(), out_tensors.end(), out_tensor) == out_tensors.end()) {
@ -176,9 +176,8 @@ void FindPreNextOps(std::vector<T *> all_ops) {
}
template <typename T>
int GetGraphInOutOps(const std::vector<mindspore::tensor::MSTensor *> &inputs,
const std::vector<mindspore::tensor::MSTensor *> &outputs, std::vector<T *> *in_ops,
std::vector<T *> *out_ops, const std::vector<T *> &all_ops) {
int GetGraphInOutOps(const std::vector<mindspore::MSTensor> &inputs, const std::vector<mindspore::MSTensor> &outputs,
std::vector<T *> *in_ops, std::vector<T *> *out_ops, const std::vector<T *> &all_ops) {
for (auto in_tensor : inputs) {
for (auto op : all_ops) {
if (find(op->inputs().begin(), op->inputs().end(), in_tensor) != op->inputs().end() &&

46
mindspore/lite/src/delegate/npu/npu_converter_utils.cc
View File

@ -15,7 +15,6 @@
*/
#include "src/delegate/npu/npu_converter_utils.h"
#include <arm_neon.h>
#include "src/common/log_adapter.h"
namespace mindspore {
#define C8NUM 8
@ -54,7 +53,7 @@ void Float16ToFloat32(const float16_t *__restrict input, float *__restrict outpu
}
#endif
ge::Shape ConverterToNPUShape(const std::vector<int> &src_shape) {
ge::Shape ConverterToNPUShape(const std::vector<int64_t> &src_shape) {
vector<int64_t> shapes;
shapes.reserve(src_shape.size());
for (int i = 0; i < src_shape.size(); i++) {
@ -82,27 +81,26 @@ ge::Format ConverterToNPUFormat(schema::Format format) {
return ge_format;
}
ge::DataType ConverterToNPUDataType(TypeId type_id) {
ge::DataType ConverterToNPUDataType(DataType type_id) {
ge::DataType data_type;
switch (type_id) {
case kNumberTypeFloat:
case kNumberTypeFloat32:
case kNumberTypeFloat16:
case DataType::kNumberTypeFloat32:
case DataType::kNumberTypeFloat16:
data_type = ge::DT_FLOAT;
break;
case kNumberTypeInt8:
case DataType::kNumberTypeInt8:
data_type = ge::DT_INT8;
break;
case kNumberTypeUInt8:
case DataType::kNumberTypeUInt8:
data_type = ge::DT_UINT8;
break;
case kNumberTypeInt16:
case DataType::kNumberTypeInt16:
data_type = ge::DT_INT16;
break;
case kNumberTypeInt32:
case DataType::kNumberTypeInt32:
data_type = ge::DT_INT32;
break;
case kNumberTypeUInt32:
case DataType::kNumberTypeUInt32:
data_type = ge::DT_UINT32;
break;
default:
@ -112,43 +110,41 @@ ge::DataType ConverterToNPUDataType(TypeId type_id) {
return data_type;
}
hiai::op::Data *ConverterToNPUData(tensor::MSTensor *src, const std::string &name) {
hiai::op::Data *ConverterToNPUData(mindspore::MSTensor src, const std::string &name) {
auto data = new (std::nothrow) hiai::op::Data(name);
if (data == nullptr) {
MS_LOG(ERROR) << "new data failed.";
return data;
}
ge::TensorDesc tensor_desc(ConverterToNPUShape(src->shape()), ge::FORMAT_NCHW,
ConverterToNPUDataType(src->data_type()));
ge::TensorDesc tensor_desc(ConverterToNPUShape(src.Shape()), ge::FORMAT_NCHW, ConverterToNPUDataType(src.DataType()));
data->update_input_desc_x(tensor_desc);
return data;
}
std::shared_ptr<ge::Tensor> ConverterToNPUTensor(tensor::MSTensor *src) {
std::shared_ptr<ge::Tensor> ConverterToNPUTensor(mindspore::MSTensor src) {
std::shared_ptr<ge::Tensor> ge_tensor = std::shared_ptr<ge::Tensor>(new (std::nothrow) ge::Tensor());
if (ge_tensor == nullptr) {
MS_LOG(ERROR) << "new ge_tensor failed.";
return nullptr;
}
ge::TensorDesc tensor_desc(ConverterToNPUShape(src->shape()), ge::FORMAT_NCHW,
ConverterToNPUDataType(src->data_type()));
ge::TensorDesc tensor_desc(ConverterToNPUShape(src.Shape()), ge::FORMAT_NCHW, ConverterToNPUDataType(src.DataType()));
ge_tensor->SetTensorDesc(tensor_desc);
if (src->data() != nullptr) {
if (src->data_type() == kNumberTypeFloat16) {
if (src.Data() != nullptr) {
if (src.DataType() == DataType::kNumberTypeFloat16) {
#ifdef ENABLE_ARM64
auto fp32_data = malloc(src->ElementsNum() * sizeof(float));
Float16ToFloat32(reinterpret_cast<float16_t *>(src->data()), reinterpret_cast<float *>(fp32_data),
src->ElementsNum());
ge_tensor->SetData(reinterpret_cast<const uint8_t *>(fp32_data), src->ElementsNum() * sizeof(float));
auto fp32_data = malloc(src.ElementNum() * sizeof(float));
Float16ToFloat32(reinterpret_cast<float16_t *>(src.MutableData()), reinterpret_cast<float *>(fp32_data),
src.ElementNum());
ge_tensor->SetData(reinterpret_cast<const uint8_t *>(fp32_data), src.ElementNum() * sizeof(float));
free(fp32_data);
#else
MS_LOG(ERROR) << "This platform does not support fp16.";
return nullptr;
#endif
} else {
ge_tensor->SetData(reinterpret_cast<const uint8_t *>(src->data()), src->Size());
ge_tensor->SetData(reinterpret_cast<const uint8_t *>(src.MutableData()), src.DataSize());
}
}
return ge_tensor;
@ -189,7 +185,7 @@ int TransFormAxis(int axis) {
}
}
bool IsContainMSTensor(const std::vector<tensor::MSTensor *> &tensor_vec, const tensor::MSTensor *tensor) {
bool IsContainMSTensor(const std::vector<mindspore::MSTensor> &tensor_vec, const mindspore::MSTensor tensor) {
return find(tensor_vec.begin(), tensor_vec.end(), tensor) != tensor_vec.end();
}
} // namespace mindspore

23
mindspore/lite/src/delegate/npu/npu_converter_utils.h
View File

@ -19,29 +19,36 @@
#include <string>
#include <memory>
#include <vector>
#ifdef ENABLE_ARM64
#include <arm_neon.h>
#endif
#include "schema/ops_generated.h"
#include "include/graph/tensor.h"
#include "include/graph/op/array_defs.h"
#include "include/ms_tensor.h"
#include "include/api/types.h"
#include "include/api/data_type.h"
namespace mindspore {
#ifdef ENABLE_ARM64
void Float32ToFloat16(const float *__restrict input, float16_t *__restrict output, int number);
std::shared_ptr<ge::Tensor> ConverterToNPUTensor(tensor::MSTensor *src);
void Float16ToFloat32(const float16_t *__restrict input, float *__restrict output, int number);
#endif
hiai::op::Data *ConverterToNPUData(tensor::MSTensor *src, const std::string &name);
std::shared_ptr<ge::Tensor> ConverterToNPUTensor(mindspore::MSTensor src);
hiai::op::Data *ConverterToNPUData(mindspore::MSTensor src, const std::string &name);
ge::Format ConverterToNPUFormat(schema::Format format);
ge::DataType ConverterToNPUDataType(TypeId type_id);
ge::DataType ConverterToNPUDataType(DataType type_id);
ge::Shape ConverterToNPUShape(const std::vector<int> &src_shape);
int ConverterToNPUActMode(schema::ActivationType type);
ge::Shape ConverterToNPUShape(const std::vector<int64_t> &src_shape);
int ConverterToNPUEltwiseMode(schema::EltwiseMode mode);
int TransFormAxis(int axis);
bool IsContainMSTensor(const std::vector<tensor::MSTensor *> &tensor_vec, const tensor::MSTensor *tensor);
bool IsContainMSTensor(const std::vector<mindspore::MSTensor> &tensor_vec, const mindspore::MSTensor tensor);
} // namespace mindspore
#endif // MINDSPORE_LITE_SRC_RUNTIME_DELEGATE_NPU_NPU_CONVERTER_UITLS_H_

38
mindspore/lite/src/delegate/npu/npu_delegate.cc
View File

@ -16,6 +16,7 @@
#include "src/delegate/npu/npu_delegate.h"
#include <queue>
#include "include/errorcode.h"
#include "src/delegate/npu/op/npu_op.h"
#include "src/delegate/npu/op/activation_npu.h"
#include "src/delegate/npu/op/argmax_npu.h"
@ -54,6 +55,9 @@
#include "src/delegate/npu/pass/npu_insert_transform_pass.h"
#include "src/delegate/npu/pass/npu_fusion_pass.h"
using mindspore::lite::RET_ERROR;
using mindspore::lite::RET_OK;
namespace mindspore {
NPUDelegate::~NPUDelegate() {
if (npu_manager_ != nullptr) {
@ -202,42 +206,42 @@ int NPUDelegate::Build(DelegateModel *model) {
}
NPUOp *NPUDelegate::GetOP(kernel::Kernel *kernel, const schema::Primitive *primitive) {
auto in_tensors = kernel->inputs();
auto out_tensors = kernel->outputs();
auto name = kernel->name();
NPUOp *npu_op = nullptr;
auto node_type = primitive->value_type();
if (node_type == schema::PrimitiveType_Conv2DFusion) {
npu_op = GetNPUConvOp(primitive, in_tensors, out_tensors, name);
npu_op = GetNPUConvOp(primitive, kernel->inputs(), kernel->outputs(), name);
} else {
if (op_func_lists_.find(node_type) != op_func_lists_.end()) {
npu_op = op_func_lists_[node_type](primitive, in_tensors, out_tensors, name);
npu_op = op_func_lists_[node_type](primitive, kernel->inputs(), kernel->outputs(), name);
} else {
MS_LOG(DEBUG) << "Unsupported op type for NPU.";
return nullptr;
}
}
for (auto tensor : in_tensors) {
if (tensor->data_type() == kNumberTypeFloat16 && tensor->data() == nullptr) {
tensor->set_data_type(kNumberTypeFloat32);
for (int i = 0; i < kernel->inputs().size(); i++) {
mindspore::MSTensor tensor = kernel->inputs()[i];
if (tensor.DataType() == DataType::kNumberTypeFloat16 && tensor.Data() == nullptr) {
tensor.SetDataType(DataType::kNumberTypeFloat32);
}
}
for (auto tensor : out_tensors) {
if (tensor->data_type() == kNumberTypeFloat16) {
tensor->set_data_type(kNumberTypeFloat32);
for (int i = 0; i < kernel->outputs().size(); i++) {
mindspore::MSTensor tensor = kernel->outputs()[i];
if (tensor.DataType() == DataType::kNumberTypeFloat16) {
tensor.SetDataType(DataType::kNumberTypeFloat32);
}
}
return npu_op;
}
std::vector<tensor::MSTensor *> GraphInTensors(const std::vector<NPUOp *> &ops, DelegateModel *model, KernelIter from,
KernelIter end) {
std::vector<mindspore::MSTensor> GraphInTensors(const std::vector<NPUOp *> &ops, DelegateModel *model, KernelIter from,
KernelIter end) {
auto in_tensors = NPUGraphUtils::GetGraphInTensors(ops);
std::vector<tensor::MSTensor *> all_in_tensors;
std::vector<mindspore::MSTensor> all_in_tensors;
for (auto op : ops) {
for (auto in_tensor : op->inputs()) {
if (in_tensor->data() != nullptr && find(in_tensors.begin(), in_tensors.end(), in_tensor) == in_tensors.end()) {
if (in_tensor.Data() != nullptr && find(in_tensors.begin(), in_tensors.end(), in_tensor) == in_tensors.end()) {
all_in_tensors.push_back(in_tensor);
}
}
@ -257,10 +261,10 @@ std::vector<tensor::MSTensor *> GraphInTensors(const std::vector<NPUOp *> &ops,
return in_tensors;
}
std::vector<tensor::MSTensor *> GraphOutTensors(const std::vector<NPUOp *> &ops, DelegateModel *model, KernelIter from,
KernelIter end) {
std::vector<mindspore::MSTensor> GraphOutTensors(const std::vector<NPUOp *> &ops, DelegateModel *model, KernelIter from,
KernelIter end) {
auto out_tensors = NPUGraphUtils::GetGraphOutTensors(ops);
std::vector<tensor::MSTensor *> all_out_tensors;
std::vector<mindspore::MSTensor> all_out_tensors;
for (auto op : ops) {
for (auto out_tensor : op->outputs()) {
if (find(out_tensors.begin(), out_tensors.end(), out_tensor) == out_tensors.end()) {

11
mindspore/lite/src/delegate/npu/npu_delegate.h
View File

@ -19,16 +19,11 @@
#include <vector>
#include <map>
#include "include/delegate.h"
#include "include/api/delegate.h"
#include "include/context.h"
#include "src/delegate/npu/npu_manager.h"
#include "src/delegate/npu/pass/npu_pass_manager.h"
#include "src/delegate/npu/op//npu_op.h"
#include "include/context.h"
#include "include/errorcode.h"
#include "src/common/log_adapter.h"
using mindspore::lite::RET_ERROR;
using mindspore::lite::RET_OK;
#include "src/delegate/npu/op/npu_op.h"
namespace mindspore {
class NPUDelegate : public Delegate {

37
mindspore/lite/src/delegate/npu/npu_executor.cc
View File

@ -47,8 +47,8 @@ int NPUExecutor::Prepare() {
return RET_OK;
}
std::vector<int> GetNpuTensorShape(int dim, std::shared_ptr<hiai::AiTensor> npu_tensor) {
std::vector<int> npu_shape;
std::vector<int64_t> GetNpuTensorShape(int dim, std::shared_ptr<hiai::AiTensor> npu_tensor) {
std::vector<int64_t> npu_shape;
if (dim > 0) {
npu_shape.push_back(npu_tensor->GetTensorDimension().GetNumber());
}
@ -75,40 +75,40 @@ std::vector<int> ExpandShapeTo4d(const std::vector<int> &shape) {
return ret;
}
bool IsSameShapeTensor(tensor::MSTensor *tensor, std::shared_ptr<hiai::AiTensor> npu_tensor) {
if (tensor->shape().size() > 4) {
bool IsSameShapeTensor(mindspore::MSTensor tensor, std::shared_ptr<hiai::AiTensor> npu_tensor) {
if (tensor.Shape().size() > 4) {
MS_LOG(ERROR) << "Npu does not support output tensor dims greater than 4";
return false;
}
return GetNpuTensorShape(tensor->shape().size(), npu_tensor) == tensor->shape();
return GetNpuTensorShape(tensor.Shape().size(), npu_tensor) == tensor.Shape();
}
int NPUExecutor::Run(const std::vector<tensor::MSTensor *> &in_tensors,
const std::vector<tensor::MSTensor *> &out_tensors, const std::vector<NPUOp *> &in_ops) {
int NPUExecutor::Run(const std::vector<mindspore::MSTensor> &in_tensors,
const std::vector<mindspore::MSTensor> &out_tensors, const std::vector<NPUOp *> &in_ops) {
hiai::AiContext context;
std::unordered_map<tensor::MSTensor *, int> tensor_uses;
std::unordered_map<std::string, int> tensor_uses;
for (const auto op : in_ops) {
for (const auto op_input : op->inputs()) {
if (tensor_uses.find(op_input) == tensor_uses.end()) {
tensor_uses.insert({op_input, 1});
if (tensor_uses.find(op_input.Name()) == tensor_uses.end()) {
tensor_uses.insert({op_input.Name(), 1});
} else {
tensor_uses[op_input]++;
tensor_uses[op_input.Name()]++;
}
}
}
for (int i = 0; i < npu_input_tensors_.size(); ++i) {
int index = 0;
for (; index < in_tensors.size(); index++) {
if (tensor_uses[in_tensors[index]] > 0 && IsSameShapeTensor(in_tensors[index], npu_input_tensors_[i])) {
void *data = in_tensors[index]->data();
if (tensor_uses[in_tensors[index].Name()] > 0 && IsSameShapeTensor(in_tensors[index], npu_input_tensors_[i])) {
auto data = in_tensors[index].Data();
if (data == nullptr) {
MS_LOG(ERROR) << "For " << model_name_ << ", the input tensor " << in_tensors[index]->tensor_name()
MS_LOG(ERROR) << "For " << model_name_ << ", the input tensor " << in_tensors[index].Name()
<< " data is nullptr";
return RET_ERROR;
}
memcpy(npu_input_tensors_[i]->GetBuffer(), data, in_tensors[index]->Size());
tensor_uses[in_tensors[index]]--;
memcpy(npu_input_tensors_[i]->GetBuffer(), data.get(), in_tensors[index].DataSize());
tensor_uses[in_tensors[index].Name()]--;
break;
}
}
@ -135,9 +135,10 @@ int NPUExecutor::Run(const std::vector<tensor::MSTensor *> &in_tensors,
int index = 0;
for (; index < out_tensors.size(); index++) {
if (!outputs_visited[index] && IsSameShapeTensor(out_tensors[index], npu_output_tensors_[i])) {
void *data = out_tensors[index]->data();
mindspore::MSTensor out_tensor = out_tensors[index];
auto data = out_tensor.MutableData();
if (data == nullptr) {
MS_LOG(ERROR) << "For " << model_name_ << ", the output tensor " << in_tensors[index]->tensor_name()
MS_LOG(ERROR) << "For " << model_name_ << ", the output tensor " << out_tensors[index].Name()
<< " data is nullptr";
return RET_ERROR;
}

2
mindspore/lite/src/delegate/npu/npu_executor.h
View File

@ -33,7 +33,7 @@ class NPUExecutor {
~NPUExecutor();
int Prepare();
int Run(const std::vector<tensor::MSTensor *> &in_tensors, const std::vector<tensor::MSTensor *> &out_tensors,
int Run(const std::vector<mindspore::MSTensor> &in_tensors, const std::vector<mindspore::MSTensor> &out_tensors,
const std::vector<NPUOp *> &in_ops);
private:

10
mindspore/lite/src/delegate/npu/npu_graph.cc
View File

@ -28,12 +28,12 @@ NPUGraph::~NPUGraph() {
for (auto *op : npu_ops_) {
delete op;
}
for (auto *tensor : insert_tensors_) {
for (auto tensor : insert_tensors_) {
delete tensor;
}
}
void NPUGraph::set_input(tensor::MSTensor *in_tensor, int index) {
void NPUGraph::set_input(mindspore::MSTensor in_tensor, int index) {
MS_ASSERT(index < inputs_.size());
auto origin_tensor = this->inputs_[index];
for (auto kernel : all_kernels_) {
@ -46,7 +46,7 @@ void NPUGraph::set_input(tensor::MSTensor *in_tensor, int index) {
this->inputs_[index] = in_tensor;
}
void NPUGraph::set_output(tensor::MSTensor *out_tensor, int index) {
void NPUGraph::set_output(mindspore::MSTensor out_tensor, int index) {
MS_ASSERT(index < outputs_.size());
auto origin_tensor = this->outputs_[index];
for (auto kernel : all_kernels_) {
@ -199,7 +199,7 @@ int NPUGraph::Prepare() {
}
for (auto output : all_kernels_[i]->outputs()) {
if (find(outputs_.begin(), outputs_.end(), output) == outputs_.end()) {
output->MutableData();
output.MutableData();
}
}
}
@ -211,7 +211,7 @@ int NPUGraph::Execute() {
// 1. malloc graph output data
for (auto output : all_kernels_[i]->outputs()) {
if (find(outputs_.begin(), outputs_.end(), output) != outputs_.end()) {
output->MutableData();
output.MutableData();
}
}
// 2. execute

14
mindspore/lite/src/delegate/npu/npu_graph.h
View File

@ -20,15 +20,15 @@
#include <vector>
#include <map>
#include <utility>
#include "include/kernel.h"
#include "include/api/kernel.h"
#include "src/delegate/npu/op/npu_op.h"
#include "src/delegate/npu/npu_executor.h"
namespace mindspore {
class NPUGraph : public kernel::Kernel {
public:
NPUGraph(std::vector<NPUOp *> npu_ops, NPUManager *npu_manager, const std::vector<tensor::MSTensor *> &inputs,
const std::vector<tensor::MSTensor *> &outputs)
NPUGraph(std::vector<NPUOp *> npu_ops, NPUManager *npu_manager, const std::vector<mindspore::MSTensor> &inputs,
const std::vector<mindspore::MSTensor> &outputs)
: kernel::Kernel(inputs, outputs, nullptr, nullptr), npu_ops_(std::move(npu_ops)), npu_manager_(npu_manager) {}
~NPUGraph() override;
@ -44,15 +44,15 @@ class NPUGraph : public kernel::Kernel {
return lite::RET_ERROR;
}
void set_input(tensor::MSTensor *in_tensor, int index) override;
void set_input(mindspore::MSTensor in_tensor, int index) override;
void set_output(tensor::MSTensor *out_tensor, int index) override;
void set_output(mindspore::MSTensor out_tensor, int index) override;
int FindPreNextOps();
std::vector<NPUOp *> *GetOps() { return &npu_ops_; }
std::vector<tensor::MSTensor *> *GetInsertTensors() { return &insert_tensors_; }
std::vector<mindspore::MSTensor *> *GetInsertTensors() { return &insert_tensors_; }
protected:
std::vector<NPUOp *> FindPreOps(NPUOp *cur_op);
@ -69,7 +69,7 @@ class NPUGraph : public kernel::Kernel {
std::vector<kernel::Kernel *> all_kernels_{};
std::vector<tensor::MSTensor *> insert_tensors_;
std::vector<mindspore::MSTensor *> insert_tensors_;
NPUManager *npu_manager_ = nullptr;
};

14
mindspore/lite/src/delegate/npu/npu_graph_utils.cc
View File

@ -16,9 +16,9 @@
#include "src/delegate/npu/npu_graph_utils.h"
namespace mindspore {
std::vector<mindspore::tensor::MSTensor *> NPUGraphUtils::GetGraphInTensors(std::vector<NPUOp *> ops) {
std::vector<mindspore::tensor::MSTensor *> inputs;
auto is_op_output = [&](tensor::MSTensor *tensor) -> bool {
std::vector<mindspore::MSTensor> NPUGraphUtils::GetGraphInTensors(std::vector<NPUOp *> ops) {
std::vector<mindspore::MSTensor> inputs;
auto is_op_output = [&](mindspore::MSTensor tensor) -> bool {
for (auto op : ops) {
auto out_tensors = op->outputs();
if (find(out_tensors.begin(), out_tensors.end(), tensor) != out_tensors.end()) {
@ -30,7 +30,7 @@ std::vector<mindspore::tensor::MSTensor *> NPUGraphUtils::GetGraphInTensors(std:
for (auto op : ops) {
for (auto in_tensor : op->inputs()) {
if (in_tensor->data() == nullptr && !is_op_output(in_tensor)) {
if (in_tensor.Data() == nullptr && !is_op_output(in_tensor)) {
inputs.push_back(in_tensor);
}
}
@ -38,9 +38,9 @@ std::vector<mindspore::tensor::MSTensor *> NPUGraphUtils::GetGraphInTensors(std:
return inputs;
}
std::vector<mindspore::tensor::MSTensor *> NPUGraphUtils::GetGraphOutTensors(std::vector<NPUOp *> ops) {
std::vector<mindspore::tensor::MSTensor *> outputs;
auto is_op_input = [&](const tensor::MSTensor *tensor) -> bool {
std::vector<mindspore::MSTensor> NPUGraphUtils::GetGraphOutTensors(std::vector<NPUOp *> ops) {
std::vector<mindspore::MSTensor> outputs;
auto is_op_input = [&](const mindspore::MSTensor tensor) -> bool {
for (auto op : ops) {
auto in_tensors = op->inputs();
if (find(in_tensors.begin(), in_tensors.end(), tensor) != in_tensors.end()) {

4
mindspore/lite/src/delegate/npu/npu_graph_utils.h
View File

@ -23,9 +23,9 @@
namespace mindspore {
class NPUGraphUtils {
public:
static std::vector<mindspore::tensor::MSTensor *> GetGraphInTensors(std::vector<NPUOp *> ops);
static std::vector<mindspore::MSTensor> GetGraphInTensors(std::vector<NPUOp *> ops);
static std::vector<mindspore::tensor::MSTensor *> GetGraphOutTensors(std::vector<NPUOp *> ops);
static std::vector<mindspore::MSTensor> GetGraphOutTensors(std::vector<NPUOp *> ops);
};
} // namespace mindspore

6
mindspore/lite/src/delegate/npu/npu_subgraph.cc
View File

@ -48,7 +48,7 @@ NPUSubGraph::~NPUSubGraph() {
op_buffer_.clear();
}
void NPUSubGraph::set_input(tensor::MSTensor *in_tensor, int index) {
void NPUSubGraph::set_input(mindspore::MSTensor in_tensor, int index) {
MS_ASSERT(index < inputs_.size());
auto origin_tensor = inputs_[index];
// only in_ops_ input tensors list used in execute function
@ -62,7 +62,7 @@ void NPUSubGraph::set_input(tensor::MSTensor *in_tensor, int index) {
this->inputs_[index] = in_tensor;
}
void NPUSubGraph::set_output(tensor::MSTensor *out_tensor, int index) {
void NPUSubGraph::set_output(mindspore::MSTensor out_tensor, int index) {
MS_ASSERT(index < out_tensor_sorted_.size());
auto origin_tensor = outputs_[index];
for (size_t i = 0; i < out_tensor_sorted_.size(); i++) {
@ -217,7 +217,7 @@ int NPUSubGraph::BuildNPUInputOp() {
return RET_OK;
}
bool NPUSubGraph::IsSubGraphInputTensor(tensor::MSTensor *input) {
bool NPUSubGraph::IsSubGraphInputTensor(mindspore::MSTensor input) {
if (find(this->inputs().begin(), this->inputs().end(), input) != this->inputs().end()) {
return true;
}

10
mindspore/lite/src/delegate/npu/npu_subgraph.h
View File

@ -20,7 +20,7 @@
#include <memory>
#include <vector>
#include <string>
#include "include/kernel.h"
#include "include/api/kernel.h"
#include "src/delegate/npu/npu_executor.h"
namespace mindspore {
@ -42,9 +42,9 @@ class NPUSubGraph : public kernel::Kernel {
return lite::RET_ERROR;
}
void set_input(tensor::MSTensor *in_tensor, int index) override;
void set_input(mindspore::MSTensor in_tensor, int index) override;
void set_output(tensor::MSTensor *out_tensor, int index) override;
void set_output(mindspore::MSTensor out_tensor, int index) override;
int GetGraphInOutOps();
@ -59,7 +59,7 @@ class NPUSubGraph : public kernel::Kernel {
int GetNPUOperators(const std::vector<NPUOp *> &ops);
bool IsSubGraphInputTensor(tensor::MSTensor *input);
bool IsSubGraphInputTensor(mindspore::MSTensor input);
std::string GetOMModelName();
@ -69,7 +69,7 @@ class NPUSubGraph : public kernel::Kernel {
std::vector<ge::Operator> subgraph_output_ops_;
std::vector<tensor::MSTensor *> out_tensor_sorted_;
std::vector<mindspore::MSTensor> out_tensor_sorted_;
std::vector<ge::Operator *> op_buffer_;

12
mindspore/lite/src/delegate/npu/op/activation_npu.cc
View File

@ -16,8 +16,8 @@
#include "src/delegate/npu/op/activation_npu.h"
namespace mindspore {
int ActivationNPUOp::IsSupport(const schema::Primitive *primitive, const std::vector<tensor::MSTensor *> &in_tensors,
const std::vector<tensor::MSTensor *> &out_tensors) {
int ActivationNPUOp::IsSupport(const schema::Primitive *primitive, const std::vector<mindspore::MSTensor> &in_tensors,
const std::vector<mindspore::MSTensor> &out_tensors) {
auto act_prim = primitive->value_as_Activation();
if (act_prim == nullptr) {
MS_LOG(ERROR) << "Get null primitive value for op ." << name_;
@ -33,8 +33,8 @@ int ActivationNPUOp::IsSupport(const schema::Primitive *primitive, const std::ve
return RET_OK;
}
int ActivationNPUOp::Init(const schema::Primitive *primitive, const std::vector<tensor::MSTensor *> &in_tensors,
const std::vector<tensor::MSTensor *> &out_tensors) {
int ActivationNPUOp::Init(const schema::Primitive *primitive, const std::vector<mindspore::MSTensor> &in_tensors,
const std::vector<mindspore::MSTensor> &out_tensors) {
act_ = new (std::nothrow) hiai::op::Activation(name_);
if (act_ == nullptr) {
MS_LOG(ERROR) << "New activation npu operator for activation op " << name_ << " failed.";
@ -72,8 +72,8 @@ int ActivationNPUOp::Init(const schema::Primitive *primitive, const std::vector<
return RET_OK;
}
int ActivationNPUOp::SetNPUInputs(const std::vector<tensor::MSTensor *> &in_tensors,
const std::vector<tensor::MSTensor *> &out_tensors,
int ActivationNPUOp::SetNPUInputs(const std::vector<mindspore::MSTensor> &in_tensors,
const std::vector<mindspore::MSTensor> &out_tensors,
const std::vector<ge::Operator *> &npu_inputs) {
act_->set_input_x(*npu_inputs[0]);
return RET_OK;

17
mindspore/lite/src/delegate/npu/op/activation_npu.h
View File

@ -18,26 +18,25 @@
#include <vector>
#include <string>
#include "include/graph/op/all_ops.h"
#include "include/graph/compatible/all_ops.h"
#include "src/delegate/npu/op/npu_op.h"
namespace mindspore {
class ActivationNPUOp : public NPUOp {
public:
ActivationNPUOp(const schema::Primitive *primitive, const std::vector<tensor::MSTensor *> &in_tensors,
const std::vector<tensor::MSTensor *> &out_tensors, std::string name)
ActivationNPUOp(const schema::Primitive *primitive, const std::vector<mindspore::MSTensor> &in_tensors,
const std::vector<mindspore::MSTensor> &out_tensors, std::string name)
: NPUOp(primitive, in_tensors, out_tensors, name) {}
~ActivationNPUOp() override;
int IsSupport(const schema::Primitive *primitive, const std::vector<tensor::MSTensor *> &in_tensors,
const std::vector<tensor::MSTensor *> &out_tensors) override;
int IsSupport(const schema::Primitive *primitive, const std::vector<mindspore::MSTensor> &in_tensors,
const std::vector<mindspore::MSTensor> &out_tensors) override;
int Init(const schema::Primitive *primitive, const std::vector<tensor::MSTensor *> &in_tensors,
const std::vector<tensor::MSTensor *> &out_tensors) override;
int Init(const schema::Primitive *primitive, const std::vector<mindspore::MSTensor> &in_tensors,
const std::vector<mindspore::MSTensor> &out_tensors) override;
int SetNPUInputs(const std::vector<tensor::MSTensor *> &in_tensors,
const std::vector<tensor::MSTensor *> &out_tensors,
int SetNPUInputs(const std::vector<mindspore::MSTensor> &in_tensors,
const std::vector<mindspore::MSTensor> &out_tensors,
const std::vector<ge::Operator *> &npu_inputs) override;
ge::Operator *GetNPUOp() override;

9
mindspore/lite/src/delegate/npu/op/argmax_npu.cc
View File

@ -16,11 +16,10 @@
#include "src/delegate/npu/op/argmax_npu.h"
#include <memory>
#include "src/delegate/npu/npu_converter_utils.h"
namespace mindspore {
int ArgmaxNPUOp::Init(const schema::Primitive *primitive, const std::vector<tensor::MSTensor *> &in_tensors,
const std::vector<tensor::MSTensor *> &out_tensors) {
int ArgmaxNPUOp::Init(const schema::Primitive *primitive, const std::vector<mindspore::MSTensor> &in_tensors,
const std::vector<mindspore::MSTensor> &out_tensors) {
argmax_ = new (std::nothrow) hiai::op::ArgMaxExt2(name_);
if (argmax_ == nullptr) {
MS_LOG(ERROR) << "New argmax npu operator for " << name_ << " failed.";
@ -54,8 +53,8 @@ int ArgmaxNPUOp::Init(const schema::Primitive *primitive, const std::vector<tens
return RET_OK;
}
int ArgmaxNPUOp::SetNPUInputs(const std::vector<tensor::MSTensor *> &in_tensors,
const std::vector<tensor::MSTensor *> &out_tensors,
int ArgmaxNPUOp::SetNPUInputs(const std::vector<mindspore::MSTensor> &in_tensors,
const std::vector<mindspore::MSTensor> &out_tensors,
const std::vector<ge::Operator *> &npu_inputs) {
argmax_->set_input_x(*npu_inputs[0]);
return RET_OK;

16
mindspore/lite/src/delegate/npu/op/argmax_npu.h
View File

@ -27,22 +27,22 @@ namespace mindspore {
class ArgmaxNPUOp : public NPUOp {
public:
ArgmaxNPUOp(const schema::Primitive *primitive, const std::vector<tensor::MSTensor *> &in_tensors,
const std::vector<tensor::MSTensor *> &out_tensors, std::string name)
ArgmaxNPUOp(const schema::Primitive *primitive, const std::vector<mindspore::MSTensor> &in_tensors,
const std::vector<mindspore::MSTensor> &out_tensors, std::string name)
: NPUOp(primitive, in_tensors, out_tensors, name) {}
~ArgmaxNPUOp() override;
int IsSupport(const schema::Primitive *primitive, const std::vector<tensor::MSTensor *> &in_tensors,
const std::vector<tensor::MSTensor *> &out_tensors) override {
int IsSupport(const schema::Primitive *primitive, const std::vector<mindspore::MSTensor> &in_tensors,
const std::vector<mindspore::MSTensor> &out_tensors) override {
return RET_OK;
}
int Init(const schema::Primitive *primitive, const std::vector<tensor::MSTensor *> &in_tensors,
const std::vector<tensor::MSTensor *> &out_tensors) override;
int Init(const schema::Primitive *primitive, const std::vector<mindspore::MSTensor> &in_tensors,
const std::vector<mindspore::MSTensor> &out_tensors) override;
int SetNPUInputs(const std::vector<tensor::MSTensor *> &in_tensors,
const std::vector<tensor::MSTensor *> &out_tensors,
int SetNPUInputs(const std::vector<mindspore::MSTensor> &in_tensors,
const std::vector<mindspore::MSTensor> &out_tensors,
const std::vector<ge::Operator *> &npu_inputs) override;
ge::Operator *GetNPUOp() override;

23
mindspore/lite/src/delegate/npu/op/arithmetic_npu.cc
View File

@ -15,23 +15,22 @@
*/
#include "src/delegate/npu/op/arithmetic_npu.h"
#include "include/graph/op/all_ops.h"
namespace mindspore {
constexpr int RELU_MODE = 1;
constexpr int RELU6_MODE = 14;
int ArithmeticNPUOp::IsSupport(const schema::Primitive *primitive, const std::vector<tensor::MSTensor *> &in_tensors,
const std::vector<tensor::MSTensor *> &out_tensors) {
if (in_tensors[0]->shape() != in_tensors[1]->shape()) {
int ArithmeticNPUOp::IsSupport(const schema::Primitive *primitive, const std::vector<mindspore::MSTensor> &in_tensors,
const std::vector<mindspore::MSTensor> &out_tensors) {
if (in_tensors[0].Shape() != in_tensors[1].Shape()) {
MS_LOG(WARNING) << name_ << " for the two inputs, the corresponding dimensions must have the same value."
<< " shape 1 is:" << in_tensors[0]->shape() << " shape 2 is:" << in_tensors[1]->shape();
<< " shape 1 is:" << in_tensors[0].Shape() << " shape 2 is:" << in_tensors[1].Shape();
return RET_NOT_SUPPORT;
}
auto type = primitive->value_type();
if (type == mindspore::schema::PrimitiveType_Less && in_tensors[0]->shape().size() == 1) {
if (type == mindspore::schema::PrimitiveType_Less && in_tensors[0].Shape().size() == 1) {
MS_LOG(WARNING) << name_ << " not support input 1d";
return RET_NOT_SUPPORT;
}
if (type == mindspore::schema::PrimitiveType_Equal && in_tensors[0]->shape().size() == 2) {
if (type == mindspore::schema::PrimitiveType_Equal && in_tensors[0].Shape().size() == 2) {
MS_LOG(WARNING) << name_ << " not support input 2d";
return RET_NOT_SUPPORT;
}
@ -48,8 +47,8 @@ ge::Operator *CreateOperator(const std::string &name) {
return op;
}
int ArithmeticNPUOp::Init(const schema::Primitive *primitive, const std::vector<tensor::MSTensor *> &in_tensors,
const std::vector<tensor::MSTensor *> &out_tensors) {
int ArithmeticNPUOp::Init(const schema::Primitive *primitive, const std::vector<mindspore::MSTensor> &in_tensors,
const std::vector<mindspore::MSTensor> &out_tensors) {
switch (type_) {
case schema::PrimitiveType_MulFusion:
op_ = CreateOperator<hiai::op::Mul>(name_);
@ -143,8 +142,8 @@ void SetInputs(const std::vector<ge::Operator *> &npu_inputs, ge::Operator *op)
return;
}
int ArithmeticNPUOp::SetNPUInputs(const std::vector<tensor::MSTensor *> &in_tensors,
const std::vector<tensor::MSTensor *> &out_tensors,
int ArithmeticNPUOp::SetNPUInputs(const std::vector<mindspore::MSTensor> &in_tensors,
const std::vector<mindspore::MSTensor> &out_tensors,
const std::vector<ge::Operator *> &npu_inputs) {
switch (type_) {
case schema::PrimitiveType_MulFusion:
@ -203,7 +202,7 @@ int ArithmeticNPUOp::SetNPUInputs(const std::vector<tensor::MSTensor *> &in_tens
}
int ArithmeticNPUOp::SetNPUInputs(
const std::vector<tensor::MSTensor *> &in_tensors, const std::vector<tensor::MSTensor *> &out_tensors,
const std::vector<mindspore::MSTensor> &in_tensors, const std::vector<mindspore::MSTensor> &out_tensors,
const std::vector<ge::Operator *> &npu_inputs,
const std::unordered_map<int, std::pair<ge::Operator *, int>> &index2_multi_out_index) {
auto ret = SetNPUInputs(in_tensors, out_tensors, npu_inputs);

20
mindspore/lite/src/delegate/npu/op/arithmetic_npu.h
View File

@ -25,24 +25,24 @@
namespace mindspore {
class ArithmeticNPUOp : public NPUOp {
public:
ArithmeticNPUOp(const schema::Primitive *primitive, const std::vector<tensor::MSTensor *> &in_tensors,
const std::vector<tensor::MSTensor *> &out_tensors, std::string name)
ArithmeticNPUOp(const schema::Primitive *primitive, const std::vector<mindspore::MSTensor> &in_tensors,
const std::vector<mindspore::MSTensor> &out_tensors, std::string name)
: NPUOp(primitive, in_tensors, out_tensors, name) {}
~ArithmeticNPUOp() override;
int IsSupport(const schema::Primitive *primitive, const std::vector<tensor::MSTensor *> &in_tensors,
const std::vector<tensor::MSTensor *> &out_tensors) override;
int IsSupport(const schema::Primitive *primitive, const std::vector<mindspore::MSTensor> &in_tensors,
const std::vector<mindspore::MSTensor> &out_tensors) override;
int Init(const schema::Primitive *primitive, const std::vector<tensor::MSTensor *> &in_tensors,
const std::vector<tensor::MSTensor *> &out_tensors) override;
int Init(const schema::Primitive *primitive, const std::vector<mindspore::MSTensor> &in_tensors,
const std::vector<mindspore::MSTensor> &out_tensors) override;
int SetNPUInputs(const std::vector<tensor::MSTensor *> &in_tensors,
const std::vector<tensor::MSTensor *> &out_tensors,
int SetNPUInputs(const std::vector<mindspore::MSTensor> &in_tensors,
const std::vector<mindspore::MSTensor> &out_tensors,
const std::vector<ge::Operator *> &npu_inputs) override;
int SetNPUInputs(const std::vector<tensor::MSTensor *> &in_tensors,
const std::vector<tensor::MSTensor *> &out_tensors, const std::vector<ge::Operator *> &npu_inputs,
int SetNPUInputs(const std::vector<mindspore::MSTensor> &in_tensors,
const std::vector<mindspore::MSTensor> &out_tensors, const std::vector<ge::Operator *> &npu_inputs,
const std::unordered_map<int, std::pair<ge::Operator *, int>> &index2_multi_out_index) override;
ge::Operator *GetNPUOp() override;

9
mindspore/lite/src/delegate/npu/op/arithmetic_self_npu.cc
View File

@ -16,7 +16,6 @@
#include "src/delegate/npu/op/arithmetic_self_npu.h"
#include <string>
#include "include/graph/op/all_ops.h"
namespace mindspore {
template <typename T>
@ -29,8 +28,8 @@ ge::Operator *CreateOperator(const std::string &name) {
return op;
}
int ArithmeticSelfNPUOp::Init(const schema::Primitive *primitive, const std::vector<tensor::MSTensor *> &in_tensors,
const std::vector<tensor::MSTensor *> &out_tensors) {
int ArithmeticSelfNPUOp::Init(const schema::Primitive *primitive, const std::vector<mindspore::MSTensor> &in_tensors,
const std::vector<mindspore::MSTensor> &out_tensors) {
switch (type_) {
case schema::PrimitiveType_Cos:
op_ = CreateOperator<hiai::op::Cos>(name_);
@ -86,8 +85,8 @@ void SetInputs(const std::vector<ge::Operator *> &npu_inputs, ge::Operator *op)
return;
}
int ArithmeticSelfNPUOp::SetNPUInputs(const std::vector<tensor::MSTensor *> &in_tensors,
const std::vector<tensor::MSTensor *> &out_tensors,
int ArithmeticSelfNPUOp::SetNPUInputs(const std::vector<mindspore::MSTensor> &in_tensors,
const std::vector<mindspore::MSTensor> &out_tensors,
const std::vector<ge::Operator *> &npu_inputs) {
switch (type_) {
case schema::PrimitiveType_Cos:

16
mindspore/lite/src/delegate/npu/op/arithmetic_self_npu.h
View File

@ -24,22 +24,22 @@
namespace mindspore {
class ArithmeticSelfNPUOp : public NPUOp {
public:
ArithmeticSelfNPUOp(const schema::Primitive *primitive, const std::vector<tensor::MSTensor *> &in_tensors,
const std::vector<tensor::MSTensor *> &out_tensors, std::string name)
ArithmeticSelfNPUOp(const schema::Primitive *primitive, const std::vector<mindspore::MSTensor> &in_tensors,
const std::vector<mindspore::MSTensor> &out_tensors, std::string name)
: NPUOp(primitive, in_tensors, out_tensors, name) {}
~ArithmeticSelfNPUOp() override;
int IsSupport(const schema::Primitive *primitive, const std::vector<tensor::MSTensor *> &in_tensors,
const std::vector<tensor::MSTensor *> &out_tensors) override {
int IsSupport(const schema::Primitive *primitive, const std::vector<mindspore::MSTensor> &in_tensors,
const std::vector<mindspore::MSTensor> &out_tensors) override {
return RET_OK;
}
int Init(const schema::Primitive *primitive, const std::vector<tensor::MSTensor *> &in_tensors,
const std::vector<tensor::MSTensor *> &out_tensors) override;
int Init(const schema::Primitive *primitive, const std::vector<mindspore::MSTensor> &in_tensors,
const std::vector<mindspore::MSTensor> &out_tensors) override;
int SetNPUInputs(const std::vector<tensor::MSTensor *> &in_tensors,
const std::vector<tensor::MSTensor *> &out_tensors,
int SetNPUInputs(const std::vector<mindspore::MSTensor> &in_tensors,
const std::vector<mindspore::MSTensor> &out_tensors,
const std::vector<ge::Operator *> &npu_inputs) override;
ge::Operator *GetNPUOp() override;

12
mindspore/lite/src/delegate/npu/op/avg_pooling_npu.cc
View File

@ -16,8 +16,8 @@
#include "src/delegate/npu/op/avg_pooling_npu.h"
namespace mindspore {
int AvgPoolingNPUOp::IsSupport(const schema::Primitive *primitive, const std::vector<tensor::MSTensor *> &in_tensors,
const std::vector<tensor::MSTensor *> &out_tensors) {
int AvgPoolingNPUOp::IsSupport(const schema::Primitive *primitive, const std::vector<mindspore::MSTensor> &in_tensors,
const std::vector<mindspore::MSTensor> &out_tensors) {
auto pooling_prim = primitive->value_as_AvgPoolFusion();
if (pooling_prim == nullptr) {
MS_LOG(ERROR) << "Get null primitive value for op ." << name_;
@ -71,8 +71,8 @@ int AvgPoolingNPUOp::SetPoolingParam(const schema::AvgPoolFusion *pooling_prim)
return RET_OK;
}
int AvgPoolingNPUOp::Init(const schema::Primitive *primitive, const std::vector<tensor::MSTensor *> &in_tensors,
const std::vector<tensor::MSTensor *> &out_tensors) {
int AvgPoolingNPUOp::Init(const schema::Primitive *primitive, const std::vector<mindspore::MSTensor> &in_tensors,
const std::vector<mindspore::MSTensor> &out_tensors) {
pooling_ = new (std::nothrow) hiai::op::PoolingD(name_ + "_pooling");
if (pooling_ == nullptr) {
MS_LOG(ERROR) << "New pooling npu operator for op " << name_ << " failed.";
@ -99,8 +99,8 @@ int AvgPoolingNPUOp::Init(const schema::Primitive *primitive, const std::vector<
return RET_OK;
}
int AvgPoolingNPUOp::SetNPUInputs(const std::vector<tensor::MSTensor *> &in_tensors,
const std::vector<tensor::MSTensor *> &out_tensors,
int AvgPoolingNPUOp::SetNPUInputs(const std::vector<mindspore::MSTensor> &in_tensors,
const std::vector<mindspore::MSTensor> &out_tensors,
const std::vector<ge::Operator *> &npu_inputs) {
pooling_->set_input_x(*npu_inputs[0]);
return RET_OK;

16
mindspore/lite/src/delegate/npu/op/avg_pooling_npu.h
View File

@ -23,20 +23,20 @@
namespace mindspore {
class AvgPoolingNPUOp : public ConvolutionBaseNPUOp {
public:
AvgPoolingNPUOp(const schema::Primitive *primitive, const std::vector<tensor::MSTensor *> &in_tensors,
const std::vector<tensor::MSTensor *> &out_tensors, std::string name)
AvgPoolingNPUOp(const schema::Primitive *primitive, const std::vector<mindspore::MSTensor> &in_tensors,
const std::vector<mindspore::MSTensor> &out_tensors, std::string name)
: ConvolutionBaseNPUOp(primitive, in_tensors, out_tensors, name) {}
~AvgPoolingNPUOp() override;
int IsSupport(const schema::Primitive *primitive, const std::vector<tensor::MSTensor *> &in_tensors,
const std::vector<tensor::MSTensor *> &out_tensors) override;
int IsSupport(const schema::Primitive *primitive, const std::vector<mindspore::MSTensor> &in_tensors,
const std::vector<mindspore::MSTensor> &out_tensors) override;
int Init(const schema::Primitive *primitive, const std::vector<tensor::MSTensor *> &in_tensors,
const std::vector<tensor::MSTensor *> &out_tensors) override;
int Init(const schema::Primitive *primitive, const std::vector<mindspore::MSTensor> &in_tensors,
const std::vector<mindspore::MSTensor> &out_tensors) override;
int SetNPUInputs(const std::vector<tensor::MSTensor *> &in_tensors,
const std::vector<tensor::MSTensor *> &out_tensors,
int SetNPUInputs(const std::vector<mindspore::MSTensor> &in_tensors,
const std::vector<mindspore::MSTensor> &out_tensors,
const std::vector<ge::Operator *> &npu_inputs) override;
ge::Operator *GetNPUOp() override;

9
mindspore/lite/src/delegate/npu/op/batchnorm_npu.cc
View File

@ -15,11 +15,12 @@
*/
#include "src/delegate/npu/op/batchnorm_npu.h"
#include "include/graph/op/all_ops.h"
#include "src/delegate/npu/npu_converter_utils.h"
namespace mindspore {
int BatchnormNPUOp::Init(const schema::Primitive *primitive, const std::vector<tensor::MSTensor *> &in_tensors,
const std::vector<tensor::MSTensor *> &out_tensors) {
int BatchnormNPUOp::Init(const schema::Primitive *primitive, const std::vector<mindspore::MSTensor> &in_tensors,
const std::vector<mindspore::MSTensor> &out_tensors) {
batchnorm_ = new (std::nothrow) ge::op::BatchNormExt2(name_);
if (batchnorm_ == nullptr) {
MS_LOG(ERROR) << "New batchnorm npu operator for batchnorm op " << name_ << " failed.";
@ -36,8 +37,8 @@ int BatchnormNPUOp::Init(const schema::Primitive *primitive, const std::vector<t
return RET_OK;
}
int BatchnormNPUOp::SetNPUInputs(const std::vector<tensor::MSTensor *> &in_tensors,
const std::vector<tensor::MSTensor *> &out_tensors,
int BatchnormNPUOp::SetNPUInputs(const std::vector<mindspore::MSTensor> &in_tensors,
const std::vector<mindspore::MSTensor> &out_tensors,
const std::vector<ge::Operator *> &npu_inputs) {
batchnorm_->set_input_x(*npu_inputs[0]);
auto scale = new (std::nothrow) hiai::op::Const(name_ + "_scale");

17
mindspore/lite/src/delegate/npu/op/batchnorm_npu.h
View File

@ -18,29 +18,28 @@
#include <vector>
#include <string>
#include "include/graph/op/all_ops.h"
#include "include/graph/compatible/all_ops.h"
#include "src/delegate/npu/op/npu_op.h"
namespace mindspore {
class BatchnormNPUOp : public NPUOp {
public:
BatchnormNPUOp(const schema::Primitive *primitive, const std::vector<tensor::MSTensor *> &in_tensors,
const std::vector<tensor::MSTensor *> &out_tensors, std::string name)
BatchnormNPUOp(const schema::Primitive *primitive, const std::vector<mindspore::MSTensor> &in_tensors,
const std::vector<mindspore::MSTensor> &out_tensors, std::string name)
: NPUOp(primitive, in_tensors, out_tensors, name) {}
~BatchnormNPUOp() override;
int IsSupport(const schema::Primitive *primitive, const std::vector<tensor::MSTensor *> &in_tensors,
const std::vector<tensor::MSTensor *> &out_tensors) override {
int IsSupport(const schema::Primitive *primitive, const std::vector<mindspore::MSTensor> &in_tensors,
const std::vector<mindspore::MSTensor> &out_tensors) override {
return RET_OK;
}
int Init(const schema::Primitive *primitive, const std::vector<tensor::MSTensor *> &in_tensors,
const std::vector<tensor::MSTensor *> &out_tensors) override;
int Init(const schema::Primitive *primitive, const std::vector<mindspore::MSTensor> &in_tensors,
const std::vector<mindspore::MSTensor> &out_tensors) override;
int SetNPUInputs(const std::vector<tensor::MSTensor *> &in_tensors,
const std::vector<tensor::MSTensor *> &out_tensors,
int SetNPUInputs(const std::vector<mindspore::MSTensor> &in_tensors,
const std::vector<mindspore::MSTensor> &out_tensors,
const std::vector<ge::Operator *> &npu_inputs) override;
ge::Operator *GetNPUOp() override;

20
mindspore/lite/src/delegate/npu/op/cast_npu.cc
View File

@ -18,10 +18,10 @@
#include "src/delegate/npu/npu_converter_utils.h"
namespace mindspore {
int CastNPUOp::IsSupport(const schema::Primitive *primitive, const std::vector<tensor::MSTensor *> &in_tensors,
const std::vector<tensor::MSTensor *> &out_tensors) {
if (in_tensors.size() >= 2 && in_tensors[1]->ElementsNum() == 1) {
dst_type_ = static_cast<int *>(in_tensors[1]->data())[0];
int CastNPUOp::IsSupport(const schema::Primitive *primitive, const std::vector<mindspore::MSTensor> &in_tensors,
const std::vector<mindspore::MSTensor> &out_tensors) {
if (in_tensors.size() >= 2 && in_tensors[1].ElementNum() == 1) {
dst_type_ = reinterpret_cast<const int *>(in_tensors[1].Data().get())[0];
} else {
MS_LOG(WARNING) << "NPU dst dtype is attribute.";
return RET_NOT_SUPPORT;
@ -29,20 +29,20 @@ int CastNPUOp::IsSupport(const schema::Primitive *primitive, const std::vector<t
return RET_OK;
}
int CastNPUOp::Init(const schema::Primitive *primitive, const std::vector<tensor::MSTensor *> &in_tensors,
const std::vector<tensor::MSTensor *> &out_tensors) {
int CastNPUOp::Init(const schema::Primitive *primitive, const std::vector<mindspore::MSTensor> &in_tensors,
const std::vector<mindspore::MSTensor> &out_tensors) {
cast_ = new (std::nothrow) hiai::op::CastT(name_);
if (cast_ == nullptr) {
MS_LOG(ERROR) << name_ << " op is nullptr";
return RET_ERROR;
}
cast_->set_attr_dst_dtype(ConverterToNPUDataType(static_cast<TypeId>(dst_type_)));
cast_->set_attr_src_dtype(ConverterToNPUDataType(static_cast<TypeId>(in_tensors[0]->data_type())));
cast_->set_attr_dst_dtype(ConverterToNPUDataType(static_cast<DataType>(dst_type_)));
cast_->set_attr_src_dtype(ConverterToNPUDataType(static_cast<DataType>(in_tensors[0].DataType())));
return RET_OK;
}
int CastNPUOp::SetNPUInputs(const std::vector<tensor::MSTensor *> &in_tensors,
const std::vector<tensor::MSTensor *> &out_tensors,
int CastNPUOp::SetNPUInputs(const std::vector<mindspore::MSTensor> &in_tensors,
const std::vector<mindspore::MSTensor> &out_tensors,
const std::vector<ge::Operator *> &npu_inputs) {
cast_->set_input_x(*npu_inputs[0]);
return RET_OK;

16
mindspore/lite/src/delegate/npu/op/cast_npu.h
View File

@ -24,20 +24,20 @@
namespace mindspore {
class CastNPUOp : public NPUOp {
public:
CastNPUOp(const schema::Primitive *primitive, const std::vector<tensor::MSTensor *> &in_tensors,
const std::vector<tensor::MSTensor *> &out_tensors, std::string name)
CastNPUOp(const schema::Primitive *primitive, const std::vector<mindspore::MSTensor> &in_tensors,
const std::vector<mindspore::MSTensor> &out_tensors, std::string name)
: NPUOp(primitive, in_tensors, out_tensors, name) {}
~CastNPUOp() override;
int IsSupport(const schema::Primitive *primitive, const std::vector<tensor::MSTensor *> &in_tensors,
const std::vector<tensor::MSTensor *> &out_tensors) override;
int IsSupport(const schema::Primitive *primitive, const std::vector<mindspore::MSTensor> &in_tensors,
const std::vector<mindspore::MSTensor> &out_tensors) override;
int Init(const schema::Primitive *primitive, const std::vector<tensor::MSTensor *> &in_tensors,
const std::vector<tensor::MSTensor *> &out_tensors) override;
int Init(const schema::Primitive *primitive, const std::vector<mindspore::MSTensor> &in_tensors,
const std::vector<mindspore::MSTensor> &out_tensors) override;
int SetNPUInputs(const std::vector<tensor::MSTensor *> &in_tensors,
const std::vector<tensor::MSTensor *> &out_tensors,
int SetNPUInputs(const std::vector<mindspore::MSTensor> &in_tensors,
const std::vector<mindspore::MSTensor> &out_tensors,
const std::vector<ge::Operator *> &npu_inputs) override;
ge::Operator *GetNPUOp() override;

8
mindspore/lite/src/delegate/npu/op/concat_npu.cc
View File

@ -18,8 +18,8 @@
#include "src/delegate/npu/npu_converter_utils.h"
namespace mindspore {
int ConcatNPUOp::Init(const schema::Primitive *primitive, const std::vector<tensor::MSTensor *> &in_tensors,
const std::vector<tensor::MSTensor *> &out_tensors) {
int ConcatNPUOp::Init(const schema::Primitive *primitive, const std::vector<mindspore::MSTensor> &in_tensors,
const std::vector<mindspore::MSTensor> &out_tensors) {
concat_ = new (std::nothrow) hiai::op::ConcatD(name_);
if (concat_ == nullptr) {
MS_LOG(ERROR) << name_ << " op is nullptr";
@ -34,8 +34,8 @@ int ConcatNPUOp::Init(const schema::Primitive *primitive, const std::vector<tens
return RET_OK;
}
int ConcatNPUOp::SetNPUInputs(const std::vector<tensor::MSTensor *> &in_tensors,
const std::vector<tensor::MSTensor *> &out_tensors,
int ConcatNPUOp::SetNPUInputs(const std::vector<mindspore::MSTensor> &in_tensors,
const std::vector<mindspore::MSTensor> &out_tensors,
const std::vector<ge::Operator *> &npu_inputs) {
concat_->set_attr_concat_dim(axis_);
concat_->set_attr_N(npu_inputs.size());

16
mindspore/lite/src/delegate/npu/op/concat_npu.h
View File

@ -23,22 +23,22 @@
namespace mindspore {
class ConcatNPUOp : public NPUOp {
public:
ConcatNPUOp(const schema::Primitive *primitive, const std::vector<tensor::MSTensor *> &in_tensors,
const std::vector<tensor::MSTensor *> &out_tensors, std::string name)
ConcatNPUOp(const schema::Primitive *primitive, const std::vector<mindspore::MSTensor> &in_tensors,
const std::vector<mindspore::MSTensor> &out_tensors, std::string name)
: NPUOp(primitive, in_tensors, out_tensors, name) {}
~ConcatNPUOp() override;
int IsSupport(const schema::Primitive *primitive, const std::vector<tensor::MSTensor *> &in_tensors,
const std::vector<tensor::MSTensor *> &out_tensors) override {
int IsSupport(const schema::Primitive *primitive, const std::vector<mindspore::MSTensor> &in_tensors,
const std::vector<mindspore::MSTensor> &out_tensors) override {
return RET_OK;
}
int Init(const schema::Primitive *primitive, const std::vector<tensor::MSTensor *> &in_tensors,
const std::vector<tensor::MSTensor *> &out_tensors) override;
int Init(const schema::Primitive *primitive, const std::vector<mindspore::MSTensor> &in_tensors,
const std::vector<mindspore::MSTensor> &out_tensors) override;
int SetNPUInputs(const std::vector<tensor::MSTensor *> &in_tensors,
const std::vector<tensor::MSTensor *> &out_tensors,
int SetNPUInputs(const std::vector<mindspore::MSTensor> &in_tensors,
const std::vector<mindspore::MSTensor> &out_tensors,
const std::vector<ge::Operator *> &npu_inputs) override;
ge::Operator *GetNPUOp() override;

39
mindspore/lite/src/delegate/npu/op/convolution_base_npu.cc
View File

@ -17,7 +17,6 @@
#include "src/delegate/npu/op/convolution_base_npu.h"
#include "src/delegate/npu/npu_converter_utils.h"
#include "src/delegate/npu/transpose_kernel.h"
#include "nnacl/fp16/cast_fp16.h"
namespace mindspore {
ConvolutionBaseNPUOp::~ConvolutionBaseNPUOp() {
@ -35,27 +34,39 @@ ConvolutionBaseNPUOp::~ConvolutionBaseNPUOp() {
}
}
int ConvolutionBaseNPUOp::InitWeightConst(const std::vector<tensor::MSTensor *> &inputs) {
int ConvolutionBaseNPUOp::InitWeightConst(const std::vector<mindspore::MSTensor> &inputs) {
weight_ = new (std::nothrow) hiai::op::Const(name_ + "_w");
if (weight_ == nullptr) {
MS_LOG(ERROR) << "New weight const failed.";
return RET_ERROR;
}
auto w_shape = inputs[1]->shape();
auto origin_data = inputs[1]->data();
auto fp32_data = origin_data;
if (inputs[1]->data_type() == kNumberTypeFloat16) {
fp32_data = reinterpret_cast<float *>(malloc(inputs[1]->ElementsNum() * sizeof(float)));
auto w_shape = inputs[1].Shape();
auto origin_data = inputs[1].Data().get();
float *fp32_data = nullptr;
if (inputs[1].DataType() == DataType::kNumberTypeFloat16) {
#ifdef ENABLE_ARM64
fp32_data = reinterpret_cast<float *>(malloc(inputs[1].ElementNum() * sizeof(float)));
// fp16->fp32
Float16ToFloat32(reinterpret_cast<float16_t *>(origin_data), reinterpret_cast<float *>(fp32_data),
inputs[1]->ElementsNum());
Float16ToFloat32(reinterpret_cast<const float16_t *>(origin_data), reinterpret_cast<float *>(fp32_data),
inputs[1].ElementNum());
#else
MS_LOG(ERROR) << "This platform does not support fp16.";
return RET_ERROR;
#endif
}
auto nchw_data = reinterpret_cast<float *>(malloc(inputs[1]->ElementsNum() * sizeof(float)));
auto nchw_data = reinterpret_cast<float *>(malloc(inputs[1].ElementNum() * sizeof(float)));
if (nchw_data == nullptr) {
MS_LOG(ERROR) << "Malloc buffer failed.";
return RET_ERROR;
}
PackNHWCToNCHWFp32(fp32_data, nchw_data, w_shape[0], w_shape[1] * w_shape[2], w_shape[3]);
if (inputs[1].DataType() == DataType::kNumberTypeFloat16) {
PackNHWCToNCHWFp32(fp32_data, nchw_data, w_shape[0], w_shape[1] * w_shape[2], w_shape[3]);
} else if (inputs[1].DataType() == DataType::kNumberTypeFloat32) {
PackNHWCToNCHWFp32(origin_data, nchw_data, w_shape[0], w_shape[1] * w_shape[2], w_shape[3]);
} else {
MS_LOG(ERROR) << "Unsupported data type of weight tensor for npu convolution.";
return RET_ERROR;
}
std::shared_ptr<ge::Tensor> weight_tensor = std::shared_ptr<ge::Tensor>(new (std::nothrow) ge::Tensor());
if (weight_tensor == nullptr) {
@ -63,16 +74,16 @@ int ConvolutionBaseNPUOp::InitWeightConst(const std::vector<tensor::MSTensor *>
return RET_ERROR;
}
ge::TensorDesc tensor_desc(ConverterToNPUShape({w_shape[0], w_shape[3], w_shape[1], w_shape[2]}), ge::FORMAT_NCHW,
ConverterToNPUDataType(inputs[1]->data_type()));
ConverterToNPUDataType(inputs[1].DataType()));
weight_tensor->SetTensorDesc(tensor_desc);
weight_tensor->SetData(reinterpret_cast<const uint8_t *>(nchw_data), inputs[1]->ElementsNum() * sizeof(float));
weight_tensor->SetData(reinterpret_cast<const uint8_t *>(nchw_data), inputs[1].ElementNum() * sizeof(float));
weight_->set_attr_value(weight_tensor);
free(nchw_data);
return RET_OK;
}
int ConvolutionBaseNPUOp::InitBiasConst(const std::vector<tensor::MSTensor *> &inputs) {
int ConvolutionBaseNPUOp::InitBiasConst(const std::vector<mindspore::MSTensor> &inputs) {
if (inputs.size() >= 3) {
bias_ = new (std::nothrow) hiai::op::Const(name_ + "_b");
if (bias_ == nullptr) {

8
mindspore/lite/src/delegate/npu/op/convolution_base_npu.h
View File

@ -24,15 +24,15 @@
namespace mindspore {
class ConvolutionBaseNPUOp : public NPUOp {
public:
ConvolutionBaseNPUOp(const schema::Primitive *primitive, const std::vector<tensor::MSTensor *> &in_tensors,
const std::vector<tensor::MSTensor *> &out_tensors, std::string name)
ConvolutionBaseNPUOp(const schema::Primitive *primitive, const std::vector<mindspore::MSTensor> &in_tensors,
const std::vector<mindspore::MSTensor> &out_tensors, std::string name)
: NPUOp(primitive, in_tensors, out_tensors, name) {}
~ConvolutionBaseNPUOp() override;
protected:
int InitWeightConst(const std::vector<tensor::MSTensor *> &inputs);
int InitBiasConst(const std::vector<tensor::MSTensor *> &inputs);
int InitWeightConst(const std::vector<mindspore::MSTensor> &inputs);
int InitBiasConst(const std::vector<mindspore::MSTensor> &inputs);
int SetActivation(const ge::Operator *input, schema::ActivationType act_type);
hiai::op::Activation *act_ = nullptr;
hiai::op::Const *weight_ = nullptr;

8
mindspore/lite/src/delegate/npu/op/convolution_depthwise_npu.cc
View File

@ -42,8 +42,8 @@ int ConvolutionDepthwiseNPUOp::SetConvDwParam(const schema::Conv2DFusion *conv_p
}
int ConvolutionDepthwiseNPUOp::Init(const schema::Primitive *primitive,
const std::vector<tensor::MSTensor *> &in_tensors,
const std::vector<tensor::MSTensor *> &out_tensors) {
const std::vector<mindspore::MSTensor> &in_tensors,
const std::vector<mindspore::MSTensor> &out_tensors) {
conv_dw_ = new (std::nothrow) hiai::op::ConvolutionDepthwise(name_ + "_conv_depthwise");
if (conv_dw_ == nullptr) {
MS_LOG(ERROR) << "New convolution depthwise operator for op " << name_ << " failed.";
@ -70,8 +70,8 @@ int ConvolutionDepthwiseNPUOp::Init(const schema::Primitive *primitive,
return RET_OK;
}
int ConvolutionDepthwiseNPUOp::SetNPUInputs(const std::vector<tensor::MSTensor *> &in_tensors,
const std::vector<tensor::MSTensor *> &out_tensors,
int ConvolutionDepthwiseNPUOp::SetNPUInputs(const std::vector<mindspore::MSTensor> &in_tensors,
const std::vector<mindspore::MSTensor> &out_tensors,
const std::vector<ge::Operator *> &npu_inputs) {
auto ret = InitWeightConst(in_tensors);
if (ret != RET_OK) {

17
mindspore/lite/src/delegate/npu/op/convolution_depthwise_npu.h
View File

@ -18,28 +18,27 @@
#define MINDSPORE_LITE_SRC_RUNTIME_DELEGATE_NPU_OP_CONVOLUTION_DEPTHWISE_NPU_H_
#include <vector>
#include <string>
#include "include/graph/op/all_ops.h"
#include "include/graph/compatible/all_ops.h"
#include "src/delegate/npu/op/convolution_base_npu.h"
namespace mindspore {
class ConvolutionDepthwiseNPUOp : public ConvolutionBaseNPUOp {
public:
ConvolutionDepthwiseNPUOp(const schema::Primitive *primitive, const std::vector<tensor::MSTensor *> &in_tensors,
const std::vector<tensor::MSTensor *> &out_tensors, std::string name)
ConvolutionDepthwiseNPUOp(const schema::Primitive *primitive, const std::vector<mindspore::MSTensor> &in_tensors,
const std::vector<mindspore::MSTensor> &out_tensors, std::string name)
: ConvolutionBaseNPUOp(primitive, in_tensors, out_tensors, name) {}
~ConvolutionDepthwiseNPUOp() override;
int IsSupport(const schema::Primitive *primitive, const std::vector<tensor::MSTensor *> &in_tensors,
const std::vector<tensor::MSTensor *> &out_tensors) override {
int IsSupport(const schema::Primitive *primitive, const std::vector<mindspore::MSTensor> &in_tensors,
const std::vector<mindspore::MSTensor> &out_tensors) override {
return RET_OK;
}
int Init(const schema::Primitive *primitive, const std::vector<tensor::MSTensor *> &in_tensors,
const std::vector<tensor::MSTensor *> &out_tensors) override;
int Init(const schema::Primitive *primitive, const std::vector<mindspore::MSTensor> &in_tensors,
const std::vector<mindspore::MSTensor> &out_tensors) override;
int SetNPUInputs(const std::vector<tensor::MSTensor *> &in_tensors,
const std::vector<tensor::MSTensor *> &out_tensors,
int SetNPUInputs(const std::vector<mindspore::MSTensor> &in_tensors,
const std::vector<mindspore::MSTensor> &out_tensors,
const std::vector<ge::Operator *> &npu_inputs) override;
ge::Operator *GetNPUOp() override;

32
mindspore/lite/src/delegate/npu/op/convolution_npu.cc
View File

@ -17,8 +17,8 @@
#include "src/delegate/npu/op/convolution_npu.h"
#include "src/delegate/npu/op/convolution_depthwise_npu.h"
namespace mindspore {
int ConvolutionNPUOp::IsSupport(const schema::Primitive *primitive, const std::vector<tensor::MSTensor *> &in_tensors,
const std::vector<tensor::MSTensor *> &out_tensors) {
int ConvolutionNPUOp::IsSupport(const schema::Primitive *primitive, const std::vector<mindspore::MSTensor> &in_tensors,
const std::vector<mindspore::MSTensor> &out_tensors) {
auto conv_prim = primitive->value_as_Conv2DFusion();
if (conv_prim == nullptr) {
MS_LOG(ERROR) << "Get null primitive value for op ." << name_;
@ -26,7 +26,7 @@ int ConvolutionNPUOp::IsSupport(const schema::Primitive *primitive, const std::v
}
auto stride_h = static_cast<int>(*(conv_prim->stride()->begin()));
auto stride_w = static_cast<int>(*(conv_prim->stride()->begin() + 1));
auto in_shape = in_tensors[0]->shape(); // default format: nhwc, RunPass not called
auto in_shape = in_tensors[0].Shape(); // default format: nhwc, RunPass not called
if (stride_h > in_shape[1] || stride_w > in_shape[2]) {
MS_LOG(WARNING) << "Npu convolution does not support stride greater than input size.";
return RET_NOT_SUPPORT;
@ -61,8 +61,8 @@ int ConvolutionNPUOp::SetConvParam(const schema::Conv2DFusion *conv_prim) {
return RET_OK;
}
int ConvolutionNPUOp::Init(const schema::Primitive *primitive, const std::vector<tensor::MSTensor *> &in_tensors,
const std::vector<tensor::MSTensor *> &out_tensors) {
int ConvolutionNPUOp::Init(const schema::Primitive *primitive, const std::vector<mindspore::MSTensor> &in_tensors,
const std::vector<mindspore::MSTensor> &out_tensors) {
// set conv attr param
conv_ = new (std::nothrow) hiai::op::Convolution(name_ + "_conv");
if (conv_ == nullptr) {
@ -90,8 +90,8 @@ int ConvolutionNPUOp::Init(const schema::Primitive *primitive, const std::vector
return RET_OK;
}
int ConvolutionNPUOp::SetNPUInputs(const std::vector<tensor::MSTensor *> &in_tensors,
const std::vector<tensor::MSTensor *> &out_tensors,
int ConvolutionNPUOp::SetNPUInputs(const std::vector<mindspore::MSTensor> &in_tensors,
const std::vector<mindspore::MSTensor> &out_tensors,
const std::vector<ge::Operator *> &npu_inputs) {
auto ret = InitWeightConst(in_tensors);
if (ret != RET_OK) {
@ -125,30 +125,30 @@ ConvolutionNPUOp::~ConvolutionNPUOp() {
conv_ = nullptr;
}
}
NPUOp *GetNPUConvOp(const schema::Primitive *primitive, const std::vector<tensor::MSTensor *> &in_tensors,
const std::vector<tensor::MSTensor *> &out_tensors, std::string name) {
auto shape = out_tensors.front()->shape();
NPUOp *GetNPUConvOp(const schema::Primitive *primitive, const std::vector<mindspore::MSTensor> &in_tensors,
const std::vector<mindspore::MSTensor> &out_tensors, std::string name) {
auto shape = out_tensors.front().Shape();
if (std::find(shape.begin(), shape.end(), -1) != shape.end()) {
MS_LOG(ERROR) << "NPU does not support runtime inference shape.";
return nullptr;
}
if (in_tensors[0]->shape().size() > 4) {
if (in_tensors[0].Shape().size() > 4) {
MS_LOG(ERROR) << "Npu does not support input tensor dims greater than 4";
return nullptr;
}
if (in_tensors[0]->data_type() != kNumberTypeFloat32 && in_tensors[0]->data_type() != kNumberTypeFloat16) {
MS_LOG(ERROR) << "Npu does not support datatype " << in_tensors[0]->data_type();
if (in_tensors[0].DataType() != DataType::kNumberTypeFloat32 &&
in_tensors[0].DataType() != DataType::kNumberTypeFloat16) {
MS_LOG(ERROR) << "Npu does not support datatype " << static_cast<int>(in_tensors[0].DataType());
return nullptr;
}
NPUOp *op = nullptr;
auto conv_prim = primitive->value_as_Conv2DFusion();
auto group = static_cast<int>(conv_prim->group());
auto input_channel = in_tensors.front()->shape()[3];
auto output_channel = out_tensors.front()->shape()[3];
auto input_channel = in_tensors.front().Shape()[3];
auto output_channel = out_tensors.front().Shape()[3];
if (group == input_channel && group == output_channel) {
op = new (std::nothrow) ConvolutionDepthwiseNPUOp(primitive, in_tensors, out_tensors, name);
} else {

20
mindspore/lite/src/delegate/npu/op/convolution_npu.h
View File

@ -23,20 +23,20 @@
namespace mindspore {
class ConvolutionNPUOp : public ConvolutionBaseNPUOp {
public:
ConvolutionNPUOp(const schema::Primitive *primitive, const std::vector<tensor::MSTensor *> &in_tensors,
const std::vector<tensor::MSTensor *> &out_tensors, std::string name)
ConvolutionNPUOp(const schema::Primitive *primitive, const std::vector<mindspore::MSTensor> &in_tensors,
const std::vector<mindspore::MSTensor> &out_tensors, std::string name)
: ConvolutionBaseNPUOp(primitive, in_tensors, out_tensors, name) {}
~ConvolutionNPUOp() override;
int IsSupport(const schema::Primitive *primitive, const std::vector<tensor::MSTensor *> &in_tensors,
const std::vector<tensor::MSTensor *> &out_tensors) override;
int IsSupport(const schema::Primitive *primitive, const std::vector<mindspore::MSTensor> &in_tensors,
const std::vector<mindspore::MSTensor> &out_tensors) override;
int Init(const schema::Primitive *primitive, const std::vector<tensor::MSTensor *> &in_tensors,
const std::vector<tensor::MSTensor *> &out_tensors) override;
int Init(const schema::Primitive *primitive, const std::vector<mindspore::MSTensor> &in_tensors,
const std::vector<mindspore::MSTensor> &out_tensors) override;
int SetNPUInputs(const std::vector<tensor::MSTensor *> &in_tensors,
const std::vector<tensor::MSTensor *> &out_tensors,
int SetNPUInputs(const std::vector<mindspore::MSTensor> &in_tensors,
const std::vector<mindspore::MSTensor> &out_tensors,
const std::vector<ge::Operator *> &npu_inputs) override;
ge::Operator *GetNPUOp() override;
@ -47,7 +47,7 @@ class ConvolutionNPUOp : public ConvolutionBaseNPUOp {
hiai::op::Convolution *conv_ = nullptr;
};
NPUOp *GetNPUConvOp(const schema::Primitive *primitive, const std::vector<tensor::MSTensor *> &in_tensors,
const std::vector<tensor::MSTensor *> &out_tensors, std::string name);
NPUOp *GetNPUConvOp(const schema::Primitive *primitive, const std::vector<mindspore::MSTensor> &in_tensors,
const std::vector<mindspore::MSTensor> &out_tensors, std::string name);
} // namespace mindspore
#endif // MINDSPORE_LITE_SRC_RUNTIME_DELEGATE_NPU_OP_CONVOLUTION_NPU_H_

13
mindspore/lite/src/delegate/npu/op/crop_and_resize_npu.cc
View File

@ -16,8 +16,9 @@
#include "src/delegate/npu/op/crop_and_resize_npu.h"
namespace mindspore {
int CropAndResizeNPUOp::IsSupport(const schema::Primitive *primitive, const std::vector<tensor::MSTensor *> &in_tensors,
const std::vector<tensor::MSTensor *> &out_tensors) {
int CropAndResizeNPUOp::IsSupport(const schema::Primitive *primitive,
const std::vector<mindspore::MSTensor> &in_tensors,
const std::vector<mindspore::MSTensor> &out_tensors) {
if (in_tensors.size() < 4) {
MS_LOG(WARNING) << "NPU CropAndResize got nput inputs size < 4";
return RET_NOT_SUPPORT;
@ -37,8 +38,8 @@ int CropAndResizeNPUOp::IsSupport(const schema::Primitive *primitive, const std:
return RET_OK;
}
int CropAndResizeNPUOp::Init(const schema::Primitive *primitive, const std::vector<tensor::MSTensor *> &in_tensors,
const std::vector<tensor::MSTensor *> &out_tensors) {
int CropAndResizeNPUOp::Init(const schema::Primitive *primitive, const std::vector<mindspore::MSTensor> &in_tensors,
const std::vector<mindspore::MSTensor> &out_tensors) {
crop_and_resize_ = new (std::nothrow) hiai::op::CropAndResize(name_);
if (crop_and_resize_ == nullptr) {
MS_LOG(ERROR) << name_ << " op is nullptr";
@ -62,8 +63,8 @@ int CropAndResizeNPUOp::Init(const schema::Primitive *primitive, const std::vect
return RET_OK;
}
int CropAndResizeNPUOp::SetNPUInputs(const std::vector<tensor::MSTensor *> &in_tensors,
const std::vector<tensor::MSTensor *> &out_tensors,
int CropAndResizeNPUOp::SetNPUInputs(const std::vector<mindspore::MSTensor> &in_tensors,
const std::vector<mindspore::MSTensor> &out_tensors,
const std::vector<ge::Operator *> &npu_inputs) {
crop_and_resize_->set_input_x(*npu_inputs[0]);
crop_and_resize_->set_input_boxes(*npu_inputs[1]);

16
mindspore/lite/src/delegate/npu/op/crop_and_resize_npu.h
View File

@ -24,20 +24,20 @@
namespace mindspore {
class CropAndResizeNPUOp : public NPUOp {
public:
CropAndResizeNPUOp(const schema::Primitive *primitive, const std::vector<tensor::MSTensor *> &in_tensors,
const std::vector<tensor::MSTensor *> &out_tensors, std::string name)
CropAndResizeNPUOp(const schema::Primitive *primitive, const std::vector<mindspore::MSTensor> &in_tensors,
const std::vector<mindspore::MSTensor> &out_tensors, std::string name)
: NPUOp(primitive, in_tensors, out_tensors, name) {}
~CropAndResizeNPUOp() override;
int IsSupport(const schema::Primitive *primitive, const std::vector<tensor::MSTensor *> &in_tensors,
const std::vector<tensor::MSTensor *> &out_tensors) override;
int IsSupport(const schema::Primitive *primitive, const std::vector<mindspore::MSTensor> &in_tensors,
const std::vector<mindspore::MSTensor> &out_tensors) override;
int Init(const schema::Primitive *primitive, const std::vector<tensor::MSTensor *> &in_tensors,
const std::vector<tensor::MSTensor *> &out_tensors) override;
int Init(const schema::Primitive *primitive, const std::vector<mindspore::MSTensor> &in_tensors,
const std::vector<mindspore::MSTensor> &out_tensors) override;
int SetNPUInputs(const std::vector<tensor::MSTensor *> &in_tensors,
const std::vector<tensor::MSTensor *> &out_tensors,
int SetNPUInputs(const std::vector<mindspore::MSTensor> &in_tensors,
const std::vector<mindspore::MSTensor> &out_tensors,
const std::vector<ge::Operator *> &npu_inputs) override;
ge::Operator *GetNPUOp() override;

13
mindspore/lite/src/delegate/npu/op/deconvolution_npu.cc
View File

@ -18,8 +18,9 @@
#include "src/delegate/npu/npu_converter_utils.h"
namespace mindspore {
int DeconvolutionNPUOp::IsSupport(const schema::Primitive *primitive, const std::vector<tensor::MSTensor *> &in_tensors,
const std::vector<tensor::MSTensor *> &out_tensors) {
int DeconvolutionNPUOp::IsSupport(const schema::Primitive *primitive,
const std::vector<mindspore::MSTensor> &in_tensors,
const std::vector<mindspore::MSTensor> &out_tensors) {
auto deconv_prim = primitive->value_as_Conv2dTransposeFusion();
if (deconv_prim == nullptr) {
MS_LOG(ERROR) << "Get null primitive value for op ." << name_;
@ -59,8 +60,8 @@ int DeconvolutionNPUOp::SetDeconvParam(const schema::Conv2dTransposeFusion *conv
return RET_OK;
}
int DeconvolutionNPUOp::Init(const schema::Primitive *primitive, const std::vector<tensor::MSTensor *> &in_tensors,
const std::vector<tensor::MSTensor *> &out_tensors) {
int DeconvolutionNPUOp::Init(const schema::Primitive *primitive, const std::vector<mindspore::MSTensor> &in_tensors,
const std::vector<mindspore::MSTensor> &out_tensors) {
// set deconv attr param
deconv_ = new (std::nothrow) hiai::op::ConvTranspose(name_ + "_deconv");
if (deconv_ == nullptr) {
@ -89,8 +90,8 @@ int DeconvolutionNPUOp::Init(const schema::Primitive *primitive, const std::vect
return RET_OK;
}
int DeconvolutionNPUOp::SetNPUInputs(const std::vector<tensor::MSTensor *> &in_tensors,
const std::vector<tensor::MSTensor *> &out_tensors,
int DeconvolutionNPUOp::SetNPUInputs(const std::vector<mindspore::MSTensor> &in_tensors,
const std::vector<mindspore::MSTensor> &out_tensors,
const std::vector<ge::Operator *> &npu_inputs) {
auto ret = InitWeightConst(in_tensors);
if (ret != RET_OK) {

16
mindspore/lite/src/delegate/npu/op/deconvolution_npu.h
View File

@ -24,19 +24,19 @@
namespace mindspore {
class DeconvolutionNPUOp : public ConvolutionBaseNPUOp {
public:
DeconvolutionNPUOp(const schema::Primitive *primitive, const std::vector<tensor::MSTensor *> &in_tensors,
const std::vector<tensor::MSTensor *> &out_tensors, std::string name)
DeconvolutionNPUOp(const schema::Primitive *primitive, const std::vector<mindspore::MSTensor> &in_tensors,
const std::vector<mindspore::MSTensor> &out_tensors, std::string name)
: ConvolutionBaseNPUOp(primitive, in_tensors, out_tensors, name) {}
~DeconvolutionNPUOp() override;
int IsSupport(const schema::Primitive *primitive, const std::vector<tensor::MSTensor *> &in_tensors,
const std::vector<tensor::MSTensor *> &out_tensors) override;
int IsSupport(const schema::Primitive *primitive, const std::vector<mindspore::MSTensor> &in_tensors,
const std::vector<mindspore::MSTensor> &out_tensors) override;
int Init(const schema::Primitive *primitive, const std::vector<tensor::MSTensor *> &in_tensors,
const std::vector<tensor::MSTensor *> &out_tensors) override;
int Init(const schema::Primitive *primitive, const std::vector<mindspore::MSTensor> &in_tensors,
const std::vector<mindspore::MSTensor> &out_tensors) override;
int SetNPUInputs(const std::vector<tensor::MSTensor *> &in_tensors,
const std::vector<tensor::MSTensor *> &out_tensors,
int SetNPUInputs(const std::vector<mindspore::MSTensor> &in_tensors,
const std::vector<mindspore::MSTensor> &out_tensors,
const std::vector<ge::Operator *> &npu_inputs) override;
ge::Operator *GetNPUOp() override;

8
mindspore/lite/src/delegate/npu/op/eltwise_npu.cc
View File

@ -20,8 +20,8 @@
#include "src/delegate/npu/npu_converter_utils.h"
namespace mindspore {
int EltwiseNPUOp::Init(const schema::Primitive *primitive, const std::vector<tensor::MSTensor *> &in_tensors,
const std::vector<tensor::MSTensor *> &out_tensors) {
int EltwiseNPUOp::Init(const schema::Primitive *primitive, const std::vector<mindspore::MSTensor> &in_tensors,
const std::vector<mindspore::MSTensor> &out_tensors) {
eltwise_ = new (std::nothrow) hiai::op::Eltwise(name_);
if (eltwise_ == nullptr) {
MS_LOG(ERROR) << name_ << " op is nullptr";
@ -39,8 +39,8 @@ int EltwiseNPUOp::Init(const schema::Primitive *primitive, const std::vector<ten
return RET_OK;
}
int EltwiseNPUOp::SetNPUInputs(const std::vector<tensor::MSTensor *> &in_tensors,
const std::vector<tensor::MSTensor *> &out_tensors,
int EltwiseNPUOp::SetNPUInputs(const std::vector<mindspore::MSTensor> &in_tensors,
const std::vector<mindspore::MSTensor> &out_tensors,
const std::vector<ge::Operator *> &npu_inputs) {
for (int i = 0; i < npu_inputs.size(); ++i) {
eltwise_->set_dynamic_input_x(i + 1, *npu_inputs[i]);

16
mindspore/lite/src/delegate/npu/op/eltwise_npu.h
View File

@ -24,22 +24,22 @@
namespace mindspore {
class EltwiseNPUOp : public NPUOp {
public:
EltwiseNPUOp(const schema::Primitive *primitive, const std::vector<tensor::MSTensor *> &in_tensors,
const std::vector<tensor::MSTensor *> &out_tensors, std::string name)
EltwiseNPUOp(const schema::Primitive *primitive, const std::vector<mindspore::MSTensor> &in_tensors,
const std::vector<mindspore::MSTensor> &out_tensors, std::string name)
: NPUOp(primitive, in_tensors, out_tensors, name) {}
~EltwiseNPUOp() override;
int IsSupport(const schema::Primitive *primitive, const std::vector<tensor::MSTensor *> &in_tensors,
const std::vector<tensor::MSTensor *> &out_tensors) override {
int IsSupport(const schema::Primitive *primitive, const std::vector<mindspore::MSTensor> &in_tensors,
const std::vector<mindspore::MSTensor> &out_tensors) override {
return RET_OK;
}
int Init(const schema::Primitive *primitive, const std::vector<tensor::MSTensor *> &in_tensors,
const std::vector<tensor::MSTensor *> &out_tensors) override;
int Init(const schema::Primitive *primitive, const std::vector<mindspore::MSTensor> &in_tensors,
const std::vector<mindspore::MSTensor> &out_tensors) override;
int SetNPUInputs(const std::vector<tensor::MSTensor *> &in_tensors,
const std::vector<tensor::MSTensor *> &out_tensors,
int SetNPUInputs(const std::vector<mindspore::MSTensor> &in_tensors,
const std::vector<mindspore::MSTensor> &out_tensors,
const std::vector<ge::Operator *> &npu_inputs) override;
ge::Operator *GetNPUOp() override;

8
mindspore/lite/src/delegate/npu/op/expand_dims_npu.cc
View File

@ -19,8 +19,8 @@
#include "src/delegate/npu/npu_converter_utils.h"
namespace mindspore {
int ExpandDimsNPUOp::Init(const schema::Primitive *primitive, const std::vector<tensor::MSTensor *> &in_tensors,
const std::vector<tensor::MSTensor *> &out_tensors) {
int ExpandDimsNPUOp::Init(const schema::Primitive *primitive, const std::vector<mindspore::MSTensor> &in_tensors,
const std::vector<mindspore::MSTensor> &out_tensors) {
expand_dims_ = new (std::nothrow) hiai::op::ExpandDims(name_);
if (expand_dims_ == nullptr) {
MS_LOG(ERROR) << name_ << " op is nullptr";
@ -29,8 +29,8 @@ int ExpandDimsNPUOp::Init(const schema::Primitive *primitive, const std::vector<
return RET_OK;
}
int ExpandDimsNPUOp::SetNPUInputs(const std::vector<tensor::MSTensor *> &in_tensors,
const std::vector<tensor::MSTensor *> &out_tensors,
int ExpandDimsNPUOp::SetNPUInputs(const std::vector<mindspore::MSTensor> &in_tensors,
const std::vector<mindspore::MSTensor> &out_tensors,
const std::vector<ge::Operator *> &npu_inputs) {
expand_dims_->set_input_x(*npu_inputs[0]);
expand_dims_->set_input_axis(*npu_inputs[1]);

16
mindspore/lite/src/delegate/npu/op/expand_dims_npu.h
View File

@ -24,21 +24,21 @@
namespace mindspore {
class ExpandDimsNPUOp : public NPUOp {
public:
ExpandDimsNPUOp(const schema::Primitive *primitive, const std::vector<tensor::MSTensor *> &in_tensors,
const std::vector<tensor::MSTensor *> &out_tensors, std::string name)
ExpandDimsNPUOp(const schema::Primitive *primitive, const std::vector<mindspore::MSTensor> &in_tensors,
const std::vector<mindspore::MSTensor> &out_tensors, std::string name)
: NPUOp(primitive, in_tensors, out_tensors, name) {}
~ExpandDimsNPUOp() override;
int IsSupport(const schema::Primitive *primitive, const std::vector<tensor::MSTensor *> &in_tensors,
const std::vector<tensor::MSTensor *> &out_tensors) override {
int IsSupport(const schema::Primitive *primitive, const std::vector<mindspore::MSTensor> &in_tensors,
const std::vector<mindspore::MSTensor> &out_tensors) override {
return RET_OK;
}
int Init(const schema::Primitive *primitive, const std::vector<tensor::MSTensor *> &in_tensors,
const std::vector<tensor::MSTensor *> &out_tensors) override;
int Init(const schema::Primitive *primitive, const std::vector<mindspore::MSTensor> &in_tensors,
const std::vector<mindspore::MSTensor> &out_tensors) override;
int SetNPUInputs(const std::vector<tensor::MSTensor *> &in_tensors,
const std::vector<tensor::MSTensor *> &out_tensors,
int SetNPUInputs(const std::vector<mindspore::MSTensor> &in_tensors,
const std::vector<mindspore::MSTensor> &out_tensors,
const std::vector<ge::Operator *> &npu_inputs) override;
ge::Operator *GetNPUOp() override;

12
mindspore/lite/src/delegate/npu/op/fullconnection_npu.cc
View File

@ -19,15 +19,15 @@
#include "src/delegate/npu/npu_converter_utils.h"
namespace mindspore {
int FullconnectionNPUOp::Init(const schema::Primitive *primitive, const std::vector<tensor::MSTensor *> &in_tensors,
const std::vector<tensor::MSTensor *> &out_tensors) {
int FullconnectionNPUOp::Init(const schema::Primitive *primitive, const std::vector<mindspore::MSTensor> &in_tensors,
const std::vector<mindspore::MSTensor> &out_tensors) {
auto fc_prim = primitive->value_as_FullConnection();
if (fc_prim == nullptr) {
MS_LOG(ERROR) << "Get null primitive value for op ." << name_;
return RET_ERROR;
}
act_type_ = fc_prim->activation_type();
auto input_shape = in_tensors[0]->shape();
auto input_shape = in_tensors[0].Shape();
reshape_ = new (std::nothrow) hiai::op::Reshape(name_ + "_reshape");
if (reshape_ == nullptr) {
MS_LOG(ERROR) << "New reshape operator for fullconnection op " << name_ << " failed.";
@ -39,7 +39,7 @@ int FullconnectionNPUOp::Init(const schema::Primitive *primitive, const std::vec
col *= input_shape[i];
}
reshape_op_ = new (std::nothrow) hiai::op::Const(name_ + "_reshape_data");
vector<int> reshape_data = {input_shape[0], col};
vector<int> reshape_data = {static_cast<int>(input_shape[0]), col};
ge::TensorDesc reshape_tensor_desc(ge::Shape({2}), ge::FORMAT_NCHW, ge::DT_FLOAT);
ge::TensorPtr reshape_tensor = std::make_shared<hiai::Tensor>(reshape_tensor_desc);
reshape_tensor->SetData(reinterpret_cast<uint8_t *>(reshape_data.data()), 2 * sizeof(float));
@ -54,8 +54,8 @@ int FullconnectionNPUOp::Init(const schema::Primitive *primitive, const std::vec
return RET_OK;
}
int FullconnectionNPUOp::SetNPUInputs(const std::vector<tensor::MSTensor *> &in_tensors,
const std::vector<tensor::MSTensor *> &out_tensors,
int FullconnectionNPUOp::SetNPUInputs(const std::vector<mindspore::MSTensor> &in_tensors,
const std::vector<mindspore::MSTensor> &out_tensors,
const std::vector<ge::Operator *> &npu_inputs) {
reshape_->set_input_x(*npu_inputs[0]);
fc_->set_input_x1(*reshape_);

16
mindspore/lite/src/delegate/npu/op/fullconnection_npu.h
View File

@ -24,22 +24,22 @@
namespace mindspore {
class FullconnectionNPUOp : public ConvolutionBaseNPUOp {
public:
FullconnectionNPUOp(const schema::Primitive *primitive, const std::vector<tensor::MSTensor *> &in_tensors,
const std::vector<tensor::MSTensor *> &out_tensors, std::string name)
FullconnectionNPUOp(const schema::Primitive *primitive, const std::vector<mindspore::MSTensor> &in_tensors,
const std::vector<mindspore::MSTensor> &out_tensors, std::string name)
: ConvolutionBaseNPUOp(primitive, in_tensors, out_tensors, name) {}
~FullconnectionNPUOp() override;
int IsSupport(const schema::Primitive *primitive, const std::vector<tensor::MSTensor *> &in_tensors,
const std::vector<tensor::MSTensor *> &out_tensors) override {
int IsSupport(const schema::Primitive *primitive, const std::vector<mindspore::MSTensor> &in_tensors,
const std::vector<mindspore::MSTensor> &out_tensors) override {
return RET_OK;
}
int Init(const schema::Primitive *primitive, const std::vector<tensor::MSTensor *> &in_tensors,
const std::vector<tensor::MSTensor *> &out_tensors) override;
int Init(const schema::Primitive *primitive, const std::vector<mindspore::MSTensor> &in_tensors,
const std::vector<mindspore::MSTensor> &out_tensors) override;
int SetNPUInputs(const std::vector<tensor::MSTensor *> &in_tensors,
const std::vector<tensor::MSTensor *> &out_tensors,
int SetNPUInputs(const std::vector<mindspore::MSTensor> &in_tensors,
const std::vector<mindspore::MSTensor> &out_tensors,
const std::vector<ge::Operator *> &npu_inputs) override;
ge::Operator *GetNPUOp() override;

18
mindspore/lite/src/delegate/npu/op/gather_npu.cc
View File

@ -17,14 +17,14 @@
#include "src/delegate/npu/op/gather_npu.h"
namespace mindspore {
int GatherNPUOp::IsSupport(const schema::Primitive *primitive, const std::vector<tensor::MSTensor *> &in_tensors,
const std::vector<tensor::MSTensor *> &out_tensors) {
if (in_tensors[1]->data_type() != kNumberTypeInt32) {
int GatherNPUOp::IsSupport(const schema::Primitive *primitive, const std::vector<mindspore::MSTensor> &in_tensors,
const std::vector<mindspore::MSTensor> &out_tensors) {
if (in_tensors[1].DataType() != DataType::kNumberTypeInt32) {
MS_LOG(WARNING) << "Gather indices only support Int32";
return RET_NOT_SUPPORT;
}
if (in_tensors.size() >= 3 && in_tensors[2]->ElementsNum() == 1) {
axis_ = static_cast<int *>(in_tensors[2]->data())[0];
if (in_tensors.size() >= 3 && in_tensors[2].ElementNum() == 1) {
axis_ = static_cast<const int *>(in_tensors[2].Data().get())[0];
} else {
MS_LOG(WARNING) << "NPU axis is attribute.";
return RET_NOT_SUPPORT;
@ -32,8 +32,8 @@ int GatherNPUOp::IsSupport(const schema::Primitive *primitive, const std::vector
return RET_OK;
}
int GatherNPUOp::Init(const schema::Primitive *primitive, const std::vector<tensor::MSTensor *> &in_tensors,
const std::vector<tensor::MSTensor *> &out_tensors) {
int GatherNPUOp::Init(const schema::Primitive *primitive, const std::vector<mindspore::MSTensor> &in_tensors,
const std::vector<mindspore::MSTensor> &out_tensors) {
gather_ = new (std::nothrow) hiai::op::GatherV2D(name_);
if (gather_ == nullptr) {
MS_LOG(ERROR) << name_ << " op is nullptr";
@ -43,8 +43,8 @@ int GatherNPUOp::Init(const schema::Primitive *primitive, const std::vector<tens
return RET_OK;
}
int GatherNPUOp::SetNPUInputs(const std::vector<tensor::MSTensor *> &in_tensors,
const std::vector<tensor::MSTensor *> &out_tensors,
int GatherNPUOp::SetNPUInputs(const std::vector<mindspore::MSTensor> &in_tensors,
const std::vector<mindspore::MSTensor> &out_tensors,
const std::vector<ge::Operator *> &npu_inputs) {
gather_->set_input_x(*npu_inputs[0]);
gather_->set_input_indices(*npu_inputs[1]);

16
mindspore/lite/src/delegate/npu/op/gather_npu.h
View File

@ -24,20 +24,20 @@
namespace mindspore {
class GatherNPUOp : public NPUOp {
public:
GatherNPUOp(const schema::Primitive *primitive, const std::vector<tensor::MSTensor *> &in_tensors,
const std::vector<tensor::MSTensor *> &out_tensors, std::string name)
GatherNPUOp(const schema::Primitive *primitive, const std::vector<mindspore::MSTensor> &in_tensors,
const std::vector<mindspore::MSTensor> &out_tensors, std::string name)
: NPUOp(primitive, in_tensors, out_tensors, name) {}
~GatherNPUOp() override;
int IsSupport(const schema::Primitive *primitive, const std::vector<tensor::MSTensor *> &in_tensors,
const std::vector<tensor::MSTensor *> &out_tensors) override;
int IsSupport(const schema::Primitive *primitive, const std::vector<mindspore::MSTensor> &in_tensors,
const std::vector<mindspore::MSTensor> &out_tensors) override;
int Init(const schema::Primitive *primitive, const std::vector<tensor::MSTensor *> &in_tensors,
const std::vector<tensor::MSTensor *> &out_tensors) override;
int Init(const schema::Primitive *primitive, const std::vector<mindspore::MSTensor> &in_tensors,
const std::vector<mindspore::MSTensor> &out_tensors) override;
int SetNPUInputs(const std::vector<tensor::MSTensor *> &in_tensors,
const std::vector<tensor::MSTensor *> &out_tensors,
int SetNPUInputs(const std::vector<mindspore::MSTensor> &in_tensors,
const std::vector<mindspore::MSTensor> &out_tensors,
const std::vector<ge::Operator *> &npu_inputs) override;
ge::Operator *GetNPUOp() override;

13
mindspore/lite/src/delegate/npu/op/instance_norm_npu.cc
View File

@ -15,12 +15,11 @@
*/
#include "src/delegate/npu/op/instance_norm_npu.h"
#include <memory>
#include "src/delegate/npu/npu_converter_utils.h"
namespace mindspore {
int InstanceNormNPUOp::Init(const schema::Primitive *primitive, const std::vector<tensor::MSTensor *> &in_tensors,
const std::vector<tensor::MSTensor *> &out_tensors) {
int InstanceNormNPUOp::Init(const schema::Primitive *primitive, const std::vector<mindspore::MSTensor> &in_tensors,
const std::vector<mindspore::MSTensor> &out_tensors) {
instance_norm_ = new (std::nothrow) hiai::op::InstanceNorm(name_);
if (instance_norm_ == nullptr) {
MS_LOG(ERROR) << "New instance norm npu operator for op " << name_ << " failed.";
@ -35,12 +34,12 @@ int InstanceNormNPUOp::Init(const schema::Primitive *primitive, const std::vecto
return RET_OK;
}
int InstanceNormNPUOp::SetNPUInputs(const std::vector<tensor::MSTensor *> &in_tensors,
const std::vector<tensor::MSTensor *> &out_tensors,
int InstanceNormNPUOp::SetNPUInputs(const std::vector<mindspore::MSTensor> &in_tensors,
const std::vector<mindspore::MSTensor> &out_tensors,
const std::vector<ge::Operator *> &npu_inputs) {
instance_norm_->set_input_x(*npu_inputs[0]);
auto gamma_shape = in_tensors[1]->shape();
auto gamma_shape = in_tensors[1].Shape();
auto gamma_tensor = ConverterToNPUTensor(in_tensors[1]);
if (gamma_tensor == nullptr) {
MS_LOG(ERROR) << "Get gamma_tensor failed.";
@ -56,7 +55,7 @@ int InstanceNormNPUOp::SetNPUInputs(const std::vector<tensor::MSTensor *> &in_te
gamma_->set_attr_value(gamma_tensor);
instance_norm_->set_input_gamma(*gamma_);
auto beta_shape = in_tensors[2]->shape();
auto beta_shape = in_tensors[2].Shape();
auto beta_tensor = ConverterToNPUTensor(in_tensors[2]);
if (beta_tensor == nullptr) {
MS_LOG(ERROR) << "Get beta_tensor failed.";

16
mindspore/lite/src/delegate/npu/op/instance_norm_npu.h
View File

@ -24,22 +24,22 @@
namespace mindspore {
class InstanceNormNPUOp : public NPUOp {
public:
InstanceNormNPUOp(const schema::Primitive *primitive, const std::vector<tensor::MSTensor *> &in_tensors,
const std::vector<tensor::MSTensor *> &out_tensors, std::string name)
InstanceNormNPUOp(const schema::Primitive *primitive, const std::vector<mindspore::MSTensor> &in_tensors,
const std::vector<mindspore::MSTensor> &out_tensors, std::string name)
: NPUOp(primitive, in_tensors, out_tensors, name) {}
~InstanceNormNPUOp() override;
int IsSupport(const schema::Primitive *primitive, const std::vector<tensor::MSTensor *> &in_tensors,
const std::vector<tensor::MSTensor *> &out_tensors) override {
int IsSupport(const schema::Primitive *primitive, const std::vector<mindspore::MSTensor> &in_tensors,
const std::vector<mindspore::MSTensor> &out_tensors) override {
return RET_OK;
}
int Init(const schema::Primitive *primitive, const std::vector<tensor::MSTensor *> &in_tensors,
const std::vector<tensor::MSTensor *> &out_tensors) override;
int Init(const schema::Primitive *primitive, const std::vector<mindspore::MSTensor> &in_tensors,
const std::vector<mindspore::MSTensor> &out_tensors) override;
int SetNPUInputs(const std::vector<tensor::MSTensor *> &in_tensors,
const std::vector<tensor::MSTensor *> &out_tensors,
int SetNPUInputs(const std::vector<mindspore::MSTensor> &in_tensors,
const std::vector<mindspore::MSTensor> &out_tensors,
const std::vector<ge::Operator *> &npu_inputs) override;
ge::Operator *GetNPUOp() override;

19
mindspore/lite/src/delegate/npu/op/matmul_npu.cc
View File

@ -15,21 +15,20 @@
*/
#include "src/delegate/npu/op/matmul_npu.h"
#include <memory>
#include "src/delegate/npu/npu_converter_utils.h"
namespace mindspore {
int MatMulNPUOp::IsSupport(const schema::Primitive *primitive, const std::vector<tensor::MSTensor *> &in_tensors,
const std::vector<tensor::MSTensor *> &out_tensors) {
int MatMulNPUOp::IsSupport(const schema::Primitive *primitive, const std::vector<mindspore::MSTensor> &in_tensors,
const std::vector<mindspore::MSTensor> &out_tensors) {
if (in_tensors.size() == 3) {
if (in_tensors[2]->shape().size() != 1) {
if (in_tensors[2].Shape().size() != 1) {
return RET_NOT_SUPPORT;
}
}
return RET_OK;
}
int MatMulNPUOp::Init(const schema::Primitive *primitive, const std::vector<tensor::MSTensor *> &in_tensors,
const std::vector<tensor::MSTensor *> &out_tensors) {
int MatMulNPUOp::Init(const schema::Primitive *primitive, const std::vector<mindspore::MSTensor> &in_tensors,
const std::vector<mindspore::MSTensor> &out_tensors) {
matmul_ = new (std::nothrow) hiai::op::MatMul(name_);
if (matmul_ == nullptr) {
MS_LOG(ERROR) << "New matmul npu operator for op " << name_ << " failed.";
@ -48,8 +47,8 @@ int MatMulNPUOp::Init(const schema::Primitive *primitive, const std::vector<tens
return RET_OK;
}
int MatMulNPUOp::SetNPUInputs(const std::vector<tensor::MSTensor *> &in_tensors,
const std::vector<tensor::MSTensor *> &out_tensors,
int MatMulNPUOp::SetNPUInputs(const std::vector<mindspore::MSTensor> &in_tensors,
const std::vector<mindspore::MSTensor> &out_tensors,
const std::vector<ge::Operator *> &npu_inputs) {
matmul_->set_input_x1(*npu_inputs[0]);
matmul_->set_input_x2(*npu_inputs[1]);
@ -60,7 +59,7 @@ int MatMulNPUOp::SetNPUInputs(const std::vector<tensor::MSTensor *> &in_tensors,
return RET_ERROR;
}
add_op_->set_input_x1(*matmul_);
auto bias_shape = in_tensors[2]->shape();
auto bias_shape = in_tensors[2].Shape();
auto bias_tensor = ConverterToNPUTensor(in_tensors[2]);
if (bias_tensor == nullptr) {
MS_LOG(ERROR) << "Get bias_tensor failed.";
@ -68,7 +67,7 @@ int MatMulNPUOp::SetNPUInputs(const std::vector<tensor::MSTensor *> &in_tensors,
}
ge::TensorDesc bias_tensor_desc(ConverterToNPUShape({1, bias_shape[0], 1, 1}));
if (out_tensors[0]->shape().size() == 2) {
if (out_tensors[0].Shape().size() == 2) {
bias_tensor_desc.SetShape(ConverterToNPUShape({1, bias_shape[0]}));
}
bias_tensor->SetTensorDesc(bias_tensor_desc);

16
mindspore/lite/src/delegate/npu/op/matmul_npu.h
View File

@ -24,20 +24,20 @@
namespace mindspore {
class MatMulNPUOp : public NPUOp {
public:
MatMulNPUOp(const schema::Primitive *primitive, const std::vector<tensor::MSTensor *> &in_tensors,
const std::vector<tensor::MSTensor *> &out_tensors, std::string name)
MatMulNPUOp(const schema::Primitive *primitive, const std::vector<mindspore::MSTensor> &in_tensors,
const std::vector<mindspore::MSTensor> &out_tensors, std::string name)
: NPUOp(primitive, in_tensors, out_tensors, name) {}
~MatMulNPUOp() override;
int IsSupport(const schema::Primitive *primitive, const std::vector<tensor::MSTensor *> &in_tensors,
const std::vector<tensor::MSTensor *> &out_tensors) override;
int IsSupport(const schema::Primitive *primitive, const std::vector<mindspore::MSTensor> &in_tensors,
const std::vector<mindspore::MSTensor> &out_tensors) override;
int Init(const schema::Primitive *primitive, const std::vector<tensor::MSTensor *> &in_tensors,
const std::vector<tensor::MSTensor *> &out_tensors) override;
int Init(const schema::Primitive *primitive, const std::vector<mindspore::MSTensor> &in_tensors,
const std::vector<mindspore::MSTensor> &out_tensors) override;
int SetNPUInputs(const std::vector<tensor::MSTensor *> &in_tensors,
const std::vector<tensor::MSTensor *> &out_tensors,
int SetNPUInputs(const std::vector<mindspore::MSTensor> &in_tensors,
const std::vector<mindspore::MSTensor> &out_tensors,
const std::vector<ge::Operator *> &npu_inputs) override;
ge::Operator *GetNPUOp() override;

12
mindspore/lite/src/delegate/npu/op/max_pooling_npu.cc
View File

@ -16,8 +16,8 @@
#include "src/delegate/npu/op/max_pooling_npu.h"
namespace mindspore {
int MaxPoolingNPUOp::IsSupport(const schema::Primitive *primitive, const std::vector<tensor::MSTensor *> &in_tensors,
const std::vector<tensor::MSTensor *> &out_tensors) {
int MaxPoolingNPUOp::IsSupport(const schema::Primitive *primitive, const std::vector<mindspore::MSTensor> &in_tensors,
const std::vector<mindspore::MSTensor> &out_tensors) {
auto pooling_prim = primitive->value_as_MaxPoolFusion();
if (pooling_prim == nullptr) {
MS_LOG(ERROR) << "Get null primitive value for op ." << name_;
@ -71,8 +71,8 @@ int MaxPoolingNPUOp::SetPoolingParam(const schema::MaxPoolFusion *pooling_prim)
return RET_OK;
}
int MaxPoolingNPUOp::Init(const schema::Primitive *primitive, const std::vector<tensor::MSTensor *> &in_tensors,
const std::vector<tensor::MSTensor *> &out_tensors) {
int MaxPoolingNPUOp::Init(const schema::Primitive *primitive, const std::vector<mindspore::MSTensor> &in_tensors,
const std::vector<mindspore::MSTensor> &out_tensors) {
pooling_ = new (std::nothrow) hiai::op::PoolingD(name_ + "_pooling");
if (pooling_ == nullptr) {
MS_LOG(ERROR) << "New pooling npu operator for op " << name_ << " failed.";
@ -99,8 +99,8 @@ int MaxPoolingNPUOp::Init(const schema::Primitive *primitive, const std::vector<
return RET_OK;
}
int MaxPoolingNPUOp::SetNPUInputs(const std::vector<tensor::MSTensor *> &in_tensors,
const std::vector<tensor::MSTensor *> &out_tensors,
int MaxPoolingNPUOp::SetNPUInputs(const std::vector<mindspore::MSTensor> &in_tensors,
const std::vector<mindspore::MSTensor> &out_tensors,
const std::vector<ge::Operator *> &npu_inputs) {
pooling_->set_input_x(*npu_inputs[0]);
return RET_OK;

17
mindspore/lite/src/delegate/npu/op/max_pooling_npu.h
View File

@ -18,25 +18,24 @@
#define MINDSPORE_LITE_SRC_RUNTIME_DELEGATE_NPU_OP_MAX_POOLING_NPU_H_
#include <vector>
#include <string>
#include "include/graph/op/all_ops.h"
#include "src/delegate/npu/op/convolution_base_npu.h"
namespace mindspore {
class MaxPoolingNPUOp : public ConvolutionBaseNPUOp {
public:
MaxPoolingNPUOp(const schema::Primitive *primitive, const std::vector<tensor::MSTensor *> &in_tensors,
const std::vector<tensor::MSTensor *> &out_tensors, std::string name)
MaxPoolingNPUOp(const schema::Primitive *primitive, const std::vector<mindspore::MSTensor> &in_tensors,
const std::vector<mindspore::MSTensor> &out_tensors, std::string name)
: ConvolutionBaseNPUOp(primitive, in_tensors, out_tensors, name) {}
~MaxPoolingNPUOp() override;
int IsSupport(const schema::Primitive *primitive, const std::vector<tensor::MSTensor *> &in_tensors,
const std::vector<tensor::MSTensor *> &out_tensors) override;
int IsSupport(const schema::Primitive *primitive, const std::vector<mindspore::MSTensor> &in_tensors,
const std::vector<mindspore::MSTensor> &out_tensors) override;
int Init(const schema::Primitive *primitive, const std::vector<tensor::MSTensor *> &in_tensors,
const std::vector<tensor::MSTensor *> &out_tensors) override;
int Init(const schema::Primitive *primitive, const std::vector<mindspore::MSTensor> &in_tensors,
const std::vector<mindspore::MSTensor> &out_tensors) override;
int SetNPUInputs(const std::vector<tensor::MSTensor *> &in_tensors,
const std::vector<tensor::MSTensor *> &out_tensors,
int SetNPUInputs(const std::vector<mindspore::MSTensor> &in_tensors,
const std::vector<mindspore::MSTensor> &out_tensors,
const std::vector<ge::Operator *> &npu_inputs) override;
ge::Operator *GetNPUOp() override;

63
mindspore/lite/src/delegate/npu/op/npu_op.h
View File

@ -21,19 +21,20 @@
#include <string>
#include <set>
#include <unordered_map>
#include "include/errorcode.h"
#include "include/ms_tensor.h"
#include "schema/model_generated.h"
#include "src/common/log_adapter.h"
#include "include/graph/graph.h"
#include "schema/model_generated.h"
#include "include/errorcode.h"
#include "include/api/types.h"
#include "include/api/data_type.h"
#include "src/common/log_adapter.h"
using mindspore::lite::RET_ERROR;
using mindspore::lite::RET_NOT_SUPPORT;
using mindspore::lite::RET_OK;
namespace mindspore {
class NPUOp {
public:
NPUOp(const schema::Primitive *primitive, const std::vector<tensor::MSTensor *> &in_tensors,
const std::vector<tensor::MSTensor *> &out_tensors, std::string name)
NPUOp(const schema::Primitive *primitive, const std::vector<mindspore::MSTensor> &in_tensors,
const std::vector<mindspore::MSTensor> &out_tensors, std::string name)
: inputs_(std::move(in_tensors)), outputs_(std::move(out_tensors)), name_(name) {
if (primitive != nullptr) {
type_ = primitive->value_type();
@ -42,24 +43,24 @@ class NPUOp {
virtual ~NPUOp() = default;
virtual int IsSupport(const schema::Primitive *primitive, const std::vector<tensor::MSTensor *> &in_tensors,
const std::vector<tensor::MSTensor *> &out_tensors) {
virtual int IsSupport(const schema::Primitive *primitive, const std::vector<mindspore::MSTensor> &in_tensors,
const std::vector<mindspore::MSTensor> &out_tensors) {
return RET_ERROR;
}
virtual int Init(const schema::Primitive *primitive, const std::vector<tensor::MSTensor *> &in_tensors,
const std::vector<tensor::MSTensor *> &out_tensors) {
virtual int Init(const schema::Primitive *primitive, const std::vector<mindspore::MSTensor> &in_tensors,
const std::vector<mindspore::MSTensor> &out_tensors) {
return RET_ERROR;
}
virtual int SetNPUInputs(const std::vector<tensor::MSTensor *> &in_tensors,
const std::vector<tensor::MSTensor *> &out_tensors,
virtual int SetNPUInputs(const std::vector<mindspore::MSTensor> &in_tensors,
const std::vector<mindspore::MSTensor> &out_tensors,
const std::vector<ge::Operator *> &npu_inputs) {
return RET_ERROR;
}
virtual int SetNPUInputs(const std::vector<tensor::MSTensor *> &in_tensors,
const std::vector<tensor::MSTensor *> &out_tensors,
virtual int SetNPUInputs(const std::vector<mindspore::MSTensor> &in_tensors,
const std::vector<mindspore::MSTensor> &out_tensors,
const std::vector<ge::Operator *> &npu_inputs,
const std::unordered_map<int, std::pair<ge::Operator *, int>> &index2_multi_out_index) {
if (index2_multi_out_index.empty()) {
@ -70,18 +71,18 @@ class NPUOp {
virtual ge::Operator *GetNPUOp() { return nullptr; }
void set_inputs(const std::vector<mindspore::tensor::MSTensor *> &in_tensors) { this->inputs_ = in_tensors; }
void set_inputs(const std::vector<mindspore::MSTensor> &in_tensors) { this->inputs_ = in_tensors; }
void set_input(mindspore::tensor::MSTensor *in_tensor, int index) {
void set_input(mindspore::MSTensor in_tensor, int index) {
MS_ASSERT(index < inputs_.size());
this->inputs_[index] = in_tensor;
}
void set_outputs(const std::vector<mindspore::tensor::MSTensor *> &out_tensors) { this->outputs_ = out_tensors; }
void set_outputs(const std::vector<mindspore::MSTensor> &out_tensors) { this->outputs_ = out_tensors; }
const std::vector<mindspore::tensor::MSTensor *> &inputs() { return this->inputs_; }
const std::vector<mindspore::MSTensor> &inputs() { return this->inputs_; }
const std::vector<mindspore::tensor::MSTensor *> &outputs() { return this->outputs_; }
const std::vector<mindspore::MSTensor> &outputs() { return this->outputs_; }
void set_in_ops(const std::vector<NPUOp *> &in_ops) { this->in_ops_ = in_ops; }
@ -98,37 +99,37 @@ class NPUOp {
void set_name(const std::string &name) { this->name_ = name; }
protected:
std::vector<mindspore::tensor::MSTensor *> inputs_;
std::vector<mindspore::tensor::MSTensor *> outputs_;
std::vector<mindspore::MSTensor> inputs_;
std::vector<mindspore::MSTensor> outputs_;
std::vector<NPUOp *> in_ops_;
std::vector<NPUOp *> out_ops_;
schema::PrimitiveType type_ = schema::PrimitiveType_NONE;
std::string name_;
};
typedef NPUOp *(*NPUGetOp)(const schema::Primitive *primitive, const std::vector<tensor::MSTensor *> &in_tensors,
const std::vector<tensor::MSTensor *> &out_tensors, std::string name);
typedef NPUOp *(*NPUGetOp)(const schema::Primitive *primitive, const std::vector<mindspore::MSTensor> &in_tensors,
const std::vector<mindspore::MSTensor> &out_tensors, std::string name);
template <class T>
NPUOp *GetNPUOp(const schema::Primitive *primitive, const std::vector<tensor::MSTensor *> &in_tensors,
const std::vector<tensor::MSTensor *> &out_tensors, std::string name) {
auto shape = out_tensors.front()->shape();
NPUOp *GetNPUOp(const schema::Primitive *primitive, const std::vector<mindspore::MSTensor> &in_tensors,
const std::vector<mindspore::MSTensor> &out_tensors, std::string name) {
auto shape = out_tensors.front().Shape();
if (std::find(shape.begin(), shape.end(), -1) != shape.end()) {
MS_LOG(ERROR) << "NPU does not support runtime inference shape.";
return nullptr;
}
if (in_tensors[0]->shape().size() > 4) {
if (in_tensors[0].Shape().size() > 4) {
MS_LOG(ERROR) << "Npu does not support input tensor dims greater than 4";
return nullptr;
}
std::set<schema::PrimitiveType> int32_lists = {schema::PrimitiveType_Cast, schema::PrimitiveType_StridedSlice};
auto support_int32 = in_tensors[0]->data_type() == kNumberTypeInt32 &&
auto support_int32 = in_tensors[0].DataType() == DataType::kNumberTypeInt32 &&
find(int32_lists.begin(), int32_lists.end(), primitive->value_type()) != int32_lists.end();
if (in_tensors[0]->data_type() != kNumberTypeFloat32 && in_tensors[0]->data_type() != kNumberTypeFloat16 &&
!support_int32) {
MS_LOG(ERROR) << "Npu does not support datatype " << in_tensors[0]->data_type() << " for op type "
if (in_tensors[0].DataType() != DataType::kNumberTypeFloat32 &&
in_tensors[0].DataType() != DataType::kNumberTypeFloat16 && !support_int32) {
MS_LOG(ERROR) << "Npu does not support datatype " << static_cast<int>(in_tensors[0].DataType()) << " for op type "
<< primitive->value_type();
return nullptr;
}

20
mindspore/lite/src/delegate/npu/op/pad_npu.cc
View File

@ -19,8 +19,8 @@
#include "src/delegate/npu/npu_converter_utils.h"
namespace mindspore {
int PadNPUOp::IsSupport(const schema::Primitive *primitive, const std::vector<tensor::MSTensor *> &in_tensors,
const std::vector<tensor::MSTensor *> &out_tensors) {
int PadNPUOp::IsSupport(const schema::Primitive *primitive, const std::vector<mindspore::MSTensor> &in_tensors,
const std::vector<mindspore::MSTensor> &out_tensors) {
auto pad_prim = primitive->value_as_PadFusion();
if (pad_prim == nullptr) {
MS_LOG(ERROR) << "Get null primitive value for op ." << name_;
@ -33,15 +33,15 @@ int PadNPUOp::IsSupport(const schema::Primitive *primitive, const std::vector<te
if (pad_prim->paddings() != nullptr) {
return RET_OK;
}
if (in_tensors.size() >= 2 && in_tensors[1]->data() != nullptr) {
if (in_tensors.size() >= 2 && in_tensors[1].Data() != nullptr) {
return RET_OK;
}
MS_LOG(WARNING) << "NPU pad only support constant pad size.";
return RET_ERROR;
}
int PadNPUOp::Init(const schema::Primitive *primitive, const std::vector<tensor::MSTensor *> &in_tensors,
const std::vector<tensor::MSTensor *> &out_tensors) {
int PadNPUOp::Init(const schema::Primitive *primitive, const std::vector<mindspore::MSTensor> &in_tensors,
const std::vector<mindspore::MSTensor> &out_tensors) {
pad_ = new (std::nothrow) hiai::op::PadV2(name_);
if (pad_ == nullptr) {
MS_LOG(ERROR) << name_ << " op is nullptr";
@ -67,9 +67,9 @@ int PadNPUOp::Init(const schema::Primitive *primitive, const std::vector<tensor:
auto paddings = std::vector<int64_t>(paddings_data->begin(), paddings_data->end());
paddings_vec_.insert(paddings_vec_.end(), paddings.begin(), paddings.end());
}
} else if (in_tensors.size() >= 2 && in_tensors[1]->data() != nullptr) {
for (int i = 0; i < in_tensors[1]->ElementsNum(); i++) {
paddings_vec_.push_back(static_cast<int *>(in_tensors[1]->data())[i]);
} else if (in_tensors.size() >= 2 && in_tensors[1].Data() != nullptr) {
for (int i = 0; i < in_tensors[1].ElementNum(); i++) {
paddings_vec_.push_back(static_cast<const int *>(in_tensors[1].Data().get())[i]);
}
} else {
MS_LOG(ERROR) << "NPU pad only support constant pad size.";
@ -86,8 +86,8 @@ int PadNPUOp::Init(const schema::Primitive *primitive, const std::vector<tensor:
return RET_OK;
}
int PadNPUOp::SetNPUInputs(const std::vector<tensor::MSTensor *> &in_tensors,
const std::vector<tensor::MSTensor *> &out_tensors,
int PadNPUOp::SetNPUInputs(const std::vector<mindspore::MSTensor> &in_tensors,
const std::vector<mindspore::MSTensor> &out_tensors,
const std::vector<ge::Operator *> &npu_inputs) {
int size = static_cast<int>(paddings_vec_.size() / 2);
ge::TensorDesc padding_tensor_desc(ge::Shape({size, 2}), ge::FORMAT_NCHW, ge::DT_INT32);

16
mindspore/lite/src/delegate/npu/op/pad_npu.h
View File

@ -24,20 +24,20 @@
namespace mindspore {
class PadNPUOp : public NPUOp {
public:
PadNPUOp(const schema::Primitive *primitive, const std::vector<tensor::MSTensor *> &in_tensors,
const std::vector<tensor::MSTensor *> &out_tensors, std::string name)
PadNPUOp(const schema::Primitive *primitive, const std::vector<mindspore::MSTensor> &in_tensors,
const std::vector<mindspore::MSTensor> &out_tensors, std::string name)
: NPUOp(primitive, in_tensors, out_tensors, name) {}
~PadNPUOp() override;
int IsSupport(const schema::Primitive *primitive, const std::vector<tensor::MSTensor *> &in_tensors,
const std::vector<tensor::MSTensor *> &out_tensors) override;
int IsSupport(const schema::Primitive *primitive, const std::vector<mindspore::MSTensor> &in_tensors,
const std::vector<mindspore::MSTensor> &out_tensors) override;
int Init(const schema::Primitive *primitive, const std::vector<tensor::MSTensor *> &in_tensors,
const std::vector<tensor::MSTensor *> &out_tensors) override;
int Init(const schema::Primitive *primitive, const std::vector<mindspore::MSTensor> &in_tensors,
const std::vector<mindspore::MSTensor> &out_tensors) override;
int SetNPUInputs(const std::vector<tensor::MSTensor *> &in_tensors,
const std::vector<tensor::MSTensor *> &out_tensors,
int SetNPUInputs(const std::vector<mindspore::MSTensor> &in_tensors,
const std::vector<mindspore::MSTensor> &out_tensors,
const std::vector<ge::Operator *> &npu_inputs) override;
ge::Operator *GetNPUOp() override;

13
mindspore/lite/src/delegate/npu/op/reduce_npu.cc
View File

@ -15,11 +15,10 @@
*/
#include "src/delegate/npu/op/reduce_npu.h"
#include <memory>
namespace mindspore {
int ReduceNPUOp::IsSupport(const schema::Primitive *primitive, const std::vector<tensor::MSTensor *> &in_tensors,
const std::vector<tensor::MSTensor *> &out_tensors) {
int ReduceNPUOp::IsSupport(const schema::Primitive *primitive, const std::vector<mindspore::MSTensor> &in_tensors,
const std::vector<mindspore::MSTensor> &out_tensors) {
auto reduce_prim = primitive->value_as_ReduceFusion();
if (reduce_prim == nullptr) {
MS_LOG(ERROR) << "Get null primitive value for op ." << name_;
@ -37,8 +36,8 @@ int ReduceNPUOp::IsSupport(const schema::Primitive *primitive, const std::vector
return RET_OK;
}
int ReduceNPUOp::Init(const schema::Primitive *primitive, const std::vector<tensor::MSTensor *> &in_tensors,
const std::vector<tensor::MSTensor *> &out_tensors) {
int ReduceNPUOp::Init(const schema::Primitive *primitive, const std::vector<mindspore::MSTensor> &in_tensors,
const std::vector<mindspore::MSTensor> &out_tensors) {
auto reduce_prim = primitive->value_as_ReduceFusion();
if (reduce_prim == nullptr) {
MS_LOG(ERROR) << "Get null primitive value for op ." << name_;
@ -59,8 +58,8 @@ int ReduceNPUOp::Init(const schema::Primitive *primitive, const std::vector<tens
return RET_OK;
}
int ReduceNPUOp::SetNPUInputs(const std::vector<tensor::MSTensor *> &in_tensors,
const std::vector<tensor::MSTensor *> &out_tensors,
int ReduceNPUOp::SetNPUInputs(const std::vector<mindspore::MSTensor> &in_tensors,
const std::vector<mindspore::MSTensor> &out_tensors,
const std::vector<ge::Operator *> &npu_inputs) {
if (reduce_mode_ == schema::ReduceMode_ReduceMean) {
auto reduce_mean = reinterpret_cast<hiai::op::ReduceMean *>(reduce_);

16
mindspore/lite/src/delegate/npu/op/reduce_npu.h
View File

@ -24,20 +24,20 @@
namespace mindspore {
class ReduceNPUOp : public NPUOp {
public:
ReduceNPUOp(const schema::Primitive *primitive, const std::vector<tensor::MSTensor *> &in_tensors,
const std::vector<tensor::MSTensor *> &out_tensors, std::string name)
ReduceNPUOp(const schema::Primitive *primitive, const std::vector<mindspore::MSTensor> &in_tensors,
const std::vector<mindspore::MSTensor> &out_tensors, std::string name)
: NPUOp(primitive, in_tensors, out_tensors, name) {}
~ReduceNPUOp() override;
int IsSupport(const schema::Primitive *primitive, const std::vector<tensor::MSTensor *> &in_tensors,
const std::vector<tensor::MSTensor *> &out_tensors) override;
int IsSupport(const schema::Primitive *primitive, const std::vector<mindspore::MSTensor> &in_tensors,
const std::vector<mindspore::MSTensor> &out_tensors) override;
int Init(const schema::Primitive *primitive, const std::vector<tensor::MSTensor *> &in_tensors,
const std::vector<tensor::MSTensor *> &out_tensors) override;
int Init(const schema::Primitive *primitive, const std::vector<mindspore::MSTensor> &in_tensors,
const std::vector<mindspore::MSTensor> &out_tensors) override;
int SetNPUInputs(const std::vector<tensor::MSTensor *> &in_tensors,
const std::vector<tensor::MSTensor *> &out_tensors,
int SetNPUInputs(const std::vector<mindspore::MSTensor> &in_tensors,
const std::vector<mindspore::MSTensor> &out_tensors,
const std::vector<ge::Operator *> &npu_inputs) override;
ge::Operator *GetNPUOp() override;

15
mindspore/lite/src/delegate/npu/op/reshape_npu.cc
View File

@ -15,26 +15,25 @@
*/
#include "src/delegate/npu/op/reshape_npu.h"
#include <memory>
#include "include/graph/op/all_ops.h"
#include "src/delegate/npu/npu_converter_utils.h"
namespace mindspore {
int ReshapeNPUOp::IsSupport(const schema::Primitive *primitive, const std::vector<tensor::MSTensor *> &in_tensors,
const std::vector<tensor::MSTensor *> &out_tensors) {
int ReshapeNPUOp::IsSupport(const schema::Primitive *primitive, const std::vector<mindspore::MSTensor> &in_tensors,
const std::vector<mindspore::MSTensor> &out_tensors) {
if (in_tensors.size() != 2) {
MS_LOG(WARNING) << "Npu op should have w2 input tensors.";
return RET_NOT_SUPPORT;
}
auto shape_tensor = in_tensors.at(1);
if (shape_tensor->data() == nullptr) {
if (shape_tensor.Data() == nullptr) {
MS_LOG(WARNING) << "Npu reshape op only supports const shape.";
return RET_NOT_SUPPORT;
}
return RET_OK;
}
int ReshapeNPUOp::Init(const schema::Primitive *primitive, const std::vector<tensor::MSTensor *> &in_tensors,
const std::vector<tensor::MSTensor *> &out_tensors) {
int ReshapeNPUOp::Init(const schema::Primitive *primitive, const std::vector<mindspore::MSTensor> &in_tensors,
const std::vector<mindspore::MSTensor> &out_tensors) {
reshape_ = new (std::nothrow) hiai::op::Reshape(name_);
if (reshape_ == nullptr) {
MS_LOG(ERROR) << name_ << " op is nullptr";
@ -43,8 +42,8 @@ int ReshapeNPUOp::Init(const schema::Primitive *primitive, const std::vector<ten
return RET_OK;
}
int ReshapeNPUOp::SetNPUInputs(const std::vector<tensor::MSTensor *> &in_tensors,
const std::vector<tensor::MSTensor *> &out_tensors,
int ReshapeNPUOp::SetNPUInputs(const std::vector<mindspore::MSTensor> &in_tensors,
const std::vector<mindspore::MSTensor> &out_tensors,
const std::vector<ge::Operator *> &npu_inputs) {
reshape_->set_input_x(*npu_inputs[0]);
reshape_->set_input_shape(*npu_inputs[1]);

16
mindspore/lite/src/delegate/npu/op/reshape_npu.h
View File

@ -23,20 +23,20 @@
namespace mindspore {
class ReshapeNPUOp : public NPUOp {
public:
ReshapeNPUOp(const schema::Primitive *primitive, const std::vector<tensor::MSTensor *> &in_tensors,
const std::vector<tensor::MSTensor *> &out_tensors, std::string name)
ReshapeNPUOp(const schema::Primitive *primitive, const std::vector<mindspore::MSTensor> &in_tensors,
const std::vector<mindspore::MSTensor> &out_tensors, std::string name)
: NPUOp(primitive, in_tensors, out_tensors, name) {}
~ReshapeNPUOp() override;
int Init(const schema::Primitive *primitive, const std::vector<tensor::MSTensor *> &in_tensors,
const std::vector<tensor::MSTensor *> &out_tensors) override;
int Init(const schema::Primitive *primitive, const std::vector<mindspore::MSTensor> &in_tensors,
const std::vector<mindspore::MSTensor> &out_tensors) override;
int IsSupport(const schema::Primitive *primitive, const std::vector<tensor::MSTensor *> &in_tensors,
const std::vector<tensor::MSTensor *> &out_tensors) override;
int IsSupport(const schema::Primitive *primitive, const std::vector<mindspore::MSTensor> &in_tensors,
const std::vector<mindspore::MSTensor> &out_tensors) override;
int SetNPUInputs(const std::vector<tensor::MSTensor *> &in_tensors,
const std::vector<tensor::MSTensor *> &out_tensors,
int SetNPUInputs(const std::vector<mindspore::MSTensor> &in_tensors,
const std::vector<mindspore::MSTensor> &out_tensors,
const std::vector<ge::Operator *> &npu_inputs) override;
ge::Operator *GetNPUOp() override;

21
mindspore/lite/src/delegate/npu/op/resize_npu.cc
View File

@ -19,8 +19,8 @@
#include "src/delegate/npu/npu_converter_utils.h"
namespace mindspore {
int ResizeNPUOp::IsSupport(const schema::Primitive *primitive, const std::vector<tensor::MSTensor *> &in_tensors,
const std::vector<tensor::MSTensor *> &out_tensors) {
int ResizeNPUOp::IsSupport(const schema::Primitive *primitive, const std::vector<mindspore::MSTensor> &in_tensors,
const std::vector<mindspore::MSTensor> &out_tensors) {
auto resize_prim = primitive->value_as_Resize();
if (resize_prim == nullptr) {
MS_LOG(ERROR) << "Get null primitive value for op ." << name_;
@ -32,16 +32,15 @@ int ResizeNPUOp::IsSupport(const schema::Primitive *primitive, const std::vector
return RET_NOT_SUPPORT;
}
if (in_tensors[0]->shape()[1] > out_tensors[0]->shape()[1] ||
in_tensors[0]->shape()[2] > out_tensors[0]->shape()[2]) {
if (in_tensors[0].Shape()[1] > out_tensors[0].Shape()[1] || in_tensors[0].Shape()[2] > out_tensors[0].Shape()[2]) {
MS_LOG(WARNING) << "Npu resize does not support reduction.";
return RET_NOT_SUPPORT;
}
return RET_OK;
}
int ResizeNPUOp::Init(const schema::Primitive *primitive, const std::vector<tensor::MSTensor *> &in_tensors,
const std::vector<tensor::MSTensor *> &out_tensors) {
int ResizeNPUOp::Init(const schema::Primitive *primitive, const std::vector<mindspore::MSTensor> &in_tensors,
const std::vector<mindspore::MSTensor> &out_tensors) {
auto resize_prim = primitive->value_as_Resize();
if (resize_prim == nullptr) {
MS_LOG(ERROR) << "Get null primitive value for op ." << name_;
@ -51,13 +50,13 @@ int ResizeNPUOp::Init(const schema::Primitive *primitive, const std::vector<tens
new_height_ = resize_prim->new_height();
new_width_ = resize_prim->new_width();
} else if (in_tensors.size() == 2) {
auto out_size = in_tensors.at(1)->data();
auto out_size = in_tensors.at(1).Data();
if (out_size == nullptr) {
MS_LOG(ERROR) << "Out size is not assigned";
return RET_ERROR;
}
new_height_ = out_tensors.at(0)->shape().at(1);
new_width_ = out_tensors.at(0)->shape().at(2);
new_height_ = out_tensors.at(0).Shape().at(1);
new_width_ = out_tensors.at(0).Shape().at(2);
} else {
MS_LOG(ERROR) << "Get resize op new_height and new_width error.";
return RET_ERROR;
@ -97,8 +96,8 @@ int ResizeNPUOp::Init(const schema::Primitive *primitive, const std::vector<tens
return RET_OK;
}
int ResizeNPUOp::SetNPUInputs(const std::vector<tensor::MSTensor *> &in_tensors,
const std::vector<tensor::MSTensor *> &out_tensors,
int ResizeNPUOp::SetNPUInputs(const std::vector<mindspore::MSTensor> &in_tensors,
const std::vector<mindspore::MSTensor> &out_tensors,
const std::vector<ge::Operator *> &npu_inputs) {
if (resize_method_ == schema::ResizeMethod_LINEAR) {
auto resize_bilinear = reinterpret_cast<hiai::op::ResizeBilinearV2 *>(resize_);

16
mindspore/lite/src/delegate/npu/op/resize_npu.h
View File

@ -24,20 +24,20 @@
namespace mindspore {
class ResizeNPUOp : public NPUOp {
public:
ResizeNPUOp(const schema::Primitive *primitive, const std::vector<tensor::MSTensor *> &in_tensors,
const std::vector<tensor::MSTensor *> &out_tensors, std::string name)
ResizeNPUOp(const schema::Primitive *primitive, const std::vector<mindspore::MSTensor> &in_tensors,
const std::vector<mindspore::MSTensor> &out_tensors, std::string name)
: NPUOp(primitive, in_tensors, out_tensors, name) {}
~ResizeNPUOp() override;
int IsSupport(const schema::Primitive *primitive, const std::vector<tensor::MSTensor *> &in_tensors,
const std::vector<tensor::MSTensor *> &out_tensors) override;
int IsSupport(const schema::Primitive *primitive, const std::vector<mindspore::MSTensor> &in_tensors,
const std::vector<mindspore::MSTensor> &out_tensors) override;
int Init(const schema::Primitive *primitive, const std::vector<tensor::MSTensor *> &in_tensors,
const std::vector<tensor::MSTensor *> &out_tensors) override;
int Init(const schema::Primitive *primitive, const std::vector<mindspore::MSTensor> &in_tensors,
const std::vector<mindspore::MSTensor> &out_tensors) override;
int SetNPUInputs(const std::vector<tensor::MSTensor *> &in_tensors,
const std::vector<tensor::MSTensor *> &out_tensors,
int SetNPUInputs(const std::vector<mindspore::MSTensor> &in_tensors,
const std::vector<mindspore::MSTensor> &out_tensors,
const std::vector<ge::Operator *> &npu_inputs) override;
ge::Operator *GetNPUOp() override;

19
mindspore/lite/src/delegate/npu/op/scale_npu.cc
View File

@ -15,12 +15,11 @@
*/
#include "src/delegate/npu/op/scale_npu.h"
#include <memory>
#include "src/delegate/npu/npu_converter_utils.h"
namespace mindspore {
int ScaleNPUOp::IsSupport(const schema::Primitive *primitive, const std::vector<tensor::MSTensor *> &in_tensors,
const std::vector<tensor::MSTensor *> &out_tensors) {
int ScaleNPUOp::IsSupport(const schema::Primitive *primitive, const std::vector<mindspore::MSTensor> &in_tensors,
const std::vector<mindspore::MSTensor> &out_tensors) {
auto scale_prim = primitive->value_as_ScaleFusion();
if (scale_prim == nullptr) {
MS_LOG(ERROR) << "Get null primitive value for op ." << name_;
@ -28,7 +27,7 @@ int ScaleNPUOp::IsSupport(const schema::Primitive *primitive, const std::vector<
}
axis_ = scale_prim->axis();
if (axis_ < 0) {
axis_ = axis_ + in_tensors[0]->shape().size();
axis_ = axis_ + in_tensors[0].Shape().size();
}
if (axis_ != 1 && axis_ != 3) {
MS_LOG(WARNING) << "Npu scale axis attr only support 1 or channel, now is " << axis_;
@ -37,8 +36,8 @@ int ScaleNPUOp::IsSupport(const schema::Primitive *primitive, const std::vector<
return RET_OK;
}
int ScaleNPUOp::Init(const schema::Primitive *primitive, const std::vector<tensor::MSTensor *> &in_tensors,
const std::vector<tensor::MSTensor *> &out_tensors) {
int ScaleNPUOp::Init(const schema::Primitive *primitive, const std::vector<mindspore::MSTensor> &in_tensors,
const std::vector<mindspore::MSTensor> &out_tensors) {
op_ = new (std::nothrow) hiai::op::Scale(name_);
if (op_ == nullptr) {
MS_LOG(ERROR) << name_ << " op is nullptr";
@ -62,12 +61,12 @@ int ScaleNPUOp::Init(const schema::Primitive *primitive, const std::vector<tenso
return RET_OK;
}
int ScaleNPUOp::SetNPUInputs(const std::vector<tensor::MSTensor *> &in_tensors,
const std::vector<tensor::MSTensor *> &out_tensors,
int ScaleNPUOp::SetNPUInputs(const std::vector<mindspore::MSTensor> &in_tensors,
const std::vector<mindspore::MSTensor> &out_tensors,
const std::vector<ge::Operator *> &npu_inputs) {
op_->set_input_x(*npu_inputs.at(0));
MS_ASSERT(in_tensors.size() > 1);
auto scale_shape = in_tensors[1]->shape();
auto scale_shape = in_tensors[1].Shape();
auto scale_tensor = ConverterToNPUTensor(in_tensors[1]);
if (scale_tensor == nullptr) {
MS_LOG(ERROR) << "Get scale_tensor failed.";
@ -84,7 +83,7 @@ int ScaleNPUOp::SetNPUInputs(const std::vector<tensor::MSTensor *> &in_tensors,
op_->set_input_scale(*scale_);
if (in_tensors.size() > 2 && in_tensors[2] != nullptr) {
auto bias_shape = in_tensors[2]->shape();
auto bias_shape = in_tensors[2].Shape();
auto bias_tensor = ConverterToNPUTensor(in_tensors[2]);
if (bias_tensor == nullptr) {
MS_LOG(ERROR) << "Get bias_tensor failed.";

16
mindspore/lite/src/delegate/npu/op/scale_npu.h
View File

@ -25,20 +25,20 @@
namespace mindspore {
class ScaleNPUOp : public NPUOp {
public:
ScaleNPUOp(const schema::Primitive *primitive, const std::vector<tensor::MSTensor *> &in_tensors,
const std::vector<tensor::MSTensor *> &out_tensors, std::string name)
ScaleNPUOp(const schema::Primitive *primitive, const std::vector<mindspore::MSTensor> &in_tensors,
const std::vector<mindspore::MSTensor> &out_tensors, std::string name)
: NPUOp(primitive, in_tensors, out_tensors, name) {}
~ScaleNPUOp() override;
int IsSupport(const schema::Primitive *primitive, const std::vector<tensor::MSTensor *> &in_tensors,
const std::vector<tensor::MSTensor *> &out_tensors) override;
int IsSupport(const schema::Primitive *primitive, const std::vector<mindspore::MSTensor> &in_tensors,
const std::vector<mindspore::MSTensor> &out_tensors) override;
int Init(const schema::Primitive *primitive, const std::vector<tensor::MSTensor *> &in_tensors,
const std::vector<tensor::MSTensor *> &out_tensors) override;
int Init(const schema::Primitive *primitive, const std::vector<mindspore::MSTensor> &in_tensors,
const std::vector<mindspore::MSTensor> &out_tensors) override;
int SetNPUInputs(const std::vector<tensor::MSTensor *> &in_tensors,
const std::vector<tensor::MSTensor *> &out_tensors,
int SetNPUInputs(const std::vector<mindspore::MSTensor> &in_tensors,
const std::vector<mindspore::MSTensor> &out_tensors,
const std::vector<ge::Operator *> &npu_inputs) override;
ge::Operator *GetNPUOp() override;

8
mindspore/lite/src/delegate/npu/op/slice_npu.cc
View File

@ -18,8 +18,8 @@
#include "src/delegate/npu/npu_converter_utils.h"
namespace mindspore {
int SliceNPUOp::Init(const schema::Primitive *primitive, const std::vector<tensor::MSTensor *> &in_tensors,
const std::vector<tensor::MSTensor *> &out_tensors) {
int SliceNPUOp::Init(const schema::Primitive *primitive, const std::vector<mindspore::MSTensor> &in_tensors,
const std::vector<mindspore::MSTensor> &out_tensors) {
slice_ = new (std::nothrow) hiai::op::Slice(name_);
if (slice_ == nullptr) {
MS_LOG(ERROR) << name_ << " op is nullptr";
@ -28,8 +28,8 @@ int SliceNPUOp::Init(const schema::Primitive *primitive, const std::vector<tenso
return RET_OK;
}
int SliceNPUOp::SetNPUInputs(const std::vector<tensor::MSTensor *> &in_tensors,
const std::vector<tensor::MSTensor *> &out_tensors,
int SliceNPUOp::SetNPUInputs(const std::vector<mindspore::MSTensor> &in_tensors,
const std::vector<mindspore::MSTensor> &out_tensors,
const std::vector<ge::Operator *> &npu_inputs) {
slice_->set_input_x(*npu_inputs[0]);
slice_->set_input_offsets(*npu_inputs[1]);

16
mindspore/lite/src/delegate/npu/op/slice_npu.h
View File

@ -24,22 +24,22 @@
namespace mindspore {
class SliceNPUOp : public NPUOp {
public:
SliceNPUOp(const schema::Primitive *primitive, const std::vector<tensor::MSTensor *> &in_tensors,
const std::vector<tensor::MSTensor *> &out_tensors, std::string name)
SliceNPUOp(const schema::Primitive *primitive, const std::vector<mindspore::MSTensor> &in_tensors,
const std::vector<mindspore::MSTensor> &out_tensors, std::string name)
: NPUOp(primitive, in_tensors, out_tensors, name) {}
~SliceNPUOp() override;
int IsSupport(const schema::Primitive *primitive, const std::vector<tensor::MSTensor *> &in_tensors,
const std::vector<tensor::MSTensor *> &out_tensors) override {
int IsSupport(const schema::Primitive *primitive, const std::vector<mindspore::MSTensor> &in_tensors,
const std::vector<mindspore::MSTensor> &out_tensors) override {
return RET_OK;
}
int Init(const schema::Primitive *primitive, const std::vector<tensor::MSTensor *> &in_tensors,
const std::vector<tensor::MSTensor *> &out_tensors) override;
int Init(const schema::Primitive *primitive, const std::vector<mindspore::MSTensor> &in_tensors,
const std::vector<mindspore::MSTensor> &out_tensors) override;
int SetNPUInputs(const std::vector<tensor::MSTensor *> &in_tensors,
const std::vector<tensor::MSTensor *> &out_tensors,
int SetNPUInputs(const std::vector<mindspore::MSTensor> &in_tensors,
const std::vector<mindspore::MSTensor> &out_tensors,
const std::vector<ge::Operator *> &npu_inputs) override;
ge::Operator *GetNPUOp() override;

10
mindspore/lite/src/delegate/npu/op/softmax_npu.cc
View File

@ -16,8 +16,8 @@
#include "src/delegate/npu/op/softmax_npu.h"
namespace mindspore {
int SoftmaxNPUOp::Init(const schema::Primitive *primitive, const std::vector<tensor::MSTensor *> &in_tensors,
const std::vector<tensor::MSTensor *> &out_tensors) {
int SoftmaxNPUOp::Init(const schema::Primitive *primitive, const std::vector<mindspore::MSTensor> &in_tensors,
const std::vector<mindspore::MSTensor> &out_tensors) {
softmax_ = new (std::nothrow) hiai::op::Softmax(name_);
if (softmax_ == nullptr) {
MS_LOG(ERROR) << name_ << " op is nullptr";
@ -30,15 +30,15 @@ int SoftmaxNPUOp::Init(const schema::Primitive *primitive, const std::vector<ten
}
auto axis = static_cast<int>(*(softmax_prim->axis()->begin()));
if (axis == -1) {
softmax_->set_attr_axis(in_tensors[0]->shape().size() + axis);
softmax_->set_attr_axis(in_tensors[0].Shape().size() + axis);
} else {
softmax_->set_attr_axis(axis);
}
return RET_OK;
}
int SoftmaxNPUOp::SetNPUInputs(const std::vector<tensor::MSTensor *> &in_tensors,
const std::vector<tensor::MSTensor *> &out_tensors,
int SoftmaxNPUOp::SetNPUInputs(const std::vector<mindspore::MSTensor> &in_tensors,
const std::vector<mindspore::MSTensor> &out_tensors,
const std::vector<ge::Operator *> &npu_inputs) {
softmax_->set_input_x(*npu_inputs[0]);
return RET_OK;

16
mindspore/lite/src/delegate/npu/op/softmax_npu.h
View File

@ -24,22 +24,22 @@
namespace mindspore {
class SoftmaxNPUOp : public NPUOp {
public:
SoftmaxNPUOp(const schema::Primitive *primitive, const std::vector<tensor::MSTensor *> &in_tensors,
const std::vector<tensor::MSTensor *> &out_tensors, std::string name)
SoftmaxNPUOp(const schema::Primitive *primitive, const std::vector<mindspore::MSTensor> &in_tensors,
const std::vector<mindspore::MSTensor> &out_tensors, std::string name)
: NPUOp(primitive, in_tensors, out_tensors, name) {}
~SoftmaxNPUOp() override;
int IsSupport(const schema::Primitive *primitive, const std::vector<tensor::MSTensor *> &in_tensors,
const std::vector<tensor::MSTensor *> &out_tensors) override {
int IsSupport(const schema::Primitive *primitive, const std::vector<mindspore::MSTensor> &in_tensors,
const std::vector<mindspore::MSTensor> &out_tensors) override {
return RET_OK;
}
int Init(const schema::Primitive *primitive, const std::vector<tensor::MSTensor *> &in_tensors,
const std::vector<tensor::MSTensor *> &out_tensors) override;
int Init(const schema::Primitive *primitive, const std::vector<mindspore::MSTensor> &in_tensors,
const std::vector<mindspore::MSTensor> &out_tensors) override;
int SetNPUInputs(const std::vector<tensor::MSTensor *> &in_tensors,
const std::vector<tensor::MSTensor *> &out_tensors,
int SetNPUInputs(const std::vector<mindspore::MSTensor> &in_tensors,
const std::vector<mindspore::MSTensor> &out_tensors,
const std::vector<ge::Operator *> &npu_inputs) override;
ge::Operator *GetNPUOp() override;

8
mindspore/lite/src/delegate/npu/op/split_npu.cc
View File

@ -19,8 +19,8 @@
#include "src/delegate/npu/npu_converter_utils.h"
namespace mindspore {
int SplitNPUOp::Init(const schema::Primitive *primitive, const std::vector<tensor::MSTensor *> &in_tensors,
const std::vector<tensor::MSTensor *> &out_tensors) {
int SplitNPUOp::Init(const schema::Primitive *primitive, const std::vector<mindspore::MSTensor> &in_tensors,
const std::vector<mindspore::MSTensor> &out_tensors) {
split_ = new (std::nothrow) hiai::op::SplitV(name_);
if (split_ == nullptr) {
MS_LOG(ERROR) << "New split npu operator for op " << name_ << " failed.";
@ -53,8 +53,8 @@ int SplitNPUOp::Init(const schema::Primitive *primitive, const std::vector<tenso
return RET_OK;
}
int SplitNPUOp::SetNPUInputs(const std::vector<tensor::MSTensor *> &in_tensors,
const std::vector<tensor::MSTensor *> &out_tensors,
int SplitNPUOp::SetNPUInputs(const std::vector<mindspore::MSTensor> &in_tensors,
const std::vector<mindspore::MSTensor> &out_tensors,
const std::vector<ge::Operator *> &npu_inputs) {
ge::TensorDesc split_dim_tensor_desc(ge::Shape({1}), ge::FORMAT_NCHW, ge::DT_INT32);
ge::TensorPtr split_dim_tensor = std::make_shared<hiai::Tensor>(split_dim_tensor_desc);

16
mindspore/lite/src/delegate/npu/op/split_npu.h
View File

@ -24,22 +24,22 @@
namespace mindspore {
class SplitNPUOp : public NPUOp {
public:
SplitNPUOp(const schema::Primitive *primitive, const std::vector<tensor::MSTensor *> &in_tensors,
const std::vector<tensor::MSTensor *> &out_tensors, std::string name)
SplitNPUOp(const schema::Primitive *primitive, const std::vector<mindspore::MSTensor> &in_tensors,
const std::vector<mindspore::MSTensor> &out_tensors, std::string name)
: NPUOp(primitive, in_tensors, out_tensors, name) {}
~SplitNPUOp();
int IsSupport(const schema::Primitive *primitive, const std::vector<tensor::MSTensor *> &in_tensors,
const std::vector<tensor::MSTensor *> &out_tensors) override {
int IsSupport(const schema::Primitive *primitive, const std::vector<mindspore::MSTensor> &in_tensors,
const std::vector<mindspore::MSTensor> &out_tensors) override {
return RET_OK;
}
int Init(const schema::Primitive *primitive, const std::vector<tensor::MSTensor *> &in_tensors,
const std::vector<tensor::MSTensor *> &out_tensors) override;
int Init(const schema::Primitive *primitive, const std::vector<mindspore::MSTensor> &in_tensors,
const std::vector<mindspore::MSTensor> &out_tensors) override;
int SetNPUInputs(const std::vector<tensor::MSTensor *> &in_tensors,
const std::vector<tensor::MSTensor *> &out_tensors,
int SetNPUInputs(const std::vector<mindspore::MSTensor> &in_tensors,
const std::vector<mindspore::MSTensor> &out_tensors,
const std::vector<ge::Operator *> &npu_inputs) override;
int HandleAxis();

Some files were not shown because too many files have changed in this diff Show More