From 6765bde58bd94378e41fe0fceac078fb8dc9bf0b Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jos=C3=A9=20Ignacio=20Espinoza=20Camacho?= <78752942+JoseIgnacioE@users.noreply.github.com> Date: Wed, 26 Oct 2022 22:47:47 -0500 Subject: [PATCH] Add files via upload --- Challenge_notebook_V1.ipynb | 654 ++++++++++++++++++++++++++++++++++++ 1 file changed, 654 insertions(+) create mode 100644 Challenge_notebook_V1.ipynb diff --git a/Challenge_notebook_V1.ipynb b/Challenge_notebook_V1.ipynb new file mode 100644 index 0000000..1cac0da --- /dev/null +++ b/Challenge_notebook_V1.ipynb @@ -0,0 +1,654 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Solving the number partitioning problem using OpenQAOA\n", + "\n", + "## The combinatorial problem\n", + "\n", + "Number partitioning is often considerest the simplest among NP-Hard combinatorial optimisation problems (see [wikipedia](https://en.wikipedia.org/wiki/Partition_problem) for a simple reference). The problem statement is quite simple: you are given a set of numbers $N$ where $n_i \\in N$ is a positive integer, and you are asked to find two subsets $A$ and $B$ such that\n", + "\n", + "1. $A \\cap B = \\emptyset$, i.e., the two sets are disjoint\n", + "2. $|\\sum_i a_i - \\sum_j b_j|$, where $ a \\in A$ and $b \\in B$ is minimised, i.e., the difference in the sum of all elements in A and the sum of all the elements in B is minimised" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now, QAOA only accepts binary terms. However, we are in luck! There is a straightforward formulation of the above problem statement in binary variables. And it is already implemented in OpenQAOA! :)\n", + "\n", + "\\begin{equation}\n", + "\\verb|Cost function| = (\\sum_i n_i x_i)^2\n", + "\\end{equation}\n", + "\n", + "where each $x_i \\in \\pm 1$ is a binary decisional variable, and $n_i$ is the i-th number in the list" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let's make a concrete case. Let's assume we want to partition the simples problem we can think of: $N = [1,2,3]$.\n", + "\n", + "Then our cost function will be\n", + "\n", + "\\begin{equation}\n", + "\\verb|Cost function| = (1*x_1 + 2*x_2 + 3*x_3)^2\n", + "\\end{equation}\n", + "\n", + "Now, our algorithm has to find a set of values $verb|solution| = (x_1, x_2, x_3)$ such that the cost function above is minimised.\n", + "\n", + "For this problem, you can verify that solutions $1,1,0$ and $0, 1, 1$ indeed solve the problem!" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Let's solve the problem with OpenQAOA" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### The very first step is the problem creation" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "from openqaoa.problems.problem import NumberPartition\n", + "np = NumberPartition(numbers=[1,2,3])\n", + "np_qubo = np.get_qubo_problem()\n", + "\n", + "# Creating device object\n", + "from openqaoa.devices import create_device\n", + "\n", + "# Get backend object\n", + "from openqaoa.backends.qaoa_backend import get_qaoa_backend\n", + "\n", + "# visualize the QUBO form on a graph\n", + "from openqaoa.utilities import plot_graph, graph_from_hamiltonian\n", + "\n", + "#extract Hamiltonain\n", + "cost_hamil = np_qubo.hamiltonian" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "{'betas': -1.1878788091103751, 'gammas': 0.9331502735380728}\n" + ] + } + ], + "source": [ + "# You are required to specify a mixer hamiltonian\n", + "from openqaoa.utilities import X_mixer_hamiltonian\n", + "mixer_hamil = X_mixer_hamiltonian(n_qubits=3)\n", + "\n", + "# Create custom parameters\n", + "from openqaoa.qaoa_parameters import create_qaoa_variational_params, QAOACircuitParams\n", + "p=1\n", + "circuit_params = QAOACircuitParams(cost_hamil, mixer_hamil, p=p)\n", + "\n", + "# Creating device object\n", + "sim_device = create_device(location='local', name='vectorized')\n", + "\n", + "# Get backend object\n", + "sim_backend = get_qaoa_backend(circuit_params, sim_device)\n", + "\n", + "import numpy\n", + "def my_submission_function(p):\n", + " \"\"\"\n", + " Note that the number of betas and gammas depend on the number of layers `p`!\n", + "\n", + " Also, in OpenQAOA there are several parametrisation techiques which will change the structure \n", + " of the return of `my_submission_function`\n", + " For more details: https://el-openqaoa.readthedocs.io/en/latest/notebooks/05_advanced_parameterization.html\n", + " \n", + " This function do the following:\n", + " 1. Randomly generate betas and gammas for p la\n", + " 2. Randomly generate 3 points arround each beta and gammas and each layer\n", + " 3. Measure the expectation value for each each beta and gammas and each layer\n", + " 4. Get the lowest expectation value for each layer\n", + " \"\"\"\n", + " for i in range(p):\n", + " #Randomly generated parameters\n", + " params= { 'betas' : [numpy.random.randn() for i in range(p)],\n", + " 'gammas' : [numpy.random.randn() for i in range(p)]}\n", + " \n", + " # Generate the corners of a triangle inside a circle of radius=1 with center at betas and gammas\n", + " betas_center= params['betas']\n", + " gammas_center=params['gammas']\n", + " \n", + " angles= numpy.array([0,2*numpy.pi/3,4*numpy.pi/3]) + numpy.random.randn()\n", + " b= betas_center + numpy.cos([angles])\n", + " b=b[0]\n", + " g= gammas_center + numpy.sin([angles])\n", + " g=g[0]\n", + " \n", + " expected=[]\n", + " for j in range(3):\n", + " variate_params = create_qaoa_variational_params(circuit_params, 'standard', 'custom', {'betas': b[j], 'gammas': g[j]})\n", + " expected.append( sim_backend.expectation(variate_params) )\n", + " \n", + " #Return the index of the minimum value\n", + " minimum_index = numpy.argmin(expected)\n", + " min_expval = expected[minimum_index]\n", + " \n", + " # Update parameters with minimum value of expectation value\n", + " params= { 'betas' : b[minimum_index],\n", + " 'gammas' : g[minimum_index]}\n", + " \n", + " \n", + " return params\n", + "\n", + "print(my_submission_function(p))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Now, let's solve the problem using OpenQAOA" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "from openqaoa.workflows.optimizer import QAOA" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The simples QAOA workflow you can crate is the following" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "# Initialise QAOA using the default values\n", + "q = QAOA()\n", + "# Complile the QAOA workflow\n", + "q.compile(np_qubo)\n", + "\n", + "# Optimise the problem!\n", + "q.optimize()" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "states kept: 8\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "q.results.plot_probabilities()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Yay! Indeed the two states with the highes probabilities are `110` and `110`" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Setting up the initial parmeters" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let's try to set the initial parameters for OpenQAOA" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [], + "source": [ + "# Initialise QAOA\n", + "q = QAOA()\n", + "q.compile(np_qubo)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "After compiling the problem, OpenQAOA generates and initialises the value of the variational parameters:" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Standard Parameterisation:\n", + "\tp: 1\n", + "Variational Parameters:\n", + "\tbetas: [0.35]\n", + "\tgammas: [0.35]" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "q.variate_params" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "However, as problems get more and more complex it gets hardwre and harder to select good parameters. In OpenQAOA we have three strategies controlled by the keywordk `init_type`:\n", + "\n", + "1. Random\n", + "2. Custom\n", + "3. (linear) Ramp" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [], + "source": [ + "# Initialise QAOA\n", + "q = QAOA()\n", + "q.set_circuit_properties(p=1, param_type='standard', init_type='rand')\n", + "q.compile(np_qubo)" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Standard Parameterisation:\n", + "\tp: 1\n", + "Variational Parameters:\n", + "\tbetas: [2.0659122]\n", + "\tgammas: [1.66074957]" + ] + }, + "execution_count": 18, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "q.variate_params" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## The challenge" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "You have to find a good way to initialise the variational parameters!" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "{'betas': -1.9322728333259969, 'gammas': 0.914100115952216}\n" + ] + } + ], + "source": [ + "# You are required to specify a mixer hamiltonian\n", + "from openqaoa.utilities import X_mixer_hamiltonian\n", + "mixer_hamil = X_mixer_hamiltonian(n_qubits=3)\n", + "\n", + "# Create custom parameters\n", + "from openqaoa.qaoa_parameters import create_qaoa_variational_params, QAOACircuitParams\n", + "p=1\n", + "circuit_params = QAOACircuitParams(cost_hamil, mixer_hamil, p=p)\n", + "\n", + "# Creating device object\n", + "sim_device = create_device(location='local', name='vectorized')\n", + "\n", + "# Get backend object\n", + "sim_backend = get_qaoa_backend(circuit_params, sim_device)\n", + "\n", + "import numpy\n", + "def my_submission_function(p):\n", + " \"\"\"\n", + " Note that the number of betas and gammas depend on the number of layers `p`!\n", + "\n", + " Also, in OpenQAOA there are several parametrisation techiques which will change the structure \n", + " of the return of `my_submission_function`\n", + " For more details: https://el-openqaoa.readthedocs.io/en/latest/notebooks/05_advanced_parameterization.html\n", + " \n", + " This function do the following:\n", + " 1. Randomly generate betas and gammas for p la\n", + " 2. Randomly generate 3 points arround each beta and gammas and each layer\n", + " 3. Measure the expectation value for each each beta and gammas and each layer\n", + " 4. Get the lowest expectation value for each layer\n", + " \"\"\"\n", + " for i in range(p):\n", + " #Randomly generated parameters\n", + " params= { 'betas' : [numpy.random.randn() for i in range(p)],\n", + " 'gammas' : [numpy.random.randn() for i in range(p)]}\n", + " \n", + " # Generate the corners of a triangle inside a circle of radius=1 with center at betas and gammas\n", + " betas_center= params['betas']\n", + " gammas_center=params['gammas']\n", + " \n", + " angles= numpy.array([0,2*numpy.pi/3,4*numpy.pi/3]) + numpy.random.randn()\n", + " b= betas_center + numpy.cos([angles])\n", + " b=b[0]\n", + " g= gammas_center + numpy.sin([angles])\n", + " g=g[0]\n", + " \n", + " expected=[]\n", + " for j in range(3):\n", + " variate_params = create_qaoa_variational_params(circuit_params, 'standard', 'custom', {'betas': b[j], 'gammas': g[j]})\n", + " expected.append( sim_backend.expectation(variate_params) )\n", + " \n", + " #Return the index of the minimum value\n", + " minimum_index = numpy.argmin(expected)\n", + " min_expval = expected[minimum_index]\n", + " \n", + " # Update parameters with minimum value of expectation value\n", + " params= { 'betas' : b[minimum_index],\n", + " 'gammas' : g[minimum_index]}\n", + " \n", + " \n", + " return params\n", + "\n", + "print(my_submission_function(p))" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [], + "source": [ + "p = 1\n", + "q_submission = QAOA()\n", + "q_submission.set_circuit_properties(p=p, \n", + " param_type='standard',\n", + " init_type='custom',\n", + " variational_params_dict=my_submission_function(p))" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'betas': 0.7576561944640988, 'gammas': 2.192973967646362}" + ] + }, + "execution_count": 23, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "my_submission_function(1)" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [], + "source": [ + "q_submission.compile(np_qubo)" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": {}, + "outputs": [], + "source": [ + "q_submission.optimize()" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "q_submission.results.plot_cost()" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "states kept: 8\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "q_submission.results.plot_probabilities()" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'optimized angles': [1.66965151740754,\n", + " 0.6375614072232378,\n", + " -1.1201697453886026,\n", + " -1.428165484630001],\n", + " 'optimized cost': 0.8831835286775866,\n", + " 'optimized measurement outcomes': array([-0.03369381-0.03310497j, -0.05957972+0.11899007j,\n", + " 0.02484488-0.13735447j, 0.67713975-0.04537234j,\n", + " 0.67713975-0.04537234j, 0.02484488-0.13735447j,\n", + " -0.05957972+0.11899007j, -0.03369381-0.03310497j]),\n", + " 'optimized run job id': []}" + ] + }, + "execution_count": 31, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "q_submission.results.optimized" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig,axes = plt.subplots(1,2,sharex = False, sharey=False,figsize=(15,7),gridspec_kw={'wspace': 0.3})\n", + "cmap = 'viridis'\n", + "\n", + "im_0 = axes[0].contourf(cost_landscape_std,cmap=cmap,levels=100,extent=(gammas[0],gammas[-1],betas[0],betas[-1]))\n", + "axes[0].set_title('Cost Landscape for Standard Parameterization')\n", + "axes[0].set_xlabel('Gammas')\n", + "axes[0].set_ylabel('Betas')\n", + "\n", + "cbar_ax = fig.add_axes([0.472, 0.15, 0.01, 0.7])\n", + "fig.colorbar(im_0, cax=cbar_ax)\n", + "\n", + "im_1 = axes[1].contourf(cost_landscape_fourier,cmap=cmap,levels=100,extent=(gammas[0],gammas[-1],betas[0],betas[-1]))\n", + "axes[1].set_title('Cost Landscape for Fourier Parameterization')\n", + "axes[1].set_xlabel(\"$u$'s (Fourier Params)\")\n", + "axes[1].set_ylabel(\"$v$'s (Fourier Params)\")\n", + "\n", + "cbar_ax = fig.add_axes([0.91, 0.15, 0.01, 0.7])\n", + "fig.colorbar(im_1, cax=cbar_ax);" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Data generation" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "To generate data for the number partitioning problem simple generate lists of 10 random numbers between 1 and 30. For example," + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "np_input = [numpy.random.randint(30) for i in range(10)]\n", + "np_input" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 [Default]", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.9.10" + }, + "vscode": { + "interpreter": { + "hash": "6a636e316c639ea10e1f179fe5f5da9fe18ed93c599b36c2c8b5bde54041450d" + } + }, + "widgets": { + "application/vnd.jupyter.widget-state+json": { + "state": {}, + "version_major": 2, + "version_minor": 0 + } + } + }, + "nbformat": 4, + "nbformat_minor": 4 +}