Introducción

Ejecutar modelos de IA de código abierto localmente en nuestras propias computadoras nos brinda privacidad, infinitas posibilidades de modificación y libertad frente a las grandes corporaciones. Es casi una cuestión de libertad de expresión.

Sin embargo, para nosotros, que somos pobres en GPU, tener nuestra propia computadora con IA parece ser un sueño costoso. Macbook M3 Max ? $3200, ¡ay! NVIDIA 4090 ? $1850; Eso duele incluso si puedes conseguir uno. Computadora portátil Microsoft Surface 6 ? A partir de $1200, todavía es demasiado.

¿Qué pasa si te digo que puedes conseguir una computadora con IA útil por 300 dólares? ¿Interesado? Es necesario que proporcione su propio monitor, teclado y mouse. Y necesita algunos retoques en el sistema operativo, los controladores, el middleware y las configuraciones de Linux.

Para aclarar, NO estamos hablando de “entrenar” o “afinar” grandes modelos de IA generativa. Nos centraremos en cómo ejecutar LLM de código abierto (modelos de lenguaje grandes como Llama 2 7B) localmente, además de generar imágenes utilizando Difusión estable .

Ahora, continuemos.

¿Qué hace que una computadora con IA sea buena (y barata)?

Supongamos que uno de los principales casos de uso de una computadora doméstica con IA se está ejecutando. grandes modelos de lenguaje o inferencia LLM. En realidad, esta tarea no necesita ninguna GPU, ya que todo se puede realizar en la CPU. llama.cpp es un software de código abierto que permite una inferencia LLM muy rápida utilizando una CPU normal. Fue diseñado originalmente para Macbook con una CPU Apple serie M, pero también funciona en CPU Intel/AMD.

Sin embargo, necesita lo siguiente para una velocidad de inferencia más rápida. De lo contrario, será como ver crecer pelo en la palma de su mano mientras el LLM escupe una ficha a la vez.

• Ancho de banda rápido de CPU a memoria
• DRAM más rápida (al menos DDR4, DDR5 será aún mejor)
• Mucha memoria (como mínimo 16 GB), especialmente si desea ejecutar modelos más grandes (más de 7B)

Para la generación de imágenes con Difusión estable, necesita potencia de GPU. Sin embargo, no es necesario tener una GPU muy sofisticada para eso. Puede aprovechar la GPU integrada que ya está en las computadoras de su hogar:

1. Todos los Mac con CPU M1/M2/M3, que integra CPU, GPU y memoria de alta velocidad (son realmente buenos, pero por precio están excluidos de este artículo en particular)

   
   

2. APU AMD (por ejemplo, Ryzen 7 5700U), que integra CPU y GPU para mini PC económicas. Este será el tema central de este artículo.

   
   

3. CPU Intel (por ejemplo, Core i5-1135G7), que también integra CPU y GPU. Están ligeramente por encima del presupuesto de $300 para toda la mini-PC, pero los lectores pueden explorarlos más por su cuenta.

¿Y la computadora con IA de $ 300 es?

Una Mini PC basada en AMD con las siguientes especificaciones generalmente se vende por menos de $300. No quiero promocionar ninguna marca en particular, así que puedes buscar tú mismo:

• AMD Ryzen 7 5800H (8C/16T, hasta 4,4GHz)
• 16 GB de RAM DDR4 (se recomiendan 32 GB)
• SSD NVME M.2 de 512 GB

Derroché un poco y opté por el modelo de $400 con 32GB de RAM y 1TB SSD (todo lo demás igual). La razón principal es que investigo sobre LLM de código abierto y me gustaría ejecutar modelos más grandes, además de ejecutar Stable Difusion. Pero deberías poder hacer casi todo lo que se describe en este artículo con la computadora de $300.

Preparación 1: asignar suficiente memoria iGPU

Para APU AMD como el Ryzen 7 5800H , la memoria se comparte entre la CPU y la iGPU (GPU integrada). En mi caso, tengo 32 GB de RAM en total, ¡pero la asignación predeterminada para iGPU era solo 3 GB! Esto varía de una computadora a otra y se configura en el BIOS durante la fabricación.

Debe cambiar eso según su caso de uso principal:

