further rename to vg

Author: refraction-ray

docs/source/tutorials/mnist_qml.ipynb

@@ -82,11 +82,11 @@ def get_zz(params, n, nlayers, inputs=None):
 
 # optimization, suppose the energy we want to minimize is just z1z2 as above
 
-vag_func = K.jit(K.value_and_grad(get_zz), static_argnums=(1, 2))
+vg_func = K.jit(K.value_and_grad(get_zz), static_argnums=(1, 2))
 opt = K.optimizer(tf.keras.optimizers.Adam(1e-2))
 
 for i in range(200):  # gradient descent
-    energy, grads = vag_func(params, 10, 5)
+    energy, grads = vg_func(params, 10, 5)
     params = opt.update(grads, params)
     if i % 20 == 0:
         print(energy)  # see energy optimization dynamics

docs/source/tutorials/mnist_qml_cn.ipynb

@@ -106,13 +106,13 @@ def vqe_forward(param):
 
 def profile(tries=3):
     time0 = time.time()
-    tc_vag = tc.backend.jit(tc.backend.value_and_grad(vqe_forward))
+    tc_vg = tc.backend.jit(tc.backend.value_and_grad(vqe_forward))
     param = tc.backend.cast(tc.backend.ones([nlayers, 2 * nwires]), "complex64")
-    print(tc_vag(param))
+    print(tc_vg(param))
 
     time1 = time.time()
     for _ in range(tries):
-        print(tc_vag(param)[0])
+        print(tc_vg(param)[0])
 
     time2 = time.time()
     print(time1 - time0, (time2 - time1) / tries)

examples/chaotic_behavior.py

@@ -67,7 +67,7 @@ def QAOAansatz(gamma, beta, g=example_graph):
 
 # 3. get compiled function for QAOA ansatz and its gradient
 
-QAOA_vag = K.jit(K.value_and_grad(QAOAansatz, argnums=(0, 1)), static_argnums=2)
+QAOA_vg = K.jit(K.value_and_grad(QAOAansatz, argnums=(0, 1)), static_argnums=2)
 
 
 # 4. optimization loop
@@ -77,6 +77,6 @@ def QAOAansatz(gamma, beta, g=example_graph):
 opt = K.optimizer(tf.keras.optimizers.Adam(1e-2))
 
 for i in range(100):
-    loss, grads = QAOA_vag(gamma, beta, example_graph)
+    loss, grads = QAOA_vg(gamma, beta, example_graph)
     print(K.numpy(loss))
     gamma, beta = opt.update(grads, [gamma, beta])  # gradient descent

examples/checkpoint_memsave.py

@@ -96,7 +96,7 @@ def vqe_forward(param, structures):
 time0 = time.time()
 
 batch = 50
