Aller au contenu principal

Qiskit Code Assistant

Les LLMs de Qiskit Code Assistant ont pour but de rendre l'informatique quantique plus accessible aux nouveaux utilisateurs de Qiskit et d'améliorer l'expérience de codage des utilisateurs actuels. Il est entraîné à partir de millions de tokens de texte issus du SDK Qiskit, d'années d'exemples de code Qiskit, et des fonctionnalités d'IBM Quantum®. Qiskit Code Assistant peut améliorer ton flux de développement quantique en proposant des suggestions générées par LLM basées sur les modèles IBM Granite et d'autres modèles open source, qui intègrent les dernières fonctionnalités d'IBM®.

Remarques

Le Grand Modèle de Langage (LLM) derrière Qiskit Code Assistant​

Pour fournir des suggestions de code, Qiskit Code Assistant utilise un Grand Modèle de Langage (LLM). Dans ce cas, Qiskit Code Assistant s'appuie actuellement sur le modèle mistral-small-3.2-24b-qiskit, construit sur le modèle Mistral-Small-3.2-24B-Qiskit. Le modèle mistral-small-3.2-24b-qiskit améliore les capacités de génération de code Qiskit du modèle Mistral-Small-3.2-24B-Instruct-2506 grâce à un pré-entraînement étendu et à un affinage sur des données Qiskit de haute qualité, ainsi que sur des commits Python et des conversations. Pour plus d'informations sur la famille de modèles Mistral AI, consulte la documentation Mistral AI. Pour plus de détails sur les modèles .*-qiskit, voir Qiskit Code Assistant : Training LLMs for generating Quantum Computing Code.

Nos LLMs spécialisés pour Qiskit sont également disponibles en tant que modèles open source. Consulte tous les modèles disponibles sur https://huggingface.co/Qiskit.

Les benchmarks Qiskit HumanEval et Qiskit HumanEval Hard​

Pour tester le modèle mistral-small-3.2-24b-qiskit et d'autres modèles, nous avons collaboré avec des Qiskit Advocates et des experts pour créer les benchmarks basés sur l'exécution appelés Qiskit HumanEval (QHE) et Qiskit HumanEval Hard (QHE Hard), et les avons appliqués aux modèles. Ces benchmarks sont similaires à HumanEval, et comprennent plusieurs problèmes de code complexes à résoudre, tous basés sur les bibliothèques officielles de Qiskit.

Les benchmarks sont composés d'environ 150 tests, chacun constitué d'une définition de fonction suivie d'une docstring qui détaille la tâche que le modèle doit résoudre. Chaque exemple inclut également une solution canonique de référence, ainsi que des tests unitaires, pour évaluer la correction des solutions générées. Il existe trois niveaux de difficulté pour les tests : basique, intermédiaire et difficile. Le benchmark Qiskit HumanEval Hard est une variante du Qiskit HumanEval, mais supprime les informations relatives aux imports de code, de sorte que le LLM doit déterminer les bons imports de méthodes ou de classes. Ce changement rend l'ensemble de données bien plus difficile pour les LLMs, selon nos tests et nos résultats initiaux.

Les jeux de données Qiskit HumanEval et Qiskit HumanEval Hard sont disponibles sur ces sites : Qiskit HumanEval et Qiskit HumanEval. Tu peux contribuer au développement de ces benchmarks sur le dépôt GitHub.

Installer Qiskit Code Assistant​

Apprends à installer, configurer et utiliser n'importe quel modèle Qiskit Code Assistant sur ta machine locale.

Télécharger depuis le site Hugging Face

Suis ces étapes pour télécharger n'importe quel modèle lié à Qiskit Code Assistant depuis le site Hugging Face :

  1. Navigue vers la page du modèle Qiskit souhaité sur Hugging Face.
  2. Va dans l'onglet Files and Versions et télécharge les fichiers du modèle au format safetensors ou GGUF.
Télécharger avec la CLI Hugging Face

Pour télécharger n'importe quel modèle Qiskit Code Assistant disponible à l'aide de la CLI Hugging Face, suis ces étapes :

  1. Installe la CLI Hugging Face

  2. Connecte-toi à ton compte Hugging Face

    huggingface-cli login

  3. Télécharge le modèle de ton choix depuis la liste précédente

    huggingface-cli download <HF REPO NAME> <MODEL PATH> --local-dir <LOCAL PATH>
