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
| Fuente | Manifestación típica | Enfoque de optimización |
|---|---|---|
| Cargar archivos grandes de una sola vez | Leer un CSV de 100MB tarda varios segundos | Lectura por fragmentos (chunk) |
| Ejecutar repetidamente el mismo cálculo | Recalcular los valores estadísticos en cada llamada | Cachear resultados |
| Procesamiento en serie de un solo hilo | Procesar 1000 archivos lleva mucho tiempo | Procesamiento paralelo |
| I/O de disco frecuente | Escribir archivos línea por línea en un bucle | Escritura por lotes |
| Carga innecesaria de dependencias | El import tarda más de 2 segundos | Importació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
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
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
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ón | Antes de optimizar | Después de optimizar |
|---|---|---|
| Leer archivos grandes | pd.read_csv(file) | pd.read_csv(file, chunksize=10000) |
| Estadísticas repetidas del mismo archivo | Recalcular cada vez | Usar huella de archivo para cachear resultados |
| Procesar múltiples archivos | Bucle for en serie | ThreadPoolExecutor en paralelo |
| Escribir archivo línea por línea | for row: f.write(row) | Recolectar en lote y escribir de una vez |
| Imports innecesarios | Todos los imports al inicio del script | Importar solo cuando se necesite (importación diferida) |
Otras extensionesMide antes de optimizar, no optimices por intuición. Usa
time.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.