def plot_smp_accuracy():
df = get_computation_result("smp_bt_time_qa_qbsolv")
sizes = df["size"].unique()
df["bt_stable"] = df["bt_stable"] / df["matching_count"]
df["qa_stable"] = df["qa_stable"] / df["matching_count"]
df["qbsolv_stable"] = df["qbsolv_stable"] / df["matching_count"]
dfvar = df.groupby(["size"]).var()
df = df.groupby(["size"]).mean()
plt.title("Accuracy for SMP")
width = 0.75
plt.bar(sizes - width / 3,
100 * df["qa_stable"],
label="qa",
width=width / 3,
align="center")
plt.bar(sizes,
100 * df["qbsolv_stable"],
label="qbsolv",
width=width / 3,
align="center")
plt.bar(sizes + width / 3,
100 * df["bt_stable"],
label="backtracking",
width=width / 3,
align="center")
plt.xticks(sizes)
plt.ylabel('portion of available solutions [%]')
plt.xlabel('problem size')
plt.legend()
show_store_plot("smp_accuracy")
def plot_accuracy_algorithms():
solver_types = ["qbsolv", "shiftbrk", "kiraly", "qa"]
df = get_computation_result("accuracy_results")
df["qa_size"] = list(map(lambda x: 0 if x == -1 else x, df["qa_size"]))
df["qbsolv_size"] = list(
map(lambda x: 0 if x == -1 else x, df["qbsolv_size"]))
del df["index_f"]
sizes = df["size"].unique()
results = {solver: {size: 0 for size in sizes} for solver in solver_types}
for index, row in df.iterrows():
for solver_type in solver_types:
if row[f"{solver_type}_stable"] == 1.0 and row[
f"{solver_type}_size"] == row["lp_size"]:
size = int(row["size"])
results[solver_type][size] = results[solver_type][size] + 1
results = {k: list(v.values()) for k, v in results.items()}
results = {k: list(map(lambda x: x / 50.0, v)) for k, v in results.items()}
plt.title("Accuracy of approximation algorithms vs QA vs qbsolv")
plt.plot(sizes, results["qbsolv"], label="QUBO-MAX-SMTI (qbsolv)")
plt.plot(sizes[:5], results["qa"][:5], label="QUBO-MAX-SMTI (qa)")
plt.plot(sizes, results["shiftbrk"], label="SHIFTBRK")
plt.plot(sizes, results["kiraly"], label="Krialy2")
# plt.xticks(sizes)
plt.ylabel('accuracy [%]')
plt.xlabel('problem size')
plt.legend()
show_store_plot("accuracy_qbsolv_vs_apx")
def compare_runtime_algorithms(plot_preprocessing=False):
solver_types = ["qubo", "lp", "shiftbrk", "kiraly"]
df = get_computation_result("time_result")
df_1 = get_computation_result("qubo_lp_time_result")
df_1 = df_1.groupby(["size"]).mean()
for solver_type in solver_types:
del df[f"{solver_type}_stable"]
del df[f"{solver_type}_size"]
del df["index_f"]
sizes = df["size"].unique()
df = df.groupby(["size"]).mean()
# convert to ms
conv = 1000
df_1["qubo_dt"] = df_1["qubo_pp[s]"] * conv
df["qubo_dt"] = df["qubo_dt[s]"] * conv
df["qubo_dt_var"] = df["qubo_dt_var[%]"] / 100 * df["qubo_dt"]
df["lp_dt"] = df["lp_dt[s]"] * conv
df["lp_dt_var"] = df["lp_dt_var[%]"] / 100 * df["lp_dt"]
df["shiftbrk_dt"] = df["shiftbrk_dt[s]"] * conv
df["shiftbrk_dt_var"] = df["shiftbrk_dt_var[%]"] / 100 * df["shiftbrk_dt"]
df["kiraly_dt"] = df["kiraly_dt[s]"] * conv
df["kiraly_dt_var"] = df["kiraly_dt_var[%]"] / 100 * df["kiraly_dt"]
if plot_preprocessing:
pass
plt.plot(sizes, df_1["qubo_dt"], label="QUBO (only preprocessing")
else:
plt.plot(sizes, df["qubo_dt"], label="QUBO")
plt.plot(sizes, df["lp_dt"], label="MAX-SMTI-LP")
plt.plot(sizes, df["shiftbrk_dt"], label="SHIFTBRK")
plt.plot(sizes, df["kiraly_dt"], label="Krialy2")
plt.ylabel('time [ms]')
plt.xlabel('problem size')
plt.legend()
if plot_preprocessing:
show_store_plot("runtime_qubo_preprocessing")
else:
show_store_plot("runtime")
def compare_qbsolv_preprocessing():
df = get_computation_result("qubo_lp_time_result")
df["qubo_total_time"] = df["qubo_pp[s]"] + df["qubo_solving[s]"]
sizes = df["size"].unique()
df = df.groupby(["size"]).mean()
plt.plot(sizes, df["qubo_total_time"])
plt.plot(sizes, df["qubo_pp[s]"])
plt.fill_between(sizes, df["qubo_pp[s]"], df["qubo_total_time"], alpha=0.30, label="time to solve QUBO")
plt.fill_between(sizes, 0, df["qubo_pp[s]"], alpha=0.30, label="time for preprocessing")
plt.margins(x=0.01, y=0.01)
plt.legend()
show_store_plot("qubo_pp_runtime")
def plot_qubo_qa_vs_lp():
solvers = ["lp", "qa", "qbsolv"]
df = get_computation_result("qbsolv_en_results")
sizes = df["size"].unique()
qbsolv_results = {
size: {
"opt": 0,
"stable": 0,
"invalid": 0
}
for size in sizes
}
qa_results = {
size: {
"opt": 0,
"stable": 0,
"invalid": 0
}
for size in sizes
}
for index, row in df.iterrows():
# more negative energy is better
size = row["size"]
assert row["opt_en"] == row["lp_en"]
if row["opt_en"] == row["qbsolv_en"]:
qbsolv_results[size]["opt"] += 1
elif row["opt_en"] < row["qbsolv_en"] < row["min_valid_en"]:
qbsolv_results[size]["stable"] += 1
else:
qbsolv_results[size]["invalid"] += 1
if size < 8:
if row["opt_en"] == row["qa_en"]:
qa_results[size]["opt"] += 1
elif row["opt_en"] < row["qa_en"] < row["min_valid_en"]:
qa_results[size]["stable"] += 1
else:
qa_results[size]["invalid"] += 1
_barplot_en_results(qbsolv_results, sizes, solver_t="qbsolv")
_barplot_en_results(qa_results, sizes[:5], solver_t="qa")
def compare_qbsolv_backtracking():
df = get_computation_result("qubo_vs_backtrack_smp")
# df_means = df.groupby([""])
sizes = []
for size in range(3, 18):
sizes = sizes + [size] * 20
df["size"] = sizes
df_mean = df.groupby(["size"]).mean()
df_error = df.groupby(["size"]).sum()
sizes = df["size"].unique()
f, (ax, ax2) = plt.subplots(2, 1, sharex=True)
ax.errorbar(sizes, df_mean["mean_b"], yerr=df_error["var_b"], label="backtracking")
ax2.errorbar(sizes, df_mean["mean_b"], yerr=df_error["var_b"], label="backtracking")
ax.errorbar(sizes, df_mean["mean_q"], yerr=df_error["var_q"], label="qbsolv")
ax2.errorbar(sizes, df_mean["mean_q"], yerr=df_error["var_q"], label="qbsolv")
# copy paste from https://matplotlib.org/3.1.0/gallery/subplots_axes_and_figures/broken_axis.html
ax.set_ylim(10, 90)
ax2.set_ylim(0, 10)
ax.spines['bottom'].set_visible(False)
ax2.spines['top'].set_visible(False)
ax.xaxis.tick_top()
ax.tick_params(labeltop=False) # don't put tick labels at the top
ax2.xaxis.tick_bottom()
d = .015
kwargs = dict(transform=ax.transAxes, color='k', clip_on=False)
ax.plot((-d, +d), (-d, +d), **kwargs)
ax.plot((1 - d, 1 + d), (-d, +d), **kwargs)
kwargs.update(transform=ax2.transAxes)
ax2.plot((-d, +d), (1 - d, 1 + d), **kwargs)
ax2.plot((1 - d, 1 + d), (1 - d, 1 + d), **kwargs)
ax.legend()
plt.show()
pass