Spanish
Idiomas
English
Japanese
Spanish
Table of Contents

Trabajar con algoritmos de Qiskit actualizados

The qiskit.algorithms module has been updated to use the primitives in all of its classes. In practice, this means that:

  1. Todos los algoritmos ahora aceptan una primitiva en lugar de un Backend o QuantumInstance

  2. Algunos algoritmos ahora tienen una nueva ruta de importación

  3. Se han introducido nuevos algoritmos específicos de primitivas

  4. Como efecto secundario de la refactorización de primitivas, qiskit.algorithms ya no usa qiskit.opflow


El uso de las Sesiones de Runtime puede ser particularmente ventajoso cuando se trabaja con algoritmos variacionales, ya que presentan cargas de trabajo iterativas que pueden enviar varios trabajos por iteración. Además de esto, las primitivas de runtime permiten probar diferentes técnicas de mitigación de errores sin cambios en el algoritmo, solo una opción de configuración simple.

Nota

El siguiente ejemplo completo ilustra cómo usar uno de los algoritmos refactorizados de qiskit.algorithms con las primitivas de Runtime de Qiskit. Para obtener una explicación detallada de otros escenarios de migración de algoritmos, consulta la guía de migración de algoritmos de Qiskit.

Ejemplo: VQE

El algoritmo de VQE anterior se ha dividido en dos nuevas implementaciones:

  • VQE : Basado en el Estimator

  • SamplingVQE : Para operadores diagonales, basados en el Sampler

La elección de la implementación depende del caso de uso, ya sea que estés interesado en acceder a la distribución de probabilidad correspondiente a un estado cuántico (SamplingVQE) o una estimación de la energía del estado fundamental que podría requerir, por ejemplo, mediciones en múltiples bases (VQE).

Veamos los cambios en el flujo de trabajo para la implementación de VQE basada en Estimator:

Paso 1: Definición del problema

El paso de definición del problema es común al antiguo y al nuevo flujo de trabajo: definir el Hamiltoniano, el ansatz, el optimizador y el punto inicial.

La única diferencia es que la definición del operador ahora se basa en qiskit.quantum_info en lugar de qiskit.opflow . En la práctica, esto significa que todas las dependencias de PauliSumOp deben ser reemplazadas por SparsePauliOp.

Nota

Todas las clases refactorizadas en qiskit.algorithms ahora aceptan operadores como instancias de SparsePauliOp en lugar de PauliSumOp.

El ansatz, el optimizador y el punto inicial se definen de forma idéntica:

from qiskit.algorithms.optimizers import SLSQP
from qiskit.circuit.library import TwoLocal

# define ansatz and optimizer
num_qubits = 2
ansatz = TwoLocal(num_qubits, "ry", "cz")
optimizer = SLSQP(maxiter=100)

# define initial point
init_pt = [-0.1, -0.1, -0.1, -0.1, -0.1, -0.1, -0.1, -0.1]

# hamiltonian/operator --> use SparsePauliOp or Operator
from qiskit.quantum_info import SparsePauliOp

hamiltonian = SparsePauliOp.from_list(
    [
        ("II", -1.052373245772859),
        ("IZ", 0.39793742484318045),
        ("ZI", -0.39793742484318045),
        ("ZZ", -0.01128010425623538),
        ("XX", 0.18093119978423156),
    ]
)

La definición del operador cambia

Legacy VQE
from qiskit.opflow import PauliSumOp

hamiltonian = PauliSumOp.from_list(
    [
        ("II", -1.052373245772859),
        ("IZ", 0.39793742484318045),
        ("ZI", -0.39793742484318045),
        ("ZZ", -0.01128010425623538),
        ("XX", 0.18093119978423156),
    ]
)
New VQE
from qiskit.quantum_info import SparsePauliOp

hamiltonian = SparsePauliOp.from_list(
    [
        ("II", -1.052373245772859),
        ("IZ", 0.39793742484318045),
        ("ZI", -0.39793742484318045),
        ("ZZ", -0.01128010425623538),
        ("XX", 0.18093119978423156),
    ]
)

Paso 2: Configuración del backend

Supongamos que deseas ejecutar VQE en ibmq_qasm_simulator en la nube. Antes de cargar tu cuenta de IBMQ, obtén el backend correspondiente del proveedor y utilízalo para configurar una QuantumInstance. Ahora, necesitas inicializar un QiskitRuntimeService, abrir una session y usarla para instanciar tu Estimator.

Legacy VQE
from qiskit.utils import QuantumInstance
from qiskit import IBMQ

IBMQ.load_account()
provider = IBMQ.get_provider(hub='MY_HUB')
my_backend = provider.get_backend("ibmq_qasm_simulator")
qi = QuantumInstance(backend=my_backend)
New VQE
from qiskit_ibm_runtime import Estimator, QiskitRuntimeService, Session

# no more IBMQ import or .load_account()
service = QiskitRuntimeService(channel="ibm_quantum")
session = Session(service, backend="ibmq_qasm_simulator") # open session
estimator = Estimator(session = session)

Paso 3: Ejecutar VQE

Ahora que se han configurado tanto el problema como la ruta de ejecución, puedes crear instancias y ejecutar VQE. Cierra la sesión solo si todos los trabajos han terminado y no necesitas ejecutar más trabajos en la sesión.

Importante

VQE es uno de los algoritmos con una ruta de importación modificada. Si no especificas la ruta completa durante la importación, es posible que tengas conflictos con el código antiguo.

Legacy VQE
from qiskit.algorithms.minimum_eigen_solvers import VQE

vqe = VQE(ansatz, optimizer, quantum_instance=qi)
result = vqe.compute_minimum_eigenvalue(hamiltonian)
New VQE
# note change of namespace
from qiskit.algorithms.minimum_eigensolvers import VQE

vqe = VQE(estimator, ansatz, optimizer)
result = vqe.compute_minimum_eigenvalue(hamiltonian)

# close session!
session.close()

Uso de administradores de contexto

Te recomendamos que inicialices tu primitiva y ejecutes tu algoritmo usando un administrador de contexto. El código para los pasos 2 y 3 se verían así:

from qiskit_ibm_runtime import Estimator, QiskitRuntimeService, Session
from qiskit.algorithms.minimum_eigensolvers import VQE

service = QiskitRuntimeService(channel="ibm_quantum")

with Session(service, backend="ibmq_qasm_simulator") as session:

    estimator = Estimator() # no need to pass the session explicitly
    vqe = VQE(estimator, ansatz, optimizer, gradient=gradient, initial_point=init_pt)
    result = vqe.compute_minimum_eigenvalue(hamiltonian)