Singularity Machine Learning - Klasifikace: Qiskit Function od Multiverse Computing

Viz referenci API

Verze balíčků

Kód na této stránce byl vytvořen s použitím následujících požadavků. Doporučujeme používat tyto verze nebo novější.

scikit-learn~=1.8.0

Poznámka

• Qiskit Functions jsou experimentální funkce dostupné pouze uživatelům plánů IBM Quantum® Premium Plan, Flex Plan a On-Prem (přes IBM Quantum Platform API). Jsou ve fázi preview a mohou se měnit.

Přehled

Funkce „Singularity Machine Learning - Klasifikace" ti umožňuje řešit skutečné problémy strojového učení na kvantovém hardwaru, aniž bys potřeboval/a znalosti kvantové fyziky. Tato aplikační funkce, založená na metodách ensemble, je hybridní klasifikátor. Využívá klasické metody jako boosting, bagging a stacking pro počáteční trénování ensemblu. Následně jsou použity kvantové algoritmy, jako je variační kvantový eigensolver (VQE) a kvantový aproximační optimalizační algoritmus (QAOA), aby se zvýšila rozmanitost natrénovaného ensemblu, jeho schopnost generalizace a celková složitost.

Na rozdíl od jiných řešení kvantového strojového učení je tato funkce schopna zpracovávat rozsáhlé datové sady s miliony příkladů a příznaků, aniž by byla omezena počtem qubitů v cílovém QPU. Počet qubitů určuje pouze velikost ensemblu, který lze natrénovat. Je také velmi flexibilní a lze ji použít k řešení klasifikačních problémů v mnoha oblastech, včetně financí, zdravotnictví a kybernetické bezpečnosti. Konzistentně dosahuje vysoké přesnosti u klasicky náročných problémů zahrnujících vícerozměrné, zašuměné a nevyvážené datové sady. Je určena pro:

1. Inženýry a datové vědce ve firmách, kteří chtějí rozšířit svou technologickou nabídku integrací kvantového strojového učení do svých produktů a služeb,
2. Výzkumníky v kvantových výzkumných laboratořích, kteří zkoumají aplikace kvantového strojového učení a chtějí využít kvantové výpočty pro klasifikační úlohy, a
3. Studenty a učitele na vzdělávacích institucích v kurzech strojového učení, kteří chtějí demonstrovat výhody kvantových výpočtů.

Následující příklad ukazuje různé funkce, včetně create, list, fit a predict, a demonstruje jejich použití na syntetickém problému dvou proložených půlkružnic – notoricky náročném problému kvůli jeho nelineární rozhodovací hranici.

Popis funkce

Tato Qiskit Function umožňuje uživatelům řešit problémy binární klasifikace pomocí kvantově vylepšeného ensemble klasifikátoru Singularity. Za scénou využívá hybridní přístup ke klasickému trénování ensemblu klasifikátorů na označené datové sadě a poté ho optimalizuje pro maximální rozmanitost a generalizaci pomocí Kvantového aproximačního optimalizačního algoritmu (QAOA) na IBM® QPU. Prostřednictvím uživatelsky přívětivého rozhraní mohou uživatelé konfigurovat klasifikátor podle svých požadavků, natrénovat ho na datové sadě dle vlastního výběru a použít ho k predikci na dříve neviděné datové sadě.

Postup řešení obecného klasifikačního problému:

1. Předzpracuj datovou sadu a rozděl ji na trénovací a testovací sady. Volitelně můžeš trénovací sadu dále rozdělit na trénovací a validační sadu. Toho lze dosáhnout pomocí scikit-learn.
2. Pokud je trénovací sada nevyvážená, můžeš ji převzorkovat, aby byly třídy vyvážené, pomocí imbalanced-learn.
3. Nahraj trénovací, validační a testovací sady samostatně do úložiště funkce pomocí metody file_upload katalogu a pokaždé jí předej příslušnou cestu.
4. Inicializuj kvantový klasifikátor pomocí akce create funkce, která přijímá hyperparametry, jako je počet a typy modelů, regularizace (hodnota lambda) a možnosti optimalizace včetně počtu vrstev, typu klasického optimalizátoru, kvantového Backend a tak dále.
5. Natrénuj kvantový klasifikátor na trénovací sadě pomocí akce fit funkce, které předáš označenou trénovací sadu a případně validační sadu.
6. Proveď predikci na dříve neviděné testovací sadě pomocí akce predict funkce.

---

Začínáme

Ověř svou totožnost pomocí klíče API platformy IBM Quantum a vyber Qiskit Function takto:

# Added by doQumentation — required packages for this notebook
!pip install -q numpy qiskit-ibm-catalog scikit-learn

