Nota

Esta página foi gerada a partir de aqua_tutorials/Qiskit Algorithms Migration Guide.ipynb.

Execute interativamente no IBM Quantum lab.

Guia de Migração dos algoritmos do Qiskit¶

Reestruturando os aplicativos

A release do Qiskit 0.25.0 inclui uma reestruturação dos aplicativos e algoritmos. O que anteriormente foi referido como Qiskit Aqua, o módulo único de aplicações e algoritmos do Qiskit, está agora dividido em módulos de aplicação dedicados para Otimização, Finanças, Machine Learning (Aprendizagem Automática) e Natureza (incluindo Física e Química). As funcionalidades principais de algoritmos e operador opflow foram movidas para o Qiskit Terra.

Interface de algoritmos

Adicionalmente à reestruturação, todos os algoritmos seguem um novo paradigma unificado: os algoritmos são classificados de acordo com os problemas que eles resolvem e, dentro de uma classe de aplicações para algoritmos, podem ser usados de forma intercambiável para resolver o mesmo problema. Isso significa que, ao contrário de antes, as instâncias de algoritmo são dissociadas do problema que resolvem. Podemos resumir isso em um fluxograma:

Drawing

Por exemplo, o eigensolver quântico variacional, VQE é um MinimumEigensolver uma vez que computa o eigenvalue mínimo de um operador. O problema aqui é especificado com o operador, cujo eigenvalue buscamos, enquanto propriedades como circuito variacional de ansatz e o otimizador clássico são propriedades do algoritmo. Isso significa que o VQE tem a seguinte estrutura

vqe = VQE(ansatz, optimizer)
result = vqe.compute_minimum_eigenvalue(operator)

Podemos trocar o VQE com qualquer outro algoritmo que implemente a interface MinimumEigensolver para calcular os eigenvalues (auto valor) do seu operador, por exemplo

numpy_based = NumPyMinimumEigensolver()
classical_reference = numpy_based.compute_minimum_eigenvalue(operator)

Isso permite alternar facilmente entre algoritmos diferentes, comparar com as referências clássicas e fornecer sua própria implementação \(-\) você apenas tem que implementar a interface existente.

Este notebook serve como guia de migração para facilitar a mudança do seu código atual usando Qiskit Aqua para a nova estrutura.

Estamos desativando o aviso de depreciação para este notebook e você não verá nenhum quando instanciarmos um objeto de qiskit. qua. No entanto, observe que o pacote inteiro está obsoleto e emitirá um aviso como o seguinte:

[1]:

from qiskit.aqua.components.optimizers import COBYLA

optimizer = COBYLA()

/Users/manoel/projects/Quantum/qiskit-aqua/qiskit/aqua/components/optimizers/optimizer.py:50: DeprecationWarning: The package qiskit.aqua.components.optimizers is deprecated. It was moved/refactored to qiskit.algorithms.optimizers (pip install qiskit-terra). For more information see <https://github.com/Qiskit/qiskit-aqua/blob/master/README.md#migration-guide>
  'qiskit.algorithms.optimizers', 'qiskit-terra')

[2]:

import warnings
warnings.simplefilter('ignore', DeprecationWarning)

QuantumInstance¶

A QuantumInstance moveu o local de importação de

qiskit.aqua.QuantumInstance

para

qiskit.utils.QuantumInstance

Anteriormente:

[3]:

from qiskit import Aer
from qiskit.aqua import QuantumInstance as AquaQuantumInstance

backend = Aer.get_backend('statevector_simulator')
aqua_qinstance = AquaQuantumInstance(backend, seed_simulator=2, seed_transpiler=2)

Novo:

[4]:

from qiskit import Aer
from qiskit.utils import QuantumInstance

backend = Aer.get_backend('statevector_simulator')
qinstance = QuantumInstance(backend, seed_simulator=2, seed_transpiler=2)

Operadores¶

Os operadores do Opflow movidos de

qiskit.aqua.operators

para

qiskit.opflow

Anteriormente:

[5]:

from qiskit.aqua.operators import X, I, Y

op = (X ^ I) + (Y ^ 2)

Novo:

[6]:

from qiskit.opflow import X, I, Y

op = (X ^ I) + (Y ^ 2)

Recursos adicionais

Com qiskit.opflow nós apresentamos uma nova e mais eficiente representação de somas de Pauli strings, que pode acelerar significativamente os cálculos em somas muito grandes de Paulis. Esta representação eficiente é usada automaticamente se as strings de Pauli forem calculadas:

[7]:

op = (X ^ X ^ Y ^ Y) + (X ^ 4) + (Y ^ 4) + (I ^ X ^ I ^ I)
type(op)

[7]:

qiskit.opflow.primitive_ops.pauli_sum_op.PauliSumOp

Otimizadores¶

As rotinas de otimização clássica mudaram de local de

qiskit.aqua.components.optimizers

para

qiskit.algorithms.optimizers

Anteriormente:

[8]:

from qiskit.aqua.components.optimizers import SPSA

spsa = SPSA(maxiter=10)

Novo:

[9]:

from qiskit.algorithms.optimizers import SPSA

spsa = SPSA(maxiter=10)

Grover¶

Resumo¶

A estrutura anterior

grover = Grover(oracle_settings, algorithm_settings)
result = grover.run()

foi alterado para dividir as configurações de problemas/oraculo e configurações de algoritmo, para

grover = Grover(algorithm_settings)
problem = AmplificationProblem(oracle_settings)
result = grover.amplify(problem)

Guia de migração¶

Para oraculos fornecidos como circuitos e a função is_good_state para determinar estados bons

[10]:

from qiskit.circuit import QuantumCircuit

oracle = QuantumCircuit(2)
oracle.cz(0, 1)

def is_good_state(bitstr):
    return sum(map(int, bitstr)) == 2

Anteriormente:

[11]:

from qiskit.aqua.algorithms import Grover

grover = Grover(oracle, is_good_state, quantum_instance=aqua_qinstance)
result = grover.run()
print('Top measurement:', result.top_measurement)

Top measurement: 11

Novo:

[12]:

from qiskit.algorithms import Grover, AmplificationProblem

problem = AmplificationProblem(oracle=oracle, is_good_state=is_good_state)
grover = Grover(quantum_instance=qinstance)
result = grover.amplify(problem)
print('Top measurement:', result.top_measurement)

Top measurement: 11

Uma vez que estamos simplificando todos os algoritmos para usar a classe QuantumCircuit como base primitiva, definir oracles usando a classe qiskit.aqua.compontents.Oracle foi descontinuado. Em vez de usar, por exemplo, o LogicalExpressionOracle, agora você pode usar o circuito PhaseOracle a partir da biblioteca de circuitos.

Anteriormente:

[13]:

from qiskit.aqua.components.oracles import LogicalExpressionOracle
from qiskit.aqua.algorithms import Grover

oracle = LogicalExpressionOracle('x & ~y')
grover = Grover(oracle, quantum_instance=aqua_qinstance)
result = grover.run()
print('Top measurement:', result.top_measurement)

Top measurement: 01

Novo:

[14]:

from qiskit.circuit.library import PhaseOracle
from qiskit.algorithms import Grover, AmplificationProblem

oracle = PhaseOracle('x & ~y')
problem = AmplificationProblem(oracle=oracle, is_good_state=oracle.evaluate_bitstring)
grover = Grover(quantum_instance=qinstance)
result = grover.amplify(problem)
print('Top measurement:', result.top_measurement)

Top measurement: 11

O qiskit.aqua.components.oracles.TruthTableOracle ainda não foi convertido, mas o comportamento pode ser facilmente obtido com o módulo qiskit.circuit.classicalfunction, veja os tutoriais no algoritmo Grover.

Mais exemplos¶

Para construir o circuito, podemos chamar construct_circuit e passar a instância de problema em que estamos interessados:

[15]:

power = 2
grover.construct_circuit(problem, power).draw('mpl', style='iqx')

[15]:

../_images/aqua_tutorials_Qiskit_Algorithms_Migration_Guide_37_0.png

Estimativa da amplitude¶

Resumo¶

Para todos os algoritmos de estimativa de amplitude * AmplitudeEstimation * IterativeAmplitudeEstimation * MaximumLikelihoodAmplitudeEstimation e * FasterAmplitudeEstimation

a interface alterada de

qae = AmplitudeEstimation(algorithm_settings, estimation_settings)
result = qae.run()

para dividir as configurações de problemas/oraculo e configurações de algoritmo

qae = AmplitudeEstimation(algorithm_settings)
problem = EstimationProblem(oracle_settings)
result = qae.amplify(problem)

Guia de migração¶

Aqui, gostaríamos de estimar a probabilidade de medir um \(|1\rangle\) no nosso único qubit. Se a preparação do estado for fornecida como circuito

