Source code for dwave.system.composites.reversecomposite

# Copyright 2019 D-Wave Systems Inc.
#
#    Licensed under the Apache License, Version 2.0 (the "License");
#    you may not use this file except in compliance with the License.
#    You may obtain a copy of the License at
#
#        http://www.apache.org/licenses/LICENSE-2.0
#
#    Unless required by applicable law or agreed to in writing, software
#    distributed under the License is distributed on an "AS IS" BASIS,
#    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
#    See the License for the specific language governing permissions and
#    limitations under the License.

"""
Composites that do batch operations for reverse annealing.
"""

import collections.abc as abc

import dimod
import numpy as np

__all__ = ['ReverseAdvanceComposite', 'ReverseBatchStatesComposite']


[docs]class ReverseAdvanceComposite(dimod.ComposedSampler): """ Composite that reverse anneals an initial sample through a sequence of anneal schedules. If you do not specify an initial sample, a random sample is used for the first submission. By default, each subsequent submission selects the most-found lowest-energy sample as its initial state. If you set reinitialize_state to False, which makes each submission behave like a random walk, the subsequent submission selects the last returned sample as its initial state. Args: sampler (:obj:`dimod.Sampler`): A dimod sampler. Examples: This example runs 100 reverse anneals each for three schedules on a problem constructed by setting random :math:`\pm 1` values on a clique (complete graph) of 15 nodes, minor-embedded on a D-Wave system using the :class:`.DWaveCliqueSampler` sampler. >>> import dimod >>> from dwave.system import DWaveCliqueSampler, ReverseAdvanceComposite ... >>> sampler = DWaveCliqueSampler() # doctest: +SKIP >>> sampler_reverse = ReverseAdvanceComposite(sampler) # doctest: +SKIP >>> schedule = [[[0.0, 1.0], [t, 0.5], [20, 1.0]] for t in (5, 10, 15)] ... >>> bqm = dimod.generators.ran_r(1, 15) >>> init_samples = {i: -1 for i in range(15)} >>> sampleset = sampler_reverse.sample(bqm, ... anneal_schedules=schedule, ... initial_state=init_samples, ... num_reads=100, ... reinitialize_state=True) # doctest: +SKIP """ def __init__(self, child_sampler): self._children = [child_sampler] @property def children(self): return self._children @property def parameters(self): param = self.child.parameters.copy() param['schedules'] = [] return param @property def properties(self): return {'child_properties': self.child.properties.copy()}
[docs] def sample(self, bqm, anneal_schedules=None, **parameters): """Sample the binary quadratic model using reverse annealing along a given set of anneal schedules. Args: bqm (:obj:`dimod.BinaryQuadraticModel`): Binary quadratic model to be sampled from. anneal_schedules (list of lists, optional, default=[[[0, 1], [1, 0.35], [9, 0.35], [10, 1]]]): Anneal schedules in order of submission. Each schedule is formatted as a list of [time, s] pairs, in which time is in microseconds and s is the normalized persistent current in the range [0,1]. initial_state (dict, optional): The state to reverse anneal from. If not provided, it will be randomly generated. **parameters: Parameters for the sampling method, specified by the child sampler. Returns: :obj:`dimod.SampleSet` that has initial_state and schedule_index fields. Examples: This example runs 100 reverse anneals each for three schedules on a problem constructed by setting random :math:`\pm 1` values on a clique (complete graph) of 15 nodes, minor-embedded on a D-Wave system using the :class:`.DWaveCliqueSampler` sampler. >>> import dimod >>> from dwave.system import DWaveCliqueSampler, ReverseAdvanceComposite ... >>> sampler = DWaveCliqueSampler() # doctest: +SKIP >>> sampler_reverse = ReverseAdvanceComposite(sampler) # doctest: +SKIP >>> schedule = [[[0.0, 1.0], [t, 0.5], [20, 1.0]] for t in (5, 10, 15)] ... >>> bqm = dimod.generators.ran_r(1, 15) >>> init_samples = {i: -1 for i in range(15)} >>> sampleset = sampler_reverse.sample(bqm, ... anneal_schedules=schedule, ... initial_state=init_samples, ... num_reads=100, ... reinitialize_state=True) # doctest: +SKIP """ child = self.child if anneal_schedules is None: anneal_schedules = [[[0, 1], [1, 0.35], [9, 0.35], [10, 1]]] vartype_values = list(bqm.vartype.value) if 'initial_state' not in parameters: initial_state = dict(zip(list(bqm.variables), np.random.choice(vartype_values, len(bqm)))) else: initial_state = parameters.pop('initial_state') if not isinstance(initial_state, abc.Mapping): raise TypeError("initial state provided must be a dict, but received {}".format(initial_state)) if 'reinitialize_state' not in parameters: parameters['reinitialize_state'] = True if "answer_mode" in child.parameters: parameters['answer_mode'] = 'histogram' samplesets = None for schedule_idx, anneal_schedule in enumerate(anneal_schedules): sampleset = child.sample(bqm, anneal_schedule=anneal_schedule, initial_state=initial_state, **parameters) initial_state, _ = dimod.as_samples(initial_state) if 'initial_state' not in sampleset.record.dtype.names: init_state_vect = [] if parameters['reinitialize_state']: init_state_vect = [initial_state[0].copy() for i in range(len(sampleset.record.energy))] else: # each sample is the next sample's initial state init_state_vect.append(initial_state[0].copy()) for sample in sampleset.record.sample[:-1]: init_state_vect.append(sample) sampleset = dimod.append_data_vectors(sampleset, initial_state=init_state_vect) if 'schedule_index' not in sampleset.record.dtype.names: schedule_index_vect = [schedule_idx] * len(sampleset.record.energy) sampleset = dimod.append_data_vectors(sampleset, schedule_index=schedule_index_vect) if samplesets is None: samplesets = sampleset else: samplesets = dimod.concatenate((samplesets, sampleset)) if schedule_idx+1 == len(anneal_schedules): # no need to create the next initial state - last iteration break # prepare the initial state for the next iteration if parameters['reinitialize_state']: # if reinitialize is on, choose the lowest energy, most probable state for next iteration ground_state_energy = sampleset.first.energy lowest_energy_samples = sampleset.record[sampleset.record.energy == ground_state_energy] lowest_energy_samples.sort(order='num_occurrences') initial_state = dict(zip(sampleset.variables, lowest_energy_samples[-1].sample)) else: # if not reinitialized, take the last state as the next initial state initial_state = dict(zip(sampleset.variables, sampleset.record.sample[-1])) samplesets.info['anneal_schedules'] = anneal_schedules return samplesets
[docs]class ReverseBatchStatesComposite(dimod.ComposedSampler, dimod.Initialized): """Composite that reverse anneals from multiple initial samples. Each submission is independent from one another. Args: sampler (:obj:`dimod.Sampler`): A dimod sampler. Examples: This example runs 100 reverse anneals each from two initial states on a problem constructed by setting random :math:`\pm 1` values on a clique (complete graph) of 15 nodes, minor-embedded on a D-Wave system using the :class:`.DWaveCliqueSampler` sampler. >>> import dimod >>> from dwave.system import DWaveCliqueSampler, ReverseBatchStatesComposite ... >>> sampler = DWaveCliqueSampler() # doctest: +SKIP >>> sampler_reverse = ReverseBatchStatesComposite(sampler) # doctest: +SKIP >>> schedule = [[0.0, 1.0], [10.0, 0.5], [20, 1.0]] ... >>> bqm = dimod.generators.ran_r(1, 15) >>> init_samples = [{i: -1 for i in range(15)}, {i: 1 for i in range(15)}] >>> sampleset = sampler_reverse.sample(bqm, ... anneal_schedule=schedule, ... initial_states=init_samples, ... num_reads=100, ... reinitialize_state=True) # doctest: +SKIP """ def __init__(self, child_sampler): self._children = [child_sampler] @property def children(self): return self._children @property def parameters(self): param = self.child.parameters.copy() param['initial_states'] = [] return param @property def properties(self): return {'child_properties': self.child.properties.copy()}
[docs] def sample(self, bqm, initial_states=None, initial_states_generator='random', num_reads=None, seed=None, **parameters): """Sample the binary quadratic model using reverse annealing from multiple initial states. Args: bqm (:obj:`dimod.BinaryQuadraticModel`): Binary quadratic model to be sampled from. initial_states (samples-like, optional, default=None): One or more samples, each defining an initial state for all the problem variables. If fewer than `num_reads` initial states are defined, additional values are generated as specified by `initial_states_generator`. See :func:`dimod.as_samples` for a description of "samples-like". initial_states_generator ({'none', 'tile', 'random'}, optional, default='random'): Defines the expansion of `initial_states` if fewer than `num_reads` are specified: * "none": If the number of initial states specified is smaller than `num_reads`, raises ValueError. * "tile": Reuses the specified initial states if fewer than `num_reads` or truncates if greater. * "random": Expands the specified initial states with randomly generated states if fewer than `num_reads` or truncates if greater. num_reads (int, optional, default=len(initial_states) or 1): Equivalent to number of desired initial states. If greater than the number of provided initial states, additional states will be generated. If not provided, it is selected to match the length of `initial_states`. If `initial_states` is not provided, `num_reads` defaults to 1. seed (int (32-bit unsigned integer), optional): Seed to use for the PRNG. Specifying a particular seed with a constant set of parameters produces identical results. If not provided, a random seed is chosen. **parameters: Parameters for the sampling method, specified by the child sampler. Returns: :obj:`dimod.SampleSet` that has initial_state field. Examples: This example runs 100 reverse anneals each from two initial states on a problem constructed by setting random :math:`\pm 1` values on a clique (complete graph) of 15 nodes, minor-embedded on a D-Wave system using the :class:`.DWaveCliqueSampler` sampler. >>> import dimod >>> from dwave.system import DWaveCliqueSampler, ReverseBatchStatesComposite ... >>> sampler = DWaveCliqueSampler() # doctest: +SKIP >>> sampler_reverse = ReverseBatchStatesComposite(sampler) # doctest: +SKIP >>> schedule = [[0.0, 1.0], [10.0, 0.5], [20, 1.0]] ... >>> bqm = dimod.generators.ran_r(1, 15) >>> init_samples = [{i: -1 for i in range(15)}, {i: 1 for i in range(15)}] >>> sampleset = sampler_reverse.sample(bqm, ... anneal_schedule=schedule, ... initial_states=init_samples, ... num_reads=100, ... reinitialize_state=True) # doctest: +SKIP """ child = self.child parsed = self.parse_initial_states(bqm, initial_states=initial_states, initial_states_generator=initial_states_generator, num_reads=num_reads, seed=seed) parsed_initial_states = np.ascontiguousarray(parsed.initial_states.record.sample) # there is gonna be way too much data generated - better to histogram them if possible if 'answer_mode' in child.parameters: parameters['answer_mode'] = 'histogram' # reduce number of network calls if possible by aggregating init states if 'num_reads' in child.parameters: aggreg = parsed.initial_states.aggregate() parsed_initial_states = np.ascontiguousarray(aggreg.record.sample) parameters['num_reads'] = aggreg.record.num_occurrences samplesets = None for initial_state in parsed_initial_states: sampleset = child.sample(bqm, initial_state=dict(zip(bqm.variables, initial_state)), **parameters) if 'initial_state' not in sampleset.record.dtype.names: init_state_vect = [initial_state.copy() for i in range(len(sampleset.record.energy))] sampleset = dimod.append_data_vectors(sampleset, initial_state=init_state_vect) if samplesets is None: samplesets = sampleset else: samplesets = dimod.concatenate((samplesets, sampleset)) return samplesets