Singularity Machine Learning - Classification: Isang Qiskit Function ng Multiverse Computing

Paalala

Ang Qiskit Functions ay isang experimental na feature na available lamang sa mga gumagamit ng IBM Quantum® Premium Plan, Flex Plan, at On-Prem (sa pamamagitan ng IBM Quantum Platform API) Plan. Nasa preview release status ito at maaaring magbago.

Pangkalahatang-ideya

Sa pamamagitan ng function na "Singularity Machine Learning - Classification", maaari kang malutas ng mga tunay na problema sa machine learning sa quantum hardware nang hindi kailangan ng kaalaman sa quantum. Ang Application function na ito, batay sa ensemble methods, ay isang hybrid classifier. Ginagamit nito ang mga klasikal na pamamaraan tulad ng boosting, bagging, at stacking para sa unang ensemble training. Pagkatapos, ginagamit ang mga quantum algorithm tulad ng variational quantum eigensolver (VQE) at quantum approximate optimization algorithm (QAOA) para mapahusay ang diversity, generalization capabilities, at kabuuang complexity ng na-train na ensemble.

Hindi tulad ng ibang quantum machine learning na solusyon, kaya ng function na ito na hawakan ang malalaking dataset na may milyun-milyong halimbawa at feature nang hindi nililimitahan ng bilang ng mga qubit sa target QPU. Ang bilang ng mga qubit ay nagtatakda lamang ng laki ng ensemble na maaaring i-train. Napaka-flexible din nito, at maaaring gamitin para malutas ang mga problema sa classification sa iba't ibang larangan, kabilang ang finance, healthcare, at cybersecurity. Palagi itong nakakamit ng mataas na accuracy sa mga klasikal na mahirap na problema na kinabibilangan ng high-dimensional, maingay, at imbalanced na dataset. Paano ito gumagana Ginawa ito para sa:

Mga engineer at data scientist sa mga kumpanya na naghahanap na palawakin ang kanilang tech offerings sa pamamagitan ng pagsasama ng quantum machine learning sa kanilang mga produkto at serbisyo,
Mga mananaliksik sa mga quantum research lab na nag-eeksplora ng mga aplikasyon sa quantum machine learning at gustong gamitin ang quantum computing para sa mga gawain sa classification, at
Mga estudyante at guro sa mga institusyong pang-edukasyon sa mga kurso tulad ng machine learning, at gustong ipakita ang mga kalamangan ng quantum computing.

Ipinapakita ng sumusunod na halimbawa ang iba't ibang functionality nito, kabilang ang create, list, fit, at predict, at ipinapakita ang paggamit nito sa isang synthetic na problema na binubuo ng dalawang magkabaluktot na kalahating bilog, isang notoriously challenging na problema dahil sa nonlinear na hangganan ng desisyon nito.

Paglalarawan ng function

Ang Qiskit Function na ito ay nagbibigay-daan sa mga gumagamit na malutas ng mga problema sa binary classification gamit ang quantum-enhanced ensemble classifier ng Singularity. Sa likod ng eksena, gumagamit ito ng hybrid approach para klasikal na i-train ang isang ensemble ng mga classifier sa labeled na dataset, at pagkatapos ay i-optimize ito para sa maximum na diversity at generalization gamit ang Quantum Approximate Optimization Algorithm (QAOA) sa mga IBM® QPU. Sa pamamagitan ng user-friendly na interface, maaaring i-configure ng mga gumagamit ang isang classifier ayon sa kanilang mga pangangailangan, i-train ito sa dataset na kanilang pinili, at gamitin ito para gumawa ng mga hula sa isang dataset na hindi pa nakikita noon.

Para malutas ang isang generic na problema sa classification:

I-preprocess ang dataset, at hatiin ito sa mga training at testing set. Opsyonal, maaari mo ring hatiin ang training set sa mga training at validation set. Maaari itong makamit gamit ang scikit-learn.
Kung ang training set ay imbalanced, maaari mo itong i-resample para balansehin ang mga klase gamit ang imbalanced-learn.
I-upload ang mga training, validation, at test set nang hiwalay sa storage ng function gamit ang file_upload na paraan ng catalog, na ipinasa ang kaugnay na path sa bawat pagkakataon.
I-initialize ang quantum classifier sa pamamagitan ng paggamit ng create action ng function, na tumatanggap ng mga hyperparameter tulad ng bilang at uri ng mga learner, ang regularization (lambda value), at mga opsyon sa optimization kabilang ang bilang ng mga layer, uri ng klasikal na optimizer, ang quantum backend, at iba pa.
I-train ang quantum classifier sa training set gamit ang fit action ng function, ipinasa ang labeled na training set, at ang validation set kung naaangkop.
Gumawa ng mga hula sa dating hindi nakitang test set gamit ang predict action ng function.