1. Si solo necesita ejecutar la inferencia LLM, puede omitir todo este paso de preparación. Dado que la inferencia de LLM solo necesitará usar CPU, debe guardar la mayor parte de la RAM para la CPU para poder ejecutar modelos LLM más grandes.

   
   

2. Si necesitas correr Difusión estable , especialmente SDXL (1024x1024), debe asignar tanta RAM para la iGPU como lo permita el sistema (normalmente la mitad de la RAM total)

En mi caso, quiero ejecutar la inferencia Stable Diffusion XL y LLM en la misma mini PC. Por lo tanto, me gustaría asignar 16 GB (de un total de 32 GB) para la GPU.

Puede lograr esto cambiando la configuración en BIOS. Normalmente, existe un límite superior y la configuración predeterminada puede ser mucho más baja que el límite superior. En mi computadora, el límite superior era 16 GB, o la mitad de la RAM total disponible.

Buen BIOS

Si el BIOS de su computadora admite dichas configuraciones, continúe y cambie al número deseado. Mi BIOS no tiene esa configuración.

BIOS deficiente: utilice la herramienta AMD universal

Si su BIOS no tiene esta configuración, siga las instrucciones “¿Desbloquear la asignación de memoria de GPU en la APU AMD Ryzen™?” por Winston Ma. Lo probé y funcionó bien, así que ahora tengo 16 GB de VRAM.

https://winstonhyypia.medium.com/amd-apu-how-to-modify-the-dedicated-gpu-memory-e27b75905056

Preparación 2: instalar controladores y middleware

Alinear las estrellas

AMD ROCm (plataforma Radeon Open Compute), comparable a la de Nvidia CUDA , es un conjunto de controladores y middleware que permite a los desarrolladores utilizar el poder de las GPU de ADM. Y, por lo general, las aplicaciones de IA necesitan ROCm para obtener aceleración de GPU.

Para instalar y hacer que ROCm de AMD funcione, debe asegurarse de que las versiones del hardware GPU, la distribución de Linux, el kernel, python, el controlador HIP, la biblioteca ROCm y pytorch sean compatibles. Si desea el menor dolor y la máxima posibilidad de éxito a la primera, siga las combinaciones recomendadas y verificadas.

Requisito previo

Consulte el siguiente enlace para obtener las versiones del kernel y del sistema operativo Linux compatibles e instálelas. Inicialmente, cometí el error de simplemente instalar mi sistema operativo Linux favorito y el kernel de Linux predeterminado, y fue un gran dolor tener que retroceder para resolver los problemas de compatibilidad. Puedes evitar este dolor simplemente usando las combinaciones oficialmente admitidas.

https://rocm.docs.amd.com/projects/install-on-linux/en/latest/reference/system-requirements.html

Instalación ROCm

https://rocm.docs.amd.com/en/latest/deploy/linux/os-native/install.html

Si toda la instalación finaliza bien, puedes escribir rocminfo y se mostrará algo como esto (solo corté las partes más relevantes resaltadas en amarillo):

ROCk module is loaded

=====================

HSA System Attributes

=====================

Runtime Version: 1.1

System Timestamp Freq.: 1000.000000MHz

Sig. Max Wait Duration: 18446744073709551615 (0xFFFFFFFFFFFFFFFF) (timestamp count)

Machine Model: LARGE

System Endianness: LITTLE

Mwaitx: DISABLED

DMAbuf Support: YES

==========

HSA Agents

==========

*******

Agent 1

*******

Name: AMD Ryzen 7 5800H with Radeon Graphics

Uuid: CPU-XX

Marketing Name: AMD Ryzen 7 5800H with Radeon Graphics

Vendor Name: CPU

Pool Info:

Pool 1

Segment: GLOBAL; FLAGS: COARSE GRAINED

Size: 16777216(0x1000000) KB

Entorno Python

La dependencia de Python puede ser bastante complicada, por lo que es una buena práctica configurar un entorno adecuado. Puedes usar cualquiera conda o venv para este propósito.

• source venv/bin/activate
• conda activate llm

Pytorch

https://pytorch.org/get-started/locally/

pip3 install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/rocm5.7

Sobrescritura de HSA

Lo siguiente es específico para APU con gráficos integrados. Aunque no cuentan con el respaldo oficial de ROCm, lo siguiente demostró funcionar.

export HSA_OVERRIDE_GFX_VERSION=9.0.0

Cómo verificar

