Spanish
Languages
English
Bengali
French
German
Japanese
Korean
Portuguese
Spanish
Tamil

Nota

Esta página fue generada a partir de tutorials/simulators/6_extended_stabilizer_tutorial.ipynb.

El Simulador de Estabilizador Extendido

Introducción

El Simulador Extendido es un nuevo método para la simulación clásica de circuitos cuánticos disponible en la última versión de Qiskit-Aer.

Este método es una implementación de las ideas publicadas en el artículo Simulation of quantum circuits by low-rank stabilizer decompositions de Bravyi, Browne, Calpin, Campbell, Gosset & Howard, 2018, arXiv:1808.00128.

Utiliza una representación diferente de un circuito cuántico, que le da algunas capacidades únicas. Este cuaderno te dará algunos ejemplos de lo que puede hacer el método de estabilizador extendido.

Por ejemplo:

[1]:
from qiskit import QuantumCircuit, transpile
from qiskit_aer import AerSimulator
from qiskit.tools.visualization import plot_histogram

import random
[2]:
circ = QuantumCircuit(40, 40)

# Initialize with a Hadamard layer
circ.h(range(40))
# Apply some random CNOT and T gates
qubit_indices = [i for i in range(40)]
for i in range(10):
    control, target, t = random.sample(qubit_indices, 3)
    circ.cx(control, target)
    circ.t(t)
circ.measure(range(40), range(40))
[2]:
<qiskit.circuit.instructionset.InstructionSet at 0x7fbd18a23310>

Creamos un circuito aleatorio con solo 60 compuertas, que actúa en 40 qubits. Pero, debido a la cantidad de qubits, si quisiéramos ejecutar esto, por ejemplo, con el simulador de statevector, entonces ¡espero que tengas acceso a terabytes de RAM!

[3]:
# Create statevector method simulator
statevector_simulator = AerSimulator(method='statevector')

# Transpile circuit for backend
tcirc = transpile(circ, statevector_simulator)

# Try and run circuit
statevector_result =  statevector_simulator.run(tcirc, shots=1).result()
print('This succeeded?: {}'.format(statevector_result.success))
print('Why not? {}'.format(statevector_result.status))
Simulation failed and returned the following error message:
ERROR:  [Experiment 0] Insufficient memory to run circuit "circuit-2" using the statevector simulator.
This succeeded?: False
Why not? ERROR:  [Experiment 0] Insufficient memory to run circuit "circuit-2" using the statevector simulator.

El método de estabilizador extendido, por el contrario, maneja este circuito muy bien. (¡Aunque necesita un par de minutos!)

[4]:
# Create extended stabilizer method simulator
extended_stabilizer_simulator = AerSimulator(method='extended_stabilizer')

# Transpile circuit for backend
tcirc = transpile(circ, extended_stabilizer_simulator)

extended_stabilizer_result = extended_stabilizer_simulator.run(tcirc, shots=1).result()
print('This succeeded?: {}'.format(extended_stabilizer_result.success))
This succeeded?: True

¿Cómo funciona?

Si estás interesado en cómo exactamente podemos manejar circuitos tan grandes, entonces para obtener una explicación detallada, puedes ¡leer el documento!

Sin embargo, para ejecutar circuitos, es importante comprender los conceptos básicos.

El método de estabilizador extendido consta de dos partes. La primera es un método para descomponer circuitos cuánticos en circuitos estabilizadores, una clase especial de circuito que se puede simular eficientemente de manera clásica. La segunda es entonces una forma de combinar estos circuitos para realizar mediciones.

El número de términos que necesitas, escala con el número de lo que llamamos non-Clifford Gates (compuertas no de tipo Clifford). Por el momento, el método sabe cómo manejar los siguientes métodos:

circ.t(qr[qubit])
circ.tdg(qr[qubit])
circ.ccx(qr[control_1], qr[control_2], qr[target])
circ.u1(rotation_angle, qr[qubit])

El simulador también puede manejar circuitos de hasta 63 qubits.

Una cosa que es importante tener en cuenta es que estas descomposiciones son aproximadas. Esto significa que los resultados no son exactamente los mismos que con el simulador de Vector de Estado.

[5]:
small_circ = QuantumCircuit(2, 2)
small_circ.h(0)
small_circ.cx(0, 1)
small_circ.t(0)
small_circ.measure([0, 1], [0, 1])
# This circuit should give 00 or 11 with equal probability...
expected_results ={'00': 50, '11': 50}
[6]:
tsmall_circ = transpile(small_circ, extended_stabilizer_simulator)
result = extended_stabilizer_simulator.run(
    tsmall_circ, shots=100).result()
