Nota

Esta página foi gerada a partir de tutorials/machine_learning/01_qsvm_classification.ipynb.

Execute interativamente no IBM Quantum lab.

Máquina de Vetor de Suporte aprimorado Quantum (QSVM)

Algoritmos de classificação e métodos para aprendizado de máquina são essenciais para o reconhecimento de padrões e aplicações de mineração de dados. Técnicas bem conhecidas, como máquinas vetoriais de suporte e redes neurais, floresceram nas duas últimas décadas como resultado dos espetaculares avanços nas capacidades e velocidade computacionais do hardware clássico. Este progresso no poder computacional permitiu a aplicação de técnicas cujas teorias foram desenvolvidas em meados do século 20, de problemas de classificação que se tornavam cada vez mais desafiadores.

Um conceito-chave nos métodos de classificação é o de um kernel. Os dados normalmente não podem ser separados por um hiperplano no seu espaço original. Uma técnica comum usada para encontrar um tal hiperplano consiste em aplicar uma função de transformação não-linear aos dados. Esta função é chamada de um mapa de ativação, uma vez que transforma as características brutas, ou propriedades mensuráveis, do fenômeno ou do sujeito em estudo. Classificando este novo espaço de funcionalidade - e, de fato, também em qualquer outro espaço, incluindo o original - é nada mais do que ver como os pontos de dados estão próximos um do outro. Isso é o mesmo que calcular o produto interno para cada par de pontos de dados no conjunto. Então, na verdade, não precisamos calcular o mapa de ativação não-lineares para cada dado, mas apenas o produto interno de cada par de dados no novo espaço de recursos. Esta coleção de produtos internos é chamada de kernel e é perfeitamente possível ter mapas de recursos que são difíceis de calcular mas cujos kernels não são.

Neste capitulo nós fornecemos um exemplo de um problema de classificação que requer um mapa de ativação para o qual computar o kernel não é eficiente - isso significa que os recursos computacionais necessários devem escalar exponencialmente com o tamanho do problema. Nós mostramos como isso pode ser resolvido em um processador quântico através de uma estimativa direta do kernel no espaço de recurso. O método que utilizámos insere-se na categoria daquilo a que se chama aprendizado supervisionado, consistindo de uma fase de treinamento (onde o kernel é calculado e os vetores de suporte obtidos) e uma fase de teste ou classificação (onde dados não rotulados são classificados de acordo com a solução encontrada na fase de treinamento).

Referências e detalhes adicionais:

[1] Vojtech Havlicek, Antonio D. C´orcoles, Kristan Temme, Aram W. Harrow, Abhinav Kandala, Jerry M. Chow, and Jay M. Gambetta1, “Supervised learning with quantum enhanced feature spaces,” arXiv: 1804.11326

import matplotlib.pyplot as plt
import numpy as np

from qiskit import BasicAer
from qiskit.circuit.library import ZZFeatureMap
from qiskit.aqua import QuantumInstance, aqua_globals
from qiskit.aqua.algorithms import QSVM
from qiskit.aqua.utils import split_dataset_to_data_and_labels, map_label_to_class_name

seed = 10599
aqua_globals.random_seed = seed

Conjunto de dados ad hoc

Como um primeiro exemplo, usaremos o dataset ad hoc como descrito no documento referenciado acima. No conjunto de dados pegamos amostras para uso como treinamento, teste e previsão final (pontos de dados).

from qiskit.ml.datasets import ad_hoc_data, sample_ad_hoc_data

feature_dim = 2
sample_total, training_input, test_input, class_labels = ad_hoc_data(
    training_size=20,
    test_size=10,
    n=feature_dim,
    gap=0.3,
    plot_data=True
)
extra_test_data = sample_ad_hoc_data(sample_total, 10, n=feature_dim)
datapoints, class_to_label = split_dataset_to_data_and_labels(extra_test_data)
print(class_to_label)

{'A': 0, 'B': 1}

Com o conjunto de dados pronto, podemos configurar o algoritmo QSVM para fazer uma classificação. Aqui utilizamos o circuito de codificação ZZFeatureMap de dados da biblioteca de circuitos Qiskit.

Aqui o BasicAer qasm_simulator é usado com 1024 coletas.

Para o teste, o resultado inclui os pormenores e a relação de sucesso; Para a previsão, o resultado inclui os rótulos previstos.

feature_map = ZZFeatureMap(feature_dimension=feature_dim, reps=2, entanglement='linear')
qsvm = QSVM(feature_map, training_input, test_input, datapoints[0])

backend = BasicAer.get_backend('qasm_simulator')
quantum_instance = QuantumInstance(backend, shots=1024, seed_simulator=seed, seed_transpiler=seed)

result = qsvm.run(quantum_instance)

print(f'Testing success ratio: {result["testing_accuracy"]}')
print()
print('Prediction from datapoints set:')
print(f'  ground truth: {map_label_to_class_name(datapoints[1], qsvm.label_to_class)}')
print(f'  prediction:   {result["predicted_classes"]}')
predicted_labels = result["predicted_labels"]
print(f'  success rate: {100*np.count_nonzero(predicted_labels == datapoints[1])/len(predicted_labels)}%')