Déployer manuellement les modèles Qiskit Code Assistant en local via Ollama

Il existe plusieurs façons de déployer et d'interagir avec le modèle Qiskit Code Assistant téléchargé. Ce guide montre comment utiliser Ollama comme suit : soit avec l'application Ollama via l'intégration Hugging Face Hub ou un modèle local, soit avec le package llama-cpp-python.

Utiliser l'application Ollama​

L'application Ollama offre une solution simple pour exécuter les LLMs localement. Elle est facile à utiliser, avec une CLI qui rend l'ensemble du processus de configuration, la gestion des modèles et l'interaction assez simples. Elle est idéale pour une expérimentation rapide et pour les utilisateurs qui souhaitent gérer moins de détails techniques.

Installer Ollama​

  1. Télécharge l'application Ollama

  2. Installe le fichier téléchargé

  3. Lance l'application Ollama installée

    info

    L'application fonctionne correctement lorsque l'icône Ollama apparaît dans la barre de menu du bureau. Tu peux également vérifier que le service est en cours d'exécution en accédant à http://localhost:11434/.

  4. Essaie Ollama dans ton terminal et commence à exécuter des modèles. Par exemple :

    ollama run hf.co/Qiskit/Qwen2.5-Coder-14B-Qiskit
Configurer Ollama avec l'intégration Hugging Face Hub​

L'intégration Ollama/Hugging Face Hub permet d'interagir avec les modèles hébergés sur le Hugging Face Hub sans avoir à créer un nouveau modelfile ni à télécharger manuellement les fichiers GGUF ou safetensors. Les fichiers template et params par défaut sont déjà inclus pour le modèle sur le Hugging Face Hub.

  1. Assure-toi que l'application Ollama est en cours d'exécution.

  2. Va sur la page du modèle souhaité et copie l'URL. Par exemple, https://huggingface.co/Qiskit/Qwen2.5-Coder-14B-Qiskit-GGUF.

  3. Depuis ton terminal, exécute la commande :

    ollama run hf.co/Qiskit/Qwen2.5-Coder-14B-Qiskit

Tu peux utiliser le modèle hf.co/Qiskit/Qwen2.5-Coder-14B-Qiskit ou n'importe lequel des autres modèles GGUF officiels recommandés hf.co/Qiskit/mistral-small-3.2-24b-qiskit-GGUF ou hf.co/Qiskit/granite-3.3-8b-qiskit-GGUF.

Configurer Ollama avec un modèle GGUF Qiskit Code Assistant téléchargé manuellement​

Si tu as téléchargé manuellement un modèle GGUF comme https://huggingface.co/Qiskit/Qwen2.5-Coder-14B-Qiskit-GGUF et que tu souhaites expérimenter avec différents templates et paramètres, tu peux suivre ces étapes pour le charger dans ton application Ollama locale.

  1. Crée un Modelfile avec le contenu suivant et assure-toi de mettre à jour <PATH-TO-GGUF-FILE> avec le chemin réel de ton modèle téléchargé.

    FROM <PATH-TO-GGUF-FILE>
    TEMPLATE """{{ if .System }}
    System:
    {{ .System }}

    {{ end }}{{ if .Prompt }}Question:
    {{ .Prompt }}

    {{ end }}Answer:
    ```python{{ .Response }}
    """

    PARAMETER stop "Question:"
    PARAMETER stop "Answer:"
    PARAMETER stop "System:"
    PARAMETER stop "```"

    PARAMETER temperature 0
    PARAMETER top_k 1

  2. Exécute la commande suivante pour créer une instance de modèle personnalisée basée sur le Modelfile.

    ollama create Qwen2.5-Coder-14B-Qiskit -f ./path-to-model-file
    remarque

    Ce processus peut prendre un certain temps pour qu'Ollama lise le fichier du modèle, initialise l'instance du modèle et la configure selon les spécifications fournies.

Exécuter le modèle Qiskit Code Assistant téléchargé manuellement dans Ollama​

Une fois le modèle Qwen2.5-Coder-14B-Qiskit configuré dans Ollama, exécute la commande suivante pour lancer le modèle et interagir avec lui dans le terminal (en mode chat).

ollama run Qwen2.5-Coder-14B-Qiskit

