8,219 leituras

Como construir um computador com IA de US$ 300 para os pobres em GPU

por Bruce Li12m2024/03/24

Muito longo; Para ler

Para nós, com pouca GPU, no entanto, ter nosso próprio computador de IA parece ser um sonho caro. Macbook M3 Máx.? $ 3.200, ai! Nvidia 4090? US$ 1.850; isso dói, mesmo que você consiga um. Microsoft Surface Laptop 6? A partir de US$ 1.200, ainda é demais. E se eu lhe disser que você pode obter um computador de IA útil por US$ 300? Interessado? Você precisa fornecer seu próprio monitor, teclado e mouse. E você precisa de alguns ajustes no sistema operacional Linux, drivers, middleware e configurações.

featured image - Como construir um computador com IA de US$ 300 para os pobres em GPU

Introdução

Executar modelos de IA de código aberto localmente em nossos próprios computadores nos dá privacidade, possibilidades infinitas de ajustes e liberdade em relação às grandes corporações. É quase uma questão de liberdade de expressão.

E se eu lhe disser que você pode obter um computador de IA útil por US$ 300? Interessado? Você precisa fornecer seu próprio monitor, teclado e mouse. E você precisa de alguns ajustes no sistema operacional Linux, drivers, middleware e configurações.

Para esclarecer, NÃO estamos falando de “treinar” ou “ajustar” grandes modelos generativos de IA. Vamos nos concentrar em como executar LLM de código aberto (grandes modelos de linguagem, como Lhama 2 7B) localmente, bem como gerar imagens usando Difusão Estável .

Agora, vamos continuar.

O que torna um computador de IA bom (e barato)?

Vamos supor que um dos principais casos de uso de um computador doméstico com IA seja executado grandes modelos de linguagem ou inferência LLM. Na verdade, esta tarefa não precisa de GPU, pois tudo pode ser feito na CPU. lhama.cpp é um software de código aberto que permite inferência LLM muito rápida usando CPU normal. Ele foi originalmente projetado para Macbook com CPU Apple série M, mas também funciona em CPUs Intel/AMD.

No entanto, você precisa do seguinte para obter uma velocidade de inferência mais rápida. Caso contrário, você será como ver o cabelo crescer na palma da mão enquanto o LLM cospe uma ficha de cada vez.

CPU rápida para largura de banda de memória
DRAM mais rápida (pelo menos DDR4, DDR5 será ainda melhor)
Muita memória (no mínimo 16 GB), especialmente se você deseja rodar modelos maiores (além de 7B)

Para geração de imagens com difusão estável, você precisa de potência de GPU. No entanto, você não precisa ter uma GPU muito sofisticada para isso. Você pode aproveitar a GPU integrada já em seus computadores domésticos:

Todos os Macs com CPU M1/M2/M3, que integra CPU, GPU e memória de alta velocidade (eles são realmente bons, mas devido ao preço estão excluídos deste artigo específico)
AMD APU (por exemplo, Ryzen 7 5700U), que integra CPU e GPU para mini-PCs econômicos. Este será o foco deste artigo.
CPU Intel (por exemplo, Core i5-1135G7), que também integra CPU e GPU. Eles estão um pouco acima do orçamento de US$ 300 para todo o mini-PC, mas os leitores podem explorá-los por conta própria.

E o computador AI de US$ 300 é?

Um Mini PC baseado em AMD com as seguintes especificações geralmente é vendido por menos de US$ 300. Não quero endossar nenhuma marca em particular, então você mesmo pode pesquisar:

AMD Ryzen 7 5800H (8C/16T, até 4,4 GHz)
16 GB de RAM DDR4 (recomendado 32 GB)
SSD NVME M.2 de 512 GB

Esbanjei um pouco e optei pelo modelo de US$ 400 com 32 GB de RAM e SSD de 1 TB (todo o resto igual). O principal motivo é que pesquiso LLMs de código aberto e gostaria de rodar modelos maiores, além de rodar Stable Difusion. Mas você poderá fazer quase tudo neste artigo com o computador de US$ 300.

Preparação 1: Alocar memória iGPU suficiente

Para APUs AMD como o Ryzen7 5800H , a memória é compartilhada entre CPU e iGPU (GPU integrada). No meu caso, tenho 32 GB de RAM no total, mas a alocação padrão para iGPU era de apenas 3 GB! Isso varia de computador para computador e é configurado no BIOS durante a fabricação.

