def test_equality(self): self.assertEqual(Binary("a"), Binary("a")) self.assertNotEqual(Binary("a"), Binary("b")) exp1 = Binary("a") + 2 exp2 = Binary("a") + 2 exp3 = Binary("b") + 2 self.assertEqual(exp1, exp2) self.assertNotEqual(exp1, exp3) mul1 = Placeholder("p") * Binary("b") mul2 = Placeholder("p") * Binary("b") mul3 = Placeholder("p") * Binary("a") self.assertEqual(mul1, mul2) self.assertNotEqual(mul1, mul3) class CustomPenalty(WithPenalty): def __init__(self, hamiltonian, penalty, label="label"): super().__init__(hamiltonian, penalty, label) a, b = Binary("a"), Binary("b") p1 = 1 + CustomPenalty(a + b, a * b) p2 = 1 + CustomPenalty(a + b, a * b) p3 = 1 + CustomPenalty(a * b, a + b) self.assertEqual(p1, p2) self.assertNotEqual(p1, p3) subh1 = SubH(a + b, label="c1") subh2 = SubH(a + b, label="c1") subh3 = SubH(a + b, label="c2") self.assertEqual(subh1, subh2) self.assertNotEqual(subh1, subh3)
def build_solver(self,member_num,expectation_member_capacity): X = Array.create('X', (self.department_num,self.term_num, member_num), 'BINARY') # Term_Member Once Constraint C_TM_Once = 0.0 for t in range(self.term_num): for m in range(member_num): C_TM_Once += Constraint( (Sum(start_index=0,end_index=self.department_num,func=lambda d:X[d,t,m]) - 1)**2 , label=f"TM_Once_{t},{m}") # Department_Member Once Constraint C_DM_Once = 0.0 for d in range(self.department_num): for m in range(member_num): C_DM_Once += Constraint( (Sum(start_index=0,end_index=self.term_num,func=lambda t:X[d,t,m]) - 1)**2 , label=f"DM_Once_{t},{m}") # Member Capacity Constraint C_MC = 0.0 for d in range(self.department_num): for t in range(self.term_num): C_MC += Constraint( (Sum(start_index=0,end_index=member_num,func=lambda m:X[d,t,m]) - expectation_member_capacity[d,t])**2 , label=f"MC_{d},{t}") P_TM_Once = Placeholder("PTMO") P_DM_Once = Placeholder("PDMO") P_MC = Placeholder("PMC") H = P_TM_Once*C_TM_Once + P_DM_Once*C_DM_Once + P_MC*C_MC model = H.compile() return model
def test_equality_of_placeholder(self): p1 = Placeholder("p1") p2 = Placeholder("p2") p3 = Placeholder("p1") self.assertTrue(p1 == p3) self.assertTrue(hash(p1) == hash(p3)) self.assertTrue(p1 != p2) self.assertTrue(p1 != Qbit("a"))
def test_compile_placeholder(self): a, b = Binary("a"), Binary("b") p, q, r = Placeholder("p"), Placeholder("q"), Placeholder("r") exp = r * (q * p * (a + b)**2 + q) expected_qubo = {('a', 'a'): 12.0, ('a', 'b'): 24.0, ('b', 'b'): 12.0} expected_offset = 4 feed_dict = {"p": 3, "q": 2, "r": 2} q, offset = exp.compile().to_qubo(feed_dict=feed_dict) self.compile_check(exp, expected_qubo, expected_offset, feed_dict)
def test_one_hot_enc_integer_equal(self): a = OneHotEncInteger("a", (0, 4), strength=Placeholder("s")) b = OneHotEncInteger("b", (0, 4), strength=Placeholder("s")) M = 2.0 H = (a + b - 5)**2 + M * (a.equal_to(3) - 1)**2 model = H.compile() q, offset = model.to_qubo(feed_dict={"s": 10.0}) sampleset = dimod.ExactSolver().sample_qubo(q) decoded = model.decode_sampleset(sampleset, feed_dict={"s": 10.0})[0] self.assertTrue(decoded.subh["a"] == 3) self.assertTrue(decoded.subh["b"] == 2) self.assertTrue(decoded.subh["a_const"] == 0) self.assertTrue(decoded.subh["b_const"] == 0) self.assertEqual(len(decoded.constraints(only_broken=True)), 0)
def test_compile_placeholder2(self): a, b, w, v = Qbit("a"), Qbit("b"), Placeholder("w"), Placeholder("v") exp = v * w * (a + b - 2) + v expected_qubo = {('a', 'a'): 15.0, ('b', 'b'): 15.0} expected_offset = -25 expected_structure = {'a': ('a', ), 'b': ('b', )} self.compile_check(exp, expected_qubo, expected_offset, expected_structure, feed_dict={ "w": 3.0, "v": 5.0 })
def test_placeholders(self): S = Array.create('S', 3, "SPIN") p1, p2 = Placeholder("p1"), Placeholder("p2") H = p1 * S[0] * S[1] + S[1] * S[2] + p2 * S[2] * S[0] + 0.5 * S[0] model = H.compile() feed_dict = {"p1": 0.8, "p2": 1.1} binary_bqm = model.to_bqm(feed_dict=feed_dict) sampler = dimod.ExactSolver() sampleset = sampler.sample(binary_bqm) sol = model.decode_sampleset(sampleset, feed_dict=feed_dict) self.assertTrue(sol[0].array("S", 0) == 0) self.assertTrue(sol[0].array("S", 1) == 0) self.assertTrue(sol[0].array("S", 2) == 1) self.assertTrue(np.isclose(sol[0].energy, -1.8))
def test_one_hot_enc_integer_equal(self): a = OneHotEncInteger("a", 0, 4, strength=Placeholder("s")) b = OneHotEncInteger("b", 0, 4, strength=Placeholder("s")) M = 2.0 H = (a + b - 5) ** 2 + M*(a.equal_to(3)-1)**2 model = H.compile() q, offset = model.to_qubo(feed_dict={"s": 10.0}) sampleset = dimod.ExactSolver().sample_qubo(q) response, broken, e = model.decode_dimod_response( sampleset, topk=1, feed_dict={"s": 10.0})[0] self.assertTrue(response["a"][0] == 0) self.assertTrue(response["a"][1] == 0) self.assertTrue(response["a"][2] == 0) self.assertTrue(response["a"][3] == 1) self.assertTrue(response["a"][4] == 0)
def make_energy(num_city, distance): # set binary variables x = Array.create('x', shape=(num_city, num_city), vartype='BINARY') # # fix variables for preprocess # x = np.array(x) # x[0][0] = 1 # for i in range(1, num_city): # x[0][i] = 0 # for t in range(1, num_city): # x[t][0] = 0 # set hyperparameters lambda_a = [] lambda_b = [] for i in range(num_city): lambda_a.append(Placeholder('h_a_{}'.format(i))) lambda_b.append(Placeholder('h_b_{}'.format(i))) lambda_c = Placeholder('h_c') # set one-hot encoding for time h_a = [] for t in range(num_city): tmp = sum([x[t][i] for i in range(num_city)]) - 1 h_a.append(tmp) # set one-hot encoding for city h_b = [] for i in range(num_city): tmp = sum([x[t][i] for t in range(num_city)]) - 1 h_b.append(tmp) # set function for augmented lagrangian function h_c = sum([h_a[i]**2 for i in range(num_city)]) h_c += sum([h_b[i]**2 for i in range(num_city)]) # convert to constraint for i in range(num_city): h_a[i] = Constraint(h_a[i], label='h_a_{}'.format(i)) h_b[i] = Constraint(h_b[i], label='h_b_{}'.format(i)) h_c = Constraint(h_c, label='h_c') # set objective function obj = 0 for t in range(num_city): for i in range(num_city): for j in range(num_city): obj += distance[i][j] * x[t][i] * x[(t + 1) % num_city][j] # compute total energy hamiltonian = obj + lambda_c / 2 * h_c hamiltonian += sum([lambda_a[i] * h_a[i] for i in range(num_city)]) hamiltonian += sum([lambda_b[i] * h_b[i] for i in range(num_city)]) # compile model = hamiltonian.compile() return model
def test_one_hot_enc_integer(self): a = OneHotEncInteger("a", 0, 4, strength=Placeholder("s")) H = (a - 3) ** 2 model = H.compile() q, offset = model.to_qubo(feed_dict={"s": 10.0}) sampleset = dimod.ExactSolver().sample_qubo(q) response, broken, e = model.decode_dimod_response( sampleset, topk=1, feed_dict={"s": 10.0})[0] self.assertTrue(response["a"][0] == 0) self.assertTrue(response["a"][1] == 0) self.assertTrue(response["a"][2] == 0) self.assertTrue(response["a"][3] == 1) self.assertTrue(response["a"][4] == 0) self.assertTrue(a.interval == (0, 4)) expected_q = {('a[0]', 'a[1]'): 40.0, ('a[0]', 'a[2]'): 40.0, ('a[0]', 'a[3]'): 40.0, ('a[0]', 'a[4]'): 40.0, ('a[1]', 'a[2]'): 44.0, ('a[1]', 'a[3]'): 46.0, ('a[1]', 'a[4]'): 48.0, ('a[2]', 'a[3]'): 52.0, ('a[2]', 'a[4]'): 56.0, ('a[3]', 'a[4]'): 64.0, ('a[0]', 'a[0]'): -20.0, ('a[1]', 'a[1]'): -25.0, ('a[2]', 'a[2]'): -28.0, ('a[3]', 'a[3]'): -29.0, ('a[4]', 'a[4]'): -28.0} assert_qubo_equal(q, expected_q)
def get_qubo(num_nodes, num_colors, edges): x = Array.create('x', (num_nodes, num_colors), "BINARY") adjacent_const = 0.0 for (i, j) in edges: for k in range(num_colors): adjacent_const += Constraint(x[i, k] * x[j, k], label="adjacent({},{})".format(i, j)) onecolor_const = 0.0 for i in range(num_nodes): onecolor_const += Constraint( (Sum(0, num_colors, lambda j: x[i, j]) - 1)**2, label="onecolor{}".format(i)) # combine the two components alpha = Placeholder("alpha") H = alpha * onecolor_const + adjacent_const model = H.compile() alpha = 1.0 # search for an alpha for which each node has only one color print("Broken constraints") while True: qubo, offset = model.to_qubo(feed_dict={"alpha": alpha}) solution = solve_qubo(qubo) decoded_solution, broken_constraints, energy = model.decode_solution( solution, vartype="BINARY", feed_dict={"alpha": alpha}) print(len(broken_constraints)) if not broken_constraints: break for (key, value) in broken_constraints.items(): if 'o' == key[0]: # onecolor alpha += 0.1 break if 'a' == key[0]: # adjacent break return qubo, decoded_solution
def optimize_leap(self): from pyqubo import Array,Constraint,Placeholder,UnaryEncInteger,Sum #LogEncInteger from dwave.system import LeapHybridSampler x = Array.create("x",shape=(self.num),vartype="BINARY") #y = LogEncInteger("y",lower=0,upper=5) y = UnaryEncInteger("y",lower=0,upper=5) #価値が最大になるように(符号を反転させる) H1 = -Sum(0,self.num,lambda i :x[i]*self.p[i].get_value() ) #H1 = -sum([x[i]*self.p[i].get_value() for i in range(self.num)]) #重さが目的の重量になるように H2 = Constraint((self.limit_weight -sum([x[i]*p_i.get_weight() for i,p_i in enumerate(self.p)]) - y*10)**2,"Const Weight") H = H1 + H2*Placeholder("balancer") model = H.compile() balance_dict = {"balancer":1.0} bqm = model.to_dimod_bqm(feed_dict=balance_dict) sampler = LeapHybridSampler() responses = sampler.sample(bqm,time_limit=3) solutions = model.decode_dimod_response(responses,feed_dict=balance_dict) if len(solutions[0][1]) == 0: print(f" y= { sum(2**i*y_i for i,y_i in enumerate(solutions[0][0]['y']))}") print("## LeapHybridSolver Optimized Result") self.print([int(solutions[0][0]['x'][i]) for i in range(self.num)]) else: print("## LeapHybridSolver Optimizing Failed")
def test_one_hot_enc_integer(self): a = OneHotEncInteger("a", (0, 4), strength=Placeholder("s")) H = (a - 3) ** 2 model = H.compile() q, offset = model.to_qubo(feed_dict={"s": 10.0}) sampleset = dimod.ExactSolver().sample_qubo(q) decoded = model.decode_sampleset( sampleset, feed_dict={"s": 10.0}) best = min(decoded, key=lambda x: x.energy) self.assertTrue(best.subh["a"]==3) self.assertTrue(a.value_range == (0, 4)) expected_q = {('a[0]', 'a[1]'): 20.0, ('a[0]', 'a[2]'): 20.0, ('a[0]', 'a[3]'): 20.0, ('a[0]', 'a[4]'): 20.0, ('a[1]', 'a[2]'): 24.0, ('a[1]', 'a[3]'): 26.0, ('a[1]', 'a[4]'): 28.0, ('a[2]', 'a[3]'): 32.0, ('a[2]', 'a[4]'): 36.0, ('a[3]', 'a[4]'): 44.0, ('a[0]', 'a[0]'): -10.0, ('a[1]', 'a[1]'): -15.0, ('a[2]', 'a[2]'): -18.0, ('a[3]', 'a[3]'): -19.0, ('a[4]', 'a[4]'): -18.0} expected_offset = 19 assert_qubo_equal(q, expected_q) self.assertTrue(offset == expected_offset)
def parse_to_pyqubo_model( self, objectives: List[ObjectiveTerm] = [], constraints: List[ConstraintTerm] = [], ) -> pyqubo.Model: parsed_objectives = [ Placeholder(o["label"]) * self.parse_mathjson(o["tex"]) for o in objectives ] parsed_constraints = [ Placeholder(c["label"]) * Constraint(self.parse_mathjson(c["tex"]), label=c["label"]) for c in constraints ] H = cast(Express, sum(parsed_objectives) + sum(parsed_constraints)) pyqubo_model = H.compile() return pyqubo_model
def test_compile_subh(self): a, b = Binary("a"), Binary("b") p = Placeholder("p") exp = p * SubH((a + b - 1)**2, label="subh") + a * b expected_qubo = {('a', 'a'): -3.0, ('a', 'b'): 7.0, ('b', 'b'): -3.0} expected_offset = 3 feed_dict = {"p": 3} self.compile_check(exp, expected_qubo, expected_offset, feed_dict)
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 test_placeholders(self): a, b, p = Binary("a"), Binary("b"), Placeholder("p") feed_dict = {'p': 2.0} exp = p * (1 + a * b + a) model = exp.compile() qubo, offset = model.to_qubo(index_label=False, feed_dict=feed_dict) dict_solution = {'a': 1, 'b': 0} dict_energy = model.energy(dict_solution, vartype="BINARY", feed_dict=feed_dict) list_solution = [1, 0] list_energy = model.energy(list_solution, vartype="BINARY", feed_dict=feed_dict) assert_qubo_equal(qubo, { ('a', 'b'): 2.0, ('a', 'a'): 2.0, ('b', 'b'): 0.0 }) self.assertEqual(offset, 2.0) self.assertTrue(dict_energy, 2.0) self.assertTrue(list_energy, 2.0) # Test that `decode_dimod_response` accepts the `feed_dict` arg import numpy as np import dimod n = 10 p = Placeholder("p") feed_dict = {'p': 2} A = [np.random.randint(-50, 50) for _ in range(n)] S = Array.create('S', n, "BINARY") H = sum(p * A[i] * S[i] for i in range(n))**2 model = H.compile() binary_bqm = model.to_dimod_bqm(feed_dict=feed_dict) sa = dimod.reference.SimulatedAnnealingSampler() response = sa.sample(binary_bqm, num_reads=10, num_sweeps=5) # Confirm that decode_dimod_response() accecpts a feed_dict. Test of accuracy delegated to decode_solution() decoded_solutions = model.decode_dimod_response(response, topk=2, feed_dict=feed_dict) for (decoded_solution, broken, energy) in decoded_solutions: assert isinstance(decoded_solution, dict) assert isinstance(broken, dict) assert isinstance(energy, float)
def model_from_pyqubo_model(): print("\n=== from pyqubo compiled model ===") model = sawatabi.model.LogicalModel(mtype="qubo") x = model.variables("x", shape=(4, 2)) y = model.variables("y", shape=(4, 2)) sum_x = sum(x[i, 0] for i in range(4)) sum_y = sum(y[i, 0] for i in range(4)) hamiltonian = Placeholder("A") * (sum_x - sum_y)**2 + 10.0 pyqubo_model = hamiltonian.compile() model.from_pyqubo(pyqubo_model) print("\nInteractions are set with pyqubo expression.") _print_utf8(model) print("\nCheck also the physical model after placeholder resolves.") physical = model.to_physical({"A": 2.0}) _print_utf8(physical)
def test_sub_qubo(self): a, b, c = Binary("a"), Binary("b"), Placeholder("c") exp = 1 + a * b + c * (a - 2) model = exp.compile() var_set = VarSetFromVarLabels([b]) sample_sol = {'a': 0, 'b': 1} sub_qubo, offset = model.sub_qubo(var_set, sample_sol, feed_dict={'c': 3.0}) self.assertTrue(sub_qubo == {("b", "b"): 0.0}) self.assertTrue(offset == -5.0)
def test_compile_placeholder3(self): a, v = Qbit("a"), Placeholder("v") exp = v * v * a + v expected_qubo = {('a', 'a'): 25.0} expected_offset = 5 expected_structure = {'a': ('a', )} self.compile_check(exp, expected_qubo, expected_offset, expected_structure, feed_dict={"v": 5.0})
def test_one_hot_enc_integer(self): a = OneHotEncInteger("a", (0, 4), strength=Placeholder("s")) H = (a - 3) ** 2 model = H.compile() q, offset = model.to_qubo(feed_dict={"s": 10.0}) sampleset = dimod.ExactSolver().sample_qubo(q) decoded = model.decode_sampleset( sampleset, feed_dict={"s": 10.0}) best = min(decoded, key=lambda x: x.energy) self.assertTrue(best.subh["a"]==3) self.assertTrue(a.value_range == (0, 4))
def define_model(self): ''' pyqubo.Modelインスタンス作成。モデル作成結果はself.modelに格納 H1(距離 目的関数)、H2,H3(都市、順序のワンホット制約) parameters ----- なし returns ----- なし ''' city_num = self.size #変数定義 x = Array.create('x', shape=(city_num, city_num), vartype="BINARY") #距離のペナルティ H1 = 0 #i番目に都市j、i+1番目に都市kを訪れる for i, j in product(range(city_num), range(city_num)): for k in range(city_num): H1 += self.dist(j, k) * x[i][j] * x[(i + 1) % city_num][k] #ある時刻には訪れる都市は1つだけ H2 = 0 for i in range(city_num): H2 += Constraint((Sum(0, city_num, lambda j: x[i][j]) - 1)**2, label=f"Constraint one hot for time{i}") #ある都市に訪れるのは1度だけ H3 = 0 for i in range(city_num): H3 += Constraint((Sum(0, city_num, lambda j: x[j][i]) - 1)**2, label=f"Constraint one hot for city {i}") H = Placeholder("H1") * H1 + H2 + H3 #モデル作成 self.model = H.compile()
def test_sub_ising(self): a, b, c = Binary("a"), Binary("b"), Placeholder("c") exp = 1 + a * b + c * (a - 2) model = exp.compile() var_set = VarSetFromVarLabels([b]) sample_sol = {'a': 0, 'b': 1} linear, quad, offset = model.sub_ising(var_set, sample_sol, feed_dict={'c': 3.0}) self.assertTrue(linear == {'b': 0.0}) self.assertTrue(quad == {}) self.assertTrue(offset == -5.0)
def test_compile_with_penalty(self): class CustomPenalty(WithPenalty): def __init__(self, hamiltonian, penalty, label): super().__init__(hamiltonian, penalty, label) a, b = Binary("a"), Binary("b") p = Placeholder("p") custom_penalty = p * CustomPenalty(a + b, a * b, "label") expected_qubo = {('a', 'a'): 2.0, ('a', 'b'): 1.0, ('b', 'b'): 2.0} expected_offset = 0.0 feed_dict = {"p": 2} self.compile_check(custom_penalty, expected_qubo, expected_offset, feed_dict)
def test_compile_const(self): a, b, w = Qbit("a"), Qbit("b"), Placeholder("w") exp = Constraint(Constraint(w * (a + b - 1), label="const1") + Constraint((a + b - 1)**2, label="const2"), label="const_all") expected_qubo = {('a', 'a'): 2.0, ('a', 'b'): 2.0, ('b', 'b'): 2.0} expected_offset = -2.0 expected_structure = {'a': ('a', ), 'b': ('b', )} self.compile_check(exp, expected_qubo, expected_offset, expected_structure, feed_dict={"w": 3.0})
def model_convert_with_placeholder(): print("\n=== convert with placeholder ===") model = sawatabi.model.LogicalModel(mtype="ising") print("\nSet variables x to shape (7,) and add interactions.") x = model.variables("x", shape=(7, )) model.add_interaction(x[0], coefficient=Placeholder("a")) model.add_interaction(x[1], coefficient=Placeholder("b") + 1.0) model.add_interaction(x[2], coefficient=2.0) model.add_interaction(x[2], name="x[2]-2", coefficient=Placeholder("c")) model.add_interaction(x[3], coefficient=2 * Placeholder("d") + 3 * Placeholder("e")) model.add_interaction(x[4], coefficient=Placeholder("f"), scale=3.0) model.add_interaction(x[5], coefficient=4.0, scale=Placeholder("g")) model.add_interaction(x[6], coefficient=Placeholder("h"), scale=Placeholder("i") * 5.0) model._offset = Placeholder("j") _print_utf8(model) print("\nConvert to Physical model with placeholders.") physical_model = model.to_physical( placeholder={ "a": 1.0, "b": 2.0, "c": 3.0, "d": 4.0, "e": -5.0, "f": 6.0, "g": -7.0, "h": 8.0, "i": 9.0, "j": 10.0 }) _print_utf8(physical_model)
def optimize_advantage(self,count=False,Best=0,balancer=1.0): from pyqubo import Array,Constraint,Placeholder,UnaryEncInteger,Sum #LogEncInteger from dwave.system import EmbeddingComposite,DWaveSampler x = Array.create("x",shape=(self.num),vartype="BINARY") #y = LogEncInteger("y",lower=0,upper=5) y = UnaryEncInteger("y",lower=0,upper=5) #価値が最大になるように(符号を反転させる) #H1 = -sum([x[i]*self.p[i].get_value() for i in range(self.num)]) H1 = -Sum(0,self.num,lambda i :x[i]*self.p[i].get_value() ) #重さが目的の重量になるように #H2 = Constraint((self.limit_weight -sum([x[i]*p_i.get_weight() for i,p_i in enumerate(self.p)]) - y*10)**2,"Const Weight") H2 = Constraint((self.limit_weight -Sum(0,self.num,lambda i: x[i]*self.p[i].get_weight()) - y*10)**2,"Const Weight") #H2 = Constraint((self.limit_weight -Sum(0,self.num,lambda i: x[i]*self.p[i].get_weight()))**2,"Const Weight") H = H1 + H2*Placeholder("balancer") model = H.compile() balance_dict = {"balancer":balancer} bqm = model.to_dimod_bqm(feed_dict=balance_dict) sampler = EmbeddingComposite(DWaveSampler(solver="Advantage_system1.1")) #sampler = EmbeddingComposite(DWaveSampler(solver="DW_2000Q_6")) responses = sampler.sample(bqm,num_reads=1000) solutions = model.decode_dimod_response(responses,feed_dict=balance_dict) #Optuna用 バランス調査 if count == True: counter = 0 for idx,sol in enumerate(solutions): const_str = sol[1] val = sum(int(sol[0]['x'][i])*self.p[i].get_value() for i in range(self.num)) weight = sum(int(sol[0]['x'][i])*self.p[i].get_weight() for i in range(self.num)) #重量が制限以下、かつ価値が最適解の9割以上をカウント if len(const_str) == 0 and val > Best*0.9 and weight <= self.limit_weight: counter += responses.record[idx][2] del H1,H2,H,model,bqm,responses,solutions gc.collect() return counter if len(solutions[0][1]) == 0: print(f" y= { sum(2**i*y_i for i,y_i in enumerate(solutions[0][0]['y']))}") print("## Advantage Solver Optimized Result") self.print([int(solutions[0][0]['x'][i]) for i in range(self.num)]) else: print("## Advantage Solver Optimizing Failed")
def test_placeholder_in_constraint(self): a = Binary("a") exp = Constraint(2 * Placeholder("c") + a, "const1") m = exp.compile() sol, broken, energy = m.decode_solution({"a": 1}, vartype="BINARY", feed_dict={"c": 1}) self.assertEqual(energy, 3.0) self.assertEqual(broken, {'const1': { 'result': { 'a': 1 }, 'penalty': 3.0 }}) self.assertEqual(sol, {'a': 1})
def test_order_enc_integer(self): a = OrderEncInteger("a", (0, 4), strength=Placeholder("s")) model = ((a - 3)**2).compile() q, offset = model.to_qubo(feed_dict={"s": 10.0}) expected_q = { ('a[3]', 'a[2]'): -8.0, ('a[0]', 'a[1]'): -8.0, ('a[3]', 'a[0]'): 2.0, ('a[2]', 'a[0]'): 2.0, ('a[1]', 'a[1]'): 5.0, ('a[3]', 'a[1]'): 2.0, ('a[2]', 'a[1]'): -8.0, ('a[3]', 'a[3]'): 5.0, ('a[0]', 'a[0]'): -5.0, ('a[2]', 'a[2]'): 5.0 } response = dimod.ExactSolver().sample_qubo(q) decoded = model.decode_sampleset(response, feed_dict={"s": 10.0})[0] self.assertTrue(decoded.subh["a"] == 3) self.assertTrue(a.value_range == (0, 4)) assert_qubo_equal(q, expected_q)
def tsp(n_city): t0 = time.time() x = Array.create('c', (n_city, n_city), 'BINARY') # Constraint not to visit more than two cities at the same time. time_const = 0.0 for i in range(n_city): # If you wrap the hamiltonian by Const(...), this part is recognized as constraint time_const += Constraint( (sum(x[i, j] for j in range(n_city)) - 1)**2, label="time{}".format(i)) # Constraint not to visit the same city more than twice. city_const = 0.0 for j in range(n_city): city_const += Constraint( (sum(x[i, j] for i in range(n_city)) - 1)**2, label="city{}".format(j)) # distance of route distance = 0.0 for i in range(n_city): for j in range(n_city): for k in range(n_city): # we set the constant distance d_ij = 10 distance += d_ij * x[k, i] * x[(k + 1) % n_city, j] # Construct hamiltonian A = Placeholder("A") H = distance + A * (time_const + city_const) # Compile model t1 = time.time() model = H.compile() qubo, offset = model.to_qubo(index_label=True, feed_dict={"A": 2.0}) t2 = time.time() return t1 - t0, t2 - t1