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(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))
# Solution: sample=Sample(sample={'a': 1, 'b': -1, 'c': -1}, energy=-3.0, num_occurrences=1)
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))
response = QBSolv().sample(state.problem, solver=self.sampler)
return state.updated(samples=response)
problems = chain(
sorted(glob('problems/qbsolv/bqp100_*'))[:5],
sorted(glob('problems/qbsolv/bqp2500_*'))[:5],
sorted(glob('problems/random-chimera/2048*'))[:5],
sorted(glob('problems/random-chimera/8192*'))[:5],
sorted(glob('problems/ac3/*'))[:5],
)
solver_factories = [
("10 second Tabu", lambda **kw: TabuProblemSampler(timeout=10000)),
("10k sweeps Simulated Annealing", lambda **kw: IdentityDecomposer() |
SimulatedAnnealingSubproblemSampler(sweeps=10000) | SplatComposer()),
("qbsolv-like solver", lambda qpu, **kw: Loop(RacingBranches(
InterruptableTabuSampler(quantum_timeout=200),
EnergyImpactDecomposer(max_size=50, rolling=True, rolling_history=0.15)
| QPUSubproblemAutoEmbeddingSampler(qpu_sampler=qpu)
| SplatComposer()) | ArgMin(),
max_iter=100,
convergence=10)),
("tiling chimera solver", lambda qpu, **kw: Loop(RacingBranches(
InterruptableTabuSampler(quantum_timeout=200),
TilingChimeraDecomposer(size=(16, 16, 4))
| QPUSubproblemExternalEmbeddingSampler(qpu_sampler=qpu)
| SplatComposer(),
) | ArgMin(),
max_iter=100,
convergence=10)),
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(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()