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

!10231 [MS][LITE] fix decode model 

From: @YeFeng_24
Reviewed-by: 
Signed-off-by:
This commit is contained in:
mindspore-ci-bot 2020-12-20 20:41:34 +08:00 committed by Gitee
parent 9821a1f7eb 731441f514
commit 491362258b
19 changed files with 168 additions and 48 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -25,7 +25,7 @@ int Executor::CheckInputs(const std::vector<Tensor *> &in_tensors) {
MS_LOG(ERROR) << "Graph input tensor is nullptr";
return RET_ERROR;
}
if (inTensor->data_c() == nullptr) {
if (inTensor->data_type() != kObjectTypeTensorType && inTensor->data_c() == nullptr) {
MS_LOG(ERROR) << "Graph input tensor data is nullptr " << in_tensors;
return RET_ERROR;
}

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

@ -144,7 +144,7 @@ lite::Tensor *LiteSession::ConvertTensor(const schema::Tensor &src_tensor) {
}
lite::Tensor *dst_tensor = nullptr;
if (TypeId(src_tensor.dataType()) == kObjectTypeTensorType) {
dst_tensor = new (std::nothrow) TensorList(shape, std::vector<int>());
dst_tensor = new (std::nothrow) TensorList(shape, std::vector<int>(), src_category);
} else {
dst_tensor = new (std::nothrow) Tensor(TypeId(src_tensor.dataType()), shape, src_tensor.format(), src_category);
}

3
mindspore/lite/src/ops/tensorlist_fromtensor.cc
View File

@ -112,6 +112,9 @@ Registry TensorListFromTensorRegistry(schema::PrimitiveType_TensorListFromTensor
#endif
int TensorListFromTensor::InferShape(std::vector<lite::Tensor *> inputs_, std::vector<lite::Tensor *> outputs_) {
if (!infer_flag()) {
return RET_INFER_INVALID;
}
auto input0 = inputs_[0];
MS_ASSERT(input0 != nullptr);
std::vector<int> input0_shape = input0->shape();

7
mindspore/lite/src/ops/tensorlist_getitem.cc
View File

@ -117,6 +117,9 @@ int TensorListGetItem::MergeShape(const std::vector<int> &tmp) {
}
int TensorListGetItem::InferShape(std::vector<lite::Tensor *> inputs_, std::vector<lite::Tensor *> outputs_) {
if (!infer_flag()) {
return RET_INFER_INVALID;
}
auto input0 = reinterpret_cast<TensorList *>(inputs_[0]);
auto get_index = inputs_[1];
MS_ASSERT(get_index != nullptr);
@ -125,8 +128,8 @@ int TensorListGetItem::InferShape(std::vector<lite::Tensor *> inputs_, std::vect
return RET_ERROR;
}
if (get_index->data_c() == nullptr) {
MS_LOG(ERROR) << "get_index->data_c() is nullptr";
return RET_NULL_PTR;
MS_LOG(DEBUG) << "get_index->data_c() is nullptr";
return RET_INFER_INVALID;
}
index_ = reinterpret_cast<int *>(get_index->data_c())[0];
if (index_ < 0 || index_ > (input0->ElementsNum() - 1)) {

5
mindspore/lite/src/ops/tensorlist_stack.cc
View File

@ -117,6 +117,9 @@ bool TensorListStack::IsFullyDefined(const std::vector<int> &shape) const {
}
int TensorListStack::InferShape(std::vector<lite::Tensor *> inputs_, std::vector<lite::Tensor *> outputs_) {
if (!infer_flag()) {
return RET_INFER_INVALID;
}
auto input0 = reinterpret_cast<TensorList *>(inputs_.front());
MS_ASSERT(input0 != nullptr);
if (input0->ElementsNum() == 0) {
@ -130,7 +133,7 @@ int TensorListStack::InferShape(std::vector<lite::Tensor *> inputs_, std::vector
return RET_NULL_PTR;
}
auto ele_shape_ptr = reinterpret_cast<int *>(ele_shape->data_c());
for (int i = 0; ele_shape->ElementsNum(); ++i) {
for (int i = 0; i < ele_shape->ElementsNum(); ++i) {
output_shape_.push_back(ele_shape_ptr[i]);
}

52
mindspore/lite/src/runtime/kernel/arm/base/merge.cc
View File

@ -17,6 +17,7 @@
#include "src/runtime/kernel/arm/base/merge.h"
#include "src/kernel_registry.h"
#include "include/errorcode.h"
#include "src/tensorlist.h"
using mindspore::lite::KernelRegistrar;
using mindspore::lite::RET_ERROR;
@ -56,31 +57,72 @@ bool MergeCPUKernel::IsReady(const std::vector<lite::Tensor *> &scope_tensors) {
std::all_of(this->in_tensors().begin() + in_tensors().size() / 2, this->in_tensors().end(),
[&](lite::Tensor *kernel_in_tensor) {
return kernel_in_tensor->IsConst() || kernel_in_tensor->IsGraphInput() ||
kernel_in_tensor->ref_count() >= 1;
kernel_in_tensor->ref_count() >= 1 ||
(kernel_in_tensor->data_type() == kObjectTypeTensorType);
});
}
int MergeCPUKernel::Init() { return RET_OK; }
int MergeCPUKernel::ReSize() { return RET_ERROR; }
int MergeCPUKernel::ReSize() { return RET_OK; }
bool MergeCPUKernel::PartialInputReady(int num_begin, int num_end) {
MS_ASSERT(in_tensors_.size() == 2 * out_tensors_.size());
bool result = (std::all_of(this->in_tensors().begin() + num_begin, this->in_tensors().begin() + num_end,
[&](lite::Tensor *kernel_in_tensor) {
return kernel_in_tensor->IsConst() || kernel_in_tensor->ref_count() >= 1 ||
kernel_in_tensor->IsGraphInput() ||
kernel_in_tensor->data_type() == kObjectTypeTensorType;
})) &&
std::all_of(this->in_tensors_.begin() + num_begin, this->in_tensors_.begin() + num_end,
[&](lite::Tensor *in_tensor) {
if (in_tensor->data_type() != kObjectTypeTensorType) {
return in_tensor->data_c() != nullptr;
} else {
return true;
}
});
return result;
}
int MergeCPUKernel::Run() {
MS_ASSERT(in_tensors_.size() == 2 * out_tensors_.size());
int in_tesnor_part_one = 0;
int in_tensor_part_two = out_tensors().size();
if (in_tensors_[in_tesnor_part_one]->data_c() != nullptr) {
int in_tensor_part_two = in_tensors_.size() / 2;
int in_tensor_part_three = in_tensors_.size();
if (PartialInputReady(in_tesnor_part_one, in_tensor_part_two)) {
for (size_t i = 0; i < out_tensors().size(); i++) {
auto out_data = out_tensors_[i]->data_c();
auto in_data = in_tensors_[i]->data_c();
if (in_tensors_[i]->data_type() == kObjectTypeTensorType) {
auto in_tensor_list = reinterpret_cast<lite::TensorList *>(in_tensors_[i]);
auto out_tensor_list = reinterpret_cast<lite::TensorList *>(out_tensors_[i]);
if (std::any_of(in_tensor_list->tensors().begin(), in_tensor_list->tensors().end(),
[&](lite::Tensor *tensor) { return tensor->data_c() == nullptr; })) {
continue;
}
*out_tensor_list = *in_tensor_list;
continue;
}
MS_ASSERT(in_data != nullptr);
MS_ASSERT(out_data != nullptr);
memcpy(out_data, in_data, in_tensors_[i]->Size());
}
}
if (in_tensors_[in_tensor_part_two]->data_c() != nullptr) {
if (PartialInputReady(in_tensor_part_two, in_tensor_part_three)) {
for (size_t i = 0; i < out_tensors().size(); i++) {
auto out_data = out_tensors_[i]->data_c();
auto in_data = in_tensors_[i + in_tensor_part_two]->data_c();
if (in_tensors_[i]->data_type() == kObjectTypeTensorType) {
auto in_tensor_list = reinterpret_cast<lite::TensorList *>(in_tensors_[i + in_tensor_part_two]);
auto out_tensor_list = reinterpret_cast<lite::TensorList *>(out_tensors_[i]);
if (std::any_of(in_tensor_list->tensors().begin(), in_tensor_list->tensors().end(),
[&](lite::Tensor *tensor) { return tensor->data_c() == nullptr; })) {
continue;
}
*out_tensor_list = *in_tensor_list;
continue;
}
MS_ASSERT(in_data != nullptr);
MS_ASSERT(out_data != nullptr);
memcpy(out_data, in_data, in_tensors_[i]->Size());

1
mindspore/lite/src/runtime/kernel/arm/base/merge.h
View File

@ -39,6 +39,7 @@ class MergeCPUKernel : public LiteKernel {
int Init() override;
int ReSize() override;
int Run() override;
bool PartialInputReady(int num_begin, int num_end);
private:
MergeParameter *merge_param_ = nullptr;

20
mindspore/lite/src/runtime/kernel/arm/base/switch.cc
View File

@ -17,6 +17,7 @@
#include "src/runtime/kernel/arm/base/switch.h"
#include "src/kernel_registry.h"
#include "include/errorcode.h"
#include "src/tensorlist.h"
using mindspore::lite::KernelRegistrar;
using mindspore::lite::RET_ERROR;
@ -28,8 +29,8 @@ int SwitchCPUKernel::PostProcess() {
auto bool_tensor = in_tensors_.front();
MS_ASSERT(bool_tensor != nullptr);
MS_ASSERT(bool_tensor->data_type() == kNumberTypeBool);
MS_ASSERT(bool_tensor->shape().size() == 1);
MS_ASSERT(bool_tensor->shape().front() == 1);
MS_ASSERT(bool_tensor->Size() == 1);
MS_ASSERT(bool_tensor->Size() == 1);
auto active = static_cast<bool *>(bool_tensor->data_c());
if (active == nullptr) {
MS_LOG(ERROR) << "data of bool tensor is nullptr";
@ -47,7 +48,7 @@ int SwitchCPUKernel::PostProcess() {
int SwitchCPUKernel::Init() { return RET_OK; }
int SwitchCPUKernel::ReSize() { return RET_ERROR; }
int SwitchCPUKernel::ReSize() { return RET_OK; }
// inputs: bool*1 data*n
// output: true-data*n, false-data*n
@ -56,8 +57,8 @@ int SwitchCPUKernel::Run() {
auto bool_tensor = in_tensors_.front();
MS_ASSERT(bool_tensor != nullptr);
MS_ASSERT(bool_tensor->data_type() == kNumberTypeBool);
MS_ASSERT(bool_tensor->shape().size() == 1);
MS_ASSERT(bool_tensor->shape().front() == 1);
MS_ASSERT(bool_tensor->Size() == 1);
MS_ASSERT(bool_tensor->Size() == 1);
auto active = static_cast<bool *>(bool_tensor->data_c());
if (active == nullptr) {
MS_LOG(ERROR) << "data of bool tensor is nullptr";
@ -68,6 +69,14 @@ int SwitchCPUKernel::Run() {
while (in_index < in_tensors_.size()) {
auto in_tensor = in_tensors_.at(in_index++);
auto out_tensor = out_tensors_.at(out_index++);
// copy for tensorlist
if (in_tensor->data_type() == kObjectTypeTensorType) {
auto in_tensor_list = reinterpret_cast<lite::TensorList *>(in_tensor);
auto out_tensor_list = reinterpret_cast<lite::TensorList *>(out_tensor);
*out_tensor_list = *in_tensor_list;
continue;
}
// copy for tensor
MS_ASSERT(in_tensor != nullptr);
MS_ASSERT(out_tensor != nullptr);
auto input = in_tensor->data_c();
@ -111,4 +120,5 @@ kernel::LiteKernel *CpuSwitchKernelCreator(const std::vector<lite::Tensor *> &in
REG_KERNEL(kCPU, kNumberTypeFloat32, PrimitiveType_Switch, CpuSwitchKernelCreator)
REG_KERNEL(kCPU, kNumberTypeBool, PrimitiveType_Switch, CpuSwitchKernelCreator)
REG_KERNEL(kCPU, kNumberTypeInt32, PrimitiveType_Switch, CpuSwitchKernelCreator)
} // namespace mindspore::kernel

1
mindspore/lite/src/runtime/kernel/arm/fp32/arithmetic_fp32.cc
View File

@ -554,6 +554,7 @@ REG_KERNEL(kCPU, kNumberTypeFloat32, PrimitiveType_Mod, CpuArithmeticFp32KernelC
REG_KERNEL(kCPU, kNumberTypeInt32, PrimitiveType_Mod, CpuArithmeticFp32KernelCreator)
REG_KERNEL(kCPU, kNumberTypeFloat32, PrimitiveType_LogicalAnd, CpuArithmeticFp32KernelCreator)
REG_KERNEL(kCPU, kNumberTypeBool, PrimitiveType_LogicalAnd, CpuArithmeticFp32KernelCreator)
REG_KERNEL(kCPU, kNumberTypeInt32, PrimitiveType_LogicalAnd, CpuArithmeticFp32KernelCreator)
REG_KERNEL(kCPU, kNumberTypeFloat32, PrimitiveType_LogicalOr, CpuArithmeticFp32KernelCreator)
REG_KERNEL(kCPU, kNumberTypeFloat32, PrimitiveType_Maximum, CpuArithmeticFp32KernelCreator)
REG_KERNEL(kCPU, kNumberTypeFloat32, PrimitiveType_Minimum, CpuArithmeticFp32KernelCreator)

19
mindspore/lite/src/runtime/kernel/arm/fp32/tensorlist_fromtensor_fp32.cc
View File

@ -59,9 +59,19 @@ int TensorListFromTensorCPUKernel::Init() {
return IsCompatibleShape();
}
int TensorListFromTensorCPUKernel::ReSize() { return RET_OK; }
int TensorListFromTensorCPUKernel::ReSize() {
auto ret = this->Init();
if (ret != RET_OK) {
MS_LOG(ERROR) << "Init kernel failed!";
return ret;
}
return RET_OK;
}
int TensorListFromTensorCPUKernel::Run() {
input0_ = in_tensors_[0]; // row tensor
input1_ = in_tensors_[1]; // element_shape tensor
output0_ = out_tensors_[0];
if (input0_->shape().size() == 0) {
MS_LOG(ERROR) << "input0_->shape().size():" << input0_->shape().size() << " must be greater than 0";
}
@ -114,13 +124,6 @@ kernel::LiteKernel *CpuTensorListFromTensorFp32KernelCreator(const std::vector<l
free(op_parameter);
return nullptr;
}
auto ret = kernel->Init();
if (ret != RET_OK) {
MS_LOG(ERROR) << "Init kernel failed! name: " << op_parameter->name_ << ", type: "
<< schema::EnumNamePrimitiveType(static_cast<schema::PrimitiveType>(op_parameter->type_));
delete kernel;
return nullptr;
}
return kernel;
}

17
mindspore/lite/src/runtime/kernel/arm/fp32/tensorlist_getitem_fp32.cc
View File

@ -70,7 +70,14 @@ int TensorListGetItemCPUKernel::Run() {
return RET_OK;
}
int TensorListGetItemCPUKernel::ReSize() { return RET_OK; }
int TensorListGetItemCPUKernel::ReSize() {
auto ret = this->Init();
if (ret != RET_OK) {
MS_LOG(ERROR) << "Init kernel failed!";
return ret;
}
return RET_OK;
}
kernel::LiteKernel *CpuTensorListGetItemFp32KernelCreator(const std::vector<lite::Tensor *> &inputs,
const std::vector<lite::Tensor *> &outputs,
@ -93,15 +100,9 @@ kernel::LiteKernel *CpuTensorListGetItemFp32KernelCreator(const std::vector<lite
free(op_parameter);
return nullptr;
}
auto ret = kernel->Init();
if (ret != RET_OK) {
MS_LOG(ERROR) << "Init kernel failed! name: " << op_parameter->name_ << ", type: "
<< schema::EnumNamePrimitiveType(static_cast<schema::PrimitiveType>(op_parameter->type_));
delete kernel;
return nullptr;
}
return kernel;
}
REG_KERNEL(kCPU, kNumberTypeFloat32, PrimitiveType_TensorListGetItem, CpuTensorListGetItemFp32KernelCreator)
REG_KERNEL(kCPU, kNumberTypeInt32, PrimitiveType_TensorListGetItem, CpuTensorListGetItemFp32KernelCreator)
} // namespace mindspore::kernel

1
mindspore/lite/src/runtime/kernel/arm/fp32/tensorlist_setitem_fp32.cc
View File

@ -116,4 +116,5 @@ kernel::LiteKernel *CpuTensorListSetItemFp32KernelCreator(const std::vector<lite
}
REG_KERNEL(kCPU, kNumberTypeFloat32, PrimitiveType_TensorListSetItem, CpuTensorListSetItemFp32KernelCreator)
REG_KERNEL(kCPU, kNumberTypeInt32, PrimitiveType_TensorListSetItem, CpuTensorListSetItemFp32KernelCreator)
} // namespace mindspore::kernel

1
mindspore/lite/src/runtime/kernel/arm/fp32/tensorlist_stack_fp32.cc
View File

@ -198,4 +198,5 @@ kernel::LiteKernel *CpuTensorListStackFp32KernelCreator(const std::vector<lite::
}
REG_KERNEL(kCPU, kNumberTypeFloat32, PrimitiveType_TensorListStack, CpuTensorListStackFp32KernelCreator)
REG_KERNEL(kCPU, kNumberTypeInt32, PrimitiveType_TensorListStack, CpuTensorListStackFp32KernelCreator)
} // namespace mindspore::kernel

56
mindspore/lite/src/scheduler.cc
View File

@ -19,6 +19,7 @@
#include <queue>
#include <string>
#include <vector>
#include <algorithm>
#include "src/tensorlist.h"
#include "src/ops/partial.h"
#include "include/errorcode.h"
@ -61,7 +62,7 @@ int Scheduler::Schedule(std::vector<kernel::LiteKernel *> *dst_kernels) {
MS_LOG(ERROR) << "op infer shape failed.";
return ret;
}
ret = ScheduleSubGraphToKernels(kMainSubGraphIndex, dst_kernels);
ret = ScheduleSubGraphToKernels(kMainSubGraphIndex, dst_kernels, nullptr, nullptr);
if (ret != RET_OK) {
MS_LOG(ERROR) << "Schedule main subgraph to kernels failed.";
return ret;
@ -117,6 +118,10 @@ int Scheduler::InferNodeShape(const lite::Model::Node *node, bool *infer_shape_i
}
primitive->set_infer_flag(!(*infer_shape_interrupt));
auto ret = primitive->InferShape(inputs, outputs);
if (ret == RET_INFER_INVALID) {
primitive->set_infer_flag(false);
*infer_shape_interrupt = true;
}
if (ret == RET_OK) {
for (auto &output : outputs) {
if (output->ElementsNum() >= MAX_MALLOC_SIZE / static_cast<int>(sizeof(int64_t))) {
@ -238,15 +243,15 @@ kernel::LiteKernel *Scheduler::SchedulePartialToKernel(const lite::Model::Node *
auto partial_primitive = reinterpret_cast<lite::Partial *>(primitive);
auto sub_graph_index = partial_primitive->GetSubGraphIndex();
std::vector<kernel::LiteKernel *> sub_kernels;
auto ret = ScheduleSubGraphToKernels(sub_graph_index, &sub_kernels);
std::vector<lite::Tensor *> in_tensors;
std::vector<lite::Tensor *> out_tensors;
auto ret = ScheduleSubGraphToKernels(sub_graph_index, &sub_kernels, &in_tensors, &out_tensors);
if (ret != RET_OK) {
MS_LOG(ERROR) << "Schedule partial failed, name: " << src_node->name_;
return nullptr;
}
auto cur_sub_graph_type = mindspore::lite::Scheduler::GetKernelSubGraphType(sub_kernels.front());
// for kernel::LiteKernelUtil::SubgraphInputTensors in CreateSubGraphKernel
FindAllInoutKernels(sub_kernels);
auto subgraph = CreateSubGraphKernel(sub_kernels, cur_sub_graph_type);
auto subgraph = CreateSubGraphKernel(sub_kernels, &in_tensors, &out_tensors, cur_sub_graph_type);
subgraph->set_name("subgraph_" + src_node->name_);
return subgraph;
}
@ -268,7 +273,9 @@ kernel::LiteKernel *Scheduler::ScheduleNodeToKernel(const lite::Model::Node *src
return kernel;
}
int Scheduler::ScheduleSubGraphToKernels(size_t subgraph_index, std::vector<kernel::LiteKernel *> *dst_kernels) {
int Scheduler::ScheduleSubGraphToKernels(size_t subgraph_index, std::vector<kernel::LiteKernel *> *dst_kernels,
std::vector<lite::Tensor *> *in_tensors,
std::vector<lite::Tensor *> *out_tensors) {
MS_ASSERT(src_model_ != nullptr);
MS_ASSERT(!src_model_->sub_graphs_.empty());
MS_ASSERT(src_model_->sub_graphs_.size() > subgraph_index);
@ -294,6 +301,14 @@ int Scheduler::ScheduleSubGraphToKernels(size_t subgraph_index, std::vector<kern
kernel->set_is_model_output(IsContain(graph_output_node_indexes_, size_t(node_index)));
dst_kernels->emplace_back(kernel);
}
if (in_tensors != nullptr) {
std::transform(subgraph->input_indices_.begin(), subgraph->input_indices_.end(), std::back_inserter(*in_tensors),
[&](const uint32_t index) { return this->src_tensors_.at(index); });
}
if (out_tensors != nullptr) {
std::transform(subgraph->output_indices_.begin(), subgraph->output_indices_.end(), std::back_inserter(*out_tensors),
[&](const uint32_t index) { return this->src_tensors_.at(index); });
}
return RET_OK;
}
@ -370,7 +385,7 @@ int Scheduler::ConstructSubGraphs(std::vector<kernel::LiteKernel *> *kernels) {
}
auto cur_sub_graph_type = mindspore::lite::Scheduler::GetKernelSubGraphType(head_kernel);
auto sub_kernels = FindAllSubGraphKernels(head_kernel, &is_kernel_finish);
auto subgraph = CreateSubGraphKernel(sub_kernels, cur_sub_graph_type);
auto subgraph = CreateSubGraphKernel(sub_kernels, nullptr, nullptr, cur_sub_graph_type);
if (subgraph == nullptr) {
MS_LOG(ERROR) << "Create SubGraphKernel failed";
return RET_ERROR;
@ -386,12 +401,14 @@ int Scheduler::ConstructSubGraphs(std::vector<kernel::LiteKernel *> *kernels) {
}
return RET_OK;
}
bool Scheduler::MergeOpIsReady(const kernel::LiteKernel *kernel,
std::map<const kernel::LiteKernel *, bool> is_kernel_finish) {
std::map<const lite::Tensor *, bool> merge_in_tensors_map;
for (auto merge_in_tensor : kernel->in_tensors()) {
merge_in_tensors_map[merge_in_tensor] = false;
if (merge_in_tensor->category() == Tensor::CONST_TENSOR || merge_in_tensor->category() == Tensor::CONST_SCALAR) {
if (merge_in_tensor->category() == Tensor::CONST_TENSOR || merge_in_tensor->category() == Tensor::CONST_SCALAR ||
merge_in_tensor->category() == Tensor::GRAPH_INPUT) {
merge_in_tensors_map[merge_in_tensor] = true;
}
for (auto merge_in_kernel : kernel->in_kernels()) {
@ -410,12 +427,24 @@ bool Scheduler::MergeOpIsReady(const kernel::LiteKernel *kernel,
}
kernel::SubGraphKernel *Scheduler::CreateSubGraphKernel(const std::vector<kernel::LiteKernel *> &kernels,
const std::vector<lite::Tensor *> *in_tensors,
const std::vector<lite::Tensor *> *out_tensors,
kernel::SubGraphType type) {
if (type == kernel::kApuSubGraph) {
return nullptr;
}
std::vector<Tensor *> input_tensors = kernel::LiteKernelUtil::SubgraphInputTensors(kernels);
std::vector<Tensor *> output_tensors = kernel::LiteKernelUtil::SubgraphOutputTensors(kernels);
std::vector<Tensor *> input_tensors;
std::vector<Tensor *> output_tensors;
if (in_tensors != nullptr) {
input_tensors = *in_tensors;
} else {
input_tensors = kernel::LiteKernelUtil::SubgraphInputTensors(kernels);
}
if (out_tensors != nullptr) {
output_tensors = *out_tensors;
} else {
output_tensors = kernel::LiteKernelUtil::SubgraphOutputTensors(kernels);
}
std::vector<kernel::LiteKernel *> input_kernels = kernel::LiteKernelUtil::SubgraphInputNodes(kernels);
std::vector<kernel::LiteKernel *> output_kernels = kernel::LiteKernelUtil::SubgraphOutputNodes(kernels);
if (type == kernel::kGpuSubGraph) {
@ -470,7 +499,12 @@ TypeId Scheduler::GetFirstFp32Fp16OrInt8Type(const std::vector<Tensor *> &in_ten
}
if (dtype == kObjectTypeTensorType) {
auto tensor_list = reinterpret_cast<TensorList *>(tensor);
return tensor_list->tensors_data_type();
auto tensor_list_dtype = tensor_list->data_type();
if (tensor_list_dtype == kNumberTypeFloat32 || tensor_list_dtype == kNumberTypeFloat16 ||
tensor_list_dtype == kNumberTypeInt8 || tensor_list_dtype == kNumberTypeInt32 ||
tensor_list_dtype == kNumberTypeBool) {
return tensor_list_dtype;
}
}
if (dtype == kNumberTypeFloat32 || dtype == kNumberTypeFloat16 || dtype == kNumberTypeInt8 ||
dtype == kNumberTypeInt32 || dtype == kNumberTypeBool) {

5
mindspore/lite/src/scheduler.h
View File

@ -53,7 +53,8 @@ class Scheduler {
// schedule a node to a kernel
kernel::LiteKernel *ScheduleNodeToKernel(const lite::Model::Node *src_node);
// schedule a Model::SubGraph into a vector of kernel and subgraph_kernel
int ScheduleSubGraphToKernels(size_t subgraph_index, std::vector<kernel::LiteKernel *> *dst_kernels);
int ScheduleSubGraphToKernels(size_t subgraph_index, std::vector<kernel::LiteKernel *> *dst_kernels,
std::vector<lite::Tensor *> *in_tensors, std::vector<lite::Tensor *> *out_tensors);
// find in_kernels_ and out_kernels of kernel, sub_graph and nodes_ in sub_graph
static void FindAllInoutKernels(const std::vector<kernel::LiteKernel *> &kernels);
@ -63,6 +64,8 @@ class Scheduler {
// create subgraph_kernel from a vector of kernel
kernel::SubGraphKernel *CreateSubGraphKernel(const std::vector<kernel::LiteKernel *> &kernels,
const std::vector<lite::Tensor *> *in_tensors,
const std::vector<lite::Tensor *> *out_tensors,
kernel::SubGraphType type);
bool MergeOpIsReady(const kernel::LiteKernel *kernel, std::map<const kernel::LiteKernel *, bool> is_kernel_finish);

2
mindspore/lite/src/tensor.h
View File

@ -133,7 +133,7 @@ class Tensor : public mindspore::tensor::MSTensor {
void set_quant_clusters(const std::vector<float> &clusters);
bool IsConst() const {
virtual bool IsConst() const {
return (this->category_ == CONST_TENSOR || this->category_ == CONST_SCALAR) && this->data_ != nullptr;
}

16
mindspore/lite/src/tensorlist.cc
View File

@ -24,8 +24,8 @@
namespace mindspore {
namespace lite {
TensorList::TensorList(std::vector<int> shape, std::vector<int> element_shape)
: Tensor(kObjectTypeTensorType, shape), element_shape_(element_shape) {}
TensorList::TensorList(std::vector<int> shape, std::vector<int> element_shape, Category category)
: Tensor(kObjectTypeTensorType, shape, schema::Format::Format_NHWC, category), element_shape_(element_shape) {}
TensorList::~TensorList() {
if (!this->tensors_.empty()) {
@ -66,6 +66,9 @@ int TensorList::CopyTensorList(const TensorList &src, bool copy_data) {
}
int TensorList::CopyTensorData(const TensorList &src) {
if (src.tensors_.empty()) {
return RET_OK;
}
for (int i = 0; i < this->ElementsNum(); ++i) {
if (src.tensors_[i] == nullptr) {
MS_LOG(ERROR) << "src tensors_[" << i << "] is nullptr!";
@ -115,8 +118,14 @@ int TensorList::MallocTensorListData(TypeId dtype, const std::vector<std::vector
}
int TensorList::MallocData(const mindspore::lite::Allocator *allocator) {
if (allocator != nullptr) {
allocator_ = const_cast<mindspore::lite::Allocator *>(allocator);
}
// malloc data buf of each tensor in tensors_
for (int i = 0; i < this->ElementsNum(); ++i) {
if (tensors_.empty()) {
return RET_OK;
}
auto tensor_ptr = this->tensors_[i];
if (tensor_ptr == nullptr) {
MS_LOG(ERROR) << "tensors_[" << i << "] is nullptr!";
@ -252,5 +261,8 @@ STATUS TensorList::Decode(const int *data) {
}
return RET_OK;
}
bool TensorList::IsConst() const { return this->category_ == CONST_TENSOR || this->category_ == CONST_SCALAR; }
} // namespace lite
} // namespace mindspore

4
mindspore/lite/src/tensorlist.h
View File

@ -60,7 +60,7 @@ class TensorList : public Tensor {
public:
TensorList() = default;
TensorList(std::vector<int> shape, std::vector<int> element_shape);
TensorList(std::vector<int> shape, std::vector<int> element_shape, Category category = VAR);
~TensorList() override;
@ -114,6 +114,8 @@ class TensorList : public Tensor {
STATUS Decode(const int *data);
bool IsConst() const override;
protected:
// The following functions must be masked.
void set_data(void *data) override { return; }

2
mindspore/lite/tools/converter/parser/tf/tf_util.cc
View File

@ -125,7 +125,7 @@ std::string TensorFlowUtils::GetFlattenNodeName(const std::string &input_name) {
if (input_splits[2] == "0") {
ret = input_splits[0];
} else {
ret = input_splits[0] + input_splits[2]; // multi output node
ret = input_splits[0] + ":" + input_splits[2]; // multi output node
}
}
return ret;