-tc_vag = tf.function(
+tc_vg = tf.function(
     tc.backend.vectorized_value_and_grad(vqe_forward, argnums=0, vectorized_argnums=1),
     input_signature=[
         tf.TensorSpec([2 * nlayers, nwires], tf.float32),
@@ -105,23 +105,23 @@ def vqe_forward(param, structures):
 )
 param = tf.Variable(tf.random.normal(stddev=0.1, shape=[2 * nlayers, nwires]))
 
-print(tc_vag(param, structures[:batch]))
+print(tc_vg(param, structures[:batch]))
 
 time1 = time.time()
 print("staging time: ", time1 - time0)
 
 try:
-    keras.save_func(tc_vag, "./funcs/%s_%s_10_tfim" % (nwires, nlayers))
+    keras.save_func(tc_vg, "./funcs/%s_%s_10_tfim" % (nwires, nlayers))
 except ValueError as e:
     print(e)  # keras.save_func now has issues to be resolved
 
 
 def train_step(param):
-    vag_list = []
+    vg_list = []
     for i in range(2):
-        vag_list.append(tc_vag(param, structures[i * nwires : i * nwires + nwires]))
-    loss = tc.backend.sum(vag_list[0][0] - vag_list[1][0])
-    gr = vag_list[0][1] - vag_list[1][1]
+        vg_list.append(tc_vg(param, structures[i * nwires : i * nwires + nwires]))
+    loss = tc.backend.sum(vg_list[0][0] - vg_list[1][0])
+    gr = vg_list[0][1] - vg_list[1][1]
     return loss, gr
 
 

examples/simple_qaoa.py

@@ -94,15 +94,15 @@ def vqe_forward(param):
 
     time0 = time.time()
     if refresh:
-        tc_vag = tf.function(
+        tc_vg = tf.function(
             tc.backend.value_and_grad(vqe_forward),
             input_signature=[tf.TensorSpec([4 * nlayers, nwires], tf.float32)],
         )
-        tc.keras.save_func(tc_vag, "./funcs/%s_%s_tfim_mpo" % (nwires, nlayers))
+        tc.keras.save_func(tc_vg, "./funcs/%s_%s_tfim_mpo" % (nwires, nlayers))
         time1 = time.time()
         print("staging time: ", time1 - time0)
 
-    tc_vag_loaded = tc.keras.load_func("./funcs/%s_%s_tfim_mpo" % (nwires, nlayers))
+    tc_vg_loaded = tc.keras.load_func("./funcs/%s_%s_tfim_mpo" % (nwires, nlayers))
 
     lr1 = 0.008
     lr2 = 0.06
@@ -121,7 +121,7 @@ def vqe_forward(param):
     param = tc.backend.implicit_randn(stddev=0.1, shape=[4 * nlayers, nwires])
 
     for j in range(steps):
-        loss, gr = tc_vag_loaded(param)
+        loss, gr = tc_vg_loaded(param)
         if j < switch:
             param = opt.update(gr, param)
         else:

examples/vqe_extra.py

@@ -219,25 +219,25 @@ def f(param):
     :rtype: Callable[..., Any]
     """
     if gradient:
-        vag = backend.value_and_grad(fun, argnums=0)
+        vg = backend.value_and_grad(fun, argnums=0)
         if jit:
-            vag = backend.jit(vag)
+            vg = backend.jit(vg)
 
-        def scipy_vag(*args: Any, **kws: Any) -> Tuple[Tensor, Tensor]:
+        def scipy_vg(*args: Any, **kws: Any) -> Tuple[Tensor, Tensor]:
             scipy_args = numpy_args_to_backend(args, dtype=dtypestr)
             if shape is not None:
                 scipy_args = list(scipy_args)
                 scipy_args[0] = backend.reshape(scipy_args[0], shape)
                 scipy_args = tuple(scipy_args)
-            vs, gs = vag(*scipy_args, **kws)
+            vs, gs = vg(*scipy_args, **kws)
             scipy_vs = general_args_to_numpy(vs)
             gs = backend.reshape(gs, [-1])
             scipy_gs = general_args_to_numpy(gs)
             scipy_vs = scipy_vs.astype(np.float64)
             scipy_gs = scipy_gs.astype(np.float64)
             return scipy_vs, scipy_gs
 
-        return scipy_vag
+        return scipy_vg
     # no gradient
     if jit:
         fun = backend.jit(fun)

examples/vqe_extra_mpo.py

@@ -155,8 +155,8 @@ def forward(theta):
         return tc.backend.real(tc.backend.sum(c.densitymatrix()))
 
     theta = tc.num_to_tensor(0.2)
-    vag = tc.backend.value_and_grad(forward)
-    _, g1 = vag(theta)
+    vg = tc.backend.value_and_grad(forward)
+    _, g1 = vg(theta)
     assert np.allclose(tc.backend.numpy(g1), 0.199, atol=1e-2)
 
     def forward2(theta):
@@ -172,8 +172,8 @@ def forward2(theta):
         return tc.backend.real(tc.backend.sum(c.densitymatrix()))
 
     theta = tc.num_to_tensor(0.2)
-    vag2 = tc.backend.value_and_grad(forward2)
-    _, g2 = vag2(theta)
+    vg2 = tc.backend.value_and_grad(forward2)
+    _, g2 = vg2(theta)
     assert np.allclose(tc.backend.numpy(g2), 0.199, atol=1e-2)
 
 
@@ -195,8 +195,8 @@ def forward(p):
         )
 
     theta = tc.num_to_tensor(0.1)
-    vag = tc.backend.value_and_grad(forward)
-    v, g = vag(theta)
+    vg = tc.backend.value_and_grad(forward)
+    v, g = vg(theta)
     assert np.allclose(v, -0.6, atol=1e-2)
     assert np.allclose(g, 4, atol=1e-2)