01-hybrid-computing-getting-started.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Quantum-Classical Hybrid Computing: Getting Started\n",
    "\n",
    "D-Wave offers two complementary approaches to hybrid computing: \n",
    "\n",
    "* [Leap Quantum Application Environment](https://cloud.dwavesys.com/leap) maintains state-of-the-art hybrid solvers.\n",
    "* Ocean software's [*dwave-hybrid*](https://docs.ocean.dwavesys.com/en/stable/docs_hybrid/sdk_index.html) provides reference\n",
    "  samplers and a Python framework for developing custom hybrid workflows and components.\n",
    "\n",
    "These notebooks demonstrate how you can apply Leap's cloud-based hybrid solvers and the *dwave-hybrid* Python framework's samplers to your problem, create hybrid workflows, and develop custom hybrid components, expanding the content presented in the D-Wave webinar [Hybrid Quantum Programming](https://www.youtube.com/watch?v=EW44reo8Bn0).\n",
    "\n",
    "This first notebook starts you off with Leap's hybrid solvers and *dwave-hybrid*'s out-of-the-box reference samplers and workflows:\n",
    "\n",
    "1. [A Few Words on Hybrid Computing](#A-Few-Words-on-Hybrid-Computing) section gives a very short introduction to quantum-classical hybrid computing. \n",
    "2. [A Sample Problem](#A-Sample-Problem) section provides an example problem used throughout the notebooks.\n",
    "3. [Using Leap's Hybrid Solvers](#Using-Leap's-Hybrid-Solvers) section demonstrates using Leap's cloud-based hybrid solvers.\n",
    "4. [Reference Samplers and Workflows](#Reference-Samplers-and-Workflows) section demonstrates using *dwave-hybrid* reference samplers and workflows. \n",
    "5. [Operational Utilities](#Operational-Utilities) section shows utilities to help your coding. \n",
    "\n",
    "More-advanced content is provided in the following notebooks:\n",
    "\n",
    "* [Quantum-Classical Hybrid Computing: Workflows](02-hybrid-computing-workflows.ipynb) notebook shows how you use *dwave-hybrid* components to create custom workflows for your problem.\n",
    "* [Quantum-Classical Hybrid Computing: Components](03-hybrid-computing-components.ipynb) notebook shows how to develop your own hybrid components for optimal performance. \n",
    "\n",
    "## Prerequisite Knowledge\n",
    "\n",
    "These notebooks assume basic familiarity with [Ocean Software](https://docs.ocean.dwavesys.com/en/stable/index.html) and its binary quadratic model ([BQM](https://docs.ocean.dwavesys.com/en/stable/concepts/bqm.html)) approach to formulating problems on quantum computers. [Leap's](https://cloud.dwavesys.com/leap) *Structural Imbalance* and *Factoring* Jupyter Notebooks are good introductions to the basics of solving problems on a quantum computer, as is the [Getting Started with the D-Wave System](https://docs.dwavesys.com/docs/latest/doc_getting_started.html) guide. For an introduction to Ocean software, see [Ocean Software documentation](https://docs.ocean.dwavesys.com/en/stable/getting_started.html#gs). "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**New to Jupyter Notebooks?** JNs are divided into text or code cells. Pressing the **Run** button in the menu bar moves to the next cell. Code cells are marked by an \"In: \\[\\]\" to the left; when run, an asterisk displays until code completion: \"In: \\[\\*\\]\"."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# A Few Words on Hybrid Computing\n",
    "Quantum-classical hybrid is the use of both classical and quantum resources to solve problems, exploiting the complementary strengths that each provides. As quantum processors grow in size, offloading hard optimization problems to quantum computers promises performance benefits similar to CPUs' outsourcing of compute-intensive graphics-display processing to GPUs. \n",
    "\n",
    "This [Medium Article](https://medium.com/d-wave/three-truths-and-the-advent-of-hybrid-quantum-computing-1941ba46ff8c) provides an overview of, and motivation for, hybrid computing. \n",
    "\n",
    "D-Wave's [Leap quantum cloud service](https://cloud.dwavesys.com/leap) provides cloud-based hybrid solvers you can submit arbitrary BQMs to. These solvers, which implement state-of-the-art classical algorithms together with intelligent allocation of the quantum processing unit (QPU) to parts of the problem where it benefits most, are designed to accommodate even very large problems. Leap's solvers can relieve you of the burden of any current and future development and optimization of hybrid algorithms that best solve your problem. \n",
    "\n",
    "[*dwave-hybrid*](https://docs.ocean.dwavesys.com/en/stable/docs_hybrid/sdk_index.html) provides you with a Python framework for building a variety of flexible hybrid workflows. These use quantum and classical resources together to find good solutions to your problem. For example, a hybrid workflow might use classical resources to find a problem’s hard core and send that to the QPU, or break a large problem into smaller pieces that can be solved on a QPU and then recombined.\n",
    "\n",
    "The *dwave-hybrid* framework enables rapid development of experimental prototypes, which provide insight into expected performance of the productized versions. It provides reference samplers and workflows you can quickly plug into your application code. You can easily experiment with customizing workflows that best solve your problem. You can also develop your own hybrid components to optimize performance.  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# A Sample Problem\n",
    "This section creates an example problem used in the following sections and notebooks.  \n",
    "\n",
    "Each of the two sets of nodes in the illustrative graph below, one red and the other blue, form an *independent set*; that is, a set of vertices with no edge connecting any of its member pairs. \n",
    "\n",
    "<img src=\"images/cover.png\" width=200x>\n",
    "\n",
    "Such a graph might represent the problem of [antenna selection](https://github.com/dwave-examples/antenna-selection), finding good coverage for a sprinkler system, or many other real-world optimization problems. If the graph represents a sprinkler system, with edges corresponding to overlaps in sprinklers' watering, a [maximum independent set](https://en.wikipedia.org/wiki/Independent_set_(graph_theory)) solves the problem of watering a lawn evenly with the lowest number of sprinklers.  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The first code cell below uses [networkx](https://networkx.github.io) to build a random sparse graph&mdash;the `random_geometric_graph()` function places uniformly at random a specified number of nodes, `problem_node_count`, in a unit cube, joining edges of any two if  the distance is below a given `radius`&mdash;and utility graphics code to plot it. To see this graphics code, select **Jupyter File Explorer View** from the Online Learning page and navigate to the folder for this notebook.\n",
    "\n",
    "<div class=\"alert alert-warning\" role=\"alert\" style=\"margin: 10px\">Note: Problem size (nodes and density of edges) selected below ensures that runtimes on compute resources (virtual CPUs) provided by the Leap environment do not exceed a few minutes.</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import networkx as nx\n",
    "from helpers.draw import plot    \n",
    "%matplotlib inline\n",
    "\n",
    "problem_node_count = 300\n",
    "\n",
    "G = nx.random_geometric_graph(problem_node_count, radius=0.0005*problem_node_count)\n",
    "\n",
    "plot(G)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As with solving any problem on the quantum computer, the first step of finding the graph's maximum independent set is to [formulate the problem as a BQM](https://docs.ocean.dwavesys.com/en/stable/overview/solving_problems.html). Use Ocean software's [dwave_networkx](https://docs.ocean.dwavesys.com/en/stable/docs_dnx/sdk_index.html) and [dimod](https://docs.ocean.dwavesys.com/en/stable/docs_dimod/sdk_index.html) to create and hold an appropriate BQM. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import dwave_networkx as dnx\n",
    "import dimod\n",
    "\n",
    "qubo = dnx.algorithms.independent_set.maximum_weighted_independent_set_qubo(G)\n",
    "bqm = dimod.BQM.from_qubo(qubo)\n",
    "\n",
    "print(\"BQM sets all node biases to {} and edge biases to {}.\".format(\n",
    "       bqm.linear[list(G.edges)[0][0]], bqm.quadratic[list(G.edges)[0]]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Using Leap's Hybrid Solvers\n",
    "D-Wave's [Leap quantum cloud service](https://cloud.dwavesys.com/leap) provides state-of-the-art hybrid solvers you can submit arbitrary BQMs to, efficiently outsourcing the development and optimization of hybrid algorithms to D-Wave's scientists with their many years of expertise in this field. This enables you to deploy a tested hybrid solver to solve your application code's BQM with minimal code updates.\n",
    "\n",
    "This section provides a demonstration of using a Leap hybrid solver.\n",
    "\n",
    "<div class=\"alert alert-warning\" role=\"alert\" style=\"margin: 10px\">Note: Not all accounts have access to this type of solver. This is the only section of the Hybrid Computing notebooks that uses these solvers&mdash;if you do not see solvers in the Hybrid section of Supported Solvers in your Leap dashboard, skip to the next section. </div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Run `LeapHybridSampler` with its default parameters on the BQM representing the problem graph. \n",
    "\n",
    "The resulting samples represent nodes of a maximum independent set with ones. The `print` line below uses [NumPy](https://numpy.org/) to count and report the size of the set. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from dwave.system import LeapHybridSampler\n",
    "import numpy as np\n",
    "\n",
    "result = LeapHybridSampler().sample(bqm, label='Notebook - Hybrid Computing 1')\n",
    "print(\"Found solution with {} nodes at energy {}.\".format(np.sum(result.record.sample), \n",
    "                                                          result.first.energy))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Plot the problem with the selected nodes colored deeper red than the background graph.  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plot(G, subgraphs=[G.subgraph(np.flatnonzero(result.record.sample==1))])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Reference Samplers and Workflows\n",
    "*dwave-hybrid* provides [reference workflows and samplers](https://docs.ocean.dwavesys.com/en/stable/docs_hybrid/reference/reference.html) that you can import into your application code. These are not optimized to a particular problem, but are a good starting point for your hybrid solution.\n",
    "\n",
    "The purpose of the rest of this notebook is to show you how you can quickly deploy these ready-made components into your application code. The [Quantum-Classical Hybrid Computing: Workflows](02-hybrid-computing-workflows.ipynb) and [Quantum-Classical Hybrid Computing: Components](03-hybrid-computing-components.ipynb) notebooks will explain the components themselves in more detail than the minimum needed for usage given here."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##  Sampler: Kerberos \n",
    "You can run the Kerberos sampler, an out-of-the-box hybrid sampler provided in the *dwave-hybrid* package, in the same way you typically run any dimod sampler. \n",
    "\n",
    "Run `KerberosSampler` with its default parameters on the BQM representing the problem graph.  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import hybrid \n",
    "import numpy as np\n",
    "\n",
    "result = hybrid.KerberosSampler().sample(bqm, \n",
    "                                         qpu_params={'label': 'Notebook - Hybrid Computing 1'})\n",
    "print(\"Found solution with {} nodes at energy {}.\".format(np.sum(result.record.sample), \n",
    "                                                          result.first.energy))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Configuring the Sampler\n",
    "Kerberos default parameters work reasonably well with a large variety of problems but are not optimized to any particular class of problem. Once your application code runs with a reference sampler, experiment with adjusting its parameters to improve performance.\n",
    "\n",
    "To configure Kerberos for your application, it's sufficient to know that Kerberos loops over three sampling branches in parallel, selecting after each iteration the best results from tabu search, simulated annealing, and QPU sampling of a subproblem.\n",
    "\n",
    "<img src=\"images/kerberos.png\" width=500x>\n",
    "\n",
    "Internally, the Kerberos structure includes the following components:\n",
    "\n",
    "* *Interruptable Tabu Sampler* and *Interruptable SA Sampler* are classical samplers that \n",
    "  run on CPU until interrupted by the QPU branch. \n",
    "* *Energy Impact Decomposer* selects a subset of the problem's variables (those that\n",
    "  maximally contribute to the problem energy); *QPU Sampler* submits subproblems to the\n",
    "  quantum computer; and *SplatComposer* inserts subproblems' samples into problem  \n",
    "  samples.\n",
    "* *ArgMin* selects the best samples from an iteration, which terminates when the quantum \n",
    "  computer returns samples. \n",
    "* *Loop* iterates these *Racing Branches* until a termination condition is reached.  \n",
    "\n",
    "The [Quantum-Classical Hybrid Computing: Workflows](02-hybrid-computing-workflows.ipynb) notebook dives into the details of *dwave-hybrid* components and structuring workflows. \n",
    "\n",
    "\n",
    "The call below limits the maximum number of iterations to `max_iter=10`.  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "result = hybrid.KerberosSampler().sample(bqm, \n",
    "                                         max_iter=10, \n",
    "                                         qpu_params={'label': 'Notebook - Hybrid Computing 1'})\n",
    "print(\"Found solution with {} nodes at energy {}.\".format(np.sum(result.record.sample), \n",
    "                                                                 result.first.energy))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-success\" role=\"alert\" style=\"margin: 10px\"> \n",
    "    <b>Exercise</b>: Kerberos provides a large set of \n",
    "    <a href=\"https://docs.ocean.dwavesys.com/en/stable/docs_hybrid/reference/reference.html\">configurable parameters</a>. In the placeholder code cell below, experiment with a few: (1) Return more sample sets (2) Increase the number of QPU sample sets (reads) per submission (3) Reduce the tabu search to 200 ms.\n",
    "\n",
    "Open the hidden code cell below it for a solution.\n",
    "\n",
    "Remember that for large problems, CPU runtimes can be long.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "solution2": "hidden",
    "solution2_first": true
   },
   "outputs": [],
   "source": [
    "# Placeholder cell for exercise. Modify and run your code here.\n",
    "\n",
    "result = hybrid.KerberosSampler().sample(bqm, \n",
    "                                         max_iter=10, \n",
    "                                         qpu_params={'label': 'Notebook - Hybrid Computing 1'})\n",
    "print(\"Found solutions with energy\", result.record.energy)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "jupyter": {
     "source_hidden": true
    },
    "solution2": "hidden"
   },
   "outputs": [],
   "source": [
    "# Click here to see solution:\n",
    "result = hybrid.KerberosSampler().sample(bqm, \n",
    "                                         num_reads=3, \n",
    "                                         max_iter=10, \n",
    "                                         qpu_reads=100, \n",
    "                                         tabu_timeout=200,\n",
    "                                         qpu_params={'label': 'Notebook - Hybrid Computing 1'})\n",
    "print(\"Found solutions with energy {}.\".format(result.record.energy))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-success\" role=\"alert\" style=\"margin: 10px\"> \n",
    "    <b>Advanced Exercise</b>: Increase the size of the subproblems submitted to the QPU to 70 variables while ensuring that Kerberos selects a QPU with over 1800 qubits. Open the hidden code cell below it for a solution.\n",
    "\n",
    "<p> Hint: The <a href=\"https://docs.ocean.dwavesys.com/en/stable/docs_cloud/sdk_index.html\">D-Wave Cloud Client</a> <code>Client.get_solvers()</code> method handles filtering for feature-based selection of QPUs.</p>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "solution2": "hidden",
    "solution2_first": true
   },
   "outputs": [],
   "source": [
    "# Write and run your exercise code here:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "jupyter": {
     "source_hidden": true
    },
    "solution2": "hidden"
   },
   "outputs": [],
   "source": [
    "# Click here to see solution:\n",
    "from dwave.system import DWaveSampler\n",
    "\n",
    "sampler_qpu = DWaveSampler(solver={'num_qubits__gt':1800})\n",
    "\n",
    "result = hybrid.KerberosSampler().sample(bqm, max_iter=10, \n",
    "                                              max_subproblem_size=70,\n",
    "                                              qpu_sampler=sampler_qpu,\n",
    "                                              qpu_params={'label': 'Notebook - Hybrid Computing 1'})\n",
    "print(\"Found solution with {} nodes at energy {}.\".format(np.sum(result.record.sample), \n",
    "                                                                 result.first.energy))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Workflow: Parallel Tempering \n",
    "*dwave-hybrid* provides tested [reference workflows](https://docs.ocean.dwavesys.com/en/stable/docs_hybrid/reference/reference.html) that you can plug into your application code.  \n",
    "\n",
    "To simply use such workflows, it's sufficient to know that the *dwave-hybrid* workflows comprise two main types of components:\n",
    "\n",
    "* *State*-class components hold a problem, samples, and optionally additional information.\n",
    "* *Runnable*-class components take input states, run for an iteration, and output updated states. \n",
    "\n",
    "Workflows&mdash;which are themselves Runnables&mdash;input states representing a problem BQM and aim to produce states updated with samples that are good solutions to the problem or parts of it. Sometimes you may be in a position to provide initial samples with values better than random for your problem; for example, if you are intermittently running a very large problem, possibly on more than one solver, and saving intermediate results. Workflows may run for a single iteration or many iterations. \n",
    "\n",
    "The [Quantum-Classical Hybrid Computing: Workflows](02-hybrid-computing-workflows.ipynb) notebook dives into the details of *dwave-hybrid* workflows."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[Parallel Tempering (PT)](https://en.wikipedia.org/wiki/Parallel_tempering) runs a number of replicas of simulated annealing at different temperatures and swaps some low- and high-energy samples between replicas. In this way, a low-temperature replica injected with a high-energy sample might escape a local minimum.  \n",
    "\n",
    "In the next cell, an initial state is produced from the BQM by the `State.from_problem` utility and input into workflow `pt_workflow`, generated by `ParallelTempering`. The example calls two methods:\n",
    "\n",
    "*  Runnable [run()](https://docs.ocean.dwavesys.com/en/stable/docs_hybrid/reference/core.html) method to execute an iteration of the PT reference workflow (workflows are Runnables).  \n",
    "* State [result()](https://docs.ocean.dwavesys.com/en/stable/docs_hybrid/reference/core.html) method to resolve the result, which is returned in a [Future](https://docs.python.org/3/library/concurrent.futures.html#concurrent.futures.Future)-like object. \n",
    "\n",
    "Note: Because the default PT workflow results in long CPU runtimes on the example problem of this notebook, parameters are specified below for a shorter execution. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "state_start = hybrid.State.from_problem(bqm)\n",
    "\n",
    "pt_workflow = hybrid.ParallelTempering(num_replicas=3, max_iter=5)\n",
    "\n",
    "result = pt_workflow.run(state_start, max_time=4).result()\n",
    "print(\"Found solution with {} nodes at energy {}.\".format(np.sum(result.samples.record.sample),\n",
    "                                                          result.samples.first.energy))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Because the `KerberosSampler` of the [Sampler: Kerberos](#Sampler:-Kerberos) section is itself just a workflow, you can  replace `ParallelTempering` with the [Kerberos reference workflow](https://docs.ocean.dwavesys.com/en/stable/docs_hybrid/reference/reference.html), configuring the appropriate parameters, and run the Kerberos workflow directly instead. \n",
    "\n",
    "The [Quantum-Classical Hybrid Computing: Components](03-hybrid-computing-components.ipynb) notebook demonstrates how you can convert hybrid workflows into dimod samplers.   "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Configuring the Workflow\n",
    "<div class=\"alert alert-success\" role=\"alert\" style=\"margin: 10px\"> \n",
    "    <b>Exercise</b>: Try adjusting some workflow parameters and observing the effect on performance. Open the hidden code cell below it for a solution.\n",
    "    Remember that for large problems, CPU runtimes can be long.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "solution2": "hidden",
    "solution2_first": true
   },
   "outputs": [],
   "source": [
    "# Write and run your exercise code here:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "jupyter": {
     "source_hidden": true
    },
    "solution2": "hidden"
   },
   "outputs": [],
   "source": [
    "# Click here to see solution:\n",
    "result = pt_workflow.run(state_start, max_iter=1, max_time=7, num_sweeps=1000).result()\n",
    "print(\"Found solution with {} nodes at energy {}.\".format(np.sum(result.samples.record.sample), \n",
    "                                                                 result.samples.first.energy))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can try other implemented [reference workflows](https://docs.ocean.dwavesys.com/en/stable/docs_hybrid/reference/reference.html), such as hybridized PT and population annealing. In the [Quantum-Classical Hybrid Computing: Workflows](02-hybrid-computing-workflows.ipynb) notebook you will build your own such workflows to best fit your problem."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Operational Utilities\n",
    "This section demonstrates a few useful operational utilities that can help you understand and debug your code.\n",
    "\n",
    "## Structure\n",
    "The `print_structure` method prints the hybrid workflow's structure of nested components."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "hybrid.print_structure(pt_workflow)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Counters\n",
    "The `print_counters` method helps you examine the execution of a hybrid workflow. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "hybrid.print_counters(pt_workflow)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Logging\n",
    "The `logger.setLevel` method sets logging level as described under [Using the Framework](https://docs.ocean.dwavesys.com/en/stable/docs_hybrid/intro/using.html). \n",
    "\n",
    "*dwave-hybrid* supports logging levels TRACE, DEBUG, INFO, WARNING, ERROR, and CRITICAL in ascending order of severity. Try setting lower levels to learn what additional information you have available for understanding and debugging your hybrid application code.  \n",
    "\n",
    "Afterwards, return the logging level to ERROR (the default level) or to any level you prefer for the following notebooks. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "hybrid.logger.setLevel(hybrid.logging.INFO) \n",
    "\n",
    "result = pt_workflow.run(state_start, max_iter=1).result()\n",
    "\n",
    "print(\"Found solution with {} nodes at energy {}.\".format(np.sum(result.samples.record.sample), \n",
    "                                                                 result.samples.first.energy))\n",
    "hybrid.logger.setLevel(hybrid.logging.ERROR) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Copyright &copy; 2020 D-Wave Systems, Inc\n",
    "\n",
    "The software is licensed under the Apache License, Version 2.0 (the \"License\");\n",
    "you may not use this file except in compliance with the License.\n",
    "You may obtain a copy of the License at\n",
    "\n",
    "    http://www.apache.org/licenses/LICENSE-2.0\n",
    "\n",
    "Unless required by applicable law or agreed to in writing, software\n",
    "distributed under the License is distributed on an \"AS IS\" BASIS,\n",
    "WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n",
    "See the License for the specific language governing permissions and\n",
    "limitations under the License.\n",
    "\n",
    "<a rel=\"license\" href=\"http://creativecommons.org/licenses/by-nc-sa/4.0/\"><img alt=\"Creative Commons License\" style=\"border-width:0\" src=\"https://i.creativecommons.org/l/by-nc-sa/4.0/88x31.png\" /></a><br />This Jupyter Notebook is licensed under a <a rel=\"license\" href=\"http://creativecommons.org/licenses/by-nc-sa/4.0/\">Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License</a>"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "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.7.0"
  },
  "latex_envs": {
   "LaTeX_envs_menu_present": true,
   "autoclose": false,
   "autocomplete": true,
   "bibliofile": "biblio.bib",
   "cite_by": "apalike",
   "current_citInitial": 1,
   "eqLabelWithNumbers": true,
   "eqNumInitial": 1,
   "hotkeys": {
    "equation": "Ctrl-E",
    "itemize": "Ctrl-I"
   },
   "labels_anchors": false,
   "latex_user_defs": false,
   "report_style_numbering": false,
   "user_envs_cfg": false
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": false,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {
    "height": "calc(100% - 180px)",
    "left": "10px",
    "top": "150px",
    "width": "165px"
   },
   "toc_section_display": true,
   "toc_window_display": true
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}