class TabuProblemSampler(Runnable, traits.ProblemSampler):
"""A tabu sampler for a binary quadratic problem.
Args:
num_reads (int, optional, default=1):
Number of states (output solutions) to read from the sampler.
tenure (int, optional):
Tabu tenure, which is the length of the tabu list, or number of recently
explored solutions kept in memory. Default is a quarter of the number
of problem variables up to a maximum value of 20.
timeout (int, optional, default=20):
Total running time in milliseconds.
Examples:
See examples on https://docs.ocean.dwavesys.com/projects/hybrid/en/latest/reference/samplers.html#examples.
"""
def __init__(self, num_reads=1, tenure=None, timeout=20):
super(TabuProblemSampler, self).__init__()
self.num_reads = num_reads
self.tenure = tenure
self.timeout = timeout
self.sampler = TabuSampler()
def __repr__(self):
return ("{self}(num_reads={self.num_reads!r}, "
"tenure={self.tenure!r}, "
"timeout={self.timeout!r})").format(self=self)
def next(self, state):
sampleset = self.sampler.sample(state.problem,
init_solution=state.samples,
tenure=self.tenure,
timeout=self.timeout,
num_reads=self.num_reads)
return state.updated(samples=sampleset)
def tabu_sampler(self):
print("\nTabu Sampler....")
from tabu import TabuSampler
qpu = TabuSampler()
self.title = "Tabu Sampler"
selected_features = np.zeros((len(self.features), len(self.features)))
for k in range(1, len(self.features) + 1):
flag = False
print("Submitting for k={}".format(k))
kbqm = dimod.generators.combinations(self.features, k, strength=25)
kbqm.update(self.bqm)
kbqm.normalize()
while not flag:
result = qpu.sample(kbqm, num_reads=10)
# result = qpu.sample_ising(kbqm.to_ising()[0], kbqm.to_ising()[1], num_reads=10)
best = result.first.sample
if list(result.first.sample.values()).count(1) == k:
flag = True
for fi, f in enumerate(self.features):
selected_features[k - 1, fi] = best[f]
if self.is_notebook:
from helpers.draw import plot_feature_selection
from helpers.plots import plot_solutions
plot_feature_selection(self.features, selected_features,
self.title)
class TabuProblemSampler(traits.ProblemSampler, traits.SISO, Runnable):
"""A tabu sampler for a binary quadratic problem.
Args:
num_reads (int, optional, default=len(state.samples) or 1):
Number of states (output solutions) to read from the sampler.
tenure (int, optional):
Tabu tenure, which is the length of the tabu list, or number of
recently explored solutions kept in memory. Default is a quarter of
the number of problem variables up to a maximum value of 20.
timeout (int, optional, default=100):
Total running time in milliseconds.
initial_states_generator (str, 'none'/'tile'/'random', optional, default='random'):
Defines the expansion of input state samples into `initial_states`
for the Tabu search, if fewer than `num_reads` samples are
present. See :meth:`~tabu.TabuSampler.sample`.
See :ref:`samplers-examples`.
"""
def __init__(self,
num_reads=None,
tenure=None,
timeout=100,
initial_states_generator='random',
**runopts):
super(TabuProblemSampler, self).__init__(**runopts)
self.num_reads = num_reads
self.tenure = tenure
self.timeout = timeout
self.initial_states_generator = initial_states_generator
self.sampler = TabuSampler()
def __repr__(self):
return ("{self}(num_reads={self.num_reads!r}, "
"tenure={self.tenure!r}, "
"timeout={self.timeout!r}, "
"initial_states_generator={self.initial_states_generator!r})"
).format(self=self)
def next(self, state, **runopts):
sampleset = self.sampler.sample(
state.problem,
initial_states=state.samples,
initial_states_generator=self.initial_states_generator,
tenure=self.tenure,
timeout=self.timeout,
num_reads=self.num_reads)
return state.updated(samples=sampleset)
print(G.number_of_nodes(),
G.number_of_edges(),
bqm.num_variables,
len(f1),
len(f2),
len(f0),
end=' ')
# Choose one of the solvers below.
#sampler = SimulatedAnnealingSampler()
sampler = TabuSampler()
#sampler = EmbeddingComposite(DWaveSampler(solver={'qpu': True, 'postprocess': 'sampling'}))
#sampler = LeapHybridSampler()
# Conduct optimization
sampleset = sampler.sample(bqm)
print(sampleset.first.energy, end=' ')
# Summarize the results on the graph
GS = sample_graph(G, b, f0, sampleset.first.sample)
# Report violations
rep = report_graph(GS, G)
print(' '.join(str(x) for x in rep), end=' ')
# Report cycles
print(len(list(nx.simple_cycles(GS))))
# output