Action-based na pamamaraan

Gumagamit ang function ng action-based na pamamaraan. Maaari mo itong isipin bilang isang virtual na kapaligiran kung saan gumagamit ka ng mga action para magsagawa ng mga gawain o baguhin ang estado nito. Sa kasalukuyan, nag-aalok ito ng mga sumusunod na action: list, create, delete, fit, predict, fit_predict, at create_fit_predict. Ipinapakita ng sumusunod na halimbawa ang create_fit_predict na action.

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

# 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):  [1, 0, 0, 1, 0]
Probabilities (first five results):  [[0.16849563539001172, 0.8315043646099888], [0.8726393386620336, 0.12736066133796647], [0.795344837290717, 0.20465516270928288], [0.36822585748882725, 0.6317741425111725], [0.6656662698604361, 0.3343337301395641]]
Usage metadata:  {'RUNNING: MAPPING': {'CPU_TIME': 7.945035696029663}, 'RUNNING: WAITING_QPU': {'CPU_TIME': 82.41029238700867}, 'RUNNING: POST_PROCESSING': {'CPU_TIME': 77.3459484577179}, 'RUNNING: EXECUTING_QPU': {'QPU_TIME': 71.27004957199097}}

1. List

Kinukuha ng list action ang lahat ng nakaimbak na classifier sa format na *.pkl.tar mula sa shared data directory. Maaari mo ring ma-access ang mga nilalaman ng direktoryong ito sa pamamagitan ng paggamit ng paraan ng catalog.files(). Sa pangkalahatan, hinahanap ng list action ang mga file na may extension na *.pkl.tar sa shared data directory at ibinabalik ang mga ito sa format na list.

Mga input

Pangalan	Uri	Paglalarawan	Kinakailangan
`action`	`str`	Ang pangalan ng action mula sa `create`, `list`, `fit`, `predict`, `fit_predict`, `create_fit_predict` at `delete`.	Oo

Paggamit

job = singularity.run(action="list")

2. Create

Ang create action ay gumagawa ng classifier ng tinukoy na uri ng quantum_classifier sa pamamagitan ng paggamit ng mga ibinigay na parameter, at sine-save ito sa shared data directory.

tala

Ang function ay kasalukuyang sumusuporta lamang sa QuantumEnhancedEnsembleClassifier.

Mga input

