Executando DeepSeek-R1-671B-Q4_K_M em Xeon com 1 a 2 Arc A770

• Documento de início rápido do IPEX-LLM portable zip/tgz para quem quer rodar llama.cpp diretamente em GPUs Intel, e os pacotes mais recentes já cobrem a execução do DeepSeek-R1-671B-Q4_K_M em Xeon com 1 ou 2 Arc A770
• O ambiente-alvo inclui Windows e Linux, com orientações para executar modelos GGUF em Intel Core Ultra / 11ª a 14ª geração e GPUs Intel Arc Série A / Série B
• O fluxo básico consiste em preparar o modelo GGUF localmente e executá-lo com llama-cli usando opções como -ngl 99, -c 2500, -n 2048 e --temp 0
• O FlashMoE, exclusivo para Linux, é uma CLI ajustada para rodar GGUFs MoE da linha DeepSeek V3/R1, exigindo para DeepSeek V3/R1 380 GB de memória CPU, de 1 a 8 Arc A770 e 500 GB de disco
• Em ambientes com várias GPUs Intel misturadas, todas as GPUs são usadas por padrão; em combinações de iGPU/dGPU, é possível selecionar a GPU com ONEAPI_DEVICE_SELECTOR ou desativar a checagem com SYCL_DEVICE_CHECK=0

---

Executando llama.cpp com portable zip/tgz

• O llama.cpp portable zip é um pacote baseado em ipex-llm para executar llama.cpp diretamente em GPUs Intel
• O fluxo parte do uso de portable zip/tgz para reduzir instalação manual, e o portable zip mais recente aborda a execução do DeepSeek-R1-671B-Q4_K_M em Xeon com 1 ou 2 Arc A770
• Faixa de hardware validada:
  • Processadores Intel Core Ultra
  • Processadores Intel Core de 11ª a 14ª geração
  • GPU Intel Arc Série A
  • GPU Intel Arc Série B

Início rápido no Windows

• Recomenda-se atualizar o driver da GPU Intel para a versão mais recente

• Baixe e extraia o IPEX-LLM llama.cpp portable zip para Windows na release v2.3.0-nightly

• No cmd, vá até a pasta extraída

  • cd /d PATH\\TO\\EXTRACTED\\FOLDER

• Usuários com múltiplas GPUs podem aplicar a configuração de seleção de GPU antes da execução

• Executando um modelo GGUF

  • Antes de executar, é preciso baixar ou copiar um modelo GGUF da comunidade para um diretório local
  • O modelo de exemplo é DeepSeek-R1-Distill-Qwen-7B-Q4_K_M.gguf de bartowski/DeepSeek-R1-Distill-Qwen-7B-GGUF
  • Substitua o caminho do modelo pela localização real e execute llama-cli.exe

  llama-cli.exe -m PATH\TO\DeepSeek-R1-Distill-Qwen-7B-Q4_K_M.gguf -p "A conversation between User and Assistant. The user asks a question, and the Assistant solves it. The assistant first thinks about the reasoning process in the mind and then provides the user with the answer. The reasoning process and answer are enclosed within <think> </think> and <answer> </answer> tags, respectively, i.e., <think> reasoning process here </think> <answer> answer here </answer>. User: Question:The product of the ages of three teenagers is 4590. How old is the oldest? a. 18 b. 19 c. 15 d. 17 Assistant: <think>" -n 2048  -t 8 -e -ngl 99 --color -c 2500 --temp 0 -no-cnv
  

  • A saída de exemplo mostra 1 dispositivo SYCL Intel Arc A770 Graphics, cache KV, SYCL compute buffer, configuração de sampler e informações de desempenho de geração de tokens

Início rápido no Linux

• Recomenda-se verificar a versão do driver da GPU e, se necessário, instalar seguindo o guia de instalação do driver Intel client GPU

