Tutoriel DeepSeek-Coder-V2 : exemples, installation, benchmarks

Qu’est-ce que DeepSeek-Coder-V2 ?

DeepSeek-Coder-V2 est un modèle de langage de code open source basé sur une Mixture-of-Experts (MoE) qui rivalise avec GPT-4 sur les tâches de code. Conçu pour accompagner les développeurs, ce modèle apporte plusieurs atouts clés :

• Multilingue : entraîné à la fois sur du code et du langage naturel dans plusieurs langues, dont l’anglais et le chinois, ce qui le rend utile pour des équipes de développement réparties à l’international.
• Polyvalent : prend en charge plus de 338 langages de programmation, pour répondre à des environnements et besoins très variés.
• À grande échelle : pré-entraîné sur des milliers de milliards de tokens de code et de texte, ce qui renforce sa compréhension et sa génération dans des scénarios de programmation variés.
• Plusieurs tailles : disponible en différentes tailles, pour choisir celle qui correspond le mieux à vos ressources de calcul et à vos contraintes projet.

Vous pouvez accéder au modèle sur le site de DeepSeek, qui propose une API payante et un chat. Le code source est disponible sur GitHub et l’article de recherche est hébergé sur arXiv.

Les modèles sont hébergés sur Hugging Face ; toutefois, il faut un matériel de niveau recherche pour exécuter localement ces modèles compte tenu de leur taille.

Benchmarks de DeepSeek-Coder-V2

Voyons comment DeepSeek-Coder-V2 se comporte sur différents benchmarks et comment il se compare à des modèles comme GPT-4 Turbo, Gemini 1.5 Pro, Claude 3 Opus, LLaMA 3‑70B et Codestral.

Source : Qihao Zhu et al.

HumanEval

Le benchmark HumanEval mesure l’aptitude à générer du code en vérifiant si le code produit réussit des tests unitaires précis. DeepSeek-Coder-V2 y affiche d’excellents résultats, avec une précision de 90,2 %. Cela souligne sa capacité à générer des extraits de code fonctionnels et exacts, y compris dans des cas complexes.

MBPP+

Le benchmark MBPP+ évalue la compréhension de code, c’est‑à‑dire la capacité du modèle à appréhender les structures et la sémantique. DeepSeek-Coder-V2 y excelle également, avec une précision de 76,2 %, signe d’une solide compréhension du sens et de la fonctionnalité du code.

MATH

Le benchmark MATH teste le raisonnement mathématique dans le code. DeepSeek-Coder-V2 conserve son avance avec 75,7 % de précision, indiquant sa maîtrise des opérations et de la logique mathématiques intégrées au code, un enjeu clé de nombreuses tâches de programmation.

GSM8K

GSM8K porte sur la résolution de problèmes arithmétiques de niveau primaire, évaluant des compétences plus larges que la simple génération de code. DeepSeek-Coder-V2 arrive juste derrière Claude 3 Opus avec une précision de 94,9 %, démontrant sa capacité à comprendre et résoudre des problèmes formulés en langage naturel.

Aider

Le benchmark Aider évalue la capacité du modèle à assister et suggérer du code. DeepSeek-Coder-V2 arrive en tête avec 73,7 % de précision, signe d’un fort potentiel comme outil d’assistance en temps réel pour les développeurs.

LiveCodeBench

LiveCodeBench mesure la génération de code en conditions réalistes. DeepSeek-Coder-V2 atteint 43,4 % de précision (deuxième après GPT‑4‑Turbo‑0409), montrant sa capacité à produire du code fonctionnel et exploitable en pratique.

SWE Bench

Le benchmark SWE‑Bench évalue spécifiquement les modèles d’IA sur des tâches d’ingénierie logicielle : génération de code, débogage et compréhension de concepts complexes. Dans ce cadre, DeepSeek-Coder-V2 obtient un score de 12,7 : une performance solide mais qui n’est pas la meilleure. Il est devancé par GPT‑4‑Turbo‑0409 (18,7) et Gemini‑1.5‑Pro (18,3), supérieurs sur ces tâches. Cependant, DeepSeek-Coder-V2 surpasse Claude‑3‑Opus (11,7), Llama‑3‑70B (2,7) et Codestral, ce qui en fait une option fiable, sans être de tout premier plan, pour les usages d’ingénierie logicielle selon ce benchmark.

