Skills Optimización de rendimiento

Cuando un Skill procesa archivos grandes o se invoca con frecuencia, los problemas de rendimiento afectan directamente la experiencia del usuario.

Este artículo presenta técnicas comunes para mejorar la velocidad de procesamiento a nivel de script.


Fuentes comunes de problemas de rendimiento

FuenteManifestación típicaEnfoque de optimización
Cargar archivos grandes de una sola vezLeer un CSV de 100MB tarda varios segundosLectura por fragmentos (chunk)
Ejecutar repetidamente el mismo cálculoRecalcular los valores estadísticos en cada llamadaCachear resultados
Procesamiento en serie de un solo hiloProcesar 1000 archivos lleva mucho tiempoProcesamiento paralelo
I/O de disco frecuenteEscribir archivos línea por línea en un bucleEscritura por lotes
Carga innecesaria de dependenciasEl import tarda más de 2 segundosImportación diferida

Lectura de archivos grandes en bloques

El parámetro de pandaschunksizepermite dividir archivos grandes en varios lotes y procesarlos por bloques, evitando ocupar demasiada memoria de una sola vez.

Ejemplo

# Ruta del archivo: scripts/chunked_reader.py
import pandas as pd
import json
import sys

def process_large_csv(file_path: str, chunk_size: int = 10000) -> dict:
    """
Leer y procesar archivos CSV grandes por bloques

Parámetros:
file_path: ruta del archivo CSV
chunk_size: número de filas por bloque, por defecto 10000

Devuelve:
Resultado estadístico combinado
    """

    total_rows   = 0
    total_sum    = 0.0
    chunk_count  = 0

    # Lee por bloques, no carga todo el archivo en memoria de una vez
    for chunk in pd.read_csv(file_path, chunksize=chunk_size):
        chunk_count += 1
        total_rows  += len(chunk)

        # Realiza estadísticas en cada bloque y acumula los resultados
        if "score" in chunk.columns:
            total_sum += chunk["score"].sum()

        # Informa el progreso en tiempo real
        print(f" Procesado lote {chunk_count}, acumuladas {total_rows} filas", flush=True)

    avg = total_sum / total_rows if total_rows > 0 else 0
    return {
        "status":      "success",
        "total_rows":  total_rows,
        "chunks":      chunk_count,
        "score_avg":   round(avg, 2)
    }

if __name__ == "__main__":
    file_path = sys.argv[1] if len(sys.argv) > 1 else ""
    result    = process_large_csv(file_path)
    print(json.dumps(result, ensure_ascii=False, indent=2))
  已处理第 1 批,累计 10000 行
  已处理第 2 批,累计 20000 行
  已处理第 3 批,累计 28456 行
{
  "status": "success",
  "total_rows": 28456,
  "chunks": 3,
  "score_avg": 82.37
}

Caché de resultados

Para operaciones que producen el mismo resultado con la misma entrada, almacena los resultados en un archivo local para evitar cálculos repetidos.

Ejemplo

# Ruta del archivo: scripts/file_cache.py
import hashlib
import json
import os
import time

CACHE_DIR = "/home/claude/.skill_cache"
os.makedirs(CACHE_DIR, exist_ok=True)

def _file_fingerprint(file_path: str) -> str:
    """
Genera una huella (fingerprint) a partir de la ruta, tamaño y fecha de modificación del archivo
Es mucho más rápido que el MD5 del contenido del archivo, adecuado para archivos grandes
    """

    stat = os.stat(file_path)
    raw  = f"{file_path}|{stat.st_size}|{stat.st_mtime}"
    return hashlib.md5(raw.encode()).hexdigest()

def get_cached(file_path: str, operation: str):
    """Obtiene la caché, devuelve None si no existe"""
    key        = _file_fingerprint(file_path) + "_" + operation
    cache_file = os.path.join(CACHE_DIR, f"{key}.json")
    if os.path.exists(cache_file):
        with open(cache_file) as f:
            return json.load(f)
    return None