Quelques commandes utiles :

  • ollama list - Lister les modèles sur ton ordinateur
  • ollama rm Qwen2.5-Coder-14B-Qiskit - Supprimer le modèle
  • ollama show Qwen2.5-Coder-14B-Qiskit - Afficher les informations sur le modèle
  • ollama stop Qwen2.5-Coder-14B-Qiskit - Arrêter un modèle en cours d'exécution
  • ollama ps - Lister les modèles actuellement chargés
Déployer manuellement les modèles Qiskit Code Assistant en local via le package llama-cpp-python

Une alternative à l'application Ollama est le package llama-cpp-python, qui est un binding Python pour llama.cpp. Il te donne plus de contrôle et de flexibilité pour exécuter le modèle GGUF localement, et est idéal pour les utilisateurs qui souhaitent intégrer le modèle local dans leurs flux de travail et leurs applications Python.

  1. Installe llama-cpp-python
  2. Interagis avec le modèle depuis ton application en utilisant llama_cpp. Par exemple :
from llama_cpp import Llama

model_path = <PATH-TO-GGUF-FILE>

model = Llama(
        model_path,
        seed=17,
        n_ctx=10000,
        n_gpu_layers=37, # to offload in gpu, but put 0 if all in cpu
    )

input = 'Generate a quantum circuit with 2 qubits'
raw_pred = model(input)[“choices”][0][“text”]

Tu peux également ajouter des paramètres de génération de texte au modèle pour personnaliser l'inférence :

generation_kwargs = {
        “max_tokens”: 512,
        “echo”: False, # Echo the prompt in the output
        “top_k”: 1
    }

raw_pred = model(input, **generation_kwargs)[“choices”][0][“text”]
Déployer manuellement les modèles Qiskit Code Assistant en local via llama.cpp

Utiliser la bibliothèque llama.cpp​

Une autre alternative est d'utiliser llama.cpp, une bibliothèque open source pour effectuer l'inférence de LLM sur un CPU avec une configuration minimale. Elle offre un contrôle de bas niveau sur l'exécution du modèle et est généralement lancée depuis la ligne de commande, en pointant vers un fichier de modèle GGUF local.

Il existe plusieurs façons d'installer llama.cpp sur ta machine :

Une fois installé, tu peux utiliser llama.cpp pour interagir avec les modèles GGUF en mode conversation comme suit :

# Use a local model file
llama-cli -m my_model.gguf -cnv

# Or download and run a model directly from Hugging Face
llama-cli -hf Qiskit/Qwen2.5-Coder-14B-Qiskit-GGUF -cnv

Tu peux également lancer un serveur API compatible OpenAI pour le modèle de la façon suivante :

llama-server -hf Qiskit/Qwen2.5-Coder-14B-Qiskit-GGUF
Paramètres avancés​

Avec le programme llama-cli, tu peux contrôler la génération du modèle à l'aide d'options en ligne de commande. Par exemple, tu peux fournir un prompt « system » initial à l'aide de l'option -p/--prompt. En mode conversation (-cnv), ce prompt initial fait office de message système. Sinon, tu peux simplement ajouter l'instruction souhaitée au début de ton texte de prompt. Tu peux également ajuster les paramètres d'échantillonnage — par exemple : la température (--temp), le top-k (--top-k), le top-p (--top-p), la pénalité de répétition (--repeat-penalty) et la graine à utiliser (--seed). Voici un exemple d'invocation utilisant ces options :

llama-cli -hf Qiskit/Qwen2.5-Coder-14B-Qiskit-GGUF \
  -p “You are a friendly assistant.” -cnv \
  --temp 0.7 \
  --top-k 50 \
  --top-p 0.95 \
  --repeat-penalty 1.1 \
  --seed 42

Pour garantir le bon fonctionnement de nos modèles Qiskit, nous recommandons d'utiliser le prompt système fourni dans nos dépôts HF GGUF : prompt système pour mistral-small-3.2-24b-qiskit-GGUF, Qwen2.5-Coder-14B-Qiskit-GGUF, granite-3.3-8b-qiskit-GGUF et granite-3.2-8b-qiskit-GGUF.

Connecter manuellement Continue (VS Code)

Continue (VS Code)​

1. Installer l'extension​

Ouvre VS Code, va dans Extensions (Cmd+Shift+X), recherche Continue, installe-la.

2. Ouvrir la configuration​

