Usando estructuras dispersas en Pandas

Introducción

Esta práctica te guiará sobre cómo utilizar estructuras de datos dispersas en la biblioteca pandas. Esto es útil en casos en los que tenemos grandes volúmenes de datos, la mayoría de los cuales son similares (como ceros o valores nulos), por lo que pueden representarse de manera más eficiente en memoria. Aprenderemos sobre SparseArray, SparseDtype, el acceso disperso, los cálculos dispersos y la interacción con matrices dispersas de scipy.

Consejos sobre la VM

Una vez que se haya iniciado la VM, haz clic en la esquina superior izquierda para cambiar a la pestaña Cuaderno y acceder a Jupyter Notebook para practicar.

A veces, es posible que tengas que esperar unos segundos a que Jupyter Notebook termine de cargarse. La validación de las operaciones no se puede automatizar debido a las limitaciones de Jupyter Notebook.

Si tienes problemas durante el aprendizaje, no dudes en preguntar a Labby. Proporciona retroalimentación después de la sesión y resolveremos el problema para ti de inmediato.

Creando un SparseArray

En primer lugar, creamos un array disperso, que es una estructura de datos de pandas para almacenar eficientemente una matriz de valores dispersos. Los valores dispersos son aquellos que no se almacenan porque son similares a la mayoría de los valores y, por lo tanto, se consideran redundantes.

## Importando las bibliotecas necesarias
import pandas as pd
import numpy as np

## Creando una matriz numpy con valores aleatorios
arr = np.random.randn(10)

## Estableciendo algunos valores en NaN
arr[2:-2] = np.nan

## Creando un array disperso con pandas
ts = pd.Series(pd.arrays.SparseArray(arr))

## Imprime el array disperso
print(ts)

Comprobando la eficiencia de la memoria

A continuación, comprobaremos la eficiencia de la memoria al utilizar estructuras de datos dispersas. Crearemos un gran DataFrame, lo convertiremos en disperso y luego compararemos el uso de memoria.

## Creando un gran DataFrame con valores aleatorios
df = pd.DataFrame(np.random.randn(10000, 4))

## Estableciendo la mayoría del DataFrame en NaN
df.iloc[:9998] = np.nan

## Convirtiendo el DataFrame en disperso
sdf = df.astype(pd.SparseDtype("float", np.nan))

## Comprobando el uso de memoria del DataFrame denso vs disperso
print('denso : {:0.2f} bytes'.format(df.memory_usage().sum() / 1e3))
print('disperso: {:0.2f} bytes'.format(sdf.memory_usage().sum() / 1e3))

Comprendiendo SparseDtype

El SparseDtype almacena el tipo de datos de los valores no dispersos y el valor de relleno escalar. Lo podemos construir pasando solo un tipo de datos, o también un valor de relleno explícito.

## Creando un SparseDtype
print(pd.SparseDtype(np.dtype('datetime64[ns]')))

## Creando un SparseDtype con un valor de relleno explícito
print(pd.SparseDtype(np.dtype('datetime64[ns]'), fill_value=pd.Timestamp('2017-01-01')))

Usando el acceso disperso

Podemos usar el accesor .sparse para obtener atributos y métodos específicos de datos dispersos.

## Creando una Serie con valores dispersos
s = pd.Series([0, 0, 1, 2], dtype="Sparse[int]")

## Usando el accesor disperso
print(s.sparse.density)
print(s.sparse.fill_value)

Realizando cálculos dispersos

Podemos aplicar funciones universales (ufuncs) de NumPy a SparseArray y obtener un SparseArray como resultado.

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

## Aplicando una función universal de NumPy
print(np.abs(arr))

Conversión entre disperso y denso

Podemos convertir fácilmente los datos de disperso a denso y viceversa.

## Convertir de disperso a denso
print(sdf.sparse.to_dense())

## Convertir de denso a disperso
dense = pd.DataFrame({"A": [1, 0, 0, 1]})
dtype = pd.SparseDtype(int, fill_value=0)
print(dense.astype(dtype))

Interactuar con matrices dispersas de scipy

Por último, podemos crear un DataFrame con valores dispersos a partir de una matriz dispersa de scipy, y viceversa.

## Importando las bibliotecas necesarias
from scipy.sparse import csr_matrix

## Creando una matriz dispersa con scipy
arr = np.random.random(size=(1000, 5))
arr[arr <.9] = 0
sp_arr = csr_matrix(arr)

## Creando un DataFrame a partir de la matriz dispersa
sdf = pd.DataFrame.sparse.from_spmatrix(sp_arr)

## Imprimiendo el DataFrame
print(sdf.head())
print(sdf.dtypes)

## Volviendo a convertir a matriz dispersa
print(sdf.sparse.to_coo())

Resumen

En este laboratorio, hemos aprendido cómo usar estructuras de datos dispersas en pandas para un almacenamiento y un cálculo eficientes en términos de memoria. Hemos utilizado SparseArray, SparseDtype y hemos realizado cálculos dispersos. También hemos aprendido cómo convertir entre datos densos y dispersos y cómo interactuar con matrices dispersas de scipy.