Huawei_Technology
/
mindspore
Not watched
1
0
Fork 0
Code
Releases 13 Wiki evaluate Activity
Issues 0 Pull Requests 0 Datasets Model Cloudbrain HPC
Browse Source

!3943 add arm cpu fp32 op: lstm 

Merge pull request !3943 from yangruoqi713/lite
tags/v0.7.0-beta
mindspore-ci-bot Gitee 5 years ago
parent
c1f8ade209 e758b22d39
commit
4b2e26f16b
8 changed files with 861 additions and 0 deletions
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. +69
    -0
      mindspore/lite/src/ops/lstm.cc
  2. +7
    -0
      mindspore/lite/src/ops/ops.h
  3. +19
    -0
      mindspore/lite/src/populate_parameter.cc
  4. +185
    -0
      mindspore/lite/src/runtime/kernel/arm/fp32/lstm.cc
  5. +57
    -0
      mindspore/lite/src/runtime/kernel/arm/fp32/lstm.h
  6. +158
    -0
      mindspore/lite/src/runtime/kernel/arm/opclib/fp32/lstm.cc
  7. +36
    -0
      mindspore/lite/src/runtime/kernel/arm/opclib/fp32/lstm.h
  8. +330
    -0
      mindspore/lite/test/ut/src/runtime/kernel/arm/fp32/lstm_fp32_tests.cc

+ 69
- 0
mindspore/lite/src/ops/lstm.cc View File

