+# +# +#
+#
+# +# +#
+#
+# +# +#
+#
+# +# +#
+#
+# +# +#
+#
+# +# +#
+#
+# +# +#
+#
+# +# +#
+#
+# +# +#
+#
+# +# +#
+#
+# +# +#
+#
+# +# +#
+#
+# +# +#
+#
+# +# +#
+#
+# +# +#
+#
+# +# +#
+#
+# +# +#
+#
+# +# +#
+#
+# +# +#
+#![](\"./fig/f4.png\")
\n",
@@ -483,7 +528,7 @@
"[1] S. J. Russell, P. Norvig, M.-W. Chang, J. Devlin, and\n",
"A. Dragan, Artificial Intelligence: A Modern Approach.\n",
"Hoboken: Pearson College Div, 4\n",
- "th ed., Nov. 2020. \n",
+ "th ed., Nov. 2020.\n",
"\n",
"[2]Schubert E, Sander J, Ester M, et al. DBSCAN revisited, revisited: why and how you should (still) use DBSCAN[J]. ACM Transactions on Database Systems (TODS), 2017, 42(3): 1-21.\n",
"\n",
diff --git a/examples/demos/gbs/gbs_clustering/gbs_clustering.py b/examples/demos/gbs/gbs_clustering/gbs_clustering.py
new file mode 100644
index 00000000..4f4a5ef8
--- /dev/null
+++ b/examples/demos/gbs/gbs_clustering/gbs_clustering.py
@@ -0,0 +1,252 @@
+# ---
+# jupyter:
+# jupytext:
+# text_representation:
+# extension: .py
+# format_name: percent
+# format_version: '1.3'
+# jupytext_version: 1.19.1
+# kernelspec:
+# display_name: dq_draw
+# language: python
+# name: python3
+# ---
+
+# %% [markdown]
+# # 基于高斯玻色采样的聚类算法
+
+# %% [markdown]
+# 聚类算法[1]是一种无监督学习算法，用于将数据集中的对象分组成为多个类别（或簇），使得同一类别内的对象彼此相似，而不同类别之间的对象则不相似。聚类算法的目标是发现数据中的内在结构，而无需预先标记数据。常见的经典聚类算法有K均值聚类 (K-Means Clustering), 密度聚类 (DBSCAN)， 谱聚类 (Spectral Clustering)等方法。
+
+# %% [markdown]
+# K均值聚类算法的核心是寻找聚类的中心， 首先随机选择K个中心点，然后计算每个数据点和中心点的距离，将其分类为最接近中心点$\mu_j$的组， 全部计算完成后将每个组的中心$\mu_j$重新计算，然后重复迭代这些步骤直到中心点不再更新就完成了聚类过程。
+# 密度聚类算法[2]能够识别出具有不同密度区域的数据点，并将它们分组为不同的簇。DBSCAN 的核心思想是根据数据点的密度来确定簇，而不是依赖于事先设定的簇的数量，DBSCAN使用的方法很简单，它任意选择一个没有类别的核心对象作为种子，然后找到所有这个核心对象能够密度可达的样本集合，即为一个聚类簇。
+# 接着继续选择另一个没有类别的核心对象去寻找密度可达的样本集合，这样就得到另一个聚类簇 （这样的得到都肯定是密度相连的），一直运行到所有核心对象都有类别为止。
+
+# %% [markdown]
+# 与此同时，高斯玻色采样也可以应用于聚类算法[3]， 根据[GBS稠密子图案例](../dense_graph/gbs_dense_graph_problem.ipynb)的讨论可知高斯玻色采样用于图问题时， 图密度较大的子图对应的样本往往有较大概率被采到， 这些子图的节点对应的数据点就属于同一个聚类，因此通过这种方法就完成了一次聚类，然后将这个聚类对应的子图移除，继续高斯玻色采样过程，可以持续的找到多个不同的聚类。
+
+# %% [markdown]
+# # 算法说明
+
+# %% [markdown]
+# 基于高斯玻色采样的聚类算法如下
+# 1. 通过分类数据集构造邻接矩阵A,
+# 设置一个阈值距离$d_0$以及距离度量 $D_{ij}=d(x_i,x_j)$, 邻接矩阵A的构造如下
+#
+# $$A_{ij} = \begin{cases} 1 & D_{ij}\le d_0 \\
+# 0 & D_{ij}>d_0 \end{cases} $$
+#
+# 2. 将邻接矩阵A放入高斯玻色采样设备中进行N次采样。
+#
+# 3. 挑选出子图对应的采样结果，即只包含0，1的样本，计算每个子图密度，
+# 设置一个阈值图密度$D_0$, 挑选出最大的子图，如果图密度大于 $D_0$
+# 则找到一个聚类，移除子图及其节点， 更新邻接矩阵A。 否则降低阈值图密度 $D_0$，回到2
+#
+# 4. 当节点数剩余较少时停止迭代，完成聚类过程。
+
+# %% [markdown]
+# # 代码演示
+
+# %% [markdown]
+# 首先导入相关库
+
+# %%
+import itertools
+
+import deepquantum.photonic as dqp
+import networkx as nx
+import numpy as np
+import torch
+
+# %% [markdown]
+# 这里采用西瓜数据集进行聚类， 每一个数据点包含密度和含糖率两个特征， 分别对应data_ws第一行和第二行。
+
+# %%
+data_ws = np.array(
+ [
+ [
+ 0.697,
+ 0.774,
+ 0.634,
+ 0.608,
+ 0.556,
+ 0.393,
+ 0.451,
+ 0.427,
+ 0.666,
+ 0.243,
+ 0.245,
+ 0.343,
+ 0.639,
+ 0.657,
+ 0.725,
+ 0.593,
+ 0.6223,
+ 0.75,
+ ],
+ [
+ 0.46,
+ 0.376,
+ 0.264,
+ 0.318,
+ 0.215,
+ 0.237,
+ 0.149,
+ 0.211,
+ 0.091,
+ 0.267,
+ 0.057,
+ 0.099,
+ 0.161,
+ 0.198,
+ 0.445,
+ 0.082,
+ 0.062,
+ 0.405,
+ ],
+ ]
+)
+
+
+# %% [markdown]
+# 
+# +# +#
+#
+# +# +#
+#
+# +# +#
+#
+# +# +#
+#
+# +# +#
+#![](\"./fig/mt1.jpg\")
\n",
" \n",
@@ -434,16 +441,16 @@
"source": [
"#####using monte-carlo mean value method\n",
"points_list = [10, 100, 1000, 5000, 10000, 20000, 30000, 40000, 50000]\n",
- "val = [ ]\n",
+ "val = []\n",
"for num_points in points_list:\n",
" a = np.array([0, -6])\n",
" b = np.array([np.pi, 6])\n",
- " random_samples = a + (b-a)*np.random.rand(num_points, 2)\n",
- " phi = random_samples[:,0]\n",
- " x = random_samples[:,1]\n",
- " vec_fun_real = np.vectorize(fun_real) # vectorize 并行化\n",
+ " random_samples = a + (b - a) * np.random.rand(num_points, 2)\n",
+ " phi = random_samples[:, 0]\n",
+ " x = random_samples[:, 1]\n",
+ " vec_fun_real = np.vectorize(fun_real) # vectorize 并行化\n",
" re = vec_fun_real(phi, x, 0, 0, mu_x, mu_p, sigma_x, sigma_p)\n",
- " volume = np.prod(b-a)\n",
+ " volume = np.prod(b - a)\n",
" integral = volume * np.mean(re)\n",
" val.append(integral)\n",
" print(num_points, integral)"
@@ -562,15 +569,15 @@
"cir = dq.QumodeCircuit(nmode=nmode, init_state='vac', cutoff=3, backend='gaussian')\n",
"cir.s(0, r=1)\n",
"cir.s(1, r=1)\n",
- "cir.bs([0,1], [np.pi/4, np.pi/4])\n",
- "state =cir()\n",
+ "cir.bs([0, 1], [np.pi / 4, np.pi / 4])\n",
+ "state = cir()\n",
"probs = cir(is_prob=True)\n",
"cir.draw()"
]
},
{
"cell_type": "code",
- "execution_count": 25,
+ "execution_count": null,
"id": "869f28b4",
"metadata": {
"ExecuteTime": {
@@ -581,27 +588,36 @@
"outputs": [],
"source": [
"def get_mu_sigma(phi_1, phi_2, mu, sigma):\n",
- " mu_1 = 0.5*(np.cos(phi_1)*mu[0] + np.sin(phi_1)*mu[2])\n",
- " mu_2 = 0.5*(np.cos(phi_2)*mu[1] + np.sin(phi_2)*mu[3])\n",
- " cov_x1x1 = 0.25*(np.cos(phi_1)**2*sigma[0,0] + np.sin(phi_1)**2*sigma[2,2]+np.sin(2*phi_1)*sigma[0,2])\n",
- " cov_x2x2 = 0.25*(np.cos(phi_2)**2*sigma[1,1] + np.sin(phi_2)**2*sigma[3,3]+np.sin(2*phi_2)*sigma[1,3])\n",
- " cov_x1x2 = 0.25*(np.cos(phi_1)*np.cos(phi_2)*sigma[0,1] + np.cos(phi_1)*np.sin(phi_2)*sigma[0,3] + \\\n",
- " np.sin(phi_1)*np.cos(phi_2)*sigma[2,1] + np.sin(phi_1)*np.sin(phi_2)*sigma[2,3])\n",
+ " mu_1 = 0.5 * (np.cos(phi_1) * mu[0] + np.sin(phi_1) * mu[2])\n",
+ " mu_2 = 0.5 * (np.cos(phi_2) * mu[1] + np.sin(phi_2) * mu[3])\n",
+ " cov_x1x1 = 0.25 * (\n",
+ " np.cos(phi_1) ** 2 * sigma[0, 0] + np.sin(phi_1) ** 2 * sigma[2, 2] + np.sin(2 * phi_1) * sigma[0, 2]\n",
+ " )\n",
+ " cov_x2x2 = 0.25 * (\n",
+ " np.cos(phi_2) ** 2 * sigma[1, 1] + np.sin(phi_2) ** 2 * sigma[3, 3] + np.sin(2 * phi_2) * sigma[1, 3]\n",
+ " )\n",
+ " cov_x1x2 = 0.25 * (\n",
+ " np.cos(phi_1) * np.cos(phi_2) * sigma[0, 1]\n",
+ " + np.cos(phi_1) * np.sin(phi_2) * sigma[0, 3]\n",
+ " + np.sin(phi_1) * np.cos(phi_2) * sigma[2, 1]\n",
+ " + np.sin(phi_1) * np.sin(phi_2) * sigma[2, 3]\n",
+ " )\n",
" mu_ = np.array([mu_1, mu_2])\n",
- " sigma_ =np.array([[cov_x1x1, cov_x1x2],\n",
- " [cov_x1x2, cov_x2x2]])\n",
+ " sigma_ = np.array([[cov_x1x1, cov_x1x2], [cov_x1x2, cov_x2x2]])\n",
" return mu_, sigma_\n",
- "def fun_twomode(phi_1, phi_2, x_1, x_2, n_1, labda_1, n_2, labda_2, mu, sigma):\n",
- " \"\"\"\n",
- " calculating expectation value of operator |n_1+labda_1>
+#
+# 
+#
+# +# +#
+# +# 这里随机的点落在积分区域的概率正比于积分区域的面积， 因此红点所占的比例乘以矩形的面积就是函数 $f(x)$ 的积分。 +# 2. 期望法 +#
+# +# +#
+#
+# +# +#
+#
+# +# +#
+#
+# +# +#
+#
+# +# +#
+#
+# +# +#
+#
+# +# +#
+#![](\"./fig/Franck_Condon_Diagram.png\")
\t\n",
+ "\t\n",
"![](\"./fig/formic_spec.png\")
\t\n",
+ "\t\n",
"
+# 
+#
+# +# +#
+#
+# +# +#
+#\n", " \n", "
\n", - "\n", - "\n" + "" ] }, { @@ -118,7 +117,7 @@ "\n", "在此算法中，无需对线路参数进行变分，既硬件友好，也节省了单独测量每个参数梯度的时间（对于梯度优化的VQA），或节省了迭代次数（对于非梯度优化的VQA）。\n", "\n", - "接下来，我们将在案例 [光量子实现VQE](https://github.com/TuringQ/deepquantum/blob/main/examples/gbs/vqe_ground_energy_for_H2_alg/vqe_ground_energy_h2.ipynb) 同个问题中，展示该算法的有效性。" + "接下来，我们将在案例 [光量子实现VQE](https://github.com/TuringQ/deepquantum/blob/main/examples/demos/gbs/vqe_ground_energy_for_H2_alg/vqe_ground_energy_h2.ipynb) 同个问题中，展示该算法的有效性。" ] }, { @@ -157,9 +156,9 @@ "source": [ "import deepquantum as dq\n", "import matplotlib.pyplot as plt\n", - "from scipy import io\n", - "import torch\n", "import numpy as np\n", + "import torch\n", + "from scipy import io\n", "\n", "dic = io.loadmat('boson_coeff2.mat')\n", "g1 = dic['g1'][0]\n", @@ -203,13 +202,13 @@ "cir.d(1, r=1)\n", "cir.ps(0)\n", "cir.ps(1)\n", - "cir.bs([0,1])\n", + "cir.bs([0, 1])\n", "cir.draw()" ] }, { "cell_type": "code", - "execution_count": 3, + "execution_count": null, "id": "c59b17d4", "metadata": { "ExecuteTime": { @@ -220,7 +219,7 @@ "outputs": [], "source": [ "def exp_h_gbs_fock(paras):\n", - " s1, s2 = torch.nn.functional.normalize(abs(paras[0:2]), dim=0) # 归一化\n", + " s1, s2 = torch.nn.functional.normalize(abs(paras[0:2]), dim=0) # 归一化\n", " nmode = 2\n", " cir = dq.QumodeCircuit(nmode=nmode, init_state='vac', cutoff=3, backend='fock', basis=False)\n", " cir.s(0, r=s1)\n", @@ -229,29 +228,34 @@ " cir.d(1, r=paras[3])\n", " cir.ps(0, paras[4])\n", " cir.ps(1, paras[5])\n", - " cir.bs([0,1], inputs=[paras[6], paras[7]])\n", + " cir.bs([0, 1], inputs=[paras[6], paras[7]])\n", "\n", " state = cir()\n", - " p_00 = state[0][0,0]\n", - " p_01 = state[0][0,1]\n", - " p_10 = state[0][1,0]\n", - " p_11 = state[0][1,1]\n", - " p_20 = state[0][2,0]\n", - " p_02 = state[0][0,2]\n", + " p_00 = state[0][0, 0]\n", + " p_01 = state[0][0, 1]\n", + " p_10 = state[0][1, 0]\n", + " p_11 = state[0][1, 1]\n", + " p_20 = state[0][2, 0]\n", + " p_02 = state[0][0, 2]\n", "\n", " p_list = torch.stack([p_00, p_01, p_10, p_11, p_20, p_02])\n", - " p_00_,p_01_,p_10_,p_11_,p_20_,p_02_ = torch.nn.functional.normalize(p_list, dim=0)\n", + " p_00_, p_01_, p_10_, p_11_, p_20_, p_02_ = torch.nn.functional.normalize(p_list, dim=0)\n", "\n", - " exp_h = g_1*abs(p_00_)**2 + g_2*abs(p_02_)**2 + g_3*(abs(p_01_)**2+ abs(p_20_)**2) + \\\n", - " g_4 *(abs(p_10_)**2 + abs(p_11_)**2) + g_5*(p_00_.conj()*p_02_+p_00_*p_02_.conj()) - \\\n", - " g_5* (p_20_.conj()*p_01_+p_20_*p_01_.conj()) # see\n", + " exp_h = (\n", + " g_1 * abs(p_00_) ** 2\n", + " + g_2 * abs(p_02_) ** 2\n", + " + g_3 * (abs(p_01_) ** 2 + abs(p_20_) ** 2)\n", + " + g_4 * (abs(p_10_) ** 2 + abs(p_11_) ** 2)\n", + " + g_5 * (p_00_.conj() * p_02_ + p_00_ * p_02_.conj())\n", + " - g_5 * (p_20_.conj() * p_01_ + p_20_ * p_01_.conj())\n", + " ) # see\n", "\n", " return (exp_h).real" ] }, { "cell_type": "code", - "execution_count": 4, + "execution_count": null, "id": "550cf730", "metadata": { "ExecuteTime": { @@ -269,7 +273,7 @@ } ], "source": [ - "loss_gbs3 = [ ]\n", + "loss_gbs3 = []\n", "for idx in range(50):\n", " g_1 = g1[idx]\n", " g_2 = g2[idx]\n", @@ -278,14 +282,14 @@ " g_5 = g5[idx]\n", "\n", " angles = torch.nn.Parameter(torch.randn(8))\n", - " optimizer = torch.optim.Adam([angles], lr=0.1)\n", - " for epoch in range(150):\n", + " optimizer = torch.optim.Adam([angles], lr=0.1)\n", + " for _ in range(150):\n", " optimizer.zero_grad()\n", " loss = exp_h_gbs_fock(angles)\n", - " loss.backward() # backpropagetion\n", - " optimizer.step() # update parameters\n", + " loss.backward() # backpropagetion\n", + " optimizer.step() # update parameters\n", " loss_gbs3.append(loss)\n", - " print(idx,loss,end='\\r')" + " print(idx, loss, end='\\r')" ] }, { @@ -312,11 +316,11 @@ ], "source": [ "R_values = np.linspace(0.1, 2.5, 50)\n", - "hartree_dis = R_values/0.529177 # using Bohr radius\n", - "fig = plt.figure()\n", - "nuclear_v = 1/hartree_dis\n", + "hartree_dis = R_values / 0.529177 # using Bohr radius\n", + "fig = plt.figure()\n", + "nuclear_v = 1 / hartree_dis\n", "openfermion_h2_fci = np.load('openfermion_h2_fci.npy')\n", - "plt.plot(R_values, torch.stack(loss_gbs3).detach().numpy() + nuclear_v,lw=2, label='vqe_GBS_shallow')\n", + "plt.plot(R_values, torch.stack(loss_gbs3).detach().numpy() + nuclear_v, lw=2, label='vqe_GBS_shallow')\n", "plt.plot(R_values, openfermion_h2_fci[0:50], ls='--', label='openfermion_fci', color='black')\n", "plt.ylabel('Hartree energy')\n", "plt.xlabel('nuclear distance(A)')\n", @@ -373,7 +377,7 @@ "cir.s(1, r=1)\n", "cir.ps(0)\n", "cir.ps(1)\n", - "cir.bs([0,1])\n", + "cir.bs([0, 1])\n", "cir.draw()" ] }, @@ -389,28 +393,33 @@ }, "outputs": [], "source": [ - "def exp_h_gbs_fock(paras,w):\n", + "def exp_h_gbs_fock(paras, w):\n", " # s1, s2 = torch.nn.functional.normalize(abs(paras[0:2]), dim=0) # 归一化\n", " nmode = 2\n", " cir = dq.QumodeCircuit(nmode=nmode, init_state='vac', cutoff=3, backend='fock', basis=False)\n", " cir.s(0, encode=True)\n", - " cir.s(1,encode=True)\n", - " cir.ps(0,encode=True)\n", - " cir.ps(1,encode=True)\n", - " cir.bs([0,1], encode=True)\n", - " state = cir(data = paras)\n", - "\n", - " p_00 = state[:,0,0]\n", - " p_01 = state[:,0,1]\n", - " p_10 = state[:,1,0]\n", - " p_11 = state[:,1,1]\n", - " p_20 = state[:,2,0]\n", - " p_02 = state[:,0,2]\n", + " cir.s(1, encode=True)\n", + " cir.ps(0, encode=True)\n", + " cir.ps(1, encode=True)\n", + " cir.bs([0, 1], encode=True)\n", + " state = cir(data=paras)\n", + "\n", + " p_00 = state[:, 0, 0]\n", + " p_01 = state[:, 0, 1]\n", + " p_10 = state[:, 1, 0]\n", + " p_11 = state[:, 1, 1]\n", + " p_20 = state[:, 2, 0]\n", + " p_02 = state[:, 0, 2]\n", " p_list = torch.stack([p_00, p_01, p_10, p_11, p_20, p_02])\n", - " p_00_,p_01_,p_10_,p_11_,p_20_,p_02_ = torch.nn.functional.normalize(p_list, dim=0)\n", - " exp_h = g_1*abs(p_00_)**2 + g_2*abs(p_02_)**2 + g_3*(abs(p_01_)**2+ abs(p_20_)**2) + \\\n", - " g_4 *(abs(p_10_)**2 + abs(p_11_)**2) + g_5*(p_00_.conj()*p_02_+p_00_*p_02_.conj()) - \\\n", - " g_5* (p_20_.conj()*p_01_+p_20_*p_01_.conj()) # see\n", + " p_00_, p_01_, p_10_, p_11_, p_20_, p_02_ = torch.nn.functional.normalize(p_list, dim=0)\n", + " exp_h = (\n", + " g_1 * abs(p_00_) ** 2\n", + " + g_2 * abs(p_02_) ** 2\n", + " + g_3 * (abs(p_01_) ** 2 + abs(p_20_) ** 2)\n", + " + g_4 * (abs(p_10_) ** 2 + abs(p_11_) ** 2)\n", + " + g_5 * (p_00_.conj() * p_02_ + p_00_ * p_02_.conj())\n", + " - g_5 * (p_20_.conj() * p_01_ + p_20_ * p_01_.conj())\n", + " ) # see\n", " w = torch.nn.functional.softmax(w, dim=0)\n", " return (exp_h).real @ w" ] @@ -425,7 +434,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": null, "id": "64aabe09", "metadata": { "ExecuteTime": { @@ -444,7 +453,7 @@ ], "source": [ "batch = 100\n", - "loss_gbs_4 = [ ]\n", + "loss_gbs_4 = []\n", "for idx in range(50):\n", " idx = idx\n", " g_1 = g1[idx]\n", @@ -453,18 +462,18 @@ " g_4 = g4[idx]\n", " g_5 = g5[idx]\n", "\n", - " angles = torch.rand(8*batch).reshape(batch,8)\n", - " angles[:,1] = 0.\n", - " angles[:,3] = 0.\n", - " w = torch.nn.Parameter(torch.rand(batch,1))\n", - " optimizer = torch.optim.Adam([w], lr=0.1)\n", - " for epoch in range(150):\n", + " angles = torch.rand(8 * batch).reshape(batch, 8)\n", + " angles[:, 1] = 0.0\n", + " angles[:, 3] = 0.0\n", + " w = torch.nn.Parameter(torch.rand(batch, 1))\n", + " optimizer = torch.optim.Adam([w], lr=0.1)\n", + " for _ in range(150):\n", " optimizer.zero_grad()\n", - " loss = exp_h_gbs_fock(angles,w)\n", - " loss.backward() # backpropagetion\n", - " optimizer.step() # update parameters\n", + " loss = exp_h_gbs_fock(angles, w)\n", + " loss.backward() # backpropagetion\n", + " optimizer.step() # update parameters\n", " loss_gbs_4.append(loss)\n", - " print(idx,loss,end='\\r')" + " print(idx, loss, end='\\r')" ] }, { @@ -490,9 +499,11 @@ } ], "source": [ - "fig = plt.figure()\n", - "plt.plot(R_values, torch.stack(loss_gbs3).detach().numpy() + nuclear_v,lw=2, label='vqe_GBS_shallow')\n", - "plt.plot(R_values, torch.stack(loss_gbs_4).mT[0].detach().numpy() + nuclear_v,lw=2, label='vqe_GBS_random',color='red')\n", + "fig = plt.figure()\n", + "plt.plot(R_values, torch.stack(loss_gbs3).detach().numpy() + nuclear_v, lw=2, label='vqe_GBS_shallow')\n", + "plt.plot(\n", + " R_values, torch.stack(loss_gbs_4).mT[0].detach().numpy() + nuclear_v, lw=2, label='vqe_GBS_random', color='red'\n", + ")\n", "plt.plot(R_values, openfermion_h2_fci[0:50], ls='--', label='openfermion_fci', color='black')\n", "plt.ylabel('Hartree energy')\n", "plt.xlabel('nuclear distance(A)')\n", diff --git a/examples/demos/gbs/vqe_ground_energy_for_H2_hardware/VQE_H2_ground_energy.py b/examples/demos/gbs/vqe_ground_energy_for_H2_hardware/VQE_H2_ground_energy.py new file mode 100644 index 00000000..36102693 --- /dev/null +++ b/examples/demos/gbs/vqe_ground_energy_for_H2_hardware/VQE_H2_ground_energy.py @@ -0,0 +1,311 @@ +# --- +# jupyter: +# jupytext: +# text_representation: +# extension: .py +# format_name: percent +# format_version: '1.3' +# jupytext_version: 1.19.1 +# kernelspec: +# display_name: dq_v3 +# language: python +# name: dq_v3 +# --- + +# %% [markdown] +# 硬件友好的并行随机光量子芯片实现VQE +# ====================================== + +# %% [markdown] +# *前置模块* +# +# [关于玻色采样的介绍](https://github.com/TuringQ/deepquantum/blob/main/examples/demos/gbs/boson_sampling/boson_sampling.ipynb) +# +# [光量子实现VQE](https://github.com/TuringQ/deepquantum/blob/main/examples/demos/gbs/vqe_ground_energy_for_H2_alg/vqe_ground_energy_h2.ipynb) +# +# 引言 +# ------ +# 在案例*氢分子基态能量求解的基础理论*中，引入了费米子体系到玻色子体系的映射，并展示了在光量子芯片中，如何使用玻色采样和高斯玻色采样实现VQE。 +# 在实践中，ansatz的大小和变分的需求都为实验验证增添了难度。 +# 此案例借鉴了论文[1]变分蒙特卡洛算法VQCMC的思路：对于表达能力不强的ansatz，构建随机线路采样池，以实现扩大ansatz表达能力的效果。 +# 特别的，由于光量子芯片可片上集成、量产的特点，我们可以利用多张参数不同的芯片构建采样池，并行地计算任务需要的观测量，经典地优化权重函数以得到系统最优解。 + +# %% [markdown] +# +# 变分量子算法 +# ------ +# +# 在DeepQuantum中，我们已经展示了若干从简单、中级到困难的变分量子算法（VQA）的案例👇 +# +# [变分量子算法案例](https://deepquantum.turingq.com/category/quantum-variational-algorithm/) +# +# [变分高斯玻色采样的训练](https://github.com/TuringQ/deepquantum/blob/main/examples/demos/gbs/variational_gbs/variational_gbs.ipynb) +# +# 变分量子算法的关键流程，是构建一个参数化的量子线路（Ansatz） $ \left |\psi(\theta) \right \rangle = U(\theta) \left |0 \right \rangle ^{\otimes n} $，测量得到损失函数 $L(\theta)$ , 通过找到使损失函数最小的最优参数 $\theta$ 来得到问题的解。 +# +# +#
+# +# +#
+#
+# +# +#
+#
+# +# +#
+#
+# +# +#
+#
+# +# +#
+#
+# +# +#
+#
+# +# +#
+#
+# +# +#
+#
+# +# +#
+#
+# +# +#
+#
+# +# +#
+#