beginners_guide_example_QUBO.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "56f0b47e",
   "metadata": {},
   "source": [
    "# Example: Computing on the Dynex Platform with Python - BQM (3)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ed479bbd",
   "metadata": {},
   "source": [
    "Dynex is the world’s first neuromorphic supercomputing blockchain based on the DynexSolve chip algorithm,\n",
    "a Proof-of-Useful-Work (PoUW) approach to solving real-world problems. This example demonstrates how to use the Dynex SDK to use Pyton to compute on the Dynex Platform with Python."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "ca97eb45-844d-4fdc-902e-504cb366c249",
   "metadata": {},
   "outputs": [],
   "source": [
    "%load_ext autoreload\n",
    "%autoreload 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "4c52a895",
   "metadata": {},
   "outputs": [],
   "source": [
    "import dynex\n",
    "import dimod"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "afd0e043",
   "metadata": {},
   "source": [
    "## Building a Binary Quadratic Model "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "499a2526",
   "metadata": {},
   "source": [
    "Binary quadratic models (BQMs) are problems of the form:"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "72b2cd4e",
   "metadata": {},
   "source": [
    "<math xmlns=\"http://www.w3.org/1998/Math/MathML\" display=\"block\">\n",
    "  <mi>E</mi>\n",
    "  <mo stretchy=\"false\">(</mo>\n",
    "  <mrow data-mjx-texclass=\"ORD\">\n",
    "    <mi mathvariant=\"bold\">v</mi>\n",
    "  </mrow>\n",
    "  <mo mathvariant=\"bold\" stretchy=\"false\">)</mo>\n",
    "  <mo mathvariant=\"bold\">=</mo>\n",
    "  <munder>\n",
    "    <mo data-mjx-texclass=\"OP\">&#x2211;</mo>\n",
    "    <mrow data-mjx-texclass=\"ORD\">\n",
    "      <mi mathvariant=\"bold\">i</mi>\n",
    "    </mrow>\n",
    "  </munder>\n",
    "  <msub>\n",
    "    <mi mathvariant=\"bold\">a</mi>\n",
    "    <mi mathvariant=\"bold\">i</mi>\n",
    "  </msub>\n",
    "  <msub>\n",
    "    <mi mathvariant=\"bold\">v</mi>\n",
    "    <mi mathvariant=\"bold\">i</mi>\n",
    "  </msub>\n",
    "  <mo mathvariant=\"bold\">+</mo>\n",
    "  <munder>\n",
    "    <mo data-mjx-texclass=\"OP\">&#x2211;</mo>\n",
    "    <mrow data-mjx-texclass=\"ORD\">\n",
    "      <mi mathvariant=\"bold\">i</mi>\n",
    "      <mo mathvariant=\"bold\">&lt;</mo>\n",
    "      <mi mathvariant=\"bold\">j</mi>\n",
    "    </mrow>\n",
    "  </munder>\n",
    "  <msub>\n",
    "    <mi mathvariant=\"bold\">b</mi>\n",
    "    <mrow data-mjx-texclass=\"ORD\">\n",
    "      <mi mathvariant=\"bold\">i</mi>\n",
    "      <mo mathvariant=\"bold\">,</mo>\n",
    "      <mi mathvariant=\"bold\">j</mi>\n",
    "    </mrow>\n",
    "  </msub>\n",
    "  <msub>\n",
    "    <mi mathvariant=\"bold\">v</mi>\n",
    "    <mi mathvariant=\"bold\">i</mi>\n",
    "  </msub>\n",
    "  <msub>\n",
    "    <mi mathvariant=\"bold\">v</mi>\n",
    "    <mi mathvariant=\"bold\">j</mi>\n",
    "  </msub>\n",
    "  <mo mathvariant=\"bold\">+</mo>\n",
    "  <mi mathvariant=\"bold\">c</mi>\n",
    "  <mstyle scriptlevel=\"0\">\n",
    "    <mspace width=\"2em\"></mspace>\n",
    "  </mstyle>\n",
    "  <mstyle scriptlevel=\"0\">\n",
    "    <mspace width=\"2em\"></mspace>\n",
    "  </mstyle>\n",
    "  <msub>\n",
    "    <mi mathvariant=\"bold\">v</mi>\n",
    "    <mi mathvariant=\"bold\">i</mi>\n",
    "  </msub>\n",
    "  <mo>&#x2208;</mo>\n",
    "  <mo fence=\"false\" stretchy=\"false\">{</mo>\n",
    "  <mo mathvariant=\"bold\">&#x2212;</mo>\n",
    "  <mn mathvariant=\"bold\">1</mn>\n",
    "  <mo mathvariant=\"bold\">,</mo>\n",
    "  <mo mathvariant=\"bold\">+</mo>\n",
    "  <mn mathvariant=\"bold\">1</mn>\n",
    "  <mo fence=\"false\" stretchy=\"false\">}</mo>\n",
    "  <mtext mathvariant=\"bold\">&#xA0;or&#xA0;</mtext>\n",
    "  <mo fence=\"false\" stretchy=\"false\">{</mo>\n",
    "  <mn mathvariant=\"bold\">0</mn>\n",
    "  <mo mathvariant=\"bold\">,</mo>\n",
    "  <mn mathvariant=\"bold\">1</mn>\n",
    "  <mo fence=\"false\" stretchy=\"false\">}</mo>\n",
    "</math>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4ce31898",
   "metadata": {},
   "source": [
    "where a,b,c are real values."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cc67c3a1",
   "metadata": {},
   "source": [
    "We need to define a quadratic model (QM) that represents our problem. The simplest way to build a binary quadratic model (BQM) is using dimod’s symbolic variables. For each mathematical variable in your BQM, we define a symbolic\n",
    "binary variable using dimod. Once the QM is defined, it is stored as a BinaryQuadraticModel object. This object stores the linear and quadratic coefficients of the mathematical expression, any constant term or offset, and\n",
    "the type of variables used to build the model. In this case, printing out the object bqmmodel that we have\n",
    "constructed reveals the following:"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c1ace556",
   "metadata": {},
   "source": [
    "The following illustrative example reduces an Ising model for a QUBO problem:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "931cfac2",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[DYNEX] MODEL CONVERTED TO QUBO\n",
      "[DYNEX] PRECISION SET TO 0.0001\n",
      "[DYNEX] QUBO: Constant offset of the binary quadratic model: 0.0\n"
     ]
    }
   ],
   "source": [
    "# Example: QUBU problem:\n",
    "\n",
    "bqmodel = dimod.BinaryQuadraticModel({'B': -1, 'A': -1}, {('A', 'B'): 2}, 0.0, dimod.BINARY)  # QUBO\n",
    "model = dynex.BQM(bqmodel);\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "c5ac8ee6-c7aa-45ca-9eaf-1f4b990904bf",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sample(sample={'A': 1, 'B': 0}, energy=-1.0, num_occurrences=1)\n"
     ]
    }
   ],
   "source": [
    "# exact solver\n",
    "response = dimod.ExactSolver().sample(bqmodel)\n",
    "print(response.first)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4122925b",
   "metadata": {},
   "source": [
    "## Interacting with the Dynex Sampler "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9e3c77de",
   "metadata": {},
   "source": [
    "To find the minimum energy state for a QM (the assignment of variable values that gives us the\n",
    "minimum energy value for our QM), the Dynex SDK provides samplers and solvers. A solver is\n",
    "a resource that runs a problem. Samplers are processes that run a problem many times to obtain\n",
    "a collection of samples, each of which is a possible solution to our problem. For convenience, we\n",
    "will generally refer to Dynex’s samplers as a whole, to include solvers as well."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "0cbcad35",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[DYNEX] SAMPLER INITIALISED\n"
     ]
    }
   ],
   "source": [
    "sampler = dynex.DynexSampler(model, mainnet=False);"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1548a123",
   "metadata": {},
   "source": [
    "Once we have established our sampler in our program, we can call it for our QM. Each type of QM\n",
    "model has its own method for interacting with the sampler, whether it be QUBO, BinaryQuadrticModel, or any other QM. We call the sampler to sample our QM using one of Dynex’s sample functions, depending on what type of QM we are using. For example, the code snippet below demonstrates how we can sample a BinaryQuadraticModel object named bqm using the Dynex Platform."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "ade2765b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[DYNEX|TESTNET] *** WAITING FOR READS ***\n",
      "╭────────────┬───────────┬───────────────────────────┬─────────┬─────┬─────────┬───────┬─────┬──────────┬─────╮\n",
      "│ DYNEXJOB   │ ELAPSED   │ WORKERS                   │ CHIPS   │ ✔   │ STEPS   │ LOC   │ ✔   │ ENERGY   │ ✔   │\n",
      "├────────────┼───────────┼───────────────────────────┼─────────┼─────┼─────────┼───────┼─────┼──────────┼─────┤\n",
      "│            │           │ *** WAITING FOR READS *** │         │     │         │       │     │          │     │\n",
      "╰────────────┴───────────┴───────────────────────────┴─────────┴─────┴─────────┴───────┴─────┴──────────┴─────╯\n",
      "\n",
      "[DYNEX] FINISHED READ AFTER 0.00 SECONDS\n",
      "[DYNEX] SAMPLESET LOADED\n",
      "   A  B energy num_oc.\n",
      "0  1  0   -1.0       1\n",
      "['BINARY', 1 rows, 1 samples, 2 variables]\n"
     ]
    }
   ],
   "source": [
    "sampleset = sampler.sample(num_reads=32, annealing_time = 100);\n",
    "print(sampleset)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6db670b2",
   "metadata": {},
   "source": [
    "After we have sampled our QM, the sampler returns a SampleSet object. This object contains all\n",
    "of the samples returned along with their corresponding energy value, number of chips, number of integration steps, and more. The additional information varies depending on which sampler is used. As users get more\n",
    "comfortable with the Dynex SDK and the variety of samplers available, it is often useful to take\n",
    "some time to explore the wealth of information provided in the SampleSet object. Some of the key properties and methods of a SampleSet that we access are the following:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "1975c33e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sample(sample={'A': 1, 'B': 0}, energy=-1.0, num_occurrences=1)\n"
     ]
    }
   ],
   "source": [
    "print(sampleset.first) # sample with the lowest energy"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ba609414",
   "metadata": {},
   "source": [
    "The sample shows the corresponding energy values for our QM and additional information like total energy, number of chips or number of integration steps."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "92cecdda",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "SampleSet(rec.array([([1, 0], -1., 1)],\n",
       "          dtype=[('sample', 'i1', (2,)), ('energy', '<f8'), ('num_occurrences', '<i8')]), Variables(['A', 'B']), {}, 'BINARY')"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sampleset # the full set of samples"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "01232e54",
   "metadata": {},
   "source": [
    "Each line shows a sample (solution) that was returned, along with the corresponding energy value,\n",
    "number of chips used (each Dynex chip provides one read), and number of integration steps (=annealing_time). Note that the effecitve number of integration steps can be lower then the specified annealing_time, because the ODE integration ends when a solution has been found."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "bce11bd4-4c42-4540-a91b-d2f503828eea",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}