Como Executar o Deepseek V3 0324 Localmente (com Passos)

Bem-vindo! Neste tutorial, vou guiá-lo na execução do DeepSeek V3 0324, um poderoso modelo de linguagem com 671 bilhões de parâmetros, em sua máquina local. Abordaremos tudo, desde a preparação até a execução de seus primeiros prompts usando técnicas de quantização dinâmica que equilibram a precisão do modelo com os requisitos de memória.

DeepSeek V3 0324: Quão Bom É?

A atualização de março de 2024 do DeepSeek traz melhorias de desempenho significativas em relação ao modelo V3 anterior:

• Pontuação MMLU-Pro melhorada em +5,3% (para 81,2%)
• Pontuação AIME melhorada em +19,8%
• Pontuação LiveCodeBench melhorada em +10,0%
• Pontuação GPQA melhorada em +9,3%

O modelo original possui impressionantes 671 bilhões de parâmetros, o que significa que precisamos de técnicas de quantização eficientes para executá-lo em hardware de consumo.

Aqui estão as opções de quantização disponíveis para equilibrar o espaço em disco e a precisão:

O modelo original em float8 ocupa 715GB, portanto, essas versões quantizadas oferecem uma economia de espaço significativa!

Tutorial Passo a Passo: Executando o DeepSeek V3 0324 no llama.cpp

Antes de começarmos, vamos entender as configurações ideais para o DeepSeek V3 0324:

• Temperatura: 0.3 (use 0.0 para tarefas de codificação)
• Min_P: 0.01 (ajuda a filtrar tokens improváveis)
• Modelo de chat: <｜Usuário｜>SEU_PROMPT<｜Assistente｜>
• Para quantização de cache KV, use 8bit (não 4bit) para melhor desempenho

Passo 1: Configurar o llama.cpp

Primeiro, precisamos obter e compilar o llama.cpp:

# Atualizar pacotes e instalar dependências necessárias
apt-get update
apt-get install pciutils build-essential cmake curl libcurl4-openssl-dev -y

# Clonar o repositório do llama.cpp
git clone <https://github.com/ggml-org/llama.cpp>

# Compilar com suporte a CUDA para GPU (use -DGGML_CUDA=OFF para apenas CPU)
# Nota: a compilação com CUDA pode levar cerca de 5 minutos
cmake llama.cpp -B llama.cpp/build \\\\
  -DBUILD_SHARED_LIBS=OFF -DGGML_CUDA=ON -DLLAMA_CURL=ON

# Compilar as ferramentas necessárias
cmake --build llama.cpp/build --config Release -j --clean-first --target llama-quantize llama-cli llama-gguf-split

# Copiar as ferramentas compiladas para fácil acesso
cp llama.cpp/build/bin/llama-* llama.cpp/

Passo 2: Baixar o Modelo Quantizado

Instale os pacotes Python necessários e baixe o modelo:

pip install huggingface_hub hf_transfer

# Configurar o ambiente para downloads mais rápidos
import os
os.environ["HF_HUB_ENABLE_HF_TRANSFER"] = "1"

# Baixar o modelo (aqui estamos usando a quantização dinâmica de 2.7bit para equilíbrio)
from huggingface_hub import snapshot_download
snapshot_download(
  repo_id = "unsloth/DeepSeek-V3-0324-GGUF",
  local_dir = "unsloth/DeepSeek-V3-0324-GGUF",
  allow_patterns = ["*UD-Q2_K_XL*"],  # Quantização dinâmica 2.7bit (230GB)
  # Use "*UD-IQ_S*" para quantização dinâmica 1.78bit (151GB) se o espaço for limitado
)

Passo 3: Executar um Prompt de Teste

Vamos testar o modelo com um prompt pedindo para criar um jogo Flappy Bird:

./llama.cpp/llama-cli \\\\
  --model unsloth/DeepSeek-V3-0324-GGUF/UD-Q2_K_XL/DeepSeek-V3-0324-UD-Q2_K_XL-00001-of-00006.gguf \\\\
  --cache-type-k q8_0 \\\\
  --threads 20 \\\\
  --n-gpu-layers 2 \\\\
  -no-cnv \\\\
  --prio 3 \\\\
  --temp 0.3 \\\\
  --min_p 0.01 \\\\
  --ctx-size 4096 \\\\
  --seed 3407 \\\\
  --prompt "<｜Usuário｜>Crie um jogo Flappy Bird em Python. Você deve incluir as seguintes coisas:
1. Você deve usar pygame.
2. A cor de fundo deve ser escolhida aleatoriamente e deve ser um tom claro. Comece com uma cor azul clara.
3. Pressionar a tecla ESPAÇO várias vezes vai acelerar o pássaro.
4. A forma do pássaro deve ser escolhida aleatoriamente como um quadrado, círculo ou triângulo. A cor deve ser escolhida aleatoriamente como uma cor escura.
5. Coloque na parte de baixo uma terra colorida de marrom escuro ou amarelo escolhida aleatoriamente.
6. Mostre uma pontuação no canto superior direito. Aumente se você passar pelos canos e não colidir com eles.
7. Faça canos espaçados aleatoriamente com espaço suficiente. Cores aleatórias como verde escuro ou marrom claro.
8. Quando você perder, mostre a melhor pontuação. Faça o texto aparecer na tela. Pressionar q ou Esc encerrará o jogo. Reiniciar é pressionar a tecla ESPAÇO novamente.
O jogo final deve estar dentro de uma seção de markdown em Python. Verifique seu código para erros e corrija-os antes da seção final de markdown.<｜Assistente｜>"

Aqui estão as explicações dos parâmetros:

• -model: Caminho para o arquivo do modelo
• -cache-type-k q8_0: Usa quantização de 8 bits para cache KV
• -threads 20: Número de threads de CPU (ajuste com base em sua CPU)
• -n-gpu-layers 2: Número de camadas a serem descarregadas para a GPU (ajuste se você tiver problemas de memória)
• no-cnv: Desabilita a convolução por questões de desempenho
• -prio 3: Configuração de prioridade
• -temp 0.3: Configuração de temperatura (use 0.0 para codificação determinística)
• -min_p 0.01: Probabilidade mínima para amostragem de tokens
• -ctx-size 4096: Tamanho da janela de contexto
• -seed 3407: Semente aleatória para reprodutibilidade

Testando Deepseek V3 0324 com o "Desafio Heptágono"

Você pode testar ainda mais as capacidades do seu modelo executando o "Desafio Heptágono", que pede ao modelo para criar uma simulação física complexa com bolas quicando dentro de um heptágono giratório:

./llama.cpp/llama-cli \\\\
  --model unsloth/DeepSeek-V3-0324-GGUF/UD-Q2_K_XL/DeepSeek-V3-0324-UD-Q2_K_XL-00001-of-00006.gguf \\\\
  --cache-type-k q8_0 \\\\
  --threads 20 \\\\
  --n-gpu-layers 2 \\\\
  -no-cnv \\\\
  --prio 3 \\\\
  --temp 0.3 \\\\
  --min_p 0.01 \\\\
  --ctx-size 4096 \\\\
  --seed 3407 \\\\
  --prompt "<｜Usuário｜>Escreva um programa em Python que mostre 20 bolas quicando dentro de um heptágono giratório:
