torchquantum

Computación cuántica en Pytorch

Depuración más rápida, escalable, fácil, implementación fácil en la máquina real

Bienvenido

Que esta haciendo

Simule cálculos cuánticos en hardware clásico usando Pytorch. Admite la simulación del vector de estado y la simulación de pulso en las GPU. Puede escalar la simulación de más de 30 qubits con múltiples GPU.

Quien se beneficiará

Investigadores sobre diseño de algoritmo cuántico, entrenamiento parametrizado de circuitos cuánticos, control óptimo cuántico, aprendizaje automático cuántico, redes neuronales cuánticas.

Diferencias de Qiskit/Pennylane

Gráfico de cálculo dinámico, cálculo automático de gradiente, soporte rápido de GPU, procesamiento tersorizado del modelo por lotes.

Noticias

• Torchquantum se usa en el equipo ganador para ACM Quantum Computing for Drug Discovery Challenge.
• Torchquantum se destaca en Unitaryhack.
• Torchquantum recibió unitaryfund.
• Torchquantum está integrado al ecosistema IBM QISKIT.
• Torchquantum está integrado al ecosistema de Pytorch.
• V0.1.8 Disponible!
• Consulte la rama de Dev para ver las nuevas características más recientes en capas cuánticas y algoritmos cuánticos.
• ¡Únete a nuestra holgura para el apoyo en tiempo real!
• ¡Bienvenido a contribuir! Póngase en contacto con nosotros o publique en los problemas de GitHub si desea tener nuevos ejemplos implementados por Torchquantum o cualquier otra pregunta.
• El sitio web de QMLSYS se pone en línea: qmlsys.mit.edu y torchquantum.org

Características

• Fácil construcción y simulación de circuitos cuánticos en Pytorch
• Gráfico de cálculo dinámico para una fácil depuración
• Soporte de gradiente a través de Autograd
• Inferencia y entrenamiento en modo por lotes en CPU/GPU
• Implementación fácil en dispositivos cuánticos reales como IBMQ
• Construcción del modelo Hybrid Classical-Quantum Hybrid
• (Próximamente) Simulación a nivel de pulso

Instalación

git clone https://github.com/mit-han-lab/torchquantum.git
cd torchquantum
pip install --editable . 

Uso básico

 import torchquantum as tq
import torchquantum . functional as tqf

qdev = tq . QuantumDevice ( n_wires = 2 , bsz = 5 , device = "cpu" , record_op = True ) # use device='cuda' for GPU

# use qdev.op
qdev . h ( wires = 0 )
qdev . cnot ( wires = [ 0 , 1 ])

# use tqf
tqf . h ( qdev , wires = 1 )
tqf . x ( qdev , wires = 1 )

# use tq.Operator
op = tq . RX ( has_params = True , trainable = True , init_params = 0.5 )
op ( qdev , wires = 0 )

# print the current state (dynamic computation graph supported)
print ( qdev )

# obtain the qasm string
from torchquantum . plugin import op_history2qasm
print ( op_history2qasm ( qdev . n_wires , qdev . op_history ))

# measure the state on z basis
print ( tq . measure ( qdev , n_shots = 1024 ))

# obtain the expval on a observable by stochastic sampling (doable on simulator and real quantum hardware)
from torchquantum . measurement import expval_joint_sampling
expval_sampling = expval_joint_sampling ( qdev , 'ZX' , n_shots = 1024 )
print ( expval_sampling )

# obtain the expval on a observable by analytical computation (only doable on classical simulator)
from torchquantum . measurement import expval_joint_analytical
expval = expval_joint_analytical ( qdev , 'ZX' )
print ( expval )

# obtain gradients of expval w.r.t. trainable parameters
expval [ 0 ]. backward ()
print ( op . params . grad )