Clique sur l'icône Continue dans la barre latérale, puis sur l'icône d'engrenage, ou ouvre la palette de commandes (Cmd+Shift+P) et exécute Continue: Open Config File.

Cela ouvre ~/.continue/config.yaml (ou config.json dans les versions plus anciennes).

3. Configurer le modèle​

Ajoute ce qui suit à config.yaml :

models:
  - name: Qiskit Code Assistant
    provider: ollama
    model: mistral-small-3.2-24b-qiskit
    apiBase: http://localhost:11434

Cela rend le modèle Qiskit disponible dans le panneau de chat (conversations dans la barre latérale, Q&R en ligne) et pour les commandes d'édition en ligne.

4. Le tester​
  • Chat : Ouvre le panneau Continue dans la barre latérale et pose une question (ex. : « Comment créer un circuit paramétré dans Qiskit ? »)
  • Édition en ligne : Sélectionne un bloc de code, appuie sur Cmd+I (Mac) ou Ctrl+I (Linux/Windows)
Connecter manuellement Jupyter AI (JupyterLab)

Jupyter AI (JupyterLab)​

Remarque : Ces instructions concernent Jupyter AI v2.x.

1. Installer Jupyter AI et le fournisseur Ollama​
pip install “jupyter-ai<3” langchain-ollama

Le pin ”jupyter-ai<3” garantit l'obtention de la v2.x. Le package langchain-ollama est nécessaire pour que Jupyter AI détecte Ollama en tant que fournisseur. Sans lui, Ollama n'apparaîtra pas dans le panneau de paramètres.

Ensuite, redémarre JupyterLab.

2. Configurer le modèle de chat​

Ouvre JupyterLab et clique sur l'icône de chat dans la barre latérale gauche. Dans le panneau de paramètres :

  1. Sous Language model, sélectionne Ollama comme fournisseur.
  2. Entre mistral-small-3.2-24b-qiskit comme nom de modèle.
  3. Aucune clé API n'est nécessaire pour Ollama (laisse le champ vide).
  4. Clique sur la flèche retour pour commencer à chatter.
3. Utiliser la commande magic %%ai​

La commande magic %%ai te permet d'interroger le modèle directement dans les cellules du notebook.

%load_ext jupyter_ai_magics

Puis dans une cellule :

%%ai ollama:mistral-small-3.2-24b-qiskit
Write a function that implements Grover's algorithm using Qiskit
4. Hôte Ollama personnalisé (optionnel)​

Par défaut, Jupyter AI se connecte à http://127.0.0.1:11434. Si ton serveur Ollama tourne sur une adresse ou un port différent :

Dans l'interface de chat : Définis le champ « Base API URL » dans le panneau de paramètres de l'IA.

Connecter manuellement OpenCode (Terminal)

OpenCode (Terminal)​

1. Installer OpenCode​
curl -fsSL https://opencode.ai/install | bash
2. Configurer le modèle Qiskit​

Crée un fichier opencode.json à la racine de ton projet (ou ~/.config/opencode/opencode.json pour une configuration globale) :

{
  “$schema”: “https://opencode.ai/config.json”,
  “provider”: {
    “ollama”: {
      “npm”: “@ai-sdk/openai-compatible”,
      “name”: “Ollama (local)”,
      “options”: {
        “baseURL”: “http://localhost:11434/v1”
      },
      “models”: {
        “mistral-small-3.2-24b-qiskit”: {
          “name”: “Qiskit Code Assistant”
        }
      }
    }
  }
}
3. Sélectionner le modèle​

Lance OpenCode dans le répertoire de ton projet :

opencode

Dans le TUI, exécute la commande /models et sélectionne Qiskit Code Assistant dans la liste.

4. Le tester​

Pose une question directement dans le chat, par exemple : « Define a Bell circuit and run it using QiskitRuntimeService »

Modèles disponibles​

Modèles actuels​

Ce sont les derniers modèles recommandés pour une utilisation avec Qiskit Code Assistant :

  1. Qiskit/mistral-small-3.2-24b-qiskit - Publié en octobre 2025
  2. Qiskit/Qwen2.5-Coder-14B-Qiskit - Publié en juin 2025
  3. qiskit/granite-3.3-8b-qiskit - Publié en juin 2025
  4. qiskit/granite-3.2-8b-qiskit - Publié en juin 2025

