update2 noisemodel

Author: yutuer21

.github/workflows/ci.yml

@@ -48,6 +48,8 @@ jobs:
           python mcnoise_boost.py
           python quantumng.py
           python universal_lr.py
+          python parameter_shift.py
+          python mpsvsexact.py
       - name: setup build
         run: |
           python3 setup.py build

.gitignore

@@ -1,3 +1,4 @@
+data
 .prettierignore
 .idea/
 dataset

CHANGELOG.md

@@ -2,6 +2,24 @@
 
 ## Unreleased
 
+### Added
+
+- Add native support for `rxx`, `ryy` and `rzz` gates for translation from qiskit
+
+- Add `from_openqasm` and `from_openqasm_file` methods for `Circuit`
+
+- Add `circuit_params` argument for translation from qiskit to make the interface universal and consistent with other `from_` methods
+
+- Add `shifts` tuple parameter for `experimental.parameter_shift_grad` API so that we can also customize finite difference gradient from this method
+
+### Changed
+
+- Improve the efficiency of `sample_expectation_ps` method by using cached state.
+
+### Fixed
+
+- Fixed `unitary_kraus` of Circuit class support for multi-qubit kraus channels, previous implementation fails to reshape the kraus tensor as matrix
+
 ## 0.5.0
 
 ### Added

README.md

@@ -109,7 +109,7 @@ We also have [Docker support](/docker).
 
 - Efficiency
 
-  - Time: 10 to 10^6 times acceleration compared to tfq or qiskit
+  - Time: 10 to 10^6+ times acceleration compared to TensorFlow Quantum, Pennylane or Qiskit
 
   - Space: 600+ qubits 1D VQE workflow (converged energy inaccuracy: < 1%)
 

README_cn.md

@@ -105,7 +105,7 @@ pip install tensorcircuit-nightly
 
 - 效率
 
-  - 时间：与 TFQ 或 Qiskit 相比，加速 10 到 10^6 倍
+  - 时间：与 TFQ, Pennylane, 或 Qiskit 相比，加速 10 到 10^6+ 倍
 
   - 空间：600+ qubits 1D VQE 工作流（收敛能量误差：< 1%）
 
@@ -145,7 +145,3 @@ pip install tensorcircuit-nightly
 
 VQEX 在 MBL 相位识别上的应用见 [教程](/docs/source/tutorials/vqex_mbl.ipynb)。
 参考论文: https://arxiv.org/pdf/2111.13719.pdf 。
-
-```
-
-```

benchmarks/README.md

@@ -2,7 +2,7 @@
 
 `cd scripts`
 
-`python benchmark.py -n [# of Qubits] -nlayer [# of QC layers] -nitrs [# of max iterations] -t [time limitation] -gpu [0 for no gpu and 1 for gpu enabled] -tcbackend [jax or tensorflow]`
+`python benchmark.py -n [# of Qubits] -nlayer [# of QC layers] -nitrs [# of max iterations] -nbatch [# of batch for QML task] -t [time limitation] -gpu [0 for no gpu and 1 for gpu enabled] -tcbackend [jax or tensorflow]`
 
 then a `.json` file will be created in data folder which contains the information of benchmarking parameters and results.
 

benchmarks/scripts/qml_pennylane.py

@@ -10,8 +10,6 @@
 import tensorcircuit as tc
 import utils
 
-tc.set_backend("tensorflow")
-
 
 def pennylane_benchmark(
     uuid,
@@ -60,6 +58,52 @@ def pennylane_benchmark(
     )
     meta["Results"] = {}
 
+    dev = qml.device("lightning.qubit", wires=nwires)
+
+    K = tc.get_backend("tensorflow")
+
+    @qml.qnode(dev, diff_method="adjoint", interface="tf")
+    def lt_expval(img, params):
+        for i in range(nwires - 1):
+            qml.RX(img[i] * np.pi, wires=i)
+        for j in range(nlayer):
+            for i in range(nwires - 1):
+                qml.IsingZZ(params[i + j * 2 * nwires], wires=[i, nwires - 1])
+            for i in range(nwires):
+                qml.RX(params[nwires + i + j * 2 * nwires], wires=i)
+        return qml.expval(qml.Hamiltonian([1.0], [qml.PauliZ(nwires - 1)], True))
+
+    def loss(imgs, lbls, param):
+        params = K.stack([param for _ in range(lbls.shape[0])])
+        params = K.transpose(params, [1, 0])
+        return K.mean(
+            (lbls - K.cast(lt_expval(imgs, params), "float32") * 0.5 - 0.5) ** 2
+        )
+
+    vag = K.value_and_grad(loss, argnums=2)
+    param = K.convert_to_tensor((np.random.normal(size=[nlayer * 2 * nwires])))
+
+    def f(train_imgs, train_lbls):
+        e, grad = vag(
+            K.transpose(
+                K.convert_to_tensor(np.array(train_imgs).astype(np.float32)), (1, 0)
+            ),
+            K.reshape(
+                K.convert_to_tensor(np.array(train_lbls).astype(np.float32)), (-1)
+            ),
+            param,
+        )
+        return e
+
+    ct, it, Nitrs = utils.qml_timing(f, nbatch, nitrs, timeLimit)
+    meta["Results"]["lightning"] = {
+        "Construction time": ct,
+        "Iteration time": it,
+        "# of actual iterations": Nitrs,
+    }
+
+    print(meta["Results"]["lightning"])
+
     dev = qml.device("default.qubit.jax", wires=nwires)
 
     @qml.qnode(dev, interface="jax")
@@ -196,7 +240,7 @@ def tf_loss(img, lbl, params):
         return loss
 
     tf_vvag = tf.function(
-        tc.backend.vvag(tf_loss, vectorized_argnums=(0, 1), argnums=2)
+        tc.get_backend("tensorflow").vvag(tf_loss, vectorized_argnums=(0, 1), argnums=2)
     )
 
     def f(train_imgs, train_lbls):

benchmarks/scripts/utils.py

@@ -6,6 +6,8 @@
 import numpy as np
 import tensorflow as tf
 from pathlib import Path
+import optax
+import tensorcircuit as tc
 
 
 qml_data = {}
@@ -218,18 +220,16 @@ def save(data, _uuid, path):
 
 def timing(f, nitrs, timeLimit):
     t0 = time.time()
-    print(f())
+    a = f()
     t1 = time.time()
     Nitrs = 1e-8
     for i in range(nitrs):
         a = f()
-        print(a)
         # if a != None:
         #    print(a)
+        Nitrs += 1
         if time.time() - t1 > timeLimit:
             break
-        else:
-            Nitrs += 1
     t2 = time.time()
     return t1 - t0, (t2 - t1) / Nitrs, int(Nitrs)
 
@@ -254,24 +254,38 @@ def qml_timing(f, nbatch, nitrs, timeLimit, tfq=False):
         )
         if a is not None:
             print(a)
+        Nitrs += 1
         if time.time() - t1 > timeLimit:
             break
-        else:
-            Nitrs += 1
     t2 = time.time()
     return t1 - t0, (t2 - t1) / Nitrs, int(Nitrs)
 
 
 class Opt:
-    def __init__(self, f, params, lr=0.01, tuning=True):
+    def __init__(self, f, params, lr=0.002, tuning=True, backend="tensorflow"):
         self.f = f
         self.params = params
-        self.adam = tf.keras.optimizers.Adam(lr)
+        if backend == "tensorflow":
+            self.adam = tc.backend.optimizer(tf.keras.optimizers.Adam(lr))
+        elif backend == "jax":
+            self.adam = tc.backend.optimizer(optax.adam(lr))
+        elif backend == "numpy":
+            self.adam = tc.get_backend("tensorflow").optimizer(
+                tf.keras.optimizers.Adam(lr)
+            )
         self.tuning = tuning
+        self.backend = backend
 
     def step(self):
-        e, grad = self.f(*self.params)
+        if getattr(self.params, "shape", False):
+            e, grad = self.f(self.params)
+        else:
+            e, grad = self.f(*self.params)
         if self.tuning:
-            grad = [tf.convert_to_tensor(g) for g in grad]
-            self.adam.apply_gradients(zip(grad, self.params))
-        return e[()]
+            if self.backend == "numpy":
+                self.params = tf.constant(self.params)
+            self.params = self.adam.update(grad, self.params)
+            if self.backend == "numpy":
+                self.params = self.params.numpy()
+        print(e)
+        return e

benchmarks/scripts/vqe_pennylane.py

@@ -129,6 +129,32 @@ def f():
         "# of actual iterations": Nitrs,
     }
 
+    print("begin testing lightning")
+    dev = qml.device("lightning.qubit", wires=nwires)
+
+    @qml.qnode(dev, diff_method="adjoint")
+    def lt_expval(params):
+        for i in range(nwires):
+            qml.Hadamard(wires=i)
+        for j in range(nlayer):
+            for i in range(nwires - minus):
+                qml.IsingZZ(params[i + j * 2 * nwires], wires=[i, (i + 1) % nwires])
+            for i in range(nwires):
+                qml.RX(params[nwires + i + j * 2 * nwires], wires=i)
+        return qml.expval(Htfim)
+
+    vag = qml.grad(lt_expval, argnum=0)
+    params = np.random.normal(size=[nlayer * 2 * nwires])
+
+    def f():
+        return vag(params)
+
+    ct, it, Nitrs = utils.timing(f, nitrs, timeLimit)
+    meta["Results"]["lightning.cpu"] = {
+        "Construction time": ct,
+        "Iteration time": it,
+        "# of actual iterations": Nitrs,
+    }
     # using tf interface and expvalcost
     # params.assign(np.random.normal(size=[nlayer * 2 * nwires]))
     # cost_fn_tf = qml.ExpvalCost(circuit, Htfim, dev, interface="tf")

benchmarks/scripts/vqe_qibo.py

@@ -0,0 +1,109 @@
+import datetime
+import sys
+import uuid
+import cpuinfo
+
+import tensorcircuit as tc
+
+tc.set_backend("tensorflow")
+import tensorflow as tf
+from functools import reduce
+from operator import mul
+import qibo
+
+qibo.set_backend("tensorflow")
+from qibo import gates, models, hamiltonians
+from qibo.symbols import I, X, Z
+import utils
+
+
+def qibo_benchmark(uuid, n, nlayer, nitrs, timeLimit, minus=1):
+    @tf.function
+    def geth(s, n):
+        ctc = tc.Circuit(n, inputs=s)
+        loss = 0.0
+        for i in range(n - 1):
+            loss += ctc.expectation_ps(z=[i, i + 1])
+        for i in range(n):
+            loss -= ctc.expectation_ps(x=[i])
+        return loss
+
+    @tf.function  # jit will raise error
+    def optimize(params):
+        with tf.GradientTape() as tape:
+            c = models.Circuit(n)
+            for i in range(n):
+                c.add(gates.H(i))
+            for j in range(nlayer):
+                for i in range(n - minus):
+                    c.add(gates.CNOT(i, i + 1))
+                    c.add(gates.RZ(i + 1, theta=params[j, i, 0]))
+                    c.add(gates.CNOT(i, i + 1))
+                for i in range(n):
+                    c.add(gates.RX(0, theta=params[j, i, 1]))
+            s = c().state()
+            # h = hamiltonians.TFIM(n, h=-1)
+            # loss = h.expectation(s)
+            # failed in jit
+            # qibo lacks the API for local expectation, using tc as assistance
+            # we must ensure the observable is computed term by term
+            # instead of the expectation for the Hamiltonian as a whole
+            # to ensure the comparison is fair
+
+            loss = geth(s, n)
+
+        grads = tape.gradient(loss, params)
+        return loss, grads
+
+    meta = {}
+    meta["Software"] = "qibo"
+    meta["minus"] = minus
+    meta["Cpuinfo"] = cpuinfo.get_cpu_info()["brand_raw"]
+    meta["Version"] = {
+        "sys": sys.version,
+        "qibo": qibo.__version__,
+    }
+    meta["VQE test parameters"] = {
+        "nQubits": n,
+        "nlayer": nlayer,
+        "nitrs": nitrs,
+        "timeLimit": timeLimit,
+    }
+    meta["UUID"] = uuid
+    meta["Benchmark Time"] = (
+        datetime.datetime.now().astimezone().strftime("%Y-%m-%d %H:%M %Z")
+    )
+    meta["Results"] = {}
+    params = tf.Variable(tf.random.normal((nlayer, n, 2), dtype=tf.float64))
+    opt = utils.Opt(optimize, params, tuning=True, backend="tensorflow")
+    ct, it, Nitrs = utils.timing(opt.step, nitrs, timeLimit)
+    meta["Results"]["with jit"] = {
+        "Construction time": ct,
+        "Iteration time": it,
+        "# of actual iterations": Nitrs,
+    }
+    print(meta)
+    return meta
+
+
+if __name__ == "__main__":
+    _uuid = str(uuid.uuid4())
+    (
+        n,
+        nlayer,
+        nitrs,
+        timeLimit,
+        isgpu,
+        minus,
+        path,
+    ) = utils.arg()
+
+    r = qibo_benchmark(
+        _uuid,
+        n,
+        nlayer,
+        nitrs,
+        timeLimit,
+        minus=minus,
+    )
+    utils.save(r, _uuid, path)