Przejdź do głównej treści

Qiskit Code Assistant

Modele LLM Qiskit Code Assistant mają na celu zwiększenie dostępności obliczeń kwantowych dla nowych użytkowników Qiskit oraz poprawę doświadczenia programistycznego dla obecnych użytkowników. Zostały wytrenowane na milionach tokenów tekstowych z Qiskit SDK, wieloletnich przykładach kodu Qiskit i funkcjach IBM Quantum®. Qiskit Code Assistant może wspierać twój przepływ pracy w zakresie obliczeń kwantowych, oferując sugestie generowane przez LLM na podstawie modeli IBM Granite i innych modeli open-source, które uwzględniają najnowsze funkcje i możliwości IBM®.

Uwagi

Duży Model Językowy (LLM) stojący za Qiskit Code Assistant​

Aby dostarczać sugestie kodu, Qiskit Code Assistant używa Dużego Modelu Językowego (LLM). W tym przypadku Qiskit Code Assistant opiera się obecnie na modelu mistral-small-3.2-24b-qiskit, zbudowanym na modelu Mistral-Small-3.2-24B-Qiskit. Model mistral-small-3.2-24b-qiskit poprawia możliwości generowania kodu modelu Mistral-Small-3.2-24B-Instruct-2506 dla Qiskit poprzez rozszerzone wstępne trenowanie i dostrajanie na wysokiej jakości danych Qiskit, a także commitach Pythona i czacie. Aby uzyskać więcej informacji o rodzinie modeli Mistral AI, zapoznaj się z dokumentacją Mistral AI. Aby dowiedzieć się więcej o modelach .*-qiskit, zobacz Qiskit Code Assistant: Training LLMs for generating Quantum Computing Code.

Nasze LLM wyspecjalizowane dla Qiskit są dostępne również jako modele open-source. Sprawdź wszystkie dostępne modele na https://huggingface.co/Qiskit.

Benchmarki Qiskit HumanEval i Qiskit HumanEval Hard​

Aby przetestować mistral-small-3.2-24b-qiskit i inne modele, współpracowaliśmy z członkami programu Qiskit Advocates i ekspertami, aby stworzyć benchmarki oparte na wykonaniu kodu o nazwie Qiskit HumanEval (QHE) i Qiskit HumanEval Hard (QHE Hard), i uruchomiliśmy je na modelach. Benchmarki te są podobne do HumanEval, zawierają wiele wymagających problemów kodowania do rozwiązania, wszystkie oparte na oficjalnych bibliotekach Qiskit.

Benchmarki składają się z około 150 testów, z których każdy tworzony jest z definicji funkcji, po której następuje docstring szczegółowo opisujący zadanie, które model ma rozwiązać. Każdy przykład zawiera również referencyjne rozwiązanie kanoniczne oraz testy jednostkowe do oceny poprawności generowanych rozwiązań. Istnieją trzy poziomy trudności testów: podstawowy, pośredni i trudny. Benchmark Qiskit HumanEval Hard jest wariantem Qiskit HumanEval, ale usuwa informacje dotyczące importów kodu, więc LLM musi samodzielnie ustalić właściwe importy metod lub klas. Ta zmiana sprawia, że zestaw danych jest znacznie bardziej wymagający dla LLM, zgodnie z naszymi testami i wstępnymi wynikami.

Zestawy danych dla Qiskit HumanEval i Qiskit HumanEval Hard są dostępne na tych stronach: Qiskit HumanEval i Qiskit HumanEval. Możesz przyczynić się do rozwoju tych benchmarków w repozytorium GitHub.

Zainstaluj Qiskit Code Assistant​

Dowiedz się, jak zainstalować, skonfigurować i używać dowolnego modelu Qiskit Code Assistant na swoim lokalnym komputerze.

Pobierz ze strony Hugging Face

Wykonaj następujące kroki, aby pobrać dowolny model związany z Qiskit Code Assistant ze strony Hugging Face:

  1. Przejdź do pożądanej strony modelu Qiskit na Hugging Face.

  2. Przejdź do zakładki Files and Versions i pobierz pliki modelu safetensors lub GGUF.

Pobierz za pomocą Hugging Face CLI

Aby pobrać dowolny z dostępnych modeli Qiskit Code Assistant za pomocą Hugging Face CLI, wykonaj następujące kroki:

  1. Zainstaluj Hugging Face CLI

  2. Zaloguj się na swoje konto Hugging Face

    huggingface-cli login

  3. Pobierz preferowany model z poprzedniej listy

    huggingface-cli download <HF REPO NAME> <MODEL PATH> --local-dir <LOCAL PATH>
Ręcznie wdróż modele Qiskit Code Assistant lokalnie przez Ollama

