Escalado de Grandes Conjuntos de Datos

Introducción

Este laboratorio se centra en cómo escalar el análisis de datos a conjuntos de datos más grandes utilizando pandas. Cubre métodos como cargar menos datos, utilizar tipos de datos eficientes, dividir en fragmentos (chunking) y aprovechar otras bibliotecas como Dask. Es importante tener en cuenta que pandas es más adecuado para el análisis en memoria y puede que no sea la mejor herramienta para conjuntos de datos muy grandes.

Consejos para la MV

Después de que la máquina virtual (VM) haya terminado de iniciar, haz clic en la esquina superior izquierda para cambiar a la pestaña Notebook y acceder a Jupyter Notebook para practicar.

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

Si encuentras problemas durante el aprendizaje, no dudes en preguntarle a Labby. Proporciona comentarios después de la sesión y resolveremos rápidamente el problema para ti.

Generar Conjunto de Datos

El primer paso es generar un gran conjunto de datos para pruebas. Creamos un conjunto de datos con muchas columnas que se puede almacenar en un archivo parquet. Este paso requiere las bibliotecas pandas y numpy.

import pandas as pd
import numpy as np

def make_timeseries(start="2000-01-01", end="2000-12-31", freq="1D", seed=None):
    ## Función para generar datos de series temporales
    index = pd.date_range(start=start, end=end, freq=freq, name="timestamp")
    n = len(index)
    state = np.random.RandomState(seed)
    columns = {
        "name": state.choice(["Alice", "Bob", "Charlie"], size=n),
        "id": state.poisson(1000, size=n),
        "x": state.rand(n) * 2 - 1,
        "y": state.rand(n) * 2 - 1,
    }
    df = pd.DataFrame(columns, index=index, columns=sorted(columns))
    if df.index[-1] == end:
        df = df.iloc[:-1]
    return df

timeseries = [
    make_timeseries(freq="1T", seed=i).rename(columns=lambda x: f"{x}_{i}")
    for i in range(10)
]
ts_wide = pd.concat(timeseries, axis=1)
ts_wide.to_parquet("timeseries_wide.parquet")

Cargar Menos Datos

En lugar de cargar todos los datos, podemos cargar solo las columnas que necesitamos. Aquí, demostramos dos métodos para cargar menos datos del archivo parquet.

## Opción 1: Cargar todos los datos y luego filtrar
columns = ["id_0", "name_0", "x_0", "y_0"]
pd.read_parquet("timeseries_wide.parquet")[columns]

## Opción 2: Cargar solo las columnas solicitadas
pd.read_parquet("timeseries_wide.parquet", columns=columns)

Utilizar Tipos de Datos Eficientes

Los tipos de datos predeterminados de pandas no son los más eficientes en términos de memoria. Este paso muestra cómo utilizar tipos de datos más eficientes para almacenar conjuntos de datos más grandes en memoria.

ts = make_timeseries(freq="30S", seed=0)
ts.to_parquet("timeseries.parquet")
ts = pd.read_parquet("timeseries.parquet")

## Convertir la columna 'name' al tipo 'category' para mayor eficiencia
ts2 = ts.copy()
ts2["name"] = ts2["name"].astype("category")

## Reducir el tamaño de las columnas numéricas a sus tipos más pequeños
ts2["id"] = pd.to_numeric(ts2["id"], downcast="unsigned")
ts2[["x", "y"]] = ts2[["x", "y"]].apply(pd.to_numeric, downcast="float")

Utilizar División en Fragmentos (Chunking)

La división en fragmentos (chunking) es un método para dividir un problema grande en problemas más pequeños que se pueden resolver de forma independiente. Siempre y cuando cada fragmento quepa en memoria, se pueden trabajar con conjuntos de datos mucho más grandes que la memoria disponible.

files = pathlib.Path("data/timeseries/").glob("ts*.parquet")
counts = pd.Series(dtype=int)
for path in files:
    df = pd.read_parquet(path)
    counts = counts.add(df["name"].value_counts(), fill_value=0)
counts.astype(int)

Utilizar Otras Bibliotecas

Otras bibliotecas como Dask pueden manejar conjuntos de datos más grandes que la memoria disponible. Dask proporciona una API similar a la de pandas y puede procesar datos en paralelo.

import dask.dataframe as dd

ddf = dd.read_parquet("data/timeseries/ts*.parquet", engine="pyarrow")

## Calcular recuentos de valores utilizando Dask
ddf["name"].value_counts().compute()

Resumen

En este laboratorio (lab), demostramos diferentes técnicas para escalar el análisis de datos a conjuntos de datos más grandes utilizando pandas. Generamos un conjunto de datos grande, aprendimos cómo cargar menos datos, utilizar tipos de datos eficientes y la división en fragmentos (chunking). También exploramos cómo aprovechar otras bibliotecas como Dask para manejar conjuntos de datos más grandes que la memoria disponible. Las técnicas y conceptos aprendidos en este laboratorio serán útiles al trabajar con conjuntos de datos grandes en proyectos de análisis de datos.