fix

Author: yuyamashiro

CMakeLists.txt

@@ -36,7 +36,7 @@ if(NOT DEFINED USE_CUDA)
     if(CMAKE_CUDA_COMPILER)
         enable_language(CUDA)
         set(USE_CUDA ${DEFAULT_USE_CUDA})
-		message(STATUS "CUDA Support")
+
         #for cuda-memcheck
         set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} -lineinfo")
         # set CXX compiler to nvcc host compiler in order to avoid linker error
@@ -63,7 +63,5 @@ endif()
 
 
 add_subdirectory(src)
-
 add_subdirectory(openjij)
-add_subdirectory(tests)
-
+add_subdirectory(tests)

openjij/sampler/__init__.py

@@ -1,6 +1,6 @@
-from .response import Response
 from .sampler import *
 from .sa_sampler import SASampler
 from .sqa_sampler import SQASampler
 from .gpu_sampler import *
 from .cmos_annealer import *
+from .response import *

openjij/sampler/cmos_annealer.py

@@ -15,13 +15,11 @@
 import requests
 import json
 
-from openjij.sampler import BaseSampler
-from openjij.sampler import Response
+from openjij.sampler import BaseSampler, Response
 from openjij.model import KingGraph
 
 import numpy as np
 
-
 class CMOSAnnealer(BaseSampler):
     """Sampler with CMOS Annealer.
 
@@ -70,18 +68,18 @@ class CMOSAnnealer(BaseSampler):
     """
 
     def __init__(self, token, machine_type="ASIC", beta_min=0.1, beta_max=5.0, step_length=10, step_num=100, iteration=1, **kwargs):
-
+        
         self.token = token
         self.machine_type = machine_type
-
+        
         self.cmos_parameters = {"temperature_num_steps": step_num,
                                 "temperature_step_length": step_length,
                                 "temperature_initial": 1/beta_min,
                                 "temperature_target": 1/beta_max,
                                 "num_executions": iteration}
-
+        
         self.cmos_parameters.update(kwargs)
-
+        
     def sample_ising(self, h=None, J=None, king_graph=None):
         """Sample from the specified Ising model.
 
@@ -116,12 +114,10 @@ def sample_ising(self, h=None, J=None, king_graph=None):
 
         var_type = 'SPIN'
         if king_graph is not None:
-            _king_graph = KingGraph(
-                machine_type=self.machine_type, king_graph=king_graph, var_type=var_type)
+            _king_graph = KingGraph(machine_type=self.machine_type, king_graph=king_graph, var_type=var_type)
             return self._sampling(_king_graph, var_type=var_type, token=self.token)
         elif (h is not None) and (J is not None):
-            _king_graph = KingGraph(
-                machine_type=self.machine_type, h=h, J=J, var_type=var_type)
+            _king_graph = KingGraph(machine_type=self.machine_type, h=h, J=J, var_type=var_type)
             return self._sampling(_king_graph, var_type=var_type, token=self.token)
         else:
             raise ValueError('intput "h and J" or king_graph model')
@@ -157,54 +153,48 @@ def sample_qubo(self, Q=None, king_graph=None):
 
         var_type = 'BINARY'
         if king_graph is not None:
-            _king_graph = KingGraph(
-                machine_type=self.machine_type, king_graph=king_graph, var_type=var_type)
+            _king_graph = KingGraph(machine_type=self.machine_type, king_graph=king_graph, var_type=var_type)
             return self._sampling(_king_graph, var_type=var_type, token=self.token)
         elif Q is not None:
-            _king_graph = KingGraph(
-                machine_type=self.machine_type, Q=Q, var_type=var_type)
+            _king_graph = KingGraph(machine_type=self.machine_type, Q=Q, var_type=var_type)
             return self._sampling(_king_graph, var_type=var_type, token=self.token)
         else:
             raise ValueError('intput Q or king_graph model')
 
+    
     def _sampling(self, king_graph, var_type, token):
         indices = king_graph.indices
         response = Response(var_type=var_type, indices=indices)
-        headers, request = self.make_json_request(
-            king_graph.get_ising_king_graph(), token)
-
+        headers, request = self.make_json_request(king_graph.get_ising_king_graph(), token)
+        
         url = 'https://annealing-cloud.com/api/v2/solve'
         res = requests.post(url, data=json.dumps(request), headers=headers)
         res_dict = res.json()
-
+        
         if res_dict['status'] != 0:
-            raise ValueError('Error status: {}, message: {}'.format(
-                res_dict['status'], res_dict['message']))
-
+            raise ValueError('Error status: {}, message: {}'.format(res_dict['status'], res_dict['message']))
+            
         if var_type == "SPIN":
-            response.states = [[s for x, y, s in spins]
-                               for spins in res_dict['result']['spins']]
-        else:  # qubo
-            response.states = [[int((s+1)/2) for x, y, s in spins]
-                               for spins in res_dict['result']['spins']]
-        response.indices = [king_graph.convert_to_index(
-            x, y) for x, y, s in res_dict['result']['spins'][0]]
-        response.energies = np.array(
-            res_dict['result']['energies']) + king_graph.energy_bias
+            response.states = [[s for x, y, s in spins] for spins in res_dict['result']['spins']]
+        else: #qubo
+            response.states = [[int((s+1)/2) for x, y, s in spins] for spins in res_dict['result']['spins']]
+        response.indices = [king_graph.convert_to_index(x, y) for x, y, s in res_dict['result']['spins'][0]]
+        response.energies = np.array(res_dict['result']['energies']) + king_graph.energy_bias
+
 
         # more infomation see : https://annealing-cloud.com/web-api/reference/v2.html
         response.info = {
             "averaged_spins": res_dict['result']["averaged_spins"],
             "averaged_energy": res_dict['result']["averaged_energy"],
-            'execution_time': res_dict['result']['execution_time'] * 10**(-3),
+            'execution_time' : res_dict['result']['execution_time'] * 10**(-3),
             'job_id': res_dict['job_id'],
         }
-
+        
         return response
-
+    
     def make_json_request(self, model, token):
         """Make request for CMOS Annealer API.