• Baixe e extraia o IPEX-LLM llama.cpp portable tgz para Linux na release v2.3.0-nightly

• No terminal, vá até a pasta extraída

  • cd /PATH/TO/EXTRACTED/FOLDER

• Ao usar o llama.cpp portable zip no Linux, não se deve dar source no oneAPI

• Executando um modelo GGUF

  • Assim como no Windows, prepare localmente um modelo GGUF da comunidade, como DeepSeek-R1-Distill-Qwen-7B-Q4_K_M.gguf
  • Substitua o caminho do modelo pela localização real e execute ./llama-cli

  ./llama-cli -m /PATH/TO/DeepSeek-R1-Distill-Qwen-7B-Q4_K_M.gguf -p "A conversation between User and Assistant. The user asks a question, and the Assistant solves it. The assistant first thinks about the reasoning process in the mind and then provides the user with the answer. The reasoning process and answer are enclosed within <think> </think> and <answer> </answer> tags, respectively, i.e., <think> reasoning process here </think> <answer> answer here </answer>. User: Question:The product of the ages of three teenagers is 4590. How old is the oldest? a. 18 b. 19 c. 15 d. 17 Assistant: <think>" -n 2048  -t 8 -e -ngl 99 --color -c 2500 --temp 0 -no-cnv
  

  • A saída de exemplo inclui a lista de dispositivos SYCL, llama_kv_cache_init, llama_init_from_model, cadeia de samplers e informações de execução como n_ctx = 2528, n_batch = 4096 e n_predict = 2048

Executando DeepSeek V3/R1 com FlashMoE

• FlashMoE é uma ferramenta de linha de comando construída sobre llama.cpp e ajustada para executar modelos MoE como DeepSeek V3/R1

• Atualmente está disponível na plataforma Linux

• Modelos MoE GGUF testados:

  • DeepSeek-V3-Q4_K_M
  • DeepSeek-V3-Q6_K
  • DeepSeek-R1-Q4_K_M.gguf
  • DeepSeek-R1-Q6_K
  • DeepSeek-V3-0324-GGUF/Q4_K_M
  • DeepSeek-V3-0324-GGUF/Q6_K

• Outros modelos MoE GGUF também são suportados

• Requisitos e observações

  • Requisitos para executar DeepSeek V3/R1:
    • 380 GB de memória CPU
    • 1 a 8 Arc A770

    • 500 GB de disco

      • Modelos maiores ou outras precisões podem exigir mais recursos
      • Em plataformas com 1 Arc A770, é preciso reduzir o comprimento de contexto para evitar OOM; no exemplo, isso é feito adicionando -c 1024 ao fim do comando
      • Em plataformas dual-socket, é possível obter melhor desempenho de decodificação ativando SNC (Sub-NUMA Clustering) na BIOS e prefixando o comando com numactl --interleave=all
      • Ao usar FlashMoE, também não se deve dar source no oneAPI

• Execução via CLI

  • O modelo de exemplo é DeepSeek-R1-Q4_K_M.gguf, e deve-se apontar para o caminho do primeiro arquivo dividido

  ./flash-moe -m /PATH/TO/DeepSeek-R1-Q4_K_M-00001-of-00009.gguf --prompt "What's AI?" -no-cnv
  

  • A saída de exemplo mostra informações de execução como buffer KV de 8 dispositivos SYCL, pipeline parallelism enabled, nós/splits do grafo, n_threads = 48, n_ctx = 4096 e n_batch = 4096

• Execução em modo serving

  ./flash-moe -m /PATH/TO/DeepSeek-R1-Q4_K_M-00001-of-00009.gguf --serve -n 512 -np 2 -c 4096
  

  • -n é o número de tokens a prever, -np é o número de sequências de decodificação paralela e -c é o tamanho total do contexto
  • Os valores podem ser ajustados conforme os requisitos
  • O recurso de serving está disponível a partir da build nightly v2.3.0
  • A saída de exemplo inclui n_slots = 2, n_ctx_slot = 2048 de cada slot, carregamento do modelo, chat template e o servidor aguardando em http://127.0.0.1:8080

