├── .gitignore ├── .python-version ├── LICENSE ├── README.md ├── notebooks ├── 0 - Qubits and gates.ipynb ├── 0.1 - Adiabatic Quantum Computing.ipynb ├── 0.2 - Limits for simulation.ipynb ├── 1 - Quantum embeddings.ipynb ├── 1.1 - Target alignment on quantum kernels.ipynb ├── 2 - Dimensionality reduction.ipynb ├── 2.1 - Dimensionality reduction using NNs.ipynb ├── 2.2 - Hand digit use case.ipynb ├── 3 - Computing derivatives.ipynb ├── 3.1 - Trainable embeddings.ipynb ├── 3.2 - Trainable Kernels and classical models.ipynb ├── 4 - Quantum Neural Networks.ipynb └── visualize.py ├── pyproject.toml ├── requirements-squlearn.txt ├── requirements.txt └── uv.lock /.gitignore: -------------------------------------------------------------------------------- 1 | # Byte-compiled / optimized / DLL files 2 | __pycache__/ 3 | *.py[cod] 4 | *$py.class 5 | 6 | # C extensions 7 | *.so 8 | 9 | # Distribution / packaging 10 | .Python 11 | build/ 12 | develop-eggs/ 13 | dist/ 14 | downloads/ 15 | eggs/ 16 | .eggs/ 17 | lib/ 18 | lib64/ 19 | parts/ 20 | sdist/ 21 | var/ 22 | wheels/ 23 | share/python-wheels/ 24 | *.egg-info/ 25 | .installed.cfg 26 | *.egg 27 | MANIFEST 28 | 29 | # PyInstaller 30 | # Usually these files are written by a python script from a template 31 | # before PyInstaller builds the exe, so as to inject date/other infos into it. 32 | *.manifest 33 | *.spec 34 | 35 | # Installer logs 36 | pip-log.txt 37 | pip-delete-this-directory.txt 38 | 39 | # Unit test / coverage reports 40 | htmlcov/ 41 | .tox/ 42 | .nox/ 43 | .coverage 44 | .coverage.* 45 | .cache 46 | nosetests.xml 47 | coverage.xml 48 | *.cover 49 | *.py,cover 50 | .hypothesis/ 51 | .pytest_cache/ 52 | cover/ 53 | 54 | # Translations 55 | *.mo 56 | *.pot 57 | 58 | # Django stuff: 59 | *.log 60 | local_settings.py 61 | db.sqlite3 62 | db.sqlite3-journal 63 | 64 | # Flask stuff: 65 | instance/ 66 | .webassets-cache 67 | 68 | # Scrapy stuff: 69 | .scrapy 70 | 71 | # Sphinx documentation 72 | docs/_build/ 73 | 74 | # PyBuilder 75 | .pybuilder/ 76 | target/ 77 | 78 | # Jupyter Notebook 79 | .ipynb_checkpoints 80 | 81 | # IPython 82 | profile_default/ 83 | ipython_config.py 84 | 85 | # pyenv 86 | # For a library or package, you might want to ignore these files since the code is 87 | # intended to run in multiple environments; otherwise, check them in: 88 | # .python-version 89 | 90 | # pipenv 91 | # According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control. 92 | # However, in case of collaboration, if having platform-specific dependencies or dependencies 93 | # having no cross-platform support, pipenv may install dependencies that don't work, or not 94 | # install all needed dependencies. 95 | #Pipfile.lock 96 | 97 | # UV 98 | # Similar to Pipfile.lock, it is generally recommended to include uv.lock in version control. 99 | # This is especially recommended for binary packages to ensure reproducibility, and is more 100 | # commonly ignored for libraries. 101 | #uv.lock 102 | 103 | # poetry 104 | # Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control. 105 | # This is especially recommended for binary packages to ensure reproducibility, and is more 106 | # commonly ignored for libraries. 107 | # https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control 108 | #poetry.lock 109 | 110 | # pdm 111 | # Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control. 112 | #pdm.lock 113 | # pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it 114 | # in version control. 115 | # https://pdm.fming.dev/latest/usage/project/#working-with-version-control 116 | .pdm.toml 117 | .pdm-python 118 | .pdm-build/ 119 | 120 | # PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm 121 | __pypackages__/ 122 | 123 | # Celery stuff 124 | celerybeat-schedule 125 | celerybeat.pid 126 | 127 | # SageMath parsed files 128 | *.sage.py 129 | 130 | # Environments 131 | .env 132 | .venv 133 | env/ 134 | venv/ 135 | ENV/ 136 | env.bak/ 137 | venv.bak/ 138 | *venv 139 | 140 | # Spyder project settings 141 | .spyderproject 142 | .spyproject 143 | 144 | # Rope project settings 145 | .ropeproject 146 | 147 | # mkdocs documentation 148 | /site 149 | 150 | # mypy 151 | .mypy_cache/ 152 | .dmypy.json 153 | dmypy.json 154 | 155 | # Pyre type checker 156 | .pyre/ 157 | 158 | # pytype static type analyzer 159 | .pytype/ 160 | 161 | # Cython debug symbols 162 | cython_debug/ 163 | 164 | # PyCharm 165 | # JetBrains specific template is maintained in a separate JetBrains.gitignore that can 166 | # be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore 167 | # and can be added to the global gitignore or merged into this file. For a more nuclear 168 | # option (not recommended) you can uncomment the following to ignore the entire idea folder. 169 | #.idea/ 170 | 171 | # PyPI configuration file 172 | .pypirc 173 | -------------------------------------------------------------------------------- /.python-version: -------------------------------------------------------------------------------- 1 | 3.12 2 | -------------------------------------------------------------------------------- /LICENSE: -------------------------------------------------------------------------------- 1 | MIT License 2 | 3 | Copyright (c) 2025 Iraitz 4 | 5 | Permission is hereby granted, free of charge, to any person obtaining a copy 6 | of this software and associated documentation files (the "Software"), to deal 7 | in the Software without restriction, including without limitation the rights 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 9 | copies of the Software, and to permit persons to whom the Software is 10 | furnished to do so, subject to the following conditions: 11 | 12 | The above copyright notice and this permission notice shall be included in all 13 | copies or substantial portions of the Software. 14 | 15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 21 | SOFTWARE. 22 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # Quickstart 2025 2 | Some code examples for the Quickstart 2025 Winter School on QML. 3 | 4 | Makes sure you create a local virtual environment by suing [uv](https://docs.astral.sh/uv/) or simply installing the _requirements.txt_ file. 5 | 6 | ``` 7 | python3 -m venv .venv 8 | source .venb/bin/activate 9 | (.venv) pip install -r requirements.txt 10 | ``` 11 | 12 | ### sQULearn 13 | 14 | In order to play around with squlearn, due to library incompatibilities, please create a second environment using the _requirements-squlearn.txt_ file. 15 | 16 | ## Outline 17 | 18 | Under the [notebooks](./notebooks/) folder, you will find a set of notebooks and some exercises to master some basic concepts in order to master the field. 19 | 20 | * _Section 0_: [Basic stuff](./notebooks/0%20-%20Qubits%20and%20gates.ipynb) around qubits and gates so that you can practice simulating using pure Numpy, specialized software like QuTip or Qiskit (among others). Also, a 101 on [Adiabatic Quantum Computing](./notebooks/0.1%20-%20Adiabatic%20Quantum%20Computing.ipynb). 21 | * _Section 1_: We should understand that working with classical data requires some transformations. Going down the [Quantum Embeddings](./notebooks/1%20-%20Quantum%20embeddings.ipynb) and how to evaluate their fitness to the task at hand with metrics such as [Target Alignment](./notebooks/1.1%20-%20Target%20alignment%20on%20quantum%20kernels.ipynb). 22 | * _Section 2_: On [dimensionality reduction](./notebooks/2%20-%20Dimensionality%20reduction.ipynb) and how to squeeze all the information that is available into a set of qubits we can easily simulate using our devices. 23 | * _Section 3_: Understanding [trainable embeddings](./notebooks/3.1%20-%20Trainable%20embeddings.ipynb) and how these can be used to improve hybrid (quantum and classical) models like [QSVMs](./notebooks/3.2%20-%20Trainable%20Kernels%20and%20classical%20models.ipynb). 24 | * _Section 4_: Pure quantum approaches like [Quantum Neural Networks](./notebooks/4%20-%20Quantum%20Neural%20Networks.ipynb). -------------------------------------------------------------------------------- /notebooks/0.1 - Adiabatic Quantum Computing.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "attachments": {}, 5 | "cell_type": "markdown", 6 | "metadata": {}, 7 | "source": [ 8 | "# Adiabatic Quantum Computing\n", 9 | "\n", 10 | "We will make a simple example so that the formalism of this algorithm is clear to everyone.\n", 11 | "\n", 12 | "We will need for this exercise:\n", 13 | "\n", 14 | "* An Initial Hamiltonian and its ground state (so it should be easy or known)\n", 15 | "* A final Hamiltonian (the problem we are trying to solve)\n", 16 | "* A Scheduling function that governs the evolution and mixture between the two\n", 17 | "\n", 18 | "So let's start by selecting our Initial Hamiltonian:\n", 19 | "\n", 20 | "$$\n", 21 | "\n", 22 | "H_{init} = - \\sum_i^N \\sigma_i^x\n", 23 | "\n", 24 | "$$" 25 | ] 26 | }, 27 | { 28 | "cell_type": "code", 29 | "execution_count": 1, 30 | "metadata": {}, 31 | "outputs": [], 32 | "source": [ 33 | "N = 3 # 3 qubit system" 34 | ] 35 | }, 36 | { 37 | "cell_type": "code", 38 | "execution_count": 2, 39 | "metadata": {}, 40 | "outputs": [ 41 | { 42 | "data": { 43 | "text/plain": [ 44 | "matrix([[ 0., -1., -1., 0., -1., 0., 0., 0.],\n", 45 | " [-1., 0., 0., -1., 0., -1., 0., 0.],\n", 46 | " [-1., 0., 0., -1., 0., 0., -1., 0.],\n", 47 | " [ 0., -1., -1., 0., 0., 0., 0., -1.],\n", 48 | " [-1., 0., 0., 0., 0., -1., -1., 0.],\n", 49 | " [ 0., -1., 0., 0., -1., 0., 0., -1.],\n", 50 | " [ 0., 0., -1., 0., -1., 0., 0., -1.],\n", 51 | " [ 0., 0., 0., -1., 0., -1., -1., 0.]])" 52 | ] 53 | }, 54 | "execution_count": 2, 55 | "metadata": {}, 56 | "output_type": "execute_result" 57 | } 58 | ], 59 | "source": [ 60 | "import numpy as np\n", 61 | "\n", 62 | "# \\sigma_x\n", 63 | "sigma_x = np.matrix([[0, 1],\n", 64 | " [1, 0]])\n", 65 | "\n", 66 | "# Initial hamiltonian\n", 67 | "H_init = 0\n", 68 | "for j in range(N):\n", 69 | " H_init += -1.0 * np.kron( np.kron(np.identity(2**j), sigma_x), np.identity(2**(N-j-1)) )\n", 70 | "\n", 71 | "H_init" 72 | ] 73 | }, 74 | { 75 | "cell_type": "code", 76 | "execution_count": 3, 77 | "metadata": {}, 78 | "outputs": [], 79 | "source": [ 80 | "from math import sqrt\n", 81 | "from numpy.linalg import eig\n", 82 | "\n", 83 | "# Get eigen spectrum for a particular hamiltonian\n", 84 | "def get_eigenspectra(h_mat):\n", 85 | " \"\"\"\n", 86 | " Computes the eigenspectra\n", 87 | " \"\"\"\n", 88 | " evals, evecs = eig(h_mat)\n", 89 | " sort_index = np.argsort(evals)\n", 90 | "\n", 91 | " return evals [sort_index], evecs[:, sort_index]\n", 92 | "\n", 93 | "# Gets the ground state\n", 94 | "def get_gs(h_mat):\n", 95 | " \"\"\" Computes the ground state \"\"\"\n", 96 | " evals, evecs = eig(h_mat)\n", 97 | " sort_index = np.argsort(evals)\n", 98 | "\n", 99 | " stat_gs = evecs[:, sort_index[0]]\n", 100 | " gs_val = evals[sort_index[0]]\n", 101 | " \n", 102 | " num = 1\n", 103 | " for idx in sort_index[1:]:\n", 104 | " if evals[idx] == gs_val:\n", 105 | " stat_gs += evecs[:, idx]\n", 106 | " num += 1\n", 107 | " else:\n", 108 | " break\n", 109 | "\n", 110 | " return np.dot((1/sqrt(num)), stat_gs)\n" 111 | ] 112 | }, 113 | { 114 | "cell_type": "code", 115 | "execution_count": 4, 116 | "metadata": {}, 117 | "outputs": [ 118 | { 119 | "data": { 120 | "text/plain": [ 121 | "matrix([[-0.35355339],\n", 122 | " [-0.35355339],\n", 123 | " [-0.35355339],\n", 124 | " [-0.35355339],\n", 125 | " [-0.35355339],\n", 126 | " [-0.35355339],\n", 127 | " [-0.35355339],\n", 128 | " [-0.35355339]])" 129 | ] 130 | }, 131 | "execution_count": 4, 132 | "metadata": {}, 133 | "output_type": "execute_result" 134 | } 135 | ], 136 | "source": [ 137 | "get_gs(H_init)" 138 | ] 139 | }, 140 | { 141 | "attachments": {}, 142 | "cell_type": "markdown", 143 | "metadata": {}, 144 | "source": [ 145 | "Now for our target Hamiltonian we will select a random instance of the Ising model that looks like:\n", 146 | "\n", 147 | "$$\n", 148 | "\n", 149 | "H_{problem} = \\sum_j^N J_{j,j+1}\\sigma_j^z\\sigma_{j+1}^z \n", 150 | "\n", 151 | "$$" 152 | ] 153 | }, 154 | { 155 | "cell_type": "code", 156 | "execution_count": 5, 157 | "metadata": {}, 158 | "outputs": [ 159 | { 160 | "data": { 161 | "text/plain": [ 162 | "matrix([[-1., 0., 0., 0., 0., 0., 0., 0.],\n", 163 | " [ 0., 1., 0., 0., 0., 0., 0., 0.],\n", 164 | " [ 0., 0., 1., 0., 0., 0., 0., 0.],\n", 165 | " [ 0., 0., 0., -1., 0., 0., 0., 0.],\n", 166 | " [ 0., 0., 0., 0., -1., 0., 0., 0.],\n", 167 | " [ 0., 0., 0., 0., 0., 1., 0., 0.],\n", 168 | " [ 0., 0., 0., 0., 0., 0., 1., 0.],\n", 169 | " [ 0., 0., 0., 0., 0., 0., 0., -1.]])" 170 | ] 171 | }, 172 | "execution_count": 5, 173 | "metadata": {}, 174 | "output_type": "execute_result" 175 | } 176 | ], 177 | "source": [ 178 | "J = -1\n", 179 | "\n", 180 | "sigma_z = np.matrix([[1, 0],\n", 181 | " [0, -1]])\n", 182 | "\n", 183 | "H_problem = 0\n", 184 | "for i in range(N-1):\n", 185 | " H_problem = J* np.kron( np.kron(np.identity(2**i), sigma_z), np.identity(2**(N-i-1)) ) * np.kron( np.kron(np.identity(2**(i+1)), sigma_z), np.identity(2**(N-(i+1)-1)) )\n", 186 | "\n", 187 | "H_problem" 188 | ] 189 | }, 190 | { 191 | "cell_type": "code", 192 | "execution_count": 6, 193 | "metadata": {}, 194 | "outputs": [ 195 | { 196 | "data": { 197 | "text/plain": [ 198 | "matrix([[0.5],\n", 199 | " [0. ],\n", 200 | " [0. ],\n", 201 | " [0.5],\n", 202 | " [0.5],\n", 203 | " [0. ],\n", 204 | " [0. ],\n", 205 | " [0.5]])" 206 | ] 207 | }, 208 | "execution_count": 6, 209 | "metadata": {}, 210 | "output_type": "execute_result" 211 | } 212 | ], 213 | "source": [ 214 | "get_gs(H_problem)" 215 | ] 216 | }, 217 | { 218 | "attachments": {}, 219 | "cell_type": "markdown", 220 | "metadata": {}, 221 | "source": [ 222 | "We can see our Ising model's ground ground state (minimum energy eigenstate) is\n", 223 | "\n", 224 | "$$\n", 225 | "\n", 226 | "|\\psi\\rangle = \\frac{1}{2}(|000\\rangle + |011\\rangle + |100\\rangle + |111\\rangle).\n", 227 | "\n", 228 | "$$\n", 229 | "\n", 230 | "Now we would only need to define a scheduling function to mix both Hamiltonians. Just for simplicity we will use a single scheduling function $\\lambda(t)$ and use its complementary for the decaying of the initial Hamiltonian.\n", 231 | "\n", 232 | "$$\n", 233 | "\n", 234 | "H(t) = (1-\\lambda(t))H_{init} + \\lambda(t)H_{problem}\n", 235 | "\n", 236 | "$$\n", 237 | "\n" 238 | ] 239 | }, 240 | { 241 | "cell_type": "code", 242 | "execution_count": 7, 243 | "metadata": {}, 244 | "outputs": [], 245 | "source": [ 246 | "e0 = []\n", 247 | "e1 = []\n", 248 | "\n", 249 | "# Now perform a mixing schedule\n", 250 | "time_range = np.arange(0.0, 1.0, 0.1)\n", 251 | "for lambda_t in time_range:\n", 252 | "\n", 253 | " # Time dependent Hamiltonian\n", 254 | " H = (1-lambda_t)*H_init + lambda_t*H_problem\n", 255 | "\n", 256 | " # Get eigenspectra\n", 257 | " vals, stats = get_eigenspectra(H)\n", 258 | " e0.append(vals[0])\n", 259 | " e1.append(vals[1])" 260 | ] 261 | }, 262 | { 263 | "cell_type": "code", 264 | "execution_count": 8, 265 | "metadata": {}, 266 | "outputs": [ 267 | { 268 | "data": { 269 | "image/png": "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", 270 | "text/plain": [ 271 | "
" 272 | ] 273 | }, 274 | "metadata": {}, 275 | "output_type": "display_data" 276 | } 277 | ], 278 | "source": [ 279 | "import matplotlib.pyplot as plt\n", 280 | "\n", 281 | "plt.plot(time_range, e0, time_range, e1)\n", 282 | "plt.show()" 283 | ] 284 | }, 285 | { 286 | "cell_type": "code", 287 | "execution_count": 9, 288 | "metadata": {}, 289 | "outputs": [ 290 | { 291 | "data": { 292 | "image/png": "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", 293 | "text/plain": [ 294 | "
" 295 | ] 296 | }, 297 | "metadata": {}, 298 | "output_type": "display_data" 299 | } 300 | ], 301 | "source": [ 302 | "plt.plot(np.subtract(e1,e0))\n", 303 | "plt.show()" 304 | ] 305 | }, 306 | { 307 | "cell_type": "code", 308 | "execution_count": 10, 309 | "metadata": {}, 310 | "outputs": [ 311 | { 312 | "data": { 313 | "text/plain": [ 314 | "matrix([[0.49701447],\n", 315 | " [0.05455839],\n", 316 | " [0.05455839],\n", 317 | " [0.49701447],\n", 318 | " [0.49701447],\n", 319 | " [0.05455839],\n", 320 | " [0.05455839],\n", 321 | " [0.49701447]])" 322 | ] 323 | }, 324 | "execution_count": 10, 325 | "metadata": {}, 326 | "output_type": "execute_result" 327 | } 328 | ], 329 | "source": [ 330 | "stats[:, 0]" 331 | ] 332 | }, 333 | { 334 | "cell_type": "markdown", 335 | "metadata": {}, 336 | "source": [ 337 | "Once again, we don't need to do everything from scratch. Libraries like Qutip allow us to benefit from the existing work." 338 | ] 339 | }, 340 | { 341 | "attachments": {}, 342 | "cell_type": "markdown", 343 | "metadata": {}, 344 | "source": [ 345 | "# Qutip" 346 | ] 347 | }, 348 | { 349 | "cell_type": "code", 350 | "execution_count": 11, 351 | "metadata": {}, 352 | "outputs": [], 353 | "source": [ 354 | "from qutip import qeye, sigmaz, sigmax, tensor\n", 355 | "\n", 356 | "# Create a particular instance\n", 357 | "J = -1\n", 358 | "\n", 359 | "# Matrices to compose the hamiltonian\n", 360 | "i = qeye(2)\n", 361 | "z = sigmaz()\n", 362 | "\n", 363 | "# Ising model\n", 364 | "h_ising = J * tensor(i,z,z)\n", 365 | "\n", 366 | "# Init state\n", 367 | "x = sigmax()\n", 368 | "h_b = -1 * tensor(x,i,i) + -1 * tensor(i,i,x) + -1 * tensor(i,x,i)" 369 | ] 370 | }, 371 | { 372 | "cell_type": "code", 373 | "execution_count": 12, 374 | "metadata": {}, 375 | "outputs": [ 376 | { 377 | "data": { 378 | "text/latex": [ 379 | "Quantum object: dims=[[2, 2, 2], [2, 2, 2]], shape=(8, 8), type='oper', dtype=CSR, isherm=True$$\\left(\\begin{array}{cc}0 & -1 & -1 & 0 & -1 & 0 & 0 & 0\\\\-1 & 0 & 0 & -1 & 0 & -1 & 0 & 0\\\\-1 & 0 & 0 & -1 & 0 & 0 & -1 & 0\\\\0 & -1 & -1 & 0 & 0 & 0 & 0 & -1\\\\-1 & 0 & 0 & 0 & 0 & -1 & -1 & 0\\\\0 & -1 & 0 & 0 & -1 & 0 & 0 & -1\\\\0 & 0 & -1 & 0 & -1 & 0 & 0 & -1\\\\0 & 0 & 0 & -1 & 0 & -1 & -1 & 0\\end{array}\\right)$$" 380 | ], 381 | "text/plain": [ 382 | "Quantum object: dims=[[2, 2, 2], [2, 2, 2]], shape=(8, 8), type='oper', dtype=CSR, isherm=True\n", 383 | "Qobj data =\n", 384 | "[[ 0. -1. -1. 0. -1. 0. 0. 0.]\n", 385 | " [-1. 0. 0. -1. 0. -1. 0. 0.]\n", 386 | " [-1. 0. 0. -1. 0. 0. -1. 0.]\n", 387 | " [ 0. -1. -1. 0. 0. 0. 0. -1.]\n", 388 | " [-1. 0. 0. 0. 0. -1. -1. 0.]\n", 389 | " [ 0. -1. 0. 0. -1. 0. 0. -1.]\n", 390 | " [ 0. 0. -1. 0. -1. 0. 0. -1.]\n", 391 | " [ 0. 0. 0. -1. 0. -1. -1. 0.]]" 392 | ] 393 | }, 394 | "execution_count": 12, 395 | "metadata": {}, 396 | "output_type": "execute_result" 397 | } 398 | ], 399 | "source": [ 400 | "h_b" 401 | ] 402 | }, 403 | { 404 | "cell_type": "code", 405 | "execution_count": 13, 406 | "metadata": {}, 407 | "outputs": [ 408 | { 409 | "data": { 410 | "text/latex": [ 411 | "Quantum object: dims=[[2, 2, 2], [2, 2, 2]], shape=(8, 8), type='oper', dtype=CSR, isherm=True$$\\left(\\begin{array}{cc}-1 & 0 & 0 & 0 & 0 & 0 & 0 & 0\\\\0 & 1 & 0 & 0 & 0 & 0 & 0 & 0\\\\0 & 0 & 1 & 0 & 0 & 0 & 0 & 0\\\\0 & 0 & 0 & -1 & 0 & 0 & 0 & 0\\\\0 & 0 & 0 & 0 & -1 & 0 & 0 & 0\\\\0 & 0 & 0 & 0 & 0 & 1 & 0 & 0\\\\0 & 0 & 0 & 0 & 0 & 0 & 1 & 0\\\\0 & 0 & 0 & 0 & 0 & 0 & 0 & -1\\end{array}\\right)$$" 412 | ], 413 | "text/plain": [ 414 | "Quantum object: dims=[[2, 2, 2], [2, 2, 2]], shape=(8, 8), type='oper', dtype=CSR, isherm=True\n", 415 | "Qobj data =\n", 416 | "[[-1. 0. 0. 0. 0. 0. 0. 0.]\n", 417 | " [ 0. 1. 0. 0. 0. 0. 0. 0.]\n", 418 | " [ 0. 0. 1. 0. 0. 0. 0. 0.]\n", 419 | " [ 0. 0. 0. -1. 0. 0. 0. 0.]\n", 420 | " [ 0. 0. 0. 0. -1. 0. 0. 0.]\n", 421 | " [ 0. 0. 0. 0. 0. 1. 0. 0.]\n", 422 | " [ 0. 0. 0. 0. 0. 0. 1. 0.]\n", 423 | " [ 0. 0. 0. 0. 0. 0. 0. -1.]]" 424 | ] 425 | }, 426 | "execution_count": 13, 427 | "metadata": {}, 428 | "output_type": "execute_result" 429 | } 430 | ], 431 | "source": [ 432 | "h_ising" 433 | ] 434 | }, 435 | { 436 | "cell_type": "code", 437 | "execution_count": 14, 438 | "metadata": {}, 439 | "outputs": [], 440 | "source": [ 441 | "from qutip import QobjEvo\n", 442 | "\n", 443 | "def schedule(t, taumax):\n", 444 | " \"\"\"\n", 445 | " Scheduling function for the adiabatic evolution\n", 446 | " \"\"\"\n", 447 | "\n", 448 | " return t/taumax\n", 449 | "\n", 450 | "# Tau max\n", 451 | "taumax = 5.0\n", 452 | "\n", 453 | "# The time dependent function\n", 454 | "h_t = QobjEvo([[h_b, lambda t: 1 - schedule(t, taumax)],\n", 455 | " [h_ising, lambda t: schedule(t, taumax)]])" 456 | ] 457 | }, 458 | { 459 | "cell_type": "code", 460 | "execution_count": 15, 461 | "metadata": {}, 462 | "outputs": [ 463 | { 464 | "data": { 465 | "text/latex": [ 466 | "Quantum object: dims=[[2, 2, 2], [2, 2, 2]], shape=(8, 8), type='oper', dtype=CSR, isherm=True$$\\left(\\begin{array}{cc}-0.200 & -0.800 & -0.800 & 0 & -0.800 & 0 & 0 & 0\\\\-0.800 & 0.200 & 0 & -0.800 & 0 & -0.800 & 0 & 0\\\\-0.800 & 0 & 0.200 & -0.800 & 0 & 0 & -0.800 & 0\\\\0 & -0.800 & -0.800 & -0.200 & 0 & 0 & 0 & -0.800\\\\-0.800 & 0 & 0 & 0 & -0.200 & -0.800 & -0.800 & 0\\\\0 & -0.800 & 0 & 0 & -0.800 & 0.200 & 0 & -0.800\\\\0 & 0 & -0.800 & 0 & -0.800 & 0 & 0.200 & -0.800\\\\0 & 0 & 0 & -0.800 & 0 & -0.800 & -0.800 & -0.200\\end{array}\\right)$$" 467 | ], 468 | "text/plain": [ 469 | "Quantum object: dims=[[2, 2, 2], [2, 2, 2]], shape=(8, 8), type='oper', dtype=CSR, isherm=True\n", 470 | "Qobj data =\n", 471 | "[[-0.2 -0.8 -0.8 0. -0.8 0. 0. 0. ]\n", 472 | " [-0.8 0.2 0. -0.8 0. -0.8 0. 0. ]\n", 473 | " [-0.8 0. 0.2 -0.8 0. 0. -0.8 0. ]\n", 474 | " [ 0. -0.8 -0.8 -0.2 0. 0. 0. -0.8]\n", 475 | " [-0.8 0. 0. 0. -0.2 -0.8 -0.8 0. ]\n", 476 | " [ 0. -0.8 0. 0. -0.8 0.2 0. -0.8]\n", 477 | " [ 0. 0. -0.8 0. -0.8 0. 0.2 -0.8]\n", 478 | " [ 0. 0. 0. -0.8 0. -0.8 -0.8 -0.2]]" 479 | ] 480 | }, 481 | "execution_count": 15, 482 | "metadata": {}, 483 | "output_type": "execute_result" 484 | } 485 | ], 486 | "source": [ 487 | "h_t(1.0)" 488 | ] 489 | }, 490 | { 491 | "cell_type": "code", 492 | "execution_count": 16, 493 | "metadata": {}, 494 | "outputs": [ 495 | { 496 | "data": { 497 | "text/plain": [ 498 | "array([-3., -1., -1., -1., 1., 1., 1., 3.])" 499 | ] 500 | }, 501 | "execution_count": 16, 502 | "metadata": {}, 503 | "output_type": "execute_result" 504 | } 505 | ], 506 | "source": [ 507 | "eigvals, eigstates = h_t(0).eigenstates()\n", 508 | "eigvals" 509 | ] 510 | }, 511 | { 512 | "cell_type": "code", 513 | "execution_count": 17, 514 | "metadata": {}, 515 | "outputs": [ 516 | { 517 | "data": { 518 | "text/latex": [ 519 | "Quantum object: dims=[[2, 2, 2], [1, 1, 1]], shape=(8, 1), type='ket', dtype=Dense$$\\left(\\begin{array}{cc}-0.354\\\\-0.354\\\\-0.354\\\\-0.354\\\\-0.354\\\\-0.354\\\\-0.354\\\\-0.354\\end{array}\\right)$$" 520 | ], 521 | "text/plain": [ 522 | "Quantum object: dims=[[2, 2, 2], [1, 1, 1]], shape=(8, 1), type='ket', dtype=Dense\n", 523 | "Qobj data =\n", 524 | "[[-0.35355339]\n", 525 | " [-0.35355339]\n", 526 | " [-0.35355339]\n", 527 | " [-0.35355339]\n", 528 | " [-0.35355339]\n", 529 | " [-0.35355339]\n", 530 | " [-0.35355339]\n", 531 | " [-0.35355339]]" 532 | ] 533 | }, 534 | "execution_count": 17, 535 | "metadata": {}, 536 | "output_type": "execute_result" 537 | } 538 | ], 539 | "source": [ 540 | "psi0 = eigstates[0]\n", 541 | "psi0" 542 | ] 543 | }, 544 | { 545 | "cell_type": "code", 546 | "execution_count": 18, 547 | "metadata": {}, 548 | "outputs": [ 549 | { 550 | "data": { 551 | "text/latex": [ 552 | "Quantum object: dims=[[2, 2, 2], [2, 2, 2]], shape=(8, 8), type='oper', dtype=CSR, isherm=True$$\\left(\\begin{array}{cc}-1 & 0 & 0 & 0 & 0 & 0 & 0 & 0\\\\0 & 1 & 0 & 0 & 0 & 0 & 0 & 0\\\\0 & 0 & 1 & 0 & 0 & 0 & 0 & 0\\\\0 & 0 & 0 & -1 & 0 & 0 & 0 & 0\\\\0 & 0 & 0 & 0 & -1 & 0 & 0 & 0\\\\0 & 0 & 0 & 0 & 0 & 1 & 0 & 0\\\\0 & 0 & 0 & 0 & 0 & 0 & 1 & 0\\\\0 & 0 & 0 & 0 & 0 & 0 & 0 & -1\\end{array}\\right)$$" 553 | ], 554 | "text/plain": [ 555 | "Quantum object: dims=[[2, 2, 2], [2, 2, 2]], shape=(8, 8), type='oper', dtype=CSR, isherm=True\n", 556 | "Qobj data =\n", 557 | "[[-1. 0. 0. 0. 0. 0. 0. 0.]\n", 558 | " [ 0. 1. 0. 0. 0. 0. 0. 0.]\n", 559 | " [ 0. 0. 1. 0. 0. 0. 0. 0.]\n", 560 | " [ 0. 0. 0. -1. 0. 0. 0. 0.]\n", 561 | " [ 0. 0. 0. 0. -1. 0. 0. 0.]\n", 562 | " [ 0. 0. 0. 0. 0. 1. 0. 0.]\n", 563 | " [ 0. 0. 0. 0. 0. 0. 1. 0.]\n", 564 | " [ 0. 0. 0. 0. 0. 0. 0. -1.]]" 565 | ] 566 | }, 567 | "execution_count": 18, 568 | "metadata": {}, 569 | "output_type": "execute_result" 570 | } 571 | ], 572 | "source": [ 573 | "h_t(taumax)" 574 | ] 575 | }, 576 | { 577 | "cell_type": "code", 578 | "execution_count": 19, 579 | "metadata": {}, 580 | "outputs": [ 581 | { 582 | "name": "stdout", 583 | "output_type": "stream", 584 | "text": [ 585 | "[-1. -1. -1. -1. 1. 1. 1. 1.]\n" 586 | ] 587 | } 588 | ], 589 | "source": [ 590 | "eigvals, eigstates = h_t(taumax).eigenstates()\n", 591 | "print(eigvals)" 592 | ] 593 | }, 594 | { 595 | "cell_type": "code", 596 | "execution_count": 20, 597 | "metadata": {}, 598 | "outputs": [ 599 | { 600 | "data": { 601 | "text/latex": [ 602 | "Quantum object: dims=[[2, 2, 2], [1, 1, 1]], shape=(8, 1), type='ket', dtype=Dense$$\\left(\\begin{array}{cc}0.500\\\\0\\\\0\\\\0.500\\\\0.500\\\\0\\\\0\\\\0.500\\end{array}\\right)$$" 603 | ], 604 | "text/plain": [ 605 | "Quantum object: dims=[[2, 2, 2], [1, 1, 1]], shape=(8, 1), type='ket', dtype=Dense\n", 606 | "Qobj data =\n", 607 | "[[0.5]\n", 608 | " [0. ]\n", 609 | " [0. ]\n", 610 | " [0.5]\n", 611 | " [0.5]\n", 612 | " [0. ]\n", 613 | " [0. ]\n", 614 | " [0.5]]" 615 | ] 616 | }, 617 | "execution_count": 20, 618 | "metadata": {}, 619 | "output_type": "execute_result" 620 | } 621 | ], 622 | "source": [ 623 | "0.5*(eigstates[0] + eigstates[1] + eigstates[2] + eigstates[3])" 624 | ] 625 | }, 626 | { 627 | "cell_type": "code", 628 | "execution_count": 21, 629 | "metadata": {}, 630 | "outputs": [], 631 | "source": [ 632 | "from qutip import mesolve\n", 633 | "\n", 634 | "taulist = np.linspace(0, taumax, 100)\n", 635 | "\n", 636 | "evals_mat = np.zeros((len(taulist), 2**N))\n", 637 | "idx = [0]\n", 638 | "min_gap = [+np.inf]\n", 639 | "\n", 640 | "def process_rho(tau, psi):\n", 641 | " \"\"\"Process in between to\n", 642 | " obtain the eigenvalues\n", 643 | "\n", 644 | " Args:\n", 645 | " tau (float): Time step\n", 646 | " psi (Qobj): Psi\n", 647 | " \"\"\"\n", 648 | " evals, _ = h_t(tau).eigenstates()\n", 649 | " evals_mat[idx[0],:] = np.real(evals)\n", 650 | " \n", 651 | " idx[0] += 1\n", 652 | " min_gap[0] = min(min_gap[0], evals[1]-evals[0])\n", 653 | "\n", 654 | "# Solve the master equation\n", 655 | "result = mesolve(h_t, psi0, taulist, c_ops=[], e_ops=process_rho, options={\"store_states\" : True})" 656 | ] 657 | }, 658 | { 659 | "cell_type": "code", 660 | "execution_count": 22, 661 | "metadata": {}, 662 | "outputs": [ 663 | { 664 | "data": { 665 | "text/latex": [ 666 | "Quantum object: dims=[[2, 2, 2], [1, 1, 1]], shape=(8, 1), type='ket', dtype=Dense$$\\left(\\begin{array}{cc}(0.403-0.288j)\\\\(-0.060-0.039j)\\\\(-0.060-0.039j)\\\\(0.403-0.288j)\\\\(0.403-0.288j)\\\\(-0.060-0.039j)\\\\(-0.060-0.039j)\\\\(0.403-0.288j)\\end{array}\\right)$$" 667 | ], 668 | "text/plain": [ 669 | "Quantum object: dims=[[2, 2, 2], [1, 1, 1]], shape=(8, 1), type='ket', dtype=Dense\n", 670 | "Qobj data =\n", 671 | "[[ 0.4026931 -0.28765221j]\n", 672 | " [-0.05965692-0.03918574j]\n", 673 | " [-0.05965692-0.03918574j]\n", 674 | " [ 0.4026931 -0.28765221j]\n", 675 | " [ 0.4026931 -0.28765221j]\n", 676 | " [-0.05965692-0.03918574j]\n", 677 | " [-0.05965692-0.03918574j]\n", 678 | " [ 0.4026931 -0.28765221j]]" 679 | ] 680 | }, 681 | "execution_count": 22, 682 | "metadata": {}, 683 | "output_type": "execute_result" 684 | } 685 | ], 686 | "source": [ 687 | "result.final_state" 688 | ] 689 | }, 690 | { 691 | "cell_type": "code", 692 | "execution_count": 23, 693 | "metadata": {}, 694 | "outputs": [ 695 | { 696 | "data": { 697 | "image/png": "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", 698 | "text/plain": [ 699 | "
" 700 | ] 701 | }, 702 | "metadata": {}, 703 | "output_type": "display_data" 704 | }, 705 | { 706 | "name": "stdout", 707 | "output_type": "stream", 708 | "text": [ 709 | "Found minimum gap: 0.0\n" 710 | ] 711 | } 712 | ], 713 | "source": [ 714 | "# Plot results\n", 715 | "plt.plot(evals_mat)\n", 716 | "plt.title('Energy gap evolution')\n", 717 | "plt.show()\n", 718 | "\n", 719 | "print(f\"Found minimum gap: {min_gap[0]}\")" 720 | ] 721 | }, 722 | { 723 | "cell_type": "markdown", 724 | "metadata": {}, 725 | "source": [ 726 | "## Exercise\n", 727 | "\n", 728 | "Can you think of a better scheduling function?" 729 | ] 730 | }, 731 | { 732 | "cell_type": "code", 733 | "execution_count": null, 734 | "metadata": {}, 735 | "outputs": [], 736 | "source": [ 737 | "# Your code goes here" 738 | ] 739 | } 740 | ], 741 | "metadata": { 742 | "kernelspec": { 743 | "display_name": ".venv", 744 | "language": "python", 745 | "name": "python3" 746 | }, 747 | "language_info": { 748 | "codemirror_mode": { 749 | "name": "ipython", 750 | "version": 3 751 | }, 752 | "file_extension": ".py", 753 | "mimetype": "text/x-python", 754 | "name": "python", 755 | "nbconvert_exporter": "python", 756 | "pygments_lexer": "ipython3", 757 | "version": "3.12.7" 758 | }, 759 | "orig_nbformat": 4 760 | }, 761 | "nbformat": 4, 762 | "nbformat_minor": 2 763 | } 764 | -------------------------------------------------------------------------------- /notebooks/3 - Computing derivatives.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "# Derivatives\n", 8 | "\n", 9 | "In order to fit the ideal set of parameters minimizing a cost or loss function, gradient based approaches are quite popular as being aware of the direction in which this cost function is minimized it may shorten the time required for the method to find it target.\n", 10 | "\n", 11 | "Quantum circuits have a similar capacity, we can free up the parameters of a given circuit and optimize based on a cost function which in most cases can be represented by the expectation value over some observable. For this, we would need to understand how these derivatives can be computed... at scale." 12 | ] 13 | }, 14 | { 15 | "cell_type": "code", 16 | "execution_count": 1, 17 | "metadata": {}, 18 | "outputs": [ 19 | { 20 | "data": { 21 | "text/html": [ 22 | "
   ┌───────┐\n",
 23 |        "q: ┤ Ry(a) ├\n",
 24 |        "   └───────┘
