Instalación y ejecución de los QDK simuladores cuánticos

QDK(Microsoft Quantum Development Kit) incluye un conjunto de simuladores cuánticos a los que puede acceder desde la Visual Studio Code extensión (VS Code) y el QDKPython paquete. Estos simuladores permiten probar cómo se ejecutan los programas cuánticos en hardware cuántico real. En este artículo se explica cómo instalar los simuladores y cómo ejecutar simulaciones básicas en Jupyter Notebook y VS Code.

Incluye QDK cuatro simuladores cuánticos:

  • Simulador disperso
  • Simulador de Clifford
  • Simulador de GPU
  • Simulador de CPU

Para obtener más información sobre los QDK simuladores cuánticos, consulte Introducción a los simuladores cuánticos en QDK.

Prerequisites

Para seguir los pasos de este artículo, debe instalar las siguientes herramientas:

Instalación de los simuladores

Los cuatro simuladores están disponibles en el QDKPython paquete, pero solo el simulador disperso está disponible en la QDKVS Code extensión.

Para usar el simulador disperso en la extensión VS Code, instale la extensión QDK para VS Code.

Para usar los simuladores cuánticos en Python y Jupyter Notebook, instale la versión más reciente del qdkPython paquete con el jupyter adicional:

pip install --upgrade "qdk[jupyter]"

El jupyter adicional no es necesario para usar los simuladores, pero instala el qdk.widgets módulo. El módulo widgets permite crear visualizaciones a partir de los resultados de la simulación en Jupyter Notebook.

Ejecución de simulaciones mediante la QDK extensión para VS Code

La QDK extensión para VS Code ofrece solo el simulador disperso. Para ejecutar el programa en el simulador disperso en VS Code, abra un programa Q# (.qs) o OpenQASM (.qasm) en VS Code y ejecute el archivo.

Por ejemplo, siga estos pasos para ejecutar uno de los programas de ejemplo de Q# que vienen con la QDK extensión :

  1. En VS Code, abra el menú Archivo y seleccione Nuevo archivo de texto.
  2. Asigne al archivo un nombre que termine con la .qs extensión .
  3. En el archivo vacío, escriba sample. Se abre una lista de ejemplos de código incluidos.
  4. Elija un ejemplo de código, por ejemplo ejemplo Bell Pair.
  5. Para ejecutar el programa en el simulador sparse, seleccione el comando Ejecutar en CodeLens, situado sobre la operación Main.

El VS Code terminal muestra la salida de la simulación.

Note

Puede agregar modelos de ruido limitados a simulaciones dispersas de programas de Q# en la QDK extensión. Para obtener más información, vea Agregar ruido de Pauli al simulador disperso en VS Code.

Ejecución de simulaciones mediante el QDKPython paquete

El QDKPython paquete ofrece los cuatro simuladores. La forma de llamar a los simuladores depende del simulador y del marco de programación cuántica.

Llamada al simulador disperso

Puede usar el simulador disperso con programas de Q#, OpenQASM y Qiskit. En la tabla siguiente se muestra cómo llamar al simulador disperso desde el qdk paquete para 10 tomas en cada marco de programación cuántica compatible.

Marco de programación Python API Llamada de ejemplo
Q# qsharp.run qsharp.run("MyQsharpProgram()", shots=10)
OpenQASM openqasm.run openqasm.run(my_qasm_program, shots=10)
Qiskit qiskit.QSharpBackend QSharpBackend().run(my_qiskit_program, shots=10)

Note

Puede agregar modelos de ruido al simulador disperso con el noise parámetro para programas Q# y OpenQASM, pero no puede agregar modelos de ruido para programas Qiskit.

Por ejemplo, siga estos pasos para ejecutar el programa Q# de par Bell en un Jupyter cuaderno de VS Code:

  1. En VS Code, abra el menú Ver y seleccione Paleta de comandos.

  2. Escriba Crear: Nuevo Jupyter Notebook. Se abre un archivo de cuaderno vacío en una nueva pestaña.

  3. En la primera celda, importe el qsharp módulo desde el qdk paquete.

    from qdk import qsharp

  4. En una nueva celda, use el %%qsharp comando magic para escribir el código Q#.

    %%qsharp

operation Main() : (Result, Result) {
    use (q1, q2) = (Qubit(), Qubit());
    PrepareBellPair(q1, q2);
    (MResetZ(q1), MResetZ(q2))
}

operation PrepareBellPair(q1 : Qubit, q2 : Qubit) : Unit {
    H(q1);
    CNOT(q1, q2);
}

  5. Crear una celda nueva. Para ejecutar el programa Q# en el simulador disperso, llame a la función run del módulo qsharp y especifique el número de ejecuciones.

    qsharp.run("Main()", shots=10)

Llamada al simulador de Clifford

Puede usar el simulador de Clifford para programas Q#, OpenQASM, Qiskit y QIR. En la tabla siguiente se muestra cómo llamar al simulador de Clifford desde el qdk paquete para 10 tomas en cada marco de programación cuántica admitido.

Marco de programación Python API Llamada de ejemplo
Q# qsharp.run qsharp.run("MyQsharpProgram()", type='clifford', shots=10)
OpenQASM openqasm.run openqasm.run(my_qasm_program, type='clifford', shots=10)
Qiskit simulation.NeutralAtomBackend simulation.NeutralAtomBackend().run(my_qiskit_program, simulator_type='clifford', shots=10)
QIR simulation.NeutralAtomDevice simulation.NeutralAtomDevice().simulate(my_qir, type='clifford', shots=10)
QIR simulation.run_qir simulation.run_qir(my_qir, type='clifford', shots=10)

Note

Las API NeutralAtomDevice y NeutralAtomBackend se utilizan específicamente para simulaciones en ordenadores cuánticos de átomos neutros. Para obtener más información, consulte Descripción general del simulador de dispositivos de átomos neutros.

Por ejemplo, el siguiente código Python crea un programa OpenQASM sencillo y ejecuta el programa en el simulador de Clifford:

from qdk.openqasm import run

qasm_code = """
    include "stdgates.inc";
    qubit[2] q;
    reset q;
    h q[0];
    cx q[0], q[1];
    bit c = measure q[1];
    """

run(qasm_code, type='clifford', shots=10)

Llame a los simuladores de GPU y CPU

Puede invocar los simuladores de GPU y de CPU para programas de Qiskit y QIR. En la tabla siguiente se muestra cómo llamar al simulador de GPU desde el qdk paquete para 10 tomas en cada uno de los marcos de programación cuántica admitidos. Para llamar al simulador de CPU, sustituya 'gpu' por 'cpu' en los parámetros de tipo del simulador.

Marco de programación Python API Llamada de ejemplo
Qiskit simulation.NeutralAtomBackend simulation.NeutralAtomBackend().run(my_qiskit_program, simulator_type='gpu', shots=10)
QIR simulation.NeutralAtomDevice simulation.NeutralAtomDevice().simulate(my_qir, type='gpu', shots=10)
QIR simulation.run_qir simulation.run_qir(my_qir, type='gpu', shots=10)

Por ejemplo, el siguiente código Python convierte un programa OpenQASM simple en QIR y ejecuta qiR en el simulador de GPU:

from qdk.openqasm import compile#, ProgramType
from qdk.simulation import run_qir

qasm_code = """
    include "stdgates.inc";
    qubit[2] q;
    reset q;
    h q[0];
    cx q[0], q[1];
    bit c = measure q[1];
    """

qir = compile(qasm_code)
run_qir(qir, type='gpu', shots=10)
  • Last updated on