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