# Apply gates to qdev with tq.QuantumModule
ops = [
    { 'name' : 'hadamard' , 'wires' : 0 }, 
    { 'name' : 'cnot' , 'wires' : [ 0 , 1 ]},
    { 'name' : 'rx' , 'wires' : 0 , 'params' : 0.5 , 'trainable' : True },
    { 'name' : 'u3' , 'wires' : 0 , 'params' : [ 0.1 , 0.2 , 0.3 ], 'trainable' : True },
    { 'name' : 'h' , 'wires' : 1 , 'inverse' : True }
]

qmodule = tq . QuantumModule . from_op_history ( ops )
qmodule ( qdev )

Guía de los ejemplos

También preparamos muchos ejemplo y tutoriales que usan Torchquantum.

Para el nivel inicial , puede verificar QNN en busca de mnist, convolución cuántica (quanvolution) y método de núcleo cuántico, y regresión cuántica.

Para el nivel intermedio , puede verificar la codificación de amplitud para MNIST, Clifford Gate Qnn, Guardar y Cargar los modelos QNN, la operación Paulisum, cómo convertir TQ a Qiskit.

Para expertos , puede verificar la capacitación de cambio de parámetros en chip, poda de gradiente VQA, VQE, VQA para la prepratación de estado, QAOA (algoritmo de optimización aproximada cuántica).

Uso

Construya modelos de circuito cuántico parametrizados tan simples como la construcción de un modelo Pytorch normal.

 import torch . nn as nn
import torch . nn . functional as F
import torchquantum as tq
import torchquantum . functional as tqf

class QFCModel ( nn . Module ):
  def __init__ ( self ):
    super (). __init__ ()
    self . n_wires = 4
    self . measure = tq . MeasureAll ( tq . PauliZ )

    self . encoder_gates = [ tqf . rx ] * 4 + [ tqf . ry ] * 4 + 
                         [ tqf . rz ] * 4 + [ tqf . rx ] * 4
    self . rx0 = tq . RX ( has_params = True , trainable = True )
    self . ry0 = tq . RY ( has_params = True , trainable = True )
    self . rz0 = tq . RZ ( has_params = True , trainable = True )
    self . crx0 = tq . CRX ( has_params = True , trainable = True )

  def forward ( self , x ):
    bsz = x . shape [ 0 ]
    # down-sample the image
    x = F . avg_pool2d ( x , 6 ). view ( bsz , 16 )

    # create a quantum device to run the gates
    qdev = tq . QuantumDevice ( n_wires = self . n_wires , bsz = bsz , device = x . device )

    # encode the classical image to quantum domain
    for k , gate in enumerate ( self . encoder_gates ):
      gate ( qdev , wires = k % self . n_wires , params = x [:, k ])

    # add some trainable gates (need to instantiate ahead of time)
    self . rx0 ( qdev , wires = 0 )
    self . ry0 ( qdev , wires = 1 )
    self . rz0 ( qdev , wires = 3 )
    self . crx0 ( qdev , wires = [ 0 , 2 ])

    # add some more non-parameterized gates (add on-the-fly)
    qdev . h ( wires = 3 )
    qdev . sx ( wires = 2 )
    qdev . cnot ( wires = [ 3 , 0 ])
    qdev . qubitunitary ( wires = [ 1 , 2 ], params = [[ 1 , 0 , 0 , 0 ],
                                            [ 0 , 1 , 0 , 0 ],
                                            [ 0 , 0 , 0 , 1j ],
                                            [ 0 , 0 , - 1j , 0 ]])

    # perform measurement to get expectations (back to classical domain)
    x = self . measure ( qdev ). reshape ( bsz , 2 , 2 )

    # classification
    x = x . sum ( - 1 ). squeeze ()
    x = F . log_softmax ( x , dim = 1 )

    return x 

Ejemplo de VQE

Entrena un circuito cuántico para realizar la tarea VQE. Script de Quito Quantum como en script simple_vqe.py:

 cd examples / vqe
python vqe . py 

