Detailed introduction to sparse storage and conversion of Python sparse matrices

This article mainly introduces Python sparse matrix-sparse storage and conversion related information, friends in need can refer to

sparse matrix-sparsep

from scipy import sparse

The storage form of sparse matrices

In the fields of science and engineering, many large matrices often appear when solving linear models. Part of the elements are all 0, which is called a sparse matrix. Using NumPy's ndarray array to save such a matrix will waste a lot of memory. Due to the sparse nature of the matrix, you can save memory usage by only saving relevant information about non-zero elements. In addition, writing operationfunctions for matrices with this special structure can also improve the operation speed of the matrix.

scipy.sparse library provides a variety of formats for representing sparse matrices, each format has different uses, among which dok_matrix and lil_matrix are suitable for gradually adding elements.

dok_matrix inherits from dict, which uses a dictionary to save the elements that are not 0 in the matrix: the key of the dictionary is a tuple that saves the element (row, column) information, and its corresponding value is the element value located in (row, column) in the matrix. Obviously, the sparse matrix in dictionary format is very suitable for the addition, deletion and access operations of single elements. Usually used to gradually add non-zero elements, and then convert to other formats that support fast operations.

a = sparse.dok_matrix((10, 5))
a[2:5, 3] = 1.0, 2.0, 3.0
print a.keys()
print a.values()

[(2, 3), (3, 3), (4, 3)]
[1.0, 2.0, 3.0]

lil_matrix uses two lists to store non-zero elements. data stores the non-zero elements in each row, and rows stores the columns in which the non-zero elements are located. This format is also great for adding elements one at a time and getting row-related data quickly.

b = sparse.lil_matrix((10, 5))
b[2, 3] = 1.0
b[3, 4] = 2.0
b[3, 2] = 3.0
print b.data
print b.rows

[[] [] [1.0] [3.0, 2.0] [] [] [] [] [] []]
[[] [] [3] [2, 4] [] [] [] [] [] []]

coo_matrix uses three arrays row, col and data to store the information of non-zero elements. The three arrays have the same length, row holds the row of elements, col holds the column of elements, and data holds the value of the element. coo_matrix does not support the access, addition and deletion of elements. Once created, it is almost impossible to perform any operations or matrix operations on it except converting it into a matrix in other formats.

coo_matrix supports repeated elements, that is, the same row and column coordinates can appear multiple times. When converted to a matrix in other formats, multiple values ​​corresponding to the same row and row coordinates will be summed. In the example below, (2, 3) corresponds to two values: 1 and 10. When converting it to an ndarray array, these two values ​​​​are added together, so the value at the coordinates of (2, 3) in the final matrix is ​​11 .

Many sparse matrix data are saved in files in this format. For example, a CSV file may have three columns: "User ID, Product ID, Evaluation Value". After reading the data using numpy.loadtxt or pandas.read_csv, it can be quickly converted into a sparse matrix through coo_matrix: each row of the matrix corresponds to a user, each column corresponds to a product, and the element value is the user's evaluation of the product. .

row = [2, 3, 3, 2]
col = [3, 4, 2, 3]
data = [1, 2, 3, 10]
c = sparse.coo_matrix((data, (row, col)), shape=(5, 6))
print c.col, c.row, c.data
print c.toarray()

[3 4 2 3] [2 3 3 2] [ 1 2 3 10]
[[ 0 0 0 0 0 0]
 [ 0 0 0 0 0 0]
 [ 0 0 0 11 0 0]
 [ 0 0 3 0 2 0]
 [ 0 0 0 0 0 0]]

In personal operation, coo_matrix was chosen because it involves sparse matrix operations, but if it is not stored in other forms, the complexity is too high (time and space). A matrix of 1000*1000 will take about 2 hours, which is also fatal. I had no choice but to think of the data input format triples in the Pajek software:

So I thought of processing my own data into similar triples!

That is, "matrix matrix"—>"tuple triple"—>"sparseMatrix2tuple"—>"scipy.sparse"

The above is the detailed content of Detailed introduction to sparse storage and conversion of Python sparse matrices. For more information, please follow other related articles on the PHP Chinese website!