Comment fonctionne DeepSeek-Coder-V2

DeepSeek-Coder-V2 s’appuie sur le modèle DeepSeek‑V2 et utilise une architecture Mixture‑of‑Experts (MoE) sophistiquée pour atteindre de hautes performances sur les tâches liées au code. Le modèle orchestre plusieurs experts, chacun spécialisé sur des tâches différentes, et sélectionne dynamiquement l’expert le plus pertinent selon l’entrée. Cette approche renforce l’efficacité et la précision.

L’entraînement de DeepSeek-Coder-V2 s’articule autour de plusieurs éléments clés. Il est pré‑entraîné sur un vaste jeu de données composé à 60 % de code source, 10 % de corpus mathématique et 30 % de langage naturel, pour un total de 10,2 billions de tokens. Cette diversité lui permet de bien comprendre et générer du code. Le corpus de code source comprend 1 170 milliards de tokens issus de GitHub et CommonCrawl, couvrant 338 langages, un élargissement majeur par rapport aux modèles précédents.

Après le pré‑entraînement, le modèle est affiné avec un jeu d’instructions spécialisé couvrant le code, les mathématiques et le langage général. Ce processus améliore sa réponse aux invites en langage naturel et en fait un assistant réellement utile.

Pour celles et ceux qui s’intéressent à l’architecture sous‑jacente, le modèle DeepSeek‑V2, sur lequel repose DeepSeek‑Coder‑V2, introduit des innovations comme le Multi‑head Latent Attention (MLA) et le framework DeepSeekMoE. Elles contribuent à une inférence efficace et à un entraînement plus économique, comme détaillé dans l’article DeepSeek‑V2 disponible sur arXiv.

Bien démarrer avec DeepSeek-Coder-V2

Plusieurs options s’offrent à vous pour utiliser DeepSeek‑Coder‑V2. Vous pouvez l’exécuter en local via la bibliothèque transformers de Hugging Face. Notez toutefois que ces modèles sont très volumineux et exigent des ressources de calcul importantes.

Autre possibilité : DeepSeek propose une API payante et une interface de chat en ligne, similaire à ChatGPT. Le chat de DeepSeek peut même exécuter du code HTML et JavaScript directement dans la fenêtre ! Une fonctionnalité assez innovante — je n’ai vu quelque chose d’approchant que dans les Artifacts du modèle Claude 3.5 Sonnet. Pour cet article, nous utiliserons le chat pour nos exemples.

DeepSeek-Coder-V2 : exemples d’utilisation

Pour le premier exemple, je demande au modèle de programmer le jeu de la vie de Conway en HTML et JavaScript. J’ai utilisé l’invite : « Pouvez‑vous écrire le jeu de la vie de Conway en HTML ? » Voici la réponse :

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>

Nous pouvons aussi cliquer sur le bouton « Run HTML » à la fin de la réponse pour exécuter le jeu directement dans la fenêtre de chat.

Capture d’écran de l’auteur.

Ensuite, j’ai demandé au modèle de créer un site dynamique du jeu me permettant de choisir la configuration initiale du plateau. Voici le résultat : cela fonctionne de manière très fluide.

Capture d’écran de l’auteur.

Pour le dernier exemple, j’ai testé le modèle sur un problème difficile de Project Euler — le problème « jumping frog ». Voici le code généré par le modèle :

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))

Ce script prendrait une éternité à s’exécuter, j’ai donc demandé au modèle de l’optimiser et j’ai obtenu la sortie suivante :

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))

J’ai laissé tourner le code optimisé pendant une demi‑heure, sans obtenir de résultat. Bien que je pense que les approches soient correctes, la difficulté réside dans l’optimisation. Étant donné que seules 328 personnes ont réussi ce problème, il n’est pas surprenant que le modèle n’y soit pas parvenu.

Conclusion

DeepSeek-Coder-V2 s’impose comme une contribution majeure aux assistants de codage open source, avec des performances compétitives face aux modèles propriétaires établis.

Pour en tirer le meilleur parti, formulez des invites claires et spécifiques. N’hésitez pas non plus à faire remonter vos retours aux développeurs si vous rencontrez des bugs.

Pour aller plus loin sur les assistants de codage en IA, je vous recommande cet épisode du podcast DataFramed : The Future of Programming with Kyle Daigle, COO at GitHub.