def plot_inter_vecs_general(self,pop_inter_vecs,start):
# plot state evolution
if self.sys_para.draw_list !=[]:
for kk in range(len(self.sys_para.draw_list)):
plt.plot(np.array([self.sys_para.dt* ii for ii in range(self.sys_para.steps+1)]),np.array(pop_inter_vecs[self.sys_para.draw_list[kk],:]),label=self.sys_para.draw_names[kk])
else:
if start > 4:
plt.plot(np.array([self.sys_para.dt* ii for ii in range(self.sys_para.steps+1)]),np.array(pop_inter_vecs[start,:]),label='Starting level '+str(start))
for jj in range(4):
plt.plot(np.array([self.sys_para.dt* ii for ii in range(self.sys_para.steps+1)]),np.array(pop_inter_vecs[jj,:]),label='level '+str(jj))
forbidden =np.zeros(self.sys_para.steps+1)
if 'states_forbidden_list' in self.sys_para.reg_coeffs:
# summing all population of forbidden states
for forbid in self.sys_para.reg_coeffs['states_forbidden_list']:
if self.sys_para.dressed_info is None or ('forbid_dressed' in self.sys_para.reg_coeffs and self.sys_para.reg_coeffs['forbid_dressed']) :
forbidden = forbidden +np.array(pop_inter_vecs[forbid,:])
else:
v_sorted=sort_ev(self.sys_para.v_c,self.sys_para.dressed_id)
dressed_vec= np.dot(v_sorted,np.sqrt(pop_inter_vecs))
forbidden = forbidden +np.array(np.square(np.abs(dressed_vec[forbid,:])))
plt.plot(np.array([self.sys_para.dt* ii for ii in range(self.sys_para.steps+1)]), forbidden,label='forbidden',linestyle='--',linewidth=4)
plt.ylabel('Population')
plt.ylim(-0.1,1.1)
plt.xlabel('Time ('+ self.time_unit+')')
plt.legend(ncol=7)
def get_inter_vecs(self):
# get propagated states at each time step
if not self.sys_para.use_inter_vecs:
return None
state_num = self.sys_para.state_num
inter_vecs_mag_squared = []
inter_vecs_real = []
inter_vecs_imag = []
if self.sys_para.is_dressed:
v_sorted = sort_ev(self.sys_para.v_c, self.sys_para.dressed_id)
ii = 0
inter_vecs = tf.stack(self.tf_inter_vecs).eval()
if self.sys_para.save:
with H5File(self.sys_para.file_path) as hf:
hf.append('inter_vecs_raw_real',
np.array(inter_vecs[:, 0:state_num, :]))
hf.append('inter_vecs_raw_imag',
np.array(inter_vecs[:, state_num:2 * state_num, :]))
for inter_vec in inter_vecs:
inter_vec_real = (inter_vec[0:state_num, :])
inter_vec_imag = (inter_vec[state_num:2 * state_num, :])
inter_vec_c = inter_vec_real + 1j * inter_vec_imag
if self.sys_para.is_dressed:
dressed_vec_c = np.dot(np.transpose(v_sorted), inter_vec_c)
inter_vec_mag_squared = np.square(np.abs(dressed_vec_c))
inter_vec_real = np.real(dressed_vec_c)
inter_vec_imag = np.imag(dressed_vec_c)
else:
inter_vec_mag_squared = np.square(np.abs(inter_vec_c))
inter_vec_real = np.real(inter_vec_c)
inter_vec_imag = np.imag(inter_vec_c)
inter_vecs_mag_squared.append(inter_vec_mag_squared)
inter_vecs_real.append(inter_vec_real)
inter_vecs_imag.append(inter_vec_imag)
ii += 1
if self.sys_para.save:
with H5File(self.sys_para.file_path) as hf:
hf.append('inter_vecs_mag_squared',
np.array(inter_vecs_mag_squared))
hf.append('inter_vecs_real', np.array(inter_vecs_real))
hf.append('inter_vecs_imag', np.array(inter_vecs_imag))
return inter_vecs_mag_squared
def get_reg_loss(tfs):
# Regulizer
with tf.name_scope('reg_errors'):
reg_loss = tfs.loss
# amplitude
if 'amplitude' in tfs.sys_para.reg_coeffs:
amp_reg_alpha_coeff = tfs.sys_para.reg_coeffs['amplitude']
amp_reg_alpha = amp_reg_alpha_coeff / float(tfs.sys_para.steps)
reg_loss = reg_loss + amp_reg_alpha * tf.nn.l2_loss(tfs.ops_weight)
# gaussian envelope
if 'envelope' in tfs.sys_para.reg_coeffs:
reg_alpha_coeff = tfs.sys_para.reg_coeffs['envelope']
reg_alpha = reg_alpha_coeff / float(tfs.sys_para.steps)
reg_loss = reg_loss + reg_alpha * tf.nn.l2_loss(
tf.multiply(tfs.tf_one_minus_gaussian_envelope,
tfs.ops_weight))
# Limiting the dwdt of control pulse
if 'dwdt' in tfs.sys_para.reg_coeffs:
zeros_for_training = tf.zeros([tfs.sys_para.ops_len, 2])
new_weights = tf.concat([tfs.ops_weight, zeros_for_training], 1)
new_weights = tf.concat([zeros_for_training, new_weights], 1)
dwdt_reg_alpha_coeff = tfs.sys_para.reg_coeffs['dwdt']
dwdt_reg_alpha = dwdt_reg_alpha_coeff / float(tfs.sys_para.steps)
reg_loss = reg_loss + dwdt_reg_alpha * tf.nn.l2_loss(
(new_weights[:, 1:] - new_weights[:, :tfs.sys_para.steps + 3])
/ tfs.sys_para.dt)
# Limiting the d2wdt2 of control pulse
if 'd2wdt2' in tfs.sys_para.reg_coeffs:
d2wdt2_reg_alpha_coeff = tfs.sys_para.reg_coeffs['d2wdt2']
d2wdt2_reg_alpha = d2wdt2_reg_alpha_coeff / float(
tfs.sys_para.steps)
reg_loss = reg_loss + d2wdt2_reg_alpha * tf.nn.l2_loss((new_weights[:, 2:] - \
2 * new_weights[:,
1:tfs.sys_para.steps + 3] + new_weights[:,
:tfs.sys_para.steps + 2]) / (
tfs.sys_para.dt ** 2))
# bandpass filter on the control
if 'bandpass' in tfs.sys_para.reg_coeffs:
## currently does not support bandpass reg for CPU (no CPU kernel for FFT)
if not tfs.sys_para.use_gpu:
raise ValueError(
'currently does not support bandpass reg for CPU (no CPU kernel for FFT)'
)
bandpass_reg_alpha_coeff = tfs.sys_para.reg_coeffs['bandpass']
bandpass_reg_alpha = bandpass_reg_alpha_coeff / float(
tfs.sys_para.steps)
tf_u = tf.cast(tfs.ops_weight, dtype=tf.complex64)
tf_fft = tf.complex_abs(tf.fft(tf_u))
band = np.array(tfs.sys_para.reg_coeffs['band'])
band_id = (band * tfs.sys_para.total_time).astype(int)
half_id = int(tfs.sys_para.steps / 2)
fft_loss = bandpass_reg_alpha * (
tf.reduce_sum(tf_fft[:, 0:band_id[0]]) +
tf.reduce_sum(tf_fft[:, band_id[1]:half_id]))
reg_loss = reg_loss + fft_loss
# Limiting the access to forbidden states
if 'forbidden_coeff_list' in tfs.sys_para.reg_coeffs:
if tfs.sys_para.is_dressed:
v_sorted = tf.constant(c_to_r_mat(
np.reshape(
sort_ev(tfs.sys_para.v_c, tfs.sys_para.dressed_id), [
len(tfs.sys_para.dressed_id),
len(tfs.sys_para.dressed_id)
])),
dtype=tf.float32)
for inter_vec in tfs.inter_vecs:
if tfs.sys_para.is_dressed and (
'forbid_dressed' in tfs.sys_para.reg_coeffs
and tfs.sys_para.reg_coeffs['forbid_dressed']):
inter_vec = tf.matmul(tf.transpose(v_sorted), inter_vec)
for inter_reg_alpha_coeff, state in zip(
tfs.sys_para.reg_coeffs['forbidden_coeff_list'],
tfs.sys_para.reg_coeffs['states_forbidden_list']):
inter_reg_alpha = inter_reg_alpha_coeff / float(
tfs.sys_para.steps)
forbidden_state_pop = tf.square(inter_vec[state, :]) + \
tf.square(inter_vec[tfs.sys_para.state_num + state, :])
reg_loss = reg_loss + inter_reg_alpha * tf.nn.l2_loss(
forbidden_state_pop)
# Speeding up the gate time
if 'speed_up' in tfs.sys_para.reg_coeffs:
speed_up_reg_alpha_coeff = -tfs.sys_para.reg_coeffs['speed_up']
speed_up_reg_alpha = speed_up_reg_alpha_coeff / float(
tfs.sys_para.steps)
target_vecs_all_timestep = tf.tile(
tf.reshape(
tfs.target_vecs,
[2 * tfs.sys_para.state_num, 1,
len(tfs.inter_vecs)]), [1, tfs.sys_para.steps + 1, 1])
target_vecs_inner_product = tfs.get_inner_product_3D(
tfs.inter_vecs_packed, target_vecs_all_timestep)
reg_loss = reg_loss + speed_up_reg_alpha * tf.nn.l2_loss(
target_vecs_inner_product)
return reg_loss