from qiskit_ibm_catalog import QiskitFunctionsCatalog

catalog = QiskitFunctionsCatalog(channel="ibm_quantum_platform")

# load function
singularity = catalog.load("multiverse/singularity")

Příklady

Klasifikace datasetu

V tomto příkladu použiješ funkci „Singularity Machine Learning - Classification" ke klasifikaci datasetu složeného ze dvou vzájemně propletených měsícovitých půlkružnic. Dataset je syntetický, dvourozměrný a označený binárními štítky. Je navržen tak, aby byl náročný pro algoritmy jako shlukování na základě centroidů nebo lineární klasifikace. V průběhu tohoto procesu se naučíš, jak vytvořit klasifikátor, přizpůsobit ho trénovacím datům, použít ho k predikci na testovacích datech a po dokončení ho smazat. Než začneš, musíš nainstalovat scikit-learn. Nainstaluj ho pomocí následujícího příkazu:

python3 -m pip install scikit-learn

Proveď následující kroky:

1. Vytvoř syntetický dataset pomocí funkce make_moons z knihovny scikit-learn.
2. Nahraj vygenerovaný syntetický dataset do sdíleného datového adresáře.
3. Vytvoř kvantově rozšířený klasifikátor pomocí akce create.
4. Zobraz seznam svých klasifikátorů pomocí akce list.
5. Natrénuj klasifikátor na trénovacích datech pomocí akce fit.
6. Použij natrénovaný klasifikátor k predikci na testovacích datech pomocí akce predict.
7. Smaž klasifikátor pomocí akce delete.
8. Po dokončení ukliď po sobě. Krok 1. Importuj potřebné moduly a vygeneruj syntetický dataset, poté ho rozděl na trénovací a testovací datasety.

# import the necessary modules for this example
import os
import tarfile
import numpy as np

# Import the make_moons and the train_test_split functions from scikit-learn
# to create a synthetic dataset and split it into training and test datasets
from sklearn.datasets import make_moons
from sklearn.model_selection import train_test_split

# generate the synthetic dataset
X, y = make_moons(n_samples=10000)

# split the data into training and test datasets
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2)

# print the first 10 samples of the training dataset
print("Features:", X_train[:10, :])
print("Targets:", y_train[:10])

Features: [[ 0.84757037 -0.48831433]
 [ 0.98132552  0.19235443]
 [-0.71626723  0.6978261 ]
 [ 1.18957848 -0.48186557]
 [ 0.52118982 -0.37791846]
 [ 0.81115408  0.58483251]
 [ 0.48706462  0.87336593]
 [-0.81880144  0.57407682]
 [ 1.67335408 -0.23932015]
 [ 0.50181306  0.8649761 ]]
Targets: [1 0 0 1 1 0 0 0 1 0]

Krok 2. Ulož označené trénovací a testovací datasety na lokální disk a poté je nahraj do sdíleného datového adresáře.

def make_tarfile(file_path, tar_file_name):
    with tarfile.open(tar_file_name, "w") as tar:
        tar.add(file_path, arcname=os.path.basename(file_path))

# save the training and test datasets on your local disk
np.save("X_train.npy", X_train)
np.save("y_train.npy", y_train)
np.save("X_test.npy", X_test)
np.save("y_test.npy", y_test)

# create tar files for the datasets
make_tarfile("X_train.npy", "X_train.npy.tar")
make_tarfile("y_train.npy", "y_train.npy.tar")
make_tarfile("X_test.npy", "X_test.npy.tar")
make_tarfile("y_test.npy", "y_test.npy.tar")

# upload the datasets to the shared data directory
catalog.file_upload("X_train.npy.tar", singularity)
catalog.file_upload("y_train.npy.tar", singularity)
catalog.file_upload("X_test.npy.tar", singularity)
catalog.file_upload("y_test.npy.tar", singularity)

# view/enlist the uploaded files in the shared data directory
print(catalog.files(singularity))

['X_test.npy.tar', 'X_train.npy.tar', 'y_test.npy.tar', 'y_train.npy.tar']

Krok 3. Vytvoř klasifikátor s kvantovým vylepšením pomocí akce create.

job = singularity.run(
    action="create",
    name="my_classifier",
    num_learners=10,
    learners_types=[
        "DecisionTreeClassifier",
        "KNeighborsClassifier",
    ],
    learners_proportions=[0.5, 0.5],
    learners_options=[{}, {}],
    regularization=0.01,
    weight_update_method="logarithmic",
    sample_scaling=True,
    optimizer_options={"simulator": True},
    voting="soft",
    prob_threshold=0.5,
)

print(job.result())

{'status': 'ok', 'message': 'Classifier created.', 'data': {}, 'metadata': {'resource_usage': {}}}

