def compute_jacobian_realization(fr_module, num_samples, signal_dim, num_freq, min_sep, fixed_freq, snr): clean_signals, signal_frs, signal_num_freqs = gen_signal( num_samples=num_samples, signal_dim=signal_dim, num_freq=num_freq, min_sep=min_sep, fixed_freq=fixed_freq) noisy_signals = noise_torch(torch.as_tensor(clean_signals), snr, 'gaussian') jacobian_realization = [] jacobian_realization_clean = [] for idx in range(clean_signals.shape[0]): clean_signal, signal_fr, signal_num_freq = clean_signals[ idx], signal_frs[idx], signal_num_freqs[idx] noisy_signal = noisy_signals[idx].cpu().numpy() clean_signal_t = clean_signal[0] + clean_signal[1] * 1j clean_signal_fft = np.fft.fft(clean_signal_t, n=1000) clean_signal_fft = np.fft.fftshift(clean_signal_fft) noisy_signal_t = noisy_signal[0] + 1j * noisy_signal[1] noisy_signal_fft = np.fft.fft(noisy_signal_t, n=1000) noisy_signal_fft = np.fft.fftshift(noisy_signal_fft) noisy_signal = torch.as_tensor(noisy_signal).unsqueeze(dim=0) jacobian, inputs, outputs = compute_jacobian_and_bias( noisy_signal, fr_module) clean_signal = torch.as_tensor(clean_signal).unsqueeze(dim=0) jacobian_clean, inputs, outputs = compute_jacobian_and_bias( clean_signal, fr_module) jacobian_realization.append(jacobian) jacobian_realization_clean.append(jacobian_clean) return jacobian_realization, jacobian_realization_clean
def load_dataloader(num_samples, signal_dim, max_n_freq, min_sep, distance, amplitude, floor_amplitude, kernel_type, kernel_param, batch_size, xgrid, snrl, snrh): num_samples *= (snrh - snrl + 1) print('Training samples per snr:', num_samples) clean_signals, f, nfreq = data.gen_signal(num_samples, signal_dim, max_n_freq, min_sep, distance=distance, amplitude=amplitude, floor_amplitude=floor_amplitude, variable_num_freq=True) frequency_representation = fr.freq2fr(f, xgrid, kernel_type, kernel_param) clean_signals = torch.from_numpy(clean_signals).float() f = torch.from_numpy(f).float() frequency_representation = torch.from_numpy( frequency_representation).float() dataset = data_utils.TensorDataset(clean_signals, frequency_representation, f) print('data dimension', clean_signals.shape, frequency_representation.shape, f.shape) return data_utils.DataLoader(dataset, batch_size=batch_size, shuffle=True)
def load_dataloader(num_samples, signal_dim, max_n_freq, min_sep, distance, amplitude, floor_amplitude, kernel_type, kernel_param, batch_size, xgrid): clean_signals, f, nfreq = data.gen_signal(num_samples, signal_dim, max_n_freq, min_sep, distance=distance, amplitude=amplitude, floor_amplitude=floor_amplitude, variable_num_freq=True) frequency_representation = fr.freq2fr(f, xgrid, kernel_type, kernel_param) clean_signals = torch.from_numpy(clean_signals).float() f = torch.from_numpy(f).float() frequency_representation = torch.from_numpy( frequency_representation).float() dataset = data_utils.TensorDataset(clean_signals, frequency_representation, f) return data_utils.DataLoader(dataset, batch_size=batch_size, shuffle=True)
def load_dataloader_fixed_noise(num_samples, signal_dim, max_n_freq, min_sep, distance, amplitude, floor_amplitude, kernel_type, kernel_param, batch_size, xgrid, snrl, snrh, noise): print('Training samples per snr:', num_samples) clean_signals_snr = [] frequency_representation_snr = [] noisy_signals_snr = [] f_snr = [] for i in range(snrl, snrh + 1): clean_signals, f, nfreq = data.gen_signal( num_samples, signal_dim, max_n_freq, min_sep, distance=distance, amplitude=amplitude, floor_amplitude=floor_amplitude, variable_num_freq=True) frequency_representation = fr.freq2fr(f, xgrid, kernel_type, kernel_param) clean_signals = torch.from_numpy(clean_signals).float() f = torch.from_numpy(f).float() frequency_representation = torch.from_numpy( frequency_representation).float() noisy_signals = noise_torch(clean_signals, i, noise) clean_signals_snr.append(clean_signals) frequency_representation_snr.append(frequency_representation) noisy_signals_snr.append(noisy_signals) f_snr.append(f) clean_signals_snr = torch.cat(clean_signals_snr, dim=0) noisy_signals_snr = torch.cat(noisy_signals_snr, dim=0) frequency_representation_snr = torch.cat(frequency_representation_snr, dim=0) f_snr = torch.cat(f_snr, dim=0) print('data dimension', clean_signals_snr.shape, noisy_signals_snr.shape, frequency_representation_snr.shape, f_snr.shape) dataset = data_utils.TensorDataset(noisy_signals_snr, clean_signals_snr, frequency_representation_snr, f_snr) return data_utils.DataLoader(dataset, batch_size=batch_size)
def generate_report_plots(num_samples=2, signal_dim=50, min_sep=1., snr=30, fixed_freq=[0.4], save=False): if not os.path.exists('./plots'): os.mkdir('./plots') save_dir = './plots' num_freq = len(fixed_freq) for signal_idx in range(num_samples): clean_signals, signal_frs, signal_num_freqs = gen_signal( num_samples=num_samples, signal_dim=signal_dim, num_freq=num_freq, min_sep=min_sep, fixed_freq=fixed_freq) noisy_signals = noise_torch(torch.as_tensor(clean_signals), snr, 'gaussian') clean_signal, signal_fr, signal_num_freq = clean_signals[ signal_idx], signal_frs[signal_idx], signal_num_freqs[signal_idx] noisy_signal = noisy_signals[signal_idx].cpu().numpy() clean_signal_t = clean_signal[0] + clean_signal[1] * 1j clean_signal_fft = np.fft.fft(clean_signal_t, n=1000) clean_signal_fft = np.fft.fftshift(clean_signal_fft) noisy_signal_t = noisy_signal[0] + 1j * noisy_signal[1] noisy_signal_fft = np.fft.fft(noisy_signal_t, n=1000) noisy_signal_fft = np.fft.fftshift(noisy_signal_fft) if signal_idx == 0: # plot clean first noisy_signal = torch.as_tensor(clean_signal).unsqueeze(dim=0) else: noisy_signal = torch.as_tensor(noisy_signal).unsqueeze(dim=0) jacobian, inputs, outputs = compute_jacobian_and_bias( noisy_signal, fr_module) fft_filter = jacobian[0] - 1j * jacobian[1] # plot 1 fig1, ax = plt.subplots(3, 1, figsize=(15, 6)) xgrid = np.linspace(-0.5, 0.5, fr_module.fr_size, endpoint=False) ax[0].plot(xgrid, outputs[0]) ax[0].set_xticks(np.arange(-0.5, 0.5, 0.2)) ylim = ax[0].get_ylim() for i in range(signal_fr.shape[0]): ax[0].vlines(signal_fr[i], ymin=ylim[0], ymax=ylim[1], label='target:{:4.2f}'.format(signal_fr[i])) ax[0].legend() ax[0].set_xlim(-0.5, 0.5) ax[1].plot(xgrid, np.abs(clean_signal_fft), label='clean fft') ax[1].plot(xgrid, np.abs(noisy_signal_fft), '--', label='noisy fft') ax[1].set_xlim(-0.5, 0.5) ylim = ax[1].get_ylim() for i in range(signal_fr.shape[0]): ax[1].vlines(signal_fr[i], ymin=ylim[0], ymax=ylim[1], label='target:{:4.2f}'.format(signal_fr[i])) ax[1].legend() im = ax[2].imshow(np.abs(fft_filter)) ax[2].set_aspect(2.2) ax[2].set_ylabel('jacobian', fontsize=13) fig1.subplots_adjust(right=0.9) cbar_ax = fig1.add_axes([0.91, 0.15, 0.01, 0.7]) fig1.colorbar(im, cax=cbar_ax) plt.show() # plot 2 fig2, ax = plt.subplots(3, 1, figsize=(15, 6)) xgrid = np.linspace(-0.5, 0.5, fr_module.fr_size, endpoint=False) ax[0].plot(xgrid, outputs[0]) ax[0].set_xticks(np.arange(-0.5, 0.5, 0.2)) ylim = ax[0].get_ylim() for i in range(signal_fr.shape[0]): ax[0].vlines(signal_fr[i], ymin=ylim[0], ymax=ylim[1], label='target:{:4.2f}'.format(signal_fr[i])) ax[0].legend() ax[1].plot(xgrid, np.abs(clean_signal_fft), label='clean fft') ax[1].plot(xgrid, np.abs(noisy_signal_fft), '--', label='noisy fft') ylim = ax[1].get_ylim() for i in range(signal_fr.shape[0]): ax[1].vlines(signal_fr[i], ymin=ylim[0], ymax=ylim[1], label='target:{:4.2f}'.format(signal_fr[i])) ax[1].legend() fft_filter_norm = fft_filter * np.conjugate(fft_filter) fft_filter_norm = fft_filter_norm.T.sum(axis=1).real ax[2].plot(xgrid, fft_filter_norm) ax[0].set_xlim(-0.5, 0.5) ax[1].set_xlim(-0.5, 0.5) ax[2].set_xlim(-0.5, 0.5) fig2.subplots_adjust(right=0.9) plt.show() # plot. 3 indices = find_neariest_idx(signal_fr, xgrid) target_filter = fft_filter.T[indices] # time domain fig3, ax = plt.subplots(target_filter.shape[0], 2) for idx, filt in enumerate(target_filter): if target_filter.shape[0] > 1: ax[idx, 0].plot(filt.real) ax[idx, 1].plot(filt.imag) ax[idx, 0].set_title('Real Part of Freq:{:4.2f};'.format( signal_fr[idx])) ax[idx, 1].set_title('Complex Part of Freq:{:4.2f};'.format( signal_fr[idx])) else: ax[0].plot(filt.real) ax[1].plot(filt.imag) ax[0].set_title('Real Part of Freq:{:4.2f};'.format( signal_fr[idx])) ax[1].set_title('Complex Part of Freq:{:4.2f};'.format( signal_fr[idx])) plt.tight_layout() plt.show() # fft domian of signals fig4, ax = plt.subplots(target_filter.shape[0], 1, dpi=300) for idx, filt in enumerate(target_filter): filt_fft = np.fft.fft(filt, n=1000) filt_fft = np.fft.fftshift(filt_fft) magnitude = np.abs(filt_fft) if target_filter.shape[0] > 1: ax[idx].plot(xgrid, magnitude) ax[idx].plot(signal_fr[idx], magnitude[indices[idx]], '*') ax[idx].plot(-signal_fr[idx], magnitude[999 - indices[idx]], '*') ax[idx].set_title('Freq:{:4.2f}'.format(signal_fr[idx])) else: ax.plot(xgrid, magnitude) ax.plot(signal_fr[idx], magnitude[indices[idx]], '*') ax.plot(-signal_fr[idx], magnitude[999 - indices[idx]], '*') ax.set_title('Freq:{:4.2f}'.format(signal_fr[idx])) plt.tight_layout() plt.show() if save: file_name = 'output_clean_{}.pdf' if signal_idx == 0 else 'output_{}.pdf' pdf = matplotlib.backends.backend_pdf.PdfPages( "./plots/" + file_name.format(signal_idx)) pdf.savefig(fig1) pdf.savefig(fig2) pdf.savefig(fig3) pdf.savefig(fig4) pdf.close()
raise ValueError( "Output directory ({}) already exists and is not empty. Use --overwrite to overcome." .format(args.output_dir)) elif not os.path.exists(args.output_dir): os.makedirs(args.output_dir) with open(os.path.join(args.output_dir, 'data.args'), 'w') as f: json.dump(args.__dict__, f, indent=2) np.random.seed(args.numpy_seed) torch.manual_seed(args.torch_seed) s, f, nfreq = gen_signal(num_samples=args.n_test, signal_dim=args.signal_dimension, num_freq=args.max_freq, min_sep=args.minimum_separation, distance=args.distance, amplitude=args.amplitude, floor_amplitude=args.floor_amplitude, variable_num_freq=True) np.save(os.path.join(args.output_dir, 'infdB'), s) np.save(os.path.join(args.output_dir, 'f'), f) eval_snrs = [np.exp(np.log(10) * float(x) / 10) for x in args.dB] for k, snr in enumerate(eval_snrs): noisy_signals = noise.noise_torch(torch.tensor(s), snr, 'gaussian').cpu() np.save( os.path.join(args.output_dir, '{}dB'.format(float(args.dB[k]))), noisy_signals)