Ahora, después de todos los pasos complicados, probemos si ROCm funciona con Torch. Y puede ver que ROCm está "fingiendo" ser CUDA para el propósito de Pytorch.

https://rocm.docs.amd.com/en/latest/how_to/pytorch_install/pytorch_install.html#test-the-pytorch-installation

python3 -c 'import torch' 2> /dev/null && echo 'Success' || echo 'Failure'

Success

python3 -c 'import torch; print(torch.cuda.is_available())'

True

Inferencia LLM

Comencemos con algo fácil para nuestra computadora AI de $ 300 recién configurada: ejecutar un modelo de lenguaje grande localmente. Podemos elegir uno de los modos populares de código abierto: Llama 2 con parámetros 7B optimizados para chatear.

Además, también puedes probar pequeños LLM de Mistral , qwen , Céfiro , y Vicuña . Se pueden encontrar más LLM de buena calidad aquí en la muy útil "tabla de clasificación de chatbot arena" de UC Berkeley. Laboratorios LMSYS .

https://huggingface.co/spaces/lmsys/chatbot-arena-leaderboard

llama.cpp

estaremos usando llama.cpp , que inicialmente está optimizado para CPU y luego también admite GPU. En mi experiencia, la inferencia LLM funciona bien en la CPU, y hay poco que ganar con una GPU modesta como las integradas dentro de la máquina de IA de 300 dólares.

https://github.com/ggerganov/llama.cpp

Primero, necesitas instalar wget y git . Y luego siga los pasos para compilar e instalar llama.cpp.

sudo apt-get install build-essential

git clone https://github.com/ggerganov/llama.cpp.git

cd llama.cpp

make

Descargar Pesos Modelo

Para ejecutar los LLM en nuestra máquina económica en lugar de servidores en la nube con GPU costosas, necesitamos usar una versión "comprimida" de los modelos para que quepan en el espacio de RAM. Para un ejemplo simple, un modelo LLaMA-2 7B tiene 7B parámetros, cada uno representado por float16 (2 bytes).

• Float 16: 14B bytes o 14GB que no caben en nuestra RAM de 8GB.

• Cuantificado a 4 bits: 3,5 Bbytes o 3,5 GB que ahora caben en nuestra RAM de 8 GB.

Además, el formato del archivo debe ser guf . Entonces. En nuestro ejemplo, necesita descargar los pesos en este archivo:

https://huggingface.co/TheBloke/Llama-2-7B-Chat-GGUF/blob/main/llama-2-7b-chat.Q4_0.gguf

Prueba en una Mini PC AMD

Primero, lo probamos en la mini PC AMD y logramos alrededor de 10 tokens por segundo. En realidad, esto es bastante decente y puede conversar con el LLM sin esperar demasiado.

Configuración del sistema:

• AMD Ryzen 5800H
• 32 GB de RAM

Instrucción de línea de comando:

./main -m models/llama-2-7b-chat.Q4_0.gguf --color -ins -n 512 --mlock

llama_print_timings: load time = 661.10 ms

llama_print_timings: sample time = 234.73 ms / 500 runs ( 0.47 ms per token, 2130.14 tokens per second)

llama_print_timings: prompt eval time = 1307.11 ms / 32 tokens ( 40.85 ms per token, 24.48 tokens per second)

llama_print_timings: eval time = 50090.22 ms / 501 runs ( 99.98 ms per token, 10.00 tokens per second)

llama_print_timings: total time = 64114.27 ms

Prueba en una Mini PC Intel

A continuación, realizamos la prueba en una mini PC Intel y logramos aproximadamente 1,5 tokens por segundo. Esto es demasiado lento para una sesión de chat fructífera. No es una comparación justa, ya que el Intel N5105 es claramente más débil que el AMD 5800H. Pero esa es la única mini PC Intel que tengo. Si utiliza la CPU Intel más potente (por ejemplo, Core i5-1135G7), debería obtener resultados comparables. Informe sus hallazgos en los comentarios a continuación.

Configuración del sistema:

• 11.a generación 4 núcleos N5105 (hasta 2,9 Ghz) 4 núcleos y 4 hilos
• 16 GB de RAM (2 GB de VRAM para iGPU)

./main -m models/llama-2-7b-chat.Q4_0.gguf -ins --color -n 512 --mlock

