RAM y VRAM para ejecutar LLMs en local

Contenido del curso

Fundamentos de los LLMs

Componentes Avanzandos de los LLMs

Personalización y Optimización

Evaluación de Modelos

20
Benchmarks para evaluar y comparar modelos LLM
12:53 min

Tomar examen

Cursos Empresas Blog Live Conf Eventos Precios

0:004:31

RAM y VRAM para ejecutar LLMs en local

Curso de Fundamentos de LLMs

Clase 14 de 20

Clase 14 / 20

Recursos

Ejecutar un LLM en local depende de cuatro variables que casi nadie explica con calma: CPU, GPU, RAM y VRAM. Si entiendes cómo se relacionan, sabrás si tu laptop aguanta el modelo o si necesitas una versión más liviana.

¿Cuál es la diferencia entre CPU y GPU al correr un LLM?

La GPU es una procesadora especializada en una sola operación matemática: M por X más B, la misma que viste en clases anteriores. Hace esa cuenta millones de veces por segundo, y por eso es ideal para machine learning.

La CPU, en cambio, es generalista. Puede abrir tu navegador, correr Photoshop, gestionar el sistema operativo y mil tareas más, pero no está optimizada para los cálculos masivos que pide un LLM [01:30].

¿Por qué los LLMs prefieren GPU sobre CPU? Porque un LLM es básicamente miles de millones de multiplicaciones de matrices, y la GPU está diseñada físicamente para hacer ese tipo de operación en paralelo.

¿Qué diferencia hay entre RAM y VRAM en modelos locales?

La RAM es la memoria que usa la CPU para guardar lo que tienes abierto ahora mismo: pestañas del navegador, una imagen en Photoshop, los archivos temporales del sistema. Para correr LLMs en local, el mínimo razonable son 16 GB de RAM y lo recomendado son 64 GB.

La VRAM viene de Video Random Access Memory. Se llama así porque las GPUs nacieron para videojuegos, aunque hoy ya existen variantes como la HBM (High Bandwidth Memory). El concepto es el mismo: una memoria integrada físicamente dentro de la GPU [02:45].

¿Por qué la VRAM es más rápida que la RAM?

Porque está pegada al chip. Y aquí viene lo interesante: entre más cerca está la memoria del procesador, menos tiempo tardan los electrones en viajar. En la CPU, los datos tienen que recorrer la motherboard hasta la RAM. En la GPU, todo está compactado en el mismo sitio, así que la latencia cae en picada.

¿Cuánta VRAM necesito para un LLM?

Para modelos pequeños o cuantizados, lo recomendable está entre 12 y 16 GB de VRAM. Ten en cuenta estos límites:

Las GPUs de consumidor llegan máximo a 36 GB de VRAM en la gama alta de Nvidia.
Las tarjetas para clusters y data centers superan ese número, pero no son para uso doméstico.
Si tu GPU tiene menos de 12 GB, vas a necesitar un modelo cuantizado sí o sí.

¿Qué es la cuantización y por qué te deja correr modelos grandes?

La cuantización es la técnica que te salva cuando tu hardware es humilde. Las computadoras manejan números con distintos niveles de precisión: 4 bits, 8 bits, 16 bits, 32 bits. Más bits, más rango numérico, más peso del modelo [05:10].

La clave es que los LLMs no necesitan toda esa precisión para funcionar bien. Puedes perder un 1 % o 2 % de exactitud y seguir teniendo un modelo perfectamente útil. Entonces, en lugar de cargar el modelo en 16 bits (la precisión típica de entrenamiento), lo bajas a 4 bits.

¿Cuánto peso ahorras con la cuantización? Si bajas un modelo de 16 bits a 4 bits, reduces su tamaño a un cuarto. Un modelo de 100 GB pasa a pesar 25 GB, lo que sí cabe en una GPU de consumidor.

¿Es difícil cuantizar un modelo hoy en día?

Ya no. Cuando estas técnicas eran nuevas requerían bastante trabajo manual, pero hoy puedes hacerlo con Hugging Face en un notebook de Python en Google Colab sin demasiada fricción. En las próximas clases vas a ver el paso a paso, y también cómo identificar en Ollama y Hugging Face si un modelo específico cabe en tu memoria disponible.

¿Ya revisaste cuánta VRAM y RAM tiene tu equipo? Cuéntame en los comentarios qué modelos te gustaría correr en local.

Mateo Montoya Henao

Hace un año

Here’s a clear breakdown of the hardware requirements to run LLMs on your local machine, tailored for different use cases (from experimentation to production):

1. Minimum Requirements (Tiny Models, CPU-Only)

Use Case: Testing small models (e.g., GPT-2 Tiny, DistilBERT).
RAM: 8GB+ (for loading the model and data).
CPU: Modern 4-core processor (e.g., Intel i5 or AMD Ryzen 5).
Storage: SSD (10GB+ free space for model weights).
Speed: Slow (seconds per token), no GPU acceleration.

Example: Run a 300M-parameter model for basic text generation.

2. Recommended (Mid-Range Models, GPU-Accelerated)

Use Case: Models like LLaMA-7B, Mistral 7B (quantized).
RAM: 16GB+ (32GB ideal for larger models).
GPU: NVIDIA with 8GB+ VRAM (e.g., RTX 3060, 3070).
VRAM Tips:
- Quantization (4-bit/8-bit) reduces VRAM usage (e.g., 7B model fits in 6GB VRAM).
- Use libraries like bitsandbytes or llama.cpp (CPU/GPU hybrid).
Storage: SSD (50GB+ for full-precision models).

Example: Chatbots or local fine-tuning with 7B-13B parameter models.

3. High-End (Large Models, Multi-GPU)

Use Case: LLaMA-70B, Falcon-40B (quantized or sharded).
RAM: 64GB+ (for offloading layers to CPU if VRAM is limited).
GPU: Multiple high-end cards (e.g., RTX 4090 24GB x2 or A100 40GB).
- NVLink helps for multi-GPU communication.
Quantization: Mandatory for 30B+ models (e.g., 4-bit via GPTQ).
Storage: Fast NVMe SSD (100GB+).

Example: Research or deploying near-state-of-the-art models locally.

4. Edge Cases (No GPU? Use Cloud or Optimized Tools)

Apple Silicon: M1/M2 Macs can run 7B-13B models via mlx or llama.cpp (unified memory).
Cloud Alternatives:
- RunPod / Lambda Labs: Rent A100s for ~$0.50/hr.
- Google Colab Pro: Free T4 or paid A100 access.

Key Software Tools

Quantization: llama.cpp (GGUF), AutoGPTQ, bitsandbytes.
GPU Acceleration: CUDA (NVIDIA), ROCm (AMD).
Frameworks: Hugging Face transformers, vLLM, Text Generation Inference.

Pro Tip: Start with a 4-bit quantized 7B model (e.g., Mistral) for the best balance of performance and hardware demands!

Fundamentos de los LLMs

Funcionamiento interno de los grandes modelos de lenguaje

Qué construirás al terminar el curso de LLMs

Historia de la inteligencia artificial desde Turing hasta GPT-4

Tokenización y embeddings en LLMs

Qué es y cómo aprende un MLP

Cómo funciona la atención en GPT-2

Fundamentos de PyTorch para modelos de machine learning

Componentes Avanzandos de los LLMs

Construye GPT-2 desde cero con PyTorch

Qué es RoPE y cómo mejora GPT

Integración de Rope en GPT-2 con PyTorch

Leyes de escalado y modelos multimodales en inteligencia artificial

Cómo se entrena un LLM paso a paso

Mixture of Experts: cómo funciona MoE

RAM y VRAM para ejecutar LLMs en local

Instalación de Olama y configuración de clúster local con ExoLabs

Personalización y Optimización

Fine tuning de GPT-4o con datos propios

Fine Tuning con LoRA en Colab gratis

Despliegue de modelos fine-tuned con Hugging Face Endpoints

Cómo funciona la cuantización de LLMs

Evaluación de Modelos

Benchmarks para evaluar y comparar modelos LLM

RAM y VRAM para ejecutar LLMs en local

Progreso del curso

Fundamentos de los LLMs

Componentes Avanzandos de los LLMs

Personalización y Optimización

Evaluación de Modelos

Recursos

Recursos