DeepSeek-Coder-V2 Tutorial: Exemplos, instalação, padrões de referência

O que é o DeepSeek-Coder-V2?

O DeepSeek-Coder-V2 é um código aberto Mixture-of-Experts (MoE) de código aberto que rivaliza com o desempenho do GPT-4 em tarefas específicas de código. Projetado para ajudar os desenvolvedores, esse modelo traz vários recursos importantes para a tabela:

• Multilíngue: Treinado em código e linguagem natural em vários idiomas, inclusive inglês e chinês, o que o torna versátil para equipes de desenvolvimento globais.
• Versátil: Oferece suporte a uma ampla variedade de mais de 338 linguagens de programação, atendendo a diversos ambientes e necessidades de codificação.
• Em grande escala: Pré-treinado em trilhões de tokens de código e dados de texto, o que aprimora seus recursos de compreensão e geração em vários cenários de codificação.
• Vários tamanhos: Os modelos estão disponíveis em vários tamanhos, permitindo que os desenvolvedores escolham o tamanho do modelo que melhor se adapte aos seus recursos computacionais e requisitos de projeto.

Você pode acessar o modelo no site da DeepSeekvocê pode acessar o modelo no site da DeepSeek, que oferece acesso pago à API e um bate-papo. O código-fonte está disponível no GitHub e o artigo de pesquisa está hospedado no arXiv.

Os modelos estão hospedados em Huggingface-No entanto, você precisa de hardware de nível de pesquisa para executar os modelos localmente devido ao seu tamanho.

DeepSeek-Coder-V2 Benchmarks

Vamos ver o desempenho do DeepSeek-Coder-V2 nos benchmarks e como ele se compara a modelos como o GPT-4 Turbo, Gemini 1.5 Pro, Claude 3 Opus, LLaMA 3-70Be Codestral.

Fonte: Qihao Zhu et. al

HumanEval

O benchmark HumanEval mede a proficiência na geração de código, avaliando se o código gerado passa em testes de unidade específicos. O DeepSeek-Coder-V2 demonstra um desempenho excepcional nesse benchmark, alcançando uma precisão de 90,2%. Esse resultado ressalta a capacidade do modelo de gerar trechos de código funcionais e precisos, mesmo em cenários complexos.

MBPP+

O benchmark MBPP+ se concentra na compreensão do código, avaliando a capacidade de um modelo de entender e interpretar as estruturas e a semântica do código. O DeepSeek-Coder-V2 novamente se destaca nessa área, alcançando uma precisão de 76,2%, destacando sua forte compreensão do significado e da funcionalidade do código.

MATEMÁTICA

O benchmark MATH testa as habilidades de raciocínio matemático de um modelo dentro do código. O DeepSeek-Coder-V2 mantém sua liderança com uma precisão de 75,7%, indicando sua proficiência em lidar com operações matemáticas e lógica incorporada no código, um aspecto crucial de muitas tarefas de programação.

GSM8K

O benchmark GSM8K concentra-se na solução de problemas de matemática do ensino fundamental, avaliando as habilidades de solução de problemas mais amplas de um modelo, além da geração pura de código. O DeepSeek-Coder-V2 vem logo atrás do Claude 3 Opus com uma precisão de 94,9%, demonstrando sua capacidade de entender e resolver problemas matemáticos apresentados em linguagem natural.

Ajudante

O benchmark Aider avalia a capacidade de um modelo de fornecer assistência e sugestões de código. O DeepSeek-Coder-V2 lidera com uma precisão de 73,7%, sugerindo seu potencial como uma ferramenta valiosa para desenvolvedores que buscam orientação e suporte em tempo real durante tarefas de codificação.

LiveCodeBench

O benchmark LiveCodeBench mede o desempenho da geração de código em cenários do mundo real. O DeepSeek-Coder-V2 atinge uma precisão de 43,4% (segundo depois do GPT-4-Turbo-0409), demonstrando sua capacidade de gerar códigos funcionais e utilizáveis em contextos práticos.

SWE Bench Benchmark

​O benchmark SWE-Bench avalia especificamente os modelos de IA em sua capacidade de executar tarefas de engenharia de software, como geração de código, depuração e compreensão de conceitos complexos de programação. Nesse contexto, o DeepSeek-Coder-V2 obteve uma pontuação de 12,7, o que indica um desempenho sólido, mas não a liderança do grupo. Ele fica atrás do GPT-4-Turbo-0409 (18,7) e do Gemini-1.5-Pro (18,3), que apresentam recursos superiores nessas tarefas. No entanto, o DeepSeek-Coder-V2 ainda superou modelos como Claude-3-Opus (11,7), Llama-3-70B (2,7) e Codestral, sugerindo que é uma opção confiável, mas não de primeira linha, para aplicativos de engenharia de software com base nesse benchmark.

