def convert_response(response):
if isinstance(response, openjij.Response):
return response
try:
from dimod.response import Response
from dimod.sampleset import SampleSet
except ImportError:
raise ImportError('Import dwave dimod : "pip install dimod"')
if isinstance(response, Response) or isinstance(response, SampleSet):
from dimod.vartypes import BINARY, SPIN
vartype = 'BINARY' if response.vartype == BINARY else 'SPIN'
o_res = openjij.Response(vartype=vartype, indices=list(response.variables))
states = []
energies = []
for rec in response.record:
for _ in range(rec[2]):
states.append(rec[0])
energies.append(rec[1])
o_res.update_ising_states_energies(states=states, energies=energies)
o_res.info = response.info
if 'qpu_sampling_time' in response.info:
o_res.info['sampling_time'] = response.info['qpu_sampling_time']
if 'anneal_time_per_run' in response.info:
o_res.info['execution_time'] = response.info['anneal_time_per_run']
o_res.info['dimod'] = response
return o_res
else:
raise TypeError('response is dimod.response.Response, SampleSet or openjij.Response')
def test_str_key_success_prob(self):
solutions = [{'a': 1, 'b': -1, 'c': -1}]
response = oj.Response(indices=['c', 'b', 'a'], var_type=oj.SPIN)
response.update_ising_states_energies(
states=[[-1, -1, 1], [1, -1, -1], [1, -1, -1]], energies=[0, 0, 0])
ps = oj.utils.success_probability(response, solutions)
self.assertEqual(ps, 1/3)
def _sampling(self,
model,
init_generator,
algorithm,
system,
initial_state=None,
reinitialize_state=True,
seed=None,
**kwargs):
self._sampling_kwargs_setting(**kwargs)
self._set_model(model)
# seed for MonteCarlo
if seed is None:
def sampling_algorithm(system):
return algorithm(system, self.schedule)
else:
def sampling_algorithm(system):
return algorithm(system, seed, self.schedule)
# run algorithm
execution_time = []
response = openjij.Response(var_type=model.var_type,
indices=self.indices)
@measure_time
def exec_sampling():
previous_state = init_generator()
for _ in range(self.iteration):
if reinitialize_state:
system.reset_spins(init_generator())
else:
system.reset_spins(previous_state)
_exec_time = measure_time(sampling_algorithm)(system)
execution_time.append(_exec_time)
previous_state = cxxjij.result.get_solution(system)
self._post_save(previous_state, system, model, response)
sampling_time = exec_sampling()
response.info['sampling_time'] = sampling_time * 10**6 # micro sec
response.info['execution_time'] = np.mean(
execution_time) * 10**6 # micro sec
response.info['list_exec_times'] = np.array(
execution_time) * 10**6 # micro sec
return response
def hubo_sa_sampling(bhom, var_type,
schedule, schedule_info,
num_sweeps=100, num_reads=1,
init_state=None, seed=None):
init_state = init_state if init_state else np.random.choice(
[1, -1], len(bhom.indices))
response = openjij.Response(
var_type=var_type, indices=bhom.indices
)
execution_time = []
@measure_time
def exec_sampling():
for _ in range(num_reads):
_exec_time, state = measure_time(
hubo_simulated_annealing)(bhom, init_state, schedule,
var_type=var_type)
execution_time.append(_exec_time)
response.states.append(state)
response.energies.append(bhom.calc_energy(state))
sampling_time, _ = exec_sampling()
response.info['sampling_time'] = sampling_time * 10**6 # micro sec
response.info['execution_time'] = np.mean(
execution_time) * 10**6 # micro sec
response.info['list_exec_times'] = np.array(
execution_time) * 10**6 # micro sec
response.update_ising_states_energies(
response.states, response.energies)
response.info['schedule'] = schedule_info
return response
def sampling(self, model,
initial_state=None, updater='single spin flip',
reinitilize_state=True, seed=None,
**kwargs):
self._sampling_kwargs_setting(**kwargs)
self._set_model(model)
ising_graph = model.get_cxxjij_ising_graph()
if initial_state is None:
if not reinitilize_state:
raise ValueError(
'You need initial_state if reinitilize_state is False.')
def _generate_init_state(): return ising_graph.gen_spin()
else:
if model.vartype == openjij.SPIN:
_init_state = np.array(initial_state)
else: # BINARY
_init_state = (2*np.array(initial_state)-1).astype(np.int)
def _generate_init_state(): return np.array(_init_state)
sa_system = cxxjij.system.make_classical_ising_Eigen(
_generate_init_state(), ising_graph)
# choose updater
_updater_name = updater.lower().replace('_', '').replace(' ', '')
if _updater_name == 'singlespinflip':
algorithm = cxxjij.algorithm.Algorithm_SingleSpinFlip_run
sa_system = cxxjij.system.make_classical_ising_Eigen(
_generate_init_state(), ising_graph)
elif _updater_name == 'swendsenwang':
# swendsen-wang is not support Eigen system
algorithm = cxxjij.algorithm.Algorithm_SwendsenWang_run
sa_system = cxxjij.system.make_classical_ising(
_generate_init_state(), ising_graph)
else:
raise ValueError(
'updater is one of "single spin flip or swendsen wang"')
# seed for MonteCarlo
if seed is None:
def simulated_annealing(system):
return algorithm(
system, self.schedule)
else:
def simulated_annealing(system): return algorithm(
system, seed, self.schedule)
states = []
energies = []
execution_time = []
@measure_time
def exec_sampling():
previous_state = _generate_init_state()
for _ in range(self.iteration):
if reinitilize_state:
sa_system.reset_spins(_generate_init_state())
else:
sa_system.reset_spins(previous_state)
_exec_time = measure_time(simulated_annealing)(sa_system)
execution_time.append(_exec_time)
previous_state = cxxjij.result.get_solution(sa_system)
states.append(previous_state)
energies.append(model.calc_energy(
previous_state,
need_to_convert_from_spin=True))
sampling_time = exec_sampling()
response = openjij.Response(
vartype=model.vartype, indices=self.indices)
response.update_ising_states_energies(states, energies)
response.info['sampling_time'] = sampling_time * \
10**6 # micro sec
response.info['execution_time'] = np.mean(
execution_time) * 10**6 # micro sec
response.info['list_exec_times'] = np.array(
execution_time) * 10**6 # micro sec
return response
def sample_hubo(self,
interactions: list,
var_type,
beta_min=None,
beta_max=None,
schedule=None,
num_sweeps=100,
num_reads=1,
init_state=None,
seed=None):
"""sampling from higher order unconstrainted binary optimization
Args:
interactions (list of dict): ordered by degree of interaction. [linear, quadratic, ...]
var_type (str, openjij.VarType): "SPIN" or "BINARY"
beta_min (float, optional): Minimum beta (initial inverse temperature). Defaults to None.
beta_max (float, optional): Maximum beta (final inverse temperature). Defaults to None.
schedule (list, optional): [description]. Defaults to None.
num_sweeps (int, optional): [description]. Defaults to 100.
num_reads (int, optional): [description]. Defaults to 1.
init_state (list, optional): initial state. Defaults to None.
seed (int, optional): [description]. Defaults to None.
Returns:
[type]: [description]
"""
self._setting_overwrite(beta_min=beta_min,
beta_max=beta_max,
num_sweeps=num_sweeps,
num_reads=num_reads)
bhom = BinaryHigherOrderModel(interactions)
if schedule or self.schedule:
self._schedule = self._convert_validation_schedule(
schedule if schedule else self.schedule)
self.schedule_info = {'schedule': 'custom schedule'}
else:
schedule = default_schedule(
bhom,
beta_min=self._schedule_setting['beta_min'],
beta_max=self._schedule_setting['beta_max'],
num_sweeps=self._schedule_setting['num_sweeps'])
self.schedule_info = {
'beta_max': schedule[-1][0],
'beta_min': schedule[0][0],
'num_sweeps': self._schedule_setting['num_sweeps']
}
init_state = init_state if init_state else np.random.choice(
[1, -1], len(bhom.indices))
response = openjij.Response(var_type=var_type, indices=bhom.indices)
execution_time = []
@measure_time
def exec_sampling():
for _ in range(num_reads):
_exec_time, state = measure_time(hubo_simulated_annealing)(
bhom, init_state, schedule, var_type=var_type)
execution_time.append(_exec_time)
response.states.append(state)
response.energies.append(bhom.calc_energy(state))
sampling_time, _ = exec_sampling()
response.info['sampling_time'] = sampling_time * 10**6 # micro sec
response.info['execution_time'] = np.mean(
execution_time) * 10**6 # micro sec
response.info['list_exec_times'] = np.array(
execution_time) * 10**6 # micro sec
response.update_ising_states_energies(response.states,
response.energies)
response.info['schedule'] = self.schedule_info
return response
def sampling(self, model,
initial_state=None, updater='single spin flip',
reinitilize_state=True, seed=None,
**kwargs):
self._sampling_kwargs_setting(**kwargs)
self._set_model(model)
ising_graph = model.get_cxxjij_ising_graph()
if initial_state is None:
if not reinitilize_state:
raise ValueError(
'You need initial_state if reinitilize_state is False.')
def _generate_init_state(): return [ising_graph.gen_spin()
for _ in range(self.trotter)]
else:
if model.var_type == openjij.SPIN:
trotter_init_state = [np.array(initial_state)
for _ in range(self.trotter)]
else: # BINARY
trotter_init_state = [
(2*np.array(initial_state)-1).astype(int)
for _ in range(self.trotter)]
def _generate_init_state(): return trotter_init_state
sqa_system = cxxjij.system.make_transverse_ising_Eigen(
_generate_init_state(), ising_graph, self.gamma
)
# choose updater
_updater_name = updater.lower().replace('_', '').replace(' ', '')
if _updater_name == 'singlespinflip':
algorithm = cxxjij.algorithm.Algorithm_SingleSpinFlip_run
else:
raise ValueError('updater is one of "single spin flip"')
# seed for MonteCarlo
if seed is None:
def sqa_algorithm(system): return algorithm(
system, self.schedule)
else:
def sqa_algorithm(system): return algorithm(
system, seed, self.schedule)
q_states = []
q_energies = []
execution_time = []
@measure_time
def exec_sampling():
# import pdb
# pdb.set_trace()
previous_state = _generate_init_state()
for _ in range(self.iteration):
if reinitilize_state:
sqa_system.reset_spins(_generate_init_state())
else:
sqa_system.reset_spins(previous_state)
_exec_time = measure_time(sqa_algorithm)(sqa_system)
execution_time.append(_exec_time)
# trotter_spins is transposed because it is stored as [Spin space][Trotter].
# [-1] is excluded because it is a tentative spin of s = 1 for convenience in SQA.
q_state = self._post_process4state(
sqa_system.trotter_spins[:-1].T)
q_energies.append(
[model.calc_energy(state,
need_to_convert_from_spin=True)
for state in q_state])
q_states.append(q_state.astype(np.int))
sampling_time = exec_sampling()
response = openjij.Response(
var_type=model.var_type, indices=self.indices)
response.update_trotter_ising_states_energies(q_states, q_energies)
response.info['sampling_time'] = sampling_time * \
10**6 # micro sec
response.info['execution_time'] = np.mean(
execution_time) * 10**6 # micro sec
response.info['list_exec_times'] = np.array(
execution_time) * 10**6 # micro sec
return response