- Todas as bolas têm o mesmo raio.
- Todas as bolas têm um número de 1 a 20.
- Todas as bolas caem do centro do heptágono ao começar.
- As cores são: #f8b862, #f6ad49, #f39800, #f08300, #ec6d51, #ee7948, #ed6d3d, #ec6800, #ec6800, #ee7800, #eb6238, #ea5506, #ea5506, #eb6101, #e49e61, #e45e32, #e17b34, #dd7a56, #db8449, #d66a35
- As bolas devem ser afetadas pela gravidade e atrito, e devem quicar nas paredes giratórias de forma realista. Deve haver colisões entre as bolas.
- O material de todas as bolas determina que a altura do impacto não deve exceder o raio do heptágono, mas deve ser maior que o raio da bola.
- Todas as bolas giram com atrito, os números na bola podem ser usados para indicar a rotação da bola.
- O heptágono está girando ao redor do seu centro, e a velocidade de rotação é de 360 graus a cada 5 segundos.
- O tamanho do heptágono deve ser grande o suficiente para conter todas as bolas.
- Não use a biblioteca pygame; implemente algoritmos de detecção de colisão e resposta de colisão etc. você mesmo. As seguintes bibliotecas de Python são permitidas: tkinter, math, numpy, dataclasses, typing, sys.
- Todo o código deve ser colocado em um único arquivo Python.<｜Assistente｜>"

Otimizando o Desempenho do Deepseek V3 0324

Atenção Rápida: Para decodificação mais rápida, use Atenção Rápida ao compilar o llama.cpp:

-DGGML_CUDA_FA_ALL_QUANTS=ON

Arquitetura do CUDA: Defina sua arquitetura CUDA específica para reduzir os tempos de compilação:

-DCMAKE_CUDA_ARCHITECTURES="80"  # Ajuste de acordo com sua GPU

Ajustando Parâmetros:

• Se você enfrentar problemas de falta de memória, tente reduzir -n-gpu-layers
• Para inferência apenas em CPU, remova o parâmetro -n-gpu-layers
• Ajuste -threads com base em seus núcleos de CPU

Agora você tem o DeepSeek V3 0324 rodando localmente! Para recapitular:

1. Configuramos o llama.cpp com suporte a CUDA
2. Baixamos uma versão quantizada do modelo (quantização dinâmica de 2.7bit)
3. Executamos prompts de teste para verificar as capacidades do modelo
4. Aprendemos sobre configurações ideais e dicas de desempenho

A quantização dinâmica de 2.7bit proporciona um excelente equilíbrio entre espaço em disco (231GB) e precisão do modelo, permitindo que você execute esse modelo de 671B de parâmetros de forma eficiente em seu próprio hardware.

Sinta-se à vontade para experimentar diferentes prompts e parâmetros para aproveitar ao máximo esse poderoso modelo!

Testando a API DeepSeek com Apidog

Se você está desenvolvendo aplicações que utilizam o DeepSeek através de sua API em vez de rodá-lo localmente, o Apidog fornece ferramentas poderosas para desenvolvimento, teste e depuração de API.

Configurando o Apidog para Teste da API DeepSeek

Passo 1: Baixar e Instalar o Apidog

1. Acesse https://apidog.com/download/ para baixar o cliente do Apidog para seu sistema operacional.

2. Instale e inicie o Apidog, depois crie uma conta ou faça login com Google/Github.

3. Quando solicitado, selecione seu papel (por exemplo, "Desenvolvedor Fullstack") e modo de trabalho preferido (por exemplo, "Design de API primeiro").

Passo 2: Criar um Novo Projeto de API para DeepSeek

1. Crie um novo projeto HTTP no Apidog para seus testes da API DeepSeek.
2. Adicione seu(s) endpoint(s) da API DeepSeek ao projeto.

Depurando Respostas em Streaming do DeepSeek

DeepSeek e muitos outros modelos de IA usam Eventos Enviados pelo Servidor (SSE) para respostas em streaming. O Apidog (versão 2.6.49 ou superior) possui suporte integrado para depuração de SSE:

1. Crie e configure seu endpoint da API DeepSeek no Apidog.
2. Envie a requisição para sua API DeepSeek.
3. Se a resposta incluir o cabeçalho Content-Type: text/event-stream, o Apidog processa automaticamente como um evento SSE.
4. Visualize as respostas em streaming em tempo real na visualização de linha do tempo do painel de resposta.

O Apidog possui suporte integrado para formatos populares de modelos de IA, incluindo:

• Formato Compatível com API OpenAI
• Formato Compatível com API Gemini
• Formato Compatível com API Claude

Para o DeepSeek especificamente, o Apidog pode exibir o processo de pensamento do modelo na linha do tempo, fornecendo insights sobre o raciocínio da IA.

Personalizando o Tratamento de Resposta SSE para DeepSeek

Se o formato de resposta do DeepSeek não corresponder às regras de reconhecimento interno do Apidog, você pode:

Configurar regras de extração JSONPath para respostas SSE formatadas em JSON:

• Para uma resposta como: data: {"choices":[{"index":0,"message":{"role":"assistant","content":"H"}}]}
• Use JSONPath: $.choices[0].message.content

Usar scripts pós-processadores para mensagens SSE não-JSON:

• Escreva scripts personalizados para lidar com o formato de dados
• Processar as mensagens de acordo com suas necessidades específicas

Criando Testes Automatizados para APIs DeepSeek

Uma vez que você tenha seu endpoint de API DeepSeek configurado, pode criar testes automatizados no Apidog para garantir que funcione corretamente:

1. Crie cenários de teste para diferentes tipos de prompts no módulo Testes.
2. Adicione validação e afirmações para verificar a estrutura e conteúdo da resposta.
3. Configure o cenário de teste para rodar em diferentes ambientes (por exemplo, desenvolvimento, produção).
4. Configure execuções em lote para testar vários cenários ao mesmo tempo.

Para integração CI/CD, o Apidog CLI permite que você execute esses testes como parte de seu pipeline:

# Instalar Apidog CLI
npm install -g apidog-cli

# Executar cenário de teste
apidog run test-scenario -c <collection-id> -e <environment-id> -k <api-key>

Você pode ler mais sobre como o apidog-cli funciona na Documentação Oficial.

Teste de Desempenho da API DeepSeek

O Apidog também oferece capacidades de teste de desempenho para avaliar como sua API DeepSeek se comporta sob carga:

Crie um cenário de teste que inclua chamadas para sua API DeepSeek.

Configure as configurações do teste de desempenho:

• Defina o número de usuários virtuais (até 100)
• Especifique a duração do teste
• Configure a duração de aumento para simular um aumento gradual de usuários

Execute o teste de desempenho para ver métricas-chave como:

• Throughput médio
• Tempo de resposta médio
• Tempo de resposta máximo/mínimo
• Taxas de erro

Isso é particularmente útil para entender como sua implantação do DeepSeek lida com múltiplas requisições concorrentes.

Conclusão

Agora você tem o DeepSeek V3 0324 rodando localmente e o conhecimento para testar APIs DeepSeek de forma eficaz usando Apidog! Para recapitular:

• Configuramos o llama.cpp com suporte a CUDA
• Baixamos uma versão quantizada do modelo (quantização dinâmica de 2.7bit)
• Executamos prompts de teste para verificar as capacidades do modelo
• Aprendemos como usar Apidog para testar e depurar APIs DeepSeek
• Exploramos dicas de otimização de desempenho tanto para implantação local quanto para teste de APIs

A quantização dinâmica de 2.7bit proporciona um excelente equilíbrio entre espaço em disco (231GB) e precisão do modelo, permitindo que você execute esse modelo de 671B de parâmetros de forma eficiente em seu próprio hardware. Enquanto isso, o Apidog oferece ferramentas poderosas para desenvolver, testar e depurar implementações da API DeepSeek, especialmente com suas capacidades de depuração SSE para respostas em streaming.

Sinta-se à vontade para experimentar diferentes opções de quantização e recursos do Apidog para encontrar a configuração que funciona melhor para suas necessidades específicas!