Remove unnecessary files

vutuanhai237 · Oct 21, 2023 · a499ef0 · a499ef0
1 parent 7e24978
commit a499ef0
Show file tree

Hide file tree

Showing 65 changed files with 354 additions and 625 deletions.
diff --git a/codes/AMEtests.py b/codes/AMEtests.py
@@ -3,7 +3,7 @@
 # import matplotlib.pyplot as plt
 # import sys
 # sys.path.insert(1, '../../')
-# import qtm.base, qtm.constant, qtm.ansatz, qtm.gradient, qtm.progress_bar
+# import , qtm.constant, qtm.ansatz, qtm.gradient
 # import types
 # import pickle 
 

diff --git a/codes/demos/AME_state.ipynb b/codes/demos/AME_state.ipynb
@@ -11,7 +11,7 @@
     "import matplotlib.pyplot as plt\n",
     "import sys\n",
     "sys.path.insert(1, '../../')\n",
-    "import qtm.base, qtm.constant, qtm.ansatz, qtm.gradient, qtm.qcompilation\n",
+    "import , qtm.constant, qtm.ansatz, qtm.gradient, qtm.qcompilation\n",
     "%load_ext autoreload\n",
     "%autoreload 2"
    ]

diff --git a/codes/demos/hessian_qng.ipynb b/codes/demos/hessian_qng.ipynb
@@ -2571,7 +2571,7 @@
     "        qc_reverse = qc_reverse.compose(vdagger.copy()).inverse()\n",
     "        qc = qc.compose(qc_reverse)\n",
     "        print(qc)\n",
-    "        return qtm.base.measure(qc, list(range(qc.num_qubits)))\n",
+    "        return .measure(qc, list(range(qc.num_qubits)))\n",
     "    G = [[0 for _ in range(length)] for _ in range(length)]\n",
     "    for i in range(0, length):\n",
     "        for j in range(0, length):\n",

diff --git a/codes/demos/qfim.ipynb b/codes/demos/qfim.ipynb
@@ -43,7 +43,7 @@
     "import numpy as np\n",
     "import sys\n",
     "sys.path.insert(1, '../../')\n",
-    "import qtm.base\n",
+    "import \n",
     "%load_ext autoreload\n",
     "%autoreload 2\n",
     "\n",
@@ -57,8 +57,8 @@
     "\n",
     "thetas = [np.pi/2, np.pi/2]\n",
     "qc = create_test_circuit()\n",
-    "grad_psi1 = qtm.base.grad_psi(qc, thetas, 1/2, np.pi)\n",
-    "grad_loss = qtm.base.grad_loss(qc, thetas)\n",
+    "grad_psi1 = .grad_psi(qc, thetas, 1/2, np.pi)\n",
+    "grad_loss = .grad_loss(qc, thetas)\n",
     "qc_copy = create_test_circuit()\n",
     "psi = qiskit.quantum_info.Statevector.from_instruction(qc_copy.bind_parameters(thetas)).data\n",
     "F = qtm.gradient.qfim(psi, grad_psi1)\n",
@@ -91,8 +91,8 @@
     "thetas = np.zeros((1,))\n",
     "\n",
     "qc = create_test_circuit2()\n",
-    "grad_psi1 = qtm.base.grad_psi(qc, thetas, 1/2, np.pi)\n",
-    "grad_loss = qtm.base.grad_loss(qc, thetas)\n",
+    "grad_psi1 = .grad_psi(qc, thetas, 1/2, np.pi)\n",
+    "grad_loss = .grad_loss(qc, thetas)\n",
     "qc_copy = create_test_circuit2()\n",
     "psi = qiskit.quantum_info.Statevector.from_instruction(qc_copy.bind_parameters(thetas)).data\n",
     "F = qtm.gradient.qfim(psi, grad_psi1)\n",