Você precisa mudar isso dependendo do seu caso de uso principal:

Se você precisar apenas executar a inferência do LLM, poderá pular toda essa etapa de preparação. Como a inferência do LLM só precisará usar CPU, você deve economizar a maior parte da RAM para a CPU para poder executar modelos LLM maiores.
Se você precisar correr Difusão Estável , especialmente SDXL (1024x1024), você precisa alocar tanta RAM para o iGPU quanto o sistema permitir (normalmente metade da RAM total)

No meu caso, quero executar a inferência Stable Diffusion XL e LLM no mesmo mini PC. Portanto, gostaria de alocar 16 GB (de um total de 32 GB) para a GPU.

Você pode conseguir isso alterando as configurações do BIOS. Normalmente, há um limite superior e a configuração padrão pode ser muito inferior ao limite superior. No meu computador, o limite máximo era de 16 GB, ou metade do total de RAM disponível.

Bom BIOS

Se o BIOS do seu computador suportar essas configurações, vá em frente e mude para o número desejado. Meu BIOS não tem essa configuração.

BIOS ruim: use a ferramenta Universal AMD

Se o seu BIOS não tiver essa configuração, siga as instruções “Desbloqueando a alocação de memória GPU na APU AMD Ryzen ™?” por Winston Ma. Eu tentei e funcionou bem, agora tenho 16 GB de VRAM.

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

Preparação 2: Instalar Drivers e Middleware

Alinhe as estrelas

da AMD ROCm (plataforma Radeon Open Compute), comparável à da Nvidia CUDA , é um conjunto de drivers e middleware para permitir que os desenvolvedores utilizem o poder das GPUs da ADM. E normalmente, os aplicativos de IA precisam de ROCm para obter aceleração de GPU.

Para instalar e fazer o ROCm da AMD funcionar, você deve se certificar de que as versões do hardware GPU, distribuição Linux, kernel, python, driver HIP, biblioteca ROCm e pytorch são compatíveis. Se você deseja o mínimo de dor e a máxima possibilidade de sucesso na primeira vez, siga as combinações recomendadas e verificadas.

Pré-requisito

Verifique o link a seguir para obter versões compatíveis do sistema operacional Linux e do kernel e instale-os. Inicialmente, cometi o erro de apenas instalar meu sistema operacional Linux favorito e o kernel Linux padrão, e foi uma grande dor retroceder para resolver problemas de compatibilidade. Você pode evitar essa dor apenas usando as combinações oficialmente suportadas.

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

Instalação ROCm

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

Se toda a instalação terminar bem, você pode digitar rocminfo e algo assim será exibido (cortei apenas as partes mais relevantes em destaque em amarelo):

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

Ambiente Python

A dependência do Python pode ser bastante complicada, por isso é uma boa prática configurar um ambiente adequado. Você pode usar qualquer um Conda ou 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

Sobrescrever HSA

O seguinte é específico para APUs com gráficos integrados. Embora não sejam oficialmente apoiados pelo ROCm, o seguinte provou funcionar.

export HSA_OVERRIDE_GFX_VERSION=9.0.0

Como verificar

Agora, depois de todos os passos complicados, vamos testar se o ROCm está funcionando com o Torch. E você pode ver que o ROCm está “fingindo” ser CUDA para fins 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

Inferência LLM

Vamos começar com algo fácil para nosso computador AI recém-configurado de US$ 300: executar localmente um grande modelo de linguagem. Podemos escolher um dos modos populares de código aberto: LLaMA 2 com parâmetros 7B otimizados para chat.

Além disso, você também pode experimentar pequenos LLMs de Mistral , Qwen , Zéfiro , e Vicunha . Mais LLMs de boa qualidade podem ser encontrados aqui no muito útil “tabela de classificação da arena do chatbot” da UC Berkeley Laboratórios LMSYS .

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

Lhama.cpp

Estaremos usando lhama.cpp , que é inicialmente otimizado para CPU e posteriormente também suporta GPU. Na minha experiência, a inferência LLM funciona bem na CPU, e há pouco a ganhar com uma GPU modesta como as integradas na máquina de IA de US$ 300.

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

Primeiro, você precisa instalar wget e git . E então siga as etapas para compilar e instalar o llama.cpp.

sudo apt-get install build-essential

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

cd llama.cpp

make

Baixar pesos do modelo