Seleção de múltiplas GPUs e erros de SYCL

• Detecção de dispositivos SYCL diferentes

  • Se houver GPUs diferentes misturadas, pode ocorrer o erro Detected different sycl devices
  • O exemplo mostra a detecção conjunta de 2 Arc A770 e 1 iGPU Intel UHD Graphics 770
  • Quando as GPUs não são iguais, as tarefas são distribuídas conforme a memória do dispositivo; no exemplo, a iGPU recebe 2/3 da carga computacional, causando grande perda de desempenho
  • Há duas opções
    • Desativar a iGPU para obter o melhor desempenho
    • Desativar a checagem e usar todos os dispositivos

  set SYCL_DEVICE_CHECK=0
  export SYCL_DEVICE_CHECK=0
  

• Especificando quais GPUs usar

  • Se houver várias GPUs Intel, o llama.cpp roda em todas por padrão
  • Para usar apenas GPUs específicas, defina a variável de ambiente ONEAPI_DEVICE_SELECTOR antes de iniciar o comando do llama.cpp
  • Windows:

  set ONEAPI_DEVICE_SELECTOR=level_zero:0
  set ONEAPI_DEVICE_SELECTOR="level_zero:0;level_zero:1"
  

  • Linux:

  export ONEAPI_DEVICE_SELECTOR=level_zero:0
  export ONEAPI_DEVICE_SELECTOR="level_zero:0;level_zero:1"
  

  • Para detalhes sobre seleção de múltiplas GPUs, consulte multi_gpus_selection.md

Opções de desempenho e verificação de assinatura

• Immediate command lists

  • SYCL_PI_LEVEL_ZERO_USE_IMMEDIATE_COMMANDLISTS determina se serão usadas immediate command lists no envio de trabalho para a GPU
  • Em geral isso pode melhorar o desempenho, mas pode haver exceções; por isso, recomenda-se testar com a variável ativada e desativada para encontrar o melhor resultado
  • Windows:

  set SYCL_PI_LEVEL_ZERO_USE_IMMEDIATE_COMMANDLISTS=1
  

  • Linux:

  export SYCL_PI_LEVEL_ZERO_USE_IMMEDIATE_COMMANDLISTS=1
  

  • Para mais detalhes, consulte a documentação da Intel sobre Level Zero immediate command lists

• Verificação de assinatura do portable zip/tgz 2.2.0

  • A versão 2.2.0 do portable zip/tgz permite verificar a assinatura com openssl
  • Antes da verificação, o sistema deve ter openssl instalado

  openssl cms -verify -in <portable-zip-or-tgz-file-name>.pkcs1.sig -inform DER -content <portable-zip-or-tgz-file-name> -out nul -noverify
  

[GN⁺]

Opiniões no Hacker News