Ejemplo de mnist

Entrena un circuito cuántico para realizar la tarea de clasificación MNIST e implementar en la computadora cuántica IBM quito real como en mnist_example.py script:

 cd examples / mnist
python mnist . py 

Archivos

Archivo	Descripción
dispositivos.py	Clase QuantumDevice que almacena el StateVector
coding.py	Codificación de capas para codificar valores clásicos al dominio cuántico
funcional.py	Funciones de la puerta cuántica
operadores.py	Clases de puerta cuántica
capas.py	Plantillas de capa como RandomLayLayer
medir.py	Medición de estados cuánticos para obtener valores clásicos
gráfico.py	Gráfico de la puerta cuántica utilizada en modo estático
super_layer.py	Plantillas de capa para supercircuits
complementos/qiskit*	Convertores y procesadores para una fácil implementación en IBMQ
Ejemplos/	Más ejemplos para capacitar a los modelos QML y VQE

Estilo de codificación

Torchquantum utiliza ganchos previos al compromiso para garantizar la consistencia del estilo de Python y evitar errores comunes en su base de código.

Para habilitar sus ganchos previos al comercio, reproduzca:

pip install pre-commit
pre-commit install

Documentos que usan Torchquantum

• [HPCA'22] Wang et al., "Quantumnas: búsqueda adaptativa de ruido de circuitos cuánticos robustos"
• [DAC'22] Wang et al., "Quantumnat: entrenamiento de ruido cuántico con inyección de ruido, cuantización y normalización"
• [DAC'22] Wang et al., "QOC: entrenamiento cuántico en chip con cambio de parámetros y poda de gradiente"
• [QCE'22] Liang et al., "Aprendizaje de pulso cuántico variacional"
• [ICCAD'22] Hu et al., "Compresión de la red neuronal cuántica"
• [ICCAD'22] Wang et al., "Quest: Transformador gráfico para la estimación de confiabilidad del circuito cuántico"
• [Taller ICML] Yun et al., "Aprendizaje federado cuántico delgado"
• [IEEE ICDCS] Yun et al., "Aprendizaje cuántico de refuerzo de múltiples agentes a través del diseño variacional del circuito cuántico"
• [QCE'23] Zhan et al., "Algoritmos de red de sensores cuánticos para la localización del transmisor"

Manuscritos

Manuscritos

• Yun et al., "Learning Machine Machine basado en la medida valorado para la clasificación de múltiples clases"
• Baek et al., "Redes neuronales convolucionales cuánticas y escalables 3D para procesamiento de datos de nubes de puntos en aplicaciones de clasificación"
• Baek et al., "Redes neuronales convolucionales cuánticas escalables"
• Yun et al., "Aprendizaje de meta refuerzo múltiple de agente cuántico"

Dependencias

• 3.9> = Python> = 3.7 (Python 3.10 puede tener el problema del paquete concurrent para Qiskit)
• Pytorch> = 1.8.0
• configargparse> = 0.14
• El entrenamiento del modelo de GPU requiere NVIDIA GPU

Contacto

Foro de Torchquantum

Hanrui wang [email protected]

Colaboradores

Jiannan Cao, Jessica Ding, Jiai GU, Song Han, Zhirui Hu, Zirui Li, Zhiding Liang, Pengyu Liu, Yilian Liu, Mohammadreza Tavasoli, Hanrui Wang, Zhepeng Wang, Zhuoyg Ye

Citación

 @inproceedings{hanruiwang2022quantumnas,
    title     = {Quantumnas: Noise-adaptive search for robust quantum circuits},
    author    = {Wang, Hanrui and Ding, Yongshan and Gu, Jiaqi and Li, Zirui and Lin, Yujun and Pan, David Z and Chong, Frederic T and Han, Song},
    booktitle = {The 28th IEEE International Symposium on High-Performance Computer Architecture (HPCA-28)},
    year      = {2022}
}