Pangalan	Uri	Paglalarawan	Kinakailangan	Default
`action`	`str`	Ang pangalan ng action mula sa `create`, `list`, `fit`, `predict`, `fit_predict`, `create_fit_predict` at `delete`.	Oo	-
`name`	`str`	Ang pangalan ng quantum classifier, hal., `spam_classifier`.	Oo	-
`instance`	`str`	IBM instance.	Oo	-
`backend_name`	`str`	IBM compute resource. Ang default ay `None`, ibig sabihin ay gagamitin ang backend na may pinakamaunting pending na trabaho.	Hindi	`None`
`quantum_classifier`	`str`	Ang uri ng quantum classifier, i.e., `QuantumEnhancedEnsembleClassifier`.	Hindi	`QuantumEnhancedEnsembleClassifier`
`num_learners`	`integer`	Ang bilang ng mga learner sa ensemble.	Hindi	`10`
`learners_types`	`list`	Mga uri ng learner. Kabilang sa mga sinusuportahang uri ang: `DecisionTreeClassifier`, `GaussianNB`, `KNeighborsClassifier`, `MLPClassifier`, at `LogisticRegression`. Ang karagdagang detalye para sa bawat isa ay makikita sa dokumentasyon ng scikit-learn.	Hindi	`[DecisionTreeClassifier]`
`learners_proportions`	`list`	Mga proporsyon ng bawat uri ng learner sa ensemble.	Hindi	`[1.0]`
`learners_options`	`list`	Mga opsyon para sa bawat uri ng learner sa ensemble. Para sa kumpletong listahan ng mga opsyon na naaayon sa napiling uri ng learner, tingnan ang dokumentasyon ng scikit-learn.	Hindi	`[{"max_depth": 3, "splitter": "random", "class_weight": None}]`
`regularization_type`	`str` o `list`	Uri/Mga uri ng regularization na gagamitin: `onsite` o `alpha`. Ang `onsite` ay nagkokontrol sa onsite term kung saan ang mas mataas na halaga ay humahantong sa mas sparse na ensemble. Ang `alpha` ay nagkokontrol sa trade-off sa pagitan ng interaction at onsite na term kung saan ang mas mababang halaga ay humahantong sa mas sparse na ensemble. Kung ibinigay ang isang list, ang mga modelo ay ita-train para sa bawat uri at pipiliin ang pinakamahusay na gumaganap.	Hindi	`onsite`
`regularization`	`str` o `float` o `list`	Halaga ng regularization. Nakakulong sa pagitan ng `0` at `+inf` kung ang regularization_type ay `onsite`. Nakakulong sa pagitan ng `0` at `1` kung ang regularization_type ay `alpha`. Kung itinakda sa `auto`, ginagamit ang auto-regularization - ang pinakamainam na regularization parameter ay nahanap sa pamamagitan ng binary search na may nais na ratio ng mga piniling classifier sa kabuuang classifier (`regularization_desired_ratio`) at ang upper bound para sa regularization parameter (`regularization_upper_bound`). Kung ibinigay ang isang list, ang mga modelo ay ita-train para sa bawat halaga at pipiliin ang pinakamahusay na gumaganap.	Hindi	`0.01`
`regularization_desired_ratio`	`float` o `list`	Nais na ratio/Mga ratio ng mga piniling classifier sa kabuuang classifier para sa auto-regularization. Kung ibinigay ang isang list, ang mga modelo ay ita-train para sa bawat ratio at pipiliin ang pinakamahusay na gumaganap.	Hindi	`0.75`
`regularization_upper_bound`	`float` o `list`	Upper bound/Mga upper bound para sa regularization parameter kapag gumagamit ng auto-regularization. Kung ibinigay ang isang list, ang mga modelo ay ita-train para sa bawat upper bound at pipiliin ang pinakamahusay na gumaganap.	Hindi	`200`
`weight_update_method`	`str`	Pamamaraan para sa pag-update ng sample weights mula sa `logarithmic` at `quadratic`.	Hindi	`logarithmic`
`sample_scaling`	`boolean`	Kung dapat ilapat ang sample scaling.	Hindi	`False`
`prediction_scaling`	`float`	Scaling factor para sa mga hula.	Hindi	`None`
`optimizer_options`	`dictionary`	Mga opsyon ng QAOA optimizer. Ang listahan ng mga available na opsyon ay ipinakita sa bandang huli ng dokumentasyong ito.	Hindi	...
`voting`	`str`	Gumamit ng majority voting (`hard`) o average ng mga probabilidad (`soft`) para sa pagsasama-sama ng mga hula/probabilidad ng mga learner.	Hindi	`hard`
`prob_threshold`	`float`	Pinakamainam na threshold ng probabilidad.	Hindi	`0.5`
`random_state`	`integer`	Kontrolin ang randomness para sa repeatability.	Hindi	`None`

Bukod dito, ang optimizer_options ay nakalista tulad ng sumusunod:

Pangalan	Uri	Paglalarawan	Kinakailangan	Default
`num_solutions`	`integer`	Ang bilang ng mga solusyon	Hindi	`1024`
`reps`	`integer`	Ang bilang ng mga paulit-ulit	Hindi	`4`
`sparsify`	`float`	Ang sparsification threshold	Hindi	`0.001`
`theta`	`float`	Ang paunang halaga ng theta, isang variational parameter ng QAOA	Hindi	`None`
`simulator`	`boolean`	Kung gagamit ng simulator o QPU	Hindi	`False`
`classical_optimizer`	`str`	Pangalan ng klasikal na optimizer para sa QAOA. Lahat ng solver na inaalok ng SciPy, tulad ng nakalista dito, ay maaaring gamitin. Kakailanganin mong itakda ang `classical_optimizer_options` nang naaangkop	Hindi	`COBYLA`
`classical_optimizer_options`	`dictionary`	Mga opsyon ng klasikal na optimizer. Para sa kumpletong listahan ng mga available na opsyon, tingnan ang dokumentasyon ng SciPy	Hindi	`{"maxiter": 60}`
`optimization_level`	`integer`	Ang lalim ng QAOA circuit	Hindi	`3`
`num_transpiler_runs`	`integer`	Bilang ng mga run ng Transpiler	Hindi	`30`
`pass_manager_options`	`dictionary`	Mga opsyon para sa pagbuo ng preset pass manager	Hindi	`{"approximation_degree": 1.0}`
`estimator_options`	`dictionary`	Mga opsyon ng Estimator. Para sa kumpletong listahan ng mga available na opsyon, tingnan ang dokumentasyon ng Qiskit Runtime Client	Hindi	`None`
`sampler_options`	`dictionary`	Mga opsyon ng Sampler. Para sa kumpletong listahan ng mga available na opsyon, tingnan ang dokumentasyon ng Qiskit Runtime Client	Hindi	`None`