# list available classifiers using the list action
job = singularity.run(action="list")

print(job.result())

# you can also find your classifiers in the shared data directory with a *.pkl.tar extension
print(catalog.files(singularity))

{'status': 'ok', 'message': 'Classifiers listed.', 'data': {'classifiers': ['my_classifier']}, 'metadata': {'resource_usage': {}}}

['X_test.npy.tar', 'X_train.npy.tar', 'my_classifier.pkl.tar', 'y_test.npy.tar', 'y_train.npy.tar']

Krok 4. Natrénuj klasifikátor s kvantovým vylepšením pomocí akce fit.

job = singularity.run(
    action="fit",
    name="my_classifier",
    X="X_train.npy",  # you do not need to specify the tar extension
    y="y_train.npy",  # you do not need to specify the tar extension
)

print(job.result())

{'status': 'ok', 'message': 'Classifier fitted.', 'data': {}, 'metadata': {'resource_usage': {'RUNNING: MAPPING': {'CPU_TIME': 13.655871629714966}, 'RUNNING: WAITING_QPU': {'CPU_TIME': 54.688621282577515}, 'RUNNING: POST_PROCESSING': {'CPU_TIME': 56.92286920547485}, 'RUNNING: EXECUTING_QPU': {'QPU_TIME': 57.92738223075867}}}}

Krok 5. Získej predikce a pravděpodobnosti z klasifikátoru s kvantovým vylepšením pomocí akce predict.

job = singularity.run(
    action="predict",
    name="my_classifier",
    X="X_test.npy",  # you do not need to specify the tar extension
)

result = job.result()

print("Action result status: ", result["status"])
print("Action result message: ", result["message"])
print("Predictions (first five results):", result["data"]["predictions"][:5])
print(
    "Probabilities (first five results):", result["data"]["probabilities"][:5]
)

Action result status:  ok
Action result message:  Classifier predicted.
Predictions (first five results): [0, 0, 1, 0, 1]
Probabilities (first five results): [[1.0, 0.0], [1.0, 0.0], [0.0, 1.0], [1.0, 0.0], [0.0, 1.0]]

Krok 6. Odstraň kvantově vylepšený klasifikátor pomocí akce delete.

job = singularity.run(
    action="delete",
    name="my_classifier",
)

# or you can delete from the shared data directory
# catalog.file_delete("my_classifier.pkl.tar", singularity)

print(job.result())

{'status': 'ok', 'message': 'Classifier deleted.', 'data': {}, 'metadata': {'resource_usage': {}}}

Krok 7. Ukliď lokální a sdílené datové adresáře.

# delete the numpy files from your local disk
os.remove("X_train.npy")
os.remove("y_train.npy")
os.remove("X_test.npy")
os.remove("y_test.npy")

# delete the tar files from your local disk
os.remove("X_train.npy.tar")
os.remove("y_train.npy.tar")
os.remove("X_test.npy.tar")
os.remove("y_test.npy.tar")

# delete the tar files from the shared data
catalog.file_delete("X_train.npy.tar", singularity)
catalog.file_delete("y_train.npy.tar", singularity)
catalog.file_delete("X_test.npy.tar", singularity)
catalog.file_delete("y_test.npy.tar", singularity)

'Requested file was deleted.'

Příklad create_fit_predict

Následující příklad demonstruje akci create_fit_predict.

# Import QiskitFunctionsCatalog to load the
# "Singularity Machine Learning - Classification" function by Multiverse Computing
from qiskit_ibm_catalog import QiskitFunctionsCatalog

# Import the make_moons and the train_test_split functions from scikit-learn
# to create a synthetic dataset and split it into training and test datasets
from sklearn.datasets import make_moons
from sklearn.model_selection import train_test_split

# authentication
# If you have not previously saved your credentials, follow instructions at
# /docs/guides/functions
# to authenticate with your API key.
catalog = QiskitFunctionsCatalog(channel="ibm_quantum_platform")

# load "Singularity Machine Learning - Classification" function by Multiverse Computing
singularity = catalog.load("multiverse/singularity")

# generate the synthetic dataset
X, y = make_moons(n_samples=1000)

# split the data into training and test datasets
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2)

job = singularity.run(
    action="create_fit_predict",
    num_learners=10,
    regularization=0.01,
    optimizer_options={"simulator": True},
    X_train=X_train,
    y_train=y_train,
    X_test=X_test,
    options={"save": False},
)

# get job status and result
status = job.status()
result = job.result()

print("Job status: ", status)
print("Action result status: ", result["status"])
print("Action result message: ", result["message"])
print("Predictions (first five results): ", result["data"]["predictions"][:5])
print(
    "Probabilities (first five results): ",
    result["data"]["probabilities"][:5],
)
print("Usage metadata: ", result["metadata"]["resource_usage"])

