pqcprep.plotting_tools

  1"""
  2Collection of functions relating to plotting and visualisation. 
  3"""
  4
  5import numpy as np 
  6import matplotlib.pyplot as plt 
  7from matplotlib import rcParams, cm
  8import os
  9from .psi_tools import x_trans_arr, get_phase_target, psi, A 
 10from .file_tools import vars_to_name_str, vars_to_name_str_ampl
 11from .resource_tools import load_data_H23
 12from .phase_tools import full_encode, phase_from_state
 13from .binary_tools import dec_to_bin, bin_to_dec
 14
 15# general settings
 16rcParams['mathtext.fontset'] = 'stix' 
 17rcParams['font.family'] = 'STIXGeneral' 
 18width=0.75 
 19""" @private """
 20color='black' 
 21""" @private """
 22fontsize=28 
 23""" @private """
 24titlesize=32
 25""" @private """
 26ticksize=22
 27""" @private """
 28figsize=(10,10)
 29""" @private """
 30
 31def benchmark_plots(arg_dict,DIR, show=False, pdf=False):  
 32    """
 33    Generates plots visualising the outputs produced by `pqcprep.training_tools.train_QNN()` and `pqcprep.training_tools.test_QNN()`. 
 34
 35    Arguments:
 36    ---- 
 37    - **arg_dict** : *dict* 
 38
 39        Dictionary containing varialbe information created using `pqcprep.file_tools.compress_args()`. 
 40
 41    - **show** : *boolean* 
 42
 43        If True, display plots. Default is False. 
 44
 45    - **pdf** : *boolean* 
 46
 47        If True, save plots in pdf format. If False, save plots in png format. Default is False. 
 48
 49    - **DIR** : *str*
 50
 51        Parent directory for output files.     
 52
 53    Returns:
 54    ---
 55
 56    Saves plots corresponding to each of the files produced by `pqcprep.training_tools.train_QNN()` and `pqcprep.training_tools.test_QNN()` (apart from `metrics_<NAME_STR>.npy`)
 57    in the directory `DIR/plots`. 
 58   
 59    """
 60
 61    name_str = vars_to_name_str(arg_dict)
 62    pdf_str = ".pdf" if pdf else ".png"
 63
 64    # data to plot 
 65    arrs =["loss", "mismatch", "grad", "vargrad"]
 66    labels=["Loss", "Mismatch", r"$|\nabla_\theta W|^2$",r"Var($\partial_\theta W$)" ]
 67
 68    for i in np.arange(len(arrs)):
 69        arr = np.load(os.path.join(DIR, "outputs", f"{arrs[i]}{name_str}.npy"))
 70
 71        plt.figure(figsize=figsize)
 72        plt.xlabel("Epoch", fontsize=fontsize)
 73        plt.ylabel(labels[i], fontsize=fontsize)
 74        plt.yscale('log')
 75        plt.tick_params(axis="both", labelsize=ticksize)
 76        plt.scatter(np.arange(len(arr))+1,arr,color="red")
 77
 78        plt.tight_layout()
 79        plt.savefig(os.path.join(DIR, "plots", f"{arrs[i]}{name_str}{pdf_str}"), bbox_inches='tight', dpi=500)
 80
 81        if show:
 82            plt.show()
 83        plt.close()      
 84
 85    # plot mismatch by state 
 86    dic = np.load(os.path.join(DIR, "outputs", f"mismatch_by_state{name_str}.npy"),allow_pickle='TRUE').item()
 87    mismatch = list(dic.values())
 88    x_arr = x_trans_arr(arg_dict["n"])
 89
 90    plt.figure(figsize=figsize)
 91    plt.xlabel(r"$f$ (Hz)", fontsize=fontsize)
 92    plt.ylabel("Mismatch", fontsize=fontsize)
 93    plt.yscale('log')
 94    plt.tick_params(axis="both", labelsize=ticksize)
 95    plt.scatter(x_arr,mismatch,color="red")
 96
 97    plt.tight_layout()
 98    plt.savefig(os.path.join(DIR, "plots", f"mismatch_by_state{name_str}{pdf_str}"), bbox_inches='tight', dpi=500)
 99
