def evolve(self, g, n_mutants, n_generations):
self.n_mutants = n_mutants
self.n_gens = n_generations
self.g_orig = g.copy()
to_graph_like(self.g_orig)
self.c_orig = zx.extract_circuit(self.g_orig.copy()).to_basic_gates()
self.c_orig = zx.basic_optimization(self.c_orig)
# self.c_orig = c
# self.g_orig = c.to_graph()
# to_graph_like(self.g_orig)
# self.mutants = [Mutant(c, self.g_orig) for _ in range(self.n_mutants)]
self.mutants = [Mutant(self.c_orig, self.g_orig) for _ in range(self.n_mutants)]
self.update_scores()
best_mutant = min(self.mutants, key=lambda m: m.score) # FIXME: Check if this assignment is by reference or value
best_score = best_mutant.score
gen_scores = [best_score]
best_scores = [best_score]
for i in tqdm(range(self.n_gens), desc="Generations", disable=self.quiet):
n_unique_mutants = len(list(set([id(m) for m in self.mutants])))
assert(n_unique_mutants == self.n_mutants)
self.mutate()
# self.update_scores()
best_in_gen = min(self.mutants, key=lambda m: m.score)
gen_scores.append(best_in_gen.score) # So that if we never improve, we see each generation. Because our actions might all rely on extracting, we may never improve on the original
if best_in_gen.score < best_score:
best_mutant = deepcopy(best_in_gen)
best_score = best_in_gen.score
best_scores.append(best_score)
if all([m.dead for m in self.mutants]):
print("[_optimize] stopping early -- all mutants are dead")
break
self.select()
return best_scores, gen_scores, best_mutant.c_curr
g_just_tr = g.copy()
zx.teleport_reduce(g_just_tr)
c_just_tr = zx.Circuit.from_graph(g_just_tr.copy()).to_basic_gates()
print("\n----- teleport_reduce -----")
print(c_just_tr.stats())
g_tr = g.copy()
zx.teleport_reduce(g_tr)
c_tr = zx.Circuit.from_graph(g_tr.copy()).to_basic_gates()
# c_opt = zx.full_optimize(c_opt)
c_tr = zx.basic_optimization(c_tr)
g_tr = c_tr.to_graph()
print("\n----- teleport_reduce + basic_optimization -----")
print(c_tr.stats())
to_graph_like(g_tr)
g_tr_extract = g.copy()
zx.teleport_reduce(g_tr_extract)
c_tr_extract = zx.extract_circuit(g_tr_extract.copy()).to_basic_gates()
c_tr_extract = zx.basic_optimization(c_tr_extract)
print("\n----- teleport_reduce (extract) + basic_optimization -----")
print(c_tr_extract.stats())
g_tr2 = g.copy()
zx.teleport_reduce(g_tr2)
c_tr2 = zx.Circuit.from_graph(g_tr2.copy()).to_basic_gates()
c_tr2 = zx.full_optimize(c_tr2)
g_tr2 = c_tr2.to_graph()
print("\n----- teleport_reduce + full_optimize -----")
print(c_tr2.stats())
g = c.to_graph()
g_tmp = g.copy()
if REDUCE_METHOD == "TR":
zx.teleport_reduce(g_tmp)
c_tr = zx.Circuit.from_graph(g_tmp.copy()).to_basic_gates()
c_tr = zx.basic_optimization(c_tr)
g_simp = c_tr.to_graph()
elif REDUCE_METHOD == "FR":
zx.full_reduce(g_tmp)
g_simp = g_tmp.copy()
else:
raise RuntimeError(f"Invalid REDUCE_METHOD: {REDUCE_METHOD}")
to_graph_like(g_simp)
_, scores = pivot_anneal(g_simp, iters=N_ITERS)
final_score = scores[-1]
for x in range(0, N_ITERS, INTERVAL):
if final_score < scores[x]:
improvement_after[x].append(1)
else:
improvement_after[x].append(0)
pdb.set_trace()
improvement_after_probs = {k: np.mean(v) for k, v in improvement_after.items()}
xs = list(improvement_after_probs.keys())
ys = list(improvement_after_probs.values())