Skip to content
TheChatArchiveThe Chat Archive
Qwenqwen3-235b-a22b· Alibaba (Qwen)Hugging Face LMArena Human Preference 140K

Explicame como puedo mejorar la velocidad de ingesta de tokens de un LLM en LlamaCPP de…

From a Chatbot Arena battleThe same person sent this prompt to two anonymous models at once. Compare it with Geminigemini-2.5-flash-preview-04-17’s answer.
  1. User

    Explicame como puedo mejorar la velocidad de ingesta de tokens de un LLM en LlamaCPP de Python sin usar GPU ni cuantizaciones ni cambiar el modelo.

  2. Qwen Assistant

    Para mejorar la velocidad de ingesta de tokens en LlamaCPP (usando la interfaz de Python) sin GPU, sin cuantización y sin cambiar el modelo, puedes aplicar las siguientes optimizaciones:


    1. Ajustar los hilos (n_threads)

    • Objetivo: Usar todos los núcleos físicos de la CPU disponibles.
    • Cómo:
      from llama_cpp import Llama
      llm = Llama(model_path="ruta/al/modelo.gguf", n_threads=8)  # Ajusta al número de núcleos físicos
      
    • Explicación: LlamaCPP no usa todos los hilos por defecto. Configurar n_threads al número de núcleos físicos (no lógicos) suele mejorar el rendimiento, ya que evita la sobrecarga del hyperthreading.

    2. Reducir el tamaño del contexto (n_ctx)

    • Objetivo: Minimizar la memoria y cálculos innecesarios.
    • Cómo:
      llm = Llama(model_path="ruta/al/modelo.gguf", n_ctx=2048)  # Reduce si no necesitas un contexto tan largo
      
    • Explicación: Un contexto más pequeño reduce la carga de trabajo en operaciones como la atención (attention). Si tu caso de uso no requiere un contexto extenso, reduce n_ctx.

    3. Optimizar la tokenización previa

    • Objetivo: Evitar tokenizar múltiples veces.
    • Cómo:
      tokens = llm.tokenize(b"Tu texto aqui")  # Tokeniza una vez y reutiliza
      llm.eval(tokens)  # Evalúa los tokens directamente
      
    • Explicación: Si ingresas texto repetidamente, tokeniza una vez y reutiliza los tokens con eval() en lugar de llamar a llm(prompt) cada vez.

    4. Deshabilitar funciones innecesarias

    • Objetivo: Reducir overhead de funcionalidades no utilizadas.
    • Cómo:
      llm = Llama(
          model_path="ruta/al/modelo.gguf",
          use_mmap=False,  # Desactiva mmap si no es necesario
          use_lock=False,  # Desactiva bloqueos si no hay concurrencia
          embedding=False  # Desactiva cálculo de embeddings si no se usan
      )
      
    • Explicación: Funciones como mmap (para cargar el modelo en memoria) o cálculo de embeddings pueden consumir recursos si no se necesitan.

    5. Compilar LlamaCPP con optimizaciones específicas del CPU

    • Objetivo: Aprovechar instrucciones SIMD (AVX, AVX2, NEON).
    • Cómo:
      • Compila desde el repositorio oficial:
        git clone https://github.com/ggerganov/llama.cpp
        cd llama.cpp
        make clean && CFLAGS="-O3 -march=native" make
        
      • Luego, usa el modelo compilado en Python.
    • Explicación: Los binarios precompilados no siempre usan todas las optimizaciones disponibles. Compilar con -march=native activa instrucciones específicas de tu CPU (ej. AVX2).

    6. Evitar cachés redundantes

    • Objetivo: Reducir consumo de memoria.
    • Cómo:
      llm = Llama(model_path="ruta/al/modelo.gguf", cache_size=0)  # Desactiva el caché KV si no se genera
      
    • Explicación: Si solo ingresas tokens sin generar nuevos (ej. para clasificación), desactivar el caché KV ahorra memoria y tiempo.

    7. Minimizar la longitud del prompt

    • Objetivo: Procesar menos tokens.
    • Cómo:
      • Usa prompts concisos y elimina texto redundante.
      • Ejemplo:
        prompt = "Clasifica esto: El producto es excelente."  # Mejor que "Por favor, clasifica el siguiente texto..."
        

    8. Usar llamadas en lote (batching)

    • Objetivo: Procesar múltiples tokens en paralelo.
    • Cómo:
      tokens = [token1, token2, token3]  # Lista de tokens
      llm.eval(tokens)  # Ingiere todos de una vez
      
    • Explicación: LlamaCPP procesa tokens de forma más eficiente en bloques que uno por uno.

    9. Optimizar el sistema operativo

    • Objetivo: Reducir latencia del sistema.
    • Cómo:
      • Desactiva servicios innecesarios (ej. antivirus, sincronización en segundo plano).
      • Ajusta el plan de energía a "Alto rendimiento".
      • Usa un kernel optimizado (ej. Linux con configuración de bajo latencia).

    10. Profiling y ajuste fino

    • Objetivo: Identificar cuellos de botella.
    • Cómo:
      • Usa herramientas como perf (Linux) o Intel VTune para analizar el uso de CPU.
      • En Python, usa cProfile para medir tiempos:
        import cProfile
        cProfile.run('llm("Texto de prueba")')
        

    Resumen de parámetros clave

    ParámetroRecomendaciónPropósito
    n_threadsIgual a núcleos físicosParalelismo CPU
    n_ctxMínimo necesarioReducir memoria y cálculos
    cache_size0 si no se generaAhorrar memoria
    use_mmapFalse si no es necesarioReducir overhead de E/S

    Con estas optimizaciones, puedes maximizar la velocidad de ingesta de tokens en LlamaCPP incluso sin GPU ni cuantización. ¡Prueba estas configuraciones y ajusta según tu hardware específico! 🚀

Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.