Para executar os LLMs em nossa máquina barata, em vez de servidores em nuvem com GPUs caras, precisamos usar uma versão “compactada” dos modelos para que eles caibam no espaço de RAM. Para um exemplo simples, um modelo LLaMA-2 7B possui 7B parâmetros, cada um representado por float16 (2 bytes).

Float 16: 14B bytes ou 14GB que não cabem em nossos 8GB de RAM.

Quantizado para 4 bits: 3,5B bytes ou 3,5GB que agora cabem em nossos 8GB de RAM.

Além disso, o formato do arquivo deve ser guf . Então. em nosso exemplo, você precisa baixar os pesos neste arquivo:

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

Teste no Mini PC AMD

Primeiro, testamos no mini PC AMD e alcançamos cerca de 10 tokens por segundo. Na verdade, isso é bastante decente e você pode conversar com o LLM sem esperar muito.

Configuração do sistema:

AMD Ryzen 5800H
32 GB de RAM

Instrução de linha 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

Teste no Mini PC Intel

Em seguida, testamos em um mini PC Intel e alcançamos cerca de 1,5 tokens por segundo. Isso é um pouco lento para uma sessão de bate-papo frutífera. Não é uma comparação justa, já que o Intel N5105 é claramente mais fraco que o AMD 5800H. Mas esse é o único mini PC Intel que possuo. Se você usar uma CPU Intel mais poderosa (por exemplo, Core i5-1135G7), deverá obter resultados comparáveis. Por favor, relate suas descobertas nos comentários abaixo.

Configuração do sistema:

11ª Geração 4 Núcleos N5105 (até 2,9 Ghz) 4 Núcleos e 4 Threads
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)

Difusão Estável

Instalação

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

E preste atenção também nesta página, em relação ao AMD ROCm

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

Começo 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

Teste de difusão estável 1.5

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

Teste 1

Dica: “cavalo na floresta”

Etapas: 20, amostrador: DDIM, escala CFG: 7, semente: 519288240, tamanho: 512x512, hash do modelo: 6ce0161689, modelo: v1-5-pruned-emaonly, versão: v1.6.0

Tempo gasto: 1 min. 8,3 seg.

Teste de difusão estável XL 1.0

SDXL (resolução máxima 1024x1024) recomenda pelo menos 12 GB de VRAM, então você definitivamente precisa realizar a etapa de preparação 1 para alocar 16 GB de VRAM para iGPU. Portanto, essa tarefa só é possível com o mini PC de US$ 400.

./webui.sh --upcast-sampling

Teste 1:

Dica: “cavalo na floresta”

Etapas: 20, amostrador: DDIM, escala CFG: 7, semente: 1102941451, tamanho: 1024x768, hash do modelo: 31e35c80fc, modelo: sd_xl_base_1.0, versão: v1.6.0

Tempo gasto: 7 min. 41 segundos

Teste 2:

Prompt: “jovem Taylor Swift com capuz vermelho andando a cavalo na floresta”

Alerta negativo: deformidades, deformidade, olhos deformados, dentes deformados, dedos deformados, rosto deformado, mãos deformadas, deformadas

Etapas: 20, amostrador: DDIM, escala CFG: 7, semente: 2960206663, tamanho: 1024x1024, hash do modelo: 31e35c80fc, modelo: sd_xl_base_1.0, versão: v1.6.0

Tempo gasto: 6 min. 12,3 seg.

Windows 11 e AMD/directml

Embora este artigo se concentre em sistemas operacionais Linux, você também pode fazer com que o Stable Diffusion funcione no Windows. Aqui estão meus experimentos:

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

Primeiro, você precisa instalar o Python 3.10.6.

Adicione o diretor Python 3.10.6 ao PATH.

Importante: o caminho Python deve ser o caminho superior
https://realpython.com/add-python-to-path/

Instale o repositório git e git clone

Execute webui-user.bat no explorador de arquivos

Teste 1:

Dica: “cavalo na floresta”
Configurações: DPM++ 2M Karras, 512x512, etapas de amostragem 20
Tempo gasto: 1m19s

Conclusões

Então, você está se divertindo executando seus próprios modelos generativos de IA em seu novo mini PC de US$ 300? Espero que você faça.

Modelos de IA de código aberto executados em dispositivos pessoais são uma das áreas mais interessantes para os criadores, já que nenhum de nós terá o enorme pool de GPU para realmente treinar um modelo fundamental. Isso permitirá uma nova geração de aplicativos que são superinteligentes e, ao mesmo tempo, preservam a privacidade de nossos dados.

Qual o proximo?