Merge branch 'beta' into cloud

Author: refraction-ray

CHANGELOG.md

@@ -6,14 +6,26 @@
 
 - Add `tc.about()` to print related software versions and configs
 
-- Torch support is updraded to 2.0, and now support native vmap and native functional grad, and thus `vvag`. Still jit support is conflict with these functional transformations and be turned off by default
+- Torch support is upgraded to 2.0, and now support native vmap and native functional grad, and thus `vvag`. Still jit support is conflict with these functional transformations and be turned off by default
 
 - Add `torch_interfaces_kws` that support static keyword arguments when wrapping with the interface
 
+- Add `gpu_memory_share` function and enable it by default
+
+- Add `scan` methods for backends
+
+- Add example demontrating how jax compiling time can be accelerated by `jax.lax.scan`
+
 ### Fixed
 
 - Add tests and fixed some missing methods for cupy backend, cupy backend is now ready to use (though still not guaranteed)
 
+- Fix adjoint gate numpy conversion for fixed gate case
+
+### Changed
+
+- Upgraded black and mypy==1.2.0 (breaking change for developers)
+
 ## 0.8.0
 
 ### Added

docs/source/quickstart.rst

@@ -696,10 +696,10 @@ There is also a more flexible torch interface that support static non-tensor inp
 .. code-block:: python
 
     def f(a, i):
-    s = 0.
-    for _ in range(i):
-        s += a
-    return s
+        s = 0.
+        for _ in range(i):
+            s += a
+        return s
 
     f_torch = tc.interfaces.torch_interface_kws(f)
     f_torch(torch.ones([2]), i=3)

examples/adiabatic_vqnhe.py

@@ -1,6 +1,7 @@
 """
 Calculate the molecule dissociation curve using VQNHE.
 """
+
 from functools import partial
 import sys
 

examples/bp_benchmark.py

@@ -1,6 +1,7 @@
 """
 benchmark on barren plateau using tfq and tc
 """
+
 import os
 
 os.environ["TF_FORCE_GPU_ALLOW_GROWTH"] = "true"

examples/bp_validation.py

@@ -2,6 +2,7 @@
 Compute the circuit gradient with single qubit random Haar averaged to
 demonstrate the gradient vanishing, aka, barren plateau.
 """
+
 import numpy as np
 from tqdm import tqdm
 import tensorcircuit as tc

examples/chaotic_behavior.py

@@ -1,6 +1,7 @@
 """
 Some chaotic properties calculations from the circuit state.
 """
+
 from functools import partial
 import sys
 

examples/ghz_dqas.py

@@ -1,6 +1,7 @@
 """
 DQAS for GHZ state preparation circuit, deprecated DQAS implementation
 """
+
 import sys
 
 sys.path.insert(0, "../")

examples/hamiltonian_building.py

@@ -1,6 +1,7 @@
 """
 benchmark sparse hamiltonian building
 """
+
 import time
 import numpy as np
 import quimb

examples/hea_scan_jit_acc.py

@@ -0,0 +1,75 @@
+"""
+reducing jit compiling time by general scan magic
+"""
+
+import numpy as np
+import tensorcircuit as tc
+
+n = 10
+nlayers = 16
+param_np = np.random.normal(size=[nlayers, n, 2])
+
+for backend in ["tensorflow", "jax"]:
+    with tc.runtime_backend(backend) as K:
+        print("running %s" % K.name)
+
+        def energy_reference(param, n, nlayers):
+            c = tc.Circuit(n)
+            for i in range(n):
+                c.h(i)
+            for i in range(nlayers):
+                for j in range(n - 1):
+                    c.rzz(j, j + 1, theta=param[i, j, 0])
+                for j in range(n):
+                    c.rx(j, theta=param[i, j, 1])
+            return K.real(c.expectation_ps(z=[0, 1]) + c.expectation_ps(x=[2]))
+
+        vg_reference = K.jit(
+            K.value_and_grad(energy_reference, argnums=0), static_argnums=(1, 2)
+        )
+
+        # a jit efficient way to utilize scan
+
+        def energy(param, n, nlayers, each):
+            def loop_f(s_, param_):
+                c_ = tc.Circuit(n, inputs=s_)
+                for i in range(each):
+                    for j in range(n - 1):
+                        c_.rzz(j, j + 1, theta=param_[i, j, 0])
+                    for j in range(n):
+                        c_.rx(j, theta=param_[i, j, 1])
+                s_ = c_.state()
+                return s_
+
+            c = tc.Circuit(n)
+            for i in range(n):
+                c.h(i)
+            s = c.state()
+            s1 = K.scan(loop_f, K.reshape(param, [nlayers // each, each, n, 2]), s)
+            c1 = tc.Circuit(n, inputs=s1)
+            return K.real(c1.expectation_ps(z=[0, 1]) + c1.expectation_ps(x=[2]))
+
+        vg = K.jit(
+            K.value_and_grad(energy, argnums=0),
+            static_argnums=(1, 2, 3),
+            jit_compile=True,
+        )
+        # set to False can improve compile time for tf
+
+        param = K.convert_to_tensor(param_np)
+
+        for each in [1, 2, 4]:
+            print("  scan impl with each=%s" % str(each))
+            r1 = tc.utils.benchmark(vg, param, n, nlayers, each)
+            print(r1[0][0])
+
+        print("  plain impl")
+        r0 = tc.utils.benchmark(vg_reference, param, n, nlayers)  # too slow
+        np.testing.assert_allclose(r0[0][0], r1[0][0], atol=1e-5)
+        np.testing.assert_allclose(r0[0][1], r1[0][1], atol=1e-5)
+        # correctness check
+
+
+# jit_compile=True icrease runtime while degrades jit time for tensorflow
+# and in general jax improves better with scan methodology,
+# both compile time and running time can outperform tf

examples/incremental_twoqubit.py

@@ -2,6 +2,7 @@
 Optimizing the parameterized circuit with progressively dense two-qubit gates,
 as a potential approach to alleviate barren plateau.
 """
+
 import sys
 
 sys.path.insert(0, "../")