diff --git a/algorithms/qml/qsvm/qsvm.ipynb b/algorithms/qml/qsvm/qsvm.ipynb index 4122b6f17..dfec1ec35 100644 --- a/algorithms/qml/qsvm/qsvm.ipynb +++ b/algorithms/qml/qsvm/qsvm.ipynb @@ -5,54 +5,162 @@ "id": "0", "metadata": {}, "source": [ - "# Quantum Support Vector Machines (QSVM)\n", - "Quantum Support Vector Machines is the quantum version of SVM; i.e., a data classification method that separates the data using a hyperplane.\n", + "# Quantum Support Vector Machines (QSVM)" + ] + }, + { + "cell_type": "markdown", + "id": "1", + "metadata": {}, + "source": [ + "> **Quantum Support Vector Machines** is the quantum version of SVM; i.e., a data classification method that separates the data by performing a mapping to a high-dimensional space, in which the data is seperated by a hyperplane [[1](#learning)]. QSVM is a hybrid quantum–classical classification algorithm in which classical data are embedded into a high-dimensional quantum Hilbert space using a parameterized quantum feature map. A quantum processor is then used to evaluate inner products between these quantum states, producing a kernel matrix that captures similarities between data points in this quantum feature space. This kernel is passed to a classical support vector machine optimizer, which learns the optimal separating hyperplane by identifying support vectors and model parameters. For prediction, the trained model classifies new data points using quantum-evaluated kernel values and a classical decision rule. \n", + ">\n", + "> The algorithm treats the following problem:\n", + ">\n", + "> - **Input:** Classical data points ${\\mathbf{x}_i}$, where $\\mathbf{x}_i\\in \\mathbb{R}^d$ are d-dimensional vectors, corresponding labels $y_i \\in\\{-1, 1\\}$, where $i=1,\\dots,m$, as well as feature map $U_\\phi(\\mathbf{x}_i)$, encoding the classical data in a quantum state.\n", + "> - **Output:** A kernel matrix evaluated using quantum measurements. The matrix is then fed into a classical SVM optimizer, producing a full characterization of the separating hyperplane.\n", + ">\n", + "> **Complexity:** \n", + "> \n", + "> ---\n", + ">\n", + "> **Keywords:** Quantum Machine Learning (QML), hybrid quantum–classical algorithm, supervised learning, binary classification. " + ] + }, + { + "cell_type": "markdown", + "id": "2", + "metadata": {}, + "source": [ + "## Background" + ] + }, + { + "cell_type": "markdown", + "id": "3", + "metadata": {}, + "source": [ + "Our goal is to find a hyperplane in $\\mathbb{R}^d$ which separates the points $\\{\\mathbf{x}_i\\}$ into ones for which the corresponding labels are $y_i = +1$ and $y_i = -1$. The hyperplane is conveniently defined by a vector normal to it, $\\mathbf{w} \\in \\mathbb{R}^d$ and an offset $b \\in \\mathbb{R}$. The classification of a point $\\mathbf{x}$ can be determined by $h_{\\mathbf{w}}(\\mathbf{x}) = \\text{sign}(\\langle \\mathbf{w},\\mathbf{x} \\rangle + b)$, which decides on which side of the hyperplane the point lies on. Here $\\langle \\mathbf{w},\\mathbf{x} \\rangle$ is the inner product between the two vectors.\n", + "\n", + "To describe the goal explicitly, we introduce the **geometric margin** as the distance from the hyperplane to the closest training point $\\mathbf{x}_i$: $\\min_{\\mathbf{x}}((\\langle \\mathbf{w},\\mathbf{x} \\rangle/||\\mathbf{w}||)$. The optimal classification corresponds to the hyperplane and offset that maximizes the geometric margin.\n", + "This goal can be stated as a naive optimization problem: find $\\mathbf{w}$ satisfying \n", + "$$\\max_{\\mathbf{w}}\\min_{\\mathbf{i}} \\text{sign}(\\langle \\mathbf{w},\\mathbf{x}_i \\rangle + b)$$ $$\\text{subject to: }~~ \\text{sign}(\\langle \\mathbf{w},\\mathbf{x}_i \\rangle + b) = \\text{sign}(y_i)~. $$\n", + "However, this formulation of the problem is a nonlinear optimization problem due to the sign comparison. Alternatively, we can express the objective as a linear function with linear constraints. A separating hyperplane satisfies\n", + "$(\\langle \\mathbf{w},\\mathbf{x}_i \\rangle + b)y_i \\geq 0 ~~, $ moreover, we set the length of $\\mathbf{w}$ by enforcing that the inner product with respect to the nearest point (in fact, there will always be two data points on each side of the hyperplane with the same minimal distance to the hyperplane) to be $\\langle \\mathbf{w},\\mathbf{x}_{\\min} \\rangle = 1$. As a result, all data points satisfy $(\\langle \\mathbf{w},\\mathbf{x}_i \\rangle + b)y_i \\geq 1$. The condition enables defining the optimization problem\n", + "$${\\text{minimize}~ \\frac{1}{2}} || \\mathbf{w}||^2 $$ $$\\text{subject to }~~ (\\langle \\mathbf{w},\\mathbf{x}_i \\rangle + b)y_i \\geq 1 ~~~~\\text{for}~~~~i=1,\\dots,m~.$$\n", + "\n", + "In general, it would not be possible to separate the bare data points by a hyperplane; therefore, a transformation of the data to a higher-dimensional space using a feature map $\\phi(\\mathbb{x})$ is performed. Following the transformation, the hyperplane and offset are evaluated (similar problem, obtained by transforming $\\mathbf{x}_i \\rightarrow \\phi(\\mathbf{x}_i)$). The main disadvantage of the present (primal) formulation of the problem is that explicitly computing $\\phi(\\mathbf{x})$ may require infeasible computational resources, or even involve a mapping to an infinite-dimensional space.\n", "\n", - "The QSVM algorithm takes these steps:\n", - "1. Maps the data into a different hyperspace (since the data may be non-linearly-separable in the original space). For QSVM, it maps the classical data into a Hilbert space.\n", - "2. Calculates the kernel matrix:\n", - " - The kernel entries are the fidelities between different feature vectors\n", - " - For QSVM, this is done on a quantum computer.\n", - "3. Optimizes the dual problem (this is always done classically):\n", - "$$ L_D(\\alpha) = \\sum_{i=1}^t \\alpha_i - \\frac{1}{2} \\sum_{i,j=1}^t y_i y_j \\alpha_i \\alpha_j K(\\vec{x}_i \\vec{x}_j) $$\n", - " - where $t$ is the number of data points\n", - " - the $\\vec{x}_i$s are the data points\n", - " - $y_i$ is the label $\\in \\{-1,1\\}$ of each data point\n", - " - $K(\\vec{x}_i \\vec{x}_j)$ is the kernel matrix element between the $i$ and $j$ data points\n", - " - optimized over the $\\alpha$s\n", - " - We expect most of the $\\alpha$s to be $0$. The $\\vec{x}_i$s that correspond to non-zero $\\alpha_i$ are called the support vectors.\n", - "4. Predicts unlabeled data by calculating the kernel matrix of the new datum with respect to the support vectors:\n", - "$$ \\text{Predicted Label}(\\vec{s}) = \\text{sign} \\left( \\sum_{i=1}^t y_i \\alpha_i^* K(\\vec{x}_i , \\vec{s}) + b \\right) $$\n", - " - where $\\vec{s}$ is the data point to be classified\n", - " - $\\alpha_i^*$ are the optimized $\\alpha$s\n", - " - $b$ is the bias\n", + "An alternative approach utilizes the dual formulation of the problem. This approach relies on the **Karush-Kuhn-Tucker theorem** [[2](#KKT)], which implies that one can formulate a dual optimization problem, whose solution (under certain conditions which are satisfied for the present case) coincides with the solution of the present (primal) problem. The dual problem of the original primal optimization problem is given by \n", + "$$\\text{maximize}~~ {\\cal{L}}_D(\\alpha_1,\\dots,\\alpha_m) = \\sum_{i=1}^m \\alpha_i - \\frac{1}{2} \\sum_{i,j=1}^m y_i y_j \\alpha_i \\alpha_j K(\\mathbf{x}_i, \\mathbf{x}_j) $$\n", + "$$\\text{subject to:}~~~~\\alpha_i \\geq 0~~~~\\text{for}~~~~i=1,\\dots,m~~$$\n", + "$$\\sum_{i=1}^m y_i \\alpha_i = 0~~,$$\n", + "where $K(\\mathbf{x}_i, \\mathbf{x}_j) = \\langle \\mathbf{x}_i,\\mathbf{x}_j \\rangle$ is the $(i,j)$ component of the kernel matrix. \n", + "The important advantage of the dual formulation is that for specific feature maps, evaluation of the kernel matrix components does not require explicit assessment of the inner product of two feature vectors (which might be infinite-dimensional after the feature map transformation).\n", "\n", - "See reference [[1](#learning)]." + "\n", + "The quantum version of SVM is based on the dual optimization problem, where the main innovation is that a quantum computer can perform unitary feature transformations by applying quantum circuits and evaluate the inner product between transformed states by specified measurements. " ] }, { "cell_type": "markdown", - "id": "1", + "id": "4", + "metadata": {}, + "source": [ + "## QSVM Algorithms" + ] + }, + { + "cell_type": "markdown", + "id": "5", + "metadata": {}, + "source": [ + "The QSVM training algorithm includes three-steps.\n", + "1. Data loading of the classical data and feature map transformation.\n", + "2. Evaluation of the overlap between two feature states.\n", + "3. Classical optimization procedure, optimizing the circuit control parameters and modification of the feature map transformation.\n", + "\n", + "\n", + "\n", + "**Step 1:** The mapping of a classical data $\\mathbf{x}$ into a quantum feature state involves loading or encoding the data into a quantum state $$ |{0}^n\\rangle \\xrightarrow{U_{DE}(\\mathbf{x})} |\\mathbf{x}\\rangle ~~.$$ Various popular transformations exist, for example: basis, amplitude, angle, and dense encoding. The possible approaches showcase a general tradeoff between the number of qubits required to encode the classical data and the circuit depth. Generally, highly entangled states allow encoding more classical data utilizing fewer qubit, while requiring deeper circuits.\n", + "Following, a unitary feature operation maps the encoded state to a quantum feature state $$ |{\\mathbf{x}}^n\\rangle \\xrightarrow{U_{\\phi}(\\mathbf{x})} |\\phi(\\mathbf{x})\\rangle ~~.$$ \n", + "The two transformations can be combined to a single unitary transformation $U(\\mathbf{x}) = U_{\\phi}(\\mathbf{x})U_{DC}(\\mathbf{x})$, dependent on the classical data point $\\mathbf{x}$.\n", + "\n", + "**Step 2:** \n", + "The overlap between two feature vectors $\\phi(\\mathbf{x}_i)$ and $\\phi(\\mathbf{x}_j)$ is performed by applying the circuit $$U_{\\text{QSVM}}(\\mathbf{x_i}) = U^{\\dagger}(\\mathbf{x}_i)U(\\mathbf{x}_j)$$ to the initial state $|0^n\\rangle$ and measuring in the probability to measure $0^n$. The expected probability, $P_{|0^n\\rangle}=| \\langle \\phi (\\mathbf{x}_i)| \\phi(\\mathbf{x}_j) \\rangle|^2$ provides the elements of the kernel matrix $$K(\\mathbf{x}_i,\\mathbf{x}_j) = \\langle \\phi (\\mathbf{x}_i)| \\phi(\\mathbf{x}_j) \\rangle~~. $$ \n", + "\n", + "\n", + "**Step 3:**\n", + "Optimize the dual problem using a classical optimization algorithm. The SVM optimization problem is a quadratic programming problem (a specific case of a convex optimization problem), for which several exact or approximate solution methods exist, such as active-set, interior point, and gradient/projection-based methods. \n", + "\n", + "\n", + "**Prediction:**\n", + "For a new data point $\\mathbf{s}$, the kernel matrix of the new datum is evaluated with respect the optimized $\\{\\alpha_i\\}$\n", + "$$\\text{Predicted Labels}(\\mathbf{x}) = \\text{sign}(\\sum_{i=1}^m y_i \\alpha_i K(\\mathbf{x}_i,\\mathbf{s})+b)~~. \\tag{1}$$" + ] + }, + { + "cell_type": "markdown", + "id": "6", + "metadata": {}, + "source": [ + "## QSVM with Classiq\n", + "\n", + "We consider two kinds of 2D data sets:\n", + "- A \"simple\" data set, constructed by randomly distributing points around two source data points. This data set enables a straightforward linear classification of the data by the introduction of a separating line (hyperplane in 2D) and constitutes a simple preliminary example.\n", + "- A more complex data set, generated by qiskit's `ad_hoc_data` function. This is a special type of dataset that requires a highly nonlinear transformation to classify the data. Specifically, it can be accurately classified by a Pauli transformation map.\n", + "\n", + "The data sets are classified utilizing two feature maps: the Bloch Sphere and Pauli maps.\n", + "\n", + "From these data sets and feature maps, we construct exemplary examples.\n", + "\n", + "1. In the first example, we generate \"simple\" artificial training, test, and prediction data sets (defined points in the data space). A Bloch sphere transformation is employed as a feature map, allowing perfect classification of the data. The model is trained, tested, and then used for predictions of the labels of the prediction data set.\n", + "\n", + "2. The second examples involve classifying the `ad_hoc_data` by application of both the Bloch sphere and Pauli mappings. The Pauli transformation can accurately classify the data, while the Bloch sphere mapping manages to classify approximately half of the test and prediction data sets.\n", + "\n", + "The examples emphasize the importance of tailoring the chosen feature map to the specific data set." + ] + }, + { + "cell_type": "markdown", + "id": "7", + "metadata": {}, + "source": [ + "### Example 1: Bloch Sphere Feature Map Applied to Linearly Classifiable Data" + ] + }, + { + "cell_type": "markdown", + "id": "8", "metadata": {}, "source": [ - "## Coding QSVM\n", "We start coding with the relevant imports:" ] }, { "cell_type": "code", - "execution_count": null, - "id": "2", + "execution_count": 1, + "id": "9", "metadata": {}, "outputs": [], "source": [ - "!pip install -qq -U \"classiq[qml]\"" + "# Uncomment to instal Classiq's QML packages\n", + "#!pip install -qq -U \"classiq[qml]\"\n", + "\n", + "# Uncomment to install qiskit-algorithms package\n", + "#!pip install qiskit-algorithms\n", + "\n", + "# Uncomment to install qiskit-machine-learning package\n", + "#!pip install qiskit-machine-learning\n", + "\n", + "# Uncomment to install the scikit learn package\n", + "#!pip install scikit-learn" ] }, { "cell_type": "code", - "execution_count": 1, - "id": "3", + "execution_count": 2, + "id": "10", "metadata": {}, "outputs": [], "source": [ @@ -65,32 +173,49 @@ }, { "cell_type": "markdown", - "id": "4", + "id": "11", "metadata": {}, "source": [ - "Next, we generate data.\n", + "Next, we generate data. Three data sets are generated:\n", + "- Training data: labelled data utilized to train and optimize the algorithm parameters\n", + "- Test data: labelled data employed to evaluate the optimization process\n", + "- Prediction data: unlabelled data that the optimized algorithm predicts the corresponding classification labels.\n", + "\n", + "\n", "\n", "This example takes a 2D input space and a binary classification (i.e., only two groups of data points):" ] }, { "cell_type": "code", - "execution_count": 2, - "id": "5", + "execution_count": 3, + "id": "12", "metadata": {}, "outputs": [], "source": [ "import random\n", "\n", - "RANDOM_SEED = 0\n", - "random.seed(RANDOM_SEED)\n", - "np.random.seed(RANDOM_SEED)" + "seed = 0\n", + "random.seed(seed)\n", + "np.random.seed(seed)" + ] + }, + { + "cell_type": "markdown", + "id": "13", + "metadata": {}, + "source": [ + "In the data generation we utilize a number of utility functions:\n", + "\n", + "- `generate_data`: given two `sources` points and outputs a python dictionary with the training data points (random points within the vicinity of the sources). \n", + "\n", + "- `data_dict_to_data_and_labels`: given a generated data dictionary, outputs the input data and associated labels.\n" ] }, { "cell_type": "code", - "execution_count": 3, - "id": "6", + "execution_count": 4, + "id": "14", "metadata": {}, "outputs": [], "source": [ @@ -113,23 +238,27 @@ }, { "cell_type": "markdown", - "id": "7", + "id": "15", "metadata": {}, "source": [ - "Now we plot the data.\n", + "To get a better understanding of the classification task at hand, we plot the data.\n", "\n", "Note that the data is expected to be normalized to within $ 0 $ to $ 2 \\pi $." ] }, { "cell_type": "code", - "execution_count": 4, - "id": "8", - "metadata": {}, + "execution_count": 35, + "id": "16", + "metadata": { + "jupyter": { + "source_hidden": true + } + }, "outputs": [ { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAhYAAAGzCAYAAABzfl4TAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy81sbWrAAAACXBIWXMAAA9hAAAPYQGoP6dpAAAwDklEQVR4nO3df3RU9Z3/8ddkIAlIMkAAk5QYEK0SI8gPwwGKIoLCF7Hqd1ERaqSu3VIQIWvXL7v9Glh3DdbWRXowKlWoRVRKi4AtoQqCdoUi5GQL5lsVDD+qgSjgJASZYOZ+/0gnMiQhM5N7586deT7OmZPOzZ2575mq95XPT5dhGIYAAABMkGR3AQAAIH4QLAAAgGkIFgAAwDQECwAAYBqCBQAAMA3BAgAAmIZgAQAATEOwAAAApiFYAAAA0xAsgDjWr18/3XfffRG9duzYsRo7dqyp9XSUy+XSwoUL7S4DwAUQLAAbvffee1q4cKG+/PJLu0uJa5WVlVq4cKEOHjxodylA3OtkdwFAInvvvfe0aNEi3Xffferevbvp7//hhx8qKSmyvx/++Mc/mlyNfSorK7Vo0SKNHTtW/fr1s7scIK4RLACH8Pv9amhoUGpqasivSUlJifh6ycnJEb8WQOKiKwSwycKFC/XjH/9YktS/f3+5XC65XK7m5nqXy6U5c+bo5Zdf1lVXXaWUlBSVlZVJkn72s59p1KhRysjIUJcuXTRs2DCtXbu2xTXOH2OxcuVKuVwu/fd//7eKiorUu3dvXXTRRbr99tv1+eefB732/DEW27Ztk8vl0po1a/Sf//mf6tu3r1JTU3XjjTdq//79La69bNkyXXrpperSpYsKCgr07rvvhjxuw+fzaf78+erdu7fS0tJ066236m9/+1uL8w4dOqQf/ehHuuKKK9SlSxdlZGRo6tSpQV0eK1eu1NSpUyVJN9xwQ/P3vG3bNknS+vXrNXnyZGVnZyslJUUDBgzQY489psbGxnbrBNASLRaATe644w599NFHeuWVV/Rf//Vf6tWrlySpd+/ezeds3bpVa9as0Zw5c9SrV6/mZvynn35at956q6ZPn66Ghga9+uqrmjp1qt544w1Nnjy53Ws/+OCD6tGjh4qLi3Xw4EEtWbJEc+bM0WuvvdbuaxcvXqykpCQ9/PDD8nq9+ulPf6rp06frz3/+c/M5paWlmjNnjsaMGaP58+fr4MGDuu2229SjRw/17du33Wv84z/+o1atWqV77rlHo0aN0tatW1v9XO+//77ee+893X333erbt68OHjyo0tJSjR07VpWVleratauuu+46zZ07V0uXLtW//uu/auDAgZLU/HPlypXq1q2bioqK1K1bN23dulWPPvqoamtr9eSTT7ZbK4DzGABs8+STTxqSjKqqqha/k2QkJSUZH3zwQYvfnT59Ouh5Q0ODkZ+fb4wbNy7oeG5urlFYWNj8fMWKFYYkY/z48Ybf728+Pn/+fMPtdhtffvll87Hrr7/euP7665ufv/3224YkY+DAgYbP52s+/vTTTxuSjL179xqGYRg+n8/IyMgwrr32WuPs2bPN561cudKQFPSeramoqDAkGT/60Y+Cjt9zzz2GJKO4uLjN78EwDGPHjh2GJOOll15qPvab3/zGkGS8/fbbLc5v7T3+6Z/+yejatatx5syZC9YKoCW6QoAYdv311ysvL6/F8S5dujT/75MnT8rr9WrMmDEqLy8P6X1/8IMfyOVyNT8fM2aMGhsbdejQoXZfO3PmzKDxF2PGjJEkffLJJ5Kk3bt36/jx43rggQfUqdM3jaLTp09Xjx492n3/P/zhD5KkuXPnBh2fN29ei3PP/R7Onj2r48eP67LLLlP37t1D/i7OfY+6ujp98cUXGjNmjE6fPq2//vWvIb0HgG/QFQLEsP79+7d6/I033tB//Md/qKKiQj6fr/n4uWHhQi655JKg54Eb/smTJzv82kA4ueyyy4LO69SpU0gzMg4dOqSkpCQNGDAg6PgVV1zR4tyvvvpKJSUlWrFihT799FMZhtH8O6/X2+61JOmDDz7QT37yE23dulW1tbVBvwv1PQB8g2ABxLBz/5oOePfdd3Xrrbfquuuu0zPPPKOsrCx17txZK1as0OrVq0N6X7fb3erxc2/MVrzWbA8++KBWrFihefPmaeTIkfJ4PHK5XLr77rvl9/vbff2XX36p66+/Xunp6fr3f/93DRgwQKmpqSovL9cjjzwS0nsACEawAGwUagvDuX77298qNTVVmzdvDppOumLFCjNLi1hubq4kaf/+/brhhhuaj3/99dc6ePCgBg0a1O7r/X6/Dhw4ENRK8eGHH7Y4d+3atSosLNTPf/7z5mNnzpxpseBYW9/ztm3bdPz4cf3ud7/Tdddd13y8qqrqgjUCaBtjLAAbXXTRRZIU1sqbbrdbLpcraDrkwYMH9frrr5tcXWSGDx+ujIwMLV++XF9//XXz8ZdffjmkrpZJkyZJkpYuXRp0fMmSJS3OdbvdLVpKfvGLX7SYKtrW9xxofTn3PRoaGvTMM8+0WyeA1tFiAdho2LBhkqR/+7d/0913363OnTtrypQpzTfC1kyePFlPPfWUJk6cqHvuuUc1NTVatmyZLrvsMv3lL3+JVultSk5O1sKFC/Xggw9q3LhxuvPOO3Xw4EGtXLlSAwYMaLeV5pprrtG0adP0zDPPyOv1atSoUdqyZUura2Xccsst+vWvfy2Px6O8vDzt2LFDb731ljIyMlq8p9vt1hNPPCGv16uUlBSNGzdOo0aNUo8ePVRYWKi5c+fK5XLp17/+tS3dOkC8oMUCsNG1116rxx57TP/zP/+j++67T9OmTWuxUNX5xo0bpxdeeEFHjx7VvHnz9Morr+iJJ57Q7bffHqWq2zdnzhwtXbpUhw8f1sMPP6x3331XGzZsUPfu3UNaOfTFF1/U3LlzVVZWpn/5l3/R2bNn9fvf/77FeU8//bTuvfdevfzyy/rnf/5nVVdX66233lK3bt2CzsvMzNSzzz6rmpoa3X///Zo2bZoqKyuVkZGhN954Q1lZWfrJT36in/3sZ5owYYJ++tOfmvZdAInGZRDNAUSB3+9X7969dccdd2j58uV2lwPAIrRYADDdmTNnWnQnvPTSSzpx4kTMbcUOwFy0WAAw3bZt2zR//nxNnTpVGRkZKi8v1wsvvKCBAwdqz549bHAGxDEGbwIwXb9+/ZSTk6OlS5fqxIkT6tmzp+69914tXryYUAHEOVosAACAaRhjAQAATEOwAAAApon6GAu/36/PPvtMaWlpES1nDAAAos8wDNXV1Sk7O1tJSW23S0Q9WHz22WfKycmJ9mUBAIAJjhw5or59+7b5+6gHi7S0NElNhaWnp0f78gAAIAK1tbXKyclpvo+3JerBItD9kZ6eTrAAAMBh2hvGwOBNAABgGoIFAAAwDcECAACYhiW9AQAIgWEY+vrrr9XY2Gh3KZZwu93q1KlTh5eCIFgAANCOhoYGVVdX6/Tp03aXYqmuXbsqKyurQ3v6ECwAALgAv9+vqqoqud1uZWdnKzk5Oe4WeDQMQw0NDfr8889VVVWlyy+//IKLYF0IwQIAgAtoaGiQ3+9XTk6Ounbtanc5lunSpYs6d+6sQ4cOqaGhQampqRG9D4M3AQAIQaR/wTuJGZ8x/r8lAAAQNWEHi08//VQzZsxQRkaGunTpoquvvlq7d++2ojYAAOAwYY2xOHnypEaPHq0bbrhBmzZtUu/evfXxxx+rR48eVtUHAAAcJKwWiyeeeEI5OTlasWKFCgoK1L9/f910000aMGCAVfUBAIAOWLZsmfr166fU1FSNGDFCu3btsvR6YQWLDRs2aPjw4Zo6dar69OmjIUOGaPny5Rd8jc/nU21tbdADAIBE0+g3tOPAca2v+FQ7DhxXo9+w/JqvvfaaioqKVFxcrPLycg0ePFg333yzampqLLtmWMHik08+UWlpqS6//HJt3rxZs2bN0ty5c/WrX/2qzdeUlJTI4/E0P3JycjpcNAAATlK2r1rfeWKrpi3fqYderdC05Tv1nSe2qmxftaXXfeqpp/TAAw9o5syZysvL07PPPquuXbvqxRdftOyaYQULv9+voUOH6vHHH9eQIUP0gx/8QA888ICeffbZNl+zYMECeb3e5seRI0c6XDQAAE5Rtq9as1aVq9p7Juj4Ue8ZzVpVblm4aGho0J49ezR+/PjmY0lJSRo/frx27NhhyTWlMINFVlaW8vLygo4NHDhQhw8fbvM1KSkpSk9PD3oAiEH+RqnqXWnv2qaf/vjcDwGIpka/oUUbK9Vap0fg2KKNlZZ0i3zxxRdqbGzUxRdfHHT84osv1tGjR02/XkBYs0JGjx6tDz/8MOjYRx99pNzcXFOLAhBllRukskek2s++OZaeLU18Qsq71b66AIfbVXWiRUvFuQxJ1d4z2lV1QiMHZESvMAuF1WIxf/587dy5U48//rj279+v1atX6/nnn9fs2bOtqg+A1So3SGvuDQ4VklRb3XS8coM9dQFxoKau7VARyXnh6NWrl9xut44dOxZ0/NixY8rMzDT9egFhBYtrr71W69at0yuvvKL8/Hw99thjWrJkiaZPn25VfQCs5G9saqm4UENt2f+hWwSIUJ+00PbbCPW8cCQnJ2vYsGHasmVL8zG/368tW7Zo5MiRpl8vIOxNyG655RbdcsstVtQCINoOvdeypSKIIdV+2nRe/zFRKwuIFwX9eyrLk6qj3jOtxneXpExPqgr697Tk+kVFRSosLNTw4cNVUFCgJUuWqL6+XjNnzrTkehK7mwKJ7dSx9s8J5zwAQdxJLhVPydOsVeVyKbhtMLDxevGUPLmTrNmG/a677tLnn3+uRx99VEePHtU111yjsrKyFgM6zcQmZEAi6xbif1xCPQ9ACxPzs1Q6Y6gyPcHdHZmeVJXOGKqJ+VmWXn/OnDk6dOiQfD6f/vznP2vEiBGWXo8WCyCR5Y5qmv1RW63Wx1m4mn6fOyralQFxZWJ+libkZWpX1QnV1J1Rn7Sm7g+rWirsRLAAElmSu2lK6Zp7pbYaaicubjoPQIe4k1xxM6X0QugKARJd3q3SnS9J6ec1x6ZnNx1nHQsAYaDFAkBTeLhyctPsj1PHmsZU5I6ipQJA2AgWAJokuZlSCqDDCBZAPPE30uoAwFYECyBesN8HgBjA4E0gHrDfB4AYQbAAnI79PgDEEIIF4HTh7PcBABYjWABOx34fgDP4G6Wqd6W9a5t+RqEV8Z133tGUKVOUnZ0tl8ul119/3fJrMngTcDr2+wBin02Dq+vr6zV48GB9//vf1x133GHZdc5FsACcjv0+gNgWGFx9/r+fgcHVFq5wO2nSJE2aNMmS924LXSGA0wX2+5D0zUbMCn6eaPt92NDkDLQqAQdX02IBxIPAfh+tNrUujv46FnYu1MV6Hogl4QyujpOVbwkWQLyIlf0+7Lyx29jkDLQqAQdX0xUCxJPAfh9X/0PTTztChV0LdSVgkzMcIAEHVxMsAJjD7hs763kgFgUGV7cY/xTgktK/FVeDqwkWAMxh9409AZuc4QA2D64+deqUKioqVFFRIUmqqqpSRUWFDh8+bMn1JIIFALPYfWNPwCZnOERgcHV6VvDx9GzLx/3s3r1bQ4YM0ZAhQyRJRUVFGjJkiB599FHLrsngTQDmsPvGznoeiGU2Da4eO3asDKO1fx+sQ7AA0KSjU0TtvrEHmpzX3Nt0raAaEnQ9D8SWwODqOEewAGDOFFGzb+yRBJ1YW88DSEAECyDRmbn2g1k39o4EnVhZzwNIUAQLIJG1O0XUJW16REr1SPWfh3aT7uiN3YygkyBNzkAsIlgAiSyUKaJ1n0kvnXMjD7QcXCg8RHpjDyXolP2fpmvTAoEoi/YgSDuY8RkJFkAii2TqZ221tOZ7Upce0lcnvzluxrLdCbivAmJf586dJUmnT59Wly5dbK7GWqdPn5b0zWeOBMECSGQRTf38+18054YKyZz9OOxeCwNohdvtVvfu3VVTUyNJ6tq1q1yutlbSdCbDMHT69GnV1NSoe/fucrsjbxEkWACJrN0pouEwoavC7rUwgDZkZmZKUnO4iFfdu3dv/qyRIlgAieyCU0Qj0cGuCrvXwgDa4HK5lJWVpT59+ujs2bN2l2OJzp07d6ilIoBgASS6tqaIdkSkXRUscoUY53a7Tbn5xjOCBYCWU0S79pLWz4q8i6QjXRUscgU4GsECQJPzp4hG1EViUlcFi1wBjkWwANC6tloOuvSUvjohy7sqWOQKcCSCBYC2tdVy8Nff01UBoFUECyARhbPBV2stB3RVAGgDwQJINGbsZCrRVQGgVUl2FwAkLH+jVPWutHdt009/o/XXDGzwdf600sCqmZUbrK8BQFyjxQKwg1mtBuEIZ4MviW4OABEhWADRZsa24JEIdYOvd34mla+MbugBEDfoCgGiqd1WAzW1GljRLRLqapjbHqerBEDECBZANIWzLbjZOrRxl8WhB0DcIFgA0WTntuCBDb4U6XbPFoYeAHGDYAFEk53bggc2+JLUMlyEETasCD2SPbNkAJiOYAFEU7utBi4p/VvWbQseWKY7PSv4eHq2NPZfQ3sPK0JP5QZpSb70q1uk397f9HNJPmM6AAdiVggQTbGwLXhbq2ZKf58N0taOpiZtMHY+u2bJALBEWC0WCxculMvlCnpceeWVVtUGxKcLtRqEehPtaLdBYNXMq/+h6WeSO7SuErNDTyizZN6YL/1lDd0jgEOE3WJx1VVX6a233vrmDTrR6AGErSN7bVi5uFZbO5patcFYKLNkTn8h/e6Bc+pgPQ0gloWdCjp16qTMzEwragESSyR7bUSj2yCaG4yFOxCU7hEg5oU9ePPjjz9Wdna2Lr30Uk2fPl2HDx++4Pk+n0+1tbVBDwARiObiWq11lVgh7IGgrKcBxLqwgsWIESO0cuVKlZWVqbS0VFVVVRozZozq6urafE1JSYk8Hk/zIycnp8NFAzHLyimTdi6uZZWI1tZw4OcEEojLMIzW/vwJyZdffqnc3Fw99dRTuv/++1s9x+fzyefzNT+vra1VTk6OvF6v0tPTI700EHus3lhs79qmqZjt+d8vNLU0OEVz947UemtMG5z2OQGHq62tlcfjaff+3aF1LLp3765vf/vb2r9/f5vnpKSkKD09PegBxJ1obEdu5+JaHXWhlpy2Zsm0JxY/J4COrWNx6tQpHThwQN/73vfMqgdwnlDGPmycK6V6pH7fiXy8QqDbINrrTHRUKC055w4YratuGkNx+ngbbxijnxOApDBbLB5++GFt375dBw8e1Hvvvafbb79dbrdb06ZNs6o+IPa1O/ZB0lcnpZdu7dhqknasM9FR4bTkBAaMDrpTumWJmj6TQz4ngGZhBYu//e1vmjZtmq644grdeeedysjI0M6dO9W7d2+r6gNiXzhTJjvaNWLG4lrR0pFZLE76nACCdGjwZiRCHfwBOEbVu017W4Ts70358/ZG/le3vzE660x0RKjfS+Ebba/n4YTPCSSIUO/fLJsJdFS7Yx/Od850yXAXyAqIZHGtaDNji3gnfE4AQdjdFOioC459uACrth+PFU6exQIgYgQLwAyRTJmM9xuq3VvEA7AFwQIwS96t0rx90vfWS116XODEBLmhOnEWC4AOI1gAZkpySwPGSlOWiumSYnYHkICYFQJYpdWFob4V/vbj8TAzIh4+A5DgmBUC2M2M7cet3n8kWpjdASQMggVgpY7cUJs35zqvUTGwyBZdCQBiEGMsgFjUkVUrAcBGBAsgFrW7/8g5i2wBQAwhWACxyIxVKwHABgQLIBaxaiUAhyJYALGIVSsBOBTBAohFrFoJwKEIFkCsYtVKAA7EOhZALDNjkS0AiCKCBRDrWLUSgIMQLIBYxN4aAByKYAHEmnjZHwRAQmLwJhBLAvuDnL/qZmB/kMoN9tQFACEiWACxgv1B4G+Uqt6V9q5t+sn/13AgukKAWBHO/iAM5ow/dIEhTtBiAcQK9gdJXHSBIY4QLIBYwf4giYkuMMQZggUQK9gfJDGF0wUGOADBAogV7A+SmOgCQ5whWACxhP1BEg9dYIgzzAoBYg37gySWQBdYbbVaH2fhavo9XWBwCIIFEIvYHyRxBLrA1tyrpi6vc8MFXWBwHrpCAMBudIEhjtBiAQCxgC4wxAmCBQDECrrAEAfoCgEAAKYhWAAAANMQLAAAgGkIFgAAwDQECwAAYBqCBQAAMA3BAgAAmIZgAQAATEOwAAAApiFYAAAA0xAsAACAaQgWAADANAQLAABgGoIFAAAwDcECAACYhmABAABM06FgsXjxYrlcLs2bN8+kcgAAgJNFHCzef/99Pffccxo0aJCZ9QAAAAeLKFicOnVK06dP1/Lly9WjRw+zawIAAA4VUbCYPXu2Jk+erPHjx7d7rs/nU21tbdADAADEp07hvuDVV19VeXm53n///ZDOLykp0aJFi8IuDAAAOE9YLRZHjhzRQw89pJdfflmpqakhvWbBggXyer3NjyNHjkRUKAAAiH0uwzCMUE9+/fXXdfvtt8vtdjcfa2xslMvlUlJSknw+X9DvWlNbWyuPxyOv16v09PTIKwcAAFET6v07rK6QG2+8UXv37g06NnPmTF155ZV65JFH2g0VAAAgvoUVLNLS0pSfnx907KKLLlJGRkaL4wAAIPGw8iYAADBN2LNCzrdt2zYTygAAAPGAFgsAAGAaggUAADANwQIAAJiGYAEAAExDsAAAAKYhWAAAANMQLAAAgGkIFgAAwDQECwAAYBqCBQAAMA3BAgAAmIZgAQAATEOwAAAApiFYAAAA0xAsAACAaQgWAADANAQLAABgGoIFAAAwDcECAACYhmABAABMQ7AAAACmIVgAAADTECwAAIBpCBYAAMA0BAsAAGAaggUAADANwQIAAJiGYAEAAExDsAAAAKYhWAAAANMQLAAAgGkIFgAAwDQECwAAYBqCBQAAMA3BAgAAmIZgAQAATEOwAAAApiFYAAAA0xAsAACAaQgWAADANAQLAABgGoIFAAAwDcECAACYhmABAABMQ7AAAACmIVgAAADTECwAAIBpCBYAAMA0YQWL0tJSDRo0SOnp6UpPT9fIkSO1adMmq2oDAAAOE1aw6Nu3rxYvXqw9e/Zo9+7dGjdunL773e/qgw8+sKo+AADgIC7DMIyOvEHPnj315JNP6v777w/p/NraWnk8Hnm9XqWnp3fk0gAAIEpCvX93ivQCjY2N+s1vfqP6+nqNHDmyzfN8Pp98Pl9QYQAAID6FPXhz79696tatm1JSUvTDH/5Q69atU15eXpvnl5SUyOPxND9ycnI6VDAAAIhdYXeFNDQ06PDhw/J6vVq7dq1++ctfavv27W2Gi9ZaLHJycugKAQDAQULtCunwGIvx48drwIABeu6550wtDAAAxA7Lx1gE+P3+oBYJwOka/YZ2VZ1QTd0Z9UlLVUH/nnInuewuCwAcIaxgsWDBAk2aNEmXXHKJ6urqtHr1am3btk2bN2+2qj4gqsr2VWvRxkpVe880H8vypKp4Sp4m5mfZWBkAOENYwaKmpkb33nuvqqur5fF4NGjQIG3evFkTJkywqj4gasr2VWvWqnKd3zd41HtGs1aVq3TGUMIFALQjrGDxwgsvWFUHYKtGv6FFGytbhApJMiS5JC3aWKkJeZl0iwDABbBXCCBpV9WJoO6P8xmSqr1ntKvqRPSKAgAHIlgAkmrq2g4VkZwHAImKYAFI6pOWaup5AJCoCBaApIL+PZXlSVVboydcapodUtC/ZzTLAgDHIVgAktxJLhVPaVo99vxwEXhePCWPgZsA0A6CBfB3E/OzVDpjqDI9wd0dmZ5UppoCQIg6vPImEE8m5mdpQl4mK28CQIQIFsB53EkujRyQYXcZAOBIdIUAAADTECwAAIBpCBYAAMA0BAsAAGAaggUAADANwQIAAJiGYAEAAExDsAAAAKYhWAAAANMQLAAAgGlY0jvONfoN9r0AAEQNwSKOle2r1qKNlar2nmk+luVJVfGUPHbqBABYgq6QOFW2r1qzVpUHhQpJOuo9o1mrylW2rzqi9230G9px4LjWV3yqHQeOq9FvmFEuACBO0GIRhxr9hhZtrFRrt3xDkkvSoo2VmpCXGVa3CC0gAID20GIRh3ZVnWjRUnEuQ1K194x2VZ0I+T2tagEBAMQXgkUcqqlrO1REcl57LSBSUwsI3SIAAIJFHOqTlmrqeVa0gAAA4hPBIg4V9O+pLE+q2ho94VLT2IiC/j1Dej+zW0AAAPGLYBGH3EkuFU/Jk6QW4SLwvHhKXsgDN81uAQEAxC+CRZyamJ+l0hlDlekJvtlnelJVOmNoWLM4zG4BiRamxgJA9DHdNM6cv9Lm9h/foD2HTnZo5c1AC8isVeVySUGDOCNpAYkGpsYCgD1chmFE9c+42tpaeTweeb1epaenR/PScc/qm6lTbtaBqbHn/4MdiD3httgAAEK/fxMs4kS0bqaxvvdIo9/Qd57Y2uYsFpeauoP+9Mi4mKobAGJdqPdvukLigFUrbbbGneTSyAEZHXoPK4UzNTaWPwcAOBWDN+MA60x8g6mxAGAvgkUc4Gb6DabGAoC9CBZxgJvpN5w6NRYA4gXBIg5wM/2G2YuDAQDCQ7CIA9xMg5m5OBgAIDxMN40jTllnojVWTGON9amxAOAkrGORoJx4M3VyIAKAREGwgCOwSiYAOEOo92/GWMA27S3sJTUt7MXmYQDgHAQL2IaFvQAg/hAsYBsW9gKA+EOwgG1Y2AsA4g+bkCEsZs46CSzsddR7ptVxFoGdSBNhYS8AiBcEC4TM7GmhgYW9Zq0ql0sKCheJuLAXAMQDukIQksC00PMHWx71ntGsVeUq21cd0fuySiYAxBdaLNCu9qaFutQ0LXRCXmZErQsT87M0IS/TcQt7AQBaCqvFoqSkRNdee63S0tLUp08f3Xbbbfrwww+tqg0xIhrTQt1JLo0ckKHvXvMtjRyQQagAAIcKK1hs375ds2fP1s6dO/Xmm2/q7Nmzuummm1RfX29VfYgBTAsFAIQqrK6QsrKyoOcrV65Unz59tGfPHl133XWmFobYwbRQAECoOjTGwuv1SpJ69mx7OqDP55PP52t+Xltb25FLwgZMCwUAhCriWSF+v1/z5s3T6NGjlZ+f3+Z5JSUl8ng8zY+cnJxILwmbBKaFSt9MAw2IxWmhjX5DOw4c1/qKT7XjwHH2GgGAKIp4d9NZs2Zp06ZN+tOf/qS+ffu2eV5rLRY5OTnsbupATtje3Ak1AoATWbpt+pw5c7R+/Xq988476t+/vyWFITaZufKm2diCHQCsE+r9O6wxFoZh6MEHH9S6deu0bdu2sEMFnC8wLTTWWL3WBgAgNGGNsZg9e7ZWrVql1atXKy0tTUePHtXRo0f11VdfWVUfEBK2YAeA2BBWsCgtLZXX69XYsWOVlZXV/Hjttdesqg8ICWttAEBsCLsrBPGnvXETsTyuIoC1NgAgNrBXSIJrbxaFU2ZZsNYGAMQGdjdNYO3tWFryh0pLdjS1gtPW2gCAeEWwSFDtzaIwJC1/t6rN30tNsyxiafEptmAHAPvRFZKg2ptFIUkXygznzrLo6PRTM8dwsAU7ANiLYJGgzJod0dH3sWIMR6yutQEAiYCukARl1uyIjrxPe2M8YmkMBwAgNASLBBWYRXGhDoIkV8uBkAEuNbUsRDrLor0xHlLsjeEAALSPYJGg2ptF4ZL0wJj+bf5e6tgsC1bKBID4RLBIYO3Noljwv/Ism2XBSpkAEJ8YvBmnQp1p0d4sCqtmWbBSJgDEJ4JFHAp3pkV7syismGXBSpkAEJ/oCokzTplpwUqZABCfCBZxxGkzLVgpEwDiD10hURKNHULDmWkRKwtIsVImAMQXgkUURGuH0GjNtDA7JLFSJgDED4KFxQJjHs7vfAiMeTCzyd+KmRbnh4iT9T499vv/F/PbqAMA7EGwsFB7Yx5cahrzMCEv05Smf7NnWrTW0tIaK0ISAMCZGLxpoWivLmnmTIu2Zpe0JhYHhgIA7EGwsJAdq0uaMdPiQi0tbWEJbgCARFeIpexaXbKjMy3aa2m5EJbgBoDERrCwkJ2rS3ZkpkVHwgFLcANAYqMrxEJOXV0yknDQ0W3UAQDxgWBhMSeuLhloaQk17sRySAIARJfLMIyoDuOvra2Vx+OR1+tVenp6NC9tq2isvGmmwKwQSe0O4mQdCwCIf6HevwkWaFNbK4b+38l56nFRsmNCEgCg40K9fzN4E21iHw8AQLgIFrgg9vEIj9O6vADAbAQLwCTR2mwOAGIZs0IAE7S1BHpgH5WyfdU2VQYA0UWwADqovc3mJPZRAZA4CBaIika/oR0Hjmt9xafaceB4XN1ko73ZHADEMsZYwHLxPvbAjs3mACBW0WIBSyXC2AO7NpsDgFhEsIBlEmXsQXtLoLOPCoBEQrCAZRJl7IFTN5sDACsQLGCZRBp74MTN5gDACgzehGUSbewBS6ADAMECFgqMPTjqPdPqOAuXmv6ij6exByyBDiDR0RUCyzD2AAASD8EClmLsAQAkFrpCYDnGHgBA4iBYICoYewAAiYGuEAAAYBqCBQAAMA3BAgAAmIZgAQAATEOwAAAApmFWiAUa/QZTKwEACSnsYPHOO+/oySef1J49e1RdXa1169bptttus6A0ZyrbV61FGyuDdvXM8qSqeEoei0EBAOJe2F0h9fX1Gjx4sJYtW2ZFPY5Wtq9as1aVt9gq/Kj3jGatKlfZvmqbKgMAIDrCbrGYNGmSJk2aFPL5Pp9PPp+v+XltbW24l3SERr+hRRsrW91sy1DT3hiLNlZqQl4m3SIAgLhl+eDNkpISeTye5kdOTo7Vl7TFrqoTLVoqzmVIqvae0a6qE9ErCgCAKLM8WCxYsEBer7f5ceTIEasvaYuaurZDRSTnAQDgRJbPCklJSVFKSorVl7Fdn7TU9k8K4zwAAJyIdSxMUtC/p7I8qWpr9IRLTbNDCvr3jGZZAABEFcHCJO4kl4qn5ElSi3AReF48JY+BmwCAuBZ2sDh16pQqKipUUVEhSaqqqlJFRYUOHz5sdm2OMzE/S6UzhirTE9zdkelJVemMoaxjAQCIey7DMFqbIdmmbdu26YYbbmhxvLCwUCtXrmz39bW1tfJ4PPJ6vUpPTw/n0o7BypsAgHgT6v077MGbY8eOVZhZJOG4k1waOSDD7jIAAIg6xlgAAADTECwAAIBpCBYAAMA0bJsOBpsCAExDsEhwbPMOADATXSEJjG3eAQBmI1gkqPa2eZeatnlv9DO1GAAQOoJFgmKbdwCAFQgWCYpt3gEAViBYJCi2eQcAWIFgkaDY5h0AYAWCRYJim3cAgBUIFgmMbd4BAGZjgawENzE/SxPyMll5EwBgCoIF2OYdAGAaukIAAIBpCBYAAMA0BAsAAGAaggUAADANwQIAAJiGWSFIeI1+g+m2AGASggUSWtm+ai3aWBm002uWJ1XFU/JYIAwAIkBXCBJW2b5qzVpV3mL7+KPeM5q1qlxl+6ptqgwAnItggYTU6De0aGOljFZ+Fzi2aGOlGv2tnQEAaAvBAglpV9WJFi0V5zIkVXvPaFfViegVBQBxgGCBhFRT13aoiOQ8AEATggUSUp+01PZPCuM8AEATggUSUkH/nsrypKqtSaUuNc0OKejfM5plAYDjESyQkNxJLhVPyZOkFuEi8Lx4Sh7rWQBAmAgWSFgT87NUOmOoMj3B3R2ZnlSVzhjKOhYAEAEWyEJCm5ifpQl5may8CQAmIVgg4bmTXBo5IMPuMgAgLtAVAgAATEOwAAAApiFYAAAA0xAsAACAaQgWAADANAQLAABgGoIFAAAwDcECAACYhmABAABMQ7AAAACmIVgAAADTECwAAIBpCBYAAMA0BAsAAGAaggUAADBNRMFi2bJl6tevn1JTUzVixAjt2rXL7LoAAIADhR0sXnvtNRUVFam4uFjl5eUaPHiwbr75ZtXU1FhRHwAAcJCwg8VTTz2lBx54QDNnzlReXp6effZZde3aVS+++KIV9QEAAAfpFM7JDQ0N2rNnjxYsWNB8LCkpSePHj9eOHTtafY3P55PP52t+7vV6JUm1tbWR1AsAAGwQuG8bhnHB88IKFl988YUaGxt18cUXBx2/+OKL9de//rXV15SUlGjRokUtjufk5IRzaQAAEAPq6urk8Xja/H1YwSISCxYsUFFRUfPzL7/8Urm5uTp8+PAFC0NLtbW1ysnJ0ZEjR5Senm53OY7B9xY5vrvI8d1Fju8uclZ+d4ZhqK6uTtnZ2Rc8L6xg0atXL7ndbh07dizo+LFjx5SZmdnqa1JSUpSSktLiuMfj4R+YCKWnp/PdRYDvLXJ8d5Hju4sc313krPruQmkQCGvwZnJysoYNG6YtW7Y0H/P7/dqyZYtGjhwZfoUAACCuhN0VUlRUpMLCQg0fPlwFBQVasmSJ6uvrNXPmTCvqAwAADhJ2sLjrrrv0+eef69FHH9XRo0d1zTXXqKysrMWAzrakpKSouLi41e4RXBjfXWT43iLHdxc5vrvI8d1FLha+O5fR3rwRAACAELFXCAAAMA3BAgAAmIZgAQAATEOwAAAApiFYAAAA00Q1WCxbtkz9+vVTamqqRowYoV27dkXz8o71zjvvaMqUKcrOzpbL5dLrr79ud0mOUFJSomuvvVZpaWnq06ePbrvtNn344Yd2l+UIpaWlGjRoUPPqfSNHjtSmTZvsLsuRFi9eLJfLpXnz5tldSsxbuHChXC5X0OPKK6+0uyzH+PTTTzVjxgxlZGSoS5cuuvrqq7V79+6o1xG1YPHaa6+pqKhIxcXFKi8v1+DBg3XzzTerpqYmWiU4Vn19vQYPHqxly5bZXYqjbN++XbNnz9bOnTv15ptv6uzZs7rppptUX19vd2kxr2/fvlq8eLH27Nmj3bt3a9y4cfrud7+rDz74wO7SHOX999/Xc889p0GDBtldimNcddVVqq6ubn786U9/srskRzh58qRGjx6tzp07a9OmTaqsrNTPf/5z9ejRI/rFGFFSUFBgzJ49u/l5Y2OjkZ2dbZSUlESrhLggyVi3bp3dZThSTU2NIcnYvn273aU4Uo8ePYxf/vKXdpfhGHV1dcbll19uvPnmm8b1119vPPTQQ3aXFPOKi4uNwYMH212GIz3yyCPGd77zHbvLMAzDMKLSYtHQ0KA9e/Zo/PjxzceSkpI0fvx47dixIxolAPJ6vZKknj172lyJszQ2NurVV19VfX09ewKFYfbs2Zo8eXLQf/fQvo8//ljZ2dm69NJLNX36dB0+fNjukhxhw4YNGj58uKZOnao+ffpoyJAhWr58uS21RCVYfPHFF2psbGyx7PfFF1+so0ePRqMEJDi/36958+Zp9OjRys/Pt7scR9i7d6+6deumlJQU/fCHP9S6deuUl5dnd1mO8Oqrr6q8vFwlJSV2l+IoI0aM0MqVK1VWVqbS0lJVVVVpzJgxqqurs7u0mPfJJ5+otLRUl19+uTZv3qxZs2Zp7ty5+tWvfhX1WsLeKwRwotmzZ2vfvn3014bhiiuuUEVFhbxer9auXavCwkJt376dcNGOI0eO6KGHHtKbb76p1NRUu8txlEmTJjX/70GDBmnEiBHKzc3VmjVrdP/999tYWezz+/0aPny4Hn/8cUnSkCFDtG/fPj377LMqLCyMai1RabHo1auX3G63jh07FnT82LFjyszMjEYJSGBz5szRG2+8obffflt9+/a1uxzHSE5O1mWXXaZhw4appKREgwcP1tNPP213WTFvz549qqmp0dChQ9WpUyd16tRJ27dv19KlS9WpUyc1NjbaXaJjdO/eXd/+9re1f/9+u0uJeVlZWS1C/8CBA23pSopKsEhOTtawYcO0ZcuW5mN+v19btmyhzxaWMQxDc+bM0bp167R161b179/f7pIcze/3y+fz2V1GzLvxxhu1d+9eVVRUND+GDx+u6dOnq6KiQm632+4SHePUqVM6cOCAsrKy7C4l5o0ePbrFdPqPPvpIubm5Ua8lal0hRUVFKiws1PDhw1VQUKAlS5aovr5eM2fOjFYJjnXq1KmgxF5VVaWKigr17NlTl1xyiY2VxbbZs2dr9erVWr9+vdLS0prH83g8HnXp0sXm6mLbggULNGnSJF1yySWqq6vT6tWrtW3bNm3evNnu0mJeWlpai3E8F110kTIyMhjf046HH35YU6ZMUW5urj777DMVFxfL7XZr2rRpdpcW8+bPn69Ro0bp8ccf15133qldu3bp+eef1/PPPx/9YqI5BeUXv/iFcckllxjJyclGQUGBsXPnzmhe3rHefvttQ1KLR2Fhod2lxbTWvjNJxooVK+wuLeZ9//vfN3Jzc43k5GSjd+/exo033mj88Y9/tLssx2K6aWjuuusuIysry0hOTja+9a1vGXfddZexf/9+u8tyjI0bNxr5+flGSkqKceWVVxrPP/+8LXW4DMMwoh9nAABAPGKvEAAAYBqCBQAAMA3BAgAAmIZgAQAATEOwAAAApiFYAAAA0xAsAACAaQgWAADANAQLAABgGoIFAAAwDcECAACY5v8DDz8fzAipK4EAAAAASUVORK5CYII=", + "image/png": "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", "text/plain": [ "
" ] @@ -139,7 +268,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -149,7 +278,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -165,7 +294,7 @@ "for k, v in training_input.items():\n", " plt.scatter(*v.T, label=str(k))\n", "plt.legend()\n", - "plt.title(\"training data\")\n", + "plt.title(\"Training Data\")\n", "plt.xlim(plot_range)\n", "plt.ylim(plot_range)\n", "plt.show()\n", @@ -173,13 +302,13 @@ "for k, v in test_input.items():\n", " plt.scatter(*v.T, label=str(k))\n", "plt.legend()\n", - "plt.title(\"test data\")\n", + "plt.title(\"Test Data\")\n", "plt.xlim(plot_range)\n", - "plt.ylim(plot_range)\n", + "plt.ylim((0, 2 * np.pi + 0.3))\n", "plt.show()\n", "\n", "plt.scatter(*predict_input.T)\n", - "plt.title(\"predict data (unlabeled)\")\n", + "plt.title(\"Prediction Data (unlabeled)\")\n", "plt.xlim(plot_range)\n", "plt.ylim(plot_range)\n", "plt.show()" @@ -187,26 +316,26 @@ }, { "cell_type": "markdown", - "id": "9", + "id": "17", "metadata": {}, "source": [ - "## Defining the Feature Map\n", - "When constructing a `QSVM` model, we must supply the feature map to use.\n", + "### Defining the Feature Map\n", + "When constructing a QSVM model, we must supply the feature map which.\n", "\n", "A feature map is a way to encode classical data into quantum.\n", "Here, we choose to encode the data onto the surface of the Bloch sphere.\n", - "This can be defined as\n", - "```\n", - "R_X(x[0] / 2)\n", - "R_Z(x[1])\n", - "```\n", - "where `x` is the 2D input vector and the circuit takes a single qubit per data point. This creates a state that is $\\cos(x[0]/4)|0\\rangle + e^{x[1]/4}\\sin(x[0]/4)|1\\rangle$ (up to a global phase). We define a quantum function that generalizes the Bloch sphere mapping to an input vector of any dimension (also known as \"dense angle encoding\" in the field of quantum neural networks). Each pair of entries in the vector is mapped to a Bloch sphere. If there is an odd size, we apply a single RX gate on an extra qubit." + "\n", + "\n", + "This can be defined in terms of the following transformation on the 2D data point $$\\mathbf{x} = [x_0,x_1]^T\\rightarrow R_Z(x_1) R_X(x_0/2)|0\\rangle = \\cos(x_0/4)|0\\rangle + e^{x_1/4}\\sin(x_0/4)|1\\rangle~~,$$\n", + "where the circuit takes a single qubit per data point and the last equality is up to a global phase. We define a quantum function that generalizes the Bloch sphere mapping to an input vector of any dimension (also known as \"dense angle encoding\" in the field of quantum neural networks). Each pair of entries in the vector is mapped to a Bloch sphere. If there is an odd size, we apply a single RX gate on an extra qubit.\n", + "\n", + "Since a single qubit stores the data of a single data point, for such a feature mapping the number of qubits required is $n=2\\lceil m d/2 \\rceil$." ] }, { "cell_type": "code", - "execution_count": 5, - "id": "10", + "execution_count": 6, + "id": "18", "metadata": {}, "outputs": [], "source": [ @@ -221,44 +350,44 @@ }, { "cell_type": "markdown", - "id": "11", + "id": "19", "metadata": {}, "source": [ - "## Defining the Data\n", + "#### Defining the Data\n", "In addition to the feature map, we need to prepare our data.\n", "\n", - "The `train_input` and `test_input` datasets consisting of data and its labels. The labels are a 1D array where the value of the label corresponds to each data point and can be basically anything, such as (0, 1), (3, 5), or ('A', 'B').\n", + "The `training_input` and `test_input` datasets consist of data and its labels. The labels are a 1D array where the value of the label corresponds to each data point and can be basically anything, such as (0, 1), (3, 5), or ('A', 'B').\n", "The `predict_input` consists only of data points (without labels).\n" ] }, { "cell_type": "code", - "execution_count": 6, - "id": "12", + "execution_count": 7, + "id": "20", "metadata": {}, "outputs": [], "source": [ "# Prepare and define `train_input` and `test_input` datasets consisting of data and labels\n", - "TRAIN_DATA, TRAIN_LABEL = data_dict_to_data_and_labels(training_input)\n", - "TEST_DATA, TEST_LABEL = data_dict_to_data_and_labels(test_input)\n", + "TRAIN_DATA_1, TRAIN_LABEL_1 = data_dict_to_data_and_labels(training_input)\n", + "TEST_DATA_1, TEST_LABEL_1 = data_dict_to_data_and_labels(test_input)\n", "\n", "# Prepare and define `predict_input`\n", - "PREDICT_DATA = predict_input" + "PREDICT_DATA_1 = predict_input" ] }, { "cell_type": "markdown", - "id": "13", + "id": "21", "metadata": {}, "source": [ - "## Constructing a Model\n", + "### Constructing a Model\n", "We can now construct the QSVM model using the `bloch_feature_map` function, and its inverse:" ] }, { "cell_type": "code", - "execution_count": 7, - "id": "14", + "execution_count": 8, + "id": "22", "metadata": {}, "outputs": [], "source": [ @@ -276,68 +405,91 @@ " invert(lambda: bloch_feature_map(data2, qba))\n", "\n", "\n", - "QSVM_BLOCH_SHPERE_qmod = create_model(main, out_file=\"qsvm\")" + "QSVM_BLOCH_SHPERE_qmod = create_model(main)\n", + "write_qmod(QSVM_BLOCH_SHPERE_qmod, \"qsvm_bloch_sphere_feature_map\", symbolic_only=False)" ] }, { "cell_type": "markdown", - "id": "15", + "id": "23", "metadata": {}, "source": [ - "## Synthesizing the Model and Exploring the Generated Quantum Circuit\n", + "#### Synthesizing the Model and Exploring the Generated Quantum Circuit\n", "Once we have constructed our QSVM model, we synthesize and view the quantum circuit that encodes our data using the Classiq built-in `synthesize` and `show` functions:" ] }, { "cell_type": "code", - "execution_count": 8, - "id": "16", + "execution_count": 9, + "id": "24", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "Quantum program link: https://platform.classiq.io/circuit/32pQdaKz3yY76oVkN4CuYyLNXrl\n" + "Quantum program link: https://platform.classiq.io/circuit/37qLGCeFW0ESmibXbmnB0V76bIw\n" ] } ], "source": [ - "qprog = synthesize(QSVM_BLOCH_SHPERE_qmod)\n", - "show(qprog)" + "qprog_bloch = synthesize(main)\n", + "show(qprog_bloch)" ] }, { "cell_type": "markdown", - "id": "17", + "id": "25", "metadata": {}, "source": [ - "## Executing QSVM\n", + "### Executing QSVM\n", "Steps in QSVM execution:\n", "1. Training.\n", - "2. Testing the training process.\n", + "2. Testing the training process, and outputing a test score.\n", "3. Predicting, by taking unlabeled data and returning its predicted labels. This may be applied multiple times on different datasets.\n", "\n", "Next, we define classical functions for applying the three parts of the execution process, where the third uses `ExecutionSession` and `batch_sample`." ] }, + { + "cell_type": "markdown", + "id": "26", + "metadata": {}, + "source": [ + "The training and prediction procedure are performed by `train_svm` and `predict_svm` functions in four main steps:\n", + "1. The data set is composed by `get_exectuation_params` to a list of dictionaries involving all pairs of data points (not including symmetric cases).\n", + "2. Utilizing Classiq's `sample_batch` we evaluate the overlap between the states encoding the two data points of each pair.\n", + "3. The measurement results are used to construct the kernel matrix by the `construct_kernel_matrix` function.\n", + "4. The kernel matrix is utilized by scikit-learn's `SVC` (Support Vector Classifier) function to optimize the quadratic program (the dual optimization problem). The function provides an `svm_model` which contains the dual optimization problem coefficients $\\{\\alpha_i\\}$. The knowledge of the optimized coefficients enables the model to predict the classification of a new data point, utilizing Eq. (1).\n", + " \n", + "\n", + "In the training procedure due to the symmety of the kernel matrix ($K(\\mathbf{x}_i, \\mathbf{x}_j) = K(\\mathbf{x}_j, \\mathbf{x}_i)$) the execution paramertes are both chosen from the training data set, and all the non-symmetric instances are evaluated Contrastly, following Eq. (1) the prediction procedure composes all the combinations of data point pairs, where one of the data points is from the training set and the other is from the prediction data set. \n", + "Note that generally $K(\\mathbf{x}_i, \\mathbf{s}_j) \\neq K(\\mathbf{x}_j, \\mathbf{s}_i)$, therefore, in the prediction, all the overlaps between all possible data point pairs are evaluated." + ] + }, { "cell_type": "code", - "execution_count": 9, - "id": "18", + "execution_count": 10, + "id": "27", "metadata": {}, "outputs": [], "source": [ "def get_execution_params(data1, data2=None):\n", " \"\"\"\n", " Generate execution parameters based on the mode (train or validate).\n", + " The output is a list of the form [{data1: np.ndarray, data2: np.ndarray},...],\n", + " each dictionary contains two data points, and the output list includes all\n", + " possible non-symmetric combinations of data points. In the training mode the data\n", + " points are only taken from data1, while in the prediction mode, the dictionary key data1 is taken from data1 input\n", + " and data2 key is taken from\n", "\n", " Parameters:\n", " - data1: First dataset (used for both training and validation).\n", " - data2: Second dataset (only required for validation).\n", "\n", " Returns:\n", - " - A list of dictionaries with execution parameters.\n", + " - A list of dictionaries with execution parameters\n", + "\n", " \"\"\"\n", " if data2 is None:\n", " # Training mode (symmetric pairs of data1)\n", @@ -378,6 +530,7 @@ " # Symmetric matrix (training)\n", " for k in range(rows):\n", " for j in range(k, cols):\n", + " # Empirical probability to measure the state |0...0>\n", " value = (\n", " res_batch[count].counts.get(\"0\" * num_output_qubits, 0) / num_shots\n", " )\n", @@ -452,7 +605,7 @@ }, { "cell_type": "markdown", - "id": "19", + "id": "28", "metadata": {}, "source": [ "We can now run the execution session with all three parts:" @@ -460,86 +613,80 @@ }, { "cell_type": "code", - "execution_count": 10, - "id": "20", + "execution_count": 11, + "id": "29", "metadata": {}, "outputs": [], "source": [ "from classiq.execution import ExecutionSession\n", "\n", - "with ExecutionSession(qprog) as es:\n", + "with ExecutionSession(qprog_bloch) as es:\n", " # train\n", - " svm_model = train_svm(es, TRAIN_DATA.tolist(), TRAIN_LABEL.tolist())\n", + " svm_model = train_svm(es, TRAIN_DATA_1.tolist(), TRAIN_LABEL_1.tolist())\n", "\n", " # test\n", - " y_test = predict_svm(es, TEST_DATA.tolist(), TRAIN_DATA.tolist(), svm_model)\n", - " test_score = sum(y_test == TEST_LABEL.tolist()) / len(TEST_LABEL.tolist())\n", + " y_test = predict_svm(es, TEST_DATA_1.tolist(), TRAIN_DATA_1.tolist(), svm_model)\n", + " test_score = sum(y_test == TEST_LABEL_1.tolist()) / len(TEST_LABEL_1.tolist())\n", "\n", " # predict\n", " predicted_labels = predict_svm(\n", - " es, PREDICT_DATA.tolist(), TRAIN_DATA.tolist(), svm_model\n", + " es, PREDICT_DATA_1.tolist(), TRAIN_DATA_1.tolist(), svm_model\n", " )" ] }, { "cell_type": "markdown", - "id": "21", + "id": "30", "metadata": {}, "source": [ - "We can view the classification accuracy through `test_score`:" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "id": "22", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "quantum kernel classification test score: 1.00\n" - ] - } - ], - "source": [ - "print(\"quantum kernel classification test score: %0.2f\" % (test_score))" + "### Results" ] }, { "cell_type": "markdown", - "id": "23", + "id": "31", "metadata": {}, "source": [ - "Since this data was previously generated, we also know the real labels and can print them for comparison." + "We can view the classification accuracy through `test_score`, moreover, since this data was previously generated, we also know the real labels and can print them for comparison." ] }, { "cell_type": "code", "execution_count": 12, - "id": "24", + "id": "32", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "[0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1\n", + "Testing success ratio: 1.0\n", + "\n", + "Prediction from datapoints set:\n", + " ground truth: [0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1\n", " 1 1 1]\n", - "[0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1\n", - " 1 1 1]\n" + " prediction: [0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1\n", + " 1 1 1]\n", + " success rate: 100.0%\n" ] } ], "source": [ - "print(predicted_labels)\n", - "print(predict_real_labels)" + "# Printing tests result\n", + "print(f\"Testing success ratio: {test_score}\")\n", + "print()\n", + "# Printing predictions\n", + "print(\"Prediction from datapoints set:\")\n", + "print(f\" ground truth: {predict_real_labels}\")\n", + "print(f\" prediction: {predicted_labels}\")\n", + "print(\n", + " f\" success rate: {100 * np.count_nonzero(predicted_labels == predict_real_labels) / len(predicted_labels)}%\"\n", + ")" ] }, { "cell_type": "markdown", - "id": "25", + "id": "33", "metadata": {}, "source": [ "We can even visualize the predicted results:" @@ -548,12 +695,12 @@ { "cell_type": "code", "execution_count": 13, - "id": "26", + "id": "34", "metadata": {}, "outputs": [ { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAhYAAAGzCAYAAABzfl4TAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy81sbWrAAAACXBIWXMAAA9hAAAPYQGoP6dpAAA/cklEQVR4nO3dd3hUdd7+8fvMhISWhN5D6NKLgPwAlWpBVkVXUUFFVt1Fg4is+yiuLrI+Glwbusui6C62pSiPYEVEqg2liAs2qvQuJCFAIDPn98eXJIRkJjPhTEver+uaK5kzZ+Z8mABz51st27ZtAQAAOMAV6QIAAEDZQbAAAACOIVgAAADHECwAAIBjCBYAAMAxBAsAAOAYggUAAHAMwQIAADiGYAEAABxDsACCsHTpUlmWpTlz5kS6lLCwLEuPPvpo/v1XX31VlmXpl19+iVhNZzu7xljwyy+/yLIsvfrqq5EuBXAcwQLlnmVZAd2WLl0a6VJj1owZMzR58uRIlxHVPvroo5gLSEBx4iJdABBpb7zxRqH7r7/+uhYuXFjkeJs2bfTjjz+Gs7Soc8stt+jGG29UQkJCUM+bMWOG1q9fr7Fjx4amsDLgo48+0pQpUwgXiHkEC5R7N998c6H7K1as0MKFC4sclxQzweLYsWOqXLmy46/rdrvldrsdf91IOHHihOLj4+Vy0XALOIl/UUApeL1ePf7442rUqJEqVqyoAQMGaNOmTUXO+/rrr3X55ZcrOTlZlStXVp8+ffTFF1+U+Pp5Yzlmz56thx56SPXq1VOVKlV01VVXaceOHYXO7du3r9q3b6/Vq1fr4osvVuXKlfXQQw9JknJycjRhwgS1aNFCCQkJSklJ0f/8z/8oJyen0Gvk5OTovvvuU+3atZWYmKirrrpKO3fuLFKXrzEW8+fPV58+fZSYmKikpCR1795dM2bMyK/vww8/1LZt2/K7lZo0aVLo2k7W6O/9nDVrlh5++GE1bNhQlStXVmZmpqTAfk5ZWVkaO3asmjRpooSEBNWpU0eXXHKJ1qxZk39OkyZNdNtttxW5ft++fdW3b1+f9d12222aMmWKpMJdc0AsosUCKIVJkybJ5XLp/vvvV0ZGhv72t79p+PDh+vrrr/PPWbx4sQYNGqSuXbtqwoQJcrlcmj59uvr376/PPvtMF1xwQYnXefzxx2VZlh544AHt379fkydP1sCBA7V27VpVqlQp/7xDhw5p0KBBuvHGG3XzzTerbt268nq9uuqqq/T555/r97//vdq0aaN169bpueee04YNGzRv3rz8599xxx168803NWzYMPXq1UuLFy/W4MGDA3ovXn31Vf3ud79Tu3btNH78eFWrVk3ffvutPv74Yw0bNkx//vOflZGRoZ07d+q5556TJFWtWlWSwlZjnscee0zx8fG6//77lZOTo/j4+IB/TqNGjdKcOXM0evRotW3bVocOHdLnn3+uH3/8Ueeff35QdZztD3/4g3bv3l1sFxwQc2wAhaSlpdm+/mksWbLElmS3adPGzsnJyT/+/PPP25LsdevW2bZt216v127ZsqV92WWX2V6vN/+8Y8eO2U2bNrUvueQSvzXkXadhw4Z2ZmZm/vG33nrLlmQ///zz+cf69OljS7JffPHFQq/xxhtv2C6Xy/7ss88KHX/xxRdtSfYXX3xh27Ztr1271pZk33333YXOGzZsmC3JnjBhQv6x6dOn25LsrVu32rZt20eOHLETExPtHj162MePHy/0/DP/3IMHD7ZTU1OL/DlDUWNx8t7PZs2a2ceOHStUY6A/p+TkZDstLc3vdVJTU+0RI0YUOd6nTx+7T58++fe3bt1qS7KnT5+ef8zf3zsgltAVApTCyJEjFR8fn3//oosukiRt2bJFkrR27Vpt3LhRw4YN06FDh3Tw4EEdPHhQ2dnZGjBggJYvXy6v11vidW699VYlJibm37/uuutUv359ffTRR4XOS0hI0MiRIwsde/vtt9WmTRu1bt06//oHDx5U//79JUlLliyRpPzXGjNmTKHnBzLQcuHChcrKytKDDz6oihUrFnoskKb8cNR4phEjRhRq6Qnm51StWjV9/fXX2r17d1DXBMobukKAUmjcuHGh+9WrV5ckHT58WJK0ceNGSeaDzJeMjIz85/nSsmXLQvcty1KLFi2KjHFo2LBhoaCTV8OPP/6o2rVrF/va+/fvlyRt27ZNLpdLzZs3L/T4eeed57c2Sdq8ebMkqX379iWeW5xw1Himpk2bFrm+FNjP6W9/+5tGjBihlJQUde3aVVdccYVuvfVWNWvWLKgagLKOYAGUgq+ZEbZtS1L+b7lPPfWUOnfuXOy5eeMMnHDmb+F5vF6vOnTooGeffbbY56SkpDh2/dIKd41nv0/B/JyGDh2qiy66SHPnztUnn3yip556Sk8++aTeeecdDRo0SJLvVhqPx1NmZtMAJSFYACGQ95t1UlKSBg4cWOrXyfuNOo9t29q0aZM6duwYUA3fffedBgwY4LdbIjU1VV6vV5s3by7UAvDzzz8HdA1JWr9+vVq0aOHzPF/XD0eN/gT7c6pfv77uvvtu3X333dq/f7/OP/98Pf744/nBonr16jpy5EiR523btq3Elg1mgaCsYIwFEAJdu3ZV8+bN9fTTT+vo0aNFHj9w4EBAr/P6668rKysr//6cOXO0Z8+e/A8yf4YOHapdu3bp5ZdfLvLY8ePHlZ2dLUn5r/XCCy8UOieQlTIvvfRSJSYmKj09XSdOnCj0WF7rjSRVqVJFGRkZEanRn0B/Th6Pp0j9derUUYMGDQpNi23evLlWrFihkydP5h/74IMPikwRLk6VKlUkqdhgAsQSWiyAEHC5XHrllVc0aNAgtWvXTiNHjlTDhg21a9cuLVmyRElJSXr//fdLfJ0aNWrowgsv1MiRI7Vv3z5NnjxZLVq00J133lnic2+55Ra99dZbGjVqlJYsWaLevXvL4/Hop59+0ltvvaUFCxaoW7du6ty5s2666Sb985//VEZGhnr16qVFixYVuy7H2ZKSkvTcc8/pjjvuUPfu3TVs2DBVr15d3333nY4dO6bXXntNkvkAnz17tsaNG6fu3buratWquvLKK8NSoz+B/pyysrLUqFEjXXfdderUqZOqVq2qTz/9VCtXrtQzzzyT/3p33HGH5syZo8svv1xDhw7V5s2b9eabbxYZG1Kcrl27SjIDVC+77DK53W7deOON5/TnAyIiwrNSgKgTyHTTt99+u9Dx4qYP2rZtf/vtt/a1115r16xZ005ISLBTU1PtoUOH2osWLfJbQ951Zs6caY8fP96uU6eOXalSJXvw4MH2tm3bCp3bp08fu127dsW+zsmTJ+0nn3zSbteunZ2QkGBXr17d7tq1qz1x4kQ7IyMj/7zjx4/bY8aMsWvWrGlXqVLFvvLKK+0dO3aUON00z3vvvWf36tXLrlSpkp2UlGRfcMEF9syZM/MfP3r0qD1s2DC7WrVqtqRCU0+drtHf+3n2zy1PST+nnJwc+09/+pPdqVMnOzEx0a5SpYrdqVMn+5///GeR13rmmWfshg0b2gkJCXbv3r3tVatWBTTdNDc3177nnnvs2rVr25ZlMfUUMcuy7TPaKwFEhaVLl6pfv356++23dd1110W6HAAIGGMsAACAYwgWAADAMQQLAADgGMZYAAAAx9BiAQAAHEOwAAAAjgn7Aller1e7d+9WYmIiS9gCABAjbNtWVlaWGjRoIJfLd7tE2IPF7t27o2LzIwAAELwdO3aoUaNGPh8Pe7BITEyUZApLSkoK9+UBAEApZGZmKiUlJf9z3JewB4u87o+kpCSCBQAAMaakYQwM3gQAAI4hWAAAAMcQLAAAgGMIFgAAwDFhH7wJoBw4tlPa/C/p8HeSu5LU6Gqp0RDJHR/pygCEGMECgLM2vSKtHGW+t72S5ZK2zZCqNpf6fypVbRLR8gCEFl0hAJyzd5H0zZ2S7TE32ae/SsreJi25TPLmRrREAKFFsADgnB8mSZa7+MfsXClrg7Trg/DWBCCsCBYAnOE5aVos8looimPFSbsJFkBZFnSw2LVrl26++WbVrFlTlSpVUocOHbRq1apQ1AYgltinJNklnSR5csJRDYAICWrw5uHDh9W7d2/169dP8+fPV+3atbVx40ZVr149VPUBiBXuylKVplL2L/IZMGxbqt4lnFUBCLOggsWTTz6plJQUTZ8+Pf9Y06ZNHS8KQAyyLOm8MdKacb5OkFwVpGYjwloWgPAKqivkvffeU7du3XT99derTp066tKli15++WW/z8nJyVFmZmahG4AyqlWa1OAKSdbp22lWnJl22utNKaFmpKoDEAZBBYstW7Zo6tSpatmypRYsWKC77rpLY8aM0WuvvebzOenp6UpOTs6/paSknHPRAKKUq4J08Typ2z+kpPMKjjUaIl3ypdT4ukhWByAMLNu2SxptlS8+Pl7dunXTl19+mX9szJgxWrlypb766qtin5OTk6OcnILBWnn7uWdkZLBtOlDWeT2mpaKEbZYBRL/MzEwlJyeX+PkdVItF/fr11bZt20LH2rRpo+3bt/t8TkJCgpKSkgrdAJQTLjehAihnggoWvXv31s8//1zo2IYNG5SamupoUQAAIDYFFSzuu+8+rVixQk888YQ2bdqkGTNmaNq0aUpLSwtVfQAAIIYEFSy6d++uuXPnaubMmWrfvr0ee+wxTZ48WcOHDw9VfQAAIIYENXjTCYEO/gAAANEjJIM3AQAA/CFYAAAAxxAsAACAYwgWAADAMQQLAADgmKB2NwVQTnhPSTvfk3bMkU5lSUmtpRa/l5JaRboyAFGOYAGgsON7pcUDpYzvJcst2R5pz8fST89IHf9Xav/nSFcIIIrRFQKggG1Ly66UMk8v3W97Cn/978PSLzMjUxuAmECLBYACBz6Tfl3l5wSX9P0TUuqNvjcXyzkkbXlVOvydFFdJaniVVP9ysyEZgDKPYAGgwO6PJCtOsnN9nOCVMtZLx/dIlRsUffiXmdKK2yRv7ungYUmbpknJ7aV+H0uVG4aweADRgK4QAAU8JyUFsM2592TRY/s/l74cfvoxr+k+yQsomT9JSy6XvB4nqwUQhQgWAArU6CrZp/yfE1+z+JaHH9Ily8d/KXauaenYM//cawQQ1QgWAAo0/q0JDj7/a3BJre6WXBUKH/aeknZ/XDDIszhWnLTzXacqBRClCBYACrgrShfNkVzxJgjkOz1eovaFUruHij4vr/vDH9uWPMcdLBZANCJYACisbl9p0Bqp6a1SXFVJLimxpdR1stT/ExM+zuauLFVuXMIL21K1Ds7WeuKAtO4x6YPW0jv1pIV9zABSxnIAEWPZtm2H84KB7ucOIErYtu+ppWf68Wnp2wfks+XCqiBds1OqWMeZujJ+lD7tK+UcLLim5ZJsr9RgsHTRO5I73plrRbOjW6Wjm6X46lL1Lr7HuQDnKNDPb/4GAiiw/zNp+TXSW1Wl2ZWkRQOl3R8G9txW90h1+6jIfyuWW5Il9XjFuVBhe6XlQ6STh1QoyNinv98936y3UZYdWS992k96r5m0+BLp427Sey2kX2ZFujKUcwQLAMbGqdKnF0u7PpBysyXPCWn/UrMS59pixlWczZ0g9Z0vdU6XKqecPmhJ9QZKAxZLzW51rtZ9i6WsDX4Gi3qlDX8/PX22DMr4Qfqkp1nQ7EzZW6Uvb5I2vRKZugCxQBYAyXQrrEwz35+5OFbeB/cP6VLdflL9S/y/jjtBavs/Ups/SblHzSBQd4Lz9e7/vISFvCSd/FU6uklKbuv89SPt2z+ZgbC+gtWasWZ11ApVw1oWINFiAUCSNr54usvCByvOtAAEyrKkComhCRVSEOMIyuB/ccf3mq4ef1N7c49JO/4vfDUBZyiD/+oABO3gl/5/+7dzpYMrwldPSer291+vJFWsJyW2CE894XRsp6QSxtxbcVL2trCUA5yNrhCgPMj4Sdr+lnTyiPmwbTJMiq9W8LgrgNkTZy+KFUm1e5sZEEfW+QgYltR6nOQqg//FJdQq+Rw7N7DzgBCgxQIoyzwnpC+GSR+2kdb/VdrwD2nVaOmd+tLmfxWc13Cw/P53YMVJDa8MebkBsyzp4nmnB4meXrxLKljUq8nNUps/Rqi4EKvaRKrZQ/5/Xm6p8XXhqggohGABlGVf3yltm22+tz2n9wGxJe8J6es7pB3zzGPN75DiKqv4/xJOf2i3uifw69pe6cAX0va3zUBLu4RVOUujSmPpiv9K3aeaFUGT20uNrpH6L5R6vla213PoPKlg99jitPmTc1N7gSCxQBZQVmVtlt5vKd/98Zb5ML7iO/MhdeALaekV0qmsM57jMt0JvWdJKdcEdt2d70ur7zVTH/NUSZXOnyylDCntnwZn2/WhCYcn9soEQq/kOj0rp8OjZTtYISIC/fwugx2QACRJO+fK/EbrK1jYUsY6EwCqNjPjFq7aKm19Tdqz0LRw1L5QanGHVKl+gNd8X1p+ddHj2dulz641+5CkXFvKPxAKaThYGrJD2rNAOrrFjJlpeGXhsTNABBAsgFA5sV/a+kbBcsuNb5Cqdwzf9U9lmb72krohTmUVfJ9QQ2p9n7kFy/ZKq8fk3Tn7QUmWtHqs1PBqyeVnaisC54o7PT4GiB4ECyAUfv67tGac+bC13JJss8R0ym+lnm9IcZVCX0PSeafHVPhhVTDdFE448KWU/YufE2zp2A7pwHKz2BaAMolOOMBpv8wyv7nbuZK85sM9b0rkjrmmXzwcUq6VKlSTzwF+VpzU5Cbnms6P7wrsvGMBngcgJhEsACfZtrRugnx+mMsrbZtp+sRDzV1R6vmqqeXsVTWtOKlSPalTunPXC3QcRqDnAYhJBAvASVkbzM3vyohWwTTPUGt0tTRwiVT7ooJjropSs5HSZd9IlRs4d61avc/YfMyHSg2kOn2duyaAqMMYC8BJudkln2O5zAZd4VLnYhMuThyQTmWaloq4Ks5fx+WWzn9O+tzPwkxdnmHgJlDG0WIBOKlqUzMg0h87NzI7blasLSU2D02oyNP4t9KFb5mWiULXri/1mik1uTF01wYQFWixAJwUX91sV71tpo89LFxmSmfDq8JeWtg0vl5qdK20f4l0bLcZU1G3X9nctwNAEfxLB5zW5W/S/mVmlsSZW1tbbkmW1PNNyR3Apl+xzOWW6g2MdBUAIoCuEMBplepJl6+UWt51RreDJdW/XLrkc6nBZREtLyRs22yr/vWd0qIB0uc3mlU4vZ6SnwugTGGvECCUPDlSzkGpQqJUoYz+ffd6pG/ulLZMN9NY7dzTK356pFq9pL4fSfHJka4SwDkK9PObFgsglNwJUuWGZTdUSNIP6dKWV833eeNK8rqADn0trRgZkbIARAZjLAAEx/ZKez6R9i+VPKekzdPkc90O2yPtnGd2Wk1sHsYiAUQKwQJA4DI3Sst+YxYBsyqc3uAsgHEUexZIiXeHvDwAkUewABCYk0ekT/tIOfvN/ZI2OMtnSd5AzwUQ6xhjASAwW6ZLJ/YWnkIbEK9Us3tISnKU7TWrk548EulKgJhGiwWAwGybJf97oBTDcktJbaVaPQM7P/e4lPG9ZFlScjuzkVqoeU9JP02WNrwgHdtpjtXoLrV70OwQCyAoBAsAgTmZEdz5ltusRHrhbBMU/PHkSOsmShv/KZ06fZ0KyVKre6T2j4RuQTFvrrR8iLR7vgqFpl9XS5/9Vur8pNT2f0JzbaCMoisEQGCqtTPrVPhkSe5KkitBqlhPanO/NOg7KbmN/9f1eqTPrpV+eLIgVEjm++8fN5ua2d7A67S90q6PpM+ulxb0NF93fVj8a2z5d9FQYYoyX9Y+IGVuCPzaAGixABCgFqOkHe/4OcGWes2QUoYE97o735F2f+T7NXe9L+18L7DXzT1uWiD2flKwSNevbmnHHKnuQKnPu1Jc5YLzN0zx/3pWnLRpmnT+0wH+YQDQYgEgMPUGSs18LXZlSY1vkBqVYnO1H5/1/7jlNh/ugVhzn7T3U/N93iDTvK/7Fkur7y18fuaP8jtuxM6VMtYHdm0AkggWAAJlWVKPV6TzJ0uVUwqOV2pgxiL0+o9kBflfyq/fmtU5/bE9Zt2MkuQckjb/W/ndGEV4zQqhJ/YXHHJXKuFFXaHdZh4og4L6X+DRRx+VZVmFbq1btw5VbQCijeWSWt8rXf2LdNVW6aot0tXbpbZ/MjuaBuubO1XyTBNLSqhZ8mvtX17y2hp2rjkvT8p1JYwb8Zot4AEELOgxFu3atdOnn35a8AJxDNMAyh3LJVVtcm6vcfi/ZvZFIJreWvI5ga6v4c0t+L7NH6Vf/nN6YOdZLR1WnFQlVWp8XWCvC0BSKYJFXFyc6tWrF4paAJQngXRvSFJCrcCCRc3ukiz5bwGxpFoXFNxNbiv1ed/MPDmVebr1wjItH4ktpH4fm43kAAQs6GCxceNGNWjQQBUrVlTPnj2Vnp6uxo0b+zw/JydHOTk5+fczMzNLVymAsqVCgFupd3rCbDtfkiqpUsPfmOmjdm7Rx604qf6lUtVmhY/Xv0S6ZrdZAOzQN5IrXmow2Jwb7JgRALJs2w54Kb358+fr6NGjOu+887Rnzx5NnDhRu3bt0vr165WYWPw//EcffVQTJ04scryk/dwBlHGeHGlufenkYd/nxCVK1+4tPEXUn+P7pIUXSke3qHDXhkuq2lS65DOpUv1zqRootzIzM5WcnFzi53dQweJsR44cUWpqqp599lndfvvtxZ5TXItFSkoKwQKA9NPz0pqxvh/v9ITUbnxwr3kyQ9r0krT5Fen4HrNYV4s7pBZ/kOKrnUu1QLkWaLA4p5GX1apVU6tWrbRp0yaf5yQkJCghgT5KAMU4b4yUm2WW87a9BYtaWZbU9kFzC1Z8slmGm6W4gYg4p2Bx9OhRbd68WbfccotT9QAoTyxLav+w1OL3ZozDsV1SpXpS6k3mK4CYE1SwuP/++3XllVcqNTVVu3fv1oQJE+R2u3XTTTeFqj4AkZSbXTCo0YqT6l9mBjaWZs0KfyrWMa0XAGJeUMFi586duummm3To0CHVrl1bF154oVasWKHatWuHqj4AkbJvibT8GrMZWN4iUhv/KVU9PQ0zsXlk6wMQlc5p8GZpBDr4A0AEZf4sfdRZ8p5U0YWj3FKlhtJvfgx8tgaAmBfo5zeTtAEU9dPk02tBFLPvhu2Rjm03XSQAcBaCBYCitr9d/CJT+VwlbKEOoLwiWAAoynO8hBO8Uu7RsJQCILawgxgQ63KPS9tmSrvel3KPSTW6mOmbZy9dHYzkdqc3CPOxBbkVJ1XrWPrXB1BmESyAWJa5QVo8QDq2U6YB0ivtWyT98JTU7QWpVVrpXrdVmrTiNt+P27lmJUsAOAtdIUCs8pyUFl9ilq2WlN+6YHvM96tGS3sWlu61m9wsNbpGZrfQM53+L6PT41K1dqV7bQBlGsECiFU755rZGban+Mctt/TD30r32i63dOFb0vnPSlWaFByv0VW6cI7U7qHSvS6AMo+uECBW7Z5vxjr4mr1he0y3iDdXcpXin7orTmo9VjrvXunkr+Za8QFudQ6g3CJYALHKe1IqcX07+3TwOId/6pYlJdQs/fMBlCt0hQCxqmZ3+Zy1IUmypKTWkrtiuCoCAIIFELOajjgdGs4eYHmG8+4NWzkAIBEsgNiVUEPqPdMM0rTO7Oo4/c+68fVS8zsjUlrUOXVU2jBFWtBDere5mU2zfY7k9THwFUCpMcYCiGWNrpYuXyn9+Ky0c57kzZGqdZBa3SM1vUWy+N1Bx3ZJn/aRjm45fcCWjm2T9n4q1b9cunie5E6IZIVAmUKwAGJd9c5Sr9cjXUX0+uJGKXubpDMGuuZN0d3zifTfR6QupZyWC6AIfp0BELtsW9q3TNr4orT1DSnnUOHHD6+VDnzuZ0M1r7RxqpSbHepKgXKDFgsAsengCumrW6WsjQXHXPFSq9FS5yfNOhz7lil/qXNfco9Kh/8r1e4Z6oqBcoFgASD2HFknLeoveXIKH/eelH56TjqVJfWYpkLdHwDCgq4QALFn3UQTIoptibClzS9LmRulOn18nHOGuCpSdXZqBZxCsAAQW04dlXbM9b1HimSm4P7yH7OFfK1eZ03HPZNLajHKhAsAjiBYAIgtJw+rxFYIuaScA+bbC2dLVRrLLCSWt5iY23ypN9Ds1ArAMYyxABBbEmqZQZrek35O8kqVU8y3lRtJg9ZKW16Ttr5mAkfV5lKL30spvy3dBm0AfOJfFIDYEldJSh0m/fKmn51dbbNAWJ4KidJ5o80NQEjRFQIg9nR81GzhbrmLf7z9I1LlhmEtCYBBsAAQe6qkSpeukOr2L3w8oY7U9e9ShwmRqQsAXSEAYlRiC6n/J9LRX6TMn6S4qlKtHpKrQqQrA8o1ggWA2Fa1ibkBiAp0hQAAAMcQLAAAgGMIFgAAwDEECwAA4BgGbwKILrnHpK1vmJUyT+w1AzOb3yk1vo4ZH0AMIFgAiB7H90mL+pnpo5IkWzq2Xdq3RNr0ktT3IymuckRLBOAfXSEAosdXt0pZGyTZp28q2MV0/2fSt/dHqjIAASJYAIgOmT9Lez/xsx26V9o8XTp5JJxVAQgSwQJAdNi/vORzvCekX1eHvhYApUawAAAAjiFYAIgOdS4u+RxXRalG19DXAqDUCBYAokPSeVK9S3xvhW65peYjpfhqYS0LQHAIFgCiR883pKotJFmnb5Ks0/9N1e4tdXk6UpUBCBDrWACIHpXqSoNWn14ga7p0Yr9UpYnU4k6p8fUskAXEAIIFgOgSV0VqOcrcAMQcukIAAIBjCBYAAMAxBAsAAOAYggUAAHAMwQIAADiGYAEAABxDsAAAAI45p2AxadIkWZalsWPHOlQOAACIZaUOFitXrtRLL72kjh07OlkPAACIYaUKFkePHtXw4cP18ssvq3r16k7XBAAAYlSpgkVaWpoGDx6sgQMHlnhuTk6OMjMzC90AAEDZFPReIbNmzdKaNWu0cuXKgM5PT0/XxIkTgy4MAADEnqBaLHbs2KF7771X//nPf1SxYsWAnjN+/HhlZGTk33bs2FGqQgEAQPSzbNu2Az153rx5uuaaa+R2u/OPeTweWZYll8ulnJycQo8VJzMzU8nJycrIyFBSUlLpKwcAAGET6Od3UF0hAwYM0Lp16wodGzlypFq3bq0HHnigxFABAADKtqCCRWJiotq3b1/oWJUqVVSzZs0ixwEAQPnDypsAAMAxQc8KOdvSpUsdKAMAAJQFtFgAAADHECwAAIBjCBYAAMAxBAsAAOAYggUAAHAMwQIAADiGYAEAABxDsAAAAI4hWAAAAMcQLAAAgGMIFgAAwDEECwAA4BiCBQAAcAzBAgAAOIZgAQAAHEOwAAAAjiFYAAAAxxAsAACAYwgWAADAMQQLAADgGIIFAABwDMECAAA4hmABAAAcQ7AAAACOIVgAAADHECwAAIBjCBYAAMAxBAsAAOAYggUAAHAMwQIAADiGYAEAABxDsAAAAI4hWAAAAMcQLAAAgGMIFgAAwDEECwAA4BiCBQAAcAzBAgAAOIZgAQAAHEOwAAAAjiFYAAAAxxAsAACAYwgWAADAMQQLAADgGIIFAABwDMECAAA4hmABAAAcQ7AAAACOCSpYTJ06VR07dlRSUpKSkpLUs2dPzZ8/P1S1AQCAGBNUsGjUqJEmTZqk1atXa9WqVerfv7+uvvpqff/996GqDwAAxBDLtm37XF6gRo0aeuqpp3T77bcHdH5mZqaSk5OVkZGhpKSkc7k0AAAIk0A/v+NKewGPx6O3335b2dnZ6tmzp8/zcnJylJOTU6gwAABQNgU9eHPdunWqWrWqEhISNGrUKM2dO1dt27b1eX56erqSk5PzbykpKedUMAAAiF5Bd4WcPHlS27dvV0ZGhubMmaNXXnlFy5Yt8xkuimuxSElJoSsEAIAYEmhXyDmPsRg4cKCaN2+ul156ydHCAABA9Aj08/uc17Hwer2FWiQAAED5FdTgzfHjx2vQoEFq3LixsrKyNGPGDC1dulQLFiwIVX0AACCGBBUs9u/fr1tvvVV79uxRcnKyOnbsqAULFuiSSy4JVX0AACCGBBUs/vWvf4WqDviRmSnNnCn99JNUtar0299KnTtHuioAAIoq9ToWCI9Zs6Tbb5eOH5fi4iTblv73f6UrrjCPJSZGukIAAAqwCVkUW7xYGjZMOnbMBIpTp6TcXPPYggXSDTdEtj4AAM5GsIhiEydKLh8/IY9Hmj9fWrMmvDUBAOAPwSJK/fqrtHy5CRC+xMVJ//d/4asJAICSECyi1NGjJZ9jWVJWVuhrAQAgUASLKFW3rpkB4k9urtS6dXjqAQAgEASLKJWQIN1xh+R2+z6nYkVp+PDw1QQAQEkIFlHskUekFi2KhguXy3SDTJsmJSdHpjYAAIpDsIhiNWpIX34pjR5duFukVy/p44+lm2+OXG0AABTnnHc3DRa7m5bOiRPSnj0mYNSuHelqAADlTaCf36y8GSMqVpSaNo10FQAA+EdXCAAAcAzBAgAAOIZgAQAAHEOwAAAAjiFYAAAAxxAsAACAY5huCr+OHZM++8x8bd9eatky0hUBAKIZLRYoltcr/fWvUr160uWXS9deK7VqJfXvL23eHOnqAADRimCBYo0ZI02YUHRb9uXLpf/3/6QdOyJTFwAguhEsUMRPP0lTphT/mMcjHTkiTZoU1pIAADGCYIEiXntNivMz+iY3V3r1VfMVAIAzESxQxK5dUklb0x07VrSbBAAAZoWUM7YtrV8vHTokpaYWv7FZvXqSZfl/nYoVpcTE0NQIAIhdtFiUI++9J7VrJ3XsKPXrJzVrJvXtK333XeHzbrnFfzdHXJx0883+u0sAAOUTwaKcmD1bGjLEDMw80+efS716FQ4XHTpIt91WfKuF2y1VrSqNHx/KagEAsYpgUQ7k5Eh33WW+P3vshMdjHh87tvDxl1+Wxo0zXR5n6tzZhJFmzUJVLQAgllm2XdIwPWdlZmYqOTlZGRkZSkpKCuely605c6Trry/5vK1bpSZNCh87ckRauFA6fty0ZHTpEooKAQDRLtDPb3rJy4Ft20wXhsdT8nlnB4tq1QILJQAASHSFlAs1a5oluktSq1boawEAlG0Ei3JgyBApPt7345ZlZou0bRu2kgAAZRTBohyoVk166CH/50yaVPLaFQAAlIRgUU488ojZrTRvlofbbb7WqGGmov7mN5GrDQBQdjArpJw5ckR6912z8maTJiZQ+OsmAQBAYlYIfKhWTRoxItJVAADKKrpCAACAYwgWAADAMQQLAADgGIJFFDh4UPrxRzOgEgCAWEawiKDvvjOzMurUMYtT1a4tXXWVtH59pCsDAKB0mBUSRsePS7NmScuXSwcOSJ98Ypbazpvwa9vSRx9JixaZc7p2jWy9AAAEi2ARJt98I11xhenu8LchWN425nfeKa1ZE94aAQA4V3SFhMHu3dIll0iHD5v7Je0y6vFI334rrV0b8tIAAHAUwSIMXnpJys4ObIfRM23YEJp6AAAIFbpCgnDypBn7cOSI1KKF1LlzYM+bM6fkVorisOI5ACDW0GIRANuWpkyRGjQwXRrXXy916WJuq1aV/Pxjx4K/ZrVqUr9+wT8PAIBIIlgE4OmnpdGji64zsW6ddPHFZtqoP+efL8UF2Tb0l79ICQnBPQcAgEgjWJTg11+lhx8u/jGPx3SPPPigub9tmzR3rvT++6a7JE9ampSb6/86cXGSy2W+TpwojR3rRPUAAIRXUMEiPT1d3bt3V2JiourUqaMhQ4bo559/DlVtUeGtt6RTp3w/7vFIH39sukiaNpWuvdYsclWvnjRmjJk62q9fQVBwnfGO533ft680bpz07LPSrl2mtcKyQvUnAgAgdIIKFsuWLVNaWppWrFihhQsX6tSpU7r00kuVnZ0dqvoibvfuwLoxliwpWOhKMoFiyhRp6FBz/9lnpTfflDp2LDinUyfpP/+RFi+WnnxSuvdeswonAACxyrLtMz8Og3PgwAHVqVNHy5Yt08UXXxzQczIzM5WcnKyMjAwlxcC0h3/+04yvKP27ZEJH374F9/MGc1aufE6lAQAQNoF+fp/TGIuMjAxJUo0aNXyek5OTo8zMzEK3WDJ0aPADL88UFydNn174WOXKhAoAQNlU6mDh9Xo1duxY9e7dW+3bt/d5Xnp6upKTk/NvKSkppb1kRNSqJT3ySPGPuQJ493JzpR07nK0JAIBoVepgkZaWpvXr12vWrFl+zxs/frwyMjLybzti8FP24Yelp54qumBVy5Ylj4lwu6WGDUNXGwAA0aRUwWL06NH64IMPtGTJEjVq1MjvuQkJCUpKSip0izWWJd1/v7R3r/Tuu9Lrr0tffin9+KN0110mPPji8UgjRoSvVgAAIimowZu2beuee+7R3LlztXTpUrVs2TLoC8ba4M2SHDxoFsDas6foWhUul3TppdKHHwbWbRJtsrKkN94wU24zMqR27aRRo6QLL4x0ZQCAcAvJ4M20tDS9+eabmjFjhhITE7V3717t3btXx48fP+eCY1WtWtIXX5gVOM8UFyfdfrv0zjuxGSo2bzZBIi3N7I+ydq00e7Z00UXnPksGAFB2BdViYflYtWn69Om67bbbAnqNstZicaYNG6SVK6UKFcyiWLVrR7qi0vF6pbZtpU2bfG+e9uKL0h/+EN66AACRE+jn9zmtY1EaZTlYlBWffCJddpnvxy1LatZM2riRFUIBoLwIyzoWKJsWLTKtLr7Ytukq2bkzfDUBAGIDwQJF+Or+OJvXG9o6AACxp9wGi9xcM3V00iTp73+Xtm+PdEXRo1cv/xuvSVL9+lIJM40BAOXQOSxWHbs+/VS6+WZp3z4ze8PrNRuAjRxp9gZJSIh0hZF11VVmUa+9e4tvvbAs8375W78DAFA+lbsWi5UrpSuukA4cMPdzc02wsG3p1VelACe3lGlxcdL770uJiYXDQ973Q4ZIf/xjREoDAES5chcsHn3UBInixgd4vdKsWdL334e9rKjTpYt5Hx58UGra1KzX0bu3eX/efrv0G7N5PNJ775lwcv750m9+I82ZU3RxMQBAbCpX000zM6Vq1fwv7hQXZz5MH3ssbGWVG8ePm26WTz81rR8eT8HX3r2l+fNNKwkAIPow3bQYGRklrxhpWdKvv4annvJm3Dhp8WLzfd7YjbyvK1aY5cIBALGtXAWL2rWlihX9n+PxmMWf4Kxff5X+/W/fU1Q9HtPNsmtXeOsCADirXAWLihXNTqP+xge4XNItt4SvprLo5Elp+nSpRw+zrXybNtJ995nj/ni90rJl4akRABAa5W666YQJ0gcf+J5K+be/mQ9DlM6xY9Lll0uffWZCmtdrZuD8/HNgzw90cS4AQHQqVy0WklnY6euvpeuuKzyVsnlzs0X4ffdFrray4KGHzG6vUuFuj0CHCPfs6XxNAIDwKXctFpJZ/GnWLPOb9ObNUtWqZotwNtQ6N1lZ0ssvl26p77g4acAAqUUL5+sCAIRPuQwWeWrXjt2tzaPR+vWmKyQQllXQiuFySU2amAXKAACxrVwHi2hn29Ly5WaKptdr9vC47DLzQRyNAqnL5ZKuvlratMnsjlqvnnT77dKdd0phXtYEABACBIsotW2bWUzqv/8tmMWSm2umwr77rtS+fWTrK07HjlJyslkvxBevV5o4UerQIXx1AQDCJ0p/9y3fsrOlfv2kH34w93NzC5a83rZN6tvXbKAWbSpVku65x/dYlbg48+ciVABA2UWwiEJvvin98kvx+2d4PNLhw9LUqWEvKyB/+Yt0zTXm+7xZN3ldJK1aSTNnRqYuAEB4ECyiUEkfvl6vCR/RqEIFs0nZRx+ZrpwOHUwLy/Tp0urVUt26ka4QABBKjLGIQocPl7zuQ2ZmeGopDZdLGjTI3AAA5QstFlGobduSlx0/77zw1QMAQKAIFlHo978vfnxFHq9Xuuuu8NUDAECgCBZRqG9fs7ZDcSxLGjxYuuGGsJYUcrZduhU7AQDRhWARhSxLmjZNeu45s/x4nlq1pEcflebOLbzPSSxbsUK69lopIcH8mdq3l156yX+LDQAgelm2Hej2UM7IzMxUcnKyMjIylMRSiyXyeKQtW8xv882amVkXZcWsWdLw4WbMSF6QyFsD4+qrpTlzyk6AAoBYF+jnNy0WUc7tllq2NIM1y1Ko2L9fuvVWE5jObJ2wbXN7913TanOmAwektWulHTvCWioAIAgEC0TE9OmmNcafF14wXzdskIYMMfuKdOkiNW5s9k1ZujTUVQIAgkWwQESsWeP/cduWfvpJWrdO6tFD+uCDwoM7v/5aGjhQ+vDD0NYJAAgOwQIRkZDge0+RPC6XdP/9UlZW0dYNr9fcfvc76dSp0NUJAAgOwQIR8Zvf+O8KiYsz024XLvR9nm2bsRrz54ekRABAKRAsEBFDhkhNm/qe9eHxmL1GSpqz5HZLmzc7Xh4AoJQIFoiI+HjTGpGSYu673aZrxO02rRX//rfUp0/Jr+P1SsnJoa0VABA4NiFDxDRvLv38s/TOO9J770knTphZH7ffLjVoYFormjc363j4armIizNrXgAAogPBAhEVHy/deKO5nc2ypCee8L18uWVJf/yjVLNmaGsEAASOrhBEtaFDpZdflipVMkGiQgUzW8TtlsaNk/73fyNdIQDgTLRYIOrdcYdptXj7bWnbNtNCcf31Uv36ka4MAHA2goXDtm83izkdO2Y21LrkEva7cEJiolmzAgAQ3QgWDjlxQvrDH6Q33jD3XS4zZbJxY2nGDKl378jWBwBAOBAsHDJ8uDRvXsHshbxFnXbuNK0W33xjWjCKk5srvf++tGyZef7FF5s1HMrSpmMAgPKBbdMdsHq11K2b78fj4qTrrpNmziz62Pr10uDBpgslL0icOiU1bGj2wejUKTQ1AwAQDLZND6OZM0148CU3V5ozR8rJKXz80CGpXz9p1y5z/9Spgn0v9u6V+vc3S1YDABArCBYOOHSo5HNyc6WjRwsfe+UV6ddfi98Lw+ORjhyRpk1zpEQAAMKCYOGApk1L3tMiMbHo0tOzZxfeCvxsXq85p6xavVq69Vapbl2pVi3pmmvMOBMAQOwiWDjgttv8BwS32yxTfXZ3SVZWya8dyDmx6LXXpO7dTTfS/v2m1eeDD8yOpk8+GenqAAClRbBwQOPG0qOPFv9YXJwZiDl+fNHHOnTwPzbD7TbnlDUbNpg1KWzbdBHlyfv+wQelzz6LTG1n8nikjz6S/vpXadIk6bvvIl0RAEQ/goVDHnlEeuklqVGjgmNxcdJvfyutWCHVqVP0OXfdVfiD9WwejzmnrJk61azz4UtcnPTCC+GrpzirV5sN0AYPlh57THr4YalzZ2ngwMDG1ABAecV0U4d5PNJ//2tW3mzVSqpd2/e5ti2NGmUGaFpWwTiNvO9HjpT+9S9zvyzp1s18cPtTp460b1946jnb1q1mmu+xY0UH1rrdZgfWFStYURVA+cJ00wjJ++Dp3dt/qJBMYHjxRfMbfPPmBcebNpX+8Q8za6SshQopsA/kSH5oP/usdPy479k6q1aZNUYAAEUFHSyWL1+uK6+8Ug0aNJBlWZo3b14Iyio/LMu0WmzYIO3ZI+3eLW3aJKWl+e8uiGWXX+4/OMTFSYMGha+es735pv8uKrdbmjUrfPUAQCwJ+qMrOztbnTp10pQpU0JRT7llWVK9embHzrLYSnGm3/9eio/3/ef0eqV77w1vTWcqaSaOxyMdPhyeWgAg1gS9V8igQYM0KIhfJ3NycpRzxpKTmZmZwV4SZUzDhtK770pXX21WI82bqpvXivH661LHjpGrr0kTafNm34/HxUktWoStHACIKSHfhCw9PV0TJ04M9WUQI7ZsMWNKFiww03STk80y5vHxZvO1UaOkZs0iW+Ndd0l/+pPvRc9yc6U77wxvTQAQK85pVohlWZo7d66GDBni85ziWixSUlLK7KwQ+DZvnjR0qGmhyBsY6XabD/Dp080qnNHg2DGzUNeaNcUP4Bw3TnrmmbCXBQARFTWzQhISEpSUlFTohvJn61YTKnJzC39YezwmaIwcaabpRoPKlaXFi80A2ipVCo6npJjZOk8/HbnaACDaldF5B4g2U6eaAOGrfczlkp5/Prw1+VO1qqln3z7p22+l77834SgtrewPrgWAcxHyMRaAJH3ySfHdCnlyc6WFC8NXT6CqVDErbgIAAhN0sDh69Kg2bdqUf3/r1q1au3atatSoocaNGztaHMqOQEbyhHcNWABAKATdFbJq1Sp16dJFXbp0kSSNGzdOXbp00V/+8hfHi0PZ0a9fyYti9esXvnoAAKHBXiEIiw0bpLZtfXeHWJb0zTdmHxEAQPSJmlkhgGQ2ZHvtNTNI88yt4uPiTKj4xz8IFQBQFjB4E2EzfLhZUfMf/zALZHm9Uv/+0ujRhAoAKCsIFgirDh2kl16KdBUAgFChKwQAADiGYAEAABxDsAAAAI4hWAAAAMcQLAAAgGMIFgAAwDEECwAA4BjWsSinbNssof3BB1JOjnT++dI110gJCZGuDAAQywgW5dCBA9K110qff16wpPapU1LNmtKcOVLfvpGuEAAQq+gKKWc8Hunyy6WvvjL3c3NNqJCkw4elQYOk77+PXH0AgNhGsChn5s+X1qwpfpdRr9cEjaefDn9dAICygWBRzrz9duHdRc+WmyvNnm3GYAAAECyCRTmTlWXCgz/Hj5vWCwAAgkWwKGdatZLcbv/npKaWfA4AAMUhWJQzd9zhvzXC5ZLS0sJXDwCgbCFYlDMtWkiPPWa+t6zCj7ndUvfu0ujR4a8LAFA2ECzKoT//WXrzTalNm4JjycnS/fdLixZJlSpFrjYAQGyzbDu84/8zMzOVnJysjIwMJSUlhfPSOIttSzt3mpU3U1JYdRMA4Fugn9+svFmOWZYJFAAAOIWuEAAA4BiCBQAAcAzBAgAAOIZgAQAAHEOwAAAAjiFYAAAAxxAsAACAYwgWAADAMQQLAADgGIIFAABwDMECAAA4hmABAAAcQ7AAAACOIVgAAADHECwAAIBjCBYAAMAxBAsAAOAYggUAAHAMwQIAADiGYAEAABxDsAAAAI4hWAAAAMcQLAAAgGMIFgAAwDEECwAA4JhSBYspU6aoSZMmqlixonr06KFvvvnG6boAAEAMCjpYzJ49W+PGjdOECRO0Zs0aderUSZdddpn2798fivoAAEAMCTpYPPvss7rzzjs1cuRItW3bVi+++KIqV66sf//736GoDwAAxJC4YE4+efKkVq9erfHjx+cfc7lcGjhwoL766qtin5OTk6OcnJz8+xkZGZKkzMzM0tQLAAAiIO9z27Ztv+cFFSwOHjwoj8ejunXrFjpet25d/fTTT8U+Jz09XRMnTixyPCUlJZhLAwCAKJCVlaXk5GSfjwcVLEpj/PjxGjduXP79I0eOKDU1Vdu3b/dbGIrKzMxUSkqKduzYoaSkpEiXEzN430qP9670eO9Kj/eu9EL53tm2raysLDVo0MDveUEFi1q1asntdmvfvn2Fju/bt0/16tUr9jkJCQlKSEgocjw5OZm/MKWUlJTEe1cKvG+lx3tXerx3pcd7V3qheu8CaRAIavBmfHy8unbtqkWLFuUf83q9WrRokXr27Bl8hQAAoEwJuitk3LhxGjFihLp166YLLrhAkydPVnZ2tkaOHBmK+gAAQAwJOljccMMNOnDggP7yl79o79696ty5sz7++OMiAzp9SUhI0IQJE4rtHoF/vHelw/tWerx3pcd7V3q8d6UXDe+dZZc0bwQAACBA7BUCAAAcQ7AAAACOIVgAAADHECwAAIBjCBYAAMAxYQ0WU6ZMUZMmTVSxYkX16NFD33zzTTgvH7OWL1+uK6+8Ug0aNJBlWZo3b16kS4oJ6enp6t69uxITE1WnTh0NGTJEP//8c6TLiglTp05Vx44d81fv69mzp+bPnx/psmLSpEmTZFmWxo4dG+lSot6jjz4qy7IK3Vq3bh3psmLGrl27dPPNN6tmzZqqVKmSOnTooFWrVoW9jrAFi9mzZ2vcuHGaMGGC1qxZo06dOumyyy7T/v37w1VCzMrOzlanTp00ZcqUSJcSU5YtW6a0tDStWLFCCxcu1KlTp3TppZcqOzs70qVFvUaNGmnSpElavXq1Vq1apf79++vqq6/W999/H+nSYsrKlSv10ksvqWPHjpEuJWa0a9dOe/bsyb99/vnnkS4pJhw+fFi9e/dWhQoVNH/+fP3www965plnVL169fAXY4fJBRdcYKelpeXf93g8doMGDez09PRwlVAmSLLnzp0b6TJi0v79+21J9rJlyyJdSkyqXr26/corr0S6jJiRlZVlt2zZ0l64cKHdp08f+9577410SVFvwoQJdqdOnSJdRkx64IEH7AsvvDDSZdi2bdthabE4efKkVq9erYEDB+Yfc7lcGjhwoL766qtwlAAoIyNDklSjRo0IVxJbPB6PZs2apezsbPYECkJaWpoGDx5c6P89lGzjxo1q0KCBmjVrpuHDh2v79u2RLikmvPfee+rWrZuuv/561alTR126dNHLL78ckVrCEiwOHjwoj8dTZNnvunXrau/eveEoAeWc1+vV2LFj1bt3b7Vv3z7S5cSEdevWqWrVqkpISNCoUaM0d+5ctW3bNtJlxYRZs2ZpzZo1Sk9Pj3QpMaVHjx569dVX9fHHH2vq1KnaunWrLrroImVlZUW6tKi3ZcsWTZ06VS1bttSCBQt01113acyYMXrttdfCXkvQe4UAsSgtLU3r16+nvzYI5513ntauXauMjAzNmTNHI0aM0LJlywgXJdixY4fuvfdeLVy4UBUrVox0OTFl0KBB+d937NhRPXr0UGpqqt566y3dfvvtEaws+nm9XnXr1k1PPPGEJKlLly5av369XnzxRY0YMSKstYSlxaJWrVpyu93at29foeP79u1TvXr1wlECyrHRo0frgw8+0JIlS9SoUaNIlxMz4uPj1aJFC3Xt2lXp6enq1KmTnn/++UiXFfVWr16t/fv36/zzz1dcXJzi4uK0bNkyvfDCC4qLi5PH44l0iTGjWrVqatWqlTZt2hTpUqJe/fr1i4T+Nm3aRKQrKSzBIj4+Xl27dtWiRYvyj3m9Xi1atIg+W4SMbdsaPXq05s6dq8WLF6tp06aRLimmeb1e5eTkRLqMqDdgwACtW7dOa9euzb9169ZNw4cP19q1a+V2uyNdYsw4evSoNm/erPr160e6lKjXu3fvItPpN2zYoNTU1LDXEraukHHjxmnEiBHq1q2bLrjgAk2ePFnZ2dkaOXJkuEqIWUePHi2U2Ldu3aq1a9eqRo0aaty4cQQri25paWmaMWOG3n33XSUmJuaP50lOTlalSpUiXF10Gz9+vAYNGqTGjRsrKytLM2bM0NKlS7VgwYJIlxb1EhMTi4zjqVKlimrWrMn4nhLcf//9uvLKK5Wamqrdu3drwoQJcrvduummmyJdWtS777771KtXLz3xxBMaOnSovvnmG02bNk3Tpk0LfzHhnILy97//3W7cuLEdHx9vX3DBBfaKFSvCefmYtWTJEltSkduIESMiXVpUK+49k2RPnz490qVFvd/97nd2amqqHR8fb9euXdseMGCA/cknn0S6rJjFdNPA3HDDDXb9+vXt+Ph4u2HDhvYNN9xgb9q0KdJlxYz333/fbt++vZ2QkGC3bt3anjZtWkTqsGzbtsMfZwAAQFnEXiEAAMAxBAsAAOAYggUAAHAMwQIAADiGYAEAABxDsAAAAI4hWAAAAMcQLAAAgGMIFgAAwDEECwAA4BiCBQAAcMz/BzA9vuJA7l8fAAAAAElFTkSuQmCC", + "image/png": "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", "text/plain": [ "
" ] @@ -577,12 +724,562 @@ }, { "cell_type": "markdown", - "id": "27", + "id": "35", + "metadata": {}, + "source": [ + "## Example 2: Puali and Bloch Sphere Feature Map on a Complex Data Set" + ] + }, + { + "cell_type": "markdown", + "id": "36", + "metadata": {}, + "source": [ + "We begin by importing the relevant software packages" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "37", + "metadata": {}, + "outputs": [], + "source": [ + "from itertools import combinations, islice\n", + "\n", + "from qiskit_algorithms.utils import algorithm_globals\n", + "from qiskit_machine_learning.datasets import ad_hoc_data" + ] + }, + { + "cell_type": "markdown", + "id": "38", + "metadata": {}, + "source": [ + "We consider a more complicated classification task, utilizing qiskit's ad_hoc_data, we generate a data set which can be fully separated by ZZ feature map [[3](#)] " + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "39", + "metadata": {}, + "outputs": [], + "source": [ + "seed = 12345\n", + "algorithm_globals.random_seed = seed\n", + "\n", + "adhoc_dimension = 2\n", + "\n", + "TRAIN_DATA_2, TRAIN_LABELS_2, test_features, test_labels, ad_hoc_total = ad_hoc_data(\n", + " training_size=20,\n", + " test_size=5 + 5, # 5 for test, 5 for predict\n", + " n=adhoc_dimension,\n", + " gap=0.3,\n", + " plot_data=False,\n", + " one_hot=False,\n", + " include_sample_total=True,\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "40", + "metadata": {}, + "source": [ + "Next we split the test features and labels to a test and prediction set." + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "41", + "metadata": {}, + "outputs": [], + "source": [ + "# the sizes of the `test_features` and `test_labels` are double those of the `test_size` argument\n", + "# Since there are `test_size` items for each `adhoc_dimension`\n", + "\n", + "\n", + "def split(obj: np.ndarray, n: int = 20):\n", + " quarter = n // 4\n", + " half = n // 2\n", + " first = np.concatenate((obj[:quarter], obj[half : half + quarter]))\n", + " second = np.concatenate((obj[quarter:half], obj[half + quarter :]))\n", + " return first, second\n", + "\n", + "\n", + "TEST_DATA_2, PREDICT_DATA_2 = split(test_features)\n", + "TEST_LABELS_2, predict_real_labels_2 = split(test_labels)" + ] + }, + { + "cell_type": "markdown", + "id": "42", + "metadata": {}, + "source": [ + "The data can be visualised by a color coded plot" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "43", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Plot data\n", + "import matplotlib.pyplot as plt\n", + "\n", + "plt.scatter(\n", + " TRAIN_DATA_2[np.where(TRAIN_LABELS_2[:] == 0), 0],\n", + " TRAIN_DATA_2[np.where(TRAIN_LABELS_2[:] == 0), 1],\n", + " marker=\"s\",\n", + " facecolors=\"w\",\n", + " edgecolors=\"b\",\n", + " label=\"A train\",\n", + ")\n", + "plt.scatter(\n", + " TRAIN_DATA_2[np.where(TRAIN_LABELS_2[:] == 1), 0],\n", + " TRAIN_DATA_2[np.where(TRAIN_LABELS_2[:] == 1), 1],\n", + " marker=\"o\",\n", + " facecolors=\"w\",\n", + " edgecolors=\"r\",\n", + " label=\"B train\",\n", + ")\n", + "plt.scatter(\n", + " TEST_DATA_2[np.where(TEST_LABELS_2[:] == 0), 0],\n", + " TEST_DATA_2[np.where(TEST_LABELS_2[:] == 0), 1],\n", + " marker=\"s\",\n", + " facecolors=\"b\",\n", + " edgecolors=\"w\",\n", + " label=\"A test\",\n", + ")\n", + "plt.scatter(\n", + " TEST_DATA_2[np.where(TEST_LABELS_2[:] == 1), 0],\n", + " TEST_DATA_2[np.where(TEST_LABELS_2[:] == 1), 1],\n", + " marker=\"o\",\n", + " facecolors=\"r\",\n", + " edgecolors=\"w\",\n", + " label=\"B test\",\n", + ")\n", + "\n", + "plt.legend(bbox_to_anchor=(1.05, 1), loc=\"upper left\", borderaxespad=0.0)\n", + "plt.title(\"Ad hoc dataset for classification\")\n", + "\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "44", + "metadata": {}, + "source": [ + "### Pauli Feature Map" + ] + }, + { + "cell_type": "markdown", + "id": "45", + "metadata": {}, + "source": [ + "We build a Pauli feature map. This feature map is of size $N$ qubits for data $\\mathbf{x}$ of size $N$, and it corresponds to the following unitary:\n", + "$$\n", + "U = \\left(\\hbox{Hadamarad Transform}\\right) \\exp\\left(\\sum f^{(1)}_k(\\mathbf{x})H^{(1)}_k + \\sum f^{(2)}_k(\\mathbf{x})H^{(2)}_k+\\dots \\right)~~,\n", + "$$\n", + "where $H^{(i)}$ is a Hamiltonian acting on $i$ qubits according to some connectivity map, and $f^{(i)}$ is some classical function, typically taken as the polynomial of degree $i$. For example, if our data is of size $3$ and we assume circular connectivity, taking Hamiltonians depending only on $Z$, the Hamiltonian reads as\n", + "$$\n", + "\\sum f^{(1)}_k(\\mathbf{x})H^{(1)}_k = \\alpha(x_0+\\beta)ZII+\\alpha(x_1+\\beta)IZI+\\alpha(x_2+\\beta)IIZ,\n", + "$$\n", + "$$\n", + "\\sum f^{(2)}_k(\\mathbf{x})H^{(2)}_k = \\gamma^2(x_0+\\zeta)(x_1+\\zeta)ZZI+\\gamma^2(x_1+\\zeta)(x_2+\\zeta)IZZ + \\gamma^2(x_0+\\zeta)(x_3+\\zeta)ZIZ~~,\n", + "$$\n", + "where $(\\alpha,\\beta)$ and $(\\gamma,\\zeta)$ define some affine transformation on the data and correspond to the functions $f^{(1,2)}$.\n", + "\n", + "We start by defining classical functions for creating a connectivity map for the Hamiltonians and for generating the full Hamiltonian:" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "46", + "metadata": {}, + "outputs": [], + "source": [ + "def generate_connectivity_map(list_size, sublist_size, connectivity_type):\n", + " \"\"\"\n", + " Generate connectivity for a given list size and sublist size.\n", + "\n", + " Parameters:\n", + " - list_size: The size of the list (number of elements).\n", + " - sublist_size: The size of the subsets to generate.\n", + " - connectivity_type: an integer (0 for linear, 1 for circular, 2 for full)\n", + "\n", + " Returns:\n", + " - A list of all unique subsets of the given size.\n", + " \"\"\"\n", + " assert connectivity_type in [\n", + " 0,\n", + " 1,\n", + " 2,\n", + " ], \"connectivity must be 0 (linear), 1 (circular), or 2 (full)\"\n", + "\n", + " if connectivity_type == 0: # linear\n", + " return [\n", + " list(range(i, i + sublist_size))\n", + " for i in range(list_size - sublist_size + 1)\n", + " ]\n", + "\n", + " elif connectivity_type == 1: # circular\n", + " return [\n", + " [(i + j) % list_size for j in range(sublist_size)] for i in range(list_size)\n", + " ]\n", + "\n", + " elif connectivity_type == 2: # full\n", + " return [list(comb) for comb in combinations(range(list_size), sublist_size)]\n", + "\n", + "\n", + "def generate_hamiltonian(\n", + " data: CArray[CReal],\n", + " paulis_list: list[list[Pauli]],\n", + " affines: list[list[float]],\n", + " connectivity: int,\n", + ") -> tuple[list[SparsePauliOp], list[CReal]]:\n", + " assert connectivity in [\n", + " 0,\n", + " 1,\n", + " 2,\n", + " ], \"connectivity must be 0 (linear), 1 (circular) or 2 (full)\"\n", + " hs = []\n", + " coeffs = []\n", + " for paulis, affine in zip(paulis_list, affines):\n", + " indices = generate_connectivity_map(data.len, len(paulis), connectivity)\n", + " for k in range(len(indices)):\n", + " indexed_paulis = [\n", + " IndexedPauli(pauli=paulis[j], index=indices[k][j])\n", + " for j in range(len(indices[0]))\n", + " ]\n", + " hs.append(\n", + " SparsePauliOp(\n", + " terms=[SparsePauliTerm(paulis=indexed_paulis, coefficient=1)],\n", + " num_qubits=data.len,\n", + " )\n", + " )\n", + " coe = np.prod(\n", + " [\n", + " affine[0] * (data[indices[k][j]] - affine[1])\n", + " for j in range(len(indices[0]))\n", + " ]\n", + " )\n", + " coeffs.append(coe)\n", + "\n", + " return hs, coeffs" + ] + }, + { + "cell_type": "markdown", + "id": "47", + "metadata": {}, + "source": [ + "Next, we define a quantum function for the Pauli feature map:" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "id": "48", + "metadata": {}, + "outputs": [], + "source": [ + "@qfunc\n", + "def pauli_kernel(\n", + " data: CArray[CReal],\n", + " paulis_list: list[list[Pauli]],\n", + " affines: list[list[float]],\n", + " connectivity: int,\n", + " reps: CInt,\n", + " qba: QArray,\n", + ") -> None:\n", + " hs, coeffs = generate_hamiltonian(data, paulis_list, affines, connectivity)\n", + " power(\n", + " reps,\n", + " lambda: (\n", + " hadamard_transform(qba),\n", + " multi_suzuki_trotter(\n", + " hamiltonians=hs,\n", + " evolution_coefficients=coeffs,\n", + " order=1,\n", + " repetitions=1,\n", + " qbv=qba,\n", + " ),\n", + " ),\n", + " )" + ] + }, + { + "cell_type": "markdown", + "id": "49", + "metadata": {}, + "source": [ + "Finally, we construct the quantum model for the QSVM routine:" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "id": "50", + "metadata": {}, + "outputs": [], + "source": [ + "N_DIM = 2\n", + "PAULIS = [[Pauli.Z], [Pauli.Z, Pauli.Z]]\n", + "CONNECTIVITY = 2\n", + "AFFINES = [[1, 0], [1, np.pi]]\n", + "REPS = 2" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "id": "51", + "metadata": {}, + "outputs": [], + "source": [ + "@qfunc\n", + "def main(data1: CArray[CReal, N_DIM], data2: CArray[CReal, N_DIM], qba: Output[QNum]):\n", + " allocate(data1.len, qba)\n", + " pauli_kernel(data1, PAULIS, AFFINES, CONNECTIVITY, REPS, qba)\n", + " invert(lambda: pauli_kernel(data2, PAULIS, AFFINES, CONNECTIVITY, REPS, qba))\n", + "\n", + "\n", + "QSVM_PAULI_Z_ZZ = create_model(main)\n", + "write_qmod(QSVM_PAULI_Z_ZZ, \"qsvm_pauli_feature_map\", symbolic_only=False)" + ] + }, + { + "cell_type": "markdown", + "id": "52", + "metadata": {}, + "source": [ + "### Viewing the Model's Parameterized Quantum Circuit" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "id": "53", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Quantum program link: https://platform.classiq.io/circuit/37qLKOEyb6gqJkON866KR3ewleP\n" + ] + } + ], + "source": [ + "qprog_pauli = synthesize(main)\n", + "show(qprog_pauli)" + ] + }, + { + "cell_type": "markdown", + "id": "54", + "metadata": {}, + "source": [ + "### Executing QSVM\n", + "Similarly to the previous example, we first train, then test and evaluate the quality of classification, and finally perform predictions on an unlabelled data set." + ] + }, + { + "cell_type": "markdown", + "id": "55", + "metadata": {}, + "source": [ + "We can now run the execution session with all three parts, first for the Pauli feature map and then for the Bloch sphere map." + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "id": "56", + "metadata": {}, + "outputs": [], + "source": [ + "with ExecutionSession(qprog_pauli) as es:\n", + " # train\n", + " svm_model_pauli = train_svm(es, TRAIN_DATA_2.tolist(), TRAIN_LABELS_2.tolist())\n", + "\n", + " # test\n", + " y_test_pauli = predict_svm(\n", + " es, TEST_DATA_2.tolist(), TRAIN_DATA_2.tolist(), svm_model_pauli\n", + " )\n", + " test_score_pauli = sum(y_test_pauli == TEST_LABELS_2.tolist()) / len(\n", + " TEST_LABELS_2.tolist()\n", + " )\n", + " # print(\"quantum kernel classification test score: %0.2f\" % (test_score))\n", + "\n", + " # predict\n", + " predicted_labels_pauli = predict_svm(\n", + " es, PREDICT_DATA_2.tolist(), TRAIN_DATA_2.tolist(), svm_model_pauli\n", + " )" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "id": "57", + "metadata": {}, + "outputs": [], + "source": [ + "with ExecutionSession(qprog_bloch) as es:\n", + " # train\n", + " svm_model_bloch = train_svm(es, TRAIN_DATA_2.tolist(), TRAIN_LABELS_2.tolist())\n", + "\n", + " # test\n", + " y_test_bloch = predict_svm(\n", + " es, TEST_DATA_2.tolist(), TRAIN_DATA_2.tolist(), svm_model_bloch\n", + " )\n", + " test_score_bloch = sum(y_test_bloch == TEST_LABELS_2.tolist()) / len(\n", + " TEST_LABELS_2.tolist()\n", + " )\n", + "\n", + " # predict\n", + " predicted_labels_bloch = predict_svm(\n", + " es, PREDICT_DATA_2.tolist(), TRAIN_DATA_2.tolist(), svm_model_bloch\n", + " )" + ] + }, + { + "cell_type": "markdown", + "id": "58", + "metadata": {}, + "source": [ + "### Results" + ] + }, + { + "cell_type": "markdown", + "id": "59", + "metadata": {}, + "source": [ + "The Pauli feature map accurately classifies the test and prediction data sets." + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "id": "60", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Testing success ratio for the Pauli feature map: 1.0\n", + "\n", + "Prediction from datapoints set:\n", + " ground truth: [0 0 0 0 0 1 1 1 1 1]\n", + " prediction: [0 0 0 0 0 1 1 1 1 1]\n", + " success rate: 100.0%\n" + ] + } + ], + "source": [ + "# Printing tests result\n", + "print(f\"Testing success ratio for the Pauli feature map: {test_score_pauli}\")\n", + "print()\n", + "# Printing predictions\n", + "print(\"Prediction from datapoints set:\")\n", + "print(f\" ground truth: {predict_real_labels_2}\")\n", + "print(f\" prediction: {predicted_labels_pauli}\")\n", + "print(\n", + " f\" success rate: {100 * np.count_nonzero(predicted_labels_pauli == predict_real_labels_2) / len(predicted_labels_pauli)}%\"\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "61", + "metadata": {}, + "source": [ + "In comparison, the Bloch sphere feature map manages to classify 60% of the test data set and only half of the prediction data set." + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "id": "62", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Testing success ratio for the Bloch sphere feature map: 0.6\n", + "\n", + "Prediction from datapoints set:\n", + " ground truth: [0 0 0 0 0 1 1 1 1 1]\n", + " prediction: [1 1 0 0 0 1 1 0 0 0]\n", + " success rate: 50.0%\n" + ] + } + ], + "source": [ + "# Printing tests result\n", + "print(f\"Testing success ratio for the Bloch sphere feature map: {test_score_bloch}\")\n", + "print()\n", + "# Printing predictions\n", + "print(\"Prediction from datapoints set:\")\n", + "print(f\" ground truth: {predict_real_labels_2}\")\n", + "print(f\" prediction: {predicted_labels_bloch}\")\n", + "print(\n", + " f\" success rate: {100 * np.count_nonzero(predicted_labels_bloch == predict_real_labels_2) / len(predicted_labels_bloch)}%\"\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "63", + "metadata": {}, + "source": [ + "## Summary and Discussion" + ] + }, + { + "cell_type": "markdown", + "id": "64", + "metadata": {}, + "source": [ + "The notebook demonstrated the application of the Quantum Support Vector Machine (QSVM) algorithm to supervised data classification tasks. Two datasets were analyzed using two distinct quantum feature maps: a Bloch-sphere–based encoding and a Pauli-based feature map. The Bloch-sphere mapping achieved perfect classification accuracy on a linearly separable dataset but showed only moderate performance when applied to a more complex, nonlinearly separable dataset. In contrast, the Pauli feature map successfully captured the structure of the complex dataset and yielded accurate classification results.\n", + "\n", + "These results emphasize a central consideration in QSVM design: the choice of quantum feature map plays a decisive role in model performance. Effective alignment between the feature map and the underlying structure of the data is essential for achieving high classification accuracy." + ] + }, + { + "cell_type": "markdown", + "id": "65", "metadata": {}, "source": [ "## Reference\n", "\n", - "[1] [Havlíček, V., Córcoles, A.D., Temme, K. et al. Supervised learning with quantum-enhanced feature spaces. Nature 567, 209-212 (2019).](https://doi.org/10.1038/s41586-019-0980-2)" + "[1] [Havlíček, V., Córcoles, A.D., Temme, K. et al. Supervised learning with quantum-enhanced feature spaces. Nature 567, 209-212 (2019).](https://doi.org/10.1038/s41586-019-0980-2)\n", + "\n", + "[2] [Karush–Kuhn–Tucker conditions](https://en.wikipedia.org/wiki/Karush%E2%80%93Kuhn%E2%80%93Tucker_conditions)\n", + "\n", + "[3][Havlíček, V., Córcoles, A. D., Temme, K., Harrow, A. W., Kandala, A., Chow, J. M., & Gambetta, J. M. (2019). Supervised learning with quantum-enhanced feature spaces. Nature, 567(7747), 209-212.](https://arxiv.org/abs/1804.11326)\n" ] } ], @@ -602,7 +1299,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.11.9" + "version": "3.11.7" }, "vscode": { "interpreter": { diff --git a/algorithms/qml/qsvm/qsvm.qmod b/algorithms/qml/qsvm/qsvm.qmod deleted file mode 100644 index 09bfe5111..000000000 --- a/algorithms/qml/qsvm/qsvm.qmod +++ /dev/null @@ -1,16 +0,0 @@ -qfunc bloch_feature_map(data: real[], qba: qbit[]) { - repeat (i: ceiling(data.len / 2)) { - RX(data[2 * i] / 2, qba[i]); - } - repeat (i: floor(data.len / 2)) { - RZ(data[(2 * i) + 1], qba[i]); - } -} - -qfunc main(data1: real[2], data2: real[2], output qba: qnum) { - allocate(qba); - bloch_feature_map(data1, qba); - invert { - bloch_feature_map(data2, qba); - } -} diff --git a/algorithms/qml/qsvm/qsvm_bloch_sphere_feature_map.qmod b/algorithms/qml/qsvm/qsvm_bloch_sphere_feature_map.qmod new file mode 100644 index 000000000..c2a866c37 --- /dev/null +++ b/algorithms/qml/qsvm/qsvm_bloch_sphere_feature_map.qmod @@ -0,0 +1,16 @@ +qfunc bloch_feature_map_expanded___0(data: real[2], qba: qbit[1]) { + repeat (i: 1) { + RX(data[2 * i] / 2, qba[i]); + } + repeat (i: 1) { + RZ(data[(2 * i) + 1], qba[i]); + } +} + +qfunc main(data1: real[2], data2: real[2], output qba: qnum<1, False, 0>) { + allocate(1, qba); + bloch_feature_map_expanded___0(data1, qba); + invert { + bloch_feature_map_expanded___0(data2, qba); + } +} diff --git a/algorithms/qml/qsvm/qsvm.synthesis_options.json b/algorithms/qml/qsvm/qsvm_bloch_sphere_feature_map.synthesis_options.json similarity index 86% rename from algorithms/qml/qsvm/qsvm.synthesis_options.json rename to algorithms/qml/qsvm/qsvm_bloch_sphere_feature_map.synthesis_options.json index 6f103111c..6dd8d6878 100644 --- a/algorithms/qml/qsvm/qsvm.synthesis_options.json +++ b/algorithms/qml/qsvm/qsvm_bloch_sphere_feature_map.synthesis_options.json @@ -1,41 +1,42 @@ { "constraints": { + "max_gate_count": {}, "optimization_parameter": "no_opt" }, "preferences": { "custom_hardware_settings": { "basis_gates": [ - "t", + "u1", + "u2", + "z", + "rx", "cz", - "sx", + "t", + "u", + "id", "rz", - "rx", + "cx", + "tdg", + "sdg", "p", - "z", - "sxdg", + "ry", "h", + "y", + "sxdg", + "sx", "cy", - "u", - "r", - "u1", - "sdg", - "s", - "u2", - "tdg", - "id", - "ry", "x", - "cx", - "y" + "r", + "s" ], "is_symmetric_connectivity": true }, "debug_mode": true, "machine_precision": 8, - "optimization_level": 3, + "optimization_level": 1, "output_format": ["qasm"], "pretty_qasm": true, - "random_seed": 1598682726, + "random_seed": 2336470090, "synthesize_all_separately": false, "timeout_seconds": 300, "transpilation_option": "auto optimize" diff --git a/algorithms/qml/qsvm_pauli_feature_map/qsvm_pauli_feature_map.qmod b/algorithms/qml/qsvm/qsvm_pauli_feature_map.qmod similarity index 100% rename from algorithms/qml/qsvm_pauli_feature_map/qsvm_pauli_feature_map.qmod rename to algorithms/qml/qsvm/qsvm_pauli_feature_map.qmod diff --git a/algorithms/qml/qsvm_pauli_feature_map/qsvm_pauli_feature_map.synthesis_options.json b/algorithms/qml/qsvm/qsvm_pauli_feature_map.synthesis_options.json similarity index 89% rename from algorithms/qml/qsvm_pauli_feature_map/qsvm_pauli_feature_map.synthesis_options.json rename to algorithms/qml/qsvm/qsvm_pauli_feature_map.synthesis_options.json index ef374d418..856c4c791 100644 --- a/algorithms/qml/qsvm_pauli_feature_map/qsvm_pauli_feature_map.synthesis_options.json +++ b/algorithms/qml/qsvm/qsvm_pauli_feature_map.synthesis_options.json @@ -1,32 +1,33 @@ { "constraints": { + "max_gate_count": {}, "optimization_parameter": "no_opt" }, "preferences": { "custom_hardware_settings": { "basis_gates": [ - "sdg", - "cx", + "u1", + "u2", + "z", + "rx", + "cz", "t", - "ry", - "rz", "u", + "id", + "rz", + "cx", "tdg", - "y", + "sdg", + "p", + "ry", "h", - "u1", + "y", + "sxdg", "sx", - "s", - "cz", - "x", - "p", "cy", - "rx", - "sxdg", - "id", + "x", "r", - "u2", - "z" + "s" ], "is_symmetric_connectivity": true }, @@ -35,7 +36,7 @@ "optimization_level": 1, "output_format": ["qasm"], "pretty_qasm": true, - "random_seed": 3113768414, + "random_seed": 3912696462, "synthesize_all_separately": false, "timeout_seconds": 300, "transpilation_option": "auto optimize" diff --git a/algorithms/qml/qsvm_pauli_feature_map/qsvm_pauli_feature_map.ipynb b/algorithms/qml/qsvm_pauli_feature_map/qsvm_pauli_feature_map.ipynb deleted file mode 100644 index 7c4a2419a..000000000 --- a/algorithms/qml/qsvm_pauli_feature_map/qsvm_pauli_feature_map.ipynb +++ /dev/null @@ -1,600 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "id": "0", - "metadata": {}, - "source": [ - "## Generating Qiskit's Data" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "1", - "metadata": {}, - "outputs": [], - "source": [ - "!pip install -qq -U \"classiq[qml]\"" - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "id": "2", - "metadata": {}, - "outputs": [], - "source": [ - "from itertools import combinations\n", - "\n", - "from qiskit_algorithms.utils import algorithm_globals\n", - "from qiskit_machine_learning.datasets import ad_hoc_data\n", - "from sklearn.svm import SVC\n", - "\n", - "from classiq import *\n", - "\n", - "seed = 12345\n", - "algorithm_globals.random_seed = seed\n", - "\n", - "adhoc_dimension = 2\n", - "train_features, train_labels, test_features, test_labels, adhoc_total = ad_hoc_data(\n", - " training_size=20,\n", - " test_size=5 + 5, # 5 for test, 5 for predict\n", - " n=adhoc_dimension,\n", - " gap=0.3,\n", - " plot_data=False,\n", - " one_hot=False,\n", - " include_sample_total=True,\n", - ")" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "id": "3", - "metadata": {}, - "outputs": [], - "source": [ - "# the sizes of the `test_features` and `test_labels` are double those of the `test_size` argument\n", - "# Since there are `test_size` items for each `adhoc_dimension`\n", - "import numpy as np\n", - "\n", - "\n", - "def split(obj: np.ndarray, n: int = 20):\n", - " quarter = n // 4\n", - " half = n // 2\n", - " first = np.concatenate((obj[:quarter], obj[half : half + quarter]))\n", - " second = np.concatenate((obj[quarter:half], obj[half + quarter :]))\n", - " return first, second\n", - "\n", - "\n", - "test_features, predict_features = split(test_features)\n", - "test_labels, predict_labels = split(test_labels)" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "id": "4", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "# Plot data\n", - "import matplotlib.pyplot as plt\n", - "import numpy as np\n", - "\n", - "plt.figure(figsize=(5, 5))\n", - "plt.ylim(0, 2 * np.pi)\n", - "plt.xlim(0, 2 * np.pi)\n", - "plt.imshow(\n", - " np.asmatrix(adhoc_total).T,\n", - " interpolation=\"nearest\",\n", - " origin=\"lower\",\n", - " cmap=\"RdBu\",\n", - " extent=[0, 2 * np.pi, 0, 2 * np.pi],\n", - ")\n", - "\n", - "plt.scatter(\n", - " train_features[np.where(train_labels[:] == 0), 0],\n", - " train_features[np.where(train_labels[:] == 0), 1],\n", - " marker=\"s\",\n", - " facecolors=\"w\",\n", - " edgecolors=\"b\",\n", - " label=\"A train\",\n", - ")\n", - "plt.scatter(\n", - " train_features[np.where(train_labels[:] == 1), 0],\n", - " train_features[np.where(train_labels[:] == 1), 1],\n", - " marker=\"o\",\n", - " facecolors=\"w\",\n", - " edgecolors=\"r\",\n", - " label=\"B train\",\n", - ")\n", - "plt.scatter(\n", - " test_features[np.where(test_labels[:] == 0), 0],\n", - " test_features[np.where(test_labels[:] == 0), 1],\n", - " marker=\"s\",\n", - " facecolors=\"b\",\n", - " edgecolors=\"w\",\n", - " label=\"A test\",\n", - ")\n", - "plt.scatter(\n", - " test_features[np.where(test_labels[:] == 1), 0],\n", - " test_features[np.where(test_labels[:] == 1), 1],\n", - " marker=\"o\",\n", - " facecolors=\"r\",\n", - " edgecolors=\"w\",\n", - " label=\"B test\",\n", - ")\n", - "\n", - "plt.legend(bbox_to_anchor=(1.05, 1), loc=\"upper left\", borderaxespad=0.0)\n", - "plt.title(\"Ad hoc dataset for classification\")\n", - "\n", - "plt.show()" - ] - }, - { - "cell_type": "markdown", - "id": "5", - "metadata": {}, - "source": [ - "## Building Classiq's QSVM" - ] - }, - { - "cell_type": "markdown", - "id": "6", - "metadata": {}, - "source": [ - "We build a Pauli feature map. This feature map is of size $N$ qubits for data $\\vec{x}$ of size $N$, and it corresponds to the following unitary:\n", - "$$\n", - "U = \\left(\\hbox{Hadamarad Transform}\\right) \\exp\\left(\\sum f^{(1)}_k(\\vec{x})H^{(1)}_k + \\sum f^{(2)}_k(\\vec{x})H^{(2)}_k+\\dots \\right),\n", - "$$\n", - "where $H^{(i)}$ is a Hamiltonian acting on $i$ qubits according to some connectivity map, and $f^{(i)}$ is some classical function, typically taken as the polynomial of degree $i$. For example, if our data is of size $3$ and we assume circular connectivity, taking Hamiltonians depending only on $Z$, the Hamiltonian reads as\n", - "$$\n", - "\\sum f^{(1)}_k(\\vec{x})H^{(1)}_k = \\alpha(x_0+\\beta)ZII+\\alpha(x_1+\\beta)IZI+\\alpha(x_2+\\beta)IIZ,\n", - "$$\n", - "$$\n", - "\\sum f^{(2)}_k(\\vec{x})H^{(2)}_k = \\gamma^2(x_0+\\zeta)(x_1+\\zeta)ZZI+\\gamma^2(x_1+\\zeta)(x_2+\\zeta)IZZ + \\gamma^2(x_0+\\zeta)(x_3+\\zeta)ZIZ,\n", - "$$\n", - "where $(\\alpha,\\beta)$ and $(\\gamma,\\zeta)$ define some affine transformation on the data and correspond to the functions $f^{(1,2)}$.\n", - "\n", - "We start with defining classical functions for creating a connectivity map for the Hamiltonians and for generating the full Hamiltonian:" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "id": "7", - "metadata": {}, - "outputs": [], - "source": [ - "from itertools import combinations, islice\n", - "\n", - "import numpy as np\n", - "\n", - "from classiq import *\n", - "\n", - "\n", - "def generate_connectivity_map(list_size, sublist_size, connectivity_type):\n", - " \"\"\"\n", - " Generate connectivity for a given list size and sublist size.\n", - "\n", - " Parameters:\n", - " - list_size: The size of the list (number of elements).\n", - " - sublist_size: The size of the subsets to generate.\n", - " - connectivity_type: an integer (0 for linear, 1 for circular, 2 for full)\n", - "\n", - " Returns:\n", - " - A list of all unique subsets of the given size.\n", - " \"\"\"\n", - " assert connectivity_type in [\n", - " 0,\n", - " 1,\n", - " 2,\n", - " ], \"connectivity must be 0 (linear), 1 (circular), or 2 (full)\"\n", - "\n", - " if connectivity_type == 0: # linear\n", - " return [\n", - " list(range(i, i + sublist_size))\n", - " for i in range(list_size - sublist_size + 1)\n", - " ]\n", - "\n", - " elif connectivity_type == 1: # circular\n", - " return [\n", - " [(i + j) % list_size for j in range(sublist_size)] for i in range(list_size)\n", - " ]\n", - "\n", - " elif connectivity_type == 2: # full\n", - " return [list(comb) for comb in combinations(range(list_size), sublist_size)]\n", - "\n", - "\n", - "def generate_hamiltonian(\n", - " data: CArray[CReal],\n", - " paulis_list: list[list[Pauli]],\n", - " affines: list[list[float]],\n", - " connectivity: int,\n", - ") -> tuple[list[SparsePauliOp], list[CReal]]:\n", - " assert connectivity in [\n", - " 0,\n", - " 1,\n", - " 2,\n", - " ], \"connectivity must be 0 (linear), 1 (circular) or 2 (full)\"\n", - " hs = []\n", - " coeffs = []\n", - " for paulis, affine in zip(paulis_list, affines):\n", - " indices = generate_connectivity_map(data.len, len(paulis), connectivity)\n", - " for k in range(len(indices)):\n", - " indexed_paulis = [\n", - " IndexedPauli(pauli=paulis[j], index=indices[k][j])\n", - " for j in range(len(indices[0]))\n", - " ]\n", - " hs.append(\n", - " SparsePauliOp(\n", - " terms=[SparsePauliTerm(paulis=indexed_paulis, coefficient=1)],\n", - " num_qubits=data.len,\n", - " )\n", - " )\n", - " coe = np.prod(\n", - " [\n", - " affine[0] * (data[indices[k][j]] - affine[1])\n", - " for j in range(len(indices[0]))\n", - " ]\n", - " )\n", - " coeffs.append(coe)\n", - "\n", - " return hs, coeffs" - ] - }, - { - "cell_type": "markdown", - "id": "8", - "metadata": {}, - "source": [ - "Next, we define a quantum function for the Pauli feature map:" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "id": "9", - "metadata": {}, - "outputs": [], - "source": [ - "@qfunc\n", - "def pauli_kernel(\n", - " data: CArray[CReal],\n", - " paulis_list: list[list[Pauli]],\n", - " affines: list[list[float]],\n", - " connectivity: int,\n", - " reps: CInt,\n", - " qba: QArray,\n", - ") -> None:\n", - " hs, coeffs = generate_hamiltonian(data, paulis_list, affines, connectivity)\n", - " power(\n", - " reps,\n", - " lambda: (\n", - " hadamard_transform(qba),\n", - " multi_suzuki_trotter(\n", - " hamiltonians=hs,\n", - " evolution_coefficients=coeffs,\n", - " order=1,\n", - " repetitions=1,\n", - " qbv=qba,\n", - " ),\n", - " ),\n", - " )" - ] - }, - { - "cell_type": "markdown", - "id": "10", - "metadata": {}, - "source": [ - "Finally, we construct the quantum model for the QSVM routine:" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "id": "11", - "metadata": {}, - "outputs": [], - "source": [ - "N_DIM = 2\n", - "PAULIS = [[Pauli.Z], [Pauli.Z, Pauli.Z]]\n", - "CONNECTIVITY = 2\n", - "AFFINES = [[1, 0], [1, np.pi]]\n", - "REPS = 2" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "id": "12", - "metadata": {}, - "outputs": [], - "source": [ - "@qfunc\n", - "def main(data1: CArray[CReal, N_DIM], data2: CArray[CReal, N_DIM], qba: Output[QNum]):\n", - " allocate(data1.len, qba)\n", - " pauli_kernel(data1, PAULIS, AFFINES, CONNECTIVITY, REPS, qba)\n", - " invert(lambda: pauli_kernel(data2, PAULIS, AFFINES, CONNECTIVITY, REPS, qba))\n", - "\n", - "\n", - "QSVM_PAULI_Z_ZZ = create_model(main)\n", - "write_qmod(QSVM_PAULI_Z_ZZ, \"qsvm_pauli_feature_map\", symbolic_only=False)" - ] - }, - { - "cell_type": "markdown", - "id": "13", - "metadata": {}, - "source": [ - "## Viewing the Model's Parameterized Quantum Circuit" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "id": "14", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Quantum program link: https://platform.classiq.io/circuit/32pQjDiThYtHON7LiLZxkiekrmq\n" - ] - } - ], - "source": [ - "qprog = synthesize(QSVM_PAULI_Z_ZZ)\n", - "show(qprog)" - ] - }, - { - "cell_type": "markdown", - "id": "15", - "metadata": {}, - "source": [ - "## Executing QSVM\n", - "The first step in QSVM is the training.\n", - "The second step in QSVM is to test the training process.\n", - "The last QSVM step, which may be applied multiple times on different datasets, is prediction: the prediction process takes unlabeled data and returns its predicted labels.\n", - "\n", - "Next, we define classical functions for applying these three parts of the execution, where the latter is done via `ExecutionSession` and `batch_sample`." - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "id": "16", - "metadata": {}, - "outputs": [], - "source": [ - "def get_execution_params(data1, data2=None):\n", - " \"\"\"\n", - " Generate execution parameters based on the mode (train or validate).\n", - "\n", - " Parameters:\n", - " - data1: First dataset (used for both training and validation).\n", - " - data2: Second dataset (only required for validation).\n", - "\n", - " Returns:\n", - " - A list of dictionaries with execution parameters.\n", - " \"\"\"\n", - " if data2 is None:\n", - " # Training mode (symmetric pairs of data1)\n", - " return [\n", - " {\"data1\": data1[k], \"data2\": data1[j]}\n", - " for k in range(len(data1))\n", - " for j in range(k, len(data1)) # Avoid symmetric pairs\n", - " ]\n", - " else:\n", - " # Prediction mode\n", - " return [\n", - " {\"data1\": data1[k], \"data2\": data2[j]}\n", - " for k in range(len(data1))\n", - " for j in range(len(data2))\n", - " ]\n", - "\n", - "\n", - "def construct_kernel_matrix(matrix_size, res_batch, train=False):\n", - " \"\"\"\n", - " Construct a kernel matrix from `res_batch`, depending on whether it's for training or predicting.\n", - "\n", - " Parameters:\n", - " - matrix_size: Tuple of (number of rows, number of columns) for the matrix.\n", - " - res_batch: Precomputed batch results.\n", - " - train: Boolean flag. If True, assumes training (symmetric matrix).\n", - "\n", - " Returns:\n", - " - A kernel matrix as a NumPy array.\n", - " \"\"\"\n", - " rows, cols = matrix_size\n", - " kernel_matrix = np.zeros((rows, cols))\n", - "\n", - " num_shots = res_batch[0].num_shots\n", - " num_output_qubits = len(next(iter(res_batch[0].counts)))\n", - "\n", - " count = 0\n", - " if train: # and rows == cols:\n", - " # Symmetric matrix (training)\n", - " for k in range(rows):\n", - " for j in range(k, cols):\n", - " value = (\n", - " res_batch[count].counts.get(\"0\" * num_output_qubits, 0) / num_shots\n", - " )\n", - " kernel_matrix[k, j] = value\n", - " kernel_matrix[j, k] = value # Use symmetry\n", - " count += 1\n", - " else:\n", - " # Non-symmetric matrix (validation)\n", - " for k in range(rows):\n", - " for j in range(cols):\n", - " kernel_matrix[k, j] = (\n", - " res_batch[count].counts.get(\"0\" * num_output_qubits, 0) / num_shots\n", - " )\n", - " count += 1\n", - "\n", - " return kernel_matrix\n", - "\n", - "\n", - "def train_svm(es, train_data, train_labels):\n", - " \"\"\"\n", - " Trains an SVM model using a custom precomputed kernel from the training data.\n", - "\n", - " Parameters:\n", - " - es: ExecutionSession object to process batch execution for kernel computation.\n", - " - train_data: List of data points for training.\n", - " - train_labels: List of binary labels corresponding to the training data.\n", - "\n", - " Returns:\n", - " - svm_model: A trained SVM model using the precomputed kernel.\n", - " \"\"\"\n", - " train_size = len(train_data)\n", - " train_execution_params = get_execution_params(train_data)\n", - " res_train_batch = es.batch_sample(train_execution_params) # execute batch\n", - " # generate kernel matrix for train\n", - " kernel_train = construct_kernel_matrix(\n", - " matrix_size=(train_size, train_size), res_batch=res_train_batch, train=True\n", - " )\n", - " svm_model = SVC(kernel=\"precomputed\")\n", - " svm_model.fit(\n", - " kernel_train, train_labels\n", - " ) # the fit gets the precomputed matrix of training, and the training labels\n", - "\n", - " return svm_model\n", - "\n", - "\n", - "def predict_svm(es, data, train_data, svm_model):\n", - " \"\"\"\n", - " Predicts labels for new data using a precomputed kernel with a trained SVM model.\n", - "\n", - " Parameters:\n", - " - es: ExecutionSession object to process batch execution for kernel computation.\n", - " - data (list): List of new data points to predict.\n", - " - train_data (list): Original training data used to train the SVM.\n", - " - svm_model: A trained SVM model returned by `train_svm`.\n", - "\n", - " Returns:\n", - " - y_predict (list): Predicted labels for the input data.\n", - " \"\"\"\n", - " predict_size = len(data)\n", - " train_size = len(train_data)\n", - " predict_execution_params = get_execution_params(data, train_data)\n", - " res_predict_batch = es.batch_sample(predict_execution_params) # execute batch\n", - " kernel_predict = construct_kernel_matrix(\n", - " matrix_size=(predict_size, train_size), res_batch=res_predict_batch, train=False\n", - " )\n", - " y_predict = svm_model.predict(\n", - " kernel_predict\n", - " ) # the predict gets the precomputed test matrix\n", - "\n", - " return y_predict" - ] - }, - { - "cell_type": "markdown", - "id": "17", - "metadata": {}, - "source": [ - "We can now run the execution session with all three parts:" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "id": "18", - "metadata": {}, - "outputs": [], - "source": [ - "from classiq.execution import ExecutionSession\n", - "\n", - "with ExecutionSession(qprog) as es:\n", - " # train\n", - " svm_model = train_svm(es, train_features.tolist(), train_labels.tolist())\n", - "\n", - " # test\n", - " y_test = predict_svm(es, test_features.tolist(), train_features.tolist(), svm_model)\n", - " test_score = sum(y_test == test_labels.tolist()) / len(test_labels.tolist())\n", - " # print(\"quantum kernel classification test score: %0.2f\" % (test_score))\n", - "\n", - " # predict\n", - " predicted_labels = predict_svm(\n", - " es, predict_features.tolist(), train_features.tolist(), svm_model\n", - " )" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "id": "19", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Testing success ratio: 1.0\n", - "\n", - "Prediction from datapoints set:\n", - " ground truth: [0 0 0 0 0 1 1 1 1 1]\n", - " prediction: [0 0 0 0 0 1 1 1 1 1]\n", - " success rate: 100.0%\n" - ] - } - ], - "source": [ - "# Printing tests result\n", - "print(f\"Testing success ratio: {test_score}\")\n", - "print()\n", - "# Printing predictions\n", - "print(\"Prediction from datapoints set:\")\n", - "print(f\" ground truth: {predict_labels}\")\n", - "print(f\" prediction: {predicted_labels}\")\n", - "print(\n", - " f\" success rate: {100 * np.count_nonzero(predicted_labels == predict_labels) / len(predicted_labels)}%\"\n", - ")" - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3 (ipykernel)", - "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.11.9" - }, - "vscode": { - "interpreter": { - "hash": "a07aacdcc8a415e7643a2bc993226848ff70704ebef014f87460de9126b773d0" - } - } - }, - "nbformat": 4, - "nbformat_minor": 9 -} diff --git a/algorithms/qml/qsvm_pauli_feature_map/qsvm_pauli_feature_map.metadata.json b/algorithms/qml/qsvm_pauli_feature_map/qsvm_pauli_feature_map.metadata.json deleted file mode 100644 index 06de60c4c..000000000 --- a/algorithms/qml/qsvm_pauli_feature_map/qsvm_pauli_feature_map.metadata.json +++ /dev/null @@ -1,7 +0,0 @@ -{ - "friendly_name": "QSVM: Pauli Kernel", - "description": "QSVM Algorithm (with Pauli Kernel)", - "problem_domain_tags": ["ml"], - "qmod_type": ["algorithms"], - "level": ["demos"] -} diff --git a/tests/notebooks/test_qsvm.py b/tests/notebooks/test_qsvm.py index 1093a19e7..e54c0c254 100644 --- a/tests/notebooks/test_qsvm.py +++ b/tests/notebooks/test_qsvm.py @@ -6,7 +6,7 @@ from testbook.client import TestbookNotebookClient -@wrap_testbook("qsvm", timeout_seconds=204) +@wrap_testbook("qsvm", timeout_seconds=300) def test_notebook(tb: TestbookNotebookClient) -> None: """ A notebook for a hybrid classical quantum neural network. @@ -14,12 +14,25 @@ def test_notebook(tb: TestbookNotebookClient) -> None: """ # test models validate_quantum_model(tb.ref("QSVM_BLOCH_SHPERE_qmod")) + validate_quantum_model(tb.ref("QSVM_PAULI_Z_ZZ")) # test quantum programs validate_quantum_program_size( - tb.ref_pydantic("qprog"), + tb.ref_pydantic("qprog_bloch"), expected_width=1, # actual width: 1 expected_depth=10, # actual depth: 4 ) - + validate_quantum_program_size( + tb.ref_pydantic("qprog_pauli"), + expected_width=2, # actual width: 2 + expected_depth=30, # actual depth: 30 + ) # test notebook content assert tb.ref("test_score") == 1 + + # test notebook content + assert tb.ref("test_score_pauli") == 1 + + success_rate = tb.ref( + "100 * np.count_nonzero(predicted_labels_pauli == predict_real_labels_2) / len(predicted_labels_pauli)" + ) + assert success_rate == 100 diff --git a/tests/notebooks/test_qsvm_pauli_feature_map.py b/tests/notebooks/test_qsvm_pauli_feature_map.py deleted file mode 100644 index cbf2cb392..000000000 --- a/tests/notebooks/test_qsvm_pauli_feature_map.py +++ /dev/null @@ -1,30 +0,0 @@ -from tests.utils_for_testbook import ( - validate_quantum_program_size, - validate_quantum_model, - wrap_testbook, -) -from testbook.client import TestbookNotebookClient - - -@wrap_testbook("qsvm_pauli_feature_map", timeout_seconds=68) -def test_notebook(tb: TestbookNotebookClient) -> None: - """ - A notebook for a hybrid classical quantum neural network. - The test verifies that the pre-trained model is indeed well trained. - """ - # test models - validate_quantum_model(tb.ref("QSVM_PAULI_Z_ZZ")) - # test quantum programs - validate_quantum_program_size( - tb.ref_pydantic("qprog"), - expected_width=2, # actual width: 2 - expected_depth=30, # actual depth: 30 - ) - - # test notebook content - assert tb.ref("test_score") == 1 - - success_rate = tb.ref( - "100 * np.count_nonzero(predicted_labels == predict_labels) / len(predicted_labels)" - ) - assert success_rate == 100