def simulate(structure, system_size, fill, interaction_shape, interaction_radius, algorithm, init_temp, cool_rate, exact_min_energy, exact_min_gap): prob = maxcut.initialize_problem(structure, system_size, fill, interaction_shape, interaction_radius) algorithm.set_cooling_schedule(init_temp, cool_rate) algorithm.solve(prob) step = len(algorithm.get_temp_history()) min_energy = prob.get_best_energy() temp_hist = algorithm.get_temp_history() energy_hist = prob.get_energy_history() partition_hist = prob.get_partition_history() if len(temp_hist) != len(energy_hist): raise RuntimeError( 'Length of temperature and energy histories must match') ground_state_found = None if exact_min_energy: ground_state_found = [0 for t in range(len(energy_hist))] if abs(min_energy - exact_min_energy) <= exact_min_gap: ground_state_found = [ float( np.round(energy_hist[t], 10) == np.round(min_energy, 10)) for t in range(len(energy_hist)) ] elif min_energy - exact_min_energy < -exact_min_gap: print('WARNING: Cannot reach energy below ground state energy') return [ step, temp_hist, energy_hist, partition_hist, ground_state_found, min_energy, prob ]
def exact_solve(structure, system_size, fill, interaction_shape, interaction_radius, path): radius_dir_path = '{}/radius_{}'.format(path, interaction_radius) util.make_dir(radius_dir_path) start = time.time() prob = maxcut.initialize_problem(structure, system_size, fill, interaction_shape, interaction_radius) min_energy, num_ground_states, sample_ground_state, num_total_states, all_energies = classical_algorithms.BruteForce( ).solve(prob) if structure != 'free': with open('{}/ground_state_partitions.csv'.format(radius_dir_path), 'w') as output_file: header = sample_ground_state.keys() dict_writer = csv.DictWriter(output_file, header) dict_writer.writeheader() dict_writer.writerow(sample_ground_state) with open('{}/energies.csv'.format(radius_dir_path), 'w') as output_file: writer = csv.writer(output_file) writer.writerow(['energy']) min_gap = float('inf') prev_energy = 0.0 for energy in sorted(all_energies): writer.writerow([energy]) if energy != prev_energy: min_gap = min(abs(energy - prev_energy), min_gap) prev_energy = energy end = time.time() return { 'radius': interaction_radius, 'min energy': min_energy, '# ground states': num_ground_states, '# states': num_total_states, 'min energy gap': min_gap, 'runtime': end - start }
def param_search(structure, system_size, fill, interaction_shape, interaction_radius, ensemble, path, exact_min_energy, exact_min_gap): radius_dir_path = '{}/radius_{}'.format(path, interaction_radius) util.make_dir(radius_dir_path) start = time.time() algorithm = classical_algorithms.SimulatedAnnealing() cooling_schedules = maxcut.get_cooling_schedules( problem=maxcut.initialize_problem(structure, system_size, fill, interaction_shape, interaction_radius)) radius_sols = [] sample_best_probs = {} for init_temp, cool_rate in cooling_schedules: radius_sols.append( run_trials(structure, system_size, fill, interaction_shape, interaction_radius, algorithm, ensemble, radius_dir_path, exact_min_energy, exact_min_gap, init_temp, cool_rate, sample_best_probs)) with open('{}/param_results.csv'.format(radius_dir_path), 'w') as output_file: header = radius_sols[0].keys() dict_writer = csv.DictWriter(output_file, header) dict_writer.writeheader() dict_writer.writerows(radius_sols) opt_sol = min(radius_sols, key=lambda sol: sol['step_from_exact']) opt_init_temp = opt_sol['init_temp'] opt_cool_rate = opt_sol['cool_rate'] opt_step_from_exact = opt_sol['step_from_exact'] opt_step_from_entropy = opt_sol['step_from_entropy'] opt_prob_ground_state_per_run = opt_sol['prob_ground_state_per_run'] if structure != 'free': sample_best_prob = sample_best_probs[(opt_init_temp, opt_cool_rate)] sample_best_partition_hist = sample_best_prob.get_partition_history() sample_best_energy_hist = sample_best_prob.get_energy_history() with open('{}/ground_state_partitions.csv'.format(radius_dir_path), 'w') as output_file: header = sample_best_partition_hist[0].keys() dict_writer = csv.DictWriter(output_file, header) dict_writer.writeheader() dict_writer.writerows(sample_best_partition_hist) with open('{}/ground_state_energies.csv'.format(radius_dir_path), 'w') as output_file: writer = csv.writer(output_file) writer.writerow(['energy']) for energy in sample_best_energy_hist: writer.writerow([energy]) end = time.time() return dict(interaction_radius=interaction_radius, init_temp=opt_init_temp, cool_rate=opt_cool_rate, step_from_exact=opt_step_from_exact, step_from_entropy=opt_step_from_entropy, prob_ground_state_per_run=opt_prob_ground_state_per_run, search_runtime=(end - start), exact_min_energy=exact_min_energy)
def maxcut_to_quantum(structure, system_size, fill, interaction_shape, interaction_radius): prob = maxcut.initialize_problem(structure, system_size, fill, interaction_shape, interaction_radius) N = prob.get_num_vertices() basis = spin_basis_general(N) # Hamiltonian terms for Ising interactions and reference field J_zz = prob.get_edges() h_x = [[-1, i] for i in range(N)] # Hamiltonian for Ising interactions static = [["zz", J_zz]] dynamic = [] H = hamiltonian(static, dynamic, basis=basis, dtype=np.float64) # reference Hamiltonian B = hamiltonian([["x", h_x]], [], dtype=np.float64, basis=basis, check_herm=False, check_symm=False) # initial state: all up in x basis (ground state of reference Hamiltonian) psi_0 = (1 / (2**(N / 2))) * np.ones(2**N, ) # all up in x basis # exact ground states states = util.get_states_str(system_size) ground_state_energy, num_ground_states, ground_states = classical_algorithms.BruteForce( ).solve(prob, allGroundStates=True) ground_states_id = [] for ground_state in ground_states: ground_state_str = '' for v in range(N): ground_state_str += str(int((ground_state[v] + 1) / 2)) ground_states_id.append(states.index(ground_state_str)) return H, B, psi_0, ground_states_id
row['search_runtime']) if row['exact_min_energy']: system_sols[interaction_radius]['exact_min_energy'] = float( row['exact_min_energy']) if structure != 'free' and interaction_shape != 'random': util.plot_steps_vs_radius(system_sols, system_size, interaction_shape, algo_dir_path) for interaction_radius, system_sol in system_sols.items(): exact_radius_dir_path = '{}/radius_{}'.format(exact_dir_path, interaction_radius) algo_radius_dir_path = '{}/radius_{}'.format(algo_dir_path, interaction_radius) prob = maxcut.initialize_problem(structure, system_size, fill, interaction_shape, interaction_radius) if structure != 'free' and interaction_shape != 'random': util.plot_interaction(maxcut.get_interaction_fn(interaction_shape), interaction_radius, system_size, experiment.LATTICE_SPACING, algo_radius_dir_path) param_results = collections.defaultdict(dict) with open('{}/param_results.csv'.format(algo_radius_dir_path), 'r') as input_file: dict_reader = csv.DictReader(input_file) for row in dict_reader: init_temp = float(row['init_temp']) cool_rate = float(row['cool_rate']) # print(cool_rate) param_results[init_temp][cool_rate] = {}
def run_trials(structure, system_size, fill, interaction_shape, interaction_radius, algorithm, ensemble, path, init_temp, cool_rate, sample_best_probs): param_sols = [] exact_min_energies = [] exact_min_gaps = [] prob = None exact_min_energy = None exact_min_gap = None for i in range(NUM_PARAM_TRIALS): if i % 10 == 0: prob = maxcut.initialize_problem(structure, system_size, fill, interaction_shape, interaction_radius) exact_sol = maxcut_exact.exact_solve_prob(prob) exact_min_energy = exact_sol['min energy'] exact_min_gap = exact_sol['min energy gap'] exact_min_energies.append(exact_min_energy) exact_min_gaps.append(exact_min_gap) prob.reset() param_sols.append( simulate(prob, algorithm, init_temp, cool_rate, exact_min_energy, exact_min_gap)) steps, temp_hists, energy_hists, partition_hists, ground_states_found, min_energies, probs = np.array( param_sols).T min_energy = min(min_energies) sample_best_probs[(init_temp, cool_rate)] = probs[np.argmin(min_energies)] all_temps_hist, all_energies_hist, all_partitions_hist, all_ground_states_found_hist, all_energies_vs_temp, all_partitions_vs_temp, all_ground_states_found_vs_temp = collect_param_stats( temp_hists, energy_hists, ground_states_found, partition_hists, exact_min_energies) stats_vs_temp = [] for temp in all_energies_vs_temp.keys(): stats_vs_temp.append( get_param_stats_per_temp(temp, all_energies_vs_temp, all_partitions_vs_temp, all_ground_states_found_vs_temp)) stats_vs_t = [] for t in all_energies_hist.keys(): stats_vs_t.append( get_param_stats_per_t(t, all_temps_hist, all_energies_hist, all_partitions_hist, all_ground_states_found_hist)) min_energy_from_entropy = get_total_iters(stats_vs_t, energy_hists, all_ground_states_found_hist, exact_min_energies) step_ave = np.mean(steps) step_from_exact = None step_from_entropy = None prob_ground_state_per_run = None t_opt_exact = None MT_exact = {} MT_from_entropy = {} for stat_vs_t in stats_vs_t: t = stat_vs_t['t'] if t == 0: continue if stat_vs_t['total_iter']: MT_exact[t] = stat_vs_t['total_iter'] if stat_vs_t['total_iter_from_entropy']: MT_from_entropy[t] = stat_vs_t['total_iter_from_entropy'] if len(MT_exact) > 0: t_opt_exact = min(MT_exact, key=MT_exact.get) step_from_exact = MT_exact[t_opt_exact] stat_vs_t_opt_exact = [ stat_vs_t for stat_vs_t in stats_vs_t if stat_vs_t['t'] == t_opt_exact ][0] prob_ground_state_per_run = stat_vs_t_opt_exact[ 'ave_prob_ground_state'] if len(MT_from_entropy) > 0: t_opt_from_entropy = min(MT_from_entropy, key=MT_from_entropy.get) step_from_entropy = MT_from_entropy[t_opt_from_entropy] with open( '{}/stats_vs_temp_T_0_{}_r_{}.csv'.format(path, init_temp, cool_rate), 'w') as output_file: header = stats_vs_temp[0].keys() dict_writer = csv.DictWriter(output_file, header) dict_writer.writeheader() dict_writer.writerows(stats_vs_temp) with open( '{}/stats_vs_t_T_0_{}_r_{}.csv'.format(path, init_temp, cool_rate), 'w') as output_file: header = stats_vs_t[0].keys() dict_writer = csv.DictWriter(output_file, header) dict_writer.writeheader() dict_writer.writerows(stats_vs_t) return dict(init_temp=init_temp, cool_rate=cool_rate, min_energy=min_energy, min_energy_from_entropy=min_energy_from_entropy, step_from_exact=step_from_exact, step_from_entropy=step_from_entropy, step_per_run=t_opt_exact, prob_ground_state_per_run=prob_ground_state_per_run)