Tutorial de DeepSeek-Coder-V2: Ejemplos, instalación, puntos de referencia

¿Qué es DeepSeek-Coder-V2?

DeepSeek-Coder-V2 es un código abierto Mezcla de Expertos (MoE) que compite con el rendimiento de GPT-4 en tareas específicas de código. Diseñado para ayudar a los desarrolladores, este modelo aporta varias características clave:

• Multilingüe: Entrenado tanto en código como en lenguaje natural en varios idiomas, incluidos el inglés y el chino, lo que lo hace versátil para equipos de desarrollo globales.
• Versátil: Admite una amplia gama de más de 338 lenguajes de programación, lo que satisface diversos entornos y necesidades de codificación.
• A gran escala: Preentrenado en billones de tokens de datos de código y texto, lo que mejora su capacidad de comprensión y generación en diversos escenarios de codificación.
• Múltiples tamaños: Los modelos están disponibles en varios tamaños, lo que permite a los desarrolladores elegir el tamaño del modelo que mejor se adapte a sus recursos informáticos y a los requisitos del proyecto.

Puedes acceder al modelo en sitio web de DeepSeekofrecen acceso de pago a la API y un chat. El código fuente está disponible en GitHub y el artículo de investigación está alojado en arXiv.

Los modelos están alojados en Huggingface-sin embargo, necesitas un hardware de nivel de investigación para ejecutar los modelos localmente debido a su tamaño.

Puntos de referencia de DeepSeek-Coder-V2

Veamos qué tal se comporta DeepSeek-Coder-V2 en las pruebas de rendimiento y cómo se compara con modelos como GPT-4 Turbo, Géminis 1.5 Pro, Claude 3 Opus, LLaMA 3-70By Codestral.

Fuente: Qihao Zhu et. al

HumanEval

El parámetro HumanEval mide la competencia en la generación de código evaluando si el código generado supera pruebas unitarias específicas. DeepSeek-Coder-V2 demuestra un rendimiento excepcional en esta prueba de referencia, alcanzando una precisión del 90,2%. Este resultado subraya la capacidad del modelo para generar fragmentos de código funcionales y precisos, incluso en escenarios complejos.

MBPP+

El punto de referencia MBPP+ se centra en la comprensión del código, evaluando la capacidad de un modelo para comprender e interpretar las estructuras y la semántica del código. DeepSeek-Coder-V2 vuelve a sobresalir en este ámbito, alcanzando una precisión del 76,2%, lo que pone de relieve su gran comprensión del significado y la funcionalidad del código.

MATH

La prueba MATH evalúa la capacidad de razonamiento matemático de un modelo dentro del código. DeepSeek-Coder-V2 mantiene su liderazgo con una precisión del 75,7%, lo que indica su destreza en el manejo de las operaciones matemáticas y la lógica incrustada en el código, un aspecto crucial de muchas tareas de programación.

GSM8K

La prueba GSM8K se centra en la resolución de problemas matemáticos de primaria, evaluando la capacidad de resolución de problemas de un modelo más allá de la mera generación de código. DeepSeek-Coder-V2 se sitúa justo detrás de Claude 3 Opus con una precisión del 94,9%, lo que demuestra su capacidad para comprender y resolver problemas matemáticos presentados en lenguaje natural.

Ayudante

El parámetro Ayudante evalúa la capacidad de un modelo para proporcionar ayuda y sugerencias sobre el código. DeepSeek-Coder-V2 lidera con una precisión del 73,7%, lo que sugiere su potencial como herramienta valiosa para los desarrolladores que buscan orientación y ayuda en tiempo real durante las tareas de codificación.

LiveCodeBench

El banco de pruebas LiveCodeBench mide el rendimiento de la generación de código en escenarios reales. DeepSeek-Coder-V2 alcanza una precisión del 43,4% (segundo tras GPT-4-Turbo-0409), lo que demuestra su capacidad para generar código funcional y utilizable en contextos prácticos.

Punto de referencia SWE

​El punto de referencia SWE-Bench evalúa específicamente los modelos de IA en función de su capacidad para realizar tareas de ingeniería de software, como la generación de código, la depuración y la comprensión de conceptos complejos de programación. En este contexto, DeepSeek-Coder-V2 obtuvo una puntuación de 12,7, lo que indica un rendimiento sólido, pero no a la cabeza. Queda por detrás de GPT-4-Turbo-0409 (18,7) y Gemini-1,5-Pro (18,3), que muestran capacidades superiores en estas tareas. Sin embargo, DeepSeek-Coder-V2 sigue superando a modelos como Claude-3-Opus (11,7), Llama-3-70B (2,7) y Codestral, lo que sugiere que es una opción fiable pero no de primer nivel para aplicaciones de ingeniería de software basadas en este punto de referencia.

