forked from mindspore-Ecosystem/mindspore
add reduceany and reduceall to cpu
This commit is contained in:
yanglf1121
parent
98f380b6e1
commit
01bfacddd6
|
|
@ -0,0 +1,185 @@
|
|||
/**
|
||||
* Copyright 2021 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 <string>
|
||||
#include <vector>
|
||||
#include <deque>
|
||||
#include <algorithm>
|
||||
#include <map>
|
||||
#include "backend/kernel_compiler/cpu/reduce_logic_cpu_kernel.h"
|
||||
#include "runtime/device/cpu/cpu_device_address.h"
|
||||
|
||||
namespace mindspore {
|
||||
namespace kernel {
|
||||
const size_t kReduceTypeAll = 1;
|
||||
const size_t kReduceTypeAny = 2;
|
||||
const size_t kMaxDim = 100;
|
||||
static std::map<std::string, int> reduce_types_map_ = {{"ReduceAll", 1}, {"ReduceAny", 2}};
|
||||
|
||||
template <typename T>
|
||||
void ReduceLogicCPUKernel<T>::InitKernel(const CNodePtr &kernel_node) {
|
||||
MS_EXCEPTION_IF_NULL(kernel_node);
|
||||
std::string kernel_name = AnfAlgo::GetCNodeName(kernel_node);
|
||||
|
||||
reduce_type_ = reduce_types_map_[kernel_name];
|
||||
if (reduce_type_ == 0) {
|
||||
MS_LOG(EXCEPTION) << "Array reduce kernel type " << kernel_name << " is not supported.";
|
||||
}
|
||||
shape_ = AnfAlgo::GetInputDeviceShape(kernel_node, 0);
|
||||
CheckAxis(kernel_node);
|
||||
if (shape_.empty()) {
|
||||
shape_.push_back(1);
|
||||
}
|
||||
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_;
|
||||
}
|
||||
|
||||
template <typename T>
|
||||
bool ReduceLogicCPUKernel<T>::Launch(const std::vector<kernel::AddressPtr> &inputs,
|
||||
const std::vector<kernel::AddressPtr> & /*workspaces*/,
|
||||
const std::vector<kernel::AddressPtr> &outputs) {
|
||||
size_t out_size = left_dims_ * sizeof(T);
|
||||
size_t in_size = stride_ * out_size;
|
||||
if (inputs[0]->size != in_size || outputs[0]->size != out_size) {
|
||||
MS_LOG(EXCEPTION) << "invalid input or output data size!";
|
||||
}
|
||||
auto input = reinterpret_cast<T *>(inputs[0]->addr);
|
||||
auto output = reinterpret_cast<T *>(outputs[0]->addr);
|
||||
int size = inputs[0]->size / sizeof(T);
|
||||
std::deque<T> new_inputs(IntToSize(size), false);
|
||||
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_inputs[0]);
|
||||
ConvertDataToOutput(&new_inputs[0], output);
|
||||
return true;
|
||||
}
|
||||
|
||||
template <typename T>
|
||||
void ReduceLogicCPUKernel<T>::CheckAxis(const CNodePtr &kernel_node) {
|
||||
auto axis_addr = AnfAlgo::GetCNodePrimitive(kernel_node)->GetAttr(AXIS);
|
||||
if (axis_addr->isa<ValueTuple>() || axis_addr->isa<ValueList>()) {
|
||||
std::vector<int> attr_axis;
|
||||
std::vector<int64_t> attr_axis_me = AnfAlgo::GetNodeAttr<std::vector<int64_t>>(kernel_node, AXIS);
|
||||
(void)std::transform(attr_axis_me.begin(), attr_axis_me.end(), std::back_inserter(attr_axis),
|
||||
[](const int64_t &value) { return static_cast<int>(value); });
|
||||
if (attr_axis.size() > shape_.size()) {
|
||||
MS_LOG(EXCEPTION) << "invalid axis size: " << axis_.size();
|
||||
} else if (attr_axis.empty()) {
|
||||
for (size_t i = 0; i < shape_.size(); ++i) {
|
||||
axis_.push_back(i);
|
||||
}
|
||||
} else {
|
||||
for (auto axis : attr_axis) {
|
||||
while (axis < 0) {
|
||||
axis += SizeToInt(shape_.size());
|
||||
}
|
||||
if (IntToSize(axis) >= (shape_.size())) {
|
||||
MS_LOG(EXCEPTION) << "axis value is oversize.";
|
||||
}
|
||||
axis_.push_back(IntToSize(axis));
|
||||
}
|
||||
}
|
||||
} else if (axis_addr->isa<Int64Imm>()) {
|
||||
int axis = static_cast<int64_t>(AnfAlgo::GetNodeAttr<int64_t>(kernel_node, AXIS));
|
||||
while (axis < 0) {
|
||||
axis += SizeToInt(shape_.size());
|
||||
}
|
||||
if (IntToSize(axis) >= shape_.size()) {
|
||||
MS_LOG(EXCEPTION) << "axis value is oversize.";
|
||||
}
|
||||
axis_.push_back(IntToSize(axis));
|
||||
} else {
|
||||
MS_LOG(EXCEPTION) << "Attribute axis type is invalid.";
|
||||
}
|
||||
}
|
||||
|
||||
template <typename T>
|
||||
void ReduceLogicCPUKernel<T>::ConvertDataToOutput(const T *new_input, T *output) {
|
||||
if (reduce_type_ == kReduceTypeAll) {
|
||||
for (size_t i = 0; i < left_dims_; ++i) {
|
||||
auto value{true};
|
||||
for (size_t k = 0; k < stride_; ++k) {
|
||||
value &= new_input[i * stride_ + k];
|
||||
}
|
||||
output[i] = value;
|
||||
}
|
||||
} else if (reduce_type_ == kReduceTypeAny) {
|
||||
for (size_t i = 0; i < left_dims_; ++i) {
|
||||
auto value{false};
|
||||
for (size_t k = 0; k < stride_; ++k) {
|
||||
value |= new_input[i * stride_ + k];
|
||||
}
|
||||
output[i] = value;
|
||||
}
|
||||
} else {
|
||||
MS_LOG(EXCEPTION) << "Array reduce kernel type " << reduce_type_ << " is not supported.";
|
||||
}
|
||||
}
|
||||
|
||||
template <typename T>
|
||||
void ReduceLogicCPUKernel<T>::Transpose(const int size, const T *input, const std::vector<size_t> &input_shape,
|
||||
const std::vector<size_t> &input_axis, const int shape_size, T *output) {
|
||||
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]);
|
||||
}
|
||||
auto task = [&](size_t start, size_t end) {
|
||||
int pos_array[kMaxDim];
|
||||
for (size_t position = start; position < end; position += 1) {
|
||||
size_t 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];
|
||||
}
|
||||
size_t new_position = pos_array[SizeToInt(input_axis[shape_size - 1])];
|
||||
size_t 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];
|
||||
}
|
||||
};
|
||||
CPUKernelUtils::ParallelFor(task, size);
|
||||
return;
|
||||
}
|
||||
} // namespace kernel
|
||||
} // namespace mindspore
|
||||
|
|
@ -0,0 +1,53 @@
|
|||
/**
|
||||
* Copyright 2021 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_BACKEND_KERNEL_COMPILER_CPU_REDUCE_LOGIC_CPU_KERNEL_H_
|
||||
#define MINDSPORE_CCSRC_BACKEND_KERNEL_COMPILER_CPU_REDUCE_LOGIC_CPU_KERNEL_H_
|
||||
#include <vector>
|
||||
#include <memory>
|
||||
#include <string>
|
||||
#include "backend/kernel_compiler/cpu/cpu_kernel.h"
|
||||
#include "backend/kernel_compiler/cpu/cpu_kernel_factory.h"
|
||||
|
||||
namespace mindspore {
|
||||
namespace kernel {
|
||||
template <typename T>
|
||||
class ReduceLogicCPUKernel : public CPUKernel {
|
||||
public:
|
||||
ReduceLogicCPUKernel() = default;
|
||||
~ReduceLogicCPUKernel() 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 T *input, const std::vector<size_t> &input_shape,
|
||||
const std::vector<size_t> &input_axis, const int shape_size, T *output);
|
||||
void ConvertDataToOutput(const T *input, T *output);
|
||||
void CheckAxis(const CNodePtr &kernel_node);
|
||||
size_t reduce_type_ = 0;
|
||||
std::vector<size_t> axis_;
|
||||
std::vector<size_t> shape_;
|
||||
size_t left_dims_ = 1;
|
||||
size_t stride_ = 1;
|
||||
};
|
||||
|
||||
MS_REG_CPU_KERNEL_T(ReduceAll, KernelAttr().AddInputAttr(kNumberTypeBool).AddOutputAttr(kNumberTypeBool),
|
||||
ReduceLogicCPUKernel, bool);
|
||||
MS_REG_CPU_KERNEL_T(ReduceAny, KernelAttr().AddInputAttr(kNumberTypeBool).AddOutputAttr(kNumberTypeBool),
|
||||
ReduceLogicCPUKernel, bool);
|
||||
} // namespace kernel
|
||||
} // namespace mindspore
|
||||
#endif // MINDSPORE_CCSRC_BACKEND_KERNEL_COMPILER_CPU_REDUCE_LOGIC_CPU_KERNEL_H_
|
||||
|
|
@ -472,7 +472,7 @@ class ReduceAll(_Reduce):
|
|||
the shape of output is :math:`(x_1, x_4, ..., x_R)`.
|
||||
|
||||
Supported Platforms:
|
||||
``Ascend`` ``GPU``
|
||||
``Ascend`` ``GPU`` ``CPU``
|
||||
|
||||
Examples:
|
||||
>>> input_x = Tensor(np.array([[True, False], [True, True]]))
|
||||
|
|
@ -514,7 +514,7 @@ class ReduceAny(_Reduce):
|
|||
the shape of output is :math:`(x_1, x_4, ..., x_R)`.
|
||||
|
||||
Supported Platforms:
|
||||
``Ascend`` ``GPU``
|
||||
``Ascend`` ``GPU`` ``CPU``
|
||||
|
||||
Examples:
|
||||
>>> input_x = Tensor(np.array([[True, False], [True, True]]))
|
||||
|
|
|
|||
|
|
@ -1,4 +1,4 @@
|
|||
# Copyright 2020 Huawei Technologies Co., Ltd
|
||||
# Copyright 2020-2021 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.
|
||||
|
|
@ -61,6 +61,27 @@ class NetReduce(nn.Cell):
|
|||
self.reduce_min(indice, self.axis6))
|
||||
|
||||
|
||||
class NetReduceLogic(nn.Cell):
|
||||
def __init__(self):
|
||||
super(NetReduceLogic, self).__init__()
|
||||
self.axis0 = 0
|
||||
self.axis1 = -1
|
||||
self.axis2 = (0, 1, 2)
|
||||
self.axis3 = ()
|
||||
self.reduce_all = P.ReduceAll(False)
|
||||
self.reduce_any = P.ReduceAny(False)
|
||||
|
||||
@ms_function
|
||||
def construct(self, indice):
|
||||
return (self.reduce_all(indice, self.axis0),
|
||||
self.reduce_all(indice, self.axis1),
|
||||
self.reduce_all(indice, self.axis2),
|
||||
self.reduce_all(indice, self.axis3),
|
||||
self.reduce_any(indice, self.axis0),
|
||||
self.reduce_any(indice, self.axis1),
|
||||
self.reduce_any(indice, self.axis2),
|
||||
self.reduce_any(indice, self.axis3),)
|
||||
|
||||
|
||||
@pytest.mark.level0
|
||||
@pytest.mark.platform_x86_cpu
|
||||
|
|
@ -125,4 +146,38 @@ def test_reduce():
|
|||
assert (output[16].asnumpy() == expect_11).all()
|
||||
assert (output[17].asnumpy() == 0.0).all()
|
||||
|
||||
|
||||
@pytest.mark.level0
|
||||
@pytest.mark.platform_x86_cpu
|
||||
@pytest.mark.env_onecard
|
||||
def test_reduce_logic():
|
||||
reduce_logic = NetReduceLogic()
|
||||
indice_bool = Tensor([[[False, True, True, True, False, True],
|
||||
[True, True, True, True, True, False]],
|
||||
[[True, False, True, True, False, True],
|
||||
[True, False, False, True, True, True]],
|
||||
[[True, True, True, False, False, False],
|
||||
[True, True, True, False, True, True]]])
|
||||
output = reduce_logic(indice_bool)
|
||||
expect_all_1 = np.array([[False, False, True, False, False, False],
|
||||
[True, False, False, False, True, False]])
|
||||
expect_all_2 = np.array([[False, False], [False, False], [False, False]])
|
||||
expect_all_3 = False
|
||||
expect_all_4 = False
|
||||
expect_any_1 = np.array([[True, True, True, True, False, True], [True, True, True, True, True, True]])
|
||||
expect_any_2 = np.array([[True, True], [True, True], [True, True]])
|
||||
expect_any_3 = True
|
||||
expect_any_4 = True
|
||||
|
||||
assert (output[0].asnumpy() == expect_all_1).all()
|
||||
assert (output[1].asnumpy() == expect_all_2).all()
|
||||
assert (output[2].asnumpy() == expect_all_3).all()
|
||||
assert (output[3].asnumpy() == expect_all_4).all()
|
||||
assert (output[4].asnumpy() == expect_any_1).all()
|
||||
assert (output[5].asnumpy() == expect_any_2).all()
|
||||
assert (output[6].asnumpy() == expect_any_3).all()
|
||||
assert (output[7].asnumpy() == expect_any_4).all()
|
||||
|
||||
|
||||
test_reduce()
|
||||
test_reduce_logic()
|
||||
|
|
|
|||
Loading…
Reference in New Issue