" 25 | ], 26 | "text/plain": [ 27 | " ┌───────┐\n", 28 | "q: ┤ Ry(a) ├\n", 29 | " └───────┘" 30 | ] 31 | }, 32 | "execution_count": 1, 33 | "metadata": {}, 34 | "output_type": "execute_result" 35 | } 36 | ], 37 | "source": [ 38 | "from qiskit import QuantumCircuit\n", 39 | "from qiskit.circuit import Parameter\n", 40 | "\n", 41 | "a = Parameter('a')\n", 42 | "\n", 43 | "qc = QuantumCircuit(1)\n", 44 | "qc.ry(a, 0)\n", 45 | "qc.draw()" 46 | ] 47 | }, 48 | { 49 | "cell_type": "markdown", 50 | "metadata": {}, 51 | "source": [ 52 | "This is a simple rotation over the Y axis of the bloch sphere. So we know that if we measure the observable X of a given state produced by this rotation we get:\n", 53 | "\n", 54 | "$$\n", 55 | "\n", 56 | "\\langle Y(a) | X | Y(a) \\rangle = \\sin(\\pi a)\n", 57 | "\n", 58 | "$$" 59 | ] 60 | }, 61 | { 62 | "cell_type": "code", 63 | "execution_count": 2, 64 | "metadata": {}, 65 | "outputs": [ 66 | { 67 | "name": "stdout", 68 | "output_type": "stream", 69 | "text": [ 70 | "Statevector([0.89100652+0.j, 0.4539905 +0.j],\n", 71 | " dims=(2,))\n" 72 | ] 73 | } 74 | ], 75 | "source": [ 76 | "import numpy as np\n", 77 | "from qiskit.quantum_info import Statevector\n", 78 | " \n", 79 | "init = QuantumCircuit(1)\n", 80 | "state = Statevector(init)\n", 81 | "\n", 82 | "val = 0.3\n", 83 | "circ = qc.assign_parameters({a : np.pi*0.3})\n", 84 | "eval = state.evolve(circ)\n", 85 | "print(eval)" 86 | ] 87 | }, 88 | { 89 | "cell_type": "code", 90 | "execution_count": 3, 91 | "metadata": {}, 92 | "outputs": [ 93 | { 94 | "name": "stdout", 95 | "output_type": "stream", 96 | "text": [ 97 | " : 0.8090169943749473\n", 98 | "Sin function: 0.8090169943749475\n" 99 | ] 100 | } 101 | ], 102 | "source": [ 103 | "from qiskit.quantum_info import Pauli\n", 104 | "\n", 105 | "# Target hamiltonian\n", 106 | "op = Pauli('X')\n", 107 | "\n", 108 | "print(f\" : {eval.expectation_value(oper=op)}\")\n", 109 | "print(f\"Sin function: {np.sin(np.pi * val)}\")" 110 | ] 111 | }, 112 | { 113 | "cell_type": "markdown", 114 | "metadata": {}, 115 | "source": [ 116 | "Then we know we could calculate its derivative as $\\pi\\cos(\\pi a)$. This may not be an option for when we go to hardware and we make the circuit much more complicated in terms of gates (in particular multiqubit gates). Enter numerical resolution of derivatives!\n", 117 | "\n", 118 | "We can produce an approximation to our target by leveraging finite differences for numerical approximation, taking into consideration the limit:\n", 119 | "\n", 120 | "$$\n", 121 | "\n", 122 | "f^{'}(a) = \\lim_{h \\rightarrow 0} \\frac{f(a + h) - f(a)}{h}\n", 123 | "\n", 124 | "$$\n", 125 | "\n", 126 | "which essentially only requires two evaluations of our function." 127 | ] 128 | }, 129 | { 130 | "cell_type": "code", 131 | "execution_count": 4, 132 | "metadata": {}, 133 | "outputs": [ 134 | { 135 | "name": "stdout", 136 | "output_type": "stream", 137 | "text": [ 138 | "Finite difference: 1.8425864574260764\n", 139 | "Cosine formula: 1.8465818304904567\n" 140 | ] 141 | } 142 | ], 143 | "source": [ 144 | "state = Statevector(init)\n", 145 | "\n", 146 | "val = 0.3\n", 147 | "h = 0.001\n", 148 | "\n", 149 | "# Get the expectation value for f(x)\n", 150 | "circ = qc.assign_parameters({a : np.pi*0.3})\n", 151 | "eval = state.evolve(circ)\n", 152 | "exp_val = eval.expectation_value(oper=op)\n", 153 | "\n", 154 | "# Get the expectation value for f(x+h)\n", 155 | "circ = qc.assign_parameters({a : np.pi*(0.3+h)})\n", 156 | "eval = state.evolve(circ)\n", 157 | "exp_val_eps = eval.expectation_value(oper=op)\n", 158 | "\n", 159 | "print('Finite difference:', (exp_val_eps - exp_val) / h)\n", 160 | "print('Cosine formula: ', np.pi * np.cos(np.pi * val))" 161 | ] 162 | }, 163 | { 164 | "cell_type": "markdown", 165 | "metadata": {}, 166 | "source": [ 167 | "With a varying number of observables and compositions, this is what automatic differentiation frameworks can provide by tracking values and benefitting from the composable nature of the numerical approximations. More information in [https://www.tensorflow.org/quantum/tutorials/gradients#2_the_need_for_a_differentiator](https://www.tensorflow.org/quantum/tutorials/gradients#2_the_need_for_a_differentiator)" 168 | ] 169 | }, 170 | { 171 | "cell_type": "code", 172 | "execution_count": 5, 173 | "metadata": {}, 174 | "outputs": [ 175 | { 176 | "data": { 177 | "image/png": "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", 178 | "text/plain": [ 179 | "
" 180 | ] 181 | }, 182 | "metadata": {}, 183 | "output_type": "display_data" 184 | } 185 | ], 186 | "source": [ 187 | "import numpy as np\n", 188 | "from qiskit.quantum_info import SparsePauliOp\n", 189 | "from qiskit.circuit import QuantumCircuit, QuantumRegister, Parameter\n", 190 | "\n", 191 | "# Instantiate the quantum circuit\n", 192 | "a = Parameter('a')\n", 193 | "b = Parameter('b')\n", 194 | "\n", 195 | "# Circuit\n", 196 | "q = QuantumRegister(1)\n", 197 | "qc = QuantumCircuit(q)\n", 198 | "qc.h(q)\n", 199 | "qc.rz(a, q[0])\n", 200 | "qc.rx(b, q[0])\n", 201 | "\n", 202 | "# Instantiate the Hamiltonian observable 2X+Z\n", 203 | "H = SparsePauliOp.from_list([('X', 2), ('Z',1)])\n", 204 | "\n", 205 | "# Parameter list\n", 206 | "params = [[np.pi / 4, 0]]\n", 207 | "\n", 208 | "display(qc.draw('mpl', style = \"clifford\"))" 209 | ] 210 | }, 211 | { 212 | "cell_type": "code", 213 | "execution_count": 6, 214 | "metadata": {}, 215 | "outputs": [], 216 | "source": [ 217 | "import warnings\n", 218 | "warnings.filterwarnings(\"ignore\")" 219 | ] 220 | }, 221 | { 222 | "cell_type": "code", 223 | "execution_count": 7, 224 | "metadata": {}, 225 | "outputs": [ 226 | { 227 | "name": "stdout", 228 | "output_type": "stream", 229 | "text": [ 230 | "State estimator gradient computed with parameter shift [array([-1.41421356, 0.70710678])]\n" 231 | ] 232 | } 233 | ], 234 | "source": [ 235 | "from qiskit.primitives import Estimator\n", 236 | "from qiskit_algorithms.gradients import ParamShiftEstimatorGradient\n", 237 | "\n", 238 | "# Define the estimator\n", 239 | "estimator = Estimator()\n", 240 | "# Define the gradient\n", 241 | "gradient = ParamShiftEstimatorGradient(estimator)\n", 242 | "\n", 243 | "# Evaluate the gradient of the circuits using parameter shift gradients\n", 244 | "pse_grad_result = gradient.run(qc, H, params).result().gradients\n", 245 | "print('State estimator gradient computed with parameter shift', pse_grad_result)" 246 | ] 247 | }, 248 | { 249 | "cell_type": "markdown", 250 | "metadata": {}, 251 | "source": [ 252 | "We can do the same thing using other frameworks." 253 | ] 254 | }, 255 | { 256 | "cell_type": "code", 257 | "execution_count": 8, 258 | "metadata": {}, 259 | "outputs": [], 260 | "source": [ 261 | "import pennylane as qml\n", 262 | "\n", 263 | "dev = qml.device(\"default.qubit\", wires=2)\n", 264 | "\n", 265 | "@qml.qnode(dev)\n", 266 | "def circuit(weights):\n", 267 | " qml.RX(weights[0], wires=0)\n", 268 | " qml.RY(weights[1], wires=1)\n", 269 | " qml.CNOT(wires=[0, 1])\n", 270 | " qml.RX(weights[2], wires=1)\n", 271 | " return qml.expval(qml.PauliZ(1))" 272 | ] 273 | }, 274 | { 275 | "cell_type": "code", 276 | "execution_count": 9, 277 | "metadata": {}, 278 | "outputs": [ 279 | { 280 | "data": { 281 | "image/png": "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", 282 | "text/plain": [ 283 | "
" 284 | ] 285 | }, 286 | "metadata": {}, 287 | "output_type": "display_data" 288 | } 289 | ], 290 | "source": [ 291 | "import pennylane.numpy as np\n", 292 | "\n", 293 | "weights = np.array([0.1, 0.2, 0.3], requires_grad=True)\n", 294 | "\n", 295 | "qml.drawer.use_style(\"pennylane\")\n", 296 | "qml.draw_mpl(circuit)(weights);" 297 | ] 298 | }, 299 | { 300 | "cell_type": "code", 301 | "execution_count": 10, 302 | "metadata": {}, 303 | "outputs": [ 304 | { 305 | "data": { 306 | "text/plain": [ 307 | "tensor(0.9316158, requires_grad=True)" 308 | ] 309 | }, 310 | "execution_count": 10, 311 | "metadata": {}, 312 | "output_type": "execute_result" 313 | } 314 | ], 315 | "source": [ 316 | "circuit(weights)" 317 | ] 318 | }, 319 | { 320 | "cell_type": "code", 321 | "execution_count": 11, 322 | "metadata": {}, 323 | "outputs": [ 324 | { 325 | "data": { 326 | "text/plain": [ 327 | "tensor([-0.09347337, -0.18884787, -0.28818254], requires_grad=True)" 328 | ] 329 | }, 330 | "execution_count": 11, 331 | "metadata": {}, 332 | "output_type": "execute_result" 333 | } 334 | ], 335 | "source": [ 336 | "qml.gradients.param_shift(circuit)(weights)" 337 | ] 338 | }, 339 | { 340 | "cell_type": "markdown", 341 | "metadata": {}, 342 | "source": [ 343 | "Checkout: https://docs.pennylane.ai/en/stable/introduction/interfaces.html" 344 | ] 345 | } 346 | ], 347 | "metadata": { 348 | "kernelspec": { 349 | "display_name": ".venv", 350 | "language": "python", 351 | "name": "python3" 352 | }, 353 | "language_info": { 354 | "codemirror_mode": { 355 | "name": "ipython", 356 | "version": 3 357 | }, 358 | "file_extension": ".py", 359 | "mimetype": "text/x-python", 360 | "name": "python", 361 | "nbconvert_exporter": "python", 362 | "pygments_lexer": "ipython3", 363 | "version": "3.12.7" 364 | } 365 | }, 366 | "nbformat": 4, 367 | "nbformat_minor": 2 368 | } 369 | -------------------------------------------------------------------------------- /notebooks/visualize.py: -------------------------------------------------------------------------------- 1 | import matplotlib.pylab as plt 2 | from matplotlib.lines import Line2D 3 | import numpy as np 4 | 5 | def plot_data_in_feature_space(X, y, highlight_rows): 6 | X_m = np.ma.array(X, mask=False) 7 | X_m.mask[highlight_rows] = True 8 | 9 | y_m = np.ma.array(y, mask=False) 10 | y_m.mask[highlight_rows] = True 11 | 12 | fig, ax = plt.subplots(figsize=(12, 8)) 13 | s1 = ax.scatter(X_m[:, 0], X_m[:, 1], c=y_m, cmap=plt.cm.tab10, marker="o", s=10) 14 | s2 = ax.scatter( 15 | X[highlight_rows, 0], 16 | X[highlight_rows, 1], 17 | c=y[highlight_rows], 18 | cmap=plt.cm.tab10, 19 | marker="X", 20 | s=80, 21 | edgecolors="k", 22 | vmin=0, 23 | vmax=9, 24 | ) 25 | ax.legend( 26 | [ 27 | Line2D( 28 | [0], 29 | [0], 30 | color="w", 31 | marker="X", 32 | markerfacecolor="w", 33 | markeredgecolor="k", 34 | markersize=10, 35 | ), 36 | Line2D( 37 | [0], 38 | [0], 39 | color="w", 40 | marker="o", 41 | markerfacecolor="w", 42 | markeredgecolor="k", 43 | markersize=6, 44 | ), 45 | ], 46 | ["Samples", "Dataset"], 47 | loc="lower right", 48 | ) 49 | cbar = fig.colorbar(s2, ticks=(0.5 + np.arange(10)) * 10 / 11) 50 | cbar.ax.set_yticklabels(np.arange(10, dtype=int)) 51 | cbar.ax.tick_params(size=0, labelsize="large") 52 | 53 | 54 | def plot_dataset(X, y, rows=5): 55 | indices = np.stack( 56 | [ 57 | np.random.choice(np.argwhere(y == i).ravel(), size=rows, replace=False) 58 | for i in range(10) 59 | ] 60 | ) 61 | fig, axs = plt.subplots(rows, 11) 62 | for i in range(rows): 63 | axs[i][0].axis("off") 64 | axs[i][0].set_aspect("equal") 65 | for j in range(10): 66 | axs[i][j + 1].imshow(X[indices[j, i], :].reshape(8, 8), cmap="Greys") 67 | axs[i][j + 1].axis("off") 68 | axs[i][j + 1].set_aspect("equal") 69 | 70 | axs[0][0].set_title("label:") 71 | 72 | for j in range(10): 73 | axs[0][j + 1].set_title(f"{j}") 74 | 75 | fig.subplots_adjust(wspace=0, hspace=0) 76 | 77 | 78 | def plot_numbers(X, y, title: str = None): 79 | fig, axs = plt.subplots( 80 | 1, 81 | X.shape[0] + int(title != None), 82 | figsize=(X.shape[0] + int(title != None) + 1, 2), 83 | ) 84 | fig.suptitle("Samples") 85 | if title: 86 | axs[0].axis("off") 87 | axs[0].set_title(title) 88 | axs[0].set_aspect("equal") 89 | if not isinstance(X, np.ndarray): 90 | X = X.to_numpy() 91 | if not isinstance(y, np.ndarray): 92 | y = y["class"] 93 | for i, (data, label) in enumerate(zip(X, y)): 94 | axs[i + int(title != None)].imshow(data.reshape(8, 8), cmap="Greys") 95 | axs[i + int(title != None)].axis("off") 96 | axs[i + int(title != None)].set_title(label) 97 | 98 | 99 | def plot_results( 100 | clf, X_train, y_train, X_test, y_test, X_highlight, y_highlight, X_range, resolution 101 | ): 102 | xx, yy = np.meshgrid( 103 | np.linspace(X_range[0][0], X_range[0][1], resolution), 104 | np.linspace(X_range[0][0], X_range[0][1], resolution), 105 | ) 106 | 107 | Z = clf.predict(np.c_[xx.ravel(), yy.ravel()]).reshape(xx.shape) 108 | 109 | fig, ax = plt.subplots(figsize=(12, 8)) 110 | pc = ax.pcolor(xx, yy, Z.astype(int), cmap=plt.cm.tab10, alpha=0.5) 111 | 112 | s1 = ax.scatter( 113 | X_train[:, 0], X_train[:, 1], c=y_train, cmap=plt.cm.tab10, s=20, edgecolors="k" 114 | ) 115 | s2 = ax.scatter( 116 | X_test[:, 0], 117 | X_test[:, 1], 118 | c=y_test, 119 | cmap=plt.cm.tab10, 120 | marker="v", 121 | s=30, 122 | edgecolors="k", 123 | ) 124 | s3 = ax.scatter( 125 | X_highlight[:, 0], 126 | X_highlight[:, 1], 127 | c=y_highlight, 128 | cmap=plt.cm.tab10, 129 | marker="X", 130 | s=80, 131 | edgecolors="w", 132 | linewidth=2, 133 | vmin=0, 134 | vmax=9, 135 | ) 136 | 137 | ax.legend( 138 | [ 139 | Line2D( 140 | [0], 141 | [0], 142 | color="w", 143 | marker="o", 144 | markerfacecolor="w", 145 | markeredgecolor="k", 146 | lw=0, 147 | ), 148 | Line2D( 149 | [0], 150 | [0], 151 | color="w", 152 | marker="v", 153 | markerfacecolor="w", 154 | markeredgecolor="k", 155 | lw=0, 156 | ), 157 | Line2D( 158 | [0], 159 | [0], 160 | color="w", 161 | marker="X", 162 | markerfacecolor="w", 163 | markeredgecolor="k", 164 | markersize=10, 165 | lw=0, 166 | ), 167 | ], 168 | ["Training", "Test", "Samples"], 169 | loc="lower right", 170 | ) 171 | 172 | cbar = fig.colorbar(s2, ticks=(0.5 + np.arange(10)) * 10 / 11) 173 | cbar.ax.set_yticklabels(np.arange(10, dtype=int)) 174 | cbar.ax.tick_params(size=0, labelsize="large") -------------------------------------------------------------------------------- /pyproject.toml: -------------------------------------------------------------------------------- 1 | [project] 2 | name = "quickstart2025" 3 | version = "0.1.0" 4 | description = "Easy to use code snippets to get you started on QML" 5 | readme = "README.md" 6 | requires-python = ">=3.10" 7 | dependencies = [ 8 | "ipykernel>=6.29.5", 9 | "qutip-qip>=0.4.0", 10 | "qutip>=5.1.1", 11 | "ingenii-quantum>=0.1.0", 12 | "qiskit-algorithms>=0.3.1", 13 | "qiskit-machine-learning>=0.8.2", 14 | "seaborn>=0.13.2", 15 | "optuna>=4.2.0", 16 | "ydata-profiling>=4.12.2", 17 | "ipywidgets>=8.1.5", 18 | ] 19 | -------------------------------------------------------------------------------- /requirements-squlearn.txt: -------------------------------------------------------------------------------- 1 | squlearn 2 | ipykernel 3 | matplotlib 4 | pylatexenc -------------------------------------------------------------------------------- /requirements.txt: -------------------------------------------------------------------------------- 1 | # This file was autogenerated by uv via the following command: 2 | # uv export --no-hashes -o requirements.txt 3 | absl-py==2.1.0 4 | aiohappyeyeballs==2.4.4 5 | aiohttp==3.11.11 6 | aiosignal==1.3.2 7 | alembic==1.14.1 8 | annotated-types==0.7.0 9 | appdirs==1.4.4 10 | appnope==0.1.4 ; platform_system == 'Darwin' 11 | asttokens==3.0.0 12 | astunparse==1.6.3 13 | async-timeout==5.0.1 ; python_full_version < '3.11' 14 | attrs==25.1.0 15 | autograd==1.7.0 16 | autoray==0.7.0 17 | cachetools==5.5.1 18 | certifi==2025.1.31 19 | cffi==1.17.1 ; platform_python_implementation != 'PyPy' or implementation_name == 'pypy' 20 | charset-normalizer==3.4.1 21 | colorama==0.4.6 ; sys_platform == 'win32' or platform_system == 'Windows' 22 | colorlog==6.9.0 23 | comm==0.2.2 24 | contourpy==1.3.1 25 | cotengra==0.7.0 26 | cryptography==44.0.0 27 | cycler==0.12.1 28 | cytoolz==1.0.1 29 | dacite==1.9.1 30 | debugpy==1.8.12 31 | decorator==5.1.1 32 | diastatic-malt==2.15.2 33 | dill==0.3.9 34 | exceptiongroup==1.2.2 ; python_full_version < '3.11' 35 | executing==2.2.0 36 | filelock==3.17.0 37 | flatbuffers==25.1.24 38 | fonttools==4.55.8 39 | frozenlist==1.5.0 40 | fsspec==2025.2.0 41 | gast==0.6.0 42 | google-pasta==0.2.0 43 | greenlet==3.1.1 ; (python_full_version < '3.14' and platform_machine == 'AMD64') or (python_full_version < '3.14' and platform_machine == 'WIN32') or (python_full_version < '3.14' and platform_machine == 'aarch64') or (python_full_version < '3.14' and platform_machine == 'amd64') or (python_full_version < '3.14' and platform_machine == 'ppc64le') or (python_full_version < '3.14' and platform_machine == 'win32') or (python_full_version < '3.14' and platform_machine == 'x86_64') 44 | grpcio==1.70.0 45 | gurobipy==12.0.1 46 | h5py==3.12.1 47 | htmlmin==0.1.12 48 | ibm-cloud-sdk-core==3.22.1 49 | ibm-platform-services==0.59.1 50 | idna==3.10 51 | imagehash==4.3.1 52 | ingenii-quantum==0.1.0 53 | ipykernel==6.29.5 54 | ipython==8.32.0 55 | ipywidgets==8.1.5 56 | jedi==0.19.2 57 | jinja2==3.1.5 58 | joblib==1.4.2 59 | jupyter-client==8.6.3 60 | jupyter-core==5.7.2 61 | jupyterlab-widgets==3.0.13 62 | keras==3.8.0 63 | kiwisolver==1.4.8 64 | libclang==18.1.1 65 | llvmlite==0.44.0 66 | mako==1.3.8 67 | markdown==3.7 68 | markdown-it-py==3.0.0 69 | markupsafe==3.0.2 70 | matplotlib==3.10.0 71 | matplotlib-inline==0.1.7 72 | mdurl==0.1.2 73 | ml-dtypes==0.4.1 74 | mpmath==1.3.0 75 | multidict==6.1.0 76 | multimethod==1.12 77 | namex==0.0.8 78 | nest-asyncio==1.6.0 79 | networkx==3.4.2 80 | numba==0.61.0 81 | numpy==2.0.2 82 | nvidia-cublas-cu12==12.4.5.8 ; platform_machine == 'x86_64' and platform_system == 'Linux' 83 | nvidia-cuda-cupti-cu12==12.4.127 ; platform_machine == 'x86_64' and platform_system == 'Linux' 84 | nvidia-cuda-nvrtc-cu12==12.4.127 ; platform_machine == 'x86_64' and platform_system == 'Linux' 85 | nvidia-cuda-runtime-cu12==12.4.127 ; platform_machine == 'x86_64' and platform_system == 'Linux' 86 | nvidia-cudnn-cu12==9.1.0.70 ; platform_machine == 'x86_64' and platform_system == 'Linux' 87 | nvidia-cufft-cu12==11.2.1.3 ; platform_machine == 'x86_64' and platform_system == 'Linux' 88 | nvidia-curand-cu12==10.3.5.147 ; platform_machine == 'x86_64' and platform_system == 'Linux' 89 | nvidia-cusolver-cu12==11.6.1.9 ; platform_machine == 'x86_64' and platform_system == 'Linux' 90 | nvidia-cusparse-cu12==12.3.1.170 ; platform_machine == 'x86_64' and platform_system == 'Linux' 91 | nvidia-cusparselt-cu12==0.6.2 ; platform_machine == 'x86_64' and platform_system == 'Linux' 92 | nvidia-nccl-cu12==2.21.5 ; platform_machine == 'x86_64' and platform_system == 'Linux' 93 | nvidia-nvjitlink-cu12==12.4.127 ; platform_machine == 'x86_64' and platform_system == 'Linux' 94 | nvidia-nvtx-cu12==12.4.127 ; platform_machine == 'x86_64' and platform_system == 'Linux' 95 | opt-einsum==3.4.0 96 | optree==0.14.0 97 | optuna==4.2.0 98 | packaging==24.2 99 | pandas==2.2.3 100 | parso==0.8.4 101 | patsy==1.0.1 102 | pbr==6.1.0 103 | pennylane==0.40.0 104 | pennylane-lightning==0.40.0 105 | pexpect==4.9.0 ; sys_platform != 'emscripten' and sys_platform != 'win32' 106 | phik==0.12.4 107 | pillow==11.1.0 108 | platformdirs==4.3.6 109 | prompt-toolkit==3.0.50 110 | propcache==0.2.1 111 | protobuf==5.29.3 112 | psutil==6.1.1 113 | ptyprocess==0.7.0 ; sys_platform != 'emscripten' and sys_platform != 'win32' 114 | pure-eval==0.2.3 115 | pycparser==2.22 ; platform_python_implementation != 'PyPy' or implementation_name == 'pypy' 116 | pydantic==2.9.2 117 | pydantic-core==2.23.4 118 | pygments==2.19.1 119 | pyjwt==2.10.1 120 | pylatexenc==2.10 121 | pyparsing==3.2.1 122 | pyspnego==0.11.2 123 | python-dateutil==2.9.0.post0 124 | pytz==2025.1 125 | pywavelets==1.8.0 126 | pywin32==308 ; platform_python_implementation != 'PyPy' and sys_platform == 'win32' 127 | pyyaml==6.0.2 128 | pyzmq==26.2.1 129 | qiskit==1.3.2 130 | qiskit-aer==0.16.0 131 | qiskit-algorithms==0.3.1 132 | qiskit-ibm-runtime==0.34.0 133 | qiskit-machine-learning==0.8.2 134 | quimb==1.10.0 135 | qutip==5.1.1 136 | qutip-qip==0.4.0 137 | requests==2.32.3 138 | requests-ntlm==1.3.0 139 | rich==13.9.4 140 | rustworkx==0.16.0 141 | scikit-learn==1.6.1 142 | scipy==1.15.1 143 | scipy-openblas32==0.3.29.0.0 144 | seaborn==0.13.2 145 | setuptools==75.8.0 146 | six==1.17.0 147 | sqlalchemy==2.0.37 148 | sspilib==0.2.0 ; sys_platform == 'win32' 149 | stack-data==0.6.3 150 | statsmodels==0.14.4 151 | stevedore==5.4.0 152 | symengine==0.13.0 153 | sympy==1.13.1 154 | tensorboard==2.18.0 155 | tensorboard-data-server==0.7.2 156 | tensorflow==2.18.0 157 | tensorflow-io-gcs-filesystem==0.37.1 ; python_full_version < '3.12' 158 | tensorly==0.9.0 159 | termcolor==2.5.0 160 | threadpoolctl==3.5.0 161 | tomlkit==0.13.2 162 | toolz==1.0.0 163 | torch==2.6.0 164 | torch-geometric==2.6.1 165 | torchaudio==2.6.0 166 | torchvision==0.21.0 167 | tornado==6.4.2 168 | tqdm==4.67.1 169 | traitlets==5.14.3 170 | triton==3.2.0 ; platform_machine == 'x86_64' and platform_system == 'Linux' 171 | typeguard==4.4.1 172 | typing-extensions==4.12.2 173 | tzdata==2025.1 174 | urllib3==2.3.0 175 | visions==0.7.6 176 | wcwidth==0.2.13 177 | websocket-client==1.8.0 178 | werkzeug==3.1.3 179 | wheel==0.45.1 180 | widgetsnbextension==4.0.13 181 | wordcloud==1.9.4 182 | wrapt==1.17.2 183 | yarl==1.18.3 184 | ydata-profiling==4.12.2 185 | --------------------------------------------------------------------------------