Como o DeepSeek-Coder-V2 funciona

O DeepSeek-Coder-V2 baseia-se no modelo DeepSeek-V2, utilizando uma sofisticada arquitetura MoE (Mixture-of-Experts) para obter alto desempenho em tarefas específicas de código. Esse modelo utiliza vários modelos de especialistas, cada um especializado em diferentes tarefas de codificação, e seleciona dinamicamente o especialista mais relevante com base no código de entrada. Essa abordagem aumenta a eficiência e a precisão do modelo.

O processo de treinamento do DeepSeek-Coder-V2 envolve vários componentes críticos. Ele é pré-treinado em um conjunto de dados abrangente que inclui 60% de código-fonte, 10% de corpus matemático e 30% de corpus de linguagem natural, totalizando 10,2 trilhões de tokens. Esse conjunto de dados diversificado permite que o modelo compreenda e gere códigos de forma eficaz. O conjunto de dados de código-fonte inclui 1.170 bilhões de tokens provenientes do GitHub e do CommonCrawl, abrangendo 338 linguagens de programação, uma expansão significativa em relação aos modelos anteriores.

Após o pré-treinamento, o modelo passa por um ajuste fino com um conjunto de dados de instruções especializadas que inclui instruções de codificação, matemática e linguagem geral. Esse processo melhora a capacidade de resposta do modelo às solicitações de linguagem natural, o que transforma o modelo em um assistente útil.

Para os interessados na arquitetura subjacente, o modelo DeepSeek-V2, no qual o DeepSeek-Coder-V2 se baseia, apresenta inovações como a MLA (Multi-head Latent Attention) e a estrutura DeepSeekMoE. Essas inovações contribuem para a inferência eficiente e o treinamento econômico, conforme detalhado no artigo do DeepSeek-V2 disponível em arXiv.

Primeiros passos com o DeepSeek-Coder-V2

Há várias maneiras de você começar a usar o modelo DeepSeek-Coder-V2. Você pode executar o modelo localmente, acessando-o por meio da biblioteca biblioteca transformers da Hugging Face. No entanto, lembre-se de que os modelos são bastante grandes e exigem recursos computacionais significativos.

Como alternativa, o DeepSeek oferece uma API paga e uma interface de bate-papo on-line semelhante ao ChatGPT. O bate-papo on-line do DeepSeek também pode executar códigos HTML e JavaScript diretamente na janela de bate-papo! Esse recurso é bastante inovador - só vi algo semelhante no Artefatos do Claude 3.5 Sonnet modelo. Para este artigo, usaremos o recurso de bate-papo para nossos exemplos.

DeepSeek-Coder-V2: Exemplo de uso

No primeiro exemplo, pedirei ao modelo que programe o jogo da vida de Conway em HTML e JavaScript. Perguntei ao modelo a seguinte questão: "Você pode escrever o jogo da vida de Conway em HTML?" Aqui está a resposta:

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>

Você também pode clicar no botão "Executar HTML" no final da resposta para obter o jogo da vida diretamente em nossa janela de bate-papo.

Captura de tela feita pelo autor.

Em seguida, pedi ao modelo que criasse um site dinâmico do jogo em que eu pudesse escolher a configuração inicial do tabuleiro. Este é o resultado, e ele funciona perfeitamente.

Captura de tela feita pelo autor.

Em nosso último exemplo, testei o modelo em um disco rígido Projeto Euler o problema "sapo saltador" o problema do "sapo saltador". Aqui está o código gerado pelo 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))

Esse script demoraria muito para ser executado, então pedi ao modelo que o otimizasse e obtive o seguinte 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))

Deixei o código otimizado ser executado por meia hora, mas ele ainda não produziu nenhum resultado. Embora eu ache que as soluções estão corretas, o desafio está em otimizar o código. Considerando que apenas 328 pessoas conseguiram resolver esse problema, não é de surpreender que o modelo não tenha conseguido resolvê-lo.

Conclusão

O DeepSeek-Coder-V2 é uma adição notável ao campo crescente de assistentes de codificação de código aberto, demonstrando desempenho competitivo com modelos proprietários estabelecidos.

Para aproveitar ao máximo o DeepSeek-Coder-V2, siga as práticas recomendadas, fornecendo prompts claros e específicos. Também incentivo você a fornecer feedback aos desenvolvedores se encontrar algum erro.

Se você quiser saber mais sobre assistentes de codificação de IA, recomendo que ouça este podcast do DataFrame: O futuro da programação com Kyle Daigle, COO do GitHub.