@@ -130,7 +130,7 @@
    "source": [
     "import qiskit\n",
     "import numpy as np\n",
-    "import qtm.base\n",
+    "import \n",
     "import qtm.constant\n",
     "import qtm.ansatz\n",
     "import qtm.gradient"

diff --git a/codes/demos/state_preparation_GHZ.ipynb b/codes/demos/state_preparation_GHZ.ipynb
@@ -30,7 +30,7 @@
    "source": [
     "import qiskit, sys\n",
     "sys.path.insert(1, '../../')\n",
-    "import qtm.base, qtm.constant, qtm.ansatz, qtm.qcompilation, qtm.state"
+    "import , qtm.constant, qtm.ansatz, qtm.qcompilation, qtm.state"
    ]
   },
   {

diff --git a/codes/demos/tomography_1qubit.ipynb b/codes/demos/tomography_1qubit.ipynb
@@ -80,7 +80,7 @@
     "sys.path.insert(1, '../../')\n",
     "import qiskit, kaleidoscope, sys\n",
     "import numpy as np, matplotlib.pyplot as plt\n",
-    "import qtm.base, qtm.qcompilation\n"
+    "import , qtm.qcompilation\n"
    ]
   },
   {

diff --git a/codes/demos/tomography_nqubit.ipynb b/codes/demos/tomography_nqubit.ipynb
@@ -28,7 +28,7 @@
    "source": [
     "import qiskit, sys\n",
     "sys.path.insert(1, '../../')\n",
-    "import qtm.base, qtm.constant, qtm.ansatz, qtm.qcompilation, qtm.state"
+    "import , qtm.constant, qtm.ansatz, qtm.qcompilation, qtm.state"
    ]
   },
   {

diff --git a/codes/multi_process.ipynb b/codes/multi_process.ipynb
diff --git a/codes/plot/plot_barren_plateaus.ipynb b/codes/plot/plot_barren_plateaus.ipynb
@@ -19,7 +19,7 @@
    "source": [
     "import qiskit\n",
     "import numpy as np\n",
-    "import qtm.base, qtm.constant, qtm.ansatz, qtm.gradient\n",
+    "import , qtm.constant, qtm.ansatz, qtm.gradient\n",
     "%load_ext autoreload\n",
     "%autoreload 2"
    ]
@@ -52,7 +52,7 @@
     "        #     print(i)\n",
     "        thetas = np.random.uniform(low= 0, high= 2 * np.pi, size=num_layers*(2*num_qubits - 2))\n",
     "        G = qtm.gradient.qng(qc.copy(), thetas, qtm.ansatz.create_star2graph_state, num_layers)\n",
-    "        grad_loss = qtm.base.grad_loss(\n",
+    "        grad_loss = .grad_loss(\n",
     "            qc, \n",
     "            qtm.ansatz.create_GHZchecker_star2graph,\n",
     "            thetas, num_layers = num_layers, theta = theta)\n",
@@ -108,7 +108,7 @@
     "        #     print(i)\n",
     "        thetas = np.random.uniform(low= 0, high= 2 * np.pi, size=num_layers*(2*num_qubits))\n",
     "        G = qtm.gradient.qng(qc.copy(), thetas, qtm.ansatz.create_polygongraph_state, num_layers)\n",
-    "        grad_loss = qtm.base.grad_loss(\n",
+    "        grad_loss = .grad_loss(\n",
     "            qc, \n",
     "            qtm.ansatz.create_GHZchecker_polygongraph,\n",
     "            thetas, num_layers = num_layers, theta = theta)\n",

diff --git a/codes/plot/plot_bloch_sphere/u3initstate_zbasis.ipynb b/codes/plot/plot_bloch_sphere/u3initstate_zbasis.ipynb
@@ -17,7 +17,7 @@
     "import numpy as np, matplotlib.pyplot as plt\n",
     "import sys\n",
     "sys.path.insert(1, '../../')\n",
-    "import qtm.base, qtm.constant, qtm.gradient"
+    "import , qtm.constant, qtm.gradient"
    ]
   },
   {
@@ -75,10 +75,10 @@
     "qc = qiskit.QuantumCircuit(1, 1)\n",
     "qc.u3(theta, phi, lambdaz, 0)\n",
     "\n",
-    "thetass_sgd, loss_values_sgd = qtm.base.fit(\n",
+    "thetass_sgd, loss_values_sgd = .fit(\n",
     "    qc, num_steps = 100, thetas = thetas, \n",
     "    create_circuit_func = qtm.ansatz.u_onequbit, \n",
-    "    grad_func = qtm.base.grad_loss,\n",
+    "    grad_func = .grad_loss,\n",
     "    loss_func = qtm.loss.loss_fubini_study,\n",
     "    optimizer = qtm.optimizer.sgd,\n",
     "    is_return_all_thetas = True,\n",
@@ -106,10 +106,10 @@
     "qc = qiskit.QuantumCircuit(1, 1)\n",
     "qc.u3(theta, phi, lambdaz, 0)\n",
     "\n",
-    "thetas_adam, loss_values_adam = qtm.base.fit(\n",
+    "thetas_adam, loss_values_adam = .fit(\n",
     "    qc, num_steps = 100, thetas = thetas, \n",
     "    create_circuit_func = qtm.ansatz.u_onequbit, \n",
-    "    grad_func = qtm.base.grad_loss,\n",
+    "    grad_func = .grad_loss,\n",
     "    loss_func = qtm.loss.loss_fubini_study,\n",
     "    optimizer = qtm.optimizer.adam,\n",
     "    verbose = 1,\n",
@@ -132,15 +132,15 @@
     "\n",
     "for i in range(0, 100):\n",
     "    G = qtm.gradient.calculate_u3z_state(qc.copy(), thetas)\n",
-    "    grad_loss = qtm.base.grad_loss(\n",
+    "    grad_loss = .grad_loss(\n",
     "        qc, \n",
     "        qtm.ansatz.u_onequbit,\n",
     "        thetas, wire = 0)\n",
     "    thetas = np.real(thetas - qtm.constant.learning_rate *\n",
     "                        (np.linalg.pinv(G) @ grad_loss)) \n",
     "    thetas_qng.append(thetas.copy())\n",
     "    qc_copy = qtm.ansatz.u_onequbit(qc.copy(), thetas, wire = 0)  \n",
-    "    loss = qtm.loss.loss_fubini_study(qtm.base.measure(qc_copy, list(range(qc_copy.num_qubits))))\n",
+    "    loss = qtm.loss.loss_fubini_study(.measure(qc_copy, list(range(qc_copy.num_qubits))))\n",
     "    loss_values_qng.append(loss)"
    ]
   },