[16]:

import numpy as np

probability = 0.25
rotation_angle = 2 * np.arcsin(np.sqrt(probability))

state_preparation = QuantumCircuit(1)
state_preparation.ry(rotation_angle, 0)

objective_qubits = [0]  # the good states are identified by qubit 0 being in state |1>

print('Target probability:', probability)

state_preparation.draw(output='mpl', style='iqx')

Target probability: 0.25

[16]:

../_images/aqua_tutorials_Qiskit_Algorithms_Migration_Guide_40_1.png

Anteriormente:

[17]:

from qiskit.aqua.algorithms import AmplitudeEstimation

# instantiate the algorithm and passing the problem instance
ae = AmplitudeEstimation(3, state_preparation, quantum_instance=aqua_qinstance)

# run the algorithm
result = ae.run()

# print the results
print('Grid-based estimate:', result.estimation)
print('Improved continuous estimate:', result.mle)

Grid-based estimate: 0.1464466
Improved continuous estimate: 0.2499999956539467

Agora:

[18]:

from qiskit.algorithms import AmplitudeEstimation, EstimationProblem

problem = EstimationProblem(state_preparation=state_preparation, objective_qubits=objective_qubits)
ae = AmplitudeEstimation(num_eval_qubits=3, quantum_instance=qinstance)

result = ae.estimate(problem)
print('Grid-based estimate:', result.estimation)
print('Improved continuous estimate:', result.mle)

Grid-based estimate: 0.1464466
Improved continuous estimate: 0.2499999956513743

Note que a antiga classe usou o último qubit no state_preparation como padrão objetivo, se nenhum outro índice foi especificado. Este padrão não existe mais para melhorar a transparência e remover pressupostos implícitos.

Mais exemplos¶

Para construir o circuito para estimativa de amplitude, nós podemos fazer

[19]:

ae.construct_circuit(estimation_problem=problem).draw('mpl', style='iqx')

[19]:

../_images/aqua_tutorials_Qiskit_Algorithms_Migration_Guide_48_0.png

Agora que o problema está separado do algoritmo que podemos trocar AmplitudeEstimation com qualquer outro algoritmo que implemente a interface AmplitudeEstimator.

[20]:

from qiskit.algorithms import IterativeAmplitudeEstimation

iae = IterativeAmplitudeEstimation(epsilon_target=0.01, alpha=0.05, quantum_instance=qinstance)

result = iae.estimate(problem)
print('Estimate:', result.estimation)

Estimate: 0.24999999999999994

[21]:

from qiskit.algorithms import MaximumLikelihoodAmplitudeEstimation

mlae = MaximumLikelihoodAmplitudeEstimation(evaluation_schedule=[0, 2, 4], quantum_instance=qinstance)

result = mlae.estimate(problem)
print('Estimate:', result.estimation)

Estimate: 0.2500081904035319

Autovalores mínimos¶

Resumo¶

A interface permaneceu principalmente a mesma, mas onde anteriormente era possível passar o operador no inicializador .
Os operadores devem agora ser construídos com operadores do qiskit.opflow ao invés do qiskit.aqua.operators.
O argumento VQE var_form foi renomeado para ansatz.

Guia de migração¶

Suponha que queremos encontrar o valor mínimo do auto valor de

\[H = Z \otimes I.\]

Eigensolver NumPy-based¶

Anteriormente:

Previously we imported the operators from qiskit.aqua.operators:

[22]:

from qiskit.aqua.operators import Z, I

observable = Z ^ I

e depois resolvido para o eigenvalue mínimo usando

[23]:

from qiskit.aqua.algorithms import NumPyMinimumEigensolver

mes = NumPyMinimumEigensolver()
result = mes.compute_minimum_eigenvalue(observable)
print(result.eigenvalue)

(-1+0j)

It used to be possible to pass the observable in the initializer, which is now not allowed anymore due to the problem-algorithm separation.

[24]:

mes = NumPyMinimumEigensolver(observable)
result = mes.compute_minimum_eigenvalue()
print(result.eigenvalue)

(-1+0j)

Agora:

Agora precisamos importar de qiskit.opflow mas a outra sintaxe permanece exatamente a mesma:

[25]:

from qiskit.opflow import Z, I

observable = Z ^ I

[26]:

from qiskit.algorithms import NumPyMinimumEigensolver

mes = NumPyMinimumEigensolver()

