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.