Testing success ratio: 1.0

Prediction from datapoints set:
  ground truth: ['A', 'A', 'A', 'A', 'A', 'A', 'A', 'A', 'A', 'A', 'B', 'B', 'B', 'B', 'B', 'B', 'B', 'B', 'B', 'B']
  prediction:   ['A', 'A', 'A', 'A', 'A', 'A', 'A', 'A', 'A', 'A', 'B', 'B', 'B', 'B', 'B', 'B', 'B', 'B', 'B', 'B']
  success rate: 100.0%

O seguinte mostra a matriz de kernel que foi construída a partir da amostra de treinamento do dataset.

kernel_matrix = result['kernel_matrix_training']
plt.imshow(np.asmatrix(kernel_matrix),interpolation='nearest',origin='upper',cmap='bone_r');

Qiskit também tem uma implementação SVM clássica que usa os mesmos dados de entrada para a classificação. Vamos executar isso e fazer uma comparação. Agora, o conjunto de dados ad hoc foi criado para mostrar que pode haver conjuntos de dados onde o quantum poderia oferecer uma vantagem.

from qiskit.aqua.algorithms import SklearnSVM

result = SklearnSVM(training_input, test_input, datapoints[0]).run()

print(f'Testing success ratio: {result["testing_accuracy"]}')
print()
print('Prediction from datapoints set:')
print(f'  ground truth: {map_label_to_class_name(datapoints[1], qsvm.label_to_class)}')
print(f'  prediction:   {result["predicted_classes"]}')
predicted_labels = result["predicted_labels"]
print(f'  success rate: {100*np.count_nonzero(predicted_labels == datapoints[1])/len(predicted_labels)}%')

kernel_matrix = result['kernel_matrix_training']
plt.imshow(np.asmatrix(kernel_matrix), interpolation='nearest', origin='upper', cmap='bone_r');

Testing success ratio: 0.65

Prediction from datapoints set:
  ground truth: ['A', 'A', 'A', 'A', 'A', 'A', 'A', 'A', 'A', 'A', 'B', 'B', 'B', 'B', 'B', 'B', 'B', 'B', 'B', 'B']
  prediction:   ['B', 'A', 'A', 'A', 'B', 'B', 'B', 'B', 'A', 'A', 'A', 'B', 'B', 'B', 'A', 'B', 'A', 'B', 'B', 'A']
  success rate: 55.0%

O conjunto de dados do câncer de mama

Agora executamos nosso algoritmo com um conjunto de dados do mundo real: o conjunto de dados para o câncer de mama, nós usamos os dois primeiros componentes principais como recursos.

from qiskit.ml.datasets import breast_cancer

feature_dim = 2
sample_total, training_input, test_input, class_labels = breast_cancer(
    training_size=20,
    test_size=10,
    n=feature_dim,
    plot_data=True
)

feature_map = ZZFeatureMap(feature_dimension=feature_dim, reps=2, entanglement='linear')
qsvm = QSVM(feature_map, training_input, test_input)

backend = BasicAer.get_backend('qasm_simulator')
quantum_instance = QuantumInstance(backend, shots=1024, seed_simulator=seed, seed_transpiler=seed)

result = qsvm.run(quantum_instance)

print(f'Testing success ratio: {result["testing_accuracy"]}')

Testing success ratio: 0.9

A matriz de kernel que foi construída a partir da amostra de treinamento do conjunto de dados.

kernel_matrix = result['kernel_matrix_training']
img = plt.imshow(np.asmatrix(kernel_matrix),interpolation='nearest',origin='upper',cmap='bone_r')

Mais uma vez, podemos comparar o resultado com uma abordagem clássica.

result = SklearnSVM(training_input, test_input).run()

print(f'Testing success ratio: {result["testing_accuracy"]}')

kernel_matrix = result['kernel_matrix_training']
plt.imshow(np.asmatrix(kernel_matrix), interpolation='nearest', origin='upper', cmap='bone_r');

Testing success ratio: 0.85

import qiskit.tools.jupyter
%qiskit_version_table
%qiskit_copyright

Version Information

Qiskit Software	Version
Qiskit	0.23.1
Terra	0.16.1
Aer	0.7.1
Ignis	0.5.1
Aqua	0.8.1
IBM Q Provider	0.11.1
System information
Python	3.6.1 |Continuum Analytics, Inc.| (default, May 11 2017, 13:09:58) [GCC 4.4.7 20120313 (Red Hat 4.4.7-1)]
OS	Linux
CPUs	1
Memory (Gb)	5.827335357666016
Fri Nov 13 15:24:51 2020 EST

This code is a part of Qiskit

© Copyright IBM 2017, 2020.

This code is licensed under the Apache License, Version 2.0. You may
obtain a copy of this license in the LICENSE.txt file in the root directory
of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.

Any modifications or derivative works of this code must retain this
copyright notice, and modified files need to carry a notice indicating
that they have been altered from the originals.