result = mes.compute_minimum_eigenvalue(observable)
print(result.eigenvalue)

(-1+0j)

VQE¶

As mesmas alterações aplicam-se para o VQE. Vamos usar o circuito RealAmplitudes como ansatz:

[27]:

from qiskit.circuit.library import RealAmplitudes

ansatz = RealAmplitudes(2, reps=1)
ansatz.draw(output='mpl', style='iqx')

[27]:

../_images/aqua_tutorials_Qiskit_Algorithms_Migration_Guide_65_0.png

Anteriormente:

Anteriormente, tivemos que importar tanto o otimizador quanto os operadores do Qiskit Aqua:

[28]:

from qiskit.aqua.algorithms import VQE
from qiskit.aqua.components.optimizers import COBYLA
from qiskit.aqua.operators import Z, I

observable = Z ^ I

vqe = VQE(var_form=ansatz, optimizer=COBYLA(), quantum_instance=aqua_qinstance)
result = vqe.compute_minimum_eigenvalue(observable)
print(result.eigenvalue)

(-0.999999996802599+0j)

Agora:

Agora importamos otimizadores de qiskit.algorithms.optimizers e operadores de qiskit.opflow.

[29]:

from qiskit.algorithms import VQE
from qiskit.algorithms.optimizers import COBYLA
from qiskit.opflow import Z, I

observable = Z ^ I

vqe = VQE(ansatz=ansatz, optimizer=COBYLA(), quantum_instance=qinstance)
result = vqe.compute_minimum_eigenvalue(observable)
print(result.eigenvalue)

-0.9999999976790017

Observe que o qiskit.aqua.components.variational_forms está completamente obsoleto em favor de objetos de circuito. A maioria das formas variacionais já foi portada para a biblioteca de circuitos em versões anteriores e agora também UCCSD faz parte da biblioteca de circuitos da Qiskit Nature:

Anteriormente:

[30]:

from qiskit.circuit import ParameterVector
from qiskit.chemistry.components.variational_forms import UCCSD

varform = UCCSD(4, (1, 1), qubit_mapping='jordan_wigner', two_qubit_reduction=False)
parameters = ParameterVector('x', varform.num_parameters)

circuit = varform.construct_circuit(parameters)
circuit.draw('mpl', style='iqx')

[30]:

../_images/aqua_tutorials_Qiskit_Algorithms_Migration_Guide_72_0.png

Novo:

[31]:

from qiskit_nature.mappers.second_quantization import JordanWignerMapper
from qiskit_nature.operators.second_quantization.qubit_converter import QubitConverter
from qiskit_nature.circuit.library import UCCSD

qubit_converter = QubitConverter(JordanWignerMapper())

circuit = UCCSD(qubit_converter, (1, 1), 4)
circuit.draw('mpl', style='iqx')

[31]:

../_images/aqua_tutorials_Qiskit_Algorithms_Migration_Guide_74_0.png

QAOA¶

For Hamiltonians from combinatorial optimization (like ours: \(Z \otimes I\)) we can use the QAOA algorithm.

Anteriormente:

[32]:

from qiskit.aqua.algorithms import QAOA
from qiskit.aqua.components.optimizers import COBYLA
from qiskit.aqua.operators import Z, I

observable = Z ^ I

qaoa = QAOA(optimizer=COBYLA(), quantum_instance=aqua_qinstance)
result = qaoa.compute_minimum_eigenvalue(observable)
print(result.eigenvalue)

(-0.999999982019625+0j)

Agora:

[33]:

from qiskit.algorithms import QAOA
from qiskit.algorithms.optimizers import COBYLA
from qiskit.opflow import Z, I

observable = Z ^ I

qaoa = QAOA(optimizer=COBYLA(), quantum_instance=qinstance)
result = qaoa.compute_minimum_eigenvalue(observable)
print(result.eigenvalue)

-0.9999999768364134

Mais exemplos:

[34]:

qaoa.construct_circuit([1, 2], observable)[0].draw(output='mpl', style='iqx')

[34]:

../_images/aqua_tutorials_Qiskit_Algorithms_Migration_Guide_81_0.png

CPLEX clássico¶

The ClassicalCPLEX algorithm is now available via the CplexOptimizer interface in the machine learning module.

Anteriormente:

[35]:

from qiskit.aqua.algorithms import ClassicalCPLEX
from qiskit.aqua.operators import WeightedPauliOperator
from qiskit.quantum_info import Pauli