Ang default na estimator_options ay:

Pangalan	Uri	Halaga
`default_shots`	`integer`	`1024`
`resilience_level`	`integer`	`2`
`twirling`	`dictionary`	`{"enable_gates": True}`
`dynamical_decoupling`	`dictionary`	`{"enable": True}`
`resilience_options`	`dictionary`	`{"zne_mitigation": False, "zne": {"amplifier": "pea", "noise_factors": [1.0, 1.3, 1.6], "extrapolator": ["linear", "polynomial_degree_2", "exponential"],}}`

Ang default na sampler_options ay:

Pangalan	Uri	Halaga
`default_shots`	`integer`	`1024`
`resilience_level`	`integer`	`1`
`twirling`	`dictionary`	`{"enable_gates": True}`
`dynamical_decoupling`	`dictionary`	`{"enable": True}`

Paggamit

job = singularity.run(
    action="create",
    name="classifier_name",  # specify your custom name for the classifier here
    num_learners=10,
    regularization=0.01,
    optimizer_options={"simulator": True},
)

Mga validation

name:
- Ang pangalan ay dapat natatangi, isang string na hanggang 64 character ang haba.
- Maaari lamang itong maglaman ng alphanumeric na character at underscore.
- Dapat magsimula sa isang titik at hindi maaaring magtapos sa underscore.
- Walang classifier na may parehong pangalan ang dapat na mayroon na sa shared data directory.

3. Delete

Tinatanggal ng delete action ang isang classifier mula sa shared data directory.

Mga input

Pangalan	Uri	Paglalarawan	Kinakailangan
`action`	`str`	Ang pangalan ng action. Dapat ay `delete`.	Oo
`name`	`str`	Ang pangalan ng classifier na tatanggalin.	Oo

Paggamit

job = singularity.run(
    action="delete",
    name="classifier_name",  # specify the name of the classifier to delete here
)

Mga validation

name:
- Ang pangalan ay dapat natatangi, isang string na hanggang 64 character ang haba.
- Maaari lamang itong maglaman ng alphanumeric na character at underscore.
- Dapat magsimula sa isang titik at hindi maaaring magtapos sa underscore.
- Ang isang classifier na may parehong pangalan ay dapat na mayroon na sa shared data directory.

4. Fit

Sine-train ng fit action ang isang classifier gamit ang ibinigay na training data.

Mga input

Pangalan	Uri	Paglalarawan	Kinakailangan
`action`	`str`	Ang pangalan ng action. Dapat ay `fit`.	Oo
`name`	`str`	Ang pangalan ng classifier na ita-train.	Oo
`X`	`array` o `list` o `str`	Ang training data. Maaaring ito ay isang NumPy array, isang list, o isang string na tumutukoy sa isang filename sa shared data directory.	Oo
`y`	`array` o `list` o `str`	Ang mga target na halaga ng training. Maaaring ito ay isang NumPy array, isang list, o isang string na tumutukoy sa isang filename sa shared data directory.	Oo
`fit_params`	`dictionary`	Mga karagdagang parameter na ipapasa sa `fit` na paraan ng classifier.	Hindi

fit_params

Pangalan	Uri	Paglalarawan	Kinakailangan	Default
`validation_data`	`tuple`	Ang validation data at mga label.	Hindi	`None`
`pos_label`	`integer` o `str`	Ang class label na imi-map sa 1.	Hindi	`None`
`optimization_data`	`str`	Dataset para i-optimize ang ensemble. Maaaring isa sa: `train`, `validation`, `both`.	Hindi	`train`

Paggamit

job = singularity.run(
    action="fit",
    name="classifier_name",  # specify the name of the classifier to train here
    X=X_train,  # or "X_train.npy" if you uploaded it in the shared data directory
    y=y_train,  # or "y_train.npy" if you uploaded it in the shared data directory
    fit_params={},  # define the fit parameters here
)

Mga validation

name:
- Ang pangalan ay dapat natatangi, isang string na hanggang 64 character ang haba.
- Maaari lamang itong maglaman ng alphanumeric na character at underscore.
- Dapat magsimula sa isang titik at hindi maaaring magtapos sa underscore.
- Ang isang classifier na may parehong pangalan ay dapat na mayroon na sa shared data directory.

5. Predict

Ginagamit ang predict action para makakuha ng mga hard at soft prediction (mga probabilidad).

Mga input

Pangalan	Uri	Paglalarawan	Kinakailangan
`action`	`str`	Ang pangalan ng action. Dapat ay `predict`.	Oo
`name`	`str`	Ang pangalan ng classifier na gagamitin.	Oo
`X`	`array` o `list` o `str`	Ang test data. Maaaring ito ay isang NumPy array, isang list, o isang string na tumutukoy sa isang filename sa shared data directory.	Oo
`options["out"]`	`str`	Ang output JSON filename para i-save ang mga hula sa shared data directory. Kung hindi ibinigay, ibabalik ang mga hula sa resulta ng trabaho.	Hindi

Paggamit

job = singularity.run(
    action="predict",
    name="classifier_name",  # specify the name of the classifier to use here
    X=X_test,  # or "X_test.npy" if you uploaded it to the shared data directory
    options={
        "out": "output.json",
    },
)

Mga validation

name:
- Ang pangalan ay dapat natatangi, isang string na hanggang 64 character ang haba.
- Maaari lamang itong maglaman ng alphanumeric na character at underscore.
- Dapat magsimula sa isang titik at hindi maaaring magtapos sa underscore.
- Ang isang classifier na may parehong pangalan ay dapat na mayroon na sa shared data directory.
options["out"]:
- Ang filename ay dapat natatangi, isang string na hanggang 64 character ang haba.
- Maaari lamang itong maglaman ng alphanumeric na character at underscore.
- Dapat magsimula sa isang titik at hindi maaaring magtapos sa underscore.
- Dapat may extension na .json.

6. Fit-predict

Sine-train ng fit_predict action ang isang classifier gamit ang training data at pagkatapos ay ginagamit ito para makakuha ng mga hard at soft prediction (mga probabilidad).

Mga input

Pangalan	Uri	Paglalarawan	Kinakailangan
`action`	`str`	Ang pangalan ng action. Dapat ay `fit_predict`.	Oo
`name`	`str`	Ang pangalan ng classifier na gagamitin.	Oo
`X_train`	`array` o `list` o `str`	Ang training data. Maaaring ito ay isang NumPy array, isang list, o isang string na tumutukoy sa isang filename sa shared data directory.	Oo
`y_train`	`array` o `list` o `str`	Ang mga target na halaga ng training. Maaaring ito ay isang NumPy array, isang list, o isang string na tumutukoy sa isang filename sa shared data directory.	Oo
`X_test`	`array` o `list` o `str`	Ang test data. Maaaring ito ay isang NumPy array, isang list, o isang string na tumutukoy sa isang filename sa shared data directory.	Oo
`fit_params`	`dictionary`	Mga karagdagang parameter na ipapasa sa `fit` na paraan ng classifier.	Hindi
`options["out"]`	`str`	Ang output JSON filename para i-save ang mga hula sa shared data directory. Kung hindi ibinigay, ibabalik ang mga hula sa resulta ng trabaho.	Hindi

Paggamit

job = singularity.run(
    action="fit_predict",
    name="classifier_name",  # specify the name of the classifier to use here
    X_train=X_train,  # or "X_train.npy" if you uploaded it in the shared data directory
    y_train=y_train,  # or "y_train.npy" if you uploaded it in the shared data directory
    X_test=X_test,  # or "X_test.npy" if you uploaded it in the shared data directory
    fit_params={},  # define the fit parameters here
    options={
        "out": "output.json",
    },
)

Mga validation

