├── hello_qiskit.ipynb ├── quantum_variational_classifier.ipynb └── svm ├── __pycache__ └── datasets.cpython-37.pyc ├── datasets.py ├── feature_map.png └── variational_form.png /hello_qiskit.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "code", 5 | "execution_count": 1, 6 | "metadata": {}, 7 | "outputs": [], 8 | "source": [ 9 | "from qiskit import QuantumCircuit, IBMQ, Aer\n", 10 | "from qiskit.tools.visualization import plot_histogram\n", 11 | "from qiskit import execute\n", 12 | "import numpy as np\n", 13 | "import matplotlib.pyplot as plt\n", 14 | "%matplotlib inline" 15 | ] 16 | }, 17 | { 18 | "cell_type": "markdown", 19 | "metadata": {}, 20 | "source": [ 21 | "# Available local and remote backends\n", 22 | "\n", 23 | "Check out tutorials on how to setup an account:\n", 24 | "https://github.com/Qiskit/qiskit-iqx-tutorials" 25 | ] 26 | }, 27 | { 28 | "cell_type": "code", 29 | "execution_count": 2, 30 | "metadata": {}, 31 | "outputs": [ 32 | { 33 | "name": "stdout", 34 | "output_type": "stream", 35 | "text": [ 36 | "Available AER backends:\n", 37 | " - qasm_simulator\n", 38 | " - statevector_simulator\n", 39 | " - unitary_simulator\n" 40 | ] 41 | } 42 | ], 43 | "source": [ 44 | "# print local backends\n", 45 | "print('Available AER backends:')\n", 46 | "for backend in Aer.backends():\n", 47 | " print(' - %s' % backend)" 48 | ] 49 | }, 50 | { 51 | "cell_type": "code", 52 | "execution_count": 3, 53 | "metadata": {}, 54 | "outputs": [ 55 | { 56 | "data": { 57 | "text/plain": [ 58 | "" 59 | ] 60 | }, 61 | "execution_count": 3, 62 | "metadata": {}, 63 | "output_type": "execute_result" 64 | } 65 | ], 66 | "source": [ 67 | "# load account\n", 68 | "IBMQ.load_account()" 69 | ] 70 | }, 71 | { 72 | "cell_type": "code", 73 | "execution_count": 4, 74 | "metadata": {}, 75 | "outputs": [ 76 | { 77 | "name": "stdout", 78 | "output_type": "stream", 79 | "text": [ 80 | "Available IBMQ providers:\n", 81 | " - \n", 82 | " - \n" 83 | ] 84 | } 85 | ], 86 | "source": [ 87 | "# check providers in account\n", 88 | "print('Available IBMQ providers:')\n", 89 | "for provider in IBMQ.providers():\n", 90 | " print(' - %s' % provider)" 91 | ] 92 | }, 93 | { 94 | "cell_type": "code", 95 | "execution_count": 5, 96 | "metadata": {}, 97 | "outputs": [ 98 | { 99 | "name": "stdout", 100 | "output_type": "stream", 101 | "text": [ 102 | "Available backends:\n", 103 | " - ibmq_qasm_simulator\n", 104 | " - ibmqx4\n", 105 | " - ibmqx2\n", 106 | " - ibmq_16_melbourne\n", 107 | " - ibmq_ourense\n" 108 | ] 109 | } 110 | ], 111 | "source": [ 112 | "# select provider and print backends\n", 113 | "provider = IBMQ.get_provider(hub='ibm-q')\n", 114 | "print('Available backends:')\n", 115 | "for backend in provider.backends():\n", 116 | " print(' - %s' % backend)" 117 | ] 118 | }, 119 | { 120 | "cell_type": "code", 121 | "execution_count": 6, 122 | "metadata": {}, 123 | "outputs": [], 124 | "source": [ 125 | "# select a backend for the tutorial\n", 126 | "backend = Aer.get_backend('qasm_simulator')" 127 | ] 128 | }, 129 | { 130 | "cell_type": "markdown", 131 | "metadata": {}, 132 | "source": [ 133 | "# Setting up Quantum Circuits\n", 134 | "\n", 135 | "Before we can work with qubits and quantum gates, we first have to initialize our quantum circuit with the corresponding quantum and classical registers.\n", 136 | "
\n", 137 | "Please note that given $n$ qubits/bits in a quantum/classical register the qubits/bits are read in the following order: $[q_{n-1}, ..., q_1, q_0]$." 138 | ] 139 | }, 140 | { 141 | "cell_type": "code", 142 | "execution_count": 7, 143 | "metadata": {}, 144 | "outputs": [ 145 | { 146 | "data": { 147 | "image/png": "iVBORw0KGgoAAAANSUhEUgAAAIQAAAB7CAYAAAC1gChrAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8QZhcZAAAEcElEQVR4nO3dP0jUfxzH8df5p/NQBEtQaEjDK03uEgVpaxJclQSLayhIsBuC9hoNxMWpIQIXJ422loaSokVpEgebSsHAXOziAtNPyy9/vH7Sr/vxw/sU3+cDvsvnewdvuCef793yuVQIIQj4S03sAfB7IQgYgoAhCBiCgCEIGIKAIQgYgoAhCBiCgCEIGIKAIQgYgoAhCBiCgCEIGIKAIQgYgoAhCBiCgCEIGIKAIQgYgoAhCBiCgCEIGIKAIQgYgoAhCBiCgCEIGIKASVwQBwcHmpmZUTabVUNDgy5evKilpSWdP39eExMTsceLri72ANV28+ZNPX36VPfu3dPAwIDevHmjq1evant7W3fv3o09XnwhQebn54Ok8PLlS1sfHR0NksLy8nIIIYSPHz+GoaGhkMlkQj6fD2/fvo0xbhSJemQ8ePBAw8PDunz5sq13dXWpvr5euVxOkjQ5Oanu7m7t7OyoWCzqypUr2t/fjzFy9cUuslo2NjaCpPD48eMj98bHx0NfX18IIYTd3d1w4sSJsL29fXj/zJkz4fXr18c2m6RjvyqVmB1ic3NTktTe3m7r5XJZS0tLGhgYkCS9e/dOp06dUmtr6+Frcrmc1tbWqjdsRIkJ4scHvL6+buvT09Pa2tpSf3+/JOnLly9qbm621zQ3N6tUKh3bbCGEY78qlZhfGWfPnlU+n9fU1JROnjyp06dPa3FxUc+ePZOkwx2isbFRnz9/tvfu7u6qqamp6jPHkJgdoqamRgsLC+rt7dXk5KRu3Lih1tZWFYtF1dXVKZ/PS5Ky2aw+ffqknZ2dw/eurq7qwoULsUavrv//lejPVigUQi6Xs7WRkZFw586dUC6Xw6NHj0JnZ2f49u1bpAmrKzGPjJ9ZWVnRpUuXbO3hw4cqFApqaWlRNpvVkydPVFtbG2nC6kp0EKVSSevr67p9+7att7W16fnz55GmiisVAv+og78l5kslKkMQMAQBQxAwBAFDEDAEAUMQMAQBQxAwBAFDEDAEAUMQMAQBQxAwBAFDEDAEAUMQMAQBQxAwBAFDEDAEAUMQMAQBQxAwBAFDEDAEAUMQMIkLgsPP/13ijhTi8PNfiH3qWTVVevj5/fv3Q09PT0ilUmFhYSHGqNEk6pFR6eHn2WxWs7OzGhwcjDFmVIkJYnNzU6urqxobGzty78OHD+rt7VU6nZYkFQoFDQ0NqaGhodpjRpeoIKRfH34eQyqVOvarUokJotLDz5MuMb8yKj38PIbwGx0VmpgdotLDz5MuMTuEJJ07d04vXrywtevXr6unp0eZTOZwbW9vT/v7+zo4ONDe3p6+fv2qdDr9n57Ff6rE7BA/s7KycuRxcevWLWUyGb169UrXrl1TJpPR+/fvI01YXYkO4sfh5//8Qjk3N3fkH2k6OjriDFllHH4Ok+gdAkcRBAxBwBAEDEHAEAQMQcAQBAxBwBAEDEHAEAQMQcAQBAxBwBAEDEHAEAQMQcAQBAxBwBAEDEHAEAQMQcAQBAxBwHwHm5zxajiYdusAAAAASUVORK5CYII=\n", 148 | "text/plain": [ 149 | "
" 150 | ] 151 | }, 152 | "execution_count": 7, 153 | "metadata": {}, 154 | "output_type": "execute_result" 155 | } 156 | ], 157 | "source": [ 158 | "# create a quantum circuit\n", 159 | "qc = QuantumCircuit(2)\n", 160 | "qc.draw(output='mpl')" 161 | ] 162 | }, 163 | { 164 | "cell_type": "markdown", 165 | "metadata": {}, 166 | "source": [ 167 | "# Some basic gates" 168 | ] 169 | }, 170 | { 171 | "cell_type": "markdown", 172 | "metadata": {}, 173 | "source": [ 174 | "## X gate\n", 175 | "\n", 176 | "The X gate is the quantum equivalent to the classical NOT gate and, thus, flips $|0\\rangle$ to $|1\\rangle$ and vice versa.
\n", 177 | "In matrix form the quantum gate reads\n", 178 | "$\\left(\\begin{array}{cc} 0 & 1 \\\\ 1 & 0 \\end{array} \\right)$.\n", 179 | "
\n", 180 | "
\n", 181 | "Exercise:
\n", 182 | "Try to create a circuit that generates the state |10>." 183 | ] 184 | }, 185 | { 186 | "cell_type": "code", 187 | "execution_count": 8, 188 | "metadata": {}, 189 | "outputs": [ 190 | { 191 | "name": "stdout", 192 | "output_type": "stream", 193 | "text": [ 194 | "counts: {'01': 1}\n" 195 | ] 196 | }, 197 | { 198 | "data": { 199 | "image/png": "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\n", 200 | "text/plain": [ 201 | "
" 202 | ] 203 | }, 204 | "execution_count": 8, 205 | "metadata": {}, 206 | "output_type": "execute_result" 207 | } 208 | ], 209 | "source": [ 210 | "# create a quantum circuit\n", 211 | "qc = QuantumCircuit(2, 2)\n", 212 | "\n", 213 | "# add a X gate on qubit, flipping it from |0> to |1>\n", 214 | "qc.x(0)\n", 215 | "# qc.x(1)\n", 216 | "\n", 217 | "# measure qubit\n", 218 | "qc.measure([0, 1], [0, 1]);\n", 219 | "\n", 220 | "# compile and run the quantum circuit\n", 221 | "shots = 1\n", 222 | "job = execute(qc, backend, shots=shots)\n", 223 | "results = job.result()\n", 224 | "print(\"counts:\", results.get_counts())\n", 225 | "\n", 226 | "# plot the circuit\n", 227 | "qc.draw(output='mpl')" 228 | ] 229 | }, 230 | { 231 | "cell_type": "markdown", 232 | "metadata": {}, 233 | "source": [ 234 | "## H gate\n", 235 | "\n", 236 | "The H gate reads\n", 237 | "$\\frac{1}{\\sqrt{2}}\\left(\\begin{array}{cc} 1 & 1 \\\\ 1 & -1 \\end{array} \\right)$.\n", 238 | "Thus, it maps $|0\\rangle$ to $\\frac{1}{\\sqrt{2}}(|0\\rangle + |1\\rangle) =: |+\\rangle$, i.e., into the equal superposition state.\n", 239 | "
\n", 240 | "
\n", 241 | "Exercise:
\n", 242 | "Repeat the experiment a couple of times.
\n", 243 | "How does the result behave?
\n", 244 | "What happens if you increase the number of shots?" 245 | ] 246 | }, 247 | { 248 | "cell_type": "code", 249 | "execution_count": 9, 250 | "metadata": {}, 251 | "outputs": [ 252 | { 253 | "data": { 254 | "image/png": "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\n", 255 | "text/plain": [ 256 | "
" 257 | ] 258 | }, 259 | "execution_count": 9, 260 | "metadata": {}, 261 | "output_type": "execute_result" 262 | } 263 | ], 264 | "source": [ 265 | "# create a quantum circuit\n", 266 | "qc = QuantumCircuit(1, 1)\n", 267 | "\n", 268 | "# add a H gate and apply it on qubit 0, mapping |0> to 1/√2(|0⟩+|1⟩)=:|+⟩\n", 269 | "qc.h(0)\n", 270 | "\n", 271 | "# measure qubit\n", 272 | "qc.measure(0, 0)\n", 273 | "\n", 274 | "# plot the circuit\n", 275 | "qc.draw(output='mpl')" 276 | ] 277 | }, 278 | { 279 | "cell_type": "code", 280 | "execution_count": 10, 281 | "metadata": {}, 282 | "outputs": [ 283 | { 284 | "name": "stdout", 285 | "output_type": "stream", 286 | "text": [ 287 | "counts: {'0': 1}\n" 288 | ] 289 | }, 290 | { 291 | "data": { 292 | "image/png": "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\n", 293 | "text/plain": [ 294 | "
" 295 | ] 296 | }, 297 | "execution_count": 10, 298 | "metadata": {}, 299 | "output_type": "execute_result" 300 | } 301 | ], 302 | "source": [ 303 | "# compile and run the quantum circuit on the local simulator\n", 304 | "shots = 1\n", 305 | "job = execute(qc, backend, shots=shots)\n", 306 | "results = job.result()\n", 307 | "print(\"counts:\", results.get_counts())\n", 308 | "\n", 309 | "# plot results\n", 310 | "plot_histogram(results.get_counts())" 311 | ] 312 | }, 313 | { 314 | "cell_type": "markdown", 315 | "metadata": {}, 316 | "source": [ 317 | "## Y rotation\n", 318 | "\n", 319 | "A Y-rotation of angle $\\theta$, denoted $R_y(\\theta)$, acts like\n", 320 | "$e^{-i\\frac{\\theta}{2}Y} = \\left(\\begin{array}{cc} \\cos(\\theta/2) & -\\sin(\\theta/2) \\\\ \\sin(\\theta/2) & \\cos(\\theta/2) \\end{array} \\right)$.
\n", 321 | "It rotates a single qubit state around the Y-axis of the Bloch sphere.
\n", 322 | "When applied to $|0\\rangle$, the probability of measuring $|1\\rangle$ equals $\\sin^2(\\theta/2)$.\n", 323 | "
\n", 324 | "
\n", 325 | "\n", 326 | "\n", 327 | "Exercise:
\n", 328 | "Find $\\theta$ such that $\\mathbb{P}[|1\\rangle] = 75\\%$ and verify it by executing the circuit." 329 | ] 330 | }, 331 | { 332 | "cell_type": "code", 333 | "execution_count": 11, 334 | "metadata": {}, 335 | "outputs": [ 336 | { 337 | "data": { 338 | "image/png": "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\n", 339 | "text/plain": [ 340 | "
" 341 | ] 342 | }, 343 | "execution_count": 11, 344 | "metadata": {}, 345 | "output_type": "execute_result" 346 | } 347 | ], 348 | "source": [ 349 | "# create a quantum circuit\n", 350 | "qc = QuantumCircuit(1, 1)\n", 351 | "\n", 352 | "# add a Y-rotation on qubit 0 with rotation angle theta\n", 353 | "theta = np.pi/2\n", 354 | "qc.ry(theta, 0)\n", 355 | "\n", 356 | "# measure qubit\n", 357 | "qc.measure(0, 0)\n", 358 | "\n", 359 | "# plot the circuit\n", 360 | "qc.draw(output='mpl')" 361 | ] 362 | }, 363 | { 364 | "cell_type": "code", 365 | "execution_count": 12, 366 | "metadata": {}, 367 | "outputs": [ 368 | { 369 | "name": "stdout", 370 | "output_type": "stream", 371 | "text": [ 372 | "counts: {'1': 489, '0': 511}\n" 373 | ] 374 | }, 375 | { 376 | "data": { 377 | "image/png": "iVBORw0KGgoAAAANSUhEUgAAAc0AAAEyCAYAAACYgYvRAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8QZhcZAAAfsElEQVR4nO3dfZzWdZ3v8denkUEgUIYmnIkdCCEcbqRRTgYl2THN7Ngjb8rcTtqtpyzZzbOn3U7tqfa07h62G93Oljfbrmm161a2brpuZtRaWrniOIFME4TAQUYagRABAafP+eO6sHGYGX4Xzs0FvJ6Px/WY6/r+vr/ffH7O4+Lt93fz/UVmIkmSDu4FI12AJEmHC0NTkqSCDE1JkgoyNCVJKsjQlCSpIENTkqSCjhnpAkbSpEmTsqmpaaTLkCRVkYcffviJzKzva9lRHZpNTU0sW7ZspMuQJFWRurq69f0tG/bDsxFxRUQ8GhFPR8TyiDj9IP1rI+LPyuvsiYgNEbGkV58LI2JVefmqiDh/aPdCknQ0GtbQjIiLgWuBq4EW4H7grogY6BjpPwDnAJcDs4C3AD/vsc2FwK3A14CXl39+IyJOG4p9kCQdvWI4p9GLiJ8BP8/M9/VoWw18MzM/2kf/s4FvACdm5hP9bPNWoC4zz+rRdg/QlZmXDFRPS0tLenhWktRTXV3d8sxc0NeyYRtpRkQtcCpwd69FdwOL+lntzcB/AFdFxMaIWB0Rfx0RL+zRZ2Ef2/zuANuUJOmQDOeFQC8CaoDNvdo3A6/rZ53pwKuBPcCFwPHAF4BG4KJynxP62eYJfW0wIi6ndKiXhoYGHnroIQAaGxsZO3Ysa9asAeC4445j+vTptLa2AlBTU8P8+fPp6Ohg586dADQ3N7N161Y2by79+ilTplBbW8vatWsBmDhxIk1NTbS1tQEwatQo5s2bR3t7O7t37wZg9uzZdHV10dXVBcDUqVOJCNatWwfApEmTaGhoYOXKlQCMHj2aOXPm8Mgjj7Bnzx4A5s6dS2dnJ1u2bAFg2rRpZCbr15fOZdfX11NfX8+qVasAGDNmDM3NzaxYsYJ9+/YBMH/+fDZs2MC2bdtK/+GnT2fv3r1s3LgRgMmTJ1NXV0d7ezsA48aNY9asWbS1tdHd3Q1AS0sLa9euZfv27QDMmDGDXbt2sWnTJvb/954wYQIdHR0AjB8/npkzZ9La2kpmEhG0tLSwevVqduzYAcCsWbN48skn6ezs9O/k38m/k3+nYfk7DWTYDs9GRCPwGLA4M3/Uo/0TwCWZeVIf69wNnA6ckJnby21nUxpJnpCZmyNiL/CezLylx3qXAddn5rED1eThWUlSb1VxeBZ4AujmwBHgizlwpLhfJ/DY/sAsay//3H/x0OMVblOSpEMybKGZmXuB5cBZvRadRekq2r7cBzT2Oof5svLP/ffR/KTCbUqSdEiG+z7NzwHvjIj3RkRzRFxL6fzkdQARcXNE3Nyj/9eBLcDfR8SciHgVpVtWvpmZvy73uRb4zxHx0Yg4KSI+CrwWuGa4dkqSdHQY1hmBMvPWiJgEfBxoAFYC52bm/lFjU6/+T0XE6yhd/PMfwDbgn4E/6dHn/oh4G/Bp4FPAr4CLM/NnQ70/kqSjy7Dep1ltvBBIktRbtVwIJEnSYc3QlCSpIENTkqSCDE1JkgoyNCVJKsjQlCSpIENTkqSCDE1JkgoyNCVJKsjQlCSpIENTkqSCDM2j2D333MMrXvEKTj31VK655sCHwnz9619n5syZLF68mMWLF3Pzzb97AM1FF13EtGnTeNvb3vacdW688UZOPfVU6urqnn2iuiQdKYb1KSeqHt3d3XzkIx/htttuo7GxkTPPPJNzzjmHk0466Tn9zj//fJYuXXrA+ldeeSW7d+/mpptuek77aaedxutf/3rOO++8oSxfkkaEI82j1PLly3npS1/KtGnTqK2t5YILLuCuu+4qvP5rXvMaXvjCFx7QfvLJJ9PU1NTHGpJ0+DM0j1KdnZ285CUvefZzY2MjnZ2dB/T7zne+w6tf/Wouu+wyNm7cOJwlSlLVMTSPUn09RzUinvP5nHPO4eGHH+bHP/4xZ5xxBh/84AeHqzxJqkqG5lGqsbGRxx577NnPmzZt4oQTTnhOn7q6OkaPHg3ApZdeysMPPzysNUpStTE0j1KnnHIKa9euZf369ezdu5fbbruNc8455zl9Hn/88Wff33XXXbzsZS8b7jIlqaoYmkepY445hqVLl3LRRRfxyle+kje/+c00Nzdz9dVXP3tB0A033MDChQs5/fTTueGGG/ibv/mbZ9c/99xzede73sW9997LnDlz+P73vw/A9ddfz5w5c9i0aROnn346S5YsGZH9k6ShEH2d2zpatLS05LJly0a6DElSFamrq1uemQv6WuZIU5KkggxNSTpMHGwWr/1uv/126urqaG1tBWDfvn1cccUVvOpVr+K0007j85///LN9r7vuOhYtWsTChQv50pe+NOT7cLhzRiBJOgwUncVrx44d3HDDDZx66qnPtt1+++3s2bOH++67j127drFw4UIuvPBCnnrqKW6++Wbuueceamtrectb3sLZZ5/NiSeeONy7d9hwpClJh4Gis3hdffXVLFmyhGOPPfbZtohg165dPPPMMzz99NPU1tYyfvx4fvnLX7JgwQLGjh3LMcccw6JFi7jzzjuHc7cOO4amJB0Giszi9fOf/5zHHnuM17/+9c9pf9Ob3sTYsWNpbm7m5JNP5oMf/CATJ06kubmZn/zkJ2zdupVdu3bxve997zn3b+tAHp6VpMPAwWbx+u1vf8vHPvax59watt/y5cupqalh1apV/OY3v+GNb3wjZ5xxBrNmzWLJkiVccMEFjBs3jrlz51JTUzOk+3G4c6QpSYeBg83i9dRTT9He3s55553H/PnzefDBB3n7299Oa2sr3/rWtzjzzDMZNWoU9fX1vOIVr3j2IqF3vOMd/PCHP+TOO+9k4sSJns88CENTkg4DB5vFa8KECaxZs4a2tjba2tpYsGABX/va12hpaWHKlCnce++9ZCY7d+7kwQcffHaGr66uLgA2btzIHXfcwYUXXjgi+3e48PCsJB0Ges7i1d3dzdvf/vZnZ/FqaWnhDW94Q7/rvuc97+FDH/oQixYtIjP5/d//febMmQPAZZddxtatWxk1ahRLly7l+OOPH65dOiw5I5AzAkmSenBGIEmSBoGhKUlSQZ7THAQf+crEkS5BQ2DpZdtGugRJVcaRpiRJBRmakiQVZGhKklSQoSlJUkGGpiRJBRmakiQVZGhKklSQoSlJUkGGpiRJBTkjkKSjjrN4HZmGYxYvR5qSJBVkaEqSVJChKUlSQYamJEkFGZqSJBVkaEqSVJChKUlSQYamJEkFGZqSJBVkaEqSVJChKUlSQYamJEkFDXtoRsQVEfFoRDwdEcsj4vSC6706Ip6JiJW92t8ZEdnH69ih2QNJ0tFqWEMzIi4GrgWuBlqA+4G7IqLpIOtNBG4Gvt9Pl11AQ89XZj49WHVLkgTDP9K8CrgpM2/MzPbMvBLoBD5wkPW+DHwF+Ek/yzMzH+/5GsSaJUkChjE0I6IWOBW4u9eiu4FFA6x3BXAC8OkBNj8mItZHxMaIuCMiWp53wZIk9TKcD6F+EVADbO7Vvhl4XV8rRMQ84BPAKzOzOyL66tYBvBtoA8YDfwDcFxHzM3N1H9u8HLgcoKGhgYceegiAxsZGxo4dy5o1awA47rjjmD59Oq2trQDU1NQwf/58Ojo62LlzJwDNzc1s3boV8IG2R6L29nZ2794NwOzZs+nq6qKrqwuAqVOnEhGsW7cOgEmTJtHQ0MDKlaVT7qNHj2bOnDk88sgj7NmzB4C5c+fS2dnJli1bAJg2bRqZyfr16wGor6+nvr6eVatWATBmzBiam5tZsWIF+/btA2D+/Pls2LCBbdtKD9udPn06e/fuZePGjQBMnjyZuro62tvbARg3bhyzZs2ira2N7u5uAFpaWli7di3bt28HYMaMGezatYtNmzYBpe/FhAkT6OjoAGD8+PHMnDmT1tZWMpOIoKWlhdWrV7Njxw4AZs2axZNPPklnZyfw/L5PmzeX/omYMmUKtbW1rF27FoCJEyfS1NREW1sbAKNGjWLevHmH9HfSkWnLli2D8n0aSGTmEO5Cj18U0Qg8BizOzB/1aP8EcElmntSr/2jgIeAvM/OWctsngYsyc+4Av6cGeBj4QWYuGaimlpaWXLZs2SHu0e/4FPgj03A8BV4jw+/skWmwvrN1dXXLM3NBX8uGc6T5BNBN6VBrTy/mwNEnlC7omQ38fUT8fbntBUBExDPAuZnZ+1Av5RHpg8DMQatckiSG8ZxmZu4FlgNn9Vp0FqWraHt7DJgHvLzH6zpgTfl9X+sQpWO4J1O6wEiSpEEznCNNgM8Bt0TEA8B9wPuBRkphSETcDJCZl2bmPqD3PZm/BvZk5soebZ8AfgqsBiYASyiF5sGuyJUkqSLDGpqZeWtETAI+Tunw60pKh1nXl7sMeL9mP44HbqB02Hc70ErpvOkDg1CyJEnPGu6RJpn5ReCL/Sw74yDrfhL4ZK+2DwMfHpzqJEnqn3PPSpJUkKEpSVJBhqYkSQUZmpIkFWRoSpJUkKEpSVJBhqYkSQUZmpIkFWRoSpJUkKEpSVJBhqYkSQUZmpIkFWRoSpJUkKEpSVJBhqYkSQUZmpIkFWRoSpJUUEWhGRFvjYize3z+XxGxMSK+GxENg1+eJEnVo9KR5if3v4mIU4D/Cfw1MAr47OCVJUlS9Tmmwv5TgY7y+/OBf87MpRFxN/DdQa1MkqQqU+lI82lgfPn9mcA95ffbe7RLknREqnSk+SPgsxHxY2ABcFG5/WXA/xvMwiRJqjaVjjQ/BOylFJbvz8xN5fY34OFZSdIRrqKRZmZuBM7ro/0PB60iSZKqVMX3aUbEsRFxUUT8cUQcX247MSLqBr88SZKqR0UjzYiYQeninxcCxwPfAH4DfKD8+b2DXaAkSdWi0pHmNcDdwGRgd4/2fwFeO1hFSZJUjSq9enYR8MrM7I6Inu0bgMZBq0qSpCp0KHPPjuqjrYnSvZqSJB2xKg3Nu4GrenzOiJgAfAq4c9CqkiSpClV6ePYq4AcR0QEcC9wKzAA2A28d5NokSaoqld6nuSkiXg5cApxCaaR6A/C1zNw94MqSJB3mKh1pUg7Hvyu/JEk6ahw0NCPiAuA7mbmv/L5fmXnboFUmSVKVKTLS/CZwAvDr8vv+JFAzGEVJklSNDhqamfmCvt5LknS0qSgEI2JxRBwQtBFRExGLB68sSZKqT6Ujxx8AfU3Mfnx5mSRJR6xKQzMonbvsbRKw8/mXI0lS9Sp0y0lE/Ev5bQJfjYg9PRbXAHOB+we5NkmSqkrR+zS3lH8GsI3nPuFkL/Bj4MZBrEuSpKpTKDQz810AEbEO+ExmeihWknTUqXQavU8NVSGSJFW7IjMC/Rx4TWZui4gV9H0hEACZefJgFidJUjUpMtL8FrD/wp+BZgSSJOmIVmRGoE/19V6SpKON0+JJklRQkXOaA57H7MlzmpKkI1nRp5xIknTUq+icpiRJRzPPaUqSVJD3aUqSVJD3aUqSVJD3aUqSVFBFc8/uFxEnAs3lj+2Z+avBK0mSpOpUUWhGxCTgy8CbgN/+rjnuAN6dmVv6XVmSpMNcpVfP/i0wAzgdOLb8Wgy8lILP04yIKyLi0Yh4OiKWR8TpA/R9TUTcHxFbImJ3RPwiIv6oj34XRsSqiNhT/nl+hfslSdJBVRqarwfel5n3ZeYz5dd9wH8rLxtQRFwMXAtcDbQA9wN3RURTP6s8Bfw1pWCeDXwa+FREXNFjmwuBW4GvAS8v//xGRJxW4b5JkjSgSkOzC+jrAdS7gCKHZq8CbsrMGzOzPTOvBDqBD/TVOTOXZ+Y/ZuYjmfloZn4V+C6lke5+fwj8IDP/vLzNPwd+WG6XJGnQVBqafwZcExEv2d9Qfv/Z8rJ+RUQtcCpwd69FdwOLivzyiGgp9/33Hs0L+9jmd4tuU5Kkog5lwvaXAusi4rHy55cATwMvpnTOsz8vAmqAzb3aNwOvO0gNG4H6cr2fyszreiw+oZ9tntDPti4HLgdoaGjgoYceAqCxsZGxY8eyZs0aAI477jimT59Oa2srADU1NcyfP5+Ojg527iwNtpubm9m6dSswcaDydZhqb29n9+7dAMyePZuuri66uroAmDp1KhHBunXrAJg0aRINDQ2sXLkSgNGjRzNnzhweeeQR9uwp3eY8d+5cOjs72bKldFBm2rRpZCbr168HoL6+nvr6elatWgXAmDFjaG5uZsWKFezbtw+A+fPns2HDBrZt2wbA9OnT2bt3Lxs3bgRg8uTJ1NXV0d7eDsC4ceOYNWsWbW1tdHd3A9DS0sLatWvZvn07ADNmzGDXrl1s2rQJKH0vJkyYQEdHBwDjx49n5syZtLa2kplEBC0tLaxevZodO3YAMGvWLJ588kk6OzuB5/d92ry59HWeMmUKtbW1rF27FoCJEyfS1NREW1sbAKNGjWLevHmH9HfSkWnLli2D8n0aSGQO/ACTiPhE0YIHuo8zIhqBx4DFmfmjXtu/JDNPGmDdlwIvBF4J/B/gDzLzlvKyvcB79n8ut10GXJ+Zxw5Ub0tLSy5btqzQvg3kI18xNI9ESy/bNtIlaIj4nT0yDdZ3tq6ubnlmLuhr2XBO2P4E0M2BI8AXc+BIsXcNj5bfroiIycAngf0h+fihbFOSpEoN24TtmbkXWA6c1WvRWZSuoi3qBcDoHp9/MgjblCTpoCqd3KAW+BhwCdAEjOq5PDNrDrKJzwG3RMQDwH3A+4FG4Lry9m8ub+fS8ucrgUeBjvL6i4E/Ar7YY5vXAvdGxEeBbwPnA68FXl3JvkmSdDCVTqP3v4GLgb8APg/8D2Aa8DbgTw+2cmbeWp5V6ONAA7ASODcz15e79L5fs4bSOcxpwDPAr4A/oRyy5W3eHxFvo3wPZ7nPxZn5swr3TZKkAVUamm8F3p+Z/xYRnwFuz8xfRUQ7pUOi1x9sA5n5RZ47Uuy57Ixen68BrimwzW/iE1gkSUOs0nOak4FV5fdPAceX3/8bcPZgFSVJUjWqNDQ3UDoHCbCG302dtxDYPVhFSZJUjSoNzW8DZ5bfX0tpHthHgZsYeGIDSZIOexWd08zMj/Z4/83yTD2LgF9m5h2DXZwkSdXkkB5CvV9m/hT46SDVIklSVat4coOIOCUibo6IB8uvWyLilKEoTpKkalJRaEbE24H/oHSP5b+WX5OBByLivw5+eZIkVY9KD8/+OfCnmXl1z8bybDyfBr46WIVJklRtKj08Ww/8Ux/t36A0SbokSUesSkPzB8AZfbSfwXMfDC1J0hGnyEOoL+jx8S7gLyJiAb+7avaVwAWUHtclSdIRq8g5zb7mdL28/OrpC/Qzp6wkSUeCIg+hHrZnbkqSVM0MREmSCjqUyQ3eGBH3RsQTEdEVEf8eEecORXGSJFWTSic3eC+lSdt/BfwxpQdCPwp8OyLePfjlSZJUPSqd3OCPgasy8//2aPtyRCynFKB/N2iVSZJUZSo9PNtE6YHTvd0FTH3+5UiSVL0O5SHUZ/XRfjaw/vmXI0lS9ar08OxngC+Un2pyP5DAq4F3AFcOcm2SJFWVSh9CfX1E/Br475RmAQJoB96ambcPdnGSJFWTwqEZEcdQOgx7b2Z+e+hKkiSpOhU+p5mZzwC3AeOHrhxJkqpXpRcCtQEzhqIQSZKqXaWh+UngsxHx5oj4vYio6/kagvokSaoalV49e2f5522UrpzdL8qfawajKEmSqlGlofnaIalCkqTDQKHQjIixwF8BbwZGAfcASzLziSGsTZKkqlL0nOangHdSOjz7D5RmBfrSENUkSVJVKnp49gLgPZn5jwAR8TXgvoioyczuIatOkqQqUnSk+XvAj/Z/yMwHgGeAxqEoSpKkalQ0NGuAvb3anqHyC4kkSTpsFQ29AL4aEXt6tB0L3BgRu/Y3ZOabBrM4SZKqSdHQ/EofbV8dzEIkSap2hUIzM9811IVIklTtKp1GT5Kko5ahKUlSQYamJEkFGZqSJBVkaEqSVJChKUlSQYamJEkFGZqSJBVkaEqSVJChKUlSQYamJEkFGZqSJBVkaEqSVJChKUlSQYamJEkFGZqSJBVkaEqSVJChKUlSQYamJEkFGZqSJBU07KEZEVdExKMR8XRELI+I0wfo2xARX4+IX0REd0Tc1Eefd0ZE9vE6dkh3RJJ01BnW0IyIi4FrgauBFuB+4K6IaOpnldHAE8BfAj8bYNO7gIaer8x8erDqliQJhn+keRVwU2bemJntmXkl0Al8oK/OmbkuM5dk5k3A1gG2m5n5eM/X4JcuSTraDVtoRkQtcCpwd69FdwOLnufmx0TE+ojYGBF3RETL89yeJEkHOGYYf9eLgBpgc6/2zcDrnsd2O4B3A23AeOAPgPsiYn5mru7dOSIuBy4HaGho4KGHHgKgsbGRsWPHsmbNGgCOO+44pk+fTmtrKwA1NTXMnz+fjo4Odu7cCUBzczNbt24FJj6P8lWt2tvb2b17NwCzZ8+mq6uLrq4uAKZOnUpEsG7dOgAmTZpEQ0MDK1euBGD06NHMmTOHRx55hD179gAwd+5cOjs72bJlCwDTpk0jM1m/fj0A9fX11NfXs2rVKgDGjBlDc3MzK1asYN++fQDMnz+fDRs2sG3bNgCmT5/O3r172bhxIwCTJ0+mrq6O9vZ2AMaNG8esWbNoa2uju7sbgJaWFtauXcv27dsBmDFjBrt27WLTpk1A6XsxYcIEOjo6ABg/fjwzZ86ktbWVzCQiaGlpYfXq1ezYsQOAWbNm8eSTT9LZ2Qk8v+/T5s2lfyKmTJlCbW0ta9euBWDixIk0NTXR1tYGwKhRo5g3b94h/Z10ZNqyZcugfJ8GEpk5hLvQ4xdFNAKPAYsz80c92j8BXJKZJx1k/TuAJzLznQfpVwM8DPwgM5cM1LelpSWXLVtWcA/695GvGJpHoqWXbRvpEjRE/M4emQbrO1tXV7c8Mxf0tWw4z2k+AXQDJ/RqfzEHjj4PWWZ2Aw8CMwdrm5IkwTCGZmbuBZYDZ/VadBalq2gHRUQEcDKlC4wkSRo0w3lOE+BzwC0R8QBwH/B+oBG4DiAibgbIzEv3rxARLy+/nQD8tvx5b2auKi//BPBTYHW5zxJKodnnFbmSJB2qYQ3NzLw1IiYBH6d0P+VK4NzMXF/u0tf9mq29Pp8HrAemlT8fD9xA6bDv9nL/xZn5wOBWL0k62g33SJPM/CLwxX6WndFHWxxkex8GPjwoxUmSNADnnpUkqSBDU5KkggxNSZIKMjQlSSrI0JQkqSBDU5KkggxNSZIKMjQlSSrI0JQkqSBDU5KkggxNSZIKMjQlSSrI0JQkqSBDU5KkggxNSZIKMjQlSSrI0JQkqSBDU5KkggxNSZIKMjQlSSrI0JQkqSBDU5KkggxNSZIKMjQlSSrI0JQkqSBDU5KkggxNSZIKMjQlSSrI0JQkqSBDU5KkggxNSZIKMjQlSSrI0JQkqSBDU5KkggxNSZIKMjQlSSrI0JQkqSBDU5KkggxNSZIKMjQlSSrI0JQkqSBDU5KkggxNSZIKMjQlSSrI0JQkqSBDU5KkggxNSZIKMjQlSSrI0JQkqSBDU5KkggxNSZIKMjQlSSrI0JQkqSBDU5KkggxNSZIKGvbQjIgrIuLRiHg6IpZHxOkH6f+acr+nI2JtRLz/+W5TkqRDMayhGREXA9cCVwMtwP3AXRHR1E//lwL/Wu7XAvwF8IWIuPBQtylJ0qEa7pHmVcBNmXljZrZn5pVAJ/CBfvq/H9iUmVeW+98IfAX4o+exTUmSDsmwhWZE1AKnAnf3WnQ3sKif1Rb20f+7wIKIGHWI25Qk6ZAM50jzRUANsLlX+2bghH7WOaGf/seUt3co25Qk6ZAcMwK/M3t9jj7aDtZ/f3sM0KfPbUbE5cDl5Y9P1dXVdQxYrXp7EfDESBcxHP72wyNdgTQo/M5Wbmp/C4YzNJ8AujlwBPhiDhwp7vd4P/2fAbZQCseKtpmZNwA3FK5azxERD2bmgpGuQ1IxfmcH17Adns3MvcBy4Kxei86idMVrX34CvK6P/g9m5r5D3KYkSYdkuA/Pfg64JSIeAO6jdHVsI3AdQETcDJCZl5b7Xwd8KCKuAa4HXgW8E7ik6DYlSRoswxqamXlrREwCPg40ACuBczNzfblLU6/+j0bEucDnKd1CsglYkpnfqmCbGlwe2pYOL35nB1FkDnQNjiRJ2s+5ZyVJKsjQlCSpIENTkqSCDE0dVETMjIjJI12HJI00LwRSnyLixcA7gA8DXZQmlOgEvgl8KzN3jmB5kjQiDE31KSJuAmYDd1CafWkS8HKgGdgILM3M741YgZIOEBETgB3pP+xDxtDUASIigB2U7ne9t0fb7wGnAe+jNDfjxZn58IgVKuk5IuJ64IHya31mPtlHn0mZuWXYiztCeE5TfZkNPArs3d+QJRsy8xvAf6EUqhePUH2SeomISyj9D+1ngduBv4qI8yPixIgYU+4zBvhyRMwbwVIPa440dYDyF+sOYCxwKfCrzPxtrz5XAu/JzJePQImSeomIGyk9wGIpcAFwGXAi0AH8K/B9YBZwbWbWjlSdhztHmjpAZu4GPgaMAW4GLo2I34uIcQARMRZ4DaUpCyWNsIg4htLRod9k5trM/ExmzgP+E/DvlAL0n4AvALeMXKWHP0ea6ldEzAX+FHgTsJPSU2e6KD15phN4b2auGLkKJe0XEROByZn5i4ioBfb1vCAoIi4G/gE4xWsRDp2hqYMq337yRuDNwNOURpjfyMxfjGhhkgYUES+g9O98d0S8j9Kh2bEjXdfhzNBURSLiBb3Pb0qqfhFxFVCTmX810rUczgxNSToKRMQooNv/6X1+DE1Jkgry6llJkgoyNCVJKsjQlCSpIENTkqSCDE1JkgoyNCVJKuj/A2sNMZO0XljfAAAAAElFTkSuQmCC\n", 378 | "text/plain": [ 379 | "
" 380 | ] 381 | }, 382 | "execution_count": 12, 383 | "metadata": {}, 384 | "output_type": "execute_result" 385 | } 386 | ], 387 | "source": [ 388 | "# compile and run the quantum circuit on the local simulator\n", 389 | "shots = 1000\n", 390 | "job = execute(qc, backend, shots=shots)\n", 391 | "results = job.result()\n", 392 | "print(\"counts:\", results.get_counts())\n", 393 | "\n", 394 | "# plot results\n", 395 | "plot_histogram(results.get_counts())" 396 | ] 397 | }, 398 | { 399 | "cell_type": "markdown", 400 | "metadata": {}, 401 | "source": [ 402 | "## CX gate\n", 403 | "\n", 404 | "A controlled X (CX) gate acts on two qubits like\n", 405 | "$\\left(\\begin{array}{cccc} \n", 406 | "1 & 0 & 0 & 0 \\\\ \n", 407 | "0 & 1 & 0 & 0 \\\\\n", 408 | "0 & 0 & 0 & 1 \\\\\n", 409 | "0 & 0 & 1 & 0 \\end{array} \\right)$.\n", 410 | "
\n", 411 | "Thus, it flips (applies an X gate to) the second qubit if the first qubit is $|1\\rangle$ and otherwise has no effect.\n", 412 | "
\n", 413 | "
\n", 414 | "Exercise:
\n", 415 | "See what happens when applying the CX to $|00\\rangle$, $|01\\rangle$, $|10\\rangle$, $|11\\rangle$.\n", 416 | "
\n", 417 | "The initial qubit states can be prepared via single-qubit X gates." 418 | ] 419 | }, 420 | { 421 | "cell_type": "code", 422 | "execution_count": 13, 423 | "metadata": {}, 424 | "outputs": [ 425 | { 426 | "name": "stdout", 427 | "output_type": "stream", 428 | "text": [ 429 | "counts: {'11': 1}\n" 430 | ] 431 | }, 432 | { 433 | "data": { 434 | "image/png": "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\n", 435 | "text/plain": [ 436 | "
" 437 | ] 438 | }, 439 | "execution_count": 13, 440 | "metadata": {}, 441 | "output_type": "execute_result" 442 | } 443 | ], 444 | "source": [ 445 | "# create a quantum circuit\n", 446 | "qc = QuantumCircuit(2, 2)\n", 447 | "\n", 448 | "# set initial state\n", 449 | "qc.x(0) # flips q[0] from |0> to |1>\n", 450 | "# qc.x(1) # flips q[1] from |0> to |1>\n", 451 | "\n", 452 | "# apply CX gate with control q[0] and target q[1]\n", 453 | "qc.cx(0, 1)\n", 454 | "\n", 455 | "# measure qubit\n", 456 | "qc.measure([0, 1], [0, 1])\n", 457 | "\n", 458 | "# compile and run the quantum circuit on the local simulator\n", 459 | "shots = 1\n", 460 | "job = execute(qc, backend, shots=shots)\n", 461 | "results = job.result()\n", 462 | "print(\"counts:\", results.get_counts())\n", 463 | "\n", 464 | "# plot the circuit\n", 465 | "qc.draw(output='mpl')" 466 | ] 467 | }, 468 | { 469 | "cell_type": "markdown", 470 | "metadata": {}, 471 | "source": [ 472 | "# The Bell state\n", 473 | "\n", 474 | "A Bell state is a fully entangled state of two qubits that has no classical counter part.\n", 475 | "
\n", 476 | "It is given by: $$\\frac{1}{\\sqrt{2}}(|00\\rangle + |11\\rangle)$$\n", 477 | "\n", 478 | "Given an initial two qubit system $|00\\rangle$, we create a Bell state by applying an H gate to the first qubit and, then, a CX gate where the first qubit acts as control and the second qubit as target state." 479 | ] 480 | }, 481 | { 482 | "cell_type": "code", 483 | "execution_count": 14, 484 | "metadata": {}, 485 | "outputs": [ 486 | { 487 | "data": { 488 | "image/png": "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\n", 489 | "text/plain": [ 490 | "
" 491 | ] 492 | }, 493 | "execution_count": 14, 494 | "metadata": {}, 495 | "output_type": "execute_result" 496 | } 497 | ], 498 | "source": [ 499 | "# create a quantum circuit\n", 500 | "qc = QuantumCircuit(2, 2)\n", 501 | "\n", 502 | "# add a H gate on qubit 0, putting this qubit in superposition\n", 503 | "qc.h(0)\n", 504 | "\n", 505 | "# add a CX (CNOT) gate on control qubit 0 and target qubit 1\n", 506 | "qc.cx(0, 1)\n", 507 | "\n", 508 | "# add a measure gate to see the state.\n", 509 | "qc.measure([0, 1], [0, 1])\n", 510 | "\n", 511 | "# plot the circuit\n", 512 | "qc.draw(output='mpl')" 513 | ] 514 | }, 515 | { 516 | "cell_type": "code", 517 | "execution_count": 15, 518 | "metadata": {}, 519 | "outputs": [ 520 | { 521 | "name": "stdout", 522 | "output_type": "stream", 523 | "text": [ 524 | "counts: {'00': 507, '11': 493}\n" 525 | ] 526 | }, 527 | { 528 | "data": { 529 | "image/png": "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\n", 530 | "text/plain": [ 531 | "
" 532 | ] 533 | }, 534 | "execution_count": 15, 535 | "metadata": {}, 536 | "output_type": "execute_result" 537 | } 538 | ], 539 | "source": [ 540 | "# compile and run the quantum circuit on the local simulator\n", 541 | "shots = 1000\n", 542 | "job = execute(qc, backend, shots=shots)\n", 543 | "results = job.result()\n", 544 | "print(\"counts:\", results.get_counts())\n", 545 | "\n", 546 | "# plot results\n", 547 | "plot_histogram(results.get_counts())" 548 | ] 549 | }, 550 | { 551 | "cell_type": "markdown", 552 | "metadata": {}, 553 | "source": [ 554 | "Exercise:
\n", 555 | "Prepare the following state: $\\frac{1}{\\sqrt{2}}(|01\\rangle + |10\\rangle)$ by designing a quantum circuit that is similar to the Bell state construction." 556 | ] 557 | }, 558 | { 559 | "cell_type": "code", 560 | "execution_count": null, 561 | "metadata": {}, 562 | "outputs": [], 563 | "source": [ 564 | "qc = QuantumCircuit(2, 2)\n", 565 | "\n", 566 | "# write your circuit here:\n", 567 | "#\n", 568 | "#\n", 569 | "#\n", 570 | "\n", 571 | "qc.measure([0, 1], [0, 1])\n", 572 | "\n", 573 | "# plot the circuit\n", 574 | "qc.draw(output='mpl')" 575 | ] 576 | }, 577 | { 578 | "cell_type": "code", 579 | "execution_count": null, 580 | "metadata": {}, 581 | "outputs": [], 582 | "source": [ 583 | "# compile and run the quantum circuit on the local simulator\n", 584 | "job = execute(qc, backend, shots=1024)\n", 585 | "results = job.result()\n", 586 | "print(\"counts:\", results.get_counts())\n", 587 | "\n", 588 | "# plot results\n", 589 | "plot_histogram(results.get_counts())" 590 | ] 591 | }, 592 | { 593 | "cell_type": "code", 594 | "execution_count": null, 595 | "metadata": {}, 596 | "outputs": [], 597 | "source": [] 598 | } 599 | ], 600 | "metadata": { 601 | "kernelspec": { 602 | "display_name": "Python 3", 603 | "language": "python", 604 | "name": "python3" 605 | }, 606 | "language_info": { 607 | "codemirror_mode": { 608 | "name": "ipython", 609 | "version": 3 610 | }, 611 | "file_extension": ".py", 612 | "mimetype": "text/x-python", 613 | "name": "python", 614 | "nbconvert_exporter": "python", 615 | "pygments_lexer": "ipython3", 616 | "version": "3.7.1" 617 | } 618 | }, 619 | "nbformat": 4, 620 | "nbformat_minor": 2 621 | } 622 | -------------------------------------------------------------------------------- /quantum_variational_classifier.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": { 6 | "collapsed": true 7 | }, 8 | "source": [ 9 | "# Quantum Variational Classifier\n", 10 | "\n", 11 | "This tutorial discusses how a quantum computer can be used to solve a classification task.
\n", 12 | "The example is based on the following paper:\n", 13 | "
\n", 14 | "
\n", 15 | "Supervised learning with quantum enhanced feature spaces
\n", 16 | "Vojtech Havlicek, Antonio D. Corcoles, Kristan Temme, Aram W. Harrow, Abhinav Kandala, Jerry M. Chow, and Jay M. Gambetta
\n", 17 | "arXiv:1804.11326 (2018)" 18 | ] 19 | }, 20 | { 21 | "cell_type": "code", 22 | "execution_count": 1, 23 | "metadata": {}, 24 | "outputs": [], 25 | "source": [ 26 | "from svm.datasets import *\n", 27 | "from qiskit.aqua.input import ClassificationInput\n", 28 | "from qiskit.aqua import run_algorithm\n", 29 | "from qiskit import QuantumRegister, ClassicalRegister, QuantumCircuit\n", 30 | "from qiskit import Aer, execute\n", 31 | "from qiskit.aqua.components.optimizers.cobyla import COBYLA\n", 32 | "import numpy as np\n", 33 | "import matplotlib.pyplot as plt\n", 34 | "%matplotlib inline" 35 | ] 36 | }, 37 | { 38 | "cell_type": "markdown", 39 | "metadata": {}, 40 | "source": [ 41 | "## Data\n", 42 | "\n", 43 | "Before we can train the Quantum Variational Classifier, we have to load the data set that we are interested in and split it into a training and a test set.\n", 44 | "
\n", 45 | "Note that the ad hoc data set is constructed suitably for the purpose of illustration.\n", 46 | "
\n", 47 | "
\n", 48 | "Exercise:
\n", 49 | "Feel free to train and test the classifier with the alternatively given training data set:
\n", 50 | "UCI Machine Learning Repository - Wine Data Set
\n", 51 | "To switch between the data sets set the use_adhoc_dataset to True or False." 52 | ] 53 | }, 54 | { 55 | "cell_type": "code", 56 | "execution_count": 2, 57 | "metadata": {}, 58 | "outputs": [ 59 | { 60 | "data": { 61 | "image/png": "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\n", 62 | "text/plain": [ 63 | "
" 64 | ] 65 | }, 66 | "metadata": { 67 | "needs_background": "light" 68 | }, 69 | "output_type": "display_data" 70 | }, 71 | { 72 | "data": { 73 | "image/png": "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\n", 74 | "text/plain": [ 75 | "
" 76 | ] 77 | }, 78 | "metadata": { 79 | "needs_background": "light" 80 | }, 81 | "output_type": "display_data" 82 | } 83 | ], 84 | "source": [ 85 | "# size of training data set\n", 86 | "training_size = 20\n", 87 | "\n", 88 | "# size of test data set\n", 89 | "test_size = 10\n", 90 | "\n", 91 | "# dimension of data sets\n", 92 | "n = 2\n", 93 | "\n", 94 | "# construct training and test data\n", 95 | "# set the following flag to True for the first data set and to False for the second dataset\n", 96 | "use_adhoc_dataset = True\n", 97 | "if use_adhoc_dataset:\n", 98 | " # first (artifical) data set to test the classifier\n", 99 | " training_input, test_input, class_labels = \\\n", 100 | " ad_hoc_data(training_size=training_size, test_size=test_size, n=n, gap=0.3, plot_data=True)\n", 101 | "else:\n", 102 | " # second data set to test the classifier\n", 103 | " training_input, test_input, class_labels = \\\n", 104 | " Wine(training_size=training_size, test_size=test_size, n=n, plot_data=True)\n" 105 | ] 106 | }, 107 | { 108 | "cell_type": "markdown", 109 | "metadata": {}, 110 | "source": [ 111 | "## Quantum Feature Map\n", 112 | "\n", 113 | "The Quantum Feature Map $\\cal{U}_{\\Phi(\\vec{x})}$ is a quantum circuit parametrized by a classical input datapoint $\\vec{x}$.\n", 114 | "Thus, $\\cal{U}$ maps $\\vec{x}$ to the quantum feature space whose dimension is exponential in the number of qubits.\n", 115 | "In this tutorial we use the following quantum feature map:\n", 116 | "\n", 117 | "
\n", 118 | "where\n", 119 | "### $$U_{\\Phi(\\vec{x})} = e^{i\\left(x_1 Z \\otimes I + x_2 I \\otimes Z + x_1x_2Z \\otimes Z \\right)}$$\n", 120 | "\n", 121 | "The classical data sample $\\vec{x}$ is loaded by applying the Quantum Feature Map onto the initial quantum state $|0{\\rangle}^{\\otimes n}$:\n", 122 | "### $$|\\phi(\\vec{x})\\rangle = \\cal{U}_{\\Phi(\\vec{x})}|0{\\rangle}^{\\otimes n}$$\n", 123 | "\n" 124 | ] 125 | }, 126 | { 127 | "cell_type": "code", 128 | "execution_count": 3, 129 | "metadata": {}, 130 | "outputs": [], 131 | "source": [ 132 | "def feature_map(x, q):\n", 133 | " \n", 134 | " # initialize quantum circuit\n", 135 | " qc = QuantumCircuit(q)\n", 136 | " \n", 137 | " # apply hadamards and U_Phi twice\n", 138 | " for _ in range(2):\n", 139 | " \n", 140 | " # apply the hadamard and Z-rotatiion to all qubits\n", 141 | " for i in range(x.shape[0]):\n", 142 | " qc.h(q[i])\n", 143 | " qc.rz(2 * x[i], q[i])\n", 144 | " \n", 145 | " # apply the two qubit gate\n", 146 | " qc.cx(q[0], q[1])\n", 147 | " qc.rz(2*(np.pi-x[0])*(np.pi-x[1]), q[1])\n", 148 | " qc.cx(q[0], q[1])\n", 149 | "\n", 150 | " # return quantum circuit\n", 151 | " return qc" 152 | ] 153 | }, 154 | { 155 | "cell_type": "markdown", 156 | "metadata": {}, 157 | "source": [ 158 | "We can now use a classical vector, for instance $\\begin{pmatrix} 1.5 \\\\ 0.3 \\end{pmatrix}$ to apply the quantum feature map onto the quantum state $|0{\\rangle}^{\\otimes 2}$, analyze the resulting statevector and plot the corresponding quantum circuit." 159 | ] 160 | }, 161 | { 162 | "cell_type": "code", 163 | "execution_count": 4, 164 | "metadata": {}, 165 | "outputs": [ 166 | { 167 | "name": "stdout", 168 | "output_type": "stream", 169 | "text": [ 170 | "simulation: Result(backend_name='statevector_simulator', backend_version='0.3.0', date=datetime.datetime(2019, 8, 24, 12, 2, 46, 689335), header=Obj(backend_name='statevector_simulator', backend_version='0.3.0'), job_id='50e6e260-cb3b-4d7a-869e-285a116a64e8', metadata={'max_memory_mb': 8103, 'omp_enabled': True, 'parallel_experiments': 1, 'time_taken': 0.0002005}, qobj_id='09bfa60f-f4b7-493c-877f-39f29e53c2ed', results=[ExperimentResult(data=ExperimentResultData(statevector=[(0.049997991887651305-0.29018719299670587j), (0.023359416632460876+0.0441673605792097j), (-0.7357557507445133-0.6039081802139161j), (0.029046334407502893-0.06252896382105116j)]), header=Obj(clbit_labels=[], creg_sizes=[], memory_slots=0, n_qubits=2, name='circuit0', qreg_sizes=[['q0', 2]], qubit_labels=[['q0', 0], ['q0', 1]]), meas_level=2, metadata={'parallel_shots': 1, 'parallel_state_update': 8}, seed_simulator=3530234561, shots=1, status='DONE', success=True, time_taken=7.96e-05)], status='COMPLETED', success=True, time_taken=0.0010178089141845703)\n", 171 | "statevector: [ 0.05 -0.2902j 0.0234+0.0442j -0.7358-0.6039j 0.029 -0.0625j]\n" 172 | ] 173 | } 174 | ], 175 | "source": [ 176 | "# initialize quantum register\n", 177 | "num_qubits = 2\n", 178 | "qr = QuantumRegister(num_qubits)\n", 179 | "\n", 180 | "# initialize test data (x1, x2)\n", 181 | "data = np.asarray([1.5, 0.3])\n", 182 | "\n", 183 | "# get quantum circuit\n", 184 | "qc_feature_map = feature_map(data, qr)\n", 185 | "# simulate using local statevector simulator\n", 186 | "backend = Aer.get_backend('statevector_simulator')\n", 187 | "\n", 188 | "job_sim = execute(qc_feature_map, backend)\n", 189 | "sim_results = job_sim.result()\n", 190 | "print('simulation: ', sim_results)\n", 191 | "print('statevector: ', np.round(sim_results.get_statevector(), decimals=4))" 192 | ] 193 | }, 194 | { 195 | "cell_type": "code", 196 | "execution_count": 5, 197 | "metadata": {}, 198 | "outputs": [ 199 | { 200 | "data": { 201 | "image/png": "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\n", 202 | "text/plain": [ 203 | "
" 204 | ] 205 | }, 206 | "execution_count": 5, 207 | "metadata": {}, 208 | "output_type": "execute_result" 209 | } 210 | ], 211 | "source": [ 212 | "# draw circuit\n", 213 | "qc_feature_map.draw(output='mpl', plot_barriers=False)" 214 | ] 215 | }, 216 | { 217 | "cell_type": "markdown", 218 | "metadata": {}, 219 | "source": [ 220 | "## Variational Form\n", 221 | "\n", 222 | "The variational form is similar to an artifical neural network:\n", 223 | "
\n", 224 | "The quantum circuit receives input data, processes it through multiple layers of parametrized quantum gates and is trained by adjusting the parameters (weights).\n", 225 | "
\n", 226 | "It should be noted that in order to optimize the parameters, the outcome of the Quantum Variational Circuit must be measured. The measurement outcome corresponds to classical bits which can be integrated in an optimization algorithm, such as gradient descent. \n", 227 | "
\n", 228 | "
\n", 229 | "In this tutorial we use the following Variational Form:\n", 230 | "
\n", 231 | "\n", 232 | "
\n", 233 | "The single qubit rotations denoted by $\\theta_{i,j}$ correspond to Z-rotations and Y-rotations and the entangler block $U_{ent}$ consists of controlled-Z gates.\n", 234 | "Further, the parameter $d$ denotes the depth of the Variational Circuit, i.e. the number of repitions of entangler blocks and single qubit rotation layers.\n", 235 | "
\n", 236 | "
\n", 237 | "Exercise:
\n", 238 | "See how the classification performance changes when you modify the types of gates used within the quantum circuit." 239 | ] 240 | }, 241 | { 242 | "cell_type": "code", 243 | "execution_count": 6, 244 | "metadata": {}, 245 | "outputs": [], 246 | "source": [ 247 | "def variational_form(q, params, depth):\n", 248 | " \n", 249 | " # initialize quantum circuit\n", 250 | " qc = QuantumCircuit(q)\n", 251 | " \n", 252 | " # first set of rotations\n", 253 | " param_idx = 0\n", 254 | " for qubit in range(2):\n", 255 | " qc.ry(params[param_idx], q[qubit])\n", 256 | " qc.rz(params[param_idx+1], q[qubit])\n", 257 | " param_idx += 2\n", 258 | "\n", 259 | " # entangler blocks and succeeding rotations\n", 260 | " for block in range(depth):\n", 261 | " qc.cz(q[0], q[1])\n", 262 | " for qubit in range(2):\n", 263 | " qc.ry(params[param_idx], q[qubit])\n", 264 | " qc.rz(params[param_idx+1], q[qubit])\n", 265 | " param_idx += 2\n", 266 | " \n", 267 | " # return quantum circuit\n", 268 | " return qc" 269 | ] 270 | }, 271 | { 272 | "cell_type": "code", 273 | "execution_count": 7, 274 | "metadata": {}, 275 | "outputs": [ 276 | { 277 | "name": "stdout", 278 | "output_type": "stream", 279 | "text": [ 280 | "simulation: Result(backend_name='statevector_simulator', backend_version='0.3.0', date=datetime.datetime(2019, 8, 24, 12, 2, 47, 238870), header=Obj(backend_name='statevector_simulator', backend_version='0.3.0'), job_id='9d817174-0488-4179-85cd-44b2ae2f7d8e', metadata={'max_memory_mb': 8103, 'omp_enabled': True, 'parallel_experiments': 1, 'time_taken': 0.0001969}, qobj_id='725cfccf-bbd5-433c-88af-6dcabb954e0b', results=[ExperimentResult(data=ExperimentResultData(statevector=[(0.716619589106532+0.04833322141870618j), (0.5354679702552034-0.37159438291186925j), (0.07245703062900394+0.22730968702723042j), (0.045470046956351914+0.018019194238159317j)]), header=Obj(clbit_labels=[], creg_sizes=[], memory_slots=0, n_qubits=2, name='circuit2', qreg_sizes=[['q1', 2]], qubit_labels=[['q1', 0], ['q1', 1]]), meas_level=2, metadata={'parallel_shots': 1, 'parallel_state_update': 8}, seed_simulator=1640106043, shots=1, status='DONE', success=True, time_taken=5.96e-05)], status='COMPLETED', success=True, time_taken=0.0030269622802734375)\n", 281 | "statevector: [0.7166+0.0483j 0.5355-0.3716j 0.0725+0.2273j 0.0455+0.018j ]\n" 282 | ] 283 | }, 284 | { 285 | "data": { 286 | "image/png": "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\n", 287 | "text/plain": [ 288 | "
" 289 | ] 290 | }, 291 | "execution_count": 7, 292 | "metadata": {}, 293 | "output_type": "execute_result" 294 | } 295 | ], 296 | "source": [ 297 | "# initialize quantum register\n", 298 | "num_qubits = 2\n", 299 | "qr = QuantumRegister(num_qubits)\n", 300 | "\n", 301 | "# set depth, i.e. number of entangler blocks and rotations (after the initial rotation)\n", 302 | "depth = 2\n", 303 | "params = [0.5,-0.3, 0.2, 0.6]*(depth+1)\n", 304 | "qc_variational_form = variational_form(qr, params, depth)\n", 305 | "\n", 306 | "# simulate using local statevector simulator\n", 307 | "job_sim = execute(qc_variational_form, backend)\n", 308 | "sim_results = job_sim.result()\n", 309 | "print('simulation: ', sim_results)\n", 310 | "print('statevector: ', np.round(sim_results.get_statevector(), decimals=4))\n", 311 | "\n", 312 | "# draw circuit\n", 313 | "qc_variational_form.draw(output='mpl', plot_barriers=False)" 314 | ] 315 | }, 316 | { 317 | "cell_type": "markdown", 318 | "metadata": {}, 319 | "source": [ 320 | "# The Quantum Variational Classifier\n", 321 | "\n", 322 | "Before we can combine the previously introduced components to the quantum variational classifier, we need to introduce some more helper functions." 323 | ] 324 | }, 325 | { 326 | "cell_type": "markdown", 327 | "metadata": {}, 328 | "source": [ 329 | "#### 1. Assign a label to the measurement outcome \n", 330 | "We use the parity function to assign a class label to the measurement outcomes which are given as bit strings. In explicit, a measurement consisting of an even number of '1's is mapped to the first class, and a measurement outcome consisting of an odd number of '1's is mapped to the second class." 331 | ] 332 | }, 333 | { 334 | "cell_type": "code", 335 | "execution_count": 8, 336 | "metadata": {}, 337 | "outputs": [], 338 | "source": [ 339 | "def assign_label(bit_string, class_labels):\n", 340 | " hamming_weight = sum([int(k) for k in list(bit_string)])\n", 341 | " is_odd_parity = hamming_weight & 1\n", 342 | " if is_odd_parity:\n", 343 | " return class_labels[1]\n", 344 | " else:\n", 345 | " return class_labels[0]" 346 | ] 347 | }, 348 | { 349 | "cell_type": "code", 350 | "execution_count": 9, 351 | "metadata": {}, 352 | "outputs": [ 353 | { 354 | "data": { 355 | "text/plain": [ 356 | "'B'" 357 | ] 358 | }, 359 | "execution_count": 9, 360 | "metadata": {}, 361 | "output_type": "execute_result" 362 | } 363 | ], 364 | "source": [ 365 | "# assigns a label \n", 366 | "assign_label('01', class_labels)" 367 | ] 368 | }, 369 | { 370 | "cell_type": "markdown", 371 | "metadata": {}, 372 | "source": [ 373 | "#### 2. Map the counts of multiple shots to probabilities for the classes\n", 374 | "After running the same circuit many times, we derive the empirical probabilities of assigning the first or second class.\n" 375 | ] 376 | }, 377 | { 378 | "cell_type": "code", 379 | "execution_count": 10, 380 | "metadata": {}, 381 | "outputs": [], 382 | "source": [ 383 | "def return_probabilities(counts, class_labels):\n", 384 | " shots = sum(counts.values())\n", 385 | " result = {class_labels[0]: 0, \n", 386 | " class_labels[1]: 0}\n", 387 | " for key, item in counts.items():\n", 388 | " label = assign_label(key, class_labels)\n", 389 | " result[label] += counts[key]/shots\n", 390 | " return result" 391 | ] 392 | }, 393 | { 394 | "cell_type": "code", 395 | "execution_count": 11, 396 | "metadata": {}, 397 | "outputs": [ 398 | { 399 | "data": { 400 | "text/plain": [ 401 | "{'A': 0.5, 'B': 0.5}" 402 | ] 403 | }, 404 | "execution_count": 11, 405 | "metadata": {}, 406 | "output_type": "execute_result" 407 | } 408 | ], 409 | "source": [ 410 | "return_probabilities({'00' : 10, '01': 10}, class_labels)" 411 | ] 412 | }, 413 | { 414 | "cell_type": "markdown", 415 | "metadata": {}, 416 | "source": [ 417 | "#### 3. Combine everything to build the classifier\n", 418 | "We combine the feature map, the variational circuit, and the label assignment to construct our (untrained) classifier.\n", 419 | "
\n", 420 | "Note that the classifier is already constructed in such a way that it is able to process a list of data points." 421 | ] 422 | }, 423 | { 424 | "cell_type": "code", 425 | "execution_count": 12, 426 | "metadata": {}, 427 | "outputs": [], 428 | "source": [ 429 | "def classifier_circuit(x, params, depth):\n", 430 | " \n", 431 | " q = QuantumRegister(2)\n", 432 | " c = ClassicalRegister(2)\n", 433 | " qc = QuantumCircuit(q, c)\n", 434 | "\n", 435 | " qc_feature_map = feature_map(x, q)\n", 436 | " qc_variational_form = variational_form(q, params, depth)\n", 437 | "\n", 438 | " qc += qc_feature_map\n", 439 | " qc += qc_variational_form\n", 440 | "\n", 441 | " qc.measure(q, c)\n", 442 | " \n", 443 | " return qc\n", 444 | "\n", 445 | "def classify(x_list, params, class_labels, depth=2, shots=100):\n", 446 | " \n", 447 | " qc_list = []\n", 448 | " for x in x_list:\n", 449 | " qc = classifier_circuit(x, params, depth)\n", 450 | " qc_list += [qc]\n", 451 | " qasm_backend = Aer.get_backend('qasm_simulator') \n", 452 | " jobs = execute(qc_list, qasm_backend, shots=shots)\n", 453 | " \n", 454 | " probs = []\n", 455 | " for qc in qc_list:\n", 456 | " counts = jobs.result().get_counts(qc)\n", 457 | " prob = return_probabilities(counts, class_labels)\n", 458 | " probs += [prob]\n", 459 | " \n", 460 | " return probs" 461 | ] 462 | }, 463 | { 464 | "cell_type": "code", 465 | "execution_count": 13, 466 | "metadata": {}, 467 | "outputs": [ 468 | { 469 | "data": { 470 | "image/png": "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\n", 471 | "text/plain": [ 472 | "
" 473 | ] 474 | }, 475 | "execution_count": 13, 476 | "metadata": {}, 477 | "output_type": "execute_result" 478 | } 479 | ], 480 | "source": [ 481 | "# draw classifier circuit\n", 482 | "qc = classifier_circuit(np.asarray([0.5, 0.5]), params, depth)\n", 483 | "\n", 484 | "\n", 485 | "# classify test data point (using random parameters constructed earlier)\n", 486 | "x = np.asarray([[0.5, 0.5]])\n", 487 | "classify(x, params, class_labels, depth)\n", 488 | "\n", 489 | "qc.draw(output='mpl', plot_barriers=False)" 490 | ] 491 | }, 492 | { 493 | "cell_type": "markdown", 494 | "metadata": {}, 495 | "source": [ 496 | "#### 4. Assign a cost value to the estimation probabilities\n", 497 | "Given a training data point and the corresponding training class label, we can calculate a cost value which represents the probability of correct/false classification. \n", 498 | "
\n", 499 | "We only need a singificant bias towards the correct classification and, thus, use the sigmoid function to evaluate the cost value (error probability).
\n", 500 | "The function is close to zero if the probability of assigning the correct class is close to one, and close to one otherwise." 501 | ] 502 | }, 503 | { 504 | "cell_type": "code", 505 | "execution_count": 14, 506 | "metadata": {}, 507 | "outputs": [], 508 | "source": [ 509 | "def cost_estimate_sigmoid(probs, expected_label):\n", 510 | "\n", 511 | " p = probs.get(expected_label)\n", 512 | " sig = None\n", 513 | " if np.isclose(p, 0.0):\n", 514 | " sig = 1\n", 515 | " elif np.isclose(p, 1.0):\n", 516 | " sig = 0\n", 517 | " else:\n", 518 | " denominator = np.sqrt(2*p*(1-p))\n", 519 | " x = np.sqrt(200)*(0.5-p)/denominator\n", 520 | " sig = 1/(1+np.exp(-x))\n", 521 | "\n", 522 | " return sig" 523 | ] 524 | }, 525 | { 526 | "cell_type": "code", 527 | "execution_count": 15, 528 | "metadata": {}, 529 | "outputs": [ 530 | { 531 | "data": { 532 | "image/png": "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\n", 533 | "text/plain": [ 534 | "
" 535 | ] 536 | }, 537 | "metadata": { 538 | "needs_background": "light" 539 | }, 540 | "output_type": "display_data" 541 | } 542 | ], 543 | "source": [ 544 | "x = np.linspace(0, 1, 20)\n", 545 | "y = [cost_estimate_sigmoid({'A': x_, 'B': 1-x_}, 'A') for x_ in x]\n", 546 | "plt.plot(x, y)\n", 547 | "plt.xlabel('Probability of assigning the correct class')\n", 548 | "plt.ylabel('Cost value')\n", 549 | "plt.show()" 550 | ] 551 | }, 552 | { 553 | "cell_type": "markdown", 554 | "metadata": {}, 555 | "source": [ 556 | "#### 5. Evaluate the overall performance for the training set\n", 557 | "We compute the average cost value over all training data points and use this as the objective function to train our classifier." 558 | ] 559 | }, 560 | { 561 | "cell_type": "code", 562 | "execution_count": 16, 563 | "metadata": { 564 | "scrolled": false 565 | }, 566 | "outputs": [], 567 | "source": [ 568 | "def cost_function(training_input, class_labels, params, depth=2, shots=100, print_value=False):\n", 569 | " \n", 570 | " # map training input to list of labels and list of samples\n", 571 | " cost = 0\n", 572 | " training_labels = []\n", 573 | " training_samples = []\n", 574 | " for label, samples in training_input.items():\n", 575 | " for sample in samples:\n", 576 | " training_labels += [label]\n", 577 | " training_samples += [sample]\n", 578 | " \n", 579 | " # classify all samples\n", 580 | " probs = classify(training_samples, params, class_labels, depth)\n", 581 | " \n", 582 | " # evaluate costs for all classified samples\n", 583 | " for i, prob in enumerate(probs):\n", 584 | " cost += cost_estimate_sigmoid(prob, training_labels[i])\n", 585 | " cost /= len(training_samples)\n", 586 | " \n", 587 | " # print resulting objective function\n", 588 | " if print_value:\n", 589 | " print('%.4f' % cost)\n", 590 | " \n", 591 | " # return objective value\n", 592 | " return cost" 593 | ] 594 | }, 595 | { 596 | "cell_type": "code", 597 | "execution_count": 17, 598 | "metadata": {}, 599 | "outputs": [ 600 | { 601 | "data": { 602 | "text/plain": [ 603 | "0.5174701439112291" 604 | ] 605 | }, 606 | "execution_count": 17, 607 | "metadata": {}, 608 | "output_type": "execute_result" 609 | } 610 | ], 611 | "source": [ 612 | "cost_function(training_input, class_labels, params, depth)" 613 | ] 614 | }, 615 | { 616 | "cell_type": "markdown", 617 | "metadata": {}, 618 | "source": [ 619 | "## Train the classifier\n", 620 | "\n", 621 | "Training the classifier corresponds to an optimization task. Explicitly, we want to minimize the cost value (sigmoid function) such that the classifier manages to properly label the given data.\n", 622 | "
\n", 623 | "
\n", 624 | "Exercise:
\n", 625 | "See how the classification performance changes when you modify the depth of the variational form, the number of shots or number of trials.
\n", 626 | "What's the best that you can achieve for the adhoc data set and the Wine data set?" 627 | ] 628 | }, 629 | { 630 | "cell_type": "code", 631 | "execution_count": 18, 632 | "metadata": { 633 | "scrolled": true 634 | }, 635 | "outputs": [ 636 | { 637 | "name": "stdout", 638 | "output_type": "stream", 639 | "text": [ 640 | "0.4976\n", 641 | "0.5419\n", 642 | "0.5018\n", 643 | "0.3947\n", 644 | "0.3869\n", 645 | "0.2150\n", 646 | "0.3162\n", 647 | "0.2457\n", 648 | "0.3052\n", 649 | "0.4130\n", 650 | "0.2616\n", 651 | "0.1266\n", 652 | "0.1364\n", 653 | "0.3340\n", 654 | "0.1683\n", 655 | "0.4126\n", 656 | "0.1147\n", 657 | "0.1227\n", 658 | "0.1361\n", 659 | "0.1874\n", 660 | "0.1141\n", 661 | "0.1547\n", 662 | "0.2002\n", 663 | "0.1543\n", 664 | "0.1448\n", 665 | "0.1681\n", 666 | "0.1896\n", 667 | "0.1340\n", 668 | "0.1622\n", 669 | "0.1612\n", 670 | "0.1540\n", 671 | "0.1260\n", 672 | "0.1534\n", 673 | "0.1107\n", 674 | "0.1258\n", 675 | "0.1292\n", 676 | "0.1078\n", 677 | "0.0956\n", 678 | "0.0949\n", 679 | "0.1003\n", 680 | "0.1027\n", 681 | "0.0960\n", 682 | "0.1339\n", 683 | "0.0820\n", 684 | "0.0762\n", 685 | "0.0727\n", 686 | "0.0898\n", 687 | "0.0624\n", 688 | "0.0824\n", 689 | "0.0494\n", 690 | "0.0612\n", 691 | "0.0619\n", 692 | "0.0730\n", 693 | "0.0627\n", 694 | "0.0627\n", 695 | "0.0750\n", 696 | "0.0593\n", 697 | "0.0719\n", 698 | "0.0646\n", 699 | "0.0730\n", 700 | "0.0718\n", 701 | "0.0648\n", 702 | "0.0716\n", 703 | "0.0750\n", 704 | "0.0572\n", 705 | "0.0737\n", 706 | "0.0718\n", 707 | "0.0632\n", 708 | "0.0741\n", 709 | "0.0838\n", 710 | "0.0688\n", 711 | "0.0686\n", 712 | "0.0572\n", 713 | "0.0605\n", 714 | "0.0687\n", 715 | "0.0777\n", 716 | "0.0696\n", 717 | "0.0700\n", 718 | "0.0762\n", 719 | "0.0759\n", 720 | "0.0651\n", 721 | "0.0721\n", 722 | "0.0776\n", 723 | "0.0657\n", 724 | "0.0616\n", 725 | "0.0698\n", 726 | "0.0736\n", 727 | "0.0653\n", 728 | "0.0576\n", 729 | "0.0787\n", 730 | "0.0687\n", 731 | "0.0666\n", 732 | "0.0733\n", 733 | "0.0590\n", 734 | "0.0845\n", 735 | "0.0714\n", 736 | "0.0628\n", 737 | "0.0561\n", 738 | "0.0767\n", 739 | "0.0558\n", 740 | "0.0792\n", 741 | "0.0630\n", 742 | "0.0677\n", 743 | "0.0719\n", 744 | "0.0758\n", 745 | "0.0620\n", 746 | "0.0850\n", 747 | "0.0671\n", 748 | "0.0667\n", 749 | "0.0584\n", 750 | "0.0628\n", 751 | "0.0799\n", 752 | "0.0628\n", 753 | "0.0691\n", 754 | "0.0748\n", 755 | "0.0766\n", 756 | "0.0892\n", 757 | "0.0677\n", 758 | "\n", 759 | "opt_params: [0.46537684 3.01203121 3.34499308 6.60826593 1.88255287 3.77234427\n", 760 | " 4.68233135 3.95397507 0.90662879 6.19788929 3.03135655 3.72127197]\n", 761 | "opt_value: 0.06769543701480436\n" 762 | ] 763 | } 764 | ], 765 | "source": [ 766 | "# set depth of variational form\n", 767 | "depth = 2\n", 768 | "\n", 769 | "# set number of shots to evaluate the classification circuit\n", 770 | "shots = 100\n", 771 | "\n", 772 | "# setup the optimizer\n", 773 | "optimizer = COBYLA()\n", 774 | "\n", 775 | "# define objective function for training\n", 776 | "objective_function = lambda params: cost_function(training_input, class_labels, params, depth, shots, print_value=True)\n", 777 | "\n", 778 | "# randomly initialize the parameters\n", 779 | "init_params = 2*np.pi*np.random.rand(num_qubits*(depth+1)*2)\n", 780 | "\n", 781 | "# train classifier\n", 782 | "opt_params, value, _ = optimizer.optimize(len(init_params), objective_function, initial_point=init_params)\n", 783 | "\n", 784 | "# print results\n", 785 | "print()\n", 786 | "print('opt_params:', opt_params)\n", 787 | "print('opt_value: ', value)" 788 | ] 789 | }, 790 | { 791 | "cell_type": "markdown", 792 | "metadata": {}, 793 | "source": [ 794 | "## Test the trained classifier\n", 795 | "\n", 796 | "To check how well we could train the classifier, we evaluate the classification performance on the test data set." 797 | ] 798 | }, 799 | { 800 | "cell_type": "code", 801 | "execution_count": 19, 802 | "metadata": { 803 | "scrolled": true 804 | }, 805 | "outputs": [ 806 | { 807 | "name": "stdout", 808 | "output_type": "stream", 809 | "text": [ 810 | "----------------------------------------------------\n", 811 | "Data point: [6.1575216 1.88495559]\n", 812 | "Label: A\n", 813 | "Assigned: A\n", 814 | "Probabilities: {'A': 0.57, 'B': 0.43000000000000005}\n", 815 | "Classification: CORRECT\n", 816 | "----------------------------------------------------\n", 817 | "Data point: [3.70707933 3.26725636]\n", 818 | "Label: A\n", 819 | "Assigned: A\n", 820 | "Probabilities: {'A': 0.52, 'B': 0.48000000000000004}\n", 821 | "Classification: CORRECT\n", 822 | "----------------------------------------------------\n", 823 | "Data point: [0.25132741 5.71769863]\n", 824 | "Label: A\n", 825 | "Assigned: A\n", 826 | "Probabilities: {'A': 0.96, 'B': 0.04}\n", 827 | "Classification: CORRECT\n", 828 | "----------------------------------------------------\n", 829 | "Data point: [2.57610598 4.46106157]\n", 830 | "Label: A\n", 831 | "Assigned: A\n", 832 | "Probabilities: {'A': 0.5, 'B': 0.5}\n", 833 | "Classification: CORRECT\n", 834 | "----------------------------------------------------\n", 835 | "Data point: [5.59203492 0.37699112]\n", 836 | "Label: A\n", 837 | "Assigned: B\n", 838 | "Probabilities: {'A': 0.45999999999999996, 'B': 0.54}\n", 839 | "Classification: INCORRECT\n", 840 | "----------------------------------------------------\n", 841 | "Data point: [5.46637122 0.37699112]\n", 842 | "Label: A\n", 843 | "Assigned: A\n", 844 | "Probabilities: {'A': 0.5, 'B': 0.5}\n", 845 | "Classification: CORRECT\n", 846 | "----------------------------------------------------\n", 847 | "Data point: [2.32477856 3.95840674]\n", 848 | "Label: A\n", 849 | "Assigned: B\n", 850 | "Probabilities: {'A': 0.35, 'B': 0.65}\n", 851 | "Classification: INCORRECT\n", 852 | "----------------------------------------------------\n", 853 | "Data point: [3.76991118 2.57610598]\n", 854 | "Label: A\n", 855 | "Assigned: B\n", 856 | "Probabilities: {'A': 0.24, 'B': 0.76}\n", 857 | "Classification: INCORRECT\n", 858 | "----------------------------------------------------\n", 859 | "Data point: [1.50796447 5.40353936]\n", 860 | "Label: A\n", 861 | "Assigned: A\n", 862 | "Probabilities: {'A': 0.77, 'B': 0.22999999999999998}\n", 863 | "Classification: CORRECT\n", 864 | "----------------------------------------------------\n", 865 | "Data point: [2.82743339 6.22035345]\n", 866 | "Label: A\n", 867 | "Assigned: A\n", 868 | "Probabilities: {'A': 0.89, 'B': 0.11}\n", 869 | "Classification: CORRECT\n", 870 | "----------------------------------------------------\n", 871 | "Data point: [5.96902604 4.20973416]\n", 872 | "Label: B\n", 873 | "Assigned: B\n", 874 | "Probabilities: {'A': 0.04, 'B': 0.96}\n", 875 | "Classification: CORRECT\n", 876 | "----------------------------------------------------\n", 877 | "Data point: [4.77522083 1.94778745]\n", 878 | "Label: B\n", 879 | "Assigned: B\n", 880 | "Probabilities: {'A': 0.26, 'B': 0.74}\n", 881 | "Classification: CORRECT\n", 882 | "----------------------------------------------------\n", 883 | "Data point: [1.88495559 3.76991118]\n", 884 | "Label: B\n", 885 | "Assigned: B\n", 886 | "Probabilities: {'A': 0.25, 'B': 0.75}\n", 887 | "Classification: CORRECT\n", 888 | "----------------------------------------------------\n", 889 | "Data point: [4.64955713 0.06283185]\n", 890 | "Label: B\n", 891 | "Assigned: B\n", 892 | "Probabilities: {'A': 0.18, 'B': 0.8200000000000001}\n", 893 | "Classification: CORRECT\n", 894 | "----------------------------------------------------\n", 895 | "Data point: [4.71238898 5.71769863]\n", 896 | "Label: B\n", 897 | "Assigned: B\n", 898 | "Probabilities: {'A': 0.05, 'B': 0.95}\n", 899 | "Classification: CORRECT\n", 900 | "----------------------------------------------------\n", 901 | "Data point: [5.2150438 5.15221195]\n", 902 | "Label: B\n", 903 | "Assigned: B\n", 904 | "Probabilities: {'A': 0.2, 'B': 0.8}\n", 905 | "Classification: CORRECT\n", 906 | "----------------------------------------------------\n", 907 | "Data point: [4.52389342 4.33539786]\n", 908 | "Label: B\n", 909 | "Assigned: B\n", 910 | "Probabilities: {'A': 0.34, 'B': 0.66}\n", 911 | "Classification: CORRECT\n", 912 | "----------------------------------------------------\n", 913 | "Data point: [0.75398224 3.45575192]\n", 914 | "Label: B\n", 915 | "Assigned: B\n", 916 | "Probabilities: {'A': 0.32, 'B': 0.68}\n", 917 | "Classification: CORRECT\n", 918 | "----------------------------------------------------\n", 919 | "Data point: [0.37699112 3.33008821]\n", 920 | "Label: B\n", 921 | "Assigned: B\n", 922 | "Probabilities: {'A': 0.14, 'B': 0.8599999999999999}\n", 923 | "Classification: CORRECT\n", 924 | "----------------------------------------------------\n", 925 | "Data point: [1.38230077 3.58141563]\n", 926 | "Label: B\n", 927 | "Assigned: B\n", 928 | "Probabilities: {'A': 0.35000000000000003, 'B': 0.65}\n", 929 | "Classification: CORRECT\n", 930 | "\n", 931 | "85.0 % of the test data was correctly classified!\n" 932 | ] 933 | }, 934 | { 935 | "data": { 936 | "image/png": "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\n", 937 | "text/plain": [ 938 | "
" 939 | ] 940 | }, 941 | "metadata": { 942 | "needs_background": "light" 943 | }, 944 | "output_type": "display_data" 945 | } 946 | ], 947 | "source": [ 948 | "# collect coordinates of test data\n", 949 | "test_label_0_x = [x[0] for x in test_input[class_labels[0]]]\n", 950 | "test_label_0_y = [x[1] for x in test_input[class_labels[0]]]\n", 951 | "test_label_1_x = [x[0] for x in test_input[class_labels[1]]]\n", 952 | "test_label_1_y = [x[1] for x in test_input[class_labels[1]]]\n", 953 | "\n", 954 | "# initialize lists for misclassified datapoints\n", 955 | "test_label_misclassified_x = []\n", 956 | "test_label_misclassified_y = []\n", 957 | "\n", 958 | "# evaluate test data\n", 959 | "for label, samples in test_input.items():\n", 960 | " \n", 961 | " # classify samples \n", 962 | " results = classify(samples, opt_params, class_labels, depth, shots=shots)\n", 963 | " \n", 964 | " # analyze results\n", 965 | " for i, result in enumerate(results):\n", 966 | " \n", 967 | " # assign label\n", 968 | " assigned_label = class_labels[np.argmax([p for p in result.values()])]\n", 969 | " print('----------------------------------------------------')\n", 970 | " print('Data point: ', samples[i])\n", 971 | " print('Label: ', label)\n", 972 | " print('Assigned: ', assigned_label)\n", 973 | " print('Probabilities: ', result)\n", 974 | " \n", 975 | " if label != assigned_label:\n", 976 | " print('Classification:', 'INCORRECT')\n", 977 | " test_label_misclassified_x += [samples[i][0]]\n", 978 | " test_label_misclassified_y += [samples[i][1]]\n", 979 | " else:\n", 980 | " print('Classification:', 'CORRECT')\n", 981 | " \n", 982 | "# compute fraction of misclassified samples\n", 983 | "total = len(test_label_0_x) + len(test_label_1_x)\n", 984 | "num_misclassified = len(test_label_misclassified_x)\n", 985 | "print()\n", 986 | "print(100*(1-num_misclassified/total), \"% of the test data was correctly classified!\")\n", 987 | "\n", 988 | "# plot results\n", 989 | "plt.figure()\n", 990 | "plt.scatter(test_label_0_x, test_label_0_y, c='b', label=class_labels[0], linewidths=5)\n", 991 | "plt.scatter(test_label_1_x, test_label_1_y, c='g', label=class_labels[1], linewidths=5)\n", 992 | "plt.scatter(test_label_misclassified_x, test_label_misclassified_y, linewidths=20, s=1, facecolors='none', edgecolors='r')\n", 993 | "plt.legend()\n", 994 | "plt.show()" 995 | ] 996 | }, 997 | { 998 | "cell_type": "code", 999 | "execution_count": null, 1000 | "metadata": {}, 1001 | "outputs": [], 1002 | "source": [] 1003 | } 1004 | ], 1005 | "metadata": { 1006 | "kernelspec": { 1007 | "display_name": "Python 3", 1008 | "language": "python", 1009 | "name": "python3" 1010 | }, 1011 | "language_info": { 1012 | "codemirror_mode": { 1013 | "name": "ipython", 1014 | "version": 3 1015 | }, 1016 | "file_extension": ".py", 1017 | "mimetype": "text/x-python", 1018 | "name": "python", 1019 | "nbconvert_exporter": "python", 1020 | "pygments_lexer": "ipython3", 1021 | "version": "3.7.1" 1022 | } 1023 | }, 1024 | "nbformat": 4, 1025 | "nbformat_minor": 1 1026 | } 1027 | -------------------------------------------------------------------------------- /svm/__pycache__/datasets.cpython-37.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stefan-woerner/qiskit_tutorial/b6cc0a85c4b442facb353eb6aebec0b63464f9be/svm/__pycache__/datasets.cpython-37.pyc -------------------------------------------------------------------------------- /svm/datasets.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | 3 | # Copyright 2018 IBM. 4 | # 5 | # Licensed under the Apache License, Version 2.0 (the "License"); 6 | # you may not use this file except in compliance with the License. 7 | # You may obtain a copy of the License at 8 | # 9 | # http://www.apache.org/licenses/LICENSE-2.0 10 | # 11 | # Unless required by applicable law or agreed to in writing, software 12 | # distributed under the License is distributed on an "AS IS" BASIS, 13 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 14 | # See the License for the specific language governing permissions and 15 | # limitations under the License. 16 | # ============================================================================= 17 | 18 | import numpy as np 19 | import scipy 20 | from scipy.linalg import expm 21 | import matplotlib 22 | matplotlib.use('TkAgg') 23 | import matplotlib.pyplot as plt 24 | from mpl_toolkits.mplot3d import Axes3D 25 | from sklearn import datasets 26 | from sklearn.model_selection import train_test_split 27 | from sklearn.preprocessing import StandardScaler, MinMaxScaler 28 | from sklearn.decomposition import PCA 29 | 30 | 31 | def ad_hoc_data(training_size, test_size, n, gap, plot_data = False): 32 | class_labels = [r'A', r'B'] 33 | if n == 2: 34 | N = 100 35 | elif n == 3: 36 | N = 20 # courseness of data seperation 37 | 38 | label_train = np.zeros(2*(training_size+test_size)) 39 | sample_train = [] 40 | sampleA = [[0 for x in range(n)] for y in range(training_size+test_size)] 41 | sampleB = [[0 for x in range(n)] for y in range(training_size+test_size)] 42 | 43 | sample_Total = [[[0 for x in range(N)] for y in range(N)] for z in range(N)] 44 | 45 | interactions = np.transpose(np.array([[1, 0], [0, 1], [1, 1]])) 46 | 47 | steps = 2*np.pi/N 48 | 49 | sx = np.array([[0, 1], [1, 0]]) 50 | X = np.asmatrix(sx) 51 | sy = np.array([[0, -1j], [1j, 0]]) 52 | Y = np.asmatrix(sy) 53 | sz = np.array([[1, 0], [0, -1]]) 54 | Z = np.asmatrix(sz) 55 | J = np.array([[1, 0], [0, 1]]) 56 | J = np.asmatrix(J) 57 | H = np.array([[1, 1], [1, -1]])/np.sqrt(2) 58 | H2 = np.kron(H, H) 59 | H3 = np.kron(H, H2) 60 | H = np.asmatrix(H) 61 | H2 = np.asmatrix(H2) 62 | H3 = np.asmatrix(H3) 63 | 64 | f = np.arange(2**n) 65 | 66 | my_array = [[0 for x in range(n)] for y in range(2**n)] 67 | 68 | for arindex in range(len(my_array)): 69 | temp_f = bin(f[arindex])[2:].zfill(n) 70 | for findex in range(n): 71 | my_array[arindex][findex] = int(temp_f[findex]) 72 | 73 | my_array = np.asarray(my_array) 74 | my_array = np.transpose(my_array) 75 | 76 | # Define decision functions 77 | maj = (-1)**(2*my_array.sum(axis=0) > n) 78 | parity = (-1)**(my_array.sum(axis=0)) 79 | dict1 = (-1)**(my_array[0]) 80 | if n == 2: 81 | D = np.diag(parity) 82 | elif n == 3: 83 | D = np.diag(maj) 84 | 85 | Basis = np.random.random((2**n, 2**n)) + 1j*np.random.random((2**n, 2**n)) 86 | Basis = np.asmatrix(Basis).getH()*np.asmatrix(Basis) 87 | 88 | [S, U] = np.linalg.eig(Basis) 89 | 90 | idx = S.argsort()[::-1] 91 | S = S[idx] 92 | U = U[:, idx] 93 | 94 | M = (np.asmatrix(U)).getH()*np.asmatrix(D)*np.asmatrix(U) 95 | 96 | psi_plus = np.transpose(np.ones(2))/np.sqrt(2) 97 | psi_0 = 1 98 | for k in range(n): 99 | psi_0 = np.kron(np.asmatrix(psi_0), np.asmatrix(psi_plus)) 100 | 101 | sample_total_A = [] 102 | sample_total_B = [] 103 | sample_total_void = [] 104 | if n == 2: 105 | for n1 in range(N): 106 | for n2 in range(N): 107 | x1 = steps*n1 108 | x2 = steps*n2 109 | phi = x1*np.kron(Z, J) + x2*np.kron(J, Z) + (np.pi-x1)*(np.pi-x2)*np.kron(Z, Z) 110 | Uu = scipy.linalg.expm(1j*phi) 111 | psi = np.asmatrix(Uu)*H2*np.asmatrix(Uu)*np.transpose(psi_0) 112 | temp = np.asscalar(np.real(psi.getH()*M*psi)) 113 | if temp > gap: 114 | sample_Total[n1][n2] = +1 115 | elif temp < -gap: 116 | sample_Total[n1][n2] = -1 117 | else: 118 | sample_Total[n1][n2] = 0 119 | 120 | # Now sample randomly from sample_Total a number of times training_size+testing_size 121 | tr = 0 122 | while tr < (training_size+test_size): 123 | draw1 = np.random.choice(N) 124 | draw2 = np.random.choice(N) 125 | if sample_Total[draw1][draw2] == +1: 126 | sampleA[tr] = [2*np.pi*draw1/N, 2*np.pi*draw2/N] 127 | tr += 1 128 | 129 | tr = 0 130 | while tr < (training_size+test_size): 131 | draw1 = np.random.choice(N) 132 | draw2 = np.random.choice(N) 133 | if sample_Total[draw1][draw2] == -1: 134 | sampleB[tr] = [2*np.pi*draw1/N, 2*np.pi*draw2/N] 135 | tr += 1 136 | 137 | sample_train = [sampleA, sampleB] 138 | 139 | for lindex in range(training_size+test_size): 140 | label_train[lindex] = 0 141 | for lindex in range(training_size+test_size): 142 | label_train[training_size+test_size+lindex] = 1 143 | label_train = label_train.astype(int) 144 | sample_train = np.reshape(sample_train, (2*(training_size+test_size), n)) 145 | training_input = {key: (sample_train[label_train == k, :])[:training_size] 146 | for k, key in enumerate(class_labels)} 147 | test_input = {key: (sample_train[label_train == k, :])[training_size:( 148 | training_size+test_size)] for k, key in enumerate(class_labels)} 149 | 150 | if plot_data: 151 | img = plt.imshow(np.asmatrix(sample_Total).T, interpolation='nearest', 152 | origin='lower', cmap='copper', extent=[0, 2*np.pi, 0, 2*np.pi]) 153 | plt.show() 154 | fig2 = plt.figure() 155 | for k in range(0, 2): 156 | plt.scatter(sample_train[label_train == k, 0][:training_size], 157 | sample_train[label_train == k, 1][:training_size]) 158 | 159 | plt.title("Ad-hoc Data") 160 | plt.show() 161 | 162 | elif n == 3: 163 | for n1 in range(N): 164 | for n2 in range(N): 165 | for n3 in range(N): 166 | x1 = steps*n1 167 | x2 = steps*n2 168 | x3 = steps*n3 169 | phi = x1*np.kron(np.kron(Z, J), J) + x2*np.kron(np.kron(J, Z), J) + x3*np.kron(np.kron(J, J), Z) + \ 170 | (np.pi-x1)*(np.pi-x2)*np.kron(np.kron(Z, Z), J)+(np.pi-x2)*(np.pi-x3)*np.kron(np.kron(J, Z), Z) + \ 171 | (np.pi-x1)*(np.pi-x3)*np.kron(np.kron(Z, J), Z) 172 | Uu = scipy.linalg.expm(1j*phi) 173 | psi = np.asmatrix(Uu)*H3*np.asmatrix(Uu)*np.transpose(psi_0) 174 | temp = np.asscalar(np.real(psi.getH()*M*psi)) 175 | if temp > gap: 176 | sample_Total[n1][n2][n3] = +1 177 | sample_total_A.append([n1, n2, n3]) 178 | elif temp < -gap: 179 | sample_Total[n1][n2][n3] = -1 180 | sample_total_B.append([n1, n2, n3]) 181 | else: 182 | sample_Total[n1][n2][n3] = 0 183 | sample_total_void.append([n1, n2, n3]) 184 | 185 | # Now sample randomly from sample_Total a number of times training_size+testing_size 186 | tr = 0 187 | while tr < (training_size+test_size): 188 | draw1 = np.random.choice(N) 189 | draw2 = np.random.choice(N) 190 | draw3 = np.random.choice(N) 191 | if sample_Total[draw1][draw2][draw3] == +1: 192 | sampleA[tr] = [2*np.pi*draw1/N, 2*np.pi*draw2/N, 2*np.pi*draw3/N] 193 | tr += 1 194 | 195 | tr = 0 196 | while tr < (training_size+test_size): 197 | draw1 = np.random.choice(N) 198 | draw2 = np.random.choice(N) 199 | draw3 = np.random.choice(N) 200 | if sample_Total[draw1][draw2][draw3] == -1: 201 | sampleB[tr] = [2*np.pi*draw1/N, 2*np.pi*draw2/N, 2*np.pi*draw3/N] 202 | tr += 1 203 | 204 | sample_train = [sampleA, sampleB] 205 | 206 | for lindex in range(training_size+test_size): 207 | label_train[lindex] = 0 208 | for lindex in range(training_size+test_size): 209 | label_train[training_size+test_size+lindex] = 1 210 | label_train = label_train.astype(int) 211 | sample_train = np.reshape(sample_train, (2*(training_size+test_size), n)) 212 | training_input = {key: (sample_train[label_train == k, :])[:training_size] 213 | for k, key in enumerate(class_labels)} 214 | test_input = {key: (sample_train[label_train == k, :])[training_size:( 215 | training_size+test_size)] for k, key in enumerate(class_labels)} 216 | 217 | if plot_data: 218 | 219 | sample_total_A = np.asarray(sample_total_A) 220 | sample_total_B = np.asarray(sample_total_B) 221 | x1 = sample_total_A[:, 0] 222 | y1 = sample_total_A[:, 1] 223 | z1 = sample_total_A[:, 2] 224 | 225 | x2 = sample_total_B[:, 0] 226 | y2 = sample_total_B[:, 1] 227 | z2 = sample_total_B[:, 2] 228 | 229 | fig1 = plt.figure() 230 | ax1 = fig1.add_subplot(1, 1, 1, projection='3d') 231 | ax1.scatter(x1, y1, z1, c='#8A360F') 232 | plt.show() 233 | # 234 | fig2 = plt.figure() 235 | ax2 = fig2.add_subplot(1, 1, 1, projection='3d') 236 | ax2.scatter(x2, y2, z2, c='#683FC8') 237 | plt.show() 238 | 239 | sample_training_A = training_input['A'] 240 | sample_training_B = training_input['B'] 241 | 242 | x1 = sample_training_A[:, 0] 243 | y1 = sample_training_A[:, 1] 244 | z1 = sample_training_A[:, 2] 245 | 246 | x2 = sample_training_B[:, 0] 247 | y2 = sample_training_B[:, 1] 248 | z2 = sample_training_B[:, 2] 249 | 250 | fig1 = plt.figure() 251 | ax1 = fig1.add_subplot(1, 1, 1, projection='3d') 252 | ax1.scatter(x1, y1, z1, c='#8A360F') 253 | ax1.scatter(x2, y2, z2, c='#683FC8') 254 | plt.show() 255 | 256 | return training_input, test_input, class_labels 257 | 258 | 259 | def Wine(training_size, test_size, n, PLOT_DATA): 260 | class_labels = [r'A', r'B', r'C'] 261 | 262 | data, target = datasets.load_wine(True) 263 | sample_train, sample_test, label_train, label_test = train_test_split(data, target, test_size=test_size, random_state=7) 264 | 265 | # Now we standarize for gaussian around 0 with unit variance 266 | std_scale = StandardScaler().fit(sample_train) 267 | sample_train = std_scale.transform(sample_train) 268 | sample_test = std_scale.transform(sample_test) 269 | 270 | # Now reduce number of features to number of qubits 271 | pca = PCA(n_components=n).fit(sample_train) 272 | sample_train = pca.transform(sample_train) 273 | sample_test = pca.transform(sample_test) 274 | 275 | # Scale to the range (-1,+1) 276 | samples = np.append(sample_train, sample_test, axis=0) 277 | minmax_scale = MinMaxScaler((-1, 1)).fit(samples) 278 | sample_train = minmax_scale.transform(sample_train) 279 | sample_test = minmax_scale.transform(sample_test) 280 | # Pick training size number of samples from each distro 281 | training_input = {key: (sample_train[label_train == k, :])[:training_size] for k, key in enumerate(class_labels)} 282 | test_input = {key: (sample_train[label_train == k, :])[training_size:( 283 | training_size+test_size)] for k, key in enumerate(class_labels)} 284 | 285 | if PLOT_DATA: 286 | for k in range(0, 2): 287 | plt.scatter(sample_train[label_train == k, 0][:training_size], 288 | sample_train[label_train == k, 1][:training_size]) 289 | 290 | plt.title("PCA dim. reduced Wine dataset") 291 | plt.show() 292 | 293 | # reduce to 2 classes 294 | training_input.pop(class_labels[-1]) 295 | test_input.pop(class_labels[-1]) 296 | class_labels = class_labels[:2] 297 | return training_input, test_input, class_labels 298 | 299 | -------------------------------------------------------------------------------- /svm/feature_map.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stefan-woerner/qiskit_tutorial/b6cc0a85c4b442facb353eb6aebec0b63464f9be/svm/feature_map.png -------------------------------------------------------------------------------- /svm/variational_form.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stefan-woerner/qiskit_tutorial/b6cc0a85c4b442facb353eb6aebec0b63464f9be/svm/variational_form.png --------------------------------------------------------------------------------