def test_runnable_composition(self):
runnable = IdentityDecomposer() | HybridSubproblemRunnable(
TabuSampler()) | IdentityComposer()
response = runnable.run(self.init_state)
self.assertIsInstance(response, concurrent.futures.Future)
self.assertEqual(response.result().samples.record[0].energy, -3.0)
def next(self, state):
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,
import dimod
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 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(),
IdentityDecomposer()
| SimulatedAnnealingSubproblemSampler(num_reads=sa_reads,
sweeps=sa_sweeps)
| SplatComposer(),
EnergyImpactDecomposer(
size=subproblem_size, rolling=True, rolling_history=0.2)
| 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)