Istnieje wiele sposobów na wdrożenie i interakcję z pobranym modelem Qiskit Code Assistant. Ten przewodnik demonstruje użycie Ollama w następujący sposób: albo z aplikacją Ollama za pomocą integracji Hugging Face Hub lub modelu lokalnego, albo z pakietem llama-cpp-python.

Używanie aplikacji Ollama​

Aplikacja Ollama zapewnia proste rozwiązanie do lokalnego uruchamiania LLM. Jest łatwa w użyciu, z interfejsem CLI, który sprawia, że cały proces konfiguracji, zarządzanie modelami i interakcja są stosunkowo proste. Jest idealna do szybkiego eksperymentowania i dla użytkowników, którzy chcą mieć mniej szczegółów technicznych do obsługi.

Zainstaluj Ollama​

  1. Pobierz aplikację Ollama

  2. Zainstaluj pobrany plik

  3. Uruchom zainstalowaną aplikację Ollama

    info

    Aplikacja działa poprawnie, gdy ikona Ollama pojawi się na pasku menu pulpitu. Możesz również sprawdzić, czy usługa działa, przechodząc do http://localhost:11434/.

  4. Wypróbuj Ollama w terminalu i zacznij uruchamiać modele. Na przykład:

    ollama run hf.co/Qiskit/Qwen2.5-Coder-14B-Qiskit
Skonfiguruj Ollama za pomocą integracji Hugging Face Hub​

Integracja Ollama/Hugging Face Hub umożliwia interakcję z modelami hostowanymi na Hugging Face Hub bez potrzeby tworzenia nowego pliku modelfile ani ręcznego pobierania plików GGUF lub safetensors. Domyślne pliki template i params są już dołączone dla modelu na Hugging Face Hub.

  1. Upewnij się, że aplikacja Ollama jest uruchomiona.

  2. Przejdź do żądanej strony modelu i skopiuj URL. Na przykład, https://huggingface.co/Qiskit/Qwen2.5-Coder-14B-Qiskit-GGUF.

  3. W terminalu uruchom polecenie:

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

Możesz użyć modelu hf.co/Qiskit/Qwen2.5-Coder-14B-Qiskit lub dowolnego z innych obecnie zalecanych oficjalnych modeli GGUF hf.co/Qiskit/mistral-small-3.2-24b-qiskit-GGUF lub hf.co/Qiskit/granite-3.3-8b-qiskit-GGUF.

Skonfiguruj Ollama z ręcznie pobranym modelem GGUF Qiskit Code Assistant​

Jeśli ręcznie pobrałeś model GGUF, taki jak https://huggingface.co/Qiskit/Qwen2.5-Coder-14B-Qiskit-GGUF, i chcesz eksperymentować z różnymi szablonami i parametrami, możesz wykonać następujące kroki, aby załadować go do lokalnej aplikacji Ollama.

  1. Utwórz plik Modelfile wpisując następującą zawartość i pamiętaj, aby zaktualizować <PATH-TO-GGUF-FILE> do rzeczywistej ścieżki pobranego modelu.

    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. Uruchom następujące polecenie, aby utworzyć niestandardową instancję modelu na podstawie pliku Modelfile.

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

    uwaga

    Ten proces może zająć trochę czasu, ponieważ Ollama musi odczytać plik modelu, zainicjować instancję modelu i skonfigurować go zgodnie z podanymi specyfikacjami.

Uruchom ręcznie pobrany model Qiskit Code Assistant w Ollama​

Po skonfigurowaniu modelu Qwen2.5-Coder-14B-Qiskit w Ollama uruchom następujące polecenie, aby uruchomić model i wchodzić z nim w interakcję w terminalu (w trybie czatu).

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

Kilka przydatnych poleceń:

  • ollama list - Wyświetla listę modeli na komputerze

  • ollama rm Qwen2.5-Coder-14B-Qiskit - Usuwa model

  • ollama show Qwen2.5-Coder-14B-Qiskit - Pokazuje informacje o modelu

  • ollama stop Qwen2.5-Coder-14B-Qiskit - Zatrzymuje model, który aktualnie działa

  • ollama ps - Wyświetla listę modeli aktualnie załadowanych

Ręcznie wdróż modele Qiskit Code Assistant lokalnie przy użyciu pakietu llama-cpp-python

Alternatywą dla aplikacji Ollama jest pakiet llama-cpp-python, który jest wiązaniem Python dla llama.cpp. Daje on większą kontrolę i elastyczność w uruchamianiu modelu GGUF lokalnie i jest idealny dla użytkowników, którzy chcą zintegrować lokalny model ze swoimi przepływami pracy i aplikacjami Python.

  1. Zainstaluj llama-cpp-python

  2. Współpracuj z modelem z poziomu swojej aplikacji, używając llama_cpp. Na przykład:

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"]

Możesz również dodać parametry generowania tekstu do modelu, aby dostosować wnioskowanie:

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"]