counts = result.get_counts(0)
print('100 shots in {}s'.format(result.time_taken))
100 shots in 0.4958779811859131s
[7]:
plot_histogram([expected_results, counts],
               legend=['Expected', 'Extended Stabilizer'])
[7]:
../../_images/tutorials_simulators_6_extended_stabilizer_tutorial_13_0.png

Puedes controlar este error de aproximación utilizando el extended_stabilizer_approximation_error en Qiskit Aer. El error predeterminado es 0.05. Cuanto menor sea el error, más precisos serán los resultados, pero también más tiempo tomará tu simulación y más memoria requerirá.

[8]:
# Add runtime options for extended stabilizer simulator
opts = {'extended_stabilizer_approximation_error': 0.03}

reduced_error = extended_stabilizer_simulator.run(
    tsmall_circ, shots=100, **opts).result()

reduced_error_counts = reduced_error.get_counts(0)
print('100 shots in {}s'.format(reduced_error.time_taken))
plot_histogram([expected_results, reduced_error_counts],
               legend=['Expected', 'Extended Stabilizer'])
100 shots in 1.404871940612793s
[8]:
../../_images/tutorials_simulators_6_extended_stabilizer_tutorial_15_1.png

Opciones del Simulador

Hay varias otras opciones que puedes modificar para controlar cómo funciona el método de estabilizador extendido. Cuáles son estas opciones y su explicación se pueden encontrar en la documentación de Qiskit Aer. Sin embargo, quiero destacar dos importantes que pueden ayudar a optimizar tus simulaciones.

Para realizar mediciones, el método de estabilizador extendido utiliza un método de cadena de Markov para muestrear resultados al azar. Esta cadena de Markov debe ejecutarse durante un tiempo que llamamos ‘tiempo de mezclado’ antes de que comience a muestrear, y debe volver a mezclarse para cada iteración del circuito.

Si esperas que la salida de tu circuito se concentre en solo unos pocos estados de salida, entonces probablemente puedas optimizar tus simulaciones reduciendo la opción extended_stabilizer_mixing_time.

[9]:
print("The circuit above, with 100 shots at precision 0.03 "
      "and default mixing time, needed {}s".format(int(reduced_error.time_taken)))

opts = {
    'extended_stabilizer_approximation_error': 0.03,
    'extended_stabilizer_mixing_time': 100
}

optimized = extended_stabilizer_simulator.run(
    tsmall_circ, shots=100, **opts).result()

print('Dialing down the mixing time, we completed in just {}s'.format(optimized.time_taken))
The circuit above, with 100 shots at precision 0.03 and default mixing time, needed 1s
Dialing down the mixing time, we completed in just 1.4710919857025146s

De manera similar, si tu circuito tiene alguna probabilidad distinta de cero en todas las amplitudes (por ejemplo, si es un circuito aleatorio), entonces puedes evitar este costoso paso de volver a mezclar para tomar múltiples iteraciones de la salida a la vez. Esto se puede habilitar configurando extended_stabilizer_measure_sampling=True.

Por ejemplo, veamos nuevamente el circuito aleatorio desde el comienzo del tutorial, que se ejecuta durante 100 iteraciones:

[10]:
# We set these options here only to make the example run more quickly.
opts = {'extended_stabilizer_mixing_time': 100}

multishot = extended_stabilizer_simulator.run(
    tcirc, shots=100, **opts).result()
print("100 shots took {} s".format(multishot.time_taken))
100 shots took 29.634929895401 s
[11]:
opts = {
    'extended_stabilizer_measure_sampling': True,
    'extended_stabilizer_mixing_time': 100
}

measure_sampling = extended_stabilizer_simulator.run(
    circ, shots=100, **opts).result()
print("With the optimization, 100 shots took {} s".format(result.time_taken))
With the optimization, 100 shots took 0.4958779811859131 s

¿Cuándo debo utilizarlo?

Si tienes circuitos más pequeños con muchas compuertas que no son de Clifford, es probable que el método de vector de estado funcione mejor que el estabilizador extendido. Sin embargo, si deseas ver circuitos en muchos qubits, sin necesidad de acceder a computación de alto rendimiento, ¡prueba este método!

[12]:
import qiskit.tools.jupyter
%qiskit_version_table
%qiskit_copyright

Version Information

Qiskit SoftwareVersion
Qiskit0.25.0
Terra0.17.0
Aer0.8.0
Ignis0.6.0
Aqua0.9.0
IBM Q Provider0.12.2
System information
Python3.7.7 (default, May 6 2020, 04:59:01) [Clang 4.0.1 (tags/RELEASE_401/final)]
OSDarwin
CPUs6
Memory (Gb)32.0
Fri Apr 02 12:28:14 2021 EDT

This code is a part of Qiskit

© Copyright IBM 2017, 2021.

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.

[ ]: