def solve_multi(self, verbose=False, num_repeats=200):
if self.qubo is None:
self.pre_process()
if verbose:
print("Solving multiple solutions of MAX-SMTI with Qbsolv")
if self.qubo_size == 0 or self.qubo_size == 1:
return [Solution(self.matching, self.pre_evaluated_solution)]
if self.mode == "np": # more memory intensive
response = QBSolv().sample(BinaryQuadraticModel.from_numpy_matrix(self.qubo), num_repeats=num_repeats)
elif self.mode == "bqm":
response = QBSolv().sample(self.qubo, num_repeats=num_repeats)
else:
raise Exception(f"mode: {self.mode} cannot be solved yet")
if verbose:
print(response)
for index, sample in enumerate(list(response.samples())):
match, valid = self.encode(sample)
print(index, ":", Solution(self.matching, match).is_stable(), match, valid)
opt_en = self.get_optimal_energy(self.matching.size)
solutions = []
for sample, energy, occ in response.record:
if energy == opt_en:
match, valid = self.encode_qa(sample.tolist())
if verbose and not valid:
print("Invalid encoding and valid energy!")
solutions.append(Solution(self.matching, match))
return solutions
def qbsolv_solver(self, ising=True):
""" qbsolv is for breaking up large optmisation problems into smaller
ones for the D-Wave machines.
This function has not been properly implemented yet.
"""
if ising:
response = QBSolv().sample_ising(self.h, self.j)
else:
response = QBSolv().sample_qubo(self.q_dict)
min_energy = 0
for sample in response.data(['sample', 'energy']):
sample_dict = {
'sample': {k: int((1 + sample[0][k]) / 2)
for k in sample[0]}
}
sample_dict.update({'energy': sample[1]})
self.samples.append(sample_dict)
min_energy = min(sample[1], min_energy)
self.solution = {
f'x{k+1}': v
for k, v in sample_dict['sample'].items()
if k < len(self.masses)
} if min_energy == sample[1] else self.solution
self._solution_blocks()
return response
def solve_multi_data(self, verbose=False, target=None, num_repeats=200):
if self.qubo is None:
self.pre_process()
if verbose:
print("Solving multiple solutions of MAX-SMTI with Qbsolv")
if self.qubo_size == 0 or self.qubo_size == 1:
return [Solution(self.matching, self.pre_evaluated_solution)]
if self.mode == "np": # more memory intensive
response = QBSolv().sample(BinaryQuadraticModel.from_numpy_matrix(self.qubo), num_repeats=num_repeats,
target=target, algorithm=SOLUTION_DIVERSITY)
elif self.mode == "bqm":
response = QBSolv().sample(self.qubo, num_repeats=num_repeats, target=target)
else:
raise Exception(f"mode: {self.mode} cannot be solved yet")
if verbose:
print(response)
for index, sample in enumerate(list(response.samples())):
match, valid = self.encode(sample)
print(index, ":", Solution(self.matching, match).is_stable(), match, valid)
samples = pd.DataFrame()
for sample, energy, occ in response.record:
match, valid = self.encode_qa(sample.tolist())
stable, size = Solution(self.matching, match).is_stable()
samples = samples.append({"match": match, "sample": sample.tolist(),
"energy": energy, "occ": occ,
"valid": valid, "stable": stable, "size": size}, ignore_index=True)
return samples
def qubo_extractor(img,file_name):
img_name, ext = file_name.split(".")
(M,N) = img.shape[0:2]
coupler_count = 0
Q = {}
for i in range(M):
for j in range(N):
foreground_node_id = (i*N*2)+(j*2)
background_node_id = foreground_node_id+1
#foreground qubit
Q[(foreground_node_id,foreground_node_id)] = unary_potential(img,1,i,j)
#background qubit
Q[(background_node_id,background_node_id)] = unary_potential(img,0,i,j)
#for qubits of same pixel - high cost should be given here to ensure both qubits are not open
Q[(foreground_node_id,background_node_id)] = 10
coupler_count += 1
#for neighbors
neighbors = find_neighbors(img,i,j)
for k in neighbors:
neighbor_foreground_node_id = (k[0]*N*2)+(k[1]*2)
neighbor_background_node_id = neighbor_foreground_node_id+1
#f.write(' '+ str(foreground_node_id) +' '+ str(neighbor_foreground_node_id) +' '+ str(f_1(img,i,j,k)) +'\n' )
#f.write(' '+ str(background_node_id) +' '+ str(neighbor_foreground_node_id) +' '+ str(f_2(img,i,j,k)) +'\n' )
#f.write(' '+ str(foreground_node_id) +' '+ str(neighbor_background_node_id) +' '+ str(f_2(img,i,j,k)) +'\n' )
#f.write(' '+ str(background_node_id) +' '+ str(neighbor_background_node_id) +' '+ str(f_1(img,i,j,k)) +'\n' )
#coupler_count += 1
#print(Q)
response = QBSolv().sample_qubo(Q)
result = list(response.samples())
counter = 1
out = []
array = result[0]
for i in array:
mode = counter
if(counter > (N*M*2)):
continue
if(mode%2 == 1):
if array[i] == 1:
out.append(int(255))
else:
out.append(0)
counter += 1
out=numpy.array(out)
out = out.reshape(M,N)
img_name, ext = file_name.split(".")
if(os.path.isdir("result/" + img_name) != 1):
call(["mkdir","result/" + img_name])
rel_path = "result/" +img_name + "/"
output_file_name = str(img_name) + "_out_python." + str(ext)
file_path = rel_path + output_file_name
scipy.misc.imsave(file_path,out)
def Solver(H,J):
from dwave_qbsolv import QBSolv
h=dict(enumerate(H.flatten(),0))
j=dict(((i,j),J[i][j]) for i in range(len(J)) for j in range(len(J[0])) if i>j and J[i][j] !=0)
response = QBSolv().sample_ising(h,j)
sample=list(response.samples())
value=list(sample[0].values())
return value
def solve(self, options):
"""
Options:
'solver' - see solver input to Qbsolve.sample, default 'tabu'
'top_samples' - int, how many samples to print
'visualize' - boolean,
'verbosity' - int, default 0 (low)
"""
DEFAULT_OPTIONS = {
'solver': 'tabu',
'top_samples': 1,
'visualize': False,
'verbosity': 0,
'repititions': 5
}
complete_options = DEFAULT_OPTIONS.copy()
complete_options.update(options)
# get hamiltonian
q = self.make_Q()
# from np matrix to dwave representation
Q = dimod.BinaryQuadraticModel.from_numpy_matrix(q)
total_time = 0
for _ in range(complete_options['repititions']):
start_time = timer()
# solve using QBSolv
response = QBSolv().sample(Q,
verbosity=complete_options['verbosity'],
solver=complete_options['solver'])
end_time = timer()
if not complete_options['no_time']:
print(f'time to solve: {end_time - start_time} s')
total_time += end_time - start_time
for sample_i, sample in enumerate(
response.samples()[0:complete_options['top_samples']]):
X = self.sample_to_x_ij_matrix(sample)
print(f'------- sample {sample_i} -------')
print('solution is valid:', self.is_solution_valid(X))
print('energy:', response.record.energy[sample_i])
print('total U:', self.objective_value(X.flat))
if complete_options['visualize']:
positions = self.sample_to_positions(sample)
self.plot_3d(positions)
avg_time = total_time / complete_options['repititions']
print(f'average time: {avg_time} s')
def Solver(H, J):
from dwave_qbsolv import QBSolv
from dwave.system.samplers import DWaveSampler
from dwave.system.composites import EmbeddingComposite
from dwave.cloud import Client
import itertools
import random
sampler = EmbeddingComposite(
DWaveSampler(token='DEV-34ebdd33f77f73904ed58bac612191ccdce89841'))
h = dict(enumerate(H.flatten(), 0))
j = dict(((i, j), J[i][j]) for i in range(len(J)) for j in range(len(J[0]))
if i > j and J[i][j] != 0)
response = QBSolv().sample_ising(h, j, solver=sampler)
sample = list(response.samples())
print(sample)
return sample
def get_solver(solver_type):
solver = None
if solver_type == 'qpu':
solver = hybrid_solver()
if solver_type == 'cpu':
solver = QBSolv()
return solver
def main():
"""Entrypoint of this script.
Synopsis is as follows:
- construct qubo of some predefined size
- solve it using QBSolv with patched sampler
- show what is recorded
"""
with open('dwave_credentials.txt') as token_file:
token = token_file.read()
qubo_dict = get_random_qubo(50)
sampler = EmbeddingComposite(DWaveSampler(token=token, endpoint=ENDPOINT))
with record_sampler_invocations(sampler) as records:
response = QBSolv().sample_qubo(qubo_dict,
solver_limit=30,
solver=sampler)
print('Sampler was invoked this many times: {}'.format(len(records)))
# In this example we take only qubo calls - when I tested it it were the only
# ones made
qubo_timings = [
record['timing'] for record in records if record['method'] == 'qubo'
]
total_sampling_time = sum(record['qpu_sampling_time']
for record in qubo_timings)
print('Average QPU samping time [QUBO]: {}'.format(total_sampling_time /
len(qubo_timings)))
def sample_qubo_slices(self, Q: TQubo = None, return_time=False, logfile: str = None, seed: int=None, **qbsolv_params)\
-> ResponseContainer:
#-> Union[object, Tuple[object, float]]:
"""
Submit a QUBO to (see `qbsolv <https://github.com/dwavesystems/qbsolv>`_).
:param Q: the QUBO's in the from of a QuboSlice container. If not defined, :py:meth:~`to_qubo` will be called.
:param return_time: if set, also return the execution time (in seconds)
:param qbsolv_params: parameters to pass to qbsolv's `sample_qubo` method
:param logfile: path to a file. if set, all qbsolv output will be redirected to this file
:param seed: the random seed for qbsolv. **MUST** be a 32-bits integer with entropy !
:return: a dimod response or a tuple (dimod response, exec_time)
(see `dimod.Response <https://docs.ocean.dwavesys.com/projects/dimod/en/latest/reference/response.html>`_)
"""
if Q is None: Q = self.to_qubo()
if seed is None:
import random
seed = random.randint(0, 1 << 31)
# Instantiate a container to hold all qubo responses
responsecontainer = ResponseContainer()
# run qbsolv
start_time = time.process_time()
for qubo in Q.quboList:
if bool(qubo.qubo):
try:
with capture_stdout(logfile):
##make dummy QBSOLV
response = QBSolv().sample_qubo(qubo.qubo,
seed=seed,
**qbsolv_params)
except: # fails if called from ipython notebook...
response = QBSolv().sample_qubo(qubo.qubo,
seed=seed,
**qbsolv_params)
exec_time = time.process_time() - start_time
if bool(qubo.qubo):
self.logger.info(
f'QUBO of size {len(qubo.qubo)} sampled in {exec_time:.2f}s (seed {seed}).'
)
responseSlice = ResponseSlice(r=response,
eta=qubo.eta,
phi=qubo.phi)
responsecontainer.addResponse(r=responseSlice)
traceback.extract_stack()
return (responsecontainer,
exec_time) if return_time else responsecontainer
def solve(self, verbose=False, num_repeats=100, target=None):
if self.qubo is None:
self.create_qubo()
if self.mode == "np": # more memory intensive
response = QBSolv().sample(BinaryQuadraticModel.from_numpy_matrix(self.qubo), target=target)
elif self.mode == "bqm":
response = QBSolv().sample(self.qubo, num_repeats=num_repeats, target=target)
else:
raise Exception(f"mode: {self.mode} cannot be solved yet")
if verbose:
print(response)
energies = list(response.data_vectors['energy'])
min_en = min(energies)
ret_match = self.encode(list(response.samples())[energies.index(min_en)])
return Solution(self.matching, ret_match)
def solve_multi(self, verbose=True, num_repeats=100, target=None):
if self.qubo is None:
self.create_qubo()
if self.mode == "np": # more memory intensive
response = QBSolv().sample(BinaryQuadraticModel.from_numpy_matrix(self.qubo), target=target)
elif self.mode == "bqm":
response = QBSolv().sample(self.qubo, num_repeats=num_repeats, target=target)
else:
raise Exception(f"mode: {self.mode} cannot be solved yet")
if verbose:
print(response)
n = self.matching.size
stable_energy = -3 / 2 * self.p1 * (n - 1) * n
energies = list(response.data_vectors['energy'])
samples = enumerate(list(response.samples()))
allowed_samples = [sample for idx, sample in samples if energies[idx] == stable_energy]
return [Solution(self.matching, self.encode(sample)) for sample in allowed_samples]
def _get_raw_solutions(self, problem, **params):
logger = logging.getLogger(__name__)
solver_params = self._extract_kwargs(params, self.DEFAULT_SOLVER_PARAMS)
qubo_params = self._extract_kwargs(params, self.DEFAULT_QUBO_PARAMS)
logger.debug('Using solver parameters: %s', solver_params)
logger.debug('Using qubo parameters: %s', qubo_params)
response = QBSolv().sample_qubo(problem.get_qubo_dict(**qubo_params), solver='tabu')
return response
def solve_tsp(self):
#response = EmbeddingComposite(DWaveSampler(token=self.sapi_token, endpoint=self.url, solver='DW_2000Q_5')).sample_qubo(self.qubo_dict, chain_strength=self.chainstrength, num_reads=self.numruns)
#sampler = EmbeddingComposite(DWaveSampler(token=self.sapi_token, endpoint=self.url, solver='DW_2000Q_5'))
#response = QBSolv().sample_qubo(Q, solver=sampler, solver_limit=subqubo_size)
subqubo_size = 6
response = QBSolv().sample_qubo(self.qubo_dict, chain_strength=self.chainstrength, num_reads=self.numruns, solver_limit=subqubo_size)
self.decode_solution(response)
return self.solution, self.distribution
def solve_tsp_Qbsolv_c(Q, G):
response = QBSolv().sample_qubo(Q)
sample = response.first.sample
adj_mat = [None] * len(G)
for (u, v), val in sample.items():
if val:
adj_mat[u] = v
cost = calculate_cost(nx.to_numpy_array(G), adj_mat=adj_mat)
return (adj_mat, cost)
def qb(dets, thresh=None, confidence=None, ax=None):
from dwave_qbsolv import QBSolv
x1 = dets[:, 0]
y1 = dets[:, 1]
x2 = dets[:, 2]
y2 = dets[:, 3]
scores = dets[:, 4]
if len(scores) == 0:
return []
elif len(scores) == 1:
return [0]
areas = (x2 - x1 + 1) * (y2 - y1 + 1)
ious = {} #np.zeros([len(x1), len(x1)])
w2 = 0.4
for i in range(len(x1)):
xx1 = np.maximum(x1[i], x1)
yy1 = np.maximum(y1[i], y1)
xx2 = np.minimum(x2[i], x2)
yy2 = np.minimum(y2[i], y2)
w = np.maximum(0.0, xx2 - xx1 + 1)
h = np.maximum(0.0, yy2 - yy1 + 1)
inter = w * h
ovr = inter / (areas[i] + areas - inter)
for j in range(len(ovr)):
if i == j:
ious[i, i] = -(1 - w2) * scores[i]
ious[i, j] += w2 * ovr[j]
else:
ious[i, j] = w2 * ovr[j]
response = QBSolv().sample_qubo(ious, verbosity=0)
samples = list(response.samples())[0]
keep = []
for i in range(len(x1)):
if samples[i] == 1:
keep.append(i)
#if len(keep) == 0:
# keep_dets = np.ndarray((0, 4))
#else:
# keep_dets = dets[keep]
## print(keep_dets)
#return keep_dets
return keep
def QBSolve_QC_solution(Qdict,
token="DEV-3fd7a21d8cf1afa9655ac1d7e9cb809bc3d7f7dc",
print_energy=False):
"""This function use QC to get solution dictionary"""
endpoint = 'https://cloud.dwavesys.com/sapi'
sampler = EmbeddingComposite(DWaveSampler(token=token, endpoint=endpoint))
response = QBSolv().sample_qubo(Qdict, solver=sampler)
if print_energy:
print("energies=" + str(list(response.data_vectors['energy'])))
qb_solution = list(response.samples())
print("\n\nqb_solution: ", qb_solution)
return qb_solution
def QBSolve_classical_solution(Qdict, print_energy=False):
"""This function use classical QBSolve to get solution dictionary"""
start = time.clock()
response = QBSolv().sample_qubo(Qdict)
qb_solution = list(response.samples())
if print_energy:
print("energies=" + str(list(response.data_vectors['energy'])))
end = time.clock()
time_taken = end - start
print("Time taken by classical QBSolv: ", time_taken)
return qb_solution
def qbsolve(Q, size=30):
q_min = 0
a_min = []
response = QBSolv().sample_qubo(Q)
for res in response.samples():
a = np.empty(size)
for key in res:
a[key] = res[key]
#------------------------------------------
q = 0
for i in xrange(size):
for j in xrange(size):
if (i, j) in Q:
q += Q[(i, j)] * a[i] * a[j]
if q < q_min:
q_min = q
a_min = a
return a_min, q_min
def get_solver(solver_type):
solver = None
if solver_type == 'standard':
solver = EmbeddingComposite(DWaveSampler())
if solver_type == 'hybrid':
solver = hybrid_solver()
if solver_type == 'kerberos':
solver = KerberosSampler()
if solver_type == 'qbsolv':
solver = QBSolv()
return solver
def solve(self, verbose=False, num_repeats=50, target=None, debug=False):
if self.qubo is None:
self.pre_process()
if verbose:
print("Solving MAX-SMTI with Qbsolv")
if self.qubo_size == 0 or self.qubo_size == 1:
if debug:
return None
return Solution(self.matching, self.pre_evaluated_solution)
if self.mode == "np": # more memory intensive
response = QBSolv().sample(BinaryQuadraticModel.from_numpy_matrix(self.qubo), num_repeats=num_repeats,
target=target)
elif self.mode == "bqm":
response = QBSolv().sample(self.qubo, num_repeats=num_repeats, target=target)
else:
raise Exception(f"mode: {self.mode} cannot be solved yet")
if debug:
return response
if verbose:
print(response)
for index, sample in enumerate(list(response.samples())):
match, valid = self.encode(sample)
print(index, ":", Solution(self.matching, match).is_stable(), match, valid)
energies = list(response.data_vectors['energy'])
min_en = min(energies)
ret_match, valid = self.encode(list(response.samples())[energies.index(min_en)])
return Solution(self.matching, ret_match, energy=min_en)
def __init__(self, qmasm, profile=None, solver=None, qbsolv=False):
"Acquire either a software sampler or a sampler representing a hardware solver."
self.qmasm = qmasm
self.sampler, self.client_info = self._get_sampler(profile, solver)
if qbsolv:
if solver == None:
self.qbsolv_sampler = EmbeddingComposite(self.sampler)
else:
self.qbsolv_sampler = self.sampler
self.sampler = QBSolv()
self.client_info[
"solver_name"] = "QBSolv + " + self.client_info["solver_name"]
else:
self.qbsolv_sampler = None
def solve_qbsolv(Q, logfile=None, seed=None, **kwargs):
from hepqpr.qallse.other.stdout_redirect import capture_stdout
from dwave_qbsolv import QBSolv
# generate seed for logging purpose
if seed is None:
import random
seed = random.randint(0, 1 << 31)
# run qbsolv
logger.debug('Running qbsolv with extra arguments: %s', kwargs)
start_time = time.process_time()
if logfile is not None:
logger.debug(
f'Writting qbsolv output to {logfile}. If you see an output in stdout, run "export PYTHONUNBUFFERED=1".'
)
with capture_stdout(logfile):
response = QBSolv().sample_qubo(Q, seed=seed, **kwargs)
else:
response = QBSolv().sample_qubo(Q, seed=seed, **kwargs)
exec_time = time.process_time() - start_time
logger.info(
f'QUBO of size {len(Q)} sampled in {exec_time:.2f}s (QBSOLV, seed={seed}).'
)
return response
def sample_qubo(self,
Q: TQubo = None,
return_time=False,
logfile: str = None,
seed: int = None,
**qbsolv_params) -> Union[object, Tuple[object, float]]:
"""
Submit a QUBO to (see `qbsolv <https://github.com/dwavesystems/qbsolv>`_).
:param Q: the QUBO. If not defined, :py:meth:~`to_qubo` will be called.
:param return_time: if set, also return the execution time (in seconds)
:param qbsolv_params: parameters to pass to qbsolv's `sample_qubo` method
:param logfile: path to a file. if set, all qbsolv output will be redirected to this file
:param seed: the random seed for qbsolv. **MUST** be a 32-bits integer with entropy !
:return: a dimod response or a tuple (dimod response, exec_time)
(see `dimod.Response <https://docs.ocean.dwavesys.com/projects/dimod/en/latest/reference/response.html>`_)
"""
if Q is None: Q = self.to_qubo()
if seed is None:
import random
seed = random.randint(0, 1 << 31)
# run qbsolv
start_time = time.process_time()
try:
with capture_stdout(logfile):
response = QBSolv().sample_qubo(Q, seed=seed, **qbsolv_params)
except: # fails if called from ipython notebook...
response = QBSolv().sample_qubo(Q, seed=seed, **qbsolv_params)
exec_time = time.process_time() - start_time
self.logger.info(
f'QUBO of size {len(Q)} sampled in {exec_time:.2f}s (seed {seed}).'
)
return (response, exec_time) if return_time else response
def do_calculation(simul):
if simul == "dwave":
_sampler = EmbeddingComposite(DWaveSampler())
_response = QBSolv().sample_qubo(qubo,
num_repeats=NUM_REPEATS,
verbosity=VERBOSITY_LEVEL,
solver=_sampler)
elif simul == "dimod":
_sampler = dimod.ExactSolver()
_response = QBSolv().sample_qubo(qubo,
num_repeats=NUM_REPEATS,
verbosity=VERBOSITY_LEVEL,
solver=_sampler)
elif simul == "neal":
_sampler = neal.SimulatedAnnealingSampler()
_response = QBSolv().sample_qubo(qubo,
num_repeats=NUM_REPEATS,
verbosity=VERBOSITY_LEVEL,
solver=_sampler)
else:
_response = QBSolv().sample_qubo(qubo,
num_repeats=NUM_REPEATS,
verbosity=VERBOSITY_LEVEL)
return _response
def solve_qubo(qubo, solver_type='qbsolv', limit=1, num_reads=50):
sampler = get_solver(solver_type)
response = None
if solver_type == 'hybrid':
response = sampler.sample_qubo(qubo.dict)
elif solver_type == 'qbsolv':
response = sampler.sample_qubo(qubo.dict, num_reads=num_reads)
elif solver_type == 'standard':
response = QBSolv().sample_qubo(qubo.dict,
solver=sampler,
chain_strength=800,
num_reads=num_reads)
else:
response = sampler.sample_qubo(qubo.dict, num_reads=num_reads)
return list(response)[:limit]
def get_sampler(self, profile, solver):
"Return a dimod.Sampler object and associated solver information."
# Handle built-in software samplers as special cases.
info = {}
if solver != None:
info["solver_name"] = solver
if solver == "exact":
return ExactSolver(), info, {}
elif solver == "neal":
return SimulatedAnnealingSampler(), info, {}
elif solver == "tabu":
return TabuSampler(), info, {}
elif solver == "kerberos" or (solver != None
and solver[:9] == "kerberos,"):
base_sampler = KerberosSampler()
try:
sub_sampler_name = solver.split(",")[1]
except IndexError:
sub_sampler_name = None
sub_sampler, sub_info, params = self.get_sampler_from_config(
profile, sub_sampler_name, "qpu")
info.update(self._recursive_properties(sub_sampler))
info["solver_name"] = "kerberos + %s" % sub_info["solver_name"]
params["qpu_sampler"] = sub_sampler
return base_sampler, info, params
elif solver == "qbsolv" or (solver != None
and solver[:7] == "qbsolv,"):
base_sampler = QBSolv()
try:
sub_sampler_name = solver.split(",")[1]
except IndexError:
sub_sampler_name = None
sub_sampler, sub_info, params = self.get_sampler(
profile, sub_sampler_name)
if getattr(sub_sampler, "structure", None) != None:
sub_sampler = EmbeddingComposite(sub_sampler)
info.update(self._recursive_properties(sub_sampler))
info["solver_name"] = "QBSolv + %s" % sub_info["solver_name"]
params["solver"] = sub_sampler
return base_sampler, info, params
# In the common case, read the configuration file, either the
# default or the one named by the DWAVE_CONFIG_FILE environment
# variable.
return self.get_sampler_from_config(profile, solver)
def pyqubo_response(df, param_a, param_b, param_c, num_reads, do_qbsolve):
t_list = calc_marginals(df)
#make H
N = len(df)
Y = Array.create('Y', shape=N, vartype='BINARY')
ysum = sum(y for y in Y)
H_0 = (ysum - t_list[0])**2
sex = df['SEX'].values.tolist()
sex_array = sum(s * y for s, y in zip(sex, Y))
H_1 = (sex_array - t_list[1])**2
aop = df['AOP'].values.tolist()
aop_array = sum(a * y for a, y in zip(aop, Y))
H_2 = (aop_array - t_list[2])**2
alpha = Placeholder("alpha")
beta = Placeholder("beta")
gamma = Placeholder("gamma")
H = alpha * H_0 + beta * H_1 + gamma * H_2
#パラメータ
feed_dict = {'alpha': param_a, 'beta': param_b, 'gamma': param_c}
#QUBOのコンパイル
model = H.compile()
qubo, offset = model.to_qubo(feed_dict=feed_dict)
if do_qbsolve == True:
res = QBSolv().sample_qubo(qubo, num_reads=num_reads)
else:
s3_destination_folder = ('amazon-braket-ecc806acea4c',
'qaExactLogisticRegression_ssato')
dw = BraketDWaveSampler(
s3_destination_folder,
device_arn='arn:aws:braket:::device/qpu/d-wave/DW_2000Q_6')
qa_sampler = AutoEmbeddingComposite(dw)
res = qa_sampler.sample(bqm,
chain_strength=chain_strength,
auto_scale=True,
chain_break_fraction=True,
num_reads=num_reads)
return res
def get_ocean_qubo_re(traveling_cost_qubo, traveling_qubo, B, cities_size):
# solver = client.get_solver()
p_qubo = traveling_qubo + traveling_cost_qubo * B
keys = []
for i in range(len(p_qubo[0])):
for j in range(len(p_qubo[1])):
keys.append((i, j))
Q = {key: val for key, val in zip(keys, p_qubo.reshape(-1))}
# sampler = neal.SimulatedAnnealingSampler()
sampler = EmbeddingComposite(DWaveSampler())
# print(Q)
result = QBSolv(qpu_reads = 1000).sample_qubo(Q, num_reads=10, qpu_sampler=sampler)
result_dw = result.first.sample
# result = sampler.sample_qubo(Q,num_reads=10)
# for sample in computation.samples:
# result = sample
print(result_dw)
return result_dw
def create_sampler(self):
if None == self.sampler:
composite = None
_inner_sampler = None
if self.mode == self.op_mode_quantum:
_inner_sampler = self.base_sampler
elif self.mode == self.op_mode_simulated_annealing:
_inner_sampler = SimulatedAnnealingSampler()
elif self.mode == self.op_mode_qbsolv:
_inner_sampler = QBSolv()
else:
raise ValueError(
"op_mode {} is not known. (only 1,2,3)".format(self.mode))
composite = StructureComposite(_inner_sampler,
self.base_sampler.nodelist,
self.base_sampler.edgelist)
self.sampler = FixedEmbeddingComposite(composite, self.embedding)