Cómo funciona DeepSeek-Coder-V2

DeepSeek-Coder-V2 se basa en los cimientos del modelo DeepSeek-V2, utilizando una sofisticada arquitectura de Mezcla de Expertos (MoE) para lograr un alto rendimiento en tareas específicas de código. Este modelo aprovecha múltiples modelos de expertos, cada uno especializado en diferentes tareas de codificación, y selecciona dinámicamente al experto más relevante en función del código de entrada. Este enfoque mejora la eficacia y la precisión del modelo.

El proceso de entrenamiento de DeepSeek-Coder-V2 implica varios componentes críticos. Está preentrenado en un amplio conjunto de datos compuesto por un 60% de código fuente, un 10% de corpus matemático y un 30% de corpus de lenguaje natural, con un total de 10,2 billones de tokens. Este variado conjunto de datos permite al modelo comprender y generar código con eficacia. El conjunto de datos de código fuente incluye 1.170.000 millones de tokens procedentes de GitHub y CommonCrawl, que abarcan 338 lenguajes de programación, una ampliación significativa respecto a modelos anteriores.

Tras el preentrenamiento, el modelo se somete a un ajuste fino con un conjunto de datos de instrucciones especializadas que incluye instrucciones de codificación, matemáticas y de lenguaje general. Este proceso mejora la capacidad de respuesta del modelo a las indicaciones del lenguaje natural, lo que transforma al modelo en un asistente útil.

Para los interesados en la arquitectura subyacente, el modelo DeepSeek-V2, en el que se basa DeepSeek-Coder-V2, introduce innovaciones como la Atención Latente Multicabezal (MLA) y el marco DeepSeekMoE. Estas innovaciones contribuyen a una inferencia eficaz y a un entrenamiento económico, como se detalla en el documento DeepSeek-V2 disponible en arXiv.

Primeros pasos con DeepSeek-Coder-V2

Hay varias formas de empezar a utilizar el modelo DeepSeek-Coder-V2. Puedes ejecutar el modelo localmente accediendo a él a través de la biblioteca transformers de Hugging Face. Sin embargo, ten en cuenta que los modelos son bastante grandes y requieren importantes recursos informáticos.

Como alternativa, DeepSeek ofrece una API de pago y una interfaz de chat online similar a ChatGPT. El chat en línea de DeepSeek también puede ejecutar código HTML y JavaScript ¡directamente en la ventana del chat! Esta función es bastante innovadora; sólo he visto algo similar en el programa Artefactos del Soneto Claude 3.5 de Claude. En este artículo, utilizaremos la función de chat para nuestros ejemplos.

DeepSeek-Coder-V2: Ejemplo de uso

Para el primer ejemplo, pediré al modelo que programe el juego de la vida de Conway en HTML y JavaScript. Le pregunté al modelo lo siguiente "¿Puedes escribir el juego de la vida de Conway en HTML?" He aquí la respuesta:

Certainly! Below is a simple implementation of Conway's Game of Life using HTML, CSS, and JavaScript. This version will display the grid in an HTML table and update it every second.

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Conway's Game of Life</title>
    <style>
        table {
            border-collapse: collapse;
        }
        td {
            width: 10px;
            height: 10px;
            border: 1px solid #ccc;
        }
        .alive {
            background-color: black;
        }
        .dead {
            background-color: white;
        }
    </style>
</head>
<body>
    <h1>Conway's Game of Life</h1>
    <table id="grid"></table>
    <script>
        const N = 50; // Grid size
        let grid = createGrid(N);
        let intervalId;
        function createGrid(N) {
            let grid = new Array(N);
            for (let i = 0; i < N; i++) {
                grid[i] = new Array(N);
                for (let j = 0; j < N; j++) {
                    grid[i][j] = Math.random() > 0.7 ? 1 : 0;
                }
            }
            return grid;
        }
        function renderGrid(grid) {
            const table = document.getElementById('grid');
            table.innerHTML = '';
            for (let i = 0; i < N; i++) {
                const row = table.insertRow();
                for (let j = 0; j < N; j++) {
                    const cell = row.insertCell();
                    cell.classList.add(grid[i][j] ? 'alive' : 'dead');
                }
            }
        }
        function updateGrid(grid) {
            const newGrid = grid.map(row => row.slice());
            for (let i = 0; i < N; i++) {
                for (let j = 0; j < N; j++) {
                    const aliveNeighbors = countAliveNeighbors(grid, i, j);
                    if (grid[i][j] === 1) {
                        newGrid[i][j] = aliveNeighbors === 2 || aliveNeighbors === 3 ? 1 : 0;
                    } else {
                        newGrid[i][j] = aliveNeighbors === 3 ? 1 : 0;
                    }
                }
            }
            return newGrid;
        }
        function countAliveNeighbors(grid, x, y) {
            let count = 0;
            for (let i = -1; i <= 1; i++) {
                for (let j = -1; j <= 1; j++) {
                    if (i === 0 && j === 0) continue;
                    const newX = (x + i + N) % N;
                    const newY = (y + j + N) % N;
                    count += grid[newX][newY];
                }
            }
            return count;
        }
        function startGame() {
            intervalId = setInterval(() => {
                grid = updateGrid(grid);
                renderGrid(grid);
            }, 1000);
        }
        renderGrid(grid);
        startGame();
    </script>
