torchquantum

Computação quântica em pytorch

Depuração mais rápida, escalável, fácil, fácil implantação em máquina real

Bem-vindo

O que está fazendo

Simule cálculos quânticos em hardware clássico usando pytorch. Ele suporta a simulação do estado de estado e a simulação de pulso nas GPUs. Ele pode aumentar a simulação de mais de 30 qubits com várias GPUs.

Quem vai se beneficiar

Pesquisadores sobre design de algoritmo quântico, treinamento parametrizado em circuitos quânticos, controle ideal quântico, aprendizado de máquina quântica, redes neurais quânticas.

Diferenças de Qiskit/Pennylane

Gráfico de computação dinâmica, computação automática de gradiente, suporte rápido à GPU, processamento tesorizado do modelo em lote.

Notícias

• Torchquantum é usado na equipe vencedora para a Computação Quântica do ACM para Descabar de Descoberta de Medicamentos.
• Torchquantum é destacado em Unitárias.
• Torchquantum recebeu o UNITYFUND.
• Torchquantum é integrado ao ecossistema IBM Qiskit.
• Torchquantum é integrado ao ecossistema de Pytorch.
• v0.1.8 Disponível!
• Verifique a filial do Dev para obter novos recursos mais recentes sobre camadas quânticas e algoritmos quânticos.
• Junte -se à nossa folga para obter suporte em tempo real!
• Bem -vindo ao contribuir! Entre em contato conosco ou poste nos problemas do GitHub se você quiser ter novos exemplos implementados por Torchquantum ou outras perguntas.
• O site da QMLSYS fica online: qmlsys.mit.edu e Torchquantum.org

Características

• Fácil construção e simulação de circuitos quânticos em pytorch
• Gráfico de computação dinâmica para facilitar a depuração
• Suporte de gradiente via AutoGRAD
• Inferência do modo em lote e treinamento na CPU/GPU
• Fácil implantação em dispositivos quânticos reais, como IBMQ
• Construção de modelo clássico-quadrado híbrido fácil
• (em breve) simulação no nível de pulso

Instalação

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 )

Guia para os exemplos

Também preparamos muitos exemplos e tutoriais usando Torchquantum.

Para o nível inicial , você pode verificar o QNN quanto ao método MNIST, convolução quântica (quanvolução) e kernel quântico e regressão quântica.

Para o nível intermediário , você pode verificar a codificação da amplitude para o MNIST, Clifford Gate QNN, salvar e carregar modelos QNN, operação Paulisum, como converter o TQ em Qiskit.

Para o especialista , você pode verificar o treinamento no chip de mudança de parâmetro, a poda do gradiente VQA, VQE, VQA para pré-prisão do estado, QAOA (algoritmo de otimização aproximada do Quantum).

Uso

Construa modelos de circuito quântico parametrizado tão simples como a construção de um modelo normal de pytorch.

 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 

Exemplo VQE

Treine um circuito quântico para executar a tarefa VQE. Quantum Computer como em Simple_vqe.py Script:

 cd examples / vqe
python vqe . py 

Exemplo mnist

Treine um circuito quântico para executar a tarefa de classificação MNIST e implantar no Computador Quantum IBM Quantum real, como em mnist_example.py script:

 cd examples / mnist
python mnist . py 

Arquivos

Arquivo	Descrição
dispositivos.py	Classe QuantumDevice, que armazena o StateVector
coding.py	Codificação de camadas para codificar valores clássicos ao domínio quântico
funcional.py	Funções do portão quântico
operadores.py	Classes de portão quântico
camada.py	Modelos de camada, como randomlayer
medir.py	Medição de estados quânticos para obter valores clássicos
Graph.py	Gráfico de portão quântico usado no modo estático
super_layer.py	Modelos de camada para supercircuitos
Plugins/Qiskit*	Conversores e processadores para facilitar a implantação no IBMQ
exemplos/	Mais exemplos para o treinamento de modelos QML e VQE

Estilo de codificação

Torchquantum usa ganchos de pré-compromisso para garantir a consistência do estilo Python e impedir erros comuns em sua base de código.

Para ativar os ganchos de pré-compromisso, reproduza:

pip install pre-commit
pre-commit install

Documentos usando Torchquantum

• [HPCA'22] Wang et al., "Quantumnas: pesquisa adaptativa ao ruído por circuitos quânticos robustos"
• [DAC'22] Wang et al., "Quantumnat: Treinamento Quantum Ruído com injeção de ruído, quantização e normalização"
• [DAC'22] Wang et al., "Qoc: Treinamento quântico no chip com mudança de parâmetro e poda de gradiente"
• [QCE'22] Liang et al., "Aprendizagem de pulso quântico variacional"
• [Iccad'22] Hu et al., "Compressão da rede neural quântica"
• [ICCAD'22] Wang et al., "Quest: transformador de gráfico para estimativa de confiabilidade do circuito quântico"
• [Workshop ICML] Yun et al., "Aprendizagem quântica federada quântica"
• [IEEE ICDCs] Yun et al., "Aprendizagem de reforço multi-agente quântico por meio do projeto do circuito quântico variacional"
• [QCE'23] Zhan et al., "Algoritmos de rede de sensores quânticos para localização do transmissor"

Manuscritos

Manuscritos

• Yun et al., "Projeção valorizada de aprendizado de máquina quântica baseado em medidas para classificação de várias classes"
• Baek et al., "Redes neurais convolucionais quânticas escaláveis 3D para o processamento de dados em nuvem de pontos em aplicativos de classificação"
• Baek et al., "Redes neurais convolucionais quânticas escaláveis"
• Yun et al., "Aprendizagem de meta-reforço quântico de agente"

Dependências

• 3.9> = Python> = 3.7 (Python 3.10 pode ter o problema de pacote concurrent para Qiskit)
• Pytorch> = 1.8.0
• ConfiguargParse> = 0,14
• O treinamento do modelo de GPU requer GPUs NVIDIA

Contato

Fórum 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, Zhuoyang Ye

Citação

 @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}
}