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

!17135 complete forward and backward of SparseToDense and check of SparseTensorDenseMatmul 

From: @zhangbuxue
Reviewed-by: 
Signed-off-by:
This commit is contained in:
mindspore-ci-bot 2021-06-02 10:57:26 +08:00 committed by Gitee
parent 6a66766a0e 0d025010ae
commit 76be4aff12
13 changed files with 378 additions and 601 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

23
mindspore/ccsrc/backend/kernel_compiler/cpu/gathernd_cpu_kernel.cc
View File

@ -19,7 +19,8 @@
namespace mindspore {
namespace kernel {
void GatherNdCPUKernel::InitKernel(const CNodePtr &kernel_node) {
template <typename T>
void GatherNdCPUKernel<T>::InitKernel(const CNodePtr &kernel_node) {
input_shapes_ = AnfAlgo::GetPrevNodeOutputInferShape(kernel_node, 0);
indices_shapes_ = AnfAlgo::GetPrevNodeOutputInferShape(kernel_node, 1);
output_shapes_ = AnfAlgo::GetOutputInferShape(kernel_node, 0);
@ -56,28 +57,14 @@ void GatherNdCPUKernel::InitKernel(const CNodePtr &kernel_node) {
}
}
bool GatherNdCPUKernel::Launch(const std::vector<kernel::AddressPtr> &inputs, const std::vector<kernel::AddressPtr> &,
const std::vector<kernel::AddressPtr> &outputs) {
if (dtype_ == kNumberTypeInt32) {
return LaunchKernel<int32_t>(inputs, outputs);
} else if (dtype_ == kNumberTypeInt64) {
return LaunchKernel<int64_t>(inputs, outputs);
} else if (dtype_ == kNumberTypeFloat32) {
return LaunchKernel<float>(inputs, outputs);
} else if (dtype_ == kNumberTypeFloat64) {
return LaunchKernel<double>(inputs, outputs);
} else {
MS_LOG(EXCEPTION) << "Only support int, float, but actual data type is " << TypeIdLabel(dtype_);
}
}
template <typename T>
bool GatherNdCPUKernel::LaunchKernel(const std::vector<AddressPtr> &inputs, const std::vector<AddressPtr> &outputs) {
bool GatherNdCPUKernel<T>::Launch(const std::vector<kernel::AddressPtr> &inputs,
const std::vector<kernel::AddressPtr> &,
const std::vector<kernel::AddressPtr> &outputs) {
auto input_addr = reinterpret_cast<T *>(inputs[0]->addr);
auto indices_addr = reinterpret_cast<int *>(inputs[1]->addr);
auto output_addr = reinterpret_cast<T *>(outputs[0]->addr);
//
size_t output_dim0 = dims_[0];
size_t output_dim1 = dims_[1];
size_t indices_dim1 = dims_[2];

17
mindspore/ccsrc/backend/kernel_compiler/cpu/gathernd_cpu_kernel.h
View File

@ -22,6 +22,7 @@
namespace mindspore {
namespace kernel {
template <typename T>
class GatherNdCPUKernel : public CPUKernel {
public:
GatherNdCPUKernel() = default;
@ -32,9 +33,6 @@ class GatherNdCPUKernel : public CPUKernel {
bool Launch(const std::vector<AddressPtr> &inputs, const std::vector<AddressPtr> &workspace,
const std::vector<AddressPtr> &outputs) override;
template <typename T>
bool LaunchKernel(const std::vector<AddressPtr> &inputs, const std::vector<AddressPtr> &outputs);
private:
std::vector<size_t> input_shapes_;
std::vector<size_t> indices_shapes_;
@ -47,7 +45,18 @@ class GatherNdCPUKernel : public CPUKernel {
TypeId dtype_{kTypeUnknown};
};
MS_REG_CPU_KERNEL(GatherNd, KernelAttr(), GatherNdCPUKernel);
MS_REG_CPU_KERNEL_T(GatherNd, KernelAttr(), GatherNdCPUKernel, bool);
MS_REG_CPU_KERNEL_T(GatherNd, KernelAttr(), GatherNdCPUKernel, int8_t);
MS_REG_CPU_KERNEL_T(GatherNd, KernelAttr(), GatherNdCPUKernel, int16_t);
MS_REG_CPU_KERNEL_T(GatherNd, KernelAttr(), GatherNdCPUKernel, int32_t);
MS_REG_CPU_KERNEL_T(GatherNd, KernelAttr(), GatherNdCPUKernel, int64_t);
MS_REG_CPU_KERNEL_T(GatherNd, KernelAttr(), GatherNdCPUKernel, uint8_t);
MS_REG_CPU_KERNEL_T(GatherNd, KernelAttr(), GatherNdCPUKernel, uint16_t);
MS_REG_CPU_KERNEL_T(GatherNd, KernelAttr(), GatherNdCPUKernel, uint32_t);
MS_REG_CPU_KERNEL_T(GatherNd, KernelAttr(), GatherNdCPUKernel, uint64_t);
MS_REG_CPU_KERNEL_T(GatherNd, KernelAttr(), GatherNdCPUKernel, float);
MS_REG_CPU_KERNEL_T(GatherNd, KernelAttr(), GatherNdCPUKernel, double);
} // namespace kernel
} // namespace mindspore

29
mindspore/ccsrc/backend/kernel_compiler/cpu/sparse_tensor_dense_matmul_cpu_kernel.cc
View File

@ -24,13 +24,21 @@ template <typename I, typename T>
void SparseTensorDenseMatmulCPUKernel<I, T>::InitKernel(const CNodePtr &kernel_node) {
adj_st_ = AnfAlgo::GetNodeAttr<bool>(kernel_node, ADJ_ST);
adj_dt_ = AnfAlgo::GetNodeAttr<bool>(kernel_node, ADJ_dT);
output_shape_ = AnfAlgo::GetOutputInferShape(kernel_node, 0);
output_size_ = std::accumulate(output_shape_.begin(), output_shape_.end(), size_t(1), std::multiplies<size_t>());
auto values_shape = AnfAlgo::GetPrevNodeOutputInferShape(kernel_node, 1);
if (values_shape.size() != 1) {
MS_LOG(EXCEPTION) << "SparseTensorDenseMatmul requires the values must be a 1-D tensor, but got "
<< values_shape.size() << "-D";
auto indices_shape = AnfAlgo::GetPrevNodeOutputInferShape(kernel_node, 0);
if (indices_shape.size() != 2 && indices_shape[1] != 2) {
MS_LOG(EXCEPTION)
<< "SparseTensorDenseMatmul requires 'indices' should be a 2-D Tensor and the second dimension length "
"should be 2, but got 'indices' shape: "
<< indices_shape;
}
auto values_shape = AnfAlgo::GetPrevNodeOutputInferShape(kernel_node, 1);
if (values_shape.size() != 1 || values_shape[0] != indices_shape[0]) {
MS_LOG(EXCEPTION)
<< "SparseTensorDenseMatmul requires 'value's should be a 1-D Tensor and the first dimension length should be "
"equal to the first dimension length of 'indices', but got 'values' shape: "
<< values_shape;
}
output_shape_ = AnfAlgo::GetOutputInferShape(kernel_node, 0);
values_size_ = values_shape[0];
b_shape_ = AnfAlgo::GetPrevNodeOutputInferShape(kernel_node, 3);
}
@ -43,21 +51,20 @@ bool SparseTensorDenseMatmulCPUKernel<I, T>::Launch(const std::vector<kernel::Ad
auto a_values = reinterpret_cast<T *>(inputs[1]->addr);
auto b = reinterpret_cast<T *>(inputs[3]->addr);
auto out = reinterpret_cast<T *>(outputs[0]->addr);
memset(out, 0, output_size_);
const size_t output_length = outputs[0]->size / sizeof(T);
memset(out, 0, output_length);
const size_t out_dim_0 = output_shape_[0];
const size_t out_dim_1 = output_shape_[1];
const size_t b_dim_0 = b_shape_[0];
const size_t b_dim_1 = b_shape_[1];
const size_t same_dim = adj_dt_ ? b_dim_1 : b_dim_0;
for (size_t i = 0; i < values_size_; ++i) {
const int row = adj_st_ ? a_indices[i * 2 + 1] : a_indices[i * 2];
const int col = adj_st_ ? a_indices[i * 2] : a_indices[i * 2 + 1];
if (row >= SizeToInt(out_dim_0) || row < 0 || col >= SizeToInt(same_dim) || col < 0) {
MS_LOG(ERROR) << "The indices including out of bounds index, row range: [0, " << out_dim_0 << "), col range: [0, "
<< same_dim << "), but got row: " << row << ", col: " << col;
return false;
MS_EXCEPTION(ValueError) << "The indices including out of bounds index, row range: [0, " << out_dim_0
<< "), col range: [0, " << same_dim << "), but got row: " << row << ", col: " << col;
}
for (size_t n = 0; n < out_dim_1; ++n) {

161
mindspore/ccsrc/backend/kernel_compiler/cpu/sparse_tensor_dense_matmul_cpu_kernel.h
View File

@ -42,68 +42,6 @@ class SparseTensorDenseMatmulCPUKernel : public CPUKernel {
bool adj_st_{false};
bool adj_dt_{false};
};
MS_REG_CPU_KERNEL_T_S(SparseTensorDenseMatmul,
KernelAttr()
.AddInputAttr(kNumberTypeInt32)
.AddInputAttr(kNumberTypeBool)
.AddInputAttr(kNumberTypeInt32)
.AddInputAttr(kNumberTypeBool)
.AddOutputAttr(kNumberTypeBool),
SparseTensorDenseMatmulCPUKernel, int32_t, bool);
MS_REG_CPU_KERNEL_T_S(SparseTensorDenseMatmul,
KernelAttr()
.AddInputAttr(kNumberTypeInt32)
.AddInputAttr(kNumberTypeUInt8)
.AddInputAttr(kNumberTypeInt32)
.AddInputAttr(kNumberTypeUInt8)
.AddOutputAttr(kNumberTypeUInt8),
SparseTensorDenseMatmulCPUKernel, int32_t, uint8_t);
MS_REG_CPU_KERNEL_T_S(SparseTensorDenseMatmul,
KernelAttr()
.AddInputAttr(kNumberTypeInt32)
.AddInputAttr(kNumberTypeUInt16)
.AddInputAttr(kNumberTypeInt32)
.AddInputAttr(kNumberTypeUInt16)
.AddOutputAttr(kNumberTypeUInt16),
SparseTensorDenseMatmulCPUKernel, int32_t, uint16_t);
MS_REG_CPU_KERNEL_T_S(SparseTensorDenseMatmul,
KernelAttr()
.AddInputAttr(kNumberTypeInt32)
.AddInputAttr(kNumberTypeUInt32)
.AddInputAttr(kNumberTypeInt32)
.AddInputAttr(kNumberTypeUInt32)
.AddOutputAttr(kNumberTypeUInt32),
SparseTensorDenseMatmulCPUKernel, int32_t, uint32_t);
MS_REG_CPU_KERNEL_T_S(SparseTensorDenseMatmul,
KernelAttr()
.AddInputAttr(kNumberTypeInt32)
.AddInputAttr(kNumberTypeUInt64)
.AddInputAttr(kNumberTypeInt32)
.AddInputAttr(kNumberTypeUInt64)
.AddOutputAttr(kNumberTypeUInt64),
SparseTensorDenseMatmulCPUKernel, int32_t, uint64_t);
MS_REG_CPU_KERNEL_T_S(SparseTensorDenseMatmul,
KernelAttr()
.AddInputAttr(kNumberTypeInt32)
.AddInputAttr(kNumberTypeInt8)
.AddInputAttr(kNumberTypeInt32)
.AddInputAttr(kNumberTypeInt8)
.AddOutputAttr(kNumberTypeInt8),
SparseTensorDenseMatmulCPUKernel, int32_t, int8_t);
MS_REG_CPU_KERNEL_T_S(SparseTensorDenseMatmul,
KernelAttr()
.AddInputAttr(kNumberTypeInt32)
.AddInputAttr(kNumberTypeInt16)
.AddInputAttr(kNumberTypeInt32)
.AddInputAttr(kNumberTypeInt16)
.AddOutputAttr(kNumberTypeInt16),
SparseTensorDenseMatmulCPUKernel, int32_t, int16_t);
MS_REG_CPU_KERNEL_T_S(SparseTensorDenseMatmul,
KernelAttr()
@ -141,105 +79,6 @@ MS_REG_CPU_KERNEL_T_S(SparseTensorDenseMatmul,
.AddOutputAttr(kNumberTypeFloat64),
SparseTensorDenseMatmulCPUKernel, int32_t, double);
MS_REG_CPU_KERNEL_T_S(SparseTensorDenseMatmul,
KernelAttr()
.AddInputAttr(kNumberTypeInt64)
.AddInputAttr(kNumberTypeBool)
.AddInputAttr(kNumberTypeInt32)
.AddInputAttr(kNumberTypeBool)
.AddOutputAttr(kNumberTypeBool),
SparseTensorDenseMatmulCPUKernel, int64_t, bool);
MS_REG_CPU_KERNEL_T_S(SparseTensorDenseMatmul,
KernelAttr()
.AddInputAttr(kNumberTypeInt64)
.AddInputAttr(kNumberTypeUInt8)
.AddInputAttr(kNumberTypeInt32)
.AddInputAttr(kNumberTypeUInt8)
.AddOutputAttr(kNumberTypeUInt8),
SparseTensorDenseMatmulCPUKernel, int64_t, uint8_t);
MS_REG_CPU_KERNEL_T_S(SparseTensorDenseMatmul,
KernelAttr()
.AddInputAttr(kNumberTypeInt64)
.AddInputAttr(kNumberTypeUInt16)
.AddInputAttr(kNumberTypeInt32)
.AddInputAttr(kNumberTypeUInt16)
.AddOutputAttr(kNumberTypeUInt16),
SparseTensorDenseMatmulCPUKernel, int64_t, uint16_t);
MS_REG_CPU_KERNEL_T_S(SparseTensorDenseMatmul,
KernelAttr()
.AddInputAttr(kNumberTypeInt64)
.AddInputAttr(kNumberTypeUInt32)
.AddInputAttr(kNumberTypeInt32)
.AddInputAttr(kNumberTypeUInt32)
.AddOutputAttr(kNumberTypeUInt32),
SparseTensorDenseMatmulCPUKernel, int64_t, uint32_t);
MS_REG_CPU_KERNEL_T_S(SparseTensorDenseMatmul,
KernelAttr()
.AddInputAttr(kNumberTypeInt64)
.AddInputAttr(kNumberTypeUInt64)
.AddInputAttr(kNumberTypeInt32)
.AddInputAttr(kNumberTypeUInt64)
.AddOutputAttr(kNumberTypeUInt64),
SparseTensorDenseMatmulCPUKernel, int64_t, uint64_t);
MS_REG_CPU_KERNEL_T_S(SparseTensorDenseMatmul,
KernelAttr()
.AddInputAttr(kNumberTypeInt64)
.AddInputAttr(kNumberTypeInt8)
.AddInputAttr(kNumberTypeInt32)
.AddInputAttr(kNumberTypeInt8)
.AddOutputAttr(kNumberTypeInt8),
SparseTensorDenseMatmulCPUKernel, int64_t, int8_t);
MS_REG_CPU_KERNEL_T_S(SparseTensorDenseMatmul,
KernelAttr()
.AddInputAttr(kNumberTypeInt64)
.AddInputAttr(kNumberTypeInt16)
.AddInputAttr(kNumberTypeInt32)
.AddInputAttr(kNumberTypeInt16)
.AddOutputAttr(kNumberTypeInt16),
SparseTensorDenseMatmulCPUKernel, int64_t, int16_t);
MS_REG_CPU_KERNEL_T_S(SparseTensorDenseMatmul,
KernelAttr()
.AddInputAttr(kNumberTypeInt64)
.AddInputAttr(kNumberTypeInt32)
.AddInputAttr(kNumberTypeInt32)
.AddInputAttr(kNumberTypeInt32)
.AddOutputAttr(kNumberTypeInt32),
SparseTensorDenseMatmulCPUKernel, int64_t, int32_t);
MS_REG_CPU_KERNEL_T_S(SparseTensorDenseMatmul,
KernelAttr()
.AddInputAttr(kNumberTypeInt64)
.AddInputAttr(kNumberTypeInt64)
.AddInputAttr(kNumberTypeInt32)
.AddInputAttr(kNumberTypeInt64)
.AddOutputAttr(kNumberTypeInt64),
SparseTensorDenseMatmulCPUKernel, int64_t, int64_t);
MS_REG_CPU_KERNEL_T_S(SparseTensorDenseMatmul,
KernelAttr()
.AddInputAttr(kNumberTypeInt64)
.AddInputAttr(kNumberTypeFloat32)
.AddInputAttr(kNumberTypeInt32)
.AddInputAttr(kNumberTypeFloat32)
.AddOutputAttr(kNumberTypeFloat32),
SparseTensorDenseMatmulCPUKernel, int64_t, float);
MS_REG_CPU_KERNEL_T_S(SparseTensorDenseMatmul,
KernelAttr()
.AddInputAttr(kNumberTypeInt64)
.AddInputAttr(kNumberTypeFloat64)
.AddInputAttr(kNumberTypeInt32)
.AddInputAttr(kNumberTypeFloat64)
.AddOutputAttr(kNumberTypeFloat64),
SparseTensorDenseMatmulCPUKernel, int64_t, double);
} // namespace kernel
} // namespace mindspore
#endif // MINDSPORE_CCSRC_BACKEND_KERNEL_COMPILER_CPU_RMSPROP_CPU_KERNEL_H_

76
mindspore/ccsrc/backend/kernel_compiler/cpu/sparse_to_dense_cpu_kernal.cc
View File

@ -23,24 +23,20 @@ namespace kernel {
template <typename I, typename T>
void SparseToDenseCPUKernel<I, T>::InitKernel(const CNodePtr &kernel_node) {
CheckParam(kernel_node);
indices_shape_ = AnfAlgo::GetPrevNodeOutputInferShape(kernel_node, 0);
values_shape_ = AnfAlgo::GetPrevNodeOutputInferShape(kernel_node, 1);
dense_shape_shape_ = AnfAlgo::GetPrevNodeOutputInferShape(kernel_node, 2);
auto indices_shape = AnfAlgo::GetPrevNodeOutputInferShape(kernel_node, 0);
if (indices_shape.size() != 2) {
MS_LOG(EXCEPTION) << "SparseToDense requires 'indices' should be a 2-D Tensor, but got " << indices_shape.size()
<< "-D";
}
auto values_shape = AnfAlgo::GetPrevNodeOutputInferShape(kernel_node, 1);
if (values_shape.size() != 1 || values_shape[0] != indices_shape[0]) {
MS_LOG(EXCEPTION)
<< "SparseToDense requires 'values' should be a 1-D Tensor and the first dimension length should be "
"equal to the 'indices' first dimension length, but got 'values' shape: "
<< values_shape;
}
values_size_ = values_shape[0];
output_shape_ = AnfAlgo::GetOutputInferShape(kernel_node, 0);
if (!indices_shape_.size() || !values_shape_.size() || !output_shape_.size()) {
MS_LOG(EXCEPTION) << "Input NULL";
}
if (indices_shape_.size() > 2 || indices_shape_[0] != values_shape_[0]) {
MS_LOG(EXCEPTION) << "Input Error";
}
}
size_t DenseGetTensorLen(const std::vector<size_t> &shape) {
size_t len = 1;
for (size_t i = 0; i < shape.size(); i++) {
len *= shape[i];
}
return len;
}
template <typename I, typename T>
@ -50,35 +46,25 @@ bool SparseToDenseCPUKernel<I, T>::Launch(const std::vector<kernel::AddressPtr>
auto indices_addr = reinterpret_cast<I *>(inputs[0]->addr);
auto values_addr = reinterpret_cast<T *>(inputs[1]->addr);
auto output_addr = reinterpret_cast<T *>(outputs[0]->addr);
const size_t output_length = outputs[0]->size / sizeof(T);
memset(output_addr, 0, output_length);
size_t output_len = DenseGetTensorLen(output_shape_);
memset(output_addr, 0, output_len * sizeof(T));
std::vector<size_t> cargo(output_shape_.size(), 0);
size_t i = output_shape_.size() - 1;
switch (indices_shape_.size()) {
case 1:
for (i = 0; i < indices_shape_[0]; i++) {
output_addr[indices_addr[i]] = values_addr[i];
size_t rank = output_shape_.size();
for (size_t i = 0; i < values_size_; ++i) {
size_t out_index = 0;
for (size_t j = 0; j < rank; j++) {
int index = indices_addr[i * rank + j];
if (index >= SizeToInt(output_shape_[j]) || index < 0) {
MS_EXCEPTION(ValueError) << "The " << i << "th value in " << j << "th dimension index: " << index
<< " out of bounds: [0, " << output_shape_[j] << ")";
}
break;
case 2:
cargo[i] = 1;
for (; i >= 1; i--) {
cargo[i - 1] = cargo[i] * output_shape_[i];
size_t count = 1;
for (size_t k = j + 1; k < rank; k++) {
count *= output_shape_[k];
}
for (i = 0; i < indices_shape_[0]; i++) {
size_t out_index = 0;
for (size_t j = 0; j < indices_shape_[1]; j++) {
out_index += (*(indices_addr + i * indices_shape_[1] + j)) * cargo[j];
}
output_addr[out_index] = values_addr[i];
}
break;
default:
break;
out_index += SizeToInt(index) * count;
}
output_addr[out_index] = values_addr[i];
}
return true;
}
@ -87,11 +73,11 @@ template <typename I, typename T>
void SparseToDenseCPUKernel<I, T>::CheckParam(const CNodePtr &kernel_node) {
size_t input_num = AnfAlgo::GetInputTensorNum(kernel_node);
if (input_num != 3) {
MS_LOG(EXCEPTION) << "Input number is " << input_num << ", but SparseToDenseCPUKernel needs 3 input.";
MS_LOG(EXCEPTION) << "SparseToDense needs 3 inputs, but got " << input_num;
}
size_t output_num = AnfAlgo::GetOutputTensorNum(kernel_node);
if (output_num != 1) {
MS_LOG(EXCEPTION) << "Output number is " << output_num << ", but SparseToDenseCPUKernel needs 1 output.";
MS_LOG(EXCEPTION) << "SparseToDense should have 2 outputs, but got " << output_num;
}
}
} // namespace kernel

147
mindspore/ccsrc/backend/kernel_compiler/cpu/sparse_to_dense_cpu_kernal.h
View File

@ -37,19 +37,17 @@ class SparseToDenseCPUKernel : public CPUKernel {
private:
void CheckParam(const CNodePtr &kernel_node);
std::vector<size_t> indices_shape_;
std::vector<size_t> values_shape_;
std::vector<size_t> dense_shape_shape_;
std::vector<size_t> output_shape_;
size_t values_size_{0};
};
MS_REG_CPU_KERNEL_T_S(SparseToDense,
KernelAttr()
.AddInputAttr(kNumberTypeInt32)
.AddInputAttr(kNumberTypeBool)
.AddInputAttr(kNumberTypeInt32)
.AddInputAttr(kNumberTypeInt32)
.AddOutputAttr(kNumberTypeInt32),
SparseToDenseCPUKernel, int32_t, int32_t);
.AddOutputAttr(kNumberTypeBool),
SparseToDenseCPUKernel, int32_t, bool);
MS_REG_CPU_KERNEL_T_S(SparseToDense,
KernelAttr()
@ -59,14 +57,6 @@ MS_REG_CPU_KERNEL_T_S(SparseToDense,
.AddOutputAttr(kNumberTypeInt8),
SparseToDenseCPUKernel, int32_t, int8_t);
MS_REG_CPU_KERNEL_T_S(SparseToDense,
KernelAttr()
.AddInputAttr(kNumberTypeInt32)
.AddInputAttr(kNumberTypeUInt8)
.AddInputAttr(kNumberTypeInt32)
.AddOutputAttr(kNumberTypeUInt8),
SparseToDenseCPUKernel, int32_t, uint8_t);
MS_REG_CPU_KERNEL_T_S(SparseToDense,
KernelAttr()
.AddInputAttr(kNumberTypeInt32)
@ -78,10 +68,10 @@ MS_REG_CPU_KERNEL_T_S(SparseToDense,
MS_REG_CPU_KERNEL_T_S(SparseToDense,
KernelAttr()
.AddInputAttr(kNumberTypeInt32)
.AddInputAttr(kNumberTypeUInt16)
.AddInputAttr(kNumberTypeInt32)
.AddOutputAttr(kNumberTypeUInt16),
SparseToDenseCPUKernel, int32_t, uint16_t);
.AddInputAttr(kNumberTypeInt32)
.AddOutputAttr(kNumberTypeInt32),
SparseToDenseCPUKernel, int32_t, int32_t);
MS_REG_CPU_KERNEL_T_S(SparseToDense,
KernelAttr()
@ -91,6 +81,38 @@ MS_REG_CPU_KERNEL_T_S(SparseToDense,
.AddOutputAttr(kNumberTypeInt64),
SparseToDenseCPUKernel, int32_t, int64_t);
MS_REG_CPU_KERNEL_T_S(SparseToDense,
KernelAttr()
.AddInputAttr(kNumberTypeInt32)
.AddInputAttr(kNumberTypeUInt8)
.AddInputAttr(kNumberTypeInt32)
.AddOutputAttr(kNumberTypeUInt8),
SparseToDenseCPUKernel, int32_t, uint8_t);
MS_REG_CPU_KERNEL_T_S(SparseToDense,
KernelAttr()
.AddInputAttr(kNumberTypeInt32)
.AddInputAttr(kNumberTypeUInt16)
.AddInputAttr(kNumberTypeInt32)
.AddOutputAttr(kNumberTypeUInt16),
SparseToDenseCPUKernel, int32_t, uint16_t);
MS_REG_CPU_KERNEL_T_S(SparseToDense,
KernelAttr()
.AddInputAttr(kNumberTypeInt32)
.AddInputAttr(kNumberTypeUInt32)
.AddInputAttr(kNumberTypeInt32)
.AddOutputAttr(kNumberTypeUInt32),
SparseToDenseCPUKernel, int32_t, uint32_t);
MS_REG_CPU_KERNEL_T_S(SparseToDense,
KernelAttr()
.AddInputAttr(kNumberTypeInt32)
.AddInputAttr(kNumberTypeUInt64)
.AddInputAttr(kNumberTypeInt32)
.AddOutputAttr(kNumberTypeUInt64),
SparseToDenseCPUKernel, int32_t, uint64_t);
MS_REG_CPU_KERNEL_T_S(SparseToDense,
KernelAttr()
.AddInputAttr(kNumberTypeInt32)
@ -102,9 +124,9 @@ MS_REG_CPU_KERNEL_T_S(SparseToDense,
MS_REG_CPU_KERNEL_T_S(SparseToDense,
KernelAttr()
.AddInputAttr(kNumberTypeInt32)
.AddInputAttr(kNumberTypeFloat)
.AddInputAttr(kNumberTypeFloat32)
.AddInputAttr(kNumberTypeInt32)
.AddOutputAttr(kNumberTypeFloat),
.AddOutputAttr(kNumberTypeFloat32),
SparseToDenseCPUKernel, int32_t, float);
MS_REG_CPU_KERNEL_T_S(SparseToDense,
@ -115,93 +137,6 @@ MS_REG_CPU_KERNEL_T_S(SparseToDense,
.AddOutputAttr(kNumberTypeFloat64),
SparseToDenseCPUKernel, int32_t, double);
MS_REG_CPU_KERNEL_T_S(SparseToDense,
KernelAttr()
.AddInputAttr(kNumberTypeInt32)
.AddInputAttr(kNumberTypeBool)
.AddInputAttr(kNumberTypeInt32)
.AddOutputAttr(kNumberTypeBool),
SparseToDenseCPUKernel, int32_t, bool);
MS_REG_CPU_KERNEL_T_S(SparseToDense,
KernelAttr()
.AddInputAttr(kNumberTypeInt64)
.AddInputAttr(kNumberTypeInt32)
.AddInputAttr(kNumberTypeInt64)
.AddOutputAttr(kNumberTypeInt32),
SparseToDenseCPUKernel, int64_t, int32_t);
MS_REG_CPU_KERNEL_T_S(SparseToDense,
KernelAttr()
.AddInputAttr(kNumberTypeInt64)
.AddInputAttr(kNumberTypeInt64)
.AddInputAttr(kNumberTypeInt64)
.AddOutputAttr(kNumberTypeInt64),
SparseToDenseCPUKernel, int64_t, int64_t);
MS_REG_CPU_KERNEL_T_S(SparseToDense,
KernelAttr()
.AddInputAttr(kNumberTypeInt64)
.AddInputAttr(kNumberTypeInt8)
.AddInputAttr(kNumberTypeInt64)
.AddOutputAttr(kNumberTypeInt8),
SparseToDenseCPUKernel, int64_t, int8_t);
MS_REG_CPU_KERNEL_T_S(SparseToDense,
KernelAttr()
.AddInputAttr(kNumberTypeInt64)
.AddInputAttr(kNumberTypeUInt8)
.AddInputAttr(kNumberTypeInt64)
.AddOutputAttr(kNumberTypeUInt8),
SparseToDenseCPUKernel, int64_t, uint8_t);
MS_REG_CPU_KERNEL_T_S(SparseToDense,
KernelAttr()
.AddInputAttr(kNumberTypeInt64)
.AddInputAttr(kNumberTypeInt16)
.AddInputAttr(kNumberTypeInt64)
.AddOutputAttr(kNumberTypeInt16),
SparseToDenseCPUKernel, int64_t, int16_t);
MS_REG_CPU_KERNEL_T_S(SparseToDense,
KernelAttr()
.AddInputAttr(kNumberTypeInt64)
.AddInputAttr(kNumberTypeUInt16)
.AddInputAttr(kNumberTypeInt64)
.AddOutputAttr(kNumberTypeUInt16),
SparseToDenseCPUKernel, int64_t, uint16_t);
MS_REG_CPU_KERNEL_T_S(SparseToDense,
KernelAttr()
.AddInputAttr(kNumberTypeInt64)
.AddInputAttr(kNumberTypeFloat16)
.AddInputAttr(kNumberTypeInt64)
.AddOutputAttr(kNumberTypeFloat16),
SparseToDenseCPUKernel, int64_t, float16);
MS_REG_CPU_KERNEL_T_S(SparseToDense,
KernelAttr()
.AddInputAttr(kNumberTypeInt64)
.AddInputAttr(kNumberTypeFloat)
.AddInputAttr(kNumberTypeInt64)
.AddOutputAttr(kNumberTypeFloat),
SparseToDenseCPUKernel, int64_t, float);
MS_REG_CPU_KERNEL_T_S(SparseToDense,
KernelAttr()
.AddInputAttr(kNumberTypeInt64)
.AddInputAttr(kNumberTypeFloat64)
.AddInputAttr(kNumberTypeInt64)
.AddOutputAttr(kNumberTypeFloat64),
SparseToDenseCPUKernel, int64_t, double);
MS_REG_CPU_KERNEL_T_S(SparseToDense,
KernelAttr()
.AddInputAttr(kNumberTypeInt64)
.AddInputAttr(kNumberTypeBool)
.AddInputAttr(kNumberTypeInt64)
.AddOutputAttr(kNumberTypeBool),
SparseToDenseCPUKernel, int64_t, bool);
} // namespace kernel
} // namespace mindspore
#endif // MINDSPORE_CCSRC_BACKEND_KERNEL_COMPILER_CPU_SPARSETODENSE_CPU_KERNEL_H_

83
mindspore/nn/sparse/sparse.py
View File

@ -19,19 +19,19 @@ from ..cell import Cell
class SparseToDense(Cell):
"""
Converts a sparse representation into a dense tensor.
Converts a sparse tensor into dense.
Not yet supported by any backend at the moment.
Inputs:
sparse_tensor (SparseTensor): the sparse tensor to convert.
- **sparse_tensor** (SparseTensor): the sparse tensor to convert.
Outputs:
Tensor, the tensor converted.
Tensor, converted from sparse tensor.
Raises:
TypeError: If `sparse_tensor.indices` is neither int32 nor int64.
TypeError: If 'sparse_tensor.values' is not a Number.
TypeError: If the`sparse_tensor.indices` data type is neither int32 nor int64.
TypeError: If the 'sparse_tensor.values' data type is not a Number or bool.
TypeError: If 'sparse_tensor.dense_shape' is not a tuple.
Supported Platforms:
@ -52,6 +52,7 @@ class SparseToDense(Cell):
[0 0 2 0]
[0 0 0 0]]
"""
def __init__(self):
super(SparseToDense, self).__init__()
self.sparse_to_dense = P.SparseToDense()
@ -61,59 +62,65 @@ class SparseToDense(Cell):
sparse_tensor.values,
sparse_tensor.dense_shape)
class SparseTensorDenseMatmul(Cell):
"""
Multiply SparseTensor(of rank 2) "A" by dense tensor.
The shape of sparse tensor is :math:`(N, C)`, and the shape of dense tensor is :math:`(C, M)`, then the shape of
output tensor is :math:`(N, M)`.The output data type is the same as "values".
Multiplies sparse matrix `a` and dense matrix `b`.
The rank of sparse matrix and dense matrix must equal to `2`.
Args:
- *adjoint_st** (Bool) - If true, SparseTensor is transposed before multiplication. Default: False.
- *adjoint_dt** (Bool) - If true, DenseTensor is transposed before multiplication. Default: False.
- *adjoint_st** (bool) - If true, sparse tensor is transposed before multiplication. Default: False.
- *adjoint_dt** (bool) - If true, dense tensor is transposed before multiplication. Default: False.
Inputs:
- **indices** (Tensor) - A 2D tensor with shape [N, rank], containing the indices of the nonzero values. The
indices of sparse representation, support int32/int64.
- **values** (Tensor) - A 1D tensor with shape [N] containing all nonzero values. Values corresponding to
each row of indices.
- **dense_shape** (tuple) - A 1D tuple with shape (N, M), specifying the shape of the tensor. An int tuple
which specifies the shape of dense tensor. The dense_shape is : math:`(N, C)`. If `adjoint_st` is True,
its shape must be :math:`(N, C)` after transpose.
- **dense** (Tensor) - Dense Matrix. The shape of the tensor is :math:`(C, M)`. If
`adjoint_dt` is True, its shape must be :math:`(C, M)` after transpose.
- **indices** (Tensor) - A 2-D Tensor, represents the position of the element in the sparse tensor.
Support int32, int64, each element value should be non-negative. The shape is :math:`(n, 2)`.
- **values** (Tensor) - A 1-D Tensor, represents the value corresponding to the position in the `indices`.
Support float16, float32, float64, int32, int64. The shape should be :math:`(n,).
- **sparse_shape** (tuple) - A positive int tuple which specifies the shape of sparse tensor,
should have 2 elements, represent sparse tensor shape is :math:`(N, C)`.
- **dense** (Tensor) - A 2-D Tensor, the dtype is same as `values`.
If `adjoint_st` is False and `adjoint_dt` is False, the shape must be :math:`(C, M)`.
If `adjoint_st` is False and `adjoint_dt` is True, the shape must be :math:`(M, C)`.
If `adjoint_st` is True and `adjoint_dt` is False, the shape must be :math:`(N, M)`.
If `adjoint_st` is True and `adjoint_dt` is True, the shape must be :math:`(M, N)`.
Returns:
Tensor, the shape of tensor is :math:`(N, M)`.The output data type is the same as "values".
Outputs:
Tensor, the dtype is the same as `values`.
If `adjoint_st` is False, the shape is :math:`(N, M)`.
If `adjoint_st` is True, the shape is :math:`(C, M)`.
Raises:
TypeError: If the type of `adjoint_st` or `adjoint_dt` is not bool, or the dtype of `indices`,
dtype of `values` and dtype of `dense` don't meet the parameter description.
ValueError: If `sparse_shape`, shape of `indices, shape of `values`,
and shape of `dense` don't meet the parameter description.
Supported Platforms:
``CPU``
Examples:
>>> class NetSparseDenseMatmul(nn.Cell):
... def __init__(self):
... super(NetSparseDenseMatmul, self).__init__()
... self.matmul = nn.SparseTensorDenseMatmul()
...
... def construct(self, indices, values, dens_shape, dt):
... return self.matmul(indices, values, dens_shape, dt)
...
>>> import mindspore as ms
>>> from mindspore import Tensor
>>> from mindspore import nn
>>> indices = Tensor([[0, 1], [1, 2]], dtype=ms.int32)
>>> values = Tensor([1, 2], dtype=ms.float32)
>>> dense_shape = (3, 4)
>>> dsMatrix = Tensor([[1, 1], [2, 2], [3, 3], [4, 4]], dtype=ms.float32)
>>> test_SparseDenseMatmul = NetSparseDenseMatmul()
>>> out = test_SparseDenseMatmul(indices, values, dense_shape, dsMatrix)
>>> sparse_shape = (3, 4)
>>> dense = Tensor([[1, 1], [2, 2], [3, 3], [4, 4]], dtype=ms.float32)
>>> sparse_dense_matmul = nn.SparseTensorDenseMatmul()
>>> out = sparse_dense_matmul(indices, values, sparse_shape, dense)
>>> print(out)
[[2 2]
[0 6]
[6 0]]
"""
def __init__(self, adjoint_st=False, adjoint_dt=False):
"""Initialize SparseTensorDenseMatmul"""
super(SparseTensorDenseMatmul, self).__init__()
self.adjst = adjoint_st
self.adjdt = adjoint_dt
self.matmul = P.SparseTensorDenseMatmul(adjoint_st=self.adjst, adjoint_dt=self.adjdt)
self.adj_st = adjoint_st
self.adj_dt = adjoint_dt
self.sparse_dense_matmul = P.SparseTensorDenseMatmul(adjoint_st=self.adj_st, adjoint_dt=self.adj_dt)
def construct(self, indices, values, dense_shape, dense):
return self.matmul(indices, values, dense_shape, dense)
def construct(self, indices, values, sparse_shape, dense):
return self.sparse_dense_matmul(indices, values, sparse_shape, dense)

2
mindspore/ops/_grad/grad_sparse.py
View File

@ -54,7 +54,7 @@ def get_bprop_sparse_to_dense(self):
"""Generate bprop for SparseToDense"""
def bprop(indices, values, dense_shape, out, dout):
return zeros_like(indices), dout, zeros_like(dense_shape)
return zeros_like(indices), F.gather_nd(dout, indices), zeros_like(dense_shape)
return bprop

15
mindspore/ops/_op_impl/cpu/gather_nd.py
View File

@ -20,10 +20,17 @@ gather_nd_op_info = CpuRegOp("GatherNd") \
.input(0, "x1", "required") \
.input(1, "x2", "required") \
.output(0, "y", "required") \
.dtype_format(DataType.I32_Default, DataType.I32_Default, DataType.I32_Default) \
.dtype_format(DataType.I64_Default, DataType.I32_Default, DataType.I64_Default) \
.dtype_format(DataType.F32_Default, DataType.I32_Default, DataType.F32_Default) \
.dtype_format(DataType.F64_Default, DataType.I32_Default, DataType.F64_Default) \
.dtype_format(DataType.BOOL_Default, DataType.I32_Default, DataType.BOOL_Default) \
.dtype_format(DataType.I8_Default, DataType.I32_Default, DataType.I8_Default) \
.dtype_format(DataType.I16_Default, DataType.I32_Default, DataType.I16_Default) \
.dtype_format(DataType.I32_Default, DataType.I32_Default, DataType.I32_Default) \
.dtype_format(DataType.I64_Default, DataType.I32_Default, DataType.I64_Default) \
.dtype_format(DataType.U8_Default, DataType.I32_Default, DataType.U8_Default) \
.dtype_format(DataType.U16_Default, DataType.I32_Default, DataType.U16_Default) \
.dtype_format(DataType.U32_Default, DataType.I32_Default, DataType.U32_Default) \
.dtype_format(DataType.U64_Default, DataType.I32_Default, DataType.U64_Default) \
.dtype_format(DataType.F32_Default, DataType.I32_Default, DataType.F32_Default) \
.dtype_format(DataType.F64_Default, DataType.I32_Default, DataType.F64_Default) \
.get_op_info()

20
mindspore/ops/_op_impl/cpu/gather_v2.py
View File

@ -20,16 +20,16 @@ gather_v2_op_info = CpuRegOp("Gather") \
.input(0, "x", "required") \
.input(1, "indices", "required") \
.output(0, "y", "required") \
.dtype_format(DataType.U8_Default, DataType.I32_Default, DataType.U8_Default) \
.dtype_format(DataType.U16_Default, DataType.I32_Default, DataType.U16_Default) \
.dtype_format(DataType.U32_Default, DataType.I32_Default, DataType.U32_Default) \
.dtype_format(DataType.U64_Default, DataType.I32_Default, DataType.U64_Default) \
.dtype_format(DataType.I8_Default, DataType.I32_Default, DataType.I8_Default) \
.dtype_format(DataType.I16_Default, DataType.I32_Default, DataType.I16_Default) \
.dtype_format(DataType.I32_Default, DataType.I32_Default, DataType.I32_Default) \
.dtype_format(DataType.I64_Default, DataType.I32_Default, DataType.I64_Default) \
.dtype_format(DataType.F32_Default, DataType.I32_Default, DataType.F32_Default) \
.dtype_format(DataType.F64_Default, DataType.I32_Default, DataType.F64_Default) \
.dtype_format(DataType.U8_Default, DataType.I32_Default, DataType.U8_Default) \
.dtype_format(DataType.U16_Default, DataType.I32_Default, DataType.U16_Default) \
.dtype_format(DataType.U32_Default, DataType.I32_Default, DataType.U32_Default) \
.dtype_format(DataType.U64_Default, DataType.I32_Default, DataType.U64_Default) \
.dtype_format(DataType.I8_Default, DataType.I32_Default, DataType.I8_Default) \
.dtype_format(DataType.I16_Default, DataType.I32_Default, DataType.I16_Default) \
.dtype_format(DataType.I32_Default, DataType.I32_Default, DataType.I32_Default) \
.dtype_format(DataType.I64_Default, DataType.I32_Default, DataType.I64_Default) \
.dtype_format(DataType.F32_Default, DataType.I32_Default, DataType.F32_Default) \
.dtype_format(DataType.F64_Default, DataType.I32_Default, DataType.F64_Default) \
.dtype_format(DataType.BOOL_Default, DataType.I32_Default, DataType.BOOL_Default) \
.get_op_info()

131
mindspore/ops/operations/sparse_ops.py
View File

@ -28,12 +28,19 @@ class SparseToDense(PrimitiveWithInfer):
Converts a sparse representation into a dense tensor.
Inputs:
- **indices** (Tensor) - The indices of sparse representation.
- **values** (Tensor) - Values corresponding to each row of indices.
- **dense_shape** (tuple) - An int tuple which specifies the shape of dense tensor.
- **indices** (Tensor) - A 2-D Tensor, represents the position of the element in the sparse tensor.
Support int32, int64, each element value should be a non-negative int number. The shape is :math:`(n, 2)`.
- **values** (Tensor) - A 1-D Tensor, represents the value corresponding to the position in the `indices`.
The shape should be :math:`(n,).
- **sparse_shape** (tuple(int)) - A positive int tuple which specifies the shape of sparse tensor,
should have 2 elements, represent sparse tensor shape is :math:`(N, C)`.
Returns:
Tensor, the shape of tensor is `dense_shape`.
Tensor, converted from sparse tensor. The dtype is same as `values`, and the shape is `sparse_shape`.
Raises:
TypeError: If the dtype of `indices` is neither int32 nor int64.
ValueError: If `sparse_shape`, shape of `indices and shape of `values` don't meet the parameter description.
Supported Platforms:
``CPU``
@ -41,8 +48,13 @@ class SparseToDense(PrimitiveWithInfer):
Examples:
>>> indices = Tensor([[0, 1], [1, 2]])
>>> values = Tensor([1, 2], dtype=ms.float32)
>>> dense_shape = (3, 4)
>>> out = ops.SparseToDense()(indices, values, dense_shape)
>>> sparse_shape = (3, 4)
>>> sparse_to_dense = ops.SparseToDense()
>>> out = sparse_to_dense(indices, values, sparse_shape)
>>> print(out)
[[0 1 0 0]
[0 0 2 0]
[0 0 0 0]]
"""
@prim_attr_register
@ -50,10 +62,28 @@ class SparseToDense(PrimitiveWithInfer):
"""Initialize index_select"""
self.init_prim_io_names(inputs=['indices', 'values', 'dense_shape'], outputs=['output'])
def __infer__(self, indices, values, dense_shape):
validator.check_subclass("indices", indices['dtype'], mstype.tensor, self.name)
validator.check_subclass("values", values['dtype'], mstype.tensor, self.name)
out = {'shape': dense_shape['value'],
def __infer__(self, indices, values, sparse_shape):
validator.check_tensor_dtype_valid('indices', indices['dtype'], [mstype.int32, mstype.int64], self.name)
validator.check_tensor_dtype_valid('values', values['dtype'], mstype.number_type + (mstype.bool_,), self.name)
indices_shape = indices['shape']
if len(indices_shape) != 2:
raise ValueError("SparseToDense requires 'indices' must be a 2-D Tensor, "
f"but got 'indices' shape: {indices_shape}")
values_shape = values['shape']
if len(values_shape) != 1 or values_shape[0] != indices_shape[0]:
raise ValueError("SparseToDense requires 'values' must be a 1-D Tensor and "
"the first dimension length must be equal to the first dimension length of 'indices', "
f"but got 'indices' shape: {indices_shape}, 'values' shape: {values_shape}")
sparse_shape_v = sparse_shape['value']
for i in sparse_shape_v:
if isinstance(i, bool) or not isinstance(i, int) or i <= 0:
raise ValueError("SparseToDense requires all elements in 'sparse_shape' must be "
f"positive int number, but got 'sparse_shape': {sparse_shape_v}")
if len(sparse_shape_v) != indices_shape[1]:
raise ValueError("SparseToDense requires the 'sparse_shape' length should be equal to the 'indices' "
"second dimension length, but got the 'indices' second dimension length: "
f"{indices_shape[1]}, 'sparse_shape' length: {len(sparse_shape_v)}")
out = {'shape': sparse_shape['value'],
'dtype': values['dtype'],
'value': None}
return out
@ -61,31 +91,36 @@ class SparseToDense(PrimitiveWithInfer):
class SparseTensorDenseMatmul(PrimitiveWithInfer):
"""
Multiply SparseTensor(of rank 2) "A" by dense tensor.
The shape of sparse tensor is :math:`(N, C)`, and the shape of dense tensor is :math:`(C, M)`, then the shape of
output tensor is :math:`(N, M)`.The output data type is the same as "values".
tensors.
Multiplies sparse matrix `A` by dense matrix `B`.
The rank of sparse matrix and dense matrix must equal to `2`.
Args:
- *adjoint_st** (Bool) - If true, SparseTensor is transposed before multiplication. Default: False.
- *adjoint_dt** (Bool) - If true, DenseTensor is transposed before multiplication. Default: False.
- *adjoint_st** (bool) - If true, sparse tensor is transposed before multiplication. Default: False.
- *adjoint_dt** (bool) - If true, dense tensor is transposed before multiplication. Default: False.
Inputs:
- **indices** (Tensor) - The indices of sparse representation, support int32/int64.
- **values** (Tensor) - Values corresponding to each row of indices.
- **dense_shape** (tuple) - An int tuple which specifies the shape of dense tensor. The dense_shape is :
math:`(N, C)`. If `adjoint_st` is True, its shape must be :math:`(N, C)` after transpose.
- **dense** (Tensor) - Dense Matrix. The shape of the tensor is :math:`(C, M)`. If
`adjoint_dt` is True, its shape must be :math:`(C, M)` after transpose.
- **indices** (Tensor) - A 2-D Tensor, represents the position of the element in the sparse tensor.
Support int32, int64, each element value should be a non-negative int number. The shape is :math:`(n, 2)`.
- **values** (Tensor) - A 1-D Tensor, represents the value corresponding to the position in the `indices`.
Support float16, float32, float64, int32, int64. The shape should be :math:`(n,).
- **sparse_shape** (tuple(int)) - A positive int tuple which specifies the shape of sparse tensor,
should have 2 elements, represent sparse tensor shape is :math:`(N, C)`.
- **dense** (Tensor) - A 2-D Tensor, the dtype is same as `values`.
If `adjoint_st` is False and `adjoint_dt` is False, the shape must be :math:`(C, M)`.
If `adjoint_st` is False and `adjoint_dt` is True, the shape must be :math:`(M, C)`.
If `adjoint_st` is True and `adjoint_dt` is False, the shape must be :math:`(N, M)`.
If `adjoint_st` is True and `adjoint_dt` is True, the shape must be :math:`(M, N)`.
Outputs:
Tensor, the shape of tensor is :math:`(N, M)`. The output data type is the same as "values".
Tensor, the dtype is the same as `values`.
If `adjoint_st` is False, the shape is :math:`(N, M)`.
If `adjoint_st` is True, the shape is :math:`(C, M)`.
Raises:
TypeError: If `indices` is neither int32 nor int64.
TypeError: If 'values' is not boot, uint8-64, int8-64, float16-64.
TypeError: If 'dense' is not boot, uint8-64, int8-64, float16-64.
ValueError: If length of shape of `SparseTensor` or `DenseTensor` is not equal to 2
TypeError: If the type of `adjoint_st` or `adjoint_dt` is not bool, or the dtype of `indices`,
dtype of `values` and dtype of `dense` don't meet the parameter description.
ValueError: If `sparse_shape`, shape of `indices, shape of `values`,
and shape of `dense` don't meet the parameter description.
Supported Platforms:
``CPU``
@ -93,9 +128,14 @@ class SparseTensorDenseMatmul(PrimitiveWithInfer):
Examples:
>>> indices = Tensor([[0, 1], [1, 2]], dtype=ms.int32)
>>> values = Tensor([1, 2], dtype=ms.float32)
>>> dense_shape = (3, 4)
>>> dsMatrix = Tensor([[1,1], [2,2], [3,3 ], [4, 4]], dtype=ms.float32)
>>> out = ops.SparseTensorDenseMatmul(indices, values, dense_shape, dsMatrix)
>>> sparse_shape = (3, 4)
>>> dense = Tensor([[1,1], [2,2], [3,3 ], [4, 4]], dtype=ms.float32)
>>> sparse_dense_matmul = ops.SparseTensorDenseMatmul()
>>> out = sparse_dense_matmul(indices, values, sparse_shape, dense)
>>> print(out)
[[2 2]
[0 6]
[6 0]]
"""
@prim_attr_register
@ -103,27 +143,40 @@ class SparseTensorDenseMatmul(PrimitiveWithInfer):
"""Initialize SparseTensorDenseMatmul"""
self.adjoint_st = adjoint_st
self.adjoint_dt = adjoint_dt
self.init_prim_io_names(inputs=['indices', 'values', 'dense_shape', 'dense'],
self.init_prim_io_names(inputs=['indices', 'values', 'sparse_shape', 'dense'],
outputs=['output'])
self.add_prim_attr('adjoint_st', self.adjoint_st)
self.add_prim_attr('adjoint_dt', self.adjoint_dt)
validator.check_value_type("adjoint_st", adjoint_st, [bool], self.name)
validator.check_value_type("adjoint_dt", adjoint_dt, [bool], self.name)
def __infer__(self, indices, values, dense_shape, dense):
def __infer__(self, indices, values, sparse_shape, dense):
validator.check_tensor_dtype_valid('indices', indices['dtype'], [mstype.int32, mstype.int64], self.name)
valid_types = mstype.number_type + (mstype.bool_,)
valid_types = (mstype.float16, mstype.float32, mstype.float64, mstype.int32, mstype.int64)
args = {'values': values['dtype'], 'dense': dense['dtype']}
validator.check_tensors_dtypes_same_and_valid(args, valid_types, self.name)
a_shape = dense_shape['value'][::-1] if self.adjoint_st else dense_shape['value']
indices_shape = indices['shape']
if len(indices_shape) != 2 or indices_shape[1] != 2:
raise ValueError("SparseTensorDenseMatmul requires 'indices' must be a 2-D Tensor and "
f"the second dimension length must be 2, but got 'indices' shape: {indices_shape}")
values_shape = values['shape']
if len(values_shape) != 1 or values_shape[0] != indices_shape[0]:
raise ValueError("SparseTensorDenseMatmul requires 'value's must be a 1-D Tensor and "
f"the first dimension length must be equal to the first dimension length of 'indices', "
f"but got 'indices' shape: {indices_shape}, 'values' shape: {values_shape}")
a_shape = sparse_shape['value'][::-1] if self.adjoint_st else sparse_shape['value']
b_shape = dense['shape'][::-1] if self.adjoint_dt else dense['shape']
for i in a_shape:
if isinstance(i, bool) or not isinstance(i, int) or i <= 0:
raise ValueError("SparseTensorDenseMatmul requires all elements in 'sparse_shape' must be "
f"positive int number, but got sparse shape: {a_shape}")
if len(a_shape) != 2 or len(b_shape) != 2:
raise ValueError('SparseTensorDenseMatmul requires SparseTensor and DenseTensor have the same dimension'
+ f'and equal to 2, while SparseTensor dim is ({len(a_shape)}) and DenseTensor dim is '
+ f'({len(b_shape)}).')
raise ValueError("SparseTensorDenseMatmul requires both the 'sparse_shape' length and the dense tensor "
f"rank should be equal to 2, but got 'sparse_shape' length: {len(a_shape)}, "
f"dense tensor rank: {len(b_shape)}")
if a_shape[1] != b_shape[0]:
raise ValueError('SparseTensorDenseMatmul requires SparseTensor dim_1 should be equal to DenseTensor dim_0,'
f'but got SparseTensor dim_1: {a_shape[1]}, DenseTensor dim_0: {b_shape[0]}')
raise ValueError(f"The sparse tensor shape: {a_shape} and the dense tensor shape: {b_shape} "
f"don't meet the condition for matmul")
out_shape = [a_shape[0], b_shape[1]]
out = {'shape': tuple(out_shape),
'dtype': values['dtype'],

10
tests/st/ops/cpu/test_sparse_tensor_dense_matmul_op.py
View File

@ -54,10 +54,10 @@ def judge_result_correct(result, expect):
@pytest.mark.env_onecard
def test_sparse_tensor_dense_matmul_no_transpose():
indices_np = np.array([[0, 0], [1, 1], [2, 2], [2, 3]], np.int64)
values_np = np.array([2, 3, 4, 5], np.float32)
values_np = np.array([2, 3, 4, 5], np.float16)
dense_shape = (3, 4)
sparse_np = np.array([[2, 0, 0, 0], [0, 3, 0, 0], [0, 0, 4, 5]], dtype=np.float32)
dense_np = np.array([[0, 1, 2], [3, 4, 5], [6, 7, 8], [9, 10, 11]], dtype=np.float32)
sparse_np = np.array([[2, 0, 0, 0], [0, 3, 0, 0], [0, 0, 4, 5]], dtype=np.float16)
dense_np = np.array([[0, 1, 2], [3, 4, 5], [6, 7, 8], [9, 10, 11]], dtype=np.float16)
sparse_dense_matmul_net = SparseDenseMatmulNet()
indices = Tensor(indices_np)
@ -69,12 +69,12 @@ def test_sparse_tensor_dense_matmul_no_transpose():
grad_net = GradNet(sparse_dense_matmul_net)
grad_ms = grad_net(indices, values, dense_shape, dense)
expect_values_grad = np.array([3., 12., 21., 30.], dtype=np.float32)
expect_values_grad = np.array([3., 12., 21., 30.], dtype=np.float16)
judge_result_correct(grad_ms[1].asnumpy(), expect_values_grad)
expect_dense_grad = np.array([[2., 2., 2.],
[3., 3., 3.],
[4., 4., 4.],
[5., 5., 5.]], dtype=np.float32)
[5., 5., 5.]], dtype=np.float16)
judge_result_correct(grad_ms[2].asnumpy(), expect_dense_grad)

265
tests/st/ops/cpu/test_sparse_to_dense_op.py
View File

@ -17,182 +17,129 @@ import numpy as np
import pytest
import mindspore.context as context
from mindspore import Tensor
from mindspore.nn import Cell
from mindspore import nn
from mindspore.ops import operations as P
from mindspore.ops import composite as C
context.set_context(mode=context.GRAPH_MODE, enable_graph_kernel=True, device_target="CPU")
context.set_context(mode=context.GRAPH_MODE, device_target="CPU")
class SparseToDenseNet(Cell):
class SparseToDenseNet(nn.Cell):
def __init__(self):
super(SparseToDenseNet, self).__init__()
self.sparse_to_dense = P.SparseToDense()
def construct(self, indices, values, dense_shape):
return self.sparse_to_dense(indices, values, dense_shape)
def construct(self, indices, values, sparse_shape):
return self.sparse_to_dense(indices, values, sparse_shape)
class GradNet(nn.Cell):
def __init__(self, network):
super(GradNet, self).__init__()
self.grad = C.GradOperation(get_all=True, sens_param=True)
self.network = network
def construct(self, indices, values, sparse_shape, sense):
return self.grad(self.network)(indices, values, sparse_shape, sense)
def judge_result_correct(result, expect):
assert result.dtype == expect.dtype
assert result.shape == expect.shape
assert np.allclose(result, expect)
def sparse_to_dense_int(i_type, v_type):
indices = np.array([[0, 1], [1, 2]]).astype(i_type)
values = np.array([7, 8]).astype(v_type)
sparse_shape = (3, 3)
forward_net = SparseToDenseNet()
forward_output = forward_net(Tensor(indices), Tensor(values), sparse_shape)
expect_forward_output = np.array([[0, 7, 0],
[0, 0, 8],
[0, 0, 0]]).astype(v_type)
judge_result_correct(forward_output.asnumpy(), expect_forward_output)
grad_net = GradNet(forward_net)
sense = Tensor(np.arange(9).reshape((3, 3)).astype(v_type))
grad_output = grad_net(Tensor(indices), Tensor(values), sparse_shape, sense)
expect_grad_output = np.array([1, 5]).astype(v_type)
judge_result_correct(grad_output[1].asnumpy(), expect_grad_output)
def sparse_to_dense_float(i_type, v_type):
indices = np.array([[0, 1, 0], [1, 2, 1], [2, 3, 2], [0, 2, 3]]).astype(i_type)
values = np.array([6.5, 7.5, 9.5, 10.5]).astype(v_type)
sparse_shape = (3, 4, 4)
forward_net = SparseToDenseNet()
forward_output = forward_net(Tensor(indices), Tensor(values), sparse_shape)
expect_forward_output = np.array([[[0, 0, 0, 0],
[6.5, 0, 0, 0],
[0, 0, 0, 10.5],
[0, 0, 0, 0]],
[[0, 0, 0, 0],
[0, 0, 0, 0],
[0, 7.5, 0, 0],
[0, 0, 0, 0]],
[[0, 0, 0, 0],
[0, 0, 0, 0],
[0, 0, 0, 0],
[0, 0, 9.5, 0]]]).astype(v_type)
judge_result_correct(forward_output.asnumpy(), expect_forward_output)
grad_net = GradNet(forward_net)
sense = Tensor(np.arange(48).reshape((3, 4, 4)).astype(v_type) + 0.8)
grad_output = grad_net(Tensor(indices), Tensor(values), sparse_shape, sense)
expect_grad_output = np.array([4.8, 25.8, 46.8, 11.8]).astype(v_type)
judge_result_correct(grad_output[1].asnumpy(), expect_grad_output)
def sparse_to_dense_1D(i_type, v_type):
indices = np.array([[8], [2], [6], [4]]).astype(i_type)
values = np.array([6.5, 7.5, 9.5, 10.5]).astype(v_type)
sparse_shape = (10,)
forward_net = SparseToDenseNet()
forward_output = forward_net(Tensor(indices), Tensor(values), sparse_shape)
expect_forward_output = np.array([0, 0, 7.5, 0, 10.5, 0, 9.5, 0, 6.5, 0]).astype(v_type)
judge_result_correct(forward_output.asnumpy(), expect_forward_output)
grad_net = GradNet(forward_net)
sense = Tensor(np.arange(10).astype(v_type) + 0.8)
grad_output = grad_net(Tensor(indices), Tensor(values), sparse_shape, sense)
expect_grad_output = np.array([8.8, 2.8, 6.8, 4.8]).astype(v_type)
judge_result_correct(grad_output[1].asnumpy(), expect_grad_output)
indices_types = (np.int32, np.int64)
@pytest.mark.level0
@pytest.mark.platform_x86_cpu_training
@pytest.mark.platform_x86_cpu
@pytest.mark.env_onecard
def test_sparse_to_dense_A():
np.random.seed(0)
indices = np.array([[0, 1], [1, 2]]).astype(np.int32)
values = np.array([7, 8]).astype(np.int32)
dense_shape = (3, 4)
net = SparseToDenseNet()
result = net(Tensor(indices), Tensor(values), dense_shape)
expect_output = np.array([[0, 7, 0, 0],
[0, 0, 8, 0],
[0, 0, 0, 0]]).astype(np.int32)
assert np.allclose(result.asnumpy(), expect_output, rtol=1.e-4, atol=1.e-8, equal_nan=True)
def test_sparse_to_dense_int():
values_types = (np.bool_,
np.uint8, np.uint16, np.uint32, np.uint64,
np.int8, np.int16, np.int32, np.int64)
for i_type in indices_types:
for v_type in values_types:
sparse_to_dense_int(i_type, v_type)
@pytest.mark.level0
@pytest.mark.platform_x86_cpu_training
@pytest.mark.platform_x86_cpu
@pytest.mark.env_onecard
def test_sparse_to_dense_B():
np.random.seed(0)
indices = np.array([[0, 1], [1, 2], [2, 3]]).astype(np.int32)
values = np.array([6.5, 7.5, 9.5]).astype(np.float64)
dense_shape = (3, 4)
net = SparseToDenseNet()
result = net(Tensor(indices), Tensor(values), dense_shape)
expect_output = np.array([[0, 6.5, 0, 0],
[0, 0, 7.5, 0],
[0, 0, 0, 9.5]]).astype(np.float64)
assert np.allclose(result.asnumpy(), expect_output, rtol=1.e-4, atol=1.e-8, equal_nan=True)
def test_sparse_to_dense_float():
values_types = (np.float16, np.float32, np.float64)
for i_type in indices_types:
for v_type in values_types:
sparse_to_dense_float(i_type, v_type)
@pytest.mark.level0
@pytest.mark.platform_x86_cpu_training
@pytest.mark.platform_x86_cpu
@pytest.mark.env_onecard
def test_sparse_to_dense_C():
np.random.seed(0)
indices = np.array([[0, 1, 0, 0],
[1, 0, 0, 2],
[2, 0, 3, 0],
[4, 2, 3, 5]]).astype(np.int32)
values = np.array([26.5, 17.5, 39.5, 11.5]).astype(np.float16)
dense_shape = (10, 8, 5, 10)
net = SparseToDenseNet()
result = net(Tensor(indices), Tensor(values), dense_shape)
expect_output = np.zeros([10, 8, 5, 10]).astype(np.float16)
for i in range(0, indices.shape[0]):
j = indices[i][0]
k = indices[i][1]
l = indices[i][2]
m = indices[i][3]
expect_output[j][k][l][m] = values[i]
assert np.allclose(result.asnumpy(), expect_output, rtol=1.e-4, atol=1.e-8, equal_nan=True)
@pytest.mark.level0
@pytest.mark.platform_x86_cpu_training
@pytest.mark.env_onecard
def test_sparse_to_dense_D():
np.random.seed(0)
indices = np.array([[0, 1, 0, 0, 2, 1],
[9, 0, 0, 8, 0, 0],
[2, 0, 4, 0, 1, 1],
[4, 2, 3, 5, 0, 2],
[7, 4, 3, 9, 0, 1]]).astype(np.int32)
values = np.array([1, 1, 1, 1, 1]).astype(np.bool)
dense_shape = (10, 5, 5, 10, 3, 3)
net = SparseToDenseNet()
result = net(Tensor(indices), Tensor(values), dense_shape)
expect_output = np.zeros([10, 5, 5, 10, 3, 3]).astype(np.bool)
for i in range(0, indices.shape[0]):
j = indices[i][0]
k = indices[i][1]
l = indices[i][2]
m = indices[i][3]
u = indices[i][4]
v = indices[i][5]
expect_output[j][k][l][m][u][v] = values[i]
assert np.allclose(result.asnumpy(), expect_output, rtol=1.e-4, atol=1.e-8, equal_nan=True)
@pytest.mark.level0
@pytest.mark.platform_x86_cpu_training
@pytest.mark.env_onecard
def test_sparse_to_dense_E():
indices = np.array([2, 5, 7]).astype(np.int32)
values = np.array([17, 18, 19]).astype(np.int8)
dense_shape = ([10])
expect_output = np.zeros([10]).astype(np.int8)
for i in range(0, indices.shape[0]):
j = indices[i]
expect_output[j] = values[i]
net = SparseToDenseNet()
result = net(Tensor(indices), Tensor(values), dense_shape)
assert np.allclose(result.asnumpy(), expect_output, rtol=1.e-4, atol=1.e-8, equal_nan=True)
@pytest.mark.level0
@pytest.mark.platform_x86_cpu_training
@pytest.mark.env_onecard
def test_sparse_to_dense_F():
indices = np.array([2, 4, 18]).astype(np.int32)
values = np.array([-23, 18, -1]).astype(np.int16)
dense_shape = ([20])
expect_output = np.zeros([20]).astype(np.int16)
for i in range(0, indices.shape[0]):
j = indices[i]
expect_output[j] = values[i]
net = SparseToDenseNet()
result = net(Tensor(indices), Tensor(values), dense_shape)
assert np.allclose(result.asnumpy(), expect_output, rtol=1.e-4, atol=1.e-8, equal_nan=True)
@pytest.mark.level0
@pytest.mark.platform_x86_cpu_training
@pytest.mark.env_onecard
def test_sparse_to_dense_G():
indices = np.array([2, 5, 7]).astype(np.int32)
values = np.array([17, 18, 19]).astype(np.uint8)
dense_shape = ([10])
expect_output = np.zeros([10]).astype(np.uint8)
for i in range(0, indices.shape[0]):
j = indices[i]
expect_output[j] = values[i]
net = SparseToDenseNet()
result = net(Tensor(indices), Tensor(values), dense_shape)
assert np.allclose(result.asnumpy(), expect_output, rtol=1.e-4, atol=1.e-8, equal_nan=True)
@pytest.mark.level0
@pytest.mark.platform_x86_cpu_training
@pytest.mark.env_onecard
def test_sparse_to_dense_H():
indices = np.array([2, 5, 7]).astype(np.int32)
values = np.array([17, 18, 19]).astype(np.uint16)
dense_shape = ([10])
expect_output = np.zeros([10]).astype(np.uint16)
for i in range(0, indices.shape[0]):
j = indices[i]
expect_output[j] = values[i]
net = SparseToDenseNet()
result = net(Tensor(indices), Tensor(values), dense_shape)
assert np.allclose(result.asnumpy(), expect_output, rtol=1.e-4, atol=1.e-8, equal_nan=True)
@pytest.mark.level0
@pytest.mark.platform_x86_cpu_training
@pytest.mark.env_onecard
def test_sparse_to_dense_I():
indices = np.array([2, 5, 7]).astype(np.int64)
values = np.array([17, 18, 19]).astype(np.float16)
dense_shape = ([10])
expect_output = np.zeros([10]).astype(np.float16)
for i in range(0, indices.shape[0]):
j = indices[i]
expect_output[j] = values[i]
net = SparseToDenseNet()
result = net(Tensor(indices), Tensor(values), dense_shape)
assert np.allclose(result.asnumpy(), expect_output, rtol=1.e-4, atol=1.e-8, equal_nan=True)
def test_sparse_to_dense_1D():
values_types = (np.float16, np.float32, np.float64)
for i_type in indices_types:
for v_type in values_types:
sparse_to_dense_1D(i_type, v_type)