op = WeightedPauliOperator([
    [1, Pauli('ZZIII')],
    [1, Pauli('ZIIIZ')],
    [1, Pauli('IZZII')]
])

cplex = ClassicalCPLEX(op, display=0)
result = cplex.run()
print('Energy:', result['energy'])

Version identifier: 20.1.0.0 | 2020-11-11 | 9bedb6d68
CPXPARAM_Read_DataCheck                          1
CPXPARAM_Threads                                 1
CPXPARAM_MIP_Display                             0
CPXPARAM_TimeLimit                               600
CPXPARAM_MIP_Tolerances_MIPGap                   0
CPXPARAM_MIP_Tolerances_Integrality              0
Energy: -3.0

Novo:

[36]:

from qiskit_optimization import QuadraticProgram
from qiskit_optimization.algorithms import CplexOptimizer
from qiskit.opflow import I, Z

op = (Z ^ Z ^ I ^ I ^ I) + (Z ^ I ^ I ^ I ^ Z) + (I ^ Z ^ Z ^ I ^ I)

qp = QuadraticProgram()
qp.from_ising(op)

cplex = CplexOptimizer()
result = cplex.solve(qp)

print('Energy:', result.fval)

Energy: -3.0

(Geral) Eigenvalues¶

Resumo¶

Quanto ao MinimumEigenSolver, a única mudança para o EigenSolver é o tipo para o observável e o caminho de importação.

Guia de migração¶

Anteriormente:

[37]:

from qiskit.aqua.algorithms import NumPyEigensolver
from qiskit.aqua.operators import I, Z

observable = Z ^ I

es = NumPyEigensolver(k=3)  # get the lowest 3 eigenvalues

result = es.compute_eigenvalues(observable)
print(result.eigenvalues)

[-1.+0.j -1.+0.j  1.+0.j]

Agora:

[38]:

from qiskit.algorithms import NumPyEigensolver
from qiskit.aqua.operators import I, Z

observable = Z ^ I

es = NumPyEigensolver(k=3)  # get the lowest 3 eigenvalues

result = es.compute_eigenvalues(observable)
print(result.eigenvalues)

[-1.+0.j -1.+0.j  1.+0.j]

Algoritmo de Shor¶

Resumo¶

Os argumentos N e a foram movidos do inicializador para o método Shor.factor.

Guia de migração¶

Nós vamos usar uma leitura shot-based para velocidade aqui.

[39]:

aqua_qasm_qinstance = AquaQuantumInstance(Aer.get_backend('qasm_simulator'))
qasm_qinstance = QuantumInstance(Aer.get_backend('qasm_simulator'))

Anteriormente:

[40]:

from qiskit.aqua.algorithms import Shor

shor = Shor(N=9, a=2, quantum_instance=aqua_qinstance)

result = shor.run()
print('Factors:', result['factors'])

Factors: [3]

Novo:

[41]:

from qiskit.algorithms import Shor

shor = Shor(quantum_instance=qinstance)

result = shor.factor(N=9, a=2)
print('Factors:', result.factors)

Factors: [3]

HHL¶

Resumo¶

HHL has been completely refactored to allow an intuitive interface and return an efficient, circuit-based representation of the result.

Guia de migração¶

Suponha que queremos resolver o seguinte sistema linear

\[\begin{split}\begin{pmatrix} 1 & -1/3 \\ -1/3 & 1 \\ \end{pmatrix} \vec x = \begin{pmatrix} 1 \\ 0 \end{pmatrix}\end{split}\]

[42]:

import numpy as np

matrix = np.array([[1, -1/3], [-1/3, 1]])
vector = np.array([1, 0])

Anteriormente:

[43]:

from qiskit.circuit.library import QFT
from qiskit.aqua.algorithms import HHL
from qiskit.aqua.components.eigs import EigsQPE
from qiskit.aqua.components.reciprocals import LookupRotation
from qiskit.aqua.components.initial_states import Custom
from qiskit.aqua.operators import MatrixOperator

def create_eigs(matrix, num_auxiliary, num_time_slices, negative_evals):
    ne_qfts = [None, None]
    if negative_evals:
        num_auxiliary += 1
        ne_qfts = [QFT(num_auxiliary - 1), QFT(num_auxiliary - 1).inverse()]
    return EigsQPE(MatrixOperator(matrix=matrix),
                   QFT(num_auxiliary).inverse(),
                   num_time_slices=num_time_slices,
                   num_ancillae=num_auxiliary,
                   expansion_mode='suzuki',
                   expansion_order=2,
                   evo_time=None,
                   negative_evals=negative_evals,
                   ne_qfts=ne_qfts)

