wehub-resource-sync
647 lines
24 KiB
Python
647 lines
24 KiB
Python
# Copyright (c) 2022 PaddlePaddle Authors. All Rights Reserved.
|
|
#
|
|
# 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 unittest
|
|
|
|
import numpy as np
|
|
from op_test import get_device, is_custom_device
|
|
|
|
import paddle
|
|
from paddle.base import core
|
|
from paddle.base.framework import in_pir_mode
|
|
|
|
devices = ['cpu', get_device()]
|
|
|
|
|
|
class TestSparseCreate(unittest.TestCase):
|
|
def test_create_coo_by_tensor(self):
|
|
indices = [[0, 0, 1, 2, 2], [1, 3, 2, 0, 1]]
|
|
values = [1, 2, 3, 4, 5]
|
|
dense_shape = [3, 4]
|
|
dense_indices = paddle.to_tensor(indices)
|
|
dense_elements = paddle.to_tensor(values, dtype='float32')
|
|
coo = paddle.sparse.sparse_coo_tensor(
|
|
dense_indices, dense_elements, dense_shape, stop_gradient=False
|
|
)
|
|
# test the to_string.py
|
|
np.testing.assert_array_equal(indices, coo.indices().numpy())
|
|
np.testing.assert_array_equal(values, coo.values().numpy())
|
|
|
|
def test_create_coo_by_np(self):
|
|
indices = [[0, 1, 2], [1, 2, 0]]
|
|
values = [1.0, 2.0, 3.0]
|
|
dense_shape = [3, 3]
|
|
coo = paddle.sparse.sparse_coo_tensor(indices, values, dense_shape)
|
|
np.testing.assert_array_equal(3, coo.nnz())
|
|
np.testing.assert_array_equal(indices, coo.indices().numpy())
|
|
np.testing.assert_array_equal(values, coo.values().numpy())
|
|
|
|
def test_create_csr_by_tensor(self):
|
|
crows = [0, 2, 3, 5]
|
|
cols = [1, 3, 2, 0, 1]
|
|
values = [1, 2, 3, 4, 5]
|
|
dense_shape = [3, 4]
|
|
dense_crows = paddle.to_tensor(crows)
|
|
dense_cols = paddle.to_tensor(cols)
|
|
dense_elements = paddle.to_tensor(values, dtype='float32')
|
|
stop_gradient = False
|
|
csr = paddle.sparse.sparse_csr_tensor(
|
|
dense_crows,
|
|
dense_cols,
|
|
dense_elements,
|
|
dense_shape,
|
|
stop_gradient=stop_gradient,
|
|
)
|
|
|
|
def test_create_csr_by_np(self):
|
|
crows = [0, 2, 3, 5]
|
|
cols = [1, 3, 2, 0, 1]
|
|
values = [1, 2, 3, 4, 5]
|
|
dense_shape = [3, 4]
|
|
csr = paddle.sparse.sparse_csr_tensor(crows, cols, values, dense_shape)
|
|
# test the to_string.py
|
|
np.testing.assert_array_equal(5, csr.nnz())
|
|
np.testing.assert_array_equal(crows, csr.crows().numpy())
|
|
np.testing.assert_array_equal(cols, csr.cols().numpy())
|
|
np.testing.assert_array_equal(values, csr.values().numpy())
|
|
|
|
def test_place(self):
|
|
place = core.CPUPlace()
|
|
indices = [[0, 1], [0, 1]]
|
|
values = [1.0, 2.0]
|
|
dense_shape = [2, 2]
|
|
coo = paddle.sparse.sparse_coo_tensor(
|
|
indices, values, dense_shape, place=place
|
|
)
|
|
assert coo.place.is_cpu_place()
|
|
assert coo.values().place.is_cpu_place()
|
|
assert coo.indices().place.is_cpu_place()
|
|
|
|
crows = [0, 2, 3, 5]
|
|
cols = [1, 3, 2, 0, 1]
|
|
values = [1.0, 2.0, 3.0, 4.0, 5.0]
|
|
csr = paddle.sparse.sparse_csr_tensor(
|
|
crows, cols, values, [3, 5], place=place
|
|
)
|
|
assert csr.place.is_cpu_place()
|
|
assert csr.crows().place.is_cpu_place()
|
|
assert csr.cols().place.is_cpu_place()
|
|
assert csr.values().place.is_cpu_place()
|
|
|
|
def test_dtype(self):
|
|
indices = [[0, 1], [0, 1]]
|
|
values = [1.0, 2.0]
|
|
dense_shape = [2, 2]
|
|
indices = paddle.to_tensor(indices, dtype='int32')
|
|
values = paddle.to_tensor(values, dtype='float32')
|
|
coo = paddle.sparse.sparse_coo_tensor(
|
|
indices, values, dense_shape, dtype='float64'
|
|
)
|
|
assert coo.dtype == paddle.float64
|
|
|
|
crows = [0, 2, 3, 5]
|
|
cols = [1, 3, 2, 0, 1]
|
|
values = [1.0, 2.0, 3.0, 4.0, 5.0]
|
|
csr = paddle.sparse.sparse_csr_tensor(
|
|
crows, cols, values, [3, 5], dtype='float16'
|
|
)
|
|
assert csr.dtype == paddle.float16
|
|
|
|
def test_create_coo_no_shape(self):
|
|
indices = [[0, 1], [0, 1]]
|
|
values = [1.0, 2.0]
|
|
indices = paddle.to_tensor(indices, dtype='int32')
|
|
values = paddle.to_tensor(values, dtype='float32')
|
|
coo = paddle.sparse.sparse_coo_tensor(indices, values)
|
|
assert [2, 2] == coo.shape
|
|
|
|
def test_create_csr_no_shape(self):
|
|
# 2D sparse tensor
|
|
crows = [0, 2, 3, 5]
|
|
cols = [1, 3, 2, 0, 1]
|
|
values = [1.0, 2.0, 3.0, 4.0, 5.0]
|
|
crows = paddle.to_tensor(crows, dtype='int32')
|
|
cols = paddle.to_tensor(cols, dtype='int32')
|
|
values = paddle.to_tensor(values, dtype='float32')
|
|
csr = paddle.sparse.sparse_csr_tensor(crows, cols, values)
|
|
assert [3, 4] == csr.shape
|
|
|
|
# 3D sparse tensor
|
|
crows = [0, 2, 2, 0, 1, 1, 0, 0, 0]
|
|
cols = [0, 1, 1]
|
|
values = [1, 2, 5]
|
|
crows = paddle.to_tensor(crows, dtype='int32')
|
|
cols = paddle.to_tensor(cols, dtype='int32')
|
|
values = paddle.to_tensor(values, dtype='float32')
|
|
csr = paddle.sparse.sparse_csr_tensor(crows, cols, values)
|
|
assert [3, 2, 2] == csr.shape
|
|
|
|
# 3D sparse tensor
|
|
crows = [0, 1, 2, 0, 1, 1, 0, 1, 2]
|
|
cols = [0, 2, 1, 0, 1]
|
|
values = [1, 2, 3, 4, 5]
|
|
crows = paddle.to_tensor(crows, dtype='int32')
|
|
cols = paddle.to_tensor(cols, dtype='int32')
|
|
values = paddle.to_tensor(values, dtype='float32')
|
|
csr = paddle.sparse.sparse_csr_tensor(crows, cols, values)
|
|
assert [3, 2, 3] == csr.shape
|
|
|
|
|
|
class TestSparseConvert(unittest.TestCase):
|
|
def test_to_sparse_coo(self):
|
|
x = [[0, 1, 0, 2], [0, 0, 3, 0], [4, 5, 0, 0]]
|
|
indices = [[0, 0, 1, 2, 2], [1, 3, 2, 0, 1]]
|
|
values = [1.0, 2.0, 3.0, 4.0, 5.0]
|
|
dense_x = paddle.to_tensor(x, dtype='float32', stop_gradient=False)
|
|
out = dense_x.to_sparse_coo(2)
|
|
np.testing.assert_array_equal(out.indices().numpy(), indices)
|
|
np.testing.assert_array_equal(out.values().numpy(), values)
|
|
# test to_sparse_coo_grad backward
|
|
out_grad_indices = [[0, 1], [0, 1]]
|
|
out_grad_values = [2.0, 3.0]
|
|
out_grad = paddle.sparse.sparse_coo_tensor(
|
|
paddle.to_tensor(out_grad_indices),
|
|
paddle.to_tensor(out_grad_values),
|
|
shape=out.shape,
|
|
stop_gradient=True,
|
|
)
|
|
out.backward(out_grad)
|
|
np.testing.assert_array_equal(
|
|
dense_x.grad.numpy(), out_grad.to_dense().numpy()
|
|
)
|
|
|
|
def test_coo_to_coo(self):
|
|
indices = [[0, 0, 1, 2, 2], [1, 3, 2, 0, 1]]
|
|
values = [1.0, 2.0, 3.0, 4.0, 5.0]
|
|
sparse_x = paddle.sparse.sparse_coo_tensor(
|
|
paddle.to_tensor(indices),
|
|
paddle.to_tensor(values),
|
|
shape=[3, 4],
|
|
stop_gradient=False,
|
|
)
|
|
sparse_x_ = sparse_x.to_sparse_coo(2)
|
|
assert sparse_x is sparse_x_
|
|
|
|
def test_csr_to_csr(self):
|
|
crows = [0, 2, 3, 5]
|
|
cols = [1, 3, 2, 0, 1]
|
|
values = [1.0, 2.0, 3.0, 4.0, 5.0]
|
|
crows = paddle.to_tensor(crows, dtype='int32')
|
|
cols = paddle.to_tensor(cols, dtype='int32')
|
|
values = paddle.to_tensor(values, dtype='float32')
|
|
sparse_x = paddle.sparse.sparse_csr_tensor(crows, cols, values)
|
|
sparse_x_ = sparse_x.to_sparse_csr()
|
|
assert sparse_x is sparse_x_
|
|
|
|
def test_coo_to_dense(self):
|
|
indices = [[0, 0, 1, 2, 2], [1, 3, 2, 0, 1]]
|
|
values = [1.0, 2.0, 3.0, 4.0, 5.0]
|
|
indices_dtypes = ['int32', 'int64']
|
|
for indices_dtype in indices_dtypes:
|
|
sparse_x = paddle.sparse.sparse_coo_tensor(
|
|
paddle.to_tensor(indices, dtype=indices_dtype),
|
|
paddle.to_tensor(values),
|
|
shape=[3, 4],
|
|
stop_gradient=False,
|
|
)
|
|
sparse_x.retain_grads()
|
|
dense_tensor = sparse_x.to_dense()
|
|
# test to_dense_grad backward
|
|
out_grad = [
|
|
[1.0, 2.0, 3.0, 4.0],
|
|
[5.0, 6.0, 7.0, 8.0],
|
|
[9.0, 10.0, 11.0, 12.0],
|
|
]
|
|
dense_tensor.backward(paddle.to_tensor(out_grad))
|
|
# mask the out_grad by sparse_x.indices()
|
|
correct_x_grad = [2.0, 4.0, 7.0, 9.0, 10.0]
|
|
np.testing.assert_array_equal(
|
|
correct_x_grad, sparse_x.grad.values().numpy()
|
|
)
|
|
|
|
paddle.device.set_device("cpu")
|
|
sparse_x_cpu = paddle.sparse.sparse_coo_tensor(
|
|
paddle.to_tensor(indices, dtype=indices_dtype),
|
|
paddle.to_tensor(values),
|
|
shape=[3, 4],
|
|
stop_gradient=False,
|
|
)
|
|
sparse_x_cpu.retain_grads()
|
|
dense_tensor_cpu = sparse_x_cpu.to_dense()
|
|
dense_tensor_cpu.backward(paddle.to_tensor(out_grad))
|
|
np.testing.assert_array_equal(
|
|
correct_x_grad, sparse_x_cpu.grad.values().numpy()
|
|
)
|
|
|
|
def test_to_sparse_csr(self):
|
|
x = [[0, 1, 0, 2], [0, 0, 3, 0], [4, 5, 0, 0]]
|
|
crows = [0, 2, 3, 5]
|
|
cols = [1, 3, 2, 0, 1]
|
|
values = [1, 2, 3, 4, 5]
|
|
dense_x = paddle.to_tensor(x)
|
|
out = dense_x.to_sparse_csr()
|
|
np.testing.assert_array_equal(out.crows().numpy(), crows)
|
|
np.testing.assert_array_equal(out.cols().numpy(), cols)
|
|
np.testing.assert_array_equal(out.values().numpy(), values)
|
|
|
|
dense_tensor = out.to_dense()
|
|
np.testing.assert_array_equal(dense_tensor.numpy(), x)
|
|
|
|
def test_coo_values_grad(self):
|
|
indices = [[0, 0, 1, 2, 2], [1, 3, 2, 0, 1]]
|
|
values = [1.0, 2.0, 3.0, 4.0, 5.0]
|
|
sparse_x = paddle.sparse.sparse_coo_tensor(
|
|
paddle.to_tensor(indices),
|
|
paddle.to_tensor(values),
|
|
shape=[3, 4],
|
|
stop_gradient=False,
|
|
)
|
|
sparse_x.retain_grads()
|
|
values_tensor = sparse_x.values()
|
|
out_grad = [2.0, 3.0, 5.0, 8.0, 9.0]
|
|
# test coo_values_grad
|
|
values_tensor.backward(paddle.to_tensor(out_grad))
|
|
np.testing.assert_array_equal(out_grad, sparse_x.grad.values().numpy())
|
|
indices = [[0, 0, 1, 2, 2], [1, 3, 2, 0, 1]]
|
|
values = [
|
|
[1.0, 1.0],
|
|
[2.0, 2.0],
|
|
[3.0, 3.0],
|
|
[4.0, 4.0],
|
|
[5.0, 5.0],
|
|
]
|
|
sparse_x = paddle.sparse.sparse_coo_tensor(
|
|
paddle.to_tensor(indices),
|
|
paddle.to_tensor(values),
|
|
shape=[3, 4, 2],
|
|
stop_gradient=False,
|
|
)
|
|
sparse_x.retain_grads()
|
|
values_tensor = sparse_x.values()
|
|
out_grad = [
|
|
[2.0, 2.0],
|
|
[3.0, 3.0],
|
|
[5.0, 5.0],
|
|
[8.0, 8.0],
|
|
[9.0, 9.0],
|
|
]
|
|
# test coo_values_grad
|
|
values_tensor.backward(paddle.to_tensor(out_grad))
|
|
np.testing.assert_array_equal(out_grad, sparse_x.grad.values().numpy())
|
|
|
|
def test_sparse_coo_tensor_grad(self):
|
|
for device in devices:
|
|
if device == 'cpu' or (
|
|
device == get_device()
|
|
and (paddle.is_compiled_with_cuda() or is_custom_device())
|
|
):
|
|
paddle.device.set_device(device)
|
|
indices = [[0, 1], [0, 1]]
|
|
values = [1, 2]
|
|
indices = paddle.to_tensor(indices, dtype='int32')
|
|
values = paddle.to_tensor(
|
|
values, dtype='float32', stop_gradient=False
|
|
)
|
|
sparse_x = paddle.sparse.sparse_coo_tensor(
|
|
indices, values, shape=[2, 2], stop_gradient=False
|
|
)
|
|
grad_indices = [[0, 1], [1, 1]]
|
|
grad_values = [2, 3]
|
|
grad_indices = paddle.to_tensor(grad_indices, dtype='int32')
|
|
grad_values = paddle.to_tensor(grad_values, dtype='float32')
|
|
sparse_out_grad = paddle.sparse.sparse_coo_tensor(
|
|
grad_indices, grad_values, shape=[2, 2]
|
|
)
|
|
sparse_x.backward(sparse_out_grad)
|
|
correct_values_grad = [0, 3]
|
|
np.testing.assert_array_equal(
|
|
correct_values_grad, values.grad.numpy()
|
|
)
|
|
|
|
# test the non-zero values is a vector
|
|
values = [[1, 1], [2, 2]]
|
|
values = paddle.to_tensor(
|
|
values, dtype='float32', stop_gradient=False
|
|
)
|
|
sparse_x = paddle.sparse.sparse_coo_tensor(
|
|
indices, values, shape=[2, 2, 2], stop_gradient=False
|
|
)
|
|
grad_values = [[2, 2], [3, 3]]
|
|
grad_values = paddle.to_tensor(grad_values, dtype='float32')
|
|
sparse_out_grad = paddle.sparse.sparse_coo_tensor(
|
|
grad_indices, grad_values, shape=[2, 2, 2]
|
|
)
|
|
sparse_x.backward(sparse_out_grad)
|
|
correct_values_grad = [[0, 0], [3, 3]]
|
|
np.testing.assert_array_equal(
|
|
correct_values_grad, values.grad.numpy()
|
|
)
|
|
|
|
def test_sparse_coo_tensor_sorted(self):
|
|
for device in devices:
|
|
if device == 'cpu' or (
|
|
device == get_device()
|
|
and (paddle.is_compiled_with_cuda() or is_custom_device())
|
|
):
|
|
paddle.device.set_device(device)
|
|
# test unsorted and duplicate indices
|
|
indices = [[1, 0, 0], [0, 1, 1]]
|
|
values = [1.0, 2.0, 3.0]
|
|
indices = paddle.to_tensor(indices, dtype='int32')
|
|
values = paddle.to_tensor(values, dtype='float32')
|
|
sparse_x = paddle.sparse.sparse_coo_tensor(indices, values)
|
|
sparse_x = paddle.sparse.coalesce(sparse_x)
|
|
indices_sorted = [[0, 1], [1, 0]]
|
|
values_sorted = [5.0, 1.0]
|
|
np.testing.assert_array_equal(
|
|
indices_sorted, sparse_x.indices().numpy()
|
|
)
|
|
np.testing.assert_array_equal(
|
|
values_sorted, sparse_x.values().numpy()
|
|
)
|
|
|
|
# test the non-zero values is a vector
|
|
values = [[1.0, 1.0], [2.0, 2.0], [3.0, 3.0]]
|
|
values = paddle.to_tensor(values, dtype='float32')
|
|
sparse_x = paddle.sparse.sparse_coo_tensor(indices, values)
|
|
sparse_x = paddle.sparse.coalesce(sparse_x)
|
|
values_sorted = [[5.0, 5.0], [1.0, 1.0]]
|
|
np.testing.assert_array_equal(
|
|
indices_sorted, sparse_x.indices().numpy()
|
|
)
|
|
np.testing.assert_array_equal(
|
|
values_sorted, sparse_x.values().numpy()
|
|
)
|
|
|
|
def test_batch_csr(self):
|
|
def verify(dense_x):
|
|
sparse_x = dense_x.to_sparse_csr()
|
|
out = sparse_x.to_dense()
|
|
np.testing.assert_allclose(out.numpy(), dense_x.numpy())
|
|
|
|
shape = np.random.randint(low=1, high=10, size=3)
|
|
shape = list(shape)
|
|
dense_x = paddle.randn(shape)
|
|
dense_x = paddle.nn.functional.dropout(dense_x, p=0.5)
|
|
verify(dense_x)
|
|
|
|
# test batches=1
|
|
shape[0] = 1
|
|
dense_x = paddle.randn(shape)
|
|
dense_x = paddle.nn.functional.dropout(dense_x, p=0.5)
|
|
verify(dense_x)
|
|
|
|
shape = np.random.randint(low=3, high=10, size=3)
|
|
shape = list(shape)
|
|
dense_x = paddle.randn(shape)
|
|
# set the 0th batch to zero
|
|
dense_x[0] = 0
|
|
verify(dense_x)
|
|
|
|
dense_x = paddle.randn(shape)
|
|
# set the 1st batch to zero
|
|
dense_x[1] = 0
|
|
verify(dense_x)
|
|
|
|
dense_x = paddle.randn(shape)
|
|
# set the 2nd batch to zero
|
|
dense_x[2] = 0
|
|
verify(dense_x)
|
|
|
|
def test_zero_nnz(self):
|
|
for device in devices:
|
|
if device == 'cpu' or (
|
|
device == get_device()
|
|
and (paddle.is_compiled_with_cuda() or is_custom_device())
|
|
):
|
|
paddle.device.set_device(device)
|
|
x1 = paddle.zeros([2, 2, 2])
|
|
x2 = paddle.zeros([2, 2, 2])
|
|
sp_csr_x = x1.to_sparse_csr()
|
|
sp_coo_x = x2.to_sparse_coo(1)
|
|
sp_coo_x.stop_gradient = False
|
|
|
|
out1 = sp_csr_x.to_dense()
|
|
out2 = sp_coo_x.to_dense()
|
|
out2.backward()
|
|
np.testing.assert_allclose(out1.numpy(), x1.numpy())
|
|
np.testing.assert_allclose(out2.numpy(), x2.numpy())
|
|
np.testing.assert_allclose(
|
|
sp_coo_x.grad.to_dense().numpy().sum(), 0.0
|
|
)
|
|
|
|
|
|
class TestCooError(unittest.TestCase):
|
|
def test_small_shape(self):
|
|
with self.assertRaises(ValueError):
|
|
indices = [[2, 3], [0, 2]]
|
|
values = [1, 2]
|
|
# 1. the shape too small
|
|
dense_shape = [2, 2]
|
|
sparse_x = paddle.sparse.sparse_coo_tensor(
|
|
indices, values, shape=dense_shape
|
|
)
|
|
|
|
def test_same_nnz(self):
|
|
with self.assertRaises(ValueError):
|
|
# 2. test the nnz of indices must same as nnz of values
|
|
indices = [[1, 2], [1, 0]]
|
|
values = [1, 2, 3]
|
|
sparse_x = paddle.sparse.sparse_coo_tensor(indices, values)
|
|
|
|
def test_same_dimensions(self):
|
|
with self.assertRaises(ValueError):
|
|
indices = [[1, 2], [1, 0]]
|
|
values = [1, 2, 3]
|
|
shape = [2, 3, 4]
|
|
sparse_x = paddle.sparse.sparse_coo_tensor(
|
|
indices, values, shape=shape
|
|
)
|
|
|
|
def test_indices_dtype(self):
|
|
with self.assertRaises(TypeError):
|
|
indices = [[1.0, 2.0], [0, 1]]
|
|
values = [1, 2]
|
|
sparse_x = paddle.sparse.sparse_coo_tensor(indices, values)
|
|
|
|
|
|
class TestCsrError(unittest.TestCase):
|
|
def test_dimension1(self):
|
|
with self.assertRaises(ValueError):
|
|
crows = [0, 1, 2, 3]
|
|
cols = [0, 1, 2]
|
|
values = [1, 2, 3]
|
|
shape = [3]
|
|
sparse_x = paddle.sparse.sparse_csr_tensor(
|
|
crows, cols, values, shape
|
|
)
|
|
|
|
def test_dimension2(self):
|
|
with self.assertRaises(ValueError):
|
|
crows = [0, 1, 2, 3]
|
|
cols = [0, 1, 2]
|
|
values = [1, 2, 3]
|
|
shape = [3, 3, 3, 3]
|
|
sparse_x = paddle.sparse.sparse_csr_tensor(
|
|
crows, cols, values, shape
|
|
)
|
|
|
|
def test_same_shape1(self):
|
|
with self.assertRaises(ValueError):
|
|
crows = [0, 1, 2, 3]
|
|
cols = [0, 1, 2, 3]
|
|
values = [1, 2, 3]
|
|
shape = [3, 4]
|
|
sparse_x = paddle.sparse.sparse_csr_tensor(
|
|
crows, cols, values, shape
|
|
)
|
|
|
|
def test_same_shape2(self):
|
|
with self.assertRaises(ValueError):
|
|
crows = [0, 1, 2, 3]
|
|
cols = [0, 1, 2, 3]
|
|
values = [1, 2, 3, 4]
|
|
shape = [3, 4]
|
|
sparse_x = paddle.sparse.sparse_csr_tensor(
|
|
crows, cols, values, shape
|
|
)
|
|
|
|
def test_same_shape3(self):
|
|
with self.assertRaises(ValueError):
|
|
crows = [0, 1, 2, 3, 0, 1, 2]
|
|
cols = [0, 1, 2, 3, 0, 1, 2]
|
|
values = [1, 2, 3, 4, 0, 1, 2]
|
|
shape = [2, 3, 4]
|
|
sparse_x = paddle.sparse.sparse_csr_tensor(
|
|
crows, cols, values, shape
|
|
)
|
|
|
|
def test_crows_first_value(self):
|
|
with self.assertRaises(ValueError):
|
|
crows = [1, 1, 2, 3]
|
|
cols = [0, 1, 2]
|
|
values = [1, 2, 3]
|
|
shape = [3, 4]
|
|
sparse_x = paddle.sparse.sparse_csr_tensor(
|
|
crows, cols, values, shape
|
|
)
|
|
|
|
def test_dtype(self):
|
|
with self.assertRaises(TypeError):
|
|
crows = [0, 1, 2, 3.0]
|
|
cols = [0, 1, 2]
|
|
values = [1, 2, 3]
|
|
shape = [3]
|
|
sparse_x = paddle.sparse.sparse_csr_tensor(
|
|
crows, cols, values, shape
|
|
)
|
|
|
|
def test_error_crows(self):
|
|
with self.assertRaises(ValueError):
|
|
crows = [0, 2, 2, 0, 1, 1, 0, 0, 0, 0]
|
|
cols = [0, 1, 1]
|
|
values = [1, 2, 5]
|
|
crows = paddle.to_tensor(crows, dtype='int32')
|
|
cols = paddle.to_tensor(cols, dtype='int32')
|
|
values = paddle.to_tensor(values, dtype='float32')
|
|
coo = paddle.sparse.sparse_csr_tensor(crows, cols, values)
|
|
|
|
|
|
devices = []
|
|
if paddle.device.get_device() != "cpu":
|
|
devices.append(paddle.device.get_device())
|
|
else:
|
|
devices.append('cpu')
|
|
|
|
|
|
class TestSparseCoalesceStatic(unittest.TestCase):
|
|
'''
|
|
test the coalesce function in static graph in pir mode
|
|
'''
|
|
|
|
def sort_and_merge(self, indices, values):
|
|
'''
|
|
sort the indices and merge the duplicate values in the same indices, using numpy and provide the correct result
|
|
'''
|
|
indices = np.array(indices)
|
|
values = np.array(values)
|
|
indices = indices[:, np.lexsort((indices[1], indices[0]))]
|
|
unique_indices, unique_indices_idx = np.unique(
|
|
indices, axis=1, return_index=True
|
|
)
|
|
v = []
|
|
for interval in zip(
|
|
unique_indices_idx.tolist(),
|
|
[*unique_indices_idx.tolist()[1:], None],
|
|
):
|
|
v.append(np.sum(values[interval[0] : interval[1]]))
|
|
unique_values = np.array(v)
|
|
return unique_indices, unique_values
|
|
|
|
def check_result(self, indices, values):
|
|
for device in devices:
|
|
paddle.device.set_device(device)
|
|
indices_tensor = paddle.to_tensor(indices, dtype='int32')
|
|
values_tensor = paddle.to_tensor(values, dtype='float32')
|
|
paddle.enable_static()
|
|
with paddle.static.program_guard(
|
|
paddle.static.Program(), paddle.static.Program()
|
|
):
|
|
x_indices = paddle.static.data(
|
|
name="x_indices",
|
|
shape=indices_tensor.shape,
|
|
dtype=indices_tensor.dtype,
|
|
)
|
|
x_values = paddle.static.data(
|
|
name="x_values",
|
|
shape=values_tensor.shape,
|
|
dtype=values_tensor.dtype,
|
|
)
|
|
sp_x = paddle.sparse.sparse_coo_tensor(
|
|
x_indices,
|
|
x_values,
|
|
dtype=x_values.dtype,
|
|
)
|
|
sp_x = paddle.sparse.coalesce(sp_x)
|
|
|
|
exe = paddle.static.Executor()
|
|
fetch = exe.run(
|
|
feed={
|
|
"x_indices": indices_tensor.numpy(),
|
|
"x_values": values_tensor.numpy(),
|
|
},
|
|
fetch_list=[sp_x.indices(), sp_x.values()],
|
|
return_numpy=True,
|
|
)
|
|
unique_indices, unique_values = self.sort_and_merge(
|
|
indices, values
|
|
)
|
|
np.testing.assert_array_equal(fetch[0], unique_indices)
|
|
np.testing.assert_array_equal(fetch[1], unique_values)
|
|
paddle.disable_static()
|
|
|
|
def test_sparse_coalesce(self):
|
|
indices = [[0, 1, 1], [0, 1, 1]]
|
|
values = [1.0, 2.0, 3.0]
|
|
if in_pir_mode():
|
|
self.check_result(indices, values)
|
|
|
|
indices = [[0, 1, 1], [0, 1, 1]]
|
|
values = [[1.0, 1.0], [2.0, 2.0], [3.0, 3.0]]
|
|
if in_pir_mode():
|
|
self.check_result(indices, values)
|
|
|
|
|
|
if __name__ == "__main__":
|
|
unittest.main()
|