torchquantum
v0.1.8
L'informatique quantique en pytorch
Un débogage plus rapide, évolutif et facile, un déploiement facile sur la machine réelle
Simulez des calculs quantiques sur le matériel classique à l'aide de pytorch. Il prend en charge la simulation de Viector Stated et la simulation d'impulsions sur les GPU. Il peut évoluer jusqu'à la simulation de plus de 30 Qubits avec plusieurs GPU.
Des chercheurs sur la conception de l'algorithme quantique, une formation paramétrée sur le circuit quantique, un contrôle optimal quantique, l'apprentissage automatique quantique, les réseaux de neurones quantiques.
Graphique de calcul dynamique, calcul automatique du gradient, prise en charge rapide du GPU, modèle de traitement par lots.
git clone https://github.com/mit-han-lab/torchquantum.git
cd torchquantum
pip install --editable . 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 )Nous préparons également de nombreux exemple et tutoriels à l'aide de Torchquantum.
Pour le niveau de début , vous pouvez vérifier QNN pour MNIST, la convolution quantique (quanvolution) et la méthode du noyau quantique et la régression quantique.
Pour le niveau intermédiaire , vous pouvez vérifier le codage d'amplitude pour MNIST, Clifford Gate QNN, les modèles QNN Enregistrer et charger, le fonctionnement de Paulisum, comment convertir TQ en Qiskit.
Pour l'expert , vous pouvez vérifier la formation sur les paramètres sur la formation, l'élagage du gradient VQA, VQE, VQA pour la préparation d'état, Qaoa (algorithme d'optimisation approximatif quantum).
Construire des modèles de circuits quantiques paramétrés aussi simples que la construction d'un modèle 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 Former un circuit quantique pour effectuer une tâche VQE. Quito Quantum Computer comme dans le script simple_vqe.py:
cd examples / vqe
python vqe . py Formez un circuit quantique pour effectuer une tâche de classification MNIST et déployer sur le véritable ordinateur quantique IBM QUITO comme dans mnist_example.py script:
cd examples / mnist
python mnist . py | Déposer | Description |
|---|---|
| dispositifs.py | Classe quantumdevice qui stocke le vecteur d'état |
| Encoding.py | Codage des couches pour coder les valeurs classiques au domaine quantique |
| fonctional.py | Fonctions de la porte quantique |
| opérateurs.py | Classes de portes quantiques |
| couches.py | Modèles de calque tels que Randomlayer |
| mesurer.py | Mesure des états quantiques pour obtenir des valeurs classiques |
| graph.py | Graphique de porte quantique utilisé en mode statique |
| super_layer.py | Modèles de calque pour SuperCircuits |
| Plugins / Qiskit * | Convertisseurs et processeurs pour un déploiement facile sur IBMQ |
| exemples / | Plus d'exemples pour la formation des modèles QML et VQE |
TorchQuantum utilise des crochets pré-comités pour assurer la cohérence du style Python et empêcher les erreurs courantes dans sa base de code.
Pour l'activer les crochets de pré-engagement, veuillez reproduire:
pip install pre-commit
pre-commit installconcurrent pour Qiskit)Torchquantum Forum
Hanrui wang [email protected]
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
@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}
}