100    if show:
101        plt.show()
102    plt.close()      
103
104    # plot extracted phase function   
105    mint = arg_dict["mint"] if arg_dict["mint"] != None else arg_dict["m"] 
106    if arg_dict["phase_reduce"]:
107        mint = 0      
108    phase = np.load(os.path.join(DIR, "outputs", f"phase{name_str}.npy"))
109    phase_target_rounded = get_phase_target(m=arg_dict["m"], psi_mode=arg_dict["func_str"], phase_reduce=arg_dict["phase_reduce"], mint=mint)
110    phase_target = psi(np.arange(2**arg_dict["n"]),mode=arg_dict["func_str"])
111
112    fig, ax = plt.subplots(2, 1, figsize=figsize, gridspec_kw={'height_ratios': [1.5, 1]})
113
114    ax[0].plot(x_arr,phase_target, color="black")
115    ax[0].plot(x_arr,phase_target_rounded, color="gray", ls="--")
116    ax[0].scatter(x_arr,phase, color="red")
117
118    ax[0].set_ylabel(r"$\Psi (f)$", fontsize=fontsize)
119    ax[0].tick_params(axis="both", labelsize=ticksize)
120    ax[0].set_xticks([])
121
122    ax[1].scatter(x_arr,phase_target_rounded-phase, color="red")
123    ax[1].set_ylabel(r"$\Delta \Psi(f)$", fontsize=fontsize)
124    ax[1].tick_params(axis="both", labelsize=ticksize)
125    ax[1].set_xlabel(r"$f$ (Hz)", fontsize=fontsize)
126
127    fig.tight_layout()
128    fig.savefig(os.path.join(DIR, "plots", f"phase{name_str}{pdf_str}"), bbox_inches='tight', dpi=500)
129
130    if show:
131        plt.show()
132    plt.close()      
133
134
135    return 0
136
137def benchmark_plots_ampl(arg_dict,DIR, show=False, pdf=False):    
138    """
139    Generates plots visualising the outputs produced by `pqcprep.training_tools.ampl_train_QNN()`.
140
141     Arguments:
142    ---- 
143    - **arg_dict** : *dict* 
144
145        Dictionary containing varialbe information created using `pqcprep.file_tools.compress_args_ampl()`. 
146
147    - **show** : *boolean* 
148
149        If True, display plots. Default is False. 
150
151    - **pdf** : *boolean* 
152
153        If True, save plots in pdf format. Default is False. 
154
155    - **DIR** : *str*
156
157        Parent directory for output files.     
158
159    Returns:
160    ---
161
162    Saves plots corresponding to each of the files produced by `pqcprep.training_tools.ampl_train_QNN()` 
163    in the directory `DIR/ampl_plots`.
164    """
165    name_str = vars_to_name_str_ampl(arg_dict)
166    pdf_str = ".pdf" if pdf else ".png"
167
168    # data to plot 
169    arrs =["loss", "mismatch"]
170    labels=["Loss", "Mismatch"]
171
172    for i in np.arange(len(arrs)):
173        arr = np.load(os.path.join(DIR, "ampl_outputs", f"{arrs[i]}{name_str}.npy"))
174
175        plt.figure(figsize=figsize)
176        plt.xlabel("Epoch", fontsize=fontsize)
177        plt.ylabel(labels[i], fontsize=fontsize)
178        plt.yscale('log')
179        plt.tick_params(axis="both", labelsize=ticksize)
180        plt.scatter(np.arange(len(arr))+1,arr,color="red")
181
182        plt.tight_layout()
183        plt.savefig(os.path.join(DIR, "ampl_plots", f"{arrs[i]}{name_str}{pdf_str}"), bbox_inches='tight', dpi=500)
184
185        if show:
186            plt.show()
187        plt.close()      
188
189    # plot amplitude 
190    x_arr = x_trans_arr(arg_dict["n"])
191
192    ampl_vec = np.abs(np.load(os.path.join(DIR, "ampl_outputs", f"statevec{name_str}.npy")))
193    ampl_target = np.array([A(i, mode=arg_dict["func_str"]) for i in x_arr])
194    ampl_target /= np.sqrt(np.sum(ampl_target**2))
195
196    fig, ax = plt.subplots(2, 1, figsize=figsize, gridspec_kw={'height_ratios': [1.5, 1]})
197    ax[0].plot(x_arr,ampl_target, color="black")
198    ax[0].scatter(x_arr,ampl_vec,color="red")
199    ax[0].set_ylabel(r"$\tilde A(f)$", fontsize=fontsize)
200    ax[0].tick_params(axis="both", labelsize=ticksize)
201    ax[0].set_xticks([])
202    ax[1].scatter(x_arr,ampl_target-ampl_vec,label="QCNN", color="red")
203    ax[1].set_ylabel(r"$\Delta \tilde A(f)$", fontsize=fontsize)
204    ax[1].tick_params(axis="both", labelsize=ticksize)
205    ax[1].set_xlabel(r"$f$ (Hz)", fontsize=fontsize)
206
207    fig.tight_layout()
208    fig.savefig(os.path.join(DIR, "ampl_plots", f"amplitude{name_str}{pdf_str}"), bbox_inches='tight', dpi=500)
209
210    if show:
211        plt.show()  
212    plt.close()          
213
214    return 0
215
216def waveform_plots(name_str_phase, name_str_ampl, in_dir, out_dir,comp, no_UA=False,show=False, pdf=False):
217    """
218    Plot the amplitude, phase, and full waveform of a state prepared using QCNNs. 
219
220    This function attempts to extract information about QCNN configurations from name strings which might not be successful in the general case. 
221
222    Arguments:
223    ----
224
225    - **name_str_phase** : *str* 
226
227        Name string (produced using `pqcprep.file_tools.vars_to_name_str()`) corresponding to the weights of the QCNN used for phase encoding. 
228
229    - **name_str_ampl** : *str* 
230
231        Name string (produced using `pqcprep.file_tools.vars_to_name_str_ampl()`) corresponding to the weights of the QCNN used for amplitude preparation. This is ignored if `no_UA` is True.      
232
233    - **in_dir** : *str*
234
235        Directory containing the input files (as specified by `name_str_phase` and `name_str_ampl`). The directory is expected to contain a `weights` file for both cases. 
236
237    - **out_dir** : *str*
238
239        Directory for output files. 
240
241    - **comp** : *str*, *optional*
242
243        Compare outputs to results from Hayes 2023: if `'GR'` compare to results obtained using the Grover-Rudolph algorithm and if `'QGAN'` compare to results 
244        obtained using the QGAN.  
245
246    - **no_UA** : *boolean*
247
248        If True, a Hadamard transform is applied to the input register instead of preparing the amplitude via a PQC. Default is False.      
249    
250    - **show** : *boolean* 
251
252        If True, display plots. Default is False. 
253
254    - **pdf** : *boolean* 
255
256        If True, save plots in pdf format. Default is False. 
257
258
259    Returns:
260    ----
261
262    Plots of the amplitude, phase, and full waveform saved in the directory `out_dir`.
263    """
264
265    pdf_str = ".pdf" if pdf else ".png"
266
267    # read in given files 
268    weights_phase = os.path.join(in_dir, f"weights{name_str_phase}.npy") 
269    weights_ampl = os.path.join(in_dir, f"weights{name_str_ampl}.npy") 
270
271    # extract information from name strings 
272    phase_reduce = '(PR)' in name_str_phase
273    real_p = '(r)' in name_str_phase
274    if '(CL)' in name_str_phase:
275        repeat_params="CL"
276    elif '(IL)' in name_str_phase:
277        repeat_params="IL" 
278    elif '(both)' in name_str_phase:
279        repeat_params="both"       
280    else:
281        repeat_params=None 
282
283    psi_mode=None 
284    func_A=None 
285    for i in ["psi", "linear", "quadratic", "sine"]:
286        if name_str_phase.count(i)==1:
287            psi_mode=i 
288            break 
289    if psi_mode==None:
290        raise ValueError("Name string could not be interpreted.")    
291    for i in ["x76", "linear", "uniform"]:
292        if name_str_ampl.count(i)==1:
293            func_A=i 
294            break     
295    if func_A==None:
296        raise ValueError("Name string could not be interpreted.")   
297    
298    n = name_str_ampl[1] if name_str_ampl[2]=="_" else name_str_ampl[1:3]
299    if int(n) < 10:
300        L_A= name_str_ampl[3] if name_str_ampl[4]=="_" else name_str_ampl[3:5] # this assumes nint=None 
301        m = name_str_phase[3] if (name_str_phase[4]=="_" or name_str_phase[4]=="(") else name_str_phase[3:5]
302    else: 
303        L_A= name_str_ampl[4] if name_str_ampl[5]=="_" else name_str_ampl[4:6] # this assumes nint=None 
304        m = name_str_phase[4] if (name_str_phase[5]=="_" or name_str_phase[5]=="(") else name_str_phase[4:6]   
305
306    mint=None 
307    for i in np.arange(int(m)+1):
308        if name_str_phase.count(f"({i})")==1:
309            mint=i 
310            break 
311    s = f"_{n}_{m}({mint})_"
312    if name_str_phase.count(s) != 1 :
313        raise ValueError("Name string could not be interpreted.")   
314    else:
315        L_phase = name_str_phase[len(s)] if name_str_phase[len(s)+1]=="_" else name_str_phase[len(s)+2]
316    s = f"_{n}_{m}({mint})_{L_phase}_"
317    if name_str_phase.count(s) != 1 :
318        raise ValueError("Name string could not be interpreted.")
319
320    n= int(n)
321    m=int(m)
322    L_phase=int(L_phase)
323    L_A=int(L_A)
324    mint=int(mint)    
325
326    # generate x array 
327    x_arr = x_trans_arr(n)
328
329    # calculate target outputs 
330    ampl_target = np.array([A(i, mode=func_A) for i in x_arr])
331    ampl_target = ampl_target / np.sqrt(np.sum(ampl_target**2))
332
333    phase_rounded = get_phase_target(m=m, psi_mode=psi_mode, phase_reduce=phase_reduce, mint=mint)
334    phase_target = psi(np.arange(2**n),mode=psi_mode)
335
336    h_target = ampl_target * np.exp(2*1.j*np.pi* phase_target)
337    wave_real_target = np.real(h_target)
338    wave_im_target = np.imag(h_target)
339
340    h_target_rounded = ampl_target * np.exp(2*1.j*np.pi* phase_rounded)
341    wave_real_target_rounded = np.real(h_target_rounded)
342    wave_im_target_rounded = np.imag(h_target_rounded)
343
344    # load Hayes 2023 data for comparison  
345    if comp=="GR":
346        ampl_vec_comp=np.abs(load_data_H23("amp_state_GR"))
347        h_comp= load_data_H23("full_state_GR")
348        psi_LPF = load_data_H23("psi_LPF_processed")  
349        comp_label="GR"
350        comp=True
351    elif comp=="QGAN":
352        ampl_vec_comp=np.abs(load_data_H23("amp_state_QGAN"))
353        h_comp= load_data_H23("full_state_QGAN")
354        psi_LPF = load_data_H23("psi_LPF_processed")  
355        comp_label="QGAN"
356        comp=True
357    else:
358        comp=False 
359
360    if comp and no_UA:
361        comp=False    
362        print("Comparison to Hayes 2023 not shown due to incompatible amplitude function.") 
363    if comp and not (psi_mode=="psi" and func_A=="x76"):
364        comp=False
365        print("Comparison to Hayes 2023 not shown due to incompatible amplitude or phase function.")    
366
367    # get PQC state
368    state_vec = full_encode(n,m, weights_ampl, weights_phase, L_A, L_phase,real_p=real_p,repeat_params=repeat_params,no_UA=no_UA)
369    phase = phase_from_state(state_vec)
370
371    ampl_vec = np.abs(state_vec)
372    real_wave =np.real(state_vec)
373    im_wave = np.imag(state_vec) 
374
375    # plot amplitude 
376    fig, ax = plt.subplots(2, 1, figsize=figsize, gridspec_kw={'height_ratios': [1.5, 1]})
377
378    ax[0].plot(x_arr,ampl_target, color="black")
379    if comp:
380        ax[0].scatter(x_arr,ampl_vec_comp,label=comp_label, color="blue")
381    ax[0].scatter(x_arr,ampl_vec,label="QCNN", color="red")
382
383    ax[0].set_ylabel(r"$\tilde A(f)$", fontsize=fontsize)
384    if comp: ax[0].legend(fontsize=fontsize, loc='upper right')
385    ax[0].tick_params(axis="both", labelsize=ticksize)
386    ax[0].set_xticks([])
387
388    if comp:
389        ax[1].scatter(x_arr,ampl_target-ampl_vec_comp,label=comp_label, color="blue")
390    ax[1].scatter(x_arr,ampl_target-ampl_vec,label="QCNN", color="red")
391
392    ax[1].set_ylabel(r"$\Delta \tilde A(f)$", fontsize=fontsize)
393    ax[1].tick_params(axis="both", labelsize=ticksize)
394    ax[1].set_xlabel(r"$f$ (Hz)", fontsize=fontsize)
395
396    fig.tight_layout()
397    fig.savefig(os.path.join(out_dir,f"amplitude{pdf_str}"), bbox_inches='tight', dpi=500)
398
399    if show:
400        plt.show()
401    plt.close() 
402
403    # plot phase 
404    fig, ax = plt.subplots(2, 1, figsize=figsize, gridspec_kw={'height_ratios': [1.5, 1]})
405
406    ax[0].plot(x_arr,phase_target, color="black")
407    ax[0].plot(x_arr,phase_rounded, color="gray", ls="--")
408    if comp:
409        ax[0].scatter(x_arr,psi_LPF,label="LPF", color="blue")
410    ax[0].scatter(x_arr,phase,label="QCNN", color="red")
411
412    ax[0].set_ylabel(r"$\Psi (f)$", fontsize=fontsize)
413    if comp: ax[0].legend(fontsize=fontsize, loc='upper right')
414    ax[0].tick_params(axis="both", labelsize=ticksize)
415    ax[0].set_xticks([])
416
417    if comp:
418        ax[1].scatter(x_arr,phase_target-psi_LPF,label="LPF + ", color="blue")
419    ax[1].scatter(x_arr,phase_rounded-phase,label="QCNN", color="red")
420
421    ax[1].set_ylabel(r"$\Delta \Psi(f)$", fontsize=fontsize)
422    ax[1].tick_params(axis="both", labelsize=ticksize)
423    ax[1].set_xlabel(r"$f$ (Hz)", fontsize=fontsize)
424
425    fig.tight_layout()
426    fig.savefig(os.path.join(out_dir,f"phase{pdf_str}"), bbox_inches='tight', dpi=500)
427
428    if show:
429        plt.show()
430    plt.close() 
431
432    # plot full waveform 
433    fig, ax = plt.subplots(2, 2, figsize=(2*figsize[0],figsize[1]), gridspec_kw={'height_ratios': [1.5, 1]})
434    fig.subplots_adjust()
435
436    ax[0,0].plot(x_arr,wave_real_target, color="black")
437    ax[0,0].plot(x_arr,wave_real_target_rounded, color="gray", ls="--")
438    if comp:
439        ax[0,0].scatter(x_arr,np.real(h_comp),label="LPF + "+comp_label, color="blue")
440    ax[0,0].scatter(x_arr,real_wave,label="QCNN", color="red")
441
442    ax[0,0].set_ylabel(r"$\Re[\tilde h(f)]$", fontsize=fontsize)
443    if comp: ax[0,0].legend(fontsize=fontsize, loc='upper right')
444    ax[0,0].tick_params(axis="both", labelsize=ticksize)
445    ax[0,0].set_xticks([])
446
447    if comp:
448        ax[1,0].scatter(x_arr,wave_real_target -np.real(h_comp),label="LPF"+comp_label, color="blue")
449    ax[1,0].scatter(x_arr,wave_real_target_rounded -real_wave,label="QCNN", color="red")
450
451    ax[1,0].set_ylabel(r"$\Delta \Re[\tilde h(f)]$", fontsize=fontsize)
452    ax[1,0].tick_params(axis="both", labelsize=ticksize)
453    ax[1,0].set_xlabel(r"$f$ (Hz)", fontsize=fontsize)
454
455    ax[0,1].plot(x_arr,wave_im_target, color="black")
456    ax[0,1].plot(x_arr,wave_im_target_rounded, color="gray", ls="--")
457    if comp:
458        ax[0,1].scatter(x_arr,np.imag(h_comp),label="LPF + "+comp_label, color="blue")
459    ax[0,1].scatter(x_arr,im_wave,label="QCNN", color="red")
460
461    ax[0,1].set_ylabel(r"$\Im[\tilde h(f)]$", fontsize=fontsize)
462    if comp: ax[0,1].legend(fontsize=fontsize, loc='upper right')
463    ax[0,1].tick_params(axis="both", labelsize=ticksize)
464    ax[0,1].set_xticks([])
465
466    if comp:
467        ax[1,1].scatter(x_arr,wave_im_target -np.imag(h_comp),label="LPF + "+comp_label, color="blue")
468    ax[1,1].scatter(x_arr,wave_im_target_rounded -im_wave,label="QCNN", color="red")
469
470    ax[1,1].set_ylabel(r"$\Delta \Im[\tilde h(f)]$", fontsize=fontsize)
471    ax[1,1].tick_params(axis="both", labelsize=ticksize)
472    ax[1,1].set_xlabel(r"$f$ (Hz)", fontsize=fontsize)
473
474    fig.tight_layout()
475    fig.savefig(os.path.join(out_dir,f"waveform{pdf_str}"), bbox_inches='tight', dpi=500)
476
477    if show:
478        plt.show()
479    plt.close()
480
481    return 0 
482
483
484def two_register_plots(name_str_phase, name_str_ampl,in_dir, out_dir, operators="QRQ",no_UA=False, show=False, pdf=False):
485    """
486    Plot the two-register statevector resulting from applying amplitude and phase preparation QCNNs. 
487
488    This function attempts to extract information about QCNN configurations from name strings which might not be successful in the general case. 
489
490    Arguments:
491    ----
492
493    - **name_str_phase** : *str* 
494
495        Name string (produced using `pqcprep.file_tools.vars_to_name_str()`) corresponding to the weights of the QCNN used for phase encoding. 
496
497    - **name_str_ampl** : *str* 
498
499        Name string (produced using `pqcprep.file_tools.vars_to_name_str_ampl()`) corresponding to the weights of the QCNN used for amplitude preparation. This is ignored if `no_UA` is True.      
500
501    - **in_dir** : *str*
502
503        Directory containing the input files (as specified by `name_str_phase` and `name_str_ampl`). The directory is expected to contain a `weights` file for both cases. 
504
505    - **out_dir** : *str*
506
507        Directory for output files. 
508
509    - **operators** : *str*, 
510
511        Which operators to apply to the registers. Options are `'QRQ'` for full phase extraction, `'RQ'` for partial phase extraction, and `'Q'` for function 
512        evaluation only. Default is `'QRQ'`.   
513
514    - **no_UA** : *boolean*
515
516        If True, a Hadamard transform is applied to the input register instead of preparing the amplitude via a PQC. Default is False.      
517    
518    - **show** : *boolean* 
519
520        If True, display plots. Default is False. 
521
522    - **pdf** : *boolean* 
523
524        If True, save plots in pdf format. Default is False. 
525
526
527    Returns:
528    ----
529
530    Plots of the amplitude and phase of the two-register state saved in the directory `out_dir`.
531    """
532    pdf_str = ".pdf" if pdf else ".png"
533
534    # read in given files 
535    weights_phase = os.path.join(in_dir, f"weights{name_str_phase}.npy") 
536    weights_ampl = os.path.join(in_dir, f"weights{name_str_ampl}.npy") 
537
538    # extract information from name strings 
539    real_p = '(r)' in name_str_phase
540    if '(CL)' in name_str_phase:
541        repeat_params="CL"
542    elif '(IL)' in name_str_phase:
543        repeat_params="IL" 
544    elif '(both)' in name_str_phase:
545        repeat_params="both"       
546    else:
547        repeat_params=None 
548
549    psi_mode=None 
550    func_A=None 
551    for i in ["psi", "linear", "quadratic", "sine"]:
552        if name_str_phase.count(i)==1:
553            psi_mode=i 
554            break 
555    if psi_mode==None:
556        raise ValueError("Name string could not be interpreted.")    
557    for i in ["x76", "linear", "uniform"]:
558        if name_str_ampl.count(i)==1:
559            func_A=i 
560            break     
561    if func_A==None:
562        raise ValueError("Name string could not be interpreted.")   
563    
564    n = name_str_ampl[1] if name_str_ampl[2]=="_" else name_str_ampl[1:3]
565    if int(n) < 10:
566        L_A= name_str_ampl[3] if name_str_ampl[4]=="_" else name_str_ampl[3:5] # this assumes nint=None 
567        m = name_str_phase[3] if (name_str_phase[4]=="_" or name_str_phase[4]=="(") else name_str_phase[3:5]
568    else: 
569        L_A= name_str_ampl[4] if name_str_ampl[5]=="_" else name_str_ampl[4:6] # this assumes nint=None 
570        m = name_str_phase[4] if (name_str_phase[5]=="_" or name_str_phase[5]=="(") else name_str_phase[4:6]   
571
572    mint=None 
573    for i in np.arange(int(m)+1):
574        if name_str_phase.count(f"({i})")==1:
575            mint=i 
576            break 
577    s = f"_{n}_{m}({mint})_"
578    if name_str_phase.count(s) != 1 :
579        raise ValueError("Name string could not be interpreted.")   
580    else:
581        L_phase = name_str_phase[len(s)] if name_str_phase[len(s)+1]=="_" else name_str_phase[len(s)+2]
582    s = f"_{n}_{m}({mint})_{L_phase}_"
583    if name_str_phase.count(s) != 1 :
584        raise ValueError("Name string could not be interpreted.")
585
586    n= int(n)
587    m=int(m)
588    L_phase=int(L_phase)
589    L_A=int(L_A)
590    mint=int(mint)    
591
592    # generate x array 
593    x_arr = x_trans_arr(n)
594
595    # get PQC state
596    state_vec, state_vec_full = full_encode(n,m, weights_ampl, weights_phase, L_A, L_phase,real_p=real_p,repeat_params=repeat_params,no_UA=no_UA, full_state_vec=True, operators=operators)
597    phase = phase_from_state(state_vec)
598    full_phase = phase_from_state(state_vec_full)
599    
600    # plot amplitude 
601    fig, ax = plt.subplots(2, 1, figsize=figsize, gridspec_kw={'height_ratios': [2**m, 1]},constrained_layout=True)
602    ax[0].scatter(x_arr,phase,label="QCNN", color="red")
603
604    ax[0].set_ylabel(r"$\tilde{\Psi}(f)$", fontsize=fontsize)
605    ax[0].tick_params(axis="both", labelsize=ticksize)
606    im=ax[0].pcolormesh(x_arr,np.arange(2**m), np.abs(state_vec_full))
607    im.set_clim(np.min(np.abs(state_vec_full)),np.max(np.abs(state_vec_full)))
608    locs = ax[0].get_yticks() 
609    ax[0].set_yticks(locs[1:-1], [np.round(bin_to_dec(dec_to_bin(i,m),nint=0)*2*np.pi,2) for i in np.arange(len(locs)-2)])
610    ax[0].set_xlabel(r"$f$ (Hz)", fontsize=fontsize)
611    ax[1].set_visible(False)    
612        
613    cb=fig.colorbar(im,ax=ax.ravel().tolist(), location='top', orientation='horizontal', pad=0.05)
614    cb.ax.tick_params(labelsize=ticksize)
615    
616    fig.savefig(os.path.join(out_dir,f"two_reg_ampl{pdf_str}"), bbox_inches='tight', dpi=500)
617
618    if show:
619        plt.show()
620    plt.close()    
621
622    # plot phase 
623    fig, ax = plt.subplots(2, 1, figsize=figsize, gridspec_kw={'height_ratios': [2**m, 1]},constrained_layout=True)
624    ax[0].scatter(x_arr,phase,label="QCNN", color="red")
625
626    ax[0].set_ylabel(r"$\tilde{\Psi}(f)$", fontsize=fontsize)
627    ax[0].tick_params(axis="both", labelsize=ticksize)
628    im=ax[0].pcolormesh(x_arr,np.arange(2**m), full_phase, cmap="hsv")
629    im.set_clim(0, 2*np.pi)
630    locs = ax[0].get_yticks() 
631    ax[0].set_yticks(locs[1:-1], [np.round(bin_to_dec(dec_to_bin(i,m),nint=0)*2*np.pi,2) for i in np.arange(len(locs)-2)])
632    ax[0].set_xlabel(r"$f$ (Hz)", fontsize=fontsize)
633    ax[1].set_visible(False)    
634    
635    cb=fig.colorbar(im,ax=ax.ravel().tolist(), location='top', orientation='horizontal', pad=0.05)
636    cb.ax.tick_params(labelsize=ticksize)
637   
638    fig.savefig(os.path.join(out_dir,f"two_reg_phase{pdf_str}"), bbox_inches='tight', dpi=500)
639     
640    if show:
641        plt.show()
642    plt.close()    
643
644    # plot amplitude and phase  
645    X = x_arr
646    Y = np.arange(2**m)
647    X, Y = np.meshgrid(X, Y)
648    Z = np.abs(state_vec_full)
649    P_norm = (full_phase) / (2* np.pi)  # normalise to value in [0,1]
650
651    # Plot the surface
652    fig, ax = plt.subplots(figsize=(10,10), subplot_kw={"projection": "3d"}, constrained_layout=False)
653    surf = ax.plot_surface(X, Y, Z,facecolors=cm.hsv(P_norm),linewidth=0, antialiased=True, shade=False)
654    ax.set_xlabel(r"$f$ (Hz)", fontsize=fontsize, labelpad=20)
655    ax.set_ylabel(r"$\tilde{\Psi}(f)$", fontsize=fontsize, labelpad=20)
656    locs = ax.get_yticks() 
657    ax.set_yticks(locs[1:-1], [np.round(bin_to_dec(dec_to_bin(i,m),nint=0)*2*np.pi,2) for i in np.arange(len(locs)-2)])
658    ax.tick_params(axis="both", labelsize=ticksize)
659
660    cb=fig.colorbar(cm.ScalarMappable(cmap=cm.hsv, norm=surf.norm), ax = ax , shrink = 0.6, aspect = 5)
661    cb.ax.tick_params(labelsize=ticksize)
662    locs = cb.ax.get_yticks()
663    cb.ax.set_yticks( [0, 0.25,0.5,0.75,1], [r'$0$',r'$\frac{\pi}{2}$', r'$\pi$',r'$\frac{3\pi}{2}$' , r'$2\pi$'])
664    
665    fig.savefig(os.path.join(out_dir,f"two_reg_3D{pdf_str}"), bbox_inches='tight', dpi=500)
666
667    if show:
668        plt.show()
669    plt.close()   
670
671    return 0