tutorials/quantum_simulation/VariationalQM_EN.ipynb

{
    "cells": [
        {
            "cell_type": "markdown",
            "metadata": {},
            "source": [
                "# Variational Quantum Metrology"
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {},
            "source": [
                "<em> Copyright (c) 2022 Institute for Quantum Computing, Baidu Inc. All Rights Reserved. </em>"
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {},
            "source": [
                "## Background"
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {},
            "source": [
                "Quantum metrology is the study of high resolution and high sensitivity measurements of physical parameters using quantum theory (e.g., quantum entanglement) in order to further describe physical systems. Its theoretical aspect is quantum parameter estimation theory, and its experimental aspect is called quantum sensing. Previous studies have shown that the estimation accuracy by quantum theory is improved by taking the square root of the required number of samples compared with the classical method [1-3]. For an unknown parameter, the goal of quantum metrology is to maximize the accuracy of parameter estimation while minimizing the required resources (such as time, number of qubits, etc.).\n",
                "\n",
                "For example, given a unitary $e^{-i\\phi H}$ with a known Hamiltonian $H$, how can we extract the information about $\\phi$ by quantum metrology? It comprises the following four steps:\n",
                "\n",
                "1. Preparation. Prepare an input state $|\\psi\\rangle$.\n",
                "2. Parameterization. Obtain the parameterized quantum state $e^{-i\\phi H}|\\psi\\rangle$ after the evolution of $e^{-i\\phi H}$.\n",
                "3. Measurement. Measure the output state.\n",
                "4. Classical estimation. Estimate the parameters based on the results of multiple measurements.\n",
                "\n",
                "Combined with quantum parameter estimation theory, this tutorial is based on the idea of variational quantum sensors in [4], and the parameterized quantum circuit is constructed using Paddle Quantum to train the loss function and obtain a quantum sensor that can estimate the parameters that are normally distributed."
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {},
            "source": [
                "## Parameter Estimation Theory"
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {},
            "source": [
                "### Classical  parameter estimation"
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {},
            "source": [
                "Classical parameter estimation, such as the maximum-likelihood estimator (MLE), uses multiple samples to calculate data containing an unknown parameter. That is, given a probability distribution depending on an unknown parameter $\\phi$, where $f$ is the probability density function, and ${\\bf{X}}=\\{X_1,X_2,... X_N\\}$ is $N$ independent and identically distributed sample data, the estimated value $\\hat\\phi$ is obtained by using MLE:\n",
                "\n",
                "$$\n",
                "\\hat\\phi({\\bf X})=\\arg\\max_{\\phi}\\prod_i^Nf(X_i,\\phi), \\tag{1}\n",
                "$$\n",
                "\n",
                "which finds $\\phi$ such that $X_i(i=1,...,N)$ occurs with maximum probability. After obtaining the estimated parameters, how to measure the difference between the estimated parameters and the actual parameters? That is, how to measure the accuracy of the estimated parameters? In the parameter estimation theory, mean squared error (MSE) is generally used to measure the accuracy.\n",
                "\n",
                "The sample containing the unknown parameter $\\bf{\\phi}$ is ${\\bf{X}}=\\{X_1,X_2,... X_N\\}\\in {\\mathcal F}^N$, where ${\\mathcal F}^N$ is the sample space. Let $\\hat{\\phi}({\\bf X}):{\\mathcal F}^N\\rightarrow\\Phi$ be the estimator that estimates $\\phi\\in\\Phi$ ($\\Phi$ is the parameter space). Then the MSE of $\\hat{\\phi}(\\bf X)$ with respect to $\\phi$ is defined as\n",
                "\n",
                "$$\n",
                "\\begin{aligned}\n",
                "{\\rm{MSE}}&=\n",
                "E[(\\hat{\\phi}({\\bf X})-\\phi)^2]\\\\\n",
                "&=\\sum_{{\\bf X}\\in {\\mathcal F}^N}f({\\bf X};\\phi)(\\hat{\\phi}({\\bf X)}-\\phi)^2,\n",
                "\\end{aligned} \\tag{2}\n",
                "$$\n",
                "\n",
                "where $f({\\bf X}; \\phi)$ is the probability density of getting the current sample $\\bf X$ given the parameter $\\phi$. Although different estimators affect the value of MSE, regardless of the choice of $\\hat{\\phi}({\\bf X})$, there is ${\\rm{MSE}}\\geq\\frac{1}{N{\\mathcal I(\\phi)}}$. This lower bound is known as the Cramér–Rao (CR) bound [2], where $\\mathcal I(\\phi)$ is the Fisher information, which reflects to what extent a slight parameter change will change the probability distribution (see [Quantum Fisher Information](https://qml.baidu.com/tutorials/qnn-research/quantum-fisher-information.html) for the application of Fisher information in Paddle Quantum). "
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {},
            "source": [
                "### Quantum parameter estimation"
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {},
            "source": [
                "In quantum parameter estimation, the samples used in classical parameter estimation become a quantum state $\\rho_{\\phi}\\in{\\mathcal F}({\\mathcal H})$ to be measured, where $\\phi$ is the unknown parameter and ${\\mathcal F}({\\mathcal H})$ denotes the set of density operators on the Hilbert space $\\mathcal H$. According to the steps of quantum metrology and [4], assuming that the initial input state is $|0\\rangle$ and the estimator is $\\hat{\\phi}(m)$, where $m$ is related to the measured results (such as the difference in the number of 1s and the number of 0s in the measured bit string), then the MSE is\n",
                "\n",
                "$$\n",
                "\\begin{aligned}\n",
                "{\\rm MSE}&=E[(\\hat{\\phi}(m)-\\phi)^2]\\\\\n",
                "&=\\sum_m(\\hat{\\phi}(m)-\\phi)^2p(m|\\phi),\n",
                "\\end{aligned} \\tag{3}\n",
                "$$\n",
                "\n",
                "where $p(m|\\phi)$ is the probability of obtaining $m$ by measurement with a given parameter $\\phi$. Similarly, no matter how $\\hat{\\phi}(m)$ is chosen, there is a quantum CR bound ${\\rm{MSE}}\\geq\\frac{1}{NF(\\phi)}$, where $N$ is the number of repeated measurements of $\\rho_\\phi$, and $F(\\phi)$ is the quantum Fisher information (see [Quantum Fisher Information](https://qml.baidu.com/tutorials/qnn-research/quantum-fisher-information.html) for the application of quantum Fisher information in Paddle Quantum). "
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {},
            "source": [
                "## Variational Quantum Sensors"
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {},
            "source": [
                "Quantum sensing is the application of quantum metrology. Based on [4], this tutorial mainly introduces a kind of variational Ramsey interferometer. The traditional Ramsey interferometer [2] (as shown in Figure 1) is a particle interferometry method that uses magnetic resonance phenomena to measure particle transition frequency and is used to measure unknown parameters. The variational Ramsay interferometer [6] (as shown in Figure 2) consists of two parameterized quantum circuits (denoted as $U_{\\rm{En}}(\\theta_{\\rm En})$ and $U_{\\rm{De}}(\\theta_{\\rm{De}})$) in the encoding and decoding parts of the circuit for setting entanglement and measuring quantum states. Previous studies have shown that by combining with quantum theory (such as quantum entanglement), the scaling of parameter estimation accuracy is enhanced to $\\frac{1}{N}$ from $\\frac{1}{\\sqrt{N}}$ [1-3], and the appropriate entanglement mode can be effectively found by the variational method.\n",
                "\n",
                "![Ramsey_interferomertry](./figures/QM-fig-RI.png \"Figure 1：Ramsey interferometer.\")\n",
                "<center> Figure 1：Ramsey interferometer. On the left is the classical configuration of a Ramsey interferometer, and on the right is a Ramsey interferometer using quantum entanglement. Compared with the classical setting, the interferometer using quantum entanglement has an advantage in the order of square root in the accuracy of estimating unknown parameters. </center>\n",
                "\n",
                "![V_Ramsey_interferomertry](./figures/QM-fig-V_RI3.png \"Figure 2：Variational Ramsey interferometer.\")\n",
                "<center> Figure 2：Variational Ramsey interferometer. Two parameterized quantum circuits are optimized to find an efficient way of utilizing entanglement. </center>\n",
                "\n",
                "In the following, we construct a parameterized quantum circuit using Paddle Quantum to investigate the accuracy of estimating normally distributed parameters by a variational Ramsey interferometer. There are three steps as follows.\n",
                "1. Initialization.\n",
                "2. Evaluation.\n",
                "3. Optimization.\n",
                "\n",
                "The probability density function of the parameters that obey the normal distribution is:\n",
                "\n",
                "$$\n",
                "f(x)=\\frac{1}{\\sqrt{2\\pi}\\nu}\\exp(-\\frac{(x-\\mu)^2}{2\\nu^2}), \\tag{4}\n",
                "$$\n",
                "\n",
                "where $\\mu$ is the mean and $\\nu^2$ is the variance. In this case, the loss function of the variational Ramsey interferometer is:\n",
                "\n",
                "$$\n",
                "C(\\theta_{\\rm En},\\theta_{\\rm De},a)=\\int d\\phi f(\\phi){\\rm{MSE}}(\\phi), \\tag{5}\n",
                "$$\n",
                "\n",
                "where the estimator is $\\hat\\phi(m)=am$, $a$ is a parameter to be optimized, $m$ is the difference in the number of 1s and the number of 0s in the measured bit string, ${\\rm MSE(\\phi)}=\\sum_m(\\hat{\\phi}(m)-\\phi)^2p_{\\theta}(m|\\phi)$, and $\\theta=(\\theta_{\\rm En},\\theta_{\\rm De})$."
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {},
            "source": [
                "### 1. Initializaiton"
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {},
            "source": [
                "- Set the input state as $|0\\rangle$.\n",
                "- Construct the parameterized quantum circuits $U_{\\rm{En}}$ and $U_{\\rm{De}}$ for encoding and decoding, respectively.\n",
                "- Encode the unknown parameter."
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {},
            "source": [
                "Let us import the necessary packages:"
            ]
        },
        {
            "cell_type": "code",
            "execution_count": 1,
            "metadata": {
                "ExecuteTime": {
                    "end_time": "2022-11-04T07:28:26.890500Z",
                    "start_time": "2022-11-04T07:28:23.298471Z"
                }
            },
            "outputs": [],
            "source": [
                "import numpy as np\n",
                "from math import exp, pi\n",
                "import matplotlib.pyplot as plt\n",
                "from typing import Optional, Tuple, List\n",
                "\n",
                "import paddle\n",
                "import paddle_quantum as pq\n",
                "from paddle_quantum.ansatz import Circuit\n",
                "from paddle_quantum.loss import Measure\n",
                "\n",
                "pq.set_backend('state_vector')\n",
                "pq.set_dtype('complex128')"
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {},
            "source": [
                "Next, we construct a parameterized quantum circuit of $N$ qubits to complete the initialization.\n",
                "\n",
                "The whole circuit includes the following five parts.\n",
                "- $R_y^{\\otimes N}(\\frac{\\pi}{2})$ gates.\n",
                "- Encoding circuit $U_{\\rm{En}}(\\theta_{\\rm{En}})$.\n",
                "- Circuit with unknown parameter $R_z^{\\otimes N}(\\phi)=e^{-i\\phi J_z}$, where $J_z=\\frac{1}{2}\\sum_{k=1}^N\\sigma_z^{(k)}$.\n",
                "- Decoding circuit $U_{\\rm{De}}(\\theta_{\\rm{De}})$.\n",
                "- $R_x^{\\otimes N}(\\frac{\\pi}{2})$ gate.\n",
                "\n",
                "So the unitary of the entire circuit is\n",
                "\n",
                "$$\n",
                "U(\\phi,\\theta_{\\rm{En}},\\theta_{\\rm{De}})=R_x^{\\otimes N}(\\frac{\\pi}{2})U_{\\rm{De}}(\\theta_{\\rm{De}})R_z^{\\otimes N}(\\phi)U_{\\rm{En}}(\\theta_{\\rm{En}})R_y^{\\otimes N}(\\frac{\\pi}{2}). \\tag{6}\n",
                "$$\n",
                "\n",
                "When the depth of the encoding circuit and decoding circuit is $0$, the entire circuit is the classical configuration of a Ramsey interferometer. Here we construct the encoding and the decoding circuits."
            ]
        },
        {
            "cell_type": "code",
            "execution_count": 2,
            "metadata": {
                "ExecuteTime": {
                    "end_time": "2022-11-04T07:28:26.906450Z",
                    "start_time": "2022-11-04T07:28:26.892489Z"
                }
            },
            "outputs": [],
            "source": [
                "def RamseyCircuit(theta_EN: paddle.Tensor, theta_DE: paddle.Tensor, input_phi: float) -> Circuit:\n",
                "    r\"\"\" Construct variational Ramsey interferometer\n",
                "    \n",
                "    Args:\n",
                "        theta_EN: the parameters of encoding circuit, shape is [depth_En, num_qubits，3]\n",
                "        theta_DE: the parameters of decoding circui, shape is [depth_De, num_qubits，3]\n",
                "        input_phi: unknown parameter\n",
                "    \n",
                "    Returns:\n",
                "        Circuit\n",
                "    \n",
                "    \"\"\"\n",
                "    depth_EN, depth_DE = theta_EN.shape[0], theta_DE.shape[0]\n",
                "    num_qubits = theta_EN.shape[1]\n",
                "    \n",
                "    cir = Circuit(num_qubits)\n",
                "    cir.ry(param=pi/2)\n",
                "    \n",
                "    # Construct the encoding circuit to generate an entangled state\n",
                "    for depth in range(depth_EN):\n",
                "        cir.u3(param=theta_EN[depth])\n",
                "        cir.cnot()\n",
                "    \n",
                "    # the gate of unknown parameter\n",
                "    cir.rz(param=input_phi)\n",
                "    \n",
                "    # Construct the decoding circuit to rotate the measurement basis\n",
                "    for depth in range(depth_DE):\n",
                "        cir.cnot()\n",
                "        cir.u3(param=theta_DE[depth])\n",
                "        \n",
                "    cir.rx(param=pi/2)\n",
                "    \n",
                "    return cir"
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {},
            "source": [
                "### 2. Evaluation"
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {},
            "source": [
                "- Calculate the probability distribution of $m$.\n",
                "- Calculate the MSE of the estimator $\\hat{\\phi}(m)=am$: ${\\rm MSE}=\\sum_m(\\hat{\\phi}(m)-\\phi)^2p_{\\theta}(m|\\phi)$.\n",
                "- Calculate the loss function. Here, we use the discrete form of the loss function to approximate its integral form:\n",
                "\n",
                "$$\n",
                "C=\\sum_{k=1}^t\\frac{2}{t}f(\\phi_k){\\rm {MSE}}, \\tag{7}\n",
                "$$\n",
                "\n",
                "where $t$ is the number of partitions in the selected interval (the total interval size is $2$ in this tutorial), and $f(\\phi_k)$ is the probability corresponding to $\\phi_k$."
            ]
        },
        {
            "cell_type": "code",
            "execution_count": 3,
            "metadata": {
                "ExecuteTime": {
                    "end_time": "2022-11-04T07:28:26.922400Z",
                    "start_time": "2022-11-04T07:28:26.908437Z"
                }
            },
            "outputs": [],
            "source": [
                "# Define the function to calculate m\n",
                "def calculate_m(num_qubits: int)-> List[int]:\n",
                "    m_list = []\n",
                "    for k in range(2**num_qubits):\n",
                "        k_bin = list(bin(k)[2:].zfill(num_qubits))\n",
                "        u = k_bin.count('1')\n",
                "        v = k_bin.count('0')\n",
                "        m = u - v\n",
                "        m_list.append(m)\n",
                "\n",
                "    return m_list\n",
                "\n",
                "\n",
                "def MSE(qnn: paddle.nn.Layer, phi: float) -> paddle.Tensor:\n",
                "    r\"\"\" Calculate MSE \n",
                "    \n",
                "    Args:\n",
                "        cir: variational Ramsey interferometer\n",
                "        phi: unknown parameter\n",
                "        a: parameter of the estimator\n",
                "        \n",
                "    Returns:\n",
                "        MSE\n",
                "    \n",
                "    \"\"\"\n",
                "    cir = RamseyCircuit(qnn.theta_EN, qnn.theta_DE, phi)\n",
                "    \n",
                "    # Measurement\n",
                "    output_state = cir()\n",
                "    prob = Measure()(output_state)\n",
                "    \n",
                "    num_qubits = cir.num_qubits\n",
                "    m = calculate_m(num_qubits)\n",
                "    return sum([((phi - qnn.a * m[i]) ** 2) * prob[i] for i in range(2 ** num_qubits)])\n",
                "\n",
                "# Define loss function\n",
                "def loss_func(qnn: paddle.nn.Layer, sampling_times: int, mean: float, variance: float):\n",
                "    r\"\"\" Calculate loss \n",
                "    \n",
                "    Args:\n",
                "        qnn: a QNN\n",
                "        sampling_times: the number of partitions in the selected interval\n",
                "        mean: the mean of a normal distribution\n",
                "        variance: the variance of a normal distribution\n",
                "    \n",
                "    \"\"\"\n",
                "    list_phi = [] # The list of phi\n",
                "    list_pdf = [] # The list of the probability density function of phi\n",
                "    for i in range(sampling_times):\n",
                "        phi = mean - 1 + (2 * i + 1)/ sampling_times # The range of phi is [u - 1, u + 1]       \n",
                "        prob = (1 / (((2 * pi) ** 0.5) * variance)) * exp(-((phi - mean) ** 2) / (2 * (variance**2)))  # The probability density of phi\n",
                "        list_phi.append(phi)\n",
                "        list_pdf.append(prob)\n",
                "    \n",
                "    return sum([list_pdf[i] * MSE(qnn, list_phi[i]) * (2 / sampling_times) for i in range(sampling_times)])"
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {},
            "source": [
                "### 3. Optimization"
            ]
        },
        {
            "cell_type": "code",
            "execution_count": 4,
            "metadata": {
                "ExecuteTime": {
                    "end_time": "2022-11-04T07:28:26.938337Z",
                    "start_time": "2022-11-04T07:28:26.926376Z"
                }
            },
            "outputs": [],
            "source": [
                "def optimization(qnn: paddle.nn.Layer, num_itr: int, learning_rate: float) -> None:\n",
                "    r\"\"\" Optimize QNN\n",
                "    \n",
                "    Args:\n",
                "        qnn: a QNN\n",
                "        num_itr: the number of optimization iterations\n",
                "        learning_rate: learning rate\n",
                "    \n",
                "    \"\"\"\n",
                "    opt = paddle.optimizer.Adam(learning_rate=learning_rate, parameters=qnn.parameters())\n",
                "    print(\"Begin：\")\n",
                "    for itr in range(1, num_itr):\n",
                "        loss = qnn()\n",
                "        loss.backward()\n",
                "        opt.minimize(loss)\n",
                "        opt.clear_grad()\n",
                "\n",
                "        if itr % 10 == 0:\n",
                "            print(\"     iter:\", itr, \"loss:\", \"%.4f\" % loss.numpy())"
            ]
        },
        {
            "cell_type": "code",
            "execution_count": 9,
            "metadata": {
                "ExecuteTime": {
                    "end_time": "2022-11-04T07:29:44.003762Z",
                    "start_time": "2022-11-04T07:29:43.988814Z"
                }
            },
            "outputs": [],
            "source": [
                "class RamseyInterferometer(paddle.nn.Layer):\n",
                "    r\"\"\" Variational Ramsey interferometer\n",
                "    \n",
                "    \"\"\"\n",
                "    def __init__(self) -> None:\n",
                "        super().__init__()\n",
                "        \n",
                "        # Add parameters\n",
                "        theta_EN = self.create_parameter(\n",
                "            shape= [depth_EN, N, 3], dtype=\"float64\",\n",
                "            default_initializer=paddle.nn.initializer.Uniform(low=0, high=2 * pi),\n",
                "        )\n",
                "        theta_DE = self.create_parameter(\n",
                "            shape= [depth_DE, N, 3], dtype=\"float64\",\n",
                "            default_initializer=paddle.nn.initializer.Uniform(low=0, high=2 * pi),\n",
                "        )\n",
                "        self.add_parameter('theta_EN', theta_EN)\n",
                "        self.add_parameter('theta_DE', theta_DE)\n",
                "        \n",
                "        # Add the parameter of the estimator\n",
                "        a = self.create_parameter(\n",
                "            shape= [1], dtype=\"float64\",\n",
                "            default_initializer=paddle.nn.initializer.Uniform(low=0, high=2 * pi),\n",
                "        )\n",
                "        self.add_parameter('a', a)\n",
                "        \n",
                "    def forward(self) -> paddle.Tensor:\n",
                "        r\"\"\" Calculate loss\n",
                "        \n",
                "        \"\"\"\n",
                "        return loss_func(self, TIMES, MEAN, VAR)\n",
                "    \n",
                "    def opt(self) -> None:\n",
                "        r\"\"\" Optimize QNN\n",
                "        \n",
                "        \"\"\"\n",
                "        optimization(self, num_itr=ITR, learning_rate=LR)"
            ]
        },
        {
            "cell_type": "code",
            "execution_count": null,
            "metadata": {},
            "outputs": [],
            "source": [
                "N = 2  # The number of qubits\n",
                "depth_EN = 3  # The depth of encoding circuit\n",
                "depth_DE = 3  # The depth of decoding circuit\n",
                "LR = 0.2  # Learning rate\n",
                "ITR = 150   # The number of optimization iterations\n",
                "TIMES = 30  # The number of partitions in the selected interval\n",
                "MEAN = 2  # The mean of a normal distribution\n",
                "VAR = 1  # The variance of a normal distribution"
            ]
        },
        {
            "cell_type": "code",
            "execution_count": 14,
            "metadata": {
                "ExecuteTime": {
                    "end_time": "2022-11-04T07:44:05.439096Z",
                    "start_time": "2022-11-04T07:40:20.208851Z"
                }
            },
            "outputs": [
                {
                    "name": "stdout",
                    "output_type": "stream",
                    "text": [
                        "Begin：\n",
                        "     iter: 10 loss: 3.8495\n",
                        "     iter: 20 loss: 0.8521\n",
                        "     iter: 30 loss: 0.7484\n",
                        "     iter: 40 loss: 0.4504\n",
                        "     iter: 50 loss: 0.3610\n",
                        "     iter: 60 loss: 0.3375\n",
                        "     iter: 70 loss: 0.3042\n",
                        "     iter: 80 loss: 0.2827\n",
                        "     iter: 90 loss: 0.2600\n",
                        "     iter: 100 loss: 0.2386\n",
                        "     iter: 110 loss: 0.2217\n",
                        "     iter: 120 loss: 0.2096\n",
                        "     iter: 130 loss: 0.2026\n",
                        "     iter: 140 loss: 0.1996\n"
                    ]
                }
            ],
            "source": [
                "QNN = RamseyInterferometer()\n",
                "QNN.opt()"
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {},
            "source": [
                "The optimized circuit is used to estimate the parameters with a normal distribution, and then we draw the MSE."
            ]
        },
        {
            "cell_type": "code",
            "execution_count": 15,
            "metadata": {
                "ExecuteTime": {
                    "end_time": "2022-11-04T07:44:49.222284Z",
                    "start_time": "2022-11-04T07:44:47.797824Z"
                },
                "scrolled": true
            },
            "outputs": [
                {
                    "data": {
                        "image/png": "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",
                        "text/plain": [
                            "<Figure size 600x400 with 1 Axes>"
                        ]
                    },
                    "metadata": {
                        "needs_background": "light"
                    },
                    "output_type": "display_data"
                }
            ],
            "source": [
                "phi_list = []\n",
                "mse_list = []\n",
                "for i in range(TIMES):\n",
                "    phi = MEAN - 1 + (2 * i + 1) / TIMES\n",
                "    mse_est = MSE(QNN, phi)\n",
                "    phi_list.append(phi)\n",
                "    mse_list.append(mse_est)\n",
                "\n",
                "font = {'family': 'Times New Roman', 'weight':'normal', 'size':16}\n",
                "plt.figure(dpi=100)\n",
                "plt.plot(phi_list,mse_list,color='darkblue', linestyle='-')\n",
                "plt.scatter(phi_list,mse_list)\n",
                "plt.xlabel('$\\\\phi$',font)\n",
                "plt.ylabel('MSE',font)\n",
                "\n",
                "plt.grid()\n",
                "plt.show()"
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {},
            "source": [
                "## Conclusion"
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {},
            "source": [
                "We can see that the MSE estimated by the optimized quantum sensor is negatively correlated with the probability density of the parameters, and the value of MSE is the lowest near the mean value of the normal distribution, indicating that the obtained quantum sensor by variational method is effective for the parameters following a normal distribution."
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {},
            "source": [
                "---\n",
                "\n",
                "## References"
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {},
            "source": [
                "[1] Braunstein S L, Caves C M. Statistical distance and the geometry of quantum states[J]. [Physical Review Letters, 1994, 72(22): 3439](https://journals.aps.org/prl/abstract/10.1103/PhysRevLett.72.3439).\n",
                "\n",
                "[2] Giovannetti V, Lloyd S, Maccone L. Quantum metrology[J]. [Physical review letters, 2006, 96(1): 010401](https://journals.aps.org/prl/abstract/10.1103/PhysRevLett.96.010401).\n",
                "\n",
                "[3] Tóth G, Apellaniz I. Quantum metrology from a quantum information science perspective[J]. [Journal of Physics A: Mathematical and Theoretical, 2014, 47(42): 424006](https://iopscience.iop.org/article/10.1088/1751-8113/47/42/424006/meta).\n",
                "\n",
                "[4] Marciniak C D, Feldker T, Pogorelov I, et al. Optimal metrology with programmable quantum sensors[J]. [Nature, 2022, 603(7902): 604-609](https://www.nature.com/articles/s41586-022-04435-4).\n",
                "\n",
                "[5] Giovannetti V, Lloyd S, Maccone L. Advances in quantum metrology[J]. [Nature photonics, 2011, 5(4): 222-229](https://www.nature.com/articles/nphoton.2011.35).\n",
                "\n",
                "[6] Kaubruegger R, Vasilyev D V, Schulte M, et al. Quantum variational optimization of Ramsey interferometry and atomic clocks[J]. [Physical Review X, 2021, 11(4): 041045](https://journals.aps.org/prx/abstract/10.1103/PhysRevX.11.041045)."
            ]
        }
    ],
    "metadata": {
        "kernelspec": {
            "display_name": "Python 3.8.13 ('pq')",
            "language": "python",
            "name": "python3"
        },
        "language_info": {
            "codemirror_mode": {
                "name": "ipython",
                "version": 3
            },
            "file_extension": ".py",
            "mimetype": "text/x-python",
            "name": "python",
            "nbconvert_exporter": "python",
            "pygments_lexer": "ipython3",
            "version": "3.8.13"
        },
        "vscode": {
            "interpreter": {
                "hash": "08942b1340a5932ff3a93f52933a99b0e263568f3aace1d262ffa4d9a0f2da31"
            }
        }
    },
    "nbformat": 4,
    "nbformat_minor": 2
}