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)