def save_plots(target_state, best_state, cost_progress, *, modes, offset=-0.11, l=5,
out_dir='sim_results', ID='state_learner', **kwargs):
"""Generate and save plots"""
if modes == 1:
# generate a wigner function plot of the target state
fig1, ax1 = wigner_3D_plot(target_state, offset=offset, l=l)
fig1.savefig(os.path.join(out_dir, ID+'_targetWigner.png'))
# generate a wigner function plot of the learnt state
fig2, ax2 = wigner_3D_plot(best_state, offset=offset, l=l)
fig2.savefig(os.path.join(out_dir, ID+'_learntWigner.png'))
# generate a wavefunction plot of the target state
figW1, axW1 = wavefunction_plot(target_state, l=l)
figW1.savefig(os.path.join(out_dir, ID+'_targetWavefunction.png'))
# generate a wavefunction plot of the learnt state
figW2, axW2 = wavefunction_plot(best_state, l=l)
figW2.savefig(os.path.join(out_dir, ID+'_learntWavefunction.png'))
elif modes == 2:
# generate a 3D wavefunction plot of the target state
figW1, axW1 = two_mode_wavefunction_plot(target_state, l=l)
figW1.savefig(os.path.join(out_dir, ID+'_targetWavefunction.png'))
# generate a 3D wavefunction plot of the learnt state
figW2, axW2 = two_mode_wavefunction_plot(best_state, l=l)
figW2.savefig(os.path.join(out_dir, ID+'_learntWavefunction.png'))
# generate a cost function plot
figC, axC = plot_cost(cost_progress)
figC.savefig(os.path.join(out_dir, ID+'_cost.png'))
def save_plots(target_unitary,
learnt_unitary,
eq_state_learnt,
eq_state_target,
cost_progress,
*,
modes,
offset=-0.11,
l=5,
out_dir='sim_results',
ID='gate_synthesis',
**kwargs):
"""Generate and save plots"""
square = not kwargs.get('maps_outside', True)
if modes == 1:
# generate a wigner function plot of the target state
fig1, ax1 = wigner_3D_plot(eq_state_target, offset=offset, l=l)
fig1.savefig(os.path.join(out_dir, ID + '_targetWigner.png'))
# generate a wigner function plot of the learnt state
fig2, ax2 = wigner_3D_plot(eq_state_learnt, offset=offset, l=l)
fig2.savefig(os.path.join(out_dir, ID + '_learntWigner.png'))
# generate a matrix plot of the target and learnt unitaries
figW1, axW1 = one_mode_unitary_plots(target_unitary,
learnt_unitary,
square=square)
figW1.savefig(os.path.join(out_dir, ID + '_unitaryPlot.png'))
elif modes == 2:
# generate a 3D wavefunction plot of the target state
figW1, axW1 = two_mode_wavefunction_plot(eq_state_target, l=l)
figW1.savefig(os.path.join(out_dir, ID + '_targetWavefunction.png'))
# generate a 3D wavefunction plot of the learnt state
figW2, axW2 = two_mode_wavefunction_plot(eq_state_learnt, l=l)
figW2.savefig(os.path.join(out_dir, ID + '_learntWavefunction.png'))
# generate a matrix plot of the target and learnt unitaries
figM1, axM1 = two_mode_unitary_plots(target_unitary,
learnt_unitary,
square=square)
figM1.savefig(os.path.join(out_dir, ID + '_unitaryPlot.png'))
# generate a cost function plot
figC, axC = plot_cost(cost_progress)
figC.savefig(os.path.join(out_dir, ID + '_cost.png'))
def optimize(ket, target_state, parameters, cutoff, reps=1000, penalty_strength=0,
out_dir='sim_results', ID='state_learning', board_name='TensorBoard',
dump_reps=100, **kwargs):
"""The optimization routine.
Args:
ket (tensor): tensorflow tensor representing the output state vector of the circuit.
target_state (array): the target state.
parameters (list): list of the tensorflow variables representing the gate
parameters to be optimized in the variational quantum circuit.
cutoff (int): the simulation Fock basis truncation.
reps (int): the number of optimization repititions.
penalty_strength (float): the strength of the penalty to apply to optimized states
deviating from a norm of 1.
out_dir (str): directory to store saved output.
ID (str): the ID of the simulation. The optimization output is saved in the directory
out_dir/ID.
board_name (str): the folder to store data for TensorBoard.
dump_reps (int): the repitition frequency at which to save output.
Returns:
dict: a dictionary containing the hyperparameters and results of the optimization.
"""
# ===============================================================================
# Loss function
# ===============================================================================
fidelity = state_fidelity(ket, target_state)
tf.summary.scalar('fidelity', fidelity)
# loss function to minimise
loss = 1-fidelity #tf.abs(tf.reduce_sum(tf.conj(ket) * target_state) - 1)
tf.summary.scalar('loss', loss)
# ===============================================================================
# Regularisation
# ===============================================================================
# calculate the norm of the state
state_norm = tf.abs(tf.reduce_sum(tf.conj(ket) * ket)) ** 2
tf.summary.scalar('norm', state_norm)
# penalty
penalty = penalty_strength * (state_norm - 1)**2
tf.summary.scalar('penalty', penalty)
# Overall cost function
cost = loss + penalty
tf.summary.scalar('cost', cost)
# ===============================================================================
# Set up the tensorflow session
# ===============================================================================
# Using Adam algorithm for optimization
optimiser = tf.train.AdamOptimizer()
minimize_cost = optimiser.minimize(cost)
# Begin Tensorflow session
session = tf.Session()
session.run(tf.global_variables_initializer())
writer = tf.summary.FileWriter(board_name)
merge = tf.summary.merge_all()
# ===============================================================================
# Run the optimization
# ===============================================================================
# Keeps track of fidelity to target state
fid_progress = []
# keep track of the cost function
cost_progress = []
# Keeps track of best state and fidelity during optimization
best_state = np.zeros(cutoff)
best_fid = 0
start = time.time()
# Run optimization
for i in range(reps):
_, cost_val, fid_val, ket_val, norm_val, penalty_val, params_val = session.run(
[minimize_cost, cost, fidelity, ket, state_norm, penalty, parameters])
# Stores fidelity at each step
cost_progress.append(cost_val)
fid_progress.append(fid_val)
fig2, ax2 = wigner_3D_plot(ket_val, offset=-0.155, l=5)
# ax2.set_xlim3d(-5, 5)
# ax2.set_ylim3d(-5, 5)
ax2.set_zlim3d(-0.2, None)
fig2.savefig(os.path.join(out_dir, '{}.png'.format(i).zfill(4)))
plt.close(fig2)
if i % dump_reps == 0:
# print progress
print("Rep: {} Cost: {:.4f} Fidelity: {:.4f} Norm: {:.4f}".format(
i, cost_val, fid_val, norm_val))
if i > 0:
# save results file
np.savez(os.path.join(out_dir, ID+'.npz'),
**sim_results)
if i > 0 and fid_val > best_fid:
best_fid = fid_val
min_cost = cost_val
best_state = correct_global_phase(ket_val)
end = time.time()
sim_results = {
# sim details
'name': HP['name'],
'target_state': target_state,
'state_params': HP['state_params'],
'cutoff': cutoff,
'depth': HP['depth'],
'reps': reps,
'penalty_strength': penalty_strength,
'best_runtime': end-start,
# optimization results
'best_rep': i,
'min_cost': cost_val,
'fidelity': best_fid,
'cost_progress': np.array(cost_progress),
'fid_progress': np.array(fid_progress),
'penalty': penalty_val,
# optimization output
'learnt_state': best_state,
'params': params_val,
'd_r': params_val[0],
'd_phi': params_val[1],
'r1': params_val[2],
'sq_r': params_val[3],
'sq_phi': params_val[4],
'r2': params_val[5],
'kappa': params_val[6]
}
end = time.time()
print("Elapsed time is {} seconds".format(np.round(end - start)))
print("Final cost = ", cost_val)
print("Minimum cost = ", min_cost)
print("Optimum fidelity = ", best_fid)
sim_results['runtime'] = end-start
sim_results['cost_progress'] = np.array(cost_progress)
sim_results['fid_progress'] = np.array(fid_progress)
np.savez(os.path.join(out_dir, ID+'.npz'), **sim_results)
return sim_results