Para correr un modelo LLM (Language Model Large) en una tarjeta RTX 4090 (con 24 GB de VRAM) y mantener un contexto de 32k tokens, necesitas un modelo que cumpla con estos requisitos técnicos. Aquí te presento las opciones más destacadas y cómo implementarlas:


1. Qwen1 (32k Context)

  • Modelo: Qwen1 (versión original o Qwen1.5)
  • Contexto: 32,768 tokens (perfecto para tu requerimiento).
  • VRAM requerida:
    • 176B parámetros: ~24 GB de VRAM con quantización de 4 bits (FP4).
    • Recomendado: Usar la versión Qwen1 en 4-bit quantization para ajustarse a la RTX 4090.
  • Enfoque: Desarrollado por Alibaba, es uno de los mejores en calidad y contexto largo.
  • Repositorio: Qwen en Hugging Face

2. Mistral 8x (32k Context)

  • Modelo: Mistral 8x (Mistral-8x-7B)
  • Contexto: 32,768 tokens.
  • VRAM requerida: ~12-15 GB (más liviano que Qwen1).
  • Enfoque: Especializado en contextos largos y optimizado para inferencia rápida.
  • Repositorio: Mistral-8x en Hugging Face

3. Llama3 (32k Context)

  • Modelo: Llama3 (versión 32B o 80B con quantización).
  • Contexto: 32,768 tokens (versión 32B) o 81,920 tokens (versión 80B).
  • VRAM requerida:
    • 32B parámetros: ~18-22 GB (con quantización de 4 bits).
    • 80B parámetros: ~24-28 GB (puede ajustarse con quantización, pero es más exigente).
  • Enfoque: Modelo de Meta con excelentes capacidades multilingües y contexto largo.
  • Repositorio: Llama3 en Hugging Face

4. Baojun (32k Context)

  • Modelo: Baojun 13B o 33B
  • Contexto: 32,768 tokens.
  • VRAM requerida:
    • 13B parámetros: ~9-12 GB (ideal para RTX 4090).
    • 33B parámetros: ~18-22 GB (con quantización).
  • Enfoque: Modelo chino con enfoque en contextos largos y rendimiento eficiente.
  • Repositorio: Baojun en Hugging Face

5. Phoenix (32k Context)

  • Modelo: Phoenix1.5-32k
  • Contexto: 32,768 tokens.
  • VRAM requerida: ~15-18 GB (versión 20B).
  • Enfoque: Modelo chino optimizado para contextos largos y velocidad.
  • Repositorio: Phoenix en Hugging Face

Cómo implementar con Quantización (Ejemplo con Qwen1)

Usa la librería transformers de Hugging Face y quantización dinámica para ajustar el modelo a tu GPU:

from transformers import AutoTokenizer, AutoModelForCausalLM, BitsAndBytesConfig

model_id = "Qwen/Qwen"
bnb_config = BitsAndBytesConfig(
    load_in_4bit=True,
    bnb_4bit_use_double_quant=True,
    bnb_4bit_quant_type="nf4",
    bnb_4bit_compute_dtype=torch.bfloat16
)

model = AutoModelForCausalLM.from_pretrained(
    model_id,
    quantization_config=bnb_config,
    device_map="auto"
)

tokenizer = AutoTokenizer.from_pretrained(model_id)

# Ejemplo de inferencia
input_text = "Escribe un poema sobre la inteligencia artificial..."
input_ids = tokenizer(input_text, return_tensors="pt").input_ids.to("cuda")
output = model.generate(input_ids, max_length=32768, temperature=0.7)
print(tokenizer.decode(output[0]))

Notas importantes:

  1. Quantización (4-bit): Es esencial para ajustar modelos grandes como Qwen1 o Llama3-80B en tu RTX 4090. Sin esto, muchos modelos no cabrían.
  2. Contexto máximo: Asegúrate de que el modelo soporte 32k tokens (ver documentación del modelo).
  3. Alternativas si no funciona: Si un modelo supera tu VRAM, prueba versiones más pequeñas (ej: Mistral-8x-7B en lugar de Qwen1).
  4. Recomendado para principiantes: Mistral-8x-7B o Baojun-13B son buenas opciones por su equilibrio entre rendimiento y consumo de memoria.

Conclusión

  • Mejor opción general: Qwen1 o Mistral-8x-7B (dependiendo de tus prioridades: Qwen por calidad, Mistral por eficiencia).
  • Si priorizas rendimiento puro: Llama3-32B con quantización de 4 bits.
  • Si buscas algo ligero: Baojun-13B o Phoenix-20B.

¡Prueba con el código de ejemplo y ajusta la quantización según necesites! 😊

Edit

Pub: 10 Mar 2025 01:27 UTC

Views: 19