ling
4 years ago
parent
74dc7d069d
commit
7454b9688c
@ -1,102 +0,0 @@
|
||||
/**
|
||||
* Copyright 2020 Huawei Technologies Co., Ltd
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*/
|
||||
#include "nnacl/arg_min_max.h"
|
||||
#include "nnacl/fp32/arg_min_max_fp32.h"
|
||||
|
||||
#define FLOAT_DATA_TYPE 43
|
||||
|
||||
void GetCalcParameter(const int *shape, int dims_number, int axis, int *pre_axis_count, int *axis_count,
|
||||
int *after_axis_count) {
|
||||
*pre_axis_count = 1;
|
||||
for (int i = 0; i < axis; ++i) {
|
||||
*pre_axis_count = (*pre_axis_count) * shape[i];
|
||||
}
|
||||
|
||||
*axis_count = shape[axis];
|
||||
|
||||
*after_axis_count = 1;
|
||||
for (int i = axis + 1; i < dims_number; ++i) {
|
||||
*after_axis_count = (*after_axis_count) * shape[i];
|
||||
}
|
||||
}
|
||||
|
||||
void ArgMinMaxTopk1(const void *input, void *output, const int *shape, const ArgMinMaxParameter *param) {
|
||||
int pre_axis_count = 1;
|
||||
int axis_count = 1;
|
||||
int after_axis_count = 1;
|
||||
GetCalcParameter(shape, param->dims_size_, param->axis_, &pre_axis_count, &axis_count, &after_axis_count);
|
||||
if (param->data_type_ != FLOAT_DATA_TYPE) {
|
||||
return;
|
||||
}
|
||||
if (param->get_max_) {
|
||||
ArgMax(input, output, param, pre_axis_count, axis_count, after_axis_count);
|
||||
} else {
|
||||
ArgMin(input, output, param, pre_axis_count, axis_count, after_axis_count);
|
||||
}
|
||||
}
|
||||
|
||||
void ArgMinMaxTopknFp32(const float *input, float *output, const int *in_shape, const ArgMinMaxParameter *param) {
|
||||
if (param->get_max_) {
|
||||
switch (param->axis_) {
|
||||
case 0:
|
||||
ArgMaxDim0(input, output, in_shape, param);
|
||||
break;
|
||||
case 1:
|
||||
ArgMaxDim1(input, output, in_shape, param);
|
||||
break;
|
||||
case 2:
|
||||
ArgMaxDim2(input, output, in_shape, param);
|
||||
break;
|
||||
case 3:
|
||||
ArgMaxDim3(input, output, in_shape, param);
|
||||
break;
|
||||
}
|
||||
} else {
|
||||
switch (param->axis_) {
|
||||
case 0:
|
||||
ArgMinDim0(input, output, in_shape, param);
|
||||
break;
|
||||
case 1:
|
||||
ArgMinDim1(input, output, in_shape, param);
|
||||
break;
|
||||
case 2:
|
||||
ArgMinDim2(input, output, in_shape, param);
|
||||
break;
|
||||
case 3:
|
||||
ArgMinDim3(input, output, in_shape, param);
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void ArgMinMax(const void *input, void *output, const int *in_shape, const ArgMinMaxParameter *param) {
|
||||
if (param->topk_ == 1) {
|
||||
ArgMinMaxTopk1(input, output, in_shape, param);
|
||||
return;
|
||||
}
|
||||
|
||||
switch (param->data_type_) {
|
||||
case FLOAT_DATA_TYPE: {
|
||||
ArgMinMaxTopknFp32(input, output, in_shape, param);
|
||||
return;
|
||||
}
|
||||
default:
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
#undef FLOAT_DATA_TYPE
|
||||
#undef INT8_DATA_TYPE
|
||||
@ -1,29 +0,0 @@
|
||||
/**
|
||||
* 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 MINDSPORE_LITE_NNACL_ARG_MIN_MAX_H_
|
||||
#define MINDSPORE_LITE_NNACL_ARG_MIN_MAX_H_
|
||||
|
||||
#include "nnacl/arg_min_max_parameter.h"
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
void ArgMinMax(const void *input, void *output, const int *in_shape, const ArgMinMaxParameter *param);
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif // MINDSPORE_LITE_NNACL_ARG_MIN_MAX_H_
|
||||
File diff suppressed because it is too large
Load Diff
@ -1,47 +0,0 @@
|
||||
/**
|
||||
* Copyright 2020 Huawei Technologies Co., Ltd
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*/
|
||||
#include "nnacl/fp32/instance_norm_fp32.h"
|
||||
#include <math.h>
|
||||
#include "nnacl/errorcode.h"
|
||||
#include "nnacl/op_base.h"
|
||||
|
||||
int InstanceNorm(int outer_size, int inner_size, const float *src_data, const float *scale_data, const float *bias_data,
|
||||
const InstanceNormParameter *param, float *dst_data, int task_id, int thread_num) {
|
||||
if (src_data == NULL || dst_data == NULL || scale_data == NULL || bias_data == NULL) {
|
||||
return NNACL_NULL_PTR;
|
||||
}
|
||||
for (int j = task_id; j < outer_size; j += thread_num) {
|
||||
int offset = (j / param->channel_) * inner_size * param->channel_;
|
||||
const float *src = src_data + offset;
|
||||
float *dst = dst_data + offset;
|
||||
float mean = 0.0f;
|
||||
float square_mean = 0.0f;
|
||||
for (int i = 0; i < inner_size; i++) {
|
||||
int idx = j % param->channel_ + i * param->channel_;
|
||||
mean += src[idx];
|
||||
square_mean += src[idx] * src[idx];
|
||||
}
|
||||
mean /= (float)inner_size;
|
||||
square_mean /= (float)inner_size;
|
||||
const float deno = 1 / sqrtf(square_mean - mean * mean + param->epsilon_);
|
||||
for (int i = 0; i < inner_size; ++i) {
|
||||
int idx = j % param->channel_ + i * param->channel_;
|
||||
int scale_idx = (j / param->channel_) * param->channel_ + j % param->channel_;
|
||||
dst[idx] = ((src[idx] - mean) * deno) * scale_data[scale_idx] + bias_data[scale_idx];
|
||||
}
|
||||
}
|
||||
return NNACL_OK;
|
||||
}
|
||||
@ -1,32 +0,0 @@
|
||||
/**
|
||||
* 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 MINDSPORE_LITE_NNACL_FP32_INSTANCE_NORM_H_
|
||||
#define MINDSPORE_LITE_NNACL_FP32_INSTANCE_NORM_H_
|
||||
|
||||
#include "nnacl/op_base.h"
|
||||
#include "nnacl/instance_norm_parameter.h"
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
int InstanceNorm(int outer_size, int inner_size, const float *src_data, const float *scale_data, const float *bias_data,
|
||||
const InstanceNormParameter *param, float *dst_data, int task_id, int thread_num);
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif // MINDSPORE_LITE_NNACL_FP32_INSTANCE_NORM_H_
|
||||
@ -1,118 +0,0 @@
|
||||
/**
|
||||
* Copyright 2020 Huawei Technologies Co., Ltd
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*/
|
||||
#include "src/runtime/kernel/arm/base/arg_min_max_base.h"
|
||||
#include "nnacl/arg_min_max.h"
|
||||
#include "src/runtime/kernel/arm/fp32/argminmax_fp32.h"
|
||||
#include "nnacl/arithmetic_common.h"
|
||||
#include "schema/model_generated.h"
|
||||
#include "src/kernel_registry.h"
|
||||
#include "include/errorcode.h"
|
||||
#include "include/context.h"
|
||||
|
||||
using mindspore::lite::KernelRegistrar;
|
||||
using mindspore::lite::RET_ERROR;
|
||||
using mindspore::lite::RET_FORMAT_ERR;
|
||||
using mindspore::lite::RET_OK;
|
||||
using mindspore::lite::RET_PARAM_INVALID;
|
||||
using mindspore::schema::PrimitiveType_ArgMax;
|
||||
using mindspore::schema::PrimitiveType_ArgMin;
|
||||
|
||||
namespace mindspore::kernel {
|
||||
int ArgMinMaxBaseCPUKernel::Init() {
|
||||
auto param = reinterpret_cast<ArgMinMaxParameter *>(op_parameter_);
|
||||
switch (op_parameter_->type_) {
|
||||
case PrimitiveType_ArgMax:
|
||||
param->get_max_ = true;
|
||||
break;
|
||||
case PrimitiveType_ArgMin:
|
||||
param->get_max_ = false;
|
||||
break;
|
||||
default:
|
||||
MS_LOG(ERROR) << "Unexpected type " << op_parameter_->type_;
|
||||
return RET_ERROR;
|
||||
}
|
||||
|
||||
return RET_OK;
|
||||
}
|
||||
|
||||
int ArgMinMaxBaseCPUKernel::ReSize() {
|
||||
auto in_shape = in_tensors_.at(0)->shape();
|
||||
auto dims_size = in_shape.size();
|
||||
auto param = reinterpret_cast<ArgMinMaxParameter *>(op_parameter_);
|
||||
int axis = param->axis_ < 0 ? param->axis_ + dims_size : param->axis_;
|
||||
param->axis_ = axis;
|
||||
param->dims_size_ = dims_size;
|
||||
if (param->topk_ <= 0) {
|
||||
MS_LOG(ERROR) << "Invalid topk " << param->topk_;
|
||||
return RET_PARAM_INVALID;
|
||||
}
|
||||
param->topk_ = MSMIN(param->topk_, in_shape.at(axis));
|
||||
ComputeStrides(in_shape.data(), param->in_strides_, in_shape.size());
|
||||
auto out_shape = out_tensors_.at(0)->shape();
|
||||
ComputeStrides(out_shape.data(), param->out_strides_, out_shape.size());
|
||||
return RET_OK;
|
||||
}
|
||||
|
||||
int ArgMinMaxBaseCPUKernel::Run() {
|
||||
auto input_data = in_tensors_.at(0)->MutableData();
|
||||
auto output_data = out_tensors_.at(0)->MutableData();
|
||||
|
||||
auto shape = in_tensors_.at(0)->shape();
|
||||
|
||||
auto param = reinterpret_cast<ArgMinMaxParameter *>(op_parameter_);
|
||||
MS_ASSERT(context_->allocator != nullptr);
|
||||
if (param->topk_ > 1 || param->keep_dims_) {
|
||||
param->arg_elements_ =
|
||||
reinterpret_cast<ArgElement *>(context_->allocator->Malloc(sizeof(ArgElement) * shape[param->axis_]));
|
||||
if (param->arg_elements_ == nullptr) {
|
||||
MS_LOG(ERROR) << "malloc memroy fail!";
|
||||
return RET_ERROR;
|
||||
}
|
||||
}
|
||||
ArgMinMax(input_data, output_data, reinterpret_cast<const int *>(shape.data()), param);
|
||||
context_->allocator->Free(param->arg_elements_);
|
||||
param->arg_elements_ = nullptr;
|
||||
return RET_OK;
|
||||
}
|
||||
|
||||
kernel::LiteKernel *CpuArgMinMaxFp32KernelCreator(const std::vector<lite::Tensor *> &inputs,
|
||||
const std::vector<lite::Tensor *> &outputs, OpParameter *op_parameter,
|
||||
const lite::InnerContext *ctx, const kernel::KernelKey &desc,
|
||||
const mindspore::lite::PrimitiveC *primitive) {
|
||||
if (op_parameter == nullptr) {
|
||||
MS_LOG(ERROR) << "Input op_parameter is nullptr!";
|
||||
return nullptr;
|
||||
}
|
||||
auto kernel = new (std::nothrow) ArgMinMaxCPUKernel(op_parameter, inputs, outputs, ctx, primitive);
|
||||
if (kernel == nullptr) {
|
||||
MS_LOG(ERROR) << "new ArgMinMaxCPUKernel fail!";
|
||||
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_ArgMax, CpuArgMinMaxFp32KernelCreator)
|
||||
REG_KERNEL(kCPU, kNumberTypeFloat32, PrimitiveType_ArgMin, CpuArgMinMaxFp32KernelCreator)
|
||||
|
||||
} // namespace mindspore::kernel
|
||||
@ -1,41 +0,0 @@
|
||||
/**
|
||||
* 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 MINDSPORE_LITE_SRC_RUNTIME_KERNEL_ARM_BASE_ARG_MIN_MAX_BASE_H_
|
||||
#define MINDSPORE_LITE_SRC_RUNTIME_KERNEL_ARM_BASE_ARG_MIN_MAX_BASE_H_
|
||||
|
||||
#include <vector>
|
||||
#include "src/lite_kernel.h"
|
||||
|
||||
namespace mindspore::kernel {
|
||||
class ArgMinMaxBaseCPUKernel : public LiteKernel {
|
||||
public:
|
||||
ArgMinMaxBaseCPUKernel(OpParameter *parameter, const std::vector<lite::Tensor *> &inputs,
|
||||
const std::vector<lite::Tensor *> &outputs, const lite::InnerContext *ctx,
|
||||
const mindspore::lite::PrimitiveC *primitive)
|
||||
: LiteKernel(parameter, inputs, outputs, ctx, primitive) {}
|
||||
|
||||
virtual ~ArgMinMaxBaseCPUKernel() = default;
|
||||
|
||||
int Init() override;
|
||||
int ReSize() override;
|
||||
int Run() override;
|
||||
|
||||
private:
|
||||
};
|
||||
} // namespace mindspore::kernel
|
||||
|
||||
#endif // MINDSPORE_LITE_SRC_RUNTIME_KERNEL_ARM_BASE_ARG_MIN_MAX_BASE_H_
|
||||
@ -1,107 +0,0 @@
|
||||
/**
|
||||
* Copyright 2020 Huawei Technologies Co., Ltd
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*/
|
||||
#include "src/runtime/kernel/arm/fp32/instance_norm_fp32.h"
|
||||
#include <vector>
|
||||
#include "schema/model_generated.h"
|
||||
#include "src/kernel_registry.h"
|
||||
#include "include/errorcode.h"
|
||||
|
||||
using mindspore::kernel::KERNEL_ARCH::kCPU;
|
||||
using mindspore::lite::KernelRegistrar;
|
||||
using mindspore::lite::RET_ERROR;
|
||||
using mindspore::lite::RET_OK;
|
||||
using mindspore::schema::PrimitiveType_InstanceNorm;
|
||||
|
||||
namespace mindspore::kernel {
|
||||
int InstanceNormCPUKernel::Init() {
|
||||
if (!InferShapeDone()) {
|
||||
return RET_OK;
|
||||
}
|
||||
return ReSize();
|
||||
}
|
||||
|
||||
int InstanceNormCPUKernel::ReSize() {
|
||||
auto input_shapes = in_tensors_.front()->shape();
|
||||
auto n_dim = input_shapes.size();
|
||||
outer_size_ = input_shapes.at(0) * input_shapes.at(n_dim - 1);
|
||||
inner_size_ = 1;
|
||||
for (size_t i = 0; i < n_dim - 1; ++i) {
|
||||
inner_size_ *= input_shapes.at(i);
|
||||
}
|
||||
param_->channel_ = input_shapes.at(n_dim - 1);
|
||||
return RET_OK;
|
||||
}
|
||||
|
||||
int InstanceNormCPUKernel::DoInstanceNorm(int task_id) {
|
||||
int ret = InstanceNorm(outer_size_, inner_size_, src_data_, scale_data_, bias_data_, param_, dst_data_, task_id,
|
||||
op_parameter_->thread_num_);
|
||||
if (ret != RET_OK) {
|
||||
MS_LOG(ERROR) << "DoInstanceNorm error error_code[" << ret << "]";
|
||||
return ret;
|
||||
}
|
||||
return RET_OK;
|
||||
}
|
||||
|
||||
int InstanceNormRun(void *cdata, int task_id) {
|
||||
auto kernel = reinterpret_cast<InstanceNormCPUKernel *>(cdata);
|
||||
auto ret = kernel->DoInstanceNorm(task_id);
|
||||
if (ret != RET_OK) {
|
||||
MS_LOG(ERROR) << "InstanceNormRun error task_id[" << task_id << "] error_code[" << ret << "]";
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
|
||||
int InstanceNormCPUKernel::Run() {
|
||||
src_data_ = reinterpret_cast<float *>(in_tensors_.at(0)->MutableData());
|
||||
scale_data_ = reinterpret_cast<float *>(in_tensors_.at(1)->MutableData());
|
||||
bias_data_ = reinterpret_cast<float *>(in_tensors_.at(2)->MutableData());
|
||||
dst_data_ = reinterpret_cast<float *>(out_tensors_.at(0)->MutableData());
|
||||
auto ret = ParallelLaunch(this->context_->thread_pool_, InstanceNormRun, this, op_parameter_->thread_num_);
|
||||
if (ret != RET_OK) {
|
||||
MS_LOG(ERROR) << "FillRun error error_code[" << ret << "]";
|
||||
return ret;
|
||||
}
|
||||
return RET_OK;
|
||||
}
|
||||
|
||||
kernel::LiteKernel *CpuInstanceNormFp32KernelCreator(const std::vector<lite::Tensor *> &inputs,
|
||||
const std::vector<lite::Tensor *> &outputs,
|
||||
OpParameter *opParameter, const lite::InnerContext *ctx,
|
||||
const kernel::KernelKey &desc,
|
||||
const mindspore::lite::PrimitiveC *primitive) {
|
||||
if (opParameter == nullptr) {
|
||||
MS_LOG(ERROR) << "Create kernel failed, opParameter is nullptr, type: PrimitiveType_InstanceNorm. ";
|
||||
return nullptr;
|
||||
}
|
||||
MS_ASSERT(desc.type == schema::PrimitiveType_InstanceNorm);
|
||||
auto *kernel = new (std::nothrow) InstanceNormCPUKernel(opParameter, inputs, outputs, ctx, primitive);
|
||||
if (kernel == nullptr) {
|
||||
MS_LOG(ERROR) << "new InstanceNormCPUKernel fail!";
|
||||
free(opParameter);
|
||||
return nullptr;
|
||||
}
|
||||
auto ret = kernel->Init();
|
||||
if (ret != RET_OK) {
|
||||
MS_LOG(ERROR) << "Init kernel failed, name: " << opParameter->name_ << ", type: "
|
||||
<< schema::EnumNamePrimitiveType(static_cast<schema::PrimitiveType>(opParameter->type_));
|
||||
delete kernel;
|
||||
return nullptr;
|
||||
}
|
||||
return kernel;
|
||||
}
|
||||
|
||||
REG_KERNEL(kCPU, kNumberTypeFloat32, PrimitiveType_InstanceNorm, CpuInstanceNormFp32KernelCreator)
|
||||
} // namespace mindspore::kernel
|
||||
@ -1,53 +0,0 @@
|
||||
/**
|
||||
* 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 MINDSPORE_LITE_SRC_RUNTIME_KERNEL_ARM_FP32_INSTANCE_NORM_H_
|
||||
#define MINDSPORE_LITE_SRC_RUNTIME_KERNEL_ARM_FP32_INSTANCE_NORM_H_
|
||||
|
||||
#include <vector>
|
||||
#include "src/lite_kernel.h"
|
||||
#include "include/context.h"
|
||||
#include "nnacl/fp32/instance_norm_fp32.h"
|
||||
|
||||
using mindspore::lite::InnerContext;
|
||||
|
||||
namespace mindspore::kernel {
|
||||
class InstanceNormCPUKernel : public LiteKernel {
|
||||
public:
|
||||
InstanceNormCPUKernel(OpParameter *parameter, const std::vector<lite::Tensor *> &inputs,
|
||||
const std::vector<lite::Tensor *> &outputs, const lite::InnerContext *ctx,
|
||||
const mindspore::lite::PrimitiveC *primitive)
|
||||
: LiteKernel(parameter, inputs, outputs, ctx, primitive) {
|
||||
param_ = reinterpret_cast<InstanceNormParameter *>(parameter);
|
||||
}
|
||||
~InstanceNormCPUKernel() override{};
|
||||
|
||||
int Init() override;
|
||||
int ReSize() override;
|
||||
int Run() override;
|
||||
int DoInstanceNorm(int thread_id);
|
||||
|
||||
private:
|
||||
InstanceNormParameter *param_ = nullptr;
|
||||
int outer_size_;
|
||||
int inner_size_;
|
||||
float *src_data_ = nullptr;
|
||||
float *dst_data_ = nullptr;
|
||||
float *scale_data_ = nullptr;
|
||||
float *bias_data_ = nullptr;
|
||||
};
|
||||
} // namespace mindspore::kernel
|
||||
|
||||
#endif // MINDSPORE_LITE_SRC_RUNTIME_KERNEL_ARM_FP32_INSTANCE_NORM_H_
|
||||
File diff suppressed because it is too large
Load Diff
@ -1,134 +0,0 @@
|
||||
/**
|
||||
* Copyright 2020 Huawei Technologies Co., Ltd
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*/
|
||||
#include <iostream>
|
||||
#include "src/common/log_adapter.h"
|
||||
#include "common/common_test.h"
|
||||
#include "mindspore/lite/nnacl/fp32/instance_norm_fp32.h"
|
||||
#include "mindspore/lite/src/kernel_registry.h"
|
||||
#include "mindspore/lite/src/lite_kernel.h"
|
||||
|
||||
namespace mindspore {
|
||||
class TestInstanceNormFp32 : public mindspore::CommonTest {
|
||||
public:
|
||||
TestInstanceNormFp32() {}
|
||||
};
|
||||
|
||||
TEST_F(TestInstanceNormFp32, INTest1) {
|
||||
std::vector<float> in_data = {-11.18675, 11.433986, 11.386012, 11.245945, -2.7614849, 14.692399,
|
||||
-1.1983503, -6.6790967, 6.383416, -13.3213005, -8.693595, 9.476344};
|
||||
std::vector<float> in_data1 = {12.352293, 5.122387, 14.249514};
|
||||
std::vector<float> in_data2 = {14.632595, 0.70900035, 11.179003};
|
||||
|
||||
InstanceNormParameter op_param;
|
||||
op_param.op_parameter_.type_ = schema::PrimitiveType_InstanceNorm;
|
||||
op_param.epsilon_ = 0.001f;
|
||||
|
||||
lite::Tensor input0_tensor(kNumberTypeFloat32, {1, 2, 2, 3});
|
||||
lite::Tensor input1_tensor(kNumberTypeFloat32, {3});
|
||||
lite::Tensor input2_tensor(kNumberTypeFloat32, {3});
|
||||
input0_tensor.set_data(in_data.data());
|
||||
input1_tensor.set_data(in_data1.data());
|
||||
input2_tensor.set_data(in_data2.data());
|
||||
std::vector<lite::Tensor *> inputs_tensor = {&input0_tensor, &input1_tensor, &input2_tensor};
|
||||
|
||||
std::vector<float> output(12);
|
||||
std::vector<float> corr_out = {5.0145645, 9.248516, 15.439679, 33.51017, 0.0012711287, 31.0666883,
|
||||
17.70254, -2.5507483, -8.204435, 2.3031063, -3.8630369, 6.4138837};
|
||||
|
||||
lite::Tensor output0_tensor(kNumberTypeFloat32, {1, 2, 2, 3});
|
||||
output0_tensor.set_data(output.data());
|
||||
std::vector<lite::Tensor *> outputs_tensor = {&output0_tensor};
|
||||
|
||||
kernel::KernelKey desc = {kernel::KERNEL_ARCH::kCPU, kNumberTypeFloat32, schema::PrimitiveType_InstanceNorm};
|
||||
auto creator = lite::KernelRegistry::GetInstance()->GetCreator(desc);
|
||||
ASSERT_NE(creator, nullptr);
|
||||
lite::InnerContext ctx;
|
||||
ctx.thread_num_ = 4;
|
||||
ASSERT_EQ(lite::RET_OK, ctx.Init());
|
||||
kernel::LiteKernel *kernel =
|
||||
creator(inputs_tensor, outputs_tensor, reinterpret_cast<OpParameter *>(&op_param), &ctx, desc, nullptr);
|
||||
ASSERT_NE(kernel, nullptr);
|
||||
auto output_tensor_shape = output0_tensor.shape();
|
||||
kernel->Run();
|
||||
|
||||
printf("==================output data=================\n");
|
||||
for (int i = 0; i < output0_tensor.ElementsNum(); i++) {
|
||||
std::cout << output[i] << " ,";
|
||||
}
|
||||
std::cout << std::endl;
|
||||
ASSERT_EQ(0, CompareOutputData(output.data(), corr_out.data(), output0_tensor.ElementsNum(), 0.001));
|
||||
|
||||
input0_tensor.set_data(nullptr);
|
||||
input1_tensor.set_data(nullptr);
|
||||
input2_tensor.set_data(nullptr);
|
||||
output0_tensor.set_data(nullptr);
|
||||
}
|
||||
|
||||
TEST_F(TestInstanceNormFp32, INTest2) {
|
||||
std::vector<float> in_data = {-11.18675, 11.433986, 11.386012, 11.245945, -2.7614849, 14.692399,
|
||||
-1.1983503, -6.6790967, 6.383416, -13.3213005, -8.693595, 9.476344,
|
||||
-12.18675, 12.433986, 12.386012, 12.245945, -3.7614849, 15.692399,
|
||||
-2.1983503, -7.6790967, 7.383416, -14.3213005, -9.693595, 10.476344};
|
||||
std::vector<float> in_data1 = {12.352293, 5.122387, 14.249514, 12.352293, 5.122387, 14.249514};
|
||||
std::vector<float> in_data2 = {14.632595, 0.70900035, 11.179003, 14.632595, 0.70900035, 11.179003};
|
||||
|
||||
InstanceNormParameter op_param;
|
||||
op_param.op_parameter_.type_ = schema::PrimitiveType_InstanceNorm;
|
||||
op_param.epsilon_ = 0.001f;
|
||||
|
||||
lite::Tensor input0_tensor(kNumberTypeFloat32, {2, 2, 2, 3});
|
||||
lite::Tensor input1_tensor(kNumberTypeFloat32, {2, 3});
|
||||
lite::Tensor input2_tensor(kNumberTypeFloat32, {2, 3});
|
||||
input0_tensor.set_data(in_data.data());
|
||||
input1_tensor.set_data(in_data1.data());
|
||||
input2_tensor.set_data(in_data2.data());
|
||||
std::vector<lite::Tensor *> inputs_tensor = {&input0_tensor, &input1_tensor, &input2_tensor};
|
||||
|
||||
std::vector<float> output(24);
|
||||
std::vector<float> corr_out = {5.0145645, 9.248516, 15.439679, 33.51017, 0.0012711287, 31.0666883,
|
||||
17.70254, -2.5507483, -8.204435, 2.3031063, -3.8630369, 6.4138837,
|
||||
5.133601, 9.310399, 15.439679, 33.886883, -0.22505027, 31.066883,
|
||||
16.888313, -2.5316327, -8.204435, 2.6215858, -3.717714, 6.4138837};
|
||||
|
||||
lite::Tensor output0_tensor(kNumberTypeFloat32, {2, 2, 2, 3});
|
||||
output0_tensor.set_data(output.data());
|
||||
std::vector<lite::Tensor *> outputs_tensor = {&output0_tensor};
|
||||
|
||||
kernel::KernelKey desc = {kernel::KERNEL_ARCH::kCPU, kNumberTypeFloat32, schema::PrimitiveType_InstanceNorm};
|
||||
auto creator = lite::KernelRegistry::GetInstance()->GetCreator(desc);
|
||||
ASSERT_NE(creator, nullptr);
|
||||
lite::InnerContext ctx;
|
||||
ctx.thread_num_ = 4;
|
||||
ASSERT_EQ(lite::RET_OK, ctx.Init());
|
||||
kernel::LiteKernel *kernel =
|
||||
creator(inputs_tensor, outputs_tensor, reinterpret_cast<OpParameter *>(&op_param), &ctx, desc, nullptr);
|
||||
ASSERT_NE(kernel, nullptr);
|
||||
auto output_tensor_shape = output0_tensor.shape();
|
||||
kernel->Run();
|
||||
|
||||
printf("==================output data=================\n");
|
||||
for (int i = 0; i < output0_tensor.ElementsNum(); i++) {
|
||||
std::cout << output[i] << " ,";
|
||||
}
|
||||
std::cout << std::endl;
|
||||
ASSERT_EQ(0, CompareOutputData(output.data(), corr_out.data(), output0_tensor.ElementsNum(), 0.001));
|
||||
|
||||
input0_tensor.set_data(nullptr);
|
||||
input1_tensor.set_data(nullptr);
|
||||
input2_tensor.set_data(nullptr);
|
||||
output0_tensor.set_data(nullptr);
|
||||
}
|
||||
} // namespace mindspore
|
||||
Loading…
Reference in new issue