1_Quantum_annealing.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "737ZUbff1j_6"
      },
      "source": [
        "#1.-QUANTUM ANNEALING\n",
        "\n",
        "###Setup"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "Tpn5NXYu1auq"
      },
      "outputs": [],
      "source": [
        "pip install dwave-ocean-sdk"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "vTdT1dsY13Z3"
      },
      "outputs": [],
      "source": [
        "!dwave config create"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "1XWjEK6Q14ux"
      },
      "source": [
        "##1.1- A simple example"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "q6X6SjT2usQv"
      },
      "outputs": [],
      "source": [
        "import dimod\n",
        "J = {(0,1):1, (0,2):1}\n",
        "h = {}\n",
        "problem = dimod.BinaryQuadraticModel(h, J, 0.0, dimod.SPIN)\n",
        "print(\"The problem we are going to solve is:\")\n",
        "print(problem)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "fHAwsSiO2B_3"
      },
      "source": [
        "### Running on the annealer"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "PLezBEyYvIkB"
      },
      "outputs": [],
      "source": [
        "from dwave.system import DWaveSampler\n",
        "from dwave.system import EmbeddingComposite\n",
        "sampler = EmbeddingComposite(DWaveSampler())\n",
        "result = sampler.sample(problem, num_reads=10)\n",
        "print(\"The solutions that we have obtained are\")\n",
        "print(result)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "lpElhPy00jJD"
      },
      "outputs": [],
      "source": [
        "print(result.info['timing']['qpu_access_time'], \"microseconds\")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Kb66k4_s2MCA"
      },
      "source": [
        "##1.2- Constrained problems"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "S27pucl4vMAh"
      },
      "outputs": [],
      "source": [
        "x0 = dimod.Binary(\"x0\")\n",
        "x1 = dimod.Binary(\"x1\")\n",
        "x2 = dimod.Binary(\"x2\")\n",
        "blp = dimod.ConstrainedQuadraticModel()\n",
        "blp.set_objective(-5*x0+3*x1-2*x2)\n",
        "blp.add_constraint(x0 + x2 <= 1, \"First constraint\")\n",
        "blp.add_constraint(3*x0 -x1 + 3*x2 <= 4, \"Second constraint\")\n",
        "print(\"Our variables are:\")\n",
        "print(blp.variables)\n",
        "print(\"Our objective is:\")\n",
        "print(blp.objective)\n",
        "print(\"Our constraints are:\") \n",
        "print(blp.constraints)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "xuJqGjWJxgi3"
      },
      "outputs": [],
      "source": [
        "sample1 = {\"x0\":1, \"x1\":1, \"x2\":1}\n",
        "print(\"The assignment is\", sample1)\n",
        "print(\"Its cost is\", blp.objective.energy(sample1))\n",
        "print(\"Is it feasible?\",blp.check_feasible(sample1))\n",
        "print(\"The violations of the constraints are\")\n",
        "print(blp.violations(sample1))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "MS6WZNRmxs0P"
      },
      "outputs": [],
      "source": [
        "sample2 = {\"x0\":0, \"x1\":0, \"x2\":1}\n",
        "print(\"The assignment is\", sample2)\n",
        "print(\"Its cost is\", blp.objective.energy(sample2))\n",
        "print(\"Is it feasible?\",blp.check_feasible(sample2))\n",
        "print(\"The violations of the constraints are\")\n",
        "print(blp.violations(sample2))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "T6cZ7yJO2XlM"
      },
      "source": [
        "### Exact solver"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "CdF92pL2xxAo"
      },
      "outputs": [],
      "source": [
        "solver = dimod.ExactCQMSolver()\n",
        "solution = solver.sample_cqm(blp)\n",
        "print(\"The list of assignments is\")\n",
        "print(solution)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "IvxrhmeezjvH"
      },
      "outputs": [],
      "source": [
        "print(solution.first)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "Xc7yNhbXztW3"
      },
      "outputs": [],
      "source": [
        "feasible_sols = solution.filter(lambda s: s.is_feasible)\n",
        "print(feasible_sols)\n",
        "print()\n",
        "print(feasible_sols.first)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "pToCoEaI2btl"
      },
      "source": [
        "### Running on the annealer"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "tX-ojqL-1BfX"
      },
      "outputs": [],
      "source": [
        "y0, y1 = dimod.Binaries([\"y0\", \"y1\"])\n",
        "cqm = dimod.ConstrainedQuadraticModel()\n",
        "cqm.set_objective(-2*y0-3*y1)\n",
        "cqm.add_constraint(y0 + 2*y1 <= 2)\n",
        "print(cqm)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "7ZOVZspS3vR5"
      },
      "outputs": [],
      "source": [
        "qubo, invert = dimod.cqm_to_bqm(cqm, lagrange_multiplier = 5)\n",
        "print(qubo)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "7cy2llfS32sZ"
      },
      "outputs": [],
      "source": [
        "sampler = EmbeddingComposite(DWaveSampler())\n",
        "result = sampler.sample(qubo, num_reads=10)\n",
        "print(\"The solutions that we have obtained are\")\n",
        "print(result)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "NF18XDkU4FJY"
      },
      "outputs": [],
      "source": [
        "samples = []\n",
        "occurrences = []\n",
        "for s in result.data():\n",
        "    samples.append(invert(s.sample))\n",
        "    occurrences.append(s.num_occurrences)\n",
        "sampleset = dimod.SampleSet.from_samples_cqm(samples,cqm,\n",
        "    num_occurrences=occurrences)\n",
        "print(\"The solutions to the original problem are\")\n",
        "print(sampleset)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "i_GR6q_a4TlA"
      },
      "outputs": [],
      "source": [
        "final_sols = sampleset.filter(lambda s: s.is_feasible)\n",
        "final_sols = final_sols.aggregate()\n",
        "print(\"The final solutions are\")\n",
        "print(final_sols)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "NoVmpdVN54Rm"
      },
      "source": [
        "##1.3- The annealers"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "Rys4m9BJ5TnQ"
      },
      "outputs": [],
      "source": [
        "from dwave.cloud import Client\n",
        "for solver in Client.from_config().get_solvers():\n",
        "    print(solver)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "4otZoOVe58G-"
      },
      "outputs": [],
      "source": [
        "from dwave.system import DWaveSampler\n",
        "sampler=DWaveSampler(solver='DW_2000Q_6')\n",
        "print(\"Name:\",sampler.properties[\"chip_id\"])\n",
        "print(\"Number of qubits:\",sampler.properties[\"num_qubits\"])\n",
        "print(\"Category:\",sampler.properties[\"category\"])\n",
        "print(\"Supported problems:\",sampler.properties[\"supported_problem_types\"])\n",
        "print(\"Topology:\",sampler.properties[\"topology\"])\n",
        "print(\"Range of reads:\",sampler.properties[\"num_reads_range\"])"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "Wnoz0-u_83Sa"
      },
      "outputs": [],
      "source": [
        "from dwave.system import DWaveSampler\n",
        "sampler=DWaveSampler(solver='Advantage_system4.1')\n",
        "print(\"Name:\",sampler.properties[\"chip_id\"])\n",
        "print(\"Number of qubits:\",sampler.properties[\"num_qubits\"])\n",
        "print(\"Category:\",sampler.properties[\"category\"])\n",
        "print(\"Supported problems:\",sampler.properties[\"supported_problem_types\"])\n",
        "print(\"Topology:\",sampler.properties[\"topology\"])\n",
        "print(\"Range of reads:\",sampler.properties[\"num_reads_range\"])"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "geQHW_wi8-Xb"
      },
      "outputs": [],
      "source": [
        "from dwave.system import DWaveSampler\n",
        "sampler=DWaveSampler(solver='Advantage2_prototype1.1')\n",
        "print(\"Name:\",sampler.properties[\"chip_id\"])\n",
        "print(\"Number of qubits:\",sampler.properties[\"num_qubits\"])\n",
        "print(\"Category:\",sampler.properties[\"category\"])\n",
        "print(\"Supported problems:\",sampler.properties[\"supported_problem_types\"])\n",
        "print(\"Topology:\",sampler.properties[\"topology\"])\n",
        "print(\"Range of reads:\",sampler.properties[\"num_reads_range\"])"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "E4sJ98PO9Yj5"
      },
      "outputs": [],
      "source": [
        "sampler=DWaveSampler(solver='DW_2000Q_6')\n",
        "print(\"Couplings:\",sampler.properties[\"couplers\"])"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "jx6s-YRlCIDa"
      },
      "outputs": [],
      "source": [
        "sampler.adjacency"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "zkBtmxgRCQhZ"
      },
      "outputs": [],
      "source": [
        "sampler=DWaveSampler(solver='Advantage_system4.1')\n",
        "sampler.adjacency"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "7a86GTY-CcQA"
      },
      "outputs": [],
      "source": [
        "print(set([len(sampler.adjacency[i]) for i in sampler.adjacency]))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "fjzYRArBOpkV"
      },
      "source": [
        "### Embeddings"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "EEgmV8KRKaAN"
      },
      "outputs": [],
      "source": [
        "J = {(0,1):1, (0,2):1, (1,2):1}\n",
        "h = {}\n",
        "triangle = dimod.BinaryQuadraticModel(h, J, 0.0, dimod.SPIN)\n",
        "# Embed it and solve it on the DW_2000Q_6 annealer\n",
        "sampler = EmbeddingComposite(DWaveSampler(solver = \"DW_2000Q_6\"))\n",
        "result = sampler.sample(triangle, num_reads=10, \n",
        "    return_embedding = True)\n",
        "print(\"The samples obtained are\")\n",
        "print(result)\n",
        "print(\"The embedding used was\")\n",
        "print(result.info[\"embedding_context\"])"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "3R5Z0-9rO1xB"
      },
      "source": [
        "##1.4- Annealing parameters"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "cq4bKaMkSV6V"
      },
      "source": [
        "### Annealing time"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "P2dR7J0VO4fp"
      },
      "outputs": [],
      "source": [
        "sampler = DWaveSampler(solver = \"Advantage_system4.1\")\n",
        "print(\"The default annealing time is\",\n",
        "    sampler.properties[\"default_annealing_time\"],\"microseconds\")\n",
        "print(\"The possible values for the annealing time (in microseconds)\"\\\n",
        "    \" lie in the range\",sampler.properties[\"annealing_time_range\"])"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "A2KCp4N5ST9_"
      },
      "outputs": [],
      "source": [
        "J = {(0,1):1, (0,2):1, (1,2):1}\n",
        "h = {}\n",
        "triangle = dimod.BinaryQuadraticModel(h, J, 0.0, dimod.SPIN)\n",
        "sampler = EmbeddingComposite(DWaveSampler(solver = \"DW_2000Q_6\"))\n",
        "result = sampler.sample(triangle, num_reads=10, annealing_time = 100)\n",
        "print(\"The samples obtained are\")\n",
        "print(result)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "3pjJFq0gSmdF"
      },
      "source": [
        "### Annealing schedules"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "83EDzWWISbyu"
      },
      "outputs": [],
      "source": [
        "forward_schedule=[[0.0, 0.0], [5.0, 0.25], [25, 0.75], [30, 1.0]]\n",
        "sampler = EmbeddingComposite(DWaveSampler())\n",
        "result = sampler.sample(triangle, num_reads=10, \n",
        "    anneal_schedule = forward_schedule)\n",
        "print(result)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "dFuK9HzhSvsZ"
      },
      "outputs": [],
      "source": [
        "reverse_schedule=[[0.0, 1.0], [10.0, 0.5], [20, 1.0]]\n",
        "initial_state = {0:1, 1:1, 2:1}\n",
        "sampler = EmbeddingComposite(DWaveSampler())\n",
        "result = sampler.sample(triangle, num_reads=10, \n",
        "    anneal_schedule = reverse_schedule,\n",
        "    reinitialize_state=False, initial_state = initial_state)\n",
        "print(\"The samples obtained are\")\n",
        "print(result)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "pNi6_miNTGZy"
      },
      "source": [
        "### Coupling strength"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "AxXYiKztTCYf"
      },
      "outputs": [],
      "source": [
        "sampler = DWaveSampler(\"Advantage_system4.1\")\n",
        "print(\"The coupling strength range is\", sampler.properties[\"h_range\"])"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "OTGwO9H8TLAA"
      },
      "outputs": [],
      "source": [
        "sampler = EmbeddingComposite(DWaveSampler(\"Advantage_system4.1\"))\n",
        "# Define the problem\n",
        "x0 = dimod.Binary(\"x0\")\n",
        "x1 = dimod.Binary(\"x1\")\n",
        "x2 = dimod.Binary(\"x2\")\n",
        "blp = dimod.ConstrainedQuadraticModel()\n",
        "blp.set_objective(-5*x0+3*x1-2*x2)\n",
        "blp.add_constraint(x0 + x2 <= 1, \"First constraint\")\n",
        "blp.add_constraint(3*x0 -x1 + 3*x2 <= 4, \"Second constraint\")\n",
        "# Convert the problem and run it\n",
        "qubo, invert = dimod.cqm_to_bqm(blp, lagrange_multiplier = 10)\n",
        "result = sampler.sample(qubo, num_reads=100)\n",
        "# Aggregate and show the results\n",
        "samples = []\n",
        "occurrences = []\n",
        "for s in result.data():\n",
        "    samples.append(invert(s.sample))\n",
        "    occurrences.append(s.num_occurrences)\n",
        "sampleset = dimod.SampleSet.from_samples_cqm(samples,blp,\n",
        "    num_occurrences=occurrences)\n",
        "print(\"The solutions to the original problem are\")\n",
        "print(sampleset.filter(lambda s: s.is_feasible).aggregate())"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "6h_jF4-aTOhu"
      },
      "outputs": [],
      "source": [
        "sampler = EmbeddingComposite(DWaveSampler(\"Advantage_system4.1\"))\n",
        "# Define the problem\n",
        "x0 = dimod.Binary(\"x0\")\n",
        "x1 = dimod.Binary(\"x1\")\n",
        "x2 = dimod.Binary(\"x2\")\n",
        "blp = dimod.ConstrainedQuadraticModel()\n",
        "blp.set_objective(-5*x0+3*x1-2*x2)\n",
        "blp.add_constraint(x0 + x2 <= 1, \"First constraint\")\n",
        "blp.add_constraint(3*x0 -x1 + 3*x2 <= 4, \"Second constraint\")\n",
        "# Convert the problem and run it\n",
        "qubo, invert = dimod.cqm_to_bqm(blp, lagrange_multiplier = 4)\n",
        "result = sampler.sample(qubo, num_reads=100)\n",
        "# Aggregate and show the results\n",
        "samples = []\n",
        "occurrences = []\n",
        "for s in result.data():\n",
        "    samples.append(invert(s.sample))\n",
        "    occurrences.append(s.num_occurrences)\n",
        "sampleset = dimod.SampleSet.from_samples_cqm(samples,blp,\n",
        "    num_occurrences=occurrences)\n",
        "print(\"The solutions to the original problem are\")\n",
        "print(sampleset.filter(lambda s: s.is_feasible).aggregate())"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "yugPnBT8TyYK"
      },
      "outputs": [],
      "source": [
        "sampler = EmbeddingComposite(DWaveSampler(\"Advantage_system4.1\"))\n",
        "# Define the problem\n",
        "x0 = dimod.Binary(\"x0\")\n",
        "x1 = dimod.Binary(\"x1\")\n",
        "x2 = dimod.Binary(\"x2\")\n",
        "blp = dimod.ConstrainedQuadraticModel()\n",
        "blp.set_objective(-5*x0+3*x1-2*x2)\n",
        "blp.add_constraint(x0 + x2 <= 1, \"First constraint\")\n",
        "blp.add_constraint(3*x0 -x1 + 3*x2 <= 4, \"Second constraint\")\n",
        "# Convert the problem and run it\n",
        "qubo, invert = dimod.cqm_to_bqm(blp, lagrange_multiplier = 1)\n",
        "result = sampler.sample(qubo, num_reads=100)\n",
        "# Aggregate and show the results\n",
        "samples = []\n",
        "occurrences = []\n",
        "for s in result.data():\n",
        "    samples.append(invert(s.sample))\n",
        "    occurrences.append(s.num_occurrences)\n",
        "sampleset = dimod.SampleSet.from_samples_cqm(samples,blp,\n",
        "    num_occurrences=occurrences)\n",
        "print(\"The solutions to the original problem are\")\n",
        "print(sampleset.filter(lambda s: s.is_feasible).aggregate())"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "VjxKttHrcg96"
      },
      "source": [
        "##1.5- Classic and hybrid solvers"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "N4qqAHtsT67O"
      },
      "outputs": [],
      "source": [
        "import greedy\n",
        "import dimod\n",
        "# Define the problem\n",
        "J = {(0,1):1, (1,2):1, (2,3):1, (3,0):1}\n",
        "h = {}\n",
        "problem = dimod.BinaryQuadraticModel(h, J, 0.0, dimod.SPIN)\n",
        "# Sample with SteepestDescentSolver\n",
        "solver = greedy.SteepestDescentSolver()\n",
        "solution = solver.sample(problem, num_reads = 10)\n",
        "print(solution.aggregate())"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "hwQiJdTRcvTG"
      },
      "outputs": [],
      "source": [
        "import tabu \n",
        "solver = tabu.TabuSampler()\n",
        "solution = solver.sample(problem, num_reads = 10)\n",
        "print(solution.aggregate())"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "vt3faSCCczWk"
      },
      "outputs": [],
      "source": [
        "import neal \n",
        "solver = neal.SimulatedAnnealingSampler()\n",
        "solution = solver.sample(problem, num_reads = 10)\n",
        "print(solution.aggregate())"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "lLDXlso8c2TB"
      },
      "outputs": [],
      "source": [
        "import dwave.system \n",
        "sampler = dwave.system.LeapHybridSampler()\n",
        "solution = solver.sample(problem, num_reads = 10)\n",
        "print(solution.aggregate())"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "hqKTAHKcfXDS"
      },
      "outputs": [],
      "source": [
        "sampler.properties[\"quota_conversion_rate\"]"
      ]
    }
  ],
  "metadata": {
    "colab": {
      "provenance": []
    },
    "kernelspec": {
      "display_name": "Python 3",
      "name": "python3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}