Modèles GGUF (recommandés pour les environnements personnels/laptops)​

Les modèles au format GGUF sont optimisés pour une utilisation locale et nécessitent moins de ressources de calcul :

  1. mistral-small-3.2-24b-qiskit-GGUF – Publié en octobre 2025
    Entraîné avec des données Qiskit jusqu'à la version 2.1

  2. Qiskit/Qwen2.5-Coder-14B-Qiskit-GGUF – Publié en juin 2025
    Entraîné avec des données Qiskit jusqu'à la version 2.0

  3. qiskit/granite-3.3-8b-qiskit-GGUF – Publié en juin 2025
    Entraîné avec des données Qiskit jusqu'à la version 2.0

  4. qiskit/granite-3.2-8b-qiskit-GGUF – Publié en juin 2025
    Entraîné avec des données Qiskit jusqu'à la version 2.0

Les modèles open source Qiskit Code Assistant sont disponibles au format safetensors ou GGUF file format et peuvent être téléchargés depuis Hugging Face comme expliqué ci-dessous.

Versions de Qiskit utilisées pour l'entraînement​

Modèle     Métriques de benchmark    Date de publicationEntraîné sur la version Qiskit
 QiskitHumanEval-HardQiskitHumanEvalHumanEvalASDivMathQASciQMBPPIFEvalCrowsPairs (English)TruthfulQA (MC1 acc)  
mistral-small-3.2-24b-qiskit32.4547.0277.493.7749.6897.5064.0048.4467.0839.41Janvier 20262.2
Qwen2.5-Coder-14B-Qiskit25.1749.0191.464.2153.9097.0077.6049.6465.1837.82Juin 20252.0
granite-3.3-8b-qiskit14.5727.1562.800.4838.6693.3052.4059.7159.7539.05Juin 20252.0
granite-3.2-8b-qiskit9.9324.5057.320.0941.4196.3051.8060.7966.7940.51Juin 20252.0
granite-8b-qiskit-rc-0.1015.8938.4159.76———————Février 20251.3
granite-8b-qiskit17.8844.3753.66———————Novembre 20241.2

Remarque : Tous les modèles listés dans le tableau de benchmark ont été évalués en utilisant leur prompt système respectif, défini dans leur modèle Hugging Face.

Modèles dépréciés​

Ces modèles ne sont plus activement maintenus mais restent disponibles :

  1. qiskit/granite-8b-qiskit-rc-0.10 - Publié en février 2025 (déprécié)
  2. qiskit/granite-8b-qiskit - Publié en novembre 2024 (déprécié)

Plus d'informations et citations​

Pour en savoir plus sur Qiskit Code Assistant, les benchmarks Qiskit HumanEval ou Qiskit HumanEval Hard, et les citer dans tes publications scientifiques, consulte ces citations recommandées :

@misc{2405.19495,
Author = {Nicolas Dupuis and Luca Buratti and Sanjay Vishwakarma and Aitana Viudes Forrat and David Kremer and Ismael Faro and Ruchir Puri and Juan Cruz-Benito},
Title = {Qiskit Code Assistant: Training LLMs for generating Quantum Computing Code},
Year = {2024},
Eprint = {arXiv:2405.19495},
}
@misc{2406.14712,
Author = {Sanjay Vishwakarma and Francis Harkins and Siddharth Golecha and Vishal Sharathchandra Bajpe and Nicolas Dupuis and Luca Buratti and David Kremer and Ismael Faro and Ruchir Puri and Juan Cruz-Benito},
Title = {Qiskit HumanEval: An Evaluation Benchmark For Quantum Code Generative Models},
Year = {2024},
Eprint = {arXiv:2406.14712},
}
@misc{2508.20907,
Author = {Nicolas Dupuis and Adarsh Tiwari and Youssef Mroueh and David Kremer and Ismael Faro and Juan Cruz-Benito},
Title = {Quantum Verifiable Rewards for Post-Training Qiskit Code Assistant},
Year = {2025},
Eprint = {arXiv:2508.20907},
}
Source : IBM Quantum docs — mis à jour le 22 mai 2026
Version anglaise sur doQumentation — mise à jour le 22 mai 2026
Cette traduction est basée sur la version anglaise du 11 mars 2026
Problème avec le site ou la traduction ?Problème de contenu ? Modifier sur IBM Quantum docs