orig_size = len(vector)

matrix, vector, truncate_powerdim, truncate_hermitian = HHL.matrix_resize(matrix, vector)

# Initialize eigenvalue finding module
eigs = create_eigs(matrix, 3, 50, False)
num_q, num_a = eigs.get_register_sizes()

# Initialize initial state module
init_state = Custom(num_q, state_vector=vector)

# Initialize reciprocal rotation module
reci = LookupRotation(negative_evals=eigs._negative_evals, evo_time=eigs._evo_time)
algo = HHL(matrix, vector, truncate_powerdim, truncate_hermitian, eigs,
           init_state, reci, num_q, num_a, orig_size)

result = algo.run(aqua_qinstance)
print(result.solution)

[ 0.66575607-5.39389682e-15j -0.38561455+4.35672537e-15j]

Agora:

[44]:

from qiskit.algorithms.linear_solvers import HHL

hhl = HHL()
result = hhl.solve(matrix, vector)
result.state.draw('mpl', style='iqx')

[44]:

../_images/aqua_tutorials_Qiskit_Algorithms_Migration_Guide_104_0.png

Note that the solution vector is not returned, since that would require an exponentially expensive simulation of the solution circuit. Instead, the circuit can be used to evaluate observables on the solution. For details, see the documentation and docstrings of HHL.

Solucionador linear NumPy-based¶

Anteriormente:

[45]:

from qiskit.aqua.algorithms import NumPyLSsolver

ls = NumPyLSsolver(matrix, vector)
result = ls.run()
print(result.solution)

[1.125, 0.375]

Agora:

[46]:

from qiskit.algorithms import NumPyLinearSolver

ls = NumPyLinearSolver()
result = ls.solve(matrix, vector)
print(result.state)

[1.125 0.375]

Estimação de fase¶

Resumo¶

A estimativa de fase foi completamente reformulada e ao invés de apenas uma classe qiskit.aqua.algorithms.QPE que era usada para calcular o eigenvalue de um Hamiltoniano, agora usa duas implementações separadas: o HamiltonianPhaseEstimation que assume o papel do antigo QPE e um novo algoritmo PhaseEstimation para a estimativa de fase didática.

A estimativa de fase iterativa, qiskit.aqua.algorithms.IQPE ainda não foi substituída, mas o vai em breve.

Guia de migração¶

Vamos considerar o problema de encontrar o eigenvalue de

\[H = 0.5 X + Y + Z\]

com o estado de entrada \(|0\rangle\).

[47]:

state_in = np.array([1, 0])

Anteriormente:

[48]:

from qiskit.circuit.library import QFT
from qiskit.aqua.algorithms import QPE
from qiskit.aqua.components.initial_states import Custom
from qiskit.aqua.operators import I, X, Y, Z

n_ancillae = 5
num_time_slices = 1

op = 0.5 * X + Y + Z

state_preparation = Custom(op.num_qubits, state_vector=state_in)
iqft = QFT(n_ancillae, do_swaps=False).inverse().reverse_bits()

qpe = QPE(op, state_preparation, iqft, num_time_slices, n_ancillae,
          expansion_mode='trotter',
          shallow_circuit_concat=True)


result = qpe.run(aqua_qinstance)

print(result.eigenvalue)

0.78125

Novo:

[49]:

from qiskit import BasicAer
from qiskit.algorithms import HamiltonianPhaseEstimation
from qiskit.opflow import I, X, Y, Z, StateFn, PauliTrotterEvolution, Suzuki

n_ancillae = 5
num_time_slices = 1

op = 0.5 * X + Y + Z

state_preparation = StateFn(state_in)

evolution = PauliTrotterEvolution('trotter', reps=num_time_slices)

qpe = HamiltonianPhaseEstimation(n_ancillae, quantum_instance=qinstance)
result = qpe.estimate(op, state_preparation, evolution=evolution)

print(result.most_likely_eigenvalue)

0.78125

Mais exemplos¶

Agora também podemos fazer estimativa da fase padrão para resolver

\[U|\psi\rangle = e^{2\pi i\phi}|\psi\rangle.\]

[50]:

from qiskit.circuit import QuantumCircuit
from qiskit.algorithms import PhaseEstimation