• Como essa configuração tem VRAM insuficiente, será necessário mover muitos dados entre a memória da CPU e a da GPU, então é bem provável que o desempenho não seja muito bom.
  Ainda assim, existe um modelo quantizado do DeepSeek-R1 com menos de 256 GB, e não é uma versão destilada: https://unsloth.ai/blog/deepseekr1-dynamic
  É difícil quantificar a diferença em relação ao DSR1 FP8 completo, mas até o modelo quantizado em ~Q2 foi mais utilizável do que eu esperava.
  Outro modelo que vale mencionar é o DeepSeek v2.5. Ele tem menos parâmetros que o V3/R1, mas ainda exige quantização agressiva para rodar em hardware de consumo. Alguém criou uma recentemente: https://www.reddit.com/r/LocalLLaMA/comments/1irwx6q/deepsee...
  Há margem para considerar o DeepSeek v2.5 melhor que o Llama 3 70B, então acho que é um modelo que quem quer rodar inferência local deveria conhecer melhor.

  • Testei a quantização R1 da Unsloth em dois Xeon Gold 5218 com 384 GB de DDR4-2666, usando só cerca de metade dos canais de memória, então não era uma configuração ideal.
    Com IQ2_XXS / 183 GB e contexto de 16k, usando apenas CPU, o processamento de prompt ficou em 3 tokens/s e a resposta em 1,44 tokens/s; com CPU + NVIDIA RTX com 70 GB de VRAM, o processamento de prompt ficou em 4,74 tokens/s e a resposta em 1,87 tokens/s.
    Acho que seria mais útil se a Unsloth lançasse uma quantização parecida para o DeepSeek V3. Como não precisa de tokens de raciocínio, mesmo com os mesmos tokens/s ele poderia ser mais rápido no geral.
  • Pretendo rodar o v2.5, e espero que ele continue tão consistente quanto o v3.5 mesmo com uma quantização tão pequena.
    Estou usando Q2_K_XL e, pessoalmente, acho bom o suficiente. O ponto em que fica abaixo do FP8 é em escrita criativa; se você inserir algumas vezes o mesmo prompt de história e comparar com o FP8, a diferença aparece.
    Em programação, 1,58 bit claramente comete mais erros do que Q2XXS ou Q2_K_XL.
  • Atualmente passa de 8 tokens/s, e há uma demonstração neste post: https://www.linkedin.com/posts/jasondai_run-671b-deepseek-r1...

• https://github.com/intel/ipex-llm/blob/main/docs/mddocs/Quic...
  Os requisitos para mais de 8 tokens/s são 380 GB de memória de CPU, de 1 a 8 placas ARC A770 e 500 GB de disco.

  • Também dá para ver a demonstração no post de Jason Dai: https://www.linkedin.com/posts/jasondai_with-the-latest-ipex...
  • Fico curioso se uma única Intel Arc A770 é suficiente para chegar a 8 tokens/s ou mais.
  • Fico curioso sobre quanto custaria aproximadamente essa configuração.
    Acho que ficaria abaixo de US$ 10 mil, e também não me lembro de ter visto números de tokens/s.

• Fiquei curioso sobre qual é exatamente o papel do Xeon nessa situação. Há algum motivo para não usar outro processador x86?

  • Acho que é porque a maioria das placas-mãe que não são Xeon não tem canais de memória suficientes para instalar tanta memória usando DIMMs que se consegue comprar comercialmente
  • DDR4 UDIMM vai até 32 GB por módulo, DDR5 UDIMM vai até 64 GB por módulo, e placas-mãe que não são Xeon normalmente têm no máximo 4 slots UDIMM, então o limite por nó é 128 GB/256 GB
    Placas-mãe de servidor têm até 16 slots DIMM por soquete e suportam RDIMM/LRDIMM, permitindo instalar mais módulos e módulos de maior capacidade
    No pico da pandemia, chegaram a ser lançados UDIMMs de 128 GB
  • Não há muitas placas-mãe, além de Epyc, que ofereçam RAM total suficiente a um preço razoável. Para teste/desenvolvimento, dá para comprar bem barato um servidor Dell antigo, usado, com Xeon dual-socket e 512 GB de RAM
    Pesquisando por alguns minutos agora, é fácil achar opções por menos de US$ 1.500 antes de adicionar placa de vídeo ou SSD, e também aparecem configurações com 1024 GB de RAM por menos de US$ 2.000
    No mínimo, para instalar várias placas PCI-Express x16 3.0 em velocidade plena, também é preciso ter pistas PCIe suficientes, algo difícil de encontrar em placas-mãe Intel workstation de soquete único
    Dá para citar alguns exemplos de configurações relativamente baratas com 512 GB de RAM. Vão consumir muita energia e fazer barulho, mas a mesma abordagem vale para outros hardwares x86-64, como hp ou supermicro. Normalmente é uma configuração com 16 x 32 GB DDR4 DIMM
    https://www.ebay.com/itm/186991103256?_skw=dell+poweredge+t6...
    https://www.ebay.com/itm/235978320621?_skw=dell+poweredge+r7...
    https://www.ebay.com/itm/115819389940?_skw=dell+poweredge+r7...