Job status:  QUEUED
Action result status:  ok
Action result message:  Classifier created, fitted, and predicted.
Predictions (first five results):  [0, 0, 1, 0, 0]
Probabilities (first five results):  [[0.87119766531518, 0.1288023346848197], [0.87119766531518, 0.1288023346848197], [0.24470328446479797, 0.7552967155352032], [0.820524432250189, 0.17947556774981072], [0.6847610293419495, 0.31523897065805173]]
Usage metadata:  {'RUNNING: MAPPING': {'CPU_TIME': 10.967791318893433}, 'RUNNING: WAITING_QPU': {'CPU_TIME': 59.91712307929993}, 'RUNNING: POST_PROCESSING': {'CPU_TIME': 59.097386837005615}, 'RUNNING: EXECUTING_QPU': {'QPU_TIME': 56.93338203430176}}

Benchmarks

Tyto benchmarky ukazují, že klasifikátor dokáže dosáhnout velmi vysoké přesnosti i na náročných problémech. Zároveň dokládají, že zvýšení počtu learnerů v ansámblu (počtu Qubitů) může vést ke zvýšení přesnosti.

„Klasická přesnost" označuje přesnost dosaženou pomocí odpovídajícího klasického nejlepšího řešení, kterým je v tomto případě klasifikátor AdaBoost postavený na ansámblu o velikosti 75. „Kvantová přesnost" naproti tomu označuje přesnost dosaženou pomocí „Singularity Machine Learning – Classification".

Problém	Velikost datasetu	Velikost ansámblu	Počet Qubitů	Klasická přesnost	Kvantová přesnost	Zlepšení
Stabilita sítě	5000 příkladů, 12 příznaků	55	55	76%	91%	15%
Stabilita sítě	5000 příkladů, 12 příznaků	65	65	76%	92%	16%
Stabilita sítě	5000 příkladů, 12 příznaků	75	75	76%	94%	18%
Stabilita sítě	5000 příkladů, 12 příznaků	85	85	76%	94%	18%
Stabilita sítě	5000 příkladů, 12 příznaků	100	100	76%	95%	19%

---

S tím, jak se kvantový hardware vyvíjí a škáluje, nabývají důsledky pro náš kvantový klasifikátor stále většího významu. Přestože počet Qubitů omezuje velikost ansámblu, který lze využít, nijak neomezuje objem dat, která lze zpracovat. Tato silná vlastnost umožňuje klasifikátoru efektivně pracovat s datasety obsahujícími miliony datových bodů a tisíce příznaků. Omezení týkající se velikosti ansámblu lze řešit implementací rozsáhlé verze klasifikátoru. Díky iterativnímu přístupu s vnější smyčkou lze ansámbl dynamicky rozšiřovat, což zvyšuje flexibilitu a celkový výkon. Tato funkce však dosud není v aktuální verzi klasifikátoru implementována.

Changelog

4. června 2025

• Vylepšen QuantumEnhancedEnsembleClassifier s následujícími změnami:
  • Přidána onsite/alpha regularizace. Pomocí parametru regularization_type lze zvolit typ onsite nebo alpha
  • Přidána automatická regularizace. Nastavením regularization na hodnotu auto se použije automatická regularizace
  • Přidán parametr optimization_data metody fit pro výběr optimalizačních dat pro kvantovou optimalizaci. Lze použít jednu z těchto možností: train, validation nebo both
  • Zlepšen celkový výkon
• Přidáno podrobné sledování stavu běžících úloh

20. května 2025

• Standardizováno zpracování chyb

18. března 2025

• Aktualizován qiskit-serverless na verzi 0.20.0 a základní obraz na verzi 0.20.1

14. února 2025

• Aktualizován základní obraz na verzi 0.19.1

6. února 2025

• Aktualizován qiskit-serverless na verzi 0.19.0 a základní obraz na verzi 0.19.0

13. listopadu 2024

• Vydání Singularity Machine Learning – Classification

Získat podporu

Máš-li jakékoli dotazy, kontaktuj Multiverse Computing.

Nezapomeň uvést následující informace:

• ID úlohy Qiskit Function (job.job_id)
• Podrobný popis problému
• Případné chybové zprávy nebo kódy
• Kroky k reprodukci problému

Další kroky

Doporučení

• Požádej o přístup k funkci Singularity Machine Learning Classification od Multiverse Computing.
• Prostuduj referenci API pro tuto Qiskit Function.
• Prostuduj Leclerc, L., et al. (2023). Financial risk management on a neutral atom quantum processor. Physical Review Research, 5, 043117.