En este tutorial, profundizamos en Modínun poderoso reemplazo de pandas que aprovecha la computación paralela para acelerar significativamente los flujos de trabajo de datos. Al importar modin.pandas como PD, transformamos nuestro código PANDAS en una potencia de cálculo distribuida. Nuestro objetivo aquí es comprender cómo Modin se desempeña en las operaciones de datos del mundo real, como Groupby, uniones, limpieza y análisis de series de tiempo, todo mientras se ejecuta en Google Colab. Competamos cada tarea con la biblioteca PANDAS estándar para ver cuánto puede ser Modin más rápido y más eficiente en la memoria.
!pip install "modin[ray]" -q
import warnings
warnings.filterwarnings('ignore')
import numpy as np
import pandas as pd
import time
import os
from typing import Dict, Any
import modin.pandas as mpd
import ray
ray.init(ignore_reinit_error=True, num_cpus=2)
print(f"Ray initialized with {ray.cluster_resources()}")Comenzamos instalando Modin con el backend de Ray, que permite operaciones de pandas paralelizadas sin problemas en Google Colab. Suprimemos las advertencias innecesarias para mantener la salida limpia y clara. Luego, importamos todas las bibliotecas necesarias e inicializamos Ray con 2 CPU, preparando nuestro entorno para el procesamiento distribuido de datos de datos.
def benchmark_operation(pandas_func, modin_func, data, operation_name: str) -> Dict[str, Any]:
"""Compare pandas vs modin performance"""
start_time = time.time()
pandas_result = pandas_func(data['pandas'])
pandas_time = time.time() - start_time
start_time = time.time()
modin_result = modin_func(data['modin'])
modin_time = time.time() - start_time
speedup = pandas_time / modin_time if modin_time > 0 else float('inf')
print(f"\n{operation_name}:")
print(f" Pandas: {pandas_time:.3f}s")
print(f" Modin: {modin_time:.3f}s")
print(f" Speedup: {speedup:.2f}x")
return {
'operation': operation_name,
'pandas_time': pandas_time,
'modin_time': modin_time,
'speedup': speedup
}
Definimos una función de referencia para comparar el tiempo de ejecución de una tarea específica utilizando pandas y modin. Al ejecutar cada operación y registrar su duración, calculamos las ofertas de Speedup Modin. Esto nos proporciona una forma clara y medible de evaluar las ganancias de rendimiento para cada operación que probamos.
def create_large_dataset(rows: int = 1_000_000):
"""Generate synthetic dataset for testing"""
np.random.seed(42)
data = {
'customer_id': np.random.randint(1, 50000, rows),
'transaction_amount': np.random.exponential(50, rows),
'category': np.random.choice(['Electronics', 'Clothing', 'Food', 'Books', 'Sports'], rows),
'region': np.random.choice(['North', 'South', 'East', 'West'], rows),
'date': pd.date_range('2020-01-01', periods=rows, freq='H'),
'is_weekend': np.random.choice([True, False], rows, p=[0.3, 0.7]),
'rating': np.random.uniform(1, 5, rows),
'quantity': np.random.poisson(3, rows) + 1,
'discount_rate': np.random.beta(2, 5, rows),
'age_group': np.random.choice(['18-25', '26-35', '36-45', '46-55', '55+'], rows)
}
pandas_df = pd.DataFrame(data)
modin_df = mpd.DataFrame(data)
print(f"Dataset created: {rows:,} rows × {len(data)} columns")
print(f"Memory usage: {pandas_df.memory_usage(deep=True).sum() / 1024**2:.1f} MB")
return {'pandas': pandas_df, 'modin': modin_df}
dataset = create_large_dataset(500_000)
print("\n" + "="*60)
print("ADVANCED MODIN OPERATIONS BENCHMARK")
print("="*60)Definimos una función create_large_dataset para generar un conjunto de datos sintético rico con 500,000 filas que imita los datos transaccionales del mundo real, incluida la información del cliente, los patrones de compra y las marcas de tiempo. Creamos versiones de Pandas y Modin de este conjunto de datos para que podamos compararlas una al lado de la otra. Después de generar los datos, mostramos sus dimensiones y huella de memoria, configurando el escenario para operaciones avanzadas de modin.
def complex_groupby(df):
return df.groupby(['category', 'region']).agg({
'transaction_amount': ['sum', 'mean', 'std', 'count'],
'rating': ['mean', 'min', 'max'],
'quantity': 'sum'
}).round(2)
groupby_results = benchmark_operation(
complex_groupby, complex_groupby, dataset, "Complex GroupBy Aggregation"
)
Definimos una función compleja_groupby para realizar operaciones de Groupby multinivel en el conjunto de datos agrupándolo por categoría y región. Luego agregamos múltiples columnas usando funciones como suma, media, desviación estándar y recuento. Finalmente, comparamos esta operación en Pandas y Modin para medir cuánto más rápido Modin ejecuta dichas agregaciones de Groupby.
def advanced_cleaning(df):
df_clean = df.copy()
Q1 = df_clean['transaction_amount'].quantile(0.25)
Q3 = df_clean['transaction_amount'].quantile(0.75)
IQR = Q3 - Q1
df_clean = df_clean[
(df_clean['transaction_amount'] >= Q1 - 1.5 * IQR) &
(df_clean['transaction_amount'] <= Q3 + 1.5 * IQR)
]
df_clean['transaction_score'] = (
df_clean['transaction_amount'] * df_clean['rating'] * df_clean['quantity']
)
df_clean['is_high_value'] = df_clean['transaction_amount'] > df_clean['transaction_amount'].median()
return df_clean
cleaning_results = benchmark_operation(
advanced_cleaning, advanced_cleaning, dataset, "Advanced Data Cleaning"
)
Definimos la función avanzada_cleaning para simular una tubería de preprocesamiento de datos del mundo real. Primero, eliminamos los valores atípicos utilizando el método IQR para garantizar ideas más limpias. Luego, realizamos ingeniería de funciones creando una nueva métrica llamada Transaction_Score y etiquetando transacciones de alto valor. Finalmente, comparamos esta lógica de limpieza utilizando pandas y modin para ver cómo manejan transformaciones complejas en grandes conjuntos de datos.
def time_series_analysis(df):
df_ts = df.copy()
df_ts = df_ts.set_index('date')
daily_sum = df_ts.groupby(df_ts.index.date)['transaction_amount'].sum()
daily_mean = df_ts.groupby(df_ts.index.date)['transaction_amount'].mean()
daily_count = df_ts.groupby(df_ts.index.date)['transaction_amount'].count()
daily_rating = df_ts.groupby(df_ts.index.date)['rating'].mean()
daily_stats = type(df)({
'transaction_sum': daily_sum,
'transaction_mean': daily_mean,
'transaction_count': daily_count,
'rating_mean': daily_rating
})
daily_stats['rolling_mean_7d'] = daily_stats['transaction_sum'].rolling(window=7).mean()
return daily_stats
ts_results = benchmark_operation(
time_series_analysis, time_series_analysis, dataset, "Time Series Analysis"
)
Definimos la función Time_Series_analysis para explorar las tendencias diarias al volver a muestrear los datos de la transacción a lo largo del tiempo. Establecemos la columna de fecha como índice, calculamos agregaciones diarias como suma, media, recuento y calificación promedio, y las compilamos en un nuevo marco de datos. Para capturar patrones a largo plazo, también agregamos un promedio de rodamiento de 7 días. Finalmente, comparamos esta tubería de la serie temporal con pandas y modin para comparar su eficiencia en los datos temporales.
def create_lookup_data():
"""Create lookup tables for joins"""
categories_data = {
'category': ['Electronics', 'Clothing', 'Food', 'Books', 'Sports'],
'commission_rate': [0.15, 0.20, 0.10, 0.12, 0.18],
'target_audience': ['Tech Enthusiasts', 'Fashion Forward', 'Food Lovers', 'Readers', 'Athletes']
}
regions_data = {
'region': ['North', 'South', 'East', 'West'],
'tax_rate': [0.08, 0.06, 0.09, 0.07],
'shipping_cost': [5.99, 4.99, 6.99, 5.49]
}
return {
'pandas': {
'categories': pd.DataFrame(categories_data),
'regions': pd.DataFrame(regions_data)
},
'modin': {
'categories': mpd.DataFrame(categories_data),
'regions': mpd.DataFrame(regions_data)
}
}
lookup_data = create_lookup_data()
Definimos la función create_lookup_data para generar dos tablas de referencia: una para categorías de productos y otra para regiones, cada una que contenga metadatos relevantes como tasas de comisión, tasas impositivas y costos de envío. Preparamos estas tablas de búsqueda en formatos de pandas y modin para que luego podamos usarlas en operaciones de unión y comparar su rendimiento en ambas bibliotecas.
def advanced_joins(df, lookup):
result = df.merge(lookup['categories'], on='category', how='left')
result = result.merge(lookup['regions'], on='region', how='left')
result['commission_amount'] = result['transaction_amount'] * result['commission_rate']
result['tax_amount'] = result['transaction_amount'] * result['tax_rate']
result['total_cost'] = result['transaction_amount'] + result['tax_amount'] + result['shipping_cost']
return result
join_results = benchmark_operation(
lambda df: advanced_joins(df, lookup_data['pandas']),
lambda df: advanced_joins(df, lookup_data['modin']),
dataset,
"Advanced Joins & Calculations"
)
Definimos la función Advanced_Joins para enriquecer nuestro conjunto de datos principal fusionándolo con tablas de búsqueda de categoría y región. Después de realizar las uniones, calculamos campos adicionales, como Commission_amount, Tax_amount y Total_cost, para simular cálculos financieros del mundo real. Finalmente, comparamos toda esta tubería de unión y cálculo utilizando pandas y modin para evaluar qué tan bien Modin maneja operaciones complejas de múltiples pasos.
print("\n" + "="*60)
print("MEMORY EFFICIENCY COMPARISON")
print("="*60)
def get_memory_usage(df, name):
"""Get memory usage of dataframe"""
if hasattr(df, '_to_pandas'):
memory_mb = df.memory_usage(deep=True).sum() / 1024**2
else:
memory_mb = df.memory_usage(deep=True).sum() / 1024**2
print(f"{name} memory usage: {memory_mb:.1f} MB")
return memory_mb
pandas_memory = get_memory_usage(dataset['pandas'], "Pandas")
modin_memory = get_memory_usage(dataset['modin'], "Modin")Ahora cambiamos el enfoque al uso de la memoria e imprimimos un encabezado de sección para resaltar esta comparación. En la función get_memory_usage, calculamos la huella de memoria de los marcos de datos de pandas y modin utilizando sus métodos internos de memoria_usage. Aseguramos la compatibilidad con Modin verificando el atributo _to_pandas. Esto nos ayuda a evaluar qué tan eficientemente Modin maneja la memoria en comparación con los pandas, especialmente con grandes conjuntos de datos.
print("\n" + "="*60)
print("PERFORMANCE SUMMARY")
print("="*60)
results = [groupby_results, cleaning_results, ts_results, join_results]
avg_speedup = sum(r['speedup'] for r in results) / len(results)
print(f"\nAverage Speedup: {avg_speedup:.2f}x")
print(f"Best Operation: {max(results, key=lambda x: x['speedup'])['operation']} "
f"({max(results, key=lambda x: x['speedup'])['speedup']:.2f}x)")
print("\nDetailed Results:")
for result in results:
print(f" {result['operation']}: {result['speedup']:.2f}x speedup")
print("\n" + "="*60)
print("MODIN BEST PRACTICES")
print("="*60)
best_practices = [
"1. Use 'import modin.pandas as pd' to replace pandas completely",
"2. Modin works best with operations on large datasets (>100MB)",
"3. Ray backend is most stable; Dask for distributed clusters",
"4. Some pandas functions may fall back to pandas automatically",
"5. Use .to_pandas() to convert Modin DataFrame to pandas when needed",
"6. Profile your specific workload - speedup varies by operation type",
"7. Modin excels at: groupby, join, apply, and large data I/O operations"
]
for tip in best_practices:
print(tip)
ray.shutdown()
print("\n✅ Tutorial completed successfully!")
print("🚀 Modin is now ready to scale your pandas workflows!")Concluimos nuestro tutorial resumiendo los puntos de referencia de rendimiento en todas las operaciones probadas, calculando la aceleración promedio que Modin logró sobre los pandas. También destacamos la operación de mejor rendimiento, proporcionando una vista clara de dónde más se destaca Modin. Luego, compartimos un conjunto de mejores prácticas para usar Modin de manera efectiva, incluidas las puntas sobre la compatibilidad, el perfil de rendimiento y la conversión entre Pandas y Modin. Finalmente, cerramos a Ray.
En conclusión, hemos visto de primera mano cómo Modin puede sobrealimentar nuestros flujos de trabajo de Pandas con cambios mínimos en nuestro código. Ya se trate de agregaciones complejas, análisis de series de tiempo o uniones intensivas en memoria, Modin ofrece un rendimiento escalable para tareas cotidianas, particularmente en plataformas como Google Colab. Con el poder del rayo debajo del capó y la compatibilidad de la API PANDAS casi completa, Modin hace que sea fácil trabajar con conjuntos de datos más grandes.
Mira el Codos. Todo el crédito por esta investigación va a los investigadores de este proyecto. Además, siéntete libre de seguirnos Gorjeoy YouTube Y no olvides unirte a nuestro Subreddit de 100k+ ml y suscribirse a Nuestro boletín.
Nikhil es consultor interno en MarktechPost. Está buscando un doble grado integrado en materiales en el Instituto Indio de Tecnología, Kharagpur. Nikhil es un entusiasta de AI/ML que siempre está investigando aplicaciones en campos como biomateriales y ciencias biomédicas. Con una sólida experiencia en la ciencia material, está explorando nuevos avances y creando oportunidades para contribuir.