• Fico me perguntando por que não lançam uma GPU com muita RAM, maior porém mais lenta. Assim daria para carregar modelos maiores e ainda manter um preço acessível

  • Para que isso serviria? Para games não seria, e, se for para AI, o jeito da Nvidia hoje é cobrar por isso
    A demanda por GPUs para AI é maior que a oferta, e por trás de grande parte dessa demanda há dinheiro superaquecido que consegue subsídios, empréstimos e investimentos. A fabricante de GPUs pode capturar esse dinheiro
    Infelizmente, VRAM é um critério perfeito para separar uso leve de uso com dinheiro. É parecido com SSO ter virado o critério perfeito para separar planos corporativos de não corporativos, com o imposto do SSO embutido
  • Se fizessem isso, haveria menos incentivo para comprar GPUs mais caras
  • É claro que é possível fabricar uma GPU com mais VRAM, mas não há concorrência suficiente para obrigar isso. O modelo atual é muito mais lucrativo
  • Você não viu as notícias sobre o AMD Halo Strix? Em AI, ele é mais de duas vezes mais rápido que a Nvidia 4090 e foi lançado na semana passada

• Será que a DeepSeek aprendeu com a OpenAI a dar nome aos modelos?

  • A convenção é meio estranha, mas é bastante padrão no setor como um todo, especialmente em modelos GGUF. Significa que 671B parâmetros foram quantizados para 4 bits
    O termo K_M parece ser mais específico do GGUF e descreve a estratégia concreta de quantização

• O texto deveria ter um pouco mais de informação. Quero entender por que todos os números de TPS estão mascarados com x, que desempenho dá para esperar dessa configuração e como ela se compara às configurações recentes e populares de workstation dual Epyc

  • Atualmente, em Xeon de 5ª geração (EMR) com 2 soquetes, sai mais de 8 TPS
  • Se houver um link para essa receita recente e popular de workstation dual Epyc, eu gostaria de ver

• Pelo fato de terem ocultado o valor de tokens/s na saída de exemplo, com certeza deve estar rodando muito bem.

• Fora da Nvidia, parecem existir algumas opções para rodar inferência de LLMs e Stable Diffusion. Intel Arc, Apple série M e, agora, AMD Ryzen AI Max também.
  É claro que rodar na Nvidia é o mais otimizado, mas como é difícil conseguir placas Nvidia com bastante VRAM a um preço razoável, continuo pensando também em hardware não Nvidia.
  Se você não tem interesse em treinamento nem fine-tuning e quer apenas inferência, será que essas soluções são realmente utilizáveis? Também fico curioso para saber se isso é possível em uma máquina Linux.

  • Se for para levar a sério, o certo é ir de Nvidia.
    Este texto, na prática, está mais para um lembrete da Intel dizendo “nós também fabricamos GPUs”, e a placa de entrada em si é boa, mas o ecossistema está muito atrasado.
    Sinceramente, esta é uma área em que é difícil fazer direito economizando no orçamento.

• Acho que, quando surgirem APUs para IA, o interesse por GPUs vai esfriar rapidamente.
  Dá para usar 512 GB ou 128 GB de RAM com uma AMD Halo Strix ou uma APU Apple M3 Studio; então por que comprar uma Nvidia 4090 cara?
  A Nvidia manteve os preços altos e o desempenho baixo pelo maior tempo possível, e só agora a concorrência está chegando. A Intel também pode criar uma APU com um monte de RAM.
  Espero que a Nvidia esteja ficando um pouco nervosa.