def test_sparse_vector(self):
mat3 = dot_product_mkl(self.mat1, self.mat2_d[:, 0])
mat3_np = np.dot(self.mat1_d, self.mat2_d[:, 0])
npt.assert_array_almost_equal(mat3_np, mat3)
def test_dense_dense(self):
mat3 = dot_product_mkl(self.mat1_zero, self.mat2_d)
mat3_np = np.dot(self.mat1_zero, self.mat2_d)
npt.assert_array_almost_equal(mat3_np, mat3)
def test_2d_2d(self):
mat3 = dot_product_mkl(VECTOR.reshape(1, -1), VECTOR.reshape(-1, 1))
mat3_np = np.dot(VECTOR.reshape(1, -1), VECTOR.reshape(-1, 1))
npt.assert_array_almost_equal(mat3_np, mat3)
def test_sparse_sparse(self):
mat3 = dot_product_mkl(self.mat1, self.mat2)
mat3_np = np.dot(self.mat1_d, self.mat2_d)
npt.assert_array_almost_equal(mat3_np, mat3.A)
def test_mixed_nocast(self):
d1, d2 = self.mat1, self.mat2.astype(np.float32)
with self.assertRaises(ValueError):
hsp3 = dot_product_mkl(d1, d2, cast=False)
def test_1d_1d(self):
mat3 = dot_product_mkl(VECTOR, VECTOR)
mat3_np = np.dot(VECTOR, VECTOR)
npt.assert_array_almost_equal(mat3_np, mat3)
def test_COO(self):
d1, d2 = _spsparse.coo_matrix(self.mat1), self.mat2
with self.assertRaises(ValueError):
hsp3 = dot_product_mkl(d1, d2)
def test_highly_highly_sparse_CSR(self):
hsp1, hsp2 = make_matrixes(2000, 1000, 3000, 0.000005)
hsp3_sp = hsp1.dot(hsp2)
hsp3 = dot_product_mkl(hsp1, hsp2)
npt.assert_array_almost_equal(hsp3.A, hsp3_sp.A)
def test_csr_error_bad_dims(self):
with self.assertRaises(ValueError):
mat3 = dot_product_mkl(self.mat1.transpose(), self.mat2)
def test_mult_2d_both_float32(self):
mat3 = dot_product_mkl(self.make_2d(self.mat1.astype(np.float32)),
self.make_2d(self.mat2.astype(np.float32)))
mat3_np = np.dot(self.make_2d(self.mat1_d), self.make_2d(self.mat2_d))
npt.assert_array_almost_equal(mat3_np, mat3, decimal=5)
def do_spmm_exp(args):
# load data
Y = smat_util.load_matrix(args.y_npz_path).astype(np.float32)
X = smat_util.load_matrix(args.x_npz_path).astype(np.float32)
YT_csr = Y.T.tocsr()
X_csr = X.tocsr()
# The #threads is control by env variables (except for pecos)
# e.g., export OMP_NUM_THREADS=16, export MKL_NUM_THREADS=16.
run_time = 0.0
if args.spmm_algo == "pecos":
start = time.time()
Z = pecos_clib.sparse_matmul(
YT_csr,
X_csr,
eliminate_zeros=False,
sorted_indices=True,
threads=args.threads,
)
run_time += time.time() - start
Z_data = Z.data
elif args.spmm_algo == "intel-mkl":
from sparse_dot_mkl import dot_product_mkl
# make sure set the index to int64 for large matrices
# export MKL_INTERFACE_LAYER=ILP64
start = time.time()
Z = dot_product_mkl(YT_csr, X_csr, reorder_output=True)
run_time += time.time() - start
Z_data = Z.data
elif args.spmm_algo == "scipy":
# scipy will not sorted the indices for each row,
# so we do it explicitly
start = time.time()
Z = YT_csr.dot(X_csr)
Z.sort_indices()
run_time += time.time() - start
Z_data = Z.data
elif args.spmm_algo == "pytorch":
import torch
def get_pt_data(A_csr):
A_indices, A_values = csr_to_coo(A_csr)
A_pt = torch.sparse_coo_tensor(
A_indices.T.astype(np.int64),
A_values.astype(np.float32),
A_csr.shape,
)
return A_pt
YT_pt = get_pt_data(YT_csr)
X_pt = get_pt_data(X_csr)
start = time.time()
Z_pt = torch.sparse.mm(YT_pt, X_pt)
run_time += time.time() - start
Z_data = Z_pt.coalesce().values().numpy()
elif args.spmm_algo == "tensorflow":
import tensorflow.compat.v1 as tf
from tensorflow.python.ops.linalg.sparse import sparse_csr_matrix_ops
def get_tf_data(A_csr):
# Define (COO format) Sparse Tensors over Numpy arrays
A_indices, A_values = csr_to_coo(A_csr)
A_st = tf.sparse.SparseTensor(
A_indices.astype(np.int64),
A_values.astype(np.float32),
A_csr.shape,
)
return A_st
# Tensorflow (v2.5.0) usage, as of 07/20/2021:
# https://www.tensorflow.org/api_docs/python/tf/raw_ops/SparseMatrixSparseMatMul
with tf.Session() as sess:
YT_st = get_tf_data(YT_csr)
X_st = get_tf_data(X_csr)
sess.run(YT_st)
sess.run(X_st)
YT_sm = sparse_csr_matrix_ops.sparse_tensor_to_csr_sparse_matrix(
YT_st.indices, YT_st.values, YT_st.dense_shape)
X_sm = sparse_csr_matrix_ops.sparse_tensor_to_csr_sparse_matrix(
X_st.indices, X_st.values, X_st.dense_shape)
start = time.time()
Z_sm = sparse_csr_matrix_ops.sparse_matrix_sparse_mat_mul(
a=YT_sm, b=X_sm, type=tf.float32)
Z_st = sparse_csr_matrix_ops.csr_sparse_matrix_to_sparse_tensor(
Z_sm, tf.float32)
Z_data = sess.run(Z_st.values)
run_time += time.time() - start
else:
raise ValueError(f"spmm_algo={args.spmm_algo} is not valid")
run_time = time.time() - start
print(
"algo {:16s} time(s) {:9.5f} nnz(Z) {:12d} mu(Z.data) {:8.4f}".format(
args.spmm_algo,
run_time,
len(Z_data),
np.mean(Z_data),
))
