update the refacor of examples! huge refactor!

Author: Wall-ee

docs/source/statics/logoV2.png docs/source/statics/logov2.jpgdocs/source/statics/logoV2.png renamed to docs/source/statics/logov2.jpg

@@ -1,10 +1,10 @@
-API comparison on the same standard variational circuit evaluation task demonstrating the advantage of TensorCircuit API design.
+API comparison on the same standard variational circuit evaluation task demonstrating the advantage of TyxonQ API design.
 
-* QML subtask refers building a keras model of quantum circuit.
+* QML subtask refers building a pytorch model of quantum circuit.
 
 * VQE subtask refers getting energy and circuit gradients.
 
-| # Lines (# Packages) | TensorFlow Quantum | Pennylane | TensorCircuit |
+| # Lines (# Packages) | TensorFlow Quantum | Pennylane | TyxonQ |
 | :------------------: | :----------------: | :-------: | :-----------: |
 |     QML subtask      |       32 (5)       |  18 (2)   |    16 (1)     |
 |     VQE subtask      |       47 (5)       |  29 (2)   |    20 (1)     |

examples/.gitignore

@@ -1,11 +1,11 @@
 """
-compilation utilities in tensorcircuit
+compilation utilities in tyxonq
 """
 
-import tensorcircuit as tc
+import tyxonq as tq
 
 
-c = tc.Circuit(3)
+c = tq.Circuit(3)
 c.rx(0, theta=0.2)
 c.rz(0, theta=-0.3)
 c.ry(1, theta=0.1)
@@ -17,24 +17,24 @@
 c.rxx(1, 2, theta=1.7)
 
 
-c0, _ = tc.compiler.qiskit_compiler.qiskit_compile(
+c0, _ = tq.compiler.qiskit_compiler.qiskit_compile(
     c,
     compiled_options={"optimization_level": 0, "basis_gates": ["cx", "cz", "h", "rz"]},
 )
 
-c1, _ = tc.compiler.qiskit_compiler.qiskit_compile(
+c1, _ = tq.compiler.qiskit_compiler.qiskit_compile(
     c,
     compiled_options={"optimization_level": 1, "basis_gates": ["cx", "cz", "h", "rz"]},
 )
 
 
-c2, _ = tc.compiler.qiskit_compiler.qiskit_compile(
+c2, _ = tq.compiler.qiskit_compiler.qiskit_compile(
     c,
     compiled_options={"optimization_level": 2, "basis_gates": ["cx", "cz", "h", "rz"]},
 )
 
 
-c3, _ = tc.compiler.qiskit_compiler.qiskit_compile(
+c3, _ = tq.compiler.qiskit_compiler.qiskit_compile(
     c,
     compiled_options={"optimization_level": 3, "basis_gates": ["cx", "cz", "h", "rz"]},
 )
@@ -52,14 +52,14 @@
 print(c3.draw())
 
 
-compiler_wo_mapping = tc.compiler.DefaultCompiler()
+compiler_wo_mapping = tq.compiler.DefaultCompiler()
 c4, _ = compiler_wo_mapping(c)
 print(
-    "compiled with tc default compiler: combining the good from qiskit and our tc own"
+    "compiled with tq default compiler: combining the good from qiskit and our tq own"
 )
 # we always uuggest using DefaultCompiler for tasks on qcloud
 # internally we run optimized compiling using U3 basis with qiskit which has good performance
-# and we unroll u3 with rz and apply replace/prune/merge loop developed in tc to further optimize the circuit
+# and we unroll u3 with rz and apply replace/prune/merge loop developed in tq to further optimize the circuit
 print(c4.draw())
 
 print("gate number comparison (last ours vs before qiskit (0, 1, 2, 3))")
@@ -68,7 +68,7 @@
 
 # if we want to apply routing/qubit mapping
 
-compiler_w_mapping = tc.compiler.DefaultCompiler(
+compiler_w_mapping = tq.compiler.DefaultCompiler(
     {"coupling_map": [[0, 2], [2, 0], [1, 0], [0, 1]]}
 )
 c5, info = compiler_w_mapping(c)

examples/apicomparison/README.md

@@ -3,19 +3,19 @@
 """
 
 import numpy as np
-import tensorflow as tf
+import torch
 
-import tensorcircuit as tc
+import tyxonq as tq
 
-ctype, rtype = tc.set_dtype("complex64")
-K = tc.set_backend("tensorflow")
+ctype, rtype = tq.set_dtype("complex64")
+K = tq.set_backend("pytorch")
 
 n = 6
 nlayers = 6
 
 
 def ansatz(structureo, structuret, preprocess="direct"):
-    c = tc.Circuit(n)
+    c = tq.Circuit(n)
     if preprocess == "softmax":
         structureo = K.softmax(structureo, axis=-1)
         structuret = K.softmax(structuret, axis=-1)
@@ -28,30 +28,30 @@ def ansatz(structureo, structuret, preprocess="direct"):
     structureo = K.cast(structureo, ctype)
     structuret = K.cast(structuret, ctype)
 
-    structureo = tf.reshape(structureo, shape=[nlayers, n, 7])
-    structuret = tf.reshape(structuret, shape=[nlayers, n, 3])
+    structureo = torch.reshape(structureo, shape=[nlayers, n, 7])
+    structuret = torch.reshape(structuret, shape=[nlayers, n, 3])
 
     for i in range(n):
-        c.H(i)
+        c.h(i)
     for j in range(nlayers):
         for i in range(n):
             c.unitary(
                 i,
-                unitary=structureo[j, i, 0] * tc.gates.i().tensor
-                + structureo[j, i, 1] * tc.gates.x().tensor
-                + structureo[j, i, 2] * tc.gates.y().tensor
-                + structureo[j, i, 3] * tc.gates.z().tensor
-                + structureo[j, i, 4] * tc.gates.h().tensor
-                + structureo[j, i, 5] * tc.gates.s().tensor
-                + structureo[j, i, 6] * tc.gates.sd().tensor,
+                unitary=structureo[j, i, 0] * tq.gates.i().tensor
+                + structureo[j, i, 1] * tq.gates.x().tensor
+                + structureo[j, i, 2] * tq.gates.y().tensor
+                + structureo[j, i, 3] * tq.gates.z().tensor
+                + structureo[j, i, 4] * tq.gates.h().tensor
+                + structureo[j, i, 5] * tq.gates.s().tensor
+                + structureo[j, i, 6] * tq.gates.sd().tensor,
             )
         for i in range(n - 1):
             c.unitary(
                 i,
                 i + 1,
-                unitary=structuret[j, i, 0] * tc.gates.ii().tensor
-                + structuret[j, i, 1] * tc.gates.cnot().tensor
-                + structuret[j, i, 2] * tc.gates.cz().tensor,
+                unitary=structuret[j, i, 0] * tq.gates.ii().tensor
+                + structuret[j, i, 1] * tq.gates.cnot().tensor
+                + structuret[j, i, 2] * tq.gates.cz().tensor,
             )
     # loss = K.real(
     #     sum(
@@ -60,7 +60,7 @@ def ansatz(structureo, structuret, preprocess="direct"):
     #     )
     # )
     s = c.state()
-    loss = -K.real(tc.quantum.entropy(tc.quantum.reduced_density_matrix(s, cut=n // 2)))
+    loss = -K.real(tq.quantum.entropy(tq.quantum.reduced_density_matrix(s, cut=n // 2)))
     return loss
 
 
@@ -77,6 +77,7 @@ def sampling_from_structure(structures, batch=1):
     return r.transpose()
 
 
+# warning pytorch might be unable to do this exactly
 @K.jit
 def best_from_structure(structures):
     return K.argmax(structures, axis=-1)
@@ -89,31 +90,30 @@ def nmf_gradient(structures, oh):
     choice = K.argmax(oh, axis=-1)
     prob = K.softmax(K.real(structures), axis=-1)
     indices = K.transpose(
-        K.stack([K.cast(tf.range(structures.shape[0]), "int64"), choice])
+        K.stack([K.cast(torch.arange(structures.shape[0]), "int64"), choice])
     )
-    prob = tf.gather_nd(prob, indices)
+    prob = torch.gather(prob, 0, indices.unsqueeze(0)).squeeze(0)
     prob = K.reshape(prob, [-1, 1])
     prob = K.tile(prob, [1, structures.shape[-1]])
 
-    return K.real(
-        tf.tensor_scatter_nd_add(
-            tf.cast(-prob, dtype=ctype),
-            indices,
-            tf.ones([structures.shape[0]], dtype=ctype),
-        )
-    )
+    # warning pytorch might be unable to do this exactly
+    result = torch.zeros_like(structures, dtype=ctype)
+    result.scatter_add_(0, indices, torch.ones([structures.shape[0]], dtype=ctype))
+    return K.real(result - prob)
 
 
+# warning pytorch might be unable to do this exactly
 nmf_gradient_vmap = K.jit(K.vmap(nmf_gradient, vectorized_argnums=1))
+# warning pytorch might be unable to do this exactly
 vf = K.jit(K.vmap(ansatz, vectorized_argnums=(0, 1)), static_argnums=2)
 
 
 def main(stddev=0.05, lr=None, epochs=2000, debug_step=50, batch=256, verbose=False):
     so = K.implicit_randn([nlayers * n, 7], stddev=stddev)
     st = K.implicit_randn([nlayers * n, 3], stddev=stddev)
     if lr is None:
-        lr = tf.keras.optimizers.schedules.ExponentialDecay(0.06, 1000, 0.5)
-    structure_opt = tc.backend.optimizer(tf.keras.optimizers.Adam(lr))
+        lr = 0.06  # Simplified learning rate
+    structure_opt = torch.optim.Adam([so, st], lr=lr)
 
     avcost = 0
     avcost2 = 0
@@ -135,23 +135,28 @@ def main(stddev=0.05, lr=None, epochs=2000, debug_step=50, batch=256, verbose=Fa
 
         # go = [(vs[i] - avcost2) * go[i] for i in range(batch)]
         # gt = [(vs[i] - avcost2) * gt[i] for i in range(batch)]
-        # go = tf.math.reduce_mean(go, axis=0)
-        # gt = tf.math.reduce_mean(gt, axis=0)
+        # go = torch.math.reduce_mean(go, axis=0)
+        # gt = torch.math.reduce_mean(gt, axis=0)
         avcost2 = avcost
 
-        [so, st] = structure_opt.update([go, gt], [so, st])
+        # Update parameters using PyTorch optimizer
+        structure_opt.zero_grad()
+        so.grad = go
+        st.grad = gt
+        structure_opt.step()
+        
         # so -= K.reshape(K.mean(so, axis=-1), [-1, 1])
         # st -= K.reshape(K.mean(st, axis=-1), [-1, 1])
         if epoch % debug_step == 0 or epoch == epochs - 1:
             print("----------epoch %s-----------" % epoch)
             print(
                 "batched average loss: ",
-                np.mean(vs),
+                np.mean(vs.detach().cpu().numpy()),
                 "minimum candidate loss: ",
-                np.min(vs),
+                np.min(vs.detach().cpu().numpy()),
             )
-            minp1 = tf.math.reduce_min(tf.math.reduce_max(tf.math.softmax(st), axis=-1))
-            minp2 = tf.math.reduce_min(tf.math.reduce_max(tf.math.softmax(so), axis=-1))
+            minp1 = torch.min(torch.max(torch.softmax(st, dim=-1), dim=-1)[0])
+            minp2 = torch.min(torch.max(torch.softmax(so, dim=-1), dim=-1)[0])
             if minp1 > 0.3 and minp2 > 0.6:
                 print("probability converged")
                 break
@@ -161,9 +166,9 @@ def main(stddev=0.05, lr=None, epochs=2000, debug_step=50, batch=256, verbose=Fa
                 print(st)
                 print(
                     "strcuture parameter: \n",
-                    so.numpy(),
+                    so.detach().cpu().numpy(),
                     "\n",
-                    st.numpy(),
+                    st.detach().cpu().numpy(),
                 )
 
             cand_preseto = best_from_structure(so)

examples/circuit_compiler.py

@@ -11,7 +11,7 @@
 import numpy as np
 
 sys.path.insert(0, "../")
-import tensorcircuit as tc
+import tyxonq as tq
 
 try:
     import kahypar
@@ -28,16 +28,16 @@
     "ordered indices corresponding to array axes.",
 )
 
-K = tc.set_backend("jax")
+K = tq.set_backend("pytorch")
 
 
 def generate_circuit(param, g, n, nlayers):
     # construct the circuit ansatz
-    c = tc.Circuit(n)
+    c = tq.Circuit(n)
     for i in range(n):
-        c.H(i)
+        c.h(i)
     for j in range(nlayers):
-        c = tc.templates.blocks.QAOA_block(c, g, param[j, 0], param[j, 1])
+        c = tq.templates.blocks.QAOA_block(c, g, param[j, 0], param[j, 1])
     return c
 
 
@@ -55,6 +55,7 @@ def loss_f(params, n, nlayers):
     params = K.implicit_randn(shape=[nlayers, 2])
 
     # run only once to trigger the compilation
+    # warning pytorch might be unable to do this exactly
     K.jit(
         loss_f,
         static_argnums=(1, 2),
@@ -151,7 +152,7 @@ def get_optimizer(method, optlib, post_processing, minimize):
             f"graph: {graph}, method: {method}, optlib: {optlib}, "
             f"post_processing: {post_processing}, minimize: {minimize}"
         )
-        tc.set_contractor(
+        tq.set_contractor(
             "custom",
             optimizer=get_optimizer(method, optlib, post_processing, minimize),
             contraction_info=True,

examples/clifford_optimization.py

@@ -6,23 +6,23 @@
 
 sys.path.insert(0, "../")
 import numpy as np
-import tensorflow as tf
+import torch
 import cirq
 
-import tensorcircuit as tc
-from tensorcircuit.applications.vags import double_qubits_initial, GHZ_vag, GHZ_vag_tfq
-from tensorcircuit.applications.dqas import (
+import tyxonq as tq
+from tyxonq.applications.vags import double_qubits_initial, GHZ_vag, GHZ_vag_tfq
+from tyxonq.applications.dqas import (
     set_op_pool,
     get_preset,
     DQAS_search,
 )
 
-tc.set_backend("tensorflow")
+tq.set_backend("pytorch")
 
 
 def main_tn():
     """
-    DQAS with the tensorcircuit engine backend by TensorNetwork
+    DQAS with the tyxonq engine backend by TensorNetwork
     state preparation example
 
     :return:
@@ -32,13 +32,13 @@ def main_tn():
         ("ry", 0),
         ("ry", 1),
         ("ry", 2),
-        ("CNOT", 0, 1),
-        ("CNOT", 1, 0),
-        ("CNOT", 0, 2),
-        ("CNOT", 2, 0),
-        ("H", 0),
-        ("H", 1),
-        ("H", 2),
+        ("cnot", 0, 1),
+        ("cnot", 1, 0),
+        ("cnot", 0, 2),
+        ("cnot", 2, 0),
+        ("h", 0),
+        ("h", 1),
+        ("h", 2),
     ]
     set_op_pool(ghz_pool)
     c = len(ghz_pool)
@@ -51,15 +51,15 @@ def main_tn():
         verbose=True,
         parallel_num=0,
         nnp_initial_value=np.zeros([p, c]),
-        structure_opt=tf.keras.optimizers.Adam(learning_rate=0.15),
+        structure_opt=torch.optim.Adam([torch.nn.Parameter(torch.zeros([p, c]))], lr=0.15),
     )
-    preset = get_preset(stp).numpy()
+    preset = get_preset(stp).detach().cpu().numpy()
     GHZ_vag(None, nnp, preset, verbose=True)
 
 
 def main_tfq():
     """
-    DQAS with the tensorflow quantum engine.
+    DQAS with the pytorch quantum engine.
     Unitary learning example.
 
     :return:
@@ -84,9 +84,9 @@ def main_tfq():
         verbose=False,
         parallel_num=0,
         nnp_initial_value=np.zeros([p, c]),
-        structure_opt=tf.keras.optimizers.Adam(learning_rate=0.15),
+        structure_opt=torch.optim.Adam([torch.nn.Parameter(torch.zeros([p, c]))], lr=0.15),
     )
-    preset = get_preset(stp).numpy()
+    preset = get_preset(stp).detach().cpu().numpy()
     GHZ_vag_tfq(double_qubits_initial().send(None), nnp, preset, verbose=True)