*Published: December 12, 2017. Updated: February 20, 2018. Download or view executable source.*

HDF5 is an established language-independent, cross-platform binary dataformat, allowing fast and partial loading of data from disk into memory. h5py is the established Python API for interacting with HDF5 files. However, neither h5py nor the pytables high-level interface of h5py provide support for sparse matrices.

Within the single-cell genomics community, 10x Genomics and Scanpy adapted the CSR/CSC/Yale for static HDF5 storage. loompy suggested to dynamically load matrices using the COO format. However, no conventions on how different API's would recognize the stored matrices have been established.

Here, I suggest to adapt the h5sparse convention intoduced by Appier, Inc.. The idea is to mark a HDF5 group that stores a sparse matrix using two attributes

- the storage format of the sparse matrix:
`h5sparse_format`

- the shape of the sparse matrix:
`h5sparse_shape`

These are sufficient to recoqnize a group as a sparse matrix of a specific format and shape.

We implemented this convention in AnnData's submodule `anndata.h5py`

, a thin layer for h5py that offers all functionality of h5py and is able to handle HDF5 files that store both dense and sparse data in different formats. The original h5sparse, by contrast, follows different design principles and only allows to deal with HDF5 files that solely contain sparse data with limited indexing options.

*Note 1:* As Scanpy is based on `anndata`

, it adopts the convention since version 0.4

*Note 2:* In the future, anndata's support for HDF5 based storage of dictionaries and categorical data might also be integrated into `anndata.h5py`

.

```
import numpy as np
from scipy.sparse import csr_matrix, csc_matrix
import anndata
from anndata import h5py, logging
print(anndata.__version__)
```

```
0.5.3
```

```
!rm test.h5
```

```
X_array = np.array(
[[0, 1, 0],
[0, 0, 2],
[0, 0, 0],
[3, 4, 0]])
# make this a sparse matrix
X = csr_matrix(X_array)
```

```
X
```

```
<4x3 sparse matrix of type '<class 'numpy.int64'>'
with 4 stored elements in Compressed Sparse Row format>
```

Show it's entries.

```
print(X)
```

```
(0, 1) 1
(1, 2) 2
(3, 0) 3
(3, 1) 4
```

```
X[:, 1:3].toarray()
```

```
array([[1, 0],
[0, 2],
[0, 0],
[4, 0]])
```

Now, let's open a file and create an `h5py.SparseDataset`

.

```
f = h5py.File('./test.h5')
```

```
f.create_dataset('X', data=X)
```

```
<HDF5 sparse dataset: format 'csr', shape (4, 3), type '<i8'>
```

```
f['X'][:, 1:3].toarray()
```

```
array([[1, 0],
[0, 2],
[0, 0],
[4, 0]])
```

```
f['X'][np.array([True, False, False, True])].toarray()
```

```
array([[0, 1, 0],
[3, 4, 0]], dtype=int64)
```

Set an element that preserves the sparsity structure.

```
f['X'][0, 1] = 9
```

```
f['X'][:].toarray()
```

```
array([[0, 9, 0],
[0, 0, 2],
[0, 0, 0],
[3, 4, 0]])
```

Set a chunk that preserves the sparsity structure.

```
f['X'][0:2] = 2*f['X'][0:2]
```

```
f['X'][:].toarray()
```

```
array([[ 0, 18, 0],
[ 0, 0, 4],
[ 0, 0, 0],
[ 3, 4, 0]])
```

Append.

```
f['X'].append(2*f['X'][0:2])
```

```
f['X'][:].toarray()
```

```
array([[ 0, 18, 0],
[ 0, 0, 4],
[ 0, 0, 0],
[ 3, 4, 0],
[ 0, 36, 0],
[ 0, 0, 8]])
```

Just check that we can do the same with the array.

```
f.create_dataset('Y', data=X_array)
```

```
<HDF5 dataset "Y": shape (4, 3), type "<i8">
```

```
f['Y'][:]
```

```
array([[0, 1, 0],
[0, 0, 2],
[0, 0, 0],
[3, 4, 0]])
```

```
f.close()
```

Looking into the file reveals the following structure.

```
!h5ls -r './test.h5'
```

```
/ Group
/X Group
/X/data Dataset {6/Inf}
/X/indices Dataset {6/Inf}
/X/indptr Dataset {7/Inf}
/Y Dataset {4, 3}
```

The group that stores the sparse matrix is marked by the two attributes `h5sparse_format`

and `h5sparse_shape`

:

```
!h5ls -v './test.h5'
```

```
Opened "./test.h5" with sec2 driver.
X Group
Attribute: h5sparse_format scalar
Type: variable-length null-terminated UTF-8 string
Data: "csr"
Attribute: h5sparse_shape {2}
Type: native long
Data: 6, 3
Location: 1:800
Links: 1
Y Dataset {4/4, 3/3}
Location: 1:15720
Links: 1
Storage: 96 logical bytes, 96 allocated bytes, 100.00% utilization
Type: native long
```

Initializing an AnnData object with a sparse matrix in memory mode.

```
from anndata import AnnData, read_h5ad
```

```
adata = AnnData(X)
```

We could now transition to backed mode by setting the `.filename`

attribute.

Instead, let us write the object as an "h5ad"-formatted HDF5 file and open it in backed mode.

```
adata.write('./test.h5ad')
```

```
adata = read_h5ad('./test.h5ad', backed='r+')
```

```
adata
```

```
AnnData object with n_obs × n_vars = 4 × 3 backed at './test.h5'
```

```
adata.X
```

```
<HDF5 sparse dataset: format 'csr', shape (4, 3), type '<f4'>
```

```
adata.X[0:2] = np.log1p(adata.X[0:2])
```

```
adata.X[:].toarray()
```

```
array([[0. , 0.6931472, 0. ],
[0. , 0. , 1.0986123],
[0. , 0. , 0. ],
[3. , 4. , 0. ]], dtype=float32)
```

Changing from csr to csc of the file.

```
adata.X
```

```
<HDF5 sparse dataset: format 'csr', shape (4, 3), type '<f4'>
```

```
adata.X = csc_matrix(X_array)
```

```
adata.X
```

```
<HDF5 sparse dataset: format 'csc', shape (4, 3), type '<i8'>
```

Let us perform some memory profiling to see whether we really gained something.

```
logging.print_memory_usage()
```

```
Memory usage: current 0.07 GB, difference +0.07 GB
```

```
X = csr_matrix(np.ones((10000, 10000)))
```

This is a really boring, really large matrix filled with $10^8$ ones.

```
X
```

```
<10000x10000 sparse matrix of type '<class 'numpy.float64'>'
with 100000000 stored elements in Compressed Sparse Row format>
```

It takes about 1.12 GB in memory.

```
logging.print_memory_usage()
```

```
Memory usage: current 1.19 GB, difference +1.12 GB
```

```
f = h5py.File('./test2.h5')
```

```
f.create_dataset('X', data=X)
```

```
<HDF5 sparse dataset: format 'csr', shape (10000, 10000), type '<f8'>
```

```
logging.print_memory_usage()
```

```
Memory usage: current 1.19 GB, difference +0.00 GB
```

```
f.close()
```

Make sure the memory is actually freed by restarting the notebook, let's start over.

```
f = h5py.File('./test1.h5')
```

```
logging.print_memory_usage()
```

```
Memory usage: current 0.07 GB, difference +0.07 GB
```

```
f['X'][1:5]
```

```
<4x10000 sparse matrix of type '<class 'numpy.float64'>'
with 40000 stored elements in Compressed Sparse Row format>
```

```
logging.print_memory_usage()
```

```
Memory usage: current 0.07 GB, difference +0.00 GB
```

```
f['X'][[1, 5, 10, 13]]
```

```
<4x10000 sparse matrix of type '<class 'numpy.float64'>'
with 40000 stored elements in Compressed Sparse Row format>
```

```
logging.print_memory_usage()
```

```
Memory usage: current 0.07 GB, difference +0.00 GB
```

Only when loading the full object into memory, we again observe an 1.12 GB increase.

```
f['X'][:]
```

```
<10000x10000 sparse matrix of type '<class 'numpy.float64'>'
with 100000000 stored elements in Compressed Sparse Row format>
```

```
logging.print_memory_usage()
```

```
Memory usage: current 1.19 GB, difference +1.12 GB
```