From 460db2369f9a14267e19cb68f75f1596369e2e1e Mon Sep 17 00:00:00 2001 From: Tom Date: Mon, 15 Apr 2019 23:09:12 +0200 Subject: [PATCH] prepared qpu solving --- .gitignore | 1 + create_wmis_result_table.sql | 5 +- run_sampler_on_scope.py | 97 ++++++++++++++++++++++++++++++++++++ test_data_extraction.py | 26 +++++----- test_sat_to_qubo_workflow.py | 49 +++++++++++++++--- util/graph.py | 9 ++++ util/queries.py | 3 ++ util/random_instance_pool.py | 17 +++++-- util/script.py | 17 ++++++- 9 files changed, 196 insertions(+), 28 deletions(-) create mode 100755 run_sampler_on_scope.py diff --git a/.gitignore b/.gitignore index 53e1ec5..f816b52 100644 --- a/.gitignore +++ b/.gitignore @@ -99,6 +99,7 @@ ENV/ #### config files # database.config +dwave.conf ### vim # diff --git a/create_wmis_result_table.sql b/create_wmis_result_table.sql index cf332c4..b4d854f 100644 --- a/create_wmis_result_table.sql +++ b/create_wmis_result_table.sql @@ -1,8 +1,7 @@ -create table c42_v5to84_1_wmis_qbsolv_results ( +create table c42_vLogistic_6_wmis_siman_results ( result_id char(24), + run int, instance_id char(24), - number_of_clauses int, - number_of_variables int, number_of_found_assignments int, chain_break_fraction float, num_occurrences int, diff --git a/run_sampler_on_scope.py b/run_sampler_on_scope.py new file mode 100755 index 0000000..97e12c2 --- /dev/null +++ b/run_sampler_on_scope.py @@ -0,0 +1,97 @@ +#!/usr/bin/env python3 + +import util.script as script +import util.queries as queries +import util.graph as graph + +import networkx as nx +import dwave_networkx as dnx +from neal import SimulatedAnnealingSampler +import dimod +from dwave.system.composites import FixedEmbeddingComposite +from dwave.system.samplers import DWaveSampler + +from tqdm import tqdm + +def main(): + mode = __get_mode() + + if mode == "SIMAN": + __run_siman() + elif mode == "QPU": + __run_qpu() + +def __get_mode(): + print("choose mode:") + print("(1) simulated annealing") + print("(2) qpu") + mode = int(input()) + + if mode == 1: + return "SIMAN" + elif mode == 2: + return "QPU" + +def __run_siman(): + db = script.connect_to_instance_pool() + target_graph = dnx.chimera_graph(16, 16, 4) + + solver_input_query = __get_solver_input_query(db, target_graph) + + base_sampler = SimulatedAnnealingSampler() + chimera_sampler = dimod.StructureComposite(base_sampler, + target_graph.nodes(), + target_graph.edges()) + + __run_on_scope(solver_input_query, db["wmis_siman_results"], base_sampler) + + +def __run_qpu(): + db = script.connect_to_instance_pool() + + base_solver = DWaveSampler() + + solver_input_query = __get_solver_input_query(db, solver_graph) + + solver_args = {} + solver_args["annealing_time"] = int(input("annealing time (in us): ")) + + __run_on_scope(solver_input_query, db["wmis_qpu_results"], base_solver, solver_args) + + + +def __get_solver_graph_id(db, solver): + solver_graph = graph.create_qpu_solver_nxgraph(solver) + return queries.get_id_of_solver_graph(db["solver_graphs"], + nx.node_link_data(solver_graph)) + +def __get_solver_input_query(db, solver): + solver_graph_id = __get_solver_graph_id(db, solver) + + scope = input("scope: ") + + solver_input_query = queries.WMIS_solver_input_scope_query(db) + solver_input_query.query(scope, solver_graph_id) + +def __run_on_scope(solver_input_query, result_collection, base_solver, solver_args=None): + run = int(input("save as run (numbered): ")) + + for solver_input in tqdm(solver_input_query): + + embedding = solver_input["embeddings"][0] + qubo = solver_input["qubo"] + + solver = FixedEmbeddingComposite(base_solver, embedding) + + res = solver.sample_qubo(qubo, **args) + + script.save_result(result_collection, + res, + solver_input, + emb_list_index = 0, + run = run) + + + +if __name__ == "__main__": + main() diff --git a/test_data_extraction.py b/test_data_extraction.py index d91b9e1..8f84d85 100755 --- a/test_data_extraction.py +++ b/test_data_extraction.py @@ -7,11 +7,11 @@ import dimod from tqdm import tqdm def main(): - instance_parameters() + #instance_parameters() #wmis_results() #wmis_siman_results_alpha_num_of_assignments() #wmis_siman_results() - #minisat_runs() + minisat_runs() def instance_parameters(): edb = script.connect_to_experimetns_db() @@ -20,15 +20,15 @@ def instance_parameters(): idb = script.connect_to_instance_pool() instances = queries.Instance_scope_query(idb) - instances.query("c42_vLogistic_1") + instances.query("c42_vLogistic_6") - insert_row = ("INSERT INTO c42_vLogistic_1_instances " + insert_row = ("INSERT INTO c42_vLogistic_6_instances " "(instance_id, " " number_of_clauses, " " number_of_variables) " "VALUES (%s, %s, %s)") - for instance, instance_id in instances: + for instance, instance_id in tqdm(instances): edb_cursor.execute(insert_row, (str(instance_id), int(instance.getNumberOfClauses()), int(instance.getNumberOfVariables()))) @@ -60,19 +60,18 @@ def wmis_siman_results_alpha_num_of_assignments(): idb = script.connect_to_instance_pool() q = queries.WMIS_result_scope_query_raw(idb) - q.query("c42_v[5-84]_1", "wmis_qbsolv_results") + q.query("c42_vLogistic_6", "wmis_siman_results") - insert_row = ("INSERT INTO c42_v5to84_1_wmis_qbsolv_results " + insert_row = ("INSERT INTO c42_vLogistic_6_wmis_siman_results " "(result_id, " + " run, " " instance_id, " - " number_of_clauses, " - " number_of_variables, " " number_of_found_assignments, " " chain_break_fraction, " " num_occurrences, " " energy, " " satisfiable) " - "VALUES (%s, %s, %s, %s, %s, %s, %s, %s, %s) ") + "VALUES (%s, %s, %s, %s, %s, %s, %s, %s) ") for result in tqdm(q): sample_set = queries.read_raw_wmis_sample_set(result["data"]) @@ -86,9 +85,8 @@ def wmis_siman_results_alpha_num_of_assignments(): isSatisfiable = sat.checkAssignment(model) edb_cursor.execute(insert_row, (str(result["_id"]), + int(result["run"]), str(result["instance"]), - int(sat.getNumberOfClauses()), - int(sat.getNumberOfVariables()), int(data["number_of_assignments"]), float(data["chain_break_fraction"]), int(data["num_occurrences"]), @@ -106,9 +104,9 @@ def minisat_runs(): idb = script.connect_to_instance_pool() runs = queries.Minisat_run_scope_query_raw(idb) - runs.query("c42_v[5-84]_1", "minisat_runs") + runs.query("c42_vLogistic_6", "minisat_runs") - insert_row = ("INSERT INTO c42_v5to84_1_minisat_runs " + insert_row = ("INSERT INTO c42_vLogistic_6_minisat_runs " "(run_id, " " instance_id, " " satisfiable) " diff --git a/test_sat_to_qubo_workflow.py b/test_sat_to_qubo_workflow.py index 991789f..779dc3c 100755 --- a/test_sat_to_qubo_workflow.py +++ b/test_sat_to_qubo_workflow.py @@ -5,6 +5,7 @@ import util.randomSAT as rand_sat import util.SAT2QUBO as SAT2QUBO import util.script as script import util.queries as queries +import util.graph as graph from dwave.system.composites import FixedEmbeddingComposite import dimod @@ -14,6 +15,10 @@ import networkx as nx import dwave_networkx as dnx import dwave.embedding +from dwave.cloud import Client +from dwave.cloud import Future +from dwave.system.samplers import DWaveSampler + from dwave_qbsolv import QBSolv import numpy as np @@ -63,23 +68,53 @@ def __wmis3(): nx.node_link_data(target_graph)) solver_input_query = queries.WMIS_solver_input_scope_query(db) - solver_input_query.query("c42_v[5-84]_1", target_graph_id) + solver_input_query.query("c42_vLogistic_6", target_graph_id) - #base_sampler = SimulatedAnnealingSampler() - base_sampler = QBSolv() + base_sampler = SimulatedAnnealingSampler() + #base_sampler = QBSolv() chimera_sampler = dimod.StructureComposite(base_sampler, target_graph.nodes(), target_graph.edges()) - + for solver_input in tqdm(solver_input_query): + sampler = FixedEmbeddingComposite(chimera_sampler, solver_input["embeddings"][0]) - res = sampler.sample_qubo(__negate_qubo(solver_input["qubo"]), solver_limit=2048) + #res = sampler.sample_qubo(solver_input["qubo"], solver_limit=2048) + res = sampler.sample_qubo(solver_input["qubo"]) + + script.save_result(db["wmis_siman_results"], + res, + solver_input, + 0, + 1) + +def __wmis_qpu(): + db = script.connect_to_instance_pool() + + base_solver = DWaveSampler() + + solver_graph = graph.create_qpu_solver_nxgraph(base_solver) + solver_graph_id = queries.get_id_of_solver_graph(db["solver_graphs"], + nx.node_link_data(solver_graph)) + + solver_input_query = queries.WMIS_solver_input_scope_query(db) + solver_input_query.query("c42_vLogistic_6", solver_graph_id) + + for solver_input in tqdm(solver_input_query): + + embedding = solver_input["embeddings"][0] + qubo = solver_input["qubo"] + + solver = FixedEmbeddingComposite(base_solver, embedding) + + res = solver.sample_qubo(qubo, annealing_time=5) - script.save_simulated_annealing_result(db["wmis_qbsolv_results"], + script.save_result(db["wmis_qpu_results"], res, solver_input, - 0) + emb_list_index = 0, + run = 1) diff --git a/util/graph.py b/util/graph.py index 6bd33ab..bcb8ff2 100644 --- a/util/graph.py +++ b/util/graph.py @@ -16,3 +16,12 @@ def negate_qubo(qubo): negative_qubo[coupler] = -1 * energy return negative_qubo + +def create_qpu_solver_nxgraph(solver): + graph = nx.Graph() + + graph.name = solver.id + + graph.add_edges_from(solver.edges) + + return graph diff --git a/util/queries.py b/util/queries.py index 8401a74..ea4232d 100644 --- a/util/queries.py +++ b/util/queries.py @@ -398,6 +398,9 @@ def read_raw_qubo(raw_qubo): def read_raw_embedding(raw_embedding): emb = {} + if "embedding" in raw_embedding: + raw_embedding = raw_embedding["embedding"] + for entry in raw_embedding: emb[tuple(entry[0])] = entry[1] diff --git a/util/random_instance_pool.py b/util/random_instance_pool.py index 8e1a8a7..750a3d9 100644 --- a/util/random_instance_pool.py +++ b/util/random_instance_pool.py @@ -116,12 +116,12 @@ class Random_logistic_variable_distribution: min_variables, max_variables, alpha_point_of_interest, - steepnesss): + steepness): self.__number_of_clauses = number_of_clauses self.__min_variables = min_variables self.__max_variables = max_variables self.__alpha_point_of_interest = alpha_point_of_interest - self.__steepnesss = steepnesss + self.__steepness = steepness def random(self): number_of_variables = 0 @@ -131,7 +131,7 @@ class Random_logistic_variable_distribution: alpha = inv_logistic(random.random(), 1, - self.__steepnesss, + self.__steepness, self.__alpha_point_of_interest) number_of_variables = int(self.__number_of_clauses / alpha) @@ -140,6 +140,17 @@ class Random_logistic_variable_distribution: def inv_logistic(x, L, k, x0): return math.log(math.pow(x / (L-x), 1/k)) + x0 + +def create_random_logistic_pool(logistic_variable_distr_params, number_of_instances, + instance_params): + + logist_distr = Random_logistic_variable_distribution(**logistic_variable_distr_params) + + rnd_range = Random_range(logist_distr, number_of_instances) + + param_range = Instance_parameter_variable_range(instance_params, rnd_range) + + return Random_instance_pool(param_range) def test(): sns.set() diff --git a/util/script.py b/util/script.py index bb97334..aff6624 100644 --- a/util/script.py +++ b/util/script.py @@ -7,12 +7,14 @@ import mysql.connector import networkx as nx from . import queries from . import graph +from . import SAT2QUBO import minorminer from tqdm import tqdm import numpy as np import random import sys + def readConfig(configFilePath): config = configparser.ConfigParser() @@ -177,6 +179,15 @@ def write_qubo_to_pool_db(collection, qubo, sat_instance_id): collection.insert_one(doc) +def create_wmis_qubos_for_scope(db, scope): + instances = queries.Instance_scope_query(db) + instances.query(scope) + + for instance, instance_id in instances: + qubo = SAT2QUBO.WMISdictQUBO(instance) + + write_qubo_to_pool_db(db["wmis_qubos"], qubo, instance_id) + def __qubo_to_JSON(qubo): quboJSON = [] @@ -295,7 +306,7 @@ def find_wmis_embeddings_for_scope(db, scope, solver_graph): percentage)) print("{} new embeddigns found".format(new_embeddings_found)) -def save_simulated_annealing_result(collection, result, solver_input, emb_list_index): +def save_sample_set(collection, result, solver_input, emb_list_index, run): doc = {} doc["data"] = result.to_serializable() @@ -304,9 +315,13 @@ def save_simulated_annealing_result(collection, result, solver_input, emb_list_i "embedding_id": solver_input["embeddings_id"], "list_index": emb_list_index } + doc["run"] = run collection.insert_one(doc) +def save_qpu_result(): + doc = {} + def analyze_wmis_sample(sample): data = {}