def test_look_and_feel(self):
fold = ArgMin(key=False)
self.assertEqual(fold.name, 'ArgMin')
self.assertEqual(str(fold), '[]>')
self.assertEqual(repr(fold), "ArgMin(key=False)")
fold = ArgMin(key=min)
self.assertEqual(repr(fold), "ArgMin(key=<built-in function min>)")
def test_custom_fold(self):
bqm = dimod.BinaryQuadraticModel({'a': 1}, {}, 0, dimod.SPIN)
states = States(
State.from_sample(min_sample(bqm), bqm), # energy: -1
State.from_sample(max_sample(bqm), bqm), # energy: +1
)
fold = ArgMin(key=lambda s: -s.samples.first.energy)
best = fold.run(states).result()
self.assertEqual(best.samples.first.energy, 1)
def test_iter_walk(self):
flow = Loop(RacingBranches(Runnable(), Runnable()) | ArgMin())
names = [r.name for r in iter_inorder(flow)]
self.assertEqual(names, [
'Loop', 'Branch', 'RacingBranches', 'Runnable', 'Runnable',
'ArgMin'
])
def test_default_fold(self):
bqm = dimod.BinaryQuadraticModel({'a': 1}, {}, 0, dimod.SPIN)
states = States(
State.from_sample(min_sample(bqm), bqm), # energy: -1
State.from_sample(max_sample(bqm), bqm), # energy: +1
)
best = ArgMin().run(states).result()
self.assertEqual(best.samples.first.energy, -1)
def test_callback_walk(self):
flow = Loop(RacingBranches(Runnable(), Runnable()) | ArgMin())
names = []
walk_inorder(flow, visit=lambda r, _: names.append(r.name))
self.assertEqual(names, [
'Loop', 'Branch', 'RacingBranches', 'Runnable', 'Runnable',
'ArgMin'
])
def test_branch(self):
class Inc(Runnable):
def next(self, state):
return state.updated(cnt=state.cnt + 1)
states = States(State(cnt=1), State(cnt=2))
branch = Map(Inc()) | ArgMin('cnt')
result = branch.run(states).result()
self.assertEqual(result.cnt, states[0].cnt + 1)
def test_dimensions_match_on_compose(self):
class A(Runnable, traits.ProblemSampler):
def next(self, state):
pass
# dimensionality check
Map(A()) | ArgMin()
with self.assertRaises(TypeError):
A() | ArgMin()
with self.assertRaises(TypeError):
ArgMin() | Map(A())
with self.assertRaises(TypeError):
ArgMin() | Map(ArgMin())
with self.assertRaises(TypeError):
Loop(ArgMin())
import dimod
from hybrid.samplers import (QPUSubproblemAutoEmbeddingSampler,
InterruptableTabuSampler)
from hybrid.decomposers import EnergyImpactDecomposer
from hybrid.composers import SplatComposer
from hybrid.core import State
from hybrid.flow import RacingBranches, ArgMin, Loop
from hybrid.utils import min_sample
# load a problem
problem = sys.argv[1]
with open(problem) as fp:
bqm = dimod.BinaryQuadraticModel.from_coo(fp)
# define the solver
iteration = RacingBranches(
InterruptableTabuSampler(),
EnergyImpactDecomposer(max_size=50, rolling=True, rolling_history=0.15)
| QPUSubproblemAutoEmbeddingSampler()
| SplatComposer()) | ArgMin()
main = Loop(iteration, max_iter=10, convergence=3)
# run solver
init_state = State.from_sample(min_sample(bqm), bqm)
solution = main.run(init_state).result()
# show results
print("Solution: sample={s.samples.first}".format(s=solution))
import dimod
from hybrid.samplers import (QPUSubproblemAutoEmbeddingSampler,
TabuProblemSampler, InterruptableTabuSampler)
from hybrid.decomposers import EnergyImpactDecomposer
from hybrid.composers import SplatComposer
from hybrid.core import State, SampleSet
from hybrid.flow import RacingBranches, ArgMin, Loop
from hybrid.utils import min_sample, max_sample, random_sample
problem = sys.argv[1]
with open(problem) as fp:
bqm = dimod.BinaryQuadraticModel.from_coo(fp)
# Run Tabu in parallel with QPU, but post-process QPU samples with very short Tabu
iteration = RacingBranches(
InterruptableTabuSampler(),
EnergyImpactDecomposer(size=50)
| QPUSubproblemAutoEmbeddingSampler(num_reads=100)
| SplatComposer()
| TabuProblemSampler(timeout=1)) | ArgMin()
main = Loop(iteration, max_iter=10, convergence=3)
init_state = State.from_sample(min_sample(bqm), bqm)
solution = main.run(init_state).result()
print("Solution: energy={s.samples.first.energy}".format(s=solution))
from hybrid.samplers import (SimulatedAnnealingSubproblemSampler,
TabuSubproblemSampler, InterruptableTabuSampler)
from hybrid.decomposers import EnergyImpactDecomposer, IdentityDecomposer
from hybrid.composers import SplatComposer
from hybrid.core import State
from hybrid.flow import RacingBranches, ArgMin, Loop
from hybrid.utils import min_sample
problem = sys.argv[1]
with open(problem) as fp:
bqm = dimod.BinaryQuadraticModel.from_coo(fp)
iteration = RacingBranches(
IdentityDecomposer() | SimulatedAnnealingSubproblemSampler()
| SplatComposer(),
EnergyImpactDecomposer(max_size=50)
| RacingBranches(SimulatedAnnealingSubproblemSampler(sweeps=1000),
TabuSubproblemSampler(tenure=20, timeout=10),
endomorphic=False)
| ArgMin(operator.attrgetter('subsamples.first.energy'))
| SplatComposer()) | ArgMin()
main = Loop(iteration, max_iter=10, convergence=3)
init_state = State.from_sample(min_sample(bqm), bqm)
solution = main.run(init_state).result()
print("Solution: energy={s.samples.first.energy}".format(s=solution))
def test_argmin(self):
self.assertEqual(self.children(ArgMin()), [])
def sample(self,
bqm,
init_sample=None,
max_iter=100,
convergence=10,
num_reads=1,
sa_reads=1,
sa_sweeps=1000,
qpu_reads=100,
qpu_sampler=None,
max_subproblem_size=50):
"""Run Tabu search, Simulated annealing and QPU subproblem sampling (for
high energy impact problem variables) in parallel and return the best
samples.
Args:
bqm (:obj:`~dimod.BinaryQuadraticModel`):
Binary quadratic model to be sampled from.
init_sample (:class:`~dimod.SampleSet`, callable, ``None``):
Initial sample set (or sample generator) used for each "read".
Use a random sample for each read by default.
max_iter (int):
Number of iterations in the hybrid algorithm.
convergence (int):
Number of iterations with no improvement that terminates sampling.
num_reads (int):
Number of reads. Each sample is the result of a single run of the
hybrid algorithm.
sa_reads (int):
Number of reads in the simulated annealing branch.
sa_sweeps (int):
Number of sweeps in the simulated annealing branch.
qpu_reads (int):
Number of reads in the QPU branch.
qpu_sampler (:class:`dimod.Sampler`, optional, default=DWaveSampler()):
Quantum sampler such as a D-Wave system.
max_subproblem_size (int):
Maximum size of the subproblem selected in the QPU branch.
Returns:
:obj:`~dimod.SampleSet`: A `dimod` :obj:`.~dimod.SampleSet` object.
"""
if callable(init_sample):
init_state_gen = lambda: State.from_sample(init_sample(), bqm)
elif init_sample is None:
init_state_gen = lambda: State.from_sample(random_sample(bqm), bqm)
elif isinstance(init_sample, dimod.SampleSet):
init_state_gen = lambda: State.from_sample(init_sample, bqm)
else:
raise TypeError(
"'init_sample' should be a SampleSet or a SampleSet generator")
subproblem_size = min(len(bqm), max_subproblem_size)
iteration = RacingBranches(
InterruptableTabuSampler(),
InterruptableSimulatedAnnealingProblemSampler(num_reads=sa_reads,
sweeps=sa_sweeps),
EnergyImpactDecomposer(size=subproblem_size,
rolling=True,
rolling_history=0.3,
traversal='bfs')
| QPUSubproblemAutoEmbeddingSampler(num_reads=qpu_reads,
qpu_sampler=qpu_sampler)
| SplatComposer(),
) | ArgMin()
self.runnable = Loop(iteration,
max_iter=max_iter,
convergence=convergence)
samples = []
energies = []
for _ in range(num_reads):
init_state = init_state_gen()
final_state = self.runnable.run(init_state)
# the best sample from each run is one "read"
ss = final_state.result().samples
ss.change_vartype(bqm.vartype, inplace=True)
samples.append(ss.first.sample)
energies.append(ss.first.energy)
return dimod.SampleSet.from_samples(samples,
vartype=bqm.vartype,
energy=energies)
#!/usr/bin/python
# -*- coding : utf -8 -*-
#
import dimod
from hybrid.samplers import (
QPUSubproblemAutoEmbeddingSampler, InterruptableTabuSampler)
from hybrid.decomposers import EnergyImpactDecomposer
from hybrid.composers import SplatComposer
from hybrid.core import State
from hybrid.flow import RacingBranches, ArgMin, Loop
from hybrid.utils import min_sample
# Construct a problem
bqm = dimod.BinaryQuadraticModel({}, {'ab': 1, 'bc': -1, 'ca': 1}, 0, dimod.SPIN)
# Define the solver
iteration = RacingBranches(
InterruptableTabuSampler(),
EnergyImpactDecomposer(max_size=2)
| QPUSubproblemAutoEmbeddingSampler()
| SplatComposer()
) | ArgMin()
main = Loop(iteration, max_iter=10, convergence=3)
# Solve the problem
init_state = State.from_sample(min_sample(bqm), bqm)
solution = main.run(init_state).result()
# Print results
print("Solution: sample={s.samples.first}".format(s=solution))
from hybrid.composers import SplatComposer
from hybrid.core import State
from hybrid.flow import RacingBranches, ArgMin, Loop
from hybrid.utils import min_sample
problem = sys.argv[1]
with open(problem) as fp:
bqm = dimod.BinaryQuadraticModel.from_coo(fp)
iteration = RacingBranches(
IdentityDecomposer() | SimulatedAnnealingSubproblemSampler() | SplatComposer(),
EnergyImpactDecomposer(size=50)
| RacingBranches(
SimulatedAnnealingSubproblemSampler(sweeps=1000),
TabuSubproblemSampler(tenure=20, timeout=10),
endomorphic=False
)
| ArgMin(operator.attrgetter('subsamples.first.energy'))
| SplatComposer()
) | ArgMin()
main = Loop(iteration, max_iter=10, convergence=3)
init_state = State.from_sample(min_sample(bqm), bqm)
solution = main.run(init_state).result()
print("Solution: energy={s.samples.first.energy}".format(s=solution))
