Contenido detallado
⚖️ Pesos y parámetros
Cuando ves un modelo llamado "Llama 3.1 8B" o "Qwen2.5 32B", ese número es lo más importante de la etiqueta. Indica la tamaño del cerebro del modelo. Entender qué significa ya te permite elegir mejor que la mayoría.
🆕 ¿Eres nuevo por aquí?
Parámetros (pesos) son los números que el modelo aprendió durante el entrenamiento; guardan todo lo que "sabe". "7B" quiere decir 7 mil millones de parámetros (la B es de billion). "70B" = 70 mil millones; "235B" = 235 mil millones. En la práctica, el archivo del modelo es básicamente una lista enorme de esos números.
🔑 La regla que conviene recordar
Más parámetros suele significar dos cosas a la vez:
- •Más capaz: tiende a razonar mejor, cometer menos errores y manejar tareas difíciles.
- •Más pesado: ocupa más memoria y se ejecuta más despacio en la misma máquina.
- •No es lineal: un 70B no es «10× mejor» que un 7B: la mejora disminuye, pero el costo de memoria aumenta a la par.
Los rangos más comunes que encontrarás en el mundo local:
Pequeños · 1B–4B
Gemma 2 2B, Llama 3.2 3B, Phi. Funcionan en casi cualquier laptop. Son excelentes para clasificación, resúmenes breves, autocompletado y tareas sencillas.
Medianos · 7B–14B
Llama 3.1 8B, Qwen2.5 7B/14B, Mistral 7B. El «punto ideal» para el uso diario: bueno para chat, escritura y código sencillo, y todavía cabe en hardware modesto.
Grandes · 27B–70B
Gemma 2 27B, Qwen2.5 32B, Llama 3.1 70B. Razonamiento más sólido; requieren una GPU potente o una Mac con bastante memoria unificada.
Enormes · 100B+
DeepSeek-V3, Llama 3.1 405B, modelos MoE (mezcla de expertos). La gama más alta local: exigen hardware de estación de trabajo o una Mac con mucha memoria.
📊 Detalle útil: "base" vs "instruct"
Casi todos los modelos vienen en dos versiones. La base solo completa texto. El instruct (o chat) se ajustó para seguir instrucciones y conversar; es lo que quieres el 99% de las veces. Busca el sufijo -instruct o -chat en el nombre.
🔤 Tokens y ventana de contexto
El modelo no lee letras ni palabras completas: lee tokens. Y solo puede prestar atención a una cantidad limitada de ellos a la vez: la ventana de contexto. Estos dos conceptos explican por qué a veces el modelo "olvida" el inicio de una conversación larga.
🆕 ¿Eres nuevo por aquí?
Token = un fragmento de texto. Puede ser una palabra corta, parte de una palabra o un signo de puntuación. Una regla práctica para portugués/inglés: 1 token ≈ 4 caracteres ≈ ¾ de una palabra. La frase "La IA local es poder" tiene ~5–6 tokens. Contexto = cuántos tokens puede «leer de una vez» el modelo (entrada + respuesta juntas).
La ventana de contexto se mide en tokens. Los tamaños más comunes:
4.096 tokens — lo básico
Caben unas pocas páginas. Es suficiente para preguntas y respuestas cortas. Los modelos antiguos se detenían aquí.
8.192 tokens — lo cómodo
Estándar de muchos modelos actuales. Puedes conversar bastante y pegar un documento mediano sin problemas.
128.000 tokens — el largo
Llama 3.1, Qwen2.5 y otros llegan hasta aquí. Cabe un libro entero. Pero atención: un contexto amplio consume memoria — rara vez necesitas usarlo todo.
💡 El costo oculto del contexto
Cuanto mayor sea la ventana que activas, más memoria extra necesita el modelo mientras trabaja (esto es el Caché KV, que ves en el tema 4). Por eso tener «128k de contexto» no es gratis: activar todo puede agotar tu memoria. Lo recomendable es usar solo el contexto que necesitas.
🗜️ Cuantización: el truco que hace que la IA quepa
Este es, quizá, el concepto más importante del módulo. Cuantización es lo que permite ejecutar un modelo grande en hardware modesto. Es la diferencia entre «no cabe en mi máquina» y «funciona sin problemas».
🆕 ¿Eres nuevo por aquí?
Cuantización = reducir la precisión de cada peso para que ocupe menos espacio. En vez de guardar cada número con muchos dígitos (FP16, 16 bits = 2 bytes por peso), lo guardas con menos (Q8 ≈ 1 byte; Q4 ≈ medio byte). Es como guardar una foto con menor calidad: el archivo se reduce mucho y, en la práctica, casi no notas la diferencia.
Mira el mismo modelo de 7B en tres precisiones. Fíjate cómo el tamaño se desploma mientras la calidad casi no baja:
Lee de arriba abajo: el el archivo se reduce a la mitad en cada paso (14 → 7 → 4 GB), mientras que la la calidad casi no cambia (100% → ~97%). Por eso casi todo el mundo ejecuta los modelos cuantizados: el ahorro de memoria vale mucho más que la pequeña pérdida de calidad.
✓ Lo que ganas al cuantizar
- ✓El modelo cabe en mucha menos memoria
- ✓Corre más rápido (menos datos que mover)
- ✓El hardware modesto empieza a ejecutar modelos más grandes
- ✓Q4/Q5 mantienen una calidad excelente para el día a día
✗ El precio que hay que pagar
- ✗Pequeña pérdida de precisión con cada nivel
- ✗Cuantizar demasiado (Q2, Q3) degrada perceptiblemente
- ✗En tareas muy precisas (código complejo), la pérdida se nota más
- ✗Por debajo de Q4 rara vez vale la pena
💡 Consejo práctico
Cuando tengas dudas, empieza con Q4_K_M o Q5_K_M — son el «punto ideal» reconocido por la comunidad: caben en poca memoria y mantienen una calidad muy alta. Puedes ver los sufijos completos (Q4_K_M, Q5_K_S…) en detalle en la Trilha 3, módulo 3.3.
🧠 Memoria: el recurso que manda
Si hay un único número que decide si un modelo funciona en tu máquina, es la memoria. No importa el tipo de procesador ni la marca de la tarjeta: importa cuánta memoria tienes para cargar los pesos. Aquí aprenderás a estimarlo mentalmente.
🆕 ¿Eres nuevo por aquí?
VRAM es la memoria de la tarjeta gráfica (GPU), la más rápida para la IA. RAM es la memoria del sistema. En las Mac con memoria unificada, ambas son lo mismo. El modelo debe caber entero (o casi) en esa memoria para funcionar rápido. El Caché KV es una memoria de trabajo extra que el modelo usa para «recordar» lo que ya leyó en la conversación, y ella crece junto con el contexto.
La regla práctica es directa:
memoria (GB) ≈ parámetros (B) × bytes por peso + margen de contexto
Donde bytes por peso = 2 (FP16), 1 (Q8) o ~0,5 (Q4). Deja ~10–20% de margen para el sistema y la caché KV.
Al aplicar la fórmula, esta es la tabla que conviene pegar en la pared: estimación de memoria solo de los pesos (un poco de margen):
| Modelo | Q4 (~0,5 B/peso) | Q8 (~1 B/peso) | FP16 (2 B/peso) |
|---|---|---|---|
| 7B | ~4 GB | ~7 GB | ~14 GB |
| 13B | ~7 GB | ~13 GB | ~26 GB |
| 34B | ~19 GB | ~34 GB | ~68 GB |
| 70B | ~39 GB | ~70 GB | ~140 GB |
Lectura práctica: con una GPU de 8 GB ejecutas cómodamente un 7B en Q4. Con 24 GB, un 34B en Q4 entra. Un 70B solo cabe completo en hardware grande (GPU de 48 GB+ o Mac con bastante memoria unificada). Siempre deja margen: el contexto consume memoria.
🧩 La caché KV, en una frase
Además de los pesos, reserva memoria para el Caché KV: guarda el "trabajo en curso" de la conversación y crece con la cantidad de tokens en el contexto. Duplicar el contexto puede duplicar ese costo. Por eso, en un hardware limitado, reducir la ventana de contexto a veces es lo que permite que el modelo por fin quepa.
💡 Consejo práctico
Si el modelo no cabe completo en la GPU, puedes enviar parte de él a la RAM (offload) — funciona, pero más lento. Mejor eso que no funcione. La Ruta 2 (Hardware) y el módulo 3.4 muestran cómo ajustarlo en la práctica.
🌳 Familias de modelos abiertos
El mundo abierto no es un solo modelo: son familias, cada uno de un laboratorio, con fortalezas diferentes. Conocer los nombres principales te evita perderte al elegir. Estos son los que más encontrarás:
🦙 Llama (Meta)
La familia más popular y con el ecosistema más amplio. Tamaños de 1B a 405B. Gran capacidad generalista, mucho material y herramientas disponibles. Licencia propia («Llama Community License»): abierta, con algunas restricciones.
🐉 Qwen (Alibaba)
Línea china muy competitiva, de 0.5B a 72B+. Excelente para código y multilingüe (incluye portugués). Muchas variantes tienen licencia Apache 2.0, bastante permisiva.
💎 Gemma (Google)
Modelos pequeños y medianos (2B, 9B, 27B) muy eficientes: rinden por encima de su tamaño. Ideales para hardware modesto. Licencia propia que permite un uso amplio.
🌬️ Mistral (Mistral AI)
Laboratorio europeo. Mistral 7B y Mixtral (MoE) se hicieron famosos por ofrecer mucho con poco. Buena parte está bajo Apache 2.0; algunos modelos premium tienen una licencia restrictiva.
🐳 DeepSeek
Laboratorio chino que conquistó el mundo con grandes modelos de razonamiento y código (DeepSeek-V3, R1). Máxima capacidad abierta, pero los modelos más grandes requieren hardware potente.
🔬 Phi (Microsoft)
Modelos pequeños (3B–14B) entrenados con datos de altísima calidad. Sorprenden para su tamaño. Licencia MIT en varias versiones, de las más permisivas.
🎯 Cómo navegar entre tantas
- •Rango pequeño (≤4B): Gemma 2 2B, Phi, Llama 3.2 3B, Qwen pequeños — para clasificación, resúmenes y equipos de bajo rendimiento.
- •Rango diario (7B–14B): Llama 3.1 8B, Qwen2.5 7B/14B, Mistral 7B: chat y código para el día a día.
- •Rango pesado (27B+): Gemma 2 27B, Qwen2.5 32B, Llama 70B, DeepSeek — razonamiento avanzado, requiere hardware potente.
- •Embeddings (tema de la Ruta 3): modelos minúsculos especializados (ej.: nomic-embed) — otra categoría, para memoria/RAG.
💡 Consejo práctico
No existe «el mejor modelo»: existe el mejor para tu tarea en tu hardware. Una buena rutina: elige 2–3 candidatos que quepan en tu memoria y pruébalos todos con un mismo prompt real tuyo. En la práctica, la diferencia suele pesar más que cualquier ranking de benchmarks.
📜 Las licencias importan
"Abierto" no significa "todo está permitido". Cada familia viene con una licencia que define lo que puedes hacer, especialmente si lo vas a usar para trabajar o en un producto. Ignorarlo puede causarte problemas después.
🆕 ¿Eres nuevo por aquí?
Licencia = el «contrato de uso» del modelo. Indica si puedes usarlo comercialmente, redistribuirlo, modificarlo y qué condiciones debes cumplir. Las más permisivas son Apache 2.0 e MIT (casi «haz lo que quieras»). Otras, como la licencia de Llama, son abiertas, pero tienen restricciones (ej.: reglas para empresas muy grandes o exigencia de atribución).
✓ Permisivas (Apache 2.0 / MIT)
- ✓Uso comercial permitido, sin trucos
- ✓Puedes modificar y redistribuir
- ✓Ej.: muchos Qwen, Mistral 7B, Phi, modelos de embeddings
- ✓La opción más sencilla para un producto
✗ Restringidas / personalizadas
- ✗Pueden limitar el uso comercial a cierta escala
- ✗Pueden exigir atribución o la aceptación de términos
- ✗Algunas prohíben usos específicos
- ✗P. ej.: licencia de Llama, algunos modelos «research only»
¿Dónde vive todo esto? En model card de Hugging Face — la página de cada modelo. Saber leerla es la habilidad práctica de este módulo:
⌨️ Ejemplo práctico: leer una tarjeta de modelo en Hugging Face
Objetivo: abrir la página de un modelo y extraer, en 30 segundos, todo lo que determina si te sirve. Ábrela en el navegador (no necesitas descargar nada).
Cómo verificar: si lograste decir "es un 7B, 128k de contexto, Apache 2.0, tiene GGUF Q4_K_M, versión instruct", ya sabes leer una ficha de modelo. Estos cinco elementos son exactamente lo que necesitas para decidir si cabe y si puedes usarlo.
✅ Lista de verificación antes de adoptar un modelo
- →¿Cabe? Los parámetros × la cuantización deben ajustarse a tu memoria (tema 4).
- →¿Puede? La licencia permite su uso (personal x comercial).
- →¿Sirve? Es la versión instruct y tiene el contexto que necesitas.
- →¿Ya existe? Hay un GGUF cuantizado disponible para descargar (Trilha 3).
Autoevaluación (opcional): quieres ejecutar un 13B y tiene una GPU de 8 GB. ¿Cuál es la jugada más sensata, según este módulo?
📌 Resumen del módulo
Siguiente:
Terminaste la Trilha 1 — Fundamentos. La teoría está lista; ahora es hora del hardware. Ruta 2 — Hardware & Lab: las categorías de máquinas, qué cabe en la tuya y cómo montar tu lab.