static_block_sparse_matrix.py 文件源码

def __init__(self, M, row_sparsity=None, column_sparsity=None, sparsity_threshold=0.05):
        # pylint: disable=len-as-condition
        self.M = M
        self.num_rows, self.num_columns = M.shape
        self.sparsity_threshold = sparsity_threshold*np.max(M.shape)

        self.M_csr = sp.sparse.csr_matrix(M)
        if row_sparsity is None:
            self.elements_per_row = np.array([self.M_csr.indptr[i + 1] - self.M_csr.indptr[i] for i in range(0, len(self.M_csr.indptr) - 1)])
            row_sparsity = self.elements_per_row < self.sparsity_threshold


        if column_sparsity is None:
            self.M_csc = sp.sparse.csc_matrix(M)
            self.elements_per_column = np.array([self.M_csc.indptr[i + 1] - self.M_csc.indptr[i] for i in range(0, len(self.M_csc.indptr) - 1)])
            column_sparsity = self.elements_per_column < self.sparsity_threshold

        self.r_s = row_sparsity if len(row_sparsity) else np.array([True]*self.M.shape[0])
        self.r_d = np.bitwise_not(self.r_s)
        self.ri_s = self.r_s.nonzero()[0]
        self.ri_d = self.r_d.nonzero()[0]

        self.c_s = column_sparsity if len(column_sparsity) else np.array([True]*self.M.shape[1])
        self.c_d = np.bitwise_not(self.c_s)
        self.ci_s = self.c_s.nonzero()[0]
        self.ci_d = self.c_d.nonzero()[0]

        M_coo = sp.sparse.coo_matrix(M)
        # sparse blocks s, and ss are created to be the size of the entire matrix, M. Dense blocks, however, are just the size of the subblocks.

        self.block_s = mask_sparse_matrix_by_rows(M_coo, self.row_sparsity)
        self.block_ss = mask_sparse_matrix_by_columns(self.block_s, self.column_sparsity).tocsr()
        self.block_ss_csc = self.block_ss.tocsc()
        self.block_sd = mask_sparse_matrix_by_columns(self.block_s, self.column_density).tocsr()[:, self.dense_column_indices].todense() if self.num_dense_columns else np.zeros((self.num_sparse_rows, self.num_dense_columns))
        self.block_s = self.block_s.tocsr()
        self.block_s_csc = self.block_s.tocsc()

        self.block_d_sparse = mask_sparse_matrix_by_rows(M_coo, self.row_density).tocsr()
        self.block_d = self.block_d_sparse[self.dense_row_indices, :].todense()
        self.block_ds = self.block_d[:, self.sparse_column_indices]
        self.block_dd = self.block_d[:, self.dense_column_indices]

        self.sparse_block = self.block_ss_csc[:, self.sparse_column_indices].tocsr()[self.sparse_row_indices, :]