@@ -157,7 +157,7 @@
     "\n",
     "for i in range(0, 100):\n",
     "    G = qtm.gradient.calculate_u3z_state(qc.copy(), thetas)\n",
-    "    grad_loss = qtm.base.grad_loss(\n",
+    "    grad_loss = .grad_loss(\n",
     "        qc, \n",
     "        qtm.ansatz.u_onequbit,\n",
     "        thetas, wire = 0)\n",
@@ -166,7 +166,7 @@
     "        m, v = list(np.zeros(thetas.shape[0])), list(np.zeros(thetas.shape[0]))\n",
     "    thetas = qtm.optimizer.adam(thetas, m, v, i, grad1)  \n",
     "    qc_copy = qtm.ansatz.u_onequbit(qc.copy(), thetas, wire = 0)  \n",
-    "    loss = qtm.loss.loss_fubini_study(qtm.base.measure(qc_copy, list(range(qc_copy.num_qubits))))\n",
+    "    loss = qtm.loss.loss_fubini_study(.measure(qc_copy, list(range(qc_copy.num_qubits))))\n",
     "    loss_values_qng_adam.append(loss)"
    ]
   },
@@ -258,7 +258,7 @@
     "psi_hat_sgd = []\n",
     "for thetas in thetas_qng:\n",
     "    \n",
-    "    temp = qiskit.quantum_info.Statevector(qtm.base.get_u_hat(\n",
+    "    temp = qiskit.quantum_info.Statevector(.get_u_hat(\n",
     "        thetas = thetas, \n",
     "        create_circuit_func = qtm.ansatz.u_onequbit, \n",
     "        num_qubits = qc.num_qubits, \n",
@@ -268,7 +268,7 @@
     "\n",
     "for thetas in thetass_sgd:\n",
     "    \n",
-    "    temp = qiskit.quantum_info.Statevector(qtm.base.get_u_hat(\n",
+    "    temp = qiskit.quantum_info.Statevector(.get_u_hat(\n",
     "        thetas = thetas, \n",
     "        create_circuit_func = qtm.ansatz.u_onequbit, \n",
     "        num_qubits = qc.num_qubits, \n",

diff --git a/codes/plot/plot_compare_tomography_state.ipynb b/codes/plot/plot_compare_tomography_state.ipynb
@@ -9,7 +9,7 @@
     "import qtm.gradient\n",
     "import qtm.ansatz\n",
     "import qtm.constant\n",
-    "import qtm.base\n",
+    "import \n",
     "import qiskit\n",
     "import numpy as np\n",
     "import matplotlib.pyplot as plt\n",
@@ -45,15 +45,15 @@
     "thetass_ghz = []\n",
     "for i in range(0, 100):\n",
     "    G = qtm.gradient.calculate_linear_state(qc.copy(), thetas, num_layers)\n",
-    "    grad_loss = qtm.base.grad_loss(\n",
+    "    grad_loss = .grad_loss(\n",
     "        qc,\n",
     "        qtm.ansatz.create_GHZchecker_linear,\n",
     "        thetas, r=1/2, s=np.pi/2, num_layers=num_layers, theta=theta)\n",
     "    thetas = np.real(thetas - qtm.constant.learning_rate *\n",
     "                     (np.linalg.inv(G) @ grad_loss))\n",
     "    qc_copy = qtm.ansatz.create_GHZchecker_linear(\n",
     "        qc.copy(), thetas, num_layers, theta)\n",
-    "    loss = qtm.loss.loss_basis(qtm.base.measure(\n",
+    "    loss = qtm.loss.loss_basis(.measure(\n",
     "        qc_copy, list(range(qc_copy.num_qubits))))\n",
     "    loss_values_ghz.append(loss)\n",
     "    thetass_ghz.append(thetas)\n"
@@ -108,7 +108,7 @@
     "    psi_hat = qiskit.quantum_info.Statevector.from_instruction(qc1)\n",
     "    rho_psi_hat = qiskit.quantum_info.DensityMatrix(psi_hat)\n",
     "    # Calculate the metrics\n",
-    "    trace, fidelity = qtm.base.get_metrics(psi, psi_hat)\n",
+    "    trace, fidelity = .get_metrics(psi, psi_hat)\n",
     "    traces_ghz.append(trace)\n",
     "    fidelities_ghz.append(fidelity)\n"
    ]
@@ -128,14 +128,14 @@
     "thetass_w = []\n",
     "for i in range(0, 100):\n",
     "    G = qtm.gradient.calculate_linear_state(qc.copy(), thetas, num_layers)\n",
-    "    grad_loss = qtm.base.grad_loss(\n",
+    "    grad_loss = .grad_loss(\n",
     "        qc,\n",
     "        qtm.ansatz.create_Wchecker_linear,\n",
     "        thetas, r=1/2, s=np.pi/2, num_layers=num_layers)\n",
     "    thetas = np.real(thetas - qtm.constant.learning_rate *\n",
     "                     (np.linalg.inv(G) @ grad_loss))\n",
     "    qc_copy = qtm.ansatz.create_Wchecker_linear(qc.copy(), thetas, num_layers)\n",
-    "    loss = qtm.loss.loss_basis(qtm.base.measure(\n",
+    "    loss = qtm.loss.loss_basis(.measure(\n",
     "        qc_copy, list(range(qc_copy.num_qubits))))\n",
     "    loss_values_w.append(loss)\n",
     "    thetass_w.append(thetas)\n"
@@ -161,7 +161,7 @@
     "    psi_hat = qiskit.quantum_info.Statevector.from_instruction(qc1)\n",
     "    rho_psi_hat = qiskit.quantum_info.DensityMatrix(psi_hat)\n",
     "    # Calculate the metrics\n",
-    "    trace, fidelity = qtm.base.get_metrics(psi, psi_hat)\n",
+    "    trace, fidelity = .get_metrics(psi, psi_hat)\n",
     "    traces_w.append(trace)\n",
     "    fidelities_w.append(fidelity)\n"
    ]
@@ -173,19 +173,19 @@
    "outputs": [],
    "source": [
     "# Haar\n",
-    "import qtm.encoding\n",
+    "import qtm.state\n",
     "thetas = thetas_origin.copy()\n",
     "psi = 2*np.random.rand(2**num_qubits)-1\n",
     "psi = psi / np.linalg.norm(psi)\n",
-    "encoder = qtm.encoding.Encoding(psi, 'amplitude_encoding')\n",
+    "encoder = qtm.state.Encoding(psi, 'amplitude_encoding')\n",
     "\n",
     "loss_values_haar = []\n",
     "thetass_haar = []\n",
     "for i in range(0, 100):\n",
     "    qc = qiskit.QuantumCircuit(num_qubits, num_qubits)\n",
     "    G = qtm.gradient.calculate_linear_state(qc.copy(), thetas, num_layers)\n",
     "    qc = encoder.qcircuit\n",
-    "    grad_loss = qtm.base.grad_loss(\n",
+    "    grad_loss = .grad_loss(\n",
     "        qc,\n",
     "        qtm.ansatz.create_haarchecker_linear,\n",
     "        thetas, r=1/2, s=np.pi/2, num_layers=num_layers, encoder=encoder)\n",
@@ -194,7 +194,7 @@
     "                     (np.linalg.inv(G) @ grad_loss))\n",
     "    qc_copy = qtm.ansatz.create_haarchecker_linear(\n",
     "        qc.copy(), thetas, num_layers, encoder)\n",
-    "    loss = qtm.loss.loss_basis(qtm.base.measure(\n",
+    "    loss = qtm.loss.loss_basis(.measure(\n",
     "        qc_copy, list(range(qc_copy.num_qubits))))\n",
     "    loss_values_haar.append(loss)\n",
     "    thetass_haar.append(thetas)\n"
@@ -250,7 +250,7 @@
     "    psi_hat = qiskit.quantum_info.Statevector.from_instruction(qc1)\n",
     "    rho_psi_hat = qiskit.quantum_info.DensityMatrix(psi_hat)\n",
     "    # Calculate the metrics\n",
-    "    trace, fidelity = qtm.base.get_metrics(psi, psi_hat)\n",
+    "    trace, fidelity = .get_metrics(psi, psi_hat)\n",
     "    traces_haar.append(trace)\n",
     "    fidelities_haar.append(fidelity)\n"
    ]

diff --git a/codes/qcompilation_evo.ipynb b/codes/qcompilation_evo.ipynb
@@ -146,7 +146,7 @@
     "for num_qubits in [2, 3,4,5,6]:\n",
     "    psi = 2*np.random.rand(2**num_qubits)-1\n",
     "    psi = psi / np.linalg.norm(psi)\n",
-    "    encoder = qtm.encoding.Encoding(psi, 'amplitude_encoding')\n",
+    "    encoder = qtm.state.Encoding(psi, 'amplitude_encoding')\n",
     "    qc = encoder.qcircuit\n",
     "    (qc.draw('mpl'))\n",
     "    print(qc.depth())"

diff --git a/codes/qsp.ipynb b/codes/qsp.ipynb
diff --git a/codes/test.py b/codes/test.py
@@ -0,0 +1,42 @@
+import sys
+import multiprocessing
+sys.path.insert(1, '../')
+import qtm.qcompilation
+
+
+def f(num_qubits, num_layers):
+    optimizer = 'adam'
+    compiler = qtm.qcompilation.QuantumCompilation(
+        u = qtm.ansatz.g2gn(num_qubits, num_layers),
+        vdagger = qtm.state.create_ame_state(num_qubits).inverse(),
+        optimizer = optimizer,
+        loss_func = 'loss_fubini_study'
+    )
+    compiler.fit(num_steps = 100, verbose = 1)
+    qspobj = qtm.qsp.QuantumStatePreparation(
+        compiler.u, 
+        compiler.vdagger,
+        compiler.thetas,
+        ansatz = qtm.ansatz.g2gn
+    )
+    qspobj.save(state = 'ame', file_name='../experiments/qsp/')
+    return 
+if __name__ == "__main__":
+    # creating thread
+    list_num_qubits = [3]
+    list_num_layers = [1, 2]
+
+    processes = [[0 for _ in range(len(list_num_layers))] for _ in range(len(list_num_qubits))]
+    for i in range(len(list_num_qubits)):
+        for j in range(len(list_num_layers)):
+            processes[i][j] = (multiprocessing.Process(target = f, args=(list_num_qubits[i], list_num_layers[j])))
+
+    for i in range(len(list_num_qubits)):
+        for j in range(len(list_num_layers)):
+            processes[i][j].start()
+
+    for i in range(len(list_num_qubits)):
+        for j in range(len(list_num_layers)):
+            processes[i][j].join()
+
+    print("Done!")
diff --git a/experiments/qsp/ame_g2gn_3_2.qspobj b/experiments/qsp/ame_g2gn_3_2.qspobj
diff --git a/experiments/tomography/barren_plateues.ipynb b/experiments/tomography/barren_plateues.ipynb
@@ -10,7 +10,7 @@
     "import numpy as np\n",
     "import sys\n",
     "sys.path.insert(1, '../../')\n",
-    "import qtm.base, qtm.constant, qtm.gradient\n",
+    "import , qtm.constant, qtm.gradient\n",
     "%load_ext autoreload\n",
     "%autoreload 2"
    ]
@@ -49,7 +49,7 @@
     "        if i % 20 == 0:\n",
     "            print('W_chain: (' + str(num_layers) + ',' + str(num_qubits) + '): ' + str(i))\n",
     "        G = qtm.gradient.qng(qc.copy(), thetas, qtm.ansatz.create_Wchain_layerd_ansatz, num_layers = num_layers)\n",
-    "        grad_loss = qtm.base.grad_loss(\n",
+    "        grad_loss = .grad_loss(\n",
     "            qc, \n",
     "            qtm.ansatz.create_Wchain_layerd_ansatz,\n",
     "            thetas, num_layers = num_layers)\n",