unitary = QuantumCircuit(1)
unitary.z(0)

state_in = QuantumCircuit(1)
state_in.x(0)  # eigenstate |1> with eigenvalue -1, hence a phase of phi = 0.5

pe = PhaseEstimation(num_evaluation_qubits=3, quantum_instance=qinstance)
result = pe.estimate(unitary, state_in)

print(result.most_likely_phase)

0.5

VQC¶

Resumo¶

VQC changed the location to qiskit_machine_learning.algorithms.VQC and is now implemented as NeuralNetworkClassification object instead of a generic variational algorithm. The interface has been updated accordingly, see the tutorials below.

Guia de migração¶

Uma vez que os exemplos são bastante longos, referimo-nos a uma comparação dos tutoriais anteriores e dos novos.

Anteriormente:

https://github.com/Qiskit/qiskit-tutorials/blob/master/tutorials/machine_learning/03_vqc.ipynb

Novo:

https://github.com/Qiskit/qiskit-machine-learning/blob/master/docs/tutorials/02_neural_network_classifier_and_regressor.ipynb

QSVM¶

Resumo¶

The QSVM workflow has been replaced by a more generic QuantumKernel routine to better highlight the possibly advantage of quantum computers in computing kernels.

Guia de migração¶

Anteriormente:

https://github.com/Qiskit/qiskit-tutorials/blob/master/tutorials/machine_learning/01_qsvm_classification.ipynb

Novo:

https://github.com/Qiskit/qiskit-machine-learning/blob/master/docs/tutorials/03_quantum_kernel.ipynb

QGAN¶

Resumo¶

A interface e os métodos permaneceram os mesmos, apenas a localização de importação do algoritmo e seus componentes foram alterados do qiskit.aqua para o qiskit_machine_learning.

Guia de migração¶

Anteriormente:

https://github.com/Qiskit/qiskit-tutorials/blob/master/tutorials/machine_learning/04_qgans_for_loading_random_distributions.ipynb

Novo:

https://github.com/Qiskit/qiskit-machine-learning/blob/master/docs/tutorials/04_qgans_for_loading_random_distributions.ipynb

Algoritmos educacionais¶

Todos os algoritmos educacionais foram descontinuados e a maioria agora está disponível no textbook.

Deutsch-Josza¶

Movido para o livro-texto: https://qiskit.org/textbook/ch-algorithms/deutsch-jozsa.html.

Bernstein-Vazirani¶

Movido para o livro-texto: https://qiskit.org/textbook/ch-algorithms/bernstein-vazirani.html.

Simon¶

Movido para o livro-texto: https://qiskit.org/textbook/ch-algorithms/simon.html.

EOH¶

A Evolução do algoritmo Hamiltoniano agora pode ser implementado com ferramentas básicas do qiskit.opflow.

Anteriormente:

[51]:

from qiskit.aqua.algorithms import EOH
from qiskit.aqua.operators import WeightedPauliOperator
from qiskit.aqua.components.initial_states import Custom
from qiskit.quantum_info import Pauli

hamiltonian = WeightedPauliOperator([[1, Pauli('XX')], [1, Pauli('ZZ')], [1j, Pauli('YY')]])

observable = WeightedPauliOperator([[1, Pauli('XI')]])

initial_state = Custom(2, 'uniform')

evo_time = 2
num_time_slices = 10

eoh = EOH(observable, initial_state, hamiltonian, evo_time=evo_time, num_time_slices=num_time_slices)
result = eoh.run(aqua_qinstance)
result['avg']

[51]:

(-0.6536436208636107+5.551115123125783e-17j)

Novo:

[52]:

import numpy as np
from qiskit.opflow import I, X, Y, Z, PauliTrotterEvolution, StateFn

hamiltonian = (X ^ X) + (Z ^ Z) + 1j * (Y ^ Y)

observable = X ^ I

initial_state = StateFn(np.ones(4) / 2)

evo_time = 2
num_time_slices = 10

# get the evolution operator
evolved_hamiltonian = (evo_time * hamiltonian).exp_i()

evo = PauliTrotterEvolution(reps=num_time_slices)
evo.convert(evolved_hamiltonian)

# get the evolved state
evolved_state = evolved_hamiltonian @ initial_state

# evaluate the target observable at the evolved state
print((~StateFn(observable) @ evolved_state).eval())

(-0.653643620863615+0j)

[ ]: