examples of vqnhe

refraction-ray · refraction-ray · commit dde5df0f3476 · 2021-06-13T12:28:54.000+08:00
diff --git a/examples/adiabatic_vqnhe.py b/examples/adiabatic_vqnhe.py
@@ -0,0 +1,138 @@
+import cirq
+import numpy as np
+import scipy
+import sympy as sy
+import networkx as nx
+import tensorflow_quantum as tfq
+import tensorflow as tf
+from functools import partial
+from functools import lru_cache
+import tensornetwork as tn
+from itertools import product
+import json
+import sys
+
+sys.path.insert(0, "../")
+import tensorcircuit as tc
+from tensorcircuit.applications.layers import *
+from tensorcircuit.applications.van import *
+from tensorcircuit.applications.graphdata import *
+from tensorcircuit.applications.dqas import *
+from tensorcircuit.applications.vags import *
+from tensorcircuit.applications.vqes import *
+
+tc.set_backend("tensorflow")
+tc.set_dtype("complex128")
+
+
+def initial_param(t, last=None, lastlast=None):
+    if ((t % 3 == 1) and last) or ((t % 3 == 2) and lastlast):
+        if t % 3 == 2:
+            last = lastlast
+        qw = last[-1]
+        qw = tf.Variable(
+            qw.numpy() + np.random.uniform(low=-0.1, high=0.1, size=qw.numpy().shape)
+        )
+        cw = last[-2]
+        for i, t in enumerate(cw):
+            cw[i] = t + np.random.uniform(low=-0.1, high=0.1, size=t.shape)
+        return {"c": cw, "q": qw}
+
+    return {}
+
+
+def adiabatic_range(hm, history):
+    if len(history) > 0:
+        last = sorted(
+            [
+                (
+                    r["energy"],
+                    r["quantum_energy"],
+                    r["model_weights"],
+                    r["circuit_weights"],
+                )
+                for r in history[-1]
+            ],
+            key=lambda s: s[0],
+        )[0]
+    else:
+        last = None
+    if len(history) > 1:
+        lastlast = sorted(
+            [
+                (
+                    r["energy"],
+                    r["quantum_energy"],
+                    r["model_weights"],
+                    r["circuit_weights"],
+                )
+                for r in history[-1]
+            ],
+            key=lambda s: s[0],
+        )[0]
+    else:
+        lastlast = None
+    print("begin caculation on new")
+    vqeinstance = VQNHE(
+        4,
+        hm,
+        {"max_value": 5, "init_value": 1.0, "min_value": 0.1},
+        {"filled_qubit": [0]},
+    )
+
+    def learn_q():
+        return JointSchedule(180, 0.009, 800, 0.001, 800)
+
+    def learn_c():
+        return JointSchedule(160, 0.002, 10000, 0.2, 1500)
+
+    rs = vqeinstance.multi_training(
+        tries=2,
+        maxiter=150,  # 10000
+        threshold=0.2 * 1e-8,
+        learn_q=learn_q,  # JointSchedule(2800, 0.009, 800, 0.002, 100),
+        learn_c=learn_c,
+        initialization_func=partial(initial_param, last=last, lastlast=lastlast),
+    )
+    print(
+        sorted(
+            [(r["energy"], r["quantum_energy"], r["iterations"]) for r in rs],
+            key=lambda s: s[0],
+        )
+    )
+    return rs
+
+
+if __name__ == "__main__":
+    history = []
+    lihh = np.load("data_file")
+    for i, h in enumerate(lihh[3:6]):
+        history.append(adiabatic_range(h.tolist(), history))
+    print(history)
+    # vqeinstance = VQNHE(
+    #     4,
+    #     lihh,
+    #     {"max_value": 5, "init_value": 1.0, "min_value": 0.1},
+    #     {"filled_qubit": [0]},
+    # )
+
+    # def learn_q():
+    #     return JointSchedule(180, 0.009, 800, 0.001, 800)
+
+    # def learn_c():
+    #     return JointSchedule(160, 0.002, 10000, 0.2, 1500)
+
+    # rs = vqeinstance.multi_training(
+    #     tries=10,
+    #     maxiter=15000,
+    #     threshold=0.2 * 1e-8,
+    #     learn_q=learn_q,  # JointSchedule(2800, 0.009, 800, 0.002, 100),
+    #     learn_c=learn_c,
+    # )
+    # print(rs)
+    # print(
+    #     sorted(
+    #         [(r["energy"], r["quantum_energy"], r["iterations"]) for r in rs],
+    #         key=lambda s: s[0],
+    #     )
+    # )
diff --git a/examples/vqnhe_h6.py b/examples/vqnhe_h6.py
@@ -56,5 +56,4 @@ def learn_c():
     debug=200,
     checkpoints=[(900, -3.18), (2600, -3.19), (4500, -3.2)],
 )
-# -3.1659 # -3.1664 # complex 3.18 # exact:-3.237746566460727 # RBM -3.2139 (-3.2097)
 print(rs)
diff --git a/tensorcircuit/applications/README.md b/tensorcircuit/applications/README.md
@@ -4,3 +4,7 @@ In `applications`, framework and relevant applications of DQAS are implemented.
 
 The entrypoint of DQAS framework is `DQAS_search` and `DQAS_search_pmb` for advanced probabilistic model based DQAS.
 One can also check [examples](/examples) for integrated example demos.
+
+## Variational Quantum-Neural Hybrid Eigensolver
+
+The main library functions and utilities are in `vqes.py`. Also see [examples](/examples) including `vqnhe_h6.py` and `adiabatic_vqnhe.py`.
diff --git a/tensorcircuit/applications/vqes.py b/tensorcircuit/applications/vqes.py
@@ -171,12 +171,16 @@ def __init__(
         self.model = self.create_model(**model_params)
         self.model_params = model_params
         if not circuit_params:
-            circuit_params = {"epochs": 2}
+            circuit_params = {"epochs": 2, "stddev": 0.1}
         self.epochs = circuit_params.get("epochs", 2)
+        self.circuit_stddev = circuit_params.get("stddev", 0.1)
 
         self.circuit_variable = tf.Variable(
             tf.random.normal(
-                mean=0.0, stddev=0.2, shape=[2 * self.epochs, self.n], dtype=tf.float64
+                mean=0.0,
+                stddev=self.circuit_stddev,
+                shape=[2 * self.epochs, self.n],
+                dtype=tf.float64,
             )
         )
         self.circuit = self.create_circuit(**circuit_params)
@@ -201,6 +205,8 @@ def create_model(self, choose: str = "real", **kws: Any) -> Model:
             return self.create_real_model(**kws)
         if choose == "complex":
             return self.create_complex_model(**kws)
+        if choose == "real-rbm":
+            return self.create_real_rbm_model(**kws)
         if choose == "complex-rbm":
             return self.create_complex_rbm_model(**kws)
 
@@ -273,6 +279,19 @@ def create_complex_model(
         model = tf.keras.Model(inputs=inputs, outputs=outputs)
         return model
 
+    def create_real_rbm_model(
+        self, stddev: float = 0.1, width: int = 2, **kws: Any
+    ) -> Model:
+        inputs = tf.keras.layers.Input(shape=[self.n])
+        x = tf.keras.layers.Dense(width * self.n, activation=None)(inputs)
+        x = tf.math.log(2 * tf.math.cosh(x))
+        x = tf.reduce_sum(x, axis=-1)
+        x = tf.reshape(x, [-1, 1])
+        y = tf.keras.layers.Dense(1, activation=None)(inputs)
+        outputs = y + x
+        model = tf.keras.Model(inputs=inputs, outputs=outputs)
+        return model
+
     def create_complex_rbm_model(
         self, stddev: float = 0.1, width: int = 2, **kws: Any
     ) -> Model:
@@ -286,8 +305,23 @@ def create_complex_rbm_model(
         model = tf.keras.Model(inputs=inputs, outputs=outputs)
         return model
 
-    def create_circuit(
-        self, epochs: int = 2, filled_qubit: List[int] = [0]
+    def create_circuit(self, choose="hea", **kws: Any) -> Callable[[Tensor], Tensor]:
+        if choose == "hea":
+            return self.create_hea_circuit(**kws)
+        if choose == "hn":
+            return self.create_hn_circuit(**kws)
+
+    def create_hn_circuit(self, **kws: Any) -> Callable[[Tensor], Tensor]:
+        def circuit(a: Tensor) -> Tensor:
+            c = Circuit(self.n)
+            for i in range(self.n):
+                c.H(i)  # type: ignore
+            return c
+
+        return circuit
+
+    def create_hea_circuit(
+        self, epochs: int = 2, filled_qubit: List[int] = [0], **kws: Any
     ) -> Callable[[Tensor], Tensor]:
         def circuit(a: Tensor) -> Tensor:
             c = Circuit(self.n)
@@ -321,6 +355,12 @@ def evaluation(self, cv: Tensor) -> Tuple[Tensor, Tensor, Tensor]:
             else:
                 loss = tf.math.real(vqe_energy_shortcut(c2, self.hop))
         grad = tape.gradient(loss, [cv, self.model.variables])
+        for i, gr in enumerate(grad):
+            if gr is None:
+                if i == 0:
+                    grad[i] = tf.zeros_like(cv)
+                else:
+                    grad[i] = tf.zeros_like(self.model.variables[i - 1])
         return loss, grad, nm
 
     @tf.function  # type: ignore
@@ -359,7 +399,7 @@ def training(
 
         optc = tf.keras.optimizers.Adam(learning_rate=learnc)
         optq = tf.keras.optimizers.Adam(learning_rate=learnq)
-
+        nm = tf.constant(1.0)
         for j in range(maxiter):
             if j < onlyq:
                 loss, grad = self.plain_evaluation(self.circuit_variable)
@@ -427,7 +467,7 @@ def multi_training(
                 self.circuit_variable = tf.Variable(
                     tf.random.normal(
                         mean=0.0,
-                        stddev=0.2,
+                        stddev=self.circuit_stddev,
                         shape=[2 * self.epochs, self.n],
                         dtype=tf.float64,
                     )

Original file line number	Diff line number	Diff line change
`@@ -56,5 +56,4 @@ def learn_c():`
`56`	`56`	`debug=200,`
`57`	`57`	`checkpoints=[(900, -3.18), (2600, -3.19), (4500, -3.2)],`
`58`	`58`	`)`
`59`		`-# -3.1659 # -3.1664 # complex 3.18 # exact:-3.237746566460727 # RBM -3.2139 (-3.2097)`
`60`	`59`	`print(rs)`