forked from OSSInnovation/mindspore
!2369 add cpu reduce op and cpu softmax_cross_entropy_with_logits op
Merge pull request !2369 from baihuawei/reduce
This commit is contained in:
Gitee
commit
c9b8a8da0a
|
|
@ -0,0 +1,99 @@
|
||||||
|
/**
|
||||||
|
* 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 "kernel/cpu/mkldnn/softmax_cross_entropy_with_logits_cpu_kernel.h"
|
||||||
|
#include <numeric>
|
||||||
|
#include <functional>
|
||||||
|
#include <cmath>
|
||||||
|
#include "kernel/cpu/mkldnn/mkl_kernel_engine.h"
|
||||||
|
#include "device/cpu/cpu_device_address.h"
|
||||||
|
#include "common/utils.h"
|
||||||
|
|
||||||
|
namespace mindspore {
|
||||||
|
namespace kernel {
|
||||||
|
void SoftmaxCrossEntropyWithLogitsCPUKernel::InitInputOutputSize(const CNodePtr &kernel_node) {
|
||||||
|
CPUKernel::InitInputOutputSize(kernel_node);
|
||||||
|
MS_EXCEPTION_IF_NULL(kernel_node);
|
||||||
|
size_t type_size = sizeof(float);
|
||||||
|
std::vector<size_t> shape = AnfAlgo::GetInputDeviceShape(kernel_node, 0);
|
||||||
|
size_t tensor_size = std::accumulate(shape.begin(), shape.end(), type_size, std::multiplies<size_t>());
|
||||||
|
workspace_size_list_.emplace_back(tensor_size);
|
||||||
|
}
|
||||||
|
|
||||||
|
void SoftmaxCrossEntropyWithLogitsCPUKernel::InitKernel(const CNodePtr &kernel_node) {
|
||||||
|
MS_EXCEPTION_IF_NULL(kernel_node);
|
||||||
|
std::vector<size_t> shape = AnfAlgo::GetInputDeviceShape(kernel_node, 0);
|
||||||
|
dnnl::memory::dims mem_dims;
|
||||||
|
mem_dims.insert(mem_dims.end(), shape.begin(), shape.end());
|
||||||
|
if (mem_dims.size() != 2) {
|
||||||
|
MS_LOG(EXCEPTION) << "SoftmaxCrossEntropyWithLogits kernel dims invalid " << mem_dims.size();
|
||||||
|
}
|
||||||
|
batch_size_ = shape[0];
|
||||||
|
class_num_ = shape[1];
|
||||||
|
if (batch_size_ == 0 || class_num_ == 0) {
|
||||||
|
MS_LOG(EXCEPTION) << "invalid batch size or class num input!";
|
||||||
|
}
|
||||||
|
dnnl::memory::desc mem_desc(mem_dims, dnnl::memory::data_type::f32, dnnl::memory::format_tag::nc);
|
||||||
|
|
||||||
|
dnnl::softmax_forward::desc desc = dnnl::softmax_forward::desc(dnnl::prop_kind::forward_training, mem_desc, 1);
|
||||||
|
auto prim_desc = dnnl::softmax_forward::primitive_desc(desc, MKLKernelEngine::Get().engine());
|
||||||
|
primitive_ = std::make_shared<dnnl::softmax_forward>(prim_desc);
|
||||||
|
|
||||||
|
AddArgument(DNNL_ARG_SRC, mem_desc);
|
||||||
|
AddArgument(DNNL_ARG_DST, mem_desc);
|
||||||
|
}
|
||||||
|
|
||||||
|
void SoftmaxCrossEntropyWithLogitsCPUKernel::ForwardPostExecute(const float *logits, const float *labels,
|
||||||
|
float *output1, float *output2) const {
|
||||||
|
float epsilon = 1e-6;
|
||||||
|
for (size_t i = 0; i < batch_size_; ++i) {
|
||||||
|
output1[i] = 0;
|
||||||
|
float loss = 0.0;
|
||||||
|
for (size_t j = 0; j < class_num_; ++j) {
|
||||||
|
float logit = logf(logits[i * class_num_ + j] <= 0.0 ? epsilon : logits[i * class_num_ + j]);
|
||||||
|
output2[i * class_num_ + j] = logits[i * class_num_ + j] - labels[i * class_num_ + j];
|
||||||
|
loss += labels[i * class_num_ + j] * logit;
|
||||||
|
}
|
||||||
|
output1[i] = -loss;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
bool SoftmaxCrossEntropyWithLogitsCPUKernel::Launch(const std::vector<kernel::AddressPtr> &inputs,
|
||||||
|
const std::vector<kernel::AddressPtr> &workspace,
|
||||||
|
const std::vector<kernel::AddressPtr> &outputs) {
|
||||||
|
if (inputs.empty() || workspace.empty() || outputs.empty()) {
|
||||||
|
MS_LOG(EXCEPTION) << "error input output size!";
|
||||||
|
}
|
||||||
|
size_t batch_float_size = batch_size_ * sizeof(float);
|
||||||
|
size_t batch_class_float_size = class_num_ * batch_float_size;
|
||||||
|
if (inputs[0]->size != workspace[0]->size || inputs[0]->size != batch_class_float_size ||
|
||||||
|
inputs[1]->size != batch_class_float_size) {
|
||||||
|
MS_LOG(EXCEPTION) << "error input data size!";
|
||||||
|
}
|
||||||
|
if (outputs[1]->size != batch_class_float_size || outputs[0]->size != batch_float_size) {
|
||||||
|
MS_LOG(EXCEPTION) << "error output data size!";
|
||||||
|
}
|
||||||
|
SetArgumentHandle(DNNL_ARG_SRC, inputs[0]->addr);
|
||||||
|
SetArgumentHandle(DNNL_ARG_DST, workspace[0]->addr);
|
||||||
|
ExecutePrimitive();
|
||||||
|
auto labels = reinterpret_cast<float *>(inputs[1]->addr);
|
||||||
|
auto logits = reinterpret_cast<float *>(workspace[0]->addr);
|
||||||
|
auto output1 = reinterpret_cast<float *>(outputs[0]->addr);
|
||||||
|
auto output2 = reinterpret_cast<float *>(outputs[1]->addr);
|
||||||
|
ForwardPostExecute(logits, labels, output1, output2);
|
||||||
|
return true;
|
||||||
|
}
|
||||||
|
} // namespace kernel
|
||||||
|
} // namespace mindspore
|
||||||
|
|
@ -0,0 +1,53 @@
|
||||||
|
/**
|
||||||
|
* 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_CCSRC_KERNEL_CPU_SOFTMAX_CROSS_ENTROPY_WITH_LOGITS_CPU_KERNEL_H_
|
||||||
|
#define MINDSPORE_CCSRC_KERNEL_CPU_SOFTMAX_CROSS_ENTROPY_WITH_LOGITS_CPU_KERNEL_H_
|
||||||
|
|
||||||
|
#include <vector>
|
||||||
|
#include <memory>
|
||||||
|
#include "kernel/cpu/mkldnn/mkl_cpu_kernel.h"
|
||||||
|
|
||||||
|
namespace mindspore {
|
||||||
|
namespace kernel {
|
||||||
|
class SoftmaxCrossEntropyWithLogitsCPUKernel : public MKLCPUKernel {
|
||||||
|
public:
|
||||||
|
SoftmaxCrossEntropyWithLogitsCPUKernel() = default;
|
||||||
|
~SoftmaxCrossEntropyWithLogitsCPUKernel() override = default;
|
||||||
|
|
||||||
|
void InitKernel(const CNodePtr &kernel_node) override;
|
||||||
|
|
||||||
|
bool Launch(const std::vector<AddressPtr> &inputs, const std::vector<AddressPtr> &workspace,
|
||||||
|
const std::vector<AddressPtr> &outputs) override;
|
||||||
|
|
||||||
|
protected:
|
||||||
|
void InitInputOutputSize(const CNodePtr &kernel_node) override;
|
||||||
|
|
||||||
|
private:
|
||||||
|
void ForwardPostExecute(const float *logits, const float *labels, float *output1, float *output2) const;
|
||||||
|
size_t class_num_{0};
|
||||||
|
size_t batch_size_{0};
|
||||||
|
};
|
||||||
|
MS_REG_CPU_KERNEL(SoftmaxCrossEntropyWithLogits,
|
||||||
|
KernelAttr()
|
||||||
|
.AddInputAttr(kNumberTypeFloat32)
|
||||||
|
.AddInputAttr(kNumberTypeFloat32)
|
||||||
|
.AddOutputAttr(kNumberTypeFloat32)
|
||||||
|
.AddOutputAttr(kNumberTypeFloat32),
|
||||||
|
SoftmaxCrossEntropyWithLogitsCPUKernel);
|
||||||
|
} // namespace kernel
|
||||||
|
} // namespace mindspore
|
||||||
|
|
||||||
|
#endif // MINDSPORE_CCSRC_KERNEL_CPU_SOFTMAX_CROSS_ENTROPY_WITH_LOGITS_CPU_KERNEL_H_
|
||||||
|
|
@ -0,0 +1,161 @@
|
||||||
|
/**
|
||||||
|
* 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 <map>
|
||||||
|
#include <string>
|
||||||
|
#include <vector>
|
||||||
|
#include "kernel/cpu/reduce_cpu_kernel.h"
|
||||||
|
#include "device/cpu/cpu_device_address.h"
|
||||||
|
|
||||||
|
namespace mindspore {
|
||||||
|
namespace kernel {
|
||||||
|
const size_t kReduceTypeMax = 0;
|
||||||
|
const size_t kReduceTypeMean = 1;
|
||||||
|
const size_t kReduceTypeSum = 2;
|
||||||
|
const size_t kMaxDim = 100;
|
||||||
|
void ReduceCPUKernel::InitKernel(const CNodePtr &kernel_node) {
|
||||||
|
MS_EXCEPTION_IF_NULL(kernel_node);
|
||||||
|
std::string kernel_name = AnfAlgo::GetCNodeName(kernel_node);
|
||||||
|
if (kernel_name == "ReduceMax") {
|
||||||
|
reduce_type_ = kReduceTypeMax;
|
||||||
|
} else if (kernel_name == "ReduceMean") {
|
||||||
|
reduce_type_ = kReduceTypeMean;
|
||||||
|
} else if (kernel_name == "ReduceSum") {
|
||||||
|
reduce_type_ = kReduceTypeSum;
|
||||||
|
} else {
|
||||||
|
MS_LOG(EXCEPTION) << "Array reduce kernel type " << kernel_name << " is not supported.";
|
||||||
|
}
|
||||||
|
shape_ = AnfAlgo::GetInputDeviceShape(kernel_node, 0);
|
||||||
|
auto axis_addr = AnfAlgo::GetCNodePrimitive(kernel_node)->GetAttr(AXIS);
|
||||||
|
if (axis_addr->isa<ValueTuple>()) {
|
||||||
|
auto attr_axis = AnfAlgo::GetNodeAttr<std::vector<int>>(kernel_node, AXIS);
|
||||||
|
if (attr_axis.size() > shape_.size()) {
|
||||||
|
MS_LOG(EXCEPTION) << "invalid axis size: " << axis_.size();
|
||||||
|
} else if (attr_axis.empty()) {
|
||||||
|
axis_.push_back(shape_.size() - 1);
|
||||||
|
} else {
|
||||||
|
for (auto axis : attr_axis) {
|
||||||
|
if (IntToSize(axis) >= (shape_.size())) {
|
||||||
|
MS_LOG(EXCEPTION) << "axis value is oversize.";
|
||||||
|
}
|
||||||
|
axis < 0 ? axis_.push_back(axis + shape_.size()) : axis_.push_back(axis);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
} else if (axis_addr->isa<Int32Imm>()) {
|
||||||
|
int axis = AnfAlgo::GetNodeAttr<int>(kernel_node, AXIS);
|
||||||
|
|
||||||
|
if (axis >= 0 && IntToSize(axis) >= shape_.size()) {
|
||||||
|
MS_LOG(EXCEPTION) << "axis value is oversize.";
|
||||||
|
}
|
||||||
|
axis < 0 ? axis_.push_back(axis + shape_.size()) : axis_.push_back(axis);
|
||||||
|
} else {
|
||||||
|
MS_LOG(EXCEPTION) << "Attribute axis type is invalid.";
|
||||||
|
}
|
||||||
|
for (size_t i = 0; i < shape_.size(); ++i) {
|
||||||
|
if (shape_[i] <= 0) {
|
||||||
|
MS_LOG(EXCEPTION) << "shape value is invalid.";
|
||||||
|
}
|
||||||
|
left_dims_ *= shape_[i];
|
||||||
|
}
|
||||||
|
for (size_t i = 0; i < axis_.size(); ++i) {
|
||||||
|
stride_ *= shape_[axis_[i]];
|
||||||
|
}
|
||||||
|
if (stride_ <= 0) {
|
||||||
|
MS_LOG(EXCEPTION) << "stride_ must greater than zero.";
|
||||||
|
}
|
||||||
|
left_dims_ = left_dims_ / stride_;
|
||||||
|
}
|
||||||
|
bool ReduceCPUKernel::Launch(const std::vector<kernel::AddressPtr> &inputs,
|
||||||
|
const std::vector<kernel::AddressPtr> & /*workspaces*/,
|
||||||
|
const std::vector<kernel::AddressPtr> &outputs) {
|
||||||
|
if (inputs.empty() || outputs.empty()) {
|
||||||
|
MS_LOG(EXCEPTION) << "input or output empty!";
|
||||||
|
}
|
||||||
|
size_t out_float_size = left_dims_ * sizeof(float);
|
||||||
|
size_t in_float_size = stride_ * out_float_size;
|
||||||
|
if (inputs[0]->size != in_float_size || outputs[0]->size != out_float_size) {
|
||||||
|
MS_LOG(EXCEPTION) << "invalid input or output data size!";
|
||||||
|
}
|
||||||
|
auto input = reinterpret_cast<float *>(inputs[0]->addr);
|
||||||
|
auto output = reinterpret_cast<float *>(outputs[0]->addr);
|
||||||
|
int size = inputs[0]->size / sizeof(float);
|
||||||
|
std::vector<float> new_input(IntToSize(size), 0.0);
|
||||||
|
std::vector<size_t> transpose_axis;
|
||||||
|
for (size_t i = 0; i < shape_.size(); ++i) {
|
||||||
|
bool insert = true;
|
||||||
|
for (size_t j = 0; j < axis_.size(); ++j) {
|
||||||
|
if (axis_[j] == i) {
|
||||||
|
insert = false;
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
if (insert) {
|
||||||
|
transpose_axis.push_back(i);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
(void)transpose_axis.insert(transpose_axis.end(), axis_.begin(), axis_.end());
|
||||||
|
Transpose(size, input, shape_, transpose_axis, SizeToInt(shape_.size()), &new_input[0]);
|
||||||
|
if (reduce_type_ == kReduceTypeMax) {
|
||||||
|
for (size_t i = 0; i < left_dims_; ++i) {
|
||||||
|
float value = new_input[i * stride_];
|
||||||
|
for (size_t k = 0; k < stride_; ++k) {
|
||||||
|
if (value < new_input[i * stride_ + k]) {
|
||||||
|
value = new_input[i * stride_ + k];
|
||||||
|
}
|
||||||
|
}
|
||||||
|
output[i] = value;
|
||||||
|
}
|
||||||
|
} else {
|
||||||
|
for (size_t i = 0; i < left_dims_; ++i) {
|
||||||
|
float value = 0.0;
|
||||||
|
for (size_t k = 0; k < stride_; ++k) {
|
||||||
|
value += new_input[i * stride_ + k];
|
||||||
|
}
|
||||||
|
if (reduce_type_ == kReduceTypeMean) {
|
||||||
|
output[i] = value / stride_;
|
||||||
|
} else {
|
||||||
|
output[i] = value;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
return true;
|
||||||
|
}
|
||||||
|
void ReduceCPUKernel::Transpose(const int size, const float *input, const std::vector<size_t> &input_shape,
|
||||||
|
const std::vector<size_t> &input_axis, const int shape_size, float *output) {
|
||||||
|
int pos_array[kMaxDim];
|
||||||
|
int size_offset[kMaxDim];
|
||||||
|
size_offset[0] = size / SizeToInt(input_shape[0]);
|
||||||
|
for (int i = 1; i < shape_size; i++) {
|
||||||
|
size_offset[i] = size_offset[i - 1] / SizeToInt(input_shape[i]);
|
||||||
|
}
|
||||||
|
for (int position = 0; position < size; position += 1) {
|
||||||
|
int temp_position = position;
|
||||||
|
pos_array[0] = temp_position / size_offset[0];
|
||||||
|
for (int i = 1; i < shape_size; i++) {
|
||||||
|
temp_position -= pos_array[i - 1] * size_offset[i - 1];
|
||||||
|
pos_array[i] = temp_position / size_offset[i];
|
||||||
|
}
|
||||||
|
int new_position = pos_array[SizeToInt(input_axis[shape_size - 1])];
|
||||||
|
int new_position_size = 1;
|
||||||
|
for (int j = shape_size - 2; j >= 0; j--) {
|
||||||
|
new_position_size *= SizeToInt(input_shape[SizeToInt(input_axis[j + 1])]);
|
||||||
|
new_position += pos_array[SizeToInt(input_axis[j])] * new_position_size;
|
||||||
|
}
|
||||||
|
output[new_position] = input[position];
|
||||||
|
}
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
} // namespace kernel
|
||||||
|
} // namespace mindspore
|
||||||
|
|
@ -0,0 +1,52 @@
|
||||||
|
/**
|
||||||
|
* 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_CCSRC_KERNEL_CPU_REDUCE_CPU_KERNEL_H_
|
||||||
|
#define MINDSPORE_CCSRC_KERNEL_CPU_REDUCE_CPU_KERNEL_H_
|
||||||
|
#include <vector>
|
||||||
|
#include <memory>
|
||||||
|
#include <string>
|
||||||
|
#include "kernel/cpu/cpu_kernel.h"
|
||||||
|
#include "kernel/cpu/cpu_kernel_factory.h"
|
||||||
|
|
||||||
|
namespace mindspore {
|
||||||
|
namespace kernel {
|
||||||
|
class ReduceCPUKernel : public CPUKernel {
|
||||||
|
public:
|
||||||
|
ReduceCPUKernel() = default;
|
||||||
|
~ReduceCPUKernel() override = default;
|
||||||
|
void InitKernel(const CNodePtr &kernel_node) override;
|
||||||
|
bool Launch(const std::vector<AddressPtr> &inputs, const std::vector<AddressPtr> &workspace,
|
||||||
|
const std::vector<AddressPtr> &outputs) override;
|
||||||
|
|
||||||
|
private:
|
||||||
|
void Transpose(const int size, const float *input, const std::vector<size_t> &input_shape,
|
||||||
|
const std::vector<size_t> &input_axis, const int shape_size, float *output);
|
||||||
|
size_t reduce_type_;
|
||||||
|
std::vector<size_t> axis_;
|
||||||
|
std::vector<size_t> shape_;
|
||||||
|
size_t left_dims_ = 1;
|
||||||
|
size_t stride_ = 1;
|
||||||
|
};
|
||||||
|
MS_REG_CPU_KERNEL(ReduceMean, KernelAttr().AddInputAttr(kNumberTypeFloat32).AddOutputAttr(kNumberTypeFloat32),
|
||||||
|
ReduceCPUKernel);
|
||||||
|
MS_REG_CPU_KERNEL(ReduceMax, KernelAttr().AddInputAttr(kNumberTypeFloat32).AddOutputAttr(kNumberTypeFloat32),
|
||||||
|
ReduceCPUKernel);
|
||||||
|
MS_REG_CPU_KERNEL(ReduceSum, KernelAttr().AddInputAttr(kNumberTypeFloat32).AddOutputAttr(kNumberTypeFloat32),
|
||||||
|
ReduceCPUKernel);
|
||||||
|
|
||||||
|
} // namespace kernel
|
||||||
|
} // namespace mindspore
|
||||||
|
#endif // MINDSPORE_CCSRC_KERNEL_CPU_REDUCE_CPU_KERNEL_H_
|
||||||
|
|
@ -0,0 +1,93 @@
|
||||||
|
# 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.
|
||||||
|
# ============================================================================
|
||||||
|
|
||||||
|
import pytest
|
||||||
|
import numpy as np
|
||||||
|
from mindspore import Tensor
|
||||||
|
from mindspore.ops import operations as P
|
||||||
|
import mindspore.nn as nn
|
||||||
|
import mindspore.context as context
|
||||||
|
from mindspore.common.api import ms_function
|
||||||
|
|
||||||
|
context.set_context(device_target="CPU")
|
||||||
|
|
||||||
|
|
||||||
|
class NetReduce(nn.Cell):
|
||||||
|
def __init__(self):
|
||||||
|
super(NetReduce, self).__init__()
|
||||||
|
self.axis0 = 0
|
||||||
|
self.axis1 = 1
|
||||||
|
self.axis2 = -1
|
||||||
|
self.axis3 = (0, 1)
|
||||||
|
self.axis4 = (0, 1, 2)
|
||||||
|
self.reduce_mean = P.ReduceMean(False)
|
||||||
|
self.reduce_sum = P.ReduceSum(False)
|
||||||
|
self.reduce_max = P.ReduceMax(False)
|
||||||
|
|
||||||
|
@ms_function
|
||||||
|
def construct(self, indice):
|
||||||
|
return (self.reduce_mean(indice, self.axis0),
|
||||||
|
self.reduce_mean(indice, self.axis1),
|
||||||
|
self.reduce_mean(indice, self.axis2),
|
||||||
|
self.reduce_mean(indice, self.axis3),
|
||||||
|
self.reduce_mean(indice, self.axis4),
|
||||||
|
self.reduce_sum(indice, self.axis0),
|
||||||
|
self.reduce_sum(indice, self.axis2),
|
||||||
|
self.reduce_max(indice, self.axis0),
|
||||||
|
self.reduce_max(indice, self.axis2))
|
||||||
|
|
||||||
|
|
||||||
|
@pytest.mark.level0
|
||||||
|
@pytest.mark.platform_x86_cpu
|
||||||
|
@pytest.mark.env_onecard
|
||||||
|
def test_reduce():
|
||||||
|
reduce = NetReduce()
|
||||||
|
indice = Tensor(np.array([
|
||||||
|
[[0., 2., 1., 4., 0., 2.], [3., 1., 2., 2., 4., 0.]],
|
||||||
|
[[2., 0., 1., 5., 0., 1.], [1., 0., 0., 4., 4., 3.]],
|
||||||
|
[[4., 1., 4., 0., 0., 0.], [2., 5., 1., 0., 1., 3.]]
|
||||||
|
]).astype(np.float32))
|
||||||
|
output = reduce(indice)
|
||||||
|
print(output[0])
|
||||||
|
print(output[1])
|
||||||
|
print(output[2])
|
||||||
|
print(output[3])
|
||||||
|
print(output[4])
|
||||||
|
print(output[5])
|
||||||
|
print(output[6])
|
||||||
|
print(output[7])
|
||||||
|
print(output[8])
|
||||||
|
expect_0 = np.array([[2., 1., 2., 3., 0., 1], [2., 2., 1., 2., 3., 2.]]).astype(np.float32)
|
||||||
|
expect_1 = np.array([[1.5, 1.5, 1.5, 3., 2., 1.], [1.5, 0., 0.5, 4.5, 2., 2.], [3., 3., 2.5, 0., 0.5, 1.5]]).astype(
|
||||||
|
np.float32)
|
||||||
|
expect_2 = np.array([[1.5, 2.], [1.5, 2.], [1.5, 2.]]).astype(np.float32)
|
||||||
|
expect_3 = np.array([2, 1.5, 1.5, 2.5, 1.5, 1.5]).astype(np.float32)
|
||||||
|
expect_4 = np.array([1.75]).astype(np.float32)
|
||||||
|
expect_5 = np.array([[6., 3., 6., 9., 0., 3.], [6., 6., 3., 6., 9., 6.]]).astype(np.float32)
|
||||||
|
expect_6 = np.array([[9., 12.], [9., 12.], [9., 12.]]).astype(np.float32)
|
||||||
|
expect_7 = np.array([[4., 2., 4., 5., 0., 2.], [3., 5., 2., 4., 4., 3.]]).astype(np.float32)
|
||||||
|
expect_8 = np.array([[4., 4.], [5., 4.], [4., 5.]]).astype(np.float32)
|
||||||
|
assert (output[0].asnumpy() == expect_0).all()
|
||||||
|
assert (output[1].asnumpy() == expect_1).all()
|
||||||
|
assert (output[2].asnumpy() == expect_2).all()
|
||||||
|
assert (output[3].asnumpy() == expect_3).all()
|
||||||
|
assert (output[4].asnumpy() == expect_4).all()
|
||||||
|
assert (output[5].asnumpy() == expect_5).all()
|
||||||
|
assert (output[6].asnumpy() == expect_6).all()
|
||||||
|
assert (output[7].asnumpy() == expect_7).all()
|
||||||
|
assert (output[8].asnumpy() == expect_8).all()
|
||||||
|
|
||||||
|
|
||||||
|
test_reduce()
|
||||||
|
|
@ -0,0 +1,52 @@
|
||||||
|
# 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.
|
||||||
|
# ============================================================================
|
||||||
|
|
||||||
|
import numpy as np
|
||||||
|
import pytest
|
||||||
|
|
||||||
|
import mindspore.context as context
|
||||||
|
import mindspore.nn as nn
|
||||||
|
from mindspore import Tensor
|
||||||
|
|
||||||
|
|
||||||
|
class NetSoftmaxCrossEntropyWithLogits(nn.Cell):
|
||||||
|
def __init__(self):
|
||||||
|
super(NetSoftmaxCrossEntropyWithLogits, self).__init__()
|
||||||
|
self.loss = nn.SoftmaxCrossEntropyWithLogits(sparse=False)
|
||||||
|
|
||||||
|
def construct(self, logits, labels):
|
||||||
|
return self.loss(logits, labels)
|
||||||
|
|
||||||
|
|
||||||
|
@pytest.mark.level0
|
||||||
|
@pytest.mark.platform_x86_cpu
|
||||||
|
@pytest.mark.env_onecard
|
||||||
|
def test_softmax_cross_entropy_with_logits():
|
||||||
|
logits = Tensor(np.array([[1, 1, 10],
|
||||||
|
[1, 10, 1],
|
||||||
|
[10, 1, 1]]).astype(np.float32))
|
||||||
|
labels = Tensor(np.array([[0, 0, 1],
|
||||||
|
[0, 1, 0],
|
||||||
|
[1, 0, 0]]).astype(np.float32))
|
||||||
|
expect_loss = [0.00024673, 0.00024673, 0.00024673]
|
||||||
|
|
||||||
|
context.set_context(mode=context.GRAPH_MODE, device_target='CPU')
|
||||||
|
softmax_cross_entropy_with_logits = NetSoftmaxCrossEntropyWithLogits()
|
||||||
|
output = softmax_cross_entropy_with_logits(logits, labels)
|
||||||
|
error0 = 1.0e-6
|
||||||
|
diff0 = output.asnumpy() - expect_loss
|
||||||
|
assert np.all(abs(diff0) < error0)
|
||||||
|
|
||||||
|
test_softmax_cross_entropy_with_logits()
|
||||||
Loading…
Reference in New Issue