Ręcznie wdróż modele Qiskit Code Assistant lokalnie przez llama.cpp

Użyj biblioteki llama.cpp​

Kolejną alternatywą jest użycie llama.cpp, biblioteki open source do wykonywania wnioskowania LLM na CPU przy minimalnej konfiguracji. Zapewnia niskopoziomową kontrolę nad wykonywaniem modelu i zazwyczaj jest uruchamiana z wiersza poleceń, wskazując na lokalny plik modelu GGUF.

Istnieje kilka sposobów instalacji llama.cpp na komputerze:

Po instalacji możesz użyć llama.cpp do interakcji z modelami GGUF w trybie konwersacji w następujący sposób:


# Use a local model file \{#use-a-local-model-file}
llama-cli -m my_model.gguf -cnv

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

Możesz również uruchomić serwer API kompatybilny z OpenAI dla modelu w następujący sposób:

llama-server -hf Qiskit/Qwen2.5-Coder-14B-Qiskit-GGUF

Parametry zaawansowane​

Za pomocą programu llama-cli możesz kontrolować generowanie modelu, używając opcji wiersza poleceń. Na przykład możesz podać wstępny prompt „systemowy” za pomocą flagi -p/--prompt. W trybie konwersacji (-cnv) ten wstępny prompt działa jako komunikat systemowy. W przeciwnym razie możesz po prostu poprzedzić tekst promptu dowolną pożądaną instrukcją. Możesz też dostosować parametry próbkowania - na przykład: temperaturę (--temp), top-k (--top-k), top-p (--top-p), karę za powtórzenia (--repeat-penalty) oraz ziarno do użycia (--seed). Poniżej znajduje się przykładowe wywołanie z użyciem tych opcji:

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

Aby zapewnić prawidłowe działanie naszych modeli Qiskit, zalecamy użycie promptu systemowego dostarczonego w naszych repozytoriach HF GGUF: prompt systemowy dla mistral-small-3.2-24b-qiskit-GGUF, Qwen2.5-Coder-14B-Qiskit-GGUF, granite-3.3-8b-qiskit-GGUF oraz granite-3.2-8b-qiskit-GGUF.

Ręcznie połącz Continue (VS Code)

Continue (VS Code)​

1. Zainstaluj rozszerzenie​

Otwórz VS Code, przejdź do Extensions (Cmd+Shift+X), wyszukaj Continue, zainstaluj je.

2. Otwórz konfigurację​

Kliknij ikonę Continue na pasku bocznym, a następnie kliknij ikonę koła zębatego, lub otwórz paletę poleceń (Cmd+Shift+P) i uruchom Continue: Open Config File.

To otwiera ~/.continue/config.yaml (lub config.json w starszych wersjach).

3. Skonfiguruj model​

Dodaj następujące elementy do config.yaml:

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

To udostępnia model Qiskit w panelu czatu (konwersacje na pasku bocznym, pytania i odpowiedzi w tekście) oraz do poleceń edycji w tekście.

4. Test it​

  • Czat: Otwórz panel Continue na pasku bocznym i zadaj pytanie (np. „Jak stworzyć sparametryzowany obwód w Qiskit?”)

  • Edycja w tekście: Zaznacz blok kodu, naciśnij Cmd+I (Mac) lub Ctrl+I (Linux/Windows)

Ręcznie połącz Jupyter AI (JupyterLab)

Jupyter AI (JupyterLab)​

Uwaga: Te instrukcje dotyczą Jupyter AI w wersji 2.x.

1. Zainstaluj Jupyter AI i dostawcę Ollama​
pip install "jupyter-ai<3" langchain-ollama

Przypięcie "jupyter-ai<3" zapewnia otrzymanie wersji 2.x. Pakiet langchain-ollama jest wymagany, aby Jupyter AI wykrył Ollama jako dostawcę. Bez niego Ollama nie pojawi się w panelu ustawień.

Następnie uruchom ponownie JupyterLab.

2. Skonfiguruj model czatu​

Otwórz JupyterLab i kliknij ikonę czatu na lewym pasku bocznym. W panelu ustawień:

  1. W sekcji Model językowy wybierz Ollama jako dostawcę.

  2. Wpisz mistral-small-3.2-24b-qiskit jako nazwę modelu.

  3. Klucz API nie jest wymagany dla Ollama (pozostaw pole puste).

  4. Kliknij strzałkę wstecz, aby rozpocząć czat.

3. Użyj polecenia magicznego %%ai​

Polecenie magiczne %%ai pozwala na bezpośrednie zapytania do modelu w komórkach notatnika.

%load_ext jupyter_ai_magics

Następnie w komórce:

%%ai ollama:mistral-small-3.2-24b-qiskit
Write a function that implements Grover's algorithm using Qiskit

