Machine Learning de singularidade - Classificação: uma função Qiskit da Multiverse Computing

Consulte a referência da API

• Versões do pacote

  O código desta página foi desenvolvido com base nos seguintes requisitos. Recomendamos usar essas versões ou versões mais recentes.

  scikit-learn~=1.8.0
  

Visão geral

Com a função "Singularity Machine Learning - Classification", você pode resolver problemas de aprendizado de máquina do mundo real em hardware quântico sem precisar de conhecimento quântico. Essa função de aplicativo, baseada em métodos de conjunto, é um classificador híbrido. Ele utiliza métodos clássicos como boosting, bagging e stacking para o treinamento inicial do conjunto. Posteriormente, os algoritmos quânticos, como o eigensolver quântico variacional (VQE) e o algoritmo de otimização aproximada quântica (QAOA), são empregados para aumentar a diversidade, os recursos de generalização e a complexidade geral do conjunto treinado.

Ao contrário de outras soluções de aprendizado de máquina quântica, essa função é capaz de lidar com conjuntos de dados em grande escala com milhões de exemplos e recursos sem ser limitada pelo número de qubits na QPU de destino. O número de qubits determina apenas o tamanho do conjunto que pode ser treinado. Também é altamente flexível e pode ser usada para resolver problemas de classificação em uma ampla gama de domínios, incluindo finanças, assistência médica e segurança cibernética.

Ele alcança consistentemente altas precisões em problemas classicamente desafiadores que envolvem conjuntos de dados de alta dimensão, com ruído e desequilibrados.

Ele foi desenvolvido para:

1. Engenheiros e cientistas de dados de empresas que buscam aprimorar suas ofertas de tecnologia integrando o aprendizado de máquina quântico em seus produtos e serviços,
2. Pesquisadores de laboratórios de pesquisa quântica que exploram aplicativos de aprendizado de máquina quântica e procuram aproveitar a computação quântica para tarefas de classificação, e
3. Alunos e professores de instituições educacionais em cursos como aprendizado de máquina e que estejam procurando demonstrar as vantagens da computação quântica.

O exemplo a seguir apresenta suas várias funcionalidades, incluindo create, list, fit e predict, e demonstra seu uso em um problema sintético que compreende dois semicírculos intercalados, um problema notoriamente desafiador devido ao seu limite de decisão não linear.

Descrição da função

Essa função Qiskit permite que os usuários resolvam problemas de classificação binária usando o classificador de conjunto aprimorado por quantum da Singularity. Nos bastidores, ele usa uma abordagem híbrida para treinar classicamente um conjunto de classificadores no conjunto de dados rotulados e, em seguida, otimizá-lo para obter o máximo de diversidade e generalização usando o QAOA (Quantum Approximate Optimization Algorithm) em IBM® QPUs. Por meio de uma interface fácil de usar, os usuários podem configurar um classificador de acordo com seus requisitos, treiná-lo no conjunto de dados de sua escolha e usá-lo para fazer previsões em um conjunto de dados não visto anteriormente.

Para resolver um problema de classificação genérico:

1. Pré-processar o conjunto de dados e dividi-lo em conjuntos de treinamento e teste. Opcionalmente, você pode dividir ainda mais o conjunto de treinamento em conjuntos de treinamento e validação. Isso pode ser feito usando o scikit-learn.
2. Se o conjunto de treinamento for desequilibrado, você poderá reamostrá-lo para equilibrar as classes usando o imbalanced-learn.
3. Faça upload dos conjuntos de treinamento, validação e teste separadamente para o armazenamento da função usando o método file_upload do catálogo, passando o caminho relevante a cada vez.
4. Inicialize o classificador quântico usando a ação create da função, que aceita hiperparâmetros, como o número e os tipos de alunos, a regularização (valor lambda) e as opções de otimização, incluindo o número de camadas, o tipo de otimizador clássico, o backend quântico e assim por diante.
5. Treine o classificador quântico no conjunto de treinamento usando a ação fit da função, passando a ele o conjunto de treinamento rotulado e o conjunto de validação, se aplicável.
6. Faça previsões sobre o conjunto de testes não vistos anteriormente usando a ação predict da função.

Introdução

Autentique-se usando sua chave de API do IBM Quantum Platform e selecione a função Qiskit da seguinte forma:

from qiskit_ibm_catalog import QiskitFunctionsCatalog

catalog = QiskitFunctionsCatalog(channel="ibm_quantum_platform")

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

Exemplos

Classificar um conjunto de dados

Neste exemplo, você usará a função "Singularity Machine Learning - Classification" para classificar um conjunto de dados que consiste em dois semicírculos intercalados em forma de lua. O conjunto de dados é sintético, bidimensional e rotulado com rótulos binários. Ele foi criado para ser um desafio para algoritmos como clustering baseado em centroides e classificação linear.

Por meio desse processo, você aprenderá a criar o classificador, ajustá-lo aos dados de treinamento, usá-lo para fazer previsões nos dados de teste e excluir o classificador quando terminar.

Antes de começar, você precisa instalar o scikit-learn. Instale-o usando o seguinte comando:

python3 -m pip install scikit-learn

Execute as seguintes etapas:

1. Crie o conjunto de dados sintético usando a make_moons função do scikit-learn.
2. Carregue o conjunto de dados sintéticos gerado no diretório de dados compartilhados.
3. Crie o classificador otimizado quântico usando a create ação.
4. Registre seus classificadores usando a list ação.
5. Treine o classificador com os dados de treinamento usando a fit ação.
6. Use o classificador treinado para fazer previsões nos dados de teste usando a predict ação.
7. Exclua o classificador usando a delete ação.
8. Limpe tudo depois de terminar.

Etapa 1. Importe os módulos necessários e gere o conjunto de dados sintético e, em seguida, divida-o em conjuntos de dados de treinamento e teste.

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

Output:

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]

Etapa 2. Salve os conjuntos de dados de treinamento e teste rotulados no seu disco local e, em seguida, envie-os para o diretório de dados compartilhado.

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

Output:

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

Etapa 3. Crie um classificador otimizado por computação quântica usando a create ação.

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

Output:

{'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))

Output:

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

Etapa 4. Treine o classificador otimizado quântico usando a fit ação.

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

Output:

{'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}}}}

Etapa 5. Obtenha previsões e probabilidades do classificador aprimorado quântico usando a predict ação.

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

Output:

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

Etapa 6. Exclua o classificador otimizado quântico usando a delete ação.

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

Output:

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

Etapa 7. Limpe os diretórios de dados locais e compartilhados.

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

Output:

'Requested file was deleted.'

create_fit_predictexemplo

O exemplo a seguir ilustra a create_fit_predict ação.

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

Output:

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

Referências

Esses benchmarks mostram que o classificador pode atingir precisões extremamente altas em problemas desafiadores. Eles também mostram que o aumento do número de alunos no conjunto (número de qubits) pode levar a uma maior precisão.

"Precisão clássica" refere-se à precisão obtida usando o estado da arte clássico correspondente que, neste caso, é um classificador AdaBoost baseado em um conjunto de tamanho 75. a "precisão quântica", por outro lado, refere-se à precisão obtida usando a "Singularidade Machine Learning - Classificação".

À medida que o hardware quântico evolui e se expande, as implicações para nosso classificador quântico se tornam cada vez mais significativas. Embora o número de qubits imponha limitações ao tamanho do conjunto que pode ser utilizado, ele não restringe o volume de dados que pode ser processado. Esse recurso avançado permite que o classificador manipule com eficiência conjuntos de dados que contêm milhões de pontos de dados e milhares de recursos. É importante ressaltar que as restrições relacionadas ao tamanho do conjunto podem ser resolvidas por meio da implementação de uma versão em grande escala do classificador. Ao aproveitar uma abordagem iterativa de loop externo, o conjunto pode ser expandido dinamicamente, aumentando a flexibilidade e o desempenho geral. No entanto, vale a pena observar que esse recurso ainda não foi implementado na versão atual do classificador.

Log de mudanças

4 de junho de 2025

• Atualizado QuantumEnhancedEnsembleClassifier com as seguintes atualizações:
  • Adição de regularização no local/alfa. Você pode especificar regularization_type para ser onsite ou alpha
  • Adicionada a regularização automática. Você pode definir regularization como auto para usar a regularização automática
  • Adicionado o parâmetro optimization_data ao método fit para escolher dados de otimização para otimização quântica. Você pode usar uma destas opções: train, validation, ou both
  • Melhoria do desempenho geral
• Adição do rastreamento detalhado do status dos trabalhos em execução

20 de maio de 2025

• Tratamento de erros padronizado

18 de março de 2025

• Atualizou o qiskit-serverless para 0.20.0 e a imagem base para 0.20.1

14 de fevereiro de 2025

• Imagem base atualizada para 0.19.1

6 de fevereiro de 2025

• Atualizou o qiskit-serverless para 0.19.0 e a imagem base para 0.19.0

13 de novembro de 2024

• Lançamento do Singularity Machine Learning - Classificação

Obtenha suporte

Em caso de dúvidas, entre em contato com a Multiverse Computing.

Certifique-se de incluir as seguintes informações:

• A função Qiskit ID do trabalho (job.job_id)
• Uma descrição detalhada do problema
• Quaisquer mensagens ou códigos de erro relevantes
• Etapas para reproduzir o problema

Próximas etapas