Written with AI assistance from the source video. The video is the authority.
Log in to leave a comment
No posts yet
Seguramente te ha pasado que, tras ver un vídeo de YouTube e introducir un comando para instalar un modelo en la terminal, la pantalla se ha quedado congelada. El motivo por el cual los LLM locales fallan en MacBooks antiguos con 8GB o 16GB de RAM, o en portátiles económicos, no es la falta de núcleos de procesamiento. La verdadera causa es que, con un ancho de banda de memoria extremadamente reducido, el tiempo de ejecución intenta leer datos que superan el límite. Midiendo el ancho de banda del dispositivo y ajustando únicamente el tamaño del contexto, es posible ejecutar y aprovechar un modelo de asistencia de código incluso en equipos antiguos.
Las versiones recientes de macOS y Ubuntu impiden instalar paquetes arbitrariamente en el Python del sistema. Tan pronto como ejecutas pip install, se detiene arrojando un error PEP 668 (error: externally-managed-environment). Si por pereza fuerzas la protección del sistema usando el indicador (--break-system-packages), terminarás corrompiendo las herramientas predeterminadas del SO y tendrás que reinstalarlo. Utiliza pipx, que admite el aislamiento de entornos virtuales independientes, para instalar la herramienta de diagnóstico.
Despliega de forma aislada pipx, una herramienta de diagnóstico de código abierto desarrollada por Alex Jones, para extraer las especificaciones de tu hardware.
`bash
brew install pipx
pipx ensurepath
pipx install llmfit
mkdir -p ~/local-ai-workspace/{configs,logs,scripts}
llmfit --json system > ~/local-ai-workspace/logs/system_specs.json
`
Una vez que finalizas este proceso en la terminal, la capacidad de RAM del dispositivo y la información del bus de memoria quedan organizadas en el archivo system_specs.json en tan solo un minuto, sin alterar las librerías del sistema.
El proceso mediante el cual un modelo de lenguaje local genera texto es una tarea secuencial en la que se predice el siguiente carácter observando los tokens anteriores. En cada paso, es necesario leer por completo los miles de millones de pesos del modelo directamente desde el bus de memoria. En otras palabras, la velocidad percibida no depende de la velocidad de reloj de la GPU, sino de la cifra de ancho de banda de la memoria.
La velocidad de salida de tokens por segundo (TPS) se calcula con la siguiente fórmula:
TPS approx rac{ ext{Memory Bandwidth (GB/s)}}{ ext{Model Weights Size (GB)} + ext{KV Cache per Step (GB)}} imes etaEl valor en la fórmula corresponde a la eficiencia de ancho de banda efectiva (MBU) del tiempo de ejecución, que suele rondar el 0.65.
Si cargas un modelo de 7B cuantizado a 4 bits (aproximadamente 4.5 GB) por completo en una RAM de escritorio DDR4 estándar con un ancho de banda de unos 45 GB/s, la velocidad de procesamiento se quedará en . Los caracteres aparecerán de forma entrecortada, lo que resulta exasperante para tareas de asistencia profesional. En cambio, si lo cargas en un modelo RTX 4060 de 8GB con un ancho de banda de 288 GB/s o en la memoria unificada de la serie M con más de 100 GB/s de ancho de banda, obtendrás entre 35 y 40 tokens por segundo, superando con facilidad la velocidad de escritura en tiempo real.
Tras comprobar las especificaciones de tu equipo, limita la selección de modelos a solo dos opciones:
Qwen2.5-Coder-7B-Instruct (Q4_K_M) con un tamaño de 4.7 GB. Alcanza más de 35 TPS en un MacBook con memoria unificada de 16GB o con una GPU dedicada con 8GB de VRAM.Llama-3.2-3B-Instruct (Q4_K_M) con un tamaño de 2.0 GB. Incluso en un entorno DDR4 de un portátil de bajo consumo, consume menos RAM y genera de forma constante alrededor de 15 TPS.Incluso después de lograr iniciar el modelo, tras un par de preguntas e interacciones, el proceso se cierra silenciosamente. El mensaje Exit Code 137 que aparece en la terminal indica que el núcleo de gestión de memoria del sistema operativo (Linux OOM-Killer o macOS JetSam) terminó el proceso por la fuerza (SIGKILL) debido a la falta de memoria RAM.
Si utilizas una GPU dedicada, se produce un problema aún más molesto: el desbordamiento silencioso a la CPU (Silent CPU Fallback). Cuando se supera el límite de la VRAM, en lugar de finalizar el proceso, una parte de las capas de cálculo se desvía hacia la lenta RAM del sistema. En ese momento, el uso de la GPU se desploma y la velocidad cae en picado hasta un nivel aproximado de 1 token por segundo.
El culpable es la caché KV (Key-Value), que consume más RAM a medida que la conversación se alarga. Si dejas el contexto abierto hasta 32,768 (32K) tokens según la arquitectura de Llama-3, se añadirán otros 4.0 GB exclusivamente para la memoria de caché, además de los 4.5 GB de los pesos. En un dispositivo de 8GB, esto provocará un fallo inevitable. Si limitas esta longitud a 4,096 (4K) tokens, la capacidad de la caché se reduce a 512 MB, permitiendo que funcione sin cerrarse en un entorno de 8GB.
Este es el procedimiento para comprobar el estado actual y fijar el límite.
Primero, introduce ollama ps en la terminal. Si en el campo PROCESSOR aparece dividido como 30%/70% CPU/GPU en lugar de 100% GPU, significa que la VRAM ya se ha desbordado y los datos se han desplazado a la RAM lenta.
Crea un archivo de configuración para fijar el tamaño del contexto. Abre ~/local-ai-workspace/configs/Modelfile.coder y escribe el siguiente contenido:
`dockerfile
FROM qwen2.5-coder:7b
PARAMETER num_ctx 4096PARAMETER temperature 0.2
`
Compila el modelo personalizado desde la terminal:
`bash
ollama create custom-coder:7b -f ~/local-ai-workspace/configs/Modelfile.coder
`
Una vez finalizada la compilación, introduce sudo purge en la terminal en macOS para vaciar la caché del disco, y en Windows cierra las instancias de WSL que no utilices con wsl --shutdown para liberar un mínimo de 2 GB de RAM disponible.
Para evitar que el código fuente de la empresa o los proyectos personales salgan al exterior, vincula el punto de conexión del servidor del modelo exclusivamente al bucle invertido local (127.0.0.1).
Crea el archivo ~/local-ai-workspace/scripts/serve_secure.sh e introduce el siguiente código:
`bash
#!/bin/bash
export OLLAMA_HOST="127.0.0.1:11434"
export OLLAMA_ORIGINS="http://127.0.0.1:*,http://localhost:*"
ollama serve > ~/local-ai-workspace/logs/ollama_runtime.log 2>&1 &
`
Tras ejecutar el script, comprueba si la dirección de recepción aparece como 127.0.0.1:11434 al introducir lsof -i :11434 | grep LISTEN en la terminal. Si aparece 0.0.0.0:11434, que permite accesos externos, debes cerrar el proceso de inmediato.
Para la integración, utiliza Continue.dev, un complemento de VS Code. Abre el archivo de configuración (~/.continue/config.json) para separar el modelo de chat y el de autocompletado.
`json
{
"models": [
{
"title": "Local Qwen2.5-Coder (Chat)",
"provider": "ollama",
"model": "custom-coder:7b",
"apiBase": "http://127.0.0.1:11434"
},
{
"title": "Local Llama3.2 (Summary)",
"provider": "ollama",
"model": "llama3.2:3b",
"apiBase": "http://127.0.0.1:11434"
}
],
"tabAutocompleteModel": {
"title": "Local Autocomplete",
"provider": "ollama",
"model": "qwen2.5-coder:1.5b",
"apiBase": "http://127.0.0.1:11434"
},
"allowAnonymousTelemetry": false
}
`
Asigna el modelo de 7B con el contexto limitado para las preguntas y respuestas, y especifica un modelo ultraligero de 1GB llamado qwen2.5-coder:1.5b para el autocompletado en pestaña. La demora en el autocompletado desaparecerá.
La verificación se realiza sin conexión a internet. Abre la terminal con el Wi-Fi desactivado en un estado sin conexión y realiza una consulta directa:
`bash
curl -s -X POST http://127.0.0.1:11434/api/generate -d '{
"model": "llama3.2:3b",
"prompt": "Prueba de red local aislada",
"stream": false
}' | grep "response"
`
Si se devuelve una respuesta JSON normal con la red bloqueada, habrás finalizado la configuración de un entorno de desarrollo seguro que funciona exclusivamente dentro de los recursos de tu portátil, sin depender de nubes externas.