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

!4870 add UnPack method in ops & remove anf_importer populater 

Merge pull request !4870 from hangq/primitive
This commit is contained in:
mindspore-ci-bot 2020-08-23 10:57:32 +08:00 committed by Gitee
parent 07a75658bf 28e3508718
commit dde257592b
202 changed files with 1967 additions and 2555 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
mindspore/lite/CMakeLists.txt
View File

@ -6,7 +6,7 @@ if (CMAKE_CXX_COMPILER_ID STREQUAL "GNU" AND CMAKE_CXX_COMPILER_VERSION VERSION_
endif ()
set(MS_VERSION_MAJOY 0)
set(MS_VERSION_MINOR 6)
set(MS_VERSION_MINOR 7)
set(MS_VERSION_REVISION 0)
set(DIR_PREFIX mindspore-lite)

12
mindspore/lite/java/build_aar.sh
View File

@ -5,13 +5,13 @@ BASE_PATH=$(cd "$(dirname $0)"; pwd)
TOP_PATH="${BASE_PATH}/../../.."
# build mindspore-lite arm64
cd ${TOP_PATH}
#bash build.sh -I arm64
#COMPILE_RET=$?
bash build.sh -I arm64
COMPILE_RET=$?
#if [[ "${COMPILE_RET}" -ne 0 ]]; then
# echo "---------------- mindspore lite: build failed ----------------"
# exit
#fi
if [[ "${COMPILE_RET}" -ne 0 ]]; then
echo "---------------- mindspore lite: build failed ----------------"
exit
fi
# copy arm64 so
cd ${TOP_PATH}/output/

2
mindspore/lite/java/native/CMakeLists.txt
View File

@ -2,7 +2,7 @@ cmake_minimum_required(VERSION 3.14)
project (Lite-java)
set(MS_VERSION_MAJOY 0)
set(MS_VERSION_MINOR 6)
set(MS_VERSION_MINOR 7)
set(MS_VERSION_REVISION 0)
set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -DMS_VERSION_MAJOY=${MS_VERSION_MAJOY} -DMS_VERSION_MINOR=${MS_VERSION_MINOR} -DMS_VERSION_REVISION=${MS_VERSION_REVISION}")
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DMS_VERSION_MAJOY=${MS_VERSION_MAJOY} -DMS_VERSION_MINOR=${MS_VERSION_MINOR} -DMS_VERSION_REVISION=${MS_VERSION_REVISION}")

1
mindspore/lite/src/common/graph_util.cc
View File

@ -32,6 +32,7 @@ std::vector<size_t> GetGraphInputNodes(const schema::MetaGraph *meta_graph) {
for (size_t j = 0; j < meta_graph->nodes()->size(); j++) {
auto *cNode = meta_graph->nodes()->GetAs<schema::CNode>(j);
MS_ASSERT(nullptr != cNode);
MS_ASSERT(nullptr != cNode->inputIndex());
for (size_t k = 0; k < cNode->inputIndex()->size(); k++) {
if (cNode->inputIndex()->GetAs<uint32_t>(k) == input_index) {
if (!IsContain<size_t>(ret, j)) {

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

@ -53,6 +53,7 @@ int Executor::Run(std::vector<tensor::Tensor *> &in_tensors, std::vector<tensor:
MS_LOG(ERROR) << "run kernel failed, name: " << kernel->name();
return ret;
}
if (after != nullptr) {
if (!after(PackToMSTensors(kernel->in_tensors()), PackToMSTensors(kernel->out_tensors()),
{kernel->name(), kernel->type_str()})) {

182
mindspore/lite/src/model.cc
View File

@ -188,186 +188,6 @@ void ModelImpl::FreeMetaGraph() {
const schema::MetaGraph *ModelImpl::meta_graph() const { return this->meta_graph_; }
PrimitiveC *ModelImpl::CopyPrimitive(const schema::Primitive *src_prim) {
MS_EXCEPTION_IF_NULL(src_prim);
auto op_type = src_prim->value_type();
switch (op_type) {
case schema::PrimitiveType_SoftMax:
return new SoftMax(const_cast<schema::Primitive *>(src_prim));
case schema::PrimitiveType_Activation:
return new Activation(const_cast<schema::Primitive *>(src_prim));
case schema::PrimitiveType_Conv2D:
return new Conv2D(const_cast<schema::Primitive *>(src_prim));
case schema::PrimitiveType_DeConv2D:
return new DeConv2D(const_cast<schema::Primitive *>(src_prim));
case schema::PrimitiveType_Reduce:
return new Reduce(const_cast<schema::Primitive *>(src_prim));
case schema::PrimitiveType_Pooling:
return new Pooling(const_cast<schema::Primitive *>(src_prim));
case schema::PrimitiveType_DepthwiseConv2D:
return new DepthwiseConv2D(const_cast<schema::Primitive *>(src_prim));
case schema::PrimitiveType_FusedBatchNorm:
return new FusedBatchNorm(const_cast<schema::Primitive *>(src_prim));
case schema::PrimitiveType_BatchNorm:
return new BatchNorm(const_cast<schema::Primitive *>(src_prim));
case schema::PrimitiveType_FullConnection:
return new FullConnection(const_cast<schema::Primitive *>(src_prim));
case schema::PrimitiveType_Power:
return new Power(const_cast<schema::Primitive *>(src_prim));
case schema::PrimitiveType_Range:
return new Range(const_cast<schema::Primitive *>(src_prim));
case schema::PrimitiveType_Mul:
return new Mul(const_cast<schema::Primitive *>(src_prim));
case schema::PrimitiveType_Add:
return new Add(const_cast<schema::Primitive *>(src_prim));
case schema::PrimitiveType_Sub:
return new Sub(const_cast<schema::Primitive *>(src_prim));
case schema::PrimitiveType_Div:
return new Div(const_cast<schema::Primitive *>(src_prim));
case schema::PrimitiveType_BiasAdd:
return new BiasAdd(const_cast<schema::Primitive *>(src_prim));
case schema::PrimitiveType_ExpandDims:
return new ExpandDims(const_cast<schema::Primitive *>(src_prim));
case schema::PrimitiveType_ArgMax:
return new ArgMax(const_cast<schema::Primitive *>(src_prim));
case schema::PrimitiveType_ArgMin:
return new ArgMin(const_cast<schema::Primitive *>(src_prim));
case schema::PrimitiveType_Cast:
return new Cast(const_cast<schema::Primitive *>(src_prim));
case schema::PrimitiveType_Reshape:
return new Reshape(const_cast<schema::Primitive *>(src_prim));
case schema::PrimitiveType_Scale:
return new Scale(const_cast<schema::Primitive *>(src_prim));
case schema::PrimitiveType_Eltwise:
return new Eltwise(const_cast<schema::Primitive *>(src_prim));
case schema::PrimitiveType_Concat:
return new Concat(const_cast<schema::Primitive *>(src_prim));
case schema::PrimitiveType_Fill:
return new Fill(const_cast<schema::Primitive *>(src_prim));
case schema::PrimitiveType_Transpose:
return new Transpose(const_cast<schema::Primitive *>(src_prim));
case schema::PrimitiveType_Slice:
return new SliceOp(const_cast<schema::Primitive *>(src_prim));
case schema::PrimitiveType_Squeeze:
return new Squeeze(const_cast<schema::Primitive *>(src_prim));
case schema::PrimitiveType_Nchw2Nhwc:
return new Nchw2Nhwc(const_cast<schema::Primitive *>(src_prim));
case schema::PrimitiveType_Nhwc2Nchw:
return new Nhwc2Nchw(const_cast<schema::Primitive *>(src_prim));
case schema::PrimitiveType_Flatten:
return new Flatten(const_cast<schema::Primitive *>(src_prim));
case schema::PrimitiveType_Mean:
return new Mean(const_cast<schema::Primitive *>(src_prim));
case schema::PrimitiveType_Stack:
return new Stack(const_cast<schema::Primitive *>(src_prim));
case schema::PrimitiveType_Crop:
return new Crop(const_cast<schema::Primitive *>(src_prim));
case schema::PrimitiveType_SquaredDifference:
return new SquaredDifference(const_cast<schema::Primitive *>(src_prim));
case schema::PrimitiveType_AddN:
return new AddN(const_cast<schema::Primitive *>(src_prim));
case schema::PrimitiveType_Abs:
return new Abs(const_cast<schema::Primitive *>(src_prim));
case schema::PrimitiveType_Sin:
return new Sin(const_cast<schema::Primitive *>(src_prim));
case schema::PrimitiveType_Cos:
return new Cos(const_cast<schema::Primitive *>(src_prim));
case schema::PrimitiveType_Log:
return new Log(const_cast<schema::Primitive *>(src_prim));
case schema::PrimitiveType_Sqrt:
return new Sqrt(const_cast<schema::Primitive *>(src_prim));
case schema::PrimitiveType_Rsqrt:
return new Rsqrt(const_cast<schema::Primitive *>(src_prim));
case schema::PrimitiveType_Square:
return new Square(const_cast<schema::Primitive *>(src_prim));
case schema::PrimitiveType_Exp:
return new Exp(const_cast<schema::Primitive *>(src_prim));
case schema::PrimitiveType_Gather:
return new Gather(const_cast<schema::Primitive *>(src_prim));
case schema::PrimitiveType_GatherNd:
return new GatherNd(const_cast<schema::Primitive *>(src_prim));
case schema::PrimitiveType_LocalResponseNormalization:
return new LocalResponseNormalization(const_cast<schema::Primitive *>(src_prim));
case schema::PrimitiveType_Maximum:
return new Maximum(const_cast<schema::Primitive *>(src_prim));
case schema::PrimitiveType_Minimum:
return new Minimum(const_cast<schema::Primitive *>(src_prim));
case schema::PrimitiveType_Pad:
return new Pad(const_cast<schema::Primitive *>(src_prim));
case schema::PrimitiveType_StridedSlice:
return new StridedSlice(const_cast<schema::Primitive *>(src_prim));
case schema::PrimitiveType_Prelu:
return new Prelu(const_cast<schema::Primitive *>(src_prim));
case schema::PrimitiveType_CaffePReLU:
return new CaffePReLU(const_cast<schema::Primitive *>(src_prim));
case schema::PrimitiveType_Round:
return new Round(const_cast<schema::Primitive *>(src_prim));
case schema::PrimitiveType_Reverse:
return new Reverse(const_cast<schema::Primitive *>(src_prim));
case schema::PrimitiveType_ReverseSequence:
return new ReverseSequence(const_cast<schema::Primitive *>(src_prim));
case schema::PrimitiveType_LogicalAnd:
return new LogicalAnd(const_cast<schema::Primitive *>(src_prim));
case schema::PrimitiveType_LogicalOr:
return new LogicalOr(const_cast<schema::Primitive *>(src_prim));
case schema::PrimitiveType_LogicalNot:
return new LogicalNot(const_cast<schema::Primitive *>(src_prim));
case schema::PrimitiveType_FloorDiv:
return new FloorDiv(const_cast<schema::Primitive *>(src_prim));
case schema::PrimitiveType_FloorMod:
return new FloorMod(const_cast<schema::Primitive *>(src_prim));
case schema::PrimitiveType_Equal:
return new Equal(const_cast<schema::Primitive *>(src_prim));
case schema::PrimitiveType_NotEqual:
return new NotEqual(const_cast<schema::Primitive *>(src_prim));
case schema::PrimitiveType_Less:
return new Less(const_cast<schema::Primitive *>(src_prim));
case schema::PrimitiveType_LessEqual:
return new LessEqual(const_cast<schema::Primitive *>(src_prim));
case schema::PrimitiveType_Greater:
return new Greater(const_cast<schema::Primitive *>(src_prim));
case schema::PrimitiveType_GreaterEqual:
return new GreaterEqual(const_cast<schema::Primitive *>(src_prim));
case schema::PrimitiveType_Floor:
return new Floor(const_cast<schema::Primitive *>(src_prim));
case schema::PrimitiveType_Ceil:
return new Ceil(const_cast<schema::Primitive *>(src_prim));
case schema::PrimitiveType_Split:
return new Split(const_cast<schema::Primitive *>(src_prim));
case schema::PrimitiveType_OneHot:
return new OneHot(const_cast<schema::Primitive *>(src_prim));
case schema::PrimitiveType_SpaceToDepth:
return new SpaceToDepth(const_cast<schema::Primitive *>(src_prim));
case schema::PrimitiveType_Tile:
return new Tile(const_cast<schema::Primitive *>(src_prim));
case schema::PrimitiveType_Resize:
return new Resize(const_cast<schema::Primitive *>(src_prim));
case schema::PrimitiveType_Unstack:
return new Unstack(const_cast<schema::Primitive *>(src_prim));
case schema::PrimitiveType_Unique:
return new Unique(const_cast<schema::Primitive *>(src_prim));
case schema::PrimitiveType_TopK:
return new TopK(const_cast<schema::Primitive *>(src_prim));
case schema::PrimitiveType_MatMul:
return new MatMul(const_cast<schema::Primitive *>(src_prim));
case schema::PrimitiveType_QuantDTypeCast:
return new QuantDTypeCast(const_cast<schema::Primitive *>(src_prim));
case schema::PrimitiveType_EmbeddingLookup:
return new EmbeddingLookup(const_cast<schema::Primitive *>(src_prim));
case schema::PrimitiveType_Elu:
return new Elu(const_cast<schema::Primitive *>(src_prim));
case schema::PrimitiveType_DeDepthwiseConv2D:
return new DeDepthwiseConv2D(const_cast<schema::Primitive *>(src_prim));
case schema::PrimitiveType_Shape:
return new Shape(const_cast<schema::Primitive *>(src_prim));
case schema::PrimitiveType_Unsqueeze:
return new Unsqueeze(const_cast<schema::Primitive *>(src_prim));
default:
break;
}
return nullptr;
}
int ModelImpl::BuildOps() {
if (this->meta_graph_ == nullptr) {
MS_LOG(ERROR) << "mete_graph is nullptr";
@ -379,7 +199,7 @@ int ModelImpl::BuildOps() {
auto name = cNode->name()->str();
auto srcPrim = cNode->primitive();
this->ops_[name] = CopyPrimitive(srcPrim);
this->ops_[name] = PrimitiveC::UnPackFromSchemaPrimitive(const_cast<schema::Primitive *>(srcPrim));
}
return 0;
}

4
mindspore/lite/src/ops/abs.h
View File

@ -33,9 +33,11 @@ namespace lite {
class Abs : public ArithmeticSelf {
public:
#ifdef PRIMITIVE_WRITEABLE
Abs() = default;
explicit Abs(schema::PrimitiveT *primitive) : ArithmeticSelf(primitive) {}
#endif
#else
explicit Abs(schema::Primitive *primitive) : ArithmeticSelf(primitive) {}
#endif
};
} // namespace lite
} // namespace mindspore

16
mindspore/lite/src/ops/activation.cc
View File

@ -15,6 +15,7 @@
*/
#include "src/ops/activation.h"
#include <memory>
namespace mindspore {
namespace lite {
@ -25,6 +26,21 @@ float Activation::GetAlpha() const { return this->primitive_->value.AsActivation
void Activation::SetType(int type) { this->primitive_->value.AsActivation()->type = (schema::ActivationType)type; }
void Activation::SetAlpha(float alpha) { this->primitive_->value.AsActivation()->alpha = alpha; }
int Activation::UnPackAttr(const Primitive &prim, const std::vector<AnfNodePtr> &inputs) {
this->primitive_ = new (schema::PrimitiveT);
auto attr = std::make_unique<schema::ActivationT>();
if (prim.name() == "ReLU") {
attr->type = schema::ActivationType_RELU;
} else if (prim.name() == "Sigmoid") {
attr->type = schema::ActivationType_SIGMOID;
} else if (prim.name() == "ReLU6") {
attr->type = schema::ActivationType_RELU6;
}
this->primitive_->value.type = schema::PrimitiveType_Activation;
this->primitive_->value.value = attr.release();
return RET_OK;
}
#else
int Activation::GetType() const { return this->primitive_->value_as_Activation()->type(); }

5
mindspore/lite/src/ops/activation.h
View File

@ -27,9 +27,12 @@ namespace lite {
class Activation : public PrimitiveC {
public:
#ifdef PRIMITIVE_WRITEABLE
Activation() = default;
explicit Activation(schema::PrimitiveT *primitive) : PrimitiveC(primitive) {}
#endif
int UnPackAttr(const Primitive &prim, const std::vector<AnfNodePtr> &inputs);
#else
explicit Activation(schema::Primitive *primitive) : PrimitiveC(primitive) {}
#endif
int GetType() const;
float GetAlpha() const;
void SetType(int type);

5
mindspore/lite/src/ops/activation_grad.h
View File

@ -28,10 +28,11 @@ namespace lite {
class ActivationGrad : public PrimitiveC {
public:
#ifdef PRIMITIVE_WRITEABLE
ActivationGrad() = default;
explicit ActivationGrad(schema::PrimitiveT *primitive) : PrimitiveC(primitive) {}
#endif
#else
explicit ActivationGrad(schema::Primitive *primitive) : PrimitiveC(primitive) {}
#endif
int GetType() const;
void SetType(int type);
};

24
mindspore/lite/src/ops/add.cc
View File

@ -15,6 +15,7 @@
*/
#include "src/ops/add.h"
#include <memory>
namespace mindspore {
namespace lite {
@ -25,6 +26,29 @@ void Add::SetActivationType(int activation_type) {
this->primitive_->value.AsAdd()->activationType = (schema::ActivationType)activation_type;
}
int Add::UnPackAttr(const Primitive &prim, const std::vector<AnfNodePtr> &inputs) {
if (this->primitive_ == nullptr) {
this->primitive_ = new (std::nothrow) schema::PrimitiveT;
if (this->primitive_ == nullptr) {
MS_LOG(ERROR) << "new primitiveT failed";
return RET_ERROR;
}
this->primitive_->value.type = schema::PrimitiveType_Add;
}
if (this->primitive_->value.type != schema::PrimitiveType_Add) {
MS_LOG(ERROR) << "Primitive type should be add";
return RET_ERROR;
}
if (this->primitive_->value.value == nullptr) {
this->primitive_->value.value = new (std::nothrow) schema::AddT();
if (this->primitive_->value.value == nullptr) {
MS_LOG(ERROR) << "new primitiveT value failed";
return RET_ERROR;
}
}
return RET_OK;
}
#else
int Add::GetActivationType() const { return this->primitive_->value_as_Add()->activationType(); }

6
mindspore/lite/src/ops/add.h
View File

@ -33,10 +33,12 @@ namespace lite {
class Add : public Arithmetic {
public:
#ifdef PRIMITIVE_WRITEABLE
Add() = default;
explicit Add(schema::PrimitiveT *primitive) : Arithmetic(primitive) {}
#endif
int UnPackAttr(const Primitive &prim, const std::vector<AnfNodePtr> &inputs);
#else
explicit Add(schema::Primitive *primitive) : Arithmetic(primitive) {}
#endif
int GetActivationType() const;
void SetActivationType(int activation_type);
};

4
mindspore/lite/src/ops/addn.h
View File

@ -28,9 +28,11 @@ namespace lite {
class AddN : public PrimitiveC {
public:
#ifdef PRIMITIVE_WRITEABLE
AddN() = default;
explicit AddN(schema::PrimitiveT *primitive) : PrimitiveC(primitive) {}
#endif
#else
explicit AddN(schema::Primitive *primitive) : PrimitiveC(primitive) {}
#endif
int InferShape(std::vector<lite::tensor::Tensor *> inputs_, std::vector<lite::tensor::Tensor *> outputs_) override;
int GetN() const;
void SetN(int n);

5
mindspore/lite/src/ops/argmax.h
View File

@ -28,10 +28,11 @@ namespace lite {
class ArgMax : public PrimitiveC {
public:
#ifdef PRIMITIVE_WRITEABLE
ArgMax() = default;
explicit ArgMax(schema::PrimitiveT *primitive) : PrimitiveC(primitive) {}
#endif
#else
explicit ArgMax(schema::Primitive *primitive) : PrimitiveC(primitive) {}
#endif
int InferShape(std::vector<lite::tensor::Tensor *> inputs_, std::vector<lite::tensor::Tensor *> outputs_) override;
int GetAxis() const;
bool GetOutMaxValue() const;

5
mindspore/lite/src/ops/argmin.h
View File

@ -28,10 +28,11 @@ namespace lite {
class ArgMin : public PrimitiveC {
public:
#ifdef PRIMITIVE_WRITEABLE
ArgMin() = default;
explicit ArgMin(schema::PrimitiveT *primitive) : PrimitiveC(primitive) {}
#endif
#else
explicit ArgMin(schema::Primitive *primitive) : PrimitiveC(primitive) {}
#endif
int InferShape(std::vector<lite::tensor::Tensor *> inputs_, std::vector<lite::tensor::Tensor *> outputs_) override;
int GetAxis() const;
bool GetOutMaxValue() const;

5
mindspore/lite/src/ops/arithmetic.h
View File

@ -28,10 +28,11 @@ namespace lite {
class Arithmetic : public PrimitiveC {
public:
#ifdef PRIMITIVE_WRITEABLE
Arithmetic() = default;
explicit Arithmetic(schema::PrimitiveT *primitive) : PrimitiveC(primitive) {}
#endif
#else
explicit Arithmetic(schema::Primitive *primitive) : PrimitiveC(primitive) {}
#endif
int InferShape(std::vector<lite::tensor::Tensor *> inputs_, std::vector<lite::tensor::Tensor *> outputs_) override;
bool Broadcasting() { return this->broadcasting_; }
int NDims() { return this->ndim_; }

5
mindspore/lite/src/ops/arithmetic_self.h
View File

@ -25,10 +25,11 @@ namespace lite {
class ArithmeticSelf : public PrimitiveC {
public:
#ifdef PRIMITIVE_WRITEABLE
ArithmeticSelf() = default;
explicit ArithmeticSelf(schema::PrimitiveT *primitive) : PrimitiveC(primitive) {}
#endif
#else
explicit ArithmeticSelf(schema::Primitive *primitive) : PrimitiveC(primitive) {}
#endif
int InferShape(std::vector<lite::tensor::Tensor *> inputs_, std::vector<lite::tensor::Tensor *> outputs_) override;
};
} // namespace lite

11
mindspore/lite/src/ops/batch_norm.cc
View File

@ -15,7 +15,7 @@
*/
#include "src/ops/batch_norm.h"
#include <memory>
namespace mindspore {
namespace lite {
#ifdef PRIMITIVE_WRITEABLE
@ -23,6 +23,15 @@ float BatchNorm::GetEpsilon() const { return this->primitive_->value.AsBatchNorm
void BatchNorm::SetEpsilon(float epsilon) { this->primitive_->value.AsBatchNorm()->epsilon = epsilon; }
int BatchNorm::UnPackAttr(const Primitive &prim, const std::vector<AnfNodePtr> &inputs) {
this->primitive_ = new (schema::PrimitiveT);
auto attr = std::make_unique<schema::FusedBatchNormT>();
attr->epsilon = GetValue<float>(prim.GetAttr("epsilon"));
this->primitive_->value.type = schema::PrimitiveType_FusedBatchNorm;
this->primitive_->value.value = attr.release();
return RET_OK;
}
#else
float BatchNorm::GetEpsilon() const { return this->primitive_->value_as_BatchNorm()->epsilon(); }

6
mindspore/lite/src/ops/batch_norm.h
View File

@ -28,10 +28,12 @@ namespace lite {
class BatchNorm : public PrimitiveC {
public:
#ifdef PRIMITIVE_WRITEABLE
BatchNorm() = default;
explicit BatchNorm(schema::PrimitiveT *primitive) : PrimitiveC(primitive) {}
#endif
int UnPackAttr(const Primitive &prim, const std::vector<AnfNodePtr> &inputs);
#else
explicit BatchNorm(schema::Primitive *primitive) : PrimitiveC(primitive) {}
#endif
float GetEpsilon() const;
void SetEpsilon(float epsilon);
};

5
mindspore/lite/src/ops/batch_to_space.h
View File

@ -28,10 +28,11 @@ namespace lite {
class BatchToSpace : public PrimitiveC {
public:
#ifdef PRIMITIVE_WRITEABLE
BatchToSpace() = default;
explicit BatchToSpace(schema::PrimitiveT *primitive) : PrimitiveC(primitive) {}
#endif
#else
explicit BatchToSpace(schema::Primitive *primitive) : PrimitiveC(primitive) {}
#endif
int InferShape(std::vector<lite::tensor::Tensor *> inputs_, std::vector<lite::tensor::Tensor *> outputs_) override;
std::vector<int> GetBlockShape() const;
std::vector<int> GetCrops() const;

11
mindspore/lite/src/ops/bias_add.cc
View File

@ -15,6 +15,7 @@
*/
#include "src/ops/bias_add.h"
#include <memory>
namespace mindspore {
namespace lite {
@ -23,6 +24,16 @@ std::vector<int> BiasAdd::GetAxis() const { return this->primitive_->value.AsBia
void BiasAdd::SetAxis(const std::vector<int> &axis) { this->primitive_->value.AsBiasAdd()->axis = axis; }
int BiasAdd::UnPackAttr(const Primitive &prim, const std::vector<AnfNodePtr> &inputs) {
this->primitive_ = new (schema::PrimitiveT);
auto attr = std::make_unique<schema::BiasAddT>();
attr->axis = {0};
this->primitive_->value.type = schema::PrimitiveType_BiasAdd;
this->primitive_->value.value = attr.release();
return RET_OK;
}
#else
std::vector<int> BiasAdd::GetAxis() const {

6
mindspore/lite/src/ops/bias_add.h
View File

@ -28,10 +28,12 @@ namespace lite {
class BiasAdd : public PrimitiveC {
public:
#ifdef PRIMITIVE_WRITEABLE
BiasAdd() = default;
explicit BiasAdd(schema::PrimitiveT *primitive) : PrimitiveC(primitive) {}
#endif
int UnPackAttr(const Primitive &prim, const std::vector<AnfNodePtr> &inputs);
#else
explicit BiasAdd(schema::Primitive *primitive) : PrimitiveC(primitive) {}
#endif
std::vector<int> GetAxis() const;
void SetAxis(const std::vector<int> &axis);
};

5
mindspore/lite/src/ops/bias_grad.h
View File

@ -28,10 +28,11 @@ namespace lite {
class BiasGrad : public PrimitiveC {
public:
#ifdef PRIMITIVE_WRITEABLE
BiasGrad() = default;
explicit BiasGrad(schema::PrimitiveT *primitive) : PrimitiveC(primitive) {}
#endif
#else
explicit BiasGrad(schema::Primitive *primitive) : PrimitiveC(primitive) {}
#endif
std::vector<int> GetAxis() const;
void SetAxis(const std::vector<int> &axis);
};

5
mindspore/lite/src/ops/bn_grad_input.h
View File

@ -28,10 +28,11 @@ namespace lite {
class BNGradInput : public PrimitiveC {
public:
#ifdef PRIMITIVE_WRITEABLE
BNGradInput() = default;
explicit BNGradInput(schema::PrimitiveT *primitive) : PrimitiveC(primitive) {}
#endif
#else
explicit BNGradInput(schema::Primitive *primitive) : PrimitiveC(primitive) {}
#endif
float GetEps() const;
int GetChannels() const;
void SetEps(float eps);

5
mindspore/lite/src/ops/broadcast_to.h
View File

@ -28,10 +28,11 @@ namespace lite {
class BroadcastTo : public PrimitiveC {
public:
#ifdef PRIMITIVE_WRITEABLE
BroadcastTo() = default;
explicit BroadcastTo(schema::PrimitiveT *primitive) : PrimitiveC(primitive) {}
#endif
#else
explicit BroadcastTo(schema::Primitive *primitive) : PrimitiveC(primitive) {}
#endif
int InferShape(std::vector<lite::tensor::Tensor *> inputs_, std::vector<lite::tensor::Tensor *> outputs_) override;
std::vector<int> GetDstShape() const;
void SetDstShape(const std::vector<int> &dst_shape);

5
mindspore/lite/src/ops/caffe_p_relu.h
View File

@ -28,10 +28,11 @@ namespace lite {
class CaffePReLU : public Activation {
public:
#ifdef PRIMITIVE_WRITEABLE
CaffePReLU() = default;
explicit CaffePReLU(schema::PrimitiveT *primitive) : Activation(primitive) {}
#endif
#else
explicit CaffePReLU(schema::Primitive *primitive) : Activation(primitive) {}
#endif
bool GetChannelShared() const;
void SetChannelShared(bool channel_shared);
};

5
mindspore/lite/src/ops/cast.h
View File

@ -28,10 +28,11 @@ namespace lite {
class Cast : public PrimitiveC {
public:
#ifdef PRIMITIVE_WRITEABLE
Cast() = default;
explicit Cast(schema::PrimitiveT *primitive) : PrimitiveC(primitive) {}
#endif
#else
explicit Cast(schema::Primitive *primitive) : PrimitiveC(primitive) {}
#endif
int InferShape(std::vector<lite::tensor::Tensor *> inputs_, std::vector<lite::tensor::Tensor *> outputs_) override;
int GetSrcT() const;
int GetDstT() const;

4
mindspore/lite/src/ops/ceil.h
View File

@ -28,9 +28,11 @@ namespace lite {
class Ceil : public ArithmeticSelf {
public:
#ifdef PRIMITIVE_WRITEABLE
Ceil() = default;
explicit Ceil(schema::PrimitiveT *primitive) : ArithmeticSelf(primitive) {}
#endif
#else
explicit Ceil(schema::Primitive *primitive) : ArithmeticSelf(primitive) {}
#endif
};
} // namespace lite
} // namespace mindspore

5
mindspore/lite/src/ops/clip.h
View File

@ -28,10 +28,11 @@ namespace lite {
class Clip : public PrimitiveC {
public:
#ifdef PRIMITIVE_WRITEABLE
Clip() = default;
explicit Clip(schema::PrimitiveT *primitive) : PrimitiveC(primitive) {}
#endif
#else
explicit Clip(schema::Primitive *primitive) : PrimitiveC(primitive) {}
#endif
float GetMax() const;
float GetMin() const;
void SetMax(float max);

12
mindspore/lite/src/ops/concat.cc
View File

@ -15,9 +15,11 @@
*/
#include "src/ops/concat.h"
#include <memory>
#include "include/errorcode.h"
#include "utils/log_adapter.h"
#include "src/ir/tensor.h"
namespace mindspore {
namespace lite {
#ifdef PRIMITIVE_WRITEABLE
@ -27,6 +29,16 @@ int Concat::GetN() const { return this->primitive_->value.AsConcat()->n; }
void Concat::SetAxis(int axis) { this->primitive_->value.AsConcat()->axis = axis; }
void Concat::SetN(int n) { this->primitive_->value.AsConcat()->n = n; }
int Concat::UnPackAttr(const Primitive &prim, const std::vector<AnfNodePtr> &inputs) {
this->primitive_ = new (schema::PrimitiveT);
auto attr = std::make_unique<schema::ConcatT>();
auto prim_axis = GetValue<int>(prim.GetAttr("axis"));
attr->axis = prim_axis;
this->primitive_->value.type = schema::PrimitiveType_Concat;
this->primitive_->value.value = attr.release();
return RET_OK;
}
#else
int Concat::GetAxis() const { return this->primitive_->value_as_Concat()->axis(); }

6
mindspore/lite/src/ops/concat.h
View File

@ -28,10 +28,12 @@ namespace lite {
class Concat : public PrimitiveC {
public:
#ifdef PRIMITIVE_WRITEABLE
Concat() = default;
explicit Concat(schema::PrimitiveT *primitive) : PrimitiveC(primitive) {}
#endif
int UnPackAttr(const Primitive &prim, const std::vector<AnfNodePtr> &inputs);
#else
explicit Concat(schema::Primitive *primitive) : PrimitiveC(primitive) {}
#endif
int InferShape(std::vector<lite::tensor::Tensor *> inputs_, std::vector<lite::tensor::Tensor *> outputs_) override;
int GetAxis() const;
int GetN() const;

4
mindspore/lite/src/ops/constant_of_shape.h
View File

@ -28,9 +28,11 @@ namespace lite {
class ConstantOfShape : public PrimitiveC {
public:
#ifdef PRIMITIVE_WRITEABLE
ConstantOfShape() = default;
explicit ConstantOfShape(schema::PrimitiveT *primitive) : PrimitiveC(primitive) {}
#endif
#else
explicit ConstantOfShape(schema::Primitive *primitive) : PrimitiveC(primitive) {}
#endif
int InferShape(std::vector<lite::tensor::Tensor *> inputs_, std::vector<lite::tensor::Tensor *> outputs_) override;
float GetValue() const;
void SetValue(float value);

264
mindspore/lite/src/ops/conv2d.cc
View File

@ -15,9 +15,14 @@
*/
#include "src/ops/conv2d.h"
#include <string>
#include <memory>
#include "include/errorcode.h"
#include "utils/log_adapter.h"
#include "src/ir/tensor.h"
#ifdef PRIMITIVE_WRITEABLE
#include "tools/converter/quantizer/quantize_util.h"
#endif
namespace mindspore {
namespace lite {
@ -63,6 +68,265 @@ void Conv2D::SetHasBias(bool has_bias) { this->primitive_->value.AsConv2D()->has
void Conv2D::SetActivationType(int activation_type) {
this->primitive_->value.AsConv2D()->activationType = (schema::ActivationType)activation_type;
}
template <typename T>
void ConvertConvWeight(const ParameterPtr &param_node) {
MS_ASSERT(param_node != nullptr);
auto param = param_node->default_param();
auto weight = std::dynamic_pointer_cast<ParamValueLite>(param);
MS_ASSERT(weight != nullptr);
std::unique_ptr<T> buf(new (std::nothrow) T[weight->tensor_shape_size()]);
if (buf == nullptr) {
MS_LOG(ERROR) << "new buf failed";
return;
}
size_t filter_k = weight->tensor_shape()[0];
size_t filter_c = weight->tensor_shape()[1];
size_t filter_h = weight->tensor_shape()[2];
size_t filter_w = weight->tensor_shape()[3];
T *p1Buff = nullptr;
T *p2Buff = nullptr;
for (size_t k = 0; k < filter_k; ++k) {
for (size_t c = 0; c < filter_c; ++c) {
for (size_t h = 0; h < filter_h; ++h) {
for (size_t w = 0; w < filter_w; ++w) {
p1Buff = reinterpret_cast<float *>(weight->tensor_addr()) +
((k * filter_c * filter_h * filter_w) + (c * filter_h * filter_w) + (h * filter_w) + (w));
p2Buff =
buf.get() + ((c * filter_k * filter_h * filter_w) + (k * filter_h * filter_w) + (h * filter_w) + (w));
*p2Buff = *p1Buff;
}
}
}
}
auto ret = ::memcpy_s(weight->tensor_addr(), weight->tensor_shape_size() * sizeof(T), buf.get(),
weight->tensor_shape_size() * sizeof(T));
if (ret != EOK) {
MS_LOG(ERROR) << "memcpy_s failed: " << ret;
return;
}
auto abstract_base = param_node->abstract();
MS_ASSERT(abstract_base != nullptr);
if (utils::isa<abstract::AbstractTensorPtr>(abstract_base)) {
auto abstract_tensor = utils::cast<abstract::AbstractTensorPtr>(abstract_base);
utils::cast<abstract::ShapePtr>(abstract_tensor->BuildShape())->shape()[0] = filter_c;
utils::cast<abstract::ShapePtr>(abstract_tensor->BuildShape())->shape()[1] = filter_k;
utils::cast<abstract::ShapePtr>(abstract_tensor->BuildShape())->shape()[2] = filter_h;
utils::cast<abstract::ShapePtr>(abstract_tensor->BuildShape())->shape()[3] = filter_w;
}
return;
}
void Conv2D::PopulaterConv2DMultiGroup(const Primitive &prim, schema::PrimitiveT *primitive, const int &group,
const std::vector<AnfNodePtr> &inputs) {
auto attr = std::make_unique<schema::DepthwiseConv2DT>();
auto format = GetValue<std::string>(prim.GetAttr("data_format"));
if (format == "NCHW") {
attr->format = schema::Format_NCHW;
} else if (format == "NHWC") {
attr->format = schema::Format_NHWC;
} else {
attr->format = schema::Format_NUM_OF_FORMAT;
}
auto pad_list = GetValue<std::vector<int>>(prim.GetAttr("pad_list"));
attr->padUp = pad_list[0];
attr->padDown = pad_list[1];
attr->padLeft = pad_list[2];
attr->padRight = pad_list[3];
auto dilation = GetValue<std::vector<int>>(prim.GetAttr("dilation"));
attr->dilateH = dilation[0];
attr->dilateW = dilation[1];
auto kernel_size = GetValue<std::vector<int>>(prim.GetAttr("kernel_size"));
attr->kernelH = kernel_size[0];
attr->kernelW = kernel_size[1];
auto stride = GetValue<std::vector<int>>(prim.GetAttr("stride"));
attr->strideH = stride[2];
attr->strideW = stride[3];
auto pad_mode = GetValue<std::string>(prim.GetAttr("pad_mode"));
if (pad_mode == "valid") {
attr->padMode = schema::PadMode_VALID;
} else if (pad_mode == "same") {
attr->padMode = schema::PadMode_SAME;
} else {
attr->padMode = schema::PadMode_NOTSET;
}
int channel_mutiplier = 1;
if (prim.GetAttr("channel_mutiplier") != nullptr) {
channel_mutiplier = GetValue<int>(prim.GetAttr("channel_multiplier"));
}
attr->channelMultiplier = channel_mutiplier;
MS_ASSERT(inputs.size() == kAnfPopulaterTwo);
auto input_node = inputs[kAnfPopulaterOne];
MS_ASSERT(input_node != nullptr);
if (input_node->isa<Parameter>()) {
auto param_node = input_node->cast<ParameterPtr>();
ConvertConvWeight<float>(param_node);
}
primitive->value.type = schema::PrimitiveType_DepthwiseConv2D;
primitive->value.value = attr.release();
}
void Conv2D::PopulaterConv2DSingleGroup(const Primitive &prim, schema::PrimitiveT *primitive, const int &group) {
auto attr = std::make_unique<schema::Conv2DT>();
attr->group = group;
auto format = GetValue<std::string>(prim.GetAttr("data_format"));
if (format == "NCHW") {
attr->format = schema::Format_NCHW;
} else if (format == "NHWC") {
attr->format = schema::Format_NHWC;
} else {
attr->format = schema::Format_NUM_OF_FORMAT;
}
auto pad_list = GetValue<std::vector<int>>(prim.GetAttr("pad_list"));
attr->padUp = pad_list[0];
attr->padDown = pad_list[1];
attr->padLeft = pad_list[2];
attr->padRight = pad_list[3];
auto dilation = GetValue<std::vector<int>>(prim.GetAttr("dilation"));
attr->dilateH = dilation[0];
attr->dilateW = dilation[1];
auto kernel_size = GetValue<std::vector<int>>(prim.GetAttr("kernel_size"));
attr->kernelH = kernel_size[0];
attr->kernelW = kernel_size[1];
auto stride = GetValue<std::vector<int>>(prim.GetAttr("stride"));
attr->strideH = stride[2];
attr->strideW = stride[3];
attr->channelOut = GetValue<int>(prim.GetAttr("out_channel"));
auto pad_mode = GetValue<std::string>(prim.GetAttr("pad_mode"));
if (pad_mode == "valid") {
attr->padMode = schema::PadMode_VALID;
} else if (pad_mode == "same") {
attr->padMode = schema::PadMode_SAME;
} else {
attr->padMode = schema::PadMode_NOTSET;
}
primitive->value.type = schema::PrimitiveType_Conv2D;
primitive->value.value = attr.release();
}
void Conv2D::CalQuantParam(const double &mean, const double &stdDev, float *mMin, float *mMax) {
constexpr float qmin = 0;
constexpr float qmax = 255;
*mMin = static_cast<float>((qmin - mean) / stdDev);
*mMax = static_cast<float>((qmax - mean) / stdDev);
}
void Conv2D::PopulaterQuantParam(const Primitive &prim,
std::vector<std::vector<schema::QuantParamT>> *vecInputQuantParam,
std::vector<std::vector<schema::QuantParamT>> *vecOutputQuantParam) {
auto narrow_range = prim.GetAttr("narrow_range");
bool narrowRangeQuantParam = GetValue<bool>(narrow_range);
auto num_bits = prim.GetAttr("num_bits");
int32_t numbitsRangeQuantParam = GetValue<int32_t>(num_bits);
std::vector<schema::QuantParamT> quants;
schema::QuantParamT quantParam;
auto mean = prim.GetAttr("mean");
auto std_dev = prim.GetAttr("std_dev");
if (mean != nullptr && std_dev != nullptr) {
auto meanQuantOaram = GetValue<double>(mean);
double stddevQuantOaram = GetValue<double>(std_dev);
float mMin = 0.0;
float mMax = 0.0;
CalQuantParam(meanQuantOaram, stddevQuantOaram, &mMin, &mMax);
quantParam.min = mMin;
quantParam.max = mMax;
} else {
auto inputMin = prim.GetAttr("input_minq");
auto inputMax = prim.GetAttr("input_maxq");
auto inputMinPtr = inputMin->cast<lite::tensor::TensorPtr>();
auto inputMaxPtr = inputMax->cast<lite::tensor::TensorPtr>();
float *minBuf = static_cast<float *>(inputMinPtr->Data());
float *maxBuf = static_cast<float *>(inputMaxPtr->Data());
quantParam.min = *minBuf;
quantParam.max = *maxBuf;
}
quant::CalQuantizationParams(&quantParam, quantParam.min, quantParam.max, narrowRangeQuantParam,
numbitsRangeQuantParam);
quants.emplace_back(quantParam);
vecInputQuantParam->emplace_back(quants);
quants.clear();
int biasQuantSize = 0;
auto filterMin = prim.GetAttr("filter_minq");
auto filterMax = prim.GetAttr("filter_maxq");
if (filterMin != nullptr && filterMax != nullptr) {
auto filterMinPtr = filterMin->cast<lite::tensor::TensorPtr>();
auto filterMaxPtr = filterMax->cast<lite::tensor::TensorPtr>();
float *minBuf = static_cast<float *>(filterMinPtr->Data());
float *maxBuf = static_cast<float *>(filterMaxPtr->Data());
biasQuantSize = filterMinPtr->DataSize();
for (int i = 0; i < biasQuantSize; ++i) {
quantParam.min = *(minBuf++);
quantParam.max = *(maxBuf++);
quant::CalQuantizationParams(&quantParam, quantParam.min, quantParam.max, narrowRangeQuantParam,
numbitsRangeQuantParam);
quants.emplace_back(quantParam);
}
vecInputQuantParam->emplace_back(quants);
}
quants.clear();
for (int i = 0; i < biasQuantSize; ++i) {
quantParam.min = 0.0;
quantParam.max = 0.0;
quantParam.zeroPoint = 0;
quantParam.scale = vecInputQuantParam->at(0).at(0).scale * vecInputQuantParam->at(1).at(i).scale;
quants.emplace_back(quantParam);
}
vecInputQuantParam->emplace_back(quants);
quants.clear();
auto outputMin = prim.GetAttr("output_minq");
auto outputMax = prim.GetAttr("output_maxq");
if (outputMin != nullptr && outputMax != nullptr) {
auto outputMinPtr = outputMin->cast<lite::tensor::TensorPtr>();
auto outputMaxPtr = outputMax->cast<lite::tensor::TensorPtr>();
float *minBuf = static_cast<float *>(outputMinPtr->Data());
float *maxBuf = static_cast<float *>(outputMaxPtr->Data());
quantParam.min = *minBuf;
quantParam.max = *maxBuf;
quant::CalQuantizationParams(&quantParam, quantParam.min, quantParam.max, narrowRangeQuantParam,
numbitsRangeQuantParam);
quants.emplace_back(quantParam);
vecOutputQuantParam->emplace_back(quants);
}
}
int Conv2D::UnPackAttr(const Primitive &prim, const std::vector<AnfNodePtr> &inputs) {
this->primitive_ = new (schema::PrimitiveT);
int group = GetValue<int>(prim.GetAttr("group"));
if (group > 1) {
PopulaterConv2DMultiGroup(prim, this->primitive_, group, inputs);
} else {
PopulaterConv2DSingleGroup(prim, this->primitive_, group);
}
if (GetQuantType() == schema::QuantType_AwareTraining) {
std::vector<std::vector<schema::QuantParamT>> vecInputQuantParam;
std::vector<std::vector<schema::QuantParamT>> vecOutputQuantParam;
PopulaterQuantParam(prim, &vecInputQuantParam, &vecOutputQuantParam);
SetInputQuantParam(vecInputQuantParam);
SetOutputQuantParam(vecOutputQuantParam);
}
return RET_OK;
}
#else

24
mindspore/lite/src/ops/conv2d.h
View File

@ -20,17 +20,35 @@
#include <vector>
#include <set>
#include <cmath>
#include "ir/dtype/type_id.h"
#include <memory>
#include "src/ops/primitive_c.h"
#include "ir/dtype/type_id.h"
namespace mindspore {
namespace lite {
class Conv2D : public PrimitiveC {
public:
#ifdef PRIMITIVE_WRITEABLE
public:
Conv2D() = default;
explicit Conv2D(schema::PrimitiveT *primitive) : PrimitiveC(primitive) {}
#endif
int UnPackAttr(const Primitive &prim, const std::vector<AnfNodePtr> &inputs);
private:
void PopulaterConv2DMultiGroup(const Primitive &prim, schema::PrimitiveT *primitive, const int &group,
const std::vector<AnfNodePtr> &inputs);
void PopulaterConv2DSingleGroup(const Primitive &prim, schema::PrimitiveT *primitive, const int &group);
void PopulaterQuantParam(const Primitive &prim, std::vector<std::vector<schema::QuantParamT>> *vecInputQuantParam,
std::vector<std::vector<schema::QuantParamT>> *vecOutputQuantParam);
void CalQuantParam(const double &mean, const double &stdDev, float *mMin, float *mMax);
#else
public:
explicit Conv2D(schema::Primitive *primitive) : PrimitiveC(primitive) {}
#endif
public:
int InferShape(std::vector<lite::tensor::Tensor *> inputs_, std::vector<lite::tensor::Tensor *> outputs_) override;
int PadUp() const;
int PadDown() const;

5
mindspore/lite/src/ops/conv2d_grad_filter.h
View File

@ -28,10 +28,11 @@ namespace lite {
class Conv2DGradFilter : public PrimitiveC {
public:
#ifdef PRIMITIVE_WRITEABLE
Conv2DGradFilter() = default;
explicit Conv2DGradFilter(schema::PrimitiveT *primitive) : PrimitiveC(primitive) {}
#endif
#else
explicit Conv2DGradFilter(schema::Primitive *primitive) : PrimitiveC(primitive) {}
#endif
int GetFormat() const;
int GetGroup() const;
int GetChannelIn() const;

5
mindspore/lite/src/ops/conv2d_grad_input.h
View File

@ -28,10 +28,11 @@ namespace lite {
class Conv2DGradInput : public PrimitiveC {
public:
#ifdef PRIMITIVE_WRITEABLE
Conv2DGradInput() = default;
explicit Conv2DGradInput(schema::PrimitiveT *primitive) : PrimitiveC(primitive) {}
#endif
#else
explicit Conv2DGradInput(schema::Primitive *primitive) : PrimitiveC(primitive) {}
#endif
int GetFormat() const;
int GetGroup() const;
int GetChannelIn() const;

4
mindspore/lite/src/ops/cos.h
View File

@ -28,9 +28,11 @@ namespace lite {
class Cos : public ArithmeticSelf {
public:
#ifdef PRIMITIVE_WRITEABLE
Cos() = default;
explicit Cos(schema::PrimitiveT *primitive) : ArithmeticSelf(primitive) {}
#endif
#else
explicit Cos(schema::Primitive *primitive) : ArithmeticSelf(primitive) {}
#endif
};
} // namespace lite
} // namespace mindspore

5
mindspore/lite/src/ops/crop.h
View File

@ -28,10 +28,11 @@ namespace lite {
class Crop : public PrimitiveC {
public:
#ifdef PRIMITIVE_WRITEABLE
Crop() = default;
explicit Crop(schema::PrimitiveT *primitive) : PrimitiveC(primitive) {}
#endif
#else
explicit Crop(schema::Primitive *primitive) : PrimitiveC(primitive) {}
#endif
int InferShape(std::vector<lite::tensor::Tensor *> inputs_, std::vector<lite::tensor::Tensor *> outputs_) override;
long GetAxis() const;
std::vector<long> GetOffsets() const;

5
mindspore/lite/src/ops/deconv2d.h
View File

@ -28,10 +28,11 @@ namespace lite {
class DeConv2D : public PrimitiveC {
public:
#ifdef PRIMITIVE_WRITEABLE
DeConv2D() = default;
explicit DeConv2D(schema::PrimitiveT *primitive) : PrimitiveC(primitive) {}
#endif
#else
explicit DeConv2D(schema::Primitive *primitive) : PrimitiveC(primitive) {}
#endif
int InferShape(std::vector<lite::tensor::Tensor *> inputs_, std::vector<lite::tensor::Tensor *> outputs_) override;
int GetFormat() const;
int GetGroup() const;

5
mindspore/lite/src/ops/dedepthwise_conv2d.h
View File

@ -28,10 +28,11 @@ namespace lite {
class DeDepthwiseConv2D : public PrimitiveC {
public:
#ifdef PRIMITIVE_WRITEABLE
DeDepthwiseConv2D() = default;
explicit DeDepthwiseConv2D(schema::PrimitiveT *primitive) : PrimitiveC(primitive) {}
#endif
#else
explicit DeDepthwiseConv2D(schema::Primitive *primitive) : PrimitiveC(primitive) {}
#endif
int InferShape(std::vector<lite::tensor::Tensor *> inputs_, std::vector<lite::tensor::Tensor *> outputs_) override;
int GetFormat() const;
int GetChannelIn() const;

5
mindspore/lite/src/ops/depth_to_space.h
View File

@ -28,10 +28,11 @@ namespace lite {
class DepthToSpace : public PrimitiveC {
public:
#ifdef PRIMITIVE_WRITEABLE
DepthToSpace() = default;
explicit DepthToSpace(schema::PrimitiveT *primitive) : PrimitiveC(primitive) {}
#endif
#else
explicit DepthToSpace(schema::Primitive *primitive) : PrimitiveC(primitive) {}
#endif
int InferShape(std::vector<lite::tensor::Tensor *> inputs_, std::vector<lite::tensor::Tensor *> outputs_) override;
int GetBlockSize() const;
int GetFormat() const;

168
mindspore/lite/src/ops/depthwise_conv2d.cc
View File

@ -15,7 +15,11 @@
*/
#include "src/ops/depthwise_conv2d.h"
#include <memory>
#include <string>
#ifdef PRIMITIVE_WRITEABLE
#include "tools/converter/quantizer/quantize_util.h"
#endif
namespace mindspore {
namespace lite {
#ifdef PRIMITIVE_WRITEABLE
@ -65,6 +69,168 @@ void DepthwiseConv2D::SetActivationType(int activation_type) {
this->primitive_->value.AsDepthwiseConv2D()->activationType = (schema::ActivationType)activation_type;
}
void DepthwiseConv2D::CalQuantParam(const double &mean, const double &stdDev, float *mMin, float *mMax) {
constexpr float qmin = 0;
constexpr float qmax = 255;
*mMin = static_cast<float>((qmin - mean) / stdDev);
*mMax = static_cast<float>((qmax - mean) / stdDev);
}
void DepthwiseConv2D::PopulaterQuantParam(const Primitive &prim,
std::vector<std::vector<schema::QuantParamT>> *vecInputQuantParam,
std::vector<std::vector<schema::QuantParamT>> *vecOutputQuantParam) {
auto narrow_range = prim.GetAttr("narrow_range");
bool narrowRangeQuantParam = GetValue<bool>(narrow_range);
auto num_bits = prim.GetAttr("num_bits");
int32_t numbitsRangeQuantParam = GetValue<int32_t>(num_bits);
std::vector<schema::QuantParamT> quants;
schema::QuantParamT quantParam;
auto mean = prim.GetAttr("mean");
auto std_dev = prim.GetAttr("std_dev");
if (mean != nullptr && std_dev != nullptr) {
auto meanQuantOaram = GetValue<double>(mean);
double stddevQuantOaram = GetValue<double>(std_dev);
float mMin = 0.0;
float mMax = 0.0;
CalQuantParam(meanQuantOaram, stddevQuantOaram, &mMin, &mMax);
quantParam.min = mMin;
quantParam.max = mMax;
} else {
auto inputMin = prim.GetAttr("input_minq");
auto inputMax = prim.GetAttr("input_maxq");
auto inputMinPtr = inputMin->cast<lite::tensor::TensorPtr>();
auto inputMaxPtr = inputMax->cast<lite::tensor::TensorPtr>();
float *minBuf = static_cast<float *>(inputMinPtr->Data());
float *maxBuf = static_cast<float *>(inputMaxPtr->Data());
quantParam.min = *minBuf;
quantParam.max = *maxBuf;
}
quant::CalQuantizationParams(&quantParam, quantParam.min, quantParam.max, narrowRangeQuantParam,
numbitsRangeQuantParam);
quants.emplace_back(quantParam);
vecInputQuantParam->emplace_back(quants);
quants.clear();
int biasQuantSize = 0;
auto filterMin = prim.GetAttr("filter_minq");
auto filterMax = prim.GetAttr("filter_maxq");
if (filterMin != nullptr && filterMax != nullptr) {
auto filterMinPtr = filterMin->cast<lite::tensor::TensorPtr>();
auto filterMaxPtr = filterMax->cast<lite::tensor::TensorPtr>();
float *minBuf = static_cast<float *>(filterMinPtr->Data());
float *maxBuf = static_cast<float *>(filterMaxPtr->Data());
biasQuantSize = filterMinPtr->DataSize();
for (int i = 0; i < biasQuantSize; ++i) {
quantParam.min = *(minBuf++);
quantParam.max = *(maxBuf++);
quant::CalQuantizationParams(&quantParam, quantParam.min, quantParam.max, narrowRangeQuantParam,
numbitsRangeQuantParam);
quants.emplace_back(quantParam);
}
vecInputQuantParam->emplace_back(quants);
}
quants.clear();
for (int i = 0; i < biasQuantSize; ++i) {
quantParam.min = 0.0;
quantParam.max = 0.0;
quantParam.zeroPoint = 0;
quantParam.scale = vecInputQuantParam->at(0).at(0).scale * vecInputQuantParam->at(1).at(i).scale;
quants.emplace_back(quantParam);
}
vecInputQuantParam->emplace_back(quants);
quants.clear();
auto outputMin = prim.GetAttr("output_minq");
auto outputMax = prim.GetAttr("output_maxq");
if (outputMin != nullptr && outputMax != nullptr) {
auto outputMinPtr = outputMin->cast<lite::tensor::TensorPtr>();
auto outputMaxPtr = outputMax->cast<lite::tensor::TensorPtr>();
float *minBuf = static_cast<float *>(outputMinPtr->Data());
float *maxBuf = static_cast<float *>(outputMaxPtr->Data());
quantParam.min = *minBuf;
quantParam.max = *maxBuf;
quant::CalQuantizationParams(&quantParam, quantParam.min, quantParam.max, narrowRangeQuantParam,
numbitsRangeQuantParam);
quants.emplace_back(quantParam);
vecOutputQuantParam->emplace_back(quants);
}
}
int DepthwiseConv2D::UnPackAttr(const Primitive &prim, const std::vector<AnfNodePtr> &inputs) {
this->primitive_ = new (schema::PrimitiveT);
auto attr = std::make_unique<schema::DepthwiseConv2DT>();
auto format = GetValue<std::string>(prim.GetAttr("data_format"));
if (format == "NCHW") {
attr->format = schema::Format_NCHW;
} else if (format == "NHWC") {
attr->format = schema::Format_NHWC;
} else {
attr->format = schema::Format_NUM_OF_FORMAT;
}
auto pad_list = GetValue<std::vector<int>>(prim.GetAttr("pads"));
attr->padUp = pad_list[0];
attr->padDown = pad_list[1];
attr->padLeft = pad_list[2];
attr->padRight = pad_list[3];
auto dilation = GetValue<std::vector<int>>(prim.GetAttr("dilation"));
attr->dilateH = dilation[0];
attr->dilateW = dilation[1];
auto kernel_size = GetValue<std::vector<int>>(prim.GetAttr("kernel_size"));
attr->kernelH = kernel_size[0];
attr->kernelW = kernel_size[1];
auto stride = GetValue<std::vector<int>>(prim.GetAttr("stride"));
attr->strideH = stride[2];
attr->strideW = stride[3];
auto pad_mode = GetValue<std::string>(prim.GetAttr("pad_mode"));
if (pad_mode == "valid") {
attr->padMode = schema::PadMode_VALID;
} else if (pad_mode == "same") {
attr->padMode = schema::PadMode_SAME;
} else {
attr->padMode = schema::PadMode_NOTSET;
}
auto channel_multiplier = GetValue<int>(prim.GetAttr("channel_multiplier"));
attr->channelMultiplier = channel_multiplier;
MS_ASSERT(inputs.size() == kAnfPopulaterTwo);
auto inputNode = inputs[kAnfPopulaterOne];
MS_ASSERT(inputNode != nullptr);
if (inputNode->isa<Parameter>()) {
auto paramNode = inputNode->cast<ParameterPtr>();
auto abstractBase = paramNode->abstract();
MS_ASSERT(abstractBase != nullptr);
if (utils::isa<abstract::AbstractTensorPtr>(abstractBase)) {
auto abstractTensor = utils::cast<abstract::AbstractTensorPtr>(abstractBase);
MS_ASSERT(abstractTensor != nullptr);
if (utils::isa<abstract::ShapePtr>(abstractTensor->BuildShape())) {
auto dims = utils::cast<abstract::ShapePtr>(abstractTensor->BuildShape())->shape();
attr->channelIn = dims[kAnfPopulaterOne];
}
}
}
this->primitive_->value.type = schema::PrimitiveType_DepthwiseConv2D;
this->primitive_->value.value = attr.release();
if (GetQuantType() == schema::QuantType_AwareTraining) {
std::vector<std::vector<schema::QuantParamT>> vecInputQuantParam;
std::vector<std::vector<schema::QuantParamT>> vecOutputQuantParam;
PopulaterQuantParam(prim, &vecInputQuantParam, &vecOutputQuantParam);
SetInputQuantParam(vecInputQuantParam);
SetOutputQuantParam(vecOutputQuantParam);
}
return RET_OK;
}
#else
int DepthwiseConv2D::GetFormat() const { return this->primitive_->value_as_DepthwiseConv2D()->format(); }

21
mindspore/lite/src/ops/depthwise_conv2d.h
View File

@ -26,12 +26,25 @@
namespace mindspore {
namespace lite {
class DepthwiseConv2D : public PrimitiveC {
public:
#ifdef PRIMITIVE_WRITEABLE
explicit DepthwiseConv2D(schema::PrimitiveT *primitive) : PrimitiveC(primitive) {}
#endif
explicit DepthwiseConv2D(schema::Primitive *primitive) : PrimitiveC(primitive) {}
public:
DepthwiseConv2D() = default;
explicit DepthwiseConv2D(schema::PrimitiveT *primitive) : PrimitiveC(primitive) {}
int UnPackAttr(const Primitive &prim, const std::vector<AnfNodePtr> &inputs);
private:
void PopulaterQuantParam(const Primitive &prim, std::vector<std::vector<schema::QuantParamT>> *vecInputQuantParam,
std::vector<std::vector<schema::QuantParamT>> *vecOutputQuantParam);
void CalQuantParam(const double &mean, const double &stdDev, float *mMin, float *mMax);
#else
public:
explicit DepthwiseConv2D(schema::Primitive *primitive) : PrimitiveC(primitive) {}
#endif
public:
int InferShape(std::vector<lite::tensor::Tensor *> inputs_, std::vector<lite::tensor::Tensor *> outputs_) override;
int GetFormat() const;
int GetChannelIn() const;

28
mindspore/lite/tools/anf_importer/anf_populater/anf_make_tuple_populater.h → mindspore/lite/src/ops/dequant.cc
View File

@ -13,18 +13,20 @@
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef MINDSPORE_ANF_MAKE_TUPLE_PARSER_H
#define MINDSPORE_ANF_MAKE_TUPLE_PARSER_H
#include "tools/anf_importer/anf_populater/anf_node_populater.h"
#include "src/ops/dequant.h"
#include <vector>
#include <memory>
namespace mindspore::lite {
class AnfMakeTuplePopulater : public AnfNodePopulater {
public:
AnfMakeTuplePopulater() = default;
~AnfMakeTuplePopulater() override = default;
int Populate(const PrimitivePtr &prim, PrimitiveC *primitiveCPtr,
const std::vector<AnfNodePtr> &inputs) override;
};
} // namespace mindspore::lite
#endif // MINDSPORE_ANF_MAKE_TUPLE_PARSER_H
namespace mindspore {
namespace lite {
#ifdef PRIMITIVE_WRITEABLE
int Dequant::UnPackAttr(const Primitive &prim, const std::vector<AnfNodePtr> &inputs) {
this->primitive_ = new (schema::PrimitiveT);
auto attr = std::make_unique<schema::OnnxInt8DequantizeT>();
this->primitive_->value.type = schema::PrimitiveType_OnnxInt8Dequantize;
this->primitive_->value.value = attr.release();
return RET_OK;
}
#endif
} // namespace lite
} // namespace mindspore

38
mindspore/lite/src/ops/dequant.h Normal file
View File

@ -0,0 +1,38 @@
/**
* Copyright 2020 Huawei Technologies Co., Ltd
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef LITE_MINDSPORE_LITE_SRC_OPS_DEQUANT_H_
#define LITE_MINDSPORE_LITE_SRC_OPS_DEQUANT_H_
#include <vector>
#include "src/ops/primitive_c.h"
namespace mindspore {
namespace lite {
class Dequant : public PrimitiveC {
public:
#ifdef PRIMITIVE_WRITEABLE
Dequant() = default;
explicit Dequant(schema::PrimitiveT *primitive) : PrimitiveC(primitive) {}
int UnPackAttr(const Primitive &prim, const std::vector<AnfNodePtr> &inputs);
#else
explicit Dequant(schema::Primitive *primitive) : PrimitiveC(primitive) {}
#endif
};
} // namespace lite
} // namespace mindspore
#endif // LITE_MINDSPORE_LITE_SRC_OPS_DEQUANT_H_

5
mindspore/lite/src/ops/detection_post_process.h
View File

@ -28,10 +28,11 @@ namespace lite {
class DetectionPostProcess : public PrimitiveC {
public:
#ifdef PRIMITIVE_WRITEABLE
DetectionPostProcess() = default;
explicit DetectionPostProcess(schema::PrimitiveT *primitive) : PrimitiveC(primitive) {}
#endif
#else
explicit DetectionPostProcess(schema::Primitive *primitive) : PrimitiveC(primitive) {}
#endif
int GetFormat() const;
int GetInputSize() const;
float GetHScale() const;

5
mindspore/lite/src/ops/div.h
View File

@ -28,10 +28,11 @@ namespace lite {
class Div : public Arithmetic {
public:
#ifdef PRIMITIVE_WRITEABLE
Div() = default;
explicit Div(schema::PrimitiveT *primitive) : Arithmetic(primitive) {}
#endif
#else
explicit Div(schema::Primitive *primitive) : Arithmetic(primitive) {}
#endif
int GetActivationType() const;
void SetActivationType(int activation_type);
};

5
mindspore/lite/src/ops/dropout.h
View File

@ -28,10 +28,11 @@ namespace lite {
class Dropout : public PrimitiveC {
public:
#ifdef PRIMITIVE_WRITEABLE
Dropout() = default;
explicit Dropout(schema::PrimitiveT *primitive) : PrimitiveC(primitive) {}
#endif
#else
explicit Dropout(schema::Primitive *primitive) : PrimitiveC(primitive) {}
#endif
float GetRatio() const;
void SetRatio(float ratio);
};

5
mindspore/lite/src/ops/eltwise.h
View File

@ -28,10 +28,11 @@ namespace lite {
class Eltwise : public PrimitiveC {
public:
#ifdef PRIMITIVE_WRITEABLE
Eltwise() = default;
explicit Eltwise(schema::PrimitiveT *primitive) : PrimitiveC(primitive) {}
#endif
#else
explicit Eltwise(schema::Primitive *primitive) : PrimitiveC(primitive) {}
#endif
int GetMode() const;
void SetMode(int mode);
};

5
mindspore/lite/src/ops/elu.h
View File

@ -28,10 +28,11 @@ namespace lite {
class Elu : public PrimitiveC {
public:
#ifdef PRIMITIVE_WRITEABLE
Elu() = default;
explicit Elu(schema::PrimitiveT *primitive) : PrimitiveC(primitive) {}
#endif
#else
explicit Elu(schema::Primitive *primitive) : PrimitiveC(primitive) {}
#endif
float GetAlpha() const;
void SetAlpha(float alpha);
};

5
mindspore/lite/src/ops/embedding_lookup.h
View File

@ -28,10 +28,11 @@ namespace lite {
class EmbeddingLookup : public PrimitiveC {
public:
#ifdef PRIMITIVE_WRITEABLE
EmbeddingLookup() = default;
explicit EmbeddingLookup(schema::PrimitiveT *primitive) : PrimitiveC(primitive) {}
#endif
#else
explicit EmbeddingLookup(schema::Primitive *primitive) : PrimitiveC(primitive) {}
#endif
int InferShape(std::vector<lite::tensor::Tensor *> inputs_, std::vector<lite::tensor::Tensor *> outputs_) override;
float GetMaxNorm() const;
void SetMaxNorm(float max_norm);

5
mindspore/lite/src/ops/embedding_lookup_sparse.h
View File

@ -28,10 +28,11 @@ namespace lite {
class EmbeddingLookupSparse : public PrimitiveC {
public:
#ifdef PRIMITIVE_WRITEABLE
EmbeddingLookupSparse() = default;
explicit EmbeddingLookupSparse(schema::PrimitiveT *primitive) : PrimitiveC(primitive) {}
#endif
#else
explicit EmbeddingLookupSparse(schema::Primitive *primitive) : PrimitiveC(primitive) {}
#endif
std::vector<int> GetSpIds() const;
std::vector<float> GetSpWeights() const;
float GetMaxNortm() const;

4
mindspore/lite/src/ops/equal.h
View File

@ -28,9 +28,11 @@ namespace lite {
class Equal : public Arithmetic {
public:
#ifdef PRIMITIVE_WRITEABLE
Equal() = default;
explicit Equal(schema::PrimitiveT *primitive) : Arithmetic(primitive) {}
#endif
#else
explicit Equal(schema::Primitive *primitive) : Arithmetic(primitive) {}
#endif
};
} // namespace lite
} // namespace mindspore

4
mindspore/lite/src/ops/exp.h
View File

@ -28,9 +28,11 @@ namespace lite {
class Exp : public ArithmeticSelf {
public:
#ifdef PRIMITIVE_WRITEABLE
Exp() = default;
explicit Exp(schema::PrimitiveT *primitive) : ArithmeticSelf(primitive) {}
#endif
#else
explicit Exp(schema::Primitive *primitive) : ArithmeticSelf(primitive) {}
#endif
};
} // namespace lite
} // namespace mindspore

5
mindspore/lite/src/ops/expand_dims.h
View File

@ -28,10 +28,11 @@ namespace lite {
class ExpandDims : public PrimitiveC {
public:
#ifdef PRIMITIVE_WRITEABLE
ExpandDims() = default;
explicit ExpandDims(schema::PrimitiveT *primitive) : PrimitiveC(primitive) {}
#endif
#else
explicit ExpandDims(schema::Primitive *primitive) : PrimitiveC(primitive) {}
#endif
int InferShape(std::vector<lite::tensor::Tensor *> inputs_, std::vector<lite::tensor::Tensor *> outputs_) override;
int GetDim() const;
void SetDim(int dim);

5
mindspore/lite/src/ops/fake_quant_with_min_max_vars.h
View File

@ -28,10 +28,11 @@ namespace lite {
class FakeQuantWithMinMaxVars : public PrimitiveC {
public:
#ifdef PRIMITIVE_WRITEABLE
FakeQuantWithMinMaxVars() = default;
explicit FakeQuantWithMinMaxVars(schema::PrimitiveT *primitive) : PrimitiveC(primitive) {}
#endif
#else
explicit FakeQuantWithMinMaxVars(schema::Primitive *primitive) : PrimitiveC(primitive) {}
#endif
bool GetNarrowRange() const;
int GetNumBits() const;
void SetNarrowRange(bool narrow_range);

5
mindspore/lite/src/ops/fill.h
View File

@ -28,10 +28,11 @@ namespace lite {
class Fill : public PrimitiveC {
public:
#ifdef PRIMITIVE_WRITEABLE
Fill() = default;
explicit Fill(schema::PrimitiveT *primitive) : PrimitiveC(primitive) {}
#endif
#else
explicit Fill(schema::Primitive *primitive) : PrimitiveC(primitive) {}
#endif
int InferShape(std::vector<lite::tensor::Tensor *> inputs_, std::vector<lite::tensor::Tensor *> outputs_) override;
std::vector<int> GetDims() const;
void SetDims(const std::vector<int> &dims);

10
mindspore/lite/src/ops/flatten.cc
View File

@ -15,6 +15,7 @@
*/
#include "src/ops/flatten.h"
#include <memory>
namespace mindspore {
namespace lite {
@ -48,5 +49,14 @@ int Flatten::InferShape(std::vector<tensor::Tensor *> inputs_, std::vector<tenso
output->set_shape(output_shape);
return RET_OK;
}
#ifdef PRIMITIVE_WRITEABLE
int Flatten::UnPackAttr(const Primitive &prim, const std::vector<AnfNodePtr> &inputs) {
this->primitive_ = new (schema::PrimitiveT);
auto attr = std::make_unique<schema::FlattenT>();
this->primitive_->value.type = schema::PrimitiveType_Flatten;
this->primitive_->value.value = attr.release();
return RET_OK;
}
#endif
} // namespace lite
} // namespace mindspore

7
mindspore/lite/src/ops/flatten.h
View File

@ -28,11 +28,14 @@ namespace lite {
class Flatten : public PrimitiveC {
public:
#ifdef PRIMITIVE_WRITEABLE
Flatten() = default;
explicit Flatten(schema::PrimitiveT *primitive) : PrimitiveC(primitive) {}
#endif
#else
explicit Flatten(schema::Primitive *primitive) : PrimitiveC(primitive) {}
#endif
int InferShape(std::vector<lite::tensor::Tensor *> inputs_, std::vector<lite::tensor::Tensor *> outputs_) override;
int UnPackAttr(const Primitive &prim, const std::vector<AnfNodePtr> &inputs);
};
} // namespace lite
} // namespace mindspore

4
mindspore/lite/src/ops/floor.h
View File

@ -28,9 +28,11 @@ namespace lite {
class Floor : public ArithmeticSelf {
public:
#ifdef PRIMITIVE_WRITEABLE
Floor() = default;
explicit Floor(schema::PrimitiveT *primitive) : ArithmeticSelf(primitive) {}
#endif
#else
explicit Floor(schema::Primitive *primitive) : ArithmeticSelf(primitive) {}
#endif
};
} // namespace lite
} // namespace mindspore

4
mindspore/lite/src/ops/floor_div.h
View File

@ -28,9 +28,11 @@ namespace lite {
class FloorDiv : public Arithmetic {
public:
#ifdef PRIMITIVE_WRITEABLE
FloorDiv() = default;
explicit FloorDiv(schema::PrimitiveT *primitive) : Arithmetic(primitive) {}
#endif
#else
explicit FloorDiv(schema::Primitive *primitive) : Arithmetic(primitive) {}
#endif
};
} // namespace lite
} // namespace mindspore

4
mindspore/lite/src/ops/floor_mod.h
View File

@ -28,9 +28,11 @@ namespace lite {
class FloorMod : public Arithmetic {
public:
#ifdef PRIMITIVE_WRITEABLE
FloorMod() = default;
explicit FloorMod(schema::PrimitiveT *primitive) : Arithmetic(primitive) {}
#endif
#else
explicit FloorMod(schema::Primitive *primitive) : Arithmetic(primitive) {}
#endif
};
} // namespace lite
} // namespace mindspore

5
mindspore/lite/src/ops/full_connection.h
View File

@ -28,10 +28,11 @@ namespace lite {
class FullConnection : public PrimitiveC {
public:
#ifdef PRIMITIVE_WRITEABLE
FullConnection() = default;
explicit FullConnection(schema::PrimitiveT *primitive) : PrimitiveC(primitive) {}
#endif
#else
explicit FullConnection(schema::Primitive *primitive) : PrimitiveC(primitive) {}
#endif
int InferShape(std::vector<lite::tensor::Tensor *> inputs_, std::vector<lite::tensor::Tensor *> outputs_) override;
bool GetHasBias() const;
int GetAxis() const;

5
mindspore/lite/src/ops/fused_batchnorm.h
View File

@ -28,10 +28,11 @@ namespace lite {
class FusedBatchNorm : public PrimitiveC {
public:
#ifdef PRIMITIVE_WRITEABLE
FusedBatchNorm() = default;
explicit FusedBatchNorm(schema::PrimitiveT *primitive) : PrimitiveC(primitive) {}
#endif
#else
explicit FusedBatchNorm(schema::Primitive *primitive) : PrimitiveC(primitive) {}
#endif
float GetEpsilon() const;
float GetMomentum() const;
int GetSpatial() const;

5
mindspore/lite/src/ops/gather.h
View File

@ -28,10 +28,11 @@ namespace lite {
class Gather : public PrimitiveC {
public:
#ifdef PRIMITIVE_WRITEABLE
Gather() = default;
explicit Gather(schema::PrimitiveT *primitive) : PrimitiveC(primitive) {}
#endif
#else
explicit Gather(schema::Primitive *primitive) : PrimitiveC(primitive) {}
#endif
int InferShape(std::vector<lite::tensor::Tensor *> inputs_, std::vector<lite::tensor::Tensor *> outputs_) override;
int GetAxis() const;
int GetBatchDims() const;

5
mindspore/lite/src/ops/gather_nd.h
View File

@ -28,10 +28,11 @@ namespace lite {
class GatherNd : public PrimitiveC {
public:
#ifdef PRIMITIVE_WRITEABLE
GatherNd() = default;
explicit GatherNd(schema::PrimitiveT *primitive) : PrimitiveC(primitive) {}
#endif
#else
explicit GatherNd(schema::Primitive *primitive) : PrimitiveC(primitive) {}
#endif
int InferShape(std::vector<lite::tensor::Tensor *> inputs_, std::vector<lite::tensor::Tensor *> outputs_) override;
int GetBatchDims() const;
void SetBatchDims(int batch_dims);

4
mindspore/lite/src/ops/greater.h
View File

@ -27,9 +27,11 @@ namespace lite {
class Greater : public Arithmetic {
public:
#ifdef PRIMITIVE_WRITEABLE
Greater() = default;
explicit Greater(schema::PrimitiveT *primitive) : Arithmetic(primitive) {}
#endif
#else
explicit Greater(schema::Primitive *primitive) : Arithmetic(primitive) {}
#endif
};
} // namespace lite
} // namespace mindspore

4
mindspore/lite/src/ops/greater_equal.h
View File

@ -28,9 +28,11 @@ namespace lite {
class GreaterEqual : public Arithmetic {
public:
#ifdef PRIMITIVE_WRITEABLE
GreaterEqual() = default;
explicit GreaterEqual(schema::PrimitiveT *primitive) : Arithmetic(primitive) {}
#endif
#else
explicit GreaterEqual(schema::Primitive *primitive) : Arithmetic(primitive) {}
#endif
};
} // namespace lite
} // namespace mindspore

5
mindspore/lite/src/ops/l2_norm.h
View File

@ -28,10 +28,11 @@ namespace lite {
class L2Norm : public PrimitiveC {
public:
#ifdef PRIMITIVE_WRITEABLE
L2Norm() = default;
explicit L2Norm(schema::PrimitiveT *primitive) : PrimitiveC(primitive) {}
#endif
#else
explicit L2Norm(schema::Primitive *primitive) : PrimitiveC(primitive) {}
#endif
std::vector<int> GetAxis() const;
float GetEpsilon() const;
void SetAxis(const std::vector<int> &axis);

5
mindspore/lite/src/ops/leaky_relu.h
View File

@ -28,10 +28,11 @@ namespace lite {
class LeakyReLU : public PrimitiveC {
public:
#ifdef PRIMITIVE_WRITEABLE
LeakyReLU() = default;
explicit LeakyReLU(schema::PrimitiveT *primitive) : PrimitiveC(primitive) {}
#endif
#else
explicit LeakyReLU(schema::Primitive *primitive) : PrimitiveC(primitive) {}
#endif
float GetNegativeSlope() const;
void SetNegativeSlope(float negative_slope);
};

4
mindspore/lite/src/ops/less.h
View File

@ -28,9 +28,11 @@ namespace lite {
class Less : public Arithmetic {
public:
#ifdef PRIMITIVE_WRITEABLE
Less() = default;
explicit Less(schema::PrimitiveT *primitive) : Arithmetic(primitive) {}
#endif
#else
explicit Less(schema::Primitive *primitive) : Arithmetic(primitive) {}
#endif
};
} // namespace lite
} // namespace mindspore

4
mindspore/lite/src/ops/less_equal.h
View File

@ -28,9 +28,11 @@ namespace lite {
class LessEqual : public Arithmetic {
public:
#ifdef PRIMITIVE_WRITEABLE
LessEqual() = default;
explicit LessEqual(schema::PrimitiveT *primitive) : Arithmetic(primitive) {}
#endif
#else
explicit LessEqual(schema::Primitive *primitive) : Arithmetic(primitive) {}
#endif
};
} // namespace lite
} // namespace mindspore

5
mindspore/lite/src/ops/local_response_normalization.h
View File

@ -28,10 +28,11 @@ namespace lite {
class LocalResponseNormalization : public PrimitiveC {
public:
#ifdef PRIMITIVE_WRITEABLE
LocalResponseNormalization() = default;
explicit LocalResponseNormalization(schema::PrimitiveT *primitive) : PrimitiveC(primitive) {}
#endif
#else
explicit LocalResponseNormalization(schema::Primitive *primitive) : PrimitiveC(primitive) {}
#endif
int GetDepthRadius() const;
float GetBias() const;
float GetAlpha() const;

4
mindspore/lite/src/ops/log.h
View File

@ -28,9 +28,11 @@ namespace lite {
class Log : public ArithmeticSelf {
public:
#ifdef PRIMITIVE_WRITEABLE
Log() = default;
explicit Log(schema::PrimitiveT *primitive) : ArithmeticSelf(primitive) {}
#endif
#else
explicit Log(schema::Primitive *primitive) : ArithmeticSelf(primitive) {}
#endif
};
} // namespace lite
} // namespace mindspore

4
mindspore/lite/src/ops/logical_and.h
View File

@ -28,9 +28,11 @@ namespace lite {
class LogicalAnd : public Arithmetic {
public:
#ifdef PRIMITIVE_WRITEABLE
LogicalAnd() = default;
explicit LogicalAnd(schema::PrimitiveT *primitive) : Arithmetic(primitive) {}
#endif
#else
explicit LogicalAnd(schema::Primitive *primitive) : Arithmetic(primitive) {}
#endif
};
} // namespace lite
} // namespace mindspore

4
mindspore/lite/src/ops/logical_not.h
View File

@ -28,9 +28,11 @@ namespace lite {
class LogicalNot : public ArithmeticSelf {
public:
#ifdef PRIMITIVE_WRITEABLE
LogicalNot() = default;
explicit LogicalNot(schema::PrimitiveT *primitive) : ArithmeticSelf(primitive) {}
#endif
#else
explicit LogicalNot(schema::Primitive *primitive) : ArithmeticSelf(primitive) {}
#endif
};
} // namespace lite
} // namespace mindspore

4
mindspore/lite/src/ops/logical_or.h
View File

@ -28,9 +28,11 @@ namespace lite {
class LogicalOr : public Arithmetic {
public:
#ifdef PRIMITIVE_WRITEABLE
LogicalOr() = default;
explicit LogicalOr(schema::PrimitiveT *primitive) : Arithmetic(primitive) {}
#endif
#else
explicit LogicalOr(schema::Primitive *primitive) : Arithmetic(primitive) {}
#endif
};
} // namespace lite
} // namespace mindspore

5
mindspore/lite/src/ops/lrn.h
View File

@ -28,10 +28,11 @@ namespace lite {
class Lrn : public PrimitiveC {
public:
#ifdef PRIMITIVE_WRITEABLE
Lrn() = default;
explicit Lrn(schema::PrimitiveT *primitive) : PrimitiveC(primitive) {}
#endif
#else
explicit Lrn(schema::Primitive *primitive) : PrimitiveC(primitive) {}
#endif
float GetAlpha() const;
float GetBeta() const;
float GetBias() const;

5
mindspore/lite/src/ops/lstm.h
View File

@ -28,10 +28,11 @@ namespace lite {
class Lstm : public PrimitiveC {
public:
#ifdef PRIMITIVE_WRITEABLE
Lstm() = default;
explicit Lstm(schema::PrimitiveT *primitive) : PrimitiveC(primitive) {}
#endif
#else
explicit Lstm(schema::Primitive *primitive) : PrimitiveC(primitive) {}
#endif
int InferShape(std::vector<lite::tensor::Tensor *> inputs_, std::vector<lite::tensor::Tensor *> outputs_) override;
bool GetBidirection() const;
void SetBidirection(bool bidirection);

31
mindspore/lite/tools/anf_importer/anf_populater/anf_quant_populater.h → mindspore/lite/src/ops/make_tuple.cc
View File

@ -13,18 +13,21 @@
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef MINDSPORE_ANF_QUANT_PARSER_H
#define MINDSPORE_ANF_QUANT_PARSER_H
#include "tools/anf_importer/anf_populater/anf_node_populater.h"
#include <vector>
namespace mindspore::lite {
class AnfQuantPopulater : public AnfNodePopulater {
public:
AnfQuantPopulater() = default;
~AnfQuantPopulater() override = default;
int Populate(const PrimitivePtr &prim, PrimitiveC *primitiveCPtr,
const std::vector<AnfNodePtr> &inputs) override;
};
} // namespace mindspore::lite
#endif // MINDSPORE_ANF_QUANT_PARSER_H
#include "src/ops/make_tuple.h"
#include <vector>
#include <memory>
namespace mindspore {
namespace lite {
#ifdef PRIMITIVE_WRITEABLE
int MakeTuple::UnPackAttr(const Primitive &prim, const std::vector<AnfNodePtr> &inputs) {
this->primitive_ = new (schema::PrimitiveT);
auto attr = std::make_unique<schema::MakeTupleT>();
this->primitive_->value.type = schema::PrimitiveType_MakeTuple;
this->primitive_->value.value = attr.release();
return RET_OK;
}
#endif
} // namespace lite
} // namespace mindspore

37
mindspore/lite/src/ops/make_tuple.h Normal file
View File

@ -0,0 +1,37 @@
/**
* Copyright 2020 Huawei Technologies Co., Ltd
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef LITE_MINDSPORE_LITE_SRC_OPS_MAKE_TUPLE_H_
#define LITE_MINDSPORE_LITE_SRC_OPS_MAKE_TUPLE_H_
#include <vector>
#include "src/ops/primitive_c.h"
namespace mindspore {
namespace lite {
class MakeTuple : public PrimitiveC {
public:
#ifdef PRIMITIVE_WRITEABLE
MakeTuple() = default;
explicit MakeTuple(schema::PrimitiveT *primitive) : PrimitiveC(primitive) {}
int UnPackAttr(const Primitive &prim, const std::vector<AnfNodePtr> &inputs);
#else
explicit MakeTuple(schema::Primitive *primitive) : PrimitiveC(primitive) {}
#endif
};
} // namespace lite
} // namespace mindspore
#endif // LITE_MINDSPORE_LITE_SRC_OPS_MAKE_TUPLE_H_

100
mindspore/lite/src/ops/matmul.cc
View File

@ -15,7 +15,11 @@
*/
#include "src/ops/matmul.h"
#include <memory>
#include <utility>
#ifdef PRIMITIVE_WRITEABLE
#include "tools/converter/quantizer/quantize_util.h"
#endif
namespace mindspore {
namespace lite {
@ -26,6 +30,102 @@ bool MatMul::GetTransposeB() const { return this->primitive_->value.AsMatMul()->
void MatMul::SetTransposeA(bool transpose_a) { this->primitive_->value.AsMatMul()->transposeA = transpose_a; }
void MatMul::SetTransposeB(bool transpose_b) { this->primitive_->value.AsMatMul()->transposeB = transpose_b; }
void MatMul::CalQuantParam(const double &mean, const double &stdDev, float *mMin, float *mMax) {
constexpr float qmin = 0;
constexpr float qmax = 255;
*mMin = static_cast<float>((qmin - mean) / stdDev);
*mMax = static_cast<float>((qmax - mean) / stdDev);
}
void MatMul::PopulaterQuantParam(const Primitive &prim,
std::vector<std::vector<schema::QuantParamT>> *vecInputQuantParam,
std::vector<std::vector<schema::QuantParamT>> *vecOutputQuantParam) {
auto narrow_range = prim.GetAttr("narrow_range");
bool narrowRangeQuantParam = GetValue<bool>(narrow_range);
auto num_bits = prim.GetAttr("num_bits");
int32_t numbitsRangeQuantParam = GetValue<int32_t>(num_bits);
std::vector<schema::QuantParamT> quants;
schema::QuantParamT quantParam;
auto mean = prim.GetAttr("mean");
auto std_dev = prim.GetAttr("std_dev");
if (mean != nullptr && std_dev != nullptr) {
auto meanQuantOaram = GetValue<double>(mean);
double stddevQuantOaram = GetValue<double>(std_dev);
float mMin = 0.0;
float mMax = 0.0;
CalQuantParam(meanQuantOaram, stddevQuantOaram, &mMin, &mMax);
quantParam.min = mMin;
quantParam.max = mMax;
} else {
auto inputMin = prim.GetAttr("input_minq");
auto inputMax = prim.GetAttr("input_maxq");
auto inputMinPtr = inputMin->cast<lite::tensor::TensorPtr>();
auto inputMaxPtr = inputMax->cast<lite::tensor::TensorPtr>();
float *minBuf = static_cast<float *>(inputMinPtr->Data());
float *maxBuf = static_cast<float *>(inputMaxPtr->Data());
quantParam.min = *minBuf;
quantParam.max = *maxBuf;
}
quant::CalQuantizationParams(&quantParam, quantParam.min, quantParam.max, narrowRangeQuantParam,
numbitsRangeQuantParam);
quants.emplace_back(quantParam);
vecInputQuantParam->emplace_back(quants);
quants.clear();
auto filterMin = prim.GetAttr("filter_minq");
auto filterMax = prim.GetAttr("filter_maxq");
if (filterMin != nullptr && filterMax != nullptr) {
auto filterMinPtr = filterMin->cast<lite::tensor::TensorPtr>();
auto filterMaxPtr = filterMax->cast<lite::tensor::TensorPtr>();
float *minBuf = static_cast<float *>(filterMinPtr->Data());
float *maxBuf = static_cast<float *>(filterMaxPtr->Data());
for (int i = 0; i < filterMinPtr->DataSize(); ++i) {
quantParam.min = *(minBuf++);
quantParam.max = *(maxBuf++);
quant::CalQuantizationParams(&quantParam, quantParam.min, quantParam.max, narrowRangeQuantParam,
numbitsRangeQuantParam);
quants.emplace_back(quantParam);
}
vecInputQuantParam->emplace_back(quants);
}
quants.clear();
auto outputMin = prim.GetAttr("output_minq");
auto outputMax = prim.GetAttr("output_maxq");
if (outputMin != nullptr && outputMax != nullptr) {
auto outputMinPtr = outputMin->cast<lite::tensor::TensorPtr>();
auto outputMaxPtr = outputMax->cast<lite::tensor::TensorPtr>();
float *minBuf = static_cast<float *>(outputMinPtr->Data());
float *maxBuf = static_cast<float *>(outputMaxPtr->Data());
quantParam.min = *minBuf;
quantParam.max = *maxBuf;
quant::CalQuantizationParams(&quantParam, quantParam.min, quantParam.max, narrowRangeQuantParam,
numbitsRangeQuantParam);
quants.emplace_back(quantParam);
vecOutputQuantParam->emplace_back(quants);
}
}
int MatMul::UnPackAttr(const Primitive &prim, const std::vector<AnfNodePtr> &inputs) {
this->primitive_ = new (schema::PrimitiveT);
auto attr = std::make_unique<schema::MatMulT>();
attr->transposeA = GetValue<bool>(prim.GetAttr("transpose_a"));
attr->transposeB = GetValue<bool>(prim.GetAttr("transpose_b"));
this->primitive_->value.type = schema::PrimitiveType_MatMul;
this->primitive_->value.value = attr.release();
if (GetQuantType() == schema::QuantType_AwareTraining) {
std::vector<std::vector<schema::QuantParamT>> vecInputQuantParam;
std::vector<std::vector<schema::QuantParamT>> vecOutputQuantParam;
PopulaterQuantParam(prim, &vecInputQuantParam, &vecOutputQuantParam);
SetInputQuantParam(vecInputQuantParam);
SetOutputQuantParam(vecOutputQuantParam);
}
return RET_OK;
}
#else
bool MatMul::GetTransposeA() const { return this->primitive_->value_as_MatMul()->transposeA(); }

19
mindspore/lite/src/ops/matmul.h
View File

@ -20,18 +20,29 @@
#include <vector>
#include <set>
#include <cmath>
#include "ir/dtype/type_id.h"
#include "src/ops/primitive_c.h"
#include "ir/dtype/type_id.h"
namespace mindspore {
namespace lite {
class MatMul : public PrimitiveC {
public:
#ifdef PRIMITIVE_WRITEABLE
public:
MatMul() = default;
explicit MatMul(schema::PrimitiveT *primitive) : PrimitiveC(primitive) {}
#endif
explicit MatMul(schema::Primitive *primitive) : PrimitiveC(primitive) {}
int UnPackAttr(const Primitive &prim, const std::vector<AnfNodePtr> &inputs);
private:
void PopulaterQuantParam(const Primitive &prim, std::vector<std::vector<schema::QuantParamT>> *vecInputQuantParam,
std::vector<std::vector<schema::QuantParamT>> *vecOutputQuantParam);
void CalQuantParam(const double &mean, const double &stdDev, float *mMin, float *mMax);
#else
public:
explicit MatMul(schema::Primitive *primitive) : PrimitiveC(primitive) {}
#endif
public:
int InferShape(std::vector<lite::tensor::Tensor *> inputs_, std::vector<lite::tensor::Tensor *> outputs_) override;
bool GetTransposeA() const;
bool GetTransposeB() const;

5
mindspore/lite/src/ops/matrix_diag.h
View File

@ -28,10 +28,11 @@ namespace lite {
class MatrixDiag : public PrimitiveC {
public:
#ifdef PRIMITIVE_WRITEABLE
MatrixDiag() = default;
explicit MatrixDiag(schema::PrimitiveT *primitive) : PrimitiveC(primitive) {}
#endif
#else
explicit MatrixDiag(schema::Primitive *primitive) : PrimitiveC(primitive) {}
#endif
int GetK() const;
int GetNumRows() const;
int GetNumCols() const;

4
mindspore/lite/src/ops/maximum.h
View File

@ -28,9 +28,11 @@ namespace lite {
class Maximum : public Arithmetic {
public:
#ifdef PRIMITIVE_WRITEABLE
Maximum() = default;
explicit Maximum(schema::PrimitiveT *primitive) : Arithmetic(primitive) {}
#endif
#else
explicit Maximum(schema::Primitive *primitive) : Arithmetic(primitive) {}
#endif
};
} // namespace lite
} // namespace mindspore

5
mindspore/lite/src/ops/mean.h
View File

@ -28,10 +28,11 @@ namespace lite {
class Mean : public PrimitiveC {
public:
#ifdef PRIMITIVE_WRITEABLE
Mean() = default;
explicit Mean(schema::PrimitiveT *primitive) : PrimitiveC(primitive) {}
#endif
#else
explicit Mean(schema::Primitive *primitive) : PrimitiveC(primitive) {}
#endif
int InferShape(std::vector<lite::tensor::Tensor *> inputs_, std::vector<lite::tensor::Tensor *> outputs_) override;
std::vector<int> GetAxis() const;
bool GetKeepDims() const;

4
mindspore/lite/src/ops/minimum.h
View File

@ -28,9 +28,11 @@ namespace lite {
class Minimum : public Arithmetic {
public:
#ifdef PRIMITIVE_WRITEABLE
Minimum() = default;
explicit Minimum(schema::PrimitiveT *primitive) : Arithmetic(primitive) {}
#endif
#else
explicit Minimum(schema::Primitive *primitive) : Arithmetic(primitive) {}
#endif
};
} // namespace lite
} // namespace mindspore

9
mindspore/lite/src/ops/mul.cc
View File

@ -15,6 +15,7 @@
*/
#include "src/ops/mul.h"
#include <memory>
namespace mindspore {
namespace lite {
@ -24,6 +25,14 @@ int Mul::GetActivationType() const { return this->primitive_->value.AsMul()->act
void Mul::SetActivationType(int activation_type) {
this->primitive_->value.AsMul()->activationType = (schema::ActivationType)activation_type;
}
int Mul::UnPackAttr(const Primitive &prim, const std::vector<AnfNodePtr> &inputs) {
this->primitive_ = new (schema::PrimitiveT);
auto attr = std::make_unique<schema::MulT>();
this->primitive_->value.type = schema::PrimitiveType_Mul;
this->primitive_->value.value = attr.release();
return RET_OK;
}
#else

7
mindspore/lite/src/ops/mul.h
View File

@ -28,12 +28,15 @@ namespace lite {
class Mul : public Arithmetic {
public:
#ifdef PRIMITIVE_WRITEABLE
Mul() = default;
explicit Mul(schema::PrimitiveT *primitive) : Arithmetic(primitive) {}
#endif
#else
explicit Mul(schema::Primitive *primitive) : Arithmetic(primitive) {}
#endif
int GetActivationType() const;
void SetActivationType(int activation_type);
int UnPackAttr(const Primitive &prim, const std::vector<AnfNodePtr> &inputs);
};
} // namespace lite
} // namespace mindspore

5
mindspore/lite/src/ops/nchw2nhwc.h
View File

@ -28,10 +28,11 @@ namespace lite {
class Nchw2Nhwc : public PrimitiveC {
public:
#ifdef PRIMITIVE_WRITEABLE
Nchw2Nhwc() = default;
explicit Nchw2Nhwc(schema::PrimitiveT *primitive) : PrimitiveC(primitive) {}
#endif
#else
explicit Nchw2Nhwc(schema::Primitive *primitive) : PrimitiveC(primitive) {}
#endif
int InferShape(std::vector<lite::tensor::Tensor *> inputs_, std::vector<lite::tensor::Tensor *> outputs_) override;
};
} // namespace lite

5
mindspore/lite/src/ops/nhwc2nchw.h
View File

@ -28,10 +28,11 @@ namespace lite {
class Nhwc2Nchw : public PrimitiveC {
public:
#ifdef PRIMITIVE_WRITEABLE
Nhwc2Nchw() = default;
explicit Nhwc2Nchw(schema::PrimitiveT *primitive) : PrimitiveC(primitive) {}
#endif
#else
explicit Nhwc2Nchw(schema::Primitive *primitive) : PrimitiveC(primitive) {}
#endif
int InferShape(std::vector<lite::tensor::Tensor *> inputs_, std::vector<lite::tensor::Tensor *> outputs_) override;
};
} // namespace lite

4
mindspore/lite/src/ops/not_equal.h
View File

@ -28,9 +28,11 @@ namespace lite {
class NotEqual : public Arithmetic {
public:
#ifdef PRIMITIVE_WRITEABLE
NotEqual() = default;
explicit NotEqual(schema::PrimitiveT *primitive) : Arithmetic(primitive) {}
#endif
#else
explicit NotEqual(schema::Primitive *primitive) : Arithmetic(primitive) {}
#endif
};
} // namespace lite
} // namespace mindspore

5
mindspore/lite/src/ops/one_hot.h
View File

@ -28,10 +28,11 @@ namespace lite {
class OneHot : public PrimitiveC {
public:
#ifdef PRIMITIVE_WRITEABLE
OneHot() = default;
explicit OneHot(schema::PrimitiveT *primitive) : PrimitiveC(primitive) {}
#endif
#else
explicit OneHot(schema::Primitive *primitive) : PrimitiveC(primitive) {}
#endif
int InferShape(std::vector<lite::tensor::Tensor *> inputs_, std::vector<lite::tensor::Tensor *> outputs_) override;
int GetAxis() const;
void SetAxis(int axis);

5
mindspore/lite/src/ops/pad.h
View File

@ -28,10 +28,11 @@ namespace lite {
class Pad : public PrimitiveC {
public:
#ifdef PRIMITIVE_WRITEABLE
Pad() = default;
explicit Pad(schema::PrimitiveT *primitive) : PrimitiveC(primitive) {}
#endif
#else
explicit Pad(schema::Primitive *primitive) : PrimitiveC(primitive) {}
#endif
int InferShape(std::vector<lite::tensor::Tensor *> inputs_, std::vector<lite::tensor::Tensor *> outputs_) override;
std::vector<int> GetPaddings() const;
int GetPaddingMode() const;

5
mindspore/lite/src/ops/permute.h
View File

@ -28,10 +28,11 @@ namespace lite {
class Permute : public PrimitiveC {
public:
#ifdef PRIMITIVE_WRITEABLE
Permute() = default;
explicit Permute(schema::PrimitiveT *primitive) : PrimitiveC(primitive) {}
#endif
#else
explicit Permute(schema::Primitive *primitive) : PrimitiveC(primitive) {}
#endif
std::vector<long> GetOrder() const;
void SetOrder(const std::vector<long> &order);
};

44
mindspore/lite/src/ops/pooling.cc
View File

@ -15,6 +15,9 @@
*/
#include "src/ops/pooling.h"
#include <memory>
#include <string>
#include <vector>
namespace mindspore {
namespace lite {
@ -52,6 +55,47 @@ void Pooling::SetRoundMode(int round_mode) {
this->primitive_->value.AsPooling()->roundMode = (schema::RoundMode)round_mode;
}
int Pooling::UnPackAttr(const Primitive &prim, const std::vector<AnfNodePtr> &inputs) {
this->primitive_ = new (schema::PrimitiveT);
auto attr = std::make_unique<schema::PoolingT>();
if (prim.instance_name() == "MaxPool") {
attr->poolingMode = schema::PoolMode_MAX_POOLING;
} else if (prim.instance_name() == "MeanPool") {
attr->poolingMode = schema::PoolMode_MEAN_POOLING;
}
auto format = GetValue<std::string>(prim.GetAttr("data_format"));
if (format == "NCHW") {
attr->format = schema::Format_NCHW;
} else if (format == "NHWC") {
attr->format = schema::Format_NHWC;
} else {
attr->format = schema::Format_NUM_OF_FORMAT;
}
auto pad_mode = GetValue<std::string>(prim.GetAttr("padding"));
if (pad_mode == "VALID") {
attr->padMode = schema::PadMode_VALID;
} else if (pad_mode == "SAME") {
attr->padMode = schema::PadMode_SAME;
} else {
attr->padMode = schema::PadMode_NOTSET;
}
auto kernel_size = GetValue<std::vector<int>>(prim.GetAttr("ksize"));
attr->windowH = kernel_size[2];
attr->windowW = kernel_size[3];
auto stride = GetValue<std::vector<int>>(prim.GetAttr("strides"));
attr->strideH = stride[2];
attr->strideW = stride[3];
this->primitive_->value.type = schema::PrimitiveType_Pooling;
this->primitive_->value.value = attr.release();
return RET_OK;
}
#else
int Pooling::GetFormat() const { return this->primitive_->value_as_Pooling()->format(); }

7
mindspore/lite/src/ops/pooling.h
View File

@ -28,10 +28,11 @@ namespace lite {
class Pooling : public PrimitiveC {
public:
#ifdef PRIMITIVE_WRITEABLE
Pooling() = default;
explicit Pooling(schema::PrimitiveT *primitive) : PrimitiveC(primitive) {}
#endif
#else
explicit Pooling(schema::Primitive *primitive) : PrimitiveC(primitive) {}
#endif
int InferShape(std::vector<lite::tensor::Tensor *> inputs_, std::vector<lite::tensor::Tensor *> outputs_) override;
int GetFormat() const;
int GetPoolingMode() const;
@ -65,6 +66,8 @@ class Pooling : public PrimitiveC {
int PadLeft() const;
int PadRight() const;
int UnPackAttr(const Primitive &prim, const std::vector<AnfNodePtr> &inputs);
protected:
int pad_u_ = 0;
int pad_d_ = 0;

5
mindspore/lite/src/ops/pooling_grad.h
View File

@ -28,10 +28,11 @@ namespace lite {
class PoolingGrad : public PrimitiveC {
public:
#ifdef PRIMITIVE_WRITEABLE
PoolingGrad() = default;
explicit PoolingGrad(schema::PrimitiveT *primitive) : PrimitiveC(primitive) {}
#endif
#else
explicit PoolingGrad(schema::Primitive *primitive) : PrimitiveC(primitive) {}
#endif
int GetFormat() const;
int GetPoolingMode() const;
bool GetGlobal() const;

5
mindspore/lite/src/ops/power.h
View File

@ -28,10 +28,11 @@ namespace lite {
class Power : public PrimitiveC {
public:
#ifdef PRIMITIVE_WRITEABLE
Power() = default;
explicit Power(schema::PrimitiveT *primitive) : PrimitiveC(primitive) {}
#endif
#else
explicit Power(schema::Primitive *primitive) : PrimitiveC(primitive) {}
#endif
int InferShape(std::vector<lite::tensor::Tensor *> inputs_, std::vector<lite::tensor::Tensor *> outputs_) override;
float GetPower() const;
float GetScale() const;

5
mindspore/lite/src/ops/power_grad.h
View File

@ -28,10 +28,11 @@ namespace lite {
class PowerGrad : public PrimitiveC {
public:
#ifdef PRIMITIVE_WRITEABLE
PowerGrad() = default;
explicit PowerGrad(schema::PrimitiveT *primitive) : PrimitiveC(primitive) {}
#endif
#else
explicit PowerGrad(schema::Primitive *primitive) : PrimitiveC(primitive) {}
#endif
float GetPower() const;
float GetScale() const;
float GetShift() const;

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