@@ -0,0 +1,69 @@
/**
* 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/ops/ops.h"
#include "include/errorcode.h"
#include "utils/log_adapter.h"
#include "src/ir/tensor.h"

namespace mindspore::lite {
const int kLstmInputNum = 6;
const int kLstmOutputNum = 3;
int Lstm::InferShape(std::vector<tensor::Tensor *> inputs_, std::vector<tensor::Tensor *> outputs_) {
MS_ASSERT(this->primitive != nullptr);
if (inputs_.size() != kLstmInputNum || outputs_.size() != kLstmOutputNum) {
MS_LOG(ERROR) << "OpLstm inputs or outputs size error.";
return RET_INPUT_TENSOR_ERROR;
}
auto input = inputs_.front();
MS_ASSERT(input != nullptr);
auto weight_i = inputs_.front();
MS_ASSERT(input0 != nullptr);
auto output = outputs_.front();
MS_ASSERT(output != nullptr);

std::vector<int> in_shape = input->shape();
std::vector<int> w_shape = weight_i->shape(); // layer, hidden_size * 4, input_size
if (in_shape.size() != 3 || w_shape.size() != 3) {
MS_LOG(ERROR) << "OpLstm input dims should be 3.";
return RET_ERROR;
}

auto lstm_prim = this->primitive->value_as_Lstm();
int hidden_size = w_shape[1] / 4;

// set output
std::vector<int> out_shape(in_shape);
out_shape[2] = hidden_size;
if (lstm_prim->bidirection()) {
out_shape.insert(out_shape.begin() + 1, 2);
}
output->set_shape(out_shape);

// set hidden state, cell state
std::vector<int> state_shape(in_shape);
state_shape[0] = lstm_prim->bidirection() ? 2 : 1;
state_shape[2] = hidden_size;
outputs_[1]->set_shape(state_shape);
outputs_[2]->set_shape(state_shape);

for (int i = 0; i < kLstmOutputNum; i++) {
outputs_[i]->set_data_type(input->data_type());
outputs_[i]->SetFormat(input->GetFormat());
}
return RET_OK;
}
} // namespace mindspore::lite

+ 7
- 0
mindspore/lite/src/ops/ops.h View File

@@ -770,6 +770,13 @@ class QuantDTypeCast : public Primitive {
const schema::QuantDTypeCast *GetAttribute() const { return this->primitive->value_as_QuantDTypeCast(); }
int InferShape(std::vector<tensor::Tensor *> inputs, std::vector<tensor::Tensor *> outputs) override;
};

class Lstm : public Primitive {
public:
explicit Lstm(schema::Primitive *primitive) : Primitive(primitive) {}
const schema::Lstm *GetAttribute() const { return this->primitive->value_as_Lstm(); }
int InferShape(std::vector<tensor::Tensor *> inputs, std::vector<tensor::Tensor *> outputs) override;
};
} // namespace lite
} // namespace mindspore
#endif // MINDSPORE_LITE_SRC_OPS_OPS_H_

+ 19
- 0
mindspore/lite/src/populate_parameter.cc View File

@@ -67,6 +67,7 @@
#include "src/runtime/kernel/arm/opclib/fp32/space_to_depth.h"
#include "src/runtime/kernel/arm/opclib/fp32/space_to_batch.h"
#include "src/runtime/kernel/arm/opclib/int8/quant_dtype_cast.h"
#include "src/runtime/kernel/arm/opclib/fp32/lstm.h"

namespace mindspore::kernel {
OpParameter *PopulateFillParameter(const lite::Primitive *primitive) {
@@ -1169,6 +1170,23 @@ OpParameter *PopulatePriorBoxParameter(const lite::Primitive *primitive) {
return reinterpret_cast<OpParameter *>(prior_box_param);
}

OpParameter *PopulateLstmParameter(const lite::Primitive *primitive) {
LstmParameter *lstm_param = new (std::nothrow) LstmParameter();
if (lstm_param == nullptr) {
MS_LOG(ERROR) << "new LstmParameter fail!";
return nullptr;
}
lstm_param->op_parameter_.type_ = primitive->Type();
auto param = primitive->Value()->value_as_Lstm();
if (param == nullptr) {
delete (lstm_param);
MS_LOG(ERROR) << "get Lstm param nullptr.";
return nullptr;
}
lstm_param->bidirectional_ = param->bidirection();
return reinterpret_cast<OpParameter *>(lstm_param);
}

PopulateParameterRegistry::PopulateParameterRegistry() {
populate_parameter_funcs_[schema::PrimitiveType_SoftMax] = PopulateSoftmaxParameter;
populate_parameter_funcs_[schema::PrimitiveType_Activation] = PopulateActivationParameter;
@@ -1244,6 +1262,7 @@ PopulateParameterRegistry::PopulateParameterRegistry() {
populate_parameter_funcs_[schema::PrimitiveType_Split] = PopulateSplitParameter;
populate_parameter_funcs_[schema::PrimitiveType_PriorBox] = PopulatePriorBoxParameter;
populate_parameter_funcs_[schema::PrimitiveType_QuantDTypeCast] = PopulateQuantDTypeCastParameter;
populate_parameter_funcs_[schema::PrimitiveType_Lstm] = PopulateLstmParameter;
}

PopulateParameterRegistry *PopulateParameterRegistry::GetInstance() {


+ 185
- 0
mindspore/lite/src/runtime/kernel/arm/fp32/lstm.cc View File

@@ -0,0 +1,185 @@
/**
* 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/lstm.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_Lstm;

namespace mindspore::kernel {
int LstmCPUKernel::InitParam() {
auto input = inputs_.front();
MS_ASSERT(input != nullptr);
std::vector<int> in_shape = input->shape();
lstm_parm_->seq_len_ = in_shape[0];
lstm_parm_->batch_ = in_shape[1];
lstm_parm_->input_size_ = in_shape[2];

auto weight_i = inputs_[1];
MS_ASSERT(weight_i != nullptr);
std::vector<int> w_shape = weight_i->shape();
lstm_parm_->hidden_size_ = w_shape[1] / 4;

lstm_parm_->input_step_ = lstm_parm_->batch_ * lstm_parm_->input_size_;
lstm_parm_->output_step_ = lstm_parm_->bidirectional_ ? 2 * lstm_parm_->batch_ * lstm_parm_->hidden_size_
: lstm_parm_->batch_ * lstm_parm_->hidden_size_;
return RET_OK;
}

int LstmCPUKernel::InitBuffer() {
gate_buffer_ = reinterpret_cast<float *>(malloc(4 * lstm_parm_->batch_ * lstm_parm_->hidden_size_ * sizeof(float)));
if (gate_buffer_ == nullptr) {
MS_LOG(ERROR) << "LstmCPUKernel malloc gate_buffer error.";
return RET_ERROR;
}
return RET_OK;
}

int LstmCPUKernel::InitWeightBias() {
// copy weight_i and weight_h
auto weight_i = inputs_.at(1);
MS_ASSERT(weight_i != nullptr);
weight_i_ptr_ = reinterpret_cast<float *>(malloc(weight_i->ElementsNum() * sizeof(float)));
if (weight_i_ptr_ == nullptr) {
MS_LOG(ERROR) << "LstmCPUKernel malloc weight_i_ptr_ error.";
return RET_ERROR;
}
memcpy(weight_i_ptr_, weight_i->Data(), weight_i->ElementsNum() * sizeof(float));

auto weight_h = inputs_.at(2);
MS_ASSERT(weight_h != nullptr);
weight_h_ptr_ = reinterpret_cast<float *>(malloc(weight_h->ElementsNum() * sizeof(float)));
if (weight_h_ptr_ == nullptr) {
MS_LOG(ERROR) << "LstmCPUKernel malloc weight_h_ error.";
return RET_ERROR;
}
memcpy(weight_h_ptr_, weight_h->Data(), weight_h->ElementsNum() * sizeof(float));

// init bias
int bias_num = lstm_parm_->bidirectional_ ? 2 * 4 * lstm_parm_->hidden_size_ : 4 * lstm_parm_->hidden_size_;
bias_ptr_ = reinterpret_cast<float *>(malloc(bias_num * sizeof(float)));
if (bias_ptr_ == nullptr) {
MS_LOG(ERROR) << "LstmCPUKernel malloc bias_ptr_ error.";
return RET_ERROR;
}

auto bias_data = reinterpret_cast<float *>(inputs_.at(3)->Data());
int state_bias_offset = 4 * lstm_parm_->hidden_size_;
for (int i = 0; i < state_bias_offset; i++) {
bias_ptr_[i] = bias_data[i] + bias_data[i + state_bias_offset];
}
if (lstm_parm_->bidirectional_) {
bias_data += 4 * lstm_parm_->hidden_size_ * 2;
auto backward_bias = bias_ptr_ + 4 * lstm_parm_->hidden_size_;
for (int i = 0; i < state_bias_offset; i++) {
backward_bias[i] = bias_data[i] + bias_data[i + state_bias_offset];
}
}
return RET_OK;
}

int LstmCPUKernel::Init() {
auto ret = InitParam();
if (ret != RET_OK) {
MS_LOG(ERROR) << "LstmCPUKernel InitParam error.";
return RET_ERROR;
}

ret = InitWeightBias();
if (ret != RET_OK) {
MS_LOG(ERROR) << "LstmCPUKernel InitWeightBias error.";
return RET_ERROR;
}

ret = InitBuffer();
if (ret != RET_OK) {
MS_LOG(ERROR) << "LstmCPUKernel InitBuffer error.";
return RET_ERROR;
}
return RET_OK;
}

int LstmCPUKernel::ReSize() {
free(gate_buffer_);

auto ret = InitParam();
if (ret != RET_OK) {
MS_LOG(ERROR) << "LstmCPUKernel InitParam error.";
return RET_ERROR;
}

ret = InitBuffer();
if (ret != RET_OK) {
MS_LOG(ERROR) << "LstmCPUKernel InitBuffer error.";
return RET_ERROR;
}
return RET_OK;
}

int LstmCPUKernel::Run() {
auto input = inputs_.at(kInputIndex);
MS_ASSERT(input != nullptr);
auto hidden_state = inputs_.at(4);
MS_ASSERT(hidden_state != nullptr);
auto cell_state = inputs_.at(5);
MS_ASSERT(cell_state != nullptr);
auto output = outputs_.at(0);
MS_ASSERT(output != nullptr);

auto input_ptr = reinterpret_cast<float *>(input->Data());
auto output_ptr = reinterpret_cast<float *>(output->Data());

auto output_hidden_state = outputs_[1];
memcpy(output_hidden_state->Data(), hidden_state->Data(), hidden_state->ElementsNum() * sizeof(float));
auto output_cell_state = outputs_[2];
memcpy(output_cell_state->Data(), cell_state->Data(), cell_state->ElementsNum() * sizeof(float));

Lstm(output_ptr, input_ptr, weight_i_ptr_, weight_h_ptr_, bias_ptr_,
reinterpret_cast<float *>(output_hidden_state->Data()), reinterpret_cast<float *>(output_cell_state->Data()),
gate_buffer_, lstm_parm_);
return RET_OK;
}

kernel::LiteKernel *CpuLstmKernelCreator(const std::vector<lite::tensor::Tensor *> &inputs,
const std::vector<lite::tensor::Tensor *> &outputs, OpParameter *opParameter,
const lite::Context *ctx, const kernel::KernelKey &desc) {
MS_ASSERT(opParameter != nullptr);
MS_ASSERT(desc.type == schema::PrimitiveType_Lstm);

auto *kernel = new (std::nothrow) LstmCPUKernel(opParameter, inputs, outputs, ctx);
if (kernel == nullptr) {
MS_LOG(ERROR) << "kernel is nullptr.";
return nullptr;
}
auto ret = kernel->Init();
if (ret != RET_OK) {
delete kernel;
MS_LOG(ERROR) << "Init kernel failed, name: " << opParameter->name_ << ", type: "
<< schema::EnumNamePrimitiveType(static_cast<schema::PrimitiveType>(opParameter->type_));
return nullptr;
}
return kernel;
}

REG_KERNEL(kCPU, kNumberTypeFloat32, PrimitiveType_Lstm, CpuLstmKernelCreator)
} // namespace mindspore::kernel

+ 57
- 0
mindspore/lite/src/runtime/kernel/arm/fp32/lstm.h View File

@@ -0,0 +1,57 @@
/**
* 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_LSTM_H_
#define MINDSPORE_LITE_SRC_RUNTIME_KERNEL_ARM_FP32_LSTM_H_

#include <vector>
#include "src/lite_kernel.h"
#include "src/runtime/kernel/arm/opclib/fp32/lstm.h"

namespace mindspore::kernel {
class LstmCPUKernel : public LiteKernel {
public:
LstmCPUKernel(OpParameter *parameter, const std::vector<lite::tensor::Tensor *> &inputs,
const std::vector<lite::tensor::Tensor *> &outputs, const lite::Context *ctx)
: LiteKernel(parameter, inputs, outputs) {
lstm_parm_ = reinterpret_cast<LstmParameter *>(opParameter);
}

~LstmCPUKernel() override {
free(gate_buffer_);
free(weight_i_ptr_);
free(weight_h_ptr_);
free(bias_ptr_);
}

int Init() override;
int ReSize() override;
int Run() override;

int InitParam();
int InitBuffer();
int InitWeightBias();

private:
float *gate_buffer_;
float *weight_i_ptr_;
float *weight_h_ptr_;
float *bias_ptr_;
LstmParameter *lstm_parm_;
};
} // namespace mindspore::kernel

#endif // MINDSPORE_LITE_SRC_RUNTIME_KERNEL_ARM_FP32_LSTM_H_

+ 158
- 0
mindspore/lite/src/runtime/kernel/arm/opclib/fp32/lstm.cc View File

@@ -0,0 +1,158 @@
/**
* 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/opclib/fp32/lstm.h"
#include <string.h>
#include "src/runtime/kernel/arm/opclib/fp32/activation.h"
#include "src/runtime/kernel/arm/opclib/fp32/arithmetic.h"

void InitGate(float *gate_buffer, const float *bias, LstmParameter *lstm_parm) {
int gate_offest = 0;
for (int l = 0; l < 4; l++) {
int batch_offest = gate_offest;
int bias_offest = l * lstm_parm->hidden_size_;
for (int b = 0; b < lstm_parm->batch_; b++) {
memcpy(gate_buffer + batch_offest, bias + bias_offest, lstm_parm->hidden_size_ * sizeof(float));
batch_offest += lstm_parm->hidden_size_;
}
gate_offest += lstm_parm->batch_ * lstm_parm->hidden_size_;
}
}

// input: [row, inner_size]; weight: [col, inner_size]; output: [row, col]
void MatMulAcc(float *output, const float *input, const float *weight, int rows, int cols, int inner_size) {
for (int r = 0; r < rows; r++) {
for (int c = 0; c < cols; c++) {
float res = 0;
for (int i = 0; i < inner_size; i++) {
res += input[r * inner_size + i] * weight[c * inner_size + i];
}
output[r * cols + c] += res;
}
}
}

void ElementMulAcc(float *input0, float *input1, float *output, int element_size) {
for (int index = 0; index < element_size; index++) {
output[index] += input0[index] * input1[index];
}
}

void UpdataState(float *cell_state, float *forget_gate, float *input_gate, float *cell_gate, int batch,
int hidden_size) {
ElementMul(forget_gate, cell_state, cell_state, batch * hidden_size);
ElementMulAcc(input_gate, cell_gate, cell_state, batch * hidden_size);
}

void UpdataOutput(float *cell_state, float *output_gate, float *hidden_state, int batch, int hidden_size) {
Tanh(cell_state, batch * hidden_size, hidden_state);
ElementMul(hidden_state, output_gate, hidden_state, batch * hidden_size);
}

void LstmStepUnit(float *output, const float *input, const float *input_input_weight, const float *input_forget_weight,
const float *input_cell_weight, const float *input_output_weight, const float *state_input_weight,
const float *state_forget_weight, const float *state_cell_weight, const float *state_output_weight,
const float *bias, float *hidden_state, float *cell_state, float *gate_buffer,
LstmParameter *lstm_parm) {
InitGate(gate_buffer, bias, lstm_parm);

float *input_gate = gate_buffer;
float *forget_gate = gate_buffer + lstm_parm->batch_ * lstm_parm->hidden_size_ * 2;
float *cell_gate = gate_buffer + lstm_parm->batch_ * lstm_parm->hidden_size_ * 3;
float *output_gate = gate_buffer + lstm_parm->batch_ * lstm_parm->hidden_size_ * 1;

// input * weight
MatMulAcc(input_gate, input, input_input_weight, lstm_parm->batch_, lstm_parm->hidden_size_, lstm_parm->input_size_);
MatMulAcc(forget_gate, input, input_forget_weight, lstm_parm->batch_, lstm_parm->hidden_size_,
lstm_parm->input_size_);
MatMulAcc(cell_gate, input, input_cell_weight, lstm_parm->batch_, lstm_parm->hidden_size_, lstm_parm->input_size_);
MatMulAcc(output_gate, input, input_output_weight, lstm_parm->batch_, lstm_parm->hidden_size_,
lstm_parm->input_size_);

// state * weight
MatMulAcc(input_gate, hidden_state, state_input_weight, lstm_parm->batch_, lstm_parm->hidden_size_,
lstm_parm->hidden_size_);
MatMulAcc(forget_gate, hidden_state, state_forget_weight, lstm_parm->batch_, lstm_parm->hidden_size_,
lstm_parm->hidden_size_);
MatMulAcc(cell_gate, hidden_state, state_cell_weight, lstm_parm->batch_, lstm_parm->hidden_size_,
lstm_parm->hidden_size_);
MatMulAcc(output_gate, hidden_state, state_output_weight, lstm_parm->batch_, lstm_parm->hidden_size_,
lstm_parm->hidden_size_);

// update input_gate
Sigmoid(input_gate, lstm_parm->batch_ * lstm_parm->hidden_size_, input_gate);

// update forget_gate
Sigmoid(forget_gate, lstm_parm->batch_ * lstm_parm->hidden_size_, forget_gate);

// update cell_gate
Tanh(cell_gate, lstm_parm->batch_ * lstm_parm->hidden_size_, cell_gate);
// update cell state
UpdataState(cell_state, forget_gate, input_gate, cell_gate, lstm_parm->batch_, lstm_parm->hidden_size_);

// update output_gate
Sigmoid(output_gate, lstm_parm->batch_ * lstm_parm->hidden_size_, output_gate);
// update output
UpdataOutput(cell_state, output_gate, hidden_state, lstm_parm->batch_, lstm_parm->hidden_size_);
memcpy(output, hidden_state, lstm_parm->batch_ * lstm_parm->hidden_size_ * sizeof(float));
}

void Lstm(float *output, const float *input, const float *weight_i, const float *weight_h, const float *bias,
float *hidden_state, float *cell_state, float *gate_buffer, LstmParameter *lstm_parm) {
// forward
const float *input_input_weight = weight_i;
const float *input_forget_weight = weight_i + lstm_parm->input_size_ * lstm_parm->hidden_size_ * 2;
const float *input_cell_weight = weight_i + lstm_parm->input_size_ * lstm_parm->hidden_size_ * 3;
const float *input_output_weight = weight_i + lstm_parm->input_size_ * lstm_parm->hidden_size_ * 1;

const float *state_input_weight = weight_h;
const float *state_forget_weight = weight_h + lstm_parm->hidden_size_ * lstm_parm->hidden_size_ * 2;
const float *state_cell_weight = weight_h + lstm_parm->hidden_size_ * lstm_parm->hidden_size_ * 3;
const float *state_output_weight = weight_h + lstm_parm->hidden_size_ * lstm_parm->hidden_size_ * 1;

for (int t = 0; t < lstm_parm->seq_len_; t++) {
const float *input_ptr = input + t * lstm_parm->input_step_;
float *output_ptr = output + t * lstm_parm->output_step_;
LstmStepUnit(output_ptr, input_ptr, input_input_weight, input_forget_weight, input_cell_weight, input_output_weight,
state_input_weight, state_forget_weight, state_cell_weight, state_output_weight, bias, hidden_state,
cell_state, gate_buffer, lstm_parm);
}

// backward
if (lstm_parm->bidirectional_) {
input_input_weight = weight_i + lstm_parm->input_size_ * lstm_parm->hidden_size_ * 4;
input_forget_weight = weight_i + lstm_parm->input_size_ * lstm_parm->hidden_size_ * 6;
input_cell_weight = weight_i + lstm_parm->input_size_ * lstm_parm->hidden_size_ * 7;
input_output_weight = weight_i + lstm_parm->input_size_ * lstm_parm->hidden_size_ * 5;

state_input_weight = weight_h + lstm_parm->hidden_size_ * lstm_parm->hidden_size_ * 4;
state_forget_weight = weight_h + lstm_parm->hidden_size_ * lstm_parm->hidden_size_ * 6;
state_cell_weight = weight_h + lstm_parm->hidden_size_ * lstm_parm->hidden_size_ * 7;
state_output_weight = weight_h + lstm_parm->hidden_size_ * lstm_parm->hidden_size_ * 5;

float *backward_output = output + lstm_parm->batch_ * lstm_parm->hidden_size_;
const float *backward_bias = bias + 4 * lstm_parm->hidden_size_;
float *backward_cell_state = cell_state + lstm_parm->batch_ * lstm_parm->hidden_size_;
float *backward_hidden_state = hidden_state + lstm_parm->batch_ * lstm_parm->hidden_size_;
for (int t = lstm_parm->seq_len_ - 1; t >= 0; t--) {
const float *input_ptr = input + t * lstm_parm->input_step_;
float *output_ptr = backward_output + t * lstm_parm->output_step_;
LstmStepUnit(output_ptr, input_ptr, input_input_weight, input_forget_weight, input_cell_weight,
input_output_weight, state_input_weight, state_forget_weight, state_cell_weight, state_output_weight,
backward_bias, backward_hidden_state, backward_cell_state, gate_buffer, lstm_parm);
}
}
}

+ 36
- 0
mindspore/lite/src/runtime/kernel/arm/opclib/fp32/lstm.h View File

@@ -0,0 +1,36 @@
/**
* 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_OPCLIB_FP32_LSTM_H_
#define MINDSPORE_LITE_SRC_RUNTIME_KERNEL_ARM_OPCLIB_FP32_LSTM_H_

#include "src/runtime/kernel/arm/opclib/op_base.h"

struct LstmParameter {
OpParameter op_parameter_;
int input_size_;
int hidden_size_; // output_size
int seq_len_;
int batch_;
int input_step_;
int output_step_;
bool bidirectional_;
};

void Lstm(float *output, const float *input, const float *weight_i, const float *weight_h, const float *bias,
float *hidden_state, float *cell_state, float *gate_buffer, LstmParameter *lstm_parm);

#endif // MINDSPORE_LITE_SRC_RUNTIME_KERNEL_ARM_OPCLIB_FP32_LSTM_H_

+ 330
- 0
mindspore/lite/test/ut/src/runtime/kernel/arm/fp32/lstm_fp32_tests.cc View File

@@ -0,0 +1,330 @@
/**
* 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 <memory>
#include "utils/log_adapter.h"
#include "common/common_test.h"
#include "mindspore/lite/src/runtime/kernel/arm/opclib/fp32/lstm.h"
#include "mindspore/lite/src/kernel_registry.h"
#include "mindspore/lite/src/ops/ops.h"

namespace mindspore {
class LstmFp32 : public mindspore::Common {
public:
LstmFp32() {}
};

void InitLstmParam(LstmParameter *lstm_param) {
lstm_param->seq_len_ = 4;
lstm_param->batch_ = 1;
lstm_param->input_size_ = 2;
lstm_param->hidden_size_ = 3;
lstm_param->bidirectional_ = false;
}

void InitLstmForwardCreator(std::vector<lite::tensor::Tensor *> *inputs, std::vector<lite::tensor::Tensor *> *outputs,
const LstmParameter *lstm_param) {
// prepare input
std::vector<float> input_data = {1.3889, -0.3006, -0.1787, 2.1504, -0.3181, 0.4945, -0.4758, -0.8187};
auto *input = new lite::tensor::Tensor;
input->set_data_type(kNumberTypeFloat32);
input->set_shape({lstm_param->seq_len_, lstm_param->batch_, lstm_param->input_size_});
input->MallocData();
memcpy(input->Data(), input_data.data(), input_data.size() * sizeof(float));

// prepare weight_i
std::vector<float> weight_i_data = {0.21368974, -0.3778776, 0.05025542, 0.09011161, 0.18355745, 0.5491228,
-0.14186832, -0.4655916, 0.49541366, -0.44039622, 0.5625571, 0.23325664,
0.3449825, -0.42750397, 0.01911497, -0.4125802, -0.56690466, 0.50593233,
-0.29129684, -0.27841482, 0.01964372, -0.42543447, 0.41720617, -0.30054367};
auto *weight_i = new lite::tensor::Tensor;
weight_i->set_data_type(kNumberTypeFloat32);
weight_i->SetFormat(schema::Format_NHWC);
weight_i->set_shape({1, lstm_param->hidden_size_ * 4, lstm_param->input_size_});
weight_i->MallocData();
memcpy(weight_i->Data(), weight_i_data.data(), weight_i_data.size() * sizeof(float));

// prepare weight_r
std::vector<float> weight_h_data = {
-0.03424168, 0.00643545, 0.36867607, -0.08598137, 0.19804275, -0.11319417, -0.0244593, -0.16440144, -0.07268238,
0.09828371, 0.33358777, 0.53381383, -0.39431244, -0.06005383, -0.3520246, 0.42687547, 0.5772828, 0.5380008,
-0.16130409, -0.24737108, 0.42409766, -0.50648475, 0.48223662, -0.5221103, -0.49216837, -0.29084128, 0.3408438,
0.34080023, 0.49467337, 0.23473483, 0.01759732, 0.04691631, 0.45574808, -0.29481018, 0.29442167, -0.36718};
auto *weight_h = new lite::tensor::Tensor;
weight_h->set_data_type(kNumberTypeFloat32);
weight_h->SetFormat(schema::Format_NHWC);
weight_h->set_shape({1, lstm_param->hidden_size_ * 4, lstm_param->hidden_size_});
weight_h->MallocData();
memcpy(weight_h->Data(), weight_h_data.data(), weight_h_data.size() * sizeof(float));

// prepare bias
std::vector<float> bias_data = {-0.00207639, 0.16391152, -0.00069344, -0.32945693, -0.367423, 0.28301108,
-0.17930457, 0.5278388, 0.12598747, -0.53130764, 0.1479364, 0.16695255,
-0.00708795, -0.46417096, -0.23966661, -0.17496741, -0.19166365, -0.50466555,
-0.23593256, -0.3911457, 0.51128435, 0.5128727, 0.253451, -0.51891875};
auto *bias = new lite::tensor::Tensor;
bias->set_data_type(kNumberTypeFloat32);
bias->SetFormat(schema::Format_NHWC);
bias->set_shape({1, lstm_param->hidden_size_ * 4 * 2});
bias->MallocData();
memcpy(bias->Data(), bias_data.data(), bias_data.size() * sizeof(float));

// prepare state
std::vector<float> state_data = {0, 0, 0};
auto *state = new lite::tensor::Tensor;
state->set_data_type(kNumberTypeFloat32);
state->SetFormat(schema::Format_NHWC);
state->set_shape({1, lstm_param->batch_, lstm_param->hidden_size_});
state->MallocData();
memcpy(state->Data(), state_data.data(), state_data.size() * sizeof(float));

inputs->push_back(input);
inputs->push_back(weight_i);
inputs->push_back(weight_h);
inputs->push_back(bias);
inputs->push_back(state);
inputs->push_back(state);

// malloc output buffer, for arm cpu, format: N C4 H W 4
auto *output = new lite::tensor::Tensor;
output->set_data_type(kNumberTypeFloat32);
output->set_shape({lstm_param->seq_len_, lstm_param->batch_, lstm_param->hidden_size_});
output->SetFormat(schema::Format_NHWC);
output->MallocData();
memset(output->Data(), 0, output->ElementsNum() * sizeof(float));

auto *cell_state = new lite::tensor::Tensor;
cell_state->set_data_type(kNumberTypeFloat32);
cell_state->set_shape({1, lstm_param->batch_, lstm_param->hidden_size_});
cell_state->SetFormat(schema::Format_NHWC);
cell_state->MallocData();
memset(cell_state->Data(), 0, cell_state->ElementsNum() * sizeof(float));

auto *hidden_state = new lite::tensor::Tensor;
hidden_state->set_data_type(kNumberTypeFloat32);
hidden_state->set_shape({1, lstm_param->batch_, lstm_param->hidden_size_});
hidden_state->SetFormat(schema::Format_NHWC);
hidden_state->MallocData();
memset(hidden_state->Data(), 0, hidden_state->ElementsNum() * sizeof(float));

outputs->push_back(output);
outputs->push_back(cell_state);
outputs->push_back(hidden_state);
}

void CompareOutput(lite::tensor::Tensor *output, std::vector<float> data) {
for (int i = 0; i < output->ElementsNum(); i++) {
std::cout << reinterpret_cast<float *>(output->Data())[i] << ", ";
}
std::cout << std::endl;

Common::CompareOutputData(reinterpret_cast<float *>(output->Data()), data.data(), output->ElementsNum(), 0.0001);
}

TEST_F(LstmFp32, LstmForwardFp32Accuracy) {
// prepare stage
auto lstm_param = new LstmParameter();
InitLstmParam(lstm_param);

// init ctx
auto ctx = new lite::Context();
ctx->thread_num_ = 1;

// init tensor
std::vector<lite::tensor::Tensor *> inputs;
std::vector<lite::tensor::Tensor *> outputs;
InitLstmForwardCreator(&inputs, &outputs, lstm_param);

// register op
kernel::KernelKey desc = {kernel::KERNEL_ARCH::kCPU, kNumberTypeFloat32, mindspore::schema::PrimitiveType_Lstm};
auto creator = lite::KernelRegistry::GetInstance()->GetCreator(desc);
ASSERT_NE(creator, nullptr);
kernel::LiteKernel *kernel = creator(inputs, outputs, reinterpret_cast<OpParameter *>(lstm_param), ctx, desc);
ASSERT_NE(kernel, nullptr);
// op run
kernel->Run();

std::cout << "==================output data=================" << std::endl;
std::vector<float> output0_data = {-0.0702, 0.1225, 0.0876, -0.0357, -0.0227, -0.2294,
-0.0345, -0.0108, -0.2002, 0.0451, 0.0853, -0.1205};
CompareOutput(outputs[0], output0_data);

std::vector<float> output1_data = {0.0451, 0.0853, -0.1205};
CompareOutput(outputs[1], output1_data);

std::vector<float> output2_data = {0.0989, 0.2094, -0.4132};
CompareOutput(outputs[2], output2_data);

delete lstm_param;
for (int i = 0; i < inputs.size() - 1; i++) {
delete inputs[i];
}
for (int i = 0; i < outputs.size(); i++) {
delete outputs[i];
}
delete kernel;
MS_LOG(INFO) << "LstmFp32 forward accuracy passed";
}

void InitLstmBackwardCreator(std::vector<lite::tensor::Tensor *> *inputs, std::vector<lite::tensor::Tensor *> *outputs,
const LstmParameter *lstm_param) {
// prepare input
std::vector<float> input_data = {1.4305, 0.5342, -0.9221, 0.0527, 2.3770, -0.3697, -0.2833, -2.1285};
auto *input = new lite::tensor::Tensor;
input->set_data_type(kNumberTypeFloat32);
input->set_shape({lstm_param->seq_len_, lstm_param->batch_, lstm_param->input_size_});
input->MallocData();
memcpy(input->Data(), input_data.data(), input_data.size() * sizeof(float));

// prepare weight_i
std::vector<float> weight_i_data = {
-0.19253477, -0.007966279, -0.06039094, 0.27697134, -0.5071223, 0.18996351, 0.20472168, -0.1007814,
0.04282999, 0.20836472, -0.4654655, 0.050321221, -0.3431457, 0.22256428, 0.29294532, 0.45042896,
0.20468240, 0.13078391, -0.20987969, -0.3173505, -0.3813517, 0.10205835, 0.21858131, -0.0386473,
0.5512280, -0.2763766, -0.3593936, -0.5181975, 0.3469863, -0.38533931, 0.010202527, -0.46598294,
-0.5740513, 0.06127524, -0.03960543, 0.2478809, -0.17296993, 0.19159525, -0.4976995, 0.05985528,
0.3653409, 0.386924, 0.3170289, -0.08830952, -0.31105759, 0.3110240, 0.15174299, 0.287579894};
auto *weight_i = new lite::tensor::Tensor;
weight_i->set_data_type(kNumberTypeFloat32);
weight_i->SetFormat(schema::Format_NHWC);
weight_i->set_shape({2, lstm_param->hidden_size_ * 4, lstm_param->input_size_});
weight_i->MallocData();
memcpy(weight_i->Data(), weight_i_data.data(), weight_i_data.size() * sizeof(float));

// prepare weight_r
std::vector<float> weight_h_data = {
0.106934666, -0.50430017, 0.33296257, -0.288117021, -0.38019785, -0.147071093, 0.422707557, 0.41497004,
-0.5329730, -0.430150926, -0.032713949, 0.35401260, 0.179495036, -0.14158579, 0.380428612, -0.175597071,
0.54088723, -0.403292059, -0.287720531, -0.51250511, -0.15405902, -0.440592586, 0.16726928, -0.0163397789,
0.51673841, 0.5094323, -0.137105107, -0.181070089, -0.47221425, -0.38046866, -0.206725060, 0.248537719,
-0.23961094, -0.117781728, 0.426800847, 0.0266208052, -0.197408229, 0.54831492, -0.280048757, -0.125062286,
-0.29929456, 0.42354834, -0.401066303, 0.356340110, 0.54629492, -0.15852552, 0.131406366, -0.101815432,
0.0121276974, -0.53553336, 0.121099889, 0.060554087, 0.46259057, -0.49666053, 0.090806663, 0.20542401,
-0.38674920, -0.23874849, -0.5222138, 0.57537007, 0.113343358, -0.35233467, -0.25532332, 0.159506142,
0.35996592, -0.201961308, -0.16323345, 0.119177639, -0.12677872, -0.175229549, -0.160024613, -0.21058899};
auto *weight_h = new lite::tensor::Tensor;
weight_h->set_data_type(kNumberTypeFloat32);
weight_h->SetFormat(schema::Format_NHWC);
weight_h->set_shape({2, lstm_param->hidden_size_ * 4, lstm_param->hidden_size_});
weight_h->MallocData();
memcpy(weight_h->Data(), weight_h_data.data(), weight_h_data.size() * sizeof(float));

// prepare bias
std::vector<float> bias_data = {
0.57061123, -0.25357073, -0.146834075, 0.412972748, -0.27809411, -0.0542128682, -0.45384609, -0.53261917,
0.222133636, -0.18093895, -0.045559883, 0.09109061, 0.080319643, 0.455167174, 0.36235427, -0.00164419412,
-0.135566502, 0.41905909, -0.450117409, 0.50565385, -0.077815443, -0.47051778, -0.141349375, -0.338519752,
0.48683023, 0.282384872, 0.13399660, -0.382526844, -0.23370727, -0.184681564, 0.45679104, -0.339453905,
0.452010273, 0.0552094578, 0.328843057, 0.127738714, -0.127084732, -0.334061294, -0.46742400, -0.401568055,
0.23712641, -0.052937567, 0.272351622, 0.42767739, 0.303884744, -0.46025499, -0.43985402, 0.256422877};
auto *bias = new lite::tensor::Tensor;
bias->set_data_type(kNumberTypeFloat32);
bias->SetFormat(schema::Format_NHWC);
bias->set_shape({2, lstm_param->hidden_size_ * 4 * 2});
bias->MallocData();
memcpy(bias->Data(), bias_data.data(), bias_data.size() * sizeof(float));

// prepare state
std::vector<float> state_data = {0, 0, 0, 0, 0, 0};
auto *state = new lite::tensor::Tensor;
state->set_data_type(kNumberTypeFloat32);
state->SetFormat(schema::Format_NHWC);
state->set_shape({2, lstm_param->batch_, lstm_param->hidden_size_});
state->MallocData();
memcpy(state->Data(), state_data.data(), state_data.size() * sizeof(float));

inputs->push_back(input);
inputs->push_back(weight_i);
inputs->push_back(weight_h);
inputs->push_back(bias);
inputs->push_back(state);
inputs->push_back(state);

// malloc output buffer, for arm cpu, format: N C4 H W 4
auto *output = new lite::tensor::Tensor;
output->set_data_type(kNumberTypeFloat32);
output->set_shape({lstm_param->seq_len_, 2, lstm_param->batch_, lstm_param->hidden_size_});
output->SetFormat(schema::Format_NHWC);
output->MallocData();
memset(output->Data(), 0, output->ElementsNum() * sizeof(float));

auto *cell_state = new lite::tensor::Tensor;
cell_state->set_data_type(kNumberTypeFloat32);
cell_state->set_shape({2, lstm_param->batch_, lstm_param->hidden_size_});
cell_state->SetFormat(schema::Format_NHWC);
cell_state->MallocData();
memset(cell_state->Data(), 0, cell_state->ElementsNum() * sizeof(float));

auto *hidden_state = new lite::tensor::Tensor;
hidden_state->set_data_type(kNumberTypeFloat32);
hidden_state->set_shape({2, lstm_param->batch_, lstm_param->hidden_size_});
hidden_state->SetFormat(schema::Format_NHWC);
hidden_state->MallocData();
memset(hidden_state->Data(), 0, hidden_state->ElementsNum() * sizeof(float));

outputs->push_back(output);
outputs->push_back(cell_state);
outputs->push_back(hidden_state);
}

TEST_F(LstmFp32, LstmBackwardFp32Accuracy) {
// prepare stage
auto lstm_param = new LstmParameter();
InitLstmParam(lstm_param);
lstm_param->bidirectional_ = true;

// init ctx
auto ctx = new lite::Context();
ctx->thread_num_ = 1;

// init tensor
std::vector<lite::tensor::Tensor *> inputs;
std::vector<lite::tensor::Tensor *> outputs;
InitLstmBackwardCreator(&inputs, &outputs, lstm_param);

// register op
kernel::KernelKey desc = {kernel::KERNEL_ARCH::kCPU, kNumberTypeFloat32, mindspore::schema::PrimitiveType_Lstm};
auto creator = lite::KernelRegistry::GetInstance()->GetCreator(desc);
ASSERT_NE(creator, nullptr);
kernel::LiteKernel *kernel = creator(inputs, outputs, reinterpret_cast<OpParameter *>(lstm_param), ctx, desc);
ASSERT_NE(kernel, nullptr);
// op run
kernel->Run();

std::cout << "==================output data=================" << std::endl;
std::vector<float> output0_data = {-0.2922, -0.1416, 0.0077, -0.0422, -0.0585, 0.2061, -0.2385, -0.0146,
-0.1796, -0.0554, -0.0973, 0.1013, -0.3062, -0.1516, -0.0310, 0.0459,
-0.0784, 0.0949, 0.0249, -0.0653, -0.0869, -0.1113, -0.2155, -0.0500};
CompareOutput(outputs[0], output0_data);

std::vector<float> output1_data = {0.0249, -0.0653, -0.0869, -0.0422, -0.0585, 0.2061};
CompareOutput(outputs[1], output1_data);

std::vector<float> output2_data = {0.0373, -0.2322, -0.1477, -0.1621, -0.1808, 0.5146};
CompareOutput(outputs[2], output2_data);

delete lstm_param;
for (int i = 0; i < inputs.size() - 1; i++) {
delete inputs[i];
}
for (int i = 0; i < outputs.size(); i++) {
delete outputs[i];
}
delete kernel;
MS_LOG(INFO) << "LstmFp32 backward accuracy passed";
}

} // namespace mindspore

Write Preview
Loading…
Cancel
Save