name:
- Ang pangalan ay dapat natatangi, isang string na hanggang 64 character ang haba.
- Maaari lamang itong maglaman ng alphanumeric na character at underscore.
- Dapat magsimula sa isang titik at hindi maaaring magtapos sa underscore.
- Ang isang classifier na may parehong pangalan ay dapat na mayroon na sa shared data directory.
options["out"]:
- Ang filename ay dapat natatangi, isang string na hanggang 64 character ang haba.
- Maaari lamang itong maglaman ng alphanumeric na character at underscore.
- Dapat magsimula sa isang titik at hindi maaaring magtapos sa underscore.
- Dapat may extension na .json.

7. Create-fit-predict

Gumagawa ang create_fit_predict action ng isang classifier, sine-train ito gamit ang ibinigay na training data, at pagkatapos ay ginagamit ito para makakuha ng mga hard at soft prediction (mga probabilidad).

Mga input

Pangalan	Uri	Paglalarawan	Kinakailangan
`action`	`str`	Ang pangalan ng action mula sa `create`, `list`, `fit`, `predict`, `fit_predict`, `create_fit_predict` at `delete`.	Oo
`name`	`str`	Ang pangalan ng classifier na gagamitin.	Oo
`quantum_classifier`	`str`	Ang uri ng classifier, i.e., `QuantumEnhancedEnsembleClassifier`. Ang default ay `QuantumEnhancedEnsembleClassifier`.	Hindi
`X_train`	`array` o `list` o `str`	Ang training data. Maaaring ito ay isang NumPy array, isang list, o isang string na tumutukoy sa isang filename sa shared data directory.	Oo
`y_train`	`array` o `list` o `str`	Ang mga target na halaga ng training. Maaaring ito ay isang NumPy array, isang list, o isang string na tumutukoy sa isang filename sa shared data directory.	Oo
`X_test`	`array` o `list` o `str`	Ang test data. Maaaring ito ay isang NumPy array, isang list, o isang string na tumutukoy sa isang filename sa shared data directory.	Oo
`fit_params`	`dictionary`	Mga karagdagang parameter na ipapasa sa `fit` na paraan ng classifier.	Hindi
`options["save"]`	`boolean`	Kung ise-save ang na-train na classifier sa shared data directory. Ang default ay `True`.	Hindi
`options["out"]`	`str`	Ang output JSON filename para i-save ang mga hula sa shared data directory. Kung hindi ibinigay, ibabalik ang mga hula sa resulta ng trabaho.	Hindi

Paggamit

job = singularity.run(
    action="create_fit_predict",
    name="classifier_name",  # specify your custom name for the classifier here
    num_learners=10,
    regularization=0.01,
    optimizer_options={"simulator": True},
    X_train=X_train,  # or "X_train.npy" if you uploaded it in the shared data directory
    y_train=y_train,  # or "y_train.npy" if you uploaded it in the shared data directory
    X_test=X_test,  # or "X_test.npy" if you uploaded it in the shared data directory
    fit_params={},  # define the fit parameters here
    options={
        "save": True,
        "out": "output.json",
    },
)

Mga validation

name:
- Kung ang options["save"] ay itinakda sa True:
  - Ang pangalan ay dapat natatangi, isang string na hanggang 64 character ang haba.
  - Maaari lamang itong maglaman ng alphanumeric na character at underscore.
  - Dapat magsimula sa isang titik at hindi maaaring magtapos sa underscore.
  - Walang classifier na may parehong pangalan ang dapat na mayroon na sa shared data directory.
options["out"]:
- Ang filename ay dapat natatangi, isang string na hanggang 64 character ang haba.
- Maaari lamang itong maglaman ng alphanumeric na character at underscore.
- Dapat magsimula sa isang titik at hindi maaaring magtapos sa underscore.
- Dapat may extension na .json.

Magsimula

Mag-authenticate gamit ang iyong IBM Quantum Platform API key, at piliin ang Qiskit Function tulad ng sumusunod:

from qiskit_ibm_catalog import QiskitFunctionsCatalog

catalog = QiskitFunctionsCatalog(channel="ibm_quantum_platform")

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

Halimbawa

Sa halimbawang ito, gagamitin mo ang function na "Singularity Machine Learning - Classification" para ma-classify ang isang dataset na binubuo ng dalawang magkasalubong na kalahating bilog na hugis-buwan. Ang dataset ay synthetic, dalawang-dimensional, at may mga binary na label. Ginawa ito upang maging mahirap para sa mga algorithm tulad ng centroid-based clustering at linear classification. Moons dataset Sa prosesong ito, matututunan mo kung paano gumawa ng classifier, i-fit ito sa training data, gamitin ito para mag-predict sa test data, at tanggalin ang classifier pagkatapos. Bago magsimula, kailangan mong i-install ang scikit-learn. I-install ito gamit ang sumusunod na command:

python3 -m pip install scikit-learn

Sundin ang mga sumusunod na hakbang:

Gumawa ng synthetic dataset gamit ang function na make_moons mula sa scikit-learn.
I-upload ang nabuong synthetic dataset sa shared data directory.
Gumawa ng quantum-enhanced classifier gamit ang action na create.
Ilista ang iyong mga classifier gamit ang action na list.
I-train ang classifier sa training data gamit ang action na fit.
Gamitin ang trained classifier para mag-predict sa test data gamit ang action na predict.
Tanggalin ang classifier gamit ang action na delete.
Linisin pagkatapos mong matapos.

Hakbang 1. I-import ang mga kinakailangang module at buuin ang synthetic dataset, pagkatapos ay hatiin ito sa training at test datasets.

# 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.99958218  0.02890441]
 [ 0.03285169  0.24578719]
 [ 1.13127903 -0.49134546]
 [ 1.86951286  0.00608971]
 [ 0.20190413  0.97940529]
 [ 0.8831311   0.46912627]
 [-0.10819442  0.99412975]
 [-0.20005727  0.97978421]
 [-0.78775705  0.61598607]
 [ 1.82453236 -0.0658148 ]]
Targets: [0 1 1 1 0 0 0 0 0 1]

Hakbang 2. I-save ang mga may label na training at test datasets sa iyong lokal na disk, at pagkatapos ay i-upload ang mga ito sa shared data directory.

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

Hakbang 3. Gumawa ng quantum-enhanced classifier gamit ang action na 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', 'y_test.npy.tar', 'y_train.npy.tar', 'my_classifier.pkl.tar']

Hakbang 4. I-train ang quantum-enhanced classifier gamit ang action na 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': 8.45469617843628}, 'RUNNING: WAITING_QPU': {'CPU_TIME': 69.4949426651001}, 'RUNNING: POST_PROCESSING': {'CPU_TIME': 73.01881957054138}, 'RUNNING: EXECUTING_QPU': {'QPU_TIME': 75.4787163734436}}}}

Hakbang 5. Kumuha ng mga prediction at probability mula sa quantum-enhanced classifier gamit ang action na 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, 1, 0, 0, 1]
Probabilities (first five results): [[1.0, 0.0], [0.0, 1.0], [1.0, 0.0], [1.0, 0.0], [0.0, 1.0]]

Hakbang 6. Tanggalin ang quantum-enhanced classifier gamit ang action na 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': {}}}

Hakbang 7. Linisin ang lokal at shared data directories.

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

Mga Benchmark

Ipinapakita ng mga benchmark na ito na kaya ng classifier na makamit ang napakataas na accuracy sa mga mahirap na problema. Ipinapakita rin nito na ang pagdaragdag ng bilang ng mga learner sa ensemble (bilang ng mga qubit) ay maaaring magdulot ng mas mataas na accuracy.

Ang "Classical accuracy" ay tumutukoy sa accuracy na nakuha gamit ang katumbas na klasikal na pinakamahusay na pamamaraan na, sa kasong ito, ay isang AdaBoost classifier batay sa ensemble na may sukat na 75. Ang "Quantum accuracy" naman ay tumutukoy sa accuracy na nakuha gamit ang "Singularity Machine Learning - Classification".

Problema	Laki ng Dataset	Laki ng Ensemble	Bilang ng mga Qubit	Classical Accuracy	Quantum Accuracy	Pagpapabuti
Grid stability	5000 halimbawa, 12 feature	55	55	76%	91%	15%
Grid stability	5000 halimbawa, 12 feature	65	65	76%	92%	16%
Grid stability	5000 halimbawa, 12 feature	75	75	76%	94%	18%
Grid stability	5000 halimbawa, 12 feature	85	85	76%	94%	18%
Grid stability	5000 halimbawa, 12 feature	100	100	76%	95%	19%