</body>
</html>

También podemos pulsar el botón "Ejecutar HTML" al final de la respuesta para obtener el juego de la vida directamente en nuestra ventana de chat.

Captura de pantalla del autor.

A continuación, pedí al modelo que creara un sitio web dinámico del juego en el que yo pudiera elegir la configuración del tablero inicial. Este es el resultado, y funciona a la perfección.

Captura de pantalla del autor.

Para nuestro último ejemplo, he probado el modelo en un duro Proyecto Euler el problema "la rana saltarina "rana saltarina". Aquí tienes el código generado por el modelo:

import numpy as np

MOD = 10**9


def matrix_power(matrix, n):
    result = np.identity(len(matrix), dtype=int)

    while n > 0:
        if n % 2 == 1:
            result = np.dot(result, matrix) % MOD

        matrix = np.dot(matrix, matrix) % MOD
        n //= 2

    return result


def fib_matrix(n):
    if n == 0:
        return 0
    elif n == 1:
        return 1

    A = np.array([[1, 1, 1], [1, 0, 0], [0, 1, 0]], dtype=int)
    A_power = matrix_power(A, n - 3)
    initial_vector = np.array([2, 1, 1])

    return np.dot(A_power, initial_vector)[0] % MOD


def S(L):
    result = 0

    for n in range(1, L + 1):
        f_n = fib_matrix(n)
        result = (result + f_n**3) % MOD

    return result


# Compute S(10**14) % 10**9
print(S(10**14))

Este script tardaba siglos en ejecutarse, así que pedí al modelo que lo optimizara y obtuve el siguiente resultado:

import numpy as np

MOD = 10**9


def matrix_power(matrix, n):
    result = np.identity(len(matrix), dtype=int)

    while n > 0:
        if n % 2 == 1:
            result = np.dot(result, matrix) % MOD
        matrix = np.dot(matrix, matrix) % MOD
        n //= 2

    return result


def fib_matrix(n):
    if n == 0:
        return 0
    elif n == 1:
        return 1

    A = np.array([[1, 1, 1], [1, 0, 0], [0, 1, 0]], dtype=int)
    A_power = matrix_power(A, n - 3)
    initial_vector = np.array([2, 1, 1])

    return np.dot(A_power, initial_vector)[0] % MOD


def find_pisano_period(m):
    previous, current = 0, 1
    for i in range(m * m):
        previous, current = current, (previous + current) % m
        if previous == 0 and current == 1:
            return i + 1


def S(L):
    pisano_period = find_pisano_period(MOD)
    period_sum = 0

    for n in range(1, pisano_period + 1):
        f_n = fib_matrix(n)
        period_sum = (period_sum + f_n**3) % MOD

    full_periods, remainder = divmod(L, pisano_period)
    result = (full_periods * period_sum) % MOD

    for n in range(1, remainder + 1):
        f_n = fib_matrix(n)
        result = (result + f_n**3) % MOD

    return result


# Compute S(10**14) % 10**9
print(S(10**14))

Dejé que el código optimizado funcionara durante media hora, pero seguía sin producir ningún resultado. Aunque creo que las soluciones son correctas, el reto está en optimizar el código. Dado que sólo 328 personas han conseguido resolver este problema, no es sorprendente que el modelo no pudiera resolverlo.

Conclusión

DeepSeek-Coder-V2 es una adición notable al creciente campo de los asistentes de codificación de código abierto, demostrando un rendimiento competitivo con los modelos propietarios establecidos.

Para sacar el máximo partido a DeepSeek-Coder-V2, sigue las mejores prácticas proporcionando indicaciones claras y específicas. También te animo a que envíes comentarios a los desarrolladores si encuentras algún error.

Si queremos saber más sobre los asistentes de codificación de IA, recomiendo escuchar este podcast de DataFramed: El futuro de la programación con Kyle Daigle, COO de GitHub.