-
+ 
         Args:
             model (list):
                 A list of 5 integer values representing vertices
@@ -216,22 +206,22 @@ def make_json_request(self, model, token):
         """
 
         headers = {"Authorization": "Bearer " + token}
-        headers.update({"Accept": "application/json"})
-        headers.update({'content-type': 'application/json'})
+        headers.update({ "Accept": "application/json" })
+        headers.update({ 'content-type': 'application/json' })
 
         request = {}
-        request["model"] = model  # modelのみ必須項目
-        request["type"] = 1 if self.machine_type == "ASIC" else 2  # FPGA
+        request["model"] = model # modelのみ必須項目
+        request["type"] = 1 if self.machine_type == "ASIC" else 2 # FPGA
         request["num_executions"] = self.cmos_parameters["num_executions"]
         request["parameter"] = {"temperature_num_steps": self.cmos_parameters["temperature_num_steps"],
-                                "temperature_step_length": self.cmos_parameters['temperature_step_length'],
-                                "temperature_initial": self.cmos_parameters['temperature_initial'],
-                                "temperature_target": self.cmos_parameters["temperature_target"]}
+                                                    "temperature_step_length": self.cmos_parameters['temperature_step_length'],
+                                                    "temperature_initial": self.cmos_parameters['temperature_initial'],
+                                                    "temperature_target": self.cmos_parameters["temperature_target"]}
         request["outputs"] = {"energies": True,
-                              "spins": True,
-                              "execution_time": True,
-                              "num_outputs": 0,
-                              "averaged_spins": True,
-                              "averaged_energy": True}
+                                                "spins": True,
+                                                "execution_time": True,
+                                                "num_outputs": 0,
+                                                "averaged_spins": True,
+                                                "averaged_energy": True}
 
         return headers, request

openjij/sampler/gpu_sampler.py

@@ -16,6 +16,7 @@
 import openjij
 from openjij.sampler import SQASampler
 from openjij.model import BinaryQuadraticModel, ChimeraModel
+from openjij import Response
 import numpy as np
 
 
@@ -100,10 +101,7 @@ def _post_process4state(self, q_state):
 
         return [list(np.array(state)[indices]) for state in q_state]
 
-    def sampling(self, model,
-                 initial_state=None,
-                 reinitialize_state=True, seed=None,
-                 **kwargs):
+    def sampling(self, model, **kwargs):
         # Check the system for GPU is compiled
         try:
             self.system_class = cxxjij.system.ChimeraTransverseGPU

openjij/sampler/response.py

@@ -61,8 +61,8 @@ def __init__(self, var_type, indices):
     def __repr__(self):
         if len(self.states) == 0:
             return "Response\n\tvar_type: {}\n\tstates: empty".format(self.var_type)
-
-        if len(self.min_samples) == 0:
+        
+        if len(min_samples) == 0:
             self.min_samples = self._minimum_sample()
         min_energy_index = np.argmin(self.energies) if len(
             self.energies) != 0 else None

openjij/sampler/sa_sampler.py

@@ -203,14 +203,14 @@ def sample_qubo(self, Q,
 
     def sampling(self, model,
                  initial_state=None, updater='single spin flip',
-                 reinitialize_state=True, seed=None,
+                 reinitilize_state=True, seed=None,
                  **kwargs):
-
+        self._sampling_kwargs_setting(**kwargs)
+        self._set_model(model)
         ising_graph = model.get_cxxjij_ising_graph()
 
-        # make init state generator
         if initial_state is None:
-            if not reinitialize_state:
+            if not reinitilize_state:
                 raise ValueError(
                     'You need initial_state if reinitilize_state is False.')
 
@@ -242,19 +242,46 @@ def _generate_init_state(): return np.array(_init_state)
             raise ValueError(
                 'updater is one of "single spin flip or swendsen wang"')
 
-        response = self._sampling(
-            model, _generate_init_state,
-            algorithm, sa_system, initial_state,
-            reinitialize_state, seed, **kwargs
-        )
-
-        response.update_ising_states_energies(
-            response.states, response.energies)
+        # 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(
+            var_type=model.var_type, 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 _post_save(self, result_state, system, model, response):
-        response.states.append(result_state)
-        response.energies.append(model.calc_energy(
-            result_state,
-            need_to_convert_from_spin=True))

openjij/sampler/sampler.py

@@ -13,9 +13,10 @@
 # limitations under the License.
 
 import numpy as np
-import cxxjij
+import cxxjij as cj
 from openjij.model import BinaryQuadraticModel
 import openjij
+from .response import Response
 
 import time
 
@@ -61,47 +62,3 @@ def _sampling_kwargs_setting(self, **kwargs):
             self.iteration = kwargs['iteration']
         elif 'num_reads' in kwargs:
             self.iteration = kwargs['num_reads']
-
-    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 _post_save(self, result_state, system, model, response):
-        pass