Sparse Arrays (scipy.sparse)#

Introduction#

scipy.sparse and its submodules provide tools for working with sparse arrays. Sparse arrays are arrays where only a few locations in the array have any data, most of the locations are considered as “empty”. Sparse arrays are useful because they allow for simpler, faster, and/or less memory-intensive algorithms for linear algebra (scipy.sparse.linalg) or graph-based computations (scipy.sparse.csgraph), but they are generally less flexible for operations like slicing, reshaping, or assignment. This guide will introduce the basics of sparse arrays in scipy.sparse, explain the unique aspects of sparse data structures, and refer onward for other sections of the user guide explaining sparse linear algebra and graph methods.

Getting started with sparse arrays#

Sparse arrays are a special kind of array where only a few locations in the array have data. This allows for compressed representations of the data to be used, where only the locations where data exists are recorded. There are many different sparse array formats, each of which makes a different tradeoff between compression and functionality. To start, let’s build a very simple sparse array, the Coordinate (COO) array (coo_array) and compare it to a dense array:

>>> import scipy as sp
>>> import numpy as np
>>> dense = np.array([[1, 0, 0, 2], [0, 4, 1, 0], [0, 0, 5, 0]])
>>> sparse = sp.sparse.coo_array(dense)
>>> dense
array([[1, 0, 0, 2],
    [0, 4, 1, 0],
    [0, 0, 5, 0]])
>>> sparse
<COOrdinate sparse array of dtype 'int64'
     with 5 stored elements and shape (3, 4)>

Note that in our dense array, we have five nonzero values. For example, 2 is at location 0,3, and 4 is at location 1,1. All of the other values are zero. The sparse array records these five values explicitly (see the 5 stored elements and shape (3, 4)), and then represents all of the remaining zeros as implicit values.

Most sparse array methods work in a similar fashion to dense array methods:

>>> sparse.max()
5
>>> dense.max()
5
>>> sparse.argmax()
10
>>> dense.argmax()
10
>>> sparse.mean()
1.0833333333333333
>>> dense.mean()
1.0833333333333333

A few “extra” properties, such as .nnz which returns the number of stored values, are present on sparse arrays as well:

>>> sparse.nnz
5

Most of the reduction operations, such as .mean(), .sum(), or .max() will return a numpy array when applied over an axis of the sparse array:

>>> sparse.mean(axis=1)
array([0.75, 1.25, 1.25])

This is because reductions over sparse arrays are often dense.

Understanding sparse array formats#

Different kinds of sparse arrays have different capabilities. For example, COO arrays cannot be subscripted or sliced:

>>> dense[2, 2]
5
>>> sparse[2, 2]
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'coo_array' object is not subscriptable

But, other formats, such as the Compressed Sparse Row (CSR) csr_array support slicing and element indexing:

>>> sparse.tocsr()[2, 2]
5

Sometimes, scipy.sparse will return a different sparse matrix format than the input sparse matrix format. For example, the dot product of two sparse arrays in COO format will be a CSR format array:

>>> sparse @ sparse.T
<Compressed Sparse Row sparse array of dtype 'int64'
     with 5 stored elements and shape (3, 3)>

This change occurs because scipy.sparse will change the format of input sparse arrays in order to use the most efficient computational method.

The scipy.sparse module contains the following formats, each with their own distinct advantages and disadvantages:

  • Block Sparse Row (BSR) arrays scipy.sparse.bsr_array, which are most appropriate when the parts of the array with data occur in contiguous blocks.

  • Coordinate (COO) arrays scipy.sparse.coo_array, which provide a simple way to construct sparse arrays and modify them in place. COO can also be quickly converted into other formats, such CSR, CSC, or BSR.

  • Compressed Sparse Row (CSR) arrays scipy.sparse.csr_array, which are most useful for fast arithmetic, vector products, and slicing by row.

  • Compressed Sparse Column (CSC) arrays scipy.sparse.csc_array, which are most useful for fast arithmetic, vector products, and slicing by column.

  • Diagonal (DIA) arrays scipy.sparse.dia_array, which are useful for efficient storage and fast arithmetic so long as the data primarily occurs along diagonals of the array.

  • Dictionary of Keys (DOK) arrays scipy.sparse.dok_array, which are useful for fast construction and single-element access.

  • List of Lists (LIL) arrays scipy.sparse.lil_array, which are useful for fast construction and modification of sparse arrays.

More information on the strengths and weaknesses of each of the sparse array formats can be found in their documentation.

All formats of scipy.sparse arrays can be constructed directly from a numpy.ndarray. However, some sparse formats can be constructed in different ways, too. Each sparse array format has different strengths, and these strengths are documented in each class. For example, one of the most common methods for constructing sparse arrays is to build a sparse array from the individual row, column, and data values. For our array from before:

>>> dense
array([[1, 0, 0, 2],
    [0, 4, 1, 0],
    [0, 0, 5, 0]])

The row, column, and data arrays describe the rows, columns, and values where our sparse array has entries:

>>> row = [0,0,1,1,2]
>>> col = [0,3,1,2,2]
>>> data = [1,2,4,1,5]

Using these, we can now define a sparse array without building a dense array first:

>>> csr = sp.sparse.csr_array((data, (row, col)))
>>> csr
<Compressed Sparse Row sparse array of dtype 'int64'
     with 5 stored elements and shape (3, 4)>

Different classes have different constructors, but the scipy.sparse.csr_array, scipy.sparse.csc_array, and scipy.sparse.coo_array allow for this style of construction.

Sparse arrays, implicit zeros, and duplicates#

Sparse arrays are useful because they represent much of their values implicitly, without storing an actual placeholder value. In scipy.sparse, the value used to represent “no data” is an implicit zero. This can be confusing when explicit zeros are required. For example, in graph methods from scipy.sparse.csgraph, we often need to be able to distinguish between (A) a link connecting nodes i and j with zero weight and (B) no link between i and j. Sparse matrices can do this, so long as we keep the explicit and implicit zeros in mind.

For example, in our previous csr array, we could include an explicit zero by including it in the data list. Let’s treat the final entry in the array at the bottom row and last column as an explicit zero:

>>> row = [0,0,1,1,2,2]
>>> col = [0,3,1,2,2,3]
>>> data = [1,2,4,1,5,0]

Then, our sparse array will have six stored elements, not five:

>>> csr = sp.sparse.csr_array((data, (row, col)))
>>> csr
<Compressed Sparse Row sparse array of dtype 'int64'
     with 6 stored elements and shape (3, 4)>

The “extra” element is our explicit zero. The two are still identical when converted back into a dense array, because dense arrays represent everything explicitly:

>>> csr.todense()
array([[1, 0, 0, 2],
    [0, 4, 1, 0],
    [0, 0, 5, 0]])
>>> dense
array([[1, 0, 0, 2],
    [0, 4, 1, 0],
    [0, 0, 5, 0]])

But, for sparse arithmetic, linear algebra, and graph methods, the value at 2,3 will be considered an explicit zero. To remove this explicit zero, we can use the csr.eliminate_zeros() method. This operates on the sparse array in place, and removes any zero-value stored elements:

>>> csr
<Compressed Sparse Row sparse array of dtype 'int64'
     with 6 stored elements and shape (3, 4)>
>>> csr.eliminate_zeros()
>>> csr
<Compressed Sparse Row sparse array of dtype 'int64'
     with 5 stored elements and shape (3, 4)>

Before csr.eliminate_zeros(), there were six stored elements. After, there are only five stored elements.

Another point of complication arises from how duplicates are processed when constructing a sparse array. A duplicate can occur when we have two or more entries at row,col when constructing a sparse array. This often occurs when building sparse arrays using the data, row, and col vectors. For example, we might represent our previous array with a duplicate value at 1,1:

>>> row = [0,0,1,1,1,2]
>>> col = [0,3,1,1,2,2]
>>> data = [1,2,1,3,1,5]

In this case, we can see that there are two data values that correspond to the 1,1 location in our final array. scipy.sparse will store these values separately:

>>> dupes = sp.sparse.coo_array((data, (row, col)))
>>> dupes
<COOrdinate sparse array of dtype 'int64'
     with 6 stored elements and shape (3, 4)>

Note that there are six stored elements in this sparse array, despite only having five unique locations where data occurs. When these arrays are converted back to dense arrays, the duplicate values are summed. So, at location 1,1, the dense array will contain the sum of duplicate stored entries, 1 + 3:

>>> dupes.todense()
array([[1, 0, 0, 2],
      [0, 4, 1, 0],
      [0, 0, 5, 0]])

To remove duplicate values within the sparse array itself and thus reduce the number of stored elements, we can use the .sum_duplicates() method:

>>> dupes.sum_duplicates()
>>> dupes
<COOrdinate sparse array of dtype 'int64'
     with 5 stored elements and shape (3, 4)>

Now there are only five stored elements in our sparse array, and it is identical to the array we have been working with throughout this guide:

>>> dupes.todense()
array([[1, 0, 0, 2],
       [0, 4, 1, 0],
       [0, 0, 5, 0]])

Canonical formats#

Several sparse array formats have “canonical formats” to allow for more efficient operations. Generally these consist of added restrictions like:

  • No duplicate entries for any value

  • Sorted indices

Classes with a canonical form include: coo_array, csr_array, csc_array, and bsr_array. See the docstrings of these classes for details on each canonical representation.

To check if an instance of these classes is in canonical form, use the .has_canonical_format attribute:

>>> coo = sp.sparse.coo_array(([1, 1, 1], ([0, 2, 1], [0, 1, 2])))
>>> coo.has_canonical_format
False

To convert an instance to canonical form, use the .sum_duplicates() method:

>>> coo.sum_duplicates()
>>> coo.has_canonical_format
True

Next steps with sparse arrays#

Sparse array types are most helpful when working with large, nearly empty arrays. Specifically, sparse linear algebra and sparse graph methods see the largest improvements in efficiency in these circumstances.

On this page