def set_cached(file_path: str, operation: str, result: dict):
    """Escribe en la caché"""
    key        = _file_fingerprint(file_path) + "_" + operation
    cache_file = os.path.join(CACHE_DIR, f"{key}.json")
    with open(cache_file, "w") as f:
        json.dump(result, f, ensure_ascii=False)

# Ejemplo de uso
def get_stats(file_path: str) -> dict:
    # Primero consulta la caché
    cached = get_cached(file_path, "stats")
    if cached:
        print("Caché acertada, se omite el cálculo repetido")
        return cached

    # Caché no acertada, ejecutar el cálculo
    import pandas as pd
    t0 = time.time()
    df = pd.read_csv(file_path)
    result = {
        "rows":    len(df),
        "cols":    len(df.columns),
        "elapsed": round(time.time() - t0, 3)
    }

    # Escribir en caché para el próximo uso
    set_cached(file_path, "stats", result)
    return result

Procesamiento paralelo de múltiples archivos

Cuando necesites procesar varios archivos, usaconcurrent.futuresEjecución paralela, la velocidad puede aumentar varias veces.

Ejemplo

# Ruta del archivo: scripts/parallel_process.py
import concurrent.futures
import os
import json
import sys

def process_single_file(file_path: str) -> dict:
    """Procesa un solo archivo (se invocará en paralelo)"""
    try:
        size = os.path.getsize(file_path)
        # Simula la lógica de procesamiento real
        return {"file": os.path.basename(file_path),
                "size_kb": size // 1024, "status": "ok"}
    except Exception as e:
        return {"file": file_path, "status": "error", "message": str(e)}

def process_files_parallel(file_paths: list, max_workers: int = 4) -> list:
    """
Procesamiento paralelo de múltiples archivos

Parámetros:
file_paths: lista de rutas de archivos
max_workers: número máximo de concurrencia, por defecto 4 (evita que demasiados procesos compitan por recursos)
    """

    results = []
    with concurrent.futures.ThreadPoolExecutor(max_workers=max_workers) as executor:
        # Enviar todas las tareas
        future_map = {
            executor.submit(process_single_file, fp): fp
            for fp in file_paths
        }
        # Recoger los resultados en orden de finalización
        for future in concurrent.futures.as_completed(future_map):
            result = future.result()
            results.append(result)
            print(f" Completado: {result['file']}")
    return results

if __name__ == "__main__":
    # Simulación: procesar todos los archivos CSV en el directorio de subidas
    upload_dir = "/mnt/user-data/uploads"
    csv_files  = [
        os.path.join(upload_dir, f)
        for f in os.listdir(upload_dir)
        if f.endswith(".csv")
    ]

    if not csv_files:
        print("No se encontraron archivos CSV")
        sys.exit(0)

    print(f"Comenzando el procesamiento paralelo de {len(csv_files)} archivos...")
    results = process_files_parallel(csv_files)
    print(json.dumps(results, ensure_ascii=False, indent=2))
开始并行处理 3 个文件...
  完成:ejemplo_jan.csv
  完成:ejemplo_mar.csv
  完成:ejemplo_feb.csv
[{"file": "ejemplo_jan.csv", "size_kb": 128, "status": "ok"}, ...]

Lista de verificación de optimización de rendimiento

Elemento de revisiónAntes de optimizarDespués de optimizar
Leer archivos grandespd.read_csv(file)pd.read_csv(file, chunksize=10000)
Estadísticas repetidas del mismo archivoRecalcular cada vezUsar huella de archivo para cachear resultados
Procesar múltiples archivosBucle for en serieThreadPoolExecutor en paralelo
Escribir archivo línea por líneafor row: f.write(row)Recolectar en lote y escribir de una vez
Imports innecesariosTodos los imports al inicio del scriptImportar solo cuando se necesite (importación diferida)

Mide antes de optimizar, no optimices por intuición. Usatime.perf_counter()o@timeitel decorador para encontrar el verdadero cuello de botella, y luego optimiza de forma específica, evitando que la optimización prematura añada complejidad innecesaria al código.

Otras extensiones