Habang umuunlad at lumalaki ang quantum hardware, nagiging mas malaki ang epekto nito sa ating quantum classifier. Bagama't ang bilang ng mga qubit ay naglalagay ng limitasyon sa laki ng ensemble na maaaring gamitin, hindi nito nililimitahan ang dami ng data na maaaring iproseso. Ang makapangyarihang kakayahang ito ay nagbibigay-daan sa classifier na mahusay na hawakan ang mga dataset na naglalaman ng milyun-milyong data point at libu-libong feature. Mahalaga ring tandaan na ang mga hadlang na may kaugnayan sa laki ng ensemble ay maaaring matugunan sa pamamagitan ng pagpapatupad ng large-scale na bersyon ng classifier. Sa pamamagitan ng paggamit ng iterative outer-loop approach, maaaring dynamic na palawakin ang ensemble, na nagpapahusay ng flexibility at pangkalahatang performance. Gayunpaman, kapansin-pansin na ang feature na ito ay hindi pa naipapatupad sa kasalukuyang bersyon ng classifier.

Changelog

4 Hunyo 2025

Na-upgrade ang QuantumEnhancedEnsembleClassifier na may mga sumusunod na pagbabago:
- Idinagdag ang onsite/alpha regularization. Maaari mong itakda ang regularization_type na maging onsite o alpha
- Idinagdag ang auto-regularization. Maaari mong itakda ang regularization sa auto para gamitin ang auto-regularization
- Idinagdag ang parameter na optimization_data sa fit method para pumili ng optimization data para sa quantum optimization. Maaari kang gumamit ng isa sa mga opsyong ito: train, validation, o both
- Pinahusay ang pangkalahatang performance
Idinagdag ang detalyadong status tracking para sa mga tumatakbong job

20 Mayo 2025

Na-standardize ang error handling

18 Marso 2025

Na-upgrade ang qiskit-serverless sa 0.20.0 at base image sa 0.20.1

14 Pebrero 2025

Na-upgrade ang base image sa 0.19.1

6 Pebrero 2025

Na-upgrade ang qiskit-serverless sa 0.19.0 at base image sa 0.19.0

13 Nobyembre 2024

Inilabas ang Singularity Machine Learning - Classification

Makakuha ng suporta

Para sa anumang katanungan, makipag-ugnayan sa Multiverse Computing.

Tiyaking isama ang sumusunod na impormasyon:

Ang Qiskit Function Job ID (job.job_id)
Isang detalyadong paglalarawan ng isyu
Anumang kaugnay na mensahe o code ng error
Mga hakbang para muling likhain ang isyu

Mga susunod na hakbang

Mga Rekomendasyon

Humiling ng access sa Multiverse Computing's Singularity Machine Learning Classification function.
Suriin ang Leclerc, L., et al. (2023). Financial risk management on a neutral atom quantum processor. Physical Review Research, 5, 043117.

Pangkalahatang-ideya​

Paglalarawan ng function​

Action-based na pamamaraan​

1. List​

Mga input​

Paggamit​

2. Create​

Mga input​

Paggamit​

Mga validation​

3. Delete​

Mga input​

Paggamit​

Mga validation​

4. Fit​

Mga input​

fit_params​

Paggamit​

Mga validation​

5. Predict​

Mga input​

Paggamit​

Mga validation​

6. Fit-predict​

Mga input​

Paggamit​

Mga validation​

7. Create-fit-predict​

Mga input​

Paggamit​

Mga validation​

Magsimula​

Halimbawa​

Mga Benchmark​

Changelog​

4 Hunyo 2025​

20 Mayo 2025​

18 Marso 2025​

14 Pebrero 2025​

6 Pebrero 2025​

13 Nobyembre 2024​

Makakuha ng suporta​

Mga susunod na hakbang​

Pangkalahatang-ideya

Paglalarawan ng function

Action-based na pamamaraan

1. List

Mga input

Paggamit

2. Create

Mga input

Paggamit

Mga validation

3. Delete

Mga input

Paggamit

Mga validation

4. Fit

Mga input

fit_params

Paggamit

Mga validation

5. Predict

Mga input

Paggamit

Mga validation

6. Fit-predict

Mga input

Paggamit

Mga validation

7. Create-fit-predict

Mga input

Paggamit

Mga validation

Magsimula

Halimbawa

Mga Benchmark

Changelog

4 Hunyo 2025

20 Mayo 2025

18 Marso 2025

14 Pebrero 2025

6 Pebrero 2025

13 Nobyembre 2024

Makakuha ng suporta

Mga susunod na hakbang