def plot_basis_state_populations_3d(e_qs: EvolvingQubitSystem): if e_qs.solve_result is None: e_qs.solve() states = get_states(e_qs.N) times = [] heights = [] xs = [] for i, _solve_result_state in enumerate(e_qs.solve_result.states): plt.ylim(0, 1) plt.grid(axis='y') solve_result_state_populations = np.abs(_solve_result_state.data.toarray().flatten()) ** 2 for _x, state in enumerate(states): state_product_basis_index = get_product_basis_states_index(state) basis_state_population = solve_result_state_populations[state_product_basis_index] times.append(e_qs.solve_result.times[i]) xs.append(_x) heights.append(basis_state_population) fig = plt.figure(figsize=(15, 8)) ax = fig.add_subplot(111, projection="3d") dt = e_qs.solve_result.times[1] - e_qs.solve_result.times[0] ax.bar3d(xs, times, z=0, dx=0.8, dy=dt, dz=heights) labels = [get_label_from_state(state) for state in states] x = np.arange(len(labels)) plt.xticks(x, labels) ax.yaxis.set_major_formatter(ticker.EngFormatter('s')) plt.ylabel('Time') plt.show()
def get_normalised_hamiltonian(N: int, norm_V: float): norm_e_qs = EvolvingQubitSystem( N=N, V=norm_V, geometry=RegularLattice1D(), Omega=None, Delta=None, t_list=None, ghz_state=None ) norm_hamiltonian = norm_e_qs.get_hamiltonian() norm_H_d = norm_hamiltonian[0] # "drift": time-independent part norm_H_c = [norm_hamiltonian[1][0], norm_hamiltonian[2][0]] # "control": time-dependent parts return norm_H_d, norm_H_c, norm_e_qs.psi_0
def solve_and_print_stats(e_qs: EvolvingQubitSystem): import time start_time = time.time() e_qs.solve() print(f"Solved in {time.time() - start_time:.2f}s") fidelity_with_ghz = e_qs.get_fidelity_with("ghz") fidelity_with_ghz_asymmetric = e_qs.get_fidelity_with("ghz_antisymmetric") print(f"fidelity with GHZ: {fidelity_with_ghz:.4f} (with antisymmetric: {fidelity_with_ghz_asymmetric:.4f})") fidelity_with_ground = e_qs.get_fidelity_with("ground") fidelity_with_excited = e_qs.get_fidelity_with("excited") superposition_probability = fidelity_with_ground + fidelity_with_excited print( f"superposition probability: {superposition_probability:.4f} (g: {fidelity_with_ground:.4f}, e: {fidelity_with_excited:.4f})") e_qs.plot(with_antisymmetric_ghz=True)
def plot_basis_state_populations_2d(e_qs: EvolvingQubitSystem, log=False, log_limit=1e-6): if e_qs.solve_result is None: e_qs.solve() quartile_index = int(len(e_qs.t_list) / 4) indices = [0, quartile_index, quartile_index * 2, quartile_index * 3, -1] states = get_states(e_qs.N) labels = [get_label_from_state(state) for state in states] x = np.arange(len(labels)) fig, axs = plt.subplots(len(indices) , 1, sharex='all', figsize=(10, 8)) for _i, i in enumerate(indices): ax = axs[_i] if not log: ax.set_ylim(0, 1) else: ax.set_ylim(log_limit, 1) ax.set_yscale('log', basey=10) ax.grid(axis='y') ax.set_ylabel(f"{e_qs.solve_result.times[i]:.2e}s") basis_state_populations = [] _solve_result_state = e_qs.solve_result.states[i] solve_result_state_populations = np.abs(_solve_result_state.data.toarray().flatten()) ** 2 for state in states: state_product_basis_index = get_product_basis_states_index(state) basis_state_population = solve_result_state_populations[state_product_basis_index] basis_state_populations.append(basis_state_population) if log: basis_state_population += log_limit ax.bar(x=x, height=basis_state_populations) plt.xticks(x, labels) plt.tight_layout() plt.show()
def solve_and_print_stats(e_qs: EvolvingQubitSystem): e_qs.solve() fidelity_with_ghz = e_qs.get_fidelity_with("ghz") fidelity_with_ghz_asymmetric = e_qs.get_fidelity_with("ghz_antisymmetric") print( f"fidelity with GHZ: {fidelity_with_ghz:.4f} (with antisymmetric: {fidelity_with_ghz_asymmetric:.4f})" ) fidelity_with_ground = e_qs.get_fidelity_with("ground") fidelity_with_excited = e_qs.get_fidelity_with("excited") superposition_probability = fidelity_with_ground + fidelity_with_excited print( f"superposition probability: {superposition_probability:.4f} (g: {fidelity_with_ground:.4f}, e: {fidelity_with_excited:.4f})" ) e_qs.plot(with_antisymmetric_ghz=True, savefig_name="evolving_fidelities.png", show=True)
def _create_evolving_qubit_system(self): t_list = self.evolving_qubit_system_kwargs['t_list'] _Omegas = np.array(self.recorded_steps['Omega']) Omega = get_hamiltonian_coeff_linear_interpolation(t_list, self.recorded_steps['Omega']) _Deltas = np.array(self.recorded_steps['Delta']) Delta = get_hamiltonian_coeff_linear_interpolation(t_list, _Deltas) # print("o:", _Omegas) # print("d:", _Deltas) evolving_qubit_system = EvolvingQubitSystem( **self.evolving_qubit_system_kwargs, Omega=Omega, Delta=Delta ) return evolving_qubit_system
def plot_optimresult(result: OptimResult, N: int, t: float, C6: float, characteristic_V: float, geometry: BaseGeometry, ghz_state: BaseGHZState = None): if ghz_state is None: ghz_state = StandardGHZState(N) final_Omega = np.hstack((result.final_amps[:, 0], result.final_amps[-1, 0])) final_Delta = np.hstack((result.final_amps[:, 1], result.final_amps[-1, 1])) time = result.time / characteristic_V final_Omega *= characteristic_V final_Delta *= characteristic_V e_qs = EvolvingQubitSystem( N=N, V=C6, geometry=geometry, Omega=get_hamiltonian_coeff_interpolation(time, final_Omega, "previous"), Delta=get_hamiltonian_coeff_interpolation(time, final_Delta, "previous"), t_list=np.linspace(0, t, 300), ghz_state=ghz_state ) solve_and_print_stats(e_qs)
def solve_and_print_stats(e_qs: EvolvingQubitSystem, **kwargs): import time start_time = time.time() e_qs.solve() print(f"Solved in {time.time() - start_time:.2f}s") fidelity_with_ghz = e_qs.get_fidelity_with("ghz") fidelity_with_ghz_asymmetric = e_qs.get_fidelity_with("ghz_antisymmetric") print( f"fidelity with GHZ: {fidelity_with_ghz:.4f} (with antisymmetric: {fidelity_with_ghz_asymmetric:.4f})" ) fidelity_with_ground = e_qs.get_fidelity_with("ground") fidelity_with_excited = e_qs.get_fidelity_with("excited") superposition_probability = fidelity_with_ground + fidelity_with_excited print( f"superposition probability: {superposition_probability:.4f} (g: {fidelity_with_ground:.4f}, e: {fidelity_with_excited:.4f})" ) e_qs.plot(with_antisymmetric_ghz=True, **kwargs, fig_kwargs={'figsize': (6, 4)}, plot_titles=False, plot_others_as_sum=True)
def plot_optimresult(result: OptimResult, N: int, geometry: BaseGeometry, t: float, unnormalise_V: float, **kwargs): time = result.time final_Omega = np.hstack( (result.final_amps[:, 0], result.final_amps[-1, 0])) final_Delta = np.hstack( (result.final_amps[:, 1], result.final_amps[-1, 1])) t /= unnormalise_V time = result.time / unnormalise_V final_Omega *= unnormalise_V final_Delta *= unnormalise_V e_qs = EvolvingQubitSystem( N=N, V=C6, geometry=geometry, Omega=get_hamiltonian_coeff_interpolation(time, final_Omega, "previous"), Delta=get_hamiltonian_coeff_interpolation(time, final_Delta, "previous"), t_list=np.linspace(0, t, 300), ghz_state=StandardGHZState(N)) solve_and_print_stats(e_qs, **kwargs)
iter_stop=40, continue_from=Result.load(OPT_RESULT_DUMP, objectives=objectives) if CONTINUE_FROM else None ) dump_file_name = OPT_RESULT_DUMP if not CONTINUE_FROM else OPT_RESULT_DUMP + "_1" opt_result.dump(dump_file_name) print(opt_result) if SHOW_PLOTS: plot_pulse(opt_result.optimized_controls[0], norm_t_list, "Optimised $\Omega$") plot_pulse(opt_result.optimized_controls[1], norm_t_list, "Optimised $\Delta$") opt_dynamics = opt_result.optimized_objectives[0].mesolve( norm_t_list, e_ops=[proj_G, proj_GHZ]) plot_population(opt_dynamics) final_Omega = opt_result.optimized_controls[0] * characteristic_V final_Delta = opt_result.optimized_controls[1] * characteristic_V t_list = norm_t_list / characteristic_V e_qs = EvolvingQubitSystem( N=N, V=C6, geometry=RegularLattice1D(LATTICE_SPACING), Omega=get_hamiltonian_coeff_interpolation(t_list, final_Omega, "cubic"), Delta=get_hamiltonian_coeff_interpolation(t_list, final_Delta, "cubic"), t_list=np.linspace(0, t, 300), ghz_state=StandardGHZState(N) ) solve_and_print_stats(e_qs) plt.show()
def rescale_evolving_qubit_system(): t = 1.1e-6 N = 4 e_qs = EvolvingQubitSystem( N=N, V=paper_data.V, geometry=RegularLattice1D(), Omega=paper_data.get_hamiltonian_coeff_fn(paper_data.Omega, N), Delta=paper_data.get_hamiltonian_coeff_fn(paper_data.Delta, N), t_list=np.linspace(0, t, 100), ghz_state=AlternatingGHZState(N)) e_qs.solve() # e_qs.plot() print(e_qs.get_fidelity_with("ghz")) max_Omega = 50e6 e_qs = EvolvingQubitSystem( N=N, V=paper_data.V / max_Omega, geometry=RegularLattice1D(), Omega=paper_data.get_hamiltonian_coeff_fn( { k: {_k * max_Omega: _v / max_Omega for _k, _v in v.items()} for k, v in paper_data.Omega.items() }, N), Delta=paper_data.get_hamiltonian_coeff_fn( { k: {_k * max_Omega: _v / max_Omega for _k, _v in v.items()} for k, v in paper_data.Delta.items() }, N), t_list=np.linspace(0, t * max_Omega, 100), ghz_state=AlternatingGHZState(N)) e_qs.solve() e_qs.plot() print(e_qs.get_fidelity_with("ghz"))
def generate_plots_2(): """ Generates plots for evolving systems for different optimisation methods """ def solve_and_print_stats(e_qs: EvolvingQubitSystem, **kwargs): import time start_time = time.time() e_qs.solve() print(f"Solved in {time.time() - start_time:.2f}s") fidelity_with_ghz = e_qs.get_fidelity_with("ghz") fidelity_with_ghz_asymmetric = e_qs.get_fidelity_with( "ghz_antisymmetric") print( f"fidelity with GHZ: {fidelity_with_ghz:.4f} (with antisymmetric: {fidelity_with_ghz_asymmetric:.4f})" ) fidelity_with_ground = e_qs.get_fidelity_with("ground") fidelity_with_excited = e_qs.get_fidelity_with("excited") superposition_probability = fidelity_with_ground + fidelity_with_excited print( f"superposition probability: {superposition_probability:.4f} (g: {fidelity_with_ground:.4f}, e: {fidelity_with_excited:.4f})" ) e_qs.plot(with_antisymmetric_ghz=True, **kwargs, fig_kwargs={'figsize': (6, 4)}, plot_titles=False, plot_others_as_sum=True) norm_V = C6 / (LATTICE_SPACING**6) / characteristic_V norm_t = t * characteristic_V def get_normalised_hamiltonian(N: int): norm_e_qs = EvolvingQubitSystem(N=N, V=norm_V, geometry=RegularLattice1D(), Omega=None, Delta=None, t_list=None, ghz_state=None) norm_hamiltonian = norm_e_qs.get_hamiltonian() norm_H_d = norm_hamiltonian[0] # "drift": time-independent part norm_H_c = [norm_hamiltonian[1][0], norm_hamiltonian[2][0]] # "control": time-dependent parts return norm_H_d, norm_H_c, norm_e_qs.psi_0 def get_optimised_controls(N: int, n_ts: int, alg: str) -> OptimResult: norm_H_d, norm_H_c, psi_0 = get_normalised_hamiltonian(N) target_state = StandardGHZState(N).get_state_tensor() norm_scaling = 0.5 / characteristic_V optim_shared_kwargs = dict( amp_lbound=-10, amp_ubound=10, # amp_lbound=0, amp_ubound=2e9 * norm_scaling, gen_stats=True, max_wall_time=300, max_iter=10000, fid_err_targ=1e-10, log_level=qutip.logging_utils.WARN, ) if alg == "GRAPE": norm_result = cpo.optimize_pulse_unitary( norm_H_d, norm_H_c, psi_0, target_state, n_ts, norm_t, # pulse_scaling=1e9 * norm_scaling, pulse_offset=1e9 * norm_scaling, # pulse_scaling=0.5, # optim_method="FMIN_BFGS", init_pulse_type="RND", **optim_shared_kwargs) else: norm_result = cpo.opt_pulse_crab_unitary( norm_H_d, norm_H_c, psi_0, target_state, n_ts, norm_t, num_coeffs=10, guess_pulse_scaling=0.1, # guess_pulse_scaling=1e9 * norm_scaling, guess_pulse_offset=1e9 * norm_scaling, guess_pulse_type="RND", **optim_shared_kwargs) return norm_result def report_stats(result: OptimResult, N: int): result.stats.report() target_state = StandardGHZState(N).get_state_tensor() final_fidelity = qutip.fidelity(target_state, result.evo_full_final)**2 print(f"final_fidelity: {final_fidelity:.5f}") print(f"Final gradient normal {result.grad_norm_final:.3e}") print(f"Terminated due to {result.termination_reason}") def plot_optimresult(result: OptimResult, N: int, geometry: BaseGeometry, t: float, unnormalise_V: float, **kwargs): time = result.time final_Omega = np.hstack( (result.final_amps[:, 0], result.final_amps[-1, 0])) final_Delta = np.hstack( (result.final_amps[:, 1], result.final_amps[-1, 1])) t /= unnormalise_V time = result.time / unnormalise_V final_Omega *= unnormalise_V final_Delta *= unnormalise_V e_qs = EvolvingQubitSystem( N=N, V=C6, geometry=geometry, Omega=get_hamiltonian_coeff_interpolation(time, final_Omega, "previous"), Delta=get_hamiltonian_coeff_interpolation(time, final_Delta, "previous"), t_list=np.linspace(0, t, 300), ghz_state=StandardGHZState(N)) solve_and_print_stats(e_qs, **kwargs) # N = 4 # Manual optimisation # e_qs = EvolvingQubitSystem( # N=N, V=C6, geometry=RegularLattice1D(spacing=LATTICE_SPACING), # Omega=get_hamiltonian_coeff_linear_interpolation([0, t / 2, t], [0, 1.4148e9, 0]), # Delta=get_hamiltonian_coeff_linear_interpolation([0, t], [1.5e9, 1e9]), # t_list=np.linspace(0, t, 300), # ghz_state=StandardGHZState(N) # ) # solve_and_print_stats(e_qs, savefig_name=f'paper_plots_2_n_{N}_manual.png') # RL # with open("reinforcement_learning/results/20190814_035606.pkl", "rb") as f: # data = pickle.load(f) # t_list = data['evolving_qubit_system_kwargs']['t_list'] # solve_t_list = np.linspace(t_list[0], t_list[-1], 300) # # data['evolving_qubit_system_kwargs'].pop('t_list') # e_qs = EvolvingQubitSystem( # **data['evolving_qubit_system_kwargs'], # Omega=get_hamiltonian_coeff_linear_interpolation(t_list, data['protocol'].Omega), # Delta=get_hamiltonian_coeff_linear_interpolation(t_list, data['protocol'].Delta), # t_list=solve_t_list, # ) # solve_and_print_stats(e_qs, savefig_name=f'paper_plots_2_n_{N}_RL.png') # GRAPE # optim_result = get_optimised_controls(N, n_ts=15, alg="GRAPE") # report_stats(optim_result, N) # plot_optimresult(optim_result, N, norm_t, characteristic_V, savefig_name=f'paper_plots_2_n_{N}_GRAPE.png') # CRAB # optim_result = get_optimised_controls(N, n_ts=15, alg="CRAB") # report_stats(optim_result, N) # plot_optimresult(optim_result, N, norm_t, characteristic_V, savefig_name=f'paper_plots_2_n_{N}_CRAB.png') N = 8 # 1d # Manual optimisation # e_qs = EvolvingQubitSystem( # N=N, V=C6, geometry=RegularLattice1D(spacing=LATTICE_SPACING), # Omega=get_hamiltonian_coeff_linear_interpolation([0, t / 6, t * 5 / 6, t], [0, 379e6, 379e6, 0]), # Delta=get_hamiltonian_coeff_linear_interpolation([0, t], [1.3e9, 1.21e9]), # t_list=np.linspace(0, t, 300), # ghz_state=StandardGHZState(N) # ) # solve_and_print_stats(e_qs, savefig_name=f'paper_plots_2_n_{N}_manual.png') # RL # with open("reinforcement_learning/results/20190814_211310.pkl", "rb") as f: # data = pickle.load(f) # t_list = data['evolving_qubit_system_kwargs']['t_list'] # solve_t_list = np.linspace(t_list[0], t_list[-1], 300) # # data['evolving_qubit_system_kwargs'].pop('t_list') # e_qs = EvolvingQubitSystem( # **data['evolving_qubit_system_kwargs'], # Omega=get_hamiltonian_coeff_linear_interpolation(t_list, data['protocol'].Omega), # Delta=get_hamiltonian_coeff_linear_interpolation(t_list, data['protocol'].Delta), # t_list=solve_t_list, # ) # solve_and_print_stats(e_qs, savefig_name=f'paper_plots_2_n_{N}_RL.png') # GRAPE # with open("optim_results/optim_result_464779.pbs.pkl", "rb") as f: # optim_result = pickle.load(f) # report_stats(optim_result, N) # plot_optimresult(optim_result, N, RegularLattice1D(LATTICE_SPACING), norm_t, characteristic_V, # savefig_name=f'paper_plots_2_n_{N}_GRAPE.png') # CRAB # with open("optim_results/optim_result_464783.pbs.pkl", "rb") as f: # optim_result = pickle.load(f) # report_stats(optim_result, N) # plot_optimresult(optim_result, N, RegularLattice1D(LATTICE_SPACING), norm_t, characteristic_V, # savefig_name=f'paper_plots_2_n_{N}_CRAB.png') # N = 8 # 2d # Manual optimisation # e_qs = EvolvingQubitSystem( # N=N, V=C6, geometry=RegularLattice2D((2, 4), spacing=LATTICE_SPACING), # Omega=get_hamiltonian_coeff_linear_interpolation([0, t / 5, t * 4 / 5, t], [0, 700e6, 700e6, 0]), # Delta=get_hamiltonian_coeff_linear_interpolation([0, t], [2e9, 1.83e9]), # t_list=np.linspace(0, t, 300), # ghz_state=StandardGHZState(N) # ) # solve_and_print_stats(e_qs, savefig_name=f'paper_plots_2_n_{N}_manual_2d.png') # RL # with open("reinforcement_learning/results/20190814_211949.pkl", "rb") as f: # data = pickle.load(f) # t_list = data['evolving_qubit_system_kwargs']['t_list'] # solve_t_list = np.linspace(t_list[0], t_list[-1], 300) # # data['evolving_qubit_system_kwargs'].pop('t_list') # e_qs = EvolvingQubitSystem( # **data['evolving_qubit_system_kwargs'], # Omega=get_hamiltonian_coeff_linear_interpolation(t_list, data['protocol'].Omega), # Delta=get_hamiltonian_coeff_linear_interpolation(t_list, data['protocol'].Delta), # t_list=solve_t_list, # ) # solve_and_print_stats(e_qs, savefig_name=f'paper_plots_2_n_{N}_RL_2d.png') # GRAPE # with open("optim_results/optim_result_464780.pbs.pkl", "rb") as f: # optim_result = pickle.load(f) # report_stats(optim_result, N) # plot_optimresult(optim_result, N, RegularLattice2D((2, 4), LATTICE_SPACING), norm_t, characteristic_V, # savefig_name=f'paper_plots_2_n_{N}_GRAPE_2d.png') # CRAB # with open("optim_results/optim_result_464784.pbs.pkl", "rb") as f: # optim_result = pickle.load(f) # report_stats(optim_result, N) # plot_optimresult(optim_result, N, RegularLattice2D((2, 4), LATTICE_SPACING), norm_t, characteristic_V, # savefig_name=f'paper_plots_2_n_{N}_CRAB_2d.png') N = 8 # 3d # Manual optimisation # e_qs = EvolvingQubitSystem( # N=N, V=C6, geometry=RegularLattice3D((2, 2, 2), spacing=LATTICE_SPACING), # Omega=get_hamiltonian_coeff_linear_interpolation([0, t / 2, t], [0, 1175e6, 0]), # Delta=get_hamiltonian_coeff_linear_interpolation([0, t], [2.5e9, 2.2e9]), # t_list=np.linspace(0, t, 300), # ghz_state=StandardGHZState(N) # ) # solve_and_print_stats(e_qs, savefig_name=f'paper_plots_2_n_{N}_manual_3d.png') # RL with open("reinforcement_learning/results/20190814_215943.pkl", "rb") as f: data = pickle.load(f) t_list = data['evolving_qubit_system_kwargs']['t_list'] solve_t_list = np.linspace(t_list[0], t_list[-1], 300) data['evolving_qubit_system_kwargs'].pop('t_list') e_qs = EvolvingQubitSystem( **data['evolving_qubit_system_kwargs'], Omega=get_hamiltonian_coeff_linear_interpolation( t_list, data['protocol'].Omega), Delta=get_hamiltonian_coeff_linear_interpolation( t_list, data['protocol'].Delta), t_list=solve_t_list, ) solve_and_print_stats(e_qs, savefig_name=f'paper_plots_2_n_{N}_RL_3d.png')
# N=N, V=C6, geometry=RegularLattice1D(spacing=LATTICE_SPACING), # Omega=get_hamiltonian_coeff_linear_interpolation([0, t / 2, t], [0, 751.23e6, 0]), # Delta=get_hamiltonian_coeff_linear_interpolation([0, t], [1.3e9, 1.14e9]), # t_list=np.linspace(0, t, 300), # ghz_state=StandardGHZState(N) # ) # solve_and_print_stats(e_qs) # plot_basis_state_populations_2d(e_qs) N = 8 t = 0.5e-6 e_qs = EvolvingQubitSystem( N=N, V=C6, geometry=RegularLattice1D(spacing=LATTICE_SPACING), Omega=get_hamiltonian_coeff_linear_interpolation([0, t / 6, t * 5 / 6, t], [0, 480e6, 490e6, 0]), Delta=get_hamiltonian_coeff_linear_interpolation([0, t], [1.5e9, 1.2e9]), t_list=np.linspace(0, t, 100), ghz_state=StandardGHZState(N) ) solve_and_print_stats(e_qs) plot_basis_state_populations_2d(e_qs, log=True) # N = 8, t = 2e-6 # N = 8 # # with open("reinforcement_learning/results/20190814_215943.pkl", "rb") as f: # data = pickle.load(f) # # t_list = data['evolving_qubit_system_kwargs']['t_list'] # solve_t_list = np.linspace(t_list[0], t_list[-1], 100)