llama_print_timings: load time = 14490.05 ms

llama_print_timings: sample time = 171.53 ms / 97 runs ( 1.77 ms per token, 565.49 tokens per second)

llama_print_timings: prompt eval time = 21234.29 ms / 33 tokens ( 643.46 ms per token, 1.55 tokens per second)

llama_print_timings: eval time = 75754.03 ms / 98 runs ( 773.00 ms per token, 1.29 tokens per second)

Difusión estable

Instalación

https://github.com/AUTOMATIC1111/stable-diffusion-webui

Y presta atención también a esta página, en lo que respecta a AMD ROCm

https://github.com/AUTOMATIC1111/stable-diffusion-webui/wiki/Install-and-Run-on-AMD-GPUs

Inicio rápido

export HSA_OVERRIDE_GFX_VERSION=9.0.0

source venv/bin/activate

./webui.sh --upcast-sampling --skip-torch-cuda-test --precision full --no-half

Prueba de difusión estable 1.5

./webui.sh --upcast-sampling --skip-torch-cuda-test --precision full --no-half

Prueba 1

• Mensaje: "caballo en el bosque"

• Pasos: 20, Muestra: DDIM, Escala CFG: 7, Semilla: 519288240, Tamaño: 512x512, Hash del modelo: 6ce0161689, Modelo: v1-5-pruned-emaonly, Versión: v1.6.0

• Tiempo empleado: 1 min. 8,3 seg.

Prueba de difusión estable XL 1.0

SDXL (resolución máxima 1024x1024) recomienda al menos 12 GB de VRAM, por lo que definitivamente debes realizar el paso de preparación 1 para asignar 16 GB de VRAM para la iGPU. Entonces, esta tarea sólo es posible con la mini PC de $400.

./webui.sh --upcast-sampling

Prueba 1:

• Mensaje: "caballo en el bosque"

• Pasos: 20, Muestra: DDIM, Escala CFG: 7, Semilla: 1102941451, Tamaño: 1024x768, Hash del modelo: 31e35c80fc, Modelo: sd_xl_base_1.0, Versión: v1.6.0

• Tiempo empleado: 7 min. 41 seg

Prueba 2:

• Mensaje: “joven taylor swift con sudadera con capucha roja montando a caballo en el bosque”

• Mensaje negativo: deformidades, deformidad, ojos deformados, dientes deformados, dedos deformados, cara deformada, manos deformadas, deformes

• Pasos: 20, Muestra: DDIM, Escala CFG: 7, Semilla: 2960206663, Tamaño: 1024x1024, Hash del modelo: 31e35c80fc, Modelo: sd_xl_base_1.0, Versión: v1.6.0

• Tiempo empleado: 6 min. 12,3 seg.

Windows 11 y AMD/directml

Aunque este artículo se centra en los sistemas operativos Linux, también puede hacer que Stable Diffusion funcione en Windows. Aquí están mis experimentos:

https://github.com/lshqqytiger/stable-diffusion-webui-directml

• Primero, necesitas instalar Python 3.10.6.

• Agregue el director Python 3.10.6 a PATH.

• Importante: la ruta de Python tiene que ser la ruta superior
• https://realpython.com/add-python-to-path/

• Instalar repositorio de git y git clone

• Ejecute webui-user.bat desde el explorador de archivos

Prueba 1:

• Mensaje: "caballo en el bosque"
• Configuraciones: DPM++ 2M Karras, 512x512, pasos de muestreo 20
• Tiempo empleado: 1m19s

Conclusiones

Entonces, ¿te estás divirtiendo ejecutando tus propios modelos de IA generativa en tu nueva mini PC de $300? Espero que lo hagas.

Los modelos de IA de código abierto que se ejecutan en dispositivos personales son una de las áreas más interesantes para los expertos, ya que ninguno de nosotros tendrá el conjunto masivo de GPU para entrenar un modelo fundamental. Esto permitirá una nueva generación de aplicaciones que son súper inteligentes y al mismo tiempo preservan la privacidad de nuestros datos.

¿Qué sigue?

• Ejecútelo en dispositivos integrados aún más pequeños: por ejemplo, Raspberry Pi

• Ejecútelo en sus teléfonos inteligentes (llama.cpp es compatible con iOS y Android)

¡Y feliz jugando con la IA, el código abierto y en el dispositivo!