Dans le domaine de la génération de code, les modèles de la classe 7B paramètres deviennent privilégiés par les développeurs. Aujourd'hui, nous comparons deux modèles populaires : le tout nouveau Qwen2.5-7B-Instruct d'Alibaba et le DeepSeek-7B de DeepSeek, à travers des tests pratiques pour évaluer leurs performances réelles en génération de code.

Qwen2.5-7B-Instruct, membre important de la série Qwen2.5, possède 7 milliards de paramètres et adopte une conception de poids entièrement activés. Ce modèle supporte un contexte ultra-long de 128K, réalisant d'excellentes performances dans de nombreux tests de référence, atteignant notamment un taux de réussite de plus de 85% dans le test de code HumanEval, comparable à CodeLlama-34B. Il supporte également la programation multilingue et les appels d'outils, et sa licence open-source conviviale en fait un choix idéal pour les applications en milieu professionnel.

1. Configuration et déploiement de l'environnement de test

1.1 Déploiement de Qwen2.5-7B-Instruct

Nous utilisons le moteur d'inférence vLLM avec l'interface Open-WebUI pour le déploiement, selon les étapes suivantes :

# Démarrage du service du modèle avec vLLM
python -m vllm.entrypoints.openai.api_server \
    --model Qwen/Qwen2.5-7B-Instruct \
    --trust-remote-code \
    --served-model-name qwen2.5-7b-instruct \
    --max-model-len 8192

Une fois le déploiement terminé, attendez quelques minutes que vLLM charge le modèle et démarre le service Open-WebUI. Vous pouvez accéder à l'interface via le navigateur, ou modifier le port 8888 du service Jupyter en port 7860 pour y accéder.

1.2 Déploiement de DeepSeek-7B

À titre de comparaison, nous déployons également le modèle DeepSeek-7B :

# Déploiement du modèle DeepSeek-7B
python -m vllm.entrypoints.openai.api_server \
    --model deepseek-ai/deepseek-llm-7b \
    --trust-remote-code \
    --served-model-name deepseek-7b \
    --max-model-len 4096

1.3 Configuration de l'environnement de test

Matériel de test :

• GPU : NVIDIA RTX 4090 (24GB)
• Mémoire vive : 32 Go DDR4
• Système : Ubuntu 20.04 LTS

Environnement logiciel :

• vLLM 0.4.1
• Open-WebUI 0.1.0
• Python 3.9

2. Tests comparatifs de génération de code

2.1 Test d'implémentation d'un algorithme de base

Nous testons d'abord la capacité des deux modèles à implémenter des algorithmes fondamentaux :

Sujet du test : Implémenter un algorithme de tri rapide.

# Code généré par Qwen2.5-7B-Instruct
def tri_rapide(tableau):
    if len(tableau) <= 1:
        return tableau
    pivot = tableau[len(tableau) // 2]
    gauche = [x for x in tableau if x < pivot]
    milieu = [x for x in tableau if x == pivot]
    droite = [x for x in tableau if x > pivot]
    return tri_rapide(gauche) + milieu + tri_rapide(droite)

# Cas de test
tab_test = [3, 6, 8, 10, 1, 2, 1]
print(tri_rapide(tab_test))

# Code généré par DeepSeek-7B
def quicksort(liste):
    if len(liste) <= 1:
        return liste
    else:
        pivot = liste[0]
        inferieurs = [x for x in liste[1:] if x <= pivot]
        superieurs = [x for x in liste[1:] if x > pivot]
        return quicksort(inferieurs) + [pivot] + quicksort(superieurs)

# Cas de test
nombres = [3, 6, 8, 10, 1, 2, 1]
nombres_tries = quicksort(nombres)
print(nombres_tries)

Analyse des résultats : Les deux modèles implémentent correctement l'algorithme de tri rapide, mais avec des approches légèrement différentes :

• Qwen choisit un élément central comme pivot, offrant une meilleure stabilité.
• DeepSeek choisit le premier élément, produisant une implémentation plus concise.
• Tous deux fournissent des cas de test et le code est directement exécutable.

2.2 Test de script de traitement de données

Sujet du test : Écrire un script Python pour lire un fichier CSV et calculer la moyenne de chaque colonne.

# Code généré par Qwen2.5-7B-Instruct
import pandas as pd

def calculer_moyennes_colonnes(chemin_csv):
    """
    Lit un fichier CSV et calcule la moyenne de chaque colonne.
    
    Args:
        chemin_csv (str): Chemin vers le fichier CSV.
    
    Returns:
        dict: Dictionnaire associant le nom de la colonne à sa moyenne.
    """
    try:
        df = pd.read_csv(chemin_csv)
        moyennes = df.mean().to_dict()
        return moyennes
    except Exception as e:
        print(f"Erreur lors du traitement du fichier : {e}")
        return {}

# Exemple d'utilisation
if __name__ == "__main__":
    resultat = calculer_moyennes_colonnes("donnees.csv")
    for col, moy in resultat.items():
        print(f"{col}: {moy:.2f}")

# Code généré par DeepSeek-7B
import csv
from statistics import mean

def moyennes_colonnes_csv(nom_fichier):
    with open(nom_fichier, 'r') as fichier:
        lecteur = csv.DictReader(fichier)
        donnees = list(lecteur)
        
    moyennes = {}
    for colonne in lecteur.fieldnames:
        try:
            valeurs = [float(ligne[colonne]) for ligne in donnees if ligne[colonne].strip()]
            if valeurs:
                moyennes[colonne] = mean(valeurs)
        except ValueError:
            continue
            
    return moyennes

# Exemple d'utilisation
resultat_moyennes = moyennes_colonnes_csv('exemple.csv')
print(resultat_moyennes)

Analyse des résultats :

• Qwen utilise la bibliothèque pandas, offrant un code plus concis et professionnel.
• DeepSeek utilise les bibliothèques standard csv et statistics, sans dépendances tierces.
• Les deux gèrent les exceptions et les valeurs vides.
• Le code de Qwen possède des commentaires plus complets, incluant la description des paramètres et la valeur de retour.

2.3 Test de code lié au développement Web

Sujet du test : Créer un point de terminaison d'API REST avec Flask renvoyant les informations utilisateur.

# Code généré par Qwen2.5-7B-Instruct
from flask import Flask, jsonify, request

app = Flask(__name__)

# Base de données utilisateur simulée
utilisateurs = {
    1: {"nom": "Alice", "email": "alice@exemple.com", "age": 25},
    2: {"nom": "Bob", "email": "bob@exemple.com", "age": 30}
}

@app.route('/api/utilisateurs/<id_utilisateur>', methods=['GET'])
def obtenir_utilisateur(id_utilisateur):
    utilisateur = utilisateurs.get(id_utilisateur)
    if utilisateur:
        return jsonify({
            "statut": "succes",
            "donnees": utilisateur
        })
    else:
        return jsonify({
            "statut": "erreur",
            "message": "Utilisateur non trouvé"
        }), 404

@app.route('/api/utilisateurs', methods=['GET'])
def lister_utilisateurs():
    return jsonify({
        "statut": "succes",
        "donnees": utilisateurs
    })

if __name__ == '__main__':
    app.run(debug=True)</id_utilisateur>

# Code généré par DeepSeek-7B
from flask import Flask, jsonify

app = Flask(__name__)

utilisateurs = [
    {"id": 1, "nom": "Jean Dupont", "email": "jean@exemple.com"},
    {"id": 2, "nom": "Marie Martin", "email": "marie@exemple.com"}
]

@app.route('/utilisateur/<id_utilisateur>', methods=['GET'])
def obtenir_utilisateur(id_utilisateur):
    utilisateur = next((u for u in utilisateurs if u['id'] == id_utilisateur), None)
    if utilisateur:
        return jsonify(utilisateur)
    return jsonify({"erreur": "Utilisateur non trouvé"}), 404

if __name__ == '__main__':
    app.run(port=5000)</id_utilisateur>

Analyse des résultats :

• L'API de Qwen est plus complète, avec plusieurs points de terminaison et un format de réponse standardisé.
• L'implémentation de DeepSeek est plus concise, mais ses fonctionnalités sont relativement basiques.
• Les deux gèrent correctement le cas où l'utilisateur n'existe pas.
• L'architecture du code de Qwen est plus adaptée à une utilisation en production.

3. Évaluation des performances et de l'efficacité

3.1 Comparaison de la qualité du code

Nous évaluons la qualité du code généré selon plusieurs dimensions :

3.2 Test de la vitesse de réponse

Test de la vitesse de génération du code dans un environnement matériel identique :

DeepSeek-7B possède un léger avantage en termes de vitesse de génération, mais le code produit par Qwen2.5-7B est de qualité supérieure.

3.3 Capacité de génération de longs morceaux de code

Test de la capacité à générer de longs segments de code :

# Pipeline de traitement de données généré par Qwen2.5-7B
class PipelineTraitementDonnees:
    def __init__(self):
        self.processeurs = []
        self.validateurs = []
    
    def ajouter_processeur(self, fonction_processeur):
        """Ajoute une fonction de traitement des données."""
        self.processeurs.append(fonction_processeur)
        return self
    
    def ajouter_validateur(self, fonction_validateur):
        """Ajoute une fonction de validation des données."""
        self.validateurs.append(fonction_validateur)
        return self
    
    def traiter(self, donnees):
        """Exécute le pipeline de traitement des données."""
        # Validation des données
        for validateur in self.validateurs:
            if not validateur(donnees):
                raise ValueError("Échec de la validation des données")
        
        # Traitement des données
        for processeur in self.processeurs:
            donnees = processeur(donnees)
        
        return donnees
    
    def traiter_par_lot(self, liste_donnees):
        """Traite les données par lot."""
        resultats = []
        for donnee in liste_donnees:
            try:
                resultat = self.traiter(donnee)
                resultats.append(resultat)
            except Exception as e:
                print(f"Échec du traitement : {e}")
                resultats.append(None)
        return resultats

# Exemple d'utilisation
pipeline = (PipelineTraitementDonnees()
    .ajouter_validateur(lambda x: x is not None)
    .ajouter_processeur(lambda x: x * 2)
    .ajouter_processeur(lambda x: x + 10))

resultat = pipeline.traiter(5)
print(resultat)  # Sortie : 20

Qwen2.5-7B est capable de générer du code plus complexe et structuré, incluant des définitions de classe, des appels de méthode en chaîne, la gestion des exceptions et d'autres fonctionnalités avancées.

4. Expérience utilisateur et recommandations

4.1 Avantages de Qwen2.5-7B-Insstruct

1. Qualité de code élevée : Le code généré s'approche d'un niveau professionnel, avec des commentaires complets et une gestion des erreurs soignée.
2. Compréhension puissante : Il est capable de comprendre avec précision des besoins complexes et de générer du code correspondant aux exigences.
3. Support multilingue : Il offre de bonnes performances dans plusieurs lagnages de programmation, dont Python, JavaScript et Java.
4. Support de long contexte : Une longueur de contexte de 128K permet la génération de grands fichiers de code.

4.2 Caractéristiques de DeepSeek-7B

1. Vitesse de génération rapide : Le temps de réponse est relativement court.
2. Code concis : Le code généré est généralement plus concis et direct.
3. Fonctionnalités de base complètes : Il offre de bonnes performances pour les tâches de complexité simple à moyenne.

4.3 Recommandations pour les scénarios d'utilisation

• Choisir Qwen2.5-7B-Instruct lorsque vous avez besoin de :
  • Une qualité de code de niveau production.
  • L'implémentation de logiques métier complexes.
  • De commentaires complets et d'une gestion des erreurs robuste.
  • La génération de code multi-fichiers ou de grande envergure.
• Choisir DeepSeek-7B lorsque vous avez besoin de :
  • Développement rapide de prototypes.
  • Scripts et outils simples.
  • D'une vitesse de réponse élevée.
  • L'implémentation d'algorithmes de base.