4. Niestandardowy host Ollama (opcjonalnie)​

Domyślnie Jupyter AI łączy się z http://127.0.0.1:11434. Jeśli twój serwer Ollama działa pod innym adresem lub portem:

W interfejsie czatu: Ustaw pole „Base API URL” w panelu ustawień AI.

Ręcznie połącz OpenCode (Terminal)

OpenCode (Terminal)​

1. Zainstaluj OpenCode​
curl -fsSL https://opencode.ai/install | bash

2. Skonfiguruj model Qiskit​

Utwórz plik opencode.json w katalogu głównym swojego projektu (lub ~/.config/opencode/opencode.json dla konfiguracji globalnej):

{
  "$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. Wybierz model​

Uruchom OpenCode w katalogu swojego projektu:

opencode

Wewnątrz TUI uruchom polecenie /models i wybierz Qiskit Code Assistant z listy.

4. Test it​

Zadaj pytanie bezpośrednio w czacie, na przykład: „Zdefiniuj obwód Bella i uruchom go za pomocą QiskitRuntimeService”

Dostępne modele​

Aktualne modele​

Są to najnowsze zalecane modele do użycia z Qiskit Code Assistant:

  1. Qiskit/mistral-small-3.2-24b-qiskit - Wydany w październiku 2025

  2. Qiskit/Qwen2.5-Coder-14B-Qiskit - Wydany w czerwcu 2025

  3. qiskit/granite-3.3-8b-qiskit - Wydany w czerwcu 2025

  4. qiskit/granite-3.2-8b-qiskit - Wydany w czerwcu 2025

Modele GGUF (zalecane dla środowisk osobistych/laptopów)​

Modele w formacie GGUF są zoptymalizowane do lokalnego użytku i wymagają mniej zasobów obliczeniowych:

  1. mistral-small-3.2-24b-qiskit-GGUF – Wydany w październiku 2025

    Trenowany na danych Qiskit do wersji 2.1

  2. Qiskit/Qwen2.5-Coder-14B-Qiskit-GGUF – Wydany w czerwcu 2025

    Trenowany na danych Qiskit do wersji 2.0

  3. qiskit/granite-3.3-8b-qiskit-GGUF – Wydany w czerwcu 2025

    Trenowany na danych Qiskit do wersji 2.0

  4. qiskit/granite-3.2-8b-qiskit-GGUF – Wydany w czerwcu 2025

    Trenowany na danych Qiskit do wersji 2.0

Modele Qiskit Code Assistant o otwartym kodzie źródłowym są dostępne w formacie safetensors lub GGUF i można je pobrać z Hugging Face, jak wyjaśniono poniżej.

Wersje Qiskit użyte do trenowania​

Model     Metryki testów porównawczych    Data wydaniaWersja Qiskit, na której wytrenowano
 QiskitHumanEval-HardQiskitHumanEvalHumanEvalASDivMathQASciQMBPPIFEvalCrowsPairs (English)TruthfulQA (MC1 acc)  
mistral-small-3.2-24b-qiskit32.4547.0277.493.7749.6897.5064.0048.4467.0839.41styczeń 20262.2
Qwen2.5-Coder-14B-Qiskit25.1749.0191.464.2153.9097.0077.6049.6465.1837.82czerwiec 20252.0
granite-3.3-8b-qiskit14.5727.1562.800.4838.6693.3052.4059.7159.7539.05czerwiec 20252.0
granite-3.2-8b-qiskit9.9324.5057.320.0941.4196.3051.8060.7966.7940.51czerwiec 20252.0
granite-8b-qiskit-rc-0.1015.8938.4159.76———————luty 20251.3
granite-8b-qiskit17.8844.3753.66———————listopad 20241.2

Uwaga: Wszystkie modele wymienione w tabeli benchmarków zostały ocenione przy użyciu ich odpowiedniego promptu systemowego, zdefiniowanego w ich modelu Hugging Face.

Przestarzałe modele​

Te modele nie są już aktywnie utrzymywane, ale pozostają dostępne:

  1. qiskit/granite-8b-qiskit-rc-0.10 - Wydany w lutym 2025 (przestarzały)

  2. qiskit/granite-8b-qiskit - Wydany w listopadzie 2024 (przestarzały)

Więcej informacji i cytowania​

Aby dowiedzieć się więcej o Qiskit Code Assistant, benchmarkach Qiskit HumanEval lub Qiskit HumanEval Hard i zacytować je w swoich publikacjach naukowych, zapoznaj się z tymi zalecanymi cytowaniami:

@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},
}

Źródło: IBM Quantum docs — zaktualizowano 22 maj 2026
Wersja angielska na doQumentation — zaktualizowano 22 maj 2026
Problem ze stroną lub tłumaczeniem?Problem z treścią? Edytuj w IBM Quantum docs