\n
![\"Chat](\"https:\/\/img.shields.io\/badge\/slack-chat-2eb67d.svg?logo=slack\")
<\/a>\n<\/a><\/p>\n
<\/p>\n
\ud83d\udc4b Welcome<\/h1>\nWhat it is doing<\/h4>\n
Quantum simulation framework based on PyTorch. It supports statevector simulation and pulse simulation (coming soon) on GPUs. It can scale up to the simulation of 30+ qubits with multiple GPUs.<\/p>\n
Who will benefit<\/h4>\n
Researchers on quantum algorithm design, parameterized quantum circuit training, quantum optimal control, quantum machine learning, quantum neural networks.<\/p>\n
Differences from Qiskit\/Pennylane<\/h4>\n
Dynamic computation graph, automatic gradient computation, fast GPU support, batch model tersorized processing.<\/p>\n
News<\/h2>\n\n- v0.1.7 Available!<\/li>\n
- Join our Slack<\/a> for real time support!<\/li>\n
- Welcome to contribute! Please contact us or post in the forum<\/a> if you want to have new examples implemented by TorchQuantum or any other questions.<\/li>\n
- Qmlsys website goes online: qmlsys.mit.edu<\/a> and torchquantum.org<\/a><\/li>\n<\/ul>\n
Features<\/h2>\n\n- Easy construction and simulation of quantum circuits in PyTorch<\/strong><\/li>\n
- Dynamic computation graph<\/strong> for easy debugging<\/li>\n
- Gradient support<\/strong> via autograd<\/li>\n
- Batch mode<\/strong> inference and training on CPU\/GPU<\/strong><\/li>\n
- Easy deployment on real quantum devices<\/strong> such as IBMQ<\/li>\n
- Easy hybrid classical-quantum<\/strong> model construction<\/li>\n
- (coming soon) pulse-level simulation<\/strong><\/li>\n<\/ul>\n
Installation<\/h2>\ngit clone<\/span> https<\/span>:\/\/github.com\/mit-han-lab\/torchquantum.git\r\ncd torchquantum\r\npip install --editable .\r\n<\/code><\/pre>\nBasic Usage<\/h2>\nimport<\/span> torchquantum as<\/span> tq\r\nimport<\/span> torchquantum.functional as<\/span> tqf\r\n\r\nqdev = tq.QuantumDevice(n_wires=2<\/span>, bsz=5<\/span>, device=\"cpu\"<\/span>, record_op=True<\/span>) # use device='cuda' for GPU<\/span>\r\n\r\n# use qdev.op<\/span>\r\nqdev.h(wires=0<\/span>)\r\nqdev.cnot(wires=[0<\/span>, 1<\/span>])\r\n\r\n# use tqf<\/span>\r\ntqf.h(qdev, wires=1<\/span>)\r\ntqf.x(qdev, wires=1<\/span>)\r\n\r\n# use tq.Operator<\/span>\r\nop = tq.RX(has_params=True<\/span>, trainable=True<\/span>, init_params=0.5<\/span>)\r\nop(qdev, wires=0<\/span>)\r\n\r\n# print the current state (dynamic computation graph supported)<\/span>\r\nprint(qdev)\r\n\r\n# obtain the qasm string<\/span>\r\nfrom<\/span> torchquantum.plugins import<\/span> op_history2qasm\r\nprint(op_history2qasm(qdev.n_wires, qdev.op_history))\r\n\r\n# measure the state on z basis<\/span>\r\nprint(tq.measure(qdev, n_shots=1024<\/span>))\r\n\r\n# obtain the expval on a observable by stochastic sampling (doable on simulator and real quantum hardware)<\/span>\r\nfrom<\/span> torchquantum.measurement import<\/span> expval_joint_sampling\r\nexpval_sampling = expval_joint_sampling(qdev, 'ZX'<\/span>, n_shots=1024<\/span>)\r\nprint(expval_sampling)\r\n\r\n# obtain the expval on a observable by analytical computation (only doable on classical simulator)<\/span>\r\nfrom<\/span> torchquantum.measurement import<\/span> expval_joint_analytical\r\nexpval = expval_joint_analytical(qdev, 'ZX'<\/span>)\r\nprint(expval)\r\n\r\n# obtain gradients of expval w.r.t. trainable parameters<\/span>\r\nexpval[0<\/span>].backward()\r\nprint(op.params.grad)\r\n\r\n\r\n# Apply gates to qdev with tq.QuantumModule<\/span>\r\nops = [\r\n {'name'<\/span>: 'hadamard'<\/span>, 'wires'<\/span>: 0<\/span>}, \r\n {'name'<\/span>: 'cnot'<\/span>, 'wires'<\/span>: [0<\/span>, 1<\/span>]},\r\n {'name'<\/span>: 'rx'<\/span>, 'wires'<\/span>: 0<\/span>, 'params'<\/span>: 0.5<\/span>, 'trainable'<\/span>: True<\/span>},\r\n {'name'<\/span>: 'u3'<\/span>, 'wires'<\/span>: 0<\/span>, 'params'<\/span>: [0.1<\/span>, 0.2<\/span>, 0.3<\/span>], 'trainable'<\/span>: True<\/span>},\r\n {'name'<\/span>: 'h'<\/span>, 'wires'<\/span>: 1<\/span>, 'inverse'<\/span>: True<\/span>}\r\n]\r\n\r\nqmodule = tq.QuantumModule.from_op_history(ops)\r\nqmodule(qdev)\r\n<\/code><\/pre>\n<\/p>\n
Guide to the examples<\/h2>\n
We also prepare many example and tutorials using TorchQuantum.<\/p>\n
For beginning level<\/strong>, you may check QNN for MNIST<\/a>, Quantum Convolution (Quanvolution)<\/a> and Quantum Kernel Method<\/a>, and Quantum Regression<\/a>.<\/p>\nFor intermediate level<\/strong>, you may check Amplitude Encoding for MNIST<\/a>, Clifford gate QNN<\/a>, Save and Load QNN models<\/a>, PauliSum Operation<\/a>, How to convert tq to Qiskit<\/a>.<\/p>\nFor expert<\/strong>, you may check Parameter Shift on-chip Training<\/a>, VQA Gradient Pruning<\/a>, VQE<\/a>, VQA for State Prepration<\/a>, QAOA (Quantum Approximate Optimization Algorithm)<\/a>.<\/p>\nUsage<\/h2>\n
Construct parameterized quantum circuit models as simple as constructing a normal pytorch model.<\/p>\n
import<\/span> torch.nn as<\/span> nn\r\nimport<\/span> torch.nn.functional as<\/span> F\r\nimport<\/span> torchquantum as<\/span> tq\r\nimport<\/span> torchquantum.functional as<\/span> tqf\r\n\r\nclass<\/span> QFCModel<\/span>(nn<\/span>.Module<\/span>):\r\n def __init__(self<\/span>):\r\n super().__init__()\r\n self.n_wires = 4\r\n self.measure = tq.MeasureAll<\/span>(tq<\/span>.PauliZ<\/span>)\r\n\r\n self.encoder_gates = [tqf.rx] * 4 + [tqf.ry] * 4 + \\\r\n [tqf.rz] * 4 + [tqf.rx] * 4\r\n self.rx0 = tq.RX<\/span>(has_params<\/span>=True<\/span>, trainable<\/span>=True<\/span>)\r\n self.ry0 = tq.RY<\/span>(has_params<\/span>=True<\/span>, trainable<\/span>=True<\/span>)\r\n self.rz0 = tq.RZ<\/span>(has_params<\/span>=True<\/span>, trainable<\/span>=True<\/span>)\r\n self.crx0 = tq.CRX<\/span>(has_params<\/span>=True<\/span>, trainable<\/span>=True<\/span>)\r\n\r\n def forward(self<\/span>, x<\/span>):\r\n bsz = x.shape[0]\r\n # down-sample the image\r\n x = F<\/span>.avg_pool2d(x<\/span>, 6).view(bsz<\/span>, 16)\r\n\r\n # create a quantum device to run the gates\r\n qdev = tq.QuantumDevice<\/span>(n_wires<\/span>=self<\/span>.n_wires<\/span>, bsz<\/span>=bsz<\/span>, device<\/span>=x<\/span>.device<\/span>)\r\n\r\n # encode the classical image to quantum domain\r\n for k, gate in enumerate(self<\/span>.encoder_gates<\/span>):\r\n gate(qdev<\/span>, wires<\/span>=k<\/span> % self<\/span>.n_wires<\/span>, params<\/span>=x<\/span>[:, k<\/span>])\r\n\r\n # add some trainable gates (need<\/span> to<\/span> instantiate<\/span> ahead<\/span> of<\/span> time<\/span>)\r\n self.rx0(qdev<\/span>, wires<\/span>=0)\r\n self.ry0(qdev<\/span>, wires<\/span>=1)\r\n self.rz0(qdev<\/span>, wires<\/span>=3)\r\n self.crx0(qdev<\/span>, wires<\/span>=[0, 2])\r\n\r\n # add some more non-parameterized gates (add<\/span> on<\/span>-the<\/span>-fly<\/span>)\r\n qdev.h(wires<\/span>=3)\r\n qdev.sx(wires<\/span>=2)\r\n qdev.cnot(wires<\/span>=[3, 0])\r\n qdev.qubitunitary(wires<\/span>=[1, 2], params<\/span>=[[1, 0, 0, 0],\r\n [0, 1, 0, 0],\r\n [0, 0, 0, 1j<\/span>],\r\n [0, 0, -1j<\/span>, 0]])\r\n\r\n # perform measurement to get expectations (back<\/span> to<\/span> classical<\/span> domain<\/span>)\r\n x = self.measure(qdev<\/span>).reshape(bsz<\/span>, 2, 2)\r\n\r\n # classification\r\n x = x.sum(-1).squeeze()\r\n x = F<\/span>.log_softmax(x<\/span>, dim<\/span>=1)\r\n\r\n return x<\/span>\r\n<\/code><\/pre>\nVQE Example<\/h2>\n
Train a quantum circuit to perform VQE task.
\nQuito quantum computer as in simple_vqe.py<\/a>
\nscript:<\/p>\ncd<\/span> examples\/simple_vqe\r\npython<\/span> simple_vqe.py<\/span>\r\n<\/code><\/pre>\nMNIST Example<\/h2>\n
Train a quantum circuit to perform MNIST classification task and deploy on the real IBM
\nQuito quantum computer as in mnist_example.py<\/a>
\nscript:<\/p>\ncd<\/span> examples\/simple_mnist\r\npython<\/span> mnist_example.py<\/span>\r\n<\/code><\/pre>\nFiles<\/h2>\n
Features<\/h2>\n\n- Easy construction and simulation of quantum circuits in PyTorch<\/strong><\/li>\n
- Dynamic computation graph<\/strong> for easy debugging<\/li>\n
- Gradient support<\/strong> via autograd<\/li>\n
- Batch mode<\/strong> inference and training on CPU\/GPU<\/strong><\/li>\n
- Easy deployment on real quantum devices<\/strong> such as IBMQ<\/li>\n
- Easy hybrid classical-quantum<\/strong> model construction<\/li>\n
- (coming soon) pulse-level simulation<\/strong><\/li>\n<\/ul>\n
Installation<\/h2>\ngit clone<\/span> https<\/span>:\/\/github.com\/mit-han-lab\/torchquantum.git\r\ncd torchquantum\r\npip install --editable .\r\n<\/code><\/pre>\nBasic Usage<\/h2>\nimport<\/span> torchquantum as<\/span> tq\r\nimport<\/span> torchquantum.functional as<\/span> tqf\r\n\r\nqdev = tq.QuantumDevice(n_wires=2<\/span>, bsz=5<\/span>, device=\"cpu\"<\/span>, record_op=True<\/span>) # use device='cuda' for GPU<\/span>\r\n\r\n# use qdev.op<\/span>\r\nqdev.h(wires=0<\/span>)\r\nqdev.cnot(wires=[0<\/span>, 1<\/span>])\r\n\r\n# use tqf<\/span>\r\ntqf.h(qdev, wires=1<\/span>)\r\ntqf.x(qdev, wires=1<\/span>)\r\n\r\n# use tq.Operator<\/span>\r\nop = tq.RX(has_params=True<\/span>, trainable=True<\/span>, init_params=0.5<\/span>)\r\nop(qdev, wires=0<\/span>)\r\n\r\n# print the current state (dynamic computation graph supported)<\/span>\r\nprint(qdev)\r\n\r\n# obtain the qasm string<\/span>\r\nfrom<\/span> torchquantum.plugins import<\/span> op_history2qasm\r\nprint(op_history2qasm(qdev.n_wires, qdev.op_history))\r\n\r\n# measure the state on z basis<\/span>\r\nprint(tq.measure(qdev, n_shots=1024<\/span>))\r\n\r\n# obtain the expval on a observable by stochastic sampling (doable on simulator and real quantum hardware)<\/span>\r\nfrom<\/span> torchquantum.measurement import<\/span> expval_joint_sampling\r\nexpval_sampling = expval_joint_sampling(qdev, 'ZX'<\/span>, n_shots=1024<\/span>)\r\nprint(expval_sampling)\r\n\r\n# obtain the expval on a observable by analytical computation (only doable on classical simulator)<\/span>\r\nfrom<\/span> torchquantum.measurement import<\/span> expval_joint_analytical\r\nexpval = expval_joint_analytical(qdev, 'ZX'<\/span>)\r\nprint(expval)\r\n\r\n# obtain gradients of expval w.r.t. trainable parameters<\/span>\r\nexpval[0<\/span>].backward()\r\nprint(op.params.grad)\r\n\r\n\r\n# Apply gates to qdev with tq.QuantumModule<\/span>\r\nops = [\r\n {'name'<\/span>: 'hadamard'<\/span>, 'wires'<\/span>: 0<\/span>}, \r\n {'name'<\/span>: 'cnot'<\/span>, 'wires'<\/span>: [0<\/span>, 1<\/span>]},\r\n {'name'<\/span>: 'rx'<\/span>, 'wires'<\/span>: 0<\/span>, 'params'<\/span>: 0.5<\/span>, 'trainable'<\/span>: True<\/span>},\r\n {'name'<\/span>: 'u3'<\/span>, 'wires'<\/span>: 0<\/span>, 'params'<\/span>: [0.1<\/span>, 0.2<\/span>, 0.3<\/span>], 'trainable'<\/span>: True<\/span>},\r\n {'name'<\/span>: 'h'<\/span>, 'wires'<\/span>: 1<\/span>, 'inverse'<\/span>: True<\/span>}\r\n]\r\n\r\nqmodule = tq.QuantumModule.from_op_history(ops)\r\nqmodule(qdev)\r\n<\/code><\/pre>\n<\/p>\n
Guide to the examples<\/h2>\n
We also prepare many example and tutorials using TorchQuantum.<\/p>\n
For beginning level<\/strong>, you may check QNN for MNIST<\/a>, Quantum Convolution (Quanvolution)<\/a> and Quantum Kernel Method<\/a>, and Quantum Regression<\/a>.<\/p>\nFor intermediate level<\/strong>, you may check Amplitude Encoding for MNIST<\/a>, Clifford gate QNN<\/a>, Save and Load QNN models<\/a>, PauliSum Operation<\/a>, How to convert tq to Qiskit<\/a>.<\/p>\nFor expert<\/strong>, you may check Parameter Shift on-chip Training<\/a>, VQA Gradient Pruning<\/a>, VQE<\/a>, VQA for State Prepration<\/a>, QAOA (Quantum Approximate Optimization Algorithm)<\/a>.<\/p>\nUsage<\/h2>\n
Construct parameterized quantum circuit models as simple as constructing a normal pytorch model.<\/p>\n
import<\/span> torch.nn as<\/span> nn\r\nimport<\/span> torch.nn.functional as<\/span> F\r\nimport<\/span> torchquantum as<\/span> tq\r\nimport<\/span> torchquantum.functional as<\/span> tqf\r\n\r\nclass<\/span> QFCModel<\/span>(nn<\/span>.Module<\/span>):\r\n def __init__(self<\/span>):\r\n super().__init__()\r\n self.n_wires = 4\r\n self.measure = tq.MeasureAll<\/span>(tq<\/span>.PauliZ<\/span>)\r\n\r\n self.encoder_gates = [tqf.rx] * 4 + [tqf.ry] * 4 + \\\r\n [tqf.rz] * 4 + [tqf.rx] * 4\r\n self.rx0 = tq.RX<\/span>(has_params<\/span>=True<\/span>, trainable<\/span>=True<\/span>)\r\n self.ry0 = tq.RY<\/span>(has_params<\/span>=True<\/span>, trainable<\/span>=True<\/span>)\r\n self.rz0 = tq.RZ<\/span>(has_params<\/span>=True<\/span>, trainable<\/span>=True<\/span>)\r\n self.crx0 = tq.CRX<\/span>(has_params<\/span>=True<\/span>, trainable<\/span>=True<\/span>)\r\n\r\n def forward(self<\/span>, x<\/span>):\r\n bsz = x.shape[0]\r\n # down-sample the image\r\n x = F<\/span>.avg_pool2d(x<\/span>, 6).view(bsz<\/span>, 16)\r\n\r\n # create a quantum device to run the gates\r\n qdev = tq.QuantumDevice<\/span>(n_wires<\/span>=self<\/span>.n_wires<\/span>, bsz<\/span>=bsz<\/span>, device<\/span>=x<\/span>.device<\/span>)\r\n\r\n # encode the classical image to quantum domain\r\n for k, gate in enumerate(self<\/span>.encoder_gates<\/span>):\r\n gate(qdev<\/span>, wires<\/span>=k<\/span> % self<\/span>.n_wires<\/span>, params<\/span>=x<\/span>[:, k<\/span>])\r\n\r\n # add some trainable gates (need<\/span> to<\/span> instantiate<\/span> ahead<\/span> of<\/span> time<\/span>)\r\n self.rx0(qdev<\/span>, wires<\/span>=0)\r\n self.ry0(qdev<\/span>, wires<\/span>=1)\r\n self.rz0(qdev<\/span>, wires<\/span>=3)\r\n self.crx0(qdev<\/span>, wires<\/span>=[0, 2])\r\n\r\n # add some more non-parameterized gates (add<\/span> on<\/span>-the<\/span>-fly<\/span>)\r\n qdev.h(wires<\/span>=3)\r\n qdev.sx(wires<\/span>=2)\r\n qdev.cnot(wires<\/span>=[3, 0])\r\n qdev.qubitunitary(wires<\/span>=[1, 2], params<\/span>=[[1, 0, 0, 0],\r\n [0, 1, 0, 0],\r\n [0, 0, 0, 1j<\/span>],\r\n [0, 0, -1j<\/span>, 0]])\r\n\r\n # perform measurement to get expectations (back<\/span> to<\/span> classical<\/span> domain<\/span>)\r\n x = self.measure(qdev<\/span>).reshape(bsz<\/span>, 2, 2)\r\n\r\n # classification\r\n x = x.sum(-1).squeeze()\r\n x = F<\/span>.log_softmax(x<\/span>, dim<\/span>=1)\r\n\r\n return x<\/span>\r\n<\/code><\/pre>\nVQE Example<\/h2>\n
Train a quantum circuit to perform VQE task.
\nQuito quantum computer as in simple_vqe.py<\/a>
\nscript:<\/p>\ncd<\/span> examples\/simple_vqe\r\npython<\/span> simple_vqe.py<\/span>\r\n<\/code><\/pre>\nMNIST Example<\/h2>\n
Train a quantum circuit to perform MNIST classification task and deploy on the real IBM
\nQuito quantum computer as in mnist_example.py<\/a>
\nscript:<\/p>\ncd<\/span> examples\/simple_mnist\r\npython<\/span> mnist_example.py<\/span>\r\n<\/code><\/pre>\nFiles<\/h2>\n
Installation<\/h2>\ngit clone<\/span> https<\/span>:\/\/github.com\/mit-han-lab\/torchquantum.git\r\ncd torchquantum\r\npip install --editable .\r\n<\/code><\/pre>\nBasic Usage<\/h2>\nimport<\/span> torchquantum as<\/span> tq\r\nimport<\/span> torchquantum.functional as<\/span> tqf\r\n\r\nqdev = tq.QuantumDevice(n_wires=2<\/span>, bsz=5<\/span>, device=\"cpu\"<\/span>, record_op=True<\/span>) # use device='cuda' for GPU<\/span>\r\n\r\n# use qdev.op<\/span>\r\nqdev.h(wires=0<\/span>)\r\nqdev.cnot(wires=[0<\/span>, 1<\/span>])\r\n\r\n# use tqf<\/span>\r\ntqf.h(qdev, wires=1<\/span>)\r\ntqf.x(qdev, wires=1<\/span>)\r\n\r\n# use tq.Operator<\/span>\r\nop = tq.RX(has_params=True<\/span>, trainable=True<\/span>, init_params=0.5<\/span>)\r\nop(qdev, wires=0<\/span>)\r\n\r\n# print the current state (dynamic computation graph supported)<\/span>\r\nprint(qdev)\r\n\r\n# obtain the qasm string<\/span>\r\nfrom<\/span> torchquantum.plugins import<\/span> op_history2qasm\r\nprint(op_history2qasm(qdev.n_wires, qdev.op_history))\r\n\r\n# measure the state on z basis<\/span>\r\nprint(tq.measure(qdev, n_shots=1024<\/span>))\r\n\r\n# obtain the expval on a observable by stochastic sampling (doable on simulator and real quantum hardware)<\/span>\r\nfrom<\/span> torchquantum.measurement import<\/span> expval_joint_sampling\r\nexpval_sampling = expval_joint_sampling(qdev, 'ZX'<\/span>, n_shots=1024<\/span>)\r\nprint(expval_sampling)\r\n\r\n# obtain the expval on a observable by analytical computation (only doable on classical simulator)<\/span>\r\nfrom<\/span> torchquantum.measurement import<\/span> expval_joint_analytical\r\nexpval = expval_joint_analytical(qdev, 'ZX'<\/span>)\r\nprint(expval)\r\n\r\n# obtain gradients of expval w.r.t. trainable parameters<\/span>\r\nexpval[0<\/span>].backward()\r\nprint(op.params.grad)\r\n\r\n\r\n# Apply gates to qdev with tq.QuantumModule<\/span>\r\nops = [\r\n {'name'<\/span>: 'hadamard'<\/span>, 'wires'<\/span>: 0<\/span>}, \r\n {'name'<\/span>: 'cnot'<\/span>, 'wires'<\/span>: [0<\/span>, 1<\/span>]},\r\n {'name'<\/span>: 'rx'<\/span>, 'wires'<\/span>: 0<\/span>, 'params'<\/span>: 0.5<\/span>, 'trainable'<\/span>: True<\/span>},\r\n {'name'<\/span>: 'u3'<\/span>, 'wires'<\/span>: 0<\/span>, 'params'<\/span>: [0.1<\/span>, 0.2<\/span>, 0.3<\/span>], 'trainable'<\/span>: True<\/span>},\r\n {'name'<\/span>: 'h'<\/span>, 'wires'<\/span>: 1<\/span>, 'inverse'<\/span>: True<\/span>}\r\n]\r\n\r\nqmodule = tq.QuantumModule.from_op_history(ops)\r\nqmodule(qdev)\r\n<\/code><\/pre>\n<\/p>\n
Guide to the examples<\/h2>\n
We also prepare many example and tutorials using TorchQuantum.<\/p>\n
For beginning level<\/strong>, you may check QNN for MNIST<\/a>, Quantum Convolution (Quanvolution)<\/a> and Quantum Kernel Method<\/a>, and Quantum Regression<\/a>.<\/p>\nFor intermediate level<\/strong>, you may check Amplitude Encoding for MNIST<\/a>, Clifford gate QNN<\/a>, Save and Load QNN models<\/a>, PauliSum Operation<\/a>, How to convert tq to Qiskit<\/a>.<\/p>\nFor expert<\/strong>, you may check Parameter Shift on-chip Training<\/a>, VQA Gradient Pruning<\/a>, VQE<\/a>, VQA for State Prepration<\/a>, QAOA (Quantum Approximate Optimization Algorithm)<\/a>.<\/p>\nUsage<\/h2>\n
Construct parameterized quantum circuit models as simple as constructing a normal pytorch model.<\/p>\n
import<\/span> torch.nn as<\/span> nn\r\nimport<\/span> torch.nn.functional as<\/span> F\r\nimport<\/span> torchquantum as<\/span> tq\r\nimport<\/span> torchquantum.functional as<\/span> tqf\r\n\r\nclass<\/span> QFCModel<\/span>(nn<\/span>.Module<\/span>):\r\n def __init__(self<\/span>):\r\n super().__init__()\r\n self.n_wires = 4\r\n self.measure = tq.MeasureAll<\/span>(tq<\/span>.PauliZ<\/span>)\r\n\r\n self.encoder_gates = [tqf.rx] * 4 + [tqf.ry] * 4 + \\\r\n [tqf.rz] * 4 + [tqf.rx] * 4\r\n self.rx0 = tq.RX<\/span>(has_params<\/span>=True<\/span>, trainable<\/span>=True<\/span>)\r\n self.ry0 = tq.RY<\/span>(has_params<\/span>=True<\/span>, trainable<\/span>=True<\/span>)\r\n self.rz0 = tq.RZ<\/span>(has_params<\/span>=True<\/span>, trainable<\/span>=True<\/span>)\r\n self.crx0 = tq.CRX<\/span>(has_params<\/span>=True<\/span>, trainable<\/span>=True<\/span>)\r\n\r\n def forward(self<\/span>, x<\/span>):\r\n bsz = x.shape[0]\r\n # down-sample the image\r\n x = F<\/span>.avg_pool2d(x<\/span>, 6).view(bsz<\/span>, 16)\r\n\r\n # create a quantum device to run the gates\r\n qdev = tq.QuantumDevice<\/span>(n_wires<\/span>=self<\/span>.n_wires<\/span>, bsz<\/span>=bsz<\/span>, device<\/span>=x<\/span>.device<\/span>)\r\n\r\n # encode the classical image to quantum domain\r\n for k, gate in enumerate(self<\/span>.encoder_gates<\/span>):\r\n gate(qdev<\/span>, wires<\/span>=k<\/span> % self<\/span>.n_wires<\/span>, params<\/span>=x<\/span>[:, k<\/span>])\r\n\r\n # add some trainable gates (need<\/span> to<\/span> instantiate<\/span> ahead<\/span> of<\/span> time<\/span>)\r\n self.rx0(qdev<\/span>, wires<\/span>=0)\r\n self.ry0(qdev<\/span>, wires<\/span>=1)\r\n self.rz0(qdev<\/span>, wires<\/span>=3)\r\n self.crx0(qdev<\/span>, wires<\/span>=[0, 2])\r\n\r\n # add some more non-parameterized gates (add<\/span> on<\/span>-the<\/span>-fly<\/span>)\r\n qdev.h(wires<\/span>=3)\r\n qdev.sx(wires<\/span>=2)\r\n qdev.cnot(wires<\/span>=[3, 0])\r\n qdev.qubitunitary(wires<\/span>=[1, 2], params<\/span>=[[1, 0, 0, 0],\r\n [0, 1, 0, 0],\r\n [0, 0, 0, 1j<\/span>],\r\n [0, 0, -1j<\/span>, 0]])\r\n\r\n # perform measurement to get expectations (back<\/span> to<\/span> classical<\/span> domain<\/span>)\r\n x = self.measure(qdev<\/span>).reshape(bsz<\/span>, 2, 2)\r\n\r\n # classification\r\n x = x.sum(-1).squeeze()\r\n x = F<\/span>.log_softmax(x<\/span>, dim<\/span>=1)\r\n\r\n return x<\/span>\r\n<\/code><\/pre>\nVQE Example<\/h2>\n
Train a quantum circuit to perform VQE task.
\nQuito quantum computer as in simple_vqe.py<\/a>
\nscript:<\/p>\ncd<\/span> examples\/simple_vqe\r\npython<\/span> simple_vqe.py<\/span>\r\n<\/code><\/pre>\nMNIST Example<\/h2>\n
Train a quantum circuit to perform MNIST classification task and deploy on the real IBM
\nQuito quantum computer as in mnist_example.py<\/a>
\nscript:<\/p>\ncd<\/span> examples\/simple_mnist\r\npython<\/span> mnist_example.py<\/span>\r\n<\/code><\/pre>\nFiles<\/h2>\n
git clone<\/span> https<\/span>:\/\/github.com\/mit-han-lab\/torchquantum.git\r\ncd torchquantum\r\npip install --editable .\r\n<\/code><\/pre>\nBasic Usage<\/h2>\nimport<\/span> torchquantum as<\/span> tq\r\nimport<\/span> torchquantum.functional as<\/span> tqf\r\n\r\nqdev = tq.QuantumDevice(n_wires=2<\/span>, bsz=5<\/span>, device=\"cpu\"<\/span>, record_op=True<\/span>) # use device='cuda' for GPU<\/span>\r\n\r\n# use qdev.op<\/span>\r\nqdev.h(wires=0<\/span>)\r\nqdev.cnot(wires=[0<\/span>, 1<\/span>])\r\n\r\n# use tqf<\/span>\r\ntqf.h(qdev, wires=1<\/span>)\r\ntqf.x(qdev, wires=1<\/span>)\r\n\r\n# use tq.Operator<\/span>\r\nop = tq.RX(has_params=True<\/span>, trainable=True<\/span>, init_params=0.5<\/span>)\r\nop(qdev, wires=0<\/span>)\r\n\r\n# print the current state (dynamic computation graph supported)<\/span>\r\nprint(qdev)\r\n\r\n# obtain the qasm string<\/span>\r\nfrom<\/span> torchquantum.plugins import<\/span> op_history2qasm\r\nprint(op_history2qasm(qdev.n_wires, qdev.op_history))\r\n\r\n# measure the state on z basis<\/span>\r\nprint(tq.measure(qdev, n_shots=1024<\/span>))\r\n\r\n# obtain the expval on a observable by stochastic sampling (doable on simulator and real quantum hardware)<\/span>\r\nfrom<\/span> torchquantum.measurement import<\/span> expval_joint_sampling\r\nexpval_sampling = expval_joint_sampling(qdev, 'ZX'<\/span>, n_shots=1024<\/span>)\r\nprint(expval_sampling)\r\n\r\n# obtain the expval on a observable by analytical computation (only doable on classical simulator)<\/span>\r\nfrom<\/span> torchquantum.measurement import<\/span> expval_joint_analytical\r\nexpval = expval_joint_analytical(qdev, 'ZX'<\/span>)\r\nprint(expval)\r\n\r\n# obtain gradients of expval w.r.t. trainable parameters<\/span>\r\nexpval[0<\/span>].backward()\r\nprint(op.params.grad)\r\n\r\n\r\n# Apply gates to qdev with tq.QuantumModule<\/span>\r\nops = [\r\n {'name'<\/span>: 'hadamard'<\/span>, 'wires'<\/span>: 0<\/span>}, \r\n {'name'<\/span>: 'cnot'<\/span>, 'wires'<\/span>: [0<\/span>, 1<\/span>]},\r\n {'name'<\/span>: 'rx'<\/span>, 'wires'<\/span>: 0<\/span>, 'params'<\/span>: 0.5<\/span>, 'trainable'<\/span>: True<\/span>},\r\n {'name'<\/span>: 'u3'<\/span>, 'wires'<\/span>: 0<\/span>, 'params'<\/span>: [0.1<\/span>, 0.2<\/span>, 0.3<\/span>], 'trainable'<\/span>: True<\/span>},\r\n {'name'<\/span>: 'h'<\/span>, 'wires'<\/span>: 1<\/span>, 'inverse'<\/span>: True<\/span>}\r\n]\r\n\r\nqmodule = tq.QuantumModule.from_op_history(ops)\r\nqmodule(qdev)\r\n<\/code><\/pre>\n<\/p>\n
Guide to the examples<\/h2>\n
We also prepare many example and tutorials using TorchQuantum.<\/p>\n
For beginning level<\/strong>, you may check QNN for MNIST<\/a>, Quantum Convolution (Quanvolution)<\/a> and Quantum Kernel Method<\/a>, and Quantum Regression<\/a>.<\/p>\nFor intermediate level<\/strong>, you may check Amplitude Encoding for MNIST<\/a>, Clifford gate QNN<\/a>, Save and Load QNN models<\/a>, PauliSum Operation<\/a>, How to convert tq to Qiskit<\/a>.<\/p>\nFor expert<\/strong>, you may check Parameter Shift on-chip Training<\/a>, VQA Gradient Pruning<\/a>, VQE<\/a>, VQA for State Prepration<\/a>, QAOA (Quantum Approximate Optimization Algorithm)<\/a>.<\/p>\nUsage<\/h2>\n
Construct parameterized quantum circuit models as simple as constructing a normal pytorch model.<\/p>\n
import<\/span> torch.nn as<\/span> nn\r\nimport<\/span> torch.nn.functional as<\/span> F\r\nimport<\/span> torchquantum as<\/span> tq\r\nimport<\/span> torchquantum.functional as<\/span> tqf\r\n\r\nclass<\/span> QFCModel<\/span>(nn<\/span>.Module<\/span>):\r\n def __init__(self<\/span>):\r\n super().__init__()\r\n self.n_wires = 4\r\n self.measure = tq.MeasureAll<\/span>(tq<\/span>.PauliZ<\/span>)\r\n\r\n self.encoder_gates = [tqf.rx] * 4 + [tqf.ry] * 4 + \\\r\n [tqf.rz] * 4 + [tqf.rx] * 4\r\n self.rx0 = tq.RX<\/span>(has_params<\/span>=True<\/span>, trainable<\/span>=True<\/span>)\r\n self.ry0 = tq.RY<\/span>(has_params<\/span>=True<\/span>, trainable<\/span>=True<\/span>)\r\n self.rz0 = tq.RZ<\/span>(has_params<\/span>=True<\/span>, trainable<\/span>=True<\/span>)\r\n self.crx0 = tq.CRX<\/span>(has_params<\/span>=True<\/span>, trainable<\/span>=True<\/span>)\r\n\r\n def forward(self<\/span>, x<\/span>):\r\n bsz = x.shape[0]\r\n # down-sample the image\r\n x = F<\/span>.avg_pool2d(x<\/span>, 6).view(bsz<\/span>, 16)\r\n\r\n # create a quantum device to run the gates\r\n qdev = tq.QuantumDevice<\/span>(n_wires<\/span>=self<\/span>.n_wires<\/span>, bsz<\/span>=bsz<\/span>, device<\/span>=x<\/span>.device<\/span>)\r\n\r\n # encode the classical image to quantum domain\r\n for k, gate in enumerate(self<\/span>.encoder_gates<\/span>):\r\n gate(qdev<\/span>, wires<\/span>=k<\/span> % self<\/span>.n_wires<\/span>, params<\/span>=x<\/span>[:, k<\/span>])\r\n\r\n # add some trainable gates (need<\/span> to<\/span> instantiate<\/span> ahead<\/span> of<\/span> time<\/span>)\r\n self.rx0(qdev<\/span>, wires<\/span>=0)\r\n self.ry0(qdev<\/span>, wires<\/span>=1)\r\n self.rz0(qdev<\/span>, wires<\/span>=3)\r\n self.crx0(qdev<\/span>, wires<\/span>=[0, 2])\r\n\r\n # add some more non-parameterized gates (add<\/span> on<\/span>-the<\/span>-fly<\/span>)\r\n qdev.h(wires<\/span>=3)\r\n qdev.sx(wires<\/span>=2)\r\n qdev.cnot(wires<\/span>=[3, 0])\r\n qdev.qubitunitary(wires<\/span>=[1, 2], params<\/span>=[[1, 0, 0, 0],\r\n [0, 1, 0, 0],\r\n [0, 0, 0, 1j<\/span>],\r\n [0, 0, -1j<\/span>, 0]])\r\n\r\n # perform measurement to get expectations (back<\/span> to<\/span> classical<\/span> domain<\/span>)\r\n x = self.measure(qdev<\/span>).reshape(bsz<\/span>, 2, 2)\r\n\r\n # classification\r\n x = x.sum(-1).squeeze()\r\n x = F<\/span>.log_softmax(x<\/span>, dim<\/span>=1)\r\n\r\n return x<\/span>\r\n<\/code><\/pre>\nVQE Example<\/h2>\n
Train a quantum circuit to perform VQE task.
\nQuito quantum computer as in simple_vqe.py<\/a>
\nscript:<\/p>\ncd<\/span> examples\/simple_vqe\r\npython<\/span> simple_vqe.py<\/span>\r\n<\/code><\/pre>\nMNIST Example<\/h2>\n
Train a quantum circuit to perform MNIST classification task and deploy on the real IBM
\nQuito quantum computer as in mnist_example.py<\/a>
\nscript:<\/p>\ncd<\/span> examples\/simple_mnist\r\npython<\/span> mnist_example.py<\/span>\r\n<\/code><\/pre>\nFiles<\/h2>\n