Cómo ejecutar Deepseek V3 0324 localmente (con pasos)

¡Bienvenido! En este tutorial, te guiaré a través de la ejecución de DeepSeek V3 0324, un potente modelo de lenguaje de 671 mil millones de parámetros, en tu máquina local. Cubriremos todo, desde la preparación hasta la ejecución de tus primeros prompts utilizando técnicas de cuantificación dinámica que equilibran la precisión del modelo con los requisitos de memoria.

DeepSeek V3 0324: ¿Qué tan bueno es?

La actualización de marzo de 2024 de DeepSeek trae mejoras significativas en el rendimiento con respecto al modelo V3 anterior:

• Puntuación MMLU-Pro mejorada en +5.3% (hasta 81.2%)
• Puntuación AIME mejorada en +19.8%
• Puntuación LiveCodeBench mejorada en +10.0%
• Puntuación GPQA mejorada en +9.3%

El modelo original tiene una enorme cantidad de 671 mil millones de parámetros, lo que significa que necesitamos técnicas de cuantificación eficientes para ejecutarlo en hardware de consumo.

Aquí están las opciones de cuantificación disponibles para equilibrar el espacio en disco y la precisión:

El modelo original float8 ocupa 715GB, ¡así que estas versiones cuantificadas ofrecen un ahorro de espacio significativo!

Tutorial Paso a Paso: Ejecutando DeepSeek V3 0324 en llama.cpp

Antes de comenzar, comprendamos la configuración óptima para DeepSeek V3 0324:

• Temperatura: 0.3 (usa 0.0 para tareas de codificación)
• Min_P: 0.01 (ayuda a filtrar tokens poco probables)
• Plantilla de chat: <｜User｜>TU_PROMPT<｜Assistant｜>
• Para la cuantificación de la caché KV, usa 8bit (no 4bit) para un mejor rendimiento

Paso 1: Configurar llama.cpp

Primero, necesitamos obtener y compilar llama.cpp:

# Actualizar paquetes e instalar las dependencias requeridas
apt-get update
apt-get install pciutils build-essential cmake curl libcurl4-openssl-dev -y

# Clonar el repositorio llama.cpp
git clone <https://github.com/ggml-org/llama.cpp>

# Construir con soporte CUDA para GPU (usa -DGGML_CUDA=OFF para solo CPU)
# Nota: la construcción con CUDA puede tardar unos 5 minutos
cmake llama.cpp -B llama.cpp/build \\\\
  -DBUILD_SHARED_LIBS=OFF -DGGML_CUDA=ON -DLLAMA_CURL=ON

# Construir las herramientas necesarias
cmake --build llama.cpp/build --config Release -j --clean-first --target llama-quantize llama-cli llama-gguf-split

# Copiar las herramientas construidas para facilitar el acceso
cp llama.cpp/build/bin/llama-* llama.cpp/

Paso 2: Descargar el Modelo Cuantificado

Instala los paquetes de Python requeridos y descarga el modelo:

pip install huggingface_hub hf_transfer

# Configurar el entorno para descargas más rápidas
import os
os.environ["HF_HUB_ENABLE_HF_TRANSFER"] = "1"

# Descargar el modelo (aquí estamos usando la cuantificación dinámica de 2.7bit para el equilibrio)
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*"],  # Dinámico 2.7bit (230GB)
  # Usa "*UD-IQ_S*" para Dinámico 1.78bit (151GB) si el espacio es limitado
)

Paso 3: Ejecutar un Prompt de Prueba

Probemos el modelo con un prompt que le pide que cree un juego de 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 "<｜User｜>Crea un juego de Flappy Bird en Python. Debes incluir estas cosas:
1. Debes usar pygame.
2. El color de fondo debe elegirse al azar y es un tono claro. Comienza con un color azul claro.
3. Presionar ESPACIO varias veces acelerará el pájaro.
4. La forma del pájaro debe elegirse al azar como un cuadrado, círculo o triángulo. El color debe elegirse al azar como un color oscuro.
5. Coloca en la parte inferior un poco de tierra coloreada como marrón oscuro o amarillo elegido al azar.
6. Haz una puntuación que se muestre en la parte superior derecha. Incrementa si pasas las tuberías y no las golpeas.
7. Haz tuberías espaciadas al azar con suficiente espacio. Coloréalas al azar como verde oscuro o marrón claro o un tono gris oscuro.
8. Cuando pierdas, muestra la mejor puntuación. Haz que el texto esté dentro de la pantalla. Presionar q o Esc saldrá del juego. Reiniciar es presionar ESPACIO nuevamente.
El juego final debe estar dentro de una sección de markdown en Python. Verifica tu código en busca de errores y corrígelos antes de la sección final de markdown.<｜Assistant｜>"

Aquí están las explicaciones de los parámetros:

• -model: Ruta al archivo del modelo
• -cache-type-k q8_0: Utiliza la cuantificación de 8 bits para la caché KV
• -threads 20: Número de hilos de CPU (ajusta según tu CPU)
• -n-gpu-layers 2: Número de capas para descargar a la GPU (ajusta si tienes problemas de memoria)
• no-cnv: Desactiva la convolución por razones de rendimiento
• -prio 3: Configuración de prioridad
• -temp 0.3: Configuración de temperatura (usa 0.0 para codificación determinista)
• -min_p 0.01: Probabilidad mínima para el muestreo de tokens
• -ctx-size 4096: Tamaño de la ventana de contexto
• -seed 3407: Semilla aleatoria para la reproducibilidad

Probando Deepseek V3 0324 con el "Desafío del Heptágono"

Puedes probar aún más las capacidades de tu modelo ejecutando el "Desafío del Heptágono", que le pide al modelo que cree una simulación física compleja con bolas que rebotan dentro de un heptágono giratorio:

./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 "<｜User｜>Escribe un programa en Python que muestre 20 bolas rebotando dentro de un heptágono giratorio:
- Todas las bolas tienen el mismo radio.
- Todas las bolas tienen un número del 1 al 20.
- Todas las bolas caen desde el centro del heptágono al comenzar.
- Los colores son: #f8b862, #f6ad49, #f39800, #f08300, #ec6d51, #ee7948, #ed6d3d, #ec6800, #ec6800, #ee7800, #eb6238, #ea5506, #ea5506, #eb6101, #e49e61, #e45e32, #e17b34, #dd7a56, #db8449, #d66a35
- Las bolas deben verse afectadas por la gravedad y la fricción, y deben rebotar en las paredes giratorias de manera realista. También debe haber colisiones entre las bolas.
- El material de todas las bolas determina que su altura de rebote de impacto no excederá el radio del heptágono, pero será mayor que el radio de la bola.
- Todas las bolas giran con fricción, los números en la bola se pueden usar para indicar el giro de la bola.
- El heptágono gira alrededor de su centro, y la velocidad de giro es de 360 grados por 5 segundos.
- El tamaño del heptágono debe ser lo suficientemente grande como para contener todas las bolas.
- No uses la biblioteca pygame; implementa algoritmos de detección de colisiones y respuesta a colisiones, etc. por ti mismo. Se permiten las siguientes bibliotecas de Python: tkinter, math, numpy, dataclasses, typing, sys.
- Todos los códigos deben colocarse en un solo archivo de Python.<｜Assistant｜>"

Optimización del Rendimiento de Deepseek V3 0324

Flash Attention: Para una decodificación más rápida, usa Flash Attention al compilar llama.cpp:

-DGGML_CUDA_FA_ALL_QUANTS=ON

Arquitectura CUDA: Establece tu arquitectura CUDA específica para reducir los tiempos de compilación:

-DCMAKE_CUDA_ARCHITECTURES="80"  # Ajusta para tu GPU

Ajuste de Parámetros:

• Si tienes problemas de falta de memoria, intenta reducir -n-gpu-layers
• Para la inferencia solo de CPU, elimina el parámetro -n-gpu-layers
• Ajusta -threads según los núcleos de tu CPU

¡Ahora tienes DeepSeek V3 0324 ejecutándose localmente! Para recapitular:

1. Configuramos llama.cpp con soporte CUDA
2. Descargamos una versión cuantificada del modelo (cuantificación dinámica de 2.7bit)
3. Ejecutamos prompts de prueba para verificar las capacidades del modelo
4. Aprendimos sobre la configuración óptima y los consejos de rendimiento

La cuantificación dinámica de 2.7bit proporciona un excelente equilibrio entre el espacio en disco (231GB) y la precisión del modelo, lo que te permite ejecutar este modelo de 671B parámetros de manera eficiente en tu propio hardware.

¡Siéntete libre de experimentar con diferentes prompts y parámetros para aprovechar al máximo este potente modelo!

Probando la API de DeepSeek con Apidog

Si estás desarrollando aplicaciones que usan DeepSeek a través de su API en lugar de ejecutarlo localmente, Apidog proporciona herramientas potentes para el desarrollo, prueba y depuración de API.

Configurando Apidog para la Prueba de la API de DeepSeek

Paso 1: Descargar e Instalar Apidog

1. Visita https://apidog.com/download/ para descargar el cliente de Apidog para tu sistema operativo.

2. Instala e inicia Apidog, luego crea una cuenta o inicia sesión con Google/Github.

3. Cuando se te solicite, selecciona tu rol (por ejemplo, "Desarrollador Fullstack") y el modo de trabajo preferido (por ejemplo, "Diseño de API primero").

Paso 2: Crear un Nuevo Proyecto de API para DeepSeek

1. Crea un nuevo proyecto HTTP en Apidog para la prueba de tu API de DeepSeek.
2. Agrega tus puntos finales de la API de DeepSeek al proyecto.

Depuración de Respuestas de Transmisión desde DeepSeek

DeepSeek y muchos otros modelos de IA usan Eventos Enviados por el Servidor (SSE) para respuestas de transmisión. Apidog (versión 2.6.49 o superior) tiene soporte integrado para la depuración de SSE:

1. Crea y configura tu punto final de la API de DeepSeek en Apidog.
2. Envía la solicitud a tu API de DeepSeek.
3. Si la respuesta incluye el encabezado Content-Type: text/event-stream, Apidog lo procesa automáticamente como un evento SSE.
4. Visualiza las respuestas de transmisión en tiempo real en la vista de línea de tiempo del panel de respuesta.

Apidog tiene soporte integrado para formatos de modelos de IA populares, incluyendo:

• Formato Compatible con la API de OpenAI
• Formato Compatible con la API de Gemini
• Formato Compatible con la API de Claude

Para DeepSeek específicamente, Apidog puede mostrar el proceso de pensamiento del modelo en la línea de tiempo, proporcionando información sobre el razonamiento de la IA.

Personalización del Manejo de Respuestas SSE para DeepSeek

Si el formato de respuesta de DeepSeek no coincide con las reglas de reconocimiento integradas de Apidog, puedes:

Configurar reglas de extracción JSONPath para respuestas SSE con formato JSON:

• Para una respuesta como: data: {"choices":[{"index":0,"message":{"role":"assistant","content":"H"}}]}
• Usa JSONPath: $.choices[0].message.content

Usar scripts de post-procesador para mensajes SSE no JSON:

• Escribe scripts personalizados para manejar el formato de datos
• Procesa los mensajes de acuerdo con tus requisitos específicos

Creación de Pruebas Automatizadas para las API de DeepSeek

Una vez que tengas configurado tu punto final de la API de DeepSeek, puedes crear pruebas automatizadas en Apidog para asegurarte de que funcione correctamente:

1. Crea escenarios de prueba para diferentes tipos de prompts en el módulo Pruebas.
2. Agrega validación y aserciones para verificar la estructura y el contenido de la respuesta.
3. Configura el escenario de prueba para que se ejecute con diferentes entornos (por ejemplo, desarrollo, producción).
4. Configura ejecuciones por lotes para probar múltiples escenarios a la vez.

Para la integración de CI/CD, Apidog CLI te permite ejecutar estas pruebas como parte de tu pipeline:

# Instalar Apidog CLI
npm install -g apidog-cli

# Ejecutar escenario de prueba
apidog run test-scenario -c <collection-id> -e <environment-id> -k <api-key>

Puedes leer más sobre cómo funciona apidog-cli en la Documentación Oficial.

Pruebas de Rendimiento de la API de DeepSeek

Apidog también ofrece capacidades de prueba de rendimiento para evaluar cómo se comporta tu API de DeepSeek bajo carga:

Crea un escenario de prueba que incluya llamadas a tu API de DeepSeek.

Configura los ajustes de la prueba de rendimiento:

• Establece el número de usuarios virtuales (hasta 100)
• Especifica la duración de la prueba
• Configura la duración de la rampa de subida para simular un aumento gradual de usuarios

Ejecuta la prueba de rendimiento para ver métricas clave como:

• Rendimiento promedio
• Tiempo de respuesta promedio
• Tiempo de respuesta máximo/mínimo
• Tasas de error

Esto es particularmente útil para comprender cómo tu implementación de DeepSeek maneja múltiples solicitudes concurrentes.

Conclusión

¡Ahora tienes tanto DeepSeek V3 0324 ejecutándose localmente como el conocimiento para probar las API de DeepSeek de manera efectiva usando Apidog! Para recapitular:

• Configuramos llama.cpp con soporte CUDA
• Descargamos una versión cuantificada del modelo (cuantificación dinámica de 2.7bit)
• Ejecutamos prompts de prueba para verificar las capacidades del modelo
• Aprendimos cómo usar Apidog para probar y depurar las API de DeepSeek
• Exploramos consejos de optimización de rendimiento tanto para la implementación local como para las pruebas de API

La cuantificación dinámica de 2.7bit proporciona un excelente equilibrio entre el espacio en disco (231GB) y la precisión del modelo, lo que te permite ejecutar este modelo de 671B parámetros de manera eficiente en tu propio hardware. Mientras tanto, Apidog te brinda herramientas potentes para desarrollar, probar y depurar implementaciones de la API de DeepSeek, especialmente con sus capacidades de depuración SSE para respuestas de transmisión.

¡Siéntete libre de experimentar con diferentes opciones de cuantificación y características de Apidog para encontrar la configuración que mejor se adapte a tus necesidades específicas!