Usando Estruturas Esparsas no Pandas

Introdução

Este laboratório irá guiá-lo sobre como usar estruturas de dados esparsas na biblioteca pandas. Isso é útil em cenários onde temos grandes volumes de dados, a maioria dos quais são semelhantes (como zero ou NaN), portanto, podem ser representados de forma mais eficiente na memória. Aprenderemos sobre SparseArray, SparseDtype, o acessador esparso, cálculos esparsos e a interação com matrizes esparsas do scipy.

Dicas para a VM

Após a inicialização da VM, clique no canto superior esquerdo para mudar para a aba Notebook e acessar o Jupyter Notebook para praticar.

Às vezes, pode ser necessário aguardar alguns segundos para que o Jupyter Notebook termine de carregar. A validação das operações não pode ser automatizada devido a limitações no Jupyter Notebook.

Se você enfrentar problemas durante o aprendizado, sinta-se à vontade para perguntar ao Labby. Forneça feedback após a sessão, e resolveremos o problema prontamente para você.

Criando um SparseArray

Primeiramente, criamos um array esparso, que é uma estrutura de dados do pandas para armazenar eficientemente um array de valores esparsos. Valores esparsos são aqueles que não são armazenados porque são semelhantes à maioria dos valores, portanto, considerados redundantes.

## Importing necessary libraries
import pandas as pd
import numpy as np

## Creating a numpy array with random values
arr = np.random.randn(10)

## Setting some values to NaN
arr[2:-2] = np.nan

## Creating a sparse array with pandas
ts = pd.Series(pd.arrays.SparseArray(arr))

## Output the sparse array
print(ts)

Verificando a Eficiência de Memória

Em seguida, verificaremos a eficiência de memória do uso de estruturas de dados esparsas. Criaremos um DataFrame grande, o converteremos para esparso e, em seguida, compararemos o uso de memória.

## Creating a large DataFrame with random values
df = pd.DataFrame(np.random.randn(10000, 4))

## Setting majority of the DataFrame to NaN
df.iloc[:9998] = np.nan

## Converting the DataFrame to sparse
sdf = df.astype(pd.SparseDtype("float", np.nan))

## Checking memory usage of dense vs sparse DataFrame
print('dense : {:0.2f} bytes'.format(df.memory_usage().sum() / 1e3))
print('sparse: {:0.2f} bytes'.format(sdf.memory_usage().sum() / 1e3))

Entendendo SparseDtype

O SparseDtype armazena o dtype dos valores não esparsos e o valor de preenchimento escalar. Podemos construí-lo passando apenas um dtype, ou também um valor de preenchimento explícito.

## Creating a SparseDtype
print(pd.SparseDtype(np.dtype('datetime64[ns]')))

## Creating a SparseDtype with an explicit fill value
print(pd.SparseDtype(np.dtype('datetime64[ns]'), fill_value=pd.Timestamp('2017-01-01')))

Usando o Acessador Esparso

Podemos usar o acessador .sparse para obter atributos e métodos específicos para dados esparsos.

## Creating a Series with sparse values
s = pd.Series([0, 0, 1, 2], dtype="Sparse[int]")

## Using the sparse accessor
print(s.sparse.density)
print(s.sparse.fill_value)

Realizando Cálculos Esparsos

Podemos aplicar ufuncs NumPy a SparseArray e obter um SparseArray como resultado.

## Creating a SparseArray
arr = pd.arrays.SparseArray([1., np.nan, np.nan, -2., np.nan])

## Applying a NumPy ufunc
print(np.abs(arr))

Convertendo entre Esparso e Denso

Podemos facilmente converter dados de esparsos para densos, e vice-versa.

## Converting from sparse to dense
print(sdf.sparse.to_dense())

## Converting from dense to sparse
dense = pd.DataFrame({"A": [1, 0, 0, 1]})
dtype = pd.SparseDtype(int, fill_value=0)
print(dense.astype(dtype))

Interagindo com scipy sparse

Finalmente, podemos criar um DataFrame com valores esparsos a partir de uma matriz esparsa scipy, e vice-versa.

## Importing necessary libraries
from scipy.sparse import csr_matrix

## Creating a sparse matrix with scipy
arr = np.random.random(size=(1000, 5))
arr[arr < .9] = 0
sp_arr = csr_matrix(arr)

## Creating a DataFrame from the sparse matrix
sdf = pd.DataFrame.sparse.from_spmatrix(sp_arr)

## Printing the DataFrame
print(sdf.head())
print(sdf.dtypes)

## Converting back to sparse matrix
print(sdf.sparse.to_coo())

Resumo

Neste laboratório, aprendemos como usar estruturas de dados esparsas no pandas para armazenamento e computação eficientes em termos de memória. Usamos SparseArray, SparseDtype e realizamos cálculos esparsos. Também aprendemos como